Language: C++

#include <algorithm>
#include <array>
#include <cassert>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#define FOR(i,a,b) for (int i=(a),for_##i##_max=(b);i<=(for_##i##_max);++i)
#define RFOR(i,a,b) for (int i=(a),rfor_##i##_min=(b);i>=(rfor_##i##_min);--i)
#define REP(i,n) for (int i=0,rep_##i##_len=(n);i<(rep_##i##_len);++i)
#define RREP(i,n) for (int i=(n)-1;i>=0;--i)

namespace { // Basics

template<typename T>
void chmin(T &x, T y) {
  x = std::min(x, y);
}

template<typename T>
void chmax(T &x, T y) {
  x = std::max(x, y);
}

template<typename T>
__attribute__((unused))
const auto minimum = static_cast<T const &(*)(T const &, T const &)>(std::min);

template<typename T>
__attribute__((unused))
const auto maximum = static_cast<T const &(*)(T const &, T const &)>(std::max);

template<typename T>
int cmp3(T lhs, T rhs) { return (lhs == rhs) ? 0 : (lhs > rhs) ? 1 : -1; }

template<typename T>
__attribute__((unused))
T constexpr infty = std::numeric_limits<T>::max / 3;
template<>
__attribute__((unused))
auto constexpr infty<int> = 1'100'100'100;
template<>
__attribute__((unused))
auto constexpr infty<long long int> = 100'500'400'300'200'100LL;

using lli = long long int;
using ld = long double;

} // namespace
namespace  { // Mod

template<int mod>
class modulo {
  public:
    constexpr modulo(): num(0) {}
    constexpr modulo(int n): num(n >= 0 ? n%mod : mod-((-n)%mod)) {}
    constexpr modulo(modulo const &) = default;
    constexpr int data() const { return num; }
    constexpr modulo &operator+=(modulo other) {
      num = (num + other.num) % mod;
      return *this;
    }
    constexpr modulo &operator-=(modulo other) {
      num = (num + mod - other.num) % mod;
      return *this;
    }
    constexpr modulo &operator*=(modulo other) {
      long long n = ((long long)num) * ((long long)other.num);
      num = n % mod;
      return *this;
    }
    constexpr modulo &operator/=(modulo other) {
      *this *= other.inverse();
      return *this;
    }
    constexpr static modulo pow(modulo a, int n, modulo res) {
      if (n == 0) { return res; }
      return pow(a*a, n/2, (n&1)?(res*a):res);
    }
    constexpr modulo inverse() const {
      return pow(*this, mod-2, modulo(1));
    }
  private:
    int num;
};

template<int mod>
constexpr modulo<mod> const operator+(modulo<mod> a, modulo<mod> b) {
  a += b;
  return a;
}

template<int mod>
constexpr modulo<mod> const operator-(modulo<mod> a, modulo<mod> b) {
  a -= b;
  return a;
}

template<int mod>
constexpr modulo<mod> const operator*(modulo<mod> a, modulo<mod> b) {
  a *= b;
  return a;
}

template<int mod>
constexpr modulo<mod> const pow(modulo<mod> a, int n) {
  return modulo<mod>::pow(a, n, 1);
}

template<int mod>
constexpr modulo<mod> const operator/(modulo<mod> a, modulo<mod> b) {
  a /= b;
  return a;
}

template<int mod, int size>
struct factorial {
  using Mod = modulo<mod>;
  Mod fact[size];
  Mod invfact[size];
  constexpr factorial(): fact(), invfact() {
    fact[0] = 1;
    for (int i = 1; i < size; ++i) {
      fact[i] = Mod(i) * fact[i-1];
    }
    invfact[size-1] = fact[size-1].inverse();
    for (int i = size - 1; i > 0; --i) {
      invfact[i-1] = invfact[i] * Mod(i);
    }
  }
  Mod const comb(int n, int k) const {
    assert(k <= n && n < size);
    return fact[n] * invfact[k] * invfact[n-k];
  }
};

} // namespace

template <size_t W>
bool next_combination(size_t n, size_t k, std::bitset<W> &S) {
  if ((S >> (n-k)).count() == k) { return false; }
  auto const s = S.to_ullong(), x = s & -s, y = s + x;
  S = std::bitset<W>((((s & ~y) / x) >> 1) | y);
  return true;
}

using namespace std;

using Mod = modulo<1'000'000'007>;

void solve(int N, vector<vector<int>> const &As) {
  int const nstates = 1 << N;
  vector<Mod> dp(nstates, 0);
  dp[0] = 1;
  REP(n, N) {
    std::bitset<32> S = (1 << n) - 1;
    do {
      REP(c, N) {
        auto const s = S.to_ullong();
        if (As[n][c] && !S[c]) { dp[s|(1<<c)] += dp[s]; }
      }
    } while (next_combination(N, n, S));
  }
  cout << dp[nstates-1].data() << endl;
}

int main() {
  int N; cin >> N;
  vector<vector<int>> As(N, vector<int>(N, 0));
  REP(i, N) REP(j, N) {
    cin >> As[i][j];
  }
  solve(N, As);
  return 0;
}


Compiler output:
a.cc:148:43: error: 'std::bitset' has not been declared
  148 | bool next_combination(size_t n, size_t k, std::bitset<W> &S) {
      |                                           ^~~
a.cc:148:54: error: expected ',' or '...' before '<' token
  148 | bool next_combination(size_t n, size_t k, std::bitset<W> &S) {
      |                                                      ^
a.cc: In function 'bool next_combination(size_t, size_t, int)':
a.cc:149:8: error: 'S' was not declared in this scope
  149 |   if ((S >> (n-k)).count() == k) { return false; }
      |        ^
a.cc:150:18: error: 'S' was not declared in this scope
  150 |   auto const s = S.to_ullong(), x = s & -s, y = s + x;
      |                  ^
a.cc:151:12: error: 'bitset' is not a member of 'std'
  151 |   S = std::bitset<W>((((s & ~y) / x) >> 1) | y);
      |            ^~~~~~
a.cc:15:1: note: 'std::bitset' is defined in header '<bitset>'; this is probably fixable by adding '#include <bitset>'
   14 | #include <utility>
  +++ |+#include <bitset>
   15 | #include <vector>
a.cc:151:30: error: 'y' was not declared in this scope
  151 |   S = std::bitset<W>((((s & ~y) / x) >> 1) | y);
      |                              ^
a.cc:151:35: error: 'x' was not declared in this scope
  151 |   S = std::bitset<W>((((s & ~y) / x) >> 1) | y);
      |                                   ^
a.cc: In function 'void solve(int, const std::vector<std::vector<int> >&)':
a.cc:164:10: error: 'bitset' is not a member of 'std'
  164 |     std::bitset<32> S = (1 << n) - 1;
      |          ^~~~~~
a.cc:164:10: note: 'std::bitset' is defined in header '<bitset>'; this is probably fixable by adding '#include <bitset>'
a.cc:164:21: error: 'S' was not declared in this scope
  164 |     std::bitset<32> S = (1 << n) - 1;
      |                     ^