submission_id string | problem_id string | status string | code string | input string | output string | problem_description string |
|---|---|---|---|---|---|---|
s929227794 | p00296 | Runtime Error | # -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0301
WA
"""
import sys
from sys import stdin
from collections import deque
input = stdin.readline
def main(args):
# members = deque(list(range(10)))
# numbers = [2, 6, 5, 18, 3]
# queries = [3, 0, 5]
N, M, Q = map(in... | 10 5 3
2 6 5 18 3
3 0 5
| 1
0
1
|
<h1>バトンリレーゲーム</h1>
<p>
アカベ高校では、毎年全校生徒が参加するゲームを行っています。まず、校庭に <var>N</var> 人の全校生徒が円形に並びます。図のように、各生徒は 0 から <var>N</var>-1 までの番号が書かれたゼッケンを付けています。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE2_PCK2014_button" width="280">
</center>
<br>
<p>
ゲームではバトンを１本使い、最初はゼッケン 0 番の生徒がバトンを持っています。そこから、以... |
s967423596 | p00296 | Runtime Error | from bisect import bisect_left as bl
n, m, q = map(int, input().split())
lst = [i for i in range(n)]
alst = list(map(int, input().split()))
ind = 0
for a in alst:
if a % 2 == 0:
ind += a
else:
ind -= a
ind = ind % len(lst)
lst.pop(ind)
ind = ind % len(lst)
qlst = list(map(int, input().split()))
for ... | 10 5 3
2 6 5 18 3
3 0 5
| 1
0
1
|
<h1>バトンリレーゲーム</h1>
<p>
アカベ高校では、毎年全校生徒が参加するゲームを行っています。まず、校庭に <var>N</var> 人の全校生徒が円形に並びます。図のように、各生徒は 0 から <var>N</var>-1 までの番号が書かれたゼッケンを付けています。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE2_PCK2014_button" width="280">
</center>
<br>
<p>
ゲームではバトンを１本使い、最初はゼッケン 0 番の生徒がバトンを持っています。そこから、以... |
s962707785 | p00297 | Wrong Answer | class MinTree:
def __init__(self, iterable):
self.iter_size = self.get_size(iterable)
self.size = self.iter_size * 2 - 1
self.value = [None] * self.size
for i, v in enumerate(iterable):
self.value[self.iter_size + i - 1] = v
self.set_value(0)
self.range = [None] * self.size
self.set_... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s596804124 | p00297 | Wrong Answer | class MinTree:
def __init__(self, iterable):
self.iter_size = self.get_size(iterable)
self.size = self.iter_size * 2 - 1
self.value = [None] * self.size
for i, v in enumerate(iterable):
self.value[self.iter_size + i - 1] = v
self.set_value(0)
self.range = [None] * self.size
self.set_... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s758613816 | p00297 | Wrong Answer | def main():
INF = 10 ** 20
class MinTree:
def __init__(self, iterable):
self.iter_size = self.get_size(iterable)
self.size = self.iter_size * 2 - 1
self.value = [None] * self.size
for i, v in enumerate(iterable):
self.value[self.iter_size + i - 1] = v
self.set_value(0)
... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s340566840 | p00297 | Wrong Answer | def main():
INF = 10 ** 20
class MinTree:
def __init__(self, iterable):
self.iter_size = self.get_size(iterable)
self.size = self.iter_size * 2 - 1
self.value = [None] * self.size
for i, v in enumerate(iterable):
self.value[self.iter_size + i - 1] = v
self.set_value(0)
... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s500682196 | p00297 | Wrong Answer | def main():
INF = 10 ** 20
class MinTree:
def __init__(self, iterable):
self.iter_size = self.get_size(iterable)
self.size = self.iter_size * 2 - 1
self.value = [None] * self.size
for i, v in enumerate(iterable):
self.value[self.iter_size + i - 1] = v
self.set_value(0)
... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s236781384 | p00297 | Wrong Answer | import math
def segmentTree(dat, f, sentinel):
pad = 2 ** math.ceil(math.log(len(dat),2))
dat = [0] * pad + dat + [sentinel] * (pad - len(dat))
for i in range(pad - 1, 0, -1):
dat[i] = f(dat[i * 2:i * 2 + 2])
return dat
def get_lr(b,d):
l = r = 0
while r < len(b):
... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s611653781 | p00297 | Wrong Answer | data = map(int, raw_input().split())
stars = data[0]
lightrange = data[1]
a = []
for i in range(stars):
a.append(map(int, raw_input().split()))
a.sort(key=lambda x:x[2])
scale = 0
for j in range(len(a)):
minlight = a[0][2]
astars = []
for k in range(len(a)):
while(len(astars)<=2):
if... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s861279006 | p00297 | Wrong Answer | data = map(int, raw_input().split())
stars = data[0]
lightrange = data[1]
a = []
for i in range(stars):
a.append(map(int, raw_input().split()))
a.sort(key=lambda x:x[2])
scale = 0
for j in range(len(a)):
astars = []
for k in range(len(a)):
while(len(astars)<=2):
if (a[k][2] <= a[0][2] + ... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s266964025 | p00297 | Wrong Answer | data = map(int, raw_input().split())
stars = data[0]
lightrange = data[1]
a = []
for i in range(stars):
a.append(map(int, raw_input().split()))
a.sort(key=lambda x:x[2])
scale = 0
while(len(a)>1):
minx=maxx=a[0][0]
miny=maxy=a[0][1]
l=1
if (a[l][2] <= a[0][2] + lightrange):
if(a[l][0]<minx):... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s809872361 | p00297 | Wrong Answer | data = map(int, raw_input().split())
stars = data[0]
lightrange = data[1]
a = []
for i in range(stars):
a.append(map(int, raw_input().split()))
a.sort(key=lambda x:x[2])
scale = 0
while(len(a)>1):
if(a[0][2] + lightrange < a[1][2]):
break;
minx=maxx=a[0][0]
miny=maxy=a[0][1]
k=1
while(a[... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s653829834 | p00297 | Wrong Answer | data = map(int, raw_input().split())
stars = data[0]
lightrange = data[1]
a = []
for i in range(stars):
a.append(map(int, raw_input().split()))
x = [a[p][0] for p in range(stars)]
y = [a[q][1] for q in range(stars)]
light = [a[r][2] for r in range(stars)]
x.sort()
y.sort()
light.sort()
X=Y=[]
k=scale=0
for j in ran... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s874770156 | p00297 | Wrong Answer | from functools import reduce
class Bound:
min_x = 2000001
min_y = 2000001
max_x = -1
max_y = -1
def add(self, x, y):
if self.min_x > x: self.min_x = x
if self.min_y > y: self.min_y = y
if self.max_x < x: self.max_x = x
if self.max_y < y: self.max_y = y
def exp... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s014470603 | p00297 | Wrong Answer | from functools import reduce
from math import ceil, sqrt
from copy import copy
class Bound:
min_x = 2000001
min_y = 2000001
max_x = -1
max_y = -1
added = False
def add(self, x, y):
self.added = True
if self.min_x > x: self.min_x = x
if self.min_y > y: self.min_y = y
... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s117709481 | p00297 | Wrong Answer | from functools import reduce
from math import ceil, sqrt
from copy import copy
class Bound:
min_x = 2000001
min_y = 2000001
max_x = -1
max_y = -1
added = False
def add(self, x, y):
self.added = True
if self.min_x > x: self.min_x = x
if self.min_y > y: self.min_y = y
... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s412504747 | p00297 | Wrong Answer | from sys import stdin
from operator import itemgetter
def get_square(L):
if not L or len(L) == 0:return 0
x=[L[0][0][0],L[0][0][1]]
y=[L[0][1][0],L[0][1][1]]
for i in L:
if i[0][0] < x[0]:x[0] = i[0][0]
if i[0][1] > x[1]:x[1] = i[0][1]
if i[1][0] < y[0]:y[0] = i[1][0]
if i[1][1] > y[1]:y[1] = i... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s859067546 | p00297 | Wrong Answer | from sys import stdin
from operator import itemgetter
from itertools import takewhile
from random import randint
from array import array
def make_data(n):
return [str(randint(0,2000000))+' '+str(randint(0,2000000))+' '+str(randint(0,1e9))
for i in range(n)]
def get_square(x_min,x_max,y_min,y_max):
return (x... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s530970169 | p00297 | Wrong Answer | from sys import stdin
from operator import itemgetter
from itertools import takewhile
from random import randint
from array import array
def make_data(n):
return [str(randint(0,2000000))+' '+str(randint(0,2000000))+' '+str(randint(0,1e9))
for i in range(n)]
def get_square(x_min,x_max,y_min,y_max):
return (x... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s780433722 | p00297 | Wrong Answer | from bisect import bisect_left as bl
class Node:
def __init__(self, val, sec):
self.val = val
self.sec = sec
self.left = sec[0]
self.right = sec[1]
self.minx = val[0]
self.maxx = val[1]
self.miny = val[2]
self.maxy = val[3]
class SegTree:
def __init__(self, num, lst):
num_ = 1
... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s133165996 | p00297 | Time Limit Exceeded | import math
class SegmentTree(object):
__slots__ = ["elem_size", "tree", "default", "op"]
def __init__(self, a: list, default: int, op):
real_size = len(a)
self.elem_size = elem_size = 1 << math.ceil(math.log2(real_size))
self.tree = tree = [default] * (elem_size * 2)
tree[elem... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s192422200 | p00297 | Time Limit Exceeded | class MinTree:
def __init__(self, iterable):
self.iter_size = self.get_size(iterable)
self.size = self.iter_size * 2 - 1
self.value = [None] * self.size
for i, v in enumerate(iterable):
self.value[self.iter_size + i - 1] = v
self.set_value(0)
self.range = [None] * self.size
self.set_... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s643779596 | p00297 | Time Limit Exceeded | def main():
INF = 10 ** 20
class MinTree:
def __init__(self, iterable):
self.iter_size = self.get_size(iterable)
self.size = self.iter_size * 2 - 1
self.value = [None] * self.size
for i, v in enumerate(iterable):
self.value[self.iter_size + i - 1] = v
self.set_value(0)
... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s188059551 | p00297 | Time Limit Exceeded | def main():
INF = 10 ** 20
class MinTree:
def __init__(self, iterable):
self.iter_size = self.get_size(iterable)
self.size = self.iter_size * 2 - 1
self.value = [None] * self.size
for i, v in enumerate(iterable):
self.value[self.iter_size + i - 1] = v
self.set_value(0)
... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s036656757 | p00297 | Time Limit Exceeded | def main():
INF = 10 ** 20
class MinTree:
def __init__(self, iterable):
self.iter_size = self.get_size(iterable)
self.size = self.iter_size * 2 - 1
self.value = [None] * self.size
for i, v in enumerate(iterable):
self.value[self.iter_size + i - 1] = v
self.set_value(0)
... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s380875250 | p00297 | Time Limit Exceeded | def main():
INF = 10 ** 20
class MinTree:
def __init__(self, iterable):
self.iter_size = self.get_size(iterable)
self.size = self.iter_size * 2 - 1
self.value = [None] * self.size
for i, v in enumerate(iterable):
self.value[self.iter_size + i - 1] = v
self.set_value(0)
... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s202684543 | p00297 | Time Limit Exceeded | def main():
INF = 10 ** 20
class MinTree:
def __init__(self, iterable):
self.iter_size = self.get_size(iterable)
self.size = self.iter_size * 2 - 1
self.value = [None] * self.size
for i, v in enumerate(iterable):
self.value[self.iter_size + i - 1] = v
self.set_value(0)
... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s358339814 | p00297 | Time Limit Exceeded | import sys
f = sys.stdin
def mix(a,b):
return (min(a[0],b[0]),min(a[1],b[1]),max(a[2],b[2]),max(a[3],b[3]))
s = {}
n, d = map(int, f.readline().split())
for _ in range(n):
x, y, b = map(int, f.readline().split())
s[b] = mix(s[b],(x,y,x,y)) if b in s else (x,y,x,y)
max_size = 0
b = sorted(s.keys())
for i... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s648043259 | p00297 | Time Limit Exceeded | import sys
f = sys.stdin
def mix(a,b):
return (min(a[0],b[0]),min(a[1],b[1]),max(a[2],b[2]),max(a[3],b[3]))
s = {}
n, d = map(int, f.readline().split())
for _ in range(n):
x, y, b = map(int, f.readline().split())
s[b] = mix(s[b],(x,y,x,y)) if b in s else (x,y,x,y)
max_size = 0
b = sorted(s.keys())
i = j... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s588450936 | p00297 | Time Limit Exceeded | import sys
f = sys.stdin
_, d = map(int, f.readline().split())
x,y = {},{}
for line in f:
xi, yi, bi = map(int, line.split())
if bi not in x:
x[bi],y[bi] = [],[]
x[bi].append(xi)
y[bi].append(yi)
b = sorted(x.keys())
xmin,xmax,ymin,ymax = [None for _ in range(len(b))],[None for _ in range(le... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s783850832 | p00297 | Time Limit Exceeded | import sys
f = sys.stdin
_, d = map(int, f.readline().split())
x,y,b = [],[],set()
for line in f:
xi, yi, bi = map(int, line.split())
x.append((xi,bi))
y.append((yi,bi))
b.update([bi])
x = sorted(x)
y = sorted(y)
b = sorted(b)
def search(target,bmin,bmax):
tmax,tmin = None,None
for i in ... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s526704112 | p00297 | Time Limit Exceeded | import math
class SegmentTree:
def __init__(self, dat, func, sentinel):
self.pad = 2 ** math.ceil(math.log(len(dat),2)) - 1
self.dat = [None] * self.pad + dat + [sentinel] * (self.pad + 1 - len(dat))
self.func = func
self.sentinel = sentinel
for i in range(self.pad - 1, -1, -... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s816385783 | p00297 | Time Limit Exceeded | import sys
f = sys.stdin
def q(t,s,e,func):
if s == e:
return t[s]
else:
return func(q(t,s,(s+e)//2,func),q(t,(s+e)//2 + 1,e,func))
_, d = map(int, f.readline().split())
b = []
for line in f:
xi, yi, bi = map(int, line.split())
b.append((bi,xi,yi))
b = sorted(b)
x = tuple(xi for _,xi,... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s013958169 | p00297 | Time Limit Exceeded | import sys
f = sys.stdin
def memoize(f):
memo = {}
def inner(v1,v2,v3,v4):
if not (v1,v2,v3,v4) in memo:
memo[v1,v2,v3,v4] = f(v1,v2,v3,v4)
return memo[v1,v2,v3,v4]
return inner
@memoize
def q(t,s,e,func):
if s == e:
return t[s]
else:
return func(q(t,s,(s+e)//2,func)... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s251767670 | p00297 | Time Limit Exceeded | import sys
f = sys.stdin
def q(t,i,s,e,func):
if s == e:
return t[s][i]
else:
return func(q(t,i,s,(s+e)//2,func),q(t,i,(s+e)//2 + 1,e,func))
_, d = map(int, f.readline().split())
b = []
for line in f:
xi, yi, bi = map(int, line.split())
b.append((bi,xi,yi))
b = sorted(b)
max_size = i... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s976149678 | p00297 | Time Limit Exceeded | import math
class SegmentTree:
def __init__(self, dat, func, sentinel):
self.pad = 2 ** math.ceil(math.log(len(dat),2)) - 1
self.dat = [None] * self.pad + dat + [sentinel] * (self.pad + 1 - len(dat))
self.func = func
self.sentinel = sentinel
for i in range(self.pad - 1, -1, -... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s575458784 | p00297 | Time Limit Exceeded | from math import ceil
class sqrt_tree:
def __init__(self,dat,f):
self.dat = dat
self.sq = int(len(dat) ** 0.5)
self.baqet = {}
for fi in f:
self.baqet[fi] = [fi(dat[i * self.sq:(i + 1) * self.sq]) for i in range(self.sq)]
#query
def q(self,f,l,r):
r +... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s978665053 | p00297 | Time Limit Exceeded | import math
class sqrt_tree:
def __init__(self,dat,f):
self.dat = dat
self.sq = int(len(dat) ** 0.5)
self.f = f
self.baqet = [self.f(dat[i * self.sq:(i + 1) * self.sq]) for i in range(len(dat) // self.sq)]
#query
def q(self,l,r):
r += 1
if math.ceil(l / s... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s953648605 | p00297 | Time Limit Exceeded | import math
class SegmentTree:
def __init__(self, dat, f, sentinel):
self.pad = 2 ** math.ceil(math.log(len(dat),2))
self.dat = [None] * self.pad + dat + [sentinel] * (self.pad - len(dat))
self.f = f
self.sentinel = sentinel
for i in range(self.pad - 1, 0, -1):
se... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s121034261 | p00297 | Time Limit Exceeded | import math
class SegmentTree:
def __init__(self, dat, f, sentinel):
self.pad = 2 ** math.ceil(math.log(len(dat),2))
self.dat = [None] * self.pad + dat + [sentinel] * (self.pad - len(dat))
self.f = f
self.sentinel = sentinel
for i in range(self.pad - 1, 0, -1):
se... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s780893823 | p00297 | Time Limit Exceeded | import math
class SegmentTree:
def __init__(self, dat, f, sentinel):
self.pad = 2 ** math.ceil(math.log(len(dat),2))
self.dat = [None] * self.pad + dat + [sentinel] * (self.pad - len(dat))
self.f = f
self.sentinel = sentinel
for i in range(self.pad - 1, 0, -1):
se... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s667517290 | p00297 | Time Limit Exceeded | import math
class SegmentTree:
def __init__(self, dat, f, sentinel):
self.pad = 2 ** math.ceil(math.log(len(dat),2))
self.dat = [None] * self.pad + dat + [sentinel] * (self.pad - len(dat))
self.f = f
self.sentinel = sentinel
for i in range(self.pad - 1, 0, -1):
se... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s358458512 | p00297 | Time Limit Exceeded | import math
def segmentTree(dat, f, sentinel):
pad = 2 ** math.ceil(math.log(len(dat),2))
dat = [None] * pad + dat + [sentinel] * (pad - len(dat))
for i in range(pad - 1, 0, -1):
dat[i] = f(dat[i * 2:i * 2 + 2])
return dat
import sys
f = sys.stdin
_, d = map(int, f.readline... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s939553251 | p00297 | Time Limit Exceeded | import math
def segmentTree(dat, f, sentinel):
pad = 2 ** math.ceil(math.log(len(dat),2))
dat = [None] * pad + dat + [sentinel] * (pad - len(dat))
for i in range(pad - 1, 0, -1):
dat[i] = f(dat[i * 2:i * 2 + 2])
return dat
import sys
f = sys.stdin
_, d = map(int, f.readline(... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s739754512 | p00297 | Time Limit Exceeded | import math
import array
def segmentTree(dat, f, sentinel):
pad = 2 ** math.ceil(math.log(len(dat),2))
dat = array.array('L',[0] * pad + dat + [sentinel] * (pad - len(dat)))
for i in range(pad - 1, 0, -1):
dat[i] = f(dat[i * 2:i * 2 + 2])
return dat
import sys
f = sys.stdin
... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s921423753 | p00297 | Time Limit Exceeded | import math
def segmentTree(dat, f, sentinel):
pad = 2 ** math.ceil(math.log(len(dat),2))
dat = [0] * pad + dat + [sentinel] * (pad - len(dat))
for i in range(pad - 1, 0, -1):
dat[i] = f(dat[i * 2:i * 2 + 2])
return dat
def get_lr(b,d):
l = r = 0
while r < len(b):
... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s686161452 | p00297 | Time Limit Exceeded | import math
def segmentTree(dat, f, sentinel):
pad = 2 ** math.ceil(math.log(len(dat),2))
dat = [0] * pad + dat + [sentinel] * (pad - len(dat))
for i in range(pad - 1, 0, -1):
dat[i] = f(dat[i * 2:i * 2 + 2])
return dat
def get_lr(b,d):
l = r = 0
while r < len(b):
... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s382817172 | p00297 | Time Limit Exceeded | data = map(int, raw_input().split())
stars = data[0]
lightrange = data[1]
a = []
for i in range(stars):
a.append(map(int, raw_input().split()))
scale = []
for j in range(len(a)):
minlight = a[j][2]
astars = []
for k in range(len(a)):
if (a[k][2] >= minlight and a[k][2] <= minlight + lightrange):... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s639063288 | p00297 | Time Limit Exceeded | data = map(int, raw_input().split())
stars = data[0]
lightrange = data[1]
a = []
for i in range(stars):
a.append(map(int, raw_input().split()))
a.sort(key=lambda x:x[2])
scale = 0
for j in range(len(a)):
minlight = a[0][2]
astars = []
for k in range(len(a)):
if (a[k][2] >= minlight and a[k][2] <... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s020020888 | p00297 | Time Limit Exceeded | data = map(int, raw_input().split())
stars = data[0]
lightrange = data[1]
a = []
for i in range(stars):
a.append(map(int, raw_input().split()))
a.sort(key=lambda x:x[2])
scale = 0
for j in range(len(a)):
minlight = a[0][2]
astars = []
for k in range(len(a)):
if (a[k][2] >= minlight and a[k][2] <... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s172567760 | p00297 | Time Limit Exceeded | data = map(int, raw_input().split())
stars = data[0]
lightrange = data[1]
a = []
for i in range(stars):
a.append(map(int, raw_input().split()))
a.sort(key=lambda x:x[2])
scale = 0
for j in range(len(a)):
astars = []
for k in range(len(a)):
while(len(astars)<=2):
if (a[k][2] <= a[0][2] + ... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s571048334 | p00297 | Time Limit Exceeded | data = map(int, raw_input().split())
stars = data[0]
lightrange = data[1]
a = []
for i in range(stars):
a.append(map(int, raw_input().split()))
a.sort(key=lambda x:x[2])
scale = 0
for j in range(len(a)):
astars = []
for k in range(len(a)):
while(len(astars)<=2):
if (a[k][2] <= a[0][2] + ... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s083689966 | p00297 | Time Limit Exceeded | data = map(int, raw_input().split())
stars = data[0]
lightrange = data[1]
a = []
for i in range(stars):
a.append(map(int, raw_input().split()))
a.sort(key=lambda x:x[2])
scale = 0
while(len(a)>1):
minx=maxx=a[0][0]
miny=maxy=a[0][1]
k=1
while(a[k][2]<=a[0][2] + lightrange):
if (a[k][0]<minx ... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s438612172 | p00297 | Time Limit Exceeded | data = map(int, raw_input().split())
stars = data[0]
lightrange = data[1]
a = []
for i in range(stars):
a.append(map(int, raw_input().split()))
a.sort(key=lambda x:x[2])
scale = 0
while(len(a)>1):
k=0
x=[]
y=[]
while(a[k][2]<=a[0][2] + lightrange):
x.append(a[k][0])
y.append(a[k][1])... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s074819859 | p00297 | Time Limit Exceeded | data = map(int, raw_input().split())
stars = data[0]
lightrange = data[1]
a = []
for i in range(stars):
a.append(map(int, raw_input().split()))
a.sort(key=lambda x:x[2])
scale = [0]
while(len(a)>1):
k=0
x=[]
y=[]
while(a[k][2]<=a[0][2] + lightrange):
x.append(a[k][0])
y.append(a[k][1... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s765572268 | p00297 | Time Limit Exceeded | data = map(int, raw_input().split())
stars = data[0]
lightrange = data[1]
a = []
for i in range(stars):
a.append(map(int, raw_input().split()))
a.sort(key=lambda x:x[2])
scale = [0]
minlight = -1
while(len(a)>1):
if a[0] == minlight:
del a[0]
else :
k=0
x=[]
y=[]
whil... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s387715497 | p00297 | Time Limit Exceeded | data = map(int, raw_input().split())
stars = data[0]
lightrange = data[1]
a = []
for i in range(stars):
a.append(map(int, raw_input().split()))
a.sort(key=lambda z:(z[2],z[0]))
x = [a[p][0] for p in range(stars)]
y = [a[q][1] for q in range(stars)]
light = [a[r][2] for r in range(stars)]
X=[]
Y=[]
k=0
scale=0
for j... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s125237993 | p00297 | Time Limit Exceeded | from collections import defaultdict
n, d = map(int, input().split())
ud, od = d // 2, (d + 1) // 2
stars = defaultdict(set)
for _ in range(n):
x, y, b = map(int, input().split())
stars[b].add((x, y))
keys = set(stars.keys())
min_b, max_b = min(keys) + ud, max(keys) - od
max_stella = 0
for b in keys.intersec... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s124743801 | p00297 | Time Limit Exceeded | n, d = map(int, input().split())
ud, od = d // 2, (d + 1) // 2
stars = dict()
for _ in range(n):
x, y, b = map(int, input().split())
xys = stars.setdefault(b, [x, x, y, y])
if xys[0] < x: xys[0] = x
if xys[1] > x: xys[1] = x
if xys[2] < y: xys[2] = y
if xys[3] > y: xys[3] = y
keys = set(stars.... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s935151920 | p00297 | Time Limit Exceeded | n, d = map(int, input().split())
ud, od = d // 2, (d + 1) // 2
stars = dict()
for _ in range(n):
x, y, b = map(int, input().split())
xys = stars.setdefault(b, [x, x, y, y])
if xys[0] < x: xys[0] = x
if xys[1] > x: xys[1] = x
if xys[2] < y: xys[2] = y
if xys[3] > y: xys[3] = y
keys = set(stars.... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s031037336 | p00297 | Time Limit Exceeded | n, d = map(int, input().split())
ud, od = d // 2, (d + 1) // 2
stars = dict()
for _ in range(n):
x, y, b = map(int, input().split())
xys = stars.setdefault(b, [x, x, y, y])
if xys[0] < x: xys[0] = x
if xys[1] > x: xys[1] = x
if xys[2] < y: xys[2] = y
if xys[3] > y: xys[3] = y
keys = set(stars.... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s601845331 | p00297 | Time Limit Exceeded | from functools import reduce
class Bound:
min_x = 2000001
min_y = 2000001
max_x = -1
max_y = -1
def add(self, x, y):
if self.min_x > x: self.min_x = x
if self.min_y > y: self.min_y = y
if self.max_x < x: self.max_x = x
if self.max_y < y: self.max_y = y
def exp... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s300630912 | p00297 | Time Limit Exceeded | from functools import reduce
from math import ceil, sqrt
from copy import copy
class Bound:
min_x = 2000001
min_y = 2000001
max_x = -1
max_y = -1
added = False
def add(self, x, y):
self.added = True
if self.min_x > x: self.min_x = x
if self.min_y > y: self.min_y = y
... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s738012308 | p00297 | Time Limit Exceeded | from math import ceil, log2
class SegmentTree:
def __init__(self, n, bounds):
n2 = 2 ** ceil(log2(n))
tree = [None] * (n2 - 1) + bounds + [None] * (n2 - n)
left = [0] * (n2 - 1) + list(range(n2))
right = [0] * (n2 - 1) + list(range(n2))
for i in range(n2 - 2, -1, -1):
... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s307375824 | p00297 | Time Limit Exceeded | answer=[]
info = list(map(int,raw_input().split()))
all_list=[] # This list include information of all stars.
for i in range (info[0]):
all_list.append(list(map(int,raw_input().split())))
dark_star=min(all_list, key=lambda x: x[2])[2]
bright_star=max(all_list, key=lambda x:x[2])[2]
for i in range (dark_star,bright_st... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s558827907 | p00297 | Time Limit Exceeded | answer=[]
info = list(map(int,raw_input().split()))
all_list=[] # This list include information of all stars.
for i in range (info[0]):
all_list.append(list(map(int,raw_input().split())))
dark_star=min(all_list, key=lambda x: x[2])[2]
bright_star=max(all_list, key=lambda x:x[2])[2]
for i in range (dark_star,bright_sta... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s541470231 | p00297 | Time Limit Exceeded | N,d = map(int,input().split())
L = [list(map(int,input().split())) for i in range(N)]
L = sorted(L,key=lambda x:x[2])
def get_square(L):
if not L:return 0
x=[L[0][0],L[0][0]]
y=[L[0][1],L[0][1]]
for i in L:
if i[0] < x[0]:x[0] = i[0]
if i[0] > x[1]:x[1] = i[0]
if i[1] < y[0]:y[0] = i[1]
if i[1]... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s066569588 | p00297 | Time Limit Exceeded | N,d = map(int,input().split())
L = [list(map(int,input().split())) for i in range(N)]
L = sorted(L,key=lambda x:x[2])
def get_square(L):
if not L or len(L) == 0:return 0
x=[L[0][0],L[0][0]]
y=[L[0][1],L[0][1]]
for i in L:
if i[0] < x[0]:x[0] = i[0]
if i[0] > x[1]:x[1] = i[0]
if i[1] < y[0]:y[0] = i... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s188560202 | p00297 | Time Limit Exceeded | from operator import itemgetter
N,d = map(int,input().split())
L = [list(map(int,input().split())) for i in range(N)]
L = sorted(L,key=itemgetter(2,0,1))
def get_square(L):
if not L or len(L) == 0:return 0
x=[L[0][0],L[0][0]]
y=[L[0][1],L[0][1]]
for i in L:
if i[0] < x[0]:x[0] = i[0]
elif i[0] > x[1]:x... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s698974823 | p00297 | Time Limit Exceeded | from operator import itemgetter
N,d = map(int,input().split())
L = [list(map(int,input().split())) for i in range(N)]
L = sorted(L,key=itemgetter(2,0,1))
def get_square(L):
if not L or len(L) == 0:return 0
x=[L[0][0][0],L[0][0][1]]
y=[L[0][1][0],L[0][1][1]]
for i in L:
if i[0][0] < x[0]:x[0] = i[0][0]
... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s380869263 | p00297 | Time Limit Exceeded | from sys import stdin
from operator import itemgetter
N,d = map(int,input().split())
L = sorted([list(map(int,i.split())) for i in stdin.readlines()],key=itemgetter(2))
#L = [list(map(int,input().split())) for i in range(N)]
#L = sorted(L,key=itemgetter(2,0,1))
def get_square(L):
if not L or len(L) == 0:return 0
x... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s364097363 | p00297 | Time Limit Exceeded | from sys import stdin
from operator import itemgetter
def get_square(L):
if not L or len(L) == 0:return 0
x=[L[0][0][0],L[0][0][1]]
y=[L[0][1][0],L[0][1][1]]
for i in L:
if i[0][0] < x[0]:x[0] = i[0][0]
if i[0][1] > x[1]:x[1] = i[0][1]
if i[1][0] < y[0]:y[0] = i[1][0]
if i[1][1] > y[1]:y[1] = i... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s768575415 | p00297 | Time Limit Exceeded | from sys import stdin
from operator import itemgetter
def get_square(L):
if not L or len(L) == 0:return 0
x=[L[0][0][0],L[0][0][1]]
y=[L[0][1][0],L[0][1][1]]
for i in L:
if i[0][0] < x[0]:x[0] = i[0][0]
if i[0][1] > x[1]:x[1] = i[0][1]
if i[1][0] < y[0]:y[0] = i[1][0]
if i[1][1] > y[1]:y[1] = i... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s733081018 | p00297 | Time Limit Exceeded | from sys import stdin
from operator import itemgetter
def get_square(L):
if not L or len(L) == 0:return 0
x=[L[0][0][0],L[0][0][1]]
y=[L[0][1][0],L[0][1][1]]
for i in L:
if i[0][0] < x[0]:x[0] = i[0][0]
if i[0][1] > x[1]:x[1] = i[0][1]
if i[1][0] < y[0]:y[0] = i[1][0]
if i[1][1] > y[1]:y[1] = i... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s315755601 | p00297 | Time Limit Exceeded | from sys import stdin
from operator import itemgetter
def get_square(L):
if not L or len(L) == 0:return 0
x=[L[0][0][0],L[0][0][1]]
y=[L[0][1][0],L[0][1][1]]
for i in L:
if i[0][0] < x[0]:x[0] = i[0][0]
if i[0][1] > x[1]:x[1] = i[0][1]
if i[1][0] < y[0]:y[0] = i[1][0]
if i[1][1] > y[1]:y[1] = i... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s745708711 | p00297 | Time Limit Exceeded | from sys import stdin
from operator import itemgetter
from itertools import takewhile
from random import randint
def make_data(n):
return [str(randint(0,2000000))+' '+str(randint(0,2000000))+' '+str(randint(0,1e9))
for i in range(n)]
def get_square(x_min,x_max,y_min,y_max):
return (x_max - x_min) * (y_max -... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s268391341 | p00297 | Time Limit Exceeded | from sys import stdin
from operator import itemgetter
from itertools import takewhile
from random import randint
def make_data(n):
return [str(randint(0,2000000))+' '+str(randint(0,2000000))+' '+str(randint(0,1e9))
for i in range(n)]
def get_square(x_min,x_max,y_min,y_max):
return (x_max - x_min) * (y_max -... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s201040912 | p00297 | Time Limit Exceeded | from sys import stdin
from operator import itemgetter as it
D={}
result=[]
N,d=map(int,input().split())
for i in stdin.readlines():
x,y,b=map(int,i.split())
if b not in D:D[b]=[]
D[b].append((x,y))
for i in range(max(D)-d+1):
l=[]
for s in range(d+1):
if i+s in D:l+=D[i+s]
if len(l)>1:
... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s104187872 | p00297 | Time Limit Exceeded | from sys import stdin
from operator import itemgetter as it
D={}
result=[]
N,d=map(int,input().split())
for i in stdin.readlines():
x,y,b=map(int,i.split())
if b not in D:D[b]=[]
D[b].append((x,y))
for i in range(max(D)-d+1):
l=[]
for s in range(d+1):
if i+s in D:l+=D[i+s]
if len(l)>1:
... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s928204601 | p00297 | Time Limit Exceeded | from sys import stdin
from operator import itemgetter as it
D={}
result=[]
N,d=map(int,input().split())
for i in stdin.readlines():
x,y,b=map(int,i.split())
if b not in D:D[b]=[]
D[b].append((x,y))
for i in range(max(D)-d+1):
l=[]
for s in range(d+1):
if i+s in D:l+=D[i+s]
if len(l)>1:
... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s823755600 | p00297 | Time Limit Exceeded | from sys import stdin
from operator import itemgetter
from itertools import takewhile
from random import randint
from array import array
def make_data(n):
return [str(randint(0,2000000))+' '+str(randint(0,2000000))+' '+str(randint(0,1e9))
for i in range(n)]
def get_square(x_min,x_max,y_min,y_max):
return (x... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s907398301 | p00297 | Time Limit Exceeded | from sys import stdin
from operator import itemgetter
from itertools import takewhile
from random import randint
from array import array
MAX = 200000000
class Point:
def __init__(self,x=-1,y=-1,b=-1):
self.x=x
self.y=y
self.b=b
class Points:
def __init__(self,b,points):
self.b=b
self.xmin=poi... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s531605229 | p00297 | Time Limit Exceeded | from bisect import bisect_right as br
class Node:
def __init__(self, val, sec):
self.val = val
self.sec = sec
self.left = sec[0]
self.right = sec[1]
self.minx = val[0]
self.maxx = val[1]
self.miny = val[2]
self.maxy = val[3]
class SegTree:
def __init__(self, num, lst):
num_ = 1
... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s757861885 | p00297 | Time Limit Exceeded | from bisect import bisect_right as br
class Node:
def __init__(self, val, sec):
self.val = val
self.sec = sec
self.left = sec[0]
self.right = sec[1]
self.minx = val[0]
self.maxx = val[1]
self.miny = val[2]
self.maxy = val[3]
class SegTree:
def __init__(self, num, lst):
num_ = 1... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s958824932 | p00297 | Time Limit Exceeded | from bisect import bisect_right as br
class Node:
def __init__(self, val, sec):
self.val = val
self.sec = sec
self.left = sec[0]
self.right = sec[1]
self.minx = val[0]
self.maxx = val[1]
self.miny = val[2]
self.maxy = val[3]
class SegTree:
def __init__(self, num, lst):
num_ = 1... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s854381909 | p00297 | Time Limit Exceeded | from bisect import bisect_right as br
class SegTree:
def __init__(self, num, lst):
num_ = 1
while num_ < num:
num_ *= 2
self.length = num_ * 2 - 1
self.arr = [None] * (num_ * 2 - 1)
for i in range(num):
x1, x2, y1, y2 = lst[i]
self.arr[num_ - 1 + i] = (x1, x2, y1, y2, i, i)
... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s954694764 | p00297 | Time Limit Exceeded | from bisect import bisect_right as br
class SegTree:
def __init__(self, num, lst):
num_ = 1
while num_ < num:
num_ *= 2
self.length = num_ * 2 - 1
self.arr = [None] * (num_ * 2 - 1)
for i in range(num):
x1, x2, y1, y2 = lst[i]
self.arr[num_ - 1 + i] = (x1, x2, y1, y2, i, i)
... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s313949653 | p00297 | Time Limit Exceeded | from bisect import bisect_right as br
def make_arr(num, lst):
num_ = 1
while num_ < num:
num_ *= 2
length = num_ * 2 - 1
arr = [None] * (num_ * 2 - 1)
for i in range(num):
x1, x2, y1, y2 = lst[i]
arr[num_ - 1 + i] = (x1, x2, y1, y2, i, i)
make(arr, length, 0)
return arr
def make(arr, length... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s567610669 | p00297 | Time Limit Exceeded | from bisect import bisect_right as br
def make(arr, length, num):
if num >= length:
return None
if arr[num] != None:
return arr[num]
else:
arr[num] = con(make(arr, length, num * 2 + 1), make(arr, length, num * 2 + 2))
return arr[num]
def con(n1, n2):
if n1 != None and n2 != None:
r0, r1,... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s737678182 | p00297 | Time Limit Exceeded | from bisect import bisect_right as br
def make(arr, length, num):
if num >= length:
return None
if arr[num] != None:
return arr[num]
else:
arr[num] = con(make(arr, length, num * 2 + 1), make(arr, length, num * 2 + 2))
return arr[num]
def con(n1, n2):
if n1 != None and n2 != None:
r0, r1,... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s788788878 | p00297 | Time Limit Exceeded | from bisect import bisect_right as br
def make(arr, length, num):
if num >= length:
return None
if arr[num] != None:
return arr[num]
else:
num_ = num * 2
arr[num] = con(make(arr, length, num_ + 1), make(arr, length, num_ + 2))
return arr[num]
def con(n1, n2):
if n1 != None and n2 != None... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s607662740 | p00297 | Memory Limit Exceeded | import sys
f = sys.stdin
def memoize(f):
memo = {}
def inner(v0,v1,v2,v3,v4):
if not (v1,v2,v3,v4) in memo:
memo[v1,v2,v3,v4] = f(v0,v1,v2,v3,v4)
return memo[v1,v2,v3,v4]
return inner
@memoize
def q(t,i,s,e,func):
if s == e:
return t[s][i]
else:
return func(q(t,i,s,(s... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s410933251 | p00297 | Memory Limit Exceeded | from collections import defaultdict
from math import ceil, log2
class SegmentTree:
left, right = None, None
def __init__(self, n, bounds, is_min):
func = min if is_min else max
sentinel = min_sentinel if is_min else max_sentinel
n2 = 2 ** ceil(log2(n))
tree = [sentinel] * (n2... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s342997439 | p00297 | Memory Limit Exceeded | from collections import defaultdict
from math import ceil, log2
class SegmentTree:
n2 = 0
def __init__(self, n, bounds, is_min):
func = min if is_min else max
sentinel = min_sentinel if is_min else max_sentinel
n2 = 2 ** ceil(log2(n))
tree = [sentinel] * (n2 - 1) + bounds + [... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s104040128 | p00297 | Memory Limit Exceeded | from collections import defaultdict
from math import ceil, log2
import gc
class SegmentTree:
n2 = 0
def __init__(self, n, bounds, is_min):
func = min if is_min else max
sentinel = min_sentinel if is_min else max_sentinel
n2 = 2 ** ceil(log2(n))
tree = [sentinel] * (n2 - 1) + ... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s363362504 | p00297 | Accepted | import sys
from heapq import heappop, heappush
N, d = map(int, sys.stdin.readline().split())
a = sorted([(b, x, y) for l in sys.stdin.readlines() for x, y, b in (map(int, l.split()),)])
x_max, x_min, y_max, y_min = [], [], [], []
ans = 0
for b, x, y in a:
heappush(x_max, (-x, b))
heappush(x_min, (x, b))
h... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s674670477 | p00297 | Accepted | import sys
from heapq import heappop, heappush
from operator import itemgetter
N, d = map(int, sys.stdin.readline().split())
x_max, x_min, y_max, y_min = [], [], [], []
ans = 0
for x, y, b in sorted([list(map(int, l.split())) for l in sys.stdin.readlines()], key=itemgetter(2)):
heappush(x_max, (-x, b))
heappu... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s385450775 | p00297 | Accepted | import math
def segmentTree(dat, f, sentinel):
pad = 2 ** math.ceil(math.log(len(dat),2))
dat = [0] * pad + dat + [sentinel] * (pad - len(dat))
for i in range(pad - 1, 0, -1):
dat[i] = f(dat[i * 2],dat[i * 2 + 1])
return dat
def get_lr(b,d):
l = r = 0
while r < len(b... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s521420186 | p00297 | Accepted | n,d = map(int,input().split())
star = []
for i in range(n):
x,y,b = map(int,input().split())
star.append((b,x,y))
star.sort()
INF = 10**9
q1 = []
q2 = []
minmax1 = [(INF,INF,-INF,-INF)]
minmax2 = [(INF,INF,-INF,-INF)]
r = 0
ans = 0
def add(que, dat):
xmin, ymin, xmax, ymax = que[-1]
x, y = dat
if ... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
s672719964 | p00297 | Accepted | import operator
from collections import deque
N, d = map(int, input().split())
P = [list(map(int, input().split())) for i in range(N)]
P.sort(key=operator.itemgetter(2))
xd_min = deque()
xd_max = deque()
yd_min = deque()
yd_max = deque()
s = -1; t = 0
ans = 0
while t < N:
t0 = t
while t < N-1 and P[t][2] == P[t... | 9 2
1 1 1
1 5 12
2 3 2
3 2 4
4 4 1
5 1 3
5 3 8
6 5 5
7 2 4
| 16
|
<h1>天体観測</h1>
<p>
ある晴れた夜の帰り道、空を見上げるとそこには無数の星。強く輝く星々、かすかに見える星々、いろ
いろな明るさの星々が夜空を彩っています。
</p>
<p>
あなたはふと思いました。この星空に自分の星座があったらどんなに素敵だろうと。そこであなたはひとつの基準を決め、部屋の窓から見える星々を適当につなげて自分の星座を作ることにしました。その基準とは、「どの２つの星を選んでも、それらの明るさの差がある定数 <var>d</var> 以下になるような星のグループを作り、その中で一番大きいものを自分の星座にしよう！」というものです。例えば、図のような窓から見える夜空を考えてみましょう（外側の長方形は... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.