Closest points

#include <iostream>
#include <vector>
#include <cmath>
#include <algorithm>
#include <limits>
#include <set>

using namespace std;

class Point {
public:
    int x, y;
    Point(int x=0, int y=0) : x(x), y(y) {}

    Point operator-(const Point& other) const {
        return Point(x - other.x, y - other.y);
    }

    bool operator==(const Point& other) const {
        return x == other.x && y == other.y;
    }

    bool operator<(const Point& other) const {
        return x < other.x || (x == other.x && y <= other.y);
    }
};

long long cross_product(const Point& p, const Point& q) {
    return static_cast<long long>(p.x) * q.y - static_cast<long long>(p.y) * q.x;
}

long long dist(const Point& p1, const Point& p2) {
    return static_cast<long long>(p1.x - p2.x) * (p1.x - p2.x) +
           static_cast<long long>(p1.y - p2.y) * (p1.y - p2.y);
}

int main() {
    int n;
    cin >> n;
    vector<Point> points;
    //set<Point> s;

    for (int i = 0; i < n; ++i) {
        int x, y;
        cin >> x >> y;
        points.emplace_back(x, y);
    }

    sort(points.begin(), points.end());

    long long d = numeric_limits<long long>::max();
    for (int i = 1; i < n; ++i) {
        int j = i - 1;
        double dd = sqrt(d);
        while (j >= 0 && points[i].x - points[j].x < dd) {
            d = min(d, dist(points[i], points[j]));
            --j;
        }
    }

    cout << d << endl;
    return 0;
}

Test 1

Verdict: ACCEPTED

Test 2

Verdict: ACCEPTED

Test 3

Verdict: ACCEPTED

Test 4

Verdict: ACCEPTED

Test 5

Verdict: ACCEPTED

Test 6

Verdict: TIME LIMIT EXCEEDED

Test 7

Verdict: ACCEPTED

Test 8

Verdict: ACCEPTED

Test 9

Verdict: ACCEPTED

Test 10

Verdict: ACCEPTED

Test 11

Verdict: ACCEPTED

Test 12

Verdict: ACCEPTED

Test 13

Verdict: ACCEPTED

Test 14

Verdict: ACCEPTED

Test 15

Verdict: ACCEPTED

Test 16

Verdict: TIME LIMIT EXCEEDED

Test 17

Verdict: ACCEPTED

Test 18

Verdict: ACCEPTED