Lilly Tech Systems
Contest Strategy & Tips
The difference between solving a problem in practice and solving it in a 2-hour contest is strategy. This lesson covers time management, systematic debugging, ready-to-use template code, and answers to the most common competitive programming questions.
Time Management During Contests
A typical 2-hour Codeforces Div 2 contest has 6 problems. Here is the optimal time allocation strategy:
| Phase | Time | Activity | Goal |
|---|---|---|---|
| Read All | 0-5 min | Skim all problems, read A and B fully | Identify easy problems, spot patterns |
| Solve A | 5-15 min | Code and submit Problem A | Fast AC, build confidence |
| Solve B | 15-30 min | Code and submit Problem B | Two problems in first 30 min |
| Read C-D | 30-35 min | Read C and D carefully | Decide which to attempt first |
| Solve C | 35-65 min | Think + code Problem C | Get the key insight, implement carefully |
| Solve D | 65-100 min | Think + code Problem D | Push for 4 problems |
| Attempt E | 100-120 min | Read E, attempt if time allows | Bonus points if solvable |
Systematic Debugging
When your solution gets Wrong Answer or Time Limit Exceeded, follow this systematic debugging process:
Step 1: Test Edge Cases
Test with: N=1, N=0, all same values, sorted ascending, sorted descending, maximum constraints. Most bugs appear in edge cases. Generate these test cases before submitting.
Step 2: Stress Test
Write a brute force solution and a random test generator. Run both on thousands of small random inputs and compare outputs. This finds bugs that manual testing misses.
Step 3: Print Debug
Add strategic print statements to verify intermediate values. For DP: print the entire table. For graphs: print the adjacency list and visited array. For sorting: print the array after sorting.
Step 4: Check Overflow
Python handles big integers natively, but modular arithmetic bugs are common. Verify: are you taking mod at every step? Is the mod value correct (10^9+7)? Are you handling negative mod results?
Stress Testing Template
import random
import subprocess
def brute_force(n, arr):
"""Slow but correct O(N^2) solution"""
# Your brute force here
pass
def optimized(n, arr):
"""Fast O(N log N) solution you want to verify"""
# Your optimized solution here
pass
def random_test():
"""Generate random test case"""
n = random.randint(1, 20) # Small for brute force
arr = [random.randint(-100, 100) for _ in range(n)]
return n, arr
def stress_test(iterations=10000):
"""Run stress test comparing brute force vs optimized"""
for i in range(iterations):
n, arr = random_test()
expected = brute_force(n, arr[:])
actual = optimized(n, arr[:])
if expected != actual:
print(f"MISMATCH on test {i}!")
print(f"Input: n={n}, arr={arr}")
print(f"Expected: {expected}")
print(f"Actual: {actual}")
return False
print(f"All {iterations} tests passed!")
return True
stress_test()Contest Template Code
Copy this template at the start of every contest. It includes fast I/O, common imports, and utility functions that save precious minutes.
import sys
import os
from io import BytesIO, IOBase
# Fast I/O for competitive programming
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b: break
ptr = self.buffer.tell()
self.buffer.seek(0, 2)
self.buffer.write(b)
self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2)
self.buffer.write(b)
self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# Common imports
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
from bisect import bisect_left, bisect_right, insort
from itertools import permutations, combinations, product, accumulate
from functools import lru_cache, reduce
from math import gcd, lcm, sqrt, ceil, floor, log2, comb, factorial
from operator import xor, add, mul
# Constants
MOD = 10**9 + 7
INF = float('inf')
sys.setrecursionlimit(300000)
# Utility functions
def ints(): return list(map(int, input().split()))
def mint(): return map(int, input().split())
def sint(): return int(input())
def solve():
# Read input
n = sint()
arr = ints()
# Solution here
print(0)
# Main
t = sint()
for _ in range(t):
solve()Common Algorithm Decision Tree
When you read a problem, use this decision tree to quickly identify the algorithm:
| Problem Pattern | Keywords | Algorithm | Time Complexity |
|---|---|---|---|
| Find if X exists / minimum X | "find minimum", "is it possible", sorted data | Binary Search | O(N log N) |
| Shortest path | "minimum cost", "shortest", "least distance" | BFS / Dijkstra / Bellman-Ford | O(V+E) to O(VE) |
| Connectivity / components | "connected", "groups", "clusters" | DSU / BFS / DFS | O(N) |
| Optimal value with choices | "maximize", "minimize", "number of ways" | Dynamic Programming | Varies |
| Always take best option | "greedy", "sort and pick" | Greedy + Sort | O(N log N) |
| Range queries with updates | "range sum", "range min", "update" | Segment Tree / BIT | O(N log N) |
| Subset optimization (N ≤ 20) | "choose subset", "select items", N small | Bitmask DP | O(2^N * N) |
| Pattern in string | "find pattern", "occurrences", "matching" | KMP / Hashing / Trie | O(N + M) |
| Assignment / matching | "assign", "pair", "match", bipartite | Bipartite Matching / Flow | O(V * E) |
| Counting with large numbers | "modulo 10^9+7", "count ways" | Combinatorics + Modular Arithmetic | O(N) |
Common Mistakes to Avoid
Not Reading the Problem
Read every word of the problem statement, especially constraints. The constraints tell you the expected time complexity. N ≤ 10^3 means O(N^2) works. N ≤ 10^5 means O(N log N). N ≤ 10^6 means O(N). Missing this wastes time on over-optimized or under-optimized solutions.
Integer Overflow
Python handles big integers, but forgetting to mod intermediate results causes TLE (big integer arithmetic is slow). Always mod after every multiplication: (a * b) % MOD, not a * b (which could be 10^18 digits).
Off-by-One Errors
The most common bug in CP. Is it 0-indexed or 1-indexed? Is the range [l, r] inclusive or exclusive? Does "N items" mean indices 0 to N-1 or 1 to N? Always clarify before coding.
Wrong Data Structure
Using a list where you need a set (O(N) lookup vs O(1)). Using list.pop(0) instead of deque.popleft() (O(N) vs O(1)). Using dict where defaultdict is cleaner. These cause both bugs and TLE.
Submitting Without Testing
Always test with the sample inputs before submitting. Then test with edge cases (N=1, empty input, maximum values). Wrong Answer penalties cost time and rating points.
Panic Coding
When stuck, take 30 seconds to think before typing. Coding without a clear plan leads to spaghetti code that is impossible to debug. Write pseudocode first, then implement methodically.
Frequently Asked Questions
How long does it take to get good at competitive programming?
With consistent daily practice (1-2 hours), most people reach Codeforces Expert (1600+) in 6-12 months. Getting to Candidate Master (1900+) typically takes 1-2 years. The key is consistency: solving 2-3 problems daily and upsolving after every contest. Progress is not linear — expect plateaus where you feel stuck for weeks. Push through by focusing on your weak topics.
Should I learn C++ for competitive programming or stick with Python?
Python works for most problems up to Div 2 D level. Its main disadvantages are: (1) 3-5x slower execution, which causes TLE on some problems even with the right algorithm, (2) recursion depth limit of ~1000 (fixable with sys.setrecursionlimit but still risky), and (3) no built-in sorted set or balanced BST. If you plan to compete seriously (target Expert+), learning C++ is worth the investment. For interview prep and casual contests, Python is perfectly fine.
What is the most important topic to learn first?
In order of priority: (1) Binary search — appears in 30%+ of contest problems either directly or as a sub-step. (2) Graphs (BFS/DFS) — the most common advanced topic. (3) Dynamic programming — the hardest to learn but most tested in interviews. (4) Greedy algorithms — required to solve easy and medium problems quickly. (5) Data structures (segment tree, DSU) — for harder problems. Master binary search first; it unlocks the most problems per hour invested.
How do I handle problems I cannot solve during a contest?
Upsolving is the most important habit. After every contest: (1) Read the editorial for every problem you could not solve. (2) Implement the solution yourself without copying. (3) If you do not understand the editorial, search for video explanations or alternate write-ups. (4) Tag the problem with the algorithm/technique it requires. (5) Revisit similar problems in 1-2 weeks to verify retention. The problems you upsolve teach you more than the ones you solve during the contest.
Is competitive programming useful for ML engineering interviews?
Yes, directly. Google, Meta, Amazon, and top AI labs all include algorithmic coding rounds in ML engineering interviews. The problems are typically LeetCode Medium to Hard level, which maps to Codeforces Div 2 B-C difficulty. CP gives you: (1) speed under pressure, (2) correct implementation habits, (3) deep understanding of time/space complexity, and (4) familiarity with graph, DP, and optimization problems that appear in ML system design.
How do I avoid Time Limit Exceeded (TLE) in Python?
Follow these rules: (1) Use sys.stdin.readline for input, not input(). (2) Use sys.stdout.write for output, not print() (especially in loops). (3) Avoid string concatenation in loops; use list.append + "".join. (4) Use arrays instead of dicts when indices are contiguous. (5) Avoid recursion for large N; convert to iterative. (6) Use built-in functions (sorted, min, max, sum) which are C-implemented and much faster than Python loops. (7) For number crunching, consider numpy or writing critical sections in a different way.
What is the best way to practice during the week?
Monday-Friday: solve 2-3 problems from Codeforces problemset filtered by your target rating range (+200 from current). Focus on a specific topic each week (e.g., Week 1: binary search, Week 2: graphs). Saturday: participate in a live contest. Sunday: upsolve all problems from Saturday's contest. Track your solved problems in a spreadsheet with columns: problem, topic, difficulty, time, and notes. Review your weak topics monthly.
How do I know if my approach is fast enough before coding?
Use the "10^8 rule": modern computers execute roughly 10^8 simple operations per second. If your algorithm does N^2 operations and N = 10^5, that is 10^10 operations = ~100 seconds = TLE. You need O(N log N) which is ~1.7 * 10^6 operations = fast. Before coding, compute: (1) what is N from the constraints? (2) what is my algorithm's time complexity? (3) does complexity * N fit in 10^8? For Python, use 10^7 as the threshold since Python is ~10x slower than C++.
Should I memorize algorithm implementations?
Yes for the fundamentals: binary search, BFS/DFS, Dijkstra, DSU, segment tree, BIT, and modular arithmetic utilities. You should be able to write these from memory in under 5 minutes each. For less common algorithms (max flow, suffix array, centroid decomposition), having a well-organized template library is sufficient. The goal is not rote memorization but deep understanding: if you understand WHY the algorithm works, you can reconstruct it even if you forget the exact code.
What are virtual contests and should I do them?
Virtual contests let you simulate a past contest under the original time constraints. Codeforces has built-in virtual contest support. You should absolutely do them: they build contest stamina, time management skills, and pressure resistance. Do 1-2 virtual contests per week in addition to live contests. Choose contests slightly above your current rating level. Virtual contests also count toward your solve statistics, helping you track progress objectively.
Course Summary
You have completed the Competitive Programming for AI course. Here is what you learned:
| Lesson | Topics | Key Takeaway |
|---|---|---|
| 1. CP for ML Engineers | Platforms, ratings, strategy | CP skills directly transfer to ML engineering |
| 2. Mathematical Problems | Modular arithmetic, matrix exp, combinatorics | Master mod pow, mod inverse, precomputed factorials |
| 3. String Algorithms | KMP, Rabin-Karp, trie, suffix array, hashing | Rolling hash is the most versatile string technique |
| 4. Graph Algorithms | Bellman-Ford, Floyd-Warshall, flow, matching, SCC | Graph problems are 30% of contest problems |
| 5. Advanced Data Structures | Segment tree, BIT, DSU, sparse table, heaps | These turn O(N) queries into O(log N) |
| 6. Contest-Style Problems | Pipeline, model selection, grid search, scheduling | 5 patterns cover most Div 2 C-D problems |
| 7. Contest Strategy | Time management, debugging, templates, FAQ | Strategy matters as much as algorithmic skill |