Articulation Points and Bridges

Articulation Point: removing a particular vertex may result in increasing the number of edges associated with its components of a graph data structure then. These points are called articulation points.

They represent the vulnerabilities in each network provided to the machine for either traversal or prediction. To check for the vulnerabilities using a brute force approach, we hand pick and check each vertex and see if it is an articulation point or if the total count of the components increased or not than the vertex.

Pseudocode Algorithm, which returns the count of total articulation Points

# Here, we are writing down the algorithm to demonstrate the concept of 
# Articulation Points and Bridges with their edge cases, functions, and algorithmic
# loops included articulating the brute force approach 
function find_articulation_points(adj[][], V)
    count = 0
    for i = 0 to V
        visited[i] = false
    initial_val = 0 
    for i = 0 to V
        if visited[i] == false
            DFS(adj, V, visited, i)
            initial_val = initial_val+1
# the below for loop code snippet help us with looping over the entire graph
    for i=0 to V
        for j = 0 to V
            visited[j] = false
            copy[j] = adj[i][j]
            adj[i][j]=adj[j][i]=0
# for loop code snippet helping us with mapping the visited nodes in a graph
        nval = 0
        for j= 0 to V
            if visited[j] == false AND j != i
                nval = nval + 1
                DFS(adj, n, visited, j)
# edge case shielding for the visited nodes in a graph data structure algorithm
        if nval > initial_val
            count = count + 1
        for j= 0 to V
            adj[i][j] = adj[j][i] = copy[j]
            # after the traversal, it returns us the number of articulation points
            # of the given graph structure
    return count
    # end of the Pseudocode algorithm of articulation points 
    # in a graph data structure

Pseudo Code

# Here, we are writing down the algorithm to demonstrate the concept of 
# Articulation Points and Bridges with their edge cases, functions, and algorithmic
# loops included articulating the brute force approach     
time = 0
function DFS(adj[][], disc[], low[], visited[], parent[], AP[], vertex, V)
        visited[vertex] = true
        disc[vertex] = low[vertex] = time+1
        child = 0
    # the below for loop code snippet help us with looping over the entire graph
        for i = 0 to V
                if adj[vertex][i] == true
                        if visited[i] == false
                                child = child + 1
# for loop code snippet helping us with mapping the visited nodes in a graph
                                parent[i] = vertex
                                DFS(adj, disc, low, visited, parent, AP, i, n, time+1)
                                low[vertex] = minimum(low[vertex], low[i])
                                if parent[vertex] == nil and child > 1
                                        AP[vertex] = true
                                if parent[vertex] != nil and low[i] >= disc[vertex]
                                        AP[vertex] = true
# edge case shielding for the visited nodes in a graph data structure algorithm
                        else if parent[vertex] != i
                                low[vertex] = minimum(low[vertex], disc[i])
# after the traversal, it returns us the number of articulation points
# of the given graph structure
# end of the Pseudocode algorithm of articulation points 
# in a graph data structure

Bridges

The bridge is the graph between any two vertices, say x and y. it is called an articulation point. When the connection/bridge is removed, it has no traversal path left. It may also represent the vulnerabilities in each network provided to the machine or system. Like articulation point, we also have to traverse through each vertex of the entire graph data structure in brute force to check for the path available by removing and checking if there is a connection among the vertices.

Pseudo Code

# Here, we are writing down the algorithm to demonstrate the concept of 
# Articulation Points and Bridges with their edge cases, functions, and algorithmic
# loops included articulating the brute force approach     
function find_bridges(adj[][], V, Edge[], E, isBridge[])
    for i = 0 to E
        adj[Edge[i].u][Edge[i].v]=adj[Edge[i].v][Edge[i].u]=0
        for j = 0 to V
            visited[j] = false
        Queue.Insert(Edge[i].u])
        visited[Edge[i].u] = true
        check = false
        while Queue.isEmpty() == false
            x = Queue.top()
            if x == Edge[i].v
                check = true
                BREAK
            Queue.Delete()
# the below for loop code snippet help us with looping over the entire graph
            for j = 0 to V
                if adj[x][j] == true AND visited[j] == false
                    Queue.insert(j)
                    visited[j] = true
        adj[Edge[i].u][Edge[i].v]=adj[Edge[i].v][Edge[i].u]=1
        if check == false
            isBridge[i] = true
# end of the Pseudocode algorithm of articulation points, bridges
    # in a graph data structure

Next TopicExecution of printf with ++ Operators

← prev next →