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 vector to track which nodes have been processed
    vector<bool> processed(n);

    // 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();

        // Skip the node if it has already been processed
        if (processed[u])
            continue;

        // Mark the node as processed
        processed[u] = true;

        // 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