Question

（见下面的解决方案）

（潜伏者出现）

我正在使用BigDecimal / BigInteger类来处理非常庞大的数字。

我有一个计算复合增长系列的公式。

对于每个n，值= initial *（coef ^ n）。

我正试图找到一种快速计算n0和n1之间值子集的和的方法。

因此，例如，其中n0 = 4且n1 = 6，

返回：初始*（coef ^ 4）+初始*（coef ^ 5）+初始*（coef ^ 6）

我不太了解数学，但也许有一种公式化的表达方式？

我基本上把所有的值加起来，通过提高系数将它们中的一些组合成10的幂。

据我所知，功能是准确的。我可以返回

的值

n0 = 1，n1 = 50000，初始值= 100，coef = 1.05，不到一秒钟。

虽然我可能永远不会将该函数用于高于~2,000的值，但是知道是否有更有效的方法会很好。

public static final BigDecimal sum(int n0, int n1, BigDecimal initial, BigDecimal coef) {
    BigDecimal sum = BigDecimal.ZERO;

    int short_cut = 1000000000;

    //Loop for each power of 10
    while (short_cut >= 10) {
        //Check the range of n is greater than the power of 10
        if (n1 - n0 >= short_cut) {
            //Calculate the coefficient * the power of 10
            BigDecimal xCoef = coef.pow(short_cut);

            //Add the first sum of values for n by re-calling the function for n0 to n0 + shortcut - 1
            BigDecimal add = sum(n0, n0 + short_cut - 1, initial, coef);
            sum = sum.add(add);

            //Move n forward by the power of 10
            n0 += short_cut;

            while (n1 - n0 >= short_cut) {
                //While the range is still less than the current power of 10
                //Continue to add the next sum multiplied by the coefficient
                add = add.multiply(xCoef);
                sum = sum.add(add);
                //Move n forward
                n0 += short_cut;
            }

        }
        //Move to the next smallest power of 10
        short_cut /= 10;
    }

    //Finish adding where n is smaller than 10
    for (; n0 <= n1; n0++)
        sum = sum.add(initial.multiply(coef.pow(n0)));
    return sum;
}

下一个问题是求出n1的最大值，其中和（n0，initial，coef）＆lt; = x。

编辑：

public static final BigDecimal sum(int n0, int n1, BigDecimal initial, BigDecimal coef) {
    return initial.multiply(coef.pow(n0).subtract(coef.pow(n1 + 1))).divide(BigDecimal.ONE.subtract(coef));
}

（initial * coef ^ n0 - coef ^ n1 + 1）/ 1 - coef

感谢维基百科。

Answer 1

我会写一些算法思想。

首先让我们简化您的公式：

所以你应该计算： S = a *（c ^ n0）+ a *（c ^（n0 + 1））+ ... + a *（c ^ n1） 其中 initial = a 和 coef = c

让 S（n）成为以下总和的函数： S（n）= a + a * c + a *（c ^ 2）+ ... + a *（c ^ n）

我们将得到 S = S（n1）-S（n0-1）

另一方面 S（n）是geometric progression的总和，因此 S（n）= a *（1-c ^ n）/（1 -c）

所以我们得到 S = S（n1）-S（n0-1）= a *（1-c ^ n1）/（1-c）-a *（1-c ^（n0- 1））/（1-C）= A *（C ^（N0〜1）-c ^ N1）/（1-c）的

所以现在我们必须处理计算 c ^ n 指数（当然BigDecimal类有pow方法，我们这样做只是为了能够计算算法的复杂性）。以下算法具有 O（log（n））复杂度：

function exp(c,n){ // throw exception when n is not an natural number or 0 if(n == 0){ return 1; } m = exp(c, floor(n/2)); if (n % 2 == 0){ return m*m; } else{ return m*m*c; } }

因此，如果我们考虑到代数运算具有 O（1） O（log（n））复杂度计算>复杂性。

计算指数增长系列

1 个答案: