message stringlengths 2 65.1k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 0 108k | cluster float64 14 14 | __index_level_0__ int64 0 217k |
|---|---|---|---|---|---|
Provide a correct Python 3 solution for this coding contest problem.
There are N rabbits, numbered 1 through N.
The i-th (1≤i≤N) rabbit likes rabbit a_i. Note that no rabbit can like itself, that is, a_i≠i.
For a pair of rabbits i and j (i＜j), we call the pair (i，j) a friendly pair if the following condition is met.
* Rabbit i likes rabbit j and rabbit j likes rabbit i.
Calculate the number of the friendly pairs.
Constraints
* 2≤N≤10^5
* 1≤a_i≤N
* a_i≠i
Input
The input is given from Standard Input in the following format:
N
a_1 a_2 ... a_N
Output
Print the number of the friendly pairs.
Examples
Input
4
2 1 4 3
Output
2
Input
3
2 3 1
Output
0
Input
5
5 5 5 5 1
Output
1 | instruction | 0 | 68,028 | 14 | 136,056 |
"Correct Solution:
```
n=int(input())
a=list(map(int,input().split()))
x=0
for i in range(n):
if i==a[a[i]-1]-1:x+=1
print(x//2)
``` | output | 1 | 68,028 | 14 | 136,057 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N rabbits, numbered 1 through N.
The i-th (1≤i≤N) rabbit likes rabbit a_i. Note that no rabbit can like itself, that is, a_i≠i.
For a pair of rabbits i and j (i＜j), we call the pair (i，j) a friendly pair if the following condition is met.
* Rabbit i likes rabbit j and rabbit j likes rabbit i.
Calculate the number of the friendly pairs.
Constraints
* 2≤N≤10^5
* 1≤a_i≤N
* a_i≠i
Input
The input is given from Standard Input in the following format:
N
a_1 a_2 ... a_N
Output
Print the number of the friendly pairs.
Examples
Input
4
2 1 4 3
Output
2
Input
3
2 3 1
Output
0
Input
5
5 5 5 5 1
Output
1
Submitted Solution:
```
N = int(input())
A = list(map(int, input().split()))
ans = 0
for i in range(N):
if i + 1 == A[A[i] - 1]:
ans += 1
print(ans // 2)
``` | instruction | 0 | 68,029 | 14 | 136,058 |
Yes | output | 1 | 68,029 | 14 | 136,059 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N rabbits, numbered 1 through N.
The i-th (1≤i≤N) rabbit likes rabbit a_i. Note that no rabbit can like itself, that is, a_i≠i.
For a pair of rabbits i and j (i＜j), we call the pair (i，j) a friendly pair if the following condition is met.
* Rabbit i likes rabbit j and rabbit j likes rabbit i.
Calculate the number of the friendly pairs.
Constraints
* 2≤N≤10^5
* 1≤a_i≤N
* a_i≠i
Input
The input is given from Standard Input in the following format:
N
a_1 a_2 ... a_N
Output
Print the number of the friendly pairs.
Examples
Input
4
2 1 4 3
Output
2
Input
3
2 3 1
Output
0
Input
5
5 5 5 5 1
Output
1
Submitted Solution:
```
n = int(input())
a = list(map(int,input().split()))
c = 0
for i in range(n):
if i == a[a[i]-1]-1:
c += 1
print(c//2)
``` | instruction | 0 | 68,030 | 14 | 136,060 |
Yes | output | 1 | 68,030 | 14 | 136,061 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N rabbits, numbered 1 through N.
The i-th (1≤i≤N) rabbit likes rabbit a_i. Note that no rabbit can like itself, that is, a_i≠i.
For a pair of rabbits i and j (i＜j), we call the pair (i，j) a friendly pair if the following condition is met.
* Rabbit i likes rabbit j and rabbit j likes rabbit i.
Calculate the number of the friendly pairs.
Constraints
* 2≤N≤10^5
* 1≤a_i≤N
* a_i≠i
Input
The input is given from Standard Input in the following format:
N
a_1 a_2 ... a_N
Output
Print the number of the friendly pairs.
Examples
Input
4
2 1 4 3
Output
2
Input
3
2 3 1
Output
0
Input
5
5 5 5 5 1
Output
1
Submitted Solution:
```
n,*a=map(int,open(0).read().split());print(sum(a[~-a[i]]==-~i for i in range(n))>>1)
``` | instruction | 0 | 68,031 | 14 | 136,062 |
Yes | output | 1 | 68,031 | 14 | 136,063 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N rabbits, numbered 1 through N.
The i-th (1≤i≤N) rabbit likes rabbit a_i. Note that no rabbit can like itself, that is, a_i≠i.
For a pair of rabbits i and j (i＜j), we call the pair (i，j) a friendly pair if the following condition is met.
* Rabbit i likes rabbit j and rabbit j likes rabbit i.
Calculate the number of the friendly pairs.
Constraints
* 2≤N≤10^5
* 1≤a_i≤N
* a_i≠i
Input
The input is given from Standard Input in the following format:
N
a_1 a_2 ... a_N
Output
Print the number of the friendly pairs.
Examples
Input
4
2 1 4 3
Output
2
Input
3
2 3 1
Output
0
Input
5
5 5 5 5 1
Output
1
Submitted Solution:
```
n,*a=map(int,open(0).read().split())
a=[0]+a
ans=0
for i in range(1,n+1):
if i==a[a[i]]:
ans+=1
print(ans//2)
``` | instruction | 0 | 68,032 | 14 | 136,064 |
Yes | output | 1 | 68,032 | 14 | 136,065 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N rabbits, numbered 1 through N.
The i-th (1≤i≤N) rabbit likes rabbit a_i. Note that no rabbit can like itself, that is, a_i≠i.
For a pair of rabbits i and j (i＜j), we call the pair (i，j) a friendly pair if the following condition is met.
* Rabbit i likes rabbit j and rabbit j likes rabbit i.
Calculate the number of the friendly pairs.
Constraints
* 2≤N≤10^5
* 1≤a_i≤N
* a_i≠i
Input
The input is given from Standard Input in the following format:
N
a_1 a_2 ... a_N
Output
Print the number of the friendly pairs.
Examples
Input
4
2 1 4 3
Output
2
Input
3
2 3 1
Output
0
Input
5
5 5 5 5 1
Output
1
Submitted Solution:
```
N = int(input())
A = [int(a) - 1 for a in input().split()]
count = 0
for i in range(N):
if i == A[A[i]]:
count += 1
print(count)
``` | instruction | 0 | 68,033 | 14 | 136,066 |
No | output | 1 | 68,033 | 14 | 136,067 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N rabbits, numbered 1 through N.
The i-th (1≤i≤N) rabbit likes rabbit a_i. Note that no rabbit can like itself, that is, a_i≠i.
For a pair of rabbits i and j (i＜j), we call the pair (i，j) a friendly pair if the following condition is met.
* Rabbit i likes rabbit j and rabbit j likes rabbit i.
Calculate the number of the friendly pairs.
Constraints
* 2≤N≤10^5
* 1≤a_i≤N
* a_i≠i
Input
The input is given from Standard Input in the following format:
N
a_1 a_2 ... a_N
Output
Print the number of the friendly pairs.
Examples
Input
4
2 1 4 3
Output
2
Input
3
2 3 1
Output
0
Input
5
5 5 5 5 1
Output
1
Submitted Solution:
```
N = int(input())
a = list(map(int, input().split()))
ans=0
if N%2==0:
for i in range(N//2):
if a[a[i]-1]==i+1:
ans += 1
else:
for i in range(N//2 +1):
if a[a[i]-1]==i+1:
ans+=1
print(ans)
``` | instruction | 0 | 68,034 | 14 | 136,068 |
No | output | 1 | 68,034 | 14 | 136,069 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N rabbits, numbered 1 through N.
The i-th (1≤i≤N) rabbit likes rabbit a_i. Note that no rabbit can like itself, that is, a_i≠i.
For a pair of rabbits i and j (i＜j), we call the pair (i，j) a friendly pair if the following condition is met.
* Rabbit i likes rabbit j and rabbit j likes rabbit i.
Calculate the number of the friendly pairs.
Constraints
* 2≤N≤10^5
* 1≤a_i≤N
* a_i≠i
Input
The input is given from Standard Input in the following format:
N
a_1 a_2 ... a_N
Output
Print the number of the friendly pairs.
Examples
Input
4
2 1 4 3
Output
2
Input
3
2 3 1
Output
0
Input
5
5 5 5 5 1
Output
1
Submitted Solution:
```
# -*- coding: utf-8 -*-
# !/usr/bin/env python
# vim: set fileencoding=utf-8 :
"""
#
# Author: Noname
# URL: https://github.com/pettan0818
# License: MIT License
# Created: 2016-09-28
#
# Usage
#
"""
import sys
def input_single_line():
"""Receive Inputs."""
return input()
def input_two_line():
"""Receive Two Lined Inputs.
Like this.
N
1 2 3 4 5
"""
sys.stdin.readline()
target = sys.stdin.readline()
target = target.rstrip("\n")
target = target.split(" ")
return target
def search_lovers(target_list: list) -> None:
"""Search Simple."""
lovers = []
for i in target_list:
if target_list[i-1] == i-1:
lovers.append(i-1)
print(len(lovers))
if __name__ == "__main__":
import doctest
doctest.testmod()
target = input_two_line()
search_lovers(target)
``` | instruction | 0 | 68,035 | 14 | 136,070 |
No | output | 1 | 68,035 | 14 | 136,071 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N rabbits, numbered 1 through N.
The i-th (1≤i≤N) rabbit likes rabbit a_i. Note that no rabbit can like itself, that is, a_i≠i.
For a pair of rabbits i and j (i＜j), we call the pair (i，j) a friendly pair if the following condition is met.
* Rabbit i likes rabbit j and rabbit j likes rabbit i.
Calculate the number of the friendly pairs.
Constraints
* 2≤N≤10^5
* 1≤a_i≤N
* a_i≠i
Input
The input is given from Standard Input in the following format:
N
a_1 a_2 ... a_N
Output
Print the number of the friendly pairs.
Examples
Input
4
2 1 4 3
Output
2
Input
3
2 3 1
Output
0
Input
5
5 5 5 5 1
Output
1
Submitted Solution:
```
n = int(input())
l = [False] * n
inputList = list(map(int, input().split()))
pairs = 0
for i in range(n):
if l[i]:
continue
x = inputList[i]-1
if inputList[x]-1 == i:
pairs += 1
l[x] = True
print(pairs)
``` | instruction | 0 | 68,036 | 14 | 136,072 |
No | output | 1 | 68,036 | 14 | 136,073 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n Christmas trees on an infinite number line. The i-th tree grows at the position x_i. All x_i are guaranteed to be distinct.
Each integer point can be either occupied by the Christmas tree, by the human or not occupied at all. Non-integer points cannot be occupied by anything.
There are m people who want to celebrate Christmas. Let y_1, y_2, ..., y_m be the positions of people (note that all values x_1, x_2, ..., x_n, y_1, y_2, ..., y_m should be distinct and all y_j should be integer). You want to find such an arrangement of people that the value ∑_{j=1}^{m}min_{i=1}^{n}|x_i - y_j| is the minimum possible (in other words, the sum of distances to the nearest Christmas tree for all people should be minimized).
In other words, let d_j be the distance from the j-th human to the nearest Christmas tree (d_j = min_{i=1}^{n} |y_j - x_i|). Then you need to choose such positions y_1, y_2, ..., y_m that ∑_{j=1}^{m} d_j is the minimum possible.
Input
The first line of the input contains two integers n and m (1 ≤ n, m ≤ 2 ⋅ 10^5) — the number of Christmas trees and the number of people.
The second line of the input contains n integers x_1, x_2, ..., x_n (-10^9 ≤ x_i ≤ 10^9), where x_i is the position of the i-th Christmas tree. It is guaranteed that all x_i are distinct.
Output
In the first line print one integer res — the minimum possible value of ∑_{j=1}^{m}min_{i=1}^{n}|x_i - y_j| (in other words, the sum of distances to the nearest Christmas tree for all people).
In the second line print m integers y_1, y_2, ..., y_m (-2 ⋅ 10^9 ≤ y_j ≤ 2 ⋅ 10^9), where y_j is the position of the j-th human. All y_j should be distinct and all values x_1, x_2, ..., x_n, y_1, y_2, ..., y_m should be distinct.
If there are multiple answers, print any of them.
Examples
Input
2 6
1 5
Output
8
-1 2 6 4 0 3
Input
3 5
0 3 1
Output
7
5 -2 4 -1 2 | instruction | 0 | 68,262 | 14 | 136,524 |
Tags: graphs, greedy, shortest paths
Correct Solution:
```
import sys
import collections
from collections import Counter, deque
import itertools
import math
import timeit
#########################
# imgur.com/Pkt7iIf.png #
#########################
def sieve(n):
if n < 2: return list()
prime = [True for _ in range(n + 1)]
p = 3
while p * p <= n:
if prime[p]:
for i in range(p * 2, n + 1, p):
prime[i] = False
p += 2
r = [2]
for p in range(3, n + 1, 2):
if prime[p]:
r.append(p)
return r
def divs(n, start=1):
divisors = []
for i in range(start, int(math.sqrt(n) + 1)):
if n % i == 0:
if n / i == i:
divisors.append(i)
else:
divisors.extend([i, n // i])
return divisors
def divn(n, primes):
divs_number = 1
for i in primes:
if n == 1:
return divs_number
t = 1
while n % i == 0:
t += 1
n //= i
divs_number *= t
def flin(d, x, default=-1):
left = right = -1
for i in range(len(d)):
if d[i] == x:
if left == -1: left = i
right = i
if left == -1:
return (default, default)
else:
return (left, right)
def ceil(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 prr(a, sep=' '): print(sep.join(map(str, a)))
def dd(): return collections.defaultdict(int)
def ddl(): return collections.defaultdict(list)
# input = sys.stdin.readline
t = 1
for _ in range(t):
n, k = mi()
d = li()
used = set(d)
left = d[:]
right = d[:]
res = []
s = 0
c = 1
while len(res) < k:
nl = []
nr = []
j = 0
while len(res) < k and j < len(left):
if left[j] - 1 not in used:
s += c
res.append(left[j] - 1)
used.add(left[j] - 1)
nl.append(left[j] - 1)
j += 1
j = 0
while len(res) < k and j < len(right):
if right[j] + 1 not in used:
s += c
res.append(right[j] + 1)
used.add(right[j] + 1)
nr.append(right[j] + 1)
j += 1
left = nl
right = nr
c += 1
print(s)
prr(res)
``` | output | 1 | 68,262 | 14 | 136,525 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n Christmas trees on an infinite number line. The i-th tree grows at the position x_i. All x_i are guaranteed to be distinct.
Each integer point can be either occupied by the Christmas tree, by the human or not occupied at all. Non-integer points cannot be occupied by anything.
There are m people who want to celebrate Christmas. Let y_1, y_2, ..., y_m be the positions of people (note that all values x_1, x_2, ..., x_n, y_1, y_2, ..., y_m should be distinct and all y_j should be integer). You want to find such an arrangement of people that the value ∑_{j=1}^{m}min_{i=1}^{n}|x_i - y_j| is the minimum possible (in other words, the sum of distances to the nearest Christmas tree for all people should be minimized).
In other words, let d_j be the distance from the j-th human to the nearest Christmas tree (d_j = min_{i=1}^{n} |y_j - x_i|). Then you need to choose such positions y_1, y_2, ..., y_m that ∑_{j=1}^{m} d_j is the minimum possible.
Input
The first line of the input contains two integers n and m (1 ≤ n, m ≤ 2 ⋅ 10^5) — the number of Christmas trees and the number of people.
The second line of the input contains n integers x_1, x_2, ..., x_n (-10^9 ≤ x_i ≤ 10^9), where x_i is the position of the i-th Christmas tree. It is guaranteed that all x_i are distinct.
Output
In the first line print one integer res — the minimum possible value of ∑_{j=1}^{m}min_{i=1}^{n}|x_i - y_j| (in other words, the sum of distances to the nearest Christmas tree for all people).
In the second line print m integers y_1, y_2, ..., y_m (-2 ⋅ 10^9 ≤ y_j ≤ 2 ⋅ 10^9), where y_j is the position of the j-th human. All y_j should be distinct and all values x_1, x_2, ..., x_n, y_1, y_2, ..., y_m should be distinct.
If there are multiple answers, print any of them.
Examples
Input
2 6
1 5
Output
8
-1 2 6 4 0 3
Input
3 5
0 3 1
Output
7
5 -2 4 -1 2 | instruction | 0 | 68,263 | 14 | 136,526 |
Tags: graphs, greedy, shortest paths
Correct Solution:
```
'''Author- Akshit Monga'''
from sys import stdin, stdout
input = stdin.readline
from collections import deque
t = 1
for _ in range(t):
n,m=map(int,input().split())
arr=[int(x) for x in input().split()]
ans=0
mans=[]
taken=deque(arr.copy())
d={}
for i in taken:
d[i]=0
while m:
val=taken.popleft()
if d[val]:
ans+=d[val]
m-=1
mans.append(val)
if val+1 not in d:
d[val+1]=d[val]+1
taken.append(val+1)
if val-1 not in d:
d[val-1]=d[val]+1
taken.append(val-1)
print(ans)
print(*mans)
``` | output | 1 | 68,263 | 14 | 136,527 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n Christmas trees on an infinite number line. The i-th tree grows at the position x_i. All x_i are guaranteed to be distinct.
Each integer point can be either occupied by the Christmas tree, by the human or not occupied at all. Non-integer points cannot be occupied by anything.
There are m people who want to celebrate Christmas. Let y_1, y_2, ..., y_m be the positions of people (note that all values x_1, x_2, ..., x_n, y_1, y_2, ..., y_m should be distinct and all y_j should be integer). You want to find such an arrangement of people that the value ∑_{j=1}^{m}min_{i=1}^{n}|x_i - y_j| is the minimum possible (in other words, the sum of distances to the nearest Christmas tree for all people should be minimized).
In other words, let d_j be the distance from the j-th human to the nearest Christmas tree (d_j = min_{i=1}^{n} |y_j - x_i|). Then you need to choose such positions y_1, y_2, ..., y_m that ∑_{j=1}^{m} d_j is the minimum possible.
Input
The first line of the input contains two integers n and m (1 ≤ n, m ≤ 2 ⋅ 10^5) — the number of Christmas trees and the number of people.
The second line of the input contains n integers x_1, x_2, ..., x_n (-10^9 ≤ x_i ≤ 10^9), where x_i is the position of the i-th Christmas tree. It is guaranteed that all x_i are distinct.
Output
In the first line print one integer res — the minimum possible value of ∑_{j=1}^{m}min_{i=1}^{n}|x_i - y_j| (in other words, the sum of distances to the nearest Christmas tree for all people).
In the second line print m integers y_1, y_2, ..., y_m (-2 ⋅ 10^9 ≤ y_j ≤ 2 ⋅ 10^9), where y_j is the position of the j-th human. All y_j should be distinct and all values x_1, x_2, ..., x_n, y_1, y_2, ..., y_m should be distinct.
If there are multiple answers, print any of them.
Examples
Input
2 6
1 5
Output
8
-1 2 6 4 0 3
Input
3 5
0 3 1
Output
7
5 -2 4 -1 2 | instruction | 0 | 68,264 | 14 | 136,528 |
Tags: graphs, greedy, shortest paths
Correct Solution:
```
from collections import deque
bfs_queue = deque()
n, m = map(int, input().split())
y = {}
ans = 0
anses = []
def bfs():
global m, ans
while len(bfs_queue):
if m <= 0:
break
f = bfs_queue.popleft()
if y.get(f) == 0:
if y.get(f+1) is None:
bfs_queue.append(f+1)
y[f+1] = y[f]+1
if y.get(f-1) is None:
bfs_queue.append(f-1)
y[f-1] = y[f]+1
else:
m -= 1
ans += y[f]
if y.get(f+1) is None:
bfs_queue.append(f+1)
y[f+1] = y[f]+1
if y.get(f-1) is None:
bfs_queue.append(f-1)
y[f-1] = y[f]+1
anses.append(f)
for i in map(int, input().split()):
bfs_queue.append(i)
y[i] = 0
bfs()
print(ans)
print(*anses)
``` | output | 1 | 68,264 | 14 | 136,529 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n Christmas trees on an infinite number line. The i-th tree grows at the position x_i. All x_i are guaranteed to be distinct.
Each integer point can be either occupied by the Christmas tree, by the human or not occupied at all. Non-integer points cannot be occupied by anything.
There are m people who want to celebrate Christmas. Let y_1, y_2, ..., y_m be the positions of people (note that all values x_1, x_2, ..., x_n, y_1, y_2, ..., y_m should be distinct and all y_j should be integer). You want to find such an arrangement of people that the value ∑_{j=1}^{m}min_{i=1}^{n}|x_i - y_j| is the minimum possible (in other words, the sum of distances to the nearest Christmas tree for all people should be minimized).
In other words, let d_j be the distance from the j-th human to the nearest Christmas tree (d_j = min_{i=1}^{n} |y_j - x_i|). Then you need to choose such positions y_1, y_2, ..., y_m that ∑_{j=1}^{m} d_j is the minimum possible.
Input
The first line of the input contains two integers n and m (1 ≤ n, m ≤ 2 ⋅ 10^5) — the number of Christmas trees and the number of people.
The second line of the input contains n integers x_1, x_2, ..., x_n (-10^9 ≤ x_i ≤ 10^9), where x_i is the position of the i-th Christmas tree. It is guaranteed that all x_i are distinct.
Output
In the first line print one integer res — the minimum possible value of ∑_{j=1}^{m}min_{i=1}^{n}|x_i - y_j| (in other words, the sum of distances to the nearest Christmas tree for all people).
In the second line print m integers y_1, y_2, ..., y_m (-2 ⋅ 10^9 ≤ y_j ≤ 2 ⋅ 10^9), where y_j is the position of the j-th human. All y_j should be distinct and all values x_1, x_2, ..., x_n, y_1, y_2, ..., y_m should be distinct.
If there are multiple answers, print any of them.
Examples
Input
2 6
1 5
Output
8
-1 2 6 4 0 3
Input
3 5
0 3 1
Output
7
5 -2 4 -1 2 | instruction | 0 | 68,265 | 14 | 136,530 |
Tags: graphs, greedy, shortest paths
Correct Solution:
```
n,m=[int(x) for x in input().split()]
a=list(sorted([int(x) for x in input().split()]))
b=[a[i]-a[i-1]-1 for i in range(1,n)]
c=set()
for i in range(n-1):
if b[i]!=0:
c.add(i)
res=[]
su=0
x=1
while m!=0:
if m>2:
res.extend([a[0]-x,a[-1]+x])
su+=2*x
m-=2
tmp=set()
for i in c:
if m>1:
if b[i]>2:
m-=2
b[i]-=2
su+=2*x
tmp.add(i)
res.extend([a[i]+x,a[i+1]-x])
elif b[i]==2:
m-=2
su+=2*x
b[i]=0
res.extend([a[i]+x,a[i+1]-x])
else:
m-=1
su+=x
b[i]=0
res.append(a[i]+x)
else:
m=0
res.append(a[i]+x)
su+=x
if m==0:
break
if m==0:
continue
c=tmp|set()
elif m==2:
res.extend([a[0]-x,a[-1]+x])
m=0
su+=2*x
else:
res.append(a[0]-x)
m=0
su+=x
x+=1
print(su)
print(*res)
``` | output | 1 | 68,265 | 14 | 136,531 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n Christmas trees on an infinite number line. The i-th tree grows at the position x_i. All x_i are guaranteed to be distinct.
Each integer point can be either occupied by the Christmas tree, by the human or not occupied at all. Non-integer points cannot be occupied by anything.
There are m people who want to celebrate Christmas. Let y_1, y_2, ..., y_m be the positions of people (note that all values x_1, x_2, ..., x_n, y_1, y_2, ..., y_m should be distinct and all y_j should be integer). You want to find such an arrangement of people that the value ∑_{j=1}^{m}min_{i=1}^{n}|x_i - y_j| is the minimum possible (in other words, the sum of distances to the nearest Christmas tree for all people should be minimized).
In other words, let d_j be the distance from the j-th human to the nearest Christmas tree (d_j = min_{i=1}^{n} |y_j - x_i|). Then you need to choose such positions y_1, y_2, ..., y_m that ∑_{j=1}^{m} d_j is the minimum possible.
Input
The first line of the input contains two integers n and m (1 ≤ n, m ≤ 2 ⋅ 10^5) — the number of Christmas trees and the number of people.
The second line of the input contains n integers x_1, x_2, ..., x_n (-10^9 ≤ x_i ≤ 10^9), where x_i is the position of the i-th Christmas tree. It is guaranteed that all x_i are distinct.
Output
In the first line print one integer res — the minimum possible value of ∑_{j=1}^{m}min_{i=1}^{n}|x_i - y_j| (in other words, the sum of distances to the nearest Christmas tree for all people).
In the second line print m integers y_1, y_2, ..., y_m (-2 ⋅ 10^9 ≤ y_j ≤ 2 ⋅ 10^9), where y_j is the position of the j-th human. All y_j should be distinct and all values x_1, x_2, ..., x_n, y_1, y_2, ..., y_m should be distinct.
If there are multiple answers, print any of them.
Examples
Input
2 6
1 5
Output
8
-1 2 6 4 0 3
Input
3 5
0 3 1
Output
7
5 -2 4 -1 2 | instruction | 0 | 68,266 | 14 | 136,532 |
Tags: graphs, greedy, shortest paths
Correct Solution:
```
def oneLineArrayPrint(arr):
print(' '.join([str(x) for x in arr]))
from queue import deque
n,m=[int(x) for x in input().split()]
a=[int(z) for z in input().split()]
occupiedPositions=set()
for x in a:
occupiedPositions.add(x) #all trees
ans=[]
positionQ=deque() #store [position,distance from nearest XMas Tree]
a.sort()
for i in range(n):
if a[i]-1 not in occupiedPositions: #all space on the left and right of trees (if not already occupied)
positionQ.append([a[i]-1,1])
occupiedPositions.add(a[i]-1)
if a[i]+1 not in occupiedPositions:
positionQ.append([a[i]+1,1])
occupiedPositions.add(a[i]+1)
totalDistance=0
while len(ans)<m:
pos,dis=positionQ.popleft()
totalDistance+=dis
ans.append(pos)
if pos-1 not in occupiedPositions:
occupiedPositions.add(pos-1)
positionQ.append([pos-1,dis+1])
if pos+1 not in occupiedPositions:
occupiedPositions.add(pos+1)
positionQ.append([pos+1,dis+1])
# print('pos:{} occupied:{} queue:{}'.format(pos,occupiedPositions,positionQ))
print(totalDistance)
oneLineArrayPrint(ans)
``` | output | 1 | 68,266 | 14 | 136,533 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n Christmas trees on an infinite number line. The i-th tree grows at the position x_i. All x_i are guaranteed to be distinct.
Each integer point can be either occupied by the Christmas tree, by the human or not occupied at all. Non-integer points cannot be occupied by anything.
There are m people who want to celebrate Christmas. Let y_1, y_2, ..., y_m be the positions of people (note that all values x_1, x_2, ..., x_n, y_1, y_2, ..., y_m should be distinct and all y_j should be integer). You want to find such an arrangement of people that the value ∑_{j=1}^{m}min_{i=1}^{n}|x_i - y_j| is the minimum possible (in other words, the sum of distances to the nearest Christmas tree for all people should be minimized).
In other words, let d_j be the distance from the j-th human to the nearest Christmas tree (d_j = min_{i=1}^{n} |y_j - x_i|). Then you need to choose such positions y_1, y_2, ..., y_m that ∑_{j=1}^{m} d_j is the minimum possible.
Input
The first line of the input contains two integers n and m (1 ≤ n, m ≤ 2 ⋅ 10^5) — the number of Christmas trees and the number of people.
The second line of the input contains n integers x_1, x_2, ..., x_n (-10^9 ≤ x_i ≤ 10^9), where x_i is the position of the i-th Christmas tree. It is guaranteed that all x_i are distinct.
Output
In the first line print one integer res — the minimum possible value of ∑_{j=1}^{m}min_{i=1}^{n}|x_i - y_j| (in other words, the sum of distances to the nearest Christmas tree for all people).
In the second line print m integers y_1, y_2, ..., y_m (-2 ⋅ 10^9 ≤ y_j ≤ 2 ⋅ 10^9), where y_j is the position of the j-th human. All y_j should be distinct and all values x_1, x_2, ..., x_n, y_1, y_2, ..., y_m should be distinct.
If there are multiple answers, print any of them.
Examples
Input
2 6
1 5
Output
8
-1 2 6 4 0 3
Input
3 5
0 3 1
Output
7
5 -2 4 -1 2 | instruction | 0 | 68,267 | 14 | 136,534 |
Tags: graphs, greedy, shortest paths
Correct Solution:
```
import sys
#556940
def binsearch(val, mas):
left = -1
right = len(mas) - 1
while right > left + 1:
mid = (right + left) // 2
if mas[mid] < val:
left = mid
else:
right = mid
try:
return min(abs(mas[left] - val), abs(mas[right] - val))
except IndexError:
return abs(mas[right] - val)
n, m = map(int, input().split())
x = [int(i) for i in sys.stdin.readline().split()]
isx = x.copy()
isx.sort()
sx = set(x)
sum = 0
a = []
while len(a) < m:
for i in x:
if i+1 not in sx:
a.append((binsearch(i + 1, isx), i + 1))
sum += (a[len(a) - 1][0])
sx.add(i+1)
x.append(i+1)
if len(a) == m:
break
if i - 1 not in sx:
a.append((binsearch(i -1, isx), i -1))
sx.add(i - 1)
sum += (a[len(a) - 1][0])
x.append(i - 1)
if len(a) == m:
break
print(sum)
for i in range(m):
sys.stdout.write(str(a[i][1]) + " ")
``` | output | 1 | 68,267 | 14 | 136,535 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n Christmas trees on an infinite number line. The i-th tree grows at the position x_i. All x_i are guaranteed to be distinct.
Each integer point can be either occupied by the Christmas tree, by the human or not occupied at all. Non-integer points cannot be occupied by anything.
There are m people who want to celebrate Christmas. Let y_1, y_2, ..., y_m be the positions of people (note that all values x_1, x_2, ..., x_n, y_1, y_2, ..., y_m should be distinct and all y_j should be integer). You want to find such an arrangement of people that the value ∑_{j=1}^{m}min_{i=1}^{n}|x_i - y_j| is the minimum possible (in other words, the sum of distances to the nearest Christmas tree for all people should be minimized).
In other words, let d_j be the distance from the j-th human to the nearest Christmas tree (d_j = min_{i=1}^{n} |y_j - x_i|). Then you need to choose such positions y_1, y_2, ..., y_m that ∑_{j=1}^{m} d_j is the minimum possible.
Input
The first line of the input contains two integers n and m (1 ≤ n, m ≤ 2 ⋅ 10^5) — the number of Christmas trees and the number of people.
The second line of the input contains n integers x_1, x_2, ..., x_n (-10^9 ≤ x_i ≤ 10^9), where x_i is the position of the i-th Christmas tree. It is guaranteed that all x_i are distinct.
Output
In the first line print one integer res — the minimum possible value of ∑_{j=1}^{m}min_{i=1}^{n}|x_i - y_j| (in other words, the sum of distances to the nearest Christmas tree for all people).
In the second line print m integers y_1, y_2, ..., y_m (-2 ⋅ 10^9 ≤ y_j ≤ 2 ⋅ 10^9), where y_j is the position of the j-th human. All y_j should be distinct and all values x_1, x_2, ..., x_n, y_1, y_2, ..., y_m should be distinct.
If there are multiple answers, print any of them.
Examples
Input
2 6
1 5
Output
8
-1 2 6 4 0 3
Input
3 5
0 3 1
Output
7
5 -2 4 -1 2 | instruction | 0 | 68,268 | 14 | 136,536 |
Tags: graphs, greedy, shortest paths
Correct Solution:
```
n,m=map(int,input().strip().split())
arr=list(map(int,input().strip().split()))
d={}
q=[]
for i in arr:
d[i]=0
q.append(i)
ans=[]
v=0
index=0
while(len(ans)!=m):
x=q[index]
if x-1 not in d :
d[x-1]=d[x]+1
ans.append(x-1)
q.append(x-1)
v=v+d[x-1]
if len(ans)==m :
break
if x+1 not in d :
d[x+1]=d[x]+1
ans.append(x+1)
q.append(x+1)
v=v+d[x+1]
index=index+1
print(v)
print(*ans)
``` | output | 1 | 68,268 | 14 | 136,537 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n Christmas trees on an infinite number line. The i-th tree grows at the position x_i. All x_i are guaranteed to be distinct.
Each integer point can be either occupied by the Christmas tree, by the human or not occupied at all. Non-integer points cannot be occupied by anything.
There are m people who want to celebrate Christmas. Let y_1, y_2, ..., y_m be the positions of people (note that all values x_1, x_2, ..., x_n, y_1, y_2, ..., y_m should be distinct and all y_j should be integer). You want to find such an arrangement of people that the value ∑_{j=1}^{m}min_{i=1}^{n}|x_i - y_j| is the minimum possible (in other words, the sum of distances to the nearest Christmas tree for all people should be minimized).
In other words, let d_j be the distance from the j-th human to the nearest Christmas tree (d_j = min_{i=1}^{n} |y_j - x_i|). Then you need to choose such positions y_1, y_2, ..., y_m that ∑_{j=1}^{m} d_j is the minimum possible.
Input
The first line of the input contains two integers n and m (1 ≤ n, m ≤ 2 ⋅ 10^5) — the number of Christmas trees and the number of people.
The second line of the input contains n integers x_1, x_2, ..., x_n (-10^9 ≤ x_i ≤ 10^9), where x_i is the position of the i-th Christmas tree. It is guaranteed that all x_i are distinct.
Output
In the first line print one integer res — the minimum possible value of ∑_{j=1}^{m}min_{i=1}^{n}|x_i - y_j| (in other words, the sum of distances to the nearest Christmas tree for all people).
In the second line print m integers y_1, y_2, ..., y_m (-2 ⋅ 10^9 ≤ y_j ≤ 2 ⋅ 10^9), where y_j is the position of the j-th human. All y_j should be distinct and all values x_1, x_2, ..., x_n, y_1, y_2, ..., y_m should be distinct.
If there are multiple answers, print any of them.
Examples
Input
2 6
1 5
Output
8
-1 2 6 4 0 3
Input
3 5
0 3 1
Output
7
5 -2 4 -1 2 | instruction | 0 | 68,269 | 14 | 136,538 |
Tags: graphs, greedy, shortest paths
Correct Solution:
```
po, men = map(int, input().split())
a = {int(i) for i in input().split()}
f = {*a}
r = set()
k = 1
s = 0
while len(r) < men:
b = set()
for i in a:
for p in -1, 1:
if i + p*k not in f:
if len(r) < men:
s += abs(p*k)
r.add(i + p*k)
f.add(i + p*k)
b.add(i)
if len(r) == men:
break
if len(r) == men:
break
k += 1
a = b
print(s)
print(*r)
``` | output | 1 | 68,269 | 14 | 136,539 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n Christmas trees on an infinite number line. The i-th tree grows at the position x_i. All x_i are guaranteed to be distinct.
Each integer point can be either occupied by the Christmas tree, by the human or not occupied at all. Non-integer points cannot be occupied by anything.
There are m people who want to celebrate Christmas. Let y_1, y_2, ..., y_m be the positions of people (note that all values x_1, x_2, ..., x_n, y_1, y_2, ..., y_m should be distinct and all y_j should be integer). You want to find such an arrangement of people that the value ∑_{j=1}^{m}min_{i=1}^{n}|x_i - y_j| is the minimum possible (in other words, the sum of distances to the nearest Christmas tree for all people should be minimized).
In other words, let d_j be the distance from the j-th human to the nearest Christmas tree (d_j = min_{i=1}^{n} |y_j - x_i|). Then you need to choose such positions y_1, y_2, ..., y_m that ∑_{j=1}^{m} d_j is the minimum possible.
Input
The first line of the input contains two integers n and m (1 ≤ n, m ≤ 2 ⋅ 10^5) — the number of Christmas trees and the number of people.
The second line of the input contains n integers x_1, x_2, ..., x_n (-10^9 ≤ x_i ≤ 10^9), where x_i is the position of the i-th Christmas tree. It is guaranteed that all x_i are distinct.
Output
In the first line print one integer res — the minimum possible value of ∑_{j=1}^{m}min_{i=1}^{n}|x_i - y_j| (in other words, the sum of distances to the nearest Christmas tree for all people).
In the second line print m integers y_1, y_2, ..., y_m (-2 ⋅ 10^9 ≤ y_j ≤ 2 ⋅ 10^9), where y_j is the position of the j-th human. All y_j should be distinct and all values x_1, x_2, ..., x_n, y_1, y_2, ..., y_m should be distinct.
If there are multiple answers, print any of them.
Examples
Input
2 6
1 5
Output
8
-1 2 6 4 0 3
Input
3 5
0 3 1
Output
7
5 -2 4 -1 2
Submitted Solution:
```
n, m = map(int, input().split())
x = list(map(int, input().split()))
visited = set(x)
y = []
frontier = x
i = 0
ans = 0
numFolks = 0
while numFolks < m:
next = []
for u in frontier:
if i > 0:
ans += i
numFolks += 1
y.append(u)
if numFolks == m:
break
if u-1 not in visited:
next.append(u-1)
visited.add(u-1)
if u+1 not in visited:
next.append(u+1)
visited.add(u+1)
i += 1
frontier = next
print(ans)
for p in y:
print(p, end=' ')
``` | instruction | 0 | 68,270 | 14 | 136,540 |
Yes | output | 1 | 68,270 | 14 | 136,541 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n Christmas trees on an infinite number line. The i-th tree grows at the position x_i. All x_i are guaranteed to be distinct.
Each integer point can be either occupied by the Christmas tree, by the human or not occupied at all. Non-integer points cannot be occupied by anything.
There are m people who want to celebrate Christmas. Let y_1, y_2, ..., y_m be the positions of people (note that all values x_1, x_2, ..., x_n, y_1, y_2, ..., y_m should be distinct and all y_j should be integer). You want to find such an arrangement of people that the value ∑_{j=1}^{m}min_{i=1}^{n}|x_i - y_j| is the minimum possible (in other words, the sum of distances to the nearest Christmas tree for all people should be minimized).
In other words, let d_j be the distance from the j-th human to the nearest Christmas tree (d_j = min_{i=1}^{n} |y_j - x_i|). Then you need to choose such positions y_1, y_2, ..., y_m that ∑_{j=1}^{m} d_j is the minimum possible.
Input
The first line of the input contains two integers n and m (1 ≤ n, m ≤ 2 ⋅ 10^5) — the number of Christmas trees and the number of people.
The second line of the input contains n integers x_1, x_2, ..., x_n (-10^9 ≤ x_i ≤ 10^9), where x_i is the position of the i-th Christmas tree. It is guaranteed that all x_i are distinct.
Output
In the first line print one integer res — the minimum possible value of ∑_{j=1}^{m}min_{i=1}^{n}|x_i - y_j| (in other words, the sum of distances to the nearest Christmas tree for all people).
In the second line print m integers y_1, y_2, ..., y_m (-2 ⋅ 10^9 ≤ y_j ≤ 2 ⋅ 10^9), where y_j is the position of the j-th human. All y_j should be distinct and all values x_1, x_2, ..., x_n, y_1, y_2, ..., y_m should be distinct.
If there are multiple answers, print any of them.
Examples
Input
2 6
1 5
Output
8
-1 2 6 4 0 3
Input
3 5
0 3 1
Output
7
5 -2 4 -1 2
Submitted Solution:
```
from collections import deque
def solve():
input_str = input().split()
n = int(input_str[0])
m = int(input_str[1])
pos = input().split()
seen = set([int(x) for x in pos])
queue = deque([int(x) for x in pos])
total_dist = 0
cur_dist = 0
ans = []
exitf = False
while queue:
for i in range(len(queue)):
cur = queue.popleft()
if (cur_dist > 0):
total_dist += cur_dist
ans.append(cur)
if len(ans) == m:
exitf = True
break
if cur - 1 not in seen:
seen.add(cur - 1)
queue.append(cur - 1)
if cur + 1 not in seen:
seen.add(cur + 1)
queue.append(cur + 1)
cur_dist += 1
if exitf == True:
break
print(total_dist)
for i in range(m):
print(ans[i], end=" ")
return 0
solve()
``` | instruction | 0 | 68,271 | 14 | 136,542 |
Yes | output | 1 | 68,271 | 14 | 136,543 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n Christmas trees on an infinite number line. The i-th tree grows at the position x_i. All x_i are guaranteed to be distinct.
Each integer point can be either occupied by the Christmas tree, by the human or not occupied at all. Non-integer points cannot be occupied by anything.
There are m people who want to celebrate Christmas. Let y_1, y_2, ..., y_m be the positions of people (note that all values x_1, x_2, ..., x_n, y_1, y_2, ..., y_m should be distinct and all y_j should be integer). You want to find such an arrangement of people that the value ∑_{j=1}^{m}min_{i=1}^{n}|x_i - y_j| is the minimum possible (in other words, the sum of distances to the nearest Christmas tree for all people should be minimized).
In other words, let d_j be the distance from the j-th human to the nearest Christmas tree (d_j = min_{i=1}^{n} |y_j - x_i|). Then you need to choose such positions y_1, y_2, ..., y_m that ∑_{j=1}^{m} d_j is the minimum possible.
Input
The first line of the input contains two integers n and m (1 ≤ n, m ≤ 2 ⋅ 10^5) — the number of Christmas trees and the number of people.
The second line of the input contains n integers x_1, x_2, ..., x_n (-10^9 ≤ x_i ≤ 10^9), where x_i is the position of the i-th Christmas tree. It is guaranteed that all x_i are distinct.
Output
In the first line print one integer res — the minimum possible value of ∑_{j=1}^{m}min_{i=1}^{n}|x_i - y_j| (in other words, the sum of distances to the nearest Christmas tree for all people).
In the second line print m integers y_1, y_2, ..., y_m (-2 ⋅ 10^9 ≤ y_j ≤ 2 ⋅ 10^9), where y_j is the position of the j-th human. All y_j should be distinct and all values x_1, x_2, ..., x_n, y_1, y_2, ..., y_m should be distinct.
If there are multiple answers, print any of them.
Examples
Input
2 6
1 5
Output
8
-1 2 6 4 0 3
Input
3 5
0 3 1
Output
7
5 -2 4 -1 2
Submitted Solution:
```
from collections import defaultdict as dc
from heapq import *
import math
import bisect
from collections import deque as dq
n,m=[int(i) for i in input().split()]
a=[int(i) for i in input().split()]
p=dc(int)
cnt=dc(int)
q=dq([])
ans=[]
d=0
for i in range(n):
p[a[i]]=0
q.append(a[i])
cnt[a[i]]=1
while(len(q)):
#print(q,p,ans,d)
if len(ans)==m:
break
k=q.popleft()
if p[k]!=0:
d+=p[k]
ans.append(k)
if cnt[k-1]==0:
p[k-1]=p[k]+1
q.append(k-1)
cnt[k-1]=1
if cnt[k+1]==0:
p[k+1]=p[k]+1
q.append(k+1)
cnt[k+1]=1
print(d)
print(*ans)
``` | instruction | 0 | 68,272 | 14 | 136,544 |
Yes | output | 1 | 68,272 | 14 | 136,545 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n Christmas trees on an infinite number line. The i-th tree grows at the position x_i. All x_i are guaranteed to be distinct.
Each integer point can be either occupied by the Christmas tree, by the human or not occupied at all. Non-integer points cannot be occupied by anything.
There are m people who want to celebrate Christmas. Let y_1, y_2, ..., y_m be the positions of people (note that all values x_1, x_2, ..., x_n, y_1, y_2, ..., y_m should be distinct and all y_j should be integer). You want to find such an arrangement of people that the value ∑_{j=1}^{m}min_{i=1}^{n}|x_i - y_j| is the minimum possible (in other words, the sum of distances to the nearest Christmas tree for all people should be minimized).
In other words, let d_j be the distance from the j-th human to the nearest Christmas tree (d_j = min_{i=1}^{n} |y_j - x_i|). Then you need to choose such positions y_1, y_2, ..., y_m that ∑_{j=1}^{m} d_j is the minimum possible.
Input
The first line of the input contains two integers n and m (1 ≤ n, m ≤ 2 ⋅ 10^5) — the number of Christmas trees and the number of people.
The second line of the input contains n integers x_1, x_2, ..., x_n (-10^9 ≤ x_i ≤ 10^9), where x_i is the position of the i-th Christmas tree. It is guaranteed that all x_i are distinct.
Output
In the first line print one integer res — the minimum possible value of ∑_{j=1}^{m}min_{i=1}^{n}|x_i - y_j| (in other words, the sum of distances to the nearest Christmas tree for all people).
In the second line print m integers y_1, y_2, ..., y_m (-2 ⋅ 10^9 ≤ y_j ≤ 2 ⋅ 10^9), where y_j is the position of the j-th human. All y_j should be distinct and all values x_1, x_2, ..., x_n, y_1, y_2, ..., y_m should be distinct.
If there are multiple answers, print any of them.
Examples
Input
2 6
1 5
Output
8
-1 2 6 4 0 3
Input
3 5
0 3 1
Output
7
5 -2 4 -1 2
Submitted Solution:
```
from sys import stdout
def solution():
a, b = map(int, input().split())
arr = frozenset(int(x) for x in input().split())
points = set(arr)
s = set()
i = 1
total = 0
while len(s) < b:
temp = set()
for v in arr:
p = v - i
if p not in points:
s.add(p)
points.add(p)
# Add v to the list of points so that we can check it directly
temp.add(v)
total += i
if len(s) == b: break
p = v + i
if p not in points:
s.add(p)
points.add(p)
temp.add(v)
total += i
if len(s) == b: break
i += 1
# Reject those points which are not contributing
arr = frozenset(temp)
"""
while len(s) < b:
for v in arr:
p = v - i
k = len(s)
if p not in points:
s.add(p)
if k != len(s):
total += i
if len(s) == b: break
p = v + i
k = len(s)
if p not in points:
s.add(p)
if k != len(s):
total += i
if len(s) == b: break
i += 1
"""
stdout.write("{}\n{}".format(total, " ".join(map(str, s))))
if __name__ == "__main__":
solution()
``` | instruction | 0 | 68,273 | 14 | 136,546 |
Yes | output | 1 | 68,273 | 14 | 136,547 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n Christmas trees on an infinite number line. The i-th tree grows at the position x_i. All x_i are guaranteed to be distinct.
Each integer point can be either occupied by the Christmas tree, by the human or not occupied at all. Non-integer points cannot be occupied by anything.
There are m people who want to celebrate Christmas. Let y_1, y_2, ..., y_m be the positions of people (note that all values x_1, x_2, ..., x_n, y_1, y_2, ..., y_m should be distinct and all y_j should be integer). You want to find such an arrangement of people that the value ∑_{j=1}^{m}min_{i=1}^{n}|x_i - y_j| is the minimum possible (in other words, the sum of distances to the nearest Christmas tree for all people should be minimized).
In other words, let d_j be the distance from the j-th human to the nearest Christmas tree (d_j = min_{i=1}^{n} |y_j - x_i|). Then you need to choose such positions y_1, y_2, ..., y_m that ∑_{j=1}^{m} d_j is the minimum possible.
Input
The first line of the input contains two integers n and m (1 ≤ n, m ≤ 2 ⋅ 10^5) — the number of Christmas trees and the number of people.
The second line of the input contains n integers x_1, x_2, ..., x_n (-10^9 ≤ x_i ≤ 10^9), where x_i is the position of the i-th Christmas tree. It is guaranteed that all x_i are distinct.
Output
In the first line print one integer res — the minimum possible value of ∑_{j=1}^{m}min_{i=1}^{n}|x_i - y_j| (in other words, the sum of distances to the nearest Christmas tree for all people).
In the second line print m integers y_1, y_2, ..., y_m (-2 ⋅ 10^9 ≤ y_j ≤ 2 ⋅ 10^9), where y_j is the position of the j-th human. All y_j should be distinct and all values x_1, x_2, ..., x_n, y_1, y_2, ..., y_m should be distinct.
If there are multiple answers, print any of them.
Examples
Input
2 6
1 5
Output
8
-1 2 6 4 0 3
Input
3 5
0 3 1
Output
7
5 -2 4 -1 2
Submitted Solution:
```
import sys
from collections import deque
input = sys.stdin.readline
n,m = map(int,input().split())
x = list(map(int,input().split()))
q = deque(x)
used = set(x)
ans = set()
cnt = 0
while cnt < m:
i = q.popleft()
if i not in used:
used.add(i)
ans.add(i)
cnt += 1
if i+1 not in used:
q.append(i+1)
if i-1 not in used:
q.append(i-1)
i = 0
ans = sorted(list(ans))
dist = 0
for y in ans:
while i+1 < n and abs(x[i+1] - y) < abs(x[i] - y):
i += 1
dist += abs(x[i] - y)
print(dist)
print(*ans)
``` | instruction | 0 | 68,274 | 14 | 136,548 |
No | output | 1 | 68,274 | 14 | 136,549 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n Christmas trees on an infinite number line. The i-th tree grows at the position x_i. All x_i are guaranteed to be distinct.
Each integer point can be either occupied by the Christmas tree, by the human or not occupied at all. Non-integer points cannot be occupied by anything.
There are m people who want to celebrate Christmas. Let y_1, y_2, ..., y_m be the positions of people (note that all values x_1, x_2, ..., x_n, y_1, y_2, ..., y_m should be distinct and all y_j should be integer). You want to find such an arrangement of people that the value ∑_{j=1}^{m}min_{i=1}^{n}|x_i - y_j| is the minimum possible (in other words, the sum of distances to the nearest Christmas tree for all people should be minimized).
In other words, let d_j be the distance from the j-th human to the nearest Christmas tree (d_j = min_{i=1}^{n} |y_j - x_i|). Then you need to choose such positions y_1, y_2, ..., y_m that ∑_{j=1}^{m} d_j is the minimum possible.
Input
The first line of the input contains two integers n and m (1 ≤ n, m ≤ 2 ⋅ 10^5) — the number of Christmas trees and the number of people.
The second line of the input contains n integers x_1, x_2, ..., x_n (-10^9 ≤ x_i ≤ 10^9), where x_i is the position of the i-th Christmas tree. It is guaranteed that all x_i are distinct.
Output
In the first line print one integer res — the minimum possible value of ∑_{j=1}^{m}min_{i=1}^{n}|x_i - y_j| (in other words, the sum of distances to the nearest Christmas tree for all people).
In the second line print m integers y_1, y_2, ..., y_m (-2 ⋅ 10^9 ≤ y_j ≤ 2 ⋅ 10^9), where y_j is the position of the j-th human. All y_j should be distinct and all values x_1, x_2, ..., x_n, y_1, y_2, ..., y_m should be distinct.
If there are multiple answers, print any of them.
Examples
Input
2 6
1 5
Output
8
-1 2 6 4 0 3
Input
3 5
0 3 1
Output
7
5 -2 4 -1 2
Submitted Solution:
```
n,m=[int(x) for x in input().split()]
t=[int(x) for x in input().split()]
t.sort()
l=[]
r=[]
for i in range(1,n):
d=t[i]-t[i-1]-1
r.append(d//2)
l.append(d-d//2)
full=l+r
full.sort()
s=sum(full)
if m>s:
full.append((m-s)//2)
full.append((m-s)-((m-s)//2))
l.insert(0,(m-s)//2)
r.append((m-s)-((m-s)//2))
else:
l.insert(0,0)
r.append(0)
full.sort()
#print(full,l,r)
total=0
lim=full[-1]
for i in full:
total+=i
if total>=m:
lim=i
break
lim-=1
ans=[]
fin=0
for i in range(n):
for j in range(1,min(lim,l[i])+1):
ans.append(t[i]-j)
fin+=(j)
for j in range(1,min(lim,r[i])+1):
ans.append(t[i]+j)
fin+=(j)
#print(lim,ans)
lim+=1
k=m-len(ans)
i=0
while k>0:
if l[i]>=lim:
ans.append(t[i]-lim)
fin+=(lim)
k-=1
if r[i]>=lim:
ans.append(t[i]+lim)
fin+=(lim)
k-=1
i+=1
print(fin)
for i in ans:
print(i,end=' ')
print()
``` | instruction | 0 | 68,275 | 14 | 136,550 |
No | output | 1 | 68,275 | 14 | 136,551 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n Christmas trees on an infinite number line. The i-th tree grows at the position x_i. All x_i are guaranteed to be distinct.
Each integer point can be either occupied by the Christmas tree, by the human or not occupied at all. Non-integer points cannot be occupied by anything.
There are m people who want to celebrate Christmas. Let y_1, y_2, ..., y_m be the positions of people (note that all values x_1, x_2, ..., x_n, y_1, y_2, ..., y_m should be distinct and all y_j should be integer). You want to find such an arrangement of people that the value ∑_{j=1}^{m}min_{i=1}^{n}|x_i - y_j| is the minimum possible (in other words, the sum of distances to the nearest Christmas tree for all people should be minimized).
In other words, let d_j be the distance from the j-th human to the nearest Christmas tree (d_j = min_{i=1}^{n} |y_j - x_i|). Then you need to choose such positions y_1, y_2, ..., y_m that ∑_{j=1}^{m} d_j is the minimum possible.
Input
The first line of the input contains two integers n and m (1 ≤ n, m ≤ 2 ⋅ 10^5) — the number of Christmas trees and the number of people.
The second line of the input contains n integers x_1, x_2, ..., x_n (-10^9 ≤ x_i ≤ 10^9), where x_i is the position of the i-th Christmas tree. It is guaranteed that all x_i are distinct.
Output
In the first line print one integer res — the minimum possible value of ∑_{j=1}^{m}min_{i=1}^{n}|x_i - y_j| (in other words, the sum of distances to the nearest Christmas tree for all people).
In the second line print m integers y_1, y_2, ..., y_m (-2 ⋅ 10^9 ≤ y_j ≤ 2 ⋅ 10^9), where y_j is the position of the j-th human. All y_j should be distinct and all values x_1, x_2, ..., x_n, y_1, y_2, ..., y_m should be distinct.
If there are multiple answers, print any of them.
Examples
Input
2 6
1 5
Output
8
-1 2 6 4 0 3
Input
3 5
0 3 1
Output
7
5 -2 4 -1 2
Submitted Solution:
```
def add_number(number_to_check,level):
global distance,m
if number_to_check not in list_of_trees:
if number_to_check not in list_of_people:
list_of_people.append(number_to_check)
distance=distance+level
m=m-1
return
def check_adjacent_level(list_of_trees,list_of_people,level):
for i in list_of_trees:
number_to_check=i+level
add_number(number_to_check,level)
if(m==0):
return
number_to_check=i-level
add_number(number_to_check,level)
if(m==0):
return
def find_all_tree_positions(list_of_trees,list_of_people):
level=1
global m
while True:
check_adjacent_level(list_of_trees,list_of_people,level)
if m==0:
break
level=level+1
list_of_n_and_m=list(map(int,input().split(' ')))
n=list_of_n_and_m[0]
m=list_of_n_and_m[1]
list_of_trees=list(map(int,input().split(' ')))
distance=0
list_of_people=[]
find_all_tree_positions(list_of_trees,list_of_people)
print(distance)
print(list_of_people)
``` | instruction | 0 | 68,276 | 14 | 136,552 |
No | output | 1 | 68,276 | 14 | 136,553 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n Christmas trees on an infinite number line. The i-th tree grows at the position x_i. All x_i are guaranteed to be distinct.
Each integer point can be either occupied by the Christmas tree, by the human or not occupied at all. Non-integer points cannot be occupied by anything.
There are m people who want to celebrate Christmas. Let y_1, y_2, ..., y_m be the positions of people (note that all values x_1, x_2, ..., x_n, y_1, y_2, ..., y_m should be distinct and all y_j should be integer). You want to find such an arrangement of people that the value ∑_{j=1}^{m}min_{i=1}^{n}|x_i - y_j| is the minimum possible (in other words, the sum of distances to the nearest Christmas tree for all people should be minimized).
In other words, let d_j be the distance from the j-th human to the nearest Christmas tree (d_j = min_{i=1}^{n} |y_j - x_i|). Then you need to choose such positions y_1, y_2, ..., y_m that ∑_{j=1}^{m} d_j is the minimum possible.
Input
The first line of the input contains two integers n and m (1 ≤ n, m ≤ 2 ⋅ 10^5) — the number of Christmas trees and the number of people.
The second line of the input contains n integers x_1, x_2, ..., x_n (-10^9 ≤ x_i ≤ 10^9), where x_i is the position of the i-th Christmas tree. It is guaranteed that all x_i are distinct.
Output
In the first line print one integer res — the minimum possible value of ∑_{j=1}^{m}min_{i=1}^{n}|x_i - y_j| (in other words, the sum of distances to the nearest Christmas tree for all people).
In the second line print m integers y_1, y_2, ..., y_m (-2 ⋅ 10^9 ≤ y_j ≤ 2 ⋅ 10^9), where y_j is the position of the j-th human. All y_j should be distinct and all values x_1, x_2, ..., x_n, y_1, y_2, ..., y_m should be distinct.
If there are multiple answers, print any of them.
Examples
Input
2 6
1 5
Output
8
-1 2 6 4 0 3
Input
3 5
0 3 1
Output
7
5 -2 4 -1 2
Submitted Solution:
```
po, men = map(int, input().split())
a = {int(i) for i in input().split()}
r = {*a}
men += len(r)
k = 1
s = 0
while len(r) < men:
b = set()
for i in a:
for p in -1, 1:
if i + p*k not in r:
if len(r) < men:
s += abs(p*k)
r.add(i + p*k)
b.add(i)
if len(r) == men:
print(s)
print(*(r - {*a}))
exit()
k += 1
a = b
``` | instruction | 0 | 68,277 | 14 | 136,554 |
No | output | 1 | 68,277 | 14 | 136,555 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n startups. Startups can be active or acquired. If a startup is acquired, then that means it has exactly one active startup that it is following. An active startup can have arbitrarily many acquired startups that are following it. An active startup cannot follow any other startup.
The following steps happen until there is exactly one active startup. The following sequence of steps takes exactly 1 day.
1. Two distinct active startups A, B, are chosen uniformly at random.
2. A fair coin is flipped, and with equal probability, A acquires B or B acquires A (i.e. if A acquires B, then that means B's state changes from active to acquired, and its starts following A).
3. When a startup changes from active to acquired, all of its previously acquired startups become active.
For example, the following scenario can happen: Let's say A, B are active startups. C, D, E are acquired startups under A, and F, G are acquired startups under B:
<image>
Active startups are shown in red.
If A acquires B, then the state will be A, F, G are active startups. C, D, E, B are acquired startups under A. F and G have no acquired startups:
<image>
If instead, B acquires A, then the state will be B, C, D, E are active startups. F, G, A are acquired startups under B. C, D, E have no acquired startups:
<image>
You are given the initial state of the startups. For each startup, you are told if it is either acquired or active. If it is acquired, you are also given the index of the active startup that it is following.
You're now wondering, what is the expected number of days needed for this process to finish with exactly one active startup at the end.
It can be shown the expected number of days can be written as a rational number P/Q, where P and Q are co-prime integers, and Q not= 0 \pmod{10^9+7}. Return the value of P ⋅ Q^{-1} modulo 10^9+7.
Input
The first line contains a single integer n (2 ≤ n ≤ 500), the number of startups.
The next line will contain n space-separated integers a_1, a_2, …, a_n (a_i = -1 or 1 ≤ a_i ≤ n). If a_i = -1, then that means startup i is active. Otherwise, if 1 ≤ a_i ≤ n, then startup i is acquired, and it is currently following startup a_i. It is guaranteed if a_i not= -1, then a_{a_i} =-1 (that is, all startups that are being followed are active).
Output
Print a single integer, the expected number of days needed for the process to end with exactly one active startup, modulo 10^9+7.
Examples
Input
3
-1 -1 -1
Output
3
Input
2
2 -1
Output
0
Input
40
3 3 -1 -1 4 4 -1 -1 -1 -1 -1 10 10 10 10 10 10 4 20 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 3 3 3 3 3 3 3 3
Output
755808950
Note
In the first sample, there are three active startups labeled 1, 2 and 3, and zero acquired startups. Here's an example of how one scenario can happen
1. Startup 1 acquires startup 2 (This state can be represented by the array [-1, 1, -1])
2. Startup 3 acquires startup 1 (This state can be represented by the array [3, -1, -1])
3. Startup 2 acquires startup 3 (This state can be represented by the array [-1, -1, 2]).
4. Startup 2 acquires startup 1 (This state can be represented by the array [2, -1, 2]).
At this point, there is only one active startup, and this sequence of steps took 4 days. It can be shown the expected number of days is 3.
For the second sample, there is only one active startup, so we need zero days.
For the last sample, remember to take the answer modulo 10^9+7. | instruction | 0 | 68,914 | 14 | 137,828 |
Tags: constructive algorithms, math
Correct Solution:
```
m,n,a = 1000000007,int(input()),input().split()
print((pow(2,n-1,m)-1 - sum(pow(2,a.count(x),m)-1 for x in set(a) if x != '-1')) % m)
``` | output | 1 | 68,914 | 14 | 137,829 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n startups. Startups can be active or acquired. If a startup is acquired, then that means it has exactly one active startup that it is following. An active startup can have arbitrarily many acquired startups that are following it. An active startup cannot follow any other startup.
The following steps happen until there is exactly one active startup. The following sequence of steps takes exactly 1 day.
1. Two distinct active startups A, B, are chosen uniformly at random.
2. A fair coin is flipped, and with equal probability, A acquires B or B acquires A (i.e. if A acquires B, then that means B's state changes from active to acquired, and its starts following A).
3. When a startup changes from active to acquired, all of its previously acquired startups become active.
For example, the following scenario can happen: Let's say A, B are active startups. C, D, E are acquired startups under A, and F, G are acquired startups under B:
<image>
Active startups are shown in red.
If A acquires B, then the state will be A, F, G are active startups. C, D, E, B are acquired startups under A. F and G have no acquired startups:
<image>
If instead, B acquires A, then the state will be B, C, D, E are active startups. F, G, A are acquired startups under B. C, D, E have no acquired startups:
<image>
You are given the initial state of the startups. For each startup, you are told if it is either acquired or active. If it is acquired, you are also given the index of the active startup that it is following.
You're now wondering, what is the expected number of days needed for this process to finish with exactly one active startup at the end.
It can be shown the expected number of days can be written as a rational number P/Q, where P and Q are co-prime integers, and Q not= 0 \pmod{10^9+7}. Return the value of P ⋅ Q^{-1} modulo 10^9+7.
Input
The first line contains a single integer n (2 ≤ n ≤ 500), the number of startups.
The next line will contain n space-separated integers a_1, a_2, …, a_n (a_i = -1 or 1 ≤ a_i ≤ n). If a_i = -1, then that means startup i is active. Otherwise, if 1 ≤ a_i ≤ n, then startup i is acquired, and it is currently following startup a_i. It is guaranteed if a_i not= -1, then a_{a_i} =-1 (that is, all startups that are being followed are active).
Output
Print a single integer, the expected number of days needed for the process to end with exactly one active startup, modulo 10^9+7.
Examples
Input
3
-1 -1 -1
Output
3
Input
2
2 -1
Output
0
Input
40
3 3 -1 -1 4 4 -1 -1 -1 -1 -1 10 10 10 10 10 10 4 20 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 3 3 3 3 3 3 3 3
Output
755808950
Note
In the first sample, there are three active startups labeled 1, 2 and 3, and zero acquired startups. Here's an example of how one scenario can happen
1. Startup 1 acquires startup 2 (This state can be represented by the array [-1, 1, -1])
2. Startup 3 acquires startup 1 (This state can be represented by the array [3, -1, -1])
3. Startup 2 acquires startup 3 (This state can be represented by the array [-1, -1, 2]).
4. Startup 2 acquires startup 1 (This state can be represented by the array [2, -1, 2]).
At this point, there is only one active startup, and this sequence of steps took 4 days. It can be shown the expected number of days is 3.
For the second sample, there is only one active startup, so we need zero days.
For the last sample, remember to take the answer modulo 10^9+7. | instruction | 0 | 68,915 | 14 | 137,830 |
Tags: constructive algorithms, math
Correct Solution:
```
n = int(input())
a = [int(i) for i in input().split()]
b = [0] * (n + 1)
sum = 2 ** (n - 1) - 1
for i in a:
if(i > 0):
b[i] = b[i] + 1
for i in b:
sum = sum - 2 ** i + 1
print(sum % 1000000007)
``` | output | 1 | 68,915 | 14 | 137,831 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n startups. Startups can be active or acquired. If a startup is acquired, then that means it has exactly one active startup that it is following. An active startup can have arbitrarily many acquired startups that are following it. An active startup cannot follow any other startup.
The following steps happen until there is exactly one active startup. The following sequence of steps takes exactly 1 day.
1. Two distinct active startups A, B, are chosen uniformly at random.
2. A fair coin is flipped, and with equal probability, A acquires B or B acquires A (i.e. if A acquires B, then that means B's state changes from active to acquired, and its starts following A).
3. When a startup changes from active to acquired, all of its previously acquired startups become active.
For example, the following scenario can happen: Let's say A, B are active startups. C, D, E are acquired startups under A, and F, G are acquired startups under B:
<image>
Active startups are shown in red.
If A acquires B, then the state will be A, F, G are active startups. C, D, E, B are acquired startups under A. F and G have no acquired startups:
<image>
If instead, B acquires A, then the state will be B, C, D, E are active startups. F, G, A are acquired startups under B. C, D, E have no acquired startups:
<image>
You are given the initial state of the startups. For each startup, you are told if it is either acquired or active. If it is acquired, you are also given the index of the active startup that it is following.
You're now wondering, what is the expected number of days needed for this process to finish with exactly one active startup at the end.
It can be shown the expected number of days can be written as a rational number P/Q, where P and Q are co-prime integers, and Q not= 0 \pmod{10^9+7}. Return the value of P ⋅ Q^{-1} modulo 10^9+7.
Input
The first line contains a single integer n (2 ≤ n ≤ 500), the number of startups.
The next line will contain n space-separated integers a_1, a_2, …, a_n (a_i = -1 or 1 ≤ a_i ≤ n). If a_i = -1, then that means startup i is active. Otherwise, if 1 ≤ a_i ≤ n, then startup i is acquired, and it is currently following startup a_i. It is guaranteed if a_i not= -1, then a_{a_i} =-1 (that is, all startups that are being followed are active).
Output
Print a single integer, the expected number of days needed for the process to end with exactly one active startup, modulo 10^9+7.
Examples
Input
3
-1 -1 -1
Output
3
Input
2
2 -1
Output
0
Input
40
3 3 -1 -1 4 4 -1 -1 -1 -1 -1 10 10 10 10 10 10 4 20 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 3 3 3 3 3 3 3 3
Output
755808950
Note
In the first sample, there are three active startups labeled 1, 2 and 3, and zero acquired startups. Here's an example of how one scenario can happen
1. Startup 1 acquires startup 2 (This state can be represented by the array [-1, 1, -1])
2. Startup 3 acquires startup 1 (This state can be represented by the array [3, -1, -1])
3. Startup 2 acquires startup 3 (This state can be represented by the array [-1, -1, 2]).
4. Startup 2 acquires startup 1 (This state can be represented by the array [2, -1, 2]).
At this point, there is only one active startup, and this sequence of steps took 4 days. It can be shown the expected number of days is 3.
For the second sample, there is only one active startup, so we need zero days.
For the last sample, remember to take the answer modulo 10^9+7. | instruction | 0 | 68,916 | 14 | 137,832 |
Tags: constructive algorithms, math
Correct Solution:
```
input();a=input().split();print((2**(len(a)-1)-1-sum(2**a.count(x)-1for x in{*a}-{'-1'}))%(10**9+7))
``` | output | 1 | 68,916 | 14 | 137,833 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n startups. Startups can be active or acquired. If a startup is acquired, then that means it has exactly one active startup that it is following. An active startup can have arbitrarily many acquired startups that are following it. An active startup cannot follow any other startup.
The following steps happen until there is exactly one active startup. The following sequence of steps takes exactly 1 day.
1. Two distinct active startups A, B, are chosen uniformly at random.
2. A fair coin is flipped, and with equal probability, A acquires B or B acquires A (i.e. if A acquires B, then that means B's state changes from active to acquired, and its starts following A).
3. When a startup changes from active to acquired, all of its previously acquired startups become active.
For example, the following scenario can happen: Let's say A, B are active startups. C, D, E are acquired startups under A, and F, G are acquired startups under B:
<image>
Active startups are shown in red.
If A acquires B, then the state will be A, F, G are active startups. C, D, E, B are acquired startups under A. F and G have no acquired startups:
<image>
If instead, B acquires A, then the state will be B, C, D, E are active startups. F, G, A are acquired startups under B. C, D, E have no acquired startups:
<image>
You are given the initial state of the startups. For each startup, you are told if it is either acquired or active. If it is acquired, you are also given the index of the active startup that it is following.
You're now wondering, what is the expected number of days needed for this process to finish with exactly one active startup at the end.
It can be shown the expected number of days can be written as a rational number P/Q, where P and Q are co-prime integers, and Q not= 0 \pmod{10^9+7}. Return the value of P ⋅ Q^{-1} modulo 10^9+7.
Input
The first line contains a single integer n (2 ≤ n ≤ 500), the number of startups.
The next line will contain n space-separated integers a_1, a_2, …, a_n (a_i = -1 or 1 ≤ a_i ≤ n). If a_i = -1, then that means startup i is active. Otherwise, if 1 ≤ a_i ≤ n, then startup i is acquired, and it is currently following startup a_i. It is guaranteed if a_i not= -1, then a_{a_i} =-1 (that is, all startups that are being followed are active).
Output
Print a single integer, the expected number of days needed for the process to end with exactly one active startup, modulo 10^9+7.
Examples
Input
3
-1 -1 -1
Output
3
Input
2
2 -1
Output
0
Input
40
3 3 -1 -1 4 4 -1 -1 -1 -1 -1 10 10 10 10 10 10 4 20 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 3 3 3 3 3 3 3 3
Output
755808950
Note
In the first sample, there are three active startups labeled 1, 2 and 3, and zero acquired startups. Here's an example of how one scenario can happen
1. Startup 1 acquires startup 2 (This state can be represented by the array [-1, 1, -1])
2. Startup 3 acquires startup 1 (This state can be represented by the array [3, -1, -1])
3. Startup 2 acquires startup 3 (This state can be represented by the array [-1, -1, 2]).
4. Startup 2 acquires startup 1 (This state can be represented by the array [2, -1, 2]).
At this point, there is only one active startup, and this sequence of steps took 4 days. It can be shown the expected number of days is 3.
For the second sample, there is only one active startup, so we need zero days.
For the last sample, remember to take the answer modulo 10^9+7. | instruction | 0 | 68,917 | 14 | 137,834 |
Tags: constructive algorithms, math
Correct Solution:
```
m = 1000000007
n = int(input())
a = input().split()
print((pow(2,n-1,m)-1 - sum(pow(2,a.count(x),m)-1 for x in set(a) if x != '-1')) % m)
``` | output | 1 | 68,917 | 14 | 137,835 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n startups. Startups can be active or acquired. If a startup is acquired, then that means it has exactly one active startup that it is following. An active startup can have arbitrarily many acquired startups that are following it. An active startup cannot follow any other startup.
The following steps happen until there is exactly one active startup. The following sequence of steps takes exactly 1 day.
1. Two distinct active startups A, B, are chosen uniformly at random.
2. A fair coin is flipped, and with equal probability, A acquires B or B acquires A (i.e. if A acquires B, then that means B's state changes from active to acquired, and its starts following A).
3. When a startup changes from active to acquired, all of its previously acquired startups become active.
For example, the following scenario can happen: Let's say A, B are active startups. C, D, E are acquired startups under A, and F, G are acquired startups under B:
<image>
Active startups are shown in red.
If A acquires B, then the state will be A, F, G are active startups. C, D, E, B are acquired startups under A. F and G have no acquired startups:
<image>
If instead, B acquires A, then the state will be B, C, D, E are active startups. F, G, A are acquired startups under B. C, D, E have no acquired startups:
<image>
You are given the initial state of the startups. For each startup, you are told if it is either acquired or active. If it is acquired, you are also given the index of the active startup that it is following.
You're now wondering, what is the expected number of days needed for this process to finish with exactly one active startup at the end.
It can be shown the expected number of days can be written as a rational number P/Q, where P and Q are co-prime integers, and Q not= 0 \pmod{10^9+7}. Return the value of P ⋅ Q^{-1} modulo 10^9+7.
Input
The first line contains a single integer n (2 ≤ n ≤ 500), the number of startups.
The next line will contain n space-separated integers a_1, a_2, …, a_n (a_i = -1 or 1 ≤ a_i ≤ n). If a_i = -1, then that means startup i is active. Otherwise, if 1 ≤ a_i ≤ n, then startup i is acquired, and it is currently following startup a_i. It is guaranteed if a_i not= -1, then a_{a_i} =-1 (that is, all startups that are being followed are active).
Output
Print a single integer, the expected number of days needed for the process to end with exactly one active startup, modulo 10^9+7.
Examples
Input
3
-1 -1 -1
Output
3
Input
2
2 -1
Output
0
Input
40
3 3 -1 -1 4 4 -1 -1 -1 -1 -1 10 10 10 10 10 10 4 20 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 3 3 3 3 3 3 3 3
Output
755808950
Note
In the first sample, there are three active startups labeled 1, 2 and 3, and zero acquired startups. Here's an example of how one scenario can happen
1. Startup 1 acquires startup 2 (This state can be represented by the array [-1, 1, -1])
2. Startup 3 acquires startup 1 (This state can be represented by the array [3, -1, -1])
3. Startup 2 acquires startup 3 (This state can be represented by the array [-1, -1, 2]).
4. Startup 2 acquires startup 1 (This state can be represented by the array [2, -1, 2]).
At this point, there is only one active startup, and this sequence of steps took 4 days. It can be shown the expected number of days is 3.
For the second sample, there is only one active startup, so we need zero days.
For the last sample, remember to take the answer modulo 10^9+7. | instruction | 0 | 68,918 | 14 | 137,836 |
Tags: constructive algorithms, math
Correct Solution:
```
m = 1000000007
n = int(input())
a = list(map(int, input().split()))
print((pow(2,n-1,m)-1 - sum(pow(2,a.count(x),m)-1 for x in set(a) if x != -1)) % m)
``` | output | 1 | 68,918 | 14 | 137,837 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n startups. Startups can be active or acquired. If a startup is acquired, then that means it has exactly one active startup that it is following. An active startup can have arbitrarily many acquired startups that are following it. An active startup cannot follow any other startup.
The following steps happen until there is exactly one active startup. The following sequence of steps takes exactly 1 day.
1. Two distinct active startups A, B, are chosen uniformly at random.
2. A fair coin is flipped, and with equal probability, A acquires B or B acquires A (i.e. if A acquires B, then that means B's state changes from active to acquired, and its starts following A).
3. When a startup changes from active to acquired, all of its previously acquired startups become active.
For example, the following scenario can happen: Let's say A, B are active startups. C, D, E are acquired startups under A, and F, G are acquired startups under B:
<image>
Active startups are shown in red.
If A acquires B, then the state will be A, F, G are active startups. C, D, E, B are acquired startups under A. F and G have no acquired startups:
<image>
If instead, B acquires A, then the state will be B, C, D, E are active startups. F, G, A are acquired startups under B. C, D, E have no acquired startups:
<image>
You are given the initial state of the startups. For each startup, you are told if it is either acquired or active. If it is acquired, you are also given the index of the active startup that it is following.
You're now wondering, what is the expected number of days needed for this process to finish with exactly one active startup at the end.
It can be shown the expected number of days can be written as a rational number P/Q, where P and Q are co-prime integers, and Q not= 0 \pmod{10^9+7}. Return the value of P ⋅ Q^{-1} modulo 10^9+7.
Input
The first line contains a single integer n (2 ≤ n ≤ 500), the number of startups.
The next line will contain n space-separated integers a_1, a_2, …, a_n (a_i = -1 or 1 ≤ a_i ≤ n). If a_i = -1, then that means startup i is active. Otherwise, if 1 ≤ a_i ≤ n, then startup i is acquired, and it is currently following startup a_i. It is guaranteed if a_i not= -1, then a_{a_i} =-1 (that is, all startups that are being followed are active).
Output
Print a single integer, the expected number of days needed for the process to end with exactly one active startup, modulo 10^9+7.
Examples
Input
3
-1 -1 -1
Output
3
Input
2
2 -1
Output
0
Input
40
3 3 -1 -1 4 4 -1 -1 -1 -1 -1 10 10 10 10 10 10 4 20 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 3 3 3 3 3 3 3 3
Output
755808950
Note
In the first sample, there are three active startups labeled 1, 2 and 3, and zero acquired startups. Here's an example of how one scenario can happen
1. Startup 1 acquires startup 2 (This state can be represented by the array [-1, 1, -1])
2. Startup 3 acquires startup 1 (This state can be represented by the array [3, -1, -1])
3. Startup 2 acquires startup 3 (This state can be represented by the array [-1, -1, 2]).
4. Startup 2 acquires startup 1 (This state can be represented by the array [2, -1, 2]).
At this point, there is only one active startup, and this sequence of steps took 4 days. It can be shown the expected number of days is 3.
For the second sample, there is only one active startup, so we need zero days.
For the last sample, remember to take the answer modulo 10^9+7. | instruction | 0 | 68,919 | 14 | 137,838 |
Tags: constructive algorithms, math
Correct Solution:
```
n=int(input())
a=input().split()
print((2**(n-1)-1-sum([2**a.count(x)-1 for x in set(a)-set(['-1'])]))%(10**9+7))
``` | output | 1 | 68,919 | 14 | 137,839 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n startups. Startups can be active or acquired. If a startup is acquired, then that means it has exactly one active startup that it is following. An active startup can have arbitrarily many acquired startups that are following it. An active startup cannot follow any other startup.
The following steps happen until there is exactly one active startup. The following sequence of steps takes exactly 1 day.
1. Two distinct active startups A, B, are chosen uniformly at random.
2. A fair coin is flipped, and with equal probability, A acquires B or B acquires A (i.e. if A acquires B, then that means B's state changes from active to acquired, and its starts following A).
3. When a startup changes from active to acquired, all of its previously acquired startups become active.
For example, the following scenario can happen: Let's say A, B are active startups. C, D, E are acquired startups under A, and F, G are acquired startups under B:
<image>
Active startups are shown in red.
If A acquires B, then the state will be A, F, G are active startups. C, D, E, B are acquired startups under A. F and G have no acquired startups:
<image>
If instead, B acquires A, then the state will be B, C, D, E are active startups. F, G, A are acquired startups under B. C, D, E have no acquired startups:
<image>
You are given the initial state of the startups. For each startup, you are told if it is either acquired or active. If it is acquired, you are also given the index of the active startup that it is following.
You're now wondering, what is the expected number of days needed for this process to finish with exactly one active startup at the end.
It can be shown the expected number of days can be written as a rational number P/Q, where P and Q are co-prime integers, and Q not= 0 \pmod{10^9+7}. Return the value of P ⋅ Q^{-1} modulo 10^9+7.
Input
The first line contains a single integer n (2 ≤ n ≤ 500), the number of startups.
The next line will contain n space-separated integers a_1, a_2, …, a_n (a_i = -1 or 1 ≤ a_i ≤ n). If a_i = -1, then that means startup i is active. Otherwise, if 1 ≤ a_i ≤ n, then startup i is acquired, and it is currently following startup a_i. It is guaranteed if a_i not= -1, then a_{a_i} =-1 (that is, all startups that are being followed are active).
Output
Print a single integer, the expected number of days needed for the process to end with exactly one active startup, modulo 10^9+7.
Examples
Input
3
-1 -1 -1
Output
3
Input
2
2 -1
Output
0
Input
40
3 3 -1 -1 4 4 -1 -1 -1 -1 -1 10 10 10 10 10 10 4 20 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 3 3 3 3 3 3 3 3
Output
755808950
Note
In the first sample, there are three active startups labeled 1, 2 and 3, and zero acquired startups. Here's an example of how one scenario can happen
1. Startup 1 acquires startup 2 (This state can be represented by the array [-1, 1, -1])
2. Startup 3 acquires startup 1 (This state can be represented by the array [3, -1, -1])
3. Startup 2 acquires startup 3 (This state can be represented by the array [-1, -1, 2]).
4. Startup 2 acquires startup 1 (This state can be represented by the array [2, -1, 2]).
At this point, there is only one active startup, and this sequence of steps took 4 days. It can be shown the expected number of days is 3.
For the second sample, there is only one active startup, so we need zero days.
For the last sample, remember to take the answer modulo 10^9+7. | instruction | 0 | 68,920 | 14 | 137,840 |
Tags: constructive algorithms, math
Correct Solution:
```
n,a=int(input()),input().split();print((pow(2,n-1)-1-sum(pow(2,a.count(x))-1for x in{*a}-{'-1'}))%(10**9+7))
``` | output | 1 | 68,920 | 14 | 137,841 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n startups. Startups can be active or acquired. If a startup is acquired, then that means it has exactly one active startup that it is following. An active startup can have arbitrarily many acquired startups that are following it. An active startup cannot follow any other startup.
The following steps happen until there is exactly one active startup. The following sequence of steps takes exactly 1 day.
1. Two distinct active startups A, B, are chosen uniformly at random.
2. A fair coin is flipped, and with equal probability, A acquires B or B acquires A (i.e. if A acquires B, then that means B's state changes from active to acquired, and its starts following A).
3. When a startup changes from active to acquired, all of its previously acquired startups become active.
For example, the following scenario can happen: Let's say A, B are active startups. C, D, E are acquired startups under A, and F, G are acquired startups under B:
<image>
Active startups are shown in red.
If A acquires B, then the state will be A, F, G are active startups. C, D, E, B are acquired startups under A. F and G have no acquired startups:
<image>
If instead, B acquires A, then the state will be B, C, D, E are active startups. F, G, A are acquired startups under B. C, D, E have no acquired startups:
<image>
You are given the initial state of the startups. For each startup, you are told if it is either acquired or active. If it is acquired, you are also given the index of the active startup that it is following.
You're now wondering, what is the expected number of days needed for this process to finish with exactly one active startup at the end.
It can be shown the expected number of days can be written as a rational number P/Q, where P and Q are co-prime integers, and Q not= 0 \pmod{10^9+7}. Return the value of P ⋅ Q^{-1} modulo 10^9+7.
Input
The first line contains a single integer n (2 ≤ n ≤ 500), the number of startups.
The next line will contain n space-separated integers a_1, a_2, …, a_n (a_i = -1 or 1 ≤ a_i ≤ n). If a_i = -1, then that means startup i is active. Otherwise, if 1 ≤ a_i ≤ n, then startup i is acquired, and it is currently following startup a_i. It is guaranteed if a_i not= -1, then a_{a_i} =-1 (that is, all startups that are being followed are active).
Output
Print a single integer, the expected number of days needed for the process to end with exactly one active startup, modulo 10^9+7.
Examples
Input
3
-1 -1 -1
Output
3
Input
2
2 -1
Output
0
Input
40
3 3 -1 -1 4 4 -1 -1 -1 -1 -1 10 10 10 10 10 10 4 20 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 3 3 3 3 3 3 3 3
Output
755808950
Note
In the first sample, there are three active startups labeled 1, 2 and 3, and zero acquired startups. Here's an example of how one scenario can happen
1. Startup 1 acquires startup 2 (This state can be represented by the array [-1, 1, -1])
2. Startup 3 acquires startup 1 (This state can be represented by the array [3, -1, -1])
3. Startup 2 acquires startup 3 (This state can be represented by the array [-1, -1, 2]).
4. Startup 2 acquires startup 1 (This state can be represented by the array [2, -1, 2]).
At this point, there is only one active startup, and this sequence of steps took 4 days. It can be shown the expected number of days is 3.
For the second sample, there is only one active startup, so we need zero days.
For the last sample, remember to take the answer modulo 10^9+7. | instruction | 0 | 68,921 | 14 | 137,842 |
Tags: constructive algorithms, math
Correct Solution:
```
from fractions import Fraction
from copy import copy
from random import randint
from collections import *
import sys
sys.setrecursionlimit(1500)
class F:
def __init__(self,m,n):
self.m = m
self.n = n
self.save = {}
def __call__(self,a):
if a in self.save:
return self.save[a]
if type(a) != Fraction:
a = Fraction(a)
m = self.m
n = self.n
if a == 0:
return Fraction(-0.5)
if a == 1:
return Fraction(-1)
self.save[a] = 2*f(a-1)-(a-2)*f(1)-1
return self.save[a]
def egcd(a, b):
if a == 0:
return (b, 0, 1)
else:
g, y, x = egcd(b % a, a)
return (g, x - (b // a) * y, y)
def modinv(a, m):
g, x, y = egcd(a, m)
if g != 1:
raise Exception('modular inverse does not exist')
else:
return x % m
# print(estimate([2,1,0]))
n = int(input())
arr = [int(x) for x in input().split()]
# arr = [3,3,-1,-1,4,4,-1,-1,-1,-1,-1,10,10,10,10,10,10,4,20,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,3,3,3,3,3,3,3,3]
a = []
cnt = defaultdict(int)
for x in arr:
cnt[x] += 1
for key in cnt:
cnt[-1] -= 1
cnt[-1] += 1
for (key,value) in cnt.items():
if key == -1:
for i in range(value):
a.append(1)
else:
a.append(value+1)
# print(len(a),sum(a),a)
n = len(a)
m = sum(a)
f = F(m,n)
# for i in range(m+1):
# print(i,f(i))
ans = sum(f(x) for x in a)-f(m)
MOD = 10**9+7
# print(float(ans))
# print(modinv(25025,MOD)*25025%MOD,ans.denominator)
print(ans.numerator*modinv(ans.denominator,MOD)%MOD)
``` | output | 1 | 68,921 | 14 | 137,843 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n startups. Startups can be active or acquired. If a startup is acquired, then that means it has exactly one active startup that it is following. An active startup can have arbitrarily many acquired startups that are following it. An active startup cannot follow any other startup.
The following steps happen until there is exactly one active startup. The following sequence of steps takes exactly 1 day.
1. Two distinct active startups A, B, are chosen uniformly at random.
2. A fair coin is flipped, and with equal probability, A acquires B or B acquires A (i.e. if A acquires B, then that means B's state changes from active to acquired, and its starts following A).
3. When a startup changes from active to acquired, all of its previously acquired startups become active.
For example, the following scenario can happen: Let's say A, B are active startups. C, D, E are acquired startups under A, and F, G are acquired startups under B:
<image>
Active startups are shown in red.
If A acquires B, then the state will be A, F, G are active startups. C, D, E, B are acquired startups under A. F and G have no acquired startups:
<image>
If instead, B acquires A, then the state will be B, C, D, E are active startups. F, G, A are acquired startups under B. C, D, E have no acquired startups:
<image>
You are given the initial state of the startups. For each startup, you are told if it is either acquired or active. If it is acquired, you are also given the index of the active startup that it is following.
You're now wondering, what is the expected number of days needed for this process to finish with exactly one active startup at the end.
It can be shown the expected number of days can be written as a rational number P/Q, where P and Q are co-prime integers, and Q not= 0 \pmod{10^9+7}. Return the value of P ⋅ Q^{-1} modulo 10^9+7.
Input
The first line contains a single integer n (2 ≤ n ≤ 500), the number of startups.
The next line will contain n space-separated integers a_1, a_2, …, a_n (a_i = -1 or 1 ≤ a_i ≤ n). If a_i = -1, then that means startup i is active. Otherwise, if 1 ≤ a_i ≤ n, then startup i is acquired, and it is currently following startup a_i. It is guaranteed if a_i not= -1, then a_{a_i} =-1 (that is, all startups that are being followed are active).
Output
Print a single integer, the expected number of days needed for the process to end with exactly one active startup, modulo 10^9+7.
Examples
Input
3
-1 -1 -1
Output
3
Input
2
2 -1
Output
0
Input
40
3 3 -1 -1 4 4 -1 -1 -1 -1 -1 10 10 10 10 10 10 4 20 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 3 3 3 3 3 3 3 3
Output
755808950
Note
In the first sample, there are three active startups labeled 1, 2 and 3, and zero acquired startups. Here's an example of how one scenario can happen
1. Startup 1 acquires startup 2 (This state can be represented by the array [-1, 1, -1])
2. Startup 3 acquires startup 1 (This state can be represented by the array [3, -1, -1])
3. Startup 2 acquires startup 3 (This state can be represented by the array [-1, -1, 2]).
4. Startup 2 acquires startup 1 (This state can be represented by the array [2, -1, 2]).
At this point, there is only one active startup, and this sequence of steps took 4 days. It can be shown the expected number of days is 3.
For the second sample, there is only one active startup, so we need zero days.
For the last sample, remember to take the answer modulo 10^9+7.
Submitted Solution:
```
n,a=int(input()),input().split()
print((pow(2,n-1)-1-sum(pow(2,a.count(x))-1for x in{*a}-{'-1'}))%(10**9+7))
``` | instruction | 0 | 68,922 | 14 | 137,844 |
Yes | output | 1 | 68,922 | 14 | 137,845 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n startups. Startups can be active or acquired. If a startup is acquired, then that means it has exactly one active startup that it is following. An active startup can have arbitrarily many acquired startups that are following it. An active startup cannot follow any other startup.
The following steps happen until there is exactly one active startup. The following sequence of steps takes exactly 1 day.
1. Two distinct active startups A, B, are chosen uniformly at random.
2. A fair coin is flipped, and with equal probability, A acquires B or B acquires A (i.e. if A acquires B, then that means B's state changes from active to acquired, and its starts following A).
3. When a startup changes from active to acquired, all of its previously acquired startups become active.
For example, the following scenario can happen: Let's say A, B are active startups. C, D, E are acquired startups under A, and F, G are acquired startups under B:
<image>
Active startups are shown in red.
If A acquires B, then the state will be A, F, G are active startups. C, D, E, B are acquired startups under A. F and G have no acquired startups:
<image>
If instead, B acquires A, then the state will be B, C, D, E are active startups. F, G, A are acquired startups under B. C, D, E have no acquired startups:
<image>
You are given the initial state of the startups. For each startup, you are told if it is either acquired or active. If it is acquired, you are also given the index of the active startup that it is following.
You're now wondering, what is the expected number of days needed for this process to finish with exactly one active startup at the end.
It can be shown the expected number of days can be written as a rational number P/Q, where P and Q are co-prime integers, and Q not= 0 \pmod{10^9+7}. Return the value of P ⋅ Q^{-1} modulo 10^9+7.
Input
The first line contains a single integer n (2 ≤ n ≤ 500), the number of startups.
The next line will contain n space-separated integers a_1, a_2, …, a_n (a_i = -1 or 1 ≤ a_i ≤ n). If a_i = -1, then that means startup i is active. Otherwise, if 1 ≤ a_i ≤ n, then startup i is acquired, and it is currently following startup a_i. It is guaranteed if a_i not= -1, then a_{a_i} =-1 (that is, all startups that are being followed are active).
Output
Print a single integer, the expected number of days needed for the process to end with exactly one active startup, modulo 10^9+7.
Examples
Input
3
-1 -1 -1
Output
3
Input
2
2 -1
Output
0
Input
40
3 3 -1 -1 4 4 -1 -1 -1 -1 -1 10 10 10 10 10 10 4 20 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 3 3 3 3 3 3 3 3
Output
755808950
Note
In the first sample, there are three active startups labeled 1, 2 and 3, and zero acquired startups. Here's an example of how one scenario can happen
1. Startup 1 acquires startup 2 (This state can be represented by the array [-1, 1, -1])
2. Startup 3 acquires startup 1 (This state can be represented by the array [3, -1, -1])
3. Startup 2 acquires startup 3 (This state can be represented by the array [-1, -1, 2]).
4. Startup 2 acquires startup 1 (This state can be represented by the array [2, -1, 2]).
At this point, there is only one active startup, and this sequence of steps took 4 days. It can be shown the expected number of days is 3.
For the second sample, there is only one active startup, so we need zero days.
For the last sample, remember to take the answer modulo 10^9+7.
Submitted Solution:
```
mod=10**9+7
n=int(input())
a=input().split()
ans=pow(2,n-1,mod)-1
sz=[0]*(n+1)
for i in a:
i=int(i)
if i!=-1:
sz[i]+=1
for i in range(1,n+1):
ans-=pow(2,sz[i],mod)-1
print((ans%mod+mod)%mod)
``` | instruction | 0 | 68,923 | 14 | 137,846 |
Yes | output | 1 | 68,923 | 14 | 137,847 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n startups. Startups can be active or acquired. If a startup is acquired, then that means it has exactly one active startup that it is following. An active startup can have arbitrarily many acquired startups that are following it. An active startup cannot follow any other startup.
The following steps happen until there is exactly one active startup. The following sequence of steps takes exactly 1 day.
1. Two distinct active startups A, B, are chosen uniformly at random.
2. A fair coin is flipped, and with equal probability, A acquires B or B acquires A (i.e. if A acquires B, then that means B's state changes from active to acquired, and its starts following A).
3. When a startup changes from active to acquired, all of its previously acquired startups become active.
For example, the following scenario can happen: Let's say A, B are active startups. C, D, E are acquired startups under A, and F, G are acquired startups under B:
<image>
Active startups are shown in red.
If A acquires B, then the state will be A, F, G are active startups. C, D, E, B are acquired startups under A. F and G have no acquired startups:
<image>
If instead, B acquires A, then the state will be B, C, D, E are active startups. F, G, A are acquired startups under B. C, D, E have no acquired startups:
<image>
You are given the initial state of the startups. For each startup, you are told if it is either acquired or active. If it is acquired, you are also given the index of the active startup that it is following.
You're now wondering, what is the expected number of days needed for this process to finish with exactly one active startup at the end.
It can be shown the expected number of days can be written as a rational number P/Q, where P and Q are co-prime integers, and Q not= 0 \pmod{10^9+7}. Return the value of P ⋅ Q^{-1} modulo 10^9+7.
Input
The first line contains a single integer n (2 ≤ n ≤ 500), the number of startups.
The next line will contain n space-separated integers a_1, a_2, …, a_n (a_i = -1 or 1 ≤ a_i ≤ n). If a_i = -1, then that means startup i is active. Otherwise, if 1 ≤ a_i ≤ n, then startup i is acquired, and it is currently following startup a_i. It is guaranteed if a_i not= -1, then a_{a_i} =-1 (that is, all startups that are being followed are active).
Output
Print a single integer, the expected number of days needed for the process to end with exactly one active startup, modulo 10^9+7.
Examples
Input
3
-1 -1 -1
Output
3
Input
2
2 -1
Output
0
Input
40
3 3 -1 -1 4 4 -1 -1 -1 -1 -1 10 10 10 10 10 10 4 20 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 3 3 3 3 3 3 3 3
Output
755808950
Note
In the first sample, there are three active startups labeled 1, 2 and 3, and zero acquired startups. Here's an example of how one scenario can happen
1. Startup 1 acquires startup 2 (This state can be represented by the array [-1, 1, -1])
2. Startup 3 acquires startup 1 (This state can be represented by the array [3, -1, -1])
3. Startup 2 acquires startup 3 (This state can be represented by the array [-1, -1, 2]).
4. Startup 2 acquires startup 1 (This state can be represented by the array [2, -1, 2]).
At this point, there is only one active startup, and this sequence of steps took 4 days. It can be shown the expected number of days is 3.
For the second sample, there is only one active startup, so we need zero days.
For the last sample, remember to take the answer modulo 10^9+7.
Submitted Solution:
```
n=int(input())
r=list(map(int,input().split()))
f=[0]*501
for t in r:
if t>=0:f[t]+=1
print((2**(n-1)-1-sum(2**k-1 for k in f)) % 1000000007)
``` | instruction | 0 | 68,924 | 14 | 137,848 |
Yes | output | 1 | 68,924 | 14 | 137,849 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n startups. Startups can be active or acquired. If a startup is acquired, then that means it has exactly one active startup that it is following. An active startup can have arbitrarily many acquired startups that are following it. An active startup cannot follow any other startup.
The following steps happen until there is exactly one active startup. The following sequence of steps takes exactly 1 day.
1. Two distinct active startups A, B, are chosen uniformly at random.
2. A fair coin is flipped, and with equal probability, A acquires B or B acquires A (i.e. if A acquires B, then that means B's state changes from active to acquired, and its starts following A).
3. When a startup changes from active to acquired, all of its previously acquired startups become active.
For example, the following scenario can happen: Let's say A, B are active startups. C, D, E are acquired startups under A, and F, G are acquired startups under B:
<image>
Active startups are shown in red.
If A acquires B, then the state will be A, F, G are active startups. C, D, E, B are acquired startups under A. F and G have no acquired startups:
<image>
If instead, B acquires A, then the state will be B, C, D, E are active startups. F, G, A are acquired startups under B. C, D, E have no acquired startups:
<image>
You are given the initial state of the startups. For each startup, you are told if it is either acquired or active. If it is acquired, you are also given the index of the active startup that it is following.
You're now wondering, what is the expected number of days needed for this process to finish with exactly one active startup at the end.
It can be shown the expected number of days can be written as a rational number P/Q, where P and Q are co-prime integers, and Q not= 0 \pmod{10^9+7}. Return the value of P ⋅ Q^{-1} modulo 10^9+7.
Input
The first line contains a single integer n (2 ≤ n ≤ 500), the number of startups.
The next line will contain n space-separated integers a_1, a_2, …, a_n (a_i = -1 or 1 ≤ a_i ≤ n). If a_i = -1, then that means startup i is active. Otherwise, if 1 ≤ a_i ≤ n, then startup i is acquired, and it is currently following startup a_i. It is guaranteed if a_i not= -1, then a_{a_i} =-1 (that is, all startups that are being followed are active).
Output
Print a single integer, the expected number of days needed for the process to end with exactly one active startup, modulo 10^9+7.
Examples
Input
3
-1 -1 -1
Output
3
Input
2
2 -1
Output
0
Input
40
3 3 -1 -1 4 4 -1 -1 -1 -1 -1 10 10 10 10 10 10 4 20 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 3 3 3 3 3 3 3 3
Output
755808950
Note
In the first sample, there are three active startups labeled 1, 2 and 3, and zero acquired startups. Here's an example of how one scenario can happen
1. Startup 1 acquires startup 2 (This state can be represented by the array [-1, 1, -1])
2. Startup 3 acquires startup 1 (This state can be represented by the array [3, -1, -1])
3. Startup 2 acquires startup 3 (This state can be represented by the array [-1, -1, 2]).
4. Startup 2 acquires startup 1 (This state can be represented by the array [2, -1, 2]).
At this point, there is only one active startup, and this sequence of steps took 4 days. It can be shown the expected number of days is 3.
For the second sample, there is only one active startup, so we need zero days.
For the last sample, remember to take the answer modulo 10^9+7.
Submitted Solution:
```
input();a=input().split();print((pow(2,len(a)-1)-1-sum(pow(2,a.count(x))-1for x in{*a}-{'-1'}))%(10**9+7))
``` | instruction | 0 | 68,925 | 14 | 137,850 |
Yes | output | 1 | 68,925 | 14 | 137,851 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n startups. Startups can be active or acquired. If a startup is acquired, then that means it has exactly one active startup that it is following. An active startup can have arbitrarily many acquired startups that are following it. An active startup cannot follow any other startup.
The following steps happen until there is exactly one active startup. The following sequence of steps takes exactly 1 day.
1. Two distinct active startups A, B, are chosen uniformly at random.
2. A fair coin is flipped, and with equal probability, A acquires B or B acquires A (i.e. if A acquires B, then that means B's state changes from active to acquired, and its starts following A).
3. When a startup changes from active to acquired, all of its previously acquired startups become active.
For example, the following scenario can happen: Let's say A, B are active startups. C, D, E are acquired startups under A, and F, G are acquired startups under B:
<image>
Active startups are shown in red.
If A acquires B, then the state will be A, F, G are active startups. C, D, E, B are acquired startups under A. F and G have no acquired startups:
<image>
If instead, B acquires A, then the state will be B, C, D, E are active startups. F, G, A are acquired startups under B. C, D, E have no acquired startups:
<image>
You are given the initial state of the startups. For each startup, you are told if it is either acquired or active. If it is acquired, you are also given the index of the active startup that it is following.
You're now wondering, what is the expected number of days needed for this process to finish with exactly one active startup at the end.
It can be shown the expected number of days can be written as a rational number P/Q, where P and Q are co-prime integers, and Q not= 0 \pmod{10^9+7}. Return the value of P ⋅ Q^{-1} modulo 10^9+7.
Input
The first line contains a single integer n (2 ≤ n ≤ 500), the number of startups.
The next line will contain n space-separated integers a_1, a_2, …, a_n (a_i = -1 or 1 ≤ a_i ≤ n). If a_i = -1, then that means startup i is active. Otherwise, if 1 ≤ a_i ≤ n, then startup i is acquired, and it is currently following startup a_i. It is guaranteed if a_i not= -1, then a_{a_i} =-1 (that is, all startups that are being followed are active).
Output
Print a single integer, the expected number of days needed for the process to end with exactly one active startup, modulo 10^9+7.
Examples
Input
3
-1 -1 -1
Output
3
Input
2
2 -1
Output
0
Input
40
3 3 -1 -1 4 4 -1 -1 -1 -1 -1 10 10 10 10 10 10 4 20 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 3 3 3 3 3 3 3 3
Output
755808950
Note
In the first sample, there are three active startups labeled 1, 2 and 3, and zero acquired startups. Here's an example of how one scenario can happen
1. Startup 1 acquires startup 2 (This state can be represented by the array [-1, 1, -1])
2. Startup 3 acquires startup 1 (This state can be represented by the array [3, -1, -1])
3. Startup 2 acquires startup 3 (This state can be represented by the array [-1, -1, 2]).
4. Startup 2 acquires startup 1 (This state can be represented by the array [2, -1, 2]).
At this point, there is only one active startup, and this sequence of steps took 4 days. It can be shown the expected number of days is 3.
For the second sample, there is only one active startup, so we need zero days.
For the last sample, remember to take the answer modulo 10^9+7.
Submitted Solution:
```
m = 1000000007
n = int(input())
a = list(map(int, input().split()))
print(pow(2,n-1,m)-1 - sum(pow(2,a.count(x),m)-1 for x in set(a) if x != -1) % m)
``` | instruction | 0 | 68,926 | 14 | 137,852 |
No | output | 1 | 68,926 | 14 | 137,853 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Please pay attention to the unusual memory limit in this problem.
In a parallel universe, Satan is called "Trygub". For that reason, the letters of his namesake were deleted from the alphabet in ancient times.
The government has n workers standing in a row and numbered with integers from 1 to n from left to right. Their job categories can be represented as a string s of length n, where the character s_i represents the job category of the i-th worker.
A new law will be approved to increase the equality between the workers. The government decided to make everyone have the same job category by performing the following operation any number of times (possibly zero).
There is a fixed rational parameter k=\frac ab describing how easy it is to convince the public, and it will be used to determine the success of an operation.
In an operation, the government first selects a job category x with at least one worker at the current moment. Suppose i_1,…, i_m (i_1<…<i_m) are the positions of all the workers with job category x. If k⋅ (i_m-i_1+1)≤ m, the government is able to choose any job category y with at least one worker at the current moment and change the job category of all workers with job category x to job category y.
If it is possible to make all workers have job category x, we say that x is obtainable. Can you tell the government the set of obtainable job categories?
Input
The first line contains three integers n, a, b (1 ≤ n ≤ 5000, 1≤ a≤ b≤ 10^5) — the number of workers and the numerator and denominator of the parameter k, respectively.
The second line contains a string s of length n, consisting of lowercase English characters — the job categories of each worker. The characters 't', 'r', 'y', 'g', 'u', and 'b' do not appear in the string s.
Output
Print an integer c equal to the number of obtainable job categories followed by c space-separated characters — the obtainable job categories sorted in the lexicographical order.
Example
Input
7 1 2
comicom
Output
3 c m o
Note
The first operation must select the job category 'i' because all other job categories cannot satisfy the condition, therefore 'i' is not obtainable.
Below is showed how to obtain 'c', 'm', and 'o'. The square brackets denote the segment containing all workers of the selected category, the red color denotes this category and the blue color denotes the new category after the change.
* Get 'c':
1. (com\color{red}{[i]}com → com\color{#1E90FF}{[o]}com)
2. (c\color{red}{[o}m\color{red}{o}c\color{red}{o]}m → c\color{#1E90FF}{[m}m\color{#1E90FF}{m}c\color{#1E90FF}{m]}m)
3. (c\color{red}{[mmm}c\color{red}{mm]} → c\color{#1E90FF}{[ccc}c\color{#1E90FF}{cc]})
* Get 'm':
1. (com\color{red}{[i]}com → com\color{#1E90FF}{[o]}com)
2. (c\color{red}{[o}m\color{red}{o}c\color{red}{o]}m → c\color{#1E90FF}{[c}m\color{#1E90FF}{c}c\color{#1E90FF}{c]}m)
3. (\color{red}{[cc}m\color{red}{ccc]}m → \color{#1E90FF}{[mm}m\color{#1E90FF}{mmm]}m)
* Get 'o':
1. (com\color{red}{[i]}com → com\color{#1E90FF}{[c]}com)
2. (\color{red}{[c}om\color{red}{cc]}om → \color{#1E90FF}{[m}om\color{#1E90FF}{mm]}om)
3. (\color{red}{[m}o\color{red}{mmm}o\color{red}{m]} → \color{#1E90FF}{[o}o\color{#1E90FF}{ooo}o\color{#1E90FF}{o]})
Submitted Solution:
```
n,a,b = list(map(int,input().split()))
s = input()
jobs={}
ratio = a/b
f_c = 0
for i in range(n):
if s[i] in jobs:
continue
for j in range(n-1, i, -1):
if s[j] == s[i]:
m = j+1
if not ratio*(j-i+1)<=j+1:
f_c += 1
if f_c >= 2:
break
jobs[s[i]] = [j+1, ratio*(j-i+1)<=j+1]
break
if f_c >= 2:
break
if not s[i] in jobs:
jobs[s[i]] = [-1, True]
if f_c <= 1:
g = list(sorted([i for i in jobs if jobs[i][1] and jobs[i][0]!=-1]))
print("{} {}".format(len(g), " ".join(g)))
else:
print("0")
``` | instruction | 0 | 69,153 | 14 | 138,306 |
No | output | 1 | 69,153 | 14 | 138,307 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Please pay attention to the unusual memory limit in this problem.
In a parallel universe, Satan is called "Trygub". For that reason, the letters of his namesake were deleted from the alphabet in ancient times.
The government has n workers standing in a row and numbered with integers from 1 to n from left to right. Their job categories can be represented as a string s of length n, where the character s_i represents the job category of the i-th worker.
A new law will be approved to increase the equality between the workers. The government decided to make everyone have the same job category by performing the following operation any number of times (possibly zero).
There is a fixed rational parameter k=\frac ab describing how easy it is to convince the public, and it will be used to determine the success of an operation.
In an operation, the government first selects a job category x with at least one worker at the current moment. Suppose i_1,…, i_m (i_1<…<i_m) are the positions of all the workers with job category x. If k⋅ (i_m-i_1+1)≤ m, the government is able to choose any job category y with at least one worker at the current moment and change the job category of all workers with job category x to job category y.
If it is possible to make all workers have job category x, we say that x is obtainable. Can you tell the government the set of obtainable job categories?
Input
The first line contains three integers n, a, b (1 ≤ n ≤ 5000, 1≤ a≤ b≤ 10^5) — the number of workers and the numerator and denominator of the parameter k, respectively.
The second line contains a string s of length n, consisting of lowercase English characters — the job categories of each worker. The characters 't', 'r', 'y', 'g', 'u', and 'b' do not appear in the string s.
Output
Print an integer c equal to the number of obtainable job categories followed by c space-separated characters — the obtainable job categories sorted in the lexicographical order.
Example
Input
7 1 2
comicom
Output
3 c m o
Note
The first operation must select the job category 'i' because all other job categories cannot satisfy the condition, therefore 'i' is not obtainable.
Below is showed how to obtain 'c', 'm', and 'o'. The square brackets denote the segment containing all workers of the selected category, the red color denotes this category and the blue color denotes the new category after the change.
* Get 'c':
1. (com\color{red}{[i]}com → com\color{#1E90FF}{[o]}com)
2. (c\color{red}{[o}m\color{red}{o}c\color{red}{o]}m → c\color{#1E90FF}{[m}m\color{#1E90FF}{m}c\color{#1E90FF}{m]}m)
3. (c\color{red}{[mmm}c\color{red}{mm]} → c\color{#1E90FF}{[ccc}c\color{#1E90FF}{cc]})
* Get 'm':
1. (com\color{red}{[i]}com → com\color{#1E90FF}{[o]}com)
2. (c\color{red}{[o}m\color{red}{o}c\color{red}{o]}m → c\color{#1E90FF}{[c}m\color{#1E90FF}{c}c\color{#1E90FF}{c]}m)
3. (\color{red}{[cc}m\color{red}{ccc]}m → \color{#1E90FF}{[mm}m\color{#1E90FF}{mmm]}m)
* Get 'o':
1. (com\color{red}{[i]}com → com\color{#1E90FF}{[c]}com)
2. (\color{red}{[c}om\color{red}{cc]}om → \color{#1E90FF}{[m}om\color{#1E90FF}{mm]}om)
3. (\color{red}{[m}o\color{red}{mmm}o\color{red}{m]} → \color{#1E90FF}{[o}o\color{#1E90FF}{ooo}o\color{#1E90FF}{o]})
Submitted Solution:
```
n,a,b = list(map(int,input().split()))
s = input()
jobs={}
ratio = a/b
f_c = 0
for i in range(n):
if s[i] in jobs:
continue
for j in range(n-1, i, -1):
if s[j] == s[i]:
m = j+1
if not ratio*(j-i+1)<=j+1:
f_c += 1
if f_c >= 2:
break
jobs[s[i]] = [j+1, ratio*(j-i+1)<=j+1]
break
if f_c >= 2:
break
if not s[i] in jobs:
jobs[s[i]] = [-1, True]
if f_c == 1:
print("{} {}".format(1, "".join([i for i in jobs if not jobs[i][1]])))
elif f_c == 0:
g = list(sorted([i for i in jobs if jobs[i][1] and jobs[i][0]!=-1]))
print("{} {}".format(len(g), " ".join(g)))
else:
print("0")
``` | instruction | 0 | 69,154 | 14 | 138,308 |
No | output | 1 | 69,154 | 14 | 138,309 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Xenia the vigorous detective faced n (n ≥ 2) foreign spies lined up in a row. We'll consider the spies numbered from 1 to n from left to right.
Spy s has an important note. He has to pass the note to spy f. Xenia interrogates the spies in several steps. During one step the spy keeping the important note can pass the note to one of his neighbours in the row. In other words, if this spy's number is x, he can pass the note to another spy, either x - 1 or x + 1 (if x = 1 or x = n, then the spy has only one neighbour). Also during a step the spy can keep a note and not pass it to anyone.
But nothing is that easy. During m steps Xenia watches some spies attentively. Specifically, during step ti (steps are numbered from 1) Xenia watches spies numbers li, li + 1, li + 2, ..., ri (1 ≤ li ≤ ri ≤ n). Of course, if during some step a spy is watched, he can't do anything: neither give the note nor take it from some other spy. Otherwise, Xenia reveals the spies' cunning plot. Nevertheless, if the spy at the current step keeps the note, Xenia sees nothing suspicious even if she watches him.
You've got s and f. Also, you have the steps during which Xenia watches spies and which spies she is going to watch during each step. Find the best way the spies should act in order to pass the note from spy s to spy f as quickly as possible (in the minimum number of steps).
Input
The first line contains four integers n, m, s and f (1 ≤ n, m ≤ 105; 1 ≤ s, f ≤ n; s ≠ f; n ≥ 2). Each of the following m lines contains three integers ti, li, ri (1 ≤ ti ≤ 109, 1 ≤ li ≤ ri ≤ n). It is guaranteed that t1 < t2 < t3 < ... < tm.
Output
Print k characters in a line: the i-th character in the line must represent the spies' actions on step i. If on step i the spy with the note must pass the note to the spy with a lesser number, the i-th character should equal "L". If on step i the spy with the note must pass it to the spy with a larger number, the i-th character must equal "R". If the spy must keep the note at the i-th step, the i-th character must equal "X".
As a result of applying the printed sequence of actions spy s must pass the note to spy f. The number of printed characters k must be as small as possible. Xenia must not catch the spies passing the note.
If there are miltiple optimal solutions, you can print any of them. It is guaranteed that the answer exists.
Examples
Input
3 5 1 3
1 1 2
2 2 3
3 3 3
4 1 1
10 1 3
Output
XXRR | instruction | 0 | 69,281 | 14 | 138,562 |
Tags: brute force, greedy, implementation
Correct Solution:
```
while True:
try:
def soln(n, m, s, t, stp):
stp.sort()
flg = True
if s > t:
flg = False
i = 1
j = 0
ans = []
while True:
fund = False
while j < m:
if stp[j][0] == i:
j += 1
fund = True
break
if fund and not flg:
a= max(stp[j-1][1], stp[j-1][2])
b = min(stp[j-1][1], stp[j-1][2])
if ( s <= a) and ( s >=b):
ans.append('X')
elif s-1 <= a and s-1 >=b:
ans.append('X')
else:
ans.append('L')
s -= 1
elif fund and flg:
a= min(stp[j-1][1], stp[j-1][2])
b = max(stp[j-1][1], stp[j-1][2])
if ( s >=a) and ( s <=b):
ans.append('X')
elif ( s+1 >=a) and ( s+1 <=b):
ans.append('X')
else:
ans.append('R')
s += 1
elif flg:
ans.append("R")
s += 1
else:
ans.append("L")
s -= 1
if s == t:
break
i += 1
print("".join(ans))
def read():
n, m, s, t = map(int,input().split())
stp = []
for i in range(m):
a, b, c = map(int, input().split())
stp.append([a,b,c])
soln(n, m, s, t, stp)
if __name__ == "__main__":
read()
except EOFError:
break
``` | output | 1 | 69,281 | 14 | 138,563 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Xenia the vigorous detective faced n (n ≥ 2) foreign spies lined up in a row. We'll consider the spies numbered from 1 to n from left to right.
Spy s has an important note. He has to pass the note to spy f. Xenia interrogates the spies in several steps. During one step the spy keeping the important note can pass the note to one of his neighbours in the row. In other words, if this spy's number is x, he can pass the note to another spy, either x - 1 or x + 1 (if x = 1 or x = n, then the spy has only one neighbour). Also during a step the spy can keep a note and not pass it to anyone.
But nothing is that easy. During m steps Xenia watches some spies attentively. Specifically, during step ti (steps are numbered from 1) Xenia watches spies numbers li, li + 1, li + 2, ..., ri (1 ≤ li ≤ ri ≤ n). Of course, if during some step a spy is watched, he can't do anything: neither give the note nor take it from some other spy. Otherwise, Xenia reveals the spies' cunning plot. Nevertheless, if the spy at the current step keeps the note, Xenia sees nothing suspicious even if she watches him.
You've got s and f. Also, you have the steps during which Xenia watches spies and which spies she is going to watch during each step. Find the best way the spies should act in order to pass the note from spy s to spy f as quickly as possible (in the minimum number of steps).
Input
The first line contains four integers n, m, s and f (1 ≤ n, m ≤ 105; 1 ≤ s, f ≤ n; s ≠ f; n ≥ 2). Each of the following m lines contains three integers ti, li, ri (1 ≤ ti ≤ 109, 1 ≤ li ≤ ri ≤ n). It is guaranteed that t1 < t2 < t3 < ... < tm.
Output
Print k characters in a line: the i-th character in the line must represent the spies' actions on step i. If on step i the spy with the note must pass the note to the spy with a lesser number, the i-th character should equal "L". If on step i the spy with the note must pass it to the spy with a larger number, the i-th character must equal "R". If the spy must keep the note at the i-th step, the i-th character must equal "X".
As a result of applying the printed sequence of actions spy s must pass the note to spy f. The number of printed characters k must be as small as possible. Xenia must not catch the spies passing the note.
If there are miltiple optimal solutions, you can print any of them. It is guaranteed that the answer exists.
Examples
Input
3 5 1 3
1 1 2
2 2 3
3 3 3
4 1 1
10 1 3
Output
XXRR | instruction | 0 | 69,282 | 14 | 138,564 |
Tags: brute force, greedy, implementation
Correct Solution:
```
n,m,s,f=list(map(int,input().split()));
d={};
for i in range(m):
t,l,r=list(map(int,input().split()));
d[t]=[l,r];
ans="";
for i in range(1,n+m):
if(s==f):
print(ans);
exit(0);
t=-1;
if(f<s):
t=s-1;
else:
t=s+1;
if i in d:
if((d[i][0]<=s and s<=d[i][1]) or (d[i][0]<=t and t<=d[i][1])):
t=-1;
if(t==-1):
ans+="X";
else:
if(f<s):
ans+="L";
else:
ans+="R";
s=t;
print(ans);
``` | output | 1 | 69,282 | 14 | 138,565 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Xenia the vigorous detective faced n (n ≥ 2) foreign spies lined up in a row. We'll consider the spies numbered from 1 to n from left to right.
Spy s has an important note. He has to pass the note to spy f. Xenia interrogates the spies in several steps. During one step the spy keeping the important note can pass the note to one of his neighbours in the row. In other words, if this spy's number is x, he can pass the note to another spy, either x - 1 or x + 1 (if x = 1 or x = n, then the spy has only one neighbour). Also during a step the spy can keep a note and not pass it to anyone.
But nothing is that easy. During m steps Xenia watches some spies attentively. Specifically, during step ti (steps are numbered from 1) Xenia watches spies numbers li, li + 1, li + 2, ..., ri (1 ≤ li ≤ ri ≤ n). Of course, if during some step a spy is watched, he can't do anything: neither give the note nor take it from some other spy. Otherwise, Xenia reveals the spies' cunning plot. Nevertheless, if the spy at the current step keeps the note, Xenia sees nothing suspicious even if she watches him.
You've got s and f. Also, you have the steps during which Xenia watches spies and which spies she is going to watch during each step. Find the best way the spies should act in order to pass the note from spy s to spy f as quickly as possible (in the minimum number of steps).
Input
The first line contains four integers n, m, s and f (1 ≤ n, m ≤ 105; 1 ≤ s, f ≤ n; s ≠ f; n ≥ 2). Each of the following m lines contains three integers ti, li, ri (1 ≤ ti ≤ 109, 1 ≤ li ≤ ri ≤ n). It is guaranteed that t1 < t2 < t3 < ... < tm.
Output
Print k characters in a line: the i-th character in the line must represent the spies' actions on step i. If on step i the spy with the note must pass the note to the spy with a lesser number, the i-th character should equal "L". If on step i the spy with the note must pass it to the spy with a larger number, the i-th character must equal "R". If the spy must keep the note at the i-th step, the i-th character must equal "X".
As a result of applying the printed sequence of actions spy s must pass the note to spy f. The number of printed characters k must be as small as possible. Xenia must not catch the spies passing the note.
If there are miltiple optimal solutions, you can print any of them. It is guaranteed that the answer exists.
Examples
Input
3 5 1 3
1 1 2
2 2 3
3 3 3
4 1 1
10 1 3
Output
XXRR | instruction | 0 | 69,283 | 14 | 138,566 |
Tags: brute force, greedy, implementation
Correct Solution:
```
#------------------------template--------------------------#
import os
import sys
from math import *
from collections import *
# from fractions import *
# from heapq import*
from bisect import *
from io import BytesIO, IOBase
def vsInput():
sys.stdin = open('input.txt', 'r')
sys.stdout = open('output.txt', 'w')
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")
ALPHA='abcdefghijklmnopqrstuvwxyz/'
M=998244353
EPS=1e-6
def Ceil(a,b): return a//b+int(a%b>0)
def value():return tuple(map(int,input().split()))
def array():return [int(i) for i in input().split()]
def Int():return int(input())
def Str():return input()
def arrayS():return [i for i in input().split()]
#-------------------------code---------------------------#
# vsInput()
n,m,s,d=value()
move=1
if(d<s):move=0
last=0
cur=s
ans=[]
given=[]
for i in range(m):given.append(value())
# print(given)
for t,l,r in given:
if(t-1!=last):
have=t-last-1
need=abs(d-cur)
if(move):
ans.extend(['R' for i in range(min(need,have))])
cur+=min(need,have)
else:
ans.extend(['L' for i in range(min(need,have))])
cur-=min(need,have)
if(cur==d): break
if(move):
if(cur+1<l or cur>r):
ans.append('R')
cur+=1
else: ans.append('X')
else:
if(cur<l or cur-1>r):
ans.append('L')
cur-=1
else: ans.append('X')
last=t
if(cur!=d):
need=abs(d-cur)
have=inf
if(move): ans.extend(['R' for i in range(min(need,have))])
else: ans.extend(['L' for i in range(min(need,have))])
print(*ans,sep="")
``` | output | 1 | 69,283 | 14 | 138,567 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Xenia the vigorous detective faced n (n ≥ 2) foreign spies lined up in a row. We'll consider the spies numbered from 1 to n from left to right.
Spy s has an important note. He has to pass the note to spy f. Xenia interrogates the spies in several steps. During one step the spy keeping the important note can pass the note to one of his neighbours in the row. In other words, if this spy's number is x, he can pass the note to another spy, either x - 1 or x + 1 (if x = 1 or x = n, then the spy has only one neighbour). Also during a step the spy can keep a note and not pass it to anyone.
But nothing is that easy. During m steps Xenia watches some spies attentively. Specifically, during step ti (steps are numbered from 1) Xenia watches spies numbers li, li + 1, li + 2, ..., ri (1 ≤ li ≤ ri ≤ n). Of course, if during some step a spy is watched, he can't do anything: neither give the note nor take it from some other spy. Otherwise, Xenia reveals the spies' cunning plot. Nevertheless, if the spy at the current step keeps the note, Xenia sees nothing suspicious even if she watches him.
You've got s and f. Also, you have the steps during which Xenia watches spies and which spies she is going to watch during each step. Find the best way the spies should act in order to pass the note from spy s to spy f as quickly as possible (in the minimum number of steps).
Input
The first line contains four integers n, m, s and f (1 ≤ n, m ≤ 105; 1 ≤ s, f ≤ n; s ≠ f; n ≥ 2). Each of the following m lines contains three integers ti, li, ri (1 ≤ ti ≤ 109, 1 ≤ li ≤ ri ≤ n). It is guaranteed that t1 < t2 < t3 < ... < tm.
Output
Print k characters in a line: the i-th character in the line must represent the spies' actions on step i. If on step i the spy with the note must pass the note to the spy with a lesser number, the i-th character should equal "L". If on step i the spy with the note must pass it to the spy with a larger number, the i-th character must equal "R". If the spy must keep the note at the i-th step, the i-th character must equal "X".
As a result of applying the printed sequence of actions spy s must pass the note to spy f. The number of printed characters k must be as small as possible. Xenia must not catch the spies passing the note.
If there are miltiple optimal solutions, you can print any of them. It is guaranteed that the answer exists.
Examples
Input
3 5 1 3
1 1 2
2 2 3
3 3 3
4 1 1
10 1 3
Output
XXRR | instruction | 0 | 69,284 | 14 | 138,568 |
Tags: brute force, greedy, implementation
Correct Solution:
```
R = lambda: map(int, input().split())
n, m, s, f = R()
if s < f:
d = 1
c = 'R'
else:
d = -1
c = 'L'
res = ""
i = 1
j = s
t, l, r = R()
k = 1
while j != f:
if i > t and k < m:
t, l, r = R()
k += 1
if i == t and (l <= j <= r or l <= j + d <= r):
res += 'X'
else:
res += c
j += d
i += 1
print(res)
``` | output | 1 | 69,284 | 14 | 138,569 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Xenia the vigorous detective faced n (n ≥ 2) foreign spies lined up in a row. We'll consider the spies numbered from 1 to n from left to right.
Spy s has an important note. He has to pass the note to spy f. Xenia interrogates the spies in several steps. During one step the spy keeping the important note can pass the note to one of his neighbours in the row. In other words, if this spy's number is x, he can pass the note to another spy, either x - 1 or x + 1 (if x = 1 or x = n, then the spy has only one neighbour). Also during a step the spy can keep a note and not pass it to anyone.
But nothing is that easy. During m steps Xenia watches some spies attentively. Specifically, during step ti (steps are numbered from 1) Xenia watches spies numbers li, li + 1, li + 2, ..., ri (1 ≤ li ≤ ri ≤ n). Of course, if during some step a spy is watched, he can't do anything: neither give the note nor take it from some other spy. Otherwise, Xenia reveals the spies' cunning plot. Nevertheless, if the spy at the current step keeps the note, Xenia sees nothing suspicious even if she watches him.
You've got s and f. Also, you have the steps during which Xenia watches spies and which spies she is going to watch during each step. Find the best way the spies should act in order to pass the note from spy s to spy f as quickly as possible (in the minimum number of steps).
Input
The first line contains four integers n, m, s and f (1 ≤ n, m ≤ 105; 1 ≤ s, f ≤ n; s ≠ f; n ≥ 2). Each of the following m lines contains three integers ti, li, ri (1 ≤ ti ≤ 109, 1 ≤ li ≤ ri ≤ n). It is guaranteed that t1 < t2 < t3 < ... < tm.
Output
Print k characters in a line: the i-th character in the line must represent the spies' actions on step i. If on step i the spy with the note must pass the note to the spy with a lesser number, the i-th character should equal "L". If on step i the spy with the note must pass it to the spy with a larger number, the i-th character must equal "R". If the spy must keep the note at the i-th step, the i-th character must equal "X".
As a result of applying the printed sequence of actions spy s must pass the note to spy f. The number of printed characters k must be as small as possible. Xenia must not catch the spies passing the note.
If there are miltiple optimal solutions, you can print any of them. It is guaranteed that the answer exists.
Examples
Input
3 5 1 3
1 1 2
2 2 3
3 3 3
4 1 1
10 1 3
Output
XXRR | instruction | 0 | 69,285 | 14 | 138,570 |
Tags: brute force, greedy, implementation
Correct Solution:
```
n, m, s, f = [int(x) for x in input().split()]
now = 1
d = 1 if f > s else -1
step = 'R' if d == 1 else 'L'
ret = ""
for _ in range(m):
t, l, r = [int(x) for x in input().split()]
if t > now:
flag = False
while t > now:
s += d
ret += step
now += 1
if s == f:
flag = True
break
if flag:
break
if l <= s <= r or l <= s+d <= r:
ret += 'X'
else:
ret += step
s += d
if s == f:
break
now += 1
while s != f:
s += d
ret += step
print(ret)
``` | output | 1 | 69,285 | 14 | 138,571 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Xenia the vigorous detective faced n (n ≥ 2) foreign spies lined up in a row. We'll consider the spies numbered from 1 to n from left to right.
Spy s has an important note. He has to pass the note to spy f. Xenia interrogates the spies in several steps. During one step the spy keeping the important note can pass the note to one of his neighbours in the row. In other words, if this spy's number is x, he can pass the note to another spy, either x - 1 or x + 1 (if x = 1 or x = n, then the spy has only one neighbour). Also during a step the spy can keep a note and not pass it to anyone.
But nothing is that easy. During m steps Xenia watches some spies attentively. Specifically, during step ti (steps are numbered from 1) Xenia watches spies numbers li, li + 1, li + 2, ..., ri (1 ≤ li ≤ ri ≤ n). Of course, if during some step a spy is watched, he can't do anything: neither give the note nor take it from some other spy. Otherwise, Xenia reveals the spies' cunning plot. Nevertheless, if the spy at the current step keeps the note, Xenia sees nothing suspicious even if she watches him.
You've got s and f. Also, you have the steps during which Xenia watches spies and which spies she is going to watch during each step. Find the best way the spies should act in order to pass the note from spy s to spy f as quickly as possible (in the minimum number of steps).
Input
The first line contains four integers n, m, s and f (1 ≤ n, m ≤ 105; 1 ≤ s, f ≤ n; s ≠ f; n ≥ 2). Each of the following m lines contains three integers ti, li, ri (1 ≤ ti ≤ 109, 1 ≤ li ≤ ri ≤ n). It is guaranteed that t1 < t2 < t3 < ... < tm.
Output
Print k characters in a line: the i-th character in the line must represent the spies' actions on step i. If on step i the spy with the note must pass the note to the spy with a lesser number, the i-th character should equal "L". If on step i the spy with the note must pass it to the spy with a larger number, the i-th character must equal "R". If the spy must keep the note at the i-th step, the i-th character must equal "X".
As a result of applying the printed sequence of actions spy s must pass the note to spy f. The number of printed characters k must be as small as possible. Xenia must not catch the spies passing the note.
If there are miltiple optimal solutions, you can print any of them. It is guaranteed that the answer exists.
Examples
Input
3 5 1 3
1 1 2
2 2 3
3 3 3
4 1 1
10 1 3
Output
XXRR | instruction | 0 | 69,286 | 14 | 138,572 |
Tags: brute force, greedy, implementation
Correct Solution:
```
import sys
n,m,s,f=map(int,sys.stdin.readline().split())
L=[]
R=[]
T=[]
for i in range(m):
t,l,r=map(int,sys.stdin.readline().split())
T.append(t)
L.append(l)
R.append(r)
if(f>s):
i=s
step=1
ind=0
Ans=""
while(i!=f):
if(ind>=m or T[ind]!=step):
Ans+="R"
i+=1
else:
if((i>=L[ind] and i<=R[ind]) or (i+1>=L[ind] and i+1<=R[ind])):
Ans+="X"
else:
Ans+="R"
i+=1
ind+=1
step+=1
else:
i=s
step=1
ind=0
Ans=""
while(i!=f):
if(ind>=m or T[ind]!=step):
Ans+="L"
i-=1
else:
if((i>=L[ind] and i<=R[ind]) or (i-1>=L[ind] and i-1<=R[ind])):
Ans+="X"
else:
Ans+="L"
i-=1
ind+=1
step+=1
sys.stdout.write(Ans+"\n")
``` | output | 1 | 69,286 | 14 | 138,573 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Xenia the vigorous detective faced n (n ≥ 2) foreign spies lined up in a row. We'll consider the spies numbered from 1 to n from left to right.
Spy s has an important note. He has to pass the note to spy f. Xenia interrogates the spies in several steps. During one step the spy keeping the important note can pass the note to one of his neighbours in the row. In other words, if this spy's number is x, he can pass the note to another spy, either x - 1 or x + 1 (if x = 1 or x = n, then the spy has only one neighbour). Also during a step the spy can keep a note and not pass it to anyone.
But nothing is that easy. During m steps Xenia watches some spies attentively. Specifically, during step ti (steps are numbered from 1) Xenia watches spies numbers li, li + 1, li + 2, ..., ri (1 ≤ li ≤ ri ≤ n). Of course, if during some step a spy is watched, he can't do anything: neither give the note nor take it from some other spy. Otherwise, Xenia reveals the spies' cunning plot. Nevertheless, if the spy at the current step keeps the note, Xenia sees nothing suspicious even if she watches him.
You've got s and f. Also, you have the steps during which Xenia watches spies and which spies she is going to watch during each step. Find the best way the spies should act in order to pass the note from spy s to spy f as quickly as possible (in the minimum number of steps).
Input
The first line contains four integers n, m, s and f (1 ≤ n, m ≤ 105; 1 ≤ s, f ≤ n; s ≠ f; n ≥ 2). Each of the following m lines contains three integers ti, li, ri (1 ≤ ti ≤ 109, 1 ≤ li ≤ ri ≤ n). It is guaranteed that t1 < t2 < t3 < ... < tm.
Output
Print k characters in a line: the i-th character in the line must represent the spies' actions on step i. If on step i the spy with the note must pass the note to the spy with a lesser number, the i-th character should equal "L". If on step i the spy with the note must pass it to the spy with a larger number, the i-th character must equal "R". If the spy must keep the note at the i-th step, the i-th character must equal "X".
As a result of applying the printed sequence of actions spy s must pass the note to spy f. The number of printed characters k must be as small as possible. Xenia must not catch the spies passing the note.
If there are miltiple optimal solutions, you can print any of them. It is guaranteed that the answer exists.
Examples
Input
3 5 1 3
1 1 2
2 2 3
3 3 3
4 1 1
10 1 3
Output
XXRR | instruction | 0 | 69,287 | 14 | 138,574 |
Tags: brute force, greedy, implementation
Correct Solution:
```
n,m,s,f=list(map(int,input().split()))
if s>f:
a='L'
c=-1
elif s==f:
a='X'
c=0
else:
a='R'
c=1
l=[]
for i in range(m):
l.append(list(map(int,input().split())))
ans=''
if l[0][0]!=1:
d=l[0][0]-1
while s!=f and d>0:
s=s+c
ans=ans+a
d=d-1
for i in range(m):
if s==f:
break
if i==0:
if (s>=l[i][1] and s<=l[i][2]) or (s+c>=l[i][1] and s+c<=l[i][2]):
ans=ans+'X'
else:
ans=ans+a
s=s+c
else:
if l[i][0]-l[i-1][0]==1:
if (s>=l[i][1] and s<=l[i][2]) or (s+c>=l[i][1] and s+c<=l[i][2]):
ans=ans+'X'
else:
ans=ans+a
s=s+c
else:
d=l[i][0]-l[i-1][0]-1
while s!=f and d>0:
s=s+c
ans=ans+a
d=d-1
if s==f:
break
if (s>=l[i][1] and s<=l[i][2]) or (s+c>=l[i][1] and s+c<=l[i][2]):
ans=ans+'X'
else:
ans=ans+a
s=s+c
if s==f:
break
if s!=f:
while s!=f:
ans=ans+a
s=s+c
print(ans)
``` | output | 1 | 69,287 | 14 | 138,575 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Xenia the vigorous detective faced n (n ≥ 2) foreign spies lined up in a row. We'll consider the spies numbered from 1 to n from left to right.
Spy s has an important note. He has to pass the note to spy f. Xenia interrogates the spies in several steps. During one step the spy keeping the important note can pass the note to one of his neighbours in the row. In other words, if this spy's number is x, he can pass the note to another spy, either x - 1 or x + 1 (if x = 1 or x = n, then the spy has only one neighbour). Also during a step the spy can keep a note and not pass it to anyone.
But nothing is that easy. During m steps Xenia watches some spies attentively. Specifically, during step ti (steps are numbered from 1) Xenia watches spies numbers li, li + 1, li + 2, ..., ri (1 ≤ li ≤ ri ≤ n). Of course, if during some step a spy is watched, he can't do anything: neither give the note nor take it from some other spy. Otherwise, Xenia reveals the spies' cunning plot. Nevertheless, if the spy at the current step keeps the note, Xenia sees nothing suspicious even if she watches him.
You've got s and f. Also, you have the steps during which Xenia watches spies and which spies she is going to watch during each step. Find the best way the spies should act in order to pass the note from spy s to spy f as quickly as possible (in the minimum number of steps).
Input
The first line contains four integers n, m, s and f (1 ≤ n, m ≤ 105; 1 ≤ s, f ≤ n; s ≠ f; n ≥ 2). Each of the following m lines contains three integers ti, li, ri (1 ≤ ti ≤ 109, 1 ≤ li ≤ ri ≤ n). It is guaranteed that t1 < t2 < t3 < ... < tm.
Output
Print k characters in a line: the i-th character in the line must represent the spies' actions on step i. If on step i the spy with the note must pass the note to the spy with a lesser number, the i-th character should equal "L". If on step i the spy with the note must pass it to the spy with a larger number, the i-th character must equal "R". If the spy must keep the note at the i-th step, the i-th character must equal "X".
As a result of applying the printed sequence of actions spy s must pass the note to spy f. The number of printed characters k must be as small as possible. Xenia must not catch the spies passing the note.
If there are miltiple optimal solutions, you can print any of them. It is guaranteed that the answer exists.
Examples
Input
3 5 1 3
1 1 2
2 2 3
3 3 3
4 1 1
10 1 3
Output
XXRR | instruction | 0 | 69,288 | 14 | 138,576 |
Tags: brute force, greedy, implementation
Correct Solution:
```
n,m,s,f=map(int,input().split())
t=dict();
for i in range(m):
t1,l1,r1=map(int,input().split())
t[t1]=(l1,r1);
pos=s;i=1;
while(1):
if(pos==f):
break
if i in t:
if t[i][0] <= pos<=t[i][1]:
print('X',end='')
i+=1
continue
elif(f-pos>0 and t[i][0]<= pos+1<=t[i][1]):
print('X',end='')
i+=1
continue
elif(f-pos<0 and t[i][0] <= pos-1<=t[i][1]):
print('X',end='')
i+=1
continue
if(f-pos>0):
print('R',end='')
pos+=1
elif(pos-f>0):
print('L',end='')
pos-=1
i+=1
``` | output | 1 | 69,288 | 14 | 138,577 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Xenia the vigorous detective faced n (n ≥ 2) foreign spies lined up in a row. We'll consider the spies numbered from 1 to n from left to right.
Spy s has an important note. He has to pass the note to spy f. Xenia interrogates the spies in several steps. During one step the spy keeping the important note can pass the note to one of his neighbours in the row. In other words, if this spy's number is x, he can pass the note to another spy, either x - 1 or x + 1 (if x = 1 or x = n, then the spy has only one neighbour). Also during a step the spy can keep a note and not pass it to anyone.
But nothing is that easy. During m steps Xenia watches some spies attentively. Specifically, during step ti (steps are numbered from 1) Xenia watches spies numbers li, li + 1, li + 2, ..., ri (1 ≤ li ≤ ri ≤ n). Of course, if during some step a spy is watched, he can't do anything: neither give the note nor take it from some other spy. Otherwise, Xenia reveals the spies' cunning plot. Nevertheless, if the spy at the current step keeps the note, Xenia sees nothing suspicious even if she watches him.
You've got s and f. Also, you have the steps during which Xenia watches spies and which spies she is going to watch during each step. Find the best way the spies should act in order to pass the note from spy s to spy f as quickly as possible (in the minimum number of steps).
Input
The first line contains four integers n, m, s and f (1 ≤ n, m ≤ 105; 1 ≤ s, f ≤ n; s ≠ f; n ≥ 2). Each of the following m lines contains three integers ti, li, ri (1 ≤ ti ≤ 109, 1 ≤ li ≤ ri ≤ n). It is guaranteed that t1 < t2 < t3 < ... < tm.
Output
Print k characters in a line: the i-th character in the line must represent the spies' actions on step i. If on step i the spy with the note must pass the note to the spy with a lesser number, the i-th character should equal "L". If on step i the spy with the note must pass it to the spy with a larger number, the i-th character must equal "R". If the spy must keep the note at the i-th step, the i-th character must equal "X".
As a result of applying the printed sequence of actions spy s must pass the note to spy f. The number of printed characters k must be as small as possible. Xenia must not catch the spies passing the note.
If there are miltiple optimal solutions, you can print any of them. It is guaranteed that the answer exists.
Examples
Input
3 5 1 3
1 1 2
2 2 3
3 3 3
4 1 1
10 1 3
Output
XXRR
Submitted Solution:
```
n,m,s,f=map(int,input().split())
t={}
step=1
ans=''
if s<f:sig='R'
else :sig='L'
for i in range(m):
t0,l0,r0=map(int,input().split())
t[t0]=[l0,r0]
for i in range(1,n+m+1):
if s<f:
u=s+1
else:u=s-1
if i in t:
if (t[i][0]<=s<=t[i][1])or(t[i][0]<=u<=t[i][1]):
ans+='X'
else:
ans+=sig
s=u
else :
ans+=sig
s=u
if s==f:break
print(ans)
``` | instruction | 0 | 69,289 | 14 | 138,578 |
Yes | output | 1 | 69,289 | 14 | 138,579 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Xenia the vigorous detective faced n (n ≥ 2) foreign spies lined up in a row. We'll consider the spies numbered from 1 to n from left to right.
Spy s has an important note. He has to pass the note to spy f. Xenia interrogates the spies in several steps. During one step the spy keeping the important note can pass the note to one of his neighbours in the row. In other words, if this spy's number is x, he can pass the note to another spy, either x - 1 or x + 1 (if x = 1 or x = n, then the spy has only one neighbour). Also during a step the spy can keep a note and not pass it to anyone.
But nothing is that easy. During m steps Xenia watches some spies attentively. Specifically, during step ti (steps are numbered from 1) Xenia watches spies numbers li, li + 1, li + 2, ..., ri (1 ≤ li ≤ ri ≤ n). Of course, if during some step a spy is watched, he can't do anything: neither give the note nor take it from some other spy. Otherwise, Xenia reveals the spies' cunning plot. Nevertheless, if the spy at the current step keeps the note, Xenia sees nothing suspicious even if she watches him.
You've got s and f. Also, you have the steps during which Xenia watches spies and which spies she is going to watch during each step. Find the best way the spies should act in order to pass the note from spy s to spy f as quickly as possible (in the minimum number of steps).
Input
The first line contains four integers n, m, s and f (1 ≤ n, m ≤ 105; 1 ≤ s, f ≤ n; s ≠ f; n ≥ 2). Each of the following m lines contains three integers ti, li, ri (1 ≤ ti ≤ 109, 1 ≤ li ≤ ri ≤ n). It is guaranteed that t1 < t2 < t3 < ... < tm.
Output
Print k characters in a line: the i-th character in the line must represent the spies' actions on step i. If on step i the spy with the note must pass the note to the spy with a lesser number, the i-th character should equal "L". If on step i the spy with the note must pass it to the spy with a larger number, the i-th character must equal "R". If the spy must keep the note at the i-th step, the i-th character must equal "X".
As a result of applying the printed sequence of actions spy s must pass the note to spy f. The number of printed characters k must be as small as possible. Xenia must not catch the spies passing the note.
If there are miltiple optimal solutions, you can print any of them. It is guaranteed that the answer exists.
Examples
Input
3 5 1 3
1 1 2
2 2 3
3 3 3
4 1 1
10 1 3
Output
XXRR
Submitted Solution:
```
n, m, s, f = map(int, input().split())
if s < f:
step = "R"
step_i = 1
else:
step = "L"
step_i = -1
ans = []
tp = 0
for i in range(m):
t, l, r = map(int, input().split())
k = min(t - tp - 1, abs(f - s))
for j in range(k):
ans.append(step)
s += step_i * k
if s == f:
print("".join(ans))
break
if not l <= s + step_i <= r and not l <= s <= r:
s += step_i
ans.append(step)
else:
ans.append("X")
tp = t
else:
if s != f:
ans.extend([step] * abs(f - s))
print("".join(ans))
``` | instruction | 0 | 69,290 | 14 | 138,580 |
Yes | output | 1 | 69,290 | 14 | 138,581 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.