Skip to content
Related Articles

Related Articles

Improve Article

Maximize the rightmost element of an array in k operations in Linear Time

  • Difficulty Level : Medium
  • Last Updated : 20 Sep, 2021

Given an array arr[ ] of size N and an integer p, the task is to find maximum possible value of rightmost element of array arr[ ] performing at most k operations.In one operation decrease arr[i] by p and increase arr[i+1] by p.

Examples:

Input: N = 4, p = 2, k = 5, arr = {3, 8, 1, 4}
Output: 8
Explanation: 
                    following operation can be performed to achieve max valued rightmost element:
                    1. decrease arr[2] by 2 and increase arr[3] by 2, arr = {3, 6, 3, 4}
                    2. decrease arr[2] by 2 and increase arr[3] by 2, arr = {3, 4, 5, 4}
                    3. decrease arr[2] by 2 and increase arr[3] by 2, arr = {3, 2, 5, 4}
                    4. decrease arr[3] by 2 and increase arr[4] by 2, arr = {3, 2, 3, 6}
                    5. decrease arr[3] by 2 and increase arr[4] by 2, arr = {3, 2, 1, 8}

                    Hence, maximum possible value of rightmost element will be 8.



Input: N = 5, p = 1, k = 2, arr = {1, 2, 3, 4, 5}
Output: 7

Naive Approach: This problem can solved naively using greedy approach. follow the steps below to solve the problem:

  • Run a while loop, un-till is k is greater than 0.
  • Run a for loop inside while loop, for i in range [N-2, 0].
  • Check if arr[i] is greater than 1, increase arr[i+1] by p and decrease arr[i] by p and break for loop.
  • Decrease the value of k by 1.
  • Print arr[N-1].

Below is the implementation of the above approach:

C++




// C++ program for above approach
#include <iostream>
using namespace std;
 
// Function to calculate maximum value of
// Rightmost element
void maxRightmostElement(int N, int k, int p, int arr[]){
   
     // Calculating maximum value of
     // Rightmost element
     while(k)
         {
        
          for(int i=N-2;i>=0;i--)
              {
             
                // Checking if arr[i] is operationable
                if(arr[i]>= p)
                  {
                      // Performing operation of i-th element
                      arr[i]=arr[i]-p;
                   
                      arr[i+1]=arr[i+1]+p;
                   
                      break;
                   
                  
             
              }
        
         // Decreasing the value of k by 1
         k--;
        }
   
        // Printing rightmost element
        cout<<arr[N-1]<<endl;
}
 
// Driver Code
int main() {
     
    // Given Input
    int N = 4, p = 2, k = 5, arr[] = {3, 8, 1, 4};
   
    // Function Call
    maxRightmostElement(N, k, p, arr);
    return 0;
}

Java




// Java program for the above approach
import java.io.*;
class GFG {
 
    // Function to calculate maximum value of
    // Rightmost element
    static int maxRightmostElement(int N, int k, int p,
                                   int arr[])
    {
       
        // Calculating maximum value of
        // Rightmost element
        while (k > 0) {
 
            for (int i = N - 2; i >= 0; i--) {
 
                // Checking if arr[i] is operationable
                if (arr[i] >= p)
                {
                   
                    // Performing operation of i-th element
                    arr[i] = arr[i] - p;
 
                    arr[i + 1] = arr[i + 1] + p;
 
                    break;
                }
            }
 
            // Decreasing the value of k by 1
            k--;
        }
 
        // returning the rightmost element
        return arr[N - 1];
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        // Given Input
        int N = 4, k = 5, p = 2;
        int arr[] = { 3, 8, 1, 4 };
       
        // Function Call
        System.out.println(
            maxRightmostElement(N, k, p, arr));
    }
}
 
// This code is contributed by dwivediyash

Python3




# Python program for the above approach
 
# Function to calculate maximum value of
# Rightmost element
def maxRightmostElement(N, k, p, arr):
   
    # Calculating maximum value of
    # Rightmost element
    while(k) :
        
        for i in range(N - 2, -1, -1) :
             
            # Checking if arr[i] is operationable
            if(arr[i] >= p) :
                 
                # Performing operation of i-th element
                arr[i] = arr[i] - p
                   
                arr[i + 1] = arr[i + 1] + p
                   
                break
                   
        # Decreasing the value of k by 1
        k = k - 1
         
    # Printing rightmost element
    print(arr[N-1])
 
 
# Driver Code
 
# Given Input
N = 4
p = 2
k = 5
arr = [3, 8, 1, 4]
   
# Function Call
maxRightmostElement(N, k, p, arr)
 
# This code is contributed by sanjoy_62.

C#




using System;
 
public class GFG {
 
    // Function to calculate maximum value of
    // Rightmost element
    static int maxRightmostElement(int N, int k, int p,
                                   int []arr)
    {
 
        // Calculating maximum value of
        // Rightmost element
        while (k > 0) {
 
            for (int i = N - 2; i >= 0; i--) {
 
                // Checking if arr[i] is operationable
                if (arr[i] >= p) {
 
                    // Performing operation of i-th element
                    arr[i] = arr[i] - p;
 
                    arr[i + 1] = arr[i + 1] + p;
 
                    break;
                }
            }
 
            // Decreasing the value of k by 1
            k--;
        }
 
        // returning the rightmost element
        return arr[N - 1];
    }
 
    // Driver Code
    static public void Main()
    {
       
        // Given Input
        int N = 4, k = 5, p = 2;
        int[] arr = { 3, 8, 1, 4 };
 
        // Function Call
        Console.WriteLine(
            maxRightmostElement(N, k, p, arr));
    }
}
 
// This code is contributed by maddler.

Javascript




  <script>
        // JavaScript Program to implement
        // the above approach
 
 
        // Function to calculate maximum value of
        // Rightmost element
        function maxRightmostElement(N, k, p, arr) {
 
            // Calculating maximum value of
            // Rightmost element
            while (k) {
 
                for (let i = N - 2; i >= 0; i--) {
 
                    // Checking if arr[i] is operationable
                    if (arr[i] >= p) {
                        // Performing operation of i-th element
                        arr[i] = arr[i] - p;
 
                        arr[i + 1] = arr[i + 1] + p;
 
                        break;
 
                    }
 
                }
 
                // Decreasing the value of k by 1
                k--;
            }
 
            // Printing rightmost element
            document.write(arr[N - 1] + "<br>");
        }
 
        // Driver Code
 
 
        // Given Input
        let N = 4, p = 2, k = 5, arr = [3, 8, 1, 4];
 
        // Function Call
        maxRightmostElement(N, k, p, arr);
 
// This code is contributed by Potta Lokesh
    </script>
Output
8

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

Efficient Approach: The above approach can be optimized by observing the fact that, i-th element of array arr[ ] can contribute 2 to the element arr[N-1] in N-1-i operations. follow the steps below to solve the problem:

  • Iterate a loop, for i in range [N-2, 0].
  • Initialize ans as arr[N-1] to store maximum value of rightmost element.
  • Find minimum contribution of i-th element say d as, d = min(a[i]/2, k/(N-1-i)).
  • Decrease k by d*(N-1-i) and increase ans by d*2.
  • Print ans, it will be final step.

C++




// C++ program for above approach
#include <iostream>
using namespace std;
 
// Function to calculate maximum value of
// Rightmost element
void maxRightmostElement(int N, int k, int arr[]){
    
     // Initializing ans to store
     // Maximum valued rightmost element
     int ans = arr[N-1];
     
     // Calculating maximum value of
     // Rightmost element
     for(int i=N-2; i>=0; i--)
       {
        int d = min(arr[i]/2, k/(N-1-i));
        
        k-=d*(N-1-i);
        
        ans+=d*2;
        }
 
        // Printing rightmost element
        cout<<ans<<endl;
}
 
// Driver Code
int main() {
     
    // Given Input
    int N = 4, k = 5, arr[] = {3, 8, 1, 4};
   
    // Function Call
    maxRightmostElement(N, k, arr);
    return 0;
}

Java




// Java program for the above approach
import java.io.*;
class GFG {
 
  // Function to calculate maximum value of
  // Rightmost element
  static int maxRightmostElement(int N, int k, int p, int arr[])
  {
     
    // Initializing ans to store
    // Maximum valued rightmost element
    int ans = arr[N - 1];
 
    // Calculating maximum value of
    // Rightmost element
    for (int i = N - 2; i >= 0; i--) {
      int d = Math.min(arr[i] / p, k / (N - 1 - i));
 
      k -= d * (N - 1 - i);
 
      ans += d * p;
    }
 
    // returning rightmost element
    return  ans;
  }
 
  // Driver Code
  public static void main(String[] args)
  {
    // Given Input
    int N = 4, k = 5, p = 2;
    int arr[] = { 3, 8, 1, 4 };
    // Function Call
    System.out.println(maxRightmostElement(N, k, p, arr));
  }
}
 
// This code is contributed by dwivediyash

Python3




# Python 3 program for above approach
 
# Function to calculate maximum value of
# Rightmost element
def maxRightmostElement(N, k, arr):
   
    # Initializing ans to store
    # Maximum valued rightmost element
    ans = arr[N-1]
     
     # Calculating maximum value of
     # Rightmost element
    i = N - 2
    while(i >= 0):
        d = min(arr[i]//2, k//(N-1-i))
        
        k -= d * (N - 1 - i)
        
        ans+=d*2
 
        # Printing rightmost element
        i -= 1
    print(ans,end = " ")
      
 
# Driver Code
if __name__ == '__main__':
   
    # Given Input
    N = 4
    k = 5
    arr = [3, 8, 1, 4]
   
    # Function Call
    maxRightmostElement(N, k, arr)
     
    # This code is contributed by SURENDRA_GANGWAR.

C#




// C# program for the above approach
using System;
 
public class GFG {
 
  // Function to calculate maximum value of
  // Rightmost element
  static int maxRightmostElement(int N, int k, int p, int []arr)
  {
     
    // Initializing ans to store
    // Maximum valued rightmost element
    int ans = arr[N - 1];
 
    // Calculating maximum value of
    // Rightmost element
    for (int i = N - 2; i >= 0; i--) {
      int d = Math.Min(arr[i] / p, k / (N - 1 - i));
 
      k -= d * (N - 1 - i);
 
      ans += d * p;
    }
 
    // returning rightmost element
    return  ans;
  }
 
  // Driver Code
  public static void Main(string[] args)
  {
     
    // Given Input
    int N = 4, k = 5, p = 2;
    int []arr = { 3, 8, 1, 4 };
     
    // Function Call
    Console.WriteLine(maxRightmostElement(N, k, p, arr));
  }
}
 
// This code is contributed by AnkThon

Javascript




<script>
// JavaScript program for the above approach
 
  // Function to calculate maximum value of
  // Rightmost element
  function maxRightmostElement( N,  k,  p,  arr)
  {
     
    // Initializing ans to store
    // Maximum valued rightmost element
    var ans = arr[N - 1];
 
    // Calculating maximum value of
    // Rightmost element
    for (var i = N - 2; i >= 0; i--) {
      var d = Math.min(arr[i] / p, k / (N - 1 - i));
 
      k -= d * (N - 1 - i);
 
      ans += d * p;
    }
 
    // returning rightmost element
    return  ans;
  }
 
  // Driver Code
    // Given Input
    var N = 4, k = 3.5, p = 2;
    var arr = [ 3, 8, 1, 4 ];
    // Function Call
    document.write(maxRightmostElement(N, k, p, arr));
   
// This code is contributed by shivanisinghss2110
 
</script>
Output
8

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




My Personal Notes arrow_drop_up
Recommended Articles
Page :