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 a correct Python 3 solution for this coding contest problem.
Aizu Gakuen High School holds a school festival every year. The most popular of these is the haunted house. The most popular reason is that 9 classes do haunted houses instead of 1 or 2 classes. Each one has its own unique haunted house. Therefore, many visitors come from the neighborhood these days.
Therefore, the school festival executive committee decided to unify the admission fee for the haunted house in the school as shown in the table below, and based on this, total the total number of visitors and income for each class.
Admission fee list (admission fee per visitor)
Morning Afternoon
200 yen 300 yen
Enter the number of visitors in the morning and afternoon for each class, and create a program that creates a list of the total number of visitors and income for each class.
Input
The input is given in the following format:
name1 a1 b1
name2 a2 b2
::
name9 a9 b9
The input consists of 9 lines, the class name of the i-th class on the i-line namei (a half-width character string of 1 to 15 characters including numbers and alphabets), the number of visitors in the morning ai (0 ≤ ai ≤ 400) , Afternoon attendance bi (0 ≤ bi ≤ 400) is given.
Output
On the i-line, output the class name of the i-class, the total number of visitors, and the fee income on one line separated by blanks.
Example
Input
1a 132 243
1c 324 183
1f 93 199
2b 372 163
2c 229 293
2e 391 206
3a 118 168
3b 263 293
3d 281 102
Output
1a 375 99300
1c 507 119700
1f 292 78300
2b 535 123300
2c 522 133700
2e 597 140000
3a 286 74000
3b 556 140500
3d 383 86800 | instruction | 0 | 54,707 | 8 | 109,414 |
"Correct Solution:
```
for i in range(9):
n,a,b = input().split()
a = int(a)
b = int(b)
print(n,a+b,200*a+300*b)
``` | output | 1 | 54,707 | 8 | 109,415 |
Provide a correct Python 3 solution for this coding contest problem.
Aizu Gakuen High School holds a school festival every year. The most popular of these is the haunted house. The most popular reason is that 9 classes do haunted houses instead of 1 or 2 classes. Each one has its own unique haunted house. Therefore, many visitors come from the neighborhood these days.
Therefore, the school festival executive committee decided to unify the admission fee for the haunted house in the school as shown in the table below, and based on this, total the total number of visitors and income for each class.
Admission fee list (admission fee per visitor)
Morning Afternoon
200 yen 300 yen
Enter the number of visitors in the morning and afternoon for each class, and create a program that creates a list of the total number of visitors and income for each class.
Input
The input is given in the following format:
name1 a1 b1
name2 a2 b2
::
name9 a9 b9
The input consists of 9 lines, the class name of the i-th class on the i-line namei (a half-width character string of 1 to 15 characters including numbers and alphabets), the number of visitors in the morning ai (0 ≤ ai ≤ 400) , Afternoon attendance bi (0 ≤ bi ≤ 400) is given.
Output
On the i-line, output the class name of the i-class, the total number of visitors, and the fee income on one line separated by blanks.
Example
Input
1a 132 243
1c 324 183
1f 93 199
2b 372 163
2c 229 293
2e 391 206
3a 118 168
3b 263 293
3d 281 102
Output
1a 375 99300
1c 507 119700
1f 292 78300
2b 535 123300
2c 522 133700
2e 597 140000
3a 286 74000
3b 556 140500
3d 383 86800 | instruction | 0 | 54,708 | 8 | 109,416 |
"Correct Solution:
```
for i in range(0,9):
n,a,b=input().split()
fee=int(a)*200+int(b)*300
p=int(a)+int(b)
print(n,p,fee)
``` | output | 1 | 54,708 | 8 | 109,417 |
Provide a correct Python 3 solution for this coding contest problem.
Aizu Gakuen High School holds a school festival every year. The most popular of these is the haunted house. The most popular reason is that 9 classes do haunted houses instead of 1 or 2 classes. Each one has its own unique haunted house. Therefore, many visitors come from the neighborhood these days.
Therefore, the school festival executive committee decided to unify the admission fee for the haunted house in the school as shown in the table below, and based on this, total the total number of visitors and income for each class.
Admission fee list (admission fee per visitor)
Morning Afternoon
200 yen 300 yen
Enter the number of visitors in the morning and afternoon for each class, and create a program that creates a list of the total number of visitors and income for each class.
Input
The input is given in the following format:
name1 a1 b1
name2 a2 b2
::
name9 a9 b9
The input consists of 9 lines, the class name of the i-th class on the i-line namei (a half-width character string of 1 to 15 characters including numbers and alphabets), the number of visitors in the morning ai (0 ≤ ai ≤ 400) , Afternoon attendance bi (0 ≤ bi ≤ 400) is given.
Output
On the i-line, output the class name of the i-class, the total number of visitors, and the fee income on one line separated by blanks.
Example
Input
1a 132 243
1c 324 183
1f 93 199
2b 372 163
2c 229 293
2e 391 206
3a 118 168
3b 263 293
3d 281 102
Output
1a 375 99300
1c 507 119700
1f 292 78300
2b 535 123300
2c 522 133700
2e 597 140000
3a 286 74000
3b 556 140500
3d 383 86800 | instruction | 0 | 54,709 | 8 | 109,418 |
"Correct Solution:
```
for _ in range(9):
a,b,c = input().split()
b = int(b)
c = int(c)
print(a,b+c,b*200+c*300)
``` | output | 1 | 54,709 | 8 | 109,419 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Aizu Gakuen High School holds a school festival every year. The most popular of these is the haunted house. The most popular reason is that 9 classes do haunted houses instead of 1 or 2 classes. Each one has its own unique haunted house. Therefore, many visitors come from the neighborhood these days.
Therefore, the school festival executive committee decided to unify the admission fee for the haunted house in the school as shown in the table below, and based on this, total the total number of visitors and income for each class.
Admission fee list (admission fee per visitor)
Morning Afternoon
200 yen 300 yen
Enter the number of visitors in the morning and afternoon for each class, and create a program that creates a list of the total number of visitors and income for each class.
Input
The input is given in the following format:
name1 a1 b1
name2 a2 b2
::
name9 a9 b9
The input consists of 9 lines, the class name of the i-th class on the i-line namei (a half-width character string of 1 to 15 characters including numbers and alphabets), the number of visitors in the morning ai (0 ≤ ai ≤ 400) , Afternoon attendance bi (0 ≤ bi ≤ 400) is given.
Output
On the i-line, output the class name of the i-class, the total number of visitors, and the fee income on one line separated by blanks.
Example
Input
1a 132 243
1c 324 183
1f 93 199
2b 372 163
2c 229 293
2e 391 206
3a 118 168
3b 263 293
3d 281 102
Output
1a 375 99300
1c 507 119700
1f 292 78300
2b 535 123300
2c 522 133700
2e 597 140000
3a 286 74000
3b 556 140500
3d 383 86800
Submitted Solution:
```
for i in range(9):
name,a,b =list(input().split())
print(name,int(a)+int(b),(int(a)*200)+(int(b)*300))
``` | instruction | 0 | 54,710 | 8 | 109,420 |
Yes | output | 1 | 54,710 | 8 | 109,421 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Aizu Gakuen High School holds a school festival every year. The most popular of these is the haunted house. The most popular reason is that 9 classes do haunted houses instead of 1 or 2 classes. Each one has its own unique haunted house. Therefore, many visitors come from the neighborhood these days.
Therefore, the school festival executive committee decided to unify the admission fee for the haunted house in the school as shown in the table below, and based on this, total the total number of visitors and income for each class.
Admission fee list (admission fee per visitor)
Morning Afternoon
200 yen 300 yen
Enter the number of visitors in the morning and afternoon for each class, and create a program that creates a list of the total number of visitors and income for each class.
Input
The input is given in the following format:
name1 a1 b1
name2 a2 b2
::
name9 a9 b9
The input consists of 9 lines, the class name of the i-th class on the i-line namei (a half-width character string of 1 to 15 characters including numbers and alphabets), the number of visitors in the morning ai (0 ≤ ai ≤ 400) , Afternoon attendance bi (0 ≤ bi ≤ 400) is given.
Output
On the i-line, output the class name of the i-class, the total number of visitors, and the fee income on one line separated by blanks.
Example
Input
1a 132 243
1c 324 183
1f 93 199
2b 372 163
2c 229 293
2e 391 206
3a 118 168
3b 263 293
3d 281 102
Output
1a 375 99300
1c 507 119700
1f 292 78300
2b 535 123300
2c 522 133700
2e 597 140000
3a 286 74000
3b 556 140500
3d 383 86800
Submitted Solution:
```
for i in range(9):
name,a,b=map(str,input().split())
a=int(a)
b=int(b)
print(name,a+b,200*a+300*b)
``` | instruction | 0 | 54,711 | 8 | 109,422 |
Yes | output | 1 | 54,711 | 8 | 109,423 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Aizu Gakuen High School holds a school festival every year. The most popular of these is the haunted house. The most popular reason is that 9 classes do haunted houses instead of 1 or 2 classes. Each one has its own unique haunted house. Therefore, many visitors come from the neighborhood these days.
Therefore, the school festival executive committee decided to unify the admission fee for the haunted house in the school as shown in the table below, and based on this, total the total number of visitors and income for each class.
Admission fee list (admission fee per visitor)
Morning Afternoon
200 yen 300 yen
Enter the number of visitors in the morning and afternoon for each class, and create a program that creates a list of the total number of visitors and income for each class.
Input
The input is given in the following format:
name1 a1 b1
name2 a2 b2
::
name9 a9 b9
The input consists of 9 lines, the class name of the i-th class on the i-line namei (a half-width character string of 1 to 15 characters including numbers and alphabets), the number of visitors in the morning ai (0 ≤ ai ≤ 400) , Afternoon attendance bi (0 ≤ bi ≤ 400) is given.
Output
On the i-line, output the class name of the i-class, the total number of visitors, and the fee income on one line separated by blanks.
Example
Input
1a 132 243
1c 324 183
1f 93 199
2b 372 163
2c 229 293
2e 391 206
3a 118 168
3b 263 293
3d 281 102
Output
1a 375 99300
1c 507 119700
1f 292 78300
2b 535 123300
2c 522 133700
2e 597 140000
3a 286 74000
3b 556 140500
3d 383 86800
Submitted Solution:
```
for i in range(9):
name,a,b=input().split()
a=int(a)
b=int(b)
print(name,a+b,(200*a)+(300*b))
``` | instruction | 0 | 54,712 | 8 | 109,424 |
Yes | output | 1 | 54,712 | 8 | 109,425 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Aizu Gakuen High School holds a school festival every year. The most popular of these is the haunted house. The most popular reason is that 9 classes do haunted houses instead of 1 or 2 classes. Each one has its own unique haunted house. Therefore, many visitors come from the neighborhood these days.
Therefore, the school festival executive committee decided to unify the admission fee for the haunted house in the school as shown in the table below, and based on this, total the total number of visitors and income for each class.
Admission fee list (admission fee per visitor)
Morning Afternoon
200 yen 300 yen
Enter the number of visitors in the morning and afternoon for each class, and create a program that creates a list of the total number of visitors and income for each class.
Input
The input is given in the following format:
name1 a1 b1
name2 a2 b2
::
name9 a9 b9
The input consists of 9 lines, the class name of the i-th class on the i-line namei (a half-width character string of 1 to 15 characters including numbers and alphabets), the number of visitors in the morning ai (0 ≤ ai ≤ 400) , Afternoon attendance bi (0 ≤ bi ≤ 400) is given.
Output
On the i-line, output the class name of the i-class, the total number of visitors, and the fee income on one line separated by blanks.
Example
Input
1a 132 243
1c 324 183
1f 93 199
2b 372 163
2c 229 293
2e 391 206
3a 118 168
3b 263 293
3d 281 102
Output
1a 375 99300
1c 507 119700
1f 292 78300
2b 535 123300
2c 522 133700
2e 597 140000
3a 286 74000
3b 556 140500
3d 383 86800
Submitted Solution:
```
a,b,c=map(str,input().split())
print(a,int(b)+int(c),int(b)*200+int(c)*300)
``` | instruction | 0 | 54,714 | 8 | 109,428 |
No | output | 1 | 54,714 | 8 | 109,429 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Summer is coming! It's time for Iahub and Iahubina to work out, as they both want to look hot at the beach. The gym where they go is a matrix a with n lines and m columns. Let number a[i][j] represents the calories burned by performing workout at the cell of gym in the i-th line and the j-th column.
Iahub starts with workout located at line 1 and column 1. He needs to finish with workout a[n][m]. After finishing workout a[i][j], he can go to workout a[i + 1][j] or a[i][j + 1]. Similarly, Iahubina starts with workout a[n][1] and she needs to finish with workout a[1][m]. After finishing workout from cell a[i][j], she goes to either a[i][j + 1] or a[i - 1][j].
There is one additional condition for their training. They have to meet in exactly one cell of gym. At that cell, none of them will work out. They will talk about fast exponentiation (pretty odd small talk) and then both of them will move to the next workout.
If a workout was done by either Iahub or Iahubina, it counts as total gain. Please plan a workout for Iahub and Iahubina such as total gain to be as big as possible. Note, that Iahub and Iahubina can perform workouts with different speed, so the number of cells that they use to reach meet cell may differs.
Input
The first line of the input contains two integers n and m (3 ≤ n, m ≤ 1000). Each of the next n lines contains m integers: j-th number from i-th line denotes element a[i][j] (0 ≤ a[i][j] ≤ 105).
Output
The output contains a single number — the maximum total gain possible.
Examples
Input
3 3
100 100 100
100 1 100
100 100 100
Output
800
Note
Iahub will choose exercises a[1][1] → a[1][2] → a[2][2] → a[3][2] → a[3][3]. Iahubina will choose exercises a[3][1] → a[2][1] → a[2][2] → a[2][3] → a[1][3]. | instruction | 0 | 55,145 | 8 | 110,290 |
Tags: dp
Correct Solution:
```
from collections import deque, defaultdict
from math import sqrt, ceil, factorial, floor, inf, log2, sqrt
import bisect
import copy
from itertools import combinations
import sys
def get_array(): return list(map(int, sys.stdin.readline().strip().split()))
def get_ints(): return map(int, sys.stdin.readline().strip().split())
def input(): return sys.stdin.readline().strip()
arr=[]
n,m=get_ints()
for i in range(n):
a=get_array()
arr.append(a)
##starting from (1,1)
dp=[[0 for i in range(m)]for j in range(n)]
##starting from (1,n)
dp1=[[0 for i in range(m)]for j in range(n)]
dp2=[[0 for i in range(m)]for j in range(n)]
dp3=[[0 for i in range(m)]for j in range(n)]
## startin from top left
dp[0][0]=arr[0][0]
for i in range(1,m):
dp[0][i]+=dp[0][i-1]+arr[0][i]
for j in range(1,n):
dp[j][0]+=dp[j-1][0]+arr[j][0]
for i in range(1,n):
for j in range(1,m):
dp[i][j]+=max(dp[i-1][j],dp[i][j-1])+arr[i][j]
##starting from bottom left
dp1[n-1][0]=arr[n-1][0]
for i in range(1,m):
dp1[n-1][i]+=dp1[n-1][i-1]+arr[n-1][i]
for i in range(n-2,-1,-1):
dp1[i][0]+=dp1[i+1][0]+arr[i][0]
for i in range(n-2,-1,-1):
for j in range(1,m):
dp1[i][j]+=max(dp1[i+1][j],dp1[i][j-1])+arr[i][j]
##starting from bottom right(for A)
dp2[n-1][m-1]=arr[n-1][m-1]
for i in range(m-2,-1,-1):
dp2[n-1][i]+=dp2[n-1][i+1]+arr[n-1][i]
for i in range(n-2,-1,-1):
dp2[i][m-1]+=dp2[i+1][m-1]+arr[i][m-1]
for i in range(n-2,-1,-1):
for j in range(m-2,-1,-1):
dp2[i][j]=max(dp2[i+1][j],dp2[i][j+1])+arr[i][j]
dp3[0][m-1]=arr[0][m-1]
## starting from top right.(for B)
for i in range(m-2,-1,-1):
dp3[0][i]+=dp3[0][i+1]+arr[0][i]
for i in range(1,n):
dp3[i][m-1]+=dp3[i-1][m-1]+arr[i][m-1]
for i in range(1,n):
for j in range(m-2,-1,-1):
dp3[i][j]=max(dp3[i-1][j],dp3[i][j+1])+arr[i][j]
ans=-1
for i in range(n):
for j in range(m):
maxi,maxi1=-1,-1
##A top and B left
if i-1>=0 and j-1>=0 and i+1<n and j+1<m:
maxi, maxi1 = -1, -1
maxi=max(maxi,dp[i-1][j]+dp1[i][j-1])
maxi1 = max(maxi1, dp2[i + 1][j] + dp3[i][j + 1])
ans=max(ans,maxi+maxi1)
if i+1<n and j-1>=0 and j+1<m and i-1>=0:
## A left and B bottom
maxi, maxi1 = -1, -1
maxi=max(maxi,dp[i][j-1]+dp1[i+1][j])
maxi1 = max(maxi1, dp2[i][j + 1] + dp3[i - 1][j])
ans=max(ans,maxi+maxi1)
##print(i,j,maxi,maxi1)
##ans=max(ans,maxi+maxi1)
print(ans)
``` | output | 1 | 55,145 | 8 | 110,291 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Summer is coming! It's time for Iahub and Iahubina to work out, as they both want to look hot at the beach. The gym where they go is a matrix a with n lines and m columns. Let number a[i][j] represents the calories burned by performing workout at the cell of gym in the i-th line and the j-th column.
Iahub starts with workout located at line 1 and column 1. He needs to finish with workout a[n][m]. After finishing workout a[i][j], he can go to workout a[i + 1][j] or a[i][j + 1]. Similarly, Iahubina starts with workout a[n][1] and she needs to finish with workout a[1][m]. After finishing workout from cell a[i][j], she goes to either a[i][j + 1] or a[i - 1][j].
There is one additional condition for their training. They have to meet in exactly one cell of gym. At that cell, none of them will work out. They will talk about fast exponentiation (pretty odd small talk) and then both of them will move to the next workout.
If a workout was done by either Iahub or Iahubina, it counts as total gain. Please plan a workout for Iahub and Iahubina such as total gain to be as big as possible. Note, that Iahub and Iahubina can perform workouts with different speed, so the number of cells that they use to reach meet cell may differs.
Input
The first line of the input contains two integers n and m (3 ≤ n, m ≤ 1000). Each of the next n lines contains m integers: j-th number from i-th line denotes element a[i][j] (0 ≤ a[i][j] ≤ 105).
Output
The output contains a single number — the maximum total gain possible.
Examples
Input
3 3
100 100 100
100 1 100
100 100 100
Output
800
Note
Iahub will choose exercises a[1][1] → a[1][2] → a[2][2] → a[3][2] → a[3][3]. Iahubina will choose exercises a[3][1] → a[2][1] → a[2][2] → a[2][3] → a[1][3]. | instruction | 0 | 55,146 | 8 | 110,292 |
Tags: dp
Correct Solution:
```
R = lambda: map(int, input().split())
n, m = R()
g = [list() for i in range(n)]
for i in range(n):
g[i] = list(R())
dp1, dp2, dp3, dp4 = ([[0] * (m + 1) for j in range(n + 1)] for i in range(4))
for i in range(n):
for j in range(m):
dp1[i][j] = g[i][j] + max(dp1[i - 1][j], dp1[i][j - 1])
for j in range(m - 1, -1, -1):
dp2[i][j] = g[i][j] + max(dp2[i - 1][j], dp2[i][j + 1])
for i in range(n - 1, -1, -1):
for j in range(m):
dp3[i][j] = g[i][j] + max(dp3[i + 1][j], dp3[i][j - 1])
for j in range(m - 1, -1, -1):
dp4[i][j] = g[i][j] + max(dp4[i + 1][j], dp4[i][j + 1])
print(max(max(dp1[i][j - 1] + dp2[i - 1][j] + dp3[i + 1][j] + dp4[i][j + 1], dp1[i - 1][j] + dp2[i][j + 1] + dp3[i][j - 1] + dp4[i + 1][j]) for j in range(1, m - 1) for i in range(1, n - 1)))
``` | output | 1 | 55,146 | 8 | 110,293 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Summer is coming! It's time for Iahub and Iahubina to work out, as they both want to look hot at the beach. The gym where they go is a matrix a with n lines and m columns. Let number a[i][j] represents the calories burned by performing workout at the cell of gym in the i-th line and the j-th column.
Iahub starts with workout located at line 1 and column 1. He needs to finish with workout a[n][m]. After finishing workout a[i][j], he can go to workout a[i + 1][j] or a[i][j + 1]. Similarly, Iahubina starts with workout a[n][1] and she needs to finish with workout a[1][m]. After finishing workout from cell a[i][j], she goes to either a[i][j + 1] or a[i - 1][j].
There is one additional condition for their training. They have to meet in exactly one cell of gym. At that cell, none of them will work out. They will talk about fast exponentiation (pretty odd small talk) and then both of them will move to the next workout.
If a workout was done by either Iahub or Iahubina, it counts as total gain. Please plan a workout for Iahub and Iahubina such as total gain to be as big as possible. Note, that Iahub and Iahubina can perform workouts with different speed, so the number of cells that they use to reach meet cell may differs.
Input
The first line of the input contains two integers n and m (3 ≤ n, m ≤ 1000). Each of the next n lines contains m integers: j-th number from i-th line denotes element a[i][j] (0 ≤ a[i][j] ≤ 105).
Output
The output contains a single number — the maximum total gain possible.
Examples
Input
3 3
100 100 100
100 1 100
100 100 100
Output
800
Note
Iahub will choose exercises a[1][1] → a[1][2] → a[2][2] → a[3][2] → a[3][3]. Iahubina will choose exercises a[3][1] → a[2][1] → a[2][2] → a[2][3] → a[1][3]. | instruction | 0 | 55,147 | 8 | 110,294 |
Tags: dp
Correct Solution:
```
# -*- coding:utf-8 -*-
"""
created by shuangquan.huang at 1/7/20
"""
import collections
import time
import os
import sys
import bisect
import heapq
from typing import List
def solve(N, M, A):
dpa = [[0 for _ in range(M+2)] for _ in range(N+2)]
dpb = [[0 for _ in range(M+2)] for _ in range(N+2)]
dpc = [[0 for _ in range(M+2)] for _ in range(N+2)]
dpd = [[0 for _ in range(M+2)] for _ in range(N+2)]
for r in range(1, N+1):
for c in range(1, M + 1):
dpa[r][c] = max(dpa[r-1][c], dpa[r][c-1]) + A[r][c]
for r in range(N, 0, -1):
for c in range(M, 0, -1):
dpb[r][c] = max(dpb[r+1][c], dpb[r][c+1]) + A[r][c]
for r in range(N, 0, -1):
for c in range(1, M+1):
dpc[r][c] = max(dpc[r+1][c], dpc[r][c-1]) + A[r][c]
for r in range(1, N+1):
for c in range(M, 0, -1):
dpd[r][c] = max(dpd[r-1][c], dpd[r][c+1]) + A[r][c]
ans = 0
for r in range(2, N):
for c in range(2, M):
a = dpa[r][c-1] + dpb[r][c+1] + dpc[r+1][c] + dpd[r-1][c]
b = dpc[r][c-1] + dpd[r][c+1] + dpa[r-1][c] + dpb[r+1][c]
ans = max(ans, a, b)
return ans
N, M = map(int, input().split())
A = [[0 for _ in range(M+2)]]
for i in range(N):
row = [0] + [int(x) for x in input().split()] + [0]
A.append(row)
A.append([0 for _ in range(M+2)])
print(solve(N, M, A))
``` | output | 1 | 55,147 | 8 | 110,295 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Summer is coming! It's time for Iahub and Iahubina to work out, as they both want to look hot at the beach. The gym where they go is a matrix a with n lines and m columns. Let number a[i][j] represents the calories burned by performing workout at the cell of gym in the i-th line and the j-th column.
Iahub starts with workout located at line 1 and column 1. He needs to finish with workout a[n][m]. After finishing workout a[i][j], he can go to workout a[i + 1][j] or a[i][j + 1]. Similarly, Iahubina starts with workout a[n][1] and she needs to finish with workout a[1][m]. After finishing workout from cell a[i][j], she goes to either a[i][j + 1] or a[i - 1][j].
There is one additional condition for their training. They have to meet in exactly one cell of gym. At that cell, none of them will work out. They will talk about fast exponentiation (pretty odd small talk) and then both of them will move to the next workout.
If a workout was done by either Iahub or Iahubina, it counts as total gain. Please plan a workout for Iahub and Iahubina such as total gain to be as big as possible. Note, that Iahub and Iahubina can perform workouts with different speed, so the number of cells that they use to reach meet cell may differs.
Input
The first line of the input contains two integers n and m (3 ≤ n, m ≤ 1000). Each of the next n lines contains m integers: j-th number from i-th line denotes element a[i][j] (0 ≤ a[i][j] ≤ 105).
Output
The output contains a single number — the maximum total gain possible.
Examples
Input
3 3
100 100 100
100 1 100
100 100 100
Output
800
Note
Iahub will choose exercises a[1][1] → a[1][2] → a[2][2] → a[3][2] → a[3][3]. Iahubina will choose exercises a[3][1] → a[2][1] → a[2][2] → a[2][3] → a[1][3]. | instruction | 0 | 55,148 | 8 | 110,296 |
Tags: dp
Correct Solution:
```
n,m=map(int,input().split())
a=[]
for i in range(n):a.append(list(map(int,input().split())))
dpa=[[[0,0] for i in range(m+2)] for i in range(n+2)]
dpb=[[[0,0] for i in range(m+2)] for i in range(n+2)]
ans=0
for i in range(1,n+1):
for j in range(1,m+1):
dpa[i][j][0]=max(dpa[i-1][j][0],dpa[i][j-1][0])+a[i-1][j-1]
dpa[n+1-i][m+1-j][1]=max(dpa[n+2-i][m+1-j][1],dpa[n+1-i][m+2-j][1])+a[n-i][m-j]
for i in range(n,0,-1):
for j in range(1,m+1):
dpb[i][j][0]=max(dpb[i+1][j][0],dpb[i][j-1][0])+a[i-1][j-1]
dpb[n+1-i][m+1-j][1]=max(dpb[n-i][m+1-j][1],dpb[n+1-i][m+2-j][1])+a[n-i][m-j]
for i in range(2,n):
for j in range(2,m):
x=dpa[i-1][j][0]+dpa[i+1][j][1]+dpb[i][j-1][0]+dpb[i][j+1][1]
y=dpb[i+1][j][0]+dpb[i-1][j][1]+dpa[i][j-1][0]+dpa[i][j+1][1]
ans=max(ans,x,y)
print(ans)
``` | output | 1 | 55,148 | 8 | 110,297 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Summer is coming! It's time for Iahub and Iahubina to work out, as they both want to look hot at the beach. The gym where they go is a matrix a with n lines and m columns. Let number a[i][j] represents the calories burned by performing workout at the cell of gym in the i-th line and the j-th column.
Iahub starts with workout located at line 1 and column 1. He needs to finish with workout a[n][m]. After finishing workout a[i][j], he can go to workout a[i + 1][j] or a[i][j + 1]. Similarly, Iahubina starts with workout a[n][1] and she needs to finish with workout a[1][m]. After finishing workout from cell a[i][j], she goes to either a[i][j + 1] or a[i - 1][j].
There is one additional condition for their training. They have to meet in exactly one cell of gym. At that cell, none of them will work out. They will talk about fast exponentiation (pretty odd small talk) and then both of them will move to the next workout.
If a workout was done by either Iahub or Iahubina, it counts as total gain. Please plan a workout for Iahub and Iahubina such as total gain to be as big as possible. Note, that Iahub and Iahubina can perform workouts with different speed, so the number of cells that they use to reach meet cell may differs.
Input
The first line of the input contains two integers n and m (3 ≤ n, m ≤ 1000). Each of the next n lines contains m integers: j-th number from i-th line denotes element a[i][j] (0 ≤ a[i][j] ≤ 105).
Output
The output contains a single number — the maximum total gain possible.
Examples
Input
3 3
100 100 100
100 1 100
100 100 100
Output
800
Note
Iahub will choose exercises a[1][1] → a[1][2] → a[2][2] → a[3][2] → a[3][3]. Iahubina will choose exercises a[3][1] → a[2][1] → a[2][2] → a[2][3] → a[1][3]. | instruction | 0 | 55,149 | 8 | 110,298 |
Tags: dp
Correct Solution:
```
n, m = map(int, input().strip().split())
dp1, dp2, dp3, dp4 = [[[0 for i in range(m+1)] for i in range(n+1)] for i in range(4)]
# print(dp1)
# print(dp2)
# print(dp3)
# print(dp4)
a = []
for i in range(n):
a.append(list(map(int, input().strip().split())))
for i in range(n):
for j in range(m):
dp1[i][j] = a[i][j] + max(dp1[i-1][j], dp1[i][j-1])
for i in range(n-1, -1, -1):
for j in range(m-1, -1, -1):
dp2[i][j] = a[i][j] + max(dp2[i+1][j], dp2[i][j+1])
for i in range(n-1, -1, -1):
for j in range(m):
dp3[i][j] = a[i][j] + max(dp3[i+1][j], dp3[i][j-1])
for i in range(n):
for j in range(m-1, -1, -1):
dp4[i][j] = a[i][j] + max(dp4[i-1][j], dp4[i][j+1])
# print("#############")
# for i in dp1:
# print(i)
# print("-----------")
# for i in dp2:
# print(i)
# print("-----------")
# for i in dp3:
# print(i)
# print("-----------")
# for i in dp4:
# print(i)
# print("#############")
ans = 0
for i in range(1,n-1):
for j in range(1, m-1):
ans = max(ans, dp1[i][j-1] + dp2[i][j+1] + dp3[i+1][j] + dp4[i-1][j], dp3[i][j-1] + dp4[i][j+1] + dp1[i-1][j] + dp2[i+1][j])
# print(dp1[i][j-1],dp2[i][j+1], dp3[i+1][j], dp4[i-1][j], dp3[i][j-1], dp4[i][j+1], dp1[i+1][j], dp2[i-1][j])
print(ans)
``` | output | 1 | 55,149 | 8 | 110,299 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Summer is coming! It's time for Iahub and Iahubina to work out, as they both want to look hot at the beach. The gym where they go is a matrix a with n lines and m columns. Let number a[i][j] represents the calories burned by performing workout at the cell of gym in the i-th line and the j-th column.
Iahub starts with workout located at line 1 and column 1. He needs to finish with workout a[n][m]. After finishing workout a[i][j], he can go to workout a[i + 1][j] or a[i][j + 1]. Similarly, Iahubina starts with workout a[n][1] and she needs to finish with workout a[1][m]. After finishing workout from cell a[i][j], she goes to either a[i][j + 1] or a[i - 1][j].
There is one additional condition for their training. They have to meet in exactly one cell of gym. At that cell, none of them will work out. They will talk about fast exponentiation (pretty odd small talk) and then both of them will move to the next workout.
If a workout was done by either Iahub or Iahubina, it counts as total gain. Please plan a workout for Iahub and Iahubina such as total gain to be as big as possible. Note, that Iahub and Iahubina can perform workouts with different speed, so the number of cells that they use to reach meet cell may differs.
Input
The first line of the input contains two integers n and m (3 ≤ n, m ≤ 1000). Each of the next n lines contains m integers: j-th number from i-th line denotes element a[i][j] (0 ≤ a[i][j] ≤ 105).
Output
The output contains a single number — the maximum total gain possible.
Examples
Input
3 3
100 100 100
100 1 100
100 100 100
Output
800
Note
Iahub will choose exercises a[1][1] → a[1][2] → a[2][2] → a[3][2] → a[3][3]. Iahubina will choose exercises a[3][1] → a[2][1] → a[2][2] → a[2][3] → a[1][3]. | instruction | 0 | 55,150 | 8 | 110,300 |
Tags: dp
Correct Solution:
```
# by the authority of GOD author: manhar singh sachdev #
import os,sys
from io import BytesIO, IOBase
def main():
n,m = map(int,input().split())
arr = [list(map(int,input().split())) for _ in range(n)]
dp1 = [[0]*(m+2) for _ in range(n+2)]
for i in range(1,n+1):
for j in range(1,m+1):
dp1[i][j] = max(dp1[i-1][j],dp1[i][j-1])+arr[i-1][j-1]
dp2 = [[0]*(m+2) for _ in range(n+2)]
for i in range(1,n+1):
for j in range(m,0,-1):
dp2[i][j] = max(dp2[i-1][j],dp2[i][j+1])+arr[i-1][j-1]
dp3 = [[0]*(m+2) for _ in range(n+2)]
for i in range(n,0,-1):
for j in range(m,0,-1):
dp3[i][j] = max(dp3[i+1][j],dp3[i][j+1])+arr[i-1][j-1]
dp4 = [[0]*(m+2) for _ in range(n+2)]
for i in range(n,0,-1):
for j in range(1,m+1):
dp4[i][j] = max(dp4[i+1][j],dp4[i][j-1])+arr[i-1][j-1]
maxi = 0
for i in range(2,n):
for j in range(2,m):
maxi = max(maxi,
dp1[i][j-1]+dp4[i+1][j]+dp2[i-1][j]+dp3[i][j+1],
dp1[i-1][j]+dp4[i][j-1]+dp2[i][j+1]+dp3[i+1][j]
)
print(maxi)
#Fast IO Region
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
if __name__ == '__main__':
main()
``` | output | 1 | 55,150 | 8 | 110,301 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Summer is coming! It's time for Iahub and Iahubina to work out, as they both want to look hot at the beach. The gym where they go is a matrix a with n lines and m columns. Let number a[i][j] represents the calories burned by performing workout at the cell of gym in the i-th line and the j-th column.
Iahub starts with workout located at line 1 and column 1. He needs to finish with workout a[n][m]. After finishing workout a[i][j], he can go to workout a[i + 1][j] or a[i][j + 1]. Similarly, Iahubina starts with workout a[n][1] and she needs to finish with workout a[1][m]. After finishing workout from cell a[i][j], she goes to either a[i][j + 1] or a[i - 1][j].
There is one additional condition for their training. They have to meet in exactly one cell of gym. At that cell, none of them will work out. They will talk about fast exponentiation (pretty odd small talk) and then both of them will move to the next workout.
If a workout was done by either Iahub or Iahubina, it counts as total gain. Please plan a workout for Iahub and Iahubina such as total gain to be as big as possible. Note, that Iahub and Iahubina can perform workouts with different speed, so the number of cells that they use to reach meet cell may differs.
Input
The first line of the input contains two integers n and m (3 ≤ n, m ≤ 1000). Each of the next n lines contains m integers: j-th number from i-th line denotes element a[i][j] (0 ≤ a[i][j] ≤ 105).
Output
The output contains a single number — the maximum total gain possible.
Examples
Input
3 3
100 100 100
100 1 100
100 100 100
Output
800
Note
Iahub will choose exercises a[1][1] → a[1][2] → a[2][2] → a[3][2] → a[3][3]. Iahubina will choose exercises a[3][1] → a[2][1] → a[2][2] → a[2][3] → a[1][3]. | instruction | 0 | 55,151 | 8 | 110,302 |
Tags: dp
Correct Solution:
```
n, m = map(int, input().split())
gym = [[0 for i in range(m+1)]]
for row in range(n):
gym.append([0] + list(map(int, input().split())))
bToMid = [[0 for i in range(m+2)] for j in range(n+2)]
for i in range(1, n+1):
for j in range(1, m+1):
bToMid[i][j] = gym[i][j] + max(bToMid[i-1][j], bToMid[i][j-1])
bToEnd = [[0 for i in range(m+2)] for j in range(n+2)]
for i in range(n, 0, -1):
for j in range(m, 0, -1):
bToEnd[i][j] = gym[i][j] + max(bToEnd[i+1][j], bToEnd[i][j+1])
aToMid = [[0 for i in range(m+2)] for j in range(n+2)]
for i in range(n, 0, -1):
for j in range(1, m+1):
aToMid[i][j] = gym[i][j] + max(aToMid[i+1][j], aToMid[i][j-1])
aToEnd = [[0 for i in range(m+2)] for j in range(n+2)]
for i in range(1, n+1):
for j in range(m, 0, -1):
aToEnd[i][j] = gym[i][j] + max(aToEnd[i-1][j], aToEnd[i][j+1])
#print(bToMid[1][2], bToEnd[3][2], aToMid[2][1], aToEnd[2][3])
best = 0
bestIJ = ()
for i in range(2, n):
for j in range(2, m):
best = max(best, bToMid[i][j-1]+bToEnd[i][j+1]+aToMid[i+1][j]+aToEnd[i-1][j])
best = max(best, bToMid[i-1][j]+bToEnd[i+1][j]+aToMid[i][j-1]+aToEnd[i][j+1])
bestIJ = (i, j)
print(best)
#print(bestIJ)
``` | output | 1 | 55,151 | 8 | 110,303 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Summer is coming! It's time for Iahub and Iahubina to work out, as they both want to look hot at the beach. The gym where they go is a matrix a with n lines and m columns. Let number a[i][j] represents the calories burned by performing workout at the cell of gym in the i-th line and the j-th column.
Iahub starts with workout located at line 1 and column 1. He needs to finish with workout a[n][m]. After finishing workout a[i][j], he can go to workout a[i + 1][j] or a[i][j + 1]. Similarly, Iahubina starts with workout a[n][1] and she needs to finish with workout a[1][m]. After finishing workout from cell a[i][j], she goes to either a[i][j + 1] or a[i - 1][j].
There is one additional condition for their training. They have to meet in exactly one cell of gym. At that cell, none of them will work out. They will talk about fast exponentiation (pretty odd small talk) and then both of them will move to the next workout.
If a workout was done by either Iahub or Iahubina, it counts as total gain. Please plan a workout for Iahub and Iahubina such as total gain to be as big as possible. Note, that Iahub and Iahubina can perform workouts with different speed, so the number of cells that they use to reach meet cell may differs.
Input
The first line of the input contains two integers n and m (3 ≤ n, m ≤ 1000). Each of the next n lines contains m integers: j-th number from i-th line denotes element a[i][j] (0 ≤ a[i][j] ≤ 105).
Output
The output contains a single number — the maximum total gain possible.
Examples
Input
3 3
100 100 100
100 1 100
100 100 100
Output
800
Note
Iahub will choose exercises a[1][1] → a[1][2] → a[2][2] → a[3][2] → a[3][3]. Iahubina will choose exercises a[3][1] → a[2][1] → a[2][2] → a[2][3] → a[1][3]. | instruction | 0 | 55,152 | 8 | 110,304 |
Tags: dp
Correct Solution:
```
from sys import maxsize, stdout, stdin,stderr
mod = int(1e9+7)
import sys
def I(): return int(stdin.readline())
def lint(): return [int(x) for x in stdin.readline().split()]
def S(): return input().strip()
def grid(r, c): return [lint() for i in range(r)]
from collections import defaultdict, Counter, deque
import math
import heapq
from heapq import heappop , heappush
import bisect
from itertools import groupby
def gcd(a,b):
while b:
a %= b
tmp = a
a = b
b = tmp
return a
def lcm(a,b):
return a // gcd(a, b) * b
def check_prime(n):
for i in range(2, int(n ** (1 / 2)) + 1):
if not n % i:
return False
return True
def Bs(a, x):
i=0
j=0
left = 1
right = x
flag=False
while left<right:
mi = (left+right)//2
#print(smi,a[mi],x)
if a[mi]<=x:
left = mi+1
i+=1
else:
right = mi
j+=1
#print(left,right,"----")
#print(i-1,j)
if left>0 and a[left-1]==x:
return i-1, j
else:
return -1, -1
def nCr(n, r):
return (fact(n) // (fact(r)
* fact(n - r)))
# Returns factorial of n
def fact(n):
res = 1
for i in range(2, n+1):
res = res * i
return res
def primefactors(n):
num=0
while n % 2 == 0:
num+=1
n = n / 2
for i in range(3,int(math.sqrt(n))+1,2):
while n % i== 0:
num+=1
n = n // i
if n > 2:
num+=1
return num
'''
def iter_ds(src):
store=[src]
while len(store):
tmp=store.pop()
if not vis[tmp]:
vis[tmp]=True
for j in ar[tmp]:
store.append(j)
'''
def ask(a):
print('? {}'.format(a),flush=True)
n=I()
return n
def dfs(i,p):
a,tmp=0,0
for j in d[i]:
if j!=p:
a+=1
tmp+=dfs(j,i)
if a==0:
return 0
return tmp/a + 1
def primeFactors(n):
l=[]
while n % 2 == 0:
l.append(2)
n = n // 2
if n > 2:
l.append(n)
return l
n,m=lint()
a=[]
dp1=[[0]*(m+2) for _ in range(n+2)]
dp2=[[0]*(m+2) for _ in range(n+2)]
dp3=[[0]*(m+2) for _ in range(n+2)]
dp4=[[0]*(m+2) for _ in range(n+2)]
ans=0
for i in range(n):
a.append(lint())
for i in range(1,n+1):
for j in range(1,m+1):
dp1[i][j]=a[i-1][j-1]+max(dp1[i-1][j],dp1[i][j-1])
for i in range(n,0,-1):
for j in range(1,m+1):
dp2[i][j]=a[i-1][j-1]+max(dp2[i+1][j],dp2[i][j-1])
for i in range(1,n+1):
for j in range(m,0,-1):
dp3[i][j]=a[i-1][j-1]+max(dp3[i-1][j],dp3[i][j+1])
for i in range(n,0,-1):
for j in range(m,0,-1):
dp4[i][j]=a[i-1][j-1]+max(dp4[i+1][j],dp4[i][j+1])
for i in range(2,n):
for j in range(2,m):
tm=dp1[i-1][j]+dp2[i][j-1]+dp3[i][j+1]+dp4[i+1][j]
pm=dp1[i][j-1]+dp2[i+1][j]+dp3[i-1][j]+dp4[i][j+1]
ans=max(ans,max(tm,pm))
'''
for i in range(n+2):
print(*dp1[i])
print('--------------------------')
for i in range(n+2):
print(*dp2[i])
print('--------------------------')
for i in range(n+2):
print(*dp3[i])
print('--------------------------')
for i in range(n+2):
print(*dp4[i])
print('--------------------------')
'''
print(ans)
``` | output | 1 | 55,152 | 8 | 110,305 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Summer is coming! It's time for Iahub and Iahubina to work out, as they both want to look hot at the beach. The gym where they go is a matrix a with n lines and m columns. Let number a[i][j] represents the calories burned by performing workout at the cell of gym in the i-th line and the j-th column.
Iahub starts with workout located at line 1 and column 1. He needs to finish with workout a[n][m]. After finishing workout a[i][j], he can go to workout a[i + 1][j] or a[i][j + 1]. Similarly, Iahubina starts with workout a[n][1] and she needs to finish with workout a[1][m]. After finishing workout from cell a[i][j], she goes to either a[i][j + 1] or a[i - 1][j].
There is one additional condition for their training. They have to meet in exactly one cell of gym. At that cell, none of them will work out. They will talk about fast exponentiation (pretty odd small talk) and then both of them will move to the next workout.
If a workout was done by either Iahub or Iahubina, it counts as total gain. Please plan a workout for Iahub and Iahubina such as total gain to be as big as possible. Note, that Iahub and Iahubina can perform workouts with different speed, so the number of cells that they use to reach meet cell may differs.
Input
The first line of the input contains two integers n and m (3 ≤ n, m ≤ 1000). Each of the next n lines contains m integers: j-th number from i-th line denotes element a[i][j] (0 ≤ a[i][j] ≤ 105).
Output
The output contains a single number — the maximum total gain possible.
Examples
Input
3 3
100 100 100
100 1 100
100 100 100
Output
800
Note
Iahub will choose exercises a[1][1] → a[1][2] → a[2][2] → a[3][2] → a[3][3]. Iahubina will choose exercises a[3][1] → a[2][1] → a[2][2] → a[2][3] → a[1][3].
Submitted Solution:
```
'''input
3 3
100 100 100
100 1 100
100 100 100
'''
# again a coding delight
from sys import stdin
def create_dp1(matrix, n, m):
dp = [[0 for i in range(m)] for j in range(n)]
for i in range(n):
for j in range(m):
if i - 1 >= 0:
dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i - 1][j])
if j - 1 >= 0:
dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i][j - 1])
elif i - 1 < 0 and j - 1 < 0:
dp[i][j] = matrix[i][j]
return dp
def create_dp2(matrix, n, m):
dp = [[0 for i in range(m)] for j in range(n)]
for i in range(n - 1, -1, -1):
for j in range(m - 1, -1, -1):
if i + 1 < n:
dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i + 1][j])
if j + 1 < m:
dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i][j + 1])
if i + 1 >= n and j + 1 >= m:
dp[i][j] = matrix[i][j]
return dp
def create_dp3(matrix, n, m):
dp = [[0 for i in range(m)] for j in range(n)]
for i in range(n - 1, -1, -1):
for j in range(m):
if i + 1 < n:
dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i + 1][j])
if j - 1 >= 0:
dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i][j - 1])
if i + 1 >= n and j - 1 < 0:
dp[i][j] = matrix[i][j]
return dp
def create_dp4(matrix, n, m):
dp = [[0 for i in range(m)] for j in range(n)]
for i in range(n):
for j in range(m - 1, -1, -1):
if i - 1 >= 0:
dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i - 1][j])
if j + 1 < m:
dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i][j + 1])
if i - 1 < 0 and j + 1 >= m:
dp[i][j] = matrix[i][j]
return dp
# main starts
n, m = list(map(int, stdin.readline().split()))
matrix = []
for _ in range(n):
matrix.append(list(map(int, stdin.readline().split())))
dp1 = create_dp1(matrix, n, m) # from 0, 0 to i, j
dp2 = create_dp2(matrix, n, m) # from i, j to n, m
dp3 = create_dp3(matrix, n, m) # from n, 1 to i, j
dp4 = create_dp4(matrix, n, m) # from i, j to 1, m
total = -float('inf')
for i in range(1, n - 1):
for j in range(1, m - 1):
first = dp1[i - 1][j] + dp2[i + 1][j] + dp3[i][j - 1] + dp4[i][j + 1]
second = dp1[i][j - 1] + dp2[i][j + 1] + dp3[i + 1][j] + dp4[i - 1][j]
total = max(total, first, second)
print(total)
``` | instruction | 0 | 55,153 | 8 | 110,306 |
Yes | output | 1 | 55,153 | 8 | 110,307 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Summer is coming! It's time for Iahub and Iahubina to work out, as they both want to look hot at the beach. The gym where they go is a matrix a with n lines and m columns. Let number a[i][j] represents the calories burned by performing workout at the cell of gym in the i-th line and the j-th column.
Iahub starts with workout located at line 1 and column 1. He needs to finish with workout a[n][m]. After finishing workout a[i][j], he can go to workout a[i + 1][j] or a[i][j + 1]. Similarly, Iahubina starts with workout a[n][1] and she needs to finish with workout a[1][m]. After finishing workout from cell a[i][j], she goes to either a[i][j + 1] or a[i - 1][j].
There is one additional condition for their training. They have to meet in exactly one cell of gym. At that cell, none of them will work out. They will talk about fast exponentiation (pretty odd small talk) and then both of them will move to the next workout.
If a workout was done by either Iahub or Iahubina, it counts as total gain. Please plan a workout for Iahub and Iahubina such as total gain to be as big as possible. Note, that Iahub and Iahubina can perform workouts with different speed, so the number of cells that they use to reach meet cell may differs.
Input
The first line of the input contains two integers n and m (3 ≤ n, m ≤ 1000). Each of the next n lines contains m integers: j-th number from i-th line denotes element a[i][j] (0 ≤ a[i][j] ≤ 105).
Output
The output contains a single number — the maximum total gain possible.
Examples
Input
3 3
100 100 100
100 1 100
100 100 100
Output
800
Note
Iahub will choose exercises a[1][1] → a[1][2] → a[2][2] → a[3][2] → a[3][3]. Iahubina will choose exercises a[3][1] → a[2][1] → a[2][2] → a[2][3] → a[1][3].
Submitted Solution:
```
from collections import defaultdict
def solve():
n,m = map(int,input().split())
la = []
for i in range(n):
z = list(map(int,input().split()))
la.append(z)
dp1, dp2, dp3, dp4 = [[[0 for i in range(m+1)] for i in range(n+1)] for i in range(4)]
for i in range(n):
for j in range(m):
dp1[i][j] = la[i][j]
z1,z2 = 0,0
if i-1>=0:
z1 = dp1[i-1][j]
if j-1>=0:
z2 = dp1[i][j-1]
dp1[i][j]+=max(z1,z2)
for i in range(n-1,-1,-1):
for j in range(m):
dp2[i][j] = la[i][j]
z1,z2 = 0,0
if i+1<n:
z1 = dp2[i+1][j]
if j-1>=0:
z2 = dp2[i][j-1]
dp2[i][j]+=max(z1,z2)
for i in range(n-1,-1,-1):
for j in range(m-1,-1,-1):
dp3[i][j] = la[i][j]
z1,z2 = 0,0
if i+1<n:
z1 = dp3[i+1][j]
if j+1<m:
z2 = dp3[i][j+1]
dp3[i][j]+=max(z1,z2)
for i in range(n):
for j in range(m-1,-1,-1):
dp4[i][j] = la[i][j]
z1,z2 = 0,0
if i-1>=0:
z1 = dp4[i-1][j]
if j+1<m:
z2 = dp4[i][j+1]
dp4[i][j]+=max(z1,z2)
ans = 0
# print(dp1)
# print(dp2)
for i in range(1,n-1):
for j in range(1,m-1):
z1,z2,z3,z4 = dp1[i][j-1],dp2[i+1][j],dp3[i][j+1],dp4[i-1][j]
ans = max(z1+z2+z3+z4,ans)
z1,z2,z3,z4 = dp1[i-1][j],dp2[i][j-1],dp3[i+1][j],dp4[i][j+1]
ans = max(z1+z2+z3+z4,ans)
# print(ans)
print(ans)
# t = int(stdin.readline())
# for _ in range(t):
solve()
``` | instruction | 0 | 55,154 | 8 | 110,308 |
Yes | output | 1 | 55,154 | 8 | 110,309 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Summer is coming! It's time for Iahub and Iahubina to work out, as they both want to look hot at the beach. The gym where they go is a matrix a with n lines and m columns. Let number a[i][j] represents the calories burned by performing workout at the cell of gym in the i-th line and the j-th column.
Iahub starts with workout located at line 1 and column 1. He needs to finish with workout a[n][m]. After finishing workout a[i][j], he can go to workout a[i + 1][j] or a[i][j + 1]. Similarly, Iahubina starts with workout a[n][1] and she needs to finish with workout a[1][m]. After finishing workout from cell a[i][j], she goes to either a[i][j + 1] or a[i - 1][j].
There is one additional condition for their training. They have to meet in exactly one cell of gym. At that cell, none of them will work out. They will talk about fast exponentiation (pretty odd small talk) and then both of them will move to the next workout.
If a workout was done by either Iahub or Iahubina, it counts as total gain. Please plan a workout for Iahub and Iahubina such as total gain to be as big as possible. Note, that Iahub and Iahubina can perform workouts with different speed, so the number of cells that they use to reach meet cell may differs.
Input
The first line of the input contains two integers n and m (3 ≤ n, m ≤ 1000). Each of the next n lines contains m integers: j-th number from i-th line denotes element a[i][j] (0 ≤ a[i][j] ≤ 105).
Output
The output contains a single number — the maximum total gain possible.
Examples
Input
3 3
100 100 100
100 1 100
100 100 100
Output
800
Note
Iahub will choose exercises a[1][1] → a[1][2] → a[2][2] → a[3][2] → a[3][3]. Iahubina will choose exercises a[3][1] → a[2][1] → a[2][2] → a[2][3] → a[1][3].
Submitted Solution:
```
"""
Author - Satwik Tiwari .
15th Dec , 2020 - Tuesday
"""
#===============================================================================================
#importing some useful libraries.
from __future__ import division, print_function
from fractions import Fraction
import sys
import os
from io import BytesIO, IOBase
from functools import cmp_to_key
# from itertools import *
from heapq import *
from math import gcd, factorial,floor,ceil,sqrt
from copy import deepcopy
from collections import deque
from bisect import bisect_left as bl
from bisect import bisect_right as br
from bisect import bisect
#==============================================================================================
#fast I/O region
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
if sys.version_info[0] < 3:
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
# inp = lambda: sys.stdin.readline().rstrip("\r\n")
#===============================================================================================
### START ITERATE RECURSION ###
from types import GeneratorType
def iterative(f, stack=[]):
def wrapped_func(*args, **kwargs):
if stack: return f(*args, **kwargs)
to = f(*args, **kwargs)
while True:
if type(to) is GeneratorType:
stack.append(to)
to = next(to)
continue
stack.pop()
if not stack: break
to = stack[-1].send(to)
return to
return wrapped_func
#### END ITERATE RECURSION ####
#===============================================================================================
#some shortcuts
def inp(): return sys.stdin.readline().rstrip("\r\n") #for fast input
def out(var): sys.stdout.write(str(var)) #for fast output, always take string
def lis(): return list(map(int, inp().split()))
def stringlis(): return list(map(str, inp().split()))
def sep(): return map(int, inp().split())
def strsep(): return map(str, inp().split())
# def graph(vertex): return [[] for i in range(0,vertex+1)]
def testcase(t):
for pp in range(t):
solve(pp)
def google(p):
print('Case #'+str(p)+': ',end='')
def lcm(a,b): return (a*b)//gcd(a,b)
def power(x, y, p) :
y%=(p-1) #not so sure about this. used when y>p-1. if p is prime.
res = 1 # Initialize result
x = x % p # Update x if it is more , than or equal to p
if (x == 0) :
return 0
while (y > 0) :
if ((y & 1) == 1) : # If y is odd, multiply, x with result
res = (res * x) % p
y = y >> 1 # y = y/2
x = (x * x) % p
return res
def ncr(n,r): return factorial(n) // (factorial(r) * factorial(max(n - r, 1)))
def isPrime(n) :
if (n <= 1) : return False
if (n <= 3) : return True
if (n % 2 == 0 or n % 3 == 0) : return False
i = 5
while(i * i <= n) :
if (n % i == 0 or n % (i + 2) == 0) :
return False
i = i + 6
return True
inf = pow(10,20)
mod = 10**9+7
#===============================================================================================
# code here ;))
def safe(x,y):
global n,m
return (0<=x<n and 0<=y<m)
def solve(case):
global n,m
n,m = sep()
g = []
for i in range(n):
tmep = lis()
g.append(tmep)
dp1 = [[0]*(m) for i in range(n)]
dp2 = [[0]*(m) for i in range(n)]
dp3 = [[0]*(m) for i in range(n)]
dp4 = [[0]*(m) for i in range(n)]
dp1[0][0] = g[0][0]
for i in range(n):
for j in range(m):
if(i == 0 and j==0):
continue
dp1[i][j] = g[i][j]
if(safe(i-1,j) and safe(i,j-1)):
dp1[i][j] += max(dp1[i-1][j],dp1[i][j-1])
elif(safe(i-1,j)):
dp1[i][j] += dp1[i-1][j]
else:
dp1[i][j] += dp1[i][j-1]
for i in range(n-1,-1,-1):
for j in range(m-1,-1,-1):
if(i == n-1 and j == m-1):
dp2[i][j] = g[i][j]
continue
dp2[i][j] = g[i][j]
if(safe(i,j+1) and safe(i+1,j)):
dp2[i][j] += max(dp2[i][j+1],dp2[i+1][j])
elif(safe(i+1,j)):
dp2[i][j] += dp2[i+1][j]
else:
dp2[i][j] += dp2[i][j+1]
for i in range(n-1,-1,-1):
for j in range(m):
if(i == n-1 and j == 0):
dp3[i][j] = g[i][j]
continue
dp3[i][j] = g[i][j]
if(safe(i,j-1) and safe(i+1,j)):
dp3[i][j] += max(dp3[i][j-1],dp3[i+1][j])
elif(safe(i+1,j)):
dp3[i][j] += dp3[i+1][j]
else:
dp3[i][j] += dp3[i][j-1]
for i in range(n):
for j in range(m-1,-1,-1):
if(i == 0 and j == m-1):
dp4[i][j] = g[i][j]
continue
dp4[i][j] = g[i][j]
if(safe(i-1,j) and safe(i,j+1)):
dp4[i][j] += max(dp4[i-1][j],dp4[i][j+1])
elif(safe(i-1,j)):
dp4[i][j] += dp4[i-1][j]
else:
dp4[i][j] += dp4[i][j+1]
ans = -inf
# for i in range(n):
# print(dp1[i])
# print('==')
# for i in range(n):
# print(dp2[i])
# print('===')
# for i in range(n):
# print(dp3[i])
# print('===')
# for i in range(n):
# print(dp4[i])
# print('==')
for i in range(1,n-1):
for j in range(1,m-1):
temp = dp1[i-1][j] + dp2[i+1][j] + dp3[i][j-1] + dp4[i][j+1]
ans= max(ans,temp)
temp = dp1[i][j-1] + dp2[i][j+1] + dp3[i+1][j] + dp4[i-1][j]
ans = max(ans,temp)
print(ans)
n,m = 0,0
testcase(1)
# testcase(int(inp()))
``` | instruction | 0 | 55,155 | 8 | 110,310 |
Yes | output | 1 | 55,155 | 8 | 110,311 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Summer is coming! It's time for Iahub and Iahubina to work out, as they both want to look hot at the beach. The gym where they go is a matrix a with n lines and m columns. Let number a[i][j] represents the calories burned by performing workout at the cell of gym in the i-th line and the j-th column.
Iahub starts with workout located at line 1 and column 1. He needs to finish with workout a[n][m]. After finishing workout a[i][j], he can go to workout a[i + 1][j] or a[i][j + 1]. Similarly, Iahubina starts with workout a[n][1] and she needs to finish with workout a[1][m]. After finishing workout from cell a[i][j], she goes to either a[i][j + 1] or a[i - 1][j].
There is one additional condition for their training. They have to meet in exactly one cell of gym. At that cell, none of them will work out. They will talk about fast exponentiation (pretty odd small talk) and then both of them will move to the next workout.
If a workout was done by either Iahub or Iahubina, it counts as total gain. Please plan a workout for Iahub and Iahubina such as total gain to be as big as possible. Note, that Iahub and Iahubina can perform workouts with different speed, so the number of cells that they use to reach meet cell may differs.
Input
The first line of the input contains two integers n and m (3 ≤ n, m ≤ 1000). Each of the next n lines contains m integers: j-th number from i-th line denotes element a[i][j] (0 ≤ a[i][j] ≤ 105).
Output
The output contains a single number — the maximum total gain possible.
Examples
Input
3 3
100 100 100
100 1 100
100 100 100
Output
800
Note
Iahub will choose exercises a[1][1] → a[1][2] → a[2][2] → a[3][2] → a[3][3]. Iahubina will choose exercises a[3][1] → a[2][1] → a[2][2] → a[2][3] → a[1][3].
Submitted Solution:
```
n,m=list(map(int,input().split()))
a=[list(map(int,input().split())) for i in range(n)]
b=[[0 for j in range(m)] for i in range(n)]
b[0][0]=a[0][0]
c=[[0 for j in range(m)] for i in range(n)]
c[n-1][0]=a[n-1][0]
d=[[0 for j in range(m)] for i in range(n)]
d[0][m-1]=a[0][m-1]
e=[[0 for j in range(m)] for i in range(n)]
e[n-1][m-1]=a[n-1][m-1]
for i in range(n):
for j in range(m):
if i==0:
if j!=0:
b[i][j]=b[i][j-1]+a[i][j]
elif j==0:
b[i][j]=b[i-1][j]+a[i][j]
else:
b[i][j]=max(b[i-1][j],b[i][j-1])+a[i][j]
for i in range(n-1,-1,-1):
for j in range(m):
if i==n-1:
if j!=0:
c[i][j]=c[i][j-1]+a[i][j]
elif j==0:
c[i][j]=c[i+1][j]+a[i][j]
else:
c[i][j]=max(c[i+1][j],c[i][j-1])+a[i][j]
for i in range(n):
for j in range(m-1,-1,-1):
if i==0:
if j!=m-1:
d[i][j]=d[i][j+1]+a[i][j]
elif j==m-1:
d[i][j]=d[i-1][j]+a[i][j]
else:
d[i][j]=max(d[i-1][j],d[i][j+1])+a[i][j]
for i in range(n-1,-1,-1):
for j in range(m-1,-1,-1):
if i==n-1:
if j!=m-1:
e[i][j]=e[i][j+1]+a[i][j]
elif j==m-1:
e[i][j]=e[i+1][j]+a[i][j]
else:
e[i][j]=max(e[i+1][j],e[i][j+1])+a[i][j]
f=0
for i in range(n):
for j in range(m):
g1=int(b[i][j-1] if j>0 else -1000000000000)+int(c[i+1][j] if i<n-1 else -1000000000000)+int(d[i-1][j] if i>0 else -1000000000000)+int(e[i][j+1] if j<m-1 else -1000000000000)
g2=int(b[i-1][j] if i>0 else -1000000000000)+int(c[i][j-1] if j>0 else -1000000000000)+int(d[i][j+1] if j<m-1 else -1000000000000)+int(e[i+1][j] if i<n-1 else -1000000000000)
f=max(f,g1,g2)
print(f)
``` | instruction | 0 | 55,156 | 8 | 110,312 |
Yes | output | 1 | 55,156 | 8 | 110,313 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Summer is coming! It's time for Iahub and Iahubina to work out, as they both want to look hot at the beach. The gym where they go is a matrix a with n lines and m columns. Let number a[i][j] represents the calories burned by performing workout at the cell of gym in the i-th line and the j-th column.
Iahub starts with workout located at line 1 and column 1. He needs to finish with workout a[n][m]. After finishing workout a[i][j], he can go to workout a[i + 1][j] or a[i][j + 1]. Similarly, Iahubina starts with workout a[n][1] and she needs to finish with workout a[1][m]. After finishing workout from cell a[i][j], she goes to either a[i][j + 1] or a[i - 1][j].
There is one additional condition for their training. They have to meet in exactly one cell of gym. At that cell, none of them will work out. They will talk about fast exponentiation (pretty odd small talk) and then both of them will move to the next workout.
If a workout was done by either Iahub or Iahubina, it counts as total gain. Please plan a workout for Iahub and Iahubina such as total gain to be as big as possible. Note, that Iahub and Iahubina can perform workouts with different speed, so the number of cells that they use to reach meet cell may differs.
Input
The first line of the input contains two integers n and m (3 ≤ n, m ≤ 1000). Each of the next n lines contains m integers: j-th number from i-th line denotes element a[i][j] (0 ≤ a[i][j] ≤ 105).
Output
The output contains a single number — the maximum total gain possible.
Examples
Input
3 3
100 100 100
100 1 100
100 100 100
Output
800
Note
Iahub will choose exercises a[1][1] → a[1][2] → a[2][2] → a[3][2] → a[3][3]. Iahubina will choose exercises a[3][1] → a[2][1] → a[2][2] → a[2][3] → a[1][3].
Submitted Solution:
```
"""
Author - Satwik Tiwari .
15th Dec , 2020 - Tuesday
"""
#===============================================================================================
#importing some useful libraries.
from __future__ import division, print_function
from fractions import Fraction
import sys
import os
from io import BytesIO, IOBase
from functools import cmp_to_key
# from itertools import *
from heapq import *
from math import gcd, factorial,floor,ceil,sqrt
from copy import deepcopy
from collections import deque
from bisect import bisect_left as bl
from bisect import bisect_right as br
from bisect import bisect
#==============================================================================================
#fast I/O region
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
if sys.version_info[0] < 3:
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
# inp = lambda: sys.stdin.readline().rstrip("\r\n")
#===============================================================================================
### START ITERATE RECURSION ###
from types import GeneratorType
def iterative(f, stack=[]):
def wrapped_func(*args, **kwargs):
if stack: return f(*args, **kwargs)
to = f(*args, **kwargs)
while True:
if type(to) is GeneratorType:
stack.append(to)
to = next(to)
continue
stack.pop()
if not stack: break
to = stack[-1].send(to)
return to
return wrapped_func
#### END ITERATE RECURSION ####
#===============================================================================================
#some shortcuts
def inp(): return sys.stdin.readline().rstrip("\r\n") #for fast input
def out(var): sys.stdout.write(str(var)) #for fast output, always take string
def lis(): return list(map(int, inp().split()))
def stringlis(): return list(map(str, inp().split()))
def sep(): return map(int, inp().split())
def strsep(): return map(str, inp().split())
# def graph(vertex): return [[] for i in range(0,vertex+1)]
def testcase(t):
for pp in range(t):
solve(pp)
def google(p):
print('Case #'+str(p)+': ',end='')
def lcm(a,b): return (a*b)//gcd(a,b)
def power(x, y, p) :
y%=(p-1) #not so sure about this. used when y>p-1. if p is prime.
res = 1 # Initialize result
x = x % p # Update x if it is more , than or equal to p
if (x == 0) :
return 0
while (y > 0) :
if ((y & 1) == 1) : # If y is odd, multiply, x with result
res = (res * x) % p
y = y >> 1 # y = y/2
x = (x * x) % p
return res
def ncr(n,r): return factorial(n) // (factorial(r) * factorial(max(n - r, 1)))
def isPrime(n) :
if (n <= 1) : return False
if (n <= 3) : return True
if (n % 2 == 0 or n % 3 == 0) : return False
i = 5
while(i * i <= n) :
if (n % i == 0 or n % (i + 2) == 0) :
return False
i = i + 6
return True
inf = pow(10,20)
mod = 10**9+7
#===============================================================================================
# code here ;))
def safe(x,y):
global n,m
return (0<=x<n and 0<=y<m)
def solve(case):
global n,m
n,m = sep()
g = []
for i in range(n):
tmep = lis()
g.append(tmep)
dp1 = [[0]*(m) for i in range(n)]
dp2 = [[0]*(m) for i in range(n)]
dp3 = [[0]*(m) for i in range(n)]
dp4 = [[0]*(m) for i in range(n)]
dp1[0][0] = g[0][0]
for i in range(n):
for j in range(m):
if(i == 0 and j==0):
continue
dp1[i][j] = g[i][j]
if(safe(i-1,j) and safe(i,j-1)):
dp1[i][j] += min(dp1[i-1][j],dp1[i][j-1])
elif(safe(i-1,j)):
dp1[i][j] += dp1[i-1][j]
else:
dp1[i][j] += dp1[i][j-1]
for i in range(n-1,-1,-1):
for j in range(m-1,-1,-1):
if(i == n-1 and j == m-1):
dp2[i][j] = g[i][j]
continue
dp2[i][j] = g[i][j]
if(safe(i,j+1) and safe(i+1,j)):
dp2[i][j] += min(dp2[i][j+1],dp2[i+1][j])
elif(safe(i+1,j)):
dp2[i][j] += dp2[i+1][j]
else:
dp2[i][j] += dp2[i][j+1]
for i in range(n-1,-1,-1):
for j in range(m):
if(i == n-1 and j == 0):
dp3[i][j] = g[i][j]
continue
dp3[i][j] = g[i][j]
if(safe(i,j-1) and safe(i+1,j)):
dp3[i][j] += min(dp3[i][j-1],dp3[i+1][j])
elif(safe(i+1,j)):
dp3[i][j] += dp3[i+1][j]
else:
dp3[i][j] += dp3[i][j-1]
for i in range(n):
for j in range(m-1,-1,-1):
if(i == 0 and j == m-1):
dp4[i][j] = g[i][j]
continue
dp4[i][j] = g[i][j]
if(safe(i-1,j) and safe(i,j+1)):
dp4[i][j] += min(dp4[i-1][j],dp4[i][j+1])
elif(safe(i-1,j)):
dp4[i][j]+=dp4[i-1][j]
else:
dp4[i][j] += dp4[i][j+1]
ans = -inf
# for i in range(n):
# print(dp1[i])
# print('==')
# for i in range(n):
# print(dp2[i])
# print('===')
# for i in range(n):
# print(dp3[i])
# print('===')
# for i in range(n):
# print(dp4[i])
# print('==')
for i in range(n):
for j in range(m):
temp = dp1[i][j] + dp2[i][j] - 2*g[i][j]
temp += dp3[i][j] + dp4[i][j] - 2*g[i][j]
ans= max(ans,temp)
print(ans)
n,m = 0,0
testcase(1)
# testcase(int(inp()))
``` | instruction | 0 | 55,157 | 8 | 110,314 |
No | output | 1 | 55,157 | 8 | 110,315 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Summer is coming! It's time for Iahub and Iahubina to work out, as they both want to look hot at the beach. The gym where they go is a matrix a with n lines and m columns. Let number a[i][j] represents the calories burned by performing workout at the cell of gym in the i-th line and the j-th column.
Iahub starts with workout located at line 1 and column 1. He needs to finish with workout a[n][m]. After finishing workout a[i][j], he can go to workout a[i + 1][j] or a[i][j + 1]. Similarly, Iahubina starts with workout a[n][1] and she needs to finish with workout a[1][m]. After finishing workout from cell a[i][j], she goes to either a[i][j + 1] or a[i - 1][j].
There is one additional condition for their training. They have to meet in exactly one cell of gym. At that cell, none of them will work out. They will talk about fast exponentiation (pretty odd small talk) and then both of them will move to the next workout.
If a workout was done by either Iahub or Iahubina, it counts as total gain. Please plan a workout for Iahub and Iahubina such as total gain to be as big as possible. Note, that Iahub and Iahubina can perform workouts with different speed, so the number of cells that they use to reach meet cell may differs.
Input
The first line of the input contains two integers n and m (3 ≤ n, m ≤ 1000). Each of the next n lines contains m integers: j-th number from i-th line denotes element a[i][j] (0 ≤ a[i][j] ≤ 105).
Output
The output contains a single number — the maximum total gain possible.
Examples
Input
3 3
100 100 100
100 1 100
100 100 100
Output
800
Note
Iahub will choose exercises a[1][1] → a[1][2] → a[2][2] → a[3][2] → a[3][3]. Iahubina will choose exercises a[3][1] → a[2][1] → a[2][2] → a[2][3] → a[1][3].
Submitted Solution:
```
# by the authority of GOD author: manhar singh sachdev #
import os,sys
from io import BytesIO, IOBase
def main():
n,m = map(int,input().split())
arr = [list(map(int,input().split())) for _ in range(n)]
dp1 = [[0]*(m+2) for _ in range(n+2)]
for i in range(1,n+1):
for j in range(1,m+1):
dp1[i][j] = max(dp1[i-1][j],dp1[i][j-1])+arr[i-1][j-1]
dp2 = [[0]*(m+2) for _ in range(n+2)]
for i in range(1,n+1):
for j in range(m,0,-1):
dp2[i][j] = max(dp2[i-1][j],dp2[i][j+1])+arr[i-1][j-1]
dp3 = [[0]*(m+2) for _ in range(n+2)]
for i in range(n,0,-1):
for j in range(m,0,-1):
dp3[i][j] = max(dp3[i+1][j],dp3[i][j+1])+arr[i-1][j-1]
dp4 = [[0]*(m+2) for _ in range(n+2)]
for i in range(n,0,-1):
for j in range(1,m+1):
dp4[i][j] = max(dp4[i+1][j],dp4[i][j-1])+arr[i-1][j-1]
maxi = 0
for i in range(1,n+1):
for j in range(1,m+1):
maxi = max(maxi,
dp1[i][j-1]+dp4[i+1][j]+dp2[i-1][j]+dp3[i][j+1],
dp1[i-1][j]+dp4[i][j-1]+dp2[i][j+1]+dp3[i+1][j]
)
print(maxi)
#Fast IO Region
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
if __name__ == '__main__':
main()
``` | instruction | 0 | 55,158 | 8 | 110,316 |
No | output | 1 | 55,158 | 8 | 110,317 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Summer is coming! It's time for Iahub and Iahubina to work out, as they both want to look hot at the beach. The gym where they go is a matrix a with n lines and m columns. Let number a[i][j] represents the calories burned by performing workout at the cell of gym in the i-th line and the j-th column.
Iahub starts with workout located at line 1 and column 1. He needs to finish with workout a[n][m]. After finishing workout a[i][j], he can go to workout a[i + 1][j] or a[i][j + 1]. Similarly, Iahubina starts with workout a[n][1] and she needs to finish with workout a[1][m]. After finishing workout from cell a[i][j], she goes to either a[i][j + 1] or a[i - 1][j].
There is one additional condition for their training. They have to meet in exactly one cell of gym. At that cell, none of them will work out. They will talk about fast exponentiation (pretty odd small talk) and then both of them will move to the next workout.
If a workout was done by either Iahub or Iahubina, it counts as total gain. Please plan a workout for Iahub and Iahubina such as total gain to be as big as possible. Note, that Iahub and Iahubina can perform workouts with different speed, so the number of cells that they use to reach meet cell may differs.
Input
The first line of the input contains two integers n and m (3 ≤ n, m ≤ 1000). Each of the next n lines contains m integers: j-th number from i-th line denotes element a[i][j] (0 ≤ a[i][j] ≤ 105).
Output
The output contains a single number — the maximum total gain possible.
Examples
Input
3 3
100 100 100
100 1 100
100 100 100
Output
800
Note
Iahub will choose exercises a[1][1] → a[1][2] → a[2][2] → a[3][2] → a[3][3]. Iahubina will choose exercises a[3][1] → a[2][1] → a[2][2] → a[2][3] → a[1][3].
Submitted Solution:
```
from collections import defaultdict, deque, Counter
from sys import stdin, stdout
from heapq import heappush, heappop
import math
import io
import os
import math
import bisect
#?############################################################
def isPrime(x):
for i in range(2, x):
if i*i > x:
break
if (x % i == 0):
return False
return True
#?############################################################
def ncr(n, r, p):
num = den = 1
for i in range(r):
num = (num * (n - i)) % p
den = (den * (i + 1)) % p
return (num * pow(den, p - 2, p)) % p
#?############################################################
def primeFactors(n):
l = []
while n % 2 == 0:
l.append(2)
n = n / 2
for i in range(3, int(math.sqrt(n))+1, 2):
while n % i == 0:
l.append(int(i))
n = n / i
if n > 2:
l.append(n)
return list(set(l))
#?############################################################
def power(x, y, p):
res = 1
x = x % p
if (x == 0):
return 0
while (y > 0):
if ((y & 1) == 1):
res = (res * x) % p
y = y >> 1
x = (x * x) % p
return res
#?############################################################
def sieve(n):
prime = [True for i in range(n+1)]
p = 2
while (p * p <= n):
if (prime[p] == True):
for i in range(p * p, n+1, p):
prime[i] = False
p += 1
return prime
#?############################################################
def digits(n):
c = 0
while (n > 0):
n //= 10
c += 1
return c
#?############################################################
def ceil(n, x):
if (n % x == 0):
return n//x
return n//x+1
#?############################################################
def mapin():
return map(int, input().split())
#?############################################################
# input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
# python3 15.py<in>op
n, m = mapin()
a = []
for i in range(n):
l = [int(x) for x in input().split()]
a.append(l)
dp1 = []
dp2 = []
# print(a)
for i in range(n):
dp2.append([0]*m)
dp1.append([0]*m)
dp1[0][0] = a[0][0]
dp2[n-1][0] = a[n-1][0]
for i in range(n):
for j in range(m):
if(i>=1 and j>=1):
dp1[i][j] = max(dp1[i-1][j], dp1[i][j-1])+ a[i][j]
elif(i>=1):
dp1[i][j] = dp1[i-1][j]+a[i][j]
elif(j>=1):
dp1[i][j] = dp1[i][j-1]+a[i][j]
for k in range(n):
for j in range(m):
i = n-k-1
if(i < n-1 and j>=1):
dp2[i][j] = max(dp2[i+1][j], dp2[i][j-1])+ a[i][j]
elif(i < n-1):
dp2[i][j] = dp2[i+1][j]+a[i][j]
elif(j>=1):
dp2[i][j] = dp2[i][j-1]+a[i][j]
ans = 0
for i in range(n):
for j in range(m):
ans = max(ans, dp1[i][j]+dp2[i][j])
print(ans)
``` | instruction | 0 | 55,159 | 8 | 110,318 |
No | output | 1 | 55,159 | 8 | 110,319 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Summer is coming! It's time for Iahub and Iahubina to work out, as they both want to look hot at the beach. The gym where they go is a matrix a with n lines and m columns. Let number a[i][j] represents the calories burned by performing workout at the cell of gym in the i-th line and the j-th column.
Iahub starts with workout located at line 1 and column 1. He needs to finish with workout a[n][m]. After finishing workout a[i][j], he can go to workout a[i + 1][j] or a[i][j + 1]. Similarly, Iahubina starts with workout a[n][1] and she needs to finish with workout a[1][m]. After finishing workout from cell a[i][j], she goes to either a[i][j + 1] or a[i - 1][j].
There is one additional condition for their training. They have to meet in exactly one cell of gym. At that cell, none of them will work out. They will talk about fast exponentiation (pretty odd small talk) and then both of them will move to the next workout.
If a workout was done by either Iahub or Iahubina, it counts as total gain. Please plan a workout for Iahub and Iahubina such as total gain to be as big as possible. Note, that Iahub and Iahubina can perform workouts with different speed, so the number of cells that they use to reach meet cell may differs.
Input
The first line of the input contains two integers n and m (3 ≤ n, m ≤ 1000). Each of the next n lines contains m integers: j-th number from i-th line denotes element a[i][j] (0 ≤ a[i][j] ≤ 105).
Output
The output contains a single number — the maximum total gain possible.
Examples
Input
3 3
100 100 100
100 1 100
100 100 100
Output
800
Note
Iahub will choose exercises a[1][1] → a[1][2] → a[2][2] → a[3][2] → a[3][3]. Iahubina will choose exercises a[3][1] → a[2][1] → a[2][2] → a[2][3] → a[1][3].
Submitted Solution:
```
from collections import deque, defaultdict
from math import sqrt, ceil, factorial, floor, inf, log2, sqrt
import bisect
import copy
from itertools import combinations
import sys
def get_array(): return list(map(int, sys.stdin.readline().strip().split()))
def get_ints(): return map(int, sys.stdin.readline().strip().split())
def input(): return sys.stdin.readline().strip()
arr=[]
n,m=get_ints()
for i in range(n):
a=get_array()
arr.append(a)
##starting from (1,1)
dp=[[0 for i in range(m)]for j in range(n)]
##starting from (1,n)
dp1=[[0 for i in range(m)]for j in range(n)]
dp2=[[0 for i in range(m)]for j in range(n)]
dp3=[[0 for i in range(m)]for j in range(n)]
## startin from top left
dp[0][0]=arr[0][0]
for i in range(1,m):
dp[0][i]+=dp[0][i-1]+arr[0][i]
for j in range(1,n):
dp[j][0]+=dp[j-1][0]+arr[j][0]
for i in range(1,n):
for j in range(1,m):
dp[i][j]+=max(dp[i-1][j],dp[i][j-1])+arr[i][j]
##starting from bottom left
dp1[n-1][0]=arr[n-1][0]
for i in range(1,m):
dp1[n-1][i]+=dp1[n-1][i-1]+arr[n-1][i]
for i in range(n-2,-1,-1):
dp1[i][0]+=dp1[i+1][0]+arr[i][0]
for i in range(n-2,-1,-1):
for j in range(1,m):
dp1[i][j]+=max(dp1[i+1][j],dp1[i][j-1])+arr[i][j]
##starting from bottom right(for A)
dp2[n-1][m-1]=arr[n-1][m-1]
for i in range(m-2,-1,-1):
dp2[n-1][i]+=dp2[n-1][i+1]+arr[n-1][i]
for i in range(n-2,-1,-1):
dp2[i][m-1]+=dp2[i+1][m-1]+arr[i][m-1]
for i in range(n-2,-1,-1):
for j in range(m-2,-1,-1):
dp2[i][j]=max(dp2[i+1][j],dp2[i][j+1])
dp3[0][m-1]=arr[0][m-1]
## starting from top right.(for B)
for i in range(m-2,-1,-1):
dp3[0][i]+=dp3[0][i+1]+arr[0][i]
for i in range(1,n):
dp3[i][m-1]+=dp3[i-1][m-1]+arr[i][m-1]
for i in range(1,n):
for j in range(m-2,-1,-1):
dp3[i][j]=max(dp3[i-1][j],dp3[i][j+1])+arr[i][j]
ans=-1
for i in range(n):
for j in range(m):
maxi,maxi1=-1,-1
##A top and B left
if i-1>=0 and j-1>=0 and i+1<n and j+1<m:
maxi, maxi1 = -1, -1
maxi=max(maxi,dp[i-1][j]+dp1[i][j-1])
maxi1 = max(maxi1, dp2[i + 1][j] + dp3[i][j + 1])
ans=max(ans,maxi+maxi1)
if i+1<n and j-1>=0 and j+1<m and i-1>=0:
## A left and B bottom
maxi, maxi1 = -1, -1
maxi=max(maxi,dp[i][j-1]+dp1[i+1][j])
maxi1 = max(maxi1, dp2[i][j + 1] + dp3[i - 1][j])
ans=max(ans,maxi+maxi1)
##print(i,j,maxi,maxi1)
##ans=max(ans,maxi+maxi1)
print(ans)
``` | instruction | 0 | 55,160 | 8 | 110,320 |
No | output | 1 | 55,160 | 8 | 110,321 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Several ages ago Berland was a kingdom. The King of Berland adored math. That's why, when he first visited one of his many palaces, he first of all paid attention to the floor in one hall. The floor was tiled with hexagonal tiles.
The hall also turned out hexagonal in its shape. The King walked along the perimeter of the hall and concluded that each of the six sides has a, b, c, a, b and c adjacent tiles, correspondingly.
To better visualize the situation, look at the picture showing a similar hexagon for a = 2, b = 3 and c = 4.
<image>
According to the legend, as the King of Berland obtained the values a, b and c, he almost immediately calculated the total number of tiles on the hall floor. Can you do the same?
Input
The first line contains three integers: a, b and c (2 ≤ a, b, c ≤ 1000).
Output
Print a single number — the total number of tiles on the hall floor.
Examples
Input
2 3 4
Output
18 | instruction | 0 | 55,881 | 8 | 111,762 |
Tags: implementation, math
Correct Solution:
```
a,b,c = map(int,input().split())
print(a*(2*c+a-1)+(c+a-1)*(b-a-1))
``` | output | 1 | 55,881 | 8 | 111,763 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Several ages ago Berland was a kingdom. The King of Berland adored math. That's why, when he first visited one of his many palaces, he first of all paid attention to the floor in one hall. The floor was tiled with hexagonal tiles.
The hall also turned out hexagonal in its shape. The King walked along the perimeter of the hall and concluded that each of the six sides has a, b, c, a, b and c adjacent tiles, correspondingly.
To better visualize the situation, look at the picture showing a similar hexagon for a = 2, b = 3 and c = 4.
<image>
According to the legend, as the King of Berland obtained the values a, b and c, he almost immediately calculated the total number of tiles on the hall floor. Can you do the same?
Input
The first line contains three integers: a, b and c (2 ≤ a, b, c ≤ 1000).
Output
Print a single number — the total number of tiles on the hall floor.
Examples
Input
2 3 4
Output
18 | instruction | 0 | 55,882 | 8 | 111,764 |
Tags: implementation, math
Correct Solution:
```
from sys import setrecursionlimit, exit, stdin
from math import ceil, floor, acos, pi
from string import ascii_lowercase, ascii_uppercase, digits
from fractions import gcd
from functools import reduce
import itertools
setrecursionlimit(10**7)
RI=lambda x=' ': list(map(int,input().split(x)))
RS=lambda x=' ': input().rstrip().split(x)
dX= [-1, 1, 0, 0,-1, 1,-1, 1]
dY= [ 0, 0,-1, 1, 1,-1,-1, 1]
mod=int(1e9+7)
eps=1e-6
MAX=1000
#################################################
a, b, c = RI()
print(a*b + b*c + a*c - a - b -c +1)
``` | output | 1 | 55,882 | 8 | 111,765 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Several ages ago Berland was a kingdom. The King of Berland adored math. That's why, when he first visited one of his many palaces, he first of all paid attention to the floor in one hall. The floor was tiled with hexagonal tiles.
The hall also turned out hexagonal in its shape. The King walked along the perimeter of the hall and concluded that each of the six sides has a, b, c, a, b and c adjacent tiles, correspondingly.
To better visualize the situation, look at the picture showing a similar hexagon for a = 2, b = 3 and c = 4.
<image>
According to the legend, as the King of Berland obtained the values a, b and c, he almost immediately calculated the total number of tiles on the hall floor. Can you do the same?
Input
The first line contains three integers: a, b and c (2 ≤ a, b, c ≤ 1000).
Output
Print a single number — the total number of tiles on the hall floor.
Examples
Input
2 3 4
Output
18 | instruction | 0 | 55,883 | 8 | 111,766 |
Tags: implementation, math
Correct Solution:
```
class CodeforcesTask216ASolution:
def __init__(self):
self.result = ''
self.a_b_c = []
def read_input(self):
self.a_b_c = [int(x) for x in input().split(" ")]
def process_task(self):
result = 0
a, b, c = self.a_b_c
width = a
for step in range(1, b + c):
result += width
if step < b and step < c:
width += 1
elif step >= b and step >= c:
width -= 1
self.result = str(result)
def get_result(self):
return self.result
if __name__ == "__main__":
Solution = CodeforcesTask216ASolution()
Solution.read_input()
Solution.process_task()
print(Solution.get_result())
``` | output | 1 | 55,883 | 8 | 111,767 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Several ages ago Berland was a kingdom. The King of Berland adored math. That's why, when he first visited one of his many palaces, he first of all paid attention to the floor in one hall. The floor was tiled with hexagonal tiles.
The hall also turned out hexagonal in its shape. The King walked along the perimeter of the hall and concluded that each of the six sides has a, b, c, a, b and c adjacent tiles, correspondingly.
To better visualize the situation, look at the picture showing a similar hexagon for a = 2, b = 3 and c = 4.
<image>
According to the legend, as the King of Berland obtained the values a, b and c, he almost immediately calculated the total number of tiles on the hall floor. Can you do the same?
Input
The first line contains three integers: a, b and c (2 ≤ a, b, c ≤ 1000).
Output
Print a single number — the total number of tiles on the hall floor.
Examples
Input
2 3 4
Output
18 | instruction | 0 | 55,884 | 8 | 111,768 |
Tags: implementation, math
Correct Solution:
```
import sys
a, b, c = [int(x) for x in (sys.stdin.readline()).split()]
print(b * c + (b + c - 1) * (a - 1))
``` | output | 1 | 55,884 | 8 | 111,769 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Several ages ago Berland was a kingdom. The King of Berland adored math. That's why, when he first visited one of his many palaces, he first of all paid attention to the floor in one hall. The floor was tiled with hexagonal tiles.
The hall also turned out hexagonal in its shape. The King walked along the perimeter of the hall and concluded that each of the six sides has a, b, c, a, b and c adjacent tiles, correspondingly.
To better visualize the situation, look at the picture showing a similar hexagon for a = 2, b = 3 and c = 4.
<image>
According to the legend, as the King of Berland obtained the values a, b and c, he almost immediately calculated the total number of tiles on the hall floor. Can you do the same?
Input
The first line contains three integers: a, b and c (2 ≤ a, b, c ≤ 1000).
Output
Print a single number — the total number of tiles on the hall floor.
Examples
Input
2 3 4
Output
18 | instruction | 0 | 55,885 | 8 | 111,770 |
Tags: implementation, math
Correct Solution:
```
a, b, c = map(int, input().split())
print(c * (b + a - 1) + (a - 1) * (b - 1))
``` | output | 1 | 55,885 | 8 | 111,771 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Several ages ago Berland was a kingdom. The King of Berland adored math. That's why, when he first visited one of his many palaces, he first of all paid attention to the floor in one hall. The floor was tiled with hexagonal tiles.
The hall also turned out hexagonal in its shape. The King walked along the perimeter of the hall and concluded that each of the six sides has a, b, c, a, b and c adjacent tiles, correspondingly.
To better visualize the situation, look at the picture showing a similar hexagon for a = 2, b = 3 and c = 4.
<image>
According to the legend, as the King of Berland obtained the values a, b and c, he almost immediately calculated the total number of tiles on the hall floor. Can you do the same?
Input
The first line contains three integers: a, b and c (2 ≤ a, b, c ≤ 1000).
Output
Print a single number — the total number of tiles on the hall floor.
Examples
Input
2 3 4
Output
18 | instruction | 0 | 55,886 | 8 | 111,772 |
Tags: implementation, math
Correct Solution:
```
try:
a,b,c=list(map(int,input().split(" ")))
print(a*b*c-((a-1)*(b-1)*(c-1)))
except:
pass
``` | output | 1 | 55,886 | 8 | 111,773 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Several ages ago Berland was a kingdom. The King of Berland adored math. That's why, when he first visited one of his many palaces, he first of all paid attention to the floor in one hall. The floor was tiled with hexagonal tiles.
The hall also turned out hexagonal in its shape. The King walked along the perimeter of the hall and concluded that each of the six sides has a, b, c, a, b and c adjacent tiles, correspondingly.
To better visualize the situation, look at the picture showing a similar hexagon for a = 2, b = 3 and c = 4.
<image>
According to the legend, as the King of Berland obtained the values a, b and c, he almost immediately calculated the total number of tiles on the hall floor. Can you do the same?
Input
The first line contains three integers: a, b and c (2 ≤ a, b, c ≤ 1000).
Output
Print a single number — the total number of tiles on the hall floor.
Examples
Input
2 3 4
Output
18 | instruction | 0 | 55,887 | 8 | 111,774 |
Tags: implementation, math
Correct Solution:
```
a,b,c=map(int,input().split())
f=lambda x:x*(x-1)//2
print(f(a+b+c-1)-f(a)-f(b)-f(c))
``` | output | 1 | 55,887 | 8 | 111,775 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Several ages ago Berland was a kingdom. The King of Berland adored math. That's why, when he first visited one of his many palaces, he first of all paid attention to the floor in one hall. The floor was tiled with hexagonal tiles.
The hall also turned out hexagonal in its shape. The King walked along the perimeter of the hall and concluded that each of the six sides has a, b, c, a, b and c adjacent tiles, correspondingly.
To better visualize the situation, look at the picture showing a similar hexagon for a = 2, b = 3 and c = 4.
<image>
According to the legend, as the King of Berland obtained the values a, b and c, he almost immediately calculated the total number of tiles on the hall floor. Can you do the same?
Input
The first line contains three integers: a, b and c (2 ≤ a, b, c ≤ 1000).
Output
Print a single number — the total number of tiles on the hall floor.
Examples
Input
2 3 4
Output
18 | instruction | 0 | 55,888 | 8 | 111,776 |
Tags: implementation, math
Correct Solution:
```
import sys
import math
import itertools
import collections
def getdict(n):
d = {}
if type(n) is list or type(n) is str:
for i in n:
if i in d:
d[i] += 1
else:
d[i] = 1
else:
for i in range(n):
t = ii()
if t in d:
d[t] += 1
else:
d[t] = 1
return d
def cdiv(n, k): return n // k + (n % k != 0)
def ii(): return int(input())
def mi(): return map(int, input().split())
def li(): return list(map(int, input().split()))
def lcm(a, b): return abs(a*b) // math.gcd(a, b)
def wr(arr): return ' '.join(map(str, arr))
def revn(n): return int(str(n)[::-1])
def prime(n):
if n == 2:
return True
if n % 2 == 0 or n <= 1:
return False
sqr = int(math.sqrt(n)) + 1
for d in range(3, sqr, 2):
if n % d == 0:
return False
return True
#arr =['v', '^', '>', '<']
a, b, c = sorted(mi())
print((b + a - 1) * (c + a - 1) - 2 * a * (a - 1) // 2)
``` | output | 1 | 55,888 | 8 | 111,777 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Several ages ago Berland was a kingdom. The King of Berland adored math. That's why, when he first visited one of his many palaces, he first of all paid attention to the floor in one hall. The floor was tiled with hexagonal tiles.
The hall also turned out hexagonal in its shape. The King walked along the perimeter of the hall and concluded that each of the six sides has a, b, c, a, b and c adjacent tiles, correspondingly.
To better visualize the situation, look at the picture showing a similar hexagon for a = 2, b = 3 and c = 4.
<image>
According to the legend, as the King of Berland obtained the values a, b and c, he almost immediately calculated the total number of tiles on the hall floor. Can you do the same?
Input
The first line contains three integers: a, b and c (2 ≤ a, b, c ≤ 1000).
Output
Print a single number — the total number of tiles on the hall floor.
Examples
Input
2 3 4
Output
18
Submitted Solution:
```
print(eval("int({0}[0])*int({0}[1])*int({0}[2])-(int({0}[0])-1)*(int({0}[1])-1)*(int({0}[2])-1)".format(input().split())))
``` | instruction | 0 | 55,889 | 8 | 111,778 |
Yes | output | 1 | 55,889 | 8 | 111,779 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Several ages ago Berland was a kingdom. The King of Berland adored math. That's why, when he first visited one of his many palaces, he first of all paid attention to the floor in one hall. The floor was tiled with hexagonal tiles.
The hall also turned out hexagonal in its shape. The King walked along the perimeter of the hall and concluded that each of the six sides has a, b, c, a, b and c adjacent tiles, correspondingly.
To better visualize the situation, look at the picture showing a similar hexagon for a = 2, b = 3 and c = 4.
<image>
According to the legend, as the King of Berland obtained the values a, b and c, he almost immediately calculated the total number of tiles on the hall floor. Can you do the same?
Input
The first line contains three integers: a, b and c (2 ≤ a, b, c ≤ 1000).
Output
Print a single number — the total number of tiles on the hall floor.
Examples
Input
2 3 4
Output
18
Submitted Solution:
```
#!/usr/bin/python3
def readln(): return tuple(map(int, input().split()))
abc = sorted(readln())
print((abc[1] + abc[0] - 1) * (abc[2] + abc[0] - 1) - (abc[0] - 1) * abc[0])
``` | instruction | 0 | 55,890 | 8 | 111,780 |
Yes | output | 1 | 55,890 | 8 | 111,781 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Several ages ago Berland was a kingdom. The King of Berland adored math. That's why, when he first visited one of his many palaces, he first of all paid attention to the floor in one hall. The floor was tiled with hexagonal tiles.
The hall also turned out hexagonal in its shape. The King walked along the perimeter of the hall and concluded that each of the six sides has a, b, c, a, b and c adjacent tiles, correspondingly.
To better visualize the situation, look at the picture showing a similar hexagon for a = 2, b = 3 and c = 4.
<image>
According to the legend, as the King of Berland obtained the values a, b and c, he almost immediately calculated the total number of tiles on the hall floor. Can you do the same?
Input
The first line contains three integers: a, b and c (2 ≤ a, b, c ≤ 1000).
Output
Print a single number — the total number of tiles on the hall floor.
Examples
Input
2 3 4
Output
18
Submitted Solution:
```
a,b,c = map(int,input().split())
ans = a * b + b * c + c * a - a - b - c + 1
print(ans)
``` | instruction | 0 | 55,891 | 8 | 111,782 |
Yes | output | 1 | 55,891 | 8 | 111,783 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Several ages ago Berland was a kingdom. The King of Berland adored math. That's why, when he first visited one of his many palaces, he first of all paid attention to the floor in one hall. The floor was tiled with hexagonal tiles.
The hall also turned out hexagonal in its shape. The King walked along the perimeter of the hall and concluded that each of the six sides has a, b, c, a, b and c adjacent tiles, correspondingly.
To better visualize the situation, look at the picture showing a similar hexagon for a = 2, b = 3 and c = 4.
<image>
According to the legend, as the King of Berland obtained the values a, b and c, he almost immediately calculated the total number of tiles on the hall floor. Can you do the same?
Input
The first line contains three integers: a, b and c (2 ≤ a, b, c ≤ 1000).
Output
Print a single number — the total number of tiles on the hall floor.
Examples
Input
2 3 4
Output
18
Submitted Solution:
```
'''
Created on 25.08.2012
@author: lam
'''
a, b, c = [int(x) for x in input().split()]
print(c*b + (a-1)*c + (a-1)*(b-1))
``` | instruction | 0 | 55,892 | 8 | 111,784 |
Yes | output | 1 | 55,892 | 8 | 111,785 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Several ages ago Berland was a kingdom. The King of Berland adored math. That's why, when he first visited one of his many palaces, he first of all paid attention to the floor in one hall. The floor was tiled with hexagonal tiles.
The hall also turned out hexagonal in its shape. The King walked along the perimeter of the hall and concluded that each of the six sides has a, b, c, a, b and c adjacent tiles, correspondingly.
To better visualize the situation, look at the picture showing a similar hexagon for a = 2, b = 3 and c = 4.
<image>
According to the legend, as the King of Berland obtained the values a, b and c, he almost immediately calculated the total number of tiles on the hall floor. Can you do the same?
Input
The first line contains three integers: a, b and c (2 ≤ a, b, c ≤ 1000).
Output
Print a single number — the total number of tiles on the hall floor.
Examples
Input
2 3 4
Output
18
Submitted Solution:
```
q=input().split()
a=int(q[0])
b=int(q[1])
c=int(q[2])
print((a+c)*b)
``` | instruction | 0 | 55,893 | 8 | 111,786 |
No | output | 1 | 55,893 | 8 | 111,787 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Several ages ago Berland was a kingdom. The King of Berland adored math. That's why, when he first visited one of his many palaces, he first of all paid attention to the floor in one hall. The floor was tiled with hexagonal tiles.
The hall also turned out hexagonal in its shape. The King walked along the perimeter of the hall and concluded that each of the six sides has a, b, c, a, b and c adjacent tiles, correspondingly.
To better visualize the situation, look at the picture showing a similar hexagon for a = 2, b = 3 and c = 4.
<image>
According to the legend, as the King of Berland obtained the values a, b and c, he almost immediately calculated the total number of tiles on the hall floor. Can you do the same?
Input
The first line contains three integers: a, b and c (2 ≤ a, b, c ≤ 1000).
Output
Print a single number — the total number of tiles on the hall floor.
Examples
Input
2 3 4
Output
18
Submitted Solution:
```
a,b,c = sorted(map(int,input().split()))
var = a*(2*c+a-1)
if a==b:
print(var-(a+c-1))
else:
print(var)
``` | instruction | 0 | 55,894 | 8 | 111,788 |
No | output | 1 | 55,894 | 8 | 111,789 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Several ages ago Berland was a kingdom. The King of Berland adored math. That's why, when he first visited one of his many palaces, he first of all paid attention to the floor in one hall. The floor was tiled with hexagonal tiles.
The hall also turned out hexagonal in its shape. The King walked along the perimeter of the hall and concluded that each of the six sides has a, b, c, a, b and c adjacent tiles, correspondingly.
To better visualize the situation, look at the picture showing a similar hexagon for a = 2, b = 3 and c = 4.
<image>
According to the legend, as the King of Berland obtained the values a, b and c, he almost immediately calculated the total number of tiles on the hall floor. Can you do the same?
Input
The first line contains three integers: a, b and c (2 ≤ a, b, c ≤ 1000).
Output
Print a single number — the total number of tiles on the hall floor.
Examples
Input
2 3 4
Output
18
Submitted Solution:
```
a,b,c = map(int,input().split())
print(a*b*c-a*b)
``` | instruction | 0 | 55,895 | 8 | 111,790 |
No | output | 1 | 55,895 | 8 | 111,791 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Several ages ago Berland was a kingdom. The King of Berland adored math. That's why, when he first visited one of his many palaces, he first of all paid attention to the floor in one hall. The floor was tiled with hexagonal tiles.
The hall also turned out hexagonal in its shape. The King walked along the perimeter of the hall and concluded that each of the six sides has a, b, c, a, b and c adjacent tiles, correspondingly.
To better visualize the situation, look at the picture showing a similar hexagon for a = 2, b = 3 and c = 4.
<image>
According to the legend, as the King of Berland obtained the values a, b and c, he almost immediately calculated the total number of tiles on the hall floor. Can you do the same?
Input
The first line contains three integers: a, b and c (2 ≤ a, b, c ≤ 1000).
Output
Print a single number — the total number of tiles on the hall floor.
Examples
Input
2 3 4
Output
18
Submitted Solution:
```
a, b, c = map(int, input().split())
print(c * (b + a - 1) + b - 1)
``` | instruction | 0 | 55,896 | 8 | 111,792 |
No | output | 1 | 55,896 | 8 | 111,793 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have k pieces of laundry, each of which you want to wash, dry and fold. You are at a laundromat that has n1 washing machines, n2 drying machines and n3 folding machines. Each machine can process only one piece of laundry at a time. You can't dry a piece of laundry before it is washed, and you can't fold it before it is dried. Moreover, after a piece of laundry is washed, it needs to be immediately moved into a drying machine, and after it is dried, it needs to be immediately moved into a folding machine.
It takes t1 minutes to wash one piece of laundry in a washing machine, t2 minutes to dry it in a drying machine, and t3 minutes to fold it in a folding machine. Find the smallest number of minutes that is enough to wash, dry and fold all the laundry you have.
Input
The only line of the input contains seven integers: k, n1, n2, n3, t1, t2, t3 (1 ≤ k ≤ 104; 1 ≤ n1, n2, n3, t1, t2, t3 ≤ 1000).
Output
Print one integer — smallest number of minutes to do all your laundry.
Examples
Input
1 1 1 1 5 5 5
Output
15
Input
8 4 3 2 10 5 2
Output
32
Note
In the first example there's one instance of each machine, each taking 5 minutes to complete. You have only one piece of laundry, so it takes 15 minutes to process it.
In the second example you start washing first two pieces at moment 0. If you start the third piece of laundry immediately, then by the time it is dried, there will be no folding machine available, so you have to wait, and start washing third piece at moment 2. Similarly, you can't start washing next piece until moment 5, since otherwise there will be no dryer available, when it is washed. Start time for each of the eight pieces of laundry is 0, 0, 2, 5, 10, 10, 12 and 15 minutes respectively. The last piece of laundry will be ready after 15 + 10 + 5 + 2 = 32 minutes. | instruction | 0 | 55,980 | 8 | 111,960 |
Tags: greedy, implementation
Correct Solution:
```
class step(object):
timer = []
def __init__(self, name, machin_num, step_time):
self.machin_num = machin_num
self.step_time = step_time
self.name = name
def step_input(self, cloth_num, t):
'''
if cloth_num + len(self.timer) > self.machin_num:
excloth = cloth_num + len(self.timer) - self.machin_num
print('%s error excloth is %d' %(self.name , excloth))
return 'error'
else:
for new_cloth in range(cloth_num):
self.timer.append(t)
#print(self.timer)
'''
for new_cloth in range(cloth_num):
self.timer.append(t)
def step_run(self, t):
tmptimer = [each_timer for each_timer in self.timer if t - each_timer < self.step_time]
#next_num = len(self.timer) - len(tmptimer)
self.timer = tmptimer
#if len(self.timer) == 0:
#print('%s in %d is empty' %(self.name, t))
#pass
#print('%d: %s timer:\n%s \n' %(t, self.name, self.timer))
#print('%d: %s timer: %d \n' %(t, self.name, next_num))
#return next_num
def checkstate(self, pre_t):
running_machine = len(self.timer)
#output = 0
for each_timer in range(running_machine):
if pre_t - self.timer[each_timer] >= self.step_time:
running_machine -= 1
#output += 1
return self.machin_num - running_machine
def main():
p, n1, n2, n3, t1, t2, t3 = map(int, input().split())
'''
p = 8
n1 = 4
n2 = 3
n3 = 2
t1 = 10
t2 = 5
t3 = 2
'''
step1 = step('step1', n1, t1)
step2 = step('step2', n2, t2)
step3 = step('step3', n3, t3)
t = 0
#cp = 0
while True:
pre_num1 = step1.checkstate(t)
pre_num2 = step2.checkstate(t + t1)
pre_num3 = step3.checkstate(t + t1 + t2)
step1_input = min(pre_num1, pre_num2, pre_num3)
p -= step1_input
step1.step_run(t)
step1.step_input(step1_input, t)
step2.step_run(t + t1)
step2.step_input(step1_input, t + t1)
step3.step_run(t + t1 + t2)
step3.step_input(step1_input, t + t1 + t2)
if p <= 0:
print(t + t1 + t2 + t3)
break
pre_t = []
if len(step1.timer) == step1.machin_num:
#print('step1 stun')
pre_t.append(t1 - (t - step1.timer[0]))
if len(step2.timer) == step2.machin_num:
#print('step2 stun')
pre_t.append(t2 - (t + t1 - step2.timer[0]))
if len(step3.timer) == step3.machin_num:
#print('step3 stun')
pre_t.append(t3 - (t + t1 + t2 - step3.timer[0]))
#print('pre_t: %s' %(pre_t))
if len(pre_t) == 0:
pre_t = 1
else:
pre_t = min(pre_t)
'''
print('%d minute input: %d' %(t, step1_input))
print('step1 timer:\n%s\npre_num1: %d'%(step1.timer, pre_num1))
print('step2 timer:\n%s\npre_num2: %d'%(step2.timer, pre_num2))
print('step3 timer:\n%s\npre_num3: %d'%(step3.timer, pre_num3))
print('pre_t: %d' %pre_t)
input()
'''
t += pre_t
if __name__ == '__main__':
main()
``` | output | 1 | 55,980 | 8 | 111,961 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have k pieces of laundry, each of which you want to wash, dry and fold. You are at a laundromat that has n1 washing machines, n2 drying machines and n3 folding machines. Each machine can process only one piece of laundry at a time. You can't dry a piece of laundry before it is washed, and you can't fold it before it is dried. Moreover, after a piece of laundry is washed, it needs to be immediately moved into a drying machine, and after it is dried, it needs to be immediately moved into a folding machine.
It takes t1 minutes to wash one piece of laundry in a washing machine, t2 minutes to dry it in a drying machine, and t3 minutes to fold it in a folding machine. Find the smallest number of minutes that is enough to wash, dry and fold all the laundry you have.
Input
The only line of the input contains seven integers: k, n1, n2, n3, t1, t2, t3 (1 ≤ k ≤ 104; 1 ≤ n1, n2, n3, t1, t2, t3 ≤ 1000).
Output
Print one integer — smallest number of minutes to do all your laundry.
Examples
Input
1 1 1 1 5 5 5
Output
15
Input
8 4 3 2 10 5 2
Output
32
Note
In the first example there's one instance of each machine, each taking 5 minutes to complete. You have only one piece of laundry, so it takes 15 minutes to process it.
In the second example you start washing first two pieces at moment 0. If you start the third piece of laundry immediately, then by the time it is dried, there will be no folding machine available, so you have to wait, and start washing third piece at moment 2. Similarly, you can't start washing next piece until moment 5, since otherwise there will be no dryer available, when it is washed. Start time for each of the eight pieces of laundry is 0, 0, 2, 5, 10, 10, 12 and 15 minutes respectively. The last piece of laundry will be ready after 15 + 10 + 5 + 2 = 32 minutes. | instruction | 0 | 55,981 | 8 | 111,962 |
Tags: greedy, implementation
Correct Solution:
```
k, na, nb, nc, ta, tb, tc = list(map(int, input().split()))
from collections import deque
a = deque()
b = deque()
c = deque()
for i in range(na):
a.append(0)
for i in range(nb):
b.append(0)
for i in range(nc):
c.append(0)
t = 0
for i in range(k):
vr = max(a[0], b[0] - ta, c[0] - (ta + tb))
a.popleft()
a.append(vr + ta)
b.popleft()
b.append(vr + tb + ta)
c.popleft()
c.append(vr + ta + tb + tc)
t = vr + ta + tb + tc
print(t)
``` | output | 1 | 55,981 | 8 | 111,963 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have k pieces of laundry, each of which you want to wash, dry and fold. You are at a laundromat that has n1 washing machines, n2 drying machines and n3 folding machines. Each machine can process only one piece of laundry at a time. You can't dry a piece of laundry before it is washed, and you can't fold it before it is dried. Moreover, after a piece of laundry is washed, it needs to be immediately moved into a drying machine, and after it is dried, it needs to be immediately moved into a folding machine.
It takes t1 minutes to wash one piece of laundry in a washing machine, t2 minutes to dry it in a drying machine, and t3 minutes to fold it in a folding machine. Find the smallest number of minutes that is enough to wash, dry and fold all the laundry you have.
Input
The only line of the input contains seven integers: k, n1, n2, n3, t1, t2, t3 (1 ≤ k ≤ 104; 1 ≤ n1, n2, n3, t1, t2, t3 ≤ 1000).
Output
Print one integer — smallest number of minutes to do all your laundry.
Examples
Input
1 1 1 1 5 5 5
Output
15
Input
8 4 3 2 10 5 2
Output
32
Note
In the first example there's one instance of each machine, each taking 5 minutes to complete. You have only one piece of laundry, so it takes 15 minutes to process it.
In the second example you start washing first two pieces at moment 0. If you start the third piece of laundry immediately, then by the time it is dried, there will be no folding machine available, so you have to wait, and start washing third piece at moment 2. Similarly, you can't start washing next piece until moment 5, since otherwise there will be no dryer available, when it is washed. Start time for each of the eight pieces of laundry is 0, 0, 2, 5, 10, 10, 12 and 15 minutes respectively. The last piece of laundry will be ready after 15 + 10 + 5 + 2 = 32 minutes. | instruction | 0 | 55,982 | 8 | 111,964 |
Tags: greedy, implementation
Correct Solution:
```
k, n1, n2, n3, t1, t2, t3 = map(int, input().split())
x1 = x2 = x3 = 0
T1, T2, T3 = [0] * n1, [0] * n2, [0] * n3
for i in range(k):
T1[x1] += t1
T2[x2] = max(T1[x1], T2[x2]) + t2
T3[x3] = max(T2[x2], T3[x3]) + t3
x1 += 1
x2 += 1
x3 += 1
if x1 == n1: x1 = 0
if x2 == n2: x2 = 0
if x3 == n3: x3 = 0
print(T3[x3 - 1])
``` | output | 1 | 55,982 | 8 | 111,965 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have k pieces of laundry, each of which you want to wash, dry and fold. You are at a laundromat that has n1 washing machines, n2 drying machines and n3 folding machines. Each machine can process only one piece of laundry at a time. You can't dry a piece of laundry before it is washed, and you can't fold it before it is dried. Moreover, after a piece of laundry is washed, it needs to be immediately moved into a drying machine, and after it is dried, it needs to be immediately moved into a folding machine.
It takes t1 minutes to wash one piece of laundry in a washing machine, t2 minutes to dry it in a drying machine, and t3 minutes to fold it in a folding machine. Find the smallest number of minutes that is enough to wash, dry and fold all the laundry you have.
Input
The only line of the input contains seven integers: k, n1, n2, n3, t1, t2, t3 (1 ≤ k ≤ 104; 1 ≤ n1, n2, n3, t1, t2, t3 ≤ 1000).
Output
Print one integer — smallest number of minutes to do all your laundry.
Examples
Input
1 1 1 1 5 5 5
Output
15
Input
8 4 3 2 10 5 2
Output
32
Note
In the first example there's one instance of each machine, each taking 5 minutes to complete. You have only one piece of laundry, so it takes 15 minutes to process it.
In the second example you start washing first two pieces at moment 0. If you start the third piece of laundry immediately, then by the time it is dried, there will be no folding machine available, so you have to wait, and start washing third piece at moment 2. Similarly, you can't start washing next piece until moment 5, since otherwise there will be no dryer available, when it is washed. Start time for each of the eight pieces of laundry is 0, 0, 2, 5, 10, 10, 12 and 15 minutes respectively. The last piece of laundry will be ready after 15 + 10 + 5 + 2 = 32 minutes.
Submitted Solution:
```
"""
solving D. Washer, Dryer, Folder
input: k, n1, n2, n3, t1, t2, t3
output: smallest number of mins
"""
try:
k, n1, n2, n3, t1, t2, t3 = map(int, input().split())
except Exception as e:
print("Invalid input:" + e)
exit()
k2 = 0
k3 = 0
time_elapsed = 0 # per minute
while k > 0 or k2 >0 or k3 >0:
time_elapsed += 1
if (time_elapsed % t3 == 0) and (k3 > 0): # reached t3
k3 -= min(k3, n3)
if (time_elapsed % t2 == 0) and (k2 > 0): # reached t2
k3 += min(k2, n2)
k2 -= min(k2, n2)
if (time_elapsed % t1 == 0) and (k > 0): # reached t1
k2 += min(k, n1)
k -= min(k, n1)
#print(str(k) + "\t" + str(k2) + "\t" + str(k3) + "\t\t" + str(time_elapsed))
print(time_elapsed)
``` | instruction | 0 | 55,983 | 8 | 111,966 |
No | output | 1 | 55,983 | 8 | 111,967 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have k pieces of laundry, each of which you want to wash, dry and fold. You are at a laundromat that has n1 washing machines, n2 drying machines and n3 folding machines. Each machine can process only one piece of laundry at a time. You can't dry a piece of laundry before it is washed, and you can't fold it before it is dried. Moreover, after a piece of laundry is washed, it needs to be immediately moved into a drying machine, and after it is dried, it needs to be immediately moved into a folding machine.
It takes t1 minutes to wash one piece of laundry in a washing machine, t2 minutes to dry it in a drying machine, and t3 minutes to fold it in a folding machine. Find the smallest number of minutes that is enough to wash, dry and fold all the laundry you have.
Input
The only line of the input contains seven integers: k, n1, n2, n3, t1, t2, t3 (1 ≤ k ≤ 104; 1 ≤ n1, n2, n3, t1, t2, t3 ≤ 1000).
Output
Print one integer — smallest number of minutes to do all your laundry.
Examples
Input
1 1 1 1 5 5 5
Output
15
Input
8 4 3 2 10 5 2
Output
32
Note
In the first example there's one instance of each machine, each taking 5 minutes to complete. You have only one piece of laundry, so it takes 15 minutes to process it.
In the second example you start washing first two pieces at moment 0. If you start the third piece of laundry immediately, then by the time it is dried, there will be no folding machine available, so you have to wait, and start washing third piece at moment 2. Similarly, you can't start washing next piece until moment 5, since otherwise there will be no dryer available, when it is washed. Start time for each of the eight pieces of laundry is 0, 0, 2, 5, 10, 10, 12 and 15 minutes respectively. The last piece of laundry will be ready after 15 + 10 + 5 + 2 = 32 minutes.
Submitted Solution:
```
"""
solving D. Washer, Dryer, Folder
input: k, n1, n2, n3, t1, t2, t3
output: smallest number of mins
"""
try:
k, n1, n2, n3, t1, t2, t3 = map(int, input().split())
except Exception as e:
print("Invalid input:" + e)
exit()
k2 = 0
k3 = 0
time_elapsed = 0 # per minute
time_k2_elapsed = 0
time_k3_elapsed = 0
while k > 0 or k2 >0 or k3 >0:
time_elapsed += 1
if k2 > 0:
time_k2_elapsed += 1
else:
time_k2_elapsed = 0
if k3 > 0:
time_k3_elapsed += 1
else:
time_k3_elapsed = 0
if k3 > 0 and time_k3_elapsed % t3 == 0: # reached t3
k3 -= min(k3, n3)
if k2 > 0 and time_k2_elapsed % t2 == 0: # reached t2
k3 += min(k2, n2)
k2 -= min(k2, n2)
if k > 0 and time_elapsed % t1 == 0: # reached t1
k2 += min(k, n1)
k -= min(k, n1)
print(str(k) + "\t" + str(k2) + "\t" + str(k3) + "\t\t" + str(time_elapsed))
print(time_elapsed)
``` | instruction | 0 | 55,984 | 8 | 111,968 |
No | output | 1 | 55,984 | 8 | 111,969 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have k pieces of laundry, each of which you want to wash, dry and fold. You are at a laundromat that has n1 washing machines, n2 drying machines and n3 folding machines. Each machine can process only one piece of laundry at a time. You can't dry a piece of laundry before it is washed, and you can't fold it before it is dried. Moreover, after a piece of laundry is washed, it needs to be immediately moved into a drying machine, and after it is dried, it needs to be immediately moved into a folding machine.
It takes t1 minutes to wash one piece of laundry in a washing machine, t2 minutes to dry it in a drying machine, and t3 minutes to fold it in a folding machine. Find the smallest number of minutes that is enough to wash, dry and fold all the laundry you have.
Input
The only line of the input contains seven integers: k, n1, n2, n3, t1, t2, t3 (1 ≤ k ≤ 104; 1 ≤ n1, n2, n3, t1, t2, t3 ≤ 1000).
Output
Print one integer — smallest number of minutes to do all your laundry.
Examples
Input
1 1 1 1 5 5 5
Output
15
Input
8 4 3 2 10 5 2
Output
32
Note
In the first example there's one instance of each machine, each taking 5 minutes to complete. You have only one piece of laundry, so it takes 15 minutes to process it.
In the second example you start washing first two pieces at moment 0. If you start the third piece of laundry immediately, then by the time it is dried, there will be no folding machine available, so you have to wait, and start washing third piece at moment 2. Similarly, you can't start washing next piece until moment 5, since otherwise there will be no dryer available, when it is washed. Start time for each of the eight pieces of laundry is 0, 0, 2, 5, 10, 10, 12 and 15 minutes respectively. The last piece of laundry will be ready after 15 + 10 + 5 + 2 = 32 minutes.
Submitted Solution:
```
"""
solving D. Washer, Dryer, Folder
input: k, n1, n2, n3, t1, t2, t3
output: smallest number of mins
"""
try:
k, n1, n2, n3, t1, t2, t3 = map(int, input().split())
#k, n1, n2, n3, t1, t2, t3 = 1,1,1,1,5,5,5
#k, n1, n2, n3, t1, t2, t3 = 8,4,3,2,10,5,2
except Exception as e:
print("Invalid input:" + e)
exit()
k2 = 0
k3 = 0
time_elapsed = 0 # per minute
time_k2_elapsed = 0
time_k3_elapsed = 0
while k > 0 or k2 >0 or k3 >0:
time_elapsed += 1
if k2 > 0:
time_k2_elapsed += 1
else:
time_k2_elapsed = 0
if k3 > 0:
time_k3_elapsed += 1
else:
time_k3_elapsed = 0
if k3 > 0 and time_k3_elapsed >0 and time_k3_elapsed % t3 == 0: # reached t3
k3 -= min(k3, n3)
if k2 > 0 and time_k2_elapsed >0 and time_k2_elapsed % t2 == 0: # reached t2
k3 += min(k2, n2)
k2 -= min(k2, n2)
if k > 0 and time_elapsed % t1 == 0: # reached t1
k2 += min(k, n1)
k -= min(k, n1)
#print(str(k) + "\t" + str(k2) + "\t" + str(k3) + "\t\t" + str(time_elapsed))
print(time_elapsed)
``` | instruction | 0 | 55,985 | 8 | 111,970 |
No | output | 1 | 55,985 | 8 | 111,971 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have k pieces of laundry, each of which you want to wash, dry and fold. You are at a laundromat that has n1 washing machines, n2 drying machines and n3 folding machines. Each machine can process only one piece of laundry at a time. You can't dry a piece of laundry before it is washed, and you can't fold it before it is dried. Moreover, after a piece of laundry is washed, it needs to be immediately moved into a drying machine, and after it is dried, it needs to be immediately moved into a folding machine.
It takes t1 minutes to wash one piece of laundry in a washing machine, t2 minutes to dry it in a drying machine, and t3 minutes to fold it in a folding machine. Find the smallest number of minutes that is enough to wash, dry and fold all the laundry you have.
Input
The only line of the input contains seven integers: k, n1, n2, n3, t1, t2, t3 (1 ≤ k ≤ 104; 1 ≤ n1, n2, n3, t1, t2, t3 ≤ 1000).
Output
Print one integer — smallest number of minutes to do all your laundry.
Examples
Input
1 1 1 1 5 5 5
Output
15
Input
8 4 3 2 10 5 2
Output
32
Note
In the first example there's one instance of each machine, each taking 5 minutes to complete. You have only one piece of laundry, so it takes 15 minutes to process it.
In the second example you start washing first two pieces at moment 0. If you start the third piece of laundry immediately, then by the time it is dried, there will be no folding machine available, so you have to wait, and start washing third piece at moment 2. Similarly, you can't start washing next piece until moment 5, since otherwise there will be no dryer available, when it is washed. Start time for each of the eight pieces of laundry is 0, 0, 2, 5, 10, 10, 12 and 15 minutes respectively. The last piece of laundry will be ready after 15 + 10 + 5 + 2 = 32 minutes.
Submitted Solution:
```
"""
solving D. Washer, Dryer, Folder
input: k, n1, n2, n3, t1, t2, t3
output: smallest number of mins
"""
try:
k, n1, n2, n3, t1, t2, t3 = map(int, input().split())
except Exception as e:
print("Invalid input:" + e)
exit()
k2 = 0
k3 = 0
time_elapsed = 0 # per minute
time_k2_elapsed = 0
time_k3_elapsed = 0
while k > 0 or k2 >0 or k3 >0:
time_elapsed += 1
if k2 > 0:
time_k2_elapsed += 1
else:
time_k2_elapsed = 0
if k3 > 0:
time_k3_elapsed += 1
else:
time_k3_elapsed = 0
if k3 > 0 and time_k3_elapsed % t3 == 0: # reached t3
k3 -= min(k3, n3)
if k2 > 0 and time_k2_elapsed % t2 == 0: # reached t2
k3 += min(k2, n2)
k2 -= min(k2, n2)
if k > 0 and time_elapsed % t1 == 0: # reached t1
k2 += min(k, n1)
k -= min(k, n1)
#print(str(k) + "\t" + str(k2) + "\t" + str(k3) + "\t\t" + str(time_elapsed))
print(time_elapsed)
``` | instruction | 0 | 55,986 | 8 | 111,972 |
No | output | 1 | 55,986 | 8 | 111,973 |
Provide a correct Python 3 solution for this coding contest problem.
There are N towers in the town where Ikta lives. Each tower is given a different number from 0 to N-1, and the tower with number i is called tower i. Curious Ikta was interested in the height of the N towers and decided to make a table T showing the magnitude relationship between them. T has N × N elements, and each element Ti, j (0 ≤ i, j ≤ N − 1) is defined as follows.
* Ti, j = −1 ⇔ The height of tower i is smaller than the height of tower j
* Ti, j = 0 ⇔ The height of tower i is equal to the height of tower j
* Ti, j = 1 ⇔ The height of tower i is larger than the height of tower j
As a survey to create Table T, Ikta repeated N-1 times to select two towers and compare their heights.
We know the following about Ikta's investigation.
* If tower ai and tower bi were selected in the i-th comparison (1 ≤ i ≤ \ N − 1), the height of tower ai was larger than the height of tower bi. That is, Tai, bi = 1, Tbi, ai = −1.
* Each tower has been compared to a tower larger than itself at most once.
Unfortunately, it is not always possible to uniquely determine the contents of Table T based on the information obtained from Ikta's research. If the table T is consistent with Ikta's research and there is a combination of tower heights in which T is defined, we will call T the correct table. Please calculate how many kinds of correct tables you can think of and tell Ikta.
However, although the heights of the two towers compared are different from each other, not all towers are different from each other.
Input
The input is given in the following format.
N
a1 b1
...
aN−1 bN−1
N represents the number of towers. ai, bi (1 ≤ i ≤ N − 1) indicates that the tower ai is higher than the tower bi.
Constraints
Each variable being input satisfies the following constraints.
* 1 ≤ N ≤ 200
* 0 ≤ ai, bi <N
* ai ≠ bi
* Different towers may be the same height.
* Ikta's findings are not inconsistent, and there is at least one Table T that is consistent with Ikta's findings.
Output
Output the remainder of dividing the number of possible correct number of tables T by 1,000,000,007.
Examples
Input
3
0 1
1 2
Output
1
Input
3
0 1
0 2
Output
3
Input
1
Output
1
Input
7
0 1
1 2
2 3
3 4
0 5
0 6
Output
91 | instruction | 0 | 56,371 | 8 | 112,742 |
"Correct Solution:
```
import sys
readline = sys.stdin.readline
write = sys.stdout.write
from collections import deque
def solve():
MOD = 10**9 + 7
N = int(readline())
dp0 = [[[0]*(N+1) for i in range(N+1)] for j in range(N+1)]
dp0[0][0][0] = 1
for c in range(1, N+1):
for a in range(N+1):
for b in range(N+1):
r = 0
if a:
r += dp0[c-1][a-1][b]
if b:
r += dp0[c-1][a][b-1]
if a and b:
r += dp0[c-1][a-1][b-1]
dp0[c][a][b] = r % MOD
G = [[] for i in range(N)]
deg = [0]*N
for i in range(N-1):
a, b = map(int, readline().split())
G[a].append(b)
deg[b] += 1
r = 0
for i in range(N):
if deg[i] == 0:
r = i
break
que = deque([r])
vs = []
while que:
v = que.popleft()
vs.append(v)
for w in G[v]:
que.append(w)
vs.reverse()
hs = [0]*N
for v in vs:
e = 0
for w in G[v]:
e = max(e, hs[w] + 1)
hs[v] = e
def dfs(v):
res = [1]
hv = 0
for w in G[v]:
r = dfs(w)
hw = len(r)-1
r0 = [0]*(hv+hw+1)
for i in range(hv+1):
for j in range(hw+1):
for k in range(max(i, j), i+j+1):
r0[k] += res[i] * r[j] * dp0[k][i][j] % MOD
res = r0
hv += hw
return [0] + res
write("%d\n" % (sum(dfs(r)) % MOD))
solve()
``` | output | 1 | 56,371 | 8 | 112,743 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vova decided to clean his room. The room can be represented as the coordinate axis OX. There are n piles of trash in the room, coordinate of the i-th pile is the integer p_i. All piles have different coordinates.
Let's define a total cleanup as the following process. The goal of this process is to collect all the piles in no more than two different x coordinates. To achieve this goal, Vova can do several (possibly, zero) moves. During one move, he can choose some x and move all piles from x to x+1 or x-1 using his broom. Note that he can't choose how many piles he will move.
Also, there are two types of queries:
* 0 x — remove a pile of trash from the coordinate x. It is guaranteed that there is a pile in the coordinate x at this moment.
* 1 x — add a pile of trash to the coordinate x. It is guaranteed that there is no pile in the coordinate x at this moment.
Note that it is possible that there are zero piles of trash in the room at some moment.
Vova wants to know the minimum number of moves he can spend if he wants to do a total cleanup before any queries. He also wants to know this number of moves after applying each query. Queries are applied in the given order. Note that the total cleanup doesn't actually happen and doesn't change the state of piles. It is only used to calculate the number of moves.
For better understanding, please read the Notes section below to see an explanation for the first example.
Input
The first line of the input contains two integers n and q (1 ≤ n, q ≤ 10^5) — the number of piles in the room before all queries and the number of queries, respectively.
The second line of the input contains n distinct integers p_1, p_2, ..., p_n (1 ≤ p_i ≤ 10^9), where p_i is the coordinate of the i-th pile.
The next q lines describe queries. The i-th query is described with two integers t_i and x_i (0 ≤ t_i ≤ 1; 1 ≤ x_i ≤ 10^9), where t_i is 0 if you need to remove a pile from the coordinate x_i and is 1 if you need to add a pile to the coordinate x_i. It is guaranteed that for t_i = 0 there is such pile in the current set of piles and for t_i = 1 there is no such pile in the current set of piles.
Output
Print q+1 integers: the minimum number of moves Vova needs to do a total cleanup before the first query and after each of q queries.
Examples
Input
5 6
1 2 6 8 10
1 4
1 9
0 6
0 10
1 100
1 50
Output
5
7
7
5
4
8
49
Input
5 8
5 1 2 4 3
0 1
0 2
0 3
0 4
0 5
1 1000000000
1 1
1 500000000
Output
3
2
1
0
0
0
0
0
499999999
Note
Consider the first example.
Initially, the set of piles is [1, 2, 6, 8, 10]. The answer before the first query is 5 because you can move all piles from 1 to 2 with one move, all piles from 10 to 8 with 2 moves and all piles from 6 to 8 with 2 moves.
After the first query, the set becomes [1, 2, 4, 6, 8, 10]. Then the answer is 7 because you can move all piles from 6 to 4 with 2 moves, all piles from 4 to 2 with 2 moves, all piles from 2 to 1 with 1 move and all piles from 10 to 8 with 2 moves.
After the second query, the set of piles becomes [1, 2, 4, 6, 8, 9, 10] and the answer is the same (and the previous sequence of moves can be applied to the current set of piles).
After the third query, the set of piles becomes [1, 2, 4, 8, 9, 10] and the answer is 5 because you can move all piles from 1 to 2 with 1 move, all piles from 2 to 4 with 2 moves, all piles from 10 to 9 with 1 move and all piles from 9 to 8 with 1 move.
After the fourth query, the set becomes [1, 2, 4, 8, 9] and the answer is almost the same (the previous sequence of moves can be applied without moving piles from 10).
After the fifth query, the set becomes [1, 2, 4, 8, 9, 100]. You can move all piles from 1 and further to 9 and keep 100 at its place. So the answer is 8.
After the sixth query, the set becomes [1, 2, 4, 8, 9, 50, 100]. The answer is 49 and can be obtained with almost the same sequence of moves as after the previous query. The only difference is that you need to move all piles from 50 to 9 too. | instruction | 0 | 56,560 | 8 | 113,120 |
Tags: data structures, implementation
Correct Solution:
```
import os
import sys
from io import BytesIO, IOBase
_str = str
BUFSIZE = 8192
def str(x=b''):
return x if type(x) is bytes else _str(x).encode()
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = 'x' in file.mode or 'r' not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b'\n') + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode('ascii'))
self.read = lambda: self.buffer.read().decode('ascii')
self.readline = lambda: self.buffer.readline().decode('ascii')
def inp():
return sys.stdin.readline().rstrip()
def mpint():
return map(int, inp().split(' '))
def itg():
return int(inp())
# ############################## import
# from ACgenerator.Y_Testing import get_code
class FenwickTree: # pyrival
def __init__(self, x=[]):
""" transform list into BIT """
self.bit = x
for i in range(len(x)):
j = i | (i + 1)
if j < len(x):
x[j] += x[i]
def update(self, idx, x):
""" updates bit[idx] += x """
while idx < len(self.bit):
self.bit[idx] += x
idx |= idx + 1
def query(self, end):
""" calc sum(bit[:end]) """
x = 0
while end:
x += self.bit[end - 1]
end &= end - 1
return x
def findkth(self, k):
"""
Find largest idx such that sum(x[:idx]) <= k
all of the element in x have to be non-negative
"""
idx = -1
for d in reversed(range(len(self.bit).bit_length())):
right_idx = idx + (1 << d)
if right_idx < len(self.bit) and k >= self.bit[right_idx]:
idx = right_idx
k -= self.bit[idx]
return idx + 1
from heapq import heappop, heappush
class Transform(int):
def __lt__(self, other):
return self >= other
class DiscreteSortedList:
def __init__(self, discrete_data):
""":param discrete_data: sorted(set(ALL_INPUT_DATA)) """
self.restore = discrete_data
self.DISCRETE_SIZE = len(self.restore)
self._len = 0
self.discrete_dict = dict(zip(self.restore, range(self.DISCRETE_SIZE)))
self._fen = FenwickTree([0] * (self.DISCRETE_SIZE + 1))
self.nums = [0] * (self.DISCRETE_SIZE + 1)
def update(self, val, num=1):
val = self.discrete_dict[val]
if num < -self.nums[val]:
num = -self.nums[val]
self.nums[val] += num
self._len += num
self._fen.update(val, num)
def clear(self):
self.nums = [0] * (self.DISCRETE_SIZE + 1)
self._fen.bit = [0] * (self.DISCRETE_SIZE + 1)
self._len = 0
def count(self, val):
return self.nums[self.discrete_dict[val]]
def bisect_left(self, val):
""" index of val """
return self._fen.query(self.discrete_dict[val])
def bisect_right(self, val):
return self._fen.query(self.discrete_dict[val] + 1)
def __getitem__(self, index):
if self._len == 0:
return None
return self.restore[self._fen.findkth(index % self._len)]
def lower(self, val):
index = self.bisect_left(val)
if index == 0:
return None
return self[index - 1]
def higher(self, val):
index = self.bisect_right(val)
if index == self._len:
return None
return self[index]
def to_dict(self):
result = {}
val = self[0]
while val:
result[val] = self.count(val)
val = self.higher(val)
return result
def __contains__(self, item):
return self.nums[self.discrete_dict[item]] > 0
def ceiling(self, val):
return val if val in self else self.higher(val)
def floor(self, val):
return val if val in self else self.lower(val)
def __iter__(self):
return (self.__getitem__(index) for index in range(self._len))
def __repr__(self):
return 'DiscreteSortedList({})'.format(list(self))
def __len__(self):
return self._len
def __bool__(self):
return self._len > 0
class RemovableHeap:
def __init__(self, max_heap_type=None):
if max_heap_type: # element's class
class Transform(max_heap_type):
def __lt__(self, other):
return self >= other
self._T = Transform
else:
self._T = lambda x: x
self.heap = []
self.rem = []
self.dict = {}
self.size = 0
def __len__(self):
return self.size
def peek(self):
self.__trim()
return self.heap[0]
def push(self, val):
val = self._T(val)
heappush(self.heap, val)
if val in self.dict:
self.dict[val] += 1
else:
self.dict[val] = 1
self.size += 1
def pop(self):
self.__trim()
if not self.heap:
return None
self.size -= 1
val = heappop(self.heap)
if self.dict[val] == 1:
del self.dict[val]
else:
self.dict[val] -= 1
return val
def remove(self, val):
val = self._T(val)
if val not in self.dict:
return
self.size -= 1
if self.dict[val] == 1:
del self.dict[val]
else:
self.dict[val] -= 1
heappush(self.rem, val)
def __trim(self):
while self.rem and self.rem[0] == self.heap[0]:
heappop(self.heap)
heappop(self.rem)
# ############################## main
def solve():
n, q = mpint()
arr = sorted(mpint())
discrete_data = arr.copy()
input_data = [tuple(mpint()) for _ in range(q)]
for t, x in input_data:
if t == 1:
discrete_data.append(x)
indices = DiscreteSortedList(sorted(set(discrete_data)))
intervals = RemovableHeap(int)
for a in arr:
indices.update(a)
for i in range(1, n):
intervals.push(arr[i] - arr[i - 1])
def query():
if not intervals:
return 0
return indices[-1] - indices[0] - intervals.peek()
print(query())
for t, x in input_data:
if t == 0: # discard
lower = indices.lower(x)
higher = indices.higher(x)
if lower:
intervals.remove(x - lower)
if higher:
intervals.remove(higher - x)
if lower and higher:
intervals.push(higher - lower)
indices.update(x, -1)
else: # add
lower = indices.lower(x)
higher = indices.higher(x)
if higher and lower:
intervals.remove(higher - lower)
if lower:
intervals.push(x - lower)
if higher:
intervals.push(higher - x)
indices.update(x)
print(query())
def main():
# print("YES" if solve() else "NO")
# print("yes" if solve() else "no")
solve()
# print(solve())
# for _ in range(itg()):
# print(solve())
DEBUG = 0
URL = 'https://codeforces.com/contest/1418/problem/D'
if __name__ == '__main__':
if DEBUG == 1:
import requests # ImportError: cannot import name 'md5' from 'sys' (unknown location)
from ACgenerator.Y_Test_Case_Runner import TestCaseRunner
runner = TestCaseRunner(main, URL)
inp = runner.input_stream
print = runner.output_stream
runner.checking()
elif DEBUG == 2:
main()
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
main()
# Please check!
``` | output | 1 | 56,560 | 8 | 113,121 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vova decided to clean his room. The room can be represented as the coordinate axis OX. There are n piles of trash in the room, coordinate of the i-th pile is the integer p_i. All piles have different coordinates.
Let's define a total cleanup as the following process. The goal of this process is to collect all the piles in no more than two different x coordinates. To achieve this goal, Vova can do several (possibly, zero) moves. During one move, he can choose some x and move all piles from x to x+1 or x-1 using his broom. Note that he can't choose how many piles he will move.
Also, there are two types of queries:
* 0 x — remove a pile of trash from the coordinate x. It is guaranteed that there is a pile in the coordinate x at this moment.
* 1 x — add a pile of trash to the coordinate x. It is guaranteed that there is no pile in the coordinate x at this moment.
Note that it is possible that there are zero piles of trash in the room at some moment.
Vova wants to know the minimum number of moves he can spend if he wants to do a total cleanup before any queries. He also wants to know this number of moves after applying each query. Queries are applied in the given order. Note that the total cleanup doesn't actually happen and doesn't change the state of piles. It is only used to calculate the number of moves.
For better understanding, please read the Notes section below to see an explanation for the first example.
Input
The first line of the input contains two integers n and q (1 ≤ n, q ≤ 10^5) — the number of piles in the room before all queries and the number of queries, respectively.
The second line of the input contains n distinct integers p_1, p_2, ..., p_n (1 ≤ p_i ≤ 10^9), where p_i is the coordinate of the i-th pile.
The next q lines describe queries. The i-th query is described with two integers t_i and x_i (0 ≤ t_i ≤ 1; 1 ≤ x_i ≤ 10^9), where t_i is 0 if you need to remove a pile from the coordinate x_i and is 1 if you need to add a pile to the coordinate x_i. It is guaranteed that for t_i = 0 there is such pile in the current set of piles and for t_i = 1 there is no such pile in the current set of piles.
Output
Print q+1 integers: the minimum number of moves Vova needs to do a total cleanup before the first query and after each of q queries.
Examples
Input
5 6
1 2 6 8 10
1 4
1 9
0 6
0 10
1 100
1 50
Output
5
7
7
5
4
8
49
Input
5 8
5 1 2 4 3
0 1
0 2
0 3
0 4
0 5
1 1000000000
1 1
1 500000000
Output
3
2
1
0
0
0
0
0
499999999
Note
Consider the first example.
Initially, the set of piles is [1, 2, 6, 8, 10]. The answer before the first query is 5 because you can move all piles from 1 to 2 with one move, all piles from 10 to 8 with 2 moves and all piles from 6 to 8 with 2 moves.
After the first query, the set becomes [1, 2, 4, 6, 8, 10]. Then the answer is 7 because you can move all piles from 6 to 4 with 2 moves, all piles from 4 to 2 with 2 moves, all piles from 2 to 1 with 1 move and all piles from 10 to 8 with 2 moves.
After the second query, the set of piles becomes [1, 2, 4, 6, 8, 9, 10] and the answer is the same (and the previous sequence of moves can be applied to the current set of piles).
After the third query, the set of piles becomes [1, 2, 4, 8, 9, 10] and the answer is 5 because you can move all piles from 1 to 2 with 1 move, all piles from 2 to 4 with 2 moves, all piles from 10 to 9 with 1 move and all piles from 9 to 8 with 1 move.
After the fourth query, the set becomes [1, 2, 4, 8, 9] and the answer is almost the same (the previous sequence of moves can be applied without moving piles from 10).
After the fifth query, the set becomes [1, 2, 4, 8, 9, 100]. You can move all piles from 1 and further to 9 and keep 100 at its place. So the answer is 8.
After the sixth query, the set becomes [1, 2, 4, 8, 9, 50, 100]. The answer is 49 and can be obtained with almost the same sequence of moves as after the previous query. The only difference is that you need to move all piles from 50 to 9 too. | instruction | 0 | 56,561 | 8 | 113,122 |
Tags: data structures, implementation
Correct Solution:
```
# -*- coding: utf-8 -*-
from heapq import heappop, heappush
from collections import Counter
import sys
# sys.setrecursionlimit(10**6)
# readline = sys.stdin.buffer.readline
readline = sys.stdin.readline
INF = 1 << 60
def read_int():
return int(readline())
def read_int_n():
return list(map(int, readline().split()))
def read_float():
return float(readline())
def read_float_n():
return list(map(float, readline().split()))
def read_str():
return readline().strip()
def read_str_n():
return readline().strip().split()
def ep(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.perf_counter()
ret = f(*args, **kwargs)
e = time.perf_counter()
ep(e - s, 'sec')
return ret
return wrap
class SegmentTree:
def __init__(self, array, operator, identity_element):
_len = len(array)
self.__len = _len
self.__op = operator
self.__size = 1 << (_len - 1).bit_length()
self.__tree = [identity_element] * self.__size + \
array + [identity_element] * (self.__size - _len)
self.__ie = identity_element
for i in range(self.__size - 1, 0, -1):
self.__tree[i] = operator(
self.__tree[i * 2], self.__tree[i * 2 + 1])
def update(self, i, v):
i += self.__size
self.__tree[i] = v
while i:
i //= 2
self.__tree[i] = self.__op(
self.__tree[i * 2], self.__tree[i * 2 + 1])
def query(self, l, r):
"""[l, r)
"""
l += self.__size
r += self.__size
ret = self.__ie
while l < r:
if l & 1:
ret = self.__op(ret, self.__tree[l])
l += 1
if r & 1:
r -= 1
ret = self.__op(ret, self.__tree[r])
l //= 2
r //= 2
return ret
def max_right(self, l, f):
# https://atcoder.jp/contests/practice2/submissions/16636885
assert 0 <= l <= self.__len
if l == self.__len:
return self.__len
l += self.__size
sm = self.__ie
while True:
while l % 2 == 0:
l >>= 1
if not f(self.__op(sm, self.__tree[l])):
while l < self.__size:
l = 2*l
if f(self.__op(sm, self.__tree[l])):
sm = self.__op(sm, self.__tree[l])
l += 1
return l - self.__size
sm = self.__op(sm, self.__tree[l])
l += 1
if (l & -l) == l:
break
return self.__len
def min_left(self, r, f):
assert 0 <= r <= self.__len
if r == 0:
return 0
r += self.__size
sm = self.__ie
while True:
r -= 1
while r > 1 and (r % 2):
r >>= 1
if not f(self.__op(sm, self.__tree[r])):
while r < self.__size:
r = 2*r + 1
if f(self.__op(sm, self.__tree[r])):
sm = self.__op(sm, self.__tree[r])
r -= 1
return r + 1 - self.__size
sm = self.__op(sm, self.__tree[r])
if (r & -r) == r:
break
return 0
def __getitem__(self, key):
return self.__tree[key + self.__size]
class RemovableHeapQueue:
def __init__(self):
self.__q = []
self.__cc = Counter()
self.o = 10**6
def add(self, v, k):
k = k[0] * self.o + k[1]
assert k < (1 << 60)
heappush(self.__q, (v, k))
self.__cc[k] += 1
def remove(self, k):
k = k[0] * self.o + k[1]
self.__cc[k] -= 1
assert self.__cc[k] >= 0
def refrash(self):
while self.__q:
if self.__cc[self.__q[0][1]] == 0:
heappop(self.__q)
else:
break
def pop(self):
self.refrash()
return heappop(self.__q)
def top(self):
self.refrash()
return self.__q[0]
def empty(self):
self.refrash()
return len(self.__q) == 0
# @mt
def slv(N, P, Q):
p = P[:] + [x for _, x in Q]
p.sort()
p2i = {p: i for i, p in enumerate(p)}
i2p = p
M = len(i2p)
lst = SegmentTree([-INF]*M, max, -INF)
rst = SegmentTree([INF]*M, min, INF)
for x in P:
i = p2i[x]
lst.update(i, i)
rst.update(i, i)
q = RemovableHeapQueue()
P.sort()
for i in range(len(P)-1):
d = P[i+1] - P[i]
ai, bi = p2i[P[i]], p2i[P[i+1]]
q.add(-d, (ai, bi))
def add(x):
ci = p2i[x]
ai = lst.query(0, ci)
bi = rst.query(ci+1, M)
lst.update(ci, ci)
rst.update(ci, ci)
if ai != -INF:
q.add(-(i2p[ci]-i2p[ai]), (ai, ci))
if bi != INF:
q.add(-(i2p[bi]-i2p[ci]), (ci, bi))
if ai != -INF and bi != INF:
q.remove((ai, bi))
return q.top() if not q.empty() else (0, (None, None))
def remove(x):
ci = p2i[x]
lst.update(ci, -INF)
rst.update(ci, INF)
ai = lst.query(0, ci)
bi = rst.query(ci+1, M)
if ai != -INF:
q.remove((ai, ci))
if bi != INF:
q.remove((ci, bi))
if ai != -INF and bi != INF:
q.add(-(i2p[bi]-i2p[ai]), (ai, bi))
return q.top() if not q.empty() else (0, (None, None))
if not q.empty():
ans = [max(P) - min(P) + q.top()[0]]
else:
ans = [0]
for t, x in Q:
if t == 0:
a = remove(x)
else:
a = add(x)
li = lst.query(0, M)
ri = rst.query(0, M)
if li != -INF:
l = i2p[li]
r = i2p[ri]
if l == r:
ans.append(0)
else:
ans.append(l-r+a[0])
else:
ans.append(0)
return ans
def main():
# 2
N, Q = read_int_n()
P = read_int_n()
Q = [read_int_n() for _ in range(Q)]
print(*slv(N, P, Q), sep='\n')
if __name__ == '__main__':
main()
``` | output | 1 | 56,561 | 8 | 113,123 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vova decided to clean his room. The room can be represented as the coordinate axis OX. There are n piles of trash in the room, coordinate of the i-th pile is the integer p_i. All piles have different coordinates.
Let's define a total cleanup as the following process. The goal of this process is to collect all the piles in no more than two different x coordinates. To achieve this goal, Vova can do several (possibly, zero) moves. During one move, he can choose some x and move all piles from x to x+1 or x-1 using his broom. Note that he can't choose how many piles he will move.
Also, there are two types of queries:
* 0 x — remove a pile of trash from the coordinate x. It is guaranteed that there is a pile in the coordinate x at this moment.
* 1 x — add a pile of trash to the coordinate x. It is guaranteed that there is no pile in the coordinate x at this moment.
Note that it is possible that there are zero piles of trash in the room at some moment.
Vova wants to know the minimum number of moves he can spend if he wants to do a total cleanup before any queries. He also wants to know this number of moves after applying each query. Queries are applied in the given order. Note that the total cleanup doesn't actually happen and doesn't change the state of piles. It is only used to calculate the number of moves.
For better understanding, please read the Notes section below to see an explanation for the first example.
Input
The first line of the input contains two integers n and q (1 ≤ n, q ≤ 10^5) — the number of piles in the room before all queries and the number of queries, respectively.
The second line of the input contains n distinct integers p_1, p_2, ..., p_n (1 ≤ p_i ≤ 10^9), where p_i is the coordinate of the i-th pile.
The next q lines describe queries. The i-th query is described with two integers t_i and x_i (0 ≤ t_i ≤ 1; 1 ≤ x_i ≤ 10^9), where t_i is 0 if you need to remove a pile from the coordinate x_i and is 1 if you need to add a pile to the coordinate x_i. It is guaranteed that for t_i = 0 there is such pile in the current set of piles and for t_i = 1 there is no such pile in the current set of piles.
Output
Print q+1 integers: the minimum number of moves Vova needs to do a total cleanup before the first query and after each of q queries.
Examples
Input
5 6
1 2 6 8 10
1 4
1 9
0 6
0 10
1 100
1 50
Output
5
7
7
5
4
8
49
Input
5 8
5 1 2 4 3
0 1
0 2
0 3
0 4
0 5
1 1000000000
1 1
1 500000000
Output
3
2
1
0
0
0
0
0
499999999
Note
Consider the first example.
Initially, the set of piles is [1, 2, 6, 8, 10]. The answer before the first query is 5 because you can move all piles from 1 to 2 with one move, all piles from 10 to 8 with 2 moves and all piles from 6 to 8 with 2 moves.
After the first query, the set becomes [1, 2, 4, 6, 8, 10]. Then the answer is 7 because you can move all piles from 6 to 4 with 2 moves, all piles from 4 to 2 with 2 moves, all piles from 2 to 1 with 1 move and all piles from 10 to 8 with 2 moves.
After the second query, the set of piles becomes [1, 2, 4, 6, 8, 9, 10] and the answer is the same (and the previous sequence of moves can be applied to the current set of piles).
After the third query, the set of piles becomes [1, 2, 4, 8, 9, 10] and the answer is 5 because you can move all piles from 1 to 2 with 1 move, all piles from 2 to 4 with 2 moves, all piles from 10 to 9 with 1 move and all piles from 9 to 8 with 1 move.
After the fourth query, the set becomes [1, 2, 4, 8, 9] and the answer is almost the same (the previous sequence of moves can be applied without moving piles from 10).
After the fifth query, the set becomes [1, 2, 4, 8, 9, 100]. You can move all piles from 1 and further to 9 and keep 100 at its place. So the answer is 8.
After the sixth query, the set becomes [1, 2, 4, 8, 9, 50, 100]. The answer is 49 and can be obtained with almost the same sequence of moves as after the previous query. The only difference is that you need to move all piles from 50 to 9 too. | instruction | 0 | 56,562 | 8 | 113,124 |
Tags: data structures, implementation
Correct Solution:
```
from bisect import bisect_left, bisect_right, insort
from functools import reduce
from operator import add, iadd
from itertools import chain, starmap, repeat
from math import log
class SortedList:
DEFAULT_LOAD_FACTOR = 1000
def __init__(self, iterable=None):
self._len = 0
self._load = self.DEFAULT_LOAD_FACTOR
self._lists = []
self._maxes = []
self._index = []
self._offset = 0
if iterable is not None:
self.update(iterable)
def clear(self):
self._len = 0
del self._lists[:]
del self._maxes[:]
del self._index[:]
self._offset = 0
def add(self, value):
_lists = self._lists
_maxes = self._maxes
if _maxes:
pos = bisect_right(_maxes, value)
if pos == len(_maxes):
pos -= 1
_lists[pos].append(value)
_maxes[pos] = value
else:
insort(_lists[pos], value)
self._expand(pos)
else:
_lists.append([value])
_maxes.append(value)
self._len += 1
def _expand(self, pos):
_load = self._load
_lists = self._lists
_index = self._index
if len(_lists[pos]) > (_load << 1):
_maxes = self._maxes
_lists_pos = _lists[pos]
half = _lists_pos[_load:]
del _lists_pos[_load:]
_maxes[pos] = _lists_pos[-1]
_lists.insert(pos + 1, half)
_maxes.insert(pos + 1, half[-1])
del _index[:]
else:
if _index:
child = self._offset + pos
while child:
_index[child] += 1
child = (child - 1) >> 1
_index[0] += 1
def update(self, iterable):
_lists = self._lists
_maxes = self._maxes
values = sorted(iterable)
if _maxes:
if len(values) * 4 >= self._len:
values.extend(chain.from_iterable(_lists))
values.sort()
self.clear()
else:
_add = self.add
for val in values:
_add(val)
return
_load = self._load
_lists.extend(values[pos:(pos + _load)]
for pos in range(0, len(values), _load))
_maxes.extend(sublist[-1] for sublist in _lists)
self._len = len(values)
del self._index[:]
def __contains__(self, value):
_maxes = self._maxes
if not _maxes:
return False
pos = bisect_left(_maxes, value)
if pos == len(_maxes):
return False
_lists = self._lists
idx = bisect_left(_lists[pos], value)
return _lists[pos][idx] == value
def discard(self, value):
_maxes = self._maxes
if not _maxes:
return
pos = bisect_left(_maxes, value)
if pos == len(_maxes):
return
_lists = self._lists
idx = bisect_left(_lists[pos], value)
if _lists[pos][idx] == value:
self._delete(pos, idx)
def remove(self, value):
_maxes = self._maxes
if not _maxes:
raise ValueError('{0!r} not in list'.format(value))
pos = bisect_left(_maxes, value)
if pos == len(_maxes):
raise ValueError('{0!r} not in list'.format(value))
_lists = self._lists
idx = bisect_left(_lists[pos], value)
if _lists[pos][idx] == value:
self._delete(pos, idx)
else:
raise ValueError('{0!r} not in list'.format(value))
def _delete(self, pos, idx):
_lists = self._lists
_maxes = self._maxes
_index = self._index
_lists_pos = _lists[pos]
del _lists_pos[idx]
self._len -= 1
len_lists_pos = len(_lists_pos)
if len_lists_pos > (self._load >> 1):
_maxes[pos] = _lists_pos[-1]
if _index:
child = self._offset + pos
while child > 0:
_index[child] -= 1
child = (child - 1) >> 1
_index[0] -= 1
elif len(_lists) > 1:
if not pos:
pos += 1
prev = pos - 1
_lists[prev].extend(_lists[pos])
_maxes[prev] = _lists[prev][-1]
del _lists[pos]
del _maxes[pos]
del _index[:]
self._expand(prev)
elif len_lists_pos:
_maxes[pos] = _lists_pos[-1]
else:
del _lists[pos]
del _maxes[pos]
del _index[:]
def _loc(self, pos, idx):
if not pos:
return idx
_index = self._index
if not _index:
self._build_index()
total = 0
pos += self._offset
while pos:
if not pos & 1:
total += _index[pos - 1]
pos = (pos - 1) >> 1
return total + idx
def _pos(self, idx):
if idx < 0:
last_len = len(self._lists[-1])
if (-idx) <= last_len:
return len(self._lists) - 1, last_len + idx
idx += self._len
if idx < 0:
raise IndexError('list index out of range')
elif idx >= self._len:
raise IndexError('list index out of range')
if idx < len(self._lists[0]):
return 0, idx
_index = self._index
if not _index:
self._build_index()
pos = 0
child = 1
len_index = len(_index)
while child < len_index:
index_child = _index[child]
if idx < index_child:
pos = child
else:
idx -= index_child
pos = child + 1
child = (pos << 1) + 1
return pos - self._offset, idx
def _build_index(self):
row0 = list(map(len, self._lists))
if len(row0) == 1:
self._index[:] = row0
self._offset = 0
return
head = iter(row0)
tail = iter(head)
row1 = list(starmap(add, zip(head, tail)))
if len(row0) & 1:
row1.append(row0[-1])
if len(row1) == 1:
self._index[:] = row1 + row0
self._offset = 1
return
size = 2 ** (int(log(len(row1) - 1, 2)) + 1)
row1.extend(repeat(0, size - len(row1)))
tree = [row0, row1]
while len(tree[-1]) > 1:
head = iter(tree[-1])
tail = iter(head)
row = list(starmap(add, zip(head, tail)))
tree.append(row)
reduce(iadd, reversed(tree), self._index)
self._offset = size * 2 - 1
def __delitem__(self, index):
if isinstance(index, slice):
start, stop, step = index.indices(self._len)
if step == 1 and start < stop:
if start == 0 and stop == self._len:
return self.clear()
elif self._len <= 8 * (stop - start):
values = self.__getitem__(slice(None, start))
if stop < self._len:
values += self.__getitem__(slice(stop, None))
self.clear()
return self.update(values)
indices = range(start, stop, step)
if step > 0:
indices = reversed(indices)
_pos, _delete = self._pos, self._delete
for index in indices:
pos, idx = _pos(index)
_delete(pos, idx)
else:
pos, idx = self._pos(index)
self._delete(pos, idx)
def __getitem__(self, index):
_lists = self._lists
if isinstance(index, slice):
start, stop, step = index.indices(self._len)
if step == 1 and start < stop:
if start == 0 and stop == self._len:
return reduce(iadd, self._lists, [])
start_pos, start_idx = self._pos(start)
start_list = _lists[start_pos]
stop_idx = start_idx + stop - start
if len(start_list) >= stop_idx:
return start_list[start_idx:stop_idx]
if stop == self._len:
stop_pos = len(_lists) - 1
stop_idx = len(_lists[stop_pos])
else:
stop_pos, stop_idx = self._pos(stop)
prefix = _lists[start_pos][start_idx:]
middle = _lists[(start_pos + 1):stop_pos]
result = reduce(iadd, middle, prefix)
result += _lists[stop_pos][:stop_idx]
return result
if step == -1 and start > stop:
result = self.__getitem__(slice(stop + 1, start + 1))
result.reverse()
return result
indices = range(start, stop, step)
return list(self.__getitem__(index) for index in indices)
else:
if self._len:
if index == 0:
return _lists[0][0]
elif index == -1:
return _lists[-1][-1]
else:
raise IndexError('list index out of range')
if 0 <= index < len(_lists[0]):
return _lists[0][index]
len_last = len(_lists[-1])
if -len_last < index < 0:
return _lists[-1][len_last + index]
pos, idx = self._pos(index)
return _lists[pos][idx]
def __setitem__(self, index, value):
message = 'use ``del sl[index]`` and ``sl.add(value)`` instead'
raise NotImplementedError(message)
def __iter__(self):
return chain.from_iterable(self._lists)
def __reversed__(self):
return chain.from_iterable(map(reversed, reversed(self._lists)))
def __len__(self):
return self._len
def pop(self, index=-1):
if not self._len:
raise IndexError('pop index out of range')
_lists = self._lists
if index == 0:
val = _lists[0][0]
self._delete(0, 0)
return val
if index == -1:
pos = len(_lists) - 1
loc = len(_lists[pos]) - 1
val = _lists[pos][loc]
self._delete(pos, loc)
return val
if 0 <= index < len(_lists[0]):
val = _lists[0][index]
self._delete(0, index)
return val
len_last = len(_lists[-1])
if -len_last < index < 0:
pos = len(_lists) - 1
loc = len_last + index
val = _lists[pos][loc]
self._delete(pos, loc)
return val
pos, idx = self._pos(index)
val = _lists[pos][idx]
self._delete(pos, idx)
return val
def index(self, value, start=None, stop=None):
_len = self._len
if not _len:
raise ValueError('{0!r} is not in list'.format(value))
if start is None:
start = 0
if start < 0:
start += _len
if start < 0:
start = 0
if stop is None:
stop = _len
if stop < 0:
stop += _len
if stop > _len:
stop = _len
if stop <= start:
raise ValueError('{0!r} is not in list'.format(value))
_maxes = self._maxes
pos_left = bisect_left(_maxes, value)
if pos_left == len(_maxes):
raise ValueError('{0!r} is not in list'.format(value))
_lists = self._lists
idx_left = bisect_left(_lists[pos_left], value)
if _lists[pos_left][idx_left] != value:
raise ValueError('{0!r} is not in list'.format(value))
stop -= 1
left = self._loc(pos_left, idx_left)
if start <= left:
if left <= stop:
return left
else:
right = self.bisect_right(value) - 1
if start <= right:
return start
raise ValueError('{0!r} is not in list'.format(value))
def bisect_right(self, value):
_maxes = self._maxes
if not _maxes:
return 0
pos = bisect_right(_maxes, value)
if pos == len(_maxes):
return self._len
idx = bisect_right(self._lists[pos], value)
return self._loc(pos, idx)
N, Q = map(int, input().split())
A = list(map(int, input().split()))
AS = SortedList(A)
DS = SortedList()
t = AS[0]
for a in AS[1:]:
DS.add(a - t)
t = a
if len(AS) > 2:
print(AS[-1] - AS[0] - DS[-1])
else:
print(0)
for _ in range(Q):
T, X = map(int, input().split())
if T == 0:
p = AS.index(X)
if len(AS) > 1:
if p == 0:
DS.discard(AS[1] - X)
elif p == len(AS) - 1:
DS.discard(X - AS[-2])
else:
DS.discard(X - AS[p - 1])
DS.discard(AS[p + 1] - X)
DS.add(AS[p + 1] - AS[p - 1])
AS.pop(p)
else:
AS.add(X)
p = AS.index(X)
if len(AS) > 1:
if p == 0:
DS.add(AS[1] - X)
elif p == len(AS) - 1:
DS.add(X - AS[-2])
else:
DS.add(X - AS[p - 1])
DS.add(AS[p + 1] - X)
DS.discard(AS[p + 1] - AS[p - 1])
if len(AS) > 2:
print(AS[-1] - AS[0] - DS[-1])
else:
print(0)
``` | output | 1 | 56,562 | 8 | 113,125 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.