Question

我正在制作物理优化器，其中关键部分通过以下CS问题解决。

您将获得一组随机有符号整数。他们的总和为零。可以创建一个循环来保持运行总和，如下所示：

int running_sum = 0;
int sum_peak = 0;

for( int i = 0; i < size_of_array; i++ )
{
  running_sum += int_array[i];
  sum_peak = max( sum_peak, abs( running_sum ) );
}

assert( running_sum == 0 );

任务是通过置换初始int_array来最小化得到的sum_peak。到目前为止我的想法：天真的方法需要一定的时间来运行。我所知道的任何NP-C问题似乎都没有表达这个问题。我想不出任何方式将这个问题表示为图形问题。

如果X是数组中最大的数字（绝对值），则max_sum的上限和下限分别为N和N / 2.

编辑：示例。

{ - 4，-6,10}：按以下方式对列表重新排序：{ - 6，10，-4}，以便sum_peak为-6。

{1,1,1,1，-4}：将列表重新排序为：{1,1，-4,1,1}，以便sum_peak为+2。

Answer 1

这可能是假的（如果我误解了这个问题）但有时最简单的方法是最好的方法

如果int是未签名的，则没有帮助
如果有签名那么：

1.input array

1,5，-2,7，-6,4，-10，-3，......

2.分离有符号和无符号的值并按值排序

+ 1，+ 4，+ 5，+ 7，...
-2，-3，-6，-10，...

3.reorder原始数组

这可以通过更多方式完成
最简单的一个是偶数，而奇数是 -
+ 1，-2，+ 4，-3，+ 5，-6，+ 7，-10
这很快但不是最佳
仍将显着降低峰值
另一种选择是：

1.while（sum＆gt; = 0）从+ array
添加数字
2.while（sum＆lt; 0）从-array
添加数字
3.当使用一个阵列时，请复制未使用的休息
不认为你可以做得更好

NP完全来自哪里？

或者我错过了什么???

[编辑1]

也可以改进以获得最佳解决方案，如
使用较大的未使用值中的较小值来获得相反数组中最大未使用值的一半的总和...
也可以就地完成

[编辑2]一些代码和测试

//---------------------------------------------------------------------------
void min_sum_peak()
    {
    const int N=1000;
    int in[N],out[N];
    int i,s,sp,e,ip0,im0,ip1,im1;
    // generate sum=0 random array to in and clear out (for easyier debug)
    for (s=0,i=1;i<N;i++)
        {
        in[i]=Random(1000)-500;
        s+=in[i];
        out[i]=0;
        } in[0]=-s; out[0]=0;

    // bubble sort in[]
    for (e=1;e;)
    for (e=0,i=1;i<N;i++)
     if (in[i-1]>in[i])
      { e=in[i-1]; in[i-1]=in[i]; in[i]=e; e=1; }


    // fill out[]
    #define peak { e=s; if (e<0) e=-e; if (sp<e) sp=e; }
    for (int mode=0;mode<3;mode++)
        {
        // scann for +/- boundary
        im0=-1; ip0=N;
        im1= 0; ip1=N-1;
        for (i=0;i<N;i++)
         if (in[i]<0) im0=i;
          else { ip0=i; break; }

        if (mode==0)            // even odd from smaller values (sp = ~2*max)
         for (i=0,s=0,sp=0;i<N;)
            {
            if (im0>=im1){ out[i]=in[im0]; s+=out[i]; im0--; i++; peak; }
            if (ip0<=ip1){ out[i]=in[ip0]; s+=out[i]; ip0++; i++; peak; }
            }
        if (mode==1)            // even odd from bigger values (sp = ~max)
         for (i=0,s=0,sp=0;i<N;)
            {
            if (im0>=im1){ out[i]=in[im1]; s+=out[i]; im1++; i++; peak; }
            if (ip0<=ip1){ out[i]=in[ip1]; s+=out[i]; ip1--; i++; peak; }
            }
        if (mode==2)            // -half sum to next max value (sp = ~0.5*max for big enough array)
            {
            for (i=0,s=0,sp=0;;)
                {
                if (im0<im1) break; // stop if any + or - valueas are exhausted
                if (ip0>ip1) break;
                if (s>=0)
                    {
                    if (+s+s<-in[im1]){ out[i]=in[ip0]; s+=out[i]; ip0++; i++; }
                    else              { out[i]=in[im1]; s+=out[i]; im1++; i++; }
                    }
                else{
                    if (-s-s<+in[ip1]){ out[i]=in[im0]; s+=out[i]; im0--; i++; }
                    else              { out[i]=in[ip1]; s+=out[i]; ip1--; i++; }
                    }
                peak;
                }
            for (;im0>=im1;){ out[i]=in[im0]; s+=out[i]; im0--; i++; peak; }
            for (;ip0<=ip1;){ out[i]=in[ip0]; s+=out[i]; ip0++; i++; peak; }
            }
        i=-in[0]; if (i<in[N-1]) i=in[N-1];
        // breakpoint here for approach assesment
        mode=mode;  // used approach
        i = i;      // abs max value
        s = s;      // sum
        sp=sp;      // sum peak
        }
    #undef peak { e=s; if (e<0) e=-e; if (sp<e) sp=e; }
    }
//---------------------------------------------------------------------------

模式0 - 来自较小值的偶数奇数sp = ~2 * max_abs_value
模式1 - 来自较大值的奇数sp = ~max_abs_value
模式2 - 下一个最大值的一半和sp = ~0.5 * max_abs_value
对于具有“均匀”分布的+/-值的足够大的数组，模式2是预期的最佳
但如果数组很小（例如N = 20），那么模式1就是赢家
模式0并不是很好

运行总和最大项目最小化

1 个答案: