sequenzia/solve

Competitive Programming Problem Solver

Solve competitive programming and LeetCode-style problems with clear educational explanations, step-by-step walkthroughs, and verified Python solutions.

CRITICAL: Complete ALL 4 phases. Do not stop after classification or skip the agent.

Phase 1: Parse Input

Goal: Extract and understand the problem statement.

If $ARGUMENTS is provided, parse the problem statement from it. Extract:

• Problem description and objective
• Input/output format
• Constraints (N, M, value ranges)
• Example test cases with expected outputs
• Any special conditions (modular arithmetic, multiple test cases, interactive)

If $ARGUMENTS is empty or unclear, use AskUserQuestion to request the problem:

AskUserQuestion:
  question: "Please provide the problem statement. You can paste the full text, describe it in your own words, or provide a link."
  options:
    - label: "Paste problem text"
      description: "Paste the full problem statement including constraints and examples"
    - label: "Describe the problem"
      description: "Describe what the problem asks in your own words"

If the problem statement is ambiguous or missing key information (constraints, examples), ask for clarification before proceeding.

Phase 2: Classify Problem

Goal: Determine the algorithmic category, technique, and difficulty.

Analyze the problem to determine:

2.1 Primary Category

Match to one of:

• Dynamic Programming — optimization over subsequences, counting ways, overlapping subproblems
• Graph Algorithms — connectivity, shortest paths, traversal, network problems
• Search and Optimization — binary search, two pointers, greedy, interval problems
• Data Structures — specialized structures needed (heap, trie, segment tree)
• Math and Combinatorics — number theory, counting, modular arithmetic, game theory
• String Algorithms — pattern matching, palindromes, hashing

2.2 Sub-pattern

Identify the specific technique within the category (e.g., "0/1 Knapsack", "Dijkstra", "Sliding Window").

2.3 Difficulty Estimate

• Easy — single technique, straightforward application
• Medium — requires insight or combining 2 techniques
• Hard — non-obvious technique, complex implementation, or 3+ techniques
• Competition — advanced techniques, mathematical reasoning, or creative construction

2.4 Constraint Analysis

Map input size to required time complexity:

| Input Size | Viable Complexity | Typical Approach | |-----------|------------------|-----------------| | N ≤ 15 | O(2^N), O(N!) | Bitmask DP, backtracking | | N ≤ 20 | O(2^N × N) | Bitmask DP | | N ≤ 100 | O(N^3) | Floyd-Warshall, interval DP | | N ≤ 500 | O(N^3) | Matrix DP, dense graph algorithms | | N ≤ 3,000 | O(N^2) | Standard DP (LCS, edit distance) | | N ≤ 10,000 | O(N^2) or O(N√N) | Careful O(N^2), sqrt decomposition | | N ≤ 100,000 | O(N log N) | Sorting, binary search, segment tree | | N ≤ 1,000,000 | O(N) or O(N log N) | Linear scan, prefix sums, two pointers | | N ≤ 10^8 | O(N) | Simple linear pass | | N ≤ 10^9+ | O(log N) or O(√N) | Binary search, math formula |

2.5 Secondary Categories

Note if the problem combines techniques (e.g., "Binary Search + DP", "Graph + Greedy").

Present the classification summary to the user before proceeding.

Phase 3: Load References and Spawn Agent

Goal: Provide the solver agent with domain-specific algorithmic knowledge.

3.1 Load Reference Skills

Based on the primary category, load the corresponding reference skill:

• Dynamic Programming → Read ${CLAUDE_PLUGIN_ROOT}/skills/dp-patterns/SKILL.md
• Graph Algorithms → Read ${CLAUDE_PLUGIN_ROOT}/skills/graph-algorithms/SKILL.md
• Search and Optimization → Read ${CLAUDE_PLUGIN_ROOT}/skills/search-and-optimization/SKILL.md
• Data Structures → Read ${CLAUDE_PLUGIN_ROOT}/skills/data-structures/SKILL.md
• Math and Combinatorics → Read ${CLAUDE_PLUGIN_ROOT}/skills/math-and-combinatorics/SKILL.md
• String Algorithms → Read ${CLAUDE_PLUGIN_ROOT}/skills/string-algorithms/SKILL.md

If a secondary category was identified, load that reference skill as well (maximum 2 reference skills).

3.2 Spawn Problem Solver Agent

Use the Task tool to spawn the problem-solver agent:

Task:
  subagent_type: "agent-alchemy-cs-tools:problem-solver"
  prompt: |
    ## Problem Statement
    [full problem text with all constraints, I/O format, and examples]

    ## Classification
    - **Category:** [primary category]
    - **Sub-pattern:** [specific technique]
    - **Difficulty:** [level]
    - **Complexity Target:** [required time complexity based on constraints]
    - **Secondary Category:** [if applicable]

    ## Reference Material
    [paste the content from the loaded reference skill(s)]

    Produce a complete solution following your structured output format.

Phase 4: Present Solution

Goal: Format and present the solution with follow-up options.

Take the agent's structured output and present it to the user. The output includes:

• Classification summary
• Key insight (the "aha" moment)
• Step-by-step approach
• Verified Python solution code
• Time and space complexity analysis with derivation
• Walkthrough tracing through an example
• Edge cases
• Common mistakes
• Alternative approaches

After presenting the solution, offer follow-up actions:

AskUserQuestion:
  question: "What would you like to do next?"
  options:
    - label: "Verify with test cases"
      description: "Run the solution through comprehensive test cases including edge cases and stress tests"
    - label: "Explain in more detail"
      description: "Get a deeper explanation of the approach, technique, or a specific part of the solution"
    - label: "Show alternative approach"
      description: "See a different way to solve this problem with trade-off analysis"
    - label: "Done"
      description: "Solution is satisfactory, no further action needed"

If the user selects "Verify with test cases", suggest they use /verify with the problem and solution. If "Explain in more detail", provide additional explanation of the requested aspect. If "Show alternative approach", re-spawn the agent with instructions to use a different technique.