Count quadruples of given type from given array

C++

// C++ program of the
// above approach

#include <cstring>
#include <iostream>

using namespace std;
const int maxN = 2002;

// lcount[i][j]: Stores the count of
// i on left of index j
int lcount[maxN][maxN];

// rcount[i][j]: Stores the count of
// i on right of index j
int rcount[maxN][maxN];

// Function to count unique elements
// on left and right of any index
void fill_counts(int a[], int n)
{
    int i, j;

    // Find the maximum array element
    int maxA = a[0];

    for (i = 0; i < n; i++) {
        if (a[i] > maxA) {
            maxA = a[i];
        }
    }

    memset(lcount, 0, sizeof(lcount));
    memset(rcount, 0, sizeof(rcount));

    for (i = 0; i < n; i++) {
        lcount[a[i]][i] = 1;
        rcount[a[i]][i] = 1;
    }

    for (i = 0; i <= maxA; i++) {

        // Calculate prefix sum of
        // counts of each value
        for (j = 0; j < n; j++) {
            lcount[i][j] = lcount[i][j - 1]
                           + lcount[i][j];
        }

        // Calculate suffix sum of
        // counts of each value
        for (j = n - 2; j >= 0; j--) {
            rcount[i][j] = rcount[i][j + 1]
                           + rcount[i][j];
        }
    }
}

// Function to count quadruples
// of the required type
int countSubsequence(int a[], int n)
{
    int i, j;
    fill_counts(a, n);
    int answer = 0;
    for (i = 1; i < n; i++) {
        for (j = i + 1; j < n - 1; j++) {

            answer += lcount[a[j]][i - 1]
                      * rcount[a[i]][j + 1];
        }
    }

    return answer;
}

// Driver Code
int main()
{
    int a[7] = { 1, 2, 3, 2, 1, 3, 2 };
    cout << countSubsequence(a, 7);

    return 0;
}

Java

// Java program of the
// above approach
import java.util.*;
class GFG{

static int maxN = 2002;

// lcount[i][j]: Stores the
// count of i on left of index j
static int [][]lcount =
       new int[maxN][maxN];

// rcount[i][j]: Stores the
// count of i on right of index j
static int [][]rcount =
       new int[maxN][maxN];

// Function to count unique
// elements on left and right
// of any index
static void fill_counts(int a[],
                        int n)
{
  int i, j;

  // Find the maximum
  // array element
  int maxA = a[0];

  for (i = 0; i < n; i++)
  {
    if (a[i] > maxA)
    {
      maxA = a[i];
    }
  }

  for (i = 0; i < n; i++)
  {
    lcount[a[i]][i] = 1;
    rcount[a[i]][i] = 1;
  }

  for (i = 0; i <= maxA; i++)
  {
    // Calculate prefix sum of
    // counts of each value
    for (j = 1; j < n; j++)
    {
      lcount[i][j] = lcount[i][j - 1] +
                     lcount[i][j];
    }

    // Calculate suffix sum of
    // counts of each value
    for (j = n - 2; j >= 0; j--)
    {
      rcount[i][j] = rcount[i][j + 1] +
                     rcount[i][j];
    }
  }
}

// Function to count quadruples
// of the required type
static int countSubsequence(int a[],
                            int n)
{
  int i, j;
  fill_counts(a, n);
  int answer = 0;
  for (i = 1; i < n; i++)
  {
    for (j = i + 1; j < n - 1; j++)
    {
      answer += lcount[a[j]][i - 1] *
                rcount[a[i]][j + 1];
    }
  }

  return answer;
}

// Driver Code
public static void main(String[] args)
{
  int a[] = {1, 2, 3, 2, 1, 3, 2};
  System.out.print(
  countSubsequence(a, a.length));
}
}

// This code is contributed by shikhasingrajput

Python3

# Python3 program of the
# above approach

maxN = 2002;

# lcount[i][j]: Stores the
# count of i on left of index j
lcount = [[0 for i in range(maxN)] for j in range(maxN)]

# rcount[i][j]: Stores the
# count of i on right of index j
rcount = [[0 for i in range(maxN)] for j in range(maxN)]

# Function to count unique
# elements on left and right
# of any index
def fill_counts(a, n):

    # Find the maximum
    # array element
    maxA = a[0];

    for i in range(n):
        if (a[i] > maxA):
            maxA = a[i];

    for i in range(n):
        lcount[a[i]][i] = 1;
        rcount[a[i]][i] = 1;

    for i in range(maxA + 1):

        # Calculate prefix sum of
        # counts of each value
        for j in range(1, n):
            lcount[i][j] = lcount[i][j - 1] + lcount[i][j];

        # Calculate suffix sum of
        # counts of each value
        for j in range(n - 2, 0, -1):
            rcount[i][j] = rcount[i][j + 1] + rcount[i][j];

# Function to count quadruples
# of the required type
def countSubsequence(a, n):
    fill_counts(a, n);
    answer = 0;
    for i in range(1, n):
        for j in range(i + 1, n - 1):
            answer += lcount[a[j]][i - 1] * rcount[a[i]][j + 1];

    return answer;

# Driver Code
if __name__ == '__main__':
    a = [1, 2, 3, 2, 1, 3, 2];
    print(countSubsequence(a, len(a)));

# This code contributed by gauravrajput1

C#

// C# program of the
// above approach
using System;

class GFG{

static int maxN = 2002;

// lcount[i][j]: Stores the
// count of i on left of index j
static int[, ] lcount = new int[maxN, maxN];

// rcount[i][j]: Stores the
// count of i on right of index j
static int[, ] rcount = new int[maxN, maxN];

// Function to count unique
// elements on left and right
// of any index
static void fill_counts(int[] a, int n)
{
    int i, j;

    // Find the maximum
    // array element
    int maxA = a[0];

    for(i = 0; i < n; i++)
    {
        if (a[i] > maxA)
        {
            maxA = a[i];
        }
    }

    for(i = 0; i < n; i++)
    {
        lcount[a[i], i] = 1;
        rcount[a[i], i] = 1;
    }

    for(i = 0; i <= maxA; i++)
    {

        // Calculate prefix sum of
        // counts of each value
        for(j = 1; j < n; j++)
        {
            lcount[i, j] = lcount[i, j - 1] +
                           lcount[i, j];
        }

        // Calculate suffix sum of
        // counts of each value
        for(j = n - 2; j >= 0; j--)
        {
            rcount[i, j] = rcount[i, j + 1] +
                           rcount[i, j];
        }
    }
}

// Function to count quadruples
// of the required type
static int countSubsequence(int[] a, int n)
{
    int i, j;
    fill_counts(a, n);
    int answer = 0;

    for(i = 1; i < n; i++)
    {
        for(j = i + 1; j < n - 1; j++)
        {
            answer += lcount[a[j], i - 1] *
                      rcount[a[i], j + 1];
        }
    }
    return answer;
}

// Driver Code
public static void Main(string[] args)
{
    int[] a = { 1, 2, 3, 2, 1, 3, 2 };

    Console.Write(countSubsequence(a, a.Length));
}
}

// This code is contributed by chitranayal

Javascript

<script>
// Javascript program of the
// above approach
let maxN = 2002;

// lcount[i][j]: Stores the
// count of i on left of index j
let lcount = new Array(maxN);

// rcount[i][j]: Stores the
// count of i on right of index j
let rcount = new Array(maxN);
for(let i = 0; i < maxN; i++)
{
    lcount[i] = new Array(maxN);
    rcount[i] = new Array(maxN);
    for(let j = 0; j < maxN; j++)
    {
        lcount[i][j] = 0;
        rcount[i][j] = 0;
    }
}

// Function to count unique
// elements on left and right
// of any index
function fill_counts(a, n)
{
    let i, j;

  // Find the maximum
  // array element
  let maxA = a[0];

  for (i = 0; i < n; i++)
  {
    if (a[i] > maxA)
    {
      maxA = a[i];
    }
  }

  for (i = 0; i < n; i++)
  {
    lcount[a[i]][i] = 1;
    rcount[a[i]][i] = 1;
  }

  for (i = 0; i <= maxA; i++)
  {
    // Calculate prefix sum of
    // counts of each value
    for (j = 1; j < n; j++)
    {
      lcount[i][j] = lcount[i][j - 1] +
                     lcount[i][j];
    }

    // Calculate suffix sum of
    // counts of each value
    for (j = n - 2; j >= 0; j--)
    {
      rcount[i][j] = rcount[i][j + 1] +
                     rcount[i][j];
    }
  }
}

// Function to count quadruples
// of the required type
function countSubsequence(a,n)
{
    let i, j;
  fill_counts(a, n);
  let answer = 0;
  for (i = 1; i < n; i++)
  {
    for (j = i + 1; j < n - 1; j++)
    {
      answer += lcount[a[j]][i - 1] *
                rcount[a[i]][j + 1];
    }
  }

  return answer;
}

// Driver Code
let a = [1, 2, 3, 2, 1, 3, 2];
document.write(countSubsequence(a, a.length));

// This code is contributed by avanitrachhadiya2155
</script>

Output:

5

Given an array arr[], the task is to find the number of quadruples of the form a[i] = a[k] and a[j] = a[l] ( 0 <= i < j < k < l <= N ) from the given array.

Examples:

Input: arr[] = {1, 2, 4, 2, 1, 5, 2}
Output: 2
Explanation: The quadruple {1, 2, 1, 2} occurs twice in the array, at indices {0, 1, 4, 6} and {0, 3, 4, 6}. Therefore, the required count is 2.

Input: arr[] = {1, 2, 3, 2, 1, 3, 2}
Output: 5
Explanation: The quadruple {1, 2, 1, 2} occurs twice in the array at indices {0, 1, 4, 6} and {0, 3, 4, 6}. The quadruples {1, 3, 1, 3}, {3, 2, 3, 2} and {2, 3, 2, 3} occurs once each. Therefore, the required count is 5.

Naive Approach: The simplest approach to solve the problem is to iteratively check all combinations of 4 elements from the given array and check if it satisfies the given condition or not.

Below is the implementation of the above approach:

C++

// C++ program of the
// above approach

#include <iostream>
using namespace std;

const int maxN = 2002;

// Function to find the count of
// the subsequence of given type
int countSubsequece(int a[], int n)
{
    int i, j, k, l;

    // Stores the count
    // of quadruples
    int answer = 0;

    // Generate all possible
    // combinations of quadruples
    for (i = 0; i < n; i++) {
        for (j = i + 1; j < n; j++) {
            for (k = j + 1; k < n; k++) {
                for (l = k + 1; l < n; l++) {

                    // Check if 1st element is
                    // equal to 3rd element
                    if (a[j] == a[l] &&

                        // Check if 2nd element is
                        // equal to 4th element
                        a[i] == a[k]) {
                        answer++;
                    }
                }
            }
        }
    }
    return answer;
}

// Driver Code
int main()
{
    int a[7] = { 1, 2, 3, 2, 1, 3, 2 };
    cout << countSubsequece(a, 7);

    return 0;
}

Java

// Java program of the
// above approach
import java.util.*;

class GFG{

// Function to find the count of
// the subsequence of given type
static int countSubsequece(int a[], int n)
{
    int i, j, k, l;

    // Stores the count
    // of quadruples
    int answer = 0;

    // Generate all possible
    // combinations of quadruples
    for(i = 0; i < n; i++)
    {
        for(j = i + 1; j < n; j++)
        {
            for(k = j + 1; k < n; k++)
            {
                for(l = k + 1; l < n; l++)
                {

                    // Check if 1st element is
                    // equal to 3rd element
                    if (a[j] == a[l] &&

                        // Check if 2nd element is
                        // equal to 4th element
                        a[i] == a[k])
                    {
                        answer++;
                    }
                }
            }
        }
    }
    return answer;
}

// Driver code
public static void main(String[] args)
{
    int[] a = { 1, 2, 3, 2, 1, 3, 2 };

    System.out.print(countSubsequece(a, 7));
}
}

// This code is contributed by code_hunt

Python3

# Python3 program of the
# above approach
maxN = 2002

# Function to find the count of
# the subsequence of given type
def countSubsequece(a, n):

    # Stores the count
    # of quadruples
    answer = 0

    # Generate all possible
    # combinations of quadruples
    for i in range(n):
        for j in range(i + 1, n):
            for k in range(j + 1, n):
                for l in range(k + 1, n):

                    # Check if 1st element is
                    # equal to 3rd element
                    if (a[j] == a[l] and

                        # Check if 2nd element is
                        # equal to 4th element
                        a[i] == a[k]):
                        answer += 1

    return answer

# Driver Code
if __name__ == '__main__':

    a = [ 1, 2, 3, 2, 1, 3, 2 ]

    print(countSubsequece(a, 7))

# This code is contributed by bgangwar59

C#

// C# program of the
// above approach
using System;

class GFG{

// Function to find the count of
// the subsequence of given type
static int countSubsequece(int[] a, int n)
{
    int i, j, k, l;

    // Stores the count
    // of quadruples
    int answer = 0;

    // Generate all possible
    // combinations of quadruples
    for(i = 0; i < n; i++)
    {
        for(j = i + 1; j < n; j++)
        {
            for(k = j + 1; k < n; k++)
            {
                for(l = k + 1; l < n; l++)
                {

                    // Check if 1st element is
                    // equal to 3rd element
                    if (a[j] == a[l] &&

                        // Check if 2nd element is
                        // equal to 4th element
                        a[i] == a[k])
                    {
                        answer++;
                    }
                }
            }
        }
    }
    return answer;
}

// Driver Code
public static void Main()
{
    int[] a = { 1, 2, 3, 2, 1, 3, 2 };

    Console.WriteLine(countSubsequece(a, 7));
}
}

// This code is contributed by susmitakundugoaldanga

Javascript

<script>
    // Javascript program of the above approach

    // Function to find the count of
    // the subsequence of given type
    function countSubsequece(a, n)
    {
        let i, j, k, l;

        // Stores the count
        // of quadruples
        let answer = 0;

        // Generate all possible
        // combinations of quadruples
        for(i = 0; i < n; i++)
        {
            for(j = i + 1; j < n; j++)
            {
                for(k = j + 1; k < n; k++)
                {
                    for(l = k + 1; l < n; l++)
                    {

                        // Check if 1st element is
                        // equal to 3rd element
                        if (a[j] == a[l] &&

                            // Check if 2nd element is
                            // equal to 4th element
                            a[i] == a[k])
                        {
                            answer++;
                        }
                    }
                }
            }
        }
        return answer;
    }

    let a = [ 1, 2, 3, 2, 1, 3, 2 ];
    document.write(countSubsequece(a, 7));

    // This code is contributed by mukesh07.
</script>

Output:

5

Time Complexity: O(N⁴)
Auxiliary Space: O(1)

Efficient Approach: To optimize the above approach, the idea is to maintain two arrays to store the count of element X on the left and right side of every index. Follow the steps below to solve the problem:

• Maintain two arrays lcount[i][j] and rcount[i][j] which stores the count of the element i in the indices less than j and rcount[i][j] stores the count of the element i in the indices greater than j.
• Iterate over the nested loop from 1 to N and find all the subsequence of type XYXY

answer += lcount[a[i]][j-1] * rcount[a[j]][i-1]

Below is the implementation of the above approach: 

C++

// C++ program of the
// above approach

#include <cstring>
#include <iostream>

using namespace std;
const int maxN = 2002;

// lcount[i][j]: Stores the count of
// i on left of index j
int lcount[maxN][maxN];

// rcount[i][j]: Stores the count of
// i on right of index j
int rcount[maxN][maxN];

// Function to count unique elements
// on left and right of any index
void fill_counts(int a[], int n)
{
    int i, j;

    // Find the maximum array element
    int maxA = a[0];

    for (i = 0; i < n; i++) {
        if (a[i] > maxA) {
            maxA = a[i];
        }
    }

    memset(lcount, 0, sizeof(lcount));
    memset(rcount, 0, sizeof(rcount));

    for (i = 0; i < n; i++) {
        lcount[a[i]][i] = 1;
        rcount[a[i]][i] = 1;
    }

    for (i = 0; i <= maxA; i++) {

        // Calculate prefix sum of
        // counts of each value
        for (j = 0; j < n; j++) {
            lcount[i][j] = lcount[i][j - 1]
                           + lcount[i][j];
        }

        // Calculate suffix sum of
        // counts of each value
        for (j = n - 2; j >= 0; j--) {
            rcount[i][j] = rcount[i][j + 1]
                           + rcount[i][j];
        }
    }
}

// Function to count quadruples
// of the required type
int countSubsequence(int a[], int n)
{
    int i, j;
    fill_counts(a, n);
    int answer = 0;
    for (i = 1; i < n; i++) {
        for (j = i + 1; j < n - 1; j++) {

            answer += lcount[a[j]][i - 1]
                      * rcount[a[i]][j + 1];
        }
    }

    return answer;
}

// Driver Code
int main()
{
    int a[7] = { 1, 2, 3, 2, 1, 3, 2 };
    cout << countSubsequence(a, 7);

    return 0;
}

Java

// Java program of the
// above approach
import java.util.*;

class GFG{
static int maxN = 2002;

// lcount[i][j]: Stores the
// count of i on left of index j
static int [][]lcount =
       new int[maxN][maxN];

// rcount[i][j]: Stores the
// count of i on right of index j
static int [][]rcount =
       new int[maxN][maxN];

// Function to count unique
// elements on left and right
// of any index
static void fill_counts(int a[],
                        int n)
{
  int i, j;

  // Find the maximum
  // array element
  int maxA = a[0];

  for (i = 0; i < n; i++)
  {
    if (a[i] > maxA)
    {
      maxA = a[i];
    }
  }

  for (i = 0; i < n; i++)
  {
    lcount[a[i]][i] = 1;
    rcount[a[i]][i] = 1;
  }

  for (i = 0; i <= maxA; i++)
  {
    // Calculate prefix sum of
    // counts of each value
    for (j = 1; j < n; j++)
    {
      lcount[i][j] = lcount[i][j - 1] +
                     lcount[i][j];
    }

    // Calculate suffix sum of
    // counts of each value
    for (j = n - 2; j >= 0; j--)
    {
      rcount[i][j] = rcount[i][j + 1] +
                     rcount[i][j];
    }
  }
}

// Function to count quadruples
// of the required type
static int countSubsequence(int a[],
                            int n)
{
  int i, j;
  fill_counts(a, n);
  int answer = 0;
  for (i = 1; i < n; i++)
  {
    for (j = i + 1; j < n - 1; j++)
    {
      answer += lcount[a[j]][i - 1] *
                rcount[a[i]][j + 1];
    }
  }

  return answer;
}

// Driver Code
public static void main(String[] args)
{
  int a[] = {1, 2, 3, 2, 1, 3, 2};
  System.out.print(
  countSubsequence(a, a.length));
}
}

// This code is contributed by shikhasingrajput

Python3

# Python3 program of the
# above approach
maxN = 2002

# lcount[i][j]: Stores the count of
# i on left of index j
lcount = [[0 for i in range(maxN)]
             for j in range(maxN)]

# rcount[i][j]: Stores the count of
# i on right of index j
rcount = [[0 for i in range(maxN)]
             for j in range(maxN)]

# Function to count unique elements
# on left and right of any index
def fill_counts(a, n):

    # Find the maximum array element
    maxA = a[0]

    for i in range(n):
        if (a[i] > maxA):
            maxA = a[i]

    for i in range(n):
        lcount[a[i]][i] = 1
        rcount[a[i]][i] = 1

    for i in range(maxA + 1):

        # Calculate prefix sum of
        # counts of each value
        for j in range(n) :
            lcount[i][j] = (lcount[i][j - 1] +
                            lcount[i][j])

        # Calculate suffix sum of
        # counts of each value
        for j in range(n - 2, -1, -1):
            rcount[i][j] = (rcount[i][j + 1] +
                            rcount[i][j])

# Function to count quadruples
# of the required type
def countSubsequence(a, n):

    fill_counts(a, n)
    answer = 0

    for i in range(1, n):
        for j in range(i + 1, n - 1):
            answer += (lcount[a[j]][i - 1] *
                       rcount[a[i]][j + 1])

    return answer

# Driver Code
a = [ 1, 2, 3, 2, 1, 3, 2 ]

print(countSubsequence(a, 7))

# This code is contributed by divyesh072019

C#

// C# program of the
// above approach
using System;

class GFG{

static int maxN = 2002;

// lcount[i,j]: Stores the
// count of i on left of index j
static int [,]lcount = new int[maxN, maxN];

// rcount[i,j]: Stores the
// count of i on right of index j
static int [,]rcount = new int[maxN, maxN];

// Function to count unique
// elements on left and right
// of any index
static void fill_counts(int []a,
                        int n)
{
    int i, j;

    // Find the maximum
    // array element
    int maxA = a[0];

    for(i = 0; i < n; i++)
    {
        if (a[i] > maxA)
        {
            maxA = a[i];
        }
    }

    for(i = 0; i < n; i++)
    {
        lcount[a[i], i] = 1;
        rcount[a[i], i] = 1;
    }

    for(i = 0; i <= maxA; i++)
    {

        // Calculate prefix sum of
        // counts of each value
        for (j = 1; j < n; j++)
        {
            lcount[i, j] = lcount[i, j - 1] +
                           lcount[i, j];
        }

        // Calculate suffix sum of
        // counts of each value
        for(j = n - 2; j >= 0; j--)
        {
            rcount[i, j] = rcount[i, j + 1] +
                           rcount[i, j];
        }
    }
}

// Function to count quadruples
// of the required type
static int countSubsequence(int []a,
                            int n)
{
    int i, j;
    fill_counts(a, n);

    int answer = 0;

    for(i = 1; i < n; i++)
    {
        for(j = i + 1; j < n - 1; j++)
        {
            answer += lcount[a[j], i - 1] *
                      rcount[a[i], j + 1];
        }
    }
    return answer;
}

// Driver Code
public static void Main(String[] args)
{
    int []a = { 1, 2, 3, 2, 1, 3, 2 };

    Console.Write(
        countSubsequence(a, a.Length));
}
}

// This code is contributed by Princi Singh

Javascript

<script>
// Javascript program of the
// above approach
let maxN = 2002;

// lcount[i][j]: Stores the
// count of i on left of index j
let lcount = new Array(maxN);

// rcount[i][j]: Stores the
// count of i on right of index j
let rcount = new Array(maxN);

for(let i = 0; i < maxN; i++)
{
    lcount[i] = new Array(maxN);
    rcount[i] = new Array(maxN);
    for(let j = 0; j < maxN; j++)
    {
        lcount[i][j] = 0;
        rcount[i][j] = 0;
    }

}

// Function to count unique
// elements on left and right
// of any index
function fill_counts(a,n)
{
    let i, j;

  // Find the maximum
  // array element
  let maxA = a[0];

  for (i = 0; i < n; i++)
  {
    if (a[i] > maxA)
    {
      maxA = a[i];
    }
  }

  for (i = 0; i < n; i++)
  {
    lcount[a[i]][i] = 1;
    rcount[a[i]][i] = 1;
  }

  for (i = 0; i <= maxA; i++)
  {
    // Calculate prefix sum of
    // counts of each value
    for (j = 1; j < n; j++)
    {
      lcount[i][j] = lcount[i][j - 1] +
                     lcount[i][j];
    }

    // Calculate suffix sum of
    // counts of each value
    for (j = n - 2; j >= 0; j--)
    {
      rcount[i][j] = rcount[i][j + 1] +
                     rcount[i][j];
    }
  }
}

// Function to count quadruples
// of the required type
function countSubsequence(a,n)
{
    let i, j;
  fill_counts(a, n);
  let answer = 0;
  for (i = 1; i < n; i++)
  {
    for (j = i + 1; j < n - 1; j++)
    {
      answer += lcount[a[j]][i - 1] *
                rcount[a[i]][j + 1];
    }
  }

  return answer;
}

// Driver Code
let a=[1, 2, 3, 2, 1, 3, 2];
document.write(countSubsequence(a, a.length));

// This code is contributed by rag2127
</script>

Output:

5

Time Complexity: O(N²)
Auxiliary Space: O(N²)