#include <iostream>
#include <vector>
#include <queue>
#include <stack>

enum Color { WHITE, GRAY, BLACK };

typedef int                             Node;
typedef std::pair<Node, Node>           Edge;
typedef std::vector<std::vector<Node>>  List;
typedef std::vector<Color>              Colors;

int t = 0;
int k = 0;

void dfs(List& neighbours, Colors& color,
         std::vector<int>& d, std::vector<int>& low_link, 
         std::stack<Node>& s, std::vector<Node>& pi, Node u)
{
    t++;
    color[u] = GRAY;
    d[u] = t;
    s.push(u);

    low_link[u] = d[u];

    for (Node v : neighbours[u]) {
        if (color[v] == WHITE) {
            pi[v] = u;
            dfs(neighbours, color, d, low_link, s, pi, v);

            low_link[u] = std::min(low_link[u], low_link[v]);

        } else {
            if(color[v] != BLACK) {
                low_link[u] = std::min(low_link[u], d[v]);
            }
        }
    }
    
    color[u] = BLACK;
    if (d[u] == low_link[u]) {
        std::cout << "Komponenta #" << ++k << ": ";
        while (1) {
            Node v = s.top(); s.pop();
            std::cout << v << " ";
            if (v == u) {
                std::cout << std::endl;
                break;
            }
        }
    }   
}

void scc(List& neighbours) 
{
    const int n = neighbours.size();

    Colors color(n, WHITE);
    std::vector<int> low_link(n);
    std::vector<int> d(n);
    std::stack<Node> s;
    std::vector<Node> pi(n, -1);

    for (Node u = 0; u < n; u++) {
        if (color[u] == WHITE) {
            dfs(neighbours, color, d, low_link, s, pi, u);
        }
    }
}

int main(void)
{
    List neighbours = {
        {1},
        {2, 4, 5},
        {3, 6},
        {2, 7},
        {0, 5},
        {6},
        {5, 7},
        {7}
    };

    scc(neighbours);
    
    return 0;
}