Open In App

# Prefix Sum Array – Implementation and Applications in Competitive Programming

Given an array arr[] of size N, find the prefix sum of the array. A prefix sum array is another array prefixSum[] of the same size, such that the value of prefixSum[i] is arr + arr + arr . . . arr[i].

Examples:

Input: arr[] = {10, 20, 10, 5, 15}
Output: prefixSum[] = {10, 30, 40, 45, 60}
Explanation: While traversing the array, update the element by adding it with its previous element.
prefixSum = 10,
prefixSum = prefixSum + arr = 30,
prefixSum = prefixSum + arr = 40 and so on.

Recommended Practice

Approach: To solve the problem follow the given steps:

• Declare a new array prefixSum[] of the same size as the input array
• Run a for loop to traverse the input array
• For each index add the value of the current element and the previous value of the prefix sum array

Below is the implementation of the above approach:

## C++

 `// C++ program for Implementing prefix sum array``#include ``using` `namespace` `std;`` ` `// Fills prefix sum array``void` `fillPrefixSum(``int` `arr[], ``int` `n, ``int` `prefixSum[])``{``    ``prefixSum = arr;``    ``// Adding present element with previous element``    ``for` `(``int` `i = 1; i < n; i++)``        ``prefixSum[i] = prefixSum[i - 1] + arr[i];``}`` ` `// Driver Code``int` `main()``{``    ``int` `arr[] = { 10, 4, 16, 20 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);``    ``int` `prefixSum[n];``   ` `      ``// Function call``    ``fillPrefixSum(arr, n, prefixSum);``    ``for` `(``int` `i = 0; i < n; i++)``        ``cout << prefixSum[i] << ``" "``;``}`` ` `// This code is contributed by Aditya Kumar (adityakumar129)`

## C

 `// C program for Implementing prefix sum array``#include `` ` `// Fills prefix sum array``void` `fillPrefixSum(``int` `arr[], ``int` `n, ``int` `prefixSum[])``{``    ``prefixSum = arr;`` ` `    ``// Adding present element with previous element``    ``for` `(``int` `i = 1; i < n; i++)``        ``prefixSum[i] = prefixSum[i - 1] + arr[i];``}`` ` `// Driver Code``int` `main()``{``    ``int` `arr[] = { 10, 4, 16, 20 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);``    ``int` `prefixSum[n];``   ` `      ``// Function call``    ``fillPrefixSum(arr, n, prefixSum);``    ``for` `(``int` `i = 0; i < n; i++)``          ``printf``(``"%d "``, prefixSum[i]);``}`` ` `// This code is contributed by Aditya Kumar (adityakumar129)`

## Java

 `// Java Program for Implementing prefix sum arrayclass`` ` `import` `java.io.*;`` ` `class` `Prefix {``    ``// Fills prefix sum array``    ``static` `void` `fillPrefixSum(``int` `arr[], ``int` `n,``                              ``int` `prefixSum[])``    ``{``        ``prefixSum[``0``] = arr[``0``];``        ``// Adding present element with previous element``        ``for` `(``int` `i = ``1``; i < n; ++i)``            ``prefixSum[i] = prefixSum[i - ``1``] + arr[i];``    ``}`` ` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `arr[] = { ``10``, ``4``, ``16``, ``20` `};``        ``int` `n = arr.length;``        ``int` `prefixSum[] = ``new` `int``[n];``       ` `          ``// Function call``        ``fillPrefixSum(arr, n, prefixSum);``        ``for` `(``int` `i = ``0``; i < n; i++)``            ``System.out.print(prefixSum[i] + ``" "``);``        ``System.out.println(``""``);``    ``}``}`` ` `// This code is contributed by Aditya Kumar (adityakumar129)`

## Python3

 `# Python3 Program for Implementing``# prefix sum array`` ` `# Fills prefix sum array`` ` ` ` `def` `fillPrefixSum(arr, n, prefixSum):`` ` `    ``prefixSum[``0``] ``=` `arr[``0``]`` ` `    ``# Adding present element``    ``# with previous element``    ``for` `i ``in` `range``(``1``, n):``        ``prefixSum[i] ``=` `prefixSum[i ``-` `1``] ``+` `arr[i]`` ` ` ` `# Driver code``if` `__name__ ``=``=` `'__main__'``:``  ``arr ``=` `[``10``, ``4``, ``16``, ``20``]``  ``n ``=` `len``(arr)`` ` `  ``# Function call``  ``prefixSum ``=` `[``0` `for` `i ``in` `range``(n ``+` `1``)]`` ` `  ``fillPrefixSum(arr, n, prefixSum)`` ` `  ``for` `i ``in` `range``(n):``      ``print``(prefixSum[i], ``" "``, end``=``"")`` ` `# This code is contributed``# by Anant Agarwal.`

## C#

 `// C# Program for Implementing``// prefix sum arrayclass``using` `System;`` ` `class` `GFG {``    ``// Fills prefix sum array``    ``static` `void` `fillPrefixSum(``int``[] arr, ``int` `n,``                              ``int``[] prefixSum)``    ``{``        ``prefixSum = arr;`` ` `        ``// Adding present element``        ``// with previous element``        ``for` `(``int` `i = 1; i < n; ++i)``            ``prefixSum[i] = prefixSum[i - 1] + arr[i];``    ``}`` ` `    ``// Driver code``    ``public` `static` `void` `Main()``    ``{``        ``int``[] arr = { 10, 4, 16, 20 };``        ``int` `n = arr.Length;``        ``int``[] prefixSum = ``new` `int``[n];`` ` `          ``// Function call``        ``fillPrefixSum(arr, n, prefixSum);`` ` `        ``for` `(``int` `i = 0; i < n; i++)``            ``Console.Write(prefixSum[i] + ``" "``);``        ``Console.Write(``""``);``    ``}``}`` ` `// This Code is Contributed by nitin mittal`

## PHP

 ``

## Javascript

 ``

Output

`10 14 30 50 `

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

## Sum of an array between indexes L and R using Prefix Sum:

Given an array arr[] of size N. Given Q queries and in each query given L and R, Print the sum of array elements from index L to R.

Follow the given steps to solve the problem:

• Create the prefix sum array of the given input array
• Now for every query (1-based indexing)
• If L is greater than 1, then print prefixSum[R] – prefixSum[L-1]
• else print prefixSum[R]

Below is the implementation of the above approach.

## C++14

 `// C++ program for the above approach`` ` `#include ``using` `namespace` `std;``const` `int` `N = 1e5 + 10;``int` `a[N];``int` `pf[N];`` ` ` ` `// Driver code``int` `main()``{``    ``int` `n = 6;``    ``int` `a[] = { 3, 6, 2, 8, 9, 2 };``    ``//Calculating prefix sum``    ``pf = a;``    ``for` `(``int` `i = 1; i < n; i++) {``        ``pf[i] = pf[i - 1] + a[i];``    ``}``   ` `    ``int` `q = 4;``      ``//Creating a 2D vector to store queries and display output``    ``vector > query``        ``= { { 2, 3 }, { 4, 6 }, { 1, 5 }, { 3, 6 } };``       ` `      ``//Printing sum from Queries``    ``for` `(``int` `i = 0; i < q; i++) {``        ``int` `l = query[i], r = query[i];``        ``if` `(r > n || l < 1) {``            ``cout << ``"Please input in range 1 to "` `<< n``                 ``<< endl;``            ``continue``;``        ``}``        ``if` `(l == 1)``            ``cout << pf[r - 1] << endl;``        ``else``            ``cout << pf[r - 1] - pf[l - 2] << endl;``    ``}``    ``return` `0;``}`

## Java

 `// Java program for the above approach`` ` `import` `java.util.*;`` ` `class` `GFG {`` ` `      ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `n = ``6``;``        ``int``[] a = { ``3``, ``6``, ``2``, ``8``, ``9``, ``2` `};``        ``int``[] pf = ``new` `int``[n + ``2``];``        ``pf[``0``] = ``0``;``        ``for` `(``int` `i = ``0``; i < n; i++) {``            ``pf[i + ``1``] = pf[i] + a[i];``        ``}`` ` `        ``int``[][] q``            ``= { { ``2``, ``3` `}, { ``4``, ``6` `}, { ``1``, ``5` `}, { ``3``, ``6` `} };``        ``for` `(``int` `i = ``0``; i < q.length; i++) {``            ``int` `l = q[i][``0``];``            ``int` `r = q[i][``1``];`` ` `            ``// Calculating sum from r to l.``            ``System.out.print(pf[r] - pf[l - ``1``] + ``"\n"``);``        ``}``    ``}``}`` ` `// This code is contributed by umadevi9616`

## Python3

 `# Python3 program for the above approach`` ` `# Driver code``if` `__name__ ``=``=` `'__main__'``:``    ``n ``=` `6``    ``a ``=` `[``3``, ``6``, ``2``, ``8``, ``9``, ``2``]``    ``pf ``=` `[``0` `for` `i ``in` `range``(n``+``2``)]``    ``for` `i ``in` `range``(n):``        ``pf[i ``+` `1``] ``=` `pf[i] ``+` `a[i]`` ` `    ``q ``=` `[[``2``, ``3``], [``4``, ``6``], [``1``, ``5``], [``3``, ``6``]]``    ``for` `i ``in` `range``(``4``):``        ``l ``=` `q[i][``0``]``        ``r ``=` `q[i][``1``]`` ` `        ``# Calculating sum from r to l.``        ``print``(pf[r] ``-` `pf[l ``-` `1``])`` ` `# This code is contributed by gauravrajput1`

## C#

 `// C# program for the above approach`` ` `using` `System;`` ` `public` `class` `GFG {`` ` `      ``// Driver code``    ``public` `static` `void` `Main(String[] args)``    ``{``        ``int` `n = 6;``        ``int``[] a = { 3, 6, 2, 8, 9, 2 };``        ``int``[] pf = ``new` `int``[n + 2];``        ``pf = 0;``        ``for` `(``int` `i = 0; i < n; i++) {``            ``pf[i + 1] = pf[i] + a[i];``        ``}`` ` `        ``int``[, ] q``            ``= { { 2, 3 }, { 4, 6 }, { 1, 5 }, { 3, 6 } };``        ``for` `(``int` `i = 0; i < q.GetLength(0); i++) {``            ``int` `l = q[i, 0];``            ``int` `r = q[i, 1];`` ` `            ``// Calculating sum from r to l.``            ``Console.Write(pf[r] - pf[l - 1] + ``"\n"``);``        ``}``    ``}``}`` ` `// This code is contributed by gauravrajput1`

## Javascript

 ``

Output

```8
19
28
21```

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

## Example Problem:

Consider an array of size N with all initial values as 0. Perform the given ‘m’ add operations from index ‘a’ to ‘b’ and evaluate the highest element in the array. An add operation adds 100 to all the elements from a to b (both inclusive).

Example:

Input: n = 5, m = 3
a = 2, b = 4.
a = 1, b = 3.
a = 1, b = 2.
Output: 300
Explanation:
After I operation – A[] = {0, 100, 100, 100, 0}
After II operation – A[] = {100, 200, 200, 100, 0}
After III operation – A[] = {200, 300, 200, 100, 0}
Highest element: 300

Naive Approach: To solve the problem follow the below idea:

A simple approach is running a loop ‘m’ times. Inputting a and b and running a loop from a to b, adding all elements by 100.

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

Efficient Approach: To solve the problem follow the below idea:

The efficient approach is to use Prefix Sum Array

Follow the given steps to solve the problem:

• Run a loop for ‘m‘ times, inputting ‘a‘ and ‘b‘.
• Add 100 at index ‘a-1‘ and subtract 100 from index ‘b‘.
• After completion of ‘m‘ operations, compute the prefix sum array.
• Scan the largest element and we’re done.

Explanation: We added 100 at ‘a’ because this will add 100 to all elements while taking the prefix sum array. Subtracting 100 from ‘b+1’ will reverse the changes made by adding 100 to elements from ‘b’ onward.

Below is the illustration of the above approach:

After I operation –
A[] = {0, 100, 0, 0, -100}

After II operation –
A[] = {100, 100, 0, -100, -100}

After III operation –
A[] = {200, 100, -100, -100, -100}

Final Prefix Sum Array : 200 300 200 100 0
The required highest element : 300

Below is the implementation of the above approach:

## C++14

 `// C++ program for the above approach`` ` `#include ``using` `namespace` `std;`` ` `int` `find(``int` `m, vector > q)``{``    ``int` `mx = 0;``    ``vector<``int``> pre(5, 0);`` ` `    ``for` `(``int` `i = 0; i < m; i++) {``        ``// take input a and b``        ``int` `a = q[i].first, b = q[i].second;`` ` `        ``// add 100 at first index and``        ``// subtract 100 from last index`` ` `        ``// pre becomes 100``        ``pre[a - 1] += 100;`` ` `        ``// pre becomes -100 and this``        ``pre[b] -= 100;``        ``// continues m times as we input diff. values of a``        ``// and b``    ``}``    ``for` `(``int` `i = 1; i < 5; i++) {``        ``// add all values in a cumulative way``        ``pre[i] += pre[i - 1];`` ` `        ``// keep track of max value``        ``mx = max(mx, pre[i]);``    ``}`` ` `    ``return` `mx;``}`` ` `// Driver Code``int` `main()``{`` ` `    ``int` `m = 3;``    ``vector > q``        ``= { { 2, 4 }, { 1, 3 }, { 1, 2 } };`` ` `    ``// Function call``    ``cout << find(m, q);``    ``return` `0;``}`

## Java

 `// Java program for the above approach`` ` `import` `java.util.*;`` ` `class` `GFG {``    ``static` `class` `pair {``        ``int` `first, second;``        ``public` `pair(``int` `first, ``int` `second)``        ``{``            ``this``.first = first;``            ``this``.second = second;``        ``}``    ``}``    ``static` `int` `find(``int` `m, pair[] q)``    ``{``        ``int` `mx = ``0``;``        ``int``[] pre = ``new` `int``[``5``];`` ` `        ``for` `(``int` `i = ``0``; i < m; i++) {`` ` `            ``// take input a and b``            ``int` `a = q[i].first, b = q[i].second;`` ` `            ``// add 100 at first index and``            ``// subtract 100 from last index`` ` `            ``// pre becomes 100``            ``pre[a - ``1``] += ``100``;`` ` `            ``// pre becomes -100 and this``            ``pre[b] -= ``100``;`` ` `            ``// continues m times as we input diff. values of``            ``// a and b``        ``}``        ``for` `(``int` `i = ``1``; i < ``5``; i++) {`` ` `            ``// add all values in a cumulative way``            ``pre[i] += pre[i - ``1``];`` ` `            ``// keep track of max value``            ``mx = Math.max(mx, pre[i]);``        ``}`` ` `        ``return` `mx;``    ``}`` ` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{`` ` `        ``int` `m = ``3``;``        ``pair[] q = { ``new` `pair(``2``, ``4``), ``new` `pair(``1``, ``3``),``                     ``new` `pair(``1``, ``2``) };`` ` `        ``// Function call``        ``System.out.print(find(m, q));``    ``}``}`` ` `// This code is contributed by gauravrajput1`

## Python3

 `# Python implementation of the approach``def` `find(m, q):``    ``mx ``=` `0``    ``pre ``=` `[``0` `for` `i ``in` `range``(``5``)]`` ` `    ``for` `i ``in` `range``(m):``        ``# take input a and b``        ``a, b ``=` `q[i][``0``], q[i][``1``]`` ` `        ``# add 100 at first index and``        ``# subtract 100 from last index`` ` `        ``# pre becomes 100``        ``pre[a``-``1``] ``+``=` `100`` ` `        ``# pre becomes -100 and this``        ``pre[b] ``-``=` `100`` ` `        ``# continues m times as we input diff. values of a and b``    ``for` `i ``in` `range``(``1``, ``5``):`` ` `        ``# add all values in a cumulative way``        ``pre[i] ``+``=` `pre[i ``-` `1``]`` ` `        ``# keep track of max value``        ``mx ``=` `max``(mx, pre[i])``    ``return` `mx`` ` ` ` `# Driver Code``m ``=` `3``q ``=` `[[``2``, ``4``], [``1``, ``3``], [``1``, ``2``]]`` ` `# Function call``print``(find(m, q))`` ` `# This code is contributed by rohitsingh07052`

## C#

 `// C# program for the above approach`` ` `using` `System;`` ` `public` `class` `GFG {``    ``public` `class` `pair {``        ``public` `int` `first, second;``        ``public` `pair(``int` `first, ``int` `second)``        ``{``            ``this``.first = first;``            ``this``.second = second;``        ``}``    ``}``    ``static` `int` `find(``int` `m, pair[] q)``    ``{``        ``int` `mx = 0;``        ``int``[] pre = ``new` `int``;`` ` `        ``for` `(``int` `i = 0; i < m; i++) {`` ` `            ``// take input a and b``            ``int` `a = q[i].first, b = q[i].second;`` ` `            ``// add 100 at first index and``            ``// subtract 100 from last index`` ` `            ``// pre becomes 100``            ``pre[a - 1] += 100;`` ` `            ``// pre becomes -100 and this``            ``pre[b] -= 100;`` ` `            ``// continues m times as we input diff. values of``            ``// a and b``        ``}``        ``for` `(``int` `i = 1; i < 5; i++) {`` ` `            ``// add all values in a cumulative way``            ``pre[i] += pre[i - 1];`` ` `            ``// keep track of max value``            ``mx = Math.Max(mx, pre[i]);``        ``}`` ` `        ``return` `mx;``    ``}`` ` `    ``// Driver Code``    ``public` `static` `void` `Main(String[] args)``    ``{``        ``int` `m = 3;``        ``pair[] q = { ``new` `pair(2, 4), ``new` `pair(1, 3),``                     ``new` `pair(1, 2) };`` ` `        ``// Function call``        ``Console.Write(find(m, q));``    ``}``}`` ` `// This code is contributed by gauravrajput1.`

## Javascript

 ``

Output

`300`

Time Complexity: O(N + M), where N is the size of the array and M is the number of operations
Auxiliary Space: O(N)

## Applications of Prefix Sum:

Related Articles:

This article is contributed by Rohit Thapliyal. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.