From c60ae08f5692319d44d89a3f1a5a0e4d24800fd7 Mon Sep 17 00:00:00 2001
From: Kai Chappell <git@kschappell.com>
Date: Wed, 10 Sep 2025 18:05:55 +0100
Subject: [PATCH] migrate 392 questions to pattern format

---
 backend/data/patterns/patterns.yaml           | 80 +++++++++++++++++++
 backend/data/questions/01-matrix.yaml         |  9 ++-
 backend/data/questions/132-pattern.yaml       |  3 +-
 backend/data/questions/2-keys-keyboard.yaml   |  3 +-
 backend/data/questions/24-game.yaml           |  3 +-
 .../questions/3sum-with-multiplicity.yaml     |  3 +-
 backend/data/questions/4sum-ii.yaml           |  3 +-
 .../a-number-after-a-double-reversal.yaml     |  3 +-
 backend/data/questions/accounts-merge.yaml    |  6 +-
 backend/data/questions/add-binary.yaml        |  3 +-
 backend/data/questions/add-digits.yaml        |  3 +-
 .../add-minimum-number-of-rungs.yaml          |  3 +-
 .../data/questions/add-one-row-to-tree.yaml   |  9 ++-
 backend/data/questions/add-strings.yaml       |  3 +-
 .../add-to-array-form-of-integer.yaml         |  3 +-
 backend/data/questions/add-two-integers.yaml  |  4 +-
 .../data/questions/add-two-numbers-ii.yaml    |  3 +-
 backend/data/questions/add-two-numbers.yaml   |  3 +-
 .../questions/adding-spaces-to-a-string.yaml  |  3 +-
 .../adding-two-negabinary-numbers.yaml        |  3 +-
 backend/data/questions/additive-number.yaml   |  3 +-
 backend/data/questions/advantage-shuffle.yaml |  6 +-
 .../airplane-seat-assignment-probability.yaml |  3 +-
 .../data/questions/alert-using-same-key.yaml  |  3 +-
 ...ns-with-highest-score-of-binary-array.yaml |  3 +-
 ...l-elements-in-two-binary-search-trees.yaml |  6 +-
 .../all-nodes-distance-k-in-binary-tree.yaml  |  6 +-
 .../all-paths-from-source-to-target.yaml      |  6 +-
 .../all-possible-full-binary-trees.yaml       |  6 +-
 .../data/questions/allocate-mailboxes.yaml    |  3 +-
 .../data/questions/alphabet-board-path.yaml   |  3 +-
 .../data/questions/alternating-digit-sum.yaml |  3 +-
 .../data/questions/ambiguous-coordinates.yaml |  3 +-
 ...f-time-for-binary-tree-to-be-infected.yaml |  6 +-
 .../angle-between-hands-of-a-clock.yaml       |  3 +-
 ...racters-to-string-to-make-subsequence.yaml |  6 +-
 .../append-k-integers-with-minimal-sum.yaml   |  3 +-
 ...wise-operations-to-make-strings-equal.yaml |  3 +-
 .../apply-operations-to-an-array.yaml         |  3 +-
 .../arithmetic-slices-ii-subsequence.yaml     |  3 +-
 backend/data/questions/arithmetic-slices.yaml |  3 +-
 .../data/questions/arithmetic-subarrays.yaml  |  3 +-
 backend/data/questions/arranging-coins.yaml   |  3 +-
 backend/data/questions/array-nesting.yaml     |  3 +-
 .../questions/array-of-doubled-pairs.yaml     |  3 +-
 backend/data/questions/array-partition.yaml   |  3 +-
 ...nts-not-equal-to-average-of-neighbors.yaml |  3 +-
 .../as-far-from-land-as-possible.yaml         |  6 +-
 backend/data/questions/assign-cookies.yaml    |  6 +-
 .../data/questions/asteroid-collision.yaml    |  3 +-
 .../available-captures-for-rook.yaml          |  3 +-
 .../average-of-levels-in-binary-tree.yaml     |  6 +-
 ...-salary-excluding-minimum-and-maximum.yaml |  3 +-
 ...ue-of-even-numbers-divisible-by-three.yaml |  3 +-
 .../data/questions/average-waiting-time.yaml  |  3 +-
 .../questions/avoid-flood-in-the-city.yaml    |  6 +-
 .../questions/backspace-string-compare.yaml   |  3 +-
 backend/data/questions/bag-of-tokens.yaml     |  6 +-
 .../balance-a-binary-search-tree.yaml         |  6 +-
 .../data/questions/balanced-binary-tree.yaml  |  6 +-
 backend/data/questions/base-7.yaml            |  3 +-
 backend/data/questions/baseball-game.yaml     |  3 +-
 .../data/questions/basic-calculator-ii.yaml   |  3 +-
 .../data/questions/basic-calculator-iv.yaml   |  3 +-
 backend/data/questions/basic-calculator.yaml  |  3 +-
 .../questions/battleships-in-a-board.yaml     |  3 +-
 .../questions/beautiful-arrangement-ii.yaml   |  3 +-
 .../data/questions/beautiful-arrangement.yaml |  3 +-
 backend/data/questions/beautiful-array.yaml   |  3 +-
 backend/data/questions/best-poker-hand.yaml   |  3 +-
 .../best-position-for-a-service-centre.yaml   |  3 +-
 .../data/questions/best-sightseeing-pair.yaml |  3 +-
 .../best-team-with-no-conflicts.yaml          |  3 +-
 .../best-time-to-buy-and-sell-stock-ii.yaml   |  3 +-
 .../best-time-to-buy-and-sell-stock-iii.yaml  |  3 +-
 .../best-time-to-buy-and-sell-stock-iv.yaml   |  3 +-
 ...e-to-buy-and-sell-stock-with-cooldown.yaml |  3 +-
 ...y-and-sell-stock-with-transaction-fee.yaml |  6 +-
 .../best-time-to-buy-and-sell-stock.yaml      |  3 +-
 backend/data/questions/binary-gap.yaml        |  3 +-
 .../binary-number-with-alternating-bits.yaml  |  3 +-
 .../binary-prefix-divisible-by-5.yaml         |  3 +-
 .../binary-search-tree-iterator.yaml          |  6 +-
 ...inary-search-tree-to-greater-sum-tree.yaml |  6 +-
 backend/data/questions/binary-search.yaml     |  3 +-
 ...g-with-substrings-representing-1-to-n.yaml |  3 +-
 .../questions/binary-subarrays-with-sum.yaml  |  6 +-
 .../data/questions/binary-tree-cameras.yaml   |  6 +-
 .../questions/binary-tree-coloring-game.yaml  |  6 +-
 .../binary-tree-inorder-traversal.yaml        |  6 +-
 .../binary-tree-level-order-traversal-ii.yaml |  6 +-
 .../binary-tree-level-order-traversal.yaml    |  6 +-
 .../binary-tree-maximum-path-sum.yaml         |  6 +-
 backend/data/questions/binary-tree-paths.yaml |  9 ++-
 .../binary-tree-postorder-traversal.yaml      |  6 +-
 .../binary-tree-preorder-traversal.yaml       |  6 +-
 .../data/questions/binary-tree-pruning.yaml   |  6 +-
 .../binary-tree-right-side-view.yaml          |  9 ++-
 backend/data/questions/binary-tree-tilt.yaml  |  6 +-
 ...ary-tree-zigzag-level-order-traversal.yaml |  6 +-
 .../questions/binary-trees-with-factors.yaml  |  3 +-
 backend/data/questions/binary-watch.yaml      |  3 +-
 .../bitwise-and-of-numbers-range.yaml         |  3 +-
 .../questions/bitwise-ors-of-subarrays.yaml   |  3 +-
 .../bitwise-xor-of-all-pairings.yaml          |  3 +-
 .../data/questions/boats-to-save-people.yaml  |  6 +-
 .../booking-concert-tickets-in-groups.yaml    |  3 +-
 .../data/questions/brace-expansion-ii.yaml    |  6 +-
 .../data/questions/break-a-palindrome.yaml    |  3 +-
 backend/data/questions/brick-wall.yaml        |  3 +-
 .../questions/bricks-falling-when-hit.yaml    |  6 +-
 backend/data/questions/broken-calculator.yaml |  3 +-
 backend/data/questions/buddy-strings.yaml     |  3 +-
 .../build-a-matrix-with-conditions.yaml       |  3 +-
 .../build-an-array-with-stack-operations.yaml |  3 +-
 .../build-array-from-permutation.yaml         |  3 +-
 ...ind-the-maximum-exactly-k-comparisons.yaml |  6 +-
 backend/data/questions/building-boxes.yaml    |  6 +-
 backend/data/questions/building-h2o.yaml      |  3 +-
 backend/data/questions/bulb-switcher-ii.yaml  |  3 +-
 backend/data/questions/bulb-switcher.yaml     |  3 +-
 backend/data/questions/bulls-and-cows.yaml    |  3 +-
 backend/data/questions/burst-balloons.yaml    |  3 +-
 backend/data/questions/bus-routes.yaml        |  3 +-
 .../data/questions/cache-with-time-limit.yaml |  3 +-
 .../calculate-amount-paid-in-taxes.yaml       |  3 +-
 .../calculate-digit-sum-of-a-string.yaml      |  3 +-
 .../calculate-money-in-leetcode-bank.yaml     |  3 +-
 .../data/questions/camelcase-matching.yaml    |  3 +-
 .../can-convert-string-in-k-moves.yaml        |  3 +-
 backend/data/questions/can-i-win.yaml         |  6 +-
 ...-arithmetic-progression-from-sequence.yaml |  3 +-
 backend/data/questions/can-place-flowers.yaml |  3 +-
 ...r-favorite-candy-on-your-favorite-day.yaml |  3 +-
 backend/data/questions/candy.yaml             |  3 +-
 ...pacity-to-ship-packages-within-d-days.yaml |  3 +-
 .../data/questions/capitalize-the-title.yaml  |  3 +-
 backend/data/questions/car-fleet-ii.yaml      |  3 +-
 backend/data/questions/car-fleet.yaml         |  3 +-
 backend/data/questions/car-pooling.yaml       |  6 +-
 .../data/questions/card-flipping-game.yaml    |  3 +-
 backend/data/questions/cat-and-mouse-ii.yaml  |  9 ++-
 backend/data/questions/cat-and-mouse.yaml     |  6 +-
 .../categorize-box-according-to-criteria.yaml |  3 +-
 .../cells-in-a-range-on-an-excel-sheet.yaml   |  3 +-
 .../cells-with-odd-values-in-a-matrix.yaml    |  3 +-
 .../data/questions/chalkboard-xor-game.yaml   |  3 +-
 backend/data/questions/champagne-tower.yaml   |  3 +-
 ...rs-to-satisfy-one-of-three-conditions.yaml |  3 +-
 .../cheapest-flights-within-k-stops.yaml      |  6 +-
 ...array-formation-through-concatenation.yaml |  3 +-
 .../check-completeness-of-a-binary-tree.yaml  |  6 +-
 .../check-distances-between-same-letters.yaml |  3 +-
 ...-if-a-parentheses-string-can-be-valid.yaml |  3 +-
 ...-if-a-string-can-break-another-string.yaml |  3 +-
 ...g-contains-all-binary-codes-of-size-k.yaml |  3 +-
 ...-1s-are-at-least-length-k-places-away.yaml |  3 +-
 ...ters-have-equal-number-of-occurrences.yaml |  3 +-
 ...-if-all-integers-in-range-are-covered.yaml |  3 +-
 ...ring-exists-given-two-encoded-strings.yaml |  3 +-
 .../check-if-array-is-sorted-and-rotated.yaml |  3 +-
 ...eck-if-array-pairs-are-divisible-by-k.yaml |  3 +-
 ...tring-has-at-most-one-segment-of-ones.yaml |  3 +-
 ...y-row-and-column-contains-all-numbers.yaml |  3 +-
 .../check-if-it-is-a-good-array.yaml          |  3 +-
 .../check-if-it-is-a-straight-line.yaml       |  3 +-
 .../check-if-matrix-is-x-matrix.yaml          |  3 +-
 .../questions/check-if-move-is-legal.yaml     |  3 +-
 .../check-if-n-and-its-double-exist.yaml      |  3 +-
 ...has-equal-digit-count-and-digit-value.yaml |  3 +-
 ...if-number-is-a-sum-of-powers-of-three.yaml |  3 +-
 ...f-numbers-are-ascending-in-a-sentence.yaml |  3 +-
 .../check-if-object-instance-of-class.yaml    |  3 +-
 ...ne-string-swap-can-make-strings-equal.yaml |  3 +-
 .../check-if-point-is-reachable.yaml          |  3 +-
 .../check-if-string-is-a-prefix-of-array.yaml |  3 +-
 ...rmable-with-substring-sort-operations.yaml |  3 +-
 .../check-if-the-sentence-is-pangram.yaml     |  3 +-
 ...re-is-a-valid-parentheses-string-path.yaml |  9 ++-
 ...re-is-a-valid-partition-for-the-array.yaml |  3 +-
 ...ck-if-there-is-a-valid-path-in-a-grid.yaml | 12 ++-
 ...k-if-two-string-arrays-are-equivalent.yaml |  3 +-
 ...ck-if-word-can-be-placed-in-crossword.yaml |  3 +-
 ...if-word-equals-summation-of-two-words.yaml |  3 +-
 ...-if-word-is-valid-after-substitutions.yaml |  3 +-
 .../check-if-word-occurs-as-prefix.yaml       |  3 +-
 .../check-knight-tour-configuration.yaml      |  3 +-
 ...xistence-of-edge-length-limited-paths.yaml |  6 +-
 backend/data/questions/climbing-stairs.yaml   |  3 +-
 backend/data/questions/clone-graph.yaml       |  6 +-
 backend/data/questions/coin-change-ii.yaml    |  3 +-
 backend/data/questions/coin-change.yaml       |  3 +-
 .../data/questions/combination-sum-ii.yaml    |  3 +-
 .../data/questions/combination-sum-iii.yaml   |  3 +-
 .../data/questions/combination-sum-iv.yaml    |  3 +-
 backend/data/questions/combination-sum.yaml   |  3 +-
 backend/data/questions/combinations.yaml      |  3 +-
 .../questions/concatenation-of-array.yaml     |  3 +-
 ...e-from-preorder-and-inorder-traversal.yaml |  6 +-
 .../data/questions/construct-quad-tree.yaml   |  6 +-
 .../questions/container-with-most-water.yaml  |  6 +-
 .../data/questions/contains-duplicate-ii.yaml |  3 +-
 .../data/questions/contains-duplicate.yaml    | 35 +++++++-
 .../questions/continuous-subarray-sum.yaml    |  3 +-
 .../convert-bst-to-greater-tree.yaml          |  6 +-
 ...rt-sorted-array-to-binary-search-tree.yaml |  6 +-
 .../copy-list-with-random-pointer.yaml        |  3 +-
 .../count-good-nodes-in-binary-tree.yaml      |  6 +-
 backend/data/questions/counting-bits.yaml     |  3 +-
 .../data/questions/course-schedule-ii.yaml    |  6 +-
 .../data/questions/course-schedule-iv.yaml    |  9 ++-
 backend/data/questions/course-schedule.yaml   |  6 +-
 .../data/questions/daily-temperatures.yaml    |  3 +-
 backend/data/questions/decode-string.yaml     |  3 +-
 backend/data/questions/decode-ways.yaml       |  3 +-
 .../delete-leaves-with-a-given-value.yaml     |  6 +-
 .../data/questions/delete-node-in-a-bst.yaml  |  6 +-
 ...n-add-and-search-words-data-structure.yaml |  6 +-
 .../data/questions/design-circular-queue.yaml |  3 +-
 backend/data/questions/design-hashmap.yaml    |  3 +-
 backend/data/questions/design-hashset.yaml    |  3 +-
 backend/data/questions/design-twitter.yaml    |  3 +-
 backend/data/questions/detect-squares.yaml    |  3 +-
 .../questions/diameter-of-binary-tree.yaml    |  6 +-
 .../data/questions/distinct-subsequences.yaml |  3 +-
 backend/data/questions/dota2-senate.yaml      |  3 +-
 backend/data/questions/edit-distance.yaml     |  3 +-
 backend/data/questions/evaluate-division.yaml |  9 ++-
 .../evaluate-reverse-polish-notation.yaml     |  3 +-
 .../questions/excel-sheet-column-title.yaml   |  3 +-
 .../questions/find-in-mountain-array.yaml     |  3 +-
 .../questions/find-k-closest-elements.yaml    |  6 +-
 .../find-median-from-data-stream.yaml         |  3 +-
 .../find-minimum-in-rotated-sorted-array.yaml |  3 +-
 .../questions/find-the-duplicate-number.yaml  |  6 +-
 .../data/questions/find-the-town-judge.yaml   |  3 +-
 .../questions/first-missing-positive.yaml     |  3 +-
 backend/data/questions/four-sum.yaml          |  3 +-
 backend/data/questions/gas-station.yaml       |  3 +-
 .../data/questions/generate-parentheses.yaml  |  3 +-
 .../greatest-common-divisor-of-strings.yaml   |  3 +-
 backend/data/questions/group-anagrams.yaml    |  3 +-
 .../guess-number-higher-or-lower.yaml         |  3 +-
 backend/data/questions/hand-of-straights.yaml |  6 +-
 backend/data/questions/happy-number.yaml      |  3 +-
 backend/data/questions/house-robber-ii.yaml   |  3 +-
 backend/data/questions/house-robber-iii.yaml  |  6 +-
 backend/data/questions/house-robber.yaml      |  3 +-
 .../implement-queue-using-stacks.yaml         |  3 +-
 .../implement-stack-using-queues.yaml         |  3 +-
 .../questions/implement-trie-prefix-tree.yaml |  3 +-
 backend/data/questions/insert-interval.yaml   |  3 +-
 .../insert-into-a-binary-search-tree.yaml     |  3 +-
 backend/data/questions/integer-break.yaml     |  6 +-
 .../data/questions/interleaving-string.yaml   |  3 +-
 .../data/questions/invert-binary-tree.yaml    |  9 ++-
 backend/data/questions/ipo.yaml               |  6 +-
 backend/data/questions/island-perimeter.yaml  |  3 +-
 backend/data/questions/jump-game-ii.yaml      |  3 +-
 backend/data/questions/jump-game-vii.yaml     |  9 ++-
 backend/data/questions/jump-game.yaml         |  6 +-
 .../questions/k-closest-points-to-origin.yaml |  3 +-
 .../data/questions/koko-eating-bananas.yaml   |  3 +-
 .../kth-largest-element-in-a-stream.yaml      |  3 +-
 .../kth-largest-element-in-an-array.yaml      | 31 ++++++-
 .../kth-smallest-element-in-a-bst.yaml        |  6 +-
 .../largest-rectangle-in-histogram.yaml       |  3 +-
 .../data/questions/last-stone-weight-ii.yaml  |  3 +-
 backend/data/questions/last-stone-weight.yaml |  3 +-
 backend/data/questions/lemonade-change.yaml   |  3 +-
 ...letter-combinations-of-a-phone-number.yaml |  3 +-
 backend/data/questions/lfu-cache.yaml         |  3 +-
 backend/data/questions/linked-list-cycle.yaml |  3 +-
 .../data/questions/longest-common-prefix.yaml |  3 +-
 .../questions/longest-common-subsequence.yaml |  3 +-
 .../longest-consecutive-sequence.yaml         |  3 +-
 .../data/questions/longest-happy-string.yaml  |  6 +-
 .../longest-increasing-path-in-a-matrix.yaml  |  9 ++-
 .../longest-increasing-subsequence.yaml       |  6 +-
 .../longest-palindromic-substring.yaml        |  6 +-
 .../longest-substring-without-repeating.yaml  |  3 +-
 .../questions/longest-turbulent-subarray.yaml |  6 +-
 .../questions/longest-valid-parentheses.yaml  |  6 +-
 ...mmon-ancestor-of-a-binary-search-tree.yaml |  6 +-
 backend/data/questions/lru-cache.yaml         |  3 +-
 .../data/questions/majority-element-ii.yaml   |  3 +-
 backend/data/questions/majority-element.yaml  |  3 +-
 .../data/questions/matchsticks-to-square.yaml |  3 +-
 .../data/questions/max-area-of-island.yaml    |  9 ++-
 .../maximum-depth-of-binary-tree.yaml         |  9 ++-
 .../questions/maximum-frequency-stack.yaml    |  5 +-
 ...ruits-harvested-after-at-most-k-steps.yaml |  9 ++-
 .../maximum-length-of-pair-chain.yaml         |  6 +-
 .../questions/maximum-product-subarray.yaml   |  3 +-
 backend/data/questions/maximum-subarray.yaml  |  3 +-
 .../maximum-sum-circular-subarray.yaml        |  3 +-
 .../median-of-two-sorted-arrays.yaml          |  3 +-
 backend/data/questions/merge-intervals.yaml   |  3 +-
 .../data/questions/merge-k-sorted-lists.yaml  |  3 +-
 .../data/questions/merge-sorted-array.yaml    |  3 +-
 .../questions/merge-strings-alternately.yaml  |  3 +-
 ...merge-triplets-to-form-target-triplet.yaml |  3 +-
 .../questions/merge-two-sorted-lists.yaml     |  3 +-
 .../questions/min-cost-climbing-stairs.yaml   |  3 +-
 .../min-cost-to-connect-all-points.yaml       |  6 +-
 backend/data/questions/min-stack.yaml         |  3 +-
 .../data/questions/minimum-height-trees.yaml  |  6 +-
 ...inimum-interval-to-include-each-query.yaml |  3 +-
 backend/data/questions/minimum-path-sum.yaml  |  6 +-
 .../questions/minimum-size-subarray-sum.yaml  |  9 ++-
 .../questions/minimum-window-substring.yaml   |  3 +-
 backend/data/questions/missing-number.yaml    |  3 +-
 backend/data/questions/multiply-strings.yaml  |  3 +-
 .../data/questions/network-delay-time.yaml    | 30 ++++++-
 backend/data/questions/number-of-1-bits.yaml  |  4 +-
 backend/data/questions/number-of-islands.yaml |  9 ++-
 .../one-bit-and-two-bit-characters.yaml       |  3 +-
 backend/data/questions/online-stock-span.yaml |  3 +-
 backend/data/questions/open-the-lock.yaml     |  3 +-
 .../pacific-atlantic-water-flow.yaml          |  6 +-
 backend/data/questions/palindrome-number.yaml |  3 +-
 .../questions/palindrome-partitioning.yaml    |  6 +-
 .../questions/palindromic-substrings.yaml     |  6 +-
 .../questions/partition-equal-subset-sum.yaml |  3 +-
 backend/data/questions/partition-labels.yaml  |  6 +-
 .../partition-to-k-equal-sum-subsets.yaml     |  3 +-
 .../questions/path-with-minimum-effort.yaml   | 12 ++-
 backend/data/questions/perfect-squares.yaml   |  6 +-
 .../data/questions/permutation-in-string.yaml |  3 +-
 backend/data/questions/permutations-ii.yaml   |  3 +-
 backend/data/questions/permutations.yaml      |  3 +-
 backend/data/questions/plus-one.yaml          |  3 +-
 backend/data/questions/powx-n.yaml            |  3 +-
 .../product-of-array-except-self.yaml         |  3 +-
 .../data/questions/reconstruct-itinerary.yaml |  3 +-
 .../data/questions/redundant-connection.yaml  |  6 +-
 .../regular-expression-matching.yaml          |  3 +-
 .../remove-duplicates-from-sorted-array.yaml  |  3 +-
 backend/data/questions/remove-element.yaml    |  3 +-
 .../remove-nth-node-from-end-of-list.yaml     |  6 +-
 backend/data/questions/reorder-list.yaml      |  6 +-
 backend/data/questions/reorganize-string.yaml | 32 +++++++-
 backend/data/questions/reverse-bits.yaml      |  3 +-
 backend/data/questions/reverse-integer.yaml   |  3 +-
 .../questions/reverse-linked-list-ii.yaml     |  3 +-
 .../data/questions/reverse-linked-list.yaml   |  3 +-
 backend/data/questions/reverse-string.yaml    |  3 +-
 backend/data/questions/roman-to-integer.yaml  |  3 +-
 backend/data/questions/rotate-array.yaml      |  3 +-
 backend/data/questions/rotate-image.yaml      |  3 +-
 backend/data/questions/rotting-oranges.yaml   |  6 +-
 backend/data/questions/same-tree.yaml         |  6 +-
 .../data/questions/search-a-2d-matrix.yaml    |  6 +-
 .../search-in-rotated-sorted-array-ii.yaml    |  3 +-
 .../search-in-rotated-sorted-array.yaml       |  3 +-
 .../questions/search-insert-position.yaml     |  3 +-
 ...serialize-and-deserialize-binary-tree.yaml |  9 ++-
 backend/data/questions/set-matrix-zeroes.yaml |  3 +-
 backend/data/questions/simplify-path.yaml     |  3 +-
 backend/data/questions/single-number.yaml     |  3 +-
 .../questions/sliding-window-maximum.yaml     |  6 +-
 backend/data/questions/sort-an-array.yaml     |  3 +-
 backend/data/questions/sort-colors.yaml       |  3 +-
 backend/data/questions/spiral-matrix-ii.yaml  |  3 +-
 backend/data/questions/spiral-matrix.yaml     |  3 +-
 .../questions/split-array-largest-sum.yaml    |  6 +-
 backend/data/questions/sqrtx.yaml             |  3 +-
 backend/data/questions/stone-game-ii.yaml     |  6 +-
 backend/data/questions/stone-game-iii.yaml    |  3 +-
 backend/data/questions/stone-game.yaml        |  3 +-
 .../subarray-product-less-than-k.yaml         |  3 +-
 .../data/questions/subarray-sum-equals-k.yaml |  3 +-
 backend/data/questions/subsets-ii.yaml        |  3 +-
 backend/data/questions/subsets.yaml           |  3 +-
 .../questions/subtree-of-another-tree.yaml    |  6 +-
 .../data/questions/sum-of-two-integers.yaml   |  3 +-
 .../data/questions/surrounded-regions.yaml    |  9 ++-
 .../data/questions/swim-in-rising-water.yaml  |  9 ++-
 backend/data/questions/target-sum.yaml        |  6 +-
 backend/data/questions/task-scheduler.yaml    | 30 ++++++-
 backend/data/questions/three-sum-closest.yaml |  3 +-
 backend/data/questions/three-sum.yaml         |  3 +-
 .../questions/top-k-frequent-elements.yaml    | 24 +++++-
 backend/data/questions/transpose-matrix.yaml  |  3 +-
 .../data/questions/trapping-rain-water.yaml   |  6 +-
 backend/data/questions/two-sum.yaml           | 31 ++++++-
 .../unique-number-of-occurrences.yaml         |  3 +-
 backend/data/questions/unique-paths-ii.yaml   |  6 +-
 backend/data/questions/unique-paths.yaml      |  3 +-
 backend/data/questions/valid-anagram.yaml     | 32 +++++++-
 .../data/questions/valid-palindrome-ii.yaml   |  3 +-
 backend/data/questions/valid-palindrome.yaml  |  3 +-
 backend/data/questions/valid-parentheses.yaml |  3 +-
 .../questions/valid-parenthesis-string.yaml   |  6 +-
 backend/data/questions/valid-sudoku.yaml      |  3 +-
 .../validate-binary-search-tree.yaml          |  6 +-
 .../verifying-an-alien-dictionary.yaml        |  3 +-
 backend/data/questions/word-break-ii.yaml     |  6 +-
 backend/data/questions/word-break.yaml        |  3 +-
 backend/data/questions/word-ladder.yaml       |  3 +-
 backend/data/questions/word-search-ii.yaml    |  9 ++-
 backend/data/questions/word-search.yaml       |  6 +-
 402 files changed, 1383 insertions(+), 545 deletions(-)

diff --git a/backend/data/patterns/patterns.yaml b/backend/data/patterns/patterns.yaml
index 22bf10b..8184e66 100644
--- a/backend/data/patterns/patterns.yaml
+++ b/backend/data/patterns/patterns.yaml
@@ -177,3 +177,83 @@ patterns:
       - Flood fill
       - Rotting oranges
       - Word search in grid
+
+  - name: Topological Sort
+    slug: topological-sort
+    description: Order vertices in a directed acyclic graph (DAG) such that for every edge u→v, u comes before v.
+    when_to_use: |
+      - Course scheduling with prerequisites
+      - Build order / dependency resolution
+      - Task scheduling with dependencies
+      - Alien dictionary problems
+      - Detecting cycles in directed graphs
+
+  - name: Bit Manipulation
+    slug: bit-manipulation
+    description: Use bitwise operations (AND, OR, XOR, shifts) to solve problems efficiently.
+    when_to_use: |
+      - Finding single/missing numbers (XOR tricks)
+      - Counting set bits
+      - Power of two checks
+      - Subset generation with bitmasks
+      - Swapping without temp variable
+
+  - name: Counting / Bucket Sort
+    slug: counting-sort
+    description: Sort or process elements by using their values as indices when the range is bounded.
+    when_to_use: |
+      - Top K frequent elements (bounded frequency range)
+      - Sort Colors (Dutch National Flag)
+      - H-Index calculation
+      - Problems where values are in known small range
+      - Frequency-based grouping
+
+  - name: Cyclic Sort
+    slug: cyclic-sort
+    description: Place each element at its correct index when values are in range [1, n] or [0, n-1].
+    when_to_use: |
+      - Find missing number in [1, n]
+      - Find duplicate in [1, n]
+      - Find all missing/duplicate numbers
+      - First missing positive
+      - Set mismatch problems
+
+  - name: Divide and Conquer
+    slug: divide-and-conquer
+    description: Split problem into smaller subproblems, solve recursively, and combine results.
+    when_to_use: |
+      - Merge sort and related problems
+      - Quick select for kth element
+      - Binary search variants
+      - Matrix multiplication
+      - Closest pair of points
+
+  - name: Hashing
+    slug: hashing
+    description: Use hash tables for O(1) average lookup, insertion, and deletion.
+    when_to_use: |
+      - Two Sum and variants
+      - Detecting duplicates
+      - Frequency counting
+      - Anagram grouping
+      - LRU/LFU cache implementation
+
+  - name: Matrix Manipulation
+    slug: matrix-manipulation
+    description: Transform or process 2D matrices using rotation, transposition, or in-place modifications.
+    when_to_use: |
+      - Rotate image 90 degrees
+      - Spiral matrix traversal
+      - Set matrix zeroes
+      - Transpose matrix
+      - Game of Life state updates
+
+  - name: Synchronization
+    slug: synchronization
+    description: Coordinate multiple threads or processes using locks, semaphores, or barriers.
+    when_to_use: |
+      - Print in order problems
+      - Producer-consumer patterns
+      - Dining philosophers
+      - Building H2O molecules
+      - Concurrent data structure design
diff --git a/backend/data/questions/01-matrix.yaml b/backend/data/questions/01-matrix.yaml
index eead7b6..c0008b9 100644
--- a/backend/data/questions/01-matrix.yaml
+++ b/backend/data/questions/01-matrix.yaml
@@ -7,9 +7,12 @@ categories:
   - arrays
   - graphs
 patterns:
-  - bfs
-  - matrix-traversal
-  - dynamic-programming
+  - slug: bfs
+    is_optimal: true
+  - slug: matrix-traversal
+    is_optimal: false
+  - slug: dynamic-programming
+    is_optimal: false
 
 function_signature: "def update_matrix(mat: list[list[int]]) -> list[list[int]]:"
 
diff --git a/backend/data/questions/132-pattern.yaml b/backend/data/questions/132-pattern.yaml
index edaf703..b08b200 100644
--- a/backend/data/questions/132-pattern.yaml
+++ b/backend/data/questions/132-pattern.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - stack
 patterns:
-  - monotonic-stack
+  - slug: monotonic-stack
+    is_optimal: true
 
 function_signature: "def find132pattern(nums: list[int]) -> bool:"
 
diff --git a/backend/data/questions/2-keys-keyboard.yaml b/backend/data/questions/2-keys-keyboard.yaml
index b2805fd..b92edb2 100644
--- a/backend/data/questions/2-keys-keyboard.yaml
+++ b/backend/data/questions/2-keys-keyboard.yaml
@@ -7,7 +7,8 @@ categories:
   - dynamic-programming
   - math
 patterns:
-  - dynamic-programming
+  - slug: dynamic-programming
+    is_optimal: true
 
 function_signature: "def min_steps(n: int) -> int:"
 
diff --git a/backend/data/questions/24-game.yaml b/backend/data/questions/24-game.yaml
index 072c37b..96e6ecb 100644
--- a/backend/data/questions/24-game.yaml
+++ b/backend/data/questions/24-game.yaml
@@ -8,7 +8,8 @@ categories:
   - math
   - recursion
 patterns:
-  - backtracking
+  - slug: backtracking
+    is_optimal: true
 
 function_signature: "def judge_point24(cards: list[int]) -> bool:"
 
diff --git a/backend/data/questions/3sum-with-multiplicity.yaml b/backend/data/questions/3sum-with-multiplicity.yaml
index f4233b3..e0f1b41 100644
--- a/backend/data/questions/3sum-with-multiplicity.yaml
+++ b/backend/data/questions/3sum-with-multiplicity.yaml
@@ -8,7 +8,8 @@ categories:
   - hash-tables
   - two-pointers
 patterns:
-  - two-pointers
+  - slug: counting-sort
+    is_optimal: true
 
 function_signature: "def three_sum_multi(arr: list[int], target: int) -> int:"
 
diff --git a/backend/data/questions/4sum-ii.yaml b/backend/data/questions/4sum-ii.yaml
index 4b9c203..2bc1f20 100644
--- a/backend/data/questions/4sum-ii.yaml
+++ b/backend/data/questions/4sum-ii.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - hash-tables
 patterns:
-  - two-pointers
+  - slug: hashing
+    is_optimal: true
 
 function_signature: "def four_sum_count(nums1: list[int], nums2: list[int], nums3: list[int], nums4: list[int]) -> int:"
 
diff --git a/backend/data/questions/a-number-after-a-double-reversal.yaml b/backend/data/questions/a-number-after-a-double-reversal.yaml
index d3d59dd..bd0d25b 100644
--- a/backend/data/questions/a-number-after-a-double-reversal.yaml
+++ b/backend/data/questions/a-number-after-a-double-reversal.yaml
@@ -6,7 +6,8 @@ leetcode_url: https://leetcode.com/problems/a-number-after-a-double-reversal/
 categories:
   - math
 patterns:
-  - greedy
+  - slug: greedy
+    is_optimal: true
 
 function_signature: "def is_same_after_reversals(num: int) -> bool:"
 
diff --git a/backend/data/questions/accounts-merge.yaml b/backend/data/questions/accounts-merge.yaml
index b7ac21d..08264f7 100644
--- a/backend/data/questions/accounts-merge.yaml
+++ b/backend/data/questions/accounts-merge.yaml
@@ -8,8 +8,10 @@ categories:
   - hash-tables
   - strings
 patterns:
-  - union-find
-  - dfs
+  - slug: union-find
+    is_optimal: true
+  - slug: dfs
+    is_optimal: false
 
 function_signature: "def accounts_merge(accounts: list[list[str]]) -> list[list[str]]:"
 
diff --git a/backend/data/questions/add-binary.yaml b/backend/data/questions/add-binary.yaml
index ae1e40f..a79a608 100644
--- a/backend/data/questions/add-binary.yaml
+++ b/backend/data/questions/add-binary.yaml
@@ -7,7 +7,8 @@ categories:
   - strings
   - math
 patterns:
-  - two-pointers
+  - slug: two-pointers
+    is_optimal: true
 
 function_signature: "def add_binary(a: str, b: str) -> str:"
 
diff --git a/backend/data/questions/add-digits.yaml b/backend/data/questions/add-digits.yaml
index d2b438d..bfb3635 100644
--- a/backend/data/questions/add-digits.yaml
+++ b/backend/data/questions/add-digits.yaml
@@ -6,7 +6,8 @@ leetcode_url: https://leetcode.com/problems/add-digits/
 categories:
   - math
 patterns:
-  - greedy
+  - slug: greedy
+    is_optimal: true
 
 function_signature: "def add_digits(num: int) -> int:"
 
diff --git a/backend/data/questions/add-minimum-number-of-rungs.yaml b/backend/data/questions/add-minimum-number-of-rungs.yaml
index 68c8faf..fde3249 100644
--- a/backend/data/questions/add-minimum-number-of-rungs.yaml
+++ b/backend/data/questions/add-minimum-number-of-rungs.yaml
@@ -6,7 +6,8 @@ leetcode_url: https://leetcode.com/problems/add-minimum-number-of-rungs/
 categories:
   - arrays
 patterns:
-  - greedy
+  - slug: greedy
+    is_optimal: true
 
 function_signature: "def add_rungs(rungs: list[int], dist: int) -> int:"
 
diff --git a/backend/data/questions/add-one-row-to-tree.yaml b/backend/data/questions/add-one-row-to-tree.yaml
index 1ef18e6..b0bc437 100644
--- a/backend/data/questions/add-one-row-to-tree.yaml
+++ b/backend/data/questions/add-one-row-to-tree.yaml
@@ -8,9 +8,12 @@ categories:
   - queue
   - recursion
 patterns:
-  - bfs
-  - dfs
-  - tree-traversal
+  - slug: bfs
+    is_optimal: true
+  - slug: dfs
+    is_optimal: false
+  - slug: tree-traversal
+    is_optimal: false
 
 function_signature: "def add_one_row(root: TreeNode, val: int, depth: int) -> TreeNode:"
 
diff --git a/backend/data/questions/add-strings.yaml b/backend/data/questions/add-strings.yaml
index b20e3da..1317efa 100644
--- a/backend/data/questions/add-strings.yaml
+++ b/backend/data/questions/add-strings.yaml
@@ -7,7 +7,8 @@ categories:
   - strings
   - math
 patterns:
-  - two-pointers
+  - slug: two-pointers
+    is_optimal: true
 
 function_signature: "def add_strings(num1: str, num2: str) -> str:"
 
diff --git a/backend/data/questions/add-to-array-form-of-integer.yaml b/backend/data/questions/add-to-array-form-of-integer.yaml
index 251c4e0..5e374d8 100644
--- a/backend/data/questions/add-to-array-form-of-integer.yaml
+++ b/backend/data/questions/add-to-array-form-of-integer.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - math
 patterns:
-  - two-pointers
+  - slug: two-pointers
+    is_optimal: true
 
 function_signature: "def add_to_array_form(num: list[int], k: int) -> list[int]:"
 
diff --git a/backend/data/questions/add-two-integers.yaml b/backend/data/questions/add-two-integers.yaml
index 57b7891..b4b21e6 100644
--- a/backend/data/questions/add-two-integers.yaml
+++ b/backend/data/questions/add-two-integers.yaml
@@ -5,7 +5,9 @@ leetcode_id: 2235
 leetcode_url: https://leetcode.com/problems/add-two-integers/
 categories:
   - math
-patterns: []
+patterns:
+  - slug: bit-manipulation
+    is_optimal: true
 
 function_signature: "def sum(num1: int, num2: int) -> int:"
 
diff --git a/backend/data/questions/add-two-numbers-ii.yaml b/backend/data/questions/add-two-numbers-ii.yaml
index 6974047..cffd810 100644
--- a/backend/data/questions/add-two-numbers-ii.yaml
+++ b/backend/data/questions/add-two-numbers-ii.yaml
@@ -8,7 +8,8 @@ categories:
   - stack
   - math
 patterns:
-  - linkedlist-reversal
+  - slug: linkedlist-reversal
+    is_optimal: true
 
 function_signature: "def add_two_numbers(l1: ListNode, l2: ListNode) -> ListNode:"
 
diff --git a/backend/data/questions/add-two-numbers.yaml b/backend/data/questions/add-two-numbers.yaml
index b1aa5a5..3b884f1 100644
--- a/backend/data/questions/add-two-numbers.yaml
+++ b/backend/data/questions/add-two-numbers.yaml
@@ -7,7 +7,8 @@ categories:
   - linked-lists
   - math
 patterns:
-  - two-pointers
+  - slug: two-pointers
+    is_optimal: true
 
 function_signature: "def add_two_numbers(l1: ListNode | None, l2: ListNode | None) -> ListNode | None:"
 
diff --git a/backend/data/questions/adding-spaces-to-a-string.yaml b/backend/data/questions/adding-spaces-to-a-string.yaml
index da1b946..49de7b2 100644
--- a/backend/data/questions/adding-spaces-to-a-string.yaml
+++ b/backend/data/questions/adding-spaces-to-a-string.yaml
@@ -8,7 +8,8 @@ categories:
   - arrays
   - two-pointers
 patterns:
-  - two-pointers
+  - slug: two-pointers
+    is_optimal: true
 
 function_signature: "def add_spaces(s: str, spaces: list[int]) -> str:"
 
diff --git a/backend/data/questions/adding-two-negabinary-numbers.yaml b/backend/data/questions/adding-two-negabinary-numbers.yaml
index 8840023..3a07d57 100644
--- a/backend/data/questions/adding-two-negabinary-numbers.yaml
+++ b/backend/data/questions/adding-two-negabinary-numbers.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - math
 patterns:
-  - two-pointers
+  - slug: two-pointers
+    is_optimal: true
 
 function_signature: "def add_negabinary(arr1: list[int], arr2: list[int]) -> list[int]:"
 
diff --git a/backend/data/questions/additive-number.yaml b/backend/data/questions/additive-number.yaml
index de8cc5e..403398b 100644
--- a/backend/data/questions/additive-number.yaml
+++ b/backend/data/questions/additive-number.yaml
@@ -7,7 +7,8 @@ categories:
   - strings
   - recursion
 patterns:
-  - backtracking
+  - slug: backtracking
+    is_optimal: true
 
 function_signature: "def is_additive_number(num: str) -> bool:"
 
diff --git a/backend/data/questions/advantage-shuffle.yaml b/backend/data/questions/advantage-shuffle.yaml
index 0e00da8..1eda83b 100644
--- a/backend/data/questions/advantage-shuffle.yaml
+++ b/backend/data/questions/advantage-shuffle.yaml
@@ -7,8 +7,10 @@ categories:
   - arrays
   - sorting
 patterns:
-  - greedy
-  - two-pointers
+  - slug: greedy
+    is_optimal: false
+  - slug: two-pointers
+    is_optimal: true
 
 function_signature: "def advantage_count(nums1: list[int], nums2: list[int]) -> list[int]:"
 
diff --git a/backend/data/questions/airplane-seat-assignment-probability.yaml b/backend/data/questions/airplane-seat-assignment-probability.yaml
index 0cc152e..5bf35d3 100644
--- a/backend/data/questions/airplane-seat-assignment-probability.yaml
+++ b/backend/data/questions/airplane-seat-assignment-probability.yaml
@@ -7,7 +7,8 @@ categories:
   - math
   - dynamic-programming
 patterns:
-  - dynamic-programming
+  - slug: dynamic-programming
+    is_optimal: true
 
 function_signature: "def nth_person_gets_nth_seat(n: int) -> float:"
 
diff --git a/backend/data/questions/alert-using-same-key.yaml b/backend/data/questions/alert-using-same-key.yaml
index 1cc7b0d..4030e67 100644
--- a/backend/data/questions/alert-using-same-key.yaml
+++ b/backend/data/questions/alert-using-same-key.yaml
@@ -9,7 +9,8 @@ categories:
   - strings
   - sorting
 patterns:
-  - sliding-window
+  - slug: sliding-window
+    is_optimal: true
 
 function_signature: "def alert_names(key_name: list[str], key_time: list[str]) -> list[str]:"
 
diff --git a/backend/data/questions/all-divisions-with-highest-score-of-binary-array.yaml b/backend/data/questions/all-divisions-with-highest-score-of-binary-array.yaml
index c0dacb0..518c5ea 100644
--- a/backend/data/questions/all-divisions-with-highest-score-of-binary-array.yaml
+++ b/backend/data/questions/all-divisions-with-highest-score-of-binary-array.yaml
@@ -6,7 +6,8 @@ leetcode_url: https://leetcode.com/problems/all-divisions-with-the-highest-score
 categories:
   - arrays
 patterns:
-  - prefix-sum
+  - slug: prefix-sum
+    is_optimal: true
 
 function_signature: "def max_score_indices(nums: list[int]) -> list[int]:"
 
diff --git a/backend/data/questions/all-elements-in-two-binary-search-trees.yaml b/backend/data/questions/all-elements-in-two-binary-search-trees.yaml
index 085ce04..32d2137 100644
--- a/backend/data/questions/all-elements-in-two-binary-search-trees.yaml
+++ b/backend/data/questions/all-elements-in-two-binary-search-trees.yaml
@@ -7,8 +7,10 @@ categories:
   - trees
   - sorting
 patterns:
-  - tree-traversal
-  - two-pointers
+  - slug: tree-traversal
+    is_optimal: false
+  - slug: two-pointers
+    is_optimal: true
 
 function_signature: "def get_all_elements(root1: TreeNode, root2: TreeNode) -> list[int]:"
 
diff --git a/backend/data/questions/all-nodes-distance-k-in-binary-tree.yaml b/backend/data/questions/all-nodes-distance-k-in-binary-tree.yaml
index 40cba3c..14ddb3c 100644
--- a/backend/data/questions/all-nodes-distance-k-in-binary-tree.yaml
+++ b/backend/data/questions/all-nodes-distance-k-in-binary-tree.yaml
@@ -8,8 +8,10 @@ categories:
   - graphs
   - hash-tables
 patterns:
-  - bfs
-  - dfs
+  - slug: bfs
+    is_optimal: true
+  - slug: dfs
+    is_optimal: false
 
 function_signature: "def distance_k(root: TreeNode, target: TreeNode, k: int) -> list[int]:"
 
diff --git a/backend/data/questions/all-paths-from-source-to-target.yaml b/backend/data/questions/all-paths-from-source-to-target.yaml
index cbcca31..324351d 100644
--- a/backend/data/questions/all-paths-from-source-to-target.yaml
+++ b/backend/data/questions/all-paths-from-source-to-target.yaml
@@ -7,8 +7,10 @@ categories:
   - graphs
   - recursion
 patterns:
-  - dfs
-  - backtracking
+  - slug: dfs
+    is_optimal: true
+  - slug: backtracking
+    is_optimal: false
 
 function_signature: "def all_paths_source_target(graph: list[list[int]]) -> list[list[int]]:"
 
diff --git a/backend/data/questions/all-possible-full-binary-trees.yaml b/backend/data/questions/all-possible-full-binary-trees.yaml
index ab90a9f..d475468 100644
--- a/backend/data/questions/all-possible-full-binary-trees.yaml
+++ b/backend/data/questions/all-possible-full-binary-trees.yaml
@@ -8,8 +8,10 @@ categories:
   - recursion
   - dynamic-programming
 patterns:
-  - backtracking
-  - dynamic-programming
+  - slug: backtracking
+    is_optimal: false
+  - slug: dynamic-programming
+    is_optimal: true
 
 function_signature: "def all_possible_fbt(n: int) -> list[TreeNode]:"
 
diff --git a/backend/data/questions/allocate-mailboxes.yaml b/backend/data/questions/allocate-mailboxes.yaml
index 20d7a9f..9bd676d 100644
--- a/backend/data/questions/allocate-mailboxes.yaml
+++ b/backend/data/questions/allocate-mailboxes.yaml
@@ -9,7 +9,8 @@ categories:
   - sorting
   - math
 patterns:
-  - dynamic-programming
+  - slug: dynamic-programming
+    is_optimal: true
 
 function_signature: "def min_distance(houses: list[int], k: int) -> int:"
 
diff --git a/backend/data/questions/alphabet-board-path.yaml b/backend/data/questions/alphabet-board-path.yaml
index 1666797..002ae1d 100644
--- a/backend/data/questions/alphabet-board-path.yaml
+++ b/backend/data/questions/alphabet-board-path.yaml
@@ -7,7 +7,8 @@ categories:
   - strings
   - hash-tables
 patterns:
-  - matrix-traversal
+  - slug: matrix-traversal
+    is_optimal: true
 
 function_signature: "def alphabet_board_path(target: str) -> str:"
 
diff --git a/backend/data/questions/alternating-digit-sum.yaml b/backend/data/questions/alternating-digit-sum.yaml
index 40a4a68..3d30bf5 100644
--- a/backend/data/questions/alternating-digit-sum.yaml
+++ b/backend/data/questions/alternating-digit-sum.yaml
@@ -6,7 +6,8 @@ leetcode_url: https://leetcode.com/problems/alternating-digit-sum/
 categories:
   - math
 patterns:
-  - greedy
+  - slug: greedy
+    is_optimal: true
 
 function_signature: "def alternate_digit_sum(n: int) -> int:"
 
diff --git a/backend/data/questions/ambiguous-coordinates.yaml b/backend/data/questions/ambiguous-coordinates.yaml
index ea652fb..fe84e1f 100644
--- a/backend/data/questions/ambiguous-coordinates.yaml
+++ b/backend/data/questions/ambiguous-coordinates.yaml
@@ -7,7 +7,8 @@ categories:
   - strings
   - recursion
 patterns:
-  - backtracking
+  - slug: backtracking
+    is_optimal: true
 
 function_signature: "def ambiguous_coordinates(s: str) -> list[str]:"
 
diff --git a/backend/data/questions/amount-of-time-for-binary-tree-to-be-infected.yaml b/backend/data/questions/amount-of-time-for-binary-tree-to-be-infected.yaml
index 7537455..4e4fca2 100644
--- a/backend/data/questions/amount-of-time-for-binary-tree-to-be-infected.yaml
+++ b/backend/data/questions/amount-of-time-for-binary-tree-to-be-infected.yaml
@@ -8,8 +8,10 @@ categories:
   - graphs
   - hash-tables
 patterns:
-  - bfs
-  - tree-traversal
+  - slug: bfs
+    is_optimal: true
+  - slug: tree-traversal
+    is_optimal: false
 
 function_signature: "def amount_of_time(root: TreeNode, start: int) -> int:"
 
diff --git a/backend/data/questions/angle-between-hands-of-a-clock.yaml b/backend/data/questions/angle-between-hands-of-a-clock.yaml
index 00d5ba4..28e3a00 100644
--- a/backend/data/questions/angle-between-hands-of-a-clock.yaml
+++ b/backend/data/questions/angle-between-hands-of-a-clock.yaml
@@ -6,7 +6,8 @@ leetcode_url: https://leetcode.com/problems/angle-between-hands-of-a-clock/
 categories:
   - math
 patterns:
-  - greedy
+  - slug: greedy
+    is_optimal: true
 
 function_signature: "def angle_clock(hour: int, minutes: int) -> float:"
 
diff --git a/backend/data/questions/append-characters-to-string-to-make-subsequence.yaml b/backend/data/questions/append-characters-to-string-to-make-subsequence.yaml
index e901ccd..33f1fd3 100644
--- a/backend/data/questions/append-characters-to-string-to-make-subsequence.yaml
+++ b/backend/data/questions/append-characters-to-string-to-make-subsequence.yaml
@@ -7,8 +7,10 @@ categories:
   - strings
   - two-pointers
 patterns:
-  - two-pointers
-  - greedy
+  - slug: two-pointers
+    is_optimal: true
+  - slug: greedy
+    is_optimal: false
 
 function_signature: "def append_characters(s: str, t: str) -> int:"
 
diff --git a/backend/data/questions/append-k-integers-with-minimal-sum.yaml b/backend/data/questions/append-k-integers-with-minimal-sum.yaml
index fc6a983..e25a9ff 100644
--- a/backend/data/questions/append-k-integers-with-minimal-sum.yaml
+++ b/backend/data/questions/append-k-integers-with-minimal-sum.yaml
@@ -8,7 +8,8 @@ categories:
   - math
   - sorting
 patterns:
-  - greedy
+  - slug: greedy
+    is_optimal: true
 
 function_signature: "def min_sum(nums: list[int], k: int) -> int:"
 
diff --git a/backend/data/questions/apply-bitwise-operations-to-make-strings-equal.yaml b/backend/data/questions/apply-bitwise-operations-to-make-strings-equal.yaml
index 4832af6..66bb2b3 100644
--- a/backend/data/questions/apply-bitwise-operations-to-make-strings-equal.yaml
+++ b/backend/data/questions/apply-bitwise-operations-to-make-strings-equal.yaml
@@ -7,7 +7,8 @@ categories:
   - strings
   - math
 patterns:
-  - greedy
+  - slug: greedy
+    is_optimal: true
 
 function_signature: "def make_strings_equal(s: str, target: str) -> bool:"
 
diff --git a/backend/data/questions/apply-operations-to-an-array.yaml b/backend/data/questions/apply-operations-to-an-array.yaml
index 0cb5f33..06811b8 100644
--- a/backend/data/questions/apply-operations-to-an-array.yaml
+++ b/backend/data/questions/apply-operations-to-an-array.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - two-pointers
 patterns:
-  - two-pointers
+  - slug: two-pointers
+    is_optimal: true
 
 function_signature: "def apply_operations(nums: list[int]) -> list[int]:"
 
diff --git a/backend/data/questions/arithmetic-slices-ii-subsequence.yaml b/backend/data/questions/arithmetic-slices-ii-subsequence.yaml
index 4f42a50..6d198cd 100644
--- a/backend/data/questions/arithmetic-slices-ii-subsequence.yaml
+++ b/backend/data/questions/arithmetic-slices-ii-subsequence.yaml
@@ -8,7 +8,8 @@ categories:
   - dynamic-programming
   - hash-tables
 patterns:
-  - dynamic-programming
+  - slug: dynamic-programming
+    is_optimal: true
 
 function_signature: "def number_of_arithmetic_slices(nums: list[int]) -> int:"
 
diff --git a/backend/data/questions/arithmetic-slices.yaml b/backend/data/questions/arithmetic-slices.yaml
index 23ce000..503c5c9 100644
--- a/backend/data/questions/arithmetic-slices.yaml
+++ b/backend/data/questions/arithmetic-slices.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - dynamic-programming
 patterns:
-  - dynamic-programming
+  - slug: dynamic-programming
+    is_optimal: true
 
 function_signature: "def number_of_arithmetic_slices(nums: list[int]) -> int:"
 
diff --git a/backend/data/questions/arithmetic-subarrays.yaml b/backend/data/questions/arithmetic-subarrays.yaml
index 4b1d252..a15dfdd 100644
--- a/backend/data/questions/arithmetic-subarrays.yaml
+++ b/backend/data/questions/arithmetic-subarrays.yaml
@@ -8,7 +8,8 @@ categories:
   - hash-tables
   - sorting
 patterns:
-  - two-pointers
+  - slug: two-pointers
+    is_optimal: true
 
 function_signature: "def check_arithmetic_subarrays(nums: list[int], l: list[int], r: list[int]) -> list[bool]:"
 
diff --git a/backend/data/questions/arranging-coins.yaml b/backend/data/questions/arranging-coins.yaml
index 9595c87..b790d6d 100644
--- a/backend/data/questions/arranging-coins.yaml
+++ b/backend/data/questions/arranging-coins.yaml
@@ -7,7 +7,8 @@ categories:
   - math
   - binary-search
 patterns:
-  - binary-search
+  - slug: binary-search
+    is_optimal: true
 
 function_signature: "def arrange_coins(n: int) -> int:"
 
diff --git a/backend/data/questions/array-nesting.yaml b/backend/data/questions/array-nesting.yaml
index fa8fa93..b484a67 100644
--- a/backend/data/questions/array-nesting.yaml
+++ b/backend/data/questions/array-nesting.yaml
@@ -6,7 +6,8 @@ leetcode_url: https://leetcode.com/problems/array-nesting/
 categories:
   - arrays
 patterns:
-  - dfs
+  - slug: dfs
+    is_optimal: true
 
 function_signature: "def array_nesting(nums: list[int]) -> int:"
 
diff --git a/backend/data/questions/array-of-doubled-pairs.yaml b/backend/data/questions/array-of-doubled-pairs.yaml
index fbf1092..0ab67a5 100644
--- a/backend/data/questions/array-of-doubled-pairs.yaml
+++ b/backend/data/questions/array-of-doubled-pairs.yaml
@@ -8,7 +8,8 @@ categories:
   - hash-tables
   - sorting
 patterns:
-  - greedy
+  - slug: greedy
+    is_optimal: true
 
 function_signature: "def can_reorder_doubled(arr: list[int]) -> bool:"
 
diff --git a/backend/data/questions/array-partition.yaml b/backend/data/questions/array-partition.yaml
index 86110e8..838295c 100644
--- a/backend/data/questions/array-partition.yaml
+++ b/backend/data/questions/array-partition.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - sorting
 patterns:
-  - greedy
+  - slug: greedy
+    is_optimal: true
 
 function_signature: "def array_pair_sum(nums: list[int]) -> int:"
 
diff --git a/backend/data/questions/array-with-elements-not-equal-to-average-of-neighbors.yaml b/backend/data/questions/array-with-elements-not-equal-to-average-of-neighbors.yaml
index 590534d..c4705df 100644
--- a/backend/data/questions/array-with-elements-not-equal-to-average-of-neighbors.yaml
+++ b/backend/data/questions/array-with-elements-not-equal-to-average-of-neighbors.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - sorting
 patterns:
-  - greedy
+  - slug: greedy
+    is_optimal: true
 
 function_signature: "def rearrange_array(nums: list[int]) -> list[int]:"
 
diff --git a/backend/data/questions/as-far-from-land-as-possible.yaml b/backend/data/questions/as-far-from-land-as-possible.yaml
index d6fdc61..9898fab 100644
--- a/backend/data/questions/as-far-from-land-as-possible.yaml
+++ b/backend/data/questions/as-far-from-land-as-possible.yaml
@@ -7,8 +7,10 @@ categories:
   - arrays
   - graphs
 patterns:
-  - bfs
-  - matrix-traversal
+  - slug: bfs
+    is_optimal: true
+  - slug: matrix-traversal
+    is_optimal: false
 
 function_signature: "def max_distance(grid: list[list[int]]) -> int:"
 
diff --git a/backend/data/questions/assign-cookies.yaml b/backend/data/questions/assign-cookies.yaml
index bf66f80..5545afc 100644
--- a/backend/data/questions/assign-cookies.yaml
+++ b/backend/data/questions/assign-cookies.yaml
@@ -8,8 +8,10 @@ categories:
   - sorting
   - two-pointers
 patterns:
-  - greedy
-  - two-pointers
+  - slug: greedy
+    is_optimal: false
+  - slug: two-pointers
+    is_optimal: true
 
 function_signature: "def find_content_children(g: list[int], s: list[int]) -> int:"
 
diff --git a/backend/data/questions/asteroid-collision.yaml b/backend/data/questions/asteroid-collision.yaml
index 9a51ad5..ac18d60 100644
--- a/backend/data/questions/asteroid-collision.yaml
+++ b/backend/data/questions/asteroid-collision.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - stack
 patterns:
-  - monotonic-stack
+  - slug: monotonic-stack
+    is_optimal: true
 
 function_signature: "def asteroid_collision(asteroids: list[int]) -> list[int]:"
 
diff --git a/backend/data/questions/available-captures-for-rook.yaml b/backend/data/questions/available-captures-for-rook.yaml
index 761489e..8645d55 100644
--- a/backend/data/questions/available-captures-for-rook.yaml
+++ b/backend/data/questions/available-captures-for-rook.yaml
@@ -6,7 +6,8 @@ leetcode_url: https://leetcode.com/problems/available-captures-for-rook/
 categories:
   - arrays
 patterns:
-  - matrix-traversal
+  - slug: matrix-traversal
+    is_optimal: true
 
 function_signature: "def num_rook_captures(board: list[list[str]]) -> int:"
 
diff --git a/backend/data/questions/average-of-levels-in-binary-tree.yaml b/backend/data/questions/average-of-levels-in-binary-tree.yaml
index 1136a99..8609052 100644
--- a/backend/data/questions/average-of-levels-in-binary-tree.yaml
+++ b/backend/data/questions/average-of-levels-in-binary-tree.yaml
@@ -7,8 +7,10 @@ categories:
   - trees
   - queue
 patterns:
-  - bfs
-  - tree-traversal
+  - slug: bfs
+    is_optimal: true
+  - slug: tree-traversal
+    is_optimal: false
 
 function_signature: "def average_of_levels(root: TreeNode) -> list[float]:"
 
diff --git a/backend/data/questions/average-salary-excluding-minimum-and-maximum.yaml b/backend/data/questions/average-salary-excluding-minimum-and-maximum.yaml
index b882fda..081c2e3 100644
--- a/backend/data/questions/average-salary-excluding-minimum-and-maximum.yaml
+++ b/backend/data/questions/average-salary-excluding-minimum-and-maximum.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - sorting
 patterns:
-  - greedy
+  - slug: greedy
+    is_optimal: true
 
 function_signature: "def average(salary: list[int]) -> float:"
 
diff --git a/backend/data/questions/average-value-of-even-numbers-divisible-by-three.yaml b/backend/data/questions/average-value-of-even-numbers-divisible-by-three.yaml
index c81bb44..b1cce71 100644
--- a/backend/data/questions/average-value-of-even-numbers-divisible-by-three.yaml
+++ b/backend/data/questions/average-value-of-even-numbers-divisible-by-three.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - math
 patterns:
-  - prefix-sum
+  - slug: prefix-sum
+    is_optimal: true
 
 function_signature: "def average_value(nums: list[int]) -> int:"
 
diff --git a/backend/data/questions/average-waiting-time.yaml b/backend/data/questions/average-waiting-time.yaml
index dad8f46..ec5a676 100644
--- a/backend/data/questions/average-waiting-time.yaml
+++ b/backend/data/questions/average-waiting-time.yaml
@@ -6,7 +6,8 @@ leetcode_url: https://leetcode.com/problems/average-waiting-time/
 categories:
   - arrays
 patterns:
-  - greedy
+  - slug: greedy
+    is_optimal: true
 
 function_signature: "def average_waiting_time(customers: list[list[int]]) -> float:"
 
diff --git a/backend/data/questions/avoid-flood-in-the-city.yaml b/backend/data/questions/avoid-flood-in-the-city.yaml
index 4432b00..05e75d2 100644
--- a/backend/data/questions/avoid-flood-in-the-city.yaml
+++ b/backend/data/questions/avoid-flood-in-the-city.yaml
@@ -7,8 +7,10 @@ categories:
   - arrays
   - hash-tables
 patterns:
-  - greedy
-  - binary-search
+  - slug: greedy
+    is_optimal: false
+  - slug: binary-search
+    is_optimal: true
 
 function_signature: "def avoid_flood(rains: list[int]) -> list[int]:"
 
diff --git a/backend/data/questions/backspace-string-compare.yaml b/backend/data/questions/backspace-string-compare.yaml
index a6fd149..1277267 100644
--- a/backend/data/questions/backspace-string-compare.yaml
+++ b/backend/data/questions/backspace-string-compare.yaml
@@ -8,7 +8,8 @@ categories:
   - stack
   - two-pointers
 patterns:
-  - two-pointers
+  - slug: two-pointers
+    is_optimal: true
 
 function_signature: "def backspace_compare(s: str, t: str) -> bool:"
 
diff --git a/backend/data/questions/bag-of-tokens.yaml b/backend/data/questions/bag-of-tokens.yaml
index 327227e..01c71f5 100644
--- a/backend/data/questions/bag-of-tokens.yaml
+++ b/backend/data/questions/bag-of-tokens.yaml
@@ -8,8 +8,10 @@ categories:
   - sorting
   - two-pointers
 patterns:
-  - two-pointers
-  - greedy
+  - slug: two-pointers
+    is_optimal: true
+  - slug: greedy
+    is_optimal: false
 
 function_signature: "def bag_of_tokens_score(tokens: list[int], power: int) -> int:"
 
diff --git a/backend/data/questions/balance-a-binary-search-tree.yaml b/backend/data/questions/balance-a-binary-search-tree.yaml
index b7791ab..869d3ef 100644
--- a/backend/data/questions/balance-a-binary-search-tree.yaml
+++ b/backend/data/questions/balance-a-binary-search-tree.yaml
@@ -6,8 +6,10 @@ leetcode_url: https://leetcode.com/problems/balance-a-binary-search-tree/
 categories:
   - trees
 patterns:
-  - tree-traversal
-  - dfs
+  - slug: tree-traversal
+    is_optimal: true
+  - slug: dfs
+    is_optimal: false
 
 function_signature: "def balance_bst(root: TreeNode) -> TreeNode:"
 
diff --git a/backend/data/questions/balanced-binary-tree.yaml b/backend/data/questions/balanced-binary-tree.yaml
index 4dc1fb6..45d9a11 100644
--- a/backend/data/questions/balanced-binary-tree.yaml
+++ b/backend/data/questions/balanced-binary-tree.yaml
@@ -7,8 +7,10 @@ categories:
   - trees
   - recursion
 patterns:
-  - dfs
-  - tree-traversal
+  - slug: dfs
+    is_optimal: true
+  - slug: tree-traversal
+    is_optimal: false
 
 function_signature: "def is_balanced(root: TreeNode) -> bool:"
 
diff --git a/backend/data/questions/base-7.yaml b/backend/data/questions/base-7.yaml
index 0f1480e..463bc0b 100644
--- a/backend/data/questions/base-7.yaml
+++ b/backend/data/questions/base-7.yaml
@@ -7,7 +7,8 @@ categories:
   - strings
   - math
 patterns:
-  - greedy
+  - slug: greedy
+    is_optimal: true
 
 function_signature: "def convert_to_base7(num: int) -> str:"
 
diff --git a/backend/data/questions/baseball-game.yaml b/backend/data/questions/baseball-game.yaml
index c6c545a..429cd24 100644
--- a/backend/data/questions/baseball-game.yaml
+++ b/backend/data/questions/baseball-game.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - stack
 patterns:
-  - monotonic-stack
+  - slug: monotonic-stack
+    is_optimal: true
 
 function_signature: "def cal_points(operations: list[str]) -> int:"
 
diff --git a/backend/data/questions/basic-calculator-ii.yaml b/backend/data/questions/basic-calculator-ii.yaml
index b44fe14..72a48a8 100644
--- a/backend/data/questions/basic-calculator-ii.yaml
+++ b/backend/data/questions/basic-calculator-ii.yaml
@@ -8,7 +8,8 @@ categories:
   - stack
   - math
 patterns:
-  - monotonic-stack
+  - slug: monotonic-stack
+    is_optimal: true
 
 function_signature: "def calculate(s: str) -> int:"
 
diff --git a/backend/data/questions/basic-calculator-iv.yaml b/backend/data/questions/basic-calculator-iv.yaml
index 5b3be44..44aeca1 100644
--- a/backend/data/questions/basic-calculator-iv.yaml
+++ b/backend/data/questions/basic-calculator-iv.yaml
@@ -10,7 +10,8 @@ categories:
   - stack
   - math
 patterns:
-  - backtracking
+  - slug: backtracking
+    is_optimal: true
 
 function_signature: "def basic_calculator_iv(expression: str, evalvars: list[str], evalints: list[int]) -> list[str]:"
 
diff --git a/backend/data/questions/basic-calculator.yaml b/backend/data/questions/basic-calculator.yaml
index 79886cb..3f0127d 100644
--- a/backend/data/questions/basic-calculator.yaml
+++ b/backend/data/questions/basic-calculator.yaml
@@ -8,7 +8,8 @@ categories:
   - stack
   - math
 patterns:
-  - monotonic-stack
+  - slug: monotonic-stack
+    is_optimal: true
 
 function_signature: "def calculate(s: str) -> int:"
 
diff --git a/backend/data/questions/battleships-in-a-board.yaml b/backend/data/questions/battleships-in-a-board.yaml
index 309f851..acc8745 100644
--- a/backend/data/questions/battleships-in-a-board.yaml
+++ b/backend/data/questions/battleships-in-a-board.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - graphs
 patterns:
-  - matrix-traversal
+  - slug: matrix-traversal
+    is_optimal: true
 
 function_signature: "def count_battleships(board: list[list[str]]) -> int:"
 
diff --git a/backend/data/questions/beautiful-arrangement-ii.yaml b/backend/data/questions/beautiful-arrangement-ii.yaml
index 331d51a..9efad5f 100644
--- a/backend/data/questions/beautiful-arrangement-ii.yaml
+++ b/backend/data/questions/beautiful-arrangement-ii.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - math
 patterns:
-  - greedy
+  - slug: greedy
+    is_optimal: true
 
 function_signature: "def construct_array(n: int, k: int) -> list[int]:"
 
diff --git a/backend/data/questions/beautiful-arrangement.yaml b/backend/data/questions/beautiful-arrangement.yaml
index 64dca76..f860b7e 100644
--- a/backend/data/questions/beautiful-arrangement.yaml
+++ b/backend/data/questions/beautiful-arrangement.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - recursion
 patterns:
-  - backtracking
+  - slug: backtracking
+    is_optimal: true
 
 function_signature: "def count_arrangement(n: int) -> int:"
 
diff --git a/backend/data/questions/beautiful-array.yaml b/backend/data/questions/beautiful-array.yaml
index 7b41963..b6e23e9 100644
--- a/backend/data/questions/beautiful-array.yaml
+++ b/backend/data/questions/beautiful-array.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - math
 patterns:
-  - dynamic-programming
+  - slug: dynamic-programming
+    is_optimal: true
 
 function_signature: "def beautiful_array(n: int) -> list[int]:"
 
diff --git a/backend/data/questions/best-poker-hand.yaml b/backend/data/questions/best-poker-hand.yaml
index ecc0c13..f158dc2 100644
--- a/backend/data/questions/best-poker-hand.yaml
+++ b/backend/data/questions/best-poker-hand.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - hash-tables
 patterns:
-  - greedy
+  - slug: greedy
+    is_optimal: true
 
 function_signature: "def best_hand(ranks: list[int], suits: list[str]) -> str:"
 
diff --git a/backend/data/questions/best-position-for-a-service-centre.yaml b/backend/data/questions/best-position-for-a-service-centre.yaml
index 759c5fb..11469c6 100644
--- a/backend/data/questions/best-position-for-a-service-centre.yaml
+++ b/backend/data/questions/best-position-for-a-service-centre.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - math
 patterns:
-  - greedy
+  - slug: greedy
+    is_optimal: true
 
 function_signature: "def get_min_dist_sum(positions: list[list[int]]) -> float:"
 
diff --git a/backend/data/questions/best-sightseeing-pair.yaml b/backend/data/questions/best-sightseeing-pair.yaml
index bb7a5a4..9a03190 100644
--- a/backend/data/questions/best-sightseeing-pair.yaml
+++ b/backend/data/questions/best-sightseeing-pair.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - dynamic-programming
 patterns:
-  - greedy
+  - slug: greedy
+    is_optimal: true
 
 function_signature: "def max_score_sightseeing_pair(values: list[int]) -> int:"
 
diff --git a/backend/data/questions/best-team-with-no-conflicts.yaml b/backend/data/questions/best-team-with-no-conflicts.yaml
index 0f5d6ff..83c845e 100644
--- a/backend/data/questions/best-team-with-no-conflicts.yaml
+++ b/backend/data/questions/best-team-with-no-conflicts.yaml
@@ -8,7 +8,8 @@ categories:
   - dynamic-programming
   - sorting
 patterns:
-  - dynamic-programming
+  - slug: dynamic-programming
+    is_optimal: true
 
 function_signature: "def best_team_score(scores: list[int], ages: list[int]) -> int:"
 
diff --git a/backend/data/questions/best-time-to-buy-and-sell-stock-ii.yaml b/backend/data/questions/best-time-to-buy-and-sell-stock-ii.yaml
index f3f43d5..0a41d35 100644
--- a/backend/data/questions/best-time-to-buy-and-sell-stock-ii.yaml
+++ b/backend/data/questions/best-time-to-buy-and-sell-stock-ii.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - dynamic-programming
 patterns:
-  - greedy
+  - slug: greedy
+    is_optimal: true
 
 function_signature: "def max_profit(prices: list[int]) -> int:"
 
diff --git a/backend/data/questions/best-time-to-buy-and-sell-stock-iii.yaml b/backend/data/questions/best-time-to-buy-and-sell-stock-iii.yaml
index 961c931..0a3890e 100644
--- a/backend/data/questions/best-time-to-buy-and-sell-stock-iii.yaml
+++ b/backend/data/questions/best-time-to-buy-and-sell-stock-iii.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - dynamic-programming
 patterns:
-  - dynamic-programming
+  - slug: dynamic-programming
+    is_optimal: true
 
 function_signature: "def max_profit(prices: list[int]) -> int:"
 
diff --git a/backend/data/questions/best-time-to-buy-and-sell-stock-iv.yaml b/backend/data/questions/best-time-to-buy-and-sell-stock-iv.yaml
index 0291a6a..ff35d5b 100644
--- a/backend/data/questions/best-time-to-buy-and-sell-stock-iv.yaml
+++ b/backend/data/questions/best-time-to-buy-and-sell-stock-iv.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - dynamic-programming
 patterns:
-  - dynamic-programming
+  - slug: dynamic-programming
+    is_optimal: true
 
 function_signature: "def max_profit(k: int, prices: list[int]) -> int:"
 
diff --git a/backend/data/questions/best-time-to-buy-and-sell-stock-with-cooldown.yaml b/backend/data/questions/best-time-to-buy-and-sell-stock-with-cooldown.yaml
index 901e171..42c7cb7 100644
--- a/backend/data/questions/best-time-to-buy-and-sell-stock-with-cooldown.yaml
+++ b/backend/data/questions/best-time-to-buy-and-sell-stock-with-cooldown.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - dynamic-programming
 patterns:
-  - dynamic-programming
+  - slug: dynamic-programming
+    is_optimal: true
 
 function_signature: "def max_profit(prices: list[int]) -> int:"
 
diff --git a/backend/data/questions/best-time-to-buy-and-sell-stock-with-transaction-fee.yaml b/backend/data/questions/best-time-to-buy-and-sell-stock-with-transaction-fee.yaml
index b4f8ec5..d8ff894 100644
--- a/backend/data/questions/best-time-to-buy-and-sell-stock-with-transaction-fee.yaml
+++ b/backend/data/questions/best-time-to-buy-and-sell-stock-with-transaction-fee.yaml
@@ -7,8 +7,10 @@ categories:
   - arrays
   - dynamic-programming
 patterns:
-  - dynamic-programming
-  - greedy
+  - slug: dynamic-programming
+    is_optimal: true
+  - slug: greedy
+    is_optimal: false
 
 function_signature: "def max_profit(prices: list[int], fee: int) -> int:"
 
diff --git a/backend/data/questions/best-time-to-buy-and-sell-stock.yaml b/backend/data/questions/best-time-to-buy-and-sell-stock.yaml
index f18bb04..79d4abb 100644
--- a/backend/data/questions/best-time-to-buy-and-sell-stock.yaml
+++ b/backend/data/questions/best-time-to-buy-and-sell-stock.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - dynamic-programming
 patterns:
-  - greedy
+  - slug: greedy
+    is_optimal: true
 
 function_signature: "def max_profit(prices: list[int]) -> int:"
 
diff --git a/backend/data/questions/binary-gap.yaml b/backend/data/questions/binary-gap.yaml
index e78956e..18db2bb 100644
--- a/backend/data/questions/binary-gap.yaml
+++ b/backend/data/questions/binary-gap.yaml
@@ -6,7 +6,8 @@ leetcode_url: https://leetcode.com/problems/binary-gap/
 categories:
   - math
 patterns:
-  - two-pointers
+  - slug: two-pointers
+    is_optimal: true
 
 function_signature: "def binary_gap(n: int) -> int:"
 
diff --git a/backend/data/questions/binary-number-with-alternating-bits.yaml b/backend/data/questions/binary-number-with-alternating-bits.yaml
index 63f2fba..575e588 100644
--- a/backend/data/questions/binary-number-with-alternating-bits.yaml
+++ b/backend/data/questions/binary-number-with-alternating-bits.yaml
@@ -6,7 +6,8 @@ leetcode_url: https://leetcode.com/problems/binary-number-with-alternating-bits/
 categories:
   - math
 patterns:
-  - greedy
+  - slug: greedy
+    is_optimal: true
 
 function_signature: "def has_alternating_bits(n: int) -> bool:"
 
diff --git a/backend/data/questions/binary-prefix-divisible-by-5.yaml b/backend/data/questions/binary-prefix-divisible-by-5.yaml
index 66cc58e..cd8680a 100644
--- a/backend/data/questions/binary-prefix-divisible-by-5.yaml
+++ b/backend/data/questions/binary-prefix-divisible-by-5.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - math
 patterns:
-  - prefix-sum
+  - slug: prefix-sum
+    is_optimal: true
 
 function_signature: "def prefixes_div_by5(nums: list[int]) -> list[bool]:"
 
diff --git a/backend/data/questions/binary-search-tree-iterator.yaml b/backend/data/questions/binary-search-tree-iterator.yaml
index 179fff9..be1d605 100644
--- a/backend/data/questions/binary-search-tree-iterator.yaml
+++ b/backend/data/questions/binary-search-tree-iterator.yaml
@@ -7,8 +7,10 @@ categories:
   - trees
   - stack
 patterns:
-  - tree-traversal
-  - monotonic-stack
+  - slug: tree-traversal
+    is_optimal: false
+  - slug: monotonic-stack
+    is_optimal: true
 
 function_signature: "class BSTIterator:\n    def __init__(self, root: TreeNode): ...\n    def next(self) -> int: ...\n    def hasNext(self) -> bool: ..."
 
diff --git a/backend/data/questions/binary-search-tree-to-greater-sum-tree.yaml b/backend/data/questions/binary-search-tree-to-greater-sum-tree.yaml
index e443617..4e2ebe3 100644
--- a/backend/data/questions/binary-search-tree-to-greater-sum-tree.yaml
+++ b/backend/data/questions/binary-search-tree-to-greater-sum-tree.yaml
@@ -6,8 +6,10 @@ leetcode_url: https://leetcode.com/problems/binary-search-tree-to-greater-sum-tr
 categories:
   - trees
 patterns:
-  - dfs
-  - tree-traversal
+  - slug: dfs
+    is_optimal: true
+  - slug: tree-traversal
+    is_optimal: false
 
 function_signature: "def bst_to_gst(root: TreeNode) -> TreeNode:"
 
diff --git a/backend/data/questions/binary-search.yaml b/backend/data/questions/binary-search.yaml
index 8409612..3a0ad23 100644
--- a/backend/data/questions/binary-search.yaml
+++ b/backend/data/questions/binary-search.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - binary-search
 patterns:
-  - binary-search
+  - slug: binary-search
+    is_optimal: true
 
 function_signature: "def search(nums: list[int], target: int) -> int:"
 
diff --git a/backend/data/questions/binary-string-with-substrings-representing-1-to-n.yaml b/backend/data/questions/binary-string-with-substrings-representing-1-to-n.yaml
index 0d4a074..b030e3f 100644
--- a/backend/data/questions/binary-string-with-substrings-representing-1-to-n.yaml
+++ b/backend/data/questions/binary-string-with-substrings-representing-1-to-n.yaml
@@ -7,7 +7,8 @@ categories:
   - strings
   - math
 patterns:
-  - sliding-window
+  - slug: sliding-window
+    is_optimal: true
 
 function_signature: "def query_string(s: str, n: int) -> bool:"
 
diff --git a/backend/data/questions/binary-subarrays-with-sum.yaml b/backend/data/questions/binary-subarrays-with-sum.yaml
index ac759b6..d51b779 100644
--- a/backend/data/questions/binary-subarrays-with-sum.yaml
+++ b/backend/data/questions/binary-subarrays-with-sum.yaml
@@ -7,8 +7,10 @@ categories:
   - arrays
   - hash-tables
 patterns:
-  - sliding-window
-  - prefix-sum
+  - slug: sliding-window
+    is_optimal: true
+  - slug: prefix-sum
+    is_optimal: false
 
 function_signature: "def num_subarrays_with_sum(nums: list[int], goal: int) -> int:"
 
diff --git a/backend/data/questions/binary-tree-cameras.yaml b/backend/data/questions/binary-tree-cameras.yaml
index eca6170..2adf5fc 100644
--- a/backend/data/questions/binary-tree-cameras.yaml
+++ b/backend/data/questions/binary-tree-cameras.yaml
@@ -7,8 +7,10 @@ categories:
   - trees
   - dynamic-programming
 patterns:
-  - dfs
-  - greedy
+  - slug: dfs
+    is_optimal: true
+  - slug: greedy
+    is_optimal: false
 
 function_signature: "def min_camera_cover(root: TreeNode) -> int:"
 
diff --git a/backend/data/questions/binary-tree-coloring-game.yaml b/backend/data/questions/binary-tree-coloring-game.yaml
index 05e2f20..d3dffab 100644
--- a/backend/data/questions/binary-tree-coloring-game.yaml
+++ b/backend/data/questions/binary-tree-coloring-game.yaml
@@ -6,8 +6,10 @@ leetcode_url: https://leetcode.com/problems/binary-tree-coloring-game/
 categories:
   - trees
 patterns:
-  - dfs
-  - tree-traversal
+  - slug: dfs
+    is_optimal: true
+  - slug: tree-traversal
+    is_optimal: false
 
 function_signature: "def btree_game_winning_move(root: TreeNode, n: int, x: int) -> bool:"
 
diff --git a/backend/data/questions/binary-tree-inorder-traversal.yaml b/backend/data/questions/binary-tree-inorder-traversal.yaml
index ddd70af..b6d6660 100644
--- a/backend/data/questions/binary-tree-inorder-traversal.yaml
+++ b/backend/data/questions/binary-tree-inorder-traversal.yaml
@@ -8,8 +8,10 @@ categories:
   - stack
   - recursion
 patterns:
-  - tree-traversal
-  - dfs
+  - slug: tree-traversal
+    is_optimal: true
+  - slug: dfs
+    is_optimal: false
 
 function_signature: "def inorder_traversal(root: TreeNode) -> list[int]:"
 
diff --git a/backend/data/questions/binary-tree-level-order-traversal-ii.yaml b/backend/data/questions/binary-tree-level-order-traversal-ii.yaml
index afe35e8..61cbc9c 100644
--- a/backend/data/questions/binary-tree-level-order-traversal-ii.yaml
+++ b/backend/data/questions/binary-tree-level-order-traversal-ii.yaml
@@ -7,8 +7,10 @@ categories:
   - trees
   - queue
 patterns:
-  - bfs
-  - tree-traversal
+  - slug: bfs
+    is_optimal: true
+  - slug: tree-traversal
+    is_optimal: false
 
 function_signature: "def level_order_bottom(root: TreeNode) -> list[list[int]]:"
 
diff --git a/backend/data/questions/binary-tree-level-order-traversal.yaml b/backend/data/questions/binary-tree-level-order-traversal.yaml
index 8f8e2e8..4574200 100644
--- a/backend/data/questions/binary-tree-level-order-traversal.yaml
+++ b/backend/data/questions/binary-tree-level-order-traversal.yaml
@@ -7,8 +7,10 @@ categories:
   - trees
   - queue
 patterns:
-  - bfs
-  - tree-traversal
+  - slug: bfs
+    is_optimal: true
+  - slug: tree-traversal
+    is_optimal: false
 
 function_signature: "def level_order(root: TreeNode | None) -> list[list[int]]:"
 
diff --git a/backend/data/questions/binary-tree-maximum-path-sum.yaml b/backend/data/questions/binary-tree-maximum-path-sum.yaml
index 3cdfc80..a4f266a 100644
--- a/backend/data/questions/binary-tree-maximum-path-sum.yaml
+++ b/backend/data/questions/binary-tree-maximum-path-sum.yaml
@@ -8,8 +8,10 @@ categories:
   - dynamic-programming
   - recursion
 patterns:
-  - dfs
-  - dynamic-programming
+  - slug: dfs
+    is_optimal: true
+  - slug: dynamic-programming
+    is_optimal: false
 
 function_signature: "def max_path_sum(root: TreeNode) -> int:"
 
diff --git a/backend/data/questions/binary-tree-paths.yaml b/backend/data/questions/binary-tree-paths.yaml
index 77f7359..109a417 100644
--- a/backend/data/questions/binary-tree-paths.yaml
+++ b/backend/data/questions/binary-tree-paths.yaml
@@ -8,9 +8,12 @@ categories:
   - strings
   - recursion
 patterns:
-  - dfs
-  - backtracking
-  - tree-traversal
+  - slug: dfs
+    is_optimal: true
+  - slug: backtracking
+    is_optimal: false
+  - slug: tree-traversal
+    is_optimal: false
 
 function_signature: "def binary_tree_paths(root: TreeNode) -> list[str]:"
 
diff --git a/backend/data/questions/binary-tree-postorder-traversal.yaml b/backend/data/questions/binary-tree-postorder-traversal.yaml
index 74a3e2e..5b1d833 100644
--- a/backend/data/questions/binary-tree-postorder-traversal.yaml
+++ b/backend/data/questions/binary-tree-postorder-traversal.yaml
@@ -8,8 +8,10 @@ categories:
   - stack
   - recursion
 patterns:
-  - dfs
-  - tree-traversal
+  - slug: dfs
+    is_optimal: true
+  - slug: tree-traversal
+    is_optimal: false
 
 function_signature: "def postorder_traversal(root: TreeNode) -> list[int]:"
 
diff --git a/backend/data/questions/binary-tree-preorder-traversal.yaml b/backend/data/questions/binary-tree-preorder-traversal.yaml
index e1bf938..fa33669 100644
--- a/backend/data/questions/binary-tree-preorder-traversal.yaml
+++ b/backend/data/questions/binary-tree-preorder-traversal.yaml
@@ -8,8 +8,10 @@ categories:
   - stack
   - recursion
 patterns:
-  - tree-traversal
-  - dfs
+  - slug: tree-traversal
+    is_optimal: true
+  - slug: dfs
+    is_optimal: false
 
 function_signature: "def preorder_traversal(root: TreeNode) -> list[int]:"
 
diff --git a/backend/data/questions/binary-tree-pruning.yaml b/backend/data/questions/binary-tree-pruning.yaml
index 5da9716..24a6f7e 100644
--- a/backend/data/questions/binary-tree-pruning.yaml
+++ b/backend/data/questions/binary-tree-pruning.yaml
@@ -7,8 +7,10 @@ categories:
   - trees
   - recursion
 patterns:
-  - dfs
-  - tree-traversal
+  - slug: dfs
+    is_optimal: true
+  - slug: tree-traversal
+    is_optimal: false
 
 function_signature: "def prune_tree(root: TreeNode) -> TreeNode:"
 
diff --git a/backend/data/questions/binary-tree-right-side-view.yaml b/backend/data/questions/binary-tree-right-side-view.yaml
index ec53a3d..1402abf 100644
--- a/backend/data/questions/binary-tree-right-side-view.yaml
+++ b/backend/data/questions/binary-tree-right-side-view.yaml
@@ -6,9 +6,12 @@ leetcode_url: https://leetcode.com/problems/binary-tree-right-side-view/
 categories:
   - trees
 patterns:
-  - bfs
-  - dfs
-  - tree-traversal
+  - slug: bfs
+    is_optimal: true
+  - slug: dfs
+    is_optimal: false
+  - slug: tree-traversal
+    is_optimal: false
 
 function_signature: "def right_side_view(root: TreeNode) -> list[int]:"
 
diff --git a/backend/data/questions/binary-tree-tilt.yaml b/backend/data/questions/binary-tree-tilt.yaml
index 9f288b4..6ef4be1 100644
--- a/backend/data/questions/binary-tree-tilt.yaml
+++ b/backend/data/questions/binary-tree-tilt.yaml
@@ -7,8 +7,10 @@ categories:
   - trees
   - recursion
 patterns:
-  - dfs
-  - tree-traversal
+  - slug: dfs
+    is_optimal: true
+  - slug: tree-traversal
+    is_optimal: false
 
 function_signature: "def find_tilt(root: TreeNode) -> int:"
 
diff --git a/backend/data/questions/binary-tree-zigzag-level-order-traversal.yaml b/backend/data/questions/binary-tree-zigzag-level-order-traversal.yaml
index e3f274f..3d8d8a1 100644
--- a/backend/data/questions/binary-tree-zigzag-level-order-traversal.yaml
+++ b/backend/data/questions/binary-tree-zigzag-level-order-traversal.yaml
@@ -7,8 +7,10 @@ categories:
   - trees
   - queue
 patterns:
-  - bfs
-  - tree-traversal
+  - slug: bfs
+    is_optimal: true
+  - slug: tree-traversal
+    is_optimal: false
 
 function_signature: "def zigzag_level_order(root: TreeNode) -> list[list[int]]:"
 
diff --git a/backend/data/questions/binary-trees-with-factors.yaml b/backend/data/questions/binary-trees-with-factors.yaml
index cda2b32..e2bae0b 100644
--- a/backend/data/questions/binary-trees-with-factors.yaml
+++ b/backend/data/questions/binary-trees-with-factors.yaml
@@ -9,7 +9,8 @@ categories:
   - dynamic-programming
   - sorting
 patterns:
-  - dynamic-programming
+  - slug: dynamic-programming
+    is_optimal: true
 
 function_signature: "def num_factored_binary_trees(arr: list[int]) -> int:"
 
diff --git a/backend/data/questions/binary-watch.yaml b/backend/data/questions/binary-watch.yaml
index 32e84aa..a27fb4e 100644
--- a/backend/data/questions/binary-watch.yaml
+++ b/backend/data/questions/binary-watch.yaml
@@ -7,7 +7,8 @@ categories:
   - math
   - recursion
 patterns:
-  - backtracking
+  - slug: backtracking
+    is_optimal: true
 
 function_signature: "def read_binary_watch(turned_on: int) -> list[str]:"
 
diff --git a/backend/data/questions/bitwise-and-of-numbers-range.yaml b/backend/data/questions/bitwise-and-of-numbers-range.yaml
index 2bbf8da..5b99e87 100644
--- a/backend/data/questions/bitwise-and-of-numbers-range.yaml
+++ b/backend/data/questions/bitwise-and-of-numbers-range.yaml
@@ -6,7 +6,8 @@ leetcode_url: https://leetcode.com/problems/bitwise-and-of-numbers-range/
 categories:
   - math
 patterns:
-  - binary-search
+  - slug: binary-search
+    is_optimal: true
 
 function_signature: "def range_bitwise_and(left: int, right: int) -> int:"
 
diff --git a/backend/data/questions/bitwise-ors-of-subarrays.yaml b/backend/data/questions/bitwise-ors-of-subarrays.yaml
index 3bcb45c..fe2c354 100644
--- a/backend/data/questions/bitwise-ors-of-subarrays.yaml
+++ b/backend/data/questions/bitwise-ors-of-subarrays.yaml
@@ -8,7 +8,8 @@ categories:
   - dynamic-programming
   - math
 patterns:
-  - dynamic-programming
+  - slug: dynamic-programming
+    is_optimal: true
 
 function_signature: "def subarray_bitwise_ors(arr: list[int]) -> int:"
 
diff --git a/backend/data/questions/bitwise-xor-of-all-pairings.yaml b/backend/data/questions/bitwise-xor-of-all-pairings.yaml
index 288017b..acf9f67 100644
--- a/backend/data/questions/bitwise-xor-of-all-pairings.yaml
+++ b/backend/data/questions/bitwise-xor-of-all-pairings.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - math
 patterns:
-  - greedy
+  - slug: greedy
+    is_optimal: true
 
 function_signature: "def xor_all_nums(nums1: list[int], nums2: list[int]) -> int:"
 
diff --git a/backend/data/questions/boats-to-save-people.yaml b/backend/data/questions/boats-to-save-people.yaml
index 8358051..3c5897d 100644
--- a/backend/data/questions/boats-to-save-people.yaml
+++ b/backend/data/questions/boats-to-save-people.yaml
@@ -8,8 +8,10 @@ categories:
   - two-pointers
   - sorting
 patterns:
-  - two-pointers
-  - greedy
+  - slug: two-pointers
+    is_optimal: true
+  - slug: greedy
+    is_optimal: false
 
 function_signature: "def num_rescue_boats(people: list[int], limit: int) -> int:"
 
diff --git a/backend/data/questions/booking-concert-tickets-in-groups.yaml b/backend/data/questions/booking-concert-tickets-in-groups.yaml
index 816ba97..6a2828b 100644
--- a/backend/data/questions/booking-concert-tickets-in-groups.yaml
+++ b/backend/data/questions/booking-concert-tickets-in-groups.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - binary-search
 patterns:
-  - binary-search
+  - slug: binary-search
+    is_optimal: true
 
 function_signature: "class BookMyShow"
 
diff --git a/backend/data/questions/brace-expansion-ii.yaml b/backend/data/questions/brace-expansion-ii.yaml
index 458765a..046f5c4 100644
--- a/backend/data/questions/brace-expansion-ii.yaml
+++ b/backend/data/questions/brace-expansion-ii.yaml
@@ -8,8 +8,10 @@ categories:
   - recursion
   - stack
 patterns:
-  - backtracking
-  - dfs
+  - slug: backtracking
+    is_optimal: false
+  - slug: dfs
+    is_optimal: true
 
 function_signature: "def brace_expansion_ii(expression: str) -> list[str]:"
 
diff --git a/backend/data/questions/break-a-palindrome.yaml b/backend/data/questions/break-a-palindrome.yaml
index 56d8ad2..d89fcda 100644
--- a/backend/data/questions/break-a-palindrome.yaml
+++ b/backend/data/questions/break-a-palindrome.yaml
@@ -6,7 +6,8 @@ leetcode_url: https://leetcode.com/problems/break-a-palindrome/
 categories:
   - strings
 patterns:
-  - greedy
+  - slug: greedy
+    is_optimal: true
 
 function_signature: "def break_palindrome(palindrome: str) -> str:"
 
diff --git a/backend/data/questions/brick-wall.yaml b/backend/data/questions/brick-wall.yaml
index f9454a8..1e1a5d5 100644
--- a/backend/data/questions/brick-wall.yaml
+++ b/backend/data/questions/brick-wall.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - hash-tables
 patterns:
-  - prefix-sum
+  - slug: prefix-sum
+    is_optimal: true
 
 function_signature: "def least_bricks(wall: list[list[int]]) -> int:"
 
diff --git a/backend/data/questions/bricks-falling-when-hit.yaml b/backend/data/questions/bricks-falling-when-hit.yaml
index 908b119..9c56fe1 100644
--- a/backend/data/questions/bricks-falling-when-hit.yaml
+++ b/backend/data/questions/bricks-falling-when-hit.yaml
@@ -7,8 +7,10 @@ categories:
   - arrays
   - graphs
 patterns:
-  - union-find
-  - matrix-traversal
+  - slug: union-find
+    is_optimal: true
+  - slug: matrix-traversal
+    is_optimal: false
 
 function_signature: "def hit_bricks(grid: list[list[int]], hits: list[list[int]]) -> list[int]:"
 
diff --git a/backend/data/questions/broken-calculator.yaml b/backend/data/questions/broken-calculator.yaml
index 69d1fd4..74be12e 100644
--- a/backend/data/questions/broken-calculator.yaml
+++ b/backend/data/questions/broken-calculator.yaml
@@ -6,7 +6,8 @@ leetcode_url: https://leetcode.com/problems/broken-calculator/
 categories:
   - math
 patterns:
-  - greedy
+  - slug: greedy
+    is_optimal: true
 
 function_signature: "def broken_calc(start_value: int, target: int) -> int:"
 
diff --git a/backend/data/questions/buddy-strings.yaml b/backend/data/questions/buddy-strings.yaml
index f1eaf40..da0c44f 100644
--- a/backend/data/questions/buddy-strings.yaml
+++ b/backend/data/questions/buddy-strings.yaml
@@ -7,7 +7,8 @@ categories:
   - strings
   - hash-tables
 patterns:
-  - two-pointers
+  - slug: two-pointers
+    is_optimal: true
 
 function_signature: "def buddy_strings(s: str, goal: str) -> bool:"
 
diff --git a/backend/data/questions/build-a-matrix-with-conditions.yaml b/backend/data/questions/build-a-matrix-with-conditions.yaml
index be930b9..df15720 100644
--- a/backend/data/questions/build-a-matrix-with-conditions.yaml
+++ b/backend/data/questions/build-a-matrix-with-conditions.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - graphs
 patterns:
-  - topological-sort
+  - slug: topological-sort
+    is_optimal: true
 
 function_signature: "def build_matrix(k: int, row_conditions: list[list[int]], col_conditions: list[list[int]]) -> list[list[int]]:"
 
diff --git a/backend/data/questions/build-an-array-with-stack-operations.yaml b/backend/data/questions/build-an-array-with-stack-operations.yaml
index 4319f00..785b128 100644
--- a/backend/data/questions/build-an-array-with-stack-operations.yaml
+++ b/backend/data/questions/build-an-array-with-stack-operations.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - stack
 patterns:
-  - two-pointers
+  - slug: two-pointers
+    is_optimal: true
 
 function_signature: "def build_array(target: list[int], n: int) -> list[str]:"
 
diff --git a/backend/data/questions/build-array-from-permutation.yaml b/backend/data/questions/build-array-from-permutation.yaml
index 58f68d3..d31c9fd 100644
--- a/backend/data/questions/build-array-from-permutation.yaml
+++ b/backend/data/questions/build-array-from-permutation.yaml
@@ -6,7 +6,8 @@ leetcode_url: https://leetcode.com/problems/build-array-from-permutation/
 categories:
   - arrays
 patterns:
-  - matrix-traversal
+  - slug: matrix-traversal
+    is_optimal: true
 
 function_signature: "def build_array(nums: list[int]) -> list[int]:"
 
diff --git a/backend/data/questions/build-array-where-you-can-find-the-maximum-exactly-k-comparisons.yaml b/backend/data/questions/build-array-where-you-can-find-the-maximum-exactly-k-comparisons.yaml
index 2bb278c..34ef88c 100644
--- a/backend/data/questions/build-array-where-you-can-find-the-maximum-exactly-k-comparisons.yaml
+++ b/backend/data/questions/build-array-where-you-can-find-the-maximum-exactly-k-comparisons.yaml
@@ -7,8 +7,10 @@ categories:
   - arrays
   - dynamic-programming
 patterns:
-  - dynamic-programming
-  - prefix-sum
+  - slug: dynamic-programming
+    is_optimal: false
+  - slug: prefix-sum
+    is_optimal: true
 
 function_signature: "def num_of_arrays(n: int, m: int, k: int) -> int:"
 
diff --git a/backend/data/questions/building-boxes.yaml b/backend/data/questions/building-boxes.yaml
index 2543ddf..7565003 100644
--- a/backend/data/questions/building-boxes.yaml
+++ b/backend/data/questions/building-boxes.yaml
@@ -7,8 +7,10 @@ categories:
   - math
   - binary-search
 patterns:
-  - binary-search
-  - greedy
+  - slug: binary-search
+    is_optimal: true
+  - slug: greedy
+    is_optimal: false
 
 function_signature: "def minimum_boxes(n: int) -> int:"
 
diff --git a/backend/data/questions/building-h2o.yaml b/backend/data/questions/building-h2o.yaml
index 616cdfb..4b192c0 100644
--- a/backend/data/questions/building-h2o.yaml
+++ b/backend/data/questions/building-h2o.yaml
@@ -6,7 +6,8 @@ leetcode_url: https://leetcode.com/problems/building-h2o/
 categories:
   - concurrency
 patterns:
-  - synchronization
+  - slug: synchronization
+    is_optimal: true
 
 function_signature: "class H2O"
 
diff --git a/backend/data/questions/bulb-switcher-ii.yaml b/backend/data/questions/bulb-switcher-ii.yaml
index ec149a2..be4d92e 100644
--- a/backend/data/questions/bulb-switcher-ii.yaml
+++ b/backend/data/questions/bulb-switcher-ii.yaml
@@ -6,7 +6,8 @@ leetcode_url: https://leetcode.com/problems/bulb-switcher-ii/
 categories:
   - math
 patterns:
-  - greedy
+  - slug: greedy
+    is_optimal: true
 
 function_signature: "def flip_lights(n: int, presses: int) -> int:"
 
diff --git a/backend/data/questions/bulb-switcher.yaml b/backend/data/questions/bulb-switcher.yaml
index 4691859..3ad28d6 100644
--- a/backend/data/questions/bulb-switcher.yaml
+++ b/backend/data/questions/bulb-switcher.yaml
@@ -6,7 +6,8 @@ leetcode_url: https://leetcode.com/problems/bulb-switcher/
 categories:
   - math
 patterns:
-  - greedy
+  - slug: greedy
+    is_optimal: true
 
 function_signature: "def bulb_switch(n: int) -> int:"
 
diff --git a/backend/data/questions/bulls-and-cows.yaml b/backend/data/questions/bulls-and-cows.yaml
index e6d76cd..ff40eaa 100644
--- a/backend/data/questions/bulls-and-cows.yaml
+++ b/backend/data/questions/bulls-and-cows.yaml
@@ -7,7 +7,8 @@ categories:
   - strings
   - hash-tables
 patterns:
-  - two-pointers
+  - slug: two-pointers
+    is_optimal: true
 
 function_signature: "def get_hint(secret: str, guess: str) -> str:"
 
diff --git a/backend/data/questions/burst-balloons.yaml b/backend/data/questions/burst-balloons.yaml
index c4366ce..1288406 100644
--- a/backend/data/questions/burst-balloons.yaml
+++ b/backend/data/questions/burst-balloons.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - dynamic-programming
 patterns:
-  - dynamic-programming
+  - slug: dynamic-programming
+    is_optimal: true
 
 function_signature: "def max_coins(nums: list[int]) -> int:"
 
diff --git a/backend/data/questions/bus-routes.yaml b/backend/data/questions/bus-routes.yaml
index 33541e2..5f83cd9 100644
--- a/backend/data/questions/bus-routes.yaml
+++ b/backend/data/questions/bus-routes.yaml
@@ -8,7 +8,8 @@ categories:
   - hash-tables
   - arrays
 patterns:
-  - bfs
+  - slug: bfs
+    is_optimal: true
 
 function_signature: "def num_buses_to_destination(routes: list[list[int]], source: int, target: int) -> int:"
 
diff --git a/backend/data/questions/cache-with-time-limit.yaml b/backend/data/questions/cache-with-time-limit.yaml
index 548c9ec..3cc0e89 100644
--- a/backend/data/questions/cache-with-time-limit.yaml
+++ b/backend/data/questions/cache-with-time-limit.yaml
@@ -6,7 +6,8 @@ leetcode_url: https://leetcode.com/problems/cache-with-time-limit/
 categories:
   - hash-tables
 patterns:
-  - heap
+  - slug: hashing
+    is_optimal: true
 
 function_signature: "class TimeLimitedCache { set(key: number, value: number, duration: number): boolean; get(key: number): number; count(): number; }"
 
diff --git a/backend/data/questions/calculate-amount-paid-in-taxes.yaml b/backend/data/questions/calculate-amount-paid-in-taxes.yaml
index 60868e8..45d7fe1 100644
--- a/backend/data/questions/calculate-amount-paid-in-taxes.yaml
+++ b/backend/data/questions/calculate-amount-paid-in-taxes.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - math
 patterns:
-  - greedy
+  - slug: greedy
+    is_optimal: true
 
 function_signature: "def calculate_tax(brackets: list[list[int]], income: int) -> float:"
 
diff --git a/backend/data/questions/calculate-digit-sum-of-a-string.yaml b/backend/data/questions/calculate-digit-sum-of-a-string.yaml
index 71c6bd6..017c369 100644
--- a/backend/data/questions/calculate-digit-sum-of-a-string.yaml
+++ b/backend/data/questions/calculate-digit-sum-of-a-string.yaml
@@ -6,7 +6,8 @@ leetcode_url: https://leetcode.com/problems/calculate-digit-sum-of-a-string/
 categories:
   - strings
 patterns:
-  - sliding-window
+  - slug: sliding-window
+    is_optimal: true
 
 function_signature: "def digit_sum(s: str, k: int) -> str:"
 
diff --git a/backend/data/questions/calculate-money-in-leetcode-bank.yaml b/backend/data/questions/calculate-money-in-leetcode-bank.yaml
index 850c39e..05952af 100644
--- a/backend/data/questions/calculate-money-in-leetcode-bank.yaml
+++ b/backend/data/questions/calculate-money-in-leetcode-bank.yaml
@@ -6,7 +6,8 @@ leetcode_url: https://leetcode.com/problems/calculate-money-in-leetcode-bank/
 categories:
   - math
 patterns:
-  - prefix-sum
+  - slug: prefix-sum
+    is_optimal: true
 
 function_signature: "def total_money(n: int) -> int:"
 
diff --git a/backend/data/questions/camelcase-matching.yaml b/backend/data/questions/camelcase-matching.yaml
index a4a7695..aad0868 100644
--- a/backend/data/questions/camelcase-matching.yaml
+++ b/backend/data/questions/camelcase-matching.yaml
@@ -8,7 +8,8 @@ categories:
   - arrays
   - two-pointers
 patterns:
-  - two-pointers
+  - slug: two-pointers
+    is_optimal: true
 
 function_signature: "def camelMatch(queries: list[str], pattern: str) -> list[bool]:"
 
diff --git a/backend/data/questions/can-convert-string-in-k-moves.yaml b/backend/data/questions/can-convert-string-in-k-moves.yaml
index 59062d5..6b75c6a 100644
--- a/backend/data/questions/can-convert-string-in-k-moves.yaml
+++ b/backend/data/questions/can-convert-string-in-k-moves.yaml
@@ -7,7 +7,8 @@ categories:
   - strings
   - hash-tables
 patterns:
-  - greedy
+  - slug: greedy
+    is_optimal: true
 
 function_signature: "def can_convert_string(s: str, t: str, k: int) -> bool:"
 
diff --git a/backend/data/questions/can-i-win.yaml b/backend/data/questions/can-i-win.yaml
index a36623d..a7c59fd 100644
--- a/backend/data/questions/can-i-win.yaml
+++ b/backend/data/questions/can-i-win.yaml
@@ -7,8 +7,10 @@ categories:
   - dynamic-programming
   - recursion
 patterns:
-  - dynamic-programming
-  - backtracking
+  - slug: dynamic-programming
+    is_optimal: true
+  - slug: backtracking
+    is_optimal: false
 
 function_signature: "def can_i_win(max_choosable: int, desired_total: int) -> bool:"
 
diff --git a/backend/data/questions/can-make-arithmetic-progression-from-sequence.yaml b/backend/data/questions/can-make-arithmetic-progression-from-sequence.yaml
index 36f05d8..feceaf6 100644
--- a/backend/data/questions/can-make-arithmetic-progression-from-sequence.yaml
+++ b/backend/data/questions/can-make-arithmetic-progression-from-sequence.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - sorting
 patterns:
-  - two-pointers
+  - slug: two-pointers
+    is_optimal: true
 
 function_signature: "def can_make_arithmetic_progression(arr: list[int]) -> bool:"
 
diff --git a/backend/data/questions/can-place-flowers.yaml b/backend/data/questions/can-place-flowers.yaml
index 6df40dc..204cea4 100644
--- a/backend/data/questions/can-place-flowers.yaml
+++ b/backend/data/questions/can-place-flowers.yaml
@@ -6,7 +6,8 @@ leetcode_url: https://leetcode.com/problems/can-place-flowers/
 categories:
   - arrays
 patterns:
-  - greedy
+  - slug: greedy
+    is_optimal: true
 
 function_signature: "def can_place_flowers(flowerbed: list[int], n: int) -> bool:"
 
diff --git a/backend/data/questions/can-you-eat-your-favorite-candy-on-your-favorite-day.yaml b/backend/data/questions/can-you-eat-your-favorite-candy-on-your-favorite-day.yaml
index 3a25142..ab271b7 100644
--- a/backend/data/questions/can-you-eat-your-favorite-candy-on-your-favorite-day.yaml
+++ b/backend/data/questions/can-you-eat-your-favorite-candy-on-your-favorite-day.yaml
@@ -6,7 +6,8 @@ leetcode_url: https://leetcode.com/problems/can-you-eat-your-favorite-candy-on-y
 categories:
   - arrays
 patterns:
-  - prefix-sum
+  - slug: prefix-sum
+    is_optimal: true
 
 function_signature: "def can_eat(candies_count: list[int], queries: list[list[int]]) -> list[bool]:"
 
diff --git a/backend/data/questions/candy.yaml b/backend/data/questions/candy.yaml
index d386dc5..827943c 100644
--- a/backend/data/questions/candy.yaml
+++ b/backend/data/questions/candy.yaml
@@ -6,7 +6,8 @@ leetcode_url: https://leetcode.com/problems/candy/
 categories:
   - arrays
 patterns:
-  - greedy
+  - slug: greedy
+    is_optimal: true
 
 function_signature: "def candy(ratings: list[int]) -> int:"
 
diff --git a/backend/data/questions/capacity-to-ship-packages-within-d-days.yaml b/backend/data/questions/capacity-to-ship-packages-within-d-days.yaml
index 53ef9b3..b7f7342 100644
--- a/backend/data/questions/capacity-to-ship-packages-within-d-days.yaml
+++ b/backend/data/questions/capacity-to-ship-packages-within-d-days.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - binary-search
 patterns:
-  - binary-search
+  - slug: binary-search
+    is_optimal: true
 
 function_signature: "def ship_within_days(weights: list[int], days: int) -> int:"
 
diff --git a/backend/data/questions/capitalize-the-title.yaml b/backend/data/questions/capitalize-the-title.yaml
index fcaf884..641e7d2 100644
--- a/backend/data/questions/capitalize-the-title.yaml
+++ b/backend/data/questions/capitalize-the-title.yaml
@@ -6,7 +6,8 @@ leetcode_url: https://leetcode.com/problems/capitalize-the-title/
 categories:
   - strings
 patterns:
-  - two-pointers
+  - slug: two-pointers
+    is_optimal: true
 
 function_signature: "def capitalize_title(title: str) -> str:"
 
diff --git a/backend/data/questions/car-fleet-ii.yaml b/backend/data/questions/car-fleet-ii.yaml
index 9691e37..1d95316 100644
--- a/backend/data/questions/car-fleet-ii.yaml
+++ b/backend/data/questions/car-fleet-ii.yaml
@@ -8,7 +8,8 @@ categories:
   - stack
   - math
 patterns:
-  - monotonic-stack
+  - slug: monotonic-stack
+    is_optimal: true
 
 function_signature: "def get_collision_times(cars: list[list[int]]) -> list[float]:"
 
diff --git a/backend/data/questions/car-fleet.yaml b/backend/data/questions/car-fleet.yaml
index 74635c1..7666c0c 100644
--- a/backend/data/questions/car-fleet.yaml
+++ b/backend/data/questions/car-fleet.yaml
@@ -8,7 +8,8 @@ categories:
   - sorting
   - stack
 patterns:
-  - monotonic-stack
+  - slug: monotonic-stack
+    is_optimal: true
 
 function_signature: "def car_fleet(target: int, position: list[int], speed: list[int]) -> int:"
 
diff --git a/backend/data/questions/car-pooling.yaml b/backend/data/questions/car-pooling.yaml
index efeb158..fbcd726 100644
--- a/backend/data/questions/car-pooling.yaml
+++ b/backend/data/questions/car-pooling.yaml
@@ -7,8 +7,10 @@ categories:
   - arrays
   - sorting
 patterns:
-  - prefix-sum
-  - intervals
+  - slug: prefix-sum
+    is_optimal: true
+  - slug: intervals
+    is_optimal: false
 
 function_signature: "def car_pooling(trips: list[list[int]], capacity: int) -> bool:"
 
diff --git a/backend/data/questions/card-flipping-game.yaml b/backend/data/questions/card-flipping-game.yaml
index 85d0885..ae0fd8b 100644
--- a/backend/data/questions/card-flipping-game.yaml
+++ b/backend/data/questions/card-flipping-game.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - hash-tables
 patterns:
-  - greedy
+  - slug: greedy
+    is_optimal: true
 
 function_signature: "def flipgame(fronts: list[int], backs: list[int]) -> int:"
 
diff --git a/backend/data/questions/cat-and-mouse-ii.yaml b/backend/data/questions/cat-and-mouse-ii.yaml
index 709313f..f7e43dc 100644
--- a/backend/data/questions/cat-and-mouse-ii.yaml
+++ b/backend/data/questions/cat-and-mouse-ii.yaml
@@ -7,9 +7,12 @@ categories:
   - graphs
   - dynamic-programming
 patterns:
-  - bfs
-  - dynamic-programming
-  - matrix-traversal
+  - slug: bfs
+    is_optimal: true
+  - slug: dynamic-programming
+    is_optimal: false
+  - slug: matrix-traversal
+    is_optimal: false
 
 function_signature: "def can_mouse_win(grid: list[str], cat_jump: int, mouse_jump: int) -> bool:"
 
diff --git a/backend/data/questions/cat-and-mouse.yaml b/backend/data/questions/cat-and-mouse.yaml
index d05afa1..434afe2 100644
--- a/backend/data/questions/cat-and-mouse.yaml
+++ b/backend/data/questions/cat-and-mouse.yaml
@@ -7,8 +7,10 @@ categories:
   - graphs
   - dynamic-programming
 patterns:
-  - dfs
-  - dynamic-programming
+  - slug: dfs
+    is_optimal: true
+  - slug: dynamic-programming
+    is_optimal: false
 
 function_signature: "def cat_mouse_game(graph: list[list[int]]) -> int:"
 
diff --git a/backend/data/questions/categorize-box-according-to-criteria.yaml b/backend/data/questions/categorize-box-according-to-criteria.yaml
index d2eb340..1d2f9d3 100644
--- a/backend/data/questions/categorize-box-according-to-criteria.yaml
+++ b/backend/data/questions/categorize-box-according-to-criteria.yaml
@@ -6,7 +6,8 @@ leetcode_url: https://leetcode.com/problems/categorize-box-according-to-criteria
 categories:
   - math
 patterns:
-  - greedy
+  - slug: greedy
+    is_optimal: true
 
 function_signature: "def categorize_box(length: int, width: int, height: int, mass: int) -> str:"
 
diff --git a/backend/data/questions/cells-in-a-range-on-an-excel-sheet.yaml b/backend/data/questions/cells-in-a-range-on-an-excel-sheet.yaml
index a8e6f19..840bd57 100644
--- a/backend/data/questions/cells-in-a-range-on-an-excel-sheet.yaml
+++ b/backend/data/questions/cells-in-a-range-on-an-excel-sheet.yaml
@@ -7,7 +7,8 @@ categories:
   - strings
   - arrays
 patterns:
-  - matrix-traversal
+  - slug: matrix-traversal
+    is_optimal: true
 
 function_signature: "def cells_in_range(s: str) -> list[str]:"
 
diff --git a/backend/data/questions/cells-with-odd-values-in-a-matrix.yaml b/backend/data/questions/cells-with-odd-values-in-a-matrix.yaml
index db5e911..de25aed 100644
--- a/backend/data/questions/cells-with-odd-values-in-a-matrix.yaml
+++ b/backend/data/questions/cells-with-odd-values-in-a-matrix.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - math
 patterns:
-  - prefix-sum
+  - slug: prefix-sum
+    is_optimal: true
 
 function_signature: "def odd_cells(m: int, n: int, indices: list[list[int]]) -> int:"
 
diff --git a/backend/data/questions/chalkboard-xor-game.yaml b/backend/data/questions/chalkboard-xor-game.yaml
index 115c942..5860e0f 100644
--- a/backend/data/questions/chalkboard-xor-game.yaml
+++ b/backend/data/questions/chalkboard-xor-game.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - math
 patterns:
-  - greedy
+  - slug: greedy
+    is_optimal: true
 
 function_signature: "def xor_game(nums: list[int]) -> bool:"
 
diff --git a/backend/data/questions/champagne-tower.yaml b/backend/data/questions/champagne-tower.yaml
index 342da28..98b798d 100644
--- a/backend/data/questions/champagne-tower.yaml
+++ b/backend/data/questions/champagne-tower.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - dynamic-programming
 patterns:
-  - dynamic-programming
+  - slug: dynamic-programming
+    is_optimal: true
 
 function_signature: "def champagne_tower(poured: int, query_row: int, query_glass: int) -> float:"
 
diff --git a/backend/data/questions/change-minimum-characters-to-satisfy-one-of-three-conditions.yaml b/backend/data/questions/change-minimum-characters-to-satisfy-one-of-three-conditions.yaml
index 01d9160..1b0cc0a 100644
--- a/backend/data/questions/change-minimum-characters-to-satisfy-one-of-three-conditions.yaml
+++ b/backend/data/questions/change-minimum-characters-to-satisfy-one-of-three-conditions.yaml
@@ -7,7 +7,8 @@ categories:
   - strings
   - hash-tables
 patterns:
-  - prefix-sum
+  - slug: prefix-sum
+    is_optimal: true
 
 function_signature: "def min_characters(a: str, b: str) -> int:"
 
diff --git a/backend/data/questions/cheapest-flights-within-k-stops.yaml b/backend/data/questions/cheapest-flights-within-k-stops.yaml
index 059d62f..0eceaed 100644
--- a/backend/data/questions/cheapest-flights-within-k-stops.yaml
+++ b/backend/data/questions/cheapest-flights-within-k-stops.yaml
@@ -7,8 +7,10 @@ categories:
   - graphs
   - dynamic-programming
 patterns:
-  - bfs
-  - dynamic-programming
+  - slug: bfs
+    is_optimal: true
+  - slug: dynamic-programming
+    is_optimal: false
 
 function_signature: "def findCheapestPrice(n: int, flights: list[list[int]], src: int, dst: int, k: int) -> int:"
 
diff --git a/backend/data/questions/check-array-formation-through-concatenation.yaml b/backend/data/questions/check-array-formation-through-concatenation.yaml
index da7d08c..709a137 100644
--- a/backend/data/questions/check-array-formation-through-concatenation.yaml
+++ b/backend/data/questions/check-array-formation-through-concatenation.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - hash-tables
 patterns:
-  - greedy
+  - slug: greedy
+    is_optimal: true
 
 function_signature: "def can_form_array(arr: list[int], pieces: list[list[int]]) -> bool:"
 
diff --git a/backend/data/questions/check-completeness-of-a-binary-tree.yaml b/backend/data/questions/check-completeness-of-a-binary-tree.yaml
index c48a6ff..48d47a1 100644
--- a/backend/data/questions/check-completeness-of-a-binary-tree.yaml
+++ b/backend/data/questions/check-completeness-of-a-binary-tree.yaml
@@ -6,8 +6,10 @@ leetcode_url: https://leetcode.com/problems/check-completeness-of-a-binary-tree/
 categories:
   - trees
 patterns:
-  - bfs
-  - tree-traversal
+  - slug: bfs
+    is_optimal: true
+  - slug: tree-traversal
+    is_optimal: false
 
 function_signature: "def is_complete_tree(root: TreeNode) -> bool:"
 
diff --git a/backend/data/questions/check-distances-between-same-letters.yaml b/backend/data/questions/check-distances-between-same-letters.yaml
index ce2b265..18fbb2a 100644
--- a/backend/data/questions/check-distances-between-same-letters.yaml
+++ b/backend/data/questions/check-distances-between-same-letters.yaml
@@ -8,7 +8,8 @@ categories:
   - strings
   - hash-tables
 patterns:
-  - two-pointers
+  - slug: two-pointers
+    is_optimal: true
 
 function_signature: "def check_distances(s: str, distance: list[int]) -> bool:"
 
diff --git a/backend/data/questions/check-if-a-parentheses-string-can-be-valid.yaml b/backend/data/questions/check-if-a-parentheses-string-can-be-valid.yaml
index a240d72..f21aa45 100644
--- a/backend/data/questions/check-if-a-parentheses-string-can-be-valid.yaml
+++ b/backend/data/questions/check-if-a-parentheses-string-can-be-valid.yaml
@@ -7,7 +7,8 @@ categories:
   - strings
   - stack
 patterns:
-  - greedy
+  - slug: greedy
+    is_optimal: true
 
 function_signature: "def can_be_valid(s: str, locked: str) -> bool:"
 
diff --git a/backend/data/questions/check-if-a-string-can-break-another-string.yaml b/backend/data/questions/check-if-a-string-can-break-another-string.yaml
index 23d8f70..00f1fa7 100644
--- a/backend/data/questions/check-if-a-string-can-break-another-string.yaml
+++ b/backend/data/questions/check-if-a-string-can-break-another-string.yaml
@@ -7,7 +7,8 @@ categories:
   - strings
   - sorting
 patterns:
-  - greedy
+  - slug: greedy
+    is_optimal: true
 
 function_signature: "def check_if_can_break(s1: str, s2: str) -> bool:"
 
diff --git a/backend/data/questions/check-if-a-string-contains-all-binary-codes-of-size-k.yaml b/backend/data/questions/check-if-a-string-contains-all-binary-codes-of-size-k.yaml
index c29c0c3..f203980 100644
--- a/backend/data/questions/check-if-a-string-contains-all-binary-codes-of-size-k.yaml
+++ b/backend/data/questions/check-if-a-string-contains-all-binary-codes-of-size-k.yaml
@@ -7,7 +7,8 @@ categories:
   - strings
   - hash-tables
 patterns:
-  - sliding-window
+  - slug: sliding-window
+    is_optimal: true
 
 function_signature: "def has_all_codes(s: str, k: int) -> bool:"
 
diff --git a/backend/data/questions/check-if-all-1s-are-at-least-length-k-places-away.yaml b/backend/data/questions/check-if-all-1s-are-at-least-length-k-places-away.yaml
index c2da6f3..edae68f 100644
--- a/backend/data/questions/check-if-all-1s-are-at-least-length-k-places-away.yaml
+++ b/backend/data/questions/check-if-all-1s-are-at-least-length-k-places-away.yaml
@@ -6,7 +6,8 @@ leetcode_url: https://leetcode.com/problems/check-if-all-1s-are-at-least-length-
 categories:
   - arrays
 patterns:
-  - two-pointers
+  - slug: two-pointers
+    is_optimal: true
 
 function_signature: "def k_length_apart(nums: list[int], k: int) -> bool:"
 
diff --git a/backend/data/questions/check-if-all-characters-have-equal-number-of-occurrences.yaml b/backend/data/questions/check-if-all-characters-have-equal-number-of-occurrences.yaml
index 38f1843..e5d5e9c 100644
--- a/backend/data/questions/check-if-all-characters-have-equal-number-of-occurrences.yaml
+++ b/backend/data/questions/check-if-all-characters-have-equal-number-of-occurrences.yaml
@@ -7,7 +7,8 @@ categories:
   - strings
   - hash-tables
 patterns:
-  - prefix-sum
+  - slug: prefix-sum
+    is_optimal: true
 
 function_signature: "def are_occurrences_equal(s: str) -> bool:"
 
diff --git a/backend/data/questions/check-if-all-integers-in-range-are-covered.yaml b/backend/data/questions/check-if-all-integers-in-range-are-covered.yaml
index fa73dfb..74c13f3 100644
--- a/backend/data/questions/check-if-all-integers-in-range-are-covered.yaml
+++ b/backend/data/questions/check-if-all-integers-in-range-are-covered.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - hash-tables
 patterns:
-  - prefix-sum
+  - slug: prefix-sum
+    is_optimal: true
 
 function_signature: "def is_covered(ranges: list[list[int]], left: int, right: int) -> bool:"
 
diff --git a/backend/data/questions/check-if-an-original-string-exists-given-two-encoded-strings.yaml b/backend/data/questions/check-if-an-original-string-exists-given-two-encoded-strings.yaml
index afd5baf..d533ea0 100644
--- a/backend/data/questions/check-if-an-original-string-exists-given-two-encoded-strings.yaml
+++ b/backend/data/questions/check-if-an-original-string-exists-given-two-encoded-strings.yaml
@@ -7,7 +7,8 @@ categories:
   - strings
   - dynamic-programming
 patterns:
-  - dynamic-programming
+  - slug: dynamic-programming
+    is_optimal: true
 
 function_signature: "def possibly_equals(s1: str, s2: str) -> bool:"
 
diff --git a/backend/data/questions/check-if-array-is-sorted-and-rotated.yaml b/backend/data/questions/check-if-array-is-sorted-and-rotated.yaml
index 6536e3b..9305235 100644
--- a/backend/data/questions/check-if-array-is-sorted-and-rotated.yaml
+++ b/backend/data/questions/check-if-array-is-sorted-and-rotated.yaml
@@ -6,7 +6,8 @@ leetcode_url: https://leetcode.com/problems/check-if-array-is-sorted-and-rotated
 categories:
   - arrays
 patterns:
-  - two-pointers
+  - slug: two-pointers
+    is_optimal: true
 
 function_signature: "def check(nums: list[int]) -> bool:"
 
diff --git a/backend/data/questions/check-if-array-pairs-are-divisible-by-k.yaml b/backend/data/questions/check-if-array-pairs-are-divisible-by-k.yaml
index 49b13b8..2a09235 100644
--- a/backend/data/questions/check-if-array-pairs-are-divisible-by-k.yaml
+++ b/backend/data/questions/check-if-array-pairs-are-divisible-by-k.yaml
@@ -8,7 +8,8 @@ categories:
   - hash-tables
   - math
 patterns:
-  - prefix-sum
+  - slug: prefix-sum
+    is_optimal: true
 
 function_signature: "def can_arrange(arr: list[int], k: int) -> bool:"
 
diff --git a/backend/data/questions/check-if-binary-string-has-at-most-one-segment-of-ones.yaml b/backend/data/questions/check-if-binary-string-has-at-most-one-segment-of-ones.yaml
index faa3413..69ecbd7 100644
--- a/backend/data/questions/check-if-binary-string-has-at-most-one-segment-of-ones.yaml
+++ b/backend/data/questions/check-if-binary-string-has-at-most-one-segment-of-ones.yaml
@@ -6,7 +6,8 @@ leetcode_url: https://leetcode.com/problems/check-if-binary-string-has-at-most-o
 categories:
   - strings
 patterns:
-  - two-pointers
+  - slug: two-pointers
+    is_optimal: true
 
 function_signature: "def check_ones_segment(s: str) -> bool:"
 
diff --git a/backend/data/questions/check-if-every-row-and-column-contains-all-numbers.yaml b/backend/data/questions/check-if-every-row-and-column-contains-all-numbers.yaml
index e48d4aa..c1c634a 100644
--- a/backend/data/questions/check-if-every-row-and-column-contains-all-numbers.yaml
+++ b/backend/data/questions/check-if-every-row-and-column-contains-all-numbers.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - hash-tables
 patterns:
-  - matrix-traversal
+  - slug: matrix-traversal
+    is_optimal: true
 
 function_signature: "def check_valid(matrix: list[list[int]]) -> bool:"
 
diff --git a/backend/data/questions/check-if-it-is-a-good-array.yaml b/backend/data/questions/check-if-it-is-a-good-array.yaml
index 12d39be..d0e5a76 100644
--- a/backend/data/questions/check-if-it-is-a-good-array.yaml
+++ b/backend/data/questions/check-if-it-is-a-good-array.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - math
 patterns:
-  - greedy
+  - slug: greedy
+    is_optimal: true
 
 function_signature: "def is_good_array(nums: list[int]) -> bool:"
 
diff --git a/backend/data/questions/check-if-it-is-a-straight-line.yaml b/backend/data/questions/check-if-it-is-a-straight-line.yaml
index 309dfd6..9a71911 100644
--- a/backend/data/questions/check-if-it-is-a-straight-line.yaml
+++ b/backend/data/questions/check-if-it-is-a-straight-line.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - math
 patterns:
-  - two-pointers
+  - slug: two-pointers
+    is_optimal: true
 
 function_signature: "def check_straight_line(coordinates: list[list[int]]) -> bool:"
 
diff --git a/backend/data/questions/check-if-matrix-is-x-matrix.yaml b/backend/data/questions/check-if-matrix-is-x-matrix.yaml
index dcddeef..9bb1532 100644
--- a/backend/data/questions/check-if-matrix-is-x-matrix.yaml
+++ b/backend/data/questions/check-if-matrix-is-x-matrix.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - math
 patterns:
-  - matrix-traversal
+  - slug: matrix-traversal
+    is_optimal: true
 
 function_signature: "def check_x_matrix(grid: list[list[int]]) -> bool:"
 
diff --git a/backend/data/questions/check-if-move-is-legal.yaml b/backend/data/questions/check-if-move-is-legal.yaml
index ff7d3e9..736319f 100644
--- a/backend/data/questions/check-if-move-is-legal.yaml
+++ b/backend/data/questions/check-if-move-is-legal.yaml
@@ -6,7 +6,8 @@ leetcode_url: https://leetcode.com/problems/check-if-move-is-legal/
 categories:
   - arrays
 patterns:
-  - matrix-traversal
+  - slug: matrix-traversal
+    is_optimal: true
 
 function_signature: "def check_move(board: list[list[str]], r_move: int, c_move: int, color: str) -> bool:"
 
diff --git a/backend/data/questions/check-if-n-and-its-double-exist.yaml b/backend/data/questions/check-if-n-and-its-double-exist.yaml
index 7b181ce..a37e0e0 100644
--- a/backend/data/questions/check-if-n-and-its-double-exist.yaml
+++ b/backend/data/questions/check-if-n-and-its-double-exist.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - hash-tables
 patterns:
-  - two-pointers
+  - slug: two-pointers
+    is_optimal: true
 
 function_signature: "def check_if_exist(arr: list[int]) -> bool:"
 
diff --git a/backend/data/questions/check-if-number-has-equal-digit-count-and-digit-value.yaml b/backend/data/questions/check-if-number-has-equal-digit-count-and-digit-value.yaml
index 625b07f..fbbd38f 100644
--- a/backend/data/questions/check-if-number-has-equal-digit-count-and-digit-value.yaml
+++ b/backend/data/questions/check-if-number-has-equal-digit-count-and-digit-value.yaml
@@ -7,7 +7,8 @@ categories:
   - strings
   - hash-tables
 patterns:
-  - prefix-sum
+  - slug: prefix-sum
+    is_optimal: true
 
 function_signature: "def digit_count(num: str) -> bool:"
 
diff --git a/backend/data/questions/check-if-number-is-a-sum-of-powers-of-three.yaml b/backend/data/questions/check-if-number-is-a-sum-of-powers-of-three.yaml
index c0b5a35..4b31ef5 100644
--- a/backend/data/questions/check-if-number-is-a-sum-of-powers-of-three.yaml
+++ b/backend/data/questions/check-if-number-is-a-sum-of-powers-of-three.yaml
@@ -6,7 +6,8 @@ leetcode_url: https://leetcode.com/problems/check-if-number-is-a-sum-of-powers-o
 categories:
   - math
 patterns:
-  - greedy
+  - slug: greedy
+    is_optimal: true
 
 function_signature: "def check_powers_of_three(n: int) -> bool:"
 
diff --git a/backend/data/questions/check-if-numbers-are-ascending-in-a-sentence.yaml b/backend/data/questions/check-if-numbers-are-ascending-in-a-sentence.yaml
index 3086ac8..fa3d541 100644
--- a/backend/data/questions/check-if-numbers-are-ascending-in-a-sentence.yaml
+++ b/backend/data/questions/check-if-numbers-are-ascending-in-a-sentence.yaml
@@ -6,7 +6,8 @@ leetcode_url: https://leetcode.com/problems/check-if-numbers-are-ascending-in-a-
 categories:
   - strings
 patterns:
-  - two-pointers
+  - slug: two-pointers
+    is_optimal: true
 
 function_signature: "def are_numbers_ascending(s: str) -> bool:"
 
diff --git a/backend/data/questions/check-if-object-instance-of-class.yaml b/backend/data/questions/check-if-object-instance-of-class.yaml
index b66b5de..0340134 100644
--- a/backend/data/questions/check-if-object-instance-of-class.yaml
+++ b/backend/data/questions/check-if-object-instance-of-class.yaml
@@ -6,7 +6,8 @@ leetcode_url: https://leetcode.com/problems/check-if-object-instance-of-class/
 categories:
   - recursion
 patterns:
-  - dfs
+  - slug: dfs
+    is_optimal: true
 
 function_signature: "function checkIfInstanceOf(obj, classFunction)"
 
diff --git a/backend/data/questions/check-if-one-string-swap-can-make-strings-equal.yaml b/backend/data/questions/check-if-one-string-swap-can-make-strings-equal.yaml
index 8d85937..ecde6ac 100644
--- a/backend/data/questions/check-if-one-string-swap-can-make-strings-equal.yaml
+++ b/backend/data/questions/check-if-one-string-swap-can-make-strings-equal.yaml
@@ -7,7 +7,8 @@ categories:
   - strings
   - hash-tables
 patterns:
-  - two-pointers
+  - slug: two-pointers
+    is_optimal: true
 
 function_signature: "def are_almost_equal(s1: str, s2: str) -> bool:"
 
diff --git a/backend/data/questions/check-if-point-is-reachable.yaml b/backend/data/questions/check-if-point-is-reachable.yaml
index 03b078b..053d0e0 100644
--- a/backend/data/questions/check-if-point-is-reachable.yaml
+++ b/backend/data/questions/check-if-point-is-reachable.yaml
@@ -6,7 +6,8 @@ leetcode_url: https://leetcode.com/problems/check-if-point-is-reachable/
 categories:
   - math
 patterns:
-  - greedy
+  - slug: greedy
+    is_optimal: true
 
 function_signature: "def is_reachable(target_x: int, target_y: int) -> bool:"
 
diff --git a/backend/data/questions/check-if-string-is-a-prefix-of-array.yaml b/backend/data/questions/check-if-string-is-a-prefix-of-array.yaml
index 9ff13b9..9f56cc3 100644
--- a/backend/data/questions/check-if-string-is-a-prefix-of-array.yaml
+++ b/backend/data/questions/check-if-string-is-a-prefix-of-array.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - strings
 patterns:
-  - two-pointers
+  - slug: two-pointers
+    is_optimal: true
 
 function_signature: "def is_prefix_string(s: str, words: list[str]) -> bool:"
 
diff --git a/backend/data/questions/check-if-string-is-transformable-with-substring-sort-operations.yaml b/backend/data/questions/check-if-string-is-transformable-with-substring-sort-operations.yaml
index d164b85..2bd24c6 100644
--- a/backend/data/questions/check-if-string-is-transformable-with-substring-sort-operations.yaml
+++ b/backend/data/questions/check-if-string-is-transformable-with-substring-sort-operations.yaml
@@ -7,7 +7,8 @@ categories:
   - strings
   - sorting
 patterns:
-  - greedy
+  - slug: greedy
+    is_optimal: true
 
 function_signature: "def is_transformable(s: str, t: str) -> bool:"
 
diff --git a/backend/data/questions/check-if-the-sentence-is-pangram.yaml b/backend/data/questions/check-if-the-sentence-is-pangram.yaml
index 9fc6c6f..f97ced3 100644
--- a/backend/data/questions/check-if-the-sentence-is-pangram.yaml
+++ b/backend/data/questions/check-if-the-sentence-is-pangram.yaml
@@ -7,7 +7,8 @@ categories:
   - strings
   - hash-tables
 patterns:
-  - prefix-sum
+  - slug: prefix-sum
+    is_optimal: true
 
 function_signature: "def check_if_pangram(sentence: str) -> bool:"
 
diff --git a/backend/data/questions/check-if-there-is-a-valid-parentheses-string-path.yaml b/backend/data/questions/check-if-there-is-a-valid-parentheses-string-path.yaml
index 0991d59..fc5ecc4 100644
--- a/backend/data/questions/check-if-there-is-a-valid-parentheses-string-path.yaml
+++ b/backend/data/questions/check-if-there-is-a-valid-parentheses-string-path.yaml
@@ -7,9 +7,12 @@ categories:
   - arrays
   - dynamic-programming
 patterns:
-  - dynamic-programming
-  - matrix-traversal
-  - dfs
+  - slug: dynamic-programming
+    is_optimal: false
+  - slug: matrix-traversal
+    is_optimal: true
+  - slug: dfs
+    is_optimal: false
 
 function_signature: "def has_valid_path(grid: list[list[str]]) -> bool:"
 
diff --git a/backend/data/questions/check-if-there-is-a-valid-partition-for-the-array.yaml b/backend/data/questions/check-if-there-is-a-valid-partition-for-the-array.yaml
index 80a544b..b7e58d4 100644
--- a/backend/data/questions/check-if-there-is-a-valid-partition-for-the-array.yaml
+++ b/backend/data/questions/check-if-there-is-a-valid-partition-for-the-array.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - dynamic-programming
 patterns:
-  - dynamic-programming
+  - slug: dynamic-programming
+    is_optimal: true
 
 function_signature: "def valid_partition(nums: list[int]) -> bool:"
 
diff --git a/backend/data/questions/check-if-there-is-a-valid-path-in-a-grid.yaml b/backend/data/questions/check-if-there-is-a-valid-path-in-a-grid.yaml
index 87e7bfd..00f823a 100644
--- a/backend/data/questions/check-if-there-is-a-valid-path-in-a-grid.yaml
+++ b/backend/data/questions/check-if-there-is-a-valid-path-in-a-grid.yaml
@@ -7,10 +7,14 @@ categories:
   - arrays
   - graphs
 patterns:
-  - bfs
-  - dfs
-  - matrix-traversal
-  - union-find
+  - slug: bfs
+    is_optimal: false
+  - slug: dfs
+    is_optimal: false
+  - slug: matrix-traversal
+    is_optimal: false
+  - slug: union-find
+    is_optimal: true
 
 function_signature: "def has_valid_path(grid: list[list[int]]) -> bool:"
 
diff --git a/backend/data/questions/check-if-two-string-arrays-are-equivalent.yaml b/backend/data/questions/check-if-two-string-arrays-are-equivalent.yaml
index 74aace5..d104011 100644
--- a/backend/data/questions/check-if-two-string-arrays-are-equivalent.yaml
+++ b/backend/data/questions/check-if-two-string-arrays-are-equivalent.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - strings
 patterns:
-  - two-pointers
+  - slug: two-pointers
+    is_optimal: true
 
 function_signature: "def array_strings_are_equal(word1: list[str], word2: list[str]) -> bool:"
 
diff --git a/backend/data/questions/check-if-word-can-be-placed-in-crossword.yaml b/backend/data/questions/check-if-word-can-be-placed-in-crossword.yaml
index 856d8be..68d02d9 100644
--- a/backend/data/questions/check-if-word-can-be-placed-in-crossword.yaml
+++ b/backend/data/questions/check-if-word-can-be-placed-in-crossword.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - strings
 patterns:
-  - matrix-traversal
+  - slug: matrix-traversal
+    is_optimal: true
 
 function_signature: "def place_word_in_crossword(board: list[list[str]], word: str) -> bool:"
 
diff --git a/backend/data/questions/check-if-word-equals-summation-of-two-words.yaml b/backend/data/questions/check-if-word-equals-summation-of-two-words.yaml
index 5f67d18..a7f872b 100644
--- a/backend/data/questions/check-if-word-equals-summation-of-two-words.yaml
+++ b/backend/data/questions/check-if-word-equals-summation-of-two-words.yaml
@@ -6,7 +6,8 @@ leetcode_url: https://leetcode.com/problems/check-if-word-equals-summation-of-tw
 categories:
   - strings
 patterns:
-  - greedy
+  - slug: greedy
+    is_optimal: true
 
 function_signature: "def is_sum_equal(first_word: str, second_word: str, target_word: str) -> bool:"
 
diff --git a/backend/data/questions/check-if-word-is-valid-after-substitutions.yaml b/backend/data/questions/check-if-word-is-valid-after-substitutions.yaml
index 950ac93..2b937cd 100644
--- a/backend/data/questions/check-if-word-is-valid-after-substitutions.yaml
+++ b/backend/data/questions/check-if-word-is-valid-after-substitutions.yaml
@@ -7,7 +7,8 @@ categories:
   - strings
   - stack
 patterns:
-  - monotonic-stack
+  - slug: monotonic-stack
+    is_optimal: true
 
 function_signature: "def is_valid(s: str) -> bool:"
 
diff --git a/backend/data/questions/check-if-word-occurs-as-prefix.yaml b/backend/data/questions/check-if-word-occurs-as-prefix.yaml
index e56ee75..e097996 100644
--- a/backend/data/questions/check-if-word-occurs-as-prefix.yaml
+++ b/backend/data/questions/check-if-word-occurs-as-prefix.yaml
@@ -6,7 +6,8 @@ leetcode_url: https://leetcode.com/problems/check-if-a-word-occurs-as-a-prefix-o
 categories:
   - strings
 patterns:
-  - two-pointers
+  - slug: two-pointers
+    is_optimal: true
 
 function_signature: "def is_prefix_of_word(sentence: str, search_word: str) -> int:"
 
diff --git a/backend/data/questions/check-knight-tour-configuration.yaml b/backend/data/questions/check-knight-tour-configuration.yaml
index 09fabae..36fa43b 100644
--- a/backend/data/questions/check-knight-tour-configuration.yaml
+++ b/backend/data/questions/check-knight-tour-configuration.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - graphs
 patterns:
-  - matrix-traversal
+  - slug: matrix-traversal
+    is_optimal: true
 
 function_signature: "def check_valid_grid(grid: list[list[int]]) -> bool:"
 
diff --git a/backend/data/questions/checking-existence-of-edge-length-limited-paths.yaml b/backend/data/questions/checking-existence-of-edge-length-limited-paths.yaml
index 4ed47ae..ba5515d 100644
--- a/backend/data/questions/checking-existence-of-edge-length-limited-paths.yaml
+++ b/backend/data/questions/checking-existence-of-edge-length-limited-paths.yaml
@@ -8,8 +8,10 @@ categories:
   - sorting
   - arrays
 patterns:
-  - union-find
-  - two-pointers
+  - slug: union-find
+    is_optimal: true
+  - slug: two-pointers
+    is_optimal: false
 
 function_signature: "def distance_limited_paths_exist(n: int, edge_list: list[list[int]], queries: list[list[int]]) -> list[bool]:"
 
diff --git a/backend/data/questions/climbing-stairs.yaml b/backend/data/questions/climbing-stairs.yaml
index c30cb74..6fca522 100644
--- a/backend/data/questions/climbing-stairs.yaml
+++ b/backend/data/questions/climbing-stairs.yaml
@@ -7,7 +7,8 @@ categories:
   - dynamic-programming
   - math
 patterns:
-  - dynamic-programming
+  - slug: dynamic-programming
+    is_optimal: true
 
 function_signature: "def climb_stairs(n: int) -> int:"
 
diff --git a/backend/data/questions/clone-graph.yaml b/backend/data/questions/clone-graph.yaml
index 4875e15..e0700db 100644
--- a/backend/data/questions/clone-graph.yaml
+++ b/backend/data/questions/clone-graph.yaml
@@ -7,8 +7,10 @@ categories:
   - graphs
   - hash-tables
 patterns:
-  - dfs
-  - bfs
+  - slug: dfs
+    is_optimal: false
+  - slug: bfs
+    is_optimal: true
 
 function_signature: "def clone_graph(node: Node | None) -> Node | None:"
 
diff --git a/backend/data/questions/coin-change-ii.yaml b/backend/data/questions/coin-change-ii.yaml
index e9b9c67..9191c4d 100644
--- a/backend/data/questions/coin-change-ii.yaml
+++ b/backend/data/questions/coin-change-ii.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - dynamic-programming
 patterns:
-  - dynamic-programming
+  - slug: dynamic-programming
+    is_optimal: true
 
 function_signature: "def change(amount: int, coins: list[int]) -> int:"
 
diff --git a/backend/data/questions/coin-change.yaml b/backend/data/questions/coin-change.yaml
index f173502..8bddf41 100644
--- a/backend/data/questions/coin-change.yaml
+++ b/backend/data/questions/coin-change.yaml
@@ -7,7 +7,8 @@ categories:
   - dynamic-programming
   - arrays
 patterns:
-  - dynamic-programming
+  - slug: dynamic-programming
+    is_optimal: true
 
 function_signature: "def coin_change(coins: list[int], amount: int) -> int:"
 
diff --git a/backend/data/questions/combination-sum-ii.yaml b/backend/data/questions/combination-sum-ii.yaml
index 5d3e394..16bc990 100644
--- a/backend/data/questions/combination-sum-ii.yaml
+++ b/backend/data/questions/combination-sum-ii.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - recursion
 patterns:
-  - backtracking
+  - slug: backtracking
+    is_optimal: true
 
 function_signature: "def combination_sum2(candidates: list[int], target: int) -> list[list[int]]:"
 
diff --git a/backend/data/questions/combination-sum-iii.yaml b/backend/data/questions/combination-sum-iii.yaml
index aed18c9..6774937 100644
--- a/backend/data/questions/combination-sum-iii.yaml
+++ b/backend/data/questions/combination-sum-iii.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - recursion
 patterns:
-  - backtracking
+  - slug: backtracking
+    is_optimal: true
 
 function_signature: "def combination_sum3(k: int, n: int) -> list[list[int]]:"
 
diff --git a/backend/data/questions/combination-sum-iv.yaml b/backend/data/questions/combination-sum-iv.yaml
index 7cde568..b1a4e70 100644
--- a/backend/data/questions/combination-sum-iv.yaml
+++ b/backend/data/questions/combination-sum-iv.yaml
@@ -7,7 +7,8 @@ categories:
   - dynamic-programming
   - arrays
 patterns:
-  - dynamic-programming
+  - slug: dynamic-programming
+    is_optimal: true
 
 function_signature: "def combination_sum4(nums: list[int], target: int) -> int:"
 
diff --git a/backend/data/questions/combination-sum.yaml b/backend/data/questions/combination-sum.yaml
index ed266cc..ffc9dd6 100644
--- a/backend/data/questions/combination-sum.yaml
+++ b/backend/data/questions/combination-sum.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - recursion
 patterns:
-  - backtracking
+  - slug: backtracking
+    is_optimal: true
 
 function_signature: "def combination_sum(candidates: list[int], target: int) -> list[list[int]]:"
 
diff --git a/backend/data/questions/combinations.yaml b/backend/data/questions/combinations.yaml
index 5c5c178..8a26d91 100644
--- a/backend/data/questions/combinations.yaml
+++ b/backend/data/questions/combinations.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - recursion
 patterns:
-  - backtracking
+  - slug: backtracking
+    is_optimal: true
 
 function_signature: "def combine(n: int, k: int) -> list[list[int]]:"
 
diff --git a/backend/data/questions/concatenation-of-array.yaml b/backend/data/questions/concatenation-of-array.yaml
index 32185f7..0605165 100644
--- a/backend/data/questions/concatenation-of-array.yaml
+++ b/backend/data/questions/concatenation-of-array.yaml
@@ -6,7 +6,8 @@ leetcode_url: https://leetcode.com/problems/concatenation-of-array/
 categories:
   - arrays
 patterns:
-  - two-pointers
+  - slug: two-pointers
+    is_optimal: true
 
 function_signature: "def get_concatenation(nums: list[int]) -> list[int]:"
 
diff --git a/backend/data/questions/construct-binary-tree-from-preorder-and-inorder-traversal.yaml b/backend/data/questions/construct-binary-tree-from-preorder-and-inorder-traversal.yaml
index e8f9aa0..2483df8 100644
--- a/backend/data/questions/construct-binary-tree-from-preorder-and-inorder-traversal.yaml
+++ b/backend/data/questions/construct-binary-tree-from-preorder-and-inorder-traversal.yaml
@@ -8,8 +8,10 @@ categories:
   - arrays
   - hash-tables
 patterns:
-  - dfs
-  - tree-traversal
+  - slug: dfs
+    is_optimal: true
+  - slug: tree-traversal
+    is_optimal: false
 
 function_signature: "def build_tree(preorder: list[int], inorder: list[int]) -> TreeNode | None:"
 
diff --git a/backend/data/questions/construct-quad-tree.yaml b/backend/data/questions/construct-quad-tree.yaml
index 428b833..e80feb1 100644
--- a/backend/data/questions/construct-quad-tree.yaml
+++ b/backend/data/questions/construct-quad-tree.yaml
@@ -8,8 +8,10 @@ categories:
   - trees
   - recursion
 patterns:
-  - matrix-traversal
-  - dfs
+  - slug: matrix-traversal
+    is_optimal: true
+  - slug: dfs
+    is_optimal: false
 
 function_signature: "def construct(grid: list[list[int]]) -> Node:"
 
diff --git a/backend/data/questions/container-with-most-water.yaml b/backend/data/questions/container-with-most-water.yaml
index 39d1b92..0ba477b 100644
--- a/backend/data/questions/container-with-most-water.yaml
+++ b/backend/data/questions/container-with-most-water.yaml
@@ -7,8 +7,10 @@ categories:
   - arrays
   - two-pointers
 patterns:
-  - two-pointers
-  - greedy
+  - slug: two-pointers
+    is_optimal: true
+  - slug: greedy
+    is_optimal: false
 
 function_signature: "def max_area(height: list[int]) -> int:"
 
diff --git a/backend/data/questions/contains-duplicate-ii.yaml b/backend/data/questions/contains-duplicate-ii.yaml
index 0b93ad6..4bf1687 100644
--- a/backend/data/questions/contains-duplicate-ii.yaml
+++ b/backend/data/questions/contains-duplicate-ii.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - hash-tables
 patterns:
-  - sliding-window
+  - slug: sliding-window
+    is_optimal: true
 
 function_signature: "def contains_nearby_duplicate(nums: list[int], k: int) -> bool:"
 
diff --git a/backend/data/questions/contains-duplicate.yaml b/backend/data/questions/contains-duplicate.yaml
index 76b06ec..03ca4e5 100644
--- a/backend/data/questions/contains-duplicate.yaml
+++ b/backend/data/questions/contains-duplicate.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - hash-tables
 patterns:
-  - heap
+  - slug: hashing
+    is_optimal: true
 
 function_signature: "def contains_duplicate(nums: list[int]) -> bool:"
 
@@ -138,6 +139,38 @@ explanation:
   time_complexity: "O(n). We traverse the array once, with O(1) set operations at each step."
   space_complexity: "O(n). In the worst case (all unique elements), we store all n elements in the set."
 
+  pattern_comparison: |
+    **Hash Set vs Sorting: The Classic Space-Time Trade-off**
+
+    Two fundamentally different approaches, each optimal in different contexts:
+
+    | Approach | Time | Space | Modifies Input? | Early Exit? |
+    |----------|------|-------|-----------------|-------------|
+    | **Hash Set** | O(n) | O(n) | No | Yes |
+    | **Sorting** | O(n log n) | O(1)* | Yes | Yes |
+
+    *In-place sorting like quicksort uses O(1) extra space (ignoring recursion stack).
+
+    **When Hash Set is better:**
+    - Memory is plentiful (most modern systems)
+    - Input must not be modified
+    - You need the fastest possible runtime
+    - Data is already streaming in one element at a time
+
+    **When Sorting is better:**
+    - Memory is extremely constrained (embedded systems, very large arrays)
+    - Modifying the input is acceptable
+    - You also need the sorted array for subsequent operations
+    - The data is nearly sorted (adaptive sorts like Timsort are very fast)
+
+    **The one-liner alternative:**
+    ```python
+    return len(nums) != len(set(nums))
+    ```
+    This is clean and Pythonic, but always processes all elements (no early exit). The iterative set approach can exit immediately upon finding a duplicate, which is faster when duplicates appear early.
+
+    **Foundation pattern**: This simple problem teaches the fundamental "have I seen this before?" pattern that appears in Two Sum, cycle detection, and many other problems.
+
 solutions:
   - approach_name: Hash Set
     is_optimal: true
diff --git a/backend/data/questions/continuous-subarray-sum.yaml b/backend/data/questions/continuous-subarray-sum.yaml
index d6465e7..1995a8f 100644
--- a/backend/data/questions/continuous-subarray-sum.yaml
+++ b/backend/data/questions/continuous-subarray-sum.yaml
@@ -8,7 +8,8 @@ categories:
   - hash-tables
   - math
 patterns:
-  - prefix-sum
+  - slug: prefix-sum
+    is_optimal: true
 
 function_signature: "def check_subarray_sum(nums: list[int], k: int) -> bool:"
 
diff --git a/backend/data/questions/convert-bst-to-greater-tree.yaml b/backend/data/questions/convert-bst-to-greater-tree.yaml
index 939a8c9..41422be 100644
--- a/backend/data/questions/convert-bst-to-greater-tree.yaml
+++ b/backend/data/questions/convert-bst-to-greater-tree.yaml
@@ -6,8 +6,10 @@ leetcode_url: https://leetcode.com/problems/convert-bst-to-greater-tree/
 categories:
   - trees
 patterns:
-  - dfs
-  - tree-traversal
+  - slug: dfs
+    is_optimal: true
+  - slug: tree-traversal
+    is_optimal: false
 
 function_signature: "def convert_bst(root: TreeNode | None) -> TreeNode | None:"
 
diff --git a/backend/data/questions/convert-sorted-array-to-binary-search-tree.yaml b/backend/data/questions/convert-sorted-array-to-binary-search-tree.yaml
index b158715..ba47387 100644
--- a/backend/data/questions/convert-sorted-array-to-binary-search-tree.yaml
+++ b/backend/data/questions/convert-sorted-array-to-binary-search-tree.yaml
@@ -8,8 +8,10 @@ categories:
   - trees
   - recursion
 patterns:
-  - binary-search
-  - dfs
+  - slug: binary-search
+    is_optimal: true
+  - slug: dfs
+    is_optimal: false
 
 function_signature: "def sorted_array_to_bst(nums: list[int]) -> TreeNode | None:"
 
diff --git a/backend/data/questions/copy-list-with-random-pointer.yaml b/backend/data/questions/copy-list-with-random-pointer.yaml
index 9b7bf26..75985cd 100644
--- a/backend/data/questions/copy-list-with-random-pointer.yaml
+++ b/backend/data/questions/copy-list-with-random-pointer.yaml
@@ -7,7 +7,8 @@ categories:
   - linked-lists
   - hash-tables
 patterns:
-  - linkedlist-reversal
+  - slug: linkedlist-reversal
+    is_optimal: true
 
 function_signature: "def copy_random_list(head: Node | None) -> Node | None:"
 
diff --git a/backend/data/questions/count-good-nodes-in-binary-tree.yaml b/backend/data/questions/count-good-nodes-in-binary-tree.yaml
index a858ea8..69af376 100644
--- a/backend/data/questions/count-good-nodes-in-binary-tree.yaml
+++ b/backend/data/questions/count-good-nodes-in-binary-tree.yaml
@@ -6,8 +6,10 @@ leetcode_url: https://leetcode.com/problems/count-good-nodes-in-binary-tree/
 categories:
   - trees
 patterns:
-  - dfs
-  - tree-traversal
+  - slug: dfs
+    is_optimal: true
+  - slug: tree-traversal
+    is_optimal: false
 
 function_signature: "def good_nodes(root: TreeNode) -> int:"
 
diff --git a/backend/data/questions/counting-bits.yaml b/backend/data/questions/counting-bits.yaml
index fc83812..0445105 100644
--- a/backend/data/questions/counting-bits.yaml
+++ b/backend/data/questions/counting-bits.yaml
@@ -8,7 +8,8 @@ categories:
   - dynamic-programming
   - math
 patterns:
-  - dynamic-programming
+  - slug: dynamic-programming
+    is_optimal: true
 
 function_signature: "def count_bits(n: int) -> list[int]:"
 
diff --git a/backend/data/questions/course-schedule-ii.yaml b/backend/data/questions/course-schedule-ii.yaml
index 686ca51..a160bd7 100644
--- a/backend/data/questions/course-schedule-ii.yaml
+++ b/backend/data/questions/course-schedule-ii.yaml
@@ -6,8 +6,10 @@ leetcode_url: https://leetcode.com/problems/course-schedule-ii/
 categories:
   - graphs
 patterns:
-  - bfs
-  - dfs
+  - slug: bfs
+    is_optimal: true
+  - slug: dfs
+    is_optimal: false
 
 function_signature: "def find_order(num_courses: int, prerequisites: list[list[int]]) -> list[int]:"
 
diff --git a/backend/data/questions/course-schedule-iv.yaml b/backend/data/questions/course-schedule-iv.yaml
index 5a1e00b..16b4e5e 100644
--- a/backend/data/questions/course-schedule-iv.yaml
+++ b/backend/data/questions/course-schedule-iv.yaml
@@ -6,9 +6,12 @@ leetcode_url: https://leetcode.com/problems/course-schedule-iv/
 categories:
   - graphs
 patterns:
-  - bfs
-  - dfs
-  - dynamic-programming
+  - slug: bfs
+    is_optimal: true
+  - slug: dfs
+    is_optimal: false
+  - slug: dynamic-programming
+    is_optimal: false
 
 function_signature: "def check_if_prerequisite(num_courses: int, prerequisites: list[list[int]], queries: list[list[int]]) -> list[bool]:"
 
diff --git a/backend/data/questions/course-schedule.yaml b/backend/data/questions/course-schedule.yaml
index 0b9fe1b..e2a1ed0 100644
--- a/backend/data/questions/course-schedule.yaml
+++ b/backend/data/questions/course-schedule.yaml
@@ -6,8 +6,10 @@ leetcode_url: https://leetcode.com/problems/course-schedule/
 categories:
   - graphs
 patterns:
-  - dfs
-  - bfs
+  - slug: dfs
+    is_optimal: false
+  - slug: bfs
+    is_optimal: true
 
 function_signature: "def can_finish(num_courses: int, prerequisites: list[list[int]]) -> bool:"
 
diff --git a/backend/data/questions/daily-temperatures.yaml b/backend/data/questions/daily-temperatures.yaml
index df4f966..fc493ed 100644
--- a/backend/data/questions/daily-temperatures.yaml
+++ b/backend/data/questions/daily-temperatures.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - stack
 patterns:
-  - monotonic-stack
+  - slug: monotonic-stack
+    is_optimal: true
 
 function_signature: "def daily_temperatures(temperatures: list[int]) -> list[int]:"
 
diff --git a/backend/data/questions/decode-string.yaml b/backend/data/questions/decode-string.yaml
index c45a44e..8dd7cb8 100644
--- a/backend/data/questions/decode-string.yaml
+++ b/backend/data/questions/decode-string.yaml
@@ -8,7 +8,8 @@ categories:
   - stack
   - recursion
 patterns:
-  - monotonic-stack
+  - slug: monotonic-stack
+    is_optimal: true
 
 function_signature: "def decode_string(s: str) -> str:"
 
diff --git a/backend/data/questions/decode-ways.yaml b/backend/data/questions/decode-ways.yaml
index 29528fd..572329d 100644
--- a/backend/data/questions/decode-ways.yaml
+++ b/backend/data/questions/decode-ways.yaml
@@ -7,7 +7,8 @@ categories:
   - strings
   - dynamic-programming
 patterns:
-  - dynamic-programming
+  - slug: dynamic-programming
+    is_optimal: true
 
 function_signature: "def num_decodings(s: str) -> int:"
 
diff --git a/backend/data/questions/delete-leaves-with-a-given-value.yaml b/backend/data/questions/delete-leaves-with-a-given-value.yaml
index 25035bb..5175f88 100644
--- a/backend/data/questions/delete-leaves-with-a-given-value.yaml
+++ b/backend/data/questions/delete-leaves-with-a-given-value.yaml
@@ -7,8 +7,10 @@ categories:
   - trees
   - recursion
 patterns:
-  - dfs
-  - tree-traversal
+  - slug: dfs
+    is_optimal: true
+  - slug: tree-traversal
+    is_optimal: false
 
 function_signature: "def remove_leaf_nodes(root: TreeNode | None, target: int) -> TreeNode | None:"
 
diff --git a/backend/data/questions/delete-node-in-a-bst.yaml b/backend/data/questions/delete-node-in-a-bst.yaml
index f0865f1..b74de2d 100644
--- a/backend/data/questions/delete-node-in-a-bst.yaml
+++ b/backend/data/questions/delete-node-in-a-bst.yaml
@@ -6,8 +6,10 @@ leetcode_url: https://leetcode.com/problems/delete-node-in-a-bst/
 categories:
   - trees
 patterns:
-  - tree-traversal
-  - dfs
+  - slug: tree-traversal
+    is_optimal: true
+  - slug: dfs
+    is_optimal: false
 
 function_signature: "def delete_node(root: TreeNode | None, key: int) -> TreeNode | None:"
 
diff --git a/backend/data/questions/design-add-and-search-words-data-structure.yaml b/backend/data/questions/design-add-and-search-words-data-structure.yaml
index da17060..b51d42b 100644
--- a/backend/data/questions/design-add-and-search-words-data-structure.yaml
+++ b/backend/data/questions/design-add-and-search-words-data-structure.yaml
@@ -7,8 +7,10 @@ categories:
   - strings
   - trees
 patterns:
-  - trie
-  - dfs
+  - slug: trie
+    is_optimal: true
+  - slug: dfs
+    is_optimal: false
 
 function_signature: "class WordDictionary: ..."
 
diff --git a/backend/data/questions/design-circular-queue.yaml b/backend/data/questions/design-circular-queue.yaml
index 2f6f9c5..f45128b 100644
--- a/backend/data/questions/design-circular-queue.yaml
+++ b/backend/data/questions/design-circular-queue.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - queue
 patterns:
-  - two-pointers
+  - slug: two-pointers
+    is_optimal: true
 
 function_signature: "class MyCircularQueue: ..."
 
diff --git a/backend/data/questions/design-hashmap.yaml b/backend/data/questions/design-hashmap.yaml
index 92fccea..126acf9 100644
--- a/backend/data/questions/design-hashmap.yaml
+++ b/backend/data/questions/design-hashmap.yaml
@@ -8,7 +8,8 @@ categories:
   - hash-tables
   - linked-lists
 patterns:
-  - heap
+  - slug: hashing
+    is_optimal: true
 
 function_signature: "class MyHashMap: ..."
 
diff --git a/backend/data/questions/design-hashset.yaml b/backend/data/questions/design-hashset.yaml
index 92ae401..2973bb3 100644
--- a/backend/data/questions/design-hashset.yaml
+++ b/backend/data/questions/design-hashset.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - hash-tables
 patterns:
-  - heap
+  - slug: hashing
+    is_optimal: true
 
 function_signature: "class MyHashSet:\n    def __init__(self): ...\n    def add(self, key: int) -> None: ...\n    def remove(self, key: int) -> None: ...\n    def contains(self, key: int) -> bool: ..."
 
diff --git a/backend/data/questions/design-twitter.yaml b/backend/data/questions/design-twitter.yaml
index 85be422..7b900d2 100644
--- a/backend/data/questions/design-twitter.yaml
+++ b/backend/data/questions/design-twitter.yaml
@@ -7,7 +7,8 @@ categories:
   - hash-tables
   - heap
 patterns:
-  - heap
+  - slug: heap
+    is_optimal: true
 
 function_signature: "class Twitter:\n    def __init__(self): ...\n    def post_tweet(self, user_id: int, tweet_id: int) -> None: ...\n    def get_news_feed(self, user_id: int) -> list[int]: ...\n    def follow(self, follower_id: int, followee_id: int) -> None: ...\n    def unfollow(self, follower_id: int, followee_id: int) -> None: ..."
 
diff --git a/backend/data/questions/detect-squares.yaml b/backend/data/questions/detect-squares.yaml
index bc07743..e7046ac 100644
--- a/backend/data/questions/detect-squares.yaml
+++ b/backend/data/questions/detect-squares.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - hash-tables
 patterns:
-  - heap
+  - slug: hashing
+    is_optimal: true
 
 function_signature: "class DetectSquares:\n    def __init__(self): ...\n    def add(self, point: list[int]) -> None: ...\n    def count(self, point: list[int]) -> int: ..."
 
diff --git a/backend/data/questions/diameter-of-binary-tree.yaml b/backend/data/questions/diameter-of-binary-tree.yaml
index f8d9807..238c7b0 100644
--- a/backend/data/questions/diameter-of-binary-tree.yaml
+++ b/backend/data/questions/diameter-of-binary-tree.yaml
@@ -7,8 +7,10 @@ categories:
   - trees
   - recursion
 patterns:
-  - dfs
-  - tree-traversal
+  - slug: dfs
+    is_optimal: true
+  - slug: tree-traversal
+    is_optimal: false
 
 function_signature: "def diameter_of_binary_tree(root: TreeNode) -> int:"
 
diff --git a/backend/data/questions/distinct-subsequences.yaml b/backend/data/questions/distinct-subsequences.yaml
index 8eee310..cf8b6d3 100644
--- a/backend/data/questions/distinct-subsequences.yaml
+++ b/backend/data/questions/distinct-subsequences.yaml
@@ -7,7 +7,8 @@ categories:
   - strings
   - dynamic-programming
 patterns:
-  - dynamic-programming
+  - slug: dynamic-programming
+    is_optimal: true
 
 function_signature: "def num_distinct(s: str, t: str) -> int:"
 
diff --git a/backend/data/questions/dota2-senate.yaml b/backend/data/questions/dota2-senate.yaml
index c221c2c..e72c472 100644
--- a/backend/data/questions/dota2-senate.yaml
+++ b/backend/data/questions/dota2-senate.yaml
@@ -7,7 +7,8 @@ categories:
   - strings
   - queue
 patterns:
-  - greedy
+  - slug: greedy
+    is_optimal: true
 
 function_signature: "def predict_party_victory(senate: str) -> str:"
 
diff --git a/backend/data/questions/edit-distance.yaml b/backend/data/questions/edit-distance.yaml
index 2f1fad4..f3e28b2 100644
--- a/backend/data/questions/edit-distance.yaml
+++ b/backend/data/questions/edit-distance.yaml
@@ -7,7 +7,8 @@ categories:
   - strings
   - dynamic-programming
 patterns:
-  - dynamic-programming
+  - slug: dynamic-programming
+    is_optimal: true
 
 function_signature: "def min_distance(word1: str, word2: str) -> int:"
 
diff --git a/backend/data/questions/evaluate-division.yaml b/backend/data/questions/evaluate-division.yaml
index 9b71b2c..6d5cb5a 100644
--- a/backend/data/questions/evaluate-division.yaml
+++ b/backend/data/questions/evaluate-division.yaml
@@ -7,9 +7,12 @@ categories:
   - graphs
   - hash-tables
 patterns:
-  - bfs
-  - dfs
-  - union-find
+  - slug: bfs
+    is_optimal: false
+  - slug: dfs
+    is_optimal: false
+  - slug: union-find
+    is_optimal: true
 
 function_signature: "def calc_equation(equations: list[list[str]], values: list[float], queries: list[list[str]]) -> list[float]:"
 
diff --git a/backend/data/questions/evaluate-reverse-polish-notation.yaml b/backend/data/questions/evaluate-reverse-polish-notation.yaml
index 28c3bf0..f0457a2 100644
--- a/backend/data/questions/evaluate-reverse-polish-notation.yaml
+++ b/backend/data/questions/evaluate-reverse-polish-notation.yaml
@@ -8,7 +8,8 @@ categories:
   - stack
   - math
 patterns:
-  - monotonic-stack
+  - slug: monotonic-stack
+    is_optimal: true
 
 function_signature: "def eval_rpn(tokens: list[str]) -> int:"
 
diff --git a/backend/data/questions/excel-sheet-column-title.yaml b/backend/data/questions/excel-sheet-column-title.yaml
index c9a072f..96be589 100644
--- a/backend/data/questions/excel-sheet-column-title.yaml
+++ b/backend/data/questions/excel-sheet-column-title.yaml
@@ -7,7 +7,8 @@ categories:
   - strings
   - math
 patterns:
-  - greedy
+  - slug: greedy
+    is_optimal: true
 
 function_signature: "def convert_to_title(column_number: int) -> str:"
 
diff --git a/backend/data/questions/find-in-mountain-array.yaml b/backend/data/questions/find-in-mountain-array.yaml
index c3ff184..303e5d2 100644
--- a/backend/data/questions/find-in-mountain-array.yaml
+++ b/backend/data/questions/find-in-mountain-array.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - binary-search
 patterns:
-  - binary-search
+  - slug: binary-search
+    is_optimal: true
 
 function_signature: "def find_in_mountain_array(target: int, mountain_arr: MountainArray) -> int:"
 
diff --git a/backend/data/questions/find-k-closest-elements.yaml b/backend/data/questions/find-k-closest-elements.yaml
index dc159fa..c8e4edb 100644
--- a/backend/data/questions/find-k-closest-elements.yaml
+++ b/backend/data/questions/find-k-closest-elements.yaml
@@ -8,8 +8,10 @@ categories:
   - binary-search
   - two-pointers
 patterns:
-  - binary-search
-  - two-pointers
+  - slug: binary-search
+    is_optimal: true
+  - slug: two-pointers
+    is_optimal: false
 
 function_signature: "def find_closest_elements(arr: list[int], k: int, x: int) -> list[int]:"
 
diff --git a/backend/data/questions/find-median-from-data-stream.yaml b/backend/data/questions/find-median-from-data-stream.yaml
index 5aa9fad..aa9feec 100644
--- a/backend/data/questions/find-median-from-data-stream.yaml
+++ b/backend/data/questions/find-median-from-data-stream.yaml
@@ -7,7 +7,8 @@ categories:
   - heap
   - sorting
 patterns:
-  - heap
+  - slug: heap
+    is_optimal: true
 
 function_signature: "class MedianFinder:\n    def __init__(self): ...\n    def add_num(self, num: int) -> None: ...\n    def find_median(self) -> float: ..."
 
diff --git a/backend/data/questions/find-minimum-in-rotated-sorted-array.yaml b/backend/data/questions/find-minimum-in-rotated-sorted-array.yaml
index 549d9fb..ae09bf6 100644
--- a/backend/data/questions/find-minimum-in-rotated-sorted-array.yaml
+++ b/backend/data/questions/find-minimum-in-rotated-sorted-array.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - binary-search
 patterns:
-  - binary-search
+  - slug: binary-search
+    is_optimal: true
 
 function_signature: "def find_min(nums: list[int]) -> int:"
 
diff --git a/backend/data/questions/find-the-duplicate-number.yaml b/backend/data/questions/find-the-duplicate-number.yaml
index f26971e..7354dc4 100644
--- a/backend/data/questions/find-the-duplicate-number.yaml
+++ b/backend/data/questions/find-the-duplicate-number.yaml
@@ -7,8 +7,10 @@ categories:
   - arrays
   - two-pointers
 patterns:
-  - fast-slow-pointers
-  - binary-search
+  - slug: fast-slow-pointers
+    is_optimal: false
+  - slug: binary-search
+    is_optimal: true
 
 function_signature: "def find_duplicate(nums: list[int]) -> int:"
 
diff --git a/backend/data/questions/find-the-town-judge.yaml b/backend/data/questions/find-the-town-judge.yaml
index a28768c..8684bd9 100644
--- a/backend/data/questions/find-the-town-judge.yaml
+++ b/backend/data/questions/find-the-town-judge.yaml
@@ -8,7 +8,8 @@ categories:
   - graphs
   - hash-tables
 patterns:
-  - greedy
+  - slug: greedy
+    is_optimal: true
 
 function_signature: "def find_judge(n: int, trust: list[list[int]]) -> int:"
 
diff --git a/backend/data/questions/first-missing-positive.yaml b/backend/data/questions/first-missing-positive.yaml
index e4a049a..9d37a4b 100644
--- a/backend/data/questions/first-missing-positive.yaml
+++ b/backend/data/questions/first-missing-positive.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - hash-tables
 patterns:
-  - matrix-traversal
+  - slug: matrix-traversal
+    is_optimal: true
 
 function_signature: "def first_missing_positive(nums: list[int]) -> int:"
 
diff --git a/backend/data/questions/four-sum.yaml b/backend/data/questions/four-sum.yaml
index cdfafde..9e42ab5 100644
--- a/backend/data/questions/four-sum.yaml
+++ b/backend/data/questions/four-sum.yaml
@@ -8,7 +8,8 @@ categories:
   - two-pointers
   - sorting
 patterns:
-  - two-pointers
+  - slug: two-pointers
+    is_optimal: true
 
 function_signature: "def four_sum(nums: list[int], target: int) -> list[list[int]]:"
 
diff --git a/backend/data/questions/gas-station.yaml b/backend/data/questions/gas-station.yaml
index df7a0fd..3c0fe71 100644
--- a/backend/data/questions/gas-station.yaml
+++ b/backend/data/questions/gas-station.yaml
@@ -6,7 +6,8 @@ leetcode_url: https://leetcode.com/problems/gas-station/
 categories:
   - arrays
 patterns:
-  - greedy
+  - slug: greedy
+    is_optimal: true
 
 function_signature: "def can_complete_circuit(gas: list[int], cost: list[int]) -> int:"
 
diff --git a/backend/data/questions/generate-parentheses.yaml b/backend/data/questions/generate-parentheses.yaml
index 810993c..f1db3c3 100644
--- a/backend/data/questions/generate-parentheses.yaml
+++ b/backend/data/questions/generate-parentheses.yaml
@@ -7,7 +7,8 @@ categories:
   - strings
   - recursion
 patterns:
-  - backtracking
+  - slug: backtracking
+    is_optimal: true
 
 function_signature: "def generate_parenthesis(n: int) -> list[str]:"
 
diff --git a/backend/data/questions/greatest-common-divisor-of-strings.yaml b/backend/data/questions/greatest-common-divisor-of-strings.yaml
index a597837..3ffaf55 100644
--- a/backend/data/questions/greatest-common-divisor-of-strings.yaml
+++ b/backend/data/questions/greatest-common-divisor-of-strings.yaml
@@ -7,7 +7,8 @@ categories:
   - strings
   - math
 patterns:
-  - greedy
+  - slug: greedy
+    is_optimal: true
 
 function_signature: "def gcd_of_strings(str1: str, str2: str) -> str:"
 
diff --git a/backend/data/questions/group-anagrams.yaml b/backend/data/questions/group-anagrams.yaml
index 9117430..98c9ad6 100644
--- a/backend/data/questions/group-anagrams.yaml
+++ b/backend/data/questions/group-anagrams.yaml
@@ -8,7 +8,8 @@ categories:
   - hash-tables
   - sorting
 patterns:
-  - hashing
+  - slug: hashing
+    is_optimal: true
 
 function_signature: "def group_anagrams(strs: list[str]) -> list[list[str]]:"
 
diff --git a/backend/data/questions/guess-number-higher-or-lower.yaml b/backend/data/questions/guess-number-higher-or-lower.yaml
index 24e9dc0..b48a3fe 100644
--- a/backend/data/questions/guess-number-higher-or-lower.yaml
+++ b/backend/data/questions/guess-number-higher-or-lower.yaml
@@ -6,7 +6,8 @@ leetcode_url: https://leetcode.com/problems/guess-number-higher-or-lower/
 categories:
   - binary-search
 patterns:
-  - binary-search
+  - slug: binary-search
+    is_optimal: true
 
 function_signature: "def guess_number(n: int) -> int:"
 
diff --git a/backend/data/questions/hand-of-straights.yaml b/backend/data/questions/hand-of-straights.yaml
index 056c43e..5f0b5f7 100644
--- a/backend/data/questions/hand-of-straights.yaml
+++ b/backend/data/questions/hand-of-straights.yaml
@@ -8,8 +8,10 @@ categories:
   - hash-tables
   - sorting
 patterns:
-  - greedy
-  - heap
+  - slug: greedy
+    is_optimal: true
+  - slug: heap
+    is_optimal: false
 
 function_signature: "def is_n_straight_hand(hand: list[int], group_size: int) -> bool:"
 
diff --git a/backend/data/questions/happy-number.yaml b/backend/data/questions/happy-number.yaml
index 13b6e35..60dfd12 100644
--- a/backend/data/questions/happy-number.yaml
+++ b/backend/data/questions/happy-number.yaml
@@ -7,7 +7,8 @@ categories:
   - math
   - hash-tables
 patterns:
-  - fast-slow-pointers
+  - slug: fast-slow-pointers
+    is_optimal: true
 
 function_signature: "def is_happy(n: int) -> bool:"
 
diff --git a/backend/data/questions/house-robber-ii.yaml b/backend/data/questions/house-robber-ii.yaml
index 549670c..c503f2b 100644
--- a/backend/data/questions/house-robber-ii.yaml
+++ b/backend/data/questions/house-robber-ii.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - dynamic-programming
 patterns:
-  - dynamic-programming
+  - slug: dynamic-programming
+    is_optimal: true
 
 function_signature: "def rob(nums: list[int]) -> int:"
 
diff --git a/backend/data/questions/house-robber-iii.yaml b/backend/data/questions/house-robber-iii.yaml
index 86dd0d8..4e0c2b4 100644
--- a/backend/data/questions/house-robber-iii.yaml
+++ b/backend/data/questions/house-robber-iii.yaml
@@ -7,8 +7,10 @@ categories:
   - trees
   - dynamic-programming
 patterns:
-  - dfs
-  - dynamic-programming
+  - slug: dfs
+    is_optimal: true
+  - slug: dynamic-programming
+    is_optimal: false
 
 function_signature: "def rob(root: TreeNode) -> int:"
 
diff --git a/backend/data/questions/house-robber.yaml b/backend/data/questions/house-robber.yaml
index de6d7ce..e1ba664 100644
--- a/backend/data/questions/house-robber.yaml
+++ b/backend/data/questions/house-robber.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - dynamic-programming
 patterns:
-  - dynamic-programming
+  - slug: dynamic-programming
+    is_optimal: true
 
 function_signature: "def rob(nums: list[int]) -> int:"
 
diff --git a/backend/data/questions/implement-queue-using-stacks.yaml b/backend/data/questions/implement-queue-using-stacks.yaml
index f864207..9c4e121 100644
--- a/backend/data/questions/implement-queue-using-stacks.yaml
+++ b/backend/data/questions/implement-queue-using-stacks.yaml
@@ -7,7 +7,8 @@ categories:
   - stack
   - queue
 patterns:
-  - monotonic-stack
+  - slug: monotonic-stack
+    is_optimal: true
 
 function_signature: "class MyQueue"
 
diff --git a/backend/data/questions/implement-stack-using-queues.yaml b/backend/data/questions/implement-stack-using-queues.yaml
index 0512908..260e5c9 100644
--- a/backend/data/questions/implement-stack-using-queues.yaml
+++ b/backend/data/questions/implement-stack-using-queues.yaml
@@ -7,7 +7,8 @@ categories:
   - stack
   - queue
 patterns:
-  - monotonic-stack
+  - slug: monotonic-stack
+    is_optimal: true
 
 function_signature: "class MyStack"
 
diff --git a/backend/data/questions/implement-trie-prefix-tree.yaml b/backend/data/questions/implement-trie-prefix-tree.yaml
index eca93ee..72efa57 100644
--- a/backend/data/questions/implement-trie-prefix-tree.yaml
+++ b/backend/data/questions/implement-trie-prefix-tree.yaml
@@ -7,7 +7,8 @@ categories:
   - strings
   - hash-tables
 patterns:
-  - trie
+  - slug: trie
+    is_optimal: true
 
 function_signature: "class Trie"
 
diff --git a/backend/data/questions/insert-interval.yaml b/backend/data/questions/insert-interval.yaml
index cf5c160..864d00f 100644
--- a/backend/data/questions/insert-interval.yaml
+++ b/backend/data/questions/insert-interval.yaml
@@ -6,7 +6,8 @@ leetcode_url: https://leetcode.com/problems/insert-interval/
 categories:
   - arrays
 patterns:
-  - intervals
+  - slug: intervals
+    is_optimal: true
 
 function_signature: "def insert(intervals: list[list[int]], newInterval: list[int]) -> list[list[int]]:"
 
diff --git a/backend/data/questions/insert-into-a-binary-search-tree.yaml b/backend/data/questions/insert-into-a-binary-search-tree.yaml
index 540210a..381dc63 100644
--- a/backend/data/questions/insert-into-a-binary-search-tree.yaml
+++ b/backend/data/questions/insert-into-a-binary-search-tree.yaml
@@ -6,7 +6,8 @@ leetcode_url: https://leetcode.com/problems/insert-into-a-binary-search-tree/
 categories:
   - trees
 patterns:
-  - tree-traversal
+  - slug: tree-traversal
+    is_optimal: true
 
 function_signature: "def insert_into_bst(root: TreeNode, val: int) -> TreeNode:"
 
diff --git a/backend/data/questions/integer-break.yaml b/backend/data/questions/integer-break.yaml
index adde7c2..7a5432c 100644
--- a/backend/data/questions/integer-break.yaml
+++ b/backend/data/questions/integer-break.yaml
@@ -7,8 +7,10 @@ categories:
   - dynamic-programming
   - math
 patterns:
-  - dynamic-programming
-  - greedy
+  - slug: dynamic-programming
+    is_optimal: true
+  - slug: greedy
+    is_optimal: false
 
 function_signature: "def integer_break(n: int) -> int:"
 
diff --git a/backend/data/questions/interleaving-string.yaml b/backend/data/questions/interleaving-string.yaml
index cda3e1c..2ae994a 100644
--- a/backend/data/questions/interleaving-string.yaml
+++ b/backend/data/questions/interleaving-string.yaml
@@ -7,7 +7,8 @@ categories:
   - strings
   - dynamic-programming
 patterns:
-  - dynamic-programming
+  - slug: dynamic-programming
+    is_optimal: true
 
 function_signature: "def is_interleave(s1: str, s2: str, s3: str) -> bool:"
 
diff --git a/backend/data/questions/invert-binary-tree.yaml b/backend/data/questions/invert-binary-tree.yaml
index 0d3a44f..36c2cf2 100644
--- a/backend/data/questions/invert-binary-tree.yaml
+++ b/backend/data/questions/invert-binary-tree.yaml
@@ -7,9 +7,12 @@ categories:
   - trees
   - recursion
 patterns:
-  - tree-traversal
-  - dfs
-  - bfs
+  - slug: tree-traversal
+    is_optimal: false
+  - slug: dfs
+    is_optimal: false
+  - slug: bfs
+    is_optimal: true
 
 function_signature: "def invert_tree(root: TreeNode | None) -> TreeNode | None:"
 
diff --git a/backend/data/questions/ipo.yaml b/backend/data/questions/ipo.yaml
index bc71c6e..b35eeca 100644
--- a/backend/data/questions/ipo.yaml
+++ b/backend/data/questions/ipo.yaml
@@ -8,8 +8,10 @@ categories:
   - heap
   - sorting
 patterns:
-  - heap
-  - greedy
+  - slug: greedy
+    is_optimal: true
+  - slug: heap
+    is_optimal: false
 
 function_signature: "def find_maximized_capital(k: int, w: int, profits: list[int], capital: list[int]) -> int:"
 
diff --git a/backend/data/questions/island-perimeter.yaml b/backend/data/questions/island-perimeter.yaml
index 639b195..a076301 100644
--- a/backend/data/questions/island-perimeter.yaml
+++ b/backend/data/questions/island-perimeter.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - math
 patterns:
-  - matrix-traversal
+  - slug: matrix-traversal
+    is_optimal: true
 
 function_signature: "def island_perimeter(grid: list[list[int]]) -> int:"
 
diff --git a/backend/data/questions/jump-game-ii.yaml b/backend/data/questions/jump-game-ii.yaml
index d01fb6c..ff332cb 100644
--- a/backend/data/questions/jump-game-ii.yaml
+++ b/backend/data/questions/jump-game-ii.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - dynamic-programming
 patterns:
-  - greedy
+  - slug: greedy
+    is_optimal: true
 
 function_signature: "def jump(nums: list[int]) -> int:"
 
diff --git a/backend/data/questions/jump-game-vii.yaml b/backend/data/questions/jump-game-vii.yaml
index 6113520..a603b55 100644
--- a/backend/data/questions/jump-game-vii.yaml
+++ b/backend/data/questions/jump-game-vii.yaml
@@ -7,9 +7,12 @@ categories:
   - strings
   - dynamic-programming
 patterns:
-  - bfs
-  - sliding-window
-  - dynamic-programming
+  - slug: bfs
+    is_optimal: false
+  - slug: sliding-window
+    is_optimal: true
+  - slug: dynamic-programming
+    is_optimal: false
 
 function_signature: "def can_reach(s: str, min_jump: int, max_jump: int) -> bool:"
 
diff --git a/backend/data/questions/jump-game.yaml b/backend/data/questions/jump-game.yaml
index b2f3213..01c4f86 100644
--- a/backend/data/questions/jump-game.yaml
+++ b/backend/data/questions/jump-game.yaml
@@ -7,8 +7,10 @@ categories:
   - arrays
   - dynamic-programming
 patterns:
-  - greedy
-  - dynamic-programming
+  - slug: greedy
+    is_optimal: true
+  - slug: dynamic-programming
+    is_optimal: false
 
 function_signature: "def can_jump(nums: list[int]) -> bool:"
 
diff --git a/backend/data/questions/k-closest-points-to-origin.yaml b/backend/data/questions/k-closest-points-to-origin.yaml
index a8b7b5f..1a5bc34 100644
--- a/backend/data/questions/k-closest-points-to-origin.yaml
+++ b/backend/data/questions/k-closest-points-to-origin.yaml
@@ -8,7 +8,8 @@ categories:
   - heap
   - sorting
 patterns:
-  - heap
+  - slug: heap
+    is_optimal: true
 
 function_signature: "def k_closest(points: list[list[int]], k: int) -> list[list[int]]:"
 
diff --git a/backend/data/questions/koko-eating-bananas.yaml b/backend/data/questions/koko-eating-bananas.yaml
index 10cab8e..f320989 100644
--- a/backend/data/questions/koko-eating-bananas.yaml
+++ b/backend/data/questions/koko-eating-bananas.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - binary-search
 patterns:
-  - binary-search
+  - slug: binary-search
+    is_optimal: true
 
 function_signature: "def min_eating_speed(piles: list[int], h: int) -> int:"
 
diff --git a/backend/data/questions/kth-largest-element-in-a-stream.yaml b/backend/data/questions/kth-largest-element-in-a-stream.yaml
index 9d69610..3f9c933 100644
--- a/backend/data/questions/kth-largest-element-in-a-stream.yaml
+++ b/backend/data/questions/kth-largest-element-in-a-stream.yaml
@@ -7,7 +7,8 @@ categories:
   - heap
   - arrays
 patterns:
-  - heap
+  - slug: heap
+    is_optimal: true
 
 function_signature: "class KthLargest:\n    def __init__(self, k: int, nums: list[int]):\n    def add(self, val: int) -> int:"
 
diff --git a/backend/data/questions/kth-largest-element-in-an-array.yaml b/backend/data/questions/kth-largest-element-in-an-array.yaml
index 6b7f43b..50a28ba 100644
--- a/backend/data/questions/kth-largest-element-in-an-array.yaml
+++ b/backend/data/questions/kth-largest-element-in-an-array.yaml
@@ -8,8 +8,10 @@ categories:
   - sorting
   - heap
 patterns:
-  - heap
-  - binary-search
+  - slug: heap
+    is_optimal: true
+  - slug: binary-search
+    is_optimal: false
 
 function_signature: "def find_kth_largest(nums: list[int], k: int) -> int:"
 
@@ -144,6 +146,31 @@ explanation:
   time_complexity: "O(n log k). We iterate through all `n` elements, and each heap operation (push/pop) takes `O(log k)` time since the heap size is bounded by `k`."
   space_complexity: "O(k). We maintain a heap containing at most `k` elements."
 
+  pattern_comparison: |
+    **Heap vs Quickselect: Choosing the Right Pattern**
+
+    Both approaches avoid full sorting, but they have different characteristics:
+
+    | Approach | Time (Avg) | Time (Worst) | Space | Modifies Input? |
+    |----------|------------|--------------|-------|-----------------|
+    | **Min Heap** | O(n log k) | O(n log k) | O(k) | No |
+    | **Quickselect** | O(n) | O(n²) | O(log n) | Yes |
+    | **Sorting** | O(n log n) | O(n log n) | O(1)-O(n) | Yes |
+
+    **When to choose Heap:**
+    - You need **guaranteed** performance (no worst-case quadratic time)
+    - The input array shouldn't be modified
+    - `k` is small relative to `n` (the O(log k) factor stays small)
+    - You're working with streaming data
+
+    **When to choose Quickselect:**
+    - You need the **fastest average** performance
+    - Modifying the input array is acceptable
+    - You're comfortable with randomised algorithms
+    - Space is at a premium (O(log n) recursion vs O(k) heap)
+
+    **Interview tip:** Start with Heap for its simplicity and guaranteed bounds, then mention Quickselect as an optimisation if the interviewer asks about O(n) solutions.
+
 solutions:
   - approach_name: Min-Heap
     is_optimal: true
diff --git a/backend/data/questions/kth-smallest-element-in-a-bst.yaml b/backend/data/questions/kth-smallest-element-in-a-bst.yaml
index 74f1547..7ef616d 100644
--- a/backend/data/questions/kth-smallest-element-in-a-bst.yaml
+++ b/backend/data/questions/kth-smallest-element-in-a-bst.yaml
@@ -7,8 +7,10 @@ categories:
   - trees
   - recursion
 patterns:
-  - dfs
-  - tree-traversal
+  - slug: dfs
+    is_optimal: true
+  - slug: tree-traversal
+    is_optimal: false
 
 function_signature: "def kth_smallest(root: TreeNode | None, k: int) -> int:"
 
diff --git a/backend/data/questions/largest-rectangle-in-histogram.yaml b/backend/data/questions/largest-rectangle-in-histogram.yaml
index 7c9e6aa..93fec62 100644
--- a/backend/data/questions/largest-rectangle-in-histogram.yaml
+++ b/backend/data/questions/largest-rectangle-in-histogram.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - stack
 patterns:
-  - monotonic-stack
+  - slug: monotonic-stack
+    is_optimal: true
 
 function_signature: "def largest_rectangle_area(heights: list[int]) -> int:"
 
diff --git a/backend/data/questions/last-stone-weight-ii.yaml b/backend/data/questions/last-stone-weight-ii.yaml
index d684e19..f3710db 100644
--- a/backend/data/questions/last-stone-weight-ii.yaml
+++ b/backend/data/questions/last-stone-weight-ii.yaml
@@ -7,7 +7,8 @@ categories:
   - dynamic-programming
   - arrays
 patterns:
-  - dynamic-programming
+  - slug: dynamic-programming
+    is_optimal: true
 
 function_signature: "def last_stone_weight_ii(stones: list[int]) -> int:"
 
diff --git a/backend/data/questions/last-stone-weight.yaml b/backend/data/questions/last-stone-weight.yaml
index 08236ed..8a69a72 100644
--- a/backend/data/questions/last-stone-weight.yaml
+++ b/backend/data/questions/last-stone-weight.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - heap
 patterns:
-  - heap
+  - slug: heap
+    is_optimal: true
 
 function_signature: "def last_stone_weight(stones: list[int]) -> int:"
 
diff --git a/backend/data/questions/lemonade-change.yaml b/backend/data/questions/lemonade-change.yaml
index c4fafba..cb0831b 100644
--- a/backend/data/questions/lemonade-change.yaml
+++ b/backend/data/questions/lemonade-change.yaml
@@ -6,7 +6,8 @@ leetcode_url: https://leetcode.com/problems/lemonade-change/
 categories:
   - arrays
 patterns:
-  - greedy
+  - slug: greedy
+    is_optimal: true
 
 function_signature: "def lemonade_change(bills: list[int]) -> bool:"
 
diff --git a/backend/data/questions/letter-combinations-of-a-phone-number.yaml b/backend/data/questions/letter-combinations-of-a-phone-number.yaml
index 6e3d21f..2a3c0fd 100644
--- a/backend/data/questions/letter-combinations-of-a-phone-number.yaml
+++ b/backend/data/questions/letter-combinations-of-a-phone-number.yaml
@@ -8,7 +8,8 @@ categories:
   - hash-tables
   - recursion
 patterns:
-  - backtracking
+  - slug: backtracking
+    is_optimal: true
 
 function_signature: "def letter_combinations(digits: str) -> list[str]:"
 
diff --git a/backend/data/questions/lfu-cache.yaml b/backend/data/questions/lfu-cache.yaml
index a5ac68a..44c01db 100644
--- a/backend/data/questions/lfu-cache.yaml
+++ b/backend/data/questions/lfu-cache.yaml
@@ -7,7 +7,8 @@ categories:
   - hash-tables
   - linked-lists
 patterns:
-  - heap
+  - slug: hashing
+    is_optimal: true
 
 function_signature: "class LFUCache: def __init__(self, capacity: int); def get(self, key: int) -> int; def put(self, key: int, value: int) -> None"
 
diff --git a/backend/data/questions/linked-list-cycle.yaml b/backend/data/questions/linked-list-cycle.yaml
index 8b53d6d..68fd4b2 100644
--- a/backend/data/questions/linked-list-cycle.yaml
+++ b/backend/data/questions/linked-list-cycle.yaml
@@ -8,7 +8,8 @@ categories:
   - two-pointers
   - hash-tables
 patterns:
-  - fast-slow-pointers
+  - slug: fast-slow-pointers
+    is_optimal: true
 
 function_signature: "def has_cycle(head: ListNode | None) -> bool:"
 
diff --git a/backend/data/questions/longest-common-prefix.yaml b/backend/data/questions/longest-common-prefix.yaml
index 9632ae6..ecfc005 100644
--- a/backend/data/questions/longest-common-prefix.yaml
+++ b/backend/data/questions/longest-common-prefix.yaml
@@ -7,7 +7,8 @@ categories:
   - strings
   - arrays
 patterns:
-  - two-pointers
+  - slug: two-pointers
+    is_optimal: true
 
 function_signature: "def longest_common_prefix(strs: list[str]) -> str:"
 
diff --git a/backend/data/questions/longest-common-subsequence.yaml b/backend/data/questions/longest-common-subsequence.yaml
index 39ecc8d..099669a 100644
--- a/backend/data/questions/longest-common-subsequence.yaml
+++ b/backend/data/questions/longest-common-subsequence.yaml
@@ -7,7 +7,8 @@ categories:
   - strings
   - dynamic-programming
 patterns:
-  - dynamic-programming
+  - slug: dynamic-programming
+    is_optimal: true
 
 function_signature: "def longest_common_subsequence(text1: str, text2: str) -> int:"
 
diff --git a/backend/data/questions/longest-consecutive-sequence.yaml b/backend/data/questions/longest-consecutive-sequence.yaml
index 395272c..292cdde 100644
--- a/backend/data/questions/longest-consecutive-sequence.yaml
+++ b/backend/data/questions/longest-consecutive-sequence.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - hash-tables
 patterns:
-  - union-find
+  - slug: union-find
+    is_optimal: true
 
 function_signature: "def longest_consecutive(nums: list[int]) -> int:"
 
diff --git a/backend/data/questions/longest-happy-string.yaml b/backend/data/questions/longest-happy-string.yaml
index 4762fe6..732c122 100644
--- a/backend/data/questions/longest-happy-string.yaml
+++ b/backend/data/questions/longest-happy-string.yaml
@@ -7,8 +7,10 @@ categories:
   - strings
   - heap
 patterns:
-  - greedy
-  - heap
+  - slug: greedy
+    is_optimal: true
+  - slug: heap
+    is_optimal: false
 
 function_signature: "def longest_happy_string(a: int, b: int, c: int) -> str:"
 
diff --git a/backend/data/questions/longest-increasing-path-in-a-matrix.yaml b/backend/data/questions/longest-increasing-path-in-a-matrix.yaml
index d66f4bc..50e1e0b 100644
--- a/backend/data/questions/longest-increasing-path-in-a-matrix.yaml
+++ b/backend/data/questions/longest-increasing-path-in-a-matrix.yaml
@@ -8,9 +8,12 @@ categories:
   - dynamic-programming
   - arrays
 patterns:
-  - dfs
-  - dynamic-programming
-  - matrix-traversal
+  - slug: dfs
+    is_optimal: true
+  - slug: dynamic-programming
+    is_optimal: false
+  - slug: matrix-traversal
+    is_optimal: false
 
 function_signature: "def longest_increasing_path(matrix: list[list[int]]) -> int:"
 
diff --git a/backend/data/questions/longest-increasing-subsequence.yaml b/backend/data/questions/longest-increasing-subsequence.yaml
index d1d1053..962848f 100644
--- a/backend/data/questions/longest-increasing-subsequence.yaml
+++ b/backend/data/questions/longest-increasing-subsequence.yaml
@@ -8,8 +8,10 @@ categories:
   - dynamic-programming
   - binary-search
 patterns:
-  - dynamic-programming
-  - binary-search
+  - slug: dynamic-programming
+    is_optimal: false
+  - slug: binary-search
+    is_optimal: true
 
 function_signature: "def length_of_lis(nums: list[int]) -> int:"
 
diff --git a/backend/data/questions/longest-palindromic-substring.yaml b/backend/data/questions/longest-palindromic-substring.yaml
index ef59bb3..f55edb3 100644
--- a/backend/data/questions/longest-palindromic-substring.yaml
+++ b/backend/data/questions/longest-palindromic-substring.yaml
@@ -7,8 +7,10 @@ categories:
   - strings
   - dynamic-programming
 patterns:
-  - two-pointers
-  - dynamic-programming
+  - slug: two-pointers
+    is_optimal: true
+  - slug: dynamic-programming
+    is_optimal: false
 
 function_signature: "def longest_palindrome(s: str) -> str:"
 
diff --git a/backend/data/questions/longest-substring-without-repeating.yaml b/backend/data/questions/longest-substring-without-repeating.yaml
index 6dbf9c1..7dc6ae2 100644
--- a/backend/data/questions/longest-substring-without-repeating.yaml
+++ b/backend/data/questions/longest-substring-without-repeating.yaml
@@ -7,7 +7,8 @@ categories:
   - strings
   - hash-tables
 patterns:
-  - sliding-window
+  - slug: sliding-window
+    is_optimal: true
 
 function_signature: "def length_of_longest_substring(s: str) -> int:"
 
diff --git a/backend/data/questions/longest-turbulent-subarray.yaml b/backend/data/questions/longest-turbulent-subarray.yaml
index 82a0553..4db8877 100644
--- a/backend/data/questions/longest-turbulent-subarray.yaml
+++ b/backend/data/questions/longest-turbulent-subarray.yaml
@@ -7,8 +7,10 @@ categories:
   - arrays
   - dynamic-programming
 patterns:
-  - sliding-window
-  - dynamic-programming
+  - slug: sliding-window
+    is_optimal: true
+  - slug: dynamic-programming
+    is_optimal: false
 
 function_signature: "def max_turbulence_size(arr: list[int]) -> int:"
 
diff --git a/backend/data/questions/longest-valid-parentheses.yaml b/backend/data/questions/longest-valid-parentheses.yaml
index 2df4692..14618ed 100644
--- a/backend/data/questions/longest-valid-parentheses.yaml
+++ b/backend/data/questions/longest-valid-parentheses.yaml
@@ -8,8 +8,10 @@ categories:
   - stack
   - dynamic-programming
 patterns:
-  - dynamic-programming
-  - monotonic-stack
+  - slug: dynamic-programming
+    is_optimal: false
+  - slug: monotonic-stack
+    is_optimal: true
 
 function_signature: "def longest_valid_parentheses(s: str) -> int:"
 
diff --git a/backend/data/questions/lowest-common-ancestor-of-a-binary-search-tree.yaml b/backend/data/questions/lowest-common-ancestor-of-a-binary-search-tree.yaml
index 773ce8f..66fedf5 100644
--- a/backend/data/questions/lowest-common-ancestor-of-a-binary-search-tree.yaml
+++ b/backend/data/questions/lowest-common-ancestor-of-a-binary-search-tree.yaml
@@ -6,8 +6,10 @@ leetcode_url: https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-s
 categories:
   - trees
 patterns:
-  - tree-traversal
-  - binary-search
+  - slug: tree-traversal
+    is_optimal: false
+  - slug: binary-search
+    is_optimal: true
 
 function_signature: "def lowest_common_ancestor(root: TreeNode, p: TreeNode, q: TreeNode) -> TreeNode:"
 
diff --git a/backend/data/questions/lru-cache.yaml b/backend/data/questions/lru-cache.yaml
index fe836e0..360eabb 100644
--- a/backend/data/questions/lru-cache.yaml
+++ b/backend/data/questions/lru-cache.yaml
@@ -7,7 +7,8 @@ categories:
   - hash-tables
   - linked-lists
 patterns:
-  - linkedlist-reversal
+  - slug: linkedlist-reversal
+    is_optimal: true
 
 function_signature: "class LRUCache: def __init__(self, capacity: int); def get(self, key: int) -> int; def put(self, key: int, value: int) -> None"
 
diff --git a/backend/data/questions/majority-element-ii.yaml b/backend/data/questions/majority-element-ii.yaml
index 7a17851..e631a07 100644
--- a/backend/data/questions/majority-element-ii.yaml
+++ b/backend/data/questions/majority-element-ii.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - hash-tables
 patterns:
-  - greedy
+  - slug: greedy
+    is_optimal: true
 
 function_signature: "def majority_element(nums: list[int]) -> list[int]:"
 
diff --git a/backend/data/questions/majority-element.yaml b/backend/data/questions/majority-element.yaml
index 6c3bc50..3350dcc 100644
--- a/backend/data/questions/majority-element.yaml
+++ b/backend/data/questions/majority-element.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - hash-tables
 patterns:
-  - greedy
+  - slug: greedy
+    is_optimal: true
 
 function_signature: "def majority_element(nums: list[int]) -> int:"
 
diff --git a/backend/data/questions/matchsticks-to-square.yaml b/backend/data/questions/matchsticks-to-square.yaml
index 7e6f18c..5d15751 100644
--- a/backend/data/questions/matchsticks-to-square.yaml
+++ b/backend/data/questions/matchsticks-to-square.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - recursion
 patterns:
-  - backtracking
+  - slug: backtracking
+    is_optimal: true
 
 function_signature: "def makesquare(matchsticks: list[int]) -> bool:"
 
diff --git a/backend/data/questions/max-area-of-island.yaml b/backend/data/questions/max-area-of-island.yaml
index 9e08a38..702960e 100644
--- a/backend/data/questions/max-area-of-island.yaml
+++ b/backend/data/questions/max-area-of-island.yaml
@@ -7,9 +7,12 @@ categories:
   - graphs
   - arrays
 patterns:
-  - dfs
-  - bfs
-  - matrix-traversal
+  - slug: dfs
+    is_optimal: false
+  - slug: bfs
+    is_optimal: true
+  - slug: matrix-traversal
+    is_optimal: false
 
 function_signature: "def max_area_of_island(grid: list[list[int]]) -> int:"
 
diff --git a/backend/data/questions/maximum-depth-of-binary-tree.yaml b/backend/data/questions/maximum-depth-of-binary-tree.yaml
index 6afd84f..cc4e477 100644
--- a/backend/data/questions/maximum-depth-of-binary-tree.yaml
+++ b/backend/data/questions/maximum-depth-of-binary-tree.yaml
@@ -7,9 +7,12 @@ categories:
   - trees
   - recursion
 patterns:
-  - dfs
-  - bfs
-  - tree-traversal
+  - slug: dfs
+    is_optimal: false
+  - slug: bfs
+    is_optimal: true
+  - slug: tree-traversal
+    is_optimal: false
 
 function_signature: "def max_depth(root: TreeNode | None) -> int:"
 
diff --git a/backend/data/questions/maximum-frequency-stack.yaml b/backend/data/questions/maximum-frequency-stack.yaml
index c7f6ac7..e885954 100644
--- a/backend/data/questions/maximum-frequency-stack.yaml
+++ b/backend/data/questions/maximum-frequency-stack.yaml
@@ -7,7 +7,10 @@ categories:
   - stack
   - hash-tables
 patterns:
-  - heap
+  - slug: monotonic-stack
+    is_optimal: true
+  - slug: hashing
+    is_optimal: false
 
 function_signature: "class FreqStack: def __init__(self); def push(self, val: int) -> None; def pop(self) -> int"
 
diff --git a/backend/data/questions/maximum-fruits-harvested-after-at-most-k-steps.yaml b/backend/data/questions/maximum-fruits-harvested-after-at-most-k-steps.yaml
index 4f0edc4..a5a8f8d 100644
--- a/backend/data/questions/maximum-fruits-harvested-after-at-most-k-steps.yaml
+++ b/backend/data/questions/maximum-fruits-harvested-after-at-most-k-steps.yaml
@@ -7,9 +7,12 @@ categories:
   - arrays
   - binary-search
 patterns:
-  - sliding-window
-  - prefix-sum
-  - two-pointers
+  - slug: sliding-window
+    is_optimal: true
+  - slug: prefix-sum
+    is_optimal: false
+  - slug: two-pointers
+    is_optimal: false
 
 function_signature: "def max_total_fruits(fruits: list[list[int]], start_pos: int, k: int) -> int:"
 
diff --git a/backend/data/questions/maximum-length-of-pair-chain.yaml b/backend/data/questions/maximum-length-of-pair-chain.yaml
index 2ff5676..46d3c17 100644
--- a/backend/data/questions/maximum-length-of-pair-chain.yaml
+++ b/backend/data/questions/maximum-length-of-pair-chain.yaml
@@ -8,8 +8,10 @@ categories:
   - sorting
   - dynamic-programming
 patterns:
-  - greedy
-  - intervals
+  - slug: greedy
+    is_optimal: false
+  - slug: intervals
+    is_optimal: true
 
 function_signature: "def find_longest_chain(pairs: list[list[int]]) -> int:"
 
diff --git a/backend/data/questions/maximum-product-subarray.yaml b/backend/data/questions/maximum-product-subarray.yaml
index 0488aed..5388679 100644
--- a/backend/data/questions/maximum-product-subarray.yaml
+++ b/backend/data/questions/maximum-product-subarray.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - dynamic-programming
 patterns:
-  - dynamic-programming
+  - slug: dynamic-programming
+    is_optimal: true
 
 function_signature: "def max_product(nums: list[int]) -> int:"
 
diff --git a/backend/data/questions/maximum-subarray.yaml b/backend/data/questions/maximum-subarray.yaml
index 70a020f..c968068 100644
--- a/backend/data/questions/maximum-subarray.yaml
+++ b/backend/data/questions/maximum-subarray.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - dynamic-programming
 patterns:
-  - dynamic-programming
+  - slug: dynamic-programming
+    is_optimal: true
 
 function_signature: "def max_subarray(nums: list[int]) -> int:"
 
diff --git a/backend/data/questions/maximum-sum-circular-subarray.yaml b/backend/data/questions/maximum-sum-circular-subarray.yaml
index 525be32..31ba4de 100644
--- a/backend/data/questions/maximum-sum-circular-subarray.yaml
+++ b/backend/data/questions/maximum-sum-circular-subarray.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - dynamic-programming
 patterns:
-  - dynamic-programming
+  - slug: dynamic-programming
+    is_optimal: true
 
 function_signature: "def max_subarray_sum_circular(nums: list[int]) -> int:"
 
diff --git a/backend/data/questions/median-of-two-sorted-arrays.yaml b/backend/data/questions/median-of-two-sorted-arrays.yaml
index 02901bd..62d5c81 100644
--- a/backend/data/questions/median-of-two-sorted-arrays.yaml
+++ b/backend/data/questions/median-of-two-sorted-arrays.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - binary-search
 patterns:
-  - binary-search
+  - slug: binary-search
+    is_optimal: true
 
 function_signature: "def find_median_sorted_arrays(nums1: list[int], nums2: list[int]) -> float:"
 
diff --git a/backend/data/questions/merge-intervals.yaml b/backend/data/questions/merge-intervals.yaml
index 96945fd..444e65b 100644
--- a/backend/data/questions/merge-intervals.yaml
+++ b/backend/data/questions/merge-intervals.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - sorting
 patterns:
-  - intervals
+  - slug: intervals
+    is_optimal: true
 
 function_signature: "def merge(intervals: list[list[int]]) -> list[list[int]]:"
 
diff --git a/backend/data/questions/merge-k-sorted-lists.yaml b/backend/data/questions/merge-k-sorted-lists.yaml
index f290be2..68e29bf 100644
--- a/backend/data/questions/merge-k-sorted-lists.yaml
+++ b/backend/data/questions/merge-k-sorted-lists.yaml
@@ -7,7 +7,8 @@ categories:
   - linked-lists
   - heap
 patterns:
-  - heap
+  - slug: heap
+    is_optimal: true
 
 function_signature: "def merge_k_lists(lists: list[ListNode | None]) -> ListNode | None:"
 
diff --git a/backend/data/questions/merge-sorted-array.yaml b/backend/data/questions/merge-sorted-array.yaml
index 3d2ae23..d4c0747 100644
--- a/backend/data/questions/merge-sorted-array.yaml
+++ b/backend/data/questions/merge-sorted-array.yaml
@@ -8,7 +8,8 @@ categories:
   - two-pointers
   - sorting
 patterns:
-  - two-pointers
+  - slug: two-pointers
+    is_optimal: true
 
 function_signature: "def merge(nums1: list[int], m: int, nums2: list[int], n: int) -> list[int]:"
 
diff --git a/backend/data/questions/merge-strings-alternately.yaml b/backend/data/questions/merge-strings-alternately.yaml
index f7e9957..1a580e6 100644
--- a/backend/data/questions/merge-strings-alternately.yaml
+++ b/backend/data/questions/merge-strings-alternately.yaml
@@ -7,7 +7,8 @@ categories:
   - strings
   - two-pointers
 patterns:
-  - two-pointers
+  - slug: two-pointers
+    is_optimal: true
 
 function_signature: "def merge_alternately(word1: str, word2: str) -> str:"
 
diff --git a/backend/data/questions/merge-triplets-to-form-target-triplet.yaml b/backend/data/questions/merge-triplets-to-form-target-triplet.yaml
index 031743c..ab6e77e 100644
--- a/backend/data/questions/merge-triplets-to-form-target-triplet.yaml
+++ b/backend/data/questions/merge-triplets-to-form-target-triplet.yaml
@@ -6,7 +6,8 @@ leetcode_url: https://leetcode.com/problems/merge-triplets-to-form-target-triple
 categories:
   - arrays
 patterns:
-  - greedy
+  - slug: greedy
+    is_optimal: true
 
 function_signature: "def merge_triplets(triplets: list[list[int]], target: list[int]) -> bool:"
 
diff --git a/backend/data/questions/merge-two-sorted-lists.yaml b/backend/data/questions/merge-two-sorted-lists.yaml
index 7d06f01..09b27bb 100644
--- a/backend/data/questions/merge-two-sorted-lists.yaml
+++ b/backend/data/questions/merge-two-sorted-lists.yaml
@@ -7,7 +7,8 @@ categories:
   - linked-lists
   - recursion
 patterns:
-  - two-pointers
+  - slug: two-pointers
+    is_optimal: true
 
 function_signature: "def merge_two_lists(list1: ListNode | None, list2: ListNode | None) -> ListNode | None:"
 
diff --git a/backend/data/questions/min-cost-climbing-stairs.yaml b/backend/data/questions/min-cost-climbing-stairs.yaml
index 7296769..b5b7c76 100644
--- a/backend/data/questions/min-cost-climbing-stairs.yaml
+++ b/backend/data/questions/min-cost-climbing-stairs.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - dynamic-programming
 patterns:
-  - dynamic-programming
+  - slug: dynamic-programming
+    is_optimal: true
 
 function_signature: "def min_cost_climbing_stairs(cost: list[int]) -> int:"
 
diff --git a/backend/data/questions/min-cost-to-connect-all-points.yaml b/backend/data/questions/min-cost-to-connect-all-points.yaml
index 39e48a6..47706e8 100644
--- a/backend/data/questions/min-cost-to-connect-all-points.yaml
+++ b/backend/data/questions/min-cost-to-connect-all-points.yaml
@@ -7,8 +7,10 @@ categories:
   - graphs
   - heap
 patterns:
-  - heap
-  - union-find
+  - slug: heap
+    is_optimal: true
+  - slug: union-find
+    is_optimal: false
 
 function_signature: "def min_cost_connect_points(points: list[list[int]]) -> int:"
 
diff --git a/backend/data/questions/min-stack.yaml b/backend/data/questions/min-stack.yaml
index 9f506fd..a7e8d2b 100644
--- a/backend/data/questions/min-stack.yaml
+++ b/backend/data/questions/min-stack.yaml
@@ -6,7 +6,8 @@ leetcode_url: https://leetcode.com/problems/min-stack/
 categories:
   - stack
 patterns:
-  - monotonic-stack
+  - slug: monotonic-stack
+    is_optimal: true
 
 function_signature: "class MinStack"
 
diff --git a/backend/data/questions/minimum-height-trees.yaml b/backend/data/questions/minimum-height-trees.yaml
index edac0ed..38e41e1 100644
--- a/backend/data/questions/minimum-height-trees.yaml
+++ b/backend/data/questions/minimum-height-trees.yaml
@@ -7,8 +7,10 @@ categories:
   - graphs
   - trees
 patterns:
-  - bfs
-  - tree-traversal
+  - slug: bfs
+    is_optimal: true
+  - slug: tree-traversal
+    is_optimal: false
 
 function_signature: "def find_min_height_trees(n: int, edges: list[list[int]]) -> list[int]:"
 
diff --git a/backend/data/questions/minimum-interval-to-include-each-query.yaml b/backend/data/questions/minimum-interval-to-include-each-query.yaml
index 171008c..33b7679 100644
--- a/backend/data/questions/minimum-interval-to-include-each-query.yaml
+++ b/backend/data/questions/minimum-interval-to-include-each-query.yaml
@@ -8,7 +8,8 @@ categories:
   - sorting
   - heap
 patterns:
-  - heap
+  - slug: heap
+    is_optimal: true
 
 function_signature: "def min_interval(intervals: list[list[int]], queries: list[int]) -> list[int]:"
 
diff --git a/backend/data/questions/minimum-path-sum.yaml b/backend/data/questions/minimum-path-sum.yaml
index 79b760c..939a9ed 100644
--- a/backend/data/questions/minimum-path-sum.yaml
+++ b/backend/data/questions/minimum-path-sum.yaml
@@ -7,8 +7,10 @@ categories:
   - arrays
   - dynamic-programming
 patterns:
-  - dynamic-programming
-  - matrix-traversal
+  - slug: dynamic-programming
+    is_optimal: false
+  - slug: matrix-traversal
+    is_optimal: true
 
 function_signature: "def min_path_sum(grid: list[list[int]]) -> int:"
 
diff --git a/backend/data/questions/minimum-size-subarray-sum.yaml b/backend/data/questions/minimum-size-subarray-sum.yaml
index b166e0d..064957f 100644
--- a/backend/data/questions/minimum-size-subarray-sum.yaml
+++ b/backend/data/questions/minimum-size-subarray-sum.yaml
@@ -7,9 +7,12 @@ categories:
   - arrays
   - binary-search
 patterns:
-  - sliding-window
-  - binary-search
-  - prefix-sum
+  - slug: sliding-window
+    is_optimal: false
+  - slug: binary-search
+    is_optimal: true
+  - slug: prefix-sum
+    is_optimal: false
 
 function_signature: "def min_subarray_len(target: int, nums: list[int]) -> int:"
 
diff --git a/backend/data/questions/minimum-window-substring.yaml b/backend/data/questions/minimum-window-substring.yaml
index c9fd6e5..a30bba4 100644
--- a/backend/data/questions/minimum-window-substring.yaml
+++ b/backend/data/questions/minimum-window-substring.yaml
@@ -7,7 +7,8 @@ categories:
   - strings
   - hash-tables
 patterns:
-  - sliding-window
+  - slug: sliding-window
+    is_optimal: true
 
 function_signature: "def min_window(s: str, t: str) -> str:"
 
diff --git a/backend/data/questions/missing-number.yaml b/backend/data/questions/missing-number.yaml
index e8728a5..9b6688c 100644
--- a/backend/data/questions/missing-number.yaml
+++ b/backend/data/questions/missing-number.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - math
 patterns:
-  - prefix-sum
+  - slug: prefix-sum
+    is_optimal: true
 
 function_signature: "def missing_number(nums: list[int]) -> int:"
 
diff --git a/backend/data/questions/multiply-strings.yaml b/backend/data/questions/multiply-strings.yaml
index 7d40f43..9953a0a 100644
--- a/backend/data/questions/multiply-strings.yaml
+++ b/backend/data/questions/multiply-strings.yaml
@@ -7,7 +7,8 @@ categories:
   - strings
   - math
 patterns:
-  - two-pointers
+  - slug: two-pointers
+    is_optimal: true
 
 function_signature: "def multiply(num1: str, num2: str) -> str:"
 
diff --git a/backend/data/questions/network-delay-time.yaml b/backend/data/questions/network-delay-time.yaml
index 572228d..cc662ab 100644
--- a/backend/data/questions/network-delay-time.yaml
+++ b/backend/data/questions/network-delay-time.yaml
@@ -7,8 +7,10 @@ categories:
   - graphs
   - heap
 patterns:
-  - bfs
-  - heap
+  - slug: heap
+    is_optimal: true
+  - slug: bfs
+    is_optimal: false
 
 function_signature: "def network_delay_time(times: list[list[int]], n: int, k: int) -> int:"
 
@@ -146,6 +148,30 @@ explanation:
   time_complexity: "O((V + E) log V). Each node is processed once, and each edge triggers at most one heap operation. With `n` nodes and `m` edges, this is O((n + m) log n)."
   space_complexity: "O(V + E). We store the adjacency list (O(E)) and the distance dictionary plus heap (O(V))."
 
+  pattern_comparison: |
+    **Dijkstra (Heap) vs BFS: When Weights Matter**
+
+    This problem illustrates a critical distinction in graph traversal:
+
+    | Algorithm | Time | Works With | Use When |
+    |-----------|------|------------|----------|
+    | **Dijkstra (Heap)** | O((V+E) log V) | Non-negative weighted edges | Edge weights vary |
+    | **BFS** | O(V + E) | Unweighted or unit-weight edges | All edges have same cost |
+    | **Bellman-Ford** | O(V × E) | Any weights (including negative) | Negative edges possible |
+
+    **Why BFS fails here:**
+    BFS explores nodes in order of *hop count* (number of edges), not *total distance*. Consider:
+    ```
+    A --1--> B --1--> C
+    A --------10------> C
+    ```
+    BFS would reach C via the direct edge first (1 hop) with cost 10, missing the shorter 2-hop path with cost 2.
+
+    **Why Dijkstra works:**
+    The min-heap ensures we process nodes in order of *actual distance* from the source. When we first reach a node, we've found the shortest path to it (because all unvisited nodes are at least as far away).
+
+    **The key insight:** Dijkstra is essentially "weighted BFS" — the heap replaces the queue to account for edge weights.
+
 solutions:
   - approach_name: Dijkstra's Algorithm
     is_optimal: true
diff --git a/backend/data/questions/number-of-1-bits.yaml b/backend/data/questions/number-of-1-bits.yaml
index 6aa8be3..58df587 100644
--- a/backend/data/questions/number-of-1-bits.yaml
+++ b/backend/data/questions/number-of-1-bits.yaml
@@ -5,7 +5,9 @@ leetcode_id: 191
 leetcode_url: https://leetcode.com/problems/number-of-1-bits/
 categories:
   - math
-patterns: []
+patterns:
+  - slug: bit-manipulation
+    is_optimal: true
 
 function_signature: "def hamming_weight(n: int) -> int:"
 
diff --git a/backend/data/questions/number-of-islands.yaml b/backend/data/questions/number-of-islands.yaml
index a1ef022..dd86ae3 100644
--- a/backend/data/questions/number-of-islands.yaml
+++ b/backend/data/questions/number-of-islands.yaml
@@ -7,9 +7,12 @@ categories:
   - graphs
   - arrays
 patterns:
-  - dfs
-  - bfs
-  - matrix-traversal
+  - slug: dfs
+    is_optimal: false
+  - slug: bfs
+    is_optimal: true
+  - slug: matrix-traversal
+    is_optimal: false
 
 function_signature: "def num_islands(grid: list[list[str]]) -> int:"
 
diff --git a/backend/data/questions/one-bit-and-two-bit-characters.yaml b/backend/data/questions/one-bit-and-two-bit-characters.yaml
index 09fcd8e..5aa1864 100644
--- a/backend/data/questions/one-bit-and-two-bit-characters.yaml
+++ b/backend/data/questions/one-bit-and-two-bit-characters.yaml
@@ -6,7 +6,8 @@ leetcode_url: https://leetcode.com/problems/1-bit-and-2-bit-characters/
 categories:
   - arrays
 patterns:
-  - greedy
+  - slug: greedy
+    is_optimal: true
 
 function_signature: "def is_one_bit_character(bits: list[int]) -> bool:"
 
diff --git a/backend/data/questions/online-stock-span.yaml b/backend/data/questions/online-stock-span.yaml
index 6b3dfaa..18576e7 100644
--- a/backend/data/questions/online-stock-span.yaml
+++ b/backend/data/questions/online-stock-span.yaml
@@ -6,7 +6,8 @@ leetcode_url: https://leetcode.com/problems/online-stock-span/
 categories:
   - stack
 patterns:
-  - monotonic-stack
+  - slug: monotonic-stack
+    is_optimal: true
 
 function_signature: "class StockSpanner"
 
diff --git a/backend/data/questions/open-the-lock.yaml b/backend/data/questions/open-the-lock.yaml
index 217f379..6dc941b 100644
--- a/backend/data/questions/open-the-lock.yaml
+++ b/backend/data/questions/open-the-lock.yaml
@@ -8,7 +8,8 @@ categories:
   - hash-tables
   - graphs
 patterns:
-  - bfs
+  - slug: bfs
+    is_optimal: true
 
 function_signature: "def open_lock(deadends: list[str], target: str) -> int:"
 
diff --git a/backend/data/questions/pacific-atlantic-water-flow.yaml b/backend/data/questions/pacific-atlantic-water-flow.yaml
index 28be447..d68173b 100644
--- a/backend/data/questions/pacific-atlantic-water-flow.yaml
+++ b/backend/data/questions/pacific-atlantic-water-flow.yaml
@@ -7,8 +7,10 @@ categories:
   - graphs
   - arrays
 patterns:
-  - dfs
-  - matrix-traversal
+  - slug: dfs
+    is_optimal: true
+  - slug: matrix-traversal
+    is_optimal: false
 
 function_signature: "def pacific_atlantic(heights: list[list[int]]) -> list[list[int]]:"
 
diff --git a/backend/data/questions/palindrome-number.yaml b/backend/data/questions/palindrome-number.yaml
index 1a70af0..d6637cb 100644
--- a/backend/data/questions/palindrome-number.yaml
+++ b/backend/data/questions/palindrome-number.yaml
@@ -6,7 +6,8 @@ leetcode_url: https://leetcode.com/problems/palindrome-number/
 categories:
   - math
 patterns:
-  - two-pointers
+  - slug: two-pointers
+    is_optimal: true
 
 function_signature: "def is_palindrome(x: int) -> bool:"
 
diff --git a/backend/data/questions/palindrome-partitioning.yaml b/backend/data/questions/palindrome-partitioning.yaml
index 624a3c3..7b9c510 100644
--- a/backend/data/questions/palindrome-partitioning.yaml
+++ b/backend/data/questions/palindrome-partitioning.yaml
@@ -8,8 +8,10 @@ categories:
   - dynamic-programming
   - recursion
 patterns:
-  - backtracking
-  - dynamic-programming
+  - slug: backtracking
+    is_optimal: false
+  - slug: dynamic-programming
+    is_optimal: true
 
 function_signature: "def partition(s: str) -> list[list[str]]:"
 
diff --git a/backend/data/questions/palindromic-substrings.yaml b/backend/data/questions/palindromic-substrings.yaml
index a7231ca..727a403 100644
--- a/backend/data/questions/palindromic-substrings.yaml
+++ b/backend/data/questions/palindromic-substrings.yaml
@@ -7,8 +7,10 @@ categories:
   - strings
   - dynamic-programming
 patterns:
-  - two-pointers
-  - dynamic-programming
+  - slug: two-pointers
+    is_optimal: true
+  - slug: dynamic-programming
+    is_optimal: false
 
 function_signature: "def count_substrings(s: str) -> int:"
 
diff --git a/backend/data/questions/partition-equal-subset-sum.yaml b/backend/data/questions/partition-equal-subset-sum.yaml
index a2d9bbd..d7c36ae 100644
--- a/backend/data/questions/partition-equal-subset-sum.yaml
+++ b/backend/data/questions/partition-equal-subset-sum.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - dynamic-programming
 patterns:
-  - dynamic-programming
+  - slug: dynamic-programming
+    is_optimal: true
 
 function_signature: "def can_partition(nums: list[int]) -> bool:"
 
diff --git a/backend/data/questions/partition-labels.yaml b/backend/data/questions/partition-labels.yaml
index f36d042..85563b7 100644
--- a/backend/data/questions/partition-labels.yaml
+++ b/backend/data/questions/partition-labels.yaml
@@ -8,8 +8,10 @@ categories:
   - hash-tables
   - two-pointers
 patterns:
-  - greedy
-  - two-pointers
+  - slug: greedy
+    is_optimal: false
+  - slug: two-pointers
+    is_optimal: true
 
 function_signature: "def partition_labels(s: str) -> list[int]:"
 
diff --git a/backend/data/questions/partition-to-k-equal-sum-subsets.yaml b/backend/data/questions/partition-to-k-equal-sum-subsets.yaml
index d071419..2556001 100644
--- a/backend/data/questions/partition-to-k-equal-sum-subsets.yaml
+++ b/backend/data/questions/partition-to-k-equal-sum-subsets.yaml
@@ -8,7 +8,8 @@ categories:
   - dynamic-programming
   - recursion
 patterns:
-  - backtracking
+  - slug: backtracking
+    is_optimal: true
 
 function_signature: "def can_partition_k_subsets(nums: list[int], k: int) -> bool:"
 
diff --git a/backend/data/questions/path-with-minimum-effort.yaml b/backend/data/questions/path-with-minimum-effort.yaml
index ac5be8e..76e27f8 100644
--- a/backend/data/questions/path-with-minimum-effort.yaml
+++ b/backend/data/questions/path-with-minimum-effort.yaml
@@ -9,10 +9,14 @@ categories:
   - binary-search
   - heap
 patterns:
-  - binary-search
-  - bfs
-  - heap
-  - matrix-traversal
+  - slug: heap
+    is_optimal: true
+  - slug: binary-search
+    is_optimal: false
+  - slug: bfs
+    is_optimal: false
+  - slug: matrix-traversal
+    is_optimal: false
 
 function_signature: "def minimum_effort_path(heights: list[list[int]]) -> int:"
 
diff --git a/backend/data/questions/perfect-squares.yaml b/backend/data/questions/perfect-squares.yaml
index 2dc977a..c2027f8 100644
--- a/backend/data/questions/perfect-squares.yaml
+++ b/backend/data/questions/perfect-squares.yaml
@@ -7,8 +7,10 @@ categories:
   - dynamic-programming
   - math
 patterns:
-  - dynamic-programming
-  - bfs
+  - slug: dynamic-programming
+    is_optimal: false
+  - slug: bfs
+    is_optimal: true
 
 function_signature: "def num_squares(n: int) -> int:"
 
diff --git a/backend/data/questions/permutation-in-string.yaml b/backend/data/questions/permutation-in-string.yaml
index 257bc85..54ebb09 100644
--- a/backend/data/questions/permutation-in-string.yaml
+++ b/backend/data/questions/permutation-in-string.yaml
@@ -8,7 +8,8 @@ categories:
   - hash-tables
   - two-pointers
 patterns:
-  - sliding-window
+  - slug: sliding-window
+    is_optimal: true
 
 function_signature: "def check_inclusion(s1: str, s2: str) -> bool:"
 
diff --git a/backend/data/questions/permutations-ii.yaml b/backend/data/questions/permutations-ii.yaml
index 067206e..4604048 100644
--- a/backend/data/questions/permutations-ii.yaml
+++ b/backend/data/questions/permutations-ii.yaml
@@ -8,7 +8,8 @@ categories:
   - sorting
   - recursion
 patterns:
-  - backtracking
+  - slug: backtracking
+    is_optimal: true
 
 function_signature: "def permute_unique(nums: list[int]) -> list[list[int]]:"
 
diff --git a/backend/data/questions/permutations.yaml b/backend/data/questions/permutations.yaml
index a07ff12..da4b990 100644
--- a/backend/data/questions/permutations.yaml
+++ b/backend/data/questions/permutations.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - recursion
 patterns:
-  - backtracking
+  - slug: backtracking
+    is_optimal: true
 
 function_signature: "def permute(nums: list[int]) -> list[list[int]]:"
 
diff --git a/backend/data/questions/plus-one.yaml b/backend/data/questions/plus-one.yaml
index 199a82b..4667d63 100644
--- a/backend/data/questions/plus-one.yaml
+++ b/backend/data/questions/plus-one.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - math
 patterns:
-  - greedy
+  - slug: greedy
+    is_optimal: true
 
 function_signature: "def plus_one(digits: list[int]) -> list[int]:"
 
diff --git a/backend/data/questions/powx-n.yaml b/backend/data/questions/powx-n.yaml
index 0296524..3cd6d60 100644
--- a/backend/data/questions/powx-n.yaml
+++ b/backend/data/questions/powx-n.yaml
@@ -7,7 +7,8 @@ categories:
   - math
   - recursion
 patterns:
-  - binary-search
+  - slug: binary-search
+    is_optimal: true
 
 function_signature: "def my_pow(x: float, n: int) -> float:"
 
diff --git a/backend/data/questions/product-of-array-except-self.yaml b/backend/data/questions/product-of-array-except-self.yaml
index 34a586b..6beb9eb 100644
--- a/backend/data/questions/product-of-array-except-self.yaml
+++ b/backend/data/questions/product-of-array-except-self.yaml
@@ -6,7 +6,8 @@ leetcode_url: https://leetcode.com/problems/product-of-array-except-self/
 categories:
   - arrays
 patterns:
-  - prefix-sum
+  - slug: prefix-sum
+    is_optimal: true
 
 function_signature: "def product_except_self(nums: list[int]) -> list[int]:"
 
diff --git a/backend/data/questions/reconstruct-itinerary.yaml b/backend/data/questions/reconstruct-itinerary.yaml
index 0f86862..b8c603f 100644
--- a/backend/data/questions/reconstruct-itinerary.yaml
+++ b/backend/data/questions/reconstruct-itinerary.yaml
@@ -6,7 +6,8 @@ leetcode_url: https://leetcode.com/problems/reconstruct-itinerary/
 categories:
   - graphs
 patterns:
-  - dfs
+  - slug: dfs
+    is_optimal: true
 
 function_signature: "def find_itinerary(tickets: list[list[str]]) -> list[str]:"
 
diff --git a/backend/data/questions/redundant-connection.yaml b/backend/data/questions/redundant-connection.yaml
index 4e53232..3c337de 100644
--- a/backend/data/questions/redundant-connection.yaml
+++ b/backend/data/questions/redundant-connection.yaml
@@ -6,8 +6,10 @@ leetcode_url: https://leetcode.com/problems/redundant-connection/
 categories:
   - graphs
 patterns:
-  - union-find
-  - dfs
+  - slug: union-find
+    is_optimal: true
+  - slug: dfs
+    is_optimal: false
 
 function_signature: "def find_redundant_connection(edges: list[list[int]]) -> list[int]:"
 
diff --git a/backend/data/questions/regular-expression-matching.yaml b/backend/data/questions/regular-expression-matching.yaml
index 94001c1..066135b 100644
--- a/backend/data/questions/regular-expression-matching.yaml
+++ b/backend/data/questions/regular-expression-matching.yaml
@@ -8,7 +8,8 @@ categories:
   - dynamic-programming
   - recursion
 patterns:
-  - dynamic-programming
+  - slug: dynamic-programming
+    is_optimal: true
 
 function_signature: "def is_match(s: str, p: str) -> bool:"
 
diff --git a/backend/data/questions/remove-duplicates-from-sorted-array.yaml b/backend/data/questions/remove-duplicates-from-sorted-array.yaml
index c83de10..beed4bf 100644
--- a/backend/data/questions/remove-duplicates-from-sorted-array.yaml
+++ b/backend/data/questions/remove-duplicates-from-sorted-array.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - two-pointers
 patterns:
-  - two-pointers
+  - slug: two-pointers
+    is_optimal: true
 
 function_signature: "def remove_duplicates(nums: list[int]) -> int:"
 
diff --git a/backend/data/questions/remove-element.yaml b/backend/data/questions/remove-element.yaml
index 40dd602..86522aa 100644
--- a/backend/data/questions/remove-element.yaml
+++ b/backend/data/questions/remove-element.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - two-pointers
 patterns:
-  - two-pointers
+  - slug: two-pointers
+    is_optimal: true
 
 function_signature: "def remove_element(nums: list[int], val: int) -> int:"
 
diff --git a/backend/data/questions/remove-nth-node-from-end-of-list.yaml b/backend/data/questions/remove-nth-node-from-end-of-list.yaml
index 87abcc8..94530b3 100644
--- a/backend/data/questions/remove-nth-node-from-end-of-list.yaml
+++ b/backend/data/questions/remove-nth-node-from-end-of-list.yaml
@@ -7,8 +7,10 @@ categories:
   - linked-lists
   - two-pointers
 patterns:
-  - two-pointers
-  - fast-slow-pointers
+  - slug: two-pointers
+    is_optimal: true
+  - slug: fast-slow-pointers
+    is_optimal: false
 
 function_signature: "def remove_nth_from_end(head: ListNode, n: int) -> ListNode:"
 
diff --git a/backend/data/questions/reorder-list.yaml b/backend/data/questions/reorder-list.yaml
index f501da6..e9786d6 100644
--- a/backend/data/questions/reorder-list.yaml
+++ b/backend/data/questions/reorder-list.yaml
@@ -7,8 +7,10 @@ categories:
   - linked-lists
   - two-pointers
 patterns:
-  - fast-slow-pointers
-  - linkedlist-reversal
+  - slug: fast-slow-pointers
+    is_optimal: true
+  - slug: linkedlist-reversal
+    is_optimal: false
 
 function_signature: "def reorder_list(head: ListNode) -> None:"
 
diff --git a/backend/data/questions/reorganize-string.yaml b/backend/data/questions/reorganize-string.yaml
index e7abbca..bf46012 100644
--- a/backend/data/questions/reorganize-string.yaml
+++ b/backend/data/questions/reorganize-string.yaml
@@ -8,8 +8,10 @@ categories:
   - hash-tables
   - heap
 patterns:
-  - greedy
-  - heap
+  - slug: heap
+    is_optimal: true
+  - slug: greedy
+    is_optimal: false
 
 function_signature: "def reorganize_string(s: str) -> str:"
 
@@ -133,6 +135,32 @@ explanation:
   time_complexity: "O(n log k). We process each of the `n` characters, and each heap operation takes O(log k) where `k` is the number of unique characters (at most 26)."
   space_complexity: "O(k). We store at most `k` unique characters in the heap and hash map, where `k <= 26` for lowercase English letters."
 
+  pattern_comparison: |
+    **Heap Greedy vs Odd-Even Placement: Two Valid Approaches**
+
+    Both solutions achieve optimal results through different strategies:
+
+    | Approach | Time | Space | Key Insight |
+    |----------|------|-------|-------------|
+    | **Max Heap** | O(n log k) | O(k) | Always place the most frequent available character |
+    | **Odd-Even** | O(n + k log k) | O(n) | Separate characters by index parity |
+
+    **Heap Greedy (Online):**
+    - Builds the string character by character
+    - Naturally handles the "don't repeat" constraint via the hold-back pattern
+    - More intuitive: "always pick the best available option"
+
+    **Odd-Even Placement (Batch):**
+    - First fills even indices (0, 2, 4...), then odd indices (1, 3, 5...)
+    - Characters at even indices can never be adjacent to each other
+    - Exploits the constraint: if max_freq ≤ (n+1)/2, even indices can hold all instances of the most frequent character
+
+    **When to prefer each:**
+    - **Heap**: When you need to explain the greedy logic step-by-step, or for streaming inputs
+    - **Odd-Even**: When you want simpler code (no heap needed), or when explaining the mathematical feasibility condition
+
+    **Both share the same core insight**: Check `max_freq ≤ (n+1)/2` first — this determines whether a solution is even possible.
+
 solutions:
   - approach_name: Max Heap (Greedy)
     is_optimal: true
diff --git a/backend/data/questions/reverse-bits.yaml b/backend/data/questions/reverse-bits.yaml
index 19a3bbd..4044929 100644
--- a/backend/data/questions/reverse-bits.yaml
+++ b/backend/data/questions/reverse-bits.yaml
@@ -6,7 +6,8 @@ leetcode_url: https://leetcode.com/problems/reverse-bits/
 categories:
   - math
 patterns:
-  - two-pointers
+  - slug: two-pointers
+    is_optimal: true
 
 function_signature: "def reverse_bits(n: int) -> int:"
 
diff --git a/backend/data/questions/reverse-integer.yaml b/backend/data/questions/reverse-integer.yaml
index bfb0a52..dfcbf74 100644
--- a/backend/data/questions/reverse-integer.yaml
+++ b/backend/data/questions/reverse-integer.yaml
@@ -6,7 +6,8 @@ leetcode_url: https://leetcode.com/problems/reverse-integer/
 categories:
   - math
 patterns:
-  - greedy
+  - slug: greedy
+    is_optimal: true
 
 function_signature: "def reverse(x: int) -> int:"
 
diff --git a/backend/data/questions/reverse-linked-list-ii.yaml b/backend/data/questions/reverse-linked-list-ii.yaml
index fdcd9fb..8f99e23 100644
--- a/backend/data/questions/reverse-linked-list-ii.yaml
+++ b/backend/data/questions/reverse-linked-list-ii.yaml
@@ -6,7 +6,8 @@ leetcode_url: https://leetcode.com/problems/reverse-linked-list-ii/
 categories:
   - linked-lists
 patterns:
-  - linkedlist-reversal
+  - slug: linkedlist-reversal
+    is_optimal: true
 
 function_signature: "def reverse_between(head: ListNode, left: int, right: int) -> ListNode:"
 
diff --git a/backend/data/questions/reverse-linked-list.yaml b/backend/data/questions/reverse-linked-list.yaml
index efcac97..cb233e0 100644
--- a/backend/data/questions/reverse-linked-list.yaml
+++ b/backend/data/questions/reverse-linked-list.yaml
@@ -7,7 +7,8 @@ categories:
   - linked-lists
   - recursion
 patterns:
-  - linkedlist-reversal
+  - slug: linkedlist-reversal
+    is_optimal: true
 
 function_signature: "def reverse_list(head: ListNode | None) -> ListNode | None:"
 
diff --git a/backend/data/questions/reverse-string.yaml b/backend/data/questions/reverse-string.yaml
index 578ac8f..fad9c2d 100644
--- a/backend/data/questions/reverse-string.yaml
+++ b/backend/data/questions/reverse-string.yaml
@@ -7,7 +7,8 @@ categories:
   - strings
   - two-pointers
 patterns:
-  - two-pointers
+  - slug: two-pointers
+    is_optimal: true
 
 function_signature: "def reverse_string(s: list[str]) -> None:"
 
diff --git a/backend/data/questions/roman-to-integer.yaml b/backend/data/questions/roman-to-integer.yaml
index af833ca..956096b 100644
--- a/backend/data/questions/roman-to-integer.yaml
+++ b/backend/data/questions/roman-to-integer.yaml
@@ -8,7 +8,8 @@ categories:
   - hash-tables
   - math
 patterns:
-  - greedy
+  - slug: greedy
+    is_optimal: true
 
 function_signature: "def roman_to_int(s: str) -> int:"
 
diff --git a/backend/data/questions/rotate-array.yaml b/backend/data/questions/rotate-array.yaml
index ab552c0..1341cc4 100644
--- a/backend/data/questions/rotate-array.yaml
+++ b/backend/data/questions/rotate-array.yaml
@@ -8,7 +8,8 @@ categories:
   - two-pointers
   - math
 patterns:
-  - two-pointers
+  - slug: two-pointers
+    is_optimal: true
 
 function_signature: "def rotate(nums: list[int], k: int) -> list[int]:"
 
diff --git a/backend/data/questions/rotate-image.yaml b/backend/data/questions/rotate-image.yaml
index b1346c7..27c5658 100644
--- a/backend/data/questions/rotate-image.yaml
+++ b/backend/data/questions/rotate-image.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - math
 patterns:
-  - matrix-manipulation
+  - slug: matrix-manipulation
+    is_optimal: true
 
 function_signature: "def rotate(matrix: list[list[int]]) -> None:"
 
diff --git a/backend/data/questions/rotting-oranges.yaml b/backend/data/questions/rotting-oranges.yaml
index ea08c3c..ff0431d 100644
--- a/backend/data/questions/rotting-oranges.yaml
+++ b/backend/data/questions/rotting-oranges.yaml
@@ -7,8 +7,10 @@ categories:
   - arrays
   - graphs
 patterns:
-  - bfs
-  - matrix-traversal
+  - slug: bfs
+    is_optimal: true
+  - slug: matrix-traversal
+    is_optimal: false
 
 function_signature: "def oranges_rotting(grid: list[list[int]]) -> int:"
 
diff --git a/backend/data/questions/same-tree.yaml b/backend/data/questions/same-tree.yaml
index e57d935..f885cc7 100644
--- a/backend/data/questions/same-tree.yaml
+++ b/backend/data/questions/same-tree.yaml
@@ -7,8 +7,10 @@ categories:
   - trees
   - recursion
 patterns:
-  - dfs
-  - tree-traversal
+  - slug: dfs
+    is_optimal: true
+  - slug: tree-traversal
+    is_optimal: false
 
 function_signature: "def is_same_tree(p: TreeNode | None, q: TreeNode | None) -> bool:"
 
diff --git a/backend/data/questions/search-a-2d-matrix.yaml b/backend/data/questions/search-a-2d-matrix.yaml
index f525f34..a1d4fce 100644
--- a/backend/data/questions/search-a-2d-matrix.yaml
+++ b/backend/data/questions/search-a-2d-matrix.yaml
@@ -7,8 +7,10 @@ categories:
   - arrays
   - binary-search
 patterns:
-  - binary-search
-  - matrix-traversal
+  - slug: binary-search
+    is_optimal: true
+  - slug: matrix-traversal
+    is_optimal: false
 
 function_signature: "def search_matrix(matrix: list[list[int]], target: int) -> bool:"
 
diff --git a/backend/data/questions/search-in-rotated-sorted-array-ii.yaml b/backend/data/questions/search-in-rotated-sorted-array-ii.yaml
index d705021..4471770 100644
--- a/backend/data/questions/search-in-rotated-sorted-array-ii.yaml
+++ b/backend/data/questions/search-in-rotated-sorted-array-ii.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - binary-search
 patterns:
-  - binary-search
+  - slug: binary-search
+    is_optimal: true
 
 function_signature: "def search(nums: list[int], target: int) -> bool:"
 
diff --git a/backend/data/questions/search-in-rotated-sorted-array.yaml b/backend/data/questions/search-in-rotated-sorted-array.yaml
index f36db71..c8c3d79 100644
--- a/backend/data/questions/search-in-rotated-sorted-array.yaml
+++ b/backend/data/questions/search-in-rotated-sorted-array.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - binary-search
 patterns:
-  - binary-search
+  - slug: binary-search
+    is_optimal: true
 
 function_signature: "def search(nums: list[int], target: int) -> int:"
 
diff --git a/backend/data/questions/search-insert-position.yaml b/backend/data/questions/search-insert-position.yaml
index 6225fee..e8e331f 100644
--- a/backend/data/questions/search-insert-position.yaml
+++ b/backend/data/questions/search-insert-position.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - binary-search
 patterns:
-  - binary-search
+  - slug: binary-search
+    is_optimal: true
 
 function_signature: "def search_insert(nums: list[int], target: int) -> int:"
 
diff --git a/backend/data/questions/serialize-and-deserialize-binary-tree.yaml b/backend/data/questions/serialize-and-deserialize-binary-tree.yaml
index 293788d..7e6f2d5 100644
--- a/backend/data/questions/serialize-and-deserialize-binary-tree.yaml
+++ b/backend/data/questions/serialize-and-deserialize-binary-tree.yaml
@@ -7,9 +7,12 @@ categories:
   - trees
   - strings
 patterns:
-  - bfs
-  - dfs
-  - tree-traversal
+  - slug: bfs
+    is_optimal: true
+  - slug: dfs
+    is_optimal: false
+  - slug: tree-traversal
+    is_optimal: false
 
 function_signature: "class Codec"
 
diff --git a/backend/data/questions/set-matrix-zeroes.yaml b/backend/data/questions/set-matrix-zeroes.yaml
index 5c319b0..43262a0 100644
--- a/backend/data/questions/set-matrix-zeroes.yaml
+++ b/backend/data/questions/set-matrix-zeroes.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - hash-tables
 patterns:
-  - matrix-traversal
+  - slug: matrix-traversal
+    is_optimal: true
 
 function_signature: "def set_zeroes(matrix: list[list[int]]) -> None:"
 
diff --git a/backend/data/questions/simplify-path.yaml b/backend/data/questions/simplify-path.yaml
index 323460a..8a2667a 100644
--- a/backend/data/questions/simplify-path.yaml
+++ b/backend/data/questions/simplify-path.yaml
@@ -7,7 +7,8 @@ categories:
   - strings
   - stack
 patterns:
-  - monotonic-stack
+  - slug: monotonic-stack
+    is_optimal: true
 
 function_signature: "def simplify_path(path: str) -> str:"
 
diff --git a/backend/data/questions/single-number.yaml b/backend/data/questions/single-number.yaml
index 88d7f3f..000e50c 100644
--- a/backend/data/questions/single-number.yaml
+++ b/backend/data/questions/single-number.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - math
 patterns:
-  - bit-manipulation
+  - slug: bit-manipulation
+    is_optimal: true
 
 function_signature: "def single_number(nums: list[int]) -> int:"
 
diff --git a/backend/data/questions/sliding-window-maximum.yaml b/backend/data/questions/sliding-window-maximum.yaml
index 49089b1..264e54f 100644
--- a/backend/data/questions/sliding-window-maximum.yaml
+++ b/backend/data/questions/sliding-window-maximum.yaml
@@ -8,8 +8,10 @@ categories:
   - queue
   - heap
 patterns:
-  - sliding-window
-  - monotonic-stack
+  - slug: monotonic-stack
+    is_optimal: true
+  - slug: sliding-window
+    is_optimal: false
 
 function_signature: "def max_sliding_window(nums: list[int], k: int) -> list[int]:"
 
diff --git a/backend/data/questions/sort-an-array.yaml b/backend/data/questions/sort-an-array.yaml
index c3afe41..7686002 100644
--- a/backend/data/questions/sort-an-array.yaml
+++ b/backend/data/questions/sort-an-array.yaml
@@ -8,7 +8,8 @@ categories:
   - sorting
   - recursion
 patterns:
-  - dynamic-programming
+  - slug: dynamic-programming
+    is_optimal: true
 
 function_signature: "def sort_array(nums: list[int]) -> list[int]:"
 
diff --git a/backend/data/questions/sort-colors.yaml b/backend/data/questions/sort-colors.yaml
index 5f8b71b..7454f23 100644
--- a/backend/data/questions/sort-colors.yaml
+++ b/backend/data/questions/sort-colors.yaml
@@ -8,7 +8,8 @@ categories:
   - two-pointers
   - sorting
 patterns:
-  - two-pointers
+  - slug: two-pointers
+    is_optimal: true
 
 function_signature: "def sort_colors(nums: list[int]) -> None:"
 
diff --git a/backend/data/questions/spiral-matrix-ii.yaml b/backend/data/questions/spiral-matrix-ii.yaml
index d273347..71050c2 100644
--- a/backend/data/questions/spiral-matrix-ii.yaml
+++ b/backend/data/questions/spiral-matrix-ii.yaml
@@ -6,7 +6,8 @@ leetcode_url: https://leetcode.com/problems/spiral-matrix-ii/
 categories:
   - arrays
 patterns:
-  - matrix-traversal
+  - slug: matrix-traversal
+    is_optimal: true
 
 function_signature: "def generate_matrix(n: int) -> list[list[int]]:"
 
diff --git a/backend/data/questions/spiral-matrix.yaml b/backend/data/questions/spiral-matrix.yaml
index 60abaf3..9a3556a 100644
--- a/backend/data/questions/spiral-matrix.yaml
+++ b/backend/data/questions/spiral-matrix.yaml
@@ -6,7 +6,8 @@ leetcode_url: https://leetcode.com/problems/spiral-matrix/
 categories:
   - arrays
 patterns:
-  - matrix-traversal
+  - slug: matrix-traversal
+    is_optimal: true
 
 function_signature: "def spiral_order(matrix: list[list[int]]) -> list[int]:"
 
diff --git a/backend/data/questions/split-array-largest-sum.yaml b/backend/data/questions/split-array-largest-sum.yaml
index b59e13c..b6cda8e 100644
--- a/backend/data/questions/split-array-largest-sum.yaml
+++ b/backend/data/questions/split-array-largest-sum.yaml
@@ -8,8 +8,10 @@ categories:
   - binary-search
   - dynamic-programming
 patterns:
-  - binary-search
-  - greedy
+  - slug: binary-search
+    is_optimal: true
+  - slug: greedy
+    is_optimal: false
 
 function_signature: "def split_array(nums: list[int], k: int) -> int:"
 
diff --git a/backend/data/questions/sqrtx.yaml b/backend/data/questions/sqrtx.yaml
index de726aa..34082c9 100644
--- a/backend/data/questions/sqrtx.yaml
+++ b/backend/data/questions/sqrtx.yaml
@@ -7,7 +7,8 @@ categories:
   - binary-search
   - math
 patterns:
-  - binary-search
+  - slug: binary-search
+    is_optimal: true
 
 function_signature: "def my_sqrt(x: int) -> int:"
 
diff --git a/backend/data/questions/stone-game-ii.yaml b/backend/data/questions/stone-game-ii.yaml
index d550d88..3751730 100644
--- a/backend/data/questions/stone-game-ii.yaml
+++ b/backend/data/questions/stone-game-ii.yaml
@@ -7,8 +7,10 @@ categories:
   - arrays
   - dynamic-programming
 patterns:
-  - dynamic-programming
-  - prefix-sum
+  - slug: dynamic-programming
+    is_optimal: false
+  - slug: prefix-sum
+    is_optimal: true
 
 function_signature: "def stone_game_ii(piles: list[int]) -> int:"
 
diff --git a/backend/data/questions/stone-game-iii.yaml b/backend/data/questions/stone-game-iii.yaml
index 1933025..68bee80 100644
--- a/backend/data/questions/stone-game-iii.yaml
+++ b/backend/data/questions/stone-game-iii.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - dynamic-programming
 patterns:
-  - dynamic-programming
+  - slug: dynamic-programming
+    is_optimal: true
 
 function_signature: "def stone_game_iii(stone_value: list[int]) -> str:"
 
diff --git a/backend/data/questions/stone-game.yaml b/backend/data/questions/stone-game.yaml
index 77c5d93..7971c2b 100644
--- a/backend/data/questions/stone-game.yaml
+++ b/backend/data/questions/stone-game.yaml
@@ -8,7 +8,8 @@ categories:
   - dynamic-programming
   - math
 patterns:
-  - dynamic-programming
+  - slug: dynamic-programming
+    is_optimal: true
 
 function_signature: "def stone_game(piles: list[int]) -> bool:"
 
diff --git a/backend/data/questions/subarray-product-less-than-k.yaml b/backend/data/questions/subarray-product-less-than-k.yaml
index 91f07e2..74663ca 100644
--- a/backend/data/questions/subarray-product-less-than-k.yaml
+++ b/backend/data/questions/subarray-product-less-than-k.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - two-pointers
 patterns:
-  - sliding-window
+  - slug: sliding-window
+    is_optimal: true
 
 function_signature: "def num_subarray_product_less_than_k(nums: list[int], k: int) -> int:"
 
diff --git a/backend/data/questions/subarray-sum-equals-k.yaml b/backend/data/questions/subarray-sum-equals-k.yaml
index 87d53e4..9d45769 100644
--- a/backend/data/questions/subarray-sum-equals-k.yaml
+++ b/backend/data/questions/subarray-sum-equals-k.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - hash-tables
 patterns:
-  - prefix-sum
+  - slug: prefix-sum
+    is_optimal: true
 
 function_signature: "def subarray_sum(nums: list[int], k: int) -> int:"
 
diff --git a/backend/data/questions/subsets-ii.yaml b/backend/data/questions/subsets-ii.yaml
index ab1e3a9..511e818 100644
--- a/backend/data/questions/subsets-ii.yaml
+++ b/backend/data/questions/subsets-ii.yaml
@@ -8,7 +8,8 @@ categories:
   - sorting
   - recursion
 patterns:
-  - backtracking
+  - slug: backtracking
+    is_optimal: true
 
 function_signature: "def subsets_with_dup(nums: list[int]) -> list[list[int]]:"
 
diff --git a/backend/data/questions/subsets.yaml b/backend/data/questions/subsets.yaml
index d710dd0..03e8ffa 100644
--- a/backend/data/questions/subsets.yaml
+++ b/backend/data/questions/subsets.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - recursion
 patterns:
-  - backtracking
+  - slug: backtracking
+    is_optimal: true
 
 function_signature: "def subsets(nums: list[int]) -> list[list[int]]:"
 
diff --git a/backend/data/questions/subtree-of-another-tree.yaml b/backend/data/questions/subtree-of-another-tree.yaml
index 01ab7a0..3dceb5a 100644
--- a/backend/data/questions/subtree-of-another-tree.yaml
+++ b/backend/data/questions/subtree-of-another-tree.yaml
@@ -7,8 +7,10 @@ categories:
   - trees
   - recursion
 patterns:
-  - dfs
-  - tree-traversal
+  - slug: dfs
+    is_optimal: true
+  - slug: tree-traversal
+    is_optimal: false
 
 function_signature: "def is_subtree(root: TreeNode | None, sub_root: TreeNode | None) -> bool:"
 
diff --git a/backend/data/questions/sum-of-two-integers.yaml b/backend/data/questions/sum-of-two-integers.yaml
index 40e5122..0b6275a 100644
--- a/backend/data/questions/sum-of-two-integers.yaml
+++ b/backend/data/questions/sum-of-two-integers.yaml
@@ -6,7 +6,8 @@ leetcode_url: https://leetcode.com/problems/sum-of-two-integers/
 categories:
   - math
 patterns:
-  - greedy
+  - slug: bit-manipulation
+    is_optimal: true
 
 function_signature: "def get_sum(a: int, b: int) -> int:"
 
diff --git a/backend/data/questions/surrounded-regions.yaml b/backend/data/questions/surrounded-regions.yaml
index c3c4427..5bcb8a8 100644
--- a/backend/data/questions/surrounded-regions.yaml
+++ b/backend/data/questions/surrounded-regions.yaml
@@ -7,9 +7,12 @@ categories:
   - graphs
   - arrays
 patterns:
-  - dfs
-  - bfs
-  - matrix-traversal
+  - slug: dfs
+    is_optimal: false
+  - slug: bfs
+    is_optimal: true
+  - slug: matrix-traversal
+    is_optimal: false
 
 function_signature: "def solve(board: list[list[str]]) -> None:"
 
diff --git a/backend/data/questions/swim-in-rising-water.yaml b/backend/data/questions/swim-in-rising-water.yaml
index 79d1d6e..839ed2f 100644
--- a/backend/data/questions/swim-in-rising-water.yaml
+++ b/backend/data/questions/swim-in-rising-water.yaml
@@ -8,9 +8,12 @@ categories:
   - binary-search
   - heap
 patterns:
-  - binary-search
-  - bfs
-  - heap
+  - slug: heap
+    is_optimal: true
+  - slug: binary-search
+    is_optimal: false
+  - slug: bfs
+    is_optimal: false
 
 function_signature: "def swim_in_water(grid: list[list[int]]) -> int:"
 
diff --git a/backend/data/questions/target-sum.yaml b/backend/data/questions/target-sum.yaml
index c52b044..59e383b 100644
--- a/backend/data/questions/target-sum.yaml
+++ b/backend/data/questions/target-sum.yaml
@@ -7,8 +7,10 @@ categories:
   - arrays
   - dynamic-programming
 patterns:
-  - dynamic-programming
-  - backtracking
+  - slug: dynamic-programming
+    is_optimal: true
+  - slug: backtracking
+    is_optimal: false
 
 function_signature: "def find_target_sum_ways(nums: list[int], target: int) -> int:"
 
diff --git a/backend/data/questions/task-scheduler.yaml b/backend/data/questions/task-scheduler.yaml
index c6e9733..fb6bc83 100644
--- a/backend/data/questions/task-scheduler.yaml
+++ b/backend/data/questions/task-scheduler.yaml
@@ -8,8 +8,10 @@ categories:
   - hash-tables
   - heap
 patterns:
-  - greedy
-  - heap
+  - slug: greedy
+    is_optimal: true
+  - slug: heap
+    is_optimal: false
 
 function_signature: "def least_interval(tasks: list[str], n: int) -> int:"
 
@@ -153,6 +155,30 @@ explanation:
   time_complexity: "O(n). We iterate through the tasks once to count frequencies, then compute the result in constant time."
   space_complexity: "O(1). We use a fixed-size counter (at most 26 letters), which is constant regardless of input size."
 
+  pattern_comparison: |
+    **Math Formula vs Heap Simulation: Why Greedy Wins**
+
+    Both approaches produce correct answers, but with vastly different performance:
+
+    | Approach | Time | Space | Complexity |
+    |----------|------|-------|------------|
+    | **Greedy (Math)** | O(n) | O(1) | Simple counting + formula |
+    | **Heap Simulation** | O(n × m) | O(26) | Simulates actual schedule |
+
+    Where `n` = number of tasks and `m` = cooldown period.
+
+    **Why the math formula is superior:**
+    - **Insight over simulation**: The formula captures the *essence* of the problem — the most frequent task dictates the schedule structure
+    - **Constant-time calculation**: After counting (O(n)), the formula runs in O(1)
+    - **No edge cases in execution**: The heap simulation has tricky termination conditions
+
+    **When Heap Simulation is useful:**
+    - When you need the **actual schedule** (not just the count)
+    - For variations where the greedy insight doesn't apply (e.g., task dependencies)
+    - As a verification tool to validate your math solution
+
+    **Interview strategy**: Mention both approaches. The math solution shows algorithmic insight; the heap shows you can handle complex state. Start with heap if unsure, optimise to math if time permits.
+
 solutions:
   - approach_name: Greedy (Math Formula)
     is_optimal: true
diff --git a/backend/data/questions/three-sum-closest.yaml b/backend/data/questions/three-sum-closest.yaml
index 3c86fb2..d695823 100644
--- a/backend/data/questions/three-sum-closest.yaml
+++ b/backend/data/questions/three-sum-closest.yaml
@@ -8,7 +8,8 @@ categories:
   - two-pointers
   - sorting
 patterns:
-  - two-pointers
+  - slug: two-pointers
+    is_optimal: true
 
 function_signature: "def three_sum_closest(nums: list[int], target: int) -> int:"
 
diff --git a/backend/data/questions/three-sum.yaml b/backend/data/questions/three-sum.yaml
index ea874ad..3d655a4 100644
--- a/backend/data/questions/three-sum.yaml
+++ b/backend/data/questions/three-sum.yaml
@@ -8,7 +8,8 @@ categories:
   - two-pointers
   - sorting
 patterns:
-  - two-pointers
+  - slug: two-pointers
+    is_optimal: true
 
 function_signature: "def three_sum(nums: list[int]) -> list[list[int]]:"
 
diff --git a/backend/data/questions/top-k-frequent-elements.yaml b/backend/data/questions/top-k-frequent-elements.yaml
index e1f3aa6..3054017 100644
--- a/backend/data/questions/top-k-frequent-elements.yaml
+++ b/backend/data/questions/top-k-frequent-elements.yaml
@@ -9,7 +9,8 @@ categories:
   - heap
   - sorting
 patterns:
-  - heap
+  - slug: counting-sort
+    is_optimal: true
 
 function_signature: "def top_k_frequent(nums: list[int], k: int) -> list[int]:"
 
@@ -133,6 +134,27 @@ explanation:
   time_complexity: "O(n). We make one pass to count frequencies and one pass to fill and traverse buckets."
   space_complexity: "O(n). We use a hash map for counts and an array of buckets, both proportional to the input size."
 
+  pattern_comparison: |
+    **Bucket Sort vs Heap: Which Pattern Wins?**
+
+    Both patterns solve this problem correctly, but with different trade-offs:
+
+    | Approach | Time | Space | When to Use |
+    |----------|------|-------|-------------|
+    | **Bucket Sort** | O(n) | O(n) | When frequencies are bounded (always true here since max freq ≤ n) |
+    | **Min Heap** | O(n log k) | O(n) | When k is much smaller than n, or for streaming data |
+    | **Sorting** | O(n log n) | O(n) | Simplest to implement, but doesn't meet the follow-up requirement |
+
+    **Why Bucket Sort is optimal here:**
+    - Frequencies are naturally bounded by array length — if you have `n` elements, the maximum frequency is `n`
+    - This bounded range lets us use the frequency as a direct array index, avoiding comparison-based sorting entirely
+    - We achieve O(n) time by exploiting the problem's structure
+
+    **When to prefer Heap:**
+    - Streaming scenarios where you don't know all elements upfront
+    - When `k << n` (the O(log k) factor becomes negligible)
+    - When you need to support dynamic updates (adding/removing elements)
+
 solutions:
   - approach_name: Bucket Sort
     is_optimal: true
diff --git a/backend/data/questions/transpose-matrix.yaml b/backend/data/questions/transpose-matrix.yaml
index d87e393..89c57d2 100644
--- a/backend/data/questions/transpose-matrix.yaml
+++ b/backend/data/questions/transpose-matrix.yaml
@@ -6,7 +6,8 @@ leetcode_url: https://leetcode.com/problems/transpose-matrix/
 categories:
   - arrays
 patterns:
-  - matrix-traversal
+  - slug: matrix-traversal
+    is_optimal: true
 
 function_signature: "def transpose(matrix: list[list[int]]) -> list[list[int]]:"
 
diff --git a/backend/data/questions/trapping-rain-water.yaml b/backend/data/questions/trapping-rain-water.yaml
index 1241b2c..4f4acaf 100644
--- a/backend/data/questions/trapping-rain-water.yaml
+++ b/backend/data/questions/trapping-rain-water.yaml
@@ -8,8 +8,10 @@ categories:
   - two-pointers
   - stack
 patterns:
-  - two-pointers
-  - monotonic-stack
+  - slug: two-pointers
+    is_optimal: false
+  - slug: monotonic-stack
+    is_optimal: true
 
 function_signature: "def trap(height: list[int]) -> int:"
 
diff --git a/backend/data/questions/two-sum.yaml b/backend/data/questions/two-sum.yaml
index 5d752eb..d5d666d 100644
--- a/backend/data/questions/two-sum.yaml
+++ b/backend/data/questions/two-sum.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - hash-tables
 patterns:
-  - two-pointers
+  - slug: hashing
+    is_optimal: true
 
 function_signature: "def two_sum(nums: list[int], target: int) -> list[int]:"
 
@@ -135,6 +136,34 @@ explanation:
   time_complexity: "O(n). We traverse the array once, and each hash map lookup/insert is O(1) on average."
   space_complexity: "O(n). In the worst case, we store all n elements in the hash map before finding a match (e.g., when the solution is the last two elements)."
 
+  pattern_comparison: |
+    **Hash Map vs Two Pointers: Different Problems, Different Patterns**
+
+    Two Sum is often confused with sorted-array two-pointer problems, but they require different approaches:
+
+    | Approach | Time | Space | Requires Sorted Input? | Returns |
+    |----------|------|-------|------------------------|---------|
+    | **Hash Map** | O(n) | O(n) | No | Original indices |
+    | **Two Pointers** | O(n) | O(1) | Yes | Values or sorted indices |
+    | **Brute Force** | O(n²) | O(1) | No | Indices |
+
+    **Why Hash Map is optimal for this problem:**
+    - We need **original indices**, not just values
+    - Sorting would lose index information (or require O(n) extra space to track)
+    - Hash map gives O(1) lookup while preserving indices naturally
+
+    **When Two Pointers would apply:**
+    - If the array is already sorted
+    - If we only need to find the values (not indices)
+    - In space-constrained environments where O(n) extra space is prohibitive
+
+    **The Two Sum pattern family:**
+    - **Two Sum** (unsorted): Hash map for complement lookup
+    - **Two Sum II** (sorted): Two pointers from both ends
+    - **3Sum/4Sum**: Sort + Two pointers (indices don't matter)
+
+    Remember: The right pattern depends on what the problem asks for and what guarantees you have about the input.
+
 solutions:
   - approach_name: One-Pass Hash Map
     is_optimal: true
diff --git a/backend/data/questions/unique-number-of-occurrences.yaml b/backend/data/questions/unique-number-of-occurrences.yaml
index d826899..9a6a7d3 100644
--- a/backend/data/questions/unique-number-of-occurrences.yaml
+++ b/backend/data/questions/unique-number-of-occurrences.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - hash-tables
 patterns:
-  - prefix-sum
+  - slug: hashing
+    is_optimal: true
 
 function_signature: "def unique_occurrences(arr: list[int]) -> bool:"
 
diff --git a/backend/data/questions/unique-paths-ii.yaml b/backend/data/questions/unique-paths-ii.yaml
index 5604f34..cf92867 100644
--- a/backend/data/questions/unique-paths-ii.yaml
+++ b/backend/data/questions/unique-paths-ii.yaml
@@ -7,8 +7,10 @@ categories:
   - arrays
   - dynamic-programming
 patterns:
-  - dynamic-programming
-  - matrix-traversal
+  - slug: dynamic-programming
+    is_optimal: false
+  - slug: matrix-traversal
+    is_optimal: true
 
 function_signature: "def unique_paths_with_obstacles(obstacle_grid: list[list[int]]) -> int:"
 
diff --git a/backend/data/questions/unique-paths.yaml b/backend/data/questions/unique-paths.yaml
index 4ddf55e..e368b17 100644
--- a/backend/data/questions/unique-paths.yaml
+++ b/backend/data/questions/unique-paths.yaml
@@ -8,7 +8,8 @@ categories:
   - dynamic-programming
   - math
 patterns:
-  - dynamic-programming
+  - slug: dynamic-programming
+    is_optimal: true
 
 function_signature: "def unique_paths(m: int, n: int) -> int:"
 
diff --git a/backend/data/questions/valid-anagram.yaml b/backend/data/questions/valid-anagram.yaml
index 75510b6..0606e87 100644
--- a/backend/data/questions/valid-anagram.yaml
+++ b/backend/data/questions/valid-anagram.yaml
@@ -8,7 +8,8 @@ categories:
   - hash-tables
   - sorting
 patterns:
-  - prefix-sum
+  - slug: hashing
+    is_optimal: true
 
 function_signature: "def is_anagram(s: str, t: str) -> bool:"
 
@@ -123,6 +124,35 @@ explanation:
   time_complexity: "O(n). We iterate through both strings once, where `n` is the length of the strings."
   space_complexity: "O(1). We use a fixed-size array of 26 integers, regardless of input size. This is technically O(26) = O(1) constant space."
 
+  pattern_comparison: |
+    **Counting Array vs Hash Map vs Sorting: Choose Your Weapon**
+
+    Three valid approaches with different trade-offs:
+
+    | Approach | Time | Space | Best For |
+    |----------|------|-------|----------|
+    | **Counting Array** | O(n) | O(1) | Fixed character set (a-z, A-Z) |
+    | **Hash Map (Counter)** | O(n) | O(k) | Unicode, variable character sets |
+    | **Sorting** | O(n log n) | O(n) | Simplest code, small inputs |
+
+    **Why Counting Array wins here:**
+    - The problem guarantees lowercase English letters only (26 characters)
+    - Array indexing (`ord(c) - ord('a')`) is faster than hash function computation
+    - Memory layout is contiguous and cache-friendly
+    - True O(1) space since array size is constant
+
+    **When to use Hash Map instead:**
+    - Unicode strings with unpredictable character sets
+    - When the follow-up asks "What if inputs contain Unicode characters?"
+    - When readability matters more than micro-optimisation
+
+    **When Sorting is acceptable:**
+    - Quick prototyping or one-off scripts
+    - When you need the sorted strings for other purposes
+    - For very short strings where the O(n log n) factor is negligible
+
+    **Interview tip**: Start with the array approach for the O(1) space, then mention the Counter approach as a "cleaner but slightly slower alternative."
+
 solutions:
   - approach_name: Character Frequency Count
     is_optimal: true
diff --git a/backend/data/questions/valid-palindrome-ii.yaml b/backend/data/questions/valid-palindrome-ii.yaml
index e4864c9..cab7ab7 100644
--- a/backend/data/questions/valid-palindrome-ii.yaml
+++ b/backend/data/questions/valid-palindrome-ii.yaml
@@ -7,7 +7,8 @@ categories:
   - strings
   - two-pointers
 patterns:
-  - two-pointers
+  - slug: two-pointers
+    is_optimal: true
 
 function_signature: "def valid_palindrome(s: str) -> bool:"
 
diff --git a/backend/data/questions/valid-palindrome.yaml b/backend/data/questions/valid-palindrome.yaml
index 6f9398f..b81d61c 100644
--- a/backend/data/questions/valid-palindrome.yaml
+++ b/backend/data/questions/valid-palindrome.yaml
@@ -7,7 +7,8 @@ categories:
   - strings
   - two-pointers
 patterns:
-  - two-pointers
+  - slug: two-pointers
+    is_optimal: true
 
 function_signature: "def is_palindrome(s: str) -> bool:"
 
diff --git a/backend/data/questions/valid-parentheses.yaml b/backend/data/questions/valid-parentheses.yaml
index 04e5d27..9208149 100644
--- a/backend/data/questions/valid-parentheses.yaml
+++ b/backend/data/questions/valid-parentheses.yaml
@@ -7,7 +7,8 @@ categories:
   - strings
   - stack
 patterns:
-  - monotonic-stack
+  - slug: monotonic-stack
+    is_optimal: true
 
 function_signature: "def is_valid(s: str) -> bool:"
 
diff --git a/backend/data/questions/valid-parenthesis-string.yaml b/backend/data/questions/valid-parenthesis-string.yaml
index 72185a4..d420581 100644
--- a/backend/data/questions/valid-parenthesis-string.yaml
+++ b/backend/data/questions/valid-parenthesis-string.yaml
@@ -8,8 +8,10 @@ categories:
   - stack
   - dynamic-programming
 patterns:
-  - greedy
-  - dynamic-programming
+  - slug: greedy
+    is_optimal: true
+  - slug: dynamic-programming
+    is_optimal: false
 
 function_signature: "def check_valid_string(s: str) -> bool:"
 
diff --git a/backend/data/questions/valid-sudoku.yaml b/backend/data/questions/valid-sudoku.yaml
index dfb0db8..30ffadb 100644
--- a/backend/data/questions/valid-sudoku.yaml
+++ b/backend/data/questions/valid-sudoku.yaml
@@ -7,7 +7,8 @@ categories:
   - arrays
   - hash-tables
 patterns:
-  - matrix-traversal
+  - slug: matrix-traversal
+    is_optimal: true
 
 function_signature: "def is_valid_sudoku(board: list[list[str]]) -> bool:"
 
diff --git a/backend/data/questions/validate-binary-search-tree.yaml b/backend/data/questions/validate-binary-search-tree.yaml
index a4198f7..4b70166 100644
--- a/backend/data/questions/validate-binary-search-tree.yaml
+++ b/backend/data/questions/validate-binary-search-tree.yaml
@@ -7,8 +7,10 @@ categories:
   - trees
   - recursion
 patterns:
-  - dfs
-  - tree-traversal
+  - slug: dfs
+    is_optimal: true
+  - slug: tree-traversal
+    is_optimal: false
 
 function_signature: "def is_valid_bst(root: TreeNode | None) -> bool:"
 
diff --git a/backend/data/questions/verifying-an-alien-dictionary.yaml b/backend/data/questions/verifying-an-alien-dictionary.yaml
index 1825e47..89bc79d 100644
--- a/backend/data/questions/verifying-an-alien-dictionary.yaml
+++ b/backend/data/questions/verifying-an-alien-dictionary.yaml
@@ -8,7 +8,8 @@ categories:
   - strings
   - hash-tables
 patterns:
-  - two-pointers
+  - slug: two-pointers
+    is_optimal: true
 
 function_signature: "def is_alien_sorted(words: list[str], order: str) -> bool:"
 
diff --git a/backend/data/questions/word-break-ii.yaml b/backend/data/questions/word-break-ii.yaml
index 75c74ac..706b2dd 100644
--- a/backend/data/questions/word-break-ii.yaml
+++ b/backend/data/questions/word-break-ii.yaml
@@ -8,8 +8,10 @@ categories:
   - dynamic-programming
   - hash-tables
 patterns:
-  - backtracking
-  - dynamic-programming
+  - slug: backtracking
+    is_optimal: false
+  - slug: dynamic-programming
+    is_optimal: true
 
 function_signature: "def word_break(s: str, word_dict: list[str]) -> list[str]:"
 
diff --git a/backend/data/questions/word-break.yaml b/backend/data/questions/word-break.yaml
index ecf6364..f9e3a33 100644
--- a/backend/data/questions/word-break.yaml
+++ b/backend/data/questions/word-break.yaml
@@ -8,7 +8,8 @@ categories:
   - strings
   - hash-tables
 patterns:
-  - dynamic-programming
+  - slug: dynamic-programming
+    is_optimal: true
 
 function_signature: "def word_break(s: str, word_dict: list[str]) -> bool:"
 
diff --git a/backend/data/questions/word-ladder.yaml b/backend/data/questions/word-ladder.yaml
index 77537e4..516363f 100644
--- a/backend/data/questions/word-ladder.yaml
+++ b/backend/data/questions/word-ladder.yaml
@@ -8,7 +8,8 @@ categories:
   - graphs
   - hash-tables
 patterns:
-  - bfs
+  - slug: bfs
+    is_optimal: true
 
 function_signature: "def ladder_length(begin_word: str, end_word: str, word_list: list[str]) -> int:"
 
diff --git a/backend/data/questions/word-search-ii.yaml b/backend/data/questions/word-search-ii.yaml
index 2ac7180..cfd7b60 100644
--- a/backend/data/questions/word-search-ii.yaml
+++ b/backend/data/questions/word-search-ii.yaml
@@ -8,9 +8,12 @@ categories:
   - strings
   - recursion
 patterns:
-  - trie
-  - backtracking
-  - matrix-traversal
+  - slug: trie
+    is_optimal: true
+  - slug: backtracking
+    is_optimal: false
+  - slug: matrix-traversal
+    is_optimal: false
 
 function_signature: "def find_words(board: list[list[str]], words: list[str]) -> list[str]:"
 
diff --git a/backend/data/questions/word-search.yaml b/backend/data/questions/word-search.yaml
index 1f50a76..861f164 100644
--- a/backend/data/questions/word-search.yaml
+++ b/backend/data/questions/word-search.yaml
@@ -7,8 +7,10 @@ categories:
   - arrays
   - recursion
 patterns:
-  - backtracking
-  - dfs
+  - slug: backtracking
+    is_optimal: false
+  - slug: dfs
+    is_optimal: true
 
 function_signature: "def exist(board: list[list[str]], word: str) -> bool:"