edit

Author: andy489

Suffix Automaton/SA.cpp

@@ -1,6 +1,6 @@
 /*
 
-The idea of using Treap data structure for storing the transitions 
+The idea of using Treap data structure for storing the transitions
 in every Node of the automaton is thanks to Iliyan Yordanov Yordanov
 
 The construction time complexity of the automaton is guaranteed O(n*log(Sigma)),
@@ -32,7 +32,7 @@ struct Node {
     }
 };
 
-int numNodes;
+int num_nodes;
 
 struct Treap {
 private:
@@ -42,6 +42,7 @@ struct Treap {
         if (t == -1) {
             return void(l = r = -1);
         }
+
         if (nodes[t].key < key) {
             split(nodes[t].r, nodes[t].r, r, key), l = t;
         } else {
@@ -53,6 +54,7 @@ struct Treap {
         if (l == -1 || r == -1) {
             return void(t = (l == -1 ? r : l));
         }
+
         if (nodes[l].prior < nodes[r].prior) {
             merge(nodes[r].l, l, nodes[r].l), t = r;
         } else {
@@ -63,9 +65,10 @@ struct Treap {
 public:
     inline void insert(int &t, char key, int state) {
         int l, m, r;
+
         split(t, l, r, key);
 
-        m = numNodes++;
+        m = num_nodes++;
         nodes[m].set(key, state);
 
         merge(t, l, m);
@@ -74,11 +77,13 @@ struct Treap {
 
     inline void copy(int &cur, int &other) {
         if (other != -1) {
-            cur = numNodes++;
+            cur = num_nodes++;
             nodes[cur] = nodes[other];
+
             if (nodes[other].l != -1) {
                 copy(nodes[cur].l, nodes[other].l);
             }
+
             if (nodes[other].r != -1) {
                 copy(nodes[cur].r, nodes[other].r);
             }
@@ -98,7 +103,7 @@ struct Treap {
         }
     }
 
-    inline vector<Node> &getTreapNodes() {
+    inline vector<Node> &get_treap_nodes() {
         return this->nodes;
     };
 
@@ -117,112 +122,137 @@ struct State {
 
 vector<State> states;
 vector<int> transitions;
-int numInfix;
+int num_infix;
 
-int prefixState(0), last(0);
+int prefix_state(0), last(0);
 
 inline void add(char symbol) {
-    int nq = ++prefixState; // the guaranteed new prefix state
+    int nq = ++prefix_state; // the guaranteed new prefix state
     states[nq].set(states[last].len + 1, -1, nq);
     transitions[nq] = -1;
-    int currTransition, q;
+
+    int curr_transition, q;
     q = last;
+
     while (q != -1) {   //  traverse upwards to root
-        currTransition = T.find(transitions[q], symbol);
-        if (currTransition != -1) {
+        curr_transition = T.find(transitions[q], symbol);
+
+        if (curr_transition != -1) {
             break;
         }
         T.insert(transitions[q], symbol, nq);
         q = states[q].par;
     }
+
     last = nq;
+
     if (q == -1) {
         return void(states[nq].par = 0);
     }
-    int p = T.getTreapNodes()[currTransition].state;
+
+    int p = T.get_treap_nodes()[curr_transition].state;
+
     if (states[q].len + 1 == states[p].len) {
         return void(states[nq].par = p);
     }
 
-    int clone = numInfix++;
+    int clone = num_infix++;
+
     states[clone].set(states[q].len + 1, states[p].par, states[p].fir);
     transitions[clone] = -1;
     T.copy(transitions[clone], transitions[p]);
+
     while (q != -1) {
-        currTransition = T.find(transitions[q], symbol);
-        if (T.getTreapNodes()[currTransition].state != p) {
+        curr_transition = T.find(transitions[q], symbol);
+
+        if (T.get_treap_nodes()[curr_transition].state != p) {
             break;
         }
-        T.getTreapNodes()[currTransition].state = clone;
+
+        T.get_treap_nodes()[curr_transition].state = clone;
         q = states[q].par;
     }
     states[p].par = states[nq].par = clone;
 }
 
-vector<int> prevEdge;
-int cntEdges;
+vector<int> prev_edge;
+int cnt_edges;
 
-void addEdge(int from, int to = cntEdges) { // to is always equal to cntEdges
-    prevEdge[to] = transitions[from];
-    transitions[from] = cntEdges++;
+void add_edge(int from, int to = cnt_edges) { // to is always equal to cnt_edges
+    prev_edge[to] = transitions[from];
+    transitions[from] = cnt_edges++;
 }
 
 vector<int> in, out;
 int t;
 
 void dfs(int v) {
     in[v] = t++;
-    for (int to = transitions[v]; to; to = prevEdge[to]) {
+
+    for (int to = transitions[v]; to; to = prev_edge[to]) {
         dfs(to);
     }
+
     out[v] = t++;
 }
 
-int cntSquares;
-vector<int> lenState;
+int cnt_squares;
+vector<int> len_state;
+
+void find_squares(int ver) {
+    len_state[states[ver].len] = ver;
+
+    int half = len_state[states[ver].len >> 1];
 
-void findSquares(int ver) {
-    lenState[states[ver].len] = ver;
-    int half = lenState[states[ver].len >> 1];
     if ((half != -1) && ((states[half].len << 1) == states[ver].len)) {
         int ind = states[ver].fir - (states[ver].len >> 1);
+
         if ((in[half] <= in[ind]) && (in[ind] <= out[half])) {
-            ++cntSquares;
+            ++cnt_squares;
         }
     }
-    for (int to = transitions[ver]; to; to = prevEdge[to]) {
-        findSquares(to);
+
+    for (int to = transitions[ver]; to; to = prev_edge[to]) {
+        find_squares(to);
     }
-    lenState[states[ver].len] = -1;
+
+    len_state[states[ver].len] = -1;
 }
 
 void init(int n) {
     states.resize(2 * n);
-    T.getTreapNodes().resize(3 * n);
-    numNodes = 0;
+    T.get_treap_nodes().resize(3 * n);
+    num_nodes = 0;
+
     transitions.resize(2 * n);
 }
 
 int main(int argc, char **argv) {
     if (argc != 2) {
         printf("Invalid executable file call! Usage: %s <file.txt>\n", argv[0]);
+        
         return 1;
     }
-    char *filePath = argv[1];
-    if (access(filePath, F_OK) < 0 || access(filePath, R_OK) < 0) {
+
+    char *file_path = argv[1];
+
+    if (access(file_path, F_OK) < 0 || access(file_path, R_OK) < 0) {
         printf("Provided file does not exist or is not readable.\n");
         return 2;
     }
-    ifstream file(filePath, ios::binary); // treat as a binary file
+
+    ifstream file(file_path, ios::binary); // treat as a binary file
     file.seekg(-1, ios::end); // seek cursor to end of file with offset -1
+
     int n = file.tellg(); // get length of file
+
     file.seekg(0, ios::beg); // seek back to beginning
 
     init(n);
 
     states[0].set(0, -1, 0);
     transitions[0] = -1;
-    numInfix = n + 1;
+    num_infix = n + 1;
     last = 0;
 
     char c;
@@ -231,35 +261,45 @@ int main(int argc, char **argv) {
     while (file.get(c) && isalpha(c)) {
         add(c);
     }
+
     file.close();
 
-    int i, cntFinal = 0, curr = last;
+    int cnt_final = 0;
+    int curr = last;
+
     while (curr != -1) {
-        ++cntFinal;
+        ++cnt_final;
         curr = states[curr].par;
     }
 
-    prevEdge.resize(numInfix);
-    for (i = 0; i < numInfix; ++i) {
+    prev_edge.resize(num_infix);
+
+    for (int i = 0; i < num_infix; ++i) {
         transitions[i] = 0;
     }
-    cntEdges = 1;
-    for (i = 1; i < numInfix; ++i) {
-        addEdge(states[i].par, i);
+
+    cnt_edges = 1;
+
+    for (int i = 1; i < num_infix; ++i) {
+        add_edge(states[i].par, i);
     }
 
-    in.resize(numInfix);
-    out.resize(numInfix);
+    in.resize(num_infix);
+    out.resize(num_infix);
 
     t = 1;
     dfs(0);
 
-    lenState.resize(n + 1);
-    for (i = 0; i < n; ++i) {
-        lenState[i] = -1;
+    len_state.resize(n + 1);
+
+    for (int i = 0; i < n; ++i) {
+        len_state[i] = -1;
     }
 
-    cntSquares = 0;
-    findSquares(0);
-    return printf("%d %d %d %d\n", numInfix, numNodes, cntFinal, cntSquares), 0;
+    cnt_squares = 0;
+    find_squares(0);
+
+    printf("%d %d %d %d\n", num_infix, num_nodes, cnt_final, cnt_squares);
+
+    return 0;
 }

Treap (Cartesian Tree)/Cartesian Tree Build (stack).cpp

@@ -1,24 +1,29 @@
-// github.com/andy489
-
+#include <iostream>
 #include <vector>
 #include <stack>
 
 using namespace std;
 
-vector<int> build(int *A, int n) {
+vector<int> build(const int *A, int n) {
     vector<int> parent(n, -1);
     stack<int> s;
 
     for (int i = 0; i < n; ++i) {
         int last = -1;
+
         while (!s.empty() && A[s.top()] >= A[i]) {
             last = s.top();
             s.pop();
         }
-        if (!s.empty())
+
+        if (!s.empty()) {
             parent[i] = s.top();
-        if (last >= 0)
+        }
+
+        if (last >= 0) {
             parent[last] = i;
+        }
+
         s.push(i);
     }
     return parent;
@@ -36,10 +41,12 @@ void display(int u, vector<vector<int>> &adj) {
             int cur = Q.front();
             Q.pop();
             printf("%d ", cur);
-            for (const int &child: adj[cur])
+            for (const int &child: adj[cur]) {
                 Q.push(child);
+            }
+
         }
-        printf("\n");
+        cout << endl;
     }
 }
 
@@ -52,11 +59,13 @@ int main() {
     vector<vector<int>> adj(n, vector<int>());
 
     int root = -1;
+
     for (int i = 0; i < n; ++i) {
-        if (CartesianTree[i] != -1)
+        if (CartesianTree[i] != -1) {
             adj[CartesianTree[i]].push_back(i);
-        else
+        } else {
             root = i;
+        }
     }
 
     return display(root, adj), 0;