对于这个，有什么比蛮力更好的解决方案？

Question

给定[0-5]之间有限的正整数序列，假设[0,3,1,5,2,4,4,4]和起始序列[0,0,0,0,0,0,0 ，0]。 我们现在想要通过执行逐步操作从起始序列构建我们给定的序列。 在一个步骤中，我们可以将起始序列中的所有数字增加1，或者将此序列中的一个索引增加1.一旦我们在这种情况下增加5，它将变为0。

找到需要最少步骤的解决方案的最有效方法是什么？ 这个解决方案当然也应该适用于其他输入（长度+上限）。 对于起始序列，我们可以假设每个索引始终为0。

蛮力方法看起来像这样。

int upperBound = 5;
int[] endSequence = {0,3,1,5,2,4,4,4};
int currentBestSteps = Integer.MAX_VALUE;
int currentTimesIncreaseAll = 0;

for(int start = 0;start <= upperBound;start++){ //how many times to increase all
  //counter how many steps required total, starting with start amount of steps
  //since we increase all values 'start' times  
  int counterSteps = start; 

  //go through all end values and calc how many steps required  
  for(int end:endSequence){ 
    if(start <= end){
      counterSteps += end-start;
    }else{
      counterSteps += end+upperBound+1-start;
    }
  }

  System.out.println("solution: increase all "+start+
                     " times, total steps: "+counterSteps);

  if(counterSteps < currentBestSteps){
    currentBestSteps = counterSteps;
    currentTimesIncreaseAll = start;
  }
}
System.out.println("best solution: increase all "+currentTimesIncreaseAll+
                   " times, total steps: "+currentBestSteps);

结果：

solution: increase all 0 times, total steps: 23
solution: increase all 1 times, total steps: 22
solution: increase all 2 times, total steps: 21
solution: increase all 3 times, total steps: 20
solution: increase all 4 times, total steps: 19
solution: increase all 5 times, total steps: 30
best solution: increase all 4 times, total steps: 19

Answer 1

我将提供一种方法来减少目标原始数组（称之为A ）以生成[0,0,0,0...] ，方法是递减所有内容或递减单个项目。 这当然是同样的问题，但反过来的步骤。

首先，计算逐个递减所有元素的成本。 将此成本称为CMAX和数组N的长度。 CMAX = sum_for_all_i（A [i]）

然后对数组进行排序，并找到每个位置i，其中i = 0或A [1]> A [I-1]。

对于每个这样的位置，很容易计算在A [i]达到0之前减少所有内容所产生的成本， 然后逐个递减。 这很容易，因为我们知道索引<i的所有内容都会回滚，而索引> = i的所有东西都不会。 所以：

COST（i）= CMAX + A [i] - A [i] *（Ni）+ i *（UPPER_BOUND + 1-A [i]）

A [i]是所有全局减量的代价。 -A [i] *（Ni）是所有不包裹的高元素的成本降低，成本i *（UPPER_BOUND + 1-A [i]）是所有元素的成本增加从0到UPPER_BOUND回绕 。

您找到的最低成本 （包括CMAX ）就是您的答案。 总复杂度为O（N log N） ，由排序主导。 如果上限保证很小，那么你可以使用计数排序并得到O（N + k）