Sadonkorjuu

input/code.cpp: In member function 'void Node::addDistance(int)':
input/code.cpp:14:25: warning: comparison of integer expressions of different signedness: 'int' and 'long long unsigned int' [-Wsign-compare]
   14 |         if(testDistance < distance){
      |            ~~~~~~~~~~~~~^~~~~~~~~~
input/code.cpp: In function 'int main()':
input/code.cpp:36:9: warning: unused variable 'tempNumber' [-Wunused-variable]
   36 |     int tempNumber;
      |         ^~~~~~~~~~

#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(int testDistance){
        if(testDistance < distance){
            distance = testDistance;
        }
    }
};
 
int GenerateKey(int a, int b){
    return a*a+b*b;
}
 
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);
    //vector<int> Ports;
    set<int> Ports;
    unordered_map<int, int> Connections(NodeCount-1);
    //fill(RoadDict.begin(), RoadDict.end(), new vector<int[2]>);
    //Ports.reserve(NodeCount);
    int tempNumber;
    for (int i = 0; i < NodeCount; i++)
    {
    cin >> NodeStates[i];
    }
    int cacheArray[] = {0,0};
    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;
        //vector<int[2]> temp(RoadDict[0]);
        //temp.push_back(bruh[0]);
        //auto& mingus = RoadDict[0];
        //mingus.pop_back();
        RoadDict[cacheArray[0]].push_back(vector<int>{cacheArray[1], Distance});
        RoadDict[cacheArray[1]].push_back(vector<int>{cacheArray[0], Distance});
        //temp.emplace_back({2,2});
        //RoadDict[bruh[0][0]] = bruh;
        //RoadDict[cacheArray[0]].push_back(bruh[0]);
        //bruh[0][0] = cacheArray[0];
        //RoadDict.try_emplace(bruh[0][0], bruh);
        
        //bruh[0][0] = cacheArray[1];
        //RoadDict.try_emplace(bruh[0][0], bruh); 
        //bruh = &RoadDict.at(cacheArray[0]);
        //bruh->push_back({cacheArray[1], Distance});
        if(!NodeStates[cacheArray[1]]){
            //Ports.push_back(cacheArray[1]);
            Ports.insert(cacheArray[1]);
            //Ports[cacheArray[1]] = 0;
        }
        if(!NodeStates[cacheArray[0]]){
            //Ports.push_back(cacheArray[0]);
            Ports.insert(cacheArray[0]);
            //Ports[cacheArray[0]] = 0;
        }
        Connections[GenerateKey(cacheArray[0], cacheArray[1])] = Distance;
    }
    
    vector<Node> NodeList(NodeCount, Node());
    //NodeList.emplace_back(NodeCount);
    for (int i = 0; i < NodeCount; i++)
    {
        NodeList.at(i).Value = i;
        if(!NodeStates[i]){
            NodeList[i].addDistance(0);
        }
    }
    vector<Node> PortNodes;
    //PortNodes.emplace_back(Ports.size());
    NodeList.reserve(Ports.size());
    for (int i : Ports)
    {
        PortNodes.push_back(NodeList[i]);
    }
 
    //Actual BFS solution:
    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++){
                //vector<int[2]> *neighbor = &;
                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);
                    //int sum = Connections.at(GenerateKey(nodeValue, neighborValue));
                    //int sum = 0;
                    //supplementing for connection method, sicne i cant work pointers for shit: 
                    neighborNode.addDistance(Connections.at(GenerateKey(nodeValue, neighborValue))+(*node).distance);
                }
            }
        }
    }
    unsigned long long int sum = 0;
    for(Node node : NodeList){
        sum += node.distance;
    }
    cout << sum << endl;
}
 

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: WRONG ANSWER

Test 7

Group: 2

Verdict: WRONG ANSWER

Test 8

Group: 1, 2

Verdict: WRONG ANSWER

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: WRONG ANSWER

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: WRONG ANSWER