深搜求割点（邻接矩阵和邻接表）

 思想：

如果父节点的任一子节点在不经过父节点的情况下不能到达祖先节点，父节点即为割点

父节点dfs找到子节点再对子节点dfs看能不能在不经过父节点的情况下到达祖先节点

以下代码dfs：每个点直走一次的那种

时间复杂度：O(n^2) ，用邻接表的话O(n+m)

#include <iostream>  //下面有数据验证
using namespace std;
int flag[20];
int num[20];  //num[i]表示节点编号为i的时间戳
int low[20];  //low[i]表示节点i在不经过父节点时能到达的最早节点的时间戳（这两个数组存储的都是时间戳）
int e[40][40];  //e[u][v]为1 表示u 和 v 有边
int root;    //根节点我们固定为1，从1开始dfs
int idx;    //时间戳
int n,m;
void dfs(int cur,int father){
    idx++;
    num[cur]=idx;  //确定这点的时间戳
    low[cur]=idx;  //不经过父节点刚开始暂定为自己为能到达的最早节点
    int i;
    int child=0;  //这个节点的儿子数
    for(i=1;i<=n;i++){
        if(e[cur][i]==1){
            if(num[i]==0){ //表示这点还没有走过
                //此时i可以理解为cur的儿子节点
                child++;
                dfs(i,cur);//走到i点
                low[cur]=min(low[cur],low[i]); //不经过父节点经过儿子节点（doge）
                if(cur!=root&&low[i]>=num[cur]){ //不经过父节点能到达的最早节点的时间戳大于等于父节点的时间戳
                    flag[cur]=1;//cur是i的父节点                 //表示父节点 是割点
                }
                if(cur==root&&child==2){
                    flag[cur]=1;
                }
            }else if(i!=father){ 
                //此时i可以理解为cur的祖先节点的编号
                low[cur]=min(low[cur],num[i]);  //不经过父节点，但自己跟祖先节点有边
            }
        }
    }
    return ;
}
int main (){
    cin>>n>>m;
    int i;
    for(i=1;i<=m;i++){
        int x,y;
        cin>>x>>y;
        e[x][y]=1;
        e[y][x]=1;
    }
    root=1;
    dfs(1,root);
    for(i=1;i<=n;i++){
        if(flag[i]==1){
            cout<<i<<endl;
        }
    }
    return 0;
}
/*输入
6 7
1 4
1 3
4 2
3 2
2 5
2 6
5 6
*/
/*输出
2
*/

下面是邻接表的代码：

#include <iostream>
using namespace std;
int first[20];
int then[20];
int u[20],v[20],w[20];
int flag[20];
int num[20];  //num[i]表示节点编号为i的时间戳
int low[20];  //low[i]表示节点i在不经过父节点时能到达的最早节点的时间戳（这两个数组存储的都是时间戳）
//int e[40][40];  //e[u][v]为1 表示u 和 v 有边
int root;    //根节点我们固定为1，从1开始dfs
int idx;    //时间戳
int n,m;
void dfs(int cur,int father){
    idx++;
    num[cur]=idx;  //确定这点的时间戳
    low[cur]=idx;  //不经过父节点刚开始暂定为自己为能到达的最早节点
    int child=0;  //这个节点的儿子数
    int k=first[cur];
    while(k!=-1){
        if(num[v[k]]==0){
            child++;
            dfs(v[k],cur);
            low[cur]=min(low[cur],low[v[k]]);
            if(cur!=root&&low[v[k]]>=num[cur]){
                flag[cur]=1;
            }
            if(cur==root&&child==2){
                flag[cur]=1;
            }
        }else if(v[k]!=father){
            low[cur]=min(low[cur],num[v[k]]);
        }
        k=then[k];
    }
    // for(i=1;i<=n;i++){
    //     if(e[cur][i]==1){
    //         if(num[i]==0){
    //             //此时i可以理解为cur的儿子节点
    //             child++;
    //             dfs(i,cur);
    //             low[cur]=min(low[cur],low[i]); //不经过父节点经过儿子节点（doge）
    //             if(cur!=root&&low[i]>=num[cur]){ //不经过父节点能到达的最早节点的时间戳大于等于父节点的时间戳
    //                 flag[cur]=1;                 //表示父节点 是割点
    //             }
    //             if(cur==root&&child==2){
    //                 flag[cur]=1;
    //             }
    //         }else if(i!=father){ 
    //             //此时i可以理解为cur的祖先节点的编号
    //             low[cur]=min(low[cur],num[i]);  //不经过父节点，但自己跟祖先节点有边
    //         }
    //     }
    // }
    return ;
}
int main (){
    cin>>n>>m;
    int i;
    for(i=1;i<=m;i++){
        cin>>u[i]>>v[i];
    }
    for(i=m+1;i<=2*m;i++){
        u[i]=v[i-m];
        v[i]=u[i-m];
    }
    for(i=1;i<=n;i++){
        first[i]=-1;
    }
    for(i=1;i<=2*m;i++){
        then[i]=first[u[i]];
        first[u[i]]=i;
    }
    root=1;
    dfs(1,root);
    for(i=1;i<=n;i++){
        if(flag[i]==1){
            cout<<i<<endl;
        }
    }
    return 0;
}
/*输入
6 7
1 4
1 3
4 2
3 2
2 5
2 6
5 6
*/
/*输出
2
*/