# Count of subarrays which start and end with the same element

Given an array A of size N where the array elements contain values from 1 to N with duplicates, the task is to find total number of subarrays which start and end with the same element.

Examples:

Input: A[] = {1, 2, 1, 5, 2}
Output: 7
Explanation:
Total 7 sub-array of the given array are {1}, {2}, {1}, {5}, {2}, {1, 2, 1} and {2, 1, 5, 2} are start and end with same element.

Input: A[] = {1, 5, 6, 1, 9, 5, 8, 10, 8, 9}
Output: 14
Explanation:
Total 14 sub-array {1}, {5}, {6}, {1}, {9}, {5}, {8}, {10}, {8}, {9}, {1, 5, 6, 1}, {5, 6, 1, 9, 5}, {9, 5, 8, 10, 8, 9} and {8, 10, 8} start and end with same element.

Naive approach: For each element in the array, if it is present at a different index as well, we will increase our result by 1. Also, all 1-size subarray are part of counted in the result. Therefore, add N to the result.

Below is the implementation of the above approach:

## CPP

 `// C++ program to Count total sub-array ` `// which start and end with same element ` ` `  `#include ` `using` `namespace` `std; ` ` `  `// Function to find total sub-array ` `// which start and end with same element ` `void` `cntArray(``int` `A[], ``int` `N) ` `{ ` `    ``// initialize result with 0 ` `    ``int` `result = 0; ` ` `  `    ``for` `(``int` `i = 0; i < N; i++) { ` ` `  `        ``// all size 1 sub-array ` `        ``// is part of our result ` `        ``result++; ` ` `  `        ``// element at current index ` `        ``int` `current_value = A[i]; ` ` `  `        ``for` `(``int` `j = i + 1; j < N; j++) { ` ` `  `            ``// Check if A[j] = A[i] ` `            ``// increase result by 1 ` `            ``if` `(A[j] == current_value) { ` `                ``result++; ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``// print the result ` `    ``cout << result << endl; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `A[] = { 1, 5, 6, 1, 9, ` `                ``5, 8, 10, 8, 9 }; ` `    ``int` `N = ``sizeof``(A) / ``sizeof``(``int``); ` ` `  `    ``cntArray(A, N); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java program to Count total sub-array ` `// which start and end with same element ` ` `  `public` `class` `Main { ` ` `  `    ``// function to find total sub-array ` `    ``// which start and end with same element ` `    ``public` `static` `void` `cntArray(``int` `A[], ``int` `N) ` `    ``{ ` `        ``// initialize result with 0 ` `        ``int` `result = ``0``; ` ` `  `        ``for` `(``int` `i = ``0``; i < N; i++) { ` ` `  `            ``// all size 1 sub-array ` `            ``// is part of our result ` `            ``result++; ` ` `  `            ``// element at current index ` `            ``int` `current_value = A[i]; ` ` `  `            ``for` `(``int` `j = i + ``1``; j < N; j++) { ` ` `  `                ``// Check if A[j] = A[i] ` `                ``// increase result by 1 ` `                ``if` `(A[j] == current_value) { ` `                    ``result++; ` `                ``} ` `            ``} ` `        ``} ` ` `  `        ``// print the result ` `        ``System.out.println(result); ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `main(String[] args) ` `    ``{ ` `        ``int``[] A = { ``1``, ``5``, ``6``, ``1``, ``9``, ` `                    ``5``, ``8``, ``10``, ``8``, ``9` `}; ` `        ``int` `N = A.length; ` `        ``cntArray(A, N); ` `    ``} ` `} `

Output:

```14
```

Time Complexity: O(N2), where N is the size of array

Space complexity: O(1)

Efficient approach: We can optimize the above method by observing that the answer just depends on frequencies of numbers in the original array.
For example in array {1, 5, 6, 1, 9, 5, 8, 10, 8, 9}, frequency of 1 is 2 and sub-array contributing to answer are {1}, {1} and {1, 5, 6, 1} respectively, i.e., a total of 3.
Therefore calculate the frequency of each element in the array. Then for each element, the increment the count by the result yielded by the following formula:

( (frequency of element)*(frequency of element + 1) ) / 2

Below is the implementation of the above approach:

## CPP

 `// C++ program to Count total sub-array ` `// which start and end with same element ` ` `  `#include ` `using` `namespace` `std; ` ` `  `// function to find total sub-array ` `// which start and end with same element ` `void` `cntArray(``int` `A[], ``int` `N) ` `{ ` `    ``// initialize result with 0 ` `    ``int` `result = 0; ` ` `  `    ``// array to count frequency of 1 to N ` `    ``int` `frequency[N + 1] = { 0 }; ` ` `  `    ``for` `(``int` `i = 0; i < N; i++) { ` `        ``// update frequency of A[i] ` `        ``frequency[A[i]]++; ` `    ``} ` ` `  `    ``for` `(``int` `i = 1; i <= N; i++) { ` `        ``int` `frequency_of_i = frequency[i]; ` ` `  `        ``// update result with sub-array ` `        ``// contributed by number i ` `        ``result += +((frequency_of_i) ` `                    ``* (frequency_of_i + 1)) ` `                  ``/ 2; ` `    ``} ` ` `  `    ``// print the result ` `    ``cout << result << endl; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `A[] = { 1, 5, 6, 1, 9, 5, ` `                ``8, 10, 8, 9 }; ` `    ``int` `N = ``sizeof``(A) / ``sizeof``(``int``); ` ` `  `    ``cntArray(A, N); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java program to Count total sub-array ` `// which start and end with same element ` ` `  `public` `class` `Main { ` ` `  `    ``// function to find total sub-array which ` `    ``// start and end with same element ` `    ``public` `static` `void` `cntArray(``int` `A[], ``int` `N) ` `    ``{ ` `        ``// initialize result with 0 ` `        ``int` `result = ``0``; ` ` `  `        ``// array to count frequency of 1 to N ` `        ``int``[] frequency = ``new` `int``[N + ``1``]; ` ` `  `        ``for` `(``int` `i = ``0``; i < N; i++) { ` `            ``// update frequency of A[i] ` `            ``frequency[A[i]]++; ` `        ``} ` ` `  `        ``for` `(``int` `i = ``1``; i <= N; i++) { ` `            ``int` `frequency_of_i = frequency[i]; ` ` `  `            ``// update result with sub-array ` `            ``// contributed by number i ` `            ``result += ((frequency_of_i) ` `                       ``* (frequency_of_i + ``1``)) ` `                      ``/ ``2``; ` `        ``} ` ` `  `        ``// print the result ` `        ``System.out.println(result); ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `main(String[] args) ` `    ``{ ` ` `  `        ``int``[] A = { ``1``, ``5``, ``6``, ``1``, ``9``, ``5``, ` `                    ``8``, ``10``, ``8``, ``9` `}; ` `        ``int` `N = A.length; ` `        ``cntArray(A, N); ` `    ``} ` `} `

Output:

```14
```

Time Complexity: O(N), where N is the size of array

Space complexity: O(N)

My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

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.