Maximum number of people that can be killed with strength P

30 May, 2022
There are infinite people standing in a row, indexed from 1. A person having index i has strength of i2. You have strength P and the task is to tell what is the maximum number of people you can kill with strength P. You can only kill a person with strength X if P ≥ X and after killing him, your strength decreases by X. 
Examples: 
Input: P = 14 Output: 3 Explaination: First person will have strength 12 = 1 which is < P P gets reduced to 13 after the first kill. Second kill, P = 13 – 22 = 9 Third kill, P = 9 – 32 = 0
Input: P = 58 Output: 5 
Naive approach: Check every single kill starting from 1 until the strength P is greater than or equal to the strength of the person being killed.
Below is the implementation of the above approach:  
C++
C
Java
Python3
C#
Javascript
// C++ implementation of the approach#include <bits/stdc++.h>using namespace std; // Function to return the maximum number of people that can// be killedint maxPeople(int p){    int tmp = 0, count = 0;     // Loop will break when the ith person cannot be killed    for (int i = 1; i * i <= p; i++) {        tmp = tmp + (i * i);        if (tmp <= p)            count++;        else            break;    }    return count;} // Driver codeint main(){    int p = 14;    cout << maxPeople(p);     return 0;} // This code is contributed by Aditya Kumar (adityakumar129)
// C implementation of the approach#include <stdio.h> // Function to return the maximum number of people that can// be killedint maxPeople(int p){    int tmp = 0, count = 0;     // Loop will break when the ith person cannot be killed    for (int i = 1; i * i <= p; i++) {        tmp = tmp + (i * i);        if (tmp <= p)            count++;        else            break;    }    return count;} // Driver codeint main(){    int p = 14;    printf("%d", maxPeople(p));     return 0;} // This code is contributed by Aditya Kumar (adityakumar129)
// Java implementation of the approachimport java.util.*; class GFG {    // Function to return the maximum number of people that    // can be killed    static int maxPeople(int p)    {        int tmp = 0, count = 0;         // Loop will break when the ith person cannot be        // killed        for (int i = 1; i * i <= p; i++) {            tmp = tmp + (i * i);            if (tmp <= p)                count++;            else                break;        }        return count;    }     // Driver code    public static void main(String args[])    {        int p = 14;        System.out.println(maxPeople(p));    }} // This code is contributed by Aditya Kumar (adityakumar129)
# Python3 implementation of the approach from math import sqrt # Function to return the maximum# number of people that can be killeddef maxPeople(p) :         tmp = 0; count = 0;     # Loop will break when the ith person    # cannot be killed    for i in range(1, int(sqrt(p)) + 1) :        tmp = tmp + (i * i);        if (tmp <= p) :            count += 1;        else :            break;         return count;  # Driver codeif __name__ == "__main__" :     p = 14;    print(maxPeople(p));     # This code is contributed by AnkitRai01
// C# implementation of the approachusing System; class GFG{     // Function to return the maximum// number of people that can be killedstatic int maxPeople(int p){    int tmp = 0, count = 0;     // Loop will break when the ith person    // cannot be killed    for (int i = 1; i * i <= p; i++)    {        tmp = tmp + (i * i);        if (tmp <= p)            count++;        else            break;    }    return count;} // Driver codepublic static void Main(){    int p = 14;    Console.WriteLine(maxPeople(p));}} // This code is contributed by anuj_67..
<script> // javascript implementation of the approach   // Function to return the maximum// number of people that can be killedfunction maxPeople(p){    var tmp = 0, count = 0;     // Loop will break when the ith person    // cannot be killed    for (var i = 1; i * i <= p; i++)    {        tmp = tmp + (i * i);        if (tmp <= p)            count++;        else            break;    }    return count;} // Driver code var p = 14;document.write(maxPeople(p)); // This code is contributed by Amit Katiyar </script>
3
Time Complexity: O(sqrt(N)), where N is the initial strength.Auxiliary Space: O(1)
Efficient approach: We can see if we kill ith person then we have already killed (i – 1)th person. This means it is a monotonic function f whose domain is the set of integers. Now we can apply binary search on this monotonic function in which instead of array lookup we are now looking for some x such that f(x) is equal to the target value. Time complexity reduces to O(Log(n)).
Below is the implementation of the above approach:  
C++
Java
Python3
C#
Javascript
// C++ implementation of the approach#include <algorithm>#include <bits/stdc++.h>using namespace std;#define ll long long static constexpr int kN = 1000000; // Function to return the maximum// number of people that can be killedint maxPeople(int p){    // Storing the sum beforehand so that    // it can be used in each query    ll sums[kN];    sums[0] = 0;    for (int i = 1; i < kN; i++)        sums[i] = (ll)(i * i) + sums[i - 1];     // lower_bound returns an iterator pointing to the    // first element greater than or equal to your val    auto it = std::lower_bound(sums, sums + kN, p);    if (*it > p) {         // Previous value        --it;    }     // Returns the index in array upto which    // killing is possible with strength P    return (it - sums);} // Driver codeint main(){    int p = 14;    cout << maxPeople(p);     return 0;}
// Java implementation of the approachclass GFG{ static int kN = 1000000; // Function to return the maximum// number of people that can be killedstatic int maxPeople(int p){    // Storing the sum beforehand so that    // it can be used in each query    long []sums = new long[kN];    sums[0] = 0;    for (int i = 1; i < kN; i++)        sums[i] = (long)(i * i) + sums[i - 1];     // lower_bound returns an iterator pointing to the    // first element greater than or equal to your val    int it = lower_bound(sums, 0, kN, p);    if (sums[it] > p)    {         // Previous value        --it;    }     // Returns the index in array upto which    // killing is possible with strength P    return it;}private static int lower_bound(long[] a, int low,                            int high, int element){    while(low < high)    {        int middle = low + (high - low)/2;        if(element > a[middle])            low = middle + 1;        else            high = middle;    }    return low;} // Driver codepublic static void main(String[] args){    int p = 14;    System.out.println(maxPeople(p));}} /* This code is contributed by PrinciRaj1992 */
# Python3 implementation of the approachkN = 1000000; # Function to return the maximum# number of people that can be killeddef maxPeople(p):     # Storing the sum beforehand so that    # it can be used in each query    sums = [0] * kN;    sums[0] = 0;    for i in range(1, kN):        sums[i] = (i * i) + sums[i - 1];     # lower_bound returns an iterator    # pointing to the first element    # greater than or equal to your val    it = lower_bound(sums, 0, kN, p);    if (it > p):         # Previous value        it -= 1;     # Returns the index in array upto which    # killing is possible with strength P    return it; def lower_bound(a, low, high, element):    while(low < high):        middle = int(low + (high - low) / 2);        if(element > a[middle]):            low = middle + 1;        else:            high = middle;    return low; # Driver codeif __name__ == '__main__':    p = 14;    print(maxPeople(p)); # This code contributed by Rajput-Ji
// C# implementation of the approachusing System;         public class GFG{ static int kN = 1000000; // Function to return the maximum// number of people that can be killedstatic int maxPeople(int p){    // Storing the sum beforehand so that    // it can be used in each query    long []sums = new long[kN];    sums[0] = 0;    for (int i = 1; i < kN; i++)        sums[i] = (long)(i * i) + sums[i - 1];     // lower_bound returns an iterator pointing to the    // first element greater than or equal to your val    int it = lower_bound(sums, 0, kN, p);    if (it > p)    {         // Previous value        --it;    }     // Returns the index in array upto which    // killing is possible with strength P    return it;}private static int lower_bound(long[] a, int low,                            int high, int element){    while(low < high)    {        int middle = low + (high - low)/2;        if(element > a[middle])            low = middle + 1;        else            high = middle;    }    return low;} // Driver codepublic static void Main(String[] args){    int p = 14;    Console.WriteLine(maxPeople(p));}} // This code has been contributed by 29AjayKumar
<script>// Javascript implementation of the approach const kN = 1000000; // Function to return the maximum// number of people that can be killedfunction maxPeople(p){    // Storing the sum beforehand so that    // it can be used in each query    let sums = new Array(kN);    sums[0] = 0;    for (let i = 1; i < kN; i++)        sums[i] = (i * i) + sums[i - 1];     // lower_bound returns an iterator pointing to the    // first element greater than or equal to your val    let it = lower_bound(sums, 0, kN, p);    if (it > p) {         // Previous value        --it;    }     // Returns the index in array upto which    // killing is possible with strength P    return it;} function lower_bound(a, low, high, element){    while(low < high)    {        let middle = low + parseInt((high - low)/2);        if(element > a[middle])            low = middle + 1;        else            high = middle;    }    return low;} // Driver code    let p = 14;    document.write(maxPeople(p)); </script>
3
Time Complexity: O(1000000)
Auxiliary Space: O(1000000)
More Efficient Approach : We can do the same problem in time complexity O(logn) and Space Complexity in O(1). Start your binary search by considering the value of low as 0 and high as 10^15. We will calculate the mid-value and according to mid, we will change the position of low and high. 
Below is the implementation of the above approach. 
C++
Java
Python3
C#
Javascript
// C++ implementation of the approach#include <algorithm>#include <bits/stdc++.h>using namespace std;     // Helper function which returns the sum// of series (1^2 + 2^2 +...+ n^2)long squareSeries(long n){    return(n * (n + 1) * (2 * n + 1)) / 6;} // maxPeople function which returns// appropriate value using Binary Search// in O(logn)long maxPeople(long n){         // Set the lower and higher values    long low = 0;    long high = 1000000L;    long ans = 0L;         while (low <= high)    {                 // Calculate the mid using        // low and high        long mid = low + ((high - low) / 2);        long value = squareSeries(mid);         // Compare value with n        if (value <= n)        {            ans = mid;            low = mid + 1;        }        else        {            high = mid - 1;        }    }         // Return the ans    return ans;} // Driver codeint main(){    long p = 14;         cout<<maxPeople(p);    return 0;}  // This code contributed by shikhasingrajput
// Java implementation of the approachclass GFG{     // Helper function which returns the sum// of series (1^2 + 2^2 +...+ n^2)static long squareSeries(long n){    return(n * (n + 1) * (2 * n + 1)) / 6;} // maxPeople function which returns// appropriate value using Binary Search// in O(logn)static long maxPeople(long n){         // Set the lower and higher values    long low = 0;    long high = 1000000L;    long ans = 0L;         while (low <= high)    {                 // Calculate the mid using        // low and high        long mid = low + ((high - low) / 2);        long value = squareSeries(mid);         // Compare value with n        if (value <= n)        {            ans = mid;            low = mid + 1;        }        else        {            high = mid - 1;        }    }         // Return the ans    return ans;} // Driver codepublic static void main(String[] args){    long p = 14;         System.out.println(maxPeople(p));}} // This code is contributed by 29AjayKumar
# Python3 implementation of the approach # helper function which returns the sum# of series (1^2 + 2^2 +...+ n^2)def squareSeries(n):    return (n*(n+1)*(2*n+1))//6 # maxPeople function which returns# appropriate value using Binary Search# in O(logn) def maxPeople(n):     # Set the lower and higher values    low = 0    high = 1000000000000000    while low<=high:         # calculate the mid using        # low and high         mid = low + ((high-low)//2)        value = squareSeries(mid)         #compare value with n        if value<=n:            ans = mid            low = mid+1        else:            high = mid-1     # return the ans    return ans if __name__=='__main__':    p=14    print(maxPeople(p)) # This code is contributed bu chaudhary_19# (* Mayank Chaudhary)
// C# implementation of the approachusing System; class GFG{     // Helper function which returns the sum// of series (1^2 + 2^2 +...+ n^2)static long squareSeries(long n){    return(n * (n + 1) * (2 * n + 1)) / 6;} // maxPeople function which returns// appropriate value using Binary Search// in O(logn)static long maxPeople(long n){         // Set the lower and higher values    long low = 0;    long high = 1000000L;    long ans = 0L;         while (low <= high)    {                 // Calculate the mid using        // low and high        long mid = low + ((high - low) / 2);        long value = squareSeries(mid);         // Compare value with n        if (value <= n)        {            ans = mid;            low = mid + 1;        }        else        {            high = mid - 1;        }    }         // Return the ans    return ans;} // Driver codepublic static void Main(String[] args){    long p = 14;         Console.Write(maxPeople(p));}} // This code is contributed by shivanisinghss2110
<script>// Javascript implementation of the approach // Helper function which returns the sum// of series (1^2 + 2^2 +...+ n^2)function squareSeries(n){    return Math.floor((n * (n + 1) * (2 * n + 1)) / 6);} // maxPeople function which returns// appropriate value using Binary Search// in O(logn)function maxPeople(n){     // Set the lower and higher values    let low = 0;    let high = 1000000;    let ans = 0;          while (low <= high)    {                  // Calculate the mid using        // low and high        let mid = low + Math.floor((high - low) / 2);        let value = squareSeries(mid);          // Compare value with n        if (value <= n)        {            ans = mid;            low = mid + 1;        }        else        {            high = mid - 1;        }    }          // Return the ans    return ans;} // Driver codelet p = 14; document.write(maxPeople(p)); // This code is contributed by avanitrachhadiya2155</script>
3
Time Complexity: O(Log(1000000)) Auxiliary Space: O(1) 
andrew1234
vt_m
ankthon
princiraj1992
29AjayKumar
Rajput-Ji
chaudhary_19
ishita081
amit143katiyar
subham348
ayush71994
shivanisinghss2110
avanitrachhadiya2155
shikhasingrajput
harendrakumar123
adityakumar129
vansikasharma1329
Constructive Algorithms
Natural Numbers
Numbers
Mathematical
Mathematical
Numbers
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.