Given the adjacency list of a bidirectional graph. The task is to copy/clone the adjacency list for each vertex and return a new list for a bidirectional graph.
An Adjacency List is used for representing graphs. Here, for every vertex in the graph, we have a list of all the other vertices to which the particular vertex has an edge.
Examples:
Input: N = 5
adj[] = adj[0] = {1, 2}; adj[2] = {0, 3, 4}; adj[3] = {1, 2}; adj[4] = {2};Output: Node 0 is connected to 1 and 2
Node 1 is connected to 0 and 3
Node 2 is connected to 0,3 and 4
Node 3 is connected to 1 and 2
Node 4 is connected to 2
Approach:
The basic Idea to clone adjacency list for each vertex is to create a cloned vector and a visited array and check whether the node is visited or not.
- First Create a vector (say clone) of size N and an array visited[] of size N to check whether a particular is visited or not.
- Check if a node is visited or not:
- If not, then call a function to mark a non-visited node as present
- Create two vectors adj[] and clone[] where adj[] has a list stored in it and clone[] will store the unmarked nodes.
- Mark every node as visited by visited[node] = 1.
- Then, traverse the adjacency list and check for non-visited nodes to add edges in the bidirectional graph.
- Push nodes and edges in the clone list
Below is the implementation of the above idea:
// C++ code to implement the approach #include <bits/stdc++.h> using namespace std;
// Function to add the edges we have // in the adjacency list to the clone list void AddEdges( int node, vector< int > adj[],
vector< int > clone[], vector< int >& visited)
{ // Marking node as visited
visited[node] = 1;
for ( int it : adj[node]) {
if (!visited[it]) {
// Nodes are bidirectionally connected
clone[node].push_back(it);
clone[it].push_back(node);
}
}
} // Function to print the adjacency list void printList(vector< int > clone[], int n)
{ for ( int node = 0; node < n; node++) {
cout << "Node " << node << " is connected to " ;
for ( int it : clone[node]) {
cout << it << " " ;
}
cout << endl;
}
} // Function to clone the given adjacency list void cloneList(vector< int > adj[], int N)
{ vector< int > clone[N];
// Visited array to check whether a particular
// node is visited or not
vector< int > visited(N, 0);
for ( int node = 0; node < N; node++) {
if (!visited[node]) {
AddEdges(node, adj, clone, visited);
}
}
printList(clone, N);
} // Driver code int main()
{ // Adjacency List of a bidirectional graph
int N = 5;
vector< int > adj[N];
adj[0] = { 1, 2 };
adj[1] = { 0, 3 };
adj[2] = { 0, 3, 4 };
adj[3] = { 1, 2 };
adj[4] = { 2 };
// Function call
cloneList(adj, N);
return 0;
} |
// Java code to implement the approach import java.util.*;
class GFG {
// Function to add the edges we have
// in the adjacency list to the clone list
public static void AddEdges( int node,
ArrayList<Integer>[] adj,
ArrayList<Integer>[] clone,
boolean [] visited)
{
visited[node] = true ;
for ( int it : adj[node]) {
if (!visited[it]) {
clone[node].add(it);
clone[it].add(node);
}
}
}
// Function to clone the given adjacency list
static void cloneList(ArrayList<Integer> adj[], int n)
{
ArrayList<Integer>[] clone = new ArrayList[n];
for ( int i = 0 ; i < n; i++)
clone[i] = new ArrayList<>();
// Visited array to check
// whether a particular node is
// visited or not
boolean [] visited = new boolean [n];
for ( int node = 0 ; node < n; node++) {
if (!visited[node]) {
AddEdges(node, adj, clone, visited);
}
}
// Printing cloned the adjacency list
for ( int node = 0 ; node < n; node++) {
System.out.print( "Node " + node
+ " is connected to " );
for ( int it : clone[node]) {
System.out.print(it + " " );
}
System.out.println();
}
}
// Driver code
public static void main(String[] args)
{
// Adjacency List of a bidirectional graph
int N = 5 ;
ArrayList<Integer>[] adj = new ArrayList[N];
adj[ 0 ] = new ArrayList<>(List.of( 1 , 2 ));
adj[ 1 ] = new ArrayList<>(List.of( 0 , 3 ));
adj[ 2 ] = new ArrayList<>(List.of( 0 , 3 , 4 ));
adj[ 3 ] = new ArrayList<>(List.of( 1 , 2 ));
adj[ 4 ] = new ArrayList<>(List.of( 2 ));
cloneList(adj, N);
}
} |
# Python code to implement the approach # Function to add the edges we have # in the adjacency list to the clone list def AddEdges(node, adj, clone, visited):
# Marking node as visited
visited[node] = 1
for i in range ( len (adj[node])):
it = adj[node][i]
if ( not visited[it]):
# Nodes are bidirectionally connected
clone[node].append(it)
clone[it].append(node)
# Function to print the adjacency list def printList(clone,n):
for node in range (n):
print ( "Node " ,end = "")
print (node,end = "")
print ( " is connected to " ,end = "")
for it in clone[node]:
print (it,end = " " )
print ()
# Function to clone the given adjacency list def cloneList(adj,N):
clone = [[] for j in range (N)]
# Visited array to check whether a particular
# node is visited or not
visited = [ 0 ] * N
for node in range (N):
if ( not visited[node]):
AddEdges(node, adj, clone, visited)
printList(clone, N)
# Driver code # Adjacency List of a bidirectional graph N = 5
adj = [[] for j in range (N)]
adj[ 0 ] = [ 1 , 2 ]
adj[ 1 ] = [ 0 , 3 ]
adj[ 2 ] = [ 0 , 3 , 4 ]
adj[ 3 ] = [ 1 , 2 ]
adj[ 4 ] = [ 2 ]
# Function call cloneList(adj, N) # This code is contributed by Pushpesh Raj. |
using System;
public class GFG{
static public void Main (){
// Code
}
|
// JS code to implement the approach // Function to add the edges we have // in the adjacency list to the clone list function AddEdges(node, adj, clone, visited)
{ // Marking node as visited
visited[node] = 1;
for (let i=0;i<adj[node].length;i++){
let it = adj[node][i];
if (!visited[it]) {
// Nodes are bidirectionally connected
clone[node].push(it);
clone[it].push(node);
}
}
} // Function to print the adjacency list function printList( clone, n)
{ for (let node = 0; node < n; node++) {
console.log( "Node " , node , " is connected to " , clone[node]);
}
} // Function to clone the given adjacency list function cloneList(adj, N)
{ let clone = [];
for (let i = 0; i < N; i++)
{
clone.push([]);
}
// Visited array to check whether a particular
// node is visited or not
let visited = [];
for (let i = 0; i < N; i++)
{
visited.push(0);
}
for (let node = 0; node < N; node++) {
if (!visited[node]) {
AddEdges(node, adj, clone, visited);
}
}
printList(clone, N);
} // Driver code // Adjacency List of a bidirectional graph let N = 5; let adj = []; for (let i =0;i<N;i++)
{ adj.push([]);
} adj[0] = [ 1, 2 ]; adj[1] = [ 0, 3 ]; adj[2] = [ 0, 3, 4 ]; adj[3] = [ 1, 2 ]; adj[4] = [ 2 ]; // Function call cloneList(adj, N); // This code is contributed by ksam24000 |
Node 0 is connected to 1 2 Node 1 is connected to 0 3 Node 2 is connected to 0 3 4 Node 3 is connected to 1 2 Node 4 is connected to 2
Time Complexity: O ( V + E ) where V is the number of vertices and E is the number of edges of the graph
Auxiliary Space: O ( V + E )
Related Articles: