实际上，这是编程珍珠第2版第8章的问题＃10。它提出了两个问题：给定一个整数数组A []（正数和非正数），你怎么能找到一个A []的连续子数组，其总和最接近0？或者最接近某个值t？
我可以想办法解决最接近0的问题。计算前缀和数组S []，其中S [i] = A [0] + A [1] + ... + A [i] 。然后根据元素值和保留的原始索引信息对此S进行排序，以找到最接近0的子阵列和，只是迭代S数组并执行两个相邻值的diff并更新最小绝对diff。
问题是，解决第二个问题的最佳方法是什么？最接近某个值t？任何人都可以提供代码或至少一个算法吗？ （如果有人有最接近零问题的解决方案，也欢迎回答）
答案 0 :(得分：6)
要解决此问题，您可以自己构建一个区间树， 在O（nlogn）中，或者平衡二元搜索树，或者甚至是从STL映射中获益。
以下是使用STL地图，lower_bound（）。
#include <map>
#include <iostream>
#include <algorithm>
using namespace std;
int A[] = {10,20,30,30,20,10,10,20};
// return (i, j) s.t. A[i] + ... + A[j] is nearest to value c
pair<int, int> nearest_to_c(int c, int n, int A[]) {
map<int, int> bst;
bst[0] = -1;
// barriers
bst[-int(1e9)] = -2;
bst[int(1e9)] = n;
int sum = 0, start, end, ret = c;
for (int i=0; i<n; ++i) {
sum += A[i];
// it->first >= sum-c, and with the minimal value in bst
map<int, int>::iterator it = bst.lower_bound(sum - c);
int tmp = -(sum - c - it->first);
if (tmp < ret) {
ret = tmp;
start = it->second + 1;
end = i;
}
--it;
// it->first < sum-c, and with the maximal value in bst
tmp = sum - c - it->first;
if (tmp < ret) {
ret = tmp;
start = it->second + 1;
end = i;
}
bst[sum] = i;
}
return make_pair(start, end);
}
// demo
int main() {
int c;
cin >> c;
pair<int, int> ans = nearest_to_c(c, 8, A);
cout << ans.first << ' ' << ans.second << endl;
return 0;
}
答案 1 :(得分：4)
您可以调整您的方法。假设您有一个前缀sum的数组S，正如您所写的那样，并且已经按照和值的递增顺序排序。关键概念不仅要检查连续的前缀和，而是使用两个指针来指示数组S中的两个位置。用（稍微pythonic）伪代码编写：
left = 0 # Initialize window of length 0 ...
right = 0 # ... at the beginning of the array
best = ∞ # Keep track of best solution so far
while right < length(S): # Iterate until window reaches the end of the array
diff = S[right] - S[left]
if diff < t: # Window is getting too small
if t - diff < best: # We have a new best subarray
best = t - diff
# remember left and right as well
right = right + 1 # Make window bigger
else: # Window getting too big
if diff - t < best # We have a new best subarray
best = diff - t
# remember left and right as well
left = left + 1 # Make window smaller
复杂性受到排序的约束。上述搜索将最多进行2 n = O（ n 次）循环的迭代，每次迭代的计算时间由常数限制。请注意，上面的代码是为了积极t而设想的。
代码是为S中的积极因素和积极t而设想的。如果出现任何负整数，最终可能会导致right的原始索引小于left的索引。因此，您最终得到的子序列总和为-t。您可以在if … < best检查中检查此情况，但如果您只是在那里禁止此类情况，我相信您可能错过了一些相关案例。底线是：采取这个想法，考虑一下，但你必须适应负数。
注意：我认为这与Boris Strandjev想要在his solution中表达的一般概念相同。但是，我发现这个解决方案有点难以阅读，难以理解，所以我提供了自己的解决方案。
答案 2 :(得分：2)
你对0案的解决方案对我来说似乎没问题。以下是我对第二种情况的解决方案：
start初始化为0（排序前缀数组中的第一个索引）end到last（前缀数组的最后一个索引）start 0 ... last，并为每个找到相应的end - 前缀总和为prefix[start]的最后一个索引+ prefix[end]＆gt; t。当您发现end时start的最佳解决方案是prefix[start] + prefix[end]或prefix[start] + prefix[end - 1]（后者仅在end { {1}}＆gt; 0）end搜索start - 在prefix[start]的所有可能值上进行迭代时，start值会增加，这意味着在每次迭代中，您只对值＆lt; = end的先前值感兴趣。start＆gt;时停止迭代end start位置获得的所有值。可以很容易地证明，这将为整个算法提供O(n logn)的复杂性。
答案 3 :(得分：1)
我偶然发现了这个问题。虽然已经有一段时间了，但我发布了它。 O（nlogn）时间，O（n）空间算法。这是运行Java代码。希望这有助于人们。
import java.util.*;
public class FindSubarrayClosestToZero {
void findSubarrayClosestToZero(int[] A) {
int curSum = 0;
List<Pair> list = new ArrayList<Pair>();
// 1. create prefix array: curSum array
for(int i = 0; i < A.length; i++) {
curSum += A[i];
Pair pair = new Pair(curSum, i);
list.add(pair);
}
// 2. sort the prefix array by value
Collections.sort(list, valueComparator);
// printPairList(list);
System.out.println();
// 3. compute pair-wise value diff: Triple< diff, i, i+1>
List<Triple> tList = new ArrayList<Triple>();
for(int i=0; i < A.length-1; i++) {
Pair p1 = list.get(i);
Pair p2 = list.get(i+1);
int valueDiff = p2.value - p1.value;
Triple Triple = new Triple(valueDiff, p1.index, p2.index);
tList.add(Triple);
}
// printTripleList(tList);
System.out.println();
// 4. Sort by min diff
Collections.sort(tList, valueDiffComparator);
// printTripleList(tList);
Triple res = tList.get(0);
int startIndex = Math.min(res.index1 + 1, res.index2);
int endIndex = Math.max(res.index1 + 1, res.index2);
System.out.println("\n\nThe subarray whose sum is closest to 0 is: ");
for(int i= startIndex; i<=endIndex; i++) {
System.out.print(" " + A[i]);
}
}
class Pair {
int value;
int index;
public Pair(int value, int index) {
this.value = value;
this.index = index;
}
}
class Triple {
int valueDiff;
int index1;
int index2;
public Triple(int valueDiff, int index1, int index2) {
this.valueDiff = valueDiff;
this.index1 = index1;
this.index2 = index2;
}
}
public static Comparator<Pair> valueComparator = new Comparator<Pair>() {
public int compare(Pair p1, Pair p2) {
return p1.value - p2.value;
}
};
public static Comparator<Triple> valueDiffComparator = new Comparator<Triple>() {
public int compare(Triple t1, Triple t2) {
return t1.valueDiff - t2.valueDiff;
}
};
void printPairList(List<Pair> list) {
for(Pair pair : list) {
System.out.println("<" + pair.value + " : " + pair.index + ">");
}
}
void printTripleList(List<Triple> list) {
for(Triple t : list) {
System.out.println("<" + t.valueDiff + " : " + t.index1 + " , " + t.index2 + ">");
}
}
public static void main(String[] args) {
int A1[] = {8, -3, 2, 1, -4, 10, -5}; // -3, 2, 1
int A2[] = {-3, 2, 4, -6, -8, 10, 11}; // 2, 4, 6
int A3[] = {10, -2, -7}; // 10, -2, -7
FindSubarrayClosestToZero f = new FindSubarrayClosestToZero();
f.findSubarrayClosestToZero(A1);
f.findSubarrayClosestToZero(A2);
f.findSubarrayClosestToZero(A3);
}
}
答案 4 :(得分：1)
解决方案时间复杂度：O(NlogN)
解决方案空间复杂度：O(N)
[注意这个问题在O（N）中无法解决，正如一些人声称的那样]
算法： -
cum[]）
C[i]-C[i+1]中的答案是最小的，$ \ forall $i∈[1，n-1]（基于1的索引）[第12行] C ++代码： -
#include<bits/stdc++.h>
#define M 1000010
#define REP(i,n) for (int i=1;i<=n;i++)
using namespace std;
typedef long long ll;
ll a[M],n,cum[M],ans=numeric_limits<ll>::max(); //cum->cumulative array
int main() {
ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
cin>>n; REP(i,n) cin>>a[i],cum[i]=cum[i-1]+a[i];
sort(cum+1,cum+n+1);
REP(i,n-1) ans=min(ans,cum[i+1]-cum[i]);
cout<<ans; //min +ve difference from 0 we can get
}
答案 5 :(得分：0)
在对这个问题进行更多思考之后，我发现@ frankyym的解决方案是正确的解决方案。我对原始解决方案进行了一些改进，这是我的代码：
#include <map>
#include <stdio.h>
#include <algorithm>
#include <limits.h>
using namespace std;
#define IDX_LOW_BOUND -2
// Return [i..j] range of A
pair<int, int> nearest_to_c(int A[], int n, int t) {
map<int, int> bst;
int presum, subsum, closest, i, j, start, end;
bool unset;
map<int, int>::iterator it;
bst[0] = -1;
// Barriers. Assume that no prefix sum is equal to INT_MAX or INT_MIN.
bst[INT_MIN] = IDX_LOW_BOUND;
bst[INT_MAX] = n;
unset = true;
// This initial value is always overwritten afterwards.
closest = 0;
presum = 0;
for (i = 0; i < n; ++i) {
presum += A[i];
for (it = bst.lower_bound(presum - t), j = 0; j < 2; --it, j++) {
if (it->first == INT_MAX || it->first == INT_MIN)
continue;
subsum = presum - it->first;
if (unset || abs(closest - t) > abs(subsum - t)) {
closest = subsum;
start = it->second + 1;
end = i;
if (closest - t == 0)
goto ret;
unset = false;
}
}
bst[presum] = i;
}
ret:
return make_pair(start, end);
}
int main() {
int A[] = {10, 20, 30, 30, 20, 10, 10, 20};
int t;
scanf("%d", &t);
pair<int, int> ans = nearest_to_c(A, 8, t);
printf("[%d:%d]\n", ans.first, ans.second);
return 0;
}
答案 6 :(得分：0)
作为旁注：我同意其他线程提供的算法。最近我还有另一种算法。
制作A []的另一个副本，即B []。在B []内，每个元素是A [i] -t / n，这意味着B [0] = A [0] -t / n，B [1] = A [1] -t / n ... B [N-1] = A [N-1] -t / N。然后第二个问题实际上转换为第一个问题，一旦找到最接近0的B []的最小子阵列，则同时找到最接近t的A []的子阵列。 （如果t不能被n整除，那有点棘手，但是，精度必须选择合适。运行时也是O（n））
答案 7 :(得分：0)
我认为最接近0解决方案存在一些小错误。在最后一步，我们不仅要检查相邻元素之间的差异，还要检查彼此不相邻的元素，如果其中一个元素大于0而另一个元素小于0。
答案 8 :(得分：0)
我们不能使用动态编程来解决类似于kadane算法的问题。这是我解决这个问题的方法。请评论这种方法是否错误。
#include <bits/stdc++.h>
using namespace std;
int main() {
//code
int test;
cin>>test;
while(test--){
int n;
cin>>n;
vector<int> A(n);
for(int i=0;i<n;i++)
cin>>A[i];
int closest_so_far=A[0];
int closest_end_here=A[0];
int start=0;
int end=0;
int lstart=0;
int lend=0;
for(int i=1;i<n;i++){
if(abs(A[i]-0)<abs(A[i]+closest_end_here-0)){
closest_end_here=A[i]-0;
lstart=i;
lend=i;
}
else{
closest_end_here=A[i]+closest_end_here-0;
lend=i;
}
if(abs(closest_end_here-0)<abs(closest_so_far-0)){
closest_so_far=closest_end_here;
start=lstart;
end=lend;
}
}
for(int i=start;i<=end;i++)
cout<<A[i]<<" ";
cout<<endl;
cout<<closest_so_far<<endl;
}
return 0;
}
答案 9 :(得分：-1)
以下是java的代码实现：
public class Solution {
/**
* @param nums: A list of integers
* @return: A list of integers includes the index of the first number
* and the index of the last number
*/
public ArrayList<Integer> subarraySumClosest(int[] nums) {
// write your code here
int len = nums.length;
ArrayList<Integer> result = new ArrayList<Integer>();
int[] sum = new int[len];
HashMap<Integer,Integer> mapHelper = new HashMap<Integer,Integer>();
int min = Integer.MAX_VALUE;
int curr1 = 0;
int curr2 = 0;
sum[0] = nums[0];
if(nums == null || len < 2){
result.add(0);
result.add(0);
return result;
}
for(int i = 1;i < len;i++){
sum[i] = sum[i-1] + nums[i];
}
for(int i = 0;i < len;i++){
if(mapHelper.containsKey(sum[i])){
result.add(mapHelper.get(sum[i])+1);
result.add(i);
return result;
}
else{
mapHelper.put(sum[i],i);
}
}
Arrays.sort(sum);
for(int i = 0;i < len-1;i++){
if(Math.abs(sum[i] - sum[i+1]) < min){
min = Math.abs(sum[i] - sum[i+1]);
curr1 = sum[i];
curr2 = sum[i+1];
}
}
if(mapHelper.get(curr1) < mapHelper.get(curr2)){
result.add(mapHelper.get(curr1)+1);
result.add(mapHelper.get(curr2));
}
else{
result.add(mapHelper.get(curr2)+1);
result.add(mapHelper.get(curr1));
}
return result;
}
}