@@ -28,6 +28,8 @@
   - [1.15 Search A 2D Matrix](ch01-binary-search/search-a-2d-matrix.md)
   - [1.16 Search In Rotated Sorted Array II](ch01-binary-search/search-in-rotated-sorted-array-ii.md)
   - [1.17 Search In Rotated Sorted Array](ch01-binary-search/search-in-rotated-sorted-array.md)
+  - [1.19 Sqrt(x)](ch01-binary-search/sqrt-x.md)
+  - [1.20 Split Array Largest Sum](ch01-binary-search/split-array-largest-sum.md)
   - [1.18 Search Insert Position](ch01-binary-search/search-insert-position.md)
   - [1.19 Single Element In A Sorted Array](ch01-binary-search/single-element-in-a-sorted-array.md)
   - [1.20 Valley Element](ch01-binary-search/valley-element.md)
@@ -57,6 +59,8 @@
   - [2.20 Burst Balloons](ch02-dynamic-programming/burst-balloons.md)
   - [2.21 Target Sum](ch02-dynamic-programming/target-sum.md)
   - [2.22 Interleaving String](ch02-dynamic-programming/interleaving-string.md)
+  - [2.23 Regular Expression Matching](ch02-dynamic-programming/regular-expression-matching.md)
+  - [2.24 Delete Operations For Two Strings](ch02-dynamic-programming/delete-operations-for-two-strings.md)
 
 - [3. Arrays, Two Pointers & Matrices](ch03-arrays/index.md)
   - [3.0 Pattern Primer: Two Pointers & The Sorted-Array Dance](ch03-arrays/pattern-primer.md)
@@ -77,6 +81,10 @@
   - [3.15 Find Pivot Index](ch03-arrays/find-pivot-index.md)
   - [3.16 Shuffle An Array](ch03-arrays/shuffle-an-array.md)
   - [3.17 Convex Hull (Erect The Fence)](ch03-arrays/convex-hull.md)
+  - [3.18 Remove Duplicates From Sorted Array](ch03-arrays/remove-duplicates-from-sorted-array.md)
+  - [3.19 Pascal's Triangle](ch03-arrays/pascals-triangle.md)
+  - [3.20 Robot Bounded In Circle](ch03-arrays/robot-bounded-in-circle.md)
+  - [3.21 Increasing Triplet Subsequence](ch03-arrays/increasing-triplet-subsequence.md)
   - [2.12 Closest Subsequence Sum](ch02-dynamic-programming/closest-subsequence-sum.md)
 
 - [4. Linked Lists](ch04-linked-lists/index.md)
@@ -90,6 +98,9 @@
   - [4.7 Add Two Numbers](ch04-linked-lists/add-two-numbers.md)
   - [4.8 Middle Of The Linked List](ch04-linked-lists/middle-of-the-linked-list.md)
   - [4.9 Palindrome Linked List](ch04-linked-lists/palindrome-linked-list.md)
+  - [4.10 Copy List With Random Pointer](ch04-linked-lists/copy-list-with-random-pointer.md)
+  - [4.11 Swap Nodes In Pairs](ch04-linked-lists/swap-nodes-in-pairs.md)
+  - [4.12 Reverse Nodes In K Groups](ch04-linked-lists/reverse-nodes-in-k-groups.md)
 
 - [5. Trees](ch05-trees/index.md)
   - [5.0 Pattern Primer: The Recursive Data Structure](ch05-trees/pattern-primer.md)
@@ -107,6 +118,7 @@
   - [5.12 All Nodes Distance K In Binary Tree](ch05-trees/all-nodes-distance-k.md)
   - [5.13 Binary Tree ZigZag Level Order](ch05-trees/zigzag-level-order.md)
   - [5.14 Count Good Nodes In Binary Tree](ch05-trees/count-good-nodes.md)
+  - [5.15 Populating Next Right Pointers In Each Node](ch05-trees/populating-next-right-pointers.md)
 
 - [6. Graphs](ch06-graphs/index.md)
   - [6.0 Pattern Primer: The Seven Engines](ch06-graphs/pattern-primer.md)
@@ -126,6 +138,8 @@
   - [6.14 Rotting Oranges](ch06-graphs/rotting-oranges.md)
   - [6.15 Accounts Merge](ch06-graphs/accounts-merge.md)
   - [6.16 Surrounded Regions](ch06-graphs/surrounded-regions.md)
+  - [6.17 Max Area Of Island](ch06-graphs/max-area-of-island.md)
+  - [6.18 Pacific Atlantic Water Flow](ch06-graphs/pacific-atlantic-water-flow.md)
 
 - [7. Heaps & Priority Queues](ch07-heaps/index.md)
   - [7.0 Pattern Primer: The Lazy Sorted Structure](ch07-heaps/pattern-primer.md)
@@ -139,6 +153,7 @@
   - [7.8 The Skyline Problem](ch07-heaps/the-skyline-problem.md)
   - [7.9 Design Hit Counter](ch07-heaps/design-hit-counter.md)
   - [7.10 Longest Happy String](ch07-heaps/longest-happy-string.md)
+  - [7.11 Merge K Sorted Lists](ch07-heaps/merge-k-sorted-lists.md)
 
 - [8. Stacks & Queues](ch08-stacks/index.md)
   - [8.0 Pattern Primer: LIFO, FIFO, and the Monotonic Stack](ch08-stacks/pattern-primer.md)
@@ -154,6 +169,8 @@
   - [8.10 Basic Calculator II](ch08-stacks/basic-calculator-ii.md)
   - [8.11 Basic Calculator](ch08-stacks/basic-calculator.md)
   - [8.12 Basic Calculator III](ch08-stacks/basic-calculator-iii.md)
+  - [8.13 Asteroid Collision](ch08-stacks/asteroid-collision.md)
+  - [8.14 Online Stock Span](ch08-stacks/online-stock-span.md)
 
 - [9. Strings](ch09-strings/index.md)
   - [9.0 Pattern Primer: The Three Lenses](ch09-strings/pattern-primer.md)
@@ -170,6 +187,8 @@
   - [9.11 Valid Palindrome](ch09-strings/valid-palindrome.md)
   - [9.12 Count And Say](ch09-strings/count-and-say.md)
   - [9.13 Add Strings](ch09-strings/add-strings.md)
+  - [9.14 String To Integer (atoi)](ch09-strings/string-to-integer-atoi.md)
+  - [9.15 Text Justification](ch09-strings/text-justification.md)
 
 - [10. Hash Tables & Sets](ch10-hash-tables/index.md)
   - [10.0 Pattern Primer: O(1) Lookup, Three Moves](ch10-hash-tables/pattern-primer.md)
@@ -188,6 +207,8 @@
   - [10.13 Unique Number Of Occurrences](ch10-hash-tables/unique-number-of-occurrences.md)
   - [10.14 Integer To English Words](ch10-hash-tables/integer-to-english-words.md)
   - [10.15 Max Points On A Line](ch10-hash-tables/max-points-on-a-line.md)
+  - [10.16 Design HashMap](ch10-hash-tables/design-hashmap.md)
+  - [10.17 Group Shifted Strings](ch10-hash-tables/group-shifted-strings.md)
 
 - [11. Greedy](ch11-greedy/index.md)
   - [11.0 Pattern Primer: The Local Choice, Defended](ch11-greedy/pattern-primer.md)
@@ -203,6 +224,7 @@
   - [11.10 Reorganize String](ch11-greedy/reorganize-string.md)
   - [11.11 Minimum Number Of Arrows To Burst Balloons](ch11-greedy/minimum-number-of-arrows-to-burst-balloons.md)
   - [11.12 Can Place Flowers](ch11-greedy/can-place-flowers.md)
+  - [11.13 Destroying Asteroids](ch11-greedy/destroying-asteroids.md)
 
 - [12. Backtracking](ch12-backtracking/index.md)
   - [12.0 Pattern Primer: DFS With an Undo Button](ch12-backtracking/pattern-primer.md)
@@ -255,6 +277,7 @@
   - [15.8 Permutation In String](ch15-sliding-window/permutation-in-string.md)
   - [15.9 Maximum Erasure Value](ch15-sliding-window/maximum-erasure-value.md)
   - [15.10 Longest Subarray Of 1s After Deleting One](ch15-sliding-window/longest-subarray-of-ones-after-deleting-one.md)
+  - [15.11 Find All Anagrams In A String](ch15-sliding-window/find-all-anagrams.md)
 
 - [16. Bit Manipulation](ch16-bit-manipulation/index.md)
   - [16.0 Pattern Primer: The Bit Identities](ch16-bit-manipulation/pattern-primer.md)
@@ -266,6 +289,7 @@
   - [16.6 Sum Of All Subset XOR Totals](ch16-bit-manipulation/sum-of-all-subset-xor-totals.md)
   - [16.7 Smallest Number With All Set Bits](ch16-bit-manipulation/smallest-number-with-all-set-bits.md)
   - [16.8 Pow(x, n)](ch16-bit-manipulation/pow-x-n.md)
+  - [16.9 Divide Two Integers](ch16-bit-manipulation/divide-two-integers.md)
 
 - [17. Advanced Graphs](ch17-advanced-graphs/index.md)
   - [17.0 Pattern Primer: Flow, Matching, MST, and State-Space BFS](ch17-advanced-graphs/pattern-primer.md)
@@ -282,6 +306,7 @@
   - [17.11 Walls And Gates](ch17-advanced-graphs/walls-and-gates.md)
   - [17.12 Bus Routes](ch17-advanced-graphs/bus-routes.md)
   - [17.13 Minimum Genetic Mutations](ch17-advanced-graphs/minimum-genetic-mutations.md)
+  - [17.14 Find Articulation Points](ch17-advanced-graphs/find-articulation-points.md)
 
 - [18. Design & Caches](ch18-design-caches/index.md)
   - [18.0 Pattern Primer: Composing Structures](ch18-design-caches/pattern-primer.md)
@@ -295,6 +320,7 @@
   - [18.8 Weighted Reservoir Sampling](ch18-design-caches/weighted-reservoir-sampling.md)
   - [18.9 LRU Cache — The Repo's Seven Implementations](ch18-design-caches/lru-cache-variants.md)
   - [18.11 My Calendar](ch18-design-caches/my-calendar.md)
+  - [18.12 BST Iterator](ch18-design-caches/bst-iterator.md)
 
 ## Appendix
 
 
@@ -0,0 +1,225 @@
+# 1.20 Split Array Largest Sum
+
+> **Source:** [`src/main/kotlin/array/dp/SplitArrayLargestSum.kt`](https://github.com/arpanpathak/AdvancedAlgorithmPatterns/blob/main/src/main/kotlin/array/dp/SplitArrayLargestSum.kt)
+> **Pattern:** minimize the max — binary search the answer · **Core page**
+
+## The Problem
+
+Split `nums` into `k` contiguous subarrays minimizing the **largest sum** among them.
+
+- Constraints: $1 \le k \le n \le 1000$.
+
+## Examples
+
+```
+Input:  nums = [7,2,5,10,8], k = 2   -> Output: 18   ([7,2,5] and [10,8])
+Input:  nums = [1,2,3,4,5], k = 2    -> Output: 9    ([1,2,3] and [4,5])
+```
+
+## Intuition — "minimize the max" is binary-searchable
+
+If a cap `C` can split the array into ≤ k parts each ≤ C, then any larger cap also works — **monotone**. Binary search the smallest feasible cap in `[max(nums), sum(nums)]`:
+
+```
+canSplit(C): greedy-pack: walk nums, start a new part whenever the running sum would exceed C.
+             feasible iff parts ≤ k.
+
+binary search: lo = max(nums), hi = sum(nums)
+  mid = (lo + hi) / 2
+  canSplit(mid) ? hi = mid : lo = mid + 1
+return lo
+```
+
+**Why `max(nums)` as the floor?** No part can hold less than the biggest element — `C < max(nums)` is infeasible by construction. The [1.x](../ch01-binary-search/pattern-primer.md) "answer must lie in [lo, hi]" tightening.
+
+**Why greedy packing for feasibility?** To test a cap, greedily extend the current part as far as possible — any feasible split can be rearranged into the greedy one (exchange argument), so the greedy part count is the *minimum* possible. The repo's memoized DP ([2.x](../ch02-dynamic-programming/pattern-primer.md) `dfs(i, splitsLeft)` over prefix sums) is the exact alternative; the binary search is the canonical LeetCode answer.
+
+## Approach 1 — DP over (index, parts) (the repo's version)
+
+`dfs(i, k)` = min largest sum splitting `nums[i:]` into k parts (prefix-sum lookups, prune when `currentSum > best`): O(n²k).
+
+## Approach 2 — Binary search the answer (optimal)
+
+```kotlin
+class SplitArrayLargestSum {
+    /**
+     * @param nums input array
+     * @param k    number of subarrays
+     * @return     minimized largest subarray sum
+     */
+    fun splitArray(nums: IntArray, k: Int): Int {
+        var lo = 0L
+        var hi = 0L
+        for (num in nums) { lo = maxOf(lo, num.toLong()); hi += num }
+
+        fun canSplit(cap: Long): Boolean {
+            var parts = 1
+            var running = 0L
+            for (num in nums) {
+                if (running + num > cap) { parts++; running = 0 }
+                running += num
+            }
+            return parts <= k
+        }
+
+        while (lo < hi) {
+            val mid = lo + (hi - lo) / 2
+            if (canSplit(mid)) hi = mid
+            else lo = mid + 1
+        }
+        return lo.toInt()
+    }
+}
+```
+
+```java
+public class SplitArrayLargestSum {
+    /**
+     * @param nums input array
+     * @param k    number of subarrays
+     * @return     minimized largest subarray sum
+     */
+    public int splitArray(int[] nums, int k) {
+        long lo = 0, hi = 0;
+        for (int num : nums) { lo = Math.max(lo, num); hi += num; }
+
+        while (lo < hi) {
+            long mid = lo + (hi - lo) / 2;
+
+            int parts = 1;
+            long running = 0;
+            for (int num : nums) {
+                if (running + num > mid) { parts++; running = 0; }
+                running += num;
+            }
+
+            if (parts <= k) hi = mid;
+            else lo = mid + 1;
+        }
+        return (int) lo;
+    }
+}
+```
+
+```cpp
+#include <vector>
+#include <algorithm>
+
+class SplitArrayLargestSum {
+public:
+    /**
+     * @param nums input array
+     * @param k    number of subarrays
+     * @return     minimized largest subarray sum
+     */
+    int splitArray(std::vector<int>& nums, int k) {
+        long lo = 0, hi = 0;
+        for (int num : nums) { lo = std::max(lo, (long)num); hi += num; }
+
+        while (lo < hi) {
+            long mid = lo + (hi - lo) / 2;
+
+            int parts = 1;
+            long running = 0;
+            for (int num : nums) {
+                if (running + num > mid) { parts++; running = 0; }
+                running += num;
+            }
+
+            if (parts <= k) hi = mid;
+            else lo = mid + 1;
+        }
+        return (int)lo;
+    }
+};
+```
+
+```python
+def split_array(nums: list[int], k: int) -> int:
+    """
+    @param nums: input array
+    @param k:    number of subarrays
+    @return:     minimized largest subarray sum
+    """
+    def can_split(cap: int) -> bool:
+        parts = 1
+        running = 0
+        for num in nums:
+            if running + num > cap:
+                parts += 1
+                running = 0
+            running += num
+        return parts <= k
+
+    lo, hi = max(nums), sum(nums)
+    while lo < hi:
+        mid = (lo + hi) // 2
+        if can_split(mid):
+            hi = mid
+        else:
+            lo = mid + 1
+    return lo
+```
+
+```rust
+impl Solution {
+    /// @param nums input array
+    /// @param k    number of subarrays
+    /// @return     minimized largest subarray sum
+    pub fn split_array(nums: Vec<i32>, k: i32) -> i32 {
+        let can_split = |cap: i64| -> bool {
+            let mut parts = 1i64;
+            let mut running = 0i64;
+            for &num in &nums {
+                if running + num as i64 > cap { parts += 1; running = 0; }
+                running += num as i64;
+            }
+            parts <= k as i64
+        };
+
+        let mut lo = *nums.iter().max().unwrap() as i64;
+        let mut hi: i64 = nums.iter().map(|&v| v as i64).sum();
+
+        while lo < hi {
+            let mid = lo + (hi - lo) / 2;
+            if can_split(mid) { hi = mid; } else { lo = mid + 1; }
+        }
+        lo as i32
+    }
+}
+```
+
+## Dry run
+
+**Input:** `nums = [7,2,5,10,8]`, `k = 2`.
+
+```
+lo = max = 10, hi = sum = 32
+mid = 21: canSplit(21)? 7+2+5=14, +10=24 > 21 -> new part.  [14][10+8=18] = 2 parts ≤ 2 ✓ -> hi=21
+mid = 15: 7+2+5=14, +10>15 -> [14][10], 8 -> 3 parts > 2 ✗ -> lo=16
+mid = 18: 7+2+5=14, +10>18 -> [14][10], 8: 10+8=18 ≤ 18 -> [14][18] = 2 parts ✓ -> hi=18
+mid = 17: 14, +10>17 -> [14][10], 8 -> 3 parts ✗ -> lo=18
+lo == hi == 18.  Output: 18 ✓
+```
+
+The monotone predicate is the crux: cap 18 works (2 parts), cap 17 doesn't (3 parts) — the boundary is exactly the answer. The greedy pack computes the *minimum* part count for each cap, and the search zooms to the smallest feasible cap.
+
+## Complexity
+
+**Time.** O(n) feasibility × O(log Σ) iterations:
+
+$$
+T(n) = O(n \log \Sigma)
+$$
+
+**Space.** Scalars:
+
+$$
+S(n) = O(1)
+$$
+
+## Variants & follow-ups
+
+- **Capacity To Ship Packages** ([1.2](capacity-to-ship-packages.md)) — the same "minimize the max with a feasible-cap binary search", with days instead of parts.
+- **Koko Eating Bananas** ([1.3](koko-eating-bananas.md)) — the same shape, eating speed instead of cap.
+- **Interview follow-up:** "Why is the greedy part count the minimum?" If a cap is feasible with some split, the greedy (extend each part maximally) uses *at most* as many parts — any split's parts can be merged into greedier ones without exceeding the cap. So `greedyParts ≤ any split's parts`; testing `greedyParts ≤ k` decides feasibility exactly.