连续子段绝对值最小问题

【座右铭】1. 想要成为行家，就必须尝试解决大量的问题；

2. 解决大量问题并不代表能解决所有问题，而是表示解决下一个问题的几率变大了

1. 现有一个数组，里面包含了正数和负数，取其中若干个连续的数，要求这些数的和的绝对值最小【问题来源于论坛】

第一部分：思路

1. 对数组A[1...N]，做和运算S[1...N]，其中S[1] = A[1]; S[2] = A[1]+A[2];...;S
=A[1]+A[2]+A[3]+...+A

2. 对S[1...N]从小到大排序

3. 连续子段绝对值最小：Min{ |S[i]|，S[i+1]-S[i]} 1<=i<=N

第二部分：Java代码，不考虑异常情况
//待修正，在获取连续子段在原数组中的开始索引和结束索引有bug。
//代码中存在错误的判断条件：S[i+1]对应的索引大于S[i]对应的索引
//问题提出日期：4.18

/**
* 现有一个数组，里面包含了正数和负数，取其中若干个连续的数，要求这些数的和的绝对值最小
* @param source
* 数组
* @param len
* 数组长度
* @return
* 一个三元组，分别是最小值，连续子段在原数组中的开始索引，结束索引
*/
public static int[] minAbs(int[] source, int len)
{
//保存最小值，连续子段在原数组中的开始索引，结束索引
int[] result = new int[3];
//和数组
int[] sum = new int[len];
sum[0] = source[0];
for(int i=1;i<len;i++)
{
source[i] += source[i-1];
sum[i] = source[i];
}
//排序
quicksort(sum, 0, len-1);

boolean isFromZero = false;
result[0] = sum[0]>0?sum[0]:-1*sum[0];
isFromZero = true;
result[1] = 0;
result[2] = sum[0];

for(int j=1;j<len;j++)
{
int cur = sum[j]>0?sum[j]:-1*sum[j];
if(cur<result[0])
{
result[0] = cur;
isFromZero = true;
result[1] = 0;
result[2] = sum[j];
}

cur = sum[j] - sum[j-1];
if(cur<result[0])
{
result[0] = cur;
isFromZero = false;
result[1] = sum[j-1];
result[2] = sum[j];
}
}
//还原数组
int k = len - 1;
for(;k>=0;k--)
{
if(source[k]==result[2])
{
result[2] = k;
break;
}
}
if(!isFromZero)
{
for(k=0;k<result[2];k++)
{
if(source[k]==result[1])
{
result[1] = k+1;
break;
}
}
}

for(k=len-1;k>0;k--)
{
source[k] -= source[k-1];
}
return result;
}
/**
* 快速排序
*/
static void quicksort(int[] source, int left, int right)
{
if(left<right)
{
int mid = partition(source, left, right);
quicksort(source, left, mid-1);
quicksort(source, mid+1, right);
}
}
static int partition(int[] source, int left, int right)
{
int start = left, end = right;
int tmp = 0;
left++;
while(left<=right)
{
while(left<=end&&source[left]<=source[start])
{
left++;
}
while(source[right]>source[start])
{
right--;
}
if(left<right)
{
tmp = source[left];
source[left] = source[right];
source[right] = tmp;
}
}
tmp = source[start];
source[start] = source[right];
source[right] = tmp;
return right;
}

第三部分：测试用例

数组{2,2,2,2}：返回{2,0,0}

数组{2,-2,1,3,4,-4}：返回{0,0,1}

数组{-2,1,2,-1,4}：返回{0,0,3}

数组{-2,3,1,-3,4,6,-7,2,8}：返回{0,3,6}

数组{-2,-6,-7,-3}：返回{2,0,0}