Given an array arr[][] of dimension N * 2 representing the co-ordinates of N points and an array Q[] consisting of M integers, the task for every element in the Q[i] is to find the number of points lying inside or on the right-angled isosceles triangle formed on the positive co-ordinate axis with two equal sides of length Q[i]in each query.
Examples:
Input: N = 4, arr[][] = { {2.1, 3.0}, {3.7, 1.2}, {1.5, 6.5}, {1.2, 0.0} }, Q[] = { 2, 8, 5}, M = 3
Output: 1 4 2
Explanation:
- First query: The point (1.2, 0.0) lies inside the triangle.
- Second query: The points { (2.1, 3.0), (3.7, 1.2), (1.2, 0.0) } lies inside the triangle and point (1.5, 6.5) lies on the triangle.
- Third query: The points {(3.7, 1.2), (1.2, 0.0)} lies inside the triangle.
Input: N = 3, arr[][] = { {0, 0}, {1, 1}, {2, 1} }, Q[] = {1, 2, 3}, M = 3
Output: 1 2 3
Explanation:
- First query: The point (0, 0) lies inside the triangle.
- Second query: The points { (0, 0), (1, 1) } lies inside the triangle.
- Third query: All the points lies inside the triangle.
Naive Approach: The simplest approach is to in each query traverse the array of points and checks if it lies inside the right-angled triangle formed. After completing the above steps, print the count.
Time Complexity: O(N * M)
Auxiliary Space: O(1)
Efficient Approach: The above approach can be optimized based on the following observations:
- A point (x, y) lies inside the isosceles right angle triangle formed on co-ordinate axis whose two equal sides are X if :
- x ? 0 && y ? 0 && x + y ? X
- By pre-storing the count of points with coordinates sum ? X, the query can be answered in constant time.
Follow the steps below to solve the problem:
- Initialize an array, say pre[] of max size, to store the count of points whose sum of coordinates is less than or equal to the index of the array.
- Traverse the array arr[][] and increment the count of ceil(arr[i][0] + arr[i][1]) by 1.
- Calculate the prefix sum array of array pre[].
- Traverse the array Q[] and print the pre[Q[i]].
Below is the implementation of the above approach:
// C++ implementation of above approach #include <bits/stdc++.h> using namespace std;
int const MAX = 1e6 + 5;
// Function to find answer of each query int query(vector<vector< float > > arr,
vector< int > Q)
{ // Stores the count of points with sum
// less than or equal to their indices
int pre[MAX] = { 0 };
// Traverse the array
for ( int i = 0; i < arr.size(); i++) {
// If both x and y-coordinate < 0
if (arr[i][0] < 0 || arr[i][1] < 0)
continue ;
// Stores the sum of co-ordinates
int sum = ceil ((arr[i][0] + arr[i][1]));
// Increment count of sum by 1
pre[sum]++;
}
// Prefix array
for ( int i = 1; i < MAX; i++)
pre[i] += pre[i - 1];
// Perform queries
for ( int i = 0; i < Q.size(); i++) {
cout << pre[Q[i]] << " " ;
}
cout << endl;
} // Drivers Code int main()
{ vector<vector< float > > arr = { { 2.1, 3.0 },
{ 3.7, 1.2 },
{ 1.5, 6.5 },
{ 1.2, 0.0 } };
vector< int > Q = { 2, 8, 5 };
int N = arr.size();
int M = Q.size();
query(arr, Q);
} |
// Java implementation of above approach import java.util.*;
class GFG
{ static int MAX = ( int ) (1e6 + 5 );
// Function to find answer of each query static void query( double [][]arr,
int []Q)
{ // Stores the count of points with sum
// less than or equal to their indices
int pre[] = new int [MAX];
// Traverse the array
for ( int i = 0 ; i < arr.length; i++)
{
// If both x and y-coordinate < 0
if (arr[i][ 0 ] < 0 || arr[i][ 1 ] < 0 )
continue ;
// Stores the sum of co-ordinates
int sum = ( int ) Math.ceil((arr[i][ 0 ] + arr[i][ 1 ]));
// Increment count of sum by 1
pre[sum]++;
}
// Prefix array
for ( int i = 1 ; i < MAX; i++)
pre[i] += pre[i - 1 ];
// Perform queries
for ( int i = 0 ; i < Q.length; i++)
{
System.out.print(pre[Q[i]]+ " " );
}
System.out.println();
} // Drivers Code public static void main(String[] args)
{ double [][] arr = { { 2.1 , 3.0 },
{ 3.7 , 1.2 },
{ 1.5 , 6.5 },
{ 1.2 , 0.0 } };
int []Q = { 2 , 8 , 5 };
int N = arr.length;
int M = Q.length;
query(arr, Q);
} } // This code is contributed by 29AjayKumar |
# Python3 implementation of above approach MAX = 10 * * 6 + 5
from math import ceil
# Function to find answer of each query def query(arr, Q):
# Stores the count of points with sum
# less than or equal to their indices
pre = [ 0 ] * ( MAX )
# Traverse the array
for i in range ( len (arr)):
#` If both x and y-coordinate < 0
if (arr[i][ 0 ] < 0 or arr[i][ 1 ] < 0 ):
continue
# Stores the sum of co-ordinates
sum = ceil((arr[i][ 0 ] + arr[i][ 1 ]));
# Increment count of sum by 1
pre[ sum ] + = 1
# Prefix array
for i in range ( 1 , MAX ):
pre[i] + = pre[i - 1 ]
# Perform queries
for i in range ( len (Q)):
print (pre[Q[i]], end = " " )
# Drivers Code if __name__ = = '__main__' :
arr = [[ 2.1 , 3.0 ],
[ 3.7 , 1.2 ],
[ 1.5 , 6.5 ],
[ 1.2 , 0.0 ]]
Q = [ 2 , 8 , 5 ]
N = len (arr)
M = len (Q)
query(arr, Q)
# This code is contributed by mohit kumar 29.
|
// C# implementation of above approach using System;
public class GFG
{ static int MAX = ( int ) (1e6 + 5);
// Function to find answer of each query
static void query( double [,]arr,
int []Q)
{
// Stores the count of points with sum
// less than or equal to their indices
int []pre = new int [MAX];
// Traverse the array
for ( int i = 0; i < arr.GetLength(0); i++)
{
// If both x and y-coordinate < 0
if (arr[i,0] < 0 || arr[i,1] < 0)
continue ;
// Stores the sum of co-ordinates
int sum = ( int ) Math.Ceiling((arr[i,0] + arr[i,1]));
// Increment count of sum by 1
pre[sum]++;
}
// Prefix array
for ( int i = 1; i < MAX; i++)
pre[i] += pre[i - 1];
// Perform queries
for ( int i = 0; i < Q.Length; i++)
{
Console.Write(pre[Q[i]]+ " " );
}
Console.WriteLine();
}
// Drivers Code
public static void Main(String[] args)
{
double [,] arr = { { 2.1, 3.0 },
{ 3.7, 1.2 },
{ 1.5, 6.5 },
{ 1.2, 0.0 } };
int []Q = { 2, 8, 5 };
int N = arr.GetLength(0);
int M = Q.Length;
query(arr, Q);
}
} // This code is contributed by 29AjayKumar |
<script> // Javascript implementation of above approach let MAX = (1e6 + 5) // Function to find answer of each query function query(arr,Q)
{ // Stores the count of points with sum
// less than or equal to their indices
let pre = new Array(MAX);
for (let i=0;i<MAX;i++)
pre[i]=0;
// Traverse the array
for (let i = 0; i < arr.length; i++)
{
// If both x and y-coordinate < 0
if (arr[i][0] < 0 || arr[i][1] < 0)
continue ;
// Stores the sum of co-ordinates
let sum = Math.ceil((arr[i][0] + arr[i][1]));
// Increment count of sum by 1
pre[sum]++;
}
// Prefix array
for (let i = 1; i < MAX; i++)
pre[i] += pre[i - 1];
// Perform queries
for (let i = 0; i < Q.length; i++)
{
document.write(pre[Q[i]]+ " " );
}
document.write( "<br>" );
} // Drivers Code let arr=[[ 2.1, 3.0 ], [ 3.7, 1.2 ],
[ 1.5, 6.5 ],
[ 1.2, 0.0 ] ];
let Q=[2, 8, 5]; let N = arr.length; let M = Q.length; query(arr, Q); // This code is contributed by unknown2108 </script> |
1 4 2
Time Complexity: O(N)
Auxiliary Space: O(N)