mirror of
https://github.com/TheAlgorithms/C-Plus-Plus.git
synced 2026-04-04 19:20:17 +08:00
fix: build
This commit is contained in:
Ayaan Khan
@@ -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);
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user