2026 8 26 http://ozark.hendrix.edu/~yorgey/forest/00JL/ 00JL /~yorgey/forest/00JL/ Algorithms problems This page collects the problems available for you to solve on problem sets. 2026 8 26 Intro/review problems The problems in this section are intended to help you review key ideas from Data Structures and Discrete Math that we will be using a lot in this class. If you are unsure about anything here, use it as an opportunity to review or ask for help! 2026 8 26 http://ozark.hendrix.edu/~yorgey/forest/00JK/ 00JK /~yorgey/forest/00JK/ [RH] Repeated halving (1 pt) How many times do you have to repeatedly halve in order to reach (or, put another way, how many times do you have to repeatedly double in order to reach )? What about ? Consider the function which given an input , outputs the number of times can be repeatedly halved before falling below . What is the common mathematical name for this function? 2026 8 26 http://ozark.hendrix.edu/~yorgey/forest/00JM/ 00JM /~yorgey/forest/00JM/ [I1] Recurrence (2 pts) Let be defined for all by 0) \end {align*}]]> State and prove a closed (that is, non-recursive) formula for . (If you need a refresher on recursion and induction, there are a lot of resources posted on the course website!) 2026 8 26 http://ozark.hendrix.edu/~yorgey/forest/00JN/ 00JN /~yorgey/forest/00JN/ [O1] Big-O review (3 pts) For each of the following, answer with the best (smallest) upper bound from this list: Give a brief justification for each. Number of leaves in a depth- balanced binary tree Depth of an -node balanced binary tree Number of edges in an -node tree Time needed to sort a list of items using merge sort Number of distinct subsets of a set of items Number of bits needed to represent the number in binary Time needed to find the closest pair of points among points in Euclidean space by simply listing all the pairs Time needed to insert items into a binary heap Time needed to find the second largest number in a sorted list of distinct numbers Time needed to find the second largest number in an unsorted list of distinct numbers 2026 8 27 http://ozark.hendrix.edu/~yorgey/forest/00JS/ 00JS /~yorgey/forest/00JS/ Big- is not about time! Students coming out of data structures often think that big- is specifically about measuring how long algorithms take, but it is not. Big- is a tool for measuring the rate of growth of one thing relative to another. We often do use it to measure the rate of growth of the time needed to run an algorithm relative to the size of the input, but we can use it to measure rates of growth of other things as well, such as the amount of memory used relative to the size of the input, the height of a tree relative to the width, and so on. So, for example, you should not assume that the questions in [O1] Big-O review (3 pts) are asking about time unless they explicitly say so. For example, part (a) is asking how many leaves there are in a tree with a depth of , that is, how fast does the number of leaves grow relative to the depth? It is not asking how long it would take to find those leaves. 2026 8 27 http://ozark.hendrix.edu/~yorgey/forest/00JO/ 00JO /~yorgey/forest/00JO/ [K1] Kattis: Akcija (1pt) Solve Akcija. 2026 8 27 http://ozark.hendrix.edu/~yorgey/forest/00JP/ 00JP /~yorgey/forest/00JP/ Tips on solving Kattis problems Throughout the semester, I will occasionally assign programming challenges from Open Kattis. These problems will help you translate theory into practice by writing working implementations of algorithms or concepts we have been discussing in class. I am very aware that solutions to Kattis problems can easily be found online, and LLMs can solve many of them. I trust you not to look at any such solutions. You only get the benefit of these problems by solving them on your own (not to mention that doing otherwise would be an academic integrity violation). 2026 8 27 Solving You can implement your solution in any programming language you wish. Kattis always expects you to submit a program that reads from standard input and writes to standard output. For example, in Python, that means using input() to read the input and print() to produce output. In Java, you can use Scanner and System.out.println, and so on. If you'd like additional hints on how to parse the input, how to access standard data structures in your chosen programming language, etc., just ask! 2026 8 27 Submitting To submit your solution to a Kattis problem, you must submit both: A screenshot showing that Kattis accepted your submission Your code. Note, do not submit a screenshot of your code, and do not submit a project folder containing a zillion auto-generated files! Just submit a single .py or .java file (for example—you can also use other languages besides Python and Java). 2026 8 27 http://ozark.hendrix.edu/~yorgey/forest/00JQ/ 00JQ /~yorgey/forest/00JQ/ [K2] Kattis: Backspace (1 pt) Solve Backspace. Tips on solving Kattis problems 2026 8 27 http://ozark.hendrix.edu/~yorgey/forest/00JR/ 00JR /~yorgey/forest/00JR/ [K3] Kattis: Forests (1pt) Solve Forests. Tips on solving Kattis problems 2026 9 4 http://ozark.hendrix.edu/~yorgey/forest/00KF/ 00KF /~yorgey/forest/00KF/ Euclidean Algorithm problems Problems related to The Euclidean Algorithm, induction, and proving algorithm correctness. 2026 8 31 http://ozark.hendrix.edu/~yorgey/forest/00JW/ 00JW /~yorgey/forest/00JW/ [GCD1] GCD via factoring vs Euclidean algorithm (2 pts) In class we considered the problem of finding the greatest common divisor of two positive integers. We explored two ways to compute the GCD: Factor the two numbers into their unique prime factorizations, and find the biggest subset of primes contained in both; this is the factorization of the GCD. Run the Euclidean Algorithm. In this problem, you will consider the difference between these methods. Use your brain, a calculator, Wolfram Alpha, and/or some other appropriate computational system to factor into its prime factors. Now factor , and use the results to find by Method 1. Trace the execution of the Euclidean Algorithm on . Compare and contrast the two methods of computing the GCD of these two numbers. Now try to factor the number shown below, using whatever methods you like (for example, try using Wolfram Alpha). What happens? I would be willing to bet some money that you did not succeed in factoring —though not a large amount, since there do exist algorithms that can factor numbers of this size in a matter of hours or even minutes; but in any case factoring a number with, say, four times as many digits as this would require more like centuries. Factoring is widely believed to be a rather difficult computational problem (the security of your bank account probably depends on it!). Now, suppose I tell you that there are in fact three prime numbers , , and , such that (this is the same number from part (d)). Find , , and . What does this suggest about the relative efficiency of the two methods for computing the GCD? 2026 9 1 http://ozark.hendrix.edu/~yorgey/forest/00JY/ 00JY /~yorgey/forest/00JY/ [K4] Kattis: GCD (1 pt) Solve GCD. You may not use any built-in GCD function; you must implement the Euclidean Algorithm yourself. Tips on solving Kattis problems 2026 9 4 http://ozark.hendrix.edu/~yorgey/forest/00KE/ 00KE /~yorgey/forest/00KE/ Runtime analysis of the Euclidean Algorithm In [GCD1] GCD via factoring vs Euclidean algorithm (2 pts), you learned that the Euclidean Algorithm seems much more efficient than factoring; but how efficient is it, exactly? The problems in this section will walk you through a classic analysis of how long the Euclidean Algorithm takes to run on given inputs. However, the problems are independent; it is possible to do each problem without having done the previous ones. Throughout this section, when referring to the Euclidean Algorithm, we will specifically work with the recursive implementation (GCDRecA from the POGIL activity). 2026 9 1 http://ozark.hendrix.edu/~yorgey/forest/00JZ/ 00JZ /~yorgey/forest/00JZ/ [GCD2] GCD of consecutive Fibonacci numbers (2 pts) Recall the Fibonacci numbers, defined by , , and . That is, the first two Fibonacci numbers are , and then each subsequent Fibonacci number is the sum of the previous two, so the first few are Compute and , and trace the execution of the Euclidean Algorithm to compute . What happens? Prove by induction on that for all . Explain why your proof also shows that the Euclidean Algorithm requires recursive steps to compute . 2026 9 1 http://ozark.hendrix.edu/~yorgey/forest/00K0/ 00K0 /~yorgey/forest/00K0/ [GCD3] Worst-case GCD input (3 pts) In fact, more is true: consecutive Fibonacci numbers are in some sense a worst-case input for the Euclidean Algorithm: they are the smallest numbers for which the Euclidean Algorithm needs steps. Let be the following proposition: For all natural numbers and , if b]]> and makes recursive calls, then and . That is, if represents the proposition " makes recursive calls", then b) \land R(a,b,n)) \to ((a \geq F_{n+1}) \land (b \geq F_n))]]>. Prove by induction on : What does the base case say? Prove it. 202691HintLook at the code for . What can you conclude about and if it makes zero recursive calls? Let be an arbitrary natural number, and prove by supposing to be true and proving . You may want to write out and in full to help you keep track of what you know and what you are trying to prove. 202691HintShow that . Explain why the previous result shows that if then the Euclidean Algorithm requires at most steps. 2026 9 1 http://ozark.hendrix.edu/~yorgey/forest/00K1/ 00K1 /~yorgey/forest/00K1/ [GCD4] Fibonacci number size (3 pts) How big are Fibonacci numbers? Let’s find out: Solve for and call the positive solution (this is often known as the golden ratio) and the negative solution . Explain why we know that and . 202691HintYour answer should be one sentence! Show that for all (by starting with and multiplying both sides by ). Note that the same is also true with in place of . Now prove by induction on that . 202691HintDon’t forget that you need two base cases; you will want to show that . Conclude that . 202691HintWhat can you say about as gets large? 2026 9 4 http://ozark.hendrix.edu/~yorgey/forest/00KD/ 00KD /~yorgey/forest/00KD/ [GCD5] Time complexity of the Euclidean Algorithm (logarithm review) (2 pts) Suppose we want to run the Euclidean Algorithm to compute , assuming b]]>. Let be the smallest Fibonacci number which is greater than or equal to . Then we know from the previous problem that the Euclidean Algorithm takes at most steps to run, with the worst case being when . We want to figure out how relates to . Starting from (since this is the worst case), and using the result from the previous problem, namely, that , solve (approximately) for in terms of . Your final answer should be of the form for suitable constants and ; you should give and in approximate, decimal form. Conclude that the Euclidean Algorithm requires, in the worst case, a number of steps proportional to the number of digits in the base-ten representation of . 2026 9 4 http://ozark.hendrix.edu/~yorgey/forest/00KG/ 00KG /~yorgey/forest/00KG/ [I2] Exponentiation (3 pts) Write a recursive algorithm which, given a real number and a natural number , computes the power . Prove that your algorithm is correct. You may express your algorithm using appropriate pseudocode, or you may implement it in a real programming language; either one is fine. You may use addition, subtraction, multiplication, and division, but you may not use any kind of built-in exponentiation operation. 2026 9 8 http://ozark.hendrix.edu/~yorgey/forest/00KI/ 00KI /~yorgey/forest/00KI/ [I3] The Jellybean Game (3 pts) The jellybean game is a game for two players. There is a row of jars, numbered to from left to right, each of which starts out containing some number of jellybeans (possibly zero). We assume that these are magical jars which can hold an unlimited number of jellybeans, so we don’t have to worry about the jars getting too full. (Note, however, that the jars cannot hold infinitely many beans—each jar must always have some finite number of jellybeans in it, but that number can be as big as we want.) We also assume that there is an unlimited supply of extra jellybeans (such as a jellybean factory or a magical jellybean-pooping unicorn). The players alternate turns. On a player’s turn, she must: Pick a nonempty jar, call it jar . Remove one jellybean from jar . Add as many jellybeans as she wants (possibly zero) to each of the jars to the left of her chosen jar. For example, suppose there are five jars which currently hold One possible valid turn is to pick jar 4 and remove one jellybean from it, then add 6, 29, and one billion jellybeans to jars , , and respectively, resulting in The winner is the player who removes the last jellybean. Put another way, the loser is the first player who is unable to move because all the jars are empty. Prove that the jellybean game always ends eventually. That is, even if the players conspire to try to make the game last forever, they cannot, as long as they follow the rules. (Of course, they certainly can make the game take a very, very long time...) Describe a winning strategy for the jellybean game. From which positions is the first player guaranteed to win, as long as they play perfectly? What strategy should the first player follow in order to guarantee a win, if a win is possible? 2026 9 8 http://ozark.hendrix.edu/~yorgey/forest/00KJ/ 00KJ /~yorgey/forest/00KJ/ Asymptotic analysis problems Problems related to asymptotic analysis. 2026 9 8 http://ozark.hendrix.edu/~yorgey/forest/00KK/ 00KK /~yorgey/forest/00KK/ [O2] Algorithm input sizes by runtime (1 pt) Suppose you have algorithms with the six running times listed below. (Assume these are the exact number of operations performed as a function of the input size .) Suppose you have a computer that can perform operations per second, and you need to compute a result in at most an hour of computation. For each of the algorithms, what is the largest input size for which you would be able to get the result within an hour? For answers smaller than , give your answer as an exact integer; for larger answers you may provide an approximation. 202698HintMost of these can be solved algebraically, but for at least one you may need to resort to numeric methods (e.g. use Wolfram Alpha or write a bit of code yourself). 2026 9 8 http://ozark.hendrix.edu/~yorgey/forest/00KL/ 00KL /~yorgey/forest/00KL/ [O3] Some asymptotic properties (2 pts) 2026 9 8 http://ozark.hendrix.edu/~yorgey/forest/00KM/ 00KM /~yorgey/forest/00KM/ Little-o notation In addition to , , and , we will also sometimes use the notation (little-o) to mean that a function is but not . So, if , then is . Intuitively, if big-O is like “less than or equal to”, little-o is like “less than”; if is then “grows strictly more slowly than” . Show that is whenever . Prove that is for any positive integer bases 1]]>. Conclude that we are justified in writing simply without caring about the base of the logarithm. 202698HintRecall, or look up, the logarithm change-of-base formula. Prove that is for any 1]]> and 0]]>. 202698HintUse l'Hôpital's rule. Prove that is for any positive integer and any real number 1]]>. For example, is . In the long run, any polynomial function grows more slowly than any exponential function! 202698HintUse induction and l'Hôpital's rule. 2026 9 11 http://ozark.hendrix.edu/~yorgey/forest/00L5/ 00L5 /~yorgey/forest/00L5/ [O4] Function ordering (1 pt) Take the following list of functions and arrange them in ascending order of asymptotic growth rate. That is, if function immediately follows function in your list, then it should be the case that is . Please prove/justify your claims by making reference to theorems from class or the previous problem. 2026 9 11 http://ozark.hendrix.edu/~yorgey/forest/00L6/ 00L6 /~yorgey/forest/00L6/ [O5] Characterizing asymptotic behavior (4 pts) Characterize the asymptotic behavior of each of the following in terms of , using . Give a brief justification for each answer. For items asking for the time needed to perform some operation or solve some problem, you should describe the worst case running time of the best possible algorithm. Average number of array lookups needed to find a given element in a sorted array of length . Number of two-element subsets of a set of size . Total number of nodes in a complete binary tree with leaves. A complete binary tree is one where every node has two children except for the leaves on the last level. For example, the complete binary tree shown below has leaves. Number of edges in a graph with nodes, where every node is connected to every other node. Number of different ways to arrange people in a line. Average number of steps needed to find a given element in a sorted linked list of length . Biggest integer that can be represented with bits. Worst-case number of swaps needed to sort an array of length if you are only allowed to swap adjacent elements. Worst-case number of steps needed to check whether two lists, each containing integers (not necessarily sorted), have any element in common. 2026911Hint is too slow! Number of array lookups performed by this Python code: Number of addition operations performed by this Java code: Total number of calls to println performed by this Java code: Total number of calls to print performed by this Python code: 0: foo(n-1) foo(n-1)]]> 2026 9 11 http://ozark.hendrix.edu/~yorgey/forest/00L7/ 00L7 /~yorgey/forest/00L7/ [O6] Dropping jars (3 pts) You’re doing some stress-testing on various models of glass jars to determine the height from which they can be dropped and still not break. The setup for this experiment, on a particular type of jar, is as follows. You have a ladder with rungs, and you want to find the highest rung from which you can drop a copy of the jar and not have it break. We call this the highest safe rung. It might be natural to try binary search: drop a jar from the middle rung, see if it breaks, and then recursively try from rung or depending on the outcome. But this has the drawback that you could break a lot of jars in finding the answer. If your primary goal were to conserve jars, on the other hand, you could try the following strategy. Start by dropping a jar from the first rung, then the second rung, and so forth, climbing one higher each time until the jar breaks. In this way, you only need a single jar—at the moment it breaks, you have the correct answer—but you may have to drop it times (rather than times as in the binary search solution). So here is the trade-off: it seems you can perform fewer drops if you’re willing to break more jars. To understand better how this trade-off works at a quantitative level, let’s consider how to run this experiment given a fixed “budget” of jars. In other words, you have to determine the correct answer—the highest safe rung—and can use at most jars in doing so. Suppose you are given a budget of jars. Describe a strategy for finding the highest safe rung that requires you to drop a jar at most times, for some function that grows slower than linearly. (In other words, should be , that is, .) Now suppose you have a budget of 2]]> jars, for some given . Describe a strategy for finding the highest safe rung using at most jars. If denotes the number of times you need to drop a jar according to your strategy, then the functions should have the property that each grows asymptotically slower than the previous one: for each . 2026 9 14 http://ozark.hendrix.edu/~yorgey/forest/00LW/ 00LW /~yorgey/forest/00LW/ Graph problems Problems related to graphs. 2026 9 14 http://ozark.hendrix.edu/~yorgey/forest/00LX/ 00LX /~yorgey/forest/00LX/ [G1] Adjacency matrices (1 pt) Given a simple graph with vertices numbered from to , an adjacency matrix for is an matrix where if and are adjacent, and otherwise. In other words, the entry at row and column tells us whether there is an edge between and , with for yes and for no. Make a drawing of the graph represented by the adjacency matrix Given a vertex and the adjacency matrix , how long does it take to list all the neighbors of : , or ? Why? A directed graph is a graph where each edge has a particular direction, that is, an edge is an ordered pair of vertices rather than just a set of two vertices. Typically such graphs are drawn with a little arrow on each edge showing which direction it goes. Explain how to generalize adjacency matrices to represent directed graphs. A weighted graph is a graph where each edge has an associated number, or weight, representing something like cost, time, or distance. Explain how to generalize adjacency matrices to represent weighted graphs. (Advanced, optional) Let be the adjacency matrix for a simple (undirected, unweighted) graph . What information does the matrix represent? What about ? In general, what about ? 2026 9 14 http://ozark.hendrix.edu/~yorgey/forest/00LY/ 00LY /~yorgey/forest/00LY/ [G2] Adjacency lists (1 pt) Given a simple graph , an adjacency list representation for consists of a map (aka dictionary) associating each vertex with the list (or set) of all its adjacent neighbors. In other words, using Java-like notation, Map<Vertex, List<Vertex> >. Make a drawing of the graph represented by the map Given a vertex and an adjacency list representation of a graph , how long does it take to list all the neighbors of : , or ? Why? Explain how to generalize adjacency lists to represent directed graphs. Explain how to generalize adjacency lists to represent weighted graphs. 2026 9 14 http://ozark.hendrix.edu/~yorgey/forest/00LZ/ 00LZ /~yorgey/forest/00LZ/ [G3] Connectivity from degree (2 pts) Let be an undirected graph with vertices, with no self-loops (that is, no edges of the form from a vertex to itself). Show that if every vertex has degree at least , the graph is connected. If it makes your proof easier, you may assume that is even. 2026914HintThink about cuts in the graph. A cut is a partition of the vertices into two sets and such that every vertex is in either or but not both. Is it possible to have a cut with no edges between and ? References Context Backlinks 2026 9 4 http://ozark.hendrix.edu/~yorgey/forest/2026-W35/ 2026-W35 /~yorgey/forest/2026-W35/ Weeknotes for 4 September 2026 (week 35) Missed last week's weeknotes since there is a whole lot going on at the start of the semester! 2026 9 4 Haskell Interlude I was on the Haskell Interlude podcast! I recorded the actual interview last spring, with Farhad Mehta and Sam Frohlich; the whole process was a lot of fun. I listened to the episode before it was released and I am not too embarrassed about anything I said, so give it a listen! 2026 9 4 Semester start Because of all administrative responsibilities, I had very little time to prepare for my actual classes, and the first few days of classes hit like a ton of bricks—I did not get very much sleep as I prepared syllabi and assignments at the very last minute. I do feel I'm in a better place now, though. Much of it was one-time overhead that need not be repeated. Getting to know my students has been fun. I am teaching one upper-level course (CSCI 382, Algorithms) in which I already knew most of the students; one introductory computing course (CSCI 150, Foundations of Computer Science); and one general education first-year seminar. For the most part, the students seem thoughtful and engaged. I am trying something a bit different with CSCI 382, Algorithms this semester (besides typing up my lecture notes in Forester). I used to assign weekly problem sets, consisting of a bunch of problems in a PDF that they would have one week to solve and submit. But scheduling the problem sets around exams and breaks, and making sure they contained appropriate material, was always tricky. They also didn't adapt well to students who were either very advanced or struggling. This semester, I am simply publishing a collection of problems, and the students are responsible for selecting which problems they want to solve. To help ensure they are making consistent progress, they still have weekly "problem sets" due, but the problem sets do not specify which problems they must solve, but only a required number of problems instead. This allows me to publish a wider variety of problems, as well as helping students who fall a bit behind continue to make consistent progress without penalizing them for being behind. We'll see how it goes! I am cautiously optimistic, though of course I'm sure there are things I will learn and change about the system next time. 2026 9 4 Missing ICFP ICFP was relatively close to me this year (Indianapolis would be about a 9 hour drive, or a short plane flight or two, away), but unfortunately, it happened during the first week of classes. Since I am the department chair and an advisor for first-year students, that sadly made ICFP a no-go. Spent the week watching the occasional livestream, reading friends post about ICFP on Mastodon, and just generally feeling like I was missing out. I am already plotting how I can make it to Nijmegen next year... 2026 9 4 Admin corner A bunch of my extra time is taken up right now with two major administrative tasks: completing a self-evaluation, and putting together a hiring request for next year. Both are due early next week. I will be very glad when they are both done! 2026 9 4 Swarm Only a tiny bit of incremental progress on the integrated help system this week; looking forward to having the above admin stuff done so I can get back to working on this more regularly! 2026 9 4 Piano corner I've continued to work on my Chopin waltz project. I'm also slowly adding repertoire to my forest. Brent A. Yorgey http://ozark.hendrix.edu/~yorgey/forest/00JF/ 00JF /~yorgey/forest/00JF/ Algorithms Fall 2026 lecture notes These are my lecture notes for CSCI 382, Algorithms for the Fall 2026 semester. Problems to be solved can be found here. http://ozark.hendrix.edu/~yorgey/forest/advanced/ advanced /~yorgey/forest/advanced/ Advanced/optional material Some sections of the notes may be marked with a star (★). This indicates optional, more advanced material which is included for the sake of those who are interested. Such material may or may not be presented in class and will not be formally assessed. 2026 8 6 http://ozark.hendrix.edu/~yorgey/forest/00JG/ 00JG /~yorgey/forest/00JG/ Introduction to POGIL/CSCI 382 We used an activity to introduce POGIL and the syllabus for CSCI 382. 2026 8 28 http://ozark.hendrix.edu/~yorgey/forest/00JT/ 00JT /~yorgey/forest/00JT/ Why POGIL? Via another activity, we learned about the two main aspects of POGIL: Guided Inquiry Learning: working in a team on an activity designed to guide you through a learning process. Process-Oriented: through the roles, the activities also help you develop process skills such as communication, critical thinking, information processing, and teamwork. 2026 8 26 http://ozark.hendrix.edu/~yorgey/forest/00JJ/ 00JJ /~yorgey/forest/00JJ/ Brute force algorithms Introduced via a POGIL activity. Some key takeaways: In this class we will consider solving problems with specified inputs and outputs. A brute-force algorithm is one that simply lists all possible outputs for the given inputs and checks which one has the desired properties. This semester we will consider a lot of clever ways to solve problems faster than brute force. But that's not always possible. 2026 8 31 http://ozark.hendrix.edu/~yorgey/forest/00JU/ 00JU /~yorgey/forest/00JU/ The Euclidean Algorithm The first algorithm we will consider is the famous Euclidean algorithm for finding the greatest common divisor of two integers. We name it after Euclid, who wrote it down in his classic work on geometry and number theory, The Elements; however, it has been reinvented in multiple times, places and cultures throughout history. 2026 8 31 http://ozark.hendrix.edu/~yorgey/forest/00JV/ 00JV /~yorgey/forest/00JV/ Review: mod and GCD The material in this section is presented via a POGIL activity. For a refresher on the operator, see these lecture notes from Discrete Math. For a refresher on GCD, see these lecture notes. 2026 9 2 http://ozark.hendrix.edu/~yorgey/forest/00K2/ 00K2 /~yorgey/forest/00K2/ The Euclidean Algorithm, recusively and iteratively The material in this section is also presented via a POGIL activity. We will consider two different implementations of the Euclidean Algorithm. 2026 9 2 http://ozark.hendrix.edu/~yorgey/forest/00K4/ 00K4 /~yorgey/forest/00K4/ Recursive Euclidean Algorithm The first implementation of the Euclidean Algorithm is recursive: GCDR($a$,$b$) = \\ \> \tb \> !if $b = 0$ \\ \> \> \tb \> !then \> $a$ \\ \> \> \> !else \> GCDR($b$, $a \bmod b$) \end {acode}]]> 2026 9 2 http://ozark.hendrix.edu/~yorgey/forest/00K5/ 00K5 /~yorgey/forest/00K5/ Iterative Euclidean Algorithm The second implementation of the Euclidean Algorithm is iterative: GCDI($m$,$n$) = \\ \> \tb \> $a \gets m$ \\ \> \> $b \gets n$ \\ \> \> !while $(a \neq 0)$ !and $(b \neq 0)$ \\ \> \> \tb \> !if $a \leq b$ \\ \> \> \> \tb \> !then \> $b \gets b \bmod a$ \\ \> \> \> \> !else \> $a \gets a \bmod b$ \\ \> \> !if $a = 0$ !then !return $b$ !else !return $a$ \end {acode}]]> By trying examples, it seems like both these algorithms produce correct results. But how can we be sure? This is an important question, because it's easy to write versions of these algorithms which look very similar, and even work some of the time, but which sometimes crash, loop forever, or return an incorrect result! 2026 9 2 http://ozark.hendrix.edu/~yorgey/forest/00K3/ 00K3 /~yorgey/forest/00K3/ Proving correct We will begin by formally proving the correctness of the recursive Euclidean Algorithm. But before we can even do that, we have to back up a bit: what does it even mean for an algorithm to be "correct"? 2026 9 2 http://ozark.hendrix.edu/~yorgey/forest/00K6/ 00K6 /~yorgey/forest/00K6/ Specification vs implementation Whenever we implement an algorithm, we have in mind a specification of what we would like the algorithm to achieve. This specification could be in the form of a mathematical definition (as in this case), or it could be a brute-force algorithm which "obviously" does what we want, or a table of inputs and outputs, or any other way of precisely defining a relationship between inputs and outputs. Our algorithm is then an implementation of this specification, and our job is to show that the specification and implementation match: that is, they produce identical outputs for all possible inputs. In this case, the specification we have in mind is the mathematical definition of ; the implementation we have in mind is the function. We are starting with because it's usually much easier to prove things about recursive algorithms than about iterative ones! In order to prove that is correct, we first need two small lemmas about the mathematical function. The proofs are included only for completeness—feel free to skip them unless you are interested. 2026 4 16 http://ozark.hendrix.edu/~yorgey/forest/00F3/ 00F3 /~yorgey/forest/00F3/ GCD is commutative Lemma . 2026416Proof Look at the definition of and note that is commutative. 2026 4 16 http://ozark.hendrix.edu/~yorgey/forest/00F8/ 00F8 /~yorgey/forest/00F8/ GCD reduction via mod Theorem For all , . 2026416Proof By the division algorithm write . Then { Division algorithm, substitute for } { GCD arguments can be subtracted from the other, applied times } { algebra } { Definition of } Now we can prove that matches its specification. 2026 9 3 http://ozark.hendrix.edu/~yorgey/forest/00K8/ 00K8 /~yorgey/forest/00K8/ is correct Theorem For all , . 202693Proof By (strong) induction on . In the base case, when , , which is indeed the definition of . Now suppose 0]]> and that for all , whenever . In this case . We know , so the induction hypothesis applies (note in particular that the induction hypothesis holds for any , and in particular we can pick as our “”). We concude that , where the last two steps follow from the fact that is commutative and the previous lemma. 2026 9 3 http://ozark.hendrix.edu/~yorgey/forest/00K9/ 00K9 /~yorgey/forest/00K9/ Proving correct Now let's prove that the iterative version of the Euclidean Algorithm is correct as well. 2026 9 3 http://ozark.hendrix.edu/~yorgey/forest/00KB/ 00KB /~yorgey/forest/00KB/ is correct Theorem . 202693Proof Suppose we initially call . Then we claim the following loop invariant: each time right before doing the loop check again, . That is, the of the current values of and is always equal to the of the original arguments to . We prove this by induction on the number of loop executions. In the base case, before the loop has executed at all, and are equal to the original arguments to , hence the invariant holds trivially. Otherwise, suppose the invariant held after loop iterations; we must show it will still hold after one more loop iteration. But this follows from the theorem GCD reduction via mod. Finally, after the loop ends, we will have either or , and we can see that we will return wichever one is nonzero. This correctly returns the of and since . But because of the loop invariant we know that , hence . It might seem like we are done, but actually we are not—we do not know that the loop will ever stop! All we have proved so far is that if it ever stops, it will deliver the correct value, but that is a big if. It's worth remarking that our proof of correctness for neatly sidestepped this issue because it was by induction on the size of the arguments to : the proof that the function returns the correct value, and the proof that the function always stops after a finite amount of time, were both wrapped up into a single argument. With , we must argue these two things separately. So, why does always stop? Each time through the loop, either gets smaller and stays the same, or gets smaller and stays the same: if the loop starts out with , then gets smaller, since . Otherwise gets smaller, since . Since neither ever gets bigger and one gets strictly smaller every loop iteration, one of them must eventually hit , which will stop the loop. 202693http://ozark.hendrix.edu/~yorgey/forest/00KC/00KC/~yorgey/forest/00KC/★ Pedantic comment about well-founded induction, for those who like that sort of thingRemarkTechnically, this argument that always stops is a proof by well-founded induction on pairs under the well-founded relation 2026 9 4 http://ozark.hendrix.edu/~yorgey/forest/00KF/ 00KF /~yorgey/forest/00KF/ Euclidean Algorithm problems Problems related to The Euclidean Algorithm, induction, and proving algorithm correctness. 2026 8 31 http://ozark.hendrix.edu/~yorgey/forest/00JW/ 00JW /~yorgey/forest/00JW/ [GCD1] GCD via factoring vs Euclidean algorithm (2 pts) In class we considered the problem of finding the greatest common divisor of two positive integers. We explored two ways to compute the GCD: Factor the two numbers into their unique prime factorizations, and find the biggest subset of primes contained in both; this is the factorization of the GCD. Run the Euclidean Algorithm. In this problem, you will consider the difference between these methods. Use your brain, a calculator, Wolfram Alpha, and/or some other appropriate computational system to factor into its prime factors. Now factor , and use the results to find by Method 1. Trace the execution of the Euclidean Algorithm on . Compare and contrast the two methods of computing the GCD of these two numbers. Now try to factor the number shown below, using whatever methods you like (for example, try using Wolfram Alpha). What happens? I would be willing to bet some money that you did not succeed in factoring —though not a large amount, since there do exist algorithms that can factor numbers of this size in a matter of hours or even minutes; but in any case factoring a number with, say, four times as many digits as this would require more like centuries. Factoring is widely believed to be a rather difficult computational problem (the security of your bank account probably depends on it!). Now, suppose I tell you that there are in fact three prime numbers , , and , such that (this is the same number from part (d)). Find , , and . What does this suggest about the relative efficiency of the two methods for computing the GCD? 2026 9 1 http://ozark.hendrix.edu/~yorgey/forest/00JY/ 00JY /~yorgey/forest/00JY/ [K4] Kattis: GCD (1 pt) Solve GCD. You may not use any built-in GCD function; you must implement the Euclidean Algorithm yourself. Tips on solving Kattis problems 2026 9 4 http://ozark.hendrix.edu/~yorgey/forest/00KE/ 00KE /~yorgey/forest/00KE/ Runtime analysis of the Euclidean Algorithm In [GCD1] GCD via factoring vs Euclidean algorithm (2 pts), you learned that the Euclidean Algorithm seems much more efficient than factoring; but how efficient is it, exactly? The problems in this section will walk you through a classic analysis of how long the Euclidean Algorithm takes to run on given inputs. However, the problems are independent; it is possible to do each problem without having done the previous ones. Throughout this section, when referring to the Euclidean Algorithm, we will specifically work with the recursive implementation (GCDRecA from the POGIL activity). 2026 9 1 http://ozark.hendrix.edu/~yorgey/forest/00JZ/ 00JZ /~yorgey/forest/00JZ/ [GCD2] GCD of consecutive Fibonacci numbers (2 pts) Recall the Fibonacci numbers, defined by , , and . That is, the first two Fibonacci numbers are , and then each subsequent Fibonacci number is the sum of the previous two, so the first few are Compute and , and trace the execution of the Euclidean Algorithm to compute . What happens? Prove by induction on that for all . Explain why your proof also shows that the Euclidean Algorithm requires recursive steps to compute . 2026 9 1 http://ozark.hendrix.edu/~yorgey/forest/00K0/ 00K0 /~yorgey/forest/00K0/ [GCD3] Worst-case GCD input (3 pts) In fact, more is true: consecutive Fibonacci numbers are in some sense a worst-case input for the Euclidean Algorithm: they are the smallest numbers for which the Euclidean Algorithm needs steps. Let be the following proposition: For all natural numbers and , if b]]> and makes recursive calls, then and . That is, if represents the proposition " makes recursive calls", then b) \land R(a,b,n)) \to ((a \geq F_{n+1}) \land (b \geq F_n))]]>. Prove by induction on : What does the base case say? Prove it. 202691HintLook at the code for . What can you conclude about and if it makes zero recursive calls? Let be an arbitrary natural number, and prove by supposing to be true and proving . You may want to write out and in full to help you keep track of what you know and what you are trying to prove. 202691HintShow that . Explain why the previous result shows that if then the Euclidean Algorithm requires at most steps. 2026 9 1 http://ozark.hendrix.edu/~yorgey/forest/00K1/ 00K1 /~yorgey/forest/00K1/ [GCD4] Fibonacci number size (3 pts) How big are Fibonacci numbers? Let’s find out: Solve for and call the positive solution (this is often known as the golden ratio) and the negative solution . Explain why we know that and . 202691HintYour answer should be one sentence! Show that for all (by starting with and multiplying both sides by ). Note that the same is also true with in place of . Now prove by induction on that . 202691HintDon’t forget that you need two base cases; you will want to show that . Conclude that . 202691HintWhat can you say about as gets large? 2026 9 4 http://ozark.hendrix.edu/~yorgey/forest/00KD/ 00KD /~yorgey/forest/00KD/ [GCD5] Time complexity of the Euclidean Algorithm (logarithm review) (2 pts) Suppose we want to run the Euclidean Algorithm to compute , assuming b]]>. Let be the smallest Fibonacci number which is greater than or equal to . Then we know from the previous problem that the Euclidean Algorithm takes at most steps to run, with the worst case being when . We want to figure out how relates to . Starting from (since this is the worst case), and using the result from the previous problem, namely, that , solve (approximately) for in terms of . Your final answer should be of the form for suitable constants and ; you should give and in approximate, decimal form. Conclude that the Euclidean Algorithm requires, in the worst case, a number of steps proportional to the number of digits in the base-ten representation of . 2026 9 4 http://ozark.hendrix.edu/~yorgey/forest/00KG/ 00KG /~yorgey/forest/00KG/ [I2] Exponentiation (3 pts) Write a recursive algorithm which, given a real number and a natural number , computes the power . Prove that your algorithm is correct. You may express your algorithm using appropriate pseudocode, or you may implement it in a real programming language; either one is fine. You may use addition, subtraction, multiplication, and division, but you may not use any kind of built-in exponentiation operation. 2026 9 8 http://ozark.hendrix.edu/~yorgey/forest/00KI/ 00KI /~yorgey/forest/00KI/ [I3] The Jellybean Game (3 pts) The jellybean game is a game for two players. There is a row of jars, numbered to from left to right, each of which starts out containing some number of jellybeans (possibly zero). We assume that these are magical jars which can hold an unlimited number of jellybeans, so we don’t have to worry about the jars getting too full. (Note, however, that the jars cannot hold infinitely many beans—each jar must always have some finite number of jellybeans in it, but that number can be as big as we want.) We also assume that there is an unlimited supply of extra jellybeans (such as a jellybean factory or a magical jellybean-pooping unicorn). The players alternate turns. On a player’s turn, she must: Pick a nonempty jar, call it jar . Remove one jellybean from jar . Add as many jellybeans as she wants (possibly zero) to each of the jars to the left of her chosen jar. For example, suppose there are five jars which currently hold One possible valid turn is to pick jar 4 and remove one jellybean from it, then add 6, 29, and one billion jellybeans to jars , , and respectively, resulting in The winner is the player who removes the last jellybean. Put another way, the loser is the first player who is unable to move because all the jars are empty. Prove that the jellybean game always ends eventually. That is, even if the players conspire to try to make the game last forever, they cannot, as long as they follow the rules. (Of course, they certainly can make the game take a very, very long time...) Describe a winning strategy for the jellybean game. From which positions is the first player guaranteed to win, as long as they play perfectly? What strategy should the first player follow in order to guarantee a win, if a win is possible? 2026 9 3 http://ozark.hendrix.edu/~yorgey/forest/00K7/ 00K7 /~yorgey/forest/00K7/ Asymptotic Analysis The basic concepts of asymptotic analysis are introduced in a POGIL activity. 2026 9 9 http://ozark.hendrix.edu/~yorgey/forest/00KN/ 00KN /~yorgey/forest/00KN/ Why asymptotic analysis? Why should we examine problems analytically at all? For example, why not just run programs and use a stopwatch to compare them? Actually running programs might take too long! The analysis lets us analyze problems for all input sizes at once, rather than having to gather data points. The analysis is independent of the algorithm implementation, the language in which the program is implemented, and the architecture in which the program is run. We insulate ourselves to all these variables. Theoretically efficient almost always implies practical efficiency. 2026 9 9 http://ozark.hendrix.edu/~yorgey/forest/00KR/ 00KR /~yorgey/forest/00KR/ Intuition and motivation for big-O From now on, we’ll assume that , , and that represents a generic function representing, say, the amount of time an algorithm takes to run on an input of size . Recall that big-O is “like ”, big-Omega is “like ”, and big-Theta is “like ”. However, if we were to define, say, big-O as “ is if ”, that would be too restrictive for us. For one thing, we don’t want it to matter what computer we run things on. What if it takes , or ? Those are not actually , but we want them to be considered “the same as” . Also, we don’t really care what happens for small values of (after all, for small values we could just run the algorithm ourselves, by hand), so it’s not necessary that (or some multiple) for all values of , only that it be so eventually. These considerations lead to the following formal definition. 2026 9 9 http://ozark.hendrix.edu/~yorgey/forest/00KO/ 00KO /~yorgey/forest/00KO/ Big-O Definition is iff there exists a real constant 0]]> and a natural number such that for all , 2026 9 9 http://ozark.hendrix.edu/~yorgey/forest/00KP/ 00KP /~yorgey/forest/00KP/ Big-Omega Definition The definition of big-Omega is identical, except that we use in place of : is iff there exists a real constant 0]]> and a natural number such that for all , 2026 9 9 http://ozark.hendrix.edu/~yorgey/forest/00KQ/ 00KQ /~yorgey/forest/00KQ/ Big-Theta Definition is iff is both and . 2026 9 9 http://ozark.hendrix.edu/~yorgey/forest/00KS/ 00KS /~yorgey/forest/00KS/ Remark Note this is not the same as replacing the in the definition of big-O with an sign! In that case, would have to be exactly equal to some constant multiple of , which would be much too restrictive. In the actual definition, must merely fall in between two different constant multiples of . 2026 9 9 http://ozark.hendrix.edu/~yorgey/forest/00KX/ 00KX /~yorgey/forest/00KX/ Little-o Definition is iff is but not . 2026 9 9 http://ozark.hendrix.edu/~yorgey/forest/00KY/ 00KY /~yorgey/forest/00KY/ Remark In other words, intuitively, is if it grows strictly more slowly than . For example, is . 2026 9 9 http://ozark.hendrix.edu/~yorgey/forest/00KT/ 00KT /~yorgey/forest/00KT/ Example Consider . To show that this is according to the definition, we can reason as follows: So we can choose and , which satisfies the definition, so is . (In fact we could also pick along with a bigger .) 2026 9 9 http://ozark.hendrix.edu/~yorgey/forest/00KU/ 00KU /~yorgey/forest/00KU/ Big-O in the real world Remark A lot of the time people use big- when what they really mean is . In this class we will be very careful to use them properly. It’s useful to have all of them at our disposal. For some problems we know exactly how fast they can be solved, so we use . For some problems we know some and some but they are not the same. For example, matrix multiplication: we know it must take time, and there are algorithms that show it is , but no one knows what the theoretical limit is (we will look at matrix multiplication later in the semester). 2026 9 9 http://ozark.hendrix.edu/~yorgey/forest/00KV/ 00KV /~yorgey/forest/00KV/ Limit theorems It is usually really annoying to use these definitions directly. Instead we can often compare rates of growth using limits. Note in the below that is used as a shorthand to mean "the limit exists and does not diverge to ", and is used as a shorthand to mean "the limit diverges to ". 2026 9 9 http://ozark.hendrix.edu/~yorgey/forest/00KW/ 00KW /~yorgey/forest/00KW/ Asymptotic bounds via limits Theorem If then is . If then is . If then is . If then is . 2026 9 9 http://ozark.hendrix.edu/~yorgey/forest/00KZ/ 00KZ /~yorgey/forest/00KZ/ Remark Note that the converse is not true, since, for example, might be even if the limit does not exist. As a counterexample, let when is even, and when is odd. Then is but does not exist. But typically this won’t be an issue with the functions we will see in this class! 2026 9 9 http://ozark.hendrix.edu/~yorgey/forest/00L0/ 00L0 /~yorgey/forest/00L0/ Arithmetic with big-O The following properties hold for and as well. when is a constant, i.e. does not depend on (running algorithms in sequence) (running nested algorithms) For example, . 2026 9 10 http://ozark.hendrix.edu/~yorgey/forest/00L1/ 00L1 /~yorgey/forest/00L1/ Time Complexity Zoo We now present a “complexity zoo”, with examples of things having each common asymptotic time complexity, with some relevant facts interspersed. Our zoo will be ordered from smallest to biggest; that is, each entry will be little-o of the next thing. For each , we will also record the largest such that we can process an input of size using a -time algorithm in approximately 1 second, assuming we can do operations per second. 2026 9 10 http://ozark.hendrix.edu/~yorgey/forest/00L2/ 00L2 /~yorgey/forest/00L2/ : constant (any input) A or constant time algorithm is one whose running time does not depend on the size of its input. If we have an algorithm that takes , we can obviously process arbitrary-sized inputs in less than one second. Examples of operations include: Access an arbitrary index in an array Push to or pop from the top of a stack Add to or remove from the end of an extensible list (e.g. ArrayList in Java; Python lists) Insert, update, or remove from a hash table (e.g. set + dictionaries in Python; HashSet/HashMap in Java) Add to or remove from either end of a deque (double-ended queue) Arithmetic (usually! sort of!) 2026 9 10 http://ozark.hendrix.edu/~yorgey/forest/00L3/ 00L3 /~yorgey/forest/00L3/ : logarithmic (unimaginably large inputs) We say something is logarithmic if it is proportional to for inputs of size . 2026 9 10 http://ozark.hendrix.edu/~yorgey/forest/00L4/ 00L4 /~yorgey/forest/00L4/ Notation We will use as an abbreviation for . Two is by far the most common and useful base for logarithms when talking about computers. If we have an algorithm that takes time, we could use it to process inputs of size in one second, which is unimaginably large. Examples of things that are : Binary search The height of a balanced binary tree with nodes The number of bits needed to represent 2026 9 11 http://ozark.hendrix.edu/~yorgey/forest/00L9/ 00L9 /~yorgey/forest/00L9/ Logarithm base doesn't matter to Theorem for all positive real numbers and . In other words, up to , the base of a logarithm doesn't matter; , , , etc. are all the same. 2026911ProofHomework. 2026 9 11 http://ozark.hendrix.edu/~yorgey/forest/00L8/ 00L8 /~yorgey/forest/00L8/ Logarithms grow more slowly than any power Theorem is for all 0]]> and any 1]]>. 2026911ProofHomework. 2026 9 11 http://ozark.hendrix.edu/~yorgey/forest/00LA/ 00LA /~yorgey/forest/00LA/ is much closer to 1 than Remark This is somewhat surprising! is actually smaller than to any positive power: even or whatever. is not “halfway between” and ; in some sense it is much closer to . For example, the biggest number that fits in a 64-bit integer is about . How long would it take to count that high? At per second, it would take seconds or about 3000 years. But if we can process it using something that repeatedly halves, . 2026 9 11 http://ozark.hendrix.edu/~yorgey/forest/00LB/ 00LB /~yorgey/forest/00LB/ (inputs up to ) This will not come up much in this course, but it is definitely a thing. See “square root decomposition”. 2026 9 11 http://ozark.hendrix.edu/~yorgey/forest/00LC/ 00LC /~yorgey/forest/00LC/ : linear (inputs up to million) Examples of things that are : Linear search Maximum/minimum/sum of a list Merge two sorted lists Insert or removing at the beginning of an array/list. 2026 9 11 http://ozark.hendrix.edu/~yorgey/forest/00LD/ 00LD /~yorgey/forest/00LD/ (inputs up to million) Examples of things that are : Mergesort, quicksort In general, divide & conquer algorithms with work at each level. We’ll study this in more detail later in the semester. If you are only allowed to compare pairs of elements to see which is greater, sorting a list of elements takes . In other words, it's impossible to sort any faster than if you are only allowed to compare elements. (If you are allowed extra operations, sorting faster than is possible; for example, a list of integers can be sorted in time.) 2026 9 11 http://ozark.hendrix.edu/~yorgey/forest/00LE/ 00LE /~yorgey/forest/00LE/ : quadratic (inputs up to 10 thousand) Examples of things that are : Two nested loops (often, but not necessarily) The number of pairs of items chosen out of , . Repeatedly appending characters to a string one by one Insertion sort, bubble sort 2026 9 11 http://ozark.hendrix.edu/~yorgey/forest/00LF/ 00LF /~yorgey/forest/00LF/ (inputs up to ) Things that take in general: nested loops. The number of subsets of size out of things, i.e. (assuming is much bigger than ). 2026 9 11 http://ozark.hendrix.edu/~yorgey/forest/00LG/ 00LG /~yorgey/forest/00LG/ Theorem Each is for . 2026911ProofHomework. 2026 9 11 http://ozark.hendrix.edu/~yorgey/forest/00LH/ 00LH /~yorgey/forest/00LH/ : exponential (up to ) Examples of things that are : Number of subsets of things Number of bitstrings of length Number of nodes (also number of leaves) in a tree of height , so it is 2026 9 11 http://ozark.hendrix.edu/~yorgey/forest/00LI/ 00LI /~yorgey/forest/00LI/ Theorem is for all integers and real numbers 1]]>. 2026911ProofHomework. 2026 9 11 http://ozark.hendrix.edu/~yorgey/forest/00LJ/ 00LJ /~yorgey/forest/00LJ/ Polynomial vs exponential Remark There is an insurmountable gulf between polynomial and exponential time. For example, even is ! We usually take this to be the dividing line between “efficient/feasible” and “inefficient/infeasible”. (Of course is probably not actually feasible but in practice we don’t see that.) 2026 9 11 http://ozark.hendrix.edu/~yorgey/forest/00LK/ 00LK /~yorgey/forest/00LK/ : factorial (inputs up to ) corresponds to the numbre of distinct orderings of things. If an algorithm takes it is really, really bad. In fact, is for all . 2026 9 13 http://ozark.hendrix.edu/~yorgey/forest/00LL/ 00LL /~yorgey/forest/00LL/ Graphs In this next unit, we will learn about (or review) graphs and several fundamental graph algorithms. 2026 9 13 http://ozark.hendrix.edu/~yorgey/forest/00LM/ 00LM /~yorgey/forest/00LM/ Graph definitions and terminology The material in this section is introduced via POGIL activity; see the activity for illustrations and examples. 2026 9 13 http://ozark.hendrix.edu/~yorgey/forest/00LN/ 00LN /~yorgey/forest/00LN/ (Simple) graph Definition A (simple) graph is a set of vertices (singular vertex) together with a set of edges, where each edge consists of a set of two vertices. 2026 9 13 http://ozark.hendrix.edu/~yorgey/forest/00LO/ 00LO /~yorgey/forest/00LO/ Graphs and graph drawings Remark We often draw graphs with a dot for each vertex, and edges represented by (straight or curved) lines drawn between vertices. Note that the same graph can have many different drawings; the important thing about a graph is which vertices are connected by edges, not the specific way it is drawn. 2026 9 13 http://ozark.hendrix.edu/~yorgey/forest/00LP/ 00LP /~yorgey/forest/00LP/ Adjacent vertices Definition Vertices are adjacent (or neighbors) if they share an edge. 2026 9 13 http://ozark.hendrix.edu/~yorgey/forest/00LQ/ 00LQ /~yorgey/forest/00LQ/ Degree Definition The degree of a vertex is the number of other vertices which are adjacent to it. 2026 9 13 http://ozark.hendrix.edu/~yorgey/forest/00LR/ 00LR /~yorgey/forest/00LR/ Leaf Definition A leaf is a vertex with degree . 2026 9 13 http://ozark.hendrix.edu/~yorgey/forest/00LS/ 00LS /~yorgey/forest/00LS/ Path Definition A path is a sequence of one or more vertices such that each consecutive pair of vertices is adjacent. 2026 9 13 http://ozark.hendrix.edu/~yorgey/forest/00LT/ 00LT /~yorgey/forest/00LT/ Connected Definition Two vertices are connected if there is a path with the two vertices as endpoints. A connected graph is one where every pair of vertices are connected. A connected component is a maximal subset of connected vertices. 2026 9 13 http://ozark.hendrix.edu/~yorgey/forest/00LU/ 00LU /~yorgey/forest/00LU/ Cycle Definition A cycle is a path which starts and ends at the same vertex and does not repeat any edges. A cyclic graph is a graph containing at least one cycle. An acyclic graph is a graph with no cycles. 2026 9 13 http://ozark.hendrix.edu/~yorgey/forest/00LV/ 00LV /~yorgey/forest/00LV/ Tree Definition A tree is an acyclic, connected graph. http://ozark.hendrix.edu/~yorgey/forest/00JE/ 00JE /~yorgey/forest/00JE/ CSCI 382, Algorithms I teach CSCI 382, Algorithms, at Hendrix College. Course syllabus Algorithms Fall 2026 lecture notes Algorithms problems Related Contributions