Algorithm 查找其删除将断开图形连接的所有节点对

给定无向连通图，查找其删除会断开该图的所有节点对（由边连接）。
没有平行边，也没有将节点连接到自身的边

这个问题似乎类似于寻找一个连通的、无向图的连接点（或桥）——但有一个扭曲，我们必须移除一对由一条边连接的顶点（以及与该对连接的所有其他边）

这是一个家庭作业问题。我一直在尝试解决这个问题，阅读了有关DFS和关节点算法（即每个节点的深度和低点）的文章，但这些方法都不能解决这个特定的问题。我查阅了科曼的算法简介，但并没有一个合适的主题（当然，这本书有1500页）

虽然发现发音点也会（大多数时候）找到这样的一对，但是有很多对不是关节点的对——考虑一个具有4个顶点、5个边（平方与一个对角线）的图：它有一个这样的对，但是没有关节点（或桥）。p>

---

我迷路了。帮帮我，你是我唯一的希望

断开图的一组k边称为k-割。您正在尝试枚举图的所有2-割

---

描述一种枚举图的所有割的有效算法。应该可以对其进行调整以找到一个图的所有2-割。

一组断开一个图的k边称为k-割。您正在尝试枚举图的所有2-割

---

描述一种枚举图的所有割的有效算法。应该可以对其进行调整，以找到图形的所有2-割。

相当简单，可能不是最有效的：

设图为G=（V，E），其中V:={V_1，…，V_n}。对于V的每个子集V'，设G_V'是包含节点V\V'的节点诱导子图。进一步设N>_v_i:={v_j in v:{v_i，v_j}in E和j>i}是v_i in G的索引大于i的所有邻居的集合。最后，设c（G）是图的连通分量集

按如下方式计算对：

pairs = {}
for each v in V:
    compute G_{v}
    if G_{v} is unconnected:
        for each v' in N>_v:
            # Ensures that removal of v' does not render subgraph connected
            # (Note comment by MkjG)
            if |c(G_{v})| > 2 or {v'} not in c(G_{v}):
                add {v,v'} to pairs
    else:
        for each v' in N>_v:
            compute G_{v,v'}
            if G_{v,v'} unconnected:
                add {v,v'} to pairs

# performs DFS on G for some root node r
c = DFS(G,r)
# computes articulation points of G and corresponding number of components
aps = {}
compCounts = {}
for each v in V:
    numComps = |c(v)|
    if v != r:
        ++numComps
    if numComps > 1:
        add v to aps
        compCounts[v] = numComps
# computes the set of all separator pairs containing at least on ap
S = {}
for each v in aps:
    numComps = compCounts[v]
    for each v' in N_v:
        if numComps > 2:
            # G_{v,v'} has at least two connected components
            add {v,v'} to S
        else:
            # if v' is an isolated node in G_{v}, then G_{v,v'} is connected
            if N_v' != {v}:
                add {v,v'} to S
# computes remaining separator pairs
for each v in V \ aps:
    compute G_{v}
    # performs DFS on G_{v} for some root r_v != v
    c_v = DFS(G_{v},r_v)
    # adds separator pairs for articulation points of G_{v} in N_v
    for each v' in N_v:
        numComps = |c(v')|
        if v' != r_v:
            ++numComps
        if numComps > 1:
            add{v,v'} to S

---

可通过O（m+n）中的DFS或BFS检查连接。因此，运行时应该是O（n*k*（m+n）），其中k是G的最大阶。

相当简单，可能不是最有效的：

设图为G=（V，E），其中V:={V_1，…，V_n}。对于V的每个子集V'，设G_V'是包含节点V\V'的节点诱导子图。进一步设N>_v_i:={v_j in v:{v_i，v_j}in E和j>i}是v_i in G的索引大于i的所有邻居的集合。最后，设c（G）是图的连通分量集

按如下方式计算对：

pairs = {}
for each v in V:
    compute G_{v}
    if G_{v} is unconnected:
        for each v' in N>_v:
            # Ensures that removal of v' does not render subgraph connected
            # (Note comment by MkjG)
            if |c(G_{v})| > 2 or {v'} not in c(G_{v}):
                add {v,v'} to pairs
    else:
        for each v' in N>_v:
            compute G_{v,v'}
            if G_{v,v'} unconnected:
                add {v,v'} to pairs

# performs DFS on G for some root node r
c = DFS(G,r)
# computes articulation points of G and corresponding number of components
aps = {}
compCounts = {}
for each v in V:
    numComps = |c(v)|
    if v != r:
        ++numComps
    if numComps > 1:
        add v to aps
        compCounts[v] = numComps
# computes the set of all separator pairs containing at least on ap
S = {}
for each v in aps:
    numComps = compCounts[v]
    for each v' in N_v:
        if numComps > 2:
            # G_{v,v'} has at least two connected components
            add {v,v'} to S
        else:
            # if v' is an isolated node in G_{v}, then G_{v,v'} is connected
            if N_v' != {v}:
                add {v,v'} to S
# computes remaining separator pairs
for each v in V \ aps:
    compute G_{v}
    # performs DFS on G_{v} for some root r_v != v
    c_v = DFS(G_{v},r_v)
    # adds separator pairs for articulation points of G_{v} in N_v
    for each v' in N_v:
        numComps = |c(v')|
        if v' != r_v:
            ++numComps
        if numComps > 1:
            add{v,v'} to S

---

可通过O（m+n）中的DFS或BFS检查连接。因此，运行时间应该是O（n*k*（m+n）），其中k是G的最大度数。

根据@MkjG的建议，更新我以前的答案，使用DFS计算关节点

设图为G=（V，E），其中V:={V_1，…，V_n}。对于V的每个子集V'，设G_V'是包含节点V\V'的节点诱导子图。对于G连通，如果G{v}不连通，我们称v中的v为连接点。设N_v是G中v的邻域集

铰接点可以通过DFS计算，有关算法的更多信息，请阅读。简言之：

为V中的某个根节点r计算DFS树T

r是一个连接点，当它在T中有多个子节点时

v中的任何其他节点v都是一个连接点，当它在T中有一个子v'时，该子v'满足以下条件：T的子树T'中以v'为根的节点都没有到v的祖先的后缘

设图G上的DFS的结果是v中节点v上的函数c。c（v）是N_v的子集，当满足以下两个条件时，它在c（v）中保持v′：

v'是T中v的子代

根在v'的T的子树T'中没有节点有到v的祖先的后缘

注意，对于T的根节点r，c（r）是r的所有子节点的集合。函数c可以在时间O（n+m）中计算

按如下方式计算分隔符对：

pairs = {}
for each v in V:
    compute G_{v}
    if G_{v} is unconnected:
        for each v' in N>_v:
            # Ensures that removal of v' does not render subgraph connected
            # (Note comment by MkjG)
            if |c(G_{v})| > 2 or {v'} not in c(G_{v}):
                add {v,v'} to pairs
    else:
        for each v' in N>_v:
            compute G_{v,v'}
            if G_{v,v'} unconnected:
                add {v,v'} to pairs

# performs DFS on G for some root node r
c = DFS(G,r)
# computes articulation points of G and corresponding number of components
aps = {}
compCounts = {}
for each v in V:
    numComps = |c(v)|
    if v != r:
        ++numComps
    if numComps > 1:
        add v to aps
        compCounts[v] = numComps
# computes the set of all separator pairs containing at least on ap
S = {}
for each v in aps:
    numComps = compCounts[v]
    for each v' in N_v:
        if numComps > 2:
            # G_{v,v'} has at least two connected components
            add {v,v'} to S
        else:
            # if v' is an isolated node in G_{v}, then G_{v,v'} is connected
            if N_v' != {v}:
                add {v,v'} to S
# computes remaining separator pairs
for each v in V \ aps:
    compute G_{v}
    # performs DFS on G_{v} for some root r_v != v
    c_v = DFS(G_{v},r_v)
    # adds separator pairs for articulation points of G_{v} in N_v
    for each v' in N_v:
        numComps = |c(v')|
        if v' != r_v:
            ++numComps
        if numComps > 1:
            add{v,v'} to S

---

运行时处于O（n*（n+m））

根据@MkjG使用DFS计算关节点的建议，更新我以前的答案

设图为G=（V，E），其中V:={V_1，…，V_n}。对于V的每个子集V'，设G_V'是包含节点V\V'的节点诱导子图。对于G连通，如果G{v}不连通，我们称v中的v为连接点。设N_v是G中v的邻域集

铰接点可以通过DFS计算，有关算法的更多信息，请阅读。简言之：

为V中的某个根节点r计算DFS树T

r是一个连接点，当它在T中有多个子节点时

v中的任何其他节点v都是一个连接点，当它在T中有一个子v'时，该子v'满足以下条件：T的子树T'中以v'为根的节点都没有到v的祖先的后缘

设图G上的DFS的结果是v中节点v上的函数c。c（v）是N_v的子集，当满足以下两个条件时，它在c（v）中保持v′：

v'是T中v的子代

根在v'的T的子树T'中没有节点有到v的祖先的后缘

注意，对于T的根节点r，c（r）是r的所有子节点的集合。函数c可以在时间O（n+m）中计算

按如下方式计算分隔符对：

pairs = {}
for each v in V:
    compute G_{v}
    if G_{v} is unconnected:
        for each v' in N>_v:
            # Ensures that removal of v' does not render subgraph connected
            # (Note comment by MkjG)
            if |c(G_{v})| > 2 or {v'} not in c(G_{v}):
                add {v,v'} to pairs
    else:
        for each v' in N>_v:
            compute G_{v,v'}
            if G_{v,v'} unconnected:
                add {v,v'} to pairs

# performs DFS on G for some root node r
c = DFS(G,r)
# computes articulation points of G and corresponding number of components
aps = {}
compCounts = {}
for each v in V:
    numComps = |c(v)|
    if v != r:
        ++numComps
    if numComps > 1:
        add v to aps
        compCounts[v] = numComps
# computes the set of all separator pairs containing at least on ap
S = {}
for each v in aps:
    numComps = compCounts[v]
    for each v' in N_v:
        if numComps > 2:
            # G_{v,v'} has at least two connected components
            add {v,v'} to S
        else:
            # if v' is an isolated node in G_{v}, then G_{v,v'} is connected
            if N_v' != {v}:
                add {v,v'} to S
# computes remaining separator pairs
for each v in V \ aps:
    compute G_{v}
    # performs DFS on G_{v} for some root r_v != v
    c_v = DFS(G_{v},r_v)
    # adds separator pairs for articulation points of G_{v} in N_v
    for each v' in N_v:
        numComps = |c(v')|
        if v' != r_v:
            ++numComps
        if numComps > 1:
            add{v,v'} to S

---

运行时处于O（n*（n+m））

不幸的是，我无法评论WildHealer给出的答案，但是，我认为这是错误的。作为反例，定义两个k>1的G_1和G_2。添加两个附加节点s_1和s_2。将s_1和s_2与G_1和G_2中的所有节点连接。进一步连接s_1和s_2。显然，移除s_1和s_2会使图形不连接。我没有证明，但我想删除任何k边都不会。两条边绝对不够。因此，2-cuts和pro