message stringlengths 2 48.6k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 318 108k | cluster float64 8 8 | __index_level_0__ int64 636 217k |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
You have a fence consisting of n vertical boards. The width of each board is 1. The height of the i-th board is a_i. You think that the fence is great if there is no pair of adjacent boards having the same height. More formally, the fence is great if and only if for all indices from 2 to n, the condition a_{i-1} ≠ a_i holds.
Unfortunately, it is possible that now your fence is not great. But you can change it! You can increase the length of the i-th board by 1, but you have to pay b_i rubles for it. The length of each board can be increased any number of times (possibly, zero).
Calculate the minimum number of rubles you have to spend to make the fence great again!
You have to answer q independent queries.
Input
The first line contains one integer q (1 ≤ q ≤ 3 ⋅ 10^5) — the number of queries.
The first line of each query contains one integers n (1 ≤ n ≤ 3 ⋅ 10^5) — the number of boards in the fence.
The following n lines of each query contain the descriptions of the boards. The i-th line contains two integers a_i and b_i (1 ≤ a_i, b_i ≤ 10^9) — the length of the i-th board and the price for increasing it by 1, respectively.
It is guaranteed that sum of all n over all queries not exceed 3 ⋅ 10^5.
It is guaranteed that answer to each query will not exceed 10^{18}.
Output
For each query print one integer — the minimum number of rubles you have to spend to make the fence great.
Example
Input
3
3
2 4
2 1
3 5
3
2 3
2 10
2 6
4
1 7
3 3
2 6
1000000000 2
Output
2
9
0
Note
In the first query you have to increase the length of second board by 2. So your total costs if 2 ⋅ b_2 = 2.
In the second query you have to increase the length of first board by 1 and the length of third board by 1. So your total costs if 1 ⋅ b_1 + 1 ⋅ b_3 = 9.
In the third query the fence is great initially, so you don't need to spend rubles. | instruction | 0 | 61,561 | 8 | 123,122 |
Tags: dp
Correct Solution:
```
import sys, math
INF = float("inf")
def main():
def input():
return sys.stdin.readline()[:-1]
q = int(input())
for _ in range(q):
n = int(input())
w = [list(map(int,input().split())) for k in range(n)]
dp = [[INF,INF,INF] for k in range(n)]
dp[0] = [0,w[0][1],2*w[0][1]]
for k in range(1,n):
for l in range(3):
for m in range(3):
if w[k-1][0]+l != w[k][0]+m:
dp[k][m] = min(dp[k][m], dp[k-1][l] + w[k][1]*m)
print(min(dp[n-1]))
if __name__ == '__main__':
main()
``` | output | 1 | 61,561 | 8 | 123,123 |
Provide tags and a correct Python 2 solution for this coding contest problem.
You have a fence consisting of n vertical boards. The width of each board is 1. The height of the i-th board is a_i. You think that the fence is great if there is no pair of adjacent boards having the same height. More formally, the fence is great if and only if for all indices from 2 to n, the condition a_{i-1} ≠ a_i holds.
Unfortunately, it is possible that now your fence is not great. But you can change it! You can increase the length of the i-th board by 1, but you have to pay b_i rubles for it. The length of each board can be increased any number of times (possibly, zero).
Calculate the minimum number of rubles you have to spend to make the fence great again!
You have to answer q independent queries.
Input
The first line contains one integer q (1 ≤ q ≤ 3 ⋅ 10^5) — the number of queries.
The first line of each query contains one integers n (1 ≤ n ≤ 3 ⋅ 10^5) — the number of boards in the fence.
The following n lines of each query contain the descriptions of the boards. The i-th line contains two integers a_i and b_i (1 ≤ a_i, b_i ≤ 10^9) — the length of the i-th board and the price for increasing it by 1, respectively.
It is guaranteed that sum of all n over all queries not exceed 3 ⋅ 10^5.
It is guaranteed that answer to each query will not exceed 10^{18}.
Output
For each query print one integer — the minimum number of rubles you have to spend to make the fence great.
Example
Input
3
3
2 4
2 1
3 5
3
2 3
2 10
2 6
4
1 7
3 3
2 6
1000000000 2
Output
2
9
0
Note
In the first query you have to increase the length of second board by 2. So your total costs if 2 ⋅ b_2 = 2.
In the second query you have to increase the length of first board by 1 and the length of third board by 1. So your total costs if 1 ⋅ b_1 + 1 ⋅ b_3 = 9.
In the third query the fence is great initially, so you don't need to spend rubles. | instruction | 0 | 61,562 | 8 | 123,124 |
Tags: dp
Correct Solution:
```
from sys import stdin, stdout
from collections import Counter, defaultdict
from itertools import permutations, combinations
raw_input = stdin.readline
pr = stdout.write
mod=10**9+7
def ni():
return int(raw_input())
def li():
return map(int,raw_input().split())
def pn(n):
stdout.write(str(n)+'\n')
def pa(arr):
pr('\n'.join(map(str,arr))+'\n')
# fast read function for total integer input
def inp():
# this function returns whole input of
# space/line seperated integers
# Use Ctrl+D to flush stdin.
return map(int,stdin.read().split())
range = xrange # not for python 3.0+
#main code
o=[]
for t in range(ni()):
n=ni()
l=[]
for i in range(n):
l.append(li())
dp=[[10**18,10**18,10**18] for i in range(n)]
dp[0][1]=l[0][1]
dp[0][0]=0
dp[0][2]=2*l[0][1]
for i in range(n-1):
for j in range(3):
for k in range(3):
if l[i][0]+j!=l[i+1][0]+k:
dp[i+1][k]=min(dp[i+1][k],dp[i][j]+(k*l[i+1][1]))
o.append(min(dp[-1]))
pa(o)
``` | output | 1 | 61,562 | 8 | 123,125 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have a fence consisting of n vertical boards. The width of each board is 1. The height of the i-th board is a_i. You think that the fence is great if there is no pair of adjacent boards having the same height. More formally, the fence is great if and only if for all indices from 2 to n, the condition a_{i-1} ≠ a_i holds.
Unfortunately, it is possible that now your fence is not great. But you can change it! You can increase the length of the i-th board by 1, but you have to pay b_i rubles for it. The length of each board can be increased any number of times (possibly, zero).
Calculate the minimum number of rubles you have to spend to make the fence great again!
You have to answer q independent queries.
Input
The first line contains one integer q (1 ≤ q ≤ 3 ⋅ 10^5) — the number of queries.
The first line of each query contains one integers n (1 ≤ n ≤ 3 ⋅ 10^5) — the number of boards in the fence.
The following n lines of each query contain the descriptions of the boards. The i-th line contains two integers a_i and b_i (1 ≤ a_i, b_i ≤ 10^9) — the length of the i-th board and the price for increasing it by 1, respectively.
It is guaranteed that sum of all n over all queries not exceed 3 ⋅ 10^5.
It is guaranteed that answer to each query will not exceed 10^{18}.
Output
For each query print one integer — the minimum number of rubles you have to spend to make the fence great.
Example
Input
3
3
2 4
2 1
3 5
3
2 3
2 10
2 6
4
1 7
3 3
2 6
1000000000 2
Output
2
9
0
Note
In the first query you have to increase the length of second board by 2. So your total costs if 2 ⋅ b_2 = 2.
In the second query you have to increase the length of first board by 1 and the length of third board by 1. So your total costs if 1 ⋅ b_1 + 1 ⋅ b_3 = 9.
In the third query the fence is great initially, so you don't need to spend rubles.
Submitted Solution:
```
'''
Auther: ghoshashis545 Ashis Ghosh
College: jalpaiguri Govt Enggineering College
'''
from os import path
import sys
from heapq import heappush,heappop
from functools import cmp_to_key as ctk
from collections import deque,defaultdict as dd
from bisect import bisect,bisect_left,bisect_right,insort,insort_left,insort_right
from itertools import permutations
from datetime import datetime
from math import ceil,sqrt,log,gcd
def ii():return int(input())
def si():return input()
def mi():return map(int,input().split())
def li():return list(mi())
abc='abcdefghijklmnopqrstuvwxyz'
# mod=1000000007
mod=998244353
inf = float("inf")
vow=['a','e','i','o','u']
dx,dy=[-1,1,0,0],[0,0,1,-1]
def bo(i):
return ord(i)-ord('a')
file=1
def solve():
for _ in range(ii()):
n=ii()
a=[]
for i in range(n):
a.append(li())
dp=[[0,0,0] for i in range(n)]
dp[0][1]=a[0][1]
dp[0][2]=2*a[0][1]
for i in range(1,n):
for j in range(3):
dp[i][j]=1e18
for k in range(3):
if(a[i-1][0]+k!=a[i][0]+j):
dp[i][j]=min(dp[i][j],dp[i-1][k]+j*a[i][1])
print(min(dp[-1]))
if __name__ =="__main__":
if(file):
if path.exists('input1.txt'):
sys.stdin=open('input1.txt', 'r')
sys.stdout=open('output1.txt','w')
else:
input=sys.stdin.readline
solve()
``` | instruction | 0 | 61,563 | 8 | 123,126 |
Yes | output | 1 | 61,563 | 8 | 123,127 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have a fence consisting of n vertical boards. The width of each board is 1. The height of the i-th board is a_i. You think that the fence is great if there is no pair of adjacent boards having the same height. More formally, the fence is great if and only if for all indices from 2 to n, the condition a_{i-1} ≠ a_i holds.
Unfortunately, it is possible that now your fence is not great. But you can change it! You can increase the length of the i-th board by 1, but you have to pay b_i rubles for it. The length of each board can be increased any number of times (possibly, zero).
Calculate the minimum number of rubles you have to spend to make the fence great again!
You have to answer q independent queries.
Input
The first line contains one integer q (1 ≤ q ≤ 3 ⋅ 10^5) — the number of queries.
The first line of each query contains one integers n (1 ≤ n ≤ 3 ⋅ 10^5) — the number of boards in the fence.
The following n lines of each query contain the descriptions of the boards. The i-th line contains two integers a_i and b_i (1 ≤ a_i, b_i ≤ 10^9) — the length of the i-th board and the price for increasing it by 1, respectively.
It is guaranteed that sum of all n over all queries not exceed 3 ⋅ 10^5.
It is guaranteed that answer to each query will not exceed 10^{18}.
Output
For each query print one integer — the minimum number of rubles you have to spend to make the fence great.
Example
Input
3
3
2 4
2 1
3 5
3
2 3
2 10
2 6
4
1 7
3 3
2 6
1000000000 2
Output
2
9
0
Note
In the first query you have to increase the length of second board by 2. So your total costs if 2 ⋅ b_2 = 2.
In the second query you have to increase the length of first board by 1 and the length of third board by 1. So your total costs if 1 ⋅ b_1 + 1 ⋅ b_3 = 9.
In the third query the fence is great initially, so you don't need to spend rubles.
Submitted Solution:
```
import sys
input = sys.stdin.readline
q = int(input())
for _ in range(q):
n = int(input())
a, b = [], []
for _ in range(n):
ai, bi = map(int, input().split())
a.append(ai)
b.append(bi)
dp = [[10**18]*3 for _ in range(n)]
dp[0][0] = 0
dp[0][1] = b[0]
dp[0][2] = 2*b[0]
for i in range(n-1):
for j in range(3):
for k in range(3):
if a[i+1]+j!=a[i]+k:
dp[i+1][j] = min(dp[i+1][j], dp[i][k]+b[i+1]*j)
print(min(dp[n-1]))
``` | instruction | 0 | 61,564 | 8 | 123,128 |
Yes | output | 1 | 61,564 | 8 | 123,129 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have a fence consisting of n vertical boards. The width of each board is 1. The height of the i-th board is a_i. You think that the fence is great if there is no pair of adjacent boards having the same height. More formally, the fence is great if and only if for all indices from 2 to n, the condition a_{i-1} ≠ a_i holds.
Unfortunately, it is possible that now your fence is not great. But you can change it! You can increase the length of the i-th board by 1, but you have to pay b_i rubles for it. The length of each board can be increased any number of times (possibly, zero).
Calculate the minimum number of rubles you have to spend to make the fence great again!
You have to answer q independent queries.
Input
The first line contains one integer q (1 ≤ q ≤ 3 ⋅ 10^5) — the number of queries.
The first line of each query contains one integers n (1 ≤ n ≤ 3 ⋅ 10^5) — the number of boards in the fence.
The following n lines of each query contain the descriptions of the boards. The i-th line contains two integers a_i and b_i (1 ≤ a_i, b_i ≤ 10^9) — the length of the i-th board and the price for increasing it by 1, respectively.
It is guaranteed that sum of all n over all queries not exceed 3 ⋅ 10^5.
It is guaranteed that answer to each query will not exceed 10^{18}.
Output
For each query print one integer — the minimum number of rubles you have to spend to make the fence great.
Example
Input
3
3
2 4
2 1
3 5
3
2 3
2 10
2 6
4
1 7
3 3
2 6
1000000000 2
Output
2
9
0
Note
In the first query you have to increase the length of second board by 2. So your total costs if 2 ⋅ b_2 = 2.
In the second query you have to increase the length of first board by 1 and the length of third board by 1. So your total costs if 1 ⋅ b_1 + 1 ⋅ b_3 = 9.
In the third query the fence is great initially, so you don't need to spend rubles.
Submitted Solution:
```
from typing import Iterator, Callable
import sys
input = sys.stdin.readline
def read_inp() -> 'Iterator[tuple[int, int]]':
for _ in range(int(input())):
yield map(int, input().split())
yield None, None
def get_answer(get_next: 'Callable[[], tuple[int, int]]') -> 'int':
a1, b1 = get_next()
dp_last_row = {a1: 0, a1 + 1: b1, a1 + 2: b1 * 2}
while True:
a_i, b_i = get_next()
if a_i is None:
break
now = {}
for diff in range(3):
for prev_last, prev_cost in dp_last_row.items():
last = a_i + diff
if last == prev_last:
continue
cur = prev_cost + (b_i * diff)
if (last not in now) or (now[last] > cur):
now[last] = cur
dp_last_row = now
return min(dp_last_row.items(), key=lambda x: x[1])[1]
if __name__ == '__main__':
for _ in range(int(input())):
data = read_inp()
print(get_answer(lambda: next(data)))
``` | instruction | 0 | 61,565 | 8 | 123,130 |
Yes | output | 1 | 61,565 | 8 | 123,131 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have a fence consisting of n vertical boards. The width of each board is 1. The height of the i-th board is a_i. You think that the fence is great if there is no pair of adjacent boards having the same height. More formally, the fence is great if and only if for all indices from 2 to n, the condition a_{i-1} ≠ a_i holds.
Unfortunately, it is possible that now your fence is not great. But you can change it! You can increase the length of the i-th board by 1, but you have to pay b_i rubles for it. The length of each board can be increased any number of times (possibly, zero).
Calculate the minimum number of rubles you have to spend to make the fence great again!
You have to answer q independent queries.
Input
The first line contains one integer q (1 ≤ q ≤ 3 ⋅ 10^5) — the number of queries.
The first line of each query contains one integers n (1 ≤ n ≤ 3 ⋅ 10^5) — the number of boards in the fence.
The following n lines of each query contain the descriptions of the boards. The i-th line contains two integers a_i and b_i (1 ≤ a_i, b_i ≤ 10^9) — the length of the i-th board and the price for increasing it by 1, respectively.
It is guaranteed that sum of all n over all queries not exceed 3 ⋅ 10^5.
It is guaranteed that answer to each query will not exceed 10^{18}.
Output
For each query print one integer — the minimum number of rubles you have to spend to make the fence great.
Example
Input
3
3
2 4
2 1
3 5
3
2 3
2 10
2 6
4
1 7
3 3
2 6
1000000000 2
Output
2
9
0
Note
In the first query you have to increase the length of second board by 2. So your total costs if 2 ⋅ b_2 = 2.
In the second query you have to increase the length of first board by 1 and the length of third board by 1. So your total costs if 1 ⋅ b_1 + 1 ⋅ b_3 = 9.
In the third query the fence is great initially, so you don't need to spend rubles.
Submitted Solution:
```
from math import inf as inf
import sys
for t in range (int(input())):
n=int(sys.stdin.readline())
dp=[[inf,inf,inf] for i in range (n+1)]
a=[]
for i in range(n):
a.append(list(map(int,sys.stdin.readline().split())))
dp[0]=[0,a[0][1],a[0][1]*2]
for i in range(1,n):
for j in range (3):
for k in range (3):
if(a[i][0]+j!=a[i-1][0]+k):
dp[i][j]=min(dp[i][j],dp[i-1][k]+a[i][1]*j)
print(min(dp[n-1]))
``` | instruction | 0 | 61,566 | 8 | 123,132 |
Yes | output | 1 | 61,566 | 8 | 123,133 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have a fence consisting of n vertical boards. The width of each board is 1. The height of the i-th board is a_i. You think that the fence is great if there is no pair of adjacent boards having the same height. More formally, the fence is great if and only if for all indices from 2 to n, the condition a_{i-1} ≠ a_i holds.
Unfortunately, it is possible that now your fence is not great. But you can change it! You can increase the length of the i-th board by 1, but you have to pay b_i rubles for it. The length of each board can be increased any number of times (possibly, zero).
Calculate the minimum number of rubles you have to spend to make the fence great again!
You have to answer q independent queries.
Input
The first line contains one integer q (1 ≤ q ≤ 3 ⋅ 10^5) — the number of queries.
The first line of each query contains one integers n (1 ≤ n ≤ 3 ⋅ 10^5) — the number of boards in the fence.
The following n lines of each query contain the descriptions of the boards. The i-th line contains two integers a_i and b_i (1 ≤ a_i, b_i ≤ 10^9) — the length of the i-th board and the price for increasing it by 1, respectively.
It is guaranteed that sum of all n over all queries not exceed 3 ⋅ 10^5.
It is guaranteed that answer to each query will not exceed 10^{18}.
Output
For each query print one integer — the minimum number of rubles you have to spend to make the fence great.
Example
Input
3
3
2 4
2 1
3 5
3
2 3
2 10
2 6
4
1 7
3 3
2 6
1000000000 2
Output
2
9
0
Note
In the first query you have to increase the length of second board by 2. So your total costs if 2 ⋅ b_2 = 2.
In the second query you have to increase the length of first board by 1 and the length of third board by 1. So your total costs if 1 ⋅ b_1 + 1 ⋅ b_3 = 9.
In the third query the fence is great initially, so you don't need to spend rubles.
Submitted Solution:
```
# https://codeforces.com/problemset/problem/1221/D
def great_fence_cost(n, a, b):
min_fences = []
min_costs = []
min_fences.append([a[0]])
min_costs.append(0)
for i in range(1, n):
cur_board = a[i]
cur_cost = b[i]
prev_min_fence = min_fences[i - 1]
prev_min_cost = min_costs[i - 1]
if cur_board == prev_min_fence[-1]:
cur_min_fence_1 = prev_min_fence + [cur_board + 1]
cur_min_cost_1 = prev_min_cost + cur_cost
cur_min_fence_2, fixing_cost = fix_fence(prev_min_fence + [cur_board], b)
cur_min_cost_2 = prev_min_cost + fixing_cost
min_fences.append(cur_min_fence_2 if cur_min_cost_1 > cur_min_cost_2 else cur_min_fence_1)
min_costs.append(cur_min_cost_2 if cur_min_cost_1 > cur_min_cost_2 else cur_min_cost_1)
else:
min_fences.append(prev_min_fence + [cur_board])
min_costs.append(prev_min_cost)
return min_costs[n-1]
def fix_fence(broken_fence, costs):
assert len(broken_fence) > 1
assert broken_fence[-1] == broken_fence[-2]
fixing_cost = 0
fixed_fence = broken_fence.copy()
start_board_idx = len(broken_fence) - 1
for i in range(start_board_idx, -1, -1):
if i == 0 or fixed_fence[i] != fixed_fence[i-1]:
break
fixed_fence[i-1] += 1
fixing_cost += costs[i-1]
return fixed_fence, fixing_cost
def solve():
query_number = int(input())
for i in range(query_number):
n = int(input())
a = []
b = []
for j in range(n):
aj, bj = list(map(int, input().split(" ")))
a.append(aj)
b.append(bj)
print(great_fence_cost(n, a, b))
solve()
``` | instruction | 0 | 61,567 | 8 | 123,134 |
No | output | 1 | 61,567 | 8 | 123,135 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have a fence consisting of n vertical boards. The width of each board is 1. The height of the i-th board is a_i. You think that the fence is great if there is no pair of adjacent boards having the same height. More formally, the fence is great if and only if for all indices from 2 to n, the condition a_{i-1} ≠ a_i holds.
Unfortunately, it is possible that now your fence is not great. But you can change it! You can increase the length of the i-th board by 1, but you have to pay b_i rubles for it. The length of each board can be increased any number of times (possibly, zero).
Calculate the minimum number of rubles you have to spend to make the fence great again!
You have to answer q independent queries.
Input
The first line contains one integer q (1 ≤ q ≤ 3 ⋅ 10^5) — the number of queries.
The first line of each query contains one integers n (1 ≤ n ≤ 3 ⋅ 10^5) — the number of boards in the fence.
The following n lines of each query contain the descriptions of the boards. The i-th line contains two integers a_i and b_i (1 ≤ a_i, b_i ≤ 10^9) — the length of the i-th board and the price for increasing it by 1, respectively.
It is guaranteed that sum of all n over all queries not exceed 3 ⋅ 10^5.
It is guaranteed that answer to each query will not exceed 10^{18}.
Output
For each query print one integer — the minimum number of rubles you have to spend to make the fence great.
Example
Input
3
3
2 4
2 1
3 5
3
2 3
2 10
2 6
4
1 7
3 3
2 6
1000000000 2
Output
2
9
0
Note
In the first query you have to increase the length of second board by 2. So your total costs if 2 ⋅ b_2 = 2.
In the second query you have to increase the length of first board by 1 and the length of third board by 1. So your total costs if 1 ⋅ b_1 + 1 ⋅ b_3 = 9.
In the third query the fence is great initially, so you don't need to spend rubles.
Submitted Solution:
```
t=int(input())
while t>0:
t-=1
n=int(input())
a=[];b=[]
for i in range(n):
x,y=input().split()
x=int(x)
y=int(y)
a.append(x)
b.append(y)
p=0
sl=0
for i in range(n-1):
if a[i]==a[i+1] :
if b[i]<b[i+1] :
a[i]+=1
sl+=b[i]
elif b[i]==b[i+1]:
a[i]+=1
sl+=b[i]
else:
a[i+1]+=1
sl+=b[i+1]
p=i
if i>0 and a[i]==a[i-1]:
if b[i]>b[i-1]:
a[i-1]+=1
sl+=b[i-1]
else:
a[i]+=1
sl+=b[i]
# p=i
#print(a)
print(sl)
a.clear()
b.clear()
``` | instruction | 0 | 61,568 | 8 | 123,136 |
No | output | 1 | 61,568 | 8 | 123,137 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have a fence consisting of n vertical boards. The width of each board is 1. The height of the i-th board is a_i. You think that the fence is great if there is no pair of adjacent boards having the same height. More formally, the fence is great if and only if for all indices from 2 to n, the condition a_{i-1} ≠ a_i holds.
Unfortunately, it is possible that now your fence is not great. But you can change it! You can increase the length of the i-th board by 1, but you have to pay b_i rubles for it. The length of each board can be increased any number of times (possibly, zero).
Calculate the minimum number of rubles you have to spend to make the fence great again!
You have to answer q independent queries.
Input
The first line contains one integer q (1 ≤ q ≤ 3 ⋅ 10^5) — the number of queries.
The first line of each query contains one integers n (1 ≤ n ≤ 3 ⋅ 10^5) — the number of boards in the fence.
The following n lines of each query contain the descriptions of the boards. The i-th line contains two integers a_i and b_i (1 ≤ a_i, b_i ≤ 10^9) — the length of the i-th board and the price for increasing it by 1, respectively.
It is guaranteed that sum of all n over all queries not exceed 3 ⋅ 10^5.
It is guaranteed that answer to each query will not exceed 10^{18}.
Output
For each query print one integer — the minimum number of rubles you have to spend to make the fence great.
Example
Input
3
3
2 4
2 1
3 5
3
2 3
2 10
2 6
4
1 7
3 3
2 6
1000000000 2
Output
2
9
0
Note
In the first query you have to increase the length of second board by 2. So your total costs if 2 ⋅ b_2 = 2.
In the second query you have to increase the length of first board by 1 and the length of third board by 1. So your total costs if 1 ⋅ b_1 + 1 ⋅ b_3 = 9.
In the third query the fence is great initially, so you don't need to spend rubles.
Submitted Solution:
```
'''
You have a fence consisting of n vertical boards. The width of each board is 1. The height of the i-th board is ai. You think that the fence is great if there is no pair of adjacent boards having the same height. More formally, the fence is great if and only if for all indices from 2 to n, the condition ai−1≠ai holds.
Unfortunately, it is possible that now your fence is not great. But you can change it! You can increase the length of the i-th board by 1, but you have to pay bi rubles for it. The length of each board can be increased any number of times (possibly, zero).
Calculate the minimum number of rubles you have to spend to make the fence great again!
You have to answer q independent queries.
Input
The first line contains one integer q (1≤q≤3⋅105) — the number of queries.
The first line of each query contains one integers n (1≤n≤3⋅105) — the number of boards in the fence.
The following n lines of each query contain the descriptions of the boards. The i-th line contains two integers ai and bi (1≤ai,bi≤109) — the length of the i-th board and the price for increasing it by 1, respectively.
It is guaranteed that sum of all n over all queries not exceed 3⋅105.
It is guaranteed that answer to each query will not exceed 1018.
Output
For each query print one integer — the minimum number of rubles you have to spend to make the fence great.
Example
input
3
3
2 4
2 1
3 5
3
2 3
2 10
2 6
4
1 7
3 3
2 6
1000000000 2
output
2
9
0
Note
In the first query you have to increase the length of second board by 2. So your total costs if 2⋅b2=2.
In the second query you have to increase the length of first board by 1 and the length of third board by 1. So your total costs if 1⋅b1+1⋅b3=9.
In the third query the fence is great initially, so you don't need to spend rubles.
'''
def get_price_to_great_fence() -> int:
def make_great(start_index, direction='forward'):
fence[start_index][0] += 1
if direction == 'forward' and start_index + 1 < fence_length:
if fence[start_index][0] == fence[start_index+1][0]:
make_great(start_index + 1)
elif start_index - 1 >= 0:
if fence[start_index][0] == fence[start_index-1][0]:
make_great(start_index - 1, direction='back')
def get_min_price_and_index(i_1:int , i_2:int) -> int:
cost_1 = fence[i_1][1]
cost_2 = fence[i_2][1]
if i_1 - 1 >= 0 and fence[i_1][0] + 1 == fence[i_1 - 1][0]:
cost_1 += get_min_price_and_index(i_1 - 1, i_1)[0]
elif i_2 + 1 < fence_length and fence[i_2][0] + 1 == fence[i_2 + 1][0]:
cost_2 += get_min_price_and_index(i_2, i_2 + 1)[0]
if cost_1 < cost_2:
index = i_1
else:
index = i_2
return min(cost_1, cost_2), index
fence = []
fence_length = int(input())
final_price = 0
for _ in range(fence_length):
length, price = map(int, input().split())
fence.append([length, price])
if len(fence) == 1:
return final_price
for i in range(1, fence_length):
if fence[i-1][0] == fence[i][0]:
price, index = get_min_price_and_index(i-1, i)
final_price += price
if index == i-1:
direction = 'back'
else:
direction = 'forward'
make_great(index, direction)
return final_price
for _ in range(int(input())):
print(get_price_to_great_fence())
``` | instruction | 0 | 61,569 | 8 | 123,138 |
No | output | 1 | 61,569 | 8 | 123,139 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have a fence consisting of n vertical boards. The width of each board is 1. The height of the i-th board is a_i. You think that the fence is great if there is no pair of adjacent boards having the same height. More formally, the fence is great if and only if for all indices from 2 to n, the condition a_{i-1} ≠ a_i holds.
Unfortunately, it is possible that now your fence is not great. But you can change it! You can increase the length of the i-th board by 1, but you have to pay b_i rubles for it. The length of each board can be increased any number of times (possibly, zero).
Calculate the minimum number of rubles you have to spend to make the fence great again!
You have to answer q independent queries.
Input
The first line contains one integer q (1 ≤ q ≤ 3 ⋅ 10^5) — the number of queries.
The first line of each query contains one integers n (1 ≤ n ≤ 3 ⋅ 10^5) — the number of boards in the fence.
The following n lines of each query contain the descriptions of the boards. The i-th line contains two integers a_i and b_i (1 ≤ a_i, b_i ≤ 10^9) — the length of the i-th board and the price for increasing it by 1, respectively.
It is guaranteed that sum of all n over all queries not exceed 3 ⋅ 10^5.
It is guaranteed that answer to each query will not exceed 10^{18}.
Output
For each query print one integer — the minimum number of rubles you have to spend to make the fence great.
Example
Input
3
3
2 4
2 1
3 5
3
2 3
2 10
2 6
4
1 7
3 3
2 6
1000000000 2
Output
2
9
0
Note
In the first query you have to increase the length of second board by 2. So your total costs if 2 ⋅ b_2 = 2.
In the second query you have to increase the length of first board by 1 and the length of third board by 1. So your total costs if 1 ⋅ b_1 + 1 ⋅ b_3 = 9.
In the third query the fence is great initially, so you don't need to spend rubles.
Submitted Solution:
```
"""
NTC here
"""
from sys import setcheckinterval, stdin, setrecursionlimit
setcheckinterval(1000)
setrecursionlimit(10**7)
# print("Case #{}: {} {}".format(i, n + m, n * m))
def iin(): return int(stdin.readline())
def lin(): return list(map(int, stdin.readline().split()))
for _ in range(iin()):
n=iin()
fence=[lin() for i in range(n)]
pv=[0 for i in range(n)]
cost=0
incr=0
if n>1:
if fence[0][0]==fence[1][0]+1:
pv[0]=fence[0][1]
nxt=[0 for i in range(n)]
for i in range(n-1):
if fence[i][0]+1==fence[i+1][0]:
nxt[i]=fence[i+1][1]
for i in range(n-1,0,-1):
nxt[i-1]+=nxt[i]
for i in range(n-1):
if fence[i][0]+1!=fence[i+1][0]:
nxt[i]=0
for idx in range(1,n):
#print(idx,pv)
if nxt[idx]==0:incr=0
if fence[idx][0]+incr==fence[idx-1][0]:
i,j=fence[idx]
do=1
if idx<n-1 and fence[idx+1][0]==i+1:
do=2
pdo=1
p1=fence[idx-1][1]
if pv[idx-1]:
pi,pj=fence[idx-1]
if pj+pv[idx-1]<=2*pj:
p1+=pv[idx-1]
else:
pdo+=1
p1+=pj
nx1=0
if nxt[idx]:
nx1=nxt[idx]+j
#print(p1,do*j,nx1)
if p1<do*j:
if nx1 and nx1<p1:
cost+=nx1
fence[idx][0]+=1
# print('A')
incr+=1
else:
cost+=p1
fence[idx-1][0]+=pdo
else:
if nx1 and nx1<do*j:
cost+=nx1
fence[idx][0]+=1
incr+=1
# print('A')
else:
fence[idx][0]+=do
cost+=do*j
if fence[idx][0]+1==fence[idx-1][0]:
pv[idx]=fence[idx][1]
pv[idx]+=pv[idx-1]
print(cost)
#print(fence,nxt)
``` | instruction | 0 | 61,570 | 8 | 123,140 |
No | output | 1 | 61,570 | 8 | 123,141 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Our old friend Alexey has finally entered the University of City N — the Berland capital. Alexey expected his father to get him a place to live in but his father said it was high time for Alexey to practice some financial independence. So, Alexey is living in a dorm.
The dorm has exactly one straight dryer — a 100 centimeter long rope to hang clothes on. The dryer has got a coordinate system installed: the leftmost end of the dryer has coordinate 0, and the opposite end has coordinate 100. Overall, the university has n students. Dean's office allows i-th student to use the segment (li, ri) of the dryer. However, the dean's office actions are contradictory and now one part of the dryer can belong to multiple students!
Alexey don't like when someone touch his clothes. That's why he want make it impossible to someone clothes touch his ones. So Alexey wonders: what is the total length of the parts of the dryer that he may use in a such way that clothes of the others (n - 1) students aren't drying there. Help him! Note that Alexey, as the most respected student, has number 1.
Input
The first line contains a positive integer n (1 ≤ n ≤ 100). The (i + 1)-th line contains integers li and ri (0 ≤ li < ri ≤ 100) — the endpoints of the corresponding segment for the i-th student.
Output
On a single line print a single number k, equal to the sum of lengths of the parts of the dryer which are inside Alexey's segment and are outside all other segments.
Examples
Input
3
0 5
2 8
1 6
Output
1
Input
3
0 10
1 5
7 15
Output
3
Note
Note that it's not important are clothes drying on the touching segments (e.g. (0, 1) and (1, 2)) considered to be touching or not because you need to find the length of segments.
In the first test sample Alexey may use the only segment (0, 1). In such case his clothes will not touch clothes on the segments (1, 6) and (2, 8). The length of segment (0, 1) is 1.
In the second test sample Alexey may dry his clothes on segments (0, 1) and (5, 7). Overall length of these segments is 3. | instruction | 0 | 61,776 | 8 | 123,552 |
Tags: implementation
Correct Solution:
```
n = int(input())
seta = set()
ax,ay = map(int, input().split(" "))
for i in range(ax,ay):
seta.add(i+0.5)
for i in range(0,n-1):
nx,ny = map(int, input().split(" "))
for j in range(nx,ny):
seta.discard(j+0.5)
print(len(seta))
``` | output | 1 | 61,776 | 8 | 123,553 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Our old friend Alexey has finally entered the University of City N — the Berland capital. Alexey expected his father to get him a place to live in but his father said it was high time for Alexey to practice some financial independence. So, Alexey is living in a dorm.
The dorm has exactly one straight dryer — a 100 centimeter long rope to hang clothes on. The dryer has got a coordinate system installed: the leftmost end of the dryer has coordinate 0, and the opposite end has coordinate 100. Overall, the university has n students. Dean's office allows i-th student to use the segment (li, ri) of the dryer. However, the dean's office actions are contradictory and now one part of the dryer can belong to multiple students!
Alexey don't like when someone touch his clothes. That's why he want make it impossible to someone clothes touch his ones. So Alexey wonders: what is the total length of the parts of the dryer that he may use in a such way that clothes of the others (n - 1) students aren't drying there. Help him! Note that Alexey, as the most respected student, has number 1.
Input
The first line contains a positive integer n (1 ≤ n ≤ 100). The (i + 1)-th line contains integers li and ri (0 ≤ li < ri ≤ 100) — the endpoints of the corresponding segment for the i-th student.
Output
On a single line print a single number k, equal to the sum of lengths of the parts of the dryer which are inside Alexey's segment and are outside all other segments.
Examples
Input
3
0 5
2 8
1 6
Output
1
Input
3
0 10
1 5
7 15
Output
3
Note
Note that it's not important are clothes drying on the touching segments (e.g. (0, 1) and (1, 2)) considered to be touching or not because you need to find the length of segments.
In the first test sample Alexey may use the only segment (0, 1). In such case his clothes will not touch clothes on the segments (1, 6) and (2, 8). The length of segment (0, 1) is 1.
In the second test sample Alexey may dry his clothes on segments (0, 1) and (5, 7). Overall length of these segments is 3. | instruction | 0 | 61,777 | 8 | 123,554 |
Tags: implementation
Correct Solution:
```
# https://codeforces.com/problemset/problem/397/A
# A. On Segment's Own Points
n = int(input())
rope = [True] * 100
x1, y1 = map(int, input().split())
for _ in range(1, n):
x , y = map(int, input().split())
for i in range(x, y):
rope[i] = False
total_len = sum(rope[x1:y1])
print(total_len)
``` | output | 1 | 61,777 | 8 | 123,555 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Our old friend Alexey has finally entered the University of City N — the Berland capital. Alexey expected his father to get him a place to live in but his father said it was high time for Alexey to practice some financial independence. So, Alexey is living in a dorm.
The dorm has exactly one straight dryer — a 100 centimeter long rope to hang clothes on. The dryer has got a coordinate system installed: the leftmost end of the dryer has coordinate 0, and the opposite end has coordinate 100. Overall, the university has n students. Dean's office allows i-th student to use the segment (li, ri) of the dryer. However, the dean's office actions are contradictory and now one part of the dryer can belong to multiple students!
Alexey don't like when someone touch his clothes. That's why he want make it impossible to someone clothes touch his ones. So Alexey wonders: what is the total length of the parts of the dryer that he may use in a such way that clothes of the others (n - 1) students aren't drying there. Help him! Note that Alexey, as the most respected student, has number 1.
Input
The first line contains a positive integer n (1 ≤ n ≤ 100). The (i + 1)-th line contains integers li and ri (0 ≤ li < ri ≤ 100) — the endpoints of the corresponding segment for the i-th student.
Output
On a single line print a single number k, equal to the sum of lengths of the parts of the dryer which are inside Alexey's segment and are outside all other segments.
Examples
Input
3
0 5
2 8
1 6
Output
1
Input
3
0 10
1 5
7 15
Output
3
Note
Note that it's not important are clothes drying on the touching segments (e.g. (0, 1) and (1, 2)) considered to be touching or not because you need to find the length of segments.
In the first test sample Alexey may use the only segment (0, 1). In such case his clothes will not touch clothes on the segments (1, 6) and (2, 8). The length of segment (0, 1) is 1.
In the second test sample Alexey may dry his clothes on segments (0, 1) and (5, 7). Overall length of these segments is 3. | instruction | 0 | 61,778 | 8 | 123,556 |
Tags: implementation
Correct Solution:
```
# read in data
n = int(input())
segments = [0] * n
for i in range(n):
segments[i] = tuple(map(int, input().split(' ')))
# mark the segments
dry_line = [0]*101
for s in range(1, n):
l, r = segments[s]
dry_line[l] -= 1
dry_line[r] += 1
# calculate cumulative sum
for i in range(1, 101):
dry_line[i] += dry_line[i-1]
# calculate sum of exclusive segment
print(sum(1 for part in range(segments[0][0], segments[0][1]) if dry_line[part] == 0))
``` | output | 1 | 61,778 | 8 | 123,557 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Our old friend Alexey has finally entered the University of City N — the Berland capital. Alexey expected his father to get him a place to live in but his father said it was high time for Alexey to practice some financial independence. So, Alexey is living in a dorm.
The dorm has exactly one straight dryer — a 100 centimeter long rope to hang clothes on. The dryer has got a coordinate system installed: the leftmost end of the dryer has coordinate 0, and the opposite end has coordinate 100. Overall, the university has n students. Dean's office allows i-th student to use the segment (li, ri) of the dryer. However, the dean's office actions are contradictory and now one part of the dryer can belong to multiple students!
Alexey don't like when someone touch his clothes. That's why he want make it impossible to someone clothes touch his ones. So Alexey wonders: what is the total length of the parts of the dryer that he may use in a such way that clothes of the others (n - 1) students aren't drying there. Help him! Note that Alexey, as the most respected student, has number 1.
Input
The first line contains a positive integer n (1 ≤ n ≤ 100). The (i + 1)-th line contains integers li and ri (0 ≤ li < ri ≤ 100) — the endpoints of the corresponding segment for the i-th student.
Output
On a single line print a single number k, equal to the sum of lengths of the parts of the dryer which are inside Alexey's segment and are outside all other segments.
Examples
Input
3
0 5
2 8
1 6
Output
1
Input
3
0 10
1 5
7 15
Output
3
Note
Note that it's not important are clothes drying on the touching segments (e.g. (0, 1) and (1, 2)) considered to be touching or not because you need to find the length of segments.
In the first test sample Alexey may use the only segment (0, 1). In such case his clothes will not touch clothes on the segments (1, 6) and (2, 8). The length of segment (0, 1) is 1.
In the second test sample Alexey may dry his clothes on segments (0, 1) and (5, 7). Overall length of these segments is 3. | instruction | 0 | 61,779 | 8 | 123,558 |
Tags: implementation
Correct Solution:
```
n = int(input())
ans = []
dha = [1]*100
# for i in range(101):
# # dha.append(i)
pair = []
for i in range(n):
a,b = map(int,input().split())
if i == 0:
temp1 = a
temp2 = b
if i!=0:
pair.append([a,b])
for j in range(a,b):
dha[j] = False
ans.sort()
bu = 0
for i in range(temp1,temp2):
if dha[i] == 1:
bu+=1
print(bu)
``` | output | 1 | 61,779 | 8 | 123,559 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Our old friend Alexey has finally entered the University of City N — the Berland capital. Alexey expected his father to get him a place to live in but his father said it was high time for Alexey to practice some financial independence. So, Alexey is living in a dorm.
The dorm has exactly one straight dryer — a 100 centimeter long rope to hang clothes on. The dryer has got a coordinate system installed: the leftmost end of the dryer has coordinate 0, and the opposite end has coordinate 100. Overall, the university has n students. Dean's office allows i-th student to use the segment (li, ri) of the dryer. However, the dean's office actions are contradictory and now one part of the dryer can belong to multiple students!
Alexey don't like when someone touch his clothes. That's why he want make it impossible to someone clothes touch his ones. So Alexey wonders: what is the total length of the parts of the dryer that he may use in a such way that clothes of the others (n - 1) students aren't drying there. Help him! Note that Alexey, as the most respected student, has number 1.
Input
The first line contains a positive integer n (1 ≤ n ≤ 100). The (i + 1)-th line contains integers li and ri (0 ≤ li < ri ≤ 100) — the endpoints of the corresponding segment for the i-th student.
Output
On a single line print a single number k, equal to the sum of lengths of the parts of the dryer which are inside Alexey's segment and are outside all other segments.
Examples
Input
3
0 5
2 8
1 6
Output
1
Input
3
0 10
1 5
7 15
Output
3
Note
Note that it's not important are clothes drying on the touching segments (e.g. (0, 1) and (1, 2)) considered to be touching or not because you need to find the length of segments.
In the first test sample Alexey may use the only segment (0, 1). In such case his clothes will not touch clothes on the segments (1, 6) and (2, 8). The length of segment (0, 1) is 1.
In the second test sample Alexey may dry his clothes on segments (0, 1) and (5, 7). Overall length of these segments is 3. | instruction | 0 | 61,780 | 8 | 123,560 |
Tags: implementation
Correct Solution:
```
# http://codeforces.com/problemset/problem/397/A
import sys
def main():
n = int(sys.stdin.readline())
intervals = []
for _ in range(n):
b, e = [int(x) for x in sys.stdin.readline().split()]
intervals.append((b, e))
arr = [0 for _ in range(101)]
for i in range(intervals[0][0], intervals[0][1]):
arr[i] = 1
for interval in intervals[1:]:
for i in range(interval[0], interval[1]):
arr[i] = 2
print(arr.count(1))
if __name__ == '__main__':
main()
``` | output | 1 | 61,780 | 8 | 123,561 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Our old friend Alexey has finally entered the University of City N — the Berland capital. Alexey expected his father to get him a place to live in but his father said it was high time for Alexey to practice some financial independence. So, Alexey is living in a dorm.
The dorm has exactly one straight dryer — a 100 centimeter long rope to hang clothes on. The dryer has got a coordinate system installed: the leftmost end of the dryer has coordinate 0, and the opposite end has coordinate 100. Overall, the university has n students. Dean's office allows i-th student to use the segment (li, ri) of the dryer. However, the dean's office actions are contradictory and now one part of the dryer can belong to multiple students!
Alexey don't like when someone touch his clothes. That's why he want make it impossible to someone clothes touch his ones. So Alexey wonders: what is the total length of the parts of the dryer that he may use in a such way that clothes of the others (n - 1) students aren't drying there. Help him! Note that Alexey, as the most respected student, has number 1.
Input
The first line contains a positive integer n (1 ≤ n ≤ 100). The (i + 1)-th line contains integers li and ri (0 ≤ li < ri ≤ 100) — the endpoints of the corresponding segment for the i-th student.
Output
On a single line print a single number k, equal to the sum of lengths of the parts of the dryer which are inside Alexey's segment and are outside all other segments.
Examples
Input
3
0 5
2 8
1 6
Output
1
Input
3
0 10
1 5
7 15
Output
3
Note
Note that it's not important are clothes drying on the touching segments (e.g. (0, 1) and (1, 2)) considered to be touching or not because you need to find the length of segments.
In the first test sample Alexey may use the only segment (0, 1). In such case his clothes will not touch clothes on the segments (1, 6) and (2, 8). The length of segment (0, 1) is 1.
In the second test sample Alexey may dry his clothes on segments (0, 1) and (5, 7). Overall length of these segments is 3. | instruction | 0 | 61,781 | 8 | 123,562 |
Tags: implementation
Correct Solution:
```
n = int(input())
h = [1] * 100
a, b = map(int, input().split())
for i in range(n - 1):
x, y = map(int, input().split())
for j in range(x, y):
h[j] = 0
print(sum(h[a : b]))
``` | output | 1 | 61,781 | 8 | 123,563 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Our old friend Alexey has finally entered the University of City N — the Berland capital. Alexey expected his father to get him a place to live in but his father said it was high time for Alexey to practice some financial independence. So, Alexey is living in a dorm.
The dorm has exactly one straight dryer — a 100 centimeter long rope to hang clothes on. The dryer has got a coordinate system installed: the leftmost end of the dryer has coordinate 0, and the opposite end has coordinate 100. Overall, the university has n students. Dean's office allows i-th student to use the segment (li, ri) of the dryer. However, the dean's office actions are contradictory and now one part of the dryer can belong to multiple students!
Alexey don't like when someone touch his clothes. That's why he want make it impossible to someone clothes touch his ones. So Alexey wonders: what is the total length of the parts of the dryer that he may use in a such way that clothes of the others (n - 1) students aren't drying there. Help him! Note that Alexey, as the most respected student, has number 1.
Input
The first line contains a positive integer n (1 ≤ n ≤ 100). The (i + 1)-th line contains integers li and ri (0 ≤ li < ri ≤ 100) — the endpoints of the corresponding segment for the i-th student.
Output
On a single line print a single number k, equal to the sum of lengths of the parts of the dryer which are inside Alexey's segment and are outside all other segments.
Examples
Input
3
0 5
2 8
1 6
Output
1
Input
3
0 10
1 5
7 15
Output
3
Note
Note that it's not important are clothes drying on the touching segments (e.g. (0, 1) and (1, 2)) considered to be touching or not because you need to find the length of segments.
In the first test sample Alexey may use the only segment (0, 1). In such case his clothes will not touch clothes on the segments (1, 6) and (2, 8). The length of segment (0, 1) is 1.
In the second test sample Alexey may dry his clothes on segments (0, 1) and (5, 7). Overall length of these segments is 3. | instruction | 0 | 61,782 | 8 | 123,564 |
Tags: implementation
Correct Solution:
```
n = int(input())
x, y = map(int, input().split())
arr = list()
for i in range(n-1):
v = tuple(map(int, input().split()))
arr.append(v)
ans = 0
for i in range(x, y):
result = True
for j in arr:
if j[0] <= i <= j[1] and j[0] <= i+1 <= j[1]:
result = False
break
if result:
ans += 1
print(ans)
``` | output | 1 | 61,782 | 8 | 123,565 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Our old friend Alexey has finally entered the University of City N — the Berland capital. Alexey expected his father to get him a place to live in but his father said it was high time for Alexey to practice some financial independence. So, Alexey is living in a dorm.
The dorm has exactly one straight dryer — a 100 centimeter long rope to hang clothes on. The dryer has got a coordinate system installed: the leftmost end of the dryer has coordinate 0, and the opposite end has coordinate 100. Overall, the university has n students. Dean's office allows i-th student to use the segment (li, ri) of the dryer. However, the dean's office actions are contradictory and now one part of the dryer can belong to multiple students!
Alexey don't like when someone touch his clothes. That's why he want make it impossible to someone clothes touch his ones. So Alexey wonders: what is the total length of the parts of the dryer that he may use in a such way that clothes of the others (n - 1) students aren't drying there. Help him! Note that Alexey, as the most respected student, has number 1.
Input
The first line contains a positive integer n (1 ≤ n ≤ 100). The (i + 1)-th line contains integers li and ri (0 ≤ li < ri ≤ 100) — the endpoints of the corresponding segment for the i-th student.
Output
On a single line print a single number k, equal to the sum of lengths of the parts of the dryer which are inside Alexey's segment and are outside all other segments.
Examples
Input
3
0 5
2 8
1 6
Output
1
Input
3
0 10
1 5
7 15
Output
3
Note
Note that it's not important are clothes drying on the touching segments (e.g. (0, 1) and (1, 2)) considered to be touching or not because you need to find the length of segments.
In the first test sample Alexey may use the only segment (0, 1). In such case his clothes will not touch clothes on the segments (1, 6) and (2, 8). The length of segment (0, 1) is 1.
In the second test sample Alexey may dry his clothes on segments (0, 1) and (5, 7). Overall length of these segments is 3. | instruction | 0 | 61,783 | 8 | 123,566 |
Tags: implementation
Correct Solution:
```
n = int(input())
m = []
l, r = 0, 0
for i in range(n):
b1, b2 = list(map(int, input().split(' ')))
if i == 0:
l, r = b1, b2
m.append( (b1, 0))
m.append( (b2, 0))
else:
m.append( (b1, 1))
m.append( (b2, -1))
m.sort()
b, a = 0, []
cont = False
for i in m:
b += i[1]
if not(cont) and i[1] == 0:
cont = True
elif cont and i[1] == 0:
a.append((i[0], b))
break
if cont:
a.append((i[0], b))
ans = 0
for i in range(len(a[:-1])):
if a[i][1] == 0:
ans += a[i+1][0] - a[i][0]
print (ans)
``` | output | 1 | 61,783 | 8 | 123,567 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Our old friend Alexey has finally entered the University of City N — the Berland capital. Alexey expected his father to get him a place to live in but his father said it was high time for Alexey to practice some financial independence. So, Alexey is living in a dorm.
The dorm has exactly one straight dryer — a 100 centimeter long rope to hang clothes on. The dryer has got a coordinate system installed: the leftmost end of the dryer has coordinate 0, and the opposite end has coordinate 100. Overall, the university has n students. Dean's office allows i-th student to use the segment (li, ri) of the dryer. However, the dean's office actions are contradictory and now one part of the dryer can belong to multiple students!
Alexey don't like when someone touch his clothes. That's why he want make it impossible to someone clothes touch his ones. So Alexey wonders: what is the total length of the parts of the dryer that he may use in a such way that clothes of the others (n - 1) students aren't drying there. Help him! Note that Alexey, as the most respected student, has number 1.
Input
The first line contains a positive integer n (1 ≤ n ≤ 100). The (i + 1)-th line contains integers li and ri (0 ≤ li < ri ≤ 100) — the endpoints of the corresponding segment for the i-th student.
Output
On a single line print a single number k, equal to the sum of lengths of the parts of the dryer which are inside Alexey's segment and are outside all other segments.
Examples
Input
3
0 5
2 8
1 6
Output
1
Input
3
0 10
1 5
7 15
Output
3
Note
Note that it's not important are clothes drying on the touching segments (e.g. (0, 1) and (1, 2)) considered to be touching or not because you need to find the length of segments.
In the first test sample Alexey may use the only segment (0, 1). In such case his clothes will not touch clothes on the segments (1, 6) and (2, 8). The length of segment (0, 1) is 1.
In the second test sample Alexey may dry his clothes on segments (0, 1) and (5, 7). Overall length of these segments is 3.
Submitted Solution:
```
n = int(input())
l = [int(i) for i in input().split(" ")]
first = {f for f in range(l[0], l[1])}
for i in range(n - 1):
l = [int(i) for i in input().split(" ")]
n = {f for f in range(l[0], l[1])}
first -= n
print(len(first))
``` | instruction | 0 | 61,784 | 8 | 123,568 |
Yes | output | 1 | 61,784 | 8 | 123,569 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Our old friend Alexey has finally entered the University of City N — the Berland capital. Alexey expected his father to get him a place to live in but his father said it was high time for Alexey to practice some financial independence. So, Alexey is living in a dorm.
The dorm has exactly one straight dryer — a 100 centimeter long rope to hang clothes on. The dryer has got a coordinate system installed: the leftmost end of the dryer has coordinate 0, and the opposite end has coordinate 100. Overall, the university has n students. Dean's office allows i-th student to use the segment (li, ri) of the dryer. However, the dean's office actions are contradictory and now one part of the dryer can belong to multiple students!
Alexey don't like when someone touch his clothes. That's why he want make it impossible to someone clothes touch his ones. So Alexey wonders: what is the total length of the parts of the dryer that he may use in a such way that clothes of the others (n - 1) students aren't drying there. Help him! Note that Alexey, as the most respected student, has number 1.
Input
The first line contains a positive integer n (1 ≤ n ≤ 100). The (i + 1)-th line contains integers li and ri (0 ≤ li < ri ≤ 100) — the endpoints of the corresponding segment for the i-th student.
Output
On a single line print a single number k, equal to the sum of lengths of the parts of the dryer which are inside Alexey's segment and are outside all other segments.
Examples
Input
3
0 5
2 8
1 6
Output
1
Input
3
0 10
1 5
7 15
Output
3
Note
Note that it's not important are clothes drying on the touching segments (e.g. (0, 1) and (1, 2)) considered to be touching or not because you need to find the length of segments.
In the first test sample Alexey may use the only segment (0, 1). In such case his clothes will not touch clothes on the segments (1, 6) and (2, 8). The length of segment (0, 1) is 1.
In the second test sample Alexey may dry his clothes on segments (0, 1) and (5, 7). Overall length of these segments is 3.
Submitted Solution:
```
def g(l) :
if len(l)==1 :
return l
else:
ans=[l[0]]
for i in range(1,len(l)) :
(a,b)=l[i]
(c,d)=ans[-1]
if a<=d :
ans[-1]=(c,max(b,d))
else:
ans.append((a,b))
return ans
def f(l) :
(a,b)=l[0]
if len(l)==1 :
return b-a
else:
lnew=sorted(l[1:])
lf=g(lnew)
ans=b-a
for i in range(len(lf)) :
(c,d)=lf[i]
if b<=c :
break
else:
if c<a :
if d>a:
if d>b :
return 0
else:
ans=ans-d+a
else:
if d>b :
ans=ans-b+c
else:
ans=ans-d+c
return ans
n=int(input())
l=[]
t=0
while t != n :
t=t+1
x=input().split(" ")
a=int(x[0])
b=int(x[1])
l.append((a,b))
print(f(l))
``` | instruction | 0 | 61,785 | 8 | 123,570 |
Yes | output | 1 | 61,785 | 8 | 123,571 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Our old friend Alexey has finally entered the University of City N — the Berland capital. Alexey expected his father to get him a place to live in but his father said it was high time for Alexey to practice some financial independence. So, Alexey is living in a dorm.
The dorm has exactly one straight dryer — a 100 centimeter long rope to hang clothes on. The dryer has got a coordinate system installed: the leftmost end of the dryer has coordinate 0, and the opposite end has coordinate 100. Overall, the university has n students. Dean's office allows i-th student to use the segment (li, ri) of the dryer. However, the dean's office actions are contradictory and now one part of the dryer can belong to multiple students!
Alexey don't like when someone touch his clothes. That's why he want make it impossible to someone clothes touch his ones. So Alexey wonders: what is the total length of the parts of the dryer that he may use in a such way that clothes of the others (n - 1) students aren't drying there. Help him! Note that Alexey, as the most respected student, has number 1.
Input
The first line contains a positive integer n (1 ≤ n ≤ 100). The (i + 1)-th line contains integers li and ri (0 ≤ li < ri ≤ 100) — the endpoints of the corresponding segment for the i-th student.
Output
On a single line print a single number k, equal to the sum of lengths of the parts of the dryer which are inside Alexey's segment and are outside all other segments.
Examples
Input
3
0 5
2 8
1 6
Output
1
Input
3
0 10
1 5
7 15
Output
3
Note
Note that it's not important are clothes drying on the touching segments (e.g. (0, 1) and (1, 2)) considered to be touching or not because you need to find the length of segments.
In the first test sample Alexey may use the only segment (0, 1). In such case his clothes will not touch clothes on the segments (1, 6) and (2, 8). The length of segment (0, 1) is 1.
In the second test sample Alexey may dry his clothes on segments (0, 1) and (5, 7). Overall length of these segments is 3.
Submitted Solution:
```
n, t = int(input()) - 1, [0] * 101
a, b = map(int, input().split())
for i in range(n) :
l, r = map(int, input().split())
t[l] += 1
t[r] -= 1
for i in range(b - 1): t[i + 1] += t[i]
print(t[a: b].count(0))
``` | instruction | 0 | 61,786 | 8 | 123,572 |
Yes | output | 1 | 61,786 | 8 | 123,573 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Our old friend Alexey has finally entered the University of City N — the Berland capital. Alexey expected his father to get him a place to live in but his father said it was high time for Alexey to practice some financial independence. So, Alexey is living in a dorm.
The dorm has exactly one straight dryer — a 100 centimeter long rope to hang clothes on. The dryer has got a coordinate system installed: the leftmost end of the dryer has coordinate 0, and the opposite end has coordinate 100. Overall, the university has n students. Dean's office allows i-th student to use the segment (li, ri) of the dryer. However, the dean's office actions are contradictory and now one part of the dryer can belong to multiple students!
Alexey don't like when someone touch his clothes. That's why he want make it impossible to someone clothes touch his ones. So Alexey wonders: what is the total length of the parts of the dryer that he may use in a such way that clothes of the others (n - 1) students aren't drying there. Help him! Note that Alexey, as the most respected student, has number 1.
Input
The first line contains a positive integer n (1 ≤ n ≤ 100). The (i + 1)-th line contains integers li and ri (0 ≤ li < ri ≤ 100) — the endpoints of the corresponding segment for the i-th student.
Output
On a single line print a single number k, equal to the sum of lengths of the parts of the dryer which are inside Alexey's segment and are outside all other segments.
Examples
Input
3
0 5
2 8
1 6
Output
1
Input
3
0 10
1 5
7 15
Output
3
Note
Note that it's not important are clothes drying on the touching segments (e.g. (0, 1) and (1, 2)) considered to be touching or not because you need to find the length of segments.
In the first test sample Alexey may use the only segment (0, 1). In such case his clothes will not touch clothes on the segments (1, 6) and (2, 8). The length of segment (0, 1) is 1.
In the second test sample Alexey may dry his clothes on segments (0, 1) and (5, 7). Overall length of these segments is 3.
Submitted Solution:
```
import sys
n=int(input())
l=[]
r=[]
for i in range(n):
li,ri=map(int,input().split())
l.append(li)
r.append(ri)
a=list(range(l[0],r[0]+1))
for i in range(1,n):
if(l[i] in a):
x=[]
x.append('{')
a=a[:a.index(l[i])+1]+x+a[a.index(l[i])+1:]
if(r[i] in a):
x=[]
x.append('}')
a=a[:a.index(r[i])]+x+a[a.index(r[i]):]
if(l[i]<l[0] and r[i]>r[0]):
print(0)
sys.exit()
sum=-1
count=0
f=0
for i in range(len(a)):
if(a[i]=='{'):
count+=1
elif(a[i]=='}'):
count-=1
f=1
if(count<0):
sum=0
count=0
else:
if(count==0):
sum+=1
if(f==1):
f=0
sum-=1
print(sum)
``` | instruction | 0 | 61,787 | 8 | 123,574 |
Yes | output | 1 | 61,787 | 8 | 123,575 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Our old friend Alexey has finally entered the University of City N — the Berland capital. Alexey expected his father to get him a place to live in but his father said it was high time for Alexey to practice some financial independence. So, Alexey is living in a dorm.
The dorm has exactly one straight dryer — a 100 centimeter long rope to hang clothes on. The dryer has got a coordinate system installed: the leftmost end of the dryer has coordinate 0, and the opposite end has coordinate 100. Overall, the university has n students. Dean's office allows i-th student to use the segment (li, ri) of the dryer. However, the dean's office actions are contradictory and now one part of the dryer can belong to multiple students!
Alexey don't like when someone touch his clothes. That's why he want make it impossible to someone clothes touch his ones. So Alexey wonders: what is the total length of the parts of the dryer that he may use in a such way that clothes of the others (n - 1) students aren't drying there. Help him! Note that Alexey, as the most respected student, has number 1.
Input
The first line contains a positive integer n (1 ≤ n ≤ 100). The (i + 1)-th line contains integers li and ri (0 ≤ li < ri ≤ 100) — the endpoints of the corresponding segment for the i-th student.
Output
On a single line print a single number k, equal to the sum of lengths of the parts of the dryer which are inside Alexey's segment and are outside all other segments.
Examples
Input
3
0 5
2 8
1 6
Output
1
Input
3
0 10
1 5
7 15
Output
3
Note
Note that it's not important are clothes drying on the touching segments (e.g. (0, 1) and (1, 2)) considered to be touching or not because you need to find the length of segments.
In the first test sample Alexey may use the only segment (0, 1). In such case his clothes will not touch clothes on the segments (1, 6) and (2, 8). The length of segment (0, 1) is 1.
In the second test sample Alexey may dry his clothes on segments (0, 1) and (5, 7). Overall length of these segments is 3.
Submitted Solution:
```
n = int(input())
l, r = map(int, input().split())
A = []
for i in range(n - 1):
A += [list(map(int, input().split()))]
A.sort()
ans = 0
for i in A:
nl, nr = i[0], i[1]
if l >= nl and r <= nr:
break
else:
ans += min(r, nl) - l
l = nr
if l >= r:
break
print(ans)
``` | instruction | 0 | 61,788 | 8 | 123,576 |
No | output | 1 | 61,788 | 8 | 123,577 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Our old friend Alexey has finally entered the University of City N — the Berland capital. Alexey expected his father to get him a place to live in but his father said it was high time for Alexey to practice some financial independence. So, Alexey is living in a dorm.
The dorm has exactly one straight dryer — a 100 centimeter long rope to hang clothes on. The dryer has got a coordinate system installed: the leftmost end of the dryer has coordinate 0, and the opposite end has coordinate 100. Overall, the university has n students. Dean's office allows i-th student to use the segment (li, ri) of the dryer. However, the dean's office actions are contradictory and now one part of the dryer can belong to multiple students!
Alexey don't like when someone touch his clothes. That's why he want make it impossible to someone clothes touch his ones. So Alexey wonders: what is the total length of the parts of the dryer that he may use in a such way that clothes of the others (n - 1) students aren't drying there. Help him! Note that Alexey, as the most respected student, has number 1.
Input
The first line contains a positive integer n (1 ≤ n ≤ 100). The (i + 1)-th line contains integers li and ri (0 ≤ li < ri ≤ 100) — the endpoints of the corresponding segment for the i-th student.
Output
On a single line print a single number k, equal to the sum of lengths of the parts of the dryer which are inside Alexey's segment and are outside all other segments.
Examples
Input
3
0 5
2 8
1 6
Output
1
Input
3
0 10
1 5
7 15
Output
3
Note
Note that it's not important are clothes drying on the touching segments (e.g. (0, 1) and (1, 2)) considered to be touching or not because you need to find the length of segments.
In the first test sample Alexey may use the only segment (0, 1). In such case his clothes will not touch clothes on the segments (1, 6) and (2, 8). The length of segment (0, 1) is 1.
In the second test sample Alexey may dry his clothes on segments (0, 1) and (5, 7). Overall length of these segments is 3.
Submitted Solution:
```
n=int(input())
l,r=map(int,input().split())
lst=[0]*100
for i in range(n-1):
a1,a2=map(int,input().split())
if a1>=l and a1<=r:
if a2>=r:lst[a1:r]=[1 for i in range(r-a1)]
else:lst[a1:a2]=[1 for i in range(a2-a1)]
elif a2>=l and a2<=r:
if a1<=l:lst[l:a2]=[1 for i in range(a2-l)]
else:lst[a1:a2]=[1 for i in range(a2-a1)]
c=0
for i in range(l,r):
if lst[i]==0:c+=1
print(c)
``` | instruction | 0 | 61,789 | 8 | 123,578 |
No | output | 1 | 61,789 | 8 | 123,579 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Our old friend Alexey has finally entered the University of City N — the Berland capital. Alexey expected his father to get him a place to live in but his father said it was high time for Alexey to practice some financial independence. So, Alexey is living in a dorm.
The dorm has exactly one straight dryer — a 100 centimeter long rope to hang clothes on. The dryer has got a coordinate system installed: the leftmost end of the dryer has coordinate 0, and the opposite end has coordinate 100. Overall, the university has n students. Dean's office allows i-th student to use the segment (li, ri) of the dryer. However, the dean's office actions are contradictory and now one part of the dryer can belong to multiple students!
Alexey don't like when someone touch his clothes. That's why he want make it impossible to someone clothes touch his ones. So Alexey wonders: what is the total length of the parts of the dryer that he may use in a such way that clothes of the others (n - 1) students aren't drying there. Help him! Note that Alexey, as the most respected student, has number 1.
Input
The first line contains a positive integer n (1 ≤ n ≤ 100). The (i + 1)-th line contains integers li and ri (0 ≤ li < ri ≤ 100) — the endpoints of the corresponding segment for the i-th student.
Output
On a single line print a single number k, equal to the sum of lengths of the parts of the dryer which are inside Alexey's segment and are outside all other segments.
Examples
Input
3
0 5
2 8
1 6
Output
1
Input
3
0 10
1 5
7 15
Output
3
Note
Note that it's not important are clothes drying on the touching segments (e.g. (0, 1) and (1, 2)) considered to be touching or not because you need to find the length of segments.
In the first test sample Alexey may use the only segment (0, 1). In such case his clothes will not touch clothes on the segments (1, 6) and (2, 8). The length of segment (0, 1) is 1.
In the second test sample Alexey may dry his clothes on segments (0, 1) and (5, 7). Overall length of these segments is 3.
Submitted Solution:
```
n = int(input())
l = []
for _ in range(n):
l.append(list(map(int, input().split())))
arr = [0]*101
for i in range(1,n):
arr[l[i][0]]+=1
arr[l[i][1]]-=1
for i in range(1,101):
arr[i]=arr[i]+arr[i-1]
cnt=0
for i in range(l[0][0],l[0][1]+1):
if arr[i]==0:
cnt+=1
print(cnt)
``` | instruction | 0 | 61,790 | 8 | 123,580 |
No | output | 1 | 61,790 | 8 | 123,581 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Our old friend Alexey has finally entered the University of City N — the Berland capital. Alexey expected his father to get him a place to live in but his father said it was high time for Alexey to practice some financial independence. So, Alexey is living in a dorm.
The dorm has exactly one straight dryer — a 100 centimeter long rope to hang clothes on. The dryer has got a coordinate system installed: the leftmost end of the dryer has coordinate 0, and the opposite end has coordinate 100. Overall, the university has n students. Dean's office allows i-th student to use the segment (li, ri) of the dryer. However, the dean's office actions are contradictory and now one part of the dryer can belong to multiple students!
Alexey don't like when someone touch his clothes. That's why he want make it impossible to someone clothes touch his ones. So Alexey wonders: what is the total length of the parts of the dryer that he may use in a such way that clothes of the others (n - 1) students aren't drying there. Help him! Note that Alexey, as the most respected student, has number 1.
Input
The first line contains a positive integer n (1 ≤ n ≤ 100). The (i + 1)-th line contains integers li and ri (0 ≤ li < ri ≤ 100) — the endpoints of the corresponding segment for the i-th student.
Output
On a single line print a single number k, equal to the sum of lengths of the parts of the dryer which are inside Alexey's segment and are outside all other segments.
Examples
Input
3
0 5
2 8
1 6
Output
1
Input
3
0 10
1 5
7 15
Output
3
Note
Note that it's not important are clothes drying on the touching segments (e.g. (0, 1) and (1, 2)) considered to be touching or not because you need to find the length of segments.
In the first test sample Alexey may use the only segment (0, 1). In such case his clothes will not touch clothes on the segments (1, 6) and (2, 8). The length of segment (0, 1) is 1.
In the second test sample Alexey may dry his clothes on segments (0, 1) and (5, 7). Overall length of these segments is 3.
Submitted Solution:
```
used = [1]*100
n = int(input())
me = [int(x) for x in input().split(' ')]
for _ in range(n-1):
ot = [int(x) for x in input().split(' ')]
used[ot[0]:ot[1]+1] = [0]*(ot[1]-ot[0])
print(sum(used[me[0]:me[1]+1]))
``` | instruction | 0 | 61,791 | 8 | 123,582 |
No | output | 1 | 61,791 | 8 | 123,583 |
Provide a correct Python 3 solution for this coding contest problem.
problem
Do you know Just Odd Inventions? The business of this company is to "just odd inventions". Here we call it JOI for short.
JOI has two offices, each of which has square rooms of the same size arranged in a grid pattern. All the rooms that are in contact with each other have an ID card authentication function. There is a door. Since JOI handles various levels of confidential information, a positive integer called the confidentiality level is set for each room, and the authentication level of the non-negative integer set for each ID office is set. You can only enter the room at the confidentiality level or higher. Each office has only one entrance / exit in the elevator hall, and the confidentiality level of the room in the elevator hall is the lowest 1. The certification level for the office is 1. When it is 0, you cannot even enter the elevator hall.
At JOI, the president suddenly proposed to conduct a tour to invite the general public to tour the company. You need to decide the combination of identification level of the ID card to be given to the visitor. Whenever a visitor finds a door that can be opened, he opens it and enters (it is possible to visit the same room multiple times). Therefore, he does not want to raise the authentication level of the visitor's ID more than necessary. However, in order to make the tour attractive, it is necessary to allow two offices, including the elevator hall room, to visit a total of R or more rooms. Lower the ID verification level. If it is too much, this condition may not be met.
JOI has two offices, and the rooms of the kth office (k = 1, 2) are Wk in the east-west direction and Hk in the north-south direction, for a total of Wk × Hk. From the west. The i-th and j-th rooms from the north are represented by (i, j) k.
Given the values of Wk, Hk and R, the location of the elevator hall (Xk, Yk) k, and the confidentiality level of each room, visitors can visit a total of R or more rooms in the two offices. Create a program to find the minimum sum of the authentication levels of the visitor's ID card.
It should be noted that how JOI profits from making "just a strange invention" is the highest secret within the company and no one knows except the president.
input
The input consists of multiple datasets. Each dataset is given in the following format.
The positive integer R (1 ≤ R ≤ 100000) is written on the first line. The data of the two offices are given in order on the second and subsequent lines.
The office data is the positive integers Wk, Hk, Xk, Yk (1 ≤ Xk ≤ Wk ≤ 500, 1 ≤ Yk ≤ Hk ≤ 500) in the first line, followed by the i-th in line j of the Hk line, the room. (i, j) Given as an integer Lk, i, j (1 ≤ Lk, i, j <100000000 = 108) representing the confidentiality level of k.
Also, R ≤ W1 × H1 + W2 × H2 is satisfied.
Of the scoring data, 30% of the points are given by satisfying R, Wk, Hk ≤ 100.
When R is 0, it indicates the end of input. The number of data sets does not exceed 10.
output
For each dataset, the minimum sum of the required ID authentication levels is output on one line.
Examples
Input
5
2 2 1 2
9 5
1 17
3 2 2 1
6 1 20
8 18 3
8
5 4 1 3
5 5 4 5 5
8 2 1 9 7
1 1 3 5 1
7 2 7 1 3
6 5 6 2
2 3 5 8 2 7
1 6 9 4 5 1
2 4 5 4 2 2
5 4 2 5 3 3
7 1 5 1 5 6
6
3 3 2 2
2 9 2
9 1 9
2 9 2
2 2 1 1
1 3
5 7
0
Output
15
4
9
Input
None
Output
None | instruction | 0 | 62,211 | 8 | 124,422 |
"Correct Solution:
```
from heapq import heappop as pop
from heapq import heappush as push
INF = 1000000000000
while True:
R = int(input())
if not R:
break
w1, h1, x1, y1 = map(int, input().split())
x1 -= 1
y1 -= 1
lst1 = [list(map(int, input().split())) for _ in range(h1)]
used1 = [[False] * w1 for _ in range(h1)]
w2, h2, x2, y2 = map(int, input().split())
x2 -= 1
y2 -= 1
lst2 = [list(map(int, input().split())) for _ in range(h2)]
used2 = [[False] * w2 for _ in range(h2)]
def bfs(lst, used, que, w, h):
v, y, x = pop(que)
if y > 0 and not used[y - 1][x]:
push(que, (lst[y - 1][x], y - 1, x))
used[y - 1][x] = True
if h > y + 1 and not used[y + 1][x]:
push(que, (lst[y + 1][x], y + 1, x))
used[y + 1][x] = True
if x > 0 and not used[y][x - 1]:
push(que, (lst[y][x - 1], y, x - 1))
used[y][x - 1] = True
if w > x + 1 and not used[y][x + 1]:
push(que, (lst[y][x + 1], y, x + 1))
used[y][x + 1] = True
return v
que = [(1, y1, x1)]
used1[y1][x1] = True
rec1 = [[0, 0]]
Max = 0
acc = 0
while que:
v = bfs(lst1, used1, que, w1, h1)
acc += 1
if v > Max:
rec1.append([v, acc])
Max = v
else:
rec1[-1][1] += 1
que = [(1, y2, x2)]
used2[y2][x2] = True
rec2 = [[0, 0]]
Max = 0
acc = 0
while que:
v = bfs(lst2, used2, que, w2, h2)
acc += 1
if v > Max:
rec2.append([v, acc])
Max = v
else:
rec2[-1][1] += 1
end1 = len(rec1)
end2 = len(rec2)
ind1 = 0
ind2 = end2 - 1
ans = INF
# print(rec1)
# print(rec2)
while ind1 < end1 and ind2 > 0:
r1, sum1 = rec1[ind1]
r2, sum2 = rec2[ind2]
if sum1 + sum2 < R:
ind1 += 1
continue
while ind2 > 0 and sum1 + sum2 >= R:
ind2 -= 1
r2, sum2 = rec2[ind2]
if ind2 == 0 and sum1 + sum2 >= R:
ans = min(ans, r1 + r2)
break
else:
if ind2 < end2 - 1:
ind2 += 1
r2, sum2 = rec2[ind2]
ans = min(ans, r1 + r2)
ind1 += 1
print(ans)
``` | output | 1 | 62,211 | 8 | 124,423 |
Provide a correct Python 3 solution for this coding contest problem.
problem
Do you know Just Odd Inventions? The business of this company is to "just odd inventions". Here we call it JOI for short.
JOI has two offices, each of which has square rooms of the same size arranged in a grid pattern. All the rooms that are in contact with each other have an ID card authentication function. There is a door. Since JOI handles various levels of confidential information, a positive integer called the confidentiality level is set for each room, and the authentication level of the non-negative integer set for each ID office is set. You can only enter the room at the confidentiality level or higher. Each office has only one entrance / exit in the elevator hall, and the confidentiality level of the room in the elevator hall is the lowest 1. The certification level for the office is 1. When it is 0, you cannot even enter the elevator hall.
At JOI, the president suddenly proposed to conduct a tour to invite the general public to tour the company. You need to decide the combination of identification level of the ID card to be given to the visitor. Whenever a visitor finds a door that can be opened, he opens it and enters (it is possible to visit the same room multiple times). Therefore, he does not want to raise the authentication level of the visitor's ID more than necessary. However, in order to make the tour attractive, it is necessary to allow two offices, including the elevator hall room, to visit a total of R or more rooms. Lower the ID verification level. If it is too much, this condition may not be met.
JOI has two offices, and the rooms of the kth office (k = 1, 2) are Wk in the east-west direction and Hk in the north-south direction, for a total of Wk × Hk. From the west. The i-th and j-th rooms from the north are represented by (i, j) k.
Given the values of Wk, Hk and R, the location of the elevator hall (Xk, Yk) k, and the confidentiality level of each room, visitors can visit a total of R or more rooms in the two offices. Create a program to find the minimum sum of the authentication levels of the visitor's ID card.
It should be noted that how JOI profits from making "just a strange invention" is the highest secret within the company and no one knows except the president.
input
The input consists of multiple datasets. Each dataset is given in the following format.
The positive integer R (1 ≤ R ≤ 100000) is written on the first line. The data of the two offices are given in order on the second and subsequent lines.
The office data is the positive integers Wk, Hk, Xk, Yk (1 ≤ Xk ≤ Wk ≤ 500, 1 ≤ Yk ≤ Hk ≤ 500) in the first line, followed by the i-th in line j of the Hk line, the room. (i, j) Given as an integer Lk, i, j (1 ≤ Lk, i, j <100000000 = 108) representing the confidentiality level of k.
Also, R ≤ W1 × H1 + W2 × H2 is satisfied.
Of the scoring data, 30% of the points are given by satisfying R, Wk, Hk ≤ 100.
When R is 0, it indicates the end of input. The number of data sets does not exceed 10.
output
For each dataset, the minimum sum of the required ID authentication levels is output on one line.
Examples
Input
5
2 2 1 2
9 5
1 17
3 2 2 1
6 1 20
8 18 3
8
5 4 1 3
5 5 4 5 5
8 2 1 9 7
1 1 3 5 1
7 2 7 1 3
6 5 6 2
2 3 5 8 2 7
1 6 9 4 5 1
2 4 5 4 2 2
5 4 2 5 3 3
7 1 5 1 5 6
6
3 3 2 2
2 9 2
9 1 9
2 9 2
2 2 1 1
1 3
5 7
0
Output
15
4
9
Input
None
Output
None | instruction | 0 | 62,212 | 8 | 124,424 |
"Correct Solution:
```
from heapq import heappop as pop
from heapq import heappush as push
INF = 1000000000000
def solve():
while True:
R = int(input())
if not R:
break
w1, h1, x1, y1 = map(int, input().split())
x1 -= 1
y1 -= 1
lst1 = [list(map(int, input().split())) for _ in range(h1)]
used1 = [[False] * w1 for _ in range(h1)]
w2, h2, x2, y2 = map(int, input().split())
x2 -= 1
y2 -= 1
lst2 = [list(map(int, input().split())) for _ in range(h2)]
used2 = [[False] * w2 for _ in range(h2)]
def bfs(lst, used, que, w, h):
v, y, x = pop(que)
if y > 0 and not used[y - 1][x]:
push(que, (lst[y - 1][x], y - 1, x))
used[y - 1][x] = True
if h > y + 1 and not used[y + 1][x]:
push(que, (lst[y + 1][x], y + 1, x))
used[y + 1][x] = True
if x > 0 and not used[y][x - 1]:
push(que, (lst[y][x - 1], y, x - 1))
used[y][x - 1] = True
if w > x + 1 and not used[y][x + 1]:
push(que, (lst[y][x + 1], y, x + 1))
used[y][x + 1] = True
return v
def make_dic(lst, w, h, x, y):
que = [(1, y, x)]
used = [[False] * w for _ in range(h)]
used[y][x] = True
dic = [[0, 0]]
app = dic.append
Max = 0
acc = 0
while que:
v = bfs(lst, used, que, w, h)
acc += 1
if v > Max:
app([v, acc])
Max = v
else:
dic[-1][1] += 1
return dic
dic1 = make_dic(lst1, w1, h1, x1, y1)
dic2 = make_dic(lst2, w2, h2, x2, y2)
end1 = len(dic1)
end2 = len(dic2)
ind1 = 0
ind2 = end2 - 1
ans = INF
while ind1 < end1 and ind2 > 0:
r1, sum1 = dic1[ind1]
r2, sum2 = dic2[ind2]
if sum1 + sum2 < R:
ind1 += 1
continue
while ind2 > 0 and sum1 + sum2 >= R:
ind2 -= 1
r2, sum2 = dic2[ind2]
if ind2 == 0 and sum1 + sum2 >= R:
rs = r1 + r2
if rs < ans:
ans = rs
break
else:
if ind2 < end2 - 1:
ind2 += 1
r2 = dic2[ind2][0]
rs = r1 + r2
if rs < ans:
ans = rs
ind1 += 1
print(ans)
solve()
``` | output | 1 | 62,212 | 8 | 124,425 |
Provide a correct Python 3 solution for this coding contest problem.
problem
Do you know Just Odd Inventions? The business of this company is to "just odd inventions". Here we call it JOI for short.
JOI has two offices, each of which has square rooms of the same size arranged in a grid pattern. All the rooms that are in contact with each other have an ID card authentication function. There is a door. Since JOI handles various levels of confidential information, a positive integer called the confidentiality level is set for each room, and the authentication level of the non-negative integer set for each ID office is set. You can only enter the room at the confidentiality level or higher. Each office has only one entrance / exit in the elevator hall, and the confidentiality level of the room in the elevator hall is the lowest 1. The certification level for the office is 1. When it is 0, you cannot even enter the elevator hall.
At JOI, the president suddenly proposed to conduct a tour to invite the general public to tour the company. You need to decide the combination of identification level of the ID card to be given to the visitor. Whenever a visitor finds a door that can be opened, he opens it and enters (it is possible to visit the same room multiple times). Therefore, he does not want to raise the authentication level of the visitor's ID more than necessary. However, in order to make the tour attractive, it is necessary to allow two offices, including the elevator hall room, to visit a total of R or more rooms. Lower the ID verification level. If it is too much, this condition may not be met.
JOI has two offices, and the rooms of the kth office (k = 1, 2) are Wk in the east-west direction and Hk in the north-south direction, for a total of Wk × Hk. From the west. The i-th and j-th rooms from the north are represented by (i, j) k.
Given the values of Wk, Hk and R, the location of the elevator hall (Xk, Yk) k, and the confidentiality level of each room, visitors can visit a total of R or more rooms in the two offices. Create a program to find the minimum sum of the authentication levels of the visitor's ID card.
It should be noted that how JOI profits from making "just a strange invention" is the highest secret within the company and no one knows except the president.
input
The input consists of multiple datasets. Each dataset is given in the following format.
The positive integer R (1 ≤ R ≤ 100000) is written on the first line. The data of the two offices are given in order on the second and subsequent lines.
The office data is the positive integers Wk, Hk, Xk, Yk (1 ≤ Xk ≤ Wk ≤ 500, 1 ≤ Yk ≤ Hk ≤ 500) in the first line, followed by the i-th in line j of the Hk line, the room. (i, j) Given as an integer Lk, i, j (1 ≤ Lk, i, j <100000000 = 108) representing the confidentiality level of k.
Also, R ≤ W1 × H1 + W2 × H2 is satisfied.
Of the scoring data, 30% of the points are given by satisfying R, Wk, Hk ≤ 100.
When R is 0, it indicates the end of input. The number of data sets does not exceed 10.
output
For each dataset, the minimum sum of the required ID authentication levels is output on one line.
Examples
Input
5
2 2 1 2
9 5
1 17
3 2 2 1
6 1 20
8 18 3
8
5 4 1 3
5 5 4 5 5
8 2 1 9 7
1 1 3 5 1
7 2 7 1 3
6 5 6 2
2 3 5 8 2 7
1 6 9 4 5 1
2 4 5 4 2 2
5 4 2 5 3 3
7 1 5 1 5 6
6
3 3 2 2
2 9 2
9 1 9
2 9 2
2 2 1 1
1 3
5 7
0
Output
15
4
9
Input
None
Output
None | instruction | 0 | 62,213 | 8 | 124,426 |
"Correct Solution:
```
from heapq import heappop as pop
from heapq import heappush as push
INF = 1000000000000
def bfs(lst, used, que, w, h):
v, y, x = pop(que)
if not used[y - 1][x]:
push(que, (lst[y - 2][x - 1], y - 1, x))
used[y - 1][x] = True
if not used[y + 1][x]:
push(que, (lst[y][x - 1], y + 1, x))
used[y + 1][x] = True
if not used[y][x - 1]:
push(que, (lst[y - 1][x - 2], y, x - 1))
used[y][x - 1] = True
if not used[y][x + 1]:
push(que, (lst[y - 1][x], y, x + 1))
used[y][x + 1] = True
return v
def make_dic(lst, w, h, x, y):
que = [(1, y, x)]
used = [[True] * (w + 2)]
for i in range(h):
used.append([True] + [False] * w + [True])
used.append([True] * (w + 2))
used[y][x] = True
dic = [[0, 0]]
app = dic.append
Max = 0
acc = 0
while que:
v = bfs(lst, used, que, w, h)
acc += 1
if v > Max:
app([v, acc])
Max = v
else:
dic[-1][1] += 1
return dic
def solve():
while True:
R = int(input())
if not R:
break
w1, h1, x1, y1 = map(int, input().split())
lst1 = [list(map(int, input().split())) for _ in range(h1)]
w2, h2, x2, y2 = map(int, input().split())
lst2 = [list(map(int, input().split())) for _ in range(h2)]
dic1 = make_dic(lst1, w1, h1, x1, y1)
dic2 = make_dic(lst2, w2, h2, x2, y2)
end1 = len(dic1)
end2 = len(dic2)
ind1 = 0
ind2 = end2 - 1
ans = INF
while ind1 < end1 and ind2 > 0:
r1, sum1 = dic1[ind1]
r2, sum2 = dic2[ind2]
if sum1 + sum2 < R:
ind1 += 1
continue
while ind2 > 0 and sum1 + sum2 >= R:
ind2 -= 1
r2, sum2 = dic2[ind2]
if ind2 == 0 and sum1 + sum2 >= R:
rs = r1 + r2
if rs < ans:
ans = rs
break
else:
ind2 += 1
r2 = dic2[ind2][0]
rs = r1 + r2
if rs < ans:
ans = rs
ind1 += 1
print(ans)
solve()
``` | output | 1 | 62,213 | 8 | 124,427 |
Provide a correct Python 3 solution for this coding contest problem.
problem
Do you know Just Odd Inventions? The business of this company is to "just odd inventions". Here we call it JOI for short.
JOI has two offices, each of which has square rooms of the same size arranged in a grid pattern. All the rooms that are in contact with each other have an ID card authentication function. There is a door. Since JOI handles various levels of confidential information, a positive integer called the confidentiality level is set for each room, and the authentication level of the non-negative integer set for each ID office is set. You can only enter the room at the confidentiality level or higher. Each office has only one entrance / exit in the elevator hall, and the confidentiality level of the room in the elevator hall is the lowest 1. The certification level for the office is 1. When it is 0, you cannot even enter the elevator hall.
At JOI, the president suddenly proposed to conduct a tour to invite the general public to tour the company. You need to decide the combination of identification level of the ID card to be given to the visitor. Whenever a visitor finds a door that can be opened, he opens it and enters (it is possible to visit the same room multiple times). Therefore, he does not want to raise the authentication level of the visitor's ID more than necessary. However, in order to make the tour attractive, it is necessary to allow two offices, including the elevator hall room, to visit a total of R or more rooms. Lower the ID verification level. If it is too much, this condition may not be met.
JOI has two offices, and the rooms of the kth office (k = 1, 2) are Wk in the east-west direction and Hk in the north-south direction, for a total of Wk × Hk. From the west. The i-th and j-th rooms from the north are represented by (i, j) k.
Given the values of Wk, Hk and R, the location of the elevator hall (Xk, Yk) k, and the confidentiality level of each room, visitors can visit a total of R or more rooms in the two offices. Create a program to find the minimum sum of the authentication levels of the visitor's ID card.
It should be noted that how JOI profits from making "just a strange invention" is the highest secret within the company and no one knows except the president.
input
The input consists of multiple datasets. Each dataset is given in the following format.
The positive integer R (1 ≤ R ≤ 100000) is written on the first line. The data of the two offices are given in order on the second and subsequent lines.
The office data is the positive integers Wk, Hk, Xk, Yk (1 ≤ Xk ≤ Wk ≤ 500, 1 ≤ Yk ≤ Hk ≤ 500) in the first line, followed by the i-th in line j of the Hk line, the room. (i, j) Given as an integer Lk, i, j (1 ≤ Lk, i, j <100000000 = 108) representing the confidentiality level of k.
Also, R ≤ W1 × H1 + W2 × H2 is satisfied.
Of the scoring data, 30% of the points are given by satisfying R, Wk, Hk ≤ 100.
When R is 0, it indicates the end of input. The number of data sets does not exceed 10.
output
For each dataset, the minimum sum of the required ID authentication levels is output on one line.
Examples
Input
5
2 2 1 2
9 5
1 17
3 2 2 1
6 1 20
8 18 3
8
5 4 1 3
5 5 4 5 5
8 2 1 9 7
1 1 3 5 1
7 2 7 1 3
6 5 6 2
2 3 5 8 2 7
1 6 9 4 5 1
2 4 5 4 2 2
5 4 2 5 3 3
7 1 5 1 5 6
6
3 3 2 2
2 9 2
9 1 9
2 9 2
2 2 1 1
1 3
5 7
0
Output
15
4
9
Input
None
Output
None | instruction | 0 | 62,214 | 8 | 124,428 |
"Correct Solution:
```
from heapq import heappop as pop
from heapq import heappush as push
INF = 1000000000000
def bfs(lst, used, que, w, h):
v, y, x = pop(que)
if y > 0 and not used[y - 1][x]:
push(que, (lst[y - 1][x], y - 1, x))
used[y - 1][x] = True
if h > y + 1 and not used[y + 1][x]:
push(que, (lst[y + 1][x], y + 1, x))
used[y + 1][x] = True
if x > 0 and not used[y][x - 1]:
push(que, (lst[y][x - 1], y, x - 1))
used[y][x - 1] = True
if w > x + 1 and not used[y][x + 1]:
push(que, (lst[y][x + 1], y, x + 1))
used[y][x + 1] = True
return v
def make_dic(lst, w, h, x, y):
que = [(1, y, x)]
used = [[False] * w for _ in range(h)]
used[y][x] = True
dic = [[0, 0]]
app = dic.append
Max = 0
acc = 0
while que:
v = bfs(lst, used, que, w, h)
acc += 1
if v > Max:
app([v, acc])
Max = v
else:
dic[-1][1] += 1
return dic
def solve():
while True:
R = int(input())
if not R:
break
w1, h1, x1, y1 = map(int, input().split())
lst1 = [list(map(int, input().split())) for _ in range(h1)]
w2, h2, x2, y2 = map(int, input().split())
lst2 = [list(map(int, input().split())) for _ in range(h2)]
dic1 = make_dic(lst1, w1, h1, x1 - 1, y1 - 1)
dic2 = make_dic(lst2, w2, h2, x2 - 1, y2 - 1)
end1 = len(dic1)
end2 = len(dic2)
ind1 = 0
ind2 = end2 - 1
ans = INF
while ind1 < end1 and ind2 > 0:
r1, sum1 = dic1[ind1]
r2, sum2 = dic2[ind2]
if sum1 + sum2 < R:
ind1 += 1
continue
while ind2 > 0 and sum1 + sum2 >= R:
ind2 -= 1
r2, sum2 = dic2[ind2]
if ind2 == 0 and sum1 + sum2 >= R:
rs = r1 + r2
if rs < ans:
ans = rs
break
else:
ind2 += 1
r2 = dic2[ind2][0]
rs = r1 + r2
if rs < ans:
ans = rs
ind1 += 1
print(ans)
solve()
``` | output | 1 | 62,214 | 8 | 124,429 |
Provide a correct Python 3 solution for this coding contest problem.
problem
Do you know Just Odd Inventions? The business of this company is to "just odd inventions". Here we call it JOI for short.
JOI has two offices, each of which has square rooms of the same size arranged in a grid pattern. All the rooms that are in contact with each other have an ID card authentication function. There is a door. Since JOI handles various levels of confidential information, a positive integer called the confidentiality level is set for each room, and the authentication level of the non-negative integer set for each ID office is set. You can only enter the room at the confidentiality level or higher. Each office has only one entrance / exit in the elevator hall, and the confidentiality level of the room in the elevator hall is the lowest 1. The certification level for the office is 1. When it is 0, you cannot even enter the elevator hall.
At JOI, the president suddenly proposed to conduct a tour to invite the general public to tour the company. You need to decide the combination of identification level of the ID card to be given to the visitor. Whenever a visitor finds a door that can be opened, he opens it and enters (it is possible to visit the same room multiple times). Therefore, he does not want to raise the authentication level of the visitor's ID more than necessary. However, in order to make the tour attractive, it is necessary to allow two offices, including the elevator hall room, to visit a total of R or more rooms. Lower the ID verification level. If it is too much, this condition may not be met.
JOI has two offices, and the rooms of the kth office (k = 1, 2) are Wk in the east-west direction and Hk in the north-south direction, for a total of Wk × Hk. From the west. The i-th and j-th rooms from the north are represented by (i, j) k.
Given the values of Wk, Hk and R, the location of the elevator hall (Xk, Yk) k, and the confidentiality level of each room, visitors can visit a total of R or more rooms in the two offices. Create a program to find the minimum sum of the authentication levels of the visitor's ID card.
It should be noted that how JOI profits from making "just a strange invention" is the highest secret within the company and no one knows except the president.
input
The input consists of multiple datasets. Each dataset is given in the following format.
The positive integer R (1 ≤ R ≤ 100000) is written on the first line. The data of the two offices are given in order on the second and subsequent lines.
The office data is the positive integers Wk, Hk, Xk, Yk (1 ≤ Xk ≤ Wk ≤ 500, 1 ≤ Yk ≤ Hk ≤ 500) in the first line, followed by the i-th in line j of the Hk line, the room. (i, j) Given as an integer Lk, i, j (1 ≤ Lk, i, j <100000000 = 108) representing the confidentiality level of k.
Also, R ≤ W1 × H1 + W2 × H2 is satisfied.
Of the scoring data, 30% of the points are given by satisfying R, Wk, Hk ≤ 100.
When R is 0, it indicates the end of input. The number of data sets does not exceed 10.
output
For each dataset, the minimum sum of the required ID authentication levels is output on one line.
Examples
Input
5
2 2 1 2
9 5
1 17
3 2 2 1
6 1 20
8 18 3
8
5 4 1 3
5 5 4 5 5
8 2 1 9 7
1 1 3 5 1
7 2 7 1 3
6 5 6 2
2 3 5 8 2 7
1 6 9 4 5 1
2 4 5 4 2 2
5 4 2 5 3 3
7 1 5 1 5 6
6
3 3 2 2
2 9 2
9 1 9
2 9 2
2 2 1 1
1 3
5 7
0
Output
15
4
9
Input
None
Output
None | instruction | 0 | 62,215 | 8 | 124,430 |
"Correct Solution:
```
from heapq import heappop as pop
from heapq import heappush as push
INF = 1000000000000
def bfs(lst, used, que, w, h):
v, y, x = pop(que)
if y > 0 and not used[y - 1][x]:
push(que, (lst[y - 1][x], y - 1, x))
used[y - 1][x] = True
if h > y + 1 and not used[y + 1][x]:
push(que, (lst[y + 1][x], y + 1, x))
used[y + 1][x] = True
if x > 0 and not used[y][x - 1]:
push(que, (lst[y][x - 1], y, x - 1))
used[y][x - 1] = True
if w > x + 1 and not used[y][x + 1]:
push(que, (lst[y][x + 1], y, x + 1))
used[y][x + 1] = True
return v
def make_dic(lst, w, h, x, y):
que = [(1, y, x)]
used = [[False] * w for _ in range(h)]
used[y][x] = True
dic = [[0, 0]]
app = dic.append
Max = 0
acc = 0
while que:
v = bfs(lst, used, que, w, h)
acc += 1
if v > Max:
app([v, acc])
Max = v
else:
dic[-1][1] += 1
return dic
def solve():
while True:
R = int(input())
if not R:
break
w1, h1, x1, y1 = map(int, input().split())
lst1 = [list(map(int, input().split())) for _ in range(h1)]
w2, h2, x2, y2 = map(int, input().split())
lst2 = [list(map(int, input().split())) for _ in range(h2)]
dic1 = make_dic(lst1, w1, h1, x1 - 1, y1 - 1)
dic2 = make_dic(lst2, w2, h2, x2 - 1, y2 - 1)
end1 = len(dic1)
end2 = len(dic2)
ind1 = 0
ind2 = end2 - 1
ans = INF
while ind1 < end1 and ind2 > 0:
r1, sum1 = dic1[ind1]
r2, sum2 = dic2[ind2]
if sum1 + sum2 < R:
ind1 += 1
continue
while ind2 > 0 and sum1 + sum2 >= R:
ind2 -= 1
r2, sum2 = dic2[ind2]
if ind2 == 0 and sum1 + sum2 >= R:
rs = r1 + r2
if rs < ans:
ans = rs
break
else:
if ind2 < end2 - 1:
ind2 += 1
r2 = dic2[ind2][0]
rs = r1 + r2
if rs < ans:
ans = rs
ind1 += 1
print(ans)
solve()
``` | output | 1 | 62,215 | 8 | 124,431 |
Provide a correct Python 3 solution for this coding contest problem.
problem
Do you know Just Odd Inventions? The business of this company is to "just odd inventions". Here we call it JOI for short.
JOI has two offices, each of which has square rooms of the same size arranged in a grid pattern. All the rooms that are in contact with each other have an ID card authentication function. There is a door. Since JOI handles various levels of confidential information, a positive integer called the confidentiality level is set for each room, and the authentication level of the non-negative integer set for each ID office is set. You can only enter the room at the confidentiality level or higher. Each office has only one entrance / exit in the elevator hall, and the confidentiality level of the room in the elevator hall is the lowest 1. The certification level for the office is 1. When it is 0, you cannot even enter the elevator hall.
At JOI, the president suddenly proposed to conduct a tour to invite the general public to tour the company. You need to decide the combination of identification level of the ID card to be given to the visitor. Whenever a visitor finds a door that can be opened, he opens it and enters (it is possible to visit the same room multiple times). Therefore, he does not want to raise the authentication level of the visitor's ID more than necessary. However, in order to make the tour attractive, it is necessary to allow two offices, including the elevator hall room, to visit a total of R or more rooms. Lower the ID verification level. If it is too much, this condition may not be met.
JOI has two offices, and the rooms of the kth office (k = 1, 2) are Wk in the east-west direction and Hk in the north-south direction, for a total of Wk × Hk. From the west. The i-th and j-th rooms from the north are represented by (i, j) k.
Given the values of Wk, Hk and R, the location of the elevator hall (Xk, Yk) k, and the confidentiality level of each room, visitors can visit a total of R or more rooms in the two offices. Create a program to find the minimum sum of the authentication levels of the visitor's ID card.
It should be noted that how JOI profits from making "just a strange invention" is the highest secret within the company and no one knows except the president.
input
The input consists of multiple datasets. Each dataset is given in the following format.
The positive integer R (1 ≤ R ≤ 100000) is written on the first line. The data of the two offices are given in order on the second and subsequent lines.
The office data is the positive integers Wk, Hk, Xk, Yk (1 ≤ Xk ≤ Wk ≤ 500, 1 ≤ Yk ≤ Hk ≤ 500) in the first line, followed by the i-th in line j of the Hk line, the room. (i, j) Given as an integer Lk, i, j (1 ≤ Lk, i, j <100000000 = 108) representing the confidentiality level of k.
Also, R ≤ W1 × H1 + W2 × H2 is satisfied.
Of the scoring data, 30% of the points are given by satisfying R, Wk, Hk ≤ 100.
When R is 0, it indicates the end of input. The number of data sets does not exceed 10.
output
For each dataset, the minimum sum of the required ID authentication levels is output on one line.
Examples
Input
5
2 2 1 2
9 5
1 17
3 2 2 1
6 1 20
8 18 3
8
5 4 1 3
5 5 4 5 5
8 2 1 9 7
1 1 3 5 1
7 2 7 1 3
6 5 6 2
2 3 5 8 2 7
1 6 9 4 5 1
2 4 5 4 2 2
5 4 2 5 3 3
7 1 5 1 5 6
6
3 3 2 2
2 9 2
9 1 9
2 9 2
2 2 1 1
1 3
5 7
0
Output
15
4
9
Input
None
Output
None | instruction | 0 | 62,216 | 8 | 124,432 |
"Correct Solution:
```
from heapq import heappop as pop
from heapq import heappush as push
INF = 1000000000000
def bfs(lst, used, que, w, h):
v, y, x = pop(que)
if not used[y - 1][x]:
push(que, (lst[y - 2][x - 1], y - 1, x))
used[y - 1][x] = True
if not used[y + 1][x]:
push(que, (lst[y][x - 1], y + 1, x))
used[y + 1][x] = True
if not used[y][x - 1]:
push(que, (lst[y - 1][x - 2], y, x - 1))
used[y][x - 1] = True
if not used[y][x + 1]:
push(que, (lst[y - 1][x], y, x + 1))
used[y][x + 1] = True
return v
def make_dic(lst, w, h, x, y):
que = [(1, y, x)]
used = [[True] + [False] * w + [True] for _ in range(h)]
used.insert(0, [True] * (w + 2))
used.append([True] * (w + 2))
used[y][x] = True
dic = [[0, 0]]
app = dic.append
Max = 0
acc = 0
while que:
v = bfs(lst, used, que, w, h)
acc += 1
if v > Max:
app([v, acc])
Max = v
else:
dic[-1][1] += 1
return dic
def solve():
while True:
R = int(input())
if not R:
break
w1, h1, x1, y1 = map(int, input().split())
lst1 = [list(map(int, input().split())) for _ in range(h1)]
w2, h2, x2, y2 = map(int, input().split())
lst2 = [list(map(int, input().split())) for _ in range(h2)]
dic1 = make_dic(lst1, w1, h1, x1, y1)
dic2 = make_dic(lst2, w2, h2, x2, y2)
end1 = len(dic1)
end2 = len(dic2)
ind1 = 0
ind2 = end2 - 1
ans = INF
while ind1 < end1 and ind2 > 0:
r1, sum1 = dic1[ind1]
r2, sum2 = dic2[ind2]
if sum1 + sum2 < R:
ind1 += 1
continue
while ind2 > 0 and sum1 + sum2 >= R:
ind2 -= 1
r2, sum2 = dic2[ind2]
if ind2 == 0 and sum1 + sum2 >= R:
rs = r1 + r2
if rs < ans:
ans = rs
break
else:
ind2 += 1
r2 = dic2[ind2][0]
rs = r1 + r2
if rs < ans:
ans = rs
ind1 += 1
print(ans)
solve()
``` | output | 1 | 62,216 | 8 | 124,433 |
Provide a correct Python 3 solution for this coding contest problem.
problem
Do you know Just Odd Inventions? The business of this company is to "just odd inventions". Here we call it JOI for short.
JOI has two offices, each of which has square rooms of the same size arranged in a grid pattern. All the rooms that are in contact with each other have an ID card authentication function. There is a door. Since JOI handles various levels of confidential information, a positive integer called the confidentiality level is set for each room, and the authentication level of the non-negative integer set for each ID office is set. You can only enter the room at the confidentiality level or higher. Each office has only one entrance / exit in the elevator hall, and the confidentiality level of the room in the elevator hall is the lowest 1. The certification level for the office is 1. When it is 0, you cannot even enter the elevator hall.
At JOI, the president suddenly proposed to conduct a tour to invite the general public to tour the company. You need to decide the combination of identification level of the ID card to be given to the visitor. Whenever a visitor finds a door that can be opened, he opens it and enters (it is possible to visit the same room multiple times). Therefore, he does not want to raise the authentication level of the visitor's ID more than necessary. However, in order to make the tour attractive, it is necessary to allow two offices, including the elevator hall room, to visit a total of R or more rooms. Lower the ID verification level. If it is too much, this condition may not be met.
JOI has two offices, and the rooms of the kth office (k = 1, 2) are Wk in the east-west direction and Hk in the north-south direction, for a total of Wk × Hk. From the west. The i-th and j-th rooms from the north are represented by (i, j) k.
Given the values of Wk, Hk and R, the location of the elevator hall (Xk, Yk) k, and the confidentiality level of each room, visitors can visit a total of R or more rooms in the two offices. Create a program to find the minimum sum of the authentication levels of the visitor's ID card.
It should be noted that how JOI profits from making "just a strange invention" is the highest secret within the company and no one knows except the president.
input
The input consists of multiple datasets. Each dataset is given in the following format.
The positive integer R (1 ≤ R ≤ 100000) is written on the first line. The data of the two offices are given in order on the second and subsequent lines.
The office data is the positive integers Wk, Hk, Xk, Yk (1 ≤ Xk ≤ Wk ≤ 500, 1 ≤ Yk ≤ Hk ≤ 500) in the first line, followed by the i-th in line j of the Hk line, the room. (i, j) Given as an integer Lk, i, j (1 ≤ Lk, i, j <100000000 = 108) representing the confidentiality level of k.
Also, R ≤ W1 × H1 + W2 × H2 is satisfied.
Of the scoring data, 30% of the points are given by satisfying R, Wk, Hk ≤ 100.
When R is 0, it indicates the end of input. The number of data sets does not exceed 10.
output
For each dataset, the minimum sum of the required ID authentication levels is output on one line.
Examples
Input
5
2 2 1 2
9 5
1 17
3 2 2 1
6 1 20
8 18 3
8
5 4 1 3
5 5 4 5 5
8 2 1 9 7
1 1 3 5 1
7 2 7 1 3
6 5 6 2
2 3 5 8 2 7
1 6 9 4 5 1
2 4 5 4 2 2
5 4 2 5 3 3
7 1 5 1 5 6
6
3 3 2 2
2 9 2
9 1 9
2 9 2
2 2 1 1
1 3
5 7
0
Output
15
4
9
Input
None
Output
None | instruction | 0 | 62,217 | 8 | 124,434 |
"Correct Solution:
```
from heapq import heappop as pop
from heapq import heappush as push
INF = 1000000000000
def bfs(lst, used, que, w, h):
v, y, x = pop(que)
if y > 0 and not used[y - 1][x]:
push(que, (lst[y - 1][x], y - 1, x))
used[y - 1][x] = True
if h > y + 1 and not used[y + 1][x]:
push(que, (lst[y + 1][x], y + 1, x))
used[y + 1][x] = True
if x > 0 and not used[y][x - 1]:
push(que, (lst[y][x - 1], y, x - 1))
used[y][x - 1] = True
if w > x + 1 and not used[y][x + 1]:
push(que, (lst[y][x + 1], y, x + 1))
used[y][x + 1] = True
return v
def make_dic(lst, w, h, x, y):
que = [(1, y, x)]
used = [[False] * w for _ in range(h)]
used[y][x] = True
dic = [[0, 0]]
app = dic.append
Max = 0
acc = 0
while que:
v = bfs(lst, used, que, w, h)
acc += 1
if v > Max:
app([v, acc])
Max = v
else:
dic[-1][1] += 1
return dic
def solve():
while True:
R = int(input())
if not R:
break
w1, h1, x1, y1 = map(int, input().split())
x1 -= 1
y1 -= 1
lst1 = [list(map(int, input().split())) for _ in range(h1)]
used1 = [[False] * w1 for _ in range(h1)]
w2, h2, x2, y2 = map(int, input().split())
x2 -= 1
y2 -= 1
lst2 = [list(map(int, input().split())) for _ in range(h2)]
used2 = [[False] * w2 for _ in range(h2)]
dic1 = make_dic(lst1, w1, h1, x1, y1)
dic2 = make_dic(lst2, w2, h2, x2, y2)
end1 = len(dic1)
end2 = len(dic2)
ind1 = 0
ind2 = end2 - 1
ans = INF
while ind1 < end1 and ind2 > 0:
r1, sum1 = dic1[ind1]
r2, sum2 = dic2[ind2]
if sum1 + sum2 < R:
ind1 += 1
continue
while ind2 > 0 and sum1 + sum2 >= R:
ind2 -= 1
r2, sum2 = dic2[ind2]
if ind2 == 0 and sum1 + sum2 >= R:
rs = r1 + r2
if rs < ans:
ans = rs
break
else:
if ind2 < end2 - 1:
ind2 += 1
r2 = dic2[ind2][0]
rs = r1 + r2
if rs < ans:
ans = rs
ind1 += 1
print(ans)
solve()
``` | output | 1 | 62,217 | 8 | 124,435 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya's house is situated in a forest, and there is a mushroom glade near it. The glade consists of two rows, each of which can be divided into n consecutive cells. For each cell Vasya knows how fast the mushrooms grow in this cell (more formally, how many grams of mushrooms grow in this cell each minute). Vasya spends exactly one minute to move to some adjacent cell. Vasya cannot leave the glade. Two cells are considered adjacent if they share a common side. When Vasya enters some cell, he instantly collects all the mushrooms growing there.
Vasya begins his journey in the left upper cell. Every minute Vasya must move to some adjacent cell, he cannot wait for the mushrooms to grow. He wants to visit all the cells exactly once and maximize the total weight of the collected mushrooms. Initially, all mushrooms have a weight of 0. Note that Vasya doesn't need to return to the starting cell.
Help Vasya! Calculate the maximum total weight of mushrooms he can collect.
Input
The first line contains the number n (1 ≤ n ≤ 3·105) — the length of the glade.
The second line contains n numbers a1, a2, ..., an (1 ≤ ai ≤ 106) — the growth rate of mushrooms in the first row of the glade.
The third line contains n numbers b1, b2, ..., bn (1 ≤ bi ≤ 106) is the growth rate of mushrooms in the second row of the glade.
Output
Output one number — the maximum total weight of mushrooms that Vasya can collect by choosing the optimal route. Pay attention that Vasya must visit every cell of the glade exactly once.
Examples
Input
3
1 2 3
6 5 4
Output
70
Input
3
1 1000 10000
10 100 100000
Output
543210
Note
In the first test case, the optimal route is as follows:
<image> Thus, the collected weight of mushrooms will be 0·1 + 1·2 + 2·3 + 3·4 + 4·5 + 5·6 = 70.
In the second test case, the optimal route is as follows:
<image> Thus, the collected weight of mushrooms will be 0·1 + 1·10 + 2·100 + 3·1000 + 4·10000 + 5·100000 = 543210. | instruction | 0 | 62,269 | 8 | 124,538 |
Tags: dp, implementation
Correct Solution:
```
n = int(input())
a = [list(map(int, input().split())) for i in range(2)]
if n != 1:
sum_up, pref_up, sum_down, pref_down = [[[0 for i in range(n)] for j in range(2)] for _ in range(4)]
for i in range(2):
sum_up[i][n - 1] = a[i][n - 1]
pref_up[i][n - 1] = a[i][n - 1]
pref_down[i][n - 1] = a[i][n - 1]
for j in range(n - 2, -1, -1):
sum_up[i][j] = sum_up[i][j + 1] + a[i][j]
pref_up[i][j] = pref_up[i][j + 1] + sum_up[i][j]
pref_down[i][j] = pref_down[i][j + 1] + a[i][j] * (n - j)
zig = [[0 for i in range(n)] for j in range(2)]
for j in range(n):
for i in range(2):
if j % 2 == 0:
if i == 0:
zig[i][j] = a[i][j] * j * 2 + zig[i][j - 1]
else:
zig[i][j] = a[i][j] * (j * 2 + 1) + zig[1 - i][j]
else:
if i == 0:
zig[1 - i][j] = a[1 - i][j] * j * 2 + zig[1 - i][j - 1]
else:
zig[1 - i][j] = a[1 - i][j] * (j * 2 + 1) + zig[i][j]
ans = -1e18
for j in range(n):
if j == 0:
ans = max(ans, pref_up[0][j] + pref_down[1][j] + sum_up[1][j] * n - sum_up[0][j] - sum_up[1][j])
else:
if j == n - 1:
ans = max(ans, zig[1 - (j % 2)][n - 1])
else:
if j % 2 == 1:
ans = max(ans, pref_up[0][j + 1] + sum_up[0][j + 1] * (4 * (j // 2 + 1) - 1) + pref_down[1][j + 1] - sum_up[1][j + 1] + sum_up[1][j + 1] * (4 * (j // 2 + 1) - 1 + n - j) + zig[0][j])
else:
ans = max(ans, pref_up[1][j + 1] - sum_up[1][j + 1] + sum_up[1][j + 1] * (4 * (j // 2) + 2) +
pref_down[0][j + 1] - sum_up[0][j + 1] + sum_up[0][j + 1] * (
4 * (j // 2) + 2 - 1 + n - j) + zig[1][j])
ans = max(ans, pref_up[1][0] + pref_down[0][1] + sum_up[0][1] * n)
print(ans)
else:
print(a[1][0])
``` | output | 1 | 62,269 | 8 | 124,539 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya's house is situated in a forest, and there is a mushroom glade near it. The glade consists of two rows, each of which can be divided into n consecutive cells. For each cell Vasya knows how fast the mushrooms grow in this cell (more formally, how many grams of mushrooms grow in this cell each minute). Vasya spends exactly one minute to move to some adjacent cell. Vasya cannot leave the glade. Two cells are considered adjacent if they share a common side. When Vasya enters some cell, he instantly collects all the mushrooms growing there.
Vasya begins his journey in the left upper cell. Every minute Vasya must move to some adjacent cell, he cannot wait for the mushrooms to grow. He wants to visit all the cells exactly once and maximize the total weight of the collected mushrooms. Initially, all mushrooms have a weight of 0. Note that Vasya doesn't need to return to the starting cell.
Help Vasya! Calculate the maximum total weight of mushrooms he can collect.
Input
The first line contains the number n (1 ≤ n ≤ 3·105) — the length of the glade.
The second line contains n numbers a1, a2, ..., an (1 ≤ ai ≤ 106) — the growth rate of mushrooms in the first row of the glade.
The third line contains n numbers b1, b2, ..., bn (1 ≤ bi ≤ 106) is the growth rate of mushrooms in the second row of the glade.
Output
Output one number — the maximum total weight of mushrooms that Vasya can collect by choosing the optimal route. Pay attention that Vasya must visit every cell of the glade exactly once.
Examples
Input
3
1 2 3
6 5 4
Output
70
Input
3
1 1000 10000
10 100 100000
Output
543210
Note
In the first test case, the optimal route is as follows:
<image> Thus, the collected weight of mushrooms will be 0·1 + 1·2 + 2·3 + 3·4 + 4·5 + 5·6 = 70.
In the second test case, the optimal route is as follows:
<image> Thus, the collected weight of mushrooms will be 0·1 + 1·10 + 2·100 + 3·1000 + 4·10000 + 5·100000 = 543210. | instruction | 0 | 62,270 | 8 | 124,540 |
Tags: dp, implementation
Correct Solution:
```
n = int(input())
F = list(map(int , input().split()))
S = list(map(int , input().split()))
Sum = [0]*n
Sum[n-1] = F[n-1] + S[n-1];
for i in range(n-2, -1, -1):
Sum[i] = Sum[i+1] + F[i] + S[i]
ans1 = 0
for i in range(n):
ans1 += F[i]*i;
ans1 += S[i]* ( 2*n - i - 1)
ans2 = 0
for i in range(n):
ans2 += S[i]* (i + 1);
for i in range(1, n):
ans2 += F[i]* (2*n - i)
x = ans1
y = ans2
ans = [x, y]
for i in range(0, max(0, n-2), 2):
x = x + F[i+1]*2 - S[i] * (2*n-2-2*i) - S[i+1] * (2*n-4-2*i) + Sum[i+2]*2
y = y - F[i+1] * (2*n -2*i - 4) - F[i+2] * (2*n - 2*i - 4) + Sum[i+2] * 2
ans.append(x)
ans.append(y)
print(max(ans))
``` | output | 1 | 62,270 | 8 | 124,541 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya's house is situated in a forest, and there is a mushroom glade near it. The glade consists of two rows, each of which can be divided into n consecutive cells. For each cell Vasya knows how fast the mushrooms grow in this cell (more formally, how many grams of mushrooms grow in this cell each minute). Vasya spends exactly one minute to move to some adjacent cell. Vasya cannot leave the glade. Two cells are considered adjacent if they share a common side. When Vasya enters some cell, he instantly collects all the mushrooms growing there.
Vasya begins his journey in the left upper cell. Every minute Vasya must move to some adjacent cell, he cannot wait for the mushrooms to grow. He wants to visit all the cells exactly once and maximize the total weight of the collected mushrooms. Initially, all mushrooms have a weight of 0. Note that Vasya doesn't need to return to the starting cell.
Help Vasya! Calculate the maximum total weight of mushrooms he can collect.
Input
The first line contains the number n (1 ≤ n ≤ 3·105) — the length of the glade.
The second line contains n numbers a1, a2, ..., an (1 ≤ ai ≤ 106) — the growth rate of mushrooms in the first row of the glade.
The third line contains n numbers b1, b2, ..., bn (1 ≤ bi ≤ 106) is the growth rate of mushrooms in the second row of the glade.
Output
Output one number — the maximum total weight of mushrooms that Vasya can collect by choosing the optimal route. Pay attention that Vasya must visit every cell of the glade exactly once.
Examples
Input
3
1 2 3
6 5 4
Output
70
Input
3
1 1000 10000
10 100 100000
Output
543210
Note
In the first test case, the optimal route is as follows:
<image> Thus, the collected weight of mushrooms will be 0·1 + 1·2 + 2·3 + 3·4 + 4·5 + 5·6 = 70.
In the second test case, the optimal route is as follows:
<image> Thus, the collected weight of mushrooms will be 0·1 + 1·10 + 2·100 + 3·1000 + 4·10000 + 5·100000 = 543210. | instruction | 0 | 62,271 | 8 | 124,542 |
Tags: dp, implementation
Correct Solution:
```
import sys
from array import array
def readline(): return sys.stdin.buffer.readline().decode('utf-8')
n = int(readline())
a = [list(map(int, readline().split())) for _ in range(2)]
acc_m1 = [0]*(2*n+1)
acc1 = [0]*(2*n+1)
acc_m2 = [0]*(2*n+1)
acc2 = [0]*(2*n+1)
for i in range(n):
acc_m1[i+1] = acc_m1[i] + a[0][i] * i
acc1[i+1] = acc1[i] + a[0][i]
acc_m2[i+1] = acc_m2[i] + a[1][i] * i
acc2[i+1] = acc2[i] + a[1][i]
for i, j in zip(range(n-1, -1, -1), range(n, 2*n)):
acc_m1[j+1] = acc_m1[j] + a[1][i] * j
acc1[j+1] = acc1[j] + a[1][i]
acc_m2[j+1] = acc_m2[j] + a[0][i] * j
acc2[j+1] = acc2[j] + a[0][i]
x = 0
ans = 0
for i in range(n):
if (i & 1) == 0:
ans = max(
ans,
x + acc_m1[2*n-i] - acc_m1[i] + (acc1[2*n-i] - acc1[i]) * i
)
x += a[0][i] * (i*2) + a[1][i] * (i*2+1)
else:
ans = max(
ans,
x + acc_m2[2*n-i] - acc_m2[i] + (acc2[2*n-i] - acc2[i]) * i
)
x += a[1][i] * (i*2) + a[0][i] * (i*2+1)
print(ans)
``` | output | 1 | 62,271 | 8 | 124,543 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya's house is situated in a forest, and there is a mushroom glade near it. The glade consists of two rows, each of which can be divided into n consecutive cells. For each cell Vasya knows how fast the mushrooms grow in this cell (more formally, how many grams of mushrooms grow in this cell each minute). Vasya spends exactly one minute to move to some adjacent cell. Vasya cannot leave the glade. Two cells are considered adjacent if they share a common side. When Vasya enters some cell, he instantly collects all the mushrooms growing there.
Vasya begins his journey in the left upper cell. Every minute Vasya must move to some adjacent cell, he cannot wait for the mushrooms to grow. He wants to visit all the cells exactly once and maximize the total weight of the collected mushrooms. Initially, all mushrooms have a weight of 0. Note that Vasya doesn't need to return to the starting cell.
Help Vasya! Calculate the maximum total weight of mushrooms he can collect.
Input
The first line contains the number n (1 ≤ n ≤ 3·105) — the length of the glade.
The second line contains n numbers a1, a2, ..., an (1 ≤ ai ≤ 106) — the growth rate of mushrooms in the first row of the glade.
The third line contains n numbers b1, b2, ..., bn (1 ≤ bi ≤ 106) is the growth rate of mushrooms in the second row of the glade.
Output
Output one number — the maximum total weight of mushrooms that Vasya can collect by choosing the optimal route. Pay attention that Vasya must visit every cell of the glade exactly once.
Examples
Input
3
1 2 3
6 5 4
Output
70
Input
3
1 1000 10000
10 100 100000
Output
543210
Note
In the first test case, the optimal route is as follows:
<image> Thus, the collected weight of mushrooms will be 0·1 + 1·2 + 2·3 + 3·4 + 4·5 + 5·6 = 70.
In the second test case, the optimal route is as follows:
<image> Thus, the collected weight of mushrooms will be 0·1 + 1·10 + 2·100 + 3·1000 + 4·10000 + 5·100000 = 543210. | instruction | 0 | 62,272 | 8 | 124,544 |
Tags: dp, implementation
Correct Solution:
```
import sys
def main():
n = int(input().strip())
a = list(map(int, input().strip().split()))
b = list(map(int, input().strip().split()))
d_a = [0 for _ in range(len(a))]
d_b = [0 for _ in range(len(b))]
sum = []
for aa, bb in zip(reversed(a), reversed(b)):
if len(sum) > 0:
sum.append(aa + bb + sum[-1])
else:
sum.append(aa + bb)
sum = list(reversed(sum))
# print(sum)
d_a[-1] = b[-1]
d_b[-1] = a[-1]
for i in reversed(list(range(n - 1))):
# print(n-i)
# print(((n - i) * 2 - 1))
d_a[i] = sum[i + 1] + d_a[i + 1] + ((n - i) * 2 - 1) * b[i]
d_b[i] = sum[i + 1] + d_b[i + 1] + ((n - i) * 2 - 1) * a[i]
ans = 0
cur = 0
for i in range(n):
if i % 2 == 0:
ans = max(
cur + d_a[i] + sum[i] * 2 * i,
ans
)
cur += 2 * i * a[i] + (2 * i + 1) * b[i]
if i + 1 < n:
ans = max(
cur + d_b[i + 1] + sum[i + 1] * (2 * i + 2),
ans
)
else:
ans = max(
cur + d_b[i] + sum[i] * 2 * i,
ans
)
cur += 2 * i * b[i] + (2 * i + 1) * a[i]
if i + 1 < n:
ans = max(
cur + d_a[i + 1] + sum[i + 1] * (2 * i + 2),
ans
)
print(ans)
return 0
def test(i):
with open("test_{}.txt".format(i)) as fin:
sys.stdin = fin
main()
if __name__ == "__main__":
# test(1)
# test(2)
sys.exit(main())
``` | output | 1 | 62,272 | 8 | 124,545 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya's house is situated in a forest, and there is a mushroom glade near it. The glade consists of two rows, each of which can be divided into n consecutive cells. For each cell Vasya knows how fast the mushrooms grow in this cell (more formally, how many grams of mushrooms grow in this cell each minute). Vasya spends exactly one minute to move to some adjacent cell. Vasya cannot leave the glade. Two cells are considered adjacent if they share a common side. When Vasya enters some cell, he instantly collects all the mushrooms growing there.
Vasya begins his journey in the left upper cell. Every minute Vasya must move to some adjacent cell, he cannot wait for the mushrooms to grow. He wants to visit all the cells exactly once and maximize the total weight of the collected mushrooms. Initially, all mushrooms have a weight of 0. Note that Vasya doesn't need to return to the starting cell.
Help Vasya! Calculate the maximum total weight of mushrooms he can collect.
Input
The first line contains the number n (1 ≤ n ≤ 3·105) — the length of the glade.
The second line contains n numbers a1, a2, ..., an (1 ≤ ai ≤ 106) — the growth rate of mushrooms in the first row of the glade.
The third line contains n numbers b1, b2, ..., bn (1 ≤ bi ≤ 106) is the growth rate of mushrooms in the second row of the glade.
Output
Output one number — the maximum total weight of mushrooms that Vasya can collect by choosing the optimal route. Pay attention that Vasya must visit every cell of the glade exactly once.
Examples
Input
3
1 2 3
6 5 4
Output
70
Input
3
1 1000 10000
10 100 100000
Output
543210
Note
In the first test case, the optimal route is as follows:
<image> Thus, the collected weight of mushrooms will be 0·1 + 1·2 + 2·3 + 3·4 + 4·5 + 5·6 = 70.
In the second test case, the optimal route is as follows:
<image> Thus, the collected weight of mushrooms will be 0·1 + 1·10 + 2·100 + 3·1000 + 4·10000 + 5·100000 = 543210. | instruction | 0 | 62,273 | 8 | 124,546 |
Tags: dp, implementation
Correct Solution:
```
def getss(a):
n = len(a)
ps = [0] * (n+1)
for i in range(n-1,0,-1):
ps[i] = ps[i+1] + a[i]
return ps
def getSum(a, b):
n = len(a)
ans = 0
for i in range(n):
ans += a[i] * i
for i in range(n, 2*n):
ans += b[2*n-i-1] * i
return ans
def main():
n, = map(int, input().split(' '))
a = [x for x in map(int, input().split(' '))]
b = [x for x in map(int, input().split(' '))]
if n == 1:
print(b[0])
return
ssa = getss(a)
ssb = getss(b)
tans = getSum(a, b)
ans = tans
for i in range(0, n - 1, 2):
tans -= (i*2) * a[i] + (i*2+1) * a[i+1] + (2*n-1)*b[i] + (2*n-2)*b[i+1]
tans += (i*2) * a[i] + (i*2+3) * a[i+1] + (i*2+1)*b[i] + (i*2+2)*b[i+1]
tans += 2 * ssa[i+2] + 2 * ssb[i+2]
ans = max(ans, tans)
tans = getSum(b, a)
tans -= (2*n-1) * a[0]
tans += b[0]
tans += ssa[1] + ssb[1]
ans = max(ans, tans)
for i in range(1, n - 1, 2):
tans -= (i*2) * b[i] + (i*2+1) * b[i+1] + (2*n-1)*a[i] + (2*n-2)*a[i+1]
tans += (i*2) * b[i] + (i*2+3) * b[i+1] + (i*2+1)*a[i] + (i*2+2)*a[i+1]
tans += 2 * ssa[i+2] + 2 * ssb[i+2]
ans = max(ans, tans)
print(ans)
if __name__ == '__main__':
main()
``` | output | 1 | 62,273 | 8 | 124,547 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya's house is situated in a forest, and there is a mushroom glade near it. The glade consists of two rows, each of which can be divided into n consecutive cells. For each cell Vasya knows how fast the mushrooms grow in this cell (more formally, how many grams of mushrooms grow in this cell each minute). Vasya spends exactly one minute to move to some adjacent cell. Vasya cannot leave the glade. Two cells are considered adjacent if they share a common side. When Vasya enters some cell, he instantly collects all the mushrooms growing there.
Vasya begins his journey in the left upper cell. Every minute Vasya must move to some adjacent cell, he cannot wait for the mushrooms to grow. He wants to visit all the cells exactly once and maximize the total weight of the collected mushrooms. Initially, all mushrooms have a weight of 0. Note that Vasya doesn't need to return to the starting cell.
Help Vasya! Calculate the maximum total weight of mushrooms he can collect.
Input
The first line contains the number n (1 ≤ n ≤ 3·105) — the length of the glade.
The second line contains n numbers a1, a2, ..., an (1 ≤ ai ≤ 106) — the growth rate of mushrooms in the first row of the glade.
The third line contains n numbers b1, b2, ..., bn (1 ≤ bi ≤ 106) is the growth rate of mushrooms in the second row of the glade.
Output
Output one number — the maximum total weight of mushrooms that Vasya can collect by choosing the optimal route. Pay attention that Vasya must visit every cell of the glade exactly once.
Examples
Input
3
1 2 3
6 5 4
Output
70
Input
3
1 1000 10000
10 100 100000
Output
543210
Note
In the first test case, the optimal route is as follows:
<image> Thus, the collected weight of mushrooms will be 0·1 + 1·2 + 2·3 + 3·4 + 4·5 + 5·6 = 70.
In the second test case, the optimal route is as follows:
<image> Thus, the collected weight of mushrooms will be 0·1 + 1·10 + 2·100 + 3·1000 + 4·10000 + 5·100000 = 543210. | instruction | 0 | 62,274 | 8 | 124,548 |
Tags: dp, implementation
Correct Solution:
```
n = int(input())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
curl_ud_weights = [0] * n
curl_du_weights = [0] * n
sums = [0] * n
sums[n - 1] = a[n - 1] + b[n - 1]
curl_ud_weights[n - 1] = b[n - 1]
curl_du_weights[n - 1] = a[n - 1]
for i in range(n - 2, -1, -1):
sums[i] = sums[i + 1] + (a[i] + b[i])
remain = n * 2 - i * 2 - 1
curl_ud_weights[i] = sums[i + 1] + curl_ud_weights[i + 1] + remain * b[i]
curl_du_weights[i] = sums[i + 1] + curl_du_weights[i + 1] + remain * a[i]
#print(sums[i] + curl_ud_weights[i + 1], remain, "*", b[i])
# -----------------------------------------------------
snake_weight = 0
max_weight = 0
current_weight = -1
for t in range(0, 2 * n, 2):
remain = t % 4
#print(t, snake_weight, a[t//2], b[t//2])
if remain == 0 :
current_weight = sums[t//2] * t + curl_ud_weights[t // 2] + snake_weight
snake_weight += (a[t // 2] * t + b[t // 2] * (t + 1))
elif remain == 2:
current_weight = sums[t//2] * t + curl_du_weights[t // 2] + snake_weight
snake_weight += (b[t // 2] * t + a[t // 2] * (t + 1))
if current_weight > max_weight:
max_weight = current_weight
#print(max_weight, t)
print(max_weight)
#print(curl_ud_weights)
#print(curl_du_weights)
#print(sums)
"""
3
0 1 0
0 0 0
"""
``` | output | 1 | 62,274 | 8 | 124,549 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya's house is situated in a forest, and there is a mushroom glade near it. The glade consists of two rows, each of which can be divided into n consecutive cells. For each cell Vasya knows how fast the mushrooms grow in this cell (more formally, how many grams of mushrooms grow in this cell each minute). Vasya spends exactly one minute to move to some adjacent cell. Vasya cannot leave the glade. Two cells are considered adjacent if they share a common side. When Vasya enters some cell, he instantly collects all the mushrooms growing there.
Vasya begins his journey in the left upper cell. Every minute Vasya must move to some adjacent cell, he cannot wait for the mushrooms to grow. He wants to visit all the cells exactly once and maximize the total weight of the collected mushrooms. Initially, all mushrooms have a weight of 0. Note that Vasya doesn't need to return to the starting cell.
Help Vasya! Calculate the maximum total weight of mushrooms he can collect.
Input
The first line contains the number n (1 ≤ n ≤ 3·105) — the length of the glade.
The second line contains n numbers a1, a2, ..., an (1 ≤ ai ≤ 106) — the growth rate of mushrooms in the first row of the glade.
The third line contains n numbers b1, b2, ..., bn (1 ≤ bi ≤ 106) is the growth rate of mushrooms in the second row of the glade.
Output
Output one number — the maximum total weight of mushrooms that Vasya can collect by choosing the optimal route. Pay attention that Vasya must visit every cell of the glade exactly once.
Examples
Input
3
1 2 3
6 5 4
Output
70
Input
3
1 1000 10000
10 100 100000
Output
543210
Note
In the first test case, the optimal route is as follows:
<image> Thus, the collected weight of mushrooms will be 0·1 + 1·2 + 2·3 + 3·4 + 4·5 + 5·6 = 70.
In the second test case, the optimal route is as follows:
<image> Thus, the collected weight of mushrooms will be 0·1 + 1·10 + 2·100 + 3·1000 + 4·10000 + 5·100000 = 543210. | instruction | 0 | 62,275 | 8 | 124,550 |
Tags: dp, implementation
Correct Solution:
```
def main():
[n] = list(map(int, input().split(" ")))
a = list(map(int, input().split(" ")))
b = list(map(int, input().split(" ")))
sums = []
for i in range(n):
if len(sums) == 0:
sums.append(a[-1]+b[-1])
else:
sums.append(sums[-1]+a[-i-1]+b[-i-1])
bottom_to_top = []
top_to_bottom = []
for i in range(n):
if i == 0:
bottom_to_top.append(a[-1])
top_to_bottom.append(b[-1])
else:
bottom_to_top.append(bottom_to_top[-1]+sums[i-1]+a[-i-1]*(2*i+1))
top_to_bottom.append(top_to_bottom[-1]+sums[i-1]+b[-i-1]*(2*i+1))
best_t = []
best_b = []
for i in range(n):
if i == 0:
best_t.append(top_to_bottom[0])
best_b.append(bottom_to_top[0])
else:
x = b[-i-1]+2*sums[i-1]+best_b[i-1]
y = a[-i-1]+2*sums[i-1]+best_t[i-1]
best_t.append(max([x, top_to_bottom[i]]))
best_b.append(max([y,bottom_to_top[i]]))
#print(list(reversed(best_t)))
#print(list(reversed(best_b)))
print(best_t[-1])
main()
``` | output | 1 | 62,275 | 8 | 124,551 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya's house is situated in a forest, and there is a mushroom glade near it. The glade consists of two rows, each of which can be divided into n consecutive cells. For each cell Vasya knows how fast the mushrooms grow in this cell (more formally, how many grams of mushrooms grow in this cell each minute). Vasya spends exactly one minute to move to some adjacent cell. Vasya cannot leave the glade. Two cells are considered adjacent if they share a common side. When Vasya enters some cell, he instantly collects all the mushrooms growing there.
Vasya begins his journey in the left upper cell. Every minute Vasya must move to some adjacent cell, he cannot wait for the mushrooms to grow. He wants to visit all the cells exactly once and maximize the total weight of the collected mushrooms. Initially, all mushrooms have a weight of 0. Note that Vasya doesn't need to return to the starting cell.
Help Vasya! Calculate the maximum total weight of mushrooms he can collect.
Input
The first line contains the number n (1 ≤ n ≤ 3·105) — the length of the glade.
The second line contains n numbers a1, a2, ..., an (1 ≤ ai ≤ 106) — the growth rate of mushrooms in the first row of the glade.
The third line contains n numbers b1, b2, ..., bn (1 ≤ bi ≤ 106) is the growth rate of mushrooms in the second row of the glade.
Output
Output one number — the maximum total weight of mushrooms that Vasya can collect by choosing the optimal route. Pay attention that Vasya must visit every cell of the glade exactly once.
Examples
Input
3
1 2 3
6 5 4
Output
70
Input
3
1 1000 10000
10 100 100000
Output
543210
Note
In the first test case, the optimal route is as follows:
<image> Thus, the collected weight of mushrooms will be 0·1 + 1·2 + 2·3 + 3·4 + 4·5 + 5·6 = 70.
In the second test case, the optimal route is as follows:
<image> Thus, the collected weight of mushrooms will be 0·1 + 1·10 + 2·100 + 3·1000 + 4·10000 + 5·100000 = 543210. | instruction | 0 | 62,276 | 8 | 124,552 |
Tags: dp, implementation
Correct Solution:
```
n = int(input())
a = list(map(int,input().split()))
b = list(map(int,input().split()))
s = 0
sumTop = [0]*n
s = 0
for i in range (n-1,-1,-1):
s+=a[i]
sumTop[i] = s
s = 0
sumBottom = [0]*n
for i in range (n-1,-1,-1):
s+=b[i]
sumBottom[i] = s
dpTop = [0]*n
s = 0
for i in range(n):
s+=a[i]*i
s+=b[i]*(2*n-i-1)
dpTop[0] = s
dpBottom = [0]*n
s = 0
for i in range(n):
s+=b[i]*i
s+=a[i]*(2*n-i-1)
dpBottom[0] = s
for i in range(1,n):
dpTop[i] = dpTop[i-1] - sumTop[i] - sumBottom[i] - b[i-1]*(2*n - (i-1)*2 - 1)
for i in range(1,n):
dpBottom[i] = dpBottom[i-1] - sumTop[i] - sumBottom[i] - a[i-1]*(2*n - (i-1)*2 - 1)
dpTop.append(0)
dpBottom.append(0)
sumTop.append(0)
sumBottom.append(0)
s = 0
ans = 0
for i in range(n):
if (i%2 == 0):
ans = max(ans,s+dpTop[i]+2*i*(sumTop[i]+sumBottom[i]))
s += a[i] * (2*i)
s += b[i] * (2*i+1)
else:
ans = max(ans,s+dpBottom[i]+2*i*(sumTop[i]+sumBottom[i]) )
s += a[i] * (2*i+1)
s += b[i] * (2*i)
# print(s,ans)
print(ans)
``` | output | 1 | 62,276 | 8 | 124,553 |
Provide tags and a correct Python 2 solution for this coding contest problem.
Vasya's house is situated in a forest, and there is a mushroom glade near it. The glade consists of two rows, each of which can be divided into n consecutive cells. For each cell Vasya knows how fast the mushrooms grow in this cell (more formally, how many grams of mushrooms grow in this cell each minute). Vasya spends exactly one minute to move to some adjacent cell. Vasya cannot leave the glade. Two cells are considered adjacent if they share a common side. When Vasya enters some cell, he instantly collects all the mushrooms growing there.
Vasya begins his journey in the left upper cell. Every minute Vasya must move to some adjacent cell, he cannot wait for the mushrooms to grow. He wants to visit all the cells exactly once and maximize the total weight of the collected mushrooms. Initially, all mushrooms have a weight of 0. Note that Vasya doesn't need to return to the starting cell.
Help Vasya! Calculate the maximum total weight of mushrooms he can collect.
Input
The first line contains the number n (1 ≤ n ≤ 3·105) — the length of the glade.
The second line contains n numbers a1, a2, ..., an (1 ≤ ai ≤ 106) — the growth rate of mushrooms in the first row of the glade.
The third line contains n numbers b1, b2, ..., bn (1 ≤ bi ≤ 106) is the growth rate of mushrooms in the second row of the glade.
Output
Output one number — the maximum total weight of mushrooms that Vasya can collect by choosing the optimal route. Pay attention that Vasya must visit every cell of the glade exactly once.
Examples
Input
3
1 2 3
6 5 4
Output
70
Input
3
1 1000 10000
10 100 100000
Output
543210
Note
In the first test case, the optimal route is as follows:
<image> Thus, the collected weight of mushrooms will be 0·1 + 1·2 + 2·3 + 3·4 + 4·5 + 5·6 = 70.
In the second test case, the optimal route is as follows:
<image> Thus, the collected weight of mushrooms will be 0·1 + 1·10 + 2·100 + 3·1000 + 4·10000 + 5·100000 = 543210. | instruction | 0 | 62,277 | 8 | 124,554 |
Tags: dp, implementation
Correct Solution:
```
from sys import stdin, stdout
from collections import Counter, defaultdict
from itertools import permutations, combinations
raw_input = stdin.readline
pr = stdout.write
def in_arr():
return map(int,raw_input().split())
def pr_num(n):
stdout.write(str(n)+'\n')
def pr_arr(arr):
for i in arr:
stdout.write(str(i)+' ')
stdout.write('\n')
range = xrange # not for python 3.0+
n=int(raw_input())
l1=in_arr()
l2 =in_arr()
arr1=l1+list(reversed(l2))
arr2=l2+list(reversed(l1))
sm1=0
sm2=0
c=0
for i in range(2*n):
sm1+=c*arr1[i]
sm2+=c*arr2[i]
c+=1
for i in range(1,n):
l1[i]+=l1[i-1]
l2[i]+=l2[i-1]
ans=sm1
curr=0
val=(2*n)-1
for i in range(n):
#print i,curr,sm1,sm2
if i:
p1=l1[i]-l1[i-1]
p2=l2[i]-l2[i-1]
else:
p1=l1[i]
p2=l2[i]
if i%2==0:
curr+=(2*i*p1)+((2*i+1)*p2)
else:
curr+=(2*i*p2)+((2*i+1)*p1)
#print val,p1,p2,
sm2-=val*p1
sm1-=val*p2
val-=2
#print sm1,sm2
sm1-=((l1[-1]-l1[i])+(l2[-1]-l2[i]))
sm2-=((l1[-1]-l1[i])+(l2[-1]-l2[i]))
if i%2:
temp=curr+sm1
else:
temp=curr+sm2
temp+=(2*(i+1)*(l1[-1]-l1[i]))
temp+=(2*(i+1)*(l2[-1]-l2[i]))
ans=max(ans,temp)
#print i,curr,sm1,sm2,temp
pr_num(ans)
``` | output | 1 | 62,277 | 8 | 124,555 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya's house is situated in a forest, and there is a mushroom glade near it. The glade consists of two rows, each of which can be divided into n consecutive cells. For each cell Vasya knows how fast the mushrooms grow in this cell (more formally, how many grams of mushrooms grow in this cell each minute). Vasya spends exactly one minute to move to some adjacent cell. Vasya cannot leave the glade. Two cells are considered adjacent if they share a common side. When Vasya enters some cell, he instantly collects all the mushrooms growing there.
Vasya begins his journey in the left upper cell. Every minute Vasya must move to some adjacent cell, he cannot wait for the mushrooms to grow. He wants to visit all the cells exactly once and maximize the total weight of the collected mushrooms. Initially, all mushrooms have a weight of 0. Note that Vasya doesn't need to return to the starting cell.
Help Vasya! Calculate the maximum total weight of mushrooms he can collect.
Input
The first line contains the number n (1 ≤ n ≤ 3·105) — the length of the glade.
The second line contains n numbers a1, a2, ..., an (1 ≤ ai ≤ 106) — the growth rate of mushrooms in the first row of the glade.
The third line contains n numbers b1, b2, ..., bn (1 ≤ bi ≤ 106) is the growth rate of mushrooms in the second row of the glade.
Output
Output one number — the maximum total weight of mushrooms that Vasya can collect by choosing the optimal route. Pay attention that Vasya must visit every cell of the glade exactly once.
Examples
Input
3
1 2 3
6 5 4
Output
70
Input
3
1 1000 10000
10 100 100000
Output
543210
Note
In the first test case, the optimal route is as follows:
<image> Thus, the collected weight of mushrooms will be 0·1 + 1·2 + 2·3 + 3·4 + 4·5 + 5·6 = 70.
In the second test case, the optimal route is as follows:
<image> Thus, the collected weight of mushrooms will be 0·1 + 1·10 + 2·100 + 3·1000 + 4·10000 + 5·100000 = 543210.
Submitted Solution:
```
n=int(input())
x=map(int,input().split())
a=[[],[]]
k=0
for i in x:
a[0].append(i)
k+=i
x=map(int,input().split())
for i in x:
a[1].append(i)
k+=i
sum=[[0],[0]]
for i in range(2):
for j in range(1,n+1):
sum[i].append(sum[i][j-1]+a[i][n-j])
sum2=[[0],[0]]
for i in range(2):
for j in range(1,n+1):
sum2[i].append(sum2[i][j-1]+sum[i][j])
sum3=[[0],[0]]
for i in range(2):
for j in range(1,n+1):
sum3[i].append(sum3[i][j-1]+a[i][n-j]*j)
ans=0
now=0
for i in range(n):
pos=n-i
line=i%2
ans=max(ans,now+sum[0][pos]*i*2+sum[1][pos]*i*2+sum2[line][pos]+sum3[1-line][pos]+sum[1-line][pos]*(n-i))
now+=(2*i+1)*a[line][i]+(2*i+2)*a[1-line][i]
print(ans-k)
``` | instruction | 0 | 62,278 | 8 | 124,556 |
Yes | output | 1 | 62,278 | 8 | 124,557 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya's house is situated in a forest, and there is a mushroom glade near it. The glade consists of two rows, each of which can be divided into n consecutive cells. For each cell Vasya knows how fast the mushrooms grow in this cell (more formally, how many grams of mushrooms grow in this cell each minute). Vasya spends exactly one minute to move to some adjacent cell. Vasya cannot leave the glade. Two cells are considered adjacent if they share a common side. When Vasya enters some cell, he instantly collects all the mushrooms growing there.
Vasya begins his journey in the left upper cell. Every minute Vasya must move to some adjacent cell, he cannot wait for the mushrooms to grow. He wants to visit all the cells exactly once and maximize the total weight of the collected mushrooms. Initially, all mushrooms have a weight of 0. Note that Vasya doesn't need to return to the starting cell.
Help Vasya! Calculate the maximum total weight of mushrooms he can collect.
Input
The first line contains the number n (1 ≤ n ≤ 3·105) — the length of the glade.
The second line contains n numbers a1, a2, ..., an (1 ≤ ai ≤ 106) — the growth rate of mushrooms in the first row of the glade.
The third line contains n numbers b1, b2, ..., bn (1 ≤ bi ≤ 106) is the growth rate of mushrooms in the second row of the glade.
Output
Output one number — the maximum total weight of mushrooms that Vasya can collect by choosing the optimal route. Pay attention that Vasya must visit every cell of the glade exactly once.
Examples
Input
3
1 2 3
6 5 4
Output
70
Input
3
1 1000 10000
10 100 100000
Output
543210
Note
In the first test case, the optimal route is as follows:
<image> Thus, the collected weight of mushrooms will be 0·1 + 1·2 + 2·3 + 3·4 + 4·5 + 5·6 = 70.
In the second test case, the optimal route is as follows:
<image> Thus, the collected weight of mushrooms will be 0·1 + 1·10 + 2·100 + 3·1000 + 4·10000 + 5·100000 = 543210.
Submitted Solution:
```
n = int(input())
a = list(map(int,input().split(' ')))
b = list(map(int,input().split(' ')))
e = [[0]*n,[0]*n]
e1 = [[0]*n,[0]*n]
e2 = [[0]*n,[0]*n]
e[0][-1] = a[-1]
e[1][-1] = b[-1]
e1[0][-1] = (n-1)*a[-1]
e1[1][-1] = (n-1)*b[-1]
for j in range(2):
for i in range(n-2,-1,-1):
e[j][i] += e[j][i+1] + (a[i] if j==0 else b[i])
e1[j][i] += e1[j][i+1] + (i)*(a[i] if j==0 else b[i])
e2[j][i] += e2[j][i+1] + (n-i-1)*(a[i] if j==0 else b[i])
sum0 = e1[0][0] + e2[1][0] + e[1][0]*n
sum1 = 0
j = 1
for i in range(n-1):
sum1 += i*2 * (a[i]+b[i]) + (b[i] if i%2==0 else a[i])
su = sum1
su += e1[j][i+1] + e2[j^1][i+1]
su += e[j][i+1] * (i+1) + e[j^1][i+1] * (i+1+n)
j ^= 1
if su > sum0:
sum0 = su
print(sum0)
``` | instruction | 0 | 62,279 | 8 | 124,558 |
Yes | output | 1 | 62,279 | 8 | 124,559 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya's house is situated in a forest, and there is a mushroom glade near it. The glade consists of two rows, each of which can be divided into n consecutive cells. For each cell Vasya knows how fast the mushrooms grow in this cell (more formally, how many grams of mushrooms grow in this cell each minute). Vasya spends exactly one minute to move to some adjacent cell. Vasya cannot leave the glade. Two cells are considered adjacent if they share a common side. When Vasya enters some cell, he instantly collects all the mushrooms growing there.
Vasya begins his journey in the left upper cell. Every minute Vasya must move to some adjacent cell, he cannot wait for the mushrooms to grow. He wants to visit all the cells exactly once and maximize the total weight of the collected mushrooms. Initially, all mushrooms have a weight of 0. Note that Vasya doesn't need to return to the starting cell.
Help Vasya! Calculate the maximum total weight of mushrooms he can collect.
Input
The first line contains the number n (1 ≤ n ≤ 3·105) — the length of the glade.
The second line contains n numbers a1, a2, ..., an (1 ≤ ai ≤ 106) — the growth rate of mushrooms in the first row of the glade.
The third line contains n numbers b1, b2, ..., bn (1 ≤ bi ≤ 106) is the growth rate of mushrooms in the second row of the glade.
Output
Output one number — the maximum total weight of mushrooms that Vasya can collect by choosing the optimal route. Pay attention that Vasya must visit every cell of the glade exactly once.
Examples
Input
3
1 2 3
6 5 4
Output
70
Input
3
1 1000 10000
10 100 100000
Output
543210
Note
In the first test case, the optimal route is as follows:
<image> Thus, the collected weight of mushrooms will be 0·1 + 1·2 + 2·3 + 3·4 + 4·5 + 5·6 = 70.
In the second test case, the optimal route is as follows:
<image> Thus, the collected weight of mushrooms will be 0·1 + 1·10 + 2·100 + 3·1000 + 4·10000 + 5·100000 = 543210.
Submitted Solution:
```
import sys
import io
stream_enable = 0
inpstream = """
3
1 2 3
6 5 4
"""
if stream_enable:
sys.stdin = io.StringIO(inpstream)
input()
def inpmap():
return list(map(int, input().split()))
n = int(input())
arr = [inpmap(), inpmap()]
s = [0] * n
s[-1] = arr[0][-1] + arr[1][-1]
for i in range(n - 2, -1, -1):
s[i] = s[i + 1] + arr[0][i] + arr[1][i]
# print(s)
a = [0] * n
a[-1] = arr[1][-1] * 2 + arr[0][-1]
b = [0] * n
b[-1] = arr[0][-1] * 2 + arr[1][-1]
for i in range(n - 2, -1, -1):
a[i] = arr[0][i] + a[i + 1] + s[i + 1] + arr[1][i] * (n - i) * 2
b[i] = arr[1][i] + b[i + 1] + s[i + 1] + arr[0][i] * (n - i) * 2
# print(a)
# print(b)
dp = [0] * n
dp[-1] = arr[n % 2][-1]
for i in range(n - 2, -1, -1):
d = i % 2
g1 = arr[1 - d][i] + dp[i + 1] + s[i + 1] * 2
g2 = (a, b)[d][i + 1] + arr[1 - d][i] * ((n - i) * 2 - 1)
dp[i] = max(g1, g2)
print(dp[0])
``` | instruction | 0 | 62,280 | 8 | 124,560 |
Yes | output | 1 | 62,280 | 8 | 124,561 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya's house is situated in a forest, and there is a mushroom glade near it. The glade consists of two rows, each of which can be divided into n consecutive cells. For each cell Vasya knows how fast the mushrooms grow in this cell (more formally, how many grams of mushrooms grow in this cell each minute). Vasya spends exactly one minute to move to some adjacent cell. Vasya cannot leave the glade. Two cells are considered adjacent if they share a common side. When Vasya enters some cell, he instantly collects all the mushrooms growing there.
Vasya begins his journey in the left upper cell. Every minute Vasya must move to some adjacent cell, he cannot wait for the mushrooms to grow. He wants to visit all the cells exactly once and maximize the total weight of the collected mushrooms. Initially, all mushrooms have a weight of 0. Note that Vasya doesn't need to return to the starting cell.
Help Vasya! Calculate the maximum total weight of mushrooms he can collect.
Input
The first line contains the number n (1 ≤ n ≤ 3·105) — the length of the glade.
The second line contains n numbers a1, a2, ..., an (1 ≤ ai ≤ 106) — the growth rate of mushrooms in the first row of the glade.
The third line contains n numbers b1, b2, ..., bn (1 ≤ bi ≤ 106) is the growth rate of mushrooms in the second row of the glade.
Output
Output one number — the maximum total weight of mushrooms that Vasya can collect by choosing the optimal route. Pay attention that Vasya must visit every cell of the glade exactly once.
Examples
Input
3
1 2 3
6 5 4
Output
70
Input
3
1 1000 10000
10 100 100000
Output
543210
Note
In the first test case, the optimal route is as follows:
<image> Thus, the collected weight of mushrooms will be 0·1 + 1·2 + 2·3 + 3·4 + 4·5 + 5·6 = 70.
In the second test case, the optimal route is as follows:
<image> Thus, the collected weight of mushrooms will be 0·1 + 1·10 + 2·100 + 3·1000 + 4·10000 + 5·100000 = 543210.
Submitted Solution:
```
import sys
import math
input = sys.stdin.readline
from functools import cmp_to_key;
def pi():
return(int(input()))
def pl():
return(int(input(), 16))
def ti():
return(list(map(int,input().split())))
def ts():
s = input()
return(list(s[:len(s) - 1]))
def invr():
return(map(int,input().split()))
mod = 998244353;
f = [];
def fact(n,m):
global f;
f = [1 for i in range(n+1)];
f[0] = 1;
for i in range(1,n+1):
f[i] = (f[i-1]*i)%m;
def fast_mod_exp(a,b,m):
res = 1;
while b > 0:
if b & 1:
res = (res*a)%m;
a = (a*a)%m;
b = b >> 1;
return res;
def inverseMod(n,m):
return fast_mod_exp(n,m-2,m);
def ncr(n,r,m):
if r == 0: return 1;
return ((f[n]*inverseMod(f[n-r],m))%m*inverseMod(f[r],m))%m;
def main():
C();
dp = [];
def D():
[n,k] = ti();
a = ti();
a = sorted(a);
cnt = [0 for i in range(n)];
for i in range(n):
c = 0;
for j in range(i,n):
if a[j]-a[i] <= 5: c+=1;
else:break;
cnt[i] = c;
global dp;
dp = [[0 for j in range(k+1)] for i in range(n+1)];
ans = 0;
for i in range(n):
for j in range(k+1):
dp[i+1][j] = max(dp[i+1][j], dp[i][j]);
if j+1 <= k:
dp[i+cnt[i]][j+1] = max(dp[i+cnt[i]][j+1], dp[i][j]+cnt[i]);
print(dp[n][k]);
def C():
n = pi();
a = ti();
b = ti();
sumA123,sumB123,sumA321,sumB321,spSum = [0 for i in range(n)],[0 for i in range(n)],[0 for i in range(n)],[0 for i in range(n)],[0 for i in range(n)];
smA = [0 for i in range(n)];
smB = [0 for i in range(n)];
for i in range(n):
if i == 0:
sumA123[i] = 0;
sumB123[i] = 0;
continue;
sumA123[i] = sumA123[i-1] + (i*a[i]);
sumB123[i] = sumB123[i-1] + (i*b[i]);
for i in range(n-1,-1,-1):
if i == n-1:
sumA321[i] = a[i];
sumB321[i] = b[i];
continue;
sumA321[i] = sumA321[i+1]+((n-i)*a[i]);
sumB321[i] = sumB321[i+1]+((n-i)*b[i]);
for i in range(n):
if i == 0:
spSum[i] = b[i];
else:
if i % 2 == 0:
spSum[i] = spSum[i-1] + 2*i*a[i] + (2*i+1)*b[i];
else:
spSum[i] = spSum[i-1] + (2*i+1)*a[i] + 2*i*b[i];
for i in range(n):
if i == 0:
smA[i] = a[i];
smB[i] = b[i];
continue;
smA[i] = smA[i-1]+a[i];
smB[i] = smB[i-1]+b[i];
mx = 0;
for i in range(n):
if i == 0:
mx = sumA123[n-1] + sumB321[i] + (2*i+n-1-i)*smB[n-1];
continue;
if i % 2 == 0:
mx = max(mx, sumA123[n-1]-sumA123[i-1]+(2*i-i)*(smA[n-1]-smA[i-1])+sumB321[i]+(2*i+n-1-i)*(smB[n-1]-smB[i-1])+spSum[i-1]);
else:
mx = max(mx, sumB123[n-1]-sumB123[i-1]+(2*i-i)*(smB[n-1]-smB[i-1])+sumA321[i]+(2*i+n-1-i)*(smA[n-1]-smA[i-1])+spSum[i-1]);
print(mx);
main();
``` | instruction | 0 | 62,281 | 8 | 124,562 |
Yes | output | 1 | 62,281 | 8 | 124,563 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya's house is situated in a forest, and there is a mushroom glade near it. The glade consists of two rows, each of which can be divided into n consecutive cells. For each cell Vasya knows how fast the mushrooms grow in this cell (more formally, how many grams of mushrooms grow in this cell each minute). Vasya spends exactly one minute to move to some adjacent cell. Vasya cannot leave the glade. Two cells are considered adjacent if they share a common side. When Vasya enters some cell, he instantly collects all the mushrooms growing there.
Vasya begins his journey in the left upper cell. Every minute Vasya must move to some adjacent cell, he cannot wait for the mushrooms to grow. He wants to visit all the cells exactly once and maximize the total weight of the collected mushrooms. Initially, all mushrooms have a weight of 0. Note that Vasya doesn't need to return to the starting cell.
Help Vasya! Calculate the maximum total weight of mushrooms he can collect.
Input
The first line contains the number n (1 ≤ n ≤ 3·105) — the length of the glade.
The second line contains n numbers a1, a2, ..., an (1 ≤ ai ≤ 106) — the growth rate of mushrooms in the first row of the glade.
The third line contains n numbers b1, b2, ..., bn (1 ≤ bi ≤ 106) is the growth rate of mushrooms in the second row of the glade.
Output
Output one number — the maximum total weight of mushrooms that Vasya can collect by choosing the optimal route. Pay attention that Vasya must visit every cell of the glade exactly once.
Examples
Input
3
1 2 3
6 5 4
Output
70
Input
3
1 1000 10000
10 100 100000
Output
543210
Note
In the first test case, the optimal route is as follows:
<image> Thus, the collected weight of mushrooms will be 0·1 + 1·2 + 2·3 + 3·4 + 4·5 + 5·6 = 70.
In the second test case, the optimal route is as follows:
<image> Thus, the collected weight of mushrooms will be 0·1 + 1·10 + 2·100 + 3·1000 + 4·10000 + 5·100000 = 543210.
Submitted Solution:
```
n=int(input())
b=[int(x) for x in input().split()]
c=[int(x) for x in input().split()]
method1=0
method2=0
time1=0
time=0
for i in range(n):
method1+=b[i]*time
time+=1
for i in range(n):
method1+=c[n-1-i]*time
time+=1
for i in range(0,n,2):
method2+=b[i]*time1
time1+=1
method2+=c[i]*time1
time1+=1
if(i+1>=n):
break
method2+=c[i+1]*time1
time1+=1
method2+=b[i+1]*time1
time1+=1
if(method2>method1):
print(method2)
else:
print(method1)
``` | instruction | 0 | 62,282 | 8 | 124,564 |
No | output | 1 | 62,282 | 8 | 124,565 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya's house is situated in a forest, and there is a mushroom glade near it. The glade consists of two rows, each of which can be divided into n consecutive cells. For each cell Vasya knows how fast the mushrooms grow in this cell (more formally, how many grams of mushrooms grow in this cell each minute). Vasya spends exactly one minute to move to some adjacent cell. Vasya cannot leave the glade. Two cells are considered adjacent if they share a common side. When Vasya enters some cell, he instantly collects all the mushrooms growing there.
Vasya begins his journey in the left upper cell. Every minute Vasya must move to some adjacent cell, he cannot wait for the mushrooms to grow. He wants to visit all the cells exactly once and maximize the total weight of the collected mushrooms. Initially, all mushrooms have a weight of 0. Note that Vasya doesn't need to return to the starting cell.
Help Vasya! Calculate the maximum total weight of mushrooms he can collect.
Input
The first line contains the number n (1 ≤ n ≤ 3·105) — the length of the glade.
The second line contains n numbers a1, a2, ..., an (1 ≤ ai ≤ 106) — the growth rate of mushrooms in the first row of the glade.
The third line contains n numbers b1, b2, ..., bn (1 ≤ bi ≤ 106) is the growth rate of mushrooms in the second row of the glade.
Output
Output one number — the maximum total weight of mushrooms that Vasya can collect by choosing the optimal route. Pay attention that Vasya must visit every cell of the glade exactly once.
Examples
Input
3
1 2 3
6 5 4
Output
70
Input
3
1 1000 10000
10 100 100000
Output
543210
Note
In the first test case, the optimal route is as follows:
<image> Thus, the collected weight of mushrooms will be 0·1 + 1·2 + 2·3 + 3·4 + 4·5 + 5·6 = 70.
In the second test case, the optimal route is as follows:
<image> Thus, the collected weight of mushrooms will be 0·1 + 1·10 + 2·100 + 3·1000 + 4·10000 + 5·100000 = 543210.
Submitted Solution:
```
#!/usr/bin/python3
def solve(N, A, B):
sumright = sum(A) + sum(B)
fromtop = 0
for i in range(N):
fromtop += i * A[i]
for i in range(N):
fromtop += (N + i) * B[-1 - i]
frombottom = 0
for i in range(N):
frombottom += i * B[i]
for i in range(N):
frombottom += (N + i) * A[-1 - i]
best = fromtop
cur = 0
# print(f'0: {best}')
for i in range(1, N):
fromtop -= (i - 1) * A[i - 1]
fromtop -= (2 * N - 1 - (i - 1)) * B[i - 1]
frombottom -= (i - 1) * B[i - 1]
frombottom -= (2 * N - 1 - (i - 1)) * A[i - 1]
sumright -= A[i - 1] + B[i - 1]
if i % 2 == 0:
cur += (2 * (i - 1)) * B[i - 1] + (2 * (i - 1) + 1) * A[i - 1]
fromtop += 2 * sumright
best = max(best, cur + fromtop)
# print(f'{i}: {cur + fromtop}, cur={cur}, fromtop={fromtop}, sumright={sumright}')
else:
cur += (2 * (i - 1)) * A[i - 1] + (2 * (i - 1) + 1) * B[i - 1]
if i == 1:
frombottom += sumright
else:
frombottom += 2 * sumright
best = max(best, cur + frombottom)
# print(f'{i}: {cur + frombottom}, cur={cur}, frombottom={frombottom}, sumright={sumright}')
return best
def main():
N = int(input())
A = [int(e) for e in input().split(' ')]
B = [int(e) for e in input().split(' ')]
assert len(A) == N
assert len(B) == N
print(solve(N, A, B))
if __name__ == '__main__':
main()
``` | instruction | 0 | 62,283 | 8 | 124,566 |
No | output | 1 | 62,283 | 8 | 124,567 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya's house is situated in a forest, and there is a mushroom glade near it. The glade consists of two rows, each of which can be divided into n consecutive cells. For each cell Vasya knows how fast the mushrooms grow in this cell (more formally, how many grams of mushrooms grow in this cell each minute). Vasya spends exactly one minute to move to some adjacent cell. Vasya cannot leave the glade. Two cells are considered adjacent if they share a common side. When Vasya enters some cell, he instantly collects all the mushrooms growing there.
Vasya begins his journey in the left upper cell. Every minute Vasya must move to some adjacent cell, he cannot wait for the mushrooms to grow. He wants to visit all the cells exactly once and maximize the total weight of the collected mushrooms. Initially, all mushrooms have a weight of 0. Note that Vasya doesn't need to return to the starting cell.
Help Vasya! Calculate the maximum total weight of mushrooms he can collect.
Input
The first line contains the number n (1 ≤ n ≤ 3·105) — the length of the glade.
The second line contains n numbers a1, a2, ..., an (1 ≤ ai ≤ 106) — the growth rate of mushrooms in the first row of the glade.
The third line contains n numbers b1, b2, ..., bn (1 ≤ bi ≤ 106) is the growth rate of mushrooms in the second row of the glade.
Output
Output one number — the maximum total weight of mushrooms that Vasya can collect by choosing the optimal route. Pay attention that Vasya must visit every cell of the glade exactly once.
Examples
Input
3
1 2 3
6 5 4
Output
70
Input
3
1 1000 10000
10 100 100000
Output
543210
Note
In the first test case, the optimal route is as follows:
<image> Thus, the collected weight of mushrooms will be 0·1 + 1·2 + 2·3 + 3·4 + 4·5 + 5·6 = 70.
In the second test case, the optimal route is as follows:
<image> Thus, the collected weight of mushrooms will be 0·1 + 1·10 + 2·100 + 3·1000 + 4·10000 + 5·100000 = 543210.
Submitted Solution:
```
t=int(input())
l1=list(map(int,input().split()))
l2=list(map(int,input().split()))
l=l1.copy()
l.extend(l2[::-1])
sum1=0
sum2=0
sum3=0
for i in range(2*t):
sum1=sum1+i*l[i]
for i in range(2*t):
sum2=sum2+i*l[i]
for i in range(t):
j=2*i
j1=2*i+1
if(i%2==0):
j,j1=j1,j
sum3=sum3+(j1)*l1[i]
sum3=sum3+(j)*l2[i]
print(max(sum1,sum2,sum3))
``` | instruction | 0 | 62,284 | 8 | 124,568 |
No | output | 1 | 62,284 | 8 | 124,569 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya's house is situated in a forest, and there is a mushroom glade near it. The glade consists of two rows, each of which can be divided into n consecutive cells. For each cell Vasya knows how fast the mushrooms grow in this cell (more formally, how many grams of mushrooms grow in this cell each minute). Vasya spends exactly one minute to move to some adjacent cell. Vasya cannot leave the glade. Two cells are considered adjacent if they share a common side. When Vasya enters some cell, he instantly collects all the mushrooms growing there.
Vasya begins his journey in the left upper cell. Every minute Vasya must move to some adjacent cell, he cannot wait for the mushrooms to grow. He wants to visit all the cells exactly once and maximize the total weight of the collected mushrooms. Initially, all mushrooms have a weight of 0. Note that Vasya doesn't need to return to the starting cell.
Help Vasya! Calculate the maximum total weight of mushrooms he can collect.
Input
The first line contains the number n (1 ≤ n ≤ 3·105) — the length of the glade.
The second line contains n numbers a1, a2, ..., an (1 ≤ ai ≤ 106) — the growth rate of mushrooms in the first row of the glade.
The third line contains n numbers b1, b2, ..., bn (1 ≤ bi ≤ 106) is the growth rate of mushrooms in the second row of the glade.
Output
Output one number — the maximum total weight of mushrooms that Vasya can collect by choosing the optimal route. Pay attention that Vasya must visit every cell of the glade exactly once.
Examples
Input
3
1 2 3
6 5 4
Output
70
Input
3
1 1000 10000
10 100 100000
Output
543210
Note
In the first test case, the optimal route is as follows:
<image> Thus, the collected weight of mushrooms will be 0·1 + 1·2 + 2·3 + 3·4 + 4·5 + 5·6 = 70.
In the second test case, the optimal route is as follows:
<image> Thus, the collected weight of mushrooms will be 0·1 + 1·10 + 2·100 + 3·1000 + 4·10000 + 5·100000 = 543210.
Submitted Solution:
```
n=int(input())
F=list(map(int,input().split()))
S=list(map(int,input().split()))
SUM=[0]*n
SUM[n-1]=F[n-1]+S[n-1]
for i in range(n-2,-1,-1):
SUM[i]=SUM[i+1]+F[i]+S[i]
ANS1=0
for i in range(n):
ANS1+=F[i]*i
ANS1+=S[i]*(2*n-1-i)
ANS2=0
for i in range(n):
ANS2+=S[i]*(i+1)
for i in range(1,n):
ANS2+=F[i]*(2*n-i)
#SABUN[i]=F[i+1]*2+S[i]*(2*n-1-i-i)+S[i+1]*(n-3-i-i)+SUM[2*i]*i
x=ANS1
y=ANS2
ANS=[x,y]
for i in range(0,n//2,2):
if 2*i+2>=n:
x=x+F[i+1]*2-S[i]*(2*n-2-i-i)-S[i+1]*(2*n-4-i-i)
#y=y-F[i+1]*(2*n-i-4)
else:
x=x+F[i+1]*2-S[i]*(2*n-2-i-i)-S[i+1]*(2*n-4-i-i)+SUM[2*i+2]*2
y=y-F[i+1]*(2*n-i-i-4)-F[i+2]*(2*n-i-i-4)+SUM[2*i+2]*2
ANS.append(x)
ANS.append(y)
#print(ANS,i)
print(max(ANS))
``` | instruction | 0 | 62,285 | 8 | 124,570 |
No | output | 1 | 62,285 | 8 | 124,571 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.