formatting fixes

Author: localhost433

notes/courses/CSCI-UA-310/08-09-hashing.md

@@ -134,12 +134,15 @@ HASH-SEARCH(T, k)
 ### Probing Strategies
 
 **Linear Probing**: $h(k, i) = (h'(k) + i) \bmod m$.
+
 * Simple but causes **primary clustering**: long runs of occupied slots form and grow.
 
 **Quadratic Probing**: $h(k, i) = (h'(k) + c_1 i + c_2 i^2) \bmod m$.
+
 * Reduces primary clustering but causes **secondary clustering**: two keys with the same $h'(k)$ have identical probe sequences.
 
 **Double Hashing**: $h(k, i) = (h_1(k) + i \cdot h_2(k)) \bmod m$.
+
 * Uses two independent hash functions.
 * Gives $\Theta(m^2)$ distinct probe sequences; approximates uniform hashing well.
 * Requirement: $h_2(k)$ must be coprime to $m$ for all $k$ (e.g., choose $m$ prime).

notes/courses/CSCI-UA-310/11-red-black-trees.md

@@ -137,12 +137,12 @@ The key insight is that a "double-black" violation is introduced when a black no
 
 ## Summary
 
-| Operation | Time |
-|---|---|
-| SEARCH | $O(\log n)$ |
-| INSERT | $O(\log n)$ |
-| DELETE | $O(\log n)$ |
-| MINIMUM/MAXIMUM | $O(\log n)$ |
+| Operation             | Time        |
+|-----------------------|-------------|
+| SEARCH                | $O(\log n)$ |
+| INSERT                | $O(\log n)$ |
+| DELETE                | $O(\log n)$ |
+| MINIMUM/MAXIMUM       | $O(\log n)$ |
 | SUCCESSOR/PREDECESSOR | $O(\log n)$ |
 
 ---

notes/courses/CSCI-UA-310/12-13-14-dynamic-programming.md

@@ -26,6 +26,7 @@ date: 2026-03-02/04/09
 **Dynamic programming** solves each subproblem exactly once and stores the result in a table.
 
 **Two key properties for DP to apply**:
+
 1. **Optimal substructure**: An optimal solution to the problem contains optimal solutions to subproblems.
 2. **Overlapping subproblems**: The recursive solution revisits the same subproblems repeatedly.
 
@@ -206,6 +207,7 @@ The **0/1** constraint means each item is either taken or not (no fractions).
 ### Optimal Substructure
 
 For item $n$:
+
 * **Skip item $n$**: optimal value from items $\{1,\dots,n-1\}$ with capacity $W$.
 * **Take item $n$** (if $w_n \leq W$): $v_n$ plus optimal value from items $\{1,\dots,n-1\}$ with capacity $W - w_n$.
 
@@ -279,6 +281,7 @@ FIBONACCI-DP(n)
 **Key fact**: Multiplying a $p \times q$ matrix by a $q \times r$ matrix costs $p \cdot q \cdot r$ scalar multiplications.
 
 **Example**: For $A_1 (30 \times 35)$, $A_2 (35 \times 15)$, $A_3 (15 \times 5)$, $A_4 (5 \times 10)$:
+
 * $((A_1 A_2) A_3) A_4$: $30 \cdot 35 \cdot 15 + 30 \cdot 15 \cdot 5 + 30 \cdot 5 \cdot 10 = 18{,}000$ multiplications.
 * $(A_1 (A_2 (A_3 A_4)))$: $15 \cdot 5 \cdot 10 + 35 \cdot 15 \cdot 10 + 30 \cdot 35 \cdot 10 = 16{,}250$ multiplications.
 
@@ -354,6 +357,7 @@ SUBSET-SUM(a[1..n], W)
 **Running time**: $O(nW)$ — pseudopolynomial (Subset Sum is NP-complete).
 
 **Worked Example**: $S = \{3, 5, 1\}$, $W = 9$.
+
 * Subset $\{3, 5, 1\}$: sum $= 9$. Answer: **yes**.
 
 ---

notes/courses/CSCI-UA-310/15-16-greedy.md

@@ -65,6 +65,7 @@ GREEDY-ACTIVITY-SELECTOR(s, f)
 Let $A = \{a_1, a_2, \dots, a_k\}$ (greedy solution, sorted by finish time) and $O = \{o_1, o_2, \dots, o_m\}$ (any optimal solution, sorted by finish time). We show $|A| = |O|$, i.e., $k = m$.
 
 **Key Lemma**: For each $i = 1, \dots, k$: $f(a_i) \leq f(o_i)$.
+
 * Base: Greedy picks the activity with the smallest finish time overall, so $f(a_1) \leq f(o_1)$.
 * Inductive step: Since $f(a_i) \leq f(o_i) \leq s(o_{i+1})$, activity $o_{i+1}$ is also compatible with $a_i$. The greedy algorithm could have picked something with finish time $\leq f(o_{i+1})$, so $f(a_{i+1}) \leq f(o_{i+1})$.
 
@@ -149,6 +150,7 @@ Sort jobs by start time. Maintain a set of machines. For each job, assign it to
 **Input**: An alphabet $C = \{c_1, \dots, c_n\}$ where character $c_i$ has frequency $f_i$.
 
 **Goal**: Assign a binary codeword to each character such that:
+
 * The code is **prefix-free** (no codeword is a prefix of another).
 * The **total encoding length** $\sum_{c \in C} f_c \cdot d_T(c)$ is minimized, where $d_T(c)$ is the depth of $c$ in the code tree $T$.
 
@@ -185,6 +187,7 @@ HUFFMAN(C)
 Frequencies: $a:45, b:13, c:12, d:16, e:9, f:5$.
 
 Step-by-step merges:
+
 1. Merge $f(5)$ and $e(9)$ → node $fe(14)$.
 2. Merge $c(12)$ and $b(13)$ → node $cb(25)$.
 3. Merge $fe(14)$ and $d(16)$ → node $fed(30)$.

notes/courses/CSCI-UA-310/17-graphs.md

@@ -25,6 +25,7 @@ A **graph** $G = (V, E)$ consists of a set of **vertices** $V$ and a set of **ed
 **Weighted graph**: Each edge $(u, v)$ has a weight $w(u, v) \in \mathbb{R}$.
 
 **Key quantities**:
+
 * $n = |V|$ (number of vertices), $m = |E|$ (number of edges).
 * For undirected graphs: $m \leq \binom{n}{2} = O(n^2)$.
 * For directed graphs: $m \leq n(n-1) = O(n^2)$.
@@ -78,7 +79,8 @@ An $n \times n$ matrix $A$ where $A[u][v] = 1$ if $(u,v) \in E$, else $0$.
 
 **Weakly connected** (directed): The underlying undirected graph is connected.
 
-**Degree**: 
+**Degree**:
+
 * Undirected: $\deg(v)$ = number of incident edges.
 * Directed: $\text{in-deg}(v)$ = edges entering, $\text{out-deg}(v)$ = edges leaving.
 * **Handshake lemma**: $\sum_{v \in V} \deg(v) = 2|E|$.

notes/courses/CSCI-UA-310/18-graph-traversal.md

@@ -83,6 +83,7 @@ DFS-VISIT(G, u)
 ### Parenthesis Theorem
 
 For any two vertices $u$ and $v$, exactly one of the following holds:
+
 1. $[u.d, u.f]$ and $[v.d, v.f]$ are **disjoint** ($u$ and $v$ are in different DFS trees).
 2. $[u.d, u.f] \subset [v.d, v.f]$ ($u$ is a **descendant** of $v$).
 3. $[v.d, v.f] \subset [u.d, u.f]$ ($v$ is a **descendant** of $u$).

notes/courses/CSCI-UA-310/19-20-shortest-paths.md

@@ -27,6 +27,7 @@ $$\delta(s, v) = \min \{ w(p) : s \xrightarrow{p} v \}$$
 and $\delta(s, v) = \infty$ if no path exists.
 
 **Shortest-path properties**:
+
 * **Optimal substructure**: Any subpath of a shortest path is itself a shortest path.
 * **Triangle inequality**: $\delta(s, v) \leq \delta(s, u) + w(u, v)$ for all edges $(u,v)$.
 * **No negative cycles**: If a negative cycle is reachable from $s$, shortest paths are undefined (can be made arbitrarily small).
@@ -38,6 +39,7 @@ and $\delta(s, v) = \infty$ if no path exists.
 All SSSP algorithms maintain estimates $v.d \geq \delta(s,v)$ and predecessors $v.\pi$.
 
 **Initialization**:
+
 ```text
 INITIALIZE-SINGLE-SOURCE(G, s)
 1. for each v in V
@@ -47,6 +49,7 @@ INITIALIZE-SINGLE-SOURCE(G, s)
 ```
 
 **Relaxation** of edge $(u, v)$:
+
 ```text
 RELAX(u, v, w)
 1. if v.d > u.d + w(u, v)
@@ -55,6 +58,7 @@ RELAX(u, v, w)
 ```
 
 **Key properties**:
+
 * After `RELAX(u, v, w)`: $v.d \leq u.d + w(u,v)$.
 * If $u.d = \delta(s, u)$ at the time of relaxation, then afterwards $v.d \leq \delta(s, v)$.
 * $v.d$ never increases.
@@ -150,6 +154,7 @@ BELLMAN-FORD(G, w, s)
 **Theorem**: After $k$ iterations of the outer loop, $v.d \leq$ the weight of the shortest path from $s$ to $v$ using **at most $k$ edges**.
 
 **Proof by induction**:
+
 * After 0 iterations: $s.d = 0 = \delta_0(s,s)$ and $v.d = \infty$ for $v \neq s$. Correct (no 0-edge paths to others).
 * After $k$ iterations: Assume $v.d \leq \delta_{k-1}(s,v)$ for all $v$ after $k-1$ iterations. When we relax edge $(u,v)$: $v.d \leq u.d + w(u,v) \leq \delta_{k-1}(s,u) + w(u,v) = \delta_k(s,v)$.
 

notes/courses/CSCI-UA-310/21-22-min-spanning-tree.md

@@ -83,6 +83,7 @@ MST-KRUSKAL(G, w)
 ## 4. Union-Find (Disjoint Set Union)
 
 Kruskal's algorithm needs efficient support for:
+
 * `MAKE-SET(x)`: Create a singleton set $\{x\}$.
 * `FIND-SET(x)`: Return the representative of $x$'s set.
 * `UNION(x, y)`: Merge the sets containing $x$ and $y$.
@@ -133,6 +134,7 @@ since $|E| \leq |V|^2$ so $\log E = O(\log V)$.
 **Why safe**: At each step, the cut $(S, V \setminus S)$ where $S$ is the current tree respects $A$. The lightest crossing edge is safe by the safe-edge theorem.
 
 Each vertex $v \notin S$ maintains:
+
 * `v.key`: minimum weight of any edge connecting $v$ to a vertex in $S$ (or $\infty$ if none).
 * `v.π`: the vertex in $S$ that achieves `v.key`.
 
@@ -164,6 +166,7 @@ When $u$ is extracted, `u.key` = $w(u, u.\pi)$ is the minimum-weight edge from $
 Graph: $V = \{a,b,c,d,e,f,g,h,i\}$, with edges of various weights.
 
 Starting from vertex $a$:
+
 * Extract $a$ (key=0). Update neighbors: $b.key=4, h.key=8$.
 * Extract $b$ (key=4). Update: $c.key=8, h.key=11$ (no improvement for $h$).
 * Extract $c$ (key=8). Update: $d.key=7, f.key=4, i.key=2$.

notes/courses/CSCI-UA-310/23-apsp-floyd-warshall.md

@@ -70,6 +70,7 @@ Better, but Floyd-Warshall achieves $O(|V|^3)$ with a different subproblem defin
 **Subproblem**: $D[u, v, i]$ = shortest path from $u$ to $v$ using only vertices from $\{v_1, \dots, v_i\}$ as intermediate vertices.
 
 **Key observation**: For the shortest $u \to v$ path using only $\{v_1,\dots,v_i\}$:
+
 * **Case 1**: $v_i$ is **not** on the path. Then $D[u,v,i] = D[u,v,i-1]$.
 * **Case 2**: $v_i$ **is** on the path. Then the sub-paths $u \to v_i$ and $v_i \to v$ both use only $\{v_1,\dots,v_{i-1}\}$. So $D[u,v,i] = D[u,v_i,i-1] + D[v_i,v,i-1]$.
 
@@ -103,6 +104,7 @@ FLOYD-WARSHALL(W)
 Graph with $V = \{v_1, v_2, v_3, v_4, v_5, v_6\}$:
 
 Computing $D[v_3, v_5, i]$ through successive iterations:
+
 * $D[v_3, v_5, 0] = \infty$ (no direct edge)
 * $D[v_3, v_5, 1] = \infty$ (no path through $v_1$ only)
 * $D[v_3, v_5, 2] = 5$ (path $v_3 \to v_2 \to v_5$)

notes/courses/CSCI-UA-310/25-26-27-complexity.md

@@ -29,6 +29,7 @@ These lectures ask two foundational questions: **which problems can computers so
 We focus on **decision problems**: problems whose answer is "yes" or "no."
 
 **Examples**:
+
 * **MST**: Given graph $G$, weights $w$, and integer $k$: is the MST of $G$ of weight $\leq k$?
 * **Halting**: Given program $P$ and input $x$: does $P(x)$ terminate?
 * **Wang Tiling**: Given a set of colored tile types, can they tile the infinite 2D plane such that adjacent tiles share the same color on touching sides?
@@ -38,10 +39,12 @@ We focus on **decision problems**: problems whose answer is "yes" or "no."
 ## 2. Decidability
 
 **Notation**:
+
 * $\langle P \rangle$ = the source code of program $P$ (in some fixed language).
 * $P(x)$ = running program $P$ on input $x$.
 
 **Definition**: An algorithm $A$ **solves** problem $\Pi$ if for all inputs:
+
 * If the answer is "yes," $A$ outputs "yes" and terminates.
 * If the answer is "no," $A$ outputs "no" and terminates.
 
@@ -93,6 +96,7 @@ Therefore $A^{\text{Halt}}$ cannot exist. $\square$
 ## 4. Reduction: Program Equality is Undecidable
 
 **Program Equality**:
+
 * **Input**: Two programs $\langle A \rangle$ and $\langle B \rangle$.
 * **Goal**: Decide if $A(x) = B(x)$ for all strings $x$.
 
@@ -127,6 +131,7 @@ So $H$ solves Halting — contradicting Turing's theorem. Hence $E$ cannot exist
 More precisely: any semantic property of programs (one that cannot be determined from syntax alone) is undecidable.
 
 **Examples of undecidable problems**:
+
 * Does program $P$ output "yes" on input $x$?
 * Does program $P$ halt on all inputs?
 * Do programs $A$ and $B$ compute the same function? (Program Equality above)
@@ -207,6 +212,7 @@ Thus: if there's a poly-time algorithm for VC, there's one for IS (and vice vers
 ## 9. Class NP
 
 **Formal Definition**: $L \in$ **NP** if there exists a polynomial-time **verifier** $V$ such that:
+
 * For every $x \in L$: there exists a **witness** $w$ with $V(x, w) = \text{"yes"}$.
 * For every $x \notin L$: for all $w$: $V(x, w) = \text{"no"}$.
 * $V$ runs in polynomial time in $|x|$.
@@ -216,6 +222,7 @@ Thus: if there's a poly-time algorithm for VC, there's one for IS (and vice vers
 **Why "NP"**: Non-deterministic Polynomial time.
 
 **Examples in NP**:
+
 * VC: witness = the $k$ vertices.
 * IS: witness = the $k$ independent vertices.
 * Clique: witness = the $k$-clique vertices.
@@ -244,12 +251,12 @@ This is the foundational result: 3SAT is the "hardest" problem in NP. Proved by
 Computable
 ┌────────────────────────────────────────────────────┐
 │  NP                                                │
-│ ┌──────────────────────┐  ┌────────────────────┐  │
-│ │  P                   │  │  NP-complete        │  │
-│ │  • MST               │  │  • 3SAT             │  │
-│ │  • APSP              │  │  • VC               │  │
-│ └──────────────────────┘  └────────────────────┘  │
-└────────────────────────────────────────────────────┘   • Halting
+│ ┌──────────────────────┐  ┌────────────────────┐   │
+│ │  P                   │  │  NP-complete       │   │
+│ │  • MST               │  │  • 3SAT            │   │
+│ │  • APSP              │  │  • VC              │   │
+│ └──────────────────────┘  └────────────────────┘   │
+└────────────────────────────────────────────────────┘    • Halting
                                                           • Wang Tiling
 ```
 
@@ -260,10 +267,12 @@ Computable
 **The central open question**: Is P = NP?
 
 **If P $\neq$ NP** (widely believed):
+
 * There is no efficient algorithm for any NP-complete problem (3SAT, VC, IS, ...).
 * Cryptography (RSA, etc.) is secure.
 
 **If P $=$ NP**:
+
 * We can solve almost everything in polynomial time.
 * "Can verify $\Rightarrow$ can solve."
 * Modern cryptography would break down.
@@ -332,6 +341,7 @@ Better hardware improves constants but does not change the asymptotic complexity
 ### Strategy 2: Simplify the Problem
 
 Identify special cases that are in P:
+
 * 2SAT (2 literals per clause) $\in$ P.
 * Vertex Cover on trees $\in$ P.
 * Knapsack with small $W$: pseudopolynomial $O(nW)$ DP.