求N阶矩阵的幂（一维，二维多种方法）

引用：对于矩阵的计算想必都是一件很头疼的事情吧，因为计算量是比较大，因为你要用前一个矩阵的行乘以后矩阵的列且对应相加才得到新矩阵的第一个元素，且两个矩阵可以相乘的条件也是前一个矩阵的列等于后一个矩阵的行，操作步骤如下.

 那么对于n阶矩阵的幂就是要求你去让两个相同的矩阵再次重新相乘，其实效果是相同的，这个也涉及到了数据结构中的图的的求法，下面展开讲述

方法一

采用一维数组函数的调用的思想

1. 首先肯定要n阶矩阵输入在呢=内，n则是由你去限定，然后就去输入你的矩阵的数吧
2. 然后转换到了malloc函数去分配一个新的内存，干嘛呢？将我的数据都存在一维数组
3. 没错是一维数组将这些数据粗存在一维数组中，具体就是这样的分配的

然后开始处理 那么我是arrTemp函数肯定是要得到初始的数值啊，然后我继续到核心部分

 这个是三重循环但是你存储在数组的数值确实在二维的数组内你的arr，但是那个k是干嘛的呢，在第三重循环k中所起到的作用就是我们最为麻烦的事，前一个矩阵的行乘以后一个矩阵的列然后进行相乘相加传递给sum，这也的确是一个数值，然后就顺理成章的传递给了arr反正人家也是一维数组，当然了，当在循环的时候，你的arr的数值是传递给你的arrtemp就是乘积后的数值，我在输入的时候定义了全局数组。单独存储开始的矩阵，因为后续所要乘的就是那个sove他是没有变的，所以一直使用但是整个过程中不改变他的值，全部代码再下边可以自行分析，有疑问欢迎提问

#include <iostream> 
using namespace std;
void in(int* arr, int n);                       //输入函数，输入一个n阶矩阵的值
int* ExponentiationForTwo(int* arr, int n);    //求二次幂函数；传入矩阵数组，矩阵的阶数，求的幂次；返回一个矩阵数组
void out(int* arr, int n);   //输出函数；输出一个n阶矩阵
int sove[1000];
int main()
{
    cout << "请输入矩形的阶数:";
    //输入矩阵阶数n
    int n;
    cin >> n;

    //为矩阵数组分配内存,分配n*n个int类型大小的空间给arr即矩阵元素个数
    int* arr = (int*)malloc(sizeof(int) * n * n);

    //输入矩阵各个元素的值
    in(arr, n);

    //算出arr的二次幂
    arr = ExponentiationForTwo(arr, n);
    //输出矩阵各个元素的值,这个时候arr是二次的
    cout << "输出二阶幂:\n";
    out(arr, n);
    //算出arr的二次幂，因为上面已经算过一次了，所以这个地方算的是三次幂了
    arr = ExponentiationForTwo(arr, n);
    //输出矩阵各个元素的值，这个时候arr是三次的
    cout << "输出"<<n<<"阶幂:\n";
    out(arr, n);

    //所以如果要求n次幂，只需要循环调用   arr= ExponentiationForTwo(arr, n);这句话就行了，类似于i=i*i;

    return 0;
}
void in(int* arr, int n)
{
    cout << "输入" << n << "行" << n << "列的数据值:\n";
    //二维数组数据的输入
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            cin >> arr[i * n + j];
            sove[i * n + j] = arr[i * n + j];
        }
    }
}

int* ExponentiationForTwo(int* arr, int n)
{
    int* tempArr1 = (int*)malloc(sizeof(int) * n * n);


    //把arr的值拷贝到tempArr中
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            tempArr1[i * n + j] = arr[i * n + j];
        }
    }
    //计算tempArr的二次幂，将结果存入到arr中
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < n; j++)
        {
            int sum = 0;
            for (int k = 0; k < n; k++)
            {
                sum += tempArr1[i * n + k] * sove[k * n + j];
            }
            arr[i * n + j] = sum;
        }
    }
    //这个时候，原矩阵arr的值已经是arr*arr了，记得要将tempArr申请的内存释放
    free(tempArr1);
    
    return arr;
}
void out(int* arr, int n)
{
    for (int i = 0; i < n; i++) { //二维数组数据的输入
        for (int j = 0; j < n; j++) {
            cout << arr[i * n + j] << " ";
        }
        printf("\n");
    }

}

第二种方法

上方使用的是一维数组，那么下边使用的是二维数组，这个我想是大多数的想法，来使用这个矩阵来用二维数组来进行存储，然后进行计算，那么想了一下，其实就需要三个数组就行了，一维使用函数保证数据的不丢失我暂且使用全局数组不是指针哈，

第一个数组的作用是为了保存初始值

第二个是起到了计算的作用

第三个是为了输出

其实也是和上述是一个的计时在for的三重循环中的关系是

//比如说是n重矩阵哈

for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            sum2 = 0;
            for (int k = 0; k < n; k++) {
                sum2 += arr[i][k] * arr1[k][j];

// 这个乘一下就可以去得到两个矩阵相乘积后的结果
            }
        }
    }

详细代码再下边，

//二维数组的形式
#include <stdio.h>
#define N 1001
void func(int arr[][N], int n);
int arr1[N][N], arr2[N][N], arr3[N][N];
int main() {
	int i, j, k, temp1, temp2, n, x;
	printf("输入无向图的邻接矩阵的阶数:");
	scanf("%d", &n);
	for (i = 0; i < n; i++) {
		for (j = 0; j < n; j++) {
			scanf("%d", &arr1[i][j]);
		}
	}
	//开始对于数据项的处理
	for (i = 0; i < n; i++) {
		for (j = 0; j < n; j++) {
			temp1 = 0;
			for (k = 0; k < n; k++) {
				temp1 += arr1[i][k] * arr1[k][j]; //符合矩阵的形式
			}
			arr2[i][j] = temp1; //此时让sum1 成为其值的一部分
		}
	} //b[][]此时是二阶的了
	x = n;
	while ((x - 1) > 0) {
		func(arr2, n);
		x--;
	}

	return 0;
}
void func(int arr[][N], int n)
{
	int sum2;
	printf("最终得到%d矩阵的邻接矩阵为：\n", n);
	for (int i = 0; i < n; i++) {
		for (int j = 0; j < n; j++) {
			sum2 = 0;
			for (int k = 0; k < n; k++) {
				sum2 += arr[i][k] * arr1[k][j];
			}
			arr3[i][j] = sum2;
		}
	}

	for (int i = 0; i < n; i++) {
		for (int j = 0; j < n; j++)
			printf("%d ", arr3[i][j]);
		printf("\n");
	}
}

若有疑问欢迎留言