CMSC 351 Final Exam (Justin)

Counting Sort Process

1. Finds the maximum value (k) in the original list (A). Then makes a list of length k called LOC filled with 0s. 2. Counts the number of elements corresponding to a value in A and adds 1 to LOC[A[i]]. 3. Makes LOC cumulative by adding LOC[i] to LOC[i+1]. 4. Finally, initializes a new list (ANEW) with the same length as A 5. iterates through A backward, and using a particular value A[i], it moves A[i] to ANEW[i] at the position LOC[A[i]], decrementing LOC[A[i]] as it goes. 6. Eventually, ANEW will be a sorted version of A.

Shortest Path Algorithm Process

1. Label each node as having a distance of ∞ 2. Start at beginning node and branch out from its connections 3. Add these nodes to the queue and pop them once we visit them (not reach but visit). Also keep track of predecessors in a data structure. 4. for each ∞ node connected to the current node, assign its distance as its predecessor's distance + 1. 5. repeat until a target is reached 6. trace steps backward from target to start to get path

Median Of Medians (MOM) Process

1. Separates a list into groups of 5 (could have some left over in a group <5) 2. Sort the sublists, then sort the groups by using the median value (located at index 2 if a group of 5, otherwise the index is at the floor of the length). 3. The median of those medians (the middle value between all columns) is the median of medians. NOTE: it may not always be the REAL median but it is close enough to optimize partitioning algorithms Odds are the MOM is located in the middle 40% of the original list.

Djikstra's Algorithm Process

1. Start at beginning node and branch out from its connections 2. Add these nodes to the queue and pop them once we visit them (not reach but visit). 3. Also keep track of predecessors in a data structure. Predecessors get updated based on weights 4. for each node connected to the current node, assign its weight as the weight from the predecessor plus its own. 5. weights are determined cumulatively 6. do this through the entire graph 7. trace steps backward from target to start to get path

Witness

A case where the decision problem is solved

Verifier

A function that determines aspects of a DP given a witness

Decision Problem (DP)

A question with a yes or no answer (e.g. Is there a subset in this list where the sum of the elements equals 0?)

Big O Notation Formal defintion

Big O

Kth Order Statistics

Find the kth value in a list. Typically used to find the median.

Verifier Cases

Given that v is the verifier function, I is the decision problem, and X is a potential witness: 1. if v(I, X) = YES, there exists a valid witness (does not mean X is it) 2. if v(I, X) = NO, then X is not a valid witness THESE CASES ARE NOT MUTUALLY EXCLUSIVE

Schoolbook Multiplication

How people write out multiplication IRL. Using this method in code is in Θ(n^2) time.

Radix Sort Process

Iterates through each digit in reverse order in a list of numbers and uses another algorithm to sort the digits.

Karatsuba's Algorithm

Likely will be using a tree on the exam. Here is the process: Counts the number of single digit multiplications (SDMs) to multiply two numbers. 1. Does this by using a recursive algorithm that splits the numbers into 3 separate parts. 2. Left "halves", summed "halves", and right "halves". 3. The "halves" are partitioned via spacing which is calculated as follows: floor(min(len(a), len(b))/2) FROM THE RIGHT.

Counting Sort In-Place

No, not in-place

Kruskal's Algorithm Time Complexity

O(Elg(V)) or O(E*α(V)) (Second one uses an advanced data structure)

Prim's Algorithm Process

Picks a START vertex and traverses through the graph based on smaller connections first. Once all nodes are included minimum spanning tree is created.

Polynomial Reduction

The idea where a problem that is hard to solve is broken down as another related problem which is easier to be solved. In computer science, this is where a DP is reduced to another via a function conversion: A <=p B via f(x), where f(A) = B due to polynomial reduction. f(x) will use what Justin refers to as an ORACLE function. This basically abstracts how we reduce A into B.

P

The set of all decision problems that are solved in polynomial time

NP

The set of all decision problems where we do not know if they can be solved in polynomial time

Median Of Medians (MOM) Idea

To get close enough to the median for partitioning processes such as quicksort. This is so it can make the process more efficient time wise. An ideal partitioning for algorithms such as quicksort is using the median as a pivot.

Depth First Traversal Process

Traverses to deeper nodes first. Visits all the way down a branch then recursively pops up in a tree. Uses a stack to keep track of nodes.

Kruskal's Algorithm Process

Until a minimum spanning tree is formed do the following: Pick minimum-cost edges in order and add them to MST unless adding them creates a cycle. Eventually a MST will form.

Breadth First Traversal Process

Visits closer nodes first. Done in a tree level by level. Uses a queue to keep track of nodes

Counting Sort Stability

Yes, it is stable

Weak Induction (give proccess)

start with

Breadth First Traversal Time Complexity

Θ(V+E)

Depth First Traversal Time Complexity

Θ(V+E)

Shortest Path Algorithm Time Complexity

Θ(V+E); V = # of vertices/nodes, E = # of edges

Prim's Algorithm Time Complexity

Θ(VE)

Djikstra's Algorithm Time Complexity

Θ(V^2+E); V^2 = all nodes reached then visited, E = # of edges

Radix Sort Time Complexity

Θ(df(n)); d = # of digits, f(n) = other algorithm's time

Counting Sort Auxiliary Space

Θ(n + k); n for new final list, k for LOC

Counting Sort Time Complexity

Θ(n+k); n = size of original list, k = size of LOC list