Q：
以下のコードを高速化してください．


```python
import math


def get_minimum_dist_point(points):
    n = len(points)
    min_dist = 1000000
    for i in range(n):
        for j in range(i+1,n):
            dist = math.sqrt((points[i][0]-points[j][0])**2 + (points[i][1]-points[j][1])**2)


            if dist < min_dist:
                min_dist = dist
    return min_dist
```

A：
このコードはすべての点のペア間の距離を計算し，最小の距離を見つけることを試みています．これはO(n^2)の時間複雑度を持つ操作ですが，より効率的な方法として，「最近接点問題」を解決するための「分割統治法」を利用することができます．このアルゴリズムは，平均的にはO(n log n)の時間複雑度を持ちます．

```python
import math


def closest_pair(points):
    def distance(p1, p2):
        return math.sqrt((p1[0] - p2[0])**2 + (p1[1] - p2[1])**2)


    def brute(points):
        min_d = distance(points[0], points[1])
        p1 = points[0]
        p2 = points[1]
        length = len(points)
        if length == 2:
            return p1, p2, min_d
        for i in range(length-1):
            for j in range(i + 1, length):
                if distance(points[i], points[j]) < min_d: 
                    min_d = distance(points[i], points[j])
                    p1, p2 = points[i], points[j]
        return min_d


    def closest_pair_strip(points, d):
        min_d = d
        length = len(points)
        for i in range(length):
            j = i + 1
            while j < length and (points[j][1] - points[i][1]) < min_d:
                min_d = distance(points[i], points[j])
                j += 1
        return min_d


    def closest_pair_rec(points):
        length = len(points)
        if length <= 3:
            return brute(points)
        mid = length // 2
        pl = points[:mid]
        pr = points[mid:]
        min_d_l = closest_pair_rec(pl)
        min_d_r = closest_pair_rec(pr)
        d = min(min_d_l, min_d_r)
        strip = [i for i in points if abs(i[0] - points[mid][0]) < d]
        min_d_strip = closest_pair_strip(strip, d)
        return min(min_d_strip, d)


    points.sort(key = lambda x: x[0])
    return closest_pair_rec(points)
```

このコードは最も近い2つの点を見つけ，その距離を返します．しかし，これはその距離だけを返すように簡単に修正することができます．

注意：分割統治法は，点の数が非常に大きい場合にのみ高速化の恩恵を受けます．点の数が少ない場合（例えば10以下），元のアルゴリズムの方が速いかもしれません．
