819 lines
22 KiB
TeX
819 lines
22 KiB
TeX
\chapter{Amortized analysis}
|
|
|
|
\index{amortized analysis}
|
|
|
|
Often the time complexity of an algorithm
|
|
is easy to analyze by looking at the structure
|
|
of the algorithm:
|
|
what loops there are and how many times
|
|
they are performed.
|
|
However, sometimes a straightforward analysis
|
|
doesn't give a true picture of the efficiency of the algorithm.
|
|
|
|
\key{Amortized analysis} can be used for analyzing
|
|
an algorithm that contains an operation whose
|
|
time complexity varies.
|
|
The idea is to consider all such operations during the
|
|
execution of the algorithm instead of a single operation,
|
|
and estimate the total time complexity of the operations.
|
|
|
|
\section{Two pointers method}
|
|
|
|
\index{two pointers method}
|
|
|
|
In the \key{two pointers method},
|
|
two pointers iterate through the elements in an array.
|
|
Both pointers can move during the algorithm,
|
|
but the restriction is that each pointer can move
|
|
to only one direction.
|
|
This ensures that the algorithm works efficiently.
|
|
|
|
We will next discuss two problems that can be solved
|
|
using the two pointers method.
|
|
|
|
\subsubsection{Subarray sum}
|
|
|
|
Given an array that contains $n$ positive integers,
|
|
our task is to find out if there is a subarray
|
|
where the sum of the elements is $x$.
|
|
For example, the array
|
|
\begin{center}
|
|
\begin{tikzpicture}[scale=0.7]
|
|
\draw (0,0) grid (8,1);
|
|
|
|
\node at (0.5,0.5) {$1$};
|
|
\node at (1.5,0.5) {$3$};
|
|
\node at (2.5,0.5) {$2$};
|
|
\node at (3.5,0.5) {$5$};
|
|
\node at (4.5,0.5) {$1$};
|
|
\node at (5.5,0.5) {$1$};
|
|
\node at (6.5,0.5) {$2$};
|
|
\node at (7.5,0.5) {$3$};
|
|
|
|
\footnotesize
|
|
\node at (0.5,1.4) {$1$};
|
|
\node at (1.5,1.4) {$2$};
|
|
\node at (2.5,1.4) {$3$};
|
|
\node at (3.5,1.4) {$4$};
|
|
\node at (4.5,1.4) {$5$};
|
|
\node at (5.5,1.4) {$6$};
|
|
\node at (6.5,1.4) {$7$};
|
|
\node at (7.5,1.4) {$8$};
|
|
\end{tikzpicture}
|
|
\end{center}
|
|
contains a subarray with sum 8:
|
|
\begin{center}
|
|
\begin{tikzpicture}[scale=0.7]
|
|
\fill[color=lightgray] (2,0) rectangle (5,1);
|
|
\draw (0,0) grid (8,1);
|
|
|
|
\node at (0.5,0.5) {$1$};
|
|
\node at (1.5,0.5) {$3$};
|
|
\node at (2.5,0.5) {$2$};
|
|
\node at (3.5,0.5) {$5$};
|
|
\node at (4.5,0.5) {$1$};
|
|
\node at (5.5,0.5) {$1$};
|
|
\node at (6.5,0.5) {$2$};
|
|
\node at (7.5,0.5) {$3$};
|
|
|
|
\footnotesize
|
|
\node at (0.5,1.4) {$1$};
|
|
\node at (1.5,1.4) {$2$};
|
|
\node at (2.5,1.4) {$3$};
|
|
\node at (3.5,1.4) {$4$};
|
|
\node at (4.5,1.4) {$5$};
|
|
\node at (5.5,1.4) {$6$};
|
|
\node at (6.5,1.4) {$7$};
|
|
\node at (7.5,1.4) {$8$};
|
|
\end{tikzpicture}
|
|
\end{center}
|
|
|
|
It turns out that the problem can be solved in
|
|
$O(n)$ time using the two pointers method.
|
|
The idea is to iterate through the array
|
|
using two pointers that define a range in the array.
|
|
On each turn, the left pointer moves one step
|
|
forward, and the right pointer moves forward
|
|
as long as the sum is at most $x$.
|
|
If the sum of the range becomes exactly $x$,
|
|
we have found a solution.
|
|
|
|
As an example, we consider the following array
|
|
with target sum $x=8$:
|
|
\begin{center}
|
|
\begin{tikzpicture}[scale=0.7]
|
|
\draw (0,0) grid (8,1);
|
|
|
|
\node at (0.5,0.5) {$1$};
|
|
\node at (1.5,0.5) {$3$};
|
|
\node at (2.5,0.5) {$2$};
|
|
\node at (3.5,0.5) {$5$};
|
|
\node at (4.5,0.5) {$1$};
|
|
\node at (5.5,0.5) {$1$};
|
|
\node at (6.5,0.5) {$2$};
|
|
\node at (7.5,0.5) {$3$};
|
|
|
|
\footnotesize
|
|
\node at (0.5,1.4) {$1$};
|
|
\node at (1.5,1.4) {$2$};
|
|
\node at (2.5,1.4) {$3$};
|
|
\node at (3.5,1.4) {$4$};
|
|
\node at (4.5,1.4) {$5$};
|
|
\node at (5.5,1.4) {$6$};
|
|
\node at (6.5,1.4) {$7$};
|
|
\node at (7.5,1.4) {$8$};
|
|
\end{tikzpicture}
|
|
\end{center}
|
|
|
|
First, the pointers define a range with sum $1+3+2=6$.
|
|
The range can't be larger
|
|
because the next number 5 would make the sum
|
|
larger than $x$.
|
|
|
|
\begin{center}
|
|
\begin{tikzpicture}[scale=0.7]
|
|
\fill[color=lightgray] (0,0) rectangle (3,1);
|
|
\draw (0,0) grid (8,1);
|
|
|
|
\node at (0.5,0.5) {$1$};
|
|
\node at (1.5,0.5) {$3$};
|
|
\node at (2.5,0.5) {$2$};
|
|
\node at (3.5,0.5) {$5$};
|
|
\node at (4.5,0.5) {$1$};
|
|
\node at (5.5,0.5) {$1$};
|
|
\node at (6.5,0.5) {$2$};
|
|
\node at (7.5,0.5) {$3$};
|
|
|
|
\draw[thick,->] (0.5,-0.7) -- (0.5,-0.1);
|
|
\draw[thick,->] (2.5,-0.7) -- (2.5,-0.1);
|
|
|
|
\footnotesize
|
|
\node at (0.5,1.4) {$1$};
|
|
\node at (1.5,1.4) {$2$};
|
|
\node at (2.5,1.4) {$3$};
|
|
\node at (3.5,1.4) {$4$};
|
|
\node at (4.5,1.4) {$5$};
|
|
\node at (5.5,1.4) {$6$};
|
|
\node at (6.5,1.4) {$7$};
|
|
\node at (7.5,1.4) {$8$};
|
|
\end{tikzpicture}
|
|
\end{center}
|
|
|
|
After this, the left pointer moves one step forward.
|
|
The right pointer doesn't move because otherwise
|
|
the sum would become too large.
|
|
|
|
\begin{center}
|
|
\begin{tikzpicture}[scale=0.7]
|
|
\fill[color=lightgray] (1,0) rectangle (3,1);
|
|
\draw (0,0) grid (8,1);
|
|
|
|
\node at (0.5,0.5) {$1$};
|
|
\node at (1.5,0.5) {$3$};
|
|
\node at (2.5,0.5) {$2$};
|
|
\node at (3.5,0.5) {$5$};
|
|
\node at (4.5,0.5) {$1$};
|
|
\node at (5.5,0.5) {$1$};
|
|
\node at (6.5,0.5) {$2$};
|
|
\node at (7.5,0.5) {$3$};
|
|
|
|
\draw[thick,->] (1.5,-0.7) -- (1.5,-0.1);
|
|
\draw[thick,->] (2.5,-0.7) -- (2.5,-0.1);
|
|
|
|
\footnotesize
|
|
\node at (0.5,1.4) {$1$};
|
|
\node at (1.5,1.4) {$2$};
|
|
\node at (2.5,1.4) {$3$};
|
|
\node at (3.5,1.4) {$4$};
|
|
\node at (4.5,1.4) {$5$};
|
|
\node at (5.5,1.4) {$6$};
|
|
\node at (6.5,1.4) {$7$};
|
|
\node at (7.5,1.4) {$8$};
|
|
\end{tikzpicture}
|
|
\end{center}
|
|
|
|
Again, the left pointer moves one step forward,
|
|
and this time the right pointer moves three
|
|
steps forward.
|
|
The sum is $2+5+1=8$, so we have found a subarray
|
|
where the sum of the elements is $x$.
|
|
|
|
\begin{center}
|
|
\begin{tikzpicture}[scale=0.7]
|
|
\fill[color=lightgray] (2,0) rectangle (5,1);
|
|
\draw (0,0) grid (8,1);
|
|
|
|
\node at (0.5,0.5) {$1$};
|
|
\node at (1.5,0.5) {$3$};
|
|
\node at (2.5,0.5) {$2$};
|
|
\node at (3.5,0.5) {$5$};
|
|
\node at (4.5,0.5) {$1$};
|
|
\node at (5.5,0.5) {$1$};
|
|
\node at (6.5,0.5) {$2$};
|
|
\node at (7.5,0.5) {$3$};
|
|
|
|
\draw[thick,->] (2.5,-0.7) -- (2.5,-0.1);
|
|
\draw[thick,->] (4.5,-0.7) -- (4.5,-0.1);
|
|
|
|
\footnotesize
|
|
\node at (0.5,1.4) {$1$};
|
|
\node at (1.5,1.4) {$2$};
|
|
\node at (2.5,1.4) {$3$};
|
|
\node at (3.5,1.4) {$4$};
|
|
\node at (4.5,1.4) {$5$};
|
|
\node at (5.5,1.4) {$6$};
|
|
\node at (6.5,1.4) {$7$};
|
|
\node at (7.5,1.4) {$8$};
|
|
\end{tikzpicture}
|
|
\end{center}
|
|
|
|
The time complexity of the algorithm depends on
|
|
the number of steps the right pointer moves.
|
|
There is no upper bound how many steps the
|
|
pointer can move on a single turn.
|
|
However, the pointer moves \emph{a total of}
|
|
$O(n)$ steps during the algorithm
|
|
because it only moves forward.
|
|
|
|
Since both the left and the right pointer
|
|
move $O(n)$ steps during the algorithm,
|
|
the time complexity is $O(n)$.
|
|
|
|
\subsubsection{Sum of two numbers}
|
|
|
|
\index{2SUM problem}
|
|
|
|
Given an array of $n$ integers and an integer $x$,
|
|
our task is to find two numbers in array
|
|
whose sum is $x$ or report that there are no such numbers.
|
|
This problem is known as the \key{2SUM} problem,
|
|
and it can be solved efficiently using the
|
|
two pointers method.
|
|
|
|
First, we sort the numbers in the array in
|
|
increasing order.
|
|
After this, we iterate through the array using
|
|
two pointers that begin at both ends of the array.
|
|
The left pointer begins from the first element
|
|
and moves one step forward on each turn.
|
|
The right pointer begins from the last element
|
|
and always moves backward until the sum of the range
|
|
defined by the pointers is at most $x$.
|
|
If the sum is exactly $x$, we have found a solution.
|
|
|
|
For example, consider the following array when
|
|
our task is to find two elements whose sum is $x=12$:
|
|
\begin{center}
|
|
\begin{tikzpicture}[scale=0.7]
|
|
\draw (0,0) grid (8,1);
|
|
|
|
\node at (0.5,0.5) {$1$};
|
|
\node at (1.5,0.5) {$4$};
|
|
\node at (2.5,0.5) {$5$};
|
|
\node at (3.5,0.5) {$6$};
|
|
\node at (4.5,0.5) {$7$};
|
|
\node at (5.5,0.5) {$9$};
|
|
\node at (6.5,0.5) {$9$};
|
|
\node at (7.5,0.5) {$10$};
|
|
|
|
\footnotesize
|
|
\node at (0.5,1.4) {$1$};
|
|
\node at (1.5,1.4) {$2$};
|
|
\node at (2.5,1.4) {$3$};
|
|
\node at (3.5,1.4) {$4$};
|
|
\node at (4.5,1.4) {$5$};
|
|
\node at (5.5,1.4) {$6$};
|
|
\node at (6.5,1.4) {$7$};
|
|
\node at (7.5,1.4) {$8$};
|
|
\end{tikzpicture}
|
|
\end{center}
|
|
|
|
The initial positions of the pointers
|
|
are as follows.
|
|
The sum of the numbers is $1+10=11$
|
|
that is smaller than $x$.
|
|
|
|
\begin{center}
|
|
\begin{tikzpicture}[scale=0.7]
|
|
\fill[color=lightgray] (0,0) rectangle (1,1);
|
|
\fill[color=lightgray] (7,0) rectangle (8,1);
|
|
\draw (0,0) grid (8,1);
|
|
|
|
\node at (0.5,0.5) {$1$};
|
|
\node at (1.5,0.5) {$4$};
|
|
\node at (2.5,0.5) {$5$};
|
|
\node at (3.5,0.5) {$6$};
|
|
\node at (4.5,0.5) {$7$};
|
|
\node at (5.5,0.5) {$9$};
|
|
\node at (6.5,0.5) {$9$};
|
|
\node at (7.5,0.5) {$10$};
|
|
|
|
\draw[thick,->] (0.5,-0.7) -- (0.5,-0.1);
|
|
\draw[thick,->] (7.5,-0.7) -- (7.5,-0.1);
|
|
|
|
\footnotesize
|
|
\node at (0.5,1.4) {$1$};
|
|
\node at (1.5,1.4) {$2$};
|
|
\node at (2.5,1.4) {$3$};
|
|
\node at (3.5,1.4) {$4$};
|
|
\node at (4.5,1.4) {$5$};
|
|
\node at (5.5,1.4) {$6$};
|
|
\node at (6.5,1.4) {$7$};
|
|
\node at (7.5,1.4) {$8$};
|
|
\end{tikzpicture}
|
|
\end{center}
|
|
|
|
Then the left pointer moves one step forward.
|
|
The right pointer moves three steps backward,
|
|
and the sum becomes $4+7=11$.
|
|
|
|
\begin{center}
|
|
\begin{tikzpicture}[scale=0.7]
|
|
\fill[color=lightgray] (1,0) rectangle (2,1);
|
|
\fill[color=lightgray] (4,0) rectangle (5,1);
|
|
\draw (0,0) grid (8,1);
|
|
|
|
\node at (0.5,0.5) {$1$};
|
|
\node at (1.5,0.5) {$4$};
|
|
\node at (2.5,0.5) {$5$};
|
|
\node at (3.5,0.5) {$6$};
|
|
\node at (4.5,0.5) {$7$};
|
|
\node at (5.5,0.5) {$9$};
|
|
\node at (6.5,0.5) {$9$};
|
|
\node at (7.5,0.5) {$10$};
|
|
|
|
\draw[thick,->] (1.5,-0.7) -- (1.5,-0.1);
|
|
\draw[thick,->] (4.5,-0.7) -- (4.5,-0.1);
|
|
|
|
\footnotesize
|
|
\node at (0.5,1.4) {$1$};
|
|
\node at (1.5,1.4) {$2$};
|
|
\node at (2.5,1.4) {$3$};
|
|
\node at (3.5,1.4) {$4$};
|
|
\node at (4.5,1.4) {$5$};
|
|
\node at (5.5,1.4) {$6$};
|
|
\node at (6.5,1.4) {$7$};
|
|
\node at (7.5,1.4) {$8$};
|
|
\end{tikzpicture}
|
|
\end{center}
|
|
|
|
After this, the left pointer moves one step forward again.
|
|
The right pointer doesn't move, and the solution
|
|
$5+7=12$ has been found.
|
|
|
|
\begin{center}
|
|
\begin{tikzpicture}[scale=0.7]
|
|
\fill[color=lightgray] (2,0) rectangle (3,1);
|
|
\fill[color=lightgray] (4,0) rectangle (5,1);
|
|
\draw (0,0) grid (8,1);
|
|
|
|
\node at (0.5,0.5) {$1$};
|
|
\node at (1.5,0.5) {$4$};
|
|
\node at (2.5,0.5) {$5$};
|
|
\node at (3.5,0.5) {$6$};
|
|
\node at (4.5,0.5) {$7$};
|
|
\node at (5.5,0.5) {$9$};
|
|
\node at (6.5,0.5) {$9$};
|
|
\node at (7.5,0.5) {$10$};
|
|
|
|
\draw[thick,->] (2.5,-0.7) -- (2.5,-0.1);
|
|
\draw[thick,->] (4.5,-0.7) -- (4.5,-0.1);
|
|
|
|
\footnotesize
|
|
\node at (0.5,1.4) {$1$};
|
|
\node at (1.5,1.4) {$2$};
|
|
\node at (2.5,1.4) {$3$};
|
|
\node at (3.5,1.4) {$4$};
|
|
\node at (4.5,1.4) {$5$};
|
|
\node at (5.5,1.4) {$6$};
|
|
\node at (6.5,1.4) {$7$};
|
|
\node at (7.5,1.4) {$8$};
|
|
\end{tikzpicture}
|
|
\end{center}
|
|
|
|
At the beginning of the algorithm,
|
|
the sorting takes $O(n \log n)$ time.
|
|
After this, the left pointer moves $O(n)$ steps
|
|
forward, and the right pointer moves $O(n)$ steps
|
|
backward. Thus, the total time complexity
|
|
of the algorithm is $O(n \log n)$.
|
|
|
|
Note that it is possible to solve
|
|
in another way in $O(n \log n)$ time using binary search.
|
|
In this solution, we iterate through the array
|
|
and for each number, we try to find another
|
|
number such that the sum is $x$.
|
|
This can be done by performing $n$ binary searches,
|
|
and each search takes $O(\log n)$ time.
|
|
|
|
\index{3SUM-ongelma}
|
|
A somewhat more difficult problem is
|
|
the \key{3SUM} problem where our task is
|
|
to find \emph{three} numbers whose sum is $x$.
|
|
This problem can be solved in $O(n^2)$ time.
|
|
Can you see how it is possible?
|
|
|
|
\section{Lähin pienempi edeltäjä}
|
|
|
|
\index{lzhin pienempi edeltxjx@lähin pienempi edeltäjä}
|
|
|
|
Tasoitetun analyysin avulla arvioidaan usein
|
|
tietorakenteeseen kohdistuvien operaatioiden määrää.
|
|
Algoritmin operaatiot voivat jakautua epätasaisesti
|
|
niin, että useimmat operaatiot tehdään tietyssä
|
|
algoritmin vaiheessa, mutta operaatioiden
|
|
yhteismäärä on kuitenkin rajoitettu.
|
|
|
|
Tarkastellaan esimerkkinä ongelmaa,
|
|
jossa tehtävänä on etsiä kullekin taulukon
|
|
alkiolle
|
|
\key{lähin pienempi edeltäjä} eli
|
|
lähinnä oleva pienempi alkio taulukon alkuosassa.
|
|
On mahdollista, ettei tällaista alkiota ole olemassa,
|
|
jolloin algoritmin tulee huomata asia.
|
|
Osoittautuu, että tehtävä on mahdollista ratkaista
|
|
tehokkaasti ajassa $O(n)$ sopivan tietorakenteen avulla.
|
|
|
|
Tehokas ratkaisu tehtävään on käydä
|
|
taulukko läpi alusta loppuun ja pitää samalla yllä ketjua,
|
|
jonka ensimmäinen luku on käsiteltävä taulukon luku
|
|
ja jokainen seuraava luku on luvun lähin
|
|
pienempi edeltäjä.
|
|
Jos ketjussa on vain yksi luku,
|
|
käsiteltävällä luvulla ei ole pienempää edeltäjää.
|
|
Joka askeleella ketjun alusta poistetaan lukuja
|
|
niin kauan, kunnes ketjun ensimmäinen luku on
|
|
pienempi kuin käsiteltävä taulukon luku tai ketju on tyhjä.
|
|
Tämän jälkeen käsiteltävä luku lisätään ketjun alkuun.
|
|
|
|
Tarkastellaan esimerkkinä algoritmin toimintaa
|
|
seuraavassa taulukossa:
|
|
\begin{center}
|
|
\begin{tikzpicture}[scale=0.7]
|
|
\draw (0,0) grid (8,1);
|
|
|
|
\node at (0.5,0.5) {$1$};
|
|
\node at (1.5,0.5) {$3$};
|
|
\node at (2.5,0.5) {$4$};
|
|
\node at (3.5,0.5) {$2$};
|
|
\node at (4.5,0.5) {$5$};
|
|
\node at (5.5,0.5) {$3$};
|
|
\node at (6.5,0.5) {$4$};
|
|
\node at (7.5,0.5) {$2$};
|
|
|
|
\footnotesize
|
|
\node at (0.5,1.4) {$1$};
|
|
\node at (1.5,1.4) {$2$};
|
|
\node at (2.5,1.4) {$3$};
|
|
\node at (3.5,1.4) {$4$};
|
|
\node at (4.5,1.4) {$5$};
|
|
\node at (5.5,1.4) {$6$};
|
|
\node at (6.5,1.4) {$7$};
|
|
\node at (7.5,1.4) {$8$};
|
|
\end{tikzpicture}
|
|
\end{center}
|
|
|
|
Aluksi luvut 1, 3 ja 4 liittyvät ketjuun, koska jokainen luku on
|
|
edellistä suurempi. Siis luvun 4 lähin pienempi edeltäjä on luku 3,
|
|
jonka lähin pienempi edeltäjä on puolestaan luku 1. Tilanne näyttää tältä:
|
|
\begin{center}
|
|
\begin{tikzpicture}[scale=0.7]
|
|
\fill[color=lightgray] (2,0) rectangle (3,1);
|
|
\draw (0,0) grid (8,1);
|
|
|
|
\node at (0.5,0.5) {$1$};
|
|
\node at (1.5,0.5) {$3$};
|
|
\node at (2.5,0.5) {$4$};
|
|
\node at (3.5,0.5) {$2$};
|
|
\node at (4.5,0.5) {$5$};
|
|
\node at (5.5,0.5) {$3$};
|
|
\node at (6.5,0.5) {$4$};
|
|
\node at (7.5,0.5) {$2$};
|
|
|
|
\draw[thick,->] (2.5,-0.25) .. controls (2.25,-1.00) and (1.75,-1.00) .. (1.6,-0.25);
|
|
\draw[thick,->] (1.4,-0.25) .. controls (1.25,-1.00) and (0.75,-1.00) .. (0.5,-0.25);
|
|
|
|
\footnotesize
|
|
\node at (0.5,1.4) {$1$};
|
|
\node at (1.5,1.4) {$2$};
|
|
\node at (2.5,1.4) {$3$};
|
|
\node at (3.5,1.4) {$4$};
|
|
\node at (4.5,1.4) {$5$};
|
|
\node at (5.5,1.4) {$6$};
|
|
\node at (6.5,1.4) {$7$};
|
|
\node at (7.5,1.4) {$8$};
|
|
\end{tikzpicture}
|
|
\end{center}
|
|
|
|
Taulukon seuraava luku 2 on pienempi kuin ketjun kaksi ensimmäistä lukua 4 ja 3.
|
|
Niinpä luvut 4 ja 3 poistetaan ketjusta, minkä jälkeen luku 2
|
|
lisätään ketjun alkuun. Sen lähin pienempi edeltäjä on luku 1:
|
|
\begin{center}
|
|
\begin{tikzpicture}[scale=0.7]
|
|
\fill[color=lightgray] (3,0) rectangle (4,1);
|
|
\draw (0,0) grid (8,1);
|
|
|
|
\node at (0.5,0.5) {$1$};
|
|
\node at (1.5,0.5) {$3$};
|
|
\node at (2.5,0.5) {$4$};
|
|
\node at (3.5,0.5) {$2$};
|
|
\node at (4.5,0.5) {$5$};
|
|
\node at (5.5,0.5) {$3$};
|
|
\node at (6.5,0.5) {$4$};
|
|
\node at (7.5,0.5) {$2$};
|
|
|
|
\draw[thick,->] (3.5,-0.25) .. controls (3.00,-1.00) and (1.00,-1.00) .. (0.5,-0.25);
|
|
|
|
\footnotesize
|
|
\node at (0.5,1.4) {$1$};
|
|
\node at (1.5,1.4) {$2$};
|
|
\node at (2.5,1.4) {$3$};
|
|
\node at (3.5,1.4) {$4$};
|
|
\node at (4.5,1.4) {$5$};
|
|
\node at (5.5,1.4) {$6$};
|
|
\node at (6.5,1.4) {$7$};
|
|
\node at (7.5,1.4) {$8$};
|
|
\end{tikzpicture}
|
|
\end{center}
|
|
|
|
Seuraava luku 5 on suurempi kuin luku 2,
|
|
joten se lisätään suoraan ketjun alkuun ja
|
|
sen lähin pienempi edeltäjä on luku 2:
|
|
\begin{center}
|
|
\begin{tikzpicture}[scale=0.7]
|
|
\fill[color=lightgray] (4,0) rectangle (5,1);
|
|
\draw (0,0) grid (8,1);
|
|
|
|
\node at (0.5,0.5) {$1$};
|
|
\node at (1.5,0.5) {$3$};
|
|
\node at (2.5,0.5) {$4$};
|
|
\node at (3.5,0.5) {$2$};
|
|
\node at (4.5,0.5) {$5$};
|
|
\node at (5.5,0.5) {$3$};
|
|
\node at (6.5,0.5) {$4$};
|
|
\node at (7.5,0.5) {$2$};
|
|
|
|
\draw[thick,->] (3.4,-0.25) .. controls (3.00,-1.00) and (1.00,-1.00) .. (0.5,-0.25);
|
|
\draw[thick,->] (4.5,-0.25) .. controls (4.25,-1.00) and (3.75,-1.00) .. (3.6,-0.25);
|
|
|
|
\footnotesize
|
|
\node at (0.5,1.4) {$1$};
|
|
\node at (1.5,1.4) {$2$};
|
|
\node at (2.5,1.4) {$3$};
|
|
\node at (3.5,1.4) {$4$};
|
|
\node at (4.5,1.4) {$5$};
|
|
\node at (5.5,1.4) {$6$};
|
|
\node at (6.5,1.4) {$7$};
|
|
\node at (7.5,1.4) {$8$};
|
|
\end{tikzpicture}
|
|
\end{center}
|
|
|
|
Algoritmi jatkaa samalla tavalla taulukon loppuun
|
|
ja selvittää jokaisen luvun lähimmän
|
|
pienemmän edeltäjän.
|
|
Mutta kuinka tehokas algoritmi on?
|
|
|
|
Algoritmin tehokkuus riippuu siitä,
|
|
kauanko ketjun käsittelyyn kuluu aikaa yhteensä.
|
|
Jos uusi luku on suurempi kuin ketjun ensimmäinen
|
|
luku, se vain lisätään ketjun alkuun,
|
|
mikä on tehokasta.
|
|
Joskus taas ketjussa voi olla useita
|
|
suurempia lukuja, joiden poistaminen vie aikaa.
|
|
Oleellista on kuitenkin, että jokainen
|
|
taulukossa oleva luku liittyy
|
|
tarkalleen kerran ketjuun ja poistuu
|
|
korkeintaan kerran ketjusta.
|
|
Niinpä jokainen luku aiheuttaa $O(1)$
|
|
ketjuun liittyvää operaatiota
|
|
ja algoritmin kokonaisaikavaativuus on $O(n)$.
|
|
|
|
\section{Liukuvan ikkunan minimi}
|
|
|
|
\index{liukuva ikkuna}
|
|
\index{liukuvan ikkunan minimi@liukuvan ikkunan minimi}
|
|
|
|
\key{Liukuva ikkuna} on taulukon halki kulkeva
|
|
aktiivinen alitaulukko, jonka pituus on vakio.
|
|
Jokaisessa liukuvan ikkunan sijainnissa
|
|
halutaan tyypillisesti laskea jotain tietoa
|
|
ikkunan alueelle osuvista alkioista.
|
|
Kiinnostava tehtävä on pitää yllä
|
|
\key{liukuvan ikkunan minimiä}.
|
|
Tämä tarkoittaa, että jokaisessa liukuvan ikkunan
|
|
sijainnissa tulee ilmoittaa pienin alkio
|
|
ikkunan alueella.
|
|
|
|
Liukuvan ikkunan minimit voi laskea
|
|
lähes samalla tavalla kuin lähimmät
|
|
pienimmät edeltäjät.
|
|
Ideana on pitää yllä ketjua, jonka alussa
|
|
on ikkunan viimeinen luku ja jossa jokainen
|
|
luku on edellistä pienempi. Joka vaiheessa
|
|
ketjun viimeinen luku on ikkunan pienin luku.
|
|
Kun liukuva ikkuna liikkuu eteenpäin ja välille
|
|
tulee uusi luku, ketjusta poistetaan kaikki luvut,
|
|
jotka ovat uutta lukua suurempia.
|
|
Tämän jälkeen uusi luku lisätään ketjun alkuun.
|
|
Lisäksi jos ketjun viimeinen luku ei enää kuulu
|
|
välille, se poistetaan ketjusta.
|
|
|
|
Tarkastellaan esimerkkinä, kuinka algoritmi selvittää
|
|
minimit seuraavassa taulukossa,
|
|
kun ikkunan koko $k=4$.
|
|
|
|
\begin{center}
|
|
\begin{tikzpicture}[scale=0.7]
|
|
\draw (0,0) grid (8,1);
|
|
|
|
\node at (0.5,0.5) {$2$};
|
|
\node at (1.5,0.5) {$1$};
|
|
\node at (2.5,0.5) {$4$};
|
|
\node at (3.5,0.5) {$5$};
|
|
\node at (4.5,0.5) {$3$};
|
|
\node at (5.5,0.5) {$4$};
|
|
\node at (6.5,0.5) {$1$};
|
|
\node at (7.5,0.5) {$2$};
|
|
|
|
\footnotesize
|
|
\node at (0.5,1.4) {$1$};
|
|
\node at (1.5,1.4) {$2$};
|
|
\node at (2.5,1.4) {$3$};
|
|
\node at (3.5,1.4) {$4$};
|
|
\node at (4.5,1.4) {$5$};
|
|
\node at (5.5,1.4) {$6$};
|
|
\node at (6.5,1.4) {$7$};
|
|
\node at (7.5,1.4) {$8$};
|
|
\end{tikzpicture}
|
|
\end{center}
|
|
|
|
Liukuva ikkuna aloittaa matkansa taulukon vasemmasta reunasta.
|
|
Ensimmäisessä ikkunan sijainnissa pienin luku on 1:
|
|
\begin{center}
|
|
\begin{tikzpicture}[scale=0.7]
|
|
\fill[color=lightgray] (0,0) rectangle (4,1);
|
|
\draw (0,0) grid (8,1);
|
|
|
|
\node at (0.5,0.5) {$2$};
|
|
\node at (1.5,0.5) {$1$};
|
|
\node at (2.5,0.5) {$4$};
|
|
\node at (3.5,0.5) {$5$};
|
|
\node at (4.5,0.5) {$3$};
|
|
\node at (5.5,0.5) {$4$};
|
|
\node at (6.5,0.5) {$1$};
|
|
\node at (7.5,0.5) {$2$};
|
|
|
|
\footnotesize
|
|
\node at (0.5,1.4) {$1$};
|
|
\node at (1.5,1.4) {$2$};
|
|
\node at (2.5,1.4) {$3$};
|
|
\node at (3.5,1.4) {$4$};
|
|
\node at (4.5,1.4) {$5$};
|
|
\node at (5.5,1.4) {$6$};
|
|
\node at (6.5,1.4) {$7$};
|
|
\node at (7.5,1.4) {$8$};
|
|
|
|
\draw[thick,->] (3.5,-0.25) .. controls (3.25,-1.00) and (2.75,-1.00) .. (2.6,-0.25);
|
|
\draw[thick,->] (2.4,-0.25) .. controls (2.25,-1.00) and (1.75,-1.00) .. (1.5,-0.25);
|
|
|
|
\end{tikzpicture}
|
|
\end{center}
|
|
|
|
Kun ikkuna siirtyy eteenpäin, mukaan tulee luku 3,
|
|
joka on pienempi kuin luvut 5 ja 4 ketjun alussa.
|
|
Niinpä luvut 5 ja 4 poistuvat ketjusta ja luku 3
|
|
siirtyy sen alkuun. Pienin luku on edelleen 1.
|
|
\begin{center}
|
|
\begin{tikzpicture}[scale=0.7]
|
|
\fill[color=lightgray] (1,0) rectangle (5,1);
|
|
\draw (0,0) grid (8,1);
|
|
|
|
\node at (0.5,0.5) {$2$};
|
|
\node at (1.5,0.5) {$1$};
|
|
\node at (2.5,0.5) {$4$};
|
|
\node at (3.5,0.5) {$5$};
|
|
\node at (4.5,0.5) {$3$};
|
|
\node at (5.5,0.5) {$4$};
|
|
\node at (6.5,0.5) {$1$};
|
|
\node at (7.5,0.5) {$2$};
|
|
|
|
\footnotesize
|
|
\node at (0.5,1.4) {$1$};
|
|
\node at (1.5,1.4) {$2$};
|
|
\node at (2.5,1.4) {$3$};
|
|
\node at (3.5,1.4) {$4$};
|
|
\node at (4.5,1.4) {$5$};
|
|
\node at (5.5,1.4) {$6$};
|
|
\node at (6.5,1.4) {$7$};
|
|
\node at (7.5,1.4) {$8$};
|
|
|
|
\draw[thick,->] (4.5,-0.25) .. controls (4.25,-1.00) and (1.75,-1.00) .. (1.5,-0.25);
|
|
|
|
\end{tikzpicture}
|
|
\end{center}
|
|
|
|
Ikkuna siirtyy taas eteenpäin, minkä seurauksena pienin luku 1
|
|
putoaa pois ikkunasta. Niinpä se poistetaan ketjun lopusta
|
|
ja uusi pienin luku on 3. Lisäksi uusi ikkunaan tuleva luku 4
|
|
lisätään ketjun alkuun.
|
|
\begin{center}
|
|
\begin{tikzpicture}[scale=0.7]
|
|
\fill[color=lightgray] (2,0) rectangle (6,1);
|
|
\draw (0,0) grid (8,1);
|
|
|
|
\node at (0.5,0.5) {$2$};
|
|
\node at (1.5,0.5) {$1$};
|
|
\node at (2.5,0.5) {$4$};
|
|
\node at (3.5,0.5) {$5$};
|
|
\node at (4.5,0.5) {$3$};
|
|
\node at (5.5,0.5) {$4$};
|
|
\node at (6.5,0.5) {$1$};
|
|
\node at (7.5,0.5) {$2$};
|
|
|
|
\footnotesize
|
|
\node at (0.5,1.4) {$1$};
|
|
\node at (1.5,1.4) {$2$};
|
|
\node at (2.5,1.4) {$3$};
|
|
\node at (3.5,1.4) {$4$};
|
|
\node at (4.5,1.4) {$5$};
|
|
\node at (5.5,1.4) {$6$};
|
|
\node at (6.5,1.4) {$7$};
|
|
\node at (7.5,1.4) {$8$};
|
|
|
|
\draw[thick,->] (5.5,-0.25) .. controls (5.25,-1.00) and (4.75,-1.00) .. (4.5,-0.25);
|
|
\end{tikzpicture}
|
|
\end{center}
|
|
|
|
Seuraavaksi ikkunaan tuleva luku 1 on pienempi
|
|
kuin kaikki ketjussa olevat luvut.
|
|
Tämän seurauksena koko ketju tyhjentyy ja
|
|
siihen jää vain luku 1:
|
|
\begin{center}
|
|
\begin{tikzpicture}[scale=0.7]
|
|
\fill[color=lightgray] (3,0) rectangle (7,1);
|
|
\draw (0,0) grid (8,1);
|
|
|
|
\node at (0.5,0.5) {$2$};
|
|
\node at (1.5,0.5) {$1$};
|
|
\node at (2.5,0.5) {$4$};
|
|
\node at (3.5,0.5) {$5$};
|
|
\node at (4.5,0.5) {$3$};
|
|
\node at (5.5,0.5) {$4$};
|
|
\node at (6.5,0.5) {$1$};
|
|
\node at (7.5,0.5) {$2$};
|
|
|
|
\footnotesize
|
|
\node at (0.5,1.4) {$1$};
|
|
\node at (1.5,1.4) {$2$};
|
|
\node at (2.5,1.4) {$3$};
|
|
\node at (3.5,1.4) {$4$};
|
|
\node at (4.5,1.4) {$5$};
|
|
\node at (5.5,1.4) {$6$};
|
|
\node at (6.5,1.4) {$7$};
|
|
\node at (7.5,1.4) {$8$};
|
|
|
|
\fill[color=black] (6.5,-0.25) circle (0.1);
|
|
|
|
%\draw[thick,->] (5.5,-0.25) .. controls (5.25,-1.00) and (4.75,-1.00) .. (4.5,-0.25);
|
|
\end{tikzpicture}
|
|
\end{center}
|
|
|
|
Lopuksi ikkuna saapuu viimeiseen sijaintiinsa.
|
|
Luku 2 lisätään ketjun alkuun,
|
|
mutta ikkunan pienin luku on edelleen 1.
|
|
\begin{center}
|
|
\begin{tikzpicture}[scale=0.7]
|
|
\fill[color=lightgray] (4,0) rectangle (8,1);
|
|
\draw (0,0) grid (8,1);
|
|
|
|
\node at (0.5,0.5) {$2$};
|
|
\node at (1.5,0.5) {$1$};
|
|
\node at (2.5,0.5) {$4$};
|
|
\node at (3.5,0.5) {$5$};
|
|
\node at (4.5,0.5) {$3$};
|
|
\node at (5.5,0.5) {$4$};
|
|
\node at (6.5,0.5) {$1$};
|
|
\node at (7.5,0.5) {$2$};
|
|
|
|
\footnotesize
|
|
\node at (0.5,1.4) {$1$};
|
|
\node at (1.5,1.4) {$2$};
|
|
\node at (2.5,1.4) {$3$};
|
|
\node at (3.5,1.4) {$4$};
|
|
\node at (4.5,1.4) {$5$};
|
|
\node at (5.5,1.4) {$6$};
|
|
\node at (6.5,1.4) {$7$};
|
|
\node at (7.5,1.4) {$8$};
|
|
|
|
\draw[thick,->] (7.5,-0.25) .. controls (7.25,-1.00) and (6.75,-1.00) .. (6.5,-0.25);
|
|
\end{tikzpicture}
|
|
\end{center}
|
|
|
|
Tässäkin algoritmissa jokainen taulukon luku lisätään
|
|
ketjuun tarkalleen kerran ja poistetaan ketjusta korkeintaan kerran,
|
|
joko ketjun alusta tai ketjun lopusta.
|
|
Niinpä algoritmin kokonaisaikavaativuus on $O(n)$.
|
|
|
|
|
|
|