Check if the length of all connected components is a Fibonacci number
Last Updated :
04 Feb, 2022
Given an undirected graph with V vertices and E edges, the task is to find all the connected components of the graph and check if each of their lengths are a Fibonacci number or not.
For example, consider the following graph.
As depicted above, the lengths of the connected components are 2, 3, and 2 which are Fibonacci numbers.
Examples:
Input: E = 4, V = 7
Output: Yes
Input: E = 6, V = 10
Output: No
Explanation: The lengths of the connected components {1}, {2,3,4,5}, {6,7,8}, {9,10} are 1, 4, 3, 2 respectively.
Approach:
Precompute and store the Fibonacci numbers in a HashSet. Traverse the vertices and generate the Connected components using the DFS approach as explained in this article. Check if all the lengths are present in the precomputed HashSet of Fibonacci numbers.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
void depthFirst( int v, vector< int > graph[],
vector< bool >& visited, int & ans)
{
visited[v] = true ;
ans++;
for ( auto i : graph[v]) {
if (visited[i] == false ) {
depthFirst(i, graph, visited, ans);
}
}
}
void countConnectedFibonacci(vector< int > graph[],
int V, int E)
{
unordered_set< int > fibonacci;
fibonacci.insert(0);
fibonacci.insert(1);
long long a = 0,b = 1;
for ( int i = 2; i < 1001; i++) {
fibonacci.insert(a + b);
a = a+b;
swap(a,b);
}
vector< bool > visited(10001, false );
for ( int i = 1; i <= V; i++) {
if (visited[i] == false ) {
int ans = 0;
depthFirst(i, graph, visited, ans);
if (fibonacci.find(ans) == fibonacci.end())
{
cout << "No" <<endl;
return ;
}
}
}
cout<< "Yes" <<endl;
}
int main()
{
vector< int > graph[1001];
int E = 4,V = 7;
graph[1].push_back(2);
graph[2].push_back(5);
graph[3].push_back(4);
graph[4].push_back(3);
graph[3].push_back(6);
graph[6].push_back(3);
graph[8].push_back(7);
graph[7].push_back(8);
countConnectedFibonacci(graph, V, E);
return 0;
}
|
Java
import java.util.*;
class GFG{
static void depthFirst( int v, Vector<Integer> graph[],
boolean []visited, int ans)
{
visited[v] = true ;
ans++;
for ( int i : graph[v]) {
if (visited[i] == false ) {
depthFirst(i, graph, visited, ans);
}
}
}
static void countConnectedFibonacci(Vector<Integer> graph[],
int V, int E)
{
HashSet<Integer> fibonacci = new HashSet<Integer>();
fibonacci.add( 0 );
fibonacci.add( 1 );
int a = 0 ,b = 1 ;
for ( int i = 2 ; i < 1001 ; i++) {
fibonacci.add(a + b);
a = a + b;
a = a + b;
b = a - b;
a = a - b;
}
boolean []visited = new boolean [ 10001 ];
for ( int i = 1 ; i <= V; i++) {
if (visited[i] == false ) {
int ans = 0 ;
depthFirst(i, graph, visited, ans);
if (!fibonacci.contains(ans))
{
System.out.println( "No" );
return ;
}
}
}
System.out.println( "Yes" );
}
public static void main(String[] args)
{
Vector<Integer> []graph = new Vector[ 1001 ];
for ( int i = 0 ; i < graph.length; i++)
graph[i] = new Vector<Integer>();
int E = 4 ,V = 7 ;
graph[ 1 ].add( 2 );
graph[ 2 ].add( 5 );
graph[ 3 ].add( 4 );
graph[ 4 ].add( 3 );
graph[ 3 ].add( 6 );
graph[ 6 ].add( 3 );
graph[ 8 ].add( 7 );
graph[ 7 ].add( 8 );
countConnectedFibonacci(graph, V, E);
}
}
|
C#
using System;
using System.Collections.Generic;
class GFG{
static void depthFirst( int v, List< int > []graph,
bool []visited, int ans)
{
visited[v] = true ;
ans++;
foreach ( int i in graph[v])
{
if (visited[i] == false )
{
depthFirst(i, graph, visited, ans);
}
}
}
static void countConnectedFibonacci(List< int > []graph,
int V, int E)
{
HashSet< int > fibonacci = new HashSet< int >();
fibonacci.Add(0);
fibonacci.Add(1);
int a = 0,b = 1;
for ( int i = 2; i < 1001; i++)
{
fibonacci.Add(a + b);
a = a + b;
a = a + b;
b = a - b;
a = a - b;
}
bool []visited = new bool [10001];
for ( int i = 1; i <= V; i++)
{
if (visited[i] == false )
{
int ans = 0;
depthFirst(i, graph, visited, ans);
if (!fibonacci.Contains(ans))
{
Console.WriteLine( "No" );
return ;
}
}
}
Console.WriteLine( "Yes" );
}
public static void Main(String[] args)
{
List< int > []graph = new List< int >[1001];
for ( int i = 0; i < graph.Length; i++)
graph[i] = new List< int >();
int E = 4,V = 7;
graph[1].Add(2);
graph[2].Add(5);
graph[3].Add(4);
graph[4].Add(3);
graph[3].Add(6);
graph[6].Add(3);
graph[8].Add(7);
graph[7].Add(8);
countConnectedFibonacci(graph, V, E);
}
}
|
Javascript
<script>
function depthFirst(v, graph, visited, ans)
{
visited[v] = true ;
ans++;
for (let i = 0; i < graph[v].length; i++) {
if (visited[graph[v][i]] == false ) {
depthFirst(graph[v][i], graph, visited, ans);
}
}
}
function countConnectedFibonacci(graph, V, E)
{
let fibonacci = new Set();
fibonacci.add(0);
fibonacci.add(1);
let a = 0,b = 1;
for (let i = 2; i < 1001; i++) {
fibonacci.add(a + b);
a = a + b;
a = a + b;
b = a - b;
a = a - b;
}
let visited = new Array(10001);
for (let i = 1; i <= V; i++) {
if (visited[i] == false ) {
let ans = 0;
depthFirst(i, graph, visited, ans);
if (!fibonacci.has(ans))
{
document.write( "No" );
return ;
}
}
}
document.write( "Yes" );
}
let graph = new Array(1001);
for (let i = 0; i < graph.length; i++)
graph[i] = [];
let E = 4,V = 7;
graph[1].push(2);
graph[2].push(5);
graph[3].push(4);
graph[4].push(3);
graph[3].push(6);
graph[6].push(3);
graph[8].push(7);
graph[7].push(8);
countConnectedFibonacci(graph, V, E);
</script>
|
Python3
def depthFirst( v, graph, visited):
global ans
visited[v] = True
ans + = 1
for i in graph[v] :
if (visited[i] = = False ) :
depthFirst(i, graph, visited)
def countConnectedFibonacci(graph, V, E):
fibonacci = set ()
fibonacci.add( 0 )
fibonacci.add( 1 )
a = 0 ;b = 1
for i in range ( 2 , 1001 ):
fibonacci.add(a + b)
a = a + b
a,b = b,a
visited = [ False ] * 10001
global ans
for i in range ( 1 ,V + 1 ):
if not visited[i]:
ans = 0
depthFirst(i, graph, visited)
if ans not in fibonacci:
print ( "No" )
return
print ( "Yes" )
if __name__ = = '__main__' :
graph = [[] for _ in range ( 1001 )]
E = 4 ;V = 7
graph[ 1 ].append( 2 )
graph[ 2 ].append( 5 )
graph[ 3 ].append( 4 )
graph[ 4 ].append( 3 )
graph[ 3 ].append( 6 )
graph[ 6 ].append( 3 )
graph[ 8 ].append( 7 )
graph[ 7 ].append( 8 )
countConnectedFibonacci(graph, V, E)
|
Complexity analysis:
The overall complexity of the program is primarily dictated by three factors, namely, the Depth First Search traversal, the identification of elements from the Fibonacci container, and the pre-computation of the Fibonacci sequence. The DFS traversal boasts a time complexity of O(E + V) where E and V are the edges and vertices of the graph. It takes O(1) time complexity to check if a particular length is present in the HashSet or not. The initial pre-computation has a time complexity of O(N) where N is the number up to which the Fibonacci sequence is stored.
Time Complexity: O(N).
Efficient Approach:
This method basically avoids the Fibonacci pre-computation and uses a simple formulation in order to check if the individual lengths are a Fibonacci number or not. The formula to detect if N is a Fibonacci number is to find the values of 5N2 + 4 and 5N2 – 4 and check if either of them is a perfect square or not. The said formulation had been formulated by I Gessel and can be referred to from this link. The rest of the program has a similar approach as above by computing connected components through DFS traversal.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
void depthFirst( int v, vector< int > graph[],
vector< bool >& visited, int & ans)
{
visited[v] = true ;
ans++;
for ( auto i : graph[v]) {
if (visited[i] == false ) {
depthFirst(i, graph, visited, ans);
}
}
}
void countConnectedFibonacci(vector< int > graph[],
int V, int E)
{
vector< bool > visited(10001, false );
for ( int i = 1; i <= V; i++) {
if (visited[i] == false ) {
int ans = 0;
depthFirst(i, graph, visited, ans);
double x1 = sqrt (5*ans*ans + 4);
int x2 = sqrt (5 * ans * ans + 4);
double y1 = sqrt (5*ans*ans - 4);
int y2 = sqrt (5 * ans * ans - 4);
if (!(x1 - x2) || !(y1 - y2))
continue ;
else
{
cout << "No" <<endl;
return ;
}
}
}
cout<< "Yes" <<endl;
}
int main()
{
vector< int > graph[1001];
int E = 4,V = 7;
graph[1].push_back(2);
graph[2].push_back(1);
graph[2].push_back(5);
graph[5].push_back(2);
graph[3].push_back(4);
graph[4].push_back(3);
graph[3].push_back(6);
graph[6].push_back(3);
graph[8].push_back(7);
graph[7].push_back(8);
countConnectedFibonacci(graph, V, E);
return 0;
}
|
Java
import java.util.*;
class GFG{
static void depthFirst( int v, Vector<Integer> graph[],
Vector<Boolean> visited, int ans)
{
visited.add(v, true );
ans++;
for ( int i : graph[v])
{
if (visited.get(i) == false )
{
depthFirst(i, graph, visited, ans);
}
}
}
static void countConnectedFibonacci(Vector<Integer> graph[],
int V, int E)
{
Vector<Boolean> visited = new Vector<>( 10001 );
for ( int i = 0 ; i < 10001 ; i++)
visited.add(i, false );
for ( int i = 1 ; i < V; i++)
{
if (visited.get(i) == false )
{
int ans = 0 ;
depthFirst(i, graph, visited, ans);
double x1 = Math.sqrt( 5 * ans * ans + 4 );
int x2 = ( int )Math.sqrt( 5 * ans * ans + 4 );
double y1 = Math.sqrt( 5 * ans * ans - 4 );
int y2 = ( int )Math.sqrt( 5 * ans * ans - 4 );
if ((x1 - x2) != 0 || (y1 - y2) != 0 )
continue ;
else
{
System.out.println( "No" );
return ;
}
}
}
System.out.println( "Yes" );
}
public static void main(String[] args)
{
@SuppressWarnings ( "unchecked" )
Vector<Integer> []graph = new Vector[ 1001 ];
for ( int i = 0 ; i < 1001 ; i++)
graph[i] = new Vector<Integer>();
int E = 4 ,V = 7 ;
graph[ 1 ].add( 2 );
graph[ 2 ].add( 1 );
graph[ 2 ].add( 5 );
graph[ 5 ].add( 2 );
graph[ 3 ].add( 4 );
graph[ 4 ].add( 3 );
graph[ 3 ].add( 6 );
graph[ 6 ].add( 3 );
graph[ 8 ].add( 7 );
graph[ 7 ].add( 8 );
countConnectedFibonacci(graph, V, E);
}
}
|
Python3
from math import sqrt
def depthFirst(v):
global visited, ans, graph
visited[v] = True
ans + = 1
for i in graph[v]:
if (visited[i] = = False ):
depthFirst(i)
def countConnectedFibonacci(V, E):
global graph, ans
for i in range ( 1 , V + 1 ):
if (visited[i] = = False ):
ans = 0
depthFirst(i)
x1 = sqrt( 5 * ans * ans + 4 )
x2 = sqrt( 5 * ans * ans + 4 )
y1 = sqrt( 5 * ans * ans - 4 )
y2 = sqrt( 5 * ans * ans - 4 )
if (( not (x1 - x2)) or ( not (y1 - y2))):
continue
else :
print ( "No" )
return
print ( "Yes" )
if __name__ = = '__main__' :
graph = [[] for i in range ( 10001 )]
visited = [ False for i in range ( 10001 )]
ans = 0
E, V = 4 , 7
graph[ 1 ].append( 2 )
graph[ 2 ].append( 1 )
graph[ 2 ].append( 5 )
graph[ 5 ].append( 2 )
graph[ 3 ].append( 4 )
graph[ 4 ].append( 3 )
graph[ 3 ].append( 6 )
graph[ 6 ].append( 3 )
graph[ 8 ].append( 7 )
graph[ 7 ].append( 8 )
countConnectedFibonacci(V, E)
|
C#
using System;
using System.Collections;
class GFG{
static void depthFirst( int v, ArrayList []graph,
ArrayList visited, int ans)
{
visited[v] = true ;
ans++;
foreach ( int i in graph[v])
{
if (( bool )visited[i] == false )
{
depthFirst(i, graph, visited, ans);
}
}
}
static void countConnectedFibonacci(ArrayList []graph,
int V, int E)
{
ArrayList visited = new ArrayList();
for ( int i = 0; i < 10001; i++)
visited.Add( false );
for ( int i = 1; i < V; i++)
{
if (( bool )visited[i] == false )
{
int ans = 0;
depthFirst(i, graph, visited, ans);
double x1 = Math.Sqrt(5 * ans * ans + 4);
int x2 = ( int )Math.Sqrt(5 * ans * ans + 4);
double y1 = Math.Sqrt(5 * ans * ans - 4);
int y2 = ( int )Math.Sqrt(5 * ans * ans - 4);
if ((x1 - x2) != 0 || (y1 - y2) != 0)
continue ;
else
{
Console.Write( "No" );
return ;
}
}
}
Console.Write( "Yes" );
}
public static void Main( string [] args)
{
ArrayList []graph =
new ArrayList[1001];
for ( int i = 0; i < 1001; i++)
graph[i] = new ArrayList();
int E = 4,
V = 7;
graph[1].Add(2);
graph[2].Add(1);
graph[2].Add(5);
graph[5].Add(2);
graph[3].Add(4);
graph[4].Add(3);
graph[3].Add(6);
graph[6].Add(3);
graph[8].Add(7);
graph[7].Add(8);
countConnectedFibonacci(graph, V, E);
}
}
|
Javascript
<script>
function depthFirst(v, graph, visited, ans)
{
visited[v] = true ;
ans++;
for (let i = 0; i < graph[v].length; i++)
{
if (visited[graph[v][i]] == false )
{
depthFirst(i, graph, visited, ans);
}
}
}
function countConnectedFibonacci(graph, V, E)
{
let visited = [];
for (let i = 0; i < 10001; i++)
visited.push( false );
for (let i = 1; i < V; i++)
{
if (visited[i] == false )
{
let ans = 0;
depthFirst(i, graph, visited, ans);
let x1 = Math.sqrt(5 * ans * ans + 4);
let x2 = parseInt(Math.sqrt(5 * ans * ans + 4), 10);
let y1 = Math.sqrt(5 * ans * ans - 4);
let y2 = parseInt(Math.sqrt(5 * ans * ans - 4), 10);
if ((x1 - x2) != 0 || (y1 - y2) != 0)
continue ;
else
{
document.write( "No" );
return ;
}
}
}
document.write( "Yes" );
}
let graph = new Array(1001);
for (let i = 0; i < 1001; i++)
graph[i] = [];
let E = 4, V = 7;
graph[1].push(2);
graph[2].push(1);
graph[2].push(5);
graph[5].push(2);
graph[3].push(4);
graph[4].push(3);
graph[3].push(6);
graph[6].push(3);
graph[8].push(7);
graph[7].push(8);
countConnectedFibonacci(graph, V, E);
</script>
|
Complexity analysis:
Time Complexity: O(V + E)
This method avoids the earlier pre-computation and uses a mathematical formulation to detect if the individual lengths are Fibonacci numbers. Thus, the computation is achieved in constant time O(1) and constant space as it avoids the use of any HashSet to store the Fibonacci numbers. Thus, the overall complexity of the program in this method is dictated solely through the DFS traversal. Hence, the complexity is O(E + V) where E and V are the numbers of edges and vertices of the undirected graph.
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...