Minimum Operations Required to Make the Network Connected

In this problem, we are given a network of n components. The components are connected to each other, and the information about the connections is given in the form of a 2D array. Our task in this problem is to find the number of minimum extra connections required such that all the components are connected to one of the components of the network. If there is no way that all the components can be connected, then we will return -1.

Examples:

Input: N = 5, c = [[0, 1], [1, 2], [0, 2], [1, 3], [0, 3]]

Output: 1

Input: N = 6, c = [[0, 1], [1, 2], [0, 2], [1, 3], [0, 3]]

Output: 2

Approach - 1

In this problem, we will use the disjoint set to find the number of extra connections in the given network. A disjoint set is a type of data structure. This data structure stores the sets of elements that do not have any element in common. Hence, the name disjoint set. The number of extra connections will tell us the number of new connections that we can make to connect the whole network. If the number of extra connections is less than the number of components - 1, then there is a way to connect the network, and this network will contain n - 1 edges where n is the total number of nodes in the graph. If the condition is not satisfied, then we will return - 1.

We will follow these steps:

We will make an adjacency list from the given 2D array of connections.
Then, we will create a disjoint set using the disjoint class and pass the number of components.
The next step is to check the number of components in the graph. We will find the number of components using the DFS traversal. The number of times the DFS function will called will be equal to the number of components in the graph.
The last step is to check the condition if the number of components - 1 is less than or equal to the number of extra edges. If yes, then we can connect all the components of the graph.
The final step is to return the minimum number of edges required.

Below is the implementation of the above approach.

Code

# Python program to find the number of operations to make the network connected

# Importing the required library
from typing import List

# Creating a class for the disjoint sets
class DisjointSet:

  # Defining the function to initialize a disjoint set
  def __init__(self, n):

    # The set will contain the rank of items, the parent and the size
    self.r = [0] * (n + 1)
    self.p = list(range(n + 1))
    self.s = [1] * (n + 1)

  # Defnining the function to find the parent nodes
  def findPar(self, n):
    if n == self.p[n]:
      return n
    self.p[n] = self.findPar(self.p[n])
    return self.p[n]

  # Defning the function to find the union of the sets using their ranks
  def Rank(self, u, v):
    pu = self.findPar(u)
    pv = self.findPar(v)
    if pu == pv:
      return
    if self.r[pu] < self.r[pv]:
      self.p[pu] = pv
    elif self.r[pv] < self.r[pu]:
      self.p[pv] = pu
    else:
      self.p[pv] = pu
      self.r[pu] += 1

  # Defning the function to find the union by size
  def Size(self, u, v):
    pu = self.findPar(u)
    pv = self.findPar(v)
    if pu == pv:
      return
    if self.s[pu] < self.s[pv]:
      self.p[pu] = pv
      self.s[pv] += self.s[pu]
    else:
      self.p[pv] = pu
      self.s[pu] += self.s[pv]

# Defining the function to perform the DFS
def dfs(curr, adj, vis):
  if vis[curr]:
    return
  vis[curr] = 1
  for i in adj[curr]:
    dfs(i, adj, vis)

# Creating a network
n = 5
c = [[0, 1], [1, 2], [0, 2], [1, 3], [0, 3]]

# Creating the adjacency list
adj = [[] for _ in range(n + 1)]
for u, v in c:
  adj[u].append(v)
  adj[v].append(u)

# Initializing a disjoint set
ds = DisjointSet(n)
e = 0

# Finding the number of extra connections required
for u, v in c:
  if ds.findPar(u) == ds.findPar(v):
    e += 1
  ds.Size(u, v)

# Creating a visited array
vis = [0] * n

# Performing the DFS on the graph
dfs(0, adj, vis)
ans = 0

# Counting the minimum connections required
for i in range(n):
  if not vis[i]:
    ans += 1
    dfs(i, adj, vis)
if ans <= e:
  print(ans)
else:
  print("The network cannot be connected")
  print(-1)

Output:

Time Complexity: The DFS takes linear time to traverse through all the nodes of the graph. The operations on the disjoint set work in constant time. Since the total number of nodes is n, the time complexity of this approach is O(n).

Space Complexity: We have used extra space to store the set; therefore, the space complexity of this approach is O (e + n), where e is the number of edges and n is the number of nodes.

Approach - 2

In this approach, we will use the minimum spanning tree method to find the minimum number of connections required to connect the whole network.

Minimum Spanning Tree

Suppose we have an undirected graph. The edges of the graph are weighted. The graph has N number of vertices and E number of edges, and let S be the set containing the edges. A minimum spanning tree is the subset of the set S that contains the edges that are enough to span the complete tree or graph and whose total is the minimum weight of all the possible sets of edges. Thus, a minimum spanning tree contains N - 1 number of edges whose total weight is minimum.

We can use this concept in our problem as we also need N - 1 number of connections to connect the whole network.

Let us see the algorithm of this approach:

We will start by initializing a map. In Python, we need to create a dictionary object to utilize the features of a map. This dictionary will store the adjacency list of the given network connections.
We will also create a 2D array of the same size as the adjacency list. We will initialize the array and give 0 value to all the indices. This array will keep track of the visited nodes of the graph, which we will need during the traversal.
Now, using the information on the connections given to us, we will create the adjacency list of the graph. Using the adjacency list, we can count the number of edges in the graph.
Now, as we have created the structure of the graph in the form of the adjacency list, we can use the DFS algorithm to traverse the complete graph and count the total number of connected components in the graph.
Now, we need to calculate the number of extra edges present in the graph. To calculate the number of extra edges, we will use this formula:
- Extra edges = Total number of edges - [(Total number of nodes - 1) - (Total number of components - 1)]
- This will give us the count of the edges that we can remove from the graph.
Now, since the number of connections we can make has an upper limit on the number of connections already present, we need to check if there is a way to connect the network.
We can check this using the condition
- Extra edges > Total number of components - 1
- If this condition is satisfied, then we can connect the disconnected components of the network using these extra edges. The minimum number of edges or connections required to connect the network will be equal to Total number of components - 1.
- If this condition is not satisfied, then we cannot connect the network with the given number of connections, and hence we will return -1.

Below is the implementation of this approach in Python.

Code

# Python program to find the number of operations to make the network connected

# Defnining the function to perform the DFS on the graph
def DFS(adj, n, visited):

 # Checking if th current node is already visited or not
 if (visited[n]):
  # If yes, then return
  return

 # Marking the current node as visited
 visited[n] = True

 # Traversing through the adjacent nodes of the current node
 if(n in adj):
  for x in adj[n]:

   # If the adjacent node is not visited
   if (visited[x] == False):
    # Recursively calling the DFS function
    DFS(adj, x, visited)

# Defining the function to check if we can connect the components
def makeConnected(N, c, M):

 # Initializing an array to store the visited nodes
 visited = [0 for i in range(N)]

 # Initializing a dictionary to store the adjacency list
 adj = {}

 # Initializing a variable to store the edge count
 edges = 0

 # Looping over the given connections to build the adjacency list
 for i in range(M):

   # Adding edges to the graph
   # If the current component is in the connection, then add the component to its list
   if c[i][0] in adj:
    adj[c[i][0]].append(c[i][1])
    edges += 1
   else:
    # Otherwise, creating a new connection for this component
    adj[c[i][0]] = []
    # Doing the same for the second component of the connection
   if c[i][1] in adj:
    adj[c[i][1]].append(c[i][0])
   # Adding the edge count
    edges += 1
   else:
    adj[c[i][1]] = []

 
 # Initializing the variable to count the number of components
 comp = 0

 # Traversing over the nodes
 for i in range(N):

  # If the current is not visited
  if (visited[i] == False):

   # Updating the count of components
   comp += 1

   # Calling the DFS function to perform DFS on the graph
   DFS(adj, i, visited)

 # Checking the count of edges
 if (edges < N - 1):
  return -1

 # Counting the number of redundant edges in the graph
 extra = edges - ((N - 1) - (comp - 1))

 # Checking if we can remove the extra edges in the graph
 if (extra >= (comp - 1)):
  return comp - 1

 return -1

# Defining the function to check if all the components can be connected or not
def Connected(N, c, M):

 # Using the above function to find the minimum edges required to connect the network
 min = makeConnected(N, c, M)

 # Returning the minimum number of edges required for the network to be connected
 print(min)

# Creating a network
n = 5
c = [[0, 1], [1, 2], [0, 2], [1, 3], [0, 3]]
m = len(c)
# Creating the adjacency list
adj = [[] for _ in range(n + 1)]
for u, v in c:
  adj[u].append(v)
  adj[v].append(u)

makeConnected(n, c, m)

Output:

Time Complexity: In this approach, we have used the DFS to find the minimum connections required; hence, the time complexity of this approach is O(n), where n is the number of nodes in the graph.

Space Complexity: We have used extra space to store the array and keep track of the visited nodes. Hence, the space complexity of this approach is O(n).

Next TopicCheck if a variable is a string in python

← prev next →