Sadonkorjuu

#include <iostream>
#include <vector>
#include <queue>
 
using namespace std;
 
// Edge class that represents an edge in the graph
class Edge
{
public:
    int to;   // The index of the node that this edge leads to
    int cost; // The cost of traveling along this edge
 
    // Constructor to initialize the edge
    Edge(int to, int cost) : to(to), cost(cost) {}
};
 
// Graph class that represents a graph with nodes and edges
class Graph
{
public:
    vector<vector<Edge>> edges; // Adjacency list that stores the edges for each node
 
    // Constructor to initialize the graph with n nodes
    Graph(int n) : edges(n) {}
 
    // Adds a new edge to the graph from node u to node v with the given cost
    void addEdge(int u, int v, int cost)
    {
        edges[u].push_back(Edge(v, cost));
        edges[v].push_back(Edge(u, cost));
    }
};
 
// A utility function to find the shortest distances from the source node to all other nodes in the graph
// using Dijkstra's algorithm
void dijkstra(const Graph& graph, vector<int>& distances, int source)
{
    // Initialize distances to all nodes as infinite
    int n = graph.edges.size();
    distances.assign(n, -1);
 
    // Create a priority queue to store the nodes that need to be processed
    auto cmp = [](pair<int, int>& a, pair<int, int>& b) { return a.first > b.first; };
    priority_queue<pair<int, int>, vector<pair<int, int>>, decltype(cmp)> pq(cmp);
 
    // Add the source node to the priority queue with distance 0
    distances[source] = 0;
    pq.push({ 0, source });
 
    // Process nodes in the priority queue until it is empty
    while (!pq.empty())
    {
        // Get the node with the smallest distance
        int u = pq.top().second;
        pq.pop();
 
        // Iterate through the edges of the node
        for (Edge edge : graph.edges[u])
        {
            // Calculate the new distance to the adjacent node
            int v = edge.to;
            int new_distance = distances[u] + edge.cost;
 
            // If the new distance is smaller than the current distance, update the distance
            if (distances[v] == -1 || new_distance < distances[v])
            {
                distances[v] = new_distance;
                pq.push({ new_distance, v });
            }
        }
    }
}
 
int main()
{
    int n;
 
    // Read the number of cities
    cin >> n;
 
    // Read the type of each city
    vector<int> city_types(n);
    for (int& type : city_types)
        cin >> type;
 
    // Create a graph with n nodes
    Graph graph(n);
 
    // Read the roads and add them to the graph
    for (int i = 0; i < n - 1; i++)
    {
        int u, v, cost;
        cin >> u >> v >> cost;
        graph.addEdge(u - 1, v - 1, cost);
    }
 
    
    // Find the indices of the sunflower fields and ports
    vector<int> sunflower_fields;
    vector<int> ports;
    for (int i = 0; i < n; i++)
    {
        if (city_types[i] == 0)
            ports.push_back(i);
        else if (city_types[i] == 1)
            sunflower_fields.push_back(i);
    }
 
    // Calculate the shortest distance from each sunflower field to a port
    int total_distance = 0;
    for (int field : sunflower_fields)
    {
        // Calculate the shortest distances from the current sunflower field to all nodes in the graph
        vector<int> distances;
        dijkstra(graph, distances, field);
 
        // Find the port that is closest to the current sunflower field
        int min_distance = -1;
        for (int port : ports)
        {
            if (min_distance == -1 || distances[port] < min_distance)
                min_distance = distances[port];
        }
 
        // Add the distance to the total distance
        total_distance += min_distance;
    }
 
    // Print the total distance
    cout << total_distance << endl;
 
    return 0;
}
 

Test 1

Group: 1, 2

Verdict: ACCEPTED

Test 2

Group: 1, 2

Verdict: ACCEPTED

Test 3

Group: 1, 2

Verdict: ACCEPTED

Test 4

Group: 1, 2

Verdict: ACCEPTED

Test 5

Group: 1, 2

Verdict: ACCEPTED

Test 6

Group: 1, 2

Verdict: ACCEPTED

Test 7

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 8

Group: 1, 2

Verdict: ACCEPTED

Test 9

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 10

Group: 1, 2

Verdict: ACCEPTED

Test 11

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 12

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 13

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 14

Group: 2

Verdict: ACCEPTED

Test 15

Group: 1, 2

Verdict: ACCEPTED

Test 16

Group: 1, 2

Verdict: ACCEPTED

Test 17

Group: 1, 2

Verdict: ACCEPTED

Test 18

Group: 1, 2

Verdict: ACCEPTED

Test 19

Group: 1, 2

Verdict: ACCEPTED

Test 20

Group: 1, 2

Verdict: ACCEPTED

Test 21

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 22

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 23

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 24

Group: 1, 2

Verdict: ACCEPTED

Test 25

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 26

Group: 1, 2

Verdict: ACCEPTED

Test 27

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 28

Group: 1, 2

Verdict: ACCEPTED

Test 29

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 30

Group: 1, 2

Verdict: ACCEPTED

Test 31

Group: 2

Verdict: TIME LIMIT EXCEEDED