斐波那契数列与矩阵

小超人拯救大世界

于 2023-02-01 20:35:39 发布

阅读量263

点赞数

分类专栏：小白算法库文章标签： javascript 备忘录模式

本文链接：https://blog.csdn.net/drowsyelf/article/details/128838279

版权

小白算法库专栏收录该内容

8 篇文章 0 订阅

订阅专栏

斐波那契数列与矩阵

剑指 Offer 10- I. 斐波那契数列

数学推导

$\begin{equation} \begin{aligned} \begin{bmatrix} 1&1\\ 1&0 \end{bmatrix} \begin{bmatrix} F(n)\\ F(n - 1) \end{bmatrix} = \begin{bmatrix} F(n) + F(n - 1)\\ F(n) \end{bmatrix} = \begin{bmatrix} F(n + 1)\\ F(n) \end{bmatrix} \\ \end{aligned} \end{equation} \\ \begin{aligned} \Downarrow \\ \end{aligned} \\ \begin{equation} \begin{aligned} \begin{bmatrix} 1&1\\ 1&0 \end{bmatrix}^{n} \begin{bmatrix} F(1)\\ F(0) \end{bmatrix} = \begin{bmatrix} F(n + 1)\\ F(n) \end{bmatrix} \\ \end{aligned} \end{equation} \\$

因此，只要对 $\begin{bmatrix} 1&1\\ 1&0 \end{bmatrix}$ 进行n次幂运算后，点乘 $\begin{bmatrix} 1\\ 0\end{bmatrix}$ ，即可得到F(n)和F(n+1)的值。

复杂度分析

矩阵乘法
```
const matrixMultiplication = (M1, M2) => {
  const M1_Rows = M1.length
  const M1_Columns = M1[0].length
  const M2_Rows = M2.length
  const M2_Columns = M2[0].length

  if (M1_Columns !== M2_Rows) {
    return new Error('M1,M2不能执行乘法运算')
  }

  const res = []

  for(let i = 0; i < M1_Rows; i++) {
    const resRow = []
    for(let j = 0; j < M2_Columns; j++) {
      let rowSum = 0
      for(let k = 0; k < M1_Columns; k++) {
        rowSum += (M1[i][k] * M2[k][j]) % (1e9+7)
      }
      resRow.push(rowSum)
    }
    res.push(resRow)
  }

  return res
}
```
- two 对于矩阵 $A_{m*k}$ 和矩阵 $B_{k*p}$ ，该算法的时间复杂度是 $O (m * k * p)$ 。
矩阵幂运算
```
const matrixPower = (M, n) => {
  let res = M
  for (let i = 1; i < n; i++) {
    res = matrixMultiplication(M, res)
  }
  return res
}
```
- 对方阵 $A_{m*m}$ 求n次幂的时间复杂度是 $O(n)*O(m^{3})=O(nm^{3})$ 。
最终，求解 $A_{m})^{n}F_{m*k}$ 的时间复杂度是 $O(nm^{3})+O(m^{2}k)$
但在本题中，A、m、F是确定的，即 $A=\begin{bmatrix} 1&1\\ 1&0 \end{bmatrix}， F=\begin{bmatrix} 1 \\ 0 \end{bmatrix}，m = 2$ ，所以时间复杂度是 $O (8 n) + O (8) = O (n)$ 。

进一步优化

幂运算可以进一步优化

const getPower = (base, power) = > {
	let res = 1
	while (power > 0) {
		// 奇数
		if ((power & 1) === 1) {
			res = res * base
		}
		// 右移1位，相当于 / 2
		power >>= 1
		base = base * base
	}
	return res
}

应用到矩阵上

const matrixPower = (M, n) => {
  	// 单位矩阵
  	let res = [[1, 0], [0, 1]]
	while (n > 0) {
		if ((n & 1) === 1) {
	    	// 单位矩阵A*M = M*A
			res = matrixMultiplication(M, res)
		}
		n >>= 1
		M = matrixMultiplication(M, M)
  	}
  	return res
}