Added new problems

Author: hasanulmukit

Intermediate/32.Solve the Topological Sorting Problem for a directed acyclic graph (DAG)/Solution.c

@@ -0,0 +1,54 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+void topologicalSortUtil(int v, int visited[], int *stack, int *top, int graph[][100], int vertices) {
+    visited[v] = 1;
+
+    for (int i = 0; i < vertices; i++) {
+        if (graph[v][i] && !visited[i]) {
+            topologicalSortUtil(i, visited, stack, top, graph, vertices);
+        }
+    }
+
+    stack[++(*top)] = v;
+}
+
+void topologicalSort(int graph[][100], int vertices) {
+    int visited[vertices];
+    int stack[vertices];
+    int top = -1;
+
+    for (int i = 0; i < vertices; i++) {
+        visited[i] = 0;
+    }
+
+    for (int i = 0; i < vertices; i++) {
+        if (!visited[i]) {
+            topologicalSortUtil(i, visited, stack, &top, graph, vertices);
+        }
+    }
+
+    printf("Topological Sort: ");
+    while (top >= 0) {
+        printf("%d ", stack[top--]);
+    }
+    printf("\n");
+}
+
+int main() {
+    int vertices, edges;
+    printf("Enter the number of vertices and edges: ");
+    scanf("%d %d", &vertices, &edges);
+
+    int graph[100][100] = {0};
+    printf("Enter the edges (u -> v):\n");
+    for (int i = 0; i < edges; i++) {
+        int u, v;
+        scanf("%d %d", &u, &v);
+        graph[u][v] = 1;
+    }
+
+    topologicalSort(graph, vertices);
+
+    return 0;
+}

Intermediate/32.Solve the Topological Sorting Problem for a directed acyclic graph (DAG)/Solution.cpp

@@ -0,0 +1,55 @@
+#include <iostream>
+#include <vector>
+#include <stack>
+using namespace std;
+
+// Recursive DFS function to process a vertex and its neighbors
+void dfs(int v, const vector<vector<int>> &graph, vector<bool> &visited, stack<int> &order) {
+    visited[v] = true;
+    for (int neighbor : graph[v]) {
+        if (!visited[neighbor]) {
+            dfs(neighbor, graph, visited, order);
+        }
+    }
+    // Push vertex onto stack after all its neighbors are processed
+    order.push(v);
+}
+
+int main() {
+    int vertices, edges;
+    cout << "Enter the number of vertices: ";
+    cin >> vertices;
+    cout << "Enter the number of edges: ";
+    cin >> edges;
+    
+    // Initialize graph as an adjacency list (0-indexed vertices)
+    vector<vector<int>> graph(vertices);
+    cout << "Enter each edge (source destination):" << endl;
+    for (int i = 0; i < edges; i++) {
+        int u, v;
+        cin >> u >> v;
+        // For a directed graph, add an edge from u to v
+        graph[u].push_back(v);
+    }
+    
+    // To keep track of visited vertices
+    vector<bool> visited(vertices, false);
+    stack<int> order;
+    
+    // Perform DFS for each vertex that hasn't been visited
+    for (int i = 0; i < vertices; i++) {
+        if (!visited[i]) {
+            dfs(i, graph, visited, order);
+        }
+    }
+    
+    // Output the topologically sorted order by popping from the stack
+    cout << "Topological Order: ";
+    while (!order.empty()) {
+        cout << order.top() << " ";
+        order.pop();
+    }
+    cout << endl;
+    
+    return 0;
+}

Intermediate/32.Solve the Topological Sorting Problem for a directed acyclic graph (DAG)/Solution.java

@@ -0,0 +1,53 @@
+import java.util.*;
+
+public class TopologicalSort {
+    static void topologicalSortUtil(int v, boolean[] visited, Stack<Integer> stack, List<List<Integer>> graph) {
+        visited[v] = true;
+
+        for (int neighbor : graph.get(v)) {
+            if (!visited[neighbor]) {
+                topologicalSortUtil(neighbor, visited, stack, graph);
+            }
+        }
+
+        stack.push(v);
+    }
+
+    static void topologicalSort(List<List<Integer>> graph, int vertices) {
+        boolean[] visited = new boolean[vertices];
+        Stack<Integer> stack = new Stack<>();
+
+        for (int i = 0; i < vertices; i++) {
+            if (!visited[i]) {
+                topologicalSortUtil(i, visited, stack, graph);
+            }
+        }
+
+        System.out.print("Topological Sort: ");
+        while (!stack.isEmpty()) {
+            System.out.print(stack.pop() + " ");
+        }
+        System.out.println();
+    }
+
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        System.out.print("Enter the number of vertices and edges: ");
+        int vertices = scanner.nextInt();
+        int edges = scanner.nextInt();
+
+        List<List<Integer>> graph = new ArrayList<>();
+        for (int i = 0; i < vertices; i++) {
+            graph.add(new ArrayList<>());
+        }
+
+        System.out.println("Enter the edges (u -> v):");
+        for (int i = 0; i < edges; i++) {
+            int u = scanner.nextInt();
+            int v = scanner.nextInt();
+            graph.get(u).add(v);
+        }
+
+        topologicalSort(graph, vertices);
+    }
+}

Intermediate/32.Solve the Topological Sorting Problem for a directed acyclic graph (DAG)/Solution.py

@@ -0,0 +1,34 @@
+def dfs(v, graph, visited, stack):
+    """Recursive DFS that marks visited nodes and appends vertices to stack."""
+    visited[v] = True
+    for neighbor in graph[v]:
+        if not visited[neighbor]:
+            dfs(neighbor, graph, visited, stack)
+    stack.append(v)
+
+def topological_sort(graph, vertices):
+    """Returns a list of vertices in topologically sorted order."""
+    visited = [False] * vertices
+    stack = []
+    for i in range(vertices):
+        if not visited[i]:
+            dfs(i, graph, visited, stack)
+    # Reverse stack to get the correct topological order.
+    return stack[::-1]
+
+def main():
+    vertices = int(input("Enter the number of vertices: "))
+    edges = int(input("Enter the number of edges: "))
+    
+    # Initialize the graph as a list of lists
+    graph = [[] for _ in range(vertices)]
+    print("Enter each edge (source destination) separated by space:")
+    for _ in range(edges):
+        u, v = map(int, input().split())
+        graph[u].append(v)  # Directed edge from u to v
+    
+    order = topological_sort(graph, vertices)
+    print("Topological Order:", " ".join(map(str, order)))
+
+if __name__ == "__main__":
+    main()

Intermediate/33.Write a program to detect a cycle in a directed graph using DFS/Solution.c

@@ -0,0 +1,59 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+int detectCycleUtil(int v, int visited[], int recStack[], int graph[][100], int vertices) {
+    visited[v] = 1;
+    recStack[v] = 1;
+
+    for (int i = 0; i < vertices; i++) {
+        if (graph[v][i]) {
+            if (!visited[i] && detectCycleUtil(i, visited, recStack, graph, vertices)) {
+                return 1;
+            } else if (recStack[i]) {
+                return 1;
+            }
+        }
+    }
+
+    recStack[v] = 0;
+    return 0;
+}
+
+int detectCycle(int graph[][100], int vertices) {
+    int visited[vertices];
+    int recStack[vertices];
+
+    for (int i = 0; i < vertices; i++) {
+        visited[i] = 0;
+        recStack[i] = 0;
+    }
+
+    for (int i = 0; i < vertices; i++) {
+        if (!visited[i] && detectCycleUtil(i, visited, recStack, graph, vertices)) {
+            return 1;
+        }
+    }
+    return 0;
+}
+
+int main() {
+    int vertices, edges;
+    printf("Enter the number of vertices and edges: ");
+    scanf("%d %d", &vertices, &edges);
+
+    int graph[100][100] = {0};
+    printf("Enter the edges (u -> v):\n");
+    for (int i = 0; i < edges; i++) {
+        int u, v;
+        scanf("%d %d", &u, &v);
+        graph[u][v] = 1;
+    }
+
+    if (detectCycle(graph, vertices)) {
+        printf("Cycle detected in the graph.\n");
+    } else {
+        printf("No cycle detected in the graph.\n");
+    }
+
+    return 0;
+}

Intermediate/33.Write a program to detect a cycle in a directed graph using DFS/Solution.cpp

@@ -0,0 +1,64 @@
+#include <iostream>
+#include <vector>
+using namespace std;
+
+// DFS function to detect cycle in a directed graph
+bool dfsCycle(int v, const vector<vector<int>>& graph, vector<bool>& visited, vector<bool>& recStack) {
+    visited[v] = true;
+    recStack[v] = true;
+
+    // Explore all neighbors
+    for (int neighbor : graph[v]) {
+        // If neighbor is not visited, do DFS on it
+        if (!visited[neighbor]) {
+            if (dfsCycle(neighbor, graph, visited, recStack))
+                return true;
+        }
+        // If neighbor is in the recursion stack, cycle detected
+        else if (recStack[neighbor]) {
+            return true;
+        }
+    }
+
+    // Remove vertex from recursion stack before returning
+    recStack[v] = false;
+    return false;
+}
+
+// Function to detect cycle in the entire graph
+bool detectCycle(const vector<vector<int>>& graph, int V) {
+    vector<bool> visited(V, false);
+    vector<bool> recStack(V, false);
+
+    for (int i = 0; i < V; i++) {
+        if (!visited[i]) {
+            if (dfsCycle(i, graph, visited, recStack))
+                return true;
+        }
+    }
+    return false;
+}
+
+int main() {
+    int V, E;
+    cout << "Enter the number of vertices: ";
+    cin >> V;
+    cout << "Enter the number of edges: ";
+    cin >> E;
+
+    // Initialize graph as an adjacency list (0-indexed vertices)
+    vector<vector<int>> graph(V);
+    cout << "Enter each edge (u v) [directed edge from u to v]:" << endl;
+    for (int i = 0; i < E; i++) {
+        int u, v;
+        cin >> u >> v;
+        graph[u].push_back(v);
+    }
+
+    if (detectCycle(graph, V))
+        cout << "Cycle detected in the graph." << endl;
+    else
+        cout << "No cycle detected in the graph." << endl;
+
+    return 0;
+}

Intermediate/33.Write a program to detect a cycle in a directed graph using DFS/Solution.java

@@ -0,0 +1,59 @@
+import java.util.*;
+
+public class CycleDetectionDirectedGraph {
+    static boolean detectCycleUtil(int v, boolean[] visited, boolean[] recStack, List<List<Integer>> graph) {
+        visited[v] = true;
+        recStack[v] = true;
+
+        for (int neighbor : graph.get(v)) {
+            if (!visited[neighbor] && detectCycleUtil(neighbor, visited, recStack, graph)) {
+                return true;
+            } else if (recStack[neighbor]) {
+                return true;
+            }
+        }
+
+        recStack[v] = false;
+        return false;
+    }
+
+    static boolean detectCycle(List<List<Integer>> graph, int vertices) {
+        boolean[] visited = new boolean[vertices];
+        boolean[] recStack = new boolean[vertices];
+
+        for (int i = 0; i < vertices; i++) {
+            if (!visited[i] && detectCycleUtil(i, visited, recStack, graph)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        System.out.print("Enter the number of vertices and edges: ");
+        int vertices = scanner.nextInt();
+        int edges = scanner.nextInt();
+
+        List<List<Integer>> graph = new ArrayList<>();
+        for (int i = 0; i < vertices; i++) {
+            graph.add(new ArrayList<>());
+        }
+
+        System.out.println("Enter the edges (u -> v):");
+        for (int i = 0; i < edges; i++) {
+            int u = scanner.nextInt();
+            int v = scanner.nextInt();
+            graph.get(u).add(v);
+        }
+
+        if (detectCycle(graph, vertices)) {
+            System.out.println("Cycle detected in the graph.");
+        } else {
+            System.out.println("No cycle detected in the graph.");
+        }
+
+        scanner.close();
+    }
+}