/*
    Name: 图的割点（边表集实现）
    Copyright: 
    Author: 巧若拙 
    Date: 20-11-14 21:17
    Description: 
    在一个无向连通图中。假设有一个顶点集合，删除这个顶点集合。以及这个集合中全部顶点相关联的边以后，原图变成多个连通块，就称这个点集为割点集合。
求割点与桥的算法是R.Tarjan发明的。对图深度优先搜索。定义DFS(u)为u在搜索树（下面简称为树）中被遍历到的次序号(等价于时间戳)。
定义Low(u)为u或u的子树中能通过非父子边追溯到的最早的节点。即DFS序号最小的节点的序号。

依据定义，则有：  
Low(u)=Min { DFS(u) ，DFS(v)}，当中 (u,v)为后向边(返祖边) 等价于 DFS(v)<DFS(u)且v不为u的父亲节点 Low(v) (u,v)为树枝边(父子边) 
一个顶点u是割点。当且仅当满足(1)或(2) ：
(1) u为树根。且u有多于一个子树。 
(2) u不为树根。且满足存在(u,v)为树枝边(或称父子边，即u为v在搜索树中的父亲)，使得DFS(u)<=Low(v)。

本文用边表集存储图的信息，实现了递归和非递归两种算法。

*/
#include<stdio.h>
#include<stdlib.h>

#define MAXN 26   //最大变量（顶点）数量 
#define MAXM 100000   //最大关系式数量

typedef char VertexType; //顶点类型由用户自己定义
typedef int EdgeType; //边上的权值类型由用户自己定义

typedef struct Edge{ //边集数组 
    int u, v; //弧尾和弧头 
    int next; //指向同一个弧尾的下一条边 
//    EdgeType weight; //权值，对于非网图能够不须要 
} EdgeLib;

EdgeLib edge[MAXM]; //存储边信息
int first[MAXN]; //指向顶点的第一条边
int flag[MAXN] = {0}; //存储顶点是否为割点 
int num[MAXN] = {0}; //存储顶点的时间戳信息 
int low[MAXN] = {0}; //存储顶点的最小时间戳信息 
int index = 0; //用来进行时间戳的递增

void CreateGraph(int n, int m);//创建一个图
void PrintGraph(int n, int m);//输出图
void CutPoint_DFS(int root, int cur, int father);//採用深度优先搜索寻找割点（递归算法） 
void CutPoint(int root, int n);//採用深度优先搜索寻找割点（非递归算法）

int main()
{
    int i, m, n;
    
    printf("请输入顶点数量和边数量:\n"); 
    scanf("%d%d", &n, &m);    
    
    CreateGraph(n, m);//创建一个图
    PrintGraph(n, m);//输出图
    
 //   CutPoint_DFS(0, 0, 0);//从0号顶点開始深度优先搜索寻找割点（递归算法） 
    CutPoint(0, n);

printf("\n割点为："); 
    for (i=0; i<n; i++)//输出全部割点
    {
        if (flag[i] == 1)
            printf("%d ", i);
    } 
    printf("\n");
    
    return 0;
}

void CreateGraph(int n, int m)//创建一个图
{
    int i;
    
    for (i=0; i<n; i++)//初始化图 
    {
        first[i] = -1;
        num[i] = low[i] = flag[i] = 0;
    }
    
    for (i=0; i<m+m; i+=2)  //读入边信息（注意是无向图） 
    {
        scanf("%d%d", &edge[i].u, &edge[i].v);
        edge[i].next = first[edge[i].u];
        first[edge[i].u] = i;
        
        edge[i+1].u = edge[i].v;
        edge[i+1].v = edge[i].u;
        edge[i+1].next = first[edge[i+1].u];
        first[edge[i+1].u] = i + 1;
    }
}

void PrintGraph(int n, int m)//输出图
{
    int i, j;
    
    for (i=0; i<n; i++)
    {
        printf("%d: ", i);
        j = first[i]; //指向i的第一条边 
        while (j != -1)
        {
            printf("<%d, %d>, ", edge[j].u, edge[j].v);
            j = edge[j].next; //指向下一条边 
        }
        printf("\n");
    }
    printf("\n");
}

void CutPoint_DFS(int root, int cur, int father)//採用深度优先搜索寻找割点（递归算法） 
{
    int k, child = 0;
    
    num[cur] = low[cur] = ++index;
    k = first[cur];
    while (k != -1)
    {
        if (num[edge[k].v] == 0) //新结点做儿子
        {
            child++;
            CutPoint_DFS(root, edge[k].v, cur);
            
            low[cur] = (low[cur] < low[edge[k].v]) ? low[cur] : low[edge[k].v];//取最小值 
            
            if ((cur != root && num[cur] <= low[edge[k].v])
             || (cur == root && child == 2))
            {
                flag[cur] = 1;
            }
        } 
        else if (edge[k].v != father) //与旁系祖先有连接，事实上也能够不加这个限制条件，由于假设父亲是自己则low[cur]值不变 
        {
            low[cur] = (low[cur] < num[edge[k].v]) ?

low[cur] : num[edge[k].v];//取最小值 
        } 
        
        k = edge[k].next;
    }
}

void CutPoint(int root, int n)//採用深度优先搜索寻找割点（非递归算法） 
{
    int Stack[MAXN]; //用来存储当前被处理顶点的栈 
    int SF[MAXN]; //指向顶点的第一条未搜索边
    int child[MAXN] = {0}; //存储顶点的儿子数量 
    int k, u, v, top = 0;
    
    for (u=0; u<n; u++)//初始化SF 
        SF[u] = first[u];
        
    Stack[top] = root;
    num[root] = low[root] = ++index;
    while (top >= 0)
    {
        k = SF[Stack[top]];
        if (k != -1)
        {
        SF[Stack[top]] = edge[k].next; //指向下一条边 
            if (num[edge[k].v] == 0)
            {
                child[Stack[top]]++;
                Stack[++top] = edge[k].v;
                low[edge[k].v] = num[edge[k].v] = ++index;
            }
            else
            {
                low[Stack[top]] = (low[Stack[top]] < num[edge[k].v]) ? low[Stack[top]] : num[edge[k].v];//取最小值
            }
        }
        else
        {
            if (top > 0)
            {
                u = Stack[top-1];
                v = Stack[top];
                low[u] = (low[u] < low[v]) ? low[u] : low[v];
                if ((u != root && low[v] >= num[u])
                 || (u == root && child[u] == 2))
                {
                    flag[u] = 1;
                }
            }
            top--;
        }
    }        
}