Decomposition

#include <string>
#include <iostream>
#include <cassert>
#include <vector>
#include <map>

using namespace std;

enum class QueryType {
    NewBus,
    BusesForStop,
    StopsForBus,
    AllBuses
};

struct Query {
    QueryType type;
    string bus;
    string stop;
    vector<string> stops;
};

istream& operator >> (istream& is, Query& q) {
    // Реализуйте эту функцию
    string query;
    is >> query;
    if (query == "NEW_BUS") {
        q.type = QueryType::NewBus;

        is >> q.bus;

        int stop_count = 0;
        is >> stop_count;
        q.stops.resize(stop_count);
        for (auto& stop : q.stops) {
            is >> stop;
        }
    }
    if (query == "BUSES_FOR_STOP") {
        q.type = QueryType::BusesForStop;
        is >> q.stop;
    }
    if (query == "STOPS_FOR_BUS") {
        q.type = QueryType::StopsForBus;
        is >> q.bus;
    }
    if (query == "ALL_BUSES") {
        q.type = QueryType::AllBuses;
    }
    return is;
}

struct BusesForStopResponse {
    // Наполните полями эту структуру
    vector<string> getBuses;
};

ostream& operator << (ostream& os, const BusesForStopResponse& r) {
    // Реализуйте эту функцию
    if (r.getBuses.size() == 0) {
        os << "No stop";
        os << endl;
    }
    else {
        int i = 1;
        for (const auto& bus : r.getBuses) {
            os << bus;
            if (i < r.getBuses.size()) {
                os << " ";
            }
        }
        os << endl;
    }
    return os;
}

struct StopsForBusResponse {
    // Наполните полями эту структуру
    vector<string> myStops;
    map<string, vector<string>> myMap;
};

ostream& operator << (ostream& os, const StopsForBusResponse& r) {
    // Реализуйте эту функцию
    if (r.myMap.size() == 0) {
        os << "No bus";
        os << endl;
    }
    else {
        int i = 1;
        for (auto& stop : r.myStops) {
            os << "Stop " << stop << ":";
            if (r.myMap.count(stop) == 0) {
                os << " no interchange";
            }
            else {
                for (auto& bus : r.myMap.at(stop)) {
                    os << " " << bus;
                }
            }
            //if (i < r.myStops.size()) {
                os << endl;
            /*}
            i++;*/
        }
    }
    return os;
}

struct AllBusesResponse {
    // Наполните полями эту структуру
    map<string, vector<string>> allBuses;
};

ostream& operator << (ostream& os, const AllBusesResponse& r) {
    // Реализуйте эту функцию
    if (r.allBuses.empty()) {
        os << "No buses";
        os << endl;
    }
    else {
        //int i = 1;
        for (const auto& bus_item : r.allBuses) {
            os << "Bus " << bus_item.first << ":";
            for (const string& stop : bus_item.second) {
                os << " " << stop;
            }
            //if (i < r.allBuses.size()) {
                os << endl;
            /*}
            i++;*/
        }
    }
    return os;
}

class BusManager {
public:
    void AddBus(const string& bus, const vector<string>& stops) {
        // Реализуйте этот метод
        buses_to_stops[bus] = stops;
        for (auto& stop : stops) {
            stops_to_buses[stop].push_back(bus);
        }
    }

    BusesForStopResponse GetBusesForStop(const string& stop) const {
        // Реализуйте этот метод
        BusesForStopResponse getAllBuses;
        if (stops_to_buses.count(stop)) {
            getAllBuses.getBuses = stops_to_buses.at(stop);
        }
        return getAllBuses;
    }

    StopsForBusResponse GetStopsForBus(const string& bus) const {
        // Реализуйте этот метод
        StopsForBusResponse result;
        if (buses_to_stops.count(bus) > 0) {
            for (auto& stop : buses_to_stops.at(bus)) {
                result.myStops.push_back(stop);
                for (auto& bus_n : GetBusesForStop(stop).getBuses) {
                    if (bus_n != bus) {
                        result.myMap[stop].push_back(bus_n);
                    }
                }
            }
        }
        return result;
    }

    AllBusesResponse GetAllBuses() const {
        // Реализуйте этот метод
        AllBusesResponse getAllBuses;
        getAllBuses.allBuses = buses_to_stops;
        return getAllBuses;
    }

private:
    map<string, vector<string>> buses_to_stops, stops_to_buses;
};

// Не меняя тела функции main, реализуйте функции и классы выше

int main() {
    int query_count;
    Query q;

    cin >> query_count;

    BusManager bm;
    for (int i = 0; i < query_count; ++i) {
        cin >> q;
        switch (q.type) {
        case QueryType::NewBus:
            bm.AddBus(q.bus, q.stops);
            break;
        case QueryType::BusesForStop:
            cout << bm.GetBusesForStop(q.stop) << endl;
            break;
        case QueryType::StopsForBus:
            cout << bm.GetStopsForBus(q.bus) << endl;
            break;
        case QueryType::AllBuses:
            cout << bm.GetAllBuses() << endl;
            break;
        }
    }
    return 0;
}