AACPOJ Note Writing Guide

Quick Index

If you want to look up syntax, start with "Markdown Basic Syntax Quick Reference" or jump directly to "LaTeX Math Quick Reference". If you are joining the C++ syntax camp for the first time, start with the shorter beginner guide: C++ Syntax Camp Note Guide (Traditional Chinese).

• Why Write Problem Notes?
• How to Use AACPOJ Notes
• What Should a Note Record?
  • Problem Summary (Abstract)
  • Key Observations / Properties
  • Thought Process
  • Mistakes / Common Pitfalls
  • Similar Problems / Extensions
  • Complexity and Tags
• Markdown Basic Syntax Quick Reference
  • Heading Levels
  • Bold, Italic, Strikethrough
  • Lists
  • Checklist
  • Code
  • Quote Blocks
  • Tables
  • Links
  • Horizontal Rules
• LaTeX Math Quick Reference
  • Inline Math and Display Math
  • LaTeX Symbol Table
  • DP / Recurrences / Cases
  • Aligned Derivations
  • Common LaTeX Mistakes
• Sharing, Layout, and Preview
  • Visibility
  • Layout Style
  • Preview
• Example of a Good Note
• Summary

Why Write Problem Notes?

The main purpose of competitive programming notes is to help your future self rebuild the solution idea quickly. If a note only says "DP" or "use a segment tree", it will not help much months later. A useful note records the reasoning chain, key observations, and mistakes you already made.

A good note is more than a copied solution. It is a record of how you learned the problem: where you got stuck, what changed your approach, why the first idea failed, and what pattern you can reuse next time.

How to Use AACPOJ Notes

AACPOJ notes support Markdown + LaTeX math. These are the basic rules to use when writing a new note:

• Inline math uses $...$; display math uses $$...$$.
• ~~...~~ is strikethrough. Use it only when you want crossed-out text.
• Checklists support - [ ] and - [x].
• Prefer normal Markdown. Raw HTML may be filtered for security.
• Note visibility can be private, class-only, or public. A good workflow is to start private, then share after cleanup.
• Notes have layout styles: plain, paper, and Kindle. The plain style is best for announcements, guides, and short references.

What Should a Note Record?

You do not need every item for every problem. Pick the parts that will help your future self the most.

Problem Summary (Abstract)

Use one or two sentences to describe the mathematical core of the problem. Remove the story.

• Less useful: "Someone wants to send gifts to friends..."
• Better: "Given an array \(a\), find the minimum \(k\) such that \(\sum a_i \le k\)."

This makes the note easy to scan later.

Key Observations / Properties

This is usually the most valuable part of the note. Write down the property that made the problem solvable:

• The answer is monotonic, so binary search applies.
• After \(k\) operations, only the first \(\log n\) positions can change.
• The problem can be modeled as a graph: vertices are states, edges are transitions.
• For a fixed right endpoint \(r\), the best left endpoint \(l\) can be maintained with two pointers.

Thought Process

The path from a simple idea to the accepted solution is often more useful than the final answer alone.

• First idea: \(O(n^2)\) brute force, enumerate all previous positions.
• Improvement 1: Notice repeated computation and use prefix sums, reducing it to \(O(n)\).
• Improvement 2: Notice monotonicity and use a monotonic queue for a cleaner implementation.

Mistakes / Common Pitfalls

Write down the bugs you actually hit:

• Forgot to use long long.
• Binary search condition was reversed.
• Used 0-indexing and 1-indexing in the same formula.
• Forgot to clear arrays between test cases.
• DP initialization missed impossible states.

These records are especially useful because they are your own weak spots.

Similar Problems / Extensions

If the problem reminds you of another problem, record the link or problem code. After solving several related problems, you will start seeing patterns.

Complexity and Tags

Write time and memory complexity, plus a few tags:

Time: $O(n \log n)$
Memory: $O(n)$
Tags: `#binary-search` `#greedy` `#prefix-sum`

Markdown Basic Syntax Quick Reference

Heading Levels

Use #, ##, and ### to create sections. In most notes, ## and ### are enough.

## Idea

### Key Observation

### Implementation Details

Do not use headings just to make text larger. Headings should describe structure.

Bold, Italic, Strikethrough

**important**
*emphasis*
~~wrong idea~~

Rendered:

important
emphasis
wrong idea

Lists

- Step 1: read input
- Step 2: sort
- Step 3: sweep once

1. Brute force
2. Optimize
3. Prove correctness

Use unordered lists for reminders and ordered lists for sequences.

Checklist

- [x] Use `long long`
- [x] Check boundary cases
- [ ] Rewrite proof

A checklist is good for bugs, TODOs, and things to verify before submitting.

Code

Inline code uses backticks:

Use `vector<int>` to store the array.

Code blocks use triple backticks. Add the language name for highlighting:

```cpp
long long ans = 0;
for (int i = 0; i < n; i++) {
    ans += a[i];
}
```

Rendered:

long long ans = 0;
for (int i = 0; i < n; i++) {
    ans += a[i];
}

Quote Blocks

> Key observation: when $n$ is even, a solution must exist.

Rendered:

Key observation: when \(n\) is even, a solution must exist.

Tables

Tables are useful for comparing approaches, listing complexities, or matching constraints with methods:

| Method | Time | Memory | Note |
|---|---|---|---|
| Brute force | $O(n^2)$ | $O(n)$ | Works for $n \le 5000$ |
| Segment tree | $O(n \log n)$ | $O(n)$ | Accepted solution |

AACPOJ also supports column alignment:

| Default | Left | Center | Right |
|---|:---|:---:|---:|
| normal | left | center | right |
| $O(n)$ | $a_i$ | $x \in S$ | $10^9+7$ |

Rendered:

The rule is simple: :--- means left-aligned, :---: means centered, and ---: means right-aligned. If a table becomes too wide or dense, use headings or lists instead.

Links

[Problem link](https://example.com)
[Jump to LaTeX section](#latex-math-quick-reference)

Use descriptive link text. Avoid writing only "click here".

Horizontal Rules

---

Use horizontal rules to separate large sections. Do not add one after every small paragraph.

LaTeX Math Quick Reference

This is the main lookup section. To find a symbol, start with "LaTeX Symbol Table". For multi-line formulas, see the DP, cases, and aligned derivation examples later.

Inline Math and Display Math

Inline math goes inside a sentence with $...$:

When $n \le 10^5$, an $O(n \log n)$ solution can pass.

Rendered:

When \(n \le 10^5\), an \(O(n \log n)\) solution can pass.

Display math uses $$...$$ as its own block. Leave a blank line before and after it:

For every $i$,

$$
\sum_{j=1}^{i} a_j \ge \lfloor \log_2 i \rfloor
$$

this inequality always holds.

Rendered:

For every \(i\),

this inequality always holds.

If you only want to show the raw LaTeX source in a guide, put it in a code block or backticks, for example `$O(n \log n)$`.

LaTeX Symbol Table

Common competitive programming symbols are grouped here. Copy from the source column and check the rendered result on the right.

Category shortcuts: Variables / Brackets, Comparison / Logic / Quantifiers, Operations / Rounding / Complexity, Sums / Ranges, Graph / Sets / Combinatorics, Greek Letters.

Variables / Brackets

Comparison / Logic / Quantifiers

Operations / Rounding / Complexity

Sums / Ranges

Graph / Sets / Combinatorics

Greek Letters

DP / Recurrences / Cases

DP transitions are easier to read as display math:

$$
dp_i = \min_{0 \le j < i} (dp_j + cost(j+1, i))
$$

Rendered:

Use cases for piecewise definitions:

$$
dp_i =
\begin{cases}
0, & i = 0 \\
dp_{i-1} + a_i, & i > 0
\end{cases}
$$

Rendered:

Aligned Derivations

Use aligned for multi-line derivations:

$$
\begin{aligned}
\sum_{i=1}^{n} i
&= 1 + 2 + \cdots + n \\
&= \frac{n(n+1)}{2}
\end{aligned}
$$

Rendered:

& marks the alignment point, usually before the equals sign. Use \\ for a line break.

Common LaTeX Mistakes

• Missing the closing $: $O(n log n) may turn the following text into math.
• Writing _ outside math: use $a_i$, not plain a_i.
• Writing Chinese or long English sentences inside math: keep text outside and put only variables/symbols in math.
• Visible braces need escaping: write $\{1,2,3\}$, not ${1,2,3}$.
• Prefer $\lvert x \rvert$ for absolute value; it is less confusing around tables than $|x|$.
• Display math should have blank lines before and after it.
• If a formula is too long, use $$...$$ instead of squeezing it inline.
• If you only want to show source code, put it in a code block.

Sharing, Layout, and Preview

Visibility

AACPOJ notes can be private, class-only, or public:

• Private: best for drafts and personal review.
• Class-only: useful for discussion with classmates or teachers.
• Public: use this after the note is cleaned up and useful to others.

Layout Style

For most problem notes, use the plain style. It is clean and good for reading code, formulas, and tables. Paper and Kindle styles only change the reading experience; they do not change the Markdown source.

Preview

The editor has edit, split, and preview modes. Before saving, check the preview at least once:

• TOC links jump to the correct section.
• Math formulas render correctly.
• Code blocks have the right language and highlighting.
• Tables align correctly.
• Checklists become checkboxes.
• Heading levels are not confusing.
• Links open correctly.

Example of a Good Note

This is a useful skeleton. Start with it, then remove sections that do not matter for the problem.

## Problem Summary

Given an array of length $n$, minimize ...

## Constraints

- $1 \le n \le 2 \times 10^5$
- $1 \le a_i \le 10^9$

## Key Observations

1. The answer is monotonic in $k$, so binary search applies.
2. For a fixed $k$, feasibility can be checked in one linear scan.

## Thought Process

- **Brute force**: enumerate every $k$, $O(n^2)$, TLE.
- **Optimization**: binary search + linear check, becoming $O(n \log n)$.

## Implementation Details

- Binary search range: `[1, max(a)]`
- `valid(k)` function: ...

## Mistakes

- [x] Used `l = mid` in binary search and caused TLE.
- [x] Forgot `long long`, causing overflow while summing.
- [ ] Before rewriting, check the monotonic direction of `valid(k)`.

## Complexity

- Time: $O(n \log V)$
- Memory: $O(n)$

## Core Code

```cpp
bool valid(long long k) {
    // ...
}

int main() {
    long long lo = 1, hi = 1000000000LL;
    while (lo < hi) {
        long long mid = (lo + hi) / 2;
        if (valid(mid)) hi = mid;
        else lo = mid + 1;
    }
    cout << lo << '\n';
}
```

## Similar Problems

- CF 1234A (same binary-search pattern)
- ABC 321D (extension: add DP)

Tags: `#binary-search` `#greedy`

Summary

The first rule of note writing is: write for your future self.

Recording key observations, thought process, and mistakes is more valuable than copying a finished solution. With Markdown headings, lists, checklists, code blocks, tables, and LaTeX formulas, you can build notes that still help you understand the problem when you come back later.