# Prefix Sums

Authors: Darren Yao, Eric Wei, Neo Wang

### Prerequisites

Computing range sum queries in constant time over a fixed array.

Focus Problem – read through this problem before continuing!

## Resources

Resources: Additional | |||
---|---|---|---|

IUSACO | module is based off this | ||

CPH | rather brief | ||

PAPS | also rather brief |

## Introduction

Let's say we have a one-indexed integer array $\texttt{arr}$ of size $N$ and we want to compute the value of

for $Q$ different pairs $(a,b)$ satisfying $1\le a\le b\le N$. We'll use the following example with $N = 6$:

Index $i$ | 1 | 2 | 3 | 4 | 5 | 6 |
---|---|---|---|---|---|---|

$\texttt{arr}[i]$ | 1 | 6 | 4 | 2 | 5 | 3 |

Naively, for every query, we can iterate through all entries from index $a$ to index $b$ to add them up. Since we have $Q$ queries and each query requires a maximum of $\mathcal{O}(N)$ operations to calculate the sum, our total time complexity is $\mathcal{O}(NQ)$. For most problems of this nature, the constraints will be $N, Q \leq 10^5$, so $NQ$ is on the order of $10^{10}$. This is **not** acceptable; it will almost certainly exceed the time limit.

Instead, we can use prefix sums to process these array sum queries. We designate a prefix sum array $\texttt{prefix}$. First, because we're 1-indexing the array, set $\texttt{prefix}[0]=0$, then for indices $k$ such that $1 \leq k \leq n$, define the prefix sum array as follows:

Basically, what this means is that the element at index $k$ of the prefix sum array stores the sum of all the elements in the original array from index $1$ up to $k$. This can be calculated easily in $\mathcal{O}(N)$ by the following formula for each $1\le k\le n$:

For the example case, our prefix sum array looks like this:

Index $i$ | 0 | 1 | 2 | 3 | 4 | 5 | 6 |
---|---|---|---|---|---|---|---|

$\texttt{prefix}[i]$ | 0 | 1 | 7 | 11 | 13 | 18 | 21 |

Now, when we want to query for the sum of the elements of $\texttt{arr}$ between (1-indexed) indices $a$ and $b$ inclusive, we can use the following formula:

Using our definition of the elements in the prefix sum array, we have

Since we are only querying two elements in the prefix sum array, we can calculate subarray sums in $\mathcal{O}(1)$ per query, which is much better than the $\mathcal{O}(N)$ per query that we had before. Now, after an $\mathcal{O}(N)$ preprocessing to calculate the prefix sum array, each of the $Q$ queries takes $\mathcal{O}(1)$ time. Thus, our total time complexity is $\mathcal{O}(N+Q)$, which should now pass the time limit.

Let's do an example query and find the subarray sum between indices $a = 2$ and $b = 5$, inclusive, in the 1-indexed $\texttt{arr}$. From looking at the original array, we see that this is

Index $i$ | 1 | 2 | 3 | 4 | 5 | 6 |
---|---|---|---|---|---|---|

$\texttt{arr}[i]$ | 1 | 6 | 4 | 2 | 5 | 3 |

Using prefix sums:

Index $i$ | 0 | 1 | 2 | 3 | 4 | 5 | 6 |
---|---|---|---|---|---|---|---|

$\texttt{prefix}[i]$ | 0 | 1 | 7 | 11 | 13 | 18 | 21 |

These are also known as partial sums.

### Code

C++

In C++ we can use `std::partial_sum`

, although it doesn't shorten the code by much.

#include <bits/stdc++.h>using namespace std;#define sz(x) (int)size(x)using ll = long long;using vl = vector<ll>;vl psum(const vl& a) {vl psum(sz(a)+1);

Python

def psum(a):psum=[0]for i in a:psum.append(psum[-1]+i) # psum[-1] is the last element in the listreturn psumprint(psum([1,2,3,4,5]))

### Problems

### Warning!

The last problem isn't submittable on USACO. Download the test data and use the script provided here to test your solution.

## 2D Prefix Sums

Focus Problem – read through this problem before continuing!

Now, what if we wanted to process $Q$ queries for the sum over a subrectangle of a 2D matrix with $N$ rows and $M$ columns? Let's assume both rows and columns are 1-indexed, and we use the following matrix as an example:

0 | 0 | 0 | 0 | 0 | 0 |

0 | 1 | 5 | 6 | 11 | 8 |

0 | 1 | 7 | 11 | 9 | 4 |

0 | 4 | 6 | 1 | 3 | 2 |

0 | 7 | 5 | 4 | 2 | 3 |

Naively, each sum query would then take $\mathcal{O}(NM)$ time, for a total of $\mathcal{O}(QNM)$. This is too slow.

Let's take the following example region, which we want to sum:

0 | 0 | 0 | 0 | 0 | 0 |

0 | 1 | 5 | 6 | 11 | 8 |

0 | 1 | 7 | 11 | 9 | 4 |

0 | 4 | 6 | 1 | 3 | 2 |

0 | 7 | 5 | 4 | 2 | 3 |

Manually summing all the cells, we have a submatrix sum of $7+11+9+6+1+3 = 37$.

The first logical optimization would be to do one-dimensional prefix sums of each row. Then, we'd have the following row-prefix sum matrix. The desired subarray sum of each row in our desired region is simply the green cell minus the red cell in that respective row. We do this for each row to get $(28-1) + (14-4) = 37$.

0 | 0 | 0 | 0 | 0 | 0 |

0 | 1 | 6 | 12 | 23 | 31 |

0 | 1 | 8 | 19 | 28 | 32 |

0 | 4 | 10 | 11 | 14 | 16 |

0 | 7 | 12 | 16 | 18 | 21 |

Now, if we wanted to find a submatrix sum, we could break up the submatrix into a subarray for each row, and then add their sums, which would be calculated using the prefix sums method described earlier. Since the matrix has $N$ rows, the time complexity of this is $\mathcal{O}(QN)$. This might be fast enough for $Q=10^5$ and $N=10^3$, but we can do better.

In fact, we can do two-dimensional prefix sums. In our two dimensional prefix sum array, we have

This can be calculated as follows for row index $1 \leq i \leq n$ and column index $1 \leq j \leq m$:

The submatrix sum between rows $a$ and $A$ and columns $b$ and $B$, can thus be expressed as follows:

Summing the blue region from above using the 2D prefix sums method, we add the value of the green square, subtract the values of the red squares, and then add the value of the gray square. In this example, we have

as expected.

0 | 0 | 0 | 0 | 0 | 0 |

0 | 1 | 6 | 12 | 23 | 31 |

0 | 2 | 14 | 31 | 51 | 63 |

0 | 6 | 24 | 42 | 65 | 79 |

0 | 13 | 36 | 58 | 83 | 100 |

Since no matter the size of the submatrix we are summing, we only need to access four values of the 2D prefix sum array, this runs in $\mathcal{O}(1)$ per query after an $\mathcal{O}(NM)$ preprocessing.

### Solution - Forest Queries

### Warning!

We need to be cautious of off-by-one errors, as intervals can be inclusive, exclusive, 1-indexed, etc.

C++

#include <bits/stdc++.h>using namespace std;#define vt vector#define FOR(i, a, b) for(int i = (a); i < (b); i++)#define FORE(i, a, b) for(int i = (a); i <= (b); i++)#define F0R(i, a) for(int i = 0; i < (a); i++)#define trav(a, x) for (auto& a : x)

### Problems

Status | Source | Problem Name | Difficulty | Tags | Solution | URL |
---|---|---|---|---|---|---|

Silver | Easy | ## Show Tags2D Prefix Sums | ||||

Gold | Hard | ## Show TagsPrefix Sums, Max Subarray Sum | External Sol | |||

Silver | Hard | ## Show TagsPrefix Sums | External Sol | |||

Plat | Very Hard | External Sol |

## Additional Applications

### Max Subarray Sum

Focus Problem – read through this problem before continuing!

This problem has a solution known as Kadane's Algorithm. Please don't use that solution; try to solve it with prefix sums.

Why are the two methods equivalent?

### Prefix Minimum, XOR, etc.

Resources: Additional | |||
---|---|---|---|

CPH | defines XOR |

Similar to prefix sums, you can also take prefix minimum or maximum; but *you cannot* answer min queries over an arbitrary range with prefix minimum. (This is because minimum doesn't have an inverse operation, the way subtraction is to addition.) On the other hand, XOR is its own inverse operation, meaning that the XOR of any number with itself is zero.

Status | Source | Problem Name | Difficulty | Tags | Solution | URL |
---|---|---|---|---|---|---|

Silver | Easy | ## Show TagsPrefix Sums | External Sol | |||

CSES | Easy | ## Show TagsPrefix Sums |

### A More Complicated Example

What if we want to quickly answer the following type of query?

Find $1\cdot a_l+2\cdot a_{l+1}+3\cdot a_{l+2}+\cdots+(r-l+1)\cdot a_{r}$.

In addition to taking prefix sums over $a_i$, we'll also need to take prefix sums over $i\cdot a_i$.

First, define the following:

Then, we have:

And so,

Which is what we were looking for!

Status | Source | Problem Name | Difficulty | Tags | Solution | URL |
---|---|---|---|---|---|---|

KS | Easy | ## Show TagsPrefix Sums | ||||

AC | Hard | ## Show TagsPrefix Sums | Check AC | |||

Plat | Insane | External Sol |

### Module Progress:

### Join the USACO Forum!

Stuck on a problem, or don't understand a module? Join the USACO Forum and get help from other competitive programmers!

## Give Us Feedback on Prefix Sums!

Leave suggestions for us by making a post on the USACO Forum! Ex: Unclear sections, mislabeled problems, etc.