// Wyznacznik wg rekurencyjnego rozwinięcia Laplace'a
// Data: 8.02.2011
// (C)2020 mgr Jerzy Wałaszek
//---------------------------------------------------

program prg;

// deklaracje typów dynamicznych
type

  NInt  = array of integer; // typ wektora kolumn
  NReal = array of double;  // typ wierszy
  MReal = array of NReal;   // typ typ tablicy dynamicznej

// Rekurencyjna funkcja obliczająca
// rozwinięcie Laplace'a
//---------------------------------
function det(n, w : integer;
             var WK : NInt;
             var A : MReal)
             : double;
var
  i, j, k, m : integer;
  s       : double;
  KK      : NInt;
begin
  if n=1 then // sprawdzamy warunek zakończenia rekurencji
    det := A[w][WK[0]]; // macierz 1x1, wyznacznik
                        // równy elementowi
  else
  begin
    SetLength(KK, n-1); // tworzymy dynamiczny wektor kolumn
    s := 0; // zerujemy wartość rozwinięcia
    m := 1; // początkowy mnożnik
    for i := 0 to n-1 do // pętla obliczająca rozwinięcie
    begin
      k := 0; // tworzymy wektor kolumn dla rekurencji
      for j := 0 to n-2 do // ma on o 1 kolumnę mniej niż WK
      begin
        if k = i then inc(k); // pomijamy bieżącą kolumnę
        KK[j] := WK[k];       // pozostałe kolumny przenosimy
                              // do KK
        inc(k);
      end;
      s := s+m*A[w][WK[i]]*det(n-1, w+1, KK, A);
      m := -m; // kolejny mnożnik
    end;
    SetLength(KK, 0); // usuwamy zbędną już tablicę dynamiczną
    det := s; // ustalamy wartość funkcji
  end;
end;

//*** PROGRAM GŁÓWNY ***
//----------------------

var
  n, i, j : integer; // stopień macierzy
  WK    : NInt;    // wektor kolumn
  A     : MReal;   // macierz

begin
  read(n);  // odczytujemy stopień macierzy
  SetLength(A, n); // tworzymy macierz wskaźników
  for i := 0 to n-1 do
  begin
    SetLength(A[i], n); // tworzymy wiersz
    for j := 0 to n-1 do // czytamy wiersz macierzy
      read(A[i][j]);
  end;
  SetLength(WK, n); // tworzymy wiersz kolumn
  for i := 0 to n-1 do // wypełniamy go numerami kolumn
    WK[i] := i;
  writeln;
  writeln(det(n, 0, WK, A):0:4); // wyznacznik
  SetLength(WK, 0); // usuwamy tablice dynamiczne
  for i := 0 to n-1 do SetLength(A[i], 0);
  SetLength(A, 0);
end.

// Wyznacznik wg rekurencyjnego
// rozwinięcia Laplace'a
// Data: 8.02.2011
// (C)2020 mgr Jerzy Wałaszek
//-----------------------------

#include <iostream>
#include <iomanip>

using namespace std;

// Rekurencyjna funkcja obliczająca
// rozwinięcie Laplace'a
//---------------------------------
double det(int n, 
           int w, 
           int * WK, 
           double ** A)
{
  int i, j, k, m, * KK;
  double s;

  if(n == 1) // sprawdzamy warunek zakończenia rekurencji
    return A[w][WK[0]]; // macierz 1x1, 
                        // wyznacznik równy elementowi
  else
  {
    KK = new int[n-1]; // tworzymy dynamiczny wektor kolumn
    s = 0; // zerujemy wartość rozwinięcia
    m = 1; // początkowy mnożnik

    for(i = 0; i < n; i++) // pętla obliczająca rozwinięcie
    {
      k = 0; // tworzymy wektor kolumn dla rekurencji
      for(j = 0; j < n-1; j++) // ma on o 1 kolumnę mniej niż WK
      {
        if(k == i) k++;  // pomijamy bieżącą kolumnę
        KK[j] = WK[k++]; // pozostałe kolumny przenosimy do KK
      }
      s += m*A[w][WK[i]]*det(n-1, w+1, KK, A);
      m = -m; // kolejny mnożnik
    }
    delete [] KK; // usuwamy zbędną już tablicę dynamiczną
    return s; // ustalamy wartość funkcji
  }
}

//*** PROGRAM GŁÓWNY ***
//----------------------

int main()
{
  int       n, i, j; // stopień macierzy
  int     * WK;    // wektor kolumn
  double ** A;     // macierz

  cout << fixed << setprecision(4);
  cin >> n; // odczytujemy stopień macierzy
  A = new double * [n]; // tworzymy macierz wskaźników
  for(i = 0; i < n; i++)
  {
    A[i] = new double[n]; // tworzymy wiersz
    for(j = 0; j < n; j++)
      cin >> A[i][j]; // czytamy wiersz macierzy
  }
  WK = new int[n]; // tworzymy wiersz kolumn
  for(i = 0; i < n; i++) // wypełniamy go numerami kolumn
    WK[i] = i;
  cout << endl;
  cout << det(n, 0, WK, A) << endl; // wyznacznik
  delete [] WK; // usuwamy tablice dynamiczne
  for(i = 0; i < n; i++)
    delete [] A[i];
  delete [] A;
}

' Wyznacznik wg rekurencyjnego
' rozwinięcia Laplace'a
' Data: 8.02.2011
' (C)2020 mgr Jerzy Wałaszek
'-----------------------------

' Rekurencyjna funkcja obliczająca
' rozwinięcie Laplace'a
'---------------------------------
Function det(n As Integer, _
             w As Integer, _
             WK As Integer Ptr, _
             A As Double Ptr Ptr) _
             As Double
  Dim As Integer i, j, k, m
  Dim As Double s
  Dim KK As Integer Ptr

  If n = 1 Then ' sprawdzamy warunek zakończenia rekurencji
    return A[w][WK[0]] ' macierz 1 x 1, 
    ' wyznacznik równy elementowi

  Else

    KK = New Integer [n-1]

    s = 0 ' zerujemy wartość rozwinięcia
    m = 1 ' początkowy mnożnik

    For i = 0 To n-1 ' pętla obliczająca rozwinięcie

      k = 0 ' tworzymy wektor kolumn dla rekurencji

      For j = 0 To n-2 ' ma on o 1 kolumnę mniej niż WK
        If k = i Then k += 1 ' pomijamy bieżącą kolumnę
        KK[j] = WK[k] ' pozostałe kolumny przenosimy do KK
        k += 1
      Next

      s += m*A[w][WK[i]]*det(n-1, w+1, KK, A)

      m = -m ' kolejny mnożnik

    Next

    det = s ' wartość funkcji

    Delete [] KK

  End If

End Function

Dim As Integer n, i, j ' stopień macierzy
 
Open Cons For Input As #1
 
Input #1, n ' odczytujemy stopień macierzy

Dim A As Double Ptr Ptr ' tworzymy macierz dynamiczną

A = New Double Ptr [n]

For i = 0 To n-1
  A[i] = New Double[n]
  For j = 0 To n-1 ' czytamy wiersz macierzy
    Input #1, A[i][j]
  Next
Next

Close #1

Dim WK As Integer Ptr ' tworzymy wiersz kolumn

WK = New Integer[n]

For i = 0 To n-1 ' wypełniamy go numerami kolumn
  WK[i] = i
Next

Print det(n, 0, WK, A) ' wyznacznik

For i = 0 To n-1 ' usuwamy tablice dynamiczne
  Delete [] A[i]
Next
Delete [] A
Delete [] WK

End

# Wyznacznik wg rekurencyjnego
# rozwinięcia Laplace'a
# Data 20.04.2024
# (C)2024 mgr Jerzy Wałaszek
#-----------------------------


# Rekurencyjna funkcja obliczająca
# rozwinięcie Laplace'a
#---------------------------------
def det(n, w, wk, a):
    # sprawdzamy warunek zakończenia rekurencji
    if n == 1:
        # macierz 1 x 1
        # wyznacznik równy elementowi
        return a[w][wk[0]]
    else:
        # tworzymy dynamiczny wektor kolumn
        kk = [0] * (n-1)
        # zerujemy wartość rozwinięcia
        s = 0
        m = 1 # początkowy mnożnik
        # pętla obliczająca rozwinięcie
        for i in range(n):
            # tworzymy wektor kolumn dla rekurencji
            k = 0
            # ma on o 1 kolumnę mniej niż WK
            for j in range(n-1):
                if k == i:
                    # pomijamy bieżącą kolumnę
                    k += 1
                # pozostałe kolumny przenosimy do KK
                kk[j] = wk[k]
                k += 1
            s += m*a[w][wk[i]]*det(n-1, w+1, kk, a)
            m = -m # kolejny mnożnik
        # usuwamy zbędną już tablicę dynamiczną
        return s # wartość funkcji


# *** PROGRAM GŁÓWNY ***
# ----------------------

n = int(input()) # odczytujemy stopień macierzy
a = [] # odczytujemy macierz
for i in range(n):
    arr = input().split()
    arr = [float(arr[j]) for j in range(n)]
    a.append(arr)
wk = [i for i in range(n)] # tworzymy wiersz kolumn
print()
print(det(n, 0, wk, a)) # wyznacznik
# usuwamy tablice dynamiczne
a = None
wk = None