Fall 2017 Mentoring 13 (#27)

* mentor13

* Reflow and fix-up Mentoring 13

Author: kevinlin1

src/mentor13.tex

@@ -13,12 +13,17 @@ \section{Networking}
 \subimport{../topics/graphs/minimum-spanning-trees/easy/}{network.tex}
 \end{questions}
 
+\clearpage
+
 \section{A* Search}
 \begin{questions}
 \subimport{../topics/graphs/shortest-paths/a-star/easy/}{s-a-d-g.tex}
 \end{questions}
 
+\clearpage
+
 \section{\extra{Algorithms}}
+\subimport{../topics/graphs/text/}{algorithms.tex}
 \begin{questions}
 \subimport{../topics/graphs/search/medium/}{greedy-dfs.tex}
 \subimport{../topics/graphs/minimum-spanning-trees/medium/}{weight-constrained.tex}

topics/graphs/minimum-spanning-trees/easy/network.tex

@@ -1,8 +1,6 @@
-\begin{blocksection}
-\question Suppose we need to design a telephone network connecting all the
-residents, labeled $A$ through $G$, in a neighborhood. How can we create a
-network that guarantees connectivity between all subscribers at the least
-possible cost?
+\question Suppose we want to design a telephone network connecting all the
+cities, labeled $A$ to $G$, in a neighborhood. We'd like to do so at the least
+cost.
 
 \begin{center}
 \begin{tikzpicture}[scale=0.15]
@@ -52,11 +50,10 @@
 \part In a graph with $N$ vertices and $M$ edges, how many edges form a minimum
 spanning tree?
 \begin{solution}[0.5in]
-$N-1$, or 6 edges in the above graph.
+$N - 1$, or 6 edges in the above graph.
 \end{solution}
 
-\part Will the new graph contain any cycles? Describe the structure of the
-graph.
+\part Will the new graph contain any cycles? Describe its structure.
 \begin{solution}[1in]
 The resulting graph is a tree which implies that it contains no cycles. If the
 tree reaches every node in the graph, then it is a \define{spanning tree}.
@@ -65,8 +62,18 @@
 weight of the tree.
 \end{solution}
 
-\part Run Kruskal's Algorithm to find the minimum spanning tree.
-\begin{solution}[1in]
+\part One algorithm to find a minimum spanning tree is Kruskal's algorithm.
+\begin{enumerate}
+\item Sort all the edges by increasing order of their weight.
+\item Pick the smallest edge and check if it forms a cycle with the spanning
+tree so far. If it doesn't form a cycle, add this edge to the spanning tree.
+\item Repeat the previous step until there are $|V| - 1$ edges in the spanning
+tree, where $|V|$ is the number of vertices in the graph.
+\end{enumerate}
+
+Run Kruskal's Algorithm to find a minimum spanning tree.
+
+\begin{solution}
 \begin{center}
 \begin{tikzpicture}[scale=0.15]
 \tikzstyle{every node}+=[inner sep=0pt]
@@ -98,6 +105,9 @@
 \draw (49.5,-30) node [left] {$1$};
 \end{tikzpicture}
 \end{center}
+
+\textbf{Meta}: Draw only the nodes and add the edges that are part of the MST
+as you walk through the problem. Labeling all the edges would take a long time,
+and erasing is confusing and complicated.
 \end{solution}
 \end{parts}
-\end{blocksection}

topics/graphs/minimum-spanning-trees/medium/weight-constrained.tex

@@ -1,10 +1,10 @@
 \begin{blocksection}
-\question Briefly describe an efficient algorithm (and report the running time)
-for finding a minimum spanning tree in an undirected, connected graph
-$G = (V, E)$ when the edge weights satisfy:
+\question Briefly describe an efficient algorithm and the runtime for finding a
+minimum spanning tree in an undirected, connected graph $G = (V, E)$ when the
+edge weights satisfy:
 
 \begin{parts}
-\part For all $e \in E$, $w_e = 1$.
+\part For all $e \in E$, $w_e = 1$. (All edge weights are 1.)
 \begin{solution}[1.5in]
 The key idea here is that any tree which connects all nodes is an MST. We can
 run DFS and take the DFS tree. You could also take a BFS tree, or run Prim's
@@ -13,8 +13,8 @@
 $\Theta(|V| + |E|) \in \Theta(|E|)$ for simple graphs.
 \end{solution}
 
-\part For all $e \in E$, $w_e \in \{1, 2\}$. (In other words, all edge weights
-are either 1 or 2.)
+\part For all $e \in E$, $w_e \in \{1, 2\}$. (All edge weights are either 1 or
+2.)
 \begin{solution}[1.5in]
 Run Prim's algorithm with a specialized priority queue, comprised of 2 regular
 queues. When we add items to the priority queue, we add it to the first queue

topics/graphs/search/medium/greedy-dfs.tex

@@ -1,6 +1,6 @@
 \begin{blocksection}
-\question Is this algorithm for computing the shortest path between two
-vertices correct?
+\question Is this algorithm for computing the \emph{single pair shortest path}
+correct?
 
 Given a starting vertex, $s$, and an ending vertex, $v$, compute the shortest
 path between $s$ and $v$ by running DFS, but at each node exploring the

topics/graphs/shortest-paths/a-star/easy/s-a-d-g.tex

@@ -1,13 +1,14 @@
-\begin{blocksection}
 \question Find the path from the start, $S$, to the goal, $G$, when running
 each of the following algorithms.
 
+The \define{heuristic}, $h$, estimates the distance from each node to the goal.
+
 \begin{center}
 \begin{tikzpicture}[scale=0.15]
 \tikzstyle{every node}+=[inner sep=0pt]
 \draw (60,-15) circle (3);
 \draw (60,-15) node {$E$};
-\draw (65,-18) node {\footnotesize $h = 1$};
+\draw (66.5,-15) node {\footnotesize $h = 1$};
 \draw (10,-30) circle (3);
 \draw (10,-30) node {$S$};
 \draw (15,-33) node {\footnotesize $h = 6$};
@@ -47,48 +48,71 @@
 \draw (58,-30) -- (67,-30);
 \fill (67,-30) -- (66.2,-29.5) -- (66.2,-30.5);
 \draw (62.5,-29.5) node [above] {$2$};
+\draw (61.66,-17.5) -- (68.34,-27.5);
+\fill (68.34,-27.5) -- (68.31,-26.56) -- (67.48,-27.12);
+\draw (64.39,-23.83) node [left] {$1$};
 \end{tikzpicture}
 \end{center}
 
 \begin{solution}
 Note that uniform cost search and greedy search are not a part of the course.
 The algorithms for all 3 of these searches are extremely similar, the only
-difference being the priority given to a key and whether or not we need the
-cumulative distance to a vertex.
+difference being the priority given to each node and whether or not we need to
+keep track of the cumulative distance to a vertex.
 \end{solution}
 
 \begin{parts}
 \part Which path does uniform cost search return?
+
+\define{Uniform cost search} is the same as Dijkstra's, except that the search
+stops once we visit the goal state.
+
 \begin{solution}[1in]
 $S - A - D - G$
 
 From the starting node, choose the path that has the least cost, go to that
 node, and repeat until we reach the goal node. We choose the lowest
 \emph{backward cost}.
 
-Note that this is very similar to Dijkstra's, just a little more general. We
-keep a priority-queue fringe that keeps track of paths. At each step, we remove
-the shortest path from the fringe and add its children to the fringe, trying
-all paths in increasing cost order until we reach G.
+We keep a priority-queue fringe that keeps track of paths. At each step, we
+remove the shortest path from the fringe and add its children to the fringe,
+trying all paths in increasing cost order until we reach $G$.
 \end{solution}
 
 \part Which path does greedy search return?
+
+In \define{greedy search}, we ignore edge weights entirely and only use the
+heuristic to decide which node to visit next.
+
 \begin{solution}[1in]
-$S - A - E - D - G$ or $S - A - D - G$ depending on tie-breaking behavior.
+$S - A - E - D - G$
 
 From the starting node, travel to the next node with the lowest value returned
 by the heuristic function until we reach the goal node. We choose the path with
 the lowest \emph{forward cost}.
+
+Note that, unlike UCS or Dijkstra's, we don't add heuristics together because
+they already estimate the distance to the goal.
 \end{solution}
 
 \part Which path does A* search return?
+
+\define{A* search} is an algorithm that combines the total distance from the
+start with the heuristic to optimize the search procedure.
+
 \begin{solution}[1in]
 $S - A - D - G$
 
 At each node, we choose the next node that has the lowest sum of the path cost
 and $h(\cdot)$ value. This is essentially uniform cost search and greedy search
 combined.
 
+For A* to work, heuristics must be \emph{admissible} and \emph{consistent}.
+
+\begin{itemize}
+\item Admissible heuristics underestimate the true distance to the goal.
+\item Consistent heuristics require that the difference in heuristic values
+between two nodes cannot be greater than the true distance between the two.
+\end{itemize}
 \end{solution}
 \end{parts}
-\end{blocksection}

topics/graphs/shortest-paths/dijkstras/hard/bfs-dijkstras.tex

@@ -6,9 +6,8 @@
 connecting them, or infinity if no such path exists.
 
 \begin{parts}
-\part Design an algorithm for solving the problem that runs faster than
-Dijkstra's.
-\begin{solution}[2in]
+\part Design an algorithm for solving the problem better than Dijkstra's.
+\begin{solution}[2.5in]
 For every edge $e$ in the graph, replace $e$ with a chain of $w-1$ vertices
 (where $w$ is the weight of $e$) where the two ends of the chain are the
 endpoints of $e$.

topics/graphs/text/algorithms.tex

@@ -1,35 +1,37 @@
+\begin{blocksection}
 \begin{description}
 \item[Traversal] Visit all the nodes in the graph.
 \begin{itemize}[$\cdot$]
 \item Depth-first traversal (preorder and postorder)
 \item Level-order traversal
 \end{itemize}
 
-\item[Search] Given a start node, find a goal state.
+\item[Search] Given $s$, find a goal $v$.
 \begin{itemize}[$\cdot$]
 \item Depth-first search
 \item Iterative-deepening depth-first search
 \item Breadth-first search
 \end{itemize}
 
-\item[\emph{Single Pair} Shortest Path] Given a start node, find the shortest
-path to a goal node.
+\item[Single Pair Shortest Path] Given $s$, find the shortest path to a
+goal $v$.
 \begin{itemize}[$\cdot$]
 \item \emph{Uniform cost search}
 \item \emph{Greedy search}
 \item A* search
 \end{itemize}
 
-\item[\emph{Single Source} Shortest Path] Given a start node, find the shortest
-paths to all other nodes.
+\item[Single Source Shortest Path] Given $s$, find the shortest path to all
+nodes.
 \begin{itemize}[$\cdot$]
 \item Dijkstra's algorithm
 \end{itemize}
 
-\item[Minimum Spanning Tree] A \emph{spanning tree}, or cycle-free subset of
-edges connecting all the nodes, with the minimum possible total edge weight.
+\item[Minimum Spanning Tree] A \emph{spanning tree}, or acyclic subgraph
+connecting all the nodes with the least total edge weight.
 \begin{itemize}[$\cdot$]
 \item Prim's algorithm
 \item Kruskal's algorithm
 \end{itemize}
 \end{description}
+\end{blocksection}