Maximum number of edges to be removed to contain exactly K connected components in the Graph

Given an undirected graph G with N nodes, M edges, and an integer K, the task is to find the maximum count of edges that can be removed such that there remains exactly K connected components after the removal of edges. If the graph cannot contain K connect components, print -1.

Examples:

Input: N = 4, M = 3, K = 2, Edges[][] = {{1, 2}, {2, 3}, {3, 4}}

Output: 1
Explanation:
One possible way is to remove edge [1, 2]. Then there will be 2 connect components as shown below:

Input: N = 3, M = 3, K = 3, Edges[][] = {{1, 2}, {2, 3}, {3, 1}}

Output: 3
Explanation: All edges can be removed to make 3 connected components as shown below:

Approach: To solve the given problem, count the number of connected components present in the given graph. Let the count be C. Observe that if C is greater than K then no possible edge removal can generate K connected components as the number of connected components will only increase. Otherwise, the answer will always exist.



Following observations need to be made in order to solve the problem:

  • Suppose C1, C2, …, Cc, are the number of node in each connected component. Then, each component must have edges as C1 – 1, C2 – 1, …, C-1 after edges are removed. Therefore,

    C1 – 1 + C2 – 1 + … + Cc – 1 = C1 + C2 + … + Cc – C = N – C, where N is the number of nodes.

  • The above condition will give us the C connected components by removing M – (N – C) edges as N – C edges are needed to make C components. To get K components, (K – C) more edges must be removed.
  • Hence, the total count of edges to be removed is given by:

    M – (N – C) + (K – C) = M – N + K

Follow the steps below to solve the problem:

  1. Count the number of connected components present in the given graph. Let the count be C.
  2. If C is greater than K, print -1.
  3. Else print M – N + K where N is the number f nodes, M is the number of edges and K is the required number of connected components.

Below is the implementation of the above approach:

Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python program for the above approach
  
class Graph:
  
    # Constructor
    def __init__(self, V):
  
        # No. of vertices
        self.V = V
  
        # Dictionary of lists
        self.adj = {i: [] for i in range(1, V + 1)}
  
    # Function to add edge
    # in the graph
    def addEdge(self, v, w):
        self.adj[v].append(w)
        self.adj[w].append(v)
  
    # Function to perform DFS
    def DFS(self, s, visited):
  
    # Create a stack for DFS
        stack = []
  
        # Push the current source node
        stack.append(s)
        while (len(stack)):
  
            # Pop a vertex from stack
            # and print it
            s = stack[-1]
            stack.pop()
  
            # Traverse adjacent vertices
            # of the popped vertex s
            for node in self.adj[s]:
                if (not visited[node]):
  
                    # If adjacent is unvisited,
                    # push it to the stack
                    visited[node] = True
                    stack.append(node)
  
# Function to return the count 
# edges removed
def countRemovedEdges(N, M, K):
  
    C = 0
  
    # Initially mark all verices
    # as not visited
    visited = [False for i in range(g.V + 1)]
  
    for node in range(1, N + 1):
  
        # If node is unvisited
        if (not visited[node]):
  
            # Increment Connected
            # component count by 1
            C = C + 1
  
            # Perform DFS Traversal
            g.DFS(node, visited)
  
    # Print the result
    if C <= K:
        print(M - N + K)
    else:
        print(-1)
  
  
# Driver Code
  
N, M, K = 4, 3, 2
  
# Create Graph
g = Graph(N)
  
# Given Edges
g.addEdge(1, 2)
g.addEdge(2, 3)
g.addEdge(3, 4)
  
# Function Call
countRemovedEdges(N, M, K)

chevron_right


Output:

1

Time Complexity: O(N + M)
Auxiliary Space: O(M + N)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.




My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.