Problema con invcertitore matrici

Ciao a tutti,
devo consegnare a breve un programma che si occupi di invertire una qualsiasi matrice. Vi posto quello che ho scritto, il programma in generale funziona, ma quando ci sono alcuni zeri durante la riduzione della matrice mi da dei problemi. Potete darmi una mano senza sconvolgere il programma???

#include <iostream>



using namespace std;





      // ci sono ancora problemi con gli zeri







char p;

int main()

{



do 

{

                                                              // Allocazione della memoria

 double **A;                                                   

 int n;

 cout<< "Creazione matrice n x n \n Inserire il valore di n: "; 

 cin>>n; cout<<endl;

 A=new double*[n];

 for(int i=0;i<n;i++) 

   A[i]=new double[n];





  

    double **I;                 // Matrice identità

    I=new double*[n];

    for(int i=0;i<n;i++) 

      I[i]=new double[n];

                                        

         for(int i=0;i<n;i++)

            for(int j=0;j<n;j++)

              if(i==j) I[i][j] = 1;

              else I[i][j]=0;







// Ricordarsi di aggiungere un controllo sul determinante: se è = 0, la matrice non si può invertire.





                                           // Riempimento matrice

  cout<<endl<<"Riempi la matrice"<<endl;

  for(int i=0;i<n;i++) 

    for(int j=0;j<n;j++)

    {

      cout<<"Elem " << i+1 << ", " << j+1 << ": "; 

      cin>>A[i][j];

    } cout<<endl;







                                           // Verifica riempimento

      cout<< "Questa è la matrice che hai inserito: "<<endl;

      for(int i=0;i<n;i++)

      {

       for(int j=0;j<n;j++)

       cout<<A[i][j] << "\t";

       cout<<endl;  

      } cout<<endl;







 //Costruzione della matrice [A|I] come metodo di riduzione

 double **B;

 B=new double*[n];

 for(int i=0;i<n;i++) 

  B[i]=new double[2*n];



 for(int i=0;i<n;i++)         // Copio la matrice A in B (che è larga il doppio, quindi 2n)

   for(int j=0;j<n;j++)

     B[i][j]=A[i][j];



 int k=0;                     // Copio la matrice I nella seconda parte di B

 for(int i=0;i<n;i++) 

 {

   for(int j=n;j<2*n;j++,k++)

     B[i][j]=I[i][k];

   k=0;

 }



//-------------------------------------------------------------------------------------------------

//-------------------------------------------------------------------------------------------------

 //Eliminazione sotto la diagonale principale

 double *tmp; tmp=new double[2*n];

 for(int j=0;j<n-1;j++)

   for(int i=j+1;i<n;i++)

     if(B[i][j]!=0) {

       double mol=B[i][j]/B[j][j];

       for(int k=0;k<2*n;k++) tmp[k]=mol*B[j][k];

       for(int k=0;k<2*n;k++) B[i][k]-=tmp[k];

     }





 //Eliminazione sopra la diagonale principale

 for(int j=n-1;j>0;j--)

   for(int i=j-1;i>=0;i--)

     if(B[i][j]!=0) {

       double mol=B[i][j]/B[j][j];

       for(int k=0;k<2*n;k++) tmp[k]=mol*B[j][k];

       for(int k=0;k<2*n;k++) B[i][k]-=tmp[k];

     }







//_________________________________________________________________________________________________

//Calcolo determinante

 int Det,d;

 Det=1;

 for(int s=0; s<n-1; s++)

  {

     if (s==0)

     {

      d=B[s][s]*B[s+1][s+1]; 

      Det=d;      

     }

         else

         {

           d=Det*B[s+1][s+1];

           Det=d;

         }

  }

 cout<<"Determinante: "<<Det<<endl;



 if(Det!=0)   //Controllo che il determinante sia !=0

 {

//_________________________________________________________________________________________________

        

//Stampa della matrice ridotta

 cout<< "Questa è la matrice ridotta: "<<endl;

      for(int i=0;i<n;i++)

      {

       for(int j=0;j<n;j++)

       cout<<B[i][j] << "\t";

       cout<<endl;  

      } cout<<endl;



 //Ultimo step per ottenere la matrice [I|A]

 for(int i=0;i<n;i++) 

   if(B[i][i]!=1) {

     double mol=B[i][i];

     for(int k=0;k<2*n;k++) 

       B[i][k]=B[i][k]/mol;

   }



//-------------------------------------------------------------------------------------------------

//-------------------------------------------------------------------------------------------------

 

 //Copia dell'inversa ottenuta

 double** Inv;

 Inv=new double*[n];

 for(int i=0;i<n;i++) 

  Inv[i]=new double[n];

 k=0;

 for(int i=0;i<n;i++) 

 {

   for(int j=n;j<2*n;j++,k++)

     Inv[i][k]=B[i][j];

   k=0;

 }





 //Scrittura della matrice Inversa

 cout<< "Matrice inversa: "<<endl;

 for(int i=0;i<n;i++)

 {

   for(int j=0;j<n;j++)

     cout<<Inv[i][j]<< "\t";

   cout<<endl;  

 } cout<<endl;

                                          }

                                          else

                                            cout<<"La matrice non si può invertire!!! "<<endl;









//Deallocazione della memoria

for(int i=0;i<n;i++) {delete I[i];delete A[i];}

delete I;

delete A;

for(int i=0;i<n;i++) delete B[i]; 

delete B;

delete tmp;





                                        

                                        cout<<"Vuoi invertire un'altra matrice? (y/n) "<<endl;

                                        cin>>p; 

                                        cout<<endl<<endl;

                                        cout<<"-----------------------------------------------------"<<endl<<endl;

                                        } //chiusura do iniziale

                                        while (p=='y');

                                        



}