Sadonkorjuu

input/code.cpp: In function 'int main()':
input/code.cpp:100:28: warning: comparison of integer expressions of different signedness: 'std::unordered_map<long long unsigned int, long long unsigned int>::size_type' {aka 'long unsigned int'} and 'int' [-Wsign-compare]
  100 |      if(Connections.size() != NodeCount-1){
      |         ~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~

 
#include <vector>
#include <iostream>
#include <unordered_map>
#include <map>
#include <numeric>
#include <set>
#include <deque>
using namespace std;
 
struct Node{
    int Value;
    unsigned long long int distance = -1; 
    void addDistance(unsigned long long int testDistance){ 
 
        if(testDistance < distance){
 
            distance = testDistance;
 
        }
 
    }
 
};
 
unsigned long long int GenerateKey(unsigned long long int a, unsigned long long int b){ 
 
    if(a>b){
 
        swap(a, b);
 
    }
 
    return ((a + b) * (a + b + 1) )/ 2 + a;
}
 
int main(){
 
        ios_base::sync_with_stdio(false); 
 
    cin.tie(NULL); 
 
    int NodeCount;
 
    cin >> NodeCount; 
 
     vector<int> NodeStates(NodeCount); 
 
    unordered_map<int,vector<vector<int>>> RoadDict(NodeCount); 
     set<int> Ports; 
 
    unordered_map<unsigned long long int, unsigned long long int> Connections(NodeCount-1); 
 
    
 for (int i = 0; i < NodeCount; i++)
    {
 
        cin >> NodeStates[i]; 
 
    }
 
     int cacheArray[] = {0,0}; 
 
    unsigned long long int Distance = 0; 
 
     vector<int[2]> bruh(1); 
    
    for (int i = 0; i < NodeCount-1; i++)
    {
 
        for(int j = 0; j < 2; j++){
 
            cin >> cacheArray[j]; 
 
            cacheArray[j] --; 
 
        }
 
        cin >> Distance; 
         RoadDict[cacheArray[0]].push_back(vector<int>{cacheArray[1], (int)Distance}); 
 
        RoadDict[cacheArray[1]].push_back(vector<int>{cacheArray[0], (int)Distance});
 
         if(!NodeStates[cacheArray[1]]){ 
        
            Ports.insert(cacheArray[1]);
          
        }
 
        if(!NodeStates[cacheArray[0]]){ 
          
            Ports.insert(cacheArray[0]);
      
        }
 
        Connections[GenerateKey(cacheArray[0], cacheArray[1])] = Distance; 
 
    }
 
     if(Connections.size() != NodeCount-1){ 
        throw runtime_error("Duplicate connections found");
    }
 
     vector<Node> NodeList(NodeCount, Node()); 
 
    for (int i = 0; i < NodeCount; i++)
    {
 
        NodeList.at(i).Value = i; 
 
         if(!NodeStates[i]){ 
            NodeList[i].addDistance(0);
        }
 
    }
 
     vector<Node> PortNodes; 
  
    NodeList.reserve(Ports.size()); 
 
    for (int i : Ports)
    {
 
        PortNodes.push_back(NodeList[i]); 
 
    }
 
 
 
     for(Node startingNode : PortNodes){ 
 
        Node* node(&startingNode); 
 
         int startingNodeValue = startingNode.Value; 
 
         vector<bool> travelledNodes(NodeCount, false); 
 
        deque<Node*> Queue; 
 
        Queue.push_back(&startingNode); 
 
        travelledNodes[startingNodeValue] = true; 
    
    while(Queue.size()){ 
 
            node = Queue.front(); 
 
            Queue.pop_front(); 
 
             int nodeValue = (*node).Value; 
 
            for(int i = 0; i < (int)RoadDict[nodeValue].size(); i++){
           
                int neighborValue = RoadDict[nodeValue][i][0]; 
                 Node& neighborNode = NodeList[neighborValue]; 
 
                if(!NodeStates[neighborValue]){ 
                    travelledNodes[neighborValue] = true;
                }
 
                else if(!travelledNodes[neighborValue]){ 
                    travelledNodes[neighborValue] = true;
                    Queue.push_back(&neighborNode);
                  
                    
 
                     neighborNode.addDistance(Connections.at(GenerateKey(nodeValue, neighborValue))+(*node).distance); 
                }
 
            }
 
        }
 
    }
 
     unsigned long long int sum = 0; 
 
    for(Node node : NodeList){ 
        sum += node.distance;
    }
 
    cout << sum; 
}

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: ACCEPTED

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: ACCEPTED

Test 12

Group: 2

Verdict: ACCEPTED

Test 13

Group: 2

Verdict: ACCEPTED

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: ACCEPTED

Test 23

Group: 2

Verdict: ACCEPTED

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: ACCEPTED

Test 30

Group: 1, 2

Verdict: ACCEPTED

Test 31

Group: 2

Verdict: ACCEPTED