Question

所以我几天来一直在处理一个任务问题，而且我发现让这个程序在线性时间运行起来非常困难。我已经让它在O（n ^ 2）中工作，但我希望得到一个完美的分数。

以下是问题：我们被要求将某些数字的副本更改为否定数字，然后将所有重复数据发送到数组的末尾。

  For example, if the input array is [ 4 , 1 , 1 , 3 , 3 , 3 , 1 , 1 ], it
  reads [ 4 , 1 , 3 , 1 , -1 , -1 , -1 , -1 ] after squeeze() completes.

这是我的计划：

int base = ints[ints.length -1];
    int count = 0;
    for (int i = ints.length - 1 ; i > 0 ; i--)
    {
        if (base == ints[i-1])
        {
            ints[i] = N_ONE;
            count++;
        } else {
            base = ints[i-1];
        }
    }
    int count2 = 0;
    for (int j = 0; (count) != count2 ; j++)
    {
        if (ints[j] == -1 && ints[j+1] != -1)
        {
            ints[j] = ints[j+1];
            ints[j+1] = N_ONE;
            count2 = 0;
            j = 0;
        } else if (ints[j] == -1 && ints[j+1] == -1){
            count2++;
        }
    }
}

我的第一个循环有效地工作，它将所有重复数字设置为-1，但不仅是我的第二个循环不在线性运行时，而且我觉得它可以以更简单的方式完成。我已经尝试手工编写过程，但我似乎只提出了O（n ^ 2）的方法。

有没有人有建议或提示？有什么东西真的很简单吗？

提前致谢！

Answer 1

这个解决方案背后的概念是，正如我在评论中所建议的那样：一次性完成，使用索引来阅读你正在阅读的地方以及你在哪里写作。只写一次以读取重复块。当你用完读取元素时，只需用-1填充数组的其余部分。

这是Java中的一个实现。如你所见，我没有做太多测试。

import java.util.Arrays;

public class Test {
  public static void main(String[] args) {
    testIt(new int[]{});
    testIt(new int[]{4, 1, 1, 3, 3, 3, 1, 1});
    testIt(new int[]{1});
    testIt(new int[]{1,1});
    testIt(new int[]{1,2});
  }

  public static void testIt(int[] in) {
    System.out.println(Arrays.toString(in));
    squeeze(in);
    System.out.println(Arrays.toString(in));
    System.out.println();
  }

  public static void squeeze(int[] data) {
    int readIndex = 0;
    int writeIndex = 0;
    while(readIndex < data.length){
      if(readIndex == 0 || data[readIndex] != data[readIndex-1]){
        // Need to store this one
        data[writeIndex] = data[readIndex];
        writeIndex++;
      }
      readIndex++;
    }
    while(writeIndex < data.length){
      data[writeIndex] = -1;
      writeIndex++;
    }
  }
}

如何让这个程序在线性时间运行？

1 个答案: