Skip to content
Related Articles

Related Articles

Check if a point having maximum X and Y coordinates exists or not
  • Difficulty Level : Easy
  • Last Updated : 28 Apr, 2021

Given a 2D array arr[] consisting of N coordinates of the form (X, Y), the task is to find a coordinate from the given array such that the X-coordinate of this point is greater than all other X-coordinates and the Y-coordinate of this point is greater than all other Y-coordinates. If no such point exists, print -1.

Examples:

Input: arr[][] = {(1, 2), (2, 1), (3, 4), (4, 3), (5, 5)}
Output: (5, 5)
Explanation:
The maximum X-coordinate is 5 and the maximum Y-coordinate is 5.
Since the point (5, 5) is present in the array, print (5, 5) as the required answer.

Input: arr[] = {(5, 3), (3, 5)}
Output: -1
Explanation:
The maximum X-coordinate is 5 and maximum Y-coordinate is 5. Since+ (5, 5) is not present. Therefore, print -1. 

Naive Approach: The simplest approach is to traverse the array and for each point, check if it is the maximum X and Y-coordinates or not. If no such point exists, print -1. Otherwise, print the point as the required answer.



Below is the implementation of the above approach:

C++




// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Initialize INF as inifnity
int INF = INT_MAX;
 
// Function to return the point having
// maximum X and Y coordinates
int* findMaxPoint(int arr[][2], int i, int n)
{
     
    // Base Case
    if (i == n)
    {
        arr[0][0] = INF;
        arr[0][1] = INF;
        return arr[0];
    }
 
    // Stores if valid point exists
    bool flag = true;
 
    // If point arr[i] is valid
    for(int j = 0; j < n; j++)
    {
         
        // Check for the same point
        if (j == i)
            continue;
 
        // Check for a valid point
        if (arr[j][0] >= arr[i][0] ||
            arr[j][1] >= arr[i][1])
        {
            flag = false;
            break;
        }
    }
 
    // If current point is the
    // required point
    if (flag)
        return arr[i];
 
    // Otherwise
    return findMaxPoint(arr, i + 1, n);
}
 
// Function to find the required point
void findMaxPoints(int arr[][2], int n)
{
     
    // Stores the point with maximum
    // X and Y-coordinates
    int ans[2];
    memcpy(ans, findMaxPoint(arr, 0, n),
           2 * sizeof(int));
 
    // If no required point exists
    if (ans[0] == INF)
    {
        cout << -1;
    }
    else
    {
        cout << "(" << ans[0] << " "
             << ans[1] << ")";
    }
}
 
// Driver Code
int main()
{
     
    // Given array of points
    int arr[][2] = { { 1, 2 }, { 2, 1 },
                     { 3, 4 }, { 4, 3 },
                     { 5, 5 } };
 
    int N = sizeof(arr) / sizeof(arr[0]);
 
    // Function Call
    findMaxPoints(arr, N);
     
    return 0;
}
 
// This code is contributed by subhammahato348

Java




// Java program for the above approach
 
import java.io.*;
 
class GFG {
 
    // Initialize INF as inifnity
    static int INF = Integer.MAX_VALUE;
 
    // Function to return the point having
    // maximum X and Y coordinates
    static int[] findMaxPoint(
        int arr[][], int i, int n)
    {
        // Base Case
        if (i == n)
            return new int[] { INF, INF };
 
        // Stores if valid point exists
        boolean flag = true;
 
        // If point arr[i] is valid
        for (int j = 0; j < n; j++) {
 
            // Check for the same point
            if (j == i)
                continue;
 
            // Check for a valid point
            if (arr[j][0] >= arr[i][0]
                || arr[j][1] >= arr[i][1]) {
                flag = false;
                break;
            }
        }
 
        // If current point is the
        // required point
        if (flag)
            return arr[i];
 
        // Otherwise
        return findMaxPoint(arr, i + 1, n);
    }
 
    // Function to find the required point
    static void findMaxPoints(int arr[][],
                              int n)
    {
        // Stores the point with maximum
        // X and Y-coordinates
        int ans[] = findMaxPoint(arr, 0, n);
 
        // If no required point exists
        if (ans[0] == INF) {
            System.out.println(-1);
        }
        else {
            System.out.println(
                "(" + ans[0] + " "
                + ans[1] + ")");
        }
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        // Given array of points
        int arr[][] = new int[][] {{ 1, 2 }, { 2, 1 },
                                   { 3, 4 }, { 4, 3 },
                                   { 5, 5 }};
 
        int N = arr.length;
 
        // Function Call
        findMaxPoints(arr, N);
    }
}

Python3




# Python3 program for the above approach
import  sys
 
# Initialize INF as inifnity
INF = sys.maxsize;
 
# Function to return the pohaving
# maximum X and Y coordinates
def findMaxPoint(arr, i, n):
   
    # Base Case
    if (i == n):
        return [INF, INF]
 
    # Stores if valid poexists
    flag = True;
 
    # If poarr[i] is valid
    for j in range(n):
 
        # Check for the same point
        if (j == i):
            continue;
 
        # Check for a valid point
        if (arr[j][0] >= arr[i][0] or arr[j][1] >= arr[i][1]):
            flag = False;
            break;
 
    # If current pois the
    # required point
    if (flag):
        return arr[i];
 
    # Otherwise
    return findMaxPoint(arr, i + 1, n);
 
# Function to find the required point
def findMaxPoints(arr, n):
   
    # Stores the powith maximum
    # X and Y-coordinates
    ans = findMaxPoint(arr, 0, n);
 
    # If no required poexists
    if (ans[0] == INF):
        print(-1);
    else:
        print("(" , ans[0] , " " , ans[1] , ")");
 
# Driver Code
if __name__ == '__main__':
   
    # Given array of points
    arr = [[1, 2],
           [2, 1],
           [3, 4],
           [4, 3],
           [5, 5]];
 
    N = len(arr);
 
    # Function Call
    findMaxPoints(arr, N);
 
# This code is contributed by shikhasingrajput

C#




// C# program for the above approach
using System;
 
class GFG{
 
// Initialize INF as inifnity
static int INF = int.MaxValue;
 
// Function to return the point having
// maximum X and Y coordinates
static int[] findMaxPoint(int [,]arr, int i,
                          int n)
{
     
    // Base Case
    if (i == n)
        return new int[]{INF, INF};
 
    // Stores if valid point exists
    bool flag = true;
 
    // If point arr[i] is valid
    for(int j = 0; j < n; j++)
    {
         
        // Check for the same point
        if (j == i)
            continue;
 
        // Check for a valid point
        if (arr[j, 0] >= arr[i, 0] ||
            arr[j, 1] >= arr[i, 1])
        {
            flag = false;
            break;
        }
    }
 
    // If current point is the
    // required point
    int []ans  = new int[arr.GetLength(1)];
    if (flag)
    {
        for(int k = 0; k < ans.GetLength(0); k++)
            ans[k] = arr[i, k];
             
        return ans;
    }
 
    // Otherwise
    return findMaxPoint(arr, i + 1, n);
}
 
// Function to find the required point
static void findMaxPoints(int [,]arr,
                          int n)
{
     
    // Stores the point with maximum
    // X and Y-coordinates
    int []ans = findMaxPoint(arr, 0, n);
 
    // If no required point exists
    if (ans[0] == INF)
    {
        Console.WriteLine(-1);
    }
    else
    {
        Console.WriteLine("(" + ans[0] + " " +
                                ans[1] + ")");
    }
}
 
// Driver Code
public static void Main(String[] args)
{
     
    // Given array of points
    int [,]arr = new int[,]{ { 1, 2 }, { 2, 1 },
                             { 3, 4 }, { 4, 3 },
                             { 5, 5 } };
 
    int N = arr.GetLength(0);
 
    // Function Call
    findMaxPoints(arr, N);
}
}
 
// This code is contributed by Princi Singh

Javascript




<script>
 
// Javascript program for the above approach
 
// Initialize INF as inifnity
let INF = Number.MAX_VALUE;
 
// Function to return the polet having
// maximum X and Y coordinates
function findMaxPolet(arr, i, n)
{
     
    // Base Case
    if (i == n)
        return [INF, INF];
 
    // Stores if valid polet exists
    let flag = true;
 
    // If polet arr[i] is valid
    for(let j = 0; j < n; j++)
    {
         
        // Check for the same polet
        if (j == i)
            continue;
 
        // Check for a valid polet
        if (arr[j][0] >= arr[i][0] ||
            arr[j][1] >= arr[i][1])
        {
            flag = false;
            break;
        }
    }
 
    // If current polet is the
    // required polet
    if (flag)
        return arr[i];
 
    // Otherwise
    return findMaxPolet(arr, i + 1, n);
}
 
// Function to find the required polet
function findMaxPolets(arr, n)
{
     
    // Stores the polet with maximum
    // X and Y-coordinates
    let ans = findMaxPolet(arr, 0, n);
 
    // If no required polet exists
    if (ans[0] == INF)
    {
        document.write(-1);
    }
    else
    {
        document.write("(" + ans[0] + " " +
                             ans[1] + ")");
    }
}
 
// Driver code
 
// Given array of polets
let arr = [ [ 1, 2 ], [ 2, 1 ],
            [ 3, 4 ], [ 4, 3 ],
            [ 5, 5 ] ];
 
let N = arr.length;
 
// Function Call
findMaxPolets(arr, N);
 
// This code is contributed by splevel62
 
</script>
Output: 
(5 5)

 

Time Complexity: O(N2) where N is the length of the given array.
Auxiliary Space: O(N)

Efficient Approach: The idea is to find the maximum X and Y coordinates. Let them be maxX and maxY. Again traverse the given array checking if the point (maxX, maxY) is present. Follow the below steps to solve the problem:

  1. Traverse the given array arr[] and find the maximum X and Y coordinates. Let them be maxX and maxY.
  2. Again traverse the array arr[] from i = 0 to N-1 checking if (arr[i].X, arr[i].Y) is equals to (maxX, maxY).
  3. If the (maxX, maxY) is present in the array arr[], print (maxX, maxY) else print -1.

Below is the implementation of the above approach:

C++




// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
#define N 5
#define P 2
 
// Function to find the point having
// max X and Y coordinates
void findMaxPoint(int arr[N][P])
{
     
    // Initialize maxX and maxY
    int maxX = INT_MIN;
    int maxY = INT_MIN;
 
    // Length of the given array
    int n = N;
 
    // Get maximum X & Y coordinates
    for(int i = 0; i < n; i++)
    {
        maxX = max(maxX, arr[i][0]);
        maxY = max(maxY, arr[i][1]);
    }
 
    // Check if the required point
    // i.e., (maxX, maxY) is present
    for(int i = 0; i < n; i++)
    {
         
        // If point with maximum X and
        // Y coordinates is present
        if (maxX == arr[i][0] &&
            maxY == arr[i][1])
        {
            cout << "(" << maxX << ", "
                        << maxY << ")";
                  
            return;
        }
    }
 
    // If no such point exists
    cout << (-1);
}
 
// Driver Code
int main()
{
     
    // Given array of points
    int arr[N][P] = { { 1, 2 }, { 2, 1 },
                      { 3, 4 }, { 4, 3 },
                      { 5, 5 } };
 
    // Print answer
    findMaxPoint(arr);
}
 
// This code is contributed by 29AjayKumar

Java




// Java program for the above approach
 
import java.io.*;
 
class GFG {
 
    // Function to find the point having
    // max X and Y coordinates
    static void findMaxPoint(int arr[][])
    {
        // Initialize maxX and maxY
        int maxX = Integer.MIN_VALUE;
        int maxY = Integer.MIN_VALUE;
 
        // Length of the given array
        int n = arr.length;
 
        // Get maximum X & Y coordinates
        for (int i = 0; i < n; i++) {
            maxX = Math.max(maxX, arr[i][0]);
            maxY = Math.max(maxY, arr[i][1]);
        }
 
        // Check if the required point
        // i.e., (maxX, maxY) is present
        for (int i = 0; i < n; i++) {
 
            // If point with maximum X and
            // Y coordinates is present
            if (maxX == arr[i][0]
                && maxY == arr[i][1]) {
 
                System.out.println(
                    "(" + maxX + ", "
                    + maxY + ")");
                return;
            }
        }
 
        // If no such point exists
        System.out.println(-1);
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        // Given array of points
        int arr[][] = new int[][] {{ 1, 2 }, { 2, 1 },
                                   { 3, 4 }, { 4, 3 },
                                   { 5, 5 }};
 
        // Print answer
        findMaxPoint(arr);
    }
}

Python3




# Python3 program for the above approach
import sys;
 
# Function to find the pohaving
# max X and Y coordinates
def findMaxPoint(arr):
     
    # Initialize maxX and maxY
    maxX = -sys.maxsize;
    maxY = -sys.maxsize;
 
    # Length of the given array
    n = len(arr);
 
    # Get maximum X & Y coordinates
    for i in range(n):
        maxX = max(maxX, arr[i][0]);
        maxY = max(maxY, arr[i][1]);
 
    # Check if the required point
    # i.e., (maxX, maxY) is present
    for i in range(n):
 
        # If powith maximum X and
        # Y coordinates is present
        if (maxX == arr[i][0] and maxY == arr[i][1]):
            print("(" , maxX , ", " , maxY , ")");
            return;
 
    # If no such poexists
    print(-1);
 
# Driver Code
if __name__ == '__main__':
   
    # Given array of points
    arr = [[1, 2], [2, 1], [3, 4], [4, 3], [5, 5]];
 
    # Pranswer
    findMaxPoint(arr);
 
# This code is contributed by gauravrajput1

C#




// C# program for the above approach
using System;
 
class GFG{
 
// Function to find the point having
// max X and Y coordinates
static void findMaxPoint(int [,]arr)
{
     
    // Initialize maxX and maxY
    int maxX = int.MinValue;
    int maxY = int.MinValue;
 
    // Length of the given array
    int n = arr.GetLength(0);
 
    // Get maximum X & Y coordinates
    for(int i = 0; i < n; i++)
    {
        maxX = Math.Max(maxX, arr[i, 0]);
        maxY = Math.Max(maxY, arr[i, 1]);
    }
 
    // Check if the required point
    // i.e., (maxX, maxY) is present
    for(int i = 0; i < n; i++)
    {
         
        // If point with maximum X and
        // Y coordinates is present
        if (maxX == arr[i, 0] &&
            maxY == arr[i, 1])
        {
            Console.WriteLine("(" + maxX + ", " +
                                    maxY + ")");
            return;
        }
    }
 
    // If no such point exists
    Console.WriteLine(-1);
}
 
// Driver Code
public static void Main(String[] args)
{
     
    // Given array of points
    int [,]arr = new int[,]{ { 1, 2 }, { 2, 1 },
                             { 3, 4 }, { 4, 3 },
                             { 5, 5 } };
 
    // Print answer
    findMaxPoint(arr);
}
}
 
// This code is contributed by Amit Katiyar
Output: 
(5, 5)

 

Time Complexity: O(N)
Auxiliary Space: O(N)

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up
Recommended Articles
Page :