# 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: ## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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

 `# 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) `

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.

Article Tags :
Practice Tags :

5

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.