diff --git a/luku15.tex b/luku15.tex
index 3088a3a..9cb9f30 100644
--- a/luku15.tex
+++ b/luku15.tex
@@ -2,14 +2,15 @@
 
 \index{spanning tree}
 
-A \key{spanning tree} is a set of edges of a graph
-such that there is a path between any two nodes
-in the graph using only the edges in the spanning tree.
-Like trees in general, a spanning tree is
+A \key{spanning tree} of a graph consists of
+the nodes of the graph and some of the
+edges of the graph so that there is a unique path
+between any two nodes.
+Like trees in general, spanning trees are
 connected and acyclic.
-Usually, there are many ways to construct a spanning tree.
+Usually there are several ways to construct a spanning tree.
 
-For example, in the graph
+For example, consider the following graph:
 \begin{center}
 \begin{tikzpicture}[scale=0.9]
 \node[draw, circle] (1) at (1.5,2) {$1$};
@@ -28,7 +29,7 @@ For example, in the graph
 \path[draw,thick,-] (3) -- node[font=\small,label=left:3] {} (6);
 \end{tikzpicture}
 \end{center}
-one possible spanning tree is as follows:
+A possible spanning tree for the graph is as follows:
 \begin{center}
 \begin{tikzpicture}[scale=0.9]
 \node[draw, circle] (1) at (1.5,2) {$1$};
@@ -54,7 +55,7 @@ $3+5+9+3+2=22$.
 A \key{minimum spanning tree}
 is a spanning tree whose weight is as small as possible.
 The weight of a minimum spanning tree for the above graph
-is 20, and a tree can be constructed as follows:
+is 20, and such a tree can be constructed as follows:
 
 \begin{center}
 \begin{tikzpicture}[scale=0.9]
@@ -78,7 +79,7 @@ is 20, and a tree can be constructed as follows:
 
 \index{maximum spanning tree}
 
-Correspondingly, a \key{maximum spanning tree}
+In a similar way, a \key{maximum spanning tree}
 is a spanning tree whose weight is as large as possible.
 The weight of a maximum spanning tree for the
 above graph is 32:
@@ -102,45 +103,46 @@ above graph is 32:
 \end{tikzpicture}
 \end{center}
 
-Note that there may be several different ways
-for constructing a minimum or maximum spanning tree,
+Note that there may be several
+minimum and maximum spanning trees
+for a graph,
 so the trees are not unique.
 
-This chapter discusses algorithms that construct
-a minimum or maximum spanning tree for a graph.
-It turns out that it is easy to find such spanning trees
-because many greedy methods produce an optimal solution.
-
-We will learn two algorithms that both construct the
-tree by choosing edges ordered by weights.
-We will focus on finding a minimum spanning tree,
-but the same algorithms can be used for finding a
-maximum spanning tree by processing the edges in reverse order.
+This chapter discusses algorithms
+for constructing spanning trees.
+It turns out that it is easy to find
+minimum and maximum spanning trees,
+because many greedy methods produce optimals solutions.
+We will learn two algorithms that both process
+the edges of the graph ordered by their weights.
+We will focus on finding minimum spanning trees,
+but similar algorithms can be used for finding
+maximum spanning trees by processing the edges in reverse order.
 
 \section{Kruskal's algorithm}
 
 \index{Kruskal's algorithm}
 
 In \key{Kruskal's algorithm}, the initial spanning tree
-is empty and doesn't contain any edges.
-Then the algorithm adds edges to the tree
-one at a time
-in increasing order of their weights.
-At each step, the algorithm includes an edge in the tree
-if it doesn't create a cycle.
+only contains the nodes of the graph
+and does not contain any edges.
+Then the algorithm goes through the edges
+ordered by their weights, and always adds an edge
+to the tree if it does not create a cycle.
 
-Kruskal's algorithm maintains the components
-in the tree.
+The algorithm maintains the components
+of the tree.
 Initially, each node of the graph
-is in its own component,
-and each edge added to the tree joins two components.
-Finally, all nodes will be in the same component,
+belongs to a separate component.
+Always when an edge is added to the tree,
+two components are joined.
+Finally, all nodes belong to the same component,
 and a minimum spanning tree has been found.
 
 \subsubsection{Example}
 
 \begin{samepage}
-Let's consider how Kruskal's algorithm processes the
+Let us consider how Kruskal's algorithm processes the
 following graph:
 \begin{center}
 \begin{tikzpicture}[scale=0.9]
@@ -184,7 +186,7 @@ edge & weight \\
 \end{samepage}
 
 After this, the algorithm goes through the list
-and adds an edge to the tree if it joins
+and adds each edge to the tree if it joins
 two separate components.
 
 Initially, each node is in its own component:
@@ -208,8 +210,8 @@ Initially, each node is in its own component:
 \end{tikzpicture}
 \end{center}
 The first edge to be added to the tree is
-edge 5--6 that joins components
-$\{5\}$ and $\{6\}$ into component $\{5,6\}$:
+the edge 5--6 that creates the component $\{5,6\}$
+by joining the components $\{5\}$ and $\{6\}$:
 
 \begin{center}
 \begin{tikzpicture}
@@ -230,7 +232,7 @@ $\{5\}$ and $\{6\}$ into component $\{5,6\}$:
 %\path[draw,thick,-] (3) -- node[font=\small,label=left:3] {} (6);
 \end{tikzpicture}
 \end{center}
-After this, edges 1--2, 3--6 and 1--5 are added in a similar way:
+After this, the edges 1--2, 3--6 and 1--5 are added in a similar way:
 
 \begin{center}
 \begin{tikzpicture}[scale=0.9]
@@ -252,18 +254,17 @@ After this, edges 1--2, 3--6 and 1--5 are added in a similar way:
 \end{tikzpicture}
 \end{center}
 
-After those steps, many components have been joined
+After those steps, most components have been joined
 and there are two components in the tree:
 $\{1,2,3,5,6\}$ and $\{4\}$.
 
-The next edge in the list is edge 2--3,
-but it will not be included in the tree because
+The next edge in the list is the edge 2--3,
+but it will not be included in the tree, because
 nodes 2 and 3 are already in the same component.
-For the same reason, edge 2--5 will not be added
-to the tree.
+For the same reason, the edge 2--5 will not be included in the tree.
 
 \begin{samepage}
-Finally, edge 4--6 will be included in the tree:
+Finally, the edge 4--6 will be included in the tree:
 
 \begin{center}
 \begin{tikzpicture}[scale=0.9]
@@ -286,25 +287,25 @@ Finally, edge 4--6 will be included in the tree:
 \end{center}
 \end{samepage}
 
-After this, the algorithm terminates because
-there is a path between any two nodes and
-the graph is connected.
+After this, the algorithm will not add any
+new edges, because the graph is connected
+and there is a path between any two nodes.
 The resulting graph is a minimum spanning tree
 with weight $2+3+3+5+7=20$.
 
 \subsubsection{Why does this work?}
 
-It's a good question why Kruskal's algorithm works.
+It is a good question why Kruskal's algorithm works.
 Why does the greedy strategy guarantee that we
 will find a minimum spanning tree?
 
-Let's see what happens if the lightest edge in
-the graph is not included in the minimum spanning tree.
-For example, assume that a minimum spanning tree
-for the above graph would not contain the edge
-between nodes 5 and 6 with weight 2.
-We don't know exactly how the new minimum spanning tree
-would look like, but still it has to contain some edges.
+Let us see what happens if the minimum weight edge of
+the graph is not included in the spanning tree.
+For example, suppose that a spanning tree
+for the above graph would not contain the
+minimum weight edge 5--6.
+We do not know the exact structure of such a spanning tree,
+but in any case it has to contain some edges.
 Assume that the tree would be as follows:
 
 \begin{center}
@@ -324,10 +325,10 @@ Assume that the tree would be as follows:
 \end{tikzpicture}
 \end{center}
 
-However, it's not possible that the above tree
-would be a real minimum spanning tree for the graph.
+However, it is not possible that the above tree
+would be a minimum spanning tree for the graph.
 The reason for this is that we can remove an edge
-from it and replace it with the edge with weight 2.
+from the tree and replace it with the minimum weight edge 5--6.
 This produces a spanning tree whose weight is
 \emph{smaller}:
 
@@ -348,23 +349,24 @@ This produces a spanning tree whose weight is
 \end{tikzpicture}
 \end{center}
 
-For this reason, it is always optimal to include the lightest edge
-in the minimum spanning tree.
-Using a similar argument, we can show that we
-can also add the second lightest edge to the tree, and so on.
-Thus, Kruskal's algorithm works correctly and
+For this reason, it is always optimal
+to include the minimum weight edge
+in the tree to produce a minimum spanning tree.
+Using a similar argument, we can show that it
+is also optimal to add the next edge in weight order
+to the tree, and so on.
+Hence, Kruskal's algorithm works correctly and
 always produces a minimum spanning tree.
 
 \subsubsection{Implementation}
 
-Kruskal's algorithm can be conveniently
-implemented using an edge list.
+When implementing Kruskal's algorithm,
+the edge list representation of the graph
+is convenient.
 The first phase of the algorithm sorts the
-edges in $O(m \log m)$ time.
+edges in the list in $O(m \log m)$ time.
 After this, the second phase of the algorithm
-builds the minimum spanning tree. 
-
-The second phase of the algorithm looks as follows:
+builds the minimum spanning tree as follows:
 
 \begin{lstlisting}
 for (...) {
@@ -378,21 +380,21 @@ where $a$ and $b$ are two nodes.
 The code uses two functions:
 the function \texttt{same} determines
 if the nodes are in the same component,
-and the function \texttt{unite}
-joins two components into a single component.
+and the function \texttt{union}
+joins the components that contain nodes $a$ and $b$.
 
 The problem is how to efficiently implement
-the functions \texttt{same} and \texttt{unite}.
-One possibility is to maintain the graph
-in a usual way and implement the function
-\texttt{same} as graph traversal.
-However, using this technique,
-the running time of the function \texttt{same} would be $O(n+m)$,
-and this would be slow because the function will be
-called for each edge in the graph.
+the functions \texttt{same} and \texttt{union}.
+One possibility is to implement the function
+\texttt{same} as graph traversal and check if
+we can reach node $b$ from node $a$.
+However, the time complexity of such a function
+would be $O(n+m)$,
+and the resulting algorithm would be slow,
+because the function \texttt{same} will be called for each edge in the graph.
 
 We will solve the problem using a union-find structure
-that implements both the functions in $O(\log n)$ time.
+that implements both functions in $O(\log n)$ time.
 Thus, the time complexity of Kruskal's algorithm
 will be $O(m \log n)$ after sorting the edge list.
 
@@ -400,23 +402,23 @@ will be $O(m \log n)$ after sorting the edge list.
 
 \index{union-find structure}
 
-The \key{union-find structure} maintains
+A \key{union-find structure} maintains
 a collection of sets.
 The sets are disjoint, so no element
 belongs to more than one set.
-Two $O(\log n)$ time operations are supported.
-The first operation checks if two elements
-belong to the same set,
-and the second operation joins two sets into a single set.
+Two $O(\log n)$ time operations are supported:
+the \texttt{union} operation joins two sets,
+and the \texttt{find} operation finds the representative
+of the set that contains a given element.
 
 \subsubsection{Structure}
 
-In the union-find structure, one element in each set
-is the representative of the set.
-All other elements in the set point to the
-representative directly or through other elements in the set.
-For example, in the following picture there are three sets:
-$\{1,4,7\}$, $\{5\}$ and $\{2,3,6,8\}$.
+In a union-find structure, one element in each set
+is the representative of the set,
+and there is a chain from any other element in the
+set to the representative.
+For example, assume that the sets are
+$\{1,4,7\}$, $\{5\}$ and $\{2,3,6,8\}$:
 \begin{center}
 \begin{tikzpicture}
 \node[draw, circle] (1) at (0,-1) {$1$};
@@ -437,23 +439,22 @@ $\{1,4,7\}$, $\{5\}$ and $\{2,3,6,8\}$.
 
 \end{tikzpicture}
 \end{center}
-In this case the representatives
+In this example the representatives
 of the sets are 4, 5 and 2.
-For each element, we can find the representative
-for the corresponding set by following the
-path that begins at the element.
-For example, element 2 is the representative for the set
-that contains element 6 because
-the path is $6 \rightarrow 3 \rightarrow 2$.
-Thus, two elements belong to the same set exactly when
-they point to the same representative.
+For each element, we can find its representative
+by following the chain that begins at the element.
+For example, the element 2 is the representative
+for the element 6, because
+there is a chain $6 \rightarrow 3 \rightarrow 2$.
+Two elements belong to the same set exactly when
+their representatives are the same.
 
-Two sets can be combined by connecting the
+Two sets can be joined by connecting the
 representative of one set to the
 representative of another set.
-For example, sets
+For example, the sets
 $\{1,4,7\}$ and $\{2,3,6,8\}$
-can be combined as follows into set $\{1,2,3,4,6,7,8\}$:
+can be joined as follows:
 \begin{center}
 \begin{tikzpicture}
 \node[draw, circle] (1) at (2,-1) {$1$};
@@ -475,44 +476,45 @@ can be combined as follows into set $\{1,2,3,4,6,7,8\}$:
 \end{tikzpicture}
 \end{center}
 
-In this case, element 2 becomes the representative
-for the whole set and the old representative 4
-points to it.
+The resulting set contains the elements
+$\{1,2,3,4,6,7,8\}$.
+From this on, the element 2 will be the representative
+for the entire set and the old representative 4
+will point to the element 2.
 
-The efficiency of the operations depends on
-the way the sets are combined.
-It turns out that we can follow a simple strategy
-and always connect the representative of the
+The efficiency of the structure depends on
+the way the sets are joined.
+It turns out that we can follow a simple strategy:
+always connect the representative of the
 smaller set to the representative of the larger set
-(or, if the sets are of the same size,
-both choices are fine).
-Using this strategy, the length of a path from
-a element in a set to a representative is
-always $O(\log n)$ because each step forward
-in the path doubles the size of the corresponding set.
+(or if the sets are of equal size,
+we can make an arbitrary choice).
+Using this strategy, the length of any chain
+will be $O(\log n)$, so we can always efficiently
+find the representative of any element by following the chain.
 
 \subsubsection{Implementation}
 
-We can implement the union-find structure
+The union-find structure can be implemented
 using arrays.
 In the following implementation,
-array \texttt{k} contains for each element
+the array \texttt{k} contains for each element
 the next element
-in the path, or the element itself if it is
+in the chain or the element itself if it is
 a representative,
-and array \texttt{s} indicates for each representative
+and the array \texttt{s} indicates for each representative
 the size of the corresponding set.
 
-Initially, each element has an own set with size 1:
+Initially, each element belongs to a separate set:
 \begin{lstlisting}
 for (int i = 1; i <= n; i++) k[i] = i;
 for (int i = 1; i <= n; i++) s[i] = 1;
 \end{lstlisting}
 
 The function \texttt{find} returns
-the representative for element $x$.
+the representative for an element $x$.
 The representative can be found by following
-the path that begins at element $x$.
+the chain that begins at $x$.
 
 \begin{lstlisting}
 int find(int x) {
@@ -521,10 +523,10 @@ int find(int x) {
 }
 \end{lstlisting}
 
-The function \texttt{same} finds out
+The function \texttt{same} checks
 whether elements $a$ and $b$ belong to the same set.
 This can easily be done by using the
-function \texttt{find}.
+function \texttt{find}:
 
 \begin{lstlisting}
 bool same(int a, int b) {
@@ -533,9 +535,9 @@ bool same(int a, int b) {
 \end{lstlisting}
 
 \begin{samepage}
-The function \texttt{union} combines the sets
+The function \texttt{union} joins the sets
 that contain elements $a$ and $b$
-into a single set.
+(the elements has to be in different sets).
 The function first finds the representatives
 of the sets and then connects the smaller
 set to the larger set.
@@ -544,7 +546,7 @@ set to the larger set.
 void union(int a, int b) {
     a = find(a);
     b = find(b);
-    if (s[b] > s[a]) swap(a,b);
+    if (s[a] < s[b]) swap(a,b);
     s[a] += s[b];
     k[b] = a;
 }
@@ -552,12 +554,12 @@ void union(int a, int b) {
 \end{samepage}
 
 The time complexity of the function \texttt{find}
-is $O(\log n)$ assuming that the length of the
-path is $O(\log n)$.
-Thus, the functions \texttt{same} and \texttt{union}
+is $O(\log n)$ assuming that the length of each
+chain is $O(\log n)$.
+In this case, the functions \texttt{same} and \texttt{union}
 also work in $O(\log n)$ time.
-The function \texttt{union} ensures that the
-length of each path is $O(\log n)$ by connecting
+The function \texttt{union} makes sure that the
+length of each chain is $O(\log n)$ by connecting
 the smaller set to the larger set.
 
 \section{Prim's algorithm}
@@ -567,7 +569,8 @@ the smaller set to the larger set.
 \key{Prim's algorithm} is an alternative method
 for finding a minimum spanning tree.
 The algorithm first adds an arbitrary node
-to the tree, and then always selects an edge
+to the tree.
+After this, the algorithm always selects an edge
 whose weight is as small as possible and
 that adds a new node to the tree.
 Finally, all nodes have been added to the tree
@@ -575,14 +578,13 @@ and a minimum spanning tree has been found.
 
 Prim's algorithm resembles Dijkstra's algorithm.
 The difference is that Dijkstra's algorithm always
-selects an edge that creates a shortest path
-from the starting node to another node,
-but Prim's algorithm simply selects the lightest
-edge that adds a new node to the tree.
+selects an edge whose distance from the starting
+node is minimum, but Prim's algorithm simply selects
+the minimum weight edge that adds a new node to the tree.
 
 \subsubsection{Example}
 
-Let's consider how Prim's algorithm works
+Let us consider how Prim's algorithm works
 in the following graph:
 
 \begin{center}
@@ -624,8 +626,8 @@ Initially, there are no edges between the nodes:
 %\path[draw,thick,-] (3) -- node[font=\small,label=left:3] {} (6);
 \end{tikzpicture}
 \end{center}
-We can select an arbitrary node as a starting node,
-so let's select node 1.
+An arbitrary node can be the starting node,
+so let us select node 1.
 First, an edge with weight 3 connects nodes 1 and 2:
 \begin{center}
 \begin{tikzpicture}[scale=0.9]
@@ -648,7 +650,7 @@ First, an edge with weight 3 connects nodes 1 and 2:
 
 After this, there are two edges with weight 5,
 so we can add either node 3 or node 5 to the tree.
-Let's add node 3 first:
+Let us add node 3 first:
 \begin{center}
 \begin{tikzpicture}[scale=0.9]
 \node[draw, circle] (1) at (1.5,2) {$1$};
@@ -694,7 +696,7 @@ The process continues until all nodes have been included in the tree:
 
 Like Dijkstra's algorithm, Prim's algorithm can be
 efficiently implemented using a priority queue.
-In this case, the priority queue contains all nodes
+The priority queue should contain all nodes
 that can be connected to the current component using
 a single edge, in increasing order of the weights
 of the corresponding edges.
@@ -702,7 +704,7 @@ of the corresponding edges.
 The time complexity of Prim's algorithm is
 $O(n + m \log m)$ that equals the time complexity
 of Dijkstra's algorithm.
-In practice, Prim's algorithm and Kruskal's algorithm
+In practice, Prim's and Kruskal's algorithms
 are both efficient, and the choice of the algorithm
 is a matter of taste.
 Still, most competitive programmers use Kruskal's algorithm.
\ No newline at end of file