需要帮助计算序列的元素

如何解决需要帮助计算序列的元素

我写了一个算法，应该计算一个序列的第n个元素，最多n = 2000000。这个序列如下：

1 - 第一个元素是 1;

2 - 对于序列的每个元素 x，元素 2x + 1 和 3x + 1 也包含在序列中；

3 - 每个元素都是升序的，没有重复的元素；

4 - 序列没有其他值；

这样前几个元素是 [1,3,4,7,9,10,13,15...],seq(50) = 175,seq(50000) = 1237222,seq(1234567) = 71221051等

我写了以下代码：

public static long seq(int n) {
    LinkedList<Long> sequence = new LinkedList<>();
    int doubleCount = 0;
    int tripleCount = 0;
    long elementDouble = 1;
    long elementTriple = 0;
    sequence.addLast(elementDouble);
    while (sequence.size() <= n + 2) {
        elementDouble = 2 * sequence.get(doubleCount) + 1; 
        elementTriple = 3 * sequence.get(tripleCount) + 1;
        if (elementDouble < elementTriple && elementDouble > sequence.getLast()) {
            sequence.addLast(elementDouble);
            doubleCount++;
        } else if (elementDouble == sequence.getLast()) {
            doubleCount++;
        } else if (elementTriple > sequence.getLast()) {
            sequence.addLast(elementTriple);
            tripleCount++;
        } else {
            tripleCount++;
        }
    }
    return sequence.get(n);
}

分别计算 2x + 1 和 3x + 1，以便将两个值中最小的一个添加到列表中，另一个存储并与下一个对应值进行比较。 这给了我正确的结果。但是，对于大于 1000000 的 n 值，它非常慢（运行时间超过 5 分钟）。有什么方法可以改进代码，以便我可以将它用于极大的 n 实例？

非常感谢您的帮助:)

解决方法

您可以尝试维护两个单独的队列，q1 和 q2。将 1 作为序列的第一个元素，然后将 2*1 + 1 == 3 放入 q1 并将 3*1 + 1 == 4 放入 q2。序列的下一个元素是每个队列前面的两个元素中较小的一个。将其出列并命名为 x。序列的下一个元素是 x，您可以将 2*x + 1 加入 q1 并将 3*x + 1 加入 q2。

,

您的代码表现非常糟糕，因为您在 get(index) 上调用 LinkedList。更改为使用 ArrayList 将大大提高性能：

public static long seq(int n) {
    ArrayList<Long> sequence = new ArrayList<>();
    int doubleCount = 0;
    int tripleCount = 0;
    long elementDouble = 1;
    long elementTriple = 0;
    sequence.add(elementDouble);
    while (sequence.size() <= n + 2) {
        elementDouble = 2 * sequence.get(doubleCount) + 1; 
        elementTriple = 3 * sequence.get(tripleCount) + 1;
        if (elementDouble < elementTriple && elementDouble > sequence.get(sequence.size() - 1)) {
            sequence.add(elementDouble);
            doubleCount++;
        } else if (elementDouble == sequence.get(sequence.size() - 1)) {
            doubleCount++;
        } else if (elementTriple > sequence.get(sequence.size() - 1)) {
            sequence.add(elementTriple);
            tripleCount++;
        } else {
            tripleCount++;
        }
    }
    return sequence.get(n);
}

测试

public static void main(String[] args) {
    test(50);
    test(50000);
    test(1000000);
    test(1234567);
    test(10000000);
    test(100000000);
}
static void test(int n) {
    long start = System.nanoTime();
    long seq = seq(n);
    long end = System.nanoTime();
    System.out.printf("%d: %d (%.9fs)%n",n,seq,(end - start) / 1e9);
}

输出

50: 175 (0.000202500s)
50000: 1237222 (0.008792100s)
1000000: 54381286 (0.100169600s)
1234567: 71221051 (0.084787500s)
10000000: 1031926810 (0.454602800s)
100000000: 19115394879 (4.044839300s)