diff --git a/annotated.html b/annotated.html index 75d13a5d3..557bef4fb 100644 --- a/annotated.html +++ b/annotated.html @@ -123,41 +123,46 @@ $(document).ready(function(){initNavTree('annotated.html',''); initResizable();  Cadaline  ▼Nquadratic_probingAn implementation of hash table using quadratic probing algorithm  CEntry - ▼NstatisticsStatistical algorithms - Cstats_computer1 - Cstats_computer2 - CBtree - Ccll - Ccompare - CComplexClass Complex to represent complex numbers as a field - CCycleCheck - Cdouble_linked_list - CEdge - CFenwickTree - CGraph - Chash_chainChain class with a given modulus - CItem - Clarge_number - Clinkedlist - Clist - CMinHeap - CMinHeapNode - Cmst - CNode - Cnode - CPoint - Cquery - CQueue + ▼Nrange_queriesAlgorithms and Data Structures that support range queries and updates + ▼Nheavy_light_decomposition + CHLDThe Heavy-Light Decomposition class + CSGSegment Tree, to store heavy chains + CTreeA Basic Tree, which supports binary lifting + ▼NstatisticsStatistical algorithms + Cstats_computer1 + Cstats_computer2 + CBtree + Ccll + Ccompare + CComplexClass Complex to represent complex numbers as a field + CCycleCheck + Cdouble_linked_list + CEdge + CFenwickTree + CGraph + Chash_chainChain class with a given modulus + CItem + Clarge_number + Clinkedlist + Clist + CMinHeap + CMinHeapNode + Cmst + CNode + Cnode + CPoint + Cquery  Cqueue - CQueue_Array - CSegmentIntersection - CSolution - Cstack - Cstack_linkedList - Ctower - ▼CTrie - CTrieNode - Ctrie + CQueue + CQueue_Array + CSegmentIntersection + CSolution + Cstack + Cstack_linkedList + Ctower + Ctrie + ▼CTrie + CTrieNode diff --git a/annotated_dup.js b/annotated_dup.js index cf7b0ce82..56397720e 100644 --- a/annotated_dup.js +++ b/annotated_dup.js @@ -8,6 +8,7 @@ var annotated_dup = [ "linear_probing", "d8/d89/namespacelinear__probing.html", "d8/d89/namespacelinear__probing" ], [ "machine_learning", "d8/d77/namespacemachine__learning.html", "d8/d77/namespacemachine__learning" ], [ "quadratic_probing", "d4/dd2/namespacequadratic__probing.html", "d4/dd2/namespacequadratic__probing" ], + [ "range_queries", "dd/d69/namespacerange__queries.html", "dd/d69/namespacerange__queries" ], [ "statistics", "d2/dcf/namespacestatistics.html", "d2/dcf/namespacestatistics" ], [ "Btree", "d9/d90/struct_btree.html", "d9/d90/struct_btree" ], [ "cll", "d5/d15/classcll.html", "d5/d15/classcll" ], @@ -30,14 +31,14 @@ var annotated_dup = [ "node", "d5/da1/structnode.html", "d5/da1/structnode" ], [ "Point", "d8/dc8/struct_point.html", "d8/dc8/struct_point" ], [ "query", "dd/d1b/structquery.html", "dd/d1b/structquery" ], - [ "Queue", "dc/db5/struct_queue.html", "dc/db5/struct_queue" ], [ "queue", "db/da9/classqueue.html", "db/da9/classqueue" ], + [ "Queue", "dc/db5/struct_queue.html", "dc/db5/struct_queue" ], [ "Queue_Array", "d0/dd2/class_queue___array.html", "d0/dd2/class_queue___array" ], [ "SegmentIntersection", "d4/db4/struct_segment_intersection.html", "d4/db4/struct_segment_intersection" ], [ "Solution", "dd/d4f/class_solution.html", "dd/d4f/class_solution" ], [ "stack", "d1/dc2/classstack.html", "d1/dc2/classstack" ], [ "stack_linkedList", "d2/dc4/classstack__linked_list.html", "d2/dc4/classstack__linked_list" ], [ "tower", "d2/d2c/structtower.html", "d2/d2c/structtower" ], - [ "Trie", "dd/d2f/class_trie.html", "dd/d2f/class_trie" ], - [ "trie", "d4/dd9/structtrie.html", "d4/dd9/structtrie" ] + [ "trie", "d4/dd9/structtrie.html", "d4/dd9/structtrie" ], + [ "Trie", "dd/d2f/class_trie.html", "dd/d2f/class_trie" ] ]; \ No newline at end of file diff --git a/classes.html b/classes.html index a8cb9fc85..b3c52694a 100644 --- a/classes.html +++ b/classes.html @@ -98,106 +98,110 @@ $(document).ready(function(){initNavTree('classes.html',''); initResizable(); }) - - - - - - - - - - - - - - - - - - - - - + + - - - + + - - + + - - - + + + - - - + + - + + + + + + + - - - - - - + - + + + + - + - + - - - - - - - - - - - - - - + + + - + + + - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  a  
  e  
-		HillCipher (ciphers)   Node   SkipList (data_structure)   
  i  
-		node   Solution   
adaline (machine_learning)   Edge   Node (data_structure)   stack   
  b  
-		Entry (linear_probing)   Item   
  p  
-		stack_linkedList   
Entry (double_hashing)   Entry (quadratic_probing)   
  l  
Point (geometry::jarvis)    stats_computer1 (statistics)   
Btree   Entry (quadratic_probing)   Point   
Entry (linear_probing)   
  q  
+		 stats_computer2 (statistics)   
  c  
-
  f  
-
adaline (machine_learning)   Entry (double_hashing)    large_number   Point (geometry::jarvis)   
  t  
linkedlist   
  q  
+
  b  
  f  
+		linkedlist   query   
cll   FenwickTree   list   
list   queue    tower   
compare   
Btree   FenwickTree   LowestCommonAncestor (graph)   Queue   Tree (range_queries::heavy_light_decomposition)   
  c  
+
  g  
LowestCommonAncestor (graph)   query   Trie   
Complex   
  m  
Queue   Queue_Array    trie   
Convexhull (geometry::jarvis)   
  r  
+		Trie   
cll    Graph   queue   MinHeap    Trie::TrieNode   
CycleCheck   
compare    Graph (graph::is_graph_bipartite)   MinHeap   Queue_Array   
  d  
-		Graph (graph)    MinHeapNode   
  r  
-
  h  
-		mst   
DenseLayer (machine_learning::neural_network::layers)   
  n  
-		 RootedTree (graph)   
double_linked_list   hash_chain   
Complex   Graph (graph)   mst   
  s  
NeuralNetwork (machine_learning::neural_network)   
Convexhull (geometry::jarvis)   
  h  
+
  n  
+
SegmentIntersection   
CycleCheck   SegmentIntersection   
  d  
+		hash_chain   NeuralNetwork (machine_learning::neural_network)   SG (range_queries::heavy_light_decomposition)   
HillCipher (ciphers)   Node (data_structure)   SkipList (data_structure)   
DenseLayer (machine_learning::neural_network::layers)   HLD (range_queries::heavy_light_decomposition)   Node   Solution   
double_linked_list   
  i  
+		node   stack   
  e  
+
  p  
+		stack_linkedList   
Item   
Edge   Point   
a | b | c | d | e | f | g | h | i | l | m | n | p | q | r | s | t
diff --git a/d0/d2c/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d__inherit__graph.map b/d0/d2c/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d__inherit__graph.map new file mode 100644 index 000000000..947b9e08d --- /dev/null +++ b/d0/d2c/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d__inherit__graph.map @@ -0,0 +1,5 @@ + + + + + diff --git a/d0/d2c/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d__inherit__graph.md5 b/d0/d2c/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d__inherit__graph.md5 new file mode 100644 index 000000000..e6ab0d663 --- /dev/null +++ b/d0/d2c/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d__inherit__graph.md5 @@ -0,0 +1 @@ +0d6902849303905cd17d404a329a289a \ No newline at end of file diff --git a/d0/d2c/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d__inherit__graph.svg b/d0/d2c/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d__inherit__graph.svg new file mode 100644 index 000000000..a7904ae6e --- /dev/null +++ b/d0/d2c/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d__inherit__graph.svg @@ -0,0 +1,58 @@ + + + + + + +range_queries::heavy_light_decomposition::HLD< X > + + + +Node1 + + +range_queries::heavy +_light_decomposition +::HLD< X > + + + + + +Node2 + + +range_queries::heavy +_light_decomposition +::Tree< X > + + + + + +Node2->Node1 + + + + + +Node3 + + +range_queries::heavy +_light_decomposition +::SG< X > + + + + + +Node3->Node1 + + + + + diff --git a/d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree.html b/d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree.html new file mode 100644 index 000000000..a91552b26 --- /dev/null +++ b/d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree.html @@ -0,0 +1,790 @@ + + + + + + + +Algorithms_in_C++: range_queries::heavy_light_decomposition::Tree< X > Class Template Reference + + + + + + + + + + + + + + + +
+
+ + + + + + +
+
Algorithms_in_C++ +  1.0.0 +
+
Set of algorithms implemented in C++.
+
+
+ + + + + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+ +
+ +
+
+Public Member Functions | +Private Member Functions | +Private Attributes | +Friends | +List of all members
+
+
range_queries::heavy_light_decomposition::Tree< X > Class Template Reference
+
+
+ +

A Basic Tree, which supports binary lifting. + More...

+
+Inheritance diagram for range_queries::heavy_light_decomposition::Tree< X >:
+
+
+
+
[legend]
+
+Collaboration diagram for range_queries::heavy_light_decomposition::Tree< X >:
+
+
+
+
[legend]
+ + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

 Tree (int nodes)
 Class parameterized constructor, resizes the and initializes the data members. More...
 
void add_edge (const int u, const int v)
 Adds an undirected edge from node u to node v in the tree. More...
 
void change_root (int new_root)
 Set the root for the tree. More...
 
void set_node_val (const std::vector< X > &node_val)
 Set the values for all the nodes. More...
 
void init ()
 This function must be called after the tree adjacency list and node values are populated The function initializes the required parameters, and populates the segment tree. More...
 
void lift (int *const p, int dist)
 The function lifts a node, k units up the tree. The lifting is done in place, and the result is stored in the address pointed by p. More...
 
int kth_ancestor (int p, const int &dist)
 The function returns the kth ancestor of a node. More...
 
int lca (int a, int b)
 The function returns the least common ancestor of two nodes. More...
 
+ + + + + + + +

+Private Member Functions

void dfs_size (int u, int p=-1)
 Utility function to compute sub-tree sizes. More...
 
void dfs_lca (int u, int p=-1)
 Utility function to populate the t_par vector. More...
 
+ + + + + + + + + + + + + + + + + + + + + + + + + +

+Private Attributes

+std::vector< std::list< int > > t_adj
 an adjacency list to stores the tree edges
 
+const int t_nodes
 number of nodes
 
+const int t_maxlift
 maximum possible height of the tree
 
+std::vector< std::vector< int > > t_par
 a matrix to store every node's 2^kth parent
 
+std::vector< int > t_depth
 a vector to store the depth of a node,
 
+std::vector< int > t_size
 a vector to store the subtree size rooted at node
 
+int t_root
 the root of the tree
 
+std::vector< X > t_val
 values of nodes
 
+ + + + +

+Friends

+template<typename T >
class HLD
 
+

Detailed Description

+

template<typename X>
+class range_queries::heavy_light_decomposition::Tree< X >

+ +

A Basic Tree, which supports binary lifting.

+
Template Parameters
+ + +
thedata type of the values stored in the tree nodes
+
+
+

Deleting the default constructor An instance can only be created with the number of nodes Defaults: t_node indexing are zero based t_root is 0 depth of root_node is 0 Supports: lift :- lift a node k units up the tree kth_ancestor :- returns the kth ancestor lca :- returns the least common ancestor

+

Constructor & Destructor Documentation

+ +

◆ Tree()

+ +
+
+
+template<typename X >
+ + + + + +
+ + + + + + + + +
range_queries::heavy_light_decomposition::Tree< X >::Tree (int nodes)
+ 		+inlineexplicit
+
+ +

Class parameterized constructor, resizes the and initializes the data members.

+
Parameters
+ + +
nodesthe total number of nodes in the tree
+
+
+
141  : t_nodes(nodes), t_maxlift(static_cast<int>(floor(log2(nodes))) + 1) {
+
142  /* Initialize and resize all the vectors */
+
143  t_root = 0; /* Default */
+
144  t_adj.resize(t_nodes);
+
145  t_par.assign(t_nodes, std::vector<int>(t_maxlift, -1));
+
146  t_depth.assign(t_nodes, 0);
+
147  t_size.assign(t_nodes, 1);
+
148  t_val.resize(t_nodes);
+
149  }
+
+Here is the call graph for this function:
+
+
+
+
+ +
+
+

Member Function Documentation

+ +

◆ add_edge()

+ +
+
+
+template<typename X >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void range_queries::heavy_light_decomposition::Tree< X >::add_edge (const int u,
const int v 
)
+ 		+inline
+
+ +

Adds an undirected edge from node u to node v in the tree.

+
Parameters
+ + + +
uthe node where the edge is from
vthe node where the edge is to
+
+
+
Returns
void
+
157  {
+
158  t_adj[u].push_back(v);
+
159  t_adj[v].push_back(u);
+
160  }
+
+Here is the call graph for this function:
+
+
+
+
+ +
+
+ +

◆ change_root()

+ +
+
+
+template<typename X >
+ + + + + +
+ + + + + + + + +
void range_queries::heavy_light_decomposition::Tree< X >::change_root (int new_root)
+ 		+inline
+
+ +

Set the root for the tree.

+
Parameters
+ + +
new_rootthe new root
+
+
+
Returns
void
+
167 { t_root = new_root; }
+
+
+
+ +

◆ dfs_lca()

+ +
+
+
+template<typename X >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void range_queries::heavy_light_decomposition::Tree< X >::dfs_lca (int u,
int p = -1 
)
+ 		+inlineprivate
+
+ +

Utility function to populate the t_par vector.

+
Parameters
+ + + +
ucurrent dfs node
pthe parent of node u
+
+
+
Returns
void
+
116  {
+
117  t_par[u][0] = p;
+
118  if (p != -1) {
+
119  t_depth[u] = 1 + t_depth[p];
+
120  }
+
121  for (int k = 1; k < t_maxlift; k++) {
+
122  if (t_par[u][k - 1] != -1) {
+
123  t_par[u][k] = t_par[t_par[u][k - 1]][k - 1];
+
124  }
+
125  }
+
126 
+
127  for (const int &v : t_adj[u]) {
+
128  if (v ^ p) {
+
129  dfs_lca(v, u);
+
130  }
+
131  }
+
132  }
+
+
+
+ +

◆ dfs_size()

+ +
+
+
+template<typename X >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void range_queries::heavy_light_decomposition::Tree< X >::dfs_size (int u,
int p = -1 
)
+ 		+inlineprivate
+
+ +

Utility function to compute sub-tree sizes.

+
Parameters
+ + + + +
ucurrent dfs node
pthe parent of node
u
+
+
+
Returns
void
+
101  {
+
102  for (const int &v : t_adj[u]) {
+
103  if (v ^ p) {
+
104  dfs_size(v, u);
+
105  t_size[u] += t_size[v];
+
106  }
+
107  }
+
108  }
+
+
+
+ +

◆ init()

+ +
+
+
+template<typename X >
+ + + + + +
+ + + + + + + +
void range_queries::heavy_light_decomposition::Tree< X >::init ()
+ 		+inline
+
+ +

This function must be called after the tree adjacency list and node values are populated The function initializes the required parameters, and populates the segment tree.

+
Returns
void
+
186  {
+
187  assert(t_nodes > 0);
+
188  dfs_size(t_root);
+
189  dfs_lca(t_root);
+
190  }
+
+Here is the call graph for this function:
+
+
+
+
+ +
+
+ +

◆ kth_ancestor()

+ +
+
+
+template<typename X >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
int range_queries::heavy_light_decomposition::Tree< X >::kth_ancestor (int p,
const int & dist 
)
+ 		+inline
+
+ +

The function returns the kth ancestor of a node.

+
Parameters
+ + + +
pthe node id whose kth ancestor is to be found
distthe distance to move up the tree
+
+
+
Returns
the kth ancestor of node
+
218  {
+
219  lift(&p, dist);
+
220  return p;
+
221  }
+
+Here is the call graph for this function:
+
+
+
+
+ +
+
+ +

◆ lca()

+ +
+
+
+template<typename X >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
int range_queries::heavy_light_decomposition::Tree< X >::lca (int a,
int b 
)
+ 		+inline
+
+ +

The function returns the least common ancestor of two nodes.

+
Parameters
+ + + +
anode id_1
bnode id_2
+
+
+
Returns
the least common ancestor of node a, and node b
+
229  {
+
230  assert(a >= 0 and b >= 0 and a < t_nodes and b < t_nodes);
+
231  if (t_depth[a] > t_depth[b]) {
+
232  lift(&a, t_depth[a] - t_depth[b]);
+
233  }
+
234  if (t_depth[b] > t_depth[a]) {
+
235  lift(&b, t_depth[b] - t_depth[a]);
+
236  }
+
237  if (a == b) {
+
238  return a;
+
239  }
+
240  for (int k = t_maxlift - 1; k >= 0; k--) {
+
241  if (t_par[a][k] != t_par[b][k]) {
+
242  a = t_par[a][k];
+
243  b = t_par[b][k];
+
244  }
+
245  }
+
246  return t_par[a][0];
+
247  }
+
+Here is the call graph for this function:
+
+
+
+
+ +
+
+ +

◆ lift()

+ +
+
+
+template<typename X >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void range_queries::heavy_light_decomposition::Tree< X >::lift (int *const p,
int dist 
)
+ 		+inline
+
+ +

The function lifts a node, k units up the tree. The lifting is done in place, and the result is stored in the address pointed by p.

+
Parameters
+ + + +
pa pointer to the variable that stores the node id
distthe distance to move up the tree
+
+
+
Returns
void
+
200  {
+
201  for (int k = 0; k < t_maxlift; k++) {
+
202  if (*p == -1) {
+
203  return;
+
204  }
+
205  if (dist & 1) {
+
206  *p = t_par[*p][k];
+
207  }
+
208  dist >>= 1;
+
209  }
+
210  }
+
+
+
+ +

◆ set_node_val()

+ +
+
+
+template<typename X >
+ + + + + +
+ + + + + + + + +
void range_queries::heavy_light_decomposition::Tree< X >::set_node_val (const std::vector< X > & node_val)
+ 		+inline
+
+ +

Set the values for all the nodes.

+
Parameters
+ + +
node_vala vector of size n, with all the node values where, n is the number of nodes
+
+
+
Returns
void
+
175  {
+
176  assert(static_cast<int>(node_val.size()) == t_nodes);
+
177  t_val = node_val;
+
178  }
+
+Here is the call graph for this function:
+
+
+
+
+ +
+
+
The documentation for this class was generated from the following file: +
+
+
std::vector::resize
T resize(T... args)
+
std::floor
T floor(T... args)
+
range_queries::heavy_light_decomposition::Tree::t_size
std::vector< int > t_size
a vector to store the subtree size rooted at node
Definition: heavy_light_decomposition.cpp:89
+
range_queries::heavy_light_decomposition::Tree::dfs_lca
void dfs_lca(int u, int p=-1)
Utility function to populate the t_par vector.
Definition: heavy_light_decomposition.cpp:116
+
range_queries::heavy_light_decomposition::Tree::t_root
int t_root
the root of the tree
Definition: heavy_light_decomposition.cpp:91
+
range_queries::heavy_light_decomposition::Tree::t_maxlift
const int t_maxlift
maximum possible height of the tree
Definition: heavy_light_decomposition.cpp:85
+
std::vector< int >
+
std::vector::size
T size(T... args)
+
range_queries::heavy_light_decomposition::Tree::lift
void lift(int *const p, int dist)
The function lifts a node, k units up the tree. The lifting is done in place, and the result is store...
Definition: heavy_light_decomposition.cpp:200
+
std::vector::push_back
T push_back(T... args)
+
range_queries::heavy_light_decomposition::Tree::t_adj
std::vector< std::list< int > > t_adj
an adjacency list to stores the tree edges
Definition: heavy_light_decomposition.cpp:83
+
range_queries::heavy_light_decomposition::Tree::t_nodes
const int t_nodes
number of nodes
Definition: heavy_light_decomposition.cpp:84
+
range_queries::heavy_light_decomposition::Tree::t_par
std::vector< std::vector< int > > t_par
a matrix to store every node's 2^kth parent
Definition: heavy_light_decomposition.cpp:87
+
range_queries::heavy_light_decomposition::Tree::t_val
std::vector< X > t_val
values of nodes
Definition: heavy_light_decomposition.cpp:92
+
std::vector::assign
T assign(T... args)
+
range_queries::heavy_light_decomposition::Tree::dfs_size
void dfs_size(int u, int p=-1)
Utility function to compute sub-tree sizes.
Definition: heavy_light_decomposition.cpp:101
+
range_queries::heavy_light_decomposition::Tree::t_depth
std::vector< int > t_depth
a vector to store the depth of a node,
Definition: heavy_light_decomposition.cpp:88
+ + + + diff --git a/d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree.js b/d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree.js new file mode 100644 index 000000000..1c9170851 --- /dev/null +++ b/d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree.js @@ -0,0 +1,22 @@ +var classrange__queries_1_1heavy__light__decomposition_1_1_tree = +[ + [ "Tree", "d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree.html#a835fb2bbb27307b8cacad9b287968bc1", null ], + [ "add_edge", "d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree.html#a79ab4601c4a95c0902ac04e779e5f54d", null ], + [ "change_root", "d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree.html#ab916d554afa8ca5230b4310c2c69fae0", null ], + [ "dfs_lca", "d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree.html#ae8de7aefcb6635d3dacdd174cd4890c4", null ], + [ "dfs_size", "d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree.html#aa339c31ec74cd86a4842a8b09653d460", null ], + [ "init", "d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree.html#ad22d760a5a33545a70e7ea5e1786c8dc", null ], + [ "kth_ancestor", "d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree.html#a8f7bca1746d40f21ad832fcea59aa6c6", null ], + [ "lca", "d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree.html#ae2b407e64aaf9878fbee7ee6efe9c7d4", null ], + [ "lift", "d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree.html#ac7761255f2ba06b398b9aae5e4dce5f3", null ], + [ "set_node_val", "d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree.html#a04cd96efaba147b19d3afc769b90ff70", null ], + [ "HLD", "d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree.html#afcdadbdea1e2391cebbb17d2c1ae2f0b", null ], + [ "t_adj", "d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree.html#ab1aeaefa1bd97b867c652ba916fbdb43", null ], + [ "t_depth", "d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree.html#a0efd0b9c564092f443ca97030d866ef1", null ], + [ "t_maxlift", "d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree.html#ab2ab020f798d00be2613ecf63074b7c1", null ], + [ "t_nodes", "d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree.html#ae4630fa70a80a1dc65a875488a67178a", null ], + [ "t_par", "d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree.html#a350157a5fb79f76fceae33fc84171203", null ], + [ "t_root", "d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree.html#aa6c37e840355b9fb2105181c578694e8", null ], + [ "t_size", "d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree.html#ada1494fccbc7f1f07b2f9be9f7e07ad5", null ], + [ "t_val", "d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree.html#a135b7952593c9b1aae38fcaf1cc1abf7", null ] +]; \ No newline at end of file diff --git a/d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree_a04cd96efaba147b19d3afc769b90ff70_cgraph.map b/d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree_a04cd96efaba147b19d3afc769b90ff70_cgraph.map new file mode 100644 index 000000000..c1ef3b438 --- /dev/null +++ b/d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree_a04cd96efaba147b19d3afc769b90ff70_cgraph.map @@ -0,0 +1,4 @@ + + + + diff --git a/d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree_a04cd96efaba147b19d3afc769b90ff70_cgraph.md5 b/d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree_a04cd96efaba147b19d3afc769b90ff70_cgraph.md5 new file mode 100644 index 000000000..17c612650 --- /dev/null +++ b/d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree_a04cd96efaba147b19d3afc769b90ff70_cgraph.md5 @@ -0,0 +1 @@ +785c0081baceccc1ca988a4db54ca8dd \ No newline at end of file diff --git a/d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree_a04cd96efaba147b19d3afc769b90ff70_cgraph.svg b/d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree_a04cd96efaba147b19d3afc769b90ff70_cgraph.svg new file mode 100644 index 000000000..e1a69b38c --- /dev/null +++ b/d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree_a04cd96efaba147b19d3afc769b90ff70_cgraph.svg @@ -0,0 +1,39 @@ + + + + + + +range_queries::heavy_light_decomposition::Tree::set_node_val + + + +Node1 + + +range_queries::heavy +_light_decomposition +::Tree::set_node_val + + + + + +Node2 + + +std::vector::size + + + + + +Node1->Node2 + + + + + diff --git a/d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree_a79ab4601c4a95c0902ac04e779e5f54d_cgraph.map b/d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree_a79ab4601c4a95c0902ac04e779e5f54d_cgraph.map new file mode 100644 index 000000000..fdc9cf0a8 --- /dev/null +++ b/d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree_a79ab4601c4a95c0902ac04e779e5f54d_cgraph.map @@ -0,0 +1,4 @@ + + + + diff --git a/d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree_a79ab4601c4a95c0902ac04e779e5f54d_cgraph.md5 b/d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree_a79ab4601c4a95c0902ac04e779e5f54d_cgraph.md5 new file mode 100644 index 000000000..5e81216cd --- /dev/null +++ b/d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree_a79ab4601c4a95c0902ac04e779e5f54d_cgraph.md5 @@ -0,0 +1 @@ +d7dc869b3ab041c99ebc389f6d275089 \ No newline at end of file diff --git a/d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree_a79ab4601c4a95c0902ac04e779e5f54d_cgraph.svg b/d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree_a79ab4601c4a95c0902ac04e779e5f54d_cgraph.svg new file mode 100644 index 000000000..8a751a3d4 --- /dev/null +++ b/d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree_a79ab4601c4a95c0902ac04e779e5f54d_cgraph.svg @@ -0,0 +1,39 @@ + + + + + + +range_queries::heavy_light_decomposition::Tree::add_edge + + + +Node1 + + +range_queries::heavy +_light_decomposition +::Tree::add_edge + + + + + +Node2 + + +std::vector::push_back + + + + + +Node1->Node2 + + + + + diff --git a/d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree_a835fb2bbb27307b8cacad9b287968bc1_cgraph.map b/d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree_a835fb2bbb27307b8cacad9b287968bc1_cgraph.map new file mode 100644 index 000000000..868b4c772 --- /dev/null +++ b/d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree_a835fb2bbb27307b8cacad9b287968bc1_cgraph.map @@ -0,0 +1,5 @@ + + + + + diff --git a/d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree_a835fb2bbb27307b8cacad9b287968bc1_cgraph.md5 b/d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree_a835fb2bbb27307b8cacad9b287968bc1_cgraph.md5 new file mode 100644 index 000000000..382e7b3ff --- /dev/null +++ b/d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree_a835fb2bbb27307b8cacad9b287968bc1_cgraph.md5 @@ -0,0 +1 @@ +61c0a4773a48d5c4a57a34196fbc1b6d \ No newline at end of file diff --git a/d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree_a835fb2bbb27307b8cacad9b287968bc1_cgraph.svg b/d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree_a835fb2bbb27307b8cacad9b287968bc1_cgraph.svg new file mode 100644 index 000000000..2d13577dd --- /dev/null +++ b/d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree_a835fb2bbb27307b8cacad9b287968bc1_cgraph.svg @@ -0,0 +1,54 @@ + + + + + + +range_queries::heavy_light_decomposition::Tree::Tree + + + +Node1 + + +range_queries::heavy +_light_decomposition +::Tree::Tree + + + + + +Node2 + + +std::vector::assign + + + + + +Node1->Node2 + + + + + +Node3 + + +std::vector::resize + + + + + +Node1->Node3 + + + + + diff --git a/d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree_a8f7bca1746d40f21ad832fcea59aa6c6_cgraph.map b/d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree_a8f7bca1746d40f21ad832fcea59aa6c6_cgraph.map new file mode 100644 index 000000000..306c03cc9 --- /dev/null +++ b/d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree_a8f7bca1746d40f21ad832fcea59aa6c6_cgraph.map @@ -0,0 +1,4 @@ + + + + diff --git a/d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree_a8f7bca1746d40f21ad832fcea59aa6c6_cgraph.md5 b/d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree_a8f7bca1746d40f21ad832fcea59aa6c6_cgraph.md5 new file mode 100644 index 000000000..fde037627 --- /dev/null +++ b/d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree_a8f7bca1746d40f21ad832fcea59aa6c6_cgraph.md5 @@ -0,0 +1 @@ +3a7a40c14ff24c6e9c9d07b9d75c658d \ No newline at end of file diff --git a/d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree_a8f7bca1746d40f21ad832fcea59aa6c6_cgraph.svg b/d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree_a8f7bca1746d40f21ad832fcea59aa6c6_cgraph.svg new file mode 100644 index 000000000..e70dcd41f --- /dev/null +++ b/d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree_a8f7bca1746d40f21ad832fcea59aa6c6_cgraph.svg @@ -0,0 +1,41 @@ + + + + + + +range_queries::heavy_light_decomposition::Tree::kth_ancestor + + + +Node1 + + +range_queries::heavy +_light_decomposition +::Tree::kth_ancestor + + + + + +Node2 + + +range_queries::heavy +_light_decomposition +::Tree::lift + + + + + +Node1->Node2 + + + + + diff --git a/d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree_ad22d760a5a33545a70e7ea5e1786c8dc_cgraph.map b/d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree_ad22d760a5a33545a70e7ea5e1786c8dc_cgraph.map new file mode 100644 index 000000000..1774c695c --- /dev/null +++ b/d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree_ad22d760a5a33545a70e7ea5e1786c8dc_cgraph.map @@ -0,0 +1,5 @@ + + + + + diff --git a/d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree_ad22d760a5a33545a70e7ea5e1786c8dc_cgraph.md5 b/d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree_ad22d760a5a33545a70e7ea5e1786c8dc_cgraph.md5 new file mode 100644 index 000000000..9639bddc3 --- /dev/null +++ b/d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree_ad22d760a5a33545a70e7ea5e1786c8dc_cgraph.md5 @@ -0,0 +1 @@ +41e2a595a15a8cfb2d32c9b139971bf2 \ No newline at end of file diff --git a/d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree_ad22d760a5a33545a70e7ea5e1786c8dc_cgraph.svg b/d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree_ad22d760a5a33545a70e7ea5e1786c8dc_cgraph.svg new file mode 100644 index 000000000..c4b1465a9 --- /dev/null +++ b/d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree_ad22d760a5a33545a70e7ea5e1786c8dc_cgraph.svg @@ -0,0 +1,58 @@ + + + + + + +range_queries::heavy_light_decomposition::Tree::init + + + +Node1 + + +range_queries::heavy +_light_decomposition +::Tree::init + + + + + +Node2 + + +range_queries::heavy +_light_decomposition +::Tree::dfs_lca + + + + + +Node1->Node2 + + + + + +Node3 + + +range_queries::heavy +_light_decomposition +::Tree::dfs_size + + + + + +Node1->Node3 + + + + + diff --git a/d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree_ae2b407e64aaf9878fbee7ee6efe9c7d4_cgraph.map b/d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree_ae2b407e64aaf9878fbee7ee6efe9c7d4_cgraph.map new file mode 100644 index 000000000..80aae918e --- /dev/null +++ b/d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree_ae2b407e64aaf9878fbee7ee6efe9c7d4_cgraph.map @@ -0,0 +1,4 @@ + + + + diff --git a/d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree_ae2b407e64aaf9878fbee7ee6efe9c7d4_cgraph.md5 b/d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree_ae2b407e64aaf9878fbee7ee6efe9c7d4_cgraph.md5 new file mode 100644 index 000000000..55168ebb4 --- /dev/null +++ b/d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree_ae2b407e64aaf9878fbee7ee6efe9c7d4_cgraph.md5 @@ -0,0 +1 @@ +e8e04603408d0ef33d0dcbaf5b08a9e8 \ No newline at end of file diff --git a/d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree_ae2b407e64aaf9878fbee7ee6efe9c7d4_cgraph.svg b/d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree_ae2b407e64aaf9878fbee7ee6efe9c7d4_cgraph.svg new file mode 100644 index 000000000..b64c975af --- /dev/null +++ b/d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree_ae2b407e64aaf9878fbee7ee6efe9c7d4_cgraph.svg @@ -0,0 +1,41 @@ + + + + + + +range_queries::heavy_light_decomposition::Tree::lca + + + +Node1 + + +range_queries::heavy +_light_decomposition +::Tree::lca + + + + + +Node2 + + +range_queries::heavy +_light_decomposition +::Tree::lift + + + + + +Node1->Node2 + + + + + diff --git a/d1/d67/classrange__queries_1_1heavy__light__decomposition_1_1_s_g__coll__graph.map b/d1/d67/classrange__queries_1_1heavy__light__decomposition_1_1_s_g__coll__graph.map new file mode 100644 index 000000000..2a1b013a2 --- /dev/null +++ b/d1/d67/classrange__queries_1_1heavy__light__decomposition_1_1_s_g__coll__graph.map @@ -0,0 +1,4 @@ + + + + diff --git a/d1/d67/classrange__queries_1_1heavy__light__decomposition_1_1_s_g__coll__graph.md5 b/d1/d67/classrange__queries_1_1heavy__light__decomposition_1_1_s_g__coll__graph.md5 new file mode 100644 index 000000000..a24f7939d --- /dev/null +++ b/d1/d67/classrange__queries_1_1heavy__light__decomposition_1_1_s_g__coll__graph.md5 @@ -0,0 +1 @@ +cc7656369f63f8b4fa9956e3ff7de06d \ No newline at end of file diff --git a/d1/d67/classrange__queries_1_1heavy__light__decomposition_1_1_s_g__coll__graph.svg b/d1/d67/classrange__queries_1_1heavy__light__decomposition_1_1_s_g__coll__graph.svg new file mode 100644 index 000000000..1f95e5c8b --- /dev/null +++ b/d1/d67/classrange__queries_1_1heavy__light__decomposition_1_1_s_g__coll__graph.svg @@ -0,0 +1,40 @@ + + + + + + +range_queries::heavy_light_decomposition::SG< X > + + + +Node1 + + +range_queries::heavy +_light_decomposition +::SG< X > + + + + + +Node2 + + +std::vector< X > + + + + + +Node2->Node1 + + + s_tree + + + diff --git a/d1/de6/classrange__queries_1_1heavy__light__decomposition_1_1_s_g__inherit__graph.map b/d1/de6/classrange__queries_1_1heavy__light__decomposition_1_1_s_g__inherit__graph.map new file mode 100644 index 000000000..385d081a0 --- /dev/null +++ b/d1/de6/classrange__queries_1_1heavy__light__decomposition_1_1_s_g__inherit__graph.map @@ -0,0 +1,4 @@ + + + + diff --git a/d1/de6/classrange__queries_1_1heavy__light__decomposition_1_1_s_g__inherit__graph.md5 b/d1/de6/classrange__queries_1_1heavy__light__decomposition_1_1_s_g__inherit__graph.md5 new file mode 100644 index 000000000..d0bc5d074 --- /dev/null +++ b/d1/de6/classrange__queries_1_1heavy__light__decomposition_1_1_s_g__inherit__graph.md5 @@ -0,0 +1 @@ +2bb159e6758b43b8174a6f9e88a3ca2a \ No newline at end of file diff --git a/d1/de6/classrange__queries_1_1heavy__light__decomposition_1_1_s_g__inherit__graph.svg b/d1/de6/classrange__queries_1_1heavy__light__decomposition_1_1_s_g__inherit__graph.svg new file mode 100644 index 000000000..27efb29d2 --- /dev/null +++ b/d1/de6/classrange__queries_1_1heavy__light__decomposition_1_1_s_g__inherit__graph.svg @@ -0,0 +1,41 @@ + + + + + + +range_queries::heavy_light_decomposition::SG< X > + + + +Node1 + + +range_queries::heavy +_light_decomposition +::SG< X > + + + + + +Node2 + + +range_queries::heavy +_light_decomposition +::HLD< X > + + + + + +Node1->Node2 + + + + + diff --git a/d1/df3/hash__search_8cpp.html b/d1/df3/hash__search_8cpp.html index a9cfcf170..664d22232 100644 --- a/d1/df3/hash__search_8cpp.html +++ b/d1/df3/hash__search_8cpp.html @@ -164,7 +164,7 @@ int 
Copyright
2020 Arctic2333

In this algorithm, we use the method of division and reservation remainder to construct the hash function, and use the method of chain address to solve the conflict, that is, we link a chain list after the data, and store all the records whose keywords are synonyms in the same linear chain list.

Warning
This program is only for educational purposes. It has serious flaws in implementation with regards to memory management resulting in large amounts of memory leaks.
-
Todo:
fix the program for memory leaks and better structure in C++ and not C fashion
+
Todo:
fix the program for memory leaks and better structure in C++ and not C fashion

Typedef Documentation

◆ node

@@ -204,7 +204,7 @@ int 
Warning
dynamic memory allocated to n never gets freed.
-
Todo:
fix memory leak
+
Todo:
fix memory leak
55  { // Construct hash table
56  link p, n;
57  int index;
diff --git a/d2/d8a/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d.html b/d2/d8a/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d.html new file mode 100644 index 000000000..2968e2251 --- /dev/null +++ b/d2/d8a/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d.html @@ -0,0 +1,721 @@ + + + + + + + +Algorithms_in_C++: range_queries::heavy_light_decomposition::HLD< X > Class Template Reference + + + + + + + + + + + + + + + +
+
+ + + + + + +
+
Algorithms_in_C++ +  1.0.0 +
+
Set of algorithms implemented in C++.
+
+
+ + + + + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+ +
+ +
+
+Public Member Functions | +Private Member Functions | +Private Attributes | +List of all members
+
+
range_queries::heavy_light_decomposition::HLD< X > Class Template Reference
+
+
+ +

The Heavy-Light Decomposition class. + More...

+
+Inheritance diagram for range_queries::heavy_light_decomposition::HLD< X >:
+
+
+
+
[legend]
+
+Collaboration diagram for range_queries::heavy_light_decomposition::HLD< X >:
+
+
+
+
[legend]
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

 HLD (int nodes)
 Class parameterized constructor. Resizes the and initilizes the data members. More...
 
void init ()
 This function must be called after the tree adjacency list and node values are populated The function initializes the required parametes, and populates the segment tree. More...
 
void update (int node, X val)
 This function updates the value at node with val. More...
 
X query (int a, int b)
 This function returns the sum of node values in the simple path from from node_1 to node_2. More...
 
- Public Member Functions inherited from range_queries::heavy_light_decomposition::Tree< X >
 Tree (int nodes)
 Class parameterized constructor, resizes the and initializes the data members. More...
 
void add_edge (const int u, const int v)
 Adds an undirected edge from node u to node v in the tree. More...
 
void change_root (int new_root)
 Set the root for the tree. More...
 
void set_node_val (const std::vector< X > &node_val)
 Set the values for all the nodes. More...
 
void init ()
 This function must be called after the tree adjacency list and node values are populated The function initializes the required parameters, and populates the segment tree. More...
 
void lift (int *const p, int dist)
 The function lifts a node, k units up the tree. The lifting is done in place, and the result is stored in the address pointed by p. More...
 
int kth_ancestor (int p, const int &dist)
 The function returns the kth ancestor of a node. More...
 
int lca (int a, int b)
 The function returns the least common ancestor of two nodes. More...
 
+ + + + + + + + + + + + + +

+Private Member Functions

void dfs_hc (int u, int p=-1)
 Utility function to assign heavy child to each node (-1 for a leaf node) More...
 
void dfs_par (int u, int p=-1)
 Utility function to assign highest parent that can be reached though heavy chains. More...
 
void dfs_labels (int u, int p=-1)
 Utility function to lable the nodes so that heavy chains have a contigous lable. More...
 
X chain_query (int a, int b)
 Utility function to break down a path query into two chain queries. More...
 
+ + + + + + + + + + + + + +

+Private Attributes

+int label
 utility member to assign labels in dfs_labels()
 
+std::vector< int > h_label
 stores the label of a node
 
+std::vector< int > h_heavychlid
 stores the heavy child of a node
 
+std::vector< int > h_parent
 stores the top of the heavy chain from a node
 
+

Detailed Description

+

template<typename X>
+class range_queries::heavy_light_decomposition::HLD< X >

+ +

The Heavy-Light Decomposition class.

+
Template Parameters
+ + +
thedata type of the values stored in the tree nodes
+
+
+

Constructor & Destructor Documentation

+ +

◆ HLD()

+ +
+
+
+template<typename X >
+ + + + + +
+ + + + + + + + +
range_queries::heavy_light_decomposition::HLD< X >::HLD (int nodes)
+ 		+inlineexplicit
+
+ +

Class parameterized constructor. Resizes the and initilizes the data members.

+
Parameters
+ + +
nodesthe total number of nodes in the tree
+
+
+
435  : Tree<X>(nodes), SG<X>(nodes) {
+
436  /* Initialization and resize vectors */
+
437  label = 0;
+
438  h_label.assign(Tree<X>::t_nodes, -1);
+
439  h_heavychlid.assign(Tree<X>::t_nodes, -1);
+
440  h_parent.resize(Tree<X>::t_nodes);
+
441  iota(h_parent.begin(), h_parent.end(), 0);
+
442  }
+
+Here is the call graph for this function:
+
+
+
+
+ +
+
+

Member Function Documentation

+ +

◆ chain_query()

+ +
+
+
+template<typename X >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
X range_queries::heavy_light_decomposition::HLD< X >::chain_query (int a,
int b 
)
+ 		+inlineprivate
+
+ +

Utility function to break down a path query into two chain queries.

+
Parameters
+ + + +
anode where the path starts
bnode where the path ends a and b must belong to a single root to leaf chain
+
+
+
Returns
the sum of ndoe values in the simple path from a to b
+
409  {
+
410  X ret = SG<X>::sret_init;
+
411  if (Tree<X>::t_depth[a] < Tree<X>::t_depth[b]) {
+
412  std::swap(a, b);
+
413  }
+
414  while (Tree<X>::t_depth[a] >= Tree<X>::t_depth[b]) {
+
415  int l = h_label[h_parent[a]];
+
416  int r = h_label[a];
+
417  if (Tree<X>::t_depth[h_parent[a]] < Tree<X>::t_depth[b]) {
+
418  l += Tree<X>::t_depth[b] - Tree<X>::t_depth[h_parent[a]];
+
419  }
+
420  ret = SG<X>::combine(ret, SG<X>::query(l, r));
+
421  a = Tree<X>::t_par[h_parent[a]][0];
+
422  if (a == -1) {
+
423  break;
+
424  }
+
425  }
+
426  return ret;
+
427  }
+
+
+
+ +

◆ dfs_hc()

+ +
+
+
+template<typename X >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void range_queries::heavy_light_decomposition::HLD< X >::dfs_hc (int u,
int p = -1 
)
+ 		+inlineprivate
+
+ +

Utility function to assign heavy child to each node (-1 for a leaf node)

+
Parameters
+ + + +
ucurrent dfs node
pthe parent of node u
+
+
+
Returns
void
+
350  {
+
351  int hc_size = -1, hc_id = -1;
+
352  for (const int &v : Tree<X>::t_adj[u]) {
+
353  if (v ^ p) {
+
354  dfs_hc(v, u);
+
355  if (Tree<X>::t_size[v] > hc_size) {
+
356  hc_size = Tree<X>::t_size[v];
+
357  hc_id = v;
+
358  }
+
359  }
+
360  }
+
361  h_heavychlid[u] = hc_id;
+
362  }
+
+
+
+ +

◆ dfs_labels()

+ +
+
+
+template<typename X >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void range_queries::heavy_light_decomposition::HLD< X >::dfs_labels (int u,
int p = -1 
)
+ 		+inlineprivate
+
+ +

Utility function to lable the nodes so that heavy chains have a contigous lable.

+
Parameters
+ + + +
ucurrent dfs node
pthe parent of node u
+
+
+
Returns
void
+
390  {
+
391  h_label[u] = label++;
+
392  if (h_heavychlid[u] != -1) {
+
393  dfs_labels(h_heavychlid[u], u);
+
394  }
+
395  for (const int &v : Tree<X>::t_adj[u]) {
+
396  if (v ^ p and v ^ h_heavychlid[u]) {
+
397  dfs_labels(v, u);
+
398  }
+
399  }
+
400  }
+
+
+
+ +

◆ dfs_par()

+ +
+
+
+template<typename X >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void range_queries::heavy_light_decomposition::HLD< X >::dfs_par (int u,
int p = -1 
)
+ 		+inlineprivate
+
+ +

Utility function to assign highest parent that can be reached though heavy chains.

+
Parameters
+ + + +
ucurrent dfs node
pthe parent of node u
+
+
+
Returns
void
+
371  {
+
372  if (h_heavychlid[u] != -1) {
+
373  h_parent[h_heavychlid[u]] = h_parent[u];
+
374  dfs_par(h_heavychlid[u], u);
+
375  }
+
376  for (const int &v : Tree<X>::t_adj[u]) {
+
377  if (v ^ p and v ^ h_heavychlid[u]) {
+
378  dfs_par(v, u);
+
379  }
+
380  }
+
381  }
+
+
+
+ +

◆ init()

+ +
+
+
+template<typename X >
+ + + + + +
+ + + + + + + +
void range_queries::heavy_light_decomposition::HLD< X >::init ()
+ 		+inline
+
+ +

This function must be called after the tree adjacency list and node values are populated The function initializes the required parametes, and populates the segment tree.

+
Returns
void
+
450  {
+
451  Tree<X>::init();
+
452 
+
453  // Fill the heavy child, greatest parent, and labels
+
454  label = 0;
+
455  dfs_hc(Tree<X>::t_root);
+
456  dfs_par(Tree<X>::t_root);
+
457  dfs_labels(Tree<X>::t_root);
+
458 
+
459  // Segment Tree Initialization
+
460  for (int i = 0; i < Tree<X>::t_nodes; i++) {
+
461  SG<X>::s_tree[h_label[i] + Tree<X>::t_nodes] = Tree<X>::t_val[i];
+
462  }
+
463  for (int i = Tree<X>::t_nodes - 1; i > 0; i--) {
+
464  SG<X>::s_tree[i] =
+
465  SG<X>::combine(SG<X>::s_tree[i << 1], SG<X>::s_tree[i << 1 | 1]);
+
466  }
+
467  }
+
+Here is the call graph for this function:
+
+
+
+
+ +
+
+ +

◆ query()

+ +
+
+
+template<typename X >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
X range_queries::heavy_light_decomposition::HLD< X >::query (int a,
int b 
)
+ 		+inline
+
+ +

This function returns the sum of node values in the simple path from from node_1 to node_2.

+
Parameters
+ + + +
athe node where the simple path starts
bthe node where the simple path ends (parameters are interchangeable, i.e., the function is commutative)
+
+
+
Returns
the sum of node values in the simple path from a to b
+
489  {
+
490  int lc = Tree<X>::lca(a, b);
+
491  X ret = SG<X>::sret_init;
+
492  assert(lc != -1);
+
493  ret += chain_query(a, lc);
+
494  ret += chain_query(b, lc);
+
495  return ret - Tree<X>::t_val[lc];
+
496  }
+
+Here is the call graph for this function:
+
+
+
+
+ +
+
+ +

◆ update()

+ +
+
+
+template<typename X >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void range_queries::heavy_light_decomposition::HLD< X >::update (int node,
X val 
)
+ 		+inline
+
+ +

This function updates the value at node with val.

+
Parameters
+ + + +
nodethe node where the update is done
valthe value that is being updated
+
+
+
Returns
void
+
475  {
+
476  X diff = val - Tree<X>::t_val[node];
+
477  SG<X>::update(h_label[node], diff);
+
478  Tree<X>::t_val[node] = val;
+
479  }
+
+Here is the call graph for this function:
+
+
+
+
+ +
+
+
The documentation for this class was generated from the following file: +
+
+
std::vector::resize
T resize(T... args)
+
range_queries::heavy_light_decomposition::HLD::chain_query
X chain_query(int a, int b)
Utility function to break down a path query into two chain queries.
Definition: heavy_light_decomposition.cpp:409
+
range_queries::heavy_light_decomposition::Tree::t_size
std::vector< int > t_size
a vector to store the subtree size rooted at node
Definition: heavy_light_decomposition.cpp:89
+
range_queries::heavy_light_decomposition::Tree::t_root
int t_root
the root of the tree
Definition: heavy_light_decomposition.cpp:91
+
range_queries::heavy_light_decomposition::Tree::lca
int lca(int a, int b)
The function returns the least common ancestor of two nodes.
Definition: heavy_light_decomposition.cpp:229
+
range_queries::heavy_light_decomposition::Tree::init
void init()
This function must be called after the tree adjacency list and node values are populated The function...
Definition: heavy_light_decomposition.cpp:186
+
range_queries::heavy_light_decomposition::SG::update
void update(int p, X v)
Update the value at a node.
Definition: heavy_light_decomposition.cpp:293
+
range_queries::heavy_light_decomposition::SG::sret_init
X sret_init
inital query return value
Definition: heavy_light_decomposition.cpp:264
+
range_queries::heavy_light_decomposition::SG::combine
X combine(X lhs, X rhs)
Function that specifies the type of operation involved when segments are combined.
Definition: heavy_light_decomposition.cpp:274
+
node
Definition: avltree.cpp:13
+
node
struct list node
+
range_queries::heavy_light_decomposition::HLD::dfs_par
void dfs_par(int u, int p=-1)
Utility function to assign highest parent that can be reached though heavy chains.
Definition: heavy_light_decomposition.cpp:371
+
range_queries::heavy_light_decomposition::HLD::h_heavychlid
std::vector< int > h_heavychlid
stores the heavy child of a node
Definition: heavy_light_decomposition.cpp:340
+
range_queries::heavy_light_decomposition::Tree::t_adj
std::vector< std::list< int > > t_adj
an adjacency list to stores the tree edges
Definition: heavy_light_decomposition.cpp:83
+
range_queries::heavy_light_decomposition::SG::s_tree
std::vector< X > s_tree
Everything here is private, and can only be accessed through the methods, in the derived class (HLD)
Definition: heavy_light_decomposition.cpp:262
+
range_queries::heavy_light_decomposition::Tree::t_nodes
const int t_nodes
number of nodes
Definition: heavy_light_decomposition.cpp:84
+
range_queries::heavy_light_decomposition::HLD::dfs_hc
void dfs_hc(int u, int p=-1)
Utility function to assign heavy child to each node (-1 for a leaf node)
Definition: heavy_light_decomposition.cpp:350
+
range_queries::heavy_light_decomposition::HLD::label
int label
utility member to assign labels in dfs_labels()
Definition: heavy_light_decomposition.cpp:338
+
range_queries::heavy_light_decomposition::Tree::t_par
std::vector< std::vector< int > > t_par
a matrix to store every node's 2^kth parent
Definition: heavy_light_decomposition.cpp:87
+
std::swap
T swap(T... args)
+
range_queries::heavy_light_decomposition::SG::query
X query(int l, int r)
Make a range query from node label l to node label r.
Definition: heavy_light_decomposition.cpp:305
+
range_queries::heavy_light_decomposition::HLD::dfs_labels
void dfs_labels(int u, int p=-1)
Utility function to lable the nodes so that heavy chains have a contigous lable.
Definition: heavy_light_decomposition.cpp:390
+
range_queries::heavy_light_decomposition::Tree::t_val
std::vector< X > t_val
values of nodes
Definition: heavy_light_decomposition.cpp:92
+
std::vector::begin
T begin(T... args)
+
std::iota
T iota(T... args)
+
range_queries::heavy_light_decomposition::HLD::h_parent
std::vector< int > h_parent
stores the top of the heavy chain from a node
Definition: heavy_light_decomposition.cpp:341
+
std::vector::assign
T assign(T... args)
+
std::vector::end
T end(T... args)
+
range_queries::heavy_light_decomposition::HLD::h_label
std::vector< int > h_label
stores the label of a node
Definition: heavy_light_decomposition.cpp:339
+
range_queries::heavy_light_decomposition::Tree::t_depth
std::vector< int > t_depth
a vector to store the depth of a node,
Definition: heavy_light_decomposition.cpp:88
+ + + + diff --git a/d2/d8a/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d.js b/d2/d8a/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d.js new file mode 100644 index 000000000..350361b34 --- /dev/null +++ b/d2/d8a/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d.js @@ -0,0 +1,15 @@ +var classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d = +[ + [ "HLD", "d2/d8a/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d.html#a6e486767434e44076c1ac374a22da726", null ], + [ "chain_query", "d2/d8a/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d.html#a7d5b40c076347a6aabfb37a0590f2f24", null ], + [ "dfs_hc", "d2/d8a/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d.html#af64848d6630c39d0f09ce2359cc7c4f8", null ], + [ "dfs_labels", "d2/d8a/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d.html#a0579062b384e54b611b80c6337c7f2c8", null ], + [ "dfs_par", "d2/d8a/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d.html#a2dfbda148aad0bfaba2ebfda9ebc915a", null ], + [ "init", "d2/d8a/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d.html#ae9e979edd69678b85665c01e2ee97828", null ], + [ "query", "d2/d8a/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d.html#a4dfbf5d9df825eeb63b294c6849bdcab", null ], + [ "update", "d2/d8a/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d.html#a9f1cb54ed09fde931bf3220d75ee4c57", null ], + [ "h_heavychlid", "d2/d8a/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d.html#a84424f180f12b514eaab57a6aa20b104", null ], + [ "h_label", "d2/d8a/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d.html#aa86a91ae0cd7898990a8170a2f2c9cda", null ], + [ "h_parent", "d2/d8a/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d.html#a1b336474d17eff1aa4be73d4068dc725", null ], + [ "label", "d2/d8a/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d.html#a722cc7cf2c3e4d15583601a48b09776f", null ] +]; \ No newline at end of file diff --git a/d2/d8a/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d_a4dfbf5d9df825eeb63b294c6849bdcab_cgraph.map b/d2/d8a/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d_a4dfbf5d9df825eeb63b294c6849bdcab_cgraph.map new file mode 100644 index 000000000..12d8dfe45 --- /dev/null +++ b/d2/d8a/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d_a4dfbf5d9df825eeb63b294c6849bdcab_cgraph.map @@ -0,0 +1,6 @@ + + + + + + diff --git a/d2/d8a/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d_a4dfbf5d9df825eeb63b294c6849bdcab_cgraph.md5 b/d2/d8a/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d_a4dfbf5d9df825eeb63b294c6849bdcab_cgraph.md5 new file mode 100644 index 000000000..5b3bea922 --- /dev/null +++ b/d2/d8a/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d_a4dfbf5d9df825eeb63b294c6849bdcab_cgraph.md5 @@ -0,0 +1 @@ +613b4ed02f561c3092a9d717650d147e \ No newline at end of file diff --git a/d2/d8a/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d_a4dfbf5d9df825eeb63b294c6849bdcab_cgraph.svg b/d2/d8a/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d_a4dfbf5d9df825eeb63b294c6849bdcab_cgraph.svg new file mode 100644 index 000000000..24ff9e4fe --- /dev/null +++ b/d2/d8a/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d_a4dfbf5d9df825eeb63b294c6849bdcab_cgraph.svg @@ -0,0 +1,75 @@ + + + + + + +range_queries::heavy_light_decomposition::HLD::query + + + +Node1 + + +range_queries::heavy +_light_decomposition +::HLD::query + + + + + +Node2 + + +range_queries::heavy +_light_decomposition +::HLD::chain_query + + + + + +Node1->Node2 + + + + + +Node3 + + +range_queries::heavy +_light_decomposition +::Tree::lca + + + + + +Node1->Node3 + + + + + +Node4 + + +range_queries::heavy +_light_decomposition +::Tree::lift + + + + + +Node3->Node4 + + + + + diff --git a/d2/d8a/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d_a6e486767434e44076c1ac374a22da726_cgraph.map b/d2/d8a/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d_a6e486767434e44076c1ac374a22da726_cgraph.map new file mode 100644 index 000000000..daceec39c --- /dev/null +++ b/d2/d8a/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d_a6e486767434e44076c1ac374a22da726_cgraph.map @@ -0,0 +1,5 @@ + + + + + diff --git a/d2/d8a/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d_a6e486767434e44076c1ac374a22da726_cgraph.md5 b/d2/d8a/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d_a6e486767434e44076c1ac374a22da726_cgraph.md5 new file mode 100644 index 000000000..8b70df609 --- /dev/null +++ b/d2/d8a/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d_a6e486767434e44076c1ac374a22da726_cgraph.md5 @@ -0,0 +1 @@ +1bc573c2c35f81f7d068d1ef8f03da9f \ No newline at end of file diff --git a/d2/d8a/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d_a6e486767434e44076c1ac374a22da726_cgraph.svg b/d2/d8a/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d_a6e486767434e44076c1ac374a22da726_cgraph.svg new file mode 100644 index 000000000..30809adde --- /dev/null +++ b/d2/d8a/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d_a6e486767434e44076c1ac374a22da726_cgraph.svg @@ -0,0 +1,56 @@ + + + + + + +range_queries::heavy_light_decomposition::HLD::HLD + + + +Node1 + + +range_queries::heavy +_light_decomposition +::HLD::HLD + + + + + +Node2 + + +range_queries::heavy +_light_decomposition +::SG::combine + + + + + +Node1->Node2 + + + + + +Node3 + + +std::swap + + + + + +Node1->Node3 + + + + + diff --git a/d2/d8a/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d_a9f1cb54ed09fde931bf3220d75ee4c57_cgraph.map b/d2/d8a/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d_a9f1cb54ed09fde931bf3220d75ee4c57_cgraph.map new file mode 100644 index 000000000..77cd58628 --- /dev/null +++ b/d2/d8a/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d_a9f1cb54ed09fde931bf3220d75ee4c57_cgraph.map @@ -0,0 +1,4 @@ + + + + diff --git a/d2/d8a/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d_a9f1cb54ed09fde931bf3220d75ee4c57_cgraph.md5 b/d2/d8a/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d_a9f1cb54ed09fde931bf3220d75ee4c57_cgraph.md5 new file mode 100644 index 000000000..5bc1f5a13 --- /dev/null +++ b/d2/d8a/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d_a9f1cb54ed09fde931bf3220d75ee4c57_cgraph.md5 @@ -0,0 +1 @@ +5ff9b2f90f9c3cd04184b7012e6c613f \ No newline at end of file diff --git a/d2/d8a/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d_a9f1cb54ed09fde931bf3220d75ee4c57_cgraph.svg b/d2/d8a/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d_a9f1cb54ed09fde931bf3220d75ee4c57_cgraph.svg new file mode 100644 index 000000000..e1ca59123 --- /dev/null +++ b/d2/d8a/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d_a9f1cb54ed09fde931bf3220d75ee4c57_cgraph.svg @@ -0,0 +1,41 @@ + + + + + + +range_queries::heavy_light_decomposition::HLD::update + + + +Node1 + + +range_queries::heavy +_light_decomposition +::HLD::update + + + + + +Node2 + + +range_queries::heavy +_light_decomposition +::SG::update + + + + + +Node1->Node2 + + + + + diff --git a/d2/d8a/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d_ae9e979edd69678b85665c01e2ee97828_cgraph.map b/d2/d8a/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d_ae9e979edd69678b85665c01e2ee97828_cgraph.map new file mode 100644 index 000000000..d87c67f62 --- /dev/null +++ b/d2/d8a/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d_ae9e979edd69678b85665c01e2ee97828_cgraph.map @@ -0,0 +1,10 @@ + + + + + + + + + + diff --git a/d2/d8a/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d_ae9e979edd69678b85665c01e2ee97828_cgraph.md5 b/d2/d8a/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d_ae9e979edd69678b85665c01e2ee97828_cgraph.md5 new file mode 100644 index 000000000..8f7dc98c6 --- /dev/null +++ b/d2/d8a/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d_ae9e979edd69678b85665c01e2ee97828_cgraph.md5 @@ -0,0 +1 @@ +1d3a59fdba7e391132e6cdc60cbcc3fa \ No newline at end of file diff --git a/d2/d8a/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d_ae9e979edd69678b85665c01e2ee97828_cgraph.svg b/d2/d8a/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d_ae9e979edd69678b85665c01e2ee97828_cgraph.svg new file mode 100644 index 000000000..b4fb4a758 --- /dev/null +++ b/d2/d8a/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d_ae9e979edd69678b85665c01e2ee97828_cgraph.svg @@ -0,0 +1,143 @@ + + + + + + +range_queries::heavy_light_decomposition::HLD::init + + + +Node1 + + +range_queries::heavy +_light_decomposition +::HLD::init + + + + + +Node2 + + +range_queries::heavy +_light_decomposition +::SG::combine + + + + + +Node1->Node2 + + + + + +Node3 + + +range_queries::heavy +_light_decomposition +::HLD::dfs_hc + + + + + +Node1->Node3 + + + + + +Node4 + + +range_queries::heavy +_light_decomposition +::HLD::dfs_labels + + + + + +Node1->Node4 + + + + + +Node5 + + +range_queries::heavy +_light_decomposition +::HLD::dfs_par + + + + + +Node1->Node5 + + + + + +Node6 + + +range_queries::heavy +_light_decomposition +::Tree::init + + + + + +Node1->Node6 + + + + + +Node7 + + +range_queries::heavy +_light_decomposition +::Tree::dfs_lca + + + + + +Node6->Node7 + + + + + +Node8 + + +range_queries::heavy +_light_decomposition +::Tree::dfs_size + + + + + +Node6->Node8 + + + + + diff --git a/d2/de9/heavy__light__decomposition_8cpp.html b/d2/de9/heavy__light__decomposition_8cpp.html new file mode 100644 index 000000000..747e91a1b --- /dev/null +++ b/d2/de9/heavy__light__decomposition_8cpp.html @@ -0,0 +1,433 @@ + + + + + + + +Algorithms_in_C++: range_queries/heavy_light_decomposition.cpp File Reference + + + + + + + + + + + + + + + +
+
+ + + + + + +
+
Algorithms_in_C++ +  1.0.0 +
+
Set of algorithms implemented in C++.
+
+
+ + + + + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+ +
+ +
+
+Classes | +Namespaces | +Functions
+
+
heavy_light_decomposition.cpp File Reference
+
+
+ +

Heavy Light Decomposition implementation +More...

+
#include <algorithm>
+#include <cassert>
+#include <cmath>
+#include <cstring>
+#include <iostream>
+#include <list>
+#include <numeric>
+#include <string>
+#include <vector>
+
+Include dependency graph for heavy_light_decomposition.cpp:
+
+
+
+
+
+ + + + + + + + + + +

+Classes

class  range_queries::heavy_light_decomposition::Tree< X >
 A Basic Tree, which supports binary lifting. More...
 
class  range_queries::heavy_light_decomposition::SG< X >
 Segment Tree, to store heavy chains. More...
 
class  range_queries::heavy_light_decomposition::HLD< X >
 The Heavy-Light Decomposition class. More...
 
+ + + + + + + +

+Namespaces

 range_queries
 Algorithms and Data Structures that support range queries and updates.
 
 heavy_light_decomposition
 Heavy light decomposition algorithm.
 
+ + + + + + + + + +

+Functions

static void test_1 ()
 
static void test_2 ()
 
static void test_3 ()
 
int main ()
 
+

Detailed Description

+

Heavy Light Decomposition implementation

+
Author
Aniruthan R
+

Heavy-Light Decomposition is a technique on trees, that supports the following:

    +
  1. Update node s, with a value v
    2. +
  2. Return the (sum) of all node values on the simple path from a to b (sum) can also be replced with XOR, OR, AND, min, or max
    3. +
+

The update is done in O(log n) time, and the query is done in O(log^2 n) time with HLD where, n is the number of nodes

+

The template type is the data type of the value stored in the nodes. If a non-primitive data-type is used as a template, the coressponding operators must be overloaded.

+

An HLD object can only be created with a constant number of nodes, and it cannot be changed later. Creaty an empty instance is not supported.

+

To start answering updates and queries,

    +
  1. Create an instance of HLD<X> object (obj), with the required data type.
    2. +
  2. Read in the edge/parent information and update it with obj.add_edge(). Note: The edges addes must be 0 indexed.
    3. +
  3. Create a vector with initial node values, and call set_node_val() with it.
    4. +
  4. Call obj.init() to populate the required information for supporting operations.
    5. +
  5. Call obj.update(node, new_val), to update the value at index 'node' to the new value. Note: node must be 0 indexed
    6. +
  6. Call obj.query(a, b) to get the (sum) of node values in the simple path from a to b. Note: a and b, must be 0 indexed.
    7. +
+

Sample I/O at the bottom.

Todo:
Support edge weight queries, by storing the edge weight value in it's child algorithm verified by testing in CSES path queries: https://cses.fi/problemset/task/1138
+

Function Documentation

+ +

◆ main()

+ +
+
+ + + + + + + +
int main ()
+
+

Main function

+
634  {
+
635  test_1();
+
636  test_2();
+
637  test_3();
+
638  return 0;
+
639 }
+
+Here is the call graph for this function:
+
+
+
+
+ +
+
+ +

◆ test_1()

+ +
+
+ + + + + +
+ + + + + + + +
static void test_1 ()
+ 		+static
+
+

Test implementations

Returns
none
+
505  {
+
506  std::cout << "Test 1:\n";
+
507 
+
508  // Test details
+
509  int n = 5;
+
510  std::vector<int64_t> node_values = {4, 2, 5, 2, 1};
+
511  std::vector<std::vector<int>> edges = {{1, 2}, {1, 3}, {3, 4}, {3, 5}};
+
512  std::vector<std::vector<int>> queries = {
+
513  {2, 1, 4},
+
514  {1, 3, 2},
+
515  {2, 1, 4},
+
516  };
+
517  std::vector<int> expected_result = {11, 8};
+
518  std::vector<int> code_result;
+
519 
+
520  range_queries::heavy_light_decomposition::HLD<int64_t> hld(n);
+
521  hld.set_node_val(node_values);
+
522  for (int i = 0; i < n - 1; i++) {
+
523  int u = edges[i][0], v = edges[i][1];
+
524  hld.add_edge(u - 1, v - 1);
+
525  }
+
526  hld.init();
+
527  for (const auto &q : queries) {
+
528  int type = q[0];
+
529  if (type == 1) {
+
530  int p = q[1], x = q[2];
+
531  hld.update(p - 1, x);
+
532  } else if (type == 2) {
+
533  int a = q[1], b = q[2];
+
534  code_result.push_back(hld.query(a - 1, b - 1));
+
535  } else {
+
536  continue;
+
537  }
+
538  }
+
539  for (int i = 0; i < static_cast<int>(expected_result.size()); i++) {
+
540  assert(expected_result[i] == code_result[i]);
+
541  }
+
542  std::cout << "\nTest 1 passed!\n";
+
543 }
+
+Here is the call graph for this function:
+
+
+
+
+ +
+
+ +

◆ test_2()

+ +
+
+ + + + + +
+ + + + + + + +
static void test_2 ()
+ 		+static
+
+

Second test implementations

Returns
void
+
549  {
+
550  std::cout << "Test 2:\n";
+
551 
+
552  // Test details (Bamboo)
+
553  int n = 10;
+
554  std::vector<int64_t> node_values = {1, 8, 6, 8, 6, 2, 9, 2, 3, 2};
+
555  std::vector<std::vector<int>> edges = {
+
556  {10, 5}, {6, 2}, {10, 7}, {5, 2}, {3, 9}, {8, 3}, {1, 4}, {6, 4}, {8, 7}};
+
557  std::vector<std::vector<int>> queries = {
+
558  {2, 1, 10}, {2, 1, 6}, {1, 3, 4}, {2, 1, 9}, {1, 5, 3},
+
559  {1, 7, 8}, {2, 1, 4}, {2, 1, 8}, {1, 1, 4}, {1, 2, 7}};
+
560  std::vector<int> expected_result = {27, 11, 45, 9, 34};
+
561  std::vector<int> code_result;
+
562 
+
563  range_queries::heavy_light_decomposition::HLD<int64_t> hld(n);
+
564  hld.set_node_val(node_values);
+
565  for (int i = 0; i < n - 1; i++) {
+
566  int u = edges[i][0], v = edges[i][1];
+
567  hld.add_edge(u - 1, v - 1);
+
568  }
+
569  hld.init();
+
570  for (const auto &q : queries) {
+
571  int type = q[0];
+
572  if (type == 1) {
+
573  int p = q[1], x = q[2];
+
574  hld.update(p - 1, x);
+
575  } else if (type == 2) {
+
576  int a = q[1], b = q[2];
+
577  code_result.push_back(hld.query(a - 1, b - 1));
+
578  } else {
+
579  continue;
+
580  }
+
581  }
+
582  for (int i = 0; i < static_cast<int>(expected_result.size()); i++) {
+
583  assert(expected_result[i] == code_result[i]);
+
584  }
+
585  std::cout << "\nTest2 passed!\n";
+
586 }
+
+Here is the call graph for this function:
+
+
+
+
+ +
+
+ +

◆ test_3()

+ +
+
+ + + + + +
+ + + + + + + +
static void test_3 ()
+ 		+static
+
+

Third test implementations

Returns
void
+
592  {
+
593  std::cout << "Test 3:\n";
+
594 
+
595  // Test details
+
596  int n = 8;
+
597  std::vector<int64_t> node_values = {1, 8, 6, 8, 6, 2, 9, 2};
+
598  std::vector<std::vector<int>> edges = {{1, 2}, {2, 3}, {3, 4}, {1, 5},
+
599  {6, 3}, {7, 5}, {8, 7}};
+
600  std::vector<std::vector<int>> queries = {
+
601  {2, 6, 8}, {2, 3, 6}, {1, 3, 4}, {2, 7, 1}, {1, 5, 3},
+
602  {1, 7, 8}, {2, 6, 4}, {2, 7, 8}, {1, 1, 4}, {1, 2, 7}};
+
603  std::vector<int> expected_result = {34, 8, 16, 14, 10};
+
604  std::vector<int> code_result;
+
605 
+
606  range_queries::heavy_light_decomposition::HLD<int64_t> hld(n);
+
607  hld.set_node_val(node_values);
+
608  for (int i = 0; i < n - 1; i++) {
+
609  int u = edges[i][0], v = edges[i][1];
+
610  hld.add_edge(u - 1, v - 1);
+
611  }
+
612  hld.init();
+
613  for (const auto &q : queries) {
+
614  int type = q[0];
+
615  if (type == 1) {
+
616  int p = q[1], x = q[2];
+
617  hld.update(p - 1, x);
+
618  } else if (type == 2) {
+
619  int a = q[1], b = q[2];
+
620  code_result.push_back(hld.query(a - 1, b - 1));
+
621  } else {
+
622  continue;
+
623  }
+
624  }
+
625  for (int i = 0; i < static_cast<int>(expected_result.size()); i++) {
+
626  assert(expected_result[i] == code_result[i]);
+
627  }
+
628  std::cout << "\nTest3 passed!\n";
+
629 }
+
+Here is the call graph for this function:
+
+
+
+
+ +
+
+
+
+
test_3
static void test_3()
Definition: heavy_light_decomposition.cpp:592
+
std::vector
STL class.
+
std::vector::size
T size(T... args)
+
test_2
static void test_2()
Definition: heavy_light_decomposition.cpp:549
+
range_queries::heavy_light_decomposition::HLD
The Heavy-Light Decomposition class.
Definition: heavy_light_decomposition.cpp:336
+
std::vector::push_back
T push_back(T... args)
+
std::cout
+
test_1
static void test_1()
Definition: heavy_light_decomposition.cpp:505
+ + + + diff --git a/d2/de9/heavy__light__decomposition_8cpp.js b/d2/de9/heavy__light__decomposition_8cpp.js new file mode 100644 index 000000000..ba5ada3fd --- /dev/null +++ b/d2/de9/heavy__light__decomposition_8cpp.js @@ -0,0 +1,10 @@ +var heavy__light__decomposition_8cpp = +[ + [ "Tree", "d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree.html", "d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree" ], + [ "SG", "d9/d35/classrange__queries_1_1heavy__light__decomposition_1_1_s_g.html", "d9/d35/classrange__queries_1_1heavy__light__decomposition_1_1_s_g" ], + [ "HLD", "d2/d8a/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d.html", "d2/d8a/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d" ], + [ "main", "d2/de9/heavy__light__decomposition_8cpp.html#ae66f6b31b5ad750f1fe042a706a4e3d4", null ], + [ "test_1", "d2/de9/heavy__light__decomposition_8cpp.html#a34b8683a2b429de5cce57e6d733ec817", null ], + [ "test_2", "d2/de9/heavy__light__decomposition_8cpp.html#a458410412185a5f09199deaff7157a8d", null ], + [ "test_3", "d2/de9/heavy__light__decomposition_8cpp.html#af31ec5409537703d9c8a47350386b32a", null ] +]; \ No newline at end of file diff --git a/d2/de9/heavy__light__decomposition_8cpp_a34b8683a2b429de5cce57e6d733ec817_cgraph.map b/d2/de9/heavy__light__decomposition_8cpp_a34b8683a2b429de5cce57e6d733ec817_cgraph.map new file mode 100644 index 000000000..6208968c2 --- /dev/null +++ b/d2/de9/heavy__light__decomposition_8cpp_a34b8683a2b429de5cce57e6d733ec817_cgraph.map @@ -0,0 +1,21 @@ + + + + + + + + + + + + + + + + + + + + + diff --git a/d2/de9/heavy__light__decomposition_8cpp_a34b8683a2b429de5cce57e6d733ec817_cgraph.md5 b/d2/de9/heavy__light__decomposition_8cpp_a34b8683a2b429de5cce57e6d733ec817_cgraph.md5 new file mode 100644 index 000000000..570cab002 --- /dev/null +++ b/d2/de9/heavy__light__decomposition_8cpp_a34b8683a2b429de5cce57e6d733ec817_cgraph.md5 @@ -0,0 +1 @@ +fdf2e1d607d6492ec2d0cd82c3962d4f \ No newline at end of file diff --git a/d2/de9/heavy__light__decomposition_8cpp_a34b8683a2b429de5cce57e6d733ec817_cgraph.svg b/d2/de9/heavy__light__decomposition_8cpp_a34b8683a2b429de5cce57e6d733ec817_cgraph.svg new file mode 100644 index 000000000..3a06c5550 --- /dev/null +++ b/d2/de9/heavy__light__decomposition_8cpp_a34b8683a2b429de5cce57e6d733ec817_cgraph.svg @@ -0,0 +1,424 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +test_1 + + + +Node1 + + +test_1 + + + + + +Node2 + + +range_queries::heavy +_light_decomposition +::Tree::add_edge + + + + + +Node1->Node2 + + + + + +Node3 + + +std::vector::push_back + + + + + +Node1->Node3 + + + + + +Node4 + + +range_queries::heavy +_light_decomposition +::HLD::init + + + + + +Node1->Node4 + + + + + +Node12 + + +range_queries::heavy +_light_decomposition +::HLD::query + + + + + +Node1->Node12 + + + + + +Node16 + + +range_queries::heavy +_light_decomposition +::Tree::set_node_val + + + + + +Node1->Node16 + + + + + +Node17 + + +std::vector::size + + + + + +Node1->Node17 + + + + + +Node18 + + +range_queries::heavy +_light_decomposition +::HLD::update + + + + + +Node1->Node18 + + + + + +Node2->Node3 + + + + + +Node5 + + +range_queries::heavy +_light_decomposition +::SG::combine + + + + + +Node4->Node5 + + + + + +Node6 + + +range_queries::heavy +_light_decomposition +::HLD::dfs_hc + + + + + +Node4->Node6 + + + + + +Node7 + + +range_queries::heavy +_light_decomposition +::HLD::dfs_labels + + + + + +Node4->Node7 + + + + + +Node8 + + +range_queries::heavy +_light_decomposition +::HLD::dfs_par + + + + + +Node4->Node8 + + + + + +Node9 + + +range_queries::heavy +_light_decomposition +::Tree::init + + + + + +Node4->Node9 + + + + + +Node10 + + +range_queries::heavy +_light_decomposition +::Tree::dfs_lca + + + + + +Node9->Node10 + + + + + +Node11 + + +range_queries::heavy +_light_decomposition +::Tree::dfs_size + + + + + +Node9->Node11 + + + + + +Node13 + + +range_queries::heavy +_light_decomposition +::HLD::chain_query + + + + + +Node12->Node13 + + + + + +Node14 + + +range_queries::heavy +_light_decomposition +::Tree::lca + + + + + +Node12->Node14 + + + + + +Node15 + + +range_queries::heavy +_light_decomposition +::Tree::lift + + + + + +Node14->Node15 + + + + + +Node16->Node17 + + + + + +Node19 + + +range_queries::heavy +_light_decomposition +::SG::update + + + + + +Node18->Node19 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/d2/de9/heavy__light__decomposition_8cpp_a34b8683a2b429de5cce57e6d733ec817_cgraph_org.svg b/d2/de9/heavy__light__decomposition_8cpp_a34b8683a2b429de5cce57e6d733ec817_cgraph_org.svg new file mode 100644 index 000000000..759869227 --- /dev/null +++ b/d2/de9/heavy__light__decomposition_8cpp_a34b8683a2b429de5cce57e6d733ec817_cgraph_org.svg @@ -0,0 +1,336 @@ + + + + + + +test_1 + + + +Node1 + + +test_1 + + + + + +Node2 + + +range_queries::heavy +_light_decomposition +::Tree::add_edge + + + + + +Node1->Node2 + + + + + +Node3 + + +std::vector::push_back + + + + + +Node1->Node3 + + + + + +Node4 + + +range_queries::heavy +_light_decomposition +::HLD::init + + + + + +Node1->Node4 + + + + + +Node12 + + +range_queries::heavy +_light_decomposition +::HLD::query + + + + + +Node1->Node12 + + + + + +Node16 + + +range_queries::heavy +_light_decomposition +::Tree::set_node_val + + + + + +Node1->Node16 + + + + + +Node17 + + +std::vector::size + + + + + +Node1->Node17 + + + + + +Node18 + + +range_queries::heavy +_light_decomposition +::HLD::update + + + + + +Node1->Node18 + + + + + +Node2->Node3 + + + + + +Node5 + + +range_queries::heavy +_light_decomposition +::SG::combine + + + + + +Node4->Node5 + + + + + +Node6 + + +range_queries::heavy +_light_decomposition +::HLD::dfs_hc + + + + + +Node4->Node6 + + + + + +Node7 + + +range_queries::heavy +_light_decomposition +::HLD::dfs_labels + + + + + +Node4->Node7 + + + + + +Node8 + + +range_queries::heavy +_light_decomposition +::HLD::dfs_par + + + + + +Node4->Node8 + + + + + +Node9 + + +range_queries::heavy +_light_decomposition +::Tree::init + + + + + +Node4->Node9 + + + + + +Node10 + + +range_queries::heavy +_light_decomposition +::Tree::dfs_lca + + + + + +Node9->Node10 + + + + + +Node11 + + +range_queries::heavy +_light_decomposition +::Tree::dfs_size + + + + + +Node9->Node11 + + + + + +Node13 + + +range_queries::heavy +_light_decomposition +::HLD::chain_query + + + + + +Node12->Node13 + + + + + +Node14 + + +range_queries::heavy +_light_decomposition +::Tree::lca + + + + + +Node12->Node14 + + + + + +Node15 + + +range_queries::heavy +_light_decomposition +::Tree::lift + + + + + +Node14->Node15 + + + + + +Node16->Node17 + + + + + +Node19 + + +range_queries::heavy +_light_decomposition +::SG::update + + + + + +Node18->Node19 + + + + + diff --git a/d2/de9/heavy__light__decomposition_8cpp_a458410412185a5f09199deaff7157a8d_cgraph.map b/d2/de9/heavy__light__decomposition_8cpp_a458410412185a5f09199deaff7157a8d_cgraph.map new file mode 100644 index 000000000..f95812a87 --- /dev/null +++ b/d2/de9/heavy__light__decomposition_8cpp_a458410412185a5f09199deaff7157a8d_cgraph.map @@ -0,0 +1,21 @@ + + + + + + + + + + + + + + + + + + + + + diff --git a/d2/de9/heavy__light__decomposition_8cpp_a458410412185a5f09199deaff7157a8d_cgraph.md5 b/d2/de9/heavy__light__decomposition_8cpp_a458410412185a5f09199deaff7157a8d_cgraph.md5 new file mode 100644 index 000000000..9ff65200b --- /dev/null +++ b/d2/de9/heavy__light__decomposition_8cpp_a458410412185a5f09199deaff7157a8d_cgraph.md5 @@ -0,0 +1 @@ +528c23ffeae1541b94cd7d5fc3d9be94 \ No newline at end of file diff --git a/d2/de9/heavy__light__decomposition_8cpp_a458410412185a5f09199deaff7157a8d_cgraph.svg b/d2/de9/heavy__light__decomposition_8cpp_a458410412185a5f09199deaff7157a8d_cgraph.svg new file mode 100644 index 000000000..215e1ebdc --- /dev/null +++ b/d2/de9/heavy__light__decomposition_8cpp_a458410412185a5f09199deaff7157a8d_cgraph.svg @@ -0,0 +1,424 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +test_2 + + + +Node1 + + +test_2 + + + + + +Node2 + + +range_queries::heavy +_light_decomposition +::Tree::add_edge + + + + + +Node1->Node2 + + + + + +Node3 + + +std::vector::push_back + + + + + +Node1->Node3 + + + + + +Node4 + + +range_queries::heavy +_light_decomposition +::HLD::init + + + + + +Node1->Node4 + + + + + +Node12 + + +range_queries::heavy +_light_decomposition +::HLD::query + + + + + +Node1->Node12 + + + + + +Node16 + + +range_queries::heavy +_light_decomposition +::Tree::set_node_val + + + + + +Node1->Node16 + + + + + +Node17 + + +std::vector::size + + + + + +Node1->Node17 + + + + + +Node18 + + +range_queries::heavy +_light_decomposition +::HLD::update + + + + + +Node1->Node18 + + + + + +Node2->Node3 + + + + + +Node5 + + +range_queries::heavy +_light_decomposition +::SG::combine + + + + + +Node4->Node5 + + + + + +Node6 + + +range_queries::heavy +_light_decomposition +::HLD::dfs_hc + + + + + +Node4->Node6 + + + + + +Node7 + + +range_queries::heavy +_light_decomposition +::HLD::dfs_labels + + + + + +Node4->Node7 + + + + + +Node8 + + +range_queries::heavy +_light_decomposition +::HLD::dfs_par + + + + + +Node4->Node8 + + + + + +Node9 + + +range_queries::heavy +_light_decomposition +::Tree::init + + + + + +Node4->Node9 + + + + + +Node10 + + +range_queries::heavy +_light_decomposition +::Tree::dfs_lca + + + + + +Node9->Node10 + + + + + +Node11 + + +range_queries::heavy +_light_decomposition +::Tree::dfs_size + + + + + +Node9->Node11 + + + + + +Node13 + + +range_queries::heavy +_light_decomposition +::HLD::chain_query + + + + + +Node12->Node13 + + + + + +Node14 + + +range_queries::heavy +_light_decomposition +::Tree::lca + + + + + +Node12->Node14 + + + + + +Node15 + + +range_queries::heavy +_light_decomposition +::Tree::lift + + + + + +Node14->Node15 + + + + + +Node16->Node17 + + + + + +Node19 + + +range_queries::heavy +_light_decomposition +::SG::update + + + + + +Node18->Node19 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/d2/de9/heavy__light__decomposition_8cpp_a458410412185a5f09199deaff7157a8d_cgraph_org.svg b/d2/de9/heavy__light__decomposition_8cpp_a458410412185a5f09199deaff7157a8d_cgraph_org.svg new file mode 100644 index 000000000..2c13b3f47 --- /dev/null +++ b/d2/de9/heavy__light__decomposition_8cpp_a458410412185a5f09199deaff7157a8d_cgraph_org.svg @@ -0,0 +1,336 @@ + + + + + + +test_2 + + + +Node1 + + +test_2 + + + + + +Node2 + + +range_queries::heavy +_light_decomposition +::Tree::add_edge + + + + + +Node1->Node2 + + + + + +Node3 + + +std::vector::push_back + + + + + +Node1->Node3 + + + + + +Node4 + + +range_queries::heavy +_light_decomposition +::HLD::init + + + + + +Node1->Node4 + + + + + +Node12 + + +range_queries::heavy +_light_decomposition +::HLD::query + + + + + +Node1->Node12 + + + + + +Node16 + + +range_queries::heavy +_light_decomposition +::Tree::set_node_val + + + + + +Node1->Node16 + + + + + +Node17 + + +std::vector::size + + + + + +Node1->Node17 + + + + + +Node18 + + +range_queries::heavy +_light_decomposition +::HLD::update + + + + + +Node1->Node18 + + + + + +Node2->Node3 + + + + + +Node5 + + +range_queries::heavy +_light_decomposition +::SG::combine + + + + + +Node4->Node5 + + + + + +Node6 + + +range_queries::heavy +_light_decomposition +::HLD::dfs_hc + + + + + +Node4->Node6 + + + + + +Node7 + + +range_queries::heavy +_light_decomposition +::HLD::dfs_labels + + + + + +Node4->Node7 + + + + + +Node8 + + +range_queries::heavy +_light_decomposition +::HLD::dfs_par + + + + + +Node4->Node8 + + + + + +Node9 + + +range_queries::heavy +_light_decomposition +::Tree::init + + + + + +Node4->Node9 + + + + + +Node10 + + +range_queries::heavy +_light_decomposition +::Tree::dfs_lca + + + + + +Node9->Node10 + + + + + +Node11 + + +range_queries::heavy +_light_decomposition +::Tree::dfs_size + + + + + +Node9->Node11 + + + + + +Node13 + + +range_queries::heavy +_light_decomposition +::HLD::chain_query + + + + + +Node12->Node13 + + + + + +Node14 + + +range_queries::heavy +_light_decomposition +::Tree::lca + + + + + +Node12->Node14 + + + + + +Node15 + + +range_queries::heavy +_light_decomposition +::Tree::lift + + + + + +Node14->Node15 + + + + + +Node16->Node17 + + + + + +Node19 + + +range_queries::heavy +_light_decomposition +::SG::update + + + + + +Node18->Node19 + + + + + diff --git a/d2/de9/heavy__light__decomposition_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.map b/d2/de9/heavy__light__decomposition_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.map new file mode 100644 index 000000000..9b44c64ce --- /dev/null +++ b/d2/de9/heavy__light__decomposition_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.map @@ -0,0 +1,24 @@ + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/d2/de9/heavy__light__decomposition_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.md5 b/d2/de9/heavy__light__decomposition_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.md5 new file mode 100644 index 000000000..eb415e403 --- /dev/null +++ b/d2/de9/heavy__light__decomposition_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.md5 @@ -0,0 +1 @@ +20bffa84e5da91b3b14d79e9259df1e8 \ No newline at end of file diff --git a/d2/de9/heavy__light__decomposition_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.svg b/d2/de9/heavy__light__decomposition_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.svg new file mode 100644 index 000000000..bb27b507d --- /dev/null +++ b/d2/de9/heavy__light__decomposition_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.svg @@ -0,0 +1,553 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +main + + + +Node1 + + +main + + + + + +Node2 + + +test_1 + + + + + +Node1->Node2 + + + + + +Node21 + + +test_2 + + + + + +Node1->Node21 + + + + + +Node22 + + +test_3 + + + + + +Node1->Node22 + + + + + +Node3 + + +range_queries::heavy +_light_decomposition +::Tree::add_edge + + + + + +Node2->Node3 + + + + + +Node4 + + +std::vector::push_back + + + + + +Node2->Node4 + + + + + +Node5 + + +range_queries::heavy +_light_decomposition +::HLD::init + + + + + +Node2->Node5 + + + + + +Node13 + + +range_queries::heavy +_light_decomposition +::HLD::query + + + + + +Node2->Node13 + + + + + +Node17 + + +range_queries::heavy +_light_decomposition +::Tree::set_node_val + + + + + +Node2->Node17 + + + + + +Node18 + + +std::vector::size + + + + + +Node2->Node18 + + + + + +Node19 + + +range_queries::heavy +_light_decomposition +::HLD::update + + + + + +Node2->Node19 + + + + + +Node3->Node4 + + + + + +Node6 + + +range_queries::heavy +_light_decomposition +::SG::combine + + + + + +Node5->Node6 + + + + + +Node7 + + +range_queries::heavy +_light_decomposition +::HLD::dfs_hc + + + + + +Node5->Node7 + + + + + +Node8 + + +range_queries::heavy +_light_decomposition +::HLD::dfs_labels + + + + + +Node5->Node8 + + + + + +Node9 + + +range_queries::heavy +_light_decomposition +::HLD::dfs_par + + + + + +Node5->Node9 + + + + + +Node10 + + +range_queries::heavy +_light_decomposition +::Tree::init + + + + + +Node5->Node10 + + + + + +Node11 + + +range_queries::heavy +_light_decomposition +::Tree::dfs_lca + + + + + +Node10->Node11 + + + + + +Node12 + + +range_queries::heavy +_light_decomposition +::Tree::dfs_size + + + + + +Node10->Node12 + + + + + +Node14 + + +range_queries::heavy +_light_decomposition +::HLD::chain_query + + + + + +Node13->Node14 + + + + + +Node15 + + +range_queries::heavy +_light_decomposition +::Tree::lca + + + + + +Node13->Node15 + + + + + +Node16 + + +range_queries::heavy +_light_decomposition +::Tree::lift + + + + + +Node15->Node16 + + + + + +Node17->Node18 + + + + + +Node20 + + +range_queries::heavy +_light_decomposition +::SG::update + + + + + +Node19->Node20 + + + + + +Node21->Node3 + + + + + +Node21->Node4 + + + + + +Node21->Node5 + + + + + +Node21->Node13 + + + + + +Node21->Node17 + + + + + +Node21->Node18 + + + + + +Node21->Node19 + + + + + +Node22->Node3 + + + + + +Node22->Node4 + + + + + +Node22->Node5 + + + + + +Node22->Node13 + + + + + +Node22->Node17 + + + + + +Node22->Node18 + + + + + +Node22->Node19 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/d2/de9/heavy__light__decomposition_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph_org.svg b/d2/de9/heavy__light__decomposition_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph_org.svg new file mode 100644 index 000000000..bc771f48c --- /dev/null +++ b/d2/de9/heavy__light__decomposition_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph_org.svg @@ -0,0 +1,465 @@ + + + + + + +main + + + +Node1 + + +main + + + + + +Node2 + + +test_1 + + + + + +Node1->Node2 + + + + + +Node21 + + +test_2 + + + + + +Node1->Node21 + + + + + +Node22 + + +test_3 + + + + + +Node1->Node22 + + + + + +Node3 + + +range_queries::heavy +_light_decomposition +::Tree::add_edge + + + + + +Node2->Node3 + + + + + +Node4 + + +std::vector::push_back + + + + + +Node2->Node4 + + + + + +Node5 + + +range_queries::heavy +_light_decomposition +::HLD::init + + + + + +Node2->Node5 + + + + + +Node13 + + +range_queries::heavy +_light_decomposition +::HLD::query + + + + + +Node2->Node13 + + + + + +Node17 + + +range_queries::heavy +_light_decomposition +::Tree::set_node_val + + + + + +Node2->Node17 + + + + + +Node18 + + +std::vector::size + + + + + +Node2->Node18 + + + + + +Node19 + + +range_queries::heavy +_light_decomposition +::HLD::update + + + + + +Node2->Node19 + + + + + +Node3->Node4 + + + + + +Node6 + + +range_queries::heavy +_light_decomposition +::SG::combine + + + + + +Node5->Node6 + + + + + +Node7 + + +range_queries::heavy +_light_decomposition +::HLD::dfs_hc + + + + + +Node5->Node7 + + + + + +Node8 + + +range_queries::heavy +_light_decomposition +::HLD::dfs_labels + + + + + +Node5->Node8 + + + + + +Node9 + + +range_queries::heavy +_light_decomposition +::HLD::dfs_par + + + + + +Node5->Node9 + + + + + +Node10 + + +range_queries::heavy +_light_decomposition +::Tree::init + + + + + +Node5->Node10 + + + + + +Node11 + + +range_queries::heavy +_light_decomposition +::Tree::dfs_lca + + + + + +Node10->Node11 + + + + + +Node12 + + +range_queries::heavy +_light_decomposition +::Tree::dfs_size + + + + + +Node10->Node12 + + + + + +Node14 + + +range_queries::heavy +_light_decomposition +::HLD::chain_query + + + + + +Node13->Node14 + + + + + +Node15 + + +range_queries::heavy +_light_decomposition +::Tree::lca + + + + + +Node13->Node15 + + + + + +Node16 + + +range_queries::heavy +_light_decomposition +::Tree::lift + + + + + +Node15->Node16 + + + + + +Node17->Node18 + + + + + +Node20 + + +range_queries::heavy +_light_decomposition +::SG::update + + + + + +Node19->Node20 + + + + + +Node21->Node3 + + + + + +Node21->Node4 + + + + + +Node21->Node5 + + + + + +Node21->Node13 + + + + + +Node21->Node17 + + + + + +Node21->Node18 + + + + + +Node21->Node19 + + + + + +Node22->Node3 + + + + + +Node22->Node4 + + + + + +Node22->Node5 + + + + + +Node22->Node13 + + + + + +Node22->Node17 + + + + + +Node22->Node18 + + + + + +Node22->Node19 + + + + + diff --git a/d2/de9/heavy__light__decomposition_8cpp_af31ec5409537703d9c8a47350386b32a_cgraph.map b/d2/de9/heavy__light__decomposition_8cpp_af31ec5409537703d9c8a47350386b32a_cgraph.map new file mode 100644 index 000000000..d7b80dd27 --- /dev/null +++ b/d2/de9/heavy__light__decomposition_8cpp_af31ec5409537703d9c8a47350386b32a_cgraph.map @@ -0,0 +1,21 @@ + + + + + + + + + + + + + + + + + + + + + diff --git a/d2/de9/heavy__light__decomposition_8cpp_af31ec5409537703d9c8a47350386b32a_cgraph.md5 b/d2/de9/heavy__light__decomposition_8cpp_af31ec5409537703d9c8a47350386b32a_cgraph.md5 new file mode 100644 index 000000000..36205611b --- /dev/null +++ b/d2/de9/heavy__light__decomposition_8cpp_af31ec5409537703d9c8a47350386b32a_cgraph.md5 @@ -0,0 +1 @@ +5764309ab9b9b4eea055eef788603a20 \ No newline at end of file diff --git a/d2/de9/heavy__light__decomposition_8cpp_af31ec5409537703d9c8a47350386b32a_cgraph.svg b/d2/de9/heavy__light__decomposition_8cpp_af31ec5409537703d9c8a47350386b32a_cgraph.svg new file mode 100644 index 000000000..9473619cc --- /dev/null +++ b/d2/de9/heavy__light__decomposition_8cpp_af31ec5409537703d9c8a47350386b32a_cgraph.svg @@ -0,0 +1,424 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +test_3 + + + +Node1 + + +test_3 + + + + + +Node2 + + +range_queries::heavy +_light_decomposition +::Tree::add_edge + + + + + +Node1->Node2 + + + + + +Node3 + + +std::vector::push_back + + + + + +Node1->Node3 + + + + + +Node4 + + +range_queries::heavy +_light_decomposition +::HLD::init + + + + + +Node1->Node4 + + + + + +Node12 + + +range_queries::heavy +_light_decomposition +::HLD::query + + + + + +Node1->Node12 + + + + + +Node16 + + +range_queries::heavy +_light_decomposition +::Tree::set_node_val + + + + + +Node1->Node16 + + + + + +Node17 + + +std::vector::size + + + + + +Node1->Node17 + + + + + +Node18 + + +range_queries::heavy +_light_decomposition +::HLD::update + + + + + +Node1->Node18 + + + + + +Node2->Node3 + + + + + +Node5 + + +range_queries::heavy +_light_decomposition +::SG::combine + + + + + +Node4->Node5 + + + + + +Node6 + + +range_queries::heavy +_light_decomposition +::HLD::dfs_hc + + + + + +Node4->Node6 + + + + + +Node7 + + +range_queries::heavy +_light_decomposition +::HLD::dfs_labels + + + + + +Node4->Node7 + + + + + +Node8 + + +range_queries::heavy +_light_decomposition +::HLD::dfs_par + + + + + +Node4->Node8 + + + + + +Node9 + + +range_queries::heavy +_light_decomposition +::Tree::init + + + + + +Node4->Node9 + + + + + +Node10 + + +range_queries::heavy +_light_decomposition +::Tree::dfs_lca + + + + + +Node9->Node10 + + + + + +Node11 + + +range_queries::heavy +_light_decomposition +::Tree::dfs_size + + + + + +Node9->Node11 + + + + + +Node13 + + +range_queries::heavy +_light_decomposition +::HLD::chain_query + + + + + +Node12->Node13 + + + + + +Node14 + + +range_queries::heavy +_light_decomposition +::Tree::lca + + + + + +Node12->Node14 + + + + + +Node15 + + +range_queries::heavy +_light_decomposition +::Tree::lift + + + + + +Node14->Node15 + + + + + +Node16->Node17 + + + + + +Node19 + + +range_queries::heavy +_light_decomposition +::SG::update + + + + + +Node18->Node19 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/d2/de9/heavy__light__decomposition_8cpp_af31ec5409537703d9c8a47350386b32a_cgraph_org.svg b/d2/de9/heavy__light__decomposition_8cpp_af31ec5409537703d9c8a47350386b32a_cgraph_org.svg new file mode 100644 index 000000000..a039cb248 --- /dev/null +++ b/d2/de9/heavy__light__decomposition_8cpp_af31ec5409537703d9c8a47350386b32a_cgraph_org.svg @@ -0,0 +1,336 @@ + + + + + + +test_3 + + + +Node1 + + +test_3 + + + + + +Node2 + + +range_queries::heavy +_light_decomposition +::Tree::add_edge + + + + + +Node1->Node2 + + + + + +Node3 + + +std::vector::push_back + + + + + +Node1->Node3 + + + + + +Node4 + + +range_queries::heavy +_light_decomposition +::HLD::init + + + + + +Node1->Node4 + + + + + +Node12 + + +range_queries::heavy +_light_decomposition +::HLD::query + + + + + +Node1->Node12 + + + + + +Node16 + + +range_queries::heavy +_light_decomposition +::Tree::set_node_val + + + + + +Node1->Node16 + + + + + +Node17 + + +std::vector::size + + + + + +Node1->Node17 + + + + + +Node18 + + +range_queries::heavy +_light_decomposition +::HLD::update + + + + + +Node1->Node18 + + + + + +Node2->Node3 + + + + + +Node5 + + +range_queries::heavy +_light_decomposition +::SG::combine + + + + + +Node4->Node5 + + + + + +Node6 + + +range_queries::heavy +_light_decomposition +::HLD::dfs_hc + + + + + +Node4->Node6 + + + + + +Node7 + + +range_queries::heavy +_light_decomposition +::HLD::dfs_labels + + + + + +Node4->Node7 + + + + + +Node8 + + +range_queries::heavy +_light_decomposition +::HLD::dfs_par + + + + + +Node4->Node8 + + + + + +Node9 + + +range_queries::heavy +_light_decomposition +::Tree::init + + + + + +Node4->Node9 + + + + + +Node10 + + +range_queries::heavy +_light_decomposition +::Tree::dfs_lca + + + + + +Node9->Node10 + + + + + +Node11 + + +range_queries::heavy +_light_decomposition +::Tree::dfs_size + + + + + +Node9->Node11 + + + + + +Node13 + + +range_queries::heavy +_light_decomposition +::HLD::chain_query + + + + + +Node12->Node13 + + + + + +Node14 + + +range_queries::heavy +_light_decomposition +::Tree::lca + + + + + +Node12->Node14 + + + + + +Node15 + + +range_queries::heavy +_light_decomposition +::Tree::lift + + + + + +Node14->Node15 + + + + + +Node16->Node17 + + + + + +Node19 + + +range_queries::heavy +_light_decomposition +::SG::update + + + + + +Node18->Node19 + + + + + diff --git a/d3/d40/graph__coloring_8cpp.html b/d3/d40/graph__coloring_8cpp.html index 2a0ad1d13..b318bbcc8 100644 --- a/d3/d40/graph__coloring_8cpp.html +++ b/d3/d40/graph__coloring_8cpp.html @@ -183,6 +183,7 @@ Functions
std::srand
T srand(T... args)
main
int main()
Definition: knuth_morris_pratt.cpp:76
main
int main()
Definition: fenwick_tree.cpp:69
+
std::vector::resize
T resize(T... args)
ternary_search
void ternary_search(int N, int A[], int target)
Definition: ternary_search.cpp:127
std::floor
T floor(T... args)
test3
void test3()
Definition: smallest_circle.cpp:188
@@ -198,27 +199,44 @@ Functions
tolowerRoman
std::string tolowerRoman(int n)
Definition: decimal_to_roman_numeral.cpp:24
test_f
void test_f(const int NUM_DATA)
Definition: shell_sort2.cpp:145
string_search
String search algorithms.
Definition: brute_force_string_searching.cpp:13
+
range_queries::heavy_light_decomposition::HLD::chain_query
X chain_query(int a, int b)
Utility function to break down a path query into two chain queries.
Definition: heavy_light_decomposition.cpp:409
MAX
#define MAX
Definition: fibonacci_fast.cpp:27
+
range_queries::heavy_light_decomposition::Tree::t_size
std::vector< int > t_size
a vector to store the subtree size rooted at node
Definition: heavy_light_decomposition.cpp:89
show_data
void show_data(T *arr, size_t LEN)
Definition: shell_sort2.cpp:18
std::list
STL class.
+
range_queries::heavy_light_decomposition::Tree::dfs_lca
void dfs_lca(int u, int p=-1)
Utility function to populate the t_par vector.
Definition: heavy_light_decomposition.cpp:116
heapSort
void heapSort(T *arr, int n)
Definition: heap_sort.cpp:84
std::clock_t
+
range_queries::heavy_light_decomposition::Tree::t_root
int t_root
the root of the tree
Definition: heavy_light_decomposition.cpp:91
std::move
T move(T... args)
main
int main()
Definition: binomial_dist.cpp:84
addition_rule_dependent
double addition_rule_dependent(double A, double B, double B_given_A)
Definition: addition_rule.cpp:25
+
range_queries::heavy_light_decomposition::Tree::t_maxlift
const int t_maxlift
maximum possible height of the tree
Definition: heavy_light_decomposition.cpp:85
+
range_queries::heavy_light_decomposition::Tree::lca
int lca(int a, int b)
The function returns the least common ancestor of two nodes.
Definition: heavy_light_decomposition.cpp:229
+
range_queries::heavy_light_decomposition::Tree::set_node_val
void set_node_val(const std::vector< X > &node_val)
Set the values for all the nodes.
Definition: heavy_light_decomposition.cpp:175
test2
void test2()
Definition: smallest_circle.cpp:173
+
range_queries::heavy_light_decomposition::Tree::init
void init()
This function must be called after the tree adjacency list and node values are populated The function...
Definition: heavy_light_decomposition.cpp:186
+
test_3
static void test_3()
Definition: heavy_light_decomposition.cpp:592
std::pair
+
range_queries::heavy_light_decomposition::Tree
A Basic Tree, which supports binary lifting.
Definition: heavy_light_decomposition.cpp:78
+
range_queries::heavy_light_decomposition::SG::update
void update(int p, X v)
Update the value at a node.
Definition: heavy_light_decomposition.cpp:293
+
range_queries::heavy_light_decomposition::Tree::Tree
Tree(int nodes)
Class parameterized constructor, resizes the and initializes the data members.
Definition: heavy_light_decomposition.cpp:140
random_tests
bool random_tests()
random tests which cover cases when we have one, multiple or zero occurences of the value we're looki...
Definition: fibonacci_search.cpp:96
std::vector
STL class.
std::find
T find(T... args)
+
range_queries::heavy_light_decomposition::SG::sret_init
X sret_init
inital query return value
Definition: heavy_light_decomposition.cpp:264
std::vector::size
T size(T... args)
Point::x
double x
Definition: smallest_circle.cpp:16
+
test_2
static void test_2()
Definition: heavy_light_decomposition.cpp:549
main
int main()
Definition: decimal_to_roman_numeral.cpp:90
FenwickTree::sum_range
int sum_range(int l, int r)
Definition: fenwick_tree.cpp:65
test
void test()
Definition: heap_sort.cpp:99
absolutePrecision
#define absolutePrecision
Definition: ternary_search.cpp:22
ans
ll ans(ll n)
Definition: matrix_exponentiation.cpp:91
+
range_queries::heavy_light_decomposition::HLD::init
void init()
This function must be called after the tree adjacency list and node values are populated The function...
Definition: heavy_light_decomposition.cpp:450
+
range_queries::heavy_light_decomposition::SG::combine
X combine(X lhs, X rhs)
Function that specifies the type of operation involved when segments are combined.
Definition: heavy_light_decomposition.cpp:274
FenwickTree
Definition: fenwick_tree.cpp:17
+
range_queries::heavy_light_decomposition::Tree::add_edge
void add_edge(const int u, const int v)
Adds an undirected edge from node u to node v in the tree.
Definition: heavy_light_decomposition.cpp:157
main
int main()
Definition: gnome_sort.cpp:130
sorting::insertionSort
void insertionSort(T *arr, int n)
Insertion Sort Function.
Definition: insertion_sort.cpp:59
HASHMAX
#define HASHMAX
Determines the length of the hash table.
Definition: hash_search.cpp:22
@@ -247,8 +265,10 @@ Functions
sorting::merge
void merge(Iterator, Iterator, const Iterator, char[])
merges 2 sorted adjacent segments into a larger sorted segment
Definition: non_recursive_merge_sort.cpp:57
sorting::shuffle
std::array< T, N > shuffle(std::array< T, N > arr)
Definition: bogo_sort.cpp:36
main
int main()
Definition: linear_search.cpp:27
+
range_queries::heavy_light_decomposition::HLD::update
void update(int node, X val)
This function updates the value at node with val.
Definition: heavy_light_decomposition.cpp:475
eqd
static float eqd(float y)
Definition: successive_approximation.cpp:17
show_array
void show_array(const std::array< T, N > &arr)
Definition: bogo_sort.cpp:68
+
range_queries::heavy_light_decomposition::SG::SG
SG(int size)
Class parameterized constructor. Resizes the and initilizes the data members.
Definition: heavy_light_decomposition.cpp:282
std::sort
T sort(T... args)
fill
std::string fill(char c, int n)
Definition: decimal_to_roman_numeral.cpp:15
mat_mul
void mat_mul(const std::valarray< std::valarray< double >> &A, const std::valarray< std::valarray< double >> &B, std::valarray< std::valarray< double >> *OUT)
Definition: qr_eigen_values.cpp:54
@@ -256,6 +276,7 @@ Functions
std::sqrt
T sqrt(T... args)
stack_idx
int stack_idx
pointer to track stack index
Definition: paranthesis_matching.cpp:23
main
int main(int argc, char *argv[])
Definition: shell_sort2.cpp:183
+
range_queries::heavy_light_decomposition::HLD
The Heavy-Light Decomposition class.
Definition: heavy_light_decomposition.cpp:336
main
int main()
Definition: interpolation_search2.cpp:32
compare
int compare(const void *a, const void *b)
Definition: shell_sort2.cpp:87
string_search::brute_force
int brute_force(const std::string &text, const std::string &pattern)
Definition: brute_force_string_searching.cpp:21
@@ -263,6 +284,7 @@ Functions
std::is_sorted
T is_sorted(T... args)
fibonacci_search
int fibonacci_search(const std::vector< int > &arr, int value)
using fibonacci search algorithm finds an index of a given element in a sorted array
Definition: fibonacci_search.cpp:23
qr_algorithm
Functions to compute QR decomposition of any rectangular matrix.
+
range_queries::heavy_light_decomposition::Tree::lift
void lift(int *const p, int dist)
The function lifts a node, k units up the tree. The lifting is done in place, and the result is store...
Definition: heavy_light_decomposition.cpp:200
FenwickTree::offset
int offset(int x)
Definition: fenwick_tree.cpp:22
create_matrix
void create_matrix(std::valarray< std::valarray< double >> *A)
Definition: qr_eigen_values.cpp:28
main
int main()
Definition: happy_number.cpp:29
@@ -279,18 +301,23 @@ Functions
string_search::recalculate_hash
int64_t recalculate_hash(const std::string &s, int old_index, int new_index, int64_t old_hash, int patLength)
Definition: rabin_karp.cpp:42
main
int main()
Definition: smallest_circle.cpp:198
test_int
void test_int(const int NUM_DATA)
Definition: shell_sort2.cpp:105
+
range_queries::heavy_light_decomposition::HLD::dfs_par
void dfs_par(int u, int p=-1)
Utility function to assign highest parent that can be reached though heavy chains.
Definition: heavy_light_decomposition.cpp:371
pascal_triangle
int ** pascal_triangle(int **arr, int n)
Definition: pascal_triangle.cpp:36
CombSort
void CombSort(int *arr, int l, int r)
Definition: comb_sort.cpp:42
sorting::quicksort
void quicksort(std::vector< T > *arr, int32_t low, int32_t high)
Definition: quick_sort_3.cpp:94
insert
node * insert(node *root, int item)
Definition: avltree.cpp:66
std::printf
T printf(T... args)
+
range_queries::heavy_light_decomposition::HLD::h_heavychlid
std::vector< int > h_heavychlid
stores the heavy child of a node
Definition: heavy_light_decomposition.cpp:340
FenwickTree::FenwickTree
FenwickTree(const std::vector< int > &arr)
Definition: fenwick_tree.cpp:28
mergeSort
void mergeSort(int *arr, int l, int r)
Definition: merge_sort.cpp:83
main
int main()
Definition: matrix_exponentiation.cpp:126
+
range_queries::heavy_light_decomposition::Tree::t_adj
std::vector< std::list< int > > t_adj
an adjacency list to stores the tree edges
Definition: heavy_light_decomposition.cpp:83
main
int main()
Definition: fast_interger_input.cpp:39
std::cout
+
range_queries::heavy_light_decomposition::SG::s_tree
std::vector< X > s_tree
Everything here is private, and can only be accessed through the methods, in the derived class (HLD)
Definition: heavy_light_decomposition.cpp:262
qr_decompose.h
Library functions to compute QR decomposition of a given matrix.
merge
void merge(int *arr, int l, int m, int r)
Definition: merge_sort.cpp:33
+
range_queries::heavy_light_decomposition::Tree::kth_ancestor
int kth_ancestor(int p, const int &dist)
The function returns the kth ancestor of a node.
Definition: heavy_light_decomposition.cpp:218
create_random_array
static void create_random_array(T *arr, int N)
Create a random array objecthelper function to create a random array.
Definition: insertion_sort.cpp:101
h
int h(int key)
Definition: hash_search.cpp:45
sorting::non_recursive_merge_sort
void non_recursive_merge_sort(const Iterator first, const Iterator last)
bottom-up merge sort which sorts elements in a non-decreasing order
Definition: non_recursive_merge_sort.cpp:86
@@ -300,7 +327,9 @@ Functions
_target
#define _target
Definition: ternary_search.cpp:27
test
void test()
Definition: bogo_sort.cpp:78
binary_search
int binary_search(int a[], int r, int key)
Definition: binary_search.cpp:15
+
range_queries::heavy_light_decomposition::Tree::t_nodes
const int t_nodes
number of nodes
Definition: heavy_light_decomposition.cpp:84
opening
char opening(char ch)
Definition: paranthesis_matching.cpp:36
+
range_queries::heavy_light_decomposition::HLD::dfs_hc
void dfs_hc(int u, int p=-1)
Utility function to assign heavy child to each node (-1 for a leaf node)
Definition: heavy_light_decomposition.cpp:350
is_happy
bool is_happy(T n)
Definition: happy_number.cpp:14
string_search::check_if_equal
bool check_if_equal(const std::string &str1, const std::string &str2, int start1, int end1, int start2, int end2)
Definition: rabin_karp.cpp:60
main
int main()
Definition: median_search.cpp:38
@@ -314,11 +343,13 @@ Functions
poisson_range_successes
double poisson_range_successes(double expected, double lower, double upper)
Definition: poisson_dist.cpp:54
main
int main()
Definition: tower_of_hanoi.cpp:65
sorting::non_recursive_merge_sort
void non_recursive_merge_sort(const Iterator first, const Iterator last, const size_t n)
bottom-up merge sort which sorts elements in a non-decreasing order
Definition: non_recursive_merge_sort.cpp:25
+
range_queries::heavy_light_decomposition::HLD::label
int label
utility member to assign labels in dfs_labels()
Definition: heavy_light_decomposition.cpp:338
ll
#define ll
Definition: matrix_exponentiation.cpp:33
std::string::erase
T erase(T... args)
std::valarray
STL class.
binomial_standard_deviation
double binomial_standard_deviation(double n, double p)
Definition: binomial_dist.cpp:36
sorting::gnomeSort
void gnomeSort(T *arr, int size)
Definition: gnome_sort.cpp:34
+
range_queries::heavy_light_decomposition::Tree::t_par
std::vector< std::vector< int > > t_par
a matrix to store every node's 2^kth parent
Definition: heavy_light_decomposition.cpp:87
TriangleArea
double TriangleArea(const Point &A, const Point &B, const Point &C)
Definition: smallest_circle.cpp:54
main
int main()
Definition: brute_force_string_searching.cpp:47
std::int64_t
@@ -349,28 +380,38 @@ Functions
main
int main()
Definition: heap_sort.cpp:120
hashtab
node hashtab[HASHMAX]
array of nodes
Definition: hash_search.cpp:35
std::string::substr
T substr(T... args)
+
heavy_light_decomposition
Heavy light decomposition algorithm.
it_ternary_search
int it_ternary_search(int left, int right, int A[], int target)
Definition: ternary_search.cpp:48
jumpSearch
int jumpSearch(int arr[], int x, int n)
Definition: jump_search.cpp:12
data
int data[MAX]
test data
Definition: hash_search.cpp:24
method1
void method1(int number)
Definition: decimal_to_binary.cpp:11
test1
void test1()
Definition: qr_eigen_values.cpp:177
no_occurence_tests
bool no_occurence_tests()
random tests for checking performance when an array doesn't contain an element
Definition: fibonacci_search.cpp:72
+
test_1
static void test_1()
Definition: heavy_light_decomposition.cpp:505
+
range_queries::heavy_light_decomposition::SG::query
X query(int l, int r)
Make a range query from node label l to node label r.
Definition: heavy_light_decomposition.cpp:305
+
range_queries::heavy_light_decomposition::HLD::dfs_labels
void dfs_labels(int u, int p=-1)
Utility function to lable the nodes so that heavy chains have a contigous lable.
Definition: heavy_light_decomposition.cpp:390
printArray
void printArray(T *arr, int sz)
Definition: heap_sort.cpp:37
std::lower_bound
T lower_bound(T... args)
main
int main()
Definition: hash_search.cpp:99
std::endl
T endl(T... args)
+
range_queries::heavy_light_decomposition::Tree::t_val
std::vector< X > t_val
values of nodes
Definition: heavy_light_decomposition.cpp:92
+
range_queries::heavy_light_decomposition::SG::s_size
int s_size
number of leaves in the segment tree
Definition: heavy_light_decomposition.cpp:263
std::left
T left(T... args)
create_list
void create_list(int key)
Definition: hash_search.cpp:55
fact
double fact(double x)
Definition: poisson_dist.cpp:30
+
range_queries::heavy_light_decomposition::SG::set_sret_init
void set_sret_init(X new_sret_init)
Set the initialization for the query data type, based on requirement.
Definition: heavy_light_decomposition.cpp:329
std::exp
T exp(T... args)
std::string::begin
T begin(T... args)
std::getline
T getline(T... args)
std
STL namespace.
+
range_queries::heavy_light_decomposition::SG
Segment Tree, to store heavy chains.
Definition: heavy_light_decomposition.cpp:254
+
main
int main()
Definition: heavy_light_decomposition.cpp:634
addition_rule_independent
double addition_rule_independent(double A, double B)
Definition: addition_rule.cpp:14
sorting::randomized_bogosort
std::array< T, N > randomized_bogosort(std::array< T, N > arr)
Definition: bogo_sort.cpp:51
show
void show(const struct tower *const F, const struct tower *const T, const struct tower *const U)
Definition: tower_of_hanoi.cpp:19
main
int main()
Definition: sparse_matrix.cpp:9
test
void test()
Definition: smallest_circle.cpp:158
+
range_queries
Algorithms and Data Structures that support range queries and updates.
compare
Definition: huffman.cpp:28
main
int main()
Definition: spiral_print.cpp:69
MAX
#define MAX
Definition: paranthesis_matching.cpp:16
@@ -378,8 +419,10 @@ Functions
power
vector< vector< ll > > power(const vector< vector< ll >> &A, ll p)
Definition: matrix_exponentiation.cpp:76
graph
Graph algorithms.
main
int main()
Definition: successive_approximation.cpp:20
+
range_queries::heavy_light_decomposition::HLD::h_parent
std::vector< int > h_parent
stores the top of the heavy chain from a node
Definition: heavy_light_decomposition.cpp:341
std::count
T count(T... args)
tests
void tests()
Definition: insertion_sort.cpp:109
+
range_queries::heavy_light_decomposition::HLD::query
X query(int a, int b)
This function returns the sum of node values in the simple path from from node_1 to node_2.
Definition: heavy_light_decomposition.cpp:489
LinearSearch
int LinearSearch(int *array, int size, int key)
Definition: linear_search.cpp:16
std::vector::assign
T assign(T... args)
IsPrime
bool IsPrime(int number)
Definition: primality_test.cpp:18
@@ -390,6 +433,7 @@ Functions
genArray
void genArray(int **a, int r, int c)
Definition: spiral_print.cpp:12
main
int main()
Definition: comb_sort.cpp:88
operator<<
static std::ostream & operator<<(std::ostream &out, matrix< T > const &v)
Definition: hill_cipher.cpp:54
+
range_queries::heavy_light_decomposition::Tree::dfs_size
void dfs_size(int u, int p=-1)
Utility function to compute sub-tree sizes.
Definition: heavy_light_decomposition.cpp:101
main
int main()
Definition: interpolation_search.cpp:37
add
std::string add(std::string a, std::string b)
Definition: string_fibonacci.cpp:24
std::time
T time(T... args)
@@ -402,9 +446,11 @@ Functions
std::setw
T setw(T... args)
main
int main()
Definition: quick_sort.cpp:82
std::max
T max(T... args)
+
range_queries::heavy_light_decomposition::Tree::change_root
void change_root(int new_root)
Set the root for the tree.
Definition: heavy_light_decomposition.cpp:167
FenwickTree::FenwickTree
FenwickTree(int x)
Definition: fenwick_tree.cpp:39
Point::Point
Point(double a=0.f, double b=0.f)
Definition: smallest_circle.cpp:23
main
int main()
Definition: primality_test.cpp:31
+
range_queries::heavy_light_decomposition::HLD::h_label
std::vector< int > h_label
stores the label of a node
Definition: heavy_light_decomposition.cpp:339
list::next
struct list * next
pointer to next link in the chain
Definition: hash_search.cpp:31
tower::top
int top
top tower ID
Definition: tower_of_hanoi.cpp:15
Point
Definition: line_segment_intersection.cpp:12
@@ -431,6 +477,7 @@ Functions
tests
void tests()
Definition: comb_sort.cpp:73
list
Definition: list_array.cpp:8
std::memset
T memset(T... args)
+
range_queries::heavy_light_decomposition::Tree::t_depth
std::vector< int > t_depth
a vector to store the depth of a node,
Definition: heavy_light_decomposition.cpp:88
binomial_variance
double binomial_variance(double n, double p)
Definition: binomial_dist.cpp:29
machine_learning::sum
T sum(const std::vector< std::valarray< T >> &A)
Definition: vector_ops.hpp:228
std::next
T next(T... args)
diff --git a/d3/de4/classrange__queries_1_1heavy__light__decomposition_1_1_s_g-members.html b/d3/de4/classrange__queries_1_1heavy__light__decomposition_1_1_s_g-members.html new file mode 100644 index 000000000..8e5d886a7 --- /dev/null +++ b/d3/de4/classrange__queries_1_1heavy__light__decomposition_1_1_s_g-members.html @@ -0,0 +1,120 @@ + + + + + + + +Algorithms_in_C++: Member List + + + + + + + + + + + + + + + +
+
+ + + + + + +
+
Algorithms_in_C++ +  1.0.0 +
+
Set of algorithms implemented in C++.
+
+
+ + + + + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+ +
+ +
+
+
range_queries::heavy_light_decomposition::SG< X > Member List
+
+
+ +

This is the complete list of members for range_queries::heavy_light_decomposition::SG< X >, including all inherited members.

+ + + + + + + + + + +
combine(X lhs, X rhs)range_queries::heavy_light_decomposition::SG< X >inlineprivate
HLD (defined in range_queries::heavy_light_decomposition::SG< X >)range_queries::heavy_light_decomposition::SG< X >friend
query(int l, int r)range_queries::heavy_light_decomposition::SG< X >inlineprivate
s_sizerange_queries::heavy_light_decomposition::SG< X >private
s_treerange_queries::heavy_light_decomposition::SG< X >private
set_sret_init(X new_sret_init)range_queries::heavy_light_decomposition::SG< X >inlineprivate
SG(int size)range_queries::heavy_light_decomposition::SG< X >inlineexplicitprivate
sret_initrange_queries::heavy_light_decomposition::SG< X >private
update(int p, X v)range_queries::heavy_light_decomposition::SG< X >inlineprivate
+
+ + + + diff --git a/d5/d88/md__d_i_r_e_c_t_o_r_y.html b/d5/d88/md__d_i_r_e_c_t_o_r_y.html index afc120f64..984d51451 100644 --- a/d5/d88/md__d_i_r_e_c_t_o_r_y.html +++ b/d5/d88/md__d_i_r_e_c_t_o_r_y.html @@ -332,6 +332,7 @@ Probability Range Queries diff --git a/d8/dc0/heavy__light__decomposition_8cpp__incl.map b/d8/dc0/heavy__light__decomposition_8cpp__incl.map new file mode 100644 index 000000000..9526b53b8 --- /dev/null +++ b/d8/dc0/heavy__light__decomposition_8cpp__incl.map @@ -0,0 +1,12 @@ + + + + + + + + + + + + diff --git a/d8/dc0/heavy__light__decomposition_8cpp__incl.md5 b/d8/dc0/heavy__light__decomposition_8cpp__incl.md5 new file mode 100644 index 000000000..5687ed925 --- /dev/null +++ b/d8/dc0/heavy__light__decomposition_8cpp__incl.md5 @@ -0,0 +1 @@ +108ca232924a02ff6933e026d475b272 \ No newline at end of file diff --git a/d8/dc0/heavy__light__decomposition_8cpp__incl.svg b/d8/dc0/heavy__light__decomposition_8cpp__incl.svg new file mode 100644 index 000000000..34857d2b2 --- /dev/null +++ b/d8/dc0/heavy__light__decomposition_8cpp__incl.svg @@ -0,0 +1,246 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +range_queries/heavy_light_decomposition.cpp + + + +Node1 + + +range_queries/heavy +_light_decomposition.cpp + + + + + +Node2 + + +algorithm + + + + + +Node1->Node2 + + + + + +Node3 + + +cassert + + + + + +Node1->Node3 + + + + + +Node4 + + +cmath + + + + + +Node1->Node4 + + + + + +Node5 + + +cstring + + + + + +Node1->Node5 + + + + + +Node6 + + +iostream + + + + + +Node1->Node6 + + + + + +Node7 + + +list + + + + + +Node1->Node7 + + + + + +Node8 + + +numeric + + + + + +Node1->Node8 + + + + + +Node9 + + +string + + + + + +Node1->Node9 + + + + + +Node10 + + +vector + + + + + +Node1->Node10 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/d8/dc0/heavy__light__decomposition_8cpp__incl_org.svg b/d8/dc0/heavy__light__decomposition_8cpp__incl_org.svg new file mode 100644 index 000000000..80bbf75a8 --- /dev/null +++ b/d8/dc0/heavy__light__decomposition_8cpp__incl_org.svg @@ -0,0 +1,158 @@ + + + + + + +range_queries/heavy_light_decomposition.cpp + + + +Node1 + + +range_queries/heavy +_light_decomposition.cpp + + + + + +Node2 + + +algorithm + + + + + +Node1->Node2 + + + + + +Node3 + + +cassert + + + + + +Node1->Node3 + + + + + +Node4 + + +cmath + + + + + +Node1->Node4 + + + + + +Node5 + + +cstring + + + + + +Node1->Node5 + + + + + +Node6 + + +iostream + + + + + +Node1->Node6 + + + + + +Node7 + + +list + + + + + +Node1->Node7 + + + + + +Node8 + + +numeric + + + + + +Node1->Node8 + + + + + +Node9 + + +string + + + + + +Node1->Node9 + + + + + +Node10 + + +vector + + + + + +Node1->Node10 + + + + + diff --git a/d9/d35/classrange__queries_1_1heavy__light__decomposition_1_1_s_g.html b/d9/d35/classrange__queries_1_1heavy__light__decomposition_1_1_s_g.html new file mode 100644 index 000000000..f860341f3 --- /dev/null +++ b/d9/d35/classrange__queries_1_1heavy__light__decomposition_1_1_s_g.html @@ -0,0 +1,470 @@ + + + + + + + +Algorithms_in_C++: range_queries::heavy_light_decomposition::SG< X > Class Template Reference + + + + + + + + + + + + + + + +
+
+ + + + + + +
+
Algorithms_in_C++ +  1.0.0 +
+
Set of algorithms implemented in C++.
+
+
+ + + + + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+ +
+ +
+
+Private Member Functions | +Private Attributes | +Friends | +List of all members
+
+
range_queries::heavy_light_decomposition::SG< X > Class Template Reference
+
+
+ +

Segment Tree, to store heavy chains. + More...

+
+Inheritance diagram for range_queries::heavy_light_decomposition::SG< X >:
+
+
+
+
[legend]
+
+Collaboration diagram for range_queries::heavy_light_decomposition::SG< X >:
+
+
+
+
[legend]
+ + + + + + + + + + + + + + + + + +

+Private Member Functions

X combine (X lhs, X rhs)
 Function that specifies the type of operation involved when segments are combined. More...
 
 SG (int size)
 Class parameterized constructor. Resizes the and initilizes the data members. More...
 
void update (int p, X v)
 Update the value at a node. More...
 
X query (int l, int r)
 Make a range query from node label l to node label r. More...
 
void set_sret_init (X new_sret_init)
 Set the initialization for the query data type, based on requirement. More...
 
+ + + + + + + + + + +

+Private Attributes

std::vector< X > s_tree
 Everything here is private, and can only be accessed through the methods, in the derived class (HLD) More...
 
+int s_size
 number of leaves in the segment tree
 
+X sret_init = 0
 inital query return value
 
+ + + + +

+Friends

+template<typename T >
class HLD
 
+

Detailed Description

+

template<typename X>
+class range_queries::heavy_light_decomposition::SG< X >

+ +

Segment Tree, to store heavy chains.

+
Template Parameters
+ + +
thedata type of the values stored in the tree nodes
+
+
+

Constructor & Destructor Documentation

+ +

◆ SG()

+ +
+
+
+template<typename X >
+ + + + + +
+ + + + + + + + +
range_queries::heavy_light_decomposition::SG< X >::SG (int size)
+ 		+inlineexplicitprivate
+
+ +

Class parameterized constructor. Resizes the and initilizes the data members.

+
Parameters
+ + +
nodesthe total number of nodes in the tree
+
+
+
Returns
void
+
282  {
+
283  s_size = size;
+
284  s_tree.assign(2 * s_size, 0ll);
+
285  }
+
+
+
+

Member Function Documentation

+ +

◆ combine()

+ +
+
+
+template<typename X >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
X range_queries::heavy_light_decomposition::SG< X >::combine (X lhs,
X rhs 
)
+ 		+inlineprivate
+
+ +

Function that specifies the type of operation involved when segments are combined.

+
Parameters
+ + + +
lhsthe left segment
rhsthe right segment
+
+
+
Returns
the combined result
+
274 { return lhs + rhs; }
+
+
+
+ +

◆ query()

+ +
+
+
+template<typename X >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
X range_queries::heavy_light_decomposition::SG< X >::query (int l,
int r 
)
+ 		+inlineprivate
+
+ +

Make a range query from node label l to node label r.

+
Parameters
+ + + +
lnode label where the path starts
rnode label where the path ends
+
+
+
Returns
void
+
305  {
+
306  X lhs = sret_init, rhs = sret_init;
+
307  for (l += s_size, r += s_size + 1; l < r; l >>= 1, r >>= 1) {
+
308  if (l & 1) {
+
309  lhs = combine(lhs, s_tree[l++]);
+
310  }
+
311  if (r & 1) {
+
312  rhs = combine(s_tree[--r], rhs);
+
313  }
+
314  }
+
315  return combine(lhs, rhs);
+
316  }
+
+Here is the call graph for this function:
+
+
+
+
+ +
+
+ +

◆ set_sret_init()

+ +
+
+
+template<typename X >
+ + + + + +
+ + + + + + + + +
void range_queries::heavy_light_decomposition::SG< X >::set_sret_init (X new_sret_init)
+ 		+inlineprivate
+
+ +

Set the initialization for the query data type, based on requirement.

+

Change the sret_init, based on requirement:

    +
  • Sum Query: 0 (Default)
    • +
  • XOR Query: 0 (Default)
    • +
  • Min Query: Infinity
    • +
  • Max Query: -Infinity
    Parameters
    + + +
    new_sret_initthe new init
    +
    +
    +
    • +
+
329 { sret_init = new_sret_init; }
+
+
+
+ +

◆ update()

+ +
+
+
+template<typename X >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void range_queries::heavy_light_decomposition::SG< X >::update (int p,
X v 
)
+ 		+inlineprivate
+
+ +

Update the value at a node.

+
Parameters
+ + + +
pthe node to be udpated
vthe update value
+
+
+
Returns
void
+
293  {
+
294  for (p += s_size; p > 0; p >>= 1) {
+
295  s_tree[p] += v;
+
296  }
+
297  }
+
+
+
+

Member Data Documentation

+ +

◆ s_tree

+ +
+
+
+template<typename X >
+ + + + + +
+ + + + +
std::vector<X> range_queries::heavy_light_decomposition::SG< X >::s_tree
+ 		+private
+
+ +

Everything here is private, and can only be accessed through the methods, in the derived class (HLD)

+

the segment tree, stored as a vector

+ +
+
+
The documentation for this class was generated from the following file: +
+
+
range_queries::heavy_light_decomposition::SG::sret_init
X sret_init
inital query return value
Definition: heavy_light_decomposition.cpp:264
+
range_queries::heavy_light_decomposition::SG::combine
X combine(X lhs, X rhs)
Function that specifies the type of operation involved when segments are combined.
Definition: heavy_light_decomposition.cpp:274
+
range_queries::heavy_light_decomposition::SG::s_tree
std::vector< X > s_tree
Everything here is private, and can only be accessed through the methods, in the derived class (HLD)
Definition: heavy_light_decomposition.cpp:262
+
range_queries::heavy_light_decomposition::SG::s_size
int s_size
number of leaves in the segment tree
Definition: heavy_light_decomposition.cpp:263
+
std::vector::assign
T assign(T... args)
+ + + + diff --git a/d9/d35/classrange__queries_1_1heavy__light__decomposition_1_1_s_g.js b/d9/d35/classrange__queries_1_1heavy__light__decomposition_1_1_s_g.js new file mode 100644 index 000000000..0d26a42dd --- /dev/null +++ b/d9/d35/classrange__queries_1_1heavy__light__decomposition_1_1_s_g.js @@ -0,0 +1,12 @@ +var classrange__queries_1_1heavy__light__decomposition_1_1_s_g = +[ + [ "SG", "d9/d35/classrange__queries_1_1heavy__light__decomposition_1_1_s_g.html#afba5c1225ba04c0025c7786c09ff28f1", null ], + [ "combine", "d9/d35/classrange__queries_1_1heavy__light__decomposition_1_1_s_g.html#a41c733f5f5e262b308f7cb95c88c1e74", null ], + [ "query", "d9/d35/classrange__queries_1_1heavy__light__decomposition_1_1_s_g.html#a1fda852e6e522707fd97f61cdb0a2591", null ], + [ "set_sret_init", "d9/d35/classrange__queries_1_1heavy__light__decomposition_1_1_s_g.html#ad3b942be27a1b0fe3cff6cb6edf01294", null ], + [ "update", "d9/d35/classrange__queries_1_1heavy__light__decomposition_1_1_s_g.html#a3c75bf5770790f8eba8cc92227b5400c", null ], + [ "HLD", "d9/d35/classrange__queries_1_1heavy__light__decomposition_1_1_s_g.html#afcdadbdea1e2391cebbb17d2c1ae2f0b", null ], + [ "s_size", "d9/d35/classrange__queries_1_1heavy__light__decomposition_1_1_s_g.html#ac6d912bbfafa3a7509f66bbc1729ca25", null ], + [ "s_tree", "d9/d35/classrange__queries_1_1heavy__light__decomposition_1_1_s_g.html#afbf8a9cb9449d5ca844f4e141a801e6a", null ], + [ "sret_init", "d9/d35/classrange__queries_1_1heavy__light__decomposition_1_1_s_g.html#aa7f93971a9f891e0bbb7023081f379d5", null ] +]; \ No newline at end of file diff --git a/d9/d35/classrange__queries_1_1heavy__light__decomposition_1_1_s_g_a1fda852e6e522707fd97f61cdb0a2591_cgraph.map b/d9/d35/classrange__queries_1_1heavy__light__decomposition_1_1_s_g_a1fda852e6e522707fd97f61cdb0a2591_cgraph.map new file mode 100644 index 000000000..157cbc5b3 --- /dev/null +++ b/d9/d35/classrange__queries_1_1heavy__light__decomposition_1_1_s_g_a1fda852e6e522707fd97f61cdb0a2591_cgraph.map @@ -0,0 +1,4 @@ + + + + diff --git a/d9/d35/classrange__queries_1_1heavy__light__decomposition_1_1_s_g_a1fda852e6e522707fd97f61cdb0a2591_cgraph.md5 b/d9/d35/classrange__queries_1_1heavy__light__decomposition_1_1_s_g_a1fda852e6e522707fd97f61cdb0a2591_cgraph.md5 new file mode 100644 index 000000000..b6a073ac5 --- /dev/null +++ b/d9/d35/classrange__queries_1_1heavy__light__decomposition_1_1_s_g_a1fda852e6e522707fd97f61cdb0a2591_cgraph.md5 @@ -0,0 +1 @@ +ee05b77207fa35354b2792288481cae8 \ No newline at end of file diff --git a/d9/d35/classrange__queries_1_1heavy__light__decomposition_1_1_s_g_a1fda852e6e522707fd97f61cdb0a2591_cgraph.svg b/d9/d35/classrange__queries_1_1heavy__light__decomposition_1_1_s_g_a1fda852e6e522707fd97f61cdb0a2591_cgraph.svg new file mode 100644 index 000000000..719846059 --- /dev/null +++ b/d9/d35/classrange__queries_1_1heavy__light__decomposition_1_1_s_g_a1fda852e6e522707fd97f61cdb0a2591_cgraph.svg @@ -0,0 +1,41 @@ + + + + + + +range_queries::heavy_light_decomposition::SG::query + + + +Node1 + + +range_queries::heavy +_light_decomposition +::SG::query + + + + + +Node2 + + +range_queries::heavy +_light_decomposition +::SG::combine + + + + + +Node1->Node2 + + + + + diff --git a/d9/d4e/classrange__queries_1_1heavy__light__decomposition_1_1_tree-members.html b/d9/d4e/classrange__queries_1_1heavy__light__decomposition_1_1_tree-members.html new file mode 100644 index 000000000..adc85701f --- /dev/null +++ b/d9/d4e/classrange__queries_1_1heavy__light__decomposition_1_1_tree-members.html @@ -0,0 +1,130 @@ + + + + + + + +Algorithms_in_C++: Member List + + + + + + + + + + + + + + + +
+
+ + + + + + +
+
Algorithms_in_C++ +  1.0.0 +
+
Set of algorithms implemented in C++.
+
+
+ + + + + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+ +
+ +
+
+
range_queries::heavy_light_decomposition::Tree< X > Member List
+
+
+ +

This is the complete list of members for range_queries::heavy_light_decomposition::Tree< X >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + +
add_edge(const int u, const int v)range_queries::heavy_light_decomposition::Tree< X >inline
change_root(int new_root)range_queries::heavy_light_decomposition::Tree< X >inline
dfs_lca(int u, int p=-1)range_queries::heavy_light_decomposition::Tree< X >inlineprivate
dfs_size(int u, int p=-1)range_queries::heavy_light_decomposition::Tree< X >inlineprivate
HLD (defined in range_queries::heavy_light_decomposition::Tree< X >)range_queries::heavy_light_decomposition::Tree< X >friend
init()range_queries::heavy_light_decomposition::Tree< X >inline
kth_ancestor(int p, const int &dist)range_queries::heavy_light_decomposition::Tree< X >inline
lca(int a, int b)range_queries::heavy_light_decomposition::Tree< X >inline
lift(int *const p, int dist)range_queries::heavy_light_decomposition::Tree< X >inline
set_node_val(const std::vector< X > &node_val)range_queries::heavy_light_decomposition::Tree< X >inline
t_adjrange_queries::heavy_light_decomposition::Tree< X >private
t_depthrange_queries::heavy_light_decomposition::Tree< X >private
t_maxliftrange_queries::heavy_light_decomposition::Tree< X >private
t_nodesrange_queries::heavy_light_decomposition::Tree< X >private
t_parrange_queries::heavy_light_decomposition::Tree< X >private
t_rootrange_queries::heavy_light_decomposition::Tree< X >private
t_sizerange_queries::heavy_light_decomposition::Tree< X >private
t_valrange_queries::heavy_light_decomposition::Tree< X >private
Tree(int nodes)range_queries::heavy_light_decomposition::Tree< X >inlineexplicit
+
+ + + + diff --git a/d9/d69/median__search_8cpp.html b/d9/d69/median__search_8cpp.html index 6fdf751c0..379b0d247 100644 --- a/d9/d69/median__search_8cpp.html +++ b/d9/d69/median__search_8cpp.html @@ -160,7 +160,7 @@ template<class X >
-
Todo:
add documentation
+
Todo:
add documentation
18  {
19  if (s1->size() >= x && s1->size() + s2->size() < x) {
20  std::cout << (*s2)[0] << " is the " << x + 1 << "th element from front";
diff --git a/da/dcc/classrange__queries_1_1heavy__light__decomposition_1_1_tree__inherit__graph.map b/da/dcc/classrange__queries_1_1heavy__light__decomposition_1_1_tree__inherit__graph.map new file mode 100644 index 000000000..aa9f0b14d --- /dev/null +++ b/da/dcc/classrange__queries_1_1heavy__light__decomposition_1_1_tree__inherit__graph.map @@ -0,0 +1,4 @@ + + + + diff --git a/da/dcc/classrange__queries_1_1heavy__light__decomposition_1_1_tree__inherit__graph.md5 b/da/dcc/classrange__queries_1_1heavy__light__decomposition_1_1_tree__inherit__graph.md5 new file mode 100644 index 000000000..33250ddc7 --- /dev/null +++ b/da/dcc/classrange__queries_1_1heavy__light__decomposition_1_1_tree__inherit__graph.md5 @@ -0,0 +1 @@ +a22753e77eff156759c1d6d9b426dac7 \ No newline at end of file diff --git a/da/dcc/classrange__queries_1_1heavy__light__decomposition_1_1_tree__inherit__graph.svg b/da/dcc/classrange__queries_1_1heavy__light__decomposition_1_1_tree__inherit__graph.svg new file mode 100644 index 000000000..e967d68a5 --- /dev/null +++ b/da/dcc/classrange__queries_1_1heavy__light__decomposition_1_1_tree__inherit__graph.svg @@ -0,0 +1,41 @@ + + + + + + +range_queries::heavy_light_decomposition::Tree< X > + + + +Node1 + + +range_queries::heavy +_light_decomposition +::Tree< X > + + + + + +Node2 + + +range_queries::heavy +_light_decomposition +::HLD< X > + + + + + +Node1->Node2 + + + + + diff --git a/db/d6f/namespaceheavy__light__decomposition.html b/db/d6f/namespaceheavy__light__decomposition.html new file mode 100644 index 000000000..bf3bf962e --- /dev/null +++ b/db/d6f/namespaceheavy__light__decomposition.html @@ -0,0 +1,114 @@ + + + + + + + +Algorithms_in_C++: heavy_light_decomposition Namespace Reference + + + + + + + + + + + + + + + +
+
+ + + + + + +
+
Algorithms_in_C++ +  1.0.0 +
+
Set of algorithms implemented in C++.
+
+
+ + + + + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+ +
+ +
+
+
heavy_light_decomposition Namespace Reference
+
+
+ +

Heavy light decomposition algorithm. +More...

+

Detailed Description

+

Heavy light decomposition algorithm.

+
+
+ + + + diff --git a/dc/dd9/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d__coll__graph.map b/dc/dd9/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d__coll__graph.map new file mode 100644 index 000000000..60fc5d19f --- /dev/null +++ b/dc/dd9/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d__coll__graph.map @@ -0,0 +1,10 @@ + + + + + + + + + + diff --git a/dc/dd9/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d__coll__graph.md5 b/dc/dd9/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d__coll__graph.md5 new file mode 100644 index 000000000..028371424 --- /dev/null +++ b/dc/dd9/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d__coll__graph.md5 @@ -0,0 +1 @@ +e6f815d7d7a7f773e6b2f78e9a402cdf \ No newline at end of file diff --git a/dc/dd9/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d__coll__graph.svg b/dc/dd9/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d__coll__graph.svg new file mode 100644 index 000000000..589c68c68 --- /dev/null +++ b/dc/dd9/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d__coll__graph.svg @@ -0,0 +1,252 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +range_queries::heavy_light_decomposition::HLD< X > + + + +Node1 + + +range_queries::heavy +_light_decomposition +::HLD< X > + + + + + +Node2 + + +range_queries::heavy +_light_decomposition +::Tree< X > + + + + + +Node2->Node1 + + + + + +Node3 + + +std::vector< std::vector +< int > > + + + + + +Node3->Node2 + + + t_par + + + +Node4 + + +std::vector< int > + + + + + +Node4->Node1 + + + h_parent +h_heavychlid +h_label + + + +Node4->Node2 + + + t_depth +t_size + + + +Node4->Node3 + + + elements + + + +Node5 + + +std::vector< std::list +< int > > + + + + + +Node5->Node2 + + + t_adj + + + +Node6 + + +std::list< int > + + + + + +Node6->Node5 + + + elements + + + +Node7 + + +std::vector< X > + + + + + +Node7->Node2 + + + t_val + + + +Node8 + + +range_queries::heavy +_light_decomposition +::SG< X > + + + + + +Node7->Node8 + + + s_tree + + + +Node8->Node1 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/dc/dd9/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d__coll__graph_org.svg b/dc/dd9/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d__coll__graph_org.svg new file mode 100644 index 000000000..c518f6c11 --- /dev/null +++ b/dc/dd9/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d__coll__graph_org.svg @@ -0,0 +1,164 @@ + + + + + + +range_queries::heavy_light_decomposition::HLD< X > + + + +Node1 + + +range_queries::heavy +_light_decomposition +::HLD< X > + + + + + +Node2 + + +range_queries::heavy +_light_decomposition +::Tree< X > + + + + + +Node2->Node1 + + + + + +Node3 + + +std::vector< std::vector +< int > > + + + + + +Node3->Node2 + + + t_par + + + +Node4 + + +std::vector< int > + + + + + +Node4->Node1 + + + h_parent +h_heavychlid +h_label + + + +Node4->Node2 + + + t_depth +t_size + + + +Node4->Node3 + + + elements + + + +Node5 + + +std::vector< std::list +< int > > + + + + + +Node5->Node2 + + + t_adj + + + +Node6 + + +std::list< int > + + + + + +Node6->Node5 + + + elements + + + +Node7 + + +std::vector< X > + + + + + +Node7->Node2 + + + t_val + + + +Node8 + + +range_queries::heavy +_light_decomposition +::SG< X > + + + + + +Node7->Node8 + + + s_tree + + + +Node8->Node1 + + + + + diff --git a/dc/dfe/ternary__search_8cpp.html b/dc/dfe/ternary__search_8cpp.html index 6f59153f4..891f2fd14 100644 --- a/dc/dfe/ternary__search_8cpp.html +++ b/dc/dfe/ternary__search_8cpp.html @@ -185,7 +185,7 @@ Functions
-

get_input function is to receive input from standard IO

Todo:
@christianbender Get input from STDIO or write input to memory as done above.
+

get_input function is to receive input from standard IO

Todo:
@christianbender Get input from STDIO or write input to memory as done above.
36 {}
diff --git a/dd/d69/namespacerange__queries.html b/dd/d69/namespacerange__queries.html new file mode 100644 index 000000000..17c12b12c --- /dev/null +++ b/dd/d69/namespacerange__queries.html @@ -0,0 +1,114 @@ + + + + + + + +Algorithms_in_C++: range_queries Namespace Reference + + + + + + + + + + + + + + + +
+
+ + + + + + +
+
Algorithms_in_C++ +  1.0.0 +
+
Set of algorithms implemented in C++.
+
+
+ + + + + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+ +
+ +
+
+
range_queries Namespace Reference
+
+
+ +

Algorithms and Data Structures that support range queries and updates. +More...

+

Detailed Description

+

Algorithms and Data Structures that support range queries and updates.

+
+
+ + + + diff --git a/dd/d69/namespacerange__queries.js b/dd/d69/namespacerange__queries.js new file mode 100644 index 000000000..780516d23 --- /dev/null +++ b/dd/d69/namespacerange__queries.js @@ -0,0 +1,8 @@ +var namespacerange__queries = +[ + [ "heavy_light_decomposition", null, [ + [ "HLD", "d2/d8a/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d.html", "d2/d8a/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d" ], + [ "SG", "d9/d35/classrange__queries_1_1heavy__light__decomposition_1_1_s_g.html", "d9/d35/classrange__queries_1_1heavy__light__decomposition_1_1_s_g" ], + [ "Tree", "d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree.html", "d1/d51/classrange__queries_1_1heavy__light__decomposition_1_1_tree" ] + ] ] +]; \ No newline at end of file diff --git a/dd/da0/todo.html b/dd/da0/todo.html index 50c07a913..ded3fb8c0 100644 --- a/dd/da0/todo.html +++ b/dd/da0/todo.html @@ -113,14 +113,16 @@ $(document).ready(function(){initNavTree('dd/da0/todo.html','../../'); initResiz
implement as a C++ class
Member test3 ()
This test fails
+
File heavy_light_decomposition.cpp
+
Support edge weight queries, by storing the edge weight value in it's child algorithm verified by testing in CSES path queries: https://cses.fi/problemset/task/1138
File hash_search.cpp
-
fix the program for memory leaks and better structure in C++ and not C fashion
+
fix the program for memory leaks and better structure in C++ and not C fashion
Member create_list (int key)
-
fix memory leak
+
fix memory leak
Member comp (X x, std::vector< int > *s1, std::vector< int > *s2, std::vector< int > *s3)
-
add documentation
+
add documentation
Member get_input ()
-
@christianbender Get input from STDIO or write input to memory as done above.
+
@christianbender Get input from STDIO or write input to memory as done above.
diff --git a/dd/dfc/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d-members.html b/dd/dfc/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d-members.html new file mode 100644 index 000000000..15befd6ff --- /dev/null +++ b/dd/dfc/classrange__queries_1_1heavy__light__decomposition_1_1_h_l_d-members.html @@ -0,0 +1,146 @@ + + + + + + + +Algorithms_in_C++: Member List + + + + + + + + + + + + + + + +
+
+ + + + + + +
+
Algorithms_in_C++ +  1.0.0 +
+
Set of algorithms implemented in C++.
+
+
+ + + + + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+ +
+ +
+
+
range_queries::heavy_light_decomposition::HLD< X > Member List
+
+
+ +

This is the complete list of members for range_queries::heavy_light_decomposition::HLD< X >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
add_edge(const int u, const int v)range_queries::heavy_light_decomposition::Tree< X >inline
chain_query(int a, int b)range_queries::heavy_light_decomposition::HLD< X >inlineprivate
change_root(int new_root)range_queries::heavy_light_decomposition::Tree< X >inline
combine(X lhs, X rhs)range_queries::heavy_light_decomposition::SG< X >inlineprivate
dfs_hc(int u, int p=-1)range_queries::heavy_light_decomposition::HLD< X >inlineprivate
dfs_labels(int u, int p=-1)range_queries::heavy_light_decomposition::HLD< X >inlineprivate
dfs_lca(int u, int p=-1)range_queries::heavy_light_decomposition::Tree< X >inlineprivate
dfs_par(int u, int p=-1)range_queries::heavy_light_decomposition::HLD< X >inlineprivate
dfs_size(int u, int p=-1)range_queries::heavy_light_decomposition::Tree< X >inlineprivate
h_heavychlidrange_queries::heavy_light_decomposition::HLD< X >private
h_labelrange_queries::heavy_light_decomposition::HLD< X >private
h_parentrange_queries::heavy_light_decomposition::HLD< X >private
HLD(int nodes)range_queries::heavy_light_decomposition::HLD< X >inlineexplicit
init()range_queries::heavy_light_decomposition::HLD< X >inline
kth_ancestor(int p, const int &dist)range_queries::heavy_light_decomposition::Tree< X >inline
labelrange_queries::heavy_light_decomposition::HLD< X >private
lca(int a, int b)range_queries::heavy_light_decomposition::Tree< X >inline
lift(int *const p, int dist)range_queries::heavy_light_decomposition::Tree< X >inline
query(int a, int b)range_queries::heavy_light_decomposition::HLD< X >inline
s_sizerange_queries::heavy_light_decomposition::SG< X >private
s_treerange_queries::heavy_light_decomposition::SG< X >private
set_node_val(const std::vector< X > &node_val)range_queries::heavy_light_decomposition::Tree< X >inline
set_sret_init(X new_sret_init)range_queries::heavy_light_decomposition::SG< X >inlineprivate
SG(int size)range_queries::heavy_light_decomposition::SG< X >inlineexplicitprivate
sret_initrange_queries::heavy_light_decomposition::SG< X >private
t_adjrange_queries::heavy_light_decomposition::Tree< X >private
t_depthrange_queries::heavy_light_decomposition::Tree< X >private
t_maxliftrange_queries::heavy_light_decomposition::Tree< X >private
t_nodesrange_queries::heavy_light_decomposition::Tree< X >private
t_parrange_queries::heavy_light_decomposition::Tree< X >private
t_rootrange_queries::heavy_light_decomposition::Tree< X >private
t_sizerange_queries::heavy_light_decomposition::Tree< X >private
t_valrange_queries::heavy_light_decomposition::Tree< X >private
Tree(int nodes)range_queries::heavy_light_decomposition::Tree< X >inlineexplicit
update(int node, X val)range_queries::heavy_light_decomposition::HLD< X >inline
+
+ + + + diff --git a/de/d4c/classrange__queries_1_1heavy__light__decomposition_1_1_tree__coll__graph.map b/de/d4c/classrange__queries_1_1heavy__light__decomposition_1_1_tree__coll__graph.map new file mode 100644 index 000000000..75dc286e2 --- /dev/null +++ b/de/d4c/classrange__queries_1_1heavy__light__decomposition_1_1_tree__coll__graph.map @@ -0,0 +1,8 @@ + + + + + + + + diff --git a/de/d4c/classrange__queries_1_1heavy__light__decomposition_1_1_tree__coll__graph.md5 b/de/d4c/classrange__queries_1_1heavy__light__decomposition_1_1_tree__coll__graph.md5 new file mode 100644 index 000000000..94c65fa02 --- /dev/null +++ b/de/d4c/classrange__queries_1_1heavy__light__decomposition_1_1_tree__coll__graph.md5 @@ -0,0 +1 @@ +2a4f39d133e81c5858d19787d0ea5b3a \ No newline at end of file diff --git a/de/d4c/classrange__queries_1_1heavy__light__decomposition_1_1_tree__coll__graph.svg b/de/d4c/classrange__queries_1_1heavy__light__decomposition_1_1_tree__coll__graph.svg new file mode 100644 index 000000000..e185fe3a6 --- /dev/null +++ b/de/d4c/classrange__queries_1_1heavy__light__decomposition_1_1_tree__coll__graph.svg @@ -0,0 +1,114 @@ + + + + + + +range_queries::heavy_light_decomposition::Tree< X > + + + +Node1 + + +range_queries::heavy +_light_decomposition +::Tree< X > + + + + + +Node2 + + +std::vector< std::vector +< int > > + + + + + +Node2->Node1 + + + t_par + + + +Node3 + + +std::vector< int > + + + + + +Node3->Node1 + + + t_depth +t_size + + + +Node3->Node2 + + + elements + + + +Node4 + + +std::vector< std::list +< int > > + + + + + +Node4->Node1 + + + t_adj + + + +Node5 + + +std::list< int > + + + + + +Node5->Node4 + + + elements + + + +Node6 + + +std::vector< X > + + + + + +Node6->Node1 + + + t_val + + + diff --git a/dir_074119ce3a874b57120c49a0cc4bb5ad.html b/dir_074119ce3a874b57120c49a0cc4bb5ad.html index 2d4aeedd2..3697acb75 100644 --- a/dir_074119ce3a874b57120c49a0cc4bb5ad.html +++ b/dir_074119ce3a874b57120c49a0cc4bb5ad.html @@ -100,6 +100,9 @@ Files file  fenwick_tree.cpp  Fenwick tree.
  +file  heavy_light_decomposition.cpp + Heavy Light Decomposition implementation
+  diff --git a/dir_074119ce3a874b57120c49a0cc4bb5ad.js b/dir_074119ce3a874b57120c49a0cc4bb5ad.js index 586f52480..541ad48f2 100644 --- a/dir_074119ce3a874b57120c49a0cc4bb5ad.js +++ b/dir_074119ce3a874b57120c49a0cc4bb5ad.js @@ -1,4 +1,5 @@ var dir_074119ce3a874b57120c49a0cc4bb5ad = [ - [ "fenwick_tree.cpp", "d6/d2e/fenwick__tree_8cpp.html", "d6/d2e/fenwick__tree_8cpp" ] + [ "fenwick_tree.cpp", "d6/d2e/fenwick__tree_8cpp.html", "d6/d2e/fenwick__tree_8cpp" ], + [ "heavy_light_decomposition.cpp", "d2/de9/heavy__light__decomposition_8cpp.html", "d2/de9/heavy__light__decomposition_8cpp" ] ]; \ No newline at end of file diff --git a/files.html b/files.html index 5515b0103..a87a669bf 100644 --- a/files.html +++ b/files.html @@ -222,6 +222,7 @@ $(document).ready(function(){initNavTree('files.html',''); initResizable(); });  poisson_dist.cppPoisson statistics  ► range_queries  fenwick_tree.cppFenwick tree + heavy_light_decomposition.cppHeavy Light Decomposition implementation  ► search  binary_search.cppBinary search algorithm  exponential_search.cppExponential search algorithm diff --git a/functions_a.html b/functions_a.html index 8053ffdb5..8d370480a 100644 --- a/functions_a.html +++ b/functions_a.html @@ -111,8 +111,11 @@ $(document).ready(function(){initNavTree('functions_a.html',''); initResizable()
  • add_digit() : large_number
    • +
  • add_edge() +: range_queries::heavy_light_decomposition::Tree< X > +
  • addEdge() -: Graph +: Graph , graph::is_graph_bipartite::Graph
  • addVertices() diff --git a/functions_c.html b/functions_c.html index 4c3cdfbe7..a502744cc 100644 --- a/functions_c.html +++ b/functions_c.html @@ -96,6 +96,12 @@ $(document).ready(function(){initNavTree('functions_c.html',''); initResizable()
  • capacity : MinHeap
    • +
  • chain_query() +: range_queries::heavy_light_decomposition::HLD< X > +
    • +
  • change_root() +: range_queries::heavy_light_decomposition::Tree< X > +
  • check_size_match() : machine_learning::adaline
    • @@ -106,6 +112,9 @@ $(document).ready(function(){initNavTree('functions_c.html',''); initResizable()
  • codec() : ciphers::HillCipher
    • +
  • combine() +: range_queries::heavy_light_decomposition::SG< X > +
  • Complex() : Complex
    • diff --git a/functions_d.html b/functions_d.html index ac665cc39..debed6765 100644 --- a/functions_d.html +++ b/functions_d.html @@ -114,6 +114,21 @@ $(document).ready(function(){initNavTree('functions_d.html',''); initResizable()
  • deQueue() : queue< Kind >
    • +
  • dfs_hc() +: range_queries::heavy_light_decomposition::HLD< X > +
    • +
  • dfs_labels() +: range_queries::heavy_light_decomposition::HLD< X > +
    • +
  • dfs_lca() +: range_queries::heavy_light_decomposition::Tree< X > +
    • +
  • dfs_par() +: range_queries::heavy_light_decomposition::HLD< X > +
    • +
  • dfs_size() +: range_queries::heavy_light_decomposition::Tree< X > +
  • digit_char() : large_number
    • diff --git a/functions_func.html b/functions_func.html index ca0ca325b..a9326bccd 100644 --- a/functions_func.html +++ b/functions_func.html @@ -115,8 +115,11 @@ $(document).ready(function(){initNavTree('functions_func.html',''); initResizabl
  • add_digit() : large_number
    • +
  • add_edge() +: range_queries::heavy_light_decomposition::Tree< X > +
  • addEdge() -: Graph +: Graph , graph::is_graph_bipartite::Graph
  • addVertices() @@ -136,6 +139,12 @@ $(document).ready(function(){initNavTree('functions_func.html',''); initResizabl

    - c -

    @@ -300,6 +330,10 @@ $(document).ready(function(){initNavTree('functions_func.html',''); initResizabl
  • imag() : Complex
    • +
  • init() +: range_queries::heavy_light_decomposition::HLD< X > +, range_queries::heavy_light_decomposition::Tree< X > +
  • insert() : Trie
    • @@ -330,13 +364,26 @@ $(document).ready(function(){initNavTree('functions_func.html',''); initResizabl +

    - k -

    + +

    - l -