Problema de memória no cálculo de determinante com polinômios

[Gutovookrj]

tenho uma struct:

typedef struct {
  double s[MAX_GRAU];
  unsigned short grau;
} polinomio;

E a minha função que dá problema de memória:

unsigned short calcDet(polinomio **matriz, unsigned short ordem, double det[MAX_GRAU]){

  double d[MAX_GRAU];
  unsigned short i,j,k,a,b,c, grau, graux;
   

  for (i=0; i<MAX_GRAU; i++)
    det[i]=0;
  grau=0;

   
  if (ordem==1)
  {
    for (k=0; k<=matriz[1][1].grau; k++)
      det[k]=matriz[1][1].s[k]; 
    grau=matriz[1][1].grau;
  }
  else if (ordem==2)
  { 
    for(i=0;(i<=matriz[1][1].grau || i<=matriz[1][2].grau); i++)
      for (j=0;(j<=matriz[2][1].grau || j<=matriz[2][2].grau); j++)
      {
        det[i+j]+= ((matriz[1][1].s[i])*(matriz[2][2].s[j]) - (matriz[1][2].s[i])*(matriz[2][1].s[j]));
      }        
    if ((matriz[1][1].grau + matriz[2][2].grau)>(matriz[1][2].grau + matriz[2][1].grau))
      grau = matriz[1][1].grau + matriz[2][2].grau;
    else (grau = matriz[1][2].grau + matriz[2][1].grau);
    while (grau!=0 && det[grau]==0) grau--;
  }
  else 
  {
    for (a=1; a<=ordem; a++) //coluna onde se encontra o cofator
    {
       auxiliar = (polinomio **)malloc((ordem+1)*sizeof(polinomio *));
       for (i=0; i<=ordem; i++)
         auxiliar[i] = (polinomio *)malloc((ordem+1)*sizeof(polinomio));
       for(i=2,c=1; i<=ordem; i++)
       {  //pula a primeira linha da matriz, pois vai ser a default para uso dos cofatores
       for (j=1,b=1; j<=ordem;j++)
          {
          if (a!=j || j!=ordem)
          {
                 if(a==j) j++;
                 auxiliar[c][b]=matriz[i][j];
              }  
          b++;
          }                
          c++;
        }
    graux = calcDet(auxiliar,ordem-1,d);

    for(i=0;i<=matriz[1][a].grau; i++)
      for (j=0;j<=graux; j++)
         {
        det[i+j]+=(a%2 + a%2 - 1)*(matriz[1][a].s[i])*(d[j]);    //considerando que o cofator sempre está na linha 1
      }
       if (grau<((i-1)+(j-1)))
     grau = (i-1)+(j-1);
  
       for (i=0; i<=ordem; i++)
         free(auxiliar[i]);
       free(auxiliar);
    }  
  }
  return (grau);
}

--

O algoritmo funciona pra 2x2, 3x3, 4x4, 5x5...

Pra 6x6 o programa trava... Só funciona se eu aumentar a dimensão do malloc do auxiliar

E conforme vou aumentando, o programa vai tolerando matrizes maiores (não entendo por quê).

Só que tem um limite, acho que com matrizes 12x12, quando passo a aumentar a dimensão da auxiliar, o programa trava mais rápido.

Teve uma vez que o programa chegou a usar 790MB de RAM.

Tenho um tratamento para ele fazer menos cálculos, reduzindo o tempo de processamento, mas não pus aqui pois não era minha dúvida.

Alguém pode me ajudar?

Agradeço antecipadamente :)

[Gutovookrj]

Nevermind, já consegui resolver.

Achei um jeito mais prático de calcular o determinante, agora se consome 1MB de memória é muito, mesmo em matrizes 20x20.