From 64fc16a2dcaf5b7391c269f115993cbb9ff2db8e Mon Sep 17 00:00:00 2001 From: Antti H S Laaksonen Date: Tue, 14 Feb 2017 00:06:35 +0200 Subject: [PATCH] Corrections --- luku08.tex | 31 ++++++++++++++++--------------- 1 file changed, 16 insertions(+), 15 deletions(-) diff --git a/luku08.tex b/luku08.tex index 9feebea..12fb7a0 100644 --- a/luku08.tex +++ b/luku08.tex @@ -102,7 +102,7 @@ On each turn, the left pointer moves one step forward, and the right pointer moves forward as long as the subarray sum is at most $x$. If the sum becomes exactly $x$, -we have found a solution. +a solution has been found. As an example, consider the following array with target sum $x=8$: @@ -133,7 +133,7 @@ with target sum $x=8$: Initially, the subarray contains the elements 1, 3 and 2, and the sum of the subarray is 6. -The subarray cannot be larger because +The subarray cannot be larger, because the next element 5 would make the sum larger than $x$. \begin{center} @@ -166,7 +166,7 @@ the next element 5 would make the sum larger than $x$. \end{center} Then, the left pointer moves one step forward. -The right pointer does not move because otherwise +The right pointer does not move, because otherwise the sum would become too large. \begin{center} @@ -260,13 +260,14 @@ or report that no such numbers exist. To solve the problem, we first sort the numbers in the array in increasing order. After that, we iterate through the array using -two pointers initially located at both ends of the array. -The left pointer begins at the first element +two pointers. +The left pointer starts at the first element and moves one step forward on each turn. The right pointer begins at the last element and always moves backward until the sum of the -subarray is at most $x$. -If the sum is exactly $x$, we have found a solution. +elements is at most $x$. +If the sum of the elements is exactly $x$, +a solution has been found. For example, consider the following array with target sum $x=12$: @@ -414,7 +415,7 @@ This can be done by performing $n$ binary searches, and each search takes $O(\log n)$ time. \index{3SUM-problem} -A somewhat more difficult problem is +A more difficult problem is the \key{3SUM-problem} that asks to find \emph{three} numbers in the array such that their sum is $x$. @@ -427,7 +428,7 @@ Can you see how it is possible? Amortized analysis is often used for estimating the number of operations -performed for a data structure. +performed on a data structure. The operations may be distributed unevenly so that most operations occur during a certain phase of the algorithm, but the total @@ -435,7 +436,7 @@ number of the operations is limited. As an example, consider the problem of finding for each element -in an array the +of an array the \key{nearest smaller element}, i.e., the first smaller element that precedes the element in the array. @@ -447,7 +448,7 @@ in $O(n)$ time using an appropriate data structure. An efficient solution to the problem is to iterate through the array from left to right, and maintain a chain of elements where the -first element is the current element, +first element is the current element and each following element is the nearest smaller element of the previous element. If the chain only contains one element, @@ -581,7 +582,7 @@ its nearest smaller element is 2: \end{tikzpicture} \end{center} -The algorithm continues in the same way, +The algorithm continues in the same way and finds the nearest smaller element for each number in the array. But how efficient is the algorithm? @@ -589,10 +590,10 @@ But how efficient is the algorithm? The efficiency of the algorithm depends on the total time used for manipulating the chain. If an element is larger than the first -element in the chain, it is directly added +element of the chain, it is directly added to the chain, which is efficient. However, sometimes the chain can contain several -larger elements, and it takes time to remove them. +larger elements and it takes time to remove them. Still, each element is added exactly once to the chain and removed at most once from the chain. Thus, each element causes $O(1)$ chain operations, @@ -607,7 +608,7 @@ of the algorithm is $O(n)$. A \key{sliding window} is a constant-size subarray that moves through the array. At each position of the window, -we typically want to calculate some information +we want to calculate some information about the elements inside the window. An interesting problem is to maintain the \key{sliding window minimum},