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 the total number of subarrays that 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:
C++
#include <bits/stdc++.h>
using namespace std;
void cntArray( int A[], int N)
{
int result = 0;
for ( int i = 0; i < N; i++) {
result++;
int current_value = A[i];
for ( int j = i + 1; j < N; j++) {
if (A[j] == current_value) {
result++;
}
}
}
cout << result << endl;
}
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
public class Main {
public static void cntArray( int A[], int N)
{
int result = 0 ;
for ( int i = 0 ; i < N; i++) {
result++;
int current_value = A[i];
for ( int j = i + 1 ; j < N; j++) {
if (A[j] == current_value) {
result++;
}
}
}
System.out.println(result);
}
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);
}
}
|
Python3
def cntArray(A, N):
result = 0
for i in range ( 0 , N):
result = result + 1
current_value = A[i]
for j in range (i + 1 , N):
if (A[j] = = current_value):
result = result + 1
print (result)
print ( "\n" )
A = [ 1 , 5 , 6 , 1 , 9 , 5 , 8 , 10 , 8 , 9 ]
N = len (A)
cntArray(A, N)
|
C#
using System;
class GFG{
public static void cntArray( int []A, int N)
{
int result = 0;
for ( int i = 0; i < N; i++)
{
result++;
int current_value = A[i];
for ( int j = i + 1; j < N; j++)
{
if (A[j] == current_value)
{
result++;
}
}
}
Console.Write(result);
}
public static void Main()
{
int [] A = { 1, 5, 6, 1, 9,
5, 8, 10, 8, 9 };
int N = A.Length;
cntArray(A, N);
}
}
|
Javascript
<script>
function cntArray(A, N)
{
var result = 0;
for ( var i = 0; i < N; i++) {
result++;
var current_value = A[i];
for ( var j = i + 1; j < N; j++) {
if (A[j] == current_value) {
result++;
}
}
}
document.write( result );
}
var A = [1, 5, 6, 1, 9,
5, 8, 10, 8, 9];
var N = A.length;
cntArray(A, N);
</script>
|
Time Complexity: O(N2), where N is the size of the 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:
C++
#include <bits/stdc++.h>
using namespace std;
void cntArray( int A[], int N)
{
int result = 0;
int frequency[N + 1] = { 0 };
for ( int i = 0; i < N; i++) {
frequency[A[i]]++;
}
for ( int i = 1; i <= N; i++) {
int frequency_of_i = frequency[i];
result += +((frequency_of_i)
* (frequency_of_i + 1))
/ 2;
}
cout << result << endl;
}
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
public class Main {
public static void cntArray( int A[], int N)
{
int result = 0 ;
int [] frequency = new int [N + 1 ];
for ( int i = 0 ; i < N; i++) {
frequency[A[i]]++;
}
for ( int i = 1 ; i <= N; i++) {
int frequency_of_i = frequency[i];
result += ((frequency_of_i)
* (frequency_of_i + 1 ))
/ 2 ;
}
System.out.println(result);
}
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);
}
}
|
Python3
def cntArray(A, N):
result = 0
frequency = [ 0 ] * (N + 1 )
for i in range ( 0 , N):
frequency[A[i]] = frequency[A[i]] + 1
for i in range ( 1 , N + 1 ):
frequency_of_i = frequency[i]
result = result + ((frequency_of_i) *
(frequency_of_i + 1 )) / 2
print ( int (result))
print ( "\n" )
A = [ 1 , 5 , 6 , 1 , 9 , 5 , 8 , 10 , 8 , 9 ]
N = len (A)
cntArray(A, N)
|
C#
using System;
class GFG{
public static void cntArray( int []A, int N)
{
int result = 0;
int [] frequency = new int [N + 1];
for ( int i = 0; i < N; i++)
{
frequency[A[i]]++;
}
for ( int i = 1; i <= N; i++)
{
int frequency_of_i = frequency[i];
result += ((frequency_of_i) *
(frequency_of_i + 1)) / 2;
}
Console.Write(result);
}
public static void Main()
{
int [] A = { 1, 5, 6, 1, 9, 5,
8, 10, 8, 9 };
int N = A.Length;
cntArray(A, N);
}
}
|
Javascript
<script>
function cntArray(A, N)
{
let result = 0;
let frequency = Array.from({length: N+1}, (_, i) => 0);
for (let i = 0; i < N; i++) {
frequency[A[i]]++;
}
for (let i = 1; i <= N; i++) {
let frequency_of_i = frequency[i];
result += ((frequency_of_i)
* (frequency_of_i + 1))
/ 2;
}
document.write(result);
}
let A = [ 1, 5, 6, 1, 9, 5,
8, 10, 8, 9 ];
let N = A.length;
cntArray(A, N);
</script>
|
Time Complexity: O(N), where N is the size of the array
Space complexity: O(N)
Related Topic: Subarrays, Subsequences, and Subsets in Array
Last Updated :
11 Jul, 2022
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...