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.


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

Output: 1
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:






# 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):
    # Function to perform DFS
    def DFS(self, s, visited):
    # Create a stack for DFS
        stack = []
        # Push the current source node
        while (len(stack)):
            # Pop a vertex from stack
            # and print it
            s = stack[-1]
            # 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
# 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)
# 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)




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 or mail your article to 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.