我想找到总和等于k的长度最小的子数组。
Input: arr[] = {2, 4, 6, 10, 2, 1}, K = 12
Output: 2
说明：
总和为 12 的所有可能子数组是 {2, 4, 6} 和 {10, 2}。
Input: arr[] = { 1, 2, 4, 3, 2, 4, 1 }, K = 7
Output: 2
【问题讨论】：
这是一个使用 JavaScript 的解决方案。
当然，它可以提高效率，但我已经对其进行了编码。
function lengthOfShortestSubArrayOfSumK(array, k) {
var combos=[];
for(var i=0; i<Math.pow(2, array.length); i++) {
var bin=("0".repeat(array.length)+i.toString(2)).slice(-array.length).split("");
var ones=bin.reduce((count, digit)=>{count+=digit=="1";return count;},0);
var sum=bin.reduce((sum, digit, index)=>{sum+=digit=="1"?array[index]:0;return sum;},0);
combos.push([bin, ones, sum]);
};
return combos.filter(combo=>combo[2]==k).sort((a, b)=>a[1]-b[1])[0][1];
}
var arraysAndKs=[
{array:[2, 4, 6, 10, 2, 1], k:12},
{array:[1, 2, 4, 3, 2, 4, 1], k:7}
];
for(arrayAndK of arraysAndKs)
console.log("Length of shortest sub array of ["+arrayAndK.array.join(", ")+"] with sum "+arrayAndK.k+" is : "+lengthOfShortestSubArrayOfSumK(arrayAndK.array, arrayAndK.k));0 和 array.length 之间的二进制数的平方将为我们提供总和中包含的数组项的表示。
我们计算该二进制数中有多少个“1”。
我们将被那些“一个”屏蔽的数组项求和。
我们将二进制数、“一个”的计数和总和的数组保存到 combos 数组中。
我们过滤 combos 的总和 k，按 "one" 的计数排序，然后返回第一个的 "one" 计数。
我确信这可以翻译成任何编程语言。
【讨论】：
您可以使用一种算法来查找大小为 K 的子集，并保存另一个变量来存储构成此类子数组的成员数。
求K子数组的算法是：
这是 Python 中的解决方案
def foo(arr,k):
dynamic = {0:0}
for i in arr:
temp = {}
for j, l in dynamic.items():
if i + j <= k: # if not it's not interesting us
# choose the smallest subarray
temp[i+j] = min(l+1,dynamic.get(i+j,len(arr)))
dynamic.update(temp)
return dynamic.get(k,-1)
复杂度为 O(N*K)。
我假设子数组是指原始数组的任何可能组合。
这是解决问题的 Python 代码在子集必须是连续的条件下：
O(N) 复杂度
def shortest_contiguous_subarray(arr,k):
if k in arr:
return 1
n = len(arr)
sub_length = float('inf')
sub = arr[(i:=0)]
j = 1
while j < n:
while sub < k and j < n:
sub += arr[j]
j += 1
while sub > k:
sub -= arr[i]
i += 1
if sub == k:
# print(arr[i:j],j-i)
sub_length = min(sub_length,j-i)
sub -= arr[i]
i += 1
return sub_length if sub_length <= n else -1
【讨论】：
if i + j <= k:，然后在我看来就可以了。但是关于复杂度很简单：如果输入长度（N）线性增加，K不变，计算的次数也会线性增加。
此答案适用于任何正数数组，如果执行 O(n) 预处理传递，则可以修改为使用具有零或负元素的数组（1. 找到最小元素 m, m <= 0， 2.通过将-m+1添加到所有元素使整个数组为正，3.求解sum + n*(1-m))
function search(input, goal) {
let queue = [ { avail: input.slice(), used: [], sum: 0 } ]; // initial state
for (let qi = 0; qi < queue.length; qi ++) {
let s = queue[qi]; // like a pop, but without using O(n) shift
for (let i = 0; i < s.avail.length; i++) {
let e = s.avail[i];
if (s.sum + e > goal) continue; // dead end
if (s.sum + e == goal) return [...s.used, e]; // eureka!!
queue.push({ // keep digging
avail: [...s.avail.slice(0, i), ...s.avail.slice(i+1)],
used: [...s.used, e],
sum: s.sum + e
});
}
}
return undefined; // no subset of input adds up to goal
}
console.log(search([2, 4, 6, 10, 2, 1], 12))这是一个经典的广度优先搜索，当它检测到我们已经超过目标总和时会进行一些修剪。它可以进一步优化以避免多次探索同一个分支（例如，[4,2] 等同于[2,4]）——但这需要额外的内存来保持一组“已访问”状态。此外，您可以先添加启发式方法来探索更有希望的分支。
【讨论】：