When students prepare for the CCC, they often ask: "Which algorithms do I need to know?" The useful answer is not a giant list of DSA names. The useful answer is a roadmap of patterns: simulation, strings, arrays, grids, counting, prefix sums, graph search, greedy, DSU, shortest paths, and dynamic programming.

This article organizes the common CCC data structures and algorithms from Junior to Senior. It is designed as a study map for students and as a parent-friendly overview of how contest programming grows from careful implementation into algorithmic modeling.

Where This Fits in the CCC DSA Map

• Level: Junior to Senior roadmap
• Pattern: DSA planning, pattern recognition, contest preparation
• Prerequisite: Python/C++ basics, arrays/lists, loops, strings, functions, debugging
• What this teaches: Organize CCC problems into a reusable study path instead of treating each problem as isolated.
• Where it appears again: CP Weekly solutions, Python/C++ Notes, CCC contest review plans

What to Study Next

• Related CP Weekly problems: CCC 2026 J4 Snail Path, CCC 2024 J5 Harvest Waterloo, CCC 2020 J5/S2 Escape Room, CCC 2017 S1 Sum Game
• Related Python / C++ foundations: loops, strings, lists/vectors, dictionaries/maps, sets, 2D arrays, functions, debugging
• Related DSA roadmap articles: CCC Grid Problems, CCC Counting Patterns, CCC Prefix and Sliding Window Patterns, CCC Senior Graph Toolkit, CCC Dynamic Programming Roadmap

How to Read This Roadmap

CCC preparation has three layers:

The key is to ask:

1. What complexity does the input size allow?
2. What structure is the problem really about?
3. What state should I store so I do not repeat work?

Foundation: Implementation Before Fancy Algorithms

Junior problems train careful implementation. This stage includes conditionals, loops, accumulation, simulation, and edge cases.

Many later mistakes come from this layer: wrong update order, missing boundary cases, or misunderstood input.

Strings and Parsing

CCC often uses strings as lightweight data structures. Students need to scan, slice, count, compare, and parse.

The goal is to extract structure from text before writing loops.

Arrays, Lists, and Grids

Once the problem has days, positions, scores, or cells, students need arrays and grids.

Grid problems are a major bridge from Junior to Senior because a grid can become a graph.

Counting: Frequency, Sets, and Parity

Counting is often the first moment when students see the value of a data structure.

Modern Art is the classic example: the full grid is unnecessary if we track row and column parity.

Prefix Sum and Sliding Window

Prefix thinking appears when a problem involves repeated ranges, consecutive segments, or cumulative state.

Sunny Days is a good transition problem: it can be explained with prefix/suffix streaks or as a sliding window with one correction.

Sorting and Greedy

Greedy problems are not just "do the obvious thing." Students must learn why a local choice is safe.

Gates also leads naturally to DSU because repeatedly searching for an available gate is too slow.

Graph Search

Graph problems often come from grids, pages, relationships, or state transitions.

Escape Room is a strong bridge problem: the graph is not given directly, but the rule creates edges.

Binary Search on Answer

Some Senior problems ask for an optimal value that is hard to compute directly but easy to test.

The key question is:

Can we do it with answer = X?

If feasibility is monotonic, binary search becomes available.

DSU and MST

Disjoint Set Union maintains connected components under merges.

Think of DSU when the problem repeatedly merges things or asks whether two items are already connected.

Weighted Shortest Paths and State Graphs

When edges have different costs, plain BFS is not enough.

The key modeling question is: does position alone describe the state, or do we need extra information such as damage, mode, or remaining resource?

Dynamic Programming

Dynamic programming is about state, transition, and order.

Connecting Territories is a good first DP example because each row only depends on the previous row.

Constructive Search and Constraint Propagation

Some Senior problems require analyzing constraints before writing code.

These problems reward thinking before coding. The first step is often to reduce the search space.

Recommended Study Order

1. Simulation and edge cases
2. Strings and parsing
3. Arrays, lists, and grids
4. Frequency counting, sets, parity
5. Prefix sums and sliding window
6. Sorting and greedy reasoning
7. DFS/BFS, flood fill, graph representation
8. Binary search on answer
9. DSU and MST
10. Dijkstra and state graphs
11. Dynamic programming
12. Constructive search and constraint propagation

For each topic, pair one explanation with two to four historical problems. Then review mistakes by type: reading error, edge case, state definition, implementation bug, or complexity mismatch.

Common Mistakes

1. Practicing only by year instead of by DSA pattern.
2. Reading solutions without rewriting the code.
3. Knowing BFS but failing to recognize graph models.
4. Learning DP as a template instead of defining state and transition.
5. Ignoring constraints and choosing the wrong complexity.
6. Treating all wrong answers the same instead of classifying the error.

Review Questions

1. What DSA patterns appear most often in Junior J4/J5?
2. Why can many grid problems become graph search problems?
3. What is the difference between prefix sum and sliding window?
4. When should DSU come to mind?
5. What are the three core questions in dynamic programming?
6. If N = 500000, which algorithmic approaches should you rule out first?