Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Find Partition Line such that sum of values on left and right is equal

  • Last Updated : 22 Oct, 2021

Consider n points on the Cartesian Coordinate Plane. Let point (Xi, Yi) is given a value Vi. A line parallel to y-axis is said to be a good partition line if sum of the point values on its left is equal to the sum of the point values on its right. Note that if a point lies on the partition line then it is not considered on either side of the line. The task is to print Yes if a good partition line exist else print No.
Example: 
 

Input: X[] = {-3, 5, 8}, Y[] = {8, 7, 9}, V[] = {8, 2, 10} 
Output: Yes 
 

x = c where 5 < c < 8 is a good partition 
line as sum of values on both sides is 10.
Input: X[] = {-2, 5, 8, 9}, Y[] = {7, 7, 9, 8}, V[] = {6, 2, 1, 8} 
Output: Yes 
 

 

Approach: 
 

  1. Count the value at each x-coordinate. This means that if there are multiple points with the same x-coordinate then they will be treated as a single point and their values will be added.
  2. Start from the minimum x-coordinate and check whether one of the following conditions is satisfied at Xi: 
    • Sum of the values till i – 1 is equal to sum of the values from i + 1 till n.
    • Sum of the values till i is equal to sum of the values from i + 1 till n.
    • Sum of the values till i – 1 is equal to sum of the values from i till n.
  3. If any of the above condition is satisfied for any given point then the line exists.

Below is the implementation of the above approach: 
 

C++




// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
const int MAX = 1000;
 
// Function that returns true if
// the required line exists
bool lineExists(int x[], int y[],
                int v[], int n)
{
 
    // To handle negative values from x[]
    int size = (2 * MAX) + 1;
    long arr[size] = { 0 };
 
    // Update arr[] such that arr[i] contains
    // the sum of all v[j] such that x[j] = i
    // for all valid values of j
    for (int i = 0; i < n; i++) {
        arr[x[i] + MAX] += v[i];
    }
 
    // Update arr[i] such that arr[i] contains
    // the sum of the subarray arr[0...i]
    // from the original array
    for (int i = 1; i < size; i++)
        arr[i] += arr[i - 1];
 
    // If all the points add to 0 then
    // the line can be drawn anywhere
    if (arr[size - 1] == 0)
        return true;
 
    // If the line is drawn touching the
    // leftmost possible points
    if (arr[size - 1] - arr[0] == 0)
        return true;
 
    for (int i = 1; i < size - 1; i++) {
 
        // If the line is drawn just before
        // the current point
        if (arr[i - 1] == arr[size - 1] - arr[i - 1])
            return true;
 
        // If the line is drawn touching
        // the current point
        if (arr[i - 1] == arr[size - 1] - arr[i])
            return true;
 
        // If the line is drawn just after
        // the current point
        if (arr[i] == arr[size - 1] - arr[i])
            return true;
    }
 
    // If the line is drawn touching the
    // rightmost possible points
    if (arr[size - 2] == 0)
        return true;
 
    return false;
}
 
// Driver code
int main()
{
    int x[] = { -3, 5, 8 };
    int y[] = { 8, 7, 9 };
    int v[] = { 8, 2, 10 };
    int n = sizeof(x) / sizeof(int);
 
    if (lineExists(x, y, v, n))
        cout << "Yes";
    else
        cout << "No";
 
    return 0;
}
Java



// Java implementation of the approach
class GFG
{
static int MAX = 1000;
 
// Function that returns true if
// the required line exists
static boolean lineExists(int x[], int y[],
                          int v[], int n)
{
 
    // To handle negative values from x[]
    int size = (2 * MAX) + 1;
    long []arr = new long[size];
 
    // Update arr[] such that arr[i] contains
    // the sum of all v[j] such that x[j] = i
    // for all valid values of j
    for (int i = 0; i < n; i++)
    {
        arr[x[i] + MAX] += v[i];
    }
 
    // Update arr[i] such that arr[i] contains
    // the sum of the subarray arr[0...i]
    // from the original array
    for (int i = 1; i < size; i++)
        arr[i] += arr[i - 1];
 
    // If all the points add to 0 then
    // the line can be drawn anywhere
    if (arr[size - 1] == 0)
        return true;
 
    // If the line is drawn touching the
    // leftmost possible points
    if (arr[size - 1] - arr[0] == 0)
        return true;
 
    for (int i = 1; i < size - 1; i++)
    {
 
        // If the line is drawn just before
        // the current point
        if (arr[i - 1] == arr[size - 1] - arr[i - 1])
            return true;
 
        // If the line is drawn touching
        // the current point
        if (arr[i - 1] == arr[size - 1] - arr[i])
            return true;
 
        // If the line is drawn just after
        // the current point
        if (arr[i] == arr[size - 1] - arr[i])
            return true;
    }
 
    // If the line is drawn touching the
    // rightmost possible points
    if (arr[size - 2] == 0)
        return true;
 
    return false;
}
 
// Driver code
public static void main(String []args)
{
    int x[] = { -3, 5, 8 };
    int y[] = { 8, 7, 9 };
    int v[] = { 8, 2, 10 };
    int n = x.length;
 
    if (lineExists(x, y, v, n))
        System.out.printf("Yes");
    else
        System.out.printf("No");
}
}
 
// This code is contributed by 29AjayKumar
Python3



# Python3 implementation of the approach
MAX = 1000;
 
# Function that returns true if
# the required line exists
def lineExists(x, y, v, n) :
 
    # To handle negative values from x[]
    size = (2 * MAX) + 1;
    arr = [0] * size ;
 
    # Update arr[] such that arr[i] contains
    # the sum of all v[j] such that x[j] = i
    # for all valid values of j
    for i in range(n) :
        arr[x[i] + MAX] += v[i];
 
    # Update arr[i] such that arr[i] contains
    # the sum of the subarray arr[0...i]
    # from the original array
    for i in range(1, size) :
        arr[i] += arr[i - 1];
 
    # If all the points add to 0 then
    # the line can be drawn anywhere
    if (arr[size - 1] == 0) :
        return True;
 
    # If the line is drawn touching the
    # leftmost possible points
    if (arr[size - 1] - arr[0] == 0) :
        return True;
 
    for i in range(1, size - 1) :
 
        # If the line is drawn just before
        # the current point
        if (arr[i - 1] == arr[size - 1] - arr[i - 1]) :
            return True;
 
        # If the line is drawn touching
        # the current point
        if (arr[i - 1] == arr[size - 1] - arr[i]) :
            return True;
 
        # If the line is drawn just after
        # the current point
        if (arr[i] == arr[size - 1] - arr[i]) :
            return True;
 
    # If the line is drawn touching the
    # rightmost possible points
    if (arr[size - 2] == 0) :
        return True;
 
    return False;
 
# Driver code
if __name__ == "__main__" :
 
    x = [ -3, 5, 8 ];
    y = [ 8, 7, 9 ];
    v = [ 8, 2, 10 ];
    n = len(x);
 
    if (lineExists(x, y, v, n)) :
        print("Yes");
    else :
        print("No");
 
# This code is contributed by AnkitRai01
C#



// C# implementation of the approach
using System;
     
class GFG
{
static int MAX = 1000;
 
// Function that returns true if
// the required line exists
static Boolean lineExists(int []x, int []y,
                          int []v, int n)
{
 
    // To handle negative values from x[]
    int size = (2 * MAX) + 1;
    long []arr = new long[size];
 
    // Update arr[] such that arr[i] contains
    // the sum of all v[j] such that x[j] = i
    // for all valid values of j
    for (int i = 0; i < n; i++)
    {
        arr[x[i] + MAX] += v[i];
    }
 
    // Update arr[i] such that arr[i] contains
    // the sum of the subarray arr[0...i]
    // from the original array
    for (int i = 1; i < size; i++)
        arr[i] += arr[i - 1];
 
    // If all the points add to 0 then
    // the line can be drawn anywhere
    if (arr[size - 1] == 0)
        return true;
 
    // If the line is drawn touching the
    // leftmost possible points
    if (arr[size - 1] - arr[0] == 0)
        return true;
 
    for (int i = 1; i < size - 1; i++)
    {
 
        // If the line is drawn just before
        // the current point
        if (arr[i - 1] == arr[size - 1] - arr[i - 1])
            return true;
 
        // If the line is drawn touching
        // the current point
        if (arr[i - 1] == arr[size - 1] - arr[i])
            return true;
 
        // If the line is drawn just after
        // the current point
        if (arr[i] == arr[size - 1] - arr[i])
            return true;
    }
 
    // If the line is drawn touching the
    // rightmost possible points
    if (arr[size - 2] == 0)
        return true;
 
    return false;
}
 
// Driver code
public static void Main(String []args)
{
    int []x = { -3, 5, 8 };
    int []y = { 8, 7, 9 };
    int []v = { 8, 2, 10 };
    int n = x.Length;
 
    if (lineExists(x, y, v, n))
        Console.WriteLine("Yes");
    else
        Console.WriteLine("No");
}
}
 
// This code is contributed by Rajput-Ji
Javascript



<script>
// Javascript implementation of the approach
const MAX = 1000;
 
// Function that returns true if
// the required line exists
function lineExists(x, y, v, n)
{
 
    // To handle negative values from x[]
    let size = (2 * MAX) + 1;
    let arr = new Array(size).fill(0);
 
    // Update arr[] such that arr[i] contains
    // the sum of all v[j] such that x[j] = i
    // for all valid values of j
    for (let i = 0; i < n; i++) {
        arr[x[i] + MAX] += v[i];
    }
 
    // Update arr[i] such that arr[i] contains
    // the sum of the subarray arr[0...i]
    // from the original array
    for (let i = 1; i < size; i++)
        arr[i] += arr[i - 1];
 
    // If all the points add to 0 then
    // the line can be drawn anywhere
    if (arr[size - 1] == 0)
        return true;
 
    // If the line is drawn touching the
    // leftmost possible points
    if (arr[size - 1] - arr[0] == 0)
        return true;
 
    for (let i = 1; i < size - 1; i++) {
 
        // If the line is drawn just before
        // the current point
        if (arr[i - 1] == arr[size - 1] - arr[i - 1])
            return true;
 
        // If the line is drawn touching
        // the current point
        if (arr[i - 1] == arr[size - 1] - arr[i])
            return true;
 
        // If the line is drawn just after
        // the current point
        if (arr[i] == arr[size - 1] - arr[i])
            return true;
    }
 
    // If the line is drawn touching the
    // rightmost possible points
    if (arr[size - 2] == 0)
        return true;
 
    return false;
}
 
// Driver code
let x = [-3, 5, 8];
let y = [8, 7, 9]
let v = [8, 2, 10];
let n = x.length;
 
if (lineExists(x, y, v, n))
    document.write("Yes");
else
    document.write("No");
 
// This code is contributed by _saurabh_jaiswal
</script>
Output: 
Yes
 

My Personal Notes
arrow_drop_up
Previous
Minimum number of moves to reach N starting from (1, 1)
Next

Python Data Types
Recommended Articles
Page :
Find an element in array such that sum of left array is equal to sum of right array
07, Sep 17
Partition array into two subarrays with every element in the right subarray strictly greater than every element in left subarray
01, Mar 21
Reorder an array such that sum of left half is not equal to sum of right half
16, Jun 20
Count of elements such that difference between sum of left and right sub arrays is equal to a multiple of k
17, Jan 20
Find the index having sum of elements on its left equal to reverse of the sum of elements on its right
13, Jan 21
Find the array element having equal sum of Prime Numbers on its left and right
11, May 21
Find the difference of count of equal elements on the right and the left for each element
22, Jul 19
Find the array element having equal count of Prime Numbers on its left and right
10, May 21
Find a permutation of 1 to N, such that A is minimum in left half and B is maximum in right half
21, Dec 21
Generate an array of maximum sum such that each element exceeds all elements present either on its left or right
03, Aug 21
Partition an array of non-negative integers into two subsets such that average of both the subsets is equal
11, Jul 19
Count ways to partition a string such that both parts have equal distinct characters
08, Apr 20
Partition of a set into K subsets with equal sum using BitMask and DP
12, Jun 20
Partition the array in K segments such that bitwise AND of individual segment sum is maximized
15, Jul 19
Equal sum array partition excluding a given element
24, Mar 18
Print equal sum sets of array (Partition problem) | Set 1
25, Mar 18
Check if it possible to partition in k subarrays with equal sum
05, Apr 18
Print equal sum sets of array (Partition Problem) | Set 2
12, May 18
Partition the array into three equal sum segments
21, Mar 19
Find maximum difference between nearest left and right smaller elements
28, Nov 16
Find the number of points that have atleast 1 point above, below, left or right of it
06, Feb 19
Find the maximum cost path from the bottom-left corner to the top-right corner
09, Aug 19
Partition into two subarrays of lengths k and (N - k) such that the difference of sums is maximum
15, Dec 17
Partition a set into two subsets such that difference between max of one and min of other is minimized
16, Jun 20
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
AshaRamMeena
@AshaRamMeena
Vote for difficulty





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!