Problem p00887 (C++) — buggy submission, verdict: Runtime Error

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;

const int mod = 2; // assert mod is prime

template <int M> struct Mint {
  int x;
  Mint() : x(0) {}
  Mint(int y) : x(y >= 0 ? y % M : M - (-y) % M) {}
  Mint &operator+=(const Mint &rhs) {
    if ((x += rhs.x) >= M)
      x -= M;
    return *this;
  }
  Mint &operator-=(const Mint &rhs) {
    if ((x += M - rhs.x) >= M)
      x -= M;
    return *this;
  }
  Mint &operator*=(const Mint &rhs) {
    x = 1LL * x * rhs.x % M;
    return *this;
  }
  Mint &operator/=(const Mint &rhs) {
    x = (1LL * x * rhs.inv().x) % M;
    return *this;
  }
  Mint operator-() const { return Mint(-x); }
  Mint operator+(const Mint &rhs) const { return Mint(*this) += rhs; }
  Mint operator-(const Mint &rhs) const { return Mint(*this) -= rhs; }
  Mint operator*(const Mint &rhs) const { return Mint(*this) *= rhs; }
  Mint operator/(const Mint &rhs) const { return Mint(*this) /= rhs; }
  bool operator<(const Mint &rhs) const { return x < rhs.x; }
  Mint inv() const {
    signed a = x, b = M, u = 1, v = 0, t;
    while (b) {
      t = a / b;
      a -= t * b;
      swap(a, b);
      u -= t * v;
      swap(u, v);
    }
    return Mint(u);
  }
  Mint pow(long long t) const {
    Mint e = *this, res = 1;
    for (; t; e *= e, t >>= 1)
      if (t & 1)
        res *= e;
    return res;
  }
};
template <int M> ostream &operator<<(ostream &os, const Mint<M> &rhs) {
  return os << rhs.x;
}
template <int M> istream &operator>>(istream &is, Mint<M> &rhs) {
  long long s;
  is >> s;
  rhs = Mint<M>(s);
  return is;
};

using mint = Mint<mod>;

using Array = vector<mint>;
using Matrix = vector<Array>;
const double eps = 1e-10;

void outMat(const Matrix &A) {
  int n = A.size(), m = A[0].size();
  for (int i = 0; i < n; i++) {
    for (int j = 0; j < m; j++) {
      cout << A[i][j] << " ";
    }
    cout << endl;
  }
  cout << endl;
}

Array GaussJordan(const Matrix &A, const Array &b) {
  int n = A.size();
  Matrix B(n, Array(n + 1));
  for (int i = 0; i < n; i++)
    for (int j = 0; j < n; j++)
      B[i][j] = A[i][j];
  for (int i = 0; i < n; i++)
    B[i][n] = b[i];
  for (int i = 0; i < n; i++) {
    int pivot = i;
    for (int j = i; j < n; j++) {
      if (B[j][i].x > B[pivot][i].x)
        pivot = j;
      // if(abs(B[j][i]) > abs(B[pivot][i])) pivot = j;
    }
    // outMat(B);
    swap(B[i], B[pivot]);
    // outMat(B);

    // if(abs(B[i][i]) < eps) return Array();
    for (int j = i + 1; j <= n; j++)
      B[i][j] /= B[i][i];
    for (int j = 0; j < n; j++) {
      if (i != j) {
        for (int k = i + 1; k <= n; k++)
          B[j][k] -= B[j][i] * B[i][k];
      }
    }
    // outMat(B);
  }

  // outMat(B);

  Array x(n);
  for (int i = 0; i < n; i++)
    x[i] = B[i][n];
  return x;
}

int b[25][25];

int main() {
  cin.tie(0);
  ios::sync_with_stdio(false);
#ifdef LOCAL
  std::ifstream in("in");
  std::cin.rdbuf(in.rdbuf());
#endif

  int m, n, d;
  while (cin >> m >> n >> d, m) {
    int N = n * m;
    for (int i = 0; i < n; i++) {
      for (int j = 0; j < m; j++) {
        cin >> b[i][j];
      }
    }

    Matrix A(N, Array(N));
    Array B(N);
    for (int i1 = 0; i1 < n; i1++) {
      for (int j1 = 0; j1 < m; j1++) {
        for (int i2 = 0; i2 < n; i2++) {
          for (int j2 = 0; j2 < m; j2++) {
            int D = abs(i1 - i2) + abs(j1 - j2);
            A[i1 * m + j1][i2 * m + j2] = (D == 0 || D == d);
          }
        }
        B[i1 * m + j1] = b[i1][j1];
      }
    }
    // outMat(A);
    auto X = GaussJordan(A, B);

    int ok = 1;
    for (int i = 0; i < N; i++) {
      mint k = 0;
      for (int j = 0; j < N; j++) {
        k += A[i][j] * X[j];
      }
      if (k.x != B[i].x) {
        ok = 0;
        break;
      }
    }

    cout << ok << endl;
  }
}

Error: 0

Fixed submission:

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;

const int mod = 2; // assert mod is prime

template <int M> struct Mint {
  int x;
  Mint() : x(0) {}
  Mint(int y) : x(y >= 0 ? y % M : M - (-y) % M) {}
  Mint &operator+=(const Mint &rhs) {
    if ((x += rhs.x) >= M)
      x -= M;
    return *this;
  }
  Mint &operator-=(const Mint &rhs) {
    if ((x += M - rhs.x) >= M)
      x -= M;
    return *this;
  }
  Mint &operator*=(const Mint &rhs) {
    x = 1LL * x * rhs.x % M;
    return *this;
  }
  Mint &operator/=(const Mint &rhs) {
    x = (1LL * x * rhs.inv().x) % M;
    return *this;
  }
  Mint operator-() const { return Mint(-x); }
  Mint operator+(const Mint &rhs) const { return Mint(*this) += rhs; }
  Mint operator-(const Mint &rhs) const { return Mint(*this) -= rhs; }
  Mint operator*(const Mint &rhs) const { return Mint(*this) *= rhs; }
  Mint operator/(const Mint &rhs) const { return Mint(*this) /= rhs; }
  bool operator<(const Mint &rhs) const { return x < rhs.x; }
  Mint inv() const {
    signed a = x, b = M, u = 1, v = 0, t;
    while (b) {
      t = a / b;
      a -= t * b;
      swap(a, b);
      u -= t * v;
      swap(u, v);
    }
    return Mint(u);
  }
  Mint pow(long long t) const {
    Mint e = *this, res = 1;
    for (; t; e *= e, t >>= 1)
      if (t & 1)
        res *= e;
    return res;
  }
};
template <int M> ostream &operator<<(ostream &os, const Mint<M> &rhs) {
  return os << rhs.x;
}
template <int M> istream &operator>>(istream &is, Mint<M> &rhs) {
  long long s;
  is >> s;
  rhs = Mint<M>(s);
  return is;
};

using mint = Mint<mod>;

using Array = vector<mint>;
using Matrix = vector<Array>;
const double eps = 1e-10;

void outMat(const Matrix &A) {
  int n = A.size(), m = A[0].size();
  for (int i = 0; i < n; i++) {
    for (int j = 0; j < m; j++) {
      cout << A[i][j] << " ";
    }
    cout << endl;
  }
  cout << endl;
}

Array GaussJordan(const Matrix &A, const Array &b) {
  int n = A.size();
  Matrix B(n, Array(n + 1));
  for (int i = 0; i < n; i++)
    for (int j = 0; j < n; j++)
      B[i][j] = A[i][j];
  for (int i = 0; i < n; i++)
    B[i][n] = b[i];
  for (int i = 0; i < n; i++) {
    int pivot = i;
    for (int j = i; j < n; j++) {
      if (B[j][i].x > B[pivot][i].x)
        pivot = j;
      // if(abs(B[j][i]) > abs(B[pivot][i])) pivot = j;
    }
    // outMat(B);
    swap(B[i], B[pivot]);
    // outMat(B);

    // if(abs(B[i][i]) < eps) return Array();
    for (int j = i + 1; j <= n; j++)
      B[i][j] /= B[i][i];
    for (int j = 0; j < n; j++) {
      if (i != j) {
        for (int k = i + 1; k <= n; k++)
          B[j][k] -= B[j][i] * B[i][k];
      }
    }
    // outMat(B);
  }

  // outMat(B);

  Array x(n);
  for (int i = 0; i < n; i++)
    x[i] = B[i][n];
  return x;
}

int b[25][25];

int main() {
  cin.tie(0);
  ios::sync_with_stdio(false);
#ifdef LOCAL
  std::ifstream in("in");
  std::cin.rdbuf(in.rdbuf());
#endif

  int m, n, d;
  while (cin >> m >> n >> d, m) {
    int N = n * m;
    for (int i = 0; i < n; i++) {
      for (int j = 0; j < m; j++) {
        cin >> b[i][j];
      }
    }

    Matrix A(N, Array(N));
    Array B(N);
    for (int i1 = 0; i1 < n; i1++) {
      for (int j1 = 0; j1 < m; j1++) {
        for (int i2 = 0; i2 < n; i2++) {
          for (int j2 = 0; j2 < m; j2++) {
            int D = abs(i1 - i2) + abs(j1 - j2);
            A[i1 * n + j1][i2 * n + j2] = (D == 0 || D == d);
          }
        }
        B[i1 * n + j1] = b[i1][j1];
      }
    }
    // outMat(A);
    auto X = GaussJordan(A, B);

    int ok = 1;
    for (int i = 0; i < N; i++) {
      mint k = 0;
      for (int j = 0; j < N; j++) {
        k += A[i][j] * X[j];
      }
      if (k.x != B[i].x) {
        ok = 0;
        break;
      }
    }

    cout << ok << endl;
  }
}