Given an array **arr[]** of **N** integers of value from **0 to N**, the task is to count the number of components in Index Array.

Index arraymeans if we are atithindex then it leads to arr[i].

Thecomponentof an index array is counted when it forms a cycle. If no cycle persists or the array contains a single element then also we consider it as a component.

For Example:

Let array arr[] = {1, 2, 0, 3}

{1, 2, 0} will form one component as starting from index 0 we reach the index 0 again as:

1 -> 2(arr[1]) -> 0(arr[2]) -> 1(arr[0])

**Examples:**

Input:arr[] = {1, 2, 3, 5, 0, 4, 6}

Output:2

Explanation:

Below is the traversal of the 2 components:

Component 1: Start traversal from 0, then the path of traversal is given by:

1 -> 2(arr[1]) -> 3(arr[2]) -> 5(arr[3]) -> 4(arr[5]) -> 0(arr[4]) -> 1(arr[0]).

Component 2: Only 6 is unvisited it creates one more component.

So, the total components = 2.

Input:arr[] = {1, 2, 0, 3}

Output:2

Explanation:

Below is the traversal of the 2 components:

Component 1: Start traversal from 0, then the path of traversal is given by:

1 -> 2(arr[1]) -> 0(arr[2]) -> 1(arr[0])

Component 2: Only 3 is unvisited it creates one more component.

So, the total components = 2.

**Approach:** The idea is to use the concept of DFS traversal. Below are the steps:

- Start from the first unvisited index which will be index with integer 0 in it.
- During
**DFS Traversal**mark the visited elements in the array until the elements form a cycle. - If a cycle is formed then it means that we have got one component and hence increase the component count.
- Repeat all the above steps for all the unvisited index in the array and count the total components in the given index array.
- If all the index of the array are visited, then print the total count of connected components.

Below is the implementation of the above approach:

`// C++ program for the above approach ` ` ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `// Function for DFS traversal ` `void` `dfs(` `int` `i, ` `int` `a[], ` ` ` `map<` `int` `, ` `int` `>& m) ` `{ ` ` ` `// Check if not visited then ` ` ` `// recurr for the next index ` ` ` `if` `(m[i] == 0) { ` ` ` `m[i] = 1; ` ` ` ` ` `// DFS Traversal for next index ` ` ` `dfs(a[i], a, m); ` ` ` `} ` ` ` ` ` `return` `; ` `} ` ` ` `// Function for checking which ` `// indexes are remaining ` `int` `allvisited(` `int` `a[], ` `int` `n, ` ` ` `map<` `int` `, ` `int` `>& m) ` `{ ` ` ` `for` `(` `int` `i = 0; i < n; i++) { ` ` ` ` ` `// Marks that the ith ` ` ` `// index is not visited ` ` ` `if` `(m[i] == 0) ` ` ` `return` `i; ` ` ` `} ` ` ` `return` `-1; ` `} ` ` ` `// Function for counting components ` `int` `count(` `int` `a[], ` `int` `n) ` `{ ` ` ` `int` `c = 0; ` ` ` ` ` `// To mark the visited index ` ` ` `// during DFS Traversal ` ` ` `map<` `int` `, ` `int` `> m; ` ` ` ` ` `// Function call ` ` ` `int` `x = allvisited(a, n, m); ` ` ` ` ` `while` `(x != -1) { ` ` ` ` ` `// Count number of components ` ` ` `c++; ` ` ` ` ` `// DFS call ` ` ` `dfs(x, a, m); ` ` ` ` ` `x = allvisited(a, n, m); ` ` ` `} ` ` ` ` ` `// Print the total count of components ` ` ` `cout << c << endl; ` `} ` ` ` `// Driver Code ` `int` `main() ` `{ ` ` ` `// Given array arr[] ` ` ` `int` `arr[] = { 1, 4, 3, 5, 0, 2, 6 }; ` ` ` ` ` `int` `N = ` `sizeof` `(arr) / ` `sizeof` `(arr[0]); ` ` ` ` ` `// Function Call ` ` ` `count(arr, N); ` ` ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

**Output:**

3

**Time Complexity:** *O(N)*

**Auxiliary Space:** *O(N)*

## Recommended Posts:

- Queries for number of distinct elements from a given index till last index in an array
- How to find last index of a number in an Array in C++
- Number of permutations such that sum of elements at odd index and even index are equal
- Number of connected components in a 2-D matrix of strings
- Number of connected components in a doubly linked list
- Check if the length of all connected components is a Fibonacci number
- Number of single cycle components in an undirected graph
- Program to count Number of connected components in an undirected graph
- Maximum number of edges among all connected components of an undirected graph
- Rearrange array such that even index elements are smaller and odd index elements are greater
- Total number of possible Binary Search Trees using Catalan Number
- Minimum cost to reach end of array array when a maximum jump of K index is allowed
- Find starting index for every occurrence of given array B in array A using Z-Algorithm
- Longest alternating sub-array starting from every index in a Binary Array
- Construct an array from XOR of all elements of array except element at same index
- Sort Array such that smallest is at 0th index and next smallest it at last index and so on
- Minimum index i such that all the elements from index i to given index are equal
- Total number of Spanning Trees in a Graph
- Total number of triplets (A, B, C) in which the points B and C are Equidistant to A
- Total number of subsets in which the product of the elements is even

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.