[ { "slug": "advanced/algorithm-engineering", "topic": "Advanced -> Algorithm Engineering", "title": "Robot Path", "url": "https://cses.fi/problemset/task/1742", "source": "CSES", "difficulty": "medium", "tracks": [], "tags": [ "Hashing", "Simulation", "Sets" ], "styles": [ "Implementation" ], "prerequisites": [ "Hash Set", "Coordinate Simulation" ], "bucket": "core", "why_fit": "A small but instructive exercise in robust simulation and state tracking." }, { "slug": "advanced/algorithm-engineering", "topic": "Advanced -> Algorithm Engineering", "title": "Dynamic Values And Maximum Sum", "url": "https://codeforces.com/problemset/problem/2209/F", "source": "Codeforces", "difficulty": "very-hard", "tracks": [], "tags": [ "Tree Process", "State Transitions" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Performance-sensitive tree optimization with many moving parts, ideal for engineering-heavy practice." }, { "slug": "advanced/algorithm-engineering", "topic": "Advanced -> Algorithm Engineering", "title": "Juan's Colorful Tree", "url": "https://codeforces.com/problemset/problem/2155/F", "source": "Codeforces", "difficulty": "very-hard", "tracks": [], "tags": [ "Tree Queries", "Set Intersections", "Hybrid Techniques" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Shows how serious contest solutions often combine several techniques to meet practical limits." }, { "slug": "advanced/algorithm-engineering", "topic": "Advanced -> Algorithm Engineering", "title": "Minimum Difference", "url": "https://codeforces.com/problemset/problem/1476/G", "source": "Codeforces", "difficulty": "very-hard", "tracks": [], "tags": [ "Data Structures", "Query Optimization", "Implementation Detail" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "A good benchmark for fast query processing where constants and representation choices matter." }, { "slug": "advanced/algorithm-engineering", "topic": "Advanced -> Algorithm Engineering", "title": "Query Jungle", "url": "https://codeforces.com/problemset/problem/2152/G", "source": "Codeforces", "difficulty": "very-hard", "tracks": [], "tags": [ "Tree Queries", "Toggle Updates", "Global State Maintenance" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Strong example of designing around query/update bottlenecks rather than just the high-level idea." }, { "slug": "advanced/algorithm-engineering", "topic": "Advanced -> Algorithm Engineering", "title": "Area of Rectangles", "url": "https://cses.fi/problemset/task/1741", "source": "CSES", "difficulty": "hard", "tracks": [], "tags": [ "Coordinate Compression", "Sweep Line", "Interval Coverage" ], "styles": [ "Engineering", "Event Processing" ], "prerequisites": [ "Compression", "Segment Tree Or Fenwick" ], "bucket": "challenge", "why_fit": "Great for practicing fast, memory-conscious sweep-line implementation." }, { "slug": "advanced/algorithm-engineering", "topic": "Advanced -> Algorithm Engineering", "title": "Lines and Queries I", "url": "https://cses.fi/problemset/task/3429", "source": "CSES", "difficulty": "hard", "tracks": [], "tags": [ "Convex Hull Trick", "Data Structures" ], "styles": [ "Online", "Optimized Query Processing" ], "prerequisites": [ "Line Evaluation", "Convex Hull Trick" ], "bucket": "challenge", "why_fit": "Rewards clean data-structure engineering and careful constant-factor control." }, { "slug": "advanced/algorithm-engineering", "topic": "Advanced -> Algorithm Engineering", "title": "Minimum Euclidean Distance", "url": "https://cses.fi/problemset/task/2194", "source": "CSES", "difficulty": "hard", "tracks": [], "tags": [ "Implementation", "Sweep Line", "Closest Pair" ], "styles": [ "Performance Tuning", "Geometric Data Structures" ], "prerequisites": [ "Sorting", "Balanced Search" ], "bucket": "challenge", "why_fit": "A classic example where asymptotics are simple but implementation details matter." }, { "slug": "advanced/approximation-and-relaxation", "topic": "Advanced -> Approximation And Relaxation", "title": "Problem Set 1", "url": "https://www.cs.dartmouth.edu/~deepc/Courses/S15/Problems/prob1.pdf", "source": "Dartmouth EO249", "difficulty": "theory", "tracks": [ "Approximation Algorithms" ], "tags": [ "TSP", "Cycle Cover", "Euler Tour" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Great starter set for approximation constructions around TSP-style problems." }, { "slug": "advanced/approximation-and-relaxation", "topic": "Advanced -> Approximation And Relaxation", "title": "Problem Set 2", "url": "https://www.cs.dartmouth.edu/~deepc/Courses/S15/Problems/prob2.pdf", "source": "Dartmouth EO249", "difficulty": "theory", "tracks": [ "Approximation Algorithms" ], "tags": [ "Set Cover", "Submodular", "Greedy Approximation" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Covers several core greedy-approximation paradigms in one assignment." }, { "slug": "advanced/approximation-and-relaxation", "topic": "Advanced -> Approximation And Relaxation", "title": "Problem Set 4", "url": "https://www.cs.dartmouth.edu/~deepc/Courses/S15/Problems/prob4.pdf", "source": "Dartmouth EO249", "difficulty": "theory", "tracks": [ "Approximation Algorithms" ], "tags": [ "Facility Location", "Integrality Gap", "LP Relaxation" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Strong LP-gap and approximation-ratio practice." }, { "slug": "advanced/approximation-and-relaxation", "topic": "Advanced -> Approximation And Relaxation", "title": "Problem Set 5", "url": "https://www.cs.dartmouth.edu/~deepc/Courses/S15/Problems/prob5.pdf", "source": "Dartmouth EO249", "difficulty": "theory", "tracks": [ "Approximation Algorithms" ], "tags": [ "Knapsack PTAS", "Iterated Rounding", "Laminar Families" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "A particularly rich set on relaxation, rounding, and structure in approximation." }, { "slug": "advanced/approximation-and-relaxation", "topic": "Advanced -> Approximation And Relaxation", "title": "Problem Set 6", "url": "https://www.cs.dartmouth.edu/~deepc/Courses/S17/Problems/ps6.pdf", "source": "Dartmouth CS 49/149", "difficulty": "theory", "tracks": [ "Approximation Algorithms" ], "tags": [ "Duality", "Randomized Rounding", "LP" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Excellent follow-up for duality and randomized-rounding based approximation design." }, { "slug": "advanced/complexity-and-hardness", "topic": "Advanced -> Complexity And Hardness", "title": "Problem Set 0", "url": "https://people.seas.harvard.edu/~salil/cs221/spring10/PS0.pdf", "source": "Harvard CS221", "difficulty": "theory", "tracks": [], "tags": [ "Search Vs Decision", "Reductions", "Complexity Classes" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "A clean course-quality entry point for formal complexity reasoning." }, { "slug": "advanced/complexity-and-hardness", "topic": "Advanced -> Complexity And Hardness", "title": "Problem Set 1", "url": "https://people.seas.harvard.edu/~salil/cs221/spring10/PS1.pdf", "source": "Harvard CS221", "difficulty": "theory", "tracks": [], "tags": [ "P-Completeness", "Circuit Complexity", "Factoring" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Covers several central reductions and class-separation themes in one place." }, { "slug": "advanced/complexity-and-hardness", "topic": "Advanced -> Complexity And Hardness", "title": "Problem Set 3", "url": "https://people.seas.harvard.edu/~salil/cs221/spring10/PS3.pdf", "source": "Harvard CS221", "difficulty": "theory", "tracks": [], "tags": [ "PSPACE", "Branching Programs", "Circuit Lower Bounds" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Very good practice for moving between models of computation." }, { "slug": "advanced/complexity-and-hardness", "topic": "Advanced -> Complexity And Hardness", "title": "Problem Set 4", "url": "https://people.seas.harvard.edu/~salil/cs221/spring10/PS4.pdf", "source": "Harvard CS221", "difficulty": "theory", "tracks": [], "tags": [ "Promise Problems", "#P", "Approximation Hardness" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Bridges exact complexity language with counting and approximation hardness." }, { "slug": "advanced/complexity-and-hardness", "topic": "Advanced -> Complexity And Hardness", "title": "Problem Set 6", "url": "https://people.seas.harvard.edu/~salil/cs221/spring10/PS6.pdf", "source": "Harvard CS221", "difficulty": "theory", "tracks": [], "tags": [ "PCP", "Property Testing", "Hardness Of Approximation" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "A strong advanced capstone on implications, PCPs, and testing/hardness themes." }, { "slug": "advanced/constructive", "topic": "Advanced -> Constructive", "title": "Same Parity Summands", "url": "https://codeforces.com/problemset/problem/1352/B", "source": "Codeforces", "difficulty": "easy", "tracks": [], "tags": [ "Math" ], "styles": [ "Construction" ], "prerequisites": [ "Parity" ], "bucket": "core", "why_fit": "Simple but very clean constructive decomposition logic." }, { "slug": "advanced/constructive", "topic": "Advanced -> Constructive", "title": "Snow Walking Robot", "url": "https://codeforces.com/problemset/problem/1272/B", "source": "Codeforces", "difficulty": "easy", "tracks": [], "tags": [ "Paths", "Grid" ], "styles": [ "Path Construction" ], "prerequisites": [ "Grid Moves", "Cancellation" ], "bucket": "core", "why_fit": "A short constructive path-building problem with neat cancellation ideas." }, { "slug": "advanced/constructive", "topic": "Advanced -> Constructive", "title": "A-B Palindrome", "url": "https://codeforces.com/problemset/problem/1512/C", "source": "Codeforces", "difficulty": "medium", "tracks": [], "tags": [ "Palindrome" ], "styles": [ "Construction" ], "prerequisites": [ "Symmetry Reasoning" ], "bucket": "core", "why_fit": "A standard constructive palindrome filling task." }, { "slug": "advanced/constructive", "topic": "Advanced -> Constructive", "title": "Build the Permutation", "url": "https://codeforces.com/problemset/problem/1608/B", "source": "Codeforces", "difficulty": "medium", "tracks": [], "tags": [ "Permutations" ], "styles": [ "Greedy Construction" ], "prerequisites": [ "Permutations", "Greedy Placement" ], "bucket": "core", "why_fit": "Build-a-valid-structure problems are exactly the constructive sweet spot." }, { "slug": "advanced/constructive", "topic": "Advanced -> Constructive", "title": "Corrupted Array", "url": "https://codeforces.com/problemset/problem/1512/D", "source": "Codeforces", "difficulty": "medium", "tracks": [], "tags": [ "Arrays" ], "styles": [ "Reconstruction" ], "prerequisites": [ "Sorting", "Multiset Reasoning" ], "bucket": "core", "why_fit": "A good example of reconstructing hidden structure from noisy data." }, { "slug": "advanced/constructive", "topic": "Advanced -> Constructive", "title": "Beautiful Tree", "url": "https://codeforces.com/problemset/problem/2162/G", "source": "Codeforces", "difficulty": "hard", "tracks": [], "tags": [ "Tree Construction", "Number Theory", "Perfect Square" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Shows how a constructive proof can be turned into a valid graph output under strong arithmetic constraints." }, { "slug": "advanced/constructive", "topic": "Advanced -> Constructive", "title": "Multiples and Power Differences", "url": "https://codeforces.com/problemset/problem/1485/D", "source": "Codeforces", "difficulty": "hard", "tracks": [], "tags": [ "Matrix Construction", "Number Theory", "Invariants" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Classic constructive use of a hidden invariant to force the judge-accepted structure." }, { "slug": "advanced/constructive", "topic": "Advanced -> Constructive", "title": "Nezzar and Nice Beatmap", "url": "https://codeforces.com/problemset/problem/1477/C", "source": "Codeforces", "difficulty": "hard", "tracks": [], "tags": [ "Ordering", "Geometry", "Greedy Construction" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Representative output-construction problem where the hard part is discovering the structure, not maintaining data." }, { "slug": "advanced/constructive", "topic": "Advanced -> Constructive", "title": "Strange Housing", "url": "https://codeforces.com/problemset/problem/1470/D", "source": "Codeforces", "difficulty": "hard", "tracks": [], "tags": [ "Graph Construction", "DFS" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Good example of mixing traversal with a constructive certificate." }, { "slug": "advanced/constructive", "topic": "Advanced -> Constructive", "title": "Cycle Closing", "url": "https://codeforces.com/problemset/problem/2150/F", "source": "Codeforces", "difficulty": "very-hard", "tracks": [], "tags": [ "Graph Operations", "Shortest Paths", "Tree Structure" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "A high-end constructive problem where the implementation follows a delicate existence argument." }, { "slug": "advanced/contest-engineering", "topic": "Advanced -> Contest Engineering", "title": "Hidden Integer", "url": "https://cses.fi/problemset/task/3112", "source": "CSES", "difficulty": "easy-medium", "tracks": [ "Interactive" ], "tags": [ "Binary Search", "Query Budget", "Flushing" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Excellent first interactive problem for disciplined I/O and query budgeting." }, { "slug": "advanced/contest-engineering", "topic": "Advanced -> Contest Engineering", "title": "Colored Chairs", "url": "https://cses.fi/problemset/task/3273", "source": "CSES", "difficulty": "medium", "tracks": [ "Interactive" ], "tags": [ "Parity", "Binary Search", "Query Budget" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Small-query interactive problem that trains calm invariant tracking." }, { "slug": "advanced/contest-engineering", "topic": "Advanced -> Contest Engineering", "title": "Hidden Permutation", "url": "https://cses.fi/problemset/task/3139", "source": "CSES", "difficulty": "medium", "tracks": [ "Interactive" ], "tags": [ "Comparison Oracle", "Reconstruction", "Query Strategy" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "A clean interactive reconstruction problem that trains protocol handling and comparison-based strategy." }, { "slug": "advanced/contest-engineering", "topic": "Advanced -> Contest Engineering", "title": "K-th Highest Score", "url": "https://cses.fi/problemset/task/3305", "source": "CSES", "difficulty": "medium", "tracks": [ "Interactive" ], "tags": [ "Merge Logic", "Query Strategy", "Two Sorted Sources" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Good practice for interactive strategy design under a global query cap." }, { "slug": "advanced/contest-engineering", "topic": "Advanced -> Contest Engineering", "title": "Permuted Binary Strings", "url": "https://cses.fi/problemset/task/3228", "source": "CSES", "difficulty": "medium", "tracks": [ "Interactive" ], "tags": [ "Bit Probing", "Reconstruction", "Query Design" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "A reconstruction problem that rewards careful experiment design." }, { "slug": "advanced/contest-engineering", "topic": "Advanced -> Contest Engineering", "title": "Inversion Sorting", "url": "https://cses.fi/problemset/task/3140", "source": "CSES", "difficulty": "hard", "tracks": [ "Interactive" ], "tags": [ "Sorting By Feedback", "Adaptive Strategy", "Interaction Protocol" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Great later-stage interactive practice where the judge feedback is indirect." }, { "slug": "advanced/gradient-descent", "topic": "Advanced -> Gradient Descent", "title": "Linear Regression Gradient Descent Benchmark", "url": "https://cs229.stanford.edu/summer2020/cs229-notes1.pdf", "source": "Stanford CS229", "difficulty": "theory", "tracks": [ "Smooth Optimization" ], "tags": [ "Linear Regression", "Squared Loss", "Learning Rate" ], "styles": [ "Theory Benchmark", "Deterministic Update Rule" ], "prerequisites": [ "Affine Models", "Derivatives", "Basic Algebra" ], "bucket": "core", "why_fit": "The cleanest first gradient-descent benchmark for this repo because one affine model and one smooth loss make the update rule completely explicit without pretending to cover modern optimizer families." }, { "slug": "advanced/gradient-descent", "topic": "Advanced -> Gradient Descent", "title": "Gradient descent", "url": "https://openlearninglibrary.mit.edu/courses/course-v1%3AMITx%2B6.036%2B1T2019/courseware/Week4/gradient_descent/", "source": "MIT Open Learning Library", "difficulty": "theory", "tracks": [ "Further Theory" ], "tags": [ "Convexity", "Step Size", "Convergence", "Optimization" ], "styles": [ "Course Notes", "Theory Breadth" ], "prerequisites": [ "Gradient", "Learning Rate" ], "bucket": "stretch", "why_fit": "A good follow-up once the repo benchmark is clear and you want broader smooth-optimization intuition without widening the lane into full numerical optimization coverage." }, { "slug": "advanced/machine-learning-algorithms", "topic": "Advanced -> Machine Learning Algorithms", "title": "Perceptron Classification Benchmark", "url": "https://cs229.stanford.edu/notes2021fall/cs229-notes6.pdf", "source": "Stanford CS229", "difficulty": "theory", "tracks": [ "Machine Learning", "Perceptron" ], "tags": [ "Binary Classification", "Linear Separability", "Mistake-Driven Update" ], "styles": [ "Theory Benchmark", "Online Update Rule" ], "prerequisites": [ "Dot Product", "Signs And Margins", "Basic Online Updates" ], "bucket": "core", "why_fit": "The cleanest first algorithmic ML benchmark for this repo because the update rule is tiny, explicit, and honest about the separability boundary." }, { "slug": "advanced/machine-learning-algorithms", "topic": "Advanced -> Machine Learning Algorithms", "title": "Perceptron, convergence, and generalization", "url": "https://ocw.mit.edu/courses/6-867-machine-learning-fall-2006/resources/lec2/", "source": "MIT OCW 6.867", "difficulty": "theory", "tracks": [ "Machine Learning", "Margins" ], "tags": [ "Perceptron", "Convergence", "Generalization" ], "styles": [ "Lecture Notes", "Theory Breadth" ], "prerequisites": [ "Perceptron", "Linear Separability" ], "bucket": "stretch", "why_fit": "A strong follow-up once the repo benchmark is clear and you want the surrounding theory without widening the lane into full modern ML." }, { "slug": "advanced/matroid-intersection", "topic": "Advanced -> Matroid Intersection", "title": "Pick Your Own Nim", "url": "https://codeforces.com/gym/102156/problem/D", "source": "Codeforces Gym", "difficulty": "very-hard", "tracks": [ "Optimization" ], "tags": [ "Partition Matroid", "Linear Matroid", "XOR Basis" ], "styles": [ "Modeling", "Augmenting Path", "Theory-Heavy" ], "prerequisites": [ "XOR Basis", "Matching", "Optimization And Duality" ], "bucket": "core", "why_fit": "A clean contest anchor where one choice per box forms a partition matroid and the xor-independence condition forms a linear matroid relative to Alice's fixed heaps." }, { "slug": "advanced/meet-in-the-middle", "topic": "Advanced -> Meet-In-The-Middle", "title": "Meet in the Middle", "url": "https://cses.fi/problemset/task/1628", "source": "CSES", "difficulty": "medium-hard", "tracks": [ "Mitm" ], "tags": [ "Subset-Sum", "Counting" ], "styles": [ "Exact Search", "Sort-And-Merge" ], "prerequisites": [ "Subset Enumeration", "Binary Search" ], "bucket": "core", "why_fit": "The cleanest internal anchor for the classic half-sum enumeration route." }, { "slug": "advanced/meet-in-the-middle", "topic": "Advanced -> Meet-In-The-Middle", "title": "Programming Contest", "url": "https://atcoder.jp/contests/abc184/tasks/abc184_f", "source": "AtCoder", "difficulty": "medium-hard", "tracks": [ "Mitm" ], "tags": [ "Best-Feasible-Sum", "Binary Search" ], "styles": [ "Exact Search", "Optimization" ], "prerequisites": [ "Subset Enumeration", "Binary Search" ], "bucket": "core", "why_fit": "A standard best-sum-no-more-than-S route where the merge is about best feasible complement rather than multiplicity." }, { "slug": "advanced/meet-in-the-middle", "topic": "Advanced -> Meet-In-The-Middle", "title": "SUBSUMS", "url": "https://www.spoj.com/problems/SUBSUMS/", "source": "SPOJ", "difficulty": "medium-hard", "tracks": [ "Mitm" ], "tags": [ "Subset-Sum", "Range Counting" ], "styles": [ "Exact Search", "Counting" ], "prerequisites": [ "Subset Enumeration", "Sorting" ], "bucket": "classic", "why_fit": "A classic SPOJ benchmark for half-sum generation with a counting-flavored merge." }, { "slug": "advanced/online-algorithms", "topic": "Advanced -> Online Algorithms", "title": "Ski Rental Benchmark", "url": "https://www.cs.jhu.edu/~mdinitz/classes/IntroAlgorithms/Fall2021/Lectures/Lecture24/lecture24slides.pdf", "source": "JHU Intro Algorithms", "difficulty": "theory", "tracks": [ "Competitive Analysis" ], "tags": [ "Ski Rental", "Competitive Ratio", "Threshold Policy", "Adversarial Future" ], "styles": [ "Competitive Analysis", "Theory Benchmark" ], "prerequisites": [ "Threshold Reasoning", "Offline Optimum", "Adversarial Analysis" ], "bucket": "core", "why_fit": "The canonical first online-algorithms benchmark where the whole lesson is to compare one deterministic threshold policy against the offline optimum." }, { "slug": "advanced/online-algorithms", "topic": "Advanced -> Online Algorithms", "title": "Online Algorithms Notes: Ski Rental and Paging", "url": "https://web.stanford.edu/class/cs369/files/cs369-notes.pdf", "source": "Stanford CS369", "difficulty": "theory", "tracks": [ "Paging", "Randomized Compare" ], "tags": [ "Competitive Ratio", "Randomized Adversary", "List Update" ], "styles": [ "Lecture Notes", "Theory Breadth" ], "prerequisites": [ "Ski Rental", "Competitive Ratio", "Basic Randomized Algorithms" ], "bucket": "stretch", "why_fit": "A clean follow-up once ski rental clicks and you want the next canonical online examples plus the randomized paging contrast." }, { "slug": "advanced/optimization-and-duality", "topic": "Advanced -> Optimization And Duality", "title": "Giant Pizza", "url": "https://cses.fi/problemset/task/1684", "source": "CSES", "difficulty": "medium", "tracks": [], "tags": [ "2-SAT", "Constraint Satisfaction" ], "styles": [ "Logical Modeling" ], "prerequisites": [ "2-SAT", "Implication Graphs" ], "bucket": "core", "why_fit": "A good example of optimizing by encoding constraints into a solvable dual structure." }, { "slug": "advanced/optimization-and-duality", "topic": "Advanced -> Optimization And Duality", "title": "Police Chase", "url": "https://cses.fi/problemset/task/1695", "source": "CSES", "difficulty": "medium", "tracks": [], "tags": [ "Minimum Cut", "Certificate", "Flow Dual" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Makes the cut side of flow duality explicit." }, { "slug": "advanced/optimization-and-duality", "topic": "Advanced -> Optimization And Duality", "title": "School Dance", "url": "https://cses.fi/problemset/task/1696", "source": "CSES", "difficulty": "medium", "tracks": [], "tags": [ "Matching", "Bipartite Graphs", "Flow", "Bipartite Graph" ], "styles": [ "Augmenting Paths" ], "prerequisites": [ "Bipartite Matching" ], "bucket": "core", "why_fit": "A very approachable gateway into max-flow / matching duality." }, { "slug": "advanced/optimization-and-duality", "topic": "Advanced -> Optimization And Duality", "title": "Distinct Routes", "url": "https://cses.fi/problemset/task/1711", "source": "CSES", "difficulty": "hard", "tracks": [], "tags": [ "Edge-Disjoint Paths", "Flow Decomposition", "Packing" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "A strong path-packing formulation that broadens optimization modeling." }, { "slug": "advanced/optimization-and-duality", "topic": "Advanced -> Optimization And Duality", "title": "Download Speed", "url": "https://cses.fi/problemset/task/1694", "source": "CSES", "difficulty": "hard", "tracks": [], "tags": [ "Max Flow", "Min Cut", "Network Optimization", "Duality Intuition" ], "styles": [ "Flow Modeling" ], "prerequisites": [ "Max Flow", "Min Cut" ], "bucket": "challenge", "why_fit": "Max-flow/min-cut duality is the core lesson of this problem." }, { "slug": "advanced/optimization-and-duality", "topic": "Advanced -> Optimization And Duality", "title": "Task Assignment", "url": "https://cses.fi/problemset/task/2129", "source": "CSES", "difficulty": "hard", "tracks": [], "tags": [ "Assignment", "Min-Cost Optimization", "Min-Cost Flow", "Bipartite Optimization" ], "styles": [ "Exact Optimization" ], "prerequisites": [ "Matching", "Cost Matrices" ], "bucket": "challenge", "why_fit": "A textbook assignment problem with a natural dual interpretation." }, { "slug": "advanced/parallel-algorithms", "topic": "Advanced -> Parallel Algorithms", "title": "Parallel Prefix Sum Benchmark", "url": "https://www.cs.cmu.edu/afs/cs/academic/class/15451-s14/www/LectureNotes/PrefixSumBlelloch.pdf", "source": "CMU / Blelloch", "difficulty": "theory", "tracks": [ "Scan" ], "tags": [ "Prefix Sum", "Blelloch Scan", "Work Span", "Pram" ], "styles": [ "Theory Benchmark", "Simulator" ], "prerequisites": [ "Associativity", "Prefix Sums", "Tree Reduction" ], "bucket": "core", "why_fit": "The canonical first parallel benchmark for this repo because scan makes the work-vs-span lens concrete without pretending the repo already provides a full multicore runtime." }, { "slug": "advanced/parallel-algorithms", "topic": "Advanced -> Parallel Algorithms", "title": "Parallel algorithms notes: Brent and work-efficient scan", "url": "https://courses.csail.mit.edu/6.854/16/Notes/n32-parallel.html", "source": "MIT 6.854", "difficulty": "theory", "tracks": [ "Further Theory" ], "tags": [ "Brent's Theorem", "Work Efficient", "Pram", "Parallel Prefix" ], "styles": [ "Lecture Notes", "Theory Breadth" ], "prerequisites": [ "Prefix Sum", "Work Span" ], "bucket": "stretch", "why_fit": "A strong follow-up once the scan route clicks and you want the first serious work-efficient simulation lens instead of only the tree mechanics." }, { "slug": "advanced/quantum-algorithms", "topic": "Advanced -> Quantum Algorithms", "title": "Deutsch-Jozsa Oracle Benchmark", "url": "https://ocw.mit.edu/courses/6-845-quantum-complexity-theory-fall-2010/resources/mit6_845f10_lec05/", "source": "MIT OCW 6.845", "difficulty": "theory", "tracks": [ "Promise Problems" ], "tags": [ "Deutsch-Jozsa", "Phase Oracle", "Hadamard", "Constant Vs Balanced" ], "styles": [ "Theory Benchmark", "Simulator" ], "prerequisites": [ "Boolean Cube", "Signs" ], "bucket": "core", "why_fit": "The canonical first quantum benchmark for this repo because one clean amplitude invariant separates the promised constant and balanced oracle families." }, { "slug": "advanced/quantum-algorithms", "topic": "Advanced -> Quantum Algorithms", "title": "Quantum computation notes", "url": "https://cs.uwaterloo.ca/~watrous/QC-notes/", "source": "Waterloo", "difficulty": "theory", "tracks": [ "Further Theory" ], "tags": [ "Grover", "Shor", "Quantum States", "Amplitudes" ], "styles": [ "Lecture Notes", "Theory Breadth" ], "prerequisites": [ "Deutsch-Jozsa", "Hadamard Layers" ], "bucket": "stretch", "why_fit": "A strong follow-up once Deutsch-Jozsa is clear and you want broader theory without pretending the repo lane already covers full quantum implementation work." }, { "slug": "advanced/randomized-algorithms", "topic": "Advanced -> Randomized Algorithms", "title": "Problem Set 1", "url": "https://www.cs.utexas.edu/~ecprice/courses/randomized/fa19/psets/randomized-ps1.pdf", "source": "UT Austin CS388R", "difficulty": "theory", "tracks": [], "tags": [ "Min-Cut", "Sampling", "Expected Complexity" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "A strong theory-first warmup on randomized design and analysis from an algorithms course." }, { "slug": "advanced/randomized-algorithms", "topic": "Advanced -> Randomized Algorithms", "title": "Problem with Random Tests", "url": "https://codeforces.com/problemset/problem/1743/D", "source": "Codeforces", "difficulty": "hard", "tracks": [], "tags": [ "Probability", "Adversarial Tests" ], "styles": [ "Probabilistic Reasoning" ], "prerequisites": [ "Expected Value", "Randomized Thinking" ], "bucket": "challenge", "why_fit": "A direct fit for understanding how random testing interacts with algorithm design." }, { "slug": "advanced/randomized-algorithms", "topic": "Advanced -> Randomized Algorithms", "title": "Wizards and Huge Prize", "url": "https://codeforces.com/problemset/problem/105/B", "source": "Codeforces", "difficulty": "hard", "tracks": [], "tags": [ "Probability", "Randomization", "Expected Value" ], "styles": [ "Probabilistic Model" ], "prerequisites": [ "Probability Basics" ], "bucket": "challenge", "why_fit": "A classic probability-heavy contest problem." }, { "slug": "advanced/randomized-algorithms", "topic": "Advanced -> Randomized Algorithms", "title": "Gosha is hunting", "url": "https://codeforces.com/problemset/problem/739/E", "source": "Codeforces", "difficulty": "very-hard", "tracks": [], "tags": [ "Probability", "Randomization", "Expected Value" ], "styles": [ "Stochastic Analysis" ], "prerequisites": [ "Probability", "DP" ], "bucket": "challenge", "why_fit": "A high-end probabilistic problem that rewards careful randomized analysis." }, { "slug": "advanced/randomized-algorithms", "topic": "Advanced -> Randomized Algorithms", "title": "Isaac's Queries", "url": "https://codeforces.com/problemset/problem/2157/G", "source": "Codeforces", "difficulty": "very-hard", "tracks": [], "tags": [ "Probability", "Interactive" ], "styles": [ "Interactive Reasoning" ], "prerequisites": [ "Probability", "Interactive Protocols" ], "bucket": "challenge", "why_fit": "A modern hard problem where randomness and interaction both matter." }, { "slug": "advanced/randomized-algorithms", "topic": "Advanced -> Randomized Algorithms", "title": "Journey", "url": "https://codeforces.com/problemset/problem/839/C", "source": "Codeforces", "difficulty": "medium", "tracks": [ "Tree Expectation", "Expected Value" ], "tags": [ "Tree DFS", "Probability" ], "styles": [ "DFS Expectation" ], "prerequisites": [ "Tree DFS", "Basic Probability" ], "bucket": "cross-topic", "why_fit": "A friendly bridge from tree DFS into expectation, best framed here as cross-topic probability practice." }, { "slug": "advanced/randomized-algorithms", "topic": "Advanced -> Randomized Algorithms", "title": "Control of Randomness", "url": "https://codeforces.com/problemset/problem/2040/E", "source": "Codeforces", "difficulty": "hard", "tracks": [ "Probability On Trees", "Tree DP" ], "tags": [ "Probability", "Expected Process" ], "styles": [ "Tree DP", "Case Analysis" ], "prerequisites": [ "Basic Probability" ], "bucket": "cross-topic", "why_fit": "Better treated as a cross-topic probability-on-trees exercise than as a pure randomized-design core problem." }, { "slug": "advanced/randomized-algorithms", "topic": "Advanced -> Randomized Algorithms", "title": "I Love Balls", "url": "https://codeforces.com/problemset/problem/1983/E", "source": "Codeforces", "difficulty": "hard", "tracks": [ "Probability DP", "Expected Value" ], "tags": [ "Game Process" ], "styles": [ "State Expectation" ], "prerequisites": [ "Basic Probability", "DP States" ], "bucket": "cross-topic", "why_fit": "A strong cross-topic expectation/DP problem that supports randomized-thinking practice without being a randomized-design essential." }, { "slug": "advanced/randomized-algorithms", "topic": "Advanced -> Randomized Algorithms", "title": "Expected Value Again", "url": "https://codeforces.com/problemset/problem/1205/E", "source": "Codeforces", "difficulty": "very-hard", "tracks": [ "Combinatorial Expectation", "Expected Value" ], "tags": [ "Combinatorics" ], "styles": [ "Counting", "Expectation Analysis" ], "prerequisites": [ "Basic Probability", "Combinatorics" ], "bucket": "cross-topic", "why_fit": "A very hard cross-topic expectation/combinatorics exercise rather than a primary randomized-algorithms core item." }, { "slug": "advanced/simplex", "topic": "Advanced -> Simplex", "title": "Cheese, If You Please", "url": "https://open.kattis.com/problems/cheeseifyouplease", "source": "Kattis", "difficulty": "medium-hard", "tracks": [ "Optimization", "Linear Programming" ], "tags": [ "Continuous Optimization", "Resource Allocation", "Blending" ], "styles": [ "Modeling", "Floating Point" ], "prerequisites": [ "Linear Constraints", "Continuous Variables" ], "bucket": "core", "why_fit": "The cleanest first simplex rep in the repo because the story is already one continuous blend-planning LP with one variable per product." }, { "slug": "advanced/simplex", "topic": "Advanced -> Simplex", "title": "Road Times", "url": "https://icpc.global/worldfinals/problems/2016-ICPC-World-Finals/icpc2016.pdf", "source": "ICPC World Finals", "difficulty": "very-hard", "tracks": [ "Optimization", "Linear Programming" ], "tags": [ "LP Modeling", "Shortest Paths", "Challenge" ], "styles": [ "Modeling", "Theory-Heavy" ], "prerequisites": [ "Simplex", "Shortest Paths", "Optimization And Duality" ], "bucket": "challenge", "why_fit": "A famous stretch problem where the LP layer is real contest substance, not just background theory." }, { "slug": "combinatorics/bounded-compositions", "topic": "Combinatorics -> Bounded Compositions", "title": "Coins", "url": "https://atcoder.jp/contests/abc087/tasks/abc087_b", "source": "AtCoder", "difficulty": "easy", "tracks": [ "Coin-Change" ], "tags": [ "Bounded Composition", "Coin Sums" ], "styles": [ "Brute Force", "Counting" ], "prerequisites": [ "Nested Loops", "Case Analysis" ], "bucket": "core", "why_fit": "A tiny bounded-composition problem where all constraints are small enough to enumerate." }, { "slug": "combinatorics/bounded-compositions", "topic": "Combinatorics -> Bounded Compositions", "title": "Distributing Apples", "url": "https://cses.fi/problemset/task/1716", "source": "CSES", "difficulty": "easy-medium", "tracks": [ "Stars-And-Bars", "Bounded Counting" ], "tags": [ "Nonnegative Parts", "Combinations" ], "styles": [ "Math", "Combinatorics" ], "prerequisites": [ "Combinations" ], "bucket": "core", "why_fit": "The cleanest unconstrained composition baseline." }, { "slug": "combinatorics/bounded-compositions", "topic": "Combinatorics -> Bounded Compositions", "title": "M - Candies", "url": "https://atcoder.jp/contests/dp/tasks/dp_m", "source": "AtCoder", "difficulty": "medium", "tracks": [ "Prefix DP" ], "tags": [ "Upper Bounds", "Children And Candies", "DP" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "A canonical bounded-distribution DP." }, { "slug": "combinatorics/bounded-compositions", "topic": "Combinatorics -> Bounded Compositions", "title": "D - Between Two Arrays", "url": "https://atcoder.jp/contests/abc222/tasks/abc222_d", "source": "AtCoder", "difficulty": "hard", "tracks": [ "Prefix DP" ], "tags": [ "Nondecreasing Arrays", "Range Bounds", "Mod 998244353" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Counting bounded monotone sequences with DP." }, { "slug": "combinatorics/bounded-compositions", "topic": "Combinatorics -> Bounded Compositions", "title": "How Many Ways?", "url": "https://atcoder.jp/contests/math-and-algorithm/tasks/math_and_algorithm_br", "source": "AtCoder", "difficulty": "medium", "tracks": [ "Triple-Counting" ], "tags": [ "Triples", "Sum Constraint" ], "styles": [ "Counting", "Brute Force" ], "prerequisites": [ "Case Analysis", "Sum Constraints" ], "bucket": "practice", "why_fit": "A small but useful constrained-composition style problem over ordered triples." }, { "slug": "combinatorics/bounded-compositions", "topic": "Combinatorics -> Bounded Compositions", "title": "Tak and Cards", "url": "https://atcoder.jp/contests/abc044/tasks/arc060_a", "source": "AtCoder", "difficulty": "medium", "tracks": [ "Subset Sum" ], "tags": [ "Sum Constraints", "Card Selection" ], "styles": [ "DP", "Counting" ], "prerequisites": [ "Cardinality Constraints" ], "bucket": "practice", "why_fit": "A good bridge from composition thinking to constrained subset counting." }, { "slug": "combinatorics/burnside-polya", "topic": "Combinatorics -> Burnside / Pólya / Group Actions", "title": "Counting Necklaces", "url": "https://cses.fi/problemset/task/2209", "source": "CSES", "difficulty": "hard", "tracks": [ "Group Actions", "Orbit Counting" ], "tags": [ "Necklaces", "Rotations", "Mod Arithmetic" ], "styles": [ "Combinatorics", "Math" ], "prerequisites": [ "Basic Counting", "Modular Exponentiation", "GCD" ], "bucket": "core", "why_fit": "The clean first Burnside problem: cyclic rotations on one n-cycle with a fixed-coloring count of m^gcd(n, r)." }, { "slug": "combinatorics/burnside-polya", "topic": "Combinatorics -> Burnside / Pólya / Group Actions", "title": "Counting Grids", "url": "https://cses.fi/problemset/task/2210", "source": "CSES", "difficulty": "hard", "tracks": [ "Rotation Symmetry" ], "tags": [ "Grids", "Quarter Turns", "Mod Arithmetic" ], "styles": [ "Combinatorics", "Math" ], "prerequisites": [ "Burnside Lemma", "Modular Exponentiation" ], "bucket": "stretch", "why_fit": "The next rep after necklaces: same orbit-counting worldview, but each rotation creates a different cell-cycle structure." }, { "slug": "combinatorics/counting-basics", "topic": "Combinatorics -> Counting Basics", "title": "Bit Strings", "url": "https://cses.fi/problemset/task/1617", "source": "CSES", "difficulty": "easy", "tracks": [ "Basic Counting", "Mod Arithmetic" ], "tags": [ "Powers Of Two" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "The simplest counting-by-choices starter." }, { "slug": "combinatorics/counting-basics", "topic": "Combinatorics -> Counting Basics", "title": "Choose Cards 1", "url": "https://atcoder.jp/contests/math-and-algorithm/tasks/math_and_algorithm_s", "source": "AtCoder", "difficulty": "easy", "tracks": [ "Pair-Counting" ], "tags": [ "Pairs" ], "styles": [ "Implementation", "Counting" ], "prerequisites": [ "Basic Counting", "Frequency Arrays" ], "bucket": "core", "why_fit": "A very direct counting warm-up with only frequency bookkeeping." }, { "slug": "combinatorics/counting-basics", "topic": "Combinatorics -> Counting Basics", "title": "Choose Cards 3", "url": "https://atcoder.jp/contests/math-and-algorithm/tasks/math_and_algorithm_v", "source": "AtCoder", "difficulty": "easy", "tracks": [ "Pair-Counting" ], "tags": [ "Two-Sum", "Frequency Counting" ], "styles": [ "Implementation", "Counting" ], "prerequisites": [ "Frequency Arrays", "Complement Counting" ], "bucket": "core", "why_fit": "A great basic complement-counting exercise with a fixed target sum." }, { "slug": "combinatorics/counting-basics", "topic": "Combinatorics -> Counting Basics", "title": "Combination Easy", "url": "https://atcoder.jp/contests/math-and-algorithm/tasks/math_and_algorithm_u", "source": "AtCoder", "difficulty": "easy", "tracks": [ "Binomial-Coefficients" ], "tags": [ "Ncr" ], "styles": [ "Math" ], "prerequisites": [ "Factorials", "Combinations" ], "bucket": "core", "why_fit": "A pure combinatorics starter that isolates nCr without any hidden twists." }, { "slug": "combinatorics/counting-basics", "topic": "Combinatorics -> Counting Basics", "title": "Two Knights", "url": "https://cses.fi/problemset/task/1072", "source": "CSES", "difficulty": "easy", "tracks": [], "tags": [ "Board Counting", "Pair Counting", "Formula" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Classic counting-by-cases on a board." }, { "slug": "combinatorics/counting-basics", "topic": "Combinatorics -> Counting Basics", "title": "Binomial Coefficients", "url": "https://cses.fi/problemset/task/1079", "source": "CSES", "difficulty": "medium", "tracks": [ "Modular-Arithmetic" ], "tags": [ "Ncr", "Factorials", "Modular Inverse" ], "styles": [ "Math", "Precomputation" ], "prerequisites": [ "Factorials", "Modular Inverse" ], "bucket": "core", "why_fit": "The standard modular-combinatorics benchmark for factorial precomputation." }, { "slug": "combinatorics/counting-basics", "topic": "Combinatorics -> Counting Basics", "title": "Choose Cards 2", "url": "https://atcoder.jp/contests/math-and-algorithm/tasks/math_and_algorithm_t", "source": "AtCoder", "difficulty": "medium", "tracks": [ "Subset-Counting" ], "tags": [ "Meet-In-The-Middle" ], "styles": [ "Search", "Counting" ], "prerequisites": [ "Subset Enumeration", "Sum Constraints" ], "bucket": "core", "why_fit": "A classic counting-by-subsets problem that sits between brute force and combinatorics." }, { "slug": "combinatorics/counting-basics", "topic": "Combinatorics -> Counting Basics", "title": "Creating Strings II", "url": "https://cses.fi/problemset/task/1715", "source": "CSES", "difficulty": "medium", "tracks": [ "Multiset Permutations" ], "tags": [ "Factorials" ], "styles": [ "Math", "Precomputation" ], "prerequisites": [ "Multiset Counting", "Modular Arithmetic" ], "bucket": "core", "why_fit": "A textbook multinomial-counting problem with duplicate letters." }, { "slug": "combinatorics/counting-basics", "topic": "Combinatorics -> Counting Basics", "title": "Two Sets II", "url": "https://cses.fi/problemset/task/1093", "source": "CSES", "difficulty": "medium", "tracks": [ "DP" ], "tags": [ "Partitions", "Subset Sum", "Mod Arithmetic" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Nice introductory partition-counting problem." }, { "slug": "combinatorics/counting-basics", "topic": "Combinatorics -> Counting Basics", "title": "Christmas Party", "url": "https://cses.fi/problemset/task/1717", "source": "CSES", "difficulty": "medium", "tracks": [ "Derangements" ], "tags": [ "Derangements", "Inclusion-Exclusion" ], "styles": [ "Combinatorics", "DP" ], "prerequisites": [ "Basic Counting", "Inclusion-Exclusion" ], "bucket": "practice", "why_fit": "A classic derangement/counting problem that is good practice for constrained permutations." }, { "slug": "combinatorics/counting-basics", "topic": "Combinatorics -> Counting Basics", "title": "Distributing Apples", "url": "https://cses.fi/problemset/task/1716", "source": "CSES", "difficulty": "medium", "tracks": [ "Stars-And-Bars" ], "tags": [ "Compositions", "Combinations", "Mod Arithmetic" ], "styles": [ "Math", "Combinatorics" ], "prerequisites": [ "Combinations" ], "bucket": "practice", "why_fit": "A canonical stars-and-bars problem and a clean step toward distributions with constraints." }, { "slug": "combinatorics/counting-basics", "topic": "Combinatorics -> Counting Basics", "title": "Counting Necklaces", "url": "https://cses.fi/problemset/task/2209", "source": "CSES", "difficulty": "hard", "tracks": [ "Group-Actions" ], "tags": [ "Burnside", "Pólya" ], "styles": [ "Combinatorics" ], "prerequisites": [ "Modular Arithmetic" ], "bucket": "stretch", "why_fit": "A more advanced counting benchmark that moves from raw counting into symmetry." }, { "slug": "combinatorics/counting-basics", "topic": "Combinatorics -> Counting Basics", "title": "Counting Permutations", "url": "https://cses.fi/problemset/task/1075", "source": "CSES", "difficulty": "hard", "tracks": [ "Permutation-Counting", "Inclusion-Style Counting" ], "tags": [ "Permutations", "Adjacency Constraints", "Adjacency Restriction", "Beautiful Permutations" ], "styles": [ "DP", "Combinatorics" ], "prerequisites": [ "Inclusion-Exclusion Mindset" ], "bucket": "stretch", "why_fit": "A stronger permutation-counting problem with a clean but nontrivial constraint." }, { "slug": "combinatorics/inclusion-exclusion", "topic": "Combinatorics -> Inclusion-Exclusion", "title": "Christmas Party", "url": "https://cses.fi/problemset/task/1717", "source": "CSES", "difficulty": "medium", "tracks": [ "Derangements" ], "tags": [ "Fixed Points", "Permutations", "Mod Arithmetic" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "A textbook derangement / inclusion-exclusion task." }, { "slug": "combinatorics/inclusion-exclusion", "topic": "Combinatorics -> Inclusion-Exclusion", "title": "Prime Multiples", "url": "https://cses.fi/problemset/task/2185", "source": "CSES", "difficulty": "medium", "tracks": [ "Number Theory", "Subset Counting" ], "tags": [ "Multiples", "Primes", "Prime Set", "LCM" ], "styles": [ "Math", "Enumeration" ], "prerequisites": [ "Inclusion-Exclusion", "LCM Reasoning" ], "bucket": "core", "why_fit": "Direct inclusion-exclusion over prime subsets." }, { "slug": "combinatorics/inclusion-exclusion", "topic": "Combinatorics -> Inclusion-Exclusion", "title": "Counting Coprime Pairs", "url": "https://cses.fi/problemset/task/2417", "source": "CSES", "difficulty": "medium-hard", "tracks": [ "Mobius", "Mobius Inversion" ], "tags": [ "Coprime Pairs", "GCD 1", "Pair Counting", "Number Theory" ], "styles": [ "Number Theory", "Sieving" ], "prerequisites": [ "Inclusion-Exclusion", "Divisor Counting" ], "bucket": "core", "why_fit": "Mobius-inversion version of inclusion-exclusion on gcds." }, { "slug": "combinatorics/inclusion-exclusion", "topic": "Combinatorics -> Inclusion-Exclusion", "title": "Coprime", "url": "https://codeforces.com/problemset/problem/1742/D", "source": "Codeforces", "difficulty": "medium", "tracks": [ "GCD" ], "tags": [ "Coprime", "Number Theory" ], "styles": [ "Number Theory", "Greedy" ], "prerequisites": [ "Pair Reasoning" ], "bucket": "practice", "why_fit": "A lighter coprimality exercise that still rewards divisor-set reasoning." }, { "slug": "combinatorics/inclusion-exclusion", "topic": "Combinatorics -> Inclusion-Exclusion", "title": "Coprime Subsequences", "url": "https://codeforces.com/problemset/problem/803/F", "source": "Codeforces", "difficulty": "hard", "tracks": [ "Mobius" ], "tags": [ "Subsequences", "Number Theory" ], "styles": [ "Combinatorics", "Number Theory" ], "prerequisites": [ "Inclusion-Exclusion", "Prime Factorization" ], "bucket": "stretch", "why_fit": "A strong advanced example where inclusion-exclusion is the heart of the solution." }, { "slug": "combinatorics/inclusion-exclusion", "topic": "Combinatorics -> Inclusion-Exclusion", "title": "Counting Necklaces", "url": "https://cses.fi/problemset/task/2209", "source": "CSES", "difficulty": "hard", "tracks": [ "Burnside", "Symmetry Counting" ], "tags": [ "Orbit Counting", "Pólya", "Rotations" ], "styles": [], "prerequisites": [], "bucket": "cross-topic", "why_fit": "Not pure IE, but a strong neighboring symmetry-counting problem." }, { "slug": "combinatorics/lexicographic-enumeration", "topic": "Combinatorics -> Lexicographic Enumeration", "title": "Count Order", "url": "https://atcoder.jp/contests/abc150/tasks/abc150_c", "source": "AtCoder", "difficulty": "easy", "tracks": [ "Permutation Ranking" ], "tags": [ "Permutations", "Lexicographic Rank" ], "styles": [ "Math", "Permutation" ], "prerequisites": [ "Factorials", "Permutation Order" ], "bucket": "core", "why_fit": "The textbook k-th-permutation problem, ideal for rank/unrank practice." }, { "slug": "combinatorics/lexicographic-enumeration", "topic": "Combinatorics -> Lexicographic Enumeration", "title": "Creating Strings", "url": "https://cses.fi/problemset/task/1622", "source": "CSES", "difficulty": "easy", "tracks": [ "Multiset Permutations", "Lexicographic Order" ], "tags": [ "Duplicate Permutations", "Generation", "Sorting" ], "styles": [ "Backtracking", "Enumeration" ], "prerequisites": [ "Sorting", "Multisets" ], "bucket": "core", "why_fit": "A classic generation task that teaches lexicographic enumeration of unique strings." }, { "slug": "combinatorics/lexicographic-enumeration", "topic": "Combinatorics -> Lexicographic Enumeration", "title": "C - One More aab aba baa", "url": "https://atcoder.jp/contests/abc215/tasks/abc215_c", "source": "AtCoder", "difficulty": "medium", "tracks": [ "Multiset Permutations" ], "tags": [ "K-Th Permutation", "Duplicate Letters", "Sorting" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Classic k-th lexicographic permutation of a multiset string." }, { "slug": "combinatorics/lexicographic-enumeration", "topic": "Combinatorics -> Lexicographic Enumeration", "title": "Permutation Order", "url": "https://cses.fi/problemset/task/3397", "source": "CSES", "difficulty": "medium", "tracks": [ "Permutation Ranking", "Lexicographic Order" ], "tags": [ "K-Th Permutation", "Factoradic", "Inverse Permutation Order" ], "styles": [ "Implementation", "Math" ], "prerequisites": [ "Factorials" ], "bucket": "core", "why_fit": "A direct bidirectional rank/unrank permutation problem with multiple query types." }, { "slug": "combinatorics/lexicographic-enumeration", "topic": "Combinatorics -> Lexicographic Enumeration", "title": "Creating Strings II", "url": "https://cses.fi/problemset/task/1715", "source": "CSES", "difficulty": "medium", "tracks": [ "Multiset Permutations", "Ranking And Counting", "Lexicographic Combinatorics" ], "tags": [ "Counting Strings", "Factorials", "Mod Arithmetic" ], "styles": [ "Math", "Precomputation" ], "prerequisites": [ "Multinomial Counting", "Lexicographic Order" ], "bucket": "practice", "why_fit": "Useful if you want both counting and ordering over repeated characters." }, { "slug": "combinatorics/lexicographic-enumeration", "topic": "Combinatorics -> Lexicographic Enumeration", "title": "Lexicographically Smallest Permutation", "url": "https://atcoder.jp/contests/abc371/tasks/abc371_g", "source": "AtCoder", "difficulty": "hard", "tracks": [ "Permutation-Cycles" ], "tags": [ "Lexicographic Order", "Permutations", "Cycle Decomposition" ], "styles": [ "Construction", "Greedy" ], "prerequisites": [ "Permutations", "Cycle Decomposition", "Lexicographic Order" ], "bucket": "stretch", "why_fit": "A strong advanced permutation problem where lexicographic minimization is the central goal." }, { "slug": "combinatorics/lexicographic-enumeration", "topic": "Combinatorics -> Lexicographic Enumeration", "title": "Reverse and Count", "url": "https://atcoder.jp/contests/arc160/tasks/arc160_a", "source": "AtCoder", "difficulty": "hard", "tracks": [ "Permutation Ranking" ], "tags": [ "Lexicographic Order" ], "styles": [ "Construction", "Combinatorics" ], "prerequisites": [ "Lexicographic Order" ], "bucket": "stretch", "why_fit": "A more specialized lexicographic ranking problem with a nice combinatorial twist." }, { "slug": "data-structures/b-trees", "topic": "Data Structures -> B-Trees", "title": "B-Tree Dictionary Benchmark", "url": "https://opendatastructures.org/ods-cpp/14_2_B_Trees.html", "source": "Open Data Structures", "difficulty": "medium", "tracks": [ "B-Tree", "Textbook Breadth" ], "tags": [ "Split-Full-Child", "Multiway-Search" ], "styles": [ "Data-Structure-Heavy", "Implementation-Heavy" ], "prerequisites": [ "Minimum Degree", "Separator Keys", "Split Full Child" ], "bucket": "core", "why_fit": "The cleanest breadth-first benchmark source where search, root split, and split-full-child are the whole lesson before deletion or B+ tree variants." }, { "slug": "data-structures/balanced-bsts", "topic": "Data Structures -> Balanced BSTs For Contests", "title": "ORDERSET - Order Statistic Set", "url": "https://www.spoj.com/problems/ORDERSET/", "source": "SPOJ", "difficulty": "medium", "tracks": [ "Balanced Bst Compare", "Order Statistics" ], "tags": [ "Rank-Query", "Kth-Smallest", "Compare-Route" ], "styles": [ "Data-Structure-Heavy", "Classic" ], "prerequisites": [ "Ordered Set Invariant", "Rank Queries", "K-Th Queries" ], "bucket": "compare", "why_fit": "Good compare practice after the AVL note because the same interface is often better served by PBDS than by hand-coding deterministic balancing." }, { "slug": "data-structures/balanced-bsts", "topic": "Data Structures -> Balanced BSTs For Contests", "title": "Salary Queries", "url": "https://cses.fi/problemset/task/1144", "source": "CSES", "difficulty": "medium", "tracks": [ "Balanced Bst Compare", "Treap Compare" ], "tags": [ "Duplicate-Safe-Wrapper", "Range-Count", "Compare-Route" ], "styles": [ "Data-Structure-Heavy", "Query-Heavy" ], "prerequisites": [ "Duplicate Counts", "Order Statistics", "Pair-Key Wrapper" ], "bucket": "compare", "why_fit": "A strong compare exercise showing that once split/merge by key or duplicate-safe wrappers matter, treap or PBDS is usually the cleaner in-repo route than AVL." }, { "slug": "data-structures/balanced-bsts", "topic": "Data Structures -> Balanced BSTs For Contests", "title": "Luogu P3369 - 普通平衡树", "url": "https://www.luogu.com.cn/problem/P3369", "source": "Luogu", "difficulty": "hard", "tracks": [ "Avl", "Red-Black", "Scapegoat", "Size-Balanced-Tree", "Balanced Bst" ], "tags": [ "Rotations", "Order-Statistics", "Predecessor-Successor" ], "styles": [ "Data-Structure-Heavy", "Implementation-Heavy" ], "prerequisites": [ "Avl Balance Invariant", "Rotations", "Duplicate Counts" ], "bucket": "implementation-challenge", "why_fit": "A canonical implementation challenge if you want to hand-code AVL-style, Red-Black-style, Scapegoat-style, or SBT-style balancing and support the textbook ordered-set operation bundle end to end." }, { "slug": "data-structures/binary-trie-xor", "topic": "Data Structures -> Binary Trie / XOR Queries", "title": "Vasiliy's Multiset", "url": "https://codeforces.com/problemset/problem/706/D", "source": "Codeforces", "difficulty": "medium", "tracks": [ "Binary Trie", "XOR Queries" ], "tags": [ "Dynamic-Multiset", "Maximum-XOR" ], "styles": [ "Data-Structure-Heavy", "Bitwise" ], "prerequisites": [ "Bitwise Prefix Walk", "Subtree Counts", "Dynamic Multiset" ], "bucket": "core", "why_fit": "The cleanest first dynamic benchmark where insert, erase-one, and maximum-xor queries are the whole problem." }, { "slug": "data-structures/binary-trie-xor", "topic": "Data Structures -> Binary Trie / XOR Queries", "title": "SUBXOR", "url": "https://www.spoj.com/problems/SUBXOR/", "source": "SPOJ", "difficulty": "hard", "tracks": [ "Binary Trie", "Counting Variant", "Classic" ], "tags": [ "Prefix-XOR", "Counting" ], "styles": [ "Bitwise", "Classic" ], "prerequisites": [ "Prefix XOR", "Bitwise Counting" ], "bucket": "stretch", "why_fit": "A classic stretch problem showing that the same family extends beyond maximum-xor queries into richer counting variants." }, { "slug": "data-structures/binary-trie-xor", "topic": "Data Structures -> Binary Trie / XOR Queries", "title": "Maximum Xor Subarray", "url": "https://cses.fi/problemset/task/1655", "source": "CSES", "difficulty": "hard", "tracks": [ "Bitwise Operations", "Prefix XOR", "Binary Trie" ], "tags": [ "Maximum-XOR" ], "styles": [ "Bitwise", "Array Transformation" ], "prerequisites": [ "Maximum XOR Query" ], "bucket": "bridge", "why_fit": "The canonical bridge from one dynamic xor set to prefix-xor scans over an array." }, { "slug": "data-structures/dsu", "topic": "Data Structures -> DSU", "title": "Disjoint Set Union I", "url": "https://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=DSL_1_A&lang=en", "source": "AOJ", "difficulty": "easy", "tracks": [], "tags": [ "Intro", "Online-Judge" ], "styles": [ "Implementation-Heavy" ], "prerequisites": [ "DSU Basics", "Component Representatives" ], "bucket": "warm-up", "why_fit": "A classic AOJ DSU starter that is ideal for practicing the raw union-find interface." }, { "slug": "data-structures/dsu", "topic": "Data Structures -> DSU", "title": "Building Roads", "url": "https://cses.fi/problemset/task/1666", "source": "CSES", "difficulty": "easy", "tracks": [], "tags": [ "Components", "Connectivity" ], "styles": [ "Data-Structure-Heavy", "Implementation-Heavy" ], "prerequisites": [ "Connected Components", "Union-Find Basics", "Graphs" ], "bucket": "core", "why_fit": "A friendly first DSU problem for merging components and counting how many remain." }, { "slug": "data-structures/dsu", "topic": "Data Structures -> DSU", "title": "Road Construction", "url": "https://cses.fi/problemset/task/1676", "source": "CSES", "difficulty": "easy", "tracks": [], "tags": [ "Dynamic-Connectivity", "Largest-Component", "Component-Size" ], "styles": [ "Data-Structure-Heavy" ], "prerequisites": [ "DSU", "Component Sizes", "Amortized Complexity" ], "bucket": "core", "why_fit": "A classic DSU exercise with incremental edge additions and size tracking." }, { "slug": "data-structures/dsu", "topic": "Data Structures -> DSU", "title": "Road Reparation", "url": "https://cses.fi/problemset/task/1675", "source": "CSES", "difficulty": "medium", "tracks": [], "tags": [ "Minimum-Spanning-Tree", "Kruskal", "MST" ], "styles": [ "Greedy-Heavy", "Data-Structure-Heavy" ], "prerequisites": [ "DSU", "MST", "Sorting Edges" ], "bucket": "classic", "why_fit": "A canonical Kruskal benchmark that shows DSU in its most common graph role." }, { "slug": "data-structures/dsu", "topic": "Data Structures -> DSU", "title": "Union Find", "url": "https://judge.yosupo.jp/problem/unionfind", "source": "Library Checker", "difficulty": "medium", "tracks": [], "tags": [ "Connectivity" ], "styles": [ "Data-Structure-Heavy" ], "prerequisites": [ "Path Compression", "Union By Size", "Online Queries" ], "bucket": "classic", "why_fit": "A clean official benchmark for validating a DSU implementation against a trusted judge." }, { "slug": "data-structures/dsu-on-tree", "topic": "Data Structures -> DSU On Tree / Small-To-Large", "title": "Distinct Colors", "url": "https://cses.fi/problemset/task/1139", "source": "CSES", "difficulty": "hard", "tracks": [ "Subtree Queries" ], "tags": [ "Distinct Values", "Subtree Aggregation", "Small-To-Large" ], "styles": [ "Small-To-Large Merging", "Subtree Frequency Maps", "Offline Aggregation" ], "prerequisites": [ "Rooted Tree", "Frequency Maps", "Subtree Traversal" ], "bucket": "core", "why_fit": "The cleanest first benchmark where each subtree owns a mergeable color-frequency container and the whole optimization is just small-to-large merging." }, { "slug": "data-structures/dsu-on-tree", "topic": "Data Structures -> DSU On Tree / Small-To-Large", "title": "Lomsat gelral", "url": "https://codeforces.com/problemset/problem/600/E", "source": "Codeforces", "difficulty": "hard", "tracks": [ "Subtree Queries" ], "tags": [ "Color Frequency", "Subtree Aggregation", "Small-To-Large" ], "styles": [ "Small-To-Large Merging", "Frequency Aggregation", "Heavy Child Compare Point" ], "prerequisites": [ "DSU On Tree", "Frequency Maps", "Subtree Traversal" ], "bucket": "stretch", "why_fit": "A classic follow-up where the merged container must track richer frequency information than just distinct-count size." }, { "slug": "data-structures/dsu-rollback", "topic": "Data Structures -> DSU Rollback / Offline Dynamic Connectivity", "title": "Dynamic Connectivity", "url": "https://cses.fi/problemset/task/2133", "source": "CSES", "difficulty": "hard", "tracks": [ "Advanced Techniques", "Dynamic Connectivity" ], "tags": [ "Rollback-DSU", "Segment-Tree-Over-Time", "Component-Count" ], "styles": [ "Offline", "Data-Structure-Heavy", "Timeline Modeling" ], "prerequisites": [ "DSU", "Offline Reasoning", "Half-Open Intervals" ], "bucket": "core", "why_fit": "The cleanest first exact benchmark for edge-lifetime intervals, rollback DSU, and component answers at every time state." }, { "slug": "data-structures/dsu-rollback", "topic": "Data Structures -> DSU Rollback / Offline Dynamic Connectivity", "title": "Dynamic Graph Vertex Add Component Sum", "url": "https://judge.yosupo.jp/problem/dynamic_graph_vertex_add_component_sum", "source": "Library Checker", "difficulty": "hard", "tracks": [ "Dynamic Connectivity" ], "tags": [ "Rollback-DSU", "Segment-Tree-Over-Time", "Component Metadata" ], "styles": [ "Offline", "Verification", "Data-Structure-Heavy" ], "prerequisites": [ "Rollback DSU", "Component Metadata", "Offline Dynamic Connectivity" ], "bucket": "stretch", "why_fit": "A strong next-step verifier once rollback connectivity itself is trusted and component-value aggregation becomes the new difficulty." }, { "slug": "data-structures/fenwick-tree", "topic": "Data Structures -> Fenwick Tree", "title": "Dynamic Range Sum Queries", "url": "https://cses.fi/problemset/task/1648", "source": "CSES", "difficulty": "medium", "tracks": [], "tags": [ "Point-Update", "Range-Sum" ], "styles": [ "Data-Structure-Heavy", "Query-Heavy" ], "prerequisites": [ "Prefix Sums", "Point Updates", "Binary Indexed Tree" ], "bucket": "core", "why_fit": "A standard first Fenwick-tree task with point updates and range sums." }, { "slug": "data-structures/fenwick-tree", "topic": "Data Structures -> Fenwick Tree", "title": "Range Update Queries", "url": "https://cses.fi/problemset/task/1651", "source": "CSES", "difficulty": "medium", "tracks": [], "tags": [ "Difference Array", "Range-Update", "Range-Add" ], "styles": [ "Data-Structure-Heavy" ], "prerequisites": [ "Difference Arrays", "Prefix Sums", "Fenwick Tree Basics" ], "bucket": "core", "why_fit": "A good bridge between difference arrays and Fenwick-style prefix maintenance." }, { "slug": "data-structures/fenwick-tree", "topic": "Data Structures -> Fenwick Tree", "title": "Point Add Range Sum", "url": "https://judge.yosupo.jp/problem/point_add_range_sum", "source": "Library Checker", "difficulty": "medium", "tracks": [], "tags": [ "Range-Sum" ], "styles": [ "Query-Heavy", "Data-Structure-Heavy" ], "prerequisites": [ "Fenwick Tree", "Point Updates", "Prefix Sums" ], "bucket": "classic", "why_fit": "A concise official benchmark for the core Fenwick use case." }, { "slug": "data-structures/fenwick-tree", "topic": "Data Structures -> Fenwick Tree", "title": "Salary Queries", "url": "https://cses.fi/problemset/task/1144", "source": "CSES", "difficulty": "medium", "tracks": [], "tags": [ "Coordinate-Compression", "Range-Count", "Compression", "Rank-Query" ], "styles": [ "Query-Heavy", "Data-Structure-Heavy" ], "prerequisites": [ "Fenwick Tree", "Coordinate Compression", "Frequency Counting" ], "bucket": "classic", "why_fit": "A canonical frequency-query problem where Fenwick trees shine after compression." }, { "slug": "data-structures/fenwick-tree", "topic": "Data Structures -> Fenwick Tree", "title": "Forest Queries II", "url": "https://cses.fi/problemset/task/1739", "source": "CSES", "difficulty": "hard", "tracks": [], "tags": [ "2D-Fenwick", "Rectangle-Query", "Grid-Updates", "Grid", "Point-Update" ], "styles": [ "Data-Structure-Heavy", "Cross-Topic" ], "prerequisites": [ "Fenwick Tree", "2D Grids", "Rectangle Sums" ], "bucket": "advanced", "why_fit": "A strong advanced benchmark for extending Fenwick ideas into two dimensions." }, { "slug": "data-structures/fenwick-tree", "topic": "Data Structures -> Fenwick Tree", "title": "Range Add Range Sum", "url": "https://judge.yosupo.jp/problem/range_add_range_sum", "source": "Library Checker", "difficulty": "hard", "tracks": [], "tags": [ "Range-Update" ], "styles": [ "Query-Heavy", "Data-Structure-Heavy" ], "prerequisites": [ "Fenwick Tree Tricks", "Difference Arrays", "Range Sums" ], "bucket": "advanced", "why_fit": "A strong benchmark for the classic two-Fenwick range-add/range-sum pattern." }, { "slug": "data-structures/heaps-and-ordered-sets", "topic": "Data Structures -> Heaps And Ordered Sets", "title": "Restaurant Customers", "url": "https://cses.fi/problemset/task/1619", "source": "CSES", "difficulty": "easy", "tracks": [], "tags": [ "Events", "Sweep Line", "Maximum-Overlap" ], "styles": [ "Modeling-Heavy" ], "prerequisites": [ "Sorting", "Event Sweeps", "Prefix Counts" ], "bucket": "core", "why_fit": "A simple and popular event-processing problem that pairs naturally with ordered scans." }, { "slug": "data-structures/heaps-and-ordered-sets", "topic": "Data Structures -> Heaps And Ordered Sets", "title": "Room Allocation", "url": "https://cses.fi/problemset/task/1164", "source": "CSES", "difficulty": "medium", "tracks": [], "tags": [ "Priority-Queue", "Interval-Scheduling", "Assignment" ], "styles": [ "Greedy-Heavy", "Data-Structure-Heavy" ], "prerequisites": [ "Priority Queues", "Sorting", "Interval Scheduling" ], "bucket": "core", "why_fit": "A classic heap-based assignment problem with a very practical greedy pattern." }, { "slug": "data-structures/heaps-and-ordered-sets", "topic": "Data Structures -> Heaps And Ordered Sets", "title": "Movie Festival II", "url": "https://cses.fi/problemset/task/1632", "source": "CSES", "difficulty": "hard", "tracks": [], "tags": [ "Multiset", "K-Members" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "A canonical multi-assign scheduling problem." }, { "slug": "data-structures/heaps-and-ordered-sets", "topic": "Data Structures -> Heaps And Ordered Sets", "title": "Concert Tickets", "url": "https://cses.fi/problemset/task/1091", "source": "CSES", "difficulty": "medium", "tracks": [], "tags": [ "Multiset", "Predecessor-Query", "Lower Bound" ], "styles": [ "Data-Structure-Heavy", "Greedy-Heavy" ], "prerequisites": [ "Ordered Sets", "Greedy Matching", "Lower Bound" ], "bucket": "classic", "why_fit": "A classic ordered-set exercise for predecessor queries under deletions." }, { "slug": "data-structures/heaps-and-ordered-sets", "topic": "Data Structures -> Heaps And Ordered Sets", "title": "Traffic Lights", "url": "https://cses.fi/problemset/task/1163", "source": "CSES", "difficulty": "medium", "tracks": [], "tags": [ "Ordered-Set", "Intervals", "Max-Gap", "Neighbors" ], "styles": [ "Data-Structure-Heavy" ], "prerequisites": [ "Ordered Sets", "Interval Maintenance", "Multisets" ], "bucket": "classic", "why_fit": "A well-known benchmark for maintaining gaps between ordered points." }, { "slug": "data-structures/heaps-and-ordered-sets", "topic": "Data Structures -> Heaps And Ordered Sets", "title": "Sliding Window Cost", "url": "https://cses.fi/problemset/task/1077", "source": "CSES", "difficulty": "hard", "tracks": [], "tags": [ "Median", "Absolute-Deviation" ], "styles": [ "Data-Structure-Heavy" ], "prerequisites": [ "Median Maintenance", "Multisets", "Sliding Windows" ], "bucket": "advanced", "why_fit": "A more demanding ordered-structure problem that extends median maintenance into cost tracking." }, { "slug": "data-structures/heaps-and-ordered-sets", "topic": "Data Structures -> Heaps And Ordered Sets", "title": "Sliding Window Median", "url": "https://cses.fi/problemset/task/1076", "source": "CSES", "difficulty": "hard", "tracks": [], "tags": [ "Median", "Sliding-Window" ], "styles": [ "Data-Structure-Heavy" ], "prerequisites": [ "Priority Queues", "Multisets", "Window Maintenance" ], "bucket": "advanced", "why_fit": "A strong benchmark for maintaining order statistics with heap-like containers." }, { "slug": "data-structures/interval-trees", "topic": "Data Structures -> Interval Trees", "title": "Reservation System", "url": "https://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0360", "source": "AOJ", "difficulty": "easy", "tracks": [ "Interval Tree", "Interval Overlap" ], "tags": [ "Half-Open-Intervals", "Overlap-Query", "Augmented-Bst" ], "styles": [ "Data-Structure-Heavy", "Query-Heavy" ], "prerequisites": [ "Half-Open Interval Overlap", "Dynamic Interval Set", "Subtree Max-Right" ], "bucket": "core", "why_fit": "A gentle first benchmark where the real invariant is 'does the new interval overlap anything in the live set?', so subtree max-right augmentation can be practiced directly even though a lighter ordered-set route also exists." }, { "slug": "data-structures/lazy-segment-tree", "topic": "Data Structures -> Lazy Segment Tree", "title": "HORRIBLE", "url": "https://www.spoj.com/problems/HORRIBLE/", "source": "SPOJ", "difficulty": "medium", "tracks": [ "Range Queries", "Lazy Propagation" ], "tags": [ "Range-Add", "Range-Sum", "Classic" ], "styles": [ "Data-Structure-Heavy", "Query-Heavy" ], "prerequisites": [ "Segment Tree Basics", "Difference Arrays Contrast", "Range Updates" ], "bucket": "core", "why_fit": "The cleanest exact range add + range sum benchmark for a first lazy segment tree." }, { "slug": "data-structures/lazy-segment-tree", "topic": "Data Structures -> Lazy Segment Tree", "title": "Polynomial Queries", "url": "https://cses.fi/problemset/task/1736", "source": "CSES", "difficulty": "hard", "tracks": [ "Range Queries" ], "tags": [ "Lazy-Propagation", "Range-Update", "Arithmetic-Progression" ], "styles": [ "Data-Structure-Heavy", "Math-Heavy" ], "prerequisites": [ "Lazy Propagation", "Range Arithmetic", "Tag Design" ], "bucket": "stretch", "why_fit": "A memorable benchmark where the update itself carries structure, not just one additive delta." }, { "slug": "data-structures/lazy-segment-tree", "topic": "Data Structures -> Lazy Segment Tree", "title": "Range Updates and Sums", "url": "https://cses.fi/problemset/task/1735", "source": "CSES", "difficulty": "hard", "tracks": [ "Range Queries" ], "tags": [ "Lazy-Propagation", "Range-Add", "Range-Assign" ], "styles": [ "Data-Structure-Heavy" ], "prerequisites": [ "Lazy Propagation", "Tag Composition", "Range Assign" ], "bucket": "stretch", "why_fit": "The natural next benchmark once plain additive tags are stable and tag precedence becomes the real challenge." }, { "slug": "data-structures/lazy-segment-tree", "topic": "Data Structures -> Lazy Segment Tree", "title": "Range Affine Range Sum", "url": "https://atcoder.jp/contests/practice2/tasks/practice2_k", "source": "AtCoder", "difficulty": "hard", "tracks": [], "tags": [ "Lazy-Propagation", "Affine-Update", "Acl-Style" ], "styles": [ "Data-Structure-Heavy", "Verification" ], "prerequisites": [ "Lazy Propagation", "Modular Arithmetic", "Affine Tags" ], "bucket": "advanced", "why_fit": "The cleanest external verifier once you want to think in generic lazy actions rather than one bespoke additive tag." }, { "slug": "data-structures/monotonic-stack-queue", "topic": "Data Structures -> Monotonic Stack / Queue", "title": "Nearest Smaller Values", "url": "https://cses.fi/problemset/task/1645", "source": "CSES", "difficulty": "medium", "tracks": [ "Monotonic Stack" ], "tags": [ "Previous-Smaller", "Boundary" ], "styles": [ "Implementation", "Amortized" ], "prerequisites": [ "Stacks", "Indices", "Strict Comparators" ], "bucket": "core", "why_fit": "The canonical first boundary-scan problem for the monotonic-stack side of the family." }, { "slug": "data-structures/monotonic-stack-queue", "topic": "Data Structures -> Monotonic Stack / Queue", "title": "Sliding Window Minimum", "url": "https://cses.fi/problemset/task/3221", "source": "CSES", "difficulty": "medium", "tracks": [ "Monotonic Deque" ], "tags": [ "Window-Minimum", "Stream" ], "styles": [ "Implementation", "Streaming" ], "prerequisites": [ "Deque", "Window Expiry", "Amortized Reasoning" ], "bucket": "core", "why_fit": "The queue-side canonical benchmark where domination pops and window expiry are both visible." }, { "slug": "data-structures/monotonic-stack-queue", "topic": "Data Structures -> Monotonic Stack / Queue", "title": "Advertisement", "url": "https://cses.fi/problemset/task/1142", "source": "CSES", "difficulty": "medium", "tracks": [ "Monotonic Stack" ], "tags": [ "Histogram", "Nearest-Smaller", "Rectangle Area" ], "styles": [ "Implementation", "Geometry-On-Array" ], "prerequisites": [ "Boundary Indices" ], "bucket": "classic", "why_fit": "A strong follow-up where nearest-smaller boundaries turn directly into widths." }, { "slug": "data-structures/mos-algorithm", "topic": "Data Structures -> Mo's Algorithm", "title": "Powerful Array", "url": "https://codeforces.com/problemset/problem/86/D", "source": "Codeforces", "difficulty": "hard", "tracks": [ "Frequency Maintenance" ], "tags": [ "Range-Frequency", "Offline" ], "styles": [ "Query-Heavy", "Data-Structure-Heavy" ], "prerequisites": [ "Offline Query Ordering", "Current Range Invariant" ], "bucket": "core", "why_fit": "A famous Mo benchmark where the current answer is one frequency-weighted score and add/remove are true local updates." }, { "slug": "data-structures/mos-algorithm", "topic": "Data Structures -> Mo's Algorithm", "title": "Static Range Count Distinct", "url": "https://judge.yosupo.jp/problem/static_range_count_distinct", "source": "Library Checker", "difficulty": "hard", "tracks": [], "tags": [ "Distinct-Count", "Offline" ], "styles": [ "Query-Heavy", "Data-Structure-Heavy" ], "prerequisites": [ "Mo's Algorithm", "Frequency Counts", "Coordinate Compression" ], "bucket": "practice", "why_fit": "An official verifier-style Mo benchmark once ordinary current-range maintenance is trusted." }, { "slug": "data-structures/mos-algorithm", "topic": "Data Structures -> Mo's Algorithm", "title": "D-query", "url": "https://www.spoj.com/problems/DQUERY/", "source": "SPOJ", "difficulty": "hard", "tracks": [ "Classic" ], "tags": [ "Distinct-Count", "Offline Range Queries" ], "styles": [ "Query-Heavy", "Data-Structure-Heavy" ], "prerequisites": [ "Mo's Algorithm", "Frequency Counts", "Coordinate Compression" ], "bucket": "classic", "why_fit": "The classic static distinct-count Mo problem and a good second rep after one frequency-score benchmark." }, { "slug": "data-structures/mos-algorithm", "topic": "Data Structures -> Mo's Algorithm", "title": "Distinct Values Queries", "url": "https://cses.fi/problemset/task/1734", "source": "CSES", "difficulty": "hard", "tracks": [ "Compare Point" ], "tags": [ "Distinct-Count", "Offline" ], "styles": [ "Query-Heavy", "Compare-Point" ], "prerequisites": [ "Mo's Algorithm", "Offline Sweeps", "Frequency Counts" ], "bucket": "bridge", "why_fit": "A deliberate compare point: Mo works, but the monotone right-endpoint sweep is cleaner and should still be preferred." }, { "slug": "data-structures/odt-chtholly", "topic": "Data Structures -> ODT / Chtholly", "title": "896C - Willem, Chtholly and Seniorious", "url": "https://codeforces.com/problemset/problem/896/C?mobile=true", "source": "Codeforces", "difficulty": "hard", "tracks": [ "Interval-Partition" ], "tags": [ "Range Assign", "Ordered Set", "Expected Complexity", "Kth Query" ], "styles": [ "Data-Structure-Heavy", "Implementation", "Randomized-Input" ], "prerequisites": [ "Ordered Set Iteration", "Split(l) / Split(r + 1)", "Range Assign" ], "bucket": "core", "why_fit": "The canonical Chtholly-tree benchmark where split, assign, and interval walks over the current runs are the whole model." }, { "slug": "data-structures/odt-chtholly", "topic": "Data Structures -> ODT / Chtholly", "title": "915E - Physical Education Lessons", "url": "https://codeforces.com/problemset/problem/915/E", "source": "Codeforces", "difficulty": "hard", "tracks": [ "Interval-Partition" ], "tags": [ "Range Assign", "Piecewise Constant", "Interval Counting" ], "styles": [ "Data-Structure-Heavy", "Query-Heavy" ], "prerequisites": [ "Ordered Set Iteration", "Range Assign", "Current Interval Partition" ], "bucket": "bridge", "why_fit": "A clean deterministic bridge where interval assign and counting over the current partition are the real invariants even without the full CF896C random-data flavor." }, { "slug": "data-structures/offline-tricks", "topic": "Data Structures -> Offline Tricks", "title": "Static Range Count Distinct", "url": "https://judge.yosupo.jp/problem/static_range_count_distinct", "source": "Library Checker", "difficulty": "hard", "tracks": [], "tags": [ "Mo's Algorithm", "Distinct-Count" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Official Mo's algorithm benchmark." }, { "slug": "data-structures/offline-tricks", "topic": "Data Structures -> Offline Tricks", "title": "Point Add Rectangle Sum", "url": "https://judge.yosupo.jp/problem/point_add_rectangle_sum", "source": "Library Checker", "difficulty": "very-hard", "tracks": [], "tags": [ "Sweep Line", "Fenwick" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Canonical offline sweep-line plus BIT." }, { "slug": "data-structures/offline-tricks", "topic": "Data Structures -> Offline Tricks", "title": "Distinct Values Queries", "url": "https://cses.fi/problemset/task/1734", "source": "CSES", "difficulty": "hard", "tracks": [], "tags": [ "Mo's Algorithm", "Range-Distinct", "Frequency" ], "styles": [ "Query-Heavy", "Data-Structure-Heavy" ], "prerequisites": [ "Mo's Algorithm", "Frequency Counts", "Offline Query Ordering" ], "bucket": "classic", "why_fit": "A canonical offline range-query problem and one of the best Mo's algorithm benchmarks." }, { "slug": "data-structures/offline-tricks", "topic": "Data Structures -> Offline Tricks", "title": "Powerful Array", "url": "https://codeforces.com/problemset/problem/86/D", "source": "Codeforces", "difficulty": "hard", "tracks": [], "tags": [ "Mo's Algorithm", "Range-Frequency" ], "styles": [ "Query-Heavy", "Data-Structure-Heavy" ], "prerequisites": [ "Mo's Algorithm", "Frequency Maintenance", "Range Queries" ], "bucket": "classic", "why_fit": "A famous Mo's algorithm benchmark with a memorable scoring function." }, { "slug": "data-structures/offline-tricks", "topic": "Data Structures -> Offline Tricks", "title": "Rectangle Sum", "url": "https://judge.yosupo.jp/problem/rectangle_sum", "source": "Library Checker", "difficulty": "medium", "tracks": [], "tags": [ "Sweep Line", "2D-Queries", "Fenwick" ], "styles": [ "Query-Heavy", "Modeling-Heavy" ], "prerequisites": [ "Offline Sweeps", "Fenwick Tree", "2D Range Counting" ], "bucket": "advanced", "why_fit": "A clean official benchmark for offline sweep-line style query processing." }, { "slug": "data-structures/offline-tricks", "topic": "Data Structures -> Offline Tricks", "title": "Distinct Values Queries II", "url": "https://cses.fi/problemset/task/3356", "source": "CSES", "difficulty": "hard", "tracks": [], "tags": [ "Updates", "Distinctness", "Query-Processing" ], "styles": [ "Query-Heavy", "Data-Structure-Heavy" ], "prerequisites": [ "Offline Thinking", "Fenwick Tree", "Last-Occurrence Reasoning" ], "bucket": "advanced", "why_fit": "A stronger follow-up that pushes the same distinctness theme into a dynamic setting." }, { "slug": "data-structures/offline-tricks", "topic": "Data Structures -> Offline Tricks", "title": "Salary Queries", "url": "https://cses.fi/problemset/task/1144", "source": "CSES", "difficulty": "medium", "tracks": [], "tags": [ "Coordinate-Compression", "Range-Count", "Updates", "Fenwick" ], "styles": [ "Query-Heavy", "Data-Structure-Heavy" ], "prerequisites": [ "Coordinate Compression", "Fenwick Tree", "Range Counting" ], "bucket": "cross-topic", "why_fit": "A very teachable query problem that often becomes much easier once values are compressed." }, { "slug": "data-structures/pairing-leftist-heap", "topic": "Data Structures -> Pairing Heap / Leftist Heap", "title": "P3377 [Template] Mergeable Heap 1", "url": "https://www.luogu.com.cn/problem/P3377", "source": "Luogu", "difficulty": "medium", "tracks": [ "Meldable-Heap", "Leftist-Heap" ], "tags": [ "Delete Min", "DSU", "Simulation" ], "styles": [ "Data-Structure-Heavy", "Implementation" ], "prerequisites": [ "Priority Queues", "Heap Merge", "Owner Tracking" ], "bucket": "core", "why_fit": "The cleanest verifier-style first rep where every item starts in its own heap, heaps meld online, and delete-min is asked by naming one item's current heap." }, { "slug": "data-structures/pairing-leftist-heap", "topic": "Data Structures -> Pairing Heap / Leftist Heap", "title": "P1456 Monkey King", "url": "https://www.luogu.com.cn/problem/P1456", "source": "Luogu", "difficulty": "hard", "tracks": [ "Meldable-Heap" ], "tags": [ "Leftist Heap", "Heap Merge" ], "styles": [ "Data-Structure-Heavy", "Implementation" ], "prerequisites": [ "Heap Merge", "Delete Min", "Owner Tracking" ], "bucket": "challenge", "why_fit": "A classic follow-up where the same meldable-heap route survives after each duel mutates the current roots before the heaps merge again." }, { "slug": "data-structures/pbds-order-statistics", "topic": "Data Structures -> PBDS / Order Statistics Tree", "title": "ORDERSET - Order Statistic Set", "url": "https://www.spoj.com/problems/ORDERSET/", "source": "SPOJ", "difficulty": "medium", "tracks": [ "Order Statistics" ], "tags": [ "Kth-Smallest", "Rank-Query" ], "styles": [ "Data-Structure-Heavy", "Classic" ], "prerequisites": [ "Ordered Set Invariant", "Order Of Key", "Find By Order" ], "bucket": "core", "why_fit": "The cleanest first benchmark where the whole problem is insert, delete, k-th, and count-smaller on one dynamic ordered set." }, { "slug": "data-structures/pbds-order-statistics", "topic": "Data Structures -> PBDS / Order Statistics Tree", "title": "Josephus Problem II", "url": "https://cses.fi/problemset/task/2163", "source": "CSES", "difficulty": "hard", "tracks": [ "Circular Elimination" ], "tags": [ "Find-By-Order", "Josephus" ], "styles": [ "Simulation-Heavy", "Data-Structure-Heavy" ], "prerequisites": [ "Find By Order", "Alive Set Maintenance", "Modulo Indexing" ], "bucket": "practice", "why_fit": "A clean follow-up where the alive set stays explicit and find_by_order drives repeated circular removals." }, { "slug": "data-structures/pbds-order-statistics", "topic": "Data Structures -> PBDS / Order Statistics Tree", "title": "Salary Queries", "url": "https://cses.fi/problemset/task/1144", "source": "CSES", "difficulty": "medium", "tracks": [ "Order Statistics" ], "tags": [ "Duplicate-Safe-Wrapper", "Range-Count" ], "styles": [ "Query-Heavy", "Data-Structure-Heavy" ], "prerequisites": [ "Pair-Key Wrapper", "Order Of Key", "Count In Range" ], "bucket": "bridge", "why_fit": "A very teachable bridge from unique sets to duplicate-safe pair-key wrappers for count-in-range queries under updates." }, { "slug": "data-structures/persistent-data-structures", "topic": "Data Structures -> Persistent Data Structures", "title": "Range Queries and Copies", "url": "https://cses.fi/problemset/task/1737", "source": "CSES", "difficulty": "hard", "tracks": [ "Persistent Segment Tree" ], "tags": [ "Path-Copying", "Version-Roots", "Range-Sum" ], "styles": [ "Data-Structure-Heavy", "Versioned Queries" ], "prerequisites": [ "Segment Tree", "Point Update", "Path Copying" ], "bucket": "core", "why_fit": "The cleanest first exact benchmark where each point update creates a new segment-tree root and old versions stay queryable." }, { "slug": "data-structures/persistent-data-structures", "topic": "Data Structures -> Persistent Data Structures", "title": "K-th Number", "url": "https://www.spoj.com/problems/MKTHNUM/", "source": "SPOJ", "difficulty": "hard", "tracks": [ "Order Statistics", "Persistent Segment Tree" ], "tags": [ "Prefix-Versions" ], "styles": [ "Data-Structure-Heavy", "Value Compression" ], "prerequisites": [ "Coordinate Compression", "Prefix Version Difference" ], "bucket": "stretch", "why_fit": "The classic stretch problem once path copying is trusted and the persistent tree stores frequencies instead of plain sums." }, { "slug": "data-structures/persistent-data-structures", "topic": "Data Structures -> Persistent Data Structures", "title": "Persistent Union Find", "url": "https://judge.yosupo.jp/problem/persistent_unionfind", "source": "Library Checker", "difficulty": "hard", "tracks": [ "Persistent Union Find" ], "tags": [ "Persistence", "Versioned Connectivity" ], "styles": [ "Verification", "Versioned Queries" ], "prerequisites": [ "Persistence Worldview", "Version Handles", "DSU Basics" ], "bucket": "challenge", "why_fit": "A family-broadening verifier showing that the persistent worldview is larger than segment-tree snapshots alone." }, { "slug": "data-structures/persistent-treap", "topic": "Data Structures -> Persistent Treap", "title": "Persistent List", "url": "https://eolymp.com/en/problems/2957", "source": "E-olymp", "difficulty": "hard", "tracks": [ "Implicit Treap", "Persistence" ], "tags": [ "Split-Merge", "Branching-Versions", "Sequence-Persistence" ], "styles": [ "Data-Structure-Heavy", "Modeling-Heavy" ], "prerequisites": [ "Split And Merge" ], "bucket": "core", "why_fit": "The cleanest first benchmark where merge/head/tail on old list roots force persistent split/merge treap rather than fixed-array path copying." }, { "slug": "data-structures/segment-tree", "topic": "Data Structures -> Segment Tree", "title": "Dynamic Range Minimum Queries", "url": "https://cses.fi/problemset/task/1649", "source": "CSES", "difficulty": "medium", "tracks": [], "tags": [ "Range-Min", "Point-Update" ], "styles": [ "Data-Structure-Heavy" ], "prerequisites": [ "Segment Tree Basics", "Min Monoid", "Updates" ], "bucket": "core", "why_fit": "A direct min-query counterpart to the range-sum baseline." }, { "slug": "data-structures/segment-tree", "topic": "Data Structures -> Segment Tree", "title": "Dynamic Range Sum Queries", "url": "https://cses.fi/problemset/task/1648", "source": "CSES", "difficulty": "medium", "tracks": [], "tags": [ "Point-Update", "Range-Sum" ], "styles": [ "Data-Structure-Heavy", "Query-Heavy" ], "prerequisites": [ "Segment Tree Basics", "Range Aggregation", "Updates" ], "bucket": "core", "why_fit": "A standard point-update/range-query baseline for segment trees." }, { "slug": "data-structures/segment-tree", "topic": "Data Structures -> Segment Tree", "title": "Hotel Queries", "url": "https://cses.fi/problemset/task/1143", "source": "CSES", "difficulty": "medium", "tracks": [], "tags": [ "First-Fit", "Prefix-Max", "Max-Query" ], "styles": [ "Data-Structure-Heavy", "Greedy-Heavy" ], "prerequisites": [ "Segment Tree", "Binary Search On Tree", "Greedy Assignment" ], "bucket": "classic", "why_fit": "A classic first-position query problem that is very segment-tree friendly." }, { "slug": "data-structures/segment-tree", "topic": "Data Structures -> Segment Tree", "title": "Prefix Sum Queries", "url": "https://cses.fi/problemset/task/2166", "source": "CSES", "difficulty": "hard", "tracks": [], "tags": [ "Prefix-Max", "Range-Query" ], "styles": [ "Query-Heavy", "Data-Structure-Heavy" ], "prerequisites": [ "Segment Trees", "Prefix Sums", "Max-Prefix Maintenance" ], "bucket": "classic", "why_fit": "A strong benchmark for maintaining multiple aggregate values per segment." }, { "slug": "data-structures/segment-tree", "topic": "Data Structures -> Segment Tree", "title": "Point Set Range Composite", "url": "https://judge.yosupo.jp/problem/point_set_range_composite", "source": "Library Checker", "difficulty": "hard", "tracks": [], "tags": [ "Function-Composition" ], "styles": [ "Query-Heavy", "Data-Structure-Heavy" ], "prerequisites": [ "Segment Tree", "Monoids", "Function Composition" ], "bucket": "advanced", "why_fit": "A strong official benchmark for monoid segment trees beyond numeric aggregates." }, { "slug": "data-structures/segment-tree", "topic": "Data Structures -> Segment Tree", "title": "Polynomial Queries", "url": "https://cses.fi/problemset/task/1736", "source": "CSES", "difficulty": "hard", "tracks": [], "tags": [ "Lazy-Propagation", "Range-Add", "Arithmetic-Progression", "Range-Update" ], "styles": [ "Data-Structure-Heavy", "Math-Heavy" ], "prerequisites": [ "Lazy Propagation", "Segment Trees", "Range Arithmetic" ], "bucket": "advanced", "why_fit": "A memorable advanced benchmark for non-uniform range updates and sum queries." }, { "slug": "data-structures/segment-tree", "topic": "Data Structures -> Segment Tree", "title": "Range Updates and Sums", "url": "https://cses.fi/problemset/task/1735", "source": "CSES", "difficulty": "hard", "tracks": [], "tags": [ "Lazy-Propagation", "Range-Add", "Range-Assign" ], "styles": [ "Data-Structure-Heavy" ], "prerequisites": [ "Lazy Propagation", "Segment Tree Merges", "Range Updates" ], "bucket": "advanced", "why_fit": "A high-value lazy-propagation benchmark with both add and assign operations." }, { "slug": "data-structures/segment-tree", "topic": "Data Structures -> Segment Tree", "title": "Subarray Sum Queries", "url": "https://cses.fi/problemset/task/1190", "source": "CSES", "difficulty": "hard", "tracks": [], "tags": [ "Max-Subarray", "Point-Update" ], "styles": [ "Data-Structure-Heavy", "Query-Heavy" ], "prerequisites": [ "Segment Trees", "Kadane-Style Merging", "Point Updates" ], "bucket": "advanced", "why_fit": "A classic advanced segment-tree problem for storing subarray summary states." }, { "slug": "data-structures/segment-tree-beats", "topic": "Data Structures -> Segment Tree Beats", "title": "Range Chmin Chmax Add Range Sum", "url": "https://judge.yosupo.jp/problem/range_chmin_chmax_add_range_sum", "source": "Library Checker", "difficulty": "hard", "tracks": [ "Range Queries" ], "tags": [ "Range-Chmin", "Range-Chmax", "Range-Add" ], "styles": [ "Data-Structure-Heavy", "Verification" ], "prerequisites": [ "Lazy Segment Tree", "Second Extremum Summaries", "Amortized Pushdown" ], "bucket": "core", "why_fit": "The cleanest official verifier for the exact canonical beats starter shipped in this repo." }, { "slug": "data-structures/segment-tree-beats", "topic": "Data Structures -> Segment Tree Beats", "title": "The Child and Sequence", "url": "https://codeforces.com/problemset/problem/438/D", "source": "Codeforces", "difficulty": "hard", "tracks": [ "Compare Point" ], "tags": [ "Beats-Like-Pruning", "Range-Modulo", "Range-Sum" ], "styles": [ "Data-Structure-Heavy", "Compare-Point" ], "prerequisites": [ "Segment Tree", "Current Maximum Pruning", "Amortized Reasoning" ], "bucket": "bridge", "why_fit": "The classic compare point where the same pruning mindset appears, but the exact canonical chmin/chmax/add/sum starter does not apply directly." }, { "slug": "data-structures/skip-lists", "topic": "Data Structures -> Skip Lists", "title": "Skiplist Dictionary Benchmark", "url": "https://opendatastructures.org/ods-cpp/4_1_Basic_Structure.html", "source": "Open Data Structures", "difficulty": "medium", "tracks": [ "Skiplist", "Textbook Breadth" ], "tags": [ "Random Heights", "Expected Logarithmic" ], "styles": [ "Data-Structure-Heavy", "Implementation-Heavy" ], "prerequisites": [ "Random Height", "Update Array", "Tower Search Path" ], "bucket": "core", "why_fit": "A clean breadth benchmark where the whole lesson is probabilistic balancing through forward-pointer towers and one update[] search path, not contest-first rank queries or split/merge." }, { "slug": "data-structures/sparse-table", "topic": "Data Structures -> Sparse Table", "title": "Static Range Minimum Queries", "url": "https://cses.fi/problemset/task/1647", "source": "CSES", "difficulty": "easy", "tracks": [], "tags": [ "Range-Min", "Static-Queries", "Idempotent" ], "styles": [ "Query-Heavy", "Data-Structure-Heavy" ], "prerequisites": [ "Idempotent Operations", "Range Queries", "Preprocessing" ], "bucket": "core", "why_fit": "The textbook static RMQ problem that sparse tables are built for." }, { "slug": "data-structures/sparse-table", "topic": "Data Structures -> Sparse Table", "title": "Range GCD Query", "url": "https://judge.yosupo.jp/problem/range_gcd_query", "source": "Library Checker", "difficulty": "medium", "tracks": [], "tags": [ "GCD", "Idempotent" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Same sparse-table idea with gcd aggregation." }, { "slug": "data-structures/sparse-table", "topic": "Data Structures -> Sparse Table", "title": "Static RMQ", "url": "https://judge.yosupo.jp/problem/staticrmq", "source": "Library Checker", "difficulty": "easy", "tracks": [], "tags": [ "Range-Min", "Idempotent" ], "styles": [ "Query-Heavy" ], "prerequisites": [ "Sparse Table", "Idempotent Queries", "Preprocessing" ], "bucket": "classic", "why_fit": "A concise official benchmark for validating a sparse table implementation." }, { "slug": "data-structures/splay-tree", "topic": "Data Structures -> Splay Tree", "title": "Luogu P3369 - 普通平衡树", "url": "https://www.luogu.com.cn/problem/P3369", "source": "Luogu", "difficulty": "hard", "tracks": [ "Order Statistics" ], "tags": [ "Rank-Query", "Kth-Smallest", "Predecessor-Successor" ], "styles": [ "Data-Structure-Heavy", "Implementation-Heavy" ], "prerequisites": [ "Bst Order", "Subtree Sizes", "Rotate And Splay" ], "bucket": "core", "why_fit": "The cleanest first benchmark where the whole statement is one self-adjusting ordered multiset interface and the splay machinery itself is the lesson." }, { "slug": "data-structures/splay-tree", "topic": "Data Structures -> Splay Tree", "title": "Luogu P3391 - 文艺平衡树", "url": "https://www.luogu.com.cn/problem/P3391", "source": "Luogu", "difficulty": "hard", "tracks": [ "Sequence Route" ], "tags": [ "Sequence", "Reverse-Interval" ], "styles": [ "Data-Structure-Heavy", "String-Like" ], "prerequisites": [ "Rotate And Splay", "Lazy Reversal Tag", "Sequence View" ], "bucket": "stretch", "why_fit": "A natural stretch once ordered-set splaying is stable and you want to see the same rotation machinery move into sequence edits with lazy reversal." }, { "slug": "data-structures/splay-tree", "topic": "Data Structures -> Splay Tree", "title": "ORDERSET - Order Statistic Set", "url": "https://www.spoj.com/problems/ORDERSET/", "source": "SPOJ", "difficulty": "medium", "tracks": [ "Compare Route" ], "tags": [ "Order-Statistics" ], "styles": [ "Data-Structure-Heavy", "Classic" ], "prerequisites": [ "Rotate And Splay", "Rank Queries", "K-Th Queries" ], "bucket": "compare", "why_fit": "A useful compare rep once the splay implementation is trusted, because the same interface can then be contrasted directly against PBDS." }, { "slug": "data-structures/treap-implicit", "topic": "Data Structures -> Treap / Implicit Treap", "title": "Salary Queries", "url": "https://cses.fi/problemset/task/1144", "source": "CSES", "difficulty": "medium", "tracks": [ "Key-Based Treap", "Order Statistics" ], "tags": [ "Range-Count", "Pair-Key-Wrapper" ], "styles": [ "Data-Structure-Heavy", "Query-Heavy" ], "prerequisites": [ "Split And Merge", "Pair Key Wrapper" ], "bucket": "core", "why_fit": "A strong first key-based benchmark where duplicate-safe pair keys and rank differences are the whole story." }, { "slug": "data-structures/treap-implicit", "topic": "Data Structures -> Treap / Implicit Treap", "title": "Cut and Paste", "url": "https://cses.fi/problemset/task/2072", "source": "CSES", "difficulty": "hard", "tracks": [ "Implicit Treap", "Sequence Surgery" ], "tags": [ "Split-Merge", "Sequence-Edits" ], "styles": [ "Data-Structure-Heavy", "Modeling-Heavy" ], "prerequisites": [ "Split And Merge", "Subtree Sizes", "Implicit Position" ], "bucket": "practice", "why_fit": "The cleanest first benchmark where cut/paste by position becomes a short split/merge script." }, { "slug": "data-structures/treap-implicit", "topic": "Data Structures -> Treap / Implicit Treap", "title": "Substring Reversals", "url": "https://cses.fi/problemset/task/2073", "source": "CSES", "difficulty": "hard", "tracks": [ "Implicit Treap", "Sequence Lazy Tags" ], "tags": [ "Reverse", "Lazy-Tag" ], "styles": [ "Data-Structure-Heavy", "String-Like" ], "prerequisites": [ "Split And Merge", "Lazy Reversal Tag" ], "bucket": "practice", "why_fit": "A direct follow-up once split/merge is trusted and one reverse tag becomes the next natural extension." }, { "slug": "data-structures/treap-implicit", "topic": "Data Structures -> Treap / Implicit Treap", "title": "Dynamic Sequence Range Affine Range Sum", "url": "https://judge.yosupo.jp/problem/dynamic_sequence_range_affine_range_sum", "source": "Library Checker", "difficulty": "very-hard", "tracks": [ "Implicit Treap", "Advanced" ], "tags": [ "Affine-Lazy", "Range-Sum" ], "styles": [ "Data-Structure-Heavy", "Verification" ], "prerequisites": [ "Lazy Propagation", "Split And Merge" ], "bucket": "stretch", "why_fit": "The canonical verifier-style stretch once the implicit-treap family is extended with aggregates and lazy tags." }, { "slug": "data-structures/wavelet-tree", "topic": "Data Structures -> Wavelet Tree", "title": "MKTHNUM - K-th Number", "url": "https://www.spoj.com/problems/MKTHNUM/", "source": "SPOJ", "difficulty": "hard", "tracks": [ "Order Statistics" ], "tags": [ "Range-Kth", "Static-Queries" ], "styles": [ "Query-Heavy", "Data-Structure-Heavy" ], "prerequisites": [ "Coordinate Compression", "Wavelet Tree", "Range Order Statistics" ], "bucket": "core", "why_fit": "The canonical first static range k-th-smallest problem and the cleanest first benchmark for this lane." }, { "slug": "data-structures/wavelet-tree", "topic": "Data Structures -> Wavelet Tree", "title": "Range K-th Smallest", "url": "https://judge.yosupo.jp/problem/range_kth_smallest", "source": "Library Checker", "difficulty": "hard", "tracks": [], "tags": [ "Range-Kth" ], "styles": [ "Query-Heavy", "Data-Structure-Heavy" ], "prerequisites": [ "Wavelet Tree", "Coordinate Compression", "Static Queries" ], "bucket": "practice", "why_fit": "An official verifier-style benchmark once the basic wavelet-tree descent is trusted." }, { "slug": "data-structures/wavelet-tree", "topic": "Data Structures -> Wavelet Tree", "title": "K-query", "url": "https://www.spoj.com/problems/KQUERY/", "source": "SPOJ", "difficulty": "hard", "tracks": [ "Threshold Counting", "Classic" ], "tags": [ "Threshold-Count" ], "styles": [ "Query-Heavy", "Classic" ], "prerequisites": [ "Wavelet Tree", "Range Counting", "Coordinate Compression" ], "bucket": "classic", "why_fit": "A classic follow-up showing the same lane extends naturally from k-th queries to value-threshold counts." }, { "slug": "data-structures/x-fast-y-fast-tries", "topic": "Data Structures -> X-Fast / Y-Fast Tries", "title": "X-Fast Dictionary Benchmark", "url": "https://opendatastructures.org/newhtml/ods/latex/integers.html", "source": "Open Data Structures", "difficulty": "hard", "tracks": [ "X-Fast Trie", "Textbook Breadth" ], "tags": [ "Bounded-Universe", "Prefix-Hashing", "Predecessor-Successor" ], "styles": [ "Data-Structure-Heavy", "Implementation-Heavy" ], "prerequisites": [ "Bounded Universe", "Deepest Existing Prefix", "Leaf Linked Order" ], "bucket": "core", "why_fit": "A clean breadth benchmark where the whole lesson is bounded-universe predecessor / successor through deepest-existing-prefix search and leaf-linked order, before y-fast bucket sampling is layered in." }, { "slug": "dp/bit-parallelism", "topic": "DP -> Bit-Parallelism / Bitset Optimization", "title": "School Excursion", "url": "https://cses.fi/problemset/task/1706/", "source": "CSES", "difficulty": "hard", "tracks": [ "Bitset DP" ], "tags": [ "Bitset", "Reachability", "Component Sizes", "Subset Sum" ], "styles": [ "Dynamic Programming", "Implementation", "Graph Modeling" ], "prerequisites": [ "DSU", "Boolean DP", "Shift-Or Reachability" ], "bucket": "core", "why_fit": "The clean flagship where a light DSU reduction produces one subset-sum reachability row and the intended implementation win is packed bitset shift-OR." }, { "slug": "dp/bit-parallelism", "topic": "DP -> Bit-Parallelism / Bitset Optimization", "title": "Money Sums", "url": "https://cses.fi/problemset/task/1745/", "source": "CSES", "difficulty": "easy", "tracks": [ "Subset Sum" ], "tags": [ "Bitset", "Reachable Sums", "Boolean DP" ], "styles": [ "Dynamic Programming", "Implementation" ], "prerequisites": [ "Boolean DP", "Shift-Or Reachability" ], "bucket": "stretch", "why_fit": "A smaller warm-up where the same packed reachability update is already clean even if ordinary scalar DP still exists." }, { "slug": "dp/bitmask-dp", "topic": "DP -> Bitmask DP", "title": "Travelling Salesman Problem", "url": "https://atcoder.jp/contests/abc406/tasks/abc406_g", "source": "AtCoder Beginner Contest 406", "difficulty": "hard", "tracks": [], "tags": [ "TSP" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "canonical TSP with visited-set state" }, { "slug": "dp/bitmask-dp", "topic": "DP -> Bitmask DP", "title": "Moovie Mooving", "url": "https://usaco.org/index.php?cpid=515&page=viewproblem2", "source": "USACO Gold", "difficulty": "medium", "tracks": [ "Coverage-DP" ], "tags": [ "Interval-Coverage" ], "styles": [ "Tabulation" ], "prerequisites": [ "Bitmask States", "Interval Reasoning" ], "bucket": "covering-with-subsets", "why_fit": "Uses subset state to model which movies have been chosen and how far coverage extends." }, { "slug": "dp/bitmask-dp", "topic": "DP -> Bitmask DP", "title": "Redistributing Gifts", "url": "https://usaco.org/index.php?cpid=1209&page=viewproblem2", "source": "USACO Gold", "difficulty": "hard", "tracks": [ "Assignment-DP" ], "tags": [ "Permutations" ], "styles": [ "Tabulation" ], "prerequisites": [ "Matching DP", "Subset Transitions" ], "bucket": "gift-reassignment", "why_fit": "A strong bitmask assignment problem where feasibility is driven by subset reachability." }, { "slug": "dp/bitmask-dp", "topic": "DP -> Bitmask DP", "title": "Hamiltonian Flights", "url": "https://cses.fi/problemset/task/1690", "source": "CSES", "difficulty": "hard", "tracks": [ "Graph-Subset-DP" ], "tags": [ "Graph", "State Compression", "Hamiltonian Path" ], "styles": [ "Tabulation" ], "prerequisites": [ "Graph Basics", "Subset Iteration" ], "bucket": "hamiltonian-path-counting", "why_fit": "visit-every-node exactly once" }, { "slug": "dp/bitmask-dp", "topic": "DP -> Bitmask DP", "title": "Grouping", "url": "https://atcoder.jp/contests/dp/tasks/dp_u", "source": "AtCoder DP Contest", "difficulty": "hard", "tracks": [ "Subset-Partition" ], "tags": [ "Partition" ], "styles": [ "Tabulation" ], "prerequisites": [ "Subset Iteration", "Memoization" ], "bucket": "merge-subsets", "why_fit": "A clean example of combining masks by iterating over all strict subsets." }, { "slug": "dp/bitmask-dp", "topic": "DP -> Bitmask DP", "title": "Smallest Sufficient Team", "url": "https://leetcode.com/problems/smallest-sufficient-team", "source": "LeetCode", "difficulty": "hard", "tracks": [ "Cover-DP" ], "tags": [ "Set-Cover" ], "styles": [ "Tabulation" ], "prerequisites": [ "Bitmask States", "Set Cover Intuition" ], "bucket": "minimum-cover", "why_fit": "A compact bitmask cover DP that is excellent for practicing subset-to-solution reconstruction." }, { "slug": "dp/bitmask-dp", "topic": "DP -> Bitmask DP", "title": "Matching", "url": "https://atcoder.jp/contests/dp/tasks/dp_o", "source": "AtCoder DP Contest", "difficulty": "medium", "tracks": [ "Assignment-DP" ], "tags": [ "Matching", "Assignment", "State Compression", "Perfect Matching" ], "styles": [ "Tabulation" ], "prerequisites": [ "Bitmask States", "Combinatorics" ], "bucket": "perfect-matching-count", "why_fit": "A textbook assignment DP where masks naturally represent assigned rows or columns." }, { "slug": "dp/bitmask-dp", "topic": "DP -> Bitmask DP", "title": "Guard Mark", "url": "https://usaco.org/index.php?cpid=494&page=viewproblem2", "source": "USACO Gold", "difficulty": "medium", "tracks": [ "Subset-Selection" ], "tags": [ "Stacking" ], "styles": [ "Tabulation" ], "prerequisites": [ "Subset DP", "Sorting" ], "bucket": "safety-constrained-subset", "why_fit": "A classic small-n bitmask problem where each subset carries a summary of feasibility and quality." }, { "slug": "dp/bitmask-dp", "topic": "DP -> Bitmask DP", "title": "Friendship Editing", "url": "https://usaco.org/index.php?cpid=1499&page=viewproblem2", "source": "USACO Gold", "difficulty": "hard", "tracks": [ "Graph-Subset-DP" ], "tags": [ "Graphs" ], "styles": [ "Tabulation" ], "prerequisites": [ "Graph States", "Subset Enumeration" ], "bucket": "small-n-graph-editing", "why_fit": "A good hard-level subset graph DP where every candidate structure is evaluated on masks." }, { "slug": "dp/bitmask-dp", "topic": "DP -> Bitmask DP", "title": "Shortest Path Visiting All Nodes", "url": "https://leetcode.com/problems/shortest-path-visiting-all-nodes", "source": "LeetCode", "difficulty": "hard", "tracks": [ "Graph-Search" ], "tags": [ "BFS" ], "styles": [ "BFS", "State-Compression" ], "prerequisites": [ "Graph Traversal", "Shortest Path Basics" ], "bucket": "state-compressed-traversal", "why_fit": "A very common state-compressed shortest-path problem that pairs naturally with bitmask DP thinking." }, { "slug": "dp/bitmask-dp", "topic": "DP -> Bitmask DP", "title": "Elevator Rides", "url": "https://cses.fi/problemset/task/1653", "source": "CSES", "difficulty": "hard", "tracks": [ "Subset-Packaging" ], "tags": [ "Packing", "Subset DP" ], "styles": [ "Tabulation" ], "prerequisites": [ "Subset Sum", "State Compression" ], "bucket": "subset-packing", "why_fit": "classic compressed-state packing DP" }, { "slug": "dp/broken-profile", "topic": "DP -> Broken Profile / Plug DP", "title": "Counting Tilings", "url": "https://cses.fi/problemset/task/2181", "source": "CSES", "difficulty": "hard", "tracks": [ "Grid DP" ], "tags": [ "Domino Tiling", "Frontier Mask", "Column Sweep" ], "styles": [ "Counting", "Frontier DP" ], "prerequisites": [ "Bitmask Basics", "Local Placements" ], "bucket": "core", "why_fit": "The cleanest first verifier for occupancy-mask profile DP on a small-width grid." }, { "slug": "dp/broken-profile", "topic": "DP -> Broken Profile / Plug DP", "title": "Compound Escape", "url": "https://usaco.org/index.php?cpid=949&page=viewproblem2", "source": "USACO Platinum", "difficulty": "very-hard", "tracks": [ "Plug-DP" ], "tags": [ "Frontier State", "Counting", "Challenge" ], "styles": [ "Counting", "Frontier DP" ], "prerequisites": [ "Occupancy Masks", "Grid Frontier Thinking" ], "bucket": "challenge", "why_fit": "A challenge-level extension once simple occupancy masks are no longer the only frontier information you can reason about." }, { "slug": "dp/cht-li-chao", "topic": "DP -> Convex Hull Trick / Li Chao Tree", "title": "Line Add Get Min", "url": "https://judge.yosupo.jp/problem/line_add_get_min", "source": "Library Checker", "difficulty": "medium", "tracks": [ "Line Container" ], "tags": [ "Point Queries" ], "styles": [ "Implementation", "Verification" ], "prerequisites": [ "Line Evaluation", "Lower Envelope Breakpoints" ], "bucket": "core", "why_fit": "The most direct official verifier for the exact full-domain LineContainer route under the affine line-container family." }, { "slug": "dp/cht-li-chao", "topic": "DP -> Convex Hull Trick / Li Chao Tree", "title": "Monster Game I", "url": "https://cses.fi/problemset/task/2084", "source": "CSES", "difficulty": "hard", "tracks": [ "Convex Hull Trick" ], "tags": [ "Affine DP", "Monotone Hull", "Line Container" ], "styles": [ "Optimization", "Monotone Structure" ], "prerequisites": [ "Affine DP Transform", "Slope / Query Monotonicity" ], "bucket": "core", "why_fit": "The clean compare-point problem where the same affine DP family still admits a lighter monotone-hull route." }, { "slug": "dp/cht-li-chao", "topic": "DP -> Convex Hull Trick / Li Chao Tree", "title": "Monster Game II", "url": "https://cses.fi/problemset/task/2085", "source": "CSES", "difficulty": "hard", "tracks": [ "Li Chao Tree" ], "tags": [ "Affine DP", "Line Container" ], "styles": [ "Optimization", "Data-Structure-Heavy" ], "prerequisites": [ "Affine DP Transform", "Line Evaluation" ], "bucket": "core", "why_fit": "The cleanest flagship for generic online min queries over lines with arbitrary insertion/query order." }, { "slug": "dp/cht-li-chao", "topic": "DP -> Convex Hull Trick / Li Chao Tree", "title": "Segment Add Get Min", "url": "https://judge.yosupo.jp/problem/segment_add_get_min", "source": "Library Checker", "difficulty": "hard", "tracks": [ "Li Chao Tree", "Segment Li Chao" ], "tags": [ "Segment-Limited Lines", "Advanced" ], "styles": [ "Implementation", "Verification" ], "prerequisites": [ "Segment Tree Thinking" ], "bucket": "challenge", "why_fit": "The next-layer verifier once the basic full-domain Li Chao route is trusted and line activity ranges matter." }, { "slug": "dp/digit-dp", "topic": "DP -> Digit DP", "title": "Almost Everywhere Zero", "url": "https://atcoder.jp/contests/abc154/tasks/abc154_e", "source": "AtCoder Beginner Contest 154", "difficulty": "medium", "tracks": [], "tags": [ "Tight DP", "Count Digits" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "count numbers by non-zero digit count" }, { "slug": "dp/digit-dp", "topic": "DP -> Digit DP", "title": "Digit Sum", "url": "https://atcoder.jp/contests/dp/tasks/dp_s", "source": "AtCoder DP Contest", "difficulty": "medium", "tracks": [], "tags": [ "Tight DP", "Mod Sum" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "classic tight digit DP" }, { "slug": "dp/digit-dp", "topic": "DP -> Digit DP", "title": "Digit Products", "url": "https://atcoder.jp/contests/abc208/tasks/abc208_e", "source": "AtCoder Beginner Contest 208", "difficulty": "hard", "tracks": [], "tags": [ "Tight DP", "Digit Product" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "digit DP with product constraint" }, { "slug": "dp/digit-dp", "topic": "DP -> Digit DP", "title": "Digit Sum Divisible", "url": "https://atcoder.jp/contests/abc336/tasks/abc336_e", "source": "AtCoder Beginner Contest 336", "difficulty": "hard", "tracks": [], "tags": [ "Tight DP", "Sum+Remainder" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "strong digit-DP state compression" }, { "slug": "dp/digit-dp", "topic": "DP -> Digit DP", "title": "Counting Numbers", "url": "https://cses.fi/problemset/task/2220", "source": "CSES", "difficulty": "medium", "tracks": [ "Tight-DP" ], "tags": [ "Tight", "Adjacency Constraint" ], "styles": [ "Memoization", "Tabulation" ], "prerequisites": [ "Leading Zeros", "State Compression" ], "bucket": "adjacent-digit-constraints", "why_fit": "tight DP with forbidden adjacent equals" }, { "slug": "dp/digit-dp", "topic": "DP -> Digit DP", "title": "Find Integers", "url": "https://leetcode.com/problems/find-integers", "source": "LeetCode", "difficulty": "medium", "tracks": [ "Binary-DP" ], "tags": [ "Binary", "Fibonacci-Like" ], "styles": [ "Memoization" ], "prerequisites": [ "Binary Representation", "State Transition" ], "bucket": "binary-digit-dp", "why_fit": "A nice non-decimal digit DP that shows the same idea works on binary digits too." }, { "slug": "dp/digit-dp", "topic": "DP -> Digit DP", "title": "Numbers At Most N Given Digit Set", "url": "https://leetcode.com/problems/numbers-at-most-n-given-digit-set", "source": "LeetCode", "difficulty": "medium", "tracks": [ "Counting" ], "tags": [ "Combinatorics" ], "styles": [ "Memoization" ], "prerequisites": [ "Place-Value Reasoning", "Combinatorics" ], "bucket": "bounded-digit-set", "why_fit": "A very approachable digit-style counting problem that is often solved with a digit DP mindset." }, { "slug": "dp/digit-dp", "topic": "DP -> Digit DP", "title": "Numbers With Repeated Digits", "url": "https://leetcode.com/problems/numbers-with-repeated-digits", "source": "LeetCode", "difficulty": "hard", "tracks": [ "Unique-Digits" ], "tags": [ "Combinatorics" ], "styles": [ "Memoization" ], "prerequisites": [ "Count Special Integers", "Combinatorics" ], "bucket": "complement-counting", "why_fit": "A standard follow-up that reinforces counting the complement via digit-state enumeration." }, { "slug": "dp/digit-dp", "topic": "DP -> Digit DP", "title": "Beautiful Numbers", "url": "https://codeforces.com/problemset/problem/55/D", "source": "Codeforces", "difficulty": "very-hard", "tracks": [ "Prime-Mask-DP" ], "tags": [ "Number Theory" ], "styles": [ "Memoization" ], "prerequisites": [ "Digit DP Basics", "Number Theory" ], "bucket": "digit-dp-with-divisibility-masks", "why_fit": "A harder digit DP classic that adds a strong arithmetic twist to the usual tight-state structure." }, { "slug": "dp/digit-dp", "topic": "DP -> Digit DP", "title": "Segment Sum", "url": "https://codeforces.com/problemset/problem/1073/E", "source": "Codeforces", "difficulty": "very-hard", "tracks": [ "Range-Aggregation" ], "tags": [ "Sum" ], "styles": [ "Memoization" ], "prerequisites": [ "Digit DP Basics", "Prefix Sums" ], "bucket": "digit-dp-with-sums", "why_fit": "A stronger range-counting digit DP that mixes digit states with numeric aggregation." }, { "slug": "dp/digit-dp", "topic": "DP -> Digit DP", "title": "Count Special Integers", "url": "https://leetcode.com/problems/count-special-integers", "source": "LeetCode", "difficulty": "hard", "tracks": [ "Unique-Digits" ], "tags": [ "Bitmask" ], "styles": [ "Memoization" ], "prerequisites": [ "Tight State", "Bitmasking" ], "bucket": "no-repeated-digits", "why_fit": "A great bridge between digit DP and bitmasking because the repeated-digit constraint matters." }, { "slug": "dp/digit-dp", "topic": "DP -> Digit DP", "title": "Digit Sum", "url": "https://www.spoj.com/problems/DIGSUM", "source": "SPOJ", "difficulty": "medium", "tracks": [ "Range-Counting" ], "tags": [ "Sum" ], "styles": [ "Memoization" ], "prerequisites": [ "Tight State", "Prefix Digit Reasoning" ], "bucket": "range-digit-count", "why_fit": "A classic range-counting digit DP that makes the tight-bound idea feel concrete." }, { "slug": "dp/digit-dp", "topic": "DP -> Digit DP", "title": "Magic Numbers", "url": "https://codeforces.com/problemset/problem/628/D", "source": "Codeforces", "difficulty": "medium-hard", "tracks": [ "Mod-Constraint" ], "tags": [ "Mod" ], "styles": [ "Memoization" ], "prerequisites": [ "Modular Arithmetic", "Leading Zeros" ], "bucket": "restricted-digit-patterns", "why_fit": "A canonical digit DP where the digit choices are constrained by both adjacency and divisibility rules." }, { "slug": "dp/digit-dp", "topic": "DP -> Digit DP", "title": "Travelling Salesman and Special Numbers", "url": "https://codeforces.com/problemset/problem/914/C", "source": "Codeforces", "difficulty": "medium-hard", "tracks": [ "Counting" ], "tags": [], "styles": [ "Memoization" ], "prerequisites": [ "Tight State", "Digit Enumeration" ], "bucket": "special-number-counting", "why_fit": "A very common digit DP problem that reinforces how to count objects with digit-based restrictions." }, { "slug": "dp/digit-dp", "topic": "DP -> Digit DP", "title": "Rotated Digits", "url": "https://leetcode.com/problems/rotated-digits", "source": "LeetCode", "difficulty": "medium", "tracks": [ "Counting" ], "tags": [ "Rotation" ], "styles": [ "Memoization" ], "prerequisites": [ "Digit Filtering", "State Encoding" ], "bucket": "valid-digit-transforms", "why_fit": "Useful for learning how to track a small property of each digit while counting up to a bound." }, { "slug": "dp/divide-and-conquer-dp", "topic": "DP -> Divide and Conquer DP", "title": "Ciel and Gondolas", "url": "https://codeforces.com/problemset/problem/321/E", "source": "Codeforces", "difficulty": "very-hard", "tracks": [ "Partition DP" ], "tags": [ "Monotone Opt", "2D Prefix Sums", "Contiguous Groups" ], "styles": [ "Partition DP", "Cost Preprocessing", "Decision Monotonicity" ], "prerequisites": [ "Prefix Sums", "Monotone Argmins" ], "bucket": "core", "why_fit": "The canonical first benchmark where interval-cost preprocessing and monotone split decisions combine into one exact divide-and-conquer DP row optimization." }, { "slug": "dp/divide-and-conquer-dp", "topic": "DP -> Divide and Conquer DP", "title": "Yet Another Minimization Problem", "url": "https://codeforces.com/problemset/problem/868/F", "source": "Codeforces", "difficulty": "very-hard", "tracks": [ "Partition DP" ], "tags": [ "Monotone Opt", "Mo-Style Cost Maintenance", "Distinct Pair Cost" ], "styles": [ "Partition DP", "Cost Maintenance", "Decision Monotonicity" ], "prerequisites": [ "Divide And Conquer DP", "Incremental Cost Updates", "Two Pointers Or Mo Intuition" ], "bucket": "stretch", "why_fit": "A strong follow-up where the row optimization stays the same but the real challenge becomes maintaining the interval cost fast enough." }, { "slug": "dp/foundations", "topic": "DP -> Foundations", "title": "Grid 1", "url": "https://atcoder.jp/contests/dp/tasks/dp_h", "source": "AtCoder DP Contest", "difficulty": "easy-medium", "tracks": [ "Grid DP" ], "tags": [ "Path Counting" ], "styles": [ "Tabulation" ], "prerequisites": [ "2D Arrays", "Basic Counting" ], "bucket": "warm-up", "why_fit": "Warm-up grid counting DP before harder path variants." }, { "slug": "dp/foundations", "topic": "DP -> Foundations", "title": "LCS", "url": "https://atcoder.jp/contests/dp/tasks/dp_f", "source": "AtCoder DP Contest", "difficulty": "medium", "tracks": [ "String DP" ], "tags": [ "2D DP" ], "styles": [ "Tabulation" ], "prerequisites": [ "2D Arrays", "String Indexing" ], "bucket": "warm-up", "why_fit": "Warm-up 2D string DP before richer edit-style transitions." }, { "slug": "dp/foundations", "topic": "DP -> Foundations", "title": "Climbing Stairs", "url": "https://leetcode.com/problems/climbing-stairs", "source": "LeetCode", "difficulty": "easy", "tracks": [ "Linear DP" ], "tags": [ "Recurrence", "1D" ], "styles": [ "Memoization", "Tabulation" ], "prerequisites": [ "Basic Recursion", "Arrays" ], "bucket": "base-recurrence", "why_fit": "The canonical one-state recurrence: each step depends only on the previous one or two states." }, { "slug": "dp/foundations", "topic": "DP -> Foundations", "title": "Vacation", "url": "https://atcoder.jp/contests/dp/tasks/dp_c", "source": "AtCoder DP Contest", "difficulty": "easy", "tracks": [ "State DP" ], "tags": [ "Choices", "Day-By-Day", "2D DP", "Daily Choice" ], "styles": [ "Tabulation" ], "prerequisites": [ "Arrays", "Basic Recurrence" ], "bucket": "choice-states", "why_fit": "Introduces multi-state DP where each day carries a small fixed set of options." }, { "slug": "dp/foundations", "topic": "DP -> Foundations", "title": "House Robber", "url": "https://leetcode.com/problems/house-robber", "source": "LeetCode", "difficulty": "medium", "tracks": [ "Linear DP" ], "tags": [ "Skip-Take", "Optimization" ], "styles": [ "Tabulation", "Rolling-Array" ], "prerequisites": [ "Arrays", "Max/Min Reasoning" ], "bucket": "choose-or-skip", "why_fit": "A compact skip-take DP that is easy to derive and easy to optimize to O(1) space." }, { "slug": "dp/foundations", "topic": "DP -> Foundations", "title": "Dice Combinations", "url": "https://cses.fi/problemset/task/1633", "source": "CSES", "difficulty": "easy", "tracks": [ "Counting DP" ], "tags": [ "Counting", "Mod" ], "styles": [ "Tabulation" ], "prerequisites": [ "Basic Recursion", "Modular Arithmetic" ], "bucket": "counting-ways", "why_fit": "Shows how counting DP turns a simple last-move recurrence into an efficient linear solution." }, { "slug": "dp/foundations", "topic": "DP -> Foundations", "title": "Unique Paths", "url": "https://leetcode.com/problems/unique-paths", "source": "LeetCode", "difficulty": "medium", "tracks": [ "Grid DP" ], "tags": [ "Grid", "Combinatorics" ], "styles": [ "Tabulation" ], "prerequisites": [ "2D Arrays", "Basic Counting" ], "bucket": "grid-paths", "why_fit": "The standard grid-counting DP that teaches how to propagate answers from left and up." }, { "slug": "dp/foundations", "topic": "DP -> Foundations", "title": "Longest Common Subsequence", "url": "https://cses.fi/problemset/task/3403", "source": "CSES", "difficulty": "medium", "tracks": [ "String DP" ], "tags": [ "2D" ], "styles": [ "Tabulation" ], "prerequisites": [ "2D Arrays", "String Indexing" ], "bucket": "pairwise-string-dp", "why_fit": "A classic 2D DP over prefixes with match-vs-skip transitions." }, { "slug": "dp/foundations", "topic": "DP -> Foundations", "title": "Edit Distance", "url": "https://cses.fi/problemset/task/1639", "source": "CSES", "difficulty": "hard", "tracks": [ "String DP" ], "tags": [ "Transformations" ], "styles": [ "Tabulation" ], "prerequisites": [ "LCS", "2D Arrays" ], "bucket": "prefix-string-transforms", "why_fit": "A foundational edit DP that generalizes prefix transitions to insert/delete/replace." }, { "slug": "dp/foundations", "topic": "DP -> Foundations", "title": "Teamwork", "url": "https://usaco.org/index.php?cpid=863&page=viewproblem2", "source": "USACO Gold", "difficulty": "easy", "tracks": [ "Segmented DP" ], "tags": [ "Partitioning", "Bounded-Lookback" ], "styles": [ "Tabulation" ], "prerequisites": [ "Prefix Sums", "Arrays" ], "bucket": "segment-partitioning", "why_fit": "A classic segmented DP where each position considers a short backward range of choices." }, { "slug": "dp/foundations", "topic": "DP -> Foundations", "title": "Frog 2", "url": "https://atcoder.jp/contests/dp/tasks/dp_b", "source": "AtCoder DP Contest", "difficulty": "easy", "tracks": [ "Linear DP" ], "tags": [ "Min-Cost", "Windowed-Transition", "1D DP", "Bounded Jump" ], "styles": [ "Tabulation" ], "prerequisites": [ "Frog 1", "Arrays" ], "bucket": "small-transition-window", "why_fit": "Builds the same recurrence idea with a wider jump window, which is a common DP stepping stone." }, { "slug": "dp/foundations", "topic": "DP -> Foundations", "title": "Frog 1", "url": "https://atcoder.jp/contests/dp/tasks/dp_a", "source": "AtCoder DP Contest", "difficulty": "easy", "tracks": [ "Linear DP" ], "tags": [ "Min-Cost", "Recurrence", "1D DP" ], "styles": [ "Tabulation", "Memoization" ], "prerequisites": [ "Arrays", "Absolute Difference" ], "bucket": "state-transition-basics", "why_fit": "A perfect first min-cost DP with a very small transition set and clear base cases." }, { "slug": "dp/fwht-subset-convolution", "topic": "DP -> FWHT / XOR Convolution / Subset Convolution", "title": "Bitwise XOR Convolution", "url": "https://judge.yosupo.jp/problem/bitwise_xor_convolution", "source": "Library Checker", "difficulty": "hard", "tracks": [ "XOR Convolution", "Boolean Cube" ], "tags": [ "Walsh-Hadamard", "Full Cube" ], "styles": [ "Dynamic Programming", "Algebra", "Implementation" ], "prerequisites": [ "Sos DP", "Modular Arithmetic", "Power-Of-Two Mask Space" ], "bucket": "core", "why_fit": "The clean first verifier where the entire task is one xor convolution on the full boolean cube and the only intended route is Walsh-Hadamard transform." }, { "slug": "dp/fwht-subset-convolution", "topic": "DP -> FWHT / XOR Convolution / Subset Convolution", "title": "Subset Convolution", "url": "https://judge.yosupo.jp/problem/subset_convolution", "source": "Library Checker", "difficulty": "hard", "tracks": [ "Subset Convolution", "Boolean Cube" ], "tags": [ "Popcount Layers", "Zeta Transform", "Full Cube" ], "styles": [ "Dynamic Programming", "Algebra", "Implementation" ], "prerequisites": [ "Sos DP", "Popcount Layering", "Modular Arithmetic" ], "bucket": "stretch", "why_fit": "The natural stretch sibling where plain SOS sweeps are no longer enough and the exact subset split must be preserved through popcount-layered transforms." }, { "slug": "dp/interval-dp", "topic": "DP -> Interval DP", "title": "Deque", "url": "https://atcoder.jp/contests/dp/tasks/dp_l", "source": "AtCoder DP Contest", "difficulty": "medium", "tracks": [], "tags": [ "Game DP" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "interval game with optimal play" }, { "slug": "dp/interval-dp", "topic": "DP -> Interval DP", "title": "Zuma", "url": "https://codeforces.com/problemset/problem/607/B", "source": "Codeforces", "difficulty": "hard", "tracks": [], "tags": [ "Palindrome Removal" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "canonical hard interval DP" }, { "slug": "dp/interval-dp", "topic": "DP -> Interval DP", "title": "Mixtures", "url": "https://www.spoj.com/problems/MIXTURES", "source": "SPOJ", "difficulty": "hard", "tracks": [ "Merge-DP" ], "tags": [ "Color-Merge" ], "styles": [ "Tabulation" ], "prerequisites": [ "Prefix Sums", "Subarray DP" ], "bucket": "color-mixing", "why_fit": "A very common merge-style interval DP that reinforces the split-at-k pattern." }, { "slug": "dp/interval-dp", "topic": "DP -> Interval DP", "title": "Remove Boxes", "url": "https://leetcode.com/problems/remove-boxes", "source": "LeetCode", "difficulty": "hard", "tracks": [ "Compressed-State-DP" ], "tags": [ "Memoization" ], "styles": [ "Memoization" ], "prerequisites": [ "Interval DP", "State Augmentation" ], "bucket": "extra-carried-state", "why_fit": "A harder interval DP that shows why one extra carried parameter can unlock the optimal recurrence." }, { "slug": "dp/interval-dp", "topic": "DP -> Interval DP", "title": "Modern Art 3", "url": "https://usaco.org/index.php?cpid=1114&page=viewproblem2", "source": "USACO Gold", "difficulty": "hard", "tracks": [ "String-Like-Intervals" ], "tags": [ "Painting" ], "styles": [ "Tabulation" ], "prerequisites": [ "Subarray DP", "State Merging" ], "bucket": "interval-repainting", "why_fit": "A great interval DP where repeated colors create the key merging opportunities." }, { "slug": "dp/interval-dp", "topic": "DP -> Interval DP", "title": "Burst Balloons", "url": "https://leetcode.com/problems/burst-balloons", "source": "LeetCode", "difficulty": "hard", "tracks": [ "Split-DP" ], "tags": [ "Maximize" ], "styles": [ "Tabulation" ], "prerequisites": [ "Interval Splitting", "Recurrence Design" ], "bucket": "last-burst-split", "why_fit": "The most famous interval DP for learning how choosing the last action simplifies the recurrence." }, { "slug": "dp/interval-dp", "topic": "DP -> Interval DP", "title": "Slimes", "url": "https://atcoder.jp/contests/dp/tasks/dp_n", "source": "AtCoder DP Contest", "difficulty": "hard", "tracks": [ "Range-DP" ], "tags": [ "Merge-Cost" ], "styles": [ "Tabulation" ], "prerequisites": [ "Prefix Sums", "Subarray DP" ], "bucket": "merge-intervals", "why_fit": "The standard interval-merging DP: split a range at every point and minimize the merge cost." }, { "slug": "dp/interval-dp", "topic": "DP -> Interval DP", "title": "Minimum Cost to Cut a Stick", "url": "https://leetcode.com/problems/minimum-cost-to-cut-a-stick", "source": "LeetCode", "difficulty": "medium", "tracks": [ "Cut-DP" ], "tags": [ "Cuts" ], "styles": [ "Tabulation" ], "prerequisites": [ "Interval DP Basics", "Sorting Cut Points" ], "bucket": "optimal-cut-ordering", "why_fit": "A clean cut-ordering problem that is ideal for practicing interval split transitions." }, { "slug": "dp/interval-dp", "topic": "DP -> Interval DP", "title": "Strange Printer", "url": "https://leetcode.com/problems/strange-printer", "source": "LeetCode", "difficulty": "hard", "tracks": [ "String DP" ], "tags": [ "Strings" ], "styles": [ "Tabulation" ], "prerequisites": [ "Subproblem Splitting" ], "bucket": "palindrome-like-merging", "why_fit": "A subtle interval/string DP that rewards spotting repeated characters that can be merged." }, { "slug": "dp/interval-dp", "topic": "DP -> Interval DP", "title": "Minimum Score Triangulation of Polygon", "url": "https://leetcode.com/problems/minimum-score-triangulation-of-polygon", "source": "LeetCode", "difficulty": "medium", "tracks": [ "Polygon-DP" ], "tags": [ "Geometry" ], "styles": [ "Tabulation" ], "prerequisites": [ "Triangle Decomposition", "Interval Splitting" ], "bucket": "polygon-splitting", "why_fit": "A classic polygon interval DP that is often the first geometry-flavored range DP." }, { "slug": "dp/interval-dp", "topic": "DP -> Interval DP", "title": "The Cow Run", "url": "https://usaco.org/index.php?cpid=265&page=viewproblem2", "source": "USACO Gold", "difficulty": "hard", "tracks": [ "Ordered-Intervals" ], "tags": [ "Path" ], "styles": [ "Tabulation" ], "prerequisites": [ "Sorting", "Prefix Sums" ], "bucket": "sorted-interval-expansion", "why_fit": "An interval DP where the visited cows always form a contiguous block in sorted order." }, { "slug": "dp/interval-dp", "topic": "DP -> Interval DP", "title": "Removal Game", "url": "https://cses.fi/problemset/task/1097", "source": "CSES", "difficulty": "medium", "tracks": [ "Game-DP" ], "tags": [ "Game-Theory", "Minimax" ], "styles": [ "Tabulation" ], "prerequisites": [ "Minimax Thinking", "Prefix Sums" ], "bucket": "take-from-ends-game", "why_fit": "classic take-left-or-right DP" }, { "slug": "dp/knapsack-family", "topic": "DP -> Knapsack Family", "title": "Book Shop II", "url": "https://cses.fi/problemset/task/1159", "source": "CSES", "difficulty": "medium-hard", "tracks": [], "tags": [ "Bounded Knapsack", "Multi-Copy" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "bounded-multiplicity knapsack variant" }, { "slug": "dp/knapsack-family", "topic": "DP -> Knapsack Family", "title": "Book Shop", "url": "https://cses.fi/problemset/task/1158", "source": "CSES", "difficulty": "easy", "tracks": [ "0-1-Knapsack" ], "tags": [ "Capacity", "Value Maximization", "Budget" ], "styles": [ "Tabulation", "Rolling-Array" ], "prerequisites": [ "Arrays", "Maximization DP" ], "bucket": "0-1-capacity-dp", "why_fit": "The cleanest 0/1 knapsack template: maximize value under a budget with each item usable once." }, { "slug": "dp/knapsack-family", "topic": "DP -> Knapsack Family", "title": "Knapsack 1", "url": "https://atcoder.jp/contests/dp/tasks/dp_d", "source": "AtCoder DP Contest", "difficulty": "medium", "tracks": [ "0-1-Knapsack" ], "tags": [ "Capacity", "Value Maximization" ], "styles": [ "Tabulation" ], "prerequisites": [ "Book Shop", "Nested Loops" ], "bucket": "0-1-knapsack", "why_fit": "The standard 0/1 knapsack formulation in its pure contest form." }, { "slug": "dp/knapsack-family", "topic": "DP -> Knapsack Family", "title": "Two Sets II", "url": "https://cses.fi/problemset/task/1093", "source": "CSES", "difficulty": "easy", "tracks": [ "Subset Sum" ], "tags": [ "Partition", "Combinatorics" ], "styles": [ "Tabulation" ], "prerequisites": [ "Modular Arithmetic" ], "bucket": "equal-partition-counting", "why_fit": "A classic partition-counting twist on subset-sum that reinforces exact-sum DP." }, { "slug": "dp/knapsack-family", "topic": "DP -> Knapsack Family", "title": "Fruit Feast", "url": "https://usaco.org/index.php?cpid=574&page=viewproblem2", "source": "USACO Gold", "difficulty": "easy", "tracks": [ "State-Augmented-Knapsack" ], "tags": [ "Unbounded", "One-Time-State" ], "styles": [ "Tabulation" ], "prerequisites": [ "Unbounded Knapsack", "State Expansion" ], "bucket": "knapsack-with-a-toggle", "why_fit": "A memorable knapsack twist where one optional action changes the reachable state space." }, { "slug": "dp/knapsack-family", "topic": "DP -> Knapsack Family", "title": "Minimizing Coins", "url": "https://cses.fi/problemset/task/1634", "source": "CSES", "difficulty": "easy", "tracks": [ "Unbounded-Knapsack" ], "tags": [ "Min-Coins", "Unbounded", "Min-Count" ], "styles": [ "Tabulation" ], "prerequisites": [ "Basic Recurrence", "Arrays" ], "bucket": "minimum-coin-count", "why_fit": "The simplest unbounded knapsack variant: minimize items while hitting an exact sum." }, { "slug": "dp/knapsack-family", "topic": "DP -> Knapsack Family", "title": "Coin Change", "url": "https://leetcode.com/problems/coin-change", "source": "LeetCode", "difficulty": "medium", "tracks": [ "Unbounded-Knapsack" ], "tags": [ "Min-Coins", "Unbounded" ], "styles": [ "Tabulation" ], "prerequisites": [ "Minimizing Coins", "Arrays" ], "bucket": "minimum-coins-with-repetition", "why_fit": "The interview-friendly version of unbounded knapsack with the same core recurrence." }, { "slug": "dp/knapsack-family", "topic": "DP -> Knapsack Family", "title": "Coin Combinations I", "url": "https://cses.fi/problemset/task/1635", "source": "CSES", "difficulty": "easy", "tracks": [ "Unbounded-Knapsack" ], "tags": [ "Counting", "Order-Matters" ], "styles": [ "Tabulation" ], "prerequisites": [ "Modular Arithmetic", "Basic Counting" ], "bucket": "ordered-unbounded-counting", "why_fit": "Classic counting knapsack where the order of coins matters and the state is one-dimensional." }, { "slug": "dp/knapsack-family", "topic": "DP -> Knapsack Family", "title": "Talent Show", "url": "https://usaco.org/index.php?cpid=839&page=viewproblem2", "source": "USACO Gold", "difficulty": "hard", "tracks": [ "Ratio-Optimization" ], "tags": [ "Binary-Search-On-Answer" ], "styles": [ "Tabulation", "Binary-Search-Check" ], "prerequisites": [ "0/1 Knapsack", "Binary Search On Answer" ], "bucket": "ratio-knapsack", "why_fit": "A classic knapsack variant that combines DP with an optimization ratio objective." }, { "slug": "dp/knapsack-family", "topic": "DP -> Knapsack Family", "title": "Money Sums", "url": "https://cses.fi/problemset/task/1745", "source": "CSES", "difficulty": "easy", "tracks": [ "Subset Sum" ], "tags": [ "Reachable-Sums", "Bitset-Friendly" ], "styles": [ "Tabulation" ], "prerequisites": [ "Set Thinking", "Boolean DP" ], "bucket": "reachable-sums", "why_fit": "A classic subset-sum reachability problem that prepares you for bitset optimization later." }, { "slug": "dp/knapsack-family", "topic": "DP -> Knapsack Family", "title": "Target Sum", "url": "https://leetcode.com/problems/target-sum", "source": "LeetCode", "difficulty": "medium", "tracks": [ "Counting-Knapsack" ], "tags": [ "Sign-Assignments", "Counting" ], "styles": [ "Tabulation" ], "prerequisites": [ "Subset Sum", "Algebraic Transformation" ], "bucket": "signed-subset-sum", "why_fit": "A classic transform-from-signs to subset-sum problem that rewards good state reframing." }, { "slug": "dp/knapsack-family", "topic": "DP -> Knapsack Family", "title": "Partition Equal Subset Sum", "url": "https://leetcode.com/problems/partition-equal-subset-sum", "source": "LeetCode", "difficulty": "medium", "tracks": [ "Subset Sum" ], "tags": [ "Partition", "Boolean" ], "styles": [ "Tabulation" ], "prerequisites": [ "Parity Checks" ], "bucket": "subset-partition", "why_fit": "A direct yes/no subset-sum target that helps cement knapsack as reachability." }, { "slug": "dp/knapsack-family", "topic": "DP -> Knapsack Family", "title": "Ones and Zeroes", "url": "https://leetcode.com/problems/ones-and-zeroes", "source": "LeetCode", "difficulty": "medium", "tracks": [ "2D-Knapsack" ], "tags": [ "Dual-Capacity", "0-1" ], "styles": [ "Tabulation" ], "prerequisites": [ "0/1 Knapsack", "Counting Items" ], "bucket": "two-dimensional-capacity", "why_fit": "A useful multi-capacity knapsack that extends the standard single-budget template." }, { "slug": "dp/knapsack-family", "topic": "DP -> Knapsack Family", "title": "Coin Combinations II", "url": "https://cses.fi/problemset/task/1636", "source": "CSES", "difficulty": "easy", "tracks": [ "Subset-Knapsack" ], "tags": [ "Counting", "Order-Does-Not-Matter" ], "styles": [ "Tabulation" ], "prerequisites": [ "Coin Combinations I", "Modular Arithmetic" ], "bucket": "unordered-counting", "why_fit": "Teaches the coin-ordering pitfall that distinguishes the two classic coin-change DPs." }, { "slug": "dp/knapsack-family", "topic": "DP -> Knapsack Family", "title": "Knapsack 2", "url": "https://atcoder.jp/contests/dp/tasks/dp_e", "source": "AtCoder DP Contest", "difficulty": "hard", "tracks": [ "Value-Based-DP" ], "tags": [ "Capacity", "Value-State", "Value-Based Knapsack", "Large W" ], "styles": [ "Tabulation" ], "prerequisites": [ "0/1 Knapsack", "State Redesign" ], "bucket": "value-indexed-knapsack", "why_fit": "Shows the key trick of flipping the DP dimension when weights are too large." }, { "slug": "dp/knuth-optimization", "topic": "DP -> Knuth Optimization", "title": "Knuth Division", "url": "https://cses.fi/problemset/task/2088", "source": "CSES", "difficulty": "hard", "tracks": [ "Interval DP" ], "tags": [ "Prefix Sums", "Merge Cost" ], "styles": [ "Interval DP", "Cost Preprocessing", "Opt Window Monotonicity" ], "prerequisites": [ "Prefix Sums", "Split-Point Recurrence" ], "bucket": "core", "why_fit": "The cleanest first benchmark where the classic merge-cost interval recurrence matches the exact Knuth optimization window." }, { "slug": "dp/knuth-optimization", "topic": "DP -> Knuth Optimization", "title": "Slimes", "url": "https://atcoder.jp/contests/dp/tasks/dp_n", "source": "AtCoder DP Contest", "difficulty": "hard", "tracks": [ "Interval DP" ], "tags": [ "Merge Cost", "Prefix Sums", "Optimization Compare Point" ], "styles": [ "Interval DP", "Cost Preprocessing", "Optimization Compare Point" ], "prerequisites": [ "Prefix Sums", "Split-Point Recurrence" ], "bucket": "stretch", "why_fit": "A canonical compare point with the same merge-style recurrence, useful for seeing the structure before or after importing the stronger Knuth optimization lens." }, { "slug": "dp/lagrangian-relaxation", "topic": "DP -> Lagrangian Relaxation / Aliens Trick", "title": "Red and Blue Lamps", "url": "https://atcoder.jp/contests/abc218/tasks/abc218_h", "source": "AtCoder", "difficulty": "hard", "tracks": [ "Aliens Trick" ], "tags": [ "Exact K", "Penalty Search", "Non-Adjacent Picks" ], "styles": [ "Penalty Search", "Linear DP", "Binary Search On Answer Space" ], "prerequisites": [ "Exact-K DP", "Non-Adjacent DP", "Count Tie-Breaking" ], "bucket": "core", "why_fit": "The clean flagship where the exact-K non-adjacent selection constraint becomes one integer penalty and the relaxed solver is a linear path DP." }, { "slug": "dp/lagrangian-relaxation", "topic": "DP -> Lagrangian Relaxation / Aliens Trick", "title": "Shojin", "url": "https://atcoder.jp/contests/abc305/tasks/abc305_h", "source": "AtCoder", "difficulty": "hard", "tracks": [ "Aliens Trick" ], "tags": [ "Exact K", "Penalty Search", "Follow-Up" ], "styles": [ "Penalty Search", "Follow-Up" ], "prerequisites": [ "Monotone Counts" ], "bucket": "stretch", "why_fit": "A strong follow-up where the same penalty-search worldview survives a different exact-K DP skin and the count dimension is still the true bottleneck." }, { "slug": "dp/lagrangian-relaxation", "topic": "DP -> Lagrangian Relaxation / Aliens Trick", "title": "Patisserie ABC 3", "url": "https://atcoder.jp/contests/abc400/tasks/abc400_g", "source": "AtCoder", "difficulty": "hard", "tracks": [ "Aliens Trick" ], "tags": [ "Exact K", "Penalty Search", "Advanced" ], "styles": [ "Penalty Search", "Advanced Modeling" ], "prerequisites": [ "Advanced DP Modeling" ], "bucket": "challenge", "why_fit": "An advanced same-family route where the core alien-DP idea remains, but the relaxed transition and structure are less direct than the flagship." }, { "slug": "dp/lagrangian-relaxation", "topic": "DP -> Lagrangian Relaxation / Aliens Trick", "title": "Welcome to Tokyo!", "url": "https://atcoder.jp/contests/wtf22-day1-open/tasks/wtf22_day1_d", "source": "AtCoder", "difficulty": "hard", "tracks": [ "Aliens Trick" ], "tags": [ "Exact K", "Penalty Search", "Challenge" ], "styles": [ "Penalty Search", "Theory-Heavy" ], "prerequisites": [ "DP Modeling" ], "bucket": "challenge", "why_fit": "A challenge anchor for recognizing the same exact-K penalty-search worldview once the flagship route feels routine." }, { "slug": "dp/sliding-window", "topic": "DP -> Sliding Window And Window DP", "title": "Dice Combinations", "url": "https://cses.fi/problemset/task/1633", "source": "CSES", "difficulty": "easy", "tracks": [], "tags": [ "1D DP", "Window Size 6" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "bounded-width transition window" }, { "slug": "dp/sliding-window", "topic": "DP -> Sliding Window And Window DP", "title": "Array Description", "url": "https://cses.fi/problemset/task/1746", "source": "CSES", "difficulty": "medium", "tracks": [], "tags": [ "Bounded Transition DP", "Prefix Sums" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "local-value window on adjacent states" }, { "slug": "dp/sliding-window", "topic": "DP -> Sliding Window And Window DP", "title": "Candies", "url": "https://atcoder.jp/contests/dp/tasks/dp_m", "source": "AtCoder DP Contest", "difficulty": "medium-hard", "tracks": [], "tags": [ "Prefix-Sum DP", "Bounded Range" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "windowed transitions via prefix sums" }, { "slug": "dp/sliding-window", "topic": "DP -> Sliding Window And Window DP", "title": "Fruit Into Baskets", "url": "https://leetcode.com/problems/fruit-into-baskets", "source": "LeetCode", "difficulty": "medium", "tracks": [ "Frequency-Window" ], "tags": [ "Distinct-Count", "Two-Pointers" ], "styles": [ "Two-Pointers" ], "prerequisites": [ "Hash Maps", "Window Invariants" ], "bucket": "at-most-k-distinct", "why_fit": "A classic at-most-two-distinct window that teaches how to expand and shrink correctly." }, { "slug": "dp/sliding-window", "topic": "DP -> Sliding Window And Window DP", "title": "Sliding Window Distinct Values", "url": "https://cses.fi/problemset/task/3222", "source": "CSES", "difficulty": "easy", "tracks": [ "Frequency-Window" ], "tags": [ "Frequency-Map", "Distinct" ], "styles": [ "Two-Pointers", "Hash-Map" ], "prerequisites": [ "Hash Maps", "Two Pointers" ], "bucket": "distinct-count-window", "why_fit": "A clean frequency-based window problem that teaches how to maintain a moving constraint." }, { "slug": "dp/sliding-window", "topic": "DP -> Sliding Window And Window DP", "title": "Permutation in String", "url": "https://leetcode.com/problems/permutation-in-string", "source": "LeetCode", "difficulty": "easy", "tracks": [ "Frequency-Window" ], "tags": [ "Anagram", "Frequency-Array" ], "styles": [ "Two-Pointers" ], "prerequisites": [ "Frequency Arrays", "Strings" ], "bucket": "fixed-length-frequency-match", "why_fit": "A crisp fixed-window frequency problem that is perfect for learning sliding updates." }, { "slug": "dp/sliding-window", "topic": "DP -> Sliding Window And Window DP", "title": "Sliding Window Cost", "url": "https://cses.fi/problemset/task/1077", "source": "CSES", "difficulty": "medium", "tracks": [ "Order-Statistics" ], "tags": [ "Median", "Cost" ], "styles": [ "Balanced-Multiset" ], "prerequisites": [ "Sliding Window Median", "Prefix Sums" ], "bucket": "median-cost", "why_fit": "A natural companion to median maintenance that adds aggregate cost tracking." }, { "slug": "dp/sliding-window", "topic": "DP -> Sliding Window And Window DP", "title": "Sliding Window Median", "url": "https://cses.fi/problemset/task/1076", "source": "CSES", "difficulty": "medium", "tracks": [ "Order-Statistics" ], "tags": [ "Median", "Multiset" ], "styles": [ "Balanced-Multiset" ], "prerequisites": [ "Multisets", "Heap Balancing" ], "bucket": "median-maintenance", "why_fit": "A classic sliding-window problem that upgrades basic window maintenance to order statistics." }, { "slug": "dp/sliding-window", "topic": "DP -> Sliding Window And Window DP", "title": "Minimum Window Substring", "url": "https://leetcode.com/problems/minimum-window-substring", "source": "LeetCode", "difficulty": "hard", "tracks": [ "Frequency-Window" ], "tags": [ "Substring", "Frequency-Map" ], "styles": [ "Two-Pointers", "Hash-Map" ], "prerequisites": [ "Hash Maps", "Substring Counting" ], "bucket": "minimum-covering-window", "why_fit": "The classic minimum-cover window that shows how to shrink only after a valid window is found." }, { "slug": "dp/sliding-window", "topic": "DP -> Sliding Window And Window DP", "title": "Sliding Window Minimum", "url": "https://cses.fi/problemset/task/3221", "source": "CSES", "difficulty": "easy", "tracks": [ "Window-Maintenance" ], "tags": [ "Deque", "Minimum" ], "styles": [ "Deque" ], "prerequisites": [ "Queues", "Amortized Analysis" ], "bucket": "monotonic-minimum", "why_fit": "The standard monotonic-deque template for maintaining a window minimum in O(n)." }, { "slug": "dp/sliding-window", "topic": "DP -> Sliding Window And Window DP", "title": "Subarray Product Less Than K", "url": "https://leetcode.com/problems/subarray-product-less-than-k", "source": "LeetCode", "difficulty": "medium", "tracks": [ "Product-Window" ], "tags": [ "Multiplicative", "Two-Pointers" ], "styles": [ "Two-Pointers" ], "prerequisites": [ "Multiplication Invariants", "Arrays" ], "bucket": "product-constraint", "why_fit": "A canonical positive-array sliding window where the product constraint controls window growth." }, { "slug": "dp/sliding-window", "topic": "DP -> Sliding Window And Window DP", "title": "Longest Repeating Character Replacement", "url": "https://leetcode.com/problems/longest-repeating-character-replacement", "source": "LeetCode", "difficulty": "medium", "tracks": [ "Frequency-Window" ], "tags": [ "Frequency", "Replacement" ], "styles": [ "Two-Pointers" ], "prerequisites": [ "Frequency Counting", "Window Invariants" ], "bucket": "single-character-dominance", "why_fit": "A very common window problem where a simple count invariant unlocks the maximum length." }, { "slug": "dp/sliding-window", "topic": "DP -> Sliding Window And Window DP", "title": "Longest Substring Without Repeating Characters", "url": "https://leetcode.com/problems/longest-substring-without-repeating-characters", "source": "LeetCode", "difficulty": "medium", "tracks": [ "Two-Pointers" ], "tags": [ "Hash-Map", "Substring" ], "styles": [ "Two-Pointers" ], "prerequisites": [ "Hash Maps", "Strings" ], "bucket": "unique-character-window", "why_fit": "The most recognizable variable-length window problem for maintaining a uniqueness invariant." }, { "slug": "dp/sliding-window", "topic": "DP -> Sliding Window And Window DP", "title": "Maximum Erasure Value", "url": "https://leetcode.com/problems/maximum-erasure-value", "source": "LeetCode", "difficulty": "medium", "tracks": [ "Frequency-Window" ], "tags": [ "Unique-Window", "Prefix-Sums" ], "styles": [ "Two-Pointers" ], "prerequisites": [ "Hash Maps", "Prefix Sums" ], "bucket": "unique-sum-window", "why_fit": "A good combination of uniqueness maintenance and rolling aggregate sums." }, { "slug": "dp/sliding-window", "topic": "DP -> Sliding Window And Window DP", "title": "Sliding Window Inversions", "url": "https://cses.fi/problemset/task/3223", "source": "CSES", "difficulty": "hard", "tracks": [ "Inversion-Counting" ], "tags": [ "Inversions", "Fenwick" ], "styles": [ "Fenwick-Tree" ], "prerequisites": [ "Coordinate Compression", "Order Statistics" ], "bucket": "window-inversion-count", "why_fit": "A strong advanced window problem that combines local maintenance with inversion counting." }, { "slug": "dp/sliding-window", "topic": "DP -> Sliding Window And Window DP", "title": "Sliding Window Advertisement", "url": "https://cses.fi/problemset/task/3227", "source": "CSES", "difficulty": "medium", "tracks": [ "Monotonic-Window" ], "tags": [ "Deque", "Max-Area" ], "styles": [ "Deque", "Prefix-Scan" ], "prerequisites": [ "Monotonic Queue", "Prefix Sums" ], "bucket": "windowed-histogram", "why_fit": "A nice windowed maximization problem where subarray-maintenance meets a geometric interpretation." }, { "slug": "dp/slope-trick", "topic": "DP -> Slope Trick", "title": "Absolute Minima", "url": "https://atcoder.jp/contests/abc127/tasks/abc127_f", "source": "AtCoder", "difficulty": "hard", "tracks": [], "tags": [ "Absolute Value Updates", "Median Maintenance", "Convex Function" ], "styles": [ "Online Queries", "Median Structure" ], "prerequisites": [ "Absolute Value Cost", "Convex Minimizers" ], "bucket": "warm-up", "why_fit": "The clean warm-up where the same convex-function family appears without movement-style shift_min, so a lighter same-family route becomes visible." }, { "slug": "dp/slope-trick", "topic": "DP -> Slope Trick", "title": "Snuketoon", "url": "https://atcoder.jp/contests/abc217/tasks/abc217_h", "source": "AtCoder", "difficulty": "hard", "tracks": [], "tags": [ "One-Sided Penalties", "Shift Min", "Convex DP" ], "styles": [ "Convex DP", "Data-Structure-Heavy" ], "prerequisites": [ "Convex Function State", "One-Sided Hinges", "Lazy Shifts" ], "bucket": "core", "why_fit": "The cleanest flagship where time gaps become bounded argmin shifts and each event adds one one-sided hinge penalty." }, { "slug": "dp/slope-trick", "topic": "DP -> Slope Trick", "title": "Travelling Salesman Problem", "url": "https://atcoder.jp/contests/abc406/tasks/abc406_g", "source": "AtCoder", "difficulty": "hard", "tracks": [], "tags": [ "Absolute Distance", "Shift Min", "Follow-Up" ], "styles": [ "Convex DP", "Follow-Up" ], "prerequisites": [ "Slope Trick", "Absolute Distance DP" ], "bucket": "stretch", "why_fit": "A strong follow-up where the same slope-trick machinery survives a different story skin and both movement and meeting costs shape the convex state." }, { "slug": "dp/slope-trick", "topic": "DP -> Slope Trick", "title": "Many Increasing Problems", "url": "https://atcoder.jp/contests/arc163/tasks/arc163_f", "source": "AtCoder", "difficulty": "hard", "tracks": [], "tags": [ "Monotone Sequence DP", "Convex DP", "Advanced" ], "styles": [ "Convex DP", "Theory-Heavy" ], "prerequisites": [ "Slope Trick", "Sequence DP" ], "bucket": "challenge", "why_fit": "The advanced follow-up where the slope-trick view still applies, but the problem is no longer a direct event-by-event coordinate process." }, { "slug": "dp/sos-dp", "topic": "DP -> SOS DP", "title": "Compatible Numbers", "url": "https://codeforces.com/problemset/problem/165/E", "source": "Codeforces", "difficulty": "very-hard", "tracks": [ "Bitmask" ], "tags": [ "Bitmasks", "Subset Zeta", "Witness Propagation", "Bitwise Complement" ], "styles": [ "Full-Cube Sweep", "Complement Modeling", "Offline Propagation" ], "prerequisites": [ "Bitmask States", "Complement Masks", "Subset Direction" ], "bucket": "core", "why_fit": "The cleanest first rep where one subset-direction SOS sweep carries a witness value and the real modeling step is querying the complement mask." }, { "slug": "dp/sos-dp", "topic": "DP -> SOS DP", "title": "SOS Bit Problem", "url": "https://cses.fi/problemset/task/1654", "source": "CSES", "difficulty": "hard", "tracks": [ "Bitmask" ], "tags": [ "Subset Zeta", "Superset Zeta", "Bitwise Or", "Bitwise And" ], "styles": [ "Full-Cube Sweep", "Count Aggregation", "Complement Counting" ], "prerequisites": [ "Sos DP", "Bitwise Predicates", "Mask Bucketing" ], "bucket": "stretch", "why_fit": "A strong follow-up where the same lane has to support both subset-side and superset-side counting in one problem." }, { "slug": "dp/tree-dp", "topic": "DP -> Tree DP", "title": "Tree Matching", "url": "https://cses.fi/problemset/task/1130", "source": "CSES", "difficulty": "medium", "tracks": [], "tags": [ "Matching" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "child-combination DP on trees" }, { "slug": "dp/tree-dp", "topic": "DP -> Tree DP", "title": "Subtree", "url": "https://atcoder.jp/contests/dp/tasks/dp_v", "source": "AtCoder DP Contest", "difficulty": "medium-hard", "tracks": [], "tags": [ "Rerooting" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "rerooting / subtree accumulation" }, { "slug": "dp/tree-dp", "topic": "DP -> Tree DP", "title": "Sum of Distances in Tree", "url": "https://leetcode.com/problems/sum-of-distances-in-tree", "source": "LeetCode", "difficulty": "hard", "tracks": [ "Rerooting" ], "tags": [], "styles": [ "DFS", "Rerooting" ], "prerequisites": [ "Subtree Sizes", "Tree Traversal" ], "bucket": "all-roots-distance-dp", "why_fit": "A very common rerooting problem that teaches how to propagate global answers across all nodes." }, { "slug": "dp/tree-dp", "topic": "DP -> Tree DP", "title": "Binary Tree Maximum Path Sum", "url": "https://leetcode.com/problems/binary-tree-maximum-path-sum", "source": "LeetCode", "difficulty": "hard", "tracks": [ "Path-Aggregation" ], "tags": [ "Path" ], "styles": [ "DFS", "Postorder" ], "prerequisites": [ "Tree Recursion", "Max Subarray Intuition" ], "bucket": "best-path-through-a-node", "why_fit": "A classic tree aggregation problem where each node contributes one-sided path values upward." }, { "slug": "dp/tree-dp", "topic": "DP -> Tree DP", "title": "Tree Distances I", "url": "https://cses.fi/problemset/task/1132", "source": "CSES", "difficulty": "medium", "tracks": [ "Rerooting" ], "tags": [ "Distance" ], "styles": [ "DFS", "Rerooting" ], "prerequisites": [ "Tree Traversal", "DFS Order" ], "bucket": "maximum-distance-per-node", "why_fit": "A clean rerooting example that asks for a per-node aggregate over the whole tree." }, { "slug": "dp/tree-dp", "topic": "DP -> Tree DP", "title": "Directory Traversal", "url": "https://usaco.org/index.php?cpid=814&page=viewproblem2", "source": "USACO Gold", "difficulty": "medium", "tracks": [ "Rerooting" ], "tags": [], "styles": [ "DFS", "Rerooting" ], "prerequisites": [ "Tree Distance Basics", "Prefix Sums" ], "bucket": "root-choice-optimization", "why_fit": "A great rerooting-style tree DP where the answer depends on where you stand in the tree." }, { "slug": "dp/tree-dp", "topic": "DP -> Tree DP", "title": "Tree Distances II", "url": "https://cses.fi/problemset/task/1133", "source": "CSES", "difficulty": "medium", "tracks": [ "Rerooting" ], "tags": [], "styles": [ "DFS", "Rerooting" ], "prerequisites": [ "Tree Distances I", "Subtree Sizes" ], "bucket": "sum-of-distances", "why_fit": "The sum-of-distances sibling to Tree Distances I, and a classic rerooting benchmark." }, { "slug": "dp/tree-dp", "topic": "DP -> Tree DP", "title": "Barn Painting", "url": "https://usaco.org/index.php?cpid=766&page=viewproblem2", "source": "USACO Gold", "difficulty": "easy", "tracks": [ "Coloring-DP" ], "tags": [ "Coloring" ], "styles": [ "DFS", "Postorder" ], "prerequisites": [ "Tree Traversal", "State Compression" ], "bucket": "tree-coloring", "why_fit": "A classic colored-tree DP that cleanly illustrates parent-state dependency." }, { "slug": "dp/tree-dp", "topic": "DP -> Tree DP", "title": "Independent Set", "url": "https://atcoder.jp/contests/dp/tasks/dp_p", "source": "AtCoder DP Contest", "difficulty": "medium", "tracks": [ "Subtree-DP" ], "tags": [ "Independent-Set", "2-State" ], "styles": [ "DFS", "Postorder" ], "prerequisites": [ "Tree Traversal", "Basic Recursion" ], "bucket": "tree-independent-set", "why_fit": "The textbook tree DP for choosing or skipping each node under parent-child constraints." }, { "slug": "dp/tree-dp", "topic": "DP -> Tree DP", "title": "House Robber III", "url": "https://leetcode.com/problems/house-robber-iii", "source": "LeetCode", "difficulty": "medium", "tracks": [ "Tree-Structure" ], "tags": [ "Binary-Tree", "Skip-Take" ], "styles": [ "DFS", "Postorder" ], "prerequisites": [ "Binary Tree Traversal", "State Pairs" ], "bucket": "tree-skip-take", "why_fit": "A highly recognizable tree DP where each node returns take and skip values." }, { "slug": "foundations/binary-search", "topic": "Foundations -> Binary Search", "title": "032 - Binary Search", "url": "https://atcoder.jp/contests/math-and-algorithm/tasks/math_and_algorithm_ad", "source": "AtCoder", "difficulty": "easy", "tracks": [], "tags": [ "Membership", "Sorted-Array" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Official warmup for binary search on sorted data." }, { "slug": "foundations/binary-search", "topic": "Foundations -> Binary Search", "title": "C - Buy an Integer", "url": "https://atcoder.jp/contests/abc146/tasks/abc146_c", "source": "AtCoder", "difficulty": "medium", "tracks": [], "tags": [ "Digit-Length", "Math" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Search over a monotone price function." }, { "slug": "foundations/binary-search", "topic": "Foundations -> Binary Search", "title": "Array Division", "url": "https://cses.fi/problemset/task/1085", "source": "CSES", "difficulty": "medium", "tracks": [], "tags": [ "Binary-Search-On-Answer", "Partitioning", "Greedy-Check", "Partition" ], "styles": [ "Proof-Heavy", "Greedy-Heavy" ], "prerequisites": [ "Binary Search", "Greedy Feasibility Checks", "Arrays" ], "bucket": "classic", "why_fit": "A standard partitioning benchmark that teaches how to build a monotone check." }, { "slug": "foundations/binary-search", "topic": "Foundations -> Binary Search", "title": "Factory Machines", "url": "https://cses.fi/problemset/task/1620", "source": "CSES", "difficulty": "medium", "tracks": [], "tags": [ "Binary-Search-On-Answer", "Monotonicity", "Counting", "Monotone-Predicate", "Minimize-Answer" ], "styles": [ "Proof-Heavy", "Math-Heavy" ], "prerequisites": [ "Binary Search", "Monotone Predicates", "Prefix Counting" ], "bucket": "classic", "why_fit": "A canonical binary-search-on-answer problem with a clean monotone feasibility check." }, { "slug": "foundations/binary-search", "topic": "Foundations -> Binary Search", "title": "Magic Powder - 2", "url": "https://codeforces.com/problemset/problem/670/D", "source": "Codeforces", "difficulty": "medium", "tracks": [], "tags": [ "Binary-Search-On-Answer", "Resource-Feasibility" ], "styles": [ "Proof-Heavy", "Greedy-Heavy" ], "prerequisites": [ "Binary Search", "Greedy Checks", "Resource Counting" ], "bucket": "classic", "why_fit": "A popular feasibility-search problem with a very reusable binary-search pattern." }, { "slug": "foundations/binary-search", "topic": "Foundations -> Binary Search", "title": "Maximum Median", "url": "https://codeforces.com/problemset/problem/1201/C", "source": "Codeforces", "difficulty": "medium", "tracks": [], "tags": [ "Binary-Search-On-Answer", "Median" ], "styles": [ "Proof-Heavy", "Math-Heavy" ], "prerequisites": [ "Binary Search", "Median Reasoning", "Greedy" ], "bucket": "classic", "why_fit": "A classic binary-search benchmark where the objective is to maximize a median value." }, { "slug": "foundations/bit-tricks", "topic": "Foundations -> Bit Tricks", "title": "Gray Code", "url": "https://cses.fi/problemset/task/2205", "source": "CSES", "difficulty": "easy", "tracks": [ "Bit Manipulation" ], "tags": [ "Gray-Code", "Constructive" ], "styles": [ "Implementation" ], "prerequisites": [ "Binary Representation", "XOR" ], "bucket": "warm-up", "why_fit": "A compact bitwise-construction problem that makes binary structure feel concrete." }, { "slug": "foundations/bit-tricks", "topic": "Foundations -> Bit Tricks", "title": "Raising Bacteria", "url": "https://codeforces.com/problemset/problem/579/A", "source": "Codeforces", "difficulty": "easy", "tracks": [ "Bit Manipulation" ], "tags": [ "Popcount", "Greedy View" ], "styles": [ "Implementation" ], "prerequisites": [ "Bit Counting" ], "bucket": "core", "why_fit": "A famous popcount benchmark and a great first reminder that bits can encode structure, not just syntax." }, { "slug": "foundations/complexity-and-invariants", "topic": "Foundations -> Complexity And Invariants", "title": "Collecting Numbers", "url": "https://cses.fi/problemset/task/2216", "source": "CSES", "difficulty": "easy", "tracks": [], "tags": [ "Permutations", "Position-Mapping", "Positions" ], "styles": [ "Proof-Heavy", "Implementation-Heavy" ], "prerequisites": [ "Permutations", "Index Mapping", "Loop Invariants" ], "bucket": "core", "why_fit": "Good practice for turning a process into a simple invariant over positions." }, { "slug": "foundations/complexity-and-invariants", "topic": "Foundations -> Complexity And Invariants", "title": "Missing Coin Sum", "url": "https://cses.fi/problemset/task/2183", "source": "CSES", "difficulty": "medium", "tracks": [], "tags": [ "Sorting" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Classic smallest-unreachable-sum invariant." }, { "slug": "foundations/complexity-and-invariants", "topic": "Foundations -> Complexity And Invariants", "title": "Stick Lengths", "url": "https://cses.fi/problemset/task/1074", "source": "CSES", "difficulty": "medium", "tracks": [], "tags": [ "Median", "Absolute-Deviation", "Sorting" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Shows why the median is optimal." }, { "slug": "foundations/complexity-and-invariants", "topic": "Foundations -> Complexity And Invariants", "title": "Collecting Numbers II", "url": "https://cses.fi/problemset/task/2217", "source": "CSES", "difficulty": "hard", "tracks": [], "tags": [ "Updates", "Swap-Delta" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Same invariant, but maintained under swaps." }, { "slug": "foundations/complexity-and-invariants", "topic": "Foundations -> Complexity And Invariants", "title": "Distinct Values Subarrays", "url": "https://cses.fi/problemset/task/3420", "source": "CSES", "difficulty": "medium", "tracks": [], "tags": [ "Two-Pointers", "Distinctness", "Subarrays" ], "styles": [ "Proof-Heavy", "Implementation-Heavy" ], "prerequisites": [ "Two Pointers", "Frequency Counts", "Subarray Reasoning" ], "bucket": "variants", "why_fit": "A good bridge from basic sliding windows to counting arguments based on a maintained invariant." }, { "slug": "foundations/complexity-and-invariants", "topic": "Foundations -> Complexity And Invariants", "title": "Playlist", "url": "https://cses.fi/problemset/task/1141", "source": "CSES", "difficulty": "medium", "tracks": [], "tags": [ "Sliding-Window", "Distinctness", "Amortized-Analysis" ], "styles": [ "Proof-Heavy", "Data-Structure-Heavy" ], "prerequisites": [ "Two Pointers", "Hash Maps", "Amortized Analysis" ], "bucket": "variants", "why_fit": "A neat amortized two-pointer invariant problem with a clean linear-time proof." }, { "slug": "foundations/complexity-and-invariants", "topic": "Foundations -> Complexity And Invariants", "title": "Towers", "url": "https://cses.fi/problemset/task/1073", "source": "CSES", "difficulty": "medium", "tracks": [], "tags": [ "Patience-Sorting", "Lower Bound" ], "styles": [ "Proof-Heavy", "Data-Structure-Heavy" ], "prerequisites": [ "Greedy Reasoning", "Binary Search", "Sorted Containers" ], "bucket": "classic", "why_fit": "A classic proof-oriented greedy where the invariant is the sorted tower tops." }, { "slug": "foundations/complexity-and-invariants", "topic": "Foundations -> Complexity And Invariants", "title": "Increasing Array", "url": "https://cses.fi/problemset/task/1094", "source": "CSES", "difficulty": "easy", "tracks": [], "tags": [ "Prefix-Maintenance", "Prefix-Max" ], "styles": [ "Proof-Heavy", "Greedy-Heavy" ], "prerequisites": [ "Greedy Reasoning", "Prefix Invariants", "Arrays" ], "bucket": "theory", "why_fit": "A compact proof-by-invariant problem that rewards understanding why the greedy step is optimal." }, { "slug": "foundations/cpp-language", "topic": "Foundations -> C++ Language", "title": "Missing Number", "url": "https://cses.fi/problemset/task/1083", "source": "CSES", "difficulty": "easy", "tracks": [], "tags": [ "Arrays", "Math", "Accumulation", "Scan" ], "styles": [ "Implementation-Heavy" ], "prerequisites": [ "Basic Arithmetic", "Arrays", "Input/Output" ], "bucket": "warm-up", "why_fit": "Good practice for reading values, tracking a simple invariant, and avoiding off-by-one mistakes." }, { "slug": "foundations/cpp-language", "topic": "Foundations -> C++ Language", "title": "Repetitions", "url": "https://cses.fi/problemset/task/1069", "source": "CSES", "difficulty": "easy", "tracks": [], "tags": [ "Scanning", "Runs", "Run-Length", "Scan" ], "styles": [ "Implementation-Heavy" ], "prerequisites": [ "Strings", "Loops", "Basic Comparisons" ], "bucket": "warm-up", "why_fit": "Reinforces careful string scanning and run-length style logic without extra data structures." }, { "slug": "foundations/cpp-language", "topic": "Foundations -> C++ Language", "title": "Weird Algorithm", "url": "https://cses.fi/problemset/task/1068", "source": "CSES", "difficulty": "easy", "tracks": [], "tags": [ "Simulation", "Loops", "I/O", "Branching" ], "styles": [ "Implementation-Heavy" ], "prerequisites": [ "Basic Loops", "Branching", "Input/Output" ], "bucket": "warm-up", "why_fit": "A clean first task for writing a loop, handling parity, and printing a sequence correctly." }, { "slug": "foundations/cpp-language", "topic": "Foundations -> C++ Language", "title": "Coin Piles", "url": "https://cses.fi/problemset/task/1754", "source": "CSES", "difficulty": "easy", "tracks": [], "tags": [ "Parity", "Cases", "Math" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Great first problem for branch logic and case analysis." }, { "slug": "foundations/cpp-language", "topic": "Foundations -> C++ Language", "title": "Permutations", "url": "https://cses.fi/problemset/task/1070", "source": "CSES", "difficulty": "easy", "tracks": [], "tags": [ "Construction", "Parity", "Output-Formatting" ], "styles": [ "Implementation-Heavy" ], "prerequisites": [ "Loops", "Arrays", "Simple Constructive Ideas" ], "bucket": "core", "why_fit": "A nice starter for constructing outputs with a simple parity-based pattern." }, { "slug": "foundations/cpp-language", "topic": "Foundations -> C++ Language", "title": "Increasing Array", "url": "https://cses.fi/problemset/task/1094", "source": "CSES", "difficulty": "easy", "tracks": [], "tags": [ "Arrays", "Invariants" ], "styles": [ "Proof-Heavy", "Implementation-Heavy" ], "prerequisites": [ "Arrays", "Greedy Reasoning", "Prefix Invariants" ], "bucket": "theory", "why_fit": "A compact proof-by-invariant problem where the implementation is simple but the invariant matters." }, { "slug": "foundations/difference-arrays", "topic": "Foundations -> Difference Arrays", "title": "D - Water Heater", "url": "https://atcoder.jp/contests/abc183/tasks/abc183_d", "source": "AtCoder", "difficulty": "medium", "tracks": [ "Imos" ], "tags": [ "Difference Array", "Sweep Line", "Events" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "A clean event-sweep difference-array problem." }, { "slug": "foundations/difference-arrays", "topic": "Foundations -> Difference Arrays", "title": "Range Update Queries", "url": "https://cses.fi/problemset/task/1651", "source": "CSES", "difficulty": "medium", "tracks": [ "Difference Array" ], "tags": [ "Range-Add", "Point-Query" ], "styles": [ "Implementation-Heavy" ], "prerequisites": [ "Difference Arrays", "Prefix Sums", "Range Updates" ], "bucket": "core", "why_fit": "The standard entry point for using a difference array to turn range updates into prefix scans." }, { "slug": "foundations/difference-arrays", "topic": "Foundations -> Difference Arrays", "title": "D - Snuke Prime", "url": "https://atcoder.jp/contests/abc188/tasks/abc188_d", "source": "AtCoder", "difficulty": "hard", "tracks": [ "Imos" ], "tags": [ "Difference Array", "Sweep Line", "Interval-Cost" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Sparse endpoints, then prefix accumulation." }, { "slug": "foundations/difference-arrays", "topic": "Foundations -> Difference Arrays", "title": "Greg and Array", "url": "https://codeforces.com/problemset/problem/295/A", "source": "Codeforces", "difficulty": "medium", "tracks": [], "tags": [ "Difference Array", "Offline", "Range-Operations" ], "styles": [ "Modeling-Heavy", "Implementation-Heavy" ], "prerequisites": [ "Difference Arrays", "Prefix Sums", "Offline Processing" ], "bucket": "classic", "why_fit": "A strong benchmark for applying difference arrays both on operations and on the final array." }, { "slug": "foundations/difference-arrays", "topic": "Foundations -> Difference Arrays", "title": "Little Girl and Maximum Sum", "url": "https://codeforces.com/problemset/problem/276/C", "source": "Codeforces", "difficulty": "medium", "tracks": [], "tags": [ "Difference Array", "Sorting", "Frequency" ], "styles": [ "Greedy-Heavy", "Math-Heavy" ], "prerequisites": [ "Difference Arrays", "Sorting", "Prefix Counts" ], "bucket": "classic", "why_fit": "A classic frequency-by-intervals problem where the difference array makes the key idea obvious." }, { "slug": "foundations/prefix-sums", "topic": "Foundations -> Prefix Sums", "title": "Static Range Sum Queries", "url": "https://cses.fi/problemset/task/1646", "source": "CSES", "difficulty": "easy", "tracks": [], "tags": [ "Range-Sum", "Prefix-Sum", "Range-Query", "Precompute" ], "styles": [ "Implementation-Heavy" ], "prerequisites": [ "Prefix Sums", "Indexing", "Arrays" ], "bucket": "warm-up", "why_fit": "The simplest possible range-sum baseline for learning prefix preprocessing." }, { "slug": "foundations/prefix-sums", "topic": "Foundations -> Prefix Sums", "title": "Range Xor Queries", "url": "https://cses.fi/problemset/task/1650", "source": "CSES", "difficulty": "easy", "tracks": [], "tags": [ "Prefix-XOR", "Range-Query", "Bitwise" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Same template, but with xor accumulation." }, { "slug": "foundations/prefix-sums", "topic": "Foundations -> Prefix Sums", "title": "Subarray Sums I", "url": "https://cses.fi/problemset/task/1660", "source": "CSES", "difficulty": "medium", "tracks": [], "tags": [ "Two-Pointers", "Subarrays" ], "styles": [ "Implementation-Heavy" ], "prerequisites": [ "Prefix Sums", "Positive Arrays", "Sliding Window" ], "bucket": "core", "why_fit": "A classic positive-array sliding-window problem that is really prefix sums in disguise." }, { "slug": "foundations/prefix-sums", "topic": "Foundations -> Prefix Sums", "title": "Subarray Sums II", "url": "https://cses.fi/problemset/task/1661", "source": "CSES", "difficulty": "medium", "tracks": [], "tags": [ "Hash-Map", "Subarrays" ], "styles": [ "Implementation-Heavy", "Math-Heavy" ], "prerequisites": [ "Prefix Sums", "Hash Maps", "Counting" ], "bucket": "core", "why_fit": "A standard prefix-sum counting problem that generalizes the idea beyond positive numbers." }, { "slug": "foundations/prefix-sums", "topic": "Foundations -> Prefix Sums", "title": "Subarray Divisibility", "url": "https://cses.fi/problemset/task/1662", "source": "CSES", "difficulty": "medium", "tracks": [], "tags": [ "Mod Arithmetic", "Counting" ], "styles": [ "Math-Heavy" ], "prerequisites": [ "Prefix Sums", "Modular Arithmetic", "Frequency Counting" ], "bucket": "classic", "why_fit": "A canonical prefix-sum-plus-modulo benchmark that shows why equal remainders matter." }, { "slug": "foundations/prefix-sums", "topic": "Foundations -> Prefix Sums", "title": "Forest Queries", "url": "https://cses.fi/problemset/task/1652", "source": "CSES", "difficulty": "medium", "tracks": [], "tags": [ "2D Prefix Sums", "Rectangles", "Rectangle-Query", "Grid" ], "styles": [ "Modeling-Heavy", "Query-Heavy" ], "prerequisites": [ "Prefix Sums", "2D Grids", "Rectangle Inclusion-Exclusion" ], "bucket": "cross-topic", "why_fit": "A great 2D prefix-sum benchmark with a very reusable inclusion-exclusion pattern." }, { "slug": "foundations/recursion-backtracking", "topic": "Foundations -> Recursion And Backtracking", "title": "Apple Division", "url": "https://cses.fi/problemset/task/1623", "source": "CSES", "difficulty": "easy", "tracks": [], "tags": [ "Subset Search", "Brute Force" ], "styles": [ "Implementation" ], "prerequisites": [ "Recursion" ], "bucket": "warm-up", "why_fit": "A tiny subset-search benchmark that teaches clean recursive branching before heavier optimization." }, { "slug": "foundations/recursion-backtracking", "topic": "Foundations -> Recursion And Backtracking", "title": "Creating Strings", "url": "https://cses.fi/problemset/task/1622", "source": "CSES", "difficulty": "easy", "tracks": [], "tags": [ "Permutations", "Duplicates" ], "styles": [ "Implementation" ], "prerequisites": [ "Recursion", "Sorting" ], "bucket": "core", "why_fit": "A clean permutation-generation route where choice ordering and duplicate handling are the whole lesson." }, { "slug": "foundations/recursion-backtracking", "topic": "Foundations -> Recursion And Backtracking", "title": "Chessboard and Queens", "url": "https://cses.fi/problemset/task/1624", "source": "CSES", "difficulty": "medium", "tracks": [], "tags": [ "Pruning", "Board Search" ], "styles": [ "Implementation", "Pruning" ], "prerequisites": [ "Recursion", "Constraint Checks" ], "bucket": "classic", "why_fit": "A classic pruning benchmark where the search tree is still explicit and understandable." }, { "slug": "foundations/sorting", "topic": "Foundations -> Sorting", "title": "Apartments", "url": "https://cses.fi/problemset/task/1084", "source": "CSES", "difficulty": "easy", "tracks": [], "tags": [ "Two-Pointers", "Matching", "Sort" ], "styles": [ "Greedy-Heavy", "Implementation-Heavy" ], "prerequisites": [ "Sorting", "Two Pointers", "Greedy Matching" ], "bucket": "core", "why_fit": "A classic sorted two-pointer matching problem with a very clean greedy proof." }, { "slug": "foundations/sorting", "topic": "Foundations -> Sorting", "title": "Movie Festival", "url": "https://cses.fi/problemset/task/1629", "source": "CSES", "difficulty": "easy", "tracks": [], "tags": [ "Intervals", "Sort" ], "styles": [ "Greedy-Heavy" ], "prerequisites": [ "Sorting", "Interval Scheduling", "Greedy" ], "bucket": "core", "why_fit": "A textbook interval-scheduling problem that rewards sorting by finish time." }, { "slug": "foundations/sorting", "topic": "Foundations -> Sorting", "title": "Reading Books", "url": "https://cses.fi/problemset/task/1631", "source": "CSES", "difficulty": "easy", "tracks": [], "tags": [ "Scheduling" ], "styles": [ "Greedy-Heavy" ], "prerequisites": [ "Sorting", "Greedy Scheduling", "Prefix Sums" ], "bucket": "core", "why_fit": "A nice example of sorting plus a simple optimization argument." }, { "slug": "foundations/sorting", "topic": "Foundations -> Sorting", "title": "Tasks and Deadlines", "url": "https://cses.fi/problemset/task/1630", "source": "CSES", "difficulty": "medium", "tracks": [], "tags": [ "Sort", "Ordering" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "A very standard sort-by-duration optimization." }, { "slug": "foundations/sorting", "topic": "Foundations -> Sorting", "title": "Ferris Wheel", "url": "https://cses.fi/problemset/task/1090", "source": "CSES", "difficulty": "easy", "tracks": [], "tags": [ "Two-Pointers", "Pairing", "Sort" ], "styles": [ "Greedy-Heavy" ], "prerequisites": [ "Sorting", "Pairing", "Two Pointers" ], "bucket": "classic", "why_fit": "One of the most recognizable introductory sorting-and-greedy pairings." }, { "slug": "foundations/sorting", "topic": "Foundations -> Sorting", "title": "Stick Lengths", "url": "https://cses.fi/problemset/task/1074", "source": "CSES", "difficulty": "medium", "tracks": [], "tags": [ "Median", "Absolute-Deviation" ], "styles": [ "Math-Heavy", "Greedy-Heavy" ], "prerequisites": [ "Sorting", "Median", "Absolute Deviations" ], "bucket": "classic", "why_fit": "A classic benchmark for the median-minimizes-L1-cost idea after sorting." }, { "slug": "foundations/sorting", "topic": "Foundations -> Sorting", "title": "Nested Ranges Check", "url": "https://cses.fi/problemset/task/2168", "source": "CSES", "difficulty": "medium", "tracks": [], "tags": [ "Intervals", "Containment" ], "styles": [ "Proof-Heavy", "Greedy-Heavy" ], "prerequisites": [ "Sorting", "Interval Containment", "Sweep-Line Ideas" ], "bucket": "advanced", "why_fit": "A strong sorting problem where handling interval order and ties is the main challenge." }, { "slug": "foundations/stl", "topic": "Foundations -> STL Basics", "title": "Distinct Numbers", "url": "https://cses.fi/problemset/task/1621", "source": "CSES", "difficulty": "easy", "tracks": [], "tags": [ "Set", "Deduplication", "Frequency", "Sort", "Unique" ], "styles": [ "Data-Structure-Heavy", "Implementation-Heavy" ], "prerequisites": [ "Arrays", "Sets", "Hashing Basics" ], "bucket": "warm-up", "why_fit": "A straightforward entry point for seeing why a set or hash set is useful." }, { "slug": "foundations/stl", "topic": "Foundations -> STL Basics", "title": "Restaurant Customers", "url": "https://cses.fi/problemset/task/1619", "source": "CSES", "difficulty": "easy", "tracks": [], "tags": [ "Events", "Sweep Line", "Sorting" ], "styles": [ "Modeling-Heavy", "Implementation-Heavy" ], "prerequisites": [ "Sorting", "Event Processing", "Prefix Counts" ], "bucket": "core", "why_fit": "Useful for learning to model arrivals and departures as events and process them cleanly." }, { "slug": "foundations/stl", "topic": "Foundations -> STL Basics", "title": "Towers", "url": "https://cses.fi/problemset/task/1073", "source": "CSES", "difficulty": "medium", "tracks": [], "tags": [ "Multiset", "Lower Bound", "Patience" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Teaches the lower_bound pattern on a multiset." }, { "slug": "foundations/stl", "topic": "Foundations -> STL Basics", "title": "Concert Tickets", "url": "https://cses.fi/problemset/task/1091", "source": "CSES", "difficulty": "medium", "tracks": [], "tags": [ "Multiset", "Lower Bound" ], "styles": [ "Data-Structure-Heavy", "Greedy-Heavy" ], "prerequisites": [ "Sorting", "Ordered Multiset Ideas", "Greedy Matching" ], "bucket": "classic", "why_fit": "A canonical ordered-container problem that rewards knowing lower_bound-style queries." }, { "slug": "foundations/stl", "topic": "Foundations -> STL Basics", "title": "Room Allocation", "url": "https://cses.fi/problemset/task/1164", "source": "CSES", "difficulty": "medium", "tracks": [], "tags": [ "Priority-Queue", "Intervals", "Assignment" ], "styles": [ "Data-Structure-Heavy", "Greedy-Heavy" ], "prerequisites": [ "Sorting", "Priority Queues", "Interval Scheduling" ], "bucket": "classic", "why_fit": "A strong multiset/priority-queue assignment problem that feels very STL-native." }, { "slug": "foundations/stl", "topic": "Foundations -> STL Basics", "title": "Traffic Lights", "url": "https://cses.fi/problemset/task/1163", "source": "CSES", "difficulty": "medium", "tracks": [], "tags": [ "Ordered-Set", "Intervals", "Updates", "Neighbors" ], "styles": [ "Data-Structure-Heavy" ], "prerequisites": [ "Ordered Sets", "Interval Reasoning", "Sorting" ], "bucket": "classic", "why_fit": "A classic ordered-set exercise with dynamic insertions and interval maintenance." }, { "slug": "foundations/stl", "topic": "Foundations -> STL Basics", "title": "Sliding Window Cost", "url": "https://cses.fi/problemset/task/1077", "source": "CSES", "difficulty": "hard", "tracks": [], "tags": [ "Median", "Sliding-Window", "Absolute-Deviation" ], "styles": [ "Data-Structure-Heavy" ], "prerequisites": [ "Multisets", "Two Pointers", "Median Reasoning" ], "bucket": "advanced", "why_fit": "A deeper ordered-container problem that pairs median maintenance with cost accounting." }, { "slug": "foundations/stl", "topic": "Foundations -> STL Basics", "title": "Sliding Window Median", "url": "https://cses.fi/problemset/task/1076", "source": "CSES", "difficulty": "hard", "tracks": [], "tags": [ "Multiset", "Median", "Sliding-Window" ], "styles": [ "Data-Structure-Heavy", "Query-Heavy" ], "prerequisites": [ "Multisets", "Two Pointers", "Balanced Data Structures" ], "bucket": "advanced", "why_fit": "A demanding but standard STL benchmark for maintaining order statistics over a moving window." }, { "slug": "foundations/two-pointers", "topic": "Foundations -> Two Pointers", "title": "Playlist", "url": "https://cses.fi/problemset/task/1141", "source": "CSES", "difficulty": "medium", "tracks": [ "Sliding Window" ], "tags": [ "Distinctness", "Subarrays", "Distinct" ], "styles": [ "Implementation-Heavy", "Proof-Heavy" ], "prerequisites": [ "Two Pointers", "Hash Maps", "Window Invariants" ], "bucket": "core", "why_fit": "A clean sliding-window benchmark where the main skill is maintaining the window invariant." }, { "slug": "foundations/two-pointers", "topic": "Foundations -> Two Pointers", "title": "Subarray Sums I", "url": "https://cses.fi/problemset/task/1660", "source": "CSES", "difficulty": "medium", "tracks": [ "Sliding Window" ], "tags": [ "Subarrays", "Positive-Sums", "Positive-Array" ], "styles": [ "Implementation-Heavy" ], "prerequisites": [ "Two Pointers", "Positive Numbers", "Window Sums" ], "bucket": "core", "why_fit": "A standard positive-array window problem that helps lock in the expand-shrink pattern." }, { "slug": "foundations/two-pointers", "topic": "Foundations -> Two Pointers", "title": "Sum of Two Values", "url": "https://cses.fi/problemset/task/1640", "source": "CSES", "difficulty": "medium", "tracks": [], "tags": [ "Pair-Sum", "Hash-Map" ], "styles": [ "Implementation-Heavy" ], "prerequisites": [ "Sorting", "Hash Maps", "Pair Sums" ], "bucket": "core", "why_fit": "A common first pair-sum problem that can be solved with either hashing or sorted two pointers." }, { "slug": "foundations/two-pointers", "topic": "Foundations -> Two Pointers", "title": "Sliding Window Distinct Values", "url": "https://cses.fi/problemset/task/3222", "source": "CSES", "difficulty": "medium", "tracks": [], "tags": [ "Sliding-Window", "Frequency-Counting", "Distinct-Count" ], "styles": [ "Implementation-Heavy" ], "prerequisites": [ "Two Pointers", "Frequency Maps", "Window Maintenance" ], "bucket": "variants", "why_fit": "A direct sliding-window variant that reinforces the same pattern with a slightly different output." }, { "slug": "foundations/two-pointers", "topic": "Foundations -> Two Pointers", "title": "Ferris Wheel", "url": "https://cses.fi/problemset/task/1090", "source": "CSES", "difficulty": "easy", "tracks": [], "tags": [ "Pairing" ], "styles": [ "Greedy-Heavy" ], "prerequisites": [ "Sorting", "Two Pointers", "Greedy Matching" ], "bucket": "classic", "why_fit": "A textbook two-pointer pairing problem that is easy to teach and easy to reuse." }, { "slug": "foundations/two-pointers", "topic": "Foundations -> Two Pointers", "title": "Distinct Values Subarrays", "url": "https://cses.fi/problemset/task/3420", "source": "CSES", "difficulty": "medium", "tracks": [ "Sliding Window" ], "tags": [ "Distinctness", "Distinct-Count" ], "styles": [ "Proof-Heavy", "Implementation-Heavy" ], "prerequisites": [ "Two Pointers", "Frequency Counts", "Subarray Counting" ], "bucket": "classic", "why_fit": "A classic counting-by-window problem that builds strong two-pointer intuition." }, { "slug": "geometry/convex-hull", "topic": "Geometry -> Convex Hull", "title": "Convex Hull", "url": "https://cses.fi/problemset/task/2195", "source": "CSES", "difficulty": "medium", "tracks": [ "Sorting" ], "tags": [ "Orientation", "Monotone-Chain", "Boundary" ], "styles": [ "Sorting", "Stack/Scan" ], "prerequisites": [ "Orientation Test", "Sorting Points" ], "bucket": "core", "why_fit": "The canonical Andrew monotone-chain convex hull problem." }, { "slug": "geometry/convex-hull", "topic": "Geometry -> Convex Hull", "title": "Convex Hull Extension", "url": "https://codeforces.com/gym/104757/problem/C", "source": "Codeforces Gym", "difficulty": "hard", "tracks": [ "Extension" ], "tags": [ "Hull-Expansion", "Distance", "Construction" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Official contest problem centered on manipulating an existing hull." }, { "slug": "geometry/convex-hull", "topic": "Geometry -> Convex Hull", "title": "Polygons", "url": "https://codeforces.com/problemset/problem/166/B", "source": "Codeforces", "difficulty": "hard", "tracks": [ "Containment" ], "tags": [ "Strictly-Convex", "Inside-Test", "Polygon" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Strong convex-polygon containment practice with hull-style reasoning." }, { "slug": "geometry/convex-hull", "topic": "Geometry -> Convex Hull", "title": "U2", "url": "https://codeforces.com/problemset/problem/1143/F", "source": "Codeforces", "difficulty": "hard", "tracks": [], "tags": [ "Parabolas", "Upper-Hull", "Counting" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "A more advanced geometry task often grouped with convex-hull thinking." }, { "slug": "geometry/convex-hull", "topic": "Geometry -> Convex Hull", "title": "Maximum Manhattan Distances", "url": "https://cses.fi/problemset/task/3410", "source": "CSES", "difficulty": "hard", "tracks": [], "tags": [ "Manhattan Distance", "Transformations" ], "styles": [ "Extreme-Point Reasoning" ], "prerequisites": [ "Coordinate Transforms", "Extreme Value Tracking" ], "bucket": "challenge", "why_fit": "Manhattan extremes are often solved by hull-like geometric transforms." }, { "slug": "geometry/convex-hull", "topic": "Geometry -> Convex Hull", "title": "Minimum Euclidean Distance", "url": "https://cses.fi/problemset/task/2194", "source": "CSES", "difficulty": "hard", "tracks": [], "tags": [ "Closest Pair", "Sweep Line", "Plane Geometry" ], "styles": [ "Divide-And-Conquer", "Sweep-Line" ], "prerequisites": [ "Sorting Points", "Balanced Search By Y" ], "bucket": "challenge", "why_fit": "A standard advanced geometry problem closely tied to hull-style point geometry." }, { "slug": "geometry/counting-geometry", "topic": "Geometry -> Counting Geometry", "title": "Polygon Lattice Points", "url": "https://cses.fi/problemset/task/2193", "source": "CSES", "difficulty": "medium", "tracks": [], "tags": [ "Lattice Points", "Pick's Theorem" ], "styles": [ "Counting" ], "prerequisites": [ "GCD", "Shoelace Formula" ], "bucket": "core", "why_fit": "A perfect counting-geometry problem on polygons." }, { "slug": "geometry/counting-geometry", "topic": "Geometry -> Counting Geometry", "title": "Right Triangles", "url": "https://codeforces.com/problemset/problem/52/B", "source": "Codeforces", "difficulty": "medium", "tracks": [], "tags": [ "Grid Geometry", "Right Triangles" ], "styles": [ "Combinatorics" ], "prerequisites": [ "Row/Column Counting" ], "bucket": "core", "why_fit": "A grid-counting geometry problem with a simple but elegant formula." }, { "slug": "geometry/counting-geometry", "topic": "Geometry -> Counting Geometry", "title": "Satyam and Counting", "url": "https://codeforces.com/problemset/problem/2009/D", "source": "Codeforces", "difficulty": "hard", "tracks": [ "Triangles" ], "tags": [ "Points", "Right-Triangles", "Combinatorics" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "A modern CF counting-geometry task with triangle counting flavor." }, { "slug": "geometry/counting-geometry", "topic": "Geometry -> Counting Geometry", "title": "Triangles 3000", "url": "https://codeforces.com/problemset/problem/528/E", "source": "Codeforces", "difficulty": "very-hard", "tracks": [ "Lines" ], "tags": [ "Intersections", "Triangle-Counting", "Arrangements" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "A high-end geometric counting problem on line arrangements." }, { "slug": "geometry/counting-geometry", "topic": "Geometry -> Counting Geometry", "title": "Area of Rectangles", "url": "https://cses.fi/problemset/task/1741", "source": "CSES", "difficulty": "hard", "tracks": [ "Union-Area" ], "tags": [ "Area Union", "Sweep Line", "Measure", "Events", "Rectangle-Union" ], "styles": [ "Coordinate Compression" ], "prerequisites": [ "Interval Counting" ], "bucket": "challenge", "why_fit": "Area accumulation from geometric event processing." }, { "slug": "geometry/counting-geometry", "topic": "Geometry -> Counting Geometry", "title": "Intersection Points", "url": "https://cses.fi/problemset/task/1740", "source": "CSES", "difficulty": "hard", "tracks": [ "Sweep-Line" ], "tags": [ "Intersection Counting", "Orthogonal-Segments", "Events", "Counts" ], "styles": [ "Event Counting" ], "prerequisites": [], "bucket": "challenge", "why_fit": "Counts geometric events rather than constructing explicit shapes." }, { "slug": "geometry/half-plane-intersection", "topic": "Geometry -> Half-Plane Intersection", "title": "Big Brother", "url": "https://open.kattis.com/problems/bigbrother", "source": "Kattis", "difficulty": "medium", "tracks": [ "Polygon-Kernel" ], "tags": [ "Directed Lines", "Continuous Geometry", "Deque" ], "styles": [ "Geometry", "Implementation" ], "prerequisites": [ "Orientation", "Polygon Area", "Directed Line Sidedness" ], "bucket": "core", "why_fit": "The cleanest polygon-kernel benchmark where every polygon edge turns into one inward half-plane and the intended route is exactly angle-sorted half-plane intersection." }, { "slug": "geometry/minkowski-sum", "topic": "Geometry -> Minkowski Sum", "title": "Mogohu-Rea Idol", "url": "https://codeforces.com/problemset/problem/87/E", "source": "Codeforces", "difficulty": "very-hard", "tracks": [ "Point-In-Convex" ], "tags": [ "Convex Polygon", "Repeated Sum", "Point Query", "Center Of Mass" ], "styles": [ "Geometry", "Modeling", "Implementation" ], "prerequisites": [ "Convex Polygon Order", "Cross Product", "Point In Convex Polygon" ], "bucket": "stretch", "why_fit": "A stretch repeated-sum model where the basic two-polygon merge is already assumed and the real lesson is reusing it for three convex polygons plus scaled point-in-convex queries." }, { "slug": "geometry/nearest-pair", "topic": "Geometry -> Nearest Pair of Points", "title": "Closest Pair", "url": "https://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=CGL_5_A", "source": "AOJ", "difficulty": "medium", "tracks": [ "Sweep-Line" ], "tags": [ "Closest Pair", "Active Strip", "Euclidean Distance", "Ordered Set" ], "styles": [ "Geometry", "Implementation" ], "prerequisites": [ "Sorting Points", "Ordered Set By Y", "Squared Distance Bookkeeping" ], "bucket": "core", "why_fit": "The cleanest official nearest-pair benchmark where the intended route is exactly the standard x-sorted sweep with a y-ordered active strip." }, { "slug": "geometry/nearest-pair", "topic": "Geometry -> Nearest Pair of Points", "title": "Minimum Euclidean Distance", "url": "https://cses.fi/problemset/task/2194", "source": "CSES", "difficulty": "hard", "tracks": [], "tags": [ "Closest Pair", "Sweep Line", "Squared Distance", "Plane Geometry" ], "styles": [ "Implementation", "Sweep-Line" ], "prerequisites": [ "Sorting Points", "Active Strip", "Integer Distance Arithmetic" ], "bucket": "challenge", "why_fit": "A harder verifier-style sibling where the same nearest-pair sweep must be implemented carefully enough for contest-sized integer input." }, { "slug": "geometry/polygon-area-point-location", "topic": "Geometry -> Polygon Area And Point Location", "title": "Point Location Test", "url": "https://cses.fi/problemset/task/2189", "source": "CSES", "difficulty": "easy", "tracks": [ "Point-Location", "Orientation" ], "tags": [ "Cross-Product", "Relative-Position" ], "styles": [ "Implementation" ], "prerequisites": [ "Cross Product Sign" ], "bucket": "core", "why_fit": "A very lightweight point-location primitive useful in polygon code." }, { "slug": "geometry/polygon-area-point-location", "topic": "Geometry -> Polygon Area And Point Location", "title": "Polygon Area", "url": "https://cses.fi/problemset/task/2191", "source": "CSES", "difficulty": "easy", "tracks": [ "Polygon-Area", "Shoelace" ], "tags": [ "Shoelace Formula", "Signed-Area", "Cross-Product", "Simple-Polygon" ], "styles": [ "Formula Derivation" ], "prerequisites": [ "Cross Product" ], "bucket": "core", "why_fit": "A standard polygon-area starter problem." }, { "slug": "geometry/polygon-area-point-location", "topic": "Geometry -> Polygon Area And Point Location", "title": "Point in Polygon", "url": "https://cses.fi/problemset/task/2192", "source": "CSES", "difficulty": "medium", "tracks": [ "Point-Location" ], "tags": [ "Ray Casting", "Orientation", "Inside-Outside" ], "styles": [ "Parity Counting" ], "prerequisites": [ "Orientation Test", "Segment Intersection" ], "bucket": "core", "why_fit": "Directly trains point-in-polygon logic and boundary handling." }, { "slug": "geometry/polygon-area-point-location", "topic": "Geometry -> Polygon Area And Point Location", "title": "Polygon Lattice Points", "url": "https://cses.fi/problemset/task/2193", "source": "CSES", "difficulty": "medium", "tracks": [ "Polygon-Area", "Lattice-Points" ], "tags": [ "Pick's Theorem", "Pick-Theorem", "Boundary", "Interior" ], "styles": [ "Counting" ], "prerequisites": [ "Shoelace Formula", "GCD On Edges" ], "bucket": "core", "why_fit": "A classic Pick's theorem application." }, { "slug": "geometry/right-triangles", "topic": "Geometry -> Right Triangles", "title": "Triangle", "url": "https://codeforces.com/problemset/problem/18/A", "source": "Codeforces", "difficulty": "easy", "tracks": [ "Classification" ], "tags": [ "Distance-Checks", "Integer-Grid", "Right-Angle" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "A small but useful right-triangle recognition/classification task." }, { "slug": "geometry/right-triangles", "topic": "Geometry -> Right Triangles", "title": "Pythagorean Triples", "url": "https://codeforces.com/problemset/problem/707/C", "source": "Codeforces", "difficulty": "medium", "tracks": [ "Number Theory" ], "tags": [ "Integer-Sides", "Construction", "Pythagorean" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Directly about right triangles and integer side lengths." }, { "slug": "geometry/right-triangles", "topic": "Geometry -> Right Triangles", "title": "Right Triangles", "url": "https://codeforces.com/problemset/problem/52/B", "source": "Codeforces", "difficulty": "medium", "tracks": [ "Grid-Counting" ], "tags": [ "Combinatorics", "Orthogonal", "Stars-Grid" ], "styles": [ "Counting" ], "prerequisites": [ "Row/Column Counts" ], "bucket": "core", "why_fit": "The standard orthogonal grid right-triangle counting problem." }, { "slug": "geometry/right-triangles", "topic": "Geometry -> Right Triangles", "title": "Triangle", "url": "https://codeforces.com/contest/407/problem/A", "source": "Codeforces", "difficulty": "medium", "tracks": [ "Construction" ], "tags": [ "Integer-Coordinates", "Existence", "Coordinate-Geometry" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Constructing a right triangle with integer coordinates is core practice." }, { "slug": "geometry/right-triangles", "topic": "Geometry -> Right Triangles", "title": "Lovely Perfect Right Triangles", "url": "https://codeforces.com/gym/106215/problem/L", "source": "Codeforces Gym", "difficulty": "hard", "tracks": [], "tags": [ "Number Theory", "Counting" ], "styles": [ "Enumeration", "Number Theoretic Filtering" ], "prerequisites": [ "Pythagorean Triples", "GCD" ], "bucket": "challenge", "why_fit": "A harder right-triangle counting task with strong arithmetic structure." }, { "slug": "geometry/segment-intersection", "topic": "Geometry -> Segment Intersection", "title": "Line Segment Intersection", "url": "https://cses.fi/problemset/task/2190", "source": "CSES", "difficulty": "medium", "tracks": [ "Orientation" ], "tags": [ "Robust Geometry", "Ccw", "Overlap", "Touching" ], "styles": [ "Case Analysis" ], "prerequisites": [ "Orientation Tests", "Segment Bounding Boxes" ], "bucket": "core", "why_fit": "The canonical segment-intersection decision problem." }, { "slug": "geometry/segment-intersection", "topic": "Geometry -> Segment Intersection", "title": "Line Segments Trace I", "url": "https://cses.fi/problemset/task/3427", "source": "CSES", "difficulty": "medium", "tracks": [ "Sweep-Line" ], "tags": [ "Envelope", "Max-Point", "Scan" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "A line-segment scan problem where sweep-style reasoning is natural." }, { "slug": "geometry/segment-intersection", "topic": "Geometry -> Segment Intersection", "title": "Line Segments Trace II", "url": "https://cses.fi/problemset/task/3428", "source": "CSES", "difficulty": "hard", "tracks": [ "Sweep-Line" ], "tags": [ "Envelope", "Comparisons", "Scan" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "The harder companion to Trace I with similar line-sweep flavor." }, { "slug": "geometry/segment-intersection", "topic": "Geometry -> Segment Intersection", "title": "Area of Rectangles", "url": "https://cses.fi/problemset/task/1741", "source": "CSES", "difficulty": "hard", "tracks": [], "tags": [ "Sweep Line", "Interval Coverage", "Rectangles" ], "styles": [ "Sweep-Line", "Coordinate Compression" ], "prerequisites": [ "Segment Events", "Range Coverage" ], "bucket": "challenge", "why_fit": "The canonical rectangle-union sweep-line problem." }, { "slug": "geometry/segment-intersection", "topic": "Geometry -> Segment Intersection", "title": "Intersection Points", "url": "https://cses.fi/problemset/task/1740", "source": "CSES", "difficulty": "hard", "tracks": [ "Sweep-Line", "Intersection-Counting" ], "tags": [ "Orthogonal Segments", "Horizontal-Vertical", "Events", "Count" ], "styles": [ "Sweep-Line" ], "prerequisites": [ "Event Sorting", "Balanced Tree / Fenwick" ], "bucket": "challenge", "why_fit": "Counts many segment intersections with a line-sweep approach." }, { "slug": "geometry/sweep-line", "topic": "Geometry -> Sweep Line", "title": "Line Segments Trace I", "url": "https://cses.fi/problemset/task/3427", "source": "CSES", "difficulty": "medium", "tracks": [ "Envelope" ], "tags": [ "Scan", "Max-Query", "Segments" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Scan-line style reasoning over many segments." }, { "slug": "geometry/sweep-line", "topic": "Geometry -> Sweep Line", "title": "Line Segments Trace II", "url": "https://cses.fi/problemset/task/3428", "source": "CSES", "difficulty": "hard", "tracks": [ "Envelope" ], "tags": [ "Scan", "Events", "Segments" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "A more intricate sweep-line companion problem." }, { "slug": "geometry/sweep-line", "topic": "Geometry -> Sweep Line", "title": "Area of Rectangles", "url": "https://cses.fi/problemset/task/1741", "source": "CSES", "difficulty": "hard", "tracks": [ "Area-Union" ], "tags": [ "Rectangle Union", "Events", "Coordinate-Compression", "Rectangles" ], "styles": [ "Coordinate Compression" ], "prerequisites": [ "Event Sweep", "Interval Coverage" ], "bucket": "challenge", "why_fit": "The classic rectangle-union sweep benchmark." }, { "slug": "geometry/sweep-line", "topic": "Geometry -> Sweep Line", "title": "Intersection Points", "url": "https://cses.fi/problemset/task/1740", "source": "CSES", "difficulty": "hard", "tracks": [ "Intersection-Counting" ], "tags": [ "Orthogonal Segments", "Intersections", "Events", "Active-Set" ], "styles": [ "Event Sorting" ], "prerequisites": [ "Ordered Events", "Fenwick Tree / Balanced Bst" ], "bucket": "challenge", "why_fit": "A textbook sweep-line intersection counter." }, { "slug": "geometry/sweep-line", "topic": "Geometry -> Sweep Line", "title": "Lines and Queries I", "url": "https://cses.fi/problemset/task/3429", "source": "CSES", "difficulty": "hard", "tracks": [], "tags": [ "Line Containers", "Optimization" ], "styles": [ "Online", "Data-Structure-Heavy" ], "prerequisites": [ "Convex Hull Trick Basics", "Line Evaluation" ], "bucket": "challenge", "why_fit": "Not a pure sweep line, but a great event-driven geometry/data-structure hybrid." }, { "slug": "geometry/sweep-line", "topic": "Geometry -> Sweep Line", "title": "Minimum Euclidean Distance", "url": "https://cses.fi/problemset/task/2194", "source": "CSES", "difficulty": "hard", "tracks": [], "tags": [ "Closest Pair" ], "styles": [ "Divide-And-Conquer", "Sweep-Line" ], "prerequisites": [ "Sorting", "Plane Sweep Intuition" ], "bucket": "challenge", "why_fit": "The closest-pair sweep is a classic geometry engineering benchmark." }, { "slug": "geometry/vector-orientation", "topic": "Geometry -> Vector And Orientation", "title": "Point Location Test", "url": "https://cses.fi/problemset/task/2189", "source": "CSES", "difficulty": "easy", "tracks": [], "tags": [ "Cross Product", "Half-Plane", "Left-Right", "Point-In-Sector" ], "styles": [ "Implementation" ], "prerequisites": [ "Cross Product Sign" ], "bucket": "core", "why_fit": "Simple orientation logic with a direct geometric interpretation." }, { "slug": "geometry/vector-orientation", "topic": "Geometry -> Vector And Orientation", "title": "Polygon Area", "url": "https://cses.fi/problemset/task/2191", "source": "CSES", "difficulty": "easy", "tracks": [ "Shoelace" ], "tags": [ "Shoelace Formula", "Area", "Signed-Area", "Cross-Product", "Polygon" ], "styles": [ "Formula Derivation" ], "prerequisites": [ "Cross Product" ], "bucket": "core", "why_fit": "Shoelace is just accumulated oriented area." }, { "slug": "geometry/vector-orientation", "topic": "Geometry -> Vector And Orientation", "title": "Triangle", "url": "https://codeforces.com/problemset/problem/18/A", "source": "Codeforces", "difficulty": "easy", "tracks": [ "Triangle-Classification" ], "tags": [ "Right-Angle", "Integer-Coordinates", "Bruteforce" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "A compact geometry check built entirely around distances and angle tests." }, { "slug": "geometry/vector-orientation", "topic": "Geometry -> Vector And Orientation", "title": "Line Segment Intersection", "url": "https://cses.fi/problemset/task/2190", "source": "CSES", "difficulty": "medium", "tracks": [ "Segment-Geometry" ], "tags": [ "Segment Intersection", "Cross Product", "Ccw", "Intersection" ], "styles": [ "Case Analysis" ], "prerequisites": [ "Orientation Test", "Bounding Boxes" ], "bucket": "core", "why_fit": "The standard cross-product intersection test in its cleanest form." }, { "slug": "geometry/vector-orientation", "topic": "Geometry -> Vector And Orientation", "title": "Triangle", "url": "https://codeforces.com/contest/407/problem/A", "source": "Codeforces", "difficulty": "medium", "tracks": [ "Construction" ], "tags": [ "Integer-Points", "Right-Triangle", "Existence" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "A direct construction problem for a right triangle on the integer grid." }, { "slug": "graphs/bfs-dfs", "topic": "Graphs -> BFS And DFS", "title": "Monsters", "url": "https://cses.fi/problemset/task/1194", "source": "CSES", "difficulty": "medium", "tracks": [ "Multi-Source BFS", "Grid BFS" ], "tags": [ "Grid", "Timing" ], "styles": [ "Two-Phase BFS", "Distance Grid", "Path Reconstruction" ], "prerequisites": [ "Queue BFS", "Distance Arrays", "Grid Moves" ], "bucket": "core", "why_fit": "Classic BFS timing problem where monster arrival times reshape the reachable state space." }, { "slug": "graphs/bfs-dfs", "topic": "Graphs -> BFS And DFS", "title": "Labyrinth", "url": "https://cses.fi/problemset/task/1193", "source": "CSES", "difficulty": "easy", "tracks": [ "Grid" ], "tags": [ "Shortest Path", "Path Reconstruction", "Maze" ], "styles": [ "BFS Tree", "Parent Array", "Route Recovery" ], "prerequisites": [ "Queue BFS", "Parent Pointers", "4-Direction Moves" ], "bucket": "bfs-shortest-path", "why_fit": "A clean way to practice BFS plus path reconstruction on an unweighted graph." }, { "slug": "graphs/bfs-dfs", "topic": "Graphs -> BFS And DFS", "title": "Building Teams", "url": "https://cses.fi/problemset/task/1668", "source": "CSES", "difficulty": "easy", "tracks": [ "Bipartite" ], "tags": [ "Two-Coloring", "Bipartite Graph" ], "styles": [ "DFS Coloring", "Conflict Detection", "Component Handling" ], "prerequisites": [ "Graph Traversal", "Parity Coloring", "Visited States" ], "bucket": "bipartite-check", "why_fit": "A canonical traversal problem that turns friendship constraints into bipartite checking." }, { "slug": "graphs/bfs-dfs", "topic": "Graphs -> BFS And DFS", "title": "Counting Rooms", "url": "https://cses.fi/problemset/task/1192", "source": "CSES", "difficulty": "easy", "tracks": [ "Grid" ], "tags": [ "Flood Fill", "Components", "Visited Cells" ], "styles": [ "DFS Flood Fill", "Component Sweep", "Boundary Checks" ], "prerequisites": [ "DFS", "Visited Array", "Grid Traversal" ], "bucket": "connected-components", "why_fit": "A textbook first traversal problem with no extra graph tricks." }, { "slug": "graphs/bfs-dfs", "topic": "Graphs -> BFS And DFS", "title": "Round Trip II", "url": "https://cses.fi/problemset/task/1678", "source": "CSES", "difficulty": "medium", "tracks": [ "Directed Graphs" ], "tags": [ "Directed Cycle", "Recursion Stack", "Witness Path", "Topological Intuition", "Reconstruction" ], "styles": [ "DFS State Colors", "Stack-Based Recovery", "Cycle Witness" ], "prerequisites": [ "Directed DFS", "Back-Edge Detection", "Parent Pointers" ], "bucket": "directed-cycle", "why_fit": "The directed counterpart to Round Trip, with trickier cycle recovery." }, { "slug": "graphs/bfs-dfs", "topic": "Graphs -> BFS And DFS", "title": "Round Trip", "url": "https://cses.fi/problemset/task/1669", "source": "CSES", "difficulty": "medium", "tracks": [ "Cycles" ], "tags": [ "Undirected Cycle", "Back Edge", "Witness Path", "Cycle Detection", "Undirected Graph", "Reconstruction" ], "styles": [ "DFS Parent Tracking", "Cycle Reconstruction", "Component Scan" ], "prerequisites": [ "DFS", "Parent Pointers", "Recursion Stack" ], "bucket": "undirected-cycle", "why_fit": "Great practice for detecting and reconstructing a cycle in an undirected graph." }, { "slug": "graphs/bfs-dfs", "topic": "Graphs -> BFS And DFS", "title": "Message Route", "url": "https://cses.fi/problemset/task/1667", "source": "CSES", "difficulty": "easy", "tracks": [ "Paths" ], "tags": [ "Unweighted Shortest Path", "Path Reconstruction", "Network", "Shortest Path" ], "styles": [ "Layered BFS", "Parent Tracking", "Shortest Route Recovery" ], "prerequisites": [ "BFS", "Adjacency Lists", "Backtracking" ], "bucket": "unweighted-bfs", "why_fit": "The standard shortest-path-in-an-unweighted-graph template." }, { "slug": "graphs/bridges-articulation", "topic": "Graphs -> Bridges, Articulation, And BCC", "title": "Necessary Cities", "url": "https://cses.fi/problemset/task/2077", "source": "CSES", "difficulty": "medium", "tracks": [ "Low-Link" ], "tags": [ "Critical Vertices", "Root Case", "Cut Vertices" ], "styles": [ "Low-Link DFS", "Root Special Case", "Critical Vertex Output" ], "prerequisites": [ "DFS", "Undirected Graphs", "Low-Link Inequalities" ], "bucket": "core", "why_fit": "The matching articulation-point counterpart to Necessary Roads." }, { "slug": "graphs/bridges-articulation", "topic": "Graphs -> Bridges, Articulation, And BCC", "title": "Necessary Roads", "url": "https://cses.fi/problemset/task/2076", "source": "CSES", "difficulty": "medium", "tracks": [ "Low-Link" ], "tags": [ "Critical Edges", "DFS Tree", "Bridge Detection" ], "styles": [ "Low-Link DFS", "Bridge Detection", "Critical Edge Output" ], "prerequisites": [ "DFS", "Undirected Graphs", "Entry Times" ], "bucket": "core", "why_fit": "The cleanest bridge-only contest problem for learning the strict low-link inequality." }, { "slug": "graphs/bridges-articulation", "topic": "Graphs -> Bridges, Articulation, And BCC", "title": "Two-Edge-Connected Components", "url": "https://judge.yosupo.jp/problem/two_edge_connected_components", "source": "Library Checker", "difficulty": "medium", "tracks": [ "Two-Edge-Connected Components" ], "tags": [ "Bridge Compression", "2-Edge Connectivity" ], "styles": [ "Bridge Removal", "Component Compression", "Tree Of Components" ], "prerequisites": [ "Bridge Detection", "DFS", "Connected Components" ], "bucket": "practice", "why_fit": "A direct verifier once bridges themselves are trusted and you want the compression layer." }, { "slug": "graphs/bridges-articulation", "topic": "Graphs -> Bridges, Articulation, And BCC", "title": "Submerging Islands", "url": "https://www.spoj.com/problems/SUBMERGE/", "source": "SPOJ", "difficulty": "medium", "tracks": [ "Classic" ], "tags": [ "Cut Vertices", "Articulation Points" ], "styles": [ "Low-Link DFS", "Cut Vertex Counting", "Root Handling" ], "prerequisites": [ "DFS", "Undirected Graphs", "Low-Link" ], "bucket": "classic", "why_fit": "A classic articulation-point problem where the root case and repeated reporting both matter." }, { "slug": "graphs/bridges-articulation", "topic": "Graphs -> Bridges, Articulation, And BCC", "title": "Forbidden Cities", "url": "https://cses.fi/problemset/task/1705", "source": "CSES", "difficulty": "hard", "tracks": [ "Bcc", "Block-Cut Tree" ], "tags": [ "Vertex-Biconnected Components" ], "styles": [ "Block-Cut Tree", "LCA On Reduced Structure", "Query Reduction" ], "prerequisites": [ "Articulation Points", "Trees", "LCA" ], "bucket": "stretch", "why_fit": "The strongest practical reason to go beyond plain articulation points into full block-cut structure." }, { "slug": "graphs/centroid-decomposition", "topic": "Graphs -> Centroid Decomposition", "title": "Finding a Centroid", "url": "https://cses.fi/problemset/task/2079", "source": "CSES", "difficulty": "medium", "tracks": [ "Trees" ], "tags": [ "Subtree Sizes", "Balance Check" ], "styles": [ "Subtree Sizes", "Balance Check", "Candidate Descent" ], "prerequisites": [ "DFS", "Subtree Sizes", "Rooted Tree" ], "bucket": "warm-up", "why_fit": "The cleanest warm-up for the centroid existence proof and the heavy-child walk used before full decomposition." }, { "slug": "graphs/centroid-decomposition", "topic": "Graphs -> Centroid Decomposition", "title": "Ciel the Commander", "url": "https://codeforces.com/problemset/problem/321/C", "source": "Codeforces", "difficulty": "hard", "tracks": [ "Construction" ], "tags": [ "Centroid Tree", "Recursive Labeling", "Balanced Split" ], "styles": [ "Centroid Decomposition", "Recursive Labeling", "Tree Partition" ], "prerequisites": [ "Centroid Basics", "Static Trees", "Subtree Sizes" ], "bucket": "core", "why_fit": "The strongest first full decomposition problem because the answer is literally the centroid-tree depth labeling." }, { "slug": "graphs/centroid-decomposition", "topic": "Graphs -> Centroid Decomposition", "title": "Xenia and Tree", "url": "https://codeforces.com/problemset/problem/342/E", "source": "Codeforces", "difficulty": "hard", "tracks": [ "Queries" ], "tags": [ "Nearest Marked Node", "Centroid Ancestors", "Distance Aggregation" ], "styles": [ "Centroid Ancestors", "Distance Aggregation", "Online Queries" ], "prerequisites": [ "Centroid Decomposition", "Tree Distances", "O(log N) Ancestor Walk" ], "bucket": "practice", "why_fit": "The canonical update/query problem where each operation becomes a walk over one logarithmic centroid-ancestor chain." }, { "slug": "graphs/centroid-decomposition", "topic": "Graphs -> Centroid Decomposition", "title": "Fixed-Length Paths I", "url": "https://cses.fi/problemset/task/2080", "source": "CSES", "difficulty": "hard", "tracks": [ "Path Counting" ], "tags": [ "Exact Length", "Depth Histogram", "Through-Centroid Counting" ], "styles": [ "Path Counting", "Depth Collection", "Frequency Merge" ], "prerequisites": [ "Centroid Decomposition", "DFS Depth Collection", "Frequency Counting" ], "bucket": "stretch", "why_fit": "The cleanest path-counting benchmark once you trust that every path is handled at the first centroid where its endpoints split." }, { "slug": "graphs/centroid-decomposition", "topic": "Graphs -> Centroid Decomposition", "title": "Fixed-Length Paths II", "url": "https://cses.fi/problemset/task/2081", "source": "CSES", "difficulty": "hard", "tracks": [ "Path Counting" ], "tags": [ "Length Range", "Depth Prefix Counts", "Through-Centroid Counting" ], "styles": [ "Path Counting", "Range Counting", "Prefix Merge" ], "prerequisites": [ "Centroid Decomposition", "Fixed-Length Paths I", "Prefix Sums" ], "bucket": "advanced", "why_fit": "A natural next step after exact-length counting, where the merge logic becomes the real difficulty rather than the decomposition itself." }, { "slug": "graphs/de-bruijn-sequence", "topic": "Graphs -> De Bruijn Sequence", "title": "De Bruijn Sequence", "url": "https://cses.fi/problemset/task/1692", "source": "CSES", "difficulty": "hard", "tracks": [ "Graph Modeling", "Construction" ], "tags": [ "De Bruijn Graph", "Eulerian Cycle", "Bitmask States" ], "styles": [ "State Graph Modeling", "Eulerian Construction", "String Reconstruction" ], "prerequisites": [ "Eulerian Cycle", "Bitmask States" ], "bucket": "core", "why_fit": "The clean binary flagship where overlap-state modeling is the whole trick, and an Eulerian cycle is only the execution engine after the graph is revealed." }, { "slug": "graphs/euler-tour-subtree", "topic": "Graphs -> Euler Tour / Subtree Queries", "title": "Subtree Queries", "url": "https://cses.fi/problemset/task/1137", "source": "CSES", "difficulty": "medium", "tracks": [ "Trees", "Euler Tour" ], "tags": [ "Subtree Sum", "Updates", "Fenwick" ], "styles": [ "Flatten Tree", "Fenwick Tree", "Range Sum Queries" ], "prerequisites": [ "Rooted Tree", "Fenwick Tree" ], "bucket": "core", "why_fit": "The canonical subtree-interval problem where flattening a rooted tree turns each subtree into one range query." }, { "slug": "graphs/euler-tour-subtree", "topic": "Graphs -> Euler Tour / Subtree Queries", "title": "Count Descendants", "url": "https://atcoder.jp/contests/abc202/tasks/abc202_e", "source": "AtCoder", "difficulty": "medium", "tracks": [ "Trees", "Euler Tour" ], "tags": [ "Subtree Interval", "Depth Buckets", "Offline" ], "styles": [ "Flatten Tree", "Offline Counting", "Binary Search" ], "prerequisites": [ "Subtree Intervals", "Binary Search" ], "bucket": "stretch", "why_fit": "A clean next step where subtree intervals stay the same but you intersect them with depth-grouped positions." }, { "slug": "graphs/euler-tour-subtree", "topic": "Graphs -> Euler Tour / Subtree Queries", "title": "Distinct Colors", "url": "https://cses.fi/problemset/task/1139", "source": "CSES", "difficulty": "hard", "tracks": [ "Trees" ], "tags": [ "Distinct Values", "Subtree Aggregation", "Offline" ], "styles": [ "Flatten Tree", "Offline Queries", "Subtree Aggregation" ], "prerequisites": [ "Euler Tour", "Subtree Intervals", "Offline Reasoning" ], "bucket": "stretch", "why_fit": "A stretch problem showing that the same subtree interval view can feed a different offline engine once sum/count is no longer enough." }, { "slug": "graphs/euler-tour-subtree", "topic": "Graphs -> Euler Tour / Subtree Queries", "title": "Path Queries", "url": "https://cses.fi/problemset/task/1138", "source": "CSES", "difficulty": "medium", "tracks": [ "Trees", "Euler Tour" ], "tags": [ "Root Path Sum", "Updates", "Tree Flattening" ], "styles": [ "Euler Tour", "Fenwick Tree", "Prefix On Tree" ], "prerequisites": [ "Tree Flattening", "Fenwick Tree", "Rooted Tree" ], "bucket": "bridge", "why_fit": "A strong compare point once subtree intervals are trusted and you want to see how similar flattening ideas answer a different rooted-tree query." }, { "slug": "graphs/euler-tour-tree", "topic": "Graphs -> Euler Tour Tree", "title": "Dynamic Tree Vertex Add Subtree Sum", "url": "https://judge.yosupo.jp/problem/dynamic_tree_vertex_add_subtree_sum", "source": "Library Checker", "difficulty": "very-hard", "tracks": [ "Dynamic Trees" ], "tags": [ "Dynamic Forest", "Subtree Sum", "Vertex Add" ], "styles": [ "Dynamic Trees", "Subtree Aggregate", "Verifier" ], "prerequisites": [ "Rooted Tree Intuition", "Split / Merge Sequence", "Make Root By Rotation" ], "bucket": "core", "why_fit": "The cleanest exact verifier for the first narrow Euler-tour-tree route: dynamic forest, point add on vertices, and subtree-side sums on one existing edge." }, { "slug": "graphs/euler-tour-tree", "topic": "Graphs -> Euler Tour Tree", "title": "Dynamic Tree Subtree Add Subtree Sum", "url": "https://judge.yosupo.jp/problem/dynamic_tree_subtree_add_subtree_sum", "source": "Library Checker", "difficulty": "very-hard", "tracks": [ "Dynamic Trees" ], "tags": [ "Dynamic Forest", "Lazy Propagation", "Subtree Sum" ], "styles": [ "Dynamic Trees", "Lazy Range Update", "Verifier" ], "prerequisites": [ "Euler Tour Tree", "Subtree Interval View", "Lazy Propagation" ], "bucket": "stretch", "why_fit": "A natural stretch once the point-add route is trusted and the same subtree-side interval view must carry a stronger lazy update." }, { "slug": "graphs/eulerian-path-cycle", "topic": "Graphs -> Eulerian Path / Cycle", "title": "Mail Delivery", "url": "https://cses.fi/problemset/task/1691", "source": "CSES", "difficulty": "medium", "tracks": [ "Undirected" ], "tags": [ "Eulerian Cycle", "Hierholzer", "Degree Parity", "Undirected Graphs" ], "styles": [ "Hierholzer Traversal", "Degree Check", "Witness Output" ], "prerequisites": [ "Undirected Graphs", "Degree Parity", "DFS-Style Traversal" ], "bucket": "core", "why_fit": "The cleanest first contest problem for undirected Eulerian cycles: parity, connected support, and one Hierholzer walk." }, { "slug": "graphs/eulerian-path-cycle", "topic": "Graphs -> Eulerian Path / Cycle", "title": "Teleporters Path", "url": "https://cses.fi/problemset/task/1693", "source": "CSES", "difficulty": "hard", "tracks": [ "Directed" ], "tags": [ "Eulerian Path", "Directed Graphs", "In-Out Balance", "Hierholzer" ], "styles": [ "Directed Hierholzer", "Balance Check", "Start-End Enforcement" ], "prerequisites": [ "Directed Graphs", "Indegree And Outdegree", "Eulerian Trail Conditions" ], "bucket": "core", "why_fit": "The canonical directed-path benchmark where start and end are fixed and in/out balance matters more than parity." }, { "slug": "graphs/eulerian-path-cycle", "topic": "Graphs -> Eulerian Path / Cycle", "title": "Play on Words", "url": "https://onlinejudge.org/external/1/10129.pdf", "source": "UVa", "difficulty": "medium", "tracks": [ "Classic" ], "tags": [ "String To Graph", "Directed Eulerian Path" ], "styles": [ "Modeling", "Balance Check", "Connected Support" ], "prerequisites": [ "Directed Graphs", "Eulerian Path Conditions", "Graph Modeling" ], "bucket": "classic", "why_fit": "A classic Eulerian-reduction problem where statement parsing and graph support checks matter as much as the traversal itself." }, { "slug": "graphs/flow", "topic": "Graphs -> Maximum Flow", "title": "Download Speed", "url": "https://cses.fi/problemset/task/1694", "source": "CSES", "difficulty": "medium", "tracks": [], "tags": [ "Directed Graphs", "S-T Cut", "Max Flow", "Capacity", "Network Throughput" ], "styles": [ "Dinic", "S-T Max Flow" ], "prerequisites": [ "Network Flow Basics", "Residual Graph" ], "bucket": "core", "why_fit": "Clean source-sink max-flow application." }, { "slug": "graphs/flow", "topic": "Graphs -> Maximum Flow", "title": "Maximum Flow", "url": "https://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=GRL_6_A", "source": "AOJ", "difficulty": "medium", "tracks": [], "tags": [ "Max Flow", "Push-Relabel", "Dinic", "Network" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Official max-flow baseline." }, { "slug": "graphs/flow", "topic": "Graphs -> Maximum Flow", "title": "Police Chase", "url": "https://cses.fi/problemset/task/1695", "source": "CSES", "difficulty": "medium", "tracks": [], "tags": [ "Min Cut", "Max Flow", "Edge Cut" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Exact minimum cut with an output certificate." }, { "slug": "graphs/flow", "topic": "Graphs -> Maximum Flow", "title": "Fast Maximum Flow", "url": "https://www.spoj.com/SPOJ/problems/FASTFLOW", "source": "SPOJ", "difficulty": "medium", "tracks": [ "Min Cut" ], "tags": [ "Undirected Graphs", "Capacity" ], "styles": [ "Dinic", "Residual Graph" ], "prerequisites": [ "Augmenting Paths", "Capacity Residuals" ], "bucket": "classic", "why_fit": "The standard introductory max-flow/min-cut baseline." }, { "slug": "graphs/flow", "topic": "Graphs -> Maximum Flow", "title": "Angry Programmer", "url": "https://onlinejudge.org/external/115/11506.pdf", "source": "UVa", "difficulty": "hard", "tracks": [ "Min Cut", "Node Splitting" ], "tags": [ "Vertex Cuts", "Security Model" ], "styles": [ "Node/Edge Splitting", "Min Cut Modeling" ], "prerequisites": [ "Flow Modeling", "Min Cut Interpretation" ], "bucket": "advanced", "why_fit": "Combines vertex and edge cuts, which is the classic split-node flow pattern." }, { "slug": "graphs/flow", "topic": "Graphs -> Maximum Flow", "title": "Distinct Routes", "url": "https://cses.fi/problemset/task/1711", "source": "CSES", "difficulty": "hard", "tracks": [ "Path Decomposition" ], "tags": [ "Route Packing", "Max Flow", "Edge-Disjoint Paths", "Route Recovery" ], "styles": [ "Unit-Capacity Flow", "Path Extraction" ], "prerequisites": [ "Augmenting Paths", "Route Decomposition" ], "bucket": "advanced", "why_fit": "Transforms edge-disjoint paths into a flow problem." }, { "slug": "graphs/flow", "topic": "Graphs -> Maximum Flow", "title": "The Problem with the Problem Setter", "url": "https://onlinejudge.org/external/100/10092.pdf", "source": "UVa", "difficulty": "medium", "tracks": [ "Bipartite Flow" ], "tags": [ "Matching", "Assignment" ], "styles": [ "Bipartite Flow", "Source-Sink Layering" ], "prerequisites": [ "Bipartite Modeling", "Flow Conservation" ], "bucket": "cross-topic", "why_fit": "A classic bipartite flow reduction with multiple source groups." }, { "slug": "graphs/flow", "topic": "Graphs -> Maximum Flow", "title": "Power Transmission", "url": "https://onlinejudge.org/external/103/10330.pdf", "source": "UVa", "difficulty": "hard", "tracks": [ "Node Splitting" ], "tags": [ "Vertex Capacities" ], "styles": [ "Vertex Splitting", "Capacity Constraints" ], "prerequisites": [ "Flow Modeling", "Vertex Capacity To Edge Capacity" ], "bucket": "cross-topic", "why_fit": "Uses node capacities, so it is a textbook vertex-splitting model." }, { "slug": "graphs/flow-lower-bounds", "topic": "Graphs -> Flow With Lower Bounds", "title": "Reactor Cooling", "url": "https://codeforces.com/problemsets/acmsguru/problem/99999/194", "source": "Codeforces acmsguru", "difficulty": "hard", "tracks": [ "Lower Bounds" ], "tags": [ "Feasible Circulation", "Balance Array", "Witness Output" ], "styles": [ "Reduction", "Witness Output" ], "prerequisites": [ "Maximum Flow", "Residual Graph", "Super Source / Super Sink" ], "bucket": "core", "why_fit": "The canonical first lower-bounds circulation problem: every edge has mandatory minimum and maximum flow, and you must print one witness in input order." }, { "slug": "graphs/flow-lower-bounds", "topic": "Graphs -> Flow With Lower Bounds", "title": "Minimum Cost b-Flow", "url": "https://judge.yosupo.jp/problem/min_cost_b_flow", "source": "Library Checker", "difficulty": "hard", "tracks": [ "Lower Bounds", "Cost" ], "tags": [ "Node Supply/Demand", "Costed Flow" ], "styles": [ "Verification", "Cross-Topic" ], "prerequisites": [ "Flow With Lower Bounds", "Min-Cost Flow", "Supply / Demand Modeling" ], "bucket": "advanced", "why_fit": "A strong official compare point showing how lower bounds and node balances grow into the costed b-flow family." }, { "slug": "graphs/general-matching", "topic": "Graphs -> Edmonds Blossom / General Matching", "title": "Matching on General Graph", "url": "https://judge.yosupo.jp/problem/general_matching", "source": "Library Checker", "difficulty": "hard", "tracks": [ "Blossom" ], "tags": [ "Edmonds Blossom", "Odd Cycle", "Maximum Matching" ], "styles": [ "Template Problem", "Non-Bipartite Matching" ], "prerequisites": [ "Augmenting Paths", "Alternating Forest", "Matching Basics" ], "bucket": "core", "why_fit": "The cleanest direct benchmark where the graph is explicitly general and the whole task is just blossom-based maximum matching." }, { "slug": "graphs/general-matching", "topic": "Graphs -> Edmonds Blossom / General Matching", "title": "P6113 [Template] General Graph Maximum Matching", "url": "https://www.luogu.com.cn/problem/P6113", "source": "Luogu", "difficulty": "hard", "tracks": [ "Blossom" ], "tags": [ "Template", "Maximum Matching" ], "styles": [ "Template Drill", "Non-Bipartite Matching" ], "prerequisites": [ "Augmenting Paths", "Odd Cycle Contraction" ], "bucket": "practice", "why_fit": "A straightforward second template benchmark once the Library Checker route feels stable." }, { "slug": "graphs/general-matching", "topic": "Graphs -> Edmonds Blossom / General Matching", "title": "QBFLOWER - Tặng hoa", "url": "https://vn.spoj.com/problems/QBFLOWER/", "source": "VN SPOJ", "difficulty": "medium", "tracks": [ "Edge Cover" ], "tags": [ "Minimum Edge Cover", "Graph Transformation" ], "styles": [ "Modeling", "Transformation" ], "prerequisites": [ "Maximum Matching", "Edge Cover Formula" ], "bucket": "bridge", "why_fit": "A strong bridge problem where blossom is still the engine, but only after reducing the story to minimum edge cover on a general graph." }, { "slug": "graphs/global-min-cut", "topic": "Graphs -> Randomized / Global Min-Cut", "title": "Police Chase", "url": "https://cses.fi/problemset/task/1695", "source": "CSES", "difficulty": "medium", "tracks": [ "Min Cut", "Edge Cut", "Flow" ], "tags": [ "Roads", "Certificate" ], "styles": [ "S-T Min Cut", "Edge Extraction" ], "prerequisites": [ "Max Flow", "Cut Extraction" ], "bucket": "warm-up", "why_fit": "Another clean compare point: extract one cut certificate first, then move to the global family where no designated pair remains." }, { "slug": "graphs/global-min-cut", "topic": "Graphs -> Randomized / Global Min-Cut", "title": "Minimum Cut", "url": "http://poj.org/problem?id=2914", "source": "POJ", "difficulty": "hard", "tracks": [ "Undirected Cuts" ], "tags": [ "Stoer-Wagner", "Cut Contraction" ], "styles": [ "Stoer-Wagner", "Dense Cut Phases" ], "prerequisites": [ "Max Flow Min Cut Intuition", "Undirected Weighted Graphs" ], "bucket": "core", "why_fit": "Canonical global min-cut benchmark: no designated source/sink, parallel edges allowed, and the whole task is exactly the cut-family route." }, { "slug": "graphs/global-min-cut", "topic": "Graphs -> Randomized / Global Min-Cut", "title": "Sabotage", "url": "https://onlinejudge.org/external/104/10480.pdf", "source": "UVa", "difficulty": "medium", "tracks": [ "Min Cut", "Flow" ], "tags": [ "Graph Partition" ], "styles": [ "S-T Min Cut", "Cut Extraction" ], "prerequisites": [ "Max Flow", "Minimum Cut" ], "bucket": "classic", "why_fit": "Warm-up compare point: still one cut-extraction task, useful before the no-source/sink global min-cut lane." }, { "slug": "graphs/gomory-hu", "topic": "Graphs -> Gomory-Hu Tree", "title": "Download Speed", "url": "https://cses.fi/problemset/task/1694", "source": "CSES", "difficulty": "medium", "tracks": [ "Cuts" ], "tags": [ "Max Flow", "Source-Sink Cut", "Network" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Good single-pair cut practice before all-pairs cuts." }, { "slug": "graphs/gomory-hu", "topic": "Graphs -> Gomory-Hu Tree", "title": "Maximum Flow", "url": "https://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=GRL_6_A", "source": "AOJ", "difficulty": "medium", "tracks": [ "Cuts" ], "tags": [ "Max Flow", "Min Cut", "Baseline" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Core primitive behind Gomory-Hu construction." }, { "slug": "graphs/gomory-hu", "topic": "Graphs -> Gomory-Hu Tree", "title": "Police Chase", "url": "https://cses.fi/problemset/task/1695", "source": "CSES", "difficulty": "medium", "tracks": [ "Min Cut", "Edge-Disjoint Separation", "Cuts" ], "tags": [ "Flow", "Roads", "Edge Cut", "Certificate" ], "styles": [ "S-T Min Cut", "Edge Extraction" ], "prerequisites": [ "Max Flow", "Cut Extraction" ], "bucket": "core", "why_fit": "Single-pair min cut, useful as the entry point before GH-tree compression." }, { "slug": "graphs/gomory-hu", "topic": "Graphs -> Gomory-Hu Tree", "title": "Gomory-Hu Tree", "url": "https://judge.yosupo.jp/problem/gomory_hu_tree", "source": "Library Checker", "difficulty": "hard", "tracks": [ "Cut-Trees" ], "tags": [ "All-Pairs Min-Cut", "Tree Of Cuts" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "The direct canonical problem for the topic." }, { "slug": "graphs/gomory-hu", "topic": "Graphs -> Gomory-Hu Tree", "title": "Sabotage", "url": "https://onlinejudge.org/external/104/10480.pdf", "source": "UVa", "difficulty": "medium", "tracks": [ "Min Cut", "Global Min Cut" ], "tags": [ "Flow", "Cuts", "Graph Partition" ], "styles": [ "Undirected Min Cut", "Cut Extraction" ], "prerequisites": [ "Max Flow", "Minimum Cut" ], "bucket": "classic", "why_fit": "A classic minimum-cut problem that motivates cut-tree thinking." }, { "slug": "graphs/gomory-hu", "topic": "Graphs -> Gomory-Hu Tree", "title": "Pumping Stations", "url": "https://codeforces.com/problemset/problem/343/E", "source": "Codeforces", "difficulty": "very-hard", "tracks": [ "Gomory-Hu Tree", "Pairwise Min Cuts" ], "tags": [ "Flow", "Trees", "Divide And Conquer" ], "styles": [ "Gh Tree Reasoning", "Cut-Tree Structure" ], "prerequisites": [ "Max Flow", "Min Cut", "Tree Compression" ], "bucket": "advanced", "why_fit": "A famous Codeforces problem whose intended insight is cut-tree structure." }, { "slug": "graphs/gomory-hu", "topic": "Graphs -> Gomory-Hu Tree", "title": "All Pairs Maximum Flow", "url": "https://onlinejudge.org/external/115/11594.pdf", "source": "UVa", "difficulty": "hard", "tracks": [ "Gomory-Hu Tree", "All-Pairs Min Cut" ], "tags": [ "Flow", "Trees" ], "styles": [ "Build Cut Tree", "Query Path Minima" ], "prerequisites": [ "Max Flow", "Min Cut", "Tree Path Minima" ], "bucket": "theory", "why_fit": "This is essentially the GH-tree use case: compress all pairwise min-cuts." }, { "slug": "graphs/graph-modeling", "topic": "Graphs -> Graph Modeling", "title": "Building Roads", "url": "https://cses.fi/problemset/task/1666", "source": "CSES", "difficulty": "easy", "tracks": [ "Components" ], "tags": [ "Connected Components", "Construction", "Union-Find" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Simple component-based modeling: connect all components with minimum new edges." }, { "slug": "graphs/graph-modeling", "topic": "Graphs -> Graph Modeling", "title": "Message Route", "url": "https://cses.fi/problemset/task/1667", "source": "CSES", "difficulty": "easy", "tracks": [ "BFS" ], "tags": [ "Unweighted Graph", "Path Reconstruction", "Shortest Path" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Bare-bones graph modeling for shortest path with a concrete route output." }, { "slug": "graphs/graph-modeling", "topic": "Graphs -> Graph Modeling", "title": "Third Avenue", "url": "https://atcoder.jp/contests/abc184/tasks/abc184_e", "source": "AtCoder", "difficulty": "medium", "tracks": [ "Grid BFS" ], "tags": [ "Teleporters", "Implicit Graph", "Grid" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "A textbook teleporter-state modeling problem on a grid." }, { "slug": "graphs/graph-modeling", "topic": "Graphs -> Graph Modeling", "title": "Giant Pizza", "url": "https://cses.fi/problemset/task/1684", "source": "CSES", "difficulty": "medium", "tracks": [ "2-SAT", "SCC" ], "tags": [ "Implication Graph", "Boolean Constraints" ], "styles": [ "Implication Graph", "SCC Condensation", "Assignment Extraction" ], "prerequisites": [ "Logical Reductions", "Directed Graphs" ], "bucket": "2-sat-modeling", "why_fit": "A very strong modeling problem: clauses become graph edges and satisfiability becomes SCC." }, { "slug": "graphs/graph-modeling", "topic": "Graphs -> Graph Modeling", "title": "Built?", "url": "https://atcoder.jp/contests/abc065/tasks/arc076_b", "source": "AtCoder", "difficulty": "medium", "tracks": [ "MST", "Geometry" ], "tags": [ "Coordinate Graph", "Kruskal", "Sparse Edges" ], "styles": [ "Edge Generation By Sorting", "DSU", "Kruskal" ], "prerequisites": [ "DSU", "Sorting", "Greedy MST" ], "bucket": "coordinate-mst", "why_fit": "A classic geometry-to-graph reduction before running Kruskal." }, { "slug": "graphs/graph-modeling", "topic": "Graphs -> Graph Modeling", "title": "Fox And Two Dots", "url": "https://codeforces.com/problemset/problem/510/B", "source": "Codeforces", "difficulty": "medium", "tracks": [ "Grid DFS" ], "tags": [ "Cycle Detection", "Same-Color Regions", "Grid Graph" ], "styles": [ "DFS With Parent Tracking", "Cycle Witness", "Component Scan" ], "prerequisites": [ "DFS", "Visited States", "Parent Pointers" ], "bucket": "grid-cycle", "why_fit": "Teaches how to find a cycle in an implicit graph hidden inside a board." }, { "slug": "graphs/graph-modeling", "topic": "Graphs -> Graph Modeling", "title": "Counting Rooms", "url": "https://cses.fi/problemset/task/1192", "source": "CSES", "difficulty": "easy", "tracks": [ "Grid DFS" ], "tags": [ "Flood Fill", "Connected Components", "Implicit Graph" ], "styles": [ "Iterative DFS", "Visited Marking", "4-Neighbor Traversal" ], "prerequisites": [ "Graph Traversal", "Stack Or Recursion", "Grid Indexing" ], "bucket": "grid-flood-fill", "why_fit": "The cleanest example of turning a matrix into a graph and counting components." }, { "slug": "graphs/graph-modeling", "topic": "Graphs -> Graph Modeling", "title": "Labyrinth", "url": "https://cses.fi/problemset/task/1193", "source": "CSES", "difficulty": "easy", "tracks": [ "Grid BFS" ], "tags": [ "Shortest Path", "Path Reconstruction", "Maze", "Grid" ], "styles": [ "Single-Source BFS", "Parent Pointers", "Route Recovery" ], "prerequisites": [ "BFS", "Parent Tracking", "4-Direction Moves" ], "bucket": "grid-shortest-path", "why_fit": "The standard implicit-grid shortest path with an explicit reconstructed route." }, { "slug": "graphs/graph-modeling", "topic": "Graphs -> Graph Modeling", "title": "Monsters", "url": "https://cses.fi/problemset/task/1194", "source": "CSES", "difficulty": "medium", "tracks": [ "Grid BFS" ], "tags": [ "Multi-Source BFS", "Escape Path", "Timing Constraints", "Timing", "Escape" ], "styles": [ "Two-Phase BFS", "Distance Grid", "Path Reconstruction" ], "prerequisites": [ "Queue BFS", "Distance Arrays", "Grid Moves" ], "bucket": "multi-source-bfs", "why_fit": "A classic hidden-state problem where enemy arrival times change the search space." }, { "slug": "graphs/hld", "topic": "Graphs -> Heavy-Light Decomposition", "title": "Path Queries II", "url": "https://cses.fi/problemset/task/2134", "source": "CSES", "difficulty": "medium", "tracks": [ "Path Max Query" ], "tags": [ "Trees", "Updates", "Segment Tree", "Path Max", "Point Update" ], "styles": [ "Path Decomposition", "Node Updates" ], "prerequisites": [ "LCA", "Segment Tree" ], "bucket": "core", "why_fit": "A modern, clean HLD benchmark with updates and path maximums." }, { "slug": "graphs/hld", "topic": "Graphs -> Heavy-Light Decomposition", "title": "Vertex Add Path Sum", "url": "https://judge.yosupo.jp/problem/vertex_add_path_sum", "source": "Library Checker", "difficulty": "medium", "tracks": [], "tags": [ "Path Sum", "Verify" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Trusted path-sum benchmark for HLD implementations." }, { "slug": "graphs/hld", "topic": "Graphs -> Heavy-Light Decomposition", "title": "Vertex Set Path Composite", "url": "https://judge.yosupo.jp/problem/vertex_set_path_composite", "source": "Library Checker", "difficulty": "hard", "tracks": [], "tags": [ "Non-Commutative", "Path Queries", "Verify" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Great stress test for HLD with non-commutative merges." }, { "slug": "graphs/hld", "topic": "Graphs -> Heavy-Light Decomposition", "title": "QTREE2", "url": "https://www.spoj.com/problems/QTREE2", "source": "SPOJ", "difficulty": "medium", "tracks": [ "Path Queries" ], "tags": [ "Trees", "Distance", "K-Th Node" ], "styles": [ "Path Distance", "K-Th Node" ], "prerequisites": [ "LCA", "Binary Lifting Or HLD" ], "bucket": "classic", "why_fit": "Adds distance and k-th-node queries on paths." }, { "slug": "graphs/hld", "topic": "Graphs -> Heavy-Light Decomposition", "title": "QTREE3", "url": "https://www.spoj.com/problems/QTREE3", "source": "SPOJ", "difficulty": "medium", "tracks": [ "Dynamic Path Query" ], "tags": [ "Trees", "Toggle", "Nearest Black Node" ], "styles": [ "Toggle Queries", "Path Prefix Search" ], "prerequisites": [ "HLD", "Segment Tree With Colors" ], "bucket": "classic", "why_fit": "Dynamic toggles on a root-to-node path are a classic HLD extension." }, { "slug": "graphs/hld", "topic": "Graphs -> Heavy-Light Decomposition", "title": "QTREE", "url": "https://www.spoj.com/problems/QTREE", "source": "SPOJ", "difficulty": "hard", "tracks": [ "Heavy-Light Decomposition", "Path Queries" ], "tags": [ "Trees", "Segment Tree" ], "styles": [ "Edge Path Queries", "Segment Tree" ], "prerequisites": [ "LCA", "Segment Trees" ], "bucket": "classic", "why_fit": "The canonical tree path-query problem for HLD." }, { "slug": "graphs/hld", "topic": "Graphs -> Heavy-Light Decomposition", "title": "QTREE4", "url": "https://www.spoj.com/problems/QTREE4", "source": "SPOJ", "difficulty": "hard", "tracks": [ "Dynamic Tree Queries" ], "tags": [ "Trees", "Toggle", "Path Aggregate" ], "styles": [ "Color Toggles", "Global Path Aggregate" ], "prerequisites": [ "HLD", "Lazy Propagation" ], "bucket": "advanced", "why_fit": "A tougher variant with nontrivial global maintenance." }, { "slug": "graphs/hld", "topic": "Graphs -> Heavy-Light Decomposition", "title": "Water Tree", "url": "https://codeforces.com/problemset/problem/343/D", "source": "Codeforces", "difficulty": "hard", "tracks": [ "Subtree Updates" ], "tags": [ "Trees", "Range Updates", "Online Queries" ], "styles": [ "Subtree Update / Ancestor Query", "Lazy Propagation" ], "prerequisites": [ "Euler/HLD", "Lazy Segment Tree" ], "bucket": "advanced", "why_fit": "Subtree filling and ancestor clearing is a famous HLD/lazy-seg hybrid." }, { "slug": "graphs/hungarian-assignment", "topic": "Graphs -> Hungarian / Assignment Problem", "title": "Task Assignment", "url": "https://cses.fi/problemset/task/2129", "source": "CSES", "difficulty": "hard", "tracks": [ "Weighted Matching" ], "tags": [ "Cost Matrix", "Perfect Matching" ], "styles": [ "Dense Cost Matrix", "Weighted Bipartite Matching" ], "prerequisites": [ "Bipartite Matching Basics", "Minimum Total Cost Modeling" ], "bucket": "core", "why_fit": "The cleanest square assignment benchmark with explicit witness output." }, { "slug": "graphs/hungarian-assignment", "topic": "Graphs -> Hungarian / Assignment Problem", "title": "Another Assignment Problem", "url": "https://www.spoj.com/problems/ASSIGN4/", "source": "SPOJ", "difficulty": "medium", "tracks": [], "tags": [ "Weighted Matching", "Optimization" ], "styles": [ "Weighted Bipartite Matching", "Assignment Matrix" ], "prerequisites": [ "Assignment Matrix", "Perfect Matching" ], "bucket": "practice", "why_fit": "Direct costed assignment practice after the flagship matrix-first route." }, { "slug": "graphs/hungarian-assignment", "topic": "Graphs -> Hungarian / Assignment Problem", "title": "The Great Wall Game", "url": "https://www.cs.cmu.edu/~eugene/teach/acm06a/hard/05.pdf", "source": "ACM regional archive", "difficulty": "hard", "tracks": [ "Geometry" ], "tags": [ "Manhattan Distance", "Modeling" ], "styles": [ "Geometry To Cost Matrix", "Minimum Cost Perfect Matching" ], "prerequisites": [ "Distance Cost Modeling", "Hungarian Basics" ], "bucket": "stretch", "why_fit": "A strong modeling extension where coordinates collapse cleanly into an assignment-cost matrix." }, { "slug": "graphs/lca", "topic": "Graphs -> LCA", "title": "Company Queries I", "url": "https://cses.fi/problemset/task/1687", "source": "CSES", "difficulty": "easy", "tracks": [], "tags": [ "Binary Lifting", "Kth Ancestor", "Jump Pointers" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Ancestor lifting in its purest form." }, { "slug": "graphs/lca", "topic": "Graphs -> LCA", "title": "Company Queries II", "url": "https://cses.fi/problemset/task/1688", "source": "CSES", "difficulty": "medium", "tracks": [ "Binary Lifting" ], "tags": [ "Lowest Common Ancestor", "Boss Queries", "Ancestor Table", "Boss Hierarchy" ], "styles": [ "Jump Pointers", "Depth Equalization", "Ancestor Climbing" ], "prerequisites": [ "Tree Depth", "Ancestor Tables" ], "bucket": "binary-lifting", "why_fit": "Classic LCA queries over a rooted tree hierarchy." }, { "slug": "graphs/lca", "topic": "Graphs -> LCA", "title": "閉路", "url": "https://atcoder.jp/contests/abc014/tasks/abc014_4", "source": "AtCoder", "difficulty": "medium", "tracks": [ "Distances" ], "tags": [ "Cycle Length", "Tree Path", "Query Answer" ], "styles": [ "Distance Via LCA", "Path Length Formula", "Query Preprocessing" ], "prerequisites": [ "LCA", "Depth Arrays", "Tree Distances" ], "bucket": "lca-application", "why_fit": "A classic LCA application where each query becomes a path-length computation." }, { "slug": "graphs/lca", "topic": "Graphs -> LCA", "title": "LCA: Lowest Common Ancestor", "url": "https://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=GRL_5_C", "source": "AOJ", "difficulty": "medium", "tracks": [], "tags": [ "Rooted Tree", "Binary Lifting", "Ancestor Queries" ], "styles": [ "Binary Lifting", "Euler Tour", "Ancestor Checks" ], "prerequisites": [ "Trees", "DFS Order", "Ancestor Climbing" ], "bucket": "lca-basics", "why_fit": "The official baseline LCA problem from AOJ." }, { "slug": "graphs/lca", "topic": "Graphs -> LCA", "title": "Lowest Common Ancestor", "url": "https://judge.yosupo.jp/problem/lca", "source": "Library Checker", "difficulty": "medium", "tracks": [], "tags": [ "Implementation Check", "Rooted Tree", "Verify", "Binary Lifting" ], "styles": [ "Binary Lifting", "HLD-Style Interface", "Query Batching" ], "prerequisites": [ "Rooted Tree", "Ancestor Tables", "LCA Concept" ], "bucket": "lca-basics", "why_fit": "A compact verification judge for a production-grade LCA routine." }, { "slug": "graphs/lca", "topic": "Graphs -> LCA", "title": "Distance Queries", "url": "https://cses.fi/problemset/task/1135", "source": "CSES", "difficulty": "medium", "tracks": [ "Distances" ], "tags": [ "Tree Distance", "Path Length", "Distance", "Rooted Tree" ], "styles": [ "Depth Plus LCA", "Distance Formula", "Binary Lifting" ], "prerequisites": [ "LCA", "Tree Depth", "Ancestor Jumps" ], "bucket": "lca-distance-formula", "why_fit": "Uses LCA as the backbone for tree distance answers." }, { "slug": "graphs/link-cut-tree", "topic": "Graphs -> Link-Cut Tree", "title": "Dynamic Tree Vertex Add Path Sum", "url": "https://judge.yosupo.jp/problem/dynamic_tree_vertex_add_path_sum", "source": "Library Checker", "difficulty": "very-hard", "tracks": [ "Dynamic Trees" ], "tags": [ "Dynamic Forest", "Path Sum", "Vertex Add" ], "styles": [ "Dynamic Trees", "Path Aggregate", "Verifier" ], "prerequisites": [ "Rooted Tree Intuition", "Preferred Paths", "Makeroot / Access" ], "bucket": "core", "why_fit": "The cleanest exact verifier for the first narrow link-cut route: dynamic forest, point add on vertices, and path sums." }, { "slug": "graphs/link-cut-tree", "topic": "Graphs -> Link-Cut Tree", "title": "Dynamic Tree Vertex Set Path Composite", "url": "https://judge.yosupo.jp/problem/dynamic_tree_vertex_set_path_composite", "source": "Library Checker", "difficulty": "very-hard", "tracks": [ "Dynamic Trees" ], "tags": [ "Dynamic Forest", "Path Composite", "Non-Commutative" ], "styles": [ "Dynamic Trees", "Non-Commutative Query", "Verifier" ], "prerequisites": [ "Link-Cut Tree", "Path Query Ordering", "Function Composition" ], "bucket": "stretch", "why_fit": "A natural stretch once the basic route is trusted and the path aggregate becomes non-commutative." }, { "slug": "graphs/matching", "topic": "Graphs -> Matching", "title": "Gopher II", "url": "https://onlinejudge.org/external/100/10080.pdf", "source": "UVa", "difficulty": "easy", "tracks": [ "Bipartite Matching", "Geometry-To-Graph" ], "tags": [ "Geometry", "Reachability" ], "styles": [ "Distance-Threshold Graph", "Max Matching" ], "prerequisites": [ "Bipartite Matching Basics", "Distance Formula" ], "bucket": "warm-up", "why_fit": "The archetypal geometry-to-matching conversion." }, { "slug": "graphs/matching", "topic": "Graphs -> Matching", "title": "The dog task", "url": "https://onlinejudge.org/index.php?Itemid=8&option=com_onlinejudge&page=show_problem&problem=611", "source": "UVa", "difficulty": "easy", "tracks": [ "Bipartite Matching" ], "tags": [ "Animals", "Assignment" ], "styles": [ "Small Bipartite Graph", "Matching" ], "prerequisites": [ "Matching Basics" ], "bucket": "warm-up", "why_fit": "A compact warm-up that drills matching construction." }, { "slug": "graphs/matching", "topic": "Graphs -> Matching", "title": "Bipartite Matching", "url": "https://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=GRL_7_A", "source": "AOJ", "difficulty": "easy", "tracks": [], "tags": [ "Bipartite Graph", "Augmenting Paths", "Kuhn" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Official bipartite matching baseline." }, { "slug": "graphs/matching", "topic": "Graphs -> Matching", "title": "Guardian of Decency", "url": "https://onlinejudge.org/external/120/12083.pdf", "source": "UVa", "difficulty": "medium", "tracks": [ "Bipartite Matching", "Independent Set" ], "tags": [ "Compatibility Graph" ], "styles": [ "Compatibility Graph", "Matching To Cover" ], "prerequisites": [ "Hall/Konig Intuition" ], "bucket": "core", "why_fit": "A classic compatibility graph that reduces to maximum matching." }, { "slug": "graphs/matching", "topic": "Graphs -> Matching", "title": "School Dance", "url": "https://cses.fi/problemset/task/1696", "source": "CSES", "difficulty": "medium", "tracks": [ "Bipartite Matching" ], "tags": [ "Bipartite Graphs", "Pairing", "Construction" ], "styles": [ "Augmenting Paths", "Bipartite Matching" ], "prerequisites": [ "Bipartite Graph Modeling" ], "bucket": "core", "why_fit": "Matching plus explicit pair recovery." }, { "slug": "graphs/matching", "topic": "Graphs -> Matching", "title": "Stable Marriage", "url": "https://www.ams.org/publicoutreach/feature-column/fc-2015-03", "source": "Canonical / Gale-Shapley", "difficulty": "medium", "tracks": [], "tags": [ "Stable Matching", "Preferences", "Blocking Pair" ], "styles": [ "Two-Sided Preferences", "Deferred Acceptance" ], "prerequisites": [ "Bipartite Pairing Model", "Strict Preferences" ], "bucket": "core", "why_fit": "The cleanest stability-based sibling once one-to-one pairing is no longer about size or cost." }, { "slug": "graphs/matching", "topic": "Graphs -> Matching", "title": "General Matching", "url": "https://judge.yosupo.jp/problem/general_matching", "source": "Library Checker", "difficulty": "hard", "tracks": [], "tags": [ "Blossom", "Non-Bipartite", "Verify" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Trusted general-graph matching verification task." }, { "slug": "graphs/matching", "topic": "Graphs -> Matching", "title": "Task Assignment", "url": "https://cses.fi/problemset/task/2129", "source": "CSES", "difficulty": "hard", "tracks": [], "tags": [ "Assignment", "Weighted Matching", "Bipartite Graph" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Weighted bipartite matching in assignment form." }, { "slug": "graphs/matching", "topic": "Graphs -> Matching", "title": "A Plug for UNIX", "url": "https://onlinejudge.org/external/7/753.pdf", "source": "UVa", "difficulty": "medium", "tracks": [ "Bipartite Matching", "Adapter Graph" ], "tags": [ "Conversion Graph" ], "styles": [ "Reachability Closure", "Max Matching" ], "prerequisites": [ "Graph Modeling" ], "bucket": "classic", "why_fit": "A very standard matching reduction with adapters and compatibility." }, { "slug": "graphs/matching", "topic": "Graphs -> Matching", "title": "Antenna Placement", "url": "https://onlinejudge.org/external/103/10349.pdf", "source": "UVa", "difficulty": "medium", "tracks": [ "Minimum Vertex Cover" ], "tags": [ "Grid Graphs", "Domination" ], "styles": [ "Grid Bipartization", "Vertex Cover Extraction" ], "prerequisites": [ "Bipartite Graphs" ], "bucket": "classic", "why_fit": "Canonical grid-adjacency matching reduction." }, { "slug": "graphs/matching", "topic": "Graphs -> Matching", "title": "Machine Schedule", "url": "https://onlinejudge.org/index.php?Itemid=8&option=com_onlinejudge&page=show_problem&problem=3635", "source": "UVa", "difficulty": "medium", "tracks": [ "Bipartite Matching", "Job Assignment" ], "tags": [ "Scheduling" ], "styles": [ "Job-Machine Bipartite Graph", "Minimum Cover Intuition" ], "prerequisites": [ "Minimum Vertex Cover Intuition" ], "bucket": "classic", "why_fit": "Another classic assignment problem with a matching core." }, { "slug": "graphs/matching", "topic": "Graphs -> Matching", "title": "Sorting Slides", "url": "https://onlinejudge.org/external/6/663.pdf", "source": "UVa", "difficulty": "hard", "tracks": [ "Unique Assignment" ], "tags": [ "Geometry", "Deduction" ], "styles": [ "Forced-Edge Reasoning", "Matching Plus Uniqueness" ], "prerequisites": [ "Bipartite Matching", "Geometry To Graph" ], "bucket": "advanced", "why_fit": "A harder matching problem because uniqueness of assignment matters." }, { "slug": "graphs/min-cost-flow", "topic": "Graphs -> Min-Cost Flow", "title": "Crime Wave - The Sequel", "url": "https://onlinejudge.org/external/107/10746.pdf", "source": "UVa", "difficulty": "medium", "tracks": [ "Min-Cost Max-Flow", "Assignment" ], "tags": [ "Bipartite Matching" ], "styles": [ "Assignment Model", "Min-Cost Matching" ], "prerequisites": [ "Bipartite Matching", "Shortest Augmenting Path" ], "bucket": "core", "why_fit": "A classic costed matching problem on a bipartite graph." }, { "slug": "graphs/min-cost-flow", "topic": "Graphs -> Min-Cost Flow", "title": "Minimum Cost Flow", "url": "https://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=GRL_6_B", "source": "AOJ", "difficulty": "medium", "tracks": [], "tags": [ "Min-Cost Max-Flow", "Potentials", "Shortest Augmenting Path" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Official min-cost-flow baseline." }, { "slug": "graphs/min-cost-flow", "topic": "Graphs -> Min-Cost Flow", "title": "Distinct Routes II", "url": "https://cses.fi/problemset/task/2130", "source": "CSES", "difficulty": "hard", "tracks": [], "tags": [ "K Routes", "Path Reconstruction" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "A direct cost-minimization variant over route decompositions." }, { "slug": "graphs/min-cost-flow", "topic": "Graphs -> Min-Cost Flow", "title": "Parcel Delivery", "url": "https://cses.fi/problemset/task/2121", "source": "CSES", "difficulty": "hard", "tracks": [], "tags": [ "Capacitated Edges", "Transport" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Natural costed transport network formulation." }, { "slug": "graphs/min-cost-flow", "topic": "Graphs -> Min-Cost Flow", "title": "Task Assignment", "url": "https://cses.fi/problemset/task/2129", "source": "CSES", "difficulty": "hard", "tracks": [], "tags": [ "Assignment", "Bipartite Matching", "Cost Matrix" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Classic assignment problem, often solved as min-cost flow." }, { "slug": "graphs/min-cost-flow", "topic": "Graphs -> Min-Cost Flow", "title": "Another Assignment Problem", "url": "https://www.spoj.com/problems/ASSIGN4", "source": "SPOJ", "difficulty": "medium", "tracks": [ "Assignment" ], "tags": [ "Matching" ], "styles": [ "Costed Bipartite Matching", "Successive Shortest Augmenting Path" ], "prerequisites": [ "Bipartite Matching", "Costed Residual Graphs" ], "bucket": "classic", "why_fit": "Direct minimum-cost assignment, ideal for MCMF practice." }, { "slug": "graphs/min-cost-flow", "topic": "Graphs -> Min-Cost Flow", "title": "Data Flow", "url": "https://onlinejudge.org/external/105/10594.pdf", "source": "UVa", "difficulty": "hard", "tracks": [ "Capacity Planning" ], "tags": [ "Latency", "Throughput" ], "styles": [ "Binary Search Over Time", "Min-Cost Flow Feasibility" ], "prerequisites": [ "Capacity Constraints", "Cost-Aware Flow" ], "bucket": "advanced", "why_fit": "Blends feasibility, capacity, and path cost into one MCMF model." }, { "slug": "graphs/min-cost-flow", "topic": "Graphs -> Min-Cost Flow", "title": "Dijkstra, Dijkstra.", "url": "https://onlinejudge.org/external/108/10806.pdf", "source": "UVa", "difficulty": "hard", "tracks": [ "Min-Cost Max-Flow", "Disjoint Paths" ], "tags": [ "Shortest Path" ], "styles": [ "Successive Shortest Augmenting Path" ], "prerequisites": [ "Shortest Path On Residual Graph", "Potentials" ], "bucket": "advanced", "why_fit": "Classic two-disjoint-paths min-cost-flow problem." }, { "slug": "graphs/min-cost-flow", "topic": "Graphs -> Min-Cost Flow", "title": "Yet Another Assignment Problem", "url": "https://www.spoj.com/problems/ASSIGN5", "source": "SPOJ", "difficulty": "hard", "tracks": [ "Scheduling" ], "tags": [ "Assignment" ], "styles": [ "Time-Expanded Scheduling", "Cost Minimization" ], "prerequisites": [ "Min-Cost Flow Modeling", "Job Assignment" ], "bucket": "advanced", "why_fit": "Scheduling with costs and capacities is a richer MCMF variant." }, { "slug": "graphs/min-cost-flow", "topic": "Graphs -> Min-Cost Flow", "title": "Warehouse", "url": "https://onlinejudge.org/external/108/10888.pdf", "source": "UVa", "difficulty": "hard", "tracks": [ "Grid Modeling" ], "tags": [ "Grid", "Movement Cost" ], "styles": [ "Graph Construction From Grid", "Minimum Cost Assignment" ], "prerequisites": [ "Shortest Path Distances", "Min-Cost Matching" ], "bucket": "cross-topic", "why_fit": "Grid movement costs map neatly to min-cost assignment." }, { "slug": "graphs/mst", "topic": "Graphs -> Minimum Spanning Tree", "title": "Minimum Spanning Tree", "url": "https://open.kattis.com/problems/minspantree", "source": "Kattis", "difficulty": "easy", "tracks": [], "tags": [ "Kruskal", "Classic" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "A standard trusted MST practice problem." }, { "slug": "graphs/mst", "topic": "Graphs -> Minimum Spanning Tree", "title": "Built?", "url": "https://atcoder.jp/contests/abc065/tasks/arc076_b", "source": "AtCoder", "difficulty": "medium", "tracks": [ "Geometry" ], "tags": [ "Coordinate Graph", "Sparse Edges" ], "styles": [ "Sorting By Coordinate", "Candidate Edge Pruning", "Kruskal" ], "prerequisites": [ "DSU", "Sorting", "Greedy MST" ], "bucket": "coordinate-mst", "why_fit": "A classic geometry-to-graph reduction before running Kruskal." }, { "slug": "graphs/mst", "topic": "Graphs -> Minimum Spanning Tree", "title": "Minimum Spanning Tree", "url": "https://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=GRL_2_A", "source": "AOJ", "difficulty": "medium", "tracks": [ "DSU" ], "tags": [ "MST Sum", "Weighted Graph", "Kruskal", "Weighted Undirected" ], "styles": [ "Edge Sorting", "Union-Find", "Weight Accumulation" ], "prerequisites": [ "Sorting", "Tree Connectivity" ], "bucket": "kruskal", "why_fit": "The canonical official MST verification problem from AOJ." }, { "slug": "graphs/mst", "topic": "Graphs -> Minimum Spanning Tree", "title": "Road Reparation", "url": "https://cses.fi/problemset/task/1675", "source": "CSES", "difficulty": "medium", "tracks": [ "DSU" ], "tags": [ "Minimum Spanning Tree", "Connectivity" ], "styles": [ "Edge Sorting", "DSU Merges", "Component Counting" ], "prerequisites": [ "Sorting", "Greedy Choice" ], "bucket": "kruskal", "why_fit": "The standard MST warm-up with a clean connectivity check." }, { "slug": "graphs/mst", "topic": "Graphs -> Minimum Spanning Tree", "title": "Minimum spanning tree for each edge", "url": "https://codeforces.com/problemset/problem/609/E", "source": "Codeforces", "difficulty": "hard", "tracks": [], "tags": [ "Replacement Edge", "MST Variants", "Binary Lifting" ], "styles": [ "Kruskal Base Tree", "Max-Edge Queries On Path", "Replacement Reasoning" ], "prerequisites": [ "MST", "LCA Or HLD", "Tree Path Maximum" ], "bucket": "mst-variants", "why_fit": "A strong follow-up to plain MST that asks for edge-wise replacement analysis." }, { "slug": "graphs/mst", "topic": "Graphs -> Minimum Spanning Tree", "title": "Minimum Spanning Tree", "url": "https://judge.yosupo.jp/problem/minimum_spanning_tree", "source": "Library Checker", "difficulty": "medium", "tracks": [], "tags": [ "Sparse Graph", "DSU", "Verify" ], "styles": [ "Kruskal Template", "Edge Index Handling", "DSU" ], "prerequisites": [ "MST Basics", "DSU", "Weighted Edges" ], "bucket": "mst-verification", "why_fit": "A clean judge problem for checking a production-ready MST implementation." }, { "slug": "graphs/scc-toposort", "topic": "Graphs -> Topological Sort And SCC", "title": "Coin Collector", "url": "https://cses.fi/problemset/task/1686", "source": "CSES", "difficulty": "hard", "tracks": [ "DAG DP" ], "tags": [ "SCC Condensation", "DP On DAG", "Weighted Nodes", "Max Path Weight" ], "styles": [ "SCC Compression", "Post-Order DP", "Component Aggregation" ], "prerequisites": [ "SCC", "Component Weights" ], "bucket": "condensation-dag", "why_fit": "A strong SCC-to-DAG condensation problem with a useful optimization layer." }, { "slug": "graphs/scc-toposort", "topic": "Graphs -> Topological Sort And SCC", "title": "Game Routes", "url": "https://cses.fi/problemset/task/1681", "source": "CSES", "difficulty": "medium", "tracks": [ "DAG DP" ], "tags": [ "Path Counting", "Topological Order", "Mod Arithmetic" ], "styles": [ "Topo-Based DP", "Path Counts", "Mod Arithmetic" ], "prerequisites": [ "Topological Sort", "DP On Dags", "Modular Arithmetic" ], "bucket": "dag-dp", "why_fit": "A classic DAG dynamic programming problem that depends on a topological order." }, { "slug": "graphs/scc-toposort", "topic": "Graphs -> Topological Sort And SCC", "title": "Longest Flight Route", "url": "https://cses.fi/problemset/task/1680", "source": "CSES", "difficulty": "medium", "tracks": [ "DAG DP" ], "tags": [ "Longest Path", "Topological Order", "Path Reconstruction" ], "styles": [ "Topo-Based DP", "Parent Reconstruction", "Reachability Filtering" ], "prerequisites": [ "Topological Sort", "Path Recovery" ], "bucket": "dag-longest-path", "why_fit": "A very clean longest-path-in-DAG template with route reconstruction." }, { "slug": "graphs/scc-toposort", "topic": "Graphs -> Topological Sort And SCC", "title": "Course Schedule II", "url": "https://cses.fi/problemset/task/1757", "source": "CSES", "difficulty": "medium", "tracks": [ "Lexicographic" ], "tags": [ "Lexicographic Order", "Topological Sort", "Directed Acyclic Graph", "Lexicographic Topo", "DAG", "Ordering" ], "styles": [ "Priority-Queue Kahn", "Smallest Available Node", "Deterministic Order" ], "prerequisites": [ "Topological Sort", "Priority Queue", "Directed Acyclic Graphs" ], "bucket": "lexicographic-topo", "why_fit": "Variant with a stronger ordering requirement." }, { "slug": "graphs/scc-toposort", "topic": "Graphs -> Topological Sort And SCC", "title": "Strongly Connected Components", "url": "https://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=GRL_3_C", "source": "AOJ", "difficulty": "medium", "tracks": [], "tags": [ "Mutual Reachability", "Tarjan", "Kosaraju", "Component Queries" ], "styles": [ "Kosaraju", "Tarjan", "Component Ids" ], "prerequisites": [ "DFS", "Directed Graphs", "Stack Order" ], "bucket": "scc-basics", "why_fit": "The official SCC fundamentals problem from AOJ." }, { "slug": "graphs/scc-toposort", "topic": "Graphs -> Topological Sort And SCC", "title": "Planets and Kingdoms", "url": "https://cses.fi/problemset/task/1683", "source": "CSES", "difficulty": "medium", "tracks": [ "Condensation" ], "tags": [ "SCC Labels", "Kingdoms", "Directed Graph", "Strongly Connected Components", "Labels" ], "styles": [ "Kosaraju Or Tarjan", "Component Numbering", "Condensation DAG" ], "prerequisites": [ "SCC", "DFS", "Component Compression" ], "bucket": "scc-labeling", "why_fit": "The standard SCC labeling problem in a contest-friendly format." }, { "slug": "graphs/scc-toposort", "topic": "Graphs -> Topological Sort And SCC", "title": "Flight Routes Check", "url": "https://cses.fi/problemset/task/1682", "source": "CSES", "difficulty": "medium", "tracks": [ "Reachability" ], "tags": [ "Strong Connectivity", "Constructive Counterexample" ], "styles": [ "SCC Decomposition", "Condensation Reasoning", "Counterexample Extraction" ], "prerequisites": [ "SCC", "DFS" ], "bucket": "strong-connectivity", "why_fit": "A pure strong-connectivity check with a useful constructive witness if it fails." }, { "slug": "graphs/scc-toposort", "topic": "Graphs -> Topological Sort And SCC", "title": "Course Schedule", "url": "https://cses.fi/problemset/task/1679", "source": "CSES", "difficulty": "easy", "tracks": [ "DAG" ], "tags": [ "Topological Sort", "Prerequisites", "Ordering", "Kahn" ], "styles": [ "Kahn Queue", "In-Degree Tracking", "Valid Order Output" ], "prerequisites": [ "Directed Graphs", "In-Degree", "Queues" ], "bucket": "topological-sort", "why_fit": "The simplest topological-ordering template with a clear feasibility check." }, { "slug": "graphs/scc-toposort", "topic": "Graphs -> Topological Sort And SCC", "title": "Topological Sort", "url": "https://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=GRL_4_B", "source": "AOJ", "difficulty": "medium", "tracks": [ "DFS" ], "tags": [ "DAG", "Ordering", "Directed Graph", "Kahn" ], "styles": [ "DFS Finish Order", "Stack Reversal", "DAG Validation" ], "prerequisites": [ "Directed Graphs", "Finish Times" ], "bucket": "topological-sort", "why_fit": "The official graph-library style topological sort problem." }, { "slug": "graphs/shortest-paths", "topic": "Graphs -> Shortest Paths", "title": "Shortest Routes II", "url": "https://cses.fi/problemset/task/1672", "source": "CSES", "difficulty": "medium", "tracks": [ "APSP" ], "tags": [ "All-Pairs Shortest Path", "Floyd-Warshall", "All-Pairs", "Undirected Weighted" ], "styles": [ "Floyd-Warshall", "Dense-Graph DP", "Distance Matrix" ], "prerequisites": [ "Matrix DP", "Transitive Relaxation", "INF Handling" ], "bucket": "all-pairs-dp", "why_fit": "Dense-graph shortest paths with repeated queries." }, { "slug": "graphs/shortest-paths", "topic": "Graphs -> Shortest Paths", "title": "バスと避けられない運命", "url": "https://atcoder.jp/contests/abc012/tasks/abc012_4", "source": "AtCoder", "difficulty": "hard", "tracks": [ "APSP" ], "tags": [ "Floyd-Warshall", "Graph Center", "Minimax Distance" ], "styles": [ "All-Pairs DP", "Radius Minimization", "Dense Graph Reasoning" ], "prerequisites": [ "Floyd-Warshall", "Graph Distances", "Minimax Thinking" ], "bucket": "all-pairs-shortest-paths", "why_fit": "A modeling-heavy shortest-path problem where the answer is a graph center." }, { "slug": "graphs/shortest-paths", "topic": "Graphs -> Shortest Paths", "title": "Dijkstra?", "url": "https://codeforces.com/problemset/problem/20/C", "source": "Codeforces", "difficulty": "medium", "tracks": [ "Dijkstra" ], "tags": [ "Weighted Graph", "Shortest Route", "Path Reconstruction" ], "styles": [ "Priority Queue Dijkstra", "Parent Pointers", "Simple Path Output" ], "prerequisites": [ "Priority Queue", "Weighted Graphs", "Path Recovery" ], "bucket": "classic-dijkstra", "why_fit": "The iconic shortest-path path-reconstruction problem every graph learner should know." }, { "slug": "graphs/shortest-paths", "topic": "Graphs -> Shortest Paths", "title": "Shortest Routes I", "url": "https://cses.fi/problemset/task/1671", "source": "CSES", "difficulty": "easy", "tracks": [ "Dijkstra" ], "tags": [ "Single-Source Shortest Path", "Weighted Digraph", "Priority Queue", "Single-Source", "Directed Weighted" ], "styles": [ "Priority Queue Relaxation", "Distance Array", "Outdated-State Skipping" ], "prerequisites": [ "Weighted Graphs", "Priority Queues", "Adjacency Lists" ], "bucket": "dijkstra", "why_fit": "Straight Dijkstra baseline from one source." }, { "slug": "graphs/shortest-paths", "topic": "Graphs -> Shortest Paths", "title": "Investigation", "url": "https://cses.fi/problemset/task/1202", "source": "CSES", "difficulty": "medium", "tracks": [ "Dijkstra" ], "tags": [ "Count Shortest Paths", "Min/Max Edges", "Mod Arithmetic", "Counts", "Min/Max Hops" ], "styles": [ "Augmented Relaxations", "Path Counting", "Tie Handling" ], "prerequisites": [ "Modular Arithmetic", "Shortest-Path DAG Intuition" ], "bucket": "dijkstra-plus-counting", "why_fit": "Shortest paths plus route counting and hop-range metadata." }, { "slug": "graphs/shortest-paths", "topic": "Graphs -> Shortest Paths", "title": "Flight Discount", "url": "https://cses.fi/problemset/task/1195", "source": "CSES", "difficulty": "medium", "tracks": [ "Dijkstra" ], "tags": [ "One-Time Discount", "Layered Graph", "Stateful Shortest Path", "State Expansion" ], "styles": [ "Two-State Dijkstra", "Forward And Reverse Distances", "Coupon Use" ], "prerequisites": [ "State Expansion", "Graph Modeling" ], "bucket": "layered-dijkstra", "why_fit": "Shortest path with one special edge-use state." }, { "slug": "graphs/shortest-paths", "topic": "Graphs -> Shortest Paths", "title": "High Score", "url": "https://cses.fi/problemset/task/1673", "source": "CSES", "difficulty": "hard", "tracks": [ "Bellman-Ford" ], "tags": [ "Negative Cycles", "Maximum Path", "Cycle Detection", "Longest Path Transform" ], "styles": [ "Bellman-Ford", "Cycle Reachability", "Score Inversion" ], "prerequisites": [ "Negative Weights", "Reachability" ], "bucket": "negative-cycle-handling", "why_fit": "A classic transformation from maximum-score routing to negative-cycle detection." }, { "slug": "graphs/shortest-paths", "topic": "Graphs -> Shortest Paths", "title": "Cycle Finding", "url": "https://cses.fi/problemset/task/1197", "source": "CSES", "difficulty": "hard", "tracks": [ "Bellman-Ford" ], "tags": [ "Negative Cycle", "Witness Cycle", "Directed Graph", "Cycle Reconstruction" ], "styles": [ "Bellman-Ford Witness Extraction", "Parent Recovery", "Cycle Backtracking" ], "prerequisites": [ "Parent Pointers", "Negative Edges" ], "bucket": "negative-cycle-witness", "why_fit": "Canonical negative-cycle detection and extraction problem." }, { "slug": "graphs/shortest-paths", "topic": "Graphs -> Shortest Paths", "title": "Shortest Path", "url": "https://judge.yosupo.jp/problem/shortest_path", "source": "Library Checker", "difficulty": "medium", "tracks": [ "Path Reconstruction" ], "tags": [ "Weighted Digraph", "Route Output", "Dijkstra" ], "styles": [ "Distance Predecessor Arrays", "Path Rebuilding", "Single-Source SSSP" ], "prerequisites": [ "Dijkstra", "Parent Recovery", "Directed Graphs" ], "bucket": "path-restoration", "why_fit": "A very clean verification-style shortest path problem with route restoration." }, { "slug": "graphs/stable-marriage", "topic": "Graphs -> Stable Marriage", "title": "Stable Marriage", "url": "https://www.ams.org/publicoutreach/feature-column/fc-2015-03", "source": "Canonical / Gale-Shapley", "difficulty": "medium", "tracks": [ "Stable Matching", "Gale-Shapley" ], "tags": [ "Blocking Pair", "Deferred Acceptance" ], "styles": [ "Two-Sided Preferences", "Canonical Benchmark" ], "prerequisites": [ "Bipartite Pairing Model", "Strict Preferences" ], "bucket": "core", "why_fit": "The cleanest in-repo flagship route where the whole job is just Gale-Shapley on complete strict preference lists." }, { "slug": "graphs/stable-marriage", "topic": "Graphs -> Stable Marriage", "title": "Stable Marriage Problem", "url": "https://judge.yosupo.jp/problem/stable_marriage_problem", "source": "Library Checker", "difficulty": "medium", "tracks": [ "Stable Matching", "Gale-Shapley" ], "tags": [ "Verify", "Preferences" ], "styles": [ "Verifier-Style Problem", "Stable Matching" ], "prerequisites": [ "Deferred Acceptance", "Strict Preferences" ], "bucket": "practice", "why_fit": "A natural verifier-style follow-up once the canonical Gale-Shapley route feels routine." }, { "slug": "graphs/tree-dp", "topic": "Graphs -> Tree DP", "title": "Choosing Capital for Treeland", "url": "https://codeforces.com/problemset/problem/219/D", "source": "Codeforces", "difficulty": "medium", "tracks": [ "Rerooting", "Tree DP On Directed Edges" ], "tags": [ "Directed Tree" ], "styles": [ "One Reroot Pass", "Edge-Cost Delta" ], "prerequisites": [ "Tree Traversal", "Edge Orientation Counts" ], "bucket": "core", "why_fit": "Re-rooting the tree changes the inversion count by one edge at a time." }, { "slug": "graphs/tree-dp", "topic": "Graphs -> Tree DP", "title": "Tree Distances I", "url": "https://cses.fi/problemset/task/1132", "source": "CSES", "difficulty": "medium", "tracks": [ "Rerooting" ], "tags": [ "Distance" ], "styles": [ "Two DFS Passes", "Diameter Endpoints" ], "prerequisites": [ "Tree Diameter Intuition", "Distance Propagation" ], "bucket": "core", "why_fit": "Standard rerooting practice for maximum distance from every node." }, { "slug": "graphs/tree-dp", "topic": "Graphs -> Tree DP", "title": "Tree Distances II", "url": "https://cses.fi/problemset/task/1133", "source": "CSES", "difficulty": "hard", "tracks": [ "Rerooting" ], "tags": [ "Distance Sums", "Sum Of Distances" ], "styles": [ "Subtree Sums", "Rerooting Formulas" ], "prerequisites": [ "Subtree Sizes", "Distance Sum Identities" ], "bucket": "core", "why_fit": "Classic rerooting DP on trees." }, { "slug": "graphs/tree-dp", "topic": "Graphs -> Tree DP", "title": "Independent Set", "url": "https://atcoder.jp/contests/dp/tasks/dp_p", "source": "AtCoder DP Contest", "difficulty": "medium", "tracks": [ "Coloring DP" ], "tags": [ "Mod Arithmetic" ], "styles": [ "Bottom-Up DFS", "Two-State DP" ], "prerequisites": [ "Rooted Tree", "State Design", "Modular Arithmetic" ], "bucket": "classic", "why_fit": "Canonical tree DP where each node keeps take/skip states." }, { "slug": "graphs/tree-dp", "topic": "Graphs -> Tree DP", "title": "Tree Matching", "url": "https://cses.fi/problemset/task/1130", "source": "CSES", "difficulty": "medium", "tracks": [ "Matching On Trees" ], "tags": [ "Matching", "Matching DP", "States" ], "styles": [ "Postorder DFS", "Local State Merge" ], "prerequisites": [ "Rooted Tree DP", "Independent-Edge Choices" ], "bucket": "classic", "why_fit": "Classic tree DP for maximum matching on a tree." }, { "slug": "graphs/tree-dp", "topic": "Graphs -> Tree DP", "title": "Subtree", "url": "https://atcoder.jp/contests/dp/tasks/dp_v", "source": "AtCoder DP Contest", "difficulty": "hard", "tracks": [ "Rerooting" ], "tags": [ "Mod Arithmetic", "Mod DP", "Rooted Tree", "Independent Set" ], "styles": [ "Prefix/Suffix Rerooting", "Subtree Products" ], "prerequisites": [ "Rooted Tree", "Subtree Aggregation", "Modular Arithmetic" ], "bucket": "advanced", "why_fit": "The go-to rerooting pattern for answering every root." }, { "slug": "graphs/tree-dp", "topic": "Graphs -> Tree DP", "title": "Zero Tree", "url": "https://codeforces.com/problemset/problem/274/B", "source": "Codeforces", "difficulty": "hard", "tracks": [ "Difference Accumulation" ], "tags": [ "Greedy" ], "styles": [ "Postorder Balancing", "Sign-Aware Subtree Merge" ], "prerequisites": [ "Rooted Tree", "Subtree Contributions" ], "bucket": "advanced", "why_fit": "A strong tree DP where subtree balances determine the answer." }, { "slug": "graphs/tree-isomorphism", "topic": "Graphs -> Tree Isomorphism", "title": "Tree Isomorphism I", "url": "https://cses.fi/problemset/task/1700", "source": "CSES", "difficulty": "hard", "tracks": [ "Canonical Encoding" ], "tags": [ "Rooted Tree", "Canonical Form", "Unordered Children" ], "styles": [ "Bottom-Up Canonicalization", "Postorder", "Structural Comparison" ], "prerequisites": [ "Rooted Tree", "DFS", "Parent-Child Structure" ], "bucket": "core", "why_fit": "The clean rooted benchmark where the whole task is comparing two unordered rooted trees by canonical subtree types." }, { "slug": "graphs/tree-isomorphism", "topic": "Graphs -> Tree Isomorphism", "title": "Tree Isomorphism II", "url": "https://cses.fi/problemset/task/1701", "source": "CSES", "difficulty": "hard", "tracks": [ "Tree Centers" ], "tags": [ "Unrooted Tree", "Centers", "Canonical Form" ], "styles": [ "Center Rooting", "Bottom-Up Canonicalization", "Structural Comparison" ], "prerequisites": [ "Tree Isomorphism I", "Rooted Tree" ], "bucket": "stretch", "why_fit": "The natural unrooted sibling: normalize by one or two centers, then reuse the rooted canonical-encoding primitive." }, { "slug": "graphs/trees", "topic": "Graphs -> Trees", "title": "Diameter of a Tree", "url": "https://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=GRL_5_A", "source": "AOJ", "difficulty": "easy", "tracks": [], "tags": [ "Tree Diameter", "DFS", "Weighted Tree" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Very clean tree baseline problem." }, { "slug": "graphs/trees", "topic": "Graphs -> Trees", "title": "Finding a Centroid", "url": "https://cses.fi/problemset/task/2079", "source": "CSES", "difficulty": "medium", "tracks": [ "Subtree Sizes", "Centroid" ], "tags": [ "Balance", "DFS" ], "styles": [ "Size DFS", "Balance Check", "Candidate Descent" ], "prerequisites": [ "DFS", "Tree Balance" ], "bucket": "centroid", "why_fit": "A compact tree problem that reinforces subtree-size reasoning." }, { "slug": "graphs/trees", "topic": "Graphs -> Trees", "title": "Distinct Colors", "url": "https://cses.fi/problemset/task/1139", "source": "CSES", "difficulty": "hard", "tracks": [ "DSU On Tree", "Subtrees" ], "tags": [ "Distinct Values", "Subtree Aggregation", "Small-To-Large" ], "styles": [ "Small-To-Large Merging", "Subtree Frequency Maps", "Offline Aggregation" ], "prerequisites": [ "Tree Traversal", "Frequency Maps", "Subtree Processing" ], "bucket": "dsu-on-tree", "why_fit": "A strong subtree-aggregation problem that rewards a nontrivial tree technique." }, { "slug": "graphs/trees", "topic": "Graphs -> Trees", "title": "Subtree Queries", "url": "https://cses.fi/problemset/task/1137", "source": "CSES", "difficulty": "medium", "tracks": [ "Euler Tour", "Fenwick" ], "tags": [ "Subtree Sum", "Updates" ], "styles": [ "Flatten Tree", "Fenwick Tree", "Range Sum Queries" ], "prerequisites": [ "Fenwick Tree", "Subtree Intervals" ], "bucket": "euler-tour-bit", "why_fit": "A canonical tree-to-array reduction for subtree updates and queries." }, { "slug": "graphs/trees", "topic": "Graphs -> Trees", "title": "Tree Distances I", "url": "https://cses.fi/problemset/task/1132", "source": "CSES", "difficulty": "medium", "tracks": [ "Rerooting", "Distances" ], "tags": [ "Eccentricity", "Distance Propagation", "Tree DP" ], "styles": [ "Two-Pass DP", "Downward And Upward Values", "Distance Maxima" ], "prerequisites": [ "Tree DP", "DFS", "Rerooting Idea" ], "bucket": "rerooting-dp", "why_fit": "Per-node farthest-distance computation on a tree." }, { "slug": "graphs/trees", "topic": "Graphs -> Trees", "title": "Tree Distances II", "url": "https://cses.fi/problemset/task/1133", "source": "CSES", "difficulty": "medium", "tracks": [ "Rerooting", "Sums" ], "tags": [ "Sum Of Distances", "Tree DP" ], "styles": [ "Subtree DP", "Reroot Transition", "Sum Aggregation" ], "prerequisites": [ "Tree DP", "Prefix Sums On Trees" ], "bucket": "rerooting-sums", "why_fit": "A classic rerooting problem where each node needs an aggregate over the whole tree." }, { "slug": "graphs/trees", "topic": "Graphs -> Trees", "title": "Path Queries", "url": "https://cses.fi/problemset/task/1138", "source": "CSES", "difficulty": "medium", "tracks": [ "Euler Tour", "Fenwick" ], "tags": [ "Root Path Sum", "Updates", "Tree Flattening" ], "styles": [ "Euler Tour", "Fenwick Tree", "Prefix-On-Tree" ], "prerequisites": [ "Tree Flattening", "Fenwick Tree", "Rooted Tree" ], "bucket": "root-path-queries", "why_fit": "Pairs a tree traversal with range data structures in a very reusable way." }, { "slug": "graphs/trees", "topic": "Graphs -> Trees", "title": "Subordinates", "url": "https://cses.fi/problemset/task/1674", "source": "CSES", "difficulty": "easy", "tracks": [ "DFS", "Subtree Sizes" ], "tags": [ "Subtree Size", "Rooted Tree", "Counting" ], "styles": [ "Postorder DFS", "Size Accumulation", "Rooted Traversal" ], "prerequisites": [ "Tree Traversal", "Parent-Child Relation" ], "bucket": "subtree-sizes", "why_fit": "A very approachable rooted-tree problem that builds subtree intuition." }, { "slug": "graphs/trees", "topic": "Graphs -> Trees", "title": "Tree Diameter", "url": "https://cses.fi/problemset/task/1131", "source": "CSES", "difficulty": "easy", "tracks": [ "DFS", "Diameter" ], "tags": [ "Two BFS", "Longest Path" ], "styles": [ "Double Sweep", "DFS/BFS Diameter", "Farthest Node" ], "prerequisites": [ "Tree Basics", "Graph Traversal", "Distance Intuition" ], "bucket": "tree-diameter", "why_fit": "The classic tree diameter pattern that every tree toolkit should contain." }, { "slug": "graphs/trees", "topic": "Graphs -> Trees", "title": "Tree Matching", "url": "https://cses.fi/problemset/task/1130", "source": "CSES", "difficulty": "medium", "tracks": [ "Tree DP", "Greedy" ], "tags": [ "Matching", "Independent Edges", "Independent Edge Set" ], "styles": [ "Bottom-Up DP", "Leaf Processing", "Pairing Choices" ], "prerequisites": [ "DFS", "Greedy Reasoning" ], "bucket": "tree-dp", "why_fit": "A concise introduction to optimizing choices on trees." }, { "slug": "graphs/two-sat", "topic": "Graphs -> Two-SAT", "title": "Two SAT", "url": "https://judge.yosupo.jp/problem/two_sat", "source": "Library Checker", "difficulty": "medium", "tracks": [ "2-SAT" ], "tags": [ "Implication Graph", "SCC", "Assignment Extraction" ], "styles": [ "Implication Graph", "SCC Check", "Witness Recovery" ], "prerequisites": [ "SCC", "Directed Graphs", "Boolean Variables" ], "bucket": "warm-up", "why_fit": "The cleanest exact verifier for a reusable 2-SAT starter." }, { "slug": "graphs/two-sat", "topic": "Graphs -> Two-SAT", "title": "Giant Pizza", "url": "https://cses.fi/problemset/task/1684", "source": "CSES", "difficulty": "medium", "tracks": [ "2-SAT", "Assignment" ], "tags": [ "Implication Graph", "Clause Modeling", "SCC", "Witness" ], "styles": [ "Clause Rewrite", "Implication Graph", "Assignment Extraction" ], "prerequisites": [ "SCC", "Literal Encoding", "Boolean Modeling" ], "bucket": "core", "why_fit": "The cleanest contest-format 2-SAT modeling problem with one recovered assignment." }, { "slug": "graphs/two-sat", "topic": "Graphs -> Two-SAT", "title": "Wedding", "url": "https://onlinejudge.org/external/112/11294.pdf", "source": "UVa", "difficulty": "medium", "tracks": [ "2-SAT", "Classic" ], "tags": [ "Seating Constraints", "Implication Graph" ], "styles": [ "Boolean Modeling", "Complement Pairs", "SCC Assignment" ], "prerequisites": [ "2-SAT Basics", "SCC", "Logical Modeling" ], "bucket": "classic", "why_fit": "A classic 2-SAT reduction where statement semantics matter more than SCC code." }, { "slug": "graphs/two-sat", "topic": "Graphs -> Two-SAT", "title": "The Door Problem", "url": "https://codeforces.com/problemset/problem/776/D", "source": "Codeforces", "difficulty": "hard", "tracks": [ "2-SAT", "Modeling" ], "tags": [ "Boolean Constraints", "Parity-Like Modeling", "Assignment" ], "styles": [ "Constraint Reframing", "Implication Graph", "Witness Recovery" ], "prerequisites": [ "2-SAT Basics", "Clause Rewriting", "SCC" ], "bucket": "stretch", "why_fit": "A strong next step once the implication-graph route itself is trusted." }, { "slug": "graphs/virtual-tree", "topic": "Graphs -> Virtual Tree / Auxiliary Tree", "title": "Kingdom and its Cities", "url": "https://codeforces.com/problemset/problem/613/D", "source": "Codeforces", "difficulty": "very-hard", "tracks": [], "tags": [ "Marked Nodes", "LCA", "Tree DP", "Minimum Separator" ], "styles": [ "Marked-Subset Compression", "LCA", "Query-Local DP" ], "prerequisites": [ "LCA", "DFS Order", "Tree DP" ], "bucket": "core", "why_fit": "The classic first full virtual-tree problem: each query marks only a small set, and the whole solution is compress-then-DP." }, { "slug": "graphs/virtual-tree", "topic": "Graphs -> Virtual Tree / Auxiliary Tree", "title": "Leaf Color", "url": "https://atcoder.jp/contests/abc340/tasks/abc340_g", "source": "AtCoder", "difficulty": "very-hard", "tracks": [], "tags": [ "Marked Nodes", "Color Grouping", "Compressed Tree" ], "styles": [ "Marked-Subset Compression", "Per-Color Processing", "Tree DP" ], "prerequisites": [ "Virtual Tree Build", "LCA", "Compressed-Tree Reasoning" ], "bucket": "stretch", "why_fit": "A strong stretch rep once the build step feels automatic and the real challenge becomes choosing the right summary on the compressed tree." }, { "slug": "greedy/huffman-data-compression", "topic": "Greedy -> Huffman / Data Compression", "title": "Huffman Coding Benchmark", "url": "https://algs4.cs.princeton.edu/code/javadoc/edu/princeton/cs/algs4/Huffman.html", "source": "Algorithms 4/e", "difficulty": "medium", "tracks": [ "Data-Compression", "Prefix-Codes" ], "tags": [ "Optimal Merge", "Min-Heap", "Weighted Path Length" ], "styles": [ "Heap Greedy", "Tree Construction" ], "prerequisites": [ "Priority Queue", "Weighted Merge Cost", "Prefix Code" ], "bucket": "core", "why_fit": "Canonical textbook benchmark where the whole lesson is the two-smallest merge greedy, not a production compression container." }, { "slug": "greedy/prefix-constraints", "topic": "Greedy -> Prefix Constraints", "title": "Lemonade Line", "url": "https://usaco.org/index.php?cpid=835&page=viewproblem2", "source": "USACO 2018 US Open Silver", "difficulty": "easy-medium", "tracks": [], "tags": [ "Sort+Greedy", "Threshold" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "keep a valid prefix by descending willingness" }, { "slug": "greedy/prefix-constraints", "topic": "Greedy -> Prefix Constraints", "title": "Two Binary Strings", "url": "https://codeforces.com/problemset/problem/1861/B", "source": "Codeforces", "difficulty": "easy", "tracks": [ "Construction" ], "tags": [ "Binary-Strings", "Prefix-Conditions" ], "styles": [ "Greedy-Construction" ], "prerequisites": [ "String Scanning", "Invariants" ], "bucket": "binary-construction", "why_fit": "A constructive greedy where valid prefixes constrain how the final string can be assembled." }, { "slug": "greedy/prefix-constraints", "topic": "Greedy -> Prefix Constraints", "title": "Prefix Min and Suffix Max", "url": "https://codeforces.com/problemset/problem/2123/C", "source": "Codeforces", "difficulty": "easy", "tracks": [ "Prefix-Extrema" ], "tags": [ "Prefix-Min", "Suffix-Max" ], "styles": [ "Greedy-Check" ], "prerequisites": [ "Suffix Extrema" ], "bucket": "extremal-constraints", "why_fit": "A nice prefix/suffix constraint problem that rewards tracking the right extrema at the right time." }, { "slug": "greedy/prefix-constraints", "topic": "Greedy -> Prefix Constraints", "title": "Prefix Max", "url": "https://codeforces.com/problemset/problem/2185/B", "source": "Codeforces", "difficulty": "easy", "tracks": [ "Prefix-Extrema" ], "tags": [ "Prefix-Max", "Arrays" ], "styles": [ "Greedy-Check" ], "prerequisites": [ "Prefix Maxima", "Comparisons" ], "bucket": "prefix-extrema", "why_fit": "A crisp prefix-max problem where the greedy invariant is both simple and central." }, { "slug": "greedy/prefix-constraints", "topic": "Greedy -> Prefix Constraints", "title": "Prefix Sum Addicts", "url": "https://codeforces.com/problemset/problem/1738/B", "source": "Codeforces", "difficulty": "easy", "tracks": [ "Prefix-Feasibility" ], "tags": [ "Prefix-Sum", "Construction" ], "styles": [ "Greedy-Check" ], "prerequisites": [ "Prefix Sums", "Parity Reasoning" ], "bucket": "prefix-feasibility", "why_fit": "The prefix-sum structure is the whole problem, so it is a nice fit for prefix-constrained greedy reasoning." }, { "slug": "greedy/prefix-constraints", "topic": "Greedy -> Prefix Constraints", "title": "Keep it Beautiful", "url": "https://codeforces.com/problemset/problem/1841/B", "source": "Codeforces", "difficulty": "easy", "tracks": [ "Stateful-Greedy" ], "tags": [ "Binary-Array" ], "styles": [ "Greedy-Check" ], "prerequisites": [ "Sequence Invariants", "Two-State Logic" ], "bucket": "prefix-monotonicity", "why_fit": "A good example of maintaining a global prefix condition while processing the sequence online." }, { "slug": "greedy/prefix-constraints", "topic": "Greedy -> Prefix Constraints", "title": "Remove Prefix", "url": "https://codeforces.com/problemset/problem/1714/B", "source": "Codeforces", "difficulty": "easy", "tracks": [ "Prefix-Invariant" ], "tags": [ "Construction" ], "styles": [ "Greedy-Check" ], "prerequisites": [ "Arrays", "Set Membership" ], "bucket": "prefix-trimming", "why_fit": "A very direct prefix-invariant greedy where the answer is determined by the first repeated prefix pattern." }, { "slug": "greedy/prefix-constraints", "topic": "Greedy -> Prefix Constraints", "title": "Binary Removals", "url": "https://codeforces.com/problemset/problem/1499/B", "source": "Codeforces", "difficulty": "easy", "tracks": [ "Prefix-Structure" ], "tags": [ "Binary-String" ], "styles": [ "Greedy-Check" ], "prerequisites": [ "String Scanning", "Prefix/Suffix Reasoning" ], "bucket": "structured-prefix-cleanup", "why_fit": "A compact prefix-constraint problem where the feasibility check is driven by a simple greedy invariant." }, { "slug": "math/berlekamp-massey-kitamasa", "topic": "Math -> Berlekamp-Massey / Kitamasa", "title": "K-th Term of Linearly Recurrent Sequence", "url": "https://judge.yosupo.jp/problem/kth_term_of_linearly_recurrent_sequence", "source": "Library Checker", "difficulty": "hard", "tracks": [ "Linear Recurrence" ], "tags": [ "Characteristic Polynomial", "K-Th Term" ], "styles": [ "Math", "Algebra", "Implementation" ], "prerequisites": [ "Modular Arithmetic", "Linear Recurrence Modeling" ], "bucket": "core", "why_fit": "The clean first verifier where the recurrence is already known and the whole point is to trust the O(d^2 log k) jump instead of a dense matrix." }, { "slug": "math/berlekamp-massey-kitamasa", "topic": "Math -> Berlekamp-Massey / Kitamasa", "title": "Find Linear Recurrence", "url": "https://judge.yosupo.jp/problem/find_linear_recurrence", "source": "Library Checker", "difficulty": "hard", "tracks": [ "Berlekamp-Massey", "Linear Recurrence" ], "tags": [ "Minimal Recurrence", "Sequence Recovery" ], "styles": [ "Math", "Algebra", "Implementation" ], "prerequisites": [ "Modular Arithmetic", "Discrepancy Updates" ], "bucket": "stretch", "why_fit": "The natural sibling verifier where recurrence recovery itself is the task before any future Kitamasa-style jump." }, { "slug": "math/bsgs-discrete-log", "topic": "Math -> BSGS / Discrete Log", "title": "Discrete Logarithm Mod", "url": "https://judge.yosupo.jp/problem/discrete_logarithm_mod", "source": "Library Checker", "difficulty": "hard", "tracks": [ "Discrete Logarithm" ], "tags": [ "Discrete Log", "Meet In The Middle", "GCD Reduction" ], "styles": [ "Math", "Meet-In-The-Middle", "Implementation" ], "prerequisites": [ "Modular Arithmetic", "Extended Euclid", "Square Root Decomposition" ], "bucket": "core", "why_fit": "The cleanest verifier for the repo's exact route: general discrete log with gcd reduction and a minimum-answer BSGS implementation." }, { "slug": "math/bsgs-discrete-log", "topic": "Math -> BSGS / Discrete Log", "title": "LibreOJ #6542", "url": "https://loj.ac/p/6542", "source": "LibreOJ", "difficulty": "hard", "tracks": [ "Discrete Logarithm" ], "tags": [ "Template", "Discrete Log" ], "styles": [ "Math", "Implementation" ], "prerequisites": [ "Bsgs", "Modular Arithmetic" ], "bucket": "stretch", "why_fit": "A classic template-style benchmark once the first verifier route is already trusted." }, { "slug": "math/chinese-remainder", "topic": "Math -> Chinese Remainder And Linear Congruences", "title": "General Chinese Remainder", "url": "https://open.kattis.com/problems/generalchineseremainder", "source": "Kattis", "difficulty": "medium", "tracks": [ "Congruence Systems" ], "tags": [ "Chinese Remainder Theorem", "Extended Euclid", "Non-Coprime Moduli" ], "styles": [ "Math", "Implementation" ], "prerequisites": [ "GCD", "Extended Euclid", "Modular Arithmetic" ], "bucket": "core", "why_fit": "The cleanest first rep for non-coprime congruence merges with an explicit no-solution branch." }, { "slug": "math/chinese-remainder", "topic": "Math -> Chinese Remainder And Linear Congruences", "title": "System of Linear Congruence", "url": "https://judge.yosupo.jp/problem/system_of_linear_congruence", "source": "Library Checker", "difficulty": "medium", "tracks": [ "Congruence Systems" ], "tags": [ "Chinese Remainder Theorem", "Linear Congruence", "Extended Euclid" ], "styles": [ "Math", "Implementation" ], "prerequisites": [ "Extended Euclid", "Congruence Merging" ], "bucket": "stretch", "why_fit": "A direct benchmark for solving and merging full congruence systems after the two-modulus route is trusted." }, { "slug": "math/dirichlet-prefix-sums", "topic": "Math -> Dirichlet Convolution / Prefix Sums Of Number-Theoretic Functions", "title": "Sum of Divisors", "url": "https://cses.fi/problemset/task/1082", "source": "CSES", "difficulty": "medium", "tracks": [ "Summatory Arithmetic Functions" ], "tags": [ "Dirichlet Convolution", "Sigma Function", "Quotient Grouping", "Harmonic Lemma" ], "styles": [ "Math", "Implementation" ], "prerequisites": [ "Number Theory Basics", "Arithmetic Progression Sums", "Floor Division Grouping" ], "bucket": "core", "why_fit": "The cleanest first benchmark where sigma = 1 * id opens a divisor-side sum and equal floor(n / d) quotients collapse the runtime to O(sqrt(n))." }, { "slug": "math/dirichlet-prefix-sums", "topic": "Math -> Dirichlet Convolution / Prefix Sums Of Number-Theoretic Functions", "title": "Totient sums", "url": "https://cses.fi/ioi17/task/947", "source": "CSES", "difficulty": "hard", "tracks": [ "Summatory Arithmetic Functions" ], "tags": [ "Totient", "Prefix Sums", "Quotient Grouping", "Follow-Up" ], "styles": [ "Math", "Implementation" ], "prerequisites": [ "Dirichlet Convolution", "Quotient Grouping", "Euler Totient" ], "bucket": "stretch", "why_fit": "A useful compare point once the first direct sigma-prefix route is trusted; the same quotient-grouping worldview survives, but the arithmetic function is no longer available by one immediate convolution expansion." }, { "slug": "math/fft", "topic": "Math -> FFT And NTT", "title": "Convolution", "url": "https://atcoder.jp/contests/practice2/tasks/practice2_f", "source": "AtCoder", "difficulty": "easy", "tracks": [ "Convolution", "NTT", "Polynomial Multiplication" ], "tags": [ "Number Theoretic Transform", "Acl" ], "styles": [ "Implementation", "Math" ], "prerequisites": [ "Polynomial Convolution", "Roots Of Unity" ], "bucket": "core", "why_fit": "The cleanest official practice problem for plain convolution under a prime modulus." }, { "slug": "math/fft", "topic": "Math -> FFT And NTT", "title": "Convolution", "url": "https://judge.yosupo.jp/problem/convolution", "source": "Library Checker", "difficulty": "easy-medium", "tracks": [ "Polynomial Multiplication", "NTT" ], "tags": [ "Convolution", "998244353" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "The standard NTT/convolution benchmark." }, { "slug": "math/fft", "topic": "Math -> FFT And NTT", "title": "Convolution Mod", "url": "https://judge.yosupo.jp/problem/convolution_mod", "source": "Library Checker", "difficulty": "medium", "tracks": [ "Polynomial Multiplication", "NTT" ], "tags": [ "Mod Convolution", "NTT-Friendly", "Formal Power Series" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Same core idea but in the Library Checker format." }, { "slug": "math/fft", "topic": "Math -> FFT And NTT", "title": "Fast Fourier Transform", "url": "https://atcoder.jp/contests/atc001/tasks/fft_c", "source": "AtCoder", "difficulty": "medium", "tracks": [ "Convolution" ], "tags": [ "Signal Processing" ], "styles": [ "Math", "Implementation" ], "prerequisites": [ "Complex Numbers", "Polynomial Multiplication" ], "bucket": "core", "why_fit": "The canonical introductory FFT task and a very natural first heavy-convolution problem." }, { "slug": "math/fft", "topic": "Math -> FFT And NTT", "title": "Divisor Set", "url": "https://codeforces.com/problemset/problem/1257/g", "source": "Codeforces", "difficulty": "hard", "tracks": [ "Number Theory" ], "tags": [ "Divisors" ], "styles": [ "Math", "Divide-And-Conquer" ], "prerequisites": [ "Convolution", "Divisor Structure" ], "bucket": "stretch", "why_fit": "A strong FFT-adjacent number theory problem where convolution appears inside a divisor lattice." }, { "slug": "math/fft", "topic": "Math -> FFT And NTT", "title": "Function Sum", "url": "https://codeforces.com/problemset/problem/1731/F", "source": "Codeforces", "difficulty": "hard", "tracks": [ "Combinatorics" ], "tags": [ "Generating Functions" ], "styles": [ "Combinatorics", "Math" ], "prerequisites": [ "FFT", "Generating Functions" ], "bucket": "stretch", "why_fit": "A more advanced combinatorial setting where convolution is the right language." }, { "slug": "math/fft", "topic": "Math -> FFT And NTT", "title": "Substring Search", "url": "https://codeforces.com/problemset/problem/1334/G", "source": "Codeforces", "difficulty": "hard", "tracks": [ "Strings" ], "tags": [ "Substring Matching", "Bitmasks" ], "styles": [ "Strings", "Convolution" ], "prerequisites": [ "FFT Matching Ideas", "String Hashing Basics" ], "bucket": "stretch", "why_fit": "A challenging string task that benefits from efficient batch correlation." }, { "slug": "math/fft", "topic": "Math -> FFT And NTT", "title": "Yet Another String Matching Problem", "url": "https://codeforces.com/contest/954/problem/I", "source": "Codeforces", "difficulty": "hard", "tracks": [ "String-Matching" ], "tags": [ "Pattern Matching" ], "styles": [ "Strings", "Convolution" ], "prerequisites": [ "FFT-Based Matching", "Alphabet Encoding" ], "bucket": "stretch", "why_fit": "A classic FFT-powered string matching problem with a memorable, reusable trick." }, { "slug": "math/game-theory", "topic": "Math -> Game Theory / Sprague-Grundy", "title": "S-Nim", "url": "https://open.kattis.com/problems/snim", "source": "Kattis", "difficulty": "medium", "tracks": [ "Sprague-Grundy" ], "tags": [ "Subtraction-Game", "Nim-Sum" ], "styles": [ "Math", "Implementation" ], "prerequisites": [ "Impartial Game", "Mex", "XOR" ], "bucket": "core", "why_fit": "The cleanest exact starter route where one subtraction-game Grundy table is reused across many multi-heap positions." }, { "slug": "math/game-theory", "topic": "Math -> Game Theory / Sprague-Grundy", "title": "Nim Game II", "url": "https://cses.fi/problemset/task/1098", "source": "CSES", "difficulty": "medium", "tracks": [ "Sprague-Grundy", "Multi-Heap Games" ], "tags": [ "Nim-Sum", "Pattern", "Subtraction-Game" ], "styles": [ "Math", "Observation" ], "prerequisites": [ "XOR" ], "bucket": "stretch", "why_fit": "A strong follow-up where the SG values collapse to a short pattern, so the contest solution is theorem plus simplification rather than a full table." }, { "slug": "math/game-theory", "topic": "Math -> Game Theory / Sprague-Grundy", "title": "Dividing Game", "url": "https://atcoder.jp/contests/abc368/tasks/abc368_f", "source": "AtCoder", "difficulty": "hard", "tracks": [ "Number Theory" ], "tags": [ "Sprague-Grundy", "Prime-Factor-Count", "Independent-Heaps" ], "styles": [ "Math", "Observation" ], "prerequisites": [ "Sprague-Grundy", "Prime Factorization" ], "bucket": "challenge", "why_fit": "A challenge compare point where the heap nimber is recognized through arithmetic structure instead of direct DP over all states." }, { "slug": "math/game-theory", "topic": "Math -> Game Theory / Sprague-Grundy", "title": "Stick Game", "url": "https://cses.fi/problemset/task/1729", "source": "CSES", "difficulty": "medium", "tracks": [ "Single-Heap Games", "Sprague-Grundy" ], "tags": [ "Winning-Losing-DP", "Subtraction-Game", "Mex" ], "styles": [ "Math", "Dynamic Programming" ], "prerequisites": [ "Impartial Game", "State DP" ], "bucket": "bridge", "why_fit": "The simplest compare point where SG precompute starts on one heap before xor across heaps matters." }, { "slug": "math/gaussian-elimination", "topic": "Math -> Gaussian Elimination And Linear Algebra", "title": "System of Linear Equations", "url": "https://cses.fi/problemset/task/3154/", "source": "CSES", "difficulty": "hard", "tracks": [ "Linear Systems" ], "tags": [ "Linear Algebra", "Mod Prime", "Free Variables" ], "styles": [ "Math", "Implementation" ], "prerequisites": [ "Modular Arithmetic", "Matrix Modeling", "Gaussian Elimination" ], "bucket": "core", "why_fit": "The cleanest first verifier for the repo's exact route: solve one dense linear system modulo one prime and output any valid assignment." }, { "slug": "math/gaussian-elimination", "topic": "Math -> Gaussian Elimination And Linear Algebra", "title": "System of Linear Equations", "url": "https://judge.yosupo.jp/problem/system_of_linear_equations", "source": "Library Checker", "difficulty": "hard", "tracks": [ "Linear Systems" ], "tags": [ "Affine Solution Space", "Mod Prime" ], "styles": [ "Math", "Implementation" ], "prerequisites": [ "Gaussian Elimination", "Free Variables", "Basis Output" ], "bucket": "stretch", "why_fit": "Same elimination worldview, but the output contract is stricter because the full affine solution space must be exposed instead of only one assignment." }, { "slug": "math/gcd-lcm", "topic": "Math -> GCD And LCM", "title": "Calculate GCD", "url": "https://atcoder.jp/contests/math-and-algorithm/tasks/math_and_algorithm_o", "source": "AtCoder", "difficulty": "easy", "tracks": [ "Euclid" ], "tags": [ "GCD", "Euclid" ], "styles": [ "Implementation" ], "prerequisites": [ "Euclid's Algorithm" ], "bucket": "core", "why_fit": "The simplest gcd-only exercise and a good starting point for the track." }, { "slug": "math/gcd-lcm", "topic": "Math -> GCD And LCM", "title": "Greatest Common Divisor of N Integers", "url": "https://atcoder.jp/contests/math-and-algorithm/tasks/math_and_algorithm_p", "source": "AtCoder", "difficulty": "easy", "tracks": [ "Euclid" ], "tags": [ "GCD", "Reduce" ], "styles": [ "Implementation" ], "prerequisites": [ "Euclid's Algorithm" ], "bucket": "core", "why_fit": "Shows how gcd scales from pairs to arrays without adding extra theory." }, { "slug": "math/gcd-lcm", "topic": "Math -> GCD And LCM", "title": "Least Common Multiple of N Integers", "url": "https://atcoder.jp/contests/math-and-algorithm/tasks/math_and_algorithm_q", "source": "AtCoder", "difficulty": "easy", "tracks": [ "Overflow-Safety" ], "tags": [ "LCM", "GCD", "Overflow" ], "styles": [ "Implementation" ], "prerequisites": [ "GCD", "Safe Multiplication" ], "bucket": "core", "why_fit": "A direct lcm task that reinforces the gcd-based formula and overflow control." }, { "slug": "math/gcd-lcm", "topic": "Math -> GCD And LCM", "title": "GCD and LCM", "url": "https://open.kattis.com/problems/gcdandlcm", "source": "Kattis", "difficulty": "easy-medium", "tracks": [], "tags": [ "GCD Formula", "LCM Formula", "Integer Arithmetic" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Straightforward gcd/lcm arithmetic practice." }, { "slug": "math/gcd-lcm", "topic": "Math -> GCD And LCM", "title": "GCD Pairs", "url": "https://open.kattis.com/problems/gcdpairs", "source": "Kattis", "difficulty": "medium", "tracks": [ "GCD Counting", "Mobius" ], "tags": [ "Pair Counting", "Divisors", "Coprime" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Uses gcd counting ideas at a pair-of-values level." }, { "slug": "math/gcd-lcm", "topic": "Math -> GCD And LCM", "title": "GCD on Blackboard", "url": "https://atcoder.jp/contests/abc125/tasks/abc125_c", "source": "AtCoder", "difficulty": "medium", "tracks": [ "Prefix/Suffix GCD" ], "tags": [ "Remove-One", "GCD Array", "Prefix Suffix" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Classic one-removal gcd optimization." }, { "slug": "math/gcd-lcm", "topic": "Math -> GCD And LCM", "title": "Orac and LCM", "url": "https://codeforces.com/contest/1349/problem/A", "source": "Codeforces", "difficulty": "medium", "tracks": [ "Number Theory" ], "tags": [ "GCD", "LCM", "Prime Exponents" ], "styles": [ "Math", "Implementation" ], "prerequisites": [ "Prime Factorization", "GCD/LCM Identities" ], "bucket": "core", "why_fit": "A classic pairwise-lcm/gcd identity problem and a strong conceptual checkpoint." }, { "slug": "math/gcd-lcm", "topic": "Math -> GCD And LCM", "title": "GCD Harmony", "url": "https://open.kattis.com/problems/gcdharmony", "source": "Kattis", "difficulty": "hard", "tracks": [ "GCD Constraints", "Optimization" ], "tags": [ "GCD Reasoning", "Integer Transform", "Number Theory" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "A deeper gcd-flavored optimization problem." }, { "slug": "math/gcd-lcm", "topic": "Math -> GCD And LCM", "title": "Common Divisors", "url": "https://cses.fi/problemset/task/1081", "source": "CSES", "difficulty": "medium", "tracks": [ "Frequency-Ideas", "Divisibility" ], "tags": [ "GCD", "Divisor Frequency", "Maximum GCD", "Frequency Over Divisors", "Array GCD" ], "styles": [ "Number Theory" ], "prerequisites": [ "GCD", "Divisor Counting" ], "bucket": "practice", "why_fit": "Directly about maximizing gcd structure in an array." }, { "slug": "math/gcd-lcm", "topic": "Math -> GCD And LCM", "title": "LCM on Whiteboard", "url": "https://atcoder.jp/contests/abc259/tasks/abc259_e", "source": "AtCoder", "difficulty": "medium", "tracks": [ "Prime-Factorization" ], "tags": [ "LCM", "Prime Exponents", "Set Cover" ], "styles": [ "Number Theory", "Implementation" ], "prerequisites": [ "LCM Via Maximum Exponents" ], "bucket": "practice", "why_fit": "A richer lcm problem that rewards exponent-level reasoning across many numbers." }, { "slug": "math/gcd-lcm", "topic": "Math -> GCD And LCM", "title": "Large LCM", "url": "https://atcoder.jp/contests/typical90/tasks/typical90_al", "source": "AtCoder", "difficulty": "medium", "tracks": [ "Overflow-Safety" ], "tags": [ "LCM", "Overflow", "Large Integers" ], "styles": [ "Implementation", "Math" ], "prerequisites": [ "GCD", "Overflow-Safe Arithmetic" ], "bucket": "practice", "why_fit": "A standard large-lcm variation where the answer must be capped safely." }, { "slug": "math/linear-recurrence", "topic": "Math -> Linear Recurrence And Matrix Exponentiation", "title": "Fibonacci Numbers", "url": "https://cses.fi/problemset/task/1722", "source": "CSES", "difficulty": "medium", "tracks": [ "Matrix/Recurrence" ], "tags": [ "Matrix Exponentiation", "Fibonacci", "Fast Doubling Compare" ], "styles": [ "Math", "Implementation" ], "prerequisites": [ "Binary Exponentiation", "Modular Arithmetic" ], "bucket": "core", "why_fit": "The smallest exact recurrence-lifting example and the cleanest compare point against fast doubling." }, { "slug": "math/linear-recurrence", "topic": "Math -> Linear Recurrence And Matrix Exponentiation", "title": "Throwing Dice", "url": "https://cses.fi/problemset/task/1096", "source": "CSES", "difficulty": "medium", "tracks": [ "DP/Recurrences" ], "tags": [ "Matrix Exponentiation", "Companion Matrix", "Mod Arithmetic" ], "styles": [ "Dynamic Programming", "Math" ], "prerequisites": [ "Basic DP", "Modular Arithmetic" ], "bucket": "core", "why_fit": "A fixed-width order-6 recurrence where huge n turns an ordinary DP into a companion-matrix route." }, { "slug": "math/linear-recurrence", "topic": "Math -> Linear Recurrence And Matrix Exponentiation", "title": "Graph Paths I", "url": "https://cses.fi/problemset/task/1723", "source": "CSES", "difficulty": "hard", "tracks": [ "Graphs/Walk Counting" ], "tags": [ "Matrix Exponentiation", "Adjacency Matrix", "Walk Counting" ], "styles": [ "Graphs", "Math" ], "prerequisites": [ "Matrix Exponentiation", "Graph Modeling" ], "bucket": "stretch", "why_fit": "Shows the same repeated-linear-transition worldview outside one-dimensional recurrences." }, { "slug": "math/lucas-theorem", "topic": "Math -> Lucas Theorem And Large Binomial Mod Prime", "title": "Binomial Coefficient (Prime Mod)", "url": "https://judge.yosupo.jp/problem/binomial_coefficient_prime_mod", "source": "Library Checker", "difficulty": "medium", "tracks": [ "Binomial Coefficients" ], "tags": [ "Binomial Coefficient", "Prime Modulus" ], "styles": [ "Math", "Implementation" ], "prerequisites": [ "Modular Arithmetic", "Factorial Binomial", "Base Conversion" ], "bucket": "core", "why_fit": "A clean benchmark for the route split between one ordinary factorial table and Lucas digit decomposition under one prime modulus." }, { "slug": "math/lucas-theorem", "topic": "Math -> Lucas Theorem And Large Binomial Mod Prime", "title": "Odd Binomial Coefficients", "url": "https://open.kattis.com/problems/oddbinom", "source": "Kattis", "difficulty": "hard", "tracks": [ "Binomial Coefficients", "Pascal Structure" ], "tags": [ "Parity", "Bitwise Pattern" ], "styles": [ "Math", "Observation" ], "prerequisites": [ "Lucas Theorem", "Bitwise Reasoning" ], "bucket": "stretch", "why_fit": "A strong compare point where Lucas with p = 2 exposes a structural parity pattern instead of only answering one binomial query." }, { "slug": "math/min25-du-jiao", "topic": "Math -> Min_25 / Du Jiao", "title": "Sum of Totient Function", "url": "https://judge.yosupo.jp/problem/sum_of_totient_function", "source": "Library Checker", "difficulty": "hard", "tracks": [ "Prefix Sums" ], "tags": [ "Du Jiao Sieve", "Euler Totient", "Quotient Set", "Dirichlet Convolution" ], "styles": [ "Math", "Implementation" ], "prerequisites": [ "Dirichlet Convolution", "Euler Totient", "Quotient Grouping" ], "bucket": "core", "why_fit": "The cleanest first benchmark where phi * 1 = id stops being one direct divisor-side expansion and instead becomes a quotient-set recurrence for the prefix sum itself." }, { "slug": "math/min25-du-jiao", "topic": "Math -> Min_25 / Du Jiao", "title": "Totient sums", "url": "https://cses.fi/ioi17/task/947", "source": "CSES", "difficulty": "hard", "tracks": [ "Prefix Sums" ], "tags": [ "Totient", "Quotient Set", "Follow-Up" ], "styles": [ "Math", "Implementation" ], "prerequisites": [ "Du Jiao Sieve", "Euler Totient", "Quotient Grouping" ], "bucket": "stretch", "why_fit": "A natural compare point after the first Du Jiao verifier route is trusted; it asks for the same implicit prefix-sum recovery worldview without forcing the lane to overclaim full Min_25 as the starter." }, { "slug": "math/mobius-multiplicative", "topic": "Math -> Mobius And Multiplicative Counting", "title": "Counting Coprime Pairs", "url": "https://cses.fi/problemset/task/2417", "source": "CSES", "difficulty": "medium", "tracks": [ "Coprime Pair Counting" ], "tags": [ "Mobius Function", "Divisor Frequency", "Coprime Pairs", "Linear Sieve" ], "styles": [ "Math", "Implementation" ], "prerequisites": [ "Number Theory Basics", "Inclusion-Exclusion", "Linear Sieve" ], "bucket": "core", "why_fit": "The cleanest first benchmark where divisor frequencies plus Mobius cancellation replace pairwise gcd checks entirely." }, { "slug": "math/modular-arithmetic", "topic": "Math -> Modular Arithmetic", "title": "Exponentiation", "url": "https://cses.fi/problemset/task/1095", "source": "CSES", "difficulty": "easy", "tracks": [ "Fast-Exponentiation", "Mod Arithmetic" ], "tags": [ "Binary Exponentiation", "Pow" ], "styles": [ "Implementation", "Math" ], "prerequisites": [ "Modular Arithmetic", "Binary Exponentiation" ], "bucket": "core", "why_fit": "Canonical modular fast-power warmup." }, { "slug": "math/modular-arithmetic", "topic": "Math -> Modular Arithmetic", "title": "Distributing Apples", "url": "https://cses.fi/problemset/task/1716", "source": "CSES", "difficulty": "easy-medium", "tracks": [ "Stars And Bars", "Mod Arithmetic" ], "tags": [ "Combinations", "Distributions" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Simple counting with modular binomial coefficients." }, { "slug": "math/modular-arithmetic", "topic": "Math -> Modular Arithmetic", "title": "Binomial Coefficients", "url": "https://cses.fi/problemset/task/1079", "source": "CSES", "difficulty": "medium", "tracks": [ "Combinatorics/Counting-Basics", "Mod Inverses", "Combinatorics" ], "tags": [ "Ncr", "Factorials", "Modular Inverse", "Inverse Factorials" ], "styles": [ "Math", "Precomputation" ], "prerequisites": [ "Factorials", "Modular Inverse", "Combinations" ], "bucket": "core", "why_fit": "Standard modular combinations with precomputation." }, { "slug": "math/modular-arithmetic", "topic": "Math -> Modular Arithmetic", "title": "Creating Strings II", "url": "https://cses.fi/problemset/task/1715", "source": "CSES", "difficulty": "medium", "tracks": [ "Factorials", "Mod Inverses" ], "tags": [ "Multiset Permutations", "Combinatorics", "Mod Arithmetic" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Distinct-string counting via modular combinatorics." }, { "slug": "math/modular-arithmetic", "topic": "Math -> Modular Arithmetic", "title": "Exponentiation II", "url": "https://cses.fi/problemset/task/1712", "source": "CSES", "difficulty": "medium", "tracks": [ "Fast-Exponentiation", "Mod-Inverse", "Totient Tricks" ], "tags": [ "Tower Exponentiation", "Fermats-Little-Theorem", "Mod Arithmetic", "Phi" ], "styles": [ "Implementation", "Number Theory" ], "prerequisites": [ "Binary Exponentiation", "Modular Arithmetic", "Fermat's Little Theorem" ], "bucket": "core", "why_fit": "Adds exponent towers and modulus reduction logic." }, { "slug": "math/modular-arithmetic", "topic": "Math -> Modular Arithmetic", "title": "Counting Grids", "url": "https://cses.fi/problemset/task/2210", "source": "CSES", "difficulty": "hard", "tracks": [ "Combinatorics/Bracelet-Counting" ], "tags": [ "Burnside", "Pólya Counting", "Mod Arithmetic" ], "styles": [ "Combinatorics", "Algebra" ], "prerequisites": [ "Modular Arithmetic", "Symmetry Counting" ], "bucket": "stretch", "why_fit": "A stronger symmetry-counting problem that rewards comfortable modular evaluation." }, { "slug": "math/modular-arithmetic", "topic": "Math -> Modular Arithmetic", "title": "Counting Necklaces", "url": "https://cses.fi/problemset/task/2209", "source": "CSES", "difficulty": "hard", "tracks": [ "Combinatorics/Burnside" ], "tags": [ "Burnside", "Group Actions", "Mod Arithmetic" ], "styles": [ "Combinatorics", "Number Theory" ], "prerequisites": [ "Modular Arithmetic", "Group Actions", "GCD/LCM Basics" ], "bucket": "stretch", "why_fit": "A canonical advanced counting problem where modular arithmetic sits inside Burnside's lemma." }, { "slug": "math/modular-arithmetic", "topic": "Math -> Modular Arithmetic", "title": "Graph Paths I", "url": "https://cses.fi/problemset/task/1723", "source": "CSES", "difficulty": "hard", "tracks": [ "Matrix-Exponentiation" ], "tags": [ "Graph Walks", "Mod Arithmetic" ], "styles": [ "Graphs", "Math" ], "prerequisites": [ "Modular Arithmetic", "Matrix Multiplication", "DP On Walks" ], "bucket": "stretch", "why_fit": "A classic matrix-exponentiation application where the answer is required modulo a prime." }, { "slug": "math/modular-square-root-discrete-root", "topic": "Math -> Modular Square Root / Discrete Root", "title": "Sqrt Mod", "url": "https://judge.yosupo.jp/problem/sqrt_mod", "source": "Library Checker", "difficulty": "hard", "tracks": [ "Quadratic Residues" ], "tags": [ "Modular Square Root", "Tonelli-Shanks", "Quadratic Residue", "Prime Modulus" ], "styles": [ "Math", "Implementation" ], "prerequisites": [ "Modular Arithmetic", "Binary Exponentiation", "Prime Modulus" ], "bucket": "core", "why_fit": "The cleanest verifier-style benchmark where the first exact route is just: test quadratic-residue reachability, then recover one root with Tonelli-Shanks." }, { "slug": "math/modular-square-root-discrete-root", "topic": "Math -> Modular Square Root / Discrete Root", "title": "K-th Root Mod", "url": "https://judge.yosupo.jp/problem/kth_root_mod", "source": "Library Checker", "difficulty": "hard", "tracks": [ "Discrete Root" ], "tags": [ "Primitive Root", "Bsgs", "Linear Congruence In Exponents" ], "styles": [ "Math", "Implementation" ], "prerequisites": [ "Modular Square Root", "Discrete Log", "Primitive Root" ], "bucket": "stretch", "why_fit": "The natural follow-up once the square-root lane is trusted and the learner is ready to reduce x^k ≡ a (mod p) to primitive-root and discrete-log machinery." }, { "slug": "math/number-theory-basics", "topic": "Math -> Number Theory Basics", "title": "Calculate GCD", "url": "https://atcoder.jp/contests/math-and-algorithm/tasks/math_and_algorithm_o", "source": "AtCoder", "difficulty": "easy", "tracks": [ "GCD/LCM" ], "tags": [ "GCD", "Euclid" ], "styles": [ "Implementation", "Math" ], "prerequisites": [ "Euclid's Algorithm" ], "bucket": "core", "why_fit": "A minimal Euclidean-algorithm exercise with no extra machinery." }, { "slug": "math/number-theory-basics", "topic": "Math -> Number Theory Basics", "title": "Divisor Enumeration", "url": "https://atcoder.jp/contests/math-and-algorithm/tasks/math_and_algorithm_m", "source": "AtCoder", "difficulty": "easy", "tracks": [ "Divisors" ], "tags": [ "Enumeration" ], "styles": [ "Implementation", "Math" ], "prerequisites": [ "Divisibility", "Sqrt Factorization" ], "bucket": "core", "why_fit": "A basic divisor-enumeration drill that teaches the square-root loop pattern." }, { "slug": "math/number-theory-basics", "topic": "Math -> Number Theory Basics", "title": "Factorization", "url": "https://atcoder.jp/contests/math-and-algorithm/tasks/math_and_algorithm_n", "source": "AtCoder", "difficulty": "easy", "tracks": [ "Primes", "Factorization" ], "tags": [ "Prime Factorization", "Trial Division" ], "styles": [ "Implementation", "Math" ], "prerequisites": [ "Division" ], "bucket": "core", "why_fit": "The standard first factorization problem before jumping into sieve-heavy tasks." }, { "slug": "math/number-theory-basics", "topic": "Math -> Number Theory Basics", "title": "Greatest Common Divisor of N Integers", "url": "https://atcoder.jp/contests/math-and-algorithm/tasks/math_and_algorithm_p", "source": "AtCoder", "difficulty": "easy", "tracks": [ "GCD/LCM" ], "tags": [ "GCD", "Fold/Reduce" ], "styles": [ "Implementation", "Math" ], "prerequisites": [ "Euclid's Algorithm", "Iterative Reduction" ], "bucket": "core", "why_fit": "A natural follow-up that checks whether you can fold gcd across many values." }, { "slug": "math/number-theory-basics", "topic": "Math -> Number Theory Basics", "title": "Least Common Multiple of N Integers", "url": "https://atcoder.jp/contests/math-and-algorithm/tasks/math_and_algorithm_q", "source": "AtCoder", "difficulty": "easy", "tracks": [ "GCD/LCM" ], "tags": [ "LCM", "GCD", "Overflow Avoidance" ], "styles": [ "Implementation", "Math" ], "prerequisites": [ "GCD", "Safe Multiplication" ], "bucket": "core", "why_fit": "A very standard lcm problem that also reinforces overflow-safe formulas." }, { "slug": "math/number-theory-basics", "topic": "Math -> Number Theory Basics", "title": "Primality Test", "url": "https://atcoder.jp/contests/math-and-algorithm/tasks/math_and_algorithm_l", "source": "AtCoder", "difficulty": "easy", "tracks": [ "Primes" ], "tags": [ "Primality", "Trial Division" ], "styles": [ "Implementation", "Math" ], "prerequisites": [ "Divisibility", "Prime Numbers" ], "bucket": "core", "why_fit": "A direct, foundational prime-checking exercise with clear constraints." }, { "slug": "math/number-theory-basics", "topic": "Math -> Number Theory Basics", "title": "Prime Multiples", "url": "https://cses.fi/problemset/task/2185", "source": "CSES", "difficulty": "medium", "tracks": [ "Inclusion-Exclusion", "Primes" ], "tags": [ "Subset Enumeration", "LCM", "Counting Multiples" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Counts multiples of prime sets with inclusion-exclusion." }, { "slug": "math/number-theory-basics", "topic": "Math -> Number Theory Basics", "title": "Counting Coprime Pairs", "url": "https://cses.fi/problemset/task/2417", "source": "CSES", "difficulty": "medium-hard", "tracks": [ "Mobius Inversion", "GCD" ], "tags": [ "Coprime Pairs", "Number Theory", "Inclusion-Exclusion" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "A stronger gcd/Mobius counting exercise." }, { "slug": "math/number-theory-basics", "topic": "Math -> Number Theory Basics", "title": "Counting Divisors", "url": "https://cses.fi/problemset/task/1713", "source": "CSES", "difficulty": "easy", "tracks": [ "Divisors", "Factorization", "Prime Factorization", "Divisor Counting" ], "tags": [ "Divisor-Count", "Sieve", "Tau(n)" ], "styles": [ "Math", "Implementation" ], "prerequisites": [ "Exponent Counting" ], "bucket": "practice", "why_fit": "Direct divisor-counting from prime exponents." }, { "slug": "math/number-theory-basics", "topic": "Math -> Number Theory Basics", "title": "Next Prime", "url": "https://cses.fi/problemset/task/3396", "source": "CSES", "difficulty": "easy-medium", "tracks": [ "Primes", "Sieving", "Primality Testing" ], "tags": [ "Prime Search", "Miller-Rabin-Style Thinking", "Next Prime", "Miller-Rabin", "Trial Division" ], "styles": [ "Implementation", "Number Theory" ], "prerequisites": [ "Search Over Integers" ], "bucket": "practice", "why_fit": "Good basic prime-search / primality practice." }, { "slug": "math/number-theory-basics", "topic": "Math -> Number Theory Basics", "title": "Common Divisors", "url": "https://cses.fi/problemset/task/1081", "source": "CSES", "difficulty": "medium", "tracks": [ "GCD/LCM", "Frequency-Ideas" ], "tags": [ "GCD", "Max-Frequency Divisor" ], "styles": [ "Number Theory", "Sieving" ], "prerequisites": [ "GCD", "Divisor Counting" ], "bucket": "practice", "why_fit": "A classic gcd-frequency problem that pushes beyond one-off Euclid calls." }, { "slug": "math/number-theory-basics", "topic": "Math -> Number Theory Basics", "title": "Sum of Divisors", "url": "https://cses.fi/problemset/task/1082", "source": "CSES", "difficulty": "medium", "tracks": [ "Divisors", "Prefix-Sums", "Divisor Sums", "Arithmetical Functions" ], "tags": [ "Sigma Function", "Divisor Summatory Function", "Sigma(n)", "Floor Division", "Mod Arithmetic" ], "styles": [ "Math", "Optimization" ], "prerequisites": [ "Floor-Division Grouping" ], "bucket": "practice", "why_fit": "Core multiplicative-function summation." }, { "slug": "math/number-theory-basics", "topic": "Math -> Number Theory Basics", "title": "Divisor Analysis", "url": "https://cses.fi/problemset/task/2182", "source": "CSES", "difficulty": "medium", "tracks": [ "Divisors", "Modular-Arithmetic", "Prime Factorization", "Multiplicative Functions" ], "tags": [ "Number Of Divisors", "Sum Of Divisors", "Product Of Divisors" ], "styles": [ "Math", "Precomputation" ], "prerequisites": [ "Geometric Series" ], "bucket": "stretch", "why_fit": "Bundle of the three textbook divisor-function formulas." }, { "slug": "math/pollard-rho", "topic": "Math -> Pollard-Rho", "title": "Factorize", "url": "https://judge.yosupo.jp/problem/factorize", "source": "Library Checker", "difficulty": "hard", "tracks": [ "Integer Factorization" ], "tags": [ "Miller-Rabin", "Prime Factorization", "64-Bit" ], "styles": [ "Math", "Implementation" ], "prerequisites": [ "Modular Arithmetic", "Fast Power", "Prime Testing" ], "bucket": "core", "why_fit": "The cleanest verifier for the repo's exact route: deterministic 64-bit primality plus Pollard-Rho recursive splitting with sorted prime-multiset output." }, { "slug": "math/polynomial-fps", "topic": "Math -> Polynomial / Formal Power Series", "title": "Inv of Formal Power Series", "url": "https://judge.yosupo.jp/problem/inv_of_formal_power_series", "source": "Library Checker", "difficulty": "hard", "tracks": [ "Formal Power Series", "NTT" ], "tags": [ "Inverse", "Newton Iteration" ], "styles": [ "Implementation", "Algebra" ], "prerequisites": [ "Exact Convolution", "Formal Power Series Mod X^n" ], "bucket": "core", "why_fit": "The clean first benchmark where the entire task is one truncated FPS inverse and Newton doubling is the exact intended route." }, { "slug": "math/polynomial-fps", "topic": "Math -> Polynomial / Formal Power Series", "title": "Log of Formal Power Series", "url": "https://judge.yosupo.jp/problem/log_of_formal_power_series", "source": "Library Checker", "difficulty": "hard", "tracks": [ "Formal Power Series", "NTT" ], "tags": [ "Logarithm", "Derivative", "Inverse" ], "styles": [ "Implementation", "Algebra" ], "prerequisites": [ "Fps Inverse", "Derivative And Integral" ], "bucket": "stretch", "why_fit": "The natural follow-up once the inverse route is trusted, because FPS log is just derivative, inverse, product, and integral glued together." }, { "slug": "math/polynomial-fps", "topic": "Math -> Polynomial / Formal Power Series", "title": "Exp of Formal Power Series", "url": "https://judge.yosupo.jp/problem/exp_of_formal_power_series", "source": "Library Checker", "difficulty": "hard", "tracks": [ "Formal Power Series", "NTT" ], "tags": [ "Exponential", "Newton Iteration", "Advanced" ], "styles": [ "Implementation", "Advanced Algebra" ], "prerequisites": [ "Fps Inverse", "Fps Log" ], "bucket": "challenge", "why_fit": "A major step up where the same FPS worldview survives but the contract grows beyond plain inversion." }, { "slug": "math/polynomial-fps", "topic": "Math -> Polynomial / Formal Power Series", "title": "Pow of Formal Power Series", "url": "https://judge.yosupo.jp/problem/pow_of_formal_power_series", "source": "Library Checker", "difficulty": "hard", "tracks": [ "Formal Power Series", "NTT" ], "tags": [ "Power", "Log-Exp", "Advanced" ], "styles": [ "Implementation", "Advanced Algebra" ], "prerequisites": [ "Fps Log", "Fps Exp" ], "bucket": "challenge", "why_fit": "A good later verifier once inverse/log/exp are in place and FPS algebra starts to feel compositional instead of magical." }, { "slug": "math/primitive-root", "topic": "Math -> Primitive Root", "title": "Primitive Root", "url": "https://judge.yosupo.jp/problem/primitive_root", "source": "Library Checker", "difficulty": "hard", "tracks": [], "tags": [ "Generator", "Prime Modulus", "Factorization" ], "styles": [ "Math", "Implementation" ], "prerequisites": [ "Modular Arithmetic", "Fast Power", "Prime Factorization" ], "bucket": "core", "why_fit": "The cleanest verifier for the repo's exact route: factor p - 1, then reject candidate generators whose reduced-order powers collapse to 1." }, { "slug": "math/primitive-root", "topic": "Math -> Primitive Root", "title": "K-th Root Mod", "url": "https://judge.yosupo.jp/problem/kth_root_mod", "source": "Library Checker", "difficulty": "hard", "tracks": [ "Discrete Root" ], "tags": [ "Discrete Log", "Linear Congruence In Exponents" ], "styles": [ "Math", "Implementation" ], "prerequisites": [ "Primitive Root", "Discrete Log", "Modular Arithmetic" ], "bucket": "stretch", "why_fit": "The natural follow-up once generator finding is trusted and the learner is ready to reduce x^k ≡ a (mod p) to exponent arithmetic." }, { "slug": "math/probability", "topic": "Math -> Probability", "title": "Dice Probability", "url": "https://cses.fi/problemset/task/1725", "source": "CSES", "difficulty": "medium", "tracks": [ "Distributions" ], "tags": [ "Probability-DP", "Pmf", "Dice" ], "styles": [ "Math", "Dynamic Programming" ], "prerequisites": [ "Basic Probability", "State DP" ], "bucket": "core", "why_fit": "The cleanest first benchmark where an exact probability answer comes from propagating a bounded sum distribution over repeated random steps." }, { "slug": "math/probability", "topic": "Math -> Probability", "title": "Moving Robots", "url": "https://cses.fi/problemset/task/1726", "source": "CSES", "difficulty": "hard", "tracks": [ "Random Walks" ], "tags": [ "Transition-Probability", "Independence", "Expectation" ], "styles": [ "Math", "State Transitions" ], "prerequisites": [ "Probability DP", "Independent Events" ], "bucket": "stretch", "why_fit": "A natural next step where one finite-state transition distribution is combined across many independent walkers." }, { "slug": "math/probability", "topic": "Math -> Probability", "title": "Inversion Probability", "url": "https://cses.fi/problemset/task/1728", "source": "CSES", "difficulty": "hard", "tracks": [ "Expected Value" ], "tags": [ "Linearity-Of-Expectation", "Pairs", "Expectation" ], "styles": [ "Math", "Counting" ], "prerequisites": [ "Counting Basics" ], "bucket": "challenge", "why_fit": "A harder compare point where linearity of expectation beats any attempt to model the full joint distribution directly." }, { "slug": "math/probability", "topic": "Math -> Probability", "title": "Candy Lottery", "url": "https://cses.fi/problemset/task/1727", "source": "CSES", "difficulty": "medium", "tracks": [ "Expected Value" ], "tags": [ "Distribution-Of-Maximum", "Independence" ], "styles": [ "Math", "Observation" ], "prerequisites": [ "Basic Probability" ], "bucket": "bridge", "why_fit": "A strong compare point where the shortest solution derives a distribution first and only then takes expectation." }, { "slug": "math/xor-basis", "topic": "Math -> XOR Basis / Linear Basis", "title": "XMAX - XOR Maximization", "url": "https://www.spoj.com/problems/XMAX/", "source": "SPOJ", "difficulty": "medium", "tracks": [ "Bitwise Algebra" ], "tags": [ "Linear-Basis", "Maximum-Subset-XOR" ], "styles": [ "Math", "Implementation" ], "prerequisites": [ "Bitwise Operations", "Greedy Elimination", "Subset XOR" ], "bucket": "core", "why_fit": "The cleanest first benchmark where a linear basis replaces brute-force subset xor search entirely." }, { "slug": "math/xor-basis", "topic": "Math -> XOR Basis / Linear Basis", "title": "Shortest Path Problem?", "url": "https://codeforces.com/problemset/problem/845/G", "source": "Codeforces", "difficulty": "hard", "tracks": [ "Graphs/Cycle XOR", "Bitwise Algebra" ], "tags": [ "Cycle-Space", "Path-XOR" ], "styles": [ "Graphs", "Math" ], "prerequisites": [ "XOR Basis", "DFS", "Cycle Reasoning" ], "bucket": "stretch", "why_fit": "The flagship bridge from subset xor span to graph cycle-space reductions, where each non-tree edge contributes one xor cycle vector." }, { "slug": "math/xor-basis", "topic": "Math -> XOR Basis / Linear Basis", "title": "ZC's School", "url": "https://codeforces.com/contest/1101/problem/G", "source": "Codeforces", "difficulty": "hard", "tracks": [ "Prefix XOR", "Bitwise Algebra" ], "tags": [ "Dimension" ], "styles": [ "Math", "Observation" ], "prerequisites": [ "XOR Basis", "Invariant Reasoning" ], "bucket": "challenge", "why_fit": "A harder compare point where basis dimension over prefix xor values becomes the real invariant instead of direct maximum-subset-xor extraction." }, { "slug": "strings/aho-corasick", "topic": "Strings -> Aho-Corasick", "title": "Finding Patterns", "url": "https://cses.fi/problemset/task/2102", "source": "CSES", "difficulty": "medium", "tracks": [], "tags": [ "Multi-Pattern Matching", "Automata" ], "styles": [ "Offline Matching" ], "prerequisites": [ "Trie", "Failure Links" ], "bucket": "core", "why_fit": "Direct multi-pattern presence queries are the textbook Aho-Corasick use case." }, { "slug": "strings/aho-corasick", "topic": "Strings -> Aho-Corasick", "title": "String Multimatching", "url": "https://open.kattis.com/problems/stringmultimatching", "source": "Kattis", "difficulty": "medium", "tracks": [ "Multi-Pattern-Matching" ], "tags": [ "Text Scanning", "Output-All" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "The standard “find all patterns in one text” AC problem." }, { "slug": "strings/aho-corasick", "topic": "Strings -> Aho-Corasick", "title": "Word Combinations", "url": "https://cses.fi/problemset/task/1731", "source": "CSES", "difficulty": "medium", "tracks": [ "DP" ], "tags": [ "Dictionary", "Segmentation", "Prefix-Automaton" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Can be accelerated by automaton-style prefix matching in the dictionary." }, { "slug": "strings/aho-corasick", "topic": "Strings -> Aho-Corasick", "title": "aho_corasick", "url": "https://judge.yosupo.jp/problem/aho_corasick", "source": "Library Checker", "difficulty": "medium", "tracks": [ "Multi-Pattern-Matching" ], "tags": [ "Failure Links", "Dictionary" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Direct official benchmark for building and querying the automaton." }, { "slug": "strings/aho-corasick", "topic": "Strings -> Aho-Corasick", "title": "Counting Patterns", "url": "https://cses.fi/problemset/task/2103", "source": "CSES", "difficulty": "hard", "tracks": [], "tags": [ "Multi-Pattern Matching", "Counting" ], "styles": [ "Aggregation", "Offline Matching" ], "prerequisites": [ "Trie", "Failure Links", "Output Links" ], "bucket": "core", "why_fit": "Counts all occurrences, which is where Aho-Corasick becomes especially useful." }, { "slug": "strings/aho-corasick", "topic": "Strings -> Aho-Corasick", "title": "Pattern Positions", "url": "https://cses.fi/problemset/task/2104", "source": "CSES", "difficulty": "hard", "tracks": [ "Trie" ], "tags": [ "Multi-Pattern Matching", "First Occurrence", "Many-Patterns", "Text-Search" ], "styles": [ "Offline Matching" ], "prerequisites": [ "Failure Links" ], "bucket": "core", "why_fit": "A clean extension of Aho-Corasick that asks for earliest matches per pattern." }, { "slug": "strings/aho-corasick", "topic": "Strings -> Aho-Corasick", "title": "Genetic engineering", "url": "https://codeforces.com/problemset/problem/86/C", "source": "Codeforces", "difficulty": "hard", "tracks": [], "tags": [ "DP", "Automata" ], "styles": [ "DP On Automaton", "Pattern Exclusion" ], "prerequisites": [ "Trie", "Failure Links", "Automaton DP" ], "bucket": "challenge", "why_fit": "A classic AC-plus-DP problem for constrained string construction." }, { "slug": "strings/eertree", "topic": "Strings -> Eertree / Palindromic Tree", "title": "Palindromes and Super Abilities", "url": "https://acm.timus.ru/problem.aspx?num=1960&space=1", "source": "Timus", "difficulty": "medium", "tracks": [ "Distinct Palindromes" ], "tags": [ "Palindromic Tree", "Append-Only String", "Per-Prefix Output" ], "styles": [ "Online Append", "Data Structure", "Per-Prefix Counting" ], "prerequisites": [ "Palindrome Basics", "Suffix Links", "Append-Only Updates" ], "bucket": "core", "why_fit": "The cleanest first exact Eertree problem because each prefix answer is just the number of ordinary nodes after one append update." }, { "slug": "strings/eertree", "topic": "Strings -> Eertree / Palindromic Tree", "title": "eertree", "url": "https://judge.yosupo.jp/problem/eertree", "source": "Library Checker", "difficulty": "medium", "tracks": [], "tags": [ "Palindromic Tree", "Construction" ], "styles": [ "Verification", "Construction" ], "prerequisites": [ "Eertree Basics", "Suffix-Link Walk", "Distinct Palindrome Nodes" ], "bucket": "practice", "why_fit": "Official verifier for the exact family; useful once the basic append-only invariants feel stable." }, { "slug": "strings/eertree", "topic": "Strings -> Eertree / Palindromic Tree", "title": "Palindromic characteristics", "url": "https://codeforces.com/problemset/problem/835/D", "source": "Codeforces", "difficulty": "hard", "tracks": [ "DP" ], "tags": [ "Palindrome", "Distinct Structure" ], "styles": [ "DP", "Palindrome Structure" ], "prerequisites": [ "Eertree Basics", "Palindrome DP", "Distinct Palindrome Worldview" ], "bucket": "stretch", "why_fit": "A strong stretch problem once the basic tree is trusted and you are ready to layer extra palindrome DP on top." }, { "slug": "strings/hashing", "topic": "Strings -> Hashing", "title": "String Hashing", "url": "https://open.kattis.com/problems/hashing", "source": "Kattis", "difficulty": "easy", "tracks": [ "Rolling Hash", "Substring Comparison" ], "tags": [ "LCS", "Equality" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Direct, judge-style hashing practice with low overhead and clean input." }, { "slug": "strings/hashing", "topic": "Strings -> Hashing", "title": "Good Substrings", "url": "https://codeforces.com/problemset/problem/271/D", "source": "Codeforces", "difficulty": "medium", "tracks": [ "Distinct Substrings" ], "tags": [ "Trie", "Substrings", "Hash Or Trie" ], "styles": [ "Enumeration", "Deduplication" ], "prerequisites": [ "Rolling Hash", "Set Or Map Deduplication" ], "bucket": "core", "why_fit": "A standard distinct-substring counting problem where hashing trims the search space." }, { "slug": "strings/hashing", "topic": "Strings -> Hashing", "title": "Watto and Mechanism", "url": "https://codeforces.com/problemset/problem/514/C", "source": "Codeforces", "difficulty": "medium", "tracks": [ "Dictionary Matching" ], "tags": [ "One-Change", "String-Lookup", "Collision-Safe" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Canonical one-edit string membership problem; hashing is a standard solution." }, { "slug": "strings/hashing", "topic": "Strings -> Hashing", "title": "rolling_hash", "url": "https://judge.yosupo.jp/problem/rolling_hash", "source": "Library Checker", "difficulty": "medium", "tracks": [ "Rolling Hash" ], "tags": [ "Substring Comparison" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Purpose-built official hashing benchmark; very close to the core technique." }, { "slug": "strings/hashing", "topic": "Strings -> Hashing", "title": "Palindrome Queries", "url": "https://cses.fi/problemset/task/2420", "source": "CSES", "difficulty": "hard", "tracks": [ "Rolling Hash", "Dynamic Queries" ], "tags": [ "Palindrome", "Range Queries", "Substring-Equality", "Updates" ], "styles": [ "Data-Structure-Heavy", "Offline/Online Hybrid" ], "prerequisites": [ "Prefix Hashes", "Modular Arithmetic", "Segment Trees" ], "bucket": "core", "why_fit": "Classic rolling-hash use case for fast substring equality under updates." }, { "slug": "strings/hashing", "topic": "Strings -> Hashing", "title": "\"a\" String Problem", "url": "https://codeforces.com/problemset/problem/1984/D", "source": "Codeforces", "difficulty": "hard", "tracks": [], "tags": [ "Suffix Structures" ], "styles": [ "Query Processing", "Invariant Maintenance" ], "prerequisites": [ "Rolling Hash", "Suffix Structures", "Substring Comparison" ], "bucket": "challenge", "why_fit": "A modern hard string problem where hashing is one of the intended tools." }, { "slug": "strings/hashing", "topic": "Strings -> Hashing", "title": "String Set Queries", "url": "https://codeforces.com/problemset/problem/710/F", "source": "Codeforces", "difficulty": "hard", "tracks": [], "tags": [ "Online Queries", "String Sets" ], "styles": [ "Online", "Dynamic Data Structures" ], "prerequisites": [ "Rolling Hash", "Online Processing", "Prefix Sums" ], "bucket": "challenge", "why_fit": "Strong fit for hash-based substring matching in a fully online setting." }, { "slug": "strings/kmp", "topic": "Strings -> KMP", "title": "Finding Borders", "url": "https://cses.fi/problemset/task/1732", "source": "CSES", "difficulty": "easy", "tracks": [ "Borders" ], "tags": [ "Prefix-Suffix", "Periods", "Prefix-Function" ], "styles": [ "Proof", "Implementation" ], "prerequisites": [ "Prefix Function" ], "bucket": "core", "why_fit": "Borders are exactly the structural output KMP-style preprocessing exposes." }, { "slug": "strings/kmp", "topic": "Strings -> KMP", "title": "String Functions", "url": "https://cses.fi/problemset/task/2107", "source": "CSES", "difficulty": "easy", "tracks": [ "Z-Function" ], "tags": [ "Prefix-Function", "Z-Array", "Pi-Array" ], "styles": [ "Implementation" ], "prerequisites": [ "Prefix Function", "Basic String Indexing" ], "bucket": "core", "why_fit": "It explicitly asks for the KMP prefix-function output." }, { "slug": "strings/kmp", "topic": "Strings -> KMP", "title": "String Matching", "url": "https://cses.fi/problemset/task/1753", "source": "CSES", "difficulty": "easy", "tracks": [ "Pattern-Matching" ], "tags": [ "Prefix-Function", "Single-Pattern", "Occurrences" ], "styles": [ "Implementation" ], "prerequisites": [ "Prefix Function" ], "bucket": "core", "why_fit": "The most direct single-pattern matching exercise for prefix-function/KMP." }, { "slug": "strings/kmp", "topic": "Strings -> KMP", "title": "Finding Periods", "url": "https://cses.fi/problemset/task/1733", "source": "CSES", "difficulty": "medium", "tracks": [ "Periodicity" ], "tags": [ "Prefix-Function", "Periods", "String-Structure" ], "styles": [ "Implementation", "Pattern Analysis" ], "prerequisites": [ "Prefix Function", "Border Chains" ], "bucket": "core", "why_fit": "A canonical periodicity problem built on prefix-function reasoning." }, { "slug": "strings/kmp", "topic": "Strings -> KMP", "title": "Required Substring", "url": "https://cses.fi/problemset/task/1112", "source": "CSES", "difficulty": "medium", "tracks": [ "Automaton-DP" ], "tags": [ "DP", "Forbidden-States", "Substring-Automaton" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Uses the KMP automaton as the backbone of a counting DP." }, { "slug": "strings/palindromes", "topic": "Strings -> Palindromes / Manacher", "title": "Enumerate Palindromes", "url": "https://judge.yosupo.jp/problem/enumerate_palindromes", "source": "Library Checker", "difficulty": "medium", "tracks": [ "Manacher", "Palindrome Radii" ], "tags": [ "Odd-Even Centers", "Radius Arrays" ], "styles": [ "Implementation", "Verification" ], "prerequisites": [ "Odd/Even Centers" ], "bucket": "core", "why_fit": "Official benchmark that asks for the raw palindrome-radii style output directly." }, { "slug": "strings/palindromes", "topic": "Strings -> Palindromes / Manacher", "title": "Longest Palindrome", "url": "https://cses.fi/problemset/task/1111", "source": "CSES", "difficulty": "medium", "tracks": [ "Manacher" ], "tags": [ "Longest Palindromic Substring", "Odd-Even Centers", "Exact Scan" ], "styles": [ "Implementation", "Static Scan" ], "prerequisites": [ "Odd/Even Centers" ], "bucket": "core", "why_fit": "The cleanest first Manacher task: recover one longest palindromic substring from a static string." }, { "slug": "strings/palindromes", "topic": "Strings -> Palindromes / Manacher", "title": "All Palindromes", "url": "https://cses.fi/problemset/task/3138", "source": "CSES", "difficulty": "hard", "tracks": [ "Manacher", "Palindrome Radii" ], "tags": [ "Per-Position Output", "Static String" ], "styles": [ "Implementation", "Output Transformation" ], "prerequisites": [ "Odd/Even Centers", "Radius-To-Answer Conversion" ], "bucket": "challenge", "why_fit": "Pushes past one longest answer into a full-radius style output problem." }, { "slug": "strings/regex-finite-automata", "topic": "Strings -> Regular Expressions / Finite Automata", "title": "Regex Membership Benchmark", "url": "https://algs4.cs.princeton.edu/54regexp/", "source": "Algorithms 4/e", "difficulty": "medium", "tracks": [ "Regular-Expressions", "Finite-Automata" ], "tags": [ "Thompson Nfa", "Epsilon Closure", "Regex Membership" ], "styles": [ "Automaton Construction", "Simulation" ], "prerequisites": [ "Implicit Concatenation", "Postfix Conversion", "Epsilon Closure" ], "bucket": "core", "why_fit": "Canonical textbook benchmark where the whole lesson is regex-to-postfix, Thompson construction, and active-state-set simulation rather than library regex semantics." }, { "slug": "strings/suffix-array-lcp", "topic": "Strings -> Suffix Array And LCP", "title": "Distinct Substrings", "url": "https://cses.fi/problemset/task/2105", "source": "CSES", "difficulty": "medium", "tracks": [ "Suffix-Array" ], "tags": [ "Distinct Substrings", "Counting", "Suffix-Structure" ], "styles": [ "Counting", "Suffix Processing" ], "prerequisites": [ "LCP Array" ], "bucket": "core", "why_fit": "One of the standard suffix-array + LCP counting problems." }, { "slug": "strings/suffix-array-lcp", "topic": "Strings -> Suffix Array And LCP", "title": "Repeating Substring", "url": "https://cses.fi/problemset/task/2106", "source": "CSES", "difficulty": "medium", "tracks": [ "Suffix-Array" ], "tags": [ "Repetition", "Longest-Repeat", "Binary-Search", "Suffix-Structure" ], "styles": [ "Maximization", "Substring Search" ], "prerequisites": [ "LCP Array" ], "bucket": "core", "why_fit": "Longest repeated substring is a canonical LCP application." }, { "slug": "strings/suffix-array-lcp", "topic": "Strings -> Suffix Array And LCP", "title": "lcp_array", "url": "https://judge.yosupo.jp/problem/lcp_array", "source": "Library Checker", "difficulty": "medium", "tracks": [ "Suffix-Array" ], "tags": [ "Kasai", "Adjacent-Suffixes" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Natural companion to suffix array construction." }, { "slug": "strings/suffix-array-lcp", "topic": "Strings -> Suffix Array And LCP", "title": "longest_common_substring", "url": "https://judge.yosupo.jp/problem/longest_common_substring", "source": "Library Checker", "difficulty": "medium", "tracks": [ "Suffix-Array" ], "tags": [ "Two-Strings", "Common-Substring" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "A very standard SA+LCP application problem." }, { "slug": "strings/suffix-array-lcp", "topic": "Strings -> Suffix Array And LCP", "title": "suffix_array", "url": "https://judge.yosupo.jp/problem/suffix_array", "source": "Library Checker", "difficulty": "medium", "tracks": [ "Suffix-Array", "String-Indexing" ], "tags": [ "Lexicographic-Order", "Core" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Direct suffix-array construction benchmark from the official judge." }, { "slug": "strings/suffix-array-lcp", "topic": "Strings -> Suffix Array And LCP", "title": "Inverse Suffix Array", "url": "https://cses.fi/problemset/task/3225", "source": "CSES", "difficulty": "hard", "tracks": [], "tags": [ "Suffix Array", "Construction", "Inverse Problems" ], "styles": [ "Construction", "Consistency Checking" ], "prerequisites": [ "Suffix Array Semantics" ], "bucket": "challenge", "why_fit": "A reverse-engineering task that deepens suffix-array understanding." }, { "slug": "strings/suffix-array-lcp", "topic": "Strings -> Suffix Array And LCP", "title": "String Transform", "url": "https://cses.fi/problemset/task/1113", "source": "CSES", "difficulty": "hard", "tracks": [], "tags": [ "Suffix Array", "Burrows-Wheeler Transform", "Reconstruction" ], "styles": [ "Construction", "Inverse Transform" ], "prerequisites": [ "Suffix Array", "Sorted Rotations" ], "bucket": "challenge", "why_fit": "This is a direct BWT-style inverse transform problem." }, { "slug": "strings/suffix-array-lcp", "topic": "Strings -> Suffix Array And LCP", "title": "Substring Order I", "url": "https://cses.fi/problemset/task/2108", "source": "CSES", "difficulty": "hard", "tracks": [ "Suffix-Array", "Lexicographic-Order" ], "tags": [ "Order Statistics", "Kth-Substring", "Ranking" ], "styles": [ "K-Th Selection", "Suffix Processing" ], "prerequisites": [ "LCP Array" ], "bucket": "challenge", "why_fit": "Selecting the k-th substring is a strong suffix-array/LCP exercise." }, { "slug": "strings/suffix-array-lcp", "topic": "Strings -> Suffix Array And LCP", "title": "Substring Order II", "url": "https://cses.fi/problemset/task/2109", "source": "CSES", "difficulty": "hard", "tracks": [], "tags": [ "Suffix Array", "Order Statistics" ], "styles": [ "K-Th Selection", "Suffix Processing" ], "prerequisites": [ "Suffix Array", "LCP Array" ], "bucket": "challenge", "why_fit": "Same core machinery as Substring Order I, but on all substrings." }, { "slug": "strings/suffix-automaton", "topic": "Strings -> Suffix Automaton", "title": "Distinct Substrings", "url": "https://cses.fi/problemset/task/2105", "source": "CSES", "difficulty": "medium", "tracks": [ "Counting" ], "tags": [ "Substrings", "States", "Endpos" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Distinct-substring counting is one of SAM’s core uses." }, { "slug": "strings/suffix-automaton", "topic": "Strings -> Suffix Automaton", "title": "Good Substrings", "url": "https://codeforces.com/problemset/problem/271/D", "source": "Codeforces", "difficulty": "medium", "tracks": [], "tags": [ "Distinct Substrings", "Trie" ], "styles": [ "Enumeration", "Deduplication" ], "prerequisites": [ "Suffix Automaton", "Distinct Substring Counting" ], "bucket": "core", "why_fit": "Not only hash/trie territory; suffix automaton also fits naturally." }, { "slug": "strings/suffix-automaton", "topic": "Strings -> Suffix Automaton", "title": "Repeating Substring", "url": "https://cses.fi/problemset/task/2106", "source": "CSES", "difficulty": "medium", "tracks": [ "Longest-Repeat" ], "tags": [ "Repeat", "Substring", "Suffix-Structure" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Another canonical SAM application with strong overlap." }, { "slug": "strings/suffix-automaton", "topic": "Strings -> Suffix Automaton", "title": "suffix_automaton", "url": "https://judge.yosupo.jp/problem/suffix_automaton", "source": "Library Checker", "difficulty": "medium", "tracks": [ "String-Indexing" ], "tags": [ "States", "Transitions" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Direct official SAM construction benchmark." }, { "slug": "strings/suffix-automaton", "topic": "Strings -> Suffix Automaton", "title": "Substring Order I", "url": "https://cses.fi/problemset/task/2108", "source": "CSES", "difficulty": "hard", "tracks": [ "Kth-Substring" ], "tags": [ "Ranking", "Distinct-Substrings", "Advanced" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "K-th substring ranking is a strong suffix-structure benchmark." }, { "slug": "strings/suffix-automaton", "topic": "Strings -> Suffix Automaton", "title": "A Trivial String Problem", "url": "https://codeforces.com/problemset/problem/2209/E", "source": "Codeforces", "difficulty": "hard", "tracks": [], "tags": [ "Hashing" ], "styles": [ "Query Processing", "Hybrid Techniques" ], "prerequisites": [ "Suffix Automaton", "Hashing" ], "bucket": "challenge", "why_fit": "Modern hard string problem where suffix structures are a key ingredient." }, { "slug": "strings/suffix-automaton", "topic": "Strings -> Suffix Automaton", "title": "Cyclical Quest", "url": "https://codeforces.com/problemset/problem/235/C", "source": "Codeforces", "difficulty": "hard", "tracks": [], "tags": [ "Cyclic Strings", "Counting" ], "styles": [ "String Compression", "Counting" ], "prerequisites": [ "Suffix Automaton", "String Rotation Intuition" ], "bucket": "challenge", "why_fit": "A standard suffix automaton problem for counting cyclic matches." }, { "slug": "strings/suffix-automaton", "topic": "Strings -> Suffix Automaton", "title": "Martian Strings", "url": "https://codeforces.com/problemset/problem/149/E", "source": "Codeforces", "difficulty": "hard", "tracks": [], "tags": [ "Substring Queries", "Pattern Matching" ], "styles": [ "Multi-Pattern Checking" ], "prerequisites": [ "Suffix Automaton", "Substring Occurrence" ], "bucket": "challenge", "why_fit": "A classic suffix-structure problem with a strong automaton solution." }, { "slug": "strings/suffix-tree", "topic": "Strings -> Suffix Tree", "title": "Pattern Positions", "url": "https://cses.fi/problemset/task/2104", "source": "CSES", "difficulty": "hard", "tracks": [ "Substring-Index" ], "tags": [ "Earliest Occurrence", "Pattern Matching" ], "styles": [ "Many Queries", "Suffix Processing" ], "prerequisites": [ "Compressed Edges", "Suffix Leaves", "Subtree Minimum" ], "bucket": "core", "why_fit": "The cleanest first verifier for one static text used as a compressed substring index with earliest-occurrence metadata." }, { "slug": "strings/suffix-tree", "topic": "Strings -> Suffix Tree", "title": "Distinct Substrings", "url": "https://cses.fi/problemset/task/2105", "source": "CSES", "difficulty": "medium", "tracks": [], "tags": [ "Distinct Substrings", "Compressed Edges" ], "styles": [ "Counting", "Suffix Processing" ], "prerequisites": [ "Compressed Edges", "Unique Terminator" ], "bucket": "stretch", "why_fit": "A good compare-point problem once the tree is trusted and you want the usable-edge-length counting view." }, { "slug": "strings/trie", "topic": "Strings -> Trie", "title": "Watto and Mechanism", "url": "https://codeforces.com/problemset/problem/514/C", "source": "Codeforces", "difficulty": "medium", "tracks": [ "Hashing" ], "tags": [ "Approximate Matching", "One-Edit", "Dictionary", "Lookup" ], "styles": [ "Implementation", "Branching Search" ], "prerequisites": [ "Trie Basics", "Edit-Distance-1 Checking" ], "bucket": "core", "why_fit": "A very common trie exercise with one-character-mismatch queries." }, { "slug": "strings/trie", "topic": "Strings -> Trie", "title": "Word Combinations", "url": "https://cses.fi/problemset/task/1731", "source": "CSES", "difficulty": "medium", "tracks": [ "DP" ], "tags": [ "Dictionary Matching", "Dictionary", "Prefixes", "Counting" ], "styles": [ "Dynamic Programming", "Data-Structure-Heavy" ], "prerequisites": [ "Trie Basics", "DP On Prefixes" ], "bucket": "core", "why_fit": "A classic trie-plus-DP word segmentation problem." }, { "slug": "strings/trie", "topic": "Strings -> Trie", "title": "trie", "url": "https://judge.yosupo.jp/problem/trie", "source": "Library Checker", "difficulty": "medium", "tracks": [ "Data-Structure" ], "tags": [ "Insert", "Lookup" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Pure trie implementation benchmark with the cleanest possible scope." }, { "slug": "strings/trie", "topic": "Strings -> Trie", "title": "A Lot of Games", "url": "https://codeforces.com/problemset/problem/455/B", "source": "Codeforces", "difficulty": "hard", "tracks": [ "Game-Theory" ], "tags": [ "Games", "Winning-States", "Game-DP", "Prefix-Tree" ], "styles": [ "Game-State Analysis" ], "prerequisites": [ "Trie", "Winning/Losing States" ], "bucket": "challenge", "why_fit": "Trie structure is the whole game board here." }, { "slug": "strings/z-function", "topic": "Strings -> Z-Function", "title": "String Functions", "url": "https://cses.fi/problemset/task/2107", "source": "CSES", "difficulty": "easy", "tracks": [ "Prefix-Function" ], "tags": [ "String Processing", "Z-Array", "Pi-Array", "Fundamentals" ], "styles": [ "Implementation" ], "prerequisites": [ "Z-Function Definition" ], "bucket": "core", "why_fit": "This task directly computes the z-array, so it is the cleanest Z-function drill." }, { "slug": "strings/z-function", "topic": "Strings -> Z-Function", "title": "String Matching", "url": "https://cses.fi/problemset/task/1753", "source": "CSES", "difficulty": "easy", "tracks": [ "Pattern-Matching" ], "tags": [ "Linear-Time String Algorithms", "Single-Pattern", "Occurrences", "Linear-Time" ], "styles": [ "Implementation" ], "prerequisites": [ "Z-Function" ], "bucket": "core", "why_fit": "Single-pattern matching is a textbook Z-function application." }, { "slug": "strings/z-function", "topic": "Strings -> Z-Function", "title": "Finding Periods", "url": "https://cses.fi/problemset/task/1733", "source": "CSES", "difficulty": "medium", "tracks": [ "Periodicity" ], "tags": [ "Borders", "Periods", "Prefix-Structure", "String-Analysis" ], "styles": [ "Proof", "Implementation" ], "prerequisites": [ "Z-Function", "Prefix-Suffix Structure" ], "bucket": "core", "why_fit": "Periods can be extracted naturally from prefix comparisons that Z handles well." }, { "slug": "strings/z-function", "topic": "Strings -> Z-Function", "title": "Password", "url": "https://codeforces.com/problemset/problem/126/B", "source": "Codeforces", "difficulty": "medium", "tracks": [ "Borders" ], "tags": [ "Prefix-Suffix", "Longest-Border", "Classic" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "A textbook border problem where Z is a natural route." }, { "slug": "strings/z-function", "topic": "Strings -> Z-Function", "title": "Prefixes and Suffixes", "url": "https://codeforces.com/problemset/problem/432/D", "source": "Codeforces", "difficulty": "medium", "tracks": [ "Border-Enumeration" ], "tags": [ "Prefixes", "Suffixes", "Counts" ], "styles": [], "prerequisites": [], "bucket": "core", "why_fit": "Canonical Z-function task for collecting all prefix-suffix matches." } ]