假设数组为1 2 3 4 5
这里N = 5
我们必须选择3个元素,我们不能选择2个以上的连续元素,因此P = 3
和k = 2
。因此,此处的输出将为1 + 2 + 4 = 7
。
我想出了一个递归解决方案,但它具有指数时间复杂度。这是代码。
#include<iostream>
using namespace std;
void mincost_hoarding (int *arr, int max_size, int P, int k, int iter, int& min_val, int sum_sofar, int orig_k)
{
if (P == 0)
{
if (sum_sofar < min_val)
min_val = sum_sofar;
return;
}
if (iter == max_size)
return;
if (k!=0)
{
mincost_hoarding (arr, max_size, P - 1, k - 1, iter + 1, min_val, sum_sofar + arr[iter], orig_k);
mincost_hoarding (arr, max_size, P, orig_k, iter + 1, min_val, sum_sofar, orig_k);
}
else
{
mincost_hoarding (arr, max_size, P, orig_k, iter + 1, min_val, sum_sofar, orig_k);
}
}
int main()
{
int a[] = {10, 5, 13, 8, 2, 11, 6, 4};
int N = sizeof(a)/sizeof(a[0]);
int P = 2;
int k = 1;
int min_val = INT_MAX;
mincost_hoarding (a, N, P, k, 0, min_val, 0, k);
cout<<min_val;
}
此外,如果假定在约束之后无法选择P元素,那么我们返回INT_MAX。
我在接受采访时被问到这个问题。在提出这个解决方案后,面试官期待更快的事情。也许,DP解决问题的方法。如果存在一个或更快的算法,有人可以提出DP算法。
我尝试了各种测试用例并得到了正确答案。如果您发现某些测试用例的回复不正确,请同时指出。
答案 0 :(得分:3)
以下是Java动态编程算法 (C ++版本应该看起来非常相似)
它基本上如下工作:
[pos][consecutive length][length]
的3D数组
这里length index = actual length - 1
),[0]
长度为1,类似于连续长度。这样做是因为在任何地方都没有任何长度。pos
处的值。pos - 1
查看所有先前位置(length - 1
除外)中的最小值,并使用加pos
处的值。pos > 0 && consecutive length > 0 && length > 0
,[pos-1][consecutive length-1][length-1]
加上pos
的值
如果其中一个为0,则将其初始化为无效值。最初感觉就像这个问题只需要2个维度,然而,一旦我试图解决它,我意识到我需要第3个。
代码:
int[] arr = {1, 2, 3, 4, 5};
int k = 2, P = 3;
int[][][] A = new int[arr.length][P][k];
for (int pos = 0; pos < arr.length; pos++)
for (int len = 0; len < P; len++)
{
int min = 1000000;
if (len > 0)
{
for (int pos2 = 0; pos2 < pos-1; pos2++)
for (int con = 0; con < k; con++)
min = Math.min(min, A[pos2][len-1][con]);
A[pos][len][0] = min + arr[pos];
}
else
A[pos][0][0] = arr[pos];
for (int con = 1; con < k; con++)
if (pos > 0 && len > 0)
A[pos][len][con] = A[pos-1][len-1][con-1] + arr[pos];
else
A[pos][len][con] = 1000000;
}
// Determine the minimum sum
int min = 100000;
for (int pos = 0; pos < arr.length; pos++)
for (int con = 0; con < k; con++)
min = Math.min(A[pos][P-1][con], min);
System.out.println(min);
我们按预期将7
作为输出。
运行时间: O(N2k + NPk)