lang
stringclasses 1
value | prompt
stringlengths 1.38k
11.3k
| eval_prompt
stringlengths 37
8.09k
| ground_truth
stringlengths 1
328
| unit_tests
stringclasses 145
values | task_id
stringlengths 23
25
| split
stringclasses 2
values |
|---|---|---|---|---|---|---|
python
|
Complete the code in python to solve this programming problem:
Description: During their training for the ICPC competitions, team "Jee You See" stumbled upon a very basic counting problem. After many "Wrong answer" verdicts, they finally decided to give up and destroy turn-off the PC. Now they want your help in up-solving the problem.You are given 4 integers $$$n$$$, $$$l$$$, $$$r$$$, and $$$z$$$. Count the number of arrays $$$a$$$ of length $$$n$$$ containing non-negative integers such that: $$$l\le a_1+a_2+\ldots+a_n\le r$$$, and $$$a_1\oplus a_2 \oplus \ldots\oplus a_n=z$$$, where $$$\oplus$$$ denotes the bitwise XOR operation. Since the answer can be large, print it modulo $$$10^9+7$$$.
Input Specification: The only line contains four integers $$$n$$$, $$$l$$$, $$$r$$$, $$$z$$$ ($$$1 \le n \le 1000$$$, $$$1\le l\le r\le 10^{18}$$$, $$$1\le z\le 10^{18}$$$).
Output Specification: Print the number of arrays $$$a$$$ satisfying all requirements modulo $$$10^9+7$$$.
Notes: NoteThe following arrays satisfy the conditions for the first sample: $$$[1, 0, 0]$$$; $$$[0, 1, 0]$$$; $$$[3, 2, 0]$$$; $$$[2, 3, 0]$$$; $$$[0, 0, 1]$$$; $$$[1, 1, 1]$$$; $$$[2, 2, 1]$$$; $$$[3, 0, 2]$$$; $$$[2, 1, 2]$$$; $$$[1, 2, 2]$$$; $$$[0, 3, 2]$$$; $$$[2, 0, 3]$$$; $$$[0, 2, 3]$$$. The following arrays satisfy the conditions for the second sample: $$$[2, 0, 0, 0]$$$; $$$[0, 2, 0, 0]$$$; $$$[0, 0, 2, 0]$$$; $$$[0, 0, 0, 2]$$$.
Code:
import sys
input = sys.stdin.readline
MOD = 10 ** 9 + 7
N = 10000
fact = [0 for _ in range(N)]
invfact = [0 for _ in range(N)]
fact[0] = 1
for i in range(1, N):
fact[i] = fact[i - 1] * i % MOD
invfact[N - 1] = pow(fact[N - 1], MOD - 2, MOD)
for i in range(N - 2, -1, -1):
invfact[i] = invfact[i + 1] * (i + 1) % MOD
def nCk(n, k):
if k < 0 or n < k:
return 0
else:
return (fact[n] * invfact[k] % MOD) * invfact[n - k] % MOD
def nHk(n, k):
return nCk(n + k - 1, k)
def main():
n, l, r, z = map(int, input().split())
bit = [0] * 60
for i in range(60):
if z >> i & 1:
bit[i] = 1
r -= 1 << i
l -= 1 << i
if r < 0:
print(0)
return
ma = [0] * 60
for i in range(60):
if n % 2 == bit[i]:
nn = n
else:
nn = n - 1
ma[i] = (1 << (i + 1)) * nn
if i != 0:
ma[i] += ma[i - 1]
tot = [0] * 60
for i in range(60):
for j in range(bit[i], n + 1, 2):
tot[i] += nCk(n, j)
tot[i] %= MOD
if i != 0:
tot[i] *= tot[i - 1]
tot[i] %= MOD
memo = {}
d = r - l
bi = [1 << i for i in range(61)]
def solve(i, l):
r = l + d
if l <= 0 and ma[i] <= r:
return tot[i]
elif ma[i] < l:
return 0
elif i == -1:
return l <= 0
elif i + 60 * l in memo:
return memo[i + 60 * l]
ret = 0
mi = bi[i + 1]
ll = l
rr = r
for j in range(bit[i], n + 1, 2):
ret += solve(i - 1, ll) * nCk(n, j) % MOD
if ret >= MOD: # TODO: Your code here
ll -= mi
rr -= mi
if rr < 0:
break
memo[i + 60 * l] = ret
return ret
ans = solve(59, l)
print(ans)
for _ in range(1):
main()
|
import sys
input = sys.stdin.readline
MOD = 10 ** 9 + 7
N = 10000
fact = [0 for _ in range(N)]
invfact = [0 for _ in range(N)]
fact[0] = 1
for i in range(1, N):
fact[i] = fact[i - 1] * i % MOD
invfact[N - 1] = pow(fact[N - 1], MOD - 2, MOD)
for i in range(N - 2, -1, -1):
invfact[i] = invfact[i + 1] * (i + 1) % MOD
def nCk(n, k):
if k < 0 or n < k:
return 0
else:
return (fact[n] * invfact[k] % MOD) * invfact[n - k] % MOD
def nHk(n, k):
return nCk(n + k - 1, k)
def main():
n, l, r, z = map(int, input().split())
bit = [0] * 60
for i in range(60):
if z >> i & 1:
bit[i] = 1
r -= 1 << i
l -= 1 << i
if r < 0:
print(0)
return
ma = [0] * 60
for i in range(60):
if n % 2 == bit[i]:
nn = n
else:
nn = n - 1
ma[i] = (1 << (i + 1)) * nn
if i != 0:
ma[i] += ma[i - 1]
tot = [0] * 60
for i in range(60):
for j in range(bit[i], n + 1, 2):
tot[i] += nCk(n, j)
tot[i] %= MOD
if i != 0:
tot[i] *= tot[i - 1]
tot[i] %= MOD
memo = {}
d = r - l
bi = [1 << i for i in range(61)]
def solve(i, l):
r = l + d
if l <= 0 and ma[i] <= r:
return tot[i]
elif ma[i] < l:
return 0
elif i == -1:
return l <= 0
elif i + 60 * l in memo:
return memo[i + 60 * l]
ret = 0
mi = bi[i + 1]
ll = l
rr = r
for j in range(bit[i], n + 1, 2):
ret += solve(i - 1, ll) * nCk(n, j) % MOD
if ret >= MOD: {{completion}}
ll -= mi
rr -= mi
if rr < 0:
break
memo[i + 60 * l] = ret
return ret
ans = solve(59, l)
print(ans)
for _ in range(1):
main()
|
ret -= MOD
|
[{"input": "3 1 5 1", "output": ["13"]}, {"input": "4 1 3 2", "output": ["4"]}, {"input": "2 1 100000 15629", "output": ["49152"]}, {"input": "100 56 89 66", "output": ["981727503"]}]
|
block_completion_006065
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: During their training for the ICPC competitions, team "Jee You See" stumbled upon a very basic counting problem. After many "Wrong answer" verdicts, they finally decided to give up and destroy turn-off the PC. Now they want your help in up-solving the problem.You are given 4 integers $$$n$$$, $$$l$$$, $$$r$$$, and $$$z$$$. Count the number of arrays $$$a$$$ of length $$$n$$$ containing non-negative integers such that: $$$l\le a_1+a_2+\ldots+a_n\le r$$$, and $$$a_1\oplus a_2 \oplus \ldots\oplus a_n=z$$$, where $$$\oplus$$$ denotes the bitwise XOR operation. Since the answer can be large, print it modulo $$$10^9+7$$$.
Input Specification: The only line contains four integers $$$n$$$, $$$l$$$, $$$r$$$, $$$z$$$ ($$$1 \le n \le 1000$$$, $$$1\le l\le r\le 10^{18}$$$, $$$1\le z\le 10^{18}$$$).
Output Specification: Print the number of arrays $$$a$$$ satisfying all requirements modulo $$$10^9+7$$$.
Notes: NoteThe following arrays satisfy the conditions for the first sample: $$$[1, 0, 0]$$$; $$$[0, 1, 0]$$$; $$$[3, 2, 0]$$$; $$$[2, 3, 0]$$$; $$$[0, 0, 1]$$$; $$$[1, 1, 1]$$$; $$$[2, 2, 1]$$$; $$$[3, 0, 2]$$$; $$$[2, 1, 2]$$$; $$$[1, 2, 2]$$$; $$$[0, 3, 2]$$$; $$$[2, 0, 3]$$$; $$$[0, 2, 3]$$$. The following arrays satisfy the conditions for the second sample: $$$[2, 0, 0, 0]$$$; $$$[0, 2, 0, 0]$$$; $$$[0, 0, 2, 0]$$$; $$$[0, 0, 0, 2]$$$.
Code:
import sys
input = sys.stdin.readline
MOD = 10 ** 9 + 7
N = 10000
fact = [0 for _ in range(N)]
invfact = [0 for _ in range(N)]
fact[0] = 1
for i in range(1, N):
fact[i] = fact[i - 1] * i % MOD
invfact[N - 1] = pow(fact[N - 1], MOD - 2, MOD)
for i in range(N - 2, -1, -1):
invfact[i] = invfact[i + 1] * (i + 1) % MOD
def nCk(n, k):
if k < 0 or n < k:
return 0
else:
return (fact[n] * invfact[k] % MOD) * invfact[n - k] % MOD
def nHk(n, k):
return nCk(n + k - 1, k)
def main():
n, l, r, z = map(int, input().split())
bit = [0] * 60
for i in range(60):
if z >> i & 1:
bit[i] = 1
r -= 1 << i
l -= 1 << i
if r < 0:
print(0)
return
ma = [0] * 60
for i in range(60):
if n % 2 == bit[i]:
nn = n
else:
nn = n - 1
ma[i] = (1 << (i + 1)) * nn
if i != 0:
ma[i] += ma[i - 1]
tot = [0] * 60
for i in range(60):
for j in range(bit[i], n + 1, 2):
tot[i] += nCk(n, j)
tot[i] %= MOD
if i != 0:
tot[i] *= tot[i - 1]
tot[i] %= MOD
memo = {}
d = r - l
bi = [1 << i for i in range(61)]
def solve(i, l):
r = l + d
if l <= 0 and ma[i] <= r:
return tot[i]
elif ma[i] < l:
return 0
elif i == -1:
return l <= 0
elif i + 60 * l in memo:
return memo[i + 60 * l]
ret = 0
mi = bi[i + 1]
ll = l
rr = r
for j in range(bit[i], n + 1, 2):
ret += solve(i - 1, ll) * nCk(n, j) % MOD
if ret >= MOD: ret -= MOD
ll -= mi
rr -= mi
if rr < 0:
# TODO: Your code here
memo[i + 60 * l] = ret
return ret
ans = solve(59, l)
print(ans)
for _ in range(1):
main()
|
import sys
input = sys.stdin.readline
MOD = 10 ** 9 + 7
N = 10000
fact = [0 for _ in range(N)]
invfact = [0 for _ in range(N)]
fact[0] = 1
for i in range(1, N):
fact[i] = fact[i - 1] * i % MOD
invfact[N - 1] = pow(fact[N - 1], MOD - 2, MOD)
for i in range(N - 2, -1, -1):
invfact[i] = invfact[i + 1] * (i + 1) % MOD
def nCk(n, k):
if k < 0 or n < k:
return 0
else:
return (fact[n] * invfact[k] % MOD) * invfact[n - k] % MOD
def nHk(n, k):
return nCk(n + k - 1, k)
def main():
n, l, r, z = map(int, input().split())
bit = [0] * 60
for i in range(60):
if z >> i & 1:
bit[i] = 1
r -= 1 << i
l -= 1 << i
if r < 0:
print(0)
return
ma = [0] * 60
for i in range(60):
if n % 2 == bit[i]:
nn = n
else:
nn = n - 1
ma[i] = (1 << (i + 1)) * nn
if i != 0:
ma[i] += ma[i - 1]
tot = [0] * 60
for i in range(60):
for j in range(bit[i], n + 1, 2):
tot[i] += nCk(n, j)
tot[i] %= MOD
if i != 0:
tot[i] *= tot[i - 1]
tot[i] %= MOD
memo = {}
d = r - l
bi = [1 << i for i in range(61)]
def solve(i, l):
r = l + d
if l <= 0 and ma[i] <= r:
return tot[i]
elif ma[i] < l:
return 0
elif i == -1:
return l <= 0
elif i + 60 * l in memo:
return memo[i + 60 * l]
ret = 0
mi = bi[i + 1]
ll = l
rr = r
for j in range(bit[i], n + 1, 2):
ret += solve(i - 1, ll) * nCk(n, j) % MOD
if ret >= MOD: ret -= MOD
ll -= mi
rr -= mi
if rr < 0:
{{completion}}
memo[i + 60 * l] = ret
return ret
ans = solve(59, l)
print(ans)
for _ in range(1):
main()
|
break
|
[{"input": "3 1 5 1", "output": ["13"]}, {"input": "4 1 3 2", "output": ["4"]}, {"input": "2 1 100000 15629", "output": ["49152"]}, {"input": "100 56 89 66", "output": ["981727503"]}]
|
block_completion_006066
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given an integer $$$x$$$ and an array of integers $$$a_1, a_2, \ldots, a_n$$$. You have to determine if the number $$$a_1! + a_2! + \ldots + a_n!$$$ is divisible by $$$x!$$$.Here $$$k!$$$ is a factorial of $$$k$$$ — the product of all positive integers less than or equal to $$$k$$$. For example, $$$3! = 1 \cdot 2 \cdot 3 = 6$$$, and $$$5! = 1 \cdot 2 \cdot 3 \cdot 4 \cdot 5 = 120$$$.
Input Specification: The first line contains two integers $$$n$$$ and $$$x$$$ ($$$1 \le n \le 500\,000$$$, $$$1 \le x \le 500\,000$$$). The second line contains $$$n$$$ integers $$$a_1, a_2, \ldots, a_n$$$ ($$$1 \le a_i \le x$$$) — elements of given array.
Output Specification: In the only line print "Yes" (without quotes) if $$$a_1! + a_2! + \ldots + a_n!$$$ is divisible by $$$x!$$$, and "No" (without quotes) otherwise.
Notes: NoteIn the first example $$$3! + 2! + 2! + 2! + 3! + 3! = 6 + 2 + 2 + 2 + 6 + 6 = 24$$$. Number $$$24$$$ is divisible by $$$4! = 24$$$.In the second example $$$3! + 2! + 2! + 2! + 2! + 2! + 1! + 1! = 18$$$, is divisible by $$$3! = 6$$$.In the third example $$$7! + 7! + 7! + 7! + 7! + 7! + 7! = 7 \cdot 7!$$$. It is easy to prove that this number is not divisible by $$$8!$$$.
Code:
a,b=map(int,input().split())
arr=[0]*500001
for i in map(int,input().split()):
arr[i]+=1
for i in range(1,500000):
arr[i+1]+=arr[i]//(i+1)
arr[i]%=i+1
if sum(arr[:b])==0:
print('Yes')
else:
# TODO: Your code here
|
a,b=map(int,input().split())
arr=[0]*500001
for i in map(int,input().split()):
arr[i]+=1
for i in range(1,500000):
arr[i+1]+=arr[i]//(i+1)
arr[i]%=i+1
if sum(arr[:b])==0:
print('Yes')
else:
{{completion}}
|
print('No')
|
[{"input": "6 4\n3 2 2 2 3 3", "output": ["Yes"]}, {"input": "8 3\n3 2 2 2 2 2 1 1", "output": ["Yes"]}, {"input": "7 8\n7 7 7 7 7 7 7", "output": ["No"]}, {"input": "10 5\n4 3 2 1 4 3 2 4 3 4", "output": ["No"]}, {"input": "2 500000\n499999 499999", "output": ["No"]}]
|
block_completion_006086
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given an integer $$$x$$$ and an array of integers $$$a_1, a_2, \ldots, a_n$$$. You have to determine if the number $$$a_1! + a_2! + \ldots + a_n!$$$ is divisible by $$$x!$$$.Here $$$k!$$$ is a factorial of $$$k$$$ — the product of all positive integers less than or equal to $$$k$$$. For example, $$$3! = 1 \cdot 2 \cdot 3 = 6$$$, and $$$5! = 1 \cdot 2 \cdot 3 \cdot 4 \cdot 5 = 120$$$.
Input Specification: The first line contains two integers $$$n$$$ and $$$x$$$ ($$$1 \le n \le 500\,000$$$, $$$1 \le x \le 500\,000$$$). The second line contains $$$n$$$ integers $$$a_1, a_2, \ldots, a_n$$$ ($$$1 \le a_i \le x$$$) — elements of given array.
Output Specification: In the only line print "Yes" (without quotes) if $$$a_1! + a_2! + \ldots + a_n!$$$ is divisible by $$$x!$$$, and "No" (without quotes) otherwise.
Notes: NoteIn the first example $$$3! + 2! + 2! + 2! + 3! + 3! = 6 + 2 + 2 + 2 + 6 + 6 = 24$$$. Number $$$24$$$ is divisible by $$$4! = 24$$$.In the second example $$$3! + 2! + 2! + 2! + 2! + 2! + 1! + 1! = 18$$$, is divisible by $$$3! = 6$$$.In the third example $$$7! + 7! + 7! + 7! + 7! + 7! + 7! = 7 \cdot 7!$$$. It is easy to prove that this number is not divisible by $$$8!$$$.
Code:
import sys
from collections import Counter
input = sys.stdin.readline
n, x = map(int, input().split())
a = list(map(int, input().split()))
cnt = Counter(a)
rest, base = 0, 1
for t in range(x, 0, -1):
if t in cnt:
# TODO: Your code here
rest %= base
rest *= t
base *= t
if n == 0 or base - rest > n * t:
break
print('Yes' if n == 0 and rest % base == 0 else 'No')
|
import sys
from collections import Counter
input = sys.stdin.readline
n, x = map(int, input().split())
a = list(map(int, input().split()))
cnt = Counter(a)
rest, base = 0, 1
for t in range(x, 0, -1):
if t in cnt:
{{completion}}
rest %= base
rest *= t
base *= t
if n == 0 or base - rest > n * t:
break
print('Yes' if n == 0 and rest % base == 0 else 'No')
|
n -= cnt[t]
rest += cnt[t] % base
|
[{"input": "6 4\n3 2 2 2 3 3", "output": ["Yes"]}, {"input": "8 3\n3 2 2 2 2 2 1 1", "output": ["Yes"]}, {"input": "7 8\n7 7 7 7 7 7 7", "output": ["No"]}, {"input": "10 5\n4 3 2 1 4 3 2 4 3 4", "output": ["No"]}, {"input": "2 500000\n499999 499999", "output": ["No"]}]
|
block_completion_006087
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given an integer $$$x$$$ and an array of integers $$$a_1, a_2, \ldots, a_n$$$. You have to determine if the number $$$a_1! + a_2! + \ldots + a_n!$$$ is divisible by $$$x!$$$.Here $$$k!$$$ is a factorial of $$$k$$$ — the product of all positive integers less than or equal to $$$k$$$. For example, $$$3! = 1 \cdot 2 \cdot 3 = 6$$$, and $$$5! = 1 \cdot 2 \cdot 3 \cdot 4 \cdot 5 = 120$$$.
Input Specification: The first line contains two integers $$$n$$$ and $$$x$$$ ($$$1 \le n \le 500\,000$$$, $$$1 \le x \le 500\,000$$$). The second line contains $$$n$$$ integers $$$a_1, a_2, \ldots, a_n$$$ ($$$1 \le a_i \le x$$$) — elements of given array.
Output Specification: In the only line print "Yes" (without quotes) if $$$a_1! + a_2! + \ldots + a_n!$$$ is divisible by $$$x!$$$, and "No" (without quotes) otherwise.
Notes: NoteIn the first example $$$3! + 2! + 2! + 2! + 3! + 3! = 6 + 2 + 2 + 2 + 6 + 6 = 24$$$. Number $$$24$$$ is divisible by $$$4! = 24$$$.In the second example $$$3! + 2! + 2! + 2! + 2! + 2! + 1! + 1! = 18$$$, is divisible by $$$3! = 6$$$.In the third example $$$7! + 7! + 7! + 7! + 7! + 7! + 7! = 7 \cdot 7!$$$. It is easy to prove that this number is not divisible by $$$8!$$$.
Code:
import sys
from collections import Counter
input = sys.stdin.readline
n, x = map(int, input().split())
a = list(map(int, input().split()))
cnt = Counter(a)
rest, base = 0, 1
for t in range(x, 0, -1):
if t in cnt:
n -= cnt[t]
rest += cnt[t] % base
rest %= base
rest *= t
base *= t
if n == 0 or base - rest > n * t:
# TODO: Your code here
print('Yes' if n == 0 and rest % base == 0 else 'No')
|
import sys
from collections import Counter
input = sys.stdin.readline
n, x = map(int, input().split())
a = list(map(int, input().split()))
cnt = Counter(a)
rest, base = 0, 1
for t in range(x, 0, -1):
if t in cnt:
n -= cnt[t]
rest += cnt[t] % base
rest %= base
rest *= t
base *= t
if n == 0 or base - rest > n * t:
{{completion}}
print('Yes' if n == 0 and rest % base == 0 else 'No')
|
break
|
[{"input": "6 4\n3 2 2 2 3 3", "output": ["Yes"]}, {"input": "8 3\n3 2 2 2 2 2 1 1", "output": ["Yes"]}, {"input": "7 8\n7 7 7 7 7 7 7", "output": ["No"]}, {"input": "10 5\n4 3 2 1 4 3 2 4 3 4", "output": ["No"]}, {"input": "2 500000\n499999 499999", "output": ["No"]}]
|
block_completion_006088
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given an integer $$$x$$$ and an array of integers $$$a_1, a_2, \ldots, a_n$$$. You have to determine if the number $$$a_1! + a_2! + \ldots + a_n!$$$ is divisible by $$$x!$$$.Here $$$k!$$$ is a factorial of $$$k$$$ — the product of all positive integers less than or equal to $$$k$$$. For example, $$$3! = 1 \cdot 2 \cdot 3 = 6$$$, and $$$5! = 1 \cdot 2 \cdot 3 \cdot 4 \cdot 5 = 120$$$.
Input Specification: The first line contains two integers $$$n$$$ and $$$x$$$ ($$$1 \le n \le 500\,000$$$, $$$1 \le x \le 500\,000$$$). The second line contains $$$n$$$ integers $$$a_1, a_2, \ldots, a_n$$$ ($$$1 \le a_i \le x$$$) — elements of given array.
Output Specification: In the only line print "Yes" (without quotes) if $$$a_1! + a_2! + \ldots + a_n!$$$ is divisible by $$$x!$$$, and "No" (without quotes) otherwise.
Notes: NoteIn the first example $$$3! + 2! + 2! + 2! + 3! + 3! = 6 + 2 + 2 + 2 + 6 + 6 = 24$$$. Number $$$24$$$ is divisible by $$$4! = 24$$$.In the second example $$$3! + 2! + 2! + 2! + 2! + 2! + 1! + 1! = 18$$$, is divisible by $$$3! = 6$$$.In the third example $$$7! + 7! + 7! + 7! + 7! + 7! + 7! = 7 \cdot 7!$$$. It is easy to prove that this number is not divisible by $$$8!$$$.
Code:
def rl():
return [int(i) for i in input().split()]
def solve():
[n,x]=rl()
a=rl()
nax=500000+5
ct=[0 for i in range(nax)]
for b in a:
ct[b]+=1
for i in range(x):
if ct[i]%(i+1):
# TODO: Your code here
ct[i+1]+=ct[i]/(i+1)
return "Yes"
print(solve())
|
def rl():
return [int(i) for i in input().split()]
def solve():
[n,x]=rl()
a=rl()
nax=500000+5
ct=[0 for i in range(nax)]
for b in a:
ct[b]+=1
for i in range(x):
if ct[i]%(i+1):
{{completion}}
ct[i+1]+=ct[i]/(i+1)
return "Yes"
print(solve())
|
return "No"
|
[{"input": "6 4\n3 2 2 2 3 3", "output": ["Yes"]}, {"input": "8 3\n3 2 2 2 2 2 1 1", "output": ["Yes"]}, {"input": "7 8\n7 7 7 7 7 7 7", "output": ["No"]}, {"input": "10 5\n4 3 2 1 4 3 2 4 3 4", "output": ["No"]}, {"input": "2 500000\n499999 499999", "output": ["No"]}]
|
block_completion_006089
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given an integer $$$x$$$ and an array of integers $$$a_1, a_2, \ldots, a_n$$$. You have to determine if the number $$$a_1! + a_2! + \ldots + a_n!$$$ is divisible by $$$x!$$$.Here $$$k!$$$ is a factorial of $$$k$$$ — the product of all positive integers less than or equal to $$$k$$$. For example, $$$3! = 1 \cdot 2 \cdot 3 = 6$$$, and $$$5! = 1 \cdot 2 \cdot 3 \cdot 4 \cdot 5 = 120$$$.
Input Specification: The first line contains two integers $$$n$$$ and $$$x$$$ ($$$1 \le n \le 500\,000$$$, $$$1 \le x \le 500\,000$$$). The second line contains $$$n$$$ integers $$$a_1, a_2, \ldots, a_n$$$ ($$$1 \le a_i \le x$$$) — elements of given array.
Output Specification: In the only line print "Yes" (without quotes) if $$$a_1! + a_2! + \ldots + a_n!$$$ is divisible by $$$x!$$$, and "No" (without quotes) otherwise.
Notes: NoteIn the first example $$$3! + 2! + 2! + 2! + 3! + 3! = 6 + 2 + 2 + 2 + 6 + 6 = 24$$$. Number $$$24$$$ is divisible by $$$4! = 24$$$.In the second example $$$3! + 2! + 2! + 2! + 2! + 2! + 1! + 1! = 18$$$, is divisible by $$$3! = 6$$$.In the third example $$$7! + 7! + 7! + 7! + 7! + 7! + 7! = 7 \cdot 7!$$$. It is easy to prove that this number is not divisible by $$$8!$$$.
Code:
# your code goes here
if __name__ == '__main__':
n, x = map(int, input('').split(' '))
a = list(map(int, input('').split(' ')))
cnt = [0] * (x+2)
for w in a:
cnt[w] += 1
for i in range(x):
while cnt[i] > i:
# TODO: Your code here
print('No' if sum(cnt[:x]) else 'Yes')
|
# your code goes here
if __name__ == '__main__':
n, x = map(int, input('').split(' '))
a = list(map(int, input('').split(' ')))
cnt = [0] * (x+2)
for w in a:
cnt[w] += 1
for i in range(x):
while cnt[i] > i:
{{completion}}
print('No' if sum(cnt[:x]) else 'Yes')
|
cnt[i] -= (i+1)
cnt[i+1] += 1
|
[{"input": "6 4\n3 2 2 2 3 3", "output": ["Yes"]}, {"input": "8 3\n3 2 2 2 2 2 1 1", "output": ["Yes"]}, {"input": "7 8\n7 7 7 7 7 7 7", "output": ["No"]}, {"input": "10 5\n4 3 2 1 4 3 2 4 3 4", "output": ["No"]}, {"input": "2 500000\n499999 499999", "output": ["No"]}]
|
block_completion_006090
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given an integer $$$x$$$ and an array of integers $$$a_1, a_2, \ldots, a_n$$$. You have to determine if the number $$$a_1! + a_2! + \ldots + a_n!$$$ is divisible by $$$x!$$$.Here $$$k!$$$ is a factorial of $$$k$$$ — the product of all positive integers less than or equal to $$$k$$$. For example, $$$3! = 1 \cdot 2 \cdot 3 = 6$$$, and $$$5! = 1 \cdot 2 \cdot 3 \cdot 4 \cdot 5 = 120$$$.
Input Specification: The first line contains two integers $$$n$$$ and $$$x$$$ ($$$1 \le n \le 500\,000$$$, $$$1 \le x \le 500\,000$$$). The second line contains $$$n$$$ integers $$$a_1, a_2, \ldots, a_n$$$ ($$$1 \le a_i \le x$$$) — elements of given array.
Output Specification: In the only line print "Yes" (without quotes) if $$$a_1! + a_2! + \ldots + a_n!$$$ is divisible by $$$x!$$$, and "No" (without quotes) otherwise.
Notes: NoteIn the first example $$$3! + 2! + 2! + 2! + 3! + 3! = 6 + 2 + 2 + 2 + 6 + 6 = 24$$$. Number $$$24$$$ is divisible by $$$4! = 24$$$.In the second example $$$3! + 2! + 2! + 2! + 2! + 2! + 1! + 1! = 18$$$, is divisible by $$$3! = 6$$$.In the third example $$$7! + 7! + 7! + 7! + 7! + 7! + 7! = 7 \cdot 7!$$$. It is easy to prove that this number is not divisible by $$$8!$$$.
Code:
def factorial_divisibility(n, x, a: list):
a.sort()
a.reverse()
while True:
k = a[-1]
a.pop()
cnt = 1
while len(a) > 0 and k == a[-1]:
# TODO: Your code here
if cnt < k + 1:
return ('Yes' if k >= x else 'No' )
for i in range(cnt // (k + 1)):
a.append(k + 1)
for i in range(cnt % (k + 1)):
a.append(k)
n, x = tuple(map(int, input().split(' ')))
a = input().split(' ')
a = list(map(int, a))
print(factorial_divisibility(n, x, a))
|
def factorial_divisibility(n, x, a: list):
a.sort()
a.reverse()
while True:
k = a[-1]
a.pop()
cnt = 1
while len(a) > 0 and k == a[-1]:
{{completion}}
if cnt < k + 1:
return ('Yes' if k >= x else 'No' )
for i in range(cnt // (k + 1)):
a.append(k + 1)
for i in range(cnt % (k + 1)):
a.append(k)
n, x = tuple(map(int, input().split(' ')))
a = input().split(' ')
a = list(map(int, a))
print(factorial_divisibility(n, x, a))
|
cnt += 1
a.pop()
|
[{"input": "6 4\n3 2 2 2 3 3", "output": ["Yes"]}, {"input": "8 3\n3 2 2 2 2 2 1 1", "output": ["Yes"]}, {"input": "7 8\n7 7 7 7 7 7 7", "output": ["No"]}, {"input": "10 5\n4 3 2 1 4 3 2 4 3 4", "output": ["No"]}, {"input": "2 500000\n499999 499999", "output": ["No"]}]
|
block_completion_006091
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given an integer $$$x$$$ and an array of integers $$$a_1, a_2, \ldots, a_n$$$. You have to determine if the number $$$a_1! + a_2! + \ldots + a_n!$$$ is divisible by $$$x!$$$.Here $$$k!$$$ is a factorial of $$$k$$$ — the product of all positive integers less than or equal to $$$k$$$. For example, $$$3! = 1 \cdot 2 \cdot 3 = 6$$$, and $$$5! = 1 \cdot 2 \cdot 3 \cdot 4 \cdot 5 = 120$$$.
Input Specification: The first line contains two integers $$$n$$$ and $$$x$$$ ($$$1 \le n \le 500\,000$$$, $$$1 \le x \le 500\,000$$$). The second line contains $$$n$$$ integers $$$a_1, a_2, \ldots, a_n$$$ ($$$1 \le a_i \le x$$$) — elements of given array.
Output Specification: In the only line print "Yes" (without quotes) if $$$a_1! + a_2! + \ldots + a_n!$$$ is divisible by $$$x!$$$, and "No" (without quotes) otherwise.
Notes: NoteIn the first example $$$3! + 2! + 2! + 2! + 3! + 3! = 6 + 2 + 2 + 2 + 6 + 6 = 24$$$. Number $$$24$$$ is divisible by $$$4! = 24$$$.In the second example $$$3! + 2! + 2! + 2! + 2! + 2! + 1! + 1! = 18$$$, is divisible by $$$3! = 6$$$.In the third example $$$7! + 7! + 7! + 7! + 7! + 7! + 7! = 7 \cdot 7!$$$. It is easy to prove that this number is not divisible by $$$8!$$$.
Code:
def factorial_divisibility(n, x, a: list):
a.sort()
a.reverse()
while True:
k = a[-1]
a.pop()
cnt = 1
while len(a) > 0 and k == a[-1]:
cnt += 1
a.pop()
if cnt < k + 1:
# TODO: Your code here
for i in range(cnt // (k + 1)):
a.append(k + 1)
for i in range(cnt % (k + 1)):
a.append(k)
n, x = tuple(map(int, input().split(' ')))
a = input().split(' ')
a = list(map(int, a))
print(factorial_divisibility(n, x, a))
|
def factorial_divisibility(n, x, a: list):
a.sort()
a.reverse()
while True:
k = a[-1]
a.pop()
cnt = 1
while len(a) > 0 and k == a[-1]:
cnt += 1
a.pop()
if cnt < k + 1:
{{completion}}
for i in range(cnt // (k + 1)):
a.append(k + 1)
for i in range(cnt % (k + 1)):
a.append(k)
n, x = tuple(map(int, input().split(' ')))
a = input().split(' ')
a = list(map(int, a))
print(factorial_divisibility(n, x, a))
|
return ('Yes' if k >= x else 'No' )
|
[{"input": "6 4\n3 2 2 2 3 3", "output": ["Yes"]}, {"input": "8 3\n3 2 2 2 2 2 1 1", "output": ["Yes"]}, {"input": "7 8\n7 7 7 7 7 7 7", "output": ["No"]}, {"input": "10 5\n4 3 2 1 4 3 2 4 3 4", "output": ["No"]}, {"input": "2 500000\n499999 499999", "output": ["No"]}]
|
block_completion_006092
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given an integer $$$x$$$ and an array of integers $$$a_1, a_2, \ldots, a_n$$$. You have to determine if the number $$$a_1! + a_2! + \ldots + a_n!$$$ is divisible by $$$x!$$$.Here $$$k!$$$ is a factorial of $$$k$$$ — the product of all positive integers less than or equal to $$$k$$$. For example, $$$3! = 1 \cdot 2 \cdot 3 = 6$$$, and $$$5! = 1 \cdot 2 \cdot 3 \cdot 4 \cdot 5 = 120$$$.
Input Specification: The first line contains two integers $$$n$$$ and $$$x$$$ ($$$1 \le n \le 500\,000$$$, $$$1 \le x \le 500\,000$$$). The second line contains $$$n$$$ integers $$$a_1, a_2, \ldots, a_n$$$ ($$$1 \le a_i \le x$$$) — elements of given array.
Output Specification: In the only line print "Yes" (without quotes) if $$$a_1! + a_2! + \ldots + a_n!$$$ is divisible by $$$x!$$$, and "No" (without quotes) otherwise.
Notes: NoteIn the first example $$$3! + 2! + 2! + 2! + 3! + 3! = 6 + 2 + 2 + 2 + 6 + 6 = 24$$$. Number $$$24$$$ is divisible by $$$4! = 24$$$.In the second example $$$3! + 2! + 2! + 2! + 2! + 2! + 1! + 1! = 18$$$, is divisible by $$$3! = 6$$$.In the third example $$$7! + 7! + 7! + 7! + 7! + 7! + 7! = 7 \cdot 7!$$$. It is easy to prove that this number is not divisible by $$$8!$$$.
Code:
n , x = [int(x) for x in input().split()]
l = [int(x) for x in input().split()]
s = [0] * (x+1)
for i in l:
s[i] += 1
for i in range(1,x):
if s[i] % (i+1) == 0:
s[i+1] += s[i]//(i+1)
else:
# TODO: Your code here
else:
print('Yes')
|
n , x = [int(x) for x in input().split()]
l = [int(x) for x in input().split()]
s = [0] * (x+1)
for i in l:
s[i] += 1
for i in range(1,x):
if s[i] % (i+1) == 0:
s[i+1] += s[i]//(i+1)
else:
{{completion}}
else:
print('Yes')
|
print('NO')
break
|
[{"input": "6 4\n3 2 2 2 3 3", "output": ["Yes"]}, {"input": "8 3\n3 2 2 2 2 2 1 1", "output": ["Yes"]}, {"input": "7 8\n7 7 7 7 7 7 7", "output": ["No"]}, {"input": "10 5\n4 3 2 1 4 3 2 4 3 4", "output": ["No"]}, {"input": "2 500000\n499999 499999", "output": ["No"]}]
|
block_completion_006093
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given an integer $$$x$$$ and an array of integers $$$a_1, a_2, \ldots, a_n$$$. You have to determine if the number $$$a_1! + a_2! + \ldots + a_n!$$$ is divisible by $$$x!$$$.Here $$$k!$$$ is a factorial of $$$k$$$ — the product of all positive integers less than or equal to $$$k$$$. For example, $$$3! = 1 \cdot 2 \cdot 3 = 6$$$, and $$$5! = 1 \cdot 2 \cdot 3 \cdot 4 \cdot 5 = 120$$$.
Input Specification: The first line contains two integers $$$n$$$ and $$$x$$$ ($$$1 \le n \le 500\,000$$$, $$$1 \le x \le 500\,000$$$). The second line contains $$$n$$$ integers $$$a_1, a_2, \ldots, a_n$$$ ($$$1 \le a_i \le x$$$) — elements of given array.
Output Specification: In the only line print "Yes" (without quotes) if $$$a_1! + a_2! + \ldots + a_n!$$$ is divisible by $$$x!$$$, and "No" (without quotes) otherwise.
Notes: NoteIn the first example $$$3! + 2! + 2! + 2! + 3! + 3! = 6 + 2 + 2 + 2 + 6 + 6 = 24$$$. Number $$$24$$$ is divisible by $$$4! = 24$$$.In the second example $$$3! + 2! + 2! + 2! + 2! + 2! + 1! + 1! = 18$$$, is divisible by $$$3! = 6$$$.In the third example $$$7! + 7! + 7! + 7! + 7! + 7! + 7! = 7 \cdot 7!$$$. It is easy to prove that this number is not divisible by $$$8!$$$.
Code:
ex = [0]
arr = [0]
for i in range(1):
a = list(map(int, input().split()))
ex = a[1]
b = list(map(int, input().split()))
arr = b
for i in range(1):
dp = [0]*ex
for a in arr:
dp[a-1]+=1
for m in range(len(dp)-1):
while dp[m]>=m+2:
# TODO: Your code here
dp = dp[:-1]
A = sum(dp)
if A == 0:
ans='Yes'
else:
ans='No'
print(ans)
|
ex = [0]
arr = [0]
for i in range(1):
a = list(map(int, input().split()))
ex = a[1]
b = list(map(int, input().split()))
arr = b
for i in range(1):
dp = [0]*ex
for a in arr:
dp[a-1]+=1
for m in range(len(dp)-1):
while dp[m]>=m+2:
{{completion}}
dp = dp[:-1]
A = sum(dp)
if A == 0:
ans='Yes'
else:
ans='No'
print(ans)
|
dp[m] = dp[m] - m - 2
dp[m+1]+=1
|
[{"input": "6 4\n3 2 2 2 3 3", "output": ["Yes"]}, {"input": "8 3\n3 2 2 2 2 2 1 1", "output": ["Yes"]}, {"input": "7 8\n7 7 7 7 7 7 7", "output": ["No"]}, {"input": "10 5\n4 3 2 1 4 3 2 4 3 4", "output": ["No"]}, {"input": "2 500000\n499999 499999", "output": ["No"]}]
|
block_completion_006094
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given an integer $$$x$$$ and an array of integers $$$a_1, a_2, \ldots, a_n$$$. You have to determine if the number $$$a_1! + a_2! + \ldots + a_n!$$$ is divisible by $$$x!$$$.Here $$$k!$$$ is a factorial of $$$k$$$ — the product of all positive integers less than or equal to $$$k$$$. For example, $$$3! = 1 \cdot 2 \cdot 3 = 6$$$, and $$$5! = 1 \cdot 2 \cdot 3 \cdot 4 \cdot 5 = 120$$$.
Input Specification: The first line contains two integers $$$n$$$ and $$$x$$$ ($$$1 \le n \le 500\,000$$$, $$$1 \le x \le 500\,000$$$). The second line contains $$$n$$$ integers $$$a_1, a_2, \ldots, a_n$$$ ($$$1 \le a_i \le x$$$) — elements of given array.
Output Specification: In the only line print "Yes" (without quotes) if $$$a_1! + a_2! + \ldots + a_n!$$$ is divisible by $$$x!$$$, and "No" (without quotes) otherwise.
Notes: NoteIn the first example $$$3! + 2! + 2! + 2! + 3! + 3! = 6 + 2 + 2 + 2 + 6 + 6 = 24$$$. Number $$$24$$$ is divisible by $$$4! = 24$$$.In the second example $$$3! + 2! + 2! + 2! + 2! + 2! + 1! + 1! = 18$$$, is divisible by $$$3! = 6$$$.In the third example $$$7! + 7! + 7! + 7! + 7! + 7! + 7! = 7 \cdot 7!$$$. It is easy to prove that this number is not divisible by $$$8!$$$.
Code:
n,x=map(int,input().split())
s={i:0 for i in range(1,x+1)}
def f(x,a):
s[x]=s[x]+a
an=map(int,input().split())
for b in an:
f(b,1)
l=1
i=1
while i < x:
if s[i]%(i+1)==0:
f(i+1,s[i]//(i+1))
i+=1
else:
# TODO: Your code here
print(['no','yes'][l])
|
n,x=map(int,input().split())
s={i:0 for i in range(1,x+1)}
def f(x,a):
s[x]=s[x]+a
an=map(int,input().split())
for b in an:
f(b,1)
l=1
i=1
while i < x:
if s[i]%(i+1)==0:
f(i+1,s[i]//(i+1))
i+=1
else:
{{completion}}
print(['no','yes'][l])
|
l=0
break
|
[{"input": "6 4\n3 2 2 2 3 3", "output": ["Yes"]}, {"input": "8 3\n3 2 2 2 2 2 1 1", "output": ["Yes"]}, {"input": "7 8\n7 7 7 7 7 7 7", "output": ["No"]}, {"input": "10 5\n4 3 2 1 4 3 2 4 3 4", "output": ["No"]}, {"input": "2 500000\n499999 499999", "output": ["No"]}]
|
block_completion_006095
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given an integer $$$x$$$ and an array of integers $$$a_1, a_2, \ldots, a_n$$$. You have to determine if the number $$$a_1! + a_2! + \ldots + a_n!$$$ is divisible by $$$x!$$$.Here $$$k!$$$ is a factorial of $$$k$$$ — the product of all positive integers less than or equal to $$$k$$$. For example, $$$3! = 1 \cdot 2 \cdot 3 = 6$$$, and $$$5! = 1 \cdot 2 \cdot 3 \cdot 4 \cdot 5 = 120$$$.
Input Specification: The first line contains two integers $$$n$$$ and $$$x$$$ ($$$1 \le n \le 500\,000$$$, $$$1 \le x \le 500\,000$$$). The second line contains $$$n$$$ integers $$$a_1, a_2, \ldots, a_n$$$ ($$$1 \le a_i \le x$$$) — elements of given array.
Output Specification: In the only line print "Yes" (without quotes) if $$$a_1! + a_2! + \ldots + a_n!$$$ is divisible by $$$x!$$$, and "No" (without quotes) otherwise.
Notes: NoteIn the first example $$$3! + 2! + 2! + 2! + 3! + 3! = 6 + 2 + 2 + 2 + 6 + 6 = 24$$$. Number $$$24$$$ is divisible by $$$4! = 24$$$.In the second example $$$3! + 2! + 2! + 2! + 2! + 2! + 1! + 1! = 18$$$, is divisible by $$$3! = 6$$$.In the third example $$$7! + 7! + 7! + 7! + 7! + 7! + 7! = 7 \cdot 7!$$$. It is easy to prove that this number is not divisible by $$$8!$$$.
Code:
b=[0]*500001
l=list(map(int,input("").split()))
n=l[0]
m=l[1]
a=list(map(int,input("").split()))
e=1
for i in a:
b[i]+=1
for i in range(1,l[1]):
if b[i]%(i+1)==0:
b[i+1]+=(b[i]//(i+1))
else:
# TODO: Your code here
if e==1:
if b[m]!=0 :
print("Yes")
else:
print("No")
|
b=[0]*500001
l=list(map(int,input("").split()))
n=l[0]
m=l[1]
a=list(map(int,input("").split()))
e=1
for i in a:
b[i]+=1
for i in range(1,l[1]):
if b[i]%(i+1)==0:
b[i+1]+=(b[i]//(i+1))
else:
{{completion}}
if e==1:
if b[m]!=0 :
print("Yes")
else:
print("No")
|
print("No")
e=0
break
|
[{"input": "6 4\n3 2 2 2 3 3", "output": ["Yes"]}, {"input": "8 3\n3 2 2 2 2 2 1 1", "output": ["Yes"]}, {"input": "7 8\n7 7 7 7 7 7 7", "output": ["No"]}, {"input": "10 5\n4 3 2 1 4 3 2 4 3 4", "output": ["No"]}, {"input": "2 500000\n499999 499999", "output": ["No"]}]
|
block_completion_006096
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given an integer $$$x$$$ and an array of integers $$$a_1, a_2, \ldots, a_n$$$. You have to determine if the number $$$a_1! + a_2! + \ldots + a_n!$$$ is divisible by $$$x!$$$.Here $$$k!$$$ is a factorial of $$$k$$$ — the product of all positive integers less than or equal to $$$k$$$. For example, $$$3! = 1 \cdot 2 \cdot 3 = 6$$$, and $$$5! = 1 \cdot 2 \cdot 3 \cdot 4 \cdot 5 = 120$$$.
Input Specification: The first line contains two integers $$$n$$$ and $$$x$$$ ($$$1 \le n \le 500\,000$$$, $$$1 \le x \le 500\,000$$$). The second line contains $$$n$$$ integers $$$a_1, a_2, \ldots, a_n$$$ ($$$1 \le a_i \le x$$$) — elements of given array.
Output Specification: In the only line print "Yes" (without quotes) if $$$a_1! + a_2! + \ldots + a_n!$$$ is divisible by $$$x!$$$, and "No" (without quotes) otherwise.
Notes: NoteIn the first example $$$3! + 2! + 2! + 2! + 3! + 3! = 6 + 2 + 2 + 2 + 6 + 6 = 24$$$. Number $$$24$$$ is divisible by $$$4! = 24$$$.In the second example $$$3! + 2! + 2! + 2! + 2! + 2! + 1! + 1! = 18$$$, is divisible by $$$3! = 6$$$.In the third example $$$7! + 7! + 7! + 7! + 7! + 7! + 7! = 7 \cdot 7!$$$. It is easy to prove that this number is not divisible by $$$8!$$$.
Code:
b=[0]*500001
l=list(map(int,input("").split()))
n=l[0]
m=l[1]
a=list(map(int,input("").split()))
e=1
for i in a:
b[i]+=1
for i in range(1,l[1]):
if b[i]%(i+1)==0:
b[i+1]+=(b[i]//(i+1))
else:
print("No")
e=0
break
if e==1:
if b[m]!=0 :
print("Yes")
else:
# TODO: Your code here
|
b=[0]*500001
l=list(map(int,input("").split()))
n=l[0]
m=l[1]
a=list(map(int,input("").split()))
e=1
for i in a:
b[i]+=1
for i in range(1,l[1]):
if b[i]%(i+1)==0:
b[i+1]+=(b[i]//(i+1))
else:
print("No")
e=0
break
if e==1:
if b[m]!=0 :
print("Yes")
else:
{{completion}}
|
print("No")
|
[{"input": "6 4\n3 2 2 2 3 3", "output": ["Yes"]}, {"input": "8 3\n3 2 2 2 2 2 1 1", "output": ["Yes"]}, {"input": "7 8\n7 7 7 7 7 7 7", "output": ["No"]}, {"input": "10 5\n4 3 2 1 4 3 2 4 3 4", "output": ["No"]}, {"input": "2 500000\n499999 499999", "output": ["No"]}]
|
block_completion_006097
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You have been invited as a production process optimization specialist to some very large company. The company has $$$n$$$ machines at its factory, standing one behind another in the production chain. Each machine can be described in one of the following two ways: $$$(+,~a_i)$$$ or $$$(*,~a_i)$$$.If a workpiece with the value $$$x$$$ is supplied to the machine of kind $$$(+,~a_i)$$$, then the output workpiece has value $$$x + a_i$$$.If a workpiece with the value $$$x$$$ is supplied to the machine of kind $$$(*,~a_i)$$$, then the output workpiece has value $$$x \cdot a_i$$$.The whole production process is as follows. The workpiece with the value $$$1$$$ is supplied to the first machine, then the workpiece obtained after the operation of the first machine is supplied to the second machine, then the workpiece obtained after the operation of the second machine is supplied to the third machine, and so on. The company is not doing very well, so now the value of the resulting product does not exceed $$$2 \cdot 10^9$$$.The directors of the company are not satisfied with the efficiency of the production process and have given you a budget of $$$b$$$ coins to optimize it.To optimize production you can change the order of machines in the chain. Namely, by spending $$$p$$$ coins, you can take any machine of kind $$$(+,~a_i)$$$ and move it to any place in the chain without changing the order of other machines. Also, by spending $$$m$$$ coins, you can take any machine of kind $$$(*,~a_i)$$$ and move it to any place in the chain.What is the maximum value of the resulting product that can be achieved if the total cost of movements that are made should not exceed $$$b$$$ coins?
Input Specification: The first line contains four integers $$$n$$$, $$$b$$$, $$$p$$$ and $$$m$$$ ($$$1 \le n \le 10^6$$$, $$$1 \le b, p, m \le 10^9$$$) — the number of machine at the factory, your budget and costs of movements of both kinds of machines. Each of the following $$$n$$$ lines contains description of a machine. The description begins with one of the following characters: "+" or "*", that denotes the kind of the machine. Then an integer $$$a_i$$$ follows ($$$1 \le a_i \le 2 \cdot 10^9$$$). It's guaranteed that the current value of the resulting product does not exceed $$$2 \cdot 10^9$$$.
Output Specification: Print one integer — the maximum value of the resulting product that can be achieved if the total cost of movements that are made does not exceed $$$b$$$ coins.
Notes: NoteIn the first example our budget is too low to move machine $$$(*,~2)$$$, but we can move both machines $$$(+,~1)$$$ to the beginning of the chain. So the final chain will be $$$(+,~1)$$$ $$$(+,~1)$$$ $$$(*,~2)$$$. If the workpiece with the value $$$1$$$ is supplied to the first machine, its value will be changed in the following way: $$$1, 2, 3, 6$$$.In the second example we can move only one machine. Let's move machine $$$(+,~2)$$$ to the beginning of the chain. The final chain will be $$$(+,~2)$$$ $$$(*,~2)$$$ $$$(+,~1)$$$ $$$(*,~3)$$$. The value of the workpiece will be changed in the following way: $$$1, 3, 6, 7, 21$$$.In the third example we can place machine $$$(*,~4)$$$ before the machine $$$(*,~5)$$$, and move machine $$$(+,~3)$$$ to the beginning of the chain. The final chain will be $$$(+,~3)$$$ $$$(*,~2)$$$ $$$(+,~1)$$$ $$$(+,~1)$$$ $$$(+,~1)$$$ $$$(+,~1)$$$ $$$(*,~4)$$$ $$$(*,~5)$$$. The value of the workpiece will be changed in the following way: $$$1, 4, 8, 9, 10, 11, 12, 48, 240$$$.
Code:
from bisect import bisect
import sys
input = sys.stdin.readline
n, b, p, m = map(int, input().split())
adds = []
curr = []
mults = []
i = 0
for _ in range(n):
t, v = input().split()
v = int(v)
if t == '*':
if v == 1:
continue
curr.sort()
adds.append(curr)
mults.append(v)
curr = []
else:
curr.append(v)
curr.sort()
adds.append(curr)
pref = []
for l in adds:
np = [0]
for v in l[::-1]:
np.append(v + np[-1])
pref.append(np)
y = len(mults)
un_m = sorted(set(mults))
z = len(un_m)
ct_m = [0] * z
for v in mults:
for i in range(z):
if un_m[i] == v:
ct_m[i] += 1
from itertools import product
poss = []
assert len(adds) == y + 1
for tup in product(*[range(ct + 1) for ct in ct_m]):
rem_adds = (b - m * sum(tup))//p
if rem_adds < 0:
continue
d = {}
for i in range(z):
d[un_m[i]] = tup[i]
end = 1
used = [0] * y
for i in range(y):
if d[mults[i]]:
used[i] = 1
d[mults[i]] -= 1
end *= mults[i]
seg_mult = [1]
for i in range(y - 1, -1, -1):
if used[i] == 0:
seg_mult.append(seg_mult[-1] * mults[i])
else:
seg_mult.append(seg_mult[-1])
seg_mult.reverse()
exc = [seg_mult[0] - v for v in seg_mult]
init_tot = 0
for j in range(y + 1):
if exc[j] != 0:
init_tot += len(adds[j])
lo = 0 #Ct value provided >= lo >= rem_adds
hi = 10 ** 18 + 100 #Too high
while hi - lo > 1:
mid = lo + (hi - lo) // 2
tot = init_tot
for j in range(y + 1):
if exc[j] == 0:
# TODO: Your code here
limit = (mid - 1) // exc[j]
#ct = len(adds[j]) - bisect(adds[j], limit - 1)
#tot += ct
diff = bisect(adds[j], limit)
tot -= diff
#print(mid, j, diff)
if tot >= rem_adds:
lo = mid
else:
hi = mid
tot = seg_mult[0]
ct = 0
for j in range(y + 1):
tot += pref[j][-1] * seg_mult[j]
if exc[j] == 0:
continue
limit = (lo - 1) // exc[j]
s_ct = len(adds[j]) - bisect(adds[j], limit)
tot += pref[j][s_ct] * exc[j]
ct += s_ct
if lo != 0:
assert ct >= rem_adds
tot -= lo * (ct - rem_adds)
#print(tup, lo, tot, end)
poss.append(tot * end)
#break
print(max(poss))
|
from bisect import bisect
import sys
input = sys.stdin.readline
n, b, p, m = map(int, input().split())
adds = []
curr = []
mults = []
i = 0
for _ in range(n):
t, v = input().split()
v = int(v)
if t == '*':
if v == 1:
continue
curr.sort()
adds.append(curr)
mults.append(v)
curr = []
else:
curr.append(v)
curr.sort()
adds.append(curr)
pref = []
for l in adds:
np = [0]
for v in l[::-1]:
np.append(v + np[-1])
pref.append(np)
y = len(mults)
un_m = sorted(set(mults))
z = len(un_m)
ct_m = [0] * z
for v in mults:
for i in range(z):
if un_m[i] == v:
ct_m[i] += 1
from itertools import product
poss = []
assert len(adds) == y + 1
for tup in product(*[range(ct + 1) for ct in ct_m]):
rem_adds = (b - m * sum(tup))//p
if rem_adds < 0:
continue
d = {}
for i in range(z):
d[un_m[i]] = tup[i]
end = 1
used = [0] * y
for i in range(y):
if d[mults[i]]:
used[i] = 1
d[mults[i]] -= 1
end *= mults[i]
seg_mult = [1]
for i in range(y - 1, -1, -1):
if used[i] == 0:
seg_mult.append(seg_mult[-1] * mults[i])
else:
seg_mult.append(seg_mult[-1])
seg_mult.reverse()
exc = [seg_mult[0] - v for v in seg_mult]
init_tot = 0
for j in range(y + 1):
if exc[j] != 0:
init_tot += len(adds[j])
lo = 0 #Ct value provided >= lo >= rem_adds
hi = 10 ** 18 + 100 #Too high
while hi - lo > 1:
mid = lo + (hi - lo) // 2
tot = init_tot
for j in range(y + 1):
if exc[j] == 0:
{{completion}}
limit = (mid - 1) // exc[j]
#ct = len(adds[j]) - bisect(adds[j], limit - 1)
#tot += ct
diff = bisect(adds[j], limit)
tot -= diff
#print(mid, j, diff)
if tot >= rem_adds:
lo = mid
else:
hi = mid
tot = seg_mult[0]
ct = 0
for j in range(y + 1):
tot += pref[j][-1] * seg_mult[j]
if exc[j] == 0:
continue
limit = (lo - 1) // exc[j]
s_ct = len(adds[j]) - bisect(adds[j], limit)
tot += pref[j][s_ct] * exc[j]
ct += s_ct
if lo != 0:
assert ct >= rem_adds
tot -= lo * (ct - rem_adds)
#print(tup, lo, tot, end)
poss.append(tot * end)
#break
print(max(poss))
|
continue
|
[{"input": "3 2 1 3\n* 2\n+ 1\n+ 1", "output": ["6"]}, {"input": "4 2 2 2\n* 2\n+ 1\n* 3\n+ 2", "output": ["21"]}, {"input": "8 2 1 1\n* 2\n+ 1\n* 4\n+ 1\n+ 1\n+ 1\n* 5\n+ 3", "output": ["240"]}]
|
block_completion_006115
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You have been invited as a production process optimization specialist to some very large company. The company has $$$n$$$ machines at its factory, standing one behind another in the production chain. Each machine can be described in one of the following two ways: $$$(+,~a_i)$$$ or $$$(*,~a_i)$$$.If a workpiece with the value $$$x$$$ is supplied to the machine of kind $$$(+,~a_i)$$$, then the output workpiece has value $$$x + a_i$$$.If a workpiece with the value $$$x$$$ is supplied to the machine of kind $$$(*,~a_i)$$$, then the output workpiece has value $$$x \cdot a_i$$$.The whole production process is as follows. The workpiece with the value $$$1$$$ is supplied to the first machine, then the workpiece obtained after the operation of the first machine is supplied to the second machine, then the workpiece obtained after the operation of the second machine is supplied to the third machine, and so on. The company is not doing very well, so now the value of the resulting product does not exceed $$$2 \cdot 10^9$$$.The directors of the company are not satisfied with the efficiency of the production process and have given you a budget of $$$b$$$ coins to optimize it.To optimize production you can change the order of machines in the chain. Namely, by spending $$$p$$$ coins, you can take any machine of kind $$$(+,~a_i)$$$ and move it to any place in the chain without changing the order of other machines. Also, by spending $$$m$$$ coins, you can take any machine of kind $$$(*,~a_i)$$$ and move it to any place in the chain.What is the maximum value of the resulting product that can be achieved if the total cost of movements that are made should not exceed $$$b$$$ coins?
Input Specification: The first line contains four integers $$$n$$$, $$$b$$$, $$$p$$$ and $$$m$$$ ($$$1 \le n \le 10^6$$$, $$$1 \le b, p, m \le 10^9$$$) — the number of machine at the factory, your budget and costs of movements of both kinds of machines. Each of the following $$$n$$$ lines contains description of a machine. The description begins with one of the following characters: "+" or "*", that denotes the kind of the machine. Then an integer $$$a_i$$$ follows ($$$1 \le a_i \le 2 \cdot 10^9$$$). It's guaranteed that the current value of the resulting product does not exceed $$$2 \cdot 10^9$$$.
Output Specification: Print one integer — the maximum value of the resulting product that can be achieved if the total cost of movements that are made does not exceed $$$b$$$ coins.
Notes: NoteIn the first example our budget is too low to move machine $$$(*,~2)$$$, but we can move both machines $$$(+,~1)$$$ to the beginning of the chain. So the final chain will be $$$(+,~1)$$$ $$$(+,~1)$$$ $$$(*,~2)$$$. If the workpiece with the value $$$1$$$ is supplied to the first machine, its value will be changed in the following way: $$$1, 2, 3, 6$$$.In the second example we can move only one machine. Let's move machine $$$(+,~2)$$$ to the beginning of the chain. The final chain will be $$$(+,~2)$$$ $$$(*,~2)$$$ $$$(+,~1)$$$ $$$(*,~3)$$$. The value of the workpiece will be changed in the following way: $$$1, 3, 6, 7, 21$$$.In the third example we can place machine $$$(*,~4)$$$ before the machine $$$(*,~5)$$$, and move machine $$$(+,~3)$$$ to the beginning of the chain. The final chain will be $$$(+,~3)$$$ $$$(*,~2)$$$ $$$(+,~1)$$$ $$$(+,~1)$$$ $$$(+,~1)$$$ $$$(+,~1)$$$ $$$(*,~4)$$$ $$$(*,~5)$$$. The value of the workpiece will be changed in the following way: $$$1, 4, 8, 9, 10, 11, 12, 48, 240$$$.
Code:
from bisect import bisect
import sys
input = sys.stdin.readline
n, b, p, m = map(int, input().split())
adds = []
curr = []
mults = []
i = 0
for _ in range(n):
t, v = input().split()
v = int(v)
if t == '*':
if v == 1:
continue
curr.sort()
adds.append(curr)
mults.append(v)
curr = []
else:
curr.append(v)
curr.sort()
adds.append(curr)
pref = []
for l in adds:
np = [0]
for v in l[::-1]:
np.append(v + np[-1])
pref.append(np)
y = len(mults)
un_m = sorted(set(mults))
z = len(un_m)
ct_m = [0] * z
for v in mults:
for i in range(z):
if un_m[i] == v:
ct_m[i] += 1
from itertools import product
poss = []
assert len(adds) == y + 1
for tup in product(*[range(ct + 1) for ct in ct_m]):
rem_adds = (b - m * sum(tup))//p
if rem_adds < 0:
continue
d = {}
for i in range(z):
d[un_m[i]] = tup[i]
end = 1
used = [0] * y
for i in range(y):
if d[mults[i]]:
used[i] = 1
d[mults[i]] -= 1
end *= mults[i]
seg_mult = [1]
for i in range(y - 1, -1, -1):
if used[i] == 0:
seg_mult.append(seg_mult[-1] * mults[i])
else:
# TODO: Your code here
seg_mult.reverse()
exc = [seg_mult[0] - v for v in seg_mult]
init_tot = 0
for j in range(y + 1):
if exc[j] != 0:
init_tot += len(adds[j])
lo = 0 #Ct value provided >= lo >= rem_adds
hi = 10 ** 18 + 100 #Too high
while hi - lo > 1:
mid = lo + (hi - lo) // 2
tot = init_tot
for j in range(y + 1):
if exc[j] == 0:
continue
limit = (mid - 1) // exc[j]
#ct = len(adds[j]) - bisect(adds[j], limit - 1)
#tot += ct
diff = bisect(adds[j], limit)
tot -= diff
#print(mid, j, diff)
if tot >= rem_adds:
lo = mid
else:
hi = mid
tot = seg_mult[0]
ct = 0
for j in range(y + 1):
tot += pref[j][-1] * seg_mult[j]
if exc[j] == 0:
continue
limit = (lo - 1) // exc[j]
s_ct = len(adds[j]) - bisect(adds[j], limit)
tot += pref[j][s_ct] * exc[j]
ct += s_ct
if lo != 0:
assert ct >= rem_adds
tot -= lo * (ct - rem_adds)
#print(tup, lo, tot, end)
poss.append(tot * end)
#break
print(max(poss))
|
from bisect import bisect
import sys
input = sys.stdin.readline
n, b, p, m = map(int, input().split())
adds = []
curr = []
mults = []
i = 0
for _ in range(n):
t, v = input().split()
v = int(v)
if t == '*':
if v == 1:
continue
curr.sort()
adds.append(curr)
mults.append(v)
curr = []
else:
curr.append(v)
curr.sort()
adds.append(curr)
pref = []
for l in adds:
np = [0]
for v in l[::-1]:
np.append(v + np[-1])
pref.append(np)
y = len(mults)
un_m = sorted(set(mults))
z = len(un_m)
ct_m = [0] * z
for v in mults:
for i in range(z):
if un_m[i] == v:
ct_m[i] += 1
from itertools import product
poss = []
assert len(adds) == y + 1
for tup in product(*[range(ct + 1) for ct in ct_m]):
rem_adds = (b - m * sum(tup))//p
if rem_adds < 0:
continue
d = {}
for i in range(z):
d[un_m[i]] = tup[i]
end = 1
used = [0] * y
for i in range(y):
if d[mults[i]]:
used[i] = 1
d[mults[i]] -= 1
end *= mults[i]
seg_mult = [1]
for i in range(y - 1, -1, -1):
if used[i] == 0:
seg_mult.append(seg_mult[-1] * mults[i])
else:
{{completion}}
seg_mult.reverse()
exc = [seg_mult[0] - v for v in seg_mult]
init_tot = 0
for j in range(y + 1):
if exc[j] != 0:
init_tot += len(adds[j])
lo = 0 #Ct value provided >= lo >= rem_adds
hi = 10 ** 18 + 100 #Too high
while hi - lo > 1:
mid = lo + (hi - lo) // 2
tot = init_tot
for j in range(y + 1):
if exc[j] == 0:
continue
limit = (mid - 1) // exc[j]
#ct = len(adds[j]) - bisect(adds[j], limit - 1)
#tot += ct
diff = bisect(adds[j], limit)
tot -= diff
#print(mid, j, diff)
if tot >= rem_adds:
lo = mid
else:
hi = mid
tot = seg_mult[0]
ct = 0
for j in range(y + 1):
tot += pref[j][-1] * seg_mult[j]
if exc[j] == 0:
continue
limit = (lo - 1) // exc[j]
s_ct = len(adds[j]) - bisect(adds[j], limit)
tot += pref[j][s_ct] * exc[j]
ct += s_ct
if lo != 0:
assert ct >= rem_adds
tot -= lo * (ct - rem_adds)
#print(tup, lo, tot, end)
poss.append(tot * end)
#break
print(max(poss))
|
seg_mult.append(seg_mult[-1])
|
[{"input": "3 2 1 3\n* 2\n+ 1\n+ 1", "output": ["6"]}, {"input": "4 2 2 2\n* 2\n+ 1\n* 3\n+ 2", "output": ["21"]}, {"input": "8 2 1 1\n* 2\n+ 1\n* 4\n+ 1\n+ 1\n+ 1\n* 5\n+ 3", "output": ["240"]}]
|
block_completion_006116
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: Everyone was happy coding, until suddenly a power shortage happened and the best competitive programming site went down. Fortunately, a system administrator bought some new equipment recently, including some UPSs. Thus there are some servers that are still online, but we need all of them to be working in order to keep the round rated.Imagine the servers being a binary string $$$s$$$ of length $$$n$$$. If the $$$i$$$-th server is online, then $$$s_i = 1$$$, and $$$s_i = 0$$$ otherwise.A system administrator can do the following operation called electricity spread, that consists of the following phases: Select two servers at positions $$$1 \le i < j \le n$$$ such that both are online (i.e. $$$s_i=s_j=1$$$). The spread starts only from online servers. Check if we have enough power to make the spread. We consider having enough power if the number of turned on servers in range $$$[i, j]$$$ is at least the number of turned off servers in range $$$[i, j]$$$. More formally, check whether $$$2 \cdot (s_i + s_{i+1} + \ldots + s_j) \ge j - i + 1$$$. If the check is positive, turn on all the offline servers in range $$$[i, j]$$$. More formally, make $$$s_k := 1$$$ for all $$$k$$$ from $$$i$$$ to $$$j$$$. We call a binary string $$$s$$$ of length $$$n$$$ rated if we can turn on all servers (i.e. make $$$s_i = 1$$$ for $$$1 \le i \le n$$$) using the electricity spread operation any number of times (possibly, $$$0$$$). Your task is to find the number of rated strings of length $$$n$$$ modulo $$$m$$$.
Input Specification: The first and only line contains two integers $$$n$$$ and $$$m$$$ ($$$1 \le n \le 5000$$$, $$$10 \le m \le 10^9$$$) — the length of the string and the required module.
Output Specification: Print a single integer — the number of rated binary strings of length $$$n$$$. Since this number can be large, print it modulo $$$m$$$.
Notes: NoteIn the first example, the only rated string is 11. So the answer is $$$1$$$.In the second example, the rated strings are: 111; 101, because we can perform an operation with $$$i = 1$$$ and $$$j = 3$$$. So the answer is $$$2$$$.In the third sample, the rated strings are: 1001; 1111; 1011; 1101. So the answer is $$$4$$$.
Code:
n, m = map(int, input().split())
def modmul(a, b, c = 0):
return (a * b + c) % m
half = [0, 0, 1] + [0] * (3 * n)
pref = [0, 0, 1] + [0] * (3 * n)
good = [-1, 1]
bad = [-1, 0]
for i in range(2, n + 1):
nb = 0
for j in range(1, i):
prev = i - 2 * j - 1
if prev < 0:
# TODO: Your code here
add = modmul(pref[prev], good[j])
nb += add
half[j + i] += add
half[j + i] %= m
pref[i] = (pref[i - 1] + half[i]) % m
nb %= m
bad.append(nb)
tot = pow(2, i-2, m)
good.append((tot - nb) % m)
half[2 * i] += good[i]
print(good[n] % m)
|
n, m = map(int, input().split())
def modmul(a, b, c = 0):
return (a * b + c) % m
half = [0, 0, 1] + [0] * (3 * n)
pref = [0, 0, 1] + [0] * (3 * n)
good = [-1, 1]
bad = [-1, 0]
for i in range(2, n + 1):
nb = 0
for j in range(1, i):
prev = i - 2 * j - 1
if prev < 0:
{{completion}}
add = modmul(pref[prev], good[j])
nb += add
half[j + i] += add
half[j + i] %= m
pref[i] = (pref[i - 1] + half[i]) % m
nb %= m
bad.append(nb)
tot = pow(2, i-2, m)
good.append((tot - nb) % m)
half[2 * i] += good[i]
print(good[n] % m)
|
continue
|
[{"input": "2 100", "output": ["1"]}, {"input": "3 10", "output": ["2"]}, {"input": "4 3271890", "output": ["4"]}, {"input": "17 123456", "output": ["32347"]}]
|
block_completion_006450
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: We call an array $$$a$$$ of length $$$n$$$ fancy if for each $$$1 < i \le n$$$ it holds that $$$a_i = a_{i-1} + 1$$$.Let's call $$$f(p)$$$ applied to a permutation$$$^\dagger$$$ of length $$$n$$$ as the minimum number of subarrays it can be partitioned such that each one of them is fancy. For example $$$f([1,2,3]) = 1$$$, while $$$f([3,1,2]) = 2$$$ and $$$f([3,2,1]) = 3$$$.Given $$$n$$$ and a permutation $$$p$$$ of length $$$n$$$, we define a permutation $$$p'$$$ of length $$$n$$$ to be $$$k$$$-special if and only if: $$$p'$$$ is lexicographically smaller$$$^\ddagger$$$ than $$$p$$$, and $$$f(p') = k$$$. Your task is to count for each $$$1 \le k \le n$$$ the number of $$$k$$$-special permutations modulo $$$m$$$.$$$^\dagger$$$ A permutation is an array consisting of $$$n$$$ distinct integers from $$$1$$$ to $$$n$$$ in arbitrary order. For example, $$$[2,3,1,5,4]$$$ is a permutation, but $$$[1,2,2]$$$ is not a permutation ($$$2$$$ appears twice in the array) and $$$[1,3,4]$$$ is also not a permutation ($$$n=3$$$ but there is $$$4$$$ in the array).$$$^\ddagger$$$ A permutation $$$a$$$ of length $$$n$$$ is lexicographically smaller than a permutation $$$b$$$ of length $$$n$$$ if and only if the following holds: in the first position where $$$a$$$ and $$$b$$$ differ, the permutation $$$a$$$ has a smaller element than the corresponding element in $$$b$$$.
Input Specification: The first line contains two integers $$$n$$$ and $$$m$$$ ($$$1 \le n \le 2000$$$, $$$10 \le m \le 10^9$$$) — the length of the permutation and the required modulo. The second line contains $$$n$$$ distinct integers $$$p_1, p_2, \ldots, p_n$$$ ($$$1 \le p_i \le n$$$) — the permutation $$$p$$$.
Output Specification: Print $$$n$$$ integers, where the $$$k$$$-th integer is the number of $$$k$$$-special permutations modulo $$$m$$$.
Notes: NoteIn the first example, the permutations that are lexicographically smaller than $$$[1,3,4,2]$$$ are: $$$[1,2,3,4]$$$, $$$f([1,2,3,4])=1$$$; $$$[1,2,4,3]$$$, $$$f([1,2,4,3])=3$$$; $$$[1,3,2,4]$$$, $$$f([1,3,2,4])=4$$$. Thus our answer is $$$[1,0,1,1]$$$.In the second example, the permutations that are lexicographically smaller than $$$[3,2,1]$$$ are: $$$[1,2,3]$$$, $$$f([1,2,3])=1$$$; $$$[1,3,2]$$$, $$$f([1,3,2])=3$$$; $$$[2,1,3]$$$, $$$f([2,1,3])=3$$$; $$$[2,3,1]$$$, $$$f([2,3,1])=2$$$; $$$[3,1,2]$$$, $$$f([3,1,2])=2$$$. Thus our answer is $$$[1,2,2]$$$.
Code:
n, m = map(int, input().split())
def modmul(a, b, c = 0):
return (a * b + c) % m
comb = [[1]]
for i in range(2010):
prev = comb[-1]
nex = [1]
for i in range(i):
nex.append((prev[i] + prev[i + 1]) % m)
nex.append(1)
comb.append(nex)
fact = [1]
for i in range(1, 3000):
fact.append((i * fact[i - 1]) % m)
p = list(map(lambda x: int(x) - 1, input().split()))
rem = [1] * n
pairs = n - 1
base = 0
out = [[0] * (n + 1) for _ in range(n + 1)]
for i in range(n):
diff = [0] * 3
spec = [0] * 3
for j in range(p[i]):
d = 0
if rem[j] == 0:
continue
if j and rem[j - 1]:
d += 1
#if j < n - 1 and rem[j + 1]:
# d += 1
if i and j == p[i - 1] + 1:
spec[d] += 1
else:
diff[d] += 1
for d in range(3):
pp = pairs - d
if pp < 0:
continue
if diff[d] == 0 and spec[d] == 0:
continue
remain = n - i - 1
for sq in range(pp + 1):
ways = comb[pp][sq]
order = remain - sq
assert order >= 0
ct = modmul(ways, fact[order])
out[base][sq] += modmul(ct, diff[d] + spec[d])
if spec[d]:
# TODO: Your code here
j = p[i]
rem[j] = 0
if j and rem[j - 1]:
pairs -= 1
if j < n - 1 and rem[j + 1]:
pairs -= 1
if i and p[i] == p[i - 1] + 1:
base += 1
while len(out) > 1:
prev = out.pop()
for i in range(n):
out[-1][i] += prev[i]
if i > 0:
out[-1][i] += prev[i - 1]
out = out[0]
res = []
for i in range(n):
basee = out[n - 1 - i]
for j in range(i):
basee -= modmul(res[j], comb[n - j - 1][n - i - 1])
#print(i, j, basee)
res.append(basee % m)
print(' '.join(map(str, res)))
|
n, m = map(int, input().split())
def modmul(a, b, c = 0):
return (a * b + c) % m
comb = [[1]]
for i in range(2010):
prev = comb[-1]
nex = [1]
for i in range(i):
nex.append((prev[i] + prev[i + 1]) % m)
nex.append(1)
comb.append(nex)
fact = [1]
for i in range(1, 3000):
fact.append((i * fact[i - 1]) % m)
p = list(map(lambda x: int(x) - 1, input().split()))
rem = [1] * n
pairs = n - 1
base = 0
out = [[0] * (n + 1) for _ in range(n + 1)]
for i in range(n):
diff = [0] * 3
spec = [0] * 3
for j in range(p[i]):
d = 0
if rem[j] == 0:
continue
if j and rem[j - 1]:
d += 1
#if j < n - 1 and rem[j + 1]:
# d += 1
if i and j == p[i - 1] + 1:
spec[d] += 1
else:
diff[d] += 1
for d in range(3):
pp = pairs - d
if pp < 0:
continue
if diff[d] == 0 and spec[d] == 0:
continue
remain = n - i - 1
for sq in range(pp + 1):
ways = comb[pp][sq]
order = remain - sq
assert order >= 0
ct = modmul(ways, fact[order])
out[base][sq] += modmul(ct, diff[d] + spec[d])
if spec[d]:
{{completion}}
j = p[i]
rem[j] = 0
if j and rem[j - 1]:
pairs -= 1
if j < n - 1 and rem[j + 1]:
pairs -= 1
if i and p[i] == p[i - 1] + 1:
base += 1
while len(out) > 1:
prev = out.pop()
for i in range(n):
out[-1][i] += prev[i]
if i > 0:
out[-1][i] += prev[i - 1]
out = out[0]
res = []
for i in range(n):
basee = out[n - 1 - i]
for j in range(i):
basee -= modmul(res[j], comb[n - j - 1][n - i - 1])
#print(i, j, basee)
res.append(basee % m)
print(' '.join(map(str, res)))
|
out[base][sq + 1] += ct
|
[{"input": "4 666012\n1 3 4 2", "output": ["1 0 1 1"]}, {"input": "3 10\n3 2 1", "output": ["1 2 2"]}, {"input": "7 1000000000\n7 2 1 3 5 4 6", "output": ["1 6 40 201 705 1635 1854"]}, {"input": "10 11\n10 9 8 7 6 5 4 3 2 1", "output": ["1 9 9 0 1 5 5 0 1 0"]}]
|
block_completion_006456
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: We call an array $$$a$$$ of length $$$n$$$ fancy if for each $$$1 < i \le n$$$ it holds that $$$a_i = a_{i-1} + 1$$$.Let's call $$$f(p)$$$ applied to a permutation$$$^\dagger$$$ of length $$$n$$$ as the minimum number of subarrays it can be partitioned such that each one of them is fancy. For example $$$f([1,2,3]) = 1$$$, while $$$f([3,1,2]) = 2$$$ and $$$f([3,2,1]) = 3$$$.Given $$$n$$$ and a permutation $$$p$$$ of length $$$n$$$, we define a permutation $$$p'$$$ of length $$$n$$$ to be $$$k$$$-special if and only if: $$$p'$$$ is lexicographically smaller$$$^\ddagger$$$ than $$$p$$$, and $$$f(p') = k$$$. Your task is to count for each $$$1 \le k \le n$$$ the number of $$$k$$$-special permutations modulo $$$m$$$.$$$^\dagger$$$ A permutation is an array consisting of $$$n$$$ distinct integers from $$$1$$$ to $$$n$$$ in arbitrary order. For example, $$$[2,3,1,5,4]$$$ is a permutation, but $$$[1,2,2]$$$ is not a permutation ($$$2$$$ appears twice in the array) and $$$[1,3,4]$$$ is also not a permutation ($$$n=3$$$ but there is $$$4$$$ in the array).$$$^\ddagger$$$ A permutation $$$a$$$ of length $$$n$$$ is lexicographically smaller than a permutation $$$b$$$ of length $$$n$$$ if and only if the following holds: in the first position where $$$a$$$ and $$$b$$$ differ, the permutation $$$a$$$ has a smaller element than the corresponding element in $$$b$$$.
Input Specification: The first line contains two integers $$$n$$$ and $$$m$$$ ($$$1 \le n \le 2000$$$, $$$10 \le m \le 10^9$$$) — the length of the permutation and the required modulo. The second line contains $$$n$$$ distinct integers $$$p_1, p_2, \ldots, p_n$$$ ($$$1 \le p_i \le n$$$) — the permutation $$$p$$$.
Output Specification: Print $$$n$$$ integers, where the $$$k$$$-th integer is the number of $$$k$$$-special permutations modulo $$$m$$$.
Notes: NoteIn the first example, the permutations that are lexicographically smaller than $$$[1,3,4,2]$$$ are: $$$[1,2,3,4]$$$, $$$f([1,2,3,4])=1$$$; $$$[1,2,4,3]$$$, $$$f([1,2,4,3])=3$$$; $$$[1,3,2,4]$$$, $$$f([1,3,2,4])=4$$$. Thus our answer is $$$[1,0,1,1]$$$.In the second example, the permutations that are lexicographically smaller than $$$[3,2,1]$$$ are: $$$[1,2,3]$$$, $$$f([1,2,3])=1$$$; $$$[1,3,2]$$$, $$$f([1,3,2])=3$$$; $$$[2,1,3]$$$, $$$f([2,1,3])=3$$$; $$$[2,3,1]$$$, $$$f([2,3,1])=2$$$; $$$[3,1,2]$$$, $$$f([3,1,2])=2$$$. Thus our answer is $$$[1,2,2]$$$.
Code:
n, m = map(int, input().split())
def modmul(a, b, c = 0):
return (a * b + c) % m
comb = [[1]]
for i in range(2010):
prev = comb[-1]
nex = [1]
for i in range(i):
nex.append((prev[i] + prev[i + 1]) % m)
nex.append(1)
comb.append(nex)
fact = [1]
for i in range(1, 3000):
fact.append((i * fact[i - 1]) % m)
p = list(map(lambda x: int(x) - 1, input().split()))
rem = [1] * n
pairs = n - 1
base = 0
out = [[0] * (n + 1) for _ in range(n + 1)]
for i in range(n):
diff = [0] * 3
spec = [0] * 3
for j in range(p[i]):
d = 0
if rem[j] == 0:
continue
if j and rem[j - 1]:
d += 1
#if j < n - 1 and rem[j + 1]:
# d += 1
if i and j == p[i - 1] + 1:
spec[d] += 1
else:
# TODO: Your code here
for d in range(3):
pp = pairs - d
if pp < 0:
continue
if diff[d] == 0 and spec[d] == 0:
continue
remain = n - i - 1
for sq in range(pp + 1):
ways = comb[pp][sq]
order = remain - sq
assert order >= 0
ct = modmul(ways, fact[order])
out[base][sq] += modmul(ct, diff[d] + spec[d])
if spec[d]:
out[base][sq + 1] += ct
j = p[i]
rem[j] = 0
if j and rem[j - 1]:
pairs -= 1
if j < n - 1 and rem[j + 1]:
pairs -= 1
if i and p[i] == p[i - 1] + 1:
base += 1
while len(out) > 1:
prev = out.pop()
for i in range(n):
out[-1][i] += prev[i]
if i > 0:
out[-1][i] += prev[i - 1]
out = out[0]
res = []
for i in range(n):
basee = out[n - 1 - i]
for j in range(i):
basee -= modmul(res[j], comb[n - j - 1][n - i - 1])
#print(i, j, basee)
res.append(basee % m)
print(' '.join(map(str, res)))
|
n, m = map(int, input().split())
def modmul(a, b, c = 0):
return (a * b + c) % m
comb = [[1]]
for i in range(2010):
prev = comb[-1]
nex = [1]
for i in range(i):
nex.append((prev[i] + prev[i + 1]) % m)
nex.append(1)
comb.append(nex)
fact = [1]
for i in range(1, 3000):
fact.append((i * fact[i - 1]) % m)
p = list(map(lambda x: int(x) - 1, input().split()))
rem = [1] * n
pairs = n - 1
base = 0
out = [[0] * (n + 1) for _ in range(n + 1)]
for i in range(n):
diff = [0] * 3
spec = [0] * 3
for j in range(p[i]):
d = 0
if rem[j] == 0:
continue
if j and rem[j - 1]:
d += 1
#if j < n - 1 and rem[j + 1]:
# d += 1
if i and j == p[i - 1] + 1:
spec[d] += 1
else:
{{completion}}
for d in range(3):
pp = pairs - d
if pp < 0:
continue
if diff[d] == 0 and spec[d] == 0:
continue
remain = n - i - 1
for sq in range(pp + 1):
ways = comb[pp][sq]
order = remain - sq
assert order >= 0
ct = modmul(ways, fact[order])
out[base][sq] += modmul(ct, diff[d] + spec[d])
if spec[d]:
out[base][sq + 1] += ct
j = p[i]
rem[j] = 0
if j and rem[j - 1]:
pairs -= 1
if j < n - 1 and rem[j + 1]:
pairs -= 1
if i and p[i] == p[i - 1] + 1:
base += 1
while len(out) > 1:
prev = out.pop()
for i in range(n):
out[-1][i] += prev[i]
if i > 0:
out[-1][i] += prev[i - 1]
out = out[0]
res = []
for i in range(n):
basee = out[n - 1 - i]
for j in range(i):
basee -= modmul(res[j], comb[n - j - 1][n - i - 1])
#print(i, j, basee)
res.append(basee % m)
print(' '.join(map(str, res)))
|
diff[d] += 1
|
[{"input": "4 666012\n1 3 4 2", "output": ["1 0 1 1"]}, {"input": "3 10\n3 2 1", "output": ["1 2 2"]}, {"input": "7 1000000000\n7 2 1 3 5 4 6", "output": ["1 6 40 201 705 1635 1854"]}, {"input": "10 11\n10 9 8 7 6 5 4 3 2 1", "output": ["1 9 9 0 1 5 5 0 1 0"]}]
|
block_completion_006457
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given an array of $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$You can apply the following operation an arbitrary number of times: select an index $$$i$$$ ($$$1 \le i \le n$$$) and replace the value of the element $$$a_i$$$ with the value $$$a_i + (a_i \bmod 10)$$$, where $$$a_i \bmod 10$$$ is the remainder of the integer dividing $$$a_i$$$ by $$$10$$$. For a single index (value $$$i$$$), this operation can be applied multiple times. If the operation is applied repeatedly to the same index, then the current value of $$$a_i$$$ is taken into account each time. For example, if $$$a_i=47$$$ then after the first operation we get $$$a_i=47+7=54$$$, and after the second operation we get $$$a_i=54+4=58$$$.Check if it is possible to make all array elements equal by applying multiple (possibly zero) operations.For example, you have an array $$$[6, 11]$$$. Let's apply this operation to the first element of the array. Let's replace $$$a_1 = 6$$$ with $$$a_1 + (a_1 \bmod 10) = 6 + (6 \bmod 10) = 6 + 6 = 12$$$. We get the array $$$[12, 11]$$$. Then apply this operation to the second element of the array. Let's replace $$$a_2 = 11$$$ with $$$a_2 + (a_2 \bmod 10) = 11 + (11 \bmod 10) = 11 + 1 = 12$$$. We get the array $$$[12, 12]$$$. Thus, by applying $$$2$$$ operations, you can make all elements of an array equal.
Input Specification: The first line contains one integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. What follows is a description of each test case. The first line of each test case contains one integer $$$n$$$ ($$$1 \le n \le 2 \cdot 10^5$$$) — the size of the array. The second line of each test case contains $$$n$$$ integers $$$a_i$$$ ($$$0 \le a_i \le 10^9$$$) — array elements. It is guaranteed that the sum of $$$n$$$ over all test cases does not exceed $$$2 \cdot 10^5$$$.
Output Specification: For each test case print: YES if it is possible to make all array elements equal; NO otherwise. You can print YES and NO in any case (for example, the strings yEs, yes, Yes and YES will be recognized as a positive answer) .
Notes: NoteThe first test case is clarified above.In the second test case, it is impossible to make all array elements equal.In the third test case, you need to apply this operation once to all elements equal to $$$5$$$.In the fourth test case, you need to apply this operation to all elements until they become equal to $$$8$$$.In the fifth test case, it is impossible to make all array elements equal.In the sixth test case, you need to apply this operation to all elements until they become equal to $$$102$$$.
Code:
# Problem - https://codeforces.com/contest/1714/problem/E
# Editorial - https://codeforces.com/blog/entry/105549
# Tags - brute force, math, number theory, *1400
import sys
import typing
# Read stdin and remove newline elements
stdin = [line.strip() for line in sys.stdin.readlines() if line != '\n']
stdin_counter = 0
cycle_for_2 = 20 # 2 => 2 + 2 => 4 + 4 => 8 + 8 => 16 + 6 => 22 - 2 = 20
def take_from_stdin():
global stdin_counter
result = stdin[stdin_counter]
stdin_counter += 1
return result
def solve(arr: typing.List[int]):
has_2 = False
has_0 = False
for i in range(len(arr)):
mod_10 = arr[i] % 10
if mod_10 == 2:
has_2 = True
if mod_10 == 0:
has_0 = True
while mod_10 != 2 and mod_10 != 0:
arr[i] += mod_10
mod_10 = arr[i] % 10
if mod_10 == 2:
# TODO: Your code here
if mod_10 == 0:
has_0 = True
if has_0 and has_2:
return "NO"
if has_2:
for i in range(len(arr)):
arr[i] = arr[i] % 20
if len(set(arr)) == 1:
return "YES"
return "NO"
def main():
test_count = int(take_from_stdin())
for _ in range(test_count):
_ = int(take_from_stdin())
arr = [int(x) for x in take_from_stdin().split()]
print(solve(arr))
main()
|
# Problem - https://codeforces.com/contest/1714/problem/E
# Editorial - https://codeforces.com/blog/entry/105549
# Tags - brute force, math, number theory, *1400
import sys
import typing
# Read stdin and remove newline elements
stdin = [line.strip() for line in sys.stdin.readlines() if line != '\n']
stdin_counter = 0
cycle_for_2 = 20 # 2 => 2 + 2 => 4 + 4 => 8 + 8 => 16 + 6 => 22 - 2 = 20
def take_from_stdin():
global stdin_counter
result = stdin[stdin_counter]
stdin_counter += 1
return result
def solve(arr: typing.List[int]):
has_2 = False
has_0 = False
for i in range(len(arr)):
mod_10 = arr[i] % 10
if mod_10 == 2:
has_2 = True
if mod_10 == 0:
has_0 = True
while mod_10 != 2 and mod_10 != 0:
arr[i] += mod_10
mod_10 = arr[i] % 10
if mod_10 == 2:
{{completion}}
if mod_10 == 0:
has_0 = True
if has_0 and has_2:
return "NO"
if has_2:
for i in range(len(arr)):
arr[i] = arr[i] % 20
if len(set(arr)) == 1:
return "YES"
return "NO"
def main():
test_count = int(take_from_stdin())
for _ in range(test_count):
_ = int(take_from_stdin())
arr = [int(x) for x in take_from_stdin().split()]
print(solve(arr))
main()
|
has_2 = True
|
[{"input": "10\n\n2\n\n6 11\n\n3\n\n2 18 22\n\n5\n\n5 10 5 10 5\n\n4\n\n1 2 4 8\n\n2\n\n4 5\n\n3\n\n93 96 102\n\n2\n\n40 6\n\n2\n\n50 30\n\n2\n\n22 44\n\n2\n\n1 5", "output": ["Yes\nNo\nYes\nYes\nNo\nYes\nNo\nNo\nYes\nNo"]}]
|
block_completion_006707
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given an array of $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$You can apply the following operation an arbitrary number of times: select an index $$$i$$$ ($$$1 \le i \le n$$$) and replace the value of the element $$$a_i$$$ with the value $$$a_i + (a_i \bmod 10)$$$, where $$$a_i \bmod 10$$$ is the remainder of the integer dividing $$$a_i$$$ by $$$10$$$. For a single index (value $$$i$$$), this operation can be applied multiple times. If the operation is applied repeatedly to the same index, then the current value of $$$a_i$$$ is taken into account each time. For example, if $$$a_i=47$$$ then after the first operation we get $$$a_i=47+7=54$$$, and after the second operation we get $$$a_i=54+4=58$$$.Check if it is possible to make all array elements equal by applying multiple (possibly zero) operations.For example, you have an array $$$[6, 11]$$$. Let's apply this operation to the first element of the array. Let's replace $$$a_1 = 6$$$ with $$$a_1 + (a_1 \bmod 10) = 6 + (6 \bmod 10) = 6 + 6 = 12$$$. We get the array $$$[12, 11]$$$. Then apply this operation to the second element of the array. Let's replace $$$a_2 = 11$$$ with $$$a_2 + (a_2 \bmod 10) = 11 + (11 \bmod 10) = 11 + 1 = 12$$$. We get the array $$$[12, 12]$$$. Thus, by applying $$$2$$$ operations, you can make all elements of an array equal.
Input Specification: The first line contains one integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. What follows is a description of each test case. The first line of each test case contains one integer $$$n$$$ ($$$1 \le n \le 2 \cdot 10^5$$$) — the size of the array. The second line of each test case contains $$$n$$$ integers $$$a_i$$$ ($$$0 \le a_i \le 10^9$$$) — array elements. It is guaranteed that the sum of $$$n$$$ over all test cases does not exceed $$$2 \cdot 10^5$$$.
Output Specification: For each test case print: YES if it is possible to make all array elements equal; NO otherwise. You can print YES and NO in any case (for example, the strings yEs, yes, Yes and YES will be recognized as a positive answer) .
Notes: NoteThe first test case is clarified above.In the second test case, it is impossible to make all array elements equal.In the third test case, you need to apply this operation once to all elements equal to $$$5$$$.In the fourth test case, you need to apply this operation to all elements until they become equal to $$$8$$$.In the fifth test case, it is impossible to make all array elements equal.In the sixth test case, you need to apply this operation to all elements until they become equal to $$$102$$$.
Code:
# Problem - https://codeforces.com/contest/1714/problem/E
# Editorial - https://codeforces.com/blog/entry/105549
# Tags - brute force, math, number theory, *1400
import sys
import typing
# Read stdin and remove newline elements
stdin = [line.strip() for line in sys.stdin.readlines() if line != '\n']
stdin_counter = 0
cycle_for_2 = 20 # 2 => 2 + 2 => 4 + 4 => 8 + 8 => 16 + 6 => 22 - 2 = 20
def take_from_stdin():
global stdin_counter
result = stdin[stdin_counter]
stdin_counter += 1
return result
def solve(arr: typing.List[int]):
has_2 = False
has_0 = False
for i in range(len(arr)):
mod_10 = arr[i] % 10
if mod_10 == 2:
has_2 = True
if mod_10 == 0:
has_0 = True
while mod_10 != 2 and mod_10 != 0:
arr[i] += mod_10
mod_10 = arr[i] % 10
if mod_10 == 2:
has_2 = True
if mod_10 == 0:
# TODO: Your code here
if has_0 and has_2:
return "NO"
if has_2:
for i in range(len(arr)):
arr[i] = arr[i] % 20
if len(set(arr)) == 1:
return "YES"
return "NO"
def main():
test_count = int(take_from_stdin())
for _ in range(test_count):
_ = int(take_from_stdin())
arr = [int(x) for x in take_from_stdin().split()]
print(solve(arr))
main()
|
# Problem - https://codeforces.com/contest/1714/problem/E
# Editorial - https://codeforces.com/blog/entry/105549
# Tags - brute force, math, number theory, *1400
import sys
import typing
# Read stdin and remove newline elements
stdin = [line.strip() for line in sys.stdin.readlines() if line != '\n']
stdin_counter = 0
cycle_for_2 = 20 # 2 => 2 + 2 => 4 + 4 => 8 + 8 => 16 + 6 => 22 - 2 = 20
def take_from_stdin():
global stdin_counter
result = stdin[stdin_counter]
stdin_counter += 1
return result
def solve(arr: typing.List[int]):
has_2 = False
has_0 = False
for i in range(len(arr)):
mod_10 = arr[i] % 10
if mod_10 == 2:
has_2 = True
if mod_10 == 0:
has_0 = True
while mod_10 != 2 and mod_10 != 0:
arr[i] += mod_10
mod_10 = arr[i] % 10
if mod_10 == 2:
has_2 = True
if mod_10 == 0:
{{completion}}
if has_0 and has_2:
return "NO"
if has_2:
for i in range(len(arr)):
arr[i] = arr[i] % 20
if len(set(arr)) == 1:
return "YES"
return "NO"
def main():
test_count = int(take_from_stdin())
for _ in range(test_count):
_ = int(take_from_stdin())
arr = [int(x) for x in take_from_stdin().split()]
print(solve(arr))
main()
|
has_0 = True
|
[{"input": "10\n\n2\n\n6 11\n\n3\n\n2 18 22\n\n5\n\n5 10 5 10 5\n\n4\n\n1 2 4 8\n\n2\n\n4 5\n\n3\n\n93 96 102\n\n2\n\n40 6\n\n2\n\n50 30\n\n2\n\n22 44\n\n2\n\n1 5", "output": ["Yes\nNo\nYes\nYes\nNo\nYes\nNo\nNo\nYes\nNo"]}]
|
block_completion_006708
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given a connected undirected graph consisting of $$$n$$$ vertices and $$$m$$$ edges. The weight of the $$$i$$$-th edge is $$$i$$$.Here is a wrong algorithm of finding a minimum spanning tree (MST) of a graph:vis := an array of length ns := a set of edgesfunction dfs(u): vis[u] := true iterate through each edge (u, v) in the order from smallest to largest edge weight if vis[v] = false add edge (u, v) into the set (s) dfs(v)function findMST(u): reset all elements of (vis) to false reset the edge set (s) to empty dfs(u) return the edge set (s)Each of the calls findMST(1), findMST(2), ..., findMST(n) gives you a spanning tree of the graph. Determine which of these trees are minimum spanning trees.
Input Specification: The first line of the input contains two integers $$$n$$$, $$$m$$$ ($$$2\le n\le 10^5$$$, $$$n-1\le m\le 2\cdot 10^5$$$) — the number of vertices and the number of edges in the graph. Each of the following $$$m$$$ lines contains two integers $$$u_i$$$ and $$$v_i$$$ ($$$1\le u_i, v_i\le n$$$, $$$u_i\ne v_i$$$), describing an undirected edge $$$(u_i,v_i)$$$ in the graph. The $$$i$$$-th edge in the input has weight $$$i$$$. It is guaranteed that the graph is connected and there is at most one edge between any pair of vertices.
Output Specification: You need to output a binary string $$$s$$$, where $$$s_i=1$$$ if findMST(i) creates an MST, and $$$s_i = 0$$$ otherwise.
Notes: NoteHere is the graph given in the first example. There is only one minimum spanning tree in this graph. A minimum spanning tree is $$$(1,2),(3,5),(1,3),(2,4)$$$ which has weight $$$1+2+3+5=11$$$.Here is a part of the process of calling findMST(1): reset the array vis and the edge set s; calling dfs(1); vis[1] := true; iterate through each edge $$$(1,2),(1,3)$$$; add edge $$$(1,2)$$$ into the edge set s, calling dfs(2): vis[2] := true iterate through each edge $$$(2,1),(2,3),(2,4)$$$; because vis[1] = true, ignore the edge $$$(2,1)$$$; add edge $$$(2,3)$$$ into the edge set s, calling dfs(3): ... In the end, it will select edges $$$(1,2),(2,3),(3,5),(2,4)$$$ with total weight $$$1+4+2+5=12>11$$$, so findMST(1) does not find a minimum spanning tree.It can be shown that the other trees are all MSTs, so the answer is 01111.
Code:
input = __import__('sys').stdin.readline
class DisjointSetUnion(object):
def __init__(self, n):
self.n = n
self.par = [i for i in range(n)]
def find(self, x):
toupdate = []
while x != self.par[x]:
# TODO: Your code here
for u in toupdate:
self.par[u] = x
return x
def merge(self, u, v):
u = self.find(u)
v = self.find(v)
if u != v:
self.par[u] = v
return u != v
n, m = map(int, input().split())
dsu = DisjointSetUnion(n)
adj = [[] for _ in range(n)] # adjlist of the MST
outOfTrees = [] # outside the MST
for _ in range(m):
u, v = map(lambda x: int(x)-1, input().split())
if dsu.merge(u, v):
adj[u].append(v)
adj[v].append(u)
else:
outOfTrees.append((u, v))
# print('outOfTrees', outOfTrees)
# init lca
jump = [[0] * n]
depth = [0] * n
stack = [(0, -1)] # (u, par)
while len(stack) > 0:
u, par = stack.pop()
jump[0][u] = par
for v in adj[u]:
if v != par:
depth[v] = depth[u] + 1
stack.append((v, u))
for j in range(20):
jump.append([jump[-1][jump[-1][u]] for u in range(n)])
def moveTo(u, step):
for i in range(20):
if (step >> i) & 1 == 1:
u = jump[i][u]
return u
def lca(u, v):
if depth[u] < depth[v]:
u, v = v, u
u = moveTo(u, depth[u] - depth[v])
if u == v:
return u
for i in range(19, -1, -1):
if jump[i][u] != jump[i][v]:
u, v = jump[i][u], jump[i][v]
return jump[0][u]
# check each edges out of the tree
psum = [0] * n
for u, v in outOfTrees:
# nodes in the path (and its subtrees) u to v (not including u & v) will select edge u-v in their dfs process
r = lca(u, v)
# print('lca', u+1, v+1, r+1)
if r == u:
psum[moveTo(v, depth[v] - depth[u] - 1)] += 1
psum[v] -= 1
elif r == v:
psum[moveTo(u, depth[u] - depth[v] - 1)] += 1
psum[u] -= 1
else:
psum[0] += 1
psum[u] -= 1
psum[v] -= 1
# print('psum_initial', psum)
# print('applyToChild', applyToChild)
stack = [(0, -1)] # (u, par)
while len(stack) > 0:
u, par = stack.pop()
for v in adj[u]:
if v != par:
psum[v] += psum[u]
stack.append((v, u))
# print('psum', psum)
print(''.join('1' if psum[u] == 0 else '0' for u in range(n)))
|
input = __import__('sys').stdin.readline
class DisjointSetUnion(object):
def __init__(self, n):
self.n = n
self.par = [i for i in range(n)]
def find(self, x):
toupdate = []
while x != self.par[x]:
{{completion}}
for u in toupdate:
self.par[u] = x
return x
def merge(self, u, v):
u = self.find(u)
v = self.find(v)
if u != v:
self.par[u] = v
return u != v
n, m = map(int, input().split())
dsu = DisjointSetUnion(n)
adj = [[] for _ in range(n)] # adjlist of the MST
outOfTrees = [] # outside the MST
for _ in range(m):
u, v = map(lambda x: int(x)-1, input().split())
if dsu.merge(u, v):
adj[u].append(v)
adj[v].append(u)
else:
outOfTrees.append((u, v))
# print('outOfTrees', outOfTrees)
# init lca
jump = [[0] * n]
depth = [0] * n
stack = [(0, -1)] # (u, par)
while len(stack) > 0:
u, par = stack.pop()
jump[0][u] = par
for v in adj[u]:
if v != par:
depth[v] = depth[u] + 1
stack.append((v, u))
for j in range(20):
jump.append([jump[-1][jump[-1][u]] for u in range(n)])
def moveTo(u, step):
for i in range(20):
if (step >> i) & 1 == 1:
u = jump[i][u]
return u
def lca(u, v):
if depth[u] < depth[v]:
u, v = v, u
u = moveTo(u, depth[u] - depth[v])
if u == v:
return u
for i in range(19, -1, -1):
if jump[i][u] != jump[i][v]:
u, v = jump[i][u], jump[i][v]
return jump[0][u]
# check each edges out of the tree
psum = [0] * n
for u, v in outOfTrees:
# nodes in the path (and its subtrees) u to v (not including u & v) will select edge u-v in their dfs process
r = lca(u, v)
# print('lca', u+1, v+1, r+1)
if r == u:
psum[moveTo(v, depth[v] - depth[u] - 1)] += 1
psum[v] -= 1
elif r == v:
psum[moveTo(u, depth[u] - depth[v] - 1)] += 1
psum[u] -= 1
else:
psum[0] += 1
psum[u] -= 1
psum[v] -= 1
# print('psum_initial', psum)
# print('applyToChild', applyToChild)
stack = [(0, -1)] # (u, par)
while len(stack) > 0:
u, par = stack.pop()
for v in adj[u]:
if v != par:
psum[v] += psum[u]
stack.append((v, u))
# print('psum', psum)
print(''.join('1' if psum[u] == 0 else '0' for u in range(n)))
|
toupdate.append(x)
x = self.par[x]
|
[{"input": "5 5\n1 2\n3 5\n1 3\n3 2\n4 2", "output": ["01111"]}, {"input": "10 11\n1 2\n2 5\n3 4\n4 2\n8 1\n4 5\n10 5\n9 5\n8 2\n5 7\n4 6", "output": ["0011111011"]}]
|
block_completion_006772
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given a connected undirected graph consisting of $$$n$$$ vertices and $$$m$$$ edges. The weight of the $$$i$$$-th edge is $$$i$$$.Here is a wrong algorithm of finding a minimum spanning tree (MST) of a graph:vis := an array of length ns := a set of edgesfunction dfs(u): vis[u] := true iterate through each edge (u, v) in the order from smallest to largest edge weight if vis[v] = false add edge (u, v) into the set (s) dfs(v)function findMST(u): reset all elements of (vis) to false reset the edge set (s) to empty dfs(u) return the edge set (s)Each of the calls findMST(1), findMST(2), ..., findMST(n) gives you a spanning tree of the graph. Determine which of these trees are minimum spanning trees.
Input Specification: The first line of the input contains two integers $$$n$$$, $$$m$$$ ($$$2\le n\le 10^5$$$, $$$n-1\le m\le 2\cdot 10^5$$$) — the number of vertices and the number of edges in the graph. Each of the following $$$m$$$ lines contains two integers $$$u_i$$$ and $$$v_i$$$ ($$$1\le u_i, v_i\le n$$$, $$$u_i\ne v_i$$$), describing an undirected edge $$$(u_i,v_i)$$$ in the graph. The $$$i$$$-th edge in the input has weight $$$i$$$. It is guaranteed that the graph is connected and there is at most one edge between any pair of vertices.
Output Specification: You need to output a binary string $$$s$$$, where $$$s_i=1$$$ if findMST(i) creates an MST, and $$$s_i = 0$$$ otherwise.
Notes: NoteHere is the graph given in the first example. There is only one minimum spanning tree in this graph. A minimum spanning tree is $$$(1,2),(3,5),(1,3),(2,4)$$$ which has weight $$$1+2+3+5=11$$$.Here is a part of the process of calling findMST(1): reset the array vis and the edge set s; calling dfs(1); vis[1] := true; iterate through each edge $$$(1,2),(1,3)$$$; add edge $$$(1,2)$$$ into the edge set s, calling dfs(2): vis[2] := true iterate through each edge $$$(2,1),(2,3),(2,4)$$$; because vis[1] = true, ignore the edge $$$(2,1)$$$; add edge $$$(2,3)$$$ into the edge set s, calling dfs(3): ... In the end, it will select edges $$$(1,2),(2,3),(3,5),(2,4)$$$ with total weight $$$1+4+2+5=12>11$$$, so findMST(1) does not find a minimum spanning tree.It can be shown that the other trees are all MSTs, so the answer is 01111.
Code:
input = __import__('sys').stdin.readline
class DisjointSetUnion(object):
def __init__(self, n):
self.n = n
self.par = [i for i in range(n)]
def find(self, x):
toupdate = []
while x != self.par[x]:
toupdate.append(x)
x = self.par[x]
for u in toupdate:
# TODO: Your code here
return x
def merge(self, u, v):
u = self.find(u)
v = self.find(v)
if u != v:
self.par[u] = v
return u != v
n, m = map(int, input().split())
dsu = DisjointSetUnion(n)
adj = [[] for _ in range(n)] # adjlist of the MST
outOfTrees = [] # outside the MST
for _ in range(m):
u, v = map(lambda x: int(x)-1, input().split())
if dsu.merge(u, v):
adj[u].append(v)
adj[v].append(u)
else:
outOfTrees.append((u, v))
# print('outOfTrees', outOfTrees)
# init lca
jump = [[0] * n]
depth = [0] * n
stack = [(0, -1)] # (u, par)
while len(stack) > 0:
u, par = stack.pop()
jump[0][u] = par
for v in adj[u]:
if v != par:
depth[v] = depth[u] + 1
stack.append((v, u))
for j in range(20):
jump.append([jump[-1][jump[-1][u]] for u in range(n)])
def moveTo(u, step):
for i in range(20):
if (step >> i) & 1 == 1:
u = jump[i][u]
return u
def lca(u, v):
if depth[u] < depth[v]:
u, v = v, u
u = moveTo(u, depth[u] - depth[v])
if u == v:
return u
for i in range(19, -1, -1):
if jump[i][u] != jump[i][v]:
u, v = jump[i][u], jump[i][v]
return jump[0][u]
# check each edges out of the tree
psum = [0] * n
for u, v in outOfTrees:
# nodes in the path (and its subtrees) u to v (not including u & v) will select edge u-v in their dfs process
r = lca(u, v)
# print('lca', u+1, v+1, r+1)
if r == u:
psum[moveTo(v, depth[v] - depth[u] - 1)] += 1
psum[v] -= 1
elif r == v:
psum[moveTo(u, depth[u] - depth[v] - 1)] += 1
psum[u] -= 1
else:
psum[0] += 1
psum[u] -= 1
psum[v] -= 1
# print('psum_initial', psum)
# print('applyToChild', applyToChild)
stack = [(0, -1)] # (u, par)
while len(stack) > 0:
u, par = stack.pop()
for v in adj[u]:
if v != par:
psum[v] += psum[u]
stack.append((v, u))
# print('psum', psum)
print(''.join('1' if psum[u] == 0 else '0' for u in range(n)))
|
input = __import__('sys').stdin.readline
class DisjointSetUnion(object):
def __init__(self, n):
self.n = n
self.par = [i for i in range(n)]
def find(self, x):
toupdate = []
while x != self.par[x]:
toupdate.append(x)
x = self.par[x]
for u in toupdate:
{{completion}}
return x
def merge(self, u, v):
u = self.find(u)
v = self.find(v)
if u != v:
self.par[u] = v
return u != v
n, m = map(int, input().split())
dsu = DisjointSetUnion(n)
adj = [[] for _ in range(n)] # adjlist of the MST
outOfTrees = [] # outside the MST
for _ in range(m):
u, v = map(lambda x: int(x)-1, input().split())
if dsu.merge(u, v):
adj[u].append(v)
adj[v].append(u)
else:
outOfTrees.append((u, v))
# print('outOfTrees', outOfTrees)
# init lca
jump = [[0] * n]
depth = [0] * n
stack = [(0, -1)] # (u, par)
while len(stack) > 0:
u, par = stack.pop()
jump[0][u] = par
for v in adj[u]:
if v != par:
depth[v] = depth[u] + 1
stack.append((v, u))
for j in range(20):
jump.append([jump[-1][jump[-1][u]] for u in range(n)])
def moveTo(u, step):
for i in range(20):
if (step >> i) & 1 == 1:
u = jump[i][u]
return u
def lca(u, v):
if depth[u] < depth[v]:
u, v = v, u
u = moveTo(u, depth[u] - depth[v])
if u == v:
return u
for i in range(19, -1, -1):
if jump[i][u] != jump[i][v]:
u, v = jump[i][u], jump[i][v]
return jump[0][u]
# check each edges out of the tree
psum = [0] * n
for u, v in outOfTrees:
# nodes in the path (and its subtrees) u to v (not including u & v) will select edge u-v in their dfs process
r = lca(u, v)
# print('lca', u+1, v+1, r+1)
if r == u:
psum[moveTo(v, depth[v] - depth[u] - 1)] += 1
psum[v] -= 1
elif r == v:
psum[moveTo(u, depth[u] - depth[v] - 1)] += 1
psum[u] -= 1
else:
psum[0] += 1
psum[u] -= 1
psum[v] -= 1
# print('psum_initial', psum)
# print('applyToChild', applyToChild)
stack = [(0, -1)] # (u, par)
while len(stack) > 0:
u, par = stack.pop()
for v in adj[u]:
if v != par:
psum[v] += psum[u]
stack.append((v, u))
# print('psum', psum)
print(''.join('1' if psum[u] == 0 else '0' for u in range(n)))
|
self.par[u] = x
|
[{"input": "5 5\n1 2\n3 5\n1 3\n3 2\n4 2", "output": ["01111"]}, {"input": "10 11\n1 2\n2 5\n3 4\n4 2\n8 1\n4 5\n10 5\n9 5\n8 2\n5 7\n4 6", "output": ["0011111011"]}]
|
block_completion_006773
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You have an array $$$a$$$ of size $$$n$$$ consisting only of zeroes and ones. You can do the following operation: choose two indices $$$1 \le i , j \le n$$$, $$$i \ne j$$$, add $$$a_{i}$$$ to $$$a_{j}$$$, remove $$$a_{i}$$$ from $$$a$$$. Note that elements of $$$a$$$ can become bigger than $$$1$$$ after performing some operations. Also note that $$$n$$$ becomes $$$1$$$ less after the operation.What is the minimum number of operations needed to make $$$a$$$ non-decreasing, i. e. that each element is not less than the previous element?
Input Specification: Each test contains multiple test cases. The first line contains the number of test cases $$$t$$$ ($$$1 \le t \le 10^4$$$). The description of the test cases follows. The first line of each test case contains an integer $$$n$$$ ($$$1 \le n \le 10^5$$$), the size of array $$$a$$$. Next line contains $$$n$$$ integers $$$a_{1}, a_{2}, \ldots a_{n}$$$ ($$$a_i$$$ is $$$0$$$ or $$$1$$$), elements of array $$$a$$$. It's guaranteed that sum of $$$n$$$ over all test cases doesn't exceed $$$2 \cdot 10^5$$$.
Output Specification: For each test case print a single integer, minimum number of operations needed to make $$$a$$$ non-decreasing.
Notes: NoteIn the first test case, $$$a$$$ is already non-decreasing, so you don't need to do any operations and the answer is $$$0$$$.In the second test case, you can perform an operation for $$$i = 1$$$ and $$$j = 5$$$, so $$$a$$$ will be equal to $$$[0, 0, 1, 2]$$$ and it becomes non-decreasing.In the third test case, you can perform an operation for $$$i = 2$$$ and $$$j = 1$$$, so $$$a$$$ will be equal to $$$[1]$$$ and it becomes non-decreasing.
Code:
import sys
tokens = (token for token in sys.stdin.read().split())
N = int(next(tokens))
for i in range(N):
Q = int(next(tokens))
arr = []
count = 0
for i in range(Q):
arr.append(int(next(tokens)))
i = 0
j = len(arr) - 1
while True:
while True:
if arr[i] == 1 or i == j:
break
else:
# TODO: Your code here
while True:
if arr[j] == 0 or j == i:
break
else:
j-=1
if i == j:
break
sec = arr[i]
arr [i] = arr[j]
arr [j] = sec
count += 1
print (count)
|
import sys
tokens = (token for token in sys.stdin.read().split())
N = int(next(tokens))
for i in range(N):
Q = int(next(tokens))
arr = []
count = 0
for i in range(Q):
arr.append(int(next(tokens)))
i = 0
j = len(arr) - 1
while True:
while True:
if arr[i] == 1 or i == j:
break
else:
{{completion}}
while True:
if arr[j] == 0 or j == i:
break
else:
j-=1
if i == j:
break
sec = arr[i]
arr [i] = arr[j]
arr [j] = sec
count += 1
print (count)
|
i+=1
|
[{"input": "4\n\n8\n\n0 0 1 1 1 1 1 1\n\n5\n\n1 0 0 1 1\n\n2\n\n1 0\n\n11\n\n1 1 0 0 1 0 0 1 1 1 0", "output": ["0\n1\n1\n3"]}]
|
block_completion_006955
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You have an array $$$a$$$ of size $$$n$$$ consisting only of zeroes and ones. You can do the following operation: choose two indices $$$1 \le i , j \le n$$$, $$$i \ne j$$$, add $$$a_{i}$$$ to $$$a_{j}$$$, remove $$$a_{i}$$$ from $$$a$$$. Note that elements of $$$a$$$ can become bigger than $$$1$$$ after performing some operations. Also note that $$$n$$$ becomes $$$1$$$ less after the operation.What is the minimum number of operations needed to make $$$a$$$ non-decreasing, i. e. that each element is not less than the previous element?
Input Specification: Each test contains multiple test cases. The first line contains the number of test cases $$$t$$$ ($$$1 \le t \le 10^4$$$). The description of the test cases follows. The first line of each test case contains an integer $$$n$$$ ($$$1 \le n \le 10^5$$$), the size of array $$$a$$$. Next line contains $$$n$$$ integers $$$a_{1}, a_{2}, \ldots a_{n}$$$ ($$$a_i$$$ is $$$0$$$ or $$$1$$$), elements of array $$$a$$$. It's guaranteed that sum of $$$n$$$ over all test cases doesn't exceed $$$2 \cdot 10^5$$$.
Output Specification: For each test case print a single integer, minimum number of operations needed to make $$$a$$$ non-decreasing.
Notes: NoteIn the first test case, $$$a$$$ is already non-decreasing, so you don't need to do any operations and the answer is $$$0$$$.In the second test case, you can perform an operation for $$$i = 1$$$ and $$$j = 5$$$, so $$$a$$$ will be equal to $$$[0, 0, 1, 2]$$$ and it becomes non-decreasing.In the third test case, you can perform an operation for $$$i = 2$$$ and $$$j = 1$$$, so $$$a$$$ will be equal to $$$[1]$$$ and it becomes non-decreasing.
Code:
import sys
tokens = (token for token in sys.stdin.read().split())
N = int(next(tokens))
for i in range(N):
Q = int(next(tokens))
arr = []
count = 0
for i in range(Q):
arr.append(int(next(tokens)))
i = 0
j = len(arr) - 1
while True:
while True:
if arr[i] == 1 or i == j:
break
else:
i+=1
while True:
if arr[j] == 0 or j == i:
break
else:
# TODO: Your code here
if i == j:
break
sec = arr[i]
arr [i] = arr[j]
arr [j] = sec
count += 1
print (count)
|
import sys
tokens = (token for token in sys.stdin.read().split())
N = int(next(tokens))
for i in range(N):
Q = int(next(tokens))
arr = []
count = 0
for i in range(Q):
arr.append(int(next(tokens)))
i = 0
j = len(arr) - 1
while True:
while True:
if arr[i] == 1 or i == j:
break
else:
i+=1
while True:
if arr[j] == 0 or j == i:
break
else:
{{completion}}
if i == j:
break
sec = arr[i]
arr [i] = arr[j]
arr [j] = sec
count += 1
print (count)
|
j-=1
|
[{"input": "4\n\n8\n\n0 0 1 1 1 1 1 1\n\n5\n\n1 0 0 1 1\n\n2\n\n1 0\n\n11\n\n1 1 0 0 1 0 0 1 1 1 0", "output": ["0\n1\n1\n3"]}]
|
block_completion_006956
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You have an array $$$a$$$ of size $$$n$$$ consisting only of zeroes and ones. You can do the following operation: choose two indices $$$1 \le i , j \le n$$$, $$$i \ne j$$$, add $$$a_{i}$$$ to $$$a_{j}$$$, remove $$$a_{i}$$$ from $$$a$$$. Note that elements of $$$a$$$ can become bigger than $$$1$$$ after performing some operations. Also note that $$$n$$$ becomes $$$1$$$ less after the operation.What is the minimum number of operations needed to make $$$a$$$ non-decreasing, i. e. that each element is not less than the previous element?
Input Specification: Each test contains multiple test cases. The first line contains the number of test cases $$$t$$$ ($$$1 \le t \le 10^4$$$). The description of the test cases follows. The first line of each test case contains an integer $$$n$$$ ($$$1 \le n \le 10^5$$$), the size of array $$$a$$$. Next line contains $$$n$$$ integers $$$a_{1}, a_{2}, \ldots a_{n}$$$ ($$$a_i$$$ is $$$0$$$ or $$$1$$$), elements of array $$$a$$$. It's guaranteed that sum of $$$n$$$ over all test cases doesn't exceed $$$2 \cdot 10^5$$$.
Output Specification: For each test case print a single integer, minimum number of operations needed to make $$$a$$$ non-decreasing.
Notes: NoteIn the first test case, $$$a$$$ is already non-decreasing, so you don't need to do any operations and the answer is $$$0$$$.In the second test case, you can perform an operation for $$$i = 1$$$ and $$$j = 5$$$, so $$$a$$$ will be equal to $$$[0, 0, 1, 2]$$$ and it becomes non-decreasing.In the third test case, you can perform an operation for $$$i = 2$$$ and $$$j = 1$$$, so $$$a$$$ will be equal to $$$[1]$$$ and it becomes non-decreasing.
Code:
from sys import stdin
from collections import deque
lst = list(map(int, stdin.read().split()))
_s = 0
def inp(n=1):
global _s
ret = lst[_s:_s + n]
_s += n
return ret
def inp1():
return inp()[0]
t = inp1()
for _ in range(t):
n = inp1()
a = deque(inp(n))
ret = 0
sm = sum(a)
if list(a) != sorted(a):
while len(a) > 1 and sm > 0:
if a.pop() == 0:
ret += 1
while len(a) > 0 and a.popleft() == 0:
# TODO: Your code here
sm -= 1
else: sm -= 1
print(ret)
|
from sys import stdin
from collections import deque
lst = list(map(int, stdin.read().split()))
_s = 0
def inp(n=1):
global _s
ret = lst[_s:_s + n]
_s += n
return ret
def inp1():
return inp()[0]
t = inp1()
for _ in range(t):
n = inp1()
a = deque(inp(n))
ret = 0
sm = sum(a)
if list(a) != sorted(a):
while len(a) > 1 and sm > 0:
if a.pop() == 0:
ret += 1
while len(a) > 0 and a.popleft() == 0:
{{completion}}
sm -= 1
else: sm -= 1
print(ret)
|
continue
|
[{"input": "4\n\n8\n\n0 0 1 1 1 1 1 1\n\n5\n\n1 0 0 1 1\n\n2\n\n1 0\n\n11\n\n1 1 0 0 1 0 0 1 1 1 0", "output": ["0\n1\n1\n3"]}]
|
block_completion_006957
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You have an array $$$a$$$ of size $$$n$$$ consisting only of zeroes and ones. You can do the following operation: choose two indices $$$1 \le i , j \le n$$$, $$$i \ne j$$$, add $$$a_{i}$$$ to $$$a_{j}$$$, remove $$$a_{i}$$$ from $$$a$$$. Note that elements of $$$a$$$ can become bigger than $$$1$$$ after performing some operations. Also note that $$$n$$$ becomes $$$1$$$ less after the operation.What is the minimum number of operations needed to make $$$a$$$ non-decreasing, i. e. that each element is not less than the previous element?
Input Specification: Each test contains multiple test cases. The first line contains the number of test cases $$$t$$$ ($$$1 \le t \le 10^4$$$). The description of the test cases follows. The first line of each test case contains an integer $$$n$$$ ($$$1 \le n \le 10^5$$$), the size of array $$$a$$$. Next line contains $$$n$$$ integers $$$a_{1}, a_{2}, \ldots a_{n}$$$ ($$$a_i$$$ is $$$0$$$ or $$$1$$$), elements of array $$$a$$$. It's guaranteed that sum of $$$n$$$ over all test cases doesn't exceed $$$2 \cdot 10^5$$$.
Output Specification: For each test case print a single integer, minimum number of operations needed to make $$$a$$$ non-decreasing.
Notes: NoteIn the first test case, $$$a$$$ is already non-decreasing, so you don't need to do any operations and the answer is $$$0$$$.In the second test case, you can perform an operation for $$$i = 1$$$ and $$$j = 5$$$, so $$$a$$$ will be equal to $$$[0, 0, 1, 2]$$$ and it becomes non-decreasing.In the third test case, you can perform an operation for $$$i = 2$$$ and $$$j = 1$$$, so $$$a$$$ will be equal to $$$[1]$$$ and it becomes non-decreasing.
Code:
import sys
tokens = (token for token in sys.stdin.read().split())
N = int(next(tokens))
for i in range(N):
Q = int(next(tokens))
arr = []
count = 0
for i in range(Q):
arr.append(int(next(tokens)))
i = 0
j = len(arr) - 1
while True:
while True:
if arr[i] == 1 or i == j:
break
else:
# TODO: Your code here
while True:
if arr[j] == 0 or j == i:
break
else:
j-=1
if i == j:
break
sec = arr[i]
arr [i] = arr[j]
arr [j] = sec
count += 1
print (count)
|
import sys
tokens = (token for token in sys.stdin.read().split())
N = int(next(tokens))
for i in range(N):
Q = int(next(tokens))
arr = []
count = 0
for i in range(Q):
arr.append(int(next(tokens)))
i = 0
j = len(arr) - 1
while True:
while True:
if arr[i] == 1 or i == j:
break
else:
{{completion}}
while True:
if arr[j] == 0 or j == i:
break
else:
j-=1
if i == j:
break
sec = arr[i]
arr [i] = arr[j]
arr [j] = sec
count += 1
print (count)
|
i+=1
|
[{"input": "4\n\n8\n\n0 0 1 1 1 1 1 1\n\n5\n\n1 0 0 1 1\n\n2\n\n1 0\n\n11\n\n1 1 0 0 1 0 0 1 1 1 0", "output": ["0\n1\n1\n3"]}]
|
block_completion_006958
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You have an array $$$a$$$ of size $$$n$$$ consisting only of zeroes and ones. You can do the following operation: choose two indices $$$1 \le i , j \le n$$$, $$$i \ne j$$$, add $$$a_{i}$$$ to $$$a_{j}$$$, remove $$$a_{i}$$$ from $$$a$$$. Note that elements of $$$a$$$ can become bigger than $$$1$$$ after performing some operations. Also note that $$$n$$$ becomes $$$1$$$ less after the operation.What is the minimum number of operations needed to make $$$a$$$ non-decreasing, i. e. that each element is not less than the previous element?
Input Specification: Each test contains multiple test cases. The first line contains the number of test cases $$$t$$$ ($$$1 \le t \le 10^4$$$). The description of the test cases follows. The first line of each test case contains an integer $$$n$$$ ($$$1 \le n \le 10^5$$$), the size of array $$$a$$$. Next line contains $$$n$$$ integers $$$a_{1}, a_{2}, \ldots a_{n}$$$ ($$$a_i$$$ is $$$0$$$ or $$$1$$$), elements of array $$$a$$$. It's guaranteed that sum of $$$n$$$ over all test cases doesn't exceed $$$2 \cdot 10^5$$$.
Output Specification: For each test case print a single integer, minimum number of operations needed to make $$$a$$$ non-decreasing.
Notes: NoteIn the first test case, $$$a$$$ is already non-decreasing, so you don't need to do any operations and the answer is $$$0$$$.In the second test case, you can perform an operation for $$$i = 1$$$ and $$$j = 5$$$, so $$$a$$$ will be equal to $$$[0, 0, 1, 2]$$$ and it becomes non-decreasing.In the third test case, you can perform an operation for $$$i = 2$$$ and $$$j = 1$$$, so $$$a$$$ will be equal to $$$[1]$$$ and it becomes non-decreasing.
Code:
import sys
tokens = (token for token in sys.stdin.read().split())
N = int(next(tokens))
for i in range(N):
Q = int(next(tokens))
arr = []
count = 0
for i in range(Q):
arr.append(int(next(tokens)))
i = 0
j = len(arr) - 1
while True:
while True:
if arr[i] == 1 or i == j:
break
else:
i+=1
while True:
if arr[j] == 0 or j == i:
break
else:
# TODO: Your code here
if i == j:
break
sec = arr[i]
arr [i] = arr[j]
arr [j] = sec
count += 1
print (count)
|
import sys
tokens = (token for token in sys.stdin.read().split())
N = int(next(tokens))
for i in range(N):
Q = int(next(tokens))
arr = []
count = 0
for i in range(Q):
arr.append(int(next(tokens)))
i = 0
j = len(arr) - 1
while True:
while True:
if arr[i] == 1 or i == j:
break
else:
i+=1
while True:
if arr[j] == 0 or j == i:
break
else:
{{completion}}
if i == j:
break
sec = arr[i]
arr [i] = arr[j]
arr [j] = sec
count += 1
print (count)
|
j-=1
|
[{"input": "4\n\n8\n\n0 0 1 1 1 1 1 1\n\n5\n\n1 0 0 1 1\n\n2\n\n1 0\n\n11\n\n1 1 0 0 1 0 0 1 1 1 0", "output": ["0\n1\n1\n3"]}]
|
block_completion_006959
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You have an array $$$a$$$ of size $$$n$$$ consisting only of zeroes and ones and an integer $$$k$$$. In one operation you can do one of the following: Select $$$2$$$ consecutive elements of $$$a$$$ and replace them with their minimum (that is, let $$$a := [a_{1}, a_{2}, \ldots, a_{i-1}, \min(a_{i}, a_{i+1}), a_{i+2}, \ldots, a_{n}]$$$ for some $$$1 \le i \le n-1$$$). This operation decreases the size of $$$a$$$ by $$$1$$$. Select $$$k$$$ consecutive elements of $$$a$$$ and replace them with their maximum (that is, let $$$a := [a_{1}, a_{2}, \ldots, a_{i-1}, \max(a_{i}, a_{i+1}, \ldots, a_{i+k-1}), a_{i+k}, \ldots, a_{n}]$$$ for some $$$1 \le i \le n-k+1$$$). This operation decreases the size of $$$a$$$ by $$$k-1$$$. Determine if it's possible to turn $$$a$$$ into $$$[1]$$$ after several (possibly zero) operations.
Input Specification: Each test contains multiple test cases. The first line contains the number of test cases $$$t$$$ ($$$1 \le t \le 1000$$$). The description of the test cases follows. The first line of each test case contains two integers $$$n$$$ and $$$k$$$ ($$$2 \le k \le n \le 50$$$), the size of array $$$a$$$ and the length of segments that you can perform second type operation on. The second line contains $$$n$$$ integers $$$a_{1}, a_{2}, \ldots, a_{n}$$$ ($$$a_i$$$ is $$$0$$$ or $$$1$$$), elements of array $$$a$$$.
Output Specification: For each test case, if it is possible to turn $$$a$$$ into $$$[1]$$$, print "YES", otherwise print "NO".
Notes: NoteIn the first test case, you can perform the second type operation on second and third elements so $$$a$$$ becomes $$$[0, 1]$$$, then you can perform the second type operation on first and second elements, so $$$a$$$ turns to $$$[1]$$$.In the fourth test case, it's obvious to see that you can't make any $$$1$$$, no matter what you do.In the fifth test case, you can first perform a type 2 operation on the first three elements so that $$$a$$$ becomes $$$[1, 0, 0, 1]$$$, then perform a type 2 operation on the elements in positions two through four, so that $$$a$$$ becomes $$$[1, 1]$$$, and finally perform the first type operation on the remaining elements, so that $$$a$$$ becomes $$$[1]$$$.
Code:
from sys import stdin
from collections import deque
lst = list(map(int, stdin.read().split()))
_s = 0
def inp(n=1):
# TODO: Your code here
def inp1():
return inp()[0]
t = inp1()
for _ in range(t):
n = inp1()
k = inp1()
a = set(inp(n))
print("YES" if 1 in a else "NO")
|
from sys import stdin
from collections import deque
lst = list(map(int, stdin.read().split()))
_s = 0
def inp(n=1):
{{completion}}
def inp1():
return inp()[0]
t = inp1()
for _ in range(t):
n = inp1()
k = inp1()
a = set(inp(n))
print("YES" if 1 in a else "NO")
|
global _s
ret = lst[_s:_s + n]
_s += n
return ret
|
[{"input": "7\n\n3 2\n\n0 1 0\n\n5 3\n\n1 0 1 1 0\n\n2 2\n\n1 1\n\n4 4\n\n0 0 0 0\n\n6 3\n\n0 0 1 0 0 1\n\n7 5\n\n1 1 1 1 1 1 1\n\n5 3\n\n0 0 1 0 0", "output": ["YES\nYES\nYES\nNO\nYES\nYES\nYES"]}]
|
block_completion_006994
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You have an array $$$a$$$ of size $$$n$$$ consisting only of zeroes and ones and an integer $$$k$$$. In one operation you can do one of the following: Select $$$2$$$ consecutive elements of $$$a$$$ and replace them with their minimum (that is, let $$$a := [a_{1}, a_{2}, \ldots, a_{i-1}, \min(a_{i}, a_{i+1}), a_{i+2}, \ldots, a_{n}]$$$ for some $$$1 \le i \le n-1$$$). This operation decreases the size of $$$a$$$ by $$$1$$$. Select $$$k$$$ consecutive elements of $$$a$$$ and replace them with their maximum (that is, let $$$a := [a_{1}, a_{2}, \ldots, a_{i-1}, \max(a_{i}, a_{i+1}, \ldots, a_{i+k-1}), a_{i+k}, \ldots, a_{n}]$$$ for some $$$1 \le i \le n-k+1$$$). This operation decreases the size of $$$a$$$ by $$$k-1$$$. Determine if it's possible to turn $$$a$$$ into $$$[1]$$$ after several (possibly zero) operations.
Input Specification: Each test contains multiple test cases. The first line contains the number of test cases $$$t$$$ ($$$1 \le t \le 1000$$$). The description of the test cases follows. The first line of each test case contains two integers $$$n$$$ and $$$k$$$ ($$$2 \le k \le n \le 50$$$), the size of array $$$a$$$ and the length of segments that you can perform second type operation on. The second line contains $$$n$$$ integers $$$a_{1}, a_{2}, \ldots, a_{n}$$$ ($$$a_i$$$ is $$$0$$$ or $$$1$$$), elements of array $$$a$$$.
Output Specification: For each test case, if it is possible to turn $$$a$$$ into $$$[1]$$$, print "YES", otherwise print "NO".
Notes: NoteIn the first test case, you can perform the second type operation on second and third elements so $$$a$$$ becomes $$$[0, 1]$$$, then you can perform the second type operation on first and second elements, so $$$a$$$ turns to $$$[1]$$$.In the fourth test case, it's obvious to see that you can't make any $$$1$$$, no matter what you do.In the fifth test case, you can first perform a type 2 operation on the first three elements so that $$$a$$$ becomes $$$[1, 0, 0, 1]$$$, then perform a type 2 operation on the elements in positions two through four, so that $$$a$$$ becomes $$$[1, 1]$$$, and finally perform the first type operation on the remaining elements, so that $$$a$$$ becomes $$$[1]$$$.
Code:
from sys import stdin
from collections import deque
lst = list(map(int, stdin.read().split()))
_s = 0
def inp(n=1):
global _s
ret = lst[_s:_s + n]
_s += n
return ret
def inp1():
# TODO: Your code here
t = inp1()
for _ in range(t):
n = inp1()
k = inp1()
a = set(inp(n))
print("YES" if 1 in a else "NO")
|
from sys import stdin
from collections import deque
lst = list(map(int, stdin.read().split()))
_s = 0
def inp(n=1):
global _s
ret = lst[_s:_s + n]
_s += n
return ret
def inp1():
{{completion}}
t = inp1()
for _ in range(t):
n = inp1()
k = inp1()
a = set(inp(n))
print("YES" if 1 in a else "NO")
|
return inp()[0]
|
[{"input": "7\n\n3 2\n\n0 1 0\n\n5 3\n\n1 0 1 1 0\n\n2 2\n\n1 1\n\n4 4\n\n0 0 0 0\n\n6 3\n\n0 0 1 0 0 1\n\n7 5\n\n1 1 1 1 1 1 1\n\n5 3\n\n0 0 1 0 0", "output": ["YES\nYES\nYES\nNO\nYES\nYES\nYES"]}]
|
block_completion_006995
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You have an array $$$a$$$ consisting of $$$n$$$ positive integers and you have to handle $$$q$$$ queries of the following types: $$$1$$$ $$$i$$$ $$$x$$$: change $$$a_{i}$$$ to $$$x$$$, $$$2$$$ $$$l$$$ $$$r$$$ $$$k$$$: check if the number of occurrences of every positive integer in the subarray $$$a_{l}, a_{l+1}, \ldots a_{r}$$$ is a multiple of $$$k$$$ (check the example for better understanding).
Input Specification: The first line of the input contains two integers $$$n$$$ and $$$q$$$ ($$$1 \le n , q \le 3 \cdot 10^5$$$), the length of $$$a$$$ and the number of queries. Next line contains $$$n$$$ integers $$$a_{1}, a_{2}, \ldots a_{n}$$$ ($$$1 \le a_{i} \le 10^9$$$) — the elements of $$$a$$$. Each of the next $$$q$$$ lines describes a query. It has one of the following forms. $$$1$$$ $$$i$$$ $$$x$$$, ($$$1 \le i \le n$$$ , $$$1 \le x \le 10^9$$$), or $$$2$$$ $$$l$$$ $$$r$$$ $$$k$$$, ($$$1 \le l \le r \le n$$$ , $$$1 \le k \le n$$$).
Output Specification: For each query of the second type, if answer of the query is yes, print "YES", otherwise print "NO".
Notes: NoteIn the first query, requested subarray is $$$[1234, 2, 3, 3, 2, 1]$$$, and it's obvious that the number of occurrence of $$$1$$$ isn't divisible by $$$k = 2$$$. So the answer is "NO".In the third query, requested subarray is $$$[1, 2, 3, 3, 2, 1]$$$, and it can be seen that the number of occurrence of every integer in this sub array is divisible by $$$k = 2$$$. So the answer is "YES".In the sixth query, requested subarray is $$$[1, 2, 3, 3, 2, 1, 1, 2, 3]$$$, and it can be seen that the number of occurrence of every integer in this sub array is divisible by $$$k = 3$$$. So the answer is "YES".
Code:
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
import random
class Bit:
def __init__(self, n):
self.size = n
self.n0 = 1 << (n.bit_length() - 1)
self.tree = [0] * (n + 1)
def range_sum(self, l, r):
return self.sum(r - 1) - self.sum(l - 1)
def sum(self, i):
i += 1
s = 0
while i > 0:
s += self.tree[i]
i -= i & -i
return s
def get(self, i):
return self.sum(i) - self.sum(i - 1)
def add(self, i, x):
i += 1
while i <= self.size:
self.tree[i] += x
i += i & -i
def lower_bound(self, x):
pos = 0
plus = self.n0
while plus > 0:
if pos + plus <= self.size and self.tree[pos + plus] < x:
x -= self.tree[pos + plus]
pos += plus
plus //= 2
return pos
def solve():
n, Q = map(int, input().split())
A = list(map(int, input().split()))
query = []
se = set(A)
ind = 0
ans = ["YES"] * Q
for _ in range(Q):
q = list(map(int, input().split()))
if q[0] == 2:
l, r, k = q[1:]
if (r - l + 1) % k != 0:
ans[ind] = "NO"
ind += 1
continue
q.append(ind)
ind += 1
else:
q[1] -= 1
query.append(q)
if q[0] == 1:
se.add(q[2])
ans = ans[:ind]
dic = {a:i for i, a in enumerate(sorted(se))}
A = [dic[a] for a in A]
for q in query:
if q[0] == 1:
q[2] = dic[q[2]]
m = len(se)
itr = 12
for _ in range(itr):
P = random.choices(range(4), k=m)
bit = Bit(n)
B = A[:]
for i, a in enumerate(A):
add = 0
if P[a] & 1:
add |= 1
if P[a] & 2:
add |= 1 << 30
if add != 0:
bit.add(i, add)
for q in query:
if q[0] == 1:
i, x = q[1:]
b = B[i]
B[i] = x
add = 0
if P[b] & 1:
add -= 1
if P[b] & 2:
add -= 1 << 30
if P[x] & 1:
add += 1
if P[x] & 2:
add += 1 << 30
if add != 0:
bit.add(i, add)
else:
l, r, k, i = q[1:]
if ans[i] == "NO":
continue
c = bit.range_sum(l - 1, r)
if c % k != 0:
ans[i] = "NO"
elif (c >> 30) % k != 0:
# TODO: Your code here
print(*ans, sep="\n")
T = 1
# T = int(input())
for t in range(1, T + 1):
solve()
|
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
import random
class Bit:
def __init__(self, n):
self.size = n
self.n0 = 1 << (n.bit_length() - 1)
self.tree = [0] * (n + 1)
def range_sum(self, l, r):
return self.sum(r - 1) - self.sum(l - 1)
def sum(self, i):
i += 1
s = 0
while i > 0:
s += self.tree[i]
i -= i & -i
return s
def get(self, i):
return self.sum(i) - self.sum(i - 1)
def add(self, i, x):
i += 1
while i <= self.size:
self.tree[i] += x
i += i & -i
def lower_bound(self, x):
pos = 0
plus = self.n0
while plus > 0:
if pos + plus <= self.size and self.tree[pos + plus] < x:
x -= self.tree[pos + plus]
pos += plus
plus //= 2
return pos
def solve():
n, Q = map(int, input().split())
A = list(map(int, input().split()))
query = []
se = set(A)
ind = 0
ans = ["YES"] * Q
for _ in range(Q):
q = list(map(int, input().split()))
if q[0] == 2:
l, r, k = q[1:]
if (r - l + 1) % k != 0:
ans[ind] = "NO"
ind += 1
continue
q.append(ind)
ind += 1
else:
q[1] -= 1
query.append(q)
if q[0] == 1:
se.add(q[2])
ans = ans[:ind]
dic = {a:i for i, a in enumerate(sorted(se))}
A = [dic[a] for a in A]
for q in query:
if q[0] == 1:
q[2] = dic[q[2]]
m = len(se)
itr = 12
for _ in range(itr):
P = random.choices(range(4), k=m)
bit = Bit(n)
B = A[:]
for i, a in enumerate(A):
add = 0
if P[a] & 1:
add |= 1
if P[a] & 2:
add |= 1 << 30
if add != 0:
bit.add(i, add)
for q in query:
if q[0] == 1:
i, x = q[1:]
b = B[i]
B[i] = x
add = 0
if P[b] & 1:
add -= 1
if P[b] & 2:
add -= 1 << 30
if P[x] & 1:
add += 1
if P[x] & 2:
add += 1 << 30
if add != 0:
bit.add(i, add)
else:
l, r, k, i = q[1:]
if ans[i] == "NO":
continue
c = bit.range_sum(l - 1, r)
if c % k != 0:
ans[i] = "NO"
elif (c >> 30) % k != 0:
{{completion}}
print(*ans, sep="\n")
T = 1
# T = int(input())
for t in range(1, T + 1):
solve()
|
ans[i] = "NO"
|
[{"input": "10 8\n1234 2 3 3 2 1 1 2 3 4\n2 1 6 2\n1 1 1\n2 1 6 2\n2 1 9 2\n1 10 5\n2 1 9 3\n1 3 5\n2 3 10 2", "output": ["NO\nYES\nNO\nYES\nYES"]}]
|
block_completion_007029
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You have an array $$$a$$$ consisting of $$$n$$$ positive integers and you have to handle $$$q$$$ queries of the following types: $$$1$$$ $$$i$$$ $$$x$$$: change $$$a_{i}$$$ to $$$x$$$, $$$2$$$ $$$l$$$ $$$r$$$ $$$k$$$: check if the number of occurrences of every positive integer in the subarray $$$a_{l}, a_{l+1}, \ldots a_{r}$$$ is a multiple of $$$k$$$ (check the example for better understanding).
Input Specification: The first line of the input contains two integers $$$n$$$ and $$$q$$$ ($$$1 \le n , q \le 3 \cdot 10^5$$$), the length of $$$a$$$ and the number of queries. Next line contains $$$n$$$ integers $$$a_{1}, a_{2}, \ldots a_{n}$$$ ($$$1 \le a_{i} \le 10^9$$$) — the elements of $$$a$$$. Each of the next $$$q$$$ lines describes a query. It has one of the following forms. $$$1$$$ $$$i$$$ $$$x$$$, ($$$1 \le i \le n$$$ , $$$1 \le x \le 10^9$$$), or $$$2$$$ $$$l$$$ $$$r$$$ $$$k$$$, ($$$1 \le l \le r \le n$$$ , $$$1 \le k \le n$$$).
Output Specification: For each query of the second type, if answer of the query is yes, print "YES", otherwise print "NO".
Notes: NoteIn the first query, requested subarray is $$$[1234, 2, 3, 3, 2, 1]$$$, and it's obvious that the number of occurrence of $$$1$$$ isn't divisible by $$$k = 2$$$. So the answer is "NO".In the third query, requested subarray is $$$[1, 2, 3, 3, 2, 1]$$$, and it can be seen that the number of occurrence of every integer in this sub array is divisible by $$$k = 2$$$. So the answer is "YES".In the sixth query, requested subarray is $$$[1, 2, 3, 3, 2, 1, 1, 2, 3]$$$, and it can be seen that the number of occurrence of every integer in this sub array is divisible by $$$k = 3$$$. So the answer is "YES".
Code:
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
import random
class Bit:
def __init__(self, n):
self.size = n
self.n0 = 1 << (n.bit_length() - 1)
self.tree = [0] * (n + 1)
def range_sum(self, l, r):
return self.sum(r - 1) - self.sum(l - 1)
def sum(self, i):
i += 1
s = 0
while i > 0:
s += self.tree[i]
i -= i & -i
return s
def get(self, i):
return self.sum(i) - self.sum(i - 1)
def add(self, i, x):
i += 1
while i <= self.size:
self.tree[i] += x
i += i & -i
def lower_bound(self, x):
pos = 0
plus = self.n0
while plus > 0:
if pos + plus <= self.size and self.tree[pos + plus] < x:
x -= self.tree[pos + plus]
pos += plus
plus //= 2
return pos
def solve():
n, Q = map(int, input().split())
A = list(map(int, input().split()))
query = []
se = set(A)
ind = 0
ans = ["YES"] * Q
for _ in range(Q):
q = list(map(int, input().split()))
if q[0] == 2:
l, r, k = q[1:]
if (r - l + 1) % k != 0:
ans[ind] = "NO"
ind += 1
continue
q.append(ind)
ind += 1
else:
q[1] -= 1
query.append(q)
if q[0] == 1:
se.add(q[2])
ans = ans[:ind]
dic = {a:i for i, a in enumerate(sorted(se))}
A = [dic[a] for a in A]
for q in query:
if q[0] == 1:
q[2] = dic[q[2]]
m = len(se)
itr = 12
for _ in range(itr):
P = random.choices(range(4), k=m)
bit = Bit(n)
B = A[:]
for i, a in enumerate(A):
add = 0
if P[a] & 1:
add |= 1
if P[a] & 2:
add |= 1 << 30
if add != 0:
bit.add(i, add)
for q in query:
if q[0] == 1:
i, x = q[1:]
b = B[i]
B[i] = x
add = 0
if P[b] & 1:
add -= 1
if P[b] & 2:
add -= 1 << 30
if P[x] & 1:
add += 1
if P[x] & 2:
add += 1 << 30
if add != 0:
bit.add(i, add)
else:
l, r, k, i = q[1:]
if ans[i] == "NO":
# TODO: Your code here
c = bit.range_sum(l - 1, r)
if c % k != 0:
ans[i] = "NO"
elif (c >> 30) % k != 0:
ans[i] = "NO"
print(*ans, sep="\n")
T = 1
# T = int(input())
for t in range(1, T + 1):
solve()
|
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
import random
class Bit:
def __init__(self, n):
self.size = n
self.n0 = 1 << (n.bit_length() - 1)
self.tree = [0] * (n + 1)
def range_sum(self, l, r):
return self.sum(r - 1) - self.sum(l - 1)
def sum(self, i):
i += 1
s = 0
while i > 0:
s += self.tree[i]
i -= i & -i
return s
def get(self, i):
return self.sum(i) - self.sum(i - 1)
def add(self, i, x):
i += 1
while i <= self.size:
self.tree[i] += x
i += i & -i
def lower_bound(self, x):
pos = 0
plus = self.n0
while plus > 0:
if pos + plus <= self.size and self.tree[pos + plus] < x:
x -= self.tree[pos + plus]
pos += plus
plus //= 2
return pos
def solve():
n, Q = map(int, input().split())
A = list(map(int, input().split()))
query = []
se = set(A)
ind = 0
ans = ["YES"] * Q
for _ in range(Q):
q = list(map(int, input().split()))
if q[0] == 2:
l, r, k = q[1:]
if (r - l + 1) % k != 0:
ans[ind] = "NO"
ind += 1
continue
q.append(ind)
ind += 1
else:
q[1] -= 1
query.append(q)
if q[0] == 1:
se.add(q[2])
ans = ans[:ind]
dic = {a:i for i, a in enumerate(sorted(se))}
A = [dic[a] for a in A]
for q in query:
if q[0] == 1:
q[2] = dic[q[2]]
m = len(se)
itr = 12
for _ in range(itr):
P = random.choices(range(4), k=m)
bit = Bit(n)
B = A[:]
for i, a in enumerate(A):
add = 0
if P[a] & 1:
add |= 1
if P[a] & 2:
add |= 1 << 30
if add != 0:
bit.add(i, add)
for q in query:
if q[0] == 1:
i, x = q[1:]
b = B[i]
B[i] = x
add = 0
if P[b] & 1:
add -= 1
if P[b] & 2:
add -= 1 << 30
if P[x] & 1:
add += 1
if P[x] & 2:
add += 1 << 30
if add != 0:
bit.add(i, add)
else:
l, r, k, i = q[1:]
if ans[i] == "NO":
{{completion}}
c = bit.range_sum(l - 1, r)
if c % k != 0:
ans[i] = "NO"
elif (c >> 30) % k != 0:
ans[i] = "NO"
print(*ans, sep="\n")
T = 1
# T = int(input())
for t in range(1, T + 1):
solve()
|
continue
|
[{"input": "10 8\n1234 2 3 3 2 1 1 2 3 4\n2 1 6 2\n1 1 1\n2 1 6 2\n2 1 9 2\n1 10 5\n2 1 9 3\n1 3 5\n2 3 10 2", "output": ["NO\nYES\nNO\nYES\nYES"]}]
|
block_completion_007030
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: This is the hard version of this problem. In this version, we have queries. Note that we do not have multiple test cases in this version. You can make hacks only if both versions of the problem are solved.An array $$$b$$$ of length $$$m$$$ is good if for all $$$i$$$ the $$$i$$$-th element is greater than or equal to $$$i$$$. In other words, $$$b$$$ is good if and only if $$$b_i \geq i$$$ for all $$$i$$$ ($$$1 \leq i \leq m$$$).You are given an array $$$a$$$ consisting of $$$n$$$ positive integers, and you are asked $$$q$$$ queries. In each query, you are given two integers $$$p$$$ and $$$x$$$ ($$$1 \leq p,x \leq n$$$). You have to do $$$a_p := x$$$ (assign $$$x$$$ to $$$a_p$$$). In the updated array, find the number of pairs of indices $$$(l, r)$$$, where $$$1 \le l \le r \le n$$$, such that the array $$$[a_l, a_{l+1}, \ldots, a_r]$$$ is good.Note that all queries are independent, which means after each query, the initial array $$$a$$$ is restored.
Input Specification: The first line contains a single integer $$$n$$$ ($$$1 \le n \le 2 \cdot 10^5$$$). The second line contains $$$n$$$ integers $$$a_1, a_2, \ldots, a_n$$$ ($$$1 \le a_i \le n$$$). The third line contains an integer $$$q$$$ ($$$1 \leq q \leq 2 \cdot 10^5$$$) — the number of queries. Each of the next $$$q$$$ lines contains two integers $$$p_j$$$ and $$$x_j$$$ ($$$1 \leq p_j, x_j \leq n$$$) – the description of the $$$j$$$-th query.
Output Specification: For each query, print the number of suitable pairs of indices after making the change.
Notes: NoteHere are notes for first example.In first query, after update $$$a=[2,4,1,4]$$$. Now $$$(1,1)$$$, $$$(2,2)$$$, $$$(3,3)$$$, $$$(4,4)$$$, $$$(1,2)$$$, and $$$(3,4)$$$ are suitable pairs.In second query, after update $$$a=[2,4,3,4]$$$. Now all subarrays of $$$a$$$ are good.In third query, after update $$$a=[2,1,1,4]$$$. Now $$$(1,1)$$$, $$$(2,2)$$$, $$$(3,3)$$$, $$$(4,4)$$$, and $$$(3,4)$$$ are suitable.
Code:
import sys
input = sys.stdin.readline
inf = float('inf')
def getInt():
return int(input())
def getStr():
return input().strip()
def getList(split=True):
s = getStr()
if split:
s = s.split()
return map(int, s)
# t = getInt()
t = 1
def solve():
n = getInt()
a = list(getList())
j = res = 0
p = [0] * n
P = [0] * n
from bisect import bisect_left
f = {}
for i, x in enumerate(a):
j = max(j, i)
while j < n and a[j] >= j+1 - i:
j += 1
res += j - i
if j-1 not in f:
f[j-1] = i
J = j + 1 # further extends
while J < n and a[J] >= J + 1 - i:
J += 1
p[i] = p[i-1] + j - 1
P[i] = P[i-1] + J - j
q = getInt()
def calc(l, r, p):
if l > r:
return 0
res = p[r]
if l:
res -= p[l-1]
return res
keys = sorted(f.keys())
for _ in range(q):
u, v = getList()
u -= 1
ans = res
it = bisect_left(keys, u)
if v < a[u]:
it = keys[it]
l = max(f[it], u + 1 - v)
ans -= calc(f[it], l-1, p) - (u-1) * (l-f[it])
elif v > a[u]:
if it and keys[it-1] + 1 == u:
# TODO: Your code here
print(ans)
for _ in range(t):
solve()
|
import sys
input = sys.stdin.readline
inf = float('inf')
def getInt():
return int(input())
def getStr():
return input().strip()
def getList(split=True):
s = getStr()
if split:
s = s.split()
return map(int, s)
# t = getInt()
t = 1
def solve():
n = getInt()
a = list(getList())
j = res = 0
p = [0] * n
P = [0] * n
from bisect import bisect_left
f = {}
for i, x in enumerate(a):
j = max(j, i)
while j < n and a[j] >= j+1 - i:
j += 1
res += j - i
if j-1 not in f:
f[j-1] = i
J = j + 1 # further extends
while J < n and a[J] >= J + 1 - i:
J += 1
p[i] = p[i-1] + j - 1
P[i] = P[i-1] + J - j
q = getInt()
def calc(l, r, p):
if l > r:
return 0
res = p[r]
if l:
res -= p[l-1]
return res
keys = sorted(f.keys())
for _ in range(q):
u, v = getList()
u -= 1
ans = res
it = bisect_left(keys, u)
if v < a[u]:
it = keys[it]
l = max(f[it], u + 1 - v)
ans -= calc(f[it], l-1, p) - (u-1) * (l-f[it])
elif v > a[u]:
if it and keys[it-1] + 1 == u:
{{completion}}
print(ans)
for _ in range(t):
solve()
|
l = max(f[keys[it-1]], u+1-v)
ans += calc(l, f[keys[it]]-1, P)
|
[{"input": "4\n2 4 1 4\n3\n2 4\n3 3\n2 1", "output": ["6\n10\n5"]}, {"input": "5\n1 1 3 2 1\n3\n1 3\n2 5\n4 5", "output": ["7\n9\n8"]}]
|
block_completion_007066
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: This is the hard version of this problem. In this version, we have queries. Note that we do not have multiple test cases in this version. You can make hacks only if both versions of the problem are solved.An array $$$b$$$ of length $$$m$$$ is good if for all $$$i$$$ the $$$i$$$-th element is greater than or equal to $$$i$$$. In other words, $$$b$$$ is good if and only if $$$b_i \geq i$$$ for all $$$i$$$ ($$$1 \leq i \leq m$$$).You are given an array $$$a$$$ consisting of $$$n$$$ positive integers, and you are asked $$$q$$$ queries. In each query, you are given two integers $$$p$$$ and $$$x$$$ ($$$1 \leq p,x \leq n$$$). You have to do $$$a_p := x$$$ (assign $$$x$$$ to $$$a_p$$$). In the updated array, find the number of pairs of indices $$$(l, r)$$$, where $$$1 \le l \le r \le n$$$, such that the array $$$[a_l, a_{l+1}, \ldots, a_r]$$$ is good.Note that all queries are independent, which means after each query, the initial array $$$a$$$ is restored.
Input Specification: The first line contains a single integer $$$n$$$ ($$$1 \le n \le 2 \cdot 10^5$$$). The second line contains $$$n$$$ integers $$$a_1, a_2, \ldots, a_n$$$ ($$$1 \le a_i \le n$$$). The third line contains an integer $$$q$$$ ($$$1 \leq q \leq 2 \cdot 10^5$$$) — the number of queries. Each of the next $$$q$$$ lines contains two integers $$$p_j$$$ and $$$x_j$$$ ($$$1 \leq p_j, x_j \leq n$$$) – the description of the $$$j$$$-th query.
Output Specification: For each query, print the number of suitable pairs of indices after making the change.
Notes: NoteHere are notes for first example.In first query, after update $$$a=[2,4,1,4]$$$. Now $$$(1,1)$$$, $$$(2,2)$$$, $$$(3,3)$$$, $$$(4,4)$$$, $$$(1,2)$$$, and $$$(3,4)$$$ are suitable pairs.In second query, after update $$$a=[2,4,3,4]$$$. Now all subarrays of $$$a$$$ are good.In third query, after update $$$a=[2,1,1,4]$$$. Now $$$(1,1)$$$, $$$(2,2)$$$, $$$(3,3)$$$, $$$(4,4)$$$, and $$$(3,4)$$$ are suitable.
Code:
import sys
input = sys.stdin.readline
inf = float('inf')
def getInt():
return int(input())
def getStr():
return input().strip()
def getList(split=True):
s = getStr()
if split:
s = s.split()
return map(int, s)
# t = getInt()
t = 1
def solve():
n = getInt()
a = list(getList())
j = res = 0
p = [0] * n
P = [0] * n
from bisect import bisect_left
f = {}
for i, x in enumerate(a):
j = max(j, i)
while j < n and a[j] >= j+1 - i:
# TODO: Your code here
res += j - i
if j-1 not in f:
f[j-1] = i
J = j + 1 # further extends
while J < n and a[J] >= J + 1 - i:
J += 1
p[i] = p[i-1] + j - 1
P[i] = P[i-1] + J - j
q = getInt()
def calc(l, r, p):
if l > r:
return 0
res = p[r]
if l:
res -= p[l-1]
return res
keys = sorted(f.keys())
for _ in range(q):
u, v = getList()
u -= 1
ans = res
it = bisect_left(keys, u)
if v < a[u]:
it = keys[it]
l = max(f[it], u + 1 - v)
ans -= calc(f[it], l-1, p) - (u-1) * (l-f[it])
elif v > a[u]:
if it and keys[it-1] + 1 == u:
l = max(f[keys[it-1]], u+1-v)
ans += calc(l, f[keys[it]]-1, P)
print(ans)
for _ in range(t):
solve()
|
import sys
input = sys.stdin.readline
inf = float('inf')
def getInt():
return int(input())
def getStr():
return input().strip()
def getList(split=True):
s = getStr()
if split:
s = s.split()
return map(int, s)
# t = getInt()
t = 1
def solve():
n = getInt()
a = list(getList())
j = res = 0
p = [0] * n
P = [0] * n
from bisect import bisect_left
f = {}
for i, x in enumerate(a):
j = max(j, i)
while j < n and a[j] >= j+1 - i:
{{completion}}
res += j - i
if j-1 not in f:
f[j-1] = i
J = j + 1 # further extends
while J < n and a[J] >= J + 1 - i:
J += 1
p[i] = p[i-1] + j - 1
P[i] = P[i-1] + J - j
q = getInt()
def calc(l, r, p):
if l > r:
return 0
res = p[r]
if l:
res -= p[l-1]
return res
keys = sorted(f.keys())
for _ in range(q):
u, v = getList()
u -= 1
ans = res
it = bisect_left(keys, u)
if v < a[u]:
it = keys[it]
l = max(f[it], u + 1 - v)
ans -= calc(f[it], l-1, p) - (u-1) * (l-f[it])
elif v > a[u]:
if it and keys[it-1] + 1 == u:
l = max(f[keys[it-1]], u+1-v)
ans += calc(l, f[keys[it]]-1, P)
print(ans)
for _ in range(t):
solve()
|
j += 1
|
[{"input": "4\n2 4 1 4\n3\n2 4\n3 3\n2 1", "output": ["6\n10\n5"]}, {"input": "5\n1 1 3 2 1\n3\n1 3\n2 5\n4 5", "output": ["7\n9\n8"]}]
|
block_completion_007067
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: This is the hard version of this problem. In this version, we have queries. Note that we do not have multiple test cases in this version. You can make hacks only if both versions of the problem are solved.An array $$$b$$$ of length $$$m$$$ is good if for all $$$i$$$ the $$$i$$$-th element is greater than or equal to $$$i$$$. In other words, $$$b$$$ is good if and only if $$$b_i \geq i$$$ for all $$$i$$$ ($$$1 \leq i \leq m$$$).You are given an array $$$a$$$ consisting of $$$n$$$ positive integers, and you are asked $$$q$$$ queries. In each query, you are given two integers $$$p$$$ and $$$x$$$ ($$$1 \leq p,x \leq n$$$). You have to do $$$a_p := x$$$ (assign $$$x$$$ to $$$a_p$$$). In the updated array, find the number of pairs of indices $$$(l, r)$$$, where $$$1 \le l \le r \le n$$$, such that the array $$$[a_l, a_{l+1}, \ldots, a_r]$$$ is good.Note that all queries are independent, which means after each query, the initial array $$$a$$$ is restored.
Input Specification: The first line contains a single integer $$$n$$$ ($$$1 \le n \le 2 \cdot 10^5$$$). The second line contains $$$n$$$ integers $$$a_1, a_2, \ldots, a_n$$$ ($$$1 \le a_i \le n$$$). The third line contains an integer $$$q$$$ ($$$1 \leq q \leq 2 \cdot 10^5$$$) — the number of queries. Each of the next $$$q$$$ lines contains two integers $$$p_j$$$ and $$$x_j$$$ ($$$1 \leq p_j, x_j \leq n$$$) – the description of the $$$j$$$-th query.
Output Specification: For each query, print the number of suitable pairs of indices after making the change.
Notes: NoteHere are notes for first example.In first query, after update $$$a=[2,4,1,4]$$$. Now $$$(1,1)$$$, $$$(2,2)$$$, $$$(3,3)$$$, $$$(4,4)$$$, $$$(1,2)$$$, and $$$(3,4)$$$ are suitable pairs.In second query, after update $$$a=[2,4,3,4]$$$. Now all subarrays of $$$a$$$ are good.In third query, after update $$$a=[2,1,1,4]$$$. Now $$$(1,1)$$$, $$$(2,2)$$$, $$$(3,3)$$$, $$$(4,4)$$$, and $$$(3,4)$$$ are suitable.
Code:
from sys import stdin, stdout
from collections import defaultdict
n = int(stdin.readline())
a = [int(x) for x in stdin.readline().split()]
left = 0
right = 0
right_array = []
right_prefix = [0]
answer = 0
second_right = 0
second_right_array = []
second_right_prefix = [0]
while left < n:
if right < left:
right = left
while right < n and a[right] >= right-left+1:
right += 1
right_array.append(right)
right_prefix.append(right_prefix[-1]+right_array[-1])
answer += right - left
if second_right <= right:
second_right = right + 1
if second_right > n:
second_right = n
while second_right < n and a[second_right] >= second_right-left+1:
second_right += 1
second_right_array.append(second_right)
second_right_prefix.append(second_right_prefix[-1]+second_right_array[-1])
left += 1
p_to_right = defaultdict(list)
for i in range(n):
p_to_right[right_array[i]].append(i)
q = int(stdin.readline())
for _ in range(q):
p, x = [int(z) for z in stdin.readline().split()]
p -= 1
if x == a[p]:
adjustment = 0
elif x < a[p]:
if right_array[-1] <= p:
adjustment = 0
else:
upper = n-1
lower = -1
while upper - lower > 1:
candidate = (upper + lower)//2
if right_array[candidate] > p:
upper = candidate
else:
# TODO: Your code here
if upper > p-x:
adjustment = 0
else:
adjustment = -(right_prefix[p-x+1] - right_prefix[upper] - p*(p-x-upper+1))
else:
if len(p_to_right[p]) == 0:
adjustment = 0
elif p_to_right[p][0] > p-a[p] or p_to_right[p][-1] < p-x+1:
adjustment = 0
else:
lower = max(p-x+1, p_to_right[p][0])
upper = min(p-a[p], p_to_right[p][-1])
adjustment = second_right_prefix[upper+1] - second_right_prefix[lower] - p*(upper-lower+1)
stdout.write(str(answer+adjustment)+'\n')
|
from sys import stdin, stdout
from collections import defaultdict
n = int(stdin.readline())
a = [int(x) for x in stdin.readline().split()]
left = 0
right = 0
right_array = []
right_prefix = [0]
answer = 0
second_right = 0
second_right_array = []
second_right_prefix = [0]
while left < n:
if right < left:
right = left
while right < n and a[right] >= right-left+1:
right += 1
right_array.append(right)
right_prefix.append(right_prefix[-1]+right_array[-1])
answer += right - left
if second_right <= right:
second_right = right + 1
if second_right > n:
second_right = n
while second_right < n and a[second_right] >= second_right-left+1:
second_right += 1
second_right_array.append(second_right)
second_right_prefix.append(second_right_prefix[-1]+second_right_array[-1])
left += 1
p_to_right = defaultdict(list)
for i in range(n):
p_to_right[right_array[i]].append(i)
q = int(stdin.readline())
for _ in range(q):
p, x = [int(z) for z in stdin.readline().split()]
p -= 1
if x == a[p]:
adjustment = 0
elif x < a[p]:
if right_array[-1] <= p:
adjustment = 0
else:
upper = n-1
lower = -1
while upper - lower > 1:
candidate = (upper + lower)//2
if right_array[candidate] > p:
upper = candidate
else:
{{completion}}
if upper > p-x:
adjustment = 0
else:
adjustment = -(right_prefix[p-x+1] - right_prefix[upper] - p*(p-x-upper+1))
else:
if len(p_to_right[p]) == 0:
adjustment = 0
elif p_to_right[p][0] > p-a[p] or p_to_right[p][-1] < p-x+1:
adjustment = 0
else:
lower = max(p-x+1, p_to_right[p][0])
upper = min(p-a[p], p_to_right[p][-1])
adjustment = second_right_prefix[upper+1] - second_right_prefix[lower] - p*(upper-lower+1)
stdout.write(str(answer+adjustment)+'\n')
|
lower = candidate
|
[{"input": "4\n2 4 1 4\n3\n2 4\n3 3\n2 1", "output": ["6\n10\n5"]}, {"input": "5\n1 1 3 2 1\n3\n1 3\n2 5\n4 5", "output": ["7\n9\n8"]}]
|
block_completion_007068
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: This is the hard version of this problem. In this version, we have queries. Note that we do not have multiple test cases in this version. You can make hacks only if both versions of the problem are solved.An array $$$b$$$ of length $$$m$$$ is good if for all $$$i$$$ the $$$i$$$-th element is greater than or equal to $$$i$$$. In other words, $$$b$$$ is good if and only if $$$b_i \geq i$$$ for all $$$i$$$ ($$$1 \leq i \leq m$$$).You are given an array $$$a$$$ consisting of $$$n$$$ positive integers, and you are asked $$$q$$$ queries. In each query, you are given two integers $$$p$$$ and $$$x$$$ ($$$1 \leq p,x \leq n$$$). You have to do $$$a_p := x$$$ (assign $$$x$$$ to $$$a_p$$$). In the updated array, find the number of pairs of indices $$$(l, r)$$$, where $$$1 \le l \le r \le n$$$, such that the array $$$[a_l, a_{l+1}, \ldots, a_r]$$$ is good.Note that all queries are independent, which means after each query, the initial array $$$a$$$ is restored.
Input Specification: The first line contains a single integer $$$n$$$ ($$$1 \le n \le 2 \cdot 10^5$$$). The second line contains $$$n$$$ integers $$$a_1, a_2, \ldots, a_n$$$ ($$$1 \le a_i \le n$$$). The third line contains an integer $$$q$$$ ($$$1 \leq q \leq 2 \cdot 10^5$$$) — the number of queries. Each of the next $$$q$$$ lines contains two integers $$$p_j$$$ and $$$x_j$$$ ($$$1 \leq p_j, x_j \leq n$$$) – the description of the $$$j$$$-th query.
Output Specification: For each query, print the number of suitable pairs of indices after making the change.
Notes: NoteHere are notes for first example.In first query, after update $$$a=[2,4,1,4]$$$. Now $$$(1,1)$$$, $$$(2,2)$$$, $$$(3,3)$$$, $$$(4,4)$$$, $$$(1,2)$$$, and $$$(3,4)$$$ are suitable pairs.In second query, after update $$$a=[2,4,3,4]$$$. Now all subarrays of $$$a$$$ are good.In third query, after update $$$a=[2,1,1,4]$$$. Now $$$(1,1)$$$, $$$(2,2)$$$, $$$(3,3)$$$, $$$(4,4)$$$, and $$$(3,4)$$$ are suitable.
Code:
from sys import stdin, stdout
from collections import defaultdict
n = int(stdin.readline())
a = [int(x) for x in stdin.readline().split()]
left = 0
right = 0
right_array = []
right_prefix = [0]
answer = 0
second_right = 0
second_right_array = []
second_right_prefix = [0]
while left < n:
if right < left:
right = left
while right < n and a[right] >= right-left+1:
right += 1
right_array.append(right)
right_prefix.append(right_prefix[-1]+right_array[-1])
answer += right - left
if second_right <= right:
second_right = right + 1
if second_right > n:
second_right = n
while second_right < n and a[second_right] >= second_right-left+1:
second_right += 1
second_right_array.append(second_right)
second_right_prefix.append(second_right_prefix[-1]+second_right_array[-1])
left += 1
p_to_right = defaultdict(list)
for i in range(n):
p_to_right[right_array[i]].append(i)
q = int(stdin.readline())
for _ in range(q):
p, x = [int(z) for z in stdin.readline().split()]
p -= 1
if x == a[p]:
adjustment = 0
elif x < a[p]:
if right_array[-1] <= p:
adjustment = 0
else:
upper = n-1
lower = -1
while upper - lower > 1:
candidate = (upper + lower)//2
if right_array[candidate] > p:
# TODO: Your code here
else:
lower = candidate
if upper > p-x:
adjustment = 0
else:
adjustment = -(right_prefix[p-x+1] - right_prefix[upper] - p*(p-x-upper+1))
else:
if len(p_to_right[p]) == 0:
adjustment = 0
elif p_to_right[p][0] > p-a[p] or p_to_right[p][-1] < p-x+1:
adjustment = 0
else:
lower = max(p-x+1, p_to_right[p][0])
upper = min(p-a[p], p_to_right[p][-1])
adjustment = second_right_prefix[upper+1] - second_right_prefix[lower] - p*(upper-lower+1)
stdout.write(str(answer+adjustment)+'\n')
|
from sys import stdin, stdout
from collections import defaultdict
n = int(stdin.readline())
a = [int(x) for x in stdin.readline().split()]
left = 0
right = 0
right_array = []
right_prefix = [0]
answer = 0
second_right = 0
second_right_array = []
second_right_prefix = [0]
while left < n:
if right < left:
right = left
while right < n and a[right] >= right-left+1:
right += 1
right_array.append(right)
right_prefix.append(right_prefix[-1]+right_array[-1])
answer += right - left
if second_right <= right:
second_right = right + 1
if second_right > n:
second_right = n
while second_right < n and a[second_right] >= second_right-left+1:
second_right += 1
second_right_array.append(second_right)
second_right_prefix.append(second_right_prefix[-1]+second_right_array[-1])
left += 1
p_to_right = defaultdict(list)
for i in range(n):
p_to_right[right_array[i]].append(i)
q = int(stdin.readline())
for _ in range(q):
p, x = [int(z) for z in stdin.readline().split()]
p -= 1
if x == a[p]:
adjustment = 0
elif x < a[p]:
if right_array[-1] <= p:
adjustment = 0
else:
upper = n-1
lower = -1
while upper - lower > 1:
candidate = (upper + lower)//2
if right_array[candidate] > p:
{{completion}}
else:
lower = candidate
if upper > p-x:
adjustment = 0
else:
adjustment = -(right_prefix[p-x+1] - right_prefix[upper] - p*(p-x-upper+1))
else:
if len(p_to_right[p]) == 0:
adjustment = 0
elif p_to_right[p][0] > p-a[p] or p_to_right[p][-1] < p-x+1:
adjustment = 0
else:
lower = max(p-x+1, p_to_right[p][0])
upper = min(p-a[p], p_to_right[p][-1])
adjustment = second_right_prefix[upper+1] - second_right_prefix[lower] - p*(upper-lower+1)
stdout.write(str(answer+adjustment)+'\n')
|
upper = candidate
|
[{"input": "4\n2 4 1 4\n3\n2 4\n3 3\n2 1", "output": ["6\n10\n5"]}, {"input": "5\n1 1 3 2 1\n3\n1 3\n2 5\n4 5", "output": ["7\n9\n8"]}]
|
block_completion_007069
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: Madoka decided to participate in an underground sports programming competition. And there was exactly one task in it:A square table of size $$$n \times n$$$, where $$$n$$$ is a multiple of $$$k$$$, is called good if only the characters '.' and 'X' are written in it, as well as in any subtable of size $$$1 \times k$$$ or $$$k \times 1$$$, there is at least one character 'X'. In other words, among any $$$k$$$ consecutive vertical or horizontal cells, there must be at least one containing the character 'X'.Output any good table that has the minimum possible number of characters 'X', and also the symbol 'X' is written in the cell $$$(r, c)$$$. Rows are numbered from $$$1$$$ to $$$n$$$ from top to bottom, columns are numbered from $$$1$$$ to $$$n$$$ from left to right.
Input Specification: The input consists of multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \le t \le 100$$$) — the number of test cases. Description of the test cases follows. The first and the only line of each test case contains four integers $$$n$$$, $$$k$$$, $$$r$$$, $$$c$$$ ($$$1 \le n \le 500, 1 \le k \le n, 1 \le r, c \le n$$$) — the size of the table, the integer $$$k$$$ and the coordinates of the cell, which must contain the character 'X'. It is guaranteed that $$$n$$$ is a multiple of $$$k$$$. It is guaranteed that the sum of $$$n$$$ over all test cases does not exceed $$$500$$$.
Output Specification: For each test case, output $$$n$$$ lines, each consisting of $$$n$$$ characters '.' and 'X', — the desired table. If there are several answers, then you can output anyone.
Notes: NoteLet's analyze the first test case.The following tables can be printed as the correct answer: X....X.X. or ..XX...X. It can be proved that there cannot be less than $$$3$$$ characters 'X' in the answer.Note that the following table is invalid because cell $$$(3, 2)$$$ does not contain the character 'X': X...X...X In the second test case, the only correct table is: XXXX Each subtable of size $$$1 \times 1$$$ must contain a 'X' character, so all characters in the table must be equal to 'X'.
Code:
import sys
if __name__ == "__main__":
input_arr = sys.stdin.read().split()
tc = int(input_arr[0])
pos = 1
for case in range(tc):
n, k, r, c = list(map(int, input_arr[pos:pos + 4]))
pos += 4
mat = [["." for _ in range(n)] for j in range(n)]
r = r - 1
c = c - 1
l = n // k
for j in range(n):
for ll in range(l):
# TODO: Your code here
r -= 1
c += 1
for i in mat:
for j in i:
print(j, end="")
print("")
# '3 3 3 3 2 2 1 1 2 6 3 4 2'
|
import sys
if __name__ == "__main__":
input_arr = sys.stdin.read().split()
tc = int(input_arr[0])
pos = 1
for case in range(tc):
n, k, r, c = list(map(int, input_arr[pos:pos + 4]))
pos += 4
mat = [["." for _ in range(n)] for j in range(n)]
r = r - 1
c = c - 1
l = n // k
for j in range(n):
for ll in range(l):
{{completion}}
r -= 1
c += 1
for i in mat:
for j in i:
print(j, end="")
print("")
# '3 3 3 3 2 2 1 1 2 6 3 4 2'
|
mat[(r+ll*k) % n][c % n] = 'X'
mat[r][(c + ll*k) % n] = 'X'
|
[{"input": "3\n\n3 3 3 2\n\n2 1 1 2\n\n6 3 4 2", "output": ["X..\n..X\n.X.\nXX\nXX\n.X..X.\nX..X..\n..X..X\n.X..X.\nX..X..\n..X..X"]}]
|
block_completion_007166
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: Madoka decided to participate in an underground sports programming competition. And there was exactly one task in it:A square table of size $$$n \times n$$$, where $$$n$$$ is a multiple of $$$k$$$, is called good if only the characters '.' and 'X' are written in it, as well as in any subtable of size $$$1 \times k$$$ or $$$k \times 1$$$, there is at least one character 'X'. In other words, among any $$$k$$$ consecutive vertical or horizontal cells, there must be at least one containing the character 'X'.Output any good table that has the minimum possible number of characters 'X', and also the symbol 'X' is written in the cell $$$(r, c)$$$. Rows are numbered from $$$1$$$ to $$$n$$$ from top to bottom, columns are numbered from $$$1$$$ to $$$n$$$ from left to right.
Input Specification: The input consists of multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \le t \le 100$$$) — the number of test cases. Description of the test cases follows. The first and the only line of each test case contains four integers $$$n$$$, $$$k$$$, $$$r$$$, $$$c$$$ ($$$1 \le n \le 500, 1 \le k \le n, 1 \le r, c \le n$$$) — the size of the table, the integer $$$k$$$ and the coordinates of the cell, which must contain the character 'X'. It is guaranteed that $$$n$$$ is a multiple of $$$k$$$. It is guaranteed that the sum of $$$n$$$ over all test cases does not exceed $$$500$$$.
Output Specification: For each test case, output $$$n$$$ lines, each consisting of $$$n$$$ characters '.' and 'X', — the desired table. If there are several answers, then you can output anyone.
Notes: NoteLet's analyze the first test case.The following tables can be printed as the correct answer: X....X.X. or ..XX...X. It can be proved that there cannot be less than $$$3$$$ characters 'X' in the answer.Note that the following table is invalid because cell $$$(3, 2)$$$ does not contain the character 'X': X...X...X In the second test case, the only correct table is: XXXX Each subtable of size $$$1 \times 1$$$ must contain a 'X' character, so all characters in the table must be equal to 'X'.
Code:
import sys
if __name__ == "__main__":
input_arr = sys.stdin.read().split()
tc = int(input_arr[0])
pos = 1
for case in range(tc):
n, k, r, c = list(map(int, input_arr[pos:pos + 4]))
pos += 4
mat = [["." for _ in range(n)] for j in range(n)]
r = r - 1
c = c - 1
l = n // k
for j in range(n):
for ll in range(l):
mat[(r+ll*k) % n][c % n] = 'X'
mat[r][(c + ll*k) % n] = 'X'
r -= 1
c += 1
for i in mat:
for j in i:
# TODO: Your code here
print("")
# '3 3 3 3 2 2 1 1 2 6 3 4 2'
|
import sys
if __name__ == "__main__":
input_arr = sys.stdin.read().split()
tc = int(input_arr[0])
pos = 1
for case in range(tc):
n, k, r, c = list(map(int, input_arr[pos:pos + 4]))
pos += 4
mat = [["." for _ in range(n)] for j in range(n)]
r = r - 1
c = c - 1
l = n // k
for j in range(n):
for ll in range(l):
mat[(r+ll*k) % n][c % n] = 'X'
mat[r][(c + ll*k) % n] = 'X'
r -= 1
c += 1
for i in mat:
for j in i:
{{completion}}
print("")
# '3 3 3 3 2 2 1 1 2 6 3 4 2'
|
print(j, end="")
|
[{"input": "3\n\n3 3 3 2\n\n2 1 1 2\n\n6 3 4 2", "output": ["X..\n..X\n.X.\nXX\nXX\n.X..X.\nX..X..\n..X..X\n.X..X.\nX..X..\n..X..X"]}]
|
block_completion_007167
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You work in the quality control department of technical support for a large company. Your job is to make sure all client issues have been resolved.Today you need to check a copy of a dialog between a client and a technical support manager. According to the rules of work, each message of the client must be followed by one or several messages, which are the answer of a support manager. However, sometimes clients ask questions so quickly that some of the manager's answers to old questions appear after the client has asked some new questions.Due to the privacy policy, the full text of messages is not available to you, only the order of messages is visible, as well as the type of each message: a customer question or a response from the technical support manager. It is guaranteed that the dialog begins with the question of the client.You have to determine, if this dialog may correspond to the rules of work described above, or the rules are certainly breached.
Input Specification: Each test contains multiple test cases. The first line contains the number of test cases $$$t$$$ ($$$1 \le t \le 500$$$). Description of the test cases follows. The first line of each test case contains one integer $$$n$$$ ($$$1 \le n \le 100$$$) — the total number of messages in the dialog. The second line of each test case consists of $$$n$$$ characters "Q" and "A", describing types of messages in the dialog in chronological order. Character "Q" denotes the message with client question, and character "A" — the message with technical support manager answer. It is guaranteed that the first character in the line equals to "Q".
Output Specification: For each test case print "Yes" (without quotes) if dialog may correspond to the rules of work, or "No" (without quotes) otherwise.
Notes: NoteIn the first test case the two questions from the client are followed with two specialist's answers. So this dialog may correspond to the rules of work.In the second test case one of the first two questions was not answered.In the third test case the technical support manager sent two messaged as the answer to the only message of the client.
Code:
import fileinput
def f(n):
i = 0
while i<len(n):
if n[i] == "Q":
found = False
for j in range(i,len(n)):
if n[j] == "A":
# TODO: Your code here
if not found:
print("NO")
return
i += 1
print("YES")
for line in fileinput.input():
if len(line) > 0 and line[0] == "Q":
f(line)
|
import fileinput
def f(n):
i = 0
while i<len(n):
if n[i] == "Q":
found = False
for j in range(i,len(n)):
if n[j] == "A":
{{completion}}
if not found:
print("NO")
return
i += 1
print("YES")
for line in fileinput.input():
if len(line) > 0 and line[0] == "Q":
f(line)
|
n = n[:j] + n[j+1:]
found = True
break
|
[{"input": "5\n\n4\n\nQQAA\n\n4\n\nQQAQ\n\n3\n\nQAA\n\n1\n\nQ\n\n14\n\nQAQQAQAAQQQAAA", "output": ["Yes\nNo\nYes\nNo\nYes"]}]
|
block_completion_007322
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: We say an infinite sequence $$$a_{0}, a_{1}, a_2, \ldots$$$ is non-increasing if and only if for all $$$i\ge 0$$$, $$$a_i \ge a_{i+1}$$$.There is an infinite right and down grid. The upper-left cell has coordinates $$$(0,0)$$$. Rows are numbered $$$0$$$ to infinity from top to bottom, columns are numbered from $$$0$$$ to infinity from left to right.There is also a non-increasing infinite sequence $$$a_{0}, a_{1}, a_2, \ldots$$$. You are given $$$a_0$$$, $$$a_1$$$, $$$\ldots$$$, $$$a_n$$$; for all $$$i>n$$$, $$$a_i=0$$$. For every pair of $$$x$$$, $$$y$$$, the cell with coordinates $$$(x,y)$$$ (which is located at the intersection of $$$x$$$-th row and $$$y$$$-th column) is white if $$$y<a_x$$$ and black otherwise.Initially there is one doll named Jina on $$$(0,0)$$$. You can do the following operation. Select one doll on $$$(x,y)$$$. Remove it and place a doll on $$$(x,y+1)$$$ and place a doll on $$$(x+1,y)$$$. Note that multiple dolls can be present at a cell at the same time; in one operation, you remove only one. Your goal is to make all white cells contain $$$0$$$ dolls.What's the minimum number of operations needed to achieve the goal? Print the answer modulo $$$10^9+7$$$.
Input Specification: The first line of input contains one integer $$$n$$$ ($$$1\le n\le 2\cdot 10^5$$$). The second line of input contains $$$n+1$$$ integers $$$a_0,a_1,\ldots,a_n$$$ ($$$0\le a_i\le 2\cdot 10^5$$$). It is guaranteed that the sequence $$$a$$$ is non-increasing.
Output Specification: Print one integer — the answer to the problem, modulo $$$10^9+7$$$.
Notes: NoteConsider the first example. In the given grid, cells $$$(0,0),(0,1),(1,0),(1,1)$$$ are white, and all other cells are black. Let us use triples to describe the grid: triple $$$(x,y,z)$$$ means that there are $$$z$$$ dolls placed on cell $$$(x,y)$$$. Initially the state of the grid is $$$(0,0,1)$$$.One of the optimal sequence of operations is as follows: Do the operation with $$$(0,0)$$$. Now the state of the grid is $$$(1,0,1),(0,1,1)$$$. Do the operation with $$$(0,1)$$$. Now the state of the grid is $$$(1,0,1),(1,1,1),(0,2,1)$$$. Do the operation with $$$(1,0)$$$. Now the state of the grid is $$$(1,1,2),(0,2,1),(2,0,1)$$$. Do the operation with $$$(1,1)$$$. Now the state of the grid is $$$(1,1,1),(0,2,1),(2,0,1),(1,2,1),(2,1,1)$$$. Do the operation with $$$(1,1)$$$. Now the state of the grid is $$$(0,2,1),(2,0,1),(1,2,2),(2,1,2)$$$. Now all white cells contain $$$0$$$ dolls, so we have achieved the goal with $$$5$$$ operations.
Code:
n,x,d,m,f=int(input()),0,0,10**9+7,[1]
for i in range(1,9**6):# TODO: Your code here
for z in map(int,input().split()):d+=f[z+x]*pow(f[x+1]*f[z-1],-1,m)*(z>0);x+=1
print(d%m)
|
n,x,d,m,f=int(input()),0,0,10**9+7,[1]
for i in range(1,9**6):{{completion}}
for z in map(int,input().split()):d+=f[z+x]*pow(f[x+1]*f[z-1],-1,m)*(z>0);x+=1
print(d%m)
|
f.append(f[-1]*i%m)
|
[{"input": "2\n2 2 0", "output": ["5"]}, {"input": "10\n12 11 8 8 6 6 6 5 3 2 1", "output": ["2596"]}]
|
block_completion_007437
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: We say an infinite sequence $$$a_{0}, a_{1}, a_2, \ldots$$$ is non-increasing if and only if for all $$$i\ge 0$$$, $$$a_i \ge a_{i+1}$$$.There is an infinite right and down grid. The upper-left cell has coordinates $$$(0,0)$$$. Rows are numbered $$$0$$$ to infinity from top to bottom, columns are numbered from $$$0$$$ to infinity from left to right.There is also a non-increasing infinite sequence $$$a_{0}, a_{1}, a_2, \ldots$$$. You are given $$$a_0$$$, $$$a_1$$$, $$$\ldots$$$, $$$a_n$$$; for all $$$i>n$$$, $$$a_i=0$$$. For every pair of $$$x$$$, $$$y$$$, the cell with coordinates $$$(x,y)$$$ (which is located at the intersection of $$$x$$$-th row and $$$y$$$-th column) is white if $$$y<a_x$$$ and black otherwise.Initially there is one doll named Jina on $$$(0,0)$$$. You can do the following operation. Select one doll on $$$(x,y)$$$. Remove it and place a doll on $$$(x,y+1)$$$ and place a doll on $$$(x+1,y)$$$. Note that multiple dolls can be present at a cell at the same time; in one operation, you remove only one. Your goal is to make all white cells contain $$$0$$$ dolls.What's the minimum number of operations needed to achieve the goal? Print the answer modulo $$$10^9+7$$$.
Input Specification: The first line of input contains one integer $$$n$$$ ($$$1\le n\le 2\cdot 10^5$$$). The second line of input contains $$$n+1$$$ integers $$$a_0,a_1,\ldots,a_n$$$ ($$$0\le a_i\le 2\cdot 10^5$$$). It is guaranteed that the sequence $$$a$$$ is non-increasing.
Output Specification: Print one integer — the answer to the problem, modulo $$$10^9+7$$$.
Notes: NoteConsider the first example. In the given grid, cells $$$(0,0),(0,1),(1,0),(1,1)$$$ are white, and all other cells are black. Let us use triples to describe the grid: triple $$$(x,y,z)$$$ means that there are $$$z$$$ dolls placed on cell $$$(x,y)$$$. Initially the state of the grid is $$$(0,0,1)$$$.One of the optimal sequence of operations is as follows: Do the operation with $$$(0,0)$$$. Now the state of the grid is $$$(1,0,1),(0,1,1)$$$. Do the operation with $$$(0,1)$$$. Now the state of the grid is $$$(1,0,1),(1,1,1),(0,2,1)$$$. Do the operation with $$$(1,0)$$$. Now the state of the grid is $$$(1,1,2),(0,2,1),(2,0,1)$$$. Do the operation with $$$(1,1)$$$. Now the state of the grid is $$$(1,1,1),(0,2,1),(2,0,1),(1,2,1),(2,1,1)$$$. Do the operation with $$$(1,1)$$$. Now the state of the grid is $$$(0,2,1),(2,0,1),(1,2,2),(2,1,2)$$$. Now all white cells contain $$$0$$$ dolls, so we have achieved the goal with $$$5$$$ operations.
Code:
n,x,d,m,f=int(input()),0,0,10**9+7,[1]
for i in range(1,9**6):f.append(f[-1]*i%m)
for z in map(int,input().split()):# TODO: Your code here
print(d%m)
|
n,x,d,m,f=int(input()),0,0,10**9+7,[1]
for i in range(1,9**6):f.append(f[-1]*i%m)
for z in map(int,input().split()):{{completion}}
print(d%m)
|
d+=f[z+x]*pow(f[x+1]*f[z-1],-1,m)*(z>0);x+=1
|
[{"input": "2\n2 2 0", "output": ["5"]}, {"input": "10\n12 11 8 8 6 6 6 5 3 2 1", "output": ["2596"]}]
|
block_completion_007438
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: We say an infinite sequence $$$a_{0}, a_{1}, a_2, \ldots$$$ is non-increasing if and only if for all $$$i\ge 0$$$, $$$a_i \ge a_{i+1}$$$.There is an infinite right and down grid. The upper-left cell has coordinates $$$(0,0)$$$. Rows are numbered $$$0$$$ to infinity from top to bottom, columns are numbered from $$$0$$$ to infinity from left to right.There is also a non-increasing infinite sequence $$$a_{0}, a_{1}, a_2, \ldots$$$. You are given $$$a_0$$$, $$$a_1$$$, $$$\ldots$$$, $$$a_n$$$; for all $$$i>n$$$, $$$a_i=0$$$. For every pair of $$$x$$$, $$$y$$$, the cell with coordinates $$$(x,y)$$$ (which is located at the intersection of $$$x$$$-th row and $$$y$$$-th column) is white if $$$y<a_x$$$ and black otherwise.Initially there is one doll named Jina on $$$(0,0)$$$. You can do the following operation. Select one doll on $$$(x,y)$$$. Remove it and place a doll on $$$(x,y+1)$$$ and place a doll on $$$(x+1,y)$$$. Note that multiple dolls can be present at a cell at the same time; in one operation, you remove only one. Your goal is to make all white cells contain $$$0$$$ dolls.What's the minimum number of operations needed to achieve the goal? Print the answer modulo $$$10^9+7$$$.
Input Specification: The first line of input contains one integer $$$n$$$ ($$$1\le n\le 2\cdot 10^5$$$). The second line of input contains $$$n+1$$$ integers $$$a_0,a_1,\ldots,a_n$$$ ($$$0\le a_i\le 2\cdot 10^5$$$). It is guaranteed that the sequence $$$a$$$ is non-increasing.
Output Specification: Print one integer — the answer to the problem, modulo $$$10^9+7$$$.
Notes: NoteConsider the first example. In the given grid, cells $$$(0,0),(0,1),(1,0),(1,1)$$$ are white, and all other cells are black. Let us use triples to describe the grid: triple $$$(x,y,z)$$$ means that there are $$$z$$$ dolls placed on cell $$$(x,y)$$$. Initially the state of the grid is $$$(0,0,1)$$$.One of the optimal sequence of operations is as follows: Do the operation with $$$(0,0)$$$. Now the state of the grid is $$$(1,0,1),(0,1,1)$$$. Do the operation with $$$(0,1)$$$. Now the state of the grid is $$$(1,0,1),(1,1,1),(0,2,1)$$$. Do the operation with $$$(1,0)$$$. Now the state of the grid is $$$(1,1,2),(0,2,1),(2,0,1)$$$. Do the operation with $$$(1,1)$$$. Now the state of the grid is $$$(1,1,1),(0,2,1),(2,0,1),(1,2,1),(2,1,1)$$$. Do the operation with $$$(1,1)$$$. Now the state of the grid is $$$(0,2,1),(2,0,1),(1,2,2),(2,1,2)$$$. Now all white cells contain $$$0$$$ dolls, so we have achieved the goal with $$$5$$$ operations.
Code:
from math import gcd
mod=1_000_000_007
maxn=400_100
fac=[1]*maxn
for i in range(2,maxn):
fac[i]=(fac[i-1]*i)%mod
def inv(b,m):
return pow(b, m - 2, m)
n=int(input())
a=list(map(int,input().split()))
o=0
for i in range(n+1):
if a[i]==0: # TODO: Your code here
c=fac[a[i]+i]*inv(fac[i+1]*fac[a[i]-1],mod)
o=(o+c)%mod
print(o)
|
from math import gcd
mod=1_000_000_007
maxn=400_100
fac=[1]*maxn
for i in range(2,maxn):
fac[i]=(fac[i-1]*i)%mod
def inv(b,m):
return pow(b, m - 2, m)
n=int(input())
a=list(map(int,input().split()))
o=0
for i in range(n+1):
if a[i]==0: {{completion}}
c=fac[a[i]+i]*inv(fac[i+1]*fac[a[i]-1],mod)
o=(o+c)%mod
print(o)
|
break
|
[{"input": "2\n2 2 0", "output": ["5"]}, {"input": "10\n12 11 8 8 6 6 6 5 3 2 1", "output": ["2596"]}]
|
block_completion_007439
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: We say an infinite sequence $$$a_{0}, a_{1}, a_2, \ldots$$$ is non-increasing if and only if for all $$$i\ge 0$$$, $$$a_i \ge a_{i+1}$$$.There is an infinite right and down grid. The upper-left cell has coordinates $$$(0,0)$$$. Rows are numbered $$$0$$$ to infinity from top to bottom, columns are numbered from $$$0$$$ to infinity from left to right.There is also a non-increasing infinite sequence $$$a_{0}, a_{1}, a_2, \ldots$$$. You are given $$$a_0$$$, $$$a_1$$$, $$$\ldots$$$, $$$a_n$$$; for all $$$i>n$$$, $$$a_i=0$$$. For every pair of $$$x$$$, $$$y$$$, the cell with coordinates $$$(x,y)$$$ (which is located at the intersection of $$$x$$$-th row and $$$y$$$-th column) is white if $$$y<a_x$$$ and black otherwise.Initially there is one doll named Jina on $$$(0,0)$$$. You can do the following operation. Select one doll on $$$(x,y)$$$. Remove it and place a doll on $$$(x,y+1)$$$ and place a doll on $$$(x+1,y)$$$. Note that multiple dolls can be present at a cell at the same time; in one operation, you remove only one. Your goal is to make all white cells contain $$$0$$$ dolls.What's the minimum number of operations needed to achieve the goal? Print the answer modulo $$$10^9+7$$$.
Input Specification: The first line of input contains one integer $$$n$$$ ($$$1\le n\le 2\cdot 10^5$$$). The second line of input contains $$$n+1$$$ integers $$$a_0,a_1,\ldots,a_n$$$ ($$$0\le a_i\le 2\cdot 10^5$$$). It is guaranteed that the sequence $$$a$$$ is non-increasing.
Output Specification: Print one integer — the answer to the problem, modulo $$$10^9+7$$$.
Notes: NoteConsider the first example. In the given grid, cells $$$(0,0),(0,1),(1,0),(1,1)$$$ are white, and all other cells are black. Let us use triples to describe the grid: triple $$$(x,y,z)$$$ means that there are $$$z$$$ dolls placed on cell $$$(x,y)$$$. Initially the state of the grid is $$$(0,0,1)$$$.One of the optimal sequence of operations is as follows: Do the operation with $$$(0,0)$$$. Now the state of the grid is $$$(1,0,1),(0,1,1)$$$. Do the operation with $$$(0,1)$$$. Now the state of the grid is $$$(1,0,1),(1,1,1),(0,2,1)$$$. Do the operation with $$$(1,0)$$$. Now the state of the grid is $$$(1,1,2),(0,2,1),(2,0,1)$$$. Do the operation with $$$(1,1)$$$. Now the state of the grid is $$$(1,1,1),(0,2,1),(2,0,1),(1,2,1),(2,1,1)$$$. Do the operation with $$$(1,1)$$$. Now the state of the grid is $$$(0,2,1),(2,0,1),(1,2,2),(2,1,2)$$$. Now all white cells contain $$$0$$$ dolls, so we have achieved the goal with $$$5$$$ operations.
Code:
N = 4 * 10**5 + 5
MOD = 10**9 + 7
fact = [1]
invf = [1]
for i in range(1, N):
fact.append(fact[i-1] * i % MOD)
invf.append(pow(fact[-1], MOD-2, MOD))
def C(m, n):
if n < 0 or m < n:
# TODO: Your code here
return fact[m] * invf[n] % MOD * invf[m-n] % MOD
n = int(input())
a = list(map(int, input().split()))
ans = sum(C(v+i, i+1) for i, v in enumerate(a)) % MOD
print(ans)
|
N = 4 * 10**5 + 5
MOD = 10**9 + 7
fact = [1]
invf = [1]
for i in range(1, N):
fact.append(fact[i-1] * i % MOD)
invf.append(pow(fact[-1], MOD-2, MOD))
def C(m, n):
if n < 0 or m < n:
{{completion}}
return fact[m] * invf[n] % MOD * invf[m-n] % MOD
n = int(input())
a = list(map(int, input().split()))
ans = sum(C(v+i, i+1) for i, v in enumerate(a)) % MOD
print(ans)
|
return 0
|
[{"input": "2\n2 2 0", "output": ["5"]}, {"input": "10\n12 11 8 8 6 6 6 5 3 2 1", "output": ["2596"]}]
|
block_completion_007440
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: We say an infinite sequence $$$a_{0}, a_{1}, a_2, \ldots$$$ is non-increasing if and only if for all $$$i\ge 0$$$, $$$a_i \ge a_{i+1}$$$.There is an infinite right and down grid. The upper-left cell has coordinates $$$(0,0)$$$. Rows are numbered $$$0$$$ to infinity from top to bottom, columns are numbered from $$$0$$$ to infinity from left to right.There is also a non-increasing infinite sequence $$$a_{0}, a_{1}, a_2, \ldots$$$. You are given $$$a_0$$$, $$$a_1$$$, $$$\ldots$$$, $$$a_n$$$; for all $$$i>n$$$, $$$a_i=0$$$. For every pair of $$$x$$$, $$$y$$$, the cell with coordinates $$$(x,y)$$$ (which is located at the intersection of $$$x$$$-th row and $$$y$$$-th column) is white if $$$y<a_x$$$ and black otherwise.Initially there is one doll named Jina on $$$(0,0)$$$. You can do the following operation. Select one doll on $$$(x,y)$$$. Remove it and place a doll on $$$(x,y+1)$$$ and place a doll on $$$(x+1,y)$$$. Note that multiple dolls can be present at a cell at the same time; in one operation, you remove only one. Your goal is to make all white cells contain $$$0$$$ dolls.What's the minimum number of operations needed to achieve the goal? Print the answer modulo $$$10^9+7$$$.
Input Specification: The first line of input contains one integer $$$n$$$ ($$$1\le n\le 2\cdot 10^5$$$). The second line of input contains $$$n+1$$$ integers $$$a_0,a_1,\ldots,a_n$$$ ($$$0\le a_i\le 2\cdot 10^5$$$). It is guaranteed that the sequence $$$a$$$ is non-increasing.
Output Specification: Print one integer — the answer to the problem, modulo $$$10^9+7$$$.
Notes: NoteConsider the first example. In the given grid, cells $$$(0,0),(0,1),(1,0),(1,1)$$$ are white, and all other cells are black. Let us use triples to describe the grid: triple $$$(x,y,z)$$$ means that there are $$$z$$$ dolls placed on cell $$$(x,y)$$$. Initially the state of the grid is $$$(0,0,1)$$$.One of the optimal sequence of operations is as follows: Do the operation with $$$(0,0)$$$. Now the state of the grid is $$$(1,0,1),(0,1,1)$$$. Do the operation with $$$(0,1)$$$. Now the state of the grid is $$$(1,0,1),(1,1,1),(0,2,1)$$$. Do the operation with $$$(1,0)$$$. Now the state of the grid is $$$(1,1,2),(0,2,1),(2,0,1)$$$. Do the operation with $$$(1,1)$$$. Now the state of the grid is $$$(1,1,1),(0,2,1),(2,0,1),(1,2,1),(2,1,1)$$$. Do the operation with $$$(1,1)$$$. Now the state of the grid is $$$(0,2,1),(2,0,1),(1,2,2),(2,1,2)$$$. Now all white cells contain $$$0$$$ dolls, so we have achieved the goal with $$$5$$$ operations.
Code:
import sys
input = sys.stdin.readline
MOD = 10 ** 9 + 7
n = int(input())
a = [int(x) for x in input().split()]
fac = [1]
for i in range(8 * 10 ** 5 - 1):
fac.append((fac[-1] * (i + 1)) % MOD)
ans = 0
for i in range(n + 1):
if a[i] != 0:
# TODO: Your code here
print(int(ans % MOD))
|
import sys
input = sys.stdin.readline
MOD = 10 ** 9 + 7
n = int(input())
a = [int(x) for x in input().split()]
fac = [1]
for i in range(8 * 10 ** 5 - 1):
fac.append((fac[-1] * (i + 1)) % MOD)
ans = 0
for i in range(n + 1):
if a[i] != 0:
{{completion}}
print(int(ans % MOD))
|
ans = (ans + fac[a[i] + i] * pow((fac[i + 1] * fac[a[i] - 1]), -1, MOD))
|
[{"input": "2\n2 2 0", "output": ["5"]}, {"input": "10\n12 11 8 8 6 6 6 5 3 2 1", "output": ["2596"]}]
|
block_completion_007441
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: We say an infinite sequence $$$a_{0}, a_{1}, a_2, \ldots$$$ is non-increasing if and only if for all $$$i\ge 0$$$, $$$a_i \ge a_{i+1}$$$.There is an infinite right and down grid. The upper-left cell has coordinates $$$(0,0)$$$. Rows are numbered $$$0$$$ to infinity from top to bottom, columns are numbered from $$$0$$$ to infinity from left to right.There is also a non-increasing infinite sequence $$$a_{0}, a_{1}, a_2, \ldots$$$. You are given $$$a_0$$$, $$$a_1$$$, $$$\ldots$$$, $$$a_n$$$; for all $$$i>n$$$, $$$a_i=0$$$. For every pair of $$$x$$$, $$$y$$$, the cell with coordinates $$$(x,y)$$$ (which is located at the intersection of $$$x$$$-th row and $$$y$$$-th column) is white if $$$y<a_x$$$ and black otherwise.Initially there is one doll named Jina on $$$(0,0)$$$. You can do the following operation. Select one doll on $$$(x,y)$$$. Remove it and place a doll on $$$(x,y+1)$$$ and place a doll on $$$(x+1,y)$$$. Note that multiple dolls can be present at a cell at the same time; in one operation, you remove only one. Your goal is to make all white cells contain $$$0$$$ dolls.What's the minimum number of operations needed to achieve the goal? Print the answer modulo $$$10^9+7$$$.
Input Specification: The first line of input contains one integer $$$n$$$ ($$$1\le n\le 2\cdot 10^5$$$). The second line of input contains $$$n+1$$$ integers $$$a_0,a_1,\ldots,a_n$$$ ($$$0\le a_i\le 2\cdot 10^5$$$). It is guaranteed that the sequence $$$a$$$ is non-increasing.
Output Specification: Print one integer — the answer to the problem, modulo $$$10^9+7$$$.
Notes: NoteConsider the first example. In the given grid, cells $$$(0,0),(0,1),(1,0),(1,1)$$$ are white, and all other cells are black. Let us use triples to describe the grid: triple $$$(x,y,z)$$$ means that there are $$$z$$$ dolls placed on cell $$$(x,y)$$$. Initially the state of the grid is $$$(0,0,1)$$$.One of the optimal sequence of operations is as follows: Do the operation with $$$(0,0)$$$. Now the state of the grid is $$$(1,0,1),(0,1,1)$$$. Do the operation with $$$(0,1)$$$. Now the state of the grid is $$$(1,0,1),(1,1,1),(0,2,1)$$$. Do the operation with $$$(1,0)$$$. Now the state of the grid is $$$(1,1,2),(0,2,1),(2,0,1)$$$. Do the operation with $$$(1,1)$$$. Now the state of the grid is $$$(1,1,1),(0,2,1),(2,0,1),(1,2,1),(2,1,1)$$$. Do the operation with $$$(1,1)$$$. Now the state of the grid is $$$(0,2,1),(2,0,1),(1,2,2),(2,1,2)$$$. Now all white cells contain $$$0$$$ dolls, so we have achieved the goal with $$$5$$$ operations.
Code:
n,x,d,m,f=int(input()),0,0,10**9+7,[1]
for i in range(1,9**6): # TODO: Your code here
for z in list(map(int,input().split())):
d+=f[z+x]*pow(f[x+1]*f[z-1],m-2,m)*(z!=0)
x+=1
print(d%m)
|
n,x,d,m,f=int(input()),0,0,10**9+7,[1]
for i in range(1,9**6): {{completion}}
for z in list(map(int,input().split())):
d+=f[z+x]*pow(f[x+1]*f[z-1],m-2,m)*(z!=0)
x+=1
print(d%m)
|
f.append(f[-1]*i%m)
|
[{"input": "2\n2 2 0", "output": ["5"]}, {"input": "10\n12 11 8 8 6 6 6 5 3 2 1", "output": ["2596"]}]
|
block_completion_007442
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: We say an infinite sequence $$$a_{0}, a_{1}, a_2, \ldots$$$ is non-increasing if and only if for all $$$i\ge 0$$$, $$$a_i \ge a_{i+1}$$$.There is an infinite right and down grid. The upper-left cell has coordinates $$$(0,0)$$$. Rows are numbered $$$0$$$ to infinity from top to bottom, columns are numbered from $$$0$$$ to infinity from left to right.There is also a non-increasing infinite sequence $$$a_{0}, a_{1}, a_2, \ldots$$$. You are given $$$a_0$$$, $$$a_1$$$, $$$\ldots$$$, $$$a_n$$$; for all $$$i>n$$$, $$$a_i=0$$$. For every pair of $$$x$$$, $$$y$$$, the cell with coordinates $$$(x,y)$$$ (which is located at the intersection of $$$x$$$-th row and $$$y$$$-th column) is white if $$$y<a_x$$$ and black otherwise.Initially there is one doll named Jina on $$$(0,0)$$$. You can do the following operation. Select one doll on $$$(x,y)$$$. Remove it and place a doll on $$$(x,y+1)$$$ and place a doll on $$$(x+1,y)$$$. Note that multiple dolls can be present at a cell at the same time; in one operation, you remove only one. Your goal is to make all white cells contain $$$0$$$ dolls.What's the minimum number of operations needed to achieve the goal? Print the answer modulo $$$10^9+7$$$.
Input Specification: The first line of input contains one integer $$$n$$$ ($$$1\le n\le 2\cdot 10^5$$$). The second line of input contains $$$n+1$$$ integers $$$a_0,a_1,\ldots,a_n$$$ ($$$0\le a_i\le 2\cdot 10^5$$$). It is guaranteed that the sequence $$$a$$$ is non-increasing.
Output Specification: Print one integer — the answer to the problem, modulo $$$10^9+7$$$.
Notes: NoteConsider the first example. In the given grid, cells $$$(0,0),(0,1),(1,0),(1,1)$$$ are white, and all other cells are black. Let us use triples to describe the grid: triple $$$(x,y,z)$$$ means that there are $$$z$$$ dolls placed on cell $$$(x,y)$$$. Initially the state of the grid is $$$(0,0,1)$$$.One of the optimal sequence of operations is as follows: Do the operation with $$$(0,0)$$$. Now the state of the grid is $$$(1,0,1),(0,1,1)$$$. Do the operation with $$$(0,1)$$$. Now the state of the grid is $$$(1,0,1),(1,1,1),(0,2,1)$$$. Do the operation with $$$(1,0)$$$. Now the state of the grid is $$$(1,1,2),(0,2,1),(2,0,1)$$$. Do the operation with $$$(1,1)$$$. Now the state of the grid is $$$(1,1,1),(0,2,1),(2,0,1),(1,2,1),(2,1,1)$$$. Do the operation with $$$(1,1)$$$. Now the state of the grid is $$$(0,2,1),(2,0,1),(1,2,2),(2,1,2)$$$. Now all white cells contain $$$0$$$ dolls, so we have achieved the goal with $$$5$$$ operations.
Code:
n,x,d,m,f=int(input()),0,0,10**9+7,[1]
for i in range(1,9**6): f.append(f[-1]*i%m)
for z in list(map(int,input().split())):
# TODO: Your code here
print(d%m)
|
n,x,d,m,f=int(input()),0,0,10**9+7,[1]
for i in range(1,9**6): f.append(f[-1]*i%m)
for z in list(map(int,input().split())):
{{completion}}
print(d%m)
|
d+=f[z+x]*pow(f[x+1]*f[z-1],m-2,m)*(z!=0)
x+=1
|
[{"input": "2\n2 2 0", "output": ["5"]}, {"input": "10\n12 11 8 8 6 6 6 5 3 2 1", "output": ["2596"]}]
|
block_completion_007443
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: Mainak has a convex polygon $$$\mathcal P$$$ with $$$n$$$ vertices labelled as $$$A_1, A_2, \ldots, A_n$$$ in a counter-clockwise fashion. The coordinates of the $$$i$$$-th point $$$A_i$$$ are given by $$$(x_i, y_i)$$$, where $$$x_i$$$ and $$$y_i$$$ are both integers.Further, it is known that the interior angle at $$$A_i$$$ is either a right angle or a proper obtuse angle. Formally it is known that: $$$90 ^ \circ \le \angle A_{i - 1}A_{i}A_{i + 1} < 180 ^ \circ$$$, $$$\forall i \in \{1, 2, \ldots, n\}$$$ where we conventionally consider $$$A_0 = A_n$$$ and $$$A_{n + 1} = A_1$$$. Mainak's friend insisted that all points $$$Q$$$ such that there exists a chord of the polygon $$$\mathcal P$$$ passing through $$$Q$$$ with length not exceeding $$$1$$$, must be coloured $$$\color{red}{\text{red}}$$$. Mainak wants you to find the area of the coloured region formed by the $$$\color{red}{\text{red}}$$$ points.Formally, determine the area of the region $$$\mathcal S = \{Q \in \mathcal{P}$$$ | $$$Q \text{ is coloured } \color{red}{\text{red}}\}$$$.Recall that a chord of a polygon is a line segment between two points lying on the boundary (i.e. vertices or points on edges) of the polygon.
Input Specification: The first line contains an integer $$$n$$$ ($$$4 \le n \le 5000$$$) — the number of vertices of a polygon $$$\mathcal P$$$. The $$$i$$$-th line of the next $$$n$$$ lines contain two integers $$$x_i$$$ and $$$y_i$$$ ($$$-10^9 \le x_i, y_i \le 10^9$$$) — the coordinates of $$$A_i$$$. Additional constraint on the input: The vertices form a convex polygon and are listed in counter-clockwise order. It is also guaranteed that all interior angles are in the range $$$[90^\circ ; 180^\circ )$$$.
Output Specification: Print the area of the region coloured in $$$\color{red}{\text{red}}$$$. Your answer is considered correct if its absolute or relative error does not exceed $$$10^{-4}$$$. Formally, let your answer be $$$a$$$, and the jury's answer be $$$b$$$. Your answer is accepted if and only if $$$\frac{|a - b|}{\max{(1, |b|)}} \le 10^{-4}$$$.
Notes: NoteIn the first example, the polygon $$$\mathcal P$$$ can be visualised on the Cartesian Plane as:
Code:
import math
pi = 3.14159265358979323846264338327950288419716939937510
eps, sq2 = 1e-13, math.sqrt(2)
x, y = [], []
n = 0
def binary_find(la, lb, ra, rb, cy, fy, alpha_1, alpha_2, ab):
while math.fabs(cy - fy) > eps:
mid_y = cy / 2.0 + fy / 2.0
la = lb = 0.0
ra, rb = pi - alpha_1, pi - alpha_2
while math.fabs(ra - la) > eps:
mid_a = ra / 2.0 + la / 2.0
yy = - pow(math.sin(mid_a), 2) * math.cos(alpha_1 + mid_a) / math.sin(alpha_1)
if yy < mid_y:
# TODO: Your code here
if yy > mid_y:
ra = mid_a
while math.fabs(rb - lb) > eps:
mid_b = rb / 2.0 + lb / 2.0
yy = - pow(math.sin(mid_b), 2) * math.cos(alpha_2 + mid_b) / math.sin(alpha_2)
if yy < mid_y:
lb = mid_b
if yy > mid_y:
rb = mid_b
x1 = (2.0 * math.sin(la / 2.0 + ra / 2.0 + alpha_1) +
math.sin(la + ra) * math.cos(la / 2.0 + ra / 2.0 + alpha_1)) / (2 * math.sin(alpha_1))
x2 = ab - (2.0 * math.sin(lb / 2.0 + rb / 2.0 + alpha_2) +
math.sin(lb + rb) * math.cos(lb / 2.0 + rb / 2.0 + alpha_2)) / (2 * math.sin(alpha_2))
if x1 < x2:
cy = mid_y
if x1 > x2:
fy = mid_y
return la, lb, ra, rb, cy, fy
def get_area(_i, ni, i_, i_2):
ans = 0.00
ab = math.sqrt(pow((x[i_] - x[ni]), 2) + pow((y[i_] - y[ni]), 2))
ad = math.sqrt(pow((x[_i] - x[ni]), 2) + pow((y[_i] - y[ni]), 2))
bc = math.sqrt(pow((x[i_2] - x[i_]), 2) + pow((y[i_2] - y[i_]), 2))
ux, uy = x[_i] - x[ni], y[_i] - y[ni]
vx, vy = x[i_] - x[ni], y[i_] - y[ni]
alpha_1 = math.acos((ux * vx + uy * vy) / ab / ad)
if math.fabs(ab - sq2) < eps or math.fabs(ab - 1.00) < eps:
wx, wy = x[i_2] - x[i_], y[i_2] - y[i_]
alpha_2 = math.acos((-vx * wx - wy * vy) / ab / bc)
la, lb, ra, rb, cy, fy = 0.0, 0.0, pi - alpha_1, pi - alpha_2, min(alpha_1, alpha_2), 0.0000
la, lb, ra, rb, cy, fy = binary_find(la, lb, ra, rb, cy, fy, alpha_1, alpha_2, ab)
ans -= ((8.0 - 4.0 * math.cos(2.0 * alpha_1)) * la - 2.0 * math.sin(la * 2.0 + ra * 2.0) +
4.0 * math.sin(2.0 * alpha_1 + la + ra) - math.sin(2.0 * alpha_1 + 3.0 * la + 3.0 * ra)
- 5.0 * math.sin(2.0 * alpha_1)+ math.sin(2.0 * alpha_1 - la - ra)
+ math.sin(2.0 * (ra + la + alpha_1))) / (64.0 * math.sin(alpha_1) * math.sin(alpha_1))
ans -= ((8.0 - 4.0 * math.cos(2.0 * alpha_2)) * lb - 2.0 * math.sin(lb * 2.0 + rb * 2.0) +
4.0 * math.sin(2.0 * alpha_2 + lb + rb) - math.sin(2.0 * alpha_2 + 3.0 * lb + 3.0 * rb)
- 5.0 * math.sin(2.0 * alpha_2) + math.sin(2.0 * alpha_2 - lb - rb)
+ math.sin(2.0 * (rb + lb + alpha_2))) / (64.0 * math.sin(alpha_2) * math.sin(alpha_2))
ans -= math.sin(pi - alpha_1) * math.cos(pi - alpha_1) * 0.500000
ans += ((4.0 - 2.0 * math.cos(2.0 * alpha_1)) * (pi - alpha_1) + 2.0 * math.sin(4.0 * alpha_1)
- 3.0 * math.sin(2.0 * alpha_1)) / (32.0 * math.sin(alpha_1) * math.sin(alpha_1))
return ans
if __name__ == "__main__":
n = eval(input())
for i in range(1, n + 1):
a, b = input().split()
a, b = eval(a), eval(b)
x.append(a), y.append(b)
if n == 4:
Ax, Ay = x[0], y[0]
Bx, By = x[1], y[1]
Cx, Cy = x[2], y[2]
Dx, Dy = x[3], y[3]
ABx, ABy = Bx - Ax, By - Ay
ADx, ADy = Dx - Ax, Dy - Ay
CBx, CBy = Bx - Cx, By - Cy
CDx, CDy = Dx - Cx, Dy - Cy
LenAB, LenAD = math.sqrt(ABx * ABx + ABy * ABy), math.sqrt(ADx * ADx + ADy * ADy)
LenCB, LenCD = math.sqrt(CBx * CBx + CBy * CBy), math.sqrt(CDx * CDx + CDy * CDy)
a = math.acos((ADx * ABx + ADy * ABy) / LenAD / LenAB)
b = math.acos((CBx * ABx + CBy * ABy) / LenCB / LenAB)
c = math.acos((CBx * CDx + CBy * CDy) / LenCB / LenCD)
d = math.acos((ADx * CDx + ADy * CDy) / LenAD / LenCD)
if math.fabs(a - pi / 2.0) < eps and math.fabs(b - pi / 2.0) < eps and \
math.fabs(c - pi / 2.0) < eps and math.fabs(d - pi / 2.0) < eps and \
((math.fabs(LenAB - 1.00) < eps and math.fabs(LenAB - LenCD) < eps) or
(math.fabs(LenCB - 1.00) < eps and math.fabs(LenCB - LenAD) < eps)):
print('%.11Lf' % (LenAB * LenCB)), exit(0)
res = 0.0000
for i in range(1, n + 1):
res += get_area((i - 1 + n) % n, i % n, (i + 1) % n, (i + 2) % n)
if math.fabs(res-1.02638863065) < 100*eps:
print('1.04719792254'), exit(0)
if math.fabs(res-1.04692745180) < 100*eps:
print('1.04720015894'), exit(0)
print('%.11Lf' % res)
|
import math
pi = 3.14159265358979323846264338327950288419716939937510
eps, sq2 = 1e-13, math.sqrt(2)
x, y = [], []
n = 0
def binary_find(la, lb, ra, rb, cy, fy, alpha_1, alpha_2, ab):
while math.fabs(cy - fy) > eps:
mid_y = cy / 2.0 + fy / 2.0
la = lb = 0.0
ra, rb = pi - alpha_1, pi - alpha_2
while math.fabs(ra - la) > eps:
mid_a = ra / 2.0 + la / 2.0
yy = - pow(math.sin(mid_a), 2) * math.cos(alpha_1 + mid_a) / math.sin(alpha_1)
if yy < mid_y:
{{completion}}
if yy > mid_y:
ra = mid_a
while math.fabs(rb - lb) > eps:
mid_b = rb / 2.0 + lb / 2.0
yy = - pow(math.sin(mid_b), 2) * math.cos(alpha_2 + mid_b) / math.sin(alpha_2)
if yy < mid_y:
lb = mid_b
if yy > mid_y:
rb = mid_b
x1 = (2.0 * math.sin(la / 2.0 + ra / 2.0 + alpha_1) +
math.sin(la + ra) * math.cos(la / 2.0 + ra / 2.0 + alpha_1)) / (2 * math.sin(alpha_1))
x2 = ab - (2.0 * math.sin(lb / 2.0 + rb / 2.0 + alpha_2) +
math.sin(lb + rb) * math.cos(lb / 2.0 + rb / 2.0 + alpha_2)) / (2 * math.sin(alpha_2))
if x1 < x2:
cy = mid_y
if x1 > x2:
fy = mid_y
return la, lb, ra, rb, cy, fy
def get_area(_i, ni, i_, i_2):
ans = 0.00
ab = math.sqrt(pow((x[i_] - x[ni]), 2) + pow((y[i_] - y[ni]), 2))
ad = math.sqrt(pow((x[_i] - x[ni]), 2) + pow((y[_i] - y[ni]), 2))
bc = math.sqrt(pow((x[i_2] - x[i_]), 2) + pow((y[i_2] - y[i_]), 2))
ux, uy = x[_i] - x[ni], y[_i] - y[ni]
vx, vy = x[i_] - x[ni], y[i_] - y[ni]
alpha_1 = math.acos((ux * vx + uy * vy) / ab / ad)
if math.fabs(ab - sq2) < eps or math.fabs(ab - 1.00) < eps:
wx, wy = x[i_2] - x[i_], y[i_2] - y[i_]
alpha_2 = math.acos((-vx * wx - wy * vy) / ab / bc)
la, lb, ra, rb, cy, fy = 0.0, 0.0, pi - alpha_1, pi - alpha_2, min(alpha_1, alpha_2), 0.0000
la, lb, ra, rb, cy, fy = binary_find(la, lb, ra, rb, cy, fy, alpha_1, alpha_2, ab)
ans -= ((8.0 - 4.0 * math.cos(2.0 * alpha_1)) * la - 2.0 * math.sin(la * 2.0 + ra * 2.0) +
4.0 * math.sin(2.0 * alpha_1 + la + ra) - math.sin(2.0 * alpha_1 + 3.0 * la + 3.0 * ra)
- 5.0 * math.sin(2.0 * alpha_1)+ math.sin(2.0 * alpha_1 - la - ra)
+ math.sin(2.0 * (ra + la + alpha_1))) / (64.0 * math.sin(alpha_1) * math.sin(alpha_1))
ans -= ((8.0 - 4.0 * math.cos(2.0 * alpha_2)) * lb - 2.0 * math.sin(lb * 2.0 + rb * 2.0) +
4.0 * math.sin(2.0 * alpha_2 + lb + rb) - math.sin(2.0 * alpha_2 + 3.0 * lb + 3.0 * rb)
- 5.0 * math.sin(2.0 * alpha_2) + math.sin(2.0 * alpha_2 - lb - rb)
+ math.sin(2.0 * (rb + lb + alpha_2))) / (64.0 * math.sin(alpha_2) * math.sin(alpha_2))
ans -= math.sin(pi - alpha_1) * math.cos(pi - alpha_1) * 0.500000
ans += ((4.0 - 2.0 * math.cos(2.0 * alpha_1)) * (pi - alpha_1) + 2.0 * math.sin(4.0 * alpha_1)
- 3.0 * math.sin(2.0 * alpha_1)) / (32.0 * math.sin(alpha_1) * math.sin(alpha_1))
return ans
if __name__ == "__main__":
n = eval(input())
for i in range(1, n + 1):
a, b = input().split()
a, b = eval(a), eval(b)
x.append(a), y.append(b)
if n == 4:
Ax, Ay = x[0], y[0]
Bx, By = x[1], y[1]
Cx, Cy = x[2], y[2]
Dx, Dy = x[3], y[3]
ABx, ABy = Bx - Ax, By - Ay
ADx, ADy = Dx - Ax, Dy - Ay
CBx, CBy = Bx - Cx, By - Cy
CDx, CDy = Dx - Cx, Dy - Cy
LenAB, LenAD = math.sqrt(ABx * ABx + ABy * ABy), math.sqrt(ADx * ADx + ADy * ADy)
LenCB, LenCD = math.sqrt(CBx * CBx + CBy * CBy), math.sqrt(CDx * CDx + CDy * CDy)
a = math.acos((ADx * ABx + ADy * ABy) / LenAD / LenAB)
b = math.acos((CBx * ABx + CBy * ABy) / LenCB / LenAB)
c = math.acos((CBx * CDx + CBy * CDy) / LenCB / LenCD)
d = math.acos((ADx * CDx + ADy * CDy) / LenAD / LenCD)
if math.fabs(a - pi / 2.0) < eps and math.fabs(b - pi / 2.0) < eps and \
math.fabs(c - pi / 2.0) < eps and math.fabs(d - pi / 2.0) < eps and \
((math.fabs(LenAB - 1.00) < eps and math.fabs(LenAB - LenCD) < eps) or
(math.fabs(LenCB - 1.00) < eps and math.fabs(LenCB - LenAD) < eps)):
print('%.11Lf' % (LenAB * LenCB)), exit(0)
res = 0.0000
for i in range(1, n + 1):
res += get_area((i - 1 + n) % n, i % n, (i + 1) % n, (i + 2) % n)
if math.fabs(res-1.02638863065) < 100*eps:
print('1.04719792254'), exit(0)
if math.fabs(res-1.04692745180) < 100*eps:
print('1.04720015894'), exit(0)
print('%.11Lf' % res)
|
la = mid_a
|
[{"input": "4\n4 5\n4 1\n7 1\n7 5", "output": ["1.17809724510"]}, {"input": "5\n-3 3\n3 1\n4 2\n-1 9\n-2 9", "output": ["1.07823651333"]}]
|
block_completion_007521
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: Mainak has a convex polygon $$$\mathcal P$$$ with $$$n$$$ vertices labelled as $$$A_1, A_2, \ldots, A_n$$$ in a counter-clockwise fashion. The coordinates of the $$$i$$$-th point $$$A_i$$$ are given by $$$(x_i, y_i)$$$, where $$$x_i$$$ and $$$y_i$$$ are both integers.Further, it is known that the interior angle at $$$A_i$$$ is either a right angle or a proper obtuse angle. Formally it is known that: $$$90 ^ \circ \le \angle A_{i - 1}A_{i}A_{i + 1} < 180 ^ \circ$$$, $$$\forall i \in \{1, 2, \ldots, n\}$$$ where we conventionally consider $$$A_0 = A_n$$$ and $$$A_{n + 1} = A_1$$$. Mainak's friend insisted that all points $$$Q$$$ such that there exists a chord of the polygon $$$\mathcal P$$$ passing through $$$Q$$$ with length not exceeding $$$1$$$, must be coloured $$$\color{red}{\text{red}}$$$. Mainak wants you to find the area of the coloured region formed by the $$$\color{red}{\text{red}}$$$ points.Formally, determine the area of the region $$$\mathcal S = \{Q \in \mathcal{P}$$$ | $$$Q \text{ is coloured } \color{red}{\text{red}}\}$$$.Recall that a chord of a polygon is a line segment between two points lying on the boundary (i.e. vertices or points on edges) of the polygon.
Input Specification: The first line contains an integer $$$n$$$ ($$$4 \le n \le 5000$$$) — the number of vertices of a polygon $$$\mathcal P$$$. The $$$i$$$-th line of the next $$$n$$$ lines contain two integers $$$x_i$$$ and $$$y_i$$$ ($$$-10^9 \le x_i, y_i \le 10^9$$$) — the coordinates of $$$A_i$$$. Additional constraint on the input: The vertices form a convex polygon and are listed in counter-clockwise order. It is also guaranteed that all interior angles are in the range $$$[90^\circ ; 180^\circ )$$$.
Output Specification: Print the area of the region coloured in $$$\color{red}{\text{red}}$$$. Your answer is considered correct if its absolute or relative error does not exceed $$$10^{-4}$$$. Formally, let your answer be $$$a$$$, and the jury's answer be $$$b$$$. Your answer is accepted if and only if $$$\frac{|a - b|}{\max{(1, |b|)}} \le 10^{-4}$$$.
Notes: NoteIn the first example, the polygon $$$\mathcal P$$$ can be visualised on the Cartesian Plane as:
Code:
import math
pi = 3.14159265358979323846264338327950288419716939937510
eps, sq2 = 1e-13, math.sqrt(2)
x, y = [], []
n = 0
def binary_find(la, lb, ra, rb, cy, fy, alpha_1, alpha_2, ab):
while math.fabs(cy - fy) > eps:
mid_y = cy / 2.0 + fy / 2.0
la = lb = 0.0
ra, rb = pi - alpha_1, pi - alpha_2
while math.fabs(ra - la) > eps:
mid_a = ra / 2.0 + la / 2.0
yy = - pow(math.sin(mid_a), 2) * math.cos(alpha_1 + mid_a) / math.sin(alpha_1)
if yy < mid_y:
la = mid_a
if yy > mid_y:
# TODO: Your code here
while math.fabs(rb - lb) > eps:
mid_b = rb / 2.0 + lb / 2.0
yy = - pow(math.sin(mid_b), 2) * math.cos(alpha_2 + mid_b) / math.sin(alpha_2)
if yy < mid_y:
lb = mid_b
if yy > mid_y:
rb = mid_b
x1 = (2.0 * math.sin(la / 2.0 + ra / 2.0 + alpha_1) +
math.sin(la + ra) * math.cos(la / 2.0 + ra / 2.0 + alpha_1)) / (2 * math.sin(alpha_1))
x2 = ab - (2.0 * math.sin(lb / 2.0 + rb / 2.0 + alpha_2) +
math.sin(lb + rb) * math.cos(lb / 2.0 + rb / 2.0 + alpha_2)) / (2 * math.sin(alpha_2))
if x1 < x2:
cy = mid_y
if x1 > x2:
fy = mid_y
return la, lb, ra, rb, cy, fy
def get_area(_i, ni, i_, i_2):
ans = 0.00
ab = math.sqrt(pow((x[i_] - x[ni]), 2) + pow((y[i_] - y[ni]), 2))
ad = math.sqrt(pow((x[_i] - x[ni]), 2) + pow((y[_i] - y[ni]), 2))
bc = math.sqrt(pow((x[i_2] - x[i_]), 2) + pow((y[i_2] - y[i_]), 2))
ux, uy = x[_i] - x[ni], y[_i] - y[ni]
vx, vy = x[i_] - x[ni], y[i_] - y[ni]
alpha_1 = math.acos((ux * vx + uy * vy) / ab / ad)
if math.fabs(ab - sq2) < eps or math.fabs(ab - 1.00) < eps:
wx, wy = x[i_2] - x[i_], y[i_2] - y[i_]
alpha_2 = math.acos((-vx * wx - wy * vy) / ab / bc)
la, lb, ra, rb, cy, fy = 0.0, 0.0, pi - alpha_1, pi - alpha_2, min(alpha_1, alpha_2), 0.0000
la, lb, ra, rb, cy, fy = binary_find(la, lb, ra, rb, cy, fy, alpha_1, alpha_2, ab)
ans -= ((8.0 - 4.0 * math.cos(2.0 * alpha_1)) * la - 2.0 * math.sin(la * 2.0 + ra * 2.0) +
4.0 * math.sin(2.0 * alpha_1 + la + ra) - math.sin(2.0 * alpha_1 + 3.0 * la + 3.0 * ra)
- 5.0 * math.sin(2.0 * alpha_1)+ math.sin(2.0 * alpha_1 - la - ra)
+ math.sin(2.0 * (ra + la + alpha_1))) / (64.0 * math.sin(alpha_1) * math.sin(alpha_1))
ans -= ((8.0 - 4.0 * math.cos(2.0 * alpha_2)) * lb - 2.0 * math.sin(lb * 2.0 + rb * 2.0) +
4.0 * math.sin(2.0 * alpha_2 + lb + rb) - math.sin(2.0 * alpha_2 + 3.0 * lb + 3.0 * rb)
- 5.0 * math.sin(2.0 * alpha_2) + math.sin(2.0 * alpha_2 - lb - rb)
+ math.sin(2.0 * (rb + lb + alpha_2))) / (64.0 * math.sin(alpha_2) * math.sin(alpha_2))
ans -= math.sin(pi - alpha_1) * math.cos(pi - alpha_1) * 0.500000
ans += ((4.0 - 2.0 * math.cos(2.0 * alpha_1)) * (pi - alpha_1) + 2.0 * math.sin(4.0 * alpha_1)
- 3.0 * math.sin(2.0 * alpha_1)) / (32.0 * math.sin(alpha_1) * math.sin(alpha_1))
return ans
if __name__ == "__main__":
n = eval(input())
for i in range(1, n + 1):
a, b = input().split()
a, b = eval(a), eval(b)
x.append(a), y.append(b)
if n == 4:
Ax, Ay = x[0], y[0]
Bx, By = x[1], y[1]
Cx, Cy = x[2], y[2]
Dx, Dy = x[3], y[3]
ABx, ABy = Bx - Ax, By - Ay
ADx, ADy = Dx - Ax, Dy - Ay
CBx, CBy = Bx - Cx, By - Cy
CDx, CDy = Dx - Cx, Dy - Cy
LenAB, LenAD = math.sqrt(ABx * ABx + ABy * ABy), math.sqrt(ADx * ADx + ADy * ADy)
LenCB, LenCD = math.sqrt(CBx * CBx + CBy * CBy), math.sqrt(CDx * CDx + CDy * CDy)
a = math.acos((ADx * ABx + ADy * ABy) / LenAD / LenAB)
b = math.acos((CBx * ABx + CBy * ABy) / LenCB / LenAB)
c = math.acos((CBx * CDx + CBy * CDy) / LenCB / LenCD)
d = math.acos((ADx * CDx + ADy * CDy) / LenAD / LenCD)
if math.fabs(a - pi / 2.0) < eps and math.fabs(b - pi / 2.0) < eps and \
math.fabs(c - pi / 2.0) < eps and math.fabs(d - pi / 2.0) < eps and \
((math.fabs(LenAB - 1.00) < eps and math.fabs(LenAB - LenCD) < eps) or
(math.fabs(LenCB - 1.00) < eps and math.fabs(LenCB - LenAD) < eps)):
print('%.11Lf' % (LenAB * LenCB)), exit(0)
res = 0.0000
for i in range(1, n + 1):
res += get_area((i - 1 + n) % n, i % n, (i + 1) % n, (i + 2) % n)
if math.fabs(res-1.02638863065) < 100*eps:
print('1.04719792254'), exit(0)
if math.fabs(res-1.04692745180) < 100*eps:
print('1.04720015894'), exit(0)
print('%.11Lf' % res)
|
import math
pi = 3.14159265358979323846264338327950288419716939937510
eps, sq2 = 1e-13, math.sqrt(2)
x, y = [], []
n = 0
def binary_find(la, lb, ra, rb, cy, fy, alpha_1, alpha_2, ab):
while math.fabs(cy - fy) > eps:
mid_y = cy / 2.0 + fy / 2.0
la = lb = 0.0
ra, rb = pi - alpha_1, pi - alpha_2
while math.fabs(ra - la) > eps:
mid_a = ra / 2.0 + la / 2.0
yy = - pow(math.sin(mid_a), 2) * math.cos(alpha_1 + mid_a) / math.sin(alpha_1)
if yy < mid_y:
la = mid_a
if yy > mid_y:
{{completion}}
while math.fabs(rb - lb) > eps:
mid_b = rb / 2.0 + lb / 2.0
yy = - pow(math.sin(mid_b), 2) * math.cos(alpha_2 + mid_b) / math.sin(alpha_2)
if yy < mid_y:
lb = mid_b
if yy > mid_y:
rb = mid_b
x1 = (2.0 * math.sin(la / 2.0 + ra / 2.0 + alpha_1) +
math.sin(la + ra) * math.cos(la / 2.0 + ra / 2.0 + alpha_1)) / (2 * math.sin(alpha_1))
x2 = ab - (2.0 * math.sin(lb / 2.0 + rb / 2.0 + alpha_2) +
math.sin(lb + rb) * math.cos(lb / 2.0 + rb / 2.0 + alpha_2)) / (2 * math.sin(alpha_2))
if x1 < x2:
cy = mid_y
if x1 > x2:
fy = mid_y
return la, lb, ra, rb, cy, fy
def get_area(_i, ni, i_, i_2):
ans = 0.00
ab = math.sqrt(pow((x[i_] - x[ni]), 2) + pow((y[i_] - y[ni]), 2))
ad = math.sqrt(pow((x[_i] - x[ni]), 2) + pow((y[_i] - y[ni]), 2))
bc = math.sqrt(pow((x[i_2] - x[i_]), 2) + pow((y[i_2] - y[i_]), 2))
ux, uy = x[_i] - x[ni], y[_i] - y[ni]
vx, vy = x[i_] - x[ni], y[i_] - y[ni]
alpha_1 = math.acos((ux * vx + uy * vy) / ab / ad)
if math.fabs(ab - sq2) < eps or math.fabs(ab - 1.00) < eps:
wx, wy = x[i_2] - x[i_], y[i_2] - y[i_]
alpha_2 = math.acos((-vx * wx - wy * vy) / ab / bc)
la, lb, ra, rb, cy, fy = 0.0, 0.0, pi - alpha_1, pi - alpha_2, min(alpha_1, alpha_2), 0.0000
la, lb, ra, rb, cy, fy = binary_find(la, lb, ra, rb, cy, fy, alpha_1, alpha_2, ab)
ans -= ((8.0 - 4.0 * math.cos(2.0 * alpha_1)) * la - 2.0 * math.sin(la * 2.0 + ra * 2.0) +
4.0 * math.sin(2.0 * alpha_1 + la + ra) - math.sin(2.0 * alpha_1 + 3.0 * la + 3.0 * ra)
- 5.0 * math.sin(2.0 * alpha_1)+ math.sin(2.0 * alpha_1 - la - ra)
+ math.sin(2.0 * (ra + la + alpha_1))) / (64.0 * math.sin(alpha_1) * math.sin(alpha_1))
ans -= ((8.0 - 4.0 * math.cos(2.0 * alpha_2)) * lb - 2.0 * math.sin(lb * 2.0 + rb * 2.0) +
4.0 * math.sin(2.0 * alpha_2 + lb + rb) - math.sin(2.0 * alpha_2 + 3.0 * lb + 3.0 * rb)
- 5.0 * math.sin(2.0 * alpha_2) + math.sin(2.0 * alpha_2 - lb - rb)
+ math.sin(2.0 * (rb + lb + alpha_2))) / (64.0 * math.sin(alpha_2) * math.sin(alpha_2))
ans -= math.sin(pi - alpha_1) * math.cos(pi - alpha_1) * 0.500000
ans += ((4.0 - 2.0 * math.cos(2.0 * alpha_1)) * (pi - alpha_1) + 2.0 * math.sin(4.0 * alpha_1)
- 3.0 * math.sin(2.0 * alpha_1)) / (32.0 * math.sin(alpha_1) * math.sin(alpha_1))
return ans
if __name__ == "__main__":
n = eval(input())
for i in range(1, n + 1):
a, b = input().split()
a, b = eval(a), eval(b)
x.append(a), y.append(b)
if n == 4:
Ax, Ay = x[0], y[0]
Bx, By = x[1], y[1]
Cx, Cy = x[2], y[2]
Dx, Dy = x[3], y[3]
ABx, ABy = Bx - Ax, By - Ay
ADx, ADy = Dx - Ax, Dy - Ay
CBx, CBy = Bx - Cx, By - Cy
CDx, CDy = Dx - Cx, Dy - Cy
LenAB, LenAD = math.sqrt(ABx * ABx + ABy * ABy), math.sqrt(ADx * ADx + ADy * ADy)
LenCB, LenCD = math.sqrt(CBx * CBx + CBy * CBy), math.sqrt(CDx * CDx + CDy * CDy)
a = math.acos((ADx * ABx + ADy * ABy) / LenAD / LenAB)
b = math.acos((CBx * ABx + CBy * ABy) / LenCB / LenAB)
c = math.acos((CBx * CDx + CBy * CDy) / LenCB / LenCD)
d = math.acos((ADx * CDx + ADy * CDy) / LenAD / LenCD)
if math.fabs(a - pi / 2.0) < eps and math.fabs(b - pi / 2.0) < eps and \
math.fabs(c - pi / 2.0) < eps and math.fabs(d - pi / 2.0) < eps and \
((math.fabs(LenAB - 1.00) < eps and math.fabs(LenAB - LenCD) < eps) or
(math.fabs(LenCB - 1.00) < eps and math.fabs(LenCB - LenAD) < eps)):
print('%.11Lf' % (LenAB * LenCB)), exit(0)
res = 0.0000
for i in range(1, n + 1):
res += get_area((i - 1 + n) % n, i % n, (i + 1) % n, (i + 2) % n)
if math.fabs(res-1.02638863065) < 100*eps:
print('1.04719792254'), exit(0)
if math.fabs(res-1.04692745180) < 100*eps:
print('1.04720015894'), exit(0)
print('%.11Lf' % res)
|
ra = mid_a
|
[{"input": "4\n4 5\n4 1\n7 1\n7 5", "output": ["1.17809724510"]}, {"input": "5\n-3 3\n3 1\n4 2\n-1 9\n-2 9", "output": ["1.07823651333"]}]
|
block_completion_007522
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: A ticket is a string consisting of six digits. A ticket is considered lucky if the sum of the first three digits is equal to the sum of the last three digits. Given a ticket, output if it is lucky or not. Note that a ticket can have leading zeroes.
Input Specification: The first line of the input contains an integer $$$t$$$ ($$$1 \leq t \leq 10^3$$$) — the number of testcases. The description of each test consists of one line containing one string consisting of six digits.
Output Specification: Output $$$t$$$ lines, each of which contains the answer to the corresponding test case. Output "YES" if the given ticket is lucky, and "NO" otherwise. You can output the answer in any case (for example, the strings "yEs", "yes", "Yes" and "YES" will be recognized as a positive answer).
Notes: NoteIn the first test case, the sum of the first three digits is $$$2 + 1 + 3 = 6$$$ and the sum of the last three digits is $$$1 + 3 + 2 = 6$$$, they are equal so the answer is "YES".In the second test case, the sum of the first three digits is $$$9 + 7 + 3 = 19$$$ and the sum of the last three digits is $$$8 + 9 + 4 = 21$$$, they are not equal so the answer is "NO".In the third test case, the sum of the first three digits is $$$0 + 4 + 5 = 9$$$ and the sum of the last three digits is $$$2 + 0 + 7 = 9$$$, they are equal so the answer is "YES".
Code:
for _ in range(int(input())):
# TODO: Your code here
|
for _ in range(int(input())):
{{completion}}
|
p = list(map(int, input()))
print('YES' if sum(p[:3]) == sum(p[3:]) else 'NO')
|
[{"input": "5\n213132\n973894\n045207\n000000\n055776", "output": ["YES\nNO\nYES\nYES\nNO"]}]
|
block_completion_007619
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: A ticket is a string consisting of six digits. A ticket is considered lucky if the sum of the first three digits is equal to the sum of the last three digits. Given a ticket, output if it is lucky or not. Note that a ticket can have leading zeroes.
Input Specification: The first line of the input contains an integer $$$t$$$ ($$$1 \leq t \leq 10^3$$$) — the number of testcases. The description of each test consists of one line containing one string consisting of six digits.
Output Specification: Output $$$t$$$ lines, each of which contains the answer to the corresponding test case. Output "YES" if the given ticket is lucky, and "NO" otherwise. You can output the answer in any case (for example, the strings "yEs", "yes", "Yes" and "YES" will be recognized as a positive answer).
Notes: NoteIn the first test case, the sum of the first three digits is $$$2 + 1 + 3 = 6$$$ and the sum of the last three digits is $$$1 + 3 + 2 = 6$$$, they are equal so the answer is "YES".In the second test case, the sum of the first three digits is $$$9 + 7 + 3 = 19$$$ and the sum of the last three digits is $$$8 + 9 + 4 = 21$$$, they are not equal so the answer is "NO".In the third test case, the sum of the first three digits is $$$0 + 4 + 5 = 9$$$ and the sum of the last three digits is $$$2 + 0 + 7 = 9$$$, they are equal so the answer is "YES".
Code:
for _ in [*open(0)][1:]:# TODO: Your code here
|
for _ in [*open(0)][1:]:{{completion}}
|
print('yes' if int(_[0]) + int(_[1]) + int(_[2]) == int(_[3]) + int(_[4]) + int(_[5]) else 'NO')
|
[{"input": "5\n213132\n973894\n045207\n000000\n055776", "output": ["YES\nNO\nYES\nYES\nNO"]}]
|
block_completion_007620
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: A ticket is a string consisting of six digits. A ticket is considered lucky if the sum of the first three digits is equal to the sum of the last three digits. Given a ticket, output if it is lucky or not. Note that a ticket can have leading zeroes.
Input Specification: The first line of the input contains an integer $$$t$$$ ($$$1 \leq t \leq 10^3$$$) — the number of testcases. The description of each test consists of one line containing one string consisting of six digits.
Output Specification: Output $$$t$$$ lines, each of which contains the answer to the corresponding test case. Output "YES" if the given ticket is lucky, and "NO" otherwise. You can output the answer in any case (for example, the strings "yEs", "yes", "Yes" and "YES" will be recognized as a positive answer).
Notes: NoteIn the first test case, the sum of the first three digits is $$$2 + 1 + 3 = 6$$$ and the sum of the last three digits is $$$1 + 3 + 2 = 6$$$, they are equal so the answer is "YES".In the second test case, the sum of the first three digits is $$$9 + 7 + 3 = 19$$$ and the sum of the last three digits is $$$8 + 9 + 4 = 21$$$, they are not equal so the answer is "NO".In the third test case, the sum of the first three digits is $$$0 + 4 + 5 = 9$$$ and the sum of the last three digits is $$$2 + 0 + 7 = 9$$$, they are equal so the answer is "YES".
Code:
t = int(input())
for i in range(1, t + 1):
summa = 0
a = int(input())
a6 = a % 10
a5 = (a // 10) % 10
a4 = (a // 100) % 10
a3 = (a // 1000) % 10
a2 = (a // 10000) % 10
a1 = (a // 100000) % 10
if a1 + a2 + a3 == a4 + a5 + a6:
print('YES')
else:
# TODO: Your code here
|
t = int(input())
for i in range(1, t + 1):
summa = 0
a = int(input())
a6 = a % 10
a5 = (a // 10) % 10
a4 = (a // 100) % 10
a3 = (a // 1000) % 10
a2 = (a // 10000) % 10
a1 = (a // 100000) % 10
if a1 + a2 + a3 == a4 + a5 + a6:
print('YES')
else:
{{completion}}
|
print("NO")
|
[{"input": "5\n213132\n973894\n045207\n000000\n055776", "output": ["YES\nNO\nYES\nYES\nNO"]}]
|
block_completion_007621
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: A ticket is a string consisting of six digits. A ticket is considered lucky if the sum of the first three digits is equal to the sum of the last three digits. Given a ticket, output if it is lucky or not. Note that a ticket can have leading zeroes.
Input Specification: The first line of the input contains an integer $$$t$$$ ($$$1 \leq t \leq 10^3$$$) — the number of testcases. The description of each test consists of one line containing one string consisting of six digits.
Output Specification: Output $$$t$$$ lines, each of which contains the answer to the corresponding test case. Output "YES" if the given ticket is lucky, and "NO" otherwise. You can output the answer in any case (for example, the strings "yEs", "yes", "Yes" and "YES" will be recognized as a positive answer).
Notes: NoteIn the first test case, the sum of the first three digits is $$$2 + 1 + 3 = 6$$$ and the sum of the last three digits is $$$1 + 3 + 2 = 6$$$, they are equal so the answer is "YES".In the second test case, the sum of the first three digits is $$$9 + 7 + 3 = 19$$$ and the sum of the last three digits is $$$8 + 9 + 4 = 21$$$, they are not equal so the answer is "NO".In the third test case, the sum of the first three digits is $$$0 + 4 + 5 = 9$$$ and the sum of the last three digits is $$$2 + 0 + 7 = 9$$$, they are equal so the answer is "YES".
Code:
for c in [input() for i in range(int(input()))]: # TODO: Your code here
|
for c in [input() for i in range(int(input()))]: {{completion}}
|
print(('NO', 'YES')[sum(int(p) for p in (c[:3])) == sum(int(p) for p in (c[3:]))])
|
[{"input": "5\n213132\n973894\n045207\n000000\n055776", "output": ["YES\nNO\nYES\nYES\nNO"]}]
|
block_completion_007622
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: A ticket is a string consisting of six digits. A ticket is considered lucky if the sum of the first three digits is equal to the sum of the last three digits. Given a ticket, output if it is lucky or not. Note that a ticket can have leading zeroes.
Input Specification: The first line of the input contains an integer $$$t$$$ ($$$1 \leq t \leq 10^3$$$) — the number of testcases. The description of each test consists of one line containing one string consisting of six digits.
Output Specification: Output $$$t$$$ lines, each of which contains the answer to the corresponding test case. Output "YES" if the given ticket is lucky, and "NO" otherwise. You can output the answer in any case (for example, the strings "yEs", "yes", "Yes" and "YES" will be recognized as a positive answer).
Notes: NoteIn the first test case, the sum of the first three digits is $$$2 + 1 + 3 = 6$$$ and the sum of the last three digits is $$$1 + 3 + 2 = 6$$$, they are equal so the answer is "YES".In the second test case, the sum of the first three digits is $$$9 + 7 + 3 = 19$$$ and the sum of the last three digits is $$$8 + 9 + 4 = 21$$$, they are not equal so the answer is "NO".In the third test case, the sum of the first three digits is $$$0 + 4 + 5 = 9$$$ and the sum of the last three digits is $$$2 + 0 + 7 = 9$$$, they are equal so the answer is "YES".
Code:
import sys
def main():
s = sys.stdin.read().strip().split('\n')[1:]
r = []
for i in s:
# TODO: Your code here
return r
print(*main(), sep='\n')
|
import sys
def main():
s = sys.stdin.read().strip().split('\n')[1:]
r = []
for i in s:
{{completion}}
return r
print(*main(), sep='\n')
|
nums = list(map(int, i))
r.append(('NO', 'YES')[sum(nums[:3]) == sum(nums[3:])])
|
[{"input": "5\n213132\n973894\n045207\n000000\n055776", "output": ["YES\nNO\nYES\nYES\nNO"]}]
|
block_completion_007623
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: A ticket is a string consisting of six digits. A ticket is considered lucky if the sum of the first three digits is equal to the sum of the last three digits. Given a ticket, output if it is lucky or not. Note that a ticket can have leading zeroes.
Input Specification: The first line of the input contains an integer $$$t$$$ ($$$1 \leq t \leq 10^3$$$) — the number of testcases. The description of each test consists of one line containing one string consisting of six digits.
Output Specification: Output $$$t$$$ lines, each of which contains the answer to the corresponding test case. Output "YES" if the given ticket is lucky, and "NO" otherwise. You can output the answer in any case (for example, the strings "yEs", "yes", "Yes" and "YES" will be recognized as a positive answer).
Notes: NoteIn the first test case, the sum of the first three digits is $$$2 + 1 + 3 = 6$$$ and the sum of the last three digits is $$$1 + 3 + 2 = 6$$$, they are equal so the answer is "YES".In the second test case, the sum of the first three digits is $$$9 + 7 + 3 = 19$$$ and the sum of the last three digits is $$$8 + 9 + 4 = 21$$$, they are not equal so the answer is "NO".In the third test case, the sum of the first three digits is $$$0 + 4 + 5 = 9$$$ and the sum of the last three digits is $$$2 + 0 + 7 = 9$$$, they are equal so the answer is "YES".
Code:
for i in range(int(input())):
# TODO: Your code here
|
for i in range(int(input())):
{{completion}}
|
a = [int(j) for j in input()]
print("YES" if sum(a[0:3])==sum(a[3:6]) else "NO")
|
[{"input": "5\n213132\n973894\n045207\n000000\n055776", "output": ["YES\nNO\nYES\nYES\nNO"]}]
|
block_completion_007624
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: A ticket is a string consisting of six digits. A ticket is considered lucky if the sum of the first three digits is equal to the sum of the last three digits. Given a ticket, output if it is lucky or not. Note that a ticket can have leading zeroes.
Input Specification: The first line of the input contains an integer $$$t$$$ ($$$1 \leq t \leq 10^3$$$) — the number of testcases. The description of each test consists of one line containing one string consisting of six digits.
Output Specification: Output $$$t$$$ lines, each of which contains the answer to the corresponding test case. Output "YES" if the given ticket is lucky, and "NO" otherwise. You can output the answer in any case (for example, the strings "yEs", "yes", "Yes" and "YES" will be recognized as a positive answer).
Notes: NoteIn the first test case, the sum of the first three digits is $$$2 + 1 + 3 = 6$$$ and the sum of the last three digits is $$$1 + 3 + 2 = 6$$$, they are equal so the answer is "YES".In the second test case, the sum of the first three digits is $$$9 + 7 + 3 = 19$$$ and the sum of the last three digits is $$$8 + 9 + 4 = 21$$$, they are not equal so the answer is "NO".In the third test case, the sum of the first three digits is $$$0 + 4 + 5 = 9$$$ and the sum of the last three digits is $$$2 + 0 + 7 = 9$$$, they are equal so the answer is "YES".
Code:
t = int(input(""))
for i in range(t):
ticket = input("")
if int(ticket[0])+int(ticket[1])+int(ticket[2]) == int(ticket[3])+int(ticket[4])+int(ticket[5]):
print("YES")
else:
# TODO: Your code here
|
t = int(input(""))
for i in range(t):
ticket = input("")
if int(ticket[0])+int(ticket[1])+int(ticket[2]) == int(ticket[3])+int(ticket[4])+int(ticket[5]):
print("YES")
else:
{{completion}}
|
print("NO")
|
[{"input": "5\n213132\n973894\n045207\n000000\n055776", "output": ["YES\nNO\nYES\nYES\nNO"]}]
|
block_completion_007625
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: A ticket is a string consisting of six digits. A ticket is considered lucky if the sum of the first three digits is equal to the sum of the last three digits. Given a ticket, output if it is lucky or not. Note that a ticket can have leading zeroes.
Input Specification: The first line of the input contains an integer $$$t$$$ ($$$1 \leq t \leq 10^3$$$) — the number of testcases. The description of each test consists of one line containing one string consisting of six digits.
Output Specification: Output $$$t$$$ lines, each of which contains the answer to the corresponding test case. Output "YES" if the given ticket is lucky, and "NO" otherwise. You can output the answer in any case (for example, the strings "yEs", "yes", "Yes" and "YES" will be recognized as a positive answer).
Notes: NoteIn the first test case, the sum of the first three digits is $$$2 + 1 + 3 = 6$$$ and the sum of the last three digits is $$$1 + 3 + 2 = 6$$$, they are equal so the answer is "YES".In the second test case, the sum of the first three digits is $$$9 + 7 + 3 = 19$$$ and the sum of the last three digits is $$$8 + 9 + 4 = 21$$$, they are not equal so the answer is "NO".In the third test case, the sum of the first three digits is $$$0 + 4 + 5 = 9$$$ and the sum of the last three digits is $$$2 + 0 + 7 = 9$$$, they are equal so the answer is "YES".
Code:
s = int(input())
r = []
for i in range(s):
a = int(input())
if a // 100000 + a // 10000 % 10 + a // 1000 % 10 == a // 100 % 10 + a % 10 + a // 10 % 10:
print("YES", end=" ")
else:
# TODO: Your code here
|
s = int(input())
r = []
for i in range(s):
a = int(input())
if a // 100000 + a // 10000 % 10 + a // 1000 % 10 == a // 100 % 10 + a % 10 + a // 10 % 10:
print("YES", end=" ")
else:
{{completion}}
|
print("NO", end=" ")
|
[{"input": "5\n213132\n973894\n045207\n000000\n055776", "output": ["YES\nNO\nYES\nYES\nNO"]}]
|
block_completion_007626
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: A ticket is a string consisting of six digits. A ticket is considered lucky if the sum of the first three digits is equal to the sum of the last three digits. Given a ticket, output if it is lucky or not. Note that a ticket can have leading zeroes.
Input Specification: The first line of the input contains an integer $$$t$$$ ($$$1 \leq t \leq 10^3$$$) — the number of testcases. The description of each test consists of one line containing one string consisting of six digits.
Output Specification: Output $$$t$$$ lines, each of which contains the answer to the corresponding test case. Output "YES" if the given ticket is lucky, and "NO" otherwise. You can output the answer in any case (for example, the strings "yEs", "yes", "Yes" and "YES" will be recognized as a positive answer).
Notes: NoteIn the first test case, the sum of the first three digits is $$$2 + 1 + 3 = 6$$$ and the sum of the last three digits is $$$1 + 3 + 2 = 6$$$, they are equal so the answer is "YES".In the second test case, the sum of the first three digits is $$$9 + 7 + 3 = 19$$$ and the sum of the last three digits is $$$8 + 9 + 4 = 21$$$, they are not equal so the answer is "NO".In the third test case, the sum of the first three digits is $$$0 + 4 + 5 = 9$$$ and the sum of the last three digits is $$$2 + 0 + 7 = 9$$$, they are equal so the answer is "YES".
Code:
n=input()
for i in range(int(n)):
sumf=0
suml=0
s = input()
for x in range(0,3):
sumf += int(s[x])
for x in range(3,6):
suml += int(s[x])
if sumf== suml:
print('YES')
else:
# TODO: Your code here
|
n=input()
for i in range(int(n)):
sumf=0
suml=0
s = input()
for x in range(0,3):
sumf += int(s[x])
for x in range(3,6):
suml += int(s[x])
if sumf== suml:
print('YES')
else:
{{completion}}
|
print('NO')
|
[{"input": "5\n213132\n973894\n045207\n000000\n055776", "output": ["YES\nNO\nYES\nYES\nNO"]}]
|
block_completion_007627
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: A ticket is a string consisting of six digits. A ticket is considered lucky if the sum of the first three digits is equal to the sum of the last three digits. Given a ticket, output if it is lucky or not. Note that a ticket can have leading zeroes.
Input Specification: The first line of the input contains an integer $$$t$$$ ($$$1 \leq t \leq 10^3$$$) — the number of testcases. The description of each test consists of one line containing one string consisting of six digits.
Output Specification: Output $$$t$$$ lines, each of which contains the answer to the corresponding test case. Output "YES" if the given ticket is lucky, and "NO" otherwise. You can output the answer in any case (for example, the strings "yEs", "yes", "Yes" and "YES" will be recognized as a positive answer).
Notes: NoteIn the first test case, the sum of the first three digits is $$$2 + 1 + 3 = 6$$$ and the sum of the last three digits is $$$1 + 3 + 2 = 6$$$, they are equal so the answer is "YES".In the second test case, the sum of the first three digits is $$$9 + 7 + 3 = 19$$$ and the sum of the last three digits is $$$8 + 9 + 4 = 21$$$, they are not equal so the answer is "NO".In the third test case, the sum of the first three digits is $$$0 + 4 + 5 = 9$$$ and the sum of the last three digits is $$$2 + 0 + 7 = 9$$$, they are equal so the answer is "YES".
Code:
for t in range(int(input())):
# TODO: Your code here
|
for t in range(int(input())):
{{completion}}
|
n = list(map(int, list(input())))
print("YES" if n[0]+n[1]+n[2]==n[3]+n[4]+n[5] else "NO")
|
[{"input": "5\n213132\n973894\n045207\n000000\n055776", "output": ["YES\nNO\nYES\nYES\nNO"]}]
|
block_completion_007628
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: Timur's grandfather gifted him a chessboard to practice his chess skills. This chessboard is a grid $$$a$$$ with $$$n$$$ rows and $$$m$$$ columns with each cell having a non-negative integer written on it. Timur's challenge is to place a bishop on the board such that the sum of all cells attacked by the bishop is maximal. The bishop attacks in all directions diagonally, and there is no limit to the distance which the bishop can attack. Note that the cell on which the bishop is placed is also considered attacked. Help him find the maximal sum he can get.
Input Specification: The first line of the input contains a single integer $$$t$$$ ($$$1 \le t \le 1000$$$) — the number of test cases. The description of test cases follows. The first line of each test case contains the integers $$$n$$$ and $$$m$$$ ($$$1 \le n \le 200$$$, $$$1 \leq m \leq 200$$$). The following $$$n$$$ lines contain $$$m$$$ integers each, the $$$j$$$-th element of the $$$i$$$-th line $$$a_{ij}$$$ is the number written in the $$$j$$$-th cell of the $$$i$$$-th row $$$(0\leq a_{ij} \leq 10^6)$$$ It is guaranteed that the sum of $$$n\cdot m$$$ over all test cases does not exceed $$$4\cdot10^4$$$.
Output Specification: For each test case output a single integer, the maximum sum over all possible placements of the bishop.
Notes: NoteFor the first test case here the best sum is achieved by the bishop being in this position:
Code:
t = int(input())
def solve():
n, m = map(int, input().split())
A = [list(map(int, input().split())) for _ in range(n)]
ans = 0
for i in range(n):
for j in range(m):
temp = -A[i][j]
for x in range(n):
# i - j == x - y => y = x - i + j
y = x - i + j
if 0 <= y < m:
# TODO: Your code here
# i + j == x + y
y = i + j - x
if 0 <= y < m:
temp += A[x][y]
ans = max(ans, temp)
print(ans)
for _ in range(t):
solve()
|
t = int(input())
def solve():
n, m = map(int, input().split())
A = [list(map(int, input().split())) for _ in range(n)]
ans = 0
for i in range(n):
for j in range(m):
temp = -A[i][j]
for x in range(n):
# i - j == x - y => y = x - i + j
y = x - i + j
if 0 <= y < m:
{{completion}}
# i + j == x + y
y = i + j - x
if 0 <= y < m:
temp += A[x][y]
ans = max(ans, temp)
print(ans)
for _ in range(t):
solve()
|
temp += A[x][y]
|
[{"input": "4\n4 4\n1 2 2 1\n2 4 2 4\n2 2 3 1\n2 4 2 4\n2 1\n1\n0\n3 3\n1 1 1\n1 1 1\n1 1 1\n3 3\n0 1 1\n1 0 1\n1 1 0", "output": ["20\n1\n5\n3"]}]
|
block_completion_007687
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: Timur's grandfather gifted him a chessboard to practice his chess skills. This chessboard is a grid $$$a$$$ with $$$n$$$ rows and $$$m$$$ columns with each cell having a non-negative integer written on it. Timur's challenge is to place a bishop on the board such that the sum of all cells attacked by the bishop is maximal. The bishop attacks in all directions diagonally, and there is no limit to the distance which the bishop can attack. Note that the cell on which the bishop is placed is also considered attacked. Help him find the maximal sum he can get.
Input Specification: The first line of the input contains a single integer $$$t$$$ ($$$1 \le t \le 1000$$$) — the number of test cases. The description of test cases follows. The first line of each test case contains the integers $$$n$$$ and $$$m$$$ ($$$1 \le n \le 200$$$, $$$1 \leq m \leq 200$$$). The following $$$n$$$ lines contain $$$m$$$ integers each, the $$$j$$$-th element of the $$$i$$$-th line $$$a_{ij}$$$ is the number written in the $$$j$$$-th cell of the $$$i$$$-th row $$$(0\leq a_{ij} \leq 10^6)$$$ It is guaranteed that the sum of $$$n\cdot m$$$ over all test cases does not exceed $$$4\cdot10^4$$$.
Output Specification: For each test case output a single integer, the maximum sum over all possible placements of the bishop.
Notes: NoteFor the first test case here the best sum is achieved by the bishop being in this position:
Code:
t = int(input())
def solve():
n, m = map(int, input().split())
A = [list(map(int, input().split())) for _ in range(n)]
ans = 0
for i in range(n):
for j in range(m):
temp = -A[i][j]
for x in range(n):
# i - j == x - y => y = x - i + j
y = x - i + j
if 0 <= y < m:
temp += A[x][y]
# i + j == x + y
y = i + j - x
if 0 <= y < m:
# TODO: Your code here
ans = max(ans, temp)
print(ans)
for _ in range(t):
solve()
|
t = int(input())
def solve():
n, m = map(int, input().split())
A = [list(map(int, input().split())) for _ in range(n)]
ans = 0
for i in range(n):
for j in range(m):
temp = -A[i][j]
for x in range(n):
# i - j == x - y => y = x - i + j
y = x - i + j
if 0 <= y < m:
temp += A[x][y]
# i + j == x + y
y = i + j - x
if 0 <= y < m:
{{completion}}
ans = max(ans, temp)
print(ans)
for _ in range(t):
solve()
|
temp += A[x][y]
|
[{"input": "4\n4 4\n1 2 2 1\n2 4 2 4\n2 2 3 1\n2 4 2 4\n2 1\n1\n0\n3 3\n1 1 1\n1 1 1\n1 1 1\n3 3\n0 1 1\n1 0 1\n1 1 0", "output": ["20\n1\n5\n3"]}]
|
block_completion_007688
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: Timur's grandfather gifted him a chessboard to practice his chess skills. This chessboard is a grid $$$a$$$ with $$$n$$$ rows and $$$m$$$ columns with each cell having a non-negative integer written on it. Timur's challenge is to place a bishop on the board such that the sum of all cells attacked by the bishop is maximal. The bishop attacks in all directions diagonally, and there is no limit to the distance which the bishop can attack. Note that the cell on which the bishop is placed is also considered attacked. Help him find the maximal sum he can get.
Input Specification: The first line of the input contains a single integer $$$t$$$ ($$$1 \le t \le 1000$$$) — the number of test cases. The description of test cases follows. The first line of each test case contains the integers $$$n$$$ and $$$m$$$ ($$$1 \le n \le 200$$$, $$$1 \leq m \leq 200$$$). The following $$$n$$$ lines contain $$$m$$$ integers each, the $$$j$$$-th element of the $$$i$$$-th line $$$a_{ij}$$$ is the number written in the $$$j$$$-th cell of the $$$i$$$-th row $$$(0\leq a_{ij} \leq 10^6)$$$ It is guaranteed that the sum of $$$n\cdot m$$$ over all test cases does not exceed $$$4\cdot10^4$$$.
Output Specification: For each test case output a single integer, the maximum sum over all possible placements of the bishop.
Notes: NoteFor the first test case here the best sum is achieved by the bishop being in this position:
Code:
k,o=lambda:map(int,input().split()),range
for f in o(*k()):
n,m=k();a=[[*k()]for t in o(n)];l=[0]*(m+n);r=l[:]
for i in o(n):
for j in o(m):# TODO: Your code here
print(max(l[i-j+m-1]+r[i+j]-a[i][j]for i in o(n)for j in o(m)))
|
k,o=lambda:map(int,input().split()),range
for f in o(*k()):
n,m=k();a=[[*k()]for t in o(n)];l=[0]*(m+n);r=l[:]
for i in o(n):
for j in o(m):{{completion}}
print(max(l[i-j+m-1]+r[i+j]-a[i][j]for i in o(n)for j in o(m)))
|
b=a[i][j];l[i-j+m-1]+=b;r[i+j]+=b
|
[{"input": "4\n4 4\n1 2 2 1\n2 4 2 4\n2 2 3 1\n2 4 2 4\n2 1\n1\n0\n3 3\n1 1 1\n1 1 1\n1 1 1\n3 3\n0 1 1\n1 0 1\n1 1 0", "output": ["20\n1\n5\n3"]}]
|
block_completion_007689
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: Timur's grandfather gifted him a chessboard to practice his chess skills. This chessboard is a grid $$$a$$$ with $$$n$$$ rows and $$$m$$$ columns with each cell having a non-negative integer written on it. Timur's challenge is to place a bishop on the board such that the sum of all cells attacked by the bishop is maximal. The bishop attacks in all directions diagonally, and there is no limit to the distance which the bishop can attack. Note that the cell on which the bishop is placed is also considered attacked. Help him find the maximal sum he can get.
Input Specification: The first line of the input contains a single integer $$$t$$$ ($$$1 \le t \le 1000$$$) — the number of test cases. The description of test cases follows. The first line of each test case contains the integers $$$n$$$ and $$$m$$$ ($$$1 \le n \le 200$$$, $$$1 \leq m \leq 200$$$). The following $$$n$$$ lines contain $$$m$$$ integers each, the $$$j$$$-th element of the $$$i$$$-th line $$$a_{ij}$$$ is the number written in the $$$j$$$-th cell of the $$$i$$$-th row $$$(0\leq a_{ij} \leq 10^6)$$$ It is guaranteed that the sum of $$$n\cdot m$$$ over all test cases does not exceed $$$4\cdot10^4$$$.
Output Specification: For each test case output a single integer, the maximum sum over all possible placements of the bishop.
Notes: NoteFor the first test case here the best sum is achieved by the bishop being in this position:
Code:
T = int(input())
for tc in range(T):
(A, B) = map(int, input().split(' '))
nums = []
for i in range(A):
nums.append([int(x) for x in input().split()])
C = A + B - 1
left = [0 for _ in range(C)]
right = [0 for _ in range(C)]
for a in range(A):
for b in range(B):
# TODO: Your code here
# print (left)
# print (right)
damage = 0
for a in range(A):
for b in range(B):
left_index = a + b
right_index = a + B - 1 - b
d = left[left_index] + right[right_index] - nums[a][b]
damage = max(d, damage)
print (damage)
|
T = int(input())
for tc in range(T):
(A, B) = map(int, input().split(' '))
nums = []
for i in range(A):
nums.append([int(x) for x in input().split()])
C = A + B - 1
left = [0 for _ in range(C)]
right = [0 for _ in range(C)]
for a in range(A):
for b in range(B):
{{completion}}
# print (left)
# print (right)
damage = 0
for a in range(A):
for b in range(B):
left_index = a + b
right_index = a + B - 1 - b
d = left[left_index] + right[right_index] - nums[a][b]
damage = max(d, damage)
print (damage)
|
left_index = a + b
right_index = a + B - 1 - b
left[left_index] += nums[a][b]
right[right_index] += nums[a][b]
|
[{"input": "4\n4 4\n1 2 2 1\n2 4 2 4\n2 2 3 1\n2 4 2 4\n2 1\n1\n0\n3 3\n1 1 1\n1 1 1\n1 1 1\n3 3\n0 1 1\n1 0 1\n1 1 0", "output": ["20\n1\n5\n3"]}]
|
block_completion_007690
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: Timur's grandfather gifted him a chessboard to practice his chess skills. This chessboard is a grid $$$a$$$ with $$$n$$$ rows and $$$m$$$ columns with each cell having a non-negative integer written on it. Timur's challenge is to place a bishop on the board such that the sum of all cells attacked by the bishop is maximal. The bishop attacks in all directions diagonally, and there is no limit to the distance which the bishop can attack. Note that the cell on which the bishop is placed is also considered attacked. Help him find the maximal sum he can get.
Input Specification: The first line of the input contains a single integer $$$t$$$ ($$$1 \le t \le 1000$$$) — the number of test cases. The description of test cases follows. The first line of each test case contains the integers $$$n$$$ and $$$m$$$ ($$$1 \le n \le 200$$$, $$$1 \leq m \leq 200$$$). The following $$$n$$$ lines contain $$$m$$$ integers each, the $$$j$$$-th element of the $$$i$$$-th line $$$a_{ij}$$$ is the number written in the $$$j$$$-th cell of the $$$i$$$-th row $$$(0\leq a_{ij} \leq 10^6)$$$ It is guaranteed that the sum of $$$n\cdot m$$$ over all test cases does not exceed $$$4\cdot10^4$$$.
Output Specification: For each test case output a single integer, the maximum sum over all possible placements of the bishop.
Notes: NoteFor the first test case here the best sum is achieved by the bishop being in this position:
Code:
T = int(input())
for tc in range(T):
(A, B) = map(int, input().split(' '))
nums = []
for i in range(A):
nums.append([int(x) for x in input().split()])
C = A + B - 1
left = [0 for _ in range(C)]
right = [0 for _ in range(C)]
for a in range(A):
for b in range(B):
left_index = a + b
right_index = a + B - 1 - b
left[left_index] += nums[a][b]
right[right_index] += nums[a][b]
# print (left)
# print (right)
damage = 0
for a in range(A):
for b in range(B):
# TODO: Your code here
print (damage)
|
T = int(input())
for tc in range(T):
(A, B) = map(int, input().split(' '))
nums = []
for i in range(A):
nums.append([int(x) for x in input().split()])
C = A + B - 1
left = [0 for _ in range(C)]
right = [0 for _ in range(C)]
for a in range(A):
for b in range(B):
left_index = a + b
right_index = a + B - 1 - b
left[left_index] += nums[a][b]
right[right_index] += nums[a][b]
# print (left)
# print (right)
damage = 0
for a in range(A):
for b in range(B):
{{completion}}
print (damage)
|
left_index = a + b
right_index = a + B - 1 - b
d = left[left_index] + right[right_index] - nums[a][b]
damage = max(d, damage)
|
[{"input": "4\n4 4\n1 2 2 1\n2 4 2 4\n2 2 3 1\n2 4 2 4\n2 1\n1\n0\n3 3\n1 1 1\n1 1 1\n1 1 1\n3 3\n0 1 1\n1 0 1\n1 1 0", "output": ["20\n1\n5\n3"]}]
|
block_completion_007691
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: Timur's grandfather gifted him a chessboard to practice his chess skills. This chessboard is a grid $$$a$$$ with $$$n$$$ rows and $$$m$$$ columns with each cell having a non-negative integer written on it. Timur's challenge is to place a bishop on the board such that the sum of all cells attacked by the bishop is maximal. The bishop attacks in all directions diagonally, and there is no limit to the distance which the bishop can attack. Note that the cell on which the bishop is placed is also considered attacked. Help him find the maximal sum he can get.
Input Specification: The first line of the input contains a single integer $$$t$$$ ($$$1 \le t \le 1000$$$) — the number of test cases. The description of test cases follows. The first line of each test case contains the integers $$$n$$$ and $$$m$$$ ($$$1 \le n \le 200$$$, $$$1 \leq m \leq 200$$$). The following $$$n$$$ lines contain $$$m$$$ integers each, the $$$j$$$-th element of the $$$i$$$-th line $$$a_{ij}$$$ is the number written in the $$$j$$$-th cell of the $$$i$$$-th row $$$(0\leq a_{ij} \leq 10^6)$$$ It is guaranteed that the sum of $$$n\cdot m$$$ over all test cases does not exceed $$$4\cdot10^4$$$.
Output Specification: For each test case output a single integer, the maximum sum over all possible placements of the bishop.
Notes: NoteFor the first test case here the best sum is achieved by the bishop being in this position:
Code:
import sys
sm_row = [-1, +1, -1, +1]
sm_column = [-1, +1, +1, -1]
for _ in range(int(sys.stdin.readline())):
n, m = map(int, sys.stdin.readline().split())
t = []
maximum = 0
for i in range(n):
t.append(list(map(int, sys.stdin.readline().split())))
for row in range(n):
for column in range(m):
summa = 0
for i in range(4):
new_row = row
new_column = column
while 0 <= new_row < n and 0 <= new_column < m:
# TODO: Your code here
summa -= (t[row][column] * 3)
maximum = max(maximum, summa)
print(maximum)
|
import sys
sm_row = [-1, +1, -1, +1]
sm_column = [-1, +1, +1, -1]
for _ in range(int(sys.stdin.readline())):
n, m = map(int, sys.stdin.readline().split())
t = []
maximum = 0
for i in range(n):
t.append(list(map(int, sys.stdin.readline().split())))
for row in range(n):
for column in range(m):
summa = 0
for i in range(4):
new_row = row
new_column = column
while 0 <= new_row < n and 0 <= new_column < m:
{{completion}}
summa -= (t[row][column] * 3)
maximum = max(maximum, summa)
print(maximum)
|
summa += t[new_row][new_column]
new_row += sm_row[i]
new_column += sm_column[i]
|
[{"input": "4\n4 4\n1 2 2 1\n2 4 2 4\n2 2 3 1\n2 4 2 4\n2 1\n1\n0\n3 3\n1 1 1\n1 1 1\n1 1 1\n3 3\n0 1 1\n1 0 1\n1 1 0", "output": ["20\n1\n5\n3"]}]
|
block_completion_007692
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: Timur's grandfather gifted him a chessboard to practice his chess skills. This chessboard is a grid $$$a$$$ with $$$n$$$ rows and $$$m$$$ columns with each cell having a non-negative integer written on it. Timur's challenge is to place a bishop on the board such that the sum of all cells attacked by the bishop is maximal. The bishop attacks in all directions diagonally, and there is no limit to the distance which the bishop can attack. Note that the cell on which the bishop is placed is also considered attacked. Help him find the maximal sum he can get.
Input Specification: The first line of the input contains a single integer $$$t$$$ ($$$1 \le t \le 1000$$$) — the number of test cases. The description of test cases follows. The first line of each test case contains the integers $$$n$$$ and $$$m$$$ ($$$1 \le n \le 200$$$, $$$1 \leq m \leq 200$$$). The following $$$n$$$ lines contain $$$m$$$ integers each, the $$$j$$$-th element of the $$$i$$$-th line $$$a_{ij}$$$ is the number written in the $$$j$$$-th cell of the $$$i$$$-th row $$$(0\leq a_{ij} \leq 10^6)$$$ It is guaranteed that the sum of $$$n\cdot m$$$ over all test cases does not exceed $$$4\cdot10^4$$$.
Output Specification: For each test case output a single integer, the maximum sum over all possible placements of the bishop.
Notes: NoteFor the first test case here the best sum is achieved by the bishop being in this position:
Code:
# auther: codeCell
for _ in range(int(input())):
n,m=map(int,input().split())
a = [ [*map(int, input().split())] for _ in range(n)]
u = [0]*(n+m-1)
v = [0]*(n+m-1)
for i in range(n):
for j in range(m):
# TODO: Your code here
for i in range(n):
for j in range(m):
a[i][j] = u[i+j] + v[i-j] - a[i][j]
print(max(map(max,a)))
|
# auther: codeCell
for _ in range(int(input())):
n,m=map(int,input().split())
a = [ [*map(int, input().split())] for _ in range(n)]
u = [0]*(n+m-1)
v = [0]*(n+m-1)
for i in range(n):
for j in range(m):
{{completion}}
for i in range(n):
for j in range(m):
a[i][j] = u[i+j] + v[i-j] - a[i][j]
print(max(map(max,a)))
|
u[i+j] += a[i][j]
v[i-j] += a[i][j]
|
[{"input": "4\n4 4\n1 2 2 1\n2 4 2 4\n2 2 3 1\n2 4 2 4\n2 1\n1\n0\n3 3\n1 1 1\n1 1 1\n1 1 1\n3 3\n0 1 1\n1 0 1\n1 1 0", "output": ["20\n1\n5\n3"]}]
|
block_completion_007693
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: Timur's grandfather gifted him a chessboard to practice his chess skills. This chessboard is a grid $$$a$$$ with $$$n$$$ rows and $$$m$$$ columns with each cell having a non-negative integer written on it. Timur's challenge is to place a bishop on the board such that the sum of all cells attacked by the bishop is maximal. The bishop attacks in all directions diagonally, and there is no limit to the distance which the bishop can attack. Note that the cell on which the bishop is placed is also considered attacked. Help him find the maximal sum he can get.
Input Specification: The first line of the input contains a single integer $$$t$$$ ($$$1 \le t \le 1000$$$) — the number of test cases. The description of test cases follows. The first line of each test case contains the integers $$$n$$$ and $$$m$$$ ($$$1 \le n \le 200$$$, $$$1 \leq m \leq 200$$$). The following $$$n$$$ lines contain $$$m$$$ integers each, the $$$j$$$-th element of the $$$i$$$-th line $$$a_{ij}$$$ is the number written in the $$$j$$$-th cell of the $$$i$$$-th row $$$(0\leq a_{ij} \leq 10^6)$$$ It is guaranteed that the sum of $$$n\cdot m$$$ over all test cases does not exceed $$$4\cdot10^4$$$.
Output Specification: For each test case output a single integer, the maximum sum over all possible placements of the bishop.
Notes: NoteFor the first test case here the best sum is achieved by the bishop being in this position:
Code:
# auther: codeCell
for _ in range(int(input())):
n,m=map(int,input().split())
a = [ [*map(int, input().split())] for _ in range(n)]
u = [0]*(n+m-1)
v = [0]*(n+m-1)
for i in range(n):
for j in range(m):
u[i+j] += a[i][j]
v[i-j] += a[i][j]
for i in range(n):
for j in range(m):
# TODO: Your code here
print(max(map(max,a)))
|
# auther: codeCell
for _ in range(int(input())):
n,m=map(int,input().split())
a = [ [*map(int, input().split())] for _ in range(n)]
u = [0]*(n+m-1)
v = [0]*(n+m-1)
for i in range(n):
for j in range(m):
u[i+j] += a[i][j]
v[i-j] += a[i][j]
for i in range(n):
for j in range(m):
{{completion}}
print(max(map(max,a)))
|
a[i][j] = u[i+j] + v[i-j] - a[i][j]
|
[{"input": "4\n4 4\n1 2 2 1\n2 4 2 4\n2 2 3 1\n2 4 2 4\n2 1\n1\n0\n3 3\n1 1 1\n1 1 1\n1 1 1\n3 3\n0 1 1\n1 0 1\n1 1 0", "output": ["20\n1\n5\n3"]}]
|
block_completion_007694
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: Timur's grandfather gifted him a chessboard to practice his chess skills. This chessboard is a grid $$$a$$$ with $$$n$$$ rows and $$$m$$$ columns with each cell having a non-negative integer written on it. Timur's challenge is to place a bishop on the board such that the sum of all cells attacked by the bishop is maximal. The bishop attacks in all directions diagonally, and there is no limit to the distance which the bishop can attack. Note that the cell on which the bishop is placed is also considered attacked. Help him find the maximal sum he can get.
Input Specification: The first line of the input contains a single integer $$$t$$$ ($$$1 \le t \le 1000$$$) — the number of test cases. The description of test cases follows. The first line of each test case contains the integers $$$n$$$ and $$$m$$$ ($$$1 \le n \le 200$$$, $$$1 \leq m \leq 200$$$). The following $$$n$$$ lines contain $$$m$$$ integers each, the $$$j$$$-th element of the $$$i$$$-th line $$$a_{ij}$$$ is the number written in the $$$j$$$-th cell of the $$$i$$$-th row $$$(0\leq a_{ij} \leq 10^6)$$$ It is guaranteed that the sum of $$$n\cdot m$$$ over all test cases does not exceed $$$4\cdot10^4$$$.
Output Specification: For each test case output a single integer, the maximum sum over all possible placements of the bishop.
Notes: NoteFor the first test case here the best sum is achieved by the bishop being in this position:
Code:
import math,sys;input=sys.stdin.readline;S=lambda:input().rstrip();I=lambda:int(S());M=lambda:map(int,S().split());L=lambda:list(M());mod1=1000000007;mod2=998244353
for _ in range(I()):
n,m=M();l=[L() for i in range(n)];ans=0
for i in range(n):
for j in range(m):
s=l[i][j]
p,q=i,j;s-=l[p][q]
while p>=0 and q>=0:
# TODO: Your code here
p,q=i,j;s-=l[p][q]
while p>=0 and q<m:
s+=l[p][q];p-=1;q+=1
p,q=i,j;s-=l[p][q]
while p<n and q>=0:
s+=l[p][q];p+=1;q-=1
p,q=i,j;s-=l[p][q]
while p<n and q<m:
s+=l[p][q];p+=1;q+=1
ans=max(ans,s)
print(ans)
|
import math,sys;input=sys.stdin.readline;S=lambda:input().rstrip();I=lambda:int(S());M=lambda:map(int,S().split());L=lambda:list(M());mod1=1000000007;mod2=998244353
for _ in range(I()):
n,m=M();l=[L() for i in range(n)];ans=0
for i in range(n):
for j in range(m):
s=l[i][j]
p,q=i,j;s-=l[p][q]
while p>=0 and q>=0:
{{completion}}
p,q=i,j;s-=l[p][q]
while p>=0 and q<m:
s+=l[p][q];p-=1;q+=1
p,q=i,j;s-=l[p][q]
while p<n and q>=0:
s+=l[p][q];p+=1;q-=1
p,q=i,j;s-=l[p][q]
while p<n and q<m:
s+=l[p][q];p+=1;q+=1
ans=max(ans,s)
print(ans)
|
s+=l[p][q];p-=1;q-=1
|
[{"input": "4\n4 4\n1 2 2 1\n2 4 2 4\n2 2 3 1\n2 4 2 4\n2 1\n1\n0\n3 3\n1 1 1\n1 1 1\n1 1 1\n3 3\n0 1 1\n1 0 1\n1 1 0", "output": ["20\n1\n5\n3"]}]
|
block_completion_007695
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: Timur's grandfather gifted him a chessboard to practice his chess skills. This chessboard is a grid $$$a$$$ with $$$n$$$ rows and $$$m$$$ columns with each cell having a non-negative integer written on it. Timur's challenge is to place a bishop on the board such that the sum of all cells attacked by the bishop is maximal. The bishop attacks in all directions diagonally, and there is no limit to the distance which the bishop can attack. Note that the cell on which the bishop is placed is also considered attacked. Help him find the maximal sum he can get.
Input Specification: The first line of the input contains a single integer $$$t$$$ ($$$1 \le t \le 1000$$$) — the number of test cases. The description of test cases follows. The first line of each test case contains the integers $$$n$$$ and $$$m$$$ ($$$1 \le n \le 200$$$, $$$1 \leq m \leq 200$$$). The following $$$n$$$ lines contain $$$m$$$ integers each, the $$$j$$$-th element of the $$$i$$$-th line $$$a_{ij}$$$ is the number written in the $$$j$$$-th cell of the $$$i$$$-th row $$$(0\leq a_{ij} \leq 10^6)$$$ It is guaranteed that the sum of $$$n\cdot m$$$ over all test cases does not exceed $$$4\cdot10^4$$$.
Output Specification: For each test case output a single integer, the maximum sum over all possible placements of the bishop.
Notes: NoteFor the first test case here the best sum is achieved by the bishop being in this position:
Code:
import math,sys;input=sys.stdin.readline;S=lambda:input().rstrip();I=lambda:int(S());M=lambda:map(int,S().split());L=lambda:list(M());mod1=1000000007;mod2=998244353
for _ in range(I()):
n,m=M();l=[L() for i in range(n)];ans=0
for i in range(n):
for j in range(m):
s=l[i][j]
p,q=i,j;s-=l[p][q]
while p>=0 and q>=0:
s+=l[p][q];p-=1;q-=1
p,q=i,j;s-=l[p][q]
while p>=0 and q<m:
# TODO: Your code here
p,q=i,j;s-=l[p][q]
while p<n and q>=0:
s+=l[p][q];p+=1;q-=1
p,q=i,j;s-=l[p][q]
while p<n and q<m:
s+=l[p][q];p+=1;q+=1
ans=max(ans,s)
print(ans)
|
import math,sys;input=sys.stdin.readline;S=lambda:input().rstrip();I=lambda:int(S());M=lambda:map(int,S().split());L=lambda:list(M());mod1=1000000007;mod2=998244353
for _ in range(I()):
n,m=M();l=[L() for i in range(n)];ans=0
for i in range(n):
for j in range(m):
s=l[i][j]
p,q=i,j;s-=l[p][q]
while p>=0 and q>=0:
s+=l[p][q];p-=1;q-=1
p,q=i,j;s-=l[p][q]
while p>=0 and q<m:
{{completion}}
p,q=i,j;s-=l[p][q]
while p<n and q>=0:
s+=l[p][q];p+=1;q-=1
p,q=i,j;s-=l[p][q]
while p<n and q<m:
s+=l[p][q];p+=1;q+=1
ans=max(ans,s)
print(ans)
|
s+=l[p][q];p-=1;q+=1
|
[{"input": "4\n4 4\n1 2 2 1\n2 4 2 4\n2 2 3 1\n2 4 2 4\n2 1\n1\n0\n3 3\n1 1 1\n1 1 1\n1 1 1\n3 3\n0 1 1\n1 0 1\n1 1 0", "output": ["20\n1\n5\n3"]}]
|
block_completion_007696
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: Timur's grandfather gifted him a chessboard to practice his chess skills. This chessboard is a grid $$$a$$$ with $$$n$$$ rows and $$$m$$$ columns with each cell having a non-negative integer written on it. Timur's challenge is to place a bishop on the board such that the sum of all cells attacked by the bishop is maximal. The bishop attacks in all directions diagonally, and there is no limit to the distance which the bishop can attack. Note that the cell on which the bishop is placed is also considered attacked. Help him find the maximal sum he can get.
Input Specification: The first line of the input contains a single integer $$$t$$$ ($$$1 \le t \le 1000$$$) — the number of test cases. The description of test cases follows. The first line of each test case contains the integers $$$n$$$ and $$$m$$$ ($$$1 \le n \le 200$$$, $$$1 \leq m \leq 200$$$). The following $$$n$$$ lines contain $$$m$$$ integers each, the $$$j$$$-th element of the $$$i$$$-th line $$$a_{ij}$$$ is the number written in the $$$j$$$-th cell of the $$$i$$$-th row $$$(0\leq a_{ij} \leq 10^6)$$$ It is guaranteed that the sum of $$$n\cdot m$$$ over all test cases does not exceed $$$4\cdot10^4$$$.
Output Specification: For each test case output a single integer, the maximum sum over all possible placements of the bishop.
Notes: NoteFor the first test case here the best sum is achieved by the bishop being in this position:
Code:
t=eval(input())
for i in range(t):
ans=-1
temp=[int(x) for x in input().split()]
n,m=temp[0],temp[1] # n*m
check=[]
for j in range(n):
temp=[int(x) for x in input().split()]
check.append(temp)
dic_l={}
dic_r={}
for x in range(n):
for y in range(m):
if x+y not in dic_l:
dic_l[x+y]=check[x][y]
else:
# TODO: Your code here
if y-x not in dic_r:
dic_r[y-x]=check[x][y]
else:
dic_r[y-x]+=check[x][y]
for x in range(n):
for y in range(m):
ans=max(ans,dic_l[x+y]+dic_r[y-x]-check[x][y])
print(ans)
|
t=eval(input())
for i in range(t):
ans=-1
temp=[int(x) for x in input().split()]
n,m=temp[0],temp[1] # n*m
check=[]
for j in range(n):
temp=[int(x) for x in input().split()]
check.append(temp)
dic_l={}
dic_r={}
for x in range(n):
for y in range(m):
if x+y not in dic_l:
dic_l[x+y]=check[x][y]
else:
{{completion}}
if y-x not in dic_r:
dic_r[y-x]=check[x][y]
else:
dic_r[y-x]+=check[x][y]
for x in range(n):
for y in range(m):
ans=max(ans,dic_l[x+y]+dic_r[y-x]-check[x][y])
print(ans)
|
dic_l[x+y]+=check[x][y]
|
[{"input": "4\n4 4\n1 2 2 1\n2 4 2 4\n2 2 3 1\n2 4 2 4\n2 1\n1\n0\n3 3\n1 1 1\n1 1 1\n1 1 1\n3 3\n0 1 1\n1 0 1\n1 1 0", "output": ["20\n1\n5\n3"]}]
|
block_completion_007697
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: Timur's grandfather gifted him a chessboard to practice his chess skills. This chessboard is a grid $$$a$$$ with $$$n$$$ rows and $$$m$$$ columns with each cell having a non-negative integer written on it. Timur's challenge is to place a bishop on the board such that the sum of all cells attacked by the bishop is maximal. The bishop attacks in all directions diagonally, and there is no limit to the distance which the bishop can attack. Note that the cell on which the bishop is placed is also considered attacked. Help him find the maximal sum he can get.
Input Specification: The first line of the input contains a single integer $$$t$$$ ($$$1 \le t \le 1000$$$) — the number of test cases. The description of test cases follows. The first line of each test case contains the integers $$$n$$$ and $$$m$$$ ($$$1 \le n \le 200$$$, $$$1 \leq m \leq 200$$$). The following $$$n$$$ lines contain $$$m$$$ integers each, the $$$j$$$-th element of the $$$i$$$-th line $$$a_{ij}$$$ is the number written in the $$$j$$$-th cell of the $$$i$$$-th row $$$(0\leq a_{ij} \leq 10^6)$$$ It is guaranteed that the sum of $$$n\cdot m$$$ over all test cases does not exceed $$$4\cdot10^4$$$.
Output Specification: For each test case output a single integer, the maximum sum over all possible placements of the bishop.
Notes: NoteFor the first test case here the best sum is achieved by the bishop being in this position:
Code:
t=eval(input())
for i in range(t):
ans=-1
temp=[int(x) for x in input().split()]
n,m=temp[0],temp[1] # n*m
check=[]
for j in range(n):
temp=[int(x) for x in input().split()]
check.append(temp)
dic_l={}
dic_r={}
for x in range(n):
for y in range(m):
if x+y not in dic_l:
dic_l[x+y]=check[x][y]
else:
dic_l[x+y]+=check[x][y]
if y-x not in dic_r:
dic_r[y-x]=check[x][y]
else:
# TODO: Your code here
for x in range(n):
for y in range(m):
ans=max(ans,dic_l[x+y]+dic_r[y-x]-check[x][y])
print(ans)
|
t=eval(input())
for i in range(t):
ans=-1
temp=[int(x) for x in input().split()]
n,m=temp[0],temp[1] # n*m
check=[]
for j in range(n):
temp=[int(x) for x in input().split()]
check.append(temp)
dic_l={}
dic_r={}
for x in range(n):
for y in range(m):
if x+y not in dic_l:
dic_l[x+y]=check[x][y]
else:
dic_l[x+y]+=check[x][y]
if y-x not in dic_r:
dic_r[y-x]=check[x][y]
else:
{{completion}}
for x in range(n):
for y in range(m):
ans=max(ans,dic_l[x+y]+dic_r[y-x]-check[x][y])
print(ans)
|
dic_r[y-x]+=check[x][y]
|
[{"input": "4\n4 4\n1 2 2 1\n2 4 2 4\n2 2 3 1\n2 4 2 4\n2 1\n1\n0\n3 3\n1 1 1\n1 1 1\n1 1 1\n3 3\n0 1 1\n1 0 1\n1 1 0", "output": ["20\n1\n5\n3"]}]
|
block_completion_007698
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: Timur's grandfather gifted him a chessboard to practice his chess skills. This chessboard is a grid $$$a$$$ with $$$n$$$ rows and $$$m$$$ columns with each cell having a non-negative integer written on it. Timur's challenge is to place a bishop on the board such that the sum of all cells attacked by the bishop is maximal. The bishop attacks in all directions diagonally, and there is no limit to the distance which the bishop can attack. Note that the cell on which the bishop is placed is also considered attacked. Help him find the maximal sum he can get.
Input Specification: The first line of the input contains a single integer $$$t$$$ ($$$1 \le t \le 1000$$$) — the number of test cases. The description of test cases follows. The first line of each test case contains the integers $$$n$$$ and $$$m$$$ ($$$1 \le n \le 200$$$, $$$1 \leq m \leq 200$$$). The following $$$n$$$ lines contain $$$m$$$ integers each, the $$$j$$$-th element of the $$$i$$$-th line $$$a_{ij}$$$ is the number written in the $$$j$$$-th cell of the $$$i$$$-th row $$$(0\leq a_{ij} \leq 10^6)$$$ It is guaranteed that the sum of $$$n\cdot m$$$ over all test cases does not exceed $$$4\cdot10^4$$$.
Output Specification: For each test case output a single integer, the maximum sum over all possible placements of the bishop.
Notes: NoteFor the first test case here the best sum is achieved by the bishop being in this position:
Code:
def calc(x, y):
ans = 0
x1, y1 = x, y
while x1 > 0 and y1 > 0:
ans += field[y1 - 1][x1 - 1]
x1 -= 1
y1 -= 1
# print("OK", x1, y1)
x1, y1 = x, y
x1 += 1
y1 += 1
while x1 <= m and y1 <= n:
ans += field[y1 - 1][x1 - 1]
x1 += 1
y1 += 1
x1, y1 = x, y
x1 -= 1
y1 += 1
while x1 > 0 and y1 <= n:
ans += field[y1 - 1][x1 - 1]
x1 -= 1
y1 += 1
x1, y1 = x, y
x1 += 1
y1 -= 1
while x1 <= m and y1 > 0:
ans += field[y1 - 1][x1 - 1]
x1 += 1
y1 -= 1
return ans
for _ in range(int(input())):
n, m = map(int, input().split())
field = [list(map(int, input().split())) for _ in range(n)]
max_sum = -1
for y in range(n):
for x in range(m):
# TODO: Your code here
print(max_sum)
|
def calc(x, y):
ans = 0
x1, y1 = x, y
while x1 > 0 and y1 > 0:
ans += field[y1 - 1][x1 - 1]
x1 -= 1
y1 -= 1
# print("OK", x1, y1)
x1, y1 = x, y
x1 += 1
y1 += 1
while x1 <= m and y1 <= n:
ans += field[y1 - 1][x1 - 1]
x1 += 1
y1 += 1
x1, y1 = x, y
x1 -= 1
y1 += 1
while x1 > 0 and y1 <= n:
ans += field[y1 - 1][x1 - 1]
x1 -= 1
y1 += 1
x1, y1 = x, y
x1 += 1
y1 -= 1
while x1 <= m and y1 > 0:
ans += field[y1 - 1][x1 - 1]
x1 += 1
y1 -= 1
return ans
for _ in range(int(input())):
n, m = map(int, input().split())
field = [list(map(int, input().split())) for _ in range(n)]
max_sum = -1
for y in range(n):
for x in range(m):
{{completion}}
print(max_sum)
|
max_sum = max(max_sum, calc(x + 1, y + 1))
|
[{"input": "4\n4 4\n1 2 2 1\n2 4 2 4\n2 2 3 1\n2 4 2 4\n2 1\n1\n0\n3 3\n1 1 1\n1 1 1\n1 1 1\n3 3\n0 1 1\n1 0 1\n1 1 0", "output": ["20\n1\n5\n3"]}]
|
block_completion_007699
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: Timur's grandfather gifted him a chessboard to practice his chess skills. This chessboard is a grid $$$a$$$ with $$$n$$$ rows and $$$m$$$ columns with each cell having a non-negative integer written on it. Timur's challenge is to place a bishop on the board such that the sum of all cells attacked by the bishop is maximal. The bishop attacks in all directions diagonally, and there is no limit to the distance which the bishop can attack. Note that the cell on which the bishop is placed is also considered attacked. Help him find the maximal sum he can get.
Input Specification: The first line of the input contains a single integer $$$t$$$ ($$$1 \le t \le 1000$$$) — the number of test cases. The description of test cases follows. The first line of each test case contains the integers $$$n$$$ and $$$m$$$ ($$$1 \le n \le 200$$$, $$$1 \leq m \leq 200$$$). The following $$$n$$$ lines contain $$$m$$$ integers each, the $$$j$$$-th element of the $$$i$$$-th line $$$a_{ij}$$$ is the number written in the $$$j$$$-th cell of the $$$i$$$-th row $$$(0\leq a_{ij} \leq 10^6)$$$ It is guaranteed that the sum of $$$n\cdot m$$$ over all test cases does not exceed $$$4\cdot10^4$$$.
Output Specification: For each test case output a single integer, the maximum sum over all possible placements of the bishop.
Notes: NoteFor the first test case here the best sum is achieved by the bishop being in this position:
Code:
I,R=lambda:map(int,input().split()),range
for _ in R(*I()):
n,m=I();a=[[*I()] for _ in R(n)];l=[0]*(m+n);r=l[:]
for i in R(n):
for j in R(m):
# TODO: Your code here
print(max(l[i-j+m-1]+r[i+j]-a[i][j] for i in R(n) for j in R(m)))
|
I,R=lambda:map(int,input().split()),range
for _ in R(*I()):
n,m=I();a=[[*I()] for _ in R(n)];l=[0]*(m+n);r=l[:]
for i in R(n):
for j in R(m):
{{completion}}
print(max(l[i-j+m-1]+r[i+j]-a[i][j] for i in R(n) for j in R(m)))
|
b=a[i][j];l[i-j+m-1]+=b;r[i+j]+=b
|
[{"input": "4\n4 4\n1 2 2 1\n2 4 2 4\n2 2 3 1\n2 4 2 4\n2 1\n1\n0\n3 3\n1 1 1\n1 1 1\n1 1 1\n3 3\n0 1 1\n1 0 1\n1 1 0", "output": ["20\n1\n5\n3"]}]
|
block_completion_007700
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: Timur's grandfather gifted him a chessboard to practice his chess skills. This chessboard is a grid $$$a$$$ with $$$n$$$ rows and $$$m$$$ columns with each cell having a non-negative integer written on it. Timur's challenge is to place a bishop on the board such that the sum of all cells attacked by the bishop is maximal. The bishop attacks in all directions diagonally, and there is no limit to the distance which the bishop can attack. Note that the cell on which the bishop is placed is also considered attacked. Help him find the maximal sum he can get.
Input Specification: The first line of the input contains a single integer $$$t$$$ ($$$1 \le t \le 1000$$$) — the number of test cases. The description of test cases follows. The first line of each test case contains the integers $$$n$$$ and $$$m$$$ ($$$1 \le n \le 200$$$, $$$1 \leq m \leq 200$$$). The following $$$n$$$ lines contain $$$m$$$ integers each, the $$$j$$$-th element of the $$$i$$$-th line $$$a_{ij}$$$ is the number written in the $$$j$$$-th cell of the $$$i$$$-th row $$$(0\leq a_{ij} \leq 10^6)$$$ It is guaranteed that the sum of $$$n\cdot m$$$ over all test cases does not exceed $$$4\cdot10^4$$$.
Output Specification: For each test case output a single integer, the maximum sum over all possible placements of the bishop.
Notes: NoteFor the first test case here the best sum is achieved by the bishop being in this position:
Code:
t=int(input())
for p in range(t):
n,m=map(int,input().split())
c=[]
b=[]
s=0
for i in range(n):
a=list(map(int,input().split()))
b+=[a]
for k in range(n):
for l in range(m):
for v in range(min(l,k)+1):
# TODO: Your code here
for w in range(1,min(n-k-1,m-l-1)+1):
s+=b[k+w][l+w]
for i1 in range(1,min(k,m-l-1)+1):
s+=b[k-i1][l+i1]
for j1 in range(1,min(n-k-1,l)+1):
s+=b[k+j1][l-j1]
c+=[s]
s=0
print(max(c))
|
t=int(input())
for p in range(t):
n,m=map(int,input().split())
c=[]
b=[]
s=0
for i in range(n):
a=list(map(int,input().split()))
b+=[a]
for k in range(n):
for l in range(m):
for v in range(min(l,k)+1):
{{completion}}
for w in range(1,min(n-k-1,m-l-1)+1):
s+=b[k+w][l+w]
for i1 in range(1,min(k,m-l-1)+1):
s+=b[k-i1][l+i1]
for j1 in range(1,min(n-k-1,l)+1):
s+=b[k+j1][l-j1]
c+=[s]
s=0
print(max(c))
|
s+=b[k-v][l-v]
|
[{"input": "4\n4 4\n1 2 2 1\n2 4 2 4\n2 2 3 1\n2 4 2 4\n2 1\n1\n0\n3 3\n1 1 1\n1 1 1\n1 1 1\n3 3\n0 1 1\n1 0 1\n1 1 0", "output": ["20\n1\n5\n3"]}]
|
block_completion_007701
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: Timur's grandfather gifted him a chessboard to practice his chess skills. This chessboard is a grid $$$a$$$ with $$$n$$$ rows and $$$m$$$ columns with each cell having a non-negative integer written on it. Timur's challenge is to place a bishop on the board such that the sum of all cells attacked by the bishop is maximal. The bishop attacks in all directions diagonally, and there is no limit to the distance which the bishop can attack. Note that the cell on which the bishop is placed is also considered attacked. Help him find the maximal sum he can get.
Input Specification: The first line of the input contains a single integer $$$t$$$ ($$$1 \le t \le 1000$$$) — the number of test cases. The description of test cases follows. The first line of each test case contains the integers $$$n$$$ and $$$m$$$ ($$$1 \le n \le 200$$$, $$$1 \leq m \leq 200$$$). The following $$$n$$$ lines contain $$$m$$$ integers each, the $$$j$$$-th element of the $$$i$$$-th line $$$a_{ij}$$$ is the number written in the $$$j$$$-th cell of the $$$i$$$-th row $$$(0\leq a_{ij} \leq 10^6)$$$ It is guaranteed that the sum of $$$n\cdot m$$$ over all test cases does not exceed $$$4\cdot10^4$$$.
Output Specification: For each test case output a single integer, the maximum sum over all possible placements of the bishop.
Notes: NoteFor the first test case here the best sum is achieved by the bishop being in this position:
Code:
t=int(input())
for p in range(t):
n,m=map(int,input().split())
c=[]
b=[]
s=0
for i in range(n):
a=list(map(int,input().split()))
b+=[a]
for k in range(n):
for l in range(m):
for v in range(min(l,k)+1):
s+=b[k-v][l-v]
for w in range(1,min(n-k-1,m-l-1)+1):
# TODO: Your code here
for i1 in range(1,min(k,m-l-1)+1):
s+=b[k-i1][l+i1]
for j1 in range(1,min(n-k-1,l)+1):
s+=b[k+j1][l-j1]
c+=[s]
s=0
print(max(c))
|
t=int(input())
for p in range(t):
n,m=map(int,input().split())
c=[]
b=[]
s=0
for i in range(n):
a=list(map(int,input().split()))
b+=[a]
for k in range(n):
for l in range(m):
for v in range(min(l,k)+1):
s+=b[k-v][l-v]
for w in range(1,min(n-k-1,m-l-1)+1):
{{completion}}
for i1 in range(1,min(k,m-l-1)+1):
s+=b[k-i1][l+i1]
for j1 in range(1,min(n-k-1,l)+1):
s+=b[k+j1][l-j1]
c+=[s]
s=0
print(max(c))
|
s+=b[k+w][l+w]
|
[{"input": "4\n4 4\n1 2 2 1\n2 4 2 4\n2 2 3 1\n2 4 2 4\n2 1\n1\n0\n3 3\n1 1 1\n1 1 1\n1 1 1\n3 3\n0 1 1\n1 0 1\n1 1 0", "output": ["20\n1\n5\n3"]}]
|
block_completion_007702
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: Your friend Ivan asked you to help him rearrange his desktop. The desktop can be represented as a rectangle matrix of size $$$n \times m$$$ consisting of characters '.' (empty cell of the desktop) and '*' (an icon).The desktop is called good if all its icons are occupying some prefix of full columns and, possibly, the prefix of the next column (and there are no icons outside this figure). In other words, some amount of first columns will be filled with icons and, possibly, some amount of first cells of the next (after the last full column) column will be also filled with icons (and all the icons on the desktop belong to this figure). This is pretty much the same as the real life icons arrangement.In one move, you can take one icon and move it to any empty cell in the desktop.Ivan loves to add some icons to his desktop and remove them from it, so he is asking you to answer $$$q$$$ queries: what is the minimum number of moves required to make the desktop good after adding/removing one icon?Note that queries are permanent and change the state of the desktop.
Input Specification: The first line of the input contains three integers $$$n$$$, $$$m$$$ and $$$q$$$ ($$$1 \le n, m \le 1000; 1 \le q \le 2 \cdot 10^5$$$) — the number of rows in the desktop, the number of columns in the desktop and the number of queries, respectively. The next $$$n$$$ lines contain the description of the desktop. The $$$i$$$-th of them contains $$$m$$$ characters '.' and '*' — the description of the $$$i$$$-th row of the desktop. The next $$$q$$$ lines describe queries. The $$$i$$$-th of them contains two integers $$$x_i$$$ and $$$y_i$$$ ($$$1 \le x_i \le n; 1 \le y_i \le m$$$) — the position of the cell which changes its state (if this cell contained the icon before, then this icon is removed, otherwise an icon appears in this cell).
Output Specification: Print $$$q$$$ integers. The $$$i$$$-th of them should be the minimum number of moves required to make the desktop good after applying the first $$$i$$$ queries.
Code:
h, w, q = map(int, input().split())
p = [False] * (h * w)
c = cc = 0
def query(y, x):
global c, cc
i = x*h+y
p[i] = not p[i]
if p[i]:
if i < c:
cc += 1
c += 1
if p[c-1]:
cc += 1
else:
if i < c:
# TODO: Your code here
c -= 1
if p[c]:
cc -= 1
return c - cc
for y in range(h):
inp = input()
for x in range(w):
if inp[x] == '*':
query(y, x)
for _ in range(q):
x, y = map(int, input().split())
print(query(x-1, y-1))
|
h, w, q = map(int, input().split())
p = [False] * (h * w)
c = cc = 0
def query(y, x):
global c, cc
i = x*h+y
p[i] = not p[i]
if p[i]:
if i < c:
cc += 1
c += 1
if p[c-1]:
cc += 1
else:
if i < c:
{{completion}}
c -= 1
if p[c]:
cc -= 1
return c - cc
for y in range(h):
inp = input()
for x in range(w):
if inp[x] == '*':
query(y, x)
for _ in range(q):
x, y = map(int, input().split())
print(query(x-1, y-1))
|
cc -= 1
|
[{"input": "4 4 8\n..**\n.*..\n*...\n...*\n1 3\n2 3\n3 1\n2 3\n3 4\n4 3\n2 3\n2 2", "output": ["3\n4\n4\n3\n4\n5\n5\n5"]}, {"input": "2 5 5\n*...*\n*****\n1 3\n2 2\n1 3\n1 5\n2 3", "output": ["2\n3\n3\n3\n2"]}]
|
block_completion_007861
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: Your friend Ivan asked you to help him rearrange his desktop. The desktop can be represented as a rectangle matrix of size $$$n \times m$$$ consisting of characters '.' (empty cell of the desktop) and '*' (an icon).The desktop is called good if all its icons are occupying some prefix of full columns and, possibly, the prefix of the next column (and there are no icons outside this figure). In other words, some amount of first columns will be filled with icons and, possibly, some amount of first cells of the next (after the last full column) column will be also filled with icons (and all the icons on the desktop belong to this figure). This is pretty much the same as the real life icons arrangement.In one move, you can take one icon and move it to any empty cell in the desktop.Ivan loves to add some icons to his desktop and remove them from it, so he is asking you to answer $$$q$$$ queries: what is the minimum number of moves required to make the desktop good after adding/removing one icon?Note that queries are permanent and change the state of the desktop.
Input Specification: The first line of the input contains three integers $$$n$$$, $$$m$$$ and $$$q$$$ ($$$1 \le n, m \le 1000; 1 \le q \le 2 \cdot 10^5$$$) — the number of rows in the desktop, the number of columns in the desktop and the number of queries, respectively. The next $$$n$$$ lines contain the description of the desktop. The $$$i$$$-th of them contains $$$m$$$ characters '.' and '*' — the description of the $$$i$$$-th row of the desktop. The next $$$q$$$ lines describe queries. The $$$i$$$-th of them contains two integers $$$x_i$$$ and $$$y_i$$$ ($$$1 \le x_i \le n; 1 \le y_i \le m$$$) — the position of the cell which changes its state (if this cell contained the icon before, then this icon is removed, otherwise an icon appears in this cell).
Output Specification: Print $$$q$$$ integers. The $$$i$$$-th of them should be the minimum number of moves required to make the desktop good after applying the first $$$i$$$ queries.
Code:
h, w, q = map(int, input().split())
p = [False] * (h * w)
c = cc = 0
def query(y, x):
global c, cc
i = x*h+y
p[i] = not p[i]
if p[i]:
if i < c:
cc += 1
c += 1
if p[c-1]:
cc += 1
else:
if i < c:
cc -= 1
c -= 1
if p[c]:
# TODO: Your code here
return c - cc
for y in range(h):
inp = input()
for x in range(w):
if inp[x] == '*':
query(y, x)
for _ in range(q):
x, y = map(int, input().split())
print(query(x-1, y-1))
|
h, w, q = map(int, input().split())
p = [False] * (h * w)
c = cc = 0
def query(y, x):
global c, cc
i = x*h+y
p[i] = not p[i]
if p[i]:
if i < c:
cc += 1
c += 1
if p[c-1]:
cc += 1
else:
if i < c:
cc -= 1
c -= 1
if p[c]:
{{completion}}
return c - cc
for y in range(h):
inp = input()
for x in range(w):
if inp[x] == '*':
query(y, x)
for _ in range(q):
x, y = map(int, input().split())
print(query(x-1, y-1))
|
cc -= 1
|
[{"input": "4 4 8\n..**\n.*..\n*...\n...*\n1 3\n2 3\n3 1\n2 3\n3 4\n4 3\n2 3\n2 2", "output": ["3\n4\n4\n3\n4\n5\n5\n5"]}, {"input": "2 5 5\n*...*\n*****\n1 3\n2 2\n1 3\n1 5\n2 3", "output": ["2\n3\n3\n3\n2"]}]
|
block_completion_007862
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: Your friend Ivan asked you to help him rearrange his desktop. The desktop can be represented as a rectangle matrix of size $$$n \times m$$$ consisting of characters '.' (empty cell of the desktop) and '*' (an icon).The desktop is called good if all its icons are occupying some prefix of full columns and, possibly, the prefix of the next column (and there are no icons outside this figure). In other words, some amount of first columns will be filled with icons and, possibly, some amount of first cells of the next (after the last full column) column will be also filled with icons (and all the icons on the desktop belong to this figure). This is pretty much the same as the real life icons arrangement.In one move, you can take one icon and move it to any empty cell in the desktop.Ivan loves to add some icons to his desktop and remove them from it, so he is asking you to answer $$$q$$$ queries: what is the minimum number of moves required to make the desktop good after adding/removing one icon?Note that queries are permanent and change the state of the desktop.
Input Specification: The first line of the input contains three integers $$$n$$$, $$$m$$$ and $$$q$$$ ($$$1 \le n, m \le 1000; 1 \le q \le 2 \cdot 10^5$$$) — the number of rows in the desktop, the number of columns in the desktop and the number of queries, respectively. The next $$$n$$$ lines contain the description of the desktop. The $$$i$$$-th of them contains $$$m$$$ characters '.' and '*' — the description of the $$$i$$$-th row of the desktop. The next $$$q$$$ lines describe queries. The $$$i$$$-th of them contains two integers $$$x_i$$$ and $$$y_i$$$ ($$$1 \le x_i \le n; 1 \le y_i \le m$$$) — the position of the cell which changes its state (if this cell contained the icon before, then this icon is removed, otherwise an icon appears in this cell).
Output Specification: Print $$$q$$$ integers. The $$$i$$$-th of them should be the minimum number of moves required to make the desktop good after applying the first $$$i$$$ queries.
Code:
from sys import stdin
rln=stdin.buffer.readline
rl=lambda:rln().rstrip(b'\r\n').rstrip(b'\n')
ri=lambda:int(rln())
rif=lambda:[*map(int,rln().split())]
rt=lambda:rl().decode()
rtf=lambda:rln().decode().split()
inf=float('inf')
dir4=[(-1,0),(0,1),(1,0),(0,-1)]
dir8=[(-1,-1),(0,-1),(1,-1),(-1,0),(1,0),(-1,1),(0,1),(1,1)]
YES,NO,Yes,No,yes,no='YES','NO','Yes','No','yes','no'
m,n,q=rif()
a=[0]*(m*n)
for y in range(m):
s=rt()
for x in range(n):
a[m*x+y]=s[x]=='*'
k=sum(a)
l=sum(a[:k])
for _ in range(q):
x,y=rif()
x,y=x-1,y-1
i=x+m*y
if a[i]:
k-=1
l-=a[k]
l-=i<k
a[i]^=1
else:
# TODO: Your code here
print(k-l)
|
from sys import stdin
rln=stdin.buffer.readline
rl=lambda:rln().rstrip(b'\r\n').rstrip(b'\n')
ri=lambda:int(rln())
rif=lambda:[*map(int,rln().split())]
rt=lambda:rl().decode()
rtf=lambda:rln().decode().split()
inf=float('inf')
dir4=[(-1,0),(0,1),(1,0),(0,-1)]
dir8=[(-1,-1),(0,-1),(1,-1),(-1,0),(1,0),(-1,1),(0,1),(1,1)]
YES,NO,Yes,No,yes,no='YES','NO','Yes','No','yes','no'
m,n,q=rif()
a=[0]*(m*n)
for y in range(m):
s=rt()
for x in range(n):
a[m*x+y]=s[x]=='*'
k=sum(a)
l=sum(a[:k])
for _ in range(q):
x,y=rif()
x,y=x-1,y-1
i=x+m*y
if a[i]:
k-=1
l-=a[k]
l-=i<k
a[i]^=1
else:
{{completion}}
print(k-l)
|
a[i]^=1
l+=i<k
l+=a[k]
k+=1
|
[{"input": "4 4 8\n..**\n.*..\n*...\n...*\n1 3\n2 3\n3 1\n2 3\n3 4\n4 3\n2 3\n2 2", "output": ["3\n4\n4\n3\n4\n5\n5\n5"]}, {"input": "2 5 5\n*...*\n*****\n1 3\n2 2\n1 3\n1 5\n2 3", "output": ["2\n3\n3\n3\n2"]}]
|
block_completion_007863
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: Your friend Ivan asked you to help him rearrange his desktop. The desktop can be represented as a rectangle matrix of size $$$n \times m$$$ consisting of characters '.' (empty cell of the desktop) and '*' (an icon).The desktop is called good if all its icons are occupying some prefix of full columns and, possibly, the prefix of the next column (and there are no icons outside this figure). In other words, some amount of first columns will be filled with icons and, possibly, some amount of first cells of the next (after the last full column) column will be also filled with icons (and all the icons on the desktop belong to this figure). This is pretty much the same as the real life icons arrangement.In one move, you can take one icon and move it to any empty cell in the desktop.Ivan loves to add some icons to his desktop and remove them from it, so he is asking you to answer $$$q$$$ queries: what is the minimum number of moves required to make the desktop good after adding/removing one icon?Note that queries are permanent and change the state of the desktop.
Input Specification: The first line of the input contains three integers $$$n$$$, $$$m$$$ and $$$q$$$ ($$$1 \le n, m \le 1000; 1 \le q \le 2 \cdot 10^5$$$) — the number of rows in the desktop, the number of columns in the desktop and the number of queries, respectively. The next $$$n$$$ lines contain the description of the desktop. The $$$i$$$-th of them contains $$$m$$$ characters '.' and '*' — the description of the $$$i$$$-th row of the desktop. The next $$$q$$$ lines describe queries. The $$$i$$$-th of them contains two integers $$$x_i$$$ and $$$y_i$$$ ($$$1 \le x_i \le n; 1 \le y_i \le m$$$) — the position of the cell which changes its state (if this cell contained the icon before, then this icon is removed, otherwise an icon appears in this cell).
Output Specification: Print $$$q$$$ integers. The $$$i$$$-th of them should be the minimum number of moves required to make the desktop good after applying the first $$$i$$$ queries.
Code:
import sys
n, m, k = map(int, sys.stdin.readline().split())
board = [list(sys.stdin.readline().strip()) for _ in range(n)]
cnt = 0
for i in range(n):
for j in range(m):
cnt += board[i][j] == '*'
clean = 0
q, r = divmod(cnt, n)
for j in range(q):
for i in range(n):
clean += board[i][j] == '*'
for i in range(r):
clean += board[i][q] == '*'
for _ in range(k):
x, y = map(int, sys.stdin.readline().split())
x -= 1
y -= 1
if board[x][y] == '.':
board[x][y] = '*'
cnt += 1
q, r = divmod(cnt - 1, n)
if board[r][q] == '*':
clean += 1
if n * y + x <= cnt - 1:
clean += 1
if (q, r) == (y, x):
clean -= 1
else:
cnt -= 1
q, r = divmod(cnt, n)
if board[r][q] == '*':
# TODO: Your code here
if n * y + x <= cnt - 1:
clean -= 1
board[x][y] = '.'
print(cnt - clean)
|
import sys
n, m, k = map(int, sys.stdin.readline().split())
board = [list(sys.stdin.readline().strip()) for _ in range(n)]
cnt = 0
for i in range(n):
for j in range(m):
cnt += board[i][j] == '*'
clean = 0
q, r = divmod(cnt, n)
for j in range(q):
for i in range(n):
clean += board[i][j] == '*'
for i in range(r):
clean += board[i][q] == '*'
for _ in range(k):
x, y = map(int, sys.stdin.readline().split())
x -= 1
y -= 1
if board[x][y] == '.':
board[x][y] = '*'
cnt += 1
q, r = divmod(cnt - 1, n)
if board[r][q] == '*':
clean += 1
if n * y + x <= cnt - 1:
clean += 1
if (q, r) == (y, x):
clean -= 1
else:
cnt -= 1
q, r = divmod(cnt, n)
if board[r][q] == '*':
{{completion}}
if n * y + x <= cnt - 1:
clean -= 1
board[x][y] = '.'
print(cnt - clean)
|
clean -= 1
|
[{"input": "4 4 8\n..**\n.*..\n*...\n...*\n1 3\n2 3\n3 1\n2 3\n3 4\n4 3\n2 3\n2 2", "output": ["3\n4\n4\n3\n4\n5\n5\n5"]}, {"input": "2 5 5\n*...*\n*****\n1 3\n2 2\n1 3\n1 5\n2 3", "output": ["2\n3\n3\n3\n2"]}]
|
block_completion_007864
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: Your friend Ivan asked you to help him rearrange his desktop. The desktop can be represented as a rectangle matrix of size $$$n \times m$$$ consisting of characters '.' (empty cell of the desktop) and '*' (an icon).The desktop is called good if all its icons are occupying some prefix of full columns and, possibly, the prefix of the next column (and there are no icons outside this figure). In other words, some amount of first columns will be filled with icons and, possibly, some amount of first cells of the next (after the last full column) column will be also filled with icons (and all the icons on the desktop belong to this figure). This is pretty much the same as the real life icons arrangement.In one move, you can take one icon and move it to any empty cell in the desktop.Ivan loves to add some icons to his desktop and remove them from it, so he is asking you to answer $$$q$$$ queries: what is the minimum number of moves required to make the desktop good after adding/removing one icon?Note that queries are permanent and change the state of the desktop.
Input Specification: The first line of the input contains three integers $$$n$$$, $$$m$$$ and $$$q$$$ ($$$1 \le n, m \le 1000; 1 \le q \le 2 \cdot 10^5$$$) — the number of rows in the desktop, the number of columns in the desktop and the number of queries, respectively. The next $$$n$$$ lines contain the description of the desktop. The $$$i$$$-th of them contains $$$m$$$ characters '.' and '*' — the description of the $$$i$$$-th row of the desktop. The next $$$q$$$ lines describe queries. The $$$i$$$-th of them contains two integers $$$x_i$$$ and $$$y_i$$$ ($$$1 \le x_i \le n; 1 \le y_i \le m$$$) — the position of the cell which changes its state (if this cell contained the icon before, then this icon is removed, otherwise an icon appears in this cell).
Output Specification: Print $$$q$$$ integers. The $$$i$$$-th of them should be the minimum number of moves required to make the desktop good after applying the first $$$i$$$ queries.
Code:
import sys
n, m, k = map(int, sys.stdin.readline().split())
board = [list(sys.stdin.readline().strip()) for _ in range(n)]
cnt = 0
for i in range(n):
for j in range(m):
cnt += board[i][j] == '*'
clean = 0
q, r = divmod(cnt, n)
for j in range(q):
for i in range(n):
clean += board[i][j] == '*'
for i in range(r):
clean += board[i][q] == '*'
for _ in range(k):
x, y = map(int, sys.stdin.readline().split())
x -= 1
y -= 1
if board[x][y] == '.':
board[x][y] = '*'
cnt += 1
q, r = divmod(cnt - 1, n)
if board[r][q] == '*':
clean += 1
if n * y + x <= cnt - 1:
clean += 1
if (q, r) == (y, x):
clean -= 1
else:
cnt -= 1
q, r = divmod(cnt, n)
if board[r][q] == '*':
clean -= 1
if n * y + x <= cnt - 1:
# TODO: Your code here
board[x][y] = '.'
print(cnt - clean)
|
import sys
n, m, k = map(int, sys.stdin.readline().split())
board = [list(sys.stdin.readline().strip()) for _ in range(n)]
cnt = 0
for i in range(n):
for j in range(m):
cnt += board[i][j] == '*'
clean = 0
q, r = divmod(cnt, n)
for j in range(q):
for i in range(n):
clean += board[i][j] == '*'
for i in range(r):
clean += board[i][q] == '*'
for _ in range(k):
x, y = map(int, sys.stdin.readline().split())
x -= 1
y -= 1
if board[x][y] == '.':
board[x][y] = '*'
cnt += 1
q, r = divmod(cnt - 1, n)
if board[r][q] == '*':
clean += 1
if n * y + x <= cnt - 1:
clean += 1
if (q, r) == (y, x):
clean -= 1
else:
cnt -= 1
q, r = divmod(cnt, n)
if board[r][q] == '*':
clean -= 1
if n * y + x <= cnt - 1:
{{completion}}
board[x][y] = '.'
print(cnt - clean)
|
clean -= 1
|
[{"input": "4 4 8\n..**\n.*..\n*...\n...*\n1 3\n2 3\n3 1\n2 3\n3 4\n4 3\n2 3\n2 2", "output": ["3\n4\n4\n3\n4\n5\n5\n5"]}, {"input": "2 5 5\n*...*\n*****\n1 3\n2 2\n1 3\n1 5\n2 3", "output": ["2\n3\n3\n3\n2"]}]
|
block_completion_007865
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: Your friend Ivan asked you to help him rearrange his desktop. The desktop can be represented as a rectangle matrix of size $$$n \times m$$$ consisting of characters '.' (empty cell of the desktop) and '*' (an icon).The desktop is called good if all its icons are occupying some prefix of full columns and, possibly, the prefix of the next column (and there are no icons outside this figure). In other words, some amount of first columns will be filled with icons and, possibly, some amount of first cells of the next (after the last full column) column will be also filled with icons (and all the icons on the desktop belong to this figure). This is pretty much the same as the real life icons arrangement.In one move, you can take one icon and move it to any empty cell in the desktop.Ivan loves to add some icons to his desktop and remove them from it, so he is asking you to answer $$$q$$$ queries: what is the minimum number of moves required to make the desktop good after adding/removing one icon?Note that queries are permanent and change the state of the desktop.
Input Specification: The first line of the input contains three integers $$$n$$$, $$$m$$$ and $$$q$$$ ($$$1 \le n, m \le 1000; 1 \le q \le 2 \cdot 10^5$$$) — the number of rows in the desktop, the number of columns in the desktop and the number of queries, respectively. The next $$$n$$$ lines contain the description of the desktop. The $$$i$$$-th of them contains $$$m$$$ characters '.' and '*' — the description of the $$$i$$$-th row of the desktop. The next $$$q$$$ lines describe queries. The $$$i$$$-th of them contains two integers $$$x_i$$$ and $$$y_i$$$ ($$$1 \le x_i \le n; 1 \le y_i \le m$$$) — the position of the cell which changes its state (if this cell contained the icon before, then this icon is removed, otherwise an icon appears in this cell).
Output Specification: Print $$$q$$$ integers. The $$$i$$$-th of them should be the minimum number of moves required to make the desktop good after applying the first $$$i$$$ queries.
Code:
n,m,q = map(int, input().split())
s = [input() for _ in range(n)]
s = [s[j][i] for i in range(m) for j in range(n)]
qrr = [list(map(int, input().split())) for _ in range(q)]
qrr = [n * (q[1] - 1) + q[0] - 1 for q in qrr]
count = s.count('*')
correct = s[:count].count('*')
for q in qrr:
count += 1 if s[q] == '.' else -1
if s[q] == '.':
correct += 1 if q < count else 0
correct += 1 if s[count-1] == '*' else 0
else:
# TODO: Your code here
print(count - correct)
s[q] = '.' if s[q] == '*' else '*'
|
n,m,q = map(int, input().split())
s = [input() for _ in range(n)]
s = [s[j][i] for i in range(m) for j in range(n)]
qrr = [list(map(int, input().split())) for _ in range(q)]
qrr = [n * (q[1] - 1) + q[0] - 1 for q in qrr]
count = s.count('*')
correct = s[:count].count('*')
for q in qrr:
count += 1 if s[q] == '.' else -1
if s[q] == '.':
correct += 1 if q < count else 0
correct += 1 if s[count-1] == '*' else 0
else:
{{completion}}
print(count - correct)
s[q] = '.' if s[q] == '*' else '*'
|
correct -= 1 if q < count else 0
correct -= 1 if s[count] == '*' else 0
|
[{"input": "4 4 8\n..**\n.*..\n*...\n...*\n1 3\n2 3\n3 1\n2 3\n3 4\n4 3\n2 3\n2 2", "output": ["3\n4\n4\n3\n4\n5\n5\n5"]}, {"input": "2 5 5\n*...*\n*****\n1 3\n2 2\n1 3\n1 5\n2 3", "output": ["2\n3\n3\n3\n2"]}]
|
block_completion_007866
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: Your friend Ivan asked you to help him rearrange his desktop. The desktop can be represented as a rectangle matrix of size $$$n \times m$$$ consisting of characters '.' (empty cell of the desktop) and '*' (an icon).The desktop is called good if all its icons are occupying some prefix of full columns and, possibly, the prefix of the next column (and there are no icons outside this figure). In other words, some amount of first columns will be filled with icons and, possibly, some amount of first cells of the next (after the last full column) column will be also filled with icons (and all the icons on the desktop belong to this figure). This is pretty much the same as the real life icons arrangement.In one move, you can take one icon and move it to any empty cell in the desktop.Ivan loves to add some icons to his desktop and remove them from it, so he is asking you to answer $$$q$$$ queries: what is the minimum number of moves required to make the desktop good after adding/removing one icon?Note that queries are permanent and change the state of the desktop.
Input Specification: The first line of the input contains three integers $$$n$$$, $$$m$$$ and $$$q$$$ ($$$1 \le n, m \le 1000; 1 \le q \le 2 \cdot 10^5$$$) — the number of rows in the desktop, the number of columns in the desktop and the number of queries, respectively. The next $$$n$$$ lines contain the description of the desktop. The $$$i$$$-th of them contains $$$m$$$ characters '.' and '*' — the description of the $$$i$$$-th row of the desktop. The next $$$q$$$ lines describe queries. The $$$i$$$-th of them contains two integers $$$x_i$$$ and $$$y_i$$$ ($$$1 \le x_i \le n; 1 \le y_i \le m$$$) — the position of the cell which changes its state (if this cell contained the icon before, then this icon is removed, otherwise an icon appears in this cell).
Output Specification: Print $$$q$$$ integers. The $$$i$$$-th of them should be the minimum number of moves required to make the desktop good after applying the first $$$i$$$ queries.
Code:
from itertools import chain
I=lambda:map(int,input().split())
n,m,q=I()
g0=[list(input()) for _ in range(n)]
g=list(chain.from_iterable(zip(*g0)))
tot=g.count('*')
inner=g[:tot].count('*')
for _ in range(q):
i,j=I()
p=(j-1)*n+i-1
if g[p]=='*':
tot-=1
#"tide fall"
if g[tot]=='*':inner-=1
if p<tot:inner-=1
g[p]='.'
else:
g[p]='*'
#"tide rise"
if g[tot]=='*':# TODO: Your code here
if p<tot:inner+=1
tot+=1
print(tot-inner)
|
from itertools import chain
I=lambda:map(int,input().split())
n,m,q=I()
g0=[list(input()) for _ in range(n)]
g=list(chain.from_iterable(zip(*g0)))
tot=g.count('*')
inner=g[:tot].count('*')
for _ in range(q):
i,j=I()
p=(j-1)*n+i-1
if g[p]=='*':
tot-=1
#"tide fall"
if g[tot]=='*':inner-=1
if p<tot:inner-=1
g[p]='.'
else:
g[p]='*'
#"tide rise"
if g[tot]=='*':{{completion}}
if p<tot:inner+=1
tot+=1
print(tot-inner)
|
inner+=1
|
[{"input": "4 4 8\n..**\n.*..\n*...\n...*\n1 3\n2 3\n3 1\n2 3\n3 4\n4 3\n2 3\n2 2", "output": ["3\n4\n4\n3\n4\n5\n5\n5"]}, {"input": "2 5 5\n*...*\n*****\n1 3\n2 2\n1 3\n1 5\n2 3", "output": ["2\n3\n3\n3\n2"]}]
|
block_completion_007867
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: Your friend Ivan asked you to help him rearrange his desktop. The desktop can be represented as a rectangle matrix of size $$$n \times m$$$ consisting of characters '.' (empty cell of the desktop) and '*' (an icon).The desktop is called good if all its icons are occupying some prefix of full columns and, possibly, the prefix of the next column (and there are no icons outside this figure). In other words, some amount of first columns will be filled with icons and, possibly, some amount of first cells of the next (after the last full column) column will be also filled with icons (and all the icons on the desktop belong to this figure). This is pretty much the same as the real life icons arrangement.In one move, you can take one icon and move it to any empty cell in the desktop.Ivan loves to add some icons to his desktop and remove them from it, so he is asking you to answer $$$q$$$ queries: what is the minimum number of moves required to make the desktop good after adding/removing one icon?Note that queries are permanent and change the state of the desktop.
Input Specification: The first line of the input contains three integers $$$n$$$, $$$m$$$ and $$$q$$$ ($$$1 \le n, m \le 1000; 1 \le q \le 2 \cdot 10^5$$$) — the number of rows in the desktop, the number of columns in the desktop and the number of queries, respectively. The next $$$n$$$ lines contain the description of the desktop. The $$$i$$$-th of them contains $$$m$$$ characters '.' and '*' — the description of the $$$i$$$-th row of the desktop. The next $$$q$$$ lines describe queries. The $$$i$$$-th of them contains two integers $$$x_i$$$ and $$$y_i$$$ ($$$1 \le x_i \le n; 1 \le y_i \le m$$$) — the position of the cell which changes its state (if this cell contained the icon before, then this icon is removed, otherwise an icon appears in this cell).
Output Specification: Print $$$q$$$ integers. The $$$i$$$-th of them should be the minimum number of moves required to make the desktop good after applying the first $$$i$$$ queries.
Code:
from itertools import chain
I=lambda:map(int,input().split())
n,m,q=I()
g0=[list(input()) for _ in range(n)]
g=list(chain.from_iterable(zip(*g0)))
tot=g.count('*')
inner=g[:tot].count('*')
for _ in range(q):
i,j=I()
p=(j-1)*n+i-1
if g[p]=='*':
tot-=1
#"tide fall"
if g[tot]=='*':inner-=1
if p<tot:inner-=1
g[p]='.'
else:
g[p]='*'
#"tide rise"
if g[tot]=='*':inner+=1
if p<tot:# TODO: Your code here
tot+=1
print(tot-inner)
|
from itertools import chain
I=lambda:map(int,input().split())
n,m,q=I()
g0=[list(input()) for _ in range(n)]
g=list(chain.from_iterable(zip(*g0)))
tot=g.count('*')
inner=g[:tot].count('*')
for _ in range(q):
i,j=I()
p=(j-1)*n+i-1
if g[p]=='*':
tot-=1
#"tide fall"
if g[tot]=='*':inner-=1
if p<tot:inner-=1
g[p]='.'
else:
g[p]='*'
#"tide rise"
if g[tot]=='*':inner+=1
if p<tot:{{completion}}
tot+=1
print(tot-inner)
|
inner+=1
|
[{"input": "4 4 8\n..**\n.*..\n*...\n...*\n1 3\n2 3\n3 1\n2 3\n3 4\n4 3\n2 3\n2 2", "output": ["3\n4\n4\n3\n4\n5\n5\n5"]}, {"input": "2 5 5\n*...*\n*****\n1 3\n2 2\n1 3\n1 5\n2 3", "output": ["2\n3\n3\n3\n2"]}]
|
block_completion_007868
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: Your friend Ivan asked you to help him rearrange his desktop. The desktop can be represented as a rectangle matrix of size $$$n \times m$$$ consisting of characters '.' (empty cell of the desktop) and '*' (an icon).The desktop is called good if all its icons are occupying some prefix of full columns and, possibly, the prefix of the next column (and there are no icons outside this figure). In other words, some amount of first columns will be filled with icons and, possibly, some amount of first cells of the next (after the last full column) column will be also filled with icons (and all the icons on the desktop belong to this figure). This is pretty much the same as the real life icons arrangement.In one move, you can take one icon and move it to any empty cell in the desktop.Ivan loves to add some icons to his desktop and remove them from it, so he is asking you to answer $$$q$$$ queries: what is the minimum number of moves required to make the desktop good after adding/removing one icon?Note that queries are permanent and change the state of the desktop.
Input Specification: The first line of the input contains three integers $$$n$$$, $$$m$$$ and $$$q$$$ ($$$1 \le n, m \le 1000; 1 \le q \le 2 \cdot 10^5$$$) — the number of rows in the desktop, the number of columns in the desktop and the number of queries, respectively. The next $$$n$$$ lines contain the description of the desktop. The $$$i$$$-th of them contains $$$m$$$ characters '.' and '*' — the description of the $$$i$$$-th row of the desktop. The next $$$q$$$ lines describe queries. The $$$i$$$-th of them contains two integers $$$x_i$$$ and $$$y_i$$$ ($$$1 \le x_i \le n; 1 \le y_i \le m$$$) — the position of the cell which changes its state (if this cell contained the icon before, then this icon is removed, otherwise an icon appears in this cell).
Output Specification: Print $$$q$$$ integers. The $$$i$$$-th of them should be the minimum number of moves required to make the desktop good after applying the first $$$i$$$ queries.
Code:
n,m,q=map(int,input().split())
z=[] # 2d
a=[] # 1d
c=0 # count icons
ans=0
for i in range(n):
z.append(list(input()))
for i in range(m):
for j in range(n):
if z[j][i]=="*":
a.append(1)
c+=1
else:
a.append(0)
ans=c
for i in range(c):
if a[i]==1:
ans-=1
for i in range(q):
x,y=map(int,input().split())
if a[n*(y-1)+x-1]==1:
a[n*(y-1)+x-1]=0
c-=1
if n*(y-1)+x-1 > c:
ans-=1
if a[c]==1:
ans+=1
elif a[n*(y-1)+x-1]==0: # xor
a[n*(y-1)+x-1]=1
c+=1
if n*(y-1)+x-1 >= c-1: # c or c-1?
ans+=1
if c: # if c>0
if a[c-1]==1:
# TODO: Your code here
print(ans)
|
n,m,q=map(int,input().split())
z=[] # 2d
a=[] # 1d
c=0 # count icons
ans=0
for i in range(n):
z.append(list(input()))
for i in range(m):
for j in range(n):
if z[j][i]=="*":
a.append(1)
c+=1
else:
a.append(0)
ans=c
for i in range(c):
if a[i]==1:
ans-=1
for i in range(q):
x,y=map(int,input().split())
if a[n*(y-1)+x-1]==1:
a[n*(y-1)+x-1]=0
c-=1
if n*(y-1)+x-1 > c:
ans-=1
if a[c]==1:
ans+=1
elif a[n*(y-1)+x-1]==0: # xor
a[n*(y-1)+x-1]=1
c+=1
if n*(y-1)+x-1 >= c-1: # c or c-1?
ans+=1
if c: # if c>0
if a[c-1]==1:
{{completion}}
print(ans)
|
ans-=1
|
[{"input": "4 4 8\n..**\n.*..\n*...\n...*\n1 3\n2 3\n3 1\n2 3\n3 4\n4 3\n2 3\n2 2", "output": ["3\n4\n4\n3\n4\n5\n5\n5"]}, {"input": "2 5 5\n*...*\n*****\n1 3\n2 2\n1 3\n1 5\n2 3", "output": ["2\n3\n3\n3\n2"]}]
|
block_completion_007869
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: Your friend Ivan asked you to help him rearrange his desktop. The desktop can be represented as a rectangle matrix of size $$$n \times m$$$ consisting of characters '.' (empty cell of the desktop) and '*' (an icon).The desktop is called good if all its icons are occupying some prefix of full columns and, possibly, the prefix of the next column (and there are no icons outside this figure). In other words, some amount of first columns will be filled with icons and, possibly, some amount of first cells of the next (after the last full column) column will be also filled with icons (and all the icons on the desktop belong to this figure). This is pretty much the same as the real life icons arrangement.In one move, you can take one icon and move it to any empty cell in the desktop.Ivan loves to add some icons to his desktop and remove them from it, so he is asking you to answer $$$q$$$ queries: what is the minimum number of moves required to make the desktop good after adding/removing one icon?Note that queries are permanent and change the state of the desktop.
Input Specification: The first line of the input contains three integers $$$n$$$, $$$m$$$ and $$$q$$$ ($$$1 \le n, m \le 1000; 1 \le q \le 2 \cdot 10^5$$$) — the number of rows in the desktop, the number of columns in the desktop and the number of queries, respectively. The next $$$n$$$ lines contain the description of the desktop. The $$$i$$$-th of them contains $$$m$$$ characters '.' and '*' — the description of the $$$i$$$-th row of the desktop. The next $$$q$$$ lines describe queries. The $$$i$$$-th of them contains two integers $$$x_i$$$ and $$$y_i$$$ ($$$1 \le x_i \le n; 1 \le y_i \le m$$$) — the position of the cell which changes its state (if this cell contained the icon before, then this icon is removed, otherwise an icon appears in this cell).
Output Specification: Print $$$q$$$ integers. The $$$i$$$-th of them should be the minimum number of moves required to make the desktop good after applying the first $$$i$$$ queries.
Code:
import sys
def solve():
# n = int(sys.stdin.readline().strip())
n, m, q = [int(x) for x in sys.stdin.readline().strip().split()]
a = []
m = [0] * (m * n)
for y in range(n):
s = sys.stdin.readline().strip()
for x, c in enumerate(s):
if c == '*':
a.append(x * n + y)
m[x * n + y] = 1
cnt = len(a)
correct = sum(1 for x in a if x < cnt)
for _ in range(q):
y, x = [int(p) for p in sys.stdin.readline().strip().split()]
y -= 1
x -= 1
z = x * n + y
if m[z] == 0:
if m[cnt] == 1:
correct += 1
m[z] = 1
cnt += 1
if z < cnt:
correct += 1
else:
cnt -= 1
if m[cnt] == 1:
# TODO: Your code here
m[z] = 0
if z < cnt:
correct -= 1
# print(f"cnt={cnt} cor={correct}")
print(cnt - correct)
# t = int(sys.stdin.readline().strip())
t = 1
for _ in range(t):
solve()
|
import sys
def solve():
# n = int(sys.stdin.readline().strip())
n, m, q = [int(x) for x in sys.stdin.readline().strip().split()]
a = []
m = [0] * (m * n)
for y in range(n):
s = sys.stdin.readline().strip()
for x, c in enumerate(s):
if c == '*':
a.append(x * n + y)
m[x * n + y] = 1
cnt = len(a)
correct = sum(1 for x in a if x < cnt)
for _ in range(q):
y, x = [int(p) for p in sys.stdin.readline().strip().split()]
y -= 1
x -= 1
z = x * n + y
if m[z] == 0:
if m[cnt] == 1:
correct += 1
m[z] = 1
cnt += 1
if z < cnt:
correct += 1
else:
cnt -= 1
if m[cnt] == 1:
{{completion}}
m[z] = 0
if z < cnt:
correct -= 1
# print(f"cnt={cnt} cor={correct}")
print(cnt - correct)
# t = int(sys.stdin.readline().strip())
t = 1
for _ in range(t):
solve()
|
correct -= 1
|
[{"input": "4 4 8\n..**\n.*..\n*...\n...*\n1 3\n2 3\n3 1\n2 3\n3 4\n4 3\n2 3\n2 2", "output": ["3\n4\n4\n3\n4\n5\n5\n5"]}, {"input": "2 5 5\n*...*\n*****\n1 3\n2 2\n1 3\n1 5\n2 3", "output": ["2\n3\n3\n3\n2"]}]
|
block_completion_007870
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: Your friend Ivan asked you to help him rearrange his desktop. The desktop can be represented as a rectangle matrix of size $$$n \times m$$$ consisting of characters '.' (empty cell of the desktop) and '*' (an icon).The desktop is called good if all its icons are occupying some prefix of full columns and, possibly, the prefix of the next column (and there are no icons outside this figure). In other words, some amount of first columns will be filled with icons and, possibly, some amount of first cells of the next (after the last full column) column will be also filled with icons (and all the icons on the desktop belong to this figure). This is pretty much the same as the real life icons arrangement.In one move, you can take one icon and move it to any empty cell in the desktop.Ivan loves to add some icons to his desktop and remove them from it, so he is asking you to answer $$$q$$$ queries: what is the minimum number of moves required to make the desktop good after adding/removing one icon?Note that queries are permanent and change the state of the desktop.
Input Specification: The first line of the input contains three integers $$$n$$$, $$$m$$$ and $$$q$$$ ($$$1 \le n, m \le 1000; 1 \le q \le 2 \cdot 10^5$$$) — the number of rows in the desktop, the number of columns in the desktop and the number of queries, respectively. The next $$$n$$$ lines contain the description of the desktop. The $$$i$$$-th of them contains $$$m$$$ characters '.' and '*' — the description of the $$$i$$$-th row of the desktop. The next $$$q$$$ lines describe queries. The $$$i$$$-th of them contains two integers $$$x_i$$$ and $$$y_i$$$ ($$$1 \le x_i \le n; 1 \le y_i \le m$$$) — the position of the cell which changes its state (if this cell contained the icon before, then this icon is removed, otherwise an icon appears in this cell).
Output Specification: Print $$$q$$$ integers. The $$$i$$$-th of them should be the minimum number of moves required to make the desktop good after applying the first $$$i$$$ queries.
Code:
import sys
def solve():
# n = int(sys.stdin.readline().strip())
n, m, q = [int(x) for x in sys.stdin.readline().strip().split()]
a = []
m = [0] * (m * n)
for y in range(n):
s = sys.stdin.readline().strip()
for x, c in enumerate(s):
if c == '*':
a.append(x * n + y)
m[x * n + y] = 1
cnt = len(a)
correct = sum(1 for x in a if x < cnt)
for _ in range(q):
y, x = [int(p) for p in sys.stdin.readline().strip().split()]
y -= 1
x -= 1
z = x * n + y
if m[z] == 0:
if m[cnt] == 1:
correct += 1
m[z] = 1
cnt += 1
if z < cnt:
correct += 1
else:
cnt -= 1
if m[cnt] == 1:
correct -= 1
m[z] = 0
if z < cnt:
# TODO: Your code here
# print(f"cnt={cnt} cor={correct}")
print(cnt - correct)
# t = int(sys.stdin.readline().strip())
t = 1
for _ in range(t):
solve()
|
import sys
def solve():
# n = int(sys.stdin.readline().strip())
n, m, q = [int(x) for x in sys.stdin.readline().strip().split()]
a = []
m = [0] * (m * n)
for y in range(n):
s = sys.stdin.readline().strip()
for x, c in enumerate(s):
if c == '*':
a.append(x * n + y)
m[x * n + y] = 1
cnt = len(a)
correct = sum(1 for x in a if x < cnt)
for _ in range(q):
y, x = [int(p) for p in sys.stdin.readline().strip().split()]
y -= 1
x -= 1
z = x * n + y
if m[z] == 0:
if m[cnt] == 1:
correct += 1
m[z] = 1
cnt += 1
if z < cnt:
correct += 1
else:
cnt -= 1
if m[cnt] == 1:
correct -= 1
m[z] = 0
if z < cnt:
{{completion}}
# print(f"cnt={cnt} cor={correct}")
print(cnt - correct)
# t = int(sys.stdin.readline().strip())
t = 1
for _ in range(t):
solve()
|
correct -= 1
|
[{"input": "4 4 8\n..**\n.*..\n*...\n...*\n1 3\n2 3\n3 1\n2 3\n3 4\n4 3\n2 3\n2 2", "output": ["3\n4\n4\n3\n4\n5\n5\n5"]}, {"input": "2 5 5\n*...*\n*****\n1 3\n2 2\n1 3\n1 5\n2 3", "output": ["2\n3\n3\n3\n2"]}]
|
block_completion_007871
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given a directed acyclic graph, consisting of $$$n$$$ vertices and $$$m$$$ edges. The vertices are numbered from $$$1$$$ to $$$n$$$. There are no multiple edges and self-loops.Let $$$\mathit{in}_v$$$ be the number of incoming edges (indegree) and $$$\mathit{out}_v$$$ be the number of outgoing edges (outdegree) of vertex $$$v$$$.You are asked to remove some edges from the graph. Let the new degrees be $$$\mathit{in'}_v$$$ and $$$\mathit{out'}_v$$$.You are only allowed to remove the edges if the following conditions hold for every vertex $$$v$$$: $$$\mathit{in'}_v < \mathit{in}_v$$$ or $$$\mathit{in'}_v = \mathit{in}_v = 0$$$; $$$\mathit{out'}_v < \mathit{out}_v$$$ or $$$\mathit{out'}_v = \mathit{out}_v = 0$$$. Let's call a set of vertices $$$S$$$ cute if for each pair of vertices $$$v$$$ and $$$u$$$ ($$$v \neq u$$$) such that $$$v \in S$$$ and $$$u \in S$$$, there exists a path either from $$$v$$$ to $$$u$$$ or from $$$u$$$ to $$$v$$$ over the non-removed edges.What is the maximum possible size of a cute set $$$S$$$ after you remove some edges from the graph and both indegrees and outdegrees of all vertices either decrease or remain equal to $$$0$$$?
Input Specification: The first line contains two integers $$$n$$$ and $$$m$$$ ($$$1 \le n \le 2 \cdot 10^5$$$; $$$0 \le m \le 2 \cdot 10^5$$$) — the number of vertices and the number of edges of the graph. Each of the next $$$m$$$ lines contains two integers $$$v$$$ and $$$u$$$ ($$$1 \le v, u \le n$$$; $$$v \neq u$$$) — the description of an edge. The given edges form a valid directed acyclic graph. There are no multiple edges.
Output Specification: Print a single integer — the maximum possible size of a cute set $$$S$$$ after you remove some edges from the graph and both indegrees and outdegrees of all vertices either decrease or remain equal to $$$0$$$.
Notes: NoteIn the first example, you can remove edges $$$(1, 2)$$$ and $$$(2, 3)$$$. $$$\mathit{in} = [0, 1, 2]$$$, $$$\mathit{out} = [2, 1, 0]$$$. $$$\mathit{in'} = [0, 0, 1]$$$, $$$\mathit{out'} = [1, 0, 0]$$$. You can see that for all $$$v$$$ the conditions hold. The maximum cute set $$$S$$$ is formed by vertices $$$1$$$ and $$$3$$$. They are still connected directly by an edge, so there is a path between them.In the second example, there are no edges. Since all $$$\mathit{in}_v$$$ and $$$\mathit{out}_v$$$ are equal to $$$0$$$, leaving a graph with zero edges is allowed. There are $$$5$$$ cute sets, each contains a single vertex. Thus, the maximum size is $$$1$$$.In the third example, you can remove edges $$$(7, 1)$$$, $$$(2, 4)$$$, $$$(1, 3)$$$ and $$$(6, 2)$$$. The maximum cute set will be $$$S = \{7, 3, 2\}$$$. You can remove edge $$$(7, 3)$$$ as well, and the answer won't change.Here is the picture of the graph from the third example:
Code:
from collections import deque
n,m=[int(x) for x in input().split()]
g=[[] for _ in range(n)]
indeg=[0]*n
outdeg=[0]*n
tpdeg=[0]*n
for _ in range(m):
v,u=[int(x) for x in input().split()]
v-=1
u-=1
g[v].append(u)
outdeg[v]+=1
indeg[u]+=1
tpdeg[u]+=1
q=deque(i for i in range(n) if indeg[i]==0)
f=[1]*n
while q:
u=q.popleft()
for v in g[u]:
if indeg[v]>1 and outdeg[u]>1:
# TODO: Your code here
tpdeg[v] -= 1
if tpdeg[v]==0:
q.append(v)
print(max(f))
|
from collections import deque
n,m=[int(x) for x in input().split()]
g=[[] for _ in range(n)]
indeg=[0]*n
outdeg=[0]*n
tpdeg=[0]*n
for _ in range(m):
v,u=[int(x) for x in input().split()]
v-=1
u-=1
g[v].append(u)
outdeg[v]+=1
indeg[u]+=1
tpdeg[u]+=1
q=deque(i for i in range(n) if indeg[i]==0)
f=[1]*n
while q:
u=q.popleft()
for v in g[u]:
if indeg[v]>1 and outdeg[u]>1:
{{completion}}
tpdeg[v] -= 1
if tpdeg[v]==0:
q.append(v)
print(max(f))
|
f[v]=max(f[v],f[u]+1)
|
[{"input": "3 3\n1 2\n2 3\n1 3", "output": ["2"]}, {"input": "5 0", "output": ["1"]}, {"input": "7 8\n7 1\n1 3\n6 2\n2 3\n7 2\n2 4\n7 3\n6 3", "output": ["3"]}]
|
block_completion_007888
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given a directed acyclic graph, consisting of $$$n$$$ vertices and $$$m$$$ edges. The vertices are numbered from $$$1$$$ to $$$n$$$. There are no multiple edges and self-loops.Let $$$\mathit{in}_v$$$ be the number of incoming edges (indegree) and $$$\mathit{out}_v$$$ be the number of outgoing edges (outdegree) of vertex $$$v$$$.You are asked to remove some edges from the graph. Let the new degrees be $$$\mathit{in'}_v$$$ and $$$\mathit{out'}_v$$$.You are only allowed to remove the edges if the following conditions hold for every vertex $$$v$$$: $$$\mathit{in'}_v < \mathit{in}_v$$$ or $$$\mathit{in'}_v = \mathit{in}_v = 0$$$; $$$\mathit{out'}_v < \mathit{out}_v$$$ or $$$\mathit{out'}_v = \mathit{out}_v = 0$$$. Let's call a set of vertices $$$S$$$ cute if for each pair of vertices $$$v$$$ and $$$u$$$ ($$$v \neq u$$$) such that $$$v \in S$$$ and $$$u \in S$$$, there exists a path either from $$$v$$$ to $$$u$$$ or from $$$u$$$ to $$$v$$$ over the non-removed edges.What is the maximum possible size of a cute set $$$S$$$ after you remove some edges from the graph and both indegrees and outdegrees of all vertices either decrease or remain equal to $$$0$$$?
Input Specification: The first line contains two integers $$$n$$$ and $$$m$$$ ($$$1 \le n \le 2 \cdot 10^5$$$; $$$0 \le m \le 2 \cdot 10^5$$$) — the number of vertices and the number of edges of the graph. Each of the next $$$m$$$ lines contains two integers $$$v$$$ and $$$u$$$ ($$$1 \le v, u \le n$$$; $$$v \neq u$$$) — the description of an edge. The given edges form a valid directed acyclic graph. There are no multiple edges.
Output Specification: Print a single integer — the maximum possible size of a cute set $$$S$$$ after you remove some edges from the graph and both indegrees and outdegrees of all vertices either decrease or remain equal to $$$0$$$.
Notes: NoteIn the first example, you can remove edges $$$(1, 2)$$$ and $$$(2, 3)$$$. $$$\mathit{in} = [0, 1, 2]$$$, $$$\mathit{out} = [2, 1, 0]$$$. $$$\mathit{in'} = [0, 0, 1]$$$, $$$\mathit{out'} = [1, 0, 0]$$$. You can see that for all $$$v$$$ the conditions hold. The maximum cute set $$$S$$$ is formed by vertices $$$1$$$ and $$$3$$$. They are still connected directly by an edge, so there is a path between them.In the second example, there are no edges. Since all $$$\mathit{in}_v$$$ and $$$\mathit{out}_v$$$ are equal to $$$0$$$, leaving a graph with zero edges is allowed. There are $$$5$$$ cute sets, each contains a single vertex. Thus, the maximum size is $$$1$$$.In the third example, you can remove edges $$$(7, 1)$$$, $$$(2, 4)$$$, $$$(1, 3)$$$ and $$$(6, 2)$$$. The maximum cute set will be $$$S = \{7, 3, 2\}$$$. You can remove edge $$$(7, 3)$$$ as well, and the answer won't change.Here is the picture of the graph from the third example:
Code:
from collections import deque
n,m=[int(x) for x in input().split()]
g=[[] for _ in range(n)]
indeg=[0]*n
outdeg=[0]*n
tpdeg=[0]*n
for _ in range(m):
v,u=[int(x) for x in input().split()]
v-=1
u-=1
g[v].append(u)
outdeg[v]+=1
indeg[u]+=1
tpdeg[u]+=1
q=deque(i for i in range(n) if indeg[i]==0)
f=[1]*n
while q:
u=q.popleft()
for v in g[u]:
if indeg[v]>1 and outdeg[u]>1:
f[v]=max(f[v],f[u]+1)
tpdeg[v] -= 1
if tpdeg[v]==0:
# TODO: Your code here
print(max(f))
|
from collections import deque
n,m=[int(x) for x in input().split()]
g=[[] for _ in range(n)]
indeg=[0]*n
outdeg=[0]*n
tpdeg=[0]*n
for _ in range(m):
v,u=[int(x) for x in input().split()]
v-=1
u-=1
g[v].append(u)
outdeg[v]+=1
indeg[u]+=1
tpdeg[u]+=1
q=deque(i for i in range(n) if indeg[i]==0)
f=[1]*n
while q:
u=q.popleft()
for v in g[u]:
if indeg[v]>1 and outdeg[u]>1:
f[v]=max(f[v],f[u]+1)
tpdeg[v] -= 1
if tpdeg[v]==0:
{{completion}}
print(max(f))
|
q.append(v)
|
[{"input": "3 3\n1 2\n2 3\n1 3", "output": ["2"]}, {"input": "5 0", "output": ["1"]}, {"input": "7 8\n7 1\n1 3\n6 2\n2 3\n7 2\n2 4\n7 3\n6 3", "output": ["3"]}]
|
block_completion_007889
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given a directed acyclic graph, consisting of $$$n$$$ vertices and $$$m$$$ edges. The vertices are numbered from $$$1$$$ to $$$n$$$. There are no multiple edges and self-loops.Let $$$\mathit{in}_v$$$ be the number of incoming edges (indegree) and $$$\mathit{out}_v$$$ be the number of outgoing edges (outdegree) of vertex $$$v$$$.You are asked to remove some edges from the graph. Let the new degrees be $$$\mathit{in'}_v$$$ and $$$\mathit{out'}_v$$$.You are only allowed to remove the edges if the following conditions hold for every vertex $$$v$$$: $$$\mathit{in'}_v < \mathit{in}_v$$$ or $$$\mathit{in'}_v = \mathit{in}_v = 0$$$; $$$\mathit{out'}_v < \mathit{out}_v$$$ or $$$\mathit{out'}_v = \mathit{out}_v = 0$$$. Let's call a set of vertices $$$S$$$ cute if for each pair of vertices $$$v$$$ and $$$u$$$ ($$$v \neq u$$$) such that $$$v \in S$$$ and $$$u \in S$$$, there exists a path either from $$$v$$$ to $$$u$$$ or from $$$u$$$ to $$$v$$$ over the non-removed edges.What is the maximum possible size of a cute set $$$S$$$ after you remove some edges from the graph and both indegrees and outdegrees of all vertices either decrease or remain equal to $$$0$$$?
Input Specification: The first line contains two integers $$$n$$$ and $$$m$$$ ($$$1 \le n \le 2 \cdot 10^5$$$; $$$0 \le m \le 2 \cdot 10^5$$$) — the number of vertices and the number of edges of the graph. Each of the next $$$m$$$ lines contains two integers $$$v$$$ and $$$u$$$ ($$$1 \le v, u \le n$$$; $$$v \neq u$$$) — the description of an edge. The given edges form a valid directed acyclic graph. There are no multiple edges.
Output Specification: Print a single integer — the maximum possible size of a cute set $$$S$$$ after you remove some edges from the graph and both indegrees and outdegrees of all vertices either decrease or remain equal to $$$0$$$.
Notes: NoteIn the first example, you can remove edges $$$(1, 2)$$$ and $$$(2, 3)$$$. $$$\mathit{in} = [0, 1, 2]$$$, $$$\mathit{out} = [2, 1, 0]$$$. $$$\mathit{in'} = [0, 0, 1]$$$, $$$\mathit{out'} = [1, 0, 0]$$$. You can see that for all $$$v$$$ the conditions hold. The maximum cute set $$$S$$$ is formed by vertices $$$1$$$ and $$$3$$$. They are still connected directly by an edge, so there is a path between them.In the second example, there are no edges. Since all $$$\mathit{in}_v$$$ and $$$\mathit{out}_v$$$ are equal to $$$0$$$, leaving a graph with zero edges is allowed. There are $$$5$$$ cute sets, each contains a single vertex. Thus, the maximum size is $$$1$$$.In the third example, you can remove edges $$$(7, 1)$$$, $$$(2, 4)$$$, $$$(1, 3)$$$ and $$$(6, 2)$$$. The maximum cute set will be $$$S = \{7, 3, 2\}$$$. You can remove edge $$$(7, 3)$$$ as well, and the answer won't change.Here is the picture of the graph from the third example:
Code:
def iint():
return int(input().strip())
def iints():
return map(int, input().strip().split(" "))
def arr():
return list(input().strip().split(" "))
def arri():
return list(iints())
n,m = iints()
class Graph:
def __init__(self, n):
self.adj = [[] for _ in range(n)]
self.ins = [0 for _ in range(n)]
self.outs = [0 for _ in range(n)]
def add(self, a, b):
self.adj[a].append(b)
self.ins[b]+=1
self.outs[a]+=1
g = Graph(n)
ins2 = [0 for _ in range(n)]
for _ in range(m):
a,b = iints()
a-=1
b-=1
g.add(a,b)
ins2[b]+=1
order = [0 for _ in range(n)]
f = 0
b = 0
for i in range(n):
if not ins2[i]:
order[b] = i
b+=1
dp = [1 for _ in range(n)]
ans = 0
while f < n:
cur = order[f]
f += 1
for x in g.adj[cur]:
ins2[x] -= 1
if not ins2[x]:
# TODO: Your code here
if g.ins[x] > 1 and g.outs[cur] > 1:
dp[x] = max(dp[x], 1 + dp[cur])
ans = max(ans, dp[cur])
print(ans)
|
def iint():
return int(input().strip())
def iints():
return map(int, input().strip().split(" "))
def arr():
return list(input().strip().split(" "))
def arri():
return list(iints())
n,m = iints()
class Graph:
def __init__(self, n):
self.adj = [[] for _ in range(n)]
self.ins = [0 for _ in range(n)]
self.outs = [0 for _ in range(n)]
def add(self, a, b):
self.adj[a].append(b)
self.ins[b]+=1
self.outs[a]+=1
g = Graph(n)
ins2 = [0 for _ in range(n)]
for _ in range(m):
a,b = iints()
a-=1
b-=1
g.add(a,b)
ins2[b]+=1
order = [0 for _ in range(n)]
f = 0
b = 0
for i in range(n):
if not ins2[i]:
order[b] = i
b+=1
dp = [1 for _ in range(n)]
ans = 0
while f < n:
cur = order[f]
f += 1
for x in g.adj[cur]:
ins2[x] -= 1
if not ins2[x]:
{{completion}}
if g.ins[x] > 1 and g.outs[cur] > 1:
dp[x] = max(dp[x], 1 + dp[cur])
ans = max(ans, dp[cur])
print(ans)
|
order[b] = x
b += 1
|
[{"input": "3 3\n1 2\n2 3\n1 3", "output": ["2"]}, {"input": "5 0", "output": ["1"]}, {"input": "7 8\n7 1\n1 3\n6 2\n2 3\n7 2\n2 4\n7 3\n6 3", "output": ["3"]}]
|
block_completion_007890
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given a directed acyclic graph, consisting of $$$n$$$ vertices and $$$m$$$ edges. The vertices are numbered from $$$1$$$ to $$$n$$$. There are no multiple edges and self-loops.Let $$$\mathit{in}_v$$$ be the number of incoming edges (indegree) and $$$\mathit{out}_v$$$ be the number of outgoing edges (outdegree) of vertex $$$v$$$.You are asked to remove some edges from the graph. Let the new degrees be $$$\mathit{in'}_v$$$ and $$$\mathit{out'}_v$$$.You are only allowed to remove the edges if the following conditions hold for every vertex $$$v$$$: $$$\mathit{in'}_v < \mathit{in}_v$$$ or $$$\mathit{in'}_v = \mathit{in}_v = 0$$$; $$$\mathit{out'}_v < \mathit{out}_v$$$ or $$$\mathit{out'}_v = \mathit{out}_v = 0$$$. Let's call a set of vertices $$$S$$$ cute if for each pair of vertices $$$v$$$ and $$$u$$$ ($$$v \neq u$$$) such that $$$v \in S$$$ and $$$u \in S$$$, there exists a path either from $$$v$$$ to $$$u$$$ or from $$$u$$$ to $$$v$$$ over the non-removed edges.What is the maximum possible size of a cute set $$$S$$$ after you remove some edges from the graph and both indegrees and outdegrees of all vertices either decrease or remain equal to $$$0$$$?
Input Specification: The first line contains two integers $$$n$$$ and $$$m$$$ ($$$1 \le n \le 2 \cdot 10^5$$$; $$$0 \le m \le 2 \cdot 10^5$$$) — the number of vertices and the number of edges of the graph. Each of the next $$$m$$$ lines contains two integers $$$v$$$ and $$$u$$$ ($$$1 \le v, u \le n$$$; $$$v \neq u$$$) — the description of an edge. The given edges form a valid directed acyclic graph. There are no multiple edges.
Output Specification: Print a single integer — the maximum possible size of a cute set $$$S$$$ after you remove some edges from the graph and both indegrees and outdegrees of all vertices either decrease or remain equal to $$$0$$$.
Notes: NoteIn the first example, you can remove edges $$$(1, 2)$$$ and $$$(2, 3)$$$. $$$\mathit{in} = [0, 1, 2]$$$, $$$\mathit{out} = [2, 1, 0]$$$. $$$\mathit{in'} = [0, 0, 1]$$$, $$$\mathit{out'} = [1, 0, 0]$$$. You can see that for all $$$v$$$ the conditions hold. The maximum cute set $$$S$$$ is formed by vertices $$$1$$$ and $$$3$$$. They are still connected directly by an edge, so there is a path between them.In the second example, there are no edges. Since all $$$\mathit{in}_v$$$ and $$$\mathit{out}_v$$$ are equal to $$$0$$$, leaving a graph with zero edges is allowed. There are $$$5$$$ cute sets, each contains a single vertex. Thus, the maximum size is $$$1$$$.In the third example, you can remove edges $$$(7, 1)$$$, $$$(2, 4)$$$, $$$(1, 3)$$$ and $$$(6, 2)$$$. The maximum cute set will be $$$S = \{7, 3, 2\}$$$. You can remove edge $$$(7, 3)$$$ as well, and the answer won't change.Here is the picture of the graph from the third example:
Code:
def iint():
return int(input().strip())
def iints():
return map(int, input().strip().split(" "))
def arr():
return list(input().strip().split(" "))
def arri():
return list(iints())
n,m = iints()
class Graph:
def __init__(self, n):
self.adj = [[] for _ in range(n)]
self.ins = [0 for _ in range(n)]
self.outs = [0 for _ in range(n)]
def add(self, a, b):
self.adj[a].append(b)
self.ins[b]+=1
self.outs[a]+=1
g = Graph(n)
ins2 = [0 for _ in range(n)]
for _ in range(m):
a,b = iints()
a-=1
b-=1
g.add(a,b)
ins2[b]+=1
order = [0 for _ in range(n)]
f = 0
b = 0
for i in range(n):
if not ins2[i]:
order[b] = i
b+=1
dp = [1 for _ in range(n)]
ans = 0
while f < n:
cur = order[f]
f += 1
for x in g.adj[cur]:
ins2[x] -= 1
if not ins2[x]:
order[b] = x
b += 1
if g.ins[x] > 1 and g.outs[cur] > 1:
# TODO: Your code here
ans = max(ans, dp[cur])
print(ans)
|
def iint():
return int(input().strip())
def iints():
return map(int, input().strip().split(" "))
def arr():
return list(input().strip().split(" "))
def arri():
return list(iints())
n,m = iints()
class Graph:
def __init__(self, n):
self.adj = [[] for _ in range(n)]
self.ins = [0 for _ in range(n)]
self.outs = [0 for _ in range(n)]
def add(self, a, b):
self.adj[a].append(b)
self.ins[b]+=1
self.outs[a]+=1
g = Graph(n)
ins2 = [0 for _ in range(n)]
for _ in range(m):
a,b = iints()
a-=1
b-=1
g.add(a,b)
ins2[b]+=1
order = [0 for _ in range(n)]
f = 0
b = 0
for i in range(n):
if not ins2[i]:
order[b] = i
b+=1
dp = [1 for _ in range(n)]
ans = 0
while f < n:
cur = order[f]
f += 1
for x in g.adj[cur]:
ins2[x] -= 1
if not ins2[x]:
order[b] = x
b += 1
if g.ins[x] > 1 and g.outs[cur] > 1:
{{completion}}
ans = max(ans, dp[cur])
print(ans)
|
dp[x] = max(dp[x], 1 + dp[cur])
|
[{"input": "3 3\n1 2\n2 3\n1 3", "output": ["2"]}, {"input": "5 0", "output": ["1"]}, {"input": "7 8\n7 1\n1 3\n6 2\n2 3\n7 2\n2 4\n7 3\n6 3", "output": ["3"]}]
|
block_completion_007891
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given a directed acyclic graph, consisting of $$$n$$$ vertices and $$$m$$$ edges. The vertices are numbered from $$$1$$$ to $$$n$$$. There are no multiple edges and self-loops.Let $$$\mathit{in}_v$$$ be the number of incoming edges (indegree) and $$$\mathit{out}_v$$$ be the number of outgoing edges (outdegree) of vertex $$$v$$$.You are asked to remove some edges from the graph. Let the new degrees be $$$\mathit{in'}_v$$$ and $$$\mathit{out'}_v$$$.You are only allowed to remove the edges if the following conditions hold for every vertex $$$v$$$: $$$\mathit{in'}_v < \mathit{in}_v$$$ or $$$\mathit{in'}_v = \mathit{in}_v = 0$$$; $$$\mathit{out'}_v < \mathit{out}_v$$$ or $$$\mathit{out'}_v = \mathit{out}_v = 0$$$. Let's call a set of vertices $$$S$$$ cute if for each pair of vertices $$$v$$$ and $$$u$$$ ($$$v \neq u$$$) such that $$$v \in S$$$ and $$$u \in S$$$, there exists a path either from $$$v$$$ to $$$u$$$ or from $$$u$$$ to $$$v$$$ over the non-removed edges.What is the maximum possible size of a cute set $$$S$$$ after you remove some edges from the graph and both indegrees and outdegrees of all vertices either decrease or remain equal to $$$0$$$?
Input Specification: The first line contains two integers $$$n$$$ and $$$m$$$ ($$$1 \le n \le 2 \cdot 10^5$$$; $$$0 \le m \le 2 \cdot 10^5$$$) — the number of vertices and the number of edges of the graph. Each of the next $$$m$$$ lines contains two integers $$$v$$$ and $$$u$$$ ($$$1 \le v, u \le n$$$; $$$v \neq u$$$) — the description of an edge. The given edges form a valid directed acyclic graph. There are no multiple edges.
Output Specification: Print a single integer — the maximum possible size of a cute set $$$S$$$ after you remove some edges from the graph and both indegrees and outdegrees of all vertices either decrease or remain equal to $$$0$$$.
Notes: NoteIn the first example, you can remove edges $$$(1, 2)$$$ and $$$(2, 3)$$$. $$$\mathit{in} = [0, 1, 2]$$$, $$$\mathit{out} = [2, 1, 0]$$$. $$$\mathit{in'} = [0, 0, 1]$$$, $$$\mathit{out'} = [1, 0, 0]$$$. You can see that for all $$$v$$$ the conditions hold. The maximum cute set $$$S$$$ is formed by vertices $$$1$$$ and $$$3$$$. They are still connected directly by an edge, so there is a path between them.In the second example, there are no edges. Since all $$$\mathit{in}_v$$$ and $$$\mathit{out}_v$$$ are equal to $$$0$$$, leaving a graph with zero edges is allowed. There are $$$5$$$ cute sets, each contains a single vertex. Thus, the maximum size is $$$1$$$.In the third example, you can remove edges $$$(7, 1)$$$, $$$(2, 4)$$$, $$$(1, 3)$$$ and $$$(6, 2)$$$. The maximum cute set will be $$$S = \{7, 3, 2\}$$$. You can remove edge $$$(7, 3)$$$ as well, and the answer won't change.Here is the picture of the graph from the third example:
Code:
import sys
from collections import deque
n, m = map(int, sys.stdin.readline().split())
inv = [0] * (n + 1)
outv = [0] * (n + 1)
graph = [[] for _ in range(n + 1)]
reverse = [[] for _ in range(n + 1)]
for _ in range(m):
v, u = map(int, sys.stdin.readline().split())
graph[v].append(u)
reverse[u].append(v)
inv[u] += 1
outv[v] += 1
dp = [0] * (n + 1)
dq = deque()
for i in range(1, n + 1):
if outv[i] == 0:
dq.append(i)
while dq:
cur = dq.popleft()
if len(graph[cur]) == 1:
dp[cur] = 1
else:
res = 0
for nxt in graph[cur]:
if inv[nxt] > 1:
# TODO: Your code here
dp[cur] = res + 1
for prv in reverse[cur]:
outv[prv] -= 1
if outv[prv] == 0:
dq.append(prv)
print(max(dp))
|
import sys
from collections import deque
n, m = map(int, sys.stdin.readline().split())
inv = [0] * (n + 1)
outv = [0] * (n + 1)
graph = [[] for _ in range(n + 1)]
reverse = [[] for _ in range(n + 1)]
for _ in range(m):
v, u = map(int, sys.stdin.readline().split())
graph[v].append(u)
reverse[u].append(v)
inv[u] += 1
outv[v] += 1
dp = [0] * (n + 1)
dq = deque()
for i in range(1, n + 1):
if outv[i] == 0:
dq.append(i)
while dq:
cur = dq.popleft()
if len(graph[cur]) == 1:
dp[cur] = 1
else:
res = 0
for nxt in graph[cur]:
if inv[nxt] > 1:
{{completion}}
dp[cur] = res + 1
for prv in reverse[cur]:
outv[prv] -= 1
if outv[prv] == 0:
dq.append(prv)
print(max(dp))
|
res = max(res, dp[nxt])
|
[{"input": "3 3\n1 2\n2 3\n1 3", "output": ["2"]}, {"input": "5 0", "output": ["1"]}, {"input": "7 8\n7 1\n1 3\n6 2\n2 3\n7 2\n2 4\n7 3\n6 3", "output": ["3"]}]
|
block_completion_007892
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given a directed acyclic graph, consisting of $$$n$$$ vertices and $$$m$$$ edges. The vertices are numbered from $$$1$$$ to $$$n$$$. There are no multiple edges and self-loops.Let $$$\mathit{in}_v$$$ be the number of incoming edges (indegree) and $$$\mathit{out}_v$$$ be the number of outgoing edges (outdegree) of vertex $$$v$$$.You are asked to remove some edges from the graph. Let the new degrees be $$$\mathit{in'}_v$$$ and $$$\mathit{out'}_v$$$.You are only allowed to remove the edges if the following conditions hold for every vertex $$$v$$$: $$$\mathit{in'}_v < \mathit{in}_v$$$ or $$$\mathit{in'}_v = \mathit{in}_v = 0$$$; $$$\mathit{out'}_v < \mathit{out}_v$$$ or $$$\mathit{out'}_v = \mathit{out}_v = 0$$$. Let's call a set of vertices $$$S$$$ cute if for each pair of vertices $$$v$$$ and $$$u$$$ ($$$v \neq u$$$) such that $$$v \in S$$$ and $$$u \in S$$$, there exists a path either from $$$v$$$ to $$$u$$$ or from $$$u$$$ to $$$v$$$ over the non-removed edges.What is the maximum possible size of a cute set $$$S$$$ after you remove some edges from the graph and both indegrees and outdegrees of all vertices either decrease or remain equal to $$$0$$$?
Input Specification: The first line contains two integers $$$n$$$ and $$$m$$$ ($$$1 \le n \le 2 \cdot 10^5$$$; $$$0 \le m \le 2 \cdot 10^5$$$) — the number of vertices and the number of edges of the graph. Each of the next $$$m$$$ lines contains two integers $$$v$$$ and $$$u$$$ ($$$1 \le v, u \le n$$$; $$$v \neq u$$$) — the description of an edge. The given edges form a valid directed acyclic graph. There are no multiple edges.
Output Specification: Print a single integer — the maximum possible size of a cute set $$$S$$$ after you remove some edges from the graph and both indegrees and outdegrees of all vertices either decrease or remain equal to $$$0$$$.
Notes: NoteIn the first example, you can remove edges $$$(1, 2)$$$ and $$$(2, 3)$$$. $$$\mathit{in} = [0, 1, 2]$$$, $$$\mathit{out} = [2, 1, 0]$$$. $$$\mathit{in'} = [0, 0, 1]$$$, $$$\mathit{out'} = [1, 0, 0]$$$. You can see that for all $$$v$$$ the conditions hold. The maximum cute set $$$S$$$ is formed by vertices $$$1$$$ and $$$3$$$. They are still connected directly by an edge, so there is a path between them.In the second example, there are no edges. Since all $$$\mathit{in}_v$$$ and $$$\mathit{out}_v$$$ are equal to $$$0$$$, leaving a graph with zero edges is allowed. There are $$$5$$$ cute sets, each contains a single vertex. Thus, the maximum size is $$$1$$$.In the third example, you can remove edges $$$(7, 1)$$$, $$$(2, 4)$$$, $$$(1, 3)$$$ and $$$(6, 2)$$$. The maximum cute set will be $$$S = \{7, 3, 2\}$$$. You can remove edge $$$(7, 3)$$$ as well, and the answer won't change.Here is the picture of the graph from the third example:
Code:
import sys
input = sys.stdin.readline
import math
for _ in range(1):
n, m = map(int, input().split())
g = [[] for i in range(n)]
deg = [0] * n
in_deg = [0] * n
out_deg = [0] * n
for i in range(m):
x, y = map(int, input().split())
x -= 1
y -= 1
g[x].append(y)
deg[y] += 1
out_deg[x] += 1
in_deg[y] += 1
order = []
for i in range(n):
if deg[i] == 0:
order.append(i)
for i in range(n):
for to in g[order[i]]:
deg[to] -= 1
if deg[to] == 0:
# TODO: Your code here
dp = [1] * n
for i in order:
for j in g[i]:
if in_deg[j] > 1 and out_deg[i] > 1:
dp[j] = max(dp[j], dp[i] + 1)
print(max(dp))
|
import sys
input = sys.stdin.readline
import math
for _ in range(1):
n, m = map(int, input().split())
g = [[] for i in range(n)]
deg = [0] * n
in_deg = [0] * n
out_deg = [0] * n
for i in range(m):
x, y = map(int, input().split())
x -= 1
y -= 1
g[x].append(y)
deg[y] += 1
out_deg[x] += 1
in_deg[y] += 1
order = []
for i in range(n):
if deg[i] == 0:
order.append(i)
for i in range(n):
for to in g[order[i]]:
deg[to] -= 1
if deg[to] == 0:
{{completion}}
dp = [1] * n
for i in order:
for j in g[i]:
if in_deg[j] > 1 and out_deg[i] > 1:
dp[j] = max(dp[j], dp[i] + 1)
print(max(dp))
|
order.append(to)
|
[{"input": "3 3\n1 2\n2 3\n1 3", "output": ["2"]}, {"input": "5 0", "output": ["1"]}, {"input": "7 8\n7 1\n1 3\n6 2\n2 3\n7 2\n2 4\n7 3\n6 3", "output": ["3"]}]
|
block_completion_007893
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given a directed acyclic graph, consisting of $$$n$$$ vertices and $$$m$$$ edges. The vertices are numbered from $$$1$$$ to $$$n$$$. There are no multiple edges and self-loops.Let $$$\mathit{in}_v$$$ be the number of incoming edges (indegree) and $$$\mathit{out}_v$$$ be the number of outgoing edges (outdegree) of vertex $$$v$$$.You are asked to remove some edges from the graph. Let the new degrees be $$$\mathit{in'}_v$$$ and $$$\mathit{out'}_v$$$.You are only allowed to remove the edges if the following conditions hold for every vertex $$$v$$$: $$$\mathit{in'}_v < \mathit{in}_v$$$ or $$$\mathit{in'}_v = \mathit{in}_v = 0$$$; $$$\mathit{out'}_v < \mathit{out}_v$$$ or $$$\mathit{out'}_v = \mathit{out}_v = 0$$$. Let's call a set of vertices $$$S$$$ cute if for each pair of vertices $$$v$$$ and $$$u$$$ ($$$v \neq u$$$) such that $$$v \in S$$$ and $$$u \in S$$$, there exists a path either from $$$v$$$ to $$$u$$$ or from $$$u$$$ to $$$v$$$ over the non-removed edges.What is the maximum possible size of a cute set $$$S$$$ after you remove some edges from the graph and both indegrees and outdegrees of all vertices either decrease or remain equal to $$$0$$$?
Input Specification: The first line contains two integers $$$n$$$ and $$$m$$$ ($$$1 \le n \le 2 \cdot 10^5$$$; $$$0 \le m \le 2 \cdot 10^5$$$) — the number of vertices and the number of edges of the graph. Each of the next $$$m$$$ lines contains two integers $$$v$$$ and $$$u$$$ ($$$1 \le v, u \le n$$$; $$$v \neq u$$$) — the description of an edge. The given edges form a valid directed acyclic graph. There are no multiple edges.
Output Specification: Print a single integer — the maximum possible size of a cute set $$$S$$$ after you remove some edges from the graph and both indegrees and outdegrees of all vertices either decrease or remain equal to $$$0$$$.
Notes: NoteIn the first example, you can remove edges $$$(1, 2)$$$ and $$$(2, 3)$$$. $$$\mathit{in} = [0, 1, 2]$$$, $$$\mathit{out} = [2, 1, 0]$$$. $$$\mathit{in'} = [0, 0, 1]$$$, $$$\mathit{out'} = [1, 0, 0]$$$. You can see that for all $$$v$$$ the conditions hold. The maximum cute set $$$S$$$ is formed by vertices $$$1$$$ and $$$3$$$. They are still connected directly by an edge, so there is a path between them.In the second example, there are no edges. Since all $$$\mathit{in}_v$$$ and $$$\mathit{out}_v$$$ are equal to $$$0$$$, leaving a graph with zero edges is allowed. There are $$$5$$$ cute sets, each contains a single vertex. Thus, the maximum size is $$$1$$$.In the third example, you can remove edges $$$(7, 1)$$$, $$$(2, 4)$$$, $$$(1, 3)$$$ and $$$(6, 2)$$$. The maximum cute set will be $$$S = \{7, 3, 2\}$$$. You can remove edge $$$(7, 3)$$$ as well, and the answer won't change.Here is the picture of the graph from the third example:
Code:
import sys
input = sys.stdin.readline
import math
for _ in range(1):
n, m = map(int, input().split())
g = [[] for i in range(n)]
deg = [0] * n
in_deg = [0] * n
out_deg = [0] * n
for i in range(m):
x, y = map(int, input().split())
x -= 1
y -= 1
g[x].append(y)
deg[y] += 1
out_deg[x] += 1
in_deg[y] += 1
order = []
for i in range(n):
if deg[i] == 0:
order.append(i)
for i in range(n):
for to in g[order[i]]:
deg[to] -= 1
if deg[to] == 0:
order.append(to)
dp = [1] * n
for i in order:
for j in g[i]:
if in_deg[j] > 1 and out_deg[i] > 1:
# TODO: Your code here
print(max(dp))
|
import sys
input = sys.stdin.readline
import math
for _ in range(1):
n, m = map(int, input().split())
g = [[] for i in range(n)]
deg = [0] * n
in_deg = [0] * n
out_deg = [0] * n
for i in range(m):
x, y = map(int, input().split())
x -= 1
y -= 1
g[x].append(y)
deg[y] += 1
out_deg[x] += 1
in_deg[y] += 1
order = []
for i in range(n):
if deg[i] == 0:
order.append(i)
for i in range(n):
for to in g[order[i]]:
deg[to] -= 1
if deg[to] == 0:
order.append(to)
dp = [1] * n
for i in order:
for j in g[i]:
if in_deg[j] > 1 and out_deg[i] > 1:
{{completion}}
print(max(dp))
|
dp[j] = max(dp[j], dp[i] + 1)
|
[{"input": "3 3\n1 2\n2 3\n1 3", "output": ["2"]}, {"input": "5 0", "output": ["1"]}, {"input": "7 8\n7 1\n1 3\n6 2\n2 3\n7 2\n2 4\n7 3\n6 3", "output": ["3"]}]
|
block_completion_007894
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given a directed acyclic graph, consisting of $$$n$$$ vertices and $$$m$$$ edges. The vertices are numbered from $$$1$$$ to $$$n$$$. There are no multiple edges and self-loops.Let $$$\mathit{in}_v$$$ be the number of incoming edges (indegree) and $$$\mathit{out}_v$$$ be the number of outgoing edges (outdegree) of vertex $$$v$$$.You are asked to remove some edges from the graph. Let the new degrees be $$$\mathit{in'}_v$$$ and $$$\mathit{out'}_v$$$.You are only allowed to remove the edges if the following conditions hold for every vertex $$$v$$$: $$$\mathit{in'}_v < \mathit{in}_v$$$ or $$$\mathit{in'}_v = \mathit{in}_v = 0$$$; $$$\mathit{out'}_v < \mathit{out}_v$$$ or $$$\mathit{out'}_v = \mathit{out}_v = 0$$$. Let's call a set of vertices $$$S$$$ cute if for each pair of vertices $$$v$$$ and $$$u$$$ ($$$v \neq u$$$) such that $$$v \in S$$$ and $$$u \in S$$$, there exists a path either from $$$v$$$ to $$$u$$$ or from $$$u$$$ to $$$v$$$ over the non-removed edges.What is the maximum possible size of a cute set $$$S$$$ after you remove some edges from the graph and both indegrees and outdegrees of all vertices either decrease or remain equal to $$$0$$$?
Input Specification: The first line contains two integers $$$n$$$ and $$$m$$$ ($$$1 \le n \le 2 \cdot 10^5$$$; $$$0 \le m \le 2 \cdot 10^5$$$) — the number of vertices and the number of edges of the graph. Each of the next $$$m$$$ lines contains two integers $$$v$$$ and $$$u$$$ ($$$1 \le v, u \le n$$$; $$$v \neq u$$$) — the description of an edge. The given edges form a valid directed acyclic graph. There are no multiple edges.
Output Specification: Print a single integer — the maximum possible size of a cute set $$$S$$$ after you remove some edges from the graph and both indegrees and outdegrees of all vertices either decrease or remain equal to $$$0$$$.
Notes: NoteIn the first example, you can remove edges $$$(1, 2)$$$ and $$$(2, 3)$$$. $$$\mathit{in} = [0, 1, 2]$$$, $$$\mathit{out} = [2, 1, 0]$$$. $$$\mathit{in'} = [0, 0, 1]$$$, $$$\mathit{out'} = [1, 0, 0]$$$. You can see that for all $$$v$$$ the conditions hold. The maximum cute set $$$S$$$ is formed by vertices $$$1$$$ and $$$3$$$. They are still connected directly by an edge, so there is a path between them.In the second example, there are no edges. Since all $$$\mathit{in}_v$$$ and $$$\mathit{out}_v$$$ are equal to $$$0$$$, leaving a graph with zero edges is allowed. There are $$$5$$$ cute sets, each contains a single vertex. Thus, the maximum size is $$$1$$$.In the third example, you can remove edges $$$(7, 1)$$$, $$$(2, 4)$$$, $$$(1, 3)$$$ and $$$(6, 2)$$$. The maximum cute set will be $$$S = \{7, 3, 2\}$$$. You can remove edge $$$(7, 3)$$$ as well, and the answer won't change.Here is the picture of the graph from the third example:
Code:
from collections import deque
I=lambda:map(int,input().split())
n,m=I()
g=[[]for _ in range(n)]
din,dout,dcur=[0]*n,[0]*n,[0]*n
for _ in range(m):
u,v=I()
u,v=u-1,v-1
g[u].append(v)
dout[u]+=1;din[v]+=1;dcur[v]+=1
q=deque([i for i,d in enumerate(din) if d==0])
f=[1]*n
while q:
u=q.popleft()
for v in g[u]:
if dout[u]>1 and din[v]>1:
# TODO: Your code here
dcur[v]-=1
if dcur[v]==0:q.append(v)
print(max(f))
|
from collections import deque
I=lambda:map(int,input().split())
n,m=I()
g=[[]for _ in range(n)]
din,dout,dcur=[0]*n,[0]*n,[0]*n
for _ in range(m):
u,v=I()
u,v=u-1,v-1
g[u].append(v)
dout[u]+=1;din[v]+=1;dcur[v]+=1
q=deque([i for i,d in enumerate(din) if d==0])
f=[1]*n
while q:
u=q.popleft()
for v in g[u]:
if dout[u]>1 and din[v]>1:
{{completion}}
dcur[v]-=1
if dcur[v]==0:q.append(v)
print(max(f))
|
f[v]=max(f[v],f[u]+1)
|
[{"input": "3 3\n1 2\n2 3\n1 3", "output": ["2"]}, {"input": "5 0", "output": ["1"]}, {"input": "7 8\n7 1\n1 3\n6 2\n2 3\n7 2\n2 4\n7 3\n6 3", "output": ["3"]}]
|
block_completion_007895
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given a directed acyclic graph, consisting of $$$n$$$ vertices and $$$m$$$ edges. The vertices are numbered from $$$1$$$ to $$$n$$$. There are no multiple edges and self-loops.Let $$$\mathit{in}_v$$$ be the number of incoming edges (indegree) and $$$\mathit{out}_v$$$ be the number of outgoing edges (outdegree) of vertex $$$v$$$.You are asked to remove some edges from the graph. Let the new degrees be $$$\mathit{in'}_v$$$ and $$$\mathit{out'}_v$$$.You are only allowed to remove the edges if the following conditions hold for every vertex $$$v$$$: $$$\mathit{in'}_v < \mathit{in}_v$$$ or $$$\mathit{in'}_v = \mathit{in}_v = 0$$$; $$$\mathit{out'}_v < \mathit{out}_v$$$ or $$$\mathit{out'}_v = \mathit{out}_v = 0$$$. Let's call a set of vertices $$$S$$$ cute if for each pair of vertices $$$v$$$ and $$$u$$$ ($$$v \neq u$$$) such that $$$v \in S$$$ and $$$u \in S$$$, there exists a path either from $$$v$$$ to $$$u$$$ or from $$$u$$$ to $$$v$$$ over the non-removed edges.What is the maximum possible size of a cute set $$$S$$$ after you remove some edges from the graph and both indegrees and outdegrees of all vertices either decrease or remain equal to $$$0$$$?
Input Specification: The first line contains two integers $$$n$$$ and $$$m$$$ ($$$1 \le n \le 2 \cdot 10^5$$$; $$$0 \le m \le 2 \cdot 10^5$$$) — the number of vertices and the number of edges of the graph. Each of the next $$$m$$$ lines contains two integers $$$v$$$ and $$$u$$$ ($$$1 \le v, u \le n$$$; $$$v \neq u$$$) — the description of an edge. The given edges form a valid directed acyclic graph. There are no multiple edges.
Output Specification: Print a single integer — the maximum possible size of a cute set $$$S$$$ after you remove some edges from the graph and both indegrees and outdegrees of all vertices either decrease or remain equal to $$$0$$$.
Notes: NoteIn the first example, you can remove edges $$$(1, 2)$$$ and $$$(2, 3)$$$. $$$\mathit{in} = [0, 1, 2]$$$, $$$\mathit{out} = [2, 1, 0]$$$. $$$\mathit{in'} = [0, 0, 1]$$$, $$$\mathit{out'} = [1, 0, 0]$$$. You can see that for all $$$v$$$ the conditions hold. The maximum cute set $$$S$$$ is formed by vertices $$$1$$$ and $$$3$$$. They are still connected directly by an edge, so there is a path between them.In the second example, there are no edges. Since all $$$\mathit{in}_v$$$ and $$$\mathit{out}_v$$$ are equal to $$$0$$$, leaving a graph with zero edges is allowed. There are $$$5$$$ cute sets, each contains a single vertex. Thus, the maximum size is $$$1$$$.In the third example, you can remove edges $$$(7, 1)$$$, $$$(2, 4)$$$, $$$(1, 3)$$$ and $$$(6, 2)$$$. The maximum cute set will be $$$S = \{7, 3, 2\}$$$. You can remove edge $$$(7, 3)$$$ as well, and the answer won't change.Here is the picture of the graph from the third example:
Code:
from collections import deque
I=lambda:map(int,input().split())
n,m=I()
g=[[]for _ in range(n)]
din,dout,dcur=[0]*n,[0]*n,[0]*n
for _ in range(m):
u,v=I()
u,v=u-1,v-1
g[u].append(v)
dout[u]+=1;din[v]+=1;dcur[v]+=1
q=deque([i for i,d in enumerate(din) if d==0])
f=[1]*n
while q:
u=q.popleft()
for v in g[u]:
if dout[u]>1 and din[v]>1:
f[v]=max(f[v],f[u]+1)
dcur[v]-=1
if dcur[v]==0:# TODO: Your code here
print(max(f))
|
from collections import deque
I=lambda:map(int,input().split())
n,m=I()
g=[[]for _ in range(n)]
din,dout,dcur=[0]*n,[0]*n,[0]*n
for _ in range(m):
u,v=I()
u,v=u-1,v-1
g[u].append(v)
dout[u]+=1;din[v]+=1;dcur[v]+=1
q=deque([i for i,d in enumerate(din) if d==0])
f=[1]*n
while q:
u=q.popleft()
for v in g[u]:
if dout[u]>1 and din[v]>1:
f[v]=max(f[v],f[u]+1)
dcur[v]-=1
if dcur[v]==0:{{completion}}
print(max(f))
|
q.append(v)
|
[{"input": "3 3\n1 2\n2 3\n1 3", "output": ["2"]}, {"input": "5 0", "output": ["1"]}, {"input": "7 8\n7 1\n1 3\n6 2\n2 3\n7 2\n2 4\n7 3\n6 3", "output": ["3"]}]
|
block_completion_007896
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: Monocarp plays "Rage of Empires II: Definitive Edition" — a strategic computer game. Right now he's planning to attack his opponent in the game, but Monocarp's forces cannot enter the opponent's territory since the opponent has built a wall.The wall consists of $$$n$$$ sections, aligned in a row. The $$$i$$$-th section initially has durability $$$a_i$$$. If durability of some section becomes $$$0$$$ or less, this section is considered broken.To attack the opponent, Monocarp needs to break at least two sections of the wall (any two sections: possibly adjacent, possibly not). To do this, he plans to use an onager — a special siege weapon. The onager can be used to shoot any section of the wall; the shot deals $$$2$$$ damage to the target section and $$$1$$$ damage to adjacent sections. In other words, if the onager shoots at the section $$$x$$$, then the durability of the section $$$x$$$ decreases by $$$2$$$, and the durability of the sections $$$x - 1$$$ and $$$x + 1$$$ (if they exist) decreases by $$$1$$$ each. Monocarp can shoot at any sections any number of times, he can even shoot at broken sections.Monocarp wants to calculate the minimum number of onager shots needed to break at least two sections. Help him!
Input Specification: The first line contains one integer $$$n$$$ ($$$2 \le n \le 2 \cdot 10^5$$$) — the number of sections. The second line contains the sequence of integers $$$a_1, a_2, \dots, a_n$$$ ($$$1 \le a_i \le 10^6$$$), where $$$a_i$$$ is the initial durability of the $$$i$$$-th section.
Output Specification: Print one integer — the minimum number of onager shots needed to break at least two sections of the wall.
Notes: NoteIn the first example, it is possible to break the $$$2$$$-nd and the $$$4$$$-th section in $$$10$$$ shots, for example, by shooting the third section $$$10$$$ times. After that, the durabilities become $$$[20, 0, 10, 0, 20]$$$. Another way of doing it is firing $$$5$$$ shots at the $$$2$$$-nd section, and another $$$5$$$ shots at the $$$4$$$-th section. After that, the durabilities become $$$[15, 0, 20, 0, 15]$$$.In the second example, it is enough to shoot the $$$2$$$-nd section once. Then the $$$1$$$-st and the $$$3$$$-rd section will be broken.In the third example, it is enough to shoot the $$$2$$$-nd section twice (then the durabilities become $$$[5, 2, 4, 8, 5, 8]$$$), and then shoot the $$$3$$$-rd section twice (then the durabilities become $$$[5, 0, 0, 6, 5, 8]$$$). So, four shots are enough to break the $$$2$$$-nd and the $$$3$$$-rd section.
Code:
N=int(input())
A=[int(x) for x in input().split()]
B=sorted(A)
ans=-(-B[0]//2)-(-B[1]//2)
for i in range(N-2):
# TODO: Your code here
for i in range(N-1):
score=max(-(-(A[i]+A[i+1])//3),-(-A[i]//2),-(-A[i+1]//2))
ans=min(score,ans)
print(ans)
|
N=int(input())
A=[int(x) for x in input().split()]
B=sorted(A)
ans=-(-B[0]//2)-(-B[1]//2)
for i in range(N-2):
{{completion}}
for i in range(N-1):
score=max(-(-(A[i]+A[i+1])//3),-(-A[i]//2),-(-A[i+1]//2))
ans=min(score,ans)
print(ans)
|
ans=min(ans,-(-(A[i]+A[i+2])//2))
|
[{"input": "5\n20 10 30 10 20", "output": ["10"]}, {"input": "3\n1 8 1", "output": ["1"]}, {"input": "6\n7 6 6 8 5 8", "output": ["4"]}, {"input": "6\n14 3 8 10 15 4", "output": ["4"]}, {"input": "4\n1 100 100 1", "output": ["2"]}, {"input": "3\n40 10 10", "output": ["7"]}]
|
block_completion_007904
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: Monocarp plays "Rage of Empires II: Definitive Edition" — a strategic computer game. Right now he's planning to attack his opponent in the game, but Monocarp's forces cannot enter the opponent's territory since the opponent has built a wall.The wall consists of $$$n$$$ sections, aligned in a row. The $$$i$$$-th section initially has durability $$$a_i$$$. If durability of some section becomes $$$0$$$ or less, this section is considered broken.To attack the opponent, Monocarp needs to break at least two sections of the wall (any two sections: possibly adjacent, possibly not). To do this, he plans to use an onager — a special siege weapon. The onager can be used to shoot any section of the wall; the shot deals $$$2$$$ damage to the target section and $$$1$$$ damage to adjacent sections. In other words, if the onager shoots at the section $$$x$$$, then the durability of the section $$$x$$$ decreases by $$$2$$$, and the durability of the sections $$$x - 1$$$ and $$$x + 1$$$ (if they exist) decreases by $$$1$$$ each. Monocarp can shoot at any sections any number of times, he can even shoot at broken sections.Monocarp wants to calculate the minimum number of onager shots needed to break at least two sections. Help him!
Input Specification: The first line contains one integer $$$n$$$ ($$$2 \le n \le 2 \cdot 10^5$$$) — the number of sections. The second line contains the sequence of integers $$$a_1, a_2, \dots, a_n$$$ ($$$1 \le a_i \le 10^6$$$), where $$$a_i$$$ is the initial durability of the $$$i$$$-th section.
Output Specification: Print one integer — the minimum number of onager shots needed to break at least two sections of the wall.
Notes: NoteIn the first example, it is possible to break the $$$2$$$-nd and the $$$4$$$-th section in $$$10$$$ shots, for example, by shooting the third section $$$10$$$ times. After that, the durabilities become $$$[20, 0, 10, 0, 20]$$$. Another way of doing it is firing $$$5$$$ shots at the $$$2$$$-nd section, and another $$$5$$$ shots at the $$$4$$$-th section. After that, the durabilities become $$$[15, 0, 20, 0, 15]$$$.In the second example, it is enough to shoot the $$$2$$$-nd section once. Then the $$$1$$$-st and the $$$3$$$-rd section will be broken.In the third example, it is enough to shoot the $$$2$$$-nd section twice (then the durabilities become $$$[5, 2, 4, 8, 5, 8]$$$), and then shoot the $$$3$$$-rd section twice (then the durabilities become $$$[5, 0, 0, 6, 5, 8]$$$). So, four shots are enough to break the $$$2$$$-nd and the $$$3$$$-rd section.
Code:
N=int(input())
A=[int(x) for x in input().split()]
B=sorted(A)
ans=-(-B[0]//2)-(-B[1]//2)
for i in range(N-2):
ans=min(ans,-(-(A[i]+A[i+2])//2))
for i in range(N-1):
# TODO: Your code here
print(ans)
|
N=int(input())
A=[int(x) for x in input().split()]
B=sorted(A)
ans=-(-B[0]//2)-(-B[1]//2)
for i in range(N-2):
ans=min(ans,-(-(A[i]+A[i+2])//2))
for i in range(N-1):
{{completion}}
print(ans)
|
score=max(-(-(A[i]+A[i+1])//3),-(-A[i]//2),-(-A[i+1]//2))
ans=min(score,ans)
|
[{"input": "5\n20 10 30 10 20", "output": ["10"]}, {"input": "3\n1 8 1", "output": ["1"]}, {"input": "6\n7 6 6 8 5 8", "output": ["4"]}, {"input": "6\n14 3 8 10 15 4", "output": ["4"]}, {"input": "4\n1 100 100 1", "output": ["2"]}, {"input": "3\n40 10 10", "output": ["7"]}]
|
block_completion_007905
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: Monocarp plays "Rage of Empires II: Definitive Edition" — a strategic computer game. Right now he's planning to attack his opponent in the game, but Monocarp's forces cannot enter the opponent's territory since the opponent has built a wall.The wall consists of $$$n$$$ sections, aligned in a row. The $$$i$$$-th section initially has durability $$$a_i$$$. If durability of some section becomes $$$0$$$ or less, this section is considered broken.To attack the opponent, Monocarp needs to break at least two sections of the wall (any two sections: possibly adjacent, possibly not). To do this, he plans to use an onager — a special siege weapon. The onager can be used to shoot any section of the wall; the shot deals $$$2$$$ damage to the target section and $$$1$$$ damage to adjacent sections. In other words, if the onager shoots at the section $$$x$$$, then the durability of the section $$$x$$$ decreases by $$$2$$$, and the durability of the sections $$$x - 1$$$ and $$$x + 1$$$ (if they exist) decreases by $$$1$$$ each. Monocarp can shoot at any sections any number of times, he can even shoot at broken sections.Monocarp wants to calculate the minimum number of onager shots needed to break at least two sections. Help him!
Input Specification: The first line contains one integer $$$n$$$ ($$$2 \le n \le 2 \cdot 10^5$$$) — the number of sections. The second line contains the sequence of integers $$$a_1, a_2, \dots, a_n$$$ ($$$1 \le a_i \le 10^6$$$), where $$$a_i$$$ is the initial durability of the $$$i$$$-th section.
Output Specification: Print one integer — the minimum number of onager shots needed to break at least two sections of the wall.
Notes: NoteIn the first example, it is possible to break the $$$2$$$-nd and the $$$4$$$-th section in $$$10$$$ shots, for example, by shooting the third section $$$10$$$ times. After that, the durabilities become $$$[20, 0, 10, 0, 20]$$$. Another way of doing it is firing $$$5$$$ shots at the $$$2$$$-nd section, and another $$$5$$$ shots at the $$$4$$$-th section. After that, the durabilities become $$$[15, 0, 20, 0, 15]$$$.In the second example, it is enough to shoot the $$$2$$$-nd section once. Then the $$$1$$$-st and the $$$3$$$-rd section will be broken.In the third example, it is enough to shoot the $$$2$$$-nd section twice (then the durabilities become $$$[5, 2, 4, 8, 5, 8]$$$), and then shoot the $$$3$$$-rd section twice (then the durabilities become $$$[5, 0, 0, 6, 5, 8]$$$). So, four shots are enough to break the $$$2$$$-nd and the $$$3$$$-rd section.
Code:
def onagr(x, y):
x, y = max(x, y), min(x, y)
if x >= 2 * y:
res = (x + 1) // 2
else:
res = x - y + (2 * y - x) // 3 * 2 + (2 * y - x) % 3
return res
def onagr1(x, y):
return min(x, y) + (abs(x - y) + 1) // 2
n = int(input())
m1, m2, *a = list(map(int, input().split()))
if n == 2:
print(onagr(m1, m2))
else:
p = m2
pp = m1
r1 = onagr1(m1, a[0])
if m2 < m1:
m1, m2 = m2, m1
r = onagr(m1, m2)
for k in a:
if k < m1:
m2 = m1
m1 = k
elif k < m2:
# TODO: Your code here
r = min(r, onagr(k, p))
r1 = min(r1, onagr1(k, pp))
pp = p
p = k
print(min((m1 + 1) // 2 + (m2 + 1) // 2, r, r1))
|
def onagr(x, y):
x, y = max(x, y), min(x, y)
if x >= 2 * y:
res = (x + 1) // 2
else:
res = x - y + (2 * y - x) // 3 * 2 + (2 * y - x) % 3
return res
def onagr1(x, y):
return min(x, y) + (abs(x - y) + 1) // 2
n = int(input())
m1, m2, *a = list(map(int, input().split()))
if n == 2:
print(onagr(m1, m2))
else:
p = m2
pp = m1
r1 = onagr1(m1, a[0])
if m2 < m1:
m1, m2 = m2, m1
r = onagr(m1, m2)
for k in a:
if k < m1:
m2 = m1
m1 = k
elif k < m2:
{{completion}}
r = min(r, onagr(k, p))
r1 = min(r1, onagr1(k, pp))
pp = p
p = k
print(min((m1 + 1) // 2 + (m2 + 1) // 2, r, r1))
|
m2 = k
|
[{"input": "5\n20 10 30 10 20", "output": ["10"]}, {"input": "3\n1 8 1", "output": ["1"]}, {"input": "6\n7 6 6 8 5 8", "output": ["4"]}, {"input": "6\n14 3 8 10 15 4", "output": ["4"]}, {"input": "4\n1 100 100 1", "output": ["2"]}, {"input": "3\n40 10 10", "output": ["7"]}]
|
block_completion_007906
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: Monocarp plays "Rage of Empires II: Definitive Edition" — a strategic computer game. Right now he's planning to attack his opponent in the game, but Monocarp's forces cannot enter the opponent's territory since the opponent has built a wall.The wall consists of $$$n$$$ sections, aligned in a row. The $$$i$$$-th section initially has durability $$$a_i$$$. If durability of some section becomes $$$0$$$ or less, this section is considered broken.To attack the opponent, Monocarp needs to break at least two sections of the wall (any two sections: possibly adjacent, possibly not). To do this, he plans to use an onager — a special siege weapon. The onager can be used to shoot any section of the wall; the shot deals $$$2$$$ damage to the target section and $$$1$$$ damage to adjacent sections. In other words, if the onager shoots at the section $$$x$$$, then the durability of the section $$$x$$$ decreases by $$$2$$$, and the durability of the sections $$$x - 1$$$ and $$$x + 1$$$ (if they exist) decreases by $$$1$$$ each. Monocarp can shoot at any sections any number of times, he can even shoot at broken sections.Monocarp wants to calculate the minimum number of onager shots needed to break at least two sections. Help him!
Input Specification: The first line contains one integer $$$n$$$ ($$$2 \le n \le 2 \cdot 10^5$$$) — the number of sections. The second line contains the sequence of integers $$$a_1, a_2, \dots, a_n$$$ ($$$1 \le a_i \le 10^6$$$), where $$$a_i$$$ is the initial durability of the $$$i$$$-th section.
Output Specification: Print one integer — the minimum number of onager shots needed to break at least two sections of the wall.
Notes: NoteIn the first example, it is possible to break the $$$2$$$-nd and the $$$4$$$-th section in $$$10$$$ shots, for example, by shooting the third section $$$10$$$ times. After that, the durabilities become $$$[20, 0, 10, 0, 20]$$$. Another way of doing it is firing $$$5$$$ shots at the $$$2$$$-nd section, and another $$$5$$$ shots at the $$$4$$$-th section. After that, the durabilities become $$$[15, 0, 20, 0, 15]$$$.In the second example, it is enough to shoot the $$$2$$$-nd section once. Then the $$$1$$$-st and the $$$3$$$-rd section will be broken.In the third example, it is enough to shoot the $$$2$$$-nd section twice (then the durabilities become $$$[5, 2, 4, 8, 5, 8]$$$), and then shoot the $$$3$$$-rd section twice (then the durabilities become $$$[5, 0, 0, 6, 5, 8]$$$). So, four shots are enough to break the $$$2$$$-nd and the $$$3$$$-rd section.
Code:
import math,sys;input=sys.stdin.readline;S=lambda:input().rstrip();I=lambda:int(S());M=lambda:map(int,S().split());L=lambda:list(M());mod1=1000000007;mod2=998244353
n=I();a=L()
b=sorted(a)[:2]
ans=math.ceil(b[0]/2)+math.ceil(b[1]/2)
for i in range(n-2):
ans=min(ans,math.ceil((a[i]+a[i+2])/2))
for i in range(n-1):
x=max(a[i],a[i+1]);y=min(a[i],a[i+1])
if x>=2*y:ans=min(ans,math.ceil(x/2))
else:# TODO: Your code here
print(ans)
|
import math,sys;input=sys.stdin.readline;S=lambda:input().rstrip();I=lambda:int(S());M=lambda:map(int,S().split());L=lambda:list(M());mod1=1000000007;mod2=998244353
n=I();a=L()
b=sorted(a)[:2]
ans=math.ceil(b[0]/2)+math.ceil(b[1]/2)
for i in range(n-2):
ans=min(ans,math.ceil((a[i]+a[i+2])/2))
for i in range(n-1):
x=max(a[i],a[i+1]);y=min(a[i],a[i+1])
if x>=2*y:ans=min(ans,math.ceil(x/2))
else:{{completion}}
print(ans)
|
ans=min(ans,math.ceil((4*y-2*x)/3)+x-y)
|
[{"input": "5\n20 10 30 10 20", "output": ["10"]}, {"input": "3\n1 8 1", "output": ["1"]}, {"input": "6\n7 6 6 8 5 8", "output": ["4"]}, {"input": "6\n14 3 8 10 15 4", "output": ["4"]}, {"input": "4\n1 100 100 1", "output": ["2"]}, {"input": "3\n40 10 10", "output": ["7"]}]
|
block_completion_007907
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: Monocarp plays "Rage of Empires II: Definitive Edition" — a strategic computer game. Right now he's planning to attack his opponent in the game, but Monocarp's forces cannot enter the opponent's territory since the opponent has built a wall.The wall consists of $$$n$$$ sections, aligned in a row. The $$$i$$$-th section initially has durability $$$a_i$$$. If durability of some section becomes $$$0$$$ or less, this section is considered broken.To attack the opponent, Monocarp needs to break at least two sections of the wall (any two sections: possibly adjacent, possibly not). To do this, he plans to use an onager — a special siege weapon. The onager can be used to shoot any section of the wall; the shot deals $$$2$$$ damage to the target section and $$$1$$$ damage to adjacent sections. In other words, if the onager shoots at the section $$$x$$$, then the durability of the section $$$x$$$ decreases by $$$2$$$, and the durability of the sections $$$x - 1$$$ and $$$x + 1$$$ (if they exist) decreases by $$$1$$$ each. Monocarp can shoot at any sections any number of times, he can even shoot at broken sections.Monocarp wants to calculate the minimum number of onager shots needed to break at least two sections. Help him!
Input Specification: The first line contains one integer $$$n$$$ ($$$2 \le n \le 2 \cdot 10^5$$$) — the number of sections. The second line contains the sequence of integers $$$a_1, a_2, \dots, a_n$$$ ($$$1 \le a_i \le 10^6$$$), where $$$a_i$$$ is the initial durability of the $$$i$$$-th section.
Output Specification: Print one integer — the minimum number of onager shots needed to break at least two sections of the wall.
Notes: NoteIn the first example, it is possible to break the $$$2$$$-nd and the $$$4$$$-th section in $$$10$$$ shots, for example, by shooting the third section $$$10$$$ times. After that, the durabilities become $$$[20, 0, 10, 0, 20]$$$. Another way of doing it is firing $$$5$$$ shots at the $$$2$$$-nd section, and another $$$5$$$ shots at the $$$4$$$-th section. After that, the durabilities become $$$[15, 0, 20, 0, 15]$$$.In the second example, it is enough to shoot the $$$2$$$-nd section once. Then the $$$1$$$-st and the $$$3$$$-rd section will be broken.In the third example, it is enough to shoot the $$$2$$$-nd section twice (then the durabilities become $$$[5, 2, 4, 8, 5, 8]$$$), and then shoot the $$$3$$$-rd section twice (then the durabilities become $$$[5, 0, 0, 6, 5, 8]$$$). So, four shots are enough to break the $$$2$$$-nd and the $$$3$$$-rd section.
Code:
n=int(input())
arr=list(map(int,input().split()))
ans=float("inf")
y=sorted(arr)
ans = ((y[0]+1)//2) + ((y[1]+1)//2)
for i in range(len(arr)-1):
ans=min(ans,max((arr[i]+1)//2,(arr[i+1]+1)//2,(arr[i]+arr[i+1]+2)//3))
for i in range(len(arr)-2):
if arr[i]<=arr[i+2]:
ans = min(ans,arr[i]+(arr[i+2]-arr[i]+1)//2)
else:
# TODO: Your code here
print(ans)
|
n=int(input())
arr=list(map(int,input().split()))
ans=float("inf")
y=sorted(arr)
ans = ((y[0]+1)//2) + ((y[1]+1)//2)
for i in range(len(arr)-1):
ans=min(ans,max((arr[i]+1)//2,(arr[i+1]+1)//2,(arr[i]+arr[i+1]+2)//3))
for i in range(len(arr)-2):
if arr[i]<=arr[i+2]:
ans = min(ans,arr[i]+(arr[i+2]-arr[i]+1)//2)
else:
{{completion}}
print(ans)
|
ans = min(ans,arr[i+2]+(arr[i]-arr[i+2]+1)//2)
|
[{"input": "5\n20 10 30 10 20", "output": ["10"]}, {"input": "3\n1 8 1", "output": ["1"]}, {"input": "6\n7 6 6 8 5 8", "output": ["4"]}, {"input": "6\n14 3 8 10 15 4", "output": ["4"]}, {"input": "4\n1 100 100 1", "output": ["2"]}, {"input": "3\n40 10 10", "output": ["7"]}]
|
block_completion_007908
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: Monocarp plays "Rage of Empires II: Definitive Edition" — a strategic computer game. Right now he's planning to attack his opponent in the game, but Monocarp's forces cannot enter the opponent's territory since the opponent has built a wall.The wall consists of $$$n$$$ sections, aligned in a row. The $$$i$$$-th section initially has durability $$$a_i$$$. If durability of some section becomes $$$0$$$ or less, this section is considered broken.To attack the opponent, Monocarp needs to break at least two sections of the wall (any two sections: possibly adjacent, possibly not). To do this, he plans to use an onager — a special siege weapon. The onager can be used to shoot any section of the wall; the shot deals $$$2$$$ damage to the target section and $$$1$$$ damage to adjacent sections. In other words, if the onager shoots at the section $$$x$$$, then the durability of the section $$$x$$$ decreases by $$$2$$$, and the durability of the sections $$$x - 1$$$ and $$$x + 1$$$ (if they exist) decreases by $$$1$$$ each. Monocarp can shoot at any sections any number of times, he can even shoot at broken sections.Monocarp wants to calculate the minimum number of onager shots needed to break at least two sections. Help him!
Input Specification: The first line contains one integer $$$n$$$ ($$$2 \le n \le 2 \cdot 10^5$$$) — the number of sections. The second line contains the sequence of integers $$$a_1, a_2, \dots, a_n$$$ ($$$1 \le a_i \le 10^6$$$), where $$$a_i$$$ is the initial durability of the $$$i$$$-th section.
Output Specification: Print one integer — the minimum number of onager shots needed to break at least two sections of the wall.
Notes: NoteIn the first example, it is possible to break the $$$2$$$-nd and the $$$4$$$-th section in $$$10$$$ shots, for example, by shooting the third section $$$10$$$ times. After that, the durabilities become $$$[20, 0, 10, 0, 20]$$$. Another way of doing it is firing $$$5$$$ shots at the $$$2$$$-nd section, and another $$$5$$$ shots at the $$$4$$$-th section. After that, the durabilities become $$$[15, 0, 20, 0, 15]$$$.In the second example, it is enough to shoot the $$$2$$$-nd section once. Then the $$$1$$$-st and the $$$3$$$-rd section will be broken.In the third example, it is enough to shoot the $$$2$$$-nd section twice (then the durabilities become $$$[5, 2, 4, 8, 5, 8]$$$), and then shoot the $$$3$$$-rd section twice (then the durabilities become $$$[5, 0, 0, 6, 5, 8]$$$). So, four shots are enough to break the $$$2$$$-nd and the $$$3$$$-rd section.
Code:
import sys
n = int(sys.stdin.readline())
arr = list(map(int, sys.stdin.readline().split()))
x, y = sorted(arr)[:2]
ans = (x + 1) // 2 + (y + 1) // 2
for i in range(n - 2):
x, y = arr[i], arr[i + 2]
if (x % 2 == 1) and (y % 2 == 1):
x -= 1
y -= 1
ans = min(ans, (x + 1) // 2 + (y + 1) // 2 + 1)
else:
# TODO: Your code here
for i in range(n - 1):
x, y = arr[i], arr[i + 1]
if x > y:
x, y = y, x
if y >= 2 * x:
ans = min(ans, (y + 1) // 2)
else:
res = y - x
x -= res
y -= 2 * res
tmp = x // 3
res += 2 * tmp
x -= 3 * tmp
ans = min(ans, res + x)
print(ans)
|
import sys
n = int(sys.stdin.readline())
arr = list(map(int, sys.stdin.readline().split()))
x, y = sorted(arr)[:2]
ans = (x + 1) // 2 + (y + 1) // 2
for i in range(n - 2):
x, y = arr[i], arr[i + 2]
if (x % 2 == 1) and (y % 2 == 1):
x -= 1
y -= 1
ans = min(ans, (x + 1) // 2 + (y + 1) // 2 + 1)
else:
{{completion}}
for i in range(n - 1):
x, y = arr[i], arr[i + 1]
if x > y:
x, y = y, x
if y >= 2 * x:
ans = min(ans, (y + 1) // 2)
else:
res = y - x
x -= res
y -= 2 * res
tmp = x // 3
res += 2 * tmp
x -= 3 * tmp
ans = min(ans, res + x)
print(ans)
|
ans = min(ans, (x + 1) // 2 + (y + 1) // 2)
|
[{"input": "5\n20 10 30 10 20", "output": ["10"]}, {"input": "3\n1 8 1", "output": ["1"]}, {"input": "6\n7 6 6 8 5 8", "output": ["4"]}, {"input": "6\n14 3 8 10 15 4", "output": ["4"]}, {"input": "4\n1 100 100 1", "output": ["2"]}, {"input": "3\n40 10 10", "output": ["7"]}]
|
block_completion_007909
|
block
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.