#include <iostream>
#include <algorithm>
#include <vector>
#include <cassert>
#include <chrono>
#include <set>
#include <unordered_set>
#include <unordered_map>
using namespace std;


namespace gp
{

unsigned long long quick_power(unsigned long long a, unsigned long long power, unsigned long long modulo_n)
{
  unsigned long long result = 1;
  unsigned long long podstawa = a;
  while (power > 0)
  {
    if ((power & 1) == 0)
    {
      podstawa = (podstawa * podstawa) % modulo_n;
      power >>= 1;
    }
    else
    {
      result *= podstawa;
      result %= modulo_n;
      podstawa = (podstawa * podstawa) % modulo_n;
      power >>= 1;
    }
  }
  return result;
}

class Liczba
{
  unsigned long long liczba;
public:
  constexpr inline static unsigned long long MODULO_N = 1000000007;
  Liczba(unsigned long long liczbaArg);
  Liczba operator +(Liczba const& second) const;
  Liczba operator -(Liczba const& second) const;
  Liczba operator *(Liczba const& second) const;
  Liczba operator /(Liczba const& second) const;
  Liczba operator %(Liczba const& second) const;
  friend std::ostream& operator << (std::ostream& stream, Liczba const permutacja);
};

Liczba::Liczba(unsigned long long liczbaArg) :
  liczba(liczbaArg)
{
}

Liczba Liczba::operator +(Liczba const& second) const
{
  unsigned long long result = (liczba + second.liczba) % MODULO_N;
  return {result};
}

Liczba Liczba::operator -(Liczba const& second) const
{
  unsigned long long result = (liczba + (MODULO_N - second.liczba)) % MODULO_N;
  return { result };
}

Liczba Liczba::operator *(Liczba const& second) const
{
  unsigned long long result = (liczba * second.liczba) % MODULO_N;
  return { result };
}

Liczba Liczba::operator /(Liczba const& second) const
{
  unsigned long long odwrotnosc = quick_power(second.liczba, MODULO_N-2, MODULO_N); // fermat theorem
  unsigned long long result = (liczba * odwrotnosc) % MODULO_N;
  return {result};
}

Liczba Liczba::operator %(Liczba const& second) const
{
  return *this - ((*this / second) * second);
}

std::ostream& operator << (std::ostream& stream, Liczba const liczba)
{
  stream << liczba.liczba;
  return stream;
}


class Ulamek
{
public:
  Liczba licznik;
  Liczba mianownik;
  Ulamek(Liczba licznikArg, Liczba mianownikArg);
  Ulamek operator +(Ulamek const& second) const;
  Ulamek operator *(Ulamek const& second) const;
};

Ulamek::Ulamek(Liczba licznikArg, Liczba mianownikArg):
  licznik(licznikArg),
  mianownik(mianownikArg)
{
}

Ulamek Ulamek::operator +(Ulamek const& second) const
{
  Liczba resultMianownik = mianownik * second.mianownik;
  Liczba resultLicznik = licznik * second.mianownik + second.licznik * mianownik;
  return Ulamek(resultLicznik, resultMianownik);
}

Ulamek Ulamek::operator *(Ulamek const& second) const
{
  Liczba resultMianownik = mianownik * second.mianownik;
  Liczba resultLicznik = licznik * second.licznik;
  return Ulamek(resultLicznik, resultMianownik);
}

struct pair_hash {
  std::size_t operator () (const std::pair<int, int>& p) const {
    return p.first * 10000 + p.second;
  }
};

struct Wierzcholek
{
  int pozycja1 = -1;
  int pozycja2 = -1;
  std::unordered_set<std::pair<int, int>, pair_hash> sasiedzi;
};

struct Graf
{
  std::unordered_map<std::pair<int,int>, Wierzcholek, pair_hash> wierzcholki;
};

struct Permutacja
{
  std::vector<int> pozycje;
};

Graf createGraf(std::vector<Permutacja> & permutacje)
{
  int n = permutacje[0].pozycje.size();
  Graf graf;
  for (int i = 0; i < n; ++i)
  {
    for (int j = 0; j < n; ++j)
    {
      if (i == j)
        continue;
      Wierzcholek w;
      w.pozycja1 = i;
      w.pozycja2 = j;
      graf.wierzcholki[std::make_pair(i, j)] = w;
    }
  }
  for (int i = 0; i < permutacje.size(); ++i)
  {
    auto & permutacja = permutacje[i];
    //std::cerr << "permutacja i: " << i << "\n";
    for (int p1 = 0; p1 < n; ++p1)
    {
      for (int p2 = 0; p2 < n; ++p2)
      {
        if (p1 == p2)
          continue;
        graf.wierzcholki[std::make_pair<>(p1, p2)].sasiedzi.insert(std::make_pair<>(permutacja.pozycje[p1], permutacja.pozycje[p2]));
        graf.wierzcholki[std::make_pair<>(p2, p1)].sasiedzi.insert(std::make_pair<>(permutacja.pozycje[p2], permutacja.pozycje[p1]));
      }
    }
  }
  return graf;
}

struct SpojnaSkladowa
{
  std::unordered_set<std::pair<int, int>, pair_hash>  wierzcholki;
};

std::vector<SpojnaSkladowa> wyliczSpojneSkladowe(Graf& graf)
{
  std::unordered_set<std::pair<int, int>, pair_hash> pozostale;
  for (auto [wierzcholek, sasiedz] : graf.wierzcholki)
    pozostale.insert(wierzcholek);
  std::vector<SpojnaSkladowa> result;
  while (pozostale.size() > 0)
  {
    SpojnaSkladowa skladowa;
    std::vector<std::pair<int, int>> dodane;
    dodane.push_back(*pozostale.begin());
    skladowa.wierzcholki.insert(*pozostale.begin());
    pozostale.erase(*pozostale.begin());
    int current = 0;
    while (current < dodane.size())
    {
      std::pair<int, int> wierzcholek = dodane[current];
      for (auto sasiad : graf.wierzcholki[wierzcholek].sasiedzi)
      {
        if (skladowa.wierzcholki.count(sasiad) == 0)
        {
          dodane.push_back(sasiad);
          skladowa.wierzcholki.insert(sasiad);
          pozostale.erase(sasiad);
        }
      }
      current++;
    }
    result.push_back(skladowa);
  }
  return result;
}

}//gp

using namespace gp;

int main()
{
  ios::sync_with_stdio(false);
  std::cin.tie(NULL);
  int n;
  int k;
  std::cin >> n >> k;
  std::vector<Permutacja> permutacje;
  for (int i = 0; i < k; ++i)
  {
    Permutacja permutacja;
    for (int j = 0; j < n; ++j)
    {
      int pozycja;
      std::cin >> pozycja;
      permutacja.pozycje.push_back(pozycja-1);
    }
    permutacje.push_back(permutacja);
  }

  Graf graf = createGraf(permutacje);
  std::vector<SpojnaSkladowa> spojneSkladowe = wyliczSpojneSkladowe(graf);
  double srednia = 0.0;
  Ulamek result(0, 1);
  for (SpojnaSkladowa& skladowa : spojneSkladowe)
  {
    int iloscInversji = 0;
    for (auto wierzcholek : skladowa.wierzcholki)
    {
      if (wierzcholek.first > wierzcholek.second)
        iloscInversji++;
    }
    int ilosc = skladowa.wierzcholki.size();
    Ulamek wklad((ilosc - iloscInversji) * iloscInversji, ilosc);
    result = result + wklad;
    srednia += (ilosc-iloscInversji) * ((double)iloscInversji / ilosc);
  }
  std::cout << (result.licznik / result.mianownik) << "";
  //std::cout << srednia << "\n";


  return 0;
}