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

📅  最后修改于: 2021-04-29 18:50:01             🧑  作者: Mango

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

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

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

##### 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
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
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
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
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