message stringlengths 2 19.9k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 322 108k | cluster float64 15 15 | __index_level_0__ int64 644 217k |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
One evening Rainbow Dash and Fluttershy have come up with a game. Since the ponies are friends, they have decided not to compete in the game but to pursue a common goal.
The game starts on a square flat grid, which initially has the outline borders built up. Rainbow Dash and Fluttershy have flat square blocks with size 1×1, Rainbow Dash has an infinite amount of light blue blocks, Fluttershy has an infinite amount of yellow blocks.
The blocks are placed according to the following rule: each newly placed block must touch the built on the previous turns figure by a side (note that the outline borders of the grid are built initially). At each turn, one pony can place any number of blocks of her color according to the game rules.
Rainbow and Fluttershy have found out that they can build patterns on the grid of the game that way. They have decided to start with something simple, so they made up their mind to place the blocks to form a chess coloring. Rainbow Dash is well-known for her speed, so she is interested in the minimum number of turns she and Fluttershy need to do to get a chess coloring, covering the whole grid with blocks. Please help her find that number!
Since the ponies can play many times on different boards, Rainbow Dash asks you to find the minimum numbers of turns for several grids of the games.
The chess coloring in two colors is the one in which each square is neighbor by side only with squares of different colors.
Input
The first line contains a single integer T (1 ≤ T ≤ 100): the number of grids of the games.
Each of the next T lines contains a single integer n (1 ≤ n ≤ 10^9): the size of the side of the grid of the game.
Output
For each grid of the game print the minimum number of turns required to build a chess coloring pattern out of blocks on it.
Example
Input
2
3
4
Output
2
3
Note
For 3×3 grid ponies can make two following moves: <image> | instruction | 0 | 24,956 | 15 | 49,912 |
Tags: greedy, math
Correct Solution:
```
from math import ceil
for _ in range(int(input())):
n=int(input())
print(int(ceil((n+1)/2)))
``` | output | 1 | 24,956 | 15 | 49,913 |
Provide tags and a correct Python 3 solution for this coding contest problem.
One evening Rainbow Dash and Fluttershy have come up with a game. Since the ponies are friends, they have decided not to compete in the game but to pursue a common goal.
The game starts on a square flat grid, which initially has the outline borders built up. Rainbow Dash and Fluttershy have flat square blocks with size 1×1, Rainbow Dash has an infinite amount of light blue blocks, Fluttershy has an infinite amount of yellow blocks.
The blocks are placed according to the following rule: each newly placed block must touch the built on the previous turns figure by a side (note that the outline borders of the grid are built initially). At each turn, one pony can place any number of blocks of her color according to the game rules.
Rainbow and Fluttershy have found out that they can build patterns on the grid of the game that way. They have decided to start with something simple, so they made up their mind to place the blocks to form a chess coloring. Rainbow Dash is well-known for her speed, so she is interested in the minimum number of turns she and Fluttershy need to do to get a chess coloring, covering the whole grid with blocks. Please help her find that number!
Since the ponies can play many times on different boards, Rainbow Dash asks you to find the minimum numbers of turns for several grids of the games.
The chess coloring in two colors is the one in which each square is neighbor by side only with squares of different colors.
Input
The first line contains a single integer T (1 ≤ T ≤ 100): the number of grids of the games.
Each of the next T lines contains a single integer n (1 ≤ n ≤ 10^9): the size of the side of the grid of the game.
Output
For each grid of the game print the minimum number of turns required to build a chess coloring pattern out of blocks on it.
Example
Input
2
3
4
Output
2
3
Note
For 3×3 grid ponies can make two following moves: <image> | instruction | 0 | 24,957 | 15 | 49,914 |
Tags: greedy, math
Correct Solution:
```
for _ in range(int(input())):
n = int(input())
k = int(n//2 + 1)
print(k)
``` | output | 1 | 24,957 | 15 | 49,915 |
Provide tags and a correct Python 3 solution for this coding contest problem.
One evening Rainbow Dash and Fluttershy have come up with a game. Since the ponies are friends, they have decided not to compete in the game but to pursue a common goal.
The game starts on a square flat grid, which initially has the outline borders built up. Rainbow Dash and Fluttershy have flat square blocks with size 1×1, Rainbow Dash has an infinite amount of light blue blocks, Fluttershy has an infinite amount of yellow blocks.
The blocks are placed according to the following rule: each newly placed block must touch the built on the previous turns figure by a side (note that the outline borders of the grid are built initially). At each turn, one pony can place any number of blocks of her color according to the game rules.
Rainbow and Fluttershy have found out that they can build patterns on the grid of the game that way. They have decided to start with something simple, so they made up their mind to place the blocks to form a chess coloring. Rainbow Dash is well-known for her speed, so she is interested in the minimum number of turns she and Fluttershy need to do to get a chess coloring, covering the whole grid with blocks. Please help her find that number!
Since the ponies can play many times on different boards, Rainbow Dash asks you to find the minimum numbers of turns for several grids of the games.
The chess coloring in two colors is the one in which each square is neighbor by side only with squares of different colors.
Input
The first line contains a single integer T (1 ≤ T ≤ 100): the number of grids of the games.
Each of the next T lines contains a single integer n (1 ≤ n ≤ 10^9): the size of the side of the grid of the game.
Output
For each grid of the game print the minimum number of turns required to build a chess coloring pattern out of blocks on it.
Example
Input
2
3
4
Output
2
3
Note
For 3×3 grid ponies can make two following moves: <image> | instruction | 0 | 24,958 | 15 | 49,916 |
Tags: greedy, math
Correct Solution:
```
# The question isn't who is doing to let me, it's who is going to stop me. Ayn Rand
# by : Blue Edge - Create some chaos
for _ in range(int(input())):
n=int(input())
print(n//2 + 1)
``` | output | 1 | 24,958 | 15 | 49,917 |
Provide tags and a correct Python 3 solution for this coding contest problem.
One evening Rainbow Dash and Fluttershy have come up with a game. Since the ponies are friends, they have decided not to compete in the game but to pursue a common goal.
The game starts on a square flat grid, which initially has the outline borders built up. Rainbow Dash and Fluttershy have flat square blocks with size 1×1, Rainbow Dash has an infinite amount of light blue blocks, Fluttershy has an infinite amount of yellow blocks.
The blocks are placed according to the following rule: each newly placed block must touch the built on the previous turns figure by a side (note that the outline borders of the grid are built initially). At each turn, one pony can place any number of blocks of her color according to the game rules.
Rainbow and Fluttershy have found out that they can build patterns on the grid of the game that way. They have decided to start with something simple, so they made up their mind to place the blocks to form a chess coloring. Rainbow Dash is well-known for her speed, so she is interested in the minimum number of turns she and Fluttershy need to do to get a chess coloring, covering the whole grid with blocks. Please help her find that number!
Since the ponies can play many times on different boards, Rainbow Dash asks you to find the minimum numbers of turns for several grids of the games.
The chess coloring in two colors is the one in which each square is neighbor by side only with squares of different colors.
Input
The first line contains a single integer T (1 ≤ T ≤ 100): the number of grids of the games.
Each of the next T lines contains a single integer n (1 ≤ n ≤ 10^9): the size of the side of the grid of the game.
Output
For each grid of the game print the minimum number of turns required to build a chess coloring pattern out of blocks on it.
Example
Input
2
3
4
Output
2
3
Note
For 3×3 grid ponies can make two following moves: <image> | instruction | 0 | 24,959 | 15 | 49,918 |
Tags: greedy, math
Correct Solution:
```
n = input()
a = []
for i in range(int(n)):
tmp = input()
a.append(int(tmp))
for i in a:
ans = i // 2 + 1
print(ans)
``` | output | 1 | 24,959 | 15 | 49,919 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One evening Rainbow Dash and Fluttershy have come up with a game. Since the ponies are friends, they have decided not to compete in the game but to pursue a common goal.
The game starts on a square flat grid, which initially has the outline borders built up. Rainbow Dash and Fluttershy have flat square blocks with size 1×1, Rainbow Dash has an infinite amount of light blue blocks, Fluttershy has an infinite amount of yellow blocks.
The blocks are placed according to the following rule: each newly placed block must touch the built on the previous turns figure by a side (note that the outline borders of the grid are built initially). At each turn, one pony can place any number of blocks of her color according to the game rules.
Rainbow and Fluttershy have found out that they can build patterns on the grid of the game that way. They have decided to start with something simple, so they made up their mind to place the blocks to form a chess coloring. Rainbow Dash is well-known for her speed, so she is interested in the minimum number of turns she and Fluttershy need to do to get a chess coloring, covering the whole grid with blocks. Please help her find that number!
Since the ponies can play many times on different boards, Rainbow Dash asks you to find the minimum numbers of turns for several grids of the games.
The chess coloring in two colors is the one in which each square is neighbor by side only with squares of different colors.
Input
The first line contains a single integer T (1 ≤ T ≤ 100): the number of grids of the games.
Each of the next T lines contains a single integer n (1 ≤ n ≤ 10^9): the size of the side of the grid of the game.
Output
For each grid of the game print the minimum number of turns required to build a chess coloring pattern out of blocks on it.
Example
Input
2
3
4
Output
2
3
Note
For 3×3 grid ponies can make two following moves: <image>
Submitted Solution:
```
numOfGrid=int(input())
sideList=[]
for i in range(numOfGrid):
sideList.append(int(input()))
for i in sideList:
print(i//2 + 1)
``` | instruction | 0 | 24,960 | 15 | 49,920 |
Yes | output | 1 | 24,960 | 15 | 49,921 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One evening Rainbow Dash and Fluttershy have come up with a game. Since the ponies are friends, they have decided not to compete in the game but to pursue a common goal.
The game starts on a square flat grid, which initially has the outline borders built up. Rainbow Dash and Fluttershy have flat square blocks with size 1×1, Rainbow Dash has an infinite amount of light blue blocks, Fluttershy has an infinite amount of yellow blocks.
The blocks are placed according to the following rule: each newly placed block must touch the built on the previous turns figure by a side (note that the outline borders of the grid are built initially). At each turn, one pony can place any number of blocks of her color according to the game rules.
Rainbow and Fluttershy have found out that they can build patterns on the grid of the game that way. They have decided to start with something simple, so they made up their mind to place the blocks to form a chess coloring. Rainbow Dash is well-known for her speed, so she is interested in the minimum number of turns she and Fluttershy need to do to get a chess coloring, covering the whole grid with blocks. Please help her find that number!
Since the ponies can play many times on different boards, Rainbow Dash asks you to find the minimum numbers of turns for several grids of the games.
The chess coloring in two colors is the one in which each square is neighbor by side only with squares of different colors.
Input
The first line contains a single integer T (1 ≤ T ≤ 100): the number of grids of the games.
Each of the next T lines contains a single integer n (1 ≤ n ≤ 10^9): the size of the side of the grid of the game.
Output
For each grid of the game print the minimum number of turns required to build a chess coloring pattern out of blocks on it.
Example
Input
2
3
4
Output
2
3
Note
For 3×3 grid ponies can make two following moves: <image>
Submitted Solution:
```
t= int(input())
for i in range(0,t):
n=int(input())
ans=int(n/2 +1)
print(ans)
``` | instruction | 0 | 24,962 | 15 | 49,924 |
Yes | output | 1 | 24,962 | 15 | 49,925 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One evening Rainbow Dash and Fluttershy have come up with a game. Since the ponies are friends, they have decided not to compete in the game but to pursue a common goal.
The game starts on a square flat grid, which initially has the outline borders built up. Rainbow Dash and Fluttershy have flat square blocks with size 1×1, Rainbow Dash has an infinite amount of light blue blocks, Fluttershy has an infinite amount of yellow blocks.
The blocks are placed according to the following rule: each newly placed block must touch the built on the previous turns figure by a side (note that the outline borders of the grid are built initially). At each turn, one pony can place any number of blocks of her color according to the game rules.
Rainbow and Fluttershy have found out that they can build patterns on the grid of the game that way. They have decided to start with something simple, so they made up their mind to place the blocks to form a chess coloring. Rainbow Dash is well-known for her speed, so she is interested in the minimum number of turns she and Fluttershy need to do to get a chess coloring, covering the whole grid with blocks. Please help her find that number!
Since the ponies can play many times on different boards, Rainbow Dash asks you to find the minimum numbers of turns for several grids of the games.
The chess coloring in two colors is the one in which each square is neighbor by side only with squares of different colors.
Input
The first line contains a single integer T (1 ≤ T ≤ 100): the number of grids of the games.
Each of the next T lines contains a single integer n (1 ≤ n ≤ 10^9): the size of the side of the grid of the game.
Output
For each grid of the game print the minimum number of turns required to build a chess coloring pattern out of blocks on it.
Example
Input
2
3
4
Output
2
3
Note
For 3×3 grid ponies can make two following moves: <image>
Submitted Solution:
```
import math
t = int(input())
while(t>0):
n = int(input())
print(math.floor(n/2)+1)
t-=1
``` | instruction | 0 | 24,963 | 15 | 49,926 |
Yes | output | 1 | 24,963 | 15 | 49,927 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One evening Rainbow Dash and Fluttershy have come up with a game. Since the ponies are friends, they have decided not to compete in the game but to pursue a common goal.
The game starts on a square flat grid, which initially has the outline borders built up. Rainbow Dash and Fluttershy have flat square blocks with size 1×1, Rainbow Dash has an infinite amount of light blue blocks, Fluttershy has an infinite amount of yellow blocks.
The blocks are placed according to the following rule: each newly placed block must touch the built on the previous turns figure by a side (note that the outline borders of the grid are built initially). At each turn, one pony can place any number of blocks of her color according to the game rules.
Rainbow and Fluttershy have found out that they can build patterns on the grid of the game that way. They have decided to start with something simple, so they made up their mind to place the blocks to form a chess coloring. Rainbow Dash is well-known for her speed, so she is interested in the minimum number of turns she and Fluttershy need to do to get a chess coloring, covering the whole grid with blocks. Please help her find that number!
Since the ponies can play many times on different boards, Rainbow Dash asks you to find the minimum numbers of turns for several grids of the games.
The chess coloring in two colors is the one in which each square is neighbor by side only with squares of different colors.
Input
The first line contains a single integer T (1 ≤ T ≤ 100): the number of grids of the games.
Each of the next T lines contains a single integer n (1 ≤ n ≤ 10^9): the size of the side of the grid of the game.
Output
For each grid of the game print the minimum number of turns required to build a chess coloring pattern out of blocks on it.
Example
Input
2
3
4
Output
2
3
Note
For 3×3 grid ponies can make two following moves: <image>
Submitted Solution:
```
t=int(input())
while(t>0):
# print("______")
n = int(input())
print(n-1)
t-=1;
``` | instruction | 0 | 24,964 | 15 | 49,928 |
No | output | 1 | 24,964 | 15 | 49,929 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One evening Rainbow Dash and Fluttershy have come up with a game. Since the ponies are friends, they have decided not to compete in the game but to pursue a common goal.
The game starts on a square flat grid, which initially has the outline borders built up. Rainbow Dash and Fluttershy have flat square blocks with size 1×1, Rainbow Dash has an infinite amount of light blue blocks, Fluttershy has an infinite amount of yellow blocks.
The blocks are placed according to the following rule: each newly placed block must touch the built on the previous turns figure by a side (note that the outline borders of the grid are built initially). At each turn, one pony can place any number of blocks of her color according to the game rules.
Rainbow and Fluttershy have found out that they can build patterns on the grid of the game that way. They have decided to start with something simple, so they made up their mind to place the blocks to form a chess coloring. Rainbow Dash is well-known for her speed, so she is interested in the minimum number of turns she and Fluttershy need to do to get a chess coloring, covering the whole grid with blocks. Please help her find that number!
Since the ponies can play many times on different boards, Rainbow Dash asks you to find the minimum numbers of turns for several grids of the games.
The chess coloring in two colors is the one in which each square is neighbor by side only with squares of different colors.
Input
The first line contains a single integer T (1 ≤ T ≤ 100): the number of grids of the games.
Each of the next T lines contains a single integer n (1 ≤ n ≤ 10^9): the size of the side of the grid of the game.
Output
For each grid of the game print the minimum number of turns required to build a chess coloring pattern out of blocks on it.
Example
Input
2
3
4
Output
2
3
Note
For 3×3 grid ponies can make two following moves: <image>
Submitted Solution:
```
for i in range(int(input())):
n=int(input())
if n==1:
print(1)
elif n%2!=0:
print(n+1//2)
else:
print(n//2+1)
``` | instruction | 0 | 24,965 | 15 | 49,930 |
No | output | 1 | 24,965 | 15 | 49,931 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One evening Rainbow Dash and Fluttershy have come up with a game. Since the ponies are friends, they have decided not to compete in the game but to pursue a common goal.
The game starts on a square flat grid, which initially has the outline borders built up. Rainbow Dash and Fluttershy have flat square blocks with size 1×1, Rainbow Dash has an infinite amount of light blue blocks, Fluttershy has an infinite amount of yellow blocks.
The blocks are placed according to the following rule: each newly placed block must touch the built on the previous turns figure by a side (note that the outline borders of the grid are built initially). At each turn, one pony can place any number of blocks of her color according to the game rules.
Rainbow and Fluttershy have found out that they can build patterns on the grid of the game that way. They have decided to start with something simple, so they made up their mind to place the blocks to form a chess coloring. Rainbow Dash is well-known for her speed, so she is interested in the minimum number of turns she and Fluttershy need to do to get a chess coloring, covering the whole grid with blocks. Please help her find that number!
Since the ponies can play many times on different boards, Rainbow Dash asks you to find the minimum numbers of turns for several grids of the games.
The chess coloring in two colors is the one in which each square is neighbor by side only with squares of different colors.
Input
The first line contains a single integer T (1 ≤ T ≤ 100): the number of grids of the games.
Each of the next T lines contains a single integer n (1 ≤ n ≤ 10^9): the size of the side of the grid of the game.
Output
For each grid of the game print the minimum number of turns required to build a chess coloring pattern out of blocks on it.
Example
Input
2
3
4
Output
2
3
Note
For 3×3 grid ponies can make two following moves: <image>
Submitted Solution:
```
from math import ceil
def solve(n):
c = 0
if(n==1):
print(1)
return
if(n&1):
print(2+n//2)
else:
print(1+n//2)
return
for _ in range(int(input())):
# c,r = map(int,input().split())
n = int(input())
# arr = list(map(int,input().split()))
solve(n)
``` | instruction | 0 | 24,967 | 15 | 49,934 |
No | output | 1 | 24,967 | 15 | 49,935 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alice and Bob love playing one-dimensional battle ships. They play on the field in the form of a line consisting of n square cells (that is, on a 1 × n table).
At the beginning of the game Alice puts k ships on the field without telling their positions to Bob. Each ship looks as a 1 × a rectangle (that is, it occupies a sequence of a consecutive squares of the field). The ships cannot intersect and even touch each other.
After that Bob makes a sequence of "shots". He names cells of the field and Alice either says that the cell is empty ("miss"), or that the cell belongs to some ship ("hit").
But here's the problem! Alice like to cheat. May be that is why she responds to each Bob's move with a "miss".
Help Bob catch Alice cheating — find Bob's first move, such that after it you can be sure that Alice cheated.
Input
The first line of the input contains three integers: n, k and a (1 ≤ n, k, a ≤ 2·105) — the size of the field, the number of the ships and the size of each ship. It is guaranteed that the n, k and a are such that you can put k ships of size a on the field, so that no two ships intersect or touch each other.
The second line contains integer m (1 ≤ m ≤ n) — the number of Bob's moves.
The third line contains m distinct integers x1, x2, ..., xm, where xi is the number of the cell where Bob made the i-th shot. The cells are numbered from left to right from 1 to n.
Output
Print a single integer — the number of such Bob's first move, after which you can be sure that Alice lied. Bob's moves are numbered from 1 to m in the order the were made. If the sought move doesn't exist, then print "-1".
Examples
Input
11 3 3
5
4 8 6 1 11
Output
3
Input
5 1 3
2
1 5
Output
-1
Input
5 1 3
1
3
Output
1 | instruction | 0 | 25,146 | 15 | 50,292 |
Tags: binary search, data structures, greedy, sortings
Correct Solution:
```
import sys
def minp():
return sys.stdin.readline().strip()
def mint():
return int(minp())
def mints():
return map(int, minp().split())
def solve():
n, k, a = mints()
a += 1
m = mint()
x = list(mints())
l = 0
r = m + 1
while r - l > 1:
c = (l + r) // 2
b = x[:c]
b.sort()
last = 0
cnt = 0
for i in b:
if i != last:
cnt += (i-last) // a
last = i
cnt += (n+1-last)//a
if cnt < k:
r = c
else:
l = c
if r == m + 1:
r = -1
print(r)
solve()
``` | output | 1 | 25,146 | 15 | 50,293 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alice and Bob love playing one-dimensional battle ships. They play on the field in the form of a line consisting of n square cells (that is, on a 1 × n table).
At the beginning of the game Alice puts k ships on the field without telling their positions to Bob. Each ship looks as a 1 × a rectangle (that is, it occupies a sequence of a consecutive squares of the field). The ships cannot intersect and even touch each other.
After that Bob makes a sequence of "shots". He names cells of the field and Alice either says that the cell is empty ("miss"), or that the cell belongs to some ship ("hit").
But here's the problem! Alice like to cheat. May be that is why she responds to each Bob's move with a "miss".
Help Bob catch Alice cheating — find Bob's first move, such that after it you can be sure that Alice cheated.
Input
The first line of the input contains three integers: n, k and a (1 ≤ n, k, a ≤ 2·105) — the size of the field, the number of the ships and the size of each ship. It is guaranteed that the n, k and a are such that you can put k ships of size a on the field, so that no two ships intersect or touch each other.
The second line contains integer m (1 ≤ m ≤ n) — the number of Bob's moves.
The third line contains m distinct integers x1, x2, ..., xm, where xi is the number of the cell where Bob made the i-th shot. The cells are numbered from left to right from 1 to n.
Output
Print a single integer — the number of such Bob's first move, after which you can be sure that Alice lied. Bob's moves are numbered from 1 to m in the order the were made. If the sought move doesn't exist, then print "-1".
Examples
Input
11 3 3
5
4 8 6 1 11
Output
3
Input
5 1 3
2
1 5
Output
-1
Input
5 1 3
1
3
Output
1 | instruction | 0 | 25,147 | 15 | 50,294 |
Tags: binary search, data structures, greedy, sortings
Correct Solution:
```
n,k,a = map(int,input().split())
m = int(input())
x = [int(y) for y in input().split()]
def check(K):
used = [0]*(n+1)
for i in range(K):
used[x[i]] = 1
for i in range(1,n+1):
used[i]+=used[i-1]
have = 0
i = a
while i<n+1:
if used[i]-used[i-a]==0:
have+=1
i+=a
i+=1
return have>=k
if check(m):
print(-1)
else:
low = -1
high = m
while high-low>1:
if check((low+high+1)//2):
low = (low+high+1)//2
else:
high = (low+high+1)//2
print(high)
``` | output | 1 | 25,147 | 15 | 50,295 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alice and Bob love playing one-dimensional battle ships. They play on the field in the form of a line consisting of n square cells (that is, on a 1 × n table).
At the beginning of the game Alice puts k ships on the field without telling their positions to Bob. Each ship looks as a 1 × a rectangle (that is, it occupies a sequence of a consecutive squares of the field). The ships cannot intersect and even touch each other.
After that Bob makes a sequence of "shots". He names cells of the field and Alice either says that the cell is empty ("miss"), or that the cell belongs to some ship ("hit").
But here's the problem! Alice like to cheat. May be that is why she responds to each Bob's move with a "miss".
Help Bob catch Alice cheating — find Bob's first move, such that after it you can be sure that Alice cheated.
Input
The first line of the input contains three integers: n, k and a (1 ≤ n, k, a ≤ 2·105) — the size of the field, the number of the ships and the size of each ship. It is guaranteed that the n, k and a are such that you can put k ships of size a on the field, so that no two ships intersect or touch each other.
The second line contains integer m (1 ≤ m ≤ n) — the number of Bob's moves.
The third line contains m distinct integers x1, x2, ..., xm, where xi is the number of the cell where Bob made the i-th shot. The cells are numbered from left to right from 1 to n.
Output
Print a single integer — the number of such Bob's first move, after which you can be sure that Alice lied. Bob's moves are numbered from 1 to m in the order the were made. If the sought move doesn't exist, then print "-1".
Examples
Input
11 3 3
5
4 8 6 1 11
Output
3
Input
5 1 3
2
1 5
Output
-1
Input
5 1 3
1
3
Output
1 | instruction | 0 | 25,148 | 15 | 50,296 |
Tags: binary search, data structures, greedy, sortings
Correct Solution:
```
n,k,b = map(int,input().split())
m = int(input())+1
b += 1
a = list(map(int,input().split()))
l,r = 0,m
while r-l > 1:
d = (l+r)//2
c = sorted(a[:d])
if sum([(p-q)//b for q,p in zip([0]+c,c+[n+1])]) >= k:
l = d
else:
r = d
print(r%m-(r==m))
``` | output | 1 | 25,148 | 15 | 50,297 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alice and Bob love playing one-dimensional battle ships. They play on the field in the form of a line consisting of n square cells (that is, on a 1 × n table).
At the beginning of the game Alice puts k ships on the field without telling their positions to Bob. Each ship looks as a 1 × a rectangle (that is, it occupies a sequence of a consecutive squares of the field). The ships cannot intersect and even touch each other.
After that Bob makes a sequence of "shots". He names cells of the field and Alice either says that the cell is empty ("miss"), or that the cell belongs to some ship ("hit").
But here's the problem! Alice like to cheat. May be that is why she responds to each Bob's move with a "miss".
Help Bob catch Alice cheating — find Bob's first move, such that after it you can be sure that Alice cheated.
Input
The first line of the input contains three integers: n, k and a (1 ≤ n, k, a ≤ 2·105) — the size of the field, the number of the ships and the size of each ship. It is guaranteed that the n, k and a are such that you can put k ships of size a on the field, so that no two ships intersect or touch each other.
The second line contains integer m (1 ≤ m ≤ n) — the number of Bob's moves.
The third line contains m distinct integers x1, x2, ..., xm, where xi is the number of the cell where Bob made the i-th shot. The cells are numbered from left to right from 1 to n.
Output
Print a single integer — the number of such Bob's first move, after which you can be sure that Alice lied. Bob's moves are numbered from 1 to m in the order the were made. If the sought move doesn't exist, then print "-1".
Examples
Input
11 3 3
5
4 8 6 1 11
Output
3
Input
5 1 3
2
1 5
Output
-1
Input
5 1 3
1
3
Output
1 | instruction | 0 | 25,149 | 15 | 50,298 |
Tags: binary search, data structures, greedy, sortings
Correct Solution:
```
import math
import heapq,bisect
import sys
from collections import deque
from fractions import Fraction
# ------------------------------warmup----------------------------
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")
# -------------------game starts now----------------------------------------------------import math
class SegmentTree:
def __init__(self, data, default=0, func=lambda a, b: a + b):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
#-------------------------------iye ha chutiya zindegi-------------------------------------
class Factorial:
def __init__(self, MOD):
self.MOD = MOD
self.factorials = [1, 1]
self.invModulos = [0, 1]
self.invFactorial_ = [1, 1]
def calc(self, n):
if n <= -1:
print("Invalid argument to calculate n!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.factorials):
return self.factorials[n]
nextArr = [0] * (n + 1 - len(self.factorials))
initialI = len(self.factorials)
prev = self.factorials[-1]
m = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = prev * i % m
self.factorials += nextArr
return self.factorials[n]
def inv(self, n):
if n <= -1:
print("Invalid argument to calculate n^(-1)")
print("n must be non-negative value. But the argument was " + str(n))
exit()
p = self.MOD
pi = n % p
if pi < len(self.invModulos):
return self.invModulos[pi]
nextArr = [0] * (n + 1 - len(self.invModulos))
initialI = len(self.invModulos)
for i in range(initialI, min(p, n + 1)):
next = -self.invModulos[p % i] * (p // i) % p
self.invModulos.append(next)
return self.invModulos[pi]
def invFactorial(self, n):
if n <= -1:
print("Invalid argument to calculate (n^(-1))!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.invFactorial_):
return self.invFactorial_[n]
self.inv(n) # To make sure already calculated n^-1
nextArr = [0] * (n + 1 - len(self.invFactorial_))
initialI = len(self.invFactorial_)
prev = self.invFactorial_[-1]
p = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = (prev * self.invModulos[i % p]) % p
self.invFactorial_ += nextArr
return self.invFactorial_[n]
class Combination:
def __init__(self, MOD):
self.MOD = MOD
self.factorial = Factorial(MOD)
def ncr(self, n, k):
if k < 0 or n < k:
return 0
k = min(k, n - k)
f = self.factorial
return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD
#--------------------------------------iye ha combinations ka zindegi---------------------------------
def powm(a, n, m):
if a == 1 or n == 0:
return 1
if n % 2 == 0:
s = powm(a, n // 2, m)
return s * s % m
else:
return a * powm(a, n - 1, m) % m
#--------------------------------------iye ha power ka zindegi---------------------------------
def sort_list(list1, list2):
zipped_pairs = zip(list2, list1)
z = [x for _, x in sorted(zipped_pairs)]
return z
#--------------------------------------------------product----------------------------------------
def product(l):
por=1
for i in range(len(l)):
por*=l[i]
return por
#--------------------------------------------------binary----------------------------------------
def binarySearchCount(arr, n, key):
left = 0
right = n - 1
count = 0
while (left <= right):
mid = int((right + left) / 2)
# Check if middle element is
# less than or equal to key
if (arr[mid] <= key):
# At least (mid + 1) elements are there
# whose values are less than
# or equal to key
count = mid + 1
left = mid + 1
# If key is smaller, ignore right half
else:
right = mid - 1
return count
#--------------------------------------------------binary----------------------------------------
def countGreater(arr, n, k):
l = 0
r = n - 1
# Stores the index of the left most element
# from the array which is greater than k
leftGreater = n
# Finds number of elements greater than k
while (l <= r):
m = int(l + (r - l) / 2)
# If mid element is greater than
# k update leftGreater and r
if (arr[m] > k):
leftGreater = m
r = m - 1
# If mid element is less than
# or equal to k update l
else:
l = m + 1
# Return the count of elements
# greater than k
return (n - leftGreater)
#--------------------------------------------------binary----------------------------------------
n,m,k=map(int,input().split())
r=int(input())
l=list(map(int,input().split()))
st=1
end=r
cout=-1
while(st<=end):
mid=(st+end)//2
y=sorted(l[:mid])
stw=1
cur=0
#print(y,mid)
for i in range(mid):
#print(k,stw,y[i])
cur+=(y[i]-1-stw+2)//(k+1)
stw=y[i]+1
#print(cur)
cur+=(n-stw+2)//(k+1)
#print(cur)
if cur<m:
cout=mid
end=mid-1
else:
st=mid+1
print(cout)
``` | output | 1 | 25,149 | 15 | 50,299 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alice and Bob love playing one-dimensional battle ships. They play on the field in the form of a line consisting of n square cells (that is, on a 1 × n table).
At the beginning of the game Alice puts k ships on the field without telling their positions to Bob. Each ship looks as a 1 × a rectangle (that is, it occupies a sequence of a consecutive squares of the field). The ships cannot intersect and even touch each other.
After that Bob makes a sequence of "shots". He names cells of the field and Alice either says that the cell is empty ("miss"), or that the cell belongs to some ship ("hit").
But here's the problem! Alice like to cheat. May be that is why she responds to each Bob's move with a "miss".
Help Bob catch Alice cheating — find Bob's first move, such that after it you can be sure that Alice cheated.
Input
The first line of the input contains three integers: n, k and a (1 ≤ n, k, a ≤ 2·105) — the size of the field, the number of the ships and the size of each ship. It is guaranteed that the n, k and a are such that you can put k ships of size a on the field, so that no two ships intersect or touch each other.
The second line contains integer m (1 ≤ m ≤ n) — the number of Bob's moves.
The third line contains m distinct integers x1, x2, ..., xm, where xi is the number of the cell where Bob made the i-th shot. The cells are numbered from left to right from 1 to n.
Output
Print a single integer — the number of such Bob's first move, after which you can be sure that Alice lied. Bob's moves are numbered from 1 to m in the order the were made. If the sought move doesn't exist, then print "-1".
Examples
Input
11 3 3
5
4 8 6 1 11
Output
3
Input
5 1 3
2
1 5
Output
-1
Input
5 1 3
1
3
Output
1 | instruction | 0 | 25,150 | 15 | 50,300 |
Tags: binary search, data structures, greedy, sortings
Correct Solution:
```
import math
from bisect import bisect_right, bisect_left
from collections import Counter, defaultdict
from heapq import heappop, heappush
from itertools import accumulate
R = lambda: map(int, input().split())
mm, k, a = R()
junk = int(input())
arr = list(R())
l, r = 0, len(arr)
while l < r:
m = (l + r) // 2
tarr = [0] + sorted(arr[:m + 1]) + [mm + 1]
cnt = 0
for i in range(1, len(tarr)):
cnt += (tarr[i] - tarr[i - 1]) // (a + 1)
if cnt < k:
r = m
else:
l = m + 1
print(l + 1 if l < len(arr) else -1)
``` | output | 1 | 25,150 | 15 | 50,301 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alice and Bob love playing one-dimensional battle ships. They play on the field in the form of a line consisting of n square cells (that is, on a 1 × n table).
At the beginning of the game Alice puts k ships on the field without telling their positions to Bob. Each ship looks as a 1 × a rectangle (that is, it occupies a sequence of a consecutive squares of the field). The ships cannot intersect and even touch each other.
After that Bob makes a sequence of "shots". He names cells of the field and Alice either says that the cell is empty ("miss"), or that the cell belongs to some ship ("hit").
But here's the problem! Alice like to cheat. May be that is why she responds to each Bob's move with a "miss".
Help Bob catch Alice cheating — find Bob's first move, such that after it you can be sure that Alice cheated.
Input
The first line of the input contains three integers: n, k and a (1 ≤ n, k, a ≤ 2·105) — the size of the field, the number of the ships and the size of each ship. It is guaranteed that the n, k and a are such that you can put k ships of size a on the field, so that no two ships intersect or touch each other.
The second line contains integer m (1 ≤ m ≤ n) — the number of Bob's moves.
The third line contains m distinct integers x1, x2, ..., xm, where xi is the number of the cell where Bob made the i-th shot. The cells are numbered from left to right from 1 to n.
Output
Print a single integer — the number of such Bob's first move, after which you can be sure that Alice lied. Bob's moves are numbered from 1 to m in the order the were made. If the sought move doesn't exist, then print "-1".
Examples
Input
11 3 3
5
4 8 6 1 11
Output
3
Input
5 1 3
2
1 5
Output
-1
Input
5 1 3
1
3
Output
1 | instruction | 0 | 25,151 | 15 | 50,302 |
Tags: binary search, data structures, greedy, sortings
Correct Solution:
```
n,k,a=map(int,input().split())
m=int(input())+1
x=list(map(int,input().split()))+[0]
l,r=0,m
while r-l>1:
d=(l+r)//2
y=sorted(x[:d])
if sum((q-p)//(a+1) for p,q in zip([0]+y,y+[n+1]))>=k:l=d
else:r=d
print(r%m-(r==m))
``` | output | 1 | 25,151 | 15 | 50,303 |
Provide a correct Python 3 solution for this coding contest problem.
There are K items placed on a grid of squares with R rows and C columns. Let (i, j) denote the square at the i-th row (1 \leq i \leq R) and the j-th column (1 \leq j \leq C). The i-th item is at (r_i, c_i) and has the value v_i.
Takahashi will begin at (1, 1), the start, and get to (R, C), the goal. When he is at (i, j), he can move to (i + 1, j) or (i, j + 1) (but cannot move to a non-existent square).
He can pick up items on the squares he visits, including the start and the goal, but at most three for each row. It is allowed to ignore the item on a square he visits.
Find the maximum possible sum of the values of items he picks up.
Constraints
* 1 \leq R, C \leq 3000
* 1 \leq K \leq \min(2 \times 10^5, R \times C)
* 1 \leq r_i \leq R
* 1 \leq c_i \leq C
* (r_i, c_i) \neq (r_j, c_j) (i \neq j)
* 1 \leq v_i \leq 10^9
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
R C K
r_1 c_1 v_1
r_2 c_2 v_2
:
r_K c_K v_K
Output
Print the maximum possible sum of the values of items Takahashi picks up.
Examples
Input
2 2 3
1 1 3
2 1 4
1 2 5
Output
8
Input
2 5 5
1 1 3
2 4 20
1 2 1
1 3 4
1 4 2
Output
29
Input
4 5 10
2 5 12
1 5 12
2 3 15
1 2 20
1 1 28
2 4 26
3 2 27
4 5 21
3 5 10
1 3 10
Output
142 | instruction | 0 | 25,321 | 15 | 50,642 |
"Correct Solution:
```
ma = lambda :map(int,input().split())
lma = lambda :list(map(int,input().split()))
tma = lambda :tuple(map(int,input().split()))
ni = lambda:int(input())
yn = lambda fl:print("Yes") if fl else print("No")
import collections
import math
import itertools
import heapq as hq
R,C,K = ma()
V = [[0 for i in range(R+1)] for j in range(C+1)]
for i in range(K):
r,c,v = ma()
V[c][r] = v
dp_prev = [[0]*4 for i in range(C+1)]
dp_nex = [[0]*4 for i in range(C+1)] #dp[h][k] h列目でmax kこまで選んだ時の最大値
for r in range(1,R+1):
for c in range(1,C+1):
v = V[c][r]
for k in range(4):
if k==0:
dp_nex[c][0] = max(dp_prev[c][3],dp_nex[c-1][0])
elif k >0:
dp_nex[c][k] = max(dp_nex[c-1][k],dp_nex[c-1][k-1]+v,dp_prev[c][3]+v)
dp_prev,dp_nex = dp_nex,dp_prev
#print(dp_prev)
print(dp_prev[C][3])
``` | output | 1 | 25,321 | 15 | 50,643 |
Provide a correct Python 3 solution for this coding contest problem.
There are K items placed on a grid of squares with R rows and C columns. Let (i, j) denote the square at the i-th row (1 \leq i \leq R) and the j-th column (1 \leq j \leq C). The i-th item is at (r_i, c_i) and has the value v_i.
Takahashi will begin at (1, 1), the start, and get to (R, C), the goal. When he is at (i, j), he can move to (i + 1, j) or (i, j + 1) (but cannot move to a non-existent square).
He can pick up items on the squares he visits, including the start and the goal, but at most three for each row. It is allowed to ignore the item on a square he visits.
Find the maximum possible sum of the values of items he picks up.
Constraints
* 1 \leq R, C \leq 3000
* 1 \leq K \leq \min(2 \times 10^5, R \times C)
* 1 \leq r_i \leq R
* 1 \leq c_i \leq C
* (r_i, c_i) \neq (r_j, c_j) (i \neq j)
* 1 \leq v_i \leq 10^9
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
R C K
r_1 c_1 v_1
r_2 c_2 v_2
:
r_K c_K v_K
Output
Print the maximum possible sum of the values of items Takahashi picks up.
Examples
Input
2 2 3
1 1 3
2 1 4
1 2 5
Output
8
Input
2 5 5
1 1 3
2 4 20
1 2 1
1 3 4
1 4 2
Output
29
Input
4 5 10
2 5 12
1 5 12
2 3 15
1 2 20
1 1 28
2 4 26
3 2 27
4 5 21
3 5 10
1 3 10
Output
142 | instruction | 0 | 25,322 | 15 | 50,644 |
"Correct Solution:
```
R, C, K = map(int, input().split())
xy = [[0] * (C + 1) for _ in range(R + 1)]
for _ in range(K) :
r, c, v = map(int, input().split())
xy[r - 1][c - 1] = v
dp = [[[0] * (C + 1) for _ in range(R + 1)] for _ in range(4)]
for cy in range(R + 1) :
for cx in range(C + 1) :
if cx < C :
dp[0][cy][cx + 1] = max(dp[0][cy][cx + 1], dp[0][cy][cx])
dp[1][cy][cx + 1] = max(dp[1][cy][cx + 1], dp[0][cy][cx] + xy[cy][cx], dp[1][cy][cx])
dp[2][cy][cx + 1] = max(dp[2][cy][cx + 1], dp[1][cy][cx] + xy[cy][cx], dp[2][cy][cx])
dp[3][cy][cx + 1] = max(dp[3][cy][cx + 1], dp[2][cy][cx] + xy[cy][cx], dp[3][cy][cx])
if cy < R :
dp[0][cy + 1][cx] = max(dp[i][cy][cx] for i in range(3)) + xy[cy][cx]
dp[0][cy + 1][cx] = max(dp[0][cy + 1][cx], dp[3][cy][cx])
print(max(dp[i][-1][-1] for i in range(4)))
``` | output | 1 | 25,322 | 15 | 50,645 |
Provide a correct Python 3 solution for this coding contest problem.
There are K items placed on a grid of squares with R rows and C columns. Let (i, j) denote the square at the i-th row (1 \leq i \leq R) and the j-th column (1 \leq j \leq C). The i-th item is at (r_i, c_i) and has the value v_i.
Takahashi will begin at (1, 1), the start, and get to (R, C), the goal. When he is at (i, j), he can move to (i + 1, j) or (i, j + 1) (but cannot move to a non-existent square).
He can pick up items on the squares he visits, including the start and the goal, but at most three for each row. It is allowed to ignore the item on a square he visits.
Find the maximum possible sum of the values of items he picks up.
Constraints
* 1 \leq R, C \leq 3000
* 1 \leq K \leq \min(2 \times 10^5, R \times C)
* 1 \leq r_i \leq R
* 1 \leq c_i \leq C
* (r_i, c_i) \neq (r_j, c_j) (i \neq j)
* 1 \leq v_i \leq 10^9
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
R C K
r_1 c_1 v_1
r_2 c_2 v_2
:
r_K c_K v_K
Output
Print the maximum possible sum of the values of items Takahashi picks up.
Examples
Input
2 2 3
1 1 3
2 1 4
1 2 5
Output
8
Input
2 5 5
1 1 3
2 4 20
1 2 1
1 3 4
1 4 2
Output
29
Input
4 5 10
2 5 12
1 5 12
2 3 15
1 2 20
1 1 28
2 4 26
3 2 27
4 5 21
3 5 10
1 3 10
Output
142 | instruction | 0 | 25,323 | 15 | 50,646 |
"Correct Solution:
```
R,C,K=map(int,input().split())
l=[[0] * C for i in range(R)]
for i in range(K):
a,b,c=map(int,input().split())
a-=1
b-=1
l[a][b]=c
dp=[[0] * C for i in range(R)]
for i in range(R):
kdp=[0]*4
for j in range(C):
if i>0:
kdp[0]=max(kdp[0],dp[i-1][j])
for k in range(2,-1,-1):
kdp[k+1]=max(kdp[k+1],kdp[k]+l[i][j])
dp[i][j]=max(dp[i][j],kdp[k+1])
print(dp[R-1][C-1])
``` | output | 1 | 25,323 | 15 | 50,647 |
Provide a correct Python 3 solution for this coding contest problem.
There are K items placed on a grid of squares with R rows and C columns. Let (i, j) denote the square at the i-th row (1 \leq i \leq R) and the j-th column (1 \leq j \leq C). The i-th item is at (r_i, c_i) and has the value v_i.
Takahashi will begin at (1, 1), the start, and get to (R, C), the goal. When he is at (i, j), he can move to (i + 1, j) or (i, j + 1) (but cannot move to a non-existent square).
He can pick up items on the squares he visits, including the start and the goal, but at most three for each row. It is allowed to ignore the item on a square he visits.
Find the maximum possible sum of the values of items he picks up.
Constraints
* 1 \leq R, C \leq 3000
* 1 \leq K \leq \min(2 \times 10^5, R \times C)
* 1 \leq r_i \leq R
* 1 \leq c_i \leq C
* (r_i, c_i) \neq (r_j, c_j) (i \neq j)
* 1 \leq v_i \leq 10^9
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
R C K
r_1 c_1 v_1
r_2 c_2 v_2
:
r_K c_K v_K
Output
Print the maximum possible sum of the values of items Takahashi picks up.
Examples
Input
2 2 3
1 1 3
2 1 4
1 2 5
Output
8
Input
2 5 5
1 1 3
2 4 20
1 2 1
1 3 4
1 4 2
Output
29
Input
4 5 10
2 5 12
1 5 12
2 3 15
1 2 20
1 1 28
2 4 26
3 2 27
4 5 21
3 5 10
1 3 10
Output
142 | instruction | 0 | 25,324 | 15 | 50,648 |
"Correct Solution:
```
f,h=range,input
R,C,K=map(int,h().split())
l=lambda:[-~C*[0]for i in f(R+1)]
G=l()
for i in'_'*K:r,c,v=map(int,h().split());G[r][c]=v
F=[l()for i in f(4)]
for r in f(1,R+1):
for x in f(1,4):
for c in f(1,C+1):F[x][r][c]=max(F[x-1][r][c],max(F[x-1][r][c-1],(x<2)*F[3][r-1][c])+G[r][c],F[x][r][c-1])
print(F[3][R][C])
``` | output | 1 | 25,324 | 15 | 50,649 |
Provide a correct Python 3 solution for this coding contest problem.
There are K items placed on a grid of squares with R rows and C columns. Let (i, j) denote the square at the i-th row (1 \leq i \leq R) and the j-th column (1 \leq j \leq C). The i-th item is at (r_i, c_i) and has the value v_i.
Takahashi will begin at (1, 1), the start, and get to (R, C), the goal. When he is at (i, j), he can move to (i + 1, j) or (i, j + 1) (but cannot move to a non-existent square).
He can pick up items on the squares he visits, including the start and the goal, but at most three for each row. It is allowed to ignore the item on a square he visits.
Find the maximum possible sum of the values of items he picks up.
Constraints
* 1 \leq R, C \leq 3000
* 1 \leq K \leq \min(2 \times 10^5, R \times C)
* 1 \leq r_i \leq R
* 1 \leq c_i \leq C
* (r_i, c_i) \neq (r_j, c_j) (i \neq j)
* 1 \leq v_i \leq 10^9
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
R C K
r_1 c_1 v_1
r_2 c_2 v_2
:
r_K c_K v_K
Output
Print the maximum possible sum of the values of items Takahashi picks up.
Examples
Input
2 2 3
1 1 3
2 1 4
1 2 5
Output
8
Input
2 5 5
1 1 3
2 4 20
1 2 1
1 3 4
1 4 2
Output
29
Input
4 5 10
2 5 12
1 5 12
2 3 15
1 2 20
1 1 28
2 4 26
3 2 27
4 5 21
3 5 10
1 3 10
Output
142 | instruction | 0 | 25,325 | 15 | 50,650 |
"Correct Solution:
```
import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return map(int, input().split())
sys.setrecursionlimit(10**9)
R, C, K = mapint()
dp = [[[0]*C for _ in range(R)] for _ in range(4)]
from collections import defaultdict
dic = [[0]*C for _ in range(R)]
for _ in range(K):
r, c, v = mapint()
dic[r-1][c-1] = v
for r in range(R):
for c in range(C):
v = dic[r][c]
for i in range(4):
if c!=0:
dp[i][r][c] = dp[i][r][c-1]
if r!=0:
dp[0][r][c] = max(dp[0][r][c], dp[i][r-1][c])
for i in range(2, -1, -1):
dp[i+1][r][c] = max(dp[i+1][r][c], dp[i][r][c]+v)
ans = 0
for i in range(4):
ans = max(ans, dp[i][R-1][C-1])
print(ans)
``` | output | 1 | 25,325 | 15 | 50,651 |
Provide a correct Python 3 solution for this coding contest problem.
There are K items placed on a grid of squares with R rows and C columns. Let (i, j) denote the square at the i-th row (1 \leq i \leq R) and the j-th column (1 \leq j \leq C). The i-th item is at (r_i, c_i) and has the value v_i.
Takahashi will begin at (1, 1), the start, and get to (R, C), the goal. When he is at (i, j), he can move to (i + 1, j) or (i, j + 1) (but cannot move to a non-existent square).
He can pick up items on the squares he visits, including the start and the goal, but at most three for each row. It is allowed to ignore the item on a square he visits.
Find the maximum possible sum of the values of items he picks up.
Constraints
* 1 \leq R, C \leq 3000
* 1 \leq K \leq \min(2 \times 10^5, R \times C)
* 1 \leq r_i \leq R
* 1 \leq c_i \leq C
* (r_i, c_i) \neq (r_j, c_j) (i \neq j)
* 1 \leq v_i \leq 10^9
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
R C K
r_1 c_1 v_1
r_2 c_2 v_2
:
r_K c_K v_K
Output
Print the maximum possible sum of the values of items Takahashi picks up.
Examples
Input
2 2 3
1 1 3
2 1 4
1 2 5
Output
8
Input
2 5 5
1 1 3
2 4 20
1 2 1
1 3 4
1 4 2
Output
29
Input
4 5 10
2 5 12
1 5 12
2 3 15
1 2 20
1 1 28
2 4 26
3 2 27
4 5 21
3 5 10
1 3 10
Output
142 | instruction | 0 | 25,326 | 15 | 50,652 |
"Correct Solution:
```
# -*- coding: utf-8 -*-
R,C,K = map(int, input().split())
items = [[0 for _ in range(C+1)] for _ in range(R+1)]
for i in range(K):
r,c,v = map(int, input().split())
items[r][c] = v
DP_prev = [0 for _ in range(C+1)]
DP1 = [0 for _ in range(C+1)]
DP2 = [0 for _ in range(C+1)]
DP3 = [0 for _ in range(C+1)]
for r in range(1,R+1):
for c in range(1,C+1):
item = items[r][c]
DP1[c] = max(DP_prev[c]+item,DP1[c-1])
DP2[c] = max(DP1[c],DP2[c-1],DP1[c-1]+item)
DP3[c] = max(DP2[c],DP3[c-1],DP2[c-1]+item)
DP_prev = DP3
print(DP_prev[C])
``` | output | 1 | 25,326 | 15 | 50,653 |
Provide a correct Python 3 solution for this coding contest problem.
There are K items placed on a grid of squares with R rows and C columns. Let (i, j) denote the square at the i-th row (1 \leq i \leq R) and the j-th column (1 \leq j \leq C). The i-th item is at (r_i, c_i) and has the value v_i.
Takahashi will begin at (1, 1), the start, and get to (R, C), the goal. When he is at (i, j), he can move to (i + 1, j) or (i, j + 1) (but cannot move to a non-existent square).
He can pick up items on the squares he visits, including the start and the goal, but at most three for each row. It is allowed to ignore the item on a square he visits.
Find the maximum possible sum of the values of items he picks up.
Constraints
* 1 \leq R, C \leq 3000
* 1 \leq K \leq \min(2 \times 10^5, R \times C)
* 1 \leq r_i \leq R
* 1 \leq c_i \leq C
* (r_i, c_i) \neq (r_j, c_j) (i \neq j)
* 1 \leq v_i \leq 10^9
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
R C K
r_1 c_1 v_1
r_2 c_2 v_2
:
r_K c_K v_K
Output
Print the maximum possible sum of the values of items Takahashi picks up.
Examples
Input
2 2 3
1 1 3
2 1 4
1 2 5
Output
8
Input
2 5 5
1 1 3
2 4 20
1 2 1
1 3 4
1 4 2
Output
29
Input
4 5 10
2 5 12
1 5 12
2 3 15
1 2 20
1 1 28
2 4 26
3 2 27
4 5 21
3 5 10
1 3 10
Output
142 | instruction | 0 | 25,327 | 15 | 50,654 |
"Correct Solution:
```
def main():
import sys
input = sys.stdin.readline
r,c,k = map(int,input().split())
b = [[0 for _ in range(c)] for _ in range(r)]
for i in range(k):
y,x,v = map(int,input().split())
y -= 1
x -= 1
b[y][x] = v
# dp[j][l]:(i,j)に居て、i行目のアイテムをl個拾ったときの価値最大値。
dp = [[0 for _ in range(4)] for _ in range(c+1)]
for i in range(r):
for j in range(c):
# アイテムを拾う遷移。個数が多い方から計算する。
for l in range(2,-1,-1):
dp[j][l+1] = max(dp[j][l]+b[i][j],dp[j][l+1])
# 移動する遷移。行を移動する際は、拾ったアイテム数はリセットされる。
for l in range(4):
dp[j+1][l] = max(dp[j][l],dp[j+1][l])
dp[j][0] = max(dp[j][l],dp[j][0])
ans = 0
for i in range(4):
ans = max(dp[c-1][i],ans)
print(ans)
main()
``` | output | 1 | 25,327 | 15 | 50,655 |
Provide a correct Python 3 solution for this coding contest problem.
There are K items placed on a grid of squares with R rows and C columns. Let (i, j) denote the square at the i-th row (1 \leq i \leq R) and the j-th column (1 \leq j \leq C). The i-th item is at (r_i, c_i) and has the value v_i.
Takahashi will begin at (1, 1), the start, and get to (R, C), the goal. When he is at (i, j), he can move to (i + 1, j) or (i, j + 1) (but cannot move to a non-existent square).
He can pick up items on the squares he visits, including the start and the goal, but at most three for each row. It is allowed to ignore the item on a square he visits.
Find the maximum possible sum of the values of items he picks up.
Constraints
* 1 \leq R, C \leq 3000
* 1 \leq K \leq \min(2 \times 10^5, R \times C)
* 1 \leq r_i \leq R
* 1 \leq c_i \leq C
* (r_i, c_i) \neq (r_j, c_j) (i \neq j)
* 1 \leq v_i \leq 10^9
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
R C K
r_1 c_1 v_1
r_2 c_2 v_2
:
r_K c_K v_K
Output
Print the maximum possible sum of the values of items Takahashi picks up.
Examples
Input
2 2 3
1 1 3
2 1 4
1 2 5
Output
8
Input
2 5 5
1 1 3
2 4 20
1 2 1
1 3 4
1 4 2
Output
29
Input
4 5 10
2 5 12
1 5 12
2 3 15
1 2 20
1 1 28
2 4 26
3 2 27
4 5 21
3 5 10
1 3 10
Output
142 | instruction | 0 | 25,328 | 15 | 50,656 |
"Correct Solution:
```
R, C, K = map(int, input().split())
V = [[0]*(C+1) for _ in range(R+1)]
for _ in range(K):
r, c, v = map(int, input().split())
V[r][c] = v
max_pre = [0]*(C+1)
for i in range(R+1):
now = [[0]*(3+1) for _ in range(C+1)]
for j in range(C+1):
v = V[i][j]
la = lb = 0
if j > 0:
la = now[j-1][0]
lb = now[j-1][1]
now[j][2] = max(now[j][2], now[j-1][2], lb + v)
now[j][3] = max(now[j][3], now[j-1][3], now[j-1][2] + v)
if i > 0:
now[j][0] = max(now[j][0], max_pre[j], la)
now[j][1] = max(now[j][1], max_pre[j] + v, la + v, lb)
max_pre[j] = max(now[j])
print(max(now[C]))
``` | output | 1 | 25,328 | 15 | 50,657 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are K items placed on a grid of squares with R rows and C columns. Let (i, j) denote the square at the i-th row (1 \leq i \leq R) and the j-th column (1 \leq j \leq C). The i-th item is at (r_i, c_i) and has the value v_i.
Takahashi will begin at (1, 1), the start, and get to (R, C), the goal. When he is at (i, j), he can move to (i + 1, j) or (i, j + 1) (but cannot move to a non-existent square).
He can pick up items on the squares he visits, including the start and the goal, but at most three for each row. It is allowed to ignore the item on a square he visits.
Find the maximum possible sum of the values of items he picks up.
Constraints
* 1 \leq R, C \leq 3000
* 1 \leq K \leq \min(2 \times 10^5, R \times C)
* 1 \leq r_i \leq R
* 1 \leq c_i \leq C
* (r_i, c_i) \neq (r_j, c_j) (i \neq j)
* 1 \leq v_i \leq 10^9
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
R C K
r_1 c_1 v_1
r_2 c_2 v_2
:
r_K c_K v_K
Output
Print the maximum possible sum of the values of items Takahashi picks up.
Examples
Input
2 2 3
1 1 3
2 1 4
1 2 5
Output
8
Input
2 5 5
1 1 3
2 4 20
1 2 1
1 3 4
1 4 2
Output
29
Input
4 5 10
2 5 12
1 5 12
2 3 15
1 2 20
1 1 28
2 4 26
3 2 27
4 5 21
3 5 10
1 3 10
Output
142
Submitted Solution:
```
r,c,k = map(int,input().split())
dp = [[[0]*(c+1) for _ in range(r+1)] for _ in range(4)]
g = [[0]*(c+1) for _ in range(r+1)]
for _ in range(k):
a,b,v = map(int,input().split())
g[a][b] = v
for i in range(r+1):
for j in range(c+1):
for m in range(4):
tmp =dp[m][i][j]
if i+1<=r:
dp[0][i+1][j] = max(tmp,dp[0][i+1][j])
dp[1][i+1][j] = max(dp[1][i+1][j],tmp + g[i+1][j])
if j+1<=c:
dp[m][i][j+1] = max(dp[m][i][j+1],tmp)
if m<3:
dp[m+1][i][j+1] = max(dp[m+1][i][j+1],tmp + g[i][j+1])
ans = 0
for m in range(4):
ans = max(ans,dp[m][-1][-1])
print(ans)
``` | instruction | 0 | 25,329 | 15 | 50,658 |
Yes | output | 1 | 25,329 | 15 | 50,659 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are K items placed on a grid of squares with R rows and C columns. Let (i, j) denote the square at the i-th row (1 \leq i \leq R) and the j-th column (1 \leq j \leq C). The i-th item is at (r_i, c_i) and has the value v_i.
Takahashi will begin at (1, 1), the start, and get to (R, C), the goal. When he is at (i, j), he can move to (i + 1, j) or (i, j + 1) (but cannot move to a non-existent square).
He can pick up items on the squares he visits, including the start and the goal, but at most three for each row. It is allowed to ignore the item on a square he visits.
Find the maximum possible sum of the values of items he picks up.
Constraints
* 1 \leq R, C \leq 3000
* 1 \leq K \leq \min(2 \times 10^5, R \times C)
* 1 \leq r_i \leq R
* 1 \leq c_i \leq C
* (r_i, c_i) \neq (r_j, c_j) (i \neq j)
* 1 \leq v_i \leq 10^9
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
R C K
r_1 c_1 v_1
r_2 c_2 v_2
:
r_K c_K v_K
Output
Print the maximum possible sum of the values of items Takahashi picks up.
Examples
Input
2 2 3
1 1 3
2 1 4
1 2 5
Output
8
Input
2 5 5
1 1 3
2 4 20
1 2 1
1 3 4
1 4 2
Output
29
Input
4 5 10
2 5 12
1 5 12
2 3 15
1 2 20
1 1 28
2 4 26
3 2 27
4 5 21
3 5 10
1 3 10
Output
142
Submitted Solution:
```
def main():
import sys
input=sys.stdin.readline
h,w,k=map(int,input().split())
H=range(h)
W=range(w)
dp=[[[0]*w for j in H] for i in range(4)]
for _ in range(k):
r,c,v=map(int,input().split())
dp[0][r-1][c-1]=v
if dp[0][0][0]!=0:
dp[1][0][0]=dp[0][0][0]
dp[0][0][0]=0
for y in H:
for x in W:
v=dp[0][y][x]
dp[0][y][x]=0
for i in range(4):
if 0<x:
if dp[i][y][x]<dp[i][y][x-1]:
dp[i][y][x]=dp[i][y][x-1]
if 0<i and v!=0 and dp[i][y][x]<dp[i-1][y][x-1]+v:
dp[i][y][x]=dp[i-1][y][x-1]+v
if 0<y:
if dp[0][y][x]<dp[i][y-1][x]:
dp[0][y][x]=dp[i][y-1][x]
if v!=0 and dp[1][y][x]<dp[i][y-1][x]+v:
dp[1][y][x]=dp[i][y-1][x]+v
print(max([dp[i][h-1][w-1] for i in range(4)]))
main()
``` | instruction | 0 | 25,330 | 15 | 50,660 |
Yes | output | 1 | 25,330 | 15 | 50,661 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are K items placed on a grid of squares with R rows and C columns. Let (i, j) denote the square at the i-th row (1 \leq i \leq R) and the j-th column (1 \leq j \leq C). The i-th item is at (r_i, c_i) and has the value v_i.
Takahashi will begin at (1, 1), the start, and get to (R, C), the goal. When he is at (i, j), he can move to (i + 1, j) or (i, j + 1) (but cannot move to a non-existent square).
He can pick up items on the squares he visits, including the start and the goal, but at most three for each row. It is allowed to ignore the item on a square he visits.
Find the maximum possible sum of the values of items he picks up.
Constraints
* 1 \leq R, C \leq 3000
* 1 \leq K \leq \min(2 \times 10^5, R \times C)
* 1 \leq r_i \leq R
* 1 \leq c_i \leq C
* (r_i, c_i) \neq (r_j, c_j) (i \neq j)
* 1 \leq v_i \leq 10^9
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
R C K
r_1 c_1 v_1
r_2 c_2 v_2
:
r_K c_K v_K
Output
Print the maximum possible sum of the values of items Takahashi picks up.
Examples
Input
2 2 3
1 1 3
2 1 4
1 2 5
Output
8
Input
2 5 5
1 1 3
2 4 20
1 2 1
1 3 4
1 4 2
Output
29
Input
4 5 10
2 5 12
1 5 12
2 3 15
1 2 20
1 1 28
2 4 26
3 2 27
4 5 21
3 5 10
1 3 10
Output
142
Submitted Solution:
```
R,C,K=map(int, input().split())
M=[[0 for i in range(C)]for i in range(R)]
for i in range(K):
r,c,v=map(int, input().split())
r-=1
c-=1
M[r][c]=v
dp0=[[0 for j in range(C)] for i in range(R)]
dp1=[[0 for j in range(C)] for i in range(R)]
dp2=[[0 for j in range(C)] for i in range(R)]
dp3=[[0 for j in range(C)] for i in range(R)]
dp1[0][0]+=M[0][0]
for r in range(R):
for c in range(C):
if 0<r:
dp1[r][c]=max(max(dp1[r-1][c],dp2[r-1][c],dp3[r-1][c])+M[r][c],dp1[r][c])
dp0[r][c]=max(max(dp1[r-1][c],dp2[r-1][c],dp3[r-1][c]),dp0[r][c])
if 0<c:
dp3[r][c]=max(dp2[r][c-1]+M[r][c],dp3[r][c],dp3[r][c-1])
dp2[r][c]=max(dp1[r][c-1]+M[r][c],dp2[r][c],dp2[r][c-1])
dp1[r][c]=max(dp0[r][c-1]+M[r][c],dp1[r][c],dp1[r][c-1])
dp0[r][c]=max(dp0[r][c-1],dp0[r][c])
print(max(dp1[-1][-1],dp2[-1][-1],dp3[-1][-1]))
``` | instruction | 0 | 25,331 | 15 | 50,662 |
Yes | output | 1 | 25,331 | 15 | 50,663 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are K items placed on a grid of squares with R rows and C columns. Let (i, j) denote the square at the i-th row (1 \leq i \leq R) and the j-th column (1 \leq j \leq C). The i-th item is at (r_i, c_i) and has the value v_i.
Takahashi will begin at (1, 1), the start, and get to (R, C), the goal. When he is at (i, j), he can move to (i + 1, j) or (i, j + 1) (but cannot move to a non-existent square).
He can pick up items on the squares he visits, including the start and the goal, but at most three for each row. It is allowed to ignore the item on a square he visits.
Find the maximum possible sum of the values of items he picks up.
Constraints
* 1 \leq R, C \leq 3000
* 1 \leq K \leq \min(2 \times 10^5, R \times C)
* 1 \leq r_i \leq R
* 1 \leq c_i \leq C
* (r_i, c_i) \neq (r_j, c_j) (i \neq j)
* 1 \leq v_i \leq 10^9
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
R C K
r_1 c_1 v_1
r_2 c_2 v_2
:
r_K c_K v_K
Output
Print the maximum possible sum of the values of items Takahashi picks up.
Examples
Input
2 2 3
1 1 3
2 1 4
1 2 5
Output
8
Input
2 5 5
1 1 3
2 4 20
1 2 1
1 3 4
1 4 2
Output
29
Input
4 5 10
2 5 12
1 5 12
2 3 15
1 2 20
1 1 28
2 4 26
3 2 27
4 5 21
3 5 10
1 3 10
Output
142
Submitted Solution:
```
import sys
read = sys.stdin.buffer.read
readlines = sys.stdin.buffer.readlines
input = sys.stdin.buffer.readline
H, W, K = map(int, input().split())
B = {}
for _ in range(K):
r, c, v = map(int, input().split())
B[(r-1,c-1)] = v
dp = [[0]*(W+1) for _ in range(4)]
for i in range(H):
for j in range(W):
if (i, j) in B:
v = B[(i, j)]
dp[0][j+1] = max(dp[0][j], dp[0][j+1], dp[1][j+1], dp[2][j+1], dp[3][j+1])
dp[1][j+1] = max(dp[1][j], dp[0][j+1]+v)
dp[2][j+1] = max(dp[2][j], dp[1][j]+v)
dp[3][j+1] = max(dp[3][j], dp[2][j]+v)
else:
dp[0][j+1] = max(dp[0][j], dp[0][j+1], dp[1][j+1], dp[2][j+1], dp[3][j+1])
dp[1][j+1] = dp[1][j]
dp[2][j+1] = dp[2][j]
dp[3][j+1] = dp[3][j]
print(max(dp[i][-1] for i in range(4)))
``` | instruction | 0 | 25,332 | 15 | 50,664 |
Yes | output | 1 | 25,332 | 15 | 50,665 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are K items placed on a grid of squares with R rows and C columns. Let (i, j) denote the square at the i-th row (1 \leq i \leq R) and the j-th column (1 \leq j \leq C). The i-th item is at (r_i, c_i) and has the value v_i.
Takahashi will begin at (1, 1), the start, and get to (R, C), the goal. When he is at (i, j), he can move to (i + 1, j) or (i, j + 1) (but cannot move to a non-existent square).
He can pick up items on the squares he visits, including the start and the goal, but at most three for each row. It is allowed to ignore the item on a square he visits.
Find the maximum possible sum of the values of items he picks up.
Constraints
* 1 \leq R, C \leq 3000
* 1 \leq K \leq \min(2 \times 10^5, R \times C)
* 1 \leq r_i \leq R
* 1 \leq c_i \leq C
* (r_i, c_i) \neq (r_j, c_j) (i \neq j)
* 1 \leq v_i \leq 10^9
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
R C K
r_1 c_1 v_1
r_2 c_2 v_2
:
r_K c_K v_K
Output
Print the maximum possible sum of the values of items Takahashi picks up.
Examples
Input
2 2 3
1 1 3
2 1 4
1 2 5
Output
8
Input
2 5 5
1 1 3
2 4 20
1 2 1
1 3 4
1 4 2
Output
29
Input
4 5 10
2 5 12
1 5 12
2 3 15
1 2 20
1 1 28
2 4 26
3 2 27
4 5 21
3 5 10
1 3 10
Output
142
Submitted Solution:
```
r, c, k = map(int,input().split())
grid = [[0] * c for i in range(r)]
for _ in range(k):
R, C, V = map(int,input().split())
grid[R - 1][C - 1] = V
dp = [[[0, 0, 0, 0] for i in range(c)] for i in range(r)]
#dp[i][j]:= (i, j)に来た時点での考えられる最大スコア
dp[0][0][1] = max(grid[0][0], 0)
for i in range(r):
for j in range(c):
if 0 <= j + 1 < c:
#横移動は拾える数に制約がある
temp = grid[i][j + 1]
for k in range(3):
#入れる場合
dp[i][j + 1][k + 1] = max(dp[i][j][k + 1],dp[i][j + 1][k + 1], dp[i][j][k] + temp)
if 0 <= i + 1 < r:
temp = grid[i + 1][j]
temp_pre = max(dp[i][j])
dp[i + 1][j][0] = max(temp_pre, dp[i + 1][j][0])
if temp > 0:
dp[i + 1][j][1] = max(temp_pre + temp, dp[i + 1][j][1])
print(max(dp[-1][-1]))
``` | instruction | 0 | 25,333 | 15 | 50,666 |
No | output | 1 | 25,333 | 15 | 50,667 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are K items placed on a grid of squares with R rows and C columns. Let (i, j) denote the square at the i-th row (1 \leq i \leq R) and the j-th column (1 \leq j \leq C). The i-th item is at (r_i, c_i) and has the value v_i.
Takahashi will begin at (1, 1), the start, and get to (R, C), the goal. When he is at (i, j), he can move to (i + 1, j) or (i, j + 1) (but cannot move to a non-existent square).
He can pick up items on the squares he visits, including the start and the goal, but at most three for each row. It is allowed to ignore the item on a square he visits.
Find the maximum possible sum of the values of items he picks up.
Constraints
* 1 \leq R, C \leq 3000
* 1 \leq K \leq \min(2 \times 10^5, R \times C)
* 1 \leq r_i \leq R
* 1 \leq c_i \leq C
* (r_i, c_i) \neq (r_j, c_j) (i \neq j)
* 1 \leq v_i \leq 10^9
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
R C K
r_1 c_1 v_1
r_2 c_2 v_2
:
r_K c_K v_K
Output
Print the maximum possible sum of the values of items Takahashi picks up.
Examples
Input
2 2 3
1 1 3
2 1 4
1 2 5
Output
8
Input
2 5 5
1 1 3
2 4 20
1 2 1
1 3 4
1 4 2
Output
29
Input
4 5 10
2 5 12
1 5 12
2 3 15
1 2 20
1 1 28
2 4 26
3 2 27
4 5 21
3 5 10
1 3 10
Output
142
Submitted Solution:
```
from collections import defaultdict as dd
R,C,K = map(int,input().split())
rcv = [tuple(map(int,input().split())) for _ in range(K)]
dp = [[[0]*5 for __ in range(C)] for _ in range(R)]
# dp[0][0][0] = 0
rc = dd(int)
for r,c,v in rcv:
rc[(r-1,c-1)] = v
dp[0][0][1] = rc[(0,0)]
for r in range(R):
for c in range(C):
val = rc[(r,c)]
if val != 0:
for k in range(4):
if c != 0:
dp[r][c][k+1] = max(dp[r][c-1][k] + val, dp[r][c][k+1])
dp[r][c][k] = max(dp[r][c-1][k], dp[r][c][k])
if r != 0:
dp[r][c][0] = max(dp[r-1][c][k] + val, dp[r][c][0])
dp[r][c][0] = max(dp[r-1][c][0], dp[r][c][0])
else:
for k in range(4):
if c != 0:
dp[r][c][k+1] = max(dp[r][c-1][k], dp[r][c][k+1])
if r != 0:
dp[r][c][0] = max(dp[r-1][c][k], dp[r][c][0])
print(max(dp[R-1][C-1]))
``` | instruction | 0 | 25,334 | 15 | 50,668 |
No | output | 1 | 25,334 | 15 | 50,669 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are K items placed on a grid of squares with R rows and C columns. Let (i, j) denote the square at the i-th row (1 \leq i \leq R) and the j-th column (1 \leq j \leq C). The i-th item is at (r_i, c_i) and has the value v_i.
Takahashi will begin at (1, 1), the start, and get to (R, C), the goal. When he is at (i, j), he can move to (i + 1, j) or (i, j + 1) (but cannot move to a non-existent square).
He can pick up items on the squares he visits, including the start and the goal, but at most three for each row. It is allowed to ignore the item on a square he visits.
Find the maximum possible sum of the values of items he picks up.
Constraints
* 1 \leq R, C \leq 3000
* 1 \leq K \leq \min(2 \times 10^5, R \times C)
* 1 \leq r_i \leq R
* 1 \leq c_i \leq C
* (r_i, c_i) \neq (r_j, c_j) (i \neq j)
* 1 \leq v_i \leq 10^9
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
R C K
r_1 c_1 v_1
r_2 c_2 v_2
:
r_K c_K v_K
Output
Print the maximum possible sum of the values of items Takahashi picks up.
Examples
Input
2 2 3
1 1 3
2 1 4
1 2 5
Output
8
Input
2 5 5
1 1 3
2 4 20
1 2 1
1 3 4
1 4 2
Output
29
Input
4 5 10
2 5 12
1 5 12
2 3 15
1 2 20
1 1 28
2 4 26
3 2 27
4 5 21
3 5 10
1 3 10
Output
142
Submitted Solution:
```
R, C, K = map(int, input().split())
X = [list(map(int, input().split())) for _ in range(K)]
items = [[0] * (C + 1) for _ in range(R + 1)]
for r, c, v in X:
items[r][c] = v
dp = [[[0] * 4 for _ in range(C + 1)] for _ in range(R + 1)]
for i in range(1, R + 1):
for j in range(1, C + 1):
# k=0, horizontal and vertical transitions are allowed
dp[i][j][0] = max(dp[i][j - 1][0], dp[i - 1][j][0], dp[i - 1][j][1],
dp[i - 1][j][2], dp[i - 1][j][3])
# k=1~3, horizontal transition and picking up are allowed
dp[i][j][3] = max(dp[i][j - 1][3], dp[i][j - 1][2] + items[i][j],
dp[i][j][2] + items[i][j])
dp[i][j][2] = max(dp[i][j - 1][2], dp[i][j - 1][1] + items[i][j],
dp[i][j][1] + items[i][j])
dp[i][j][1] = max(dp[i][j - 1][1], dp[i][j - 1][0] + items[i][j],
dp[i][j][0] + items[i][j])
print(max(dp[-1][-1]))
``` | instruction | 0 | 25,335 | 15 | 50,670 |
No | output | 1 | 25,335 | 15 | 50,671 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are K items placed on a grid of squares with R rows and C columns. Let (i, j) denote the square at the i-th row (1 \leq i \leq R) and the j-th column (1 \leq j \leq C). The i-th item is at (r_i, c_i) and has the value v_i.
Takahashi will begin at (1, 1), the start, and get to (R, C), the goal. When he is at (i, j), he can move to (i + 1, j) or (i, j + 1) (but cannot move to a non-existent square).
He can pick up items on the squares he visits, including the start and the goal, but at most three for each row. It is allowed to ignore the item on a square he visits.
Find the maximum possible sum of the values of items he picks up.
Constraints
* 1 \leq R, C \leq 3000
* 1 \leq K \leq \min(2 \times 10^5, R \times C)
* 1 \leq r_i \leq R
* 1 \leq c_i \leq C
* (r_i, c_i) \neq (r_j, c_j) (i \neq j)
* 1 \leq v_i \leq 10^9
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
R C K
r_1 c_1 v_1
r_2 c_2 v_2
:
r_K c_K v_K
Output
Print the maximum possible sum of the values of items Takahashi picks up.
Examples
Input
2 2 3
1 1 3
2 1 4
1 2 5
Output
8
Input
2 5 5
1 1 3
2 4 20
1 2 1
1 3 4
1 4 2
Output
29
Input
4 5 10
2 5 12
1 5 12
2 3 15
1 2 20
1 1 28
2 4 26
3 2 27
4 5 21
3 5 10
1 3 10
Output
142
Submitted Solution:
```
import sys
input=lambda:sys.stdin.readline().rstrip()
r,c,k=map(int,input().split())
dp=[[(c+1)*[0]for _ in range(r+1)]for _ in range(4)]
p=[c*[0]for _ in range(r)]
for _ in range(k):
rr,cc,u=map(int,input().split())
rr-=1
cc-=1
p[rr][cc]=u
ans=0
for j in range(1,r+1):
for k in range(1,c+1):
dp[0][j][k]=max(dp[0][j-1][k],dp[0][j][k-1])
for i in range(1,4):
dp[i][j][k]=max(dp[i][j][k],dp[0][j-1][k],dp[1][j-1][k],dp[2][j-1][k],dp[3][j-1][k],dp[i][j][k-1])
if p[j-1][k-1]:
dp[i][j][k]=max(dp[i][j][k],dp[i-1][j][k-1]+p[j-1][k-1],max(dp[0][j-1][k],dp[1][j-1][k],dp[2][j-1][k],dp[3][j-1][k])+p[j-1][k-1])
ans=max(ans,dp[i][j][k])
print(ans)
``` | instruction | 0 | 25,336 | 15 | 50,672 |
No | output | 1 | 25,336 | 15 | 50,673 |
Provide a correct Python 3 solution for this coding contest problem.
Aoki is in search of Takahashi, who is missing in a one-dimentional world. Initially, the coordinate of Aoki is 0, and the coordinate of Takahashi is known to be x, but his coordinate afterwards cannot be known to Aoki.
Time is divided into turns. In each turn, Aoki and Takahashi take the following actions simultaneously:
* Let the current coordinate of Aoki be a, then Aoki moves to a coordinate he selects from a-1, a and a+1.
* Let the current coordinate of Takahashi be b, then Takahashi moves to the coordinate b-1 with probability of p percent, and moves to the coordinate b+1 with probability of 100-p percent.
When the coordinates of Aoki and Takahashi coincide, Aoki can find Takahashi. When they pass by each other, Aoki cannot find Takahashi.
Aoki wants to minimize the expected number of turns taken until he finds Takahashi. Find the minimum possible expected number of turns.
Constraints
* 1 ≦ x ≦ 1,000,000,000
* 1 ≦ p ≦ 100
* x and p are integers.
Input
The input is given from Standard Input in the following format:
x
p
Output
Print the minimum possible expected number of turns. The output is considered correct if the absolute or relative error is at most 10^{-6}.
Examples
Input
3
100
Output
2.0000000
Input
6
40
Output
7.5000000
Input
101
80
Output
63.7500000 | instruction | 0 | 25,455 | 15 | 50,910 |
"Correct Solution:
```
x = int(input())
p = int(input())
p *= 0.01
print((x+1)//2/p)
``` | output | 1 | 25,455 | 15 | 50,911 |
Provide a correct Python 3 solution for this coding contest problem.
Aoki is in search of Takahashi, who is missing in a one-dimentional world. Initially, the coordinate of Aoki is 0, and the coordinate of Takahashi is known to be x, but his coordinate afterwards cannot be known to Aoki.
Time is divided into turns. In each turn, Aoki and Takahashi take the following actions simultaneously:
* Let the current coordinate of Aoki be a, then Aoki moves to a coordinate he selects from a-1, a and a+1.
* Let the current coordinate of Takahashi be b, then Takahashi moves to the coordinate b-1 with probability of p percent, and moves to the coordinate b+1 with probability of 100-p percent.
When the coordinates of Aoki and Takahashi coincide, Aoki can find Takahashi. When they pass by each other, Aoki cannot find Takahashi.
Aoki wants to minimize the expected number of turns taken until he finds Takahashi. Find the minimum possible expected number of turns.
Constraints
* 1 ≦ x ≦ 1,000,000,000
* 1 ≦ p ≦ 100
* x and p are integers.
Input
The input is given from Standard Input in the following format:
x
p
Output
Print the minimum possible expected number of turns. The output is considered correct if the absolute or relative error is at most 10^{-6}.
Examples
Input
3
100
Output
2.0000000
Input
6
40
Output
7.5000000
Input
101
80
Output
63.7500000 | instruction | 0 | 25,456 | 15 | 50,912 |
"Correct Solution:
```
print((int(input())+1)//2/int(input())*100)
``` | output | 1 | 25,456 | 15 | 50,913 |
Provide a correct Python 3 solution for this coding contest problem.
Aoki is in search of Takahashi, who is missing in a one-dimentional world. Initially, the coordinate of Aoki is 0, and the coordinate of Takahashi is known to be x, but his coordinate afterwards cannot be known to Aoki.
Time is divided into turns. In each turn, Aoki and Takahashi take the following actions simultaneously:
* Let the current coordinate of Aoki be a, then Aoki moves to a coordinate he selects from a-1, a and a+1.
* Let the current coordinate of Takahashi be b, then Takahashi moves to the coordinate b-1 with probability of p percent, and moves to the coordinate b+1 with probability of 100-p percent.
When the coordinates of Aoki and Takahashi coincide, Aoki can find Takahashi. When they pass by each other, Aoki cannot find Takahashi.
Aoki wants to minimize the expected number of turns taken until he finds Takahashi. Find the minimum possible expected number of turns.
Constraints
* 1 ≦ x ≦ 1,000,000,000
* 1 ≦ p ≦ 100
* x and p are integers.
Input
The input is given from Standard Input in the following format:
x
p
Output
Print the minimum possible expected number of turns. The output is considered correct if the absolute or relative error is at most 10^{-6}.
Examples
Input
3
100
Output
2.0000000
Input
6
40
Output
7.5000000
Input
101
80
Output
63.7500000 | instruction | 0 | 25,457 | 15 | 50,914 |
"Correct Solution:
```
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
# 偶奇をあわせて寄せていくだけ
X,P = map(int,read().split())
def f(x):
y = x // 2
return y * 100 / P
if X % 2 == 0:
answer = f(X)
else:
answer = 1 + (P * f(X-1) + (100-P) * f(X+1))/100
print(answer)
``` | output | 1 | 25,457 | 15 | 50,915 |
Provide a correct Python 3 solution for this coding contest problem.
Aoki is in search of Takahashi, who is missing in a one-dimentional world. Initially, the coordinate of Aoki is 0, and the coordinate of Takahashi is known to be x, but his coordinate afterwards cannot be known to Aoki.
Time is divided into turns. In each turn, Aoki and Takahashi take the following actions simultaneously:
* Let the current coordinate of Aoki be a, then Aoki moves to a coordinate he selects from a-1, a and a+1.
* Let the current coordinate of Takahashi be b, then Takahashi moves to the coordinate b-1 with probability of p percent, and moves to the coordinate b+1 with probability of 100-p percent.
When the coordinates of Aoki and Takahashi coincide, Aoki can find Takahashi. When they pass by each other, Aoki cannot find Takahashi.
Aoki wants to minimize the expected number of turns taken until he finds Takahashi. Find the minimum possible expected number of turns.
Constraints
* 1 ≦ x ≦ 1,000,000,000
* 1 ≦ p ≦ 100
* x and p are integers.
Input
The input is given from Standard Input in the following format:
x
p
Output
Print the minimum possible expected number of turns. The output is considered correct if the absolute or relative error is at most 10^{-6}.
Examples
Input
3
100
Output
2.0000000
Input
6
40
Output
7.5000000
Input
101
80
Output
63.7500000 | instruction | 0 | 25,458 | 15 | 50,916 |
"Correct Solution:
```
#!/usr/bin/env python3
import math
x = int(input())
p = int(input())/100
print(math.ceil(x / 2) / p)
``` | output | 1 | 25,458 | 15 | 50,917 |
Provide a correct Python 3 solution for this coding contest problem.
Aoki is in search of Takahashi, who is missing in a one-dimentional world. Initially, the coordinate of Aoki is 0, and the coordinate of Takahashi is known to be x, but his coordinate afterwards cannot be known to Aoki.
Time is divided into turns. In each turn, Aoki and Takahashi take the following actions simultaneously:
* Let the current coordinate of Aoki be a, then Aoki moves to a coordinate he selects from a-1, a and a+1.
* Let the current coordinate of Takahashi be b, then Takahashi moves to the coordinate b-1 with probability of p percent, and moves to the coordinate b+1 with probability of 100-p percent.
When the coordinates of Aoki and Takahashi coincide, Aoki can find Takahashi. When they pass by each other, Aoki cannot find Takahashi.
Aoki wants to minimize the expected number of turns taken until he finds Takahashi. Find the minimum possible expected number of turns.
Constraints
* 1 ≦ x ≦ 1,000,000,000
* 1 ≦ p ≦ 100
* x and p are integers.
Input
The input is given from Standard Input in the following format:
x
p
Output
Print the minimum possible expected number of turns. The output is considered correct if the absolute or relative error is at most 10^{-6}.
Examples
Input
3
100
Output
2.0000000
Input
6
40
Output
7.5000000
Input
101
80
Output
63.7500000 | instruction | 0 | 25,459 | 15 | 50,918 |
"Correct Solution:
```
x = int(input())
p = int(input())
if x % 2 == 0:
print (100 * (x//2) / p)
else:
print ((100 * (x//2+1) / p))
``` | output | 1 | 25,459 | 15 | 50,919 |
Provide a correct Python 3 solution for this coding contest problem.
Aoki is in search of Takahashi, who is missing in a one-dimentional world. Initially, the coordinate of Aoki is 0, and the coordinate of Takahashi is known to be x, but his coordinate afterwards cannot be known to Aoki.
Time is divided into turns. In each turn, Aoki and Takahashi take the following actions simultaneously:
* Let the current coordinate of Aoki be a, then Aoki moves to a coordinate he selects from a-1, a and a+1.
* Let the current coordinate of Takahashi be b, then Takahashi moves to the coordinate b-1 with probability of p percent, and moves to the coordinate b+1 with probability of 100-p percent.
When the coordinates of Aoki and Takahashi coincide, Aoki can find Takahashi. When they pass by each other, Aoki cannot find Takahashi.
Aoki wants to minimize the expected number of turns taken until he finds Takahashi. Find the minimum possible expected number of turns.
Constraints
* 1 ≦ x ≦ 1,000,000,000
* 1 ≦ p ≦ 100
* x and p are integers.
Input
The input is given from Standard Input in the following format:
x
p
Output
Print the minimum possible expected number of turns. The output is considered correct if the absolute or relative error is at most 10^{-6}.
Examples
Input
3
100
Output
2.0000000
Input
6
40
Output
7.5000000
Input
101
80
Output
63.7500000 | instruction | 0 | 25,460 | 15 | 50,920 |
"Correct Solution:
```
from sys import exit, setrecursionlimit
from functools import reduce
from itertools import *
from collections import defaultdict
from bisect import bisect
def read():
return int(input())
def reads():
return [int(x) for x in input().split()]
setrecursionlimit(1000000)
x = read()
p = read()
p *= 0.01
if x % 2 == 0:
print((x // 2) / p)
else:
y = x // 2
print(1 + p * y / p + (1 - p) * (y + 1) / p)
``` | output | 1 | 25,460 | 15 | 50,921 |
Provide a correct Python 3 solution for this coding contest problem.
Aoki is in search of Takahashi, who is missing in a one-dimentional world. Initially, the coordinate of Aoki is 0, and the coordinate of Takahashi is known to be x, but his coordinate afterwards cannot be known to Aoki.
Time is divided into turns. In each turn, Aoki and Takahashi take the following actions simultaneously:
* Let the current coordinate of Aoki be a, then Aoki moves to a coordinate he selects from a-1, a and a+1.
* Let the current coordinate of Takahashi be b, then Takahashi moves to the coordinate b-1 with probability of p percent, and moves to the coordinate b+1 with probability of 100-p percent.
When the coordinates of Aoki and Takahashi coincide, Aoki can find Takahashi. When they pass by each other, Aoki cannot find Takahashi.
Aoki wants to minimize the expected number of turns taken until he finds Takahashi. Find the minimum possible expected number of turns.
Constraints
* 1 ≦ x ≦ 1,000,000,000
* 1 ≦ p ≦ 100
* x and p are integers.
Input
The input is given from Standard Input in the following format:
x
p
Output
Print the minimum possible expected number of turns. The output is considered correct if the absolute or relative error is at most 10^{-6}.
Examples
Input
3
100
Output
2.0000000
Input
6
40
Output
7.5000000
Input
101
80
Output
63.7500000 | instruction | 0 | 25,461 | 15 | 50,922 |
"Correct Solution:
```
x = int(input())
p = int(input()) / 100
print(((x + 1) // 2) / p)
``` | output | 1 | 25,461 | 15 | 50,923 |
Provide a correct Python 3 solution for this coding contest problem.
Aoki is in search of Takahashi, who is missing in a one-dimentional world. Initially, the coordinate of Aoki is 0, and the coordinate of Takahashi is known to be x, but his coordinate afterwards cannot be known to Aoki.
Time is divided into turns. In each turn, Aoki and Takahashi take the following actions simultaneously:
* Let the current coordinate of Aoki be a, then Aoki moves to a coordinate he selects from a-1, a and a+1.
* Let the current coordinate of Takahashi be b, then Takahashi moves to the coordinate b-1 with probability of p percent, and moves to the coordinate b+1 with probability of 100-p percent.
When the coordinates of Aoki and Takahashi coincide, Aoki can find Takahashi. When they pass by each other, Aoki cannot find Takahashi.
Aoki wants to minimize the expected number of turns taken until he finds Takahashi. Find the minimum possible expected number of turns.
Constraints
* 1 ≦ x ≦ 1,000,000,000
* 1 ≦ p ≦ 100
* x and p are integers.
Input
The input is given from Standard Input in the following format:
x
p
Output
Print the minimum possible expected number of turns. The output is considered correct if the absolute or relative error is at most 10^{-6}.
Examples
Input
3
100
Output
2.0000000
Input
6
40
Output
7.5000000
Input
101
80
Output
63.7500000 | instruction | 0 | 25,462 | 15 | 50,924 |
"Correct Solution:
```
N = int(input())
M = int(input())
if N%2:
print(1 + (N-1) / 2 + (100 - M) * (N+1) /2 / M)
else:
print(N * 50 / M)
``` | output | 1 | 25,462 | 15 | 50,925 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Aoki is in search of Takahashi, who is missing in a one-dimentional world. Initially, the coordinate of Aoki is 0, and the coordinate of Takahashi is known to be x, but his coordinate afterwards cannot be known to Aoki.
Time is divided into turns. In each turn, Aoki and Takahashi take the following actions simultaneously:
* Let the current coordinate of Aoki be a, then Aoki moves to a coordinate he selects from a-1, a and a+1.
* Let the current coordinate of Takahashi be b, then Takahashi moves to the coordinate b-1 with probability of p percent, and moves to the coordinate b+1 with probability of 100-p percent.
When the coordinates of Aoki and Takahashi coincide, Aoki can find Takahashi. When they pass by each other, Aoki cannot find Takahashi.
Aoki wants to minimize the expected number of turns taken until he finds Takahashi. Find the minimum possible expected number of turns.
Constraints
* 1 ≦ x ≦ 1,000,000,000
* 1 ≦ p ≦ 100
* x and p are integers.
Input
The input is given from Standard Input in the following format:
x
p
Output
Print the minimum possible expected number of turns. The output is considered correct if the absolute or relative error is at most 10^{-6}.
Examples
Input
3
100
Output
2.0000000
Input
6
40
Output
7.5000000
Input
101
80
Output
63.7500000
Submitted Solution:
```
x=int(input())
p=int(input())/100
print((x+1)//2 * 1 / p)
``` | instruction | 0 | 25,465 | 15 | 50,930 |
Yes | output | 1 | 25,465 | 15 | 50,931 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The jewel, a national treasure of the Kingdom of Pal, was stolen by bandits. As an adventurer, you heard the rumor and headed for the thief's hideout and managed to get the jewels back.
However, when I went to return the jewel to the castle of the Kingdom of Pal, the guard of the castle said, "My king has not completely trusted you yet. I doubt that the jewel is genuine, and I got it back in the first place. It is a lie, and I suspect that he is a member of the thief who is aiming for the king's life. "
You have been challenged by the guards to see if you really can be trusted. The content of the trial is, "Go to the castle's underground warehouse and place the jewel in the designated place. There is a magic circle that reacts when the jewel is genuine. However, do not cause suspicious behavior. Therefore, do not follow the movement pattern that the guards said from the entrance of the underground warehouse to the designated place. "
For example, for the shape and prohibition pattern of the underground warehouse shown in the figure below, the movement pattern as shown in the figure must not be adopted. This is because part of the movement pattern (highlighted in red) is included in the prohibited pattern. (In addition, the second and third movements "↓↓" in this movement pattern are also included in the prohibited pattern)
<image>
On the other hand, a movement pattern as shown in the figure below is allowed because no part of the movement pattern is included in the prohibited pattern.
<image>
As input, the shape of the underground warehouse and the prohibition pattern are given. Find the minimum number of moves required to move from the entrance to the magic circle without taking the ban pattern.
Notes on Test Cases
Multiple datasets are given in the above input format. Create a program that outputs each data set in the above output format.
When n, m is 0, it indicates the end of input.
<!-
Input
The inputs include the shape of the underground warehouse and the prohibition pattern.
The shape of the underground warehouse is represented as follows. First, two integers N and M are given. It means the number of rows and columns of the underground warehouse, respectively. (1 ≤ N, M ≤ 50)
Subsequently, N lines of character strings consisting of M characters are given. The characters included and their meanings are as follows.
Character | Meaning
--- | ---
S | The entrance to the underground warehouse. Only one is always included per underground warehouse.
G | Magic circle. Only one is always included per underground warehouse.
. | Aisle. You can pass (if you don't take the prohibition pattern).
| Wall. You can't go through the wall.
Next, a prohibition pattern is given. The prohibition pattern is expressed as follows. First, one integer P is given. Means the number of prohibited patterns. (0 ≤ P ≤ 10)
Subsequently, a character string meaning a prohibition pattern is given over P lines. The characters included in the prohibited pattern and their meanings are as follows.
Character | Meaning
--- | ---
U | ↑ move.
Move R |->.
D | ↓ movement.
L | <-Move.
The length of the prohibited pattern is 1 or more and 10 or less. One prohibition pattern may be a substring of another prohibition pattern. It may also include the same prohibition pattern.
Output
Output an integer that means the minimum number of moves required. If you can't reach the magic circle, output -1.
Examples
Input
7 6
......
.####.
.####.
...S#.
...##.
...##.
.....G
3
LD
DD
LLL
7 8
S#......
.#.####.
.#.#G.#.
.#.##.#.
.#....#.
.######.
........
8
DDDD
DDDU
UUUU
UUUD
RRRR
RRRL
LLLL
LLLR
3 8
########
S......G
########
2
U
D
6 10
..........
.S........
..........
..........
........G.
..........
0
6 7
.......
...#...
...#.S.
...###.
.G.....
.......
2
LL
DD
0 0
Output
13
60
7
10
-1
Input
7 6
......
.####.
.####.
...S#.
...##.
...##.
.....G
3
LD
DD
LLL
Output
13
Input
7 8
S#......
.#.####.
.#.#G.#.
.#.##.#.
.#....#.
.######.
........
8
DDDD
DDDU
UUUU
UUUD
RRRR
RRRL
LLLL
LLLR
Output
60
Input
3 8
S......G
2
U
D
Output
7
Input
6 10
..........
.S........
..........
..........
........G.
..........
0
Output
10
Input
6 7
.......
...#...
...#.S.
...###.
.G.....
.......
2
LL
DD
Output
-1
Input
7 6
......
.####.
.####.
...S#.
...##.
...##.
.....G
3
LD
DD
LLL
7 8
S#......
.#.####.
.#.#G.#.
.#.##.#.
.#....#.
.######.
........
8
DDDD
DDDU
UUUU
UUUD
RRRR
RRRL
LLLL
LLLR
3 8
S......G
2
U
D
6 10
..........
.S........
..........
..........
........G.
..........
0
6 7
.......
...#...
...#.S.
...###.
.G.....
.......
2
LL
DD
0 0
Output
13
60
7
10
-1
Submitted Solution:
```
from heapq import heappush, heappop
from collections import deque
def main():
while True:
n, m = map(int, input().split())
if n == 0:break
mp = ["#" * (m + 2)] + ["#" + input() + "#" for _ in range(n)] + ["#" * (m + 2)]
for y in range(1, n + 1):
for x in range(1, m + 1):
if mp[y][x] == "S":
sx, sy = x, y
if mp[y][x] == "G":
gx, gy = x, y
p = int(input())
bans = [input() for _ in range(p)]
dist = [[None] * (m + 2) for _ in range(n + 2)]
dist[gy][gx] = 0
vec = ((1, 0), (0, -1), (-1, 0), (0, 1))
que = deque()
que.append((0, gx, gy))
while que:
score, x, y = que.popleft()
for dx, dy in vec:
nx, ny = x + dx, y + dy
if dist[ny][nx] == None and mp[ny][nx] != "#":
dist[ny][nx] = score + 1
que.append((score + 1, nx, ny))
def check(com):
for ban in bans:
if ban in com:return False
return True
que = []
heappush(que, (0 + dist[sy][sx], 0, sx, sy, ""))
save = set()
save.add((sx, sy, ""))
while que:
total, turn, x, y, com = heappop(que)
if (x, y) == (gx, gy):
print(turn)
break
nx, ny = x + 1, y
if mp[ny][nx] != "#" and check(com + "R") and (nx, ny, (com + "R")[-9:]) not in save:
heappush(que, (turn + 1 + dist[ny][nx], turn + 1, nx, ny, (com + "R")[-9:]))
save.add((nx, ny, (com + "R")[-9:]))
nx, ny = x - 1, y
if mp[ny][nx] != "#" and check(com + "L") and (nx, ny, (com + "L")[-9:]) not in save:
heappush(que, (turn + 1 + dist[ny][nx], turn + 1, nx, ny, (com + "L")[-9:]))
save.add((nx, ny, (com + "L")[-9:]))
nx, ny = x, y + 1
if mp[ny][nx] != "#" and check(com + "D") and (nx, ny, (com + "D")[-9:]) not in save:
heappush(que, (turn + 1 + dist[ny][nx], turn + 1, nx, ny, (com + "D")[-9:]))
save.add((nx, ny, (com + "D")[-9:]))
nx, ny = x, y - 1
if mp[ny][nx] != "#" and check(com + "U") and (nx, ny, (com + "U")[-9:]) not in save:
heappush(que, (turn + 1 + dist[ny][nx], turn + 1, nx, ny, (com + "U")[-9:]))
save.add((nx, ny, (com + "U")[-9:]))
else:
print(-1)
main()
``` | instruction | 0 | 25,546 | 15 | 51,092 |
No | output | 1 | 25,546 | 15 | 51,093 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The jewel, a national treasure of the Kingdom of Pal, was stolen by bandits. As an adventurer, you heard the rumor and headed for the thief's hideout and managed to get the jewels back.
However, when I went to return the jewel to the castle of the Kingdom of Pal, the guard of the castle said, "My king has not completely trusted you yet. I doubt that the jewel is genuine, and I got it back in the first place. It is a lie, and I suspect that he is a member of the thief who is aiming for the king's life. "
You have been challenged by the guards to see if you really can be trusted. The content of the trial is, "Go to the castle's underground warehouse and place the jewel in the designated place. There is a magic circle that reacts when the jewel is genuine. However, do not cause suspicious behavior. Therefore, do not follow the movement pattern that the guards said from the entrance of the underground warehouse to the designated place. "
For example, for the shape and prohibition pattern of the underground warehouse shown in the figure below, the movement pattern as shown in the figure must not be adopted. This is because part of the movement pattern (highlighted in red) is included in the prohibited pattern. (In addition, the second and third movements "↓↓" in this movement pattern are also included in the prohibited pattern)
<image>
On the other hand, a movement pattern as shown in the figure below is allowed because no part of the movement pattern is included in the prohibited pattern.
<image>
As input, the shape of the underground warehouse and the prohibition pattern are given. Find the minimum number of moves required to move from the entrance to the magic circle without taking the ban pattern.
Notes on Test Cases
Multiple datasets are given in the above input format. Create a program that outputs each data set in the above output format.
When n, m is 0, it indicates the end of input.
<!-
Input
The inputs include the shape of the underground warehouse and the prohibition pattern.
The shape of the underground warehouse is represented as follows. First, two integers N and M are given. It means the number of rows and columns of the underground warehouse, respectively. (1 ≤ N, M ≤ 50)
Subsequently, N lines of character strings consisting of M characters are given. The characters included and their meanings are as follows.
Character | Meaning
--- | ---
S | The entrance to the underground warehouse. Only one is always included per underground warehouse.
G | Magic circle. Only one is always included per underground warehouse.
. | Aisle. You can pass (if you don't take the prohibition pattern).
| Wall. You can't go through the wall.
Next, a prohibition pattern is given. The prohibition pattern is expressed as follows. First, one integer P is given. Means the number of prohibited patterns. (0 ≤ P ≤ 10)
Subsequently, a character string meaning a prohibition pattern is given over P lines. The characters included in the prohibited pattern and their meanings are as follows.
Character | Meaning
--- | ---
U | ↑ move.
Move R |->.
D | ↓ movement.
L | <-Move.
The length of the prohibited pattern is 1 or more and 10 or less. One prohibition pattern may be a substring of another prohibition pattern. It may also include the same prohibition pattern.
Output
Output an integer that means the minimum number of moves required. If you can't reach the magic circle, output -1.
Examples
Input
7 6
......
.####.
.####.
...S#.
...##.
...##.
.....G
3
LD
DD
LLL
7 8
S#......
.#.####.
.#.#G.#.
.#.##.#.
.#....#.
.######.
........
8
DDDD
DDDU
UUUU
UUUD
RRRR
RRRL
LLLL
LLLR
3 8
########
S......G
########
2
U
D
6 10
..........
.S........
..........
..........
........G.
..........
0
6 7
.......
...#...
...#.S.
...###.
.G.....
.......
2
LL
DD
0 0
Output
13
60
7
10
-1
Input
7 6
......
.####.
.####.
...S#.
...##.
...##.
.....G
3
LD
DD
LLL
Output
13
Input
7 8
S#......
.#.####.
.#.#G.#.
.#.##.#.
.#....#.
.######.
........
8
DDDD
DDDU
UUUU
UUUD
RRRR
RRRL
LLLL
LLLR
Output
60
Input
3 8
S......G
2
U
D
Output
7
Input
6 10
..........
.S........
..........
..........
........G.
..........
0
Output
10
Input
6 7
.......
...#...
...#.S.
...###.
.G.....
.......
2
LL
DD
Output
-1
Input
7 6
......
.####.
.####.
...S#.
...##.
...##.
.....G
3
LD
DD
LLL
7 8
S#......
.#.####.
.#.#G.#.
.#.##.#.
.#....#.
.######.
........
8
DDDD
DDDU
UUUU
UUUD
RRRR
RRRL
LLLL
LLLR
3 8
S......G
2
U
D
6 10
..........
.S........
..........
..........
........G.
..........
0
6 7
.......
...#...
...#.S.
...###.
.G.....
.......
2
LL
DD
0 0
Output
13
60
7
10
-1
Submitted Solution:
```
from heapq import heappush, heappop
from collections import deque
def main():
while True:
n, m = map(int, input().split())
if n == 0:break
mp = ["#" * (m + 2)] + ["#" + input() + "#" for _ in range(n)] + ["#" * (m + 2)]
for y in range(1, n + 1):
for x in range(1, m + 1):
if mp[y][x] == "S":
sx, sy = x, y
if mp[y][x] == "G":
gx, gy = x, y
p = int(input())
bans = [input() for _ in range(p)]
dist = [[None] * (m + 2) for _ in range(n + 2)]
dist[gy][gx] = 0
vec = ((1, 0), (0, -1), (-1, 0), (0, 1))
que = deque()
que.append((0, gx, gy))
while que:
score, x, y = que.popleft()
for dx, dy in vec:
nx, ny = x + dx, y + dy
if dist[ny][nx] == None and mp[ny][nx] != "#":
dist[ny][nx] = score + 1
que.append((score + 1, nx, ny))
if dist[sy][sx] == None:
print(-1)
continue
def check(com):
for ban in bans:
if ban in com:return False
return True
que = []
heappush(que, (0 + dist[sy][sx], 0, sx, sy, ""))
save = set()
save.add((sx, sy, ""))
while que:
total, turn, x, y, com = heappop(que)
if (x, y) == (gx, gy):
print(turn)
break
nx, ny = x + 1, y
if mp[ny][nx] != "#" and check(com + "R") and (nx, ny, (com + "R")[-9:]) not in save:
heappush(que, (turn + 1 + dist[ny][nx], turn + 1, nx, ny, (com + "R")[-9:]))
save.add((nx, ny, (com + "R")[-9:]))
nx, ny = x - 1, y
if mp[ny][nx] != "#" and check(com + "L") and (nx, ny, (com + "L")[-9:]) not in save:
heappush(que, (turn + 1 + dist[ny][nx], turn + 1, nx, ny, (com + "L")[-9:]))
save.add((nx, ny, (com + "L")[-9:]))
nx, ny = x, y + 1
if mp[ny][nx] != "#" and check(com + "D") and (nx, ny, (com + "D")[-9:]) not in save:
heappush(que, (turn + 1 + dist[ny][nx], turn + 1, nx, ny, (com + "D")[-9:]))
save.add((nx, ny, (com + "D")[-9:]))
nx, ny = x, y - 1
if mp[ny][nx] != "#" and check(com + "U") and (nx, ny, (com + "U")[-9:]) not in save:
heappush(que, (turn + 1 + dist[ny][nx], turn + 1, nx, ny, (com + "U")[-9:]))
save.add((nx, ny, (com + "U")[-9:]))
else:
print(-1)
main()
``` | instruction | 0 | 25,547 | 15 | 51,094 |
No | output | 1 | 25,547 | 15 | 51,095 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The jewel, a national treasure of the Kingdom of Pal, was stolen by bandits. As an adventurer, you heard the rumor and headed for the thief's hideout and managed to get the jewels back.
However, when I went to return the jewel to the castle of the Kingdom of Pal, the guard of the castle said, "My king has not completely trusted you yet. I doubt that the jewel is genuine, and I got it back in the first place. It is a lie, and I suspect that he is a member of the thief who is aiming for the king's life. "
You have been challenged by the guards to see if you really can be trusted. The content of the trial is, "Go to the castle's underground warehouse and place the jewel in the designated place. There is a magic circle that reacts when the jewel is genuine. However, do not cause suspicious behavior. Therefore, do not follow the movement pattern that the guards said from the entrance of the underground warehouse to the designated place. "
For example, for the shape and prohibition pattern of the underground warehouse shown in the figure below, the movement pattern as shown in the figure must not be adopted. This is because part of the movement pattern (highlighted in red) is included in the prohibited pattern. (In addition, the second and third movements "↓↓" in this movement pattern are also included in the prohibited pattern)
<image>
On the other hand, a movement pattern as shown in the figure below is allowed because no part of the movement pattern is included in the prohibited pattern.
<image>
As input, the shape of the underground warehouse and the prohibition pattern are given. Find the minimum number of moves required to move from the entrance to the magic circle without taking the ban pattern.
Notes on Test Cases
Multiple datasets are given in the above input format. Create a program that outputs each data set in the above output format.
When n, m is 0, it indicates the end of input.
<!-
Input
The inputs include the shape of the underground warehouse and the prohibition pattern.
The shape of the underground warehouse is represented as follows. First, two integers N and M are given. It means the number of rows and columns of the underground warehouse, respectively. (1 ≤ N, M ≤ 50)
Subsequently, N lines of character strings consisting of M characters are given. The characters included and their meanings are as follows.
Character | Meaning
--- | ---
S | The entrance to the underground warehouse. Only one is always included per underground warehouse.
G | Magic circle. Only one is always included per underground warehouse.
. | Aisle. You can pass (if you don't take the prohibition pattern).
| Wall. You can't go through the wall.
Next, a prohibition pattern is given. The prohibition pattern is expressed as follows. First, one integer P is given. Means the number of prohibited patterns. (0 ≤ P ≤ 10)
Subsequently, a character string meaning a prohibition pattern is given over P lines. The characters included in the prohibited pattern and their meanings are as follows.
Character | Meaning
--- | ---
U | ↑ move.
Move R |->.
D | ↓ movement.
L | <-Move.
The length of the prohibited pattern is 1 or more and 10 or less. One prohibition pattern may be a substring of another prohibition pattern. It may also include the same prohibition pattern.
Output
Output an integer that means the minimum number of moves required. If you can't reach the magic circle, output -1.
Examples
Input
7 6
......
.####.
.####.
...S#.
...##.
...##.
.....G
3
LD
DD
LLL
7 8
S#......
.#.####.
.#.#G.#.
.#.##.#.
.#....#.
.######.
........
8
DDDD
DDDU
UUUU
UUUD
RRRR
RRRL
LLLL
LLLR
3 8
########
S......G
########
2
U
D
6 10
..........
.S........
..........
..........
........G.
..........
0
6 7
.......
...#...
...#.S.
...###.
.G.....
.......
2
LL
DD
0 0
Output
13
60
7
10
-1
Input
7 6
......
.####.
.####.
...S#.
...##.
...##.
.....G
3
LD
DD
LLL
Output
13
Input
7 8
S#......
.#.####.
.#.#G.#.
.#.##.#.
.#....#.
.######.
........
8
DDDD
DDDU
UUUU
UUUD
RRRR
RRRL
LLLL
LLLR
Output
60
Input
3 8
S......G
2
U
D
Output
7
Input
6 10
..........
.S........
..........
..........
........G.
..........
0
Output
10
Input
6 7
.......
...#...
...#.S.
...###.
.G.....
.......
2
LL
DD
Output
-1
Input
7 6
......
.####.
.####.
...S#.
...##.
...##.
.....G
3
LD
DD
LLL
7 8
S#......
.#.####.
.#.#G.#.
.#.##.#.
.#....#.
.######.
........
8
DDDD
DDDU
UUUU
UUUD
RRRR
RRRL
LLLL
LLLR
3 8
S......G
2
U
D
6 10
..........
.S........
..........
..........
........G.
..........
0
6 7
.......
...#...
...#.S.
...###.
.G.....
.......
2
LL
DD
0 0
Output
13
60
7
10
-1
Submitted Solution:
```
from heapq import heappush, heappop
from collections import deque
def main():
while True:
n, m = map(int, input().split())
if n == 0:break
mp = ["#" * (m + 2)] + ["#" + input() + "#" for _ in range(n)] + ["#" * (m + 2)]
for y in range(1, n + 1):
for x in range(1, m + 1):
if mp[y][x] == "S":
sx, sy = x, y
if mp[y][x] == "G":
gx, gy = x, y
p = int(input())
bans = [input() for _ in range(p)]
bans_part = set([""])
for ban in bans:
for i in range(len(ban)):
bans_part.add(ban[:i])
dist = [[None] * (m + 2) for _ in range(n + 2)]
dist[gy][gx] = 0
vec = ((1, 0), (0, -1), (-1, 0), (0, 1))
que = deque()
que.append((0, gx, gy))
while que:
score, x, y = que.popleft()
for dx, dy in vec:
nx, ny = x + dx, y + dy
if dist[ny][nx] == None and mp[ny][nx] != "#":
dist[ny][nx] = score + 1
que.append((score + 1, nx, ny))
if dist[sy][sx] == None:
print(-1)
continue
def check(com):
for ban in bans:
if ban in com:return False
return True
que = []
heappush(que, (dist[sy][sx], 0, sx, sy, ""))
save = set()
save.add((sx, sy, ""))
while que:
total, turn, x, y, com = heappop(que)
#print(turn, com)
if (x, y) == (gx, gy):
print(turn)
break
nx, ny = x + 1, y
new_com = com + "R"
if mp[ny][nx] != "#" and check(new_com):
for i in range(-9, 1):
if new_com[i:] in bans_part:
new_com = new_com[i:]
break
if (nx, ny, new_com) not in save:
heappush(que, (turn + 1 + dist[ny][nx], turn + 1, nx, ny, new_com))
save.add((nx, ny, new_com))
nx, ny = x - 1, y
new_com = com + "L"
if mp[ny][nx] != "#" and check(new_com):
for i in range(-9, 1):
if new_com[i:] in bans_part:
new_com = new_com[i:]
break
if (nx, ny, new_com) not in save:
heappush(que, (turn + 1 + dist[ny][nx], turn + 1, nx, ny, new_com))
save.add((nx, ny, new_com))
nx, ny = x, y + 1
new_com = com + "D"
if mp[ny][nx] != "#" and check(new_com):
for i in range(-9, 1):
if new_com[i:] in bans_part:
new_com = new_com[i:]
break
if (nx, ny, new_com) not in save:
heappush(que, (turn + 1 + dist[ny][nx], turn + 1, nx, ny, new_com))
save.add((nx, ny, new_com))
nx, ny = x, y - 1
new_com = com + "U"
if mp[ny][nx] != "#" and check(new_com):
for i in range(-9, 1):
if new_com[i:] in bans_part:
new_com = new_com[i:]
break
if (nx, ny, new_com) not in save:
heappush(que, (turn + 1 + dist[ny][nx], turn + 1, nx, ny, new_com))
save.add((nx, ny, new_com))
else:
print(-1)
main()
``` | instruction | 0 | 25,548 | 15 | 51,096 |
No | output | 1 | 25,548 | 15 | 51,097 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n cells, numbered 1,2,..., n from left to right. You have to place a robot at any cell initially. The robot must make exactly k moves.
In one move, the robot must move one cell to the left or right, provided that it doesn't move out of bounds. In other words, if the robot was in the cell i, it must move to either the cell i-1 or the cell i+1, as long as it lies between 1 and n (endpoints inclusive). The cells, in the order they are visited (including the cell the robot is placed), together make a good path.
Each cell i has a value a_i associated with it. Let c_0, c_1, ..., c_k be the sequence of cells in a good path in the order they are visited (c_0 is the cell robot is initially placed, c_1 is the cell where the robot is after its first move, and so on; more formally, c_i is the cell that the robot is at after i moves). Then the value of the path is calculated as a_{c_0} + a_{c_1} + ... + a_{c_k}.
Your task is to calculate the sum of values over all possible good paths. Since this number can be very large, output it modulo 10^9 + 7. Two good paths are considered different if the starting cell differs or there exists an integer i ∈ [1, k] such that the current cell of the robot after exactly i moves is different in those paths.
You must process q updates to a and print the updated sum each time. Each update changes the value of exactly one cell. See the input format and the sample input-output for more details.
Input
The first line of the input contains three space-separated integers n, k and q (2 ≤ n ≤ 5000; 1 ≤ k ≤ 5000; 1 ≤ q ≤ 2 ⋅ 10^5).
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9).
q lines follow. Each line contains two space-separated integers i and x (1 ≤ i ≤ n; 1 ≤ x ≤ 10^9) indicating that you must change the value of a_i to x.
Output
Print q integers. The i-th integer should be the sum of values over all good paths after the first i updates are performed. Since the answers may be large, print them modulo 10^9 + 7.
Examples
Input
5 1 5
3 5 1 4 2
1 9
2 4
3 6
4 6
5 2
Output
62
58
78
86
86
Input
5 2 5
3 5 1 4 2
1 9
2 4
3 6
4 6
5 2
Output
157
147
207
227
227
Input
4 40 6
92 21 82 46
3 56
1 72
4 28
1 97
2 49
2 88
Output
239185261
666314041
50729936
516818968
766409450
756910476
Note
In the first example, the good paths are (1, 2), (2, 1), (2, 3), (3, 2), (3, 4), (4, 3), (4, 5), (5, 4).
Initially the values of a are [3, 5, 1, 4, 2]. After the first update, they become [9, 5, 1, 4, 2]. After the second update, they become [9, 4, 1, 4, 2], and so on. | instruction | 0 | 25,814 | 15 | 51,628 |
Tags: combinatorics, dp, math
Correct Solution:
```
from sys import stdin
import sys
mod = 10**9+7
tt = 1
ans = []
for loop in range(tt):
n,k,q = map(int,stdin.readline().split())
dp = [[0] * (k+1) for i in range(n)]
for j in range(k,-1,-1):
for i in range(n):
if j == k:
dp[i][j] = 1
continue
if i != 0:
dp[i][j] += dp[i-1][j+1]
if i != n-1:
dp[i][j] += dp[i+1][j+1]
dp[i][j] %= mod
slis = [ 0 ] * n
for i in range(n):
for j in range(k+1):
slis[i] += dp[i][j] * dp[i][k-j]
slis[i] %= mod
nsum = 0
a = list(map(int,stdin.readline().split()))
for i in range(n):
nsum += slis[i] * a[i]
nsum %= mod
#print (slis)
for i in range(q):
ind,x = map(int,stdin.readline().split())
ind -= 1
nsum += slis[ind] * (x-a[ind])
a[ind] = x
nsum %= mod
ans.append(nsum)
print ("\n".join(map(str,ans)))
``` | output | 1 | 25,814 | 15 | 51,629 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n cells, numbered 1,2,..., n from left to right. You have to place a robot at any cell initially. The robot must make exactly k moves.
In one move, the robot must move one cell to the left or right, provided that it doesn't move out of bounds. In other words, if the robot was in the cell i, it must move to either the cell i-1 or the cell i+1, as long as it lies between 1 and n (endpoints inclusive). The cells, in the order they are visited (including the cell the robot is placed), together make a good path.
Each cell i has a value a_i associated with it. Let c_0, c_1, ..., c_k be the sequence of cells in a good path in the order they are visited (c_0 is the cell robot is initially placed, c_1 is the cell where the robot is after its first move, and so on; more formally, c_i is the cell that the robot is at after i moves). Then the value of the path is calculated as a_{c_0} + a_{c_1} + ... + a_{c_k}.
Your task is to calculate the sum of values over all possible good paths. Since this number can be very large, output it modulo 10^9 + 7. Two good paths are considered different if the starting cell differs or there exists an integer i ∈ [1, k] such that the current cell of the robot after exactly i moves is different in those paths.
You must process q updates to a and print the updated sum each time. Each update changes the value of exactly one cell. See the input format and the sample input-output for more details.
Input
The first line of the input contains three space-separated integers n, k and q (2 ≤ n ≤ 5000; 1 ≤ k ≤ 5000; 1 ≤ q ≤ 2 ⋅ 10^5).
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9).
q lines follow. Each line contains two space-separated integers i and x (1 ≤ i ≤ n; 1 ≤ x ≤ 10^9) indicating that you must change the value of a_i to x.
Output
Print q integers. The i-th integer should be the sum of values over all good paths after the first i updates are performed. Since the answers may be large, print them modulo 10^9 + 7.
Examples
Input
5 1 5
3 5 1 4 2
1 9
2 4
3 6
4 6
5 2
Output
62
58
78
86
86
Input
5 2 5
3 5 1 4 2
1 9
2 4
3 6
4 6
5 2
Output
157
147
207
227
227
Input
4 40 6
92 21 82 46
3 56
1 72
4 28
1 97
2 49
2 88
Output
239185261
666314041
50729936
516818968
766409450
756910476
Note
In the first example, the good paths are (1, 2), (2, 1), (2, 3), (3, 2), (3, 4), (4, 3), (4, 5), (5, 4).
Initially the values of a are [3, 5, 1, 4, 2]. After the first update, they become [9, 5, 1, 4, 2]. After the second update, they become [9, 4, 1, 4, 2], and so on. | instruction | 0 | 25,815 | 15 | 51,630 |
Tags: combinatorics, dp, math
Correct Solution:
```
import sys, io, os
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
mod = 1000000007
n,k,q = map(int,input().split())
dp = [[0 for j in range(k+1)] for i in range(n+1)]
for i in range(n):
dp[i][0] = 1
for j in range(1,k+1):
dp[0][j] = dp[1][j-1]
for i in range(1,n-1):
dp[i][j] = (dp[i-1][j-1]+dp[i+1][j-1])%mod
dp[n-1][j] = dp[n-2][j-1]
count = [0]*n
for i in range(n):
for j in range(k+1):
count[i] += dp[i][j] * dp[i][k-j]
count[i] %= mod
a = list(map(int,input().split()))
ans = 0
for i in range(n):
ans += a[i]*count[i]
ans %= mod
for _ in range(q):
i,x = map(int,input().split())
i -= 1
ans -= a[i]*count[i]
ans += mod
ans %= mod
ans += x*count[i]
ans %= mod
a[i] = x
print(ans)
``` | output | 1 | 25,815 | 15 | 51,631 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n cells, numbered 1,2,..., n from left to right. You have to place a robot at any cell initially. The robot must make exactly k moves.
In one move, the robot must move one cell to the left or right, provided that it doesn't move out of bounds. In other words, if the robot was in the cell i, it must move to either the cell i-1 or the cell i+1, as long as it lies between 1 and n (endpoints inclusive). The cells, in the order they are visited (including the cell the robot is placed), together make a good path.
Each cell i has a value a_i associated with it. Let c_0, c_1, ..., c_k be the sequence of cells in a good path in the order they are visited (c_0 is the cell robot is initially placed, c_1 is the cell where the robot is after its first move, and so on; more formally, c_i is the cell that the robot is at after i moves). Then the value of the path is calculated as a_{c_0} + a_{c_1} + ... + a_{c_k}.
Your task is to calculate the sum of values over all possible good paths. Since this number can be very large, output it modulo 10^9 + 7. Two good paths are considered different if the starting cell differs or there exists an integer i ∈ [1, k] such that the current cell of the robot after exactly i moves is different in those paths.
You must process q updates to a and print the updated sum each time. Each update changes the value of exactly one cell. See the input format and the sample input-output for more details.
Input
The first line of the input contains three space-separated integers n, k and q (2 ≤ n ≤ 5000; 1 ≤ k ≤ 5000; 1 ≤ q ≤ 2 ⋅ 10^5).
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9).
q lines follow. Each line contains two space-separated integers i and x (1 ≤ i ≤ n; 1 ≤ x ≤ 10^9) indicating that you must change the value of a_i to x.
Output
Print q integers. The i-th integer should be the sum of values over all good paths after the first i updates are performed. Since the answers may be large, print them modulo 10^9 + 7.
Examples
Input
5 1 5
3 5 1 4 2
1 9
2 4
3 6
4 6
5 2
Output
62
58
78
86
86
Input
5 2 5
3 5 1 4 2
1 9
2 4
3 6
4 6
5 2
Output
157
147
207
227
227
Input
4 40 6
92 21 82 46
3 56
1 72
4 28
1 97
2 49
2 88
Output
239185261
666314041
50729936
516818968
766409450
756910476
Note
In the first example, the good paths are (1, 2), (2, 1), (2, 3), (3, 2), (3, 4), (4, 3), (4, 5), (5, 4).
Initially the values of a are [3, 5, 1, 4, 2]. After the first update, they become [9, 5, 1, 4, 2]. After the second update, they become [9, 4, 1, 4, 2], and so on. | instruction | 0 | 25,816 | 15 | 51,632 |
Tags: combinatorics, dp, math
Correct Solution:
```
# by the authority of GOD author: manhar singh sachdev #
import os,sys
from io import BytesIO,IOBase
def main():
mod = 10**9+7
n,k,q = map(int,input().split())
a = list(map(int,input().split()))
curr = [[0]*(n+2) for _ in range(k+1)]
curr[0] = [0]+[1]*n+[0]
for i in range(1,k+1):
for j in range(1,n+1):
curr[i][j] = (curr[i-1][j-1]+curr[i-1][j+1])%mod
dp = [0]*n
for j in range(n):
for x in range(k+1):
dp[j] = (dp[j]+curr[k-x][j+1]*curr[x][j+1])%mod
su = 0
for i in range(n):
su = (su+dp[i]*a[i])%mod
ans = []
for _ in range(q):
x,y = map(int,input().split())
su = (su+dp[x-1]*(y-a[x-1]))%mod
a[x-1] = y
ans.append(su)
for i in ans:
print(i)
#Fast IO Region
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
if __name__ == '__main__':
main()
``` | output | 1 | 25,816 | 15 | 51,633 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n cells, numbered 1,2,..., n from left to right. You have to place a robot at any cell initially. The robot must make exactly k moves.
In one move, the robot must move one cell to the left or right, provided that it doesn't move out of bounds. In other words, if the robot was in the cell i, it must move to either the cell i-1 or the cell i+1, as long as it lies between 1 and n (endpoints inclusive). The cells, in the order they are visited (including the cell the robot is placed), together make a good path.
Each cell i has a value a_i associated with it. Let c_0, c_1, ..., c_k be the sequence of cells in a good path in the order they are visited (c_0 is the cell robot is initially placed, c_1 is the cell where the robot is after its first move, and so on; more formally, c_i is the cell that the robot is at after i moves). Then the value of the path is calculated as a_{c_0} + a_{c_1} + ... + a_{c_k}.
Your task is to calculate the sum of values over all possible good paths. Since this number can be very large, output it modulo 10^9 + 7. Two good paths are considered different if the starting cell differs or there exists an integer i ∈ [1, k] such that the current cell of the robot after exactly i moves is different in those paths.
You must process q updates to a and print the updated sum each time. Each update changes the value of exactly one cell. See the input format and the sample input-output for more details.
Input
The first line of the input contains three space-separated integers n, k and q (2 ≤ n ≤ 5000; 1 ≤ k ≤ 5000; 1 ≤ q ≤ 2 ⋅ 10^5).
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9).
q lines follow. Each line contains two space-separated integers i and x (1 ≤ i ≤ n; 1 ≤ x ≤ 10^9) indicating that you must change the value of a_i to x.
Output
Print q integers. The i-th integer should be the sum of values over all good paths after the first i updates are performed. Since the answers may be large, print them modulo 10^9 + 7.
Examples
Input
5 1 5
3 5 1 4 2
1 9
2 4
3 6
4 6
5 2
Output
62
58
78
86
86
Input
5 2 5
3 5 1 4 2
1 9
2 4
3 6
4 6
5 2
Output
157
147
207
227
227
Input
4 40 6
92 21 82 46
3 56
1 72
4 28
1 97
2 49
2 88
Output
239185261
666314041
50729936
516818968
766409450
756910476
Note
In the first example, the good paths are (1, 2), (2, 1), (2, 3), (3, 2), (3, 4), (4, 3), (4, 5), (5, 4).
Initially the values of a are [3, 5, 1, 4, 2]. After the first update, they become [9, 5, 1, 4, 2]. After the second update, they become [9, 4, 1, 4, 2], and so on. | instruction | 0 | 25,817 | 15 | 51,634 |
Tags: combinatorics, dp, math
Correct Solution:
```
import io,os;input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
n,k,q = map(int,input().split());mod = 10**9+7;dp = [[0 for j in range((n+1)//2)] for i in range(k//2+1)];dp[0] = [1 for j in range((n+1)//2)]
for i in range(1,k//2+1):
for j in range((n+1)//2):
if j:
dp[i][j] += dp[i-1][j-1]
dp[i][j] %= mod
if j!=(n+1)//2-1:
dp[i][j] += dp[i-1][j+1]
dp[i][j] %= mod
if n%2==1:
dp[i][(n+1)//2-1] += dp[i-1][(n+1)//2-2]
dp[i][(n+1)//2-1] %= mod
else:
dp[i][(n+1)//2-1] += dp[i-1][(n+1)//2-1]
dp[i][(n+1)//2-1] %= mod
cnt = [0 for i in range((n+1)//2)]
if k%2==0:
for i in range((n+1)//2):cnt[i] += dp[k//2][i] * dp[k//2][i];cnt[i] %= mod
sub = [dp[-1][j] for j in range((n+1)//2)]
for i in range(k//2+1,k+1):
next = [0 for j in range((n+1)//2)]
for j in range((n+1)//2):
if j:next[j] += sub[j-1];next[j] %= mod
if j!=(n+1)//2-1:next[j] += sub[j+1];next[j] %= mod
if n%2==1:next[(n+1)//2-1] += sub[(n+1)//2-2];next[(n+1)//2-1] %= mod
else:next[(n+1)//2-1] += sub[(n+1)//2-1];next[(n+1)//2-1] %= mod
for j in range((n+1)//2):cnt[j] += 2 * next[j] * dp[k-i][j];cnt[j] %= mod
sub = next
cnt += ([cnt[-2-j] for j in range(n//2)] if n%2==1 else [cnt[-1-j] for j in range(n//2)]);a = list(map(int,input().split()));res = 0;ans = []
for i in range(n):res += a[i] * cnt[i];res %= mod
for i in range(q):idx,x = map(int,input().split());idx -= 1;res = res + cnt[idx] * (x - a[idx]);res %= mod;a[idx] = x;ans.append(res)
print(*ans,sep="\n")
``` | output | 1 | 25,817 | 15 | 51,635 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n cells, numbered 1,2,..., n from left to right. You have to place a robot at any cell initially. The robot must make exactly k moves.
In one move, the robot must move one cell to the left or right, provided that it doesn't move out of bounds. In other words, if the robot was in the cell i, it must move to either the cell i-1 or the cell i+1, as long as it lies between 1 and n (endpoints inclusive). The cells, in the order they are visited (including the cell the robot is placed), together make a good path.
Each cell i has a value a_i associated with it. Let c_0, c_1, ..., c_k be the sequence of cells in a good path in the order they are visited (c_0 is the cell robot is initially placed, c_1 is the cell where the robot is after its first move, and so on; more formally, c_i is the cell that the robot is at after i moves). Then the value of the path is calculated as a_{c_0} + a_{c_1} + ... + a_{c_k}.
Your task is to calculate the sum of values over all possible good paths. Since this number can be very large, output it modulo 10^9 + 7. Two good paths are considered different if the starting cell differs or there exists an integer i ∈ [1, k] such that the current cell of the robot after exactly i moves is different in those paths.
You must process q updates to a and print the updated sum each time. Each update changes the value of exactly one cell. See the input format and the sample input-output for more details.
Input
The first line of the input contains three space-separated integers n, k and q (2 ≤ n ≤ 5000; 1 ≤ k ≤ 5000; 1 ≤ q ≤ 2 ⋅ 10^5).
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9).
q lines follow. Each line contains two space-separated integers i and x (1 ≤ i ≤ n; 1 ≤ x ≤ 10^9) indicating that you must change the value of a_i to x.
Output
Print q integers. The i-th integer should be the sum of values over all good paths after the first i updates are performed. Since the answers may be large, print them modulo 10^9 + 7.
Examples
Input
5 1 5
3 5 1 4 2
1 9
2 4
3 6
4 6
5 2
Output
62
58
78
86
86
Input
5 2 5
3 5 1 4 2
1 9
2 4
3 6
4 6
5 2
Output
157
147
207
227
227
Input
4 40 6
92 21 82 46
3 56
1 72
4 28
1 97
2 49
2 88
Output
239185261
666314041
50729936
516818968
766409450
756910476
Note
In the first example, the good paths are (1, 2), (2, 1), (2, 3), (3, 2), (3, 4), (4, 3), (4, 5), (5, 4).
Initially the values of a are [3, 5, 1, 4, 2]. After the first update, they become [9, 5, 1, 4, 2]. After the second update, they become [9, 4, 1, 4, 2], and so on. | instruction | 0 | 25,818 | 15 | 51,636 |
Tags: combinatorics, dp, math
Correct Solution:
```
import io,os;input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
n,k,q = map(int,input().split());mod = 10**9+7;dp = [[0 for j in range((n+1)//2)] for i in range(k//2+1)];dp[0] = [1 for j in range((n+1)//2)]
for i in range(1,k//2+1):
for j in range((n+1)//2):
if j:dp[i][j] += dp[i-1][j-1];dp[i][j] %= mod
if j!=(n+1)//2-1:dp[i][j] += dp[i-1][j+1];dp[i][j] %= mod
if n%2==1:dp[i][(n+1)//2-1] += dp[i-1][(n+1)//2-2];dp[i][(n+1)//2-1] %= mod
else:dp[i][(n+1)//2-1] += dp[i-1][(n+1)//2-1];dp[i][(n+1)//2-1] %= mod
cnt = [0 for i in range((n+1)//2)]
if k%2==0:
for i in range((n+1)//2):cnt[i] += dp[k//2][i] * dp[k//2][i];cnt[i] %= mod
sub = [dp[-1][j] for j in range((n+1)//2)]
for i in range(k//2+1,k+1):
next = [0 for j in range((n+1)//2)]
for j in range((n+1)//2):
if j:next[j] += sub[j-1];next[j] %= mod
if j!=(n+1)//2-1:next[j] += sub[j+1];next[j] %= mod
if n%2==1:next[(n+1)//2-1] += sub[(n+1)//2-2];next[(n+1)//2-1] %= mod
else:next[(n+1)//2-1] += sub[(n+1)//2-1];next[(n+1)//2-1] %= mod
for j in range((n+1)//2):cnt[j] += 2 * next[j] * dp[k-i][j];cnt[j] %= mod
sub = next
cnt += ([cnt[-2-j] for j in range(n//2)] if n%2==1 else [cnt[-1-j] for j in range(n//2)]);a = list(map(int,input().split()));res = 0;ans = []
for i in range(n):res += a[i] * cnt[i];res %= mod
for i in range(q):idx,x = map(int,input().split());idx -= 1;res = res + cnt[idx] * (x - a[idx]);res %= mod;a[idx] = x;ans.append(res)
print(*ans,sep="\n")
``` | output | 1 | 25,818 | 15 | 51,637 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n cells, numbered 1,2,..., n from left to right. You have to place a robot at any cell initially. The robot must make exactly k moves.
In one move, the robot must move one cell to the left or right, provided that it doesn't move out of bounds. In other words, if the robot was in the cell i, it must move to either the cell i-1 or the cell i+1, as long as it lies between 1 and n (endpoints inclusive). The cells, in the order they are visited (including the cell the robot is placed), together make a good path.
Each cell i has a value a_i associated with it. Let c_0, c_1, ..., c_k be the sequence of cells in a good path in the order they are visited (c_0 is the cell robot is initially placed, c_1 is the cell where the robot is after its first move, and so on; more formally, c_i is the cell that the robot is at after i moves). Then the value of the path is calculated as a_{c_0} + a_{c_1} + ... + a_{c_k}.
Your task is to calculate the sum of values over all possible good paths. Since this number can be very large, output it modulo 10^9 + 7. Two good paths are considered different if the starting cell differs or there exists an integer i ∈ [1, k] such that the current cell of the robot after exactly i moves is different in those paths.
You must process q updates to a and print the updated sum each time. Each update changes the value of exactly one cell. See the input format and the sample input-output for more details.
Input
The first line of the input contains three space-separated integers n, k and q (2 ≤ n ≤ 5000; 1 ≤ k ≤ 5000; 1 ≤ q ≤ 2 ⋅ 10^5).
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9).
q lines follow. Each line contains two space-separated integers i and x (1 ≤ i ≤ n; 1 ≤ x ≤ 10^9) indicating that you must change the value of a_i to x.
Output
Print q integers. The i-th integer should be the sum of values over all good paths after the first i updates are performed. Since the answers may be large, print them modulo 10^9 + 7.
Examples
Input
5 1 5
3 5 1 4 2
1 9
2 4
3 6
4 6
5 2
Output
62
58
78
86
86
Input
5 2 5
3 5 1 4 2
1 9
2 4
3 6
4 6
5 2
Output
157
147
207
227
227
Input
4 40 6
92 21 82 46
3 56
1 72
4 28
1 97
2 49
2 88
Output
239185261
666314041
50729936
516818968
766409450
756910476
Note
In the first example, the good paths are (1, 2), (2, 1), (2, 3), (3, 2), (3, 4), (4, 3), (4, 5), (5, 4).
Initially the values of a are [3, 5, 1, 4, 2]. After the first update, they become [9, 5, 1, 4, 2]. After the second update, they become [9, 4, 1, 4, 2], and so on. | instruction | 0 | 25,819 | 15 | 51,638 |
Tags: combinatorics, dp, math
Correct Solution:
```
import sys, io, os
read = sys.stdin.readline
#read = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
input = lambda: map(int, read().split())
M = 10 ** 9 + 7
n, k, q = input()
a = list(input())
r = [0] * (n * (k + 1))
for i in range(n):
r[i] = 1
for j in range(1, k + 1):
for i in range(1, n - 1):
r[j * n + i] = r[(j - 1) * n + i - 1] + r[(j - 1) * n + i + 1]
if r[j * n + i] > M:
r[j * n + i] -= M
r[j * n] = r[(j - 1) * n + 1]
r[j * n + n - 1] = r[(j - 1) * n + n - 2]
s = [0] * n
for i in range(n):
for j in range(k + 1):
s[i] = (s[i] + r[j * n + i] * r[(k - j) * n + i]) % M
v = 0
for i in range(n):
v = (v + s[i] * a[i]) % M
out = []
for _ in range(q):
i, x = input()
v = (v + (x - a[i - 1]) * s[i - 1]) % M
a[i - 1] = x
out.append(str(v))
print('\n'.join(out))
``` | output | 1 | 25,819 | 15 | 51,639 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.