wesley-a-leung / resources Goto Github PK

Data Structures, Algorithms, Utility Classes for Competitive Programming, Codeforces: https://codeforces.com/profile/wleung_bvg, AtCoder: https://atcoder.jp/users/wleung_bvg, DMOJ: https://dmoj.ca/user/wleung_bvg

License: Creative Commons Zero v1.0 Universal

Java 0.60% C++ 98.78% Kotlin 0.32% Python 0.20% Shell 0.10%

competitive-programming data-structures algorithms icpc codeforces atcoder dmoj

resources's Introduction

Resources

Data Structures, Algorithms, Utility Classes

C++ Resources compile with g++-10 in C++11, C++14, C++17, and C++20 on Ubuntu and Windows
Java Resources compile in Java 8, Java 11
Kotlin Resources compile in Kotlin 1.5

Licensing

most files are covered under LICENSE.txt (Creative Commons Zero 1.0), with certain files being covered under a different license, which are listed below, and stated at the top of those files with the license files also being provided in their folders

Apache License 2.0

Content/C++/string/SAISSuffixArray.h LICENSE

GNU General Public License 3.0

Content/C++/graph/other/MaximumClique.h LICENSE

Style Guidelines

79 character line limit unless the line contains the string http
2 spaces for indentation
very compressed coding style to reduce wasted space in PDF, with multiple statements on a single line
if, else, for, while, etc ... statements should either be immediately followed by a single statement and a newline, a block wrapped in curly braces followed by a newline, a curly brace and a newline, or only a newline
short functions and blocks can be squeezed onto a single line wrapped in curly braces
all lines should end in \n
important variables and constants should be completely capitalized, classes and filename should be upper camel case, other variables and functions should be lower camel case, unless it is to match C++ STL conventions
otherwise mostly adheres to Google's Style Guide
templates should either be a standalone function, or a struct/class
functions and classes should have generic types if possible
classes should have constant parameters passed as template parameters if possible, variable parameters should be passed in the constructor
classes and functions should have a quick summary, specify conventions used, descriptions of template parameters, constructor arguments, member functions and fields, mention the constant factor (roughly) relative to its advertised time complexity, time complexity and memory complexity, and specify where it was tested
constant factors (very small, small, moderate, large, very large) roughly differ by factors of 10
if template parameters are non-trivial, those should be described as well, possibly with an example provided
std::vector is preferred over fixed-sized arrays and std::string, use std::vector::reserve if possible
the new operator should be avoided and memory should be allocated on the stack, or std::unique_ptr should be used

resources's People

Contributors

Stargazers

Watchers

Forkers

carson-tang thomas-li-dev kiritofeng pidddgy minhtamphan zecookiez plasmatic1 goatgirl98 austin-zeng

resources's Issues

Minimum Edit Distance

Implement Minimum Edit Distance Algorithm

Schönhage–Strassen Algorithm

Implement Schönhage–Strassen algorithm for fast multiplication

Add DP Problems from ICS4U

Deque

Implement Deque Data Structure

Segment Tree 2D

Implement 2D Segment Tree

DataInputStream Reader

Improve performance of DataInputStreamReader

Segment Tree

Implement New Segment Tree Class with Lazy Propagation and Reversions

Sorting methods

Implement sorting methods for lists and comparators

C++ Utility Classes

Implement Utility Classes in C++

Heaps

Add Binomial Heaps, Multiway Heaps
Add Max varients

Minimum Arborescence

Implement Minimum Arborescence Algorithm

Fix Removable Graphs

Implement adj using Bags
Implement removed using HashSets
Restore Edges method
Restore Single Edge method
Remove Vertex method
Restore Verticies method
Restore Single Vertex method
Fix edges counter

Linear Time Sorting Algorithms

Implement Counting Sort, Radix Sort, and Bucket Sort

Bidirectional Breadth First Paths and Directed Paths

Implement Bidirectional Breadth First Paths and Directed Paths algorithms

Link Cut Tree

Implement Link Cut Tree Data Structure

Gauss-Jordan Elimination

Implement Gauss-Jordan Elimination algorithm (or Gaussian Elimination because more efficient)

Treap

Implement Treap Data Structure

Segment Tree

Implement Segment Tree Data Structure

Matrix

Implement Matrix Data Structure

Binary Search Methods

Implement Binary search for lists, include upper bound, lower bound, and equals range

Mo

Implement Mo's Algorithm

Sliding Range Query, Maximum Subarray

Add Sliding Range Minimum/Maximum Query link
Add Maximum Subarray Sum of Size K link
Add Maximum Subarray Sum of Size K or Less DMPG15S5 - Pizza Problem

Dinic Max Flow

Implement Dinic Max Flow Algorithm with Link Cut Tree

TimSort

Implement TimSort algorithm

AVL and Red Black Tree Sets

Implement AVL and Red Black Tree Sets

Range Update Fenwick Tree

Implement Fenwick Tree with Range Update

Fibonacci Heap

Implement Fibonacci Heap Data Structure

Shortest Path Faster Algorithm

Implement SPFA

Half Plane Intersection

Implement Half Plane Intersection Algorithm

Skip List

Implement Skip List Class based on link

Tarjan Offline Least Common Ancestor

Implement Tarjan's Offline Least Common Ancestor

Dynamic MST

Implement Online Dynamic MST Algorithm

Egg Dropping Problem

Add Egg Dropping DP Algorithm

Point3D

Implement 3D Point Class

Critical Path Method

Implement CPM

Quick Select

Implement Quick Select Algorithm

Prefix Sum Array 2D and Suffix Sum Array 2D

Implement 2D variants of Prefix and Suffix Sum Arrays

Suffix Arrays

Add Suffix Arrays Class

Yen K Shortest Path

Implement Yen's K Shortest Path Algorithm
Pseudo-code:

function YenKSP(Graph, source, sink, K):
   // Determine the shortest path from the source to the sink.
   A[0] = Dijkstra(Graph, source, sink);
   // Initialize the heap to store the potential kth shortest path.
   B = [];
   
   for k from 1 to K:
       // The spur node ranges from the first node to the next to last node in the previous k-shortest path.
       for i from 0 to size(A[k − 1]) − 1:
           
           // Spur node is retrieved from the previous k-shortest path, k − 1.
           spurNode = A[k-1].node(i);
           // The sequence of nodes from the source to the spur node of the previous k-shortest path.
           rootPath = A[k-1].nodes(0, i);
           
           for each path p in A:
               if rootPath == p.nodes(0, i):
                   // Remove the links that are part of the previous shortest paths which share the same root path.
                   remove p.edge(i,i + 1) from Graph;
           
           for each node rootPathNode in rootPath except spurNode:
               remove rootPathNode from Graph;
           
           // Calculate the spur path from the spur node to the sink.
           spurPath = Dijkstra(Graph, spurNode, sink);
           
           // Entire path is made up of the root path and spur path.
           totalPath = rootPath + spurPath;
           // Add the potential k-shortest path to the heap.
           B.append(totalPath);
           
           // Add back the edges and nodes that were removed from the graph.
           restore edges to Graph;
           restore nodes in rootPath to Graph;
                   
       if B is empty:
           // This handles the case of there being no spur paths, or no spur paths left.
           // This could happen if the spur paths have already been exhausted (added to A), 
           // or there are no spur paths at all - such as when both the source and sink vertices 
           // lie along a "dead end".
           break;
       // Sort the potential k-shortest paths by cost.
       B.sort();
       // Add the lowest cost path becomes the k-shortest path.
       A[k] = B[0];
       B.pop();
   
   return A;