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

enum Color { WHITE, GRAY, BLACK };

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

int t = 0;

void dfs(List& neigbours, Colors& color,
         std::vector<int>& d, std::vector<int>& low_link, 
         std::vector<bool>& point, std::vector<Node>& pi, Node u)
{
    t++;
    color[u] = GRAY;
    d[u] = t;

    low_link[u] = d[u];
    int num_children = 0;

    for (int v : neigbours[u]) {
        if (color[v] == WHITE) {
            num_children++;
            pi[v] = u;
            dfs(neigbours, color, d, low_link, point, pi, v);

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

            if (pi[u] == -1 && num_children > 1) {
                point[u] = true;
            }

            if (pi[u] != -1 && low_link[v] >= d[u]) {
                point[u] = true;
            }
        } else {
            if (pi[u] != v) {
                low_link[u] = std::min(low_link[u], d[v]);
            }
        }
    }
    
    color[u] = BLACK;
}

void articulation_points(List& neigbours) 
{
    const int n = neigbours.size();

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

    dfs(neigbours, color, d, low_link, point, pi, 0);

    for (Node u = 0; u < n; u++) {
        if (point[u]) {
            std::cout << u << std::endl;
        }
    }

}

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

    articulation_points(neigbours);
    
    return 0;
}