message stringlengths 2 20.1k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 1.95k 109k | cluster float64 17 17 | __index_level_0__ int64 3.91k 217k |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
The R1 company wants to hold a web search championship. There were n computers given for the competition, each of them is connected to the Internet. The organizers believe that the data transfer speed directly affects the result. The higher the speed of the Internet is, the faster the participant will find the necessary information. Therefore, before the competition started, each computer had its maximum possible data transfer speed measured. On the i-th computer it was ai kilobits per second.
There will be k participants competing in the championship, each should get a separate computer. The organizing company does not want any of the participants to have an advantage over the others, so they want to provide the same data transfer speed to each participant's computer. Also, the organizers want to create the most comfortable conditions for the participants, so the data transfer speed on the participants' computers should be as large as possible.
The network settings of the R1 company has a special option that lets you to cut the initial maximum data transfer speed of any computer to any lower speed. How should the R1 company configure the network using the described option so that at least k of n computers had the same data transfer speed and the data transfer speed on these computers was as large as possible?
Input
The first line contains two space-separated integers n and k (1 ≤ k ≤ n ≤ 100) — the number of computers and the number of participants, respectively. In the second line you have a space-separated sequence consisting of n integers: a1, a2, ..., an (16 ≤ ai ≤ 32768); number ai denotes the maximum data transfer speed on the i-th computer.
Output
Print a single integer — the maximum Internet speed value. It is guaranteed that the answer to the problem is always an integer.
Examples
Input
3 2
40 20 30
Output
30
Input
6 4
100 20 40 20 50 50
Output
40
Note
In the first test case the organizers can cut the first computer's speed to 30 kilobits. Then two computers (the first and the third one) will have the same speed of 30 kilobits. They should be used as the participants' computers. This answer is optimal. | instruction | 0 | 44,179 | 17 | 88,358 |
Tags: greedy, sortings
Correct Solution:
```
n, k = map(int, input().split())
s = sorted(list(map(int, input().split())), reverse = True)
print(s[k - 1])
``` | output | 1 | 44,179 | 17 | 88,359 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The R1 company wants to hold a web search championship. There were n computers given for the competition, each of them is connected to the Internet. The organizers believe that the data transfer speed directly affects the result. The higher the speed of the Internet is, the faster the participant will find the necessary information. Therefore, before the competition started, each computer had its maximum possible data transfer speed measured. On the i-th computer it was ai kilobits per second.
There will be k participants competing in the championship, each should get a separate computer. The organizing company does not want any of the participants to have an advantage over the others, so they want to provide the same data transfer speed to each participant's computer. Also, the organizers want to create the most comfortable conditions for the participants, so the data transfer speed on the participants' computers should be as large as possible.
The network settings of the R1 company has a special option that lets you to cut the initial maximum data transfer speed of any computer to any lower speed. How should the R1 company configure the network using the described option so that at least k of n computers had the same data transfer speed and the data transfer speed on these computers was as large as possible?
Input
The first line contains two space-separated integers n and k (1 ≤ k ≤ n ≤ 100) — the number of computers and the number of participants, respectively. In the second line you have a space-separated sequence consisting of n integers: a1, a2, ..., an (16 ≤ ai ≤ 32768); number ai denotes the maximum data transfer speed on the i-th computer.
Output
Print a single integer — the maximum Internet speed value. It is guaranteed that the answer to the problem is always an integer.
Examples
Input
3 2
40 20 30
Output
30
Input
6 4
100 20 40 20 50 50
Output
40
Note
In the first test case the organizers can cut the first computer's speed to 30 kilobits. Then two computers (the first and the third one) will have the same speed of 30 kilobits. They should be used as the participants' computers. This answer is optimal. | instruction | 0 | 44,180 | 17 | 88,360 |
Tags: greedy, sortings
Correct Solution:
```
n, k = list(map(int, input().split()))
ar = list(map(int, input().split()))
ar = sorted(ar, reverse=True)
print(ar[k-1])
``` | output | 1 | 44,180 | 17 | 88,361 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The R1 company wants to hold a web search championship. There were n computers given for the competition, each of them is connected to the Internet. The organizers believe that the data transfer speed directly affects the result. The higher the speed of the Internet is, the faster the participant will find the necessary information. Therefore, before the competition started, each computer had its maximum possible data transfer speed measured. On the i-th computer it was ai kilobits per second.
There will be k participants competing in the championship, each should get a separate computer. The organizing company does not want any of the participants to have an advantage over the others, so they want to provide the same data transfer speed to each participant's computer. Also, the organizers want to create the most comfortable conditions for the participants, so the data transfer speed on the participants' computers should be as large as possible.
The network settings of the R1 company has a special option that lets you to cut the initial maximum data transfer speed of any computer to any lower speed. How should the R1 company configure the network using the described option so that at least k of n computers had the same data transfer speed and the data transfer speed on these computers was as large as possible?
Input
The first line contains two space-separated integers n and k (1 ≤ k ≤ n ≤ 100) — the number of computers and the number of participants, respectively. In the second line you have a space-separated sequence consisting of n integers: a1, a2, ..., an (16 ≤ ai ≤ 32768); number ai denotes the maximum data transfer speed on the i-th computer.
Output
Print a single integer — the maximum Internet speed value. It is guaranteed that the answer to the problem is always an integer.
Examples
Input
3 2
40 20 30
Output
30
Input
6 4
100 20 40 20 50 50
Output
40
Note
In the first test case the organizers can cut the first computer's speed to 30 kilobits. Then two computers (the first and the third one) will have the same speed of 30 kilobits. They should be used as the participants' computers. This answer is optimal. | instruction | 0 | 44,181 | 17 | 88,362 |
Tags: greedy, sortings
Correct Solution:
```
n,k=map(int,input().split())
a=list(map(int,input().split()))
a.sort()
x=(n-k)
print(a[x])
``` | output | 1 | 44,181 | 17 | 88,363 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The R1 company wants to hold a web search championship. There were n computers given for the competition, each of them is connected to the Internet. The organizers believe that the data transfer speed directly affects the result. The higher the speed of the Internet is, the faster the participant will find the necessary information. Therefore, before the competition started, each computer had its maximum possible data transfer speed measured. On the i-th computer it was ai kilobits per second.
There will be k participants competing in the championship, each should get a separate computer. The organizing company does not want any of the participants to have an advantage over the others, so they want to provide the same data transfer speed to each participant's computer. Also, the organizers want to create the most comfortable conditions for the participants, so the data transfer speed on the participants' computers should be as large as possible.
The network settings of the R1 company has a special option that lets you to cut the initial maximum data transfer speed of any computer to any lower speed. How should the R1 company configure the network using the described option so that at least k of n computers had the same data transfer speed and the data transfer speed on these computers was as large as possible?
Input
The first line contains two space-separated integers n and k (1 ≤ k ≤ n ≤ 100) — the number of computers and the number of participants, respectively. In the second line you have a space-separated sequence consisting of n integers: a1, a2, ..., an (16 ≤ ai ≤ 32768); number ai denotes the maximum data transfer speed on the i-th computer.
Output
Print a single integer — the maximum Internet speed value. It is guaranteed that the answer to the problem is always an integer.
Examples
Input
3 2
40 20 30
Output
30
Input
6 4
100 20 40 20 50 50
Output
40
Note
In the first test case the organizers can cut the first computer's speed to 30 kilobits. Then two computers (the first and the third one) will have the same speed of 30 kilobits. They should be used as the participants' computers. This answer is optimal. | instruction | 0 | 44,182 | 17 | 88,364 |
Tags: greedy, sortings
Correct Solution:
```
import sys
import math
import itertools
import collections
def divs(n, start=1):
r = []
for i in range(start, int(math.sqrt(n) + 1)):
if (n % i == 0):
if (n / i == i):
r.append(i)
else:
r.extend([i, n // i])
return r
def cdiv(n, k): return n // k + (n % k != 0)
def ii(): return int(input())
def mi(): return map(int, input().split())
def li(): return list(map(int, input().split()))
def lcm(a, b): return abs(a*b) // math.gcd(a, b)
def wr(arr): return ''.join(map(str, arr))
def revn(n): return int(str(n)[::-1])
def prime(n):
if n == 2: return True
if n % 2 == 0 or n <= 1: return False
sqr = int(math.sqrt(n)) + 1
for d in range(3, sqr, 2):
if n % d == 0: return False
return True
def convn(number, base=3):
newnumber = ''
while number > 0:
newnumber = str(number % base) + newnumber
number //= base
return newnumber
n, k = mi()
a = li()
a.sort(reverse=True)
print(a[k - 1])
``` | output | 1 | 44,182 | 17 | 88,365 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The R1 company wants to hold a web search championship. There were n computers given for the competition, each of them is connected to the Internet. The organizers believe that the data transfer speed directly affects the result. The higher the speed of the Internet is, the faster the participant will find the necessary information. Therefore, before the competition started, each computer had its maximum possible data transfer speed measured. On the i-th computer it was ai kilobits per second.
There will be k participants competing in the championship, each should get a separate computer. The organizing company does not want any of the participants to have an advantage over the others, so they want to provide the same data transfer speed to each participant's computer. Also, the organizers want to create the most comfortable conditions for the participants, so the data transfer speed on the participants' computers should be as large as possible.
The network settings of the R1 company has a special option that lets you to cut the initial maximum data transfer speed of any computer to any lower speed. How should the R1 company configure the network using the described option so that at least k of n computers had the same data transfer speed and the data transfer speed on these computers was as large as possible?
Input
The first line contains two space-separated integers n and k (1 ≤ k ≤ n ≤ 100) — the number of computers and the number of participants, respectively. In the second line you have a space-separated sequence consisting of n integers: a1, a2, ..., an (16 ≤ ai ≤ 32768); number ai denotes the maximum data transfer speed on the i-th computer.
Output
Print a single integer — the maximum Internet speed value. It is guaranteed that the answer to the problem is always an integer.
Examples
Input
3 2
40 20 30
Output
30
Input
6 4
100 20 40 20 50 50
Output
40
Note
In the first test case the organizers can cut the first computer's speed to 30 kilobits. Then two computers (the first and the third one) will have the same speed of 30 kilobits. They should be used as the participants' computers. This answer is optimal. | instruction | 0 | 44,183 | 17 | 88,366 |
Tags: greedy, sortings
Correct Solution:
```
n, k = map(int, input().split())
a = list(map(int, input().split()))
a = sorted(a)
print(a[n-k])
``` | output | 1 | 44,183 | 17 | 88,367 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The R1 company wants to hold a web search championship. There were n computers given for the competition, each of them is connected to the Internet. The organizers believe that the data transfer speed directly affects the result. The higher the speed of the Internet is, the faster the participant will find the necessary information. Therefore, before the competition started, each computer had its maximum possible data transfer speed measured. On the i-th computer it was ai kilobits per second.
There will be k participants competing in the championship, each should get a separate computer. The organizing company does not want any of the participants to have an advantage over the others, so they want to provide the same data transfer speed to each participant's computer. Also, the organizers want to create the most comfortable conditions for the participants, so the data transfer speed on the participants' computers should be as large as possible.
The network settings of the R1 company has a special option that lets you to cut the initial maximum data transfer speed of any computer to any lower speed. How should the R1 company configure the network using the described option so that at least k of n computers had the same data transfer speed and the data transfer speed on these computers was as large as possible?
Input
The first line contains two space-separated integers n and k (1 ≤ k ≤ n ≤ 100) — the number of computers and the number of participants, respectively. In the second line you have a space-separated sequence consisting of n integers: a1, a2, ..., an (16 ≤ ai ≤ 32768); number ai denotes the maximum data transfer speed on the i-th computer.
Output
Print a single integer — the maximum Internet speed value. It is guaranteed that the answer to the problem is always an integer.
Examples
Input
3 2
40 20 30
Output
30
Input
6 4
100 20 40 20 50 50
Output
40
Note
In the first test case the organizers can cut the first computer's speed to 30 kilobits. Then two computers (the first and the third one) will have the same speed of 30 kilobits. They should be used as the participants' computers. This answer is optimal. | instruction | 0 | 44,184 | 17 | 88,368 |
Tags: greedy, sortings
Correct Solution:
```
n, m = [int(j) for j in input().split()]
speed = sorted([int(j) for j in input().split()])
print(speed[n - m])
``` | output | 1 | 44,184 | 17 | 88,369 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The University of Aizu started a new system for taking classes in 2009. Under the new system, compulsory subjects have been abolished, and subjects can be freely selected in consideration of each course.
However, not all courses can be taken unconditionally, and in order to take a specific course, it is necessary to meet the pre-registration conditions. The figure below shows some examples of the course schedule:
<image>
The rectangle in the figure represents one subject and contains the subject name and the number of credits. The arrows in the figure indicate the pre-repair conditions. The meaning of the arrow is that in order to take the subject pointed to by the end point of the arrow, it is necessary to have acquired the subject indicating the start point of the arrow. For example, in order to take Linear Algebra II (Linear Algebra 2), it is necessary to have mastered Linear Algebra I (Linear Algebra 1). Also, in order to take Applied Algebra, you need to have both Linear Algebra I and Discrete Systems.
By the way, the combination of courses that meets the minimum total number of credits U required for graduation in the course registration plan is interesting for lazy students.
Your job is to create a program that reads the given course schedule and U and reports the minimum number of courses taken. Since this is a plan, it is assumed that the courses registered for the course will always be able to earn credits.
Input
The input consists of multiple datasets. Each dataset is given in the following format:
> n U
> c0 k0 r01 r02 ... r0 k0
> c1 k1 r11 r12 ... r1 k1
> ..
> ..
> cn-1 kn-1 r (n-1) 1 r (n-1) 2 ... r (n-1) kn-1
>
n (1 ≤ n ≤ 20) is an integer indicating the number of courses included in the course schedule. It is assumed that the subjects are assigned numbers from 0 to n-1, and the i-th subject is referred to as subject i below.
U (1 ≤ U ≤ 100) is an integer representing the total number of units required.
ci (1 ≤ ci ≤ 10) indicates the number of credits in subject i. The next ki (0 ≤ ki ≤ 5) indicates the number of pre-study subjects in subject i. Subsequent ri1 ri2 ... riki indicates the subject number of the pre-study subject of subject i.
No input is given to follow one or more arrows indicating the pre-repair conditions from a subject and return to that subject again. It may also be assumed that there is always a combination of subjects that satisfy U.
When both n and U are 0, it indicates the end of input. The number of datasets does not exceed 100.
Output
For each dataset, output the minimum required number of subjects on one line.
Example
Input
4 4
1 0
3 2 0 2
2 0
2 0
3 6
1 0
3 2 0 2
2 0
0 0
Output
2
3
Submitted Solution:
```
# AOJ 1032 Course Planning for Lazy Students
# Python3 2018.7.6 bal4u
import sys
from sys import stdin
input = stdin.readline
def bitcount(bits): return bin(bits).count('1')
while True:
n, U = map(int, input().split())
if n == 0: break
c, r = [], []
for i in range(n):
a = list(map(int, input().split()))
c.append(a[0])
t = 0
for x in a[2:]: t |= (1<<x)
r.append(t)
mk = [0]*(1<<n)
mk[0] = 1
Q = []
Q.append((0, 0))
while Q != []:
s, k = Q.pop(0)
if k >= U: break
for i in range(n):
if s & (1<<i): continue
t = s | (1<<i)
if (r[i]&s) == r[i] and mk[t] == 0:
mk[t] = 1
Q.append((t, k+c[i]))
print(bitcount(s))
``` | instruction | 0 | 44,599 | 17 | 89,198 |
No | output | 1 | 44,599 | 17 | 89,199 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n students and m clubs in a college. The clubs are numbered from 1 to m. Each student has a potential p_i and is a member of the club with index c_i. Initially, each student is a member of exactly one club. A technical fest starts in the college, and it will run for the next d days. There is a coding competition every day in the technical fest.
Every day, in the morning, exactly one student of the college leaves their club. Once a student leaves their club, they will never join any club again. Every day, in the afternoon, the director of the college will select one student from each club (in case some club has no members, nobody is selected from that club) to form a team for this day's coding competition. The strength of a team is the mex of potentials of the students in the team. The director wants to know the maximum possible strength of the team for each of the coming d days. Thus, every day the director chooses such team, that the team strength is maximized.
The mex of the multiset S is the smallest non-negative integer that is not present in S. For example, the mex of the \{0, 1, 1, 2, 4, 5, 9\} is 3, the mex of \{1, 2, 3\} is 0 and the mex of ∅ (empty set) is 0.
Input
The first line contains two integers n and m (1 ≤ m ≤ n ≤ 5000), the number of students and the number of clubs in college.
The second line contains n integers p_1, p_2, …, p_n (0 ≤ p_i < 5000), where p_i is the potential of the i-th student.
The third line contains n integers c_1, c_2, …, c_n (1 ≤ c_i ≤ m), which means that i-th student is initially a member of the club with index c_i.
The fourth line contains an integer d (1 ≤ d ≤ n), number of days for which the director wants to know the maximum possible strength of the team.
Each of the next d lines contains an integer k_i (1 ≤ k_i ≤ n), which means that k_i-th student lefts their club on the i-th day. It is guaranteed, that the k_i-th student has not left their club earlier.
Output
For each of the d days, print the maximum possible strength of the team on that day.
Examples
Input
5 3
0 1 2 2 0
1 2 2 3 2
5
3
2
4
5
1
Output
3
1
1
1
0
Input
5 3
0 1 2 2 1
1 3 2 3 2
5
4
2
3
5
1
Output
3
2
2
1
0
Input
5 5
0 1 2 4 5
1 2 3 4 5
4
2
3
5
4
Output
1
1
1
1
Note
Consider the first example:
On the first day, student 3 leaves their club. Now, the remaining students are 1, 2, 4 and 5. We can select students 1, 2 and 4 to get maximum possible strength, which is 3. Note, that we can't select students 1, 2 and 5, as students 2 and 5 belong to the same club. Also, we can't select students 1, 3 and 4, since student 3 has left their club.
On the second day, student 2 leaves their club. Now, the remaining students are 1, 4 and 5. We can select students 1, 4 and 5 to get maximum possible strength, which is 1.
On the third day, the remaining students are 1 and 5. We can select students 1 and 5 to get maximum possible strength, which is 1.
On the fourth day, the remaining student is 1. We can select student 1 to get maximum possible strength, which is 1.
On the fifth day, no club has students and so the maximum possible strength is 0. | instruction | 0 | 45,434 | 17 | 90,868 |
Tags: flows, graph matchings, graphs
Correct Solution:
```
n, m = map(int, input().split())
p = list(map(int, input().split()))
c = list(map(int, input().split()))
d = int(input())
k = []
for i in range(d):
k.append(int(input()))
vis = [False for i in range(m+1)]
match = [-1 for i in range(m+1)]
def dfs(u: int) -> bool:
for v in e[u]:
if not vis[v]:
vis[v] = True
if match[v] == -1 or dfs(match[v]):
match[v] = u
return True
return False
e = [[] for i in range(5005)]
for i in range(n):
if i + 1 not in k:
e[p[i]].append(c[i])
mex = 0
ans = []
for i in range(d - 1, -1, -1):
while True:
vis = [False for j in range(m+1)]
if not dfs(mex):
break
mex += 1
ans.append(mex)
e[p[k[i]-1]].append(c[k[i]-1])
for i in reversed(ans):
print(i)
``` | output | 1 | 45,434 | 17 | 90,869 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n students and m clubs in a college. The clubs are numbered from 1 to m. Each student has a potential p_i and is a member of the club with index c_i. Initially, each student is a member of exactly one club. A technical fest starts in the college, and it will run for the next d days. There is a coding competition every day in the technical fest.
Every day, in the morning, exactly one student of the college leaves their club. Once a student leaves their club, they will never join any club again. Every day, in the afternoon, the director of the college will select one student from each club (in case some club has no members, nobody is selected from that club) to form a team for this day's coding competition. The strength of a team is the mex of potentials of the students in the team. The director wants to know the maximum possible strength of the team for each of the coming d days. Thus, every day the director chooses such team, that the team strength is maximized.
The mex of the multiset S is the smallest non-negative integer that is not present in S. For example, the mex of the \{0, 1, 1, 2, 4, 5, 9\} is 3, the mex of \{1, 2, 3\} is 0 and the mex of ∅ (empty set) is 0.
Input
The first line contains two integers n and m (1 ≤ m ≤ n ≤ 5000), the number of students and the number of clubs in college.
The second line contains n integers p_1, p_2, …, p_n (0 ≤ p_i < 5000), where p_i is the potential of the i-th student.
The third line contains n integers c_1, c_2, …, c_n (1 ≤ c_i ≤ m), which means that i-th student is initially a member of the club with index c_i.
The fourth line contains an integer d (1 ≤ d ≤ n), number of days for which the director wants to know the maximum possible strength of the team.
Each of the next d lines contains an integer k_i (1 ≤ k_i ≤ n), which means that k_i-th student lefts their club on the i-th day. It is guaranteed, that the k_i-th student has not left their club earlier.
Output
For each of the d days, print the maximum possible strength of the team on that day.
Examples
Input
5 3
0 1 2 2 0
1 2 2 3 2
5
3
2
4
5
1
Output
3
1
1
1
0
Input
5 3
0 1 2 2 1
1 3 2 3 2
5
4
2
3
5
1
Output
3
2
2
1
0
Input
5 5
0 1 2 4 5
1 2 3 4 5
4
2
3
5
4
Output
1
1
1
1
Note
Consider the first example:
On the first day, student 3 leaves their club. Now, the remaining students are 1, 2, 4 and 5. We can select students 1, 2 and 4 to get maximum possible strength, which is 3. Note, that we can't select students 1, 2 and 5, as students 2 and 5 belong to the same club. Also, we can't select students 1, 3 and 4, since student 3 has left their club.
On the second day, student 2 leaves their club. Now, the remaining students are 1, 4 and 5. We can select students 1, 4 and 5 to get maximum possible strength, which is 1.
On the third day, the remaining students are 1 and 5. We can select students 1 and 5 to get maximum possible strength, which is 1.
On the fourth day, the remaining student is 1. We can select student 1 to get maximum possible strength, which is 1.
On the fifth day, no club has students and so the maximum possible strength is 0. | instruction | 0 | 45,435 | 17 | 90,870 |
Tags: flows, graph matchings, graphs
Correct Solution:
```
import sys
input = sys.stdin.readline
n, m = map(int, input().split())
p = list(map(int, input().split()))
c = list(map(int, input().split()))
d = int(input())
disable = [False] * n
base = 5001
ds = [int(input())-1 for _ in range(d)]
for ele in ds:
disable[ele] = True
# Create Graph
childs = [[] for i in range(base+m+1)]
for idx, (i, j) in enumerate(zip(p, c)):
if not disable[idx]:
childs[i].append(base+j)
# dfs
# alternative path for finding maximum cardinality
vis = [False]*(base+m+1)
matching = [-1]*(base+m+1)
def dfs(num):
for child in childs[num]:
if not vis[child]:
vis[child] = True
if matching[child] == -1 or dfs(matching[child]):
matching[child] = num
return True
return False
ans = []
mex = 0
for idx in range(d-1, -1, -1):
while True:
vis = [False]*(base+m+1)
if not dfs(mex):
break
mex += 1
# Add edge
ans.append(mex)
childs[p[ds[idx]]].append(base+c[ds[idx]])
print("\n".join([str(a) for a in reversed(ans)]))
``` | output | 1 | 45,435 | 17 | 90,871 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n students and m clubs in a college. The clubs are numbered from 1 to m. Each student has a potential p_i and is a member of the club with index c_i. Initially, each student is a member of exactly one club. A technical fest starts in the college, and it will run for the next d days. There is a coding competition every day in the technical fest.
Every day, in the morning, exactly one student of the college leaves their club. Once a student leaves their club, they will never join any club again. Every day, in the afternoon, the director of the college will select one student from each club (in case some club has no members, nobody is selected from that club) to form a team for this day's coding competition. The strength of a team is the mex of potentials of the students in the team. The director wants to know the maximum possible strength of the team for each of the coming d days. Thus, every day the director chooses such team, that the team strength is maximized.
The mex of the multiset S is the smallest non-negative integer that is not present in S. For example, the mex of the \{0, 1, 1, 2, 4, 5, 9\} is 3, the mex of \{1, 2, 3\} is 0 and the mex of ∅ (empty set) is 0.
Input
The first line contains two integers n and m (1 ≤ m ≤ n ≤ 5000), the number of students and the number of clubs in college.
The second line contains n integers p_1, p_2, …, p_n (0 ≤ p_i < 5000), where p_i is the potential of the i-th student.
The third line contains n integers c_1, c_2, …, c_n (1 ≤ c_i ≤ m), which means that i-th student is initially a member of the club with index c_i.
The fourth line contains an integer d (1 ≤ d ≤ n), number of days for which the director wants to know the maximum possible strength of the team.
Each of the next d lines contains an integer k_i (1 ≤ k_i ≤ n), which means that k_i-th student lefts their club on the i-th day. It is guaranteed, that the k_i-th student has not left their club earlier.
Output
For each of the d days, print the maximum possible strength of the team on that day.
Examples
Input
5 3
0 1 2 2 0
1 2 2 3 2
5
3
2
4
5
1
Output
3
1
1
1
0
Input
5 3
0 1 2 2 1
1 3 2 3 2
5
4
2
3
5
1
Output
3
2
2
1
0
Input
5 5
0 1 2 4 5
1 2 3 4 5
4
2
3
5
4
Output
1
1
1
1
Note
Consider the first example:
On the first day, student 3 leaves their club. Now, the remaining students are 1, 2, 4 and 5. We can select students 1, 2 and 4 to get maximum possible strength, which is 3. Note, that we can't select students 1, 2 and 5, as students 2 and 5 belong to the same club. Also, we can't select students 1, 3 and 4, since student 3 has left their club.
On the second day, student 2 leaves their club. Now, the remaining students are 1, 4 and 5. We can select students 1, 4 and 5 to get maximum possible strength, which is 1.
On the third day, the remaining students are 1 and 5. We can select students 1 and 5 to get maximum possible strength, which is 1.
On the fourth day, the remaining student is 1. We can select student 1 to get maximum possible strength, which is 1.
On the fifth day, no club has students and so the maximum possible strength is 0.
Submitted Solution:
```
# 1139E
import collections
def do():
students, clubs = map(int, input().split(" "))
p = [int(i) for i in input().split(" ")]
stu2club = [int(i) - 1 for i in input().split(" ")]
g = collections.defaultdict(set)
days = int(input())
delete = [False] * students
query = [0] * days
res = [0] * (days + 1)
match = [-1] * clubs
seen = [0] * 5001
for _ in range(days):
i = int(input()) - 1
delete[i] = True
query[_] = i
for i in range(students):
if not delete[i]:
g[p[i]].add(stu2club[i]) # p -> club
def dfs(mex):
nonlocal cur
seen[mex] = cur
for club in g[mex]:
if match[club] != -1 and seen[match[club]] == cur:
continue
if match[club] == -1 or dfs(match[club]):
match[club] = mex
return True
return False
cur = 1
for i in range(days - 1, -1, -1):
res[i] = res[i + 1]
while dfs(res[i]):
res[i] += 1
cur += 1
new_student = query[i]
g[p[new_student]].add(stu2club[new_student])
for i in range(days):
print(res[i])
do()
``` | instruction | 0 | 45,436 | 17 | 90,872 |
No | output | 1 | 45,436 | 17 | 90,873 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n students and m clubs in a college. The clubs are numbered from 1 to m. Each student has a potential p_i and is a member of the club with index c_i. Initially, each student is a member of exactly one club. A technical fest starts in the college, and it will run for the next d days. There is a coding competition every day in the technical fest.
Every day, in the morning, exactly one student of the college leaves their club. Once a student leaves their club, they will never join any club again. Every day, in the afternoon, the director of the college will select one student from each club (in case some club has no members, nobody is selected from that club) to form a team for this day's coding competition. The strength of a team is the mex of potentials of the students in the team. The director wants to know the maximum possible strength of the team for each of the coming d days. Thus, every day the director chooses such team, that the team strength is maximized.
The mex of the multiset S is the smallest non-negative integer that is not present in S. For example, the mex of the \{0, 1, 1, 2, 4, 5, 9\} is 3, the mex of \{1, 2, 3\} is 0 and the mex of ∅ (empty set) is 0.
Input
The first line contains two integers n and m (1 ≤ m ≤ n ≤ 5000), the number of students and the number of clubs in college.
The second line contains n integers p_1, p_2, …, p_n (0 ≤ p_i < 5000), where p_i is the potential of the i-th student.
The third line contains n integers c_1, c_2, …, c_n (1 ≤ c_i ≤ m), which means that i-th student is initially a member of the club with index c_i.
The fourth line contains an integer d (1 ≤ d ≤ n), number of days for which the director wants to know the maximum possible strength of the team.
Each of the next d lines contains an integer k_i (1 ≤ k_i ≤ n), which means that k_i-th student lefts their club on the i-th day. It is guaranteed, that the k_i-th student has not left their club earlier.
Output
For each of the d days, print the maximum possible strength of the team on that day.
Examples
Input
5 3
0 1 2 2 0
1 2 2 3 2
5
3
2
4
5
1
Output
3
1
1
1
0
Input
5 3
0 1 2 2 1
1 3 2 3 2
5
4
2
3
5
1
Output
3
2
2
1
0
Input
5 5
0 1 2 4 5
1 2 3 4 5
4
2
3
5
4
Output
1
1
1
1
Note
Consider the first example:
On the first day, student 3 leaves their club. Now, the remaining students are 1, 2, 4 and 5. We can select students 1, 2 and 4 to get maximum possible strength, which is 3. Note, that we can't select students 1, 2 and 5, as students 2 and 5 belong to the same club. Also, we can't select students 1, 3 and 4, since student 3 has left their club.
On the second day, student 2 leaves their club. Now, the remaining students are 1, 4 and 5. We can select students 1, 4 and 5 to get maximum possible strength, which is 1.
On the third day, the remaining students are 1 and 5. We can select students 1 and 5 to get maximum possible strength, which is 1.
On the fourth day, the remaining student is 1. We can select student 1 to get maximum possible strength, which is 1.
On the fifth day, no club has students and so the maximum possible strength is 0.
Submitted Solution:
```
# import time
import itertools
def delete_node(children, node):
for v in children:
v.discard(node)
def find_longest_path(children, clubs, frontier):
clubs_visited = []
path = []
top_path = []
result = [0, 0]
while frontier:
ele = frontier.pop()
if ele is None:
clubs_visited.pop()
path.pop()
else:
frontier.append(None)
new_nodes = list(filter(lambda x: clubs[x] not in clubs_visited, children[ele]))
frontier.extend(new_nodes)
clubs_visited.append(clubs[ele])
path.append(ele)
if not new_nodes:
# print('ya')
if len(clubs_visited) > result[0]:
top_path = path.copy()
result.append(len(clubs_visited))
result.sort(reverse=True)
result.pop()
return result, top_path
def solve(potentials, clubs, dies, m, n, d):
debug = False
if m > 100:
print('Debug on due to m =', m)
debug = True
potential_index = {}
for i, p in enumerate(potentials):
if p in potential_index:
potential_index[p].add(i)
else:
potential_index[p] = set([i])
# print('p_index:')
# print(potential_index)
# print('club_index')
# print(club_index)
childrens = [set() for i in range(n)]
potentials_index_key = sorted(list(potential_index.keys()))
for i in range(1, len(potentials_index_key)):
last_po, current_po = potentials_index_key[i - 1], potentials_index_key[i]
if last_po == current_po - 1:
for a, b in filter(lambda x: clubs[x[0]] != clubs[x[1]],
itertools.product(potential_index[last_po], potential_index[current_po])):
childrens[a].add(b)
result = []
top_two_length, top_path = [0, 0], []
# print('children:')
# print(childrens)
potentials_0 = potential_index[0]
# print('haha')
for i in range(d):
delete_node(childrens, dies[i])
if debug:
print('i:', i)
potentials_0.discard(dies[i])
try:
die_index = top_path.index(dies[i])
except ValueError:
die_index = -1
if top_path and die_index == -1:
pass
if debug:
print('P1')
elif top_path and die_index >= top_two_length[1]:
top_two_length[0] = die_index
top_path = top_path[:die_index]
if debug:
print('P2')
else:
if debug:
print('P3')
top_two_length, top_path = find_longest_path(childrens, clubs, list(potentials_0))
result.append(top_two_length[0])
return result
def main():
# Deal with input.
n , m = map(int, input().split())
potentials = list(map(int, input().split()))
clubs = list(map(int, input().split()))
d = int(input())
dies = []
for _ in range(d):
dies.append(int(input()) - 1)
# tick = time.time()
result = solve(potentials, clubs, dies, m, n, d)
# tock = time.time()
# Deal with output.
for ele in result:
print(ele)
# Printe time.
# print('T:', round(tock - tick ,5))
def test():
n, m = 1000, 1000
potentials = list(range(n))
clubs = list(range(m))
dies = list(reversed(range(1, n + 1)))
d = n
# tick = time.time()
result = solve(potentials, clubs, dies, m, n, d)
# tock = time.time()
# Deal with output.
for ele in result:
print(ele)
# Printe time.
# print('T:', round(tock - tick ,5))
if __name__ == "__main__":
test()
``` | instruction | 0 | 45,437 | 17 | 90,874 |
No | output | 1 | 45,437 | 17 | 90,875 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n students and m clubs in a college. The clubs are numbered from 1 to m. Each student has a potential p_i and is a member of the club with index c_i. Initially, each student is a member of exactly one club. A technical fest starts in the college, and it will run for the next d days. There is a coding competition every day in the technical fest.
Every day, in the morning, exactly one student of the college leaves their club. Once a student leaves their club, they will never join any club again. Every day, in the afternoon, the director of the college will select one student from each club (in case some club has no members, nobody is selected from that club) to form a team for this day's coding competition. The strength of a team is the mex of potentials of the students in the team. The director wants to know the maximum possible strength of the team for each of the coming d days. Thus, every day the director chooses such team, that the team strength is maximized.
The mex of the multiset S is the smallest non-negative integer that is not present in S. For example, the mex of the \{0, 1, 1, 2, 4, 5, 9\} is 3, the mex of \{1, 2, 3\} is 0 and the mex of ∅ (empty set) is 0.
Input
The first line contains two integers n and m (1 ≤ m ≤ n ≤ 5000), the number of students and the number of clubs in college.
The second line contains n integers p_1, p_2, …, p_n (0 ≤ p_i < 5000), where p_i is the potential of the i-th student.
The third line contains n integers c_1, c_2, …, c_n (1 ≤ c_i ≤ m), which means that i-th student is initially a member of the club with index c_i.
The fourth line contains an integer d (1 ≤ d ≤ n), number of days for which the director wants to know the maximum possible strength of the team.
Each of the next d lines contains an integer k_i (1 ≤ k_i ≤ n), which means that k_i-th student lefts their club on the i-th day. It is guaranteed, that the k_i-th student has not left their club earlier.
Output
For each of the d days, print the maximum possible strength of the team on that day.
Examples
Input
5 3
0 1 2 2 0
1 2 2 3 2
5
3
2
4
5
1
Output
3
1
1
1
0
Input
5 3
0 1 2 2 1
1 3 2 3 2
5
4
2
3
5
1
Output
3
2
2
1
0
Input
5 5
0 1 2 4 5
1 2 3 4 5
4
2
3
5
4
Output
1
1
1
1
Note
Consider the first example:
On the first day, student 3 leaves their club. Now, the remaining students are 1, 2, 4 and 5. We can select students 1, 2 and 4 to get maximum possible strength, which is 3. Note, that we can't select students 1, 2 and 5, as students 2 and 5 belong to the same club. Also, we can't select students 1, 3 and 4, since student 3 has left their club.
On the second day, student 2 leaves their club. Now, the remaining students are 1, 4 and 5. We can select students 1, 4 and 5 to get maximum possible strength, which is 1.
On the third day, the remaining students are 1 and 5. We can select students 1 and 5 to get maximum possible strength, which is 1.
On the fourth day, the remaining student is 1. We can select student 1 to get maximum possible strength, which is 1.
On the fifth day, no club has students and so the maximum possible strength is 0.
Submitted Solution:
```
import sys
import bisect
input = sys.stdin.readline
n,m=map(int,input().split())
P=list(map(int,input().split()))
C=list(map(int,input().split()))
d=int(input())
q=[int(input()) for i in range(d)]
NEEDLEN=5001
SUM=[0]*NEEDLEN
CP=[[] for i in range(NEEDLEN)]
PC=[set() for i in range(NEEDLEN)]
MAX=[NEEDLEN]
for i in range(n):
CP[C[i]].append(P[i])
PC[P[i]].add(C[i])
SUM[P[i]]+=1
for i in range(NEEDLEN):
CP[i].sort()
#print(SUM,CP,PC)
for i in range(NEEDLEN):
if SUM[i]==1:
x=list(PC[i])[0]
if CP[x][-1]>i:
z=CP[x].pop()
PC[z].remove(x)
SUM[z]-=1
if SUM[i]==0:
MAX[0]=i
break
#print(SUM,CP,PC,MAX)
def sumrem(power):
x=list(PC[power])[0]
while CP[x][-1]>power:
z=CP[x].pop()
PC[z].remove(x)
SUM[z]-=1
if SUM[z]==1:
sumrem(z)
if SUM[z]==0:
MAX[0]=z
for k in q:
if P[k-1]>MAX[0]:
print(MAX[0])
continue
mem,club=P[k-1],C[k-1]
if club in PC[mem]:
PC[mem].remove(club)
SUM[mem]-=1
if SUM[mem]==1:
sumrem(mem)
if SUM[mem]==0:
MAX[0]=mem
print(MAX[0])
``` | instruction | 0 | 45,438 | 17 | 90,876 |
No | output | 1 | 45,438 | 17 | 90,877 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n students and m clubs in a college. The clubs are numbered from 1 to m. Each student has a potential p_i and is a member of the club with index c_i. Initially, each student is a member of exactly one club. A technical fest starts in the college, and it will run for the next d days. There is a coding competition every day in the technical fest.
Every day, in the morning, exactly one student of the college leaves their club. Once a student leaves their club, they will never join any club again. Every day, in the afternoon, the director of the college will select one student from each club (in case some club has no members, nobody is selected from that club) to form a team for this day's coding competition. The strength of a team is the mex of potentials of the students in the team. The director wants to know the maximum possible strength of the team for each of the coming d days. Thus, every day the director chooses such team, that the team strength is maximized.
The mex of the multiset S is the smallest non-negative integer that is not present in S. For example, the mex of the \{0, 1, 1, 2, 4, 5, 9\} is 3, the mex of \{1, 2, 3\} is 0 and the mex of ∅ (empty set) is 0.
Input
The first line contains two integers n and m (1 ≤ m ≤ n ≤ 5000), the number of students and the number of clubs in college.
The second line contains n integers p_1, p_2, …, p_n (0 ≤ p_i < 5000), where p_i is the potential of the i-th student.
The third line contains n integers c_1, c_2, …, c_n (1 ≤ c_i ≤ m), which means that i-th student is initially a member of the club with index c_i.
The fourth line contains an integer d (1 ≤ d ≤ n), number of days for which the director wants to know the maximum possible strength of the team.
Each of the next d lines contains an integer k_i (1 ≤ k_i ≤ n), which means that k_i-th student lefts their club on the i-th day. It is guaranteed, that the k_i-th student has not left their club earlier.
Output
For each of the d days, print the maximum possible strength of the team on that day.
Examples
Input
5 3
0 1 2 2 0
1 2 2 3 2
5
3
2
4
5
1
Output
3
1
1
1
0
Input
5 3
0 1 2 2 1
1 3 2 3 2
5
4
2
3
5
1
Output
3
2
2
1
0
Input
5 5
0 1 2 4 5
1 2 3 4 5
4
2
3
5
4
Output
1
1
1
1
Note
Consider the first example:
On the first day, student 3 leaves their club. Now, the remaining students are 1, 2, 4 and 5. We can select students 1, 2 and 4 to get maximum possible strength, which is 3. Note, that we can't select students 1, 2 and 5, as students 2 and 5 belong to the same club. Also, we can't select students 1, 3 and 4, since student 3 has left their club.
On the second day, student 2 leaves their club. Now, the remaining students are 1, 4 and 5. We can select students 1, 4 and 5 to get maximum possible strength, which is 1.
On the third day, the remaining students are 1 and 5. We can select students 1 and 5 to get maximum possible strength, which is 1.
On the fourth day, the remaining student is 1. We can select student 1 to get maximum possible strength, which is 1.
On the fifth day, no club has students and so the maximum possible strength is 0.
Submitted Solution:
```
# import time
import itertools
def delete_node(children, node):
for v in children:
v.discard(node)
def find_longest_path(children, clubs, frontier):
clubs_visited = []
path = []
top_path = []
result = [0, 0]
while frontier:
ele = frontier.pop()
if ele is None:
clubs_visited.pop()
path.pop()
else:
frontier.append(None)
new_nodes = list(filter(lambda x: clubs[x] not in clubs_visited, children[ele]))
frontier.extend(new_nodes)
clubs_visited.append(clubs[ele])
path.append(ele)
if not new_nodes:
# print('ya')
if len(clubs_visited) > result[0]:
top_path = path.copy()
result.append(len(clubs_visited))
result.sort(reverse=True)
result.pop()
return result, top_path
def solve(potentials, clubs, dies, m, n, d):
debug = False
if m > 1000:
debug = True
potential_index = {}
for i, p in enumerate(potentials):
if p in potential_index:
potential_index[p].add(i)
else:
potential_index[p] = set([i])
# print('p_index:')
# print(potential_index)
# print('club_index')
# print(club_index)
childrens = [set() for i in range(n)]
potentials_index_key = sorted(list(potential_index.keys()))
for i in range(1, len(potentials_index_key)):
last_po, current_po = potentials_index_key[i - 1], potentials_index_key[i]
if last_po == current_po - 1:
for a, b in filter(lambda x: clubs[x[0]] != clubs[x[1]],
itertools.product(potential_index[last_po], potential_index[current_po])):
childrens[a].add(b)
result = []
top_two_length, top_path = [0, 0], []
# print('children:')
# print(childrens)
potentials_0 = potential_index[0]
# print('haha')
for i in range(d):
if i % 100 == 0:
debug = True
else:
debug = False
if debug:
print('i:', i)
# print(top_two_length, top_path)
delete_node(childrens, dies[i])
potentials_0.discard(dies[i])
try:
die_index = top_path.index(dies[i])
except ValueError:
die_index = -1
if top_path and die_index == -1:
pass
if debug:
print('P1')
elif top_path and die_index >= top_two_length[1]:
top_two_length[0] = die_index
top_path = top_path[:die_index]
if debug:
print('P2')
else:
if debug:
print('P3')
top_two_length, top_path = find_longest_path(childrens, clubs, list(potentials_0))
result.append(top_two_length[0])
return result
def main():
# Deal with input.
n , m = map(int, input().split())
potentials = list(map(int, input().split()))
clubs = list(map(int, input().split()))
d = int(input())
dies = []
for _ in range(d):
dies.append(int(input()) - 1)
# tick = time.time()
result = solve(potentials, clubs, dies, m, n, d)
# tock = time.time()
# Deal with output.
for ele in result:
print(ele)
# Printe time.
# print('T:', round(tock - tick ,5))
def test():
n, m = 1000, 1000
potentials = list(range(n))
clubs = list(range(m))
dies = list(reversed(range(1, n + 1)))
d = n
# tick = time.time()
result = solve(potentials, clubs, dies, m, n, d)
# tock = time.time()
# Deal with output.
for ele in result:
print(ele)
# Printe time.
# print('T:', round(tock - tick ,5))
if __name__ == "__main__":
main()
``` | instruction | 0 | 45,439 | 17 | 90,878 |
No | output | 1 | 45,439 | 17 | 90,879 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n students at your university. The programming skill of the i-th student is a_i. As a coach, you want to divide them into teams to prepare them for the upcoming ICPC finals. Just imagine how good this university is if it has 2 ⋅ 10^5 students ready for the finals!
Each team should consist of at least three students. Each student should belong to exactly one team. The diversity of a team is the difference between the maximum programming skill of some student that belongs to this team and the minimum programming skill of some student that belongs to this team (in other words, if the team consists of k students with programming skills a[i_1], a[i_2], ..., a[i_k], then the diversity of this team is max_{j=1}^{k} a[i_j] - min_{j=1}^{k} a[i_j]).
The total diversity is the sum of diversities of all teams formed.
Your task is to minimize the total diversity of the division of students and find the optimal way to divide the students.
Input
The first line of the input contains one integer n (3 ≤ n ≤ 2 ⋅ 10^5) — the number of students.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is the programming skill of the i-th student.
Output
In the first line print two integers res and k — the minimum total diversity of the division of students and the number of teams in your division, correspondingly.
In the second line print n integers t_1, t_2, ..., t_n (1 ≤ t_i ≤ k), where t_i is the number of team to which the i-th student belong.
If there are multiple answers, you can print any. Note that you don't need to minimize the number of teams. Each team should consist of at least three students.
Examples
Input
5
1 1 3 4 2
Output
3 1
1 1 1 1 1
Input
6
1 5 12 13 2 15
Output
7 2
2 2 1 1 2 1
Input
10
1 2 5 129 185 581 1041 1909 1580 8150
Output
7486 3
3 3 3 2 2 2 2 1 1 1
Note
In the first example, there is only one team with skills [1, 1, 2, 3, 4] so the answer is 3. It can be shown that you cannot achieve a better answer.
In the second example, there are two teams with skills [1, 2, 5] and [12, 13, 15] so the answer is 4 + 3 = 7.
In the third example, there are three teams with skills [1, 2, 5], [129, 185, 581, 1041] and [1580, 1909, 8150] so the answer is 4 + 912 + 6570 = 7486. | instruction | 0 | 45,512 | 17 | 91,024 |
Tags: dp, greedy, sortings
Correct Solution:
```
n = int(input())
a = list(map(int, input().split()))
idx = sorted(range(n), key=lambda i:a[i])
a = sorted(a)
diff = [x-y for x, y in zip(a[1:], a[:-1])]
dp = [0] * (n-1)
mask = [0] * (n-1)
for i in range(n-1):
if i < 2:
continue
if i <= n-4:
add = 0 if i==2 else dp[i-3]
if diff[i] + add > dp[i-1]:
dp[i] = diff[i] + add
mask[i] = 1
else:
dp[i] = dp[i-1]
else:
dp[i] = dp[i-1]
i=n-2
while i >= 0:
if mask[i]==1:
for _ in range(2):
i-=1
if i >= 0:
mask[i]=0
i-=1
comp = [None] * n
cur=1
comp[0]=cur
for i, x in enumerate(mask):
if x==1:
cur+=1
comp[i+1] = cur
else:
comp[i+1] = comp[i]
ans=[None] * n
for i, x in enumerate(idx):
ans[x] = str(comp[i])
print(str(sum(diff) - dp[-1]) + ' ' + str(cur))
print(' '.join(ans))
``` | output | 1 | 45,512 | 17 | 91,025 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n students at your university. The programming skill of the i-th student is a_i. As a coach, you want to divide them into teams to prepare them for the upcoming ICPC finals. Just imagine how good this university is if it has 2 ⋅ 10^5 students ready for the finals!
Each team should consist of at least three students. Each student should belong to exactly one team. The diversity of a team is the difference between the maximum programming skill of some student that belongs to this team and the minimum programming skill of some student that belongs to this team (in other words, if the team consists of k students with programming skills a[i_1], a[i_2], ..., a[i_k], then the diversity of this team is max_{j=1}^{k} a[i_j] - min_{j=1}^{k} a[i_j]).
The total diversity is the sum of diversities of all teams formed.
Your task is to minimize the total diversity of the division of students and find the optimal way to divide the students.
Input
The first line of the input contains one integer n (3 ≤ n ≤ 2 ⋅ 10^5) — the number of students.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is the programming skill of the i-th student.
Output
In the first line print two integers res and k — the minimum total diversity of the division of students and the number of teams in your division, correspondingly.
In the second line print n integers t_1, t_2, ..., t_n (1 ≤ t_i ≤ k), where t_i is the number of team to which the i-th student belong.
If there are multiple answers, you can print any. Note that you don't need to minimize the number of teams. Each team should consist of at least three students.
Examples
Input
5
1 1 3 4 2
Output
3 1
1 1 1 1 1
Input
6
1 5 12 13 2 15
Output
7 2
2 2 1 1 2 1
Input
10
1 2 5 129 185 581 1041 1909 1580 8150
Output
7486 3
3 3 3 2 2 2 2 1 1 1
Note
In the first example, there is only one team with skills [1, 1, 2, 3, 4] so the answer is 3. It can be shown that you cannot achieve a better answer.
In the second example, there are two teams with skills [1, 2, 5] and [12, 13, 15] so the answer is 4 + 3 = 7.
In the third example, there are three teams with skills [1, 2, 5], [129, 185, 581, 1041] and [1580, 1909, 8150] so the answer is 4 + 912 + 6570 = 7486. | instruction | 0 | 45,513 | 17 | 91,026 |
Tags: dp, greedy, sortings
Correct Solution:
```
n = int(input())
l = list(map(int,input().split()))
a = [[l[i], i] for i in range(n)]
a.sort()
ll = l.copy()
ll.sort()
if n < 6:
print(a[-1][0] - a[0][0], 1)
print(*([1] * n))
else:
b = [ll[i] - ll[i-1] for i in range(3, n - 2)]
#wybieramy najwieksza sume z b ale nie moge wybrac ziomow o mniej niz 2 od siebie
dp = [[0,0] for i in range(len(b) + 5)]
i = len(b) - 1
dp[i] = [0, b[i]]
while i >= 0:
dp[i][0] = max(dp[i+1])
dp[i][1] = max(dp[i+3]) + b[i]
i-=1
odp = []
i = 0
while True:
if dp[i] == [0,0]:
break
if dp[i][1] > dp[i][0]:
odp.append(i)
i += 3
else:
i += 1
odp = [i+3 for i in odp]
grupy = [0] * n
grupa = 1
wsk = 0
for i in range(n):
if wsk <= len(odp)-1:
if i == odp[wsk]:
wsk += 1
grupa += 1
grupy[a[i][1]] = grupa
print(ll[-1] - ll[0] - max(dp[0]), grupa)
print(*grupy)
``` | output | 1 | 45,513 | 17 | 91,027 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n students at your university. The programming skill of the i-th student is a_i. As a coach, you want to divide them into teams to prepare them for the upcoming ICPC finals. Just imagine how good this university is if it has 2 ⋅ 10^5 students ready for the finals!
Each team should consist of at least three students. Each student should belong to exactly one team. The diversity of a team is the difference between the maximum programming skill of some student that belongs to this team and the minimum programming skill of some student that belongs to this team (in other words, if the team consists of k students with programming skills a[i_1], a[i_2], ..., a[i_k], then the diversity of this team is max_{j=1}^{k} a[i_j] - min_{j=1}^{k} a[i_j]).
The total diversity is the sum of diversities of all teams formed.
Your task is to minimize the total diversity of the division of students and find the optimal way to divide the students.
Input
The first line of the input contains one integer n (3 ≤ n ≤ 2 ⋅ 10^5) — the number of students.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is the programming skill of the i-th student.
Output
In the first line print two integers res and k — the minimum total diversity of the division of students and the number of teams in your division, correspondingly.
In the second line print n integers t_1, t_2, ..., t_n (1 ≤ t_i ≤ k), where t_i is the number of team to which the i-th student belong.
If there are multiple answers, you can print any. Note that you don't need to minimize the number of teams. Each team should consist of at least three students.
Examples
Input
5
1 1 3 4 2
Output
3 1
1 1 1 1 1
Input
6
1 5 12 13 2 15
Output
7 2
2 2 1 1 2 1
Input
10
1 2 5 129 185 581 1041 1909 1580 8150
Output
7486 3
3 3 3 2 2 2 2 1 1 1
Note
In the first example, there is only one team with skills [1, 1, 2, 3, 4] so the answer is 3. It can be shown that you cannot achieve a better answer.
In the second example, there are two teams with skills [1, 2, 5] and [12, 13, 15] so the answer is 4 + 3 = 7.
In the third example, there are three teams with skills [1, 2, 5], [129, 185, 581, 1041] and [1580, 1909, 8150] so the answer is 4 + 912 + 6570 = 7486. | instruction | 0 | 45,514 | 17 | 91,028 |
Tags: dp, greedy, sortings
Correct Solution:
```
from math import inf
I = input
SS = sorted
n = int(I())
A=list(map(int,I().split()))
A = ([index, int(x), -1] for index, x in enumerate(A))
A = SS(A, key=lambda tup: tup[1])
dp = [inf] * (n+1)
dp[0] = 0
p = [-1] * (n+1)
for i in range(n):
j = 3
while j <= 5 and i+j <= n:
deff = dp[i] + A[i+j - 1][1] - A[i][1]
dp[i+j] = min(dp[i + j], deff)
if dp[i+j] == deff:
p[i+j] = i
j += 1
ind = n
team = 1
while ind !=0:
for i in range(ind -1, p[ind] - 1, -1):
A[i][2] = team
team += 1
ind = p[ind]
print(f"{dp[-1]} {team - 1}")
# ans = (list(zip(A, ans)))
A = SS(A)
print(*(x for _,_,x in A))
``` | output | 1 | 45,514 | 17 | 91,029 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n students at your university. The programming skill of the i-th student is a_i. As a coach, you want to divide them into teams to prepare them for the upcoming ICPC finals. Just imagine how good this university is if it has 2 ⋅ 10^5 students ready for the finals!
Each team should consist of at least three students. Each student should belong to exactly one team. The diversity of a team is the difference between the maximum programming skill of some student that belongs to this team and the minimum programming skill of some student that belongs to this team (in other words, if the team consists of k students with programming skills a[i_1], a[i_2], ..., a[i_k], then the diversity of this team is max_{j=1}^{k} a[i_j] - min_{j=1}^{k} a[i_j]).
The total diversity is the sum of diversities of all teams formed.
Your task is to minimize the total diversity of the division of students and find the optimal way to divide the students.
Input
The first line of the input contains one integer n (3 ≤ n ≤ 2 ⋅ 10^5) — the number of students.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is the programming skill of the i-th student.
Output
In the first line print two integers res and k — the minimum total diversity of the division of students and the number of teams in your division, correspondingly.
In the second line print n integers t_1, t_2, ..., t_n (1 ≤ t_i ≤ k), where t_i is the number of team to which the i-th student belong.
If there are multiple answers, you can print any. Note that you don't need to minimize the number of teams. Each team should consist of at least three students.
Examples
Input
5
1 1 3 4 2
Output
3 1
1 1 1 1 1
Input
6
1 5 12 13 2 15
Output
7 2
2 2 1 1 2 1
Input
10
1 2 5 129 185 581 1041 1909 1580 8150
Output
7486 3
3 3 3 2 2 2 2 1 1 1
Note
In the first example, there is only one team with skills [1, 1, 2, 3, 4] so the answer is 3. It can be shown that you cannot achieve a better answer.
In the second example, there are two teams with skills [1, 2, 5] and [12, 13, 15] so the answer is 4 + 3 = 7.
In the third example, there are three teams with skills [1, 2, 5], [129, 185, 581, 1041] and [1580, 1909, 8150] so the answer is 4 + 912 + 6570 = 7486. | instruction | 0 | 45,515 | 17 | 91,030 |
Tags: dp, greedy, sortings
Correct Solution:
```
import sys
input = sys.stdin.readline
n=int(input())
A=list(map(int,input().split()))
B=[(a,ind) for ind,a in enumerate(A)]
B.sort()
DP=[0]*(n+1)
for i in range(3,n-2):
DP[i]=max(DP[i-1],DP[i-3]+B[i][0]-B[i-1][0])
#print(DP)
MAX=max(DP)
x=DP.index(MAX)
REMLIST=[]
while x>0:
if DP[x]==DP[x-1]:
x-=1
else:
REMLIST.append(x)
x-=3
REMLIST.sort()
REMLIST.append(1<<60)
print(max(A)-min(A)-MAX,len(REMLIST))
ANS=[-1]*n
remind=0
NOW=1
for i in range(n):
if i==REMLIST[remind]:
NOW+=1
remind+=1
ANS[B[i][1]]=NOW
print(*ANS)
``` | output | 1 | 45,515 | 17 | 91,031 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n students at your university. The programming skill of the i-th student is a_i. As a coach, you want to divide them into teams to prepare them for the upcoming ICPC finals. Just imagine how good this university is if it has 2 ⋅ 10^5 students ready for the finals!
Each team should consist of at least three students. Each student should belong to exactly one team. The diversity of a team is the difference between the maximum programming skill of some student that belongs to this team and the minimum programming skill of some student that belongs to this team (in other words, if the team consists of k students with programming skills a[i_1], a[i_2], ..., a[i_k], then the diversity of this team is max_{j=1}^{k} a[i_j] - min_{j=1}^{k} a[i_j]).
The total diversity is the sum of diversities of all teams formed.
Your task is to minimize the total diversity of the division of students and find the optimal way to divide the students.
Input
The first line of the input contains one integer n (3 ≤ n ≤ 2 ⋅ 10^5) — the number of students.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is the programming skill of the i-th student.
Output
In the first line print two integers res and k — the minimum total diversity of the division of students and the number of teams in your division, correspondingly.
In the second line print n integers t_1, t_2, ..., t_n (1 ≤ t_i ≤ k), where t_i is the number of team to which the i-th student belong.
If there are multiple answers, you can print any. Note that you don't need to minimize the number of teams. Each team should consist of at least three students.
Examples
Input
5
1 1 3 4 2
Output
3 1
1 1 1 1 1
Input
6
1 5 12 13 2 15
Output
7 2
2 2 1 1 2 1
Input
10
1 2 5 129 185 581 1041 1909 1580 8150
Output
7486 3
3 3 3 2 2 2 2 1 1 1
Note
In the first example, there is only one team with skills [1, 1, 2, 3, 4] so the answer is 3. It can be shown that you cannot achieve a better answer.
In the second example, there are two teams with skills [1, 2, 5] and [12, 13, 15] so the answer is 4 + 3 = 7.
In the third example, there are three teams with skills [1, 2, 5], [129, 185, 581, 1041] and [1580, 1909, 8150] so the answer is 4 + 912 + 6570 = 7486. | instruction | 0 | 45,516 | 17 | 91,032 |
Tags: dp, greedy, sortings
Correct Solution:
```
import sys
from copy import *
from bisect import *
zz=1
sys.setrecursionlimit(10**5)
if zz:
input=sys.stdin.readline
else:
sys.stdin=open('input.txt', 'r')
sys.stdout=open('all.txt','w')
di=[[-1,0],[1,0],[0,1],[0,-1]]
def fori(n):
return [fi() for i in range(n)]
def inc(d,c,x=1):
d[c]=d[c]+x if c in d else x
def ii():
return input().rstrip()
def li():
return [int(xx) for xx in input().split()]
def fli():
return [float(x) for x in input().split()]
def comp(a,b):
if(a>b):
return 2
return 2 if a==b else 0
def gi():
return [xx for xx in input().split()]
def gtc(tc,ans):
print("Case #"+str(tc)+":",ans)
def cil(n,m):
return n//m+int(n%m>0)
def fi():
return int(input())
def pro(a):
return reduce(lambda a,b:a*b,a)
def swap(a,i,j):
a[i],a[j]=a[j],a[i]
def si():
return list(input().rstrip())
def mi():
return map(int,input().split())
def gh():
sys.stdout.flush()
def isvalid(i,j,n,m):
return 0<=i<n and 0<=j<m
def bo(i):
return ord(i)-ord('a')
def graph(n,m):
for i in range(m):
x,y=mi()
a[x].append(y)
a[y].append(x)
t=1
uu=t
while t>0:
t-=1
n=fi()
a=li()
b=deepcopy(a)
a.sort()
d={}
for i in range(n):
if b[i] not in d:
d[b[i]]=[]
d[b[i]].append(i)
p=[]
for i in range(1,n):
p.append(a[i]-a[i-1])
dp=[0]*(len(p))
for i in range(2,len(p)):
if i<=4:
dp[i]=max(dp[i-1],p[i])
else:
dp[i]=max(dp[i-1],p[i]+dp[i-3])
if n-i<=3:
dp[i]=dp[i-1]
c=1
j=n-2
ans=[0]*n
ans[d[a[n-1]][-1]]=1
d[a[n-1]].pop()
cur=dp[-1]
cur=bisect_left(dp,dp[-1])
while j>=1:
if j==cur:
cur=bisect_left(dp,dp[j]-p[j])
c+=1
ans[d[a[j]][-1]]=c
d[a[j]].pop()
j-=1
ans[d[a[0]][-1]]=c
print(sum(p)-dp[-1],c)
print(*ans)
``` | output | 1 | 45,516 | 17 | 91,033 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n students at your university. The programming skill of the i-th student is a_i. As a coach, you want to divide them into teams to prepare them for the upcoming ICPC finals. Just imagine how good this university is if it has 2 ⋅ 10^5 students ready for the finals!
Each team should consist of at least three students. Each student should belong to exactly one team. The diversity of a team is the difference between the maximum programming skill of some student that belongs to this team and the minimum programming skill of some student that belongs to this team (in other words, if the team consists of k students with programming skills a[i_1], a[i_2], ..., a[i_k], then the diversity of this team is max_{j=1}^{k} a[i_j] - min_{j=1}^{k} a[i_j]).
The total diversity is the sum of diversities of all teams formed.
Your task is to minimize the total diversity of the division of students and find the optimal way to divide the students.
Input
The first line of the input contains one integer n (3 ≤ n ≤ 2 ⋅ 10^5) — the number of students.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is the programming skill of the i-th student.
Output
In the first line print two integers res and k — the minimum total diversity of the division of students and the number of teams in your division, correspondingly.
In the second line print n integers t_1, t_2, ..., t_n (1 ≤ t_i ≤ k), where t_i is the number of team to which the i-th student belong.
If there are multiple answers, you can print any. Note that you don't need to minimize the number of teams. Each team should consist of at least three students.
Examples
Input
5
1 1 3 4 2
Output
3 1
1 1 1 1 1
Input
6
1 5 12 13 2 15
Output
7 2
2 2 1 1 2 1
Input
10
1 2 5 129 185 581 1041 1909 1580 8150
Output
7486 3
3 3 3 2 2 2 2 1 1 1
Note
In the first example, there is only one team with skills [1, 1, 2, 3, 4] so the answer is 3. It can be shown that you cannot achieve a better answer.
In the second example, there are two teams with skills [1, 2, 5] and [12, 13, 15] so the answer is 4 + 3 = 7.
In the third example, there are three teams with skills [1, 2, 5], [129, 185, 581, 1041] and [1580, 1909, 8150] so the answer is 4 + 912 + 6570 = 7486. | instruction | 0 | 45,517 | 17 | 91,034 |
Tags: dp, greedy, sortings
Correct Solution:
```
n=int(input())
x=list(map(int,input().split()))
y=[]
for i in range(n):
y.append(x[i])
m={}
inf=885627645626577863562
for i in range(n):
m[x[i]]=i
x.sort()
dp,cnt,ans=[0]*n,[0]*n,[[]for i in range(n)]
dp[0]=dp[1]=inf
for i in range(2,n):
dp[i]=inf
for i2 in range(3,6):
if i-i2==-1:
if dp[i]>x[i]-x[i-i2+1]:
dp[i]=x[i]-x[i-i2+1]
cnt[i]=i2
elif i-i2>=0:
if dp[i]>dp[i-i2]+x[i]-x[i-i2+1]:
dp[i]=dp[i-i2]+x[i]-x[i-i2+1]
cnt[i]=i2
skip,temp=inf,0
for i in range(n-1,-1,-1):
if i<=skip:
skip=i-cnt[i]
temp+=1
if i>skip:
ans[m[x[i]]].append(temp)
print(dp[n-1],temp)
for i in range(n):
p=m[y[i]]
print(ans[p][len(ans[p])-1],end=" ")
ans[p].pop()
``` | output | 1 | 45,517 | 17 | 91,035 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n students at your university. The programming skill of the i-th student is a_i. As a coach, you want to divide them into teams to prepare them for the upcoming ICPC finals. Just imagine how good this university is if it has 2 ⋅ 10^5 students ready for the finals!
Each team should consist of at least three students. Each student should belong to exactly one team. The diversity of a team is the difference between the maximum programming skill of some student that belongs to this team and the minimum programming skill of some student that belongs to this team (in other words, if the team consists of k students with programming skills a[i_1], a[i_2], ..., a[i_k], then the diversity of this team is max_{j=1}^{k} a[i_j] - min_{j=1}^{k} a[i_j]).
The total diversity is the sum of diversities of all teams formed.
Your task is to minimize the total diversity of the division of students and find the optimal way to divide the students.
Input
The first line of the input contains one integer n (3 ≤ n ≤ 2 ⋅ 10^5) — the number of students.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is the programming skill of the i-th student.
Output
In the first line print two integers res and k — the minimum total diversity of the division of students and the number of teams in your division, correspondingly.
In the second line print n integers t_1, t_2, ..., t_n (1 ≤ t_i ≤ k), where t_i is the number of team to which the i-th student belong.
If there are multiple answers, you can print any. Note that you don't need to minimize the number of teams. Each team should consist of at least three students.
Examples
Input
5
1 1 3 4 2
Output
3 1
1 1 1 1 1
Input
6
1 5 12 13 2 15
Output
7 2
2 2 1 1 2 1
Input
10
1 2 5 129 185 581 1041 1909 1580 8150
Output
7486 3
3 3 3 2 2 2 2 1 1 1
Note
In the first example, there is only one team with skills [1, 1, 2, 3, 4] so the answer is 3. It can be shown that you cannot achieve a better answer.
In the second example, there are two teams with skills [1, 2, 5] and [12, 13, 15] so the answer is 4 + 3 = 7.
In the third example, there are three teams with skills [1, 2, 5], [129, 185, 581, 1041] and [1580, 1909, 8150] so the answer is 4 + 912 + 6570 = 7486. | instruction | 0 | 45,518 | 17 | 91,036 |
Tags: dp, greedy, sortings
Correct Solution:
```
import math
import sys
from collections import defaultdict
from itertools import groupby
#input = sys.stdin.readline
rt = lambda: map(int, input().split())
ri = lambda: int(input())
rl = lambda: list(map(int, input().split()))
def main():
n = ri()
a_raw = rl()
a = [(x, i) for i, x in enumerate(a_raw)]
a.sort()
dp = [math.inf] * (n+1)
dp[0] = 0
size = defaultdict(int)
for i in range(n):
if dp[i] == math.inf:
continue
if i+3 <= n and dp[i] + a[i+2][0] - a[i][0] < dp[i+3]:
dp[i+3] = dp[i] + a[i+2][0] - a[i][0]
size[i+3] = 3
if i+4 <= n and dp[i] + a[i+3][0] - a[i][0] < dp[i+4]:
dp[i+4] = dp[i] + a[i+3][0] - a[i][0]
size[i+4] = 4
if i+5 <= n and dp[i] + a[i+4][0] - a[i][0] < dp[i+5]:
dp[i+5] = dp[i] + a[i+4][0] - a[i][0]
size[i+5] = 5
team = 1
res = [0] * n
pos = n-1
div = 0
while pos >= 0:
start = pos - size[pos+1]+1
for i in range(start, pos+1):
res[a[i][1]] = team
div += a[pos][0] - a[start][0]
pos = start - 1
if pos >= 0:
team += 1
print(div, team)
print(*res)
if __name__ == '__main__':
main()
``` | output | 1 | 45,518 | 17 | 91,037 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n students at your university. The programming skill of the i-th student is a_i. As a coach, you want to divide them into teams to prepare them for the upcoming ICPC finals. Just imagine how good this university is if it has 2 ⋅ 10^5 students ready for the finals!
Each team should consist of at least three students. Each student should belong to exactly one team. The diversity of a team is the difference between the maximum programming skill of some student that belongs to this team and the minimum programming skill of some student that belongs to this team (in other words, if the team consists of k students with programming skills a[i_1], a[i_2], ..., a[i_k], then the diversity of this team is max_{j=1}^{k} a[i_j] - min_{j=1}^{k} a[i_j]).
The total diversity is the sum of diversities of all teams formed.
Your task is to minimize the total diversity of the division of students and find the optimal way to divide the students.
Input
The first line of the input contains one integer n (3 ≤ n ≤ 2 ⋅ 10^5) — the number of students.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is the programming skill of the i-th student.
Output
In the first line print two integers res and k — the minimum total diversity of the division of students and the number of teams in your division, correspondingly.
In the second line print n integers t_1, t_2, ..., t_n (1 ≤ t_i ≤ k), where t_i is the number of team to which the i-th student belong.
If there are multiple answers, you can print any. Note that you don't need to minimize the number of teams. Each team should consist of at least three students.
Examples
Input
5
1 1 3 4 2
Output
3 1
1 1 1 1 1
Input
6
1 5 12 13 2 15
Output
7 2
2 2 1 1 2 1
Input
10
1 2 5 129 185 581 1041 1909 1580 8150
Output
7486 3
3 3 3 2 2 2 2 1 1 1
Note
In the first example, there is only one team with skills [1, 1, 2, 3, 4] so the answer is 3. It can be shown that you cannot achieve a better answer.
In the second example, there are two teams with skills [1, 2, 5] and [12, 13, 15] so the answer is 4 + 3 = 7.
In the third example, there are three teams with skills [1, 2, 5], [129, 185, 581, 1041] and [1580, 1909, 8150] so the answer is 4 + 912 + 6570 = 7486. | instruction | 0 | 45,519 | 17 | 91,038 |
Tags: dp, greedy, sortings
Correct Solution:
```
def main():
n=int(input())
a=readIntArr()
a2=[[x,i] for i,x in enumerate(a)] # [value, index]
a2.sort(key=lambda x:x[0]) # sort by value asc
dp=[inf for _ in range(n)] # dp[i] is the min diversity achievable at i
left=[0 for _ in range(n)]
for i in range(n):
currSz3=inf
currSz4=inf
currSz5=inf
if i>=2: currSz3=a2[i][0]-a2[i-2][0]
if i>=3: currSz3+=dp[i-3]
if i>=3: currSz4=a2[i][0]-a2[i-3][0]
if i>=4: currSz4+=dp[i-4]
if i>=4: currSz5=a2[i][0]-a2[i-4][0]
if i>=5: currSz5+=dp[i-5]
# print('i:{} 3:{} 4:{} 5:{}'.format(i,currSz3,currSz4,currSz5))
minn=min(currSz3,currSz4,currSz5)
if i>=5:
if minn==currSz3: left[i]=i-2
elif minn==currSz4: left[i]=i-3
else: left[i]=i-4
dp[i]=minn
res=dp[n-1]
groups=[]
right=n-1
while True:
left_=left[right]
temp=[]
for i in range(left_,right+1):
temp.append(a2[i][1])
groups.append(temp)
if left_==0: break
right=left_-1
grouping=[-1 for _ in range(n)]
for i,group in enumerate(groups):
for student in group:
grouping[student]=i+1
print('{} {}'.format(res,len(groups)))
oneLineArrayPrint(grouping)
# print(dp) #
# print(left) #
return
import sys
# input=sys.stdin.buffer.readline #FOR READING PURE INTEGER INPUTS (space separation ok)
input=lambda: sys.stdin.readline().rstrip("\r\n") #FOR READING STRING/TEXT INPUTS.
def oneLineArrayPrint(arr):
print(' '.join([str(x) for x in arr]))
def multiLineArrayPrint(arr):
print('\n'.join([str(x) for x in arr]))
def multiLineArrayOfArraysPrint(arr):
print('\n'.join([' '.join([str(x) for x in y]) for y in arr]))
def readIntArr():
return [int(x) for x in input().split()]
# def readFloatArr():
# return [float(x) for x in input().split()]
def makeArr(defaultVal,dimensionArr): # eg. makeArr(0,[n,m])
dv=defaultVal;da=dimensionArr
if len(da)==1:return [dv for _ in range(da[0])]
else:return [makeArr(dv,da[1:]) for _ in range(da[0])]
def queryInteractive(x,y):
print('? {} {}'.format(x,y))
sys.stdout.flush()
return int(input())
def answerInteractive(ans):
print('! {}'.format(ans))
sys.stdout.flush()
inf=float('inf')
MOD=10**9+7
for _abc in range(1):
main()
``` | output | 1 | 45,519 | 17 | 91,039 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n students at your university. The programming skill of the i-th student is a_i. As a coach, you want to divide them into teams to prepare them for the upcoming ICPC finals. Just imagine how good this university is if it has 2 ⋅ 10^5 students ready for the finals!
Each team should consist of at least three students. Each student should belong to exactly one team. The diversity of a team is the difference between the maximum programming skill of some student that belongs to this team and the minimum programming skill of some student that belongs to this team (in other words, if the team consists of k students with programming skills a[i_1], a[i_2], ..., a[i_k], then the diversity of this team is max_{j=1}^{k} a[i_j] - min_{j=1}^{k} a[i_j]).
The total diversity is the sum of diversities of all teams formed.
Your task is to minimize the total diversity of the division of students and find the optimal way to divide the students.
Input
The first line of the input contains one integer n (3 ≤ n ≤ 2 ⋅ 10^5) — the number of students.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is the programming skill of the i-th student.
Output
In the first line print two integers res and k — the minimum total diversity of the division of students and the number of teams in your division, correspondingly.
In the second line print n integers t_1, t_2, ..., t_n (1 ≤ t_i ≤ k), where t_i is the number of team to which the i-th student belong.
If there are multiple answers, you can print any. Note that you don't need to minimize the number of teams. Each team should consist of at least three students.
Examples
Input
5
1 1 3 4 2
Output
3 1
1 1 1 1 1
Input
6
1 5 12 13 2 15
Output
7 2
2 2 1 1 2 1
Input
10
1 2 5 129 185 581 1041 1909 1580 8150
Output
7486 3
3 3 3 2 2 2 2 1 1 1
Note
In the first example, there is only one team with skills [1, 1, 2, 3, 4] so the answer is 3. It can be shown that you cannot achieve a better answer.
In the second example, there are two teams with skills [1, 2, 5] and [12, 13, 15] so the answer is 4 + 3 = 7.
In the third example, there are three teams with skills [1, 2, 5], [129, 185, 581, 1041] and [1580, 1909, 8150] so the answer is 4 + 912 + 6570 = 7486.
Submitted Solution:
```
def main():
n=int(input())
a=readIntArr()
a2=[[x,i+1] for i,x in enumerate(a)] # [value, index]
a2.sort(key=lambda x:x[0]) # sort by value asc
dp=[inf for _ in range(n)] # dp[i] is the min diversity achievable at i
#dp[i]=min(ai-aj+dp[j-1])=min(a[i]+(dp[j-1]-a[j]))=a[i]+dp2[i-2]
dp2=[inf for _ in range(n)] # dp2[j] is the min dp[j-1]-a[j] so far (prefix min)
dp2i=[-1 for _ in range(n)] # dp2i[i] stores the index where dp2[i] was previously minimised
for i in range(2,min(n,5)):
dp[i]=a2[i][0]-a2[0][0]
dp2[i]=dp[i-1]-a2[i][0]
dp2i[i]=i
if dp2[i]>=dp2[i-1]:
dp2i[i]=dp2i[i-1]
dp2[i]=dp2[i-1]
for i in range(5,n):
dp2[i]=dp[i-1]-a2[i][0]
dp2i[i]=i
if dp2[i]>=dp2[i-1]:
dp2i[i]=dp2i[i-1]
dp2[i]=dp2[i-1]
dp[i]=a2[i][0]+dp2[i-2]
# print('i:{} a2[i][0]:{} dp2[i-2]:{}'.format(i,a2[i][0],dp2[i-2]))
# print('a2:{}'.format(a2))
# print('dp:{}'.format(dp))
# print('dp2:{}'.format(dp2))
# print('dp2i:{}'.format(dp2i))
minDiversity=dp[n-1]
groups=[]
right=n-1
while True:
left=dp2i[right-2]
if left==-1:
left=0
temp=[]
for i in range(left,right+1):
temp.append(a2[i][1])
groups.append(temp)
if left==0:
break
right=left-1
nGroups=len(groups)
grouping=[-1 for _ in range(n)]
for i in range(nGroups):
for student in groups[i]:
grouping[student-1]=i+1
print('{} {}'.format(minDiversity,nGroups))
oneLineArrayPrint(grouping)
return
import sys
# input=sys.stdin.buffer.readline #FOR READING PURE INTEGER INPUTS (space separation ok)
input=lambda: sys.stdin.readline().rstrip("\r\n") #FOR READING STRING/TEXT INPUTS.
def oneLineArrayPrint(arr):
print(' '.join([str(x) for x in arr]))
def multiLineArrayPrint(arr):
print('\n'.join([str(x) for x in arr]))
def multiLineArrayOfArraysPrint(arr):
print('\n'.join([' '.join([str(x) for x in y]) for y in arr]))
def readIntArr():
return [int(x) for x in input().split()]
# def readFloatArr():
# return [float(x) for x in input().split()]
def makeArr(defaultVal,dimensionArr): # eg. makeArr(0,[n,m])
dv=defaultVal;da=dimensionArr
if len(da)==1:return [dv for _ in range(da[0])]
else:return [makeArr(dv,da[1:]) for _ in range(da[0])]
def queryInteractive(x,y):
print('? {} {}'.format(x,y))
sys.stdout.flush()
return int(input())
def answerInteractive(ans):
print('! {}'.format(ans))
sys.stdout.flush()
inf=float('inf')
MOD=10**9+7
for _abc in range(1):
main()
``` | instruction | 0 | 45,520 | 17 | 91,040 |
Yes | output | 1 | 45,520 | 17 | 91,041 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n students at your university. The programming skill of the i-th student is a_i. As a coach, you want to divide them into teams to prepare them for the upcoming ICPC finals. Just imagine how good this university is if it has 2 ⋅ 10^5 students ready for the finals!
Each team should consist of at least three students. Each student should belong to exactly one team. The diversity of a team is the difference between the maximum programming skill of some student that belongs to this team and the minimum programming skill of some student that belongs to this team (in other words, if the team consists of k students with programming skills a[i_1], a[i_2], ..., a[i_k], then the diversity of this team is max_{j=1}^{k} a[i_j] - min_{j=1}^{k} a[i_j]).
The total diversity is the sum of diversities of all teams formed.
Your task is to minimize the total diversity of the division of students and find the optimal way to divide the students.
Input
The first line of the input contains one integer n (3 ≤ n ≤ 2 ⋅ 10^5) — the number of students.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is the programming skill of the i-th student.
Output
In the first line print two integers res and k — the minimum total diversity of the division of students and the number of teams in your division, correspondingly.
In the second line print n integers t_1, t_2, ..., t_n (1 ≤ t_i ≤ k), where t_i is the number of team to which the i-th student belong.
If there are multiple answers, you can print any. Note that you don't need to minimize the number of teams. Each team should consist of at least three students.
Examples
Input
5
1 1 3 4 2
Output
3 1
1 1 1 1 1
Input
6
1 5 12 13 2 15
Output
7 2
2 2 1 1 2 1
Input
10
1 2 5 129 185 581 1041 1909 1580 8150
Output
7486 3
3 3 3 2 2 2 2 1 1 1
Note
In the first example, there is only one team with skills [1, 1, 2, 3, 4] so the answer is 3. It can be shown that you cannot achieve a better answer.
In the second example, there are two teams with skills [1, 2, 5] and [12, 13, 15] so the answer is 4 + 3 = 7.
In the third example, there are three teams with skills [1, 2, 5], [129, 185, 581, 1041] and [1580, 1909, 8150] so the answer is 4 + 912 + 6570 = 7486.
Submitted Solution:
```
import sys
from sys import stdin
n = int(stdin.readline())
ao = list(map(int,stdin.readline().split()))
ai = [(ao[i],i) for i in range(n)]
ai.sort()
a = [ai[i][0] for i in range(n)]
dp = [ [float("inf")] * 3 for i in range(n+1) ]
pp = [ [0,1,2] for i in range(n+1) ]
dp[0][0] = 0
for i in range(n):
if dp[i+1][1] > dp[i][0] - a[i]:
dp[i+1][1] = dp[i][0] - a[i]
pp[i+1][1] = 0
if dp[i+1][2] > dp[i][1]:
dp[i+1][2] = dp[i][1]
pp[i+1][2] = 1
if dp[i+1][2] > dp[i][2]:
dp[i+1][2] = dp[i][2]
pp[i+1][2] = 2
if dp[i+1][0] > dp[i][2] + a[i]:
dp[i+1][0] = dp[i][2] + a[i]
pp[i+1][0] = 2
ansmax = dp[n][0]
#print (ansmax,file=sys.stderr)
ans = [None] * n
now = 1
nv = pp[n][0]
for i in range(n-1,-1,-1):
ans[ai[i][1]] = now
if nv == 0:
now += 1
nv = pp[i][nv]
print (ansmax,max(ans))
print (*ans)
``` | instruction | 0 | 45,521 | 17 | 91,042 |
Yes | output | 1 | 45,521 | 17 | 91,043 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n students at your university. The programming skill of the i-th student is a_i. As a coach, you want to divide them into teams to prepare them for the upcoming ICPC finals. Just imagine how good this university is if it has 2 ⋅ 10^5 students ready for the finals!
Each team should consist of at least three students. Each student should belong to exactly one team. The diversity of a team is the difference between the maximum programming skill of some student that belongs to this team and the minimum programming skill of some student that belongs to this team (in other words, if the team consists of k students with programming skills a[i_1], a[i_2], ..., a[i_k], then the diversity of this team is max_{j=1}^{k} a[i_j] - min_{j=1}^{k} a[i_j]).
The total diversity is the sum of diversities of all teams formed.
Your task is to minimize the total diversity of the division of students and find the optimal way to divide the students.
Input
The first line of the input contains one integer n (3 ≤ n ≤ 2 ⋅ 10^5) — the number of students.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is the programming skill of the i-th student.
Output
In the first line print two integers res and k — the minimum total diversity of the division of students and the number of teams in your division, correspondingly.
In the second line print n integers t_1, t_2, ..., t_n (1 ≤ t_i ≤ k), where t_i is the number of team to which the i-th student belong.
If there are multiple answers, you can print any. Note that you don't need to minimize the number of teams. Each team should consist of at least three students.
Examples
Input
5
1 1 3 4 2
Output
3 1
1 1 1 1 1
Input
6
1 5 12 13 2 15
Output
7 2
2 2 1 1 2 1
Input
10
1 2 5 129 185 581 1041 1909 1580 8150
Output
7486 3
3 3 3 2 2 2 2 1 1 1
Note
In the first example, there is only one team with skills [1, 1, 2, 3, 4] so the answer is 3. It can be shown that you cannot achieve a better answer.
In the second example, there are two teams with skills [1, 2, 5] and [12, 13, 15] so the answer is 4 + 3 = 7.
In the third example, there are three teams with skills [1, 2, 5], [129, 185, 581, 1041] and [1580, 1909, 8150] so the answer is 4 + 912 + 6570 = 7486.
Submitted Solution:
```
#!/usr/bin/env python -i
from operator import itemgetter
from math import inf
n = int(input())
a = list(map(int, input().split()))
s = list(enumerate(a))
s.sort(key=itemgetter(1))
dp = [inf] * (n + 1)
dp[0] = 0
p = [-1] * (n + 1)
for i, (j, aj) in enumerate(s):
for k in range(i - 2, i - 6, -1):
if k >= 0 and dp[k] + abs(s[i][1] - s[k][1]) < dp[i + 1]:
dp[i + 1] = dp[k] + abs(s[i][1] - s[k][1])
p[i + 1] = k
t = [-1] * n
i = n
j = 1
while i:
k = p[i]
for l in range(k, i):
t[s[l][0]] = j
i = k
j += 1
print(dp[n], len(set(t)))
print(*t)
``` | instruction | 0 | 45,522 | 17 | 91,044 |
Yes | output | 1 | 45,522 | 17 | 91,045 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n students at your university. The programming skill of the i-th student is a_i. As a coach, you want to divide them into teams to prepare them for the upcoming ICPC finals. Just imagine how good this university is if it has 2 ⋅ 10^5 students ready for the finals!
Each team should consist of at least three students. Each student should belong to exactly one team. The diversity of a team is the difference between the maximum programming skill of some student that belongs to this team and the minimum programming skill of some student that belongs to this team (in other words, if the team consists of k students with programming skills a[i_1], a[i_2], ..., a[i_k], then the diversity of this team is max_{j=1}^{k} a[i_j] - min_{j=1}^{k} a[i_j]).
The total diversity is the sum of diversities of all teams formed.
Your task is to minimize the total diversity of the division of students and find the optimal way to divide the students.
Input
The first line of the input contains one integer n (3 ≤ n ≤ 2 ⋅ 10^5) — the number of students.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is the programming skill of the i-th student.
Output
In the first line print two integers res and k — the minimum total diversity of the division of students and the number of teams in your division, correspondingly.
In the second line print n integers t_1, t_2, ..., t_n (1 ≤ t_i ≤ k), where t_i is the number of team to which the i-th student belong.
If there are multiple answers, you can print any. Note that you don't need to minimize the number of teams. Each team should consist of at least three students.
Examples
Input
5
1 1 3 4 2
Output
3 1
1 1 1 1 1
Input
6
1 5 12 13 2 15
Output
7 2
2 2 1 1 2 1
Input
10
1 2 5 129 185 581 1041 1909 1580 8150
Output
7486 3
3 3 3 2 2 2 2 1 1 1
Note
In the first example, there is only one team with skills [1, 1, 2, 3, 4] so the answer is 3. It can be shown that you cannot achieve a better answer.
In the second example, there are two teams with skills [1, 2, 5] and [12, 13, 15] so the answer is 4 + 3 = 7.
In the third example, there are three teams with skills [1, 2, 5], [129, 185, 581, 1041] and [1580, 1909, 8150] so the answer is 4 + 912 + 6570 = 7486.
Submitted Solution:
```
import math,string,itertools,fractions,heapq,collections,re,array,bisect
n = int(input())
a = [int(s) for s in input().split()]
inc = list(range(n))
inc.sort(key=lambda i:a[i])
A = [a[i] for i in inc]
cliff = [0]*n
for i in range(1,n):
cliff[i] = A[i] - A[i-1]
total = A[n-1] - A[0]
# if cliff[i] is abandoned, means A[i] is the rightSide team's min, A[i-1] is the leftSide team's max
# since if there is overlap, the diversity can be reduced by swapping max1 and min2
# neighbor abandoned cliff i, j must satisfy j-i >= 3
# i, j should also satisfy j - i <= 5
# since if there is a seg >= 6, divide it to 2 segs, means abandon one more element end diversity reduced
memoSum = collections.deque([-1, -1, 0, -1, -1]) # dp memo len = 5
cliff.append(0) # for convenience
steps = [0]*(n+1)
for i in range(3, n+1):
choice = max(0, 1, 2, key=lambda i:memoSum[i])
steps[i] = 5 - choice
memoSum.append(memoSum[choice] + cliff[i])
memoSum.popleft()
diversity = total - memoSum[-1]
ans = [0]*n
i = n
teamTag = 0
while i > 0:
teamTag += 1
teamMem = steps[i]
for j in range(teamMem):
i -= 1
ans[inc[i]] = teamTag
print("{} {}".format(diversity, teamTag))
print(' '.join(str(i) for i in ans))
``` | instruction | 0 | 45,523 | 17 | 91,046 |
Yes | output | 1 | 45,523 | 17 | 91,047 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n students at your university. The programming skill of the i-th student is a_i. As a coach, you want to divide them into teams to prepare them for the upcoming ICPC finals. Just imagine how good this university is if it has 2 ⋅ 10^5 students ready for the finals!
Each team should consist of at least three students. Each student should belong to exactly one team. The diversity of a team is the difference between the maximum programming skill of some student that belongs to this team and the minimum programming skill of some student that belongs to this team (in other words, if the team consists of k students with programming skills a[i_1], a[i_2], ..., a[i_k], then the diversity of this team is max_{j=1}^{k} a[i_j] - min_{j=1}^{k} a[i_j]).
The total diversity is the sum of diversities of all teams formed.
Your task is to minimize the total diversity of the division of students and find the optimal way to divide the students.
Input
The first line of the input contains one integer n (3 ≤ n ≤ 2 ⋅ 10^5) — the number of students.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is the programming skill of the i-th student.
Output
In the first line print two integers res and k — the minimum total diversity of the division of students and the number of teams in your division, correspondingly.
In the second line print n integers t_1, t_2, ..., t_n (1 ≤ t_i ≤ k), where t_i is the number of team to which the i-th student belong.
If there are multiple answers, you can print any. Note that you don't need to minimize the number of teams. Each team should consist of at least three students.
Examples
Input
5
1 1 3 4 2
Output
3 1
1 1 1 1 1
Input
6
1 5 12 13 2 15
Output
7 2
2 2 1 1 2 1
Input
10
1 2 5 129 185 581 1041 1909 1580 8150
Output
7486 3
3 3 3 2 2 2 2 1 1 1
Note
In the first example, there is only one team with skills [1, 1, 2, 3, 4] so the answer is 3. It can be shown that you cannot achieve a better answer.
In the second example, there are two teams with skills [1, 2, 5] and [12, 13, 15] so the answer is 4 + 3 = 7.
In the third example, there are three teams with skills [1, 2, 5], [129, 185, 581, 1041] and [1580, 1909, 8150] so the answer is 4 + 912 + 6570 = 7486.
Submitted Solution:
```
n = int(input())
l = [(int(j),i) for i,j in enumerate(input().split())]
l.sort()
i = n-1
tn = 0
ans = [0]*n
teams = 1
res =0
mx = l[-1][0]
while(i>=0):
if(tn<3) or i<2:
tn+=1
ans[l[i][1]] = teams
i-=1
continue
x = (l[i][0] - l[i-1][0])
y = (l[i+1][0] - l[i][0])
# print(x,y, "chaa")
if x>y:
tn+=1
ans[l[i][1]] = teams
i-=1
continue
else:
teams+=1
tn=1
res+=mx-l[i+1][0]
mx = l[i][0]
ans[l[i][1]] = teams
i-=1
res+=mx-l[0][0]
# print(l, ans)
print(res,teams)
# ans = ans[::-1]
for i in range(n):
print(ans[i], end = " ")
print()
``` | instruction | 0 | 45,524 | 17 | 91,048 |
No | output | 1 | 45,524 | 17 | 91,049 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n students at your university. The programming skill of the i-th student is a_i. As a coach, you want to divide them into teams to prepare them for the upcoming ICPC finals. Just imagine how good this university is if it has 2 ⋅ 10^5 students ready for the finals!
Each team should consist of at least three students. Each student should belong to exactly one team. The diversity of a team is the difference between the maximum programming skill of some student that belongs to this team and the minimum programming skill of some student that belongs to this team (in other words, if the team consists of k students with programming skills a[i_1], a[i_2], ..., a[i_k], then the diversity of this team is max_{j=1}^{k} a[i_j] - min_{j=1}^{k} a[i_j]).
The total diversity is the sum of diversities of all teams formed.
Your task is to minimize the total diversity of the division of students and find the optimal way to divide the students.
Input
The first line of the input contains one integer n (3 ≤ n ≤ 2 ⋅ 10^5) — the number of students.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is the programming skill of the i-th student.
Output
In the first line print two integers res and k — the minimum total diversity of the division of students and the number of teams in your division, correspondingly.
In the second line print n integers t_1, t_2, ..., t_n (1 ≤ t_i ≤ k), where t_i is the number of team to which the i-th student belong.
If there are multiple answers, you can print any. Note that you don't need to minimize the number of teams. Each team should consist of at least three students.
Examples
Input
5
1 1 3 4 2
Output
3 1
1 1 1 1 1
Input
6
1 5 12 13 2 15
Output
7 2
2 2 1 1 2 1
Input
10
1 2 5 129 185 581 1041 1909 1580 8150
Output
7486 3
3 3 3 2 2 2 2 1 1 1
Note
In the first example, there is only one team with skills [1, 1, 2, 3, 4] so the answer is 3. It can be shown that you cannot achieve a better answer.
In the second example, there are two teams with skills [1, 2, 5] and [12, 13, 15] so the answer is 4 + 3 = 7.
In the third example, there are three teams with skills [1, 2, 5], [129, 185, 581, 1041] and [1580, 1909, 8150] so the answer is 4 + 912 + 6570 = 7486.
Submitted Solution:
```
import bisect
n = int(input())
a = list(map(int,input().split()))
b = sorted(a)
dp = [0]*n
if n == 3:
print(b[-1]-b[0],1)
print(1,1,1)
elif n == 4:
print(b[-1]-b[0],1)
print(1,1,1,1)
elif n == 5:
print(b[-1]-b[0],1)
print(1,1,1,1,1)
else:
cnt = [0]*n
dp[2] = b[2]-b[0]
dp[3] = b[3]-b[0]
dp[4] = b[4]-b[0]
cnt[2] = 3
cnt[3] = 4
cnt[5] = 5
for i in range(5,n):
tmp = dp[i-5]+b[i]-b[i-4]
cnt[i] = 5
if tmp >= dp[i-4]+b[i]-b[i-3]:
tmp = dp[i-4]+b[i]-b[i-3]
cnt[i] = 4
if tmp >= dp[i-3]+b[i]-b[i-2]:
tmp = dp[i-3]+b[i]-b[i-2]
cnt[i] = 3
dp[i] = tmp
k = 0
qq = 0
for i in range(n-1,-1,-1):
if k == 0:
qq += 1
k = cnt[i]-1
cnt[i] = qq
else:
cnt[i] = qq
k -= 1
idx = [0]*n
for i,e in enumerate(a):
kk = bisect.bisect_left(b,e)
idx[i] = cnt[kk]
b[kk] -= 1
print(dp[-1],qq)
for e in idx:
print(e,end=' ')
``` | instruction | 0 | 45,525 | 17 | 91,050 |
No | output | 1 | 45,525 | 17 | 91,051 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n students at your university. The programming skill of the i-th student is a_i. As a coach, you want to divide them into teams to prepare them for the upcoming ICPC finals. Just imagine how good this university is if it has 2 ⋅ 10^5 students ready for the finals!
Each team should consist of at least three students. Each student should belong to exactly one team. The diversity of a team is the difference between the maximum programming skill of some student that belongs to this team and the minimum programming skill of some student that belongs to this team (in other words, if the team consists of k students with programming skills a[i_1], a[i_2], ..., a[i_k], then the diversity of this team is max_{j=1}^{k} a[i_j] - min_{j=1}^{k} a[i_j]).
The total diversity is the sum of diversities of all teams formed.
Your task is to minimize the total diversity of the division of students and find the optimal way to divide the students.
Input
The first line of the input contains one integer n (3 ≤ n ≤ 2 ⋅ 10^5) — the number of students.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is the programming skill of the i-th student.
Output
In the first line print two integers res and k — the minimum total diversity of the division of students and the number of teams in your division, correspondingly.
In the second line print n integers t_1, t_2, ..., t_n (1 ≤ t_i ≤ k), where t_i is the number of team to which the i-th student belong.
If there are multiple answers, you can print any. Note that you don't need to minimize the number of teams. Each team should consist of at least three students.
Examples
Input
5
1 1 3 4 2
Output
3 1
1 1 1 1 1
Input
6
1 5 12 13 2 15
Output
7 2
2 2 1 1 2 1
Input
10
1 2 5 129 185 581 1041 1909 1580 8150
Output
7486 3
3 3 3 2 2 2 2 1 1 1
Note
In the first example, there is only one team with skills [1, 1, 2, 3, 4] so the answer is 3. It can be shown that you cannot achieve a better answer.
In the second example, there are two teams with skills [1, 2, 5] and [12, 13, 15] so the answer is 4 + 3 = 7.
In the third example, there are three teams with skills [1, 2, 5], [129, 185, 581, 1041] and [1580, 1909, 8150] so the answer is 4 + 912 + 6570 = 7486.
Submitted Solution:
```
import os
import sys
from io import BytesIO, IOBase
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# ------------------------------
from math import factorial
from collections import Counter, defaultdict, deque
from heapq import heapify, heappop, heappush
def RL(): return map(int, sys.stdin.readline().rstrip().split())
def RLL(): return list(map(int, sys.stdin.readline().rstrip().split()))
def N(): return int(input())
def comb(n, m): return factorial(n) / (factorial(m) * factorial(n - m)) if n >= m else 0
def perm(n, m): return factorial(n) // (factorial(n - m)) if n >= m else 0
def mdis(x1, y1, x2, y2): return abs(x1 - x2) + abs(y1 - y2)
mod = 998244353
INF = float('inf')
# ------------------------------
def main():
n = N()
arr = RLL()
ind = [i for i in range(n)]
ind.sort(key=lambda a: arr[a])
dp = [[INF]*4 for i in range(n+1)]
dp[0] = [0, 0, 0, 0]
dic = {0: 3, 1: 4, 2: 5, 3: 6}
for i in range(1, n+1):
for j in range(4):
for k in range(4):
now = dp[i-dic[j]][k]
if now==INF: continue
dif = arr[ind[i-1]]-arr[ind[i-dic[j]]]
dp[i][j] = min(dp[i-dic[j]][k]+dif, dp[i][j])
res = min(dp[-1])
tm = []
tag = n; tmtag = 0
while tag>0:
tmtag+=1
mind = 0
for i in range(4):
if dp[tag][i]<dp[tag][mind]:
mind = i
tm.extend([tmtag]*dic[mind])
tag-=dic[mind]
td = [(ind[i], tm[i]) for i in range(n)]
print(res, tmtag)
td.sort(key=lambda a: a[0])
print(*[i[1] for i in td])
if __name__ == "__main__":
main()
``` | instruction | 0 | 45,526 | 17 | 91,052 |
No | output | 1 | 45,526 | 17 | 91,053 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n students at your university. The programming skill of the i-th student is a_i. As a coach, you want to divide them into teams to prepare them for the upcoming ICPC finals. Just imagine how good this university is if it has 2 ⋅ 10^5 students ready for the finals!
Each team should consist of at least three students. Each student should belong to exactly one team. The diversity of a team is the difference between the maximum programming skill of some student that belongs to this team and the minimum programming skill of some student that belongs to this team (in other words, if the team consists of k students with programming skills a[i_1], a[i_2], ..., a[i_k], then the diversity of this team is max_{j=1}^{k} a[i_j] - min_{j=1}^{k} a[i_j]).
The total diversity is the sum of diversities of all teams formed.
Your task is to minimize the total diversity of the division of students and find the optimal way to divide the students.
Input
The first line of the input contains one integer n (3 ≤ n ≤ 2 ⋅ 10^5) — the number of students.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is the programming skill of the i-th student.
Output
In the first line print two integers res and k — the minimum total diversity of the division of students and the number of teams in your division, correspondingly.
In the second line print n integers t_1, t_2, ..., t_n (1 ≤ t_i ≤ k), where t_i is the number of team to which the i-th student belong.
If there are multiple answers, you can print any. Note that you don't need to minimize the number of teams. Each team should consist of at least three students.
Examples
Input
5
1 1 3 4 2
Output
3 1
1 1 1 1 1
Input
6
1 5 12 13 2 15
Output
7 2
2 2 1 1 2 1
Input
10
1 2 5 129 185 581 1041 1909 1580 8150
Output
7486 3
3 3 3 2 2 2 2 1 1 1
Note
In the first example, there is only one team with skills [1, 1, 2, 3, 4] so the answer is 3. It can be shown that you cannot achieve a better answer.
In the second example, there are two teams with skills [1, 2, 5] and [12, 13, 15] so the answer is 4 + 3 = 7.
In the third example, there are three teams with skills [1, 2, 5], [129, 185, 581, 1041] and [1580, 1909, 8150] so the answer is 4 + 912 + 6570 = 7486.
Submitted Solution:
```
print("3 1")
print("1 1 1 1 1")
``` | instruction | 0 | 45,527 | 17 | 91,054 |
No | output | 1 | 45,527 | 17 | 91,055 |
Provide tags and a correct Python 3 solution for this coding contest problem.
One day, at the "Russian Code Cup" event it was decided to play football as an out of competition event. All participants was divided into n teams and played several matches, two teams could not play against each other more than once.
The appointed Judge was the most experienced member — Pavel. But since he was the wisest of all, he soon got bored of the game and fell asleep. Waking up, he discovered that the tournament is over and the teams want to know the results of all the matches.
Pavel didn't want anyone to discover about him sleeping and not keeping an eye on the results, so he decided to recover the results of all games. To do this, he asked all the teams and learned that the real winner was friendship, that is, each team beat the other teams exactly k times. Help Pavel come up with chronology of the tournir that meets all the conditions, or otherwise report that there is no such table.
Input
The first line contains two integers — n and k (1 ≤ n, k ≤ 1000).
Output
In the first line print an integer m — number of the played games. The following m lines should contain the information about all the matches, one match per line. The i-th line should contain two integers ai and bi (1 ≤ ai, bi ≤ n; ai ≠ bi). The numbers ai and bi mean, that in the i-th match the team with number ai won against the team with number bi. You can assume, that the teams are numbered from 1 to n.
If a tournir that meets the conditions of the problem does not exist, then print -1.
Examples
Input
3 1
Output
3
1 2
2 3
3 1 | instruction | 0 | 46,611 | 17 | 93,222 |
Tags: constructive algorithms, graphs, implementation
Correct Solution:
```
import math,sys,bisect,heapq
from collections import defaultdict,Counter,deque
from itertools import groupby,accumulate
#sys.setrecursionlimit(200000000)
int1 = lambda x: int(x) - 1
#def input(): return sys.stdin.readline().strip()
input = iter(sys.stdin.buffer.read().decode().splitlines()).__next__
ilele = lambda: map(int,input().split())
alele = lambda: list(map(int, input().split()))
ilelec = lambda: map(int1,input().split())
alelec = lambda: list(map(int1, input().split()))
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
#MOD = 1000000000 + 7
def Y(c): print(["NO","YES"][c])
def y(c): print(["no","yes"][c])
def Yy(c): print(["No","Yes"][c])
n,k = ilele()
if not(2*k <= n-1):
print(-1)
else:
print(n*k)
for i in range(1,n+1):
for j in range(i+1,i+1+k):
if j > n:
j = j - n
print(i,j)
``` | output | 1 | 46,611 | 17 | 93,223 |
Provide tags and a correct Python 3 solution for this coding contest problem.
One day, at the "Russian Code Cup" event it was decided to play football as an out of competition event. All participants was divided into n teams and played several matches, two teams could not play against each other more than once.
The appointed Judge was the most experienced member — Pavel. But since he was the wisest of all, he soon got bored of the game and fell asleep. Waking up, he discovered that the tournament is over and the teams want to know the results of all the matches.
Pavel didn't want anyone to discover about him sleeping and not keeping an eye on the results, so he decided to recover the results of all games. To do this, he asked all the teams and learned that the real winner was friendship, that is, each team beat the other teams exactly k times. Help Pavel come up with chronology of the tournir that meets all the conditions, or otherwise report that there is no such table.
Input
The first line contains two integers — n and k (1 ≤ n, k ≤ 1000).
Output
In the first line print an integer m — number of the played games. The following m lines should contain the information about all the matches, one match per line. The i-th line should contain two integers ai and bi (1 ≤ ai, bi ≤ n; ai ≠ bi). The numbers ai and bi mean, that in the i-th match the team with number ai won against the team with number bi. You can assume, that the teams are numbered from 1 to n.
If a tournir that meets the conditions of the problem does not exist, then print -1.
Examples
Input
3 1
Output
3
1 2
2 3
3 1 | instruction | 0 | 46,612 | 17 | 93,224 |
Tags: constructive algorithms, graphs, implementation
Correct Solution:
```
n, k = tuple(map(int, input().split()))
if (n - 1) // 2 < k:
print(-1)
else:
answer = []
m = n * k
print(m)
for i in range(1, n + 1):
for j in range(1, k + 1):
a = i
b = (i + j) % n
if not b:
b = n
answer.append(str(a) + ' ' + str(b))
print('\n'.join(answer))
``` | output | 1 | 46,612 | 17 | 93,225 |
Provide tags and a correct Python 3 solution for this coding contest problem.
One day, at the "Russian Code Cup" event it was decided to play football as an out of competition event. All participants was divided into n teams and played several matches, two teams could not play against each other more than once.
The appointed Judge was the most experienced member — Pavel. But since he was the wisest of all, he soon got bored of the game and fell asleep. Waking up, he discovered that the tournament is over and the teams want to know the results of all the matches.
Pavel didn't want anyone to discover about him sleeping and not keeping an eye on the results, so he decided to recover the results of all games. To do this, he asked all the teams and learned that the real winner was friendship, that is, each team beat the other teams exactly k times. Help Pavel come up with chronology of the tournir that meets all the conditions, or otherwise report that there is no such table.
Input
The first line contains two integers — n and k (1 ≤ n, k ≤ 1000).
Output
In the first line print an integer m — number of the played games. The following m lines should contain the information about all the matches, one match per line. The i-th line should contain two integers ai and bi (1 ≤ ai, bi ≤ n; ai ≠ bi). The numbers ai and bi mean, that in the i-th match the team with number ai won against the team with number bi. You can assume, that the teams are numbered from 1 to n.
If a tournir that meets the conditions of the problem does not exist, then print -1.
Examples
Input
3 1
Output
3
1 2
2 3
3 1 | instruction | 0 | 46,613 | 17 | 93,226 |
Tags: constructive algorithms, graphs, implementation
Correct Solution:
```
n,k=map(int,input().split())
if n<2*k+1:
print(-1)
else:
print(n*k)
for i in range(1,n+1):
for z in range(k):
print(i,(i+z)%n+1)
``` | output | 1 | 46,613 | 17 | 93,227 |
Provide tags and a correct Python 3 solution for this coding contest problem.
One day, at the "Russian Code Cup" event it was decided to play football as an out of competition event. All participants was divided into n teams and played several matches, two teams could not play against each other more than once.
The appointed Judge was the most experienced member — Pavel. But since he was the wisest of all, he soon got bored of the game and fell asleep. Waking up, he discovered that the tournament is over and the teams want to know the results of all the matches.
Pavel didn't want anyone to discover about him sleeping and not keeping an eye on the results, so he decided to recover the results of all games. To do this, he asked all the teams and learned that the real winner was friendship, that is, each team beat the other teams exactly k times. Help Pavel come up with chronology of the tournir that meets all the conditions, or otherwise report that there is no such table.
Input
The first line contains two integers — n and k (1 ≤ n, k ≤ 1000).
Output
In the first line print an integer m — number of the played games. The following m lines should contain the information about all the matches, one match per line. The i-th line should contain two integers ai and bi (1 ≤ ai, bi ≤ n; ai ≠ bi). The numbers ai and bi mean, that in the i-th match the team with number ai won against the team with number bi. You can assume, that the teams are numbered from 1 to n.
If a tournir that meets the conditions of the problem does not exist, then print -1.
Examples
Input
3 1
Output
3
1 2
2 3
3 1 | instruction | 0 | 46,614 | 17 | 93,228 |
Tags: constructive algorithms, graphs, implementation
Correct Solution:
```
import sys
f = sys.stdin
n, k = map(int, f.readline().strip().split())
if 2*k>(n-1):
print('-1')
else:
r = [str(n*k)]
for i in range(n):
for j in range(k):
r.append(str(i+1) + ' ' + str((i+j+1)%n+1))
print('\n'.join(r))
``` | output | 1 | 46,614 | 17 | 93,229 |
Provide tags and a correct Python 3 solution for this coding contest problem.
One day, at the "Russian Code Cup" event it was decided to play football as an out of competition event. All participants was divided into n teams and played several matches, two teams could not play against each other more than once.
The appointed Judge was the most experienced member — Pavel. But since he was the wisest of all, he soon got bored of the game and fell asleep. Waking up, he discovered that the tournament is over and the teams want to know the results of all the matches.
Pavel didn't want anyone to discover about him sleeping and not keeping an eye on the results, so he decided to recover the results of all games. To do this, he asked all the teams and learned that the real winner was friendship, that is, each team beat the other teams exactly k times. Help Pavel come up with chronology of the tournir that meets all the conditions, or otherwise report that there is no such table.
Input
The first line contains two integers — n and k (1 ≤ n, k ≤ 1000).
Output
In the first line print an integer m — number of the played games. The following m lines should contain the information about all the matches, one match per line. The i-th line should contain two integers ai and bi (1 ≤ ai, bi ≤ n; ai ≠ bi). The numbers ai and bi mean, that in the i-th match the team with number ai won against the team with number bi. You can assume, that the teams are numbered from 1 to n.
If a tournir that meets the conditions of the problem does not exist, then print -1.
Examples
Input
3 1
Output
3
1 2
2 3
3 1 | instruction | 0 | 46,615 | 17 | 93,230 |
Tags: constructive algorithms, graphs, implementation
Correct Solution:
```
#code by AanchalTiwari
n, k = map(int, input().split())
if n < 2 * k + 1:
print(-1)
else:
print(n*k)
for i in range(1, n + 1):
c = 1
while c <= k:
a = i
b = i+c
if i + c > n:
a = i
b = (i+c) % n
print(a, b)
c = c + 1
``` | output | 1 | 46,615 | 17 | 93,231 |
Provide tags and a correct Python 3 solution for this coding contest problem.
One day, at the "Russian Code Cup" event it was decided to play football as an out of competition event. All participants was divided into n teams and played several matches, two teams could not play against each other more than once.
The appointed Judge was the most experienced member — Pavel. But since he was the wisest of all, he soon got bored of the game and fell asleep. Waking up, he discovered that the tournament is over and the teams want to know the results of all the matches.
Pavel didn't want anyone to discover about him sleeping and not keeping an eye on the results, so he decided to recover the results of all games. To do this, he asked all the teams and learned that the real winner was friendship, that is, each team beat the other teams exactly k times. Help Pavel come up with chronology of the tournir that meets all the conditions, or otherwise report that there is no such table.
Input
The first line contains two integers — n and k (1 ≤ n, k ≤ 1000).
Output
In the first line print an integer m — number of the played games. The following m lines should contain the information about all the matches, one match per line. The i-th line should contain two integers ai and bi (1 ≤ ai, bi ≤ n; ai ≠ bi). The numbers ai and bi mean, that in the i-th match the team with number ai won against the team with number bi. You can assume, that the teams are numbered from 1 to n.
If a tournir that meets the conditions of the problem does not exist, then print -1.
Examples
Input
3 1
Output
3
1 2
2 3
3 1 | instruction | 0 | 46,616 | 17 | 93,232 |
Tags: constructive algorithms, graphs, implementation
Correct Solution:
```
#collaborated with Bhumi Patel
input_var=input()
input_var=input_var.split()
n=int(input_var[0])
k=int(input_var[1])
temp=n-1
if (temp/2<k):
print("-1")
else:
print(n*k)
for i in range(1,k+1):
for j in range(1,n+1):
print(j,sep=" ",end=" ")
if ((j+i)%n)!=0:
print((i+j)%n,sep=" ")
else:
print(n,sep=" ")
``` | output | 1 | 46,616 | 17 | 93,233 |
Provide tags and a correct Python 3 solution for this coding contest problem.
One day, at the "Russian Code Cup" event it was decided to play football as an out of competition event. All participants was divided into n teams and played several matches, two teams could not play against each other more than once.
The appointed Judge was the most experienced member — Pavel. But since he was the wisest of all, he soon got bored of the game and fell asleep. Waking up, he discovered that the tournament is over and the teams want to know the results of all the matches.
Pavel didn't want anyone to discover about him sleeping and not keeping an eye on the results, so he decided to recover the results of all games. To do this, he asked all the teams and learned that the real winner was friendship, that is, each team beat the other teams exactly k times. Help Pavel come up with chronology of the tournir that meets all the conditions, or otherwise report that there is no such table.
Input
The first line contains two integers — n and k (1 ≤ n, k ≤ 1000).
Output
In the first line print an integer m — number of the played games. The following m lines should contain the information about all the matches, one match per line. The i-th line should contain two integers ai and bi (1 ≤ ai, bi ≤ n; ai ≠ bi). The numbers ai and bi mean, that in the i-th match the team with number ai won against the team with number bi. You can assume, that the teams are numbered from 1 to n.
If a tournir that meets the conditions of the problem does not exist, then print -1.
Examples
Input
3 1
Output
3
1 2
2 3
3 1 | instruction | 0 | 46,617 | 17 | 93,234 |
Tags: constructive algorithms, graphs, implementation
Correct Solution:
```
# Made By Mostafa_Khaled
bot = True
import sys
f = sys.stdin
n, k = map(int, f.readline().strip().split())
if 2*k>(n-1):
print('-1')
else:
r = [str(n*k)]
for i in range(n):
for j in range(k):
r.append(str(i+1) + ' ' + str((i+j+1)%n+1))
print('\n'.join(r))
# Made By Mostafa_Khaled
``` | output | 1 | 46,617 | 17 | 93,235 |
Provide tags and a correct Python 3 solution for this coding contest problem.
One day, at the "Russian Code Cup" event it was decided to play football as an out of competition event. All participants was divided into n teams and played several matches, two teams could not play against each other more than once.
The appointed Judge was the most experienced member — Pavel. But since he was the wisest of all, he soon got bored of the game and fell asleep. Waking up, he discovered that the tournament is over and the teams want to know the results of all the matches.
Pavel didn't want anyone to discover about him sleeping and not keeping an eye on the results, so he decided to recover the results of all games. To do this, he asked all the teams and learned that the real winner was friendship, that is, each team beat the other teams exactly k times. Help Pavel come up with chronology of the tournir that meets all the conditions, or otherwise report that there is no such table.
Input
The first line contains two integers — n and k (1 ≤ n, k ≤ 1000).
Output
In the first line print an integer m — number of the played games. The following m lines should contain the information about all the matches, one match per line. The i-th line should contain two integers ai and bi (1 ≤ ai, bi ≤ n; ai ≠ bi). The numbers ai and bi mean, that in the i-th match the team with number ai won against the team with number bi. You can assume, that the teams are numbered from 1 to n.
If a tournir that meets the conditions of the problem does not exist, then print -1.
Examples
Input
3 1
Output
3
1 2
2 3
3 1 | instruction | 0 | 46,618 | 17 | 93,236 |
Tags: constructive algorithms, graphs, implementation
Correct Solution:
```
n,m=map(int,input().split())
if (2*m+1>n): print(-1)
else:
print(n*m)
for i in range(0,n):
for j in range(1,m+1):
print(i+1,(i+j)%n+1)
``` | output | 1 | 46,618 | 17 | 93,237 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One day, at the "Russian Code Cup" event it was decided to play football as an out of competition event. All participants was divided into n teams and played several matches, two teams could not play against each other more than once.
The appointed Judge was the most experienced member — Pavel. But since he was the wisest of all, he soon got bored of the game and fell asleep. Waking up, he discovered that the tournament is over and the teams want to know the results of all the matches.
Pavel didn't want anyone to discover about him sleeping and not keeping an eye on the results, so he decided to recover the results of all games. To do this, he asked all the teams and learned that the real winner was friendship, that is, each team beat the other teams exactly k times. Help Pavel come up with chronology of the tournir that meets all the conditions, or otherwise report that there is no such table.
Input
The first line contains two integers — n and k (1 ≤ n, k ≤ 1000).
Output
In the first line print an integer m — number of the played games. The following m lines should contain the information about all the matches, one match per line. The i-th line should contain two integers ai and bi (1 ≤ ai, bi ≤ n; ai ≠ bi). The numbers ai and bi mean, that in the i-th match the team with number ai won against the team with number bi. You can assume, that the teams are numbered from 1 to n.
If a tournir that meets the conditions of the problem does not exist, then print -1.
Examples
Input
3 1
Output
3
1 2
2 3
3 1
Submitted Solution:
```
n,k = map(int, input().split())
if 2*k+1>n:
print(-1)
else:
print(n*k)
for i in range(n):
for j in range(k):
print(i+1,(i+1+j)%n+1)
``` | instruction | 0 | 46,619 | 17 | 93,238 |
Yes | output | 1 | 46,619 | 17 | 93,239 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One day, at the "Russian Code Cup" event it was decided to play football as an out of competition event. All participants was divided into n teams and played several matches, two teams could not play against each other more than once.
The appointed Judge was the most experienced member — Pavel. But since he was the wisest of all, he soon got bored of the game and fell asleep. Waking up, he discovered that the tournament is over and the teams want to know the results of all the matches.
Pavel didn't want anyone to discover about him sleeping and not keeping an eye on the results, so he decided to recover the results of all games. To do this, he asked all the teams and learned that the real winner was friendship, that is, each team beat the other teams exactly k times. Help Pavel come up with chronology of the tournir that meets all the conditions, or otherwise report that there is no such table.
Input
The first line contains two integers — n and k (1 ≤ n, k ≤ 1000).
Output
In the first line print an integer m — number of the played games. The following m lines should contain the information about all the matches, one match per line. The i-th line should contain two integers ai and bi (1 ≤ ai, bi ≤ n; ai ≠ bi). The numbers ai and bi mean, that in the i-th match the team with number ai won against the team with number bi. You can assume, that the teams are numbered from 1 to n.
If a tournir that meets the conditions of the problem does not exist, then print -1.
Examples
Input
3 1
Output
3
1 2
2 3
3 1
Submitted Solution:
```
import sys,math
n,k=map(int,sys.stdin.readline().split())
if n<=2*k:
print(-1)
else:
ans=[]
for i in range(n):
for j in range(i+1,k+i+1):
if j+1==n:
ans.append([i+1,j+1])
else:
ans.append([i+1,((j+1)%n)])
print(len(ans))
for i in range(len(ans)):
print(*ans[i])
``` | instruction | 0 | 46,620 | 17 | 93,240 |
Yes | output | 1 | 46,620 | 17 | 93,241 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One day, at the "Russian Code Cup" event it was decided to play football as an out of competition event. All participants was divided into n teams and played several matches, two teams could not play against each other more than once.
The appointed Judge was the most experienced member — Pavel. But since he was the wisest of all, he soon got bored of the game and fell asleep. Waking up, he discovered that the tournament is over and the teams want to know the results of all the matches.
Pavel didn't want anyone to discover about him sleeping and not keeping an eye on the results, so he decided to recover the results of all games. To do this, he asked all the teams and learned that the real winner was friendship, that is, each team beat the other teams exactly k times. Help Pavel come up with chronology of the tournir that meets all the conditions, or otherwise report that there is no such table.
Input
The first line contains two integers — n and k (1 ≤ n, k ≤ 1000).
Output
In the first line print an integer m — number of the played games. The following m lines should contain the information about all the matches, one match per line. The i-th line should contain two integers ai and bi (1 ≤ ai, bi ≤ n; ai ≠ bi). The numbers ai and bi mean, that in the i-th match the team with number ai won against the team with number bi. You can assume, that the teams are numbered from 1 to n.
If a tournir that meets the conditions of the problem does not exist, then print -1.
Examples
Input
3 1
Output
3
1 2
2 3
3 1
Submitted Solution:
```
#!/usr/bin/python
import re
import inspect
import os
from sys import argv, exit
def rstr():
return input()
def rstrs(splitchar=' '):
return [i for i in input().split(splitchar)]
def rint():
return int(input())
def rints(splitchar=' '):
return [int(i) for i in rstrs(splitchar)]
def varnames(obj, namespace=globals()):
return [name for name in namespace if namespace[name] is obj]
def pvar(var, override=False):
prnt(varnames(var), var)
def prnt(*args, override=False):
return
if '-v' in argv or override:
print(*args)
pq = []
def penq(thing):
pq.append(thing)
def pdump():
s = ('\n'.join(pq)).encode()
os.write(1, s)
if __name__ == '__main__':
teams, wins = rints()
if teams < wins*2+1:
print('-1')
exit(0)
penq(str(teams*wins))
for team in range(teams):
w = 0
while w < wins:
otherteam = (team + w + 1) % teams
penq('{} {}'.format(team + 1, otherteam + 1))
w += 1
pdump()
``` | instruction | 0 | 46,621 | 17 | 93,242 |
Yes | output | 1 | 46,621 | 17 | 93,243 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One day, at the "Russian Code Cup" event it was decided to play football as an out of competition event. All participants was divided into n teams and played several matches, two teams could not play against each other more than once.
The appointed Judge was the most experienced member — Pavel. But since he was the wisest of all, he soon got bored of the game and fell asleep. Waking up, he discovered that the tournament is over and the teams want to know the results of all the matches.
Pavel didn't want anyone to discover about him sleeping and not keeping an eye on the results, so he decided to recover the results of all games. To do this, he asked all the teams and learned that the real winner was friendship, that is, each team beat the other teams exactly k times. Help Pavel come up with chronology of the tournir that meets all the conditions, or otherwise report that there is no such table.
Input
The first line contains two integers — n and k (1 ≤ n, k ≤ 1000).
Output
In the first line print an integer m — number of the played games. The following m lines should contain the information about all the matches, one match per line. The i-th line should contain two integers ai and bi (1 ≤ ai, bi ≤ n; ai ≠ bi). The numbers ai and bi mean, that in the i-th match the team with number ai won against the team with number bi. You can assume, that the teams are numbered from 1 to n.
If a tournir that meets the conditions of the problem does not exist, then print -1.
Examples
Input
3 1
Output
3
1 2
2 3
3 1
Submitted Solution:
```
n,k=map(int,input().split())
a=n*(n-1)//2
if(n*k>a):
print(-1)
else:
l=set()
for i in range(1,n+1):
for j in range(k):
l.add(str(i)+' '+str((i+j)%n+1))
print(n*k)
print('\n'.join(l))
``` | instruction | 0 | 46,622 | 17 | 93,244 |
Yes | output | 1 | 46,622 | 17 | 93,245 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One day, at the "Russian Code Cup" event it was decided to play football as an out of competition event. All participants was divided into n teams and played several matches, two teams could not play against each other more than once.
The appointed Judge was the most experienced member — Pavel. But since he was the wisest of all, he soon got bored of the game and fell asleep. Waking up, he discovered that the tournament is over and the teams want to know the results of all the matches.
Pavel didn't want anyone to discover about him sleeping and not keeping an eye on the results, so he decided to recover the results of all games. To do this, he asked all the teams and learned that the real winner was friendship, that is, each team beat the other teams exactly k times. Help Pavel come up with chronology of the tournir that meets all the conditions, or otherwise report that there is no such table.
Input
The first line contains two integers — n and k (1 ≤ n, k ≤ 1000).
Output
In the first line print an integer m — number of the played games. The following m lines should contain the information about all the matches, one match per line. The i-th line should contain two integers ai and bi (1 ≤ ai, bi ≤ n; ai ≠ bi). The numbers ai and bi mean, that in the i-th match the team with number ai won against the team with number bi. You can assume, that the teams are numbered from 1 to n.
If a tournir that meets the conditions of the problem does not exist, then print -1.
Examples
Input
3 1
Output
3
1 2
2 3
3 1
Submitted Solution:
```
#collaborated with Bhumi Patel
input_var=input()
input_var=input_var.split()
n=int(input_var[0])
print(n)
k=int(input_var[1])
arrayteamA=[]
arrayteamB=[]
for i in range(1,n+1):
arrayteamA.append(i)
if i==n:
arrayteamB.append(1)
break
arrayteamB.append(i+1)
for i in range(3):
print(arrayteamA[i],arrayteamB[i],sep=" ")
``` | instruction | 0 | 46,623 | 17 | 93,246 |
No | output | 1 | 46,623 | 17 | 93,247 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One day, at the "Russian Code Cup" event it was decided to play football as an out of competition event. All participants was divided into n teams and played several matches, two teams could not play against each other more than once.
The appointed Judge was the most experienced member — Pavel. But since he was the wisest of all, he soon got bored of the game and fell asleep. Waking up, he discovered that the tournament is over and the teams want to know the results of all the matches.
Pavel didn't want anyone to discover about him sleeping and not keeping an eye on the results, so he decided to recover the results of all games. To do this, he asked all the teams and learned that the real winner was friendship, that is, each team beat the other teams exactly k times. Help Pavel come up with chronology of the tournir that meets all the conditions, or otherwise report that there is no such table.
Input
The first line contains two integers — n and k (1 ≤ n, k ≤ 1000).
Output
In the first line print an integer m — number of the played games. The following m lines should contain the information about all the matches, one match per line. The i-th line should contain two integers ai and bi (1 ≤ ai, bi ≤ n; ai ≠ bi). The numbers ai and bi mean, that in the i-th match the team with number ai won against the team with number bi. You can assume, that the teams are numbered from 1 to n.
If a tournir that meets the conditions of the problem does not exist, then print -1.
Examples
Input
3 1
Output
3
1 2
2 3
3 1
Submitted Solution:
```
n, k =list(map(int, input().split()))
wins = [0] * n
matches = (n*(n-1))//2
verdict = []
playedwith = [[] for i in range(n)]
if matches/n == k:
for i in range(matches):
towin = wins.index(min(wins))
#print('mustplay:', towin+1, 'he played with:', playedwith[towin])
for j in range(n):
matchesleft = n-1-len(playedwith[j])
#print(j+1, 'has', matchesleft, 'matches left. He need:', k-wins[j])
if j not in playedwith[towin] and j != towin and matchesleft > k-wins[j]:
verdict.append([towin+1, j+1])
tolose = j
break
else:
print(-1)
exit()
playedwith[towin].append(tolose)
wins[towin] += 1
playedwith[tolose].append(towin)
print(matches)
else:
print(-1)
for i in verdict:
print(i[0], i[1])
``` | instruction | 0 | 46,624 | 17 | 93,248 |
No | output | 1 | 46,624 | 17 | 93,249 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One day, at the "Russian Code Cup" event it was decided to play football as an out of competition event. All participants was divided into n teams and played several matches, two teams could not play against each other more than once.
The appointed Judge was the most experienced member — Pavel. But since he was the wisest of all, he soon got bored of the game and fell asleep. Waking up, he discovered that the tournament is over and the teams want to know the results of all the matches.
Pavel didn't want anyone to discover about him sleeping and not keeping an eye on the results, so he decided to recover the results of all games. To do this, he asked all the teams and learned that the real winner was friendship, that is, each team beat the other teams exactly k times. Help Pavel come up with chronology of the tournir that meets all the conditions, or otherwise report that there is no such table.
Input
The first line contains two integers — n and k (1 ≤ n, k ≤ 1000).
Output
In the first line print an integer m — number of the played games. The following m lines should contain the information about all the matches, one match per line. The i-th line should contain two integers ai and bi (1 ≤ ai, bi ≤ n; ai ≠ bi). The numbers ai and bi mean, that in the i-th match the team with number ai won against the team with number bi. You can assume, that the teams are numbered from 1 to n.
If a tournir that meets the conditions of the problem does not exist, then print -1.
Examples
Input
3 1
Output
3
1 2
2 3
3 1
Submitted Solution:
```
#collaborated with Bhumi Patel
input_var=input()
input_var=input_var.split()
n=int(input_var[0])
k=int(input_var[1])
temp=n-1
temp_summation_var=temp+(temp*(temp-1))/2
if ((k*n)>temp_summation_var):
print("error")
else:
print(n*k)
for i in range(1,n+1):
for j in range(i+1,i+k+1):
if j>n:
print(i , j%n)
else:
print(i,j)
``` | instruction | 0 | 46,625 | 17 | 93,250 |
No | output | 1 | 46,625 | 17 | 93,251 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One day, at the "Russian Code Cup" event it was decided to play football as an out of competition event. All participants was divided into n teams and played several matches, two teams could not play against each other more than once.
The appointed Judge was the most experienced member — Pavel. But since he was the wisest of all, he soon got bored of the game and fell asleep. Waking up, he discovered that the tournament is over and the teams want to know the results of all the matches.
Pavel didn't want anyone to discover about him sleeping and not keeping an eye on the results, so he decided to recover the results of all games. To do this, he asked all the teams and learned that the real winner was friendship, that is, each team beat the other teams exactly k times. Help Pavel come up with chronology of the tournir that meets all the conditions, or otherwise report that there is no such table.
Input
The first line contains two integers — n and k (1 ≤ n, k ≤ 1000).
Output
In the first line print an integer m — number of the played games. The following m lines should contain the information about all the matches, one match per line. The i-th line should contain two integers ai and bi (1 ≤ ai, bi ≤ n; ai ≠ bi). The numbers ai and bi mean, that in the i-th match the team with number ai won against the team with number bi. You can assume, that the teams are numbered from 1 to n.
If a tournir that meets the conditions of the problem does not exist, then print -1.
Examples
Input
3 1
Output
3
1 2
2 3
3 1
Submitted Solution:
```
n, k = tuple(map(int, str.split(input())))
m = (n - 1) * n // 2
print(m)
if k * n != m:
print(-1)
exit()
wins = [0] * n
for i in range(n - 1):
for j in range(i + 1, n):
if wins[i] != k:
print(i + 1, j + 1)
wins[i] += 1
elif wins[j] != k:
print(j + 1, i + 1)
wins[j] += 1
else:
print("wtf!")
``` | instruction | 0 | 46,626 | 17 | 93,252 |
No | output | 1 | 46,626 | 17 | 93,253 |
Provide a correct Python 3 solution for this coding contest problem.
The athletics competition 200M semi-final three races were held. Eight players (24 players in total) will participate in each group. A total of eight players, including the top two players in each group and the top two players from all the players in each group who are third or lower, will advance to the final.
Create a program that inputs the player numbers and times and outputs the numbers and times of the eight finalists.
Input
The input is given in the following format:
p1 t1
p2 t2
::
p24 t24
Lines 1-8, 1st set player number pi (integer, 1 ≤ pi ≤ 10000) and time ti (real number measured to 1/100, 1 ≤ ti ≤ 100), lines 9-16 Is given the player number pi and time ti of the second group, and the player number pi and time ti of the third group on the 17th to 24th lines. It is assumed that there are no players with the same player number or the same time.
Output
In the following order, please output the player numbers and times of the finalists on one line, separated by blanks.
1st place player in the 1st group
2nd place player in the 1st group
1st place player in the 2nd group
2nd place player in the 2nd group
1st place player in the 3rd group
Second place player in the third group
The player with the fastest time among the players who are 3rd or lower in each group
The player with the second fastest time among the players who are third or lower in each group
Example
Input
18 25.46
16 26.23
3 23.00
10 24.79
5 22.88
11 23.87
19 23.90
1 25.11
23 23.88
4 23.46
7 24.12
12 22.91
13 21.99
14 22.86
21 23.12
9 24.09
17 22.51
22 23.49
6 23.02
20 22.23
24 21.89
15 24.14
8 23.77
2 23.42
Output
5 22.88
3 23.00
13 21.99
14 22.86
24 21.89
20 22.23
17 22.51
12 22.91 | instruction | 0 | 46,958 | 17 | 93,916 |
"Correct Solution:
```
R = []
for _ in range(3):
L = []
for i in range(8):
p, t = input().split()
p = int(p)
t = float(t)
L.append((p,t))
L.sort(key=lambda x: x[1])
for i in [0, 1]:
print(*L[i])
R.extend(L[2:])
R.sort(key=lambda x: x[1])
for i in [0, 1]:
print(*R[i])
``` | output | 1 | 46,958 | 17 | 93,917 |
Provide a correct Python 3 solution for this coding contest problem.
The athletics competition 200M semi-final three races were held. Eight players (24 players in total) will participate in each group. A total of eight players, including the top two players in each group and the top two players from all the players in each group who are third or lower, will advance to the final.
Create a program that inputs the player numbers and times and outputs the numbers and times of the eight finalists.
Input
The input is given in the following format:
p1 t1
p2 t2
::
p24 t24
Lines 1-8, 1st set player number pi (integer, 1 ≤ pi ≤ 10000) and time ti (real number measured to 1/100, 1 ≤ ti ≤ 100), lines 9-16 Is given the player number pi and time ti of the second group, and the player number pi and time ti of the third group on the 17th to 24th lines. It is assumed that there are no players with the same player number or the same time.
Output
In the following order, please output the player numbers and times of the finalists on one line, separated by blanks.
1st place player in the 1st group
2nd place player in the 1st group
1st place player in the 2nd group
2nd place player in the 2nd group
1st place player in the 3rd group
Second place player in the third group
The player with the fastest time among the players who are 3rd or lower in each group
The player with the second fastest time among the players who are third or lower in each group
Example
Input
18 25.46
16 26.23
3 23.00
10 24.79
5 22.88
11 23.87
19 23.90
1 25.11
23 23.88
4 23.46
7 24.12
12 22.91
13 21.99
14 22.86
21 23.12
9 24.09
17 22.51
22 23.49
6 23.02
20 22.23
24 21.89
15 24.14
8 23.77
2 23.42
Output
5 22.88
3 23.00
13 21.99
14 22.86
24 21.89
20 22.23
17 22.51
12 22.91 | instruction | 0 | 46,959 | 17 | 93,918 |
"Correct Solution:
```
race1 = {}
for i in range(8):
p, t = input().split()
race1[int(p)] = float(t)
race2 = {}
for i in range(8):
p, t = input().split()
race2[int(p)] = float(t)
race3 = {}
for i in range(8):
p, t = input().split()
race3[int(p)] = float(t)
for p,t in sorted(race1.items(), key = lambda x: x[1])[:2]:
print(p,race1.pop(p))
for p,t in sorted(race2.items(), key = lambda x: x[1])[:2]:
print(p,race2.pop(p))
for p,t in sorted(race3.items(), key = lambda x: x[1])[:2]:
print(p,race3.pop(p))
race1.update(race2)
race1.update(race3)
for p,t in sorted(race1.items(), key = lambda x: x[1])[:2]:
print(p,race1.pop(p))
``` | output | 1 | 46,959 | 17 | 93,919 |
Provide a correct Python 3 solution for this coding contest problem.
The athletics competition 200M semi-final three races were held. Eight players (24 players in total) will participate in each group. A total of eight players, including the top two players in each group and the top two players from all the players in each group who are third or lower, will advance to the final.
Create a program that inputs the player numbers and times and outputs the numbers and times of the eight finalists.
Input
The input is given in the following format:
p1 t1
p2 t2
::
p24 t24
Lines 1-8, 1st set player number pi (integer, 1 ≤ pi ≤ 10000) and time ti (real number measured to 1/100, 1 ≤ ti ≤ 100), lines 9-16 Is given the player number pi and time ti of the second group, and the player number pi and time ti of the third group on the 17th to 24th lines. It is assumed that there are no players with the same player number or the same time.
Output
In the following order, please output the player numbers and times of the finalists on one line, separated by blanks.
1st place player in the 1st group
2nd place player in the 1st group
1st place player in the 2nd group
2nd place player in the 2nd group
1st place player in the 3rd group
Second place player in the third group
The player with the fastest time among the players who are 3rd or lower in each group
The player with the second fastest time among the players who are third or lower in each group
Example
Input
18 25.46
16 26.23
3 23.00
10 24.79
5 22.88
11 23.87
19 23.90
1 25.11
23 23.88
4 23.46
7 24.12
12 22.91
13 21.99
14 22.86
21 23.12
9 24.09
17 22.51
22 23.49
6 23.02
20 22.23
24 21.89
15 24.14
8 23.77
2 23.42
Output
5 22.88
3 23.00
13 21.99
14 22.86
24 21.89
20 22.23
17 22.51
12 22.91 | instruction | 0 | 46,960 | 17 | 93,920 |
"Correct Solution:
```
A_lis = []
for i in range(3):
S_lis = []
for j in range(8):
p,t = map(float,input().split())
S_lis.append([int(p),t])
S_lis = sorted(S_lis, key=lambda x: x[1])
print(S_lis[0][0],S_lis[0][1])
S_lis.remove(S_lis[0])
print(S_lis[0][0],S_lis[0][1])
S_lis.remove(S_lis[0])
A_lis += S_lis
A_lis = sorted(A_lis, key=lambda x: x[1])
print(A_lis[0][0],A_lis[0][1])
print(A_lis[1][0],A_lis[1][1])
``` | output | 1 | 46,960 | 17 | 93,921 |
Provide a correct Python 3 solution for this coding contest problem.
The athletics competition 200M semi-final three races were held. Eight players (24 players in total) will participate in each group. A total of eight players, including the top two players in each group and the top two players from all the players in each group who are third or lower, will advance to the final.
Create a program that inputs the player numbers and times and outputs the numbers and times of the eight finalists.
Input
The input is given in the following format:
p1 t1
p2 t2
::
p24 t24
Lines 1-8, 1st set player number pi (integer, 1 ≤ pi ≤ 10000) and time ti (real number measured to 1/100, 1 ≤ ti ≤ 100), lines 9-16 Is given the player number pi and time ti of the second group, and the player number pi and time ti of the third group on the 17th to 24th lines. It is assumed that there are no players with the same player number or the same time.
Output
In the following order, please output the player numbers and times of the finalists on one line, separated by blanks.
1st place player in the 1st group
2nd place player in the 1st group
1st place player in the 2nd group
2nd place player in the 2nd group
1st place player in the 3rd group
Second place player in the third group
The player with the fastest time among the players who are 3rd or lower in each group
The player with the second fastest time among the players who are third or lower in each group
Example
Input
18 25.46
16 26.23
3 23.00
10 24.79
5 22.88
11 23.87
19 23.90
1 25.11
23 23.88
4 23.46
7 24.12
12 22.91
13 21.99
14 22.86
21 23.12
9 24.09
17 22.51
22 23.49
6 23.02
20 22.23
24 21.89
15 24.14
8 23.77
2 23.42
Output
5 22.88
3 23.00
13 21.99
14 22.86
24 21.89
20 22.23
17 22.51
12 22.91 | instruction | 0 | 46,961 | 17 | 93,922 |
"Correct Solution:
```
l1,l2,l3=[],[],[]
final=[]
count=0
for i in range(24):
p,t=map(float,input().split())
if count<=7:l1.append([t,p])
elif 7<count<=15:l2.append([t,p])
elif 15<count<=23:l3.append([t,p])
count +=1
l1=sorted(l1)
l2=sorted(l2)
l3=sorted(l3)
final +=[l1[0],l1[1],l2[0],l2[1],l3[0],l3[1]]
del l1[0],l1[0],l2[0],l2[0],l3[0],l3[0]
third=sorted(l1+l2+l3)
final +=[third[0],third[1]]
for i in range(8):print(int(final[i][1]),final[i][0])
``` | output | 1 | 46,961 | 17 | 93,923 |
Provide a correct Python 3 solution for this coding contest problem.
The athletics competition 200M semi-final three races were held. Eight players (24 players in total) will participate in each group. A total of eight players, including the top two players in each group and the top two players from all the players in each group who are third or lower, will advance to the final.
Create a program that inputs the player numbers and times and outputs the numbers and times of the eight finalists.
Input
The input is given in the following format:
p1 t1
p2 t2
::
p24 t24
Lines 1-8, 1st set player number pi (integer, 1 ≤ pi ≤ 10000) and time ti (real number measured to 1/100, 1 ≤ ti ≤ 100), lines 9-16 Is given the player number pi and time ti of the second group, and the player number pi and time ti of the third group on the 17th to 24th lines. It is assumed that there are no players with the same player number or the same time.
Output
In the following order, please output the player numbers and times of the finalists on one line, separated by blanks.
1st place player in the 1st group
2nd place player in the 1st group
1st place player in the 2nd group
2nd place player in the 2nd group
1st place player in the 3rd group
Second place player in the third group
The player with the fastest time among the players who are 3rd or lower in each group
The player with the second fastest time among the players who are third or lower in each group
Example
Input
18 25.46
16 26.23
3 23.00
10 24.79
5 22.88
11 23.87
19 23.90
1 25.11
23 23.88
4 23.46
7 24.12
12 22.91
13 21.99
14 22.86
21 23.12
9 24.09
17 22.51
22 23.49
6 23.02
20 22.23
24 21.89
15 24.14
8 23.77
2 23.42
Output
5 22.88
3 23.00
13 21.99
14 22.86
24 21.89
20 22.23
17 22.51
12 22.91 | instruction | 0 | 46,962 | 17 | 93,924 |
"Correct Solution:
```
def inp():
return sorted([list(map(float, input().split())) for _ in range(8)], key=lambda x:x[1])
lst1 = inp()
lst2 = inp()
lst3 = inp()
rest = lst1[2:] + lst2[2:] + lst3[2:]
rest.sort(key=lambda x:x[1])
select = lst1[:2] + lst2[:2] + lst3[:2] + rest[:2]
for p, t in select:
print(int(p), t)
``` | output | 1 | 46,962 | 17 | 93,925 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.