Given an array a[] consisting of N positive integers, and an integer K, the task is to find the minimum number of operations required to make the sum of adjacent elements less than or equal to K, where, one operation involves decreasing any array element by 1. For every ith element in the given array, the operations can be performed 0 to a[i] times. Since the answer can be large, compute it modulo 109 + 7.
Examples:
_Input: _a[] = {11, 3, 13, 10, 8, 17, 22}, K = 14
_Output: _34
Explanation:
Minimum number of operations required to obtain the desired arrangement is as follows:
The given array is modified to the following arrangement = {11, 3, 11, 3, 8, 6, 8}
Total number of operations is 2 + 5 + 7 + 11 + 18 = 34.
_Input: _a[] = {1000000000, 1000000000, 1000000000, 1000000000}, K = 0
_Output3: _999999979
Explanation:
Since the sum of adjacent pairs is required to be 0, all elements in the array need to be reduced to 0.
Therefore, the answer is sum of array % (109 + 7).
Sum of array is 4000000000
Therefore, the required answer is 4000000000 % 109 + 7 = 999999979
Recommended: Please try your approach on {IDE} first, before moving on to the solution.
Approach:
Follow the steps below to solve the problem:
Below is the implementation of the above approach:
// C++ program to implement
// the above approach
#include<bits/stdc++.h>
**using**
**namespace**
std;
// Function to calculate the minimum
// number of operations required
**int**
minimum_required_operations(``**int**
arr[],
**int**
n,
**int**
k)
{
// Stores the total number
// of operations
**int**
answer = 0;
**long**
**long**
mod = 1000000007;
// Iterate over the array
**for**``(``**int**
i = 0; i < n - 1; i++)
{
// If the sum of pair of adjacent
// elements exceed k.
**if**
(arr[i] + arr[i + 1] > k)
{
// If current element exceeds k
**if**
(arr[i] > k)
{
// Reduce arr[i] to k
answer += (arr[i] - k);
arr[i] = k;
}
// Update arr[i + 1] accordingly
answer += (arr[i] + arr[i + 1]) - k;
arr[i + 1] = (k - arr[i]);
// Update answer
answer %= mod;
}
}
**return**
answer;
}
// Driver Code
**int**
main()
{
**int**
a[] = { 9, 50, 4, 14, 42, 89 };
**int**
k = 10;
**int**
n =
**sizeof**``(a) /
**sizeof**``(a[0]);
cout << (minimum_required_operations(a, n, k));
**return**
0;
}
// This code is contributed by chitranayal
Output:
178
_Time Complexity: _O(N)
_Auxiliary Space: _O(1)
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.
#arrays #greedy #mathematical #searching