Problem:


Score : 400 points

Problem Statement

We have N points in a two-dimensional plane.

The coordinates of the i-th point (1 \leq i \leq N) are (x_i,y_i).

Let us consider a rectangle whose sides are parallel to the coordinate axes that contains K or more of the N points in its interior.

Here, points on the sides of the rectangle are considered to be in the interior.

Find the minimum possible area of such a rectangle.  

Constraints

2 \leq K \leq N \leq 50 

-10^9 \leq x_i,y_i \leq 10^9 (1 \leq i \leq N) 

x_i≠x_j (1 \leq i<j \leq N) 

y_i≠y_j (1 \leq i<j \leq N) 

All input values are integers. (Added at 21:50 JST)  

Input

Input is given from Standard Input in the following format:  

N K  
x_1 y_1
:  
x_{N} y_{N}

Output

Print the minimum possible area of a rectangle that satisfies the condition.  

Sample Input 1

4 4
1 4
3 3
6 2
8 1

Sample Output 1

21

One rectangle that satisfies the condition with the minimum possible area has the following vertices: (1,1), (8,1), (1,4) and (8,4).

Its area is (8-1) × (4-1) = 21.  

Sample Input 2

4 2
0 0
1 1
2 2
3 3

Sample Output 2

1

Sample Input 3

4 3
-1000000000 -1000000000
1000000000 1000000000
-999999999 999999999
999999999 -999999999

Sample Output 3

3999999996000000001

Watch out for integer overflows.  



Sample input:
4 4
1 4
3 3
6 2
8 1


Sample output:
21

Submission status: Time Limit Exceeded

Solution code:
#!/usr/bin/env python3

import sys
# import time
# import math
# import numpy as np
# import scipy.sparse.csgraph as cs            # csgraph_from_dense(ndarray, null_value=inf), bellman_ford(G, return_predecessors=True), dijkstra, floyd_warshall
# import random                                # random, uniform, randint, randrange, shuffle, sample
# import string                                # ascii_lowercase, ascii_uppercase, ascii_letters, digits, hexdigits
# import re                                    # re.compile(pattern) => ptn obj; p.search(s), p.match(s), p.finditer(s) => match obj; p.sub(after, s)
# from bisect import bisect_left, bisect_right # bisect_left(a, x, lo=0, hi=len(a)) returns i such that all(val<x for val in a[lo:i]) and all(val>-=x for val in a[i:hi]).
# from collections import deque                # deque class. deque(L): dq.append(x), dq.appendleft(x), dq.pop(), dq.popleft(), dq.rotate()
# from collections import defaultdict          # subclass of dict. defaultdict(facroty)
# from collections import Counter              # subclass of dict. Counter(iter): c.elements(), c.most_common(n), c.subtract(iter)
# from datetime import date, datetime          # date.today(), date(year,month,day) => date obj; datetime.now(), datetime(year,month,day,hour,second,microsecond) => datetime obj; subtraction => timedelta obj
# from datetime.datetime import strptime       # strptime('2019/01/01 10:05:20', '%Y/%m/%d/ %H:%M:%S') returns datetime obj
# from datetime import timedelta               # td.days, td.seconds, td.microseconds, td.total_seconds(). abs function is also available.
# from copy import copy, deepcopy              # use deepcopy to copy multi-dimentional matrix without reference
# from functools import reduce                 # reduce(f, iter[, init])
# from functools import lru_cache              # @lrucache ...arguments of functions should be able to be keys of dict (e.g. list is not allowed)
# from heapq import heapify, heappush, heappop # built-in list. heapify(L) changes list in-place to min-heap in O(n), heappush(heapL, x) and heappop(heapL) in O(lgn).
# from heapq import nlargest, nsmallest        # nlargest(n, iter[, key]) returns k-largest-list in O(n+klgn).
# from itertools import count, cycle, repeat   # count(start[,step]), cycle(iter), repeat(elm[,n])
# from itertools import groupby                # [(k, list(g)) for k, g in groupby('000112')] returns [('0',['0','0','0']), ('1',['1','1']), ('2',['2'])]
# from itertools import starmap                # starmap(pow, [[2,5], [3,2]]) returns [32, 9]
# from itertools import product, permutations  # product(iter, repeat=n), permutations(iter[,r])
# from itertools import combinations, combinations_with_replacement
# from itertools import accumulate             # accumulate(iter[, f])
from operator import itemgetter              # itemgetter(1), itemgetter('key')
# from fractions import gcd                    # for Python 3.4 (previous contest @AtCoder)



def main():
    mod = 1000000007                # 10^9+7
    inf = float('inf')              # sys.float_info.max = 1.79...e+308
    # inf = 2 ** 64 - 1             # (for fast JIT compile in PyPy) 1.84...e+19
    sys.setrecursionlimit(10**6)    # 1000 -> 1000000
    def input(): return sys.stdin.readline().rstrip()
    def ii():    return int(input())
    def mi():    return map(int, input().split())
    def mi_0():  return map(lambda x: int(x)-1, input().split())
    def lmi():   return list(map(int, input().split()))
    def lmi_0(): return list(map(lambda x: int(x)-1, input().split()))
    def li():    return list(input())
    
    

    class TwoDimNode:
        def __init__(self, x=None, y=None, parent=None, left=None, right=None):
            '''
            2 次元二分探索木のためのノード
            '''        
            self.x = x
            self.y = y
            self.parent = parent
            self.left = left
            self.right = right
            self.flag = True
    
    class TwoDimTree:
        def __init__(self, points=[]):
            '''
            2 次元二分探索木 (kD tree) を作成する
            root の深さを 0 として、深さが偶数の場合そこでは x を基準に、奇数の場合 y を基準に二分探索木条件を満たすようにする
            '''
            # nil の設定
            self.nil = TwoDimNode()
            self.nil.parent = self.nil
            self.nil.left = self.nil
            self.nil.right = self.nil
            # root の設定
            self.root = self.nil
            # もし予め一次元の点の集合が与えられるのならバランスする形で kD tree を構築する
            self._balance_insert(points)
        
        # def preorder_traverse(self, node=None):
        #     node = self.root if node is None else node
        #     if node != self.nil:
        #         print(f'({node.x},{node.y})', end=' ')
        #         self.preorder_traverse(node=node.left)
        #         self.preorder_traverse(node=node.right)
            
        # def postorder_traverse(self, node=None):
        #     node = self.root if node is None else node
        #     if node != self.nil:
        #         self.preorder_traverse(node=node.left)
        #         self.preorder_traverse(node=node.right)
        #         print(f'({node.x},{node.y})', end=' ')
    
        # def inorder_traverse(self, node=None):
        #     node = self.root if node is None else node
        #     if node != self.nil:
        #         self.preorder_traverse(node=node.left)
        #         print(f'({node.x},{node.y})', end=' ')
        #         self.preorder_traverse(node=node.right)
        
        def _balance_insert(self, seq, depth=0):
            # 毎回 x or y をキーとしてソートを行い、中央値をとって insert すれば平衡になる
            if seq:
                arranged = sorted(seq, key=itemgetter(depth % 2))
                mid = len(seq) // 2
                self.insert(arranged[mid][0], arranged[mid][1])
                self._balance_insert(arranged[:mid], depth+1)
                self._balance_insert(arranged[mid+1:], depth+1)
    
    
        def insert(self, x, y):
            '''
            kD tree に値が (x, y) であるノードを O(depth) で挿入する
            (コンストラクタで生成した kD tree は平衡であることが保証されるが、insert により生成した部分の平衡性は保証されないことに注意)        
            '''
            trailer = self.nil    # (x, y) を挿入するべき nil の一つ前のノードを保存するトレーラポインタ
            pos = self.root    # (x, y) を挿入するべき nil の場所を探す
            depth = 0
            while pos != self.nil:
                trailer = pos
                k, pos_k = (x, pos.x) if depth % 2 == 0 else (y, pos.y)
                if k < pos_k:
                    pos = pos.left
                elif pos_k < k:
                    pos = pos.right
                else:
                    pos.flag ^= pos.flag
                    pos = pos.left if pos.flag else pos.right
                depth += 1
            inserted_node = TwoDimNode(x, y, trailer, self.nil, self.nil)
            # trailer の depth
            depth -= 1
            k, trailer_k = (x, trailer.x) if depth % 2 == 0 else (y, trailer.y)
            # tree is empty
            if trailer == self.nil:
                self.root = inserted_node
            # どこかのノードの子供の位置に挿入する時
            elif k < trailer_k or (k == trailer_k and trailer.flag):
                trailer.left = inserted_node
            else:
                trailer.right = inserted_node
        
        def two_dim_search(self, sx, tx, sy, ty, node=None, depth=0):
            '''
            kD tree に対し閉区間 D = {(x, y) | sx<=x<=tx, sy<=y<=ty} 内に存在する点を探してリストにまとめて返す (対応する点の個数 k として O(√n + k))
            下記のように検索必要性を判断し再帰的に左右の子に対し探索を行えば良い
    
            <-------- node.x -------->
            <----------->
            少しでも [sx,tx] が左側ゾーン ((-inf, node.x]) に被っていたら検索しておく必要がある
                        <----->
                        少しでも [sx, tx] が右側ゾーン ([node.x, inf)) に被っていたら検索しておく必要がある
            '''        
            # buf = []
            # node = self.root if node is None else node
            # # print(f'{node.x} {node.y}')
            # if depth % 2 == 0:
            #     if node.left != self.nil and sx <= node.x:
            #         buf += self.two_dim_search(sx, tx, sy, ty, node.left, depth+1)
            #     if sx <= node.x <= tx and sy <= node.y <= ty:
            #         buf.append((node.x, node.y))
            #     if node.right != self.nil and tx >= node.x:
            #         buf += self.two_dim_search(sx, tx, sy, ty, node.right, depth+1)
            # else:
            #     if node.left != self.nil and sy <= node.y:
            #         buf += self.two_dim_search(sx, tx, sy, ty, node.left, depth+1)
            #     if sx <= node.x <= tx and sy <= node.y <= ty:
            #         buf.append((node.x, node.y))
            #     if node.right != self.nil and ty >= node.y:
            #         buf += self.two_dim_search(sx, tx, sy, ty, node.right, depth+1)
            # return buf
            cnt = 0
            node = self.root if node is None else node
            if depth % 2 == 0:
                if node.left != self.nil and sx <= node.x:
                    cnt += self.two_dim_search(sx, tx, sy, ty, node.left, depth+1)
                if sx <= node.x <= tx and sy <= node.y <= ty:
                    cnt += 1
                if node.right != self.nil and tx >= node.x:
                    cnt += self.two_dim_search(sx, tx, sy, ty, node.right, depth+1)
            else:
                if node.left != self.nil and sy <= node.y:
                    cnt += self.two_dim_search(sx, tx, sy, ty, node.left, depth+1)
                if sx <= node.x <= tx and sy <= node.y <= ty:
                    cnt += 1
                if node.right != self.nil and ty >= node.y:
                    cnt += self.two_dim_search(sx, tx, sy, ty, node.right, depth+1)
            return cnt


    n, num_of_points = mi()
    points = [lmi() for _ in range(n)]
    x_sorted_p = sorted(points, key=itemgetter(0))
    y_sorted_p = sorted(points, key=itemgetter(1))
    kd = TwoDimTree(points)

    area = inf
    for i in range(n-1):
        for j in range(i+1, n):
            sx, tx = x_sorted_p[i][0], x_sorted_p[j][0]
            # 枝かり
            if kd.two_dim_search(sx, tx, y_sorted_p[0][1], y_sorted_p[-1][1]) < num_of_points:
                continue
            for k in range(n-1):
                for l in range(k+1, n):
                    sy, ty = y_sorted_p[k][1], y_sorted_p[l][1]
                    if kd.two_dim_search(sx, tx, sy, ty) >= num_of_points:
                        # print(f"{sx} {tx} {sy} {ty} {kd.two_dim_search(sx, tx, sy, ty)}")
                        area = min(area, abs(tx - sx) * abs(ty - sy))
    print(area)
    


if __name__ == "__main__":
    main()

Submission status: Time Limit Exceeded

Solution code:
#!/usr/bin/env python3

import sys
# import time
# import math
# import numpy as np
# import scipy.sparse.csgraph as cs            # csgraph_from_dense(ndarray, null_value=inf), bellman_ford(G, return_predecessors=True), dijkstra, floyd_warshall
# import random                                # random, uniform, randint, randrange, shuffle, sample
# import string                                # ascii_lowercase, ascii_uppercase, ascii_letters, digits, hexdigits
# import re                                    # re.compile(pattern) => ptn obj; p.search(s), p.match(s), p.finditer(s) => match obj; p.sub(after, s)
# from bisect import bisect_left, bisect_right # bisect_left(a, x, lo=0, hi=len(a)) returns i such that all(val<x for val in a[lo:i]) and all(val>-=x for val in a[i:hi]).
# from collections import deque                # deque class. deque(L): dq.append(x), dq.appendleft(x), dq.pop(), dq.popleft(), dq.rotate()
# from collections import defaultdict          # subclass of dict. defaultdict(facroty)
# from collections import Counter              # subclass of dict. Counter(iter): c.elements(), c.most_common(n), c.subtract(iter)
# from datetime import date, datetime          # date.today(), date(year,month,day) => date obj; datetime.now(), datetime(year,month,day,hour,second,microsecond) => datetime obj; subtraction => timedelta obj
# from datetime.datetime import strptime       # strptime('2019/01/01 10:05:20', '%Y/%m/%d/ %H:%M:%S') returns datetime obj
# from datetime import timedelta               # td.days, td.seconds, td.microseconds, td.total_seconds(). abs function is also available.
# from copy import copy, deepcopy              # use deepcopy to copy multi-dimentional matrix without reference
# from functools import reduce                 # reduce(f, iter[, init])
# from functools import lru_cache              # @lrucache ...arguments of functions should be able to be keys of dict (e.g. list is not allowed)
# from heapq import heapify, heappush, heappop # built-in list. heapify(L) changes list in-place to min-heap in O(n), heappush(heapL, x) and heappop(heapL) in O(lgn).
# from heapq import nlargest, nsmallest        # nlargest(n, iter[, key]) returns k-largest-list in O(n+klgn).
# from itertools import count, cycle, repeat   # count(start[,step]), cycle(iter), repeat(elm[,n])
# from itertools import groupby                # [(k, list(g)) for k, g in groupby('000112')] returns [('0',['0','0','0']), ('1',['1','1']), ('2',['2'])]
# from itertools import starmap                # starmap(pow, [[2,5], [3,2]]) returns [32, 9]
# from itertools import product, permutations  # product(iter, repeat=n), permutations(iter[,r])
# from itertools import combinations, combinations_with_replacement
# from itertools import accumulate             # accumulate(iter[, f])
from operator import itemgetter              # itemgetter(1), itemgetter('key')
# from fractions import gcd                    # for Python 3.4 (previous contest @AtCoder)



def main():
    mod = 1000000007                # 10^9+7
    inf = float('inf')              # sys.float_info.max = 1.79...e+308
    # inf = 2 ** 64 - 1             # (for fast JIT compile in PyPy) 1.84...e+19
    sys.setrecursionlimit(10**6)    # 1000 -> 1000000
    def input(): return sys.stdin.readline().rstrip()
    def ii():    return int(input())
    def mi():    return map(int, input().split())
    def mi_0():  return map(lambda x: int(x)-1, input().split())
    def lmi():   return list(map(int, input().split()))
    def lmi_0(): return list(map(lambda x: int(x)-1, input().split()))
    def li():    return list(input())
    
    

    class TwoDimNode:
        def __init__(self, x=None, y=None, parent=None, left=None, right=None):
            '''
            2 次元二分探索木のためのノード
            '''        
            self.x = x
            self.y = y
            self.parent = parent
            self.left = left
            self.right = right
            self.flag = True
    
    class TwoDimTree:
        def __init__(self, points=[]):
            '''
            2 次元二分探索木 (kD tree) を作成する
            root の深さを 0 として、深さが偶数の場合そこでは x を基準に、奇数の場合 y を基準に二分探索木条件を満たすようにする
            '''
            # nil の設定
            self.nil = TwoDimNode()
            self.nil.parent = self.nil
            self.nil.left = self.nil
            self.nil.right = self.nil
            # root の設定
            self.root = self.nil
            # もし予め一次元の点の集合が与えられるのならバランスする形で kD tree を構築する
            self._balance_insert(points)
        
        # def preorder_traverse(self, node=None):
        #     node = self.root if node is None else node
        #     if node != self.nil:
        #         print(f'({node.x},{node.y})', end=' ')
        #         self.preorder_traverse(node=node.left)
        #         self.preorder_traverse(node=node.right)
            
        # def postorder_traverse(self, node=None):
        #     node = self.root if node is None else node
        #     if node != self.nil:
        #         self.preorder_traverse(node=node.left)
        #         self.preorder_traverse(node=node.right)
        #         print(f'({node.x},{node.y})', end=' ')
    
        # def inorder_traverse(self, node=None):
        #     node = self.root if node is None else node
        #     if node != self.nil:
        #         self.preorder_traverse(node=node.left)
        #         print(f'({node.x},{node.y})', end=' ')
        #         self.preorder_traverse(node=node.right)
        
        def _balance_insert(self, seq, depth=0):
            # 毎回 x or y をキーとしてソートを行い、中央値をとって insert すれば平衡になる
            if seq:
                arranged = sorted(seq, key=itemgetter(depth % 2))
                mid = len(seq) // 2
                self.insert(arranged[mid][0], arranged[mid][1])
                self._balance_insert(arranged[:mid], depth+1)
                self._balance_insert(arranged[mid+1:], depth+1)
    
    
        def insert(self, x, y):
            '''
            kD tree に値が (x, y) であるノードを O(depth) で挿入する
            (コンストラクタで生成した kD tree は平衡であることが保証されるが、insert により生成した部分の平衡性は保証されないことに注意)        
            '''
            trailer = self.nil    # (x, y) を挿入するべき nil の一つ前のノードを保存するトレーラポインタ
            pos = self.root    # (x, y) を挿入するべき nil の場所を探す
            depth = 0
            while pos != self.nil:
                trailer = pos
                k, pos_k = (x, pos.x) if depth % 2 == 0 else (y, pos.y)
                if k < pos_k:
                    pos = pos.left
                elif pos_k < k:
                    pos = pos.right
                else:
                    pos.flag ^= pos.flag
                    pos = pos.left if pos.flag else pos.right
                depth += 1
            inserted_node = TwoDimNode(x, y, trailer, self.nil, self.nil)
            # trailer の depth
            depth -= 1
            k, trailer_k = (x, trailer.x) if depth % 2 == 0 else (y, trailer.y)
            # tree is empty
            if trailer == self.nil:
                self.root = inserted_node
            # どこかのノードの子供の位置に挿入する時
            elif k < trailer_k or (k == trailer_k and trailer.flag):
                trailer.left = inserted_node
            else:
                trailer.right = inserted_node
        
        def two_dim_search(self, sx, tx, sy, ty, node=None, depth=0):
            '''
            kD tree に対し閉区間 D = {(x, y) | sx<=x<=tx, sy<=y<=ty} 内に存在する点を探してリストにまとめて返す (対応する点の個数 k として O(√n + k))
            下記のように検索必要性を判断し再帰的に左右の子に対し探索を行えば良い
    
            <-------- node.x -------->
            <----------->
            少しでも [sx,tx] が左側ゾーン ((-inf, node.x]) に被っていたら検索しておく必要がある
                        <----->
                        少しでも [sx, tx] が右側ゾーン ([node.x, inf)) に被っていたら検索しておく必要がある
            '''        
            # buf = []
            # node = self.root if node is None else node
            # # print(f'{node.x} {node.y}')
            # if depth % 2 == 0:
            #     if node.left != self.nil and sx <= node.x:
            #         buf += self.two_dim_search(sx, tx, sy, ty, node.left, depth+1)
            #     if sx <= node.x <= tx and sy <= node.y <= ty:
            #         buf.append((node.x, node.y))
            #     if node.right != self.nil and tx >= node.x:
            #         buf += self.two_dim_search(sx, tx, sy, ty, node.right, depth+1)
            # else:
            #     if node.left != self.nil and sy <= node.y:
            #         buf += self.two_dim_search(sx, tx, sy, ty, node.left, depth+1)
            #     if sx <= node.x <= tx and sy <= node.y <= ty:
            #         buf.append((node.x, node.y))
            #     if node.right != self.nil and ty >= node.y:
            #         buf += self.two_dim_search(sx, tx, sy, ty, node.right, depth+1)
            # return buf
            cnt = 0
            node = self.root if node is None else node
            if depth % 2 == 0:
                if node.left != self.nil and sx <= node.x:
                    cnt += self.two_dim_search(sx, tx, sy, ty, node.left, depth+1)
                if sx <= node.x <= tx and sy <= node.y <= ty:
                    cnt += 1
                if node.right != self.nil and tx >= node.x:
                    cnt += self.two_dim_search(sx, tx, sy, ty, node.right, depth+1)
            else:
                if node.left != self.nil and sy <= node.y:
                    cnt += self.two_dim_search(sx, tx, sy, ty, node.left, depth+1)
                if sx <= node.x <= tx and sy <= node.y <= ty:
                    cnt += 1
                if node.right != self.nil and ty >= node.y:
                    cnt += self.two_dim_search(sx, tx, sy, ty, node.right, depth+1)
            return cnt


    n, num_of_points = mi()
    points = [lmi() for _ in range(n)]
    x_sorted_p = sorted(points, key=itemgetter(0))
    y_sorted_p = sorted(points, key=itemgetter(1))
    kd = TwoDimTree(points)

    area = inf
    for i in range(n-1):
        for j in range(i+1, n):
            sx, tx = x_sorted_p[i][0], x_sorted_p[j][0]
            for k in range(n-1):
                for l in range(k+1, n):
                    sy, ty = y_sorted_p[k][1], y_sorted_p[l][1]
                    if kd.two_dim_search(sx, tx, sy, ty) >= num_of_points:
                        # print(f"{sx} {tx} {sy} {ty} {kd.two_dim_search(sx, tx, sy, ty)}")
                        area = min(area, abs(tx - sx) * abs(ty - sy))
    print(area)
    


if __name__ == "__main__":
    main()

Submission status: Time Limit Exceeded

Solution code:
def main():
    N, K = map(int, input().split())
    XY = [tuple(map(int, input().split())) for _ in range(N)]
    X, Y = [], []
    for x, y in XY:
        X.append(x)
        Y.append(y)
    X.sort()
    Y.sort()
    Xm = {x: i for i, x in enumerate(X)}
    Ym = {y: i for i, y in enumerate(Y)}
    Xr = {i: x for i, x in enumerate(X)}
    Yr = {i: y for i, y in enumerate(Y)}
    cXY = [(Xm[x], Ym[y]) for x, y in XY]
    m = 10 ** 40
    for l in range(N):
        for r in range(l + 1, N):
            for b in range(N):
                for t in range(b + 1, N):
                    k = sum(1 for x, y in cXY if l <= x <= r and b <= y <= t)
                    if k >= K:
                        m = min(m, (Xr[r] - Xr[l]) * (Yr[t] - Yr[b]))
    return m
print(main())

Submission status: Time Limit Exceeded

Solution code:
def main():
    N, K = map(int, input().split())
    XY = [tuple(map(int, input().split())) for _ in range(N)]
    X, Y = [], []
    for x, y in XY:
        X.append(x)
        Y.append(y)
    X.sort()
    Y.sort()
    Xm = {x: i for i, x in enumerate(X)}
    Ym = {y: i for i, y in enumerate(Y)}
    Xr = {i: x for i, x in enumerate(X)}
    Yr = {i: y for i, y in enumerate(Y)}
    cXY = [(Xm[x], Ym[y]) for x, y in XY]
    m = 10 ** 40
    for l in range(N):
        for r in range(l + 1, N):
            for b in range(N):
                for t in range(b + 1, N):
                    k = 0
                    for x, y in cXY:
                        if l <= x <= r and b <= y <= t:
                            k += 1
                    if k >= K:
                        m = min(m, (Xr[r] - Xr[l]) * (Yr[t] - Yr[b]))
    return m
print(main())

Submission status: Time Limit Exceeded

Solution code:
def main():
    N, K = map(int, input().split())
    l = []
    xl = []
    yl = []
    for _ in range(N):
        x, y = map(int, input().split())
        l.append((x, y))
        xl.append(x)
        yl.append(y)
    xl.sort()
    yl.sort()
    xd = {}
    dx = {}
    t = 0
    p = xl[0]
    for i in xl:
        if i != p:
            t += 1
        xd[i] = t
        dx[t] = i
        p = i
    yd = {}
    dy = {}
    t = 0
    p = yl[0]
    for i in yl:
        if i != p:
            t += 1
        yd[i] = t
        dy[t] = i
        p = i
    l2 = []
    for x, y in l:
        l2.append((xd[x], yd[y]))
    m = 10**100
    for si in range(len(xd)-1):
        for ei in range(si+1, len(xd)):
            for sj in range(len(yd)-1):
                for ej in range(sj+1, len(yd)):
                    t = 0
                    for x, y in l2:
                        if si <= x <= ei and sj <= y <= ej:
                            t += 1
                    if t >= K:
                        m = min(m, (dx[ei]-dx[si]) * (dy[ej]-dy[sj]))
    return m
print(main())

Submission status: Time Limit Exceeded

Solution code:
import sys
input = sys.stdin.buffer.readline

def main():
    n, k = map(int, input().split())
    XY = []
    xs = []
    ys = []
    for i in range(n):
        x, y = map(int, input().split())
        XY.append((x, y))
        xs.append(x)
        ys.append(y)

    xs.sort()
    ys.sort()
    ans = float('inf')
    for a in range(n-1):
        for b in range(a+1, n):
            for c in range(n-1):
                for d in range(c+1, n):
                    xl = xs[a]
                    xr = xs[b]
                    yl = ys[c]
                    yu = ys[d]
                    cnt = 0
                    for x, y in XY:
                        if xl <= x <= xr and yl <= y <= yu:
                            cnt += 1
                    if cnt >= k:
                        ans = min(ans, (xr-xl)*(yu-yl))
    print(ans)

if __name__ == '__main__':
    main()

Submission status: Time Limit Exceeded

Solution code:
n, k = map(int, input().split())
XY = []
xs = []
ys = []
for i in range(n):
    x, y = map(int, input().split())
    XY.append((x, y))
    xs.append(x)
    ys.append(y)

xs.sort()
ys.sort()
ans = float('inf')
for a in range(n-1):
    for b in range(a+1, n):
        for c in range(n-1):
            for d in range(c+1, n):
                xl = xs[a]
                xr = xs[b]
                yl = ys[c]
                yu = ys[d]
                cnt = 0
                for x, y in XY:
                    if xl <= x <= xr and yl <= y <= yu:
                        cnt += 1
                if cnt >= k:
                    ans = min(ans, (xr-xl)*(yu-yl))
print(ans)

Submission status: Time Limit Exceeded

Solution code:
import sys
sys.setrecursionlimit(10**8)

def main():
    n,k = map(int,input().split())
    xy = []
    X = []
    Y = []
    for _ in range(n):
        x,y = map(int,input().split())
        xy.append((x,y))
        X.append(x)
        Y.append(y)
    ans = 10**20
    for i in range(n-1):
        for j in range(i+1,n):
            for a in range(n-1):
                for b in range(a+1,n):
                    xl,xr = X[i],X[j]
                    yd,yu = Y[a],Y[b]
                    if xl > xr:
                        xr,xl = xl,xr
                    if yd > yu:
                        yd,yu = yu,yd
                    area = (xr-xl)*(yu-yd)
                    if ans < area:
                        continue
                    cnt = 0
                    for c in range(n):
                        if xl <= xy[c][0] and xy[c][0] <= xr and yd <= xy[c][1] and xy[c][1] <= yu:
                            cnt += 1
                    if cnt >= k:
                        ans = min(ans,area)
    print(ans)

if __name__ == "__main__":
    main()

Submission status: Time Limit Exceeded

Solution code:
# 全探索する

import sys
readline = sys.stdin.readline

N,K = map(int,readline().split())

P = [None] * N
for i in range(N):
  P[i] = list(map(int,readline().split()))

ans = 10 ** 18 * 4 + 1
for ix in range(N-1):
  for jx in range(ix,N):
    # X軸が決まる
    left = P[ix][0]
    right = P[jx][0]
    if left > right:
      left,right = right,left
    for iy in range(N-1):
      for jy in range(iy,N):
        up = P[iy][1]
        down = P[jy][1]
        if up < down:
          up,down = down,up
        d = abs(up - down) * abs(right - left)
        if d > ans:
          continue
        cnt = 0
        for i in range(N):
          if left <= P[i][0] <= right and down <= P[i][1] <= up:
            cnt += 1
        if cnt >= K:
          ans = d
print(ans)

Submission status: Time Limit Exceeded

Solution code:
n,K = map(int,input().split())
xy = [[int(i) for i in input().split()] for j in range(n)]

ans = 10**20

for i in range(n):
    for j in range(i+1,n):
        if K == 2:
            ans = min(ans,abs(xy[i][0]-xy[j][0])*abs(xy[i][1]-xy[j][1]))
        for k in range(j+1,n):
            if K == 2:
                break
            max_x = max(xy[i][0],xy[j][0],xy[k][0])
            min_x = min(xy[i][0],xy[j][0],xy[k][0])
            max_y = max(xy[i][1],xy[j][1],xy[k][1])
            min_y = min(xy[i][1],xy[j][1],xy[k][1])
            if K == 3:
                #max_x = max(xy[i][0],xy[j][0],xy[k][0])
                #min_x = min(xy[i][0],xy[j][0],xy[k][0])
                #max_y = max(xy[i][1],xy[j][1],xy[k][1])
                #min_y = min(xy[i][1],xy[j][1],xy[k][1])
                ans = min(ans,abs(max_x-min_x)*abs(max_y-min_y))
            for l in range(k+1,n):
                if K == 2 or K == 3:
                    break
                cnt = 0
                max_x = max(max(xy[i][0],xy[j][0],xy[k][0]),xy[l][0])
                min_x = min(min(xy[i][0],xy[j][0],xy[k][0]),xy[l][0])
                max_y = max(max(xy[i][1],xy[j][1],xy[k][1]),xy[l][1])
                min_y = min(min(xy[i][1],xy[j][1],xy[k][1]),xy[l][1])
                for m in range(n):
                    if xy[m][0] >= min_x and xy[m][0] <= max_x\
                       and xy[m][1] >= min_y and xy[m][1] <= max_y:
                           cnt += 1
                if cnt >= K:
                    #print(cnt,K)
                    ans = min(ans,(max_x-min_x)*(max_y-min_y))
                
print(ans)