Recursive squaring
0 likes1,561 views
This document describes an algorithm to compute the nth Fibonacci number using recursive squaring in better than linear time. It does this by raising the matrix ((1,1),(1,0)) to the nth power using recursive squaring. If n is even, it recursively computes An/2 and multiplies it by itself. If n is odd, it recursively computes A(n-1)/2 and multiplies it by itself and the original matrix A. This allows it to compute An in O(log n) time rather than the naive O(n) linear time approach. Pseudocode and a C++ implementation are provided.
![1
Fibonacci using recursive squaring
The naive bottom-up algorithm to compute the nth ibonacci number take linear
time O(n). We can do better than linear time. One of the well-known properties
of ibonacci numbers is :
Fn+1 Fn
Fn Fn−1
=
1 1
1 0
n
We can therefore compute the nth power of A = ((1, 1), (1, 0)) using recursive
squaring. That is, if n is even, we recursively compute An/2
. This sub-problem
takes T(n/2) time. Cache this result in a temp variable. The desired result is An
=
An/2
× An/2
. Since, we have already computed An/2
, it’s the same subproblem,
we don’t have to repeat this work. So, all we do is temp*temp. Multiplying two
2 × 2 matrices takes constant time - O(1). So, the total running time is T(n) =
T(n/2) + O(1) which has upper bound O(lg n).
Here’s the code snippet:
#include <iostream >
class matrix
{
int items[2][2];
public:
matrix();
matrix(const matrix& A);
matrix(int init_value);
matrix& operator = (const matrix& A);
matrix operator * (const matrix& A) const;
void print() const;
void set(int i, int j, int x);
matrix rec_power(int n);
};
int main()
{
matrix A;
matrix B = A.rec_power(5);
std::cout << "nA^5 = ";
B.print();
std::cin.clear();](https://image.slidesharecdn.com/recursivesquaring-180614043045/85/Recursive-squaring-1-320.jpg)
![2
std::cin.get();
return 0;
}
matrix::matrix()
{
items[0][0] = items[1][0] = items[0][1] = 1;
items[1][1] = 0;
}
matrix::matrix(const matrix& A)
{
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++)
items[i][j] = A.items[i][j];
}
matrix::matrix(int init_value)
{
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++)
items[i][j] = init_value;
}
matrix& matrix::operator = (const matrix& A)
{
if (this == &A)
return *this;
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++)
items[i][j] = A.items[i][j];
return *this;
}
matrix matrix::operator * (const matrix& A) const
{
matrix temp(0);
for (int i = 0; i < 2; i++)
{
for (int j = 0; j < 2; j++)
{
for (int k = 0; k < 2; k++)
{
temp.items[i][j] += items[i][k] * A.items[k][j];](https://image.slidesharecdn.com/recursivesquaring-180614043045/85/Recursive-squaring-2-320.jpg)
![3
}
}
}
return temp;
}
void matrix::print() const
{
std::cout << "n(" << items[0][0] << "," << items[0][1]
<< ")";
std::cout << "n(" << items[1][0] << "," << items[1][1]
<< ")";
}
void matrix::set(int i, int j, int x)
{
items[i][j] = x;
}
matrix matrix::rec_power(int n)
{
if (n == 0)
{
matrix temp;
temp.items[0][0] = temp.items[1][1] = 1;
temp.items[0][1] = temp.items[1][0] = 0;
return temp;
}
if (n == 1)
{
return *this;
}
else
{
if (n % 2 == 0)
{
matrix temp = rec_power(n / 2);
return temp * temp;
}
else
{
matrix temp = rec_power((n - 1) / 2);
return temp * temp * (*this);
}
}](https://image.slidesharecdn.com/recursivesquaring-180614043045/85/Recursive-squaring-3-320.jpg)
Recursive squaring
- 1. 1 Fibonacci using recursive squaring The naive bottom-up algorithm to compute the nth ibonacci number take linear time O(n). We can do better than linear time. One of the well-known properties of ibonacci numbers is : Fn+1 Fn Fn Fn−1 = 1 1 1 0 n We can therefore compute the nth power of A = ((1, 1), (1, 0)) using recursive squaring. That is, if n is even, we recursively compute An/2 . This sub-problem takes T(n/2) time. Cache this result in a temp variable. The desired result is An = An/2 × An/2 . Since, we have already computed An/2 , it’s the same subproblem, we don’t have to repeat this work. So, all we do is temp*temp. Multiplying two 2 × 2 matrices takes constant time - O(1). So, the total running time is T(n) = T(n/2) + O(1) which has upper bound O(lg n). Here’s the code snippet: #include <iostream > class matrix { int items[2][2]; public: matrix(); matrix(const matrix& A); matrix(int init_value); matrix& operator = (const matrix& A); matrix operator * (const matrix& A) const; void print() const; void set(int i, int j, int x); matrix rec_power(int n); }; int main() { matrix A; matrix B = A.rec_power(5); std::cout << "nA^5 = "; B.print(); std::cin.clear();
- 2. 2 std::cin.get(); return 0; } matrix::matrix() { items[0][0] = items[1][0] = items[0][1] = 1; items[1][1] = 0; } matrix::matrix(const matrix& A) { for (int i = 0; i < 2; i++) for (int j = 0; j < 2; j++) items[i][j] = A.items[i][j]; } matrix::matrix(int init_value) { for (int i = 0; i < 2; i++) for (int j = 0; j < 2; j++) items[i][j] = init_value; } matrix& matrix::operator = (const matrix& A) { if (this == &A) return *this; for (int i = 0; i < 2; i++) for (int j = 0; j < 2; j++) items[i][j] = A.items[i][j]; return *this; } matrix matrix::operator * (const matrix& A) const { matrix temp(0); for (int i = 0; i < 2; i++) { for (int j = 0; j < 2; j++) { for (int k = 0; k < 2; k++) { temp.items[i][j] += items[i][k] * A.items[k][j];
- 3. 3 } } } return temp; } void matrix::print() const { std::cout << "n(" << items[0][0] << "," << items[0][1] << ")"; std::cout << "n(" << items[1][0] << "," << items[1][1] << ")"; } void matrix::set(int i, int j, int x) { items[i][j] = x; } matrix matrix::rec_power(int n) { if (n == 0) { matrix temp; temp.items[0][0] = temp.items[1][1] = 1; temp.items[0][1] = temp.items[1][0] = 0; return temp; } if (n == 1) { return *this; } else { if (n % 2 == 0) { matrix temp = rec_power(n / 2); return temp * temp; } else { matrix temp = rec_power((n - 1) / 2); return temp * temp * (*this); } }