Count of subarrays having exactly K perfect square numbers

Given a unsorted integer array arr[] and an integer K. The task is to count the number of subarray with exactly K Perfect Square Numbers. 
Examples:

Input: arr[] = {2, 4, 9, 3}, K = 2 
Output: 4 
Explanation:
Since total number of perfect square number in the array are 2. 
So the 4 subarrays with 2 perfect square number are: 
1.{2, 4, 9} 
2.{2, 4, 9, 3} 
3.{4, 9} 
4.{4, 9, 3}
Input: arr[] = {4, 2, 5}, K = 3 
Output: 0 

Simple Approach:
Generate all the subarrays and count the number of perfect numbers in the given subarray if the count is equal to K increment the count for ans variable.
Time Complexity: O(N²)
Efficient Approach:

1. Traverse the given array arr[] and check whether the element is Perfect Square or not. 
   
2. If the current element is Perfect Square then change the value of array at that index to 1, Else change the value at that index to 0. 
   
3. Now the given array is converted into Binary Array. 
   
4. Now, Find the count of subarray with sum equals to K in the above Binary Array using the approach discussed in this article. 
   

Below is the implementation of the above approach.

C++

// C++ program to Count of subarrays having
// exactly K perfect square numbers.

#include <bits/stdc++.h>
using namespace std;

// A utility function to check if
// the number n is perfect square
// or not
bool isPerfectSquare(long double x)
{
    // Find floating point value of
    // square root of x.
    long double sr = sqrt(x);

    // If square root is an integer
    return ((sr - floor(sr)) == 0);
}

// Function to find number of subarrays
// with sum exactly equal to k
int findSubarraySum(int arr[], int n, int K)
{
    // STL map to store number of subarrays
    // starting from index zero having
    // particular value of sum.
    unordered_map<int, int> prevSum;

    int res = 0;

    // To store the sum of element traverse
    // so far
    int currsum = 0;

    for (int i = 0; i < n; i++) {

        // Add current element to currsum
        currsum += arr[i];

        // If currsum = K, then a new
        // subarray is found
        if (currsum == K) {
            res++;
        }

        // If currsum > K then find the
        // no. of subarrays with sum
        // currsum - K and exclude those
        // subarrays
        if (prevSum.find(currsum - K)
            != prevSum.end())
            res += (prevSum[currsum - K]);

        // Add currsum to count of
        // different values of sum
        prevSum[currsum]++;
    }

    // Return the final result
    return res;
}

// Function to count the subarray with K
// perfect square numbers
void countSubarray(int arr[], int n, int K)
{
    // Update the array element
    for (int i = 0; i < n; i++) {

        // If current element is perfect
        // square then update the
        // arr[i] to 1
        if (isPerfectSquare(arr[i])) {
            arr[i] = 1;
        }

        // Else change arr[i] to 0
        else {
            arr[i] = 0;
        }
    }

    // Function Call
    cout << findSubarraySum(arr, n, K);
}

// Driver Code
int main()
{
    int arr[] = { 2, 4, 9, 2 };
    int K = 2;
    int N = sizeof(arr) / sizeof(arr[0]);

    // Function Call
    countSubarray(arr, N, K);
    return 0;
}

Java

// Java program to Count of subarrays having
// exactly K perfect square numbers.
import java.util.*;

class GFG {

// A utility function to check if
// the number n is perfect square
// or not
static boolean isPerfectSquare(double x)
{

    // Find floating point value of
    // square root of x.
    double sr = Math.sqrt(x);

    // If square root is an integer
    return ((sr - Math.floor(sr)) == 0);
}

// Function to find number of subarrays
// with sum exactly equal to k
static int findSubarraySum(int arr[],
                           int n, int K)
{

    // Map to store number of subarrays
    // starting from index zero having
    // particular value of sum.
    Map<Integer, Integer> prevSum = new HashMap<>();

    int res = 0;

    // To store the sum of element
    // traverse so far
    int currsum = 0;

    for(int i = 0; i < n; i++)
    {

       // Add current element to currsum
       currsum += arr[i];

       // If currsum = K, then a new
       // subarray is found
       if (currsum == K)
       {
           res++;
       }

       // If currsum > K then find the
       // no. of subarrays with sum
       // currsum - K and exclude those
       // subarrays
       if (prevSum.containsKey(currsum - K))
           res += (prevSum.get(currsum - K));

       // Add currsum to count of
       // different values of sum
       prevSum.put(currsum,
                   prevSum.getOrDefault(currsum, 0) + 1);
    }

    // Return the final result
    return res;
}

// Function to count the subarray with K
// perfect square numbers
static void countSubarray(int arr[], int n, int K)
{

    // Update the array element
    for(int i = 0; i < n; i++)
    {

       // If current element is perfect
       // square then update the
       // arr[i] to 1
       if (isPerfectSquare(arr[i]))
       {
           arr[i] = 1;
       }

       // Else change arr[i] to 0
       else
       {
           arr[i] = 0;
       }
    }

    // Function Call
    System.out.println(findSubarraySum(arr, n, K));
}

// Driver code
public static void main(String[] args)
{
    int arr[] = { 2, 4, 9, 2 };
    int K = 2;
    int N = arr.length;

    // Function Call
    countSubarray(arr, N, K);
}
}

// This code is contributed by offbeat

Python3

# Python3 program to count of subarrays
# having exactly K perfect square numbers.
from collections import defaultdict
import math

# A utility function to check if
# the number n is perfect square
# or not
def isPerfectSquare(x):

    # Find floating point value of
    # square root of x.
    sr = math.sqrt(x)

    # If square root is an integer
    return ((sr - math.floor(sr)) == 0)

# Function to find number of subarrays
# with sum exactly equal to k
def findSubarraySum(arr, n, K):

    # STL map to store number of subarrays
    # starting from index zero having
    # particular value of sum.
    prevSum = defaultdict(int)

    res = 0

    # To store the sum of element traverse
    # so far
    currsum = 0

    for i in range(n):

        # Add current element to currsum
        currsum += arr[i]

        # If currsum = K, then a new
        # subarray is found
        if (currsum == K):
            res += 1

        # If currsum > K then find the
        # no. of subarrays with sum
        # currsum - K and exclude those
        # subarrays
        if ((currsum - K) in prevSum):
            res += (prevSum[currsum - K])

        # Add currsum to count of
        # different values of sum
        prevSum[currsum] += 1

    # Return the final result
    return res

# Function to count the subarray with K
# perfect square numbers
def countSubarray(arr, n, K):

    # Update the array element
    for i in range(n):

        # If current element is perfect
        # square then update the
        # arr[i] to 1
        if (isPerfectSquare(arr[i])):
            arr[i] = 1

        # Else change arr[i] to 0
        else:
            arr[i] = 0

    # Function Call
    print(findSubarraySum(arr, n, K))

# Driver Code
if __name__ == "__main__":

    arr = [ 2, 4, 9, 2 ]
    K = 2
    N = len(arr)

    # Function Call
    countSubarray(arr, N, K)

# This code is contributed by chitranayal

C#

// C# program to count of subarrays having
// exactly K perfect square numbers.
using System;
using System.Collections;
using System.Collections.Generic;

class GFG{

// A utility function to check if
// the number n is perfect square
// or not
static bool isPerfectSquare(double x)
{

    // Find floating point value of
    // square root of x.
    double sr = Math.Sqrt(x);

    // If square root is an integer
    return ((sr - Math.Floor(sr)) == 0);
}

// Function to find number of subarrays
// with sum exactly equal to k
static int findSubarraySum(int []arr,
                           int n, int K)
{

    // Map to store number of subarrays
    // starting from index zero having
    // particular value of sum.
    Dictionary<int,
               int> prevSum = new Dictionary<int,
                                             int>();

    int res = 0;

    // To store the sum of element
    // traverse so far
    int currsum = 0;

    for(int i = 0; i < n; i++)
    {

        // Add current element to currsum
        currsum += arr[i];

        // If currsum = K, then a new
        // subarray is found
        if (currsum == K)
        {
            res++;
        }

        // If currsum > K then find the
        // no. of subarrays with sum
        // currsum - K and exclude those
        // subarrays
        if (prevSum.ContainsKey(currsum - K))
            res += (prevSum[currsum - K]);

        // Add currsum to count of
        // different values of sum
        if(prevSum.ContainsKey(currsum))
        {
            prevSum[currsum]++;
        }
        else
        {
            prevSum[currsum] = 1;
        }
    }

    // Return the final result
    return res;
}

// Function to count the subarray with K
// perfect square numbers
static void countSubarray(int []arr, int n,
                                     int K)
{

    // Update the array element
    for(int i = 0; i < n; i++)
    {

        // If current element is perfect
        // square then update the
        // arr[i] to 1
        if (isPerfectSquare(arr[i]))
        {
            arr[i] = 1;
        }

        // Else change arr[i] to 0
        else
        {
            arr[i] = 0;
        }
    }

    // Function call
    Console.Write(findSubarraySum(arr, n, K));
}

// Driver Code
public static void Main(string[] args)
{
    int []arr = { 2, 4, 9, 2 };
    int K = 2;
    int N = arr.Length;

    // Function call
    countSubarray(arr, N, K);
}
}

// This code is contributed by rutvik_56

Javascript

<script>
// Javascript program to Count of subarrays having
// exactly K perfect square numbers.

// A utility function to check if
// the number n is perfect square
// or not
function isPerfectSquare(x)
{

    // Find floating point value of
    // square root of x.
    let sr = Math.sqrt(x);

    // If square root is an integer
    return ((sr - Math.floor(sr)) == 0);
}

// Function to find number of subarrays
// with sum exactly equal to k
function findSubarraySum(arr, n, k)
{

    // Map to store number of subarrays
    // starting from index zero having
    // particular value of sum.
    let prevSum = new Map();
    let res = 0;

    // To store the sum of element
    // traverse so far
    let currsum = 0;
    for(let i = 0; i < n; i++)
    {

       // Add current element to currsum
       currsum += arr[i];

       // If currsum = K, then a new
       // subarray is found
       if (currsum == K)
       {
           res++;
       }

       // If currsum > K then find the
       // no. of subarrays with sum
       // currsum - K and exclude those
       // subarrays
       if (prevSum.has(currsum - K))
           res += (prevSum.get(currsum - K));

       // Add currsum to count of
       // different values of sum
       prevSum.set(currsum,
                   prevSum.get(currsum)==null?1:prevSum.get(currsum) + 1);
    }

    // Return the final result
    return res;
}

// Function to count the subarray with K
// perfect square numbers
function countSubarray(arr, n, k)
{

    // Update the array element
    for(let i = 0; i < n; i++)
    {

       // If current element is perfect
       // square then update the
       // arr[i] to 1
       if (isPerfectSquare(arr[i]))
       {
           arr[i] = 1;
       }

       // Else change arr[i] to 0
       else
       {
           arr[i] = 0;
       }
    }

    // Function Call
    document.write(findSubarraySum(arr, n, K));
}

// Driver code
let arr=[2, 4, 9, 2];
let K = 2;
let N = arr.length;

// Function Call
countSubarray(arr, N, K);

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

Output:

4

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

Related Topic: Subarrays, Subsequences, and Subsets in Array