diff --git a/algorithms/geometry/convex_hull.cpp b/algorithms/geometry/convex_hull.cpp
index 0ebd65e112fd545d90d8c13d9d313b97e92f0461..8929b85df0159ee60724a5a0ebac2d018f288f1f 100644
--- a/algorithms/geometry/convex_hull.cpp
+++ b/algorithms/geometry/convex_hull.cpp
@@ -7,16 +7,20 @@
typedef pair<double,double> dd;
-
-// The three points are a counter-clockwise turn if cross > 0, clockwise if
-// cross < 0, and collinear if cross = 0
+/**
+ * The three points are a counter-clockwise turn if cross > 0, clockwise if
+ * cross < 0, and collinear if cross = 0
+ * @param a,b,c input points
+ */
double cross(dd a, dd b, dd c) {
return (b.fi - a.fi) * (c.se - a.se) - (b.se - a.se) * (c.fi - a.fi);
}
-
-// Find, among v, the points that form a convex hull
-int convex_hull(vector<dd> &v) {
+/**
+ * Finds, among v, the points that form a convex hull
+ * @param v vector of points
+ */
+int convex_hull(const vector<dd> &v) {
int k = 0;
vector<int> ans(v.sz * 2);
@@ -47,6 +51,6 @@ int convex_hull(vector<dd> &v) {
sort(all(ans));
ans.erase(unique(all(ans)), ans.end());
- // Returns amount of point in the convex hull
+ // Return number of points in the convex hull
return k - 1;
}
diff --git a/algorithms/graph/articulations_bridges.cpp b/algorithms/graph/articulations_bridges.cpp
index a2b780ac9d9f615d5198910876fe8d4b706b0286..e3a6c69800c4da2b1f86405a56d5d209d798f33c 100644
--- a/algorithms/graph/articulations_bridges.cpp
+++ b/algorithms/graph/articulations_bridges.cpp
@@ -16,8 +16,10 @@ vector<ii> bridges;
// Answer vector with articulations (vertices)
vector<int> articulations;
-
-// Finds all articulations and bridges in the graph
+/**
+ * Finds all articulations and bridges in the graph.
+ * @param x root vertex
+ */
void dfs(int x) {
int child = 0;
cont[x] = 1;
@@ -43,11 +45,13 @@ void dfs(int x) {
}
}
-
-// Applies tarjan algorithm and format articulations vector
-void tarjan(int v) {
+/**
+ * Applies tarjan algorithm and format articulations vector.
+ * @param x root vertex
+ */
+void tarjan(int x) {
mset(parent, -1);
- dfs(v);
+ dfs(x);
// Remove duplicates for articulations
sort(all(articulations));
diff --git a/algorithms/graph/bellman_ford.cpp b/algorithms/graph/bellman_ford.cpp
index d8a3e1d148bda0acfdb6d25cc11267d9239ef850..f512b2ced604124612bfe96b7aa05cb5f86277b3 100644
--- a/algorithms/graph/bellman_ford.cpp
+++ b/algorithms/graph/bellman_ford.cpp
@@ -5,15 +5,17 @@
* Complexity (Space): O(V + E)
*/
-struct edge {
- int u, v, w;
-};
+struct edge { int u, v, w; };
int dist[MAX];
vector<edge> graph;
-// Returns distance between s and d in a graph with V vertices
-// using bellman_ford
+/**
+ * Returns distance between s and d in a graph with V vertices
+ * using bellman_ford.
+ * @param s,d origin and destination vertices
+ * @param V number of vertices
+ */
int bellman_ford(int s, int d, int V) {
mset(dist, inf);
dist[s] = 0;
diff --git a/algorithms/graph/bfs.cpp b/algorithms/graph/bfs.cpp
index 2317e9a3c3c98820ba0157edddadbbd913f9f486..e7bfa631c6d8a70485a80588b9af838cbdff71c6 100644
--- a/algorithms/graph/bfs.cpp
+++ b/algorithms/graph/bfs.cpp
@@ -8,6 +8,10 @@
bool cont[MAX];
vector<int> graph[MAX];
+/**
+ * Applies BFS on graph.
+ * @param x starting vertex
+ */
void bfs(int x) {
queue<int> Q;
diff --git a/algorithms/graph/bipartite_match.cpp b/algorithms/graph/bipartite_match.cpp
index d77b0d3243e68ac4a06b133b45740cb412f599f5..b04c34746354e3bd5335b7357e06732e786579f9 100644
--- a/algorithms/graph/bipartite_match.cpp
+++ b/algorithms/graph/bipartite_match.cpp
@@ -8,7 +8,10 @@
vector<int> graph[MAX];
int cont[MAX], match[MAX];
-// Find match for x
+/**
+ * Finds match for x.
+ * @param x starting vertex
+ */
int dfs(int x) {
if (cont[x])
return 0;
@@ -23,14 +26,17 @@ int dfs(int x) {
return 0;
}
-// Returns number of left elements in matching and fills match array with the
-// match itself (match[right_i] = left_i)
+/**
+ * Returns number of left elements in matching and fills match array with the
+ * match itself (match[right_i] = left_i).
+ * @param n number of vertices on the left
+ */
int bipartite_matching(int n) {
int ans = 0;
- memset(match, -1, sizeof match);
+ mset(match, -1);
for (int i = 0; i < n; ++i) {
- memset(cont, 0, sizeof cont);
+ mset(cont, 0);
ans += dfs(i);
}
diff --git a/algorithms/graph/dfs.cpp b/algorithms/graph/dfs.cpp
index 1dd2da5adccc36bb5f446f8b2633de49b44b132e..1e6b06754fa96be11ea55cde1d88e2b8b6a31910 100644
--- a/algorithms/graph/dfs.cpp
+++ b/algorithms/graph/dfs.cpp
@@ -8,6 +8,10 @@
bool cont[MAX];
vector<int> graph[MAX];
+/**
+ * Applies DFS on graph.
+ * @param x starting vertex
+ */
void dfs(int x) {
cont[x] = true;
for (auto i : graph[x])
diff --git a/algorithms/graph/dijkstra.cpp b/algorithms/graph/dijkstra.cpp
index 8b86c90950d348d1a8677081754555d61ab48cbe..510c31c1d9ac1e365ac9534d1931ab225ebd7a26 100644
--- a/algorithms/graph/dijkstra.cpp
+++ b/algorithms/graph/dijkstra.cpp
@@ -8,15 +8,18 @@
int dist[MAX];
vector<ii> graph[MAX];
-// Get shortest distance from o to d
-int dijkstra(int o, int d) {
+/**
+ * Returns shortest distance from s to d
+ * @param s,d origin and destination vertices
+ */
+int dijkstra(int s, int d) {
set<ii> pq;
int u, v, wt;
mset(dist, inf);
- dist[o] = 0;
- pq.insert(ii(0, o));
+ dist[s] = 0;
+ pq.insert(ii(0, s));
while (pq.size() != 0) {
u = pq.begin()->second;
@@ -26,7 +29,11 @@ int dijkstra(int o, int d) {
v = i.first;
wt = i.second;
+ // If the distance to v can be improved from d, improve it
if (dist[v] > dist[u] + wt) {
+
+ // Erase v from pq, because the distance was updated, if
+ // the distance is inf, then v is not on pq
if (dist[v] != inf)
pq.erase(pq.find(ii(dist[v], v)));
diff --git a/algorithms/graph/dinic.cpp b/algorithms/graph/dinic.cpp
index 82d9fd657ad5518778d92fc67f6f399a79aae147..38d6078f5bb8841eb2f9c1687f440360a4289c26 100644
--- a/algorithms/graph/dinic.cpp
+++ b/algorithms/graph/dinic.cpp
@@ -6,7 +6,7 @@
*/
// Edge struct to be used in adjacency list similar to vector<ii> graph[MAX],
-// but storing more information than ii
+// but storing more information than ii.
struct edge {
int u;
int flow, cap;
@@ -19,13 +19,15 @@ struct edge {
{}
};
-
int depth[MAX];
int start[MAX];
vector<edge> graph[MAX];
-
-// Adds edge between s and t with capacity c
+/**
+ * Adds edge to the graph.
+ * @param s,t origin and destination of edge
+ * @param c capacity of edge
+ */
void add_edge(int s, int t, int c) {
edge forward(t, 0, c, graph[t].size());
edge backward(s, 0, 0, graph[s].size());
@@ -34,9 +36,11 @@ void add_edge(int s, int t, int c) {
graph[t].pb(backward);
}
-
-// Calculates depth of each vertex from source, considering only
-// edges with remaining capacity
+/**
+ * Calculates depth of each vertex from source, considering only
+ * edges with remaining capacity.
+ * @param s,t source and sink of flow graph
+ */
bool bfs(int s, int t) {
queue<int> Q;
Q.push(s);
@@ -58,8 +62,11 @@ bool bfs(int s, int t) {
return depth[t] != -1;
}
-
-// Finds bottleneck flow and add to the edges belonging to the paths found
+/**
+ * Finds bottleneck flow and add to the edges belonging to the paths found.
+ * @param s,t source and sink of flow graph
+ * @param flow minimum flow so far
+ */
int dfs(int s, int t, int flow) {
if (s == t)
return flow;
@@ -84,8 +91,10 @@ int dfs(int s, int t, int flow) {
return 0;
}
-
-// Returns maximum flow between s and t
+/**
+ * Returns maximum flow.
+ * @param s,t source and sink of flow graph
+ */
int dinic(int s, int t) {
int ans = 0;
diff --git a/algorithms/graph/edmonds_karp.cpp b/algorithms/graph/edmonds_karp.cpp
index 12262903ee3749df32e1e18593106e345079eeec..5e3243fb9d4dd5dd12f677481c667bbebb4dcfbf 100644
--- a/algorithms/graph/edmonds_karp.cpp
+++ b/algorithms/graph/edmonds_karp.cpp
@@ -11,8 +11,11 @@ int graph[MAX][MAX], rg[MAX][MAX];
bool cont[MAX];
-// Finds if there's a path between s and t using non-full
-// residual edges
+/**
+ * Finds if there's a path between s and t using non-full
+ * residual edges.
+ * @param s,t source and sink of flow graph
+ */
bool bfs(int s, int t) {
queue<int> Q;
Q.push(s);
@@ -21,6 +24,7 @@ bool bfs(int s, int t) {
while (!Q.empty()) {
int u = Q.front(); Q.pop();
+ // Sink was found, there is a path
if (u == t)
return true;
@@ -35,8 +39,10 @@ bool bfs(int s, int t) {
return false;
}
-
-// Returns maximum flow between s (source) and t (sink)
+/**
+ * Returns maximum flow.
+ * @param s,t source and sink of flow graph
+ */
int edmonds_karp(int s, int t) {
int ans = 0;
par[s] = -1;
diff --git a/algorithms/graph/floyd_warshall.cpp b/algorithms/graph/floyd_warshall.cpp
index 8774a58b8600768354fe335410ba782489d05f3e..5fbe5916b60d8da7bab5e9e53a7b248138749d57 100644
--- a/algorithms/graph/floyd_warshall.cpp
+++ b/algorithms/graph/floyd_warshall.cpp
@@ -8,7 +8,10 @@
int dist[MAX][MAX];
int graph[MAX][MAX];
-// Build dist matrix
+/**
+ * Computes shortest path between all pairs of vertices.
+ * @param n number of vertices
+ */
int floyd_warshall(int n) {
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j)
@@ -17,6 +20,5 @@ int floyd_warshall(int n) {
for (int k = 0; k < n; ++k)
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j)
- if (dist[i][k] + dist[k][j] < dist[i][j])
- dist[i][j] = dist[i][k] + dist[k][j];
+ dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j])
}
diff --git a/algorithms/graph/ford_fulkerson.cpp b/algorithms/graph/ford_fulkerson.cpp
index 5e9eee51bcd9b16d1b1276a3aa5582719710f73b..3930726d56f9ae7f744fcb4353b6cb73f95c40a5 100644
--- a/algorithms/graph/ford_fulkerson.cpp
+++ b/algorithms/graph/ford_fulkerson.cpp
@@ -11,8 +11,11 @@ int graph[MAX][MAX], rg[MAX][MAX];
bool cont[MAX];
-// Finds if there's a path between s and t using non-full
-// residual edges
+/**
+ * Finds if there's a path between s and t using non-full
+ * residual edges.
+ * @param s,t source and sink of flow graph
+ */
bool dfs(int s, int t) {
cont[s] = true;
if (s == t)
@@ -29,8 +32,10 @@ bool dfs(int s, int t) {
return false;
}
-
-// Returns maximum flow between s (source) and t (sink)
+/**
+ * Returns maximum flow.
+ * @param s,t source and sink of flow graph
+ */
int ford_fulkerson(int s, int t) {
int ans = 0;
par[s] = -1;
diff --git a/algorithms/graph/hopcroft_karp.cpp b/algorithms/graph/hopcroft_karp.cpp
index ec36bac173b05185a655c631b6fee0b58d02b972..d82719154d255b1f089ed88a4795d058bf4ac8e0 100644
--- a/algorithms/graph/hopcroft_karp.cpp
+++ b/algorithms/graph/hopcroft_karp.cpp
@@ -10,9 +10,12 @@ int matchL[MAX], matchR[MAX];
vector<int> graph[MAX];
-// Builds an alternating level graph rooted at unmatched vertices in L
-// using BFS, and returns whether there is an augmenting path in the graph
-// or not
+/**
+ * Builds an alternating level graph rooted at unmatched vertices in L
+ * using BFS, and returns whether there is an augmenting path in the graph
+ * or not.
+ * @param n number of vertices on the left
+ */
bool bfs(int n) {
queue<int> Q;
@@ -40,9 +43,11 @@ bool bfs(int n) {
return (dist[0] != inf);
}
-
-// Augments path starting in l if there is one, returns
-// whether a path was augmented or not
+/**
+ * Augments path starting in l if there is one, returns
+ * whether a path was augmented or not.
+ * @param l initial free vertex on the left
+ */
bool dfs(int l) {
if (l == 0)
return true;
@@ -62,8 +67,10 @@ bool dfs(int l) {
return false;
}
-
-// Returns number of matched vertices on the left (matched edges)
+/**
+ * Returns number of matched vertices on the left (matched edges).
+ * @param n number of vertices on the left
+ */
int hopcroft_karp(int n) {
mset(matchL, 0);
mset(matchR, 0);
diff --git a/algorithms/graph/kosaraju.cpp b/algorithms/graph/kosaraju.cpp
index 486883b7eab72ca5442dc29d35c28a24d9ab1f64..3a789e9df7e056cd882b0d969eaa75259a3fbd28 100644
--- a/algorithms/graph/kosaraju.cpp
+++ b/algorithms/graph/kosaraju.cpp
@@ -11,7 +11,10 @@ vector<int> transp[MAX];
bool cont[MAX];
-// Traverse a SCC
+/**
+ * Traverses a SCC.
+ * @param x initial vertex
+ */
void dfs(int x) {
// x belong to current scc
cont[x] = true;
@@ -21,8 +24,10 @@ void dfs(int x) {
dfs(i);
}
-
-// Fill stack with DFS starting points to find SCC
+/**
+ * Fills stack with DFS starting points to find SCC.
+ * @param x initial vertex
+ */
void fill_stack(int x) {
cont[x] = true;
@@ -33,12 +38,14 @@ void fill_stack(int x) {
S.push(x);
}
-
-// Return number of SCC of a graph with n vertices
+/**
+ * Returns number of SCC of a graph.
+ * @param n number of vertices
+ */
int kosaraju(int n) {
int scc = 0;
- memset(cont, 0, sizeof cont);
+ mset(cont, 0);
for (int i = 0; i < n; ++i)
if (!cont[i])
fill_stack(i);
@@ -49,7 +56,7 @@ int kosaraju(int n) {
transp[j].push_back(i);
// Count SCC
- memset(cont, 0, sizeof cont);
+ mset(cont, 0);
while (!S.empty()) {
int v = S.top();
S.pop();
diff --git a/algorithms/graph/kruskal.cpp b/algorithms/graph/kruskal.cpp
index d6b05e0e8c4604dbaa8373bb8b5a6eb0d578b3a0..bda5b7eb13268524afa5d7ce465dc35395650de1 100644
--- a/algorithms/graph/kruskal.cpp
+++ b/algorithms/graph/kruskal.cpp
@@ -9,11 +9,16 @@
* OBS: * = return maximum spanning tree
*/
-vector<iii> mst; // Result
+typedef pair<ii,int> iii;
vector<iii> edges;
-// Return value of MST and build mst vector with edges that belong to the tree
-int kruskal() {
+/**
+ * Returns value of MST.
+ * @param mst[out] vector with edges of computed MST
+ */
+int kruskal(vector<iii> &mst) {
+
+ // Sort by weight of the edges
sort(all(edges), [&](const iii &a, const iii &b) {
return a.se < b.se;
//* return a.se > b.se
@@ -27,6 +32,7 @@ int kruskal() {
int pu = find_set(edges[i].fi.fi);
int pv = find_set(edges[i].fi.se);
+ // If the sets are different, then the edge i does not close a cycle
if (pu != pv) {
mst.pb(edges[i]);
size += edges[i].se;
diff --git a/algorithms/graph/lca.cpp b/algorithms/graph/lca.cpp
index 6bfb144c8cbedf4cbd0dee609db2b436878ef997..0d638e94f6e019b8a96d0d6ab5d58f545c4910ae 100644
--- a/algorithms/graph/lca.cpp
+++ b/algorithms/graph/lca.cpp
@@ -19,7 +19,10 @@ int h[MAX];
int par[MAX][MAXLOG];
//*** int cost[MAX][MAXLOG];
-// Perform DFS while filling h, par, and cost
+/**
+ * Performs DFS while filling h, par, and cost.
+ * @param v root of the tree
+ */
void dfs(int v, int p = -1, int c = 0) {
par[v][0] = p;
//*** cost[v][0] = c;
@@ -39,16 +42,20 @@ void dfs(int v, int p = -1, int c = 0) {
dfs(u.fi, v, u.se);
}
-
-// Preprocess tree rooted at v
+/**
+ * Preprocess tree.
+ * @param v root of the tree
+ */
void preprocess(int v) {
mset(par, -1);
//*** mset(cost, 0;
dfs(v);
}
-
-// Return LCA (or sum or max) between p and q
+/**
+ * Returns LCA (or sum or max).
+ * @param p,q query nodes
+ */
int query(int p, int q) {
//*** int ans = 0;
@@ -73,11 +80,11 @@ int query(int p, int q) {
q = par[q][i];
}
- return par[p][0];
-
//* if (p == q) return ans;
//* else return ans + cost[p][0] + cost[q][0];
//** if (p == q) return ans;
//** else return max(ans, max(cost[p][0], cost[q][0]));
+
+ return par[p][0];
}
diff --git a/algorithms/graph/prim.cpp b/algorithms/graph/prim.cpp
index 2270fa3ff9c2484cfaa8a380a41d6f524d30b119..264d509975f7a0676830e966c809f08ec454d0fc 100644
--- a/algorithms/graph/prim.cpp
+++ b/algorithms/graph/prim.cpp
@@ -8,7 +8,9 @@
bool cont[MAX];
vector<ii> graph[MAX];
-// Returns value of MST of graph
+/**
+ * Returns value of MST of graph.
+ */
int prim() {
mset(cont, false);
cont[0] = true;
diff --git a/algorithms/graph/tarjan.cpp b/algorithms/graph/tarjan.cpp
index ede8a49d3753c40bfedfeb7f254c075d286c10bd..dac3ee0c73c88fdd7a93c337d33a98c55a31a302 100644
--- a/algorithms/graph/tarjan.cpp
+++ b/algorithms/graph/tarjan.cpp
@@ -13,7 +13,10 @@ int ncomp, ind;
int cont[MAX], parent[MAX];
int low[MAX], L[MAX];
-// Fills SCC with strongly connected components of graph
+/**
+ * Fills SCC with strongly connected components of graph.
+ * @param x any vertex
+ */
void dfs(int x) {
L[x] = ind;
low[x] = ind++;
@@ -39,10 +42,12 @@ void dfs(int x) {
}
}
-
-// Return number of SCCs
+/**
+ * Return number of SCCs.
+ * @param n number of vertices
+ */
int tarjan(int n) {
- memset(L, -1, sizeof L);
+ mset(L, -1);
ncomp = ind = 0;
for (int i = 0; i < n; ++i)
diff --git a/algorithms/graph/topological_sort.cpp b/algorithms/graph/topological_sort.cpp
index 024828dac5f213e95ce0a85c003eef2de228813d..508b30e5cec840471360033beeda5692325b4cc7 100644
--- a/algorithms/graph/topological_sort.cpp
+++ b/algorithms/graph/topological_sort.cpp
@@ -10,7 +10,10 @@ vector<int> graph[MAX];
int cont[MAX];
-// Fill stack and check for cycles
+/**
+ * Fills stack and check for cycles.
+ * @param x any vertex
+ */
bool dfs(int x) {
cont[x] = 1;
@@ -27,9 +30,11 @@ bool dfs(int x) {
return false;
}
-
-// Returns whether graph contains cycle or not, and fills tsort vector with
-// topological sort of the graph
+/**
+ * Returns whether graph contains cycle or not.
+ * @param n number of vertices
+ * @param[out] tsort topological sort of the graph
+ */
bool topological_sort(int n, vector<int> &tsort) {
mset(cont, 0);
diff --git a/algorithms/math/binary_exponentiation.cpp b/algorithms/math/binary_exponentiation.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..58f8b026fd26660801213f607527e3cb95aeb719
--- /dev/null
+++ b/algorithms/math/binary_exponentiation.cpp
@@ -0,0 +1,26 @@
+/**
+ * Binary Exponentiation
+ *
+ * Complexity (Time): O(log n)
+ * Complexity (Space): O(1)
+ */
+
+/**
+ * Returns x^n in O(log n) time
+ * @param x number
+ * @param n exponent
+ */
+template <typename T>
+T fast_pow(T x, ll n) {
+ T ans = 1;
+
+ while (n) {
+ if (n & 1)
+ ans = ans * x;
+
+ n >>= 1;
+ x = x * x;
+ }
+
+ return ans;
+}
diff --git a/algorithms/math/fast_matrix_pow.cpp b/algorithms/math/fast_matrix_pow.cpp
deleted file mode 100644
index 7146188573eae6aeab663e193d70e5f0054d8ee8..0000000000000000000000000000000000000000
--- a/algorithms/math/fast_matrix_pow.cpp
+++ /dev/null
@@ -1,87 +0,0 @@
-/**
- * Fast Matrix Exponentiation
- *
- * Complexity (Time): O(K^3 log n)
- * Complexity (Space): O(K^2)
- */
-
-// This algorithm is used to solve recurrences such as:
-// f(n) = x1 * f(n - 1) + x2 * f(n - 1) + ... + xk * f(n - k)
-//
-// It works by defining this recurrence as a linear combination,
-// for example (k = 2):
-// f(n) = [x1 x2] [f(n - 1)]
-// [f(n - 2)]
-// It can be rewriten as:
-// [ f(n) ] = [x1 x2] [f(n - 1)]
-// [f(n - 1)] [ 1 0] [f(n - 2)]
-//
-// And that is solved by calculating the following matrix power:
-// [x1 x2]^n
-// [ 1 0]
-
-
-#define K 2
-
-struct matrix {
- ll m[K][K];
-
- // Matrix multiplication - O(k^3)
- matrix operator*(matrix a) {
- matrix aux;
-
- for (int i = 0; i < K; i++)
- for (int j = 0; j < K; j++) {
- ll sum = 0;
-
- for (int k = 0; k < K; k++)
- sum += (m[i][k] * a[k][j]) % MOD;
-
- aux[i][j] = sum % MOD;
- }
-
- return aux;
- }
-
- ll *operator[](int i) {
- return m[i];
- }
-
- void clear() {
- mset(m, 0);
- }
-};
-
-
-// Fast exponentiation (can be used with integers as well) - O(log n)
-matrix matrix_pow(matrix in, ll n) {
- matrix ans, b = in;
-
- // Set ans as identity matrix
- ans.clear();
- for (int i = 0; i < K; ++i)
- ans[i][i] = 1;
-
- while (n) {
- if (n & 1)
- ans = ans * b;
-
- n >>= 1;
- b = b * b;
- }
-
- return ans;
-}
-
-
-// Solves f(n) = x * f(n - 1) + y * f(n - 2)
-matrix solve(ll x, ll y, ll n) {
- matrix in;
-
- in[0][0] = x % MOD;
- in[0][1] = y % MOD;
- in[1][0] = 1;
- in[1][1] = 0;
-
- return matrix_pow(in, n);
-}
diff --git a/algorithms/math/linear_recurrence.cpp b/algorithms/math/linear_recurrence.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3235d59c14d0a53368fa5ac19215209b3b04044a
--- /dev/null
+++ b/algorithms/math/linear_recurrence.cpp
@@ -0,0 +1,37 @@
+/**
+ * Linear Recurrence
+ *
+ * Complexity (Time): O(log n)
+ * Complexity (Space): O(1)
+ *
+ * #include "math/binary_exponentiation.cpp"
+ * #include "math/matrix.cpp"
+ */
+
+/**
+ * Solves f(n) = x * f(n - 1) + y * f(n - 2)
+ * This algorithm is used to solve recurrences such as:
+ * f(n) = x1 * f(n - 1) + x2 * f(n - 1) + ... + xk * f(n - k)
+ *
+ * It works by defining this recurrence as a linear combination,
+ * for example (k = 2):
+ * f(n) = [x1 x2] [f(n - 1)]
+ * [f(n - 2)]
+ * It can be rewriten as:
+ * [ f(n) ] = [x1 x2] [f(n - 1)]
+ * [f(n - 1)] [ 1 0] [f(n - 2)]
+ *
+ * And that is solved by calculating the following matrix power:
+ * [x1 x2]^n
+ * [ 1 0]
+ */
+matrix solve(ll x, ll y, ll n) {
+ matrix in(2);
+
+ in[0][0] = x % MOD;
+ in[0][1] = y % MOD;
+ in[1][0] = 1;
+ in[1][1] = 0;
+
+ return fast_pow(in, n);
+}
diff --git a/algorithms/math/matrix.cpp b/algorithms/math/matrix.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ab09b06bc5432ac2c33df522264bcce1c410d724
--- /dev/null
+++ b/algorithms/math/matrix.cpp
@@ -0,0 +1,57 @@
+/**
+ * Matrix
+ */
+
+struct matrix {
+ int r, c;
+ vector<vector<ll>> m;
+
+ matrix(int k) : r(k), c(k) {
+ m = vector<vector<ll>>(k, vector<ll>(k, 0));
+ }
+
+ matrix(int r, int c) : r(r), c(c) {
+ m = vector<vector<ll>>(r, vector<ll>(c, 0));
+ }
+
+ matrix operator*(matrix a) {
+ assert(r == a.c && c = a.r);
+
+ matrix res(r, c);
+ for (int i = 0; i < r; i++)
+ for (int j = 0; j < c; j++) {
+ res[i][j] = 0;
+
+ for (int k = 0; k < c; k++)
+ res[i][j] += m[i][k] * a[k][j];
+ }
+
+ return res;
+ }
+
+ matrix operator+(matrix a) {
+ matrix res(k);
+ for (int i = 0; i < r; ++i)
+ for (int j = 0; j < c; ++j)
+ res[i][j] = m[i][j] + a[i][j];
+
+ return res;
+ }
+
+ void to_identity() {
+ assert(r == c);
+
+ for (auto &i : m)
+ fill(all(i), 0);
+ for (int i = 0; i < r; ++i)
+ m[i][i] = 1;
+ }
+
+ ll *operator[](int i) {
+ return m[i];
+ }
+
+ void clear() {
+ mset(m, 0);
+ }
+};
diff --git a/algorithms/math/modular_multiplicative_inverse.cpp b/algorithms/math/modular_multiplicative_inverse.cpp
index 8a0579850ed78c5de80851fcdfac9877695af39e..1b43fe2b1f908c0154b97a8174fec3811634f7f7 100644
--- a/algorithms/math/modular_multiplicative_inverse.cpp
+++ b/algorithms/math/modular_multiplicative_inverse.cpp
@@ -7,34 +7,22 @@
// ========== Fermat's Little Theorem ==========
// Used when m is prime
+// #include "binary_exponentiation.cpp"
-ll power(ll x, ll y) {
- ll ans = 1;
-
- while (y) {
- if (y & 1)
- ans = (ans * x) % MOD;
-
- y >>= 1;
- x = (x * x) % MOD;
- }
-
- return ans % MOD;
-}
-
-
-// Find x where:
-// a*x === 1 (mod MOD)
+/**
+ * Finds x where: a*x === 1 (mod MOD)
+ */
ll mod_inverse(ll a) {
- return power(a, MOD - 2);
+ return fast_pow(a, MOD - 2);
}
// ========== Extended Euclidean Algorithm ==========
// Used when m and a are coprime
-// return gcd(a, b) and find x, y where:
-// a*x + b*y = gcd(a, b)
+/**
+ * Returns gcd(a, b) and find x, y where: a*x + b*y = gcd(a, b)
+ */
ll gcd_extended(ll a, ll b, ll &x, ll &y) {
if (!a) {
x = 0;
@@ -51,9 +39,9 @@ ll gcd_extended(ll a, ll b, ll &x, ll &y) {
return g;
}
-
-// Find x where:
-// a*x === 1 (mod MOD)
+/**
+ * Finds x where: a*x === 1 (mod MOD)
+ */
ll mod_inverse(ll a) {
ll x, y;
ll g = gcd_extended(a, MOD, x, y);
diff --git a/algorithms/math/sieve_of_eratosthenes.cpp b/algorithms/math/sieve_of_eratosthenes.cpp
index dd3069809d5de7fcc817bc6ac8fc13c7d8588385..8e25be7cb27830c80d277d67fcf4c2be8d7645ec 100644
--- a/algorithms/math/sieve_of_eratosthenes.cpp
+++ b/algorithms/math/sieve_of_eratosthenes.cpp
@@ -5,7 +5,9 @@
* Complexity (Space): O(n)
*/
-// Returns vector of primes less than or equal to n
+/**
+ * Returns vector of primes less than or equal to n
+ */
vector<int> sieve(int n) {
vector<int> primes;
vector<bool> is_prime(n+1, true);
diff --git a/algorithms/paradigm/edit_distance.cpp b/algorithms/paradigm/edit_distance.cpp
index 7f9ef1137a06050805d0f500fb0d58b1731c3a24..a1edb780089d315d478f6e403af32684d9f02720 100644
--- a/algorithms/paradigm/edit_distance.cpp
+++ b/algorithms/paradigm/edit_distance.cpp
@@ -5,12 +5,16 @@
* Complexity (Space): O(m*n)
*/
+int dp[MAX][MAX];
+
+/**
+ * Returns edit distance (Levenshtein distance) between a and b
+ * @param a,b input strings
+ */
int edit_distance(string a, string b) {
int n = a.size();
int m = b.size();
- vector<vector<int>> dp(n+1, vector<int>(m+1));
-
for (int i = 0; i <= n; ++i) {
for (int j = 0; j <= m; ++j) {
if (i == 0)
@@ -20,9 +24,9 @@ int edit_distance(string a, string b) {
else if (a[i-1] == b[j-1])
dp[i][j] = d[i-1][j-1];
else
- dp[i][j] = 1 + min(dp[i][j-1], // Insert
- min(dp[i-1][j], // Remove
- dp[i-1][j-1])); // Replace
+ dp[i][j] = 1 + min({dp[i][j-1], // Insert
+ dp[i-1][j], // Remove
+ dp[i-1][j-1]}); // Replace
}
}
diff --git a/algorithms/paradigm/kadane.cpp b/algorithms/paradigm/kadane.cpp
index dbd4fcdbdb4dfe8d2422ca5d9c709b87345c13b5..b5fba6795af5b2155bdc44d9593b3394679148f3 100644
--- a/algorithms/paradigm/kadane.cpp
+++ b/algorithms/paradigm/kadane.cpp
@@ -5,13 +5,17 @@
* Complexity (Space): O(n + m)
*/
-int v[MAX];
-
-int kadane() {
+/**
+ * Returns the largest sum of a contiguous subarray
+ * @param[in] v input vector
+ * @param[out] start,end start and end index of said subarray
+ */
+int kadane(const vector<int> &v, int &start, int &end) {
// Maximum so far (msf), Maximum ending here (meh).
int msf = -0x3f3f3f3f, meh = 0;
- int start = 0, end = 0, s = 0;
+ int s = 0;
+ start = end = 0;
for (int i = 0; i < n; ++i) {
meh += v[i];
diff --git a/algorithms/paradigm/lis.cpp b/algorithms/paradigm/lis.cpp
index 55b960b2b0a77b48a5846e77fb0117938d9332ff..8c69ed12ab9f70f1cac9dfbb6034da73bdb8f776 100644
--- a/algorithms/paradigm/lis.cpp
+++ b/algorithms/paradigm/lis.cpp
@@ -5,6 +5,10 @@
* Complexity (Space): O(n)
*/
+/**
+ * Returns the length of the longest increasing subsequence
+ * @param v input vector
+ */
int lis(vector<int> v) {
int n = v.size();
diff --git a/algorithms/paradigm/ternary_search.cpp b/algorithms/paradigm/ternary_search.cpp
index f07e7168a0bfab259579fa63e415ceba256c2698..84786526556cba681872d0a25624e03a6aa3e087 100644
--- a/algorithms/paradigm/ternary_search.cpp
+++ b/algorithms/paradigm/ternary_search.cpp
@@ -7,13 +7,17 @@
#define EPS 1e-6
-// Unimodal function
+/**
+ * Unimodal function
+ */
double f(double x) {
return x * x;
}
-
-// Execute ternary search to find maximum or minimum between l and r
+/**
+ * Executes ternary search to find maximum or minimum
+ * @param l,r boundaries of search
+ */
double ternary_search(double l, double r) {
double rt, lt;
diff --git a/algorithms/string/kmp.cpp b/algorithms/string/kmp.cpp
index 741289a15a306cf0a43ca35e53664eccd7d79af3..6158db09b25782b5ce4f1c09b3364231fed9931b 100644
--- a/algorithms/string/kmp.cpp
+++ b/algorithms/string/kmp.cpp
@@ -8,10 +8,12 @@
*/
int table[MAX];
-vector<int> occurs;
-// Build the table where table[i] is the longest prefix of patt[0..i] which is
-// also a sufix of patt[0..i]
+/**
+ * Builds the table where table[i] is the longest prefix of patt[0..i] which is
+ * also a sufix of patt[0..i]
+ * @param patt pattern to be found
+ */
void preprocess(string patt) {
int i = 1, len = 0;
@@ -25,21 +27,28 @@ void preprocess(string patt) {
}
}
-
-// Search for occurrences of patt in txt and add indexes of matches to occurs
+/**
+ * Searches for occurrences of patt in txt and add indexes of matches to occurs
+ * @param patt pattern to be found
+ * @param txt text
+ */
void search(string patt, string txt) {
int i = 0, j = 0;
+ vector<int> occurs;
while (i < txt.size()) {
if (patt[j] == txt[i])
i++, j++;
if (j == patt.size()) {
- occurs.push_back(i - j); // Pattern found at (i - j)
+ // Pattern found at (i - j)
+ occurs.push_back(i - j);
j = table[j - 1];
} else if (i < txt.size() && patt[j] != txt[i]) {
- if (j) j = table[j - 1];
- else i++;
+ if (j > 0)
+ j = table[j - 1];
+ else
+ i++;
}
}
}
diff --git a/algorithms/structure/avl.cpp b/algorithms/structure/avl.cpp
index 97820ac8e741742fbfa609b29ca77e5cd73215b3..0dbff66c05fa9a7a92270f4960e9f2474d59d603 100644
--- a/algorithms/structure/avl.cpp
+++ b/algorithms/structure/avl.cpp
@@ -19,22 +19,30 @@ struct avl_t {
avl_node_t *root;
};
-
-static inline int get_height(avl_node_t *node) {
+/**
+ * Returns height of node.
+ */
+inline int get_height(avl_node_t *node) {
return (node == NULL) ? 0 : node->height;
}
-
-static inline int get_size(avl_node_t *node) {
+/**
+ * Returns size of node.
+ */
+inline int get_size(avl_node_t *node) {
return (node == NULL) ? 0 : node->size;
}
-
-static inline int get_balance(avl_node_t *node) {
+/**
+ * Returns balance of node.
+ */
+inline int get_balance(avl_node_t *node) {
return (node == NULL) ? 0 : get_height(node->left) - get_height(node->right);
}
-
+/**
+ * Rotates node to right.
+ */
avl_node_t *rotate_right(avl_node_t *node) {
avl_node_t *aux1 = node->left;
avl_node_t *aux2 = aux1->right;
@@ -51,7 +59,9 @@ avl_node_t *rotate_right(avl_node_t *node) {
return aux1;
}
-
+/**
+ * Rotates node to left.
+ */
avl_node_t *rotate_left(avl_node_t *node) {
avl_node_t *aux1 = node->right;
avl_node_t *aux2 = aux1->left;
@@ -68,10 +78,13 @@ avl_node_t *rotate_left(avl_node_t *node) {
return aux1;
}
-
-// Insert key in AVL
+/**
+ * Inserts key in AVL and returns new root.
+ */
avl_node_t *avl_insert(avl_t *avl, avl_node_t *node, int key) {
if (node == NULL) {
+
+ // Create new node
avl_node_t *neu = new avl_node_t;
neu->key = key;
@@ -84,6 +97,7 @@ avl_node_t *avl_insert(avl_t *avl, avl_node_t *node, int key) {
return neu;
}
+ // Insert recursively
if (key < node->key)
node->left = avl_insert(avl, node->left, key);
else
@@ -93,6 +107,7 @@ avl_node_t *avl_insert(avl_t *avl, avl_node_t *node, int key) {
node->height = max(get_height(node->left), get_height(node->right)) + 1;
node->size = get_size(node->left) + get_size(node->right) + 1;
+ // Check balance of tree and rotates if necessary
if (balance > 1 && key < node->left->key) {
return rotate_right(node);
} else if (balance < -1 && key > node->right->key) {
diff --git a/algorithms/structure/ball_tree.cpp b/algorithms/structure/ball_tree.cpp
index a515b6f6a1fd3c01781877c78240bd3abdce8784..361a572784fba2b3858d3df9604b19f7d71d761d 100644
--- a/algorithms/structure/ball_tree.cpp
+++ b/algorithms/structure/ball_tree.cpp
@@ -18,13 +18,16 @@ struct node {
node *left, *right;
};
-
+/**
+ * Returns distance between point a and b
+ */
double distance(point &a, point &b) {
return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
}
-
-// Find furthest point from center and returns <distance,index> of that point
+/**
+ * Finds furthest point from center and returns <distance,index> of that point
+ */
pair<double, int> get_radius(point ¢er, pset &ps) {
int ind = 0;
double dist, radius = -1.0;
@@ -41,9 +44,12 @@ pair<double, int> get_radius(point ¢er, pset &ps) {
return pair<double, int>(radius, ind);
}
-
-// Find average point and pretends it's the center of the given set of points
-void get_center(pset &ps, point ¢er) {
+/**
+ * Finds average point and pretends it's the center of the given set of points
+ * @param ps vector of points
+ * @param[out] center center point
+ */
+void get_center(const pset &ps, point ¢er) {
center.x = center.y = 0;
for (auto p : ps) {
@@ -51,15 +57,20 @@ void get_center(pset &ps, point ¢er) {
center.y += p.y;
}
- center.x /= (double)ps.size();
- center.y /= (double)ps.size();
+ center.x /= (double) ps.size();
+ center.y /= (double) ps.size();
}
-
-// Splits the set of points in closer to ps[lind] and closer to ps[rind],
-// where lind is returned by get_radius and rind is the furthest points
-// from ps[lind]
-void partition(pset &ps, pset &left, pset &right, int lind) {
+/**
+ * Splits the set of points in closer to ps[lind] and closer to ps[rind],
+ * where lind is returned by get_radius and rind is the furthest points
+ * from ps[lind]
+ * @param ps vector of points
+ * @param[out] left leftmost point
+ * @param[out] right rightmost point
+ * @param lind index of left point
+ */
+void partition(const pset &ps, pset &left, pset &right, int lind) {
int rind = 0;
double dist, grt = -1.0;
double ldist, rdist;
@@ -94,9 +105,10 @@ void partition(pset &ps, pset &left, pset &right, int lind) {
}
}
-
-// Build ball-tree recursively
-// ps: vector of points
+/**
+ * Builds ball-tree recursively.
+ * @param ps vector of points
+ */
node *build(pset &ps) {
if (ps.size() == 0)
return nullptr;
@@ -127,12 +139,13 @@ node *build(pset &ps) {
return n;
}
-
-// Search the ball-tree recursively
-// n: root
-// t: query point
-// pq: initially empty multiset (will contain the answer after execution)
-// k: number of nearest neighbors
+/**
+ * Search the ball-tree recursively
+ * @param n root
+ * @param t query point
+ * @param pq initially empty multiset (will contain the answer after execution)
+ * @param k number of nearest neighbors
+ */
void search(node *n, point t, multiset<double> &pq, int &k) {
if (n->left == nullptr && n->right == nullptr) {
double dist = distance(t, n->center);
diff --git a/algorithms/structure/bit.cpp b/algorithms/structure/bit.cpp
index 69d3ab1815ba8b14ddd88717ce4c2ec7cd2b407d..35ad665e0ecdd5333e2819f35a3faa6aab33973c 100644
--- a/algorithms/structure/bit.cpp
+++ b/algorithms/structure/bit.cpp
@@ -9,7 +9,9 @@
int tree[MAX];
-// Perform query in array (tree) in the idx position
+/**
+ * Performs query in array (tree) in the idx position.
+ */
int query(int idx) {
int sum = 0;
for (; idx > 0; idx -= (idx & -idx))
@@ -18,8 +20,9 @@ int query(int idx) {
return sum;
}
-
-// Add a value (val) to a single position (idx) in the array (tree).
+/**
+ * Adds a value (val) to a single position (idx) in the array (tree).
+ */
void update(int idx, int val) {
for (; idx <= MAX; idx += (idx & -idx))
tree[idx] += val;
diff --git a/algorithms/structure/bit2d.cpp b/algorithms/structure/bit2d.cpp
index 786faaa2c08f40241d514ee673a0822568d1221b..68dca491c1d5e1188649318ea87b09cf1133f9e8 100644
--- a/algorithms/structure/bit2d.cpp
+++ b/algorithms/structure/bit2d.cpp
@@ -9,7 +9,9 @@
int tree[MAXN][MAXM];
-// Perform query in array (tree) in the (idx,idy) position
+/**
+ * Performs query in array (tree) in the (idx,idy) position.
+ */
int query(int idx, int idy) {
int sum = 0;
for (; idx > 0; idx -= (idx & -idx))
@@ -19,8 +21,9 @@ int query(int idx, int idy) {
return sum;
}
-
-// Add a value (val) to a single position (idx,idy) in the array (tree).
+/**
+ * Adds a value (val) to a single position (idx,idy) in the array (tree).
+ */
void update(int idx, int idy, int val) {
for (; idx <= MAXN; idx += (idx & -idx))
for (int m = idy; m <= MAXM; m += (m & -m))
diff --git a/algorithms/structure/bitmask.cpp b/algorithms/structure/bitmask.cpp
index 7c330630690f52c28f5370c23517de7a754e8507..2ce620293c3610b93af9b0c4b77213b6fc7db481 100644
--- a/algorithms/structure/bitmask.cpp
+++ b/algorithms/structure/bitmask.cpp
@@ -5,43 +5,51 @@
* Complexity (Space): O(1)
*/
-// Set bit in position pos (0 to 1)
+/**
+ * Sets bit in position pos (0 to 1).
+ */
void set(ll &bitmask, int pos) {
bitmask |= (1 << pos);
}
-
-// Set all bits in a bitmask with size n
+/**
+ * Sets all bits in a bitmask with size n.
+ */
void set_all(ll &bitmask, int n) {
bitmask = (1 << n) - 1;
}
-
-// Unset bit in position pos (1 to 0)
+/**
+ * Unsets bit in position pos (1 to 0).
+ */
void unset(ll &bitmask, int pos) {
bitmask &= ~(1 << pos);
}
-
-// Unset all bits
+/**
+ * Unsets all bits.
+ */
void unset_all(ll &bitmask) {
bitmask = 0;
}
-
-// Get value of bit in position pos
+/**
+ * Gets value of bit in position pos.
+ */
int get(ll bitmask, int pos) {
return bitmask & (1 << pos);
}
-
-// Toggle value in position pos
+/**
+ * Toggles value in position pos.
+ */
void toggle(ll &bitmask, int pos) {
bitmask ^= (1 << pos);
}
-
-// Get position of least significant 1
+/**
+ * Gets position of least significant 1.
+ */
int least_significant_one(ll bitmask) {
return bitmask & (-bitmask);
}
diff --git a/algorithms/structure/disjoint_set.cpp b/algorithms/structure/disjoint_set.cpp
index 5b1bd73ef5b8665dfc1f87c7e53148d1696a6c74..d9f943999c96c56bf7781bd43026cba972f2352a 100644
--- a/algorithms/structure/disjoint_set.cpp
+++ b/algorithms/structure/disjoint_set.cpp
@@ -12,23 +12,27 @@ int h[MAX];
int par[MAX];
int size[MAX];
-// Initialize element x
+/**
+ * Initializes element x.
+ */
void make_set(int x) {
par[x] = x;
h[x] = 0;
size[x] = 1;
}
-
-// Return set index from element x
+/**
+ * Returns set index from element x.
+ */
int find_set(int x) {
if (par[x] != x)
par[x] = find_set(par[x]);
return par[x];
}
-
-// Make x and y belong to the same set
+/**
+ * Makes x and y belong to the same set.
+ */
void union_set(int x, int y) {
x = find_set(x);
y = find_set(y);
diff --git a/algorithms/structure/lazy_segment_tree.cpp b/algorithms/structure/lazy_segment_tree.cpp
index 68c279c43974cff396d4fc24fde21ba6b1bab9d6..a159d3f297278d194e1ba64878e030e4def9d856 100644
--- a/algorithms/structure/lazy_segment_tree.cpp
+++ b/algorithms/structure/lazy_segment_tree.cpp
@@ -15,7 +15,9 @@ int tree[4 * MAX], lazy[4 * MAX];
#define left(x) (x << 1)
#define right(x) ((x << 1) + 1)
-// Builds tree with elements from v (0-indexed)
+/**
+ * Builds tree with elements from v (0-indexed).
+ */
void build(int node = 1, int a = 0, int b = N - 1) {
if (a > b)
return;
@@ -30,8 +32,12 @@ void build(int node = 1, int a = 0, int b = N - 1) {
tree[node] = tree[node * 2] + tree[node * 2 + 1];
}
-
-// Propagates value to tree and through lazy tree
+/**
+ * Propagates value to tree and through lazy tree.
+ * @param node node to change
+ * @param a,b range of node
+ * @param val value to be pushed
+ */
void push(int node, int a, int b, int val) {
tree[node] += val;
// tree[node] += (b - a + 1) * val; (for Range Sum Query)
@@ -44,8 +50,11 @@ void push(int node, int a, int b, int val) {
lazy[node] = 0;
}
-
-// Updates segment [i,j] by adding value val
+/**
+ * Updates segment [i,j] by adding value val.
+ * @param i,j range
+ * @param val value to be added
+ */
void update(int i, int j, int val, int node = 1, int a = 0, int b = N - 1) {
if (lazy[node] != 0)
push(node, a, b, lazy[node]);
@@ -63,8 +72,10 @@ void update(int i, int j, int val, int node = 1, int a = 0, int b = N - 1) {
tree[node] = tree[node * 2] + tree[node * 2 + 1];
}
-
-// Returns sum of [i,j]
+/**
+ * Returns sum of [i,j].
+ * @param i,j range
+ */
int query(int i, int j, int node = 1, int a = 0, int b = N - 1) {
if (a > b || a > j || b < i)
return 0;
diff --git a/algorithms/structure/policy_tree.cpp b/algorithms/structure/policy_tree.cpp
index ee6cff39aaeb7514fbdeb8fe43db0bb6fa81ebaf..e6d7770029bbf6d093ca819c25e8309e3762ab10 100644
--- a/algorithms/structure/policy_tree.cpp
+++ b/algorithms/structure/policy_tree.cpp
@@ -18,6 +18,9 @@ using namespace __gnu_pbds;
typedef tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update> set_t;
+/**
+ * Demonstration of operations.
+ */
void operations() {
set_t S;
diff --git a/algorithms/structure/segment_tree.cpp b/algorithms/structure/segment_tree.cpp
index c5038a7a68b34ba450c11f600f6423f2a4751bcb..9152accaaf4952c42b491c92a2533ef1fd18f746 100644
--- a/algorithms/structure/segment_tree.cpp
+++ b/algorithms/structure/segment_tree.cpp
@@ -15,7 +15,9 @@ int tree[4 * MAX];
#define left(x) (x << 1)
#define right(x) ((x << 1) + 1)
-// Build tree with elements from v
+/**
+ * Builds tree with elements from v (0-indexed).
+ */
void build(int node = 1, int a = 0, int b = N - 1) {
if (a > b)
return;
@@ -30,8 +32,11 @@ void build(int node = 1, int a = 0, int b = N - 1) {
tree[node] = tree[node * 2] + tree[node * 2 + 1];
}
-
-// Update position idx with value val
+/**
+ * Updates position idx by adding value val.
+ * @param idx position
+ * @param val value to be added
+ */
void update(int idx, int val, int node = 1, int a = 0, int b = N - 1) {
if (a > b || a > idx || b < idx)
return;
@@ -46,8 +51,10 @@ void update(int idx, int val, int node = 1, int a = 0, int b = N - 1) {
tree[node] = tree[node * 2] + tree[node * 2 + 1];
}
-
-// Return sum of [i,j]
+/**
+ * Returns sum of [i,j].
+ * @param i,j range
+ */
int query(int i, int j, int node = 1, int a = 0, int b = N - 1) {
if (a > b || a > j || b < i)
return 0;
diff --git a/algorithms/structure/trie.cpp b/algorithms/structure/trie.cpp
index 948876a9aba2ffde2f850adec54bb495265d45b4..979afb6d1c18b050a25adab990c11754136b9a05 100644
--- a/algorithms/structure/trie.cpp
+++ b/algorithms/structure/trie.cpp
@@ -15,7 +15,9 @@ int trie[MAX][26]; // mset(-1)
// character of a string contained in the Trie
bool ending[MAX];
-// Insert word into the Trie
+/**
+ * Inserts word into the Trie.
+ */
void insert(string word) {
int node = 0;
@@ -30,7 +32,9 @@ void insert(string word) {
ending[node] = true;
}
-// Return true if word is in the Trie
+/**
+ * Returns true if word is in the Trie.
+ */
bool search(string word) {
int node = 0;
@@ -52,7 +56,9 @@ int trie[MAX][2]; // mset(-1)
// bit of an integer contained in the Trie
bool ending[MAX];
-// Insert x into the Trie
+/**
+ * Inserts x into the Trie.
+ */
void insert(int x) {
int node = 0;
@@ -67,7 +73,9 @@ void insert(int x) {
ending[node] = true;
}
-// Return true if x is in the Trie
+/**
+ * Returns true if x is in the Trie.
+ */
bool search(int x) {
int node = 0;
diff --git a/testing.py b/testing.py
index 51b14e2649083a79d8fd8f8dd0007e768ca6f53e..1280b7fae7ad690a77e2707b9ce0093b36baa25a 100644
--- a/testing.py
+++ b/testing.py
@@ -7,6 +7,8 @@ dirs = [
'problems'
]
+# Returns a tree represented as dict, with structure of files
+# and directories
def get_file_tree():
tree = {}
for di in dirs:
@@ -23,25 +25,25 @@ def get_file_tree():
if not branch[-2] in curr:
curr[branch[-2]] = []
- curr[branch[-2]].append(str(path))
+ curr[branch[-2]].append(str(branch[-1]))
return tree
-
+# Print elements in arr in Latex format
def gen_code_latex(arr, depth):
for i in arr:
print('\\' + depth + '{' + i + '}')
-
+# Generate Latex from tree
def gen_latex(tree):
stack = [ (tree, 0) ]
depth = ['chapter', 'section', 'subsection']
while len(stack) != 0:
x, h = stack.pop()
- if type(x) == list:
- for i in x:
- gen_code_latex(x, depth[h])
+ print(x)
+ #if type(x) == list:
+ # gen_code_latex(x, depth[h])
#print('\\' + depth[h] + '{' + i + '}')
for i in x:
@@ -50,5 +52,14 @@ def gen_latex(tree):
tree = get_file_tree()
+for i in tree:
+ print(i)
+ for j in tree[i]:
+ print('\t' + j)
+ if type(tree[i]) != list:
+ for k in tree[i][j]:
+ print('\t\t' + k)
+ print()
+ print()
#print(tree)
-gen_latex(tree)
+#gen_latex(tree)