Merge pull request #239 from admirerr/main

feat(graph): added maximal network rank and jump game 3 in cpp

Author: Pradeepsingh61

CPP/data_structures/graphs/graph/jump_game_3.cpp

@@ -0,0 +1,35 @@
+#include <iostream>
+#include <vector>
+using namespace std;
+
+class Solution {
+public:
+    bool canReach(vector<int>& nums, int startIndex) {
+        vector<int> visited(nums.size(), 0);
+        return explore(nums, startIndex, visited);
+    }
+
+private:
+    bool explore(vector<int>& nums, int currentIndex, vector<int>& visited) {
+        if (currentIndex < 0 || currentIndex >= nums.size()) return false;
+        if (visited[currentIndex]) return false;
+        if (nums[currentIndex] == 0) return true;
+
+        visited[currentIndex] = 1;
+
+        return explore(nums, currentIndex + nums[currentIndex], visited) ||
+               explore(nums, currentIndex - nums[currentIndex], visited);
+    }
+};
+
+int main() {
+    Solution solution;
+
+    vector<int> nums = {4, 2, 3, 0, 3, 1, 2};
+    int startIndex = 5;
+
+    bool result = solution.canReach(nums, startIndex);
+    cout << (result ? "Reachable" : "Not Reachable") << endl;
+
+    return 0;
+}

CPP/data_structures/graphs/graph/maximal_network_rank.cpp

@@ -0,0 +1,53 @@
+#include <iostream>
+#include <vector>
+#include <algorithm>
+using namespace std;
+
+class Solution {
+public:
+    int maximalNetworkRank(int numCities, vector<vector<int>>& roads) {
+        vector<int> degree(numCities, 0);
+        vector<vector<int>> adjacency(numCities);
+        int maxRank = 0;
+
+        for (int i = 0; i < roads.size(); i++) {
+            int cityA = roads[i][0];
+            int cityB = roads[i][1];
+
+            adjacency[cityA].push_back(cityB);
+            adjacency[cityB].push_back(cityA);
+
+            degree[cityA]++;
+            degree[cityB]++;
+        }
+
+        for (int cityA = 0; cityA < numCities; cityA++) {
+            for (int cityB = cityA + 1; cityB < numCities; cityB++) {
+                int rank = degree[cityA] + degree[cityB];
+                if (count(adjacency[cityA].begin(), adjacency[cityA].end(), cityB)) {
+                    rank--;
+                }
+                maxRank = max(maxRank, rank);
+            }
+        }
+
+        return maxRank;
+    }
+};
+
+int main() {
+    Solution solution;
+
+    int numCities = 4;
+    vector<vector<int>> roads = {
+        {0, 1},
+        {0, 3},
+        {1, 2},
+        {1, 3}
+    };
+
+    int result = solution.maximalNetworkRank(numCities, roads);
+    cout << "Maximal Network Rank: " << result << endl;
+
+    return 0;
+}