message stringlengths 2 44.5k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 276 109k | cluster float64 23 23 | __index_level_0__ int64 552 217k |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a farm whose length and width are A yard and B yard, respectively. A farmer, John, made a vertical road and a horizontal road inside the farm from one border to another, as shown below: (The gray part represents the roads.)
What is the area of this yard excluding the roads? Find it.
Constraints
* A is an integer between 2 and 100 (inclusive).
* B is an integer between 2 and 100 (inclusive).
Input
Input is given from Standard Input in the following format:
A B
Output
Print the area of this yard excluding the roads (in square yards).
Examples
Input
2 2
Output
1
Input
5 7
Output
24
Submitted Solution:
```
source = input().split()
A,B = int(source[0]), int(source[1])
print(A*B-(A+B))
``` | instruction | 0 | 32,331 | 23 | 64,662 |
No | output | 1 | 32,331 | 23 | 64,663 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a farm whose length and width are A yard and B yard, respectively. A farmer, John, made a vertical road and a horizontal road inside the farm from one border to another, as shown below: (The gray part represents the roads.)
What is the area of this yard excluding the roads? Find it.
Constraints
* A is an integer between 2 and 100 (inclusive).
* B is an integer between 2 and 100 (inclusive).
Input
Input is given from Standard Input in the following format:
A B
Output
Print the area of this yard excluding the roads (in square yards).
Examples
Input
2 2
Output
1
Input
5 7
Output
24
Submitted Solution:
```
s = input().split()
a, b = int(s[0]),int(s[1])
print(a-1)*(b-1))
``` | instruction | 0 | 32,332 | 23 | 64,664 |
No | output | 1 | 32,332 | 23 | 64,665 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a farm whose length and width are A yard and B yard, respectively. A farmer, John, made a vertical road and a horizontal road inside the farm from one border to another, as shown below: (The gray part represents the roads.)
What is the area of this yard excluding the roads? Find it.
Constraints
* A is an integer between 2 and 100 (inclusive).
* B is an integer between 2 and 100 (inclusive).
Input
Input is given from Standard Input in the following format:
A B
Output
Print the area of this yard excluding the roads (in square yards).
Examples
Input
2 2
Output
1
Input
5 7
Output
24
Submitted Solution:
```
def reflesh_string(current_answer):
index = min(K, len(current_answer))
return current_answer[:index]
def update_string(string_answer):
string_answer = string_answer.replace("1", "1")
string_answer = string_answer.replace("2", "22")
string_answer = string_answer.replace("3", "333")
string_answer = string_answer.replace("4", "4444")
string_answer = string_answer.replace("5", "55555")
string_answer = string_answer.replace("6", "666666")
string_answer = string_answer.replace("7", "7777777")
string_answer = string_answer.replace("8", "88888888")
string_answer = string_answer.replace("9", "999999999")
return string_answer
def check_skip(current_answer):
counter = [0 for i in range(9)]
for i in range(1, 10):
i = str(i)
if(i in current_answer):
counter[int(i) - 1] = 1
if(sum(counter[1:]) > 1):
return False
if(counter[0] == 0)
return True
def ch_skip(current_answer):
for k in range(min(K, len(current_answer))):
if(int(current_answer[k]) != 1):
return False
return True
S = input().strip()
K = int(input().strip())
for c in range(5 * 10**15):
S = update_string(S)
S = reflesh_string(S)
if(check_skip(S)):
break
print(S[K-1])
``` | instruction | 0 | 32,333 | 23 | 64,666 |
No | output | 1 | 32,333 | 23 | 64,667 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a farm whose length and width are A yard and B yard, respectively. A farmer, John, made a vertical road and a horizontal road inside the farm from one border to another, as shown below: (The gray part represents the roads.)
What is the area of this yard excluding the roads? Find it.
Constraints
* A is an integer between 2 and 100 (inclusive).
* B is an integer between 2 and 100 (inclusive).
Input
Input is given from Standard Input in the following format:
A B
Output
Print the area of this yard excluding the roads (in square yards).
Examples
Input
2 2
Output
1
Input
5 7
Output
24
Submitted Solution:
```
S = input()
K = int(input())
L = [int(i) for i in S]
count = 1
for i in L:
if i != 1:
if count <= K:
print(i)
else:
print(1)
exit()
else:
count += 1
print(1)
``` | instruction | 0 | 32,334 | 23 | 64,668 |
No | output | 1 | 32,334 | 23 | 64,669 |
Provide a correct Python 3 solution for this coding contest problem.
We have a 3 \times 3 grid. A number c_{i, j} is written in the square (i, j), where (i, j) denotes the square at the i-th row from the top and the j-th column from the left.
According to Takahashi, there are six integers a_1, a_2, a_3, b_1, b_2, b_3 whose values are fixed, and the number written in the square (i, j) is equal to a_i + b_j.
Determine if he is correct.
Constraints
* c_{i, j} \ (1 \leq i \leq 3, 1 \leq j \leq 3) is an integer between 0 and 100 (inclusive).
Input
Input is given from Standard Input in the following format:
c_{1,1} c_{1,2} c_{1,3}
c_{2,1} c_{2,2} c_{2,3}
c_{3,1} c_{3,2} c_{3,3}
Output
If Takahashi's statement is correct, print `Yes`; otherwise, print `No`.
Examples
Input
1 0 1
2 1 2
1 0 1
Output
Yes
Input
2 2 2
2 1 2
2 2 2
Output
No
Input
0 8 8
0 8 8
0 8 8
Output
Yes
Input
1 8 6
2 9 7
0 7 7
Output
No | instruction | 0 | 32,335 | 23 | 64,670 |
"Correct Solution:
```
a=[list(map(int,input().split())) for i in range(3)]
for i in range(2):
for j in range(2):
if a[i][j]-a[i][j+1]==a[i+1][j]-a[i+1][j+1]:
continue
else:print("No");exit()
print("Yes")
``` | output | 1 | 32,335 | 23 | 64,671 |
Provide a correct Python 3 solution for this coding contest problem.
We have a 3 \times 3 grid. A number c_{i, j} is written in the square (i, j), where (i, j) denotes the square at the i-th row from the top and the j-th column from the left.
According to Takahashi, there are six integers a_1, a_2, a_3, b_1, b_2, b_3 whose values are fixed, and the number written in the square (i, j) is equal to a_i + b_j.
Determine if he is correct.
Constraints
* c_{i, j} \ (1 \leq i \leq 3, 1 \leq j \leq 3) is an integer between 0 and 100 (inclusive).
Input
Input is given from Standard Input in the following format:
c_{1,1} c_{1,2} c_{1,3}
c_{2,1} c_{2,2} c_{2,3}
c_{3,1} c_{3,2} c_{3,3}
Output
If Takahashi's statement is correct, print `Yes`; otherwise, print `No`.
Examples
Input
1 0 1
2 1 2
1 0 1
Output
Yes
Input
2 2 2
2 1 2
2 2 2
Output
No
Input
0 8 8
0 8 8
0 8 8
Output
Yes
Input
1 8 6
2 9 7
0 7 7
Output
No | instruction | 0 | 32,336 | 23 | 64,672 |
"Correct Solution:
```
c=[list(map(int,input().split())) for _ in range(3)]
for i in range(3):
for j in range(3):
if c[i][j]!=c[i][(j+1)%3]+c[(i+1)%3][j]-c[(i+1)%3][(j+1)%3]:
print('No')
exit()
print('Yes')
``` | output | 1 | 32,336 | 23 | 64,673 |
Provide a correct Python 3 solution for this coding contest problem.
We have a 3 \times 3 grid. A number c_{i, j} is written in the square (i, j), where (i, j) denotes the square at the i-th row from the top and the j-th column from the left.
According to Takahashi, there are six integers a_1, a_2, a_3, b_1, b_2, b_3 whose values are fixed, and the number written in the square (i, j) is equal to a_i + b_j.
Determine if he is correct.
Constraints
* c_{i, j} \ (1 \leq i \leq 3, 1 \leq j \leq 3) is an integer between 0 and 100 (inclusive).
Input
Input is given from Standard Input in the following format:
c_{1,1} c_{1,2} c_{1,3}
c_{2,1} c_{2,2} c_{2,3}
c_{3,1} c_{3,2} c_{3,3}
Output
If Takahashi's statement is correct, print `Yes`; otherwise, print `No`.
Examples
Input
1 0 1
2 1 2
1 0 1
Output
Yes
Input
2 2 2
2 1 2
2 2 2
Output
No
Input
0 8 8
0 8 8
0 8 8
Output
Yes
Input
1 8 6
2 9 7
0 7 7
Output
No | instruction | 0 | 32,337 | 23 | 64,674 |
"Correct Solution:
```
J=lambda:map(int,input().split());A,B,C=J();D,E,F=J();G,H,I=J();print("YNeos"[any([A-B-D+E,A-C-G+I,E-F-H+I])::2])
``` | output | 1 | 32,337 | 23 | 64,675 |
Provide a correct Python 3 solution for this coding contest problem.
We have a 3 \times 3 grid. A number c_{i, j} is written in the square (i, j), where (i, j) denotes the square at the i-th row from the top and the j-th column from the left.
According to Takahashi, there are six integers a_1, a_2, a_3, b_1, b_2, b_3 whose values are fixed, and the number written in the square (i, j) is equal to a_i + b_j.
Determine if he is correct.
Constraints
* c_{i, j} \ (1 \leq i \leq 3, 1 \leq j \leq 3) is an integer between 0 and 100 (inclusive).
Input
Input is given from Standard Input in the following format:
c_{1,1} c_{1,2} c_{1,3}
c_{2,1} c_{2,2} c_{2,3}
c_{3,1} c_{3,2} c_{3,3}
Output
If Takahashi's statement is correct, print `Yes`; otherwise, print `No`.
Examples
Input
1 0 1
2 1 2
1 0 1
Output
Yes
Input
2 2 2
2 1 2
2 2 2
Output
No
Input
0 8 8
0 8 8
0 8 8
Output
Yes
Input
1 8 6
2 9 7
0 7 7
Output
No | instruction | 0 | 32,339 | 23 | 64,678 |
"Correct Solution:
```
c = [list(map(int,input().split())) for i in range(3)]
d=[0,0,0]
ans='Yes'
for i in range(2):
for j in range(3):
d[j] = c[i+1][j]-c[i][j]
if d[0]==d[1] and d[0]==d[2]:
continue
else:
ans='No'
print(ans)
``` | output | 1 | 32,339 | 23 | 64,679 |
Provide a correct Python 3 solution for this coding contest problem.
We have a 3 \times 3 grid. A number c_{i, j} is written in the square (i, j), where (i, j) denotes the square at the i-th row from the top and the j-th column from the left.
According to Takahashi, there are six integers a_1, a_2, a_3, b_1, b_2, b_3 whose values are fixed, and the number written in the square (i, j) is equal to a_i + b_j.
Determine if he is correct.
Constraints
* c_{i, j} \ (1 \leq i \leq 3, 1 \leq j \leq 3) is an integer between 0 and 100 (inclusive).
Input
Input is given from Standard Input in the following format:
c_{1,1} c_{1,2} c_{1,3}
c_{2,1} c_{2,2} c_{2,3}
c_{3,1} c_{3,2} c_{3,3}
Output
If Takahashi's statement is correct, print `Yes`; otherwise, print `No`.
Examples
Input
1 0 1
2 1 2
1 0 1
Output
Yes
Input
2 2 2
2 1 2
2 2 2
Output
No
Input
0 8 8
0 8 8
0 8 8
Output
Yes
Input
1 8 6
2 9 7
0 7 7
Output
No | instruction | 0 | 32,340 | 23 | 64,680 |
"Correct Solution:
```
c = []
for i in range(3):
c.append(list(map(int, input().split())))
if(c[0][0] + c[1][1] + c[2][2] == c[0][1] + c[1][2] + c[2][0] == c[0][2] + c[1][0] + c[2][1]):
print("Yes")
else:
print("No")
``` | output | 1 | 32,340 | 23 | 64,681 |
Provide a correct Python 3 solution for this coding contest problem.
We have a 3 \times 3 grid. A number c_{i, j} is written in the square (i, j), where (i, j) denotes the square at the i-th row from the top and the j-th column from the left.
According to Takahashi, there are six integers a_1, a_2, a_3, b_1, b_2, b_3 whose values are fixed, and the number written in the square (i, j) is equal to a_i + b_j.
Determine if he is correct.
Constraints
* c_{i, j} \ (1 \leq i \leq 3, 1 \leq j \leq 3) is an integer between 0 and 100 (inclusive).
Input
Input is given from Standard Input in the following format:
c_{1,1} c_{1,2} c_{1,3}
c_{2,1} c_{2,2} c_{2,3}
c_{3,1} c_{3,2} c_{3,3}
Output
If Takahashi's statement is correct, print `Yes`; otherwise, print `No`.
Examples
Input
1 0 1
2 1 2
1 0 1
Output
Yes
Input
2 2 2
2 1 2
2 2 2
Output
No
Input
0 8 8
0 8 8
0 8 8
Output
Yes
Input
1 8 6
2 9 7
0 7 7
Output
No | instruction | 0 | 32,341 | 23 | 64,682 |
"Correct Solution:
```
C = [list(map(int,input().split())) for _ in range(3)]
ans = 'Yes'
for i in range(1,3):
for j in range(1,3):
if C[i][j]+C[0][0]!=C[i][0]+C[0][j]:
ans = 'No'
print(ans)
``` | output | 1 | 32,341 | 23 | 64,683 |
Provide a correct Python 3 solution for this coding contest problem.
We have a 3 \times 3 grid. A number c_{i, j} is written in the square (i, j), where (i, j) denotes the square at the i-th row from the top and the j-th column from the left.
According to Takahashi, there are six integers a_1, a_2, a_3, b_1, b_2, b_3 whose values are fixed, and the number written in the square (i, j) is equal to a_i + b_j.
Determine if he is correct.
Constraints
* c_{i, j} \ (1 \leq i \leq 3, 1 \leq j \leq 3) is an integer between 0 and 100 (inclusive).
Input
Input is given from Standard Input in the following format:
c_{1,1} c_{1,2} c_{1,3}
c_{2,1} c_{2,2} c_{2,3}
c_{3,1} c_{3,2} c_{3,3}
Output
If Takahashi's statement is correct, print `Yes`; otherwise, print `No`.
Examples
Input
1 0 1
2 1 2
1 0 1
Output
Yes
Input
2 2 2
2 1 2
2 2 2
Output
No
Input
0 8 8
0 8 8
0 8 8
Output
Yes
Input
1 8 6
2 9 7
0 7 7
Output
No | instruction | 0 | 32,342 | 23 | 64,684 |
"Correct Solution:
```
c = [list(map(int,input().split())) for k in range(3)]
if c[0][0] + c[1][1] != c[0][1] + c[1][0] or c[0][2] + c[2][0] != c[0][0] + c[2][2] or c[1][2] + c[2][1] != c[1][1] + c[2][2]:
print("No")
else:
print("Yes")
``` | output | 1 | 32,342 | 23 | 64,685 |
Provide a correct Python 3 solution for this coding contest problem.
Write a program which calculates the area and perimeter of a given rectangle.
Constraints
* 1 ≤ a, b ≤ 100
Input
The length a and breadth b of the rectangle are given in a line separated by a single space.
Output
Print the area and perimeter of the rectangle in a line. The two integers should be separated by a single space.
Example
Input
3 5
Output
15 16 | instruction | 0 | 32,476 | 23 | 64,952 |
"Correct Solution:
```
A,B=map(int,input().split())
print(A*B,(A+B)*2)
``` | output | 1 | 32,476 | 23 | 64,953 |
Provide a correct Python 3 solution for this coding contest problem.
Write a program which calculates the area and perimeter of a given rectangle.
Constraints
* 1 ≤ a, b ≤ 100
Input
The length a and breadth b of the rectangle are given in a line separated by a single space.
Output
Print the area and perimeter of the rectangle in a line. The two integers should be separated by a single space.
Example
Input
3 5
Output
15 16 | instruction | 0 | 32,477 | 23 | 64,954 |
"Correct Solution:
```
a, b = map(int, (input().split()))
print(a * b, a*2 + b*2)
``` | output | 1 | 32,477 | 23 | 64,955 |
Provide a correct Python 3 solution for this coding contest problem.
Write a program which calculates the area and perimeter of a given rectangle.
Constraints
* 1 ≤ a, b ≤ 100
Input
The length a and breadth b of the rectangle are given in a line separated by a single space.
Output
Print the area and perimeter of the rectangle in a line. The two integers should be separated by a single space.
Example
Input
3 5
Output
15 16 | instruction | 0 | 32,478 | 23 | 64,956 |
"Correct Solution:
```
a, b = map(int, input().split(' '))
print(a*b, 2*(a+b))
``` | output | 1 | 32,478 | 23 | 64,957 |
Provide a correct Python 3 solution for this coding contest problem.
Write a program which calculates the area and perimeter of a given rectangle.
Constraints
* 1 ≤ a, b ≤ 100
Input
The length a and breadth b of the rectangle are given in a line separated by a single space.
Output
Print the area and perimeter of the rectangle in a line. The two integers should be separated by a single space.
Example
Input
3 5
Output
15 16 | instruction | 0 | 32,479 | 23 | 64,958 |
"Correct Solution:
```
l=input()
a,b = list(map(int,l.split()))
print(a*b,2*(a+b))
``` | output | 1 | 32,479 | 23 | 64,959 |
Provide a correct Python 3 solution for this coding contest problem.
Write a program which calculates the area and perimeter of a given rectangle.
Constraints
* 1 ≤ a, b ≤ 100
Input
The length a and breadth b of the rectangle are given in a line separated by a single space.
Output
Print the area and perimeter of the rectangle in a line. The two integers should be separated by a single space.
Example
Input
3 5
Output
15 16 | instruction | 0 | 32,480 | 23 | 64,960 |
"Correct Solution:
```
l, s = map(int, input().split())
print(l*s,2*l+2*s)
``` | output | 1 | 32,480 | 23 | 64,961 |
Provide a correct Python 3 solution for this coding contest problem.
Write a program which calculates the area and perimeter of a given rectangle.
Constraints
* 1 ≤ a, b ≤ 100
Input
The length a and breadth b of the rectangle are given in a line separated by a single space.
Output
Print the area and perimeter of the rectangle in a line. The two integers should be separated by a single space.
Example
Input
3 5
Output
15 16 | instruction | 0 | 32,481 | 23 | 64,962 |
"Correct Solution:
```
a,b=map(int, input().split())
s=a*b
l=2*a+(2*b)
print(s,l)
``` | output | 1 | 32,481 | 23 | 64,963 |
Provide a correct Python 3 solution for this coding contest problem.
Write a program which calculates the area and perimeter of a given rectangle.
Constraints
* 1 ≤ a, b ≤ 100
Input
The length a and breadth b of the rectangle are given in a line separated by a single space.
Output
Print the area and perimeter of the rectangle in a line. The two integers should be separated by a single space.
Example
Input
3 5
Output
15 16 | instruction | 0 | 32,482 | 23 | 64,964 |
"Correct Solution:
```
w, h = map(int, input().split())
print(w * h, w * 2 + h * 2)
``` | output | 1 | 32,482 | 23 | 64,965 |
Provide a correct Python 3 solution for this coding contest problem.
Write a program which calculates the area and perimeter of a given rectangle.
Constraints
* 1 ≤ a, b ≤ 100
Input
The length a and breadth b of the rectangle are given in a line separated by a single space.
Output
Print the area and perimeter of the rectangle in a line. The two integers should be separated by a single space.
Example
Input
3 5
Output
15 16 | instruction | 0 | 32,483 | 23 | 64,966 |
"Correct Solution:
```
a,b=map(int, input().split())
print(a*b, (a+b)*2)
``` | output | 1 | 32,483 | 23 | 64,967 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Write a program which calculates the area and perimeter of a given rectangle.
Constraints
* 1 ≤ a, b ≤ 100
Input
The length a and breadth b of the rectangle are given in a line separated by a single space.
Output
Print the area and perimeter of the rectangle in a line. The two integers should be separated by a single space.
Example
Input
3 5
Output
15 16
Submitted Solution:
```
l=input().split(' ')
a=int(l[0])
b=int(l[1])
print(a*b,2*(a+b))
``` | instruction | 0 | 32,484 | 23 | 64,968 |
Yes | output | 1 | 32,484 | 23 | 64,969 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Write a program which calculates the area and perimeter of a given rectangle.
Constraints
* 1 ≤ a, b ≤ 100
Input
The length a and breadth b of the rectangle are given in a line separated by a single space.
Output
Print the area and perimeter of the rectangle in a line. The two integers should be separated by a single space.
Example
Input
3 5
Output
15 16
Submitted Solution:
```
a,b=map(int,input().split())
A=(a*b)
B=((a+b)*2)
print(A,B)
``` | instruction | 0 | 32,485 | 23 | 64,970 |
Yes | output | 1 | 32,485 | 23 | 64,971 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Write a program which calculates the area and perimeter of a given rectangle.
Constraints
* 1 ≤ a, b ≤ 100
Input
The length a and breadth b of the rectangle are given in a line separated by a single space.
Output
Print the area and perimeter of the rectangle in a line. The two integers should be separated by a single space.
Example
Input
3 5
Output
15 16
Submitted Solution:
```
n, m = map(int, input().split())
print(n*m, 2*n+2*m)
``` | instruction | 0 | 32,486 | 23 | 64,972 |
Yes | output | 1 | 32,486 | 23 | 64,973 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Write a program which calculates the area and perimeter of a given rectangle.
Constraints
* 1 ≤ a, b ≤ 100
Input
The length a and breadth b of the rectangle are given in a line separated by a single space.
Output
Print the area and perimeter of the rectangle in a line. The two integers should be separated by a single space.
Example
Input
3 5
Output
15 16
Submitted Solution:
```
a,b=map(int, input().split())
c,d = a*b, 2*(a+b)
print(c,d)
``` | instruction | 0 | 32,487 | 23 | 64,974 |
Yes | output | 1 | 32,487 | 23 | 64,975 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Write a program which calculates the area and perimeter of a given rectangle.
Constraints
* 1 ≤ a, b ≤ 100
Input
The length a and breadth b of the rectangle are given in a line separated by a single space.
Output
Print the area and perimeter of the rectangle in a line. The two integers should be separated by a single space.
Example
Input
3 5
Output
15 16
Submitted Solution:
```
#実際の計算
hight = int(3)
wide = int(5)
area = hight*wide
length = (hight+ｗide)*2
print(area)
print(length)
``` | instruction | 0 | 32,488 | 23 | 64,976 |
No | output | 1 | 32,488 | 23 | 64,977 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Write a program which calculates the area and perimeter of a given rectangle.
Constraints
* 1 ≤ a, b ≤ 100
Input
The length a and breadth b of the rectangle are given in a line separated by a single space.
Output
Print the area and perimeter of the rectangle in a line. The two integers should be separated by a single space.
Example
Input
3 5
Output
15 16
Submitted Solution:
```
import sys
args = sys.argv
a = int(args[1])
b = int(args[2])
def P(x,y):
print(x*y)
print(2*x+2*y)
return 0
P(a,b)
``` | instruction | 0 | 32,489 | 23 | 64,978 |
No | output | 1 | 32,489 | 23 | 64,979 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Write a program which calculates the area and perimeter of a given rectangle.
Constraints
* 1 ≤ a, b ≤ 100
Input
The length a and breadth b of the rectangle are given in a line separated by a single space.
Output
Print the area and perimeter of the rectangle in a line. The two integers should be separated by a single space.
Example
Input
3 5
Output
15 16
Submitted Solution:
```
a,b = map(int(),input().split())
print(a*b,2*(a+b))
``` | instruction | 0 | 32,490 | 23 | 64,980 |
No | output | 1 | 32,490 | 23 | 64,981 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Write a program which calculates the area and perimeter of a given rectangle.
Constraints
* 1 ≤ a, b ≤ 100
Input
The length a and breadth b of the rectangle are given in a line separated by a single space.
Output
Print the area and perimeter of the rectangle in a line. The two integers should be separated by a single space.
Example
Input
3 5
Output
15 16
Submitted Solution:
```
h, w = map(int, input().split())
print(h*w, 2*h+2*w)
``` | instruction | 0 | 32,491 | 23 | 64,982 |
No | output | 1 | 32,491 | 23 | 64,983 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya has got a magic matrix a of size n × m. The rows of the matrix are numbered from 1 to n from top to bottom, the columns are numbered from 1 to m from left to right. Let a_{ij} be the element in the intersection of the i-th row and the j-th column.
Vasya has also got a chip. Initially, the chip is in the intersection of the r-th row and the c-th column (that is, in the element a_{rc}). Vasya performs the following process as long as possible: among all elements of the matrix having their value less than the value of the element with the chip in it, Vasya randomly and equiprobably chooses one element and moves his chip to this element.
After moving the chip, he adds to his score the square of the Euclidean distance between these elements (that is, between the element in which the chip is now and the element the chip was moved from). The process ends when there are no elements having their values less than the value of the element with the chip in it.
Euclidean distance between matrix elements with coordinates (i_1, j_1) and (i_2, j_2) is equal to √{(i_1-i_2)^2 + (j_1-j_2)^2}.
Calculate the expected value of the Vasya's final score.
It can be shown that the answer can be represented as P/Q, where P and Q are coprime integer numbers, and Q not≡ 0~(mod ~ 998244353). Print the value P ⋅ Q^{-1} modulo 998244353.
Input
The first line of the input contains two integers n and m (1 ≤ n, m ≤ 1 000) — the number of rows and the number of columns in the matrix a.
The following n lines contain description of the matrix a. The i-th line contains m integers a_{i1}, a_{i2}, ..., a_{im} ~ (0 ≤ a_{ij} ≤ 10^9).
The following line contains two integers r and c (1 ≤ r ≤ n, 1 ≤ c ≤ m) — the index of row and the index of column where the chip is now.
Output
Print the expected value of Vasya's final score in the format described in the problem statement.
Examples
Input
1 4
1 1 2 1
1 3
Output
2
Input
2 3
1 5 7
2 3 1
1 2
Output
665496238
Note
In the first example, Vasya will move his chip exactly once. The expected value of the final score is equal to (1^2 + 2^2+ 1^2)/(3) = 2.
Submitted Solution:
```
import io
import os
import sys
# Trying to speed up c1729, which in turn is trying to speed up pajenegod's submissions
# which in turn is trying to speed up meooows code
a = os.read(0, os.fstat(0).st_size)
# Speed
inp = []
i = 0
numb = 0
try:
while True:
if a[i] >= b'0' [0]:
numb = 10 * numb + a[i] - 48
elif a[i] != b'\r' [0]:
inp.append(numb)
numb = 0
i += 1
except:
pass
if a and a[-1] >= b'0' [0]:
inp.append(numb)
ii = 0
def mergesort(A):
B, n = A[:], len(A)
for i in range(0,n-1,2):
if A[i^1]<A[i]:
A[i],A[i^1] = A[i^1],A[i]
width = 2
while width < n:
for i in range(0, n, 2 * width):
right, end = min(i + width, n), min(i + 2 * width, n)
j = right
for k in range(i, end):
if i < right and (j >= end or A[i] <= A[j]):
B[k] = A[i]
i += 1
else:
B[k] = A[j]
j += 1
A,B = B,A
width *= 2
return A
# Using pajenegod's floating point mod mul
MOD = 998244353
MODF = float(MOD)
MAGIC = 6755399441055744.0
SHRT = 65536.0
MODF_INV = 1.0 / MODF
SHRT_INV = 1.0 / SHRT
fround = lambda x: (x + MAGIC) - MAGIC
fmod = lambda a: a - MODF * fround(MODF_INV * a)
fmul = lambda a, b, c=0.0: fmod(fmod(a * SHRT) * fround(SHRT_INV * b) + a * (b - SHRT * fround(b * SHRT_INV)) + c)
def fpow(x, y):
if y == 0:
return 1.0
res = 1.0
while y > 1:
if y & 1 == 1:
res = fmul(res, x)
x = fmul(x, x)
y >>= 1
return fmul(res, x)
n, m = inp[ii], inp[ii + 1]
ii += 2
a = inp[ii:ii + n * m]
ii += n * m
# try this against vanilla sort
a = [(a[i], i) for i in range(n * m)]
a = mergesort(a)
sx, sy = inp[ii], inp[ii + 1]
ii += 2
MX = n * m + 1
inv = [0.0] * MX
inv[1] = 1.0
for i in range(2, MX):
inv[i] = fmul(-1.0 * (MOD // i), inv[MOD % i])
fsum = isum = i2sum = jsum = j2sum = 0
cnt = 0
inv_cnt = 0.0
i = 0
fa = [0] * (n * m)
while i < n * m:
j = i + 1
while j < n * m and a[i][0] == a[j][0]:
j += 1
for k in range(i, j):
x, y = divmod(a[k][1], m)
x += 1
y += 1
f = fmul(1.0 * cnt, 1.0 * (x * x + y * y), i2sum + j2sum + fsum - 2.0 * (x * isum + y * jsum))
f = fmul(f, inv_cnt)
if sx == x and sy == y:
print(int(f + MODF) % MOD)
sys.exit()
fa[k] = int(f)
for k in range(i, j):
x, y = divmod(a[k][1], m)
x += 1.0
y += 1.0
fsum = (fa[k] + fsum) % MOD
isum += x
i2sum += x * x
jsum += y
j2sum += y * y
cnt += j - i
inv_cnt = inv[cnt]
i = j
``` | instruction | 0 | 32,516 | 23 | 65,032 |
Yes | output | 1 | 32,516 | 23 | 65,033 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya has got a magic matrix a of size n × m. The rows of the matrix are numbered from 1 to n from top to bottom, the columns are numbered from 1 to m from left to right. Let a_{ij} be the element in the intersection of the i-th row and the j-th column.
Vasya has also got a chip. Initially, the chip is in the intersection of the r-th row and the c-th column (that is, in the element a_{rc}). Vasya performs the following process as long as possible: among all elements of the matrix having their value less than the value of the element with the chip in it, Vasya randomly and equiprobably chooses one element and moves his chip to this element.
After moving the chip, he adds to his score the square of the Euclidean distance between these elements (that is, between the element in which the chip is now and the element the chip was moved from). The process ends when there are no elements having their values less than the value of the element with the chip in it.
Euclidean distance between matrix elements with coordinates (i_1, j_1) and (i_2, j_2) is equal to √{(i_1-i_2)^2 + (j_1-j_2)^2}.
Calculate the expected value of the Vasya's final score.
It can be shown that the answer can be represented as P/Q, where P and Q are coprime integer numbers, and Q not≡ 0~(mod ~ 998244353). Print the value P ⋅ Q^{-1} modulo 998244353.
Input
The first line of the input contains two integers n and m (1 ≤ n, m ≤ 1 000) — the number of rows and the number of columns in the matrix a.
The following n lines contain description of the matrix a. The i-th line contains m integers a_{i1}, a_{i2}, ..., a_{im} ~ (0 ≤ a_{ij} ≤ 10^9).
The following line contains two integers r and c (1 ≤ r ≤ n, 1 ≤ c ≤ m) — the index of row and the index of column where the chip is now.
Output
Print the expected value of Vasya's final score in the format described in the problem statement.
Examples
Input
1 4
1 1 2 1
1 3
Output
2
Input
2 3
1 5 7
2 3 1
1 2
Output
665496238
Note
In the first example, Vasya will move his chip exactly once. The expected value of the final score is equal to (1^2 + 2^2+ 1^2)/(3) = 2.
Submitted Solution:
```
import io
import os
import sys
# Trying to speed up c1729, which in turn is trying to speed up pajenegod's submissions
# which in turn is trying to speed up meooows code
a = os.read(0, os.fstat(0).st_size)
# Speed
inp = []
i = 0
numb = 0
try:
while True:
if a[i] >= b'0' [0]:
numb = 10 * numb + a[i] - 48
elif a[i] != b'\r' [0]:
inp.append(numb)
numb = 0
i += 1
except:
pass
if a and a[-1] >= b'0' [0]:
inp.append(numb)
ii = 0
# Homemade stable mergesort
def mergesort(A, key=lambda x: x, reverse=False):
B, n = A[:], len(A)
for i in range(0, n - 1, 2):
if key(A[i]) > key(A[i ^ 1]):
A[i], A[i ^ 1] = A[i ^ 1], A[i]
width = 2
while width < n:
for i in range(0, n, 2 * width):
R1 = j = min(i + width, n)
R2 = min(i + 2 * width, n)
k = i
while i < R1 and j < R2:
if key(A[i]) > key(A[j]):
B[k] = A[j]
j += 1
else:
B[k] = A[i]
i += 1
k += 1
while i < R1:
B[k] = A[i]
k += 1
i += 1
while k < R2:
B[k] = A[k]
k += 1
A, B = B, A
width *= 2
if reverse:
A.reverse()
return A
# Using pajenegod's floating point mod mul
MOD = 998244353
MODF = float(MOD)
MAGIC = 6755399441055744.0
SHRT = 65536.0
MODF_INV = 1.0 / MODF
SHRT_INV = 1.0 / SHRT
fround = lambda x: (x + MAGIC) - MAGIC
fmod = lambda a: a - MODF * fround(MODF_INV * a)
fmul = lambda a, b, c=0.0: fmod(fmod(a * SHRT) * fround(SHRT_INV * b) + a * (b - SHRT * fround(b * SHRT_INV)) + c)
def fpow(x, y):
if y == 0:
return 1.0
res = 1.0
while y > 1:
if y & 1 == 1:
res = fmul(res, x)
x = fmul(x, x)
y >>= 1
return fmul(res, x)
n, m = inp[ii], inp[ii + 1]
ii += 2
a = inp[ii:ii + n * m]
ii += n * m
# try this against vanilla sort
order = mergesort(list(range(n * m)), key=lambda x: a[x])
sx, sy = inp[ii], inp[ii + 1]
ii += 2
MX = n * m + 1
inv = [0.0] * MX
inv[1] = 1.0
for i in range(2, MX):
inv[i] = fmul(-1.0 * (MOD // i), inv[MOD % i])
fsum = isum = i2sum = jsum = j2sum = 0
cnt = 0
inv_cnt = 0.0
i = 0
fa = [0] * (n * m)
while i < n * m:
j = i + 1
while j < n * m and a[order[i]] == a[order[j]]:
j += 1
for k in range(i, j):
x, y = divmod(order[k], m)
x += 1
y += 1
f = fmul(1.0 * cnt, 1.0 * (x * x + y * y), i2sum + j2sum + fsum - 2.0 * (x * isum + y * jsum))
f = fmul(f, inv_cnt)
if sx == x and sy == y:
print(int(f + MODF) % MOD)
sys.exit()
fa[k] = int(f)
for k in range(i, j):
x, y = divmod(order[k], m)
x += 1.0
y += 1.0
fsum = (fa[k] + fsum) % MOD
isum += x
i2sum += x * x
jsum += y
j2sum += y * y
cnt += j - i
inv_cnt = inv[cnt]
i = j
``` | instruction | 0 | 32,517 | 23 | 65,034 |
Yes | output | 1 | 32,517 | 23 | 65,035 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya has got a magic matrix a of size n × m. The rows of the matrix are numbered from 1 to n from top to bottom, the columns are numbered from 1 to m from left to right. Let a_{ij} be the element in the intersection of the i-th row and the j-th column.
Vasya has also got a chip. Initially, the chip is in the intersection of the r-th row and the c-th column (that is, in the element a_{rc}). Vasya performs the following process as long as possible: among all elements of the matrix having their value less than the value of the element with the chip in it, Vasya randomly and equiprobably chooses one element and moves his chip to this element.
After moving the chip, he adds to his score the square of the Euclidean distance between these elements (that is, between the element in which the chip is now and the element the chip was moved from). The process ends when there are no elements having their values less than the value of the element with the chip in it.
Euclidean distance between matrix elements with coordinates (i_1, j_1) and (i_2, j_2) is equal to √{(i_1-i_2)^2 + (j_1-j_2)^2}.
Calculate the expected value of the Vasya's final score.
It can be shown that the answer can be represented as P/Q, where P and Q are coprime integer numbers, and Q not≡ 0~(mod ~ 998244353). Print the value P ⋅ Q^{-1} modulo 998244353.
Input
The first line of the input contains two integers n and m (1 ≤ n, m ≤ 1 000) — the number of rows and the number of columns in the matrix a.
The following n lines contain description of the matrix a. The i-th line contains m integers a_{i1}, a_{i2}, ..., a_{im} ~ (0 ≤ a_{ij} ≤ 10^9).
The following line contains two integers r and c (1 ≤ r ≤ n, 1 ≤ c ≤ m) — the index of row and the index of column where the chip is now.
Output
Print the expected value of Vasya's final score in the format described in the problem statement.
Examples
Input
1 4
1 1 2 1
1 3
Output
2
Input
2 3
1 5 7
2 3 1
1 2
Output
665496238
Note
In the first example, Vasya will move his chip exactly once. The expected value of the final score is equal to (1^2 + 2^2+ 1^2)/(3) = 2.
Submitted Solution:
```
import io
import os
import sys
# Trying to speed up c1729, which in turn is trying to speed up pajenegod's submissions
# which in turn is trying to speed up meooows code
a = os.read(0, os.fstat(0).st_size)
# Speed
inp = []
i = 0
numb = 0
try:
while True:
if a[i] >= b'0' [0]:
numb = 10 * numb + a[i] - 48
elif a[i] != b'\r' [0]:
inp.append(numb)
numb = 0
i += 1
except:
pass
if a and a[-1] >= b'0' [0]:
inp.append(numb)
ii = 0
# Homemade mergesort
def mergesort(A,ls_cmp=None):
if ls_cmp is None:
ls_cmp = lambda i,j: i<j
B, n = A[:], len(A)
for i in range(0,n-1,2):
if ls_cmp(A[i^1],A[i]):
A[i],A[i^1] = A[i^1],A[i]
width = 2
while width < n:
for i in range(0, n, 2*width):
R1 = j = min(i + width, n)
R2 = min(i + 2 * width, n)
k = i
while i<R1 and j<R2:
if ls_cmp(A[i],A[j]):
B[k] = A[i]
i += 1
else:
B[k] = A[j]
j += 1
k += 1
while i<R1:
B[k] = A[i]
k += 1
i += 1
while k<R2:
B[k] = A[k]
k += 1
A,B = B,A
width *= 2
return A
# Using pajenegod's floating point mod mul
MOD = 998244353
MODF = float(MOD)
MAGIC = 6755399441055744.0
SHRT = 65536.0
MODF_INV = 1.0 / MODF
SHRT_INV = 1.0 / SHRT
fround = lambda x: (x + MAGIC) - MAGIC
fmod = lambda a: a - MODF * fround(MODF_INV * a)
fmul = lambda a, b, c=0.0: fmod(fmod(a * SHRT) * fround(SHRT_INV * b) + a * (b - SHRT * fround(b * SHRT_INV)) + c)
def fpow(x, y):
if y == 0:
return 1.0
res = 1.0
while y > 1:
if y & 1 == 1:
res = fmul(res, x)
x = fmul(x, x)
y >>= 1
return fmul(res, x)
n, m = inp[ii], inp[ii + 1]
ii += 2
a = inp[ii:ii + n * m]
ii += n * m
# try this against vanilla sort
a = [(a[i], i) for i in range(n * m)]
a = mergesort(a)
sx, sy = inp[ii], inp[ii + 1]
ii += 2
MX = n * m + 1
inv = [0.0] * MX
inv[1] = 1.0
for i in range(2, MX):
inv[i] = fmul(-1.0 * (MOD // i), inv[MOD % i])
fsum = isum = i2sum = jsum = j2sum = 0
cnt = 0
inv_cnt = 0.0
i = 0
fa = [0] * (n * m)
while i < n * m:
j = i + 1
while j < n * m and a[i][0] == a[j][0]:
j += 1
for k in range(i, j):
x, y = divmod(a[k][1], m)
x += 1
y += 1
f = fmul(1.0 * cnt, 1.0 * (x * x + y * y), i2sum + j2sum + fsum - 2.0 * (x * isum + y * jsum))
f = fmul(f, inv_cnt)
if sx == x and sy == y:
print(int(f + MODF) % MOD)
sys.exit()
fa[k] = int(f)
for k in range(i, j):
x, y = divmod(a[k][1], m)
x += 1.0
y += 1.0
fsum = (fa[k] + fsum) % MOD
isum += x
i2sum += x * x
jsum += y
j2sum += y * y
cnt += j - i
inv_cnt = inv[cnt]
i = j
``` | instruction | 0 | 32,518 | 23 | 65,036 |
Yes | output | 1 | 32,518 | 23 | 65,037 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya has got a magic matrix a of size n × m. The rows of the matrix are numbered from 1 to n from top to bottom, the columns are numbered from 1 to m from left to right. Let a_{ij} be the element in the intersection of the i-th row and the j-th column.
Vasya has also got a chip. Initially, the chip is in the intersection of the r-th row and the c-th column (that is, in the element a_{rc}). Vasya performs the following process as long as possible: among all elements of the matrix having their value less than the value of the element with the chip in it, Vasya randomly and equiprobably chooses one element and moves his chip to this element.
After moving the chip, he adds to his score the square of the Euclidean distance between these elements (that is, between the element in which the chip is now and the element the chip was moved from). The process ends when there are no elements having their values less than the value of the element with the chip in it.
Euclidean distance between matrix elements with coordinates (i_1, j_1) and (i_2, j_2) is equal to √{(i_1-i_2)^2 + (j_1-j_2)^2}.
Calculate the expected value of the Vasya's final score.
It can be shown that the answer can be represented as P/Q, where P and Q are coprime integer numbers, and Q not≡ 0~(mod ~ 998244353). Print the value P ⋅ Q^{-1} modulo 998244353.
Input
The first line of the input contains two integers n and m (1 ≤ n, m ≤ 1 000) — the number of rows and the number of columns in the matrix a.
The following n lines contain description of the matrix a. The i-th line contains m integers a_{i1}, a_{i2}, ..., a_{im} ~ (0 ≤ a_{ij} ≤ 10^9).
The following line contains two integers r and c (1 ≤ r ≤ n, 1 ≤ c ≤ m) — the index of row and the index of column where the chip is now.
Output
Print the expected value of Vasya's final score in the format described in the problem statement.
Examples
Input
1 4
1 1 2 1
1 3
Output
2
Input
2 3
1 5 7
2 3 1
1 2
Output
665496238
Note
In the first example, Vasya will move his chip exactly once. The expected value of the final score is equal to (1^2 + 2^2+ 1^2)/(3) = 2.
Submitted Solution:
```
import io
import os
import sys
# Trying to speed up c1729, which in turn is trying to speed up pajenegod's submissions
# which in turn is trying to speed up meooows code
a = os.read(0, os.fstat(0).st_size)
# Speed
inp = []
i = 0
numb = 0
try:
while True:
if a[i] >= b'0' [0]:
numb = 10 * numb + a[i] - 48
elif a[i] != b'\r' [0]:
inp.append(numb)
numb = 0
i += 1
except:
pass
if a and a[-1] >= b'0' [0]:
inp.append(numb)
ii = 0
# Homemade stable mergesort
def mergesort(A, gt_cmp=None):
if gt_cmp is None:
gt_cmp = lambda i,j: i>j
B, n = A[:], len(A)
for i in range(0,n-1,2):
if gt_cmp(A[i],A[i^1]):
A[i],A[i^1] = A[i^1],A[i]
width = 2
while width < n:
for i in range(0,n, 2*width):
R1 = j = min(i + width, n)
R2 = min(i + 2 * width, n)
k = i
while i<R1 and j<R2:
if gt_cmp(A[i],A[j]):
B[k] = A[j]
j += 1
else:
B[k] = A[i]
i += 1
k += 1
while i<R1:
B[k] = A[i]
k += 1
i += 1
while k<R2:
B[k] = A[k]
k += 1
A,B = B,A
width *= 2
return A
# Using pajenegod's floating point mod mul
MOD = 998244353
MODF = float(MOD)
MAGIC = 6755399441055744.0
SHRT = 65536.0
MODF_INV = 1.0 / MODF
SHRT_INV = 1.0 / SHRT
fround = lambda x: (x + MAGIC) - MAGIC
fmod = lambda a: a - MODF * fround(MODF_INV * a)
fmul = lambda a, b, c=0.0: fmod(fmod(a * SHRT) * fround(SHRT_INV * b) + a * (b - SHRT * fround(b * SHRT_INV)) + c)
def fpow(x, y):
if y == 0:
return 1.0
res = 1.0
while y > 1:
if y & 1 == 1:
res = fmul(res, x)
x = fmul(x, x)
y >>= 1
return fmul(res, x)
n, m = inp[ii], inp[ii + 1]
ii += 2
a = inp[ii:ii + n * m]
ii += n * m
# try this against vanilla sort
order = mergesort(list(range(n*m)), lambda i,j:a[i]>a[j])
sx, sy = inp[ii], inp[ii + 1]
ii += 2
MX = n * m + 1
inv = [0.0] * MX
inv[1] = 1.0
for i in range(2, MX):
inv[i] = fmul(-1.0 * (MOD // i), inv[MOD % i])
fsum = isum = i2sum = jsum = j2sum = 0
cnt = 0
inv_cnt = 0.0
i = 0
fa = [0] * (n * m)
while i < n * m:
j = i + 1
while j < n * m and a[order[i]] == a[order[j]]:
j += 1
for k in range(i, j):
x, y = divmod(order[k], m)
x += 1
y += 1
f = fmul(1.0 * cnt, 1.0 * (x * x + y * y), i2sum + j2sum + fsum - 2.0 * (x * isum + y * jsum))
f = fmul(f, inv_cnt)
if sx == x and sy == y:
print(int(f + MODF) % MOD)
sys.exit()
fa[k] = int(f)
for k in range(i, j):
x, y = divmod(order[k], m)
x += 1.0
y += 1.0
fsum = (fa[k] + fsum) % MOD
isum += x
i2sum += x * x
jsum += y
j2sum += y * y
cnt += j - i
inv_cnt = inv[cnt]
i = j
``` | instruction | 0 | 32,519 | 23 | 65,038 |
Yes | output | 1 | 32,519 | 23 | 65,039 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya has got a magic matrix a of size n × m. The rows of the matrix are numbered from 1 to n from top to bottom, the columns are numbered from 1 to m from left to right. Let a_{ij} be the element in the intersection of the i-th row and the j-th column.
Vasya has also got a chip. Initially, the chip is in the intersection of the r-th row and the c-th column (that is, in the element a_{rc}). Vasya performs the following process as long as possible: among all elements of the matrix having their value less than the value of the element with the chip in it, Vasya randomly and equiprobably chooses one element and moves his chip to this element.
After moving the chip, he adds to his score the square of the Euclidean distance between these elements (that is, between the element in which the chip is now and the element the chip was moved from). The process ends when there are no elements having their values less than the value of the element with the chip in it.
Euclidean distance between matrix elements with coordinates (i_1, j_1) and (i_2, j_2) is equal to √{(i_1-i_2)^2 + (j_1-j_2)^2}.
Calculate the expected value of the Vasya's final score.
It can be shown that the answer can be represented as P/Q, where P and Q are coprime integer numbers, and Q not≡ 0~(mod ~ 998244353). Print the value P ⋅ Q^{-1} modulo 998244353.
Input
The first line of the input contains two integers n and m (1 ≤ n, m ≤ 1 000) — the number of rows and the number of columns in the matrix a.
The following n lines contain description of the matrix a. The i-th line contains m integers a_{i1}, a_{i2}, ..., a_{im} ~ (0 ≤ a_{ij} ≤ 10^9).
The following line contains two integers r and c (1 ≤ r ≤ n, 1 ≤ c ≤ m) — the index of row and the index of column where the chip is now.
Output
Print the expected value of Vasya's final score in the format described in the problem statement.
Examples
Input
1 4
1 1 2 1
1 3
Output
2
Input
2 3
1 5 7
2 3 1
1 2
Output
665496238
Note
In the first example, Vasya will move his chip exactly once. The expected value of the final score is equal to (1^2 + 2^2+ 1^2)/(3) = 2.
Submitted Solution:
```
def inv(a,m=998244353):
if a<0:
a+=m
else:
a%=m
return a if a == 1 else (m - (inv(m, a)) * (m) / a)
n,m=map(int,input().split())
List=[]
for i in range(n):
k=0
for j in input().split():
List.append([int(j),i,k])
k+=1
r,c=map(int,input().split())
value=List[r*c-1]
List.sort(key=lambda x:x[0])
n=List.index(value)
Dp=[0 for i in range(10**6)]
MX=10**6
MOD=998244353
inv = [1] * MX
for i in range(2, MX):
inv[i] = -(MOD // i) * inv[MOD % i] % MOD
for i in range(n+1):
num=0
for j in range(i):
if List[i][0]>List[j][0]:
Dp[i]+=((List[i][1]%MOD-List[j][1]%MOD)**2%MOD+(List[i][2]%MOD-List[j][2]%MOD)**2%MOD)+Dp[j]
Dp[i]%=MOD
num+=1
if num>0:
Dp[i]=int(((Dp[i]%MOD)*(inv[num]%MOD))%MOD)
print(Dp[n])
``` | instruction | 0 | 32,520 | 23 | 65,040 |
No | output | 1 | 32,520 | 23 | 65,041 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya has got a magic matrix a of size n × m. The rows of the matrix are numbered from 1 to n from top to bottom, the columns are numbered from 1 to m from left to right. Let a_{ij} be the element in the intersection of the i-th row and the j-th column.
Vasya has also got a chip. Initially, the chip is in the intersection of the r-th row and the c-th column (that is, in the element a_{rc}). Vasya performs the following process as long as possible: among all elements of the matrix having their value less than the value of the element with the chip in it, Vasya randomly and equiprobably chooses one element and moves his chip to this element.
After moving the chip, he adds to his score the square of the Euclidean distance between these elements (that is, between the element in which the chip is now and the element the chip was moved from). The process ends when there are no elements having their values less than the value of the element with the chip in it.
Euclidean distance between matrix elements with coordinates (i_1, j_1) and (i_2, j_2) is equal to √{(i_1-i_2)^2 + (j_1-j_2)^2}.
Calculate the expected value of the Vasya's final score.
It can be shown that the answer can be represented as P/Q, where P and Q are coprime integer numbers, and Q not≡ 0~(mod ~ 998244353). Print the value P ⋅ Q^{-1} modulo 998244353.
Input
The first line of the input contains two integers n and m (1 ≤ n, m ≤ 1 000) — the number of rows and the number of columns in the matrix a.
The following n lines contain description of the matrix a. The i-th line contains m integers a_{i1}, a_{i2}, ..., a_{im} ~ (0 ≤ a_{ij} ≤ 10^9).
The following line contains two integers r and c (1 ≤ r ≤ n, 1 ≤ c ≤ m) — the index of row and the index of column where the chip is now.
Output
Print the expected value of Vasya's final score in the format described in the problem statement.
Examples
Input
1 4
1 1 2 1
1 3
Output
2
Input
2 3
1 5 7
2 3 1
1 2
Output
665496238
Note
In the first example, Vasya will move his chip exactly once. The expected value of the final score is equal to (1^2 + 2^2+ 1^2)/(3) = 2.
Submitted Solution:
```
import io, os
ns = iter(os.read(0, os.fstat(0).st_size).split()).__next__
n,m=int(ns()), int(ns())
List = [[int(ns()),i] for i in range(n * m)]
MX=10**6
mod=998244353
r,c=int(ns()), int(ns())
List.sort(key=lambda x:x[0])
print(List)
Dp=[0 for i in range(n*m+1)]
inv = [1] * MX
for i in range(2, MX):
inv[i] = -(mod // i) * inv[mod % i] % mod
for i in range(n*m):
cnt=0
for j in range(i):
if List[i][0]>List[j][0]:
x1,y1=divmod(List[j][1],m)
x,y=divmod(List[i][1],m)
Dp[i]+=((x-x1)**2+(y-y1)**2+Dp[j])%mod
cnt+=1
Dp[i]*=inv[cnt]
Dp[i]%=mod
if List[i][1]==(r)*(c)-1:
print(Dp[i])
exit()
``` | instruction | 0 | 32,521 | 23 | 65,042 |
No | output | 1 | 32,521 | 23 | 65,043 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya has got a magic matrix a of size n × m. The rows of the matrix are numbered from 1 to n from top to bottom, the columns are numbered from 1 to m from left to right. Let a_{ij} be the element in the intersection of the i-th row and the j-th column.
Vasya has also got a chip. Initially, the chip is in the intersection of the r-th row and the c-th column (that is, in the element a_{rc}). Vasya performs the following process as long as possible: among all elements of the matrix having their value less than the value of the element with the chip in it, Vasya randomly and equiprobably chooses one element and moves his chip to this element.
After moving the chip, he adds to his score the square of the Euclidean distance between these elements (that is, between the element in which the chip is now and the element the chip was moved from). The process ends when there are no elements having their values less than the value of the element with the chip in it.
Euclidean distance between matrix elements with coordinates (i_1, j_1) and (i_2, j_2) is equal to √{(i_1-i_2)^2 + (j_1-j_2)^2}.
Calculate the expected value of the Vasya's final score.
It can be shown that the answer can be represented as P/Q, where P and Q are coprime integer numbers, and Q not≡ 0~(mod ~ 998244353). Print the value P ⋅ Q^{-1} modulo 998244353.
Input
The first line of the input contains two integers n and m (1 ≤ n, m ≤ 1 000) — the number of rows and the number of columns in the matrix a.
The following n lines contain description of the matrix a. The i-th line contains m integers a_{i1}, a_{i2}, ..., a_{im} ~ (0 ≤ a_{ij} ≤ 10^9).
The following line contains two integers r and c (1 ≤ r ≤ n, 1 ≤ c ≤ m) — the index of row and the index of column where the chip is now.
Output
Print the expected value of Vasya's final score in the format described in the problem statement.
Examples
Input
1 4
1 1 2 1
1 3
Output
2
Input
2 3
1 5 7
2 3 1
1 2
Output
665496238
Note
In the first example, Vasya will move his chip exactly once. The expected value of the final score is equal to (1^2 + 2^2+ 1^2)/(3) = 2.
Submitted Solution:
```
import io
import os
import sys
# Trying to speed up c1729, which in turn is trying to speed up pajenegod's submissions
# which in turn is trying to speed up meooows code
a = os.read(0, os.fstat(0).st_size)
# Speed
inp = []
i = 0
numb = 0
try:
while True:
if a[i] >= b'0' [0]:
numb = 10 * numb + a[i] - 48
elif a[i] != b'\r' [0]:
inp.append(numb)
numb = 0
i += 1
except:
pass
if a and a[-1] >= b'0' [0]:
inp.append(numb)
ii = 0
# Homemade stable mergesort
def mergesort(A, key=lambda x: x, reverse=False):
B, n = A[:], len(A)
for i in range(0, n - 1, 2):
if key(A[i]) > key(A[i ^ 1]):
A[i], A[i ^ 1] = A[i ^ 1], A[i]
width = 2
while width < n:
for i in range(0, n, 2 * width):
R1 = j = min(i + width, n)
R2 = min(i + 2 * width, n)
k = i
while i < R1 and j < R2:
if key(A[i]) > key(A[j]):
B[k] = A[j]
j += 1
else:
B[k] = A[i]
i += 1
k += 1
while i < R1:
B[k] = A[i]
k += 1
i += 1
while k < R2:
B[k] = A[k]
k += 1
A, B = B, A
width *= 2
if reverse:
A.reverse()
# Using pajenegod's floating point mod mul
MOD = 998244353
MODF = float(MOD)
MAGIC = 6755399441055744.0
SHRT = 65536.0
MODF_INV = 1.0 / MODF
SHRT_INV = 1.0 / SHRT
fround = lambda x: (x + MAGIC) - MAGIC
fmod = lambda a: a - MODF * fround(MODF_INV * a)
fmul = lambda a, b, c=0.0: fmod(fmod(a * SHRT) * fround(SHRT_INV * b) + a * (b - SHRT * fround(b * SHRT_INV)) + c)
def fpow(x, y):
if y == 0:
return 1.0
res = 1.0
while y > 1:
if y & 1 == 1:
res = fmul(res, x)
x = fmul(x, x)
y >>= 1
return fmul(res, x)
n, m = inp[ii], inp[ii + 1]
ii += 2
a = inp[ii:ii + n * m]
ii += n * m
order = list(range(n * m))
# try this against vanilla sort
mergesort(order, key=lambda x: a[x])
sx, sy = inp[ii], inp[ii + 1]
ii += 2
MX = n * m + 1
inv = [0.0] * MX
inv[1] = 1.0
for i in range(2, MX):
inv[i] = fmul(-1.0 * (MOD // i), inv[MOD % i])
fsum = isum = i2sum = jsum = j2sum = 0
cnt = 0
inv_cnt = 0.0
i = 0
fa = [0] * (n * m)
while i < n * m:
j = i + 1
while j < n * m and a[order[i]] == a[order[j]]:
j += 1
for k in range(i, j):
x, y = divmod(order[k], m)
x += 1
y += 1
f = fmul(1.0 * cnt, 1.0 * (x * x + y * y), i2sum + j2sum + fsum - 2.0 * (x * isum + y * jsum))
f = fmul(f, inv_cnt)
if sx == x and sy == y:
print(int(f + MODF) % MOD)
sys.exit()
fa[k] = int(f)
for k in range(i, j):
x, y = divmod(order[k], m)
x += 1.0
y += 1.0
fsum = (fa[k] + fsum) % MOD
isum += x
i2sum += x * x
jsum += y
j2sum += y * y
cnt += j - i
inv_cnt = inv[cnt]
i = j
``` | instruction | 0 | 32,522 | 23 | 65,044 |
No | output | 1 | 32,522 | 23 | 65,045 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya has got a magic matrix a of size n × m. The rows of the matrix are numbered from 1 to n from top to bottom, the columns are numbered from 1 to m from left to right. Let a_{ij} be the element in the intersection of the i-th row and the j-th column.
Vasya has also got a chip. Initially, the chip is in the intersection of the r-th row and the c-th column (that is, in the element a_{rc}). Vasya performs the following process as long as possible: among all elements of the matrix having their value less than the value of the element with the chip in it, Vasya randomly and equiprobably chooses one element and moves his chip to this element.
After moving the chip, he adds to his score the square of the Euclidean distance between these elements (that is, between the element in which the chip is now and the element the chip was moved from). The process ends when there are no elements having their values less than the value of the element with the chip in it.
Euclidean distance between matrix elements with coordinates (i_1, j_1) and (i_2, j_2) is equal to √{(i_1-i_2)^2 + (j_1-j_2)^2}.
Calculate the expected value of the Vasya's final score.
It can be shown that the answer can be represented as P/Q, where P and Q are coprime integer numbers, and Q not≡ 0~(mod ~ 998244353). Print the value P ⋅ Q^{-1} modulo 998244353.
Input
The first line of the input contains two integers n and m (1 ≤ n, m ≤ 1 000) — the number of rows and the number of columns in the matrix a.
The following n lines contain description of the matrix a. The i-th line contains m integers a_{i1}, a_{i2}, ..., a_{im} ~ (0 ≤ a_{ij} ≤ 10^9).
The following line contains two integers r and c (1 ≤ r ≤ n, 1 ≤ c ≤ m) — the index of row and the index of column where the chip is now.
Output
Print the expected value of Vasya's final score in the format described in the problem statement.
Examples
Input
1 4
1 1 2 1
1 3
Output
2
Input
2 3
1 5 7
2 3 1
1 2
Output
665496238
Note
In the first example, Vasya will move his chip exactly once. The expected value of the final score is equal to (1^2 + 2^2+ 1^2)/(3) = 2.
Submitted Solution:
```
import io, os
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
# meooows code
# Using pajenegod's floating point mod mul
MOD = 998244353
MODF = float(MOD)
MAGIC = 6755399441055744.0
SHRT = 65536.0
MODF_INV = 1.0 / MODF
SHRT_INV = 1.0 / SHRT
fround = lambda x: (x + MAGIC) - MAGIC
fmod = lambda a: a - MODF * fround(MODF_INV * a)
fmul = lambda a, b, c=0.0: fmod(fmod(a * SHRT) * fround(SHRT_INV * b) + a * (b - SHRT * fround(b * SHRT_INV)) + c)
def fpow(x, y):
if y == 0:
return 1.0
res = 1.0
while y > 1:
if y & 1 == 1:
res = fmul(res, x)
x = fmul(x, x)
y >>= 1
return fmul(res, x)
n, m = map(int, input().split())
a = [None]*(n * m)
X = [None]*(n*m)
Y = [None]*(n*m)
for i in range(n):
row = list(map(int, input().split()))
for j in range(m):
ind = i*m + j
a[ind] = row[j]
X[ind] = i + 1.0
Y[ind] = j + 1.0
sx, sy = map(int, input().split())
a.sort()
def solve():
fsum = isum = i2sum = jsum = j2sum = cnt = 0.0
i = 0
fa = [0.0] * (n * m)
while i < n * m:
j = i + 1
while j < n * m and a[i] == a[j]:
j += 1
for k in range(i, j):
x, y = X[k], Y[k]
f = fmul(cnt, x*x + y*y, fsum + i2sum + j2sum - fmul(2, fmul(x, isum) + fmul(y, jsum)))
f = fmul(f, fpow(cnt, MOD - 2))
if sx == x and sy == y:
return int(f + MODF) % MOD
fa[k] = f
for k in range(i, j):
x, y = X[k], Y[k]
fsum = fmod(fa[k] + fsum)
isum += x
i2sum += x * x
jsum += y
j2sum += y * y
cnt += j - i
i = j
print(solve())
``` | instruction | 0 | 32,523 | 23 | 65,046 |
No | output | 1 | 32,523 | 23 | 65,047 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a square of size 10^6 × 10^6 on the coordinate plane with four points (0, 0), (0, 10^6), (10^6, 0), and (10^6, 10^6) as its vertices.
You are going to draw segments on the plane. All segments are either horizontal or vertical and intersect with at least one side of the square.
Now you are wondering how many pieces this square divides into after drawing all segments. Write a program calculating the number of pieces of the square.
Input
The first line contains two integers n and m (0 ≤ n, m ≤ 10^5) — the number of horizontal segments and the number of vertical segments.
The next n lines contain descriptions of the horizontal segments. The i-th line contains three integers y_i, lx_i and rx_i (0 < y_i < 10^6; 0 ≤ lx_i < rx_i ≤ 10^6), which means the segment connects (lx_i, y_i) and (rx_i, y_i).
The next m lines contain descriptions of the vertical segments. The i-th line contains three integers x_i, ly_i and ry_i (0 < x_i < 10^6; 0 ≤ ly_i < ry_i ≤ 10^6), which means the segment connects (x_i, ly_i) and (x_i, ry_i).
It's guaranteed that there are no two segments on the same line, and each segment intersects with at least one of square's sides.
Output
Print the number of pieces the square is divided into after drawing all the segments.
Example
Input
3 3
2 3 1000000
4 0 4
3 0 1000000
4 0 1
2 0 5
3 1 1000000
Output
7
Note
The sample is like this:
<image> | instruction | 0 | 32,700 | 23 | 65,400 |
Tags: data structures, geometry, implementation, sortings
Correct Solution:
```
import sys;input=sys.stdin.readline
class Bit:
def __init__(self, n):
self.size = n
self.tree = [0] * (n + 1)
def sum(self, i):
s = 0
while i > 0:
s += self.tree[i]
i -= i & -i
return s
def add(self, i, x):
while i <= self.size:
self.tree[i] += x
i += i & -i
N, M = map(int, input().split())
E = []
R = 1
for _ in range(N):
y, lx, rx = map(int, input().split())
E.append((3*y+1, (lx, rx)))
if rx-lx == 10**6:
R += 1
for _ in range(M):
x, ly, ry = map(int, input().split())
E.append((3*ly, x))
E.append((3*ry+2, x))
if ry-ly == 10**6:
R += 1
E.sort(key=lambda x:x[0])
bit = Bit(10**6+1)
for y, v in E:
if y%3 == 1:
R += bit.sum(v[1])-bit.sum(v[0]-1)
elif y%3==2:
bit.add(v, -1)
else:
bit.add(v, 1)
print(R)
``` | output | 1 | 32,700 | 23 | 65,401 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a square of size 10^6 × 10^6 on the coordinate plane with four points (0, 0), (0, 10^6), (10^6, 0), and (10^6, 10^6) as its vertices.
You are going to draw segments on the plane. All segments are either horizontal or vertical and intersect with at least one side of the square.
Now you are wondering how many pieces this square divides into after drawing all segments. Write a program calculating the number of pieces of the square.
Input
The first line contains two integers n and m (0 ≤ n, m ≤ 10^5) — the number of horizontal segments and the number of vertical segments.
The next n lines contain descriptions of the horizontal segments. The i-th line contains three integers y_i, lx_i and rx_i (0 < y_i < 10^6; 0 ≤ lx_i < rx_i ≤ 10^6), which means the segment connects (lx_i, y_i) and (rx_i, y_i).
The next m lines contain descriptions of the vertical segments. The i-th line contains three integers x_i, ly_i and ry_i (0 < x_i < 10^6; 0 ≤ ly_i < ry_i ≤ 10^6), which means the segment connects (x_i, ly_i) and (x_i, ry_i).
It's guaranteed that there are no two segments on the same line, and each segment intersects with at least one of square's sides.
Output
Print the number of pieces the square is divided into after drawing all the segments.
Example
Input
3 3
2 3 1000000
4 0 4
3 0 1000000
4 0 1
2 0 5
3 1 1000000
Output
7
Note
The sample is like this:
<image> | instruction | 0 | 32,701 | 23 | 65,402 |
Tags: data structures, geometry, implementation, sortings
Correct Solution:
```
import sys
from collections import deque
from queue import PriorityQueue
from math import gcd
input_ = lambda: sys.stdin.readline().strip("\r\n")
ii = lambda : int(input_())
il = lambda : list(map(int, input_().split()))
ilf = lambda : list(map(float, input_().split()))
ip = lambda : input_()
fi = lambda : float(input_())
ap = lambda ab,bc,cd : ab[bc].append(cd)
li = lambda : list(input_())
pr = lambda x : print(x)
prinT = lambda x : print(x)
f = lambda : sys.stdout.flush()
mod = 10**9 + 7
n,m = il()
a = []
ans = 1
for _ in range (n) :
y,lx,ly = il()
a.append([3*y+1,[lx,ly]])
if (ly-lx == 10**6) :
ans += 1
for _ in range (m) :
x,ly,ry = il()
a.append([3*ly,x])
a.append([3*ry+2,x])
if (ry-ly == 10**6) :
ans += 1
m = 10**6 + 5
def sum(i) :
s = 0
while (i>0) :
s += fin[i]
i -= i&-i
return s
def add(i,x) :
while (i<=m) :
fin[i] += x
i += i&-i
a.sort()
fin = [0 for i in range(10**6 + 5)]
#print(a)
for i in range (len(a)) :
y,x = a[i][0],a[i][1]
if (y%3 == 1) :
ans += sum(x[1]) - sum(x[0]-1)
elif (y%3 == 0) :
add(x,1)
else :
add(x,-1)
print(ans)
``` | output | 1 | 32,701 | 23 | 65,403 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a square of size 10^6 × 10^6 on the coordinate plane with four points (0, 0), (0, 10^6), (10^6, 0), and (10^6, 10^6) as its vertices.
You are going to draw segments on the plane. All segments are either horizontal or vertical and intersect with at least one side of the square.
Now you are wondering how many pieces this square divides into after drawing all segments. Write a program calculating the number of pieces of the square.
Input
The first line contains two integers n and m (0 ≤ n, m ≤ 10^5) — the number of horizontal segments and the number of vertical segments.
The next n lines contain descriptions of the horizontal segments. The i-th line contains three integers y_i, lx_i and rx_i (0 < y_i < 10^6; 0 ≤ lx_i < rx_i ≤ 10^6), which means the segment connects (lx_i, y_i) and (rx_i, y_i).
The next m lines contain descriptions of the vertical segments. The i-th line contains three integers x_i, ly_i and ry_i (0 < x_i < 10^6; 0 ≤ ly_i < ry_i ≤ 10^6), which means the segment connects (x_i, ly_i) and (x_i, ry_i).
It's guaranteed that there are no two segments on the same line, and each segment intersects with at least one of square's sides.
Output
Print the number of pieces the square is divided into after drawing all the segments.
Example
Input
3 3
2 3 1000000
4 0 4
3 0 1000000
4 0 1
2 0 5
3 1 1000000
Output
7
Note
The sample is like this:
<image> | instruction | 0 | 32,702 | 23 | 65,404 |
Tags: data structures, geometry, implementation, sortings
Correct Solution:
```
import sys
input=sys.stdin.readline
class Bit:
def __init__(self, n):
self.size = n
self.tree = [0] * (n + 1)
def sum(self, i):
s = 0
while i > 0:
s += self.tree[i]
i -= i & -i
return s
def add(self, i, x):
while i <= self.size:
self.tree[i] += x
i += i & -i
n,m=map(int,input().split())
e=[]
r=1
for i in range(n):
y,lx,rx=map(int,input().split())
e.append((3*y+1,(lx,rx)))
if rx-lx==10**6:
r+=1
for i in range(m):
x,ly,ry=map(int,input().split())
e.append((3*ly,x))
e.append((3*ry+2,x))
if ry-ly==10**6:
r+=1
e.sort(key=lambda x:x[0])
bit=Bit(10**6+1)
for y,x in e:
if y%3==1:
r+=bit.sum(x[1])-bit.sum(x[0]-1)
elif y%3==0:
bit.add(x,1)
else:
bit.add(x,-1)
print(r)
``` | output | 1 | 32,702 | 23 | 65,405 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a square of size 10^6 × 10^6 on the coordinate plane with four points (0, 0), (0, 10^6), (10^6, 0), and (10^6, 10^6) as its vertices.
You are going to draw segments on the plane. All segments are either horizontal or vertical and intersect with at least one side of the square.
Now you are wondering how many pieces this square divides into after drawing all segments. Write a program calculating the number of pieces of the square.
Input
The first line contains two integers n and m (0 ≤ n, m ≤ 10^5) — the number of horizontal segments and the number of vertical segments.
The next n lines contain descriptions of the horizontal segments. The i-th line contains three integers y_i, lx_i and rx_i (0 < y_i < 10^6; 0 ≤ lx_i < rx_i ≤ 10^6), which means the segment connects (lx_i, y_i) and (rx_i, y_i).
The next m lines contain descriptions of the vertical segments. The i-th line contains three integers x_i, ly_i and ry_i (0 < x_i < 10^6; 0 ≤ ly_i < ry_i ≤ 10^6), which means the segment connects (x_i, ly_i) and (x_i, ry_i).
It's guaranteed that there are no two segments on the same line, and each segment intersects with at least one of square's sides.
Output
Print the number of pieces the square is divided into after drawing all the segments.
Example
Input
3 3
2 3 1000000
4 0 4
3 0 1000000
4 0 1
2 0 5
3 1 1000000
Output
7
Note
The sample is like this:
<image> | instruction | 0 | 32,703 | 23 | 65,406 |
Tags: data structures, geometry, implementation, sortings
Correct Solution:
```
import sys
from collections import defaultdict
input = sys.stdin.buffer.readline
fw, n = [0]*1000002, 1000001
def fw_add(p, val):
while p <= n:
fw[p] += val
p += p & -p
def fw_sum(p):
sm = 0
while p > 0:
sm += fw[p]
p -= p & -p
return sm
def fw_rsum(p1, p2):
return fw_sum(p2)-fw_sum(p1-1)
N, M = map(int, input().split())
fw_add(1, 1); fw_add(1000001, 1)
rmv, add = defaultdict(list), defaultdict(list)
for _ in range(N):
y, x1, x2 = map(int, input().split())
y, x1, x2 = y+1, x1+1, x2+1
if x1 == 1:
fw_add(y, 1)
rmv[x2].append(y)
else:
add[x1].append(y)
query = {}
for _ in range(M):
x, y1, y2 = map(int, input().split())
x, y1, y2 = x+1, y1+1, y2+1
query[x] = (y1, y2)
query[1000001] = (1, 1000001)
cc = 0
for p in range(1, 1000002):
if p in add:
for y in add[p]: fw_add(y, 1)
if p in query:
y1, y2 = query[p]
cc += fw_rsum(y1, y2)-1
#print(p-1, y1-1, y2-1, fw_rsum(y1, y2)-1)
if p in rmv:
for y in rmv[p]: fw_add(y, -1)
print(cc-sum(len(u) for u in add.values()))
``` | output | 1 | 32,703 | 23 | 65,407 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a square of size 10^6 × 10^6 on the coordinate plane with four points (0, 0), (0, 10^6), (10^6, 0), and (10^6, 10^6) as its vertices.
You are going to draw segments on the plane. All segments are either horizontal or vertical and intersect with at least one side of the square.
Now you are wondering how many pieces this square divides into after drawing all segments. Write a program calculating the number of pieces of the square.
Input
The first line contains two integers n and m (0 ≤ n, m ≤ 10^5) — the number of horizontal segments and the number of vertical segments.
The next n lines contain descriptions of the horizontal segments. The i-th line contains three integers y_i, lx_i and rx_i (0 < y_i < 10^6; 0 ≤ lx_i < rx_i ≤ 10^6), which means the segment connects (lx_i, y_i) and (rx_i, y_i).
The next m lines contain descriptions of the vertical segments. The i-th line contains three integers x_i, ly_i and ry_i (0 < x_i < 10^6; 0 ≤ ly_i < ry_i ≤ 10^6), which means the segment connects (x_i, ly_i) and (x_i, ry_i).
It's guaranteed that there are no two segments on the same line, and each segment intersects with at least one of square's sides.
Output
Print the number of pieces the square is divided into after drawing all the segments.
Example
Input
3 3
2 3 1000000
4 0 4
3 0 1000000
4 0 1
2 0 5
3 1 1000000
Output
7
Note
The sample is like this:
<image> | instruction | 0 | 32,704 | 23 | 65,408 |
Tags: data structures, geometry, implementation, sortings
Correct Solution:
```
import sys
import io, os
input = sys.stdin.buffer.readline
n, m = map(int, input().split())
INF = 10**18
ans = 1
H = []
ys = []
for i in range(n):
y, lx, rx = map(int, input().split())
if lx == 0 and rx == 10**6:
ans += 1
H.append((lx, y, 1))
H.append((rx+1, y, -1))
ys.append(y)
V = []
for i in range(m):
x, ly, ry = map(int, input().split())
if ly == 0 and ry == 10**6:
ans += 1
V.append((x, ly, ry))
ys = list(set(ys))
ys.sort()
ys = [-INF]+ys
ymap = {}
for i, y in enumerate(ys):
ymap[y] = i
class BIT:
def __init__(self, n):
self.n = n
self.bit = [0]*(self.n+1) # 1-indexed
def init(self, init_val):
for i, v in enumerate(init_val):
self.add(i, v)
def add(self, i, x):
# i: 0-indexed
i += 1 # to 1-indexed
while i <= self.n:
self.bit[i] += x
i += (i & -i)
def sum(self, i, j):
# return sum of [i, j)
# i, j: 0-indexed
return self._sum(j) - self._sum(i)
def _sum(self, i):
# return sum of [0, i)
# i: 0-indexed
res = 0
while i > 0:
res += self.bit[i]
i -= i & (-i)
return res
def lower_bound(self, x):
s = 0
pos = 0
depth = self.n.bit_length()
v = 1 << depth
for i in range(depth, -1, -1):
k = pos + v
if k <= self.n and s + self.bit[k] < x:
s += self.bit[k]
pos += v
v >>= 1
return pos
V.sort()
H.sort()
hid = 0
nh = len(H)
nv = len(ys)
bit = BIT(nv+1)
import bisect
for x, ly, ry in V:
while hid < nh:
if H[hid][0] <= x:
bit.add(ymap[H[hid][1]], H[hid][2])
hid += 1
else:
break
l = bisect.bisect_left(ys, ly)
r = bisect.bisect_right(ys, ry)
ans += bit.sum(l, r)
print(ans)
``` | output | 1 | 32,704 | 23 | 65,409 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a square of size 10^6 × 10^6 on the coordinate plane with four points (0, 0), (0, 10^6), (10^6, 0), and (10^6, 10^6) as its vertices.
You are going to draw segments on the plane. All segments are either horizontal or vertical and intersect with at least one side of the square.
Now you are wondering how many pieces this square divides into after drawing all segments. Write a program calculating the number of pieces of the square.
Input
The first line contains two integers n and m (0 ≤ n, m ≤ 10^5) — the number of horizontal segments and the number of vertical segments.
The next n lines contain descriptions of the horizontal segments. The i-th line contains three integers y_i, lx_i and rx_i (0 < y_i < 10^6; 0 ≤ lx_i < rx_i ≤ 10^6), which means the segment connects (lx_i, y_i) and (rx_i, y_i).
The next m lines contain descriptions of the vertical segments. The i-th line contains three integers x_i, ly_i and ry_i (0 < x_i < 10^6; 0 ≤ ly_i < ry_i ≤ 10^6), which means the segment connects (x_i, ly_i) and (x_i, ry_i).
It's guaranteed that there are no two segments on the same line, and each segment intersects with at least one of square's sides.
Output
Print the number of pieces the square is divided into after drawing all the segments.
Example
Input
3 3
2 3 1000000
4 0 4
3 0 1000000
4 0 1
2 0 5
3 1 1000000
Output
7
Note
The sample is like this:
<image> | instruction | 0 | 32,705 | 23 | 65,410 |
Tags: data structures, geometry, implementation, sortings
Correct Solution:
```
import sys, math
import io, os
data = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
#from bisect import bisect_left as bl, bisect_right as br, insort
#from heapq import heapify, heappush, heappop
#from collections import defaultdict as dd, deque, Counter
#from itertools import permutations,combinations
#def data(): return sys.stdin.readline().strip()
def mdata(): return list(map(int, data().split()))
def outl(var) : sys.stdout.write(' '.join(map(str, var))+'\n')
def out(var) : sys.stdout.write(str(var)+'\n')
from decimal import Decimal
#from fractions import Fraction
#sys.setrecursionlimit(100000)
INF = float('inf')
mod = int(1e9)+7
class SortedList:
def __init__(self, iterable=[], _load=200):
"""Initialize sorted list instance."""
values = sorted(iterable)
self._len = _len = len(values)
self._load = _load
self._lists = _lists = [values[i:i + _load] for i in range(0, _len, _load)]
self._list_lens = [len(_list) for _list in _lists]
self._mins = [_list[0] for _list in _lists]
self._fen_tree = []
self._rebuild = True
def _fen_build(self):
"""Build a fenwick tree instance."""
self._fen_tree[:] = self._list_lens
_fen_tree = self._fen_tree
for i in range(len(_fen_tree)):
if i | i + 1 < len(_fen_tree):
_fen_tree[i | i + 1] += _fen_tree[i]
self._rebuild = False
def _fen_update(self, index, value):
"""Update `fen_tree[index] += value`."""
if not self._rebuild:
_fen_tree = self._fen_tree
while index < len(_fen_tree):
_fen_tree[index] += value
index |= index + 1
def _fen_query(self, end):
"""Return `sum(_fen_tree[:end])`."""
if self._rebuild:
self._fen_build()
_fen_tree = self._fen_tree
x = 0
while end:
x += _fen_tree[end - 1]
end &= end - 1
return x
def _fen_findkth(self, k):
"""Return a pair of (the largest `idx` such that `sum(_fen_tree[:idx]) <= k`, `k - sum(_fen_tree[:idx])`)."""
_list_lens = self._list_lens
if k < _list_lens[0]:
return 0, k
if k >= self._len - _list_lens[-1]:
return len(_list_lens) - 1, k + _list_lens[-1] - self._len
if self._rebuild:
self._fen_build()
_fen_tree = self._fen_tree
idx = -1
for d in reversed(range(len(_fen_tree).bit_length())):
right_idx = idx + (1 << d)
if right_idx < len(_fen_tree) and k >= _fen_tree[right_idx]:
idx = right_idx
k -= _fen_tree[idx]
return idx + 1, k
def _delete(self, pos, idx):
"""Delete value at the given `(pos, idx)`."""
_lists = self._lists
_mins = self._mins
_list_lens = self._list_lens
self._len -= 1
self._fen_update(pos, -1)
del _lists[pos][idx]
_list_lens[pos] -= 1
if _list_lens[pos]:
_mins[pos] = _lists[pos][0]
else:
del _lists[pos]
del _list_lens[pos]
del _mins[pos]
self._rebuild = True
def _loc_left(self, value):
"""Return an index pair that corresponds to the first position of `value` in the sorted list."""
if not self._len:
return 0, 0
_lists = self._lists
_mins = self._mins
lo, pos = -1, len(_lists) - 1
while lo + 1 < pos:
mi = (lo + pos) >> 1
if value <= _mins[mi]:
pos = mi
else:
lo = mi
if pos and value <= _lists[pos - 1][-1]:
pos -= 1
_list = _lists[pos]
lo, idx = -1, len(_list)
while lo + 1 < idx:
mi = (lo + idx) >> 1
if value <= _list[mi]:
idx = mi
else:
lo = mi
return pos, idx
def _loc_right(self, value):
"""Return an index pair that corresponds to the last position of `value` in the sorted list."""
if not self._len:
return 0, 0
_lists = self._lists
_mins = self._mins
pos, hi = 0, len(_lists)
while pos + 1 < hi:
mi = (pos + hi) >> 1
if value < _mins[mi]:
hi = mi
else:
pos = mi
_list = _lists[pos]
lo, idx = -1, len(_list)
while lo + 1 < idx:
mi = (lo + idx) >> 1
if value < _list[mi]:
idx = mi
else:
lo = mi
return pos, idx
def add(self, value):
"""Add `value` to sorted list."""
_load = self._load
_lists = self._lists
_mins = self._mins
_list_lens = self._list_lens
self._len += 1
if _lists:
pos, idx = self._loc_right(value)
self._fen_update(pos, 1)
_list = _lists[pos]
_list.insert(idx, value)
_list_lens[pos] += 1
_mins[pos] = _list[0]
if _load + _load < len(_list):
_lists.insert(pos + 1, _list[_load:])
_list_lens.insert(pos + 1, len(_list) - _load)
_mins.insert(pos + 1, _list[_load])
_list_lens[pos] = _load
del _list[_load:]
self._rebuild = True
else:
_lists.append([value])
_mins.append(value)
_list_lens.append(1)
self._rebuild = True
def discard(self, value):
"""Remove `value` from sorted list if it is a member."""
_lists = self._lists
if _lists:
pos, idx = self._loc_right(value)
if idx and _lists[pos][idx - 1] == value:
self._delete(pos, idx - 1)
def remove(self, value):
"""Remove `value` from sorted list; `value` must be a member."""
_len = self._len
self.discard(value)
if _len == self._len:
raise ValueError('{0!r} not in list'.format(value))
def pop(self, index=-1):
"""Remove and return value at `index` in sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
value = self._lists[pos][idx]
self._delete(pos, idx)
return value
def bisect_left(self, value):
"""Return the first index to insert `value` in the sorted list."""
pos, idx = self._loc_left(value)
return self._fen_query(pos) + idx
def bisect_right(self, value):
"""Return the last index to insert `value` in the sorted list."""
pos, idx = self._loc_right(value)
return self._fen_query(pos) + idx
def count(self, value):
"""Return number of occurrences of `value` in the sorted list."""
return self.bisect_right(value) - self.bisect_left(value)
def __len__(self):
"""Return the size of the sorted list."""
return self._len
def __getitem__(self, index):
"""Lookup value at `index` in sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
return self._lists[pos][idx]
def __delitem__(self, index):
"""Remove value at `index` from sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
self._delete(pos, idx)
def __contains__(self, value):
"""Return true if `value` is an element of the sorted list."""
_lists = self._lists
if _lists:
pos, idx = self._loc_left(value)
return idx < len(_lists[pos]) and _lists[pos][idx] == value
return False
def __iter__(self):
"""Return an iterator over the sorted list."""
return (value for _list in self._lists for value in _list)
def __reversed__(self):
"""Return a reverse iterator over the sorted list."""
return (value for _list in reversed(self._lists) for value in reversed(_list))
def __repr__(self):
"""Return string representation of sorted list."""
return 'SortedList({0})'.format(list(self))
n,m=mdata()
hor=[mdata() for i in range(n)]
ver=[mdata() for i in range(m)]
topVer=SortedList()
botVer=SortedList()
ans=1
for x,bot,top in ver:
if bot==0:
botVer.add(x)
if top==10**6:
ans+=1
else:
topVer.add(x)
hor.sort(key=lambda x:x[0],reverse=True)
ver.sort(key=lambda x:x[1],reverse=True)
ind1,i=0,0
while i<n:
if hor[i][1]==0 and hor[i][2]==10**6:
ans+=1
while ind1<m and topVer and ver[ind1][1]>hor[i][0]:
topVer.remove(ver[ind1][0])
ind1+=1
if hor[i][1]==0:
ans+=topVer.bisect_right(hor[i][2])
else:
ans+=len(topVer)-topVer.bisect_left(hor[i][1])
i+=1
hor.reverse()
ver.sort(key=lambda x:x[2])
ind1,i=0,0
while i<n and botVer:
while ind1<m and botVer and ver[ind1][2]<hor[i][0]:
botVer.remove(ver[ind1][0])
ind1+=1
if hor[i][1]==0:
ans+=botVer.bisect_right(hor[i][2])
else:
ans+=len(botVer)-botVer.bisect_left(hor[i][1])
i+=1
out(ans)
``` | output | 1 | 32,705 | 23 | 65,411 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a square of size 10^6 × 10^6 on the coordinate plane with four points (0, 0), (0, 10^6), (10^6, 0), and (10^6, 10^6) as its vertices.
You are going to draw segments on the plane. All segments are either horizontal or vertical and intersect with at least one side of the square.
Now you are wondering how many pieces this square divides into after drawing all segments. Write a program calculating the number of pieces of the square.
Input
The first line contains two integers n and m (0 ≤ n, m ≤ 10^5) — the number of horizontal segments and the number of vertical segments.
The next n lines contain descriptions of the horizontal segments. The i-th line contains three integers y_i, lx_i and rx_i (0 < y_i < 10^6; 0 ≤ lx_i < rx_i ≤ 10^6), which means the segment connects (lx_i, y_i) and (rx_i, y_i).
The next m lines contain descriptions of the vertical segments. The i-th line contains three integers x_i, ly_i and ry_i (0 < x_i < 10^6; 0 ≤ ly_i < ry_i ≤ 10^6), which means the segment connects (x_i, ly_i) and (x_i, ry_i).
It's guaranteed that there are no two segments on the same line, and each segment intersects with at least one of square's sides.
Output
Print the number of pieces the square is divided into after drawing all the segments.
Example
Input
3 3
2 3 1000000
4 0 4
3 0 1000000
4 0 1
2 0 5
3 1 1000000
Output
7
Note
The sample is like this:
<image> | instruction | 0 | 32,706 | 23 | 65,412 |
Tags: data structures, geometry, implementation, sortings
Correct Solution:
```
import io
import os
from collections import Counter, defaultdict, deque
# https://raw.githubusercontent.com/cheran-senthil/PyRival/master/pyrival/data_structures/SortedList.py
class SortedList:
def __init__(self, iterable=[], _load=200):
"""Initialize sorted list instance."""
values = sorted(iterable)
self._len = _len = len(values)
self._load = _load
self._lists = _lists = [values[i : i + _load] for i in range(0, _len, _load)]
self._list_lens = [len(_list) for _list in _lists]
self._mins = [_list[0] for _list in _lists]
self._fen_tree = []
self._rebuild = True
def _fen_build(self):
"""Build a fenwick tree instance."""
self._fen_tree[:] = self._list_lens
_fen_tree = self._fen_tree
for i in range(len(_fen_tree)):
if i | i + 1 < len(_fen_tree):
_fen_tree[i | i + 1] += _fen_tree[i]
self._rebuild = False
def _fen_update(self, index, value):
"""Update `fen_tree[index] += value`."""
if not self._rebuild:
_fen_tree = self._fen_tree
while index < len(_fen_tree):
_fen_tree[index] += value
index |= index + 1
def _fen_query(self, end):
"""Return `sum(_fen_tree[:end])`."""
if self._rebuild:
self._fen_build()
_fen_tree = self._fen_tree
x = 0
while end:
x += _fen_tree[end - 1]
end &= end - 1
return x
def _fen_findkth(self, k):
"""Return a pair of (the largest `idx` such that `sum(_fen_tree[:idx]) <= k`, `k - sum(_fen_tree[:idx])`)."""
_list_lens = self._list_lens
if k < _list_lens[0]:
return 0, k
if k >= self._len - _list_lens[-1]:
return len(_list_lens) - 1, k + _list_lens[-1] - self._len
if self._rebuild:
self._fen_build()
_fen_tree = self._fen_tree
idx = -1
for d in reversed(range(len(_fen_tree).bit_length())):
right_idx = idx + (1 << d)
if right_idx < len(_fen_tree) and k >= _fen_tree[right_idx]:
idx = right_idx
k -= _fen_tree[idx]
return idx + 1, k
def _delete(self, pos, idx):
"""Delete value at the given `(pos, idx)`."""
_lists = self._lists
_mins = self._mins
_list_lens = self._list_lens
self._len -= 1
self._fen_update(pos, -1)
del _lists[pos][idx]
_list_lens[pos] -= 1
if _list_lens[pos]:
_mins[pos] = _lists[pos][0]
else:
del _lists[pos]
del _list_lens[pos]
del _mins[pos]
self._rebuild = True
def _loc_left(self, value):
"""Return an index pair that corresponds to the first position of `value` in the sorted list."""
if not self._len:
return 0, 0
_lists = self._lists
_mins = self._mins
lo, pos = -1, len(_lists) - 1
while lo + 1 < pos:
mi = (lo + pos) >> 1
if value <= _mins[mi]:
pos = mi
else:
lo = mi
if pos and value <= _lists[pos - 1][-1]:
pos -= 1
_list = _lists[pos]
lo, idx = -1, len(_list)
while lo + 1 < idx:
mi = (lo + idx) >> 1
if value <= _list[mi]:
idx = mi
else:
lo = mi
return pos, idx
def _loc_right(self, value):
"""Return an index pair that corresponds to the last position of `value` in the sorted list."""
if not self._len:
return 0, 0
_lists = self._lists
_mins = self._mins
pos, hi = 0, len(_lists)
while pos + 1 < hi:
mi = (pos + hi) >> 1
if value < _mins[mi]:
hi = mi
else:
pos = mi
_list = _lists[pos]
lo, idx = -1, len(_list)
while lo + 1 < idx:
mi = (lo + idx) >> 1
if value < _list[mi]:
idx = mi
else:
lo = mi
return pos, idx
def add(self, value):
"""Add `value` to sorted list."""
_load = self._load
_lists = self._lists
_mins = self._mins
_list_lens = self._list_lens
self._len += 1
if _lists:
pos, idx = self._loc_right(value)
self._fen_update(pos, 1)
_list = _lists[pos]
_list.insert(idx, value)
_list_lens[pos] += 1
_mins[pos] = _list[0]
if _load + _load < len(_list):
_lists.insert(pos + 1, _list[_load:])
_list_lens.insert(pos + 1, len(_list) - _load)
_mins.insert(pos + 1, _list[_load])
_list_lens[pos] = _load
del _list[_load:]
self._rebuild = True
else:
_lists.append([value])
_mins.append(value)
_list_lens.append(1)
self._rebuild = True
def discard(self, value):
"""Remove `value` from sorted list if it is a member."""
_lists = self._lists
if _lists:
pos, idx = self._loc_right(value)
if idx and _lists[pos][idx - 1] == value:
self._delete(pos, idx - 1)
def remove(self, value):
"""Remove `value` from sorted list; `value` must be a member."""
_len = self._len
self.discard(value)
if _len == self._len:
raise ValueError("{0!r} not in list".format(value))
def pop(self, index=-1):
"""Remove and return value at `index` in sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
value = self._lists[pos][idx]
self._delete(pos, idx)
return value
def bisect_left(self, value):
"""Return the first index to insert `value` in the sorted list."""
pos, idx = self._loc_left(value)
return self._fen_query(pos) + idx
def bisect_right(self, value):
"""Return the last index to insert `value` in the sorted list."""
pos, idx = self._loc_right(value)
return self._fen_query(pos) + idx
def count(self, value):
"""Return number of occurrences of `value` in the sorted list."""
return self.bisect_right(value) - self.bisect_left(value)
def __len__(self):
"""Return the size of the sorted list."""
return self._len
def __getitem__(self, index):
"""Lookup value at `index` in sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
return self._lists[pos][idx]
def __delitem__(self, index):
"""Remove value at `index` from sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
self._delete(pos, idx)
def __contains__(self, value):
"""Return true if `value` is an element of the sorted list."""
_lists = self._lists
if _lists:
pos, idx = self._loc_left(value)
return idx < len(_lists[pos]) and _lists[pos][idx] == value
return False
def __iter__(self):
"""Return an iterator over the sorted list."""
return (value for _list in self._lists for value in _list)
def __reversed__(self):
"""Return a reverse iterator over the sorted list."""
return (value for _list in reversed(self._lists) for value in reversed(_list))
def __repr__(self):
"""Return string representation of sorted list."""
return "SortedList({0})".format(list(self))
def solve(N, M, YLR, XBT):
# y, (l, r)
H = []
H.append((0, (0, 10 ** 6)))
H.append((10 ** 6, (0, 10 ** 6)))
for y, l, r in YLR:
H.append((y, (l, r)))
H.sort(key=lambda ylr: ylr[1][0]) # Sort by left
# x, (b, t)
V = []
V.append((0, (0, 10 ** 6)))
V.append((10 ** 6, (0, 10 ** 6)))
for x, b, t in XBT:
V.append((x, (b, t)))
V.sort() # Sort by x
straddling = SortedList() # (r, i)
straddlingByY = SortedList() # (y)
goodLeftByY = SortedList() # (y, i)
j = 0
ans = 0
for index, (x, (b, t)) in enumerate(V):
# Make sure straddling always have r >= x
while straddling and straddling[0][0] < x:
r, i = straddling.pop(0)
straddlingByY.remove(H[i][0])
if index != 0:
# Count intersections
lo = straddlingByY.bisect_left(b)
hi = straddlingByY.bisect_right(t)
assert hi - lo > 0 # always intersect one
ans += hi - lo - 1
# Enter stuff with l <= x
while j < len(H) and H[j][1][0] <= x:
goodLeftByY.add((H[j][0], j))
j += 1
# Stuff with good left and intersects current vertical is a new straddle
lo = goodLeftByY.bisect_left((b, 0))
hi = goodLeftByY.bisect_right((t, 10 ** 7))
move = list(goodLeftByY[k] for k in range(lo, hi))
for tup in move:
y, i = tup
y, (l, r) = H[i]
assert b <= y <= t
assert l <= x
goodLeftByY.remove(tup)
straddling.add((r, i))
straddlingByY.add(y)
return ans
if __name__ == "__main__":
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
(N, M) = [int(x) for x in input().split()]
YLR = ((int(x) for x in input().split()) for i in range(N))
XBT = ((int(x) for x in input().split()) for i in range(M))
ans = solve(N, M, YLR, XBT)
print(ans)
``` | output | 1 | 32,706 | 23 | 65,413 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a square of size 10^6 × 10^6 on the coordinate plane with four points (0, 0), (0, 10^6), (10^6, 0), and (10^6, 10^6) as its vertices.
You are going to draw segments on the plane. All segments are either horizontal or vertical and intersect with at least one side of the square.
Now you are wondering how many pieces this square divides into after drawing all segments. Write a program calculating the number of pieces of the square.
Input
The first line contains two integers n and m (0 ≤ n, m ≤ 10^5) — the number of horizontal segments and the number of vertical segments.
The next n lines contain descriptions of the horizontal segments. The i-th line contains three integers y_i, lx_i and rx_i (0 < y_i < 10^6; 0 ≤ lx_i < rx_i ≤ 10^6), which means the segment connects (lx_i, y_i) and (rx_i, y_i).
The next m lines contain descriptions of the vertical segments. The i-th line contains three integers x_i, ly_i and ry_i (0 < x_i < 10^6; 0 ≤ ly_i < ry_i ≤ 10^6), which means the segment connects (x_i, ly_i) and (x_i, ry_i).
It's guaranteed that there are no two segments on the same line, and each segment intersects with at least one of square's sides.
Output
Print the number of pieces the square is divided into after drawing all the segments.
Example
Input
3 3
2 3 1000000
4 0 4
3 0 1000000
4 0 1
2 0 5
3 1 1000000
Output
7
Note
The sample is like this:
<image> | instruction | 0 | 32,707 | 23 | 65,414 |
Tags: data structures, geometry, implementation, sortings
Correct Solution:
```
import sys
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def SI(): return sys.stdin.readline()[:-1]
class BitSum:
def __init__(self, n):
self.n = n + 1
self.table = [0] * self.n
def add(self, i, x):
i += 1
while i < self.n:
self.table[i] += x
i += i & -i
def sum(self, i):
i += 1
res = 0
while i > 0:
res += self.table[i]
i -= i & -i
return res
from heapq import *
def solve(ans):
enc = {y: i for i, y in enumerate(sorted(yy))}
yn = len(yy)
bit = BitSum(yn)
bit.add(yn - 1, 1)
while hp:
x, t, y1, r = heappop(hp)
if t == 0:
bit.add(enc[y1], 1)
heappush(hp,(r,2,y1,-1))
if t == 1:
if y1 == 0: ans += bit.sum(enc[r])
else: ans += bit.sum(enc[mx] - 1) - bit.sum(enc[y1] - 1)
if t == 2:
bit.add(enc[y1], -1)
# print(x,t,y1,y2,ans)
print(ans)
mx=10**6
n,m=MI()
yy=set([0,mx])
hp=[]
ans=1
for _ in range(n):
y,l,r=MI()
if l==0 and r==mx:ans+=1
heappush(hp,(l,0,y,r))
yy.add(y)
for _ in range(m):
x,l,r=MI()
heappush(hp,(x,1,l,r))
yy.add(l)
yy.add(r)
solve(ans)
``` | output | 1 | 32,707 | 23 | 65,415 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a square of size 10^6 × 10^6 on the coordinate plane with four points (0, 0), (0, 10^6), (10^6, 0), and (10^6, 10^6) as its vertices.
You are going to draw segments on the plane. All segments are either horizontal or vertical and intersect with at least one side of the square.
Now you are wondering how many pieces this square divides into after drawing all segments. Write a program calculating the number of pieces of the square.
Input
The first line contains two integers n and m (0 ≤ n, m ≤ 10^5) — the number of horizontal segments and the number of vertical segments.
The next n lines contain descriptions of the horizontal segments. The i-th line contains three integers y_i, lx_i and rx_i (0 < y_i < 10^6; 0 ≤ lx_i < rx_i ≤ 10^6), which means the segment connects (lx_i, y_i) and (rx_i, y_i).
The next m lines contain descriptions of the vertical segments. The i-th line contains three integers x_i, ly_i and ry_i (0 < x_i < 10^6; 0 ≤ ly_i < ry_i ≤ 10^6), which means the segment connects (x_i, ly_i) and (x_i, ry_i).
It's guaranteed that there are no two segments on the same line, and each segment intersects with at least one of square's sides.
Output
Print the number of pieces the square is divided into after drawing all the segments.
Example
Input
3 3
2 3 1000000
4 0 4
3 0 1000000
4 0 1
2 0 5
3 1 1000000
Output
7
Note
The sample is like this:
<image>
Submitted Solution:
```
import sys
import io, os
input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
n, m = map(int, input().split())
INF = 10**18
ans = 1
H = []
ys = []
for i in range(n):
y, lx, rx = map(int, input().split())
if lx == 0 and rx == 10**6:
ans += 1
H.append((lx, y, 1))
H.append((rx+1, y, -1))
ys.append(y)
V = []
for i in range(m):
x, ly, ry = map(int, input().split())
if ly == 0 and ry == 10**6:
ans += 1
V.append((x, ly, ry))
ys = list(set(ys))
ys.sort()
ys = [-INF]+ys
ymap = {}
for i, y in enumerate(ys):
ymap[y] = i
class BIT:
def __init__(self, n):
self.n = n
self.bit = [0]*(self.n+1) # 1-indexed
def init(self, init_val):
for i, v in enumerate(init_val):
self.add(i, v)
def add(self, i, x):
# i: 0-indexed
i += 1 # to 1-indexed
while i <= self.n:
self.bit[i] += x
i += (i & -i)
def sum(self, i, j):
# return sum of [i, j)
# i, j: 0-indexed
return self._sum(j) - self._sum(i)
def _sum(self, i):
# return sum of [0, i)
# i: 0-indexed
res = 0
while i > 0:
res += self.bit[i]
i -= i & (-i)
return res
def lower_bound(self, x):
s = 0
pos = 0
depth = self.n.bit_length()
v = 1 << depth
for i in range(depth, -1, -1):
k = pos + v
if k <= self.n and s + self.bit[k] < x:
s += self.bit[k]
pos += v
v >>= 1
return pos
V.sort()
H.sort()
hid = 0
nh = len(H)
nv = len(ys)
bit = BIT(nv+1)
import bisect
for x, ly, ry in V:
while hid < nh:
if H[hid][0] <= x:
bit.add(ymap[H[hid][1]], H[hid][2])
hid += 1
else:
break
l = bisect.bisect_left(ys, ly)
r = bisect.bisect_right(ys, ry)
ans += bit.sum(l, r)
print(ans)
``` | instruction | 0 | 32,708 | 23 | 65,416 |
Yes | output | 1 | 32,708 | 23 | 65,417 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a square of size 10^6 × 10^6 on the coordinate plane with four points (0, 0), (0, 10^6), (10^6, 0), and (10^6, 10^6) as its vertices.
You are going to draw segments on the plane. All segments are either horizontal or vertical and intersect with at least one side of the square.
Now you are wondering how many pieces this square divides into after drawing all segments. Write a program calculating the number of pieces of the square.
Input
The first line contains two integers n and m (0 ≤ n, m ≤ 10^5) — the number of horizontal segments and the number of vertical segments.
The next n lines contain descriptions of the horizontal segments. The i-th line contains three integers y_i, lx_i and rx_i (0 < y_i < 10^6; 0 ≤ lx_i < rx_i ≤ 10^6), which means the segment connects (lx_i, y_i) and (rx_i, y_i).
The next m lines contain descriptions of the vertical segments. The i-th line contains three integers x_i, ly_i and ry_i (0 < x_i < 10^6; 0 ≤ ly_i < ry_i ≤ 10^6), which means the segment connects (x_i, ly_i) and (x_i, ry_i).
It's guaranteed that there are no two segments on the same line, and each segment intersects with at least one of square's sides.
Output
Print the number of pieces the square is divided into after drawing all the segments.
Example
Input
3 3
2 3 1000000
4 0 4
3 0 1000000
4 0 1
2 0 5
3 1 1000000
Output
7
Note
The sample is like this:
<image>
Submitted Solution:
```
# Fast IO (be careful about bitstring)
import os,io
input=io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
MaxLength = 1 << 20
FenwickTree = []
CurLen = MaxLength
while CurLen != 0:
FenwickTree.append([0] * CurLen)
CurLen //= 2
Depth = len(FenwickTree)
def addElem(n,index): # add n to an element in index
for j in range(Depth):
if index < len(FenwickTree[j]):
FenwickTree[j][index] += n
index //= 2
def firstNSum(n): # Return the sum of the first n elements (0 to n-1)
nCpy = n
summ = 0
depthCur = 0
while nCpy != 0:
if nCpy % 2 != 0:
summ += FenwickTree[depthCur][nCpy - 1]
nCpy //= 2
depthCur += 1
return summ
n,m = map(int,input().split())
QueryList = []
ans = 0
for _ in range(n):
a,b,c = map(int,input().split())
if b == 0 and c == 10 ** 6:
QueryList.append((0,1,a))
ans += 1
elif b == 0:
QueryList.append((0,1,a))
QueryList.append((c + 1,-1,a))
elif c == 10 ** 6:
QueryList.append((b,1,a))
QueryList.sort()
LineList = []
for _ in range(m):
a,b,c = map(int,input().split())
LineList.append((a,b,c))
if b == 0 and c == 10 ** 6:
ans += 1
LineList.sort()
QueryIndex = 0
LineIndex = 0
while True:
if LineIndex >= len(LineList):
break
if QueryIndex >= len(QueryList) or LineList[LineIndex][0] < QueryList[QueryIndex][0]:
ans += firstNSum(LineList[LineIndex][2] + 1) - firstNSum(LineList[LineIndex][1])
LineIndex += 1
elif LineIndex >= len(LineList) or LineList[LineIndex][0] >= QueryList[QueryIndex][0]:
addElem(QueryList[QueryIndex][1],QueryList[QueryIndex][2])
QueryIndex += 1
else:
break
print(ans + 1)
``` | instruction | 0 | 32,709 | 23 | 65,418 |
Yes | output | 1 | 32,709 | 23 | 65,419 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a square of size 10^6 × 10^6 on the coordinate plane with four points (0, 0), (0, 10^6), (10^6, 0), and (10^6, 10^6) as its vertices.
You are going to draw segments on the plane. All segments are either horizontal or vertical and intersect with at least one side of the square.
Now you are wondering how many pieces this square divides into after drawing all segments. Write a program calculating the number of pieces of the square.
Input
The first line contains two integers n and m (0 ≤ n, m ≤ 10^5) — the number of horizontal segments and the number of vertical segments.
The next n lines contain descriptions of the horizontal segments. The i-th line contains three integers y_i, lx_i and rx_i (0 < y_i < 10^6; 0 ≤ lx_i < rx_i ≤ 10^6), which means the segment connects (lx_i, y_i) and (rx_i, y_i).
The next m lines contain descriptions of the vertical segments. The i-th line contains three integers x_i, ly_i and ry_i (0 < x_i < 10^6; 0 ≤ ly_i < ry_i ≤ 10^6), which means the segment connects (x_i, ly_i) and (x_i, ry_i).
It's guaranteed that there are no two segments on the same line, and each segment intersects with at least one of square's sides.
Output
Print the number of pieces the square is divided into after drawing all the segments.
Example
Input
3 3
2 3 1000000
4 0 4
3 0 1000000
4 0 1
2 0 5
3 1 1000000
Output
7
Note
The sample is like this:
<image>
Submitted Solution:
```
import sys
input=sys.stdin.readline
class Bit:
def __init__(self, n):
self.size = n
self.tree = [0] * (n + 1)
def sum(self, i):
s = 0
while i > 0:
s += self.tree[i]
i -= i & -i
return s
def add(self, i, x):
while i <= self.size:
self.tree[i] += x
i += i & -i
x,y = list(map(int, input().split()))
ans = 1
#3 types of events
#vertical begins - add
#vertical ends - rem
#horizontal crosses - sum
fenwick = Bit(10**6+1)
events = []
for _ in range(x):
a,b,c = list(map(int, input().split()))
if b==0 and c==10**6:
ans += 1
events.append((a,1,b,c))
for _ in range(y):
a,b,c = list(map(int, input().split()))
if b==0 and c==10**6:
ans += 1
events.append((b,0,a,c))
events.append((c,2,a,c))
events.sort()
for e in events:
h,b,c,d = e
if b==1:
#print(ans, e)
#print(fenwick.sum(d), fenwick.sum(c-1))
ans += fenwick.sum(d) - fenwick.sum(c-1)
if b==0:
# print('add', c, a)
fenwick.add(c, 1)
if b==2:
# print('rem', c, a)
fenwick.add(c, -1)
print(ans)
``` | instruction | 0 | 32,710 | 23 | 65,420 |
Yes | output | 1 | 32,710 | 23 | 65,421 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a square of size 10^6 × 10^6 on the coordinate plane with four points (0, 0), (0, 10^6), (10^6, 0), and (10^6, 10^6) as its vertices.
You are going to draw segments on the plane. All segments are either horizontal or vertical and intersect with at least one side of the square.
Now you are wondering how many pieces this square divides into after drawing all segments. Write a program calculating the number of pieces of the square.
Input
The first line contains two integers n and m (0 ≤ n, m ≤ 10^5) — the number of horizontal segments and the number of vertical segments.
The next n lines contain descriptions of the horizontal segments. The i-th line contains three integers y_i, lx_i and rx_i (0 < y_i < 10^6; 0 ≤ lx_i < rx_i ≤ 10^6), which means the segment connects (lx_i, y_i) and (rx_i, y_i).
The next m lines contain descriptions of the vertical segments. The i-th line contains three integers x_i, ly_i and ry_i (0 < x_i < 10^6; 0 ≤ ly_i < ry_i ≤ 10^6), which means the segment connects (x_i, ly_i) and (x_i, ry_i).
It's guaranteed that there are no two segments on the same line, and each segment intersects with at least one of square's sides.
Output
Print the number of pieces the square is divided into after drawing all the segments.
Example
Input
3 3
2 3 1000000
4 0 4
3 0 1000000
4 0 1
2 0 5
3 1 1000000
Output
7
Note
The sample is like this:
<image>
Submitted Solution:
```
import sys, math
import io, os
#data = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
#from bisect import bisect_left as bl, bisect_right as br, insort
#from heapq import heapify, heappush, heappop
#from collections import defaultdict as dd, deque, Counter
#from itertools import permutations,combinations
def data(): return sys.stdin.readline().strip()
def mdata(): return list(map(int, data().split()))
def outl(var) : sys.stdout.write(' '.join(map(str, var))+'\n')
def out(var) : sys.stdout.write(str(var)+'\n')
from decimal import Decimal
#from fractions import Fraction
#sys.setrecursionlimit(100000)
INF = float('inf')
mod = int(1e9)+7
class SortedList:
def __init__(self, iterable=[], _load=200):
"""Initialize sorted list instance."""
values = sorted(iterable)
self._len = _len = len(values)
self._load = _load
self._lists = _lists = [values[i:i + _load] for i in range(0, _len, _load)]
self._list_lens = [len(_list) for _list in _lists]
self._mins = [_list[0] for _list in _lists]
self._fen_tree = []
self._rebuild = True
def _fen_build(self):
"""Build a fenwick tree instance."""
self._fen_tree[:] = self._list_lens
_fen_tree = self._fen_tree
for i in range(len(_fen_tree)):
if i | i + 1 < len(_fen_tree):
_fen_tree[i | i + 1] += _fen_tree[i]
self._rebuild = False
def _fen_update(self, index, value):
"""Update `fen_tree[index] += value`."""
if not self._rebuild:
_fen_tree = self._fen_tree
while index < len(_fen_tree):
_fen_tree[index] += value
index |= index + 1
def _fen_query(self, end):
"""Return `sum(_fen_tree[:end])`."""
if self._rebuild:
self._fen_build()
_fen_tree = self._fen_tree
x = 0
while end:
x += _fen_tree[end - 1]
end &= end - 1
return x
def _fen_findkth(self, k):
"""Return a pair of (the largest `idx` such that `sum(_fen_tree[:idx]) <= k`, `k - sum(_fen_tree[:idx])`)."""
_list_lens = self._list_lens
if k < _list_lens[0]:
return 0, k
if k >= self._len - _list_lens[-1]:
return len(_list_lens) - 1, k + _list_lens[-1] - self._len
if self._rebuild:
self._fen_build()
_fen_tree = self._fen_tree
idx = -1
for d in reversed(range(len(_fen_tree).bit_length())):
right_idx = idx + (1 << d)
if right_idx < len(_fen_tree) and k >= _fen_tree[right_idx]:
idx = right_idx
k -= _fen_tree[idx]
return idx + 1, k
def _delete(self, pos, idx):
"""Delete value at the given `(pos, idx)`."""
_lists = self._lists
_mins = self._mins
_list_lens = self._list_lens
self._len -= 1
self._fen_update(pos, -1)
del _lists[pos][idx]
_list_lens[pos] -= 1
if _list_lens[pos]:
_mins[pos] = _lists[pos][0]
else:
del _lists[pos]
del _list_lens[pos]
del _mins[pos]
self._rebuild = True
def _loc_left(self, value):
"""Return an index pair that corresponds to the first position of `value` in the sorted list."""
if not self._len:
return 0, 0
_lists = self._lists
_mins = self._mins
lo, pos = -1, len(_lists) - 1
while lo + 1 < pos:
mi = (lo + pos) >> 1
if value <= _mins[mi]:
pos = mi
else:
lo = mi
if pos and value <= _lists[pos - 1][-1]:
pos -= 1
_list = _lists[pos]
lo, idx = -1, len(_list)
while lo + 1 < idx:
mi = (lo + idx) >> 1
if value <= _list[mi]:
idx = mi
else:
lo = mi
return pos, idx
def _loc_right(self, value):
"""Return an index pair that corresponds to the last position of `value` in the sorted list."""
if not self._len:
return 0, 0
_lists = self._lists
_mins = self._mins
pos, hi = 0, len(_lists)
while pos + 1 < hi:
mi = (pos + hi) >> 1
if value < _mins[mi]:
hi = mi
else:
pos = mi
_list = _lists[pos]
lo, idx = -1, len(_list)
while lo + 1 < idx:
mi = (lo + idx) >> 1
if value < _list[mi]:
idx = mi
else:
lo = mi
return pos, idx
def add(self, value):
"""Add `value` to sorted list."""
_load = self._load
_lists = self._lists
_mins = self._mins
_list_lens = self._list_lens
self._len += 1
if _lists:
pos, idx = self._loc_right(value)
self._fen_update(pos, 1)
_list = _lists[pos]
_list.insert(idx, value)
_list_lens[pos] += 1
_mins[pos] = _list[0]
if _load + _load < len(_list):
_lists.insert(pos + 1, _list[_load:])
_list_lens.insert(pos + 1, len(_list) - _load)
_mins.insert(pos + 1, _list[_load])
_list_lens[pos] = _load
del _list[_load:]
self._rebuild = True
else:
_lists.append([value])
_mins.append(value)
_list_lens.append(1)
self._rebuild = True
def discard(self, value):
"""Remove `value` from sorted list if it is a member."""
_lists = self._lists
if _lists:
pos, idx = self._loc_right(value)
if idx and _lists[pos][idx - 1] == value:
self._delete(pos, idx - 1)
def remove(self, value):
"""Remove `value` from sorted list; `value` must be a member."""
_len = self._len
self.discard(value)
if _len == self._len:
raise ValueError('{0!r} not in list'.format(value))
def pop(self, index=-1):
"""Remove and return value at `index` in sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
value = self._lists[pos][idx]
self._delete(pos, idx)
return value
def bisect_left(self, value):
"""Return the first index to insert `value` in the sorted list."""
pos, idx = self._loc_left(value)
return self._fen_query(pos) + idx
def bisect_right(self, value):
"""Return the last index to insert `value` in the sorted list."""
pos, idx = self._loc_right(value)
return self._fen_query(pos) + idx
def count(self, value):
"""Return number of occurrences of `value` in the sorted list."""
return self.bisect_right(value) - self.bisect_left(value)
def __len__(self):
"""Return the size of the sorted list."""
return self._len
def __getitem__(self, index):
"""Lookup value at `index` in sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
return self._lists[pos][idx]
def __delitem__(self, index):
"""Remove value at `index` from sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
self._delete(pos, idx)
def __contains__(self, value):
"""Return true if `value` is an element of the sorted list."""
_lists = self._lists
if _lists:
pos, idx = self._loc_left(value)
return idx < len(_lists[pos]) and _lists[pos][idx] == value
return False
def __iter__(self):
"""Return an iterator over the sorted list."""
return (value for _list in self._lists for value in _list)
def __reversed__(self):
"""Return a reverse iterator over the sorted list."""
return (value for _list in reversed(self._lists) for value in reversed(_list))
def __repr__(self):
"""Return string representation of sorted list."""
return 'SortedList({0})'.format(list(self))
n,m=mdata()
hor=[mdata() for i in range(n)]
ver=[mdata() for i in range(m)]
topVer=SortedList()
botVer=SortedList()
ans=1
for x,bot,top in ver:
if bot==0:
botVer.add(x)
if top==10**6:
ans+=1
else:
topVer.add(x)
hor.sort(key=lambda x:x[0],reverse=True)
ver.sort(key=lambda x:x[1],reverse=True)
ind1=0
for i in range(n):
if hor[i][1]==0 and hor[i][2]==10**6:
ans+=1
while ind1<m and topVer and ver[ind1][1]>hor[i][0]:
topVer.remove(ver[ind1][0])
ind1+=1
if hor[i][1]==0:
ans+=topVer.bisect_right(hor[i][2])
else:
ans+=len(topVer)-topVer.bisect_left(hor[i][1])
hor.reverse()
ver.sort(key=lambda x:x[2])
ind1=0
for i in range(n):
while ind1<m and botVer and ver[ind1][2]<hor[i][0]:
botVer.remove(ver[ind1][0])
ind1+=1
if hor[i][1]==0:
ans+=botVer.bisect_right(hor[i][2])
else:
ans+=len(botVer)-botVer.bisect_left(hor[i][1])
out(ans)
``` | instruction | 0 | 32,711 | 23 | 65,422 |
Yes | output | 1 | 32,711 | 23 | 65,423 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a square of size 10^6 × 10^6 on the coordinate plane with four points (0, 0), (0, 10^6), (10^6, 0), and (10^6, 10^6) as its vertices.
You are going to draw segments on the plane. All segments are either horizontal or vertical and intersect with at least one side of the square.
Now you are wondering how many pieces this square divides into after drawing all segments. Write a program calculating the number of pieces of the square.
Input
The first line contains two integers n and m (0 ≤ n, m ≤ 10^5) — the number of horizontal segments and the number of vertical segments.
The next n lines contain descriptions of the horizontal segments. The i-th line contains three integers y_i, lx_i and rx_i (0 < y_i < 10^6; 0 ≤ lx_i < rx_i ≤ 10^6), which means the segment connects (lx_i, y_i) and (rx_i, y_i).
The next m lines contain descriptions of the vertical segments. The i-th line contains three integers x_i, ly_i and ry_i (0 < x_i < 10^6; 0 ≤ ly_i < ry_i ≤ 10^6), which means the segment connects (x_i, ly_i) and (x_i, ry_i).
It's guaranteed that there are no two segments on the same line, and each segment intersects with at least one of square's sides.
Output
Print the number of pieces the square is divided into after drawing all the segments.
Example
Input
3 3
2 3 1000000
4 0 4
3 0 1000000
4 0 1
2 0 5
3 1 1000000
Output
7
Note
The sample is like this:
<image>
Submitted Solution:
```
horiz = []
vert = []
n, m = map(int, input().split())
for _ in range(n):
y, lx, rx = map(int, input().split())
horiz.append([y, lx, rx])
horiz.sort()
polys = 0
for _ in range(m):
x, ly, ry = map(int, input().split())
for h in horiz:
if (ry >= h[0] and h[0] >= ly) and (h[2] >= x and x >= h[1]):
counter = 0
if (ly == 0):
counter+=1
if (ry == 1000000):
counter+=1
if (h[1] == 0):
counter+=1
if (h[2] == 1000000):
counter+=1
print("*****")
print(counter)
polys+=2**(counter-2)
print("*****")
print(polys)
``` | instruction | 0 | 32,712 | 23 | 65,424 |
No | output | 1 | 32,712 | 23 | 65,425 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a square of size 10^6 × 10^6 on the coordinate plane with four points (0, 0), (0, 10^6), (10^6, 0), and (10^6, 10^6) as its vertices.
You are going to draw segments on the plane. All segments are either horizontal or vertical and intersect with at least one side of the square.
Now you are wondering how many pieces this square divides into after drawing all segments. Write a program calculating the number of pieces of the square.
Input
The first line contains two integers n and m (0 ≤ n, m ≤ 10^5) — the number of horizontal segments and the number of vertical segments.
The next n lines contain descriptions of the horizontal segments. The i-th line contains three integers y_i, lx_i and rx_i (0 < y_i < 10^6; 0 ≤ lx_i < rx_i ≤ 10^6), which means the segment connects (lx_i, y_i) and (rx_i, y_i).
The next m lines contain descriptions of the vertical segments. The i-th line contains three integers x_i, ly_i and ry_i (0 < x_i < 10^6; 0 ≤ ly_i < ry_i ≤ 10^6), which means the segment connects (x_i, ly_i) and (x_i, ry_i).
It's guaranteed that there are no two segments on the same line, and each segment intersects with at least one of square's sides.
Output
Print the number of pieces the square is divided into after drawing all the segments.
Example
Input
3 3
2 3 1000000
4 0 4
3 0 1000000
4 0 1
2 0 5
3 1 1000000
Output
7
Note
The sample is like this:
<image>
Submitted Solution:
```
n,m = map(int,input().split())
k = 10**6
heights = [[0,[0,k]],[0,[k,0]],[k,[0,k]],[k,[k,0]]]
ans=0
for i in range(n):
l1 = list(map(int,input().split()))
#heights.append(l1[0])
heights.append([l1[0],[l1[1],l1[2]]])
#vertisegs.append([l1[1],l1[2]])
for i in range(m):
l2 = list(map(int,input().split()))
for x in range(n+4):
if l2[0]>=heights[x][1][0] and l2[0]<=heights[x][1][1]:
if l2[1]<=heights[x][0] and l2[2]>=heights[x][0]:
ans+=1
else:
break
print(ans)
``` | instruction | 0 | 32,713 | 23 | 65,426 |
No | output | 1 | 32,713 | 23 | 65,427 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a square of size 10^6 × 10^6 on the coordinate plane with four points (0, 0), (0, 10^6), (10^6, 0), and (10^6, 10^6) as its vertices.
You are going to draw segments on the plane. All segments are either horizontal or vertical and intersect with at least one side of the square.
Now you are wondering how many pieces this square divides into after drawing all segments. Write a program calculating the number of pieces of the square.
Input
The first line contains two integers n and m (0 ≤ n, m ≤ 10^5) — the number of horizontal segments and the number of vertical segments.
The next n lines contain descriptions of the horizontal segments. The i-th line contains three integers y_i, lx_i and rx_i (0 < y_i < 10^6; 0 ≤ lx_i < rx_i ≤ 10^6), which means the segment connects (lx_i, y_i) and (rx_i, y_i).
The next m lines contain descriptions of the vertical segments. The i-th line contains three integers x_i, ly_i and ry_i (0 < x_i < 10^6; 0 ≤ ly_i < ry_i ≤ 10^6), which means the segment connects (x_i, ly_i) and (x_i, ry_i).
It's guaranteed that there are no two segments on the same line, and each segment intersects with at least one of square's sides.
Output
Print the number of pieces the square is divided into after drawing all the segments.
Example
Input
3 3
2 3 1000000
4 0 4
3 0 1000000
4 0 1
2 0 5
3 1 1000000
Output
7
Note
The sample is like this:
<image>
Submitted Solution:
```
#!/usr/bin/env python3
import sys
input=sys.stdin.readline
class BIT:
def __init__(self,n):
self.n=n+1
self.BIT=[0]*self.n
def add(self,i,x):
idx=i
while idx<self.n:
self.BIT[idx]+=x
idx+=(idx&-idx)
def _sum(self,i):
if i==-1:
return -1
ret=0
idx=i
while idx>0:
ret+=self.BIT[idx]
idx-=(idx&-idx)
return ret
def sum(self,l,r):
return self._sum(r)-self._sum(l-1)
def value(self,i):
return self._sum(i)-self._sum(i-1)
bound=10**6
n,m=map(int,input().split())
yoko_edges=[list(map(int,input().split())) for _ in range(n)]
yoko_edges=sorted(yoko_edges,reverse=True,key=lambda x:x[0])
ue_tate_edges=[[] for _ in range(bound+1)]
sita_tate_edges=[[] for _ in range(bound+1)]
tate_edges=BIT(bound)
tate_edges.add(bound,1)
ans=1
for _ in range(m):
x,l,r=map(int,input().split())
if l==0 and r==bound:
tate_edges.add(x,1)
ans+=1
elif l==0:
sita_tate_edges[r].append(x)
elif r==bound:
ue_tate_edges[l].append(x)
tate_edges.add(x,1)
prev=bound
for y,l,r in yoko_edges:
while prev>=y:
for x in sita_tate_edges[prev]:
tate_edges.add(x,1)
for x in ue_tate_edges[prev]:
tate_edges.add(x,-1)
prev-=1
ans+=tate_edges.sum(l,r)-1
print(ans)
``` | instruction | 0 | 32,714 | 23 | 65,428 |
No | output | 1 | 32,714 | 23 | 65,429 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.