From 1319f46f0ed8acd462d51e72df76282b06bee21a Mon Sep 17 00:00:00 2001 From: Antti H S Laaksonen Date: Sat, 4 Feb 2017 01:54:48 +0200 Subject: [PATCH] Corrections --- luku09.tex | 143 +++++++++++++++++++++++++++-------------------------- 1 file changed, 74 insertions(+), 69 deletions(-) diff --git a/luku09.tex b/luku09.tex index 2bd4ea3..2a7f3a1 100644 --- a/luku09.tex +++ b/luku09.tex @@ -5,16 +5,15 @@ \index{minimum query} \index{maximum query} -In a \key{range query}, a range of an array -is given and we should calculate some value from the -elements in the range. Typical range queries are: +A \key{range query} asks to calculate some information +about the elements in a given range of an array. +Typical range queries are: \begin{itemize} -\item \key{sum query}: calculate the sum of elements in range $[a,b]$ -\item \key{minimum query}: find the smallest element in range $[a,b]$ -\item \key{maximum query}: find the largest element in range $[a,b]$ +\item \key{sum query}: calculate the sum of elements in a range +\item \key{minimum query}: find the smallest element in a range +\item \key{maximum query}: find the largest element in a range \end{itemize} -For example, in range $[4,7]$ of the following array, -the sum is $4+6+1+3=14$, the minimum is 1 and the maximum is 6: +For example, consider the range $[4,7]$ in the following array: \begin{center} \begin{tikzpicture}[scale=0.7] \fill[color=lightgray] (3,0) rectangle (7,1); @@ -40,10 +39,14 @@ the sum is $4+6+1+3=14$, the minimum is 1 and the maximum is 6: \node at (7.5,1.4) {$8$}; \end{tikzpicture} \end{center} +In this range, the sum of elements is $4+6+1+3=16$, +the minimum element is 1 and the maximum element is 6. -An easy way to answer a range query is -to iterate through all the elements in the range. -For example, we can answer a sum query as follows: + +An easy way to process range queries is +to go through all the elements in the range. +For example, we can calculate the sum +in a range $[a,b]$ as follows: \begin{lstlisting} int sum(int a, int b) { @@ -55,34 +58,34 @@ int sum(int a, int b) { } \end{lstlisting} -The above function handles a sum query -in $O(n)$ time, which is slow if the array is large -and there are a lot of queries. -In this chapter we will learn how -range queries can be answered much more efficiently. +The above function works in $O(n)$ time. +However, if the array is large and there are several queries, +such an approach is slow. +In this chapter, we will learn how +range queries can be processed much more efficiently. \section{Static array queries} -We will first focus on a simple case where +We first focus on a simple situation where the array is \key{static}, i.e., the elements never change between the queries. -In this case, it suffices to process the -contents of the array beforehand and construct -a data structure that can be used for answering +In this case, it suffices to preprocess the +array and construct +a data structure that can be used for +finding the answer for any possible range query efficiently. \subsubsection{Sum query} \index{prefix sum array} -Sum queries can be answered efficiently +Sum queries can be processed efficiently by constructing a \key{sum array} -that contains the sum of the range $[1,k]$ +that contains the sum of elements in the range $[1,k]$ for each $k=1,2,\ldots,n$. -After this, the sum of any range $[a,b]$ of the -original array -can be calculated in $O(1)$ time using the -precalculated sum array. +Using the sum array, the sum of elements in +any range $[a,b]$ of the original array can +be calculated in $O(1)$ time. For example, for the array \begin{center} @@ -137,27 +140,27 @@ the corresponding sum array is as follows: \node at (7.5,1.4) {$8$}; \end{tikzpicture} \end{center} -The following code constructs a prefix sum -array \texttt{s} from array \texttt{t} in $O(n)$ time: +The following code constructs a sum array +\texttt{s} for an array \texttt{t} in $O(n)$ time: \begin{lstlisting} for (int i = 1; i <= n; i++) { s[i] = s[i-1]+t[i]; } \end{lstlisting} -After this, the following function answers -a sum query in $O(1)$ time: +After this, the following function processes +any sum query in $O(1)$ time: \begin{lstlisting} int sum(int a, int b) { return s[b]-s[a-1]; } \end{lstlisting} -The function calculates the sum of range $[a,b]$ -by subtracting the sum of range $[1,a-1]$ -from the sum of range $[1,b]$. -Thus, only two values from the sum array +The function calculates the sum in the range $[a,b]$ +by subtracting the sum in the range $[1,a-1]$ +from the sum in the range $[1,b]$. +Thus, only two values of the sum array are needed, and the query takes $O(1)$ time. -Note that thanks to the one-based indexing, +Note that because of the one-based indexing, the function also works when $a=1$ if $\texttt{s}[0]=0$. As an example, consider the range $[4,7]$: @@ -186,9 +189,9 @@ As an example, consider the range $[4,7]$: \node at (7.5,1.4) {$8$}; \end{tikzpicture} \end{center} -The sum of the range $[4,7]$ is $8+6+1+4=19$. -This can be calculated from the sum array -using the sums $[1,3]$ and $[1,7]$: +The sum in the range is $8+6+1+4=19$. +This can be calculated using the precalculated +sums for the ranges $[1,3]$ and $[1,7]$: \begin{center} \begin{tikzpicture}[scale=0.7] \fill[color=lightgray] (2,0) rectangle (3,1); @@ -216,14 +219,15 @@ using the sums $[1,3]$ and $[1,7]$: \node at (7.5,1.4) {$8$}; \end{tikzpicture} \end{center} -Thus, the sum of the range $[4,7]$ is $27-8=19$. +Thus, the sum in the range $[4,7]$ is $27-8=19$. -We can also generalize the idea of a sum array -for a two-dimensional array. -In this case, it will be possible to calculate the sum of -any rectangular subarray in $O(1)$ time. -The sum array will contain sums -for all subarrays that begin from the upper-left corner. +It is also possible to generalize this idea +to higher dimensions. +For example, we can construct a two-dimensional +sum array that can be used for calculating +the sum of any rectangular subarray in $O(1)$ time. +Each value in such an array is the sum of a subarray +that begins at the upper-left corner of the array. \begin{samepage} The following picture illustrates the idea: @@ -240,23 +244,23 @@ The following picture illustrates the idea: \end{center} \end{samepage} -The sum inside the gray subarray can be calculated +The sum of the gray subarray can be calculated using the formula -\[S(A) - S(B) - S(C) + S(D)\] -where $S(X)$ denotes the sum in a rectangular +\[S(A) - S(B) - S(C) + S(D),\] +where $S(X)$ denotes the sum of a rectangular subarray from the upper-left corner -to the position of letter $X$. +to the position of $X$. \subsubsection{Minimum query} -It is also possible to answer a minimum query +It is also possible to process minimum queries in $O(1)$ time after preprocessing, though it is -more difficult than answer a sum query. +more difficult than processing sum queries. Note that minimum and maximum queries can always be implemented using same techniques, -so it suffices to focus on the minimum query. +so it suffices to focus on minimum queries. -The idea is to find the minimum element for each range +The idea is to precalculate the minimum element of each range of size $2^k$ in the array. For example, in the array @@ -336,21 +340,22 @@ $[1,8]$ & 8 & 1 \\ \end{center} -The number of $2^k$ ranges in an array is $O(n \log n)$ -because there are $O(\log n)$ ranges that begin -from each array index. -The minima for all $2^k$ ranges can be calculated -in $O(n \log n)$ time because each $2^k$ range -consists of two $2^{k-1}$ ranges, so the minima +There are $O(n \log n)$ ranges of size $2^k$, +because for each array position, +there are $O(\log n)$ ranges that begin at that position. +The minima in all ranges of size $2^k$ can be calculated +in $O(n \log n)$ time, because each range of size $2^k$ +consists of two ranges of size $2^{k-1}$ and the minima can be calculated recursively. -After this, the minimum of any range $[a,b]$c +After this, the minimum in any range $[a,b]$ can be calculated in $O(1)$ time as a minimum of -two $2^k$ ranges where $k=\lfloor \log_2(b-a+1) \rfloor$. -The first range begins from index $a$, -and the second range ends to index $b$. -The parameter $k$ is so chosen that -two $2^k$ ranges cover the range $[a,b]$ entirely. +two ranges of size $2^k$ where $k=\lfloor \log_2(b-a+1) \rfloor$. +The first range begins at index $a$, +and the second range ends at index $b$. +The parameter $k$ is chosen so that +the two ranges of size $2^k$ +fully cover the range $[a,b]$. As an example, consider the range $[2,7]$: \begin{center} @@ -378,7 +383,7 @@ As an example, consider the range $[2,7]$: \node at (7.5,1.4) {$8$}; \end{tikzpicture} \end{center} -The length of the range $[2,7]$ is 6, +The length of the range is 6, and $\lfloor \log_2(6) \rfloor = 2$. Thus, the minimum can be calculated from two ranges of length 4. @@ -434,9 +439,9 @@ The ranges are $[2,5]$ and $[4,7]$: \node at (7.5,1.4) {$8$}; \end{tikzpicture} \end{center} -The minimum of the range $[2,5]$ is 3, -and the minimum of the range $[4,7]$ is 1. -Thus, the minimum of the range $[2,7]$ is 1. +Since the minimum in the range $[2,5]$ is 3 +and the minimum in the range $[4,7]$ is 1, +we know that the minimum in the range $[2,7]$ is 1. \section{Binary indexed tree}