Related Articles

# Find array sum after incrementing by K adjacent elements of every positive element M times

• Last Updated : 07 Oct, 2021

Given a circular array arr[] of N integers and two integer M and K, the task is to find the sum of array elements arr[] after performing M operations such that in each operation, increment the adjacent array elements of all the positive array element by K, i.e., if arr[i] > 0, then increment the value of arr[i – 1] and arr[i + 1] by K.

Examples:

Input: arr[] = {0, 1, 0, 1, 0, 0}, M = 2, K = 1
Output: 16
Explanation:
In the 1st operation after incrementing the adjacent array elements of arr[] > 0, the given array modifies to arr[] = {1, 1, 2, 1, 1, 0}.
In the 2nd operation after incrementing the adjacent array elements of arr[] > 0, the given array modifies to arr[] = {2, 3, 4, 3, 2, 2}. So the sum of all elements of arr[] is 16.

Input: arr[] = {1, 2, 3}, M = 10, K = 2
Output: 126

Approach: The given problem can be solved based on the following observations:

• Any non-zero element will always increase the sum of the array by 2 * K in a single move.
• The number of moves required to increment an integer from 0 to a non-zero value is always equal to the distance of the closest non-zero element.

Follow the below steps to solve the problem:

• Create an array steps[], which store the distance of the current element from the nearest non-zero element.
• Create a function nearestLeft() to find the index of the nearest non-zero element while traversing the array in the left direction using the approach discussed in this article.
• Similarly, create a function nearestRight() to find the index of the nearest non-zero element while traversing the array in the right direction.
• The number of operations required to increment the value of the ith element from 0 is given by steps[i] and after that, it will contribute 2 * K to the final sum after each operation. Therefore, the total contribution of ith integer in the final sum after M operations are 2 * K * (M – steps[i]).
• Traverse the array arr[] in the range [1, N] and keep track of the sum contributed by each index in a variable, say sum.
• After completing the above steps, print the value of sum as the result.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `// Function to find the nearest non-zero``// element in the left direction``void` `nearestLeft(``int` `arr[], ``int` `N,``                 ``vector<``int``>& steps)``{``    ``// Stores the index of the first element``    ``// greater than 0 from the right side``    ``int` `L = -N;` `    ``// Traverse the array in the range [1, N]``    ``for` `(``int` `i = N - 1; i >= 0; i--) {``        ``// Check arr[i] is greater than 0``        ``if` `(arr[i] > 0) {``            ``// Update the value of L``            ``L = -(N - i);``            ``break``;``        ``}``    ``}` `    ``// Traverse the array from the left side``    ``for` `(``int` `i = 0; i < N; i++) {``        ``// Check arr[i] is greater than 0``        ``if` `(arr[i] > 0) {``            ``// Update the value of L``            ``L = i;``        ``}` `        ``// Update the value of steps[i]``        ``steps[i] = i - L;``    ``}``}` `// Function to find the nearest non-zero``// element in the right direction``void` `nearestRight(``int` `arr[], ``int` `N,``                  ``vector<``int``>& steps)``{``    ``// Stores the index of the first element``    ``// greater than 0 from the left side``    ``int` `R = 2 * N;` `    ``// Traverse the array from the left side``    ``for` `(``int` `i = 0; i < N; i++) {` `        ``// Check arr[i] is greater than 0``        ``if` `(arr[i] > 0) {` `            ``// Update the value of R``            ``R = N + i;``            ``break``;``        ``}``    ``}` `    ``// Traverse the array from the right side``    ``for` `(``int` `i = N - 1; i >= 0; i--) {``        ``// Check arr[i] is greater than 0``        ``if` `(arr[i] > 0) {``            ``// Update the value of R``            ``R = i;``        ``}` `        ``// Update the value of steps[i]``        ``steps[i] = min(steps[i], R - i);``    ``}``}` `// Function to find the sum of the array``// after the given operation M times``int` `findSum(``int` `arr[], ``int` `N, ``int` `M, ``int` `K)``{``    ``// Stores the distance of the nearest``    ``// non zero element.``    ``vector<``int``> steps(N);` `    ``// Stores sum of the initial array arr[]``    ``int` `sum = accumulate(arr, arr + N, 0);` `    ``if` `(sum == 0) {``        ``return` `0;``    ``}` `    ``nearestLeft(arr, N, steps);``    ``nearestRight(arr, N, steps);` `    ``// Traverse the array from the left side``    ``for` `(``int` `i = 0; i < N; i++)` `        ``// Update the value of sum``        ``sum += 2 * K * max(0, M - steps[i]);` `    ``// Print the total sum of the array``    ``return` `sum;``}` `// Driver Code``int` `main()``{``    ``int` `arr[] = { 0, 1, 0, 1, 0, 0 };``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);``    ``int` `M = 2;``    ``int` `K = 1;` `    ``cout << findSum(arr, N, M, K);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.util.*;` `class` `GFG{` `// Function to find the nearest non-zero``// element in the left direction``static` `void` `nearestLeft(``int` `arr[], ``int` `N,``                 ``int``[] steps)``{``  ` `    ``// Stores the index of the first element``    ``// greater than 0 from the right side``    ``int` `L = -N;` `    ``// Traverse the array in the range [1, N]``    ``for` `(``int` `i = N - ``1``; i >= ``0``; i--)``    ``{``      ` `        ``// Check arr[i] is greater than 0``        ``if` `(arr[i] > ``0``)``        ``{``          ` `            ``// Update the value of L``            ``L = -(N - i);``            ``break``;``        ``}``    ``}` `    ``// Traverse the array from the left side``    ``for` `(``int` `i = ``0``; i < N; i++)``    ``{``      ` `        ``// Check arr[i] is greater than 0``        ``if` `(arr[i] > ``0``)``        ``{``          ` `            ``// Update the value of L``            ``L = i;``        ``}` `        ``// Update the value of steps[i]``        ``steps[i] = i - L;``    ``}``}` `// Function to find the nearest non-zero``// element in the right direction``static` `void` `nearestRight(``int` `arr[], ``int` `N,``                 ``int``[] steps)``{``  ` `    ``// Stores the index of the first element``    ``// greater than 0 from the left side``    ``int` `R = ``2` `* N;` `    ``// Traverse the array from the left side``    ``for` `(``int` `i = ``0``; i < N; i++) {` `        ``// Check arr[i] is greater than 0``        ``if` `(arr[i] > ``0``) {` `            ``// Update the value of R``            ``R = N + i;``            ``break``;``        ``}``    ``}` `    ``// Traverse the array from the right side``    ``for` `(``int` `i = N - ``1``; i >= ``0``; i--)``    ``{``      ` `        ``// Check arr[i] is greater than 0``        ``if` `(arr[i] > ``0``)``        ``{``          ` `            ``// Update the value of R``            ``R = i;``        ``}` `        ``// Update the value of steps[i]``        ``steps[i] = Math.min(steps[i], R - i);``    ``}``}``static` `int` `accumulate(``int``[] arr, ``int` `start, ``int` `end){``    ``int` `sum = ``0``;``    ``for``(``int` `i= ``0``; i < arr.length; i++)``        ``sum += arr[i];``    ``return` `sum;``}``  ` `// Function to find the sum of the array``// after the given operation M times``static` `int` `findSum(``int` `arr[], ``int` `N, ``int` `M, ``int` `K)``{``  ` `    ``// Stores the distance of the nearest``    ``// non zero element.``    ``int` `[]steps = ``new` `int``[N];` `    ``// Stores sum of the initial array arr[]``    ``int` `sum = accumulate(arr, ``0``, N);` `    ``if` `(sum == ``0``) {``        ``return` `0``;``    ``}` `    ``nearestLeft(arr, N, steps);``    ``nearestRight(arr, N, steps);` `    ``// Traverse the array from the left side``    ``for` `(``int` `i = ``0``; i < N; i++)` `        ``// Update the value of sum``        ``sum += ``2` `* K * Math.max(``0``, M - steps[i]);` `    ``// Print the total sum of the array``    ``return` `sum;``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``int` `arr[] = { ``0``, ``1``, ``0``, ``1``, ``0``, ``0` `};``    ``int` `N = arr.length;``    ``int` `M = ``2``;``    ``int` `K = ``1``;` `    ``System.out.print(findSum(arr, N, M, K));``}``}` `// This code is contributed by shikhasingrajput`

## Python3

 `# Python3 program for the above approach` `# Function to find the nearest non-zero``# element in the left direction``def` `nearestLeft(arr, N, steps):``    ` `    ``# Stores the index of the first element``    ``# greater than 0 from the right side``    ``L ``=` `-``N` `    ``# Traverse the array in the range [1, N]``    ``for` `i ``in` `range``(N ``-` `1``, ``-``1``, ``-``1``):``        ` `        ``# Check arr[i] is greater than 0``        ``if` `(arr[i] > ``0``):``            ` `            ``# Update the value of L``            ``L ``=` `-``(N ``-` `i)``            ``break` `    ``# Traverse the array from the left side``    ``for` `i ``in` `range``(N):``        ` `        ``# Check arr[i] is greater than 0``        ``if` `(arr[i] > ``0``):``            ` `            ``# Update the value of L``            ``L ``=` `i` `        ``# Update the value of steps[i]``        ``steps[i] ``=` `i ``-` `L` `# Function to find the nearest non-zero``# element in the right direction``def` `nearestRight(arr, N, steps):` `    ``# Stores the index of the first element``    ``# greater than 0 from the left side``    ``R ``=` `2` `*` `N` `    ``# Traverse the array from the left side``    ``for` `i ``in` `range``(N):` `        ``# Check arr[i] is greater than 0``        ``if` `(arr[i] > ``0``):` `            ``# Update the value of R``            ``R ``=` `N ``+` `i``            ``break` `    ``# Traverse the array from the right side``    ``for` `i ``in` `range``(N ``-` `1``, ``-``1``, ``-``1``):``        ` `        ``# Check arr[i] is greater than 0``        ``if` `(arr[i] > ``0``):``            ` `            ``# Update the value of R``            ``R ``=` `i` `        ``# Update the value of steps[i]``        ``steps[i] ``=` `min``(steps[i], R ``-` `i)` `# Function to find the sum of the array``# after the given operation M times``def` `findSum(arr, N, M, K):` `    ``# Stores the distance of the nearest``    ``# non zero element.``    ``steps ``=` `[``0``] ``*` `N` `    ``# Stores sum of the initial array arr[]``    ``s ``=` `sum``(arr)` `    ``if` `(s ``=``=` `0``):``        ``return` `0` `    ``nearestLeft(arr, N, steps)``    ``nearestRight(arr, N, steps)` `    ``# Traverse the array from the left side``    ``for` `i ``in` `range``(N):` `        ``# Update the value of sum``        ``s ``+``=` `2` `*` `K ``*` `max``(``0``, M ``-` `steps[i])` `    ``# Print the total sum of the array``    ``return` `s` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:` `    ``arr ``=` `[ ``0``, ``1``, ``0``, ``1``, ``0``, ``0` `]``    ``N ``=` `len``(arr)``    ``M ``=` `2``    ``K ``=` `1` `    ``print``(findSum(arr, N, M, K))` `# This code is contributed by ukasp`

## C#

 `// C# program for the above approach``using` `System;``public` `class` `GFG{` `// Function to find the nearest non-zero``// element in the left direction``static` `void` `nearestLeft(``int` `[]arr, ``int` `N,``                 ``int``[] steps)``{``  ` `    ``// Stores the index of the first element``    ``// greater than 0 from the right side``    ``int` `L = -N;` `    ``// Traverse the array in the range [1, N]``    ``for` `(``int` `i = N - 1; i >= 0; i--)``    ``{``      ` `        ``// Check arr[i] is greater than 0``        ``if` `(arr[i] > 0)``        ``{``          ` `            ``// Update the value of L``            ``L = -(N - i);``            ``break``;``        ``}``    ``}` `    ``// Traverse the array from the left side``    ``for` `(``int` `i = 0; i < N; i++)``    ``{``      ` `        ``// Check arr[i] is greater than 0``        ``if` `(arr[i] > 0)``        ``{``          ` `            ``// Update the value of L``            ``L = i;``        ``}` `        ``// Update the value of steps[i]``        ``steps[i] = i - L;``    ``}``}` `// Function to find the nearest non-zero``// element in the right direction``static` `void` `nearestRight(``int` `[]arr, ``int` `N,``                 ``int``[] steps)``{``  ` `    ``// Stores the index of the first element``    ``// greater than 0 from the left side``    ``int` `R = 2 * N;` `    ``// Traverse the array from the left side``    ``for` `(``int` `i = 0; i < N; i++) {` `        ``// Check arr[i] is greater than 0``        ``if` `(arr[i] > 0) {` `            ``// Update the value of R``            ``R = N + i;``            ``break``;``        ``}``    ``}` `    ``// Traverse the array from the right side``    ``for` `(``int` `i = N - 1; i >= 0; i--)``    ``{``      ` `        ``// Check arr[i] is greater than 0``        ``if` `(arr[i] > 0)``        ``{``          ` `            ``// Update the value of R``            ``R = i;``        ``}` `        ``// Update the value of steps[i]``        ``steps[i] = Math.Min(steps[i], R - i);``    ``}``}``static` `int` `accumulate(``int``[] arr, ``int` `start, ``int` `end){``    ``int` `sum = 0;``    ``for``(``int` `i= 0; i < arr.Length; i++)``        ``sum += arr[i];``    ``return` `sum;``}``  ` `// Function to find the sum of the array``// after the given operation M times``static` `int` `findSum(``int` `[]arr, ``int` `N, ``int` `M, ``int` `K)``{``  ` `    ``// Stores the distance of the nearest``    ``// non zero element.``    ``int` `[]steps = ``new` `int``[N];` `    ``// Stores sum of the initial array []arr``    ``int` `sum = accumulate(arr, 0, N);` `    ``if` `(sum == 0) {``        ``return` `0;``    ``}` `    ``nearestLeft(arr, N, steps);``    ``nearestRight(arr, N, steps);` `    ``// Traverse the array from the left side``    ``for` `(``int` `i = 0; i < N; i++)` `        ``// Update the value of sum``        ``sum += 2 * K * Math.Max(0, M - steps[i]);` `    ``// Print the total sum of the array``    ``return` `sum;``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``    ``int` `[]arr = { 0, 1, 0, 1, 0, 0 };``    ``int` `N = arr.Length;``    ``int` `M = 2;``    ``int` `K = 1;` `    ``Console.Write(findSum(arr, N, M, K));``}``}` `// This code is contributed by shikhasingrajput`

## Javascript

 ``
Output:
`16`

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

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up