diff --git a/annotated.html b/annotated.html index 8820b426e..6e5f576e9 100644 --- a/annotated.html +++ b/annotated.html @@ -115,60 +115,61 @@ $(document).ready(function(){initNavTree('annotated.html',''); initResizable();  ▼Nis_graph_bipartite  CGraphClass for representing graph as an adjacency list  CGraph - CLowestCommonAncestor - CRootedTree - ▼Nlinear_probingAn implementation of hash table using linear probing algorithm - CEntry - ▼Nmachine_learningMachine learning algorithms - ▼Nneural_network - ▼Nlayers - CDenseLayer - CNeuralNetwork - Cadaline - ▼NothersOther algorithms - ▼Npostfix_expression - CStackCreates an array to be used as stack for storing values - ▼Nquadratic_probingAn implementation of hash table using quadratic probing algorithm - CEntry - ▼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 - CQueue_Array - CSegmentIntersection - CSolution - Cstack - Cstack_linkedList - Ctower - ▼CTrie - CTrieNode + CHKGraphRepresents Bipartite graph for Hopcroft Karp implementation + CLowestCommonAncestor + CRootedTree + ▼Nlinear_probingAn implementation of hash table using linear probing algorithm + CEntry + ▼Nmachine_learningMachine learning algorithms + ▼Nneural_network + ▼Nlayers + CDenseLayer + CNeuralNetwork + Cadaline + ▼NothersOther algorithms + ▼Npostfix_expression + CStackCreates an array to be used as stack for storing values + ▼Nquadratic_probingAn implementation of hash table using quadratic probing algorithm + CEntry + ▼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 + CQueue_Array + CSegmentIntersection + CSolution + Cstack + Cstack_linkedList + Ctower + ▼CTrie + CTrieNode diff --git a/classes.html b/classes.html index a79cb5ad6..cc1f781ca 100644 --- a/classes.html +++ b/classes.html @@ -98,21 +98,21 @@ $(document).ready(function(){initNavTree('classes.html',''); initResizable(); }) - + - + - + - + @@ -120,7 +120,7 @@ $(document).ready(function(){initNavTree('classes.html',''); initResizable(); }) - + @@ -187,24 +187,25 @@ $(document).ready(function(){initNavTree('classes.html',''); initResizable(); }) - + - + + - - + - + +
  a  
Entry (double_hashing)   Entry (quadratic_probing)   
  l  
 Node    SkipList (data_structures)   
Entry (linear_probing)   
Entry (double_hashing)   
  p  
 Solution   
adaline (machine_learning)   Entry (quadratic_probing)   Entry (linear_probing)    large_number   Stack (others::postfix_expression)   stack   
  b  
 link (data_structures::linked_list)    Point (geometry::jarvis)   stack   Stack (others::postfix_expression)   
linkedlist    Point   
DenseLayer (machine_learning::neural_network::layers)   HLD (range_queries::heavy_light_decomposition)   HKGraph (graph)    NeuralNetwork (machine_learning::neural_network)   
double_linked_list   
  i  
-		HLD (range_queries::heavy_light_decomposition)    Node (data_structures)    SegmentIntersection   
  e  
  i  
+		 node    SG (range_queries::heavy_light_decomposition)   
Item   
Edge   
Item   
a | b | c | d | e | f | g | h | i | l | m | n | p | q | r | s | t
diff --git a/d1/d9a/hopcroft__karp_8cpp.html b/d1/d9a/hopcroft__karp_8cpp.html new file mode 100644 index 000000000..8fa7972b9 --- /dev/null +++ b/d1/d9a/hopcroft__karp_8cpp.html @@ -0,0 +1,291 @@ + + + + + + + +Algorithms_in_C++: graph/hopcroft_karp.cpp File Reference + + + + + + + + + + + + + + + +
+
+ + + + + + +
+
Algorithms_in_C++ +  1.0.0 +
+
Set of algorithms implemented in C++.
+
+
+ + + + + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+ +
+ +
+
+Classes | +Namespaces | +Functions
+
+
hopcroft_karp.cpp File Reference
+
+
+ +

Implementation of Hopcroft–Karp algorithm. +More...

+
#include <iostream>
+#include <cstdlib>
+#include <queue>
+#include <list>
+#include <climits>
+#include <memory>
+#include <cassert>
+
+Include dependency graph for hopcroft_karp.cpp:
+
+
+
+
+
+ + + + +

+Classes

class  graph::HKGraph
 Represents Bipartite graph for Hopcroft Karp implementation. More...
 
+ + + + +

+Namespaces

 graph
 Graph algorithms.
 
+ + + + + + +

+Functions

void tests ()
 
int main ()
 Main function. More...
 
+

Detailed Description

+

Implementation of Hopcroft–Karp algorithm.

+

The Hopcroft–Karp algorithm is an algorithm that takes as input a bipartite graph and produces as output a maximum cardinality matching, it runs in O(E√V) time in worst case.

+

+Bipartite graph

+

A bipartite graph (or bigraph) is a graph whose vertices can be divided into two disjoint and independent sets U and V such that every edge connects a vertex in U to one in V. Vertex sets U and V are usually called the parts of the graph. Equivalently, a bipartite graph is a graph that does not contain any odd-length cycles.

+

+Matching and Not-Matching edges

+

Given a matching M, edges that are part of matching are called Matching edges and edges that are not part of M (or connect free nodes) are called Not-Matching edges.

+

+Maximum cardinality matching

+

Given a bipartite graphs G = ( V = ( X , Y ) , E ) whose partition has the parts X and Y, with E denoting the edges of the graph, the goal is to find a matching with as many edges as possible. Equivalently, a matching that covers as many vertices as possible.

+

+Augmenting paths

+

Given a matching M, an augmenting path is an alternating path that starts from and ends on free vertices. All single edge paths that start and end with free vertices are augmenting paths.

+

+Concept

+

A matching M is not maximum if there exists an augmenting path. It is also true other way, i.e, a matching is maximum if no augmenting path exists.

+

+Algorithm

+

1) Initialize the Maximal Matching M as empty. 2) While there exists an Augmenting Path P Remove matching edges of P from M and add not-matching edges of P to M (This increases size of M by 1 as P starts and ends with a free vertex i.e. a node that is not part of matching.) 3) Return M.

+
Author
Krishna Pal Deora
+

Function Documentation

+ +

◆ main()

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

Main function.

+
Returns
0 on exit
+
307 {
+
308  tests(); // perform self-tests
+
309 
+
310  int v1 = 0, v2 = 0, e = 0;
+
311  std::cin >> v1 >> v2 >> e; // vertices of left side, right side and edges
+
312  HKGraph g(v1, v2);
+
313  int u = 0, v = 0;
+
314  for (int i = 0; i < e; ++i)
+
315  {
+
316  std::cin >> u >> v;
+
317  g.addEdge(u, v);
+
318  }
+
319 
+
320  int res = g.hopcroftKarpAlgorithm();
+
321  std::cout << "Maximum matching is " << res <<"\n";
+
322 
+
323  return 0;
+
324 
+
325 }
+
+Here is the call graph for this function:
+
+
+
+
+ +
+
+ +

◆ tests()

+ +
+
+ + + + + + + +
void tests ()
+
+

Self-test implementation

Returns
none
+
255  {
+
256  // Sample test case 1
+
257  int v1a = 3, v1b = 5, e1 = 2; // vertices of left side, right side and edges
+
258  HKGraph g1(v1a, v1b); // execute the algorithm
+
259 
+
260  g1.addEdge(0,1);
+
261  g1.addEdge(1,4);
+
262 
+
263  int expected_res1 = 0; // for the above sample data, this is the expected output
+
264  int res1 = g1.hopcroftKarpAlgorithm();
+
265 
+
266  assert(res1 == expected_res1); // assert check to ensure that the algorithm executed correctly for test 1
+
267 
+
268  // Sample test case 2
+
269  int v2a = 4, v2b = 4, e2 = 6; // vertices of left side, right side and edges
+
270  HKGraph g2(v2a, v2b); // execute the algorithm
+
271 
+
272  g2.addEdge(1,1);
+
273  g2.addEdge(1,3);
+
274  g2.addEdge(2,3);
+
275  g2.addEdge(3,4);
+
276  g2.addEdge(4,3);
+
277  g2.addEdge(4,2);
+
278 
+
279  int expected_res2 = 0; // for the above sample data, this is the expected output
+
280  int res2 = g2.hopcroftKarpAlgorithm();
+
281 
+
282  assert(res2 == expected_res2); // assert check to ensure that the algorithm executed correctly for test 2
+
283 
+
284  // Sample test case 3
+
285  int v3a = 6, v3b = 6, e3 = 4; // vertices of left side, right side and edges
+
286  HKGraph g3(v3a, v3b); // execute the algorithm
+
287 
+
288  g3.addEdge(0,1);
+
289  g3.addEdge(1,4);
+
290  g3.addEdge(1,5);
+
291  g3.addEdge(5,0);
+
292 
+
293  int expected_res3 = 0; // for the above sample data, this is the expected output
+
294  int res3 = g3.hopcroftKarpAlgorithm();
+
295 
+
296  assert(res3 == expected_res3); // assert check to ensure that the algorithm executed correctly for test 3
+
297 
+
298 
+
299 
+
300 }
+
+Here is the call graph for this function:
+
+
+
+
+ +
+
+
+
+
std::cout
+
tests
void tests()
Definition: hopcroft_karp.cpp:255
+
graph::HKGraph
Represents Bipartite graph for Hopcroft Karp implementation.
Definition: hopcroft_karp.cpp:67
+
std::cin
+ + + + diff --git a/d1/d9a/hopcroft__karp_8cpp.js b/d1/d9a/hopcroft__karp_8cpp.js new file mode 100644 index 000000000..c5f05fa1a --- /dev/null +++ b/d1/d9a/hopcroft__karp_8cpp.js @@ -0,0 +1,6 @@ +var hopcroft__karp_8cpp = +[ + [ "HKGraph", "d8/d69/classgraph_1_1_h_k_graph.html", "d8/d69/classgraph_1_1_h_k_graph" ], + [ "main", "d1/d9a/hopcroft__karp_8cpp.html#ae66f6b31b5ad750f1fe042a706a4e3d4", null ], + [ "tests", "d1/d9a/hopcroft__karp_8cpp.html#a88ec9ad42717780d6caaff9d3d6977f9", null ] +]; \ No newline at end of file diff --git a/d1/d9a/hopcroft__karp_8cpp_a88ec9ad42717780d6caaff9d3d6977f9_cgraph.map b/d1/d9a/hopcroft__karp_8cpp_a88ec9ad42717780d6caaff9d3d6977f9_cgraph.map new file mode 100644 index 000000000..14a4c7c21 --- /dev/null +++ b/d1/d9a/hopcroft__karp_8cpp_a88ec9ad42717780d6caaff9d3d6977f9_cgraph.map @@ -0,0 +1,9 @@ + + + + + + + + + diff --git a/d1/d9a/hopcroft__karp_8cpp_a88ec9ad42717780d6caaff9d3d6977f9_cgraph.md5 b/d1/d9a/hopcroft__karp_8cpp_a88ec9ad42717780d6caaff9d3d6977f9_cgraph.md5 new file mode 100644 index 000000000..ce602f3d2 --- /dev/null +++ b/d1/d9a/hopcroft__karp_8cpp_a88ec9ad42717780d6caaff9d3d6977f9_cgraph.md5 @@ -0,0 +1 @@ +419a8bf7cbe88704d5a9b06319e81efb \ No newline at end of file diff --git a/d1/d9a/hopcroft__karp_8cpp_a88ec9ad42717780d6caaff9d3d6977f9_cgraph.svg b/d1/d9a/hopcroft__karp_8cpp_a88ec9ad42717780d6caaff9d3d6977f9_cgraph.svg new file mode 100644 index 000000000..78157c8af --- /dev/null +++ b/d1/d9a/hopcroft__karp_8cpp_a88ec9ad42717780d6caaff9d3d6977f9_cgraph.svg @@ -0,0 +1,119 @@ + + + + + + +tests + + + +Node1 + + +tests + + + + + +Node2 + + +graph::HKGraph::addEdge + + + + + +Node1->Node2 + + + + + +Node4 + + +graph::HKGraph::hopcroft +KarpAlgorithm + + + + + +Node1->Node4 + + + + + +Node3 + + +std::vector::push_back + + + + + +Node2->Node3 + + + + + +Node5 + + +graph::HKGraph::bfs + + + + + +Node4->Node5 + + + + + +Node7 + + +graph::HKGraph::dfs + + + + + +Node4->Node7 + + + + + +Node6 + + +std::vector::end + + + + + +Node5->Node6 + + + + + +Node7->Node6 + + + + + diff --git a/d1/d9a/hopcroft__karp_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.map b/d1/d9a/hopcroft__karp_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.map new file mode 100644 index 000000000..2b9d62114 --- /dev/null +++ b/d1/d9a/hopcroft__karp_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.map @@ -0,0 +1,10 @@ + + + + + + + + + + diff --git a/d1/d9a/hopcroft__karp_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.md5 b/d1/d9a/hopcroft__karp_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.md5 new file mode 100644 index 000000000..2cacb1180 --- /dev/null +++ b/d1/d9a/hopcroft__karp_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.md5 @@ -0,0 +1 @@ +a0d5a38cc5fee67eca81aa0294d0349d \ No newline at end of file diff --git a/d1/d9a/hopcroft__karp_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.svg b/d1/d9a/hopcroft__karp_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.svg new file mode 100644 index 000000000..2ff3c1d02 --- /dev/null +++ b/d1/d9a/hopcroft__karp_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.svg @@ -0,0 +1,234 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +main + + + +Node1 + + +main + + + + + +Node2 + + +graph::HKGraph::addEdge + + + + + +Node1->Node2 + + + + + +Node4 + + +graph::HKGraph::hopcroft +KarpAlgorithm + + + + + +Node1->Node4 + + + + + +Node8 + + +tests + + + + + +Node1->Node8 + + + + + +Node3 + + +std::vector::push_back + + + + + +Node2->Node3 + + + + + +Node5 + + +graph::HKGraph::bfs + + + + + +Node4->Node5 + + + + + +Node7 + + +graph::HKGraph::dfs + + + + + +Node4->Node7 + + + + + +Node6 + + +std::vector::end + + + + + +Node5->Node6 + + + + + +Node7->Node6 + + + + + +Node8->Node2 + + + + + +Node8->Node4 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/d1/d9a/hopcroft__karp_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph_org.svg b/d1/d9a/hopcroft__karp_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph_org.svg new file mode 100644 index 000000000..3b197e55f --- /dev/null +++ b/d1/d9a/hopcroft__karp_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph_org.svg @@ -0,0 +1,146 @@ + + + + + + +main + + + +Node1 + + +main + + + + + +Node2 + + +graph::HKGraph::addEdge + + + + + +Node1->Node2 + + + + + +Node4 + + +graph::HKGraph::hopcroft +KarpAlgorithm + + + + + +Node1->Node4 + + + + + +Node8 + + +tests + + + + + +Node1->Node8 + + + + + +Node3 + + +std::vector::push_back + + + + + +Node2->Node3 + + + + + +Node5 + + +graph::HKGraph::bfs + + + + + +Node4->Node5 + + + + + +Node7 + + +graph::HKGraph::dfs + + + + + +Node4->Node7 + + + + + +Node6 + + +std::vector::end + + + + + +Node5->Node6 + + + + + +Node7->Node6 + + + + + +Node8->Node2 + + + + + +Node8->Node4 + + + + + 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 eead0d68e..04f95be91 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 @@ -192,6 +192,7 @@ Graph
  • Depth First Search With Stack
  • Dijkstra
  • Hamiltons Cycle
    • +
  • Hopcroft Karp
  • Is Graph Bipartite
  • Kosaraju
  • Kruskal
    • diff --git a/d5/ddb/bogo__sort_8cpp.html b/d5/ddb/bogo__sort_8cpp.html index 46fbbebf5..e482e7cb1 100644 --- a/d5/ddb/bogo__sort_8cpp.html +++ b/d5/ddb/bogo__sort_8cpp.html @@ -136,7 +136,7 @@ Functions

    Detailed Description

    Implementation of Bogosort algorithm

    In computer science, bogosort (also known as permutation sort, stupid sort, slowsort, shotgun sort, random sort, monkey sort, bobosort or shuffle sort) is a highly inefficient sorting algorithm based on the generate and test paradigm. Two versions of this algorithm exist: a deterministic version that enumerates all permutations until it hits a sorted one, and a randomized version that randomly permutes its input.Randomized version is implemented here.

    -

    +

    Algorithm

    Shuffle the array untill array is sorted.

    Author
    Deep Raval
    diff --git a/d8/d69/classgraph_1_1_h_k_graph.html b/d8/d69/classgraph_1_1_h_k_graph.html new file mode 100644 index 000000000..1b4e3cad1 --- /dev/null +++ b/d8/d69/classgraph_1_1_h_k_graph.html @@ -0,0 +1,482 @@ + + + + + + + +Algorithms_in_C++: graph::HKGraph Class Reference + + + + + + + + + + + + + + + +
    +
    + + + + + + +
    +
    Algorithms_in_C++ +  1.0.0 +
    +
    Set of algorithms implemented in C++.
    +
    +
    + + + + + + + +
    +
    + +
    +
    +
    + +
    + +
    +
    + + +
    + +
    + +
    +
    +Public Member Functions | +Private Attributes | +List of all members
    +
    +
    graph::HKGraph Class Reference
    +
    +
    + +

    Represents Bipartite graph for Hopcroft Karp implementation. + More...

    +
    +Collaboration diagram for graph::HKGraph:
    +
    +
    +
    +
    [legend]
    + + + + + + + + + + + + + + + + + + + + +

    +Public Member Functions

    + HKGraph ()
     Default Constructor for initialization.
     
     HKGraph (int m, int n)
     Constructor for initialization. More...
     
    void addEdge (int u, int v)
     function to add edge from u to v More...
     
    bool bfs ()
     This function checks for the possibility of augmented path availability. More...
     
    bool dfs (int u)
     This functions checks whether an augmenting path is available exists beginning with free vertex u. More...
     
    int hopcroftKarpAlgorithm ()
     This function counts the number of augmenting paths between left and right sides of the Bipartite graph. More...
     
    + + + + + + + + + + + + + + + + + + + + + + + +

    +Private Attributes

    +int m {}
     m is the number of vertices on left side of Bipartite Graph
     
    +int n {}
     n is the number of vertices on right side of Bipartite Graph
     
    +const int NIL {0}
     
    +const int INF {INT_MAX}
     
    +std::vector< std::list< int > > adj
     adj[u] stores adjacents of left side and 0 is used for dummy vertex
     
    +std::vector< int > pair_u
     value of vertex 'u' ranges from 1 to m
     
    +std::vector< int > pair_v
     value of vertex 'v' ranges from 1 to n
     
    +std::vector< int > dist
     dist represents the distance between vertex 'u' and vertex 'v'
     
    +

    Detailed Description

    +

    Represents Bipartite graph for Hopcroft Karp implementation.

    +

    Constructor & Destructor Documentation

    + +

    ◆ HKGraph()

    + +
    +
    + + + + + + + + + + + + + + + + + + +
    graph::HKGraph::HKGraph (int m,
    int n 
    )
    +
    + +

    Constructor for initialization.

    +
    Parameters
    + + + +
    mis the number of vertices on left side of Bipartite Graph
    nis the number of vertices on right side of Bipartite Graph
    +
    +
    +
    231  {
    +
    232  this->m = m;
    +
    233  this->n = n;
    +
    234  adj = std::vector<std::list<int> >(m + 1);
    +
    235 }
    +
    +
    +
    +

    Member Function Documentation

    + +

    ◆ addEdge()

    + +
    +
    + + + + + + + + + + + + + + + + + + +
    void graph::HKGraph::addEdge (int u,
    int v 
    )
    +
    + +

    function to add edge from u to v

    +
    Parameters
    + + + +
    uis the position of first vertex
    vis the position of second vertex
    +
    +
    +
    243 {
    +
    244  adj[u].push_back(v); // Add v to u’s list.
    +
    245 }
    +
    +Here is the call graph for this function:
    +
    +
    +
    +
    + +
    +
    + +

    ◆ bfs()

    + +
    +
    + + + + + + + +
    bool graph::HKGraph::bfs ()
    +
    + +

    This function checks for the possibility of augmented path availability.

    +
    Returns
    true if there is an augmenting path available
    +
    +false if there is no augmenting path available
    +
    134 {
    +
    135  std::queue<int> q; // an integer queue for bfs
    +
    136 
    +
    137  // First layer of vertices (set distance as 0)
    +
    138  for (int u = 1; u <= m; u++)
    +
    139  {
    +
    140  // If this is a free vertex, add it to queue
    +
    141  if (pair_u[u] == NIL){
    +
    142 
    +
    143  dist[u] = 0; // u is not matched so distance is 0
    +
    144  q.push(u);
    +
    145  }
    +
    146 
    +
    147  else{
    +
    148  dist[u] = INF; // set distance as infinite so that this vertex is considered next time for availibility
    +
    149  }
    +
    150  }
    +
    151 
    +
    152 
    +
    153  dist[NIL] = INF; // Initialize distance to NIL as infinite
    +
    154 
    +
    155  // q is going to contain vertices of left side only.
    +
    156  while (!q.empty())
    +
    157  {
    +
    158  int u = q.front(); // dequeue a vertex
    +
    159  q.pop();
    +
    160 
    +
    161  // If this node is not NIL and can provide a shorter path to NIL then
    +
    162  if (dist[u] < dist[NIL])
    +
    163  {
    +
    164  // Get all the adjacent vertices of the dequeued vertex u
    +
    165  std::list<int>::iterator it;
    +
    166  for (it = adj[u].begin(); it != adj[u].end(); ++it)
    +
    167  {
    +
    168  int v = *it;
    +
    169 
    +
    170  // If pair of v is not considered so far i.e. (v, pair_v[v]) is not yet explored edge.
    +
    171  if (dist[pair_v[v]] == INF)
    +
    172  {
    +
    173  dist[pair_v[v]] = dist[u] + 1;
    +
    174  q.push(pair_v[v]); // Consider the pair and push it to queue
    +
    175  }
    +
    176  }
    +
    177  }
    +
    178  }
    +
    179 
    +
    180 
    +
    181 
    +
    182  return (dist[NIL] != INF); // If we could come back to NIL using alternating path of distinct vertices then there is an augmenting path available
    +
    183 }
    +
    +Here is the call graph for this function:
    +
    +
    +
    +
    + +
    +
    + +

    ◆ dfs()

    + +
    +
    + + + + + + + + +
    bool graph::HKGraph::dfs (int u)
    +
    + +

    This functions checks whether an augmenting path is available exists beginning with free vertex u.

    +
    Parameters
    + + +
    urepresents position of vertex
    +
    +
    +
    Returns
    true if there is an augmenting path beginning with free vertex u
    +
    +false if there is no augmenting path beginning with free vertex u
    +
    192 {
    +
    193  if (u != NIL)
    +
    194  {
    +
    195  std::list<int>::iterator it;
    +
    196  for (it = adj[u].begin(); it != adj[u].end(); ++it)
    +
    197  {
    +
    198 
    +
    199  int v = *it; // Adjacent vertex of u
    +
    200 
    +
    201  // Follow the distances set by BFS search
    +
    202  if (dist[pair_v[v]] == dist[u] + 1)
    +
    203  {
    +
    204  // If dfs for pair of v also return true then new matching possible, store the matching
    +
    205  if (dfs(pair_v[v]) == true)
    +
    206  {
    +
    207  pair_v[v] = u;
    +
    208  pair_u[u] = v;
    +
    209  return true;
    +
    210  }
    +
    211  }
    +
    212  }
    +
    213 
    +
    214 
    +
    215  dist[u] = INF; // If there is no augmenting path beginning with u then set distance to infinite.
    +
    216  return false;
    +
    217  }
    +
    218  return true;
    +
    219 }
    +
    +Here is the call graph for this function:
    +
    +
    +
    +
    + +
    +
    + +

    ◆ hopcroftKarpAlgorithm()

    + +
    +
    + + + + + + + +
    int graph::HKGraph::hopcroftKarpAlgorithm ()
    +
    + +

    This function counts the number of augmenting paths between left and right sides of the Bipartite graph.

    +
    Returns
    size of maximum matching
    +
    96 {
    +
    97 
    +
    98  // pair_u[u] stores pair of u in matching on left side of Bipartite Graph.
    +
    99  // If u doesn't have any pair, then pair_u[u] is NIL
    +
    100  pair_u = std::vector<int>(m + 1,NIL);
    +
    101 
    +
    102  // pair_v[v] stores pair of v in matching on right side of Biparite Graph.
    +
    103  // If v doesn't have any pair, then pair_u[v] is NIL
    +
    104  pair_v = std::vector<int>(n + 1,NIL);
    +
    105 
    +
    106  dist = std::vector<int>(m + 1); // dist[u] stores distance of left side vertices
    +
    107 
    +
    108  int result = 0; // Initialize result
    +
    109 
    +
    110  // Keep updating the result while there is an augmenting path possible.
    +
    111  while (bfs())
    +
    112  {
    +
    113  // Find a free vertex to check for a matching
    +
    114  for (int u = 1; u <= m; u++){
    +
    115 
    +
    116  // If current vertex is free and there is
    +
    117  // an augmenting path from current vertex
    +
    118  // then increment the result
    +
    119  if (pair_u[u] == NIL && dfs(u)){
    +
    120  result++;
    +
    121  }
    +
    122  }
    +
    123  }
    +
    124  return result;
    +
    125 }
    +
    +Here is the call graph for this function:
    +
    +
    +
    +
    + +
    +
    +
    The documentation for this class was generated from the following file: +
    +
    +
    std::list
    STL class.
    +
    graph::HKGraph::m
    int m
    m is the number of vertices on left side of Bipartite Graph
    Definition: hopcroft_karp.cpp:68
    +
    graph::HKGraph::n
    int n
    n is the number of vertices on right side of Bipartite Graph
    Definition: hopcroft_karp.cpp:69
    +
    std::vector
    STL class.
    +
    std::queue
    STL class.
    +
    std::vector::push_back
    T push_back(T... args)
    +
    graph::HKGraph::bfs
    bool bfs()
    This function checks for the possibility of augmented path availability.
    Definition: hopcroft_karp.cpp:133
    +
    std::begin
    T begin(T... args)
    +
    graph::HKGraph::adj
    std::vector< std::list< int > > adj
    adj[u] stores adjacents of left side and 0 is used for dummy vertex
    Definition: hopcroft_karp.cpp:73
    +
    graph::HKGraph::dist
    std::vector< int > dist
    dist represents the distance between vertex 'u' and vertex 'v'
    Definition: hopcroft_karp.cpp:77
    +
    std::vector::end
    T end(T... args)
    +
    graph::HKGraph::pair_v
    std::vector< int > pair_v
    value of vertex 'v' ranges from 1 to n
    Definition: hopcroft_karp.cpp:76
    +
    graph::HKGraph::pair_u
    std::vector< int > pair_u
    value of vertex 'u' ranges from 1 to m
    Definition: hopcroft_karp.cpp:75
    +
    graph::HKGraph::dfs
    bool dfs(int u)
    This functions checks whether an augmenting path is available exists beginning with free vertex u.
    Definition: hopcroft_karp.cpp:191
    + + + + diff --git a/d8/d69/classgraph_1_1_h_k_graph.js b/d8/d69/classgraph_1_1_h_k_graph.js new file mode 100644 index 000000000..bda662e57 --- /dev/null +++ b/d8/d69/classgraph_1_1_h_k_graph.js @@ -0,0 +1,17 @@ +var classgraph_1_1_h_k_graph = +[ + [ "HKGraph", "d8/d69/classgraph_1_1_h_k_graph.html#af02b0c83911070ac6d95fc9905e58aa9", null ], + [ "HKGraph", "d8/d69/classgraph_1_1_h_k_graph.html#a0da5aa674d3b3e54a38251ee60d7cd64", null ], + [ "addEdge", "d8/d69/classgraph_1_1_h_k_graph.html#a3b49011c09cf90a116ab53bef61cd95a", null ], + [ "bfs", "d8/d69/classgraph_1_1_h_k_graph.html#a7491add14d9fc04f679114ca6d6f0f93", null ], + [ "dfs", "d8/d69/classgraph_1_1_h_k_graph.html#ae794950cb3407b6b47d3dc986cf714c0", null ], + [ "hopcroftKarpAlgorithm", "d8/d69/classgraph_1_1_h_k_graph.html#a9dbda80d02bdc26c3e8ff7330c9be75d", null ], + [ "adj", "d8/d69/classgraph_1_1_h_k_graph.html#a35893def7a1c5cd60907b4893117796f", null ], + [ "dist", "d8/d69/classgraph_1_1_h_k_graph.html#a6a0228bbba3818447fcf6b56128b552a", null ], + [ "INF", "d8/d69/classgraph_1_1_h_k_graph.html#a44742cb9cfecd1a4493970af9b8bbb15", null ], + [ "m", "d8/d69/classgraph_1_1_h_k_graph.html#a3d9101e3b4598159005fd028b9b0ff74", null ], + [ "n", "d8/d69/classgraph_1_1_h_k_graph.html#a6f5a9fdbb83ef731d739ba6707e21c3c", null ], + [ "NIL", "d8/d69/classgraph_1_1_h_k_graph.html#ae6d069bd16d6eafa6e08c7e5f735eda6", null ], + [ "pair_u", "d8/d69/classgraph_1_1_h_k_graph.html#a86ebff8a70cbfedd05281993d5d1987b", null ], + [ "pair_v", "d8/d69/classgraph_1_1_h_k_graph.html#a976ee239402cc2726a280e781c706d77", null ] +]; \ No newline at end of file diff --git a/d8/d69/classgraph_1_1_h_k_graph_a3b49011c09cf90a116ab53bef61cd95a_cgraph.map b/d8/d69/classgraph_1_1_h_k_graph_a3b49011c09cf90a116ab53bef61cd95a_cgraph.map new file mode 100644 index 000000000..ffcf09ad7 --- /dev/null +++ b/d8/d69/classgraph_1_1_h_k_graph_a3b49011c09cf90a116ab53bef61cd95a_cgraph.map @@ -0,0 +1,4 @@ + + + + diff --git a/d8/d69/classgraph_1_1_h_k_graph_a3b49011c09cf90a116ab53bef61cd95a_cgraph.md5 b/d8/d69/classgraph_1_1_h_k_graph_a3b49011c09cf90a116ab53bef61cd95a_cgraph.md5 new file mode 100644 index 000000000..179279ac3 --- /dev/null +++ b/d8/d69/classgraph_1_1_h_k_graph_a3b49011c09cf90a116ab53bef61cd95a_cgraph.md5 @@ -0,0 +1 @@ +15f4467c23533c0c12ca74642c798856 \ No newline at end of file diff --git a/d8/d69/classgraph_1_1_h_k_graph_a3b49011c09cf90a116ab53bef61cd95a_cgraph.svg b/d8/d69/classgraph_1_1_h_k_graph_a3b49011c09cf90a116ab53bef61cd95a_cgraph.svg new file mode 100644 index 000000000..227f15bf0 --- /dev/null +++ b/d8/d69/classgraph_1_1_h_k_graph_a3b49011c09cf90a116ab53bef61cd95a_cgraph.svg @@ -0,0 +1,37 @@ + + + + + + +graph::HKGraph::addEdge + + + +Node1 + + +graph::HKGraph::addEdge + + + + + +Node2 + + +std::vector::push_back + + + + + +Node1->Node2 + + + + + diff --git a/d8/d69/classgraph_1_1_h_k_graph_a7491add14d9fc04f679114ca6d6f0f93_cgraph.map b/d8/d69/classgraph_1_1_h_k_graph_a7491add14d9fc04f679114ca6d6f0f93_cgraph.map new file mode 100644 index 000000000..d89223337 --- /dev/null +++ b/d8/d69/classgraph_1_1_h_k_graph_a7491add14d9fc04f679114ca6d6f0f93_cgraph.map @@ -0,0 +1,4 @@ + + + + diff --git a/d8/d69/classgraph_1_1_h_k_graph_a7491add14d9fc04f679114ca6d6f0f93_cgraph.md5 b/d8/d69/classgraph_1_1_h_k_graph_a7491add14d9fc04f679114ca6d6f0f93_cgraph.md5 new file mode 100644 index 000000000..d724dd7f7 --- /dev/null +++ b/d8/d69/classgraph_1_1_h_k_graph_a7491add14d9fc04f679114ca6d6f0f93_cgraph.md5 @@ -0,0 +1 @@ +4a958172f669039dfd4d2318d4dbf48d \ No newline at end of file diff --git a/d8/d69/classgraph_1_1_h_k_graph_a7491add14d9fc04f679114ca6d6f0f93_cgraph.svg b/d8/d69/classgraph_1_1_h_k_graph_a7491add14d9fc04f679114ca6d6f0f93_cgraph.svg new file mode 100644 index 000000000..2e44370b3 --- /dev/null +++ b/d8/d69/classgraph_1_1_h_k_graph_a7491add14d9fc04f679114ca6d6f0f93_cgraph.svg @@ -0,0 +1,37 @@ + + + + + + +graph::HKGraph::bfs + + + +Node1 + + +graph::HKGraph::bfs + + + + + +Node2 + + +std::vector::end + + + + + +Node1->Node2 + + + + + diff --git a/d8/d69/classgraph_1_1_h_k_graph_a9dbda80d02bdc26c3e8ff7330c9be75d_cgraph.map b/d8/d69/classgraph_1_1_h_k_graph_a9dbda80d02bdc26c3e8ff7330c9be75d_cgraph.map new file mode 100644 index 000000000..1bf4fd3e4 --- /dev/null +++ b/d8/d69/classgraph_1_1_h_k_graph_a9dbda80d02bdc26c3e8ff7330c9be75d_cgraph.map @@ -0,0 +1,6 @@ + + + + + + diff --git a/d8/d69/classgraph_1_1_h_k_graph_a9dbda80d02bdc26c3e8ff7330c9be75d_cgraph.md5 b/d8/d69/classgraph_1_1_h_k_graph_a9dbda80d02bdc26c3e8ff7330c9be75d_cgraph.md5 new file mode 100644 index 000000000..a37ef5e06 --- /dev/null +++ b/d8/d69/classgraph_1_1_h_k_graph_a9dbda80d02bdc26c3e8ff7330c9be75d_cgraph.md5 @@ -0,0 +1 @@ +8ca3a64ad81d15f892e4f1cb1c1f0ef3 \ No newline at end of file diff --git a/d8/d69/classgraph_1_1_h_k_graph_a9dbda80d02bdc26c3e8ff7330c9be75d_cgraph.svg b/d8/d69/classgraph_1_1_h_k_graph_a9dbda80d02bdc26c3e8ff7330c9be75d_cgraph.svg new file mode 100644 index 000000000..2947a3401 --- /dev/null +++ b/d8/d69/classgraph_1_1_h_k_graph_a9dbda80d02bdc26c3e8ff7330c9be75d_cgraph.svg @@ -0,0 +1,74 @@ + + + + + + +graph::HKGraph::hopcroftKarpAlgorithm + + + +Node1 + + +graph::HKGraph::hopcroft +KarpAlgorithm + + + + + +Node2 + + +graph::HKGraph::bfs + + + + + +Node1->Node2 + + + + + +Node4 + + +graph::HKGraph::dfs + + + + + +Node1->Node4 + + + + + +Node3 + + +std::vector::end + + + + + +Node2->Node3 + + + + + +Node4->Node3 + + + + + diff --git a/d8/d69/classgraph_1_1_h_k_graph_ae794950cb3407b6b47d3dc986cf714c0_cgraph.map b/d8/d69/classgraph_1_1_h_k_graph_ae794950cb3407b6b47d3dc986cf714c0_cgraph.map new file mode 100644 index 000000000..543edc7cb --- /dev/null +++ b/d8/d69/classgraph_1_1_h_k_graph_ae794950cb3407b6b47d3dc986cf714c0_cgraph.map @@ -0,0 +1,4 @@ + + + + diff --git a/d8/d69/classgraph_1_1_h_k_graph_ae794950cb3407b6b47d3dc986cf714c0_cgraph.md5 b/d8/d69/classgraph_1_1_h_k_graph_ae794950cb3407b6b47d3dc986cf714c0_cgraph.md5 new file mode 100644 index 000000000..985ae93f9 --- /dev/null +++ b/d8/d69/classgraph_1_1_h_k_graph_ae794950cb3407b6b47d3dc986cf714c0_cgraph.md5 @@ -0,0 +1 @@ +0a0a39e7d357d82d1aa385bc9971f1dc \ No newline at end of file diff --git a/d8/d69/classgraph_1_1_h_k_graph_ae794950cb3407b6b47d3dc986cf714c0_cgraph.svg b/d8/d69/classgraph_1_1_h_k_graph_ae794950cb3407b6b47d3dc986cf714c0_cgraph.svg new file mode 100644 index 000000000..3ad8c7e00 --- /dev/null +++ b/d8/d69/classgraph_1_1_h_k_graph_ae794950cb3407b6b47d3dc986cf714c0_cgraph.svg @@ -0,0 +1,37 @@ + + + + + + +graph::HKGraph::dfs + + + +Node1 + + +graph::HKGraph::dfs + + + + + +Node2 + + +std::vector::end + + + + + +Node1->Node2 + + + + + diff --git a/d8/d95/vector__ops_8hpp_source.html b/d8/d95/vector__ops_8hpp_source.html index aed9fb950..77d810396 100644 --- a/d8/d95/vector__ops_8hpp_source.html +++ b/d8/d95/vector__ops_8hpp_source.html @@ -651,11 +651,13 @@ $(document).ready(function(){initNavTree('d8/d95/vector__ops_8hpp_source.html','
    machine_learning::equal_shuffle
    void equal_shuffle(std::vector< std::vector< std::valarray< T >>> &A, std::vector< std::vector< std::valarray< T >>> &B)
    Definition: vector_ops.hpp:136
    graph::LowestCommonAncestor::LowestCommonAncestor
    LowestCommonAncestor(const RootedTree &tree_)
    Stores the tree and precomputs "up lifts".
    Definition: lowest_common_ancestor.cpp:151
    std::inner_product
    T inner_product(T... args)
    +
    graph::HKGraph::m
    int m
    m is the number of vertices on left side of Bipartite Graph
    Definition: hopcroft_karp.cpp:68
    linear_probing::Entry::Entry
    Entry(int key=notPresent)
    constructor
    Definition: linear_probing_hash_table.cpp:36
    std::clock_t
    std::move
    T move(T... args)
    machine_learning::operator/
    std::vector< std::valarray< T > > operator/(const std::vector< std::valarray< T >> &A, const T &val)
    Definition: vector_ops.hpp:365
    operator+
    std::vector< T > operator+(std::vector< T > const &A, std::vector< T > const &B)
    Definition: ordinary_least_squares_regressor.cpp:204
    +
    graph::HKGraph::n
    int n
    n is the number of vertices on right side of Bipartite Graph
    Definition: hopcroft_karp.cpp:69
    linear_probing::putProber
    bool putProber(const Entry &entry, int key)
    Definition: linear_probing_hash_table.cpp:98
    machine_learning::pop_front
    std::valarray< T > pop_front(const std::valarray< T > &A)
    Definition: vector_ops.hpp:102
    double_hashing
    An implementation of hash table using double hashing algorithm.
    @@ -693,6 +695,7 @@ $(document).ready(function(){initNavTree('d8/d95/vector__ops_8hpp_source.html','
    main
    int main(int argc, char **argv)
    Definition: spirograph.cpp:268
    Graph::Graph
    Graph(unsigned int vertices, AdjList adjList)
    Definition: cycle_check_directed_graph.cpp:68
    std::default_random_engine
    +
    graph::HKGraph::addEdge
    void addEdge(int u, int v)
    function to add edge from u to v
    Definition: hopcroft_karp.cpp:242
    std::queue::emplace
    T emplace(T... args)
    graph::getConnectedComponents
    int getConnectedComponents(const std::vector< std::vector< int >> *adj)
    Function that perfoms depth first search algorithm on graph and calculated the number of connected co...
    Definition: connected_components.cpp:77
    graph::LowestCommonAncestor::populate_up
    void populate_up()
    Definition: lowest_common_ancestor.cpp:212
    @@ -885,6 +888,7 @@ $(document).ready(function(){initNavTree('d8/d95/vector__ops_8hpp_source.html','
    quadratic_probing::Entry::Entry
    Entry(int key=notPresent)
    constructor
    Definition: quadratic_probing_hash_table.cpp:38
    stack::top
    Type top()
    Definition: stack.h:93
    geometry::jarvis::Convexhull
    Definition: jarvis_algorithm.cpp:55
    +
    graph::HKGraph::bfs
    bool bfs()
    This function checks for the possibility of augmented path availability.
    Definition: hopcroft_karp.cpp:133
    hamilton_cycle
    bool hamilton_cycle(const std::vector< std::vector< bool >> &routes)
    Definition: hamiltons_cycle.cpp:30
    data_structures::trie::deleteString
    bool deleteString(const std::string &str, int index)
    Definition: trie_tree.cpp:134
    tests
    void tests()
    Definition: connected_components.cpp:93
    @@ -908,6 +912,7 @@ $(document).ready(function(){initNavTree('d8/d95/vector__ops_8hpp_source.html','
    get_inverse
    std::vector< std::vector< float > > get_inverse(std::vector< std::vector< T >> const &A)
    Definition: ordinary_least_squares_regressor.cpp:226
    data_structures::trie::search
    bool search(const std::shared_ptr< trie > &root, const std::string &str, int index)
    Definition: trie_tree.cpp:56
    machine_learning::neural_network::NeuralNetwork::get_XY_from_csv
    std::pair< std::vector< std::vector< std::valarray< double > > >, std::vector< std::vector< std::valarray< double > > > > get_XY_from_csv(const std::string &file_name, const bool &last_label, const bool &normalize, const int &slip_lines=1)
    Definition: neural_network.cpp:382
    +
    main
    int main()
    Main function.
    Definition: hopcroft_karp.cpp:306
    double_hashing::searchingProber
    bool searchingProber(const Entry &entry, int key)
    Definition: double_hash_hash_table.cpp:133
    std::left
    T left(T... args)
    hash_chain::next
    std::shared_ptr< struct Node > next
    pointer to the next node
    Definition: chaining.cpp:23
    @@ -922,13 +927,16 @@ $(document).ready(function(){initNavTree('d8/d95/vector__ops_8hpp_source.html','
    std::greater
    machine_learning::get_shape
    std::pair< size_t, size_t > get_shape(const std::vector< std::valarray< T >> &A)
    Definition: vector_ops.hpp:247
    std
    STL namespace.
    +
    graph::HKGraph::adj
    std::vector< std::list< int > > adj
    adj[u] stores adjacents of left side and 0 is used for dummy vertex
    Definition: hopcroft_karp.cpp:73
    std::vector::insert
    T insert(T... args)
    +
    graph::HKGraph::HKGraph
    HKGraph()
    Default Constructor for initialization.
    machine_learning::neural_network::NeuralNetwork::operator=
    NeuralNetwork & operator=(NeuralNetwork &&)=default
    machine_learning::neural_network::NeuralNetwork::save_model
    void save_model(const std::string &_file_name)
    Definition: neural_network.cpp:652
    machine_learning::MIN_DISTANCE
    constexpr double MIN_DISTANCE
    Definition: kohonen_som_topology.cpp:129
    linear_probing::removalInfo
    void removalInfo(int key)
    Definition: linear_probing_hash_table.cpp:201
    show
    void show(const struct tower *const F, const struct tower *const T, const struct tower *const U)
    Definition: tower_of_hanoi.cpp:19
    graph::Graph::number_of_vertices
    int number_of_vertices() const
    Definition: lowest_common_ancestor.cpp:74
    +
    tests
    void tests()
    Definition: hopcroft_karp.cpp:255
    compare
    Definition: huffman.cpp:28
    stack
    Definition: stack.h:26
    machine_learning::neural_network::activations::dsigmoid
    double dsigmoid(const double &x)
    Definition: neural_network.cpp:67
    @@ -956,6 +964,7 @@ $(document).ready(function(){initNavTree('d8/d95/vector__ops_8hpp_source.html','
    geometry::jarvis::Point
    Definition: jarvis_algorithm.cpp:47
    test3
    void test3()
    Definition: kohonen_som_trace.cpp:414
    std::queue::push
    T push(T... args)
    +
    graph::HKGraph::dist
    std::vector< int > dist
    dist represents the distance between vertex 'u' and vertex 'v'
    Definition: hopcroft_karp.cpp:77
    ols_test
    void ols_test()
    Definition: ordinary_least_squares_regressor.cpp:369
    stack::isEmptyStack
    bool isEmptyStack()
    Definition: stack.h:80
    layers
    This namespace contains layers used in MLP.
    @@ -975,7 +984,9 @@ $(document).ready(function(){initNavTree('d8/d95/vector__ops_8hpp_source.html','
    double_hashing::Entry::key
    int key
    key value
    Definition: double_hash_hash_table.cpp:38
    geometry::jarvis::Convexhull::orientation
    static int orientation(const Point &p, const Point &q, const Point &r)
    Definition: jarvis_algorithm.cpp:133
    std::setw
    T setw(T... args)
    +
    graph::HKGraph
    Represents Bipartite graph for Hopcroft Karp implementation.
    Definition: hopcroft_karp.cpp:67
    machine_learning::adaline::accuracy
    const double accuracy
    model fit convergence accuracy
    Definition: adaline_learning.cpp:208
    +
    graph::HKGraph::pair_v
    std::vector< int > pair_v
    value of vertex 'v' ranges from 1 to n
    Definition: hopcroft_karp.cpp:76
    std::max
    T max(T... args)
    main
    int main()
    Definition: dijkstra.cpp:152
    machine_learning::operator+
    std::vector< std::valarray< T > > operator+(const std::vector< std::valarray< T >> &A, const std::vector< std::valarray< T >> &B)
    Definition: vector_ops.hpp:406
    @@ -986,6 +997,7 @@ $(document).ready(function(){initNavTree('d8/d95/vector__ops_8hpp_source.html','
    Point
    Definition: line_segment_intersection.cpp:12
    machine_learning::hadamard_product
    std::vector< std::valarray< T > > hadamard_product(const std::vector< std::valarray< T >> &A, const std::vector< std::valarray< T >> &B)
    Definition: vector_ops.hpp:494
    graph::is_graph_bipartite::Graph
    Class for representing graph as an adjacency list.
    Definition: is_graph_bipartite.cpp:51
    +
    graph::HKGraph::hopcroftKarpAlgorithm
    int hopcroftKarpAlgorithm()
    This function counts the number of augmenting paths between left and right sides of the Bipartite gra...
    Definition: hopcroft_karp.cpp:95
    machine_learning::kohonen_som
    void kohonen_som(const std::vector< std::valarray< double >> &X, std::vector< std::vector< std::valarray< double >>> *W, double alpha_min)
    Definition: kohonen_som_topology.cpp:269
    push
    void push(char ch)
    push byte to stack variable
    Definition: paranthesis_matching.cpp:26
    Trie::removeWordHelper
    std::shared_ptr< TrieNode > removeWordHelper(const std::string &word, std::shared_ptr< TrieNode > curr, size_t index)
    Definition: trie_modern.cpp:64
    @@ -1000,6 +1012,7 @@ $(document).ready(function(){initNavTree('d8/d95/vector__ops_8hpp_source.html','
    graph::LowestCommonAncestor::lowest_common_ancestor
    int lowest_common_ancestor(int u, int v) const
    Query the structure to find the lowest common ancestor. Assumes that the provided numbers are valid i...
    Definition: lowest_common_ancestor.cpp:164
    std::cin
    hash_chain::display
    void display()
    Display the chain.
    Definition: chaining.cpp:63
    +
    graph::HKGraph::pair_u
    std::vector< int > pair_u
    value of vertex 'u' ranges from 1 to m
    Definition: hopcroft_karp.cpp:75
    main
    int main()
    Definition: shortest_common_supersequence.cpp:164
    sorting::quickSort
    void quickSort(int arr[], int low, int high)
    Definition: quick_sort.cpp:63
    test2
    void test2(double eta=0.01)
    Definition: adaline_learning.cpp:262
    @@ -1015,6 +1028,7 @@ $(document).ready(function(){initNavTree('d8/d95/vector__ops_8hpp_source.html','
    operator/
    std::vector< float > operator/(std::vector< T > const &A, float const scalar)
    Definition: ordinary_least_squares_regressor.cpp:174
    machine_learning::kohonen_som_tracer
    void kohonen_som_tracer(const std::vector< std::valarray< double >> &X, std::vector< std::valarray< double >> *W, double alpha_min)
    Definition: kohonen_som_trace.cpp:149
    util_functions
    Various utility functions used in Neural network.
    +
    graph::HKGraph::dfs
    bool dfs(int u)
    This functions checks whether an augmenting path is available exists beginning with free vertex u.
    Definition: hopcroft_karp.cpp:191
    graph::is_graph_bipartite::Graph::addEdge
    void addEdge(int u, int v)
    Function that add an edge between two nodes or vertices of graph.
    Definition: is_graph_bipartite.cpp:83
    std::ifstream::eof
    T eof(T... args)
    std::exit
    T exit(T... args)
    diff --git a/d9/d43/hopcroft__karp_8cpp__incl.map b/d9/d43/hopcroft__karp_8cpp__incl.map new file mode 100644 index 000000000..52ac5f367 --- /dev/null +++ b/d9/d43/hopcroft__karp_8cpp__incl.map @@ -0,0 +1,10 @@ + + + + + + + + + + diff --git a/d9/d43/hopcroft__karp_8cpp__incl.md5 b/d9/d43/hopcroft__karp_8cpp__incl.md5 new file mode 100644 index 000000000..ce6f1dbd5 --- /dev/null +++ b/d9/d43/hopcroft__karp_8cpp__incl.md5 @@ -0,0 +1 @@ +9d0351860954a721fcec403f6f3bd9d1 \ No newline at end of file diff --git a/d9/d43/hopcroft__karp_8cpp__incl.svg b/d9/d43/hopcroft__karp_8cpp__incl.svg new file mode 100644 index 000000000..2254fdcaa --- /dev/null +++ b/d9/d43/hopcroft__karp_8cpp__incl.svg @@ -0,0 +1,127 @@ + + + + + + +graph/hopcroft_karp.cpp + + + +Node1 + + +graph/hopcroft_karp.cpp + + + + + +Node2 + + +iostream + + + + + +Node1->Node2 + + + + + +Node3 + + +cstdlib + + + + + +Node1->Node3 + + + + + +Node4 + + +queue + + + + + +Node1->Node4 + + + + + +Node5 + + +list + + + + + +Node1->Node5 + + + + + +Node6 + + +climits + + + + + +Node1->Node6 + + + + + +Node7 + + +memory + + + + + +Node1->Node7 + + + + + +Node8 + + +cassert + + + + + +Node1->Node8 + + + + + diff --git a/dc/dea/classgraph_1_1_h_k_graph-members.html b/dc/dea/classgraph_1_1_h_k_graph-members.html new file mode 100644 index 000000000..cf5244c6a --- /dev/null +++ b/dc/dea/classgraph_1_1_h_k_graph-members.html @@ -0,0 +1,123 @@ + + + + + + + +Algorithms_in_C++: Member List + + + + + + + + + + + + + + + +
    +
    + + + + + + +
    +
    Algorithms_in_C++ +  1.0.0 +
    +
    Set of algorithms implemented in C++.
    +
    +
    + + + + + + + +
    +
    + +
    +
    +
    + +
    + +
    +
    + + +
    + +
    + +
    +
    +
    graph::HKGraph Member List
    +
    +
    + +

    This is the complete list of members for graph::HKGraph, including all inherited members.

    + + + + + + + + + + + + + + + +
    addEdge(int u, int v)graph::HKGraph
    adjgraph::HKGraphprivate
    bfs()graph::HKGraph
    dfs(int u)graph::HKGraph
    distgraph::HKGraphprivate
    HKGraph()graph::HKGraph
    HKGraph(int m, int n)graph::HKGraph
    hopcroftKarpAlgorithm()graph::HKGraph
    INF (defined in graph::HKGraph)graph::HKGraphprivate
    mgraph::HKGraphprivate
    ngraph::HKGraphprivate
    NIL (defined in graph::HKGraph)graph::HKGraphprivate
    pair_ugraph::HKGraphprivate
    pair_vgraph::HKGraphprivate
    +
    + + + + diff --git a/df/d82/classgraph_1_1_h_k_graph__coll__graph.map b/df/d82/classgraph_1_1_h_k_graph__coll__graph.map new file mode 100644 index 000000000..6c80278c1 --- /dev/null +++ b/df/d82/classgraph_1_1_h_k_graph__coll__graph.map @@ -0,0 +1,6 @@ + + + + + + diff --git a/df/d82/classgraph_1_1_h_k_graph__coll__graph.md5 b/df/d82/classgraph_1_1_h_k_graph__coll__graph.md5 new file mode 100644 index 000000000..e2752e5eb --- /dev/null +++ b/df/d82/classgraph_1_1_h_k_graph__coll__graph.md5 @@ -0,0 +1 @@ +6f02041634dc236fe9f0252ed9d79c5f \ No newline at end of file diff --git a/df/d82/classgraph_1_1_h_k_graph__coll__graph.svg b/df/d82/classgraph_1_1_h_k_graph__coll__graph.svg new file mode 100644 index 000000000..5a22dd136 --- /dev/null +++ b/df/d82/classgraph_1_1_h_k_graph__coll__graph.svg @@ -0,0 +1,73 @@ + + + + + + +graph::HKGraph + + + +Node1 + + +graph::HKGraph + + + + + +Node2 + + +std::vector< std::list +< int > > + + + + + +Node2->Node1 + + + adj + + + +Node3 + + +std::list< int > + + + + + +Node3->Node2 + + + elements + + + +Node4 + + +std::vector< int > + + + + + +Node4->Node1 + + + dist +pair_u +pair_v + + + diff --git a/df/dce/namespacegraph.html b/df/dce/namespacegraph.html index c70ef3a37..e165c5398 100644 --- a/df/dce/namespacegraph.html +++ b/df/dce/namespacegraph.html @@ -106,6 +106,9 @@ $(document).ready(function(){initNavTree('df/dce/namespacegraph.html','../../'); Classes class  Graph   +class  HKGraph + Represents Bipartite graph for Hopcroft Karp implementation. More...
    +  class  LowestCommonAncestor   class  RootedTree diff --git a/df/dce/namespacegraph.js b/df/dce/namespacegraph.js index 2e8db1f75..d25c041a9 100644 --- a/df/dce/namespacegraph.js +++ b/df/dce/namespacegraph.js @@ -4,6 +4,7 @@ var namespacegraph = [ "Graph", "de/d00/classgraph_1_1is__graph__bipartite_1_1_graph.html", "de/d00/classgraph_1_1is__graph__bipartite_1_1_graph" ] ] ], [ "Graph", "dc/d61/classgraph_1_1_graph.html", "dc/d61/classgraph_1_1_graph" ], + [ "HKGraph", "d8/d69/classgraph_1_1_h_k_graph.html", "d8/d69/classgraph_1_1_h_k_graph" ], [ "LowestCommonAncestor", "d9/d23/classgraph_1_1_lowest_common_ancestor.html", "d9/d23/classgraph_1_1_lowest_common_ancestor" ], [ "RootedTree", "d0/d58/classgraph_1_1_rooted_tree.html", "d0/d58/classgraph_1_1_rooted_tree" ] ]; \ No newline at end of file diff --git a/dir_12552d7fa429bf94a2e32e5cf39f7e69.html b/dir_12552d7fa429bf94a2e32e5cf39f7e69.html index 7b93bac2c..ac11d29e6 100644 --- a/dir_12552d7fa429bf94a2e32e5cf39f7e69.html +++ b/dir_12552d7fa429bf94a2e32e5cf39f7e69.html @@ -112,6 +112,9 @@ Files file  hamiltons_cycle.cpp  The implementation of Hamilton's cycle dynamic solution for vertices number less than 20.
      +file  hopcroft_karp.cpp + Implementation of Hopcroft–Karp algorithm.
    +  file  is_graph_bipartite.cpp  Algorithm to check whether a graph is bipartite
      diff --git a/dir_12552d7fa429bf94a2e32e5cf39f7e69.js b/dir_12552d7fa429bf94a2e32e5cf39f7e69.js index b36574232..0f8c6d658 100644 --- a/dir_12552d7fa429bf94a2e32e5cf39f7e69.js +++ b/dir_12552d7fa429bf94a2e32e5cf39f7e69.js @@ -5,6 +5,7 @@ var dir_12552d7fa429bf94a2e32e5cf39f7e69 = [ "depth_first_search.cpp", "da/d8d/depth__first__search_8cpp.html", "da/d8d/depth__first__search_8cpp" ], [ "dijkstra.cpp", "d7/d1e/graph_2dijkstra_8cpp.html", "d7/d1e/graph_2dijkstra_8cpp" ], [ "hamiltons_cycle.cpp", "dd/d0c/hamiltons__cycle_8cpp.html", "dd/d0c/hamiltons__cycle_8cpp" ], + [ "hopcroft_karp.cpp", "d1/d9a/hopcroft__karp_8cpp.html", "d1/d9a/hopcroft__karp_8cpp" ], [ "is_graph_bipartite.cpp", "d6/dd8/is__graph__bipartite_8cpp.html", "d6/dd8/is__graph__bipartite_8cpp" ], [ "lowest_common_ancestor.cpp", "de/dde/lowest__common__ancestor_8cpp.html", "de/dde/lowest__common__ancestor_8cpp" ] ]; \ No newline at end of file diff --git a/files.html b/files.html index 72b9d8185..6c65fff8a 100644 --- a/files.html +++ b/files.html @@ -137,8 +137,9 @@ $(document).ready(function(){initNavTree('files.html',''); initResizable(); });  depth_first_search.cppDepth First Search Algorithm (Depth First Search)  dijkstra.cppGraph Dijkstras Shortest Path Algorithm (Dijkstra's Shortest Path)  hamiltons_cycle.cppThe implementation of Hamilton's cycle dynamic solution for vertices number less than 20 - is_graph_bipartite.cppAlgorithm to check whether a graph is bipartite - lowest_common_ancestor.cppData structure for finding the lowest common ancestor of two vertices in a rooted tree using binary lifting + hopcroft_karp.cppImplementation of Hopcroft–Karp algorithm + is_graph_bipartite.cppAlgorithm to check whether a graph is bipartite + lowest_common_ancestor.cppData structure for finding the lowest common ancestor of two vertices in a rooted tree using binary lifting  ► graphics  spirograph.cppImplementation of Spirograph  ► greedy_algorithms diff --git a/functions_a.html b/functions_a.html index f5dbb746a..c91133177 100644 --- a/functions_a.html +++ b/functions_a.html @@ -116,13 +116,15 @@ $(document).ready(function(){initNavTree('functions_a.html',''); initResizable()
  • addEdge() : Graph +, graph::HKGraph , graph::is_graph_bipartite::Graph
  • addVertices() : Graph
  • adj -: graph::is_graph_bipartite::Graph +: graph::HKGraph +, graph::is_graph_bipartite::Graph
  • arg() : Complex diff --git a/functions_b.html b/functions_b.html index fc34f9f5f..8ff382144 100644 --- a/functions_b.html +++ b/functions_b.html @@ -96,6 +96,9 @@ $(document).ready(function(){initNavTree('functions_b.html',''); initResizable()
  • batch_predict() : machine_learning::neural_network::NeuralNetwork
    • +
  • bfs() +: graph::HKGraph +
    • diff --git a/functions_d.html b/functions_d.html index 539aa84ae..096d5f5c3 100644 --- a/functions_d.html +++ b/functions_d.html @@ -117,6 +117,9 @@ $(document).ready(function(){initNavTree('functions_d.html',''); initResizable()
  • deQueue() : queue< Kind >
    • +
  • dfs() +: graph::HKGraph +
  • dfs_hc() : range_queries::heavy_light_decomposition::HLD< X >
    • @@ -147,6 +150,9 @@ $(document).ready(function(){initNavTree('functions_d.html',''); initResizable()
  • displayList() : data_structures::SkipList
    • +
  • dist +: graph::HKGraph +
    • diff --git a/functions_func.html b/functions_func.html index 026c90e34..a6a9f90f8 100644 --- a/functions_func.html +++ b/functions_func.html @@ -97,575 +97,6 @@ $(document).ready(function(){initNavTree('functions_func.html',''); initResizabl : machine_learning::neural_network::NeuralNetwork - - -

    - a -

    - - -

    - b -

    - - -

    - c -

    - - -

    - d -

    - - -

    - e -

    - - -

    - f -

    - - -

    - g -

    - - -

    - h -

    - - -

    - i -

    - - -

    - k -

    - - -

    - l -

    - - -

    - m -

    - - -

    - n -

    - - -

    - o -

    - - -

    - p -

    - - -

    - q -

    - - -

    - r -

    - - -

    - s -

    - - -

    - t -

    - - -

    - u -

    - - -

    - v -

    - - -

    - ~ -

    diff --git a/functions_func.js b/functions_func.js new file mode 100644 index 000000000..d55a7000a --- /dev/null +++ b/functions_func.js @@ -0,0 +1,26 @@ +var functions_func = +[ + [ "_", "functions_func.html", null ], + [ "a", "functions_func_a.html", null ], + [ "b", "functions_func_b.html", null ], + [ "c", "functions_func_c.html", null ], + [ "d", "functions_func_d.html", null ], + [ "e", "functions_func_e.html", null ], + [ "f", "functions_func_f.html", null ], + [ "g", "functions_func_g.html", null ], + [ "h", "functions_func_h.html", null ], + [ "i", "functions_func_i.html", null ], + [ "k", "functions_func_k.html", null ], + [ "l", "functions_func_l.html", null ], + [ "m", "functions_func_m.html", null ], + [ "n", "functions_func_n.html", null ], + [ "o", "functions_func_o.html", null ], + [ "p", "functions_func_p.html", null ], + [ "q", "functions_func_q.html", null ], + [ "r", "functions_func_r.html", null ], + [ "s", "functions_func_s.html", null ], + [ "t", "functions_func_t.html", null ], + [ "u", "functions_func_u.html", null ], + [ "v", "functions_func_v.html", null ], + [ "~", "functions_func_~.html", null ] +]; \ No newline at end of file diff --git a/functions_func_a.html b/functions_func_a.html new file mode 100644 index 000000000..c0343dfd0 --- /dev/null +++ b/functions_func_a.html @@ -0,0 +1,135 @@ + + + + + + + +Algorithms_in_C++: Class Members - Functions + + + + + + + + + + + + + + + +
    +
    + + + + + + +
    +
    Algorithms_in_C++ +  1.0.0 +
    +
    Set of algorithms implemented in C++.
    +
    +
    + + + + + + + +
    +
    + +
    +
    +
    + +
    + +
    +
    + + +
    + +
    + +
    +  + +

    - a -

    +
    +
    + + + + diff --git a/functions_func_b.html b/functions_func_b.html new file mode 100644 index 000000000..82c343e5a --- /dev/null +++ b/functions_func_b.html @@ -0,0 +1,112 @@ + + + + + + + +Algorithms_in_C++: Class Members - Functions + + + + + + + + + + + + + + + +
    +
    + + + + + + +
    +
    Algorithms_in_C++ +  1.0.0 +
    +
    Set of algorithms implemented in C++.
    +
    +
    + + + + + + + +
    +
    + +
    +
    +
    + +
    + +
    +
    + + +
    + +
    + +
    +  + +

    - b -

    +
    +
    + + + + diff --git a/functions_func_c.html b/functions_func_c.html new file mode 100644 index 000000000..27dd3822d --- /dev/null +++ b/functions_func_c.html @@ -0,0 +1,134 @@ + + + + + + + +Algorithms_in_C++: Class Members - Functions + + + + + + + + + + + + + + + +
    +
    + + + + + + +
    +
    Algorithms_in_C++ +  1.0.0 +
    +
    Set of algorithms implemented in C++.
    +
    +
    + + + + + + + +
    +
    + +
    +
    +
    + +
    + +
    +
    + + +
    + +
    + +
    +  + +

    - c -

    +
    +
    + + + + diff --git a/functions_func_d.html b/functions_func_d.html new file mode 100644 index 000000000..203708b59 --- /dev/null +++ b/functions_func_d.html @@ -0,0 +1,160 @@ + + + + + + + +Algorithms_in_C++: Class Members - Functions + + + + + + + + + + + + + + + +
    +
    + + + + + + +
    +
    Algorithms_in_C++ +  1.0.0 +
    +
    Set of algorithms implemented in C++.
    +
    +
    + + + + + + + +
    +
    + +
    +
    +
    + +
    + +
    +
    + + +
    + +
    + +
    +  + +

    - d -

    +
    +
    + + + + diff --git a/functions_func_e.html b/functions_func_e.html new file mode 100644 index 000000000..954daf174 --- /dev/null +++ b/functions_func_e.html @@ -0,0 +1,132 @@ + + + + + + + +Algorithms_in_C++: Class Members - Functions + + + + + + + + + + + + + + + +
    +
    + + + + + + +
    +
    Algorithms_in_C++ +  1.0.0 +
    +
    Set of algorithms implemented in C++.
    +
    +
    + + + + + + + +
    +
    + +
    +
    +
    + +
    + +
    +
    + + +
    + +
    + +
    +  + +

    - e -

    +
    +
    + + + + diff --git a/functions_func_f.html b/functions_func_f.html new file mode 100644 index 000000000..9e437e208 --- /dev/null +++ b/functions_func_f.html @@ -0,0 +1,122 @@ + + + + + + + +Algorithms_in_C++: Class Members - Functions + + + + + + + + + + + + + + + +
    +
    + + + + + + +
    +
    Algorithms_in_C++ +  1.0.0 +
    +
    Set of algorithms implemented in C++.
    +
    +
    + + + + + + + +
    +
    + +
    +
    +
    + +
    + +
    +
    + + +
    + +
    + +
    +  + +

    - f -

    +
    +
    + + + + diff --git a/functions_func_g.html b/functions_func_g.html new file mode 100644 index 000000000..9086d1171 --- /dev/null +++ b/functions_func_g.html @@ -0,0 +1,147 @@ + + + + + + + +Algorithms_in_C++: Class Members - Functions + + + + + + + + + + + + + + + +
    +
    + + + + + + +
    +
    Algorithms_in_C++ +  1.0.0 +
    +
    Set of algorithms implemented in C++.
    +
    +
    + + + + + + + +
    +
    + +
    +
    +
    + +
    + +
    +
    + + +
    + +
    + +
    +  + +

    - g -

    +
    +
    + + + + diff --git a/functions_func_h.html b/functions_func_h.html new file mode 100644 index 000000000..427c93ec1 --- /dev/null +++ b/functions_func_h.html @@ -0,0 +1,124 @@ + + + + + + + +Algorithms_in_C++: Class Members - Functions + + + + + + + + + + + + + + + +
    +
    + + + + + + +
    +
    Algorithms_in_C++ +  1.0.0 +
    +
    Set of algorithms implemented in C++.
    +
    +
    + + + + + + + +
    +
    + +
    +
    +
    + +
    + +
    +
    + + +
    + +
    + +
    +  + +

    - h -

    +
    +
    + + + + diff --git a/functions_func_i.html b/functions_func_i.html new file mode 100644 index 000000000..442d38d4d --- /dev/null +++ b/functions_func_i.html @@ -0,0 +1,144 @@ + + + + + + + +Algorithms_in_C++: Class Members - Functions + + + + + + + + + + + + + + + +
    +
    + + + + + + +
    +
    Algorithms_in_C++ +  1.0.0 +
    +
    Set of algorithms implemented in C++.
    +
    +
    + + + + + + + +
    +
    + +
    +
    +
    + +
    + +
    +
    + + +
    + +
    + +
    +  + +

    - i -

    +
    +
    + + + + diff --git a/functions_func_k.html b/functions_func_k.html new file mode 100644 index 000000000..79b06e9d2 --- /dev/null +++ b/functions_func_k.html @@ -0,0 +1,109 @@ + + + + + + + +Algorithms_in_C++: Class Members - Functions + + + + + + + + + + + + + + + +
    +
    + + + + + + +
    +
    Algorithms_in_C++ +  1.0.0 +
    +
    Set of algorithms implemented in C++.
    +
    +
    + + + + + + + +
    +
    + +
    +
    +
    + +
    + +
    +
    + + +
    + +
    + +
    +  + +

    - k -

    +
    +
    + + + + diff --git a/functions_func_l.html b/functions_func_l.html new file mode 100644 index 000000000..236191e64 --- /dev/null +++ b/functions_func_l.html @@ -0,0 +1,133 @@ + + + + + + + +Algorithms_in_C++: Class Members - Functions + + + + + + + + + + + + + + + +
    +
    + + + + + + +
    +
    Algorithms_in_C++ +  1.0.0 +
    +
    Set of algorithms implemented in C++.
    +
    +
    + + + + + + + +
    +
    + +
    +
    +
    + +
    + +
    +
    + + +
    + +
    + +
    +  + +

    - l -

    +
    +
    + + + + diff --git a/functions_func_m.html b/functions_func_m.html new file mode 100644 index 000000000..e6aef0ee9 --- /dev/null +++ b/functions_func_m.html @@ -0,0 +1,122 @@ + + + + + + + +Algorithms_in_C++: Class Members - Functions + + + + + + + + + + + + + + + +
    +
    + + + + + + +
    +
    Algorithms_in_C++ +  1.0.0 +
    +
    Set of algorithms implemented in C++.
    +
    +
    + + + + + + + +
    +
    + +
    +
    +
    + +
    + +
    +
    + + +
    + +
    + +
    +  + +

    - m -

    +
    +
    + + + + diff --git a/functions_func_n.html b/functions_func_n.html new file mode 100644 index 000000000..8f5c5f6cf --- /dev/null +++ b/functions_func_n.html @@ -0,0 +1,122 @@ + + + + + + + +Algorithms_in_C++: Class Members - Functions + + + + + + + + + + + + + + + +
    +
    + + + + + + +
    +
    Algorithms_in_C++ +  1.0.0 +
    +
    Set of algorithms implemented in C++.
    +
    +
    + + + + + + + +
    +
    + +
    +
    +
    + +
    + +
    +
    + + +
    + +
    + +
    +  + +

    - n -

    +
    +
    + + + + diff --git a/functions_func_o.html b/functions_func_o.html new file mode 100644 index 000000000..375cbe62e --- /dev/null +++ b/functions_func_o.html @@ -0,0 +1,149 @@ + + + + + + + +Algorithms_in_C++: Class Members - Functions + + + + + + + + + + + + + + + +
    +
    + + + + + + +
    +
    Algorithms_in_C++ +  1.0.0 +
    +
    Set of algorithms implemented in C++.
    +
    +
    + + + + + + + +
    +
    + +
    +
    +
    + +
    + +
    +
    + + +
    + +
    + +
    +  + +

    - o -

    +
    +
    + + + + diff --git a/functions_func_p.html b/functions_func_p.html new file mode 100644 index 000000000..38f3dacd3 --- /dev/null +++ b/functions_func_p.html @@ -0,0 +1,130 @@ + + + + + + + +Algorithms_in_C++: Class Members - Functions + + + + + + + + + + + + + + + +
    +
    + + + + + + +
    +
    Algorithms_in_C++ +  1.0.0 +
    +
    Set of algorithms implemented in C++.
    +
    +
    + + + + + + + +
    +
    + +
    +
    +
    + +
    + +
    +
    + + +
    + +
    + +
    +  + +

    - p -

    +
    +
    + + + + diff --git a/functions_func_q.html b/functions_func_q.html new file mode 100644 index 000000000..9bd54d174 --- /dev/null +++ b/functions_func_q.html @@ -0,0 +1,113 @@ + + + + + + + +Algorithms_in_C++: Class Members - Functions + + + + + + + + + + + + + + + +
    +
    + + + + + + +
    +
    Algorithms_in_C++ +  1.0.0 +
    +
    Set of algorithms implemented in C++.
    +
    +
    + + + + + + + +
    +
    + +
    +
    +
    + +
    + +
    +
    + + +
    + +
    + +
    +  + +

    - q -

    +
    +
    + + + + diff --git a/functions_func_r.html b/functions_func_r.html new file mode 100644 index 000000000..67cfd037b --- /dev/null +++ b/functions_func_r.html @@ -0,0 +1,124 @@ + + + + + + + +Algorithms_in_C++: Class Members - Functions + + + + + + + + + + + + + + + +
    +
    + + + + + + +
    +
    Algorithms_in_C++ +  1.0.0 +
    +
    Set of algorithms implemented in C++.
    +
    +
    + + + + + + + +
    +
    + +
    +
    +
    + +
    + +
    +
    + + +
    + +
    + +
    +  + +

    - r -

    +
    +
    + + + + diff --git a/functions_func_s.html b/functions_func_s.html new file mode 100644 index 000000000..3b900dfa3 --- /dev/null +++ b/functions_func_s.html @@ -0,0 +1,151 @@ + + + + + + + +Algorithms_in_C++: Class Members - Functions + + + + + + + + + + + + + + + +
    +
    + + + + + + +
    +
    Algorithms_in_C++ +  1.0.0 +
    +
    Set of algorithms implemented in C++.
    +
    +
    + + + + + + + +
    +
    + +
    +
    +
    + +
    + +
    +
    + + +
    + +
    + +
    +  + +

    - s -

    +
    +
    + + + + diff --git a/functions_func_t.html b/functions_func_t.html new file mode 100644 index 000000000..cb77d1077 --- /dev/null +++ b/functions_func_t.html @@ -0,0 +1,121 @@ + + + + + + + +Algorithms_in_C++: Class Members - Functions + + + + + + + + + + + + + + + +
    +
    + + + + + + +
    +
    Algorithms_in_C++ +  1.0.0 +
    +
    Set of algorithms implemented in C++.
    +
    +
    + + + + + + + +
    +
    + +
    +
    +
    + +
    + +
    +
    + + +
    + +
    + +
    +  + +

    - t -

    +
    +
    + + + + diff --git a/functions_func_u.html b/functions_func_u.html new file mode 100644 index 000000000..8994d942a --- /dev/null +++ b/functions_func_u.html @@ -0,0 +1,111 @@ + + + + + + + +Algorithms_in_C++: Class Members - Functions + + + + + + + + + + + + + + + +
    +
    + + + + + + +
    +
    Algorithms_in_C++ +  1.0.0 +
    +
    Set of algorithms implemented in C++.
    +
    +
    + + + + + + + +
    +
    + +
    +
    +
    + +
    + +
    +
    + + +
    + +
    + +
    +  + +

    - u -

    +
    +
    + + + + diff --git a/functions_func_v.html b/functions_func_v.html new file mode 100644 index 000000000..e6466d4df --- /dev/null +++ b/functions_func_v.html @@ -0,0 +1,113 @@ + + + + + + + +Algorithms_in_C++: Class Members - Functions + + + + + + + + + + + + + + + +
    +
    + + + + + + +
    +
    Algorithms_in_C++ +  1.0.0 +
    +
    Set of algorithms implemented in C++.
    +
    +
    + + + + + + + +
    +
    + +
    +
    +
    + +
    + +
    +
    + + +
    + +
    + +
    +  + +

    - v -

    +
    +
    + + + + diff --git a/functions_func_~.html b/functions_func_~.html new file mode 100644 index 000000000..714971786 --- /dev/null +++ b/functions_func_~.html @@ -0,0 +1,118 @@ + + + + + + + +Algorithms_in_C++: Class Members - Functions + + + + + + + + + + + + + + + +
    +
    + + + + + + +
    +
    Algorithms_in_C++ +  1.0.0 +
    +
    Set of algorithms implemented in C++.
    +
    +
    + + + + + + + +
    +
    + +
    +
    +
    + +
    + +
    +
    + + +
    + +
    + +
    +  + +

    - ~ -

    +
    +
    + + + + diff --git a/functions_h.html b/functions_h.html index df194c15e..7e1ba5d89 100644 --- a/functions_h.html +++ b/functions_h.html @@ -123,9 +123,15 @@ $(document).ready(function(){initNavTree('functions_h.html',''); initResizable()
  • heap_size : MinHeap
    • +
  • HKGraph() +: graph::HKGraph +
  • HLD() : range_queries::heavy_light_decomposition::HLD< X >
    • +
  • hopcroftKarpAlgorithm() +: graph::HKGraph +
    • diff --git a/functions_m.html b/functions_m.html index 4af1ad352..aa94641ab 100644 --- a/functions_m.html +++ b/functions_m.html @@ -93,6 +93,9 @@ $(document).ready(function(){initNavTree('functions_m.html',''); initResizable()
    Here is a list of all documented class members with links to the class documentation for each member:

    - m -