# Queries on count of points lie inside a circle

Given n coordinate (x, y) of points on 2D plane and Q queries. Each query contains an integer r, the task is to count the number of points lying inside or on the circumference of the circle having radius r and centered at the origin.

Examples:

```Input : n = 5
Coordinates:
1 1
2 2
3 3
-1 -1
4 4

Query 1: 3
Query 2: 32

Output :
3
5
For first query radius = 3, number of points lie
inside or on the circumference are (1, 1), (-1, -1),
(2, 2). There are only 3 points lie inside or on
the circumference of the circle.
For second query radius = 32, all five points are
inside the circle.
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

The equation for the circle centered at origin (0, 0) with radius r, x2 + y2 = r2. And condition for a point at (x1, y1) to lie inside or on the circumference, x12 + y12 <= r2.

A Naive approach can be for each query, traverse through all points and check the condition. This take O(n*Q) time complexity.

An Efficient approach is to precompute x2 + y2 for each point coordinate and store them in an array p[]. Now, sort the array p[]. Then apply binary search on the array to find last index with condition p[i] <= r2 for each query.

Below is the implementation of this approach:

## C++

```// C++ program to find number of points lie inside or
// on the cirumference of circle for Q queries.
#include<bits/stdc++.h>
using namespace std;

// Computing the x^2 + y^2 for each given points
// and sorting them.
void preprocess(int p[], int x[], int y[], int n)
{
for (int i = 0; i < n; i++)
p[i] = x[i]*x[i] + y[i]*y[i];

sort(p, p + n);
}

// Return count of points lie inside or on circumference
// of circle using binary search on p[0..n-1]
int query(int p[], int n, int rad)
{
int start = 0, end = n-1;
while ((end - start)>1)
{
int mid = (start+end)/2;
double tp = sqrt(p[mid]);

end = mid - 1;
else
start = mid;
}

double tp1 = sqrt(p[start]), tp2 = sqrt(p[end]);

return 0;
return end+1;
else
return start+1;
}

// Driven Program
int main()
{
int x[] = { 1, 2, 3, -1, 4 };
int y[] = { 1, 2, 3, -1, 4 };
int n = sizeof(x)/sizeof(x[0]);

// Compute distances of all points and keep
// the distances sorted so that query can
// work in O(logn) using Binary Search.
int p[n];
preprocess(p, x, y, n);

// Print number of points in a circle of radius 3.
cout << query(p, n, 3) << endl;

// Print number of points in a circle of radius 32.
cout << query(p, n, 32) << endl;
return 0;
}
```

## Java

```// JAVA Code for Queries on count of
// points lie inside a circle
import java.util.*;

class GFG {

// Computing the x^2 + y^2 for each given points
// and sorting them.
public static void preprocess(int p[], int x[],
int y[], int n)
{
for (int i = 0; i < n; i ++)
p[i] = x[i] * x[i] + y[i] * y[i];

Arrays.sort(p);
}

// Return count of points lie inside or on
// circumference of circle using binary
// search on p[0..n-1]
public static int query(int p[], int n, int rad)
{
int start = 0, end = n-1;
while ((end - start) > 1)
{
int mid = (start + end) / 2;
double tp = Math.sqrt(p[mid]);

if (tp > (rad * 1.0))
end = mid - 1;
else
start = mid;
}

double tp1 = Math.sqrt(p[start]);
double tp2 = Math.sqrt(p[end]);

if (tp1 > (rad * 1.0))
return 0;
else if (tp2 <= (rad * 1.0))
return end + 1;
else
return start + 1;
}

/* Driver program to test above function */
public static void main(String[] args)
{
int x[] = { 1, 2, 3, -1, 4 };
int y[] = { 1, 2, 3, -1, 4 };
int n = x.length;

// Compute distances of all points and keep
// the distances sorted so that query can
// work in O(logn) using Binary Search.
int p[]=new int[n];
preprocess(p, x, y, n);

// Print number of points in a circle of
System.out.println(query(p, n, 3));

// Print number of points in a circle of
System.out.println(query(p, n, 32));
}
}
// This code is contributed by Arnav Kr. Mandal.
```

Output:

```3
5
```

Time Complexity: O(n log n) for preprocessing and O(Q Log n) for Q queries.

This article is contributed by Anuj Chauhan. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

# GATE CS Corner    Company Wise Coding Practice

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.
3.2 Average Difficulty : 3.2/5.0
Based on 5 vote(s)