backup/C-Plus-Plus
1
0
Fork 0
mirror of https://github.com/TheAlgorithms/C-Plus-Plus.git synced 2026-04-01 17:52:40 +08:00
Code Issues Projects Releases Wiki Activity

fix: build

Browse Source
This commit is contained in:
Ayaan Khan
2020-07-25 07:55:30 +05:30
parent 0023339182
commit cbb43c90aa
9 changed files with 494 additions and 493 deletions
Download Patch File Download Diff File Expand all files Collapse all files

240
graph/bfs.cpp
View File

@@ -1,62 +1,196 @@
/**
*
* \file
* \brief [Breadth First Search Algorithm
* (Breadth First Search)](https://en.wikipedia.org/wiki/Breadth-first_search)
*
* \author [Ayaan Khan](http://github.com/ayaankhan98)
*
* \details
* Breadth First Search also quoted as BFS is a Graph Traversal Algorithm.
* Time Complexity O(|V| + |E|) where V are the number of vertices and E
* are the number of edges in the graph.
*
* Applications of Breadth First Search are
*
* 1. Finding shortest path between two vertices say u and v, with path
* length measured by number of edges (an advantage over depth first
* search algorithm)
* 2. Ford-Fulkerson Method for computing the maximum flow in a flow network.
* 3. Testing bipartiteness of a graph.
* 4. Cheney's Algorithm, Copying garbage collection.
*
* And there are many more...
*
* <h4>working</h4>
* In the implementation below we first created a graph using the adjacency
* list representation of graph.
* Breadth First Search Works as follows
* it requires a vertex as a start vertex, Start vertex is that vertex
* from where you want to start traversing the graph.
* we maintain a bool array or a vector to keep track of the vertices
* which we have visited so that we do not traverse the visited vertices
* again and again and eventually fall into an infinite loop. Along with this
* boolen array we use a Queue.
*
* 1. First we mark the start vertex as visited.
* 2. Push this visited vertex in the Queue.
* 3. while the queue is not empty we repeat the following steps
*
* 1. Take out an element from the front of queue
* 2. start exploring the adjacency list of this vertex
* if element in the adjacency list is not visited then we
* push that element into the queue and mark this as visited
*
*/
#include <algorithm>
#include <cassert>
#include <iostream>
using namespace std;
class graph {
int v;
list<int> *adj;
#include <queue>
#include <vector>
public:
graph(int v);
void addedge(int src, int dest);
void printgraph();
void bfs(int s);
};
graph::graph(int v) {
this->v = v;
this->adj = new list<int>[v];
/**
* \namespace graph
* \brief Graph algorithms
*/
namespace graph {
/**
* \brief
* Adds and edge between two vertices of graph say u and v in this
* case.
*
* @param adj Adjacency list representation of graph
* @param u first vertex
* @param v second vertex
*
*/
void addEdge(std::vector<std::vector<int>> *adj, int u, int v) {
/**
* Here we are considering directed graph that's the
* reason we are adding v to the adjacency list representation of u
* but not adding u to the adjacency list representation of v
*
* in case of a un-directed graph you can un comment the statement below.
*/
(*adj)[u - 1].push_back(v - 1);
// adj[v - 1].push_back(u -1);
}
void graph::addedge(int src, int dest) {
src--;
dest--;
adj[src].push_back(dest);
// adj[dest].push_back(src);
}
void graph::printgraph() {
for (int i = 0; i < this->v; i++) {
cout << "Adjacency list of vertex " << i + 1 << " is \n";
list<int>::iterator it;
for (it = adj[i].begin(); it != adj[i].end(); ++it) {
cout << *it + 1 << " ";
}
cout << endl;
}
}
void graph::bfs(int s) {
bool *visited = new bool[this->v + 1];
memset(visited, false, sizeof(bool) * (this->v + 1));
visited[s] = true;
list<int> q;
q.push_back(s);
list<int>::iterator it;
while (!q.empty()) {
int u = q.front();
cout << u << " ";
q.pop_front();
for (it = adj[u].begin(); it != adj[u].end(); ++it) {
if (visited[*it] == false) {
visited[*it] = true;
q.push_back(*it);
/**
* \brief
* Function performs the breadth first search algorithm over the graph
*
* @param adj Adjacency list representation of graph
* @param start vertex from where traversing starts
*
*/
std::vector<int> beadth_first_search(const std::vector<std::vector<int>> &adj,
int start) {
size_t vertices = adj.size();
std::vector<int> result;
/// vector to keep track of visited vertices
std::vector<bool> visited(vertices, 0);
std::queue<int> tracker;
/// marking the start vertex as visited
visited[start] = true;
tracker.push(start);
while (!tracker.empty()) {
size_t vertex = tracker.front();
tracker.pop();
result.push_back(vertex + 1);
for (auto x : adj[vertex]) {
/// if the vertex is not visited then mark this as visited
/// and push it to the queue
if (!visited[x]) {
visited[x] = true;
tracker.push(x);
}
}
}
return result;
}
} // namespace graph
void tests() {
std::cout << "Initiating Tests" << std::endl;
/// Test 1 Begin
std::vector<std::vector<int>> graphData(4, std::vector<int>());
graph::addEdge(&graphData, 1, 2);
graph::addEdge(&graphData, 1, 3);
graph::addEdge(&graphData, 2, 3);
graph::addEdge(&graphData, 3, 1);
graph::addEdge(&graphData, 3, 4);
graph::addEdge(&graphData, 4, 4);
std::vector<int> returnedResult = graph::beadth_first_search(graphData, 2);
std::vector<int> correctResult = {3, 1, 4, 2};
assert(std::equal(correctResult.begin(), correctResult.end(),
returnedResult.begin()));
std::cout << "Test 1 Passed..." << std::endl;
/// Test 2 Begin
/// clear data from previous test
returnedResult.clear();
correctResult.clear();
returnedResult = graph::beadth_first_search(graphData, 0);
correctResult = {1, 2, 3, 4};
assert(std::equal(correctResult.begin(), correctResult.end(),
returnedResult.begin()));
std::cout << "Test 2 Passed..." << std::endl;
/// Test 3 Begins
/// clear data from previous test
graphData.clear();
returnedResult.clear();
correctResult.clear();
graphData.resize(6);
graph::addEdge(&graphData, 1, 2);
graph::addEdge(&graphData, 1, 3);
graph::addEdge(&graphData, 2, 4);
graph::addEdge(&graphData, 3, 4);
graph::addEdge(&graphData, 2, 5);
graph::addEdge(&graphData, 4, 6);
returnedResult = graph::beadth_first_search(graphData, 0);
correctResult = {1, 2, 3, 4, 5, 6};
assert(std::equal(correctResult.begin(), correctResult.end(),
returnedResult.begin()));
std::cout << "Test 3 Passed..." << std::endl;
}
/** Main function */
int main() {
graph g(4);
g.addedge(1, 2);
g.addedge(2, 3);
g.addedge(3, 4);
g.addedge(1, 4);
g.addedge(1, 3);
// g.printgraph();
g.bfs(2);
/// running predefined test cases
tests();
size_t vertices, edges;
std::cout << "Enter the number of vertices : ";
std::cin >> vertices;
std::cout << "Enter the number of edges : ";
std::cin >> edges;
/// creating a graph
std::vector<std::vector<int>> adj(vertices, std::vector<int>());
/// taking input for edges
std::cout << "Enter vertices in pair which have edges between them : "
<< std::endl;
while (edges--) {
int u, v;
std::cin >> u >> v;
graph::addEdge(&adj, u, v);
}
/// running Breadth First Search Algorithm on the graph
graph::beadth_first_search(adj, 0);
return 0;
}
}

2
graph/bridge_finding_with_tarjan_algorithm.cpp
View File

@@ -7,9 +7,11 @@
#include <algorithm> // for min & max
#include <iostream> // for cout
#include <vector> // for std::vector
using std::cout;
using std::min;
using std::vector;
class Solution {
vector<vector<int>> graph;
vector<int> in_time, out_time;

345
graph/cycle_check_directed_graph.cpp
View File

@@ -1,302 +1,57 @@
/**
* Copyright 2020
* @file cycle_check_directed graph.cpp
*
* @brief BFS and DFS algorithms to check for cycle in a directed graph.
*
* @author Anmol3299
* contact: mittalanmol22@gmail.com
*
*/
#include <iostream>
#include <vector>
#include <stdlib.h>
using std::vector;
using std::pair;
#include <iostream> // for std::cout
#include <queue> // for std::queue
#include <stdexcept> // for throwing errors
#include <type_traits> // for std::remove_reference_t
#include <unordered_map> // for std::unordered_map
#include <utility> // for std::move
#include <vector> // for std::vector
/**
* Implementation of non-weighted directed edge of a graph.
*
* The source vertex of the edge is labelled "src" and destination vertex is
* labelled "dest".
*/
struct Edge {
unsigned int src;
unsigned int dest;
Edge() = delete;
~Edge() = default;
Edge(Edge&&) = default;
Edge& operator=(Edge&&) = default;
Edge(Edge const&) = default;
Edge& operator=(Edge const&) = default;
/** Set the source and destination of the vertex.
*
* @param source is the source vertex of the edge.
* @param destination is the destination vertex of the edge.
*/
Edge(unsigned int source, unsigned int destination)
: src(source), dest(destination) {}
void explore(int i, vector<vector<int>> &adj, int *state)
{
state[i] = 1;
for(auto it2 : adj[i])
{
if (state[it2] == 0)
{
explore(it2, adj,state);
}
if (state[it2] == 1)
{
std::cout<<"1";
exit(0);
}
}
state[i] = 2;
};
int acyclic(vector<vector<int> > &adj,size_t n) {
//write your code here
using AdjList = std::unordered_map<unsigned int, std::vector<unsigned int>>;
int state[n]; // permitted states are 0 1 and 2
/**
* Implementation of graph class.
*
* The graph will be represented using Adjacency List representation.
* This class contains 2 data members "m_vertices" & "m_adjList" used to
* represent the number of vertices and adjacency list of the graph
* respectively. The vertices are labelled 0 - (m_vertices - 1).
*/
class Graph {
public:
Graph() : m_vertices(0), m_adjList({}) {}
~Graph() = default;
Graph(Graph&&) = default;
Graph& operator=(Graph&&) = default;
Graph(Graph const&) = default;
Graph& operator=(Graph const&) = default;
// mark the states of all vertices initially to 0
for(int i=0;i<n;i++)
state[i] = 0;
/** Create a graph from vertices and adjacency list.
*
* @param vertices specify the number of vertices the graph would contain.
* @param adjList is the adjacency list representation of graph.
*/
Graph(unsigned int vertices, AdjList const& adjList)
: m_vertices(vertices), m_adjList(adjList) {}
/** Create a graph from vertices and adjacency list.
*
* @param vertices specify the number of vertices the graph would contain.
* @param adjList is the adjacency list representation of graph.
*/
Graph(unsigned int vertices, AdjList&& adjList)
: m_vertices(std::move(vertices)), m_adjList(std::move(adjList)) {}
/** Create a graph from vertices and a set of edges.
*
* Adjacency list of the graph would be created from the set of edges. If
* the source or destination of any edge has a value greater or equal to
* number of vertices, then it would throw a range_error.
*
* @param vertices specify the number of vertices the graph would contain.
* @param edges is a vector of edges.
*/
Graph(unsigned int vertices, std::vector<Edge> const& edges)
: m_vertices(vertices) {
for (auto const& edge : edges) {
if (edge.src >= vertices || edge.dest >= vertices) {
throw std::range_error(
"Either src or dest of edge out of range");
}
m_adjList[edge.src].emplace_back(edge.dest);
}
for(auto it1 = 0; it1 != adj.size(); it1++)
{
if (state[it1] == 0)
explore(it1,adj,state);
if (state[it1] == 1)
{
std::cout<<"1";
exit(0);
}
/** Return a const reference of the adjacency list.
*
* @return const reference to the adjacency list
*/
std::remove_reference_t<AdjList> const& getAdjList() const {
return m_adjList;
}
/**
* @return number of vertices in the graph.
*/
std::remove_reference_t<unsigned int> const& getVertices() const {
return m_vertices;
}
/** Add vertices in the graph.
*
* @param num is the number of vertices to be added. It adds 1 vertex by
* default.
*
*/
void addVertices(unsigned int num = 1) { m_vertices += num; }
/** Add an edge in the graph.
*
* @param edge that needs to be added.
*/
void addEdge(Edge const& edge) {
if (edge.src >= m_vertices || edge.dest >= m_vertices) {
throw std::range_error("Either src or dest of edge out of range");
}
m_adjList[edge.src].emplace_back(edge.dest);
}
/** Add an Edge in the graph
*
* @param source is source vertex of the edge.
* @param destination is the destination vertex of the edge.
*/
void addEdge(unsigned int source, unsigned int destination) {
if (source >= m_vertices || destination >= m_vertices) {
throw std::range_error(
"Either source or destination of edge out of range");
}
m_adjList[source].emplace_back(destination);
}
private:
unsigned int m_vertices;
AdjList m_adjList;
};
class CycleCheck {
private:
enum nodeStates : uint8_t { not_visited = 0, in_stack, visited };
/** Helper function of "isCyclicDFS".
*
* @param adjList is the adjacency list representation of some graph.
* @param state is the state of the nodes of the graph.
* @param node is the node being evaluated.
*
* @return true if graph has a cycle, else false.
*/
static bool isCyclicDFSHelper(AdjList const& adjList,
std::vector<nodeStates>* state,
unsigned int node) {
// Add node "in_stack" state.
(*state)[node] = in_stack;
// If the node has children, then recursively visit all children of the
// node.
if (auto const& it = adjList.find(node); it != adjList.end()) {
for (auto child : it->second) {
// If state of child node is "not_visited", evaluate that child
// for presence of cycle.
if (auto state_of_child = (*state)[child];
state_of_child == not_visited) {
if (isCyclicDFSHelper(adjList, state, child)) {
return true;
}
} else if (state_of_child == in_stack) {
// If child node was "in_stack", then that means that there
// is a cycle in the graph. Return true for presence of the
// cycle.
return true;
}
}
}
// Current node has been evaluated for the presence of cycle and had no
// cycle. Mark current node as "visited".
(*state)[node] = visited;
// Return that current node didn't result in any cycles.
return false;
}
public:
/** Driver function to check if a graph has a cycle.
*
* This function uses DFS to check for cycle in the graph.
*
* @param graph which needs to be evaluated for the presence of cycle.
* @return true if a cycle is detected, else false.
*/
static bool isCyclicDFS(Graph const& graph) {
/** State of the node.
*
* It is a vector of "nodeStates" which represents the state node is in.
* It can take only 3 values: "not_visited", "in_stack", and "visited".
*
* Initially, all nodes are in "not_visited" state.
*/
std::vector<nodeStates> state(graph.getVertices(), not_visited);
// Start visiting each node.
for (auto node = 0; node < graph.getVertices(); node++) {
// If a node is not visited, only then check for presence of cycle.
// There is no need to check for presence of cycle for a visited
// node as it has already been checked for presence of cycle.
if (state[node] == not_visited) {
// Check for cycle.
if (isCyclicDFSHelper(graph.getAdjList(), &state, node)) {
return true;
}
}
}
// All nodes have been safely traversed, that means there is no cycle in
// the graph. Return false.
return false;
}
/** Check if a graph has cycle or not.
*
* This function uses BFS to check if a graph is cyclic or not.
*
* @param graph which needs to be evaluated for the presence of cycle.
* @return true if a cycle is detected, else false.
*/
static bool isCyclicBFS(Graph const& graph) {
AdjList graphAjdList = graph.getAdjList();
std::vector<unsigned int> indegree(graph.getVertices(), 0);
// Calculate the indegree i.e. the number of incident edges to the node.
for (auto const& [parent, children] : graphAjdList) {
for (auto const& child : children) {
indegree[child]++;
}
}
std::queue<unsigned int> can_be_solved;
for (auto node = 0; node < graph.getVertices(); node++) {
// If a node doesn't have any input edges, then that node will
// definately not result in a cycle and can be visited safely.
if (!indegree[node]) {
can_be_solved.emplace(node);
}
}
// Vertices that need to be traversed.
auto remain = graph.getVertices();
// While there are safe nodes that we can visit.
while (!can_be_solved.empty()) {
auto front = can_be_solved.front();
// Visit the node.
can_be_solved.pop();
// Decrease number of nodes that need to be traversed.
remain--;
// Visit all the children of the visited node.
if (auto it = graphAjdList.find(front); it != graphAjdList.end()) {
for (auto child : it->second) {
// Check if we can visited the node safely.
if (--indegree[child] == 0) {
// if node can be visited safely, then add that node to
// the visit queue.
can_be_solved.emplace(child);
}
}
}
}
// If there are still nodes that we can't visit, then it means that
// there is a cycle and return true, else return false.
return !(remain == 0);
}
};
/**
* Main function.
*/
int main() {
// Instantiate the graph.
Graph g(7, std::vector<Edge>{{0, 1}, {1, 2}, {2, 0}, {2, 5}, {3, 5}});
// Check for cycle using BFS method.
std::cout << CycleCheck::isCyclicBFS(g) << '\n';
// Check for cycle using DFS method.
std::cout << CycleCheck::isCyclicDFS(g) << '\n';
return 0;
}
std::cout<<"0";
return 0;
}
int main() {
size_t n, m;
std::cin >> n >> m;
vector<vector<int> > adj(n, vector<int>());
for (size_t i = 0; i < m; i++) {
int x, y;
std::cin >> x >> y;
adj[x - 1].push_back(y - 1);
}
acyclic(adj,n);
}

141
graph/dfs.cpp
View File

@@ -1,26 +1,133 @@
/**
*
* \file
* \brief [Depth First Search Algorithm
* (Depth First Search)](https://en.wikipedia.org/wiki/Depth-first_search)
*
* \author [Ayaan Khan](http://github.com/ayaankhan98)
*
* \details
* Depth First Search also quoted as DFS is a Graph Traversal Algorithm.
* Time Complexity O(|V| + |E|) where V is number of vertices and E
* is number of edges in graph.
*
* Application of Depth First Search are
*
* 1. Finding connected components
* 2. Finding 2-(edge or vertex)-connected components.
* 3. Finding 3-(edge or vertex)-connected components.
* 4. Finding the bridges of a graph.
* 5. Generating words in order to plot the limit set of a group.
* 6. Finding strongly connected components.
*
* And there are many more...
*
* <h4>Working</h4>
* 1. Mark all vertices as unvisited first
* 2. start exploring from some starting vertex.
*
* While exploring vertex we mark the vertex as visited
* and start exploring the vertices connected to this
* vertex in recursive way.
*
*/
#include <algorithm>
#include <iostream>
using namespace std;
int v = 4;
void DFSUtil_(int graph[4][4], bool visited[], int s) {
visited[s] = true;
cout << s << " ";
for (int i = 0; i < v; i++) {
if (graph[s][i] == 1 && visited[i] == false) {
DFSUtil_(graph, visited, i);
#include <vector>
/**
*
* \namespace graph
* \brief Graph Algorithms
*
*/
namespace graph {
/**
* \brief
* Adds and edge between two vertices of graph say u and v in this
* case.
*
* @param adj Adjacency list representation of graph
* @param u first vertex
* @param v second vertex
*
*/
void addEdge(std::vector<std::vector<size_t>> *adj, size_t u, size_t v) {
/**
*
* 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);
}
/**
*
* \brief
* Explores the given vertex, exploring a vertex means traversing
* over all the vertices which are connected to the vertex that is
* currently being explored.
*
* @param adj garph
* @param v vertex to be explored
* @param visited already visited vertices
*
*/
void explore(const std::vector<std::vector<size_t>> &adj, size_t v,
std::vector<bool> *visited) {
std::cout << v + 1 << " ";
(*visited)[v] = true;
for (auto x : adj[v]) {
if (!(*visited)[x]) {
explore(adj, x, visited);
}
}
}
void DFS_(int graph[4][4], int s) {
bool visited[v];
memset(visited, 0, sizeof(visited));
DFSUtil_(graph, visited, s);
}
/**
* \brief
* initiates depth first search algorithm.
*
* @param adj adjacency list of graph
* @param start vertex from where DFS starts traversing.
*
*/
void depth_first_search(const std::vector<std::vector<size_t>> &adj,
size_t start) {
size_t vertices = adj.size();
std::vector<bool> visited(vertices, false);
explore(adj, start, &visited);
}
} // namespace graph
/** Main function */
int main() {
int graph[4][4] = {{0, 1, 1, 0}, {0, 0, 1, 0}, {1, 0, 0, 1}, {0, 0, 0, 1}};
cout << "DFS: ";
DFS_(graph, 2);
cout << endl;
size_t vertices, edges;
std::cout << "Enter the Vertices : ";
std::cin >> vertices;
std::cout << "Enter the Edges : ";
std::cin >> edges;
/// creating graph
std::vector<std::vector<size_t>> adj(vertices, std::vector<size_t>());
/// taking input for edges
std::cout << "Enter the vertices which have edges between them : "
<< std::endl;
while (edges--) {
size_t u, v;
std::cin >> u >> v;
graph::addEdge(&adj, u, v);
}
/// running depth first search over graph
graph::depth_first_search(adj, 2);
std::cout << std::endl;
return 0;
}

184
graph/dijkstra.cpp
View File

@@ -39,31 +39,31 @@ constexpr int64_t INF = std::numeric_limits<int64_t>::max();
*/
namespace graph {
/**
* @brief Function that add edge between two nodes or vertices of graph
*
* @param u any node or vertex of graph
* @param v any node or vertex of graph
*/
void addEdge(std::vector<std::vector<std::pair<int, int>>> *adj, int u, int v,
int w) {
/**
* @brief Function that add edge between two nodes or vertices of graph
*
* @param u any node or vertex of graph
* @param v any node or vertex of graph
*/
void addEdge(std::vector<std::vector<std::pair<int, int>>> *adj, int u, int v,
int w) {
(*adj)[u - 1].push_back(std::make_pair(v - 1, w));
// (*adj)[v - 1].push_back(std::make_pair(u - 1, w));
}
}
/**
* @brief 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.
*
* @param adj input graph
* @param s source vertex
* @param t target vertex
*
* @return shortest distance if target is reachable from source else -1 in
* case if target is not reachable from source.
*/
int dijkstra(std::vector<std::vector<std::pair<int, int>>> *adj, int s, int t) {
/**
* @brief 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.
*
* @param adj input graph
* @param s source vertex
* @param t target vertex
*
* @return shortest distance if target is reachable from source else -1 in
* case if target is not reachable from source.
*/
int dijkstra(std::vector<std::vector<std::pair<int, int>>> *adj, int s, int t) {
/// n denotes the number of vertices in graph
int n = adj->size();
@@ -74,7 +74,7 @@ int dijkstra(std::vector<std::vector<std::pair<int, int>>> *adj, int s, int t) {
/// 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::greater<std::pair<int, int>>>
pq;
/// pushing the source vertex 's' with 0 distance in min heap
@@ -84,97 +84,97 @@ int dijkstra(std::vector<std::vector<std::pair<int, int>>> *adj, int s, int t) {
dist[s] = 0;
while (!pq.empty()) {
/// second element of pair denotes the node / vertex
int currentNode = pq.top().second;
/// 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;
/// first element of pair denotes the distance
int currentDist = pq.top().first;
pq.pop();
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));
}
/// 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 dist[t];
}
return -1;
}
}
} // namespace graph
/** Function to test the Algorithm */
void tests() {
std::cout << "Initiatinig Predefined Tests..." << std::endl;
std::cout << "Initiating Test 1..." << std::endl;
std::vector<std::vector<std::pair<int, int>>> adj1(
4, std::vector<std::pair<int, int>>());
graph::addEdge(&adj1, 1, 2, 1);
graph::addEdge(&adj1, 4, 1, 2);
graph::addEdge(&adj1, 2, 3, 2);
graph::addEdge(&adj1, 1, 3, 5);
std::cout << "Initiatinig Predefined Tests..." << std::endl;
std::cout << "Initiating Test 1..." << std::endl;
std::vector<std::vector<std::pair<int, int>>> adj1(
4, std::vector<std::pair<int, int>>());
graph::addEdge(&adj1, 1, 2, 1);
graph::addEdge(&adj1, 4, 1, 2);
graph::addEdge(&adj1, 2, 3, 2);
graph::addEdge(&adj1, 1, 3, 5);
int s = 1, t = 3;
assert(graph::dijkstra(&adj1, s - 1, t - 1) == 3);
std::cout << "Test 1 Passed..." << std::endl;
int s = 1, t = 3;
assert(graph::dijkstra(&adj1, s - 1, t - 1) == 3);
std::cout << "Test 1 Passed..." << std::endl;
s = 4, t = 3;
std::cout << "Initiating Test 2..." << std::endl;
assert(graph::dijkstra(&adj1, s - 1, t - 1) == 5);
std::cout << "Test 2 Passed..." << std::endl;
s = 4, t = 3;
std::cout << "Initiating Test 2..." << std::endl;
assert(graph::dijkstra(&adj1, s - 1, t - 1) == 5);
std::cout << "Test 2 Passed..." << std::endl;
std::vector<std::vector<std::pair<int, int>>> adj2(
5, std::vector<std::pair<int, int>>());
graph::addEdge(&adj2, 1, 2, 4);
graph::addEdge(&adj2, 1, 3, 2);
graph::addEdge(&adj2, 2, 3, 2);
graph::addEdge(&adj2, 3, 2, 1);
graph::addEdge(&adj2, 2, 4, 2);
graph::addEdge(&adj2, 3, 5, 4);
graph::addEdge(&adj2, 5, 4, 1);
graph::addEdge(&adj2, 2, 5, 3);
graph::addEdge(&adj2, 3, 4, 4);
std::vector<std::vector<std::pair<int, int>>> adj2(
5, std::vector<std::pair<int, int>>());
graph::addEdge(&adj2, 1, 2, 4);
graph::addEdge(&adj2, 1, 3, 2);
graph::addEdge(&adj2, 2, 3, 2);
graph::addEdge(&adj2, 3, 2, 1);
graph::addEdge(&adj2, 2, 4, 2);
graph::addEdge(&adj2, 3, 5, 4);
graph::addEdge(&adj2, 5, 4, 1);
graph::addEdge(&adj2, 2, 5, 3);
graph::addEdge(&adj2, 3, 4, 4);
s = 1, t = 5;
std::cout << "Initiating Test 3..." << std::endl;
assert(graph::dijkstra(&adj2, s - 1, t - 1) == 6);
std::cout << "Test 3 Passed..." << std::endl;
std::cout << "All Test Passed..." << std::endl << std::endl;
s = 1, t = 5;
std::cout << "Initiating Test 3..." << std::endl;
assert(graph::dijkstra(&adj2, s - 1, t - 1) == 6);
std::cout << "Test 3 Passed..." << std::endl;
std::cout << "All Test Passed..." << std::endl << std::endl;
}
/** Main function */
int main() {
// running predefined tests
tests();
// running predefined tests
tests();
int vertices = int(), edges = int();
std::cout << "Enter the number of vertices : ";
std::cin >> vertices;
std::cout << "Enter the number of edges : ";
std::cin >> edges;
int vertices = int(), edges = int();
std::cout << "Enter the number of vertices : ";
std::cin >> vertices;
std::cout << "Enter the number of edges : ";
std::cin >> edges;
std::vector<std::vector<std::pair<int, int>>> adj(
vertices, std::vector<std::pair<int, int>>());
std::vector<std::vector<std::pair<int, int>>> adj(
vertices, std::vector<std::pair<int, int>>());
int u = int(), v = int(), w = int();
while (edges--) {
std::cin >> u >> v >> w;
graph::addEdge(&adj, u, v, w);
}
int u = int(), v = int(), w = int();
while (edges--) {
std::cin >> u >> v >> w;
graph::addEdge(&adj, u, v, w);
}
int s = int(), t = int();
std::cin >> s >> t;
int dist = graph::dijkstra(&adj, s - 1, t - 1);
if (dist == -1) {
std::cout << "Target not reachable from source" << std::endl;
} else {
std::cout << "Shortest Path Distance : " << dist << std::endl;
}
return 0;
int s = int(), t = int();
std::cin >> s >> t;
int dist = graph::dijkstra(&adj, s - 1, t - 1);
if (dist == -1) {
std::cout << "Target not reachable from source" << std::endl;
} else {
std::cout << "Shortest Path Distance : " << dist << std::endl;
}
return 0;
}

30
graph/kosaraju.cpp
View File

@@ -4,8 +4,8 @@
#include <iostream>
#include <vector>
#include <stack>
using namespace std;
/**
* Iterative function/method to print graph:
@@ -13,13 +13,13 @@ using namespace std;
* @param V : vertices
* @return void
**/
void print(vector<int> a[], int V) {
void print(std::vector<int> a[], int V) {
for (int i = 0; i < V; i++) {
if (!a[i].empty())
cout << "i=" << i << "-->";
for (int j = 0; j < a[i].size(); j++) cout << a[i][j] << " ";
std::cout << "i=" << i << "-->";
for (int j = 0; j < a[i].size(); j++) std::cout << a[i][j] << " ";
if (!a[i].empty())
cout << endl;
std::cout << std::endl;
}
}
@@ -31,7 +31,7 @@ void print(vector<int> a[], int V) {
* @param adj[] : array of vectors to represent graph
* @return void
**/
void push_vertex(int v, stack<int> &st, bool vis[], vector<int> adj[]) {
void push_vertex(int v, std::stack<int> &st, bool vis[], std::vector<int> adj[]) {
vis[v] = true;
for (auto i = adj[v].begin(); i != adj[v].end(); i++) {
if (vis[*i] == false)
@@ -47,7 +47,7 @@ void push_vertex(int v, stack<int> &st, bool vis[], vector<int> adj[]) {
* @param grev[] : graph with reversed edges
* @return void
**/
void dfs(int v, bool vis[], vector<int> grev[]) {
void dfs(int v, bool vis[], std::vector<int> grev[]) {
vis[v] = true;
// cout<<v<<" ";
for (auto i = grev[v].begin(); i != grev[v].end(); i++) {
@@ -66,15 +66,15 @@ no SCCs i.e. none(0) or there will be x no. of SCCs (x>0)) i.e. it returns the
count of (number of) strongly connected components (SCCs) in the graph.
(variable 'count_scc' within function)
**/
int kosaraju(int V, vector<int> adj[]) {
int kosaraju(int V, std::vector<int> adj[]) {
bool vis[V] = {};
stack<int> st;
std::stack<int> st;
for (int v = 0; v < V; v++) {
if (vis[v] == false)
push_vertex(v, st, vis, adj);
}
// making new graph (grev) with reverse edges as in adj[]:
vector<int> grev[V];
std::vector<int> grev[V];
for (int i = 0; i < V + 1; i++) {
for (auto j = adj[i].begin(); j != adj[i].end(); j++) {
grev[*j].push_back(i);
@@ -102,20 +102,20 @@ int kosaraju(int V, vector<int> adj[]) {
// Input your required values: (not hardcoded)
int main() {
int t;
cin >> t;
std::cin >> t;
while (t--) {
int a, b; // a->number of nodes, b->directed edges.
cin >> a >> b;
std::cin >> a >> b;
int m, n;
vector<int> adj[a + 1];
std::vector<int> adj[a + 1];
for (int i = 0; i < b; i++) // take total b inputs of 2 vertices each
// required to form an edge.
{
cin >> m >> n; // take input m,n denoting edge from m->n.
std::cin >> m >> n; // take input m,n denoting edge from m->n.
adj[m].push_back(n);
}
// pass number of nodes and adjacency array as parameters to function:
cout << kosaraju(a, adj) << endl;
std::cout << kosaraju(a, adj) << std::endl;
}
return 0;
}

2
graph/kruskal.cpp
View File

@@ -1,4 +1,6 @@
#include <iostream>
#include <vector>
#include <algorithm>
//#include <boost/multiprecision/cpp_int.hpp>
// using namespace boost::multiprecision;
const int mx = 1e6 + 5;

22
graph/lca.cpp
View File

@@ -1,7 +1,9 @@
//#include<bits/stdc++.h>
#include <iostream>
using namespace std;
#include <vector>
#include <cmath>
#include <cassert>
#include <cstring>
// Find the lowest common ancestor using binary lifting in O(nlogn)
// Zero based indexing
// Resource : https://cp-algorithms.com/graph/lca_binary_lifting.html
@@ -9,7 +11,7 @@ const int N = 1005;
const int LG = log2(N) + 1;
struct lca {
int n;
vector<int> adj[N]; // Graph
std::vector<int> adj[N]; // Graph
int up[LG][N]; // build this table
int level[N]; // get the levels of all of them
@@ -18,7 +20,7 @@ struct lca {
memset(level, 0, sizeof(level));
for (int i = 0; i < n - 1; ++i) {
int a, b;
cin >> a >> b;
std::cin >> a >> b;
a--;
b--;
adj[a].push_back(b);
@@ -30,15 +32,15 @@ struct lca {
}
void verify() {
for (int i = 0; i < n; ++i) {
cout << i << " : level: " << level[i] << endl;
std::cout << i << " : level: " << level[i] << std::endl;
}
cout << endl;
std::cout << std::endl;
for (int i = 0; i < LG; ++i) {
cout << "Power:" << i << ": ";
std::cout << "Power:" << i << ": ";
for (int j = 0; j < n; ++j) {
cout << up[i][j] << " ";
std::cout << up[i][j] << " ";
}
cout << endl;
std::cout << std::endl;
}
}
@@ -65,7 +67,7 @@ struct lca {
u--;
v--;
if (level[v] > level[u]) {
swap(u, v);
std::swap(u, v);
}
// u is at the bottom.
int dist = level[u] - level[v];

21
graph/topological_sort.cpp
View File

@@ -1,12 +1,11 @@
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int n, m; // For number of Vertices (V) and number of edges (E)
vector<vector<int>> G;
vector<bool> visited;
vector<int> ans;
std::vector<std::vector<int>> G;
std::vector<bool> visited;
std::vector<int> ans;
void dfs(int v) {
visited[v] = true;
@@ -27,21 +26,21 @@ void topological_sort() {
reverse(ans.begin(), ans.end());
}
int main() {
cout << "Enter the number of vertices and the number of directed edges\n";
cin >> n >> m;
std::cout << "Enter the number of vertices and the number of directed edges\n";
std::cin >> n >> m;
int x, y;
G.resize(n, vector<int>());
G.resize(n, std::vector<int>());
for (int i = 0; i < n; ++i) {
cin >> x >> y;
std::cin >> x >> y;
x--, y--; // to convert 1-indexed to 0-indexed
G[x].push_back(y);
}
topological_sort();
cout << "Topological Order : \n";
std::cout << "Topological Order : \n";
for (int v : ans) {
cout << v + 1
std::cout << v + 1
<< ' '; // converting zero based indexing back to one based.
}
cout << '\n';
std::cout << '\n';
return 0;
}