Dělení matice – C / C++ – Fórum – Programujte.com

Dobrý den,

mám vytvořit program, který bude pro matici

| 1 2 3 4 5 |

| 6 7 8 9 0 |

| 2 3 4 5 1 |

| 7 8 9 0 6 |

| 5 3 2 1 4 |

počítat její hodnotu a to takto:

f(M) = 1*f(M1) + 7*f(M2) + 4*f(M3) + 0*f(M4) + 4*f(M5)
 v případě, že matice bude 0x0, nebo 1x1 bude rekurze vracet 0, pokud 2x2, tak hodnotu prvků na hlavní-vedlejší diagonále.

Můj kód vypadá takto:

int main()
{
    int n;
    printf("Zadej rozmer matice:");
    scanf("%d",&n);
//osetreni vstupu
    if ( n < 0 )
    {
        printf("Spatne zadany rozmer.");
        return -1;
    }
    int mat[n][n];
    int p;

    nullMat(n,mat);	//nulovani matice	
    scanMat(n,mat);	//nacitani matice
    //print(n,mat);

    //volani rekurzivni funkce
    printf("Funkce ma hodnotu: %d\n",rekurze(n,mat));


    return 0;
}

Funkce pro 2x2:

int dvaMat(int n, int mat[n][n])
{
    int soucinh = 1;
    int soucinv = 1;
    for( int i = (n-2); i < n; i++)
    {
        for( int j = (n-2); j < n; j++)
        {

            if( i == j) soucinh *= mat[i][j];
            if( (i == 1 && j == 0) || (i == 0 && j == 1))soucinv *=mat[i][j];
        }
    }

    return (soucinh-soucinv);

}

A funkce rekurzivni:

int rekurze(int n, int mat[n][n])
{
    int soucin = 0;
    if( n <= 1) return 0;
    if( n == 2) return dvaMat(n,mat);

    for( int i = 0; i < n; i++)
    {
        int subMat[n-1][n-1];
        for(int k = 0; k < n; k++)
        {
            for(int j = 0; j < n; j++)
            {
                subMat[k][j] = mat[k+1][j+1];

            }
        }
        soucin += mat[i][i] * rekurze((n-k-1), subMat);

    }
    return soucin;
}

Bohužel mi tento algoritmus funguje pro matice 3x3, kdy je jen jedno "dělení" submatice, ale pro větší už nepočítá správně, nedaří se mi nějak uchovat výsledek rekurzivního součtu matice n-1.

Poradili byste? Děkuji

#1 Hanule

1) Ani z popisu ulohy, ani z kodu neni jasne, co "to ma delat".

2) Tohle v C/C++ rozhodne nefunguje:

int n;
scanf("%d", &n);

int mat[n][n]; /* <---- neni mi jasne, co tohle ve skutecnosti dela, ale urcite ne to, co bylo pravdepodobne zamysleno */

Pro zacatek bych doporucil bud naucit se neco o dynamicke alokaci {jedno/vice}-rozmernych poli, pripade deklarovat matici s nejakym dostatecne velkym "N_max".

#2 paya
Má to vytvořit pole o velikosti n. Dynamická alokace mě nenapadla, já si ale myslím, že tam budu mít chybu někde v té rekurzivní funkci, respektive úplně špatně ten algoritmus.

Má to dělal toto:
Pre matice rozmeru 1 x 1 alebo 0 x 0: f(M) = 0

Pre matice romzeru 2 x 2: f(M) = M[0][0] * M[1][1] - M[0][1]*M[1][0], tj. nasobok prvkov na hlavnej diagonale minus nasobok prvkov na vedlajsej diagonale

Pre hocijaky iny rozmer: f(M) = sucet jednotlivych prvkov na hlavnej diagonale vynasobeny (kazdy jeden diagonalny prvok osobitne) hodnotou funkcie f pre stvorcovu maticu zo zvysnych prvkov napravo a dole (bez aktualneho riadku/stlpca matice) od daneho diagonalneho prvku
 

#3 Hanule
...Dynamická alokace mě nenapadla,...

To by mela, protoze v C kreace typu

int n;
scanf("%d", &n);
int mat[n][n];

dvojrozmerne pole n*n nealokuje.

#4 paya
Ja si myslím, že alokuje. Staticky. Akurát si treba dať pozor aby n nebolo moc veľké, pretože sa nedá ustrážiť či je dostatok miesta na zásobníku. No pre nejaké malé hodnoty n nie je problém takto vytvoriť dočasnú maticu.

Schválne si to skús:  gcc -std=c99 -pedantic -Wall -Wextra -o 2d-static-alloc 2d-static-alloc.c

#include <stdlib.h>
#include <stdio.h>


int main(void) {
  int n;
  scanf("%d", &n);
  int mat[n][n];

  for(int i = 0; i < n; ++i) {
    for(int j = 0; j < n; ++j) {
      printf("%d ", mat[i][j]);
    }
    putchar('\n');
  }

  return EXIT_SUCCESS;
}

#5 m->29

No toto mozne je, ale neni to uplne standardni a IMHO spolehat se na toto zpusobi vic bugu nez uzitku.