矩阵快速幂求斐波那契数列循环输入c语言代码

### 回答1：
以下是矩阵快速幂求斐波那契数列的 C 语言代码：

#include <stdio.h>

void matrix_multiply(int a[2][2], int b[2][2], int c[2][2]) {
int i, j, k;
for (i = ; i < 2; i++) {
for (j = ; j < 2; j++) {
c[i][j] = ;
for (k = ; k < 2; k++) {
c[i][j] += a[i][k] * b[k][j];
}
}
}
}

void matrix_pow(int a[2][2], int n, int b[2][2]) {
int i, j;
int c[2][2];
b[][] = b[1][1] = 1;
b[][1] = b[1][] = ;
while (n > ) {
if (n % 2 == 1) {
matrix_multiply(b, a, c);
for (i = ; i < 2; i++) {
for (j = ; j < 2; j++) {
b[i][j] = c[i][j];
}
}
}
matrix_multiply(a, a, c);
for (i = ; i < 2; i++) {
for (j = ; j < 2; j++) {
a[i][j] = c[i][j];
}
}
n /= 2;
}
}

int fibonacci(int n) {
int a[2][2] = {{1, 1}, {1, }};
int b[2][2];
matrix_pow(a, n - 1, b);
return b[][];
}

int main() {
int n;
while (scanf("%d", &n) != EOF) {
printf("%d\n", fibonacci(n));
}
return ;
}

### 回答2：
#include <stdio.h>

int main() {
int n;
// 输入n的值
scanf("%d", &n);

// 矩阵乘法函数
void matrixMultiply(int a[2][2], int b[2][2], int c[2][2]) {
int i, j, k;
for(i = 0; i < 2; i++) {
for(j = 0; j < 2; j++) {
c[i][j] = 0;
for(k = 0; k < 2; k++) {
c[i][j] += a[i][k] * b[k][j];
}
}
}
}

// 矩阵快速幂函数
void matrixPower(int base[2][2], int result[2][2], int n) {
int i, j;
int temp[2][2];
// 初始化结果为单位矩阵
result[0][0] = result[1][1] = 1;
result[0][1] = result[1][0] = 0;
while(n > 0) {
// 如果n为奇数，则乘以base
if(n % 2) {
matrixMultiply(result, base, temp);
for(i = 0; i < 2; i++) {
for(j = 0; j < 2; j++) {
result[i][j] = temp[i][j];
}
}
}
// base自乘
matrixMultiply(base, base, temp);
for(i = 0; i < 2; i++) {
for(j = 0; j < 2; j++) {
base[i][j] = temp[i][j];
}
}
n /= 2;
}
}

// 斐波那契数列计算函数
int fibonacci(int n) {
int base[2][2] = {{1, 1}, {1, 0}};
int result[2][2];

matrixPower(base, result, n-1);

return result[0][0];
}

// 循环输入n的值，计算并输出结果
while(1) {
scanf("%d", &n);
if(n == -1) // 输入-1时结束循环
break;
printf("%d\n", fibonacci(n));
}

return 0;
}

### 回答3：
下面是一个用C语言实现斐波那契数列的矩阵快速幂算法的示例代码：

#include <stdio.h>

void multiply(int F[2][2], int M[2][2])
{
    int x = F[0][0] * M[0][0] + F[0][1] * M[1][0];
    int y = F[0][0] * M[0][1] + F[0][1] * M[1][1];
    int z = F[1][0] * M[0][0] + F[1][1] * M[1][0];
    int w = F[1][0] * M[0][1] + F[1][1] * M[1][1];
    
    F[0][0] = x;
    F[0][1] = y;
    F[1][0] = z;
    F[1][1] = w;
}

void power(int F[2][2], int n)
{
    int M[2][2] = {{1, 1}, {1, 0}}; // 斐波那契数列的转移矩阵
    
    for (int i = 2; i <= n; i++)
    {
        multiply(F, M);
    }
}

int fibonacci(int n)
{
    if (n == 0)
        return 0;
    
    int F[2][2] = {{1, 1}, {1, 0}};
    
    power(F, n - 1);
    
    return F[0][0];
}

int main()
{
    int n;
    printf("请输入要求的斐波那契数列的索引：");
    scanf("%d", &n);
    
    printf("第%d个斐波那契数是：%d\n", n, fibonacci(n));
    
    return 0;
}

在这段代码中，我们首先定义了一个`multiply`函数，用于计算两个矩阵的乘法。然后定义了一个`power`函数，通过多次调用`multiply`函数来进行矩阵的快速幂运算。最后，我们定义了一个`fibonacci`函数，它接收一个整数作为参数，返回对应斐波那契数列的值。在`main`函数中，我们通过用户输入的值调用`fibonacci`函数并输出结果。

这段代码通过矩阵快速幂的方式来计算斐波那契数列的第n个值，相比传统的递归或迭代方法，具有更高效的计算速度。