Upsolving & Pattern Recognition

Upsolving & Pattern Recognition | Algoryva

Worked by hand

A contest log

Suppose a contest had six problems. You solved A and E live, and upsolved B, C and F afterwards. D is still unsolved. The log records each problem with its topic and status.

Two things stand out. Both DP problems (D and F) have caused trouble, so DP is where to focus. And the live score (2 solved) is lower than the score you would have after upsolving (5 out of 6, with D still open).

Problem	Topic	Status	Signal to remember
A	prefix sum	solved live	many range-sum queries
B	two pointers	upsolved	sorted array and a target pair
C	binary search	upsolved	smallest value that works, monotone
D	DP	unsolved	still open: choose or skip under a small state
E	BFS	solved live	fewest moves on a grid
F	DP	upsolved	choose or skip, best future from a small state

Implementation

Analysing the log and scheduling reviews

The plan: count which topics are not yet solved live, and compute review dates that double the gap each time. Both use only the standard library, so the analysis is repeatable.

Plan in plain steps

pseudocode

count the topics not solved live; the most common one is where to practise
reviews: day 1, then +2, +4, +8 (each gap doubles)

python

from collections import Counter

log = [
    ("A", "prefix sum", "solved"),
    ("B", "two pointers", "upsolved"),
    ("C", "binary search", "upsolved"),
    ("D", "DP", "unsolved"),
    ("E", "BFS", "solved"),
    ("F", "DP", "upsolved"),
]

print(sum(1 for _, _, s in log if s == "solved"))   # 2
print(sum(1 for _, _, s in log if s == "unsolved"))   # 1
print(Counter(topic for _, topic, s in log if s != "solved").most_common(1))   # [('DP', 2)]

def review_days(first=1, times=4):
    day, gap, out = 0, first, []
    for _ in range(times):
        day += gap
        out.append(day)
        gap *= 2
    return out

print(review_days())   # [1, 3, 7, 15]

Reading the code

›The first three prints summarise the log: how many were solved live, how many are open, and which topic has the most problems that were not solved live. DP appears twice, so it leads.
›review_days doubles the gap each time. Starting from day 0, the reviews fall on days 1, 3, 7 and 15, so each review comes after a longer rest than the one before.
›Counter comes from the standard library and counts strings. It is the simplest way to see where the weak topics cluster.

Worked problem

Worked problem: turning one upsolve into a rule

The problem

After upsolving a problem that asked for the number of ways to pick two positions in a sorted array summing to a target, you want a rule you can apply next time. Write it.

Name the technique: two pointers on a sorted array, moving the ends towards the middle.
State the signal: a sorted sequence and a target sum to find a pair of positions.
Record the mistake that caused the trouble: forgetting to move the correct pointer when the sum was too small or too large.

python

signal = "sorted array, find a pair with a target sum"
technique = "two pointers: move the left end up if the sum is too small, the right end down if too large"
mistake = "moved the wrong pointer, so the search skipped a valid pair"
print(technique)   # two pointers: move the left end up if the sum is too small, the right end down if too large

Takeaway. A good log entry has three parts: the technique, the signal that suggests it, and the mistake to avoid. Together they turn one problem into a rule you can apply.

Wrap-up

Remember this

Upsolving turns contest mistakes into reusable patterns, which is where most of the learning happens.
A good log records the technique, the signal in the statement, and the mistake, not only the solution.
Review spacing with doubling gaps keeps patterns in memory with little total effort.
Measure honestly: separate solved-live results from upsolved ones, and focus on the topic with the most open entries.

Cheat sheet

Upsolve: solve the problems you could not finish, afterwards, without time pressure
Log entry: problem, technique, signal in the statement, mistake that cost time
Reviews: space them out, each gap roughly double the last
Progress: keep solved-live and upsolved separate; track the topics with most open entries

Top traps to avoid

Reading the editorial and moving on without solving the problem yourself.
Logging only the solution, not the signal.
Counting upsolved problems as contest results.

Mastery check

0 of 15 answered

Answer from understanding, not memory of the page. You need 12 of 15. Each answer is explained, and you can retry as often as you like.

1.What is the main purpose of upsolving?
2.In the log above (A solved, B upsolved, C upsolved, D unsolved, E solved, F upsolved), how many problems were solved live?
3.Using the review rule that doubles the gap from day 0 with a first gap of 1, on which days are the first three reviews?
4.Why should a log record the signal in the statement, not only the solution?
5.Which problem is the most useful to upsolve?
6.What does upsolving mean?
7.After a contest, which problems should you upsolve first?
8.What is a good first step before reading an editorial when upsolving?
9.Why review your own wrong submissions?
10.What does a spaced review schedule do for a problem you have solved?
11.When reading an editorial, what is the most useful thing to extract?
12.Why group upsolved problems by technique?
13.After solving an upsolved problem, what should you record?
14.What is a sign that your upsolving is working?
15.Why come back to a solved problem after a gap of days or weeks?

Upsolving & Pattern Recognition

After this lesson you will be able to

The contest is the test; upsolving is the lesson

What makes upsolving work

A contest log

A recognition map from upsolving

Analysing the log and scheduling reviews

Reading the code

The cost of keeping a log

Cases to handle in the log

Common mistakes when upsolving

Recognising a pattern worth upsolving