Remove documentations

Author: adamant-pwn

cp-algo/graph/tree_diameter.hpp

@@ -7,58 +7,43 @@
 #include <algorithm>
 
 namespace cp_algo::graph {
-
-/**
- * @brief Finds the diameter of a weighted tree
- * 
- * Returns the maximum distance between any two nodes in the tree.
- * Uses XOR DFS to traverse the tree while tracking path distances.
- * 
- * @param g The input weighted tree
- * @return Tuple of (diameter_length, starting_node, path_edges)
- *         The path is represented as a sequence of edge indices from start to end
- * 
- * Time complexity: O(n)
- * Space complexity: O(n)
- */
-template<weighted_undirected_graph_type graph>
-std::tuple<int64_t, node_index, std::basic_string<edge_index>> tree_diameter(graph const& g) {
-    struct up_path {
-        int64_t length = 0;
-        node_index start;
-    };
-    std::vector<up_path> up(g.n());
-    for(auto v: g.nodes()) {
-        up[v].start = v;
-    }
-    up_path s, t;
-    auto parents = xor_dfs(g, [&](node_index v, edge_index ep) {
-        if (ep == edge_index(-1)) return;
-        node_index u = g.edge(ep).traverse(v);
-        up[v].length += g.edge(ep).w;
-        if (up[v].length + up[u].length > s.length + t.length) {
-            s = up[v];
-            t = up[u];
-        }
-        if (up[v].length > up[u].length) {
-            up[u] = up[v];
+    template<weighted_undirected_graph_type graph>
+    std::tuple<int64_t, node_index, std::basic_string<edge_index>> tree_diameter(graph const& g) {
+        struct up_path {
+            int64_t length = 0;
+            node_index start;
+        };
+        std::vector<up_path> up(g.n());
+        for(auto v: g.nodes()) {
+            up[v].start = v;
         }
-    });
-    auto collect = [&](up_path v) {
-        std::basic_string<edge_index> path;
-        while(v.length) {
-            edge_index ep = parents[v.start];
-            path.push_back(ep);
-            v.length -= g.edge(ep).w;
-            v.start = g.edge(ep).traverse(v.start);
-        }
-        return path;
-    };
-    auto paths = collect(s);
-    auto patht = collect(t);
-    std::ranges::reverse(patht);
-    return {s.length + t.length, s.start, paths += patht};
+        up_path s, t;
+        auto parents = xor_dfs(g, [&](node_index v, edge_index ep) {
+            if (ep == edge_index(-1)) return;
+            node_index u = g.edge(ep).traverse(v);
+            up[v].length += g.edge(ep).w;
+            if (up[v].length + up[u].length > s.length + t.length) {
+                s = up[v];
+                t = up[u];
+            }
+            if (up[v].length > up[u].length) {
+                up[u] = up[v];
+            }
+        });
+        auto collect = [&](up_path v) {
+            std::basic_string<edge_index> path;
+            while(v.length) {
+                edge_index ep = parents[v.start];
+                path.push_back(ep);
+                v.length -= g.edge(ep).w;
+                v.start = g.edge(ep).traverse(v.start);
+            }
+            return path;
+        };
+        auto paths = collect(s);
+        auto patht = collect(t);
+        std::ranges::reverse(patht);
+        return {s.length + t.length, s.start, paths += patht};
+    }
 }
-
-} // namespace cp_algo::graph
 #endif // CP_ALGO_GRAPH_TREE_DIAMETER_HPP

cp-algo/graph/xor_dfs.hpp

@@ -4,46 +4,30 @@
 #include <vector>
 
 namespace cp_algo::graph {
-
-/**
- * @brief XOR DFS on trees - processes leaves to root using XOR trick
- * 
- * Uses XOR to track remaining edges instead of storing parent pointers.
- * Calls callback for each leaf being processed, passing the leaf node and its parent edge.
- * 
- * @param tree The input tree (undirected graph)
- * @param callback Function called for each leaf with (node, edge) parameters
- * @param root Root node (default 0)
- * @return Vector where result[v] = XOR of all incident edge indices at node v
- * 
- * Time complexity: O(n)
- * Space complexity: O(n)
- */
-template<undirected_graph_type graph>
-auto xor_dfs(graph const& tree, auto &&callback, node_index root = 0) {
-    std::vector<int> degree(tree.n());
-    std::vector<edge_index> neig_xor(tree.n());
-    for(auto v: tree.nodes()) {
-        for(auto e: tree.outgoing(v)) {
-            degree[v]++;
-            neig_xor[v] ^= e;
+    template<undirected_graph_type graph>
+    auto xor_dfs(graph const& tree, auto &&callback, node_index root = 0) {
+        std::vector<int> degree(tree.n());
+        std::vector<edge_index> neig_xor(tree.n());
+        for(auto v: tree.nodes()) {
+            for(auto e: tree.outgoing(v)) {
+                degree[v]++;
+                neig_xor[v] ^= e;
+            }
         }
-    }
-    neig_xor[root] ^= edge_index(-1);
-    degree[root]++;
-    for(auto v: tree.nodes()) {
-        while(degree[v] == 1) {
-            edge_index ep = neig_xor[v];
-            callback(v, ep);
-            degree[v]--;
-            if (v == root) break;
-            v = tree.edge(ep).traverse(v);
-            degree[v]--;
-            neig_xor[v] ^= ep;
+        neig_xor[root] ^= edge_index(-1);
+        degree[root]++;
+        for(auto v: tree.nodes()) {
+            while(degree[v] == 1) {
+                edge_index ep = neig_xor[v];
+                callback(v, ep);
+                degree[v]--;
+                if (v == root) break;
+                v = tree.edge(ep).traverse(v);
+                degree[v]--;
+                neig_xor[v] ^= ep;
+            }
         }
+        return neig_xor;
     }
-    return neig_xor;
 }
-
-} // namespace cp_algo::graph
 #endif // CP_ALGO_GRAPH_XOR_DFS_HPP