PromptBase
Close icon
General
Home
Marketplace
Hire
Create
Login
Sell
Explore
πŸ€– GPT

Algorithm Design Challenge

Algorithm Design Challenge gpt prompt mini thumbnail
8Eye icon
Views
GPT-3.5-TURBO
TestedTick icon
TipsTick icon
🌟 Dive into the Algorithm Design Challenge and unlock the thrill of shaping digital landscapes! πŸš€ Ignite your intellect, conquer complexities, and sculpt solutions that dance with efficiency. πŸ€–πŸ’‘ Join us on a coding odyssey where each algorithm crafted is a masterpiece, and victory is the sweet melody of computational triumph! πŸ†πŸ” #CodeMagic
...more
$4.99
Get prompt
After purchasing, you will gain access to the prompt file which you can use with GPT or the app builder. You'll receive 20 free generation credits with this purchase. By purchasing this prompt, you agree to our terms of service.
Over 1 month ago

Prompt Details

Model
Chat - GPT-3.5 (gpt-3.5-turbo)
Token size
123 ($0.00010 / call)
Example input
[specific problem statement]: finding the shortest path in a weighted graph [programming language]: C++
Example output
### Problem Definition and Constraints: **Problem:** Find the shortest path in a weighted graph from a given source vertex to a destination vertex. **Constraints:** - The graph is directed and may contain cycles. - Each edge has a non-negative weight. - The graph may be sparse or dense. - The number of vertices (n) and edges (m) can vary. - The graph may be represented as an adjacency matrix or adjacency list. ### Approach: #### Dijkstra's Algorithm: Dijkstra's algorithm is a common and efficient algorithm for finding the shortest path in a weighted graph. It works well when all edge weights are non-negative. The algorithm maintains a set of vertices whose shortest distance from the source is known and continuously updates the distances to neighboring vertices. **Time Complexity:** O((V + E) log V) with a binary heap as the priority queue. **Space Complexity:** O(V + E) for the distance array and priority queue. #### Step-by-Step Explanation: 1. **Initialization:** - Create an array `dist` to store the shortest distances from the source to each vertex. - Initialize `dist` with infinity for all vertices except the source, set `dist[source]` to 0. - Use a priority queue (min heap) to store vertices and their distances. 2. **Main Loop:** - Repeat until the priority queue is not empty: - Extract the vertex `u` with the minimum distance from the priority queue. - For each neighbor `v` of `u`: - If `dist[u] + weight(u, v) < dist[v]`, update `dist[v]`. - Enqueue `v` with the updated distance. 3. **Implementation:** ```cpp #include <iostream> #include <vector> #include <queue> #include <limits> using namespace std; #define INF numeric_limits<int>::max() // Function to add an edge to the graph void addEdge(vector<pair<int, int>> adj[], int u, int v, int weight) { adj[u].emplace_back(v, weight); } // Dijkstra's Algorithm void dijkstra(vector<pair<int, int>> adj[], int V, int src) { // Priority queue to store vertices and their distances priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq; // Distance array to store the shortest distances vector<int> dist(V, INF); // Enqueue the source vertex with distance 0 pq.push({0, src}); dist[src] = 0; while (!pq.empty()) { // Extract the vertex with the minimum distance int u = pq.top().second; pq.pop(); // Update distances to neighboring vertices for (const auto& neighbor : adj[u]) { int v = neighbor.first; int weight = neighbor.second; if (dist[u] + weight < dist[v]) { dist[v] = dist[u] + weight; pq.push({dist[v], v}); } } } // Print the shortest distances cout << "Shortest distances from source " << src << ":\n"; for (int i = 0; i < V; ++i) { cout << "To " << i << ": " << (dist[i] == INF ? -1 : dist[i]) << "\n"; } } int main() { // Example graph representation using an adjacency list int V = 6; vector<pair<int, int>> adj[V]; // Adding edges to the graph addEdge(adj, 0, 1, 5); addEdge(adj, 0, 2, 3); addEdge(adj, 1, 3, 6); addEdge(adj, 1, 4, 2); addEdge(adj, 2, 4, 7); addEdge(adj, 3, 5, 1); addEdge(adj, 4, 5, 4); // Source vertex int src = 0; // Apply Dijkstra's algorithm dijkstra(adj, V, src); return 0; } ``` ### Test Cases: The given test case corresponds to the graph in the code: ``` 0 --5--> 1 --6--> 3 \ | / 3 2 1 \ | / --7--> 4 \ | 4 | v 5 ``` Expected Output: ``` Shortest distances from source 0: To 0: 0 To 1: 5 To 2: 3 To 3: 11 To 4: 7 To 5: 12 ``` Feel free to modify the graph and test cases to suit your requirements.
Browse Marketplace