DFS树求割点问题

时间复杂度：O(n玄学)总之不大

代码实现（好麻烦，蓝题变紫题）

 #include<iostream>
 #include<string.h>
 #include<algorithm>
 #include<vector>
 #include<map>
 #include<bitset>
 #include<set>
 #include<string>
 #if !defined(_WIN32)
 #include<bits/stdc++.h>
 #endif // !defined(_WIN32)
 #define ll long long
 #define dd double
 using namespace std;
 int n, m;
 int tot;
 ll ans;
 struct edge
 {
     bool t;
     bool flag;
     int to;
     int num;
     int next;
 }e[];
 struct node
 {
     int son;
     bool flag;
     int f;
     int head;
     int d;
     int deep;
 }p[];
 int vis[];
 void add(int x, int y)
 {
     tot++;
     e[tot].to = y;
     e[tot].next = p[x].head;
     p[x].head = tot;
 }
 bool check(int x)
 {
     for (int i = p[x].head; i; i = e[i].next)
     {
         if (e[i].flag && !e[i].t)
         {
             int to = e[i].to;
             if (!(p[to].d < p[x].deep))
                 return ;
         }
     }
     return ;
 }
 void dfs(int x, int f)
 {
     vis[x] = ;
     p[x].deep = p[f].deep + ;
     p[x].d = p[x].deep;
     for (int i = p[x].head; i; i = e[i].next)
     {
         int to = e[i].to;
         if (!vis[to])
         {
             p[x].son++;
             p[to].f = x;
             e[i].flag = ;
             dfs(to, x);
         }
     }
 }
 void init(int x)
 {
     for (int i = p[x].head; i; i = e[i].next)
     {
         int to = e[i].to;
         if (e[i].flag && !e[i].t)
         {
             init(to);
             p[x].d = min(p[x].d, p[to].d);
         }
     }
 }
 void work()
 {
     for (int x = ; x <= n; x++)
     {
         if (x == )
         {
             if (p[x].son <= )
                 p[x].flag = ;
         }
         else if (p[x].son == )
         {
             p[x].flag = ;
         }
         else
         {
             if (check(x))
                 p[x].flag = ;
         }
     }
 }
 int main()
 {
     cin >> n >> m;
     for (int i = ; i <= m; i++)
     {
         int x, y;
         cin >> x >> y;
         add(x, y);
         add(y, x);
     }
     dfs(, );
     for (int i = ; i <= n; i++)
     {
         for (int j = p[i].head; j; j = e[j].next)
         {
             int to = e[j].to;
             if (!e[j].flag && to != p[i].f)
             {
                 p[i].d = min(p[i].d, p[to].deep);
             }
             else if (to == p[i].f)
             {
                 e[j].t = ;
             }
         }
     }
     init();
     work();
     for (int i = ; i <= n; i++)
     {
         if (!p[i].flag)
             cout << i << endl;
     }
     return ;
 }