Here are some useful blogs I found in CodeForces.

Note that:

• This list can be treated as an extension of catalog, since much of these tutorials are included in catalog but the others are collected by myself.
• The same blog may be included in this post twice or more.
• Blogs to ask questions are NOT included in this blog, since they seemed not quite useful to CP.
• If there are any blogs that I have missed, please tell me in the comment section. Thank you very much.

Hint: you can use Ctrl+F to search for information here.

General Advices

Micellaneous

• How to use Codeforces [GUIDE]
• [Tutorial] The command line: how to read input from file without #ifdef and much more
• After a Round FAQ
• [Tutorial] How to read editorials
• Pro Tips — get them while they are free
• Interactive Problems: Guide for Participants
• The Reason You are Bad at Codeforces — You are Not Russian Enough
• All You Need is Randomly Guessing — How to Improve at Codeforces

How to come up with solutions?

• How to read problem statements
• How to come up with the solutions: techniques
• Characteristics of the optimal solution, a technique for finding observations in a problem
• On "is this greedy or DP", forcing and rubber bands
• How to prove your solutions in Competitive Programming
• How to solve problems
• How to Solve Questions [Dominater Version]
• How to Effectively Practice CP + Problem Solving Guide

How to practice?

• F.A.Q. (in PM)
• My opinion on how to practice competitive programming
• Self-deception: maybe why you're still grey after practicing every day
• How to practice Competitive Programming [Um_nik version]
• [Tutorial] A Way to Practice Competitive Programming : From rating 1000 to 2000
• [Tutorial] How to learn better, and what most people don't get about learning
• How to Effectively Practice CP + Problem Solving Guide

How to ask for help?

• How to ask for help in PM
• Asking for help FAQ
• What not to say when you are accused of cheating

Algorithms

Micellaneous

• [Tutorial] Collection of little techniques
• General ideas
• A bit more of general ideas
• Tricks that I learnt while practicing
• The Ultimate Topic List (with Resources, Problems and Templates)
• A Huge Update on The Ultimate Topic List
• Problem Topics

Binary and Ternary Searches

• EDU: Binary Search
• The most comprehensive Binary Search lecture
• Binary search implementation
• Binary search on real values
• Bin search and relative error
• [Tutorial] Binary search and other "halving" methods
• Parallel Binary Search [tutorial]
• Tutorial On Tof (Ternary Search)
• Multi-dimensional ternary search
• Binary Lifting, No Memory Wasted

Constructive Algorithms

• Tips on Constructive Algorithms

Data Structures

Micellaneous

• Algorithm Gym :: Data Structures
• [Tutorial] Supporting Queue-like Undoing on DS
• [Tutorial] Supporting Priority-Queue-like Undoing on DS
• [Tutorial] Kinetic Tournament (Used in FBHC Round 2)
• Tutorial on Permutation Tree（析合树）
• Introduction to New Data Structure: Wavelet Trees
• [Tutorial] On Range LIS Queries, Part 1
• [Tutorial] On Range LIS Queries, Part 2
• Sqrt-tree: answering queries in O(1) with O(NloglogN) preprocessing.
• [Tutorial] Minimum Deque
• Palindromic tree: behind the scenes
• A bit more about palindromes
• Unknown Data Structure — (Sqrt Fragmented Tree)
• [Tutorial] Reachability Tree / DSU-tree
• A Well-known Data Structure -- Version Tree
• “Log Decomposition”, a technique to insert random elements into sorted data structures
• [Tutorial] The sparse set data structure

Fenwick Trees (BIT)

• Binary Indexed Tree
• [Tutorial] Searching Binary Indexed Tree in O(log(N)) using Binary Lifting
• Understanding Fenwick Trees / Binary Indexed Trees
• Nifty implementation of multi-dimensional Binary Indexed Trees using templates.
• [Tutorial] A Bit of Math, Historic Sum, and Range Add Range Sum Binary Indexed Tree (Fenwick Tree)
• [Tutorial] Initializing Binary Indexed Trees in linear time
• Fenwick tree: initialization in O(N)
• [Tutorial] "1354D — Multiset" + A Gentle Introduction to Fenwick Trees

Segment Trees

Ordinary Segment Trees

• EDU: Segment Tree, part 1
• Algorithm Gym :: Everything About Segment Trees
• Segment Tree
• Generalizing Segment Trees with Rust
• Efficient and easy segment trees
• An efficient way to strengthen up your segment tree.
• crazySegmentTree: Segment Tree implementation with 5x faster queries than bottom-up tree
• Segment tree with insertion and deletion operators.
• Push-Free Segment Tree
• A Slight Generalization of Push-Free Segment Trees
• Easy and (Semi)Efficient Dynamic Segment Trees (with Policy Hash Tables)
• Compressed segment trees and merging sets in O(N logU)
• using merging segment tree to solve problems about sorted list
• Minimum memory consumption by the segment tree
• Non-recursive segment tree tutorial
• Should you practice segment tree if you are below purple?
• [Video Tutorial] Majority Element Range Queries (Segment Tree)

Other Segment Trees

• [Tutorial] XOR Segment Tree
• Modular Segment Tree with Lazy Propagation
• AlgorithmsThread Ep 3: Segment Trees (+ hard ST Problem)

Segment Tree Beats

• A simple introduction to "Segment tree beats"
• Video: Segment Tree Beats
• AlgorithmsThread Ep 4: Segment Tree Beats

Segment Tree Problems

• Segment Tree Problems

Binary Search Trees

Balanced Trees

• AVL tree without "big rotations"
• "Merging treaps" -- or how to merge sorted sets in good complexity...
• Algorithms Thread 9: Treaps (+ Gym Contest!)
• [Tutorial] Splay Tree: One Tree to Rule Them All
• Splay tree and its implementation.
• Splay tree tutorial

Cartesian Trees

• Cartesian tree
• [Tutorial] Cartesian tree and some related problems
• Implicit cartesian tree in GNU C++ STL.

Link-cut Trees

• Link-cut tree tutorial
• Maintain subtree information using link/cut trees
• [Tutorial] Subtree lazy propagation on the link-cut tree
• Link Cut Tree implementation

Disjoint Set Union

• EDU: DSU
• [Tutorial] Proving the inverse Ackermann complexity of Union-Find
• DSU with randomized linking is as fast as with rank heuristic

Sparse Table (To Solve RMQ Problems)

• [Tutorial] Sparse table
• [Tutorial] Sparse table
• About performance of sparse tables
• [Tutorial] Range minimum query in O(1) with linear time construction
• 2D Range Minimum Query in O(1)
• On Multidimensional Range Queries
• Memory-optimal Range Queries and Updates in logN
• Some method for solving RMQ
• Algorithms Dead Episode 2: RMQ Tricks!

Persistent Data Structures

• AlgorithmsThread 5: Persistent Data Structures

Other Integer Sets

• [Tutorial] A powerful representation of integer sets
• Partially Ordered Sets
• About ordered set
• Venice Technique

Solving Other Problems Using Data Structures

• [Tutorial] Problems about swapping adjacent elements

Divide-and-conquer

• Dynamic connectivity problem
• Divide and conquer. Dynamic connectivity offline and DP optimization. Divide and conquer by queries.
• [Tutorial] Divide and Conquer Offline Query — A Niche Way to solve Static Range Query
• The Akra-Bazzi theorem — a generalization of the master theorem for recurrences

Dynamic Programming

Micellaneous

• Dynamic Programming Type
• Everything About Dynamic Programming
• Dynamic Programming Optimizations
• [Tutorial] Non-trivial DP Tricks and Techniques
• Dynamic Programming: two trainings by SPbSU students

Types of DP

Micellaneous

• A little bit of classics: dynamic programming over subsets and paths in graphs
• [Tutorial] Recurrent Sequences — Application of combinatorics in DP (basics)
• Kadane's Algorithm — (Dynamic Programming) — For new Solvers!
• [Tutorial] Dp with connected components, a simple way to understand it.
• [Tutorial] Product Trick
• Tutorial — "Randomized" DP leading to state elimination
• Hirschberg's Algorithm

Knapsack

• Optimized solution for Knapsack Problem
• [Tutorial] Knapsack, Subset Sum and the (max,+) Convolution

DP on Trees

• DP on Trees
• Dp On Trees
• Dynamic Programming on Trees
• DP on Trees Tutorial

SOS DP

• SOS DP
• SOS Dynamic Programming [Tutorial]
• Some SOS DP Insights

Digit DP

• Digit DP

Plug DP

• An Introduction to Plug DP

Optimization

Micellaneous

• 1D1D-optimization
• [Tutorial]Using Segment Trees to solve Dynamic Programming problems
• Theoretical grounds of lambda optimization
• Incredibly beautiful DP optimization from N^3 to N log^2 N
• Simple DP optimizations
• DP on Function Calls — Remove a Log Factor
• Dynamic Programming Optimizations ( Problems )
• DP optimization tips
• [Tutorial] Rotating calipers technique and its applications
• [Tutorial] Rotating calipers technique and its applications, Part 2

Convex Hull Trick

• On convex hull trick and e-maxx-eng
• [Tutorial] Convex Hull Trick — Geometry being useful
• Tiny Dynamic Convex Hull Implementation
• Efficient 3D Convex Hull Tutorial
• Dynamic convex hull implementation
• Fully Persistent Convex Hull Trick
• AlgorithmsThread Episode 6: Convex Hull Tricks
• [Tutorial] Li Chao Tree Extended
• [Tutorial] Li Chao Tree Extended 2

Slope Trick

• [Tutorial] Slope Trick
• Slope trick explained
• [Tutorial] Intuition on Slope Trick

Geometry

• Geometry: 2D points and lines [Tutorial]
• Geometry: Polygon algorithms
• Easy geometry using std::complex
• [Tutorial] Solving Interval Problems with Geometry
• Some rotational invariants in geometry
• Extremal Triangles
• [Tutorial] Voronoi Diagram and Delaunay Triangulation in O(n log n) with Fortune's Algorithm
• Quaternion algebra and geometry
• Geometry shrink trick
• Pythagorean triples and Pell's equations
• [Tutorial] Nearest Neighbor Search: Locality-Sensitive Hashing, K-Dimensional Tree, Vantage-Point Tree
• AlgorithmsThread 7: All Point Pairs

Game Theory

• Nim (Algorithmic Game)
• The Intuition Behind NIM and Grundy Numbers in Combinatorial Game Theory
• Nimbers and Sprague-Grundy theorem
• A blog on the Sprague-Grundy Theorem
• [Tutorial] Slight Generalization of Grundy Numbers

Graph Theory

Micellaneous

• Algorithm Gym :: Graph Algorithms
• Basic Graph Theory
• Graph Theory Concepts and Problems.
• [Tutorial] 2-SAT
• 2-SAT Tutorial
• Vertex cover and 2-SAT
• Faster Dijkstra on Special Graphs [Tutorial]
• Add edges to a digraph to make it strongly connected
• Articulation points and bridges (Tarjan's Algorithm)
• Online Query Based Rerooting Technique
• Heuristic algorithm for Hamiltonian path in directed graphs
• Traversing the complement graph in linear/near-linear time in multiple ways
• Story about edge coloring of graph
• Merging Queries Trick
• A Brief Inquiry into Online Connectivity
• Maintaining mst with online edge insertions — no LCT needed
• [Tutorial] Online Dynamic Connectivity
• [Tutorial] Hungarian algorithm in Õ(mn) or O(n^3)

DFS

• [Tutorial] The DFS tree and its applications: how I found out I really didn't understand bridges
• [Tutorial] Directed DFS trees (and the Tarjan algorithm for Strongly Connected Components)
• My own algorithm — offline incremental strongly connected components in O(m*log(m))

Shortest Paths

• 0-1 BFS [Tutorial]
• [Tutorial] 1-K BFS
• [Tutorial] k shortest paths and Eppstein's algorithm
• Rethink the Dijkstra algorithm -- Let's go deeper
• [Tutorial] The Floyd-Warshall algorithm and its generalizations
• Shortest Path Modelling Tutorial

Trees

Micellaneous

• A list of important concepts in Tree-based Problems
• Algorithms Thread 8: Tree Basics (+ Gym Contest)
• On Euler tour trees
• [Insight] Number of Topological Orderings of a Directed Tree
• [Tutorial] Path sum queries on a tree using a Fenwick tree
• Bridge Trees [Tutorial]
• Finding Bridges Tutorial
• [Tutorial] Binary lifting
• [Tutorial] Tree Isomorphism CSES
• [Tutorial] Diameter of a tree and its applications
• [Tutorial] Fully Dynamic Trees Supporting Path/Subtree Aggregates and Lazy Path/Subtree Updates
• Optimal 2/3 halving in interactive tree problems
• K-th smallest edge on a tree's path, a tutorial about its approaches
• [Tutorial] Boruvka's Algorithm
• The Ultimate Reroot Template

Heavy-Light Decomposition

• Hybrid Tutorial #-1: Heavy-Light Decomposition
• Heavy-light decompositon — it can be simple!
• Easiest HLD with subtree queries
• Heavy-light decomposition implementation
• [Idea] Using HLD to reduce memory
• [Tutorial] Theoretically Faster HLD and Centroid Decomposition
• Non-Recursive HLD Implementation
• Tutorial on Heavy Light Decomposition + Problems

Centroid Decomposition and similiar

• Centroid Decomposition on a tree(Beginner)
• Hybrid Tutorial #-2: Centroid Decomposition
• [Tutorial] Theoretically Faster HLD and Centroid Decomposition
• Shallowest Decomposition Tree

DSU on Trees

• [Tutorial] Sack (dsu on tree)
• [Explanation] dsu on trees (small to large)
• DSU on trees

LCA

Micellaneous

• [Tutorial] a few strange lca algorithms with a few strange time complexities pt 1
• LCA in logN — Binary lifting, Video tutorial

Problems

• LCA problems

Tools

• The Tree Generator — generate different kinds of trees by simple strings!

Matching

• [Tutorial] Blossom Algorithm for General Matching in O(n^3)
• Randomized general matching with Tutte matrix

Flows

• network flow
• [Tutorial, Flows] Project Selection Problem
• [Tutorial] My way of understanding Dinitz's ("Dinic's") algorithm
• [Tutorial] Minimum cost (maximum) flow
• [Tutorial] More about minimum cost flows: potentials and Dinitz
• [Tutorial] The residual graph and working with the set of all minimum cuts
• [Tutorial] Network simplex
• Kőnig's and Hall's theorems through minimum cut in bipartite graphs
• [Tutorial] Simulating Cost Flow
• Implementing Dinitz on bipartite graphs
• [Tutorial] Graph Potentials, Johnson's Algorithm, and Min Cost Max Flow

Greedy Algorithms

• [Tutorial] Matroid intersection in simple words
• [Tutorial] Greedoids: a formal way to look at families of greedily-solvable problems

Hashing

• [Tutorial] Rolling hash and 8 interesting problems [Editorial]
• Analysis of polynomial hashing
• Kapun's algorithm
• On the mathematics behind rolling hashes and anti-hash tests
• XOR Hashing [TUTORIAL]

Minima/Maxima

• Minima/maxima over all fixed-size arrays (multi-dimensional)

Mathematics

Micellaneous

• Number of Solutions to a Linear Algebraic Equation
• An interesting algebraic construction
• [Tutorial] 2-SAT
• 2-SAT Tutorial
• [Tutorial] Floors, ceilings and inequalities for beginners (with some programming tips)
• An efficient way to solve some counting problems without matrix multiplication
• Snapshot of finite calculus and using it to solve a 3000 rated problem

Bitwise Operations

• Bitwise operations for beginners
• Bitwise operations 2 — popcount & bitsets
• A Beautiful Technique for Some XOR Related Problems
• XOR basis without linear algebra

Number Theory

Micellaneous

• Essentials of Elementary Number Theory
• Finding minimum residue of a linear function in O(log M) time
• On the Min25 sieve and extensions / SPOJ ASSIEVE
• [Tutorial] Chinese Remainder Theorem
• p-adic exponent or why there is a primitive root modulo powers of prime numbers (except 2)
• [Tutorial] Berlakamp's Algorithm for Polynomial Factorization in a Field (1698G buffed)
• [Tutorial] Euler's phi function, its properties, and how to compute it
• Lucas Theorem is not an equation, it's an operation!
• Recovering rational number from its remainder modulo huge integer
• Integer solutions to x² + y² = z
• Number of positive integral solutions of equation 1/x+1/y=1/n!
• Some useful conclutions for some naive algorithms to solve number theory problem

Euclid's Algorithm

• Division-less Euclid's algorithm

Modular Arithmetic

• Modular Arithmetic for Beginners
• Algorithms Dead Episode 1: Divsion Under Mod!

Modular Inversion

• [Tutorial] Calculate modulo inverses efficiently!
• Short modular inverse

Primes & Divisors

• Counting Divisors of a Number in $$$O(N^{\frac{1}{3}}$$$) [tutorial]
• Counting primes in $O(n^{2/3})$
• Implicit Prime Factorisation
• [Tutorial] Number theory — Storing information about multiples/divisors

Prime Sieve

• Prime Factorization In log(n) After Sieve
• Extensions of the Prime Sieve
• Sieve Methods : Prime, Divisor, Euler Phi etc.

Möbius Inversion

• [Tutorial] Generalized Möbius Inversion on Posets
• Mobius inversion

Dirichlet Convolution

• [Tutorial] Math note — Dirichlet convolution
• Dirichlet convolution. Part 1: Fast prefix sum computations
• Dirichlet convolution. Part 2: Dirichlet series and prime counting

Probability Theory

• Sums and Expected Value — part 1
• Sums and Expected Value — part 2
• [Tutorial] Expected number of coin flips required to achieve a given string
• Probability 101, the intuition behind martingales and solving problems with them

Combinatorics

Micellaneous

• [Tutorial] Inclusion-Exclusion Principle
• Young Tableaus and the Hook Length Formula
• [Tutorial] Invariants and Monovariants
• An intuition and simpler proof for Kirchoff's tree theorem
• Lattice paths and Lindström–Gessel–Viennot lemma
• MacMahon's master theorem

Burnside Lemma

• [Tutorial] Burnside's lemma (with example)
• [Tutorial] From Burnside to Polya: A Short Introduction to Group Theory

Stirling & Catalan Numbers

• Stirling numbers with fixed n and k
• Catalan Numbers and Generating Uniform Balanced Bracket Sequences
• [Tutorial] Catalan Numbers and Catalan Convolution

Linear Algebra

• A Beautiful Technique for Some XOR Related Problems
• Linear Basis (Xor Basis Extended)
• 2 Special cases of Gaussian [Tutorial]

Matrix

• Matrix Exponentiation tutorial + training contest
• Matrix

Permutations

• [Tutorial] A comprehensive guide to permutations for beginners
• Permutation group basis construction (Schreier–Sims algorithm)
• Derangement Generation of an Array [Tutorial]
• An efficient way to map a permutation (length 11 or 12) to an integer without using std::map

Polynomials, Series and Recurrences

Micellaneous

• Lagrange inversion theorem
• Lagrange interpolation and partial fraction decomposition
• Computing n! modulo pᵏ for small p
• Calculating Series Sums with Binary Exponentiation
• How to composite (some) polynomials faster?
• The discrete derivative, falling factorials and polynomials

Generating Functions

• Generating Functions in Competitive Programming (Part 1)
• Generating Functions in Competitive Programming (Part 2)
• A problem collection of ODE and differential technique
• Prefix Sum Polynomial
• Combinatorial species: An intuition behind generating functions
• Unlabeling combinatorial species (cycle index series)
• Moment-generating functions, inversions and q-analogs
• OGFs, EGFs, differentiation and Taylor shifts
• Fast polynomial composition
• Solving the "simple math problem" with generating functions
• Useful substitutions with generating functions
• Partitions and pentagonal number theorem
• Arrow product: How to enumerate directed graphs
• Shift of polynomial sampling points
• Unexpected application of cosines
• [Math note] On the relationship between gf and me

FFT and Similar Transformations

• [Tutorial] FFT
• Tutorial on FFT/NTT Part 1
• Tutorial on FFT/NTT Part 2
• Fast Fourier Transform and variations of it
• Operations on Formal Power Series
• Operations on polynomials (on cp-algorithms)
• Fast convolution for 64-bit integers
• CDQ convolution (online FFT) generalization with Newton method
• Notes on FFT / NTT, and the "ultimate" NTT with modulus > 9 * 10^18
• [Tutorial] Generalized Chirp Z-Transform
• Discrete Fourier Transform eigenvalues
• A simple way to understand the transposed algo of multi-eval
• An unexpected D&C with FFT
• Tutorial: A simple O(n log n) polynomial multiplication algorithm
• Introducing the imaginary cyclic convolution, speeding up convolution by a factor of 2
• Montgomery/Barret reduction and NTT [Performance optimization]

Bitwise Convolutions

• Generalized FWHT: How I realized I did not understand FWHT
• Tutorial on Zeta Transform, Mobius Transform and Subset Sum Convolution
• Fast Walsh Hadamard Transforms and it's inner workings
• Subset convolution interpretation
• Optimal Algorithm on Polynomial Composite Set Power Series
• OR Convolution for Common People
• [Tutorial] GCD Convolution
• [Tutorial] Zeta, Mobius Transform to AND, OR, GCD Convolution
• [Tutorial] XOR Convolution without math

Linear Recurrences

• Linear Recurrence and Berlekamp-Massey Algorithm
• [Tutorial] Berlekamp-Massey
• On linear recurrences and the math behind them
• Recovering a linear recurrence with the extended Euclidean algorithm
• [Tutorial] Solving Linear Recurrences with various methods, Including O(N logN logK) using FFT
• Hadamard product and binomial convolution of linear recurrences
• Half-GCD algorithm
• [Tutorial] An elementary way of solving recurrences

Optimizations

• Multi-dimensional ternary search
• Theoretical grounds of lambda optimization
• Duality in linear programming. Part 1 — definition and construction
• Duality in linear programming. Part 2 — in competitive programming

Abstract Nonsense

• Permutation group basis construction (Schreier–Sims algorithm)
• Associativity and general identity testing

Non-exact and Randomized Algorithms

• [Tutorial] Simulated Annealing in Competitive Programming
• Randomized algorithms lecture, part 1 & 2
• On the Number of Runs at the Monte-Carlo Method
• Randomized general matching with Tutte matrix
• How randomized solutions can be hacked, and how to make your solution unhackable
• Increase the chance of a random algorithm passing by abusing TLE verdict on Codeforces
• A (Somehow) Simple (Randomized) Algorithm for Frobenius Form of a Matrix

Sortings

• Quicksort and chill
• Lecture #3 — Exchange arguments (sorting with dp)

Square Root Techniques

Micellaneous

• [Tutorial] Square Root Techniques
• Sqrt-tree: answering queries in O(1) with O(NloglogN) preprocessing.
• Sqrt-tree (part 2): modifications in O(sqrtN), lazy propagation
• Unknown Data Structure — (Sqrt Fragmented Tree)
• [Tutorial] Subset Sum Square Root Optimisation

SQRT Decomposition

• [Tutorial] Square root decomposition and applications
• What's slower than a segment tree and needs some more space to be free ?
• SQRT decomposition and Mo's Algorithm

Mo's Algorithm

• Mo's Algorithm
• Mo's Algorithm on Trees [Tutorial]
• An alternative sorting order for Mo's algorithm
• Mo's Algorithm (with update and without update, now you can understand both)
• [Tutorial] Two ways to apply Mo's Algorithm on Trees
• [Video Tutorial] Range Queries with Mo's Algorithm
• SQRT decomposition and Mo's Algorithm

Strings

Micellaneous

• Palindromic tree: behind the scenes
• A bit more about palindromes
• The history of some recurring problem
• [Tutorial] Expected number of coin flips required to achieve a given string
• Random notes on Lyndon decomposition
• Hunt-Szymanski Algorithm Explained (LCS but optimized for special cases)

KMP Algorithm

• KMP
• Video tutorial on KMP algorithm

Trie

• Trie Data Structure — Video Tutorial

AC Automata

• Aho-Corasick algorithm. Construction

Manacher's Algorithm

• Manacher's algorithm
• Longest Palindromic Substring — Manacher's Algorithm (Video tutorial)

Suffix Automata/Trees/Arrays

• Suffix tree. Basics. Building in O(nlogn)
• Suffix tree. Ukkonen's algorithm
• suffix automata
• A short guide to suffix automata
• [Tutorial] Dynamic Suffix Arrays
• Obtaining suffix array from suffix automaton

Z Algorithm

• Z Algorithm

Other Matchings

• [Tutorial] Dictionary of Basic Factors — O(1) String Matching
• [Tutorial] On Variations of String Matching

Sweeping Line

• How to sweep like a Sir
• [Tutorial] Finding inclusion hierarchy among circles — An implementation of a sweep-line algorithm

Two Pointers

• EDU: Two Pointers Method

C++

Tips & Tricks

• C++ Tricks
• C++ tips and tricks
• Template Metaprogramming in C++ Part 1 / Infinity
• [Tutorial] On lambdas, C++ and otherwise: the what, the why, and the how
• Competitive C++ Manifesto: A Style Guide
• C++11 for programming contests...
• C++17, competitive programming edition
• std::generator and recursive lambdas in C++23
• N Dimensional Vector (For std::vector Addicts!)
• Don't use rand(): a guide to random number generators in C++
• A way to use C++ iostream for large input (gcc only)
• Explanation to weird/strange floating point behaviour in C++
• How NOT to use macros
• Performance tip : using std::deque as a memory cache
• How to get actual 64 bit bitsets on Codeforces [Not Recommended] [Don't do this at your job]
• Dynamic Bitsets in GCC
• [Tutorial] Writing C++ like Python: tricks Python doesn't want you to know
• [C++] Avoiding temporaries — generalizing i++ using std::exchange
• [Tutorial] Common Mistakes in Competitive Programming and How to Avoid Them

Debugging Tools

• C++ Trick — Easy Debugging / Logging
• C++ Debug Template!
• Compilation and debugging tutorial

Optimization

• [Tutorial] GCC Optimization Pragmas
• Tutorial on SIMD vectorisation to speed up brute force
• 4-5x Faster Drop-in Replacement for std::lower_bound
• Introducing My Fast I/O Library for C++

Hacking

• Catching silly mistakes with GCC
• You won't believe how this simple trick defeated the unexplained bug destroying every top LGM
• Blowing up unordered_map, and how to stop getting hacked on it
• Anti-hash test.
• [Tutorial] Hacking a weak hash
• On the mathematics behind rolling hashes and anti-hash tests
• A tool for hacking rolling hashes with fixed modulos and bases

STL & Policy Based Data Structures

• C++ STL: Policy based data structures
• C++ STL: Policy based data structures. Part 2
• Implicit cartesian tree in GNU C++ STL.
• Generic data structure templates via C++ mixins
• About a general reader / writer for STL-Structures,
• C++ STL: Order of magnitude faster hash tables with Policy Based Data Structures

Meta

CodeForces Extensions

• CF-Predictor — Know your rating changes!
• Codeforces Practice Tracker — Browser Extension
• Presenting Codeforces Optimal Theme
• UpSolve.me | Efficient Codeforces Practice
• Colorize standings by used programming language
• Average number of problems solved during a contest per rating
• Multiple rating graph with other accounts
• Have you already seen the history of ratings on clist?
• Codeforces Problem Tracker Chrome Extension
• CF Static Site Enhancer — Browser Extension
• [chrome extension] Codeforces Customizer
• Google Chrome extension for automatic sample case testing on Codeforces
• Dark mode in codeforces
• Chrome/Firefox Extension to analyse Codeforces profiles
• [BrowserExtension] : New Year Before New Year?
• Gym Finder
• Userscript: table view in Catalog
• Finally, semantic search for competitive programming problems
• Codeforces Visulaizer

Other Tools

• Sublime Text [FastOlympicCoding] — tools for competitive programming
• [Tool] Graph Debugger
• A tool for testing interactive problems

Code Libraries

• AtCoder Library
• New online judge: Library-Checker!
• (The Ultimate) Code Library
• Introduction to CPLib — Modern C++ Library for Test Data in CP

Problem and Contest Preparation

Polygon

Tips

• 10 Reasons to Prepare Problems in Polygon
• [Tutorial] Polygon.Codeforces Tutorial — A Guide to Problem Preparation [Part 1]
• [Tutorial] How to use polygon.codeforces in problem preperation?
• Polygon: Warnings for Packages — Incomplete Tests + Statement/Validator Mismatches
• Polygon: AI-Powered Automatic Tips
• Automatic Translation of Problem Statements in Polygon

Updates

• Polygon Updates (Fall-Winter 2014)
• Codeforces Updates (April-May, 2015)
• Testlib and Polygon Updates (June, 2015)
• Testlib and Polygon Updates [July, 2018]
• Polygon updates (June-October 2019)
• Polygon Updates (June — August 2021)

Preparing with testlib.h

• Briefly about testlib.h
• Generators with testlib.h
• Validators with testlib.h
• Checkers with testlib.h
• Interactors with testlib.h
• Testlib: Opts — parsing command line options
• Testlib: tests + CI

Problemsetting

• How to come up with problem ideas
• Way of problemsetter
• What is it like to be a problem writer?
• Problemsetter's Memoir
• On problemsetting
• On problemsetting 2
• About Problemsetting (for AtCoder and Codeforces)
• [Problemsetting] How to write editorials for a contest
• Insights from testing and preparing contests, and why problemsetting trends need to change

Others

• TCR trick: Line hashes