#### If there are any blogs that I have missed, please tell in the comment section. Thank you.

# Mathematics Stuff

- Number Theory in Competitive Programming [Tutorial]
- Number of points on Convex hull with lattice points
- FFT, big modulos, precision errors.
- Number of ways between two vertices
- Mathematics For Competitive Programming
- FFT and NTT
- Burnside Lemma
- Number of positive integral solutions of equation 1/x+1/y=1/n!
- On burnside (again)
- Simple but often unknown theorems/lemmas/formula? Do you know?
- Probability of creating a Cycle
- Fast Fourier Transform and variations of it
- Mathematics
- Tutorial on FFT/NTT — The tough made simple. ( Part 2 )
- On continued fractions. Part 2: Properties and interpretation
- [Tutorial] Math note — Dirichlet convolution
- Fast modular multiplication
- Sums and Expected Value — part 2
- Recovering rational number from its remainder modulo huge integer
- Short modular inverse
- The Intuition Behind NIM and Grundy Numbers in Combinatorial Game Theory
- An efficient way to solve some counting problems without matrix multiplication\n
- On Fast Fourier Transform
- [Tutorial] Math note — Möbius inversion
- O(1) runtime prime checking
- [Tutorial] Burnside's lemma (with example)
- [Tutorial] Math note — linear sieve
- [Tutorial] Chinese Remainder Theorem
- A blog on the Sprague-Grundy Theorem
- [Tutorial] Invariants and Monovariants
- Operations on Formal Power Series
- On the mathematics behind rolling hashes and anti-hash tests
- A problem collection of ODE and differential technique
- [Tutorial] Inclusion-Exclusion Principle, Part 1.
- Tutorial on FFT/NTT — The tough made simple. ( Part 1 )
- Sums and Expected Value — part 1
- [Tutorial] Generating Functions in Competitive Programming (Part 2)
- [Tutorial] Generating Functions in Competitive Programming (Part 1)
- [Tutorial] Matroid intersection in simple words
- [Tutorial] Calculate modulo inverses efficiently!
- [TUTORIAL] Basic Lagrange Interpolation
- The Application of Lagrange Interpolation in Mathematics
- [Tutorial] Slight Generalization of Grundy Numbers
- Simple Linear and Effectively Duval Algorithm for Lyndon Factorization
- On the Number of Runs at the Monte-Carlo Method
- [Tutorial] Catalan Numbers and Catalan Convolution
- Counting Divisors of a Number in [tutorial]

# Geometry

- Extremal Triangles
- Preparing for Computational Geometry
- Is the solution of this geometry problem actually optimal?
- Writing a book on geometry, need some feedback
- Two-liners for triangle centers using Barycentric coordinates
- 3D Hull with Coplanar Points
- Quaternion algebra and geometry
- [Tutorial] Slope Trick
- Easy geometry using std::complex
- Geometry: 2D points and lines [Tutorial]
- Original Gym contest: Geometry Special 2018
- O(n) algorithm for finding largest triangle in a convex is wrong?
- How to sweep like a Sir
- Efficient 3D Convex Hull Tutorial
- Writing a book on geometry — Update
- Geometry: Polygon algorithms
- Slope trick explained
- [Tutorial] Slope Trick Visualised
- AlgorithmsThread 7: All Point Pairs
- [Tutorial] Voronoi Diagram and Delaunay Triangulation in O(n log n) with Fortune's Algorithm

# Strings

- Obtaining suffix array from suffix automaton
- String Algorithms
- Suffix tree. Basics. Building in O(nlogn)
- Suffix tree. Ukkonen's algorithm
- Z Algorithm
- On suffix automaton (and tree)
- [C++] basic_string
- Aho-Corasick algorithm. Construction
- A short guide to suffix automata
- Short story about palindromes
- Lexicographically Minimal String Rotation
- Do you really understand Suffix Arrays? An Experiment took a twisted turn!

# Dynamic Programming

- Everything About Dynamic Programming
- Tutorial — "Randomized" DP leading to state elimination
- DP Optimisation Problem
- O(n) solution for 631E (Convex Hull Trick special case)
- DP on Function Calls — Remove a Log Factor
- Fully Persistent Convex Hull Trick
- A range query convex hull problem
- [Tutorial] Recurrent Sequences — Application of combinatorics in DP (basics)
- Hirschberg's Algorithm
- Dp On Trees
- Dynamic Programming on Trees
- [Tutorial] Optimized solution for Knapsack problem
- Digit DP
- [Tutorial]A Complete Guide on Matrix Exponentiation
- "The trick from aliens"
- Introduction to DP with Bitmasking
- Dynamic Programming Optimizations ( Problems )
- AlgorithmsThread Episode 6: Convex Hull Tricks
- Dynamic convex hull implementation
- DP on Trees Tutorial
- [Tutorial] Li Chao Tree Extended
- [Tutorial] Convex Hull Trick — Geometry being useful
- Lecture #3 — Exchange arguments (sorting with dp)
- Matrix Exponentiation tutorial + training contest
- Linear Recurrence and Berlekamp-Massey Algorithm
- Dynamic Programming Optimizations
- [Tutorial] Non-trivial DP Tricks and Techniques
- SOS Dynamic Programming [Tutorial]
- Introduction to Digit Dynamic Programming
- Video Tutorial — Everything about Knapsack Problem
- Convex Hull Trick
- Nice trick involving sparse matrix exponentiation (kind-of)
- An Introduction to Plug DP

# Segment Trees

- Compressed segment trees and merging sets in O(N logU)
- [Video Tutorial] Majority Element Range Queries (Segment Tree)
- Do we actually need lazy propagation on segment trees?
- Persistent segment tree ( Problems )
- Easy and (Semi)Efficient Dynamic Segment Trees (with Policy Hash Tables)
- Segment Tree Beats. A simpler understanding.
- An efficient way to strengthen up your segment tree.
- using merging segment tree to solve problems about sorted list
- Minimum memory consumption by the segment tree
- Segment Tree Problems
- AlgorithmsThread Ep 3: Segment Trees (+ hard ST Problem)
- A simple introduction to "Segment tree beats"
- Efficient and easy segment trees
- Algorithm Gym :: Everything About Segment Trees
- A simple introduction to "Segment tree beats"
- "Efficient and easy segment trees" proof
- Modular Segment Tree with Lazy Propagation
- Sort before insert — A small, yet powerful extension to Merge sort tree
- Segment Tree vs Binary Index Tree (Fenwick Tree): Which is Better?
- Video: Segment Tree Beats
- crazySegmentTree: Segment Tree implementation with 5x faster queries than bottom-up tree

# Mo's Algorithm & Range queries Stuff

- Mo's Algorithm
- Some method for solving RMQ
- Range query data structures
- [Tutorial] 1D and 2D constant time per query range updates (a.k.a difference arrays)
- 2D Range Minimum Query in O(1)
- About performance of sparse tables
- Mo's Algorithm (with update and without update, now you can understand both)
- [Tutorial] Two ways to apply Mo's Algorithm on Trees
- A simple sqrt decomposition solution to online FFT
- SQRT decomposition
- [Tutorial] Square root decomposition and applications
- Fractional cascading is in fact slow?
- [Tutorial] Range minimum query in O(1) with linear time construction
- Everything on Mo's Algorithm
- Algorithms Dead Episode 2: RMQ Tricks!
- On Multidimensional Range Queries
- Mo's Algorithm on Trees [Tutorial]
- [Video Tutorial] Offline Range Queries using Mo's Algorithm
- An alternative sorting order for Mo's algorithm

# Graphs

- Graph Theory Concepts and Problems.
- Faster Dijkstra on Special Graphs [Tutorial]
- Kőnig's Theorem
- Dynamic connectivity problem
- Flow Series
- 2-SAT Tutorial
- Vertex cover and 2-SAT
- 0-1 BFS [Tutorial]
- Are there any learning materials of polynomial minimum cost flow algorithms?
- ICPC Graph Mining Challenge solution
- Algorithm Gym :: Graph Algorithms
- [Tutorial] The DFS tree and its applications: how I found out I really didn't understand bridges
- Story about edge coloring of graph
- Graph Visualizer: Visualize graph inputs
- [Tutorial] 1-K BFS
- Heuristic algorithm for Hamiltonian path in directed graphs
- Shortest Path Modelling Tutorial

# Trees

- A list of important concepts in Tree-based Problems
- Rerooting dynamic Euler tour trees
- [Tutorial] Initializing Binary Indexed Trees in linear time
- [Tutorial] Sack (dsu on tree)
- Non-Recursive HLD Implementation
- [Insight] Number of Topological Orderings of a Directed Tree
- Wavelet Tree Problems
- Understanding Fenwick Trees / Binary Indexed Trees
- Transform Skip list into a BIT with insert operator
- Fenwick tree: initialization in O(N)
- Dominator Tree [Tutorial]
- K-th smallest edge on a tree's path, a tutorial about its approaches
- The Tree Generator — generate different kinds of trees by simple strings!
- On Euler tour trees
- Algorithms Thread 8: Tree Basics (+ Gym Contest)
- Treaps reinvented?
- Sqrt-tree (part 2): modifications in O(sqrtN), lazy propagation
- Finding Bridges Tutorial
- Splay tree tutorial
- Tutorial on Heavy Light Decomposition + Problems
- [Explanation] dsu on trees (small to large)
- Unknown Data Structure — (Sqrt Fragmented Tree)
- Palindromic tree
- [Tutorial] Reachability Tree / DSU-tree
- Nifty implementation of multi-dimensional Binary Indexed Trees using templates.
- Centroid Decomposition on a tree(Beginner)
- Palindromic tree: behind the scenes
- Link-cut tree tutorial
- [Tutorial] Nearest Neighbor Search: Locality-Sensitive Hashing, K-Dimensional Tree, Vantage-Point Tree
- AVL tree without "big rotations"
- Tutorial on Virtual/Auxiliary Trees and YouTube channel
- Link Cut Tree implementation
- Implicit cartesian tree in GNU C++ STL.
- Easiest HLD with subtree queries
- Hybrid Tutorial #-1: Heavy-Light Decomposition
- Sqrt-tree: answering queries in O(1) with O(NloglogN) preprocessing.
- Maintain subtree information using link/cut trees
- Tutorial on Permutation Tree
- [Tutorial] Path sum queries on a tree using a Fenwick tree
- Heavy-light decompositon — it can be simple!
- Heavy-light decomposition implementation
- [Tutorial] Searching Binary Indexed Tree in O(log(N)) using Binary Lifting
- LCA problems
- Online Query Based Rerooting Technique
- Almost-LCA in Tree\n
- DSU with randomized linking is as fast as with rank heuristic
- Introduction to New Data Structure: Wavelet Trees
- [Tutorial] Boruvka's Algorithm
- [Tutorial] a few strange lca algorithms with a few strange time complexities pt 1
- [Tutorial] "1354D — Multiset" + A Gentle Introduction to Fenwick Trees
- A Well-known Data Structure -- Version Tree
- Hybrid Tutorial #-2: Centroid Decomposition

# Z-Category

- A bit more about palindromes
- Tips on Constructive Algorithms
- The most comprehensive Binary Search lecture
- Sublime Text [FastOlympicCoding] — tools for competitive programming
- (almost) Every Algorithms & Data Structures you needed to learn , with practice problems
- Codeforces Visulaizer
- An Introduction to the USA Computing Olympiad -- Book Released
- An Efficient (and quite common) Way to Navigate Grid Problems [C++]
- Ok, lets talk about cout.tie once and forever
- [Tutorial] How to use polygon.codeforces in problem preperation?
- A more elegant solution to 1054H — Epic Convolution
- Bitwise range AND/OR with no updates in O(n) preprocessing and O(1) time per query
- Counting the number of bitmasks in a given array that are submasks of m for every m -- why does this trick work?
- XOR Hashing [TUTORIAL]
- [Tutorial] Easy Introduction to Kitamasa Method
- Finding minimum residue of a linear function in O(log M) time
- About ordered set
- Problem Topics
- [Tutorial] Supporting Queue-like Undoing on DS
- Tricks that I learnt while practicing
- [Tutorial] A powerful representation of integer sets
- Looking for a Challenge 2
- Tips and tricks for solving permutation problems
- [Tutorial] A way to Practice Competitive Programming : From Rating 1000 to 2400+
- Algorithms Thread 9: Treaps (+ Gym Contest!)
- Competitive Programmer's Handbook — a new book on competitive programming
- My opinion on how to practice competitive programming
- TCR trick: Line hashes
- [Tutorial] Generalized Chirp Z-Transform
- How to get started with solving Ad-Hoc tasks on codeforces
- C++ Trick — Easy Debugging / Logging
- C++ STL: Policy based data structures. Part 2
- Random Walk: Hard version
- Venice Technique\n
- What are the greatest programming tips and tricks you have learned on your own by years of coding?
- Add Policy Based Data Structures in the C++ standard
- Game Theory Proof
- The power of assert()
- Matrix
- How does dynamic memory allocation work?
- Derangement Generation of an Array [Tutorial]
- Minimum swaps to sort an array\n
- A Solution of the P versus NP Problem
- Interactive Problems
- Top 5 Optimizations, Tips, and Tricks LGMs Don't Want YOU To Know About !
- Gym Contest with Editorial
- Very useful concepts I haven't seen here
- How to solve problems
- An efficient way to map a permutation (length 11 or 12) to an integer without using std::map
- Binary search on real values
- First Codeforces Tools Website
- Short and important problemsolving advices required
- Improving my Thinking Ability
- A Good Problem
- [Tutorial] Interview preparation guide for Google, Facebook, and other tech companies.
- Tutorial On Tof (Ternary Search)
- Mindf**k of the day — rand() from c++ and Berlekamp–Massey algorithm
- C++ STL: Policy based data structures
- A Bitwise Convolution Tutorial\n
- Useful macro
- Optimal psychological state for programming competitions\n
- A Concise Solution to Problem E from Round #642\n
- Advanced Algorithms and Complexity Course
- Randomization tasks
- The Fear of Gaussian Elimination
- Efficient implementation of Karatsuba multiply with auto-vectorization
- Micro- and macro-management for your next cpp source: General tips'n'tricks
- New data structures
- AlgorithmsThread 5: Persistent Data Structures
- Tutorial on Zeta Transform, Mobius Transform and Subset Sum Convolution
- How do you polar sort?
- Explanation to weird/strange floating point behaviour in C++
- [Tutorial] Kinetic Tournament (Used in FBHC Round 2)
- Fresh and unconventional algorithms & ideas for competitive programming
- Bitwise operations for beginners
- An interesting way of organizing the natural numbers in the tree
- Coding library
- Visualization tool for 2D problems (C++)
- What are the things that you discovered independently?
- An efficient way to control energy in a contest (Part 1+2)
- AlgoWiki: A wiki dedicated to competitive programming
- The history of some recurring problem
- An alternative and very interesting approach on binary search
- Variety of solutions depending on constraints
- Anti-hash test
- Randomized algorithms lecture, part 1 & 2
- Competitive programming course
- All you should know about comparators in C++
- One thing you should know about comparators — Strict Weak Ordering
- How to come up with problem ideas
- MNM Cheating Algorithm
- A simple tool for graph vizualization
- Bitwise operations 2 — popcount & bitsets
- How to get actual 64 bit bitsets on Codeforces [Not Recommended] [Don't do this at your job]
- Bin search and relative error
- Jngen: generic library for generating testcases
- Increase the chance of a random algorithm passing by abusing TLE verdict on Codeforces\n
- ATSP constant approximation: great job, dj3500!
- Blogewoosh #2
- Don't use rand(): a guide to random number generators in C++
- C++ Tricks
- AtCoder Library
- Blogewoosh #1
- How randomized solutions can be hacked, and how to make your solution unhackable
- [Tutorial] Rolling hash and 8 interesting problems [Editorial]\n
- Parallel Binary Search [tutorial]
- Partially Ordered Sets
- [Tutorial] Everything about unordered_map
- C++ STL: Order of magnitude faster hash tables with Policy Based Data Structures
- Minima/maxima over all fixed-size arrays (multi-dimensional)
- Short instruction of formulas writing (translation)
- How to read problem statements
- A problem collection (Spoiler Alert)
- A Beautiful Technique for Some XOR Related Problems
- Blowing up unordered_map, and how to stop getting hacked on it
- How to come up with the solutions: techniques
- Blogewoosh #4
- Blogewoosh #3
- Blogewoosh #5 (with images from now)
- General ideas
- Blogewoosh #7
- N Dimensional Vector (For std::vector Addicts!)
- Cool Code Snippet for Debugging
- Tricks Which Will Increase Your Rating!
- C++ tips and tricks
- Algorithm Gym :: Data structures
- Educational Round 83 problem E (Array Shrinking): O(n log n) solution
- Blogewoosh #6