将数组划分为K个相等和子数组的方式数量

给定一个整数K和N个整数的数组arr [] ，任务是找到将数组拆分为K个非零长度的相等和子数组的方式。

例子：

Input: arr[] = {0, 0, 0, 0}, K = 3
Output: 3
All possible ways are:
{{0}, {0}, {0, 0}}
{{0}, {0, 0}, {0}}
{{0, 0}, {0}, {0}}

Input: arr[] = {1, -1, 1, -1}, K = 2
Output: 1

方法：可以使用动态编程解决此问题。以下是我们的算法：

1. 找到数组所有元素的总和，并将其存储在变量SUM中。
   在执行步骤2之前，让我们尝试了解DP的状态。
   为此，可视化放置条以将数组划分为K个相等的部分。因此，我们必须总共放置K – 1个小节。
   因此，我们的dp状态将包含2个项。
   • i –我们当前所在元素的索引。
   • ck –我们已经插入的小节数+ 1。

   dp [i] [ck]可以定义为将剩余条形放入数组以使其分成K个相等一半的方式的数量。现在，让我们继续执行我们算法的步骤2。

2. 用i = 0和ck = 1调用递归函数，递归关系将是：

   Case 1: sum upto index i equals ((SUM)/k)* ck
   dp[i][ck] = dp[i+1][ck] + dp[i+1][ck+1]
   Case 2: sum upto index not i equals ((SUM)/k)* ck
   dp[i][ck] = dp[i+1][ck]

下面是上述方法的实现：

C++

// C++ implementation of the approach
#include 
#define max_size 20
#define max_k 20
using namespace std;
  
// Array to store the states of DP
int dp[max_size][max_k];
  
// Array to check if a
// state has been solved before
bool v[max_size][max_k];
  
// To store the sum of
// the array elements
int sum = 0;
  
// Function to find the sum of
// all the array elements
void findSum(int arr[], int n)
{
    for (int i = 0; i < n; i++)
        sum += arr[i];
}
  
// Function to return the number of ways
int cntWays(int arr[], int i, int ck,
            int k, int n, int curr_sum)
{
    // If sum is not divisible by k
    // answer will be zero
    if (sum % k != 0)
        return 0;
    if (i != n and ck == k + 1)
        return 0;
  
    // Base case
    if (i == n) {
        if (ck == k + 1)
            return 1;
        else
            return 0;
    }
  
    // To check if a state
    // has been solved before
    if (v[i][ck])
        return dp[i][ck];
  
    // Sum of all the numbers from the beginning
    // of the array
    curr_sum += arr[i];
  
    // Setting the current state as solved
    v[i][ck] = 1;
  
    // Recurrence relation
    dp[i][ck] = cntWays(arr, i + 1, ck, k, n, curr_sum);
    if (curr_sum == (sum / k) * ck)
        dp[i][ck] += cntWays(arr, i + 1, ck + 1, k, n, curr_sum);
  
    // Returning solved state
    return dp[i][ck];
}
  
// Driver code
int main()
{
    int arr[] = { 1, -1, 1, -1, 1, -1 };
    int n = sizeof(arr) / sizeof(int);
    int k = 2;
  
    // Function call to find the
    // sum of the array elements
    findSum(arr, n);
  
    // Print the number of ways
    cout << cntWays(arr, 0, 1, k, n, 0);
}

Java

// Java implementation of the approach
class GFG 
{
      
static int max_size= 20;
static int max_k =20;
  
// Array to store the states of DP
static int [][]dp = new int[max_size][max_k];
  
// Array to check if a
// state has been solved before
static boolean [][]v = new boolean[max_size][max_k];
  
// To store the sum of
// the array elements
static int sum = 0;
  
// Function to find the sum of
// all the array elements
static void findSum(int arr[], int n)
{
    for (int i = 0; i < n; i++)
        sum += arr[i];
}
  
// Function to return the number of ways
static int cntWays(int arr[], int i, int ck,
            int k, int n, int curr_sum)
{
    // If sum is not divisible by k
    // answer will be zero
    if (sum % k != 0)
        return 0;
    if (i != n && ck == k + 1)
        return 0;
  
    // Base case
    if (i == n) 
    {
        if (ck == k + 1)
            return 1;
        else
            return 0;
    }
  
    // To check if a state
    // has been solved before
    if (v[i][ck])
        return dp[i][ck];
  
    // Sum of all the numbers from the beginning
    // of the array
    curr_sum += arr[i];
  
    // Setting the current state as solved
    v[i][ck] = true;
  
    // Recurrence relation
    dp[i][ck] = cntWays(arr, i + 1, ck, k, n, curr_sum);
    if (curr_sum == (sum / k) * ck)
        dp[i][ck] += cntWays(arr, i + 1, ck + 1, k, n, curr_sum);
  
    // Returning solved state
    return dp[i][ck];
}
  
// Driver code
public static void main(String[] args)
{
    int arr[] = { 1, -1, 1, -1, 1, -1 };
    int n = arr.length;
    int k = 2;
  
    // Function call to find the
    // sum of the array elements
    findSum(arr, n);
  
    // Print the number of ways
    System.out.println(cntWays(arr, 0, 1, k, n, 0));
}
}
  
// This code is contributed by Princi Singh

Python3

# Python3 implementation of the approach
import numpy as np
  
max_size = 20 
max_k = 20 
  
  
# Array to store the states of DP 
dp = np.zeros((max_size,max_k)); 
  
# Array to check if a 
# state has been solved before 
v = np.zeros((max_size,max_k)); 
  
# To store the sum of 
# the array elements 
sum = 0; 
  
# Function to find the sum of 
# all the array elements 
def findSum(arr, n) : 
    global sum
    for i in range(n) :
        sum += arr[i]; 
  
  
# Function to return the number of ways 
def cntWays(arr, i, ck, k, n,  curr_sum) : 
  
    # If sum is not divisible by k 
    # answer will be zero 
    if (sum % k != 0) :
        return 0; 
    if (i != n and ck == k + 1) :
        return 0; 
  
    # Base case 
    if (i == n) :
        if (ck == k + 1) :
            return 1; 
        else :
            return 0; 
  
    # To check if a state 
    # has been solved before 
    if (v[i][ck]) :
        return dp[i][ck]; 
  
    # Sum of all the numbers from the beginning 
    # of the array 
    curr_sum += arr[i]; 
  
    # Setting the current state as solved 
    v[i][ck] = 1; 
  
    # Recurrence relation 
    dp[i][ck] = cntWays(arr, i + 1, ck, k, n, curr_sum); 
    if (curr_sum == (sum / k) * ck)  :
        dp[i][ck] += cntWays(arr, i + 1, ck + 1, k, n, curr_sum); 
  
    # Returning solved state 
    return dp[i][ck]; 
   
  
# Driver code 
if __name__ == "__main__" : 
  
    arr = [ 1, -1, 1, -1, 1, -1 ]; 
    n = len(arr); 
    k = 2; 
  
    # Function call to find the 
    # sum of the array elements 
    findSum(arr, n); 
  
    # Print the number of ways 
    print(cntWays(arr, 0, 1, k, n, 0)); 
  
    # This code is contributed by AnkitRai01

C#

// C# implementation of the approach
using System;     
      
class GFG 
{
      
static int max_size= 20;
static int max_k =20;
  
// Array to store the states of DP
static int [,]dp = new int[max_size, max_k];
  
// Array to check if a
// state has been solved before
static Boolean [,]v = new Boolean[max_size, max_k];
  
// To store the sum of
// the array elements
static int sum = 0;
  
// Function to find the sum of
// all the array elements
static void findSum(int []arr, int n)
{
    for (int i = 0; i < n; i++)
        sum += arr[i];
}
  
// Function to return the number of ways
static int cntWays(int []arr, int i, int ck,
            int k, int n, int curr_sum)
{
    // If sum is not divisible by k
    // answer will be zero
    if (sum % k != 0)
        return 0;
    if (i != n && ck == k + 1)
        return 0;
  
    // Base case
    if (i == n) 
    {
        if (ck == k + 1)
            return 1;
        else
            return 0;
    }
  
    // To check if a state
    // has been solved before
    if (v[i, ck])
        return dp[i, ck];
  
    // Sum of all the numbers from the beginning
    // of the array
    curr_sum += arr[i];
  
    // Setting the current state as solved
    v[i, ck] = true;
  
    // Recurrence relation
    dp[i,ck] = cntWays(arr, i + 1, ck, k, n, curr_sum);
    if (curr_sum == (sum / k) * ck)
        dp[i, ck] += cntWays(arr, i + 1, ck + 1, k, n, curr_sum);
  
    // Returning solved state
    return dp[i, ck];
}
  
// Driver code
public static void Main(String[] args)
{
    int []arr = { 1, -1, 1, -1, 1, -1 };
    int n = arr.Length;
    int k = 2;
  
    // Function call to find the
    // sum of the array elements
    findSum(arr, n);
  
    // Print the number of ways
    Console.WriteLine(cntWays(arr, 0, 1, k, n, 0));
}
}
  
// This code contributed by Rajput-Ji

输出：

2

时间复杂度： O(n * k)