Быстрое вычисление членов линейной рекуррентной последовательности

Пусть нам дана линейная реккурента размера [math]k[/math]. А именно: [math]a_n = c_1 \cdot a_{n - 1} + c_2 \cdot a_{n - 2} + \cdots + c_k \cdot a_{n - k}[/math], а так же заданы [math]k[/math] первых членов последовательности. Требуется уметь вычислять произвольное [math]a_n[/math].

Самый простой способ сделать это — последовательно считать каждый [math]a_i[/math], пока [math]i[/math] не станет равен [math]n[/math]. Однако этот способ не самый эффективный, ведь он, очевидно, требует [math]O(n \cdot k)[/math] времени. Хочется уметь как-то быстрее решать эту задачу. Рассмотрим два способа это сделать.

Умножение матриц (за [math]O(k^3 \cdot logn)[/math])

Заметим, что линейные рекурренты хорошо выражаются через матрицы. Запишем наши первые [math]k[/math] членов последовательности в столбик. [math]A_0 = \begin{pmatrix} a_{k - 1}\\ a_{k - 2}\\ \vdots \\ a_0 \end{pmatrix}[/math] Так же выпишем следующую матрицу перехода: [math]T = \begin{pmatrix} c_1 & c_2 & c_3 & \cdots & c_k\\ 1 & 0 & 0 & \cdots & 0\\ 0 & 1 & 0 & \cdots & 0\\ \vdots & \vdots & \vdots & ~ & \vdots \\ 0 & 0 & 0 & \cdots & 1\\ \end{pmatrix}[/math]

Заметим, что умножив [math]A_0[/math] слева на [math]T[/math], мы получим столбик [math]A_1[/math] следующего вида: [math]A_1 = T \cdot A_0 = \begin{pmatrix} a_{k}\\ a_{k - 1}\\ \vdots \\ a_1 \end{pmatrix}[/math] Аналогично, домножив [math]A_1[/math] слева на [math]T[/math], получим [math]A_2 = T \cdot A_1 = \begin{pmatrix} a_{k + 1}\\ a_{k}\\ \vdots \\ a_2 \end{pmatrix}[/math]

Продолжая так для любого [math]i[/math], мы получим столбик [math]A_i[/math], состоящий из [math]k[/math] подряд идущий членов последовательности, начиная с [math]a_i[/math]. Пользуясь ассоциативностью произведения матриц, можно записать, что [math]A_i = T^i \cdot A_0[/math]. Из этого соотношения вытекает алгоритм вычисления произвольного [math]a_n[/math]:

1. Инициализировать матрицы [math]A_0[/math] и [math]T[/math]
2. Возвести матрицу [math]T[/math] в степень [math]n[/math]
3. Посчитать [math]A_n[/math] как [math]T^n \cdot A_0[/math] и взять из него [math]a_n[/math]

Используя быстрое возведение в степень, второй пункт будет тратить [math]O(k^3 \cdot logn)[/math] времени, умножение же в третьем пункте выполняется за [math]O(k^2)[/math].

Итого мы получили алгоритм за [math]O(k^3 \cdot logn)[/math].

Связь с многочленами (за [math]O(k^2 \cdot logn)[/math])

Вспомним, что по теореме о связи рекурренты и многочленов наша реккурента эквивалента некому многочлену [math]A(t) = \dfrac{P(t)}{Q(t)}[/math], при этом [math]Q(t) = 1 - c_1 \cdot t - c_2 \cdot t^2 - \cdots - c_k \cdot t^k[/math]. Домножим числитель и знаменатель на [math]Q(-t)[/math]. Новый знаменатель [math]R(t) = Q(t) \cdot Q(-t)[/math]. При этом [math]r_n = \sum\limits_{i = 0}^{n} q_i \cdot q_{n - i} \cdot (-1)^{n - i}[/math]. Нетрудно заметить, что при нечётных [math]n[/math] коэффициенты [math]r_n[/math] обращаются в [math]0[/math], a [math]r_0 = 1[/math].

Отсюда мы получаем, что многочлен [math]R(t)[/math] имеет вид: [math]R(t) = 1 + r_2 \cdot t^2 + r_4 \cdot t^4 + \cdots + r_{2k} \cdot t^{2k}[/math]. Однако вспомним о связи с рекуррентой, а именно мы получили, что [math]a_n = -r_2 \cdot a_{n - 2} - r_4 \cdot a_{n - 4} - \cdots - r_{2k} \cdot a_{n - 2k}[/math]

Иными словами мы получили новое рекуррентное соотношение для данной последовательности, где каждый элемент зависит от элементов с номерами, имеющими такую же чётность, что номер исходного. То есть по сути наша последовательность разделилась на две независимых: с чётными и нечётными номерами. Можно сказать, что мы теперь ищем не [math]a_n[/math] из исходной последовательности, а [math]a'_{n~div~2}[/math] из подпоследовательности элементов, имеющих ту же чётность, что и [math]n[/math]. Заметим, что этот процесс можно проделывать далее пока [math]n \geqslant k[/math], ведь в итоге искомый окажется среди [math]k[/math] первых. Всё, что нам нужно,— поддерживать первые [math]k[/math] элементов для каждой новой последовательности.

Исходя из всего вышесказанного получаем алгоритм:

   while (n <= k) {
        count a[k], a[k + 1], ..., a[2k - 1];
        Q(t) = Q(t) * Q(-t);
        leave a[i] with (i % 2 == n % 2);
        Q: t^2i -> t^i;
        n = n div 2;
   }
   return a[n];

Вычисление [math]a[k], a[k + 1], \cdots , a[2k - 1][/math] занимает [math]O(k^2)[/math] времени, ибо их всего [math]k[/math], а каждое считается за [math]O(k)[/math]. Умножение многочленов длины порядка [math]k[/math] также занимает [math]O(k^2)[/math] времени. Итераций внешнего цикла будет [math]O(logn)[/math] в силу того, что мы делим [math]n[/math] на [math]2[/math] каждый раз.

Итого мы получили алгоритм, работающий за [math]O(k^2 \cdot logn)[/math]