Programa C++ para cálculo do determinante de uma matriz NxN

Esta é uma pré-visualização de arquivo. Entre para ver o arquivo original

/*------------------------------------------------------
| Algoritmo para encontrar determinantes |
|		 Feito por Guttardo Néri Pereira |
|			Ciência da Computação/UFV				 |
|------------------------------------------------------*/
#include <iostream>
#include <cmath>
#include <cstdio>
#include <stdlib.h>
using namespace std;
int determinante=0, matriz[10][10];
//Função para realizar o cálculo do determinante, recebe as permutações, a matriz e a ordem da mesma;
void calculo(const int *v, const int tamanho)
{
	int inversao=0, resultado=1;
	
	//Contar o número de inversões para uma permutação;
	for (int i=0;i<tamanho;i++){
		for (int j=0;j<tamanho;j++){
			if (v[i]>v[j]&&i<j) //Se o valor de i for maior do que j e ele preceder o j, então incrementa-se uma inversão;
				inversao++;
		}
	}
	
	/*cout << "Inversoes: " << inversao << endl;
	cout << "Permutacao: ";
	for (int i=0;i<tamanho;i++)
		cout << v[i] << " ";
	cout << endl;*/
	
	//Icrementa o valor que estar no elemento a(ij) da matriz ao resultado de uma parcela;	
	if (v != 0) {
		for (int i = 0; i < tamanho; i++){
			if (inversao%2==0){ // Se a inversão for par então se faz adição da parcela;
 			resultado*= matriz[i][v[i]];
 		}
	 		else{ // Se não então se faz a subtração;
	 			resultado*= -matriz[i][v[i]];
	 			inversao--; //Como não se pode multiplicar novamente pelo negativo, pois ele irá virá positivo, tiramos uma unidade da inversão para assim as outras parcelar serem consideradas como o primeiro caso;
	 		}
 	}
 }
	// Soma resultado de uma parcela ao determinante; 
	determinante+=resultado;
} 
//Função que troca os valores na permutação;
void troca(int *v, const int i, const int j)
{
	int t;
	t = v[i];
	v[i] = v[j];
	v[j] = t;
} 
//Função que retorna ao valor original para se começar uma nova permutação;
void rodar(int *v, const int comecar, const int n)
{
	int tmp = v[comecar];
	
	for (int i = comecar; i < n-1; i++) {
 	v[i] = v[i+1];
 	}
 	
	v[n-1] = tmp;
} 
//A função à qual todo o algoritmo está preso, realiza todas as permutações possíveis;
void permutacao(int *v, const int comecar, const int n)
{
	calculo(v, n);
	if (comecar < n) {
		int i, j;
		for (i = n-2; i >= comecar; i--) {
 		for (j = i + 1; j < n; j++) {
				troca(v, i, j);
					permutacao(v, i+1, n);
			} // Para todo j;
			rodar(v, i, n);
 	} // Para todo i;
 	}
}
//Iniciar a permutação e guardar os valores constants (1,2,3,4...);
void iniciar(int *v, int N)
{
 for (int i = 0; i < N; i++) {
 v[i] = i+1;
 }
}
//Função principal, para usuário digitar a ordem e sua matriz;
int main ()
{	
	int N, constante[10];
	determinante=0;
	cout << "Digite a ordem de sua matriz A:(1-10)\n";
	cin >> N;
	
	while (N>10){
		cout << "Somente ordem menor ou igual a 10...\n";
		cin >> N;
	}
	
	for (int i=1;i<=N;i++)
		constante[i]=i;
	
	cout << "Agora digite todos os elementos da sua matriz A:\n"
			 "-----------------------------------------------\n";
	
	
	for (int i=0;i<N;i++)
		for (int j=1;j<=N;j++)
			cin >> matriz[i][j];
			
		
	if (N > 0 && N <= 10) {
	 int *v = new int[N];
	 iniciar(v, N);
	 permutacao(v, 0, N);
	 delete [] v;
 	}
 	
	cout << "------------------------------------------------\n";
	cout << "DetA = " << determinante << endl;		
	cout << "\n------------------------------------------------\n"
			"Algoritmo feito por Guttardo Neri Pereira/UFV\n";
	
	system("PAUSE");
	
	return 0;
}