Awesome Competitive Programming Problems

This repository contains my implementation of useful / well-known data structures, algorithms and solutions for awesome competitive programming problems in Hackerrank, Project Euler and Leetcode

I create this for faster implementation and better preparation in interviews as well as programming contests

📆 Last updated on 06.04.2021 in Python 3 by Le Duc Khai

⚠️ This repo is day-by-day updated. Please make sure you have the latest version!

❓ How to use

• : Useful / well-known data structures or algorithms

• : Solutions for some awesome competitive programming problems

Mathematics : Type of the Algorithm

Permutation Problems : Category of the Problem

Lexicographic Permutations : Name of the problem

Awesome-Competitive-Programming 
│   README.md 
│
└───Folder 1        : Type of Algorithm 
│   │   File1.ipynb : Python codes for the problem
│   │   ...   
│   
└───Folder 2
│   │   File2.ipynb
│   │   ...
│     
└───Folder Data Bank: Descriptions and Solution Guides for the Problem 
│   │   File1.pdf
│   │   ...
│
└───...    

🍉 Algorithms

A) Data Structures Applications

🌴 Binary Search Tree Algorithm

1. • Binary Search Tree: Original Binary Search Tree Algorithm - O(log(n))
2. • Binary Search Tree: Check a Number: Check if a Number is in a Sorted List using BST Algorithm - O(log(n))
3. • Binary Search Tree: Index of a Number: Find the Index of a Number in a Sorted List using BST Algorithm - O(log(n))

B) String Algorithm

🌾 Suffix Tree - Suffix Array

1. • Suffix Array (Manber-Myers Algorithm): Find suffix array of a string S based on Manber-Myers algorithm - O(n.log(n)) , n = |S|
2. • Longest Common Prefix Array (Kasai Algorithm): Find longest common prefix array of a string S with the help of suffix array based on Kasai algorithm - O(n) , n = |S|
3. • Longest Palindromic Substring - (O(n)) (Đang cập nhật)
4. • Pattern Search - O(log(n)) (Đang cập nhật)

C) Searching and Graph Algorithms

❄️ Graph Theory

1. • Graph Representation using Adjacency List: Unweighted, Un-/Directed: Create a Unweighted Un-/Directed Graph using Adjacency List
2. • Graph Representation using Adjacency List: Weighted, Un-/Directed (Đang cập nhật)
3. • Find All Nodes: Find All Nodes in the Unweighted Graph - O(V+E) for Adjacency List , V, E is the number of vertices and edges
4. • Find All Edges (Đang cập nhật)
5. • Find All Paths between 2 Nodes: Find All Paths between 2 Nodes in a Unweighted Graph using BFS - NP-Hard
6. • Disjoint Set (Union-Find): Union by Rank and Path Compression: Create a Disjoint Set (Union-Find) using "Union by Rank and Path Compression" for an Undirected Graph (used to Detect Cycle) - Time = O(small constant), Space = O(V)

♻️ Detect Cycle

7. • Detect Cycle: Disjoint Set: Detect Cycle in an Undirected Graph based on Disjoint Set (Union-Find) using "Union by Rank and Path Compression" - O(V)

✈️ Graph Traversal

8. • Breadth-First Search: Find BFS Path from a Starting Node in Un-/Directed Graph - O(V+E) for Adjacency List; O(V²) for Adjacency Matrix , V, E is the number of vertices and edges
9. • Depth-First Search: Find DFS Path from a Starting Node in Un-/Directed Graph - O(V+E) for Adjacency List; O(V²) for Adjacency Matrix , V, E is the number of vertices and edges

☘️ Minimum Spanning Tree (MST)

10. • MST: Prim Algorithm^[PDF]: Find Minimum Spanning Tree (MST) of an Undirected Graph using Prim Algorithm - O(E.log(V))
11. • MST: Kruskal Algorithm^[PDF]: Find Minimum Spanning Tree (MST) of an Undirected Graph using Kruskal Algorithm - O(E.log(E)) or O(E.log(V))

🛴 Shortest Path

Type of Algorithm	Subjects of Application	Time Complexity
Breadth-First Search	Unweighted, Un-/Directed Graph	O(V+E) for Adjacency List
Dijkstra	Non-Negative Un-/Weighted Un-/Directed Graph	O(E.log(V)) for Min-priority Queue
Bellman-Ford
Floyd-Warshall

12. • Shortest Path: Breadth-First Search: Find the Shortest Path in a Unweighted Un-/Directed Graph based on BFS - O(V+E) for Adjacency List , V, E is the number of vertices and edges
13. • Shortest Path: Dijkstra using Min-Heap^[PDF]: Find Shortest Path of an Non-Negative Un-/Weighted Un-/Directed Graph based on Dijkstra Algorithm using Min-Heap - O(E.log(V))
14. • Shortest Path: Bellman-Ford (Đang cập nhật)
15. • Shortest Path: Floyd-Warshall (Đang cập nhật)

D) Greedy Algorithm

1. Sherlock and The Beast

• Find the "Decent Number" having n Digits ("Decent Number" has its digits to be only 3's and/or 5's; the number of 3's it contains is divisible by 5; the number of 5's it contains is divisible by 3; and it is the largest such number for its length)

2. Largest Permutation

• Swap 2 digits of a number k times to get largest number - O(n)

E) Dynamic Programming

Coin Change Algorithms: Given an array of choices, every choice is picked unlimited times

Knapsack Problems: Given an array of choices, every choice is picked only once

💰 Coin Change Algorithms

1. • Coin Change^[PDF]: How many ways to pay V money using C coins [C1,C2,...Cn] - O(C.V)
2. • Integer Partition^[PDF]: How many ways to partition number N using [1,2,...N] numbers - O(n^1.5)
3. • Minimum Coin Change^[Wiki]: Find Minimum Number of Coins to pay V money using C coins [C1,C2,...,Cn] - O(C.V)

👜 Knapsack Problems

4. • Knapsack 0/1^[Wiki]: Given a List of Weights associated with their Values, find the Founding Weights and Maximum Total Value attained with its Total Weight <= Given Total Weight, each Weight is only picked once (0/1 Rule) - O(N.W) , N, W is length of weights array and given total weight
5. • Partition Problem: Subset Sum^[Wiki]: Given an Array containing only Positive Integers, find if it can be Partitioned into 2 Subsets having Sum of elements in both subsets is Equal. - O(N.T) , N, T is the length of numbers array and the target sum (=sum/2)
6. • Partition Problem: Multiway Number Partitioning^[Wiki]: Đang cập nhật

📈 Path Sum Problems

7. • Max Path Sum Triangle^[PDF]: Find Maximum Path Sum from Top to Bottom of a Triangle - O(R) , R is number of rows of the triangle
8. • Min Path Sum Matrix: Top-Left to Right-Bottom, Right and Down Moves^[PDF]: Find Min Path Sum from Top-Left to Right-Bottom of a Matrix using Right and Down Moves - O(R.C) , R, C is length of row and column of the matrix

Subsequence = Any subset of an array/string

Subarray = Contiguous subsequence of an array

Substring = Contiguous subsequence of a string

📅 Subarray Problems

9. • Max Subarray Sum (Kadane Algorithm)^[PDF]: Find Maximum Subarray Sum of an Array - O(n)
10. • Max Subarray Sum (Kadane Algorithm - Extended)^[PDF]: Find Maximum Subarray Sum of an Array and its Indices - O(n)
11. • Min Subarray Sum (Kadane Algorithm's Min Varient): Find Minimum Subarray Sum of an Array - O(n)
12. • Subarray Sum Equals K^[Leetcode]: Find the Number of Continuous Subarrays of an Array whose Sum Equals to K - O(n)
13. • Subarray Sum Divisible by K^[Leetcode]: Find the Number of Continuous Subarrays of an Array whose Sum is Divisible by K - O(n)

🍡 Subsequence Problems

14. • Longest Common Subsequence (LCS)^[PDF]: Find the longest string S, every character in S is also in S1 and S2 but in order - O(|S1|.|S2|)
15. • Longest Increasing/Decreasing Subsequence (Patience Sorting Algorithm)^[PDF]: Find the Longest Increasing or Decreasing Subsequence of an Array List based on Patience Sorting Algorithm- O(n.log(n))

📃 Substring Problems

16. • Longest Common Substring (Longest Common Factor - LCF): Find the Longest Common Substring (Factor) of 2 strings S1 and S2 - O(|S1|.|S2|)
17. • Sum Of Substrings^[PDF]: Find Sum of All Substrings of an Number String S - O(|S|)

F) Mathematics

📘 Binomial Coefficient Problems

1. • Pascal Triangle: Create Pascal Triangle (to Calculate Multiple Large-Number Combinations) - O(n²)
2. • PE #15: Lattice Paths^[PDF] : Find the number of routes from the top left corner to the bottom right corner in a rectangular grid

📕 Factors Problems

3. • Factorization: Find All Factors of a Number - O(n^1/2)

📗 Multiples Problems

4. • PE #1: Multiples of 3 and 5^[PDF]: Find Sum of Multiples of a Number - O(1)

📓 Permutation Problems

5. • Lexicographic Permutations^[PDF]: Find n-th Lexicographic Permutation of a very long Word - O(n)
6. • Permutation Check: Check if 2 Numbers/Strings are Permutations - O(n) , n = max(|a|,|b|)

📙 Primes Problems

7. • "Sieve Method" All Primes: Find All Primes < n - O(n^1/2)
8. • Primality Test (Common Method): Check if n is a Prime Number using "Common Method" - O(n^1/2)
9. • Primality Test (Miller-Rabin): Check if n is a Prime Number using Miller-Rabin Probabilistic Test - O(k.log³n) , k = [1,2,...]
10. • Coprimes Check: Check if 2 Numbers are Coprime - O(log a.b)

📔 Primes-Factors Problems

11. • Euler Totient Function (Number List): Find ALL Numbers of Coprimes < n based on Euler Totient Function - O((l) + m.loglogm + l.(logm + k)) , k is the number of prime factors of n; m and l is max value and length of the input number list
12. • Euler Totient Function (Single Number): Find the Number of Coprimes < n based on Euler Totient Function - O(n^1/2 + k) , k is the number of prime factors of the input number n
13. • "Sieve Method" Smallest Prime Factors (SPF): Find Smallest Prime Factors for All Numbers < N - O(n.loglogn)
14. • Prime Factorization (Smallest Prime Factor): Find All Prime Factors of a Number using Smallest Prime Factor (SPF) - O(log n) if a list of all Smallest Prime Factors from 0 to n available
15. • Prime Factorization: Find All Prime Factors of a Number - O(n^1/2)

📒 Pythagorean Theorem

16. • Pythagorean Triplets Perimeter: Find Pythagorean Triplets having Perimeter (or Sum) P - O(P)
17. • Pythagorean Triplets Less or Equal N: Generate all Pythagorean Triplets <= N - O(N.log(N))

📖 Non-categorized

18. • Number Spiral Diagonals^[PDF]: Find Sum of Diagonals of Ulam Spiral Matrix

Recursion Algorithm

Backtracking

Divide and Conquer