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