Added new problem solutions

Author: hasanulmukit

Advance/6.Write a program to detect a cycle in a linked list/Solution.c

@@ -0,0 +1,63 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+struct Node {
+    int data;
+    struct Node* next;
+};
+
+struct Node* createNode(int data) {
+    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
+    newNode->data = data;
+    newNode->next = NULL;
+    return newNode;
+}
+
+int detectCycle(struct Node* head) {
+    struct Node *slow = head, *fast = head;
+    while (fast != NULL && fast->next != NULL) {
+        slow = slow->next;
+        fast = fast->next->next;
+        if (slow == fast)
+            return 1;
+    }
+    return 0;
+}
+
+int main() {
+    int n, val, pos;
+    struct Node *head = NULL, *tail = NULL, *cycleNode = NULL;
+
+    printf("Enter the number of nodes: ");
+    scanf("%d", &n);
+
+    for (int i = 0; i < n; i++) {
+        printf("Enter value for node %d: ", i + 1);
+        scanf("%d", &val);
+        struct Node* newNode = createNode(val);
+        if (head == NULL) {
+            head = newNode;
+        } else {
+            tail->next = newNode;
+        }
+        tail = newNode;
+        if (i == 0)
+            cycleNode = newNode;
+    }
+
+    printf("Enter the position to create a cycle (0 for no cycle): ");
+    scanf("%d", &pos);
+    if (pos > 0) {
+        struct Node* temp = head;
+        for (int i = 1; i < pos; i++)
+            temp = temp->next;
+        tail->next = temp;
+    }
+
+    if (detectCycle(head))
+        printf("Cycle detected in the linked list.\n");
+    else
+        printf("No cycle detected in the linked list.\n");
+
+    return 0;
+}

Advance/6.Write a program to detect a cycle in a linked list/Solution.cpp

@@ -0,0 +1,54 @@
+#include <iostream>
+using namespace std;
+
+struct Node {
+    int data;
+    Node* next;
+    Node(int val) : data(val), next(nullptr) {}
+};
+
+bool detectCycle(Node* head) {
+    Node *slow = head, *fast = head;
+    while (fast != nullptr && fast->next != nullptr) {
+        slow = slow->next;
+        fast = fast->next->next;
+        if (slow == fast)
+            return true;
+    }
+    return false;
+}
+
+int main() {
+    int n, val, pos;
+    cout << "Enter the number of nodes: ";
+    cin >> n;
+
+    Node *head = nullptr, *tail = nullptr;
+    for (int i = 0; i < n; i++) {
+        cout << "Enter value for node " << i + 1 << ": ";
+        cin >> val;
+        Node* newNode = new Node(val);
+        if (head == nullptr) {
+            head = newNode;
+        } else {
+            tail->next = newNode;
+        }
+        tail = newNode;
+    }
+
+    cout << "Enter the position to create a cycle (0 for no cycle): ";
+    cin >> pos;
+    if (pos > 0) {
+        Node* temp = head;
+        for (int i = 1; i < pos; i++)
+            temp = temp->next;
+        tail->next = temp;
+    }
+
+    if (detectCycle(head))
+        cout << "Cycle detected in the linked list.\n";
+    else
+        cout << "No cycle detected in the linked list.\n";
+
+    return 0;
+}

Advance/6.Write a program to detect a cycle in a linked list/Solution.java

@@ -0,0 +1,59 @@
+import java.util.Scanner;
+
+class Node {
+    int data;
+    Node next;
+    Node(int data) {
+        this.data = data;
+        this.next = null;
+    }
+}
+
+public class DetectCycle {
+    static boolean detectCycle(Node head) {
+        Node slow = head, fast = head;
+        while (fast != null && fast.next != null) {
+            slow = slow.next;
+            fast = fast.next.next;
+            if (slow == fast)
+                return true;
+        }
+        return false;
+    }
+
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        System.out.print("Enter the number of nodes: ");
+        int n = scanner.nextInt();
+
+        Node head = null, tail = null;
+        for (int i = 0; i < n; i++) {
+            System.out.print("Enter value for node " + (i + 1) + ": ");
+            int val = scanner.nextInt();
+            Node newNode = new Node(val);
+            if (head == null) {
+                head = newNode;
+            } else {
+                tail.next = newNode;
+            }
+            tail = newNode;
+        }
+
+        System.out.print("Enter the position to create a cycle (0 for no cycle): ");
+        int pos = scanner.nextInt();
+        if (pos > 0) {
+            Node temp = head;
+            for (int i = 1; i < pos; i++) {
+                temp = temp.next;
+            }
+            tail.next = temp;
+        }
+
+        if (detectCycle(head))
+            System.out.println("Cycle detected in the linked list.");
+        else
+            System.out.println("No cycle detected in the linked list.");
+
+        scanner.close();
+    }
+}

Advance/6.Write a program to detect a cycle in a linked list/Solution.py

@@ -0,0 +1,39 @@
+class Node:
+    def __init__(self, data):
+        self.data = data
+        self.next = None
+
+def detect_cycle(head):
+    slow, fast = head, head
+    while fast and fast.next:
+        slow = slow.next
+        fast = fast.next.next
+        if slow == fast:
+            return True
+    return False
+
+if __name__ == "__main__":
+    n = int(input("Enter the number of nodes: "))
+    head = None
+    tail = None
+
+    for i in range(n):
+        val = int(input(f"Enter value for node {i + 1}: "))
+        new_node = Node(val)
+        if head is None:
+            head = new_node
+        else:
+            tail.next = new_node
+        tail = new_node
+
+    pos = int(input("Enter the position to create a cycle (0 for no cycle): "))
+    if pos > 0:
+        temp = head
+        for _ in range(pos - 1):
+            temp = temp.next
+        tail.next = temp
+
+    if detect_cycle(head):
+        print("Cycle detected in the linked list.")
+    else:
+        print("No cycle detected in the linked list.")

Advance/7.Find the shortest path in a graph using Dijkstra’s Algorithm/Solution.c

@@ -0,0 +1,61 @@
+#include <stdio.h>
+#include <limits.h>
+
+#define MAX 100
+
+int findMinDistance(int dist[], int visited[], int n) {
+    int min = INT_MAX, minIndex = -1;
+    for (int v = 0; v < n; v++) {
+        if (!visited[v] && dist[v] <= min) {
+            min = dist[v];
+            minIndex = v;
+        }
+    }
+    return minIndex;
+}
+
+void dijkstra(int graph[MAX][MAX], int n, int start) {
+    int dist[n], visited[n];
+
+    for (int i = 0; i < n; i++) {
+        dist[i] = INT_MAX;
+        visited[i] = 0;
+    }
+    dist[start] = 0;
+
+    for (int count = 0; count < n - 1; count++) {
+        int u = findMinDistance(dist, visited, n);
+        visited[u] = 1;
+
+        for (int v = 0; v < n; v++) {
+            if (!visited[v] && graph[u][v] && dist[u] != INT_MAX && dist[u] + graph[u][v] < dist[v]) {
+                dist[v] = dist[u] + graph[u][v];
+            }
+        }
+    }
+
+    printf("Vertex\tDistance from Source\n");
+    for (int i = 0; i < n; i++) {
+        printf("%d\t%d\n", i, dist[i]);
+    }
+}
+
+int main() {
+    int n, start;
+    int graph[MAX][MAX];
+    printf("Enter the number of vertices: ");
+    scanf("%d", &n);
+
+    printf("Enter the adjacency matrix:\n");
+    for (int i = 0; i < n; i++) {
+        for (int j = 0; j < n; j++) {
+            scanf("%d", &graph[i][j]);
+        }
+    }
+
+    printf("Enter the starting vertex: ");
+    scanf("%d", &start);
+
+    dijkstra(graph, n, start);
+    return 0;
+}

Advance/7.Find the shortest path in a graph using Dijkstra’s Algorithm/Solution.cpp

@@ -0,0 +1,58 @@
+#include <iostream>
+#include <vector>
+#include <climits>
+using namespace std;
+
+int findMinDistance(vector<int>& dist, vector<bool>& visited, int n) {
+    int min = INT_MAX, minIndex = -1;
+    for (int v = 0; v < n; v++) {
+        if (!visited[v] && dist[v] <= min) {
+            min = dist[v];
+            minIndex = v;
+        }
+    }
+    return minIndex;
+}
+
+void dijkstra(vector<vector<int>>& graph, int n, int start) {
+    vector<int> dist(n, INT_MAX);
+    vector<bool> visited(n, false);
+
+    dist[start] = 0;
+
+    for (int count = 0; count < n - 1; count++) {
+        int u = findMinDistance(dist, visited, n);
+        visited[u] = true;
+
+        for (int v = 0; v < n; v++) {
+            if (!visited[v] && graph[u][v] && dist[u] != INT_MAX && dist[u] + graph[u][v] < dist[v]) {
+                dist[v] = dist[u] + graph[u][v];
+            }
+        }
+    }
+
+    cout << "Vertex\tDistance from Source" << endl;
+    for (int i = 0; i < n; i++) {
+        cout << i << "\t" << dist[i] << endl;
+    }
+}
+
+int main() {
+    int n, start;
+    cout << "Enter the number of vertices: ";
+    cin >> n;
+
+    vector<vector<int>> graph(n, vector<int>(n));
+    cout << "Enter the adjacency matrix:" << endl;
+    for (int i = 0; i < n; i++) {
+        for (int j = 0; j < n; j++) {
+            cin >> graph[i][j];
+        }
+    }
+
+    cout << "Enter the starting vertex: ";
+    cin >> start;
+
+    dijkstra(graph, n, start);
+    return 0;
+}