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, …, Cc -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:
- Count the number of connected components present in the given graph. Let the count be C.
- If C is greater than K, print -1.
- 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:
C++
#include <bits/stdc++.h>
using namespace std;
class Graph
{
public :
int V;
map< int , vector< int >> adj;
Graph( int );
void addEdge( int , int );
void DFS( int , vector< bool > &);
} * g;
Graph::Graph( int V)
{
this ->V = V;
for ( int i = 1; i <= V; i++)
adj[i] = vector< int >();
}
void Graph::addEdge( int v, int w)
{
adj[v].push_back(w);
adj[w].push_back(v);
}
void Graph::DFS( int s, vector< bool > &visited)
{
stack< int > stack;
stack.push(s);
while (!stack.empty())
{
s = stack.top();
stack.pop();
for ( auto node : adj[s])
{
if (!visited[node])
{
visited[node] = true ;
stack.push(node);
}
}
}
}
void countRemovedEdges( int N, int M, int K)
{
int C = 0;
vector< bool > visited(g->V + 1, false );
for ( int node = 1; node <= N; node++)
{
if (!visited[node])
{
C = C + 1;
g->DFS(node, visited);
if (C <= K)
cout << M - N + K << endl;
else
cout << -1 << endl;
}
}
}
int main( int argc, char const *argv[])
{
int N = 4, M = 3, K = 2;
g = new Graph(N);
g->addEdge(1, 2);
g->addEdge(2, 3);
g->addEdge(3, 4);
countRemovedEdges(N, M, K);
}
|
Java
import java.util.*;
class GFG
{
static ArrayList<ArrayList<Integer>> graph;
static void DFS( int s, boolean [] visited)
{
Stack<Integer> stack = new Stack<>();
stack.push(s);
while (!stack.isEmpty())
{
s = stack.peek();
stack.pop();
for (Integer node : graph.get(s))
{
if (!visited[node])
{
visited[node] = true ;
stack.push(node);
}
}
}
}
static void countRemovedEdges( int N, int M, int K)
{
int C = 0 ;
boolean [] visited = new boolean [N+ 1 ];
for ( int node = 1 ; node <= N; node++)
{
if (!visited[node])
{
C = C + 1 ;
DFS(node, visited);
if (C <= K)
System.out.println(M - N + K);
else
System.out.println(- 1 );
}
}
}
public static void main (String[] args)
{
int N = 4 , M = 3 , K = 2 ;
graph = new ArrayList<>();
for ( int i = 0 ; i <= N; i++)
graph.add( new ArrayList<Integer>());
graph.get( 1 ).add( 2 );
graph.get( 2 ).add( 3 );
graph.get( 3 ).add( 4 );
countRemovedEdges(N, M, K);
}
}
|
Python3
class Graph:
def __init__( self , V):
self .V = V
self .adj = {i: [] for i in range ( 1 , V + 1 )}
def addEdge( self , v, w):
self .adj[v].append(w)
self .adj[w].append(v)
def DFS( self , s, visited):
stack = []
stack.append(s)
while ( len (stack)):
s = stack[ - 1 ]
stack.pop()
for node in self .adj[s]:
if ( not visited[node]):
visited[node] = True
stack.append(node)
def countRemovedEdges(N, M, K):
C = 0
visited = [ False for i in range (g.V + 1 )]
for node in range ( 1 , N + 1 ):
if ( not visited[node]):
C = C + 1
g.DFS(node, visited)
if C < = K:
print (M - N + K)
else :
print ( - 1 )
N, M, K = 4 , 3 , 2
g = Graph(N)
g.addEdge( 1 , 2 )
g.addEdge( 2 , 3 )
g.addEdge( 3 , 4 )
countRemovedEdges(N, M, K)
|
C#
using System;
using System.Collections.Generic;
class GFG {
static List<List< int >> graph;
static void DFS( int s, bool [] visited)
{
Stack< int > stack = new Stack< int >();
stack.Push(s);
while (stack.Count > 0)
{
s = ( int )stack.Peek();
stack.Pop();
foreach ( int node in graph[s])
{
if (!visited[node])
{
visited[node] = true ;
stack.Push(node);
}
}
}
}
static void countRemovedEdges( int N, int M, int K)
{
int C = 0;
bool [] visited = new bool [N+1];
for ( int node = 1; node <= N; node++)
{
if (!visited[node])
{
C = C + 1;
DFS(node, visited);
if (C <= K)
Console.WriteLine(M - N + K);
else
Console.WriteLine(-1);
}
}
}
static void Main() {
int N = 4, M = 3, K = 2;
graph = new List<List< int >>();
for ( int i = 0; i <= N; i++)
graph.Add( new List< int >());
graph[1].Add(2);
graph[2].Add(3);
graph[3].Add(4);
countRemovedEdges(N, M, K);
}
}
|
Javascript
<script>
let graph;
function DFS(s, visited)
{
let stack = [];
stack.push(s);
while (stack.length > 0)
{
s = stack[stack.length - 1];
stack.pop();
for (let node = 0; node < graph[s].length; node++)
{
if (!visited[graph[s][node]])
{
visited[graph[s][node]] = true ;
stack.push(graph[s][node]);
}
}
}
}
function countRemovedEdges(N, M, K)
{
let C = 0;
let visited = new Array(N+1);
visited.fill( false );
for (let node = 1; node <= N; node++)
{
if (!visited[node])
{
C = C + 1;
DFS(node, visited);
if (C <= K)
document.write((M - N + K) + "</br>" );
else
document.write(-1 + "</br>" );
}
}
}
let N = 4, M = 3, K = 2;
graph = [];
for (let i = 0; i <= N; i++)
graph.push([]);
graph[1].push(2);
graph[2].push(3);
graph[3].push(4);
countRemovedEdges(N, M, K);
</script>
|
Time Complexity: O(N + M)
Auxiliary Space: O(M + N)
Last Updated :
27 Aug, 2021
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...