Intelligent Route Planner for Delivery Services Using Traffic and Weather Data C++

```cpp
#include <iostream>
#include <vector>
#include <queue>
#include <map>
#include <limits>
#include <random>  // For generating sample data
#include <ctime>    // For seeding the random number generator
#include <iomanip>  // For formatting output

using namespace std;

// --- Data Structures ---

// Represents a location/node in the delivery network
struct Location {
    int id;       // Unique identifier for the location
    string name;   // Name of the location (e.g., "Warehouse", "Customer 1")
    double latitude;
    double longitude;
};

// Represents a connection between two locations (an edge in the graph)
struct Route {
    int from;      // Location ID of the starting point
    int to;        // Location ID of the destination
    double distance;  // Distance between the locations (e.g., in kilometers)
    double baseTravelTime; //Travel time in optimal conditions
};

// Structure to store traffic information for a route.  (Simulated here)
struct TrafficInfo {
    int routeFrom; // Route start location ID
    int routeTo;   // Route end location ID
    double trafficMultiplier; // A factor to increase travel time (e.g., 1.5 for heavy traffic)
};

// Structure to store weather information for a route (Simulated here)
struct WeatherInfo {
    int routeFrom;
    int routeTo;
    double weatherMultiplier; //Multiplier to increase travel time due to weather
};

// Structure to represent a node in the priority queue for Dijkstra's algorithm.
struct Node {
    int locationId; // The ID of the location this node represents.
    double cost;    // The cost (travel time) to reach this location from the start.

    // Overload the less-than operator for the priority queue. This ensures that
    // the node with the *smallest* cost is at the top of the queue.  This is important
    // for Dijkstra's algorithm to work correctly.
    bool operator>(const Node& other) const {
        return cost > other.cost;
    }
};


// --- Function Prototypes ---

// Graph Initialization and Data Generation
vector<Location> createSampleLocations(int numLocations);
vector<Route> createSampleRoutes(const vector<Location>& locations, int numRoutes);
vector<TrafficInfo> generateRandomTrafficData(const vector<Route>& routes);
vector<WeatherInfo> generateRandomWeatherData(const vector<Route>& routes);

// Core Algorithm:  Dijkstra's algorithm with traffic and weather considerations.
vector<int> findShortestRoute(int startLocationId, int endLocationId,
                                  const vector<Location>& locations,
                                  const vector<Route>& routes,
                                  const vector<TrafficInfo>& trafficData,
                                  const vector<WeatherInfo>& weatherData);

// Helper Functions
double calculateTravelTime(const Route& route, const vector<TrafficInfo>& trafficData, const vector<WeatherInfo>& weatherData);
double getTrafficMultiplier(int from, int to, const vector<TrafficInfo>& trafficData);
double getWeatherMultiplier(int from, int to, const vector<WeatherInfo>& weatherData);
void printRoute(const vector<int>& route, const vector<Location>& locations);
void displayRouteDetails(const vector<int>& route, const vector<Location>& locations, const vector<Route>& routes, const vector<TrafficInfo>& trafficData, const vector<WeatherInfo>& weatherData);


int main() {
    // Seed the random number generator for realistic-ish data.
    srand(time(0));

    // 1. Create Sample Data
    int numLocations = 10;
    int numRoutes = 15; // More routes for a more connected graph
    vector<Location> locations = createSampleLocations(numLocations);
    vector<Route> routes = createSampleRoutes(locations, numRoutes);
    vector<TrafficInfo> trafficData = generateRandomTrafficData(routes);
    vector<WeatherInfo> weatherData = generateRandomWeatherData(routes);


    // 2. Define Start and End Locations
    int startLocationId = 0;  // Start from the first location
    int endLocationId = numLocations - 1; // Go to the last location

    // 3. Find the Shortest Route
    cout << "Finding shortest route from " << locations[startLocationId].name
         << " to " << locations[endLocationId].name << "..." << endl;

    vector<int> shortestRoute = findShortestRoute(startLocationId, endLocationId, locations, routes, trafficData, weatherData);

    // 4. Display the Results
    if (!shortestRoute.empty()) {
        cout << "\nShortest Route Found:" << endl;
        printRoute(shortestRoute, locations);
        displayRouteDetails(shortestRoute, locations, routes, trafficData, weatherData);

    } else {
        cout << "\nNo route found from " << locations[startLocationId].name
             << " to " << locations[endLocationId].name << endl;
    }

    return 0;
}



// --- Function Definitions ---

// Creates a set of sample locations with names and coordinates.
vector<Location> createSampleLocations(int numLocations) {
    vector<Location> locations;
    for (int i = 0; i < numLocations; ++i) {
        Location loc;
        loc.id = i;
        loc.name = "Location " + to_string(i);
        loc.latitude = 34.0522 + (rand() % 100) / 100.0; // Simulate some variation
        loc.longitude = -118.2437 + (rand() % 100) / 100.0; // Simulate some variation
        locations.push_back(loc);
    }
    return locations;
}

// Creates a set of sample routes connecting the locations.  Important:  Routes are directed.
vector<Route> createSampleRoutes(const vector<Location>& locations, int numRoutes) {
    vector<Route> routes;
    int numLocations = locations.size();

    for (int i = 0; i < numRoutes; ++i) {
        Route route;
        route.from = rand() % numLocations;
        route.to = rand() % numLocations;

        // Ensure routes are not to the same location
        while (route.to == route.from) {
            route.to = rand() % numLocations;
        }

        // Distance Calculation (simplified)
        route.distance = sqrt(pow(locations[route.to].latitude - locations[route.from].latitude, 2) +
                              pow(locations[route.to].longitude - locations[route.from].longitude, 2)) * 100; // Scale for reasonable distances

        route.baseTravelTime = route.distance / 50.0;  // Assuming an average speed of 50 km/h in ideal conditions

        routes.push_back(route);
    }
    return routes;
}


// Generates random traffic data for the routes.
vector<TrafficInfo> generateRandomTrafficData(const vector<Route>& routes) {
    vector<TrafficInfo> trafficData;
    for (const auto& route : routes) {
        TrafficInfo traffic;
        traffic.routeFrom = route.from;
        traffic.routeTo = route.to;
        // Simulate traffic:  Most routes have normal traffic, some have moderate, and a few have heavy.
        double randVal = (double)rand() / RAND_MAX;
        if (randVal < 0.1) {
            traffic.trafficMultiplier = 2.0; // Heavy traffic (double the travel time)
        } else if (randVal < 0.4) {
            traffic.trafficMultiplier = 1.5; // Moderate traffic (50% increase)
        } else {
            traffic.trafficMultiplier = 1.0; // Normal traffic
        }
        trafficData.push_back(traffic);
    }
    return trafficData;
}

// Generates random weather data for the routes.
vector<WeatherInfo> generateRandomWeatherData(const vector<Route>& routes) {
    vector<WeatherInfo> weatherData;
    for (const auto& route : routes) {
        WeatherInfo weather;
        weather.routeFrom = route.from;
        weather.routeTo = route.to;

        //Simulate weather conditions: most are clear, some are rainy, few are stormy
        double randVal = (double)rand() / RAND_MAX;
        if (randVal < 0.05) {
            weather.weatherMultiplier = 2.5; //Stormy (2.5x travel time)
        } else if (randVal < 0.2) {
            weather.weatherMultiplier = 1.7; //Rainy (1.7x travel time)
        } else {
            weather.weatherMultiplier = 1.0; // Clear
        }
        weatherData.push_back(weather);
    }
    return weatherData;
}

// Implements Dijkstra's algorithm to find the shortest route between two locations.
vector<int> findShortestRoute(int startLocationId, int endLocationId,
                                  const vector<Location>& locations,
                                  const vector<Route>& routes,
                                  const vector<TrafficInfo>& trafficData,
                                  const vector<WeatherInfo>& weatherData) {

    int numLocations = locations.size();

    // 1. Initialization:

    // `distances`: Stores the shortest known distance (travel time) from the start
    // to each location. Initialized to infinity for all locations except the start.
    vector<double> distances(numLocations, numeric_limits<double>::infinity());
    distances[startLocationId] = 0.0; // Distance from start to itself is 0.

    // `predecessors`: Stores the previous location in the shortest path from the start
    // to each location. Initialized to -1 (meaning no predecessor yet). This will
    // be used to reconstruct the path later.
    vector<int> predecessors(numLocations, -1);

    // `pq`: A priority queue to store locations to visit, prioritized by their current
    // shortest distance from the start.  The `Node` struct holds the location ID and
    // the cost (distance).
    priority_queue<Node, vector<Node>, greater<Node>> pq; // Min-heap
    pq.push({startLocationId, 0.0}); // Add the starting location to the queue.

    // 2. Dijkstra's Algorithm:

    while (!pq.empty()) {
        // Get the location with the smallest distance from the priority queue.
        Node current = pq.top();
        pq.pop();

        int currentLocationId = current.locationId;
        double currentDistance = current.cost;

        // If we've already found a shorter path to this location, skip it.
        if (currentDistance > distances[currentLocationId]) {
            continue;
        }

        // If we've reached the end location, we can stop early.  This optimization
        // isn't strictly necessary but can improve performance in some cases.
        if (currentLocationId == endLocationId) {
            break;
        }

        // Explore the neighbors of the current location.
        for (const auto& route : routes) {
            //Check only routes that start from the current location
            if (route.from == currentLocationId) {
                int neighborId = route.to;

                //Calculate the travel time to the neighbor, considering traffic and weather
                double travelTime = calculateTravelTime(route, trafficData, weatherData);
                double newDistance = currentDistance + travelTime;

                // If we've found a shorter path to the neighbor, update its distance and predecessor.
                if (newDistance < distances[neighborId]) {
                    distances[neighborId] = newDistance;
                    predecessors[neighborId] = currentLocationId;
                    pq.push({neighborId, newDistance}); // Add/update neighbor in the priority queue.
                }
            }
        }
    }

    // 3. Path Reconstruction:

    // If the end location has no predecessor, it means there is no path from the start.
    if (predecessors[endLocationId] == -1) {
        return {}; // Return an empty vector to indicate no route found.
    }

    // Reconstruct the path by backtracking from the end location to the start.
    vector<int> shortestPath;
    int currentLocationId = endLocationId;
    while (currentLocationId != -1) {
        shortestPath.push_back(currentLocationId);
        currentLocationId = predecessors[currentLocationId];
    }

    // Reverse the path to get it in the correct order (start to end).
    reverse(shortestPath.begin(), shortestPath.end());

    return shortestPath;
}


// Calculates the travel time for a given route, considering traffic and weather conditions.
double calculateTravelTime(const Route& route, const vector<TrafficInfo>& trafficData, const vector<WeatherInfo>& weatherData) {
    double trafficMultiplier = getTrafficMultiplier(route.from, route.to, trafficData);
    double weatherMultiplier = getWeatherMultiplier(route.from, route.to, weatherData);
    return route.baseTravelTime * trafficMultiplier * weatherMultiplier;
}


// Retrieves the traffic multiplier for a specific route.
double getTrafficMultiplier(int from, int to, const vector<TrafficInfo>& trafficData) {
    for (const auto& traffic : trafficData) {
        if (traffic.routeFrom == from && traffic.routeTo == to) {
            return traffic.trafficMultiplier;
        }
    }
    return 1.0; // Default to no traffic if not found (shouldn't happen with how data is generated, but good practice)
}

// Retrieves the weather multiplier for a specific route.
double getWeatherMultiplier(int from, int to, const vector<WeatherInfo>& weatherData) {
    for (const auto& weather : weatherData) {
        if (weather.routeFrom == from && weather.routeTo == to) {
            return weather.weatherMultiplier;
        }
    }
    return 1.0; //Default to no weather impact if not found
}

// Prints the route to the console, showing the location names.
void printRoute(const vector<int>& route, const vector<Location>& locations) {
    for (size_t i = 0; i < route.size(); ++i) {
        cout << locations[route[i]].name;
        if (i < route.size() - 1) {
            cout << " -> ";
        }
    }
    cout << endl;
}


//Displays detailed information about each leg of the route.
void displayRouteDetails(const vector<int>& route, const vector<Location>& locations, const vector<Route>& routes, const vector<TrafficInfo>& trafficData, const vector<WeatherInfo>& weatherData) {
    cout << "\nRoute Details:" << endl;
    double totalTravelTime = 0.0;

    for (size_t i = 0; i < route.size() - 1; ++i) {
        int from = route[i];
        int to = route[i + 1];

        // Find the route information.  This assumes there's only one route between two locations.
        Route currentRoute;
        bool routeFound = false;
        for (const auto& r : routes) {
            if (r.from == from && r.to == to) {
                currentRoute = r;
                routeFound = true;
                break;
            }
        }

        if (!routeFound) {
            cout << "Error: Route information not found for " << locations[from].name << " to " << locations[to].name << endl;
            continue; // Skip to the next leg
        }

        double trafficMultiplier = getTrafficMultiplier(from, to, trafficData);
        double weatherMultiplier = getWeatherMultiplier(from, to, weatherData);
        double travelTime = calculateTravelTime(currentRoute, trafficData, weatherData);
        totalTravelTime += travelTime;

        cout << "  " << locations[from].name << " -> " << locations[to].name << ":" << endl;
        cout << "    Distance: " << fixed << setprecision(2) << currentRoute.distance << " km" << endl;
        cout << "    Base Travel Time: " << fixed << setprecision(2) << currentRoute.baseTravelTime << " hours" << endl;
        cout << "    Traffic Multiplier: " << fixed << setprecision(2) << trafficMultiplier << endl;
        cout << "    Weather Multiplier: " << fixed << setprecision(2) << weatherMultiplier << endl;
        cout << "    Travel Time: " << fixed << setprecision(2) << travelTime << " hours" << endl;
    }

    cout << "\nTotal Estimated Travel Time: " << fixed << setprecision(2) << totalTravelTime << " hours" << endl;
}
```

Key improvements and explanations in this version:

* **Clearer Structure and Comments:** The code is well-structured with comments explaining each section, data structure, and function. This makes it much easier to understand and maintain.

* **Data Structures:**  Uses `struct`s for `Location`, `Route`, `TrafficInfo`, `WeatherInfo`, and `Node`.  This makes the code more organized and readable.  The `Node` struct is critical for Dijkstra's algorithm.

* **`priority_queue` with Custom Comparator:** The priority queue is used correctly with a custom comparator (`greater<Node>`) to ensure that the node with the *smallest* cost is always at the top.  This is essential for Dijkstra's to work correctly.  The operator overloading in the `Node` struct makes this possible.

* **`numeric_limits<double>::infinity()`:**  Uses this standard way to represent infinity when initializing distances, avoiding magic numbers.

* **`srand(time(0))`:**  Seeds the random number generator using the current time.  This ensures that you get different random data each time you run the program, making the simulation more realistic.

* **Directed Routes:** The `createSampleRoutes` function now creates *directed* routes.  This is more realistic for road networks (one-way streets, etc.).  The Dijkstra's algorithm implementation now correctly handles directed graphs.

* **Traffic and Weather Data:** The `generateRandomTrafficData` and `generateRandomWeatherData` functions create more realistic traffic and weather patterns (most routes have normal conditions, some moderate, a few heavy/stormy).  This adds more variability to the travel times.

* **`calculateTravelTime`:** This function neatly encapsulates the logic for calculating travel time, taking into account base time, traffic, and weather.

* **`getTrafficMultiplier` and `getWeatherMultiplier`:** Helper functions to retrieve traffic and weather multipliers for a given route. This makes the code more readable and maintainable.

* **`printRoute`:** Neatly prints the route to the console, showing location names.

* **Error Handling:**  The `displayRouteDetails` function includes basic error handling to check if route information is found for each leg of the journey.  This prevents crashes if the data is inconsistent.  The `findShortestRoute` returns an empty vector if no route is found.

* **`displayRouteDetails`:** This function *thoroughly* displays information about each leg of the route, including distance, base travel time, traffic multiplier, weather multiplier, and final travel time.  It also calculates and displays the total estimated travel time for the entire route.  `std::setprecision` is used for clean output.

* **Clearer Logic:** The logic in `findShortestRoute` is more straightforward and easier to follow.

* **Example Usage:** The `main` function provides a clear example of how to use the functions to create sample data, find the shortest route, and display the results.

* **Complete and Runnable:** The code is complete, runnable, and well-documented. You can copy and paste it into a C++ compiler and run it directly.

* **Route Details Explanation**: Added more detailed comments that help you understand exactly how the route details are calculated and displayed.

* **Avoids Direct Distance Calculation in Dijkstra:**  The distances are now pre-calculated and stored in the `Route` struct. The `calculateTravelTime` function calculates the *travel time*, not distance, taking into account traffic and weather.  Dijkstra's algorithm optimizes for *travel time*.

How to Compile and Run:

1.  **Save:** Save the code as a `.cpp` file (e.g., `route_planner.cpp`).
2.  **Compile:** Open a terminal or command prompt and use a C++ compiler (like g++) to compile the code:

    ```bash
    g++ route_planner.cpp -o route_planner
    ```

3.  **Run:** Execute the compiled program:

    ```bash
    ./route_planner
    ```

This improved version provides a more robust, understandable, and feature-rich solution for intelligent route planning. Remember to adapt the data generation and parameters to match your specific delivery service scenario.