多线程求行列式值

#include<iostream>
#include<pthread.h>
#include<cstdlib>
#include<cstdio>
#include<sys/time.h>
#include<stdlib.h>
#include<string.h>
#include<iomanip>
using namespace std;
#define Max_Matrix_size 1000
#define Max_pthread_size 100
double Matrix[Max_Matrix_size][Max_Matrix_size];
int Matrix_size;
int Thread_num;
int Per_thread_do;
double Per_thread_cal[Max_pthread_size];
double result = 0.0;
pthread_mutex_t mut;
double det_cal(double **mmatrix,int size){
	if(size == 1){
		return mmatrix[0][0];
	}
	else{
		double res = 0.0;
		double **matrix = (double **)malloc(sizeof(double*) * (size));
		for(int i = 0;i < size - 1;i++){
			matrix[i] = (double *)malloc(sizeof(double) * (size));
		}
		for(int i = 0;i < size;i++){
			for(int j = 1;j < size;j++){
				for(int k = 0;k < size;k++){
					if(k < i){
						matrix[j - 1][k] = mmatrix[j][k];
					}
					if(k > i){
						matrix[j - 1][k - 1] = mmatrix[j][k];
					}
				}
			}
			if(i % 2 == 0){
				res += mmatrix[0][i] * det_cal(matrix,size - 1);
			}
			else{
				res -= mmatrix[0][i] * det_cal(matrix,size - 1);
			}
		}
		for (int i = 0; i < size - 1; i++) {
			free(matrix[i]);
		}
		free(matrix);
		return res;
	}
}
void *t_hread(void *arg){
	int q = *(int*)arg;
	double **matrix = (double **)malloc(sizeof(double*) * (Matrix_size));     
	for(int i = 0;i < Matrix_size;i++){
		matrix[i] = (double *)malloc(sizeof(double) * (Matrix_size));
	}
	if(q != Thread_num - 1){
		for(int i = q * Per_thread_do;i < ((q + 1) * Per_thread_do);i++){
			for(int j = 1;j < Matrix_size;j++){
				for(int k = 0;k < Matrix_size;k++){
					if(k < i){
						matrix[j - 1][k] = Matrix[j][k];
					}
					if(k > i){
						matrix[j - 1][k - 1] = Matrix[j][k];
					}
				}
			}
			if(i % 2 == 0){
				Per_thread_cal[q] += Matrix[0][i] * det_cal(matrix,Matrix_size - 1);	
			}
			
			else{
				Per_thread_cal[q] -= Matrix[0][i] * det_cal(matrix,Matrix_size - 1);
			}
		}		
	} 
	if(q == Thread_num - 1){
		for(int i = q * Per_thread_do;i < Matrix_size;i++){
			for(int j = 1;j < Matrix_size;j++){
				for(int k = 0;k < Matrix_size;k++){
					if(k < i){
						matrix[j - 1][k] = Matrix[j][k];
					}
					if(k > i){
						matrix[j - 1][k - 1] = Matrix[j][k];
					}
				}
			}
			if(i % 2 == 0){
				Per_thread_cal[q] += Matrix[0][i] * det_cal(matrix,Matrix_size - 1);	
			}
			
			else{
				Per_thread_cal[q] -= Matrix[0][i] * det_cal(matrix,Matrix_size - 1);
			}
		}		
	}
	pthread_mutex_lock(&mut);
	result += Per_thread_cal[q];
	pthread_mutex_unlock(&mut);
	for(int i = 0;i < Matrix_size - 1;i++){
		free(matrix[i]);
	}
	free(matrix);
	pthread_exit(0);
}
int main(int argc,char *argv[]){
	if(argc != 4){
		cout<<"Input format:MATRIX_SIZE,THREAD_NUM,INPUT_FILE"<<endl;
		return 0;
	}	
	memset(Per_thread_cal, 0.0, sizeof(Per_thread_cal));
	Matrix_size = atoi(argv[1]);    
	Thread_num = atoi(argv[2]);		
	char *input = argv[3];			
	Per_thread_do = Matrix_size / Thread_num;		
	pthread_mutex_init(&mut,NULL);
	freopen(input,"r",stdin);					
	for(int i = 0;i < Matrix_size;i++){
		for(int j = 0;j < Matrix_size;j++){
			cin>>Matrix[i][j];
		}
	}															
	pthread_t thread[Max_pthread_size];
	//int id[100];
	int *id = (int *)malloc(sizeof(int) * (Thread_num));
	struct timeval begin,end;
    gettimeofday(&begin,NULL);
	for(int i = 0;i < Thread_num;i++){
		id[i] = i;
		pthread_create(&thread[i],NULL,t_hread,(void*)&id[i]);
	}
	for(int i = 0;i < Thread_num;i++){
		pthread_join(thread[i],NULL);
	}
	free(id);
	cout<<fixed<<setprecision(2)<<result<<endl;
	gettimeofday(&end,NULL);
	int time = (end.tv_sec - begin.tv_sec) * 1000000 + (end.tv_usec - begin.tv_usec);
    printf("time: %d us\n", time);
	return 0;
}