Question

此问题的时间复杂度不同于所提出的类似问题。这是Zauba开发人员招聘挑战（活动在一个月前结束）的一个问题：

f(0) = p
f(1) = q
f(2) = r

for n > 2

f(n) = a*f(n-1) + b*f(n-2) + c*f(n-3) + g(n)

where g(n) = n*n*(n+1)

给出

p, q, r, a, b, c, n。 n可以和10^18一样大。

Link to a similar problem

在上面的链接中，没有指定时间复杂度，我已经在O(n)中解决了这个问题，伪代码在下面（只是一种方法，所有可能的边界和边缘情况都在比赛中处理了））。

if(n == 0) return p;
if(n == 1) return q;
if(n == 2) return r;
for(long i=3;i<=n;i++){
    now = a*r + b*q + c*p + i*i*(i+1);
    p = q; q = r; r = now;
}

请注意，我在原始代码中的适当位置使用了模10^9 + 7来处理溢出，在必要时使用了适当的边沿情况，并且使用了Java long数据类型（如果有帮助）。

但是，由于这仍然需要O(n)的时间，我希望有一个可以处理n ~ 10^18的更好的解决方案。

编辑

正如用户גלעדברקן提到其与矩阵指数的关系一样，我尝试这样做并停留在特定的位置，我不确定在矩阵的第四行第三列中放置什么。请提出任何建议和更正。

| a b c  1? |   | f(n) |        | f(n+1) |
| 1 0 0  0  |   |f(n-1)|        |  f(n)  |
| 0 1 0  0  |   |f(n-2)|    =>  | f(n-1) |
| 0 0 ?! 0  |   | g(n) |        | g(n+1) |

    M               A               B

Answer 1

矩阵求幂确实是正确的方法，但是还有更多工作要做。

由于g(n)的值不是常数，所以无法有效地将矩阵求幂（O(log n)代替O(n)）应用于其当前形式。

需要为g(n)找到一个类似的递归关系，并且尾随常数。由于g(n)是三次的，因此需要3个递归项：

g(n) = x*g(n-1) + y*g(n-2) + z*g(n-3) + w

展开它们各自的三次表达式：

n³ + n² = x(n³-2n²+n) + y(n³-5n²+8n-4) + z*(n³-8n²+21n-18) + w

        = n³(x+y+z) + n²(-2x-5y-8z) + n(x+8y+21z) + (w-4y-18z)

匹配系数以获得x, y, z的三个联立方程，再加上另一个方程来计算w：

  x +  y +   z = 1
-2x - 5y -  8z = 1
  x + 8y + 21z = 0
  w - 4y - 18z = 0

解决它们以获得：

x = 3    y = -3    z = 1    w = 6

方便地，这些系数也是整数*，这意味着可以直接对递归执行模算。

^{*我怀疑这是一个巧合-可能正是招聘审查员的意图。}

因此，矩阵递推方程为：

|  a  b  c  1  0  0  0 |   | f(n-1) |   |   f(n) |
|  1  0  0  0  0  0  0 |   | f(n-2) |   | f(n-1) |
|  0  1  0  0  0  0  0 |   | f(n-3) |   | f(n-2) |
|  0  0  0  3 -3  1  6 | x |   g(n) | = | g(n+1) |
|  0  0  0  1  0  0  0 |   | g(n-1) |   |   g(n) |
|  0  0  0  0  1  0  0 |   | g(n-2) |   | g(n-1) |
|  0  0  0  0  0  0  1 |   |      1 |   |      1 |

最终的矩阵幂方程为：

                        [n-2]
|  a  b  c  1  0  0  0 |       | f(2) |   |   f(n) |        | f(2) |   |  r |
|  1  0  0  0  0  0  0 |       | f(1) |   | f(n-1) |        | f(1) |   |  q |
|  0  1  0  0  0  0  0 |       | f(0) |   | f(n-2) |        | f(0) |   |  p |
|  0  0  0  3 -3  1  6 |   x   | g(3) | = | g(n+1) |   ,    | g(3) | = | 36 |
|  0  0  0  1  0  0  0 |       | g(2) |   |   g(n) |        | g(2) |   | 12 |
|  0  0  0  0  1  0  0 |       | g(1) |   | g(n-1) |        | g(1) |   |  2 |
|  0  0  0  0  0  0  1 |       |  1   |   |      1 |        |  1   |   |  1 |

（每个操作都隐式地以10^9 + 7或以提供该数字的方式为模。）

请注意，Java的%运算符是余数，与负数的模数不同。示例：

-1 % 5 == -1     // Java
-1 = 4 (mod 5)   // mathematical modulus

解决方法非常简单：

long mod(long b, long a)
{
    // computes a mod b
    // assumes that b is positive
    return (b + (a % b)) % b;
}

原始的迭代算法：

long recurrence_original(
    long a, long b, long c,
    long p, long q, long r,
    long n, long m // 10^9 + 7 or whatever
) {
    // base cases
    if (n == 0) return p;
    if (n == 1) return q;
    if (n == 2) return r;

    long f0, f1, f2;
    f0 = p; f1 = q; f2 = r;
    for (long i = 3; i <= n; i++) {
        long f3 = mod(m,
            mod(m, a*f2) + mod(m, b*f1) + mod(m, c*f0) +
            mod(m, mod(m, i) * mod(m, i)) * mod(m, i+1)
        );
        f0 = f1; f1 = f2; f2 = f3;
    }
    return f2;
}

模矩阵函数：

long[][] matrix_create(int n)
{
    return new long[n][n];
}

void matrix_multiply(int n, long m, long[][] c, long[][] a, long[][] b)
{
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            long s = 0;
            for (int k = 0; k < n; k++)
                s = mod(m, s + mod(m, a[i][k]*b[k][j]));
            c[i][j] = s;
        }
    }
}

void matrix_pow(int n, long m, long p, long[][] y, long[][] x)
{
    // swap matrices
    long[][] a = matrix_create(n);
    long[][] b = matrix_create(n);
    long[][] c = matrix_create(n);

    // initialize accumulator to identity
    for (int i = 0; i < n; i++)
        a[i][i] = 1;

    // initialize base to original matrix
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            b[i][j] = x[i][j];

    // exponentiation by squaring
    // there are better algorithms, but this is the easiest to implement
    // and is still O(log n)
    long[][] t = null;
    for (long s = p; s > 0; s /= 2) {
        if (s % 2 == 1) {
            matrix_multiply(n, m, c, a, b);
            t = c; c = a; a = t;
        }
        matrix_multiply(n, m, c, b, b);
        t = c; c = b; b = t;
    }

    // write to output
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            y[i][j] = a[i][j];
}

最后，新算法本身：

long recurrence_matrix(
    long a, long b, long c,
    long p, long q, long r,
    long n, long m
) {
    if (n == 0) return p;
    if (n == 1) return q;
    if (n == 2) return r;

    // original recurrence matrix
    long[][] mat = matrix_create(7);
    mat[0][0] = a; mat[0][1] = b; mat[0][2] = c; mat[0][3] = 1;
    mat[1][0] = 1; mat[2][1] = 1;
    mat[3][3] = 3; mat[3][4] = -3; mat[3][5] = 1; mat[3][6] = 6;
    mat[4][3] = 1; mat[5][4] = 1;
    mat[6][6] = 1;

    // exponentiate
    long[][] res = matrix_create(7);
    matrix_pow(7, m, n - 2, res, mat);

    // multiply the first row with the initial vector
    return mod(m, mod(m, res[0][6])
        + mod(m, res[0][0]*r)  + mod(m, res[0][1]*q)  + mod(m, res[0][2]*p)
        + mod(m, res[0][3]*36) + mod(m, res[0][4]*12) + mod(m, res[0][5]*2)
    );
}

以下是上述两种算法的一些示例基准。

原始迭代算法：

n       time (μs)
-------------------
10^1    9.3
10^2    44.9
10^3    401.501
10^4    3882.099
10^5    27940.9
10^6    88873.599
10^7    877100.5
10^8    9057329.099
10^9    91749994.4

新矩阵算法：

n       time (μs)
------------------
10^1    69.168
10^2    128.771
10^3    212.697
10^4    258.385
10^5    318.195
10^6    380.9
10^7    453.487
10^8    560.428
10^9    619.835
10^10   652.344
10^11   750.518
10^12   769.901
10^13   851.845
10^14   934.915
10^15   1016.732
10^16   1079.613
10^17   1123.413
10^18   1225.323

旧算法花了90秒以上的时间来计算n = 10^9，而新算法只用了0.6 milli 秒即可完成计算（速度提高了150,000倍）！

原始算法的时间复杂度显然是线性的（符合预期）； n = 10^10完成时间太长，因此我没有继续。

新算法的时间复杂度显然是对数的-将n的数量级加倍导致执行时间加倍（再次，由于平方幂，这是预期的）。

对于n（< 100的“较小”值，矩阵分配和运算的开销使算法本身黯然失色，但是随着n的增加而迅速变得微不足道。

在小于O（N）

1 个答案: