C++Advanced-Map and Set - Lab-Cities by Continent and Country

#include<iostream>
#include<vector>
#include<unordered_set>
#include<unordered_map>
#include<string>
#include<sstream>
#include<array>

const int LINE_ATTRIBUTES_COUNT = 3;
const int CONTINENT_IDX = 0;
const int COUNTRY_IDX = 1;
const int CITY_IDX = 2;


std::vector<std::array<std::string, LINE_ATTRIBUTES_COUNT>> readAttributes(int& numbLines) {
    std::vector<std::array<std::string, LINE_ATTRIBUTES_COUNT>> attributes(numbLines);

    for (size_t i = 0; i < numbLines; i++)
    {
        for (size_t j = 0; j < LINE_ATTRIBUTES_COUNT; j++)
        {
            std::cin >> attributes[i][j];

        }
    }

    return attributes;
}

std::vector<std::string> getContinents(const std::vector<std::array<std::string, LINE_ATTRIBUTES_COUNT>>& attributes,
                                       const int numbLines) {
    std::vector<std::string> continents{};

    std::unordered_set<std::string> uniqueContinents{};
    for (size_t i = 0; i < numbLines; i++)
    {
        for (size_t j = 0; j < LINE_ATTRIBUTES_COUNT; j++)
        {
            if (j == CONTINENT_IDX)
            {
                auto it = uniqueContinents.find(attributes[i][CONTINENT_IDX]);
                if (it == uniqueContinents.end())
                {
                    continents.push_back(attributes[i][CONTINENT_IDX]);
                    uniqueContinents.insert(attributes[i][CONTINENT_IDX]);
                }
                break;
            }
        }
    }

    return continents;
}

std::unordered_map<std::string, std::vector<std::string>> getCountries(const std::vector<std::array<std::string, LINE_ATTRIBUTES_COUNT>>& attributes,
                                                   const int numbLines,
                                                   const std::vector<std::string>& continents) {
    std::unordered_map<std::string, std::vector<std::string>> countries{};

    std::unordered_set<std::string> uniqueCountries{};
    for (const auto& continent : continents)
    {
        std::vector<std::string> currContCountries{};
        for (size_t i = 0; i < numbLines; i++)
        {
            for (size_t j = 0; j < LINE_ATTRIBUTES_COUNT; j++)
            {
                if (attributes[i][CONTINENT_IDX] == continent)
                {
                    auto it = uniqueCountries.find(attributes[i][COUNTRY_IDX]);
                    if (it == uniqueCountries.end())
                    {
                        currContCountries.push_back(attributes[i][COUNTRY_IDX]);
                        uniqueCountries.insert(attributes[i][COUNTRY_IDX]);
                        //std::cout << attributes[i][COUNTRY_IDX] << std::endl;
                    }
                    break;
                }
            }
        }
        if (!currContCountries.empty())
        {
            countries[continent] = currContCountries;
        }
    }

    return countries;
}

std::unordered_map<std::string, std::vector<std::string>> getCities(const std::vector<std::array<std::string, LINE_ATTRIBUTES_COUNT>>& attributes,
                                                const int numbLines,
                                                const std::unordered_map<std::string, std::vector<std::string>>& countries) {
    std::unordered_map<std::string, std::vector<std::string>> cities{};

    for (auto it = countries.begin(); it != countries.end(); ++it)
    {
        for (auto& country : it->second)
        {
            std::vector<std::string> currCountryCities{};
            for (size_t i = 0; i < numbLines; i++)
            {
                for (size_t j = 0; j < LINE_ATTRIBUTES_COUNT; j++)
                {
                    if (attributes[i][COUNTRY_IDX] == country) {
                        currCountryCities.push_back(attributes[i][CITY_IDX]);
                    }
                    break;
                }
            }
            cities[country] = currCountryCities;
        }
    }

    return cities;
}

void printSolution(const std::vector<std::string>& continents,
                   const std::unordered_map<std::string, std::vector<std::string>>& countries,
                   const std::unordered_map<std::string, std::vector<std::string>>& cities) {
    const size_t continentsCount = continents.size();
    for (size_t i = 0; i < continentsCount; i++)
    {
        std::cout << continents[i] << ":" << std::endl;
        const auto itCountries = countries.find(continents[i]);
        if (itCountries != countries.end())
        {
            for (const auto& country : itCountries->second)
            {
                std::cout << "  " << country << " -> ";
                const auto itCities = cities.find(country);
                if (itCities != cities.end())
                {
                    std::string result;
                    for (const auto& city : itCities->second)
                    {
                        result.append(city).append(", ");
                    }
                    result.pop_back();
                    result.pop_back();
                    std::cout << result << std::endl;
                }
            }
        }

    }
}

int main() {
    int numbLines = 0;
    std::cin >> numbLines;
    std::cin.ignore();
    const std::vector<std::array<std::string, LINE_ATTRIBUTES_COUNT>> attributes = readAttributes(numbLines);
    const std::vector<std::string> continents = getContinents(attributes, numbLines);
    const std::unordered_map<std::string, std::vector<std::string>> countries = getCountries(attributes, numbLines, continents);
    const std::unordered_map<std::string, std::vector<std::string>> cities = getCities(attributes, numbLines, countries);
    printSolution(continents, countries, cities);
    /*for (const auto& continent : continents)
    {
        std::cout << continent << std::endl;
    }
    std::cout << std::endl;*/

    /*for (auto it = cities.begin(); it != cities.end(); ++it)
    {
        for (auto& country : it->second)
        {
            std::cout << country << ' ';
        }
        std::cout << std::endl;
    }*/

    /*for (auto it = cities.begin(); it != cities.end(); ++it)
    {
        std::queue<std::string> ccc = it->second;
        while (!ccc.empty())
        {
            const auto& city = ccc.front();
            std::cout << city << ' ';
            ccc.pop();
        }
        std::cout << std::endl;
    }*/

    //std::cout << continents.size() << std::endl;
    return 0;
}