Find count of pair of nodes at even distance | Set 2 (Using BFS)

Given a connected acyclic graph with N nodes numbered from 1 to N and N-1 edges, find out the pair of nodes that are at even distance from each other.

Note: The graph is represented in the form of an adjacency list.

Examples:

Input: N = 3, graph = {{}, {2}, {1, 3}, {2}}
Output:1
Explanation: Here there are three pairs {1, 2}, {1, 3}
and {2, 3} and only {1, 3} has even distance between them.
i.e.,         1
/
2
/
3

Input: N = 5, graph = {{}, {2, 4}, {1, 3}, {2}, {1, 5}, {4}}
Output: 4
Explanation: There are four pairs {1, 3}, {1, 5}, {2, 4}
and {3, 5} which has even distance.

Start traversing from any node (say 1) as the root of the graph and store the number of nodes in odd and even numbered level. The nodes in even numbered level are distance away from each other. The same is true for nodes in odd numbered levels.

Follow the steps mentioned below to implement the idea:

• Create an array to keep track of all the visited nodes.
• Using queue do BFS traversal of the graph.
• Initially push the first node in the queue and then traverse and push its neighbours which are not yet visited into the queue and continue the BFS in this way.
• Count the number of nodes in even numbered levels (say X) and odd numbered levels (say Y).
• The answer will be the sum of the number of ways to choose any two elements from X (i.e (X * (X – 1)) / 2)and any two elements from Y (i.e. (Y * (Y – 1)) / 2 ).

Below is the implementation of the above approach:

C++

 `// C++ code to implement the approach` `#include ``using` `namespace` `std;` `// Function to find the count of nodes at``// even distance using BFS method``int` `countOfNodes(vector<``int``> graph[], ``int` `n)``{``    ``// Declare one vector to check that``    ``// element is visited or not``    ``vector<``int``> vis(n + 1);` `    ``// Declare one queue``    ``queue > q;``    ``long` `long` `_0 = 0, _1 = 0;` `    ``// Initially push the first node with its``    ``// level as even in the queue``    ``q.push({ 1, 0 });` `    ``// Run this loop until q is not empty``    ``while` `(!q.empty()) {``        ``vis[q.front().first] = 1;` `        ``// Check for the adjacent nodes``        ``for` `(``auto` `child : graph[q.front().first]) {``            ``// Check only if adjacent node``            ``// is not visited``            ``if` `(!vis[child])``                ``q.push({ child, 1 - q.front().second });``        ``}``        ``if` `(q.front().second)``            ``_1++;``        ``else``            ``_0++;``        ``q.pop();``    ``}` `    ``// Answer will be the sum of the number``    ``// of ways to choose any two elements``    ``// of even and odd type``    ``int` `ans``        ``= (_0 * (_0 - 1)) / 2``          ``+ (_1 * (_1 - 1)) / 2;``    ``return` `ans;``}` `// Driver code``int` `main()``{``    ``int` `N = 3;` `    ``// Creating adjacency list for the graph``    ``vector<``int``> graph[N + 1];``    ``graph[1].push_back(2);``    ``graph[2].push_back(1);``    ``graph[2].push_back(3);``    ``graph[3].push_back(2);` `    ``// Function call``    ``cout << countOfNodes(graph, N);``    ``return` `0;``}`

Java

 `// Java code to implement the approach``import` `java.io.*;``import` `java.util.*;` `// User defined Pair class``class` `Pair {``  ``int` `x;``  ``int` `y;` `  ``// Constructor``  ``public` `Pair(``int` `x, ``int` `y)``  ``{``    ``this``.x = x;``    ``this``.y = y;``  ``}``}` `class` `GFG {` `  ``static` `void` `addEdge(ArrayList > adj,``                      ``int` `u, ``int` `v)``  ``{``    ``adj.get(u).add(v);``  ``}` `  ``// Function to find the count of nodes at``  ``// even distance using BFS method``  ``public` `static` `long``    ``countOfNodes(ArrayList > graph,``                 ``int` `n)``  ``{``    ``// Declare one vector to check that``    ``// element is visited or not``    ``int` `vis[] = ``new` `int``[n + ``1``];` `    ``// Declare one queue` `    ``Queue q = ``new` `LinkedList<>();` `    ``long` `_0 = ``0``, _1 = ``0``;` `    ``// Initially push the first node with its``    ``// level as even in the queue``    ``q.add(``new` `Pair(``1``, ``0``));` `    ``// Run this loop until q is not empty``    ``while` `(!q.isEmpty()) {``      ``vis[q.peek().x] = ``1``;` `      ``// Check for the adjacent nodes``      ``for` `(Integer child : graph.get(q.peek().x)) {``        ``// Check only if adjacent node``        ``// is not visited``        ``if` `(vis[child] == ``0``)``          ``q.add(``new` `Pair(child, ``1` `- q.peek().y));``      ``}``      ``if` `(q.peek().y != ``0``)``        ``_1++;``      ``else``        ``_0++;``      ``q.poll();``    ``}` `    ``// Answer will be the sum of the number``    ``// of ways to choose any two elements``    ``// of even and odd type``    ``long` `ans``      ``= (_0 * (_0 - ``1``)) / ``2` `+ (_1 * (_1 - ``1``)) / ``2``;``    ``return` `ans;``  ``}` `  ``// Driver code``  ``public` `static` `void` `main(String[] args)``  ``{``    ``int` `N = ``3``;` `    ``// Creating adjacency list for the graph``    ``ArrayList > graph``      ``= ``new` `ArrayList >(N + ``1``);` `    ``for` `(``int` `i = ``0``; i < N + ``1``; i++)``      ``graph.add(``new` `ArrayList());``    ``addEdge(graph, ``1``, ``2``);``    ``addEdge(graph, ``2``, ``1``);``    ``addEdge(graph, ``2``, ``3``);``    ``addEdge(graph, ``3``, ``2``);` `    ``// Function call``    ``System.out.print(countOfNodes(graph, N));``  ``}``}` `// This code is contributed by Rohit Pradhan`

Python3

 `# Python3 code to implement the above approach` `# Function to find the count of nodes at``# even distance using BFS method``def` `countOfNodes(graph, n):` `    ``# Declare one vector to check that``    ``# element is visited or not``    ``vis ``=` `[``None``] ``*` `(n ``+` `1``)` `    ``# Declare one queue``    ``q ``=` `[]``    ``_0 ``=` `0``    ``_1 ``=` `0` `    ``# Initially push the first node with its``    ``# level as even in the queue``    ``q.append([``1``, ``0``])` `    ``# Run this loop until q is not empty``    ``while` `(``len``(q) > ``0``):``        ``front ``=` `q.pop(``0``)``        ``vis[front[``0``]] ``=` `1` `        ``# Check for the adjacent nodes``        ``for` `child ``in` `graph[front[``0``]]:``            ``# Check only if adjacent node``            ``# is not visited``            ``if` `vis[child] ``is` `None``:``                ``q.append([child, ``1` `-` `front[``1``]])` `        ``if` `(front[``1``]):``            ``_1 ``+``=` `1``        ``else``:``            ``_0 ``+``=` `1` `    ``# Answer will be the sum of the number``    ``# of ways to choose any two elements``    ``# of even and odd type``    ``ans ``=` `(_0 ``*` `(_0 ``-` `1``)) ``/``/` `2` `+` `(_1 ``*` `(_1 ``-` `1``)) ``/``/` `2``    ``return` `ans` `# Driver code``N ``=` `3` `# Creating adjacency list for the graph``graph ``=` `[[]]``graph.append([``2``])``graph.append([``1``, ``3``])``graph.append([``2``])` `# Function call``print``(countOfNodes(graph, N))` `# This code is contributed by phasing17`

C#

 `// C# code to implement the approach``using` `System;``using` `System.Collections.Generic;` `// User defined Pair class``class` `Pair {``  ``public` `int` `x;``  ``public` `int` `y;` `  ``// Constructor``  ``public` `Pair(``int` `x, ``int` `y)``  ``{``    ``this``.x = x;``    ``this``.y = y;``  ``}``}` `class` `GFG {` `  ``static` `void` `addEdge(List > adj, ``int` `u, ``int` `v)``  ``{``    ``adj[u].Add(v);``  ``}` `  ``// Function to find the count of nodes at``  ``// even distance using BFS method``  ``public` `static` `long` `countOfNodes(List > graph,``                                  ``int` `n)``  ``{``    ``// Declare one vector to check that``    ``// element is visited or not``    ``int``[] vis = ``new` `int``[n + 1];` `    ``// Declare one queue` `    ``Queue q = ``new` `Queue();` `    ``long` `_0 = 0, _1 = 0;` `    ``// Initially push the first node with its``    ``// level as even in the queue``    ``q.Enqueue(``new` `Pair(1, 0));` `    ``// Run this loop until q is not empty``    ``while` `(q.Count > 0) {``      ``vis[q.Peek().x] = 1;` `      ``// Check for the adjacent nodes``      ``foreach``(``int` `child ``in` `graph[q.Peek().x])``      ``{``        ``// Check only if adjacent node``        ``// is not visited``        ``if` `(vis[child] == 0)``          ``q.Enqueue(``          ``new` `Pair(child, 1 - q.Peek().y));``      ``}``      ``if` `(q.Peek().y != 0)``        ``_1++;``      ``else``        ``_0++;``      ``q.Dequeue();``    ``}` `    ``// Answer will be the sum of the number``    ``// of ways to choose any two elements``    ``// of even and odd type``    ``long` `ans``      ``= (_0 * (_0 - 1)) / 2 + (_1 * (_1 - 1)) / 2;``    ``return` `ans;``  ``}` `  ``// Driver code``  ``public` `static` `void` `Main(``string``[] args)``  ``{``    ``int` `N = 3;` `    ``// Creating adjacency list for the graph``    ``List > graph``      ``= ``new` `List >(N + 1);` `    ``for` `(``int` `i = 0; i < N + 1; i++)``      ``graph.Add(``new` `List<``int``>());``    ``addEdge(graph, 1, 2);``    ``addEdge(graph, 2, 1);``    ``addEdge(graph, 2, 3);``    ``addEdge(graph, 3, 2);` `    ``// Function call``    ``Console.Write(countOfNodes(graph, N));``  ``}``}` `// This code is contributed by phasing17`

Javascript

 ``

Output
`1`

Time Complexity: O(V+E) = O(N). As V = number of nodes = N, E = number of edges = N-1 as given.
Auxiliary Space: O(N)

Previous
Next