diff --git a/d2/d32/number__of__paths_8cpp.html b/d2/d32/number__of__paths_8cpp.html new file mode 100644 index 000000000..68bff0f83 --- /dev/null +++ b/d2/d32/number__of__paths_8cpp.html @@ -0,0 +1,291 @@ + + + + + + + + +TheAlgorithms/C++: graph/number_of_paths.cpp File Reference + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
TheAlgorithms/C++ 1.0.0 +
+
All the algorithms implemented in C++
+
+
+ + + + + + + + +
+
+ +
+
+
+ +
+
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
number_of_paths.cpp File Reference
+
+
+ +

Algorithm to count paths between two nodes in a directed graph using DFS. +More...

+
#include <vector>
+#include <iostream>
+#include <cassert>
+#include <cstdint>
+
+Include dependency graph for number_of_paths.cpp:
+
+
+
+
+

Go to the source code of this file.

+ + + + +

+Namespaces

namespace  graph
 Graph Algorithms.
+ + + + + + + + + +

+Functions

std::uint32_t graph::count_paths_dfs (const std::vector< std::vector< std::uint32_t > > &A, std::uint32_t u, std::uint32_t v, std::uint32_t n, std::vector< bool > &visited)
 Helper function to perform DFS and count the number of paths from node u to node v
std::uint32_t graph::count_paths (const std::vector< std::vector< std::uint32_t > > &A, std::uint32_t u, std::uint32_t v, std::uint32_t n)
 Counts the number of paths from node u to node v in a directed graph using Depth First Search (DFS)
static void test ()
 Self-test implementations.
int main ()
 Main function.
+

Detailed Description

+

Algorithm to count paths between two nodes in a directed graph using DFS.

+

This algorithm implements Depth First Search (DFS) to count the number of possible paths between two nodes in a directed graph. It is represented using an adjacency matrix. The algorithm recursively traverses the graph to find all paths from the source node u to the destination node v.

+
Author
Aditya Borate
+
See also
https://en.wikipedia.org/wiki/Path_(graph_theory)
+ +

Definition in file number_of_paths.cpp.

+

Function Documentation

+ +

◆ main()

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

Main function.

+
Returns
0 on exit
+ +

Definition at line 148 of file number_of_paths.cpp.

+
148 {
+
149 test(); // Run self-test implementations
+
150 return 0;
+
151}
+
test
static void test()
Self-test implementations.
Definition number_of_paths.cpp:86
+
+
+
+ +

◆ test()

+ +
+
+ + + + + +
+ + + + + + + +
void test ()
+ 		+static
+
+ +

Self-test implementations.

+
Returns
void
+ +

Definition at line 86 of file number_of_paths.cpp.

+
86 {
+
87 // Test case 1: Simple directed graph with multiple paths
+
88 std::vector<std::vector<std::uint32_t>> graph1 = {
+
89 {0, 1, 0, 1, 0},
+
90 {0, 0, 1, 0, 1},
+
91 {0, 0, 0, 0, 1},
+
92 {0, 0, 1, 0, 0},
+
93 {0, 0, 0, 0, 0}
+
94 };
+
95 std::uint32_t n1 = 5, u1 = 0, v1 = 4;
+
96 assert(graph::count_paths(graph1, u1, v1, n1) == 3); // There are 3 paths from node 0 to 4
+
97
+
98 // Test case 2: No possible path (disconnected graph)
+
99 std::vector<std::vector<std::uint32_t>> graph2 = {
+
100 {0, 1, 0, 0, 0},
+
101 {0, 0, 0, 0, 0},
+
102 {0, 0, 0, 0, 1},
+
103 {0, 0, 1, 0, 0},
+
104 {0, 0, 0, 0, 0}
+
105 };
+
106 std::uint32_t n2 = 5, u2 = 0, v2 = 4;
+
107 assert(graph::count_paths(graph2, u2, v2, n2) == 0); // No path from node 0 to 4
+
108
+
109 // Test case 3: Cyclic graph with multiple paths
+
110 std::vector<std::vector<std::uint32_t>> graph3 = {
+
111 {0, 1, 0, 0, 0},
+
112 {0, 0, 1, 1, 0},
+
113 {1, 0, 0, 0, 1},
+
114 {0, 0, 1, 0, 1},
+
115 {0, 0, 0, 0, 0}
+
116 };
+
117 std::uint32_t n3 = 5, u3 = 0, v3 = 4;
+
118 assert(graph::count_paths(graph3, u3, v3, n3) == 3); // There are 3 paths from node 0 to 4
+
119
+
120 // Test case 4: Single node graph (self-loop)
+
121 std::vector<std::vector<std::uint32_t>> graph4 = {
+
122 {0}
+
123 };
+
124 std::uint32_t n4 = 1, u4 = 0, v4 = 0;
+
125 assert(graph::count_paths(graph4, u4, v4, n4) == 1); // There is self-loop, so 1 path from node 0 to 0
+
126
+
127 // Test case 5: Empty graph (no nodes, no paths)
+
128 std::vector<std::vector<std::uint32_t>> graph5 = {{}};
+
129 int n5 = 0, u5 = 0, v5 = 0;
+
130 assert(graph::count_paths(graph5, u5, v5, n5) == 0); // There are no paths in an empty graph
+
131
+
132 // Test case 6: Invalid nodes (out of bounds)
+
133 std::vector<std::vector<std::uint32_t>> graph6 = {
+
134 {0, 1, 0},
+
135 {0, 0, 1},
+
136 {0, 0, 0}
+
137 };
+
138 int n6 = 3, u6 = 0, v6 = 5; // Node `v` is out of bounds (n = 3, so valid indices are 0, 1, 2)
+
139 assert(graph::count_paths(graph6, u6, v6, n6) == 0); // Should return 0 because `v = 5` is invalid
+
140
+
141 std::cout << "All tests have successfully passed!\n";
+
142}
+
graph::count_paths
std::uint32_t count_paths(const std::vector< std::vector< std::uint32_t > > &A, std::uint32_t u, std::uint32_t v, std::uint32_t n)
Counts the number of paths from node u to node v in a directed graph using Depth First Search (DFS)
Definition number_of_paths.cpp:67
+
+
+
+
+
+
+
+
+
+
+
+
+
+ + + + diff --git a/d2/d32/number__of__paths_8cpp.js b/d2/d32/number__of__paths_8cpp.js new file mode 100644 index 000000000..e8e86862b --- /dev/null +++ b/d2/d32/number__of__paths_8cpp.js @@ -0,0 +1,7 @@ +var number__of__paths_8cpp = +[ + [ "graph::count_paths", "df/dce/namespacegraph.html#a7c3adb1551bc527a7aa93f331b1c0987", null ], + [ "graph::count_paths_dfs", "df/dce/namespacegraph.html#af99fccdd19e8f223e8749561589a762b", null ], + [ "main", "d2/d32/number__of__paths_8cpp.html#ae66f6b31b5ad750f1fe042a706a4e3d4", null ], + [ "test", "d2/d32/number__of__paths_8cpp.html#aa8dca7b867074164d5f45b0f3851269d", null ] +]; \ No newline at end of file diff --git a/d2/d32/number__of__paths_8cpp_source.html b/d2/d32/number__of__paths_8cpp_source.html new file mode 100644 index 000000000..87a8f6c94 --- /dev/null +++ b/d2/d32/number__of__paths_8cpp_source.html @@ -0,0 +1,252 @@ + + + + + + + + +TheAlgorithms/C++: graph/number_of_paths.cpp Source File + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
TheAlgorithms/C++ 1.0.0 +
+
All the algorithms implemented in C++
+
+
+ + + + + + + + +
+
+ +
+
+
+ +
+
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
number_of_paths.cpp
+
+
+Go to the documentation of this file.
1
+
13
+
14#include <vector>
+
15#include <iostream>
+
16#include <cassert>
+
17#include <cstdint>
+
18
+
23namespace graph {
+
24
+
+
34 std::uint32_t count_paths_dfs(const std::vector<std::vector<std::uint32_t>>& A,
+
35 std::uint32_t u,
+
36 std::uint32_t v,
+
37 std::uint32_t n,
+
38 std::vector<bool>& visited) {
+
39 if (u == v) {
+
40 return 1; // Base case: Reached the destination node
+
41 }
+
42
+
43 visited[u] = true; // Mark the current node as visited
+
44 std::uint32_t path_count = 0; // Count of all paths from `u` to `v`
+
45
+
46 for (std::uint32_t i = 0; i < n; i++) {
+
47 if (A[u][i] == 1 && !visited[i]) { // Check if there is an edge and the node is not visited
+
48 path_count += count_paths_dfs(A, i, v, n, visited); // Recursively explore paths from `i` to `v`
+
49 }
+
50 }
+
51
+
52 visited[u] = false; // Unmark the current node as visited (backtracking)
+
53 return path_count;
+
54 }
+
+
55
+
56
+
+
67 std::uint32_t count_paths(const std::vector<std::vector<std::uint32_t>>& A,
+
68 std::uint32_t u,
+
69 std::uint32_t v,
+
70 std::uint32_t n) {
+
71 // Check for invalid nodes or empty graph
+
72 if (u >= n || v >= n || A.empty() || A[0].empty()) {
+
73 return 0; // No valid paths if graph is empty or nodes are out of bounds
+
74 }
+
75
+
76 std::vector<bool> visited(n, false); // Initialize a visited vector for tracking nodes
+
77 return count_paths_dfs(A, u, v, n, visited); // Start DFS
+
78 }
+
+
79
+
80} // namespace graph
+
81
+
+
86static void test() {
+
87 // Test case 1: Simple directed graph with multiple paths
+
88 std::vector<std::vector<std::uint32_t>> graph1 = {
+
89 {0, 1, 0, 1, 0},
+
90 {0, 0, 1, 0, 1},
+
91 {0, 0, 0, 0, 1},
+
92 {0, 0, 1, 0, 0},
+
93 {0, 0, 0, 0, 0}
+
94 };
+
95 std::uint32_t n1 = 5, u1 = 0, v1 = 4;
+
96 assert(graph::count_paths(graph1, u1, v1, n1) == 3); // There are 3 paths from node 0 to 4
+
97
+
98 // Test case 2: No possible path (disconnected graph)
+
99 std::vector<std::vector<std::uint32_t>> graph2 = {
+
100 {0, 1, 0, 0, 0},
+
101 {0, 0, 0, 0, 0},
+
102 {0, 0, 0, 0, 1},
+
103 {0, 0, 1, 0, 0},
+
104 {0, 0, 0, 0, 0}
+
105 };
+
106 std::uint32_t n2 = 5, u2 = 0, v2 = 4;
+
107 assert(graph::count_paths(graph2, u2, v2, n2) == 0); // No path from node 0 to 4
+
108
+
109 // Test case 3: Cyclic graph with multiple paths
+
110 std::vector<std::vector<std::uint32_t>> graph3 = {
+
111 {0, 1, 0, 0, 0},
+
112 {0, 0, 1, 1, 0},
+
113 {1, 0, 0, 0, 1},
+
114 {0, 0, 1, 0, 1},
+
115 {0, 0, 0, 0, 0}
+
116 };
+
117 std::uint32_t n3 = 5, u3 = 0, v3 = 4;
+
118 assert(graph::count_paths(graph3, u3, v3, n3) == 3); // There are 3 paths from node 0 to 4
+
119
+
120 // Test case 4: Single node graph (self-loop)
+
121 std::vector<std::vector<std::uint32_t>> graph4 = {
+
122 {0}
+
123 };
+
124 std::uint32_t n4 = 1, u4 = 0, v4 = 0;
+
125 assert(graph::count_paths(graph4, u4, v4, n4) == 1); // There is self-loop, so 1 path from node 0 to 0
+
126
+
127 // Test case 5: Empty graph (no nodes, no paths)
+
128 std::vector<std::vector<std::uint32_t>> graph5 = {{}};
+
129 int n5 = 0, u5 = 0, v5 = 0;
+
130 assert(graph::count_paths(graph5, u5, v5, n5) == 0); // There are no paths in an empty graph
+
131
+
132 // Test case 6: Invalid nodes (out of bounds)
+
133 std::vector<std::vector<std::uint32_t>> graph6 = {
+
134 {0, 1, 0},
+
135 {0, 0, 1},
+
136 {0, 0, 0}
+
137 };
+
138 int n6 = 3, u6 = 0, v6 = 5; // Node `v` is out of bounds (n = 3, so valid indices are 0, 1, 2)
+
139 assert(graph::count_paths(graph6, u6, v6, n6) == 0); // Should return 0 because `v = 5` is invalid
+
140
+
141 std::cout << "All tests have successfully passed!\n";
+
142}
+
+
143
+
+
148int main() {
+
149 test(); // Run self-test implementations
+
150 return 0;
+
151}
+
+
graph
Graph Algorithms.
+
graph::count_paths
std::uint32_t count_paths(const std::vector< std::vector< std::uint32_t > > &A, std::uint32_t u, std::uint32_t v, std::uint32_t n)
Counts the number of paths from node u to node v in a directed graph using Depth First Search (DFS)
Definition number_of_paths.cpp:67
+
graph::count_paths_dfs
std::uint32_t count_paths_dfs(const std::vector< std::vector< std::uint32_t > > &A, std::uint32_t u, std::uint32_t v, std::uint32_t n, std::vector< bool > &visited)
Helper function to perform DFS and count the number of paths from node u to node v
Definition number_of_paths.cpp:34
+
test
static void test()
Self-test implementations.
Definition number_of_paths.cpp:86
+
main
int main()
Main function.
Definition number_of_paths.cpp:148
+
+
+
+ + + + diff --git a/df/d20/number__of__paths_8cpp__incl.map b/df/d20/number__of__paths_8cpp__incl.map new file mode 100644 index 000000000..15a2bada3 --- /dev/null +++ b/df/d20/number__of__paths_8cpp__incl.map @@ -0,0 +1,11 @@ + + + + + + + + + + + diff --git a/df/d20/number__of__paths_8cpp__incl.md5 b/df/d20/number__of__paths_8cpp__incl.md5 new file mode 100644 index 000000000..3383d71dc --- /dev/null +++ b/df/d20/number__of__paths_8cpp__incl.md5 @@ -0,0 +1 @@ +249df2cc955071ab2823b7bd52f29a09 \ No newline at end of file diff --git a/df/d20/number__of__paths_8cpp__incl.svg b/df/d20/number__of__paths_8cpp__incl.svg new file mode 100644 index 000000000..5793228c3 --- /dev/null +++ b/df/d20/number__of__paths_8cpp__incl.svg @@ -0,0 +1,119 @@ + + + + + + + + + + + + +graph/number_of_paths.cpp + + +Node1 + + +graph/number_of_paths.cpp + + + + + +Node2 + + +vector + + + + + +Node1->Node2 + + + + + + + + +Node3 + + +iostream + + + + + +Node1->Node3 + + + + + + + + +Node4 + + +cassert + + + + + +Node1->Node4 + + + + + + + + +Node5 + + +cstdint + + + + + +Node1->Node5 + + + + + + + + + + + + + diff --git a/df/d20/number__of__paths_8cpp__incl_org.svg b/df/d20/number__of__paths_8cpp__incl_org.svg new file mode 100644 index 000000000..0fc814b46 --- /dev/null +++ b/df/d20/number__of__paths_8cpp__incl_org.svg @@ -0,0 +1,93 @@ + + + + + + +graph/number_of_paths.cpp + + +Node1 + + +graph/number_of_paths.cpp + + + + + +Node2 + + +vector + + + + + +Node1->Node2 + + + + + + + + +Node3 + + +iostream + + + + + +Node1->Node3 + + + + + + + + +Node4 + + +cassert + + + + + +Node1->Node4 + + + + + + + + +Node5 + + +cstdint + + + + + +Node1->Node5 + + + + + + + + diff --git a/df/dce/namespacegraph.html b/df/dce/namespacegraph.html index e7cecd482..91cfdff72 100644 --- a/df/dce/namespacegraph.html +++ b/df/dce/namespacegraph.html @@ -150,6 +150,10 @@ Functions  function to check whether the passed graph is bipartite or not
bool isBipartite (const std::vector< std::vector< int64_t > > &graph)  returns true if the given graph is bipartite else returns false
+std::uint32_t count_paths_dfs (const std::vector< std::vector< std::uint32_t > > &A, std::uint32_t u, std::uint32_t v, std::uint32_t n, std::vector< bool > &visited) + Helper function to perform DFS and count the number of paths from node u to node v
+std::uint32_t count_paths (const std::vector< std::vector< std::uint32_t > > &A, std::uint32_t u, std::uint32_t v, std::uint32_t n) + Counts the number of paths from node u to node v in a directed graph using Depth First Search (DFS)
int TravellingSalesmanProblem (std::vector< std::vector< uint32_t > > *cities, int32_t src, uint32_t V)  Function calculates the minimum path distance that will cover all the cities starting from the source.
@@ -164,6 +168,7 @@ Functions

A bipartite graph is the one whose nodes can be divided into two disjoint sets in such a way that the nodes in a set are not connected to each other at all, i.e. no intra-set connections. The only connections that exist are that of inter-set, i.e. the nodes from one set are connected to a subset of nodes in the other set. In this implementation, using a graph in the form of adjacency list, check whether the given graph is a bipartite or not.

References used: GeeksForGeeks

Author
tushar2407 for assert for IO operations for queue data structure for vector data structure

Graphical algorithms

+

for std::vector for IO operations for assert for fixed-size integer types (e.g., std::uint32_t)

for std::min for IO operations for limits of integral types for std::vector

Graph Algorithms

Function Documentation

@@ -379,6 +384,129 @@ Functions + +

◆ count_paths()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + +
std::uint32_t graph::count_paths (const std::vector< std::vector< std::uint32_t > > & A,
std::uint32_t u,
std::uint32_t v,
std::uint32_t n )
+
+ +

Counts the number of paths from node u to node v in a directed graph using Depth First Search (DFS)

+
Parameters
+ + + + + +
Aadjacency matrix representing the graph (1: edge exists, 0: no edge)
uthe starting node
vthe destination node
nthe number of nodes in the graph
+
+
+
Returns
the number of paths from node u to node v
+ +

Definition at line 67 of file number_of_paths.cpp.

+
70 {
+
71 // Check for invalid nodes or empty graph
+
72 if (u >= n || v >= n || A.empty() || A[0].empty()) {
+
73 return 0; // No valid paths if graph is empty or nodes are out of bounds
+
74 }
+
75
+
76 std::vector<bool> visited(n, false); // Initialize a visited vector for tracking nodes
+
77 return count_paths_dfs(A, u, v, n, visited); // Start DFS
+
78 }
+
graph::count_paths_dfs
std::uint32_t count_paths_dfs(const std::vector< std::vector< std::uint32_t > > &A, std::uint32_t u, std::uint32_t v, std::uint32_t n, std::vector< bool > &visited)
Helper function to perform DFS and count the number of paths from node u to node v
Definition number_of_paths.cpp:34
+
+
+
+ +

◆ count_paths_dfs()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + +
std::uint32_t graph::count_paths_dfs (const std::vector< std::vector< std::uint32_t > > & A,
std::uint32_t u,
std::uint32_t v,
std::uint32_t n,
std::vector< bool > & visited )
+
+ +

Helper function to perform DFS and count the number of paths from node u to node v

+
Parameters
+ + + + + + +
Aadjacency matrix representing the graph (1: edge exists, 0: no edge)
uthe starting node
vthe destination node
nthe number of nodes in the graph
visiteda vector to keep track of visited nodes in the current DFS path
+
+
+
Returns
the number of paths from node u to node v
+ +

Definition at line 34 of file number_of_paths.cpp.

+
38 {
+
39 if (u == v) {
+
40 return 1; // Base case: Reached the destination node
+
41 }
+
42
+
43 visited[u] = true; // Mark the current node as visited
+
44 std::uint32_t path_count = 0; // Count of all paths from `u` to `v`
+
45
+
46 for (std::uint32_t i = 0; i < n; i++) {
+
47 if (A[u][i] == 1 && !visited[i]) { // Check if there is an edge and the node is not visited
+
48 path_count += count_paths_dfs(A, i, v, n, visited); // Recursively explore paths from `i` to `v`
+
49 }
+
50 }
+
51
+
52 visited[u] = false; // Unmark the current node as visited (backtracking)
+
53 return path_count;
+
54 }
+
+
+

◆ depth_first_search()

diff --git a/df/dce/namespacegraph.js b/df/dce/namespacegraph.js index ef65fe97c..521944788 100644 --- a/df/dce/namespacegraph.js +++ b/df/dce/namespacegraph.js @@ -8,6 +8,8 @@ var namespacegraph = [ "addEdge", "df/dce/namespacegraph.html#ad4016cfc80485a43748895a2c26c7d08", null ], [ "addEdge", "df/dce/namespacegraph.html#a0e30e0dca68cb6e4f671440819b35b6a", null ], [ "checkBipartite", "df/dce/namespacegraph.html#a8e1b547cd407c0774e63f0dc95cda9e7", null ], + [ "count_paths", "df/dce/namespacegraph.html#a7c3adb1551bc527a7aa93f331b1c0987", null ], + [ "count_paths_dfs", "df/dce/namespacegraph.html#af99fccdd19e8f223e8749561589a762b", null ], [ "depth_first_search", "df/dce/namespacegraph.html#ab5428a3519267a28bba4b4310cfbb6ae", null ], [ "dijkstra", "df/dce/namespacegraph.html#adc68cbc8ba09eb1142265935c0d45b84", null ], [ "explore", "df/dce/namespacegraph.html#a3ae80bc4c6a79d041b4f3a6589eb7fb8", null ], diff --git a/dir_12552d7fa429bf94a2e32e5cf39f7e69.html b/dir_12552d7fa429bf94a2e32e5cf39f7e69.html index e9fe2d813..b2a4b916b 100644 --- a/dir_12552d7fa429bf94a2e32e5cf39f7e69.html +++ b/dir_12552d7fa429bf94a2e32e5cf39f7e69.html @@ -147,6 +147,8 @@ Files
 lowest_common_ancestor.cpp  Data structure for finding the lowest common ancestor of two vertices in a rooted tree using binary lifting.
 max_flow_with_ford_fulkerson_and_edmond_karp_algo.cpp +
 number_of_paths.cpp + Algorithm to count paths between two nodes in a directed graph using DFS.
 prim.cpp
 topological_sort.cpp  Topological Sort Algorithm
diff --git a/dir_12552d7fa429bf94a2e32e5cf39f7e69.js b/dir_12552d7fa429bf94a2e32e5cf39f7e69.js index 16000e270..a49a454c4 100644 --- a/dir_12552d7fa429bf94a2e32e5cf39f7e69.js +++ b/dir_12552d7fa429bf94a2e32e5cf39f7e69.js @@ -17,6 +17,7 @@ var dir_12552d7fa429bf94a2e32e5cf39f7e69 = [ "kruskal.cpp", "d9/d1c/kruskal_8cpp_source.html", null ], [ "lowest_common_ancestor.cpp", "de/dde/lowest__common__ancestor_8cpp.html", "de/dde/lowest__common__ancestor_8cpp" ], [ "max_flow_with_ford_fulkerson_and_edmond_karp_algo.cpp", "d2/d48/max__flow__with__ford__fulkerson__and__edmond__karp__algo_8cpp_source.html", null ], + [ "number_of_paths.cpp", "d2/d32/number__of__paths_8cpp.html", "d2/d32/number__of__paths_8cpp" ], [ "prim.cpp", "da/d27/prim_8cpp_source.html", null ], [ "topological_sort.cpp", "d8/db9/topological__sort_8cpp.html", "d8/db9/topological__sort_8cpp" ], [ "topological_sort_by_kahns_algo.cpp", "d1/d1b/topological__sort__by__kahns__algo_8cpp_source.html", null ], diff --git a/doxygen_crawl.html b/doxygen_crawl.html index 152a1c21b..f45453e36 100644 --- a/doxygen_crawl.html +++ b/doxygen_crawl.html @@ -423,6 +423,10 @@ + + + + @@ -3274,6 +3278,7 @@ + @@ -3282,6 +3287,7 @@ + diff --git a/files.html b/files.html index e7969ecd2..b2ba53aa6 100644 --- a/files.html +++ b/files.html @@ -264,10 +264,11 @@ solve-a-rat-in-a-maze-c-java-pytho/" target="_blank">Rat in a Maze algorithm  
kruskal.cpp  
lowest_common_ancestor.cppData structure for finding the lowest common ancestor of two vertices in a rooted tree using binary lifting  
max_flow_with_ford_fulkerson_and_edmond_karp_algo.cpp - 
prim.cpp - 
topological_sort.cppTopological Sort Algorithm - 
topological_sort_by_kahns_algo.cpp - 
travelling_salesman_problem.cpp[Travelling Salesman Problem] (https://en.wikipedia.org/wiki/Travelling_salesman_problem) implementation + 
number_of_paths.cppAlgorithm to count paths between two nodes in a directed graph using DFS + 
prim.cpp + 
topological_sort.cppTopological Sort Algorithm + 
topological_sort_by_kahns_algo.cpp + 
travelling_salesman_problem.cpp[Travelling Salesman Problem] (https://en.wikipedia.org/wiki/Travelling_salesman_problem) implementation  
graphics  
spirograph.cppImplementation of Spirograph  
greedy_algorithms diff --git a/globals_func_m.html b/globals_func_m.html index 474e816ff..253a2619a 100644 --- a/globals_func_m.html +++ b/globals_func_m.html @@ -116,7 +116,7 @@ $(function(){initNavTree('globals_func_m.html','',''); });
Here is a list of all documented functions with links to the documentation:

- m -