There are **n** people and two identical voting machines. We are also given an array **a[]** of size n such that **a[i]** stores time required by i-th person to go to any machine, mark his vote and come back. At one time instant, only one person can be there on each of the machines. Given a value x, defining the maximum allowable time for which machines are operational, check whether all persons can cast their vote or not.

**Examples:**

Input : n = 3, x = 4 a[] = {2, 4, 2} Output: YES There are n = 3 persons say and maximum allowed time is x = 4 units. Let the persons be P0, P1, and P2 and two machines be M0 and M1. At t0: P0 goes to M0 At t0: P2 goes to M1 At t2: M0 is free, p3 goes to M0 At t4: both M0 and M1 are free and all 3 have given their vote.

**Method 1**

Let **sum** be the total time taken by all n people. If sum <=x, then answer will obviously be YES. Otherwise, we need to check whether the given array can be split into two parts such that the sum of the first part and sum of the second part are both less than or equal to x. The problem is similar to the knapsack problem. Imagine two knapsacks each with capacity x. Now find, maximum people who can vote on any one machine i.e. find maximum subset sum for a knapsack of capacity x. Let this sum be s1. Now if (sum-s1) <= x, then answer is YES else answer is NO.

## C++

`// C++ program to check if all people can ` `// vote using two machines within limited ` `// time ` `#include<bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `// Returns true if n people can vote using ` `// two machines in x time. ` `bool` `canVote(` `int` `a[], ` `int` `n, ` `int` `x) ` `{ ` ` ` `// dp[i][j] stores maximum possible number ` ` ` `// of people among arr[0..i-1] can vote ` ` ` `// in j time. ` ` ` `int` `dp[n+1][x+1]; ` ` ` `memset` `(dp, 0, ` `sizeof` `(dp)); ` ` ` ` ` `// Find sum of all times ` ` ` `int` `sum = 0; ` ` ` `for` `(` `int` `i=0; i<=n; i++ ) ` ` ` `sum += a[i]; ` ` ` ` ` `// Fill dp[][] in bottom up manner (Similar ` ` ` `// to knapsack). ` ` ` `for` `(` `int` `i=1; i<=n; i++) ` ` ` `for` `(` `int` `j=1; j<=x; j++) ` ` ` `if` `(a[i] <= j) ` ` ` `dp[i][j] = max(dp[i-1][j], ` ` ` `a[i] + dp[i-1][j-a[i]]); ` ` ` `else` ` ` `dp[i][j] = dp[i-1][j]; ` ` ` ` ` `// If remaining people can go to other machine. ` ` ` `return` `(sum - dp[n][x] <= x); ` `} ` ` ` `// Driver code ` `int` `main() ` `{ ` ` ` `int` `n = 3, x = 4; ` ` ` `int` `a[] = {2, 4, 2}; ` ` ` `canVote(a, n, x)? cout << ` `"YES\n"` `: ` ` ` `cout << ` `"NO\n"` `; ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

## Python3

`# Python3 program to check if all people can ` `# vote using two machines within limited ` `# time ` ` ` `# Function returns true if n people can vote ` `# using two machines in x time. ` `def` `canVote(a, n, x): ` ` ` ` ` `# dp[i][j] stores maximum possible number ` ` ` `# of people among arr[0..i-1] can vote ` ` ` `# in j time. ` ` ` `dp ` `=` `[[` `0` `] ` `*` `(x ` `+` `1` `) ` `for` `_ ` `in` `range` `(n ` `+` `1` `)] ` ` ` `a ` `=` `a[:] ` ` ` `a.append(` `0` `) ` ` ` ` ` `# Find sum of all times ` ` ` `sm ` `=` `0` ` ` `for` `i ` `in` `range` `(n ` `+` `1` `): ` ` ` `sm ` `+` `=` `a[i] ` ` ` ` ` `# Fill dp[][] in bottom up manner ` ` ` `# (Similar to knapsack). ` ` ` `for` `i ` `in` `range` `(` `1` `, n ` `+` `1` `): ` ` ` `for` `j ` `in` `range` `(` `1` `, x ` `+` `1` `): ` ` ` `if` `a[i] <` `=` `j: ` ` ` `dp[i][j] ` `=` `max` `(dp[i ` `-` `1` `][j], a[i] ` `+` ` ` `dp[i ` `-` `1` `][j ` `-` `a[i]]) ` ` ` `else` `: ` ` ` `dp[i][j] ` `=` `dp[i ` `-` `1` `][j] ` ` ` ` ` `# If remaining people can go to other machine. ` ` ` `return` `(sm ` `-` `dp[n][x]) <` `=` `x ` ` ` `# Driver Code ` `if` `__name__ ` `=` `=` `"__main__"` `: ` ` ` `n ` `=` `3` ` ` `x ` `=` `4` ` ` `a ` `=` `[` `2` `, ` `4` `, ` `2` `] ` ` ` `print` `(` `"YES"` `if` `canVote(a, n, x) ` `else` `"NO"` `) ` ` ` `# This code is contributed ` `# by vibhu4agarwal ` |

*chevron_right*

*filter_none*

**Output:**

YES

**Time Complexity:** O(x * n)

**Auxiliary Space:** O(x * n)

This article is contributed by **Ekta Goel**. 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.

**Method 2**

The above method uses O(x * n) extra space, here we give a method that uses O(n) extra space.

Idea is to sort the array and then check if we can get any two array that can be a subarray which can be between the start and end of array such that its sum less than or equal to x and the sum of reamining elements is also less than x.

We use prefix sum for this purpose. We set i and j and check if sorted array between i to j – 1 gives sum <= x and the remaining elements also sum to sum <= x.

## C++

`// C++ program to check if all people can ` `// vote using two machines within limited ` `// time ` `#include<bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `// Returns true if n people can vote using ` `// two machines in x time. ` `bool` `canVote(vector<` `int` `> a, ` `int` `n, ` `int` `x) ` `{ ` ` ` `// calculate total sum i.e total ` ` ` `// time taken by all people ` ` ` `int` `total_sum = 0; ` ` ` `for` `(` `auto` `x : a){ ` ` ` `total_sum += x; ` ` ` `} ` ` ` ` ` `// if total time is less than x then ` ` ` `// all people can definitely vote ` ` ` `// hence return true ` ` ` `if` `(total_sum <= x) ` ` ` `return` `true` `; ` ` ` ` ` `// sort the vector ` ` ` `sort(a.begin(), a.end()); ` ` ` ` ` `// declare a vector presum of same size ` ` ` `// as that of a and initialize it with 0 ` ` ` `vector<` `int` `> presum(a.size(), 0); ` ` ` ` ` `// prefixsum for first element ` ` ` `// will be element itself ` ` ` `presum[0] = a[0]; ` ` ` `// fill the array ` ` ` `for` `(` `int` `i = 1; i < presum.size(); i++){ ` ` ` `presum[i] = presum[i - 1] + a[i]; ` ` ` `} ` ` ` ` ` `// Set i and j and check if array ` ` ` `// from i to j - 1 gives sum <= x ` ` ` `for` `(` `int` `i = 0; i < presum.size(); i++){ ` ` ` `for` `(` `int` `j = i + 1; j < presum.size(); j++){ ` ` ` `int` `arr1_sum = (presum[i] + ` ` ` `(total_sum - presum[j])); ` ` ` `if` `((arr1_sum <= x) && ` ` ` `(total_sum - arr1_sum) <= x) ` ` ` `return` `true` `; ` ` ` `} ` ` ` `} ` ` ` ` ` `return` `false` `; ` `} ` ` ` `// Driver code ` `int` `main() ` `{ ` ` ` `int` `n = 3, x = 4; ` ` ` `vector<` `int` `>a = {2, 4, 2}; ` ` ` `canVote(a, n, x)? cout << ` `"YES\n"` `: ` ` ` `cout << ` `"NO\n"` `; ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

## Python3

`# Python3 program to check if all people can ` `# vote using two machines within limited ` `# time ` ` ` `# Returns true if n people can vote using ` `# two machines in x time. ` `def` `canVote(a, n, x): ` ` ` ` ` `# calculate total sum i.e total ` ` ` `# time taken by all people ` ` ` `total_sum ` `=` `0` ` ` `for` `i ` `in` `range` `(` `len` `(a)): ` ` ` `total_sum ` `+` `=` `a[i] ` ` ` ` ` `# if total time is less than x then ` ` ` `# all people can definitely vote ` ` ` `# hence return true ` ` ` `if` `(total_sum <` `=` `x): ` ` ` `return` `True` ` ` ` ` `# sort the list ` ` ` `a.sort() ` ` ` ` ` `# declare a list presum of same size ` ` ` `# as that of a and initialize it with 0 ` ` ` `presum ` `=` `[` `0` `for` `i ` `in` `range` `(` `len` `(a))] ` ` ` ` ` `# prefixsum for first element ` ` ` `# will be element itself ` ` ` `presum[` `0` `] ` `=` `a[` `0` `] ` ` ` ` ` `# fill the array ` ` ` `for` `i ` `in` `range` `(` `1` `, ` `len` `(presum)): ` ` ` `presum[i] ` `=` `presum[i ` `-` `1` `] ` `+` `a[i] ` ` ` ` ` `# Set i and j and check if array ` ` ` `# from i to j - 1 gives sum <= x ` ` ` `for` `i ` `in` `range` `(` `0` `, ` `len` `(presum)): ` ` ` `for` `j ` `in` `range` `(i ` `+` `1` `, ` `len` `(presum)): ` ` ` `arr1_sum ` `=` `(presum[i] ` `+` `(total_sum ` `-` `presum[j])) ` ` ` `if` `((arr1_sum <` `=` `x) ` `and` ` ` `(total_sum ` `-` `arr1_sum) <` `=` `x): ` ` ` `return` `True` ` ` ` ` `return` `False` ` ` `# Driver code ` `n ` `=` `3` `x ` `=` `4` `a ` `=` `[` `2` `, ` `4` `, ` `2` `] ` `if` `(canVote(a, n, x)): ` ` ` `print` `(` `"YES"` `) ` `else` `: ` ` ` `print` `(` `"NO"` `) ` ` ` `# This code is contributed by ashutosh450 ` |

*chevron_right*

*filter_none*

**Time Complexity:** O(n * n)

**Auxiliary Space:** O(n)

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

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.

## Recommended Posts:

- Number of ways to pair people
- Find number of edges that can be broken in a tree such that Bitwise OR of resulting two trees are equal
- Check if array sum can be made K by three operations on it
- Check if N can be converted to the form K power K by the given operation
- Check if a substring can be Palindromic by replacing K characters for Q queries
- Check if one string can be converted to other using given operation
- Check if an array can be split into 3 subsequences of equal sum or not
- Minimum number of coins that can generate all the values in the given range
- Maximum sum of Bitwise XOR of all elements of two equal length subsets
- Check whether row or column swaps produce maximum size binary sub-matrix with all 1s
- Largest subsequence such that all indices and all values are multiples individually
- Count of strings that can be formed using a, b and c under given constraints
- Counting pairs when a person can form pair with at most one
- Number of ways a convex polygon of n+2 sides can split into triangles by connecting vertices
- Find maximum points which can be obtained by deleting elements from array
- Total number of different staircase that can made from N boxes
- Number of balanced bracket expressions that can be formed from a string
- Maximum items that can be filled in K Knapsacks of given Capacity
- Maximum number of strings that can be formed with given zeros and ones
- Longest subarray whose elements can be made equal by maximum K increments