# Maximum rods to put horizontally such that no two rods overlap on X coordinate

• Last Updated : 22 Oct, 2021

Given two arrays X[] and H[] of size N, where X[i] denotes the X-coordinate of the ith vertical rod and H[i] denotes the height of that rod, and also given that an ith rod can also be put horizontally, by either placing the rod on the segment [X[i]-H[i], X[i]] or [X[i], X[i]+H[i]] on the X coordinate, the task is to find the maximum number of rods that can be put horizontally such that no two rods overlap on the X coordinate.

Examples:

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Input: N = 3, X[] = {1, 2, 3}, H[] = {2, 5, 5}
Output: 2
Explanation:
One possible way to place the rods is:

1. Put the rod at X( = 1) horizontally on the left of X i.e on the segment [-1, 1].
2. Let the rod placed at position X( = 2) be vertical.
3. Put the rod at X( = 3) horizontally on the right of X i.e on the segment [3, 8].

Therefore, 2 rods can be put horizontally. And it is also the maximum possible count.

Input: N = 3, X[] = {1, 2, 5}, H[] = {1, 2, 5}
Output: 3

Approach: The problem can be solved by using the Greedy algorithm. Follow the steps below to solve the problem:

• Initialize two variables, say, ans as 0 to store the answer and prev as INT_MIN to store the last occupied point on X coordinate.
• Iterate over the range [0, N] using the variable i and perform the following steps:
• If the current rod can be put on the left, i.e if  X[i]-H[i] is greater than prev, then increment the value of ans by 1 and update prev to X[i].
• Else, if the current rod can be put on the right, i.e if  X[i]+H[i] is less than X[i+1], then increment the value of ans by 1 and update prev to X[i]+H[i].
• Else, update prev to X[i].
• Finally, after completing the above steps, print the answer obtained in ans.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ` `using` `namespace` `std;` `// Function to find the maximum number``// of rods that can be put horizontally``int` `findMaximumPoints(``int` `N, ``int` `X[], ``int` `H[])``{` `    ``// Stores the result``    ``int` `ans = 0;` `    ``// Stores the last occupied point``    ``int` `prev = INT_MIN;` `    ``// Traverse the array arr[]``    ``for` `(``int` `i = 0; i < N; ++i) {` `        ``// If the current point can be put on``        ``// the left side``        ``if` `(prev < (X[i] - H[i])) {` `            ``// Increment the ans by 1``            ``++ans;` `            ``// Update prev``            ``prev = X[i];``        ``}` `        ``// Else if the given point can be put``        ``// on the right side``        ``else` `if` `(i == N - 1``                 ``|| (X[i] + H[i]) < X[i + 1]) {` `            ``// Increment the ans by 1``            ``++ans;` `            ``// Update prev``            ``prev = X[i] + H[i];``        ``}` `        ``// Otherwise,``        ``else` `{``            ``// Update prev``            ``prev = X[i];``        ``}``    ``}` `    ``// Return the ans``    ``return` `ans;``}` `// Driver Code``int` `main()``{` `    ``int` `X[] = { 1, 2, 3 };``    ``int` `H[] = { 2, 5, 5 };``    ``int` `N = ``sizeof``(X) / ``sizeof``(X);` `    ``cout << findMaximumPoints(N, X, H);``}`

## Java

 `// Java program for the above approach` `class` `GFG {` `    ``// Function to find the maximum number``    ``// of rods that can be put horizontally``    ``public` `static` `int` `findMaximumPoints(``int` `N, ``int` `X[], ``int` `H[]) {` `        ``// Stores the result``        ``int` `ans = ``0``;` `        ``// Stores the last occupied point``        ``int` `prev = Integer.MIN_VALUE;` `        ``// Traverse the array arr[]``        ``for` `(``int` `i = ``0``; i < N; ++i) {` `            ``// If the current point can be put on``            ``// the left side``            ``if` `(prev < (X[i] - H[i])) {` `                ``// Increment the ans by 1``                ``++ans;` `                ``// Update prev``                ``prev = X[i];``            ``}` `            ``// Else if the given point can be put``            ``// on the right side``            ``else` `if` `(i == N - ``1` `|| (X[i] + H[i]) < X[i + ``1``]) {` `                ``// Increment the ans by 1``                ``++ans;` `                ``// Update prev``                ``prev = X[i] + H[i];``            ``}` `            ``// Otherwise,``            ``else` `{``                ``// Update prev``                ``prev = X[i];``            ``}``        ``}` `        ``// Return the ans``        ``return` `ans;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String args[]) {` `        ``int` `X[] = { ``1``, ``2``, ``3` `};``        ``int` `H[] = { ``2``, ``5``, ``5` `};``        ``int` `N = X.length;` `        ``System.out.println(findMaximumPoints(N, X, H));``    ``}``}` `// This code is contributed by _saurabh_jaiswal.`

## Python3

 `# Python 3 program for the above approach``import` `sys` `# Function to find the maximum number``# of rods that can be put horizontally``def` `findMaximumPoints(N, X, H):``    ``# Stores the result``    ``ans ``=` `0` `    ``# Stores the last occupied point``    ``prev ``=` `-``sys.maxsize``-``1` `    ``# Traverse the array arr[]``    ``for` `i ``in` `range``(N):``      ` `        ``# If the current point can be put on``        ``# the left side``        ``if` `(prev < (X[i] ``-` `H[i])):` `            ``# Increment the ans by 1``            ``ans ``+``=` `1` `            ``# Update prev``            ``prev ``=` `X[i]` `        ``# Else if the given point can be put``        ``# on the right side``        ``elif``(i ``=``=` `N ``-` `1` `or` `(X[i] ``+` `H[i]) < X[i ``+` `1``]):` `            ``# Increment the ans by 1``            ``ans ``+``=` `1` `            ``# Update prev``            ``prev ``=` `X[i] ``+` `H[i]` `        ``# Otherwise,``        ``else``:``            ``# Update prev``            ``prev ``=` `X[i]` `    ``# Return the ans``    ``return` `ans` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ``X ``=` `[``1``, ``2``, ``3``]``    ``H ``=` `[``2``, ``5``, ``5``]``    ``N ``=` `len``(X)` `    ``print``(findMaximumPoints(N, X, H))``    ` `    ``# This code is contributed by SURENDRA_GANGWAR.`

## C#

 `// C# program for the above approach``using` `System;` `class` `GFG{``    ` `    ``// Function to find the maximum number``    ``// of rods that can be put horizontally``    ``public` `static` `int` `findMaximumPoints(``int` `N, ``int``[] X, ``int``[] H) {` `        ``// Stores the result``        ``int` `ans = 0;` `        ``// Stores the last occupied point``        ``int` `prev = Int32.MinValue;` `        ``// Traverse the array arr[]``        ``for` `(``int` `i = 0; i < N; ++i) {` `            ``// If the current point can be put on``            ``// the left side``            ``if` `(prev < (X[i] - H[i])) {` `                ``// Increment the ans by 1``                ``++ans;` `                ``// Update prev``                ``prev = X[i];``            ``}` `            ``// Else if the given point can be put``            ``// on the right side``            ``else` `if` `(i == N - 1 || (X[i] + H[i]) < X[i + 1]) {` `                ``// Increment the ans by 1``                ``++ans;` `                ``// Update prev``                ``prev = X[i] + H[i];``            ``}` `            ``// Otherwise,``            ``else` `{``                ``// Update prev``                ``prev = X[i];``            ``}``        ``}` `        ``// Return the ans``        ``return` `ans;``    ``}`  `// Driver code``static` `public` `void` `Main()``{``    ``int``[] X = { 1, 2, 3 };``        ``int``[] H = { 2, 5, 5 };``        ``int` `N = X.Length;` `        ``Console.WriteLine(findMaximumPoints(N, X, H));``}``}` `// This code is contributed by sanjoy_62.`

## Javascript

 ``
Output
`2`

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

My Personal Notes arrow_drop_up