graph Namespace Reference

Graph Algorithms. More...

## Classes

class | Graph
class | HKGraph
| Represents Bipartite graph for Hopcroft Karp implementation. More...
class | RootedTree
class | LowestCommonAncestor

## Functions

void | addEdge (std::vector< std::vector< int >> *adj, int u, int v)
| Function that add edge between two nodes or vertices of graph. More...
void | explore (const std::vector< std::vector< int >> *adj, int u, std::vector< bool > *visited)
| Utility function for depth first seach algorithm this function explores the vertex which is passed into. More...
int | getConnectedComponents (const std::vector< std::vector< int >> *adj)
| Function that perfoms depth first search algorithm on graph and calculated the number of connected components. More...
void | addEdge (std::vector< std::vector< size_t >> *adj, size_t u, size_t v)
| Adds and edge between two vertices of graph say u and v in this case. More...
void | explore (const std::vector< std::vector< size_t >> &adj, size_t v, std::vector< bool > *visited)
| Explores the given vertex, exploring a vertex means traversing over all the vertices which are connected to the vertex that is currently being explored. More...
void | depth_first_search (const std::vector< std::vector< size_t >> &adj, size_t start)
| initiates depth first search algorithm. More...
void | addEdge (std::vector< std::vector< std::pair< int, int >>> *adj, int u, int v, int w)
| Function that add edge between two nodes or vertices of graph. More...
int | dijkstra (std::vector< std::vector< std::pair< int, int >>> *adj, int s, int t)
| Function runs the dijkstra algorithm for some source vertex and target vertex in the graph and returns the shortest distance of target from the source. More...

## Detailed Description

Graph Algorithms.

for std::vector

Graph algorithms.

for IO operations for std::set

Graph Algorithms

## Function Documentation

## addEdge() [1/3]

void graph::addEdge | ( | std::vector< std::vector< int >> * | adj,
|  | int | u,
|  | int | v
| ) |  |

Function that add edge between two nodes or vertices of graph.

Parameters

  adj | adjacency list of graph.
  u | any node or vertex of graph.
  v | any node or vertex of graph.

{
(*adj)[u - 1].push_back(v - 1);
(*adj)[v - 1].push_back(u - 1);
}

## addEdge() [2/3]

void graph::addEdge | ( | std::vector< std::vector< size_t >> * | adj,
|  | size_t | u,
|  | size_t | v
| ) |  |

Adds and edge between two vertices of graph say u and v in this case.

Parameters

  adj | Adjacency list representation of graph
  u | first vertex
  v | second vertex

{
/*
*
* Here we are considering undirected graph that's the
* reason we are adding v to the adjacency list representation of u
* and also adding u to the adjacency list representation of v
*
*/
(*adj)[u - 1].push_back(v - 1);
(*adj)[v - 1].push_back(u - 1);
}

## addEdge() [3/3]

void graph::addEdge | ( | std::vector< std::vector< std::pair< int, int >>> * | adj,
|  | int | u,
|  | int | v,
|  | int | w
| ) |  |

Function that add edge between two nodes or vertices of graph.

Parameters

  u | any node or vertex of graph
  v | any node or vertex of graph

{
(*adj)[u - 1].push_back(std::make_pair(v - 1, w));
// (*adj)[v - 1].push_back(std::make_pair(u - 1, w));
}
std::make_pair
T make_pair(T... args)
Here is the call graph for this function:

## depth_first_search()

void graph::depth_first_search | ( | const std::vector< std::vector< size_t >> & | adj,
|  | size_t | start
| ) |  |

initiates depth first search algorithm.

Parameters

  adj | adjacency list of graph
  start | vertex from where DFS starts traversing.

{
size_t vertices = adj.size();
std::vector<bool> visited(vertices, false);
explore(adj, start, &visited);
}
graph::explore
void explore(const std::vector< std::vector< size_t >> &adj, size_t v, std::vector< bool > *visited)
Explores the given vertex, exploring a vertex means traversing over all the vertices which are connec...
Definition: depth_first_search.cpp:80
std::vector::size
T size(T... args)
std::vector< bool >
Here is the call graph for this function:

## dijkstra()

int graph::dijkstra | ( | std::vector< std::vector< std::pair< int, int >>> * | adj,
|  | int | s,
|  | int | t
| ) |  |

Function runs the dijkstra algorithm for some source vertex and target vertex in the graph and returns the shortest distance of target from the source.

Parameters

  adj | input graph
  s | source vertex
  t | target vertex

Returns
  shortest distance if target is reachable from source else -1 in case if target is not reachable from source.

n denotes the number of vertices in graph

setting all the distances initially to INF

creating a min heap using priority queue first element of pair contains the distance second element of pair contains the vertex

pushing the source vertex 's' with 0 distance in min heap

marking the distance of source as 0

second element of pair denotes the node / vertex

first element of pair denotes the distance

for all the reachable vertex from the currently exploring vertex we will try to minimize the distance

minimizing distances

{
/// n denotes the number of vertices in graph
int n = adj->size();
/// setting all the distances initially to INF
std::vector<int64_t> dist(n, INF);
/// creating a min heap using priority queue
/// first element of pair contains the distance
/// second element of pair contains the vertex
std::priority_queue<std::pair<int, int>, std::vector<std::pair<int, int>>,
std::greater<std::pair<int, int>>>
pq;
/// pushing the source vertex 's' with 0 distance in min heap
pq.push(std::make_pair(0, s));
/// marking the distance of source as 0
dist[s] = 0;
while (!pq.empty()) {
/// second element of pair denotes the node / vertex
int currentNode = pq.top().second;
/// first element of pair denotes the distance
int currentDist = pq.top().first;
pq.pop();
/// for all the reachable vertex from the currently exploring vertex
/// we will try to minimize the distance
for (std::pair<int, int> edge : (*adj)[currentNode]) {
/// minimizing distances
if (currentDist + edge.second < dist[edge.first]) {
dist[edge.first] = currentDist + edge.second;
pq.push(std::make_pair(dist[edge.first], edge.first));
}
}
}
if (dist[t] != INF) {
return dist[t];
}
return -1;
}
std::priority_queue::empty
T empty(T... args)
std::greater
std::pair
std::priority_queue::pop
T pop(T... args)
std::priority_queue
std::priority_queue::push
T push(T... args)
std::priority_queue::top
T top(T... args)
Here is the call graph for this function:

## explore() [1/2]

void graph::explore | ( | const std::vector< std::vector< int >> * | adj,
|  | int | u,
|  | std::vector< bool > * | visited
| ) |  |

Utility function for depth first seach algorithm this function explores the vertex which is passed into.

Parameters

  adj | adjacency list of graph.
  u | vertex or node to be explored.
  visited | already visited vertices.

{
(*visited)[u] = true;
for (auto v : (*adj)[u]) {
if (!(*visited)[v]) {
explore(adj, v, visited);
}
}
}
graph::explore
void explore(const std::vector< std::vector< int >> *adj, int u, std::vector< bool > *visited)
Utility function for depth first seach algorithm this function explores the vertex which is passed in...
Definition: connected_components.cpp:59

## explore() [2/2]

void graph::explore | ( | const std::vector< std::vector< size_t >> & | adj,
|  | size_t | v,
|  | std::vector< bool > * | visited
| ) |  |

Explores the given vertex, exploring a vertex means traversing over all the vertices which are connected to the vertex that is currently being explored.

Parameters

  adj | garph
  v | vertex to be explored
  visited | already visited vertices

{
std::cout << v + 1 << " ";
(*visited)[v] = true;
for (auto x : adj[v]) {
if (!(*visited)[x]) {
explore(adj, x, visited);
}
}
}
std::cout
Here is the call graph for this function:

## getConnectedComponents()

int graph::getConnectedComponents | ( | const std::vector< std::vector< int >> * | adj | ) |

Function that perfoms depth first search algorithm on graph and calculated the number of connected components.

Parameters

  adj | adjacency list of graph.

Returns
  connected_components number of connected components in graph.

{
int n = adj->size();
int connected_components = 0;
std::vector<bool> visited(n, false);
for (int i = 0; i < n; i++) {
if (!visited[i]) {
explore(adj, i, &visited);
connected_components++;
}
}
return connected_components;
}
Here is the call graph for this function: