图表中的关节点（或切割顶点）

如果移除无向连通图中的顶点（以及通过它的边）断开图的连接，则该顶点是一个连接点（或切割顶点）。连接点代表连接网络中的漏洞——其故障会将网络分成 2 个或更多组件的单点。它们对于设计可靠的网络很有用。

对于断开的无向图，关节点是一个顶点移除，它增加了连接组件的数量。

以下是一些用红色包围的关节点的示例图。

如何找到给定图形中的所有关节点？
一个简单的方法是，一个一个地移除所有顶点，看看移除一个顶点是否会导致图不连贯。以下是连接图的简单方法的步骤。
1) 对于每个顶点 v，执行以下操作
.....a) 从图中删除 v
.....b) 查看图是否保持连接（我们可以使用 BFS 或 DFS）
.....c) 将 v 添加回图表
对于使用邻接表表示的图，上述方法的时间复杂度为 O(V*(V+E))。我们能做得更好吗？

AO(V+E) 算法查找所有关节点 (AP)
这个想法是使用 DFS（深度优先搜索）。在 DFS 中，我们遵循称为 DFS 树的树形式的顶点。在 DFS 树中，一个顶点 u 是另一个顶点 v 的父节点，如果 v 是 u 发现的（显然 v 是图中 u 的相邻节点）。在 DFS 树中，如果以下两个条件之一为真，则顶点 u 是关节点。
1) u 是 DFS 树的根，它至少有两个孩子。
2) u 不是 DFS 树的根，并且它有一个子 v，因此以 v 为根的子树中的任何顶点都没有到 u 的祖先之一（在 DFS 树中）的后边。

下图显示了与上面相同的点，还有一个额外的点，即 DFS 树中的叶子永远不能成为关节点。

我们使用附加代码对给定图进行 DFS 遍历，以找出关节点 (AP)。在 DFS 遍历中，我们维护一个 parent[] 数组，其中 parent[u] 存储顶点 u 的父级。在上述两种情况中，第一种情况比较容易检测。对于每个顶点，计算孩子。如果当前访问的顶点 u 是根节点（parent[u] 是 NIL）并且有两个以上的子节点，则打印它。

第二种情况如何处理？第二种情况更棘手。我们维护一个数组 disc[] 来存储顶点的发现时间。对于每个节点 u，我们需要找出可以从以 u 为根的子树到达的最早访问的顶点（发现时间最短的顶点）。所以我们维护一个额外的数组low[]，定义如下。

low[u] = min(disc[u], disc[w]) 
where w is an ancestor of u and there is a back edge from 
some descendant of u to w.

以下是 Tarjan 寻找关节点的算法的实现。

C++

// C++ program to find articulation points in an undirected graph
#include 
using namespace std;
 
// A recursive function that find articulation
// points using DFS traversal
// adj[] --> Adjacency List representation of the graph
// u --> The vertex to be visited next
// visited[] --> keeps track of visited vertices
// disc[] --> Stores discovery times of visited vertices
// low[] -- >> earliest visited vertex (the vertex with minimum
// discovery time) that can be reached from subtree
// rooted with current vertex
// parent --> Stores the parent vertex in DFS tree
// isAP[] --> Stores articulation points
void APUtil(vector adj[], int u, bool visited[],
            int disc[], int low[], int& time, int parent,
            bool isAP[])
{
    // Count of children in DFS Tree
    int children = 0;
 
    // Mark the current node as visited
    visited[u] = true;
 
    // Initialize discovery time and low value
    disc[u] = low[u] = ++time;
 
    // Go through all vertices adjacent to this
    for (auto v : adj[u]) {
        // If v is not visited yet, then make it a child of u
        // in DFS tree and recur for it
        if (!visited[v]) {
            children++;
            APUtil(adj, v, visited, disc, low, time, u, isAP);
 
            // Check if the subtree rooted with v has
            // a connection to one of the ancestors of u
            low[u] = min(low[u], low[v]);
 
            // If u is not root and low value of one of
            // its child is more than discovery value of u.
            if (parent != -1 && low[v] >= disc[u])
                isAP[u] = true;
        }
 
        // Update low value of u for parent function calls.
        else if (v != parent)
            low[u] = min(low[u], disc[v]);
    }
 
    // If u is root of DFS tree and has two or more children.
    if (parent == -1 && children > 1)
        isAP[u] = true;
}
 
void AP(vector adj[], int V)
{
    int disc[V] = { 0 };
    int low[V];
    bool visited[V] = { false };
    bool isAP[V] = { false };
    int time = 0, par = -1;
 
    // Adding this loop so that the
    // code works even if we are given
    // disconnected graph
    for (int u = 0; u < V; u++)
        if (!visited[u])
            APUtil(adj, u, visited, disc, low,
                   time, par, isAP);
 
    // Printing the APs
    for (int u = 0; u < V; u++)
        if (isAP[u] == true)
            cout << u << " ";
}
 
// Utility function to add an edge
void addEdge(vector adj[], int u, int v)
{
    adj[u].push_back(v);
    adj[v].push_back(u);
}
 
int main()
{
    // Create graphs given in above diagrams
    cout << "Articulation points in first graph \n";
    int V = 5;
    vector adj1[V];
    addEdge(adj1, 1, 0);
    addEdge(adj1, 0, 2);
    addEdge(adj1, 2, 1);
    addEdge(adj1, 0, 3);
    addEdge(adj1, 3, 4);
    AP(adj1, V);
 
    cout << "\nArticulation points in second graph \n";
    V = 4;
    vector adj2[V];
    addEdge(adj2, 0, 1);
    addEdge(adj2, 1, 2);
    addEdge(adj2, 2, 3);
    AP(adj2, V);
 
    cout << "\nArticulation points in third graph \n";
    V = 7;
    vector adj3[V];
    addEdge(adj3, 0, 1);
    addEdge(adj3, 1, 2);
    addEdge(adj3, 2, 0);
    addEdge(adj3, 1, 3);
    addEdge(adj3, 1, 4);
    addEdge(adj3, 1, 6);
    addEdge(adj3, 3, 5);
    addEdge(adj3, 4, 5);
    AP(adj3, V);
 
    return 0;
}

Java

// A Java program to find articulation
// points in an undirected graph
import java.util.*;
 
class Graph {
 
    static int time;
 
    static void addEdge(ArrayList > adj, int u, int v)
    {
        adj.get(u).add(v);
        adj.get(v).add(u);
    }
 
    static void APUtil(ArrayList > adj, int u,
                       boolean visited[], int disc[], int low[],
                       int parent, boolean isAP[])
    {
        // Count of children in DFS Tree
        int children = 0;
 
        // Mark the current node as visited
        visited[u] = true;
 
        // Initialize discovery time and low value
        disc[u] = low[u] = ++time;
 
        // Go through all vertices adjacent to this
        for (Integer v : adj.get(u)) {
            // If v is not visited yet, then make it a child of u
            // in DFS tree and recur for it
            if (!visited[v]) {
                children++;
                APUtil(adj, v, visited, disc, low, u, isAP);
 
                // Check if the subtree rooted with v has
                // a connection to one of the ancestors of u
                low[u] = Math.min(low[u], low[v]);
 
                // If u is not root and low value of one of
                // its child is more than discovery value of u.
                if (parent != -1 && low[v] >= disc[u])
                    isAP[u] = true;
            }
 
            // Update low value of u for parent function calls.
            else if (v != parent)
                low[u] = Math.min(low[u], disc[v]);
        }
 
        // If u is root of DFS tree and has two or more children.
        if (parent == -1 && children > 1)
            isAP[u] = true;
    }
 
    static void AP(ArrayList > adj, int V)
    {
        boolean[] visited = new boolean[V];
        int[] disc = new int[V];
        int[] low = new int[V];
        boolean[] isAP = new boolean[V];
        int time = 0, par = -1;
 
        // Adding this loop so that the
        // code works even if we are given
        // disconnected graph
        for (int u = 0; u < V; u++)
            if (visited[u] == false)
                APUtil(adj, u, visited, disc, low, par, isAP);
 
        for (int u = 0; u < V; u++)
            if (isAP[u] == true)
                System.out.print(u + " ");
        System.out.println();
    }
 
    public static void main(String[] args)
    {
 
        // Creating first example graph
        int V = 5;
        ArrayList > adj1 =
                         new ArrayList >(V);
        for (int i = 0; i < V; i++)
            adj1.add(new ArrayList());
        addEdge(adj1, 1, 0);
        addEdge(adj1, 0, 2);
        addEdge(adj1, 2, 1);
        addEdge(adj1, 0, 3);
        addEdge(adj1, 3, 4);
        System.out.println("Articulation points in first graph");
        AP(adj1, V);
 
        // Creating second example graph
        V = 4;
        ArrayList > adj2 =
                         new ArrayList >(V);
        for (int i = 0; i < V; i++)
            adj2.add(new ArrayList());
 
        addEdge(adj2, 0, 1);
        addEdge(adj2, 1, 2);
        addEdge(adj2, 2, 3);
 
        System.out.println("Articulation points in second graph");
        AP(adj2, V);
 
        // Creating third example graph
        V = 7;
        ArrayList > adj3 =
                            new ArrayList >(V);
        for (int i = 0; i < V; i++)
            adj3.add(new ArrayList());
 
        addEdge(adj3, 0, 1);
        addEdge(adj3, 1, 2);
        addEdge(adj3, 2, 0);
        addEdge(adj3, 1, 3);
        addEdge(adj3, 1, 4);
        addEdge(adj3, 1, 6);
        addEdge(adj3, 3, 5);
        addEdge(adj3, 4, 5);
 
        System.out.println("Articulation points in third graph");
 
        AP(adj3, V);
    }
}

Python3

# Python program to find articulation points in an undirected graph
  
from collections import defaultdict
  
# This class represents an undirected graph
# using adjacency list representation
class Graph:
  
    def __init__(self, vertices):
        self.V = vertices # No. of vertices
        self.graph = defaultdict(list) # default dictionary to store graph
        self.Time = 0
  
    # function to add an edge to graph
    def addEdge(self, u, v):
        self.graph[u].append(v)
        self.graph[v].append(u)
  
    '''A recursive function that find articulation points
    using DFS traversal
    u --> The vertex to be visited next
    visited[] --> keeps track of visited vertices
    disc[] --> Stores discovery times of visited vertices
    parent[] --> Stores parent vertices in DFS tree
    ap[] --> Store articulation points'''
    def APUtil(self, u, visited, ap, parent, low, disc):
 
        # Count of children in current node
        children = 0
 
        # Mark the current node as visited and print it
        visited[u]= True
 
        # Initialize discovery time and low value
        disc[u] = self.Time
        low[u] = self.Time
        self.Time += 1
 
        # Recur for all the vertices adjacent to this vertex
        for v in self.graph[u]:
            # If v is not visited yet, then make it a child of u
            # in DFS tree and recur for it
            if visited[v] == False :
                parent[v] = u
                children += 1
                self.APUtil(v, visited, ap, parent, low, disc)
 
                # Check if the subtree rooted with v has a connection to
                # one of the ancestors of u
                low[u] = min(low[u], low[v])
 
                # u is an articulation point in following cases
                # (1) u is root of DFS tree and has two or more children.
                if parent[u] == -1 and children > 1:
                    ap[u] = True
 
                #(2) If u is not root and low value of one of its child is more
                # than discovery value of u.
                if parent[u] != -1 and low[v] >= disc[u]:
                    ap[u] = True   
                     
                # Update low value of u for parent function calls   
            elif v != parent[u]:
                low[u] = min(low[u], disc[v])
 
 
    # The function to do DFS traversal. It uses recursive APUtil()
    def AP(self):
  
        # Mark all the vertices as not visited
        # and Initialize parent and visited,
        # and ap(articulation point) arrays
        visited = [False] * (self.V)
        disc = [float("Inf")] * (self.V)
        low = [float("Inf")] * (self.V)
        parent = [-1] * (self.V)
        ap = [False] * (self.V) # To store articulation points
 
        # Call the recursive helper function
        # to find articulation points
        # in DFS tree rooted with vertex 'i'
        for i in range(self.V):
            if visited[i] == False:
                self.APUtil(i, visited, ap, parent, low, disc)
 
        for index, value in enumerate (ap):
            if value == True: print (index,end=" ")
 
 # Create a graph given in the above diagram
g1 = Graph(5)
g1.addEdge(1, 0)
g1.addEdge(0, 2)
g1.addEdge(2, 1)
g1.addEdge(0, 3)
g1.addEdge(3, 4)
  
print ("\nArticulation points in first graph ")
g1.AP()
 
g2 = Graph(4)
g2.addEdge(0, 1)
g2.addEdge(1, 2)
g2.addEdge(2, 3)
print ("\nArticulation points in second graph ")
g2.AP()
 
  
g3 = Graph (7)
g3.addEdge(0, 1)
g3.addEdge(1, 2)
g3.addEdge(2, 0)
g3.addEdge(1, 3)
g3.addEdge(1, 4)
g3.addEdge(1, 6)
g3.addEdge(3, 5)
g3.addEdge(4, 5)
print ("\nArticulation points in third graph ")
g3.AP()
 
# This code is contributed by Neelam Yadav

C#

// A C# program to find articulation
// points in an undirected graph
using System;
using System.Collections.Generic;
 
// This class represents an undirected graph
// using adjacency list representation
public class Graph {
    private int V; // No. of vertices
 
    // Array of lists for Adjacency List Representation
    private List[] adj;
    int time = 0;
    static readonly int NIL = -1;
 
    // Constructor
    Graph(int v)
    {
        V = v;
        adj = new List[v];
        for (int i = 0; i < v; ++i)
            adj[i] = new List();
    }
 
    // Function to add an edge into the graph
    void addEdge(int v, int w)
    {
        adj[v].Add(w); // Add w to v's list.
        adj[w].Add(v); // Add v to w's list
    }
 
    // A recursive function that find articulation points using DFS
    // u --> The vertex to be visited next
    // visited[] --> keeps track of visited vertices
    // disc[] --> Stores discovery times of visited vertices
    // parent[] --> Stores parent vertices in DFS tree
    // ap[] --> Store articulation points
    void APUtil(int u, bool[] visited, int[] disc,
                int[] low, int[] parent, bool[] ap)
    {
 
        // Count of children in DFS Tree
        int children = 0;
 
        // Mark the current node as visited
        visited[u] = true;
 
        // Initialize discovery time and low value
        disc[u] = low[u] = ++time;
 
        // Go through all vertices adjacent to this
        foreach(int i in adj[u])
        {
            int v = i; // v is current adjacent of u
 
            // If v is not visited yet, then make it a child of u
            // in DFS tree and recur for it
            if (!visited[v]) {
                children++;
                parent[v] = u;
                APUtil(v, visited, disc, low, parent, ap);
 
                // Check if the subtree rooted with v has
                // a connection to one of the ancestors of u
                low[u] = Math.Min(low[u], low[v]);
 
                // u is an articulation point in following cases
 
                // (1) u is root of DFS tree and has two or more children.
                if (parent[u] == NIL && children > 1)
                    ap[u] = true;
 
                // (2) If u is not root and low value of one of its child
                // is more than discovery value of u.
                if (parent[u] != NIL && low[v] >= disc[u])
                    ap[u] = true;
            }
 
            // Update low value of u for parent function calls.
            else if (v != parent[u])
                low[u] = Math.Min(low[u], disc[v]);
        }
    }
 
    // The function to do DFS traversal.
    // It uses recursive function APUtil()
    void AP()
    {
        // Mark all the vertices as not visited
        bool[] visited = new bool[V];
        int[] disc = new int[V];
        int[] low = new int[V];
        int[] parent = new int[V];
        bool[] ap = new bool[V]; // To store articulation points
 
        // Initialize parent and visited, and
        // ap(articulation point) arrays
        for (int i = 0; i < V; i++) {
            parent[i] = NIL;
            visited[i] = false;
            ap[i] = false;
        }
 
        // Call the recursive helper function to find articulation
        // points in DFS tree rooted with vertex 'i'
        for (int i = 0; i < V; i++)
            if (visited[i] == false)
                APUtil(i, visited, disc, low, parent, ap);
 
        // Now ap[] contains articulation points, print them
        for (int i = 0; i < V; i++)
            if (ap[i] == true)
                Console.Write(i + " ");
    }
 
    // Driver method
    public static void Main(String[] args)
    {
        // Create graphs given in above diagrams
        Console.WriteLine("Articulation points in first graph ");
        Graph g1 = new Graph(5);
        g1.addEdge(1, 0);
        g1.addEdge(0, 2);
        g1.addEdge(2, 1);
        g1.addEdge(0, 3);
        g1.addEdge(3, 4);
        g1.AP();
        Console.WriteLine();
 
        Console.WriteLine("Articulation points in Second graph");
        Graph g2 = new Graph(4);
        g2.addEdge(0, 1);
        g2.addEdge(1, 2);
        g2.addEdge(2, 3);
        g2.AP();
        Console.WriteLine();
 
        Console.WriteLine("Articulation points in Third graph ");
        Graph g3 = new Graph(7);
        g3.addEdge(0, 1);
        g3.addEdge(1, 2);
        g3.addEdge(2, 0);
        g3.addEdge(1, 3);
        g3.addEdge(1, 4);
        g3.addEdge(1, 6);
        g3.addEdge(3, 5);
        g3.addEdge(4, 5);
        g3.AP();
    }
}
 
// This code is contributed by PrinciRaj1992

Javascript

// A Javascript program to find articulation points in an undirected graph
 
// This class represents an undirected graph using adjacency list
// representation
class Graph
{
    // Constructor
    constructor(v)
    {
        this.V = v;
        this.adj = new Array(v);
        this.NIL = -1;
        this.time = 0;
        for (let i=0; i<v; ++i)
            this.adj[i] = [];
    }
     
    //Function to add an edge into the graph
    addEdge(v, w)
    {
        this.adj[v].push(w);  // Add w to v's list.
        this.adj[w].push(v);    //Add v to w's list
    }
     
    // A recursive function that find articulation points using DFS
    // u --> The vertex to be visited next
    // visited[] --> keeps track of visited vertices
    // disc[] --> Stores discovery times of visited vertices
    // parent[] --> Stores parent vertices in DFS tree
    // ap[] --> Store articulation points
    APUtil(u, visited, disc, low, parent, ap)
    {
        // Count of children in DFS Tree
        let children = 0;
  
        // Mark the current node as visited
        visited[u] = true;
  
        // Initialize discovery time and low value
        disc[u] = low[u] = ++this.time;
  
        // Go through all vertices adjacent to this
         
        for(let i of this.adj[u])
        {
            let v = i;  // v is current adjacent of u
  
            // If v is not visited yet, then make it a child of u
            // in DFS tree and recur for it
            if (!visited[v])
            {
                children++;
                parent[v] = u;
                this.APUtil(v, visited, disc, low, parent, ap);
  
                // Check if the subtree rooted with v has a connection to
                // one of the ancestors of u
                low[u]  = Math.min(low[u], low[v]);
  
                // u is an articulation point in following cases
  
                // (1) u is root of DFS tree and has two or more children.
                if (parent[u] == this.NIL && children > 1)
                    ap[u] = true;
  
                // (2) If u is not root and low value of one of its child
                // is more than discovery value of u.
                if (parent[u] != this.NIL && low[v] >= disc[u])
                    ap[u] = true;
            }
  
            // Update low value of u for parent function calls.
            else if (v != parent[u])
                low[u]  = Math.min(low[u], disc[v]);
        }
    }
     
    // The function to do DFS traversal. It uses recursive function APUtil()
    AP()
    {
        // Mark all the vertices as not visited
        let visited = new Array(this.V);
        let disc = new Array(this.V);
        let low = new Array(this.V);
        let parent = new Array(this.V);
        let ap = new Array(this.V); // To store articulation points
  
        // Initialize parent and visited, and ap(articulation point)
        // arrays
        for (let i = 0; i < this.V; i++)
        {
            parent[i] = this.NIL;
            visited[i] = false;
            ap[i] = false;
        }
  
        // Call the recursive helper function to find articulation
        // points in DFS tree rooted with vertex 'i'
        for (let i = 0; i < this.V; i++)
            if (visited[i] == false)
                this.APUtil(i, visited, disc, low, parent, ap);
  
        // Now ap[] contains articulation points, print them
        for (let i = 0; i < this.V; i++)
            if (ap[i] == true)
                document.write(i+" ");
    }
}
 
// Driver method
// Create graphs given in above diagrams
document.write("Articulation points in first graph  <br>");
let g1 = new Graph(5);
g1.addEdge(1, 0);
g1.addEdge(0, 2);
g1.addEdge(2, 1);
g1.addEdge(0, 3);
g1.addEdge(3, 4);
g1.AP();
document.write("<br>");
 
document.write("Articulation points in Second graph <br>");
let g2 = new Graph(4);
g2.addEdge(0, 1);
g2.addEdge(1, 2);
g2.addEdge(2, 3);
g2.AP();
document.write("<br>");
 
document.write("Articulation points in Third graph  <br>");
let g3 = new Graph(7);
g3.addEdge(0, 1);
g3.addEdge(1, 2);
g3.addEdge(2, 0);
g3.addEdge(1, 3);
g3.addEdge(1, 4);
g3.addEdge(1, 6);
g3.addEdge(3, 5);
g3.addEdge(4, 5);
g3.AP();
 
 
// This code is contributed by avanitrachhadiya2155

输出：

Articulation points in first graph
0 3
Articulation points in second graph
1 2
Articulation points in third graph
1

时间复杂度：上述函数是带有附加数组的简单 DFS。因此，时间复杂度与 DFS 相同，即图的邻接表表示的 O(V+E)。