具有完全K个完美平方数的子数组的数量

给定一个未排序的整数数组arr []和一个整数K。任务是计算具有精确的K个完美平方数的子数组的数量。
例子：

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

简单方法：
如果计数等于K，则生成所有子数组并计算给定子数组中的理想数的数目，并增加ans变量的计数。
时间复杂度： O(N ² )

高效方法：

1. 遍历给定的数组arr []并检查元素是否为Perfect Square。
2. 如果当前元素是Perfect Square，则将该索引处的array值更改为1，否则将该索引处的值更改为0。
3. 现在，给定的数组将转换为Binary Array。
4. 现在，使用本文讨论的方法，在上述二进制数组中找到总和等于K的子数组的计数。

下面是上述方法的实现。

C++

// C++ program to Count of subarrays having
// exactly K perfect square numbers.
  
#include 
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 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 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 prevSum = new Dictionary(); 
                                               
    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

输出：

4

时间复杂度： O(N)
空间复杂度： O(N)