I’m posting my code for a LeetCode problem. If you’d like to review, please do so. Thank you for your time!

Problem

You have a very large square wall and a circular dartboard placed on the wall. You have been challenged to throw darts into the board blindfolded. Darts thrown at the wall are represented as an array of points on a 2D plane.

Return the maximum number of points that are within or lie on any circular dartboard of radius r.

Example 1:

Input: points = [[-2,0],[2,0],[0,2],[0,-2]], r = 2
Output: 4
Explanation: Circle dartboard with center in (0,0) and radius = 2 contain all points.

Example 2:

Input: points = [[-3,0],[3,0],[2,6],[5,4],[0,9],[7,8]], r = 5
Output: 5
Explanation: Circle dartboard with center in (0,4) and radius = 5 contain all points except the point (7,8).

Example 3:

Input: points = [[-2,0],[2,0],[0,2],[0,-2]], r = 1
Output: 1

Example 4:

Input: points = [[1,2],[3,5],[1,-1],[2,3],[4,1],[1,3]], r = 2
Output: 4

Constraints:

• $1 <= points.length <= 100$
• $points[i].length == 2$
• $-10^4 <= points[i][0], points[i][1] <= 10^4$
• $1 <= r <= 5000$

Inputs

[[-2,0],[2,0],[0,2],[0,-2]]
2

[[-3,0],[3,0],[2,6],[5,4],[0,9],[7,8]]
5

[[-2,0],[2,0],[0,2],[0,-2]]
1

[[1,2],[3,5],[1,-1],[2,3],[4,1],[1,3]]
2

[[5738,-1857],[2264,1769],[5944,-9368],[3459,-9748],[8624,159],[985,-5051],[-8275,-9383],[7923,-591],[-8121,4781],[-9594,938],[-24,223],[9084,-4952],[-6787,5289],[4879,-4],[3998,369],[-7996,-7220],[-414,3638],[5092,4406],[1454,2965],[9210,-6966],[-4111,-8614],[4507,2213],[-4112,3699],[-9956,-2420],[7246,6775],[1164,5762],[6778,-5099],[-6655,-9514],[-2778,-7768],[6973,-7458],[7334,-1124],[4840,-8991],[941,5018],[1937,3608],[6807,6159],[763,1355],[-9776,-5074],[1107,1822],[-6779,-5400],[4219,-5674],[9823,-4630],[-9172,-7089],[-1875,162],[2267,1685],[4161,-1638],[-2475,9697],[-5367,-952],[-7786,4367],[839,1415],[8832,-4596],[-3843,7126],[-4242,8513],[-7883,1951],[9105,8342],[-4109,-4510],[1875,3149],[-7759,-6505],[1764,1624],[-6917,-6653],[-1438,6916],[-758,-3300],[3694,6699],[6135,2622],[7485,8284],[-9616,-8501],[408,4743],[8939,-731],[9208,-3748],[6059,-2587],[8403,4154],[2361,5708],[-3958,-3943],[-1746,-9082],[2864,-3231],[-4940,8519],[-8786,7898],[5154,-3647],[9011,8170],[-205,8717],[...
4411

Outputs

4
5
1
4
23

Code

#include <cstdint>
#include <cmath>
#include <vector>
#include <utility>
#include <algorithm>

class Solution {
    static constexpr double precision = 1e-6;
    double R;

    static struct Point {
        double x;
        double y;
    };

    std::vector<Point> point;

public:
    std::int_fast32_t numPoints(
        const std::vector<std::vector<int>>& points,
        const std::int_fast32_t r
    ) {
    
        const std::size_t length = points.size();
        R = (double) r;
        point.resize(length);

        for (std::size_t len = 0; len < length; ++len) {
            point[len].x = points[len][0];
            point[len].y = points[len][1];
        }

        std::int_fast32_t max_darts = 1;

        for (std::size_t i = 0; i < length; ++i) {
            for (std::size_t j = 0; j < length; ++j) {
                if (i == j || getEuclideanDistance(point[i], point[j]) - 2 * R > precision) {
                    continue;
                }

                std::int_fast32_t curr_darts = 0;
                const auto center = getDartboardCenter(point[i], point[j]);

                for (std::size_t k = 0; k < length; ++k) {
                    if (getEuclideanDistance(point[k], center.first) - R < precision) {
                        ++curr_darts;
                    }
                }

                max_darts = std::max(max_darts, curr_darts);
            }
        }

        return max_darts;
    }

private:
    double getEuclideanDistance(
        const Point& a,
        const Point& b
    ) {
        return std::sqrt(std::pow(a.x - b.x, 2) + std::pow(a.y - b.y, 2));
    }

    std::pair<Point, Point> getDartboardCenter(
        const Point& a,
        const Point& b
    ) {
        Point mid;
        std::pair<Point, Point> center;
        mid.x = (a.x + b.x) / 2;
        mid.y = (a.y + b.y) / 2;
        const double theta = std::atan2(a.y - b.y, b.x - a.x);
        const double temp_point = getEuclideanDistance(a, b) / 2;
        const double euc_dist = std::sqrt(std::pow(R, 2) - std::pow(temp_point, 2));
        center.first.x = mid.x - euc_dist * std::sin(theta);
        center.first.y = mid.y - euc_dist * std::cos(theta);
        // For optimization, later!
        center.second.x = mid.x + euc_dist * std::sin(theta);
        center.second.y = mid.y + euc_dist * std::cos(theta);
        return center;
    }
};

References

• Problem

• Discuss

• Solution