SoloCodigo

Hola....
Necesito que alguien me ayude con un programa en c++ que me calcule la inversa de una matriz n*n, si es posible que sea de más de 2*2.
Porfa, me lo pueden enviar a juliancho@hackemate.com.ar
Agradezco toda su colaboración.

Ese es el mayor problemibiris.
Aun no se nisiquera como hacerle.
Creo que primero hay que sacar la determinante de la matríz, luego sacar la matriz adjunta, a la adjunta sacarle la transpuesta y por último dividir la transpuesta por el determinante.
Lo que no c es como sacar el determinante y como sacar la adjunta.
Agradezco toda la ayuda.

espero que te sirva leelo !/*
Calculo de la Iversa de una Matriz - Algoritmo de Gauss


*/

#include <iostream.h>

class matriz {
      /*
         Definicion del objeto matriz. Usare tabla para guardar los datos orginales
         y sobre tabla2 se realizaran las operaciones.
      */
      double **tabla,**tabla2;
      int dim;
   public:
      enum tipo_tabla{coef,ampliada,inversa};
      matriz(int);
      ~matriz();
      void llenar();
      void imprimir(int);
      bool invertir(int,bool);
};

matriz::matriz(int n) {
   int i;
   dim=n;
   tabla=new double *[dim];
   for (i=0;i<dim;i++) *(tabla+i)=new double[dim*2];
}

matriz::~matriz() {
   int i;
   for (i=0;i<dim;i++) delete [] *(tabla+i);
   delete [] tabla;
   for (i=0;i<dim;i++) delete [] *(tabla2+i);
   delete [] tabla2;
}

void matriz::llenar() {
   int i,j;
   double num;
   for (i=0;i<dim;i++) {
      for (j=0;j<dim;j++) {
         cout<<"Ingresa coeficiente a["<<i+1<<","<<j+1<<"]: ";
         cin>>num;
         *(*(tabla+i)+j)=num;
      }
      for (j=dim;j<dim*2;j++) *(*(tabla+i)+j)=(i==(j-dim))?(double)1:(double)0;
   }
   tabla2=new double *[dim];
   for (i=0;i<dim;i++) *(tabla2+i)=new double[dim*2];
   for (i=0;i<dim;i++)
      for (j=0;j<dim*2;j++) *(*(tabla2+i)+j)=*(*(tabla+i)+j);
}

void matriz::imprimir(int t_tabla) {
   int i,j;
   if (t_tabla==coef) {
      for (i=0;i<dim;i++,cout<<endl)
         for (j=0;j<dim;j++) cout<<*(*(tabla+i)+j)<<"t";
   }
   else if (t_tabla==ampliada) {
      for (i=0;i<dim;i++,cout<<endl)
         for (j=0;j<dim*2;j++) cout<<*(*(tabla+i)+j)<<"t";
   }
   else {
      for (i=0;i<dim;i++,cout<<endl)
         for (j=dim;j<dim*2;j++) cout<<*(*(tabla2+i)+j)<<"t";
   }
}

bool matriz::invertir(int pivote=0,bool ida=true) {
   /*
      Invierte la matriz en tabla2. Retorna true si el proceso se realizo con exito, o sea
      si la matriz en tabla es invertible o de lo contrario false.
      Pivote es el elemento de la diagonal bajo, o sobre, el cual se anularan los coeficientes.
      ida indica que paso se ejecuta, la formacion de:
         i) triangular superior
         ii) triangular inferior y simplificacion
      Vea las hojas de respuesta para ver una explicacion detallada de los pasos y el algoritmo
   */
   int i,j;
   double k;
   if (!*(*(tabla2+pivote)+pivote)) return false; // Matriz no invertible
   else if (ida) {
      // Fomacion trinagular superior
      if (pivote==dim-1) return invertir(pivote,false); //Se llega al elemento a[n,n] y se llama a si misma pero con false, o sea pasa al paso ii
      else {
         for (i=pivote;i<dim-1;i++) {
            k=*(*(tabla2+i+1)+pivote)/ *(*(tabla2+pivote)+pivote); // Calculo de k
            for (j=0;j<dim*2;j++)
               *(*(tabla2+i+1)+j)=*(*(tabla2+i+1)+j)-*(*(tabla2+pivote)+j)*k; // Operacion fila
         }
         return invertir(++pivote);
      }
   }
   else {
      // Fomacion trinagular inferior
      if (pivote==0) { //Se llega al elemento a[1,1]
         k=1/ *(*(tabla2+pivote)+pivote);
         for (j=0;j<dim*2;j++)
            *(*(tabla2+pivote)+j)*=k; //Se simplifica el elemento la fila por el elemento de la diagonal (paso iii)
         return true;
      }
      else {
         for (i=pivote;i>0;i--) {
            k=*(*(tabla2+i-1)+pivote)/ *(*(tabla2+pivote)+pivote); // Calculo de k
            for (j=0;j<dim*2;j++)
               *(*(tabla2+i-1)+j)=*(*(tabla2+i-1)+j)-*(*(tabla2+pivote)+j)*k; // Operacion fila
            k=1/ *(*(tabla2+pivote)+pivote);
            for (j=0;j<dim*2;j++)
               *(*(tabla2+pivote)+j)*=k; //Se simplifica el elemento la fila por el elemento de la diagonal (paso iii)

         }
         return invertir(--pivote,false);
      }
   }
}

int main() {
   int dim;
   matriz *tabla;
   cout<<"Calculo de la Iversa de una Matriz - Algoritmo de Gauss"<<endl<<endl;
   cout<<"Fase de Tarea Certamen 2 - Fundamentos de Informatica I"<<endl<<endl;
   cout<<"Jorge Riquelme S. 2173090-4"<<endl;
   cout<<"http://www.totex.cl - totex@totex.cl"<<endl<<endl<<endl;
   cout<<"Dimension de la matriz? ";
   cin>>dim;
   tabla=new matriz(dim);
   tabla->llenar();
   cout<<endl<<"Matriz de coeficientes ingresados:"<<endl;
   tabla->imprimir(matriz::coef);
   cout<<endl<<"Matriz ampliada"<<endl;
   tabla->imprimir(matriz::ampliada);
   if (tabla->invertir()) {
      // Si la matriz se pudo invertir la muestra
      cout<<endl<<"Matriz Inversa"<<endl;
      tabla->imprimir(matriz::inversa);
   }
   else cout<<endl<<"La matriz no tiene inversa!"<<endl;
   return 0;
}

no se como ingrsar datos en una matriz dinamica como esta:
#include<stdio.h>
#include<stdlib.h>
/*declaracion matriz*/
int *matriz;
int a,b;
/* decalracion variables*/
int x,y,i,j,cont=0;
/*inicio*/
main()
{
        matriz = (int *) malloc (sizeof(int)*a*;
        for(x=1;x<=2;x++)
        {
                for(y=1;y<=2;y++)
                {
                        printf("[%d][%d]=>",x,y);scanf("%d",&matriz[x, y]);//aqui si le pongo matriz

• [y] sale error

                }
        }
        for(i=1;i<=2;i++)
        {
                for(j=1;j<=2;j++)
                {
                        printf("%d",matriz [i, j]);//solo imprime los 2 ultimos dos veses
                }
        }
}