graph Namespace Reference

Graph Algorithms. More...

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

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.

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));
}

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);
}

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;
}

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);
        }
    }
}

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);
        }
    }
}

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: