Algorithmic Design

Number of steps taken / size of input

Simple operations are 'regular work days' and get an income of some constant amount. They pay their cost with this income and put the rest in 'savings'. Expensive operations are 'vacation days', and can use savings to pay their cost. As long as savings never goes below 0 (which you can prove by induction), we can prove a time complexity.

Problems where there is a set of configurations and an objective function, and the goal is to find a configuration that maximizes (or minimizes) the value of the objective function. eg knapsack

A problem has it if an optimal solution can be constructed from optimal solutions of its subproblems.

Two subproblems that don't share resources, or the solution of one doesn't affect the solution of the other

Optimal substructure, independent subproblems, non-overlapping subproblems

Two subproblems are overlapping if they are really the same subproblem that occurs as a subproblem of different problems

No code word is a prefix of any other code word

1) Build a frequency table

2) Sort characters from lowest to highest frequency

3) Pull the two lowest-valued nodes/trees from the list

4) Create a new tree with the lowest-valued node as its left subtree and the highest-value node as its right subtree

5) Put this subtree back into the list with its value being the aggregate value of all its trees/nodes

6) Sort the list again

7) Repeat until there is only 1 tree, which is the final answer

1) DIVIDE the problem into subproblems

2) Recursively solve the subproblems (CONQUER)

3) Put the solutions together to create a solution to the big problem

Divide and conquer

Iterative substitution, recursion trees, master theorem

Start with the base case, build up to more complex cases

Greedy algorithms

(amodc×bmodc)modc

(x + y) mod n = 0

(x * x^-1)mod n = 1

A number is relatively prime (or coprime) to another if their greatest common divisor is 1

The number of non-negative integers less than n that are relatively prime to n

(p-1)(q-1)

O(2^n)

directed graph. G = (V,E)

A graph with the same nodes (vertices), but whenever there is an indirect path from u to v, it includes u,v as an edge

1) Populate G* (the transitive closure graph) with the same nodes and vertices as G

2) Go through all the edges and whenever there is a pair (vi, vj) and (vj, vk), add (vi,vk).

3) Repeat until there are no more transitive edges

for any given vertex if you follow an edge that connects that vertex to another, there is no path in the graph to get back to that initial vertex

1) all vertices must be included 2)The mst must be acyclic

Given a cycle, the MST for that cycle can be obtained by removing the highest-weighted edge

Yes

• Consider a partition of the vertices of G intosubsets U and V• Let e be an edge of minimum weight across thepartition• There is a minimum spanning tree of G containingedge e

• Sort the edges, lightest to heaviest• Divide all the vertices into clusters, one vertex per cluster• Start with the lightest edge, e• If e connects two clusters• Add e to the MST• Create a new cluster by merging those clusters• Else• Discard e• Keep going until there is only one cluster

no

Source (s) and sink (t)

The amount of flow over edge e

the set of incoming edges for vertex v

the set of outgoing edges for vertex v

An edge always has at least 0 flow, and never has more flow than its capacity

The flow entering a vertex must equal the flow going out (except for s and t)

the sum of the outgoing flows from the source, or the incoming flows to the sink

No

V_s, V_t

No

the flows across the forward edges minus the sum of the flows across the backwards edges

the capacities of all the forward edges

true

no matter how one cuts the network, the value of the capacityat that cut is an upper bound for the flow of the network as a whole

Yes

true

If e is a forward edge, the residual capacity of e is the amount of capacity that fhas not consumed yet

1) f(e) < c(e) if e is a forward edge (non full and forward)2) f(e) > 0 if e is a backward edge (non empty and backward)

a set of edges that have no endpoints in common

n-1

a = number of pieces the problem gets divided in with each call. For mergesort A = 2

b = denominator of fraction of input size that each piece takes (usually the same of a, but can be different). For mergesort b = 2

theta (n^c) is how complex it is to put the pieces back together when you finish, so c=1 for merge sort

n-a

(a * b) mod n = 1

yes or no

language

solved, checked

certificate

there is no certificate which will satisfy B, i.e. B will output 0 on input (x,y) for any y

some y (of size bounded by a polynomial q(n)) such that B will output 1 on input (x,y)

deterministic polynomial-time, sound, complete

No

every problem in NP can be reduced to it

it is NP-hard and an element of NP

connected to every other node; there is an edge between every two nodes.

1. Construct a minimal spanning tree M from G2. Construct an Euler-tree traversal E of M •E starts and ends at the same vertex and traverses each edge of M exactly once in each direction 3. Construct a tour T from E by marching through the edges of E, but each time we have (u, v) and (v, w) in E, such that v has already been visited, we replace those two edges with (u, w)

Cost of the solution is at most twice of the optimal one

there is a vertex between them

there is an edge between them

1) Initialize the result as {}2) Consider the set of all edges in G. Let the set be E.3) Do following while E is not emptya) Pick an arbitrary edge (u, v) from set E and add 'u' and 'v' to resultb) Remove all edges from E which are either incident on u or v4) Return result

Given a graph, find a minimal subset v of vertices such that every edge in the original graph is incident to some vertex in v

it is an endpoint to that vertex.

satisfiability (relating to logical formulas)

a candidate solution is worse than a solution one already has(There is no need to continue working on a candidate solution that is guaranteed to be worse than a solution you already have)

• Informally:• Given an array arr of length n• Start at the last element in the array (arr[n-1])• Roll a random number r in [0, ..., n-1]• Swap the last element with the element in arr[r]• Do this for the next-to-last element and a random number in [0, ..., n-2]• Keep doing this for all elements except arr[0]• You can do arr[0], too, it won’t hurt anything• All the elements are now in random spots