Sadonkorjuu

input/code.cpp: In function 'void bfs(const Graph&, int*, int)':
input/code.cpp:43:5: warning: this 'for' clause does not guard... [-Wmisleading-indentation]
   43 |     for (int i = 0; i < n; i++)
      |     ^~~
input/code.cpp:47:9: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'for'
   47 |         deque<int> q;
      |         ^~~~~

#include <iostream>
#include <deque>
#include <unordered_set>
#include<vector>
 
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 breadth-first search
void bfs(const Graph& graph, int* distances, int source)
{
    // Initialize distances to all nodes as infinite
    int n = graph.edges.size();
    for (int i = 0; i < n; i++)
        distances[i] = -1;
 
        // Create a deque to store the nodes that need to be processed
        deque<int> q;
 
    // Add the source node to the deque with distance 0
    distances[source] = 0;
    q.push_back(source);
 
    // Process nodes in the deque until it is empty
    while (!q.empty())
    {
        // Get the next node in the deque
        int u = q.front();
        q.pop_front();
 
        // Iterate through
            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;
                        q.push_back(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
    unordered_set<int> sunflower_fields;
    unordered_set<int> ports;
    for (int i = 0; i < n; i++)
    {
        if (city_types[i] == 0)
            ports.insert(i);
        else if (city_types[i] == 1)
            sunflower_fields.insert(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
        int* distances = new int[n];
        bfs(graph, distances, field);
 
        // Find the port with the smallest distance to the sunflower field
        int min_distance = -1;
        for (int port : ports)
        {
            if (distances[port] != -1 && (min_distance == -1 || distances[port] < min_distance))
                min_distance = distances[port];
        }
 
        // Add the distance to the total distance
        total_distance += min_distance;
 
        // Free the memory used by the array
        delete[] distances;
    }
 
    // 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