most useful algorithms

code/Most_Useful_Algorithms/ActivitySelection.cpp

@@ -0,0 +1,55 @@
+#include <iostream>
+#include <vector>
+#include <algorithm>
+
+using namespace std;
+
+
+struct Activity {
+    int start;
+    int finish;
+};
+
+bool compareActivities(const Activity& a1, const Activity& a2) {
+    return a1.finish < a2.finish;
+}
+
+
+void selectActivities(vector<Activity>& activities) {
+    int n = activities.size();
+
+
+    sort(activities.begin(), activities.end(), compareActivities);
+
+    cout << "Selected Activities: ";
+    int prevFinish = activities[0].finish;
+    cout << "(" << activities[0].start << ", " << activities[0].finish << ") ";
+
+
+    for (int i = 1; i < n; i++) {
+
+        if (activities[i].start >= prevFinish) {
+            cout << "(" << activities[i].start << ", " << activities[i].finish << ") ";
+            prevFinish = activities[i].finish;
+        }
+    }
+    cout << endl;
+}
+
+int main() {
+    int n;
+    cout << "Enter the number of activities: ";
+    cin >> n;
+
+    vector<Activity> activities(n);
+
+    cout << "Enter the start and finish times for each activity:" << endl;
+    for (int i = 0; i < n; i++) {
+        cout << "Activity " << i + 1 << ": ";
+        cin >> activities[i].start >> activities[i].finish;
+    }
+
+    selectActivities(activities);
+
+    return 0;
+}

code/Most_Useful_Algorithms/BellManFord.cpp

@@ -0,0 +1,90 @@
+#include <iostream>
+#include <vector>
+#include <climits>
+
+using namespace std;
+
+const int INF = INT_MAX; 
+
+
+struct Edge {
+    int src, dest, weight;
+};
+
+class Graph {
+public:
+    int V, E; 
+    vector<Edge> edges;
+
+    Graph(int vertices, int edges) : V(vertices), E(edges) {}
+
+
+    void addEdge(int src, int dest, int weight) {
+        Edge edge = {src, dest, weight};
+        edges.push_back(edge);
+    }
+
+
+    void bellmanFord(int src) {
+        vector<int> distance(V, INF);
+        distance[src] = 0;
+
+
+        for (int i = 1; i <= V - 1; i++) {
+            for (const Edge& edge : edges) {
+                int u = edge.src;
+                int v = edge.dest;
+                int weight = edge.weight;
+
+                if (distance[u] != INF && distance[u] + weight < distance[v]) {
+                    distance[v] = distance[u] + weight;
+                }
+            }
+        }
+
+
+        for (const Edge& edge : edges) {
+            int u = edge.src;
+            int v = edge.dest;
+            int weight = edge.weight;
+
+            if (distance[u] != INF && distance[u] + weight < distance[v]) {
+                cout << "Graph contains negative-weight cycle." << endl;
+                return;
+            }
+        }
+
+        cout << "Shortest Distances from Source Vertex " << src << ":" << endl;
+        for (int i = 0; i < V; i++) {
+            cout << "Vertex " << i << ": ";
+            if (distance[i] == INF) {
+                cout << "INF" << endl;
+            } else {
+                cout << distance[i] << endl;
+            }
+        }
+    }
+};
+
+int main() {
+    int V, E;
+    cout << "Enter the number of vertices (V) and edges (E): ";
+    cin >> V >> E;
+
+    Graph g(V, E);
+
+    cout << "Enter the edges and their weights (format: src dest weight):" << endl;
+    for (int i = 0; i < E; i++) {
+        int src, dest, weight;
+        cin >> src >> dest >> weight;
+        g.addEdge(src, dest, weight);
+    }
+
+    int src;
+    cout << "Enter the source vertex: ";
+    cin >> src;
+
+    g.bellmanFord(src);
+
+    return 0;
+}

code/Most_Useful_Algorithms/Dijkstra.cpp

@@ -0,0 +1,103 @@
+#include <iostream>
+#include <vector>
+#include <queue>
+#include <climits>
+
+using namespace std;
+
+const int INF = INT_MAX;
+
+struct Edge {
+    int dest, weight;
+};
+
+
+struct Vertex {
+    int vertex, distance;
+
+
+    bool operator>(const Vertex& other) const {
+        return distance > other.distance;
+    }
+};
+
+class Graph {
+public:
+    int V; 
+    vector<vector<Edge>> adj;
+
+    Graph(int vertices) : V(vertices) {
+        adj.resize(V);
+    }
+
+
+    void addEdge(int src, int dest, int weight) {
+        Edge edge = {dest, weight};
+        adj[src].push_back(edge);
+    }
+
+
+    void dijkstra(int src) {
+        vector<int> distance(V, INF);
+        vector<bool> visited(V, false);
+
+        distance[src] = 0;
+
+        priority_queue<Vertex, vector<Vertex>, greater<Vertex>> pq;
+        pq.push({src, 0});
+
+        while (!pq.empty()) {
+            int u = pq.top().vertex;
+            pq.pop();
+
+            if (visited[u]) {
+                continue;
+            }
+
+            visited[u] = true;
+
+            for (const Edge& edge : adj[u]) {
+                int v = edge.dest;
+                int weight = edge.weight;
+
+                if (!visited[v] && distance[u] != INF && distance[u] + weight < distance[v]) {
+                    distance[v] = distance[u] + weight;
+                    pq.push({v, distance[v]});
+                }
+            }
+        }
+
+        cout << "Shortest Distances from Source Vertex " << src << ":" << endl;
+        for (int i = 0; i < V; i++) {
+            cout << "Vertex " << i << ": ";
+            if (distance[i] == INF) {
+                cout << "INF" << endl;
+            } else {
+                cout << distance[i] << endl;
+            }
+        }
+    }
+};
+
+int main() {
+    int V, E;
+    cout << "Enter the number of vertices (V) and edges (E): ";
+    cin >> V >> E;
+
+    Graph g(V);
+
+    cout << "Enter the edges (format: src dest weight):" << endl;
+    for (int i = 0; i < E; i++) {
+        int src, dest, weight;
+        cin >> src >> dest >> weight;
+        g.addEdge(src, dest, weight);
+    }
+
+    int src;
+    cout << "Enter the source vertex: ";
+    cin >> src;
+
+    g.dijkstra(src);
+
+    return 0;
+}

code/Most_Useful_Algorithms/Floyd Warshall.cpp

@@ -0,0 +1,77 @@
+#include <iostream>
+#include <vector>
+#include <climits>
+
+using namespace std;
+
+const int INF = INT_MAX; 
+
+class Graph {
+public:
+    int V; 
+    vector<vector<int>> adj;
+
+    Graph(int vertices) : V(vertices) {
+
+        adj.resize(V, vector<int>(V, INF));
+
+
+        for (int i = 0; i < V; i++) {
+            adj[i][i] = 0;
+        }
+    }
+
+
+    void addEdge(int src, int dest, int weight) {
+        adj[src][dest] = weight;
+    }
+
+
+    void floydWarshall() {
+        vector<vector<int>> dist = adj; 
+
+
+        for (int k = 0; k < V; k++) {
+            for (int i = 0; i < V; i++) {
+                for (int j = 0; j < V; j++) {
+
+                    if (dist[i][k] != INF && dist[k][j] != INF && dist[i][k] + dist[k][j] < dist[i][j]) {
+                        dist[i][j] = dist[i][k] + dist[k][j];
+                    }
+                }
+            }
+        }
+
+
+        cout << "Shortest Distances between All Pairs of Vertices:" << endl;
+        for (int i = 0; i < V; i++) {
+            for (int j = 0; j < V; j++) {
+                if (dist[i][j] == INF) {
+                    cout << "INF\t";
+                } else {
+                    cout << dist[i][j] << "\t";
+                }
+            }
+            cout << endl;
+        }
+    }
+};
+
+int main() {
+    int V, E;
+    cout << "Enter the number of vertices (V) and edges (E): ";
+    cin >> V >> E;
+
+    Graph g(V);
+
+    cout << "Enter the edges and their weights (format: src dest weight):" << endl;
+    for (int i = 0; i < E; i++) {
+        int src, dest, weight;
+        cin >> src >> dest >> weight;
+        g.addEdge(src, dest, weight);
+    }
+
+    g.floydWarshall();
+
+    return 0;
+}