我有一个数组，我必须计算将它分成 3 个连续部分的方法数，以使它们的总和相等。如何修改分区问题来做到这一点？
例如-
令 A 为包含 {1, 2, 3, 0, 3}
的数组
答案 - 2
因为它可以分为{{1,2},{3},{0,3}}和{{1,2},{3,0},{3} } 总和相等。
【问题讨论】：
如果我对您的理解正确，那么您就是在限制问题，以至于您无法重新排列数组中值的顺序。假设问题集是合理的，您可以轻松循环并测试每个可能的变化。这将是递归的，但不需要动态编程。我面前没有 IDE，但我相信代码看起来像这样（适应选择的语言）：
public int countWays(Array array) {
int count = 0;
int sum = 0;
for (int index = 0; index < array.length(); ++index) {
// how much would each partition sum to if we partitioned here?
sum += array.get(index);
// how many ways could the rest of the array be split to match that sum?
count += recursiveCount(sum, array.subArray(index + 1, array.length());
}
return count;
}
public int recursiveCount(int partitionSum, Array remaining) {
// base case
if (remaining.length() == 0) {
return 1;
}
int count = 0;
int sum = 0;
for (int index = 0; index < remaining.length(); ++index) {
// how much would this partion sum to if we partitioned here?
sum += remaining.get(index);
// did we hit the mark?
if (sum == partitionSum) {
// make a partion here and see if we can finish the rest of the array
count += recursiveCount(paritionSum, remaining.subArray(index + 1, remaining.length());
}
}
return count;
}
*注意：这假设一个 subArray 函数创建一个新数组，从第一个索引包含到第二个索引。我相信这是大多数库中最常见的行为。
您对输入的了解越多，您可以添加的捷径就越多，从而提高效率。例如;如果您知道数组将只包含正数，那么您可以在总和大于目标值时停止测试分区，因为无论您添加什么正数，它都不会使总和回到目标值。
【讨论】：
在提出的问题中，我们需要在一个数组中找到三个连续的部分，它们的总和相同。我将提到可以为您解决问题的步骤以及代码 sn-p。
我们这里要做的是，从 start 开始遍历数组直到 len(array)-3。在假设索引 i 上找到总和 sum/3 后，我们得到了我们需要的前半部分。
现在，不要关心后半部分，向解决方案变量（初始化为零）添加一个等于 end[i+2] 的值。 end[i+2] 告诉我们从 i+2 到结束的总路数，第三部分的总和等于 sum/3。
在这里，我们已经处理了第一部分和第三部分，我们还处理了第二部分，默认情况下等于 sum/3。我们的解决方案变量将是问题的最终答案。
为了更好地理解上述算法，下面给出了sn-ps代码::-
这里我们进行反向扫描，以存储每个索引从末尾得到 sum/3 的方法数。
long long int *end = (long long int *)calloc(numbers, sizeof(long long int);
long long int temp = array[numbers-1];
if(temp==sum/3){
end[numbers-1] = 1;
}
for(i=numbers-2;i>=0;i--){
end[i] = end[i+1];
temp += array[i];
if(temp==sum/3){
end[i]++;
}
}
一旦我们有了结束数组，我们就会执行前向循环并得到最终解决方案
long long int solution = 0;
temp = 0;
for(i=0;i<numbers-2;i++){
temp+= array[i];
if(temp==sum/3){
solution+=end[i+2];
}
}
solution 存储最终答案，即将数组拆分为三个总和相等的连续部分的方法数。
【讨论】：
这是一个更正的工作解决方案，有两个基于@Mattew Pape 答案的示例。但这是尝试所有可能分区的蛮力方法。这个可以进一步优化。这个方法的复杂度是O(N!)。
public class partitonArray {
static int total = 0;
public static int countWays(int [] arr) {
int sum = 0;
for (int index = 0; index < arr.length; ++index) {
sum += arr[index];
List<List<Integer>> lst = new ArrayList();
List<Integer> l1 = new ArrayList();
for(int j=0;j<=index;j++)
l1.add(arr[j]);
lst.add(l1);
recursiveCount(sum, Arrays.copyOfRange(arr, index + 1, arr.length), lst);
}
return total;
}
public static void recursiveCount(int partitionSum, int [] remaining, List<List<Integer>> lst) {
// base case
if (remaining.length == 0 && lst.size() > 1) {
System.out.println("Result here = "+lst.toString());
total++;
}
int sum = 0;
List<Integer> l1 = new ArrayList();
for (int index = 0; index < remaining.length; ++index) {
sum += remaining[index];
l1.add(remaining[index]);
// did we hit the mark?
if (sum == partitionSum) {
// make a partion here and see if we can finish the rest of the array
lst.add(l1);
recursiveCount(partitionSum, Arrays.copyOfRange(remaining, index + 1, remaining.length), lst);
lst.remove(l1);
}
}
}
public static void main(String [] args) {
//int [] arr ={ 2, 4, 6,7, 7, 6, 3, 3, 3, 4, 3, 4,5, 4, 4, 3, 3, 1,4};
int [] arr = {1, 2, 3, 0, 3};
System.out.println(countWays(arr));
}
}
**Output**:
Result here = [[1, 2], [3], [0, 3]]
Result here = [[1, 2], [3, 0], [3]]
2
/*
Result here `enter code here`= [[2, 4, 6, 7], [7, 6, 3, 3], [3, 4, 3, 4, 5], [4, 4, 3, 3, 1, 4]]
Result here = [[2, 4, 6, 7, 7, 6, 3, 3], [3, 4, 3, 4, 5, 4, 4, 3, 3, 1, 4]]
2
*/
【讨论】：
解决方法如下：
例如：{1, 2, 3, 0, 3} 。让我们做上面的步骤。
我的解决方案： https://github.com/setu1421/programming-revamp/blob/master/InterviewBit/Arrays/Partitions.cpp
【讨论】：