Submission #2117233

---

Source Code Expand

#include <iomanip>
#include <iostream>

using namespace std;

template<int mod>
class Modulo {
  public:
    constexpr Modulo(): num(0) {}
    constexpr Modulo(int n): num(n % mod) {}
    constexpr Modulo(Modulo const &) = default;
    constexpr int data() const { return num; }
  private:
    int num;
};

template<int mod>
constexpr Modulo<mod> operator+(Modulo<mod> a, Modulo<mod> b) {
  return Modulo<mod>(a.data() + b.data());
}

template<int mod>
constexpr Modulo<mod> operator-(Modulo<mod> a, Modulo<mod> b) {
  return Modulo<mod>(mod + a.data() - b.data());
}

template<int mod>
constexpr Modulo<mod> operator*(Modulo<mod> a, Modulo<mod> b) {
  long long n = ((long long)a.data()) * ((long long)b.data());
  return Modulo<mod>(n % mod);
}

template<int mod>
constexpr Modulo<mod> pow(Modulo<mod> a, int n) {
  if (n == 0) { return Modulo<mod>(1); }
  Modulo<mod> res = pow(a * a, n / 2);
  if (n & 1) { res = res * a; }
  return res;
}
template<int mod>
constexpr Modulo<mod> inv(Modulo<mod> a) {
  return pow(a, mod - 2 );
}

template<int mod>
constexpr Modulo<mod> operator/(Modulo<mod> a, Modulo<mod> b) {
  return a * inv(b);
}

template<int mod, int size>
struct Factorial {
  using Mod = Modulo<mod>;
  Mod fact[size];
  Mod invfact[size];
  constexpr Factorial(): fact(), invfact() {
    fact[0] = 1;
    invfact[0] = 1;
    for (int i = 1; i < size; ++i) {
      fact[i] = Mod(i) * fact[i-1];
      invfact[i] = Mod(1) / fact[i];
    }
  }
};

constexpr int mod = 1e9 + 7;
constexpr int FMAX = 1000;
using Mod = Modulo<mod>;
constexpr auto fact = Factorial<mod, FMAX>();

Mod solve(int r, int c, int x, int y, int d, int l) {
  Mod ans = 1;
  ans = ans * fact.fact[x*y];
  ans = ans / fact.fact[d];
  ans = ans / fact.fact[l];
  ans = ans / fact.fact[x*y-(d+l)];
  ans = ans * Mod(r+1-x);
  ans = ans * Mod(c+1-y);
  return ans;
}

int main() {
  int R, C, X, Y, D, L;
  cin >> R >> C >> X >> Y >> D >> L;
  cout << solve(R, C, X, Y, D, L).data() << endl;
  return 0;
}

Submission Info

Judge Result