Merge branch 'main' into main

Author: OzPol

README.md

@@ -130,8 +130,8 @@ In order to achieve greater coverage and encourage more people to contribute to
                 </a>
             </td>
             <td> <!-- C++ -->
-                <a href="./CONTRIBUTING.md">
-                    <img align="center" height="25" src="./logos/github.svg" />
+                <a href="./src/cpp/FloydWarshall.cpp">
+                    <img align="center" height="25" src="./logos/cplusplus.svg" />
                 </a>
             </td>
             <td> <!-- Java -->
@@ -246,8 +246,8 @@ In order to achieve greater coverage and encourage more people to contribute to
                 </a>
             </td>
             <td> <!-- C++ -->
-                <a href="./CONTRIBUTING.md">
-                    <img align="center" height="25" src="./logos/github.svg" />
+                <a href="./src/cpp/GraphSearch.cpp">
+                    <img align="center" height="25" src="./logos/cplusplus.svg" />
                 </a>
             </td>
             <td> <!-- Java -->
@@ -1174,8 +1174,8 @@ In order to achieve greater coverage and encourage more people to contribute to
                 </a>
             </td>
             <td> <!-- C++ -->
-                <a href="./CONTRIBUTING.md">
-                    <img align="center" height="25" src="./logos/github.svg" />
+                <a href="./src/cpp/ConnectedComponents.cpp">
+                    <img align="center" height="25" src="./logos/cplusplus.svg" />
                 </a>
             </td>
             <td> <!-- Java -->

src/cpp/ConnectedComponents.cpp

@@ -0,0 +1,53 @@
+#include <iostream>
+#include <vector>
+
+#define VERTICES 6
+#define INF -1
+
+std::vector<bool> visited(VERTICES, false); // Array to track visited vertices
+int components = 0;
+
+// Adjacency matrix representing the graph
+int matrix[VERTICES][VERTICES] = {{0, INF, 1, INF, INF, INF},
+                                  {INF, 0, INF, 1, 1, INF},
+                                  {1, INF, 0, INF, INF, INF},
+                                  {INF, 1, INF, 0, 1, 1},
+                                  {INF, 1, INF, 1, 0, 1},
+                                  {INF, INF, INF, 1, 1, 0}};
+
+// Recursive method to find connected components using adjacency matrix
+void findConnectedComponents(int current)
+{
+    for (int i = 0; i < VERTICES; i++)
+    {
+        if (!visited[i] && matrix[current][i] == 1)
+        {
+            visited[i] = true;
+            components++;
+            std::cout << "(" << i << ")-";
+            findConnectedComponents(i);
+        }
+    }
+}
+
+int main()
+{
+    // Initialize all vertices as unvisited
+    for (int i = 0; i < VERTICES; i++)
+        visited[i] = false;
+
+    // For each vertex, if it is unvisited, start a DFS and count components
+    for (int i = 0; i < VERTICES; i++)
+    {
+        if (!visited[i])
+        {
+            components = 0;
+            visited[i] = true;
+            std::cout << "Starting at vertex (" << i << ")-";
+            findConnectedComponents(i);
+            std::cout << "\nNumber of connected components starting from vertex " << i << ": " << components << "\n\n";
+        }
+    }
+
+    return 0;
+}

src/cpp/FloydWarshall.cpp

@@ -0,0 +1,71 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+// Function to display the matrix
+void showMatrix(const vector<vector<long>> &matrix, int numVertices)
+{
+    for (int i = 0; i < numVertices; i++)
+    {
+        for (int j = 0; j < numVertices; j++)
+        {
+            if (matrix[i][j] < 10) // For better alignment
+                cout << " ";
+            cout << matrix[i][j] << " ";
+        }
+        cout << endl;
+    }
+    cout << endl;
+}
+
+// Floyd-Warshall algorithm
+void floydWarshall(vector<vector<long>> &matrix, int n)
+{
+    for (int k = 0; k < n; k++) // Intermediary vertex
+    {
+        for (int i = 0; i < n; i++) // Origin vertex
+        {
+            for (int j = 0; j < n; j++) // Destination vertex
+            {
+                if (matrix[i][k] != LONG_MAX &&                 // i -> k exists
+                    matrix[k][j] != LONG_MAX &&                 // k -> j exists
+                    matrix[i][j] > matrix[i][k] + matrix[k][j]) // i -> j is shorter via k
+                {
+                    matrix[i][j] = matrix[i][k] + matrix[k][j]; // Update i -> j
+                }
+            }
+        }
+    }
+}
+
+int main()
+{
+    int numVertices = 5;
+
+    // Initialize matrix with given values
+    vector<vector<long>> matrix = {
+        {0, 2, 10, 5, 7},
+        {2, 0, 3, 3, 1},
+        {10, 3, 0, 1, 2},
+        {5, 3, 1, 0, LONG_MAX},
+        {7, 1, 2, 2, 0}};
+
+    // Display the original matrix
+    cout << "Original matrix:" << endl;
+    showMatrix(matrix, numVertices);
+
+    // Apply Floyd-Warshall algorithm
+    floydWarshall(matrix, numVertices);
+
+    // Display the updated matrix
+    cout << "Updated matrix:" << endl;
+    showMatrix(matrix, numVertices);
+
+    // Show all shortest paths in 3 columns: source, destination, shortest distance
+    cout << "Source\tDestination\tShortest Distance" << endl;
+    for (int i = 0; i < numVertices; i++)
+        for (int j = 0; j < numVertices; j++)
+            cout << i << "\t" << j << "\t\t" << matrix[i][j] << endl;
+
+    return 0;
+}

src/cpp/GraphSearch.cpp

@@ -0,0 +1,135 @@
+#include <iostream>
+#include <vector>
+#include <queue>
+
+#define MAX_VERTICES 6 // Maximum number of vertices in the graph
+
+// Structure that defines each Vertex of the Graph
+struct Vertex
+{
+    char id;
+    std::vector<Vertex *> neighbors; // List of neighbors
+    bool visited;
+
+    Vertex(char id) : id(id), visited(false) {}
+};
+
+// Creates a vertex and returns it
+Vertex *createVertex(char id)
+{
+    return new Vertex(id);
+}
+
+// Links two vertices (makes them neighbors)
+void linkVertices(Vertex *v1, Vertex *v2)
+{
+    v1->neighbors.push_back(v2); // Add v2 as a neighbor of v1
+    v2->neighbors.push_back(v1); // Add v1 as a neighbor of v2
+}
+
+/*
+ * Depth First Search (DFS)
+ * Recursively visits neighbors of the starting vertex
+ */
+int depthFirstSearch(Vertex *start, Vertex *destination, int steps)
+{
+    start->visited = true; // Mark the current vertex as visited
+    if (start == destination)
+        return steps; // If found, return the distance
+
+    for (Vertex *neighbor : start->neighbors)
+    { // Visit all neighbors
+        if (!neighbor->visited)
+        { // If neighbor hasn't been visited
+            int result = depthFirstSearch(neighbor, destination, steps + 1);
+            if (result != -1)
+                return result; // If destination found, return result
+        }
+    }
+    return -1; // Destination not found
+}
+
+/*
+ * Breadth First Search (BFS)
+ * Uses a queue to traverse level by level
+ */
+int breadthFirstSearch(Vertex *start, Vertex *destination)
+{
+    std::queue<Vertex *> q;
+    q.push(start); // Enqueue starting vertex
+    start->visited = true;
+
+    int steps = 0;
+
+    while (!q.empty())
+    {
+        int qSize = q.size(); // Current queue size (level size)
+
+        // Process all vertices at the current level
+        for (int i = 0; i < qSize; i++)
+        {
+            Vertex *current = q.front();
+            q.pop();
+
+            if (current == destination)
+                return steps; // If destination found, return steps
+
+            // Enqueue all unvisited neighbors
+            for (Vertex *neighbor : current->neighbors)
+            {
+                if (!neighbor->visited)
+                {
+                    neighbor->visited = true;
+                    q.push(neighbor);
+                }
+            }
+        }
+        steps++; // Increment the level
+    }
+    return -1; // Destination not found
+}
+
+int main()
+{
+    // Create vertices
+    Vertex *A = createVertex('A');
+    Vertex *B = createVertex('B');
+    Vertex *C = createVertex('C');
+    Vertex *D = createVertex('D');
+    Vertex *E = createVertex('E');
+    Vertex *F = createVertex('F');
+
+    // Link vertices as per the graph structure
+    linkVertices(A, B);
+    linkVertices(A, C);
+    linkVertices(B, D);
+    linkVertices(C, D);
+    linkVertices(B, E);
+    linkVertices(D, E);
+    linkVertices(E, F);
+    linkVertices(D, F);
+
+    // Perform Depth First Search
+    int result = depthFirstSearch(A, F, 0);
+    if (result != -1)
+        std::cout << "DFS - Found. Distance: " << result << std::endl;
+    else
+        std::cout << "DFS - Not Found." << std::endl;
+
+    // Reset visited status for all vertices
+    A->visited = false;
+    B->visited = false;
+    C->visited = false;
+    D->visited = false;
+    E->visited = false;
+    F->visited = false;
+
+    // Perform Breadth First Search
+    result = breadthFirstSearch(A, F);
+    if (result != -1)
+        std::cout << "BFS - Found. Distance: " << result << std::endl;
+    else
+        std::cout << "BFS - Not Found." << std::endl;
+
+    return 0;
+}