将数组划分为 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 bar。
   因此，我们的 dp 状态将包含 2 个术语。
   • i – 我们当前所在元素的索引。
   • ck – 我们已经插入的柱数 + 1。
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

Javascript

 
// Javascript implementation of the approach
 
var max_size = 20;
var max_k = 20
 
// Array to store the states of DP
var dp = Array.from(Array(max_size), ()=> Array(max_k));
 
// Array to check if a
// state has been solved before
var v = Array.from(Array(max_size), ()=> Array(max_k));
 
// To store the sum of
// the array elements
var sum = 0;
 
// Function to find the sum of
// all the array elements
function findSum(arr, n)
{
    for (var i = 0; i < n; i++)
        sum += arr[i];
}
 
// Function to return the number of ways
function 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 && 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
var arr = [1, -1, 1, -1, 1, -1];
var n = arr.length;
var k = 2;
// Function call to find the
// sum of the array elements
findSum(arr, n);
// Print the number of ways
document.write( cntWays(arr, 0, 1, k, n, 0));
 
 

输出：

2

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

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。