problem_id stringlengths 6 6 | language stringclasses 2 values | original_status stringclasses 3 values | original_src stringlengths 19 243k | changed_src stringlengths 19 243k | change stringclasses 3 values | i1 int64 0 8.44k | i2 int64 0 8.44k | j1 int64 0 8.44k | j2 int64 0 8.44k | error stringclasses 270 values | stderr stringlengths 0 226k |
|---|---|---|---|---|---|---|---|---|---|---|---|
p02782 | C++ | Runtime Error | #include <bits/stdc++.h>
#define pb push_back
#define int long long
#define It set<node>::iterator
#define endl '\n'
#define fastio \
ios::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL)
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const int maxn = 1e6 + 10;
const int inf = 0x3f3f3f3f;
const int mod = 1e9 + 7;
int r1, c1, r2, c2, ans;
int val[maxn], inv[maxn];
inline int qpow(int a, int x) {
int res = 1;
while (x) {
if (x & 1)
res = a * res % mod;
a = a * a % mod;
x >>= 1;
}
return res;
}
inline int Inv(int dat) { return qpow(dat, mod - 2); }
inline int calc(int a, int b) {
if (b == 0)
return 1;
return (val[a] * inv[b] % mod) * inv[a - b] % mod;
}
signed main() {
cin >> r1 >> c1 >> r2 >> c2;
val[1] = 1;
for (int i = 2; i <= r2 + c2 + 5; ++i)
val[i] = val[i - 1] * i % mod;
for (int i = 1; i <= r2 + c2 + 5; ++i)
inv[i] = Inv(val[i]);
// for(int i=1;i<=r2+c2+5;++i) cout<<inv[i]<<" ";
// cout<<endl;
for (int i = r1 + 1; i <= r2 + 1; ++i) {
ans = (ans + calc(i + c2, c2) % mod) % mod;
// cout<<i+c2<<" "<<c2<<" "<<calc(i+c2,c2)<<endl;
}
for (int i = r1 + 1; i <= r2 + 1; ++i) {
ans = (ans - calc(i + c1 - 1, c1 - 1) % mod + mod) % mod;
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define pb push_back
#define int long long
#define It set<node>::iterator
#define endl '\n'
#define fastio \
ios::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL)
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const int maxn = 3e6 + 10;
const int inf = 0x3f3f3f3f;
const int mod = 1e9 + 7;
int r1, c1, r2, c2, ans;
int val[maxn], inv[maxn];
inline int qpow(int a, int x) {
int res = 1;
while (x) {
if (x & 1)
res = a * res % mod;
a = a * a % mod;
x >>= 1;
}
return res;
}
inline int Inv(int dat) { return qpow(dat, mod - 2); }
inline int calc(int a, int b) {
if (b == 0)
return 1;
return (val[a] * inv[b] % mod) * inv[a - b] % mod;
}
signed main() {
cin >> r1 >> c1 >> r2 >> c2;
val[1] = 1;
for (int i = 2; i <= r2 + c2 + 5; ++i)
val[i] = val[i - 1] * i % mod;
for (int i = 1; i <= r2 + c2 + 5; ++i)
inv[i] = Inv(val[i]);
// for(int i=1;i<=r2+c2+5;++i) cout<<inv[i]<<" ";
// cout<<endl;
for (int i = r1 + 1; i <= r2 + 1; ++i) {
ans = (ans + calc(i + c2, c2) % mod) % mod;
// cout<<i+c2<<" "<<c2<<" "<<calc(i+c2,c2)<<endl;
}
for (int i = r1 + 1; i <= r2 + 1; ++i) {
ans = (ans - calc(i + c1 - 1, c1 - 1) % mod + mod) % mod;
}
cout << ans << endl;
return 0;
} | replace | 13 | 14 | 13 | 14 | 0 | |
p02782 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
ll ans = 0;
const ll mo = 1000000007;
auto mod = [](ll modx) {
modx %= mo;
modx += mo;
modx %= mo;
return modx;
};
const ll MAX = 1000100;
const ll MOD = 1000000007;
long long fac[MAX], finv[MAX], inv[MAX];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (ll i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
long long COM(ll n, ll k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
int main() {
ll r, c, t, v;
cin >> r >> c >> t >> v;
COMinit();
ans += COM(t + 1 + v + 1, v + 1) - 1;
ans -= COM(r + v + 1, v + 1) - 1;
ans -= COM(t + 1 + c, c) - 1;
ans += COM(r + c, c) - 1;
cout << mod(ans) << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
ll ans = 0;
const ll mo = 1000000007;
auto mod = [](ll modx) {
modx %= mo;
modx += mo;
modx %= mo;
return modx;
};
const ll MAX = 2000100;
const ll MOD = 1000000007;
long long fac[MAX], finv[MAX], inv[MAX];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (ll i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
long long COM(ll n, ll k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
int main() {
ll r, c, t, v;
cin >> r >> c >> t >> v;
COMinit();
ans += COM(t + 1 + v + 1, v + 1) - 1;
ans -= COM(r + v + 1, v + 1) - 1;
ans -= COM(t + 1 + c, c) - 1;
ans += COM(r + c, c) - 1;
cout << mod(ans) << endl;
return 0;
} | replace | 12 | 13 | 12 | 13 | 0 | |
p02782 | C++ | Runtime Error | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define REP(i, n) for (int i = 0; i < n; i++)
#define all(x) (x).begin(), (x).end()
#define mp make_pair
#define eb emplace_back
typedef long long ll;
using namespace std;
const int mod = 1000000007;
struct mint {
ll x; // typedef long long ll;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const {
mint res(*this);
return res += a;
}
mint operator-(const mint a) const {
mint res(*this);
return res -= a;
}
mint operator*(const mint a) const {
mint res(*this);
return res *= a;
}
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
// for prime mod
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint a) { return (*this) *= a.inv(); }
mint operator/(const mint a) const {
mint res(*this);
return res /= a;
}
};
const int MAX = 510000;
const int MOD = 1000000007;
long long fac[MAX], finv[MAX], inv[MAX];
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
mint f(ll r, ll c) { return (mint)COM(r + c, r); }
mint g(ll r, ll c) {
mint res = 0;
for (ll i = r + 1; i >= 1; i--) {
res += f(i, c);
}
return res;
}
int main(void) {
COMinit();
ll r1, c1, r2, c2;
cin >> r1 >> c1 >> r2 >> c2;
mint ans = 0;
ans = g(r2, c2) - g(r1 - 1, c2) - g(r2, c1 - 1) + g(r1 - 1, c1 - 1);
cout << ans.x << '\n';
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define REP(i, n) for (int i = 0; i < n; i++)
#define all(x) (x).begin(), (x).end()
#define mp make_pair
#define eb emplace_back
typedef long long ll;
using namespace std;
const int mod = 1000000007;
struct mint {
ll x; // typedef long long ll;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const {
mint res(*this);
return res += a;
}
mint operator-(const mint a) const {
mint res(*this);
return res -= a;
}
mint operator*(const mint a) const {
mint res(*this);
return res *= a;
}
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
// for prime mod
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint a) { return (*this) *= a.inv(); }
mint operator/(const mint a) const {
mint res(*this);
return res /= a;
}
};
const int MAX = 2010000;
const int MOD = 1000000007;
long long fac[MAX], finv[MAX], inv[MAX];
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
mint f(ll r, ll c) { return (mint)COM(r + c, r); }
mint g(ll r, ll c) {
mint res = 0;
for (ll i = r + 1; i >= 1; i--) {
res += f(i, c);
}
return res;
}
int main(void) {
COMinit();
ll r1, c1, r2, c2;
cin >> r1 >> c1 >> r2 >> c2;
mint ans = 0;
ans = g(r2, c2) - g(r1 - 1, c2) - g(r2, c1 - 1) + g(r1 - 1, c1 - 1);
cout << ans.x << '\n';
return 0;
}
| replace | 83 | 84 | 83 | 84 | 0 | |
p02782 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
using Graph = vector<vector<ll>>;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define rep2(i, m, n) for (ll i = m; i < (ll)(n); i++)
#define rrep(i, n, m) for (ll i = n; i >= (ll)(m); i--)
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const int ddx[8] = {0, 1, 1, 1, 0, -1, -1, -1};
const int ddy[8] = {1, 1, 0, -1, -1, -1, 0, 1};
const ll MOD = 1000000007;
const ll INF = 1000000000000000000L;
#ifdef __DEBUG
/**
* For DEBUG
* https://github.com/ta7uw/cpp-pyprint
*/
#include "cpp-pyprint/pyprint.h"
#endif
const int MAX = 1010000;
long long fac[MAX], finv[MAX], inv[MAX];
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
ll f(ll r, ll c) {
ll res = COM(r + c + 2, r + 1) % MOD;
res--;
return res;
}
void Main() {
ll r1, c1, r2, c2;
cin >> r1 >> c1 >> r2 >> c2;
COMinit();
ll ans = f(r2, c2);
ans -= f(r2, c1 - 1);
if (ans < 0)
ans += MOD;
ans -= f(r1 - 1, c2);
if (ans < 0)
ans += MOD;
ans += f(r1 - 1, c1 - 1);
ans %= MOD;
cout << ans << '\n';
}
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(15);
Main();
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
using Graph = vector<vector<ll>>;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define rep2(i, m, n) for (ll i = m; i < (ll)(n); i++)
#define rrep(i, n, m) for (ll i = n; i >= (ll)(m); i--)
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const int ddx[8] = {0, 1, 1, 1, 0, -1, -1, -1};
const int ddy[8] = {1, 1, 0, -1, -1, -1, 0, 1};
const ll MOD = 1000000007;
const ll INF = 1000000000000000000L;
#ifdef __DEBUG
/**
* For DEBUG
* https://github.com/ta7uw/cpp-pyprint
*/
#include "cpp-pyprint/pyprint.h"
#endif
const int MAX = 3010000;
long long fac[MAX], finv[MAX], inv[MAX];
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
ll f(ll r, ll c) {
ll res = COM(r + c + 2, r + 1) % MOD;
res--;
return res;
}
void Main() {
ll r1, c1, r2, c2;
cin >> r1 >> c1 >> r2 >> c2;
COMinit();
ll ans = f(r2, c2);
ans -= f(r2, c1 - 1);
if (ans < 0)
ans += MOD;
ans -= f(r1 - 1, c2);
if (ans < 0)
ans += MOD;
ans += f(r1 - 1, c1 - 1);
ans %= MOD;
cout << ans << '\n';
}
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(15);
Main();
return 0;
}
| replace | 26 | 27 | 26 | 27 | 0 | |
p02782 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
using Graph = vector<vector<ll>>;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define rep2(i, m, n) for (ll i = m; i < (ll)(n); i++)
#define rrep(i, n, m) for (ll i = n; i >= (ll)(m); i--)
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const int ddx[8] = {0, 1, 1, 1, 0, -1, -1, -1};
const int ddy[8] = {1, 1, 0, -1, -1, -1, 0, 1};
const ll MOD = 1000000007;
const ll INF = 1000000000000000000L;
#ifdef __DEBUG
/**
* For DEBUG
* https://github.com/ta7uw/cpp-pyprint
*/
#include "cpp-pyprint/pyprint.h"
#endif
const int MAX = 1000000;
long long fac[MAX], finv[MAX], inv[MAX];
bool initialized = false;
/**
* @fn
* This function must be called at first.
*/
void combination_init() {
initialized = true;
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
/**
* @fn
* Calculates the combination ( nCK % p: N choose K mod p).
*
* @brief constraint: 1 ≤ k ≤ n ≤ 10^7
* @return nCK % MOD
*/
long long combination(int n, int k) {
assert(initialized);
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
/**
* @fn
* Calculates the factorial of the number.
*
* @brief constraint: 1 ≤ k ≤ 10^7 and 1 ≤ n ≤ 10^9
* @return N! % MOD
*/
long long factorial(int n) {
assert(initialized);
if (n < 0)
return 0;
return fac[n] % MOD;
}
/**
* @fn
* Calculates the combination ( nCK % p: N choose K mod p).
*
* @brief
* @return nCK % MOD
*/
long long combination2(int n, int k) {
assert(initialized);
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
ll res = 1;
k = min(k, n - k);
for (long long x = 1; x <= k; x++) {
res *= (n - x + 1);
res %= MOD;
res *= inv[x];
res %= MOD;
}
return res;
}
ll f(ll r, ll c) { return (combination(r + c + 2, r + 1) - 1) % MOD; }
void Main() {
ll r1, c1, r2, c2;
cin >> r1 >> c1 >> r2 >> c2;
combination_init();
ll ans = f(r2, c2);
ans -= f(r1 - 1, c2);
ans %= MOD;
if (ans < 0)
ans += MOD;
ans -= f(r2, c1 - 1);
ans %= MOD;
if (ans < 0)
ans += MOD;
ans += f(r1 - 1, c1 - 1);
ans %= MOD;
cout << ans << '\n';
}
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(15);
Main();
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
using Graph = vector<vector<ll>>;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define rep2(i, m, n) for (ll i = m; i < (ll)(n); i++)
#define rrep(i, n, m) for (ll i = n; i >= (ll)(m); i--)
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const int ddx[8] = {0, 1, 1, 1, 0, -1, -1, -1};
const int ddy[8] = {1, 1, 0, -1, -1, -1, 0, 1};
const ll MOD = 1000000007;
const ll INF = 1000000000000000000L;
#ifdef __DEBUG
/**
* For DEBUG
* https://github.com/ta7uw/cpp-pyprint
*/
#include "cpp-pyprint/pyprint.h"
#endif
const int MAX = 10000000;
long long fac[MAX], finv[MAX], inv[MAX];
bool initialized = false;
/**
* @fn
* This function must be called at first.
*/
void combination_init() {
initialized = true;
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
/**
* @fn
* Calculates the combination ( nCK % p: N choose K mod p).
*
* @brief constraint: 1 ≤ k ≤ n ≤ 10^7
* @return nCK % MOD
*/
long long combination(int n, int k) {
assert(initialized);
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
/**
* @fn
* Calculates the factorial of the number.
*
* @brief constraint: 1 ≤ k ≤ 10^7 and 1 ≤ n ≤ 10^9
* @return N! % MOD
*/
long long factorial(int n) {
assert(initialized);
if (n < 0)
return 0;
return fac[n] % MOD;
}
/**
* @fn
* Calculates the combination ( nCK % p: N choose K mod p).
*
* @brief
* @return nCK % MOD
*/
long long combination2(int n, int k) {
assert(initialized);
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
ll res = 1;
k = min(k, n - k);
for (long long x = 1; x <= k; x++) {
res *= (n - x + 1);
res %= MOD;
res *= inv[x];
res %= MOD;
}
return res;
}
ll f(ll r, ll c) { return (combination(r + c + 2, r + 1) - 1) % MOD; }
void Main() {
ll r1, c1, r2, c2;
cin >> r1 >> c1 >> r2 >> c2;
combination_init();
ll ans = f(r2, c2);
ans -= f(r1 - 1, c2);
ans %= MOD;
if (ans < 0)
ans += MOD;
ans -= f(r2, c1 - 1);
ans %= MOD;
if (ans < 0)
ans += MOD;
ans += f(r1 - 1, c1 - 1);
ans %= MOD;
cout << ans << '\n';
}
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(15);
Main();
return 0;
}
| replace | 25 | 26 | 25 | 26 | 0 | |
p02782 | C++ | Runtime Error | #include <bits/stdc++.h>
#define fo(i, a, b) for (int i = (a); i <= (b); ++i)
#define rv(i, a, b) for (int i = (a); i >= (b); --i)
using namespace std;
const int M = 1200000;
const int md = 1e9 + 7;
typedef long long ll;
int n, m, k;
int fac[M], inv[M];
void ini() {
inv[0] = inv[1] = 1;
fac[0] = fac[1] = 1;
fo(i, 2, M - 1) { inv[i] = 1ll * (md - md / i) * inv[md % i] % md; }
fo(i, 2, M - 1) {
inv[i] = 1ll * inv[i - 1] * inv[i] % md;
fac[i] = 1ll * fac[i - 1] * i % md;
}
}
ll C(int a, int b) {
if (b < 0 || a < b)
return 0;
return 1ll * fac[a] * inv[a - b] % md * inv[b] % md;
}
ll f(int a, int b) { return C(a + b, a); }
int main() {
ini();
int r1, r2, c1, c2;
cin >> r1 >> c1 >> r2 >> c2;
ll ans = f(r1, c1);
fo(i, r1 + 1, r2) ans = (ans + f(i, c2)) % md;
fo(i, c1 + 1, c2) ans = (ans + f(r2, i)) % md;
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define fo(i, a, b) for (int i = (a); i <= (b); ++i)
#define rv(i, a, b) for (int i = (a); i >= (b); --i)
using namespace std;
const int M = 2200000;
const int md = 1e9 + 7;
typedef long long ll;
int n, m, k;
int fac[M], inv[M];
void ini() {
inv[0] = inv[1] = 1;
fac[0] = fac[1] = 1;
fo(i, 2, M - 1) { inv[i] = 1ll * (md - md / i) * inv[md % i] % md; }
fo(i, 2, M - 1) {
inv[i] = 1ll * inv[i - 1] * inv[i] % md;
fac[i] = 1ll * fac[i - 1] * i % md;
}
}
ll C(int a, int b) {
if (b < 0 || a < b)
return 0;
return 1ll * fac[a] * inv[a - b] % md * inv[b] % md;
}
ll f(int a, int b) { return C(a + b, a); }
int main() {
ini();
int r1, r2, c1, c2;
cin >> r1 >> c1 >> r2 >> c2;
ll ans = f(r1, c1);
fo(i, r1 + 1, r2) ans = (ans + f(i, c2)) % md;
fo(i, c1 + 1, c2) ans = (ans + f(r2, i)) % md;
cout << ans << endl;
return 0;
} | replace | 4 | 5 | 4 | 5 | 0 | |
p02782 | C++ | Runtime Error | #ifdef LOCAL
#define _GLIBCXX_DEBUG
#define __clock__
#else
#pragma GCC optimize("Ofast")
#endif
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using VI = vector<ll>;
using VV = vector<VI>;
using VS = vector<string>;
using PII = pair<ll, ll>;
// tourist set
template <typename A, typename B> string to_string(pair<A, B> p);
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);
string to_string(const string &s) { return '"' + s + '"'; }
string to_string(const char *s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
string to_string(vector<bool> v) {
bool first = true;
string res = "{";
for (int i = 0; i < static_cast<int>(v.size()); i++) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(v[i]);
}
res += "}";
return res;
}
template <size_t N> string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++) {
res += static_cast<char>('0' + v[i]);
}
return res;
}
template <typename A> string to_string(A v) {
bool first = true;
string res = "{";
for (const auto &x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
template <typename A, typename B> string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ")";
}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}
void debug_out() { cerr << '\n'; }
template <typename Head, typename... Tail> void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
#ifdef LOCAL
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define debug(...) 42
#endif
// tourist set end
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
#define FOR(i, a, b) for (ll i = (a); i < (b); ++i)
#define rep(i, b) FOR(i, 0, b)
#define ALL(v) (v).begin(), (v).end()
#define p(s) cout << (s) << '\n'
#define p2(s, t) cout << (s) << " " << (t) << '\n'
#define br() p("")
#define pn(s) cout << (#s) << " " << (s) << '\n'
#define p_yes() p("YES")
#define p_no() p("NO")
#define SZ(x) ((int)(x).size())
#define SORT(A) sort(ALL(A))
#define RSORT(A) sort(ALL(A), greater<ll>())
#define MP make_pair
void no() {
p_no();
exit(0);
}
void yes() {
p_yes();
exit(0);
}
const ll mod = 1e9 + 7;
const ll inf = 1e18;
const double PI = acos(-1);
const int N_MAX = 400010;
ll Per[N_MAX] = {}; // n!
ll Per_inv[N_MAX] = {}; //(n!)^-1
ll nCr(ll n, ll r) {
if (n < r)
return 0;
if (n == r || r == 0)
return 1;
else
return Per[n] * Per_inv[n - r] % mod * Per_inv[r] % mod;
}
// a^b mod p
ll mod_pow(ll a, ll b) {
if (b == 0)
return 1;
// 肩が奇数
if (b % 2 == 1) {
return a * mod_pow(a, b - 1) % mod;
} else {
return mod_pow(a * a % mod, b / 2) % mod;
}
}
void prepare_nCr() {
Per[0] = 1;
Per_inv[0] = 1;
// nCr高速化準備
Per[1] = 1;
FOR(i, 2, N_MAX) { Per[i] = i * Per[i - 1] % mod; }
Per_inv[1] = 1;
FOR(i, 2, N_MAX) { Per_inv[i] = mod_pow(Per[i], mod - 2); }
}
ll nHr(ll n, ll r) { return nCr(n - 1 + r, n - 1); }
ll f_naive(ll r, ll c) {
ll sum = 0;
debug(r, c);
rep(i, r + 1) {
rep(j, c + 1) { sum += nCr(i + j, j); }
}
debug(sum);
return sum;
}
ll f(ll r, ll c) {
// return f_naive(r, c);
ll ans = r + 1;
FOR(i, 1, c + 1) {
ans += nCr(r + i + 1, r);
ans %= mod;
}
return ans;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
prepare_nCr();
// input
ll r1, c1, r2, c2;
cin >> r1 >> c1 >> r2 >> c2;
ll a = f(r2, c2);
debug(a);
ll b = f(r2, c1 - 1);
ll c = f(r1 - 1, c2);
ll d = f(r1 - 1, c1 - 1);
ll ans = a - b - c + d;
ans %= mod;
if (ans < 0)
ans += mod;
p(ans);
return 0;
} | #ifdef LOCAL
#define _GLIBCXX_DEBUG
#define __clock__
#else
#pragma GCC optimize("Ofast")
#endif
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using VI = vector<ll>;
using VV = vector<VI>;
using VS = vector<string>;
using PII = pair<ll, ll>;
// tourist set
template <typename A, typename B> string to_string(pair<A, B> p);
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);
string to_string(const string &s) { return '"' + s + '"'; }
string to_string(const char *s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
string to_string(vector<bool> v) {
bool first = true;
string res = "{";
for (int i = 0; i < static_cast<int>(v.size()); i++) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(v[i]);
}
res += "}";
return res;
}
template <size_t N> string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++) {
res += static_cast<char>('0' + v[i]);
}
return res;
}
template <typename A> string to_string(A v) {
bool first = true;
string res = "{";
for (const auto &x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
template <typename A, typename B> string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ")";
}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}
void debug_out() { cerr << '\n'; }
template <typename Head, typename... Tail> void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
#ifdef LOCAL
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define debug(...) 42
#endif
// tourist set end
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
#define FOR(i, a, b) for (ll i = (a); i < (b); ++i)
#define rep(i, b) FOR(i, 0, b)
#define ALL(v) (v).begin(), (v).end()
#define p(s) cout << (s) << '\n'
#define p2(s, t) cout << (s) << " " << (t) << '\n'
#define br() p("")
#define pn(s) cout << (#s) << " " << (s) << '\n'
#define p_yes() p("YES")
#define p_no() p("NO")
#define SZ(x) ((int)(x).size())
#define SORT(A) sort(ALL(A))
#define RSORT(A) sort(ALL(A), greater<ll>())
#define MP make_pair
void no() {
p_no();
exit(0);
}
void yes() {
p_yes();
exit(0);
}
const ll mod = 1e9 + 7;
const ll inf = 1e18;
const double PI = acos(-1);
const int N_MAX = 2000010;
ll Per[N_MAX] = {}; // n!
ll Per_inv[N_MAX] = {}; //(n!)^-1
ll nCr(ll n, ll r) {
if (n < r)
return 0;
if (n == r || r == 0)
return 1;
else
return Per[n] * Per_inv[n - r] % mod * Per_inv[r] % mod;
}
// a^b mod p
ll mod_pow(ll a, ll b) {
if (b == 0)
return 1;
// 肩が奇数
if (b % 2 == 1) {
return a * mod_pow(a, b - 1) % mod;
} else {
return mod_pow(a * a % mod, b / 2) % mod;
}
}
void prepare_nCr() {
Per[0] = 1;
Per_inv[0] = 1;
// nCr高速化準備
Per[1] = 1;
FOR(i, 2, N_MAX) { Per[i] = i * Per[i - 1] % mod; }
Per_inv[1] = 1;
FOR(i, 2, N_MAX) { Per_inv[i] = mod_pow(Per[i], mod - 2); }
}
ll nHr(ll n, ll r) { return nCr(n - 1 + r, n - 1); }
ll f_naive(ll r, ll c) {
ll sum = 0;
debug(r, c);
rep(i, r + 1) {
rep(j, c + 1) { sum += nCr(i + j, j); }
}
debug(sum);
return sum;
}
ll f(ll r, ll c) {
// return f_naive(r, c);
ll ans = r + 1;
FOR(i, 1, c + 1) {
ans += nCr(r + i + 1, r);
ans %= mod;
}
return ans;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
prepare_nCr();
// input
ll r1, c1, r2, c2;
cin >> r1 >> c1 >> r2 >> c2;
ll a = f(r2, c2);
debug(a);
ll b = f(r2, c1 - 1);
ll c = f(r1 - 1, c2);
ll d = f(r1 - 1, c1 - 1);
ll ans = a - b - c + d;
ans %= mod;
if (ans < 0)
ans += mod;
p(ans);
return 0;
} | replace | 137 | 138 | 137 | 138 | 0 | |
p02782 | C++ | Runtime Error | // in the name of god
// if you read this code please search about imam hussain
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define pb push_back
#define endl "\n"
#define X first
#define Y second
#define pii pair<int, int>
#define migmig \
ios::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0)
#define read \
freopen("input.txt", "r", stdin); \
freopen("output.txt", "w", stdout)
const int maxn = 1e6 + 50;
const int mod = 1e9 + 7;
const int inf = 1e9;
const int del = 728729;
ll poww(ll a, ll b, ll md) {
return (!b ? 1
: (b & 1 ? a * poww(a * a % md, b / 2, md) % md
: poww(a * a % md, b / 2, md) % md));
}
ll r1;
ll r2;
ll c1;
ll c2;
ll fact[maxn];
ll inv[maxn];
ll ans;
ll combi(ll a, ll b) {
if (a < b)
return 0;
ll cp = fact[a];
cp = (cp * inv[b]) % mod;
cp = (cp * inv[a - b]) % mod;
return cp;
}
int main() {
migmig;
cin >> r1 >> c1 >> r2 >> c2;
fact[0] = fact[1] = 1;
inv[1] = 1;
inv[0] = 1;
for (int i = 1; i < maxn; i++) {
fact[i] = (fact[i - 1] * i) % mod;
inv[i] = poww(fact[i], mod - 2, mod) % mod;
}
// cout<<combi(3,2);
// cout
for (int i = r1; i <= r2; i++) {
ll x = combi(i + 1 + c2, c2) % mod;
ll y = combi(i + 1 + c1 - 1, c1 - 1) % mod;
ans = (ans + x - y + mod) % mod;
}
cout << ans << endl;
return 0;
}
| // in the name of god
// if you read this code please search about imam hussain
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define pb push_back
#define endl "\n"
#define X first
#define Y second
#define pii pair<int, int>
#define migmig \
ios::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0)
#define read \
freopen("input.txt", "r", stdin); \
freopen("output.txt", "w", stdout)
const int maxn = 2e6 + 50;
const int mod = 1e9 + 7;
const int inf = 1e9;
const int del = 728729;
ll poww(ll a, ll b, ll md) {
return (!b ? 1
: (b & 1 ? a * poww(a * a % md, b / 2, md) % md
: poww(a * a % md, b / 2, md) % md));
}
ll r1;
ll r2;
ll c1;
ll c2;
ll fact[maxn];
ll inv[maxn];
ll ans;
ll combi(ll a, ll b) {
if (a < b)
return 0;
ll cp = fact[a];
cp = (cp * inv[b]) % mod;
cp = (cp * inv[a - b]) % mod;
return cp;
}
int main() {
migmig;
cin >> r1 >> c1 >> r2 >> c2;
fact[0] = fact[1] = 1;
inv[1] = 1;
inv[0] = 1;
for (int i = 1; i < maxn; i++) {
fact[i] = (fact[i - 1] * i) % mod;
inv[i] = poww(fact[i], mod - 2, mod) % mod;
}
// cout<<combi(3,2);
// cout
for (int i = r1; i <= r2; i++) {
ll x = combi(i + 1 + c2, c2) % mod;
ll y = combi(i + 1 + c1 - 1, c1 - 1) % mod;
ans = (ans + x - y + mod) % mod;
}
cout << ans << endl;
return 0;
}
| replace | 21 | 22 | 21 | 22 | 0 | |
p02782 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll MOD = 1000000007;
inline ll add(ll x, ll y) { return (x + y) % MOD; }
inline ll sub(ll x, ll y) {
ll res = x - y;
if (res < 0)
res += MOD;
return res;
}
const int MAX = 200005;
ll fac[MAX], finv[MAX], inv[MAX];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
long long COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
int main() {
COMinit();
int r1, c1, r2, c2;
cin >> r1 >> c1 >> r2 >> c2;
ll ans = 0;
ans = add(ans, COM(r2 + c2 + 2, r2 + 1) - 1);
ans = add(ans, COM(r1 + c1, r1) - 1);
ans = sub(ans, COM(r2 + c1 + 1, r2 + 1) - 1);
ans = sub(ans, COM(r1 + c2 + 1, r1) - 1);
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll MOD = 1000000007;
inline ll add(ll x, ll y) { return (x + y) % MOD; }
inline ll sub(ll x, ll y) {
ll res = x - y;
if (res < 0)
res += MOD;
return res;
}
const int MAX = 2000005;
ll fac[MAX], finv[MAX], inv[MAX];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
long long COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
int main() {
COMinit();
int r1, c1, r2, c2;
cin >> r1 >> c1 >> r2 >> c2;
ll ans = 0;
ans = add(ans, COM(r2 + c2 + 2, r2 + 1) - 1);
ans = add(ans, COM(r1 + c1, r1) - 1);
ans = sub(ans, COM(r2 + c1 + 1, r2 + 1) - 1);
ans = sub(ans, COM(r1 + c2 + 1, r1) - 1);
cout << ans << endl;
return 0;
} | replace | 13 | 14 | 13 | 14 | 0 | |
p02782 | C++ | Runtime Error | #include <bits/stdc++.h>
#define ll long long
#define ld long double
#define mp make_pair
#define pb push_back
#define in insert
#define vll vector<ll>
#define endl "\n"
#define pll pair<ll, ll>
#define all(x) (x).begin(), (x).end()
#define f first
#define s second
#define pr(x) cout << x << endl;
#define pr2(x, y) cout << x << " " << y << endl;
#define pr3(x, y, z) cout << x << " " << y << endl;
#define prv(v) \
for (auto x : v) \
cout << x << " ";
#define ffs fflush(stdout);
#define int ll
#define sz(x) (ll) x.size()
using namespace std;
const ll MOD = 1e9 + 7;
const ll INF = 1e9;
const ll LOG = 29;
#define PI 3.141592653589793238
const ll N = (1e6 + 5);
const ld ep = 1e-9;
ll fact[N];
long long binpow(long long a, long long b) {
a %= MOD;
long long res = 1;
while (b > 0) {
if (b & 1)
res = (res * a) % MOD;
a = (a * a) % MOD;
b >>= 1;
}
res %= MOD;
return res;
}
ll ncr(ll n, ll r) {
ll ret = fact[n];
ret = (ret * binpow(fact[r], MOD - 2)) % MOD;
ret = (ret * binpow(fact[n - r], MOD - 2)) % MOD;
return ret;
}
void solve() {
ll r1, c1, r2, c2;
cin >> r1 >> c1 >> r2 >> c2;
fact[0] = 1;
for (int i = 1; i < N; i++) {
fact[i] = (fact[i - 1] * i) % MOD;
}
ll ans = 0;
for (int i = r1; i <= r2; i++) {
ans = (ans + (ncr(c2 + i + 1, i + 1) - ncr(c1 + i, i + 1) + MOD)) % MOD;
}
cout << ans << endl;
}
/*
2 3 4 5 6
3 6 10 15 21
4 10 20 35 56
5 15 35 70 126
6 21 56 126 252
*/
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
ll tt = 1;
while (tt--) {
solve();
}
} | #include <bits/stdc++.h>
#define ll long long
#define ld long double
#define mp make_pair
#define pb push_back
#define in insert
#define vll vector<ll>
#define endl "\n"
#define pll pair<ll, ll>
#define all(x) (x).begin(), (x).end()
#define f first
#define s second
#define pr(x) cout << x << endl;
#define pr2(x, y) cout << x << " " << y << endl;
#define pr3(x, y, z) cout << x << " " << y << endl;
#define prv(v) \
for (auto x : v) \
cout << x << " ";
#define ffs fflush(stdout);
#define int ll
#define sz(x) (ll) x.size()
using namespace std;
const ll MOD = 1e9 + 7;
const ll INF = 1e9;
const ll LOG = 29;
#define PI 3.141592653589793238
const ll N = (5e6 + 5);
const ld ep = 1e-9;
ll fact[N];
long long binpow(long long a, long long b) {
a %= MOD;
long long res = 1;
while (b > 0) {
if (b & 1)
res = (res * a) % MOD;
a = (a * a) % MOD;
b >>= 1;
}
res %= MOD;
return res;
}
ll ncr(ll n, ll r) {
ll ret = fact[n];
ret = (ret * binpow(fact[r], MOD - 2)) % MOD;
ret = (ret * binpow(fact[n - r], MOD - 2)) % MOD;
return ret;
}
void solve() {
ll r1, c1, r2, c2;
cin >> r1 >> c1 >> r2 >> c2;
fact[0] = 1;
for (int i = 1; i < N; i++) {
fact[i] = (fact[i - 1] * i) % MOD;
}
ll ans = 0;
for (int i = r1; i <= r2; i++) {
ans = (ans + (ncr(c2 + i + 1, i + 1) - ncr(c1 + i, i + 1) + MOD)) % MOD;
}
cout << ans << endl;
}
/*
2 3 4 5 6
3 6 10 15 21
4 10 20 35 56
5 15 35 70 126
6 21 56 126 252
*/
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
ll tt = 1;
while (tt--) {
solve();
}
} | replace | 28 | 29 | 28 | 29 | 0 | |
p02782 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 1000000 + 10;
const int mod = 1e9 + 7;
ll qpow(ll n, ll k) {
ll res = 1;
while (k) {
if (k & 1)
res = res * n % mod;
n = n * n % mod;
k >>= 1;
}
return res;
}
ll fac[N], inv[N];
ll C(int n, int k) { return fac[n] * inv[k] % mod * inv[n - k] % mod; }
ll f(int x, int y) {
int n = 0, k = 0;
ll S = 1, ans = S;
for (int i = 1; i <= x; i++) {
S = (S * 2 - C(n, k) + mod) % mod, n++;
S = (S + C(n, k + 1)) % mod, k++;
// cout<<n<<' '<<k<<' '<<S<<endl;
ans += S;
}
for (int i = 1; i <= y; i++) {
S = (S * 2 - C(n, k) + mod) % mod, n++;
// cout<<n<<' '<<k<<' '<<S<<endl;
ans += S;
}
n = 0, k = 0, S = 1, ans -= S;
for (int i = 1; i <= y; i++) {
S = (S * 2 - C(n, k) + mod) % mod, n++;
// cout<<n<<' '<<k<<' '<<S<<endl;
ans -= S;
}
for (int i = 1; i <= x; i++) {
S = (S * 2 - C(n, k) + mod) % mod, n++;
S = (S + C(n, k + 1)) % mod, k++;
// cout<<n<<' '<<k<<' '<<S<<endl;
ans -= S;
}
for (int i = 0; i <= y; i++)
ans += C(i, 0);
for (int i = 1; i <= x; i++)
ans += C(i + y, i);
// cout<<x<<' '<<y<<' '<<ans<<endl;
return (ans % mod + mod) % mod;
}
int main() {
fac[0] = 1;
for (int i = 1; i < N; i++)
fac[i] = fac[i - 1] * i % mod;
inv[N - 1] = qpow(fac[N - 1], mod - 2);
for (int i = N - 2; i >= 0; i--)
inv[i] = inv[i + 1] * (i + 1) % mod;
int x1, x2, y1, y2;
cin >> x1 >> y1 >> x2 >> y2;
ll ans = f(x2, y2) - f(x2, y1 - 1) - f(x1 - 1, y2) + f(x1 - 1, y1 - 1);
ans = (ans % mod + mod) % mod;
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 2000000 + 10;
const int mod = 1e9 + 7;
ll qpow(ll n, ll k) {
ll res = 1;
while (k) {
if (k & 1)
res = res * n % mod;
n = n * n % mod;
k >>= 1;
}
return res;
}
ll fac[N], inv[N];
ll C(int n, int k) { return fac[n] * inv[k] % mod * inv[n - k] % mod; }
ll f(int x, int y) {
int n = 0, k = 0;
ll S = 1, ans = S;
for (int i = 1; i <= x; i++) {
S = (S * 2 - C(n, k) + mod) % mod, n++;
S = (S + C(n, k + 1)) % mod, k++;
// cout<<n<<' '<<k<<' '<<S<<endl;
ans += S;
}
for (int i = 1; i <= y; i++) {
S = (S * 2 - C(n, k) + mod) % mod, n++;
// cout<<n<<' '<<k<<' '<<S<<endl;
ans += S;
}
n = 0, k = 0, S = 1, ans -= S;
for (int i = 1; i <= y; i++) {
S = (S * 2 - C(n, k) + mod) % mod, n++;
// cout<<n<<' '<<k<<' '<<S<<endl;
ans -= S;
}
for (int i = 1; i <= x; i++) {
S = (S * 2 - C(n, k) + mod) % mod, n++;
S = (S + C(n, k + 1)) % mod, k++;
// cout<<n<<' '<<k<<' '<<S<<endl;
ans -= S;
}
for (int i = 0; i <= y; i++)
ans += C(i, 0);
for (int i = 1; i <= x; i++)
ans += C(i + y, i);
// cout<<x<<' '<<y<<' '<<ans<<endl;
return (ans % mod + mod) % mod;
}
int main() {
fac[0] = 1;
for (int i = 1; i < N; i++)
fac[i] = fac[i - 1] * i % mod;
inv[N - 1] = qpow(fac[N - 1], mod - 2);
for (int i = N - 2; i >= 0; i--)
inv[i] = inv[i + 1] * (i + 1) % mod;
int x1, x2, y1, y2;
cin >> x1 >> y1 >> x2 >> y2;
ll ans = f(x2, y2) - f(x2, y1 - 1) - f(x1 - 1, y2) + f(x1 - 1, y1 - 1);
ans = (ans % mod + mod) % mod;
cout << ans << endl;
}
| replace | 3 | 4 | 3 | 4 | 0 | |
p02782 | C++ | Runtime Error | #include <algorithm>
#include <bitset>
#include <iostream>
#include <queue>
#include <set>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using Pii = pair<int, int>;
using Pll = pair<ll, ll>;
template <class T> using Vvec = vector<vector<T>>;
template <class T> void debug(T &v) {
for (auto &x : v)
cout << x << " ";
cout << endl;
}
constexpr long long default_mod = 1e9 + 7;
// element of Z/pZ
class Modulo {
public:
long long p;
long long n;
Modulo(long long n0, long long p0);
bool operator==(const Modulo rhs) const { return n == rhs.n; }
Modulo &operator+=(const long long rhs);
Modulo &operator+=(const Modulo &rhs);
Modulo &operator*=(const long long rhs);
Modulo &operator*=(const Modulo &rhs);
Modulo &operator-=(const long long rhs);
Modulo &operator-=(const Modulo &rhs);
Modulo pow(const long long k) const;
Modulo inverse() const;
Modulo &operator/=(const long long rhs);
Modulo &operator/=(const Modulo &rhs);
long long get() const { return n; };
};
const Modulo operator+(const Modulo &lhs, const Modulo &rhs);
const Modulo operator+(const Modulo &lhs, const long long rhs);
const Modulo operator+(const long long lhs, const Modulo &rhs);
const Modulo operator*(const Modulo &lhs, const Modulo &rhs);
const Modulo operator*(const Modulo &lhs, const long long rhs);
const Modulo operator*(const long long lhs, const Modulo &rhs);
template <class T> T ext_gcd(T a, T b, T &x, T &y);
// constructor
Modulo::Modulo(long long n0, long long p0 = default_mod) : p(p0) {
n = n0 >= 0 ? n0 % p : (p - (-n0 % p)) % p;
}
// operator +=
inline Modulo &Modulo::operator+=(const long long rhs) {
long long rhs1 = rhs >= 0 ? rhs % p : (p - (-rhs % p)) % p;
n = (n + rhs1) % p;
return *this;
}
inline Modulo &Modulo::operator+=(const Modulo &rhs) {
(*this) += rhs.n;
return *this;
}
// operator *=
inline Modulo &Modulo::operator*=(const long long rhs) {
long long rhs1 = rhs >= 0 ? rhs % p : (p - (-rhs % p)) % p;
n = (n * rhs1) % p;
return *this;
}
inline Modulo &Modulo::operator*=(const Modulo &rhs) {
(*this) *= rhs.n;
return *this;
}
// operator -=
inline Modulo &Modulo::operator-=(const long long rhs) { return *this += -rhs; }
inline Modulo &Modulo::operator-=(const Modulo &rhs) {
(*this) -= rhs.get();
return *this;
}
//(*this)**k
Modulo Modulo::pow(const long long k) const {
if (k == 0)
return Modulo(1, p);
if (k == 1)
return Modulo(n, p);
long long k1 = k >= 0 ? k % (p - 1) : ((p - 1) - (-k % (p - 1))) % (p - 1);
Modulo r = pow(k1 / 2);
if (k1 % 2 == 0)
return r * r;
else
return r * r * n;
}
//(*this)**(-1)
Modulo Modulo::inverse() const {
long long x, y;
ext_gcd(n, p, x, y);
return Modulo(x, p).n;
}
// operator /=
inline Modulo &Modulo::operator/=(const long long rhs) {
Modulo inv(rhs, p);
inv = inv.inverse();
return *this *= inv;
}
inline Modulo &Modulo::operator/=(const Modulo &rhs) {
(*this) /= rhs.get();
return *this;
}
// operator +
const Modulo operator+(const Modulo &lhs, const Modulo &rhs) {
return Modulo(lhs.get(), lhs.p) += rhs;
}
const Modulo operator+(const Modulo &lhs, const long long rhs) {
return Modulo(lhs.get(), lhs.p) += rhs;
}
const Modulo operator+(const long long lhs, const Modulo &rhs) {
return Modulo(lhs, rhs.p) += rhs;
}
// operator *
const Modulo operator*(const Modulo &lhs, const Modulo &rhs) {
return Modulo(lhs.get(), lhs.p) *= rhs;
}
const Modulo operator*(const Modulo &lhs, const long long rhs) {
return Modulo(lhs.get(), lhs.p) *= rhs;
}
const Modulo operator*(const long long lhs, const Modulo &rhs) {
return Modulo(lhs, rhs.p) *= rhs;
}
// operator -
const Modulo operator-(const Modulo &lhs, const Modulo &rhs) {
return Modulo(lhs.get(), lhs.p) -= rhs;
}
const Modulo operator-(const Modulo &lhs, const long long rhs) {
return Modulo(lhs.get(), lhs.p) -= rhs;
}
const Modulo operator-(const long long lhs, const Modulo &rhs) {
return Modulo(lhs, rhs.p) -= rhs;
}
// operator /
const Modulo operator/(const Modulo &lhs, const Modulo &rhs) {
return Modulo(lhs.get(), lhs.p) /= rhs;
}
const Modulo operator/(const Modulo &lhs, const long long rhs) {
return Modulo(lhs.get(), lhs.p) /= rhs;
}
const Modulo operator/(const long long lhs, const Modulo &rhs) {
return Modulo(lhs, rhs.p) /= rhs;
}
// very very useful functions
// n**k
Modulo pow(Modulo n, long long k) {
Modulo tmp = n;
tmp = tmp.pow(k);
return tmp;
}
// n!
Modulo fact(long long n, long long p = default_mod,
long long init_size = 1e+6) {
static bool is_init = false;
static std::vector<long long> dat;
if (!is_init) {
is_init = true;
dat.resize(init_size);
dat[0] = 1;
for (int i = 1; i < init_size; i++)
dat[i] = dat[i - 1] * i % p;
}
return Modulo(dat[n], p);
}
// 1/n!
Modulo ifact(long long n, long long p = default_mod,
long long init_size = 1e+6) {
static bool is_init = false;
static std::vector<long long> dat;
if (!is_init) {
is_init = true;
dat.resize(init_size);
dat[0] = 1;
for (int i = 1; i < init_size; i++)
dat[i] = (Modulo(dat[i - 1], p) / i).n;
}
return Modulo(dat[n], p);
}
// initialize
void initFact(long long init_size, long long p = default_mod) {
fact(0, p, init_size);
ifact(0, p, init_size);
}
// nCk
Modulo comb(long long n, long long k, long long p = default_mod) {
Modulo a = fact(n, p);
Modulo b = ifact(k, p);
Modulo c = ifact(n - k, p);
return a * b * c;
}
// ax + by = d
template <class T> T ext_gcd(T a, T b, T &x, T &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
T d = ext_gcd(b, a % b, x, y);
T x_ = x;
x = y;
y = x_ - a / b * y;
return d;
}
int main() {
ll r1, r2, c1, c2;
cin >> r1 >> c1 >> r2 >> c2;
Modulo ans = 0;
initFact(200010);
for (int i = r1; i <= r2; i++) {
ans += ifact(i + 1) *
(fact(c2 + i + 1) * ifact(c2) - fact(c1 + i) * ifact(c1 - 1));
}
cout << ans.n << endl;
} | #include <algorithm>
#include <bitset>
#include <iostream>
#include <queue>
#include <set>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using Pii = pair<int, int>;
using Pll = pair<ll, ll>;
template <class T> using Vvec = vector<vector<T>>;
template <class T> void debug(T &v) {
for (auto &x : v)
cout << x << " ";
cout << endl;
}
constexpr long long default_mod = 1e9 + 7;
// element of Z/pZ
class Modulo {
public:
long long p;
long long n;
Modulo(long long n0, long long p0);
bool operator==(const Modulo rhs) const { return n == rhs.n; }
Modulo &operator+=(const long long rhs);
Modulo &operator+=(const Modulo &rhs);
Modulo &operator*=(const long long rhs);
Modulo &operator*=(const Modulo &rhs);
Modulo &operator-=(const long long rhs);
Modulo &operator-=(const Modulo &rhs);
Modulo pow(const long long k) const;
Modulo inverse() const;
Modulo &operator/=(const long long rhs);
Modulo &operator/=(const Modulo &rhs);
long long get() const { return n; };
};
const Modulo operator+(const Modulo &lhs, const Modulo &rhs);
const Modulo operator+(const Modulo &lhs, const long long rhs);
const Modulo operator+(const long long lhs, const Modulo &rhs);
const Modulo operator*(const Modulo &lhs, const Modulo &rhs);
const Modulo operator*(const Modulo &lhs, const long long rhs);
const Modulo operator*(const long long lhs, const Modulo &rhs);
template <class T> T ext_gcd(T a, T b, T &x, T &y);
// constructor
Modulo::Modulo(long long n0, long long p0 = default_mod) : p(p0) {
n = n0 >= 0 ? n0 % p : (p - (-n0 % p)) % p;
}
// operator +=
inline Modulo &Modulo::operator+=(const long long rhs) {
long long rhs1 = rhs >= 0 ? rhs % p : (p - (-rhs % p)) % p;
n = (n + rhs1) % p;
return *this;
}
inline Modulo &Modulo::operator+=(const Modulo &rhs) {
(*this) += rhs.n;
return *this;
}
// operator *=
inline Modulo &Modulo::operator*=(const long long rhs) {
long long rhs1 = rhs >= 0 ? rhs % p : (p - (-rhs % p)) % p;
n = (n * rhs1) % p;
return *this;
}
inline Modulo &Modulo::operator*=(const Modulo &rhs) {
(*this) *= rhs.n;
return *this;
}
// operator -=
inline Modulo &Modulo::operator-=(const long long rhs) { return *this += -rhs; }
inline Modulo &Modulo::operator-=(const Modulo &rhs) {
(*this) -= rhs.get();
return *this;
}
//(*this)**k
Modulo Modulo::pow(const long long k) const {
if (k == 0)
return Modulo(1, p);
if (k == 1)
return Modulo(n, p);
long long k1 = k >= 0 ? k % (p - 1) : ((p - 1) - (-k % (p - 1))) % (p - 1);
Modulo r = pow(k1 / 2);
if (k1 % 2 == 0)
return r * r;
else
return r * r * n;
}
//(*this)**(-1)
Modulo Modulo::inverse() const {
long long x, y;
ext_gcd(n, p, x, y);
return Modulo(x, p).n;
}
// operator /=
inline Modulo &Modulo::operator/=(const long long rhs) {
Modulo inv(rhs, p);
inv = inv.inverse();
return *this *= inv;
}
inline Modulo &Modulo::operator/=(const Modulo &rhs) {
(*this) /= rhs.get();
return *this;
}
// operator +
const Modulo operator+(const Modulo &lhs, const Modulo &rhs) {
return Modulo(lhs.get(), lhs.p) += rhs;
}
const Modulo operator+(const Modulo &lhs, const long long rhs) {
return Modulo(lhs.get(), lhs.p) += rhs;
}
const Modulo operator+(const long long lhs, const Modulo &rhs) {
return Modulo(lhs, rhs.p) += rhs;
}
// operator *
const Modulo operator*(const Modulo &lhs, const Modulo &rhs) {
return Modulo(lhs.get(), lhs.p) *= rhs;
}
const Modulo operator*(const Modulo &lhs, const long long rhs) {
return Modulo(lhs.get(), lhs.p) *= rhs;
}
const Modulo operator*(const long long lhs, const Modulo &rhs) {
return Modulo(lhs, rhs.p) *= rhs;
}
// operator -
const Modulo operator-(const Modulo &lhs, const Modulo &rhs) {
return Modulo(lhs.get(), lhs.p) -= rhs;
}
const Modulo operator-(const Modulo &lhs, const long long rhs) {
return Modulo(lhs.get(), lhs.p) -= rhs;
}
const Modulo operator-(const long long lhs, const Modulo &rhs) {
return Modulo(lhs, rhs.p) -= rhs;
}
// operator /
const Modulo operator/(const Modulo &lhs, const Modulo &rhs) {
return Modulo(lhs.get(), lhs.p) /= rhs;
}
const Modulo operator/(const Modulo &lhs, const long long rhs) {
return Modulo(lhs.get(), lhs.p) /= rhs;
}
const Modulo operator/(const long long lhs, const Modulo &rhs) {
return Modulo(lhs, rhs.p) /= rhs;
}
// very very useful functions
// n**k
Modulo pow(Modulo n, long long k) {
Modulo tmp = n;
tmp = tmp.pow(k);
return tmp;
}
// n!
Modulo fact(long long n, long long p = default_mod,
long long init_size = 1e+6) {
static bool is_init = false;
static std::vector<long long> dat;
if (!is_init) {
is_init = true;
dat.resize(init_size);
dat[0] = 1;
for (int i = 1; i < init_size; i++)
dat[i] = dat[i - 1] * i % p;
}
return Modulo(dat[n], p);
}
// 1/n!
Modulo ifact(long long n, long long p = default_mod,
long long init_size = 1e+6) {
static bool is_init = false;
static std::vector<long long> dat;
if (!is_init) {
is_init = true;
dat.resize(init_size);
dat[0] = 1;
for (int i = 1; i < init_size; i++)
dat[i] = (Modulo(dat[i - 1], p) / i).n;
}
return Modulo(dat[n], p);
}
// initialize
void initFact(long long init_size, long long p = default_mod) {
fact(0, p, init_size);
ifact(0, p, init_size);
}
// nCk
Modulo comb(long long n, long long k, long long p = default_mod) {
Modulo a = fact(n, p);
Modulo b = ifact(k, p);
Modulo c = ifact(n - k, p);
return a * b * c;
}
// ax + by = d
template <class T> T ext_gcd(T a, T b, T &x, T &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
T d = ext_gcd(b, a % b, x, y);
T x_ = x;
x = y;
y = x_ - a / b * y;
return d;
}
int main() {
ll r1, r2, c1, c2;
cin >> r1 >> c1 >> r2 >> c2;
Modulo ans = 0;
initFact(2e6 + 10);
for (int i = r1; i <= r2; i++) {
ans += ifact(i + 1) *
(fact(c2 + i + 1) * ifact(c2) - fact(c1 + i) * ifact(c1 - 1));
}
cout << ans.n << endl;
} | replace | 248 | 249 | 248 | 249 | 0 | |
p02782 | C++ | Runtime Error | #include <algorithm>
#include <bitset>
#include <cassert>
#include <climits>
#include <cmath>
#include <complex>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
#define REP(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define FOR(i, a, b) for (int(i) = (a); (i) < (b); (i)++)
#define RREP(i, a) for (int(i) = (a)-1; (i) >= 0; (i)--)
#define FORR(i, a, b) for (int(i) = (a)-1; (i) >= (b); (i)--)
#define DEBUG(C) cerr << #C << " = " << C << endl;
using LL = long long;
using VI = vector<int>;
using VVI = vector<VI>;
using VL = vector<LL>;
using VVL = vector<VL>;
using VD = vector<double>;
using VVD = vector<VD>;
using PII = pair<int, int>;
using PDD = pair<double, double>;
using PLL = pair<LL, LL>;
using VPII = vector<PII>;
template <typename T> using VT = vector<T>;
#define ALL(a) begin((a)), end((a))
#define RALL(a) rbegin((a)), rend((a))
#define SORT(a) sort(ALL((a)))
#define RSORT(a) sort(RALL((a)))
#define REVERSE(a) reverse(ALL((a)))
#define MP make_pair
#define FORE(a, b) for (auto &&a : (b))
#define EB emplace_back
#define GREATER(T) T, VT<T> greater<T>
template <typename T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
const int INF = 1e9;
const int MOD = INF + 7;
const LL LLINF = 1e18;
const int MAX = 1e6 + 10;
template <int mod> class mod_calc {
private:
const int defnum = -1;
public:
mod_calc() {}
const inline int add(int a, const int b) const {
a += b;
while (a < 0)
a += mod;
while (a >= mod)
a -= mod;
return a;
}
const inline int mul(const int a, const int b) const {
return (long long)a * b % mod;
}
const inline void add_ref(int &a, const int b) const { a = this->add(a, b); }
const inline void mul_ref(int &a, const int b) const { a = this->mul(a, b); }
const inline void add_ref(long long &a, const int b) const {
a = this->add(a, b);
}
const inline void mul_ref(long long &a, const int b) const {
a = this->mul(a, b);
}
const inline int pow(int a, int p) const {
int res = 1;
while (p > 0) {
if (p & 1)
res = this->mul(res, a);
a = this->mul(a, a);
p >>= 1;
}
return res;
}
const inline int inverse(int a) const { return this->pow(a, mod - 2); }
};
mod_calc<MOD> mc;
int memo_fact[MAX], memo_inv_fact[MAX];
inline int fact(int n) {
if (memo_fact[n] != -1)
return memo_fact[n];
return memo_fact[n] = (n == 0 ? 1 : mc.mul(n, fact(n - 1)));
}
inline int inv_fact(int n) {
if (memo_inv_fact[n] != -1)
return memo_inv_fact[n];
return memo_inv_fact[n] = mc.inverse(fact(n));
}
inline long long perm(int n, int r) { return mc.mul(fact(n), inv_fact(n - r)); }
inline long long comb(int n, int r) {
return mc.mul(mc.mul(fact(n), inv_fact(r)), inv_fact(n - r));
}
// M個の物をN人で分ける
inline long long comb_with_repetition(int M, int N) {
return comb(M + N - 1, N - 1);
}
// 最初に呼んで♪ O(MAX)
inline void init() {
memset(memo_fact, -1, sizeof(memo_fact));
memset(memo_inv_fact, -1, sizeof(memo_inv_fact));
for (int i = 0; i < MAX; i++) {
fact(i);
inv_fact(i);
}
}
int fast_resolve(int r, int c) {
int ans = 0;
REP(i, r) { mc.add_ref(ans, comb(i + c, i + 1)); }
return ans;
}
int main(void) {
init();
int r1, c1, r2, c2;
cin >> r1 >> c1 >> r2 >> c2;
const auto tmp1 = fast_resolve(r2 + 1, c2 + 1);
const auto tmp2 = fast_resolve(r2 + 1, c1);
const auto tmp3 = fast_resolve(r1, c2 + 1);
const auto tmp4 = fast_resolve(r1, c1);
cout << mc.add(mc.add(tmp1, mc.add(-tmp2, -tmp3)), tmp4) << endl;
}
| #include <algorithm>
#include <bitset>
#include <cassert>
#include <climits>
#include <cmath>
#include <complex>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
#define REP(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define FOR(i, a, b) for (int(i) = (a); (i) < (b); (i)++)
#define RREP(i, a) for (int(i) = (a)-1; (i) >= 0; (i)--)
#define FORR(i, a, b) for (int(i) = (a)-1; (i) >= (b); (i)--)
#define DEBUG(C) cerr << #C << " = " << C << endl;
using LL = long long;
using VI = vector<int>;
using VVI = vector<VI>;
using VL = vector<LL>;
using VVL = vector<VL>;
using VD = vector<double>;
using VVD = vector<VD>;
using PII = pair<int, int>;
using PDD = pair<double, double>;
using PLL = pair<LL, LL>;
using VPII = vector<PII>;
template <typename T> using VT = vector<T>;
#define ALL(a) begin((a)), end((a))
#define RALL(a) rbegin((a)), rend((a))
#define SORT(a) sort(ALL((a)))
#define RSORT(a) sort(RALL((a)))
#define REVERSE(a) reverse(ALL((a)))
#define MP make_pair
#define FORE(a, b) for (auto &&a : (b))
#define EB emplace_back
#define GREATER(T) T, VT<T> greater<T>
template <typename T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
const int INF = 1e9;
const int MOD = INF + 7;
const LL LLINF = 1e18;
const int MAX = 2e6 + 10;
template <int mod> class mod_calc {
private:
const int defnum = -1;
public:
mod_calc() {}
const inline int add(int a, const int b) const {
a += b;
while (a < 0)
a += mod;
while (a >= mod)
a -= mod;
return a;
}
const inline int mul(const int a, const int b) const {
return (long long)a * b % mod;
}
const inline void add_ref(int &a, const int b) const { a = this->add(a, b); }
const inline void mul_ref(int &a, const int b) const { a = this->mul(a, b); }
const inline void add_ref(long long &a, const int b) const {
a = this->add(a, b);
}
const inline void mul_ref(long long &a, const int b) const {
a = this->mul(a, b);
}
const inline int pow(int a, int p) const {
int res = 1;
while (p > 0) {
if (p & 1)
res = this->mul(res, a);
a = this->mul(a, a);
p >>= 1;
}
return res;
}
const inline int inverse(int a) const { return this->pow(a, mod - 2); }
};
mod_calc<MOD> mc;
int memo_fact[MAX], memo_inv_fact[MAX];
inline int fact(int n) {
if (memo_fact[n] != -1)
return memo_fact[n];
return memo_fact[n] = (n == 0 ? 1 : mc.mul(n, fact(n - 1)));
}
inline int inv_fact(int n) {
if (memo_inv_fact[n] != -1)
return memo_inv_fact[n];
return memo_inv_fact[n] = mc.inverse(fact(n));
}
inline long long perm(int n, int r) { return mc.mul(fact(n), inv_fact(n - r)); }
inline long long comb(int n, int r) {
return mc.mul(mc.mul(fact(n), inv_fact(r)), inv_fact(n - r));
}
// M個の物をN人で分ける
inline long long comb_with_repetition(int M, int N) {
return comb(M + N - 1, N - 1);
}
// 最初に呼んで♪ O(MAX)
inline void init() {
memset(memo_fact, -1, sizeof(memo_fact));
memset(memo_inv_fact, -1, sizeof(memo_inv_fact));
for (int i = 0; i < MAX; i++) {
fact(i);
inv_fact(i);
}
}
int fast_resolve(int r, int c) {
int ans = 0;
REP(i, r) { mc.add_ref(ans, comb(i + c, i + 1)); }
return ans;
}
int main(void) {
init();
int r1, c1, r2, c2;
cin >> r1 >> c1 >> r2 >> c2;
const auto tmp1 = fast_resolve(r2 + 1, c2 + 1);
const auto tmp2 = fast_resolve(r2 + 1, c1);
const auto tmp3 = fast_resolve(r1, c2 + 1);
const auto tmp4 = fast_resolve(r1, c1);
cout << mc.add(mc.add(tmp1, mc.add(-tmp2, -tmp3)), tmp4) << endl;
}
| replace | 75 | 76 | 75 | 76 | 0 | |
p02782 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
const int nmax = 1e6 + 5;
const int mod = 1e9 + 7;
int fact[nmax + 1], invfact[nmax + 1];
int modpow(int x, int y) {
int ans = 1;
while (y) {
if (y & 1)
ans = (1LL * ans * x) % mod;
x = (1LL * x * x) % mod;
y >>= 1;
}
return ans;
}
int nCr(int n, int r) {
if (r > n)
return 0;
return (1LL * ((1LL * fact[n] * invfact[r]) % mod) * invfact[n - r]) % mod;
}
void preprocess() {
fact[0] = 1;
for (int i = 1; i <= nmax; i++) {
fact[i] = (1LL * i * fact[i - 1]) % mod;
}
invfact[nmax] = modpow(fact[nmax], mod - 2);
for (int i = nmax - 1; i >= 0; i--) {
invfact[i] = (1LL * (i + 1) * invfact[i + 1]) % mod;
}
}
int main() {
int r1, c1, r2, c2;
cin >> r1 >> c1 >> r2 >> c2;
preprocess();
long long ans = 0;
for (int i = r1; i <= r2; i++) {
ans += nCr(i + c2 + 1, i + 1);
ans -= nCr(i + c1, i + 1);
ans = (ans + mod) % mod;
}
cout << ans << "\n";
} | #include <bits/stdc++.h>
using namespace std;
const int nmax = 2e6 + 5;
const int mod = 1e9 + 7;
int fact[nmax + 1], invfact[nmax + 1];
int modpow(int x, int y) {
int ans = 1;
while (y) {
if (y & 1)
ans = (1LL * ans * x) % mod;
x = (1LL * x * x) % mod;
y >>= 1;
}
return ans;
}
int nCr(int n, int r) {
if (r > n)
return 0;
return (1LL * ((1LL * fact[n] * invfact[r]) % mod) * invfact[n - r]) % mod;
}
void preprocess() {
fact[0] = 1;
for (int i = 1; i <= nmax; i++) {
fact[i] = (1LL * i * fact[i - 1]) % mod;
}
invfact[nmax] = modpow(fact[nmax], mod - 2);
for (int i = nmax - 1; i >= 0; i--) {
invfact[i] = (1LL * (i + 1) * invfact[i + 1]) % mod;
}
}
int main() {
int r1, c1, r2, c2;
cin >> r1 >> c1 >> r2 >> c2;
preprocess();
long long ans = 0;
for (int i = r1; i <= r2; i++) {
ans += nCr(i + c2 + 1, i + 1);
ans -= nCr(i + c1, i + 1);
ans = (ans + mod) % mod;
}
cout << ans << "\n";
} | replace | 2 | 3 | 2 | 3 | 0 | |
p02782 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
#include <numeric>
#include <string>
#include <vector>
#define REP(i, a, b) for (int i = int(a); i < int(b); i++)
using namespace std;
typedef long long int ll;
// clang-format off
#ifdef _DEBUG_
#define dump(...) do{ cerr << __LINE__ << ":\t" << #__VA_ARGS__ << " = "; PPPPP(__VA_ARGS__); cerr << endl; } while(false)
template<typename T> void PPPPP(T t) { cerr << t; }
template<typename T, typename... S> void PPPPP(T t, S... s) { cerr << t << ", "; PPPPP(s...); }
#else
#define dump(...)
#endif
template<typename T> vector<T> make_v(size_t a, T b) { return vector<T>(a, b); }
template<typename... Ts> auto make_v(size_t a, Ts... ts) { return vector<decltype(make_v(ts...))>(a, make_v(ts...)); }
template<typename T>
bool chmin(T &a, T b) { if (a > b) {a = b; return true; } return false;}
template<typename T>
bool chmax(T &a, T b) { if (a < b) {a = b; return true; } return false;}
// clang-format on
template <ll MOD = 1000000007> class ModInt {
ll n;
static constexpr ModInt pow(const ModInt x, ll p) {
ModInt<MOD> ans = 1;
for (ModInt<MOD> m = x; p > 0; p /= 2, m *= m) {
if (p % 2)
ans *= m;
}
return ans;
}
ModInt constexpr inverse() const { return ModInt::pow(*this, MOD - 2); }
public:
ModInt() : n(0) {}
ModInt(ll _n) : n(((_n % MOD) + MOD) % MOD) {}
ModInt operator+=(const ModInt &m) {
n += m.n;
if (n >= MOD)
n -= MOD;
return *this;
}
ModInt operator-=(const ModInt &m) {
n -= m.n;
if (n < 0)
n += MOD;
return *this;
}
ModInt operator*=(const ModInt &m) {
n *= m.n;
if (n >= MOD)
n %= MOD;
return *this;
}
ModInt operator/=(const ModInt &m) {
(*this) *= m.inverse();
return *this;
}
friend ModInt operator+(ModInt t, const ModInt &m) { return t += m; }
friend ModInt operator-(ModInt t, const ModInt &m) { return t -= m; }
friend ModInt operator*(ModInt t, const ModInt &m) { return t *= m; }
friend ModInt operator/(ModInt t, const ModInt &m) { return t /= m; }
ModInt operator=(const ll l) {
n = l % MOD;
if (n < 0)
n += MOD;
return *this;
}
friend ostream &operator<<(ostream &out, const ModInt &m) {
out << m.n;
return out;
}
friend istream &operator>>(istream &in, ModInt &m) {
ll l;
in >> l;
m = l;
return in;
}
};
using mint = ModInt<>;
mint operator"" _m(unsigned long long m) { return mint(m); }
int SZ = 1000010;
vector<mint> fact(SZ, 1);
mint nCr(int n, int r) { return fact[n] / fact[r] / fact[n - r]; }
mint calc(int r, int c) {
return (nCr(c + r + 2, r) * (c + 2) - r - 1) / (r + 1);
}
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
REP(i, 0, SZ - 1) { fact[i + 1] = fact[i] * (i + 1); }
int r1, c1, r2, c2;
cin >> r1 >> c1 >> r2 >> c2;
cout << calc(r2, c2) - calc(r1 - 1, c2) - calc(r2, c1 - 1) +
calc(r1 - 1, c1 - 1)
<< endl;
return 0;
}
| #include <algorithm>
#include <iostream>
#include <numeric>
#include <string>
#include <vector>
#define REP(i, a, b) for (int i = int(a); i < int(b); i++)
using namespace std;
typedef long long int ll;
// clang-format off
#ifdef _DEBUG_
#define dump(...) do{ cerr << __LINE__ << ":\t" << #__VA_ARGS__ << " = "; PPPPP(__VA_ARGS__); cerr << endl; } while(false)
template<typename T> void PPPPP(T t) { cerr << t; }
template<typename T, typename... S> void PPPPP(T t, S... s) { cerr << t << ", "; PPPPP(s...); }
#else
#define dump(...)
#endif
template<typename T> vector<T> make_v(size_t a, T b) { return vector<T>(a, b); }
template<typename... Ts> auto make_v(size_t a, Ts... ts) { return vector<decltype(make_v(ts...))>(a, make_v(ts...)); }
template<typename T>
bool chmin(T &a, T b) { if (a > b) {a = b; return true; } return false;}
template<typename T>
bool chmax(T &a, T b) { if (a < b) {a = b; return true; } return false;}
// clang-format on
template <ll MOD = 1000000007> class ModInt {
ll n;
static constexpr ModInt pow(const ModInt x, ll p) {
ModInt<MOD> ans = 1;
for (ModInt<MOD> m = x; p > 0; p /= 2, m *= m) {
if (p % 2)
ans *= m;
}
return ans;
}
ModInt constexpr inverse() const { return ModInt::pow(*this, MOD - 2); }
public:
ModInt() : n(0) {}
ModInt(ll _n) : n(((_n % MOD) + MOD) % MOD) {}
ModInt operator+=(const ModInt &m) {
n += m.n;
if (n >= MOD)
n -= MOD;
return *this;
}
ModInt operator-=(const ModInt &m) {
n -= m.n;
if (n < 0)
n += MOD;
return *this;
}
ModInt operator*=(const ModInt &m) {
n *= m.n;
if (n >= MOD)
n %= MOD;
return *this;
}
ModInt operator/=(const ModInt &m) {
(*this) *= m.inverse();
return *this;
}
friend ModInt operator+(ModInt t, const ModInt &m) { return t += m; }
friend ModInt operator-(ModInt t, const ModInt &m) { return t -= m; }
friend ModInt operator*(ModInt t, const ModInt &m) { return t *= m; }
friend ModInt operator/(ModInt t, const ModInt &m) { return t /= m; }
ModInt operator=(const ll l) {
n = l % MOD;
if (n < 0)
n += MOD;
return *this;
}
friend ostream &operator<<(ostream &out, const ModInt &m) {
out << m.n;
return out;
}
friend istream &operator>>(istream &in, ModInt &m) {
ll l;
in >> l;
m = l;
return in;
}
};
using mint = ModInt<>;
mint operator"" _m(unsigned long long m) { return mint(m); }
int SZ = 2000200;
vector<mint> fact(SZ, 1);
mint nCr(int n, int r) { return fact[n] / fact[r] / fact[n - r]; }
mint calc(int r, int c) {
return (nCr(c + r + 2, r) * (c + 2) - r - 1) / (r + 1);
}
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
REP(i, 0, SZ - 1) { fact[i + 1] = fact[i] * (i + 1); }
int r1, c1, r2, c2;
cin >> r1 >> c1 >> r2 >> c2;
cout << calc(r2, c2) - calc(r1 - 1, c2) - calc(r2, c1 - 1) +
calc(r1 - 1, c1 - 1)
<< endl;
return 0;
}
| replace | 87 | 88 | 87 | 88 | 0 | |
p02782 | C++ | Runtime Error | #include "bits/stdc++.h"
using namespace std;
vector<long long> F, RF, R;
long long MOD = 1000000007;
void init(long long N) {
F.resize(N + 1);
RF.resize(N + 1);
R.resize(N + 1);
F[0] = F[1] = RF[0] = RF[1] = R[0] = R[1] = 1;
for (int i = 2; i <= N; i++) {
F[i] = (F[i - 1] * i) % MOD;
R[i] = MOD - (R[MOD % i] * (MOD / i)) % MOD;
RF[i] = (RF[i - 1] * R[i]) % MOD;
}
}
long long Comb(long long N, long long M) {
return (F[N] * ((RF[N - M] * RF[M]) % MOD)) % MOD;
}
int main() {
long long R1, C1, R2, C2;
cin >> R1 >> C1 >> R2 >> C2;
R2++, C2++;
init(200000);
long long ANS = 0;
ANS += Comb(R1 + C1, R1) - 1;
ANS += Comb(R2 + C2, R2) - 1;
ANS -= Comb(R1 + C2, R1) - 1;
ANS -= Comb(R2 + C1, R2) - 1;
ANS += MOD * 2;
cout << ANS % MOD << endl;
} | #include "bits/stdc++.h"
using namespace std;
vector<long long> F, RF, R;
long long MOD = 1000000007;
void init(long long N) {
F.resize(N + 1);
RF.resize(N + 1);
R.resize(N + 1);
F[0] = F[1] = RF[0] = RF[1] = R[0] = R[1] = 1;
for (int i = 2; i <= N; i++) {
F[i] = (F[i - 1] * i) % MOD;
R[i] = MOD - (R[MOD % i] * (MOD / i)) % MOD;
RF[i] = (RF[i - 1] * R[i]) % MOD;
}
}
long long Comb(long long N, long long M) {
return (F[N] * ((RF[N - M] * RF[M]) % MOD)) % MOD;
}
int main() {
long long R1, C1, R2, C2;
cin >> R1 >> C1 >> R2 >> C2;
R2++, C2++;
init(2000010);
long long ANS = 0;
ANS += Comb(R1 + C1, R1) - 1;
ANS += Comb(R2 + C2, R2) - 1;
ANS -= Comb(R1 + C2, R1) - 1;
ANS -= Comb(R2 + C1, R2) - 1;
ANS += MOD * 2;
cout << ANS % MOD << endl;
} | replace | 26 | 27 | 26 | 27 | 0 | |
p02782 | C++ | Memory Limit Exceeded | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define sz(x) int(x.size())
using namespace std;
typedef long long ll;
// auto mod int
// https://youtu.be/L8grWxBlIZ4?t=9858
// https://youtu.be/ERZuLAxZffQ?t=4807 : optimize
// https://youtu.be/8uowVvQ_-Mo?t=1329 : division
const int mod = 1000000007;
struct mint {
ll x; // typedef long long ll;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
mint operator-() const { return mint(-x); }
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const {
mint res(*this);
return res += a;
}
mint operator-(const mint a) const {
mint res(*this);
return res -= a;
}
mint operator*(const mint a) const {
mint res(*this);
return res *= a;
}
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
// for prime mod
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint a) { return (*this) *= a.inv(); }
mint operator/(const mint a) const {
mint res(*this);
return res /= a;
}
};
struct combination {
vector<mint> fact, ifact;
combination(int n) : fact(n + 1), ifact(n + 1) {
assert(n < mod);
fact[0] = 1;
for (int i = 1; i <= n; ++i)
fact[i] = fact[i - 1] * i;
ifact[n] = fact[n].inv();
for (int i = n; i >= 1; --i)
ifact[i - 1] = ifact[i] * i;
}
mint operator()(int n, int k) {
if (k < 0 || k > n)
return 0;
return fact[n] * ifact[k] * ifact[n - k];
}
} comb(1e8);
int c1, r1, c2, r2;
mint g(int r, int c) { return comb(c + r + 2, r + 1); }
int main() {
cin >> r1 >> c1 >> r2 >> c2;
c1--;
r1--;
mint ans = 0;
ans += g(r2, c2);
ans -= g(r1, c2);
ans -= g(r2, c1);
ans += g(r1, c1);
cout << ans.x << endl;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define sz(x) int(x.size())
using namespace std;
typedef long long ll;
// auto mod int
// https://youtu.be/L8grWxBlIZ4?t=9858
// https://youtu.be/ERZuLAxZffQ?t=4807 : optimize
// https://youtu.be/8uowVvQ_-Mo?t=1329 : division
const int mod = 1000000007;
struct mint {
ll x; // typedef long long ll;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
mint operator-() const { return mint(-x); }
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const {
mint res(*this);
return res += a;
}
mint operator-(const mint a) const {
mint res(*this);
return res -= a;
}
mint operator*(const mint a) const {
mint res(*this);
return res *= a;
}
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
// for prime mod
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint a) { return (*this) *= a.inv(); }
mint operator/(const mint a) const {
mint res(*this);
return res /= a;
}
};
struct combination {
vector<mint> fact, ifact;
combination(int n) : fact(n + 1), ifact(n + 1) {
assert(n < mod);
fact[0] = 1;
for (int i = 1; i <= n; ++i)
fact[i] = fact[i - 1] * i;
ifact[n] = fact[n].inv();
for (int i = n; i >= 1; --i)
ifact[i - 1] = ifact[i] * i;
}
mint operator()(int n, int k) {
if (k < 0 || k > n)
return 0;
return fact[n] * ifact[k] * ifact[n - k];
}
} comb(1e7);
int c1, r1, c2, r2;
mint g(int r, int c) { return comb(c + r + 2, r + 1); }
int main() {
cin >> r1 >> c1 >> r2 >> c2;
c1--;
r1--;
mint ans = 0;
ans += g(r2, c2);
ans -= g(r1, c2);
ans -= g(r2, c1);
ans += g(r1, c1);
cout << ans.x << endl;
} | replace | 77 | 78 | 77 | 78 | MLE | |
p02782 | C++ | Runtime Error | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define sz(x) int(x.size())
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const ll INF = 1LL << 60;
const int mod = 1e9 + 7;
struct mint {
ll x; // typedef long long ll;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
mint operator-() const { return mint(-x); }
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const { return mint(*this) += a; }
mint operator-(const mint a) const { return mint(*this) -= a; }
mint operator*(const mint a) const { return mint(*this) *= a; }
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
// for prime mod
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint a) { return *this *= a.inv(); }
mint operator/(const mint a) const { return mint(*this) /= a; }
};
istream &operator>>(istream &is, const mint &a) { return is >> a.x; }
ostream &operator<<(ostream &os, const mint &a) { return os << a.x; }
struct combination {
vector<mint> fact, ifact;
combination(int n) : fact(n + 1), ifact(n + 1) {
assert(n < mod);
fact[0] = 1;
for (int i = 1; i <= n; ++i)
fact[i] = fact[i - 1] * i;
ifact[n] = fact[n].inv();
for (int i = n; i >= 1; --i)
ifact[i - 1] = ifact[i] * i;
}
mint operator()(int n, int k) {
if (k < 0 || k > n)
return 0;
return fact[n] * ifact[k] * ifact[n - k];
}
} comb(1e6 + 10);
ll r1, c1, r2, c2;
mint f(ll r, ll c) { return comb(r + c + 2, r + 1) - 1; }
int main() {
cin >> r1 >> c1 >> r2 >> c2;
r1--;
c1--;
mint ans = f(r2, c2);
ans -= f(r1, c2);
ans -= f(r2, c1);
ans += f(r1, c1);
cout << ans << endl;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define sz(x) int(x.size())
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const ll INF = 1LL << 60;
const int mod = 1e9 + 7;
struct mint {
ll x; // typedef long long ll;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
mint operator-() const { return mint(-x); }
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const { return mint(*this) += a; }
mint operator-(const mint a) const { return mint(*this) -= a; }
mint operator*(const mint a) const { return mint(*this) *= a; }
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
// for prime mod
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint a) { return *this *= a.inv(); }
mint operator/(const mint a) const { return mint(*this) /= a; }
};
istream &operator>>(istream &is, const mint &a) { return is >> a.x; }
ostream &operator<<(ostream &os, const mint &a) { return os << a.x; }
struct combination {
vector<mint> fact, ifact;
combination(int n) : fact(n + 1), ifact(n + 1) {
assert(n < mod);
fact[0] = 1;
for (int i = 1; i <= n; ++i)
fact[i] = fact[i - 1] * i;
ifact[n] = fact[n].inv();
for (int i = n; i >= 1; --i)
ifact[i - 1] = ifact[i] * i;
}
mint operator()(int n, int k) {
if (k < 0 || k > n)
return 0;
return fact[n] * ifact[k] * ifact[n - k];
}
} comb(2e6 + 10);
ll r1, c1, r2, c2;
mint f(ll r, ll c) { return comb(r + c + 2, r + 1) - 1; }
int main() {
cin >> r1 >> c1 >> r2 >> c2;
r1--;
c1--;
mint ans = f(r2, c2);
ans -= f(r1, c2);
ans -= f(r2, c1);
ans += f(r1, c1);
cout << ans << endl;
} | replace | 66 | 67 | 66 | 67 | 0 | |
p02782 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) FOR(i, 0, (n))
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define LAR(a, b) ((a) = max((a), (b)))
#define SML(a, b) ((a) = min((a), (b)))
using ll = long long;
using ld = long double;
using vi = vector<int>;
using vl = vector<ll>;
using pii = pair<int, int>;
using vpii = vector<pair<int, int>>;
template <typename T> using pque = priority_queue<T, vector<T>, greater<T>>;
#define PB push_back
#define EB emplace_back
#define MP make_pair
#define ALL(a) (a).begin(), (a).end()
#ifdef LOCAL_DEBUG
#define DEBUG(...) printf(__VA_ARGS__)
#else
#define DEBUG(...)
#endif
#define MOD 1'000'000'007LL
#define N 212345
ll fct[N] = {1};
ll fctinv[N];
ll pw(ll a, ll b) {
ll c = 1;
do {
if (b & 1)
c = c * a % MOD;
a = a * a % MOD;
} while (b /= 2);
return c;
}
ll inv(ll a) { return pw(a, MOD - 2); }
ll cmb(ll a, ll b) { return fct[a] * fctinv[b] % MOD * fctinv[a - b] % MOD; }
ll g(ll a, ll b) {
ll tmp = 0, sm = 0;
REP(i, b) {
tmp = tmp * 2 + cmb(a + i, i);
tmp %= MOD;
sm += tmp;
sm %= MOD;
DEBUG(" %d %lld %lld\n", i, tmp, sm);
}
DEBUG(" g(%lld, %lld) = %lld\n", a, b, sm);
return sm;
}
ll f(ll a, ll b) {
ll ret = (pw(2, a + b + 1) + MOD - 1) % MOD;
DEBUG(" 2^() = %lld\n", ret);
ret = (ret + MOD - g(a, b)) % MOD;
ret = (ret + MOD - g(b, a)) % MOD;
DEBUG("f(%lld, %lld) = %lld\n", a, b, ret);
return ret;
}
int main() {
FOR(i, 1, N) fct[i] = fct[i - 1] * i % MOD;
REP(i, N) fctinv[i] = inv(fct[i]);
ll a, b, c, d;
scanf("%lld%lld%lld%lld", &a, &b, &c, &d);
a--;
b--;
ll ans = f(c, d) - f(a, d) - f(c, b) + f(a, b);
ans = (ans + MOD * 3) % MOD;
printf("%lld\n", ans);
}
| #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) FOR(i, 0, (n))
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define LAR(a, b) ((a) = max((a), (b)))
#define SML(a, b) ((a) = min((a), (b)))
using ll = long long;
using ld = long double;
using vi = vector<int>;
using vl = vector<ll>;
using pii = pair<int, int>;
using vpii = vector<pair<int, int>>;
template <typename T> using pque = priority_queue<T, vector<T>, greater<T>>;
#define PB push_back
#define EB emplace_back
#define MP make_pair
#define ALL(a) (a).begin(), (a).end()
#ifdef LOCAL_DEBUG
#define DEBUG(...) printf(__VA_ARGS__)
#else
#define DEBUG(...)
#endif
#define MOD 1'000'000'007LL
#define N 2123456
ll fct[N] = {1};
ll fctinv[N];
ll pw(ll a, ll b) {
ll c = 1;
do {
if (b & 1)
c = c * a % MOD;
a = a * a % MOD;
} while (b /= 2);
return c;
}
ll inv(ll a) { return pw(a, MOD - 2); }
ll cmb(ll a, ll b) { return fct[a] * fctinv[b] % MOD * fctinv[a - b] % MOD; }
ll g(ll a, ll b) {
ll tmp = 0, sm = 0;
REP(i, b) {
tmp = tmp * 2 + cmb(a + i, i);
tmp %= MOD;
sm += tmp;
sm %= MOD;
DEBUG(" %d %lld %lld\n", i, tmp, sm);
}
DEBUG(" g(%lld, %lld) = %lld\n", a, b, sm);
return sm;
}
ll f(ll a, ll b) {
ll ret = (pw(2, a + b + 1) + MOD - 1) % MOD;
DEBUG(" 2^() = %lld\n", ret);
ret = (ret + MOD - g(a, b)) % MOD;
ret = (ret + MOD - g(b, a)) % MOD;
DEBUG("f(%lld, %lld) = %lld\n", a, b, ret);
return ret;
}
int main() {
FOR(i, 1, N) fct[i] = fct[i - 1] * i % MOD;
REP(i, N) fctinv[i] = inv(fct[i]);
ll a, b, c, d;
scanf("%lld%lld%lld%lld", &a, &b, &c, &d);
a--;
b--;
ll ans = f(c, d) - f(a, d) - f(c, b) + f(a, b);
ans = (ans + MOD * 3) % MOD;
printf("%lld\n", ans);
}
| replace | 24 | 25 | 24 | 25 | 0 | |
p02782 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep1(i, n) for (int i = 1; i <= (n); i++)
#define show(a, n) \
rep(i, n) { cout << a[i] << ' '; } \
cout << endl;
using namespace std;
typedef vector<int> vi;
typedef pair<int, int> pii;
typedef long long ll;
typedef pair<long long, long long> pll;
const int INF = 1 << 30;
const long long INFL = 1LL << 62;
const int MOD = 1000000007;
const int MAX = 100000;
const int N = 100010;
struct mint {
ll x;
mint(ll x = 0) : x((x % MOD + MOD) % MOD) {}
mint operator-() const { return mint(-x); }
mint &operator+=(const mint a) {
if ((x += a.x) >= MOD)
x -= MOD;
return *this;
}
mint &operator-=(const mint a) {
if ((x += MOD - a.x) >= MOD)
x -= MOD;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= MOD;
return *this;
}
mint operator+(const mint a) const {
mint res(*this);
return res += a;
}
mint operator-(const mint a) const {
mint res(*this);
return res -= a;
}
mint operator*(const mint a) const {
mint res(*this);
return res *= a;
}
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
// for prime mod
mint inv() const { return pow(MOD - 2); }
mint &operator/=(const mint a) { return (*this) *= a.inv(); }
mint operator/(const mint a) const {
mint res(*this);
return res /= a;
}
};
const int cmax = 1000010;
mint fac[cmax], finv[cmax], inv[cmax];
void com_init() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < cmax; i++) {
fac[i] = fac[i - 1] * i;
inv[i] = -inv[MOD % i] * (MOD / i);
finv[i] = finv[i - 1] * inv[i];
}
}
mint com(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
mint ret = fac[n] * finv[k] * finv[n - k];
return ret;
}
mint path(int r, int c) { return com(r + c + 2, c + 1) - 1; }
int main() {
ll r1, c1, r2, c2;
cin >> r1 >> c1 >> r2 >> c2;
mint ans = 0;
com_init();
ans =
path(r2, c2) - path(r1 - 1, c2) - path(r2, c1 - 1) + path(r1 - 1, c1 - 1);
cout << ans.x << endl;
}
| #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep1(i, n) for (int i = 1; i <= (n); i++)
#define show(a, n) \
rep(i, n) { cout << a[i] << ' '; } \
cout << endl;
using namespace std;
typedef vector<int> vi;
typedef pair<int, int> pii;
typedef long long ll;
typedef pair<long long, long long> pll;
const int INF = 1 << 30;
const long long INFL = 1LL << 62;
const int MOD = 1000000007;
const int MAX = 100000;
const int N = 100010;
struct mint {
ll x;
mint(ll x = 0) : x((x % MOD + MOD) % MOD) {}
mint operator-() const { return mint(-x); }
mint &operator+=(const mint a) {
if ((x += a.x) >= MOD)
x -= MOD;
return *this;
}
mint &operator-=(const mint a) {
if ((x += MOD - a.x) >= MOD)
x -= MOD;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= MOD;
return *this;
}
mint operator+(const mint a) const {
mint res(*this);
return res += a;
}
mint operator-(const mint a) const {
mint res(*this);
return res -= a;
}
mint operator*(const mint a) const {
mint res(*this);
return res *= a;
}
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
// for prime mod
mint inv() const { return pow(MOD - 2); }
mint &operator/=(const mint a) { return (*this) *= a.inv(); }
mint operator/(const mint a) const {
mint res(*this);
return res /= a;
}
};
const int cmax = 2000010;
mint fac[cmax], finv[cmax], inv[cmax];
void com_init() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < cmax; i++) {
fac[i] = fac[i - 1] * i;
inv[i] = -inv[MOD % i] * (MOD / i);
finv[i] = finv[i - 1] * inv[i];
}
}
mint com(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
mint ret = fac[n] * finv[k] * finv[n - k];
return ret;
}
mint path(int r, int c) { return com(r + c + 2, c + 1) - 1; }
int main() {
ll r1, c1, r2, c2;
cin >> r1 >> c1 >> r2 >> c2;
mint ans = 0;
com_init();
ans =
path(r2, c2) - path(r1 - 1, c2) - path(r2, c1 - 1) + path(r1 - 1, c1 - 1);
cout << ans.x << endl;
}
| replace | 84 | 85 | 84 | 85 | 0 | |
p02782 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
namespace {
constexpr size_t MOD = 1e9 + 7;
constexpr size_t MAX = 1e6 + 2;
size_t mod_pow(size_t x, size_t p) {
size_t u = x;
size_t t = 1;
while (p) {
if (p & 1) {
t = t * u % MOD;
}
u = u * u % MOD;
p >>= 1;
}
return t;
}
size_t mod_inv(size_t x) { return mod_pow(x, MOD - 2); }
vector<size_t> fact(MAX + 1), ifact(MAX + 1);
void init() {
fact[0] = 1;
for (size_t i = 1; i <= MAX; i++) {
fact[i] = fact[i - 1] * i % MOD;
}
ifact[MAX] = mod_inv(fact[MAX]);
for (long long i = MAX - 1; i >= 0; i--) {
ifact[i] = ifact[i + 1] * (i + 1) % MOD;
}
}
size_t mod_cmb(size_t x, size_t y) {
return fact[x] * ifact[x - y] % MOD * ifact[y] % MOD;
}
} // namespace
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
init();
int r1, r2, c1, c2;
cin >> r1 >> c1 >> r2 >> c2;
auto f = [&](int r, int c) { return mod_cmb(r + c, c); };
auto g = [&](int r, int c) { return f(r + 1, c + 1) - f(r, 0); };
auto ans = g(r2, c2);
ans = ans + MOD - g(r1 - 1, c2);
ans %= MOD;
ans = ans + MOD - g(r2, c1 - 1);
ans %= MOD;
ans = ans + g(r1 - 1, c1 - 1);
ans %= MOD;
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
namespace {
constexpr size_t MOD = 1e9 + 7;
constexpr size_t MAX = 2e6 + 2;
size_t mod_pow(size_t x, size_t p) {
size_t u = x;
size_t t = 1;
while (p) {
if (p & 1) {
t = t * u % MOD;
}
u = u * u % MOD;
p >>= 1;
}
return t;
}
size_t mod_inv(size_t x) { return mod_pow(x, MOD - 2); }
vector<size_t> fact(MAX + 1), ifact(MAX + 1);
void init() {
fact[0] = 1;
for (size_t i = 1; i <= MAX; i++) {
fact[i] = fact[i - 1] * i % MOD;
}
ifact[MAX] = mod_inv(fact[MAX]);
for (long long i = MAX - 1; i >= 0; i--) {
ifact[i] = ifact[i + 1] * (i + 1) % MOD;
}
}
size_t mod_cmb(size_t x, size_t y) {
return fact[x] * ifact[x - y] % MOD * ifact[y] % MOD;
}
} // namespace
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
init();
int r1, r2, c1, c2;
cin >> r1 >> c1 >> r2 >> c2;
auto f = [&](int r, int c) { return mod_cmb(r + c, c); };
auto g = [&](int r, int c) { return f(r + 1, c + 1) - f(r, 0); };
auto ans = g(r2, c2);
ans = ans + MOD - g(r1 - 1, c2);
ans %= MOD;
ans = ans + MOD - g(r2, c1 - 1);
ans %= MOD;
ans = ans + g(r1 - 1, c1 - 1);
ans %= MOD;
cout << ans << endl;
return 0;
}
| replace | 7 | 8 | 7 | 8 | 0 | |
p02782 | C++ | Runtime Error | #pragma GCC target("sse,sse2,sse3,ssse3,sse4")
#pragma GCC optimize("Ofast")
// #pragma GCC optimize("unroll-loops")
#include <list>
// hloya template v25
// ░░░░░░░▄▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄░░░░░░
// ░░░░░░█░░▄▀▀▀▀▀▀▀▀▀▀▀▀▀▄░░█░░░░░
// ░░░░░░█░█░▀░░░░░▀░░▀░░░░█░█░░░░░
// ░░░░░░█░█░░░░░░░░▄▀▀▄░▀░█░█▄▀▀▄░
// █▀▀█▄░█░█░░▀░░░░░█░░░▀▄▄█▄▀░░░█░
// ▀▄▄░▀██░█▄░▀░░░▄▄▀░░░░░░░░░░░░▀▄
// ░░▀█▄▄█░█░░░░▄░░█░░░▄█░░░▄░▄█░░█
// ░░░░░▀█░▀▄▀░░░░░█░██░▄░░▄░░▄░███
// ░░░░░▄█▄░░▀▀▀▀▀▀▀▀▄░░▀▀▀▀▀▀▀░▄▀░
// ░░░░█░░▄█▀█▀▀█▀▀▀▀▀▀█▀▀█▀█▀▀█░░░
// ░░░░▀▀▀▀░░▀▀▀░░░░░░░░▀▀▀░░▀▀░░░░
#include <bits/stdc++.h>
#include <valarray>
using namespace std;
bool dbg = 0;
clock_t start_time = clock();
#define current_time \
fixed << setprecision(6) << (ld)(clock() - start_time) / CLOCKS_PER_SEC
#define f first
#define s second
#define mp make_pair
#define pb push_back
#define all(x) (x).begin(), (x).end()
#define ll long long
#define ld long double
#define pii pair<int, int>
#define umap unordered_map<int, int>
#define files1 freopen("input.txt", "r", stdin)
#define files2 freopen("output.txt", "w", stdout)
#define files \
files1; \
files2
#define fast_io \
ios_base::sync_with_stdio(0); \
cin.tie(0)
#define endl '\n'
#define ln(i, n) " \n"[(i) == (n)-1]
void bad(string mes = "Impossible") {
cout << mes;
exit(0);
}
void bad(int mes) {
cout << mes;
exit(0);
}
template <typename T> string bin(T x, int st = 2) {
string ans = "";
while (x > 0) {
ans += char('0' + x % st);
x /= st;
}
reverse(ans.begin(), ans.end());
return ans.empty() ? "0" : ans;
}
template <typename T> void amax(T &x, T y) { x = max(x, y); }
template <typename T> void amin(T &x, T y) { x = min(x, y); }
// inline int popcount(int x){
// int count = 0;
// __asm__ volatile("POPCNT %1, %0;":"=r"(count):"r"(x):);
// return count;
// }
template <typename T> T input() {
T ans = 0, m = 1;
char c = ' ';
while (!((c >= '0' && c <= '9') || c == '-')) {
c = getchar();
}
if (c == '-')
m = -1, c = getchar();
while (c >= '0' && c <= '9') {
ans = ans * 10 + (c - '0'), c = getchar();
}
return ans * m;
}
template <typename T> void read(T &a) { a = input<T>(); }
template <typename T> void read(T &a, T &b) { read(a), read(b); }
template <typename T> void read(T &a, T &b, T &c) { read(a, b), read(c); }
template <typename T> void read(T &a, T &b, T &c, T &d) {
read(a, b), read(c, d);
}
const int inf = 1e9 + 20;
const short short_inf = 3e4 + 20;
const long double eps = 1e-12;
const int maxn = (int)1e6 + 12, base = 1e9 + 7;
const ll llinf = 1e18 + 5;
const double PI = acos(-1.0);
const int mod = base;
template <typename T> T binpow(T n, T s) {
if (s <= 0)
return 1LL;
if (s % 2 == 0) {
T b = binpow(n, s / 2);
return (1LL * b * b) % mod;
} else {
return (1LL * binpow(n, s - 1) * n) % mod;
}
}
int fact[maxn], inv[maxn];
int main() {
fast_io;
fact[0] = 1;
for (int i = 1; i < maxn; i++) {
fact[i] = 1ll * fact[i - 1] * i % mod;
}
inv[maxn - 1] = binpow(fact[maxn - 1], mod - 2);
for (int i = maxn - 2; i >= 0; i--) {
inv[i] = 1ll * inv[i + 1] * (i + 1) % mod;
}
auto c = [&](int n, int k) {
return 1ll * fact[n] * inv[k] % mod * inv[n - k] % mod;
};
int r1, c1, r2, c2;
cin >> r1 >> c1 >> r2 >> c2;
int res = 0;
for (int j = c1; j <= c2; j++) {
int l = j + r1, r = j + r2;
(res += (c(r + 1, j + 1) - c(l, j + 1) + mod) % mod) %= mod;
}
cout << res;
return 0;
} | #pragma GCC target("sse,sse2,sse3,ssse3,sse4")
#pragma GCC optimize("Ofast")
// #pragma GCC optimize("unroll-loops")
#include <list>
// hloya template v25
// ░░░░░░░▄▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄░░░░░░
// ░░░░░░█░░▄▀▀▀▀▀▀▀▀▀▀▀▀▀▄░░█░░░░░
// ░░░░░░█░█░▀░░░░░▀░░▀░░░░█░█░░░░░
// ░░░░░░█░█░░░░░░░░▄▀▀▄░▀░█░█▄▀▀▄░
// █▀▀█▄░█░█░░▀░░░░░█░░░▀▄▄█▄▀░░░█░
// ▀▄▄░▀██░█▄░▀░░░▄▄▀░░░░░░░░░░░░▀▄
// ░░▀█▄▄█░█░░░░▄░░█░░░▄█░░░▄░▄█░░█
// ░░░░░▀█░▀▄▀░░░░░█░██░▄░░▄░░▄░███
// ░░░░░▄█▄░░▀▀▀▀▀▀▀▀▄░░▀▀▀▀▀▀▀░▄▀░
// ░░░░█░░▄█▀█▀▀█▀▀▀▀▀▀█▀▀█▀█▀▀█░░░
// ░░░░▀▀▀▀░░▀▀▀░░░░░░░░▀▀▀░░▀▀░░░░
#include <bits/stdc++.h>
#include <valarray>
using namespace std;
bool dbg = 0;
clock_t start_time = clock();
#define current_time \
fixed << setprecision(6) << (ld)(clock() - start_time) / CLOCKS_PER_SEC
#define f first
#define s second
#define mp make_pair
#define pb push_back
#define all(x) (x).begin(), (x).end()
#define ll long long
#define ld long double
#define pii pair<int, int>
#define umap unordered_map<int, int>
#define files1 freopen("input.txt", "r", stdin)
#define files2 freopen("output.txt", "w", stdout)
#define files \
files1; \
files2
#define fast_io \
ios_base::sync_with_stdio(0); \
cin.tie(0)
#define endl '\n'
#define ln(i, n) " \n"[(i) == (n)-1]
void bad(string mes = "Impossible") {
cout << mes;
exit(0);
}
void bad(int mes) {
cout << mes;
exit(0);
}
template <typename T> string bin(T x, int st = 2) {
string ans = "";
while (x > 0) {
ans += char('0' + x % st);
x /= st;
}
reverse(ans.begin(), ans.end());
return ans.empty() ? "0" : ans;
}
template <typename T> void amax(T &x, T y) { x = max(x, y); }
template <typename T> void amin(T &x, T y) { x = min(x, y); }
// inline int popcount(int x){
// int count = 0;
// __asm__ volatile("POPCNT %1, %0;":"=r"(count):"r"(x):);
// return count;
// }
template <typename T> T input() {
T ans = 0, m = 1;
char c = ' ';
while (!((c >= '0' && c <= '9') || c == '-')) {
c = getchar();
}
if (c == '-')
m = -1, c = getchar();
while (c >= '0' && c <= '9') {
ans = ans * 10 + (c - '0'), c = getchar();
}
return ans * m;
}
template <typename T> void read(T &a) { a = input<T>(); }
template <typename T> void read(T &a, T &b) { read(a), read(b); }
template <typename T> void read(T &a, T &b, T &c) { read(a, b), read(c); }
template <typename T> void read(T &a, T &b, T &c, T &d) {
read(a, b), read(c, d);
}
const int inf = 1e9 + 20;
const short short_inf = 3e4 + 20;
const long double eps = 1e-12;
const int maxn = (int)2e6 + 12, base = 1e9 + 7;
const ll llinf = 1e18 + 5;
const double PI = acos(-1.0);
const int mod = base;
template <typename T> T binpow(T n, T s) {
if (s <= 0)
return 1LL;
if (s % 2 == 0) {
T b = binpow(n, s / 2);
return (1LL * b * b) % mod;
} else {
return (1LL * binpow(n, s - 1) * n) % mod;
}
}
int fact[maxn], inv[maxn];
int main() {
fast_io;
fact[0] = 1;
for (int i = 1; i < maxn; i++) {
fact[i] = 1ll * fact[i - 1] * i % mod;
}
inv[maxn - 1] = binpow(fact[maxn - 1], mod - 2);
for (int i = maxn - 2; i >= 0; i--) {
inv[i] = 1ll * inv[i + 1] * (i + 1) % mod;
}
auto c = [&](int n, int k) {
return 1ll * fact[n] * inv[k] % mod * inv[n - k] % mod;
};
int r1, c1, r2, c2;
cin >> r1 >> c1 >> r2 >> c2;
int res = 0;
for (int j = c1; j <= c2; j++) {
int l = j + r1, r = j + r2;
(res += (c(r + 1, j + 1) - c(l, j + 1) + mod) % mod) %= mod;
}
cout << res;
return 0;
} | replace | 107 | 108 | 107 | 108 | 0 | |
p02782 | C++ | Runtime Error | #include <bits/stdc++.h>
#define REP(i, x, n) for (int i = x; i < (int)(n); i++)
#define rep(i, n) REP(i, 0, n)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define sz(x) (int)(x.size())
#define popcount(x) __builtin_popcount(x)
#define popcountll(x) __builtin_popcountll(x)
#define uniq(x) x.erase(unique(x.begin(), x.end()), x.end())
#define F first
#define S second
#define mp make_pair
#define eb emplace_back
#define pii pair<int, int>
#define pll pair<ll, ll>
using namespace std;
typedef long long ll;
/* --- INFやMODの値が適切か確認する --- */
// const int INF = 1 << 30;
// const ll INF = 1LL << 60;
const ll MOD = 1000000007;
const int MAX = 1000005;
ll modFact[MAX];
ll modInv[MAX];
ll modFactInv[MAX];
// calc nCr % mod
ll comb(int n, int r) {
return modFact[n] * (modFactInv[r] * modFactInv[n - r] % MOD) % MOD;
}
int main() {
modFact[0] = modFact[1] = 1;
modFactInv[0] = modFactInv[1] = 1;
modInv[1] = 1;
REP(i, 2, MAX) {
modFact[i] = modFact[i - 1] * i % MOD;
modInv[i] = MOD - modInv[MOD % i] * (MOD / i) % MOD;
modFactInv[i] = modFactInv[i - 1] * modInv[i] % MOD;
}
int r1, c1, r2, c2;
cin >> r1 >> c1 >> r2 >> c2;
ll ans = 0;
for (int i = c1; i <= c2; i++) {
ans = (ans + comb(r2 + i + 1, i + 1)) % MOD;
ans = (ans + MOD - comb(r1 - 1 + i + 1, i + 1)) % MOD;
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
#define REP(i, x, n) for (int i = x; i < (int)(n); i++)
#define rep(i, n) REP(i, 0, n)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define sz(x) (int)(x.size())
#define popcount(x) __builtin_popcount(x)
#define popcountll(x) __builtin_popcountll(x)
#define uniq(x) x.erase(unique(x.begin(), x.end()), x.end())
#define F first
#define S second
#define mp make_pair
#define eb emplace_back
#define pii pair<int, int>
#define pll pair<ll, ll>
using namespace std;
typedef long long ll;
/* --- INFやMODの値が適切か確認する --- */
// const int INF = 1 << 30;
// const ll INF = 1LL << 60;
const ll MOD = 1000000007;
const int MAX = 2000005;
ll modFact[MAX];
ll modInv[MAX];
ll modFactInv[MAX];
// calc nCr % mod
ll comb(int n, int r) {
return modFact[n] * (modFactInv[r] * modFactInv[n - r] % MOD) % MOD;
}
int main() {
modFact[0] = modFact[1] = 1;
modFactInv[0] = modFactInv[1] = 1;
modInv[1] = 1;
REP(i, 2, MAX) {
modFact[i] = modFact[i - 1] * i % MOD;
modInv[i] = MOD - modInv[MOD % i] * (MOD / i) % MOD;
modFactInv[i] = modFactInv[i - 1] * modInv[i] % MOD;
}
int r1, c1, r2, c2;
cin >> r1 >> c1 >> r2 >> c2;
ll ans = 0;
for (int i = c1; i <= c2; i++) {
ans = (ans + comb(r2 + i + 1, i + 1)) % MOD;
ans = (ans + MOD - comb(r1 - 1 + i + 1, i + 1)) % MOD;
}
cout << ans << endl;
}
| replace | 26 | 27 | 26 | 27 | 0 | |
p02782 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
using ll = int_fast64_t;
using ld = long double;
using pll = pair<ll, ll>;
constexpr ll INF = 1LL << 60, MOD = 1e9 + 7; // 998244353;
void solve();
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
solve();
}
#define SELECTOR(_1, _2, _3, _4, SELECT, ...) SELECT
#define rep(...) SELECTOR(__VA_ARGS__, _rep2, _rep1, _rep0)(__VA_ARGS__)
#define _rep0(i, n) for (ll i = 0; i < n; ++i)
#define _rep1(i, k, n) for (ll i = k; i < n; ++i)
#define _rep2(i, k, n, d) for (ll i = k; d > 0 ? i < n : i > n; i += d)
#define foreach(a, A) for (auto &a : A)
#define endl "\n"
#ifdef __LOCAL
#include "ostreams.h"
#endif
template <class T> inline bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T> vector<T> make_vector(size_t a, T b) {
return vector<T>(a, b);
}
template <class... Ts> auto make_vector(size_t a, Ts... ts) {
return vector<decltype(make_vector(ts...))>(a, make_vector(ts...));
}
void print() { cerr << endl; }
template <class T, class... Ts> void print(const T &a, const Ts &...ts) {
cerr << a << ' ';
print(ts...);
}
template <ll MOD> class Modint {
private:
ll x;
public:
constexpr Modint(ll v = 0) : x(v % MOD + (v >= 0 ? 0 : MOD)) {}
constexpr Modint operator+(const Modint &rhs) const {
return Modint(*this) += rhs;
}
constexpr Modint operator-(const Modint &rhs) const {
return Modint(*this) -= rhs;
}
constexpr Modint operator*(const Modint &rhs) const {
return Modint(*this) *= rhs;
}
constexpr Modint operator/(const Modint &rhs) const {
return Modint(*this) /= rhs;
}
constexpr Modint operator+=(const Modint &rhs) {
x += rhs.x;
if (x >= MOD)
x -= MOD;
return *this;
}
constexpr Modint operator-=(const Modint &rhs) {
x -= rhs.x;
if (x < 0)
x += MOD;
return *this;
}
constexpr Modint operator*=(const Modint &rhs) {
(x *= rhs.x) %= MOD;
return *this;
}
constexpr Modint operator/=(const Modint &rhs) {
return *this *= pow(rhs, -1);
}
template <class T> constexpr explicit operator T() const { return x; }
constexpr static Modint pow(Modint a, ll p) {
p = p % (MOD - 1) + (p >= 0 ? 0 : MOD - 1);
Modint res = 1;
while (p) {
if (p & 1)
res *= a;
a *= a;
p >>= 1;
}
return res;
}
// constexpr static Modint pow(Modint a, ll p){
// if(p < 0){
// ll b = MOD, u = 1, v = 0;
// while(b){ll t = a.x / b; a.x -= t * b; swap(a.x, b); u -= t * v;
// swap(u, v);} a = Modint(u); p *= -1;}
// Modint res = 1;
// while(p){if(p & 1) res *= a; a *= a; p >>= 1;}
// return res;
// }
constexpr void from_stream(istream &st) { st >> x; }
constexpr void to_stream(ostream &st) const { st << x; }
};
template <ll MOD> constexpr istream &operator>>(istream &st, Modint<MOD> &a) {
a.from_stream(st);
return st;
}
template <ll MOD>
constexpr ostream &operator<<(ostream &st, const Modint<MOD> &a) {
a.to_stream(st);
return st;
}
using mint = Modint<MOD>;
template <ll N> class Modfact {
private:
ll _fact[N + 1], _invfact[N + 1];
public:
constexpr Modfact() : _fact(), _invfact() {
_fact[0] = 1;
rep(i, N) _fact[i + 1] = _fact[i] * (i + 1) % MOD;
_invfact[N] = (ll)mint::pow(_fact[N], -1);
rep(i, N - 1, -1, -1) _invfact[i] = _invfact[i + 1] * (i + 1) % MOD;
}
constexpr mint fact(ll n) const { return _fact[n]; }
constexpr mint invfact(ll n) const { return _invfact[n]; }
constexpr mint comb(ll n, ll k) const {
return 0 <= k && k <= n ? (mint)_fact[n] * _invfact[k] * _invfact[n - k]
: 0;
}
constexpr mint perm(ll n, ll k) const {
return 0 <= k && k <= n ? (mint)_fact[n] * _invfact[n - k] : 0;
}
};
constexpr ll N_MAX = 200000;
constexpr Modfact<N_MAX> mf;
void solve() {
ll r1, c1, r2, c2;
cin >> r1 >> c1 >> r2 >> c2;
assert(r2 + c2 + 2 <= N_MAX);
auto S = [&](ll m, ll n) {
mint res = (mint)(m + 2) * mf.comb(m + n + 2, m + 2) * mint::pow(n + 1, -1);
return res - 1;
};
cout << S(r2, c2) - S(r1 - 1, c2) - S(r2, c1 - 1) + S(r1 - 1, c1 - 1) << endl;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = int_fast64_t;
using ld = long double;
using pll = pair<ll, ll>;
constexpr ll INF = 1LL << 60, MOD = 1e9 + 7; // 998244353;
void solve();
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
solve();
}
#define SELECTOR(_1, _2, _3, _4, SELECT, ...) SELECT
#define rep(...) SELECTOR(__VA_ARGS__, _rep2, _rep1, _rep0)(__VA_ARGS__)
#define _rep0(i, n) for (ll i = 0; i < n; ++i)
#define _rep1(i, k, n) for (ll i = k; i < n; ++i)
#define _rep2(i, k, n, d) for (ll i = k; d > 0 ? i < n : i > n; i += d)
#define foreach(a, A) for (auto &a : A)
#define endl "\n"
#ifdef __LOCAL
#include "ostreams.h"
#endif
template <class T> inline bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T> vector<T> make_vector(size_t a, T b) {
return vector<T>(a, b);
}
template <class... Ts> auto make_vector(size_t a, Ts... ts) {
return vector<decltype(make_vector(ts...))>(a, make_vector(ts...));
}
void print() { cerr << endl; }
template <class T, class... Ts> void print(const T &a, const Ts &...ts) {
cerr << a << ' ';
print(ts...);
}
template <ll MOD> class Modint {
private:
ll x;
public:
constexpr Modint(ll v = 0) : x(v % MOD + (v >= 0 ? 0 : MOD)) {}
constexpr Modint operator+(const Modint &rhs) const {
return Modint(*this) += rhs;
}
constexpr Modint operator-(const Modint &rhs) const {
return Modint(*this) -= rhs;
}
constexpr Modint operator*(const Modint &rhs) const {
return Modint(*this) *= rhs;
}
constexpr Modint operator/(const Modint &rhs) const {
return Modint(*this) /= rhs;
}
constexpr Modint operator+=(const Modint &rhs) {
x += rhs.x;
if (x >= MOD)
x -= MOD;
return *this;
}
constexpr Modint operator-=(const Modint &rhs) {
x -= rhs.x;
if (x < 0)
x += MOD;
return *this;
}
constexpr Modint operator*=(const Modint &rhs) {
(x *= rhs.x) %= MOD;
return *this;
}
constexpr Modint operator/=(const Modint &rhs) {
return *this *= pow(rhs, -1);
}
template <class T> constexpr explicit operator T() const { return x; }
constexpr static Modint pow(Modint a, ll p) {
p = p % (MOD - 1) + (p >= 0 ? 0 : MOD - 1);
Modint res = 1;
while (p) {
if (p & 1)
res *= a;
a *= a;
p >>= 1;
}
return res;
}
// constexpr static Modint pow(Modint a, ll p){
// if(p < 0){
// ll b = MOD, u = 1, v = 0;
// while(b){ll t = a.x / b; a.x -= t * b; swap(a.x, b); u -= t * v;
// swap(u, v);} a = Modint(u); p *= -1;}
// Modint res = 1;
// while(p){if(p & 1) res *= a; a *= a; p >>= 1;}
// return res;
// }
constexpr void from_stream(istream &st) { st >> x; }
constexpr void to_stream(ostream &st) const { st << x; }
};
template <ll MOD> constexpr istream &operator>>(istream &st, Modint<MOD> &a) {
a.from_stream(st);
return st;
}
template <ll MOD>
constexpr ostream &operator<<(ostream &st, const Modint<MOD> &a) {
a.to_stream(st);
return st;
}
using mint = Modint<MOD>;
template <ll N> class Modfact {
private:
ll _fact[N + 1], _invfact[N + 1];
public:
constexpr Modfact() : _fact(), _invfact() {
_fact[0] = 1;
rep(i, N) _fact[i + 1] = _fact[i] * (i + 1) % MOD;
_invfact[N] = (ll)mint::pow(_fact[N], -1);
rep(i, N - 1, -1, -1) _invfact[i] = _invfact[i + 1] * (i + 1) % MOD;
}
constexpr mint fact(ll n) const { return _fact[n]; }
constexpr mint invfact(ll n) const { return _invfact[n]; }
constexpr mint comb(ll n, ll k) const {
return 0 <= k && k <= n ? (mint)_fact[n] * _invfact[k] * _invfact[n - k]
: 0;
}
constexpr mint perm(ll n, ll k) const {
return 0 <= k && k <= n ? (mint)_fact[n] * _invfact[n - k] : 0;
}
};
constexpr ll N_MAX = 2000005;
constexpr Modfact<N_MAX> mf;
void solve() {
ll r1, c1, r2, c2;
cin >> r1 >> c1 >> r2 >> c2;
assert(r2 + c2 + 2 <= N_MAX);
auto S = [&](ll m, ll n) {
mint res = (mint)(m + 2) * mf.comb(m + n + 2, m + 2) * mint::pow(n + 1, -1);
return res - 1;
};
cout << S(r2, c2) - S(r1 - 1, c2) - S(r2, c1 - 1) + S(r1 - 1, c1 - 1) << endl;
}
| replace | 142 | 143 | 142 | 143 | 0 | |
p02782 | C++ | Runtime Error | #include <bits/stdc++.h>
#define ll long long
#define MAX 1000005
#define P ((ll)1e9 + 7)
using namespace std;
ll qpow(ll a, ll n) {
ll res = 1;
while (n) {
if (n & 1)
res = res * a % P;
a = a * a % P;
n >>= 1;
}
return res;
}
ll fac[MAX], inv[MAX];
void init() {
fac[0] = 1;
for (int i = 1; i < MAX; i++) {
fac[i] = fac[i - 1] * i % P;
}
inv[MAX - 1] = qpow(fac[MAX - 1], P - 2);
for (int i = MAX - 2; i >= 0; i--) {
inv[i] = inv[i + 1] * (i + 1) % P;
}
}
ll C(ll n, ll m) {
if (!m)
return 1;
return fac[n] * inv[m] % P * inv[n - m] % P;
}
ll calc(ll x, ll l, ll r) { return (C(r + 1, x + 1) - C(l, x + 1) + P) % P; }
int main() {
init();
ll x1, y1, x2, y2, ans = 0;
cin >> x1 >> y1 >> x2 >> y2;
for (int i = x1; i <= x2; i++) {
ans = (ans + calc(i, i + y1, i + y2)) % P;
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define ll long long
#define MAX 4000005
#define P ((ll)1e9 + 7)
using namespace std;
ll qpow(ll a, ll n) {
ll res = 1;
while (n) {
if (n & 1)
res = res * a % P;
a = a * a % P;
n >>= 1;
}
return res;
}
ll fac[MAX], inv[MAX];
void init() {
fac[0] = 1;
for (int i = 1; i < MAX; i++) {
fac[i] = fac[i - 1] * i % P;
}
inv[MAX - 1] = qpow(fac[MAX - 1], P - 2);
for (int i = MAX - 2; i >= 0; i--) {
inv[i] = inv[i + 1] * (i + 1) % P;
}
}
ll C(ll n, ll m) {
if (!m)
return 1;
return fac[n] * inv[m] % P * inv[n - m] % P;
}
ll calc(ll x, ll l, ll r) { return (C(r + 1, x + 1) - C(l, x + 1) + P) % P; }
int main() {
init();
ll x1, y1, x2, y2, ans = 0;
cin >> x1 >> y1 >> x2 >> y2;
for (int i = x1; i <= x2; i++) {
ans = (ans + calc(i, i + y1, i + y2)) % P;
}
cout << ans << endl;
return 0;
} | replace | 2 | 3 | 2 | 3 | 0 | |
p02782 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
using Graph = vector<vector<ll>>;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define rep2(i, m, n) for (ll i = m; i < (ll)(n); i++)
#define rrep(i, n, m) for (ll i = n; i >= (ll)(m); i--)
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const int ddx[8] = {0, 1, 1, 1, 0, -1, -1, -1};
const int ddy[8] = {1, 1, 0, -1, -1, -1, 0, 1};
const ll MOD = 1000000007;
const ll INF = 1000000000000000000L;
#ifdef __DEBUG
/**
* For DEBUG
* https://github.com/ta7uw/cpp-pyprint
*/
#include "cpp-pyprint/pyprint.h"
#endif
const int MAX = 1010000;
long long fac[MAX], finv[MAX], inv[MAX];
bool initialized = false;
/**
* @fn
* This function must be called at first.
*/
void combination_init() {
initialized = true;
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
/**
* @fn
* Calculates the combination ( nCK % p: N choose K mod p).
*
* @brief constraint: 1 ≤ k ≤ n ≤ 10^7
* @return nCK % MOD
*/
long long combination(int n, int k) {
assert(initialized);
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
/**
* @fn
* Calculates the factorial of the number.
*
* @return N! % MOD
*/
long long factorial(int n) {
assert(initialized);
if (n < 0)
return 0;
return fac[n] % MOD;
}
/**
* @fn
* Calculates the combination ( nCK % p: N choose K mod p).
*
* @brief constraint: 1 ≤ k ≤ 10^7 and 1 ≤ n ≤ 10^9
* @return nCK % MOD
*/
long long combination2(int n, int k) {
assert(initialized);
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
ll res = 1;
k = min(k, n - k);
for (long long x = 1; x <= k; x++) {
res *= (n - x + 1);
res %= MOD;
res *= inv[x];
res %= MOD;
}
return res;
}
ll f(ll r, ll c) { return combination(r + c + 2, r + 1) - 1; }
void Main() {
ll r1, c1, r2, c2;
cin >> r1 >> c1 >> r2 >> c2;
combination_init();
ll ans = f(r2, c2);
ans %= MOD;
ans -= f(r2, c1 - 1);
ans %= MOD;
if (ans < 0)
ans += MOD;
ans -= f(r1 - 1, c2);
ans %= MOD;
if (ans < 0)
ans += MOD;
ans += f(r1 - 1, c1 - 1);
ans %= MOD;
cout << ans << '\n';
}
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(15);
Main();
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
using Graph = vector<vector<ll>>;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define rep2(i, m, n) for (ll i = m; i < (ll)(n); i++)
#define rrep(i, n, m) for (ll i = n; i >= (ll)(m); i--)
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const int ddx[8] = {0, 1, 1, 1, 0, -1, -1, -1};
const int ddy[8] = {1, 1, 0, -1, -1, -1, 0, 1};
const ll MOD = 1000000007;
const ll INF = 1000000000000000000L;
#ifdef __DEBUG
/**
* For DEBUG
* https://github.com/ta7uw/cpp-pyprint
*/
#include "cpp-pyprint/pyprint.h"
#endif
const int MAX = 3010000;
long long fac[MAX], finv[MAX], inv[MAX];
bool initialized = false;
/**
* @fn
* This function must be called at first.
*/
void combination_init() {
initialized = true;
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
/**
* @fn
* Calculates the combination ( nCK % p: N choose K mod p).
*
* @brief constraint: 1 ≤ k ≤ n ≤ 10^7
* @return nCK % MOD
*/
long long combination(int n, int k) {
assert(initialized);
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
/**
* @fn
* Calculates the factorial of the number.
*
* @return N! % MOD
*/
long long factorial(int n) {
assert(initialized);
if (n < 0)
return 0;
return fac[n] % MOD;
}
/**
* @fn
* Calculates the combination ( nCK % p: N choose K mod p).
*
* @brief constraint: 1 ≤ k ≤ 10^7 and 1 ≤ n ≤ 10^9
* @return nCK % MOD
*/
long long combination2(int n, int k) {
assert(initialized);
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
ll res = 1;
k = min(k, n - k);
for (long long x = 1; x <= k; x++) {
res *= (n - x + 1);
res %= MOD;
res *= inv[x];
res %= MOD;
}
return res;
}
ll f(ll r, ll c) { return combination(r + c + 2, r + 1) - 1; }
void Main() {
ll r1, c1, r2, c2;
cin >> r1 >> c1 >> r2 >> c2;
combination_init();
ll ans = f(r2, c2);
ans %= MOD;
ans -= f(r2, c1 - 1);
ans %= MOD;
if (ans < 0)
ans += MOD;
ans -= f(r1 - 1, c2);
ans %= MOD;
if (ans < 0)
ans += MOD;
ans += f(r1 - 1, c1 - 1);
ans %= MOD;
cout << ans << '\n';
}
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(15);
Main();
return 0;
}
| replace | 26 | 27 | 26 | 27 | 0 | |
p02782 | C++ | Runtime Error | #include "bits/stdc++.h"
using namespace std;
const int maxn = 1e6 + 5;
const int MOD = 1e9 + 7;
struct mi {
long long v;
explicit operator long long() const { return v; }
mi() { v = 0; }
mi(long long _v) {
v = (-MOD < _v && _v < MOD) ? _v : _v % MOD;
if (v < 0) {
v += MOD;
}
}
friend bool operator==(const mi &a, const mi &b) { return a.v == b.v; }
friend bool operator!=(const mi &a, const mi &b) { return !(a == b); }
friend bool operator<(const mi &a, const mi &b) { return a.v < b.v; }
mi &operator+=(const mi &m) {
if ((v += m.v) >= MOD) {
v -= MOD;
}
return *this;
}
mi &operator-=(const mi &m) {
if ((v -= m.v) < 0) {
v += MOD;
}
return *this;
}
mi &operator*=(const mi &m) {
v = v * m.v % MOD;
return *this;
}
mi &operator/=(const mi &m) { return (*this) *= inv(m); }
friend mi pow(mi a, long long p) {
mi ans = 1;
assert(p >= 0);
for (; p; p /= 2, a *= a) {
if (p & 1) {
ans *= a;
}
}
return ans;
}
friend mi inv(const mi &a) {
assert(a.v != 0);
return pow(a, MOD - 2);
}
mi operator-() const { return mi(-v); }
mi &operator++() { return *this += 1; }
mi &operator--() { return *this -= 1; }
mi operator++(int) {
mi temp;
temp.v = v++;
return temp;
}
mi operator--(int) {
mi temp;
temp.v = v--;
return temp;
}
friend mi operator+(mi a, const mi &b) { return a += b; }
friend mi operator-(mi a, const mi &b) { return a -= b; }
friend mi operator*(mi a, const mi &b) { return a *= b; }
friend mi operator/(mi a, const mi &b) { return a /= b; }
friend ostream &operator<<(ostream &os, const mi &m) {
os << m.v;
return os;
}
friend istream &operator>>(istream &is, mi &m) {
long long x;
is >> x;
m.v = x;
return is;
}
};
mi fact[maxn];
mi ifact[maxn];
void preCalc() {
fact[0] = 1;
ifact[0] = 1;
for (int i = 1; i < maxn; i++) {
fact[i] = i * fact[i - 1];
ifact[i] = 1 / fact[i];
}
}
mi nCr(int n, int r) {
if (n < 0 or r < 0 or n < r) {
return 0;
}
return fact[n] * ifact[r] * ifact[n - r];
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
preCalc();
int r1, c1, r2, c2;
cin >> r1 >> c1 >> r2 >> c2;
mi ans = 0;
for (int c = c1; c <= c2; c++) {
mi add = 0;
if (c + r2 >= c) {
mi ncr = nCr(c + r2 + 1, c + 1);
ncr = ncr - (c - 1);
add = ncr;
}
if (c + r1 > c) {
mi ncr = nCr(c + r1 + 1 - 1, c + 1);
ncr = ncr - (c - 1);
add -= ncr;
}
ans += add;
}
cout << ans << endl;
} | #include "bits/stdc++.h"
using namespace std;
const int maxn = 5e6 + 5;
const int MOD = 1e9 + 7;
struct mi {
long long v;
explicit operator long long() const { return v; }
mi() { v = 0; }
mi(long long _v) {
v = (-MOD < _v && _v < MOD) ? _v : _v % MOD;
if (v < 0) {
v += MOD;
}
}
friend bool operator==(const mi &a, const mi &b) { return a.v == b.v; }
friend bool operator!=(const mi &a, const mi &b) { return !(a == b); }
friend bool operator<(const mi &a, const mi &b) { return a.v < b.v; }
mi &operator+=(const mi &m) {
if ((v += m.v) >= MOD) {
v -= MOD;
}
return *this;
}
mi &operator-=(const mi &m) {
if ((v -= m.v) < 0) {
v += MOD;
}
return *this;
}
mi &operator*=(const mi &m) {
v = v * m.v % MOD;
return *this;
}
mi &operator/=(const mi &m) { return (*this) *= inv(m); }
friend mi pow(mi a, long long p) {
mi ans = 1;
assert(p >= 0);
for (; p; p /= 2, a *= a) {
if (p & 1) {
ans *= a;
}
}
return ans;
}
friend mi inv(const mi &a) {
assert(a.v != 0);
return pow(a, MOD - 2);
}
mi operator-() const { return mi(-v); }
mi &operator++() { return *this += 1; }
mi &operator--() { return *this -= 1; }
mi operator++(int) {
mi temp;
temp.v = v++;
return temp;
}
mi operator--(int) {
mi temp;
temp.v = v--;
return temp;
}
friend mi operator+(mi a, const mi &b) { return a += b; }
friend mi operator-(mi a, const mi &b) { return a -= b; }
friend mi operator*(mi a, const mi &b) { return a *= b; }
friend mi operator/(mi a, const mi &b) { return a /= b; }
friend ostream &operator<<(ostream &os, const mi &m) {
os << m.v;
return os;
}
friend istream &operator>>(istream &is, mi &m) {
long long x;
is >> x;
m.v = x;
return is;
}
};
mi fact[maxn];
mi ifact[maxn];
void preCalc() {
fact[0] = 1;
ifact[0] = 1;
for (int i = 1; i < maxn; i++) {
fact[i] = i * fact[i - 1];
ifact[i] = 1 / fact[i];
}
}
mi nCr(int n, int r) {
if (n < 0 or r < 0 or n < r) {
return 0;
}
return fact[n] * ifact[r] * ifact[n - r];
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
preCalc();
int r1, c1, r2, c2;
cin >> r1 >> c1 >> r2 >> c2;
mi ans = 0;
for (int c = c1; c <= c2; c++) {
mi add = 0;
if (c + r2 >= c) {
mi ncr = nCr(c + r2 + 1, c + 1);
ncr = ncr - (c - 1);
add = ncr;
}
if (c + r1 > c) {
mi ncr = nCr(c + r1 + 1 - 1, c + 1);
ncr = ncr - (c - 1);
add -= ncr;
}
ans += add;
}
cout << ans << endl;
} | replace | 4 | 5 | 4 | 5 | 0 | |
p02782 | C++ | Runtime Error | // #include <bits/stdc++.h>
#include <algorithm>
#include <iostream>
#include <array>
#include <bitset>
#include <complex>
#include <cstring>
#include <deque>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <valarray>
#include <vector>
#include <cassert>
#include <chrono>
#include <cmath>
#include <functional>
#include <iomanip>
#include <numeric>
#include <random>
#include <memory>
using namespace std;
#define int long long
typedef long long ll;
typedef unsigned long long ull;
// typedef unsigned __int128 HASH;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<ull, ull> pullull;
typedef pair<ll, int> plli;
typedef pair<double, int> pdi;
typedef pair<long double, int> pdbi;
typedef pair<int, pii> pipii;
typedef pair<ll, pll> plpll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<vi> vvi;
typedef vector<vvi> vvvi;
typedef vector<pii> vpii;
typedef vector<vector<int>> mat;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep2(i, a, b) for (int i = (a); i < (b); i++)
#define rrep(i, n) for (int i = (n); i > 0; i--)
#define rrep2(i, a, b) for (int i = (a); i > b; i--)
#define fi first
#define se second
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
template <class T>
using MINPQ = std::priority_queue<T, vector<T>, greater<T>>; // MINPQ<pii> pq;
template <class T> using MAXPQ = std::priority_queue<T>;
const ll hmod1 = 999999937;
const ll hmod2 = 1000000000 + 9;
const int INF = 1 << 30;
const ll INFLL = 1LL << 62;
const double EPS = 1e-12;
const ll mod = 1000000000 + 7;
// const ll mod = 998244353;
const int dx4[4] = {1, 0, -1, 0};
const int dy4[4] = {0, 1, 0, -1};
const int dx8[8] = {1, 1, 1, 0, 0, -1, -1, -1};
const int dy8[8] = {0, 1, -1, 1, -1, 0, 1, -1};
const long double pi = 3.141592653589793;
#define addm(X, Y) (X) = ((X) + ((Y) % mod) + mod) % mod
#define inside(y, x, h, w) \
(0 <= (y) && (y) < (h) && 0 <= (x) && (x) < (w)) ? true : false
#define stand(B, i) \
(((B >> i) & 1) == 1) ? true : false // Bのi番目のbitが1ならtrue, 0ならfalse
// debug
#define DEBUG
#define DUMPOUT cerr
#ifdef DEBUG
#define dump(...) \
DUMPOUT << #__VA_ARGS__ << " :[" << __FUNCTION__ << ":" << __LINE__ << "]" \
<< endl; \
DUMPOUT << " "; \
dump_func(__VA_ARGS__)
#else
#define dump(...)
#endif
void dump_func() { DUMPOUT << endl; };
template <class Head, class... Tail>
void dump_func(Head &&head, Tail &&...tail) {
DUMPOUT << head;
if (sizeof...(Tail) == 0)
DUMPOUT << " ";
else
DUMPOUT << ", ";
dump_func(std::move(tail)...);
}
// ostream
template <typename T> ostream &operator<<(ostream &os, vector<T> &vec) {
os << "[";
for (int i = 0; i < vec.size(); i++)
os << vec[i] << (i + 1 == vec.size() ? "" : ", ");
os << "]";
return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, pair<T, U> &pair_var) {
os << "(" << pair_var.first << ", " << pair_var.second << ")";
return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, map<T, U> &map_var) {
os << "[";
for (auto itr = map_var.begin(); itr != map_var.end(); itr++) {
os << "(" << itr->first << ", " << itr->second << ")";
itr++;
if (itr != map_var.end())
os << ", ";
itr--;
}
os << "]";
return os;
}
template <typename T> ostream &operator<<(ostream &os, set<T> &set_var) {
os << "[";
for (auto itr = set_var.begin(); itr != set_var.end(); itr++) {
os << *itr;
++itr;
if (itr != set_var.end())
os << ", ";
itr--;
}
os << "]";
return os;
}
int r1, r2, c1, c2;
const int COMMAX = 200000 + 5; // nCkのnの上限
vector<long long> fact(COMMAX), finv(COMMAX), inv(COMMAX);
long long powmod(long long n, long long k) {
if (k < 0)
return 0;
if (k == 0)
return 1;
else if (k % 2 == 0) {
long long tmp = powmod(n, k / 2);
return tmp * tmp % mod;
} else
return powmod(n, k - 1) * n % mod;
}
void init_com() {
fact[0] = fact[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < COMMAX; i++) {
fact[i] = fact[i - 1] * i % mod;
inv[i] = -inv[mod % i] * (mod / i) % mod;
finv[i] = finv[i - 1] * inv[i] % mod;
}
}
long long nCk(int n, int k) {
if (n < k || n < 0 || k < 0)
return 0;
return fact[n] * (finv[k] * finv[n - k] % mod) % mod;
}
int g(int r, int c) {
int ret = 0;
rep2(i, 1, r + 2) addm(ret, nCk(i + c, i));
return ret;
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> r1 >> c1 >> r2 >> c2;
init_com();
int ans = g(r2, c2);
addm(ans, -g(r2, c1 - 1));
addm(ans, -g(r1 - 1, c2));
addm(ans, g(r1 - 1, c1 - 1));
cout << ans << endl;
}
| // #include <bits/stdc++.h>
#include <algorithm>
#include <iostream>
#include <array>
#include <bitset>
#include <complex>
#include <cstring>
#include <deque>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <valarray>
#include <vector>
#include <cassert>
#include <chrono>
#include <cmath>
#include <functional>
#include <iomanip>
#include <numeric>
#include <random>
#include <memory>
using namespace std;
#define int long long
typedef long long ll;
typedef unsigned long long ull;
// typedef unsigned __int128 HASH;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<ull, ull> pullull;
typedef pair<ll, int> plli;
typedef pair<double, int> pdi;
typedef pair<long double, int> pdbi;
typedef pair<int, pii> pipii;
typedef pair<ll, pll> plpll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<vi> vvi;
typedef vector<vvi> vvvi;
typedef vector<pii> vpii;
typedef vector<vector<int>> mat;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep2(i, a, b) for (int i = (a); i < (b); i++)
#define rrep(i, n) for (int i = (n); i > 0; i--)
#define rrep2(i, a, b) for (int i = (a); i > b; i--)
#define fi first
#define se second
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
template <class T>
using MINPQ = std::priority_queue<T, vector<T>, greater<T>>; // MINPQ<pii> pq;
template <class T> using MAXPQ = std::priority_queue<T>;
const ll hmod1 = 999999937;
const ll hmod2 = 1000000000 + 9;
const int INF = 1 << 30;
const ll INFLL = 1LL << 62;
const double EPS = 1e-12;
const ll mod = 1000000000 + 7;
// const ll mod = 998244353;
const int dx4[4] = {1, 0, -1, 0};
const int dy4[4] = {0, 1, 0, -1};
const int dx8[8] = {1, 1, 1, 0, 0, -1, -1, -1};
const int dy8[8] = {0, 1, -1, 1, -1, 0, 1, -1};
const long double pi = 3.141592653589793;
#define addm(X, Y) (X) = ((X) + ((Y) % mod) + mod) % mod
#define inside(y, x, h, w) \
(0 <= (y) && (y) < (h) && 0 <= (x) && (x) < (w)) ? true : false
#define stand(B, i) \
(((B >> i) & 1) == 1) ? true : false // Bのi番目のbitが1ならtrue, 0ならfalse
// debug
#define DEBUG
#define DUMPOUT cerr
#ifdef DEBUG
#define dump(...) \
DUMPOUT << #__VA_ARGS__ << " :[" << __FUNCTION__ << ":" << __LINE__ << "]" \
<< endl; \
DUMPOUT << " "; \
dump_func(__VA_ARGS__)
#else
#define dump(...)
#endif
void dump_func() { DUMPOUT << endl; };
template <class Head, class... Tail>
void dump_func(Head &&head, Tail &&...tail) {
DUMPOUT << head;
if (sizeof...(Tail) == 0)
DUMPOUT << " ";
else
DUMPOUT << ", ";
dump_func(std::move(tail)...);
}
// ostream
template <typename T> ostream &operator<<(ostream &os, vector<T> &vec) {
os << "[";
for (int i = 0; i < vec.size(); i++)
os << vec[i] << (i + 1 == vec.size() ? "" : ", ");
os << "]";
return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, pair<T, U> &pair_var) {
os << "(" << pair_var.first << ", " << pair_var.second << ")";
return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, map<T, U> &map_var) {
os << "[";
for (auto itr = map_var.begin(); itr != map_var.end(); itr++) {
os << "(" << itr->first << ", " << itr->second << ")";
itr++;
if (itr != map_var.end())
os << ", ";
itr--;
}
os << "]";
return os;
}
template <typename T> ostream &operator<<(ostream &os, set<T> &set_var) {
os << "[";
for (auto itr = set_var.begin(); itr != set_var.end(); itr++) {
os << *itr;
++itr;
if (itr != set_var.end())
os << ", ";
itr--;
}
os << "]";
return os;
}
int r1, r2, c1, c2;
const int COMMAX = 2000000 + 5; // nCkのnの上限
vector<long long> fact(COMMAX), finv(COMMAX), inv(COMMAX);
long long powmod(long long n, long long k) {
if (k < 0)
return 0;
if (k == 0)
return 1;
else if (k % 2 == 0) {
long long tmp = powmod(n, k / 2);
return tmp * tmp % mod;
} else
return powmod(n, k - 1) * n % mod;
}
void init_com() {
fact[0] = fact[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < COMMAX; i++) {
fact[i] = fact[i - 1] * i % mod;
inv[i] = -inv[mod % i] * (mod / i) % mod;
finv[i] = finv[i - 1] * inv[i] % mod;
}
}
long long nCk(int n, int k) {
if (n < k || n < 0 || k < 0)
return 0;
return fact[n] * (finv[k] * finv[n - k] % mod) % mod;
}
int g(int r, int c) {
int ret = 0;
rep2(i, 1, r + 2) addm(ret, nCk(i + c, i));
return ret;
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> r1 >> c1 >> r2 >> c2;
init_com();
int ans = g(r2, c2);
addm(ans, -g(r2, c1 - 1));
addm(ans, -g(r1 - 1, c2));
addm(ans, g(r1 - 1, c1 - 1));
cout << ans << endl;
}
| replace | 155 | 156 | 155 | 156 | 0 | |
p02782 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> Pii;
typedef pair<ll, ll> Pll;
#define rep(i, n) for (ll i = 0; i < (n); ++i)
#define rep2(i, a, b) for (ll i = (a); i < (b); ++i)
#define debug(x) cout << #x << '=' << x << endl
#define all(v) (v).begin(), (v).end()
const ll MOD = 1e9 + 7;
// const ll MOD=998244353;
const ll INF = 1e9;
const ll IINF = 1e18;
const double EPS = 1e-8;
const double pi = acos(-1);
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <uint_fast64_t Modulus> class modint {
using u64 = uint_fast64_t;
public:
u64 a;
constexpr modint(const u64 x = 0) noexcept
: a(((x % Modulus) + Modulus) % Modulus) {}
constexpr u64 &value() noexcept { return a; }
constexpr const u64 &value() const noexcept { return a; }
constexpr modint &operator+=(const modint &rhs) noexcept {
a += rhs.a;
if (a >= Modulus)
a -= Modulus;
return *this;
}
constexpr modint operator+(const modint &rhs) const noexcept {
return modint(*this) += rhs;
}
constexpr modint &operator++() noexcept { return ++a, *this; }
constexpr modint operator++(int) noexcept {
modint t = *this;
return ++a, t;
}
constexpr modint &operator-=(const modint &rhs) noexcept {
if (a < rhs.a)
a += Modulus;
a -= rhs.a;
return *this;
}
constexpr modint operator-(const modint &rhs) const noexcept {
return modint(*this) -= rhs;
}
constexpr modint &operator--() noexcept { return --a, *this; }
constexpr modint operator--(int) noexcept {
modint t = *this;
return --a, t;
}
constexpr modint &operator*=(const modint &rhs) noexcept {
a = a * rhs.a % Modulus;
return *this;
}
constexpr modint operator*(const modint &rhs) const noexcept {
return modint(*this) *= rhs;
}
constexpr modint &operator/=(modint rhs) noexcept {
u64 exp = Modulus - 2;
while (exp) {
if (exp & 1)
*this *= rhs;
rhs *= rhs;
exp >>= 1;
}
return *this;
}
constexpr modint operator/(const modint &rhs) const noexcept {
return modint(*this) /= rhs;
}
constexpr modint operator-() const noexcept { return modint(Modulus - a); }
constexpr bool operator==(const modint &rhs) const noexcept {
return a == rhs.a;
}
constexpr bool operator!=(const modint &rhs) const noexcept {
return a != rhs.a;
}
constexpr bool operator!() const noexcept { return !a; }
friend constexpr modint pow(modint rhs, long long exp) noexcept {
modint res{1};
while (exp) {
if (exp & 1)
res *= rhs;
rhs *= rhs;
exp >>= 1;
}
return res;
}
friend ostream &operator<<(ostream &s, const modint &rhs) noexcept {
return s << rhs.a;
}
friend istream &operator>>(istream &s, modint &rhs) noexcept {
u64 a;
rhs = modint{(s >> a, a)};
return s;
}
};
using mint = modint<MOD>;
const int MAX = 1e6 + 10;
vector<mint> fac(MAX), finv(MAX), inv(MAX);
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; ++i) {
fac[i] = fac[i - 1] * i;
inv[i] = -inv[MOD % i] * (MOD / i);
finv[i] = finv[i - 1] * inv[i];
}
}
mint COM(int n, int k) {
if (n < k || n < 0 || k < 0)
return 0;
return fac[n] * finv[k] * finv[n - k];
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int a, b, c, d;
cin >> a >> c >> b >> d;
COMinit();
mint ans = 0;
rep2(j, c, d + 1) {
ans += (COM(b + j + 1, b + 1) * (b + 1) - COM(a + j, a) * a) * inv[j + 1];
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> Pii;
typedef pair<ll, ll> Pll;
#define rep(i, n) for (ll i = 0; i < (n); ++i)
#define rep2(i, a, b) for (ll i = (a); i < (b); ++i)
#define debug(x) cout << #x << '=' << x << endl
#define all(v) (v).begin(), (v).end()
const ll MOD = 1e9 + 7;
// const ll MOD=998244353;
const ll INF = 1e9;
const ll IINF = 1e18;
const double EPS = 1e-8;
const double pi = acos(-1);
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <uint_fast64_t Modulus> class modint {
using u64 = uint_fast64_t;
public:
u64 a;
constexpr modint(const u64 x = 0) noexcept
: a(((x % Modulus) + Modulus) % Modulus) {}
constexpr u64 &value() noexcept { return a; }
constexpr const u64 &value() const noexcept { return a; }
constexpr modint &operator+=(const modint &rhs) noexcept {
a += rhs.a;
if (a >= Modulus)
a -= Modulus;
return *this;
}
constexpr modint operator+(const modint &rhs) const noexcept {
return modint(*this) += rhs;
}
constexpr modint &operator++() noexcept { return ++a, *this; }
constexpr modint operator++(int) noexcept {
modint t = *this;
return ++a, t;
}
constexpr modint &operator-=(const modint &rhs) noexcept {
if (a < rhs.a)
a += Modulus;
a -= rhs.a;
return *this;
}
constexpr modint operator-(const modint &rhs) const noexcept {
return modint(*this) -= rhs;
}
constexpr modint &operator--() noexcept { return --a, *this; }
constexpr modint operator--(int) noexcept {
modint t = *this;
return --a, t;
}
constexpr modint &operator*=(const modint &rhs) noexcept {
a = a * rhs.a % Modulus;
return *this;
}
constexpr modint operator*(const modint &rhs) const noexcept {
return modint(*this) *= rhs;
}
constexpr modint &operator/=(modint rhs) noexcept {
u64 exp = Modulus - 2;
while (exp) {
if (exp & 1)
*this *= rhs;
rhs *= rhs;
exp >>= 1;
}
return *this;
}
constexpr modint operator/(const modint &rhs) const noexcept {
return modint(*this) /= rhs;
}
constexpr modint operator-() const noexcept { return modint(Modulus - a); }
constexpr bool operator==(const modint &rhs) const noexcept {
return a == rhs.a;
}
constexpr bool operator!=(const modint &rhs) const noexcept {
return a != rhs.a;
}
constexpr bool operator!() const noexcept { return !a; }
friend constexpr modint pow(modint rhs, long long exp) noexcept {
modint res{1};
while (exp) {
if (exp & 1)
res *= rhs;
rhs *= rhs;
exp >>= 1;
}
return res;
}
friend ostream &operator<<(ostream &s, const modint &rhs) noexcept {
return s << rhs.a;
}
friend istream &operator>>(istream &s, modint &rhs) noexcept {
u64 a;
rhs = modint{(s >> a, a)};
return s;
}
};
using mint = modint<MOD>;
const int MAX = 2e6 + 10;
vector<mint> fac(MAX), finv(MAX), inv(MAX);
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; ++i) {
fac[i] = fac[i - 1] * i;
inv[i] = -inv[MOD % i] * (MOD / i);
finv[i] = finv[i - 1] * inv[i];
}
}
mint COM(int n, int k) {
if (n < k || n < 0 || k < 0)
return 0;
return fac[n] * finv[k] * finv[n - k];
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int a, b, c, d;
cin >> a >> c >> b >> d;
COMinit();
mint ans = 0;
rep2(j, c, d + 1) {
ans += (COM(b + j + 1, b + 1) * (b + 1) - COM(a + j, a) * a) * inv[j + 1];
}
cout << ans << endl;
} | replace | 118 | 119 | 118 | 119 | 0 | |
p02782 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define F first
#define S second
#define pii pair<int, int>
#define eb emplace_back
#define all(v) v.begin(), v.end()
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rep3(i, l, n) for (int i = l; i < (n); ++i)
#define sz(v) (int)v.size()
const int inf = 1e9 + 7;
const ll INF = 1e18;
#define abs(x) (x >= 0 ? x : -(x))
#define lb(v, x) (int)(lower_bound(all(v), x) - v.begin())
#define ub(v, x) (int)(upper_bound(all(v), x) - v.begin())
template <typename T1, typename T2> inline bool chmin(T1 &a, T2 b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <typename T1, typename T2> inline bool chmax(T1 &a, T2 b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <typename T> T gcd(T a, T b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
template <typename T> T lcm(T a, T b) { return a / gcd(a, b) * b; }
template <typename T> T pow(T a, int b) {
return b ? pow(a * a, b / 2) * (b % 2 ? a : 1) : 1;
}
const int mod = 1000000007;
ll modpow(ll a, int b) {
return b ? modpow(a * a % mod, b / 2) * (b % 2 ? a : 1) % mod : 1;
}
template <class T> ostream &operator<<(ostream &os, const vector<T> &vec) {
for (auto &vi : vec)
os << vi << " ";
return os;
}
void solve();
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int T;
// cin >> T;
T = 1;
while (T--) {
solve();
}
}
const int MAX = 1000005;
ll fac[MAX], finv[MAX], inv[MAX];
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % mod;
inv[i] = mod - inv[mod % i] * (mod / i) % mod;
finv[i] = finv[i - 1] * inv[i] % mod;
}
}
// 二項係数計算
ll COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % mod) % mod;
}
ll f(int r, int c) {
return ((r + 2) * COM(c + r + 2, r + 2) % mod - c - 1 + mod) % mod *
modpow(c + 1, mod - 2) % mod;
}
// https://www.wolframalpha.com/input/?i=Sum%5BSum%5Bcomb%28x+%2B+y%2C+x%29%2C+%7By%2C+0%2C+c%7D%5D%2C+%7Bx%2C+0%2C+r%7D%5D&lang=ja
void solve() {
int r1, r2, c1, c2;
cin >> r1 >> c1 >> r2 >> c2;
COMinit();
ll ans =
f(r2, c2) + mod - f(r2, c1 - 1) + mod - f(r1 - 1, c2) + f(r1 - 1, c1 - 1);
cout << ans % mod << endl;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define F first
#define S second
#define pii pair<int, int>
#define eb emplace_back
#define all(v) v.begin(), v.end()
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rep3(i, l, n) for (int i = l; i < (n); ++i)
#define sz(v) (int)v.size()
const int inf = 1e9 + 7;
const ll INF = 1e18;
#define abs(x) (x >= 0 ? x : -(x))
#define lb(v, x) (int)(lower_bound(all(v), x) - v.begin())
#define ub(v, x) (int)(upper_bound(all(v), x) - v.begin())
template <typename T1, typename T2> inline bool chmin(T1 &a, T2 b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <typename T1, typename T2> inline bool chmax(T1 &a, T2 b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <typename T> T gcd(T a, T b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
template <typename T> T lcm(T a, T b) { return a / gcd(a, b) * b; }
template <typename T> T pow(T a, int b) {
return b ? pow(a * a, b / 2) * (b % 2 ? a : 1) : 1;
}
const int mod = 1000000007;
ll modpow(ll a, int b) {
return b ? modpow(a * a % mod, b / 2) * (b % 2 ? a : 1) % mod : 1;
}
template <class T> ostream &operator<<(ostream &os, const vector<T> &vec) {
for (auto &vi : vec)
os << vi << " ";
return os;
}
void solve();
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int T;
// cin >> T;
T = 1;
while (T--) {
solve();
}
}
const int MAX = 2000005; // c + r
ll fac[MAX], finv[MAX], inv[MAX];
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % mod;
inv[i] = mod - inv[mod % i] * (mod / i) % mod;
finv[i] = finv[i - 1] * inv[i] % mod;
}
}
// 二項係数計算
ll COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % mod) % mod;
}
ll f(int r, int c) {
return ((r + 2) * COM(c + r + 2, r + 2) % mod - c - 1 + mod) % mod *
modpow(c + 1, mod - 2) % mod;
}
// https://www.wolframalpha.com/input/?i=Sum%5BSum%5Bcomb%28x+%2B+y%2C+x%29%2C+%7By%2C+0%2C+c%7D%5D%2C+%7Bx%2C+0%2C+r%7D%5D&lang=ja
void solve() {
int r1, r2, c1, c2;
cin >> r1 >> c1 >> r2 >> c2;
COMinit();
ll ans =
f(r2, c2) + mod - f(r2, c1 - 1) + mod - f(r1 - 1, c2) + f(r1 - 1, c1 - 1);
cout << ans % mod << endl;
}
| replace | 65 | 66 | 65 | 66 | 0 | |
p02782 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define name ""
#define ini \
freopen(name ".inp", "r", stdin); \
freopen(name ".out", "w", stdout)
#define foe(it, c) for (__typeof(c.begin()) it = c.begin(); it != c.end(); it++)
#define long long long
#define db double
#define pii pair<int, int>
#define pll pair<long, long>
#define all(c) c.begin(), c.end()
#define fastio \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0)
const int INF = 1e9 + 7;
const int MOD = 1e9 + 7;
const int dx[4] = {0, 0, -1, 1};
const int dy[4] = {-1, 1, 0, 0};
const int N = 1e6 + 2;
long fact[N], ifact[N];
long POW(long x, long n) {
if (n == 0)
return 1;
long y = POW(x, n / 2);
y = y * y % MOD;
if (n % 2)
return x * y % MOD;
else
return y;
}
int main() {
fastio;
int u, v, x, y;
cin >> u >> v >> x >> y;
fact[0] = 1;
for (int i = 1; i < N; i++)
fact[i] = fact[i - 1] * i % MOD;
ifact[N - 1] = POW(fact[N - 1], MOD - 2);
ifact[0] = 1;
for (int i = N - 2; i > 0; i--)
ifact[i] = ifact[i + 1] * (i + 1) % MOD;
auto C = [&](int k, int n) {
long res = fact[n] * (ifact[k] * ifact[n - k] % MOD) % MOD;
return res;
};
auto F = [&](int u, int v) {
long res = 0;
for (int i = 1; i <= u + 1; i++) {
res += C(i, v + i);
res %= MOD;
}
return res;
};
long res = F(x, y) - F(u - 1, y) - F(x, v - 1) + F(u - 1, v - 1);
res %= MOD;
(res += MOD) %= MOD;
cout << res;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define name ""
#define ini \
freopen(name ".inp", "r", stdin); \
freopen(name ".out", "w", stdout)
#define foe(it, c) for (__typeof(c.begin()) it = c.begin(); it != c.end(); it++)
#define long long long
#define db double
#define pii pair<int, int>
#define pll pair<long, long>
#define all(c) c.begin(), c.end()
#define fastio \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0)
const int INF = 1e9 + 7;
const int MOD = 1e9 + 7;
const int dx[4] = {0, 0, -1, 1};
const int dy[4] = {-1, 1, 0, 0};
const int N = 2e6 + 2;
long fact[N], ifact[N];
long POW(long x, long n) {
if (n == 0)
return 1;
long y = POW(x, n / 2);
y = y * y % MOD;
if (n % 2)
return x * y % MOD;
else
return y;
}
int main() {
fastio;
int u, v, x, y;
cin >> u >> v >> x >> y;
fact[0] = 1;
for (int i = 1; i < N; i++)
fact[i] = fact[i - 1] * i % MOD;
ifact[N - 1] = POW(fact[N - 1], MOD - 2);
ifact[0] = 1;
for (int i = N - 2; i > 0; i--)
ifact[i] = ifact[i + 1] * (i + 1) % MOD;
auto C = [&](int k, int n) {
long res = fact[n] * (ifact[k] * ifact[n - k] % MOD) % MOD;
return res;
};
auto F = [&](int u, int v) {
long res = 0;
for (int i = 1; i <= u + 1; i++) {
res += C(i, v + i);
res %= MOD;
}
return res;
};
long res = F(x, y) - F(u - 1, y) - F(x, v - 1) + F(u - 1, v - 1);
res %= MOD;
(res += MOD) %= MOD;
cout << res;
return 0;
} | replace | 23 | 24 | 23 | 24 | 0 | |
p02782 | C++ | Runtime Error | #include <bits/stdc++.h>
#include <stdlib.h>
#include <sys/time.h>
#include <unistd.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
typedef pair<P, ll> T;
long long int INF = 2e18;
const ll fact_table = 1200008;
double Pi = 3.1415926535897932384626;
priority_queue<ll> pql;
priority_queue<P> pqp;
priority_queue<P> bag;
// big priority queue
priority_queue<ll, vector<ll>, greater<ll>> pqls;
priority_queue<P, vector<P>, greater<P>> pqps;
// small priority queue
// top pop
ll dx[8] = {1, 0, -1, 0, 1, 1, -1, -1};
ll dy[8] = {0, 1, 0, -1, 1, -1, -1, 1};
char dir[] = "DRUL";
// ↓,→,↑,←
#define endl "\n"
#ifdef ENJAPMA
#undef endl
#endif
#define p(x) cout << x << endl;
#define el cout << endl;
#define pe(x) cout << x << " ";
#define ps(x) cout << fixed << setprecision(25) << x << endl;
#define pu(x) cout << (x);
#define pb push_back
#define lb lower_bound
#define ub upper_bound
#define CLEAR(a) a = decltype(a)();
#define pc(x) cout << x << ",";
// const ll mod = 998244353ll;
const ll mod = 1000000007ll;
ll mypow(ll number1, ll number2, ll mod) {
if (number2 == 0) {
return 1ll;
} else {
ll number3 = mypow(number1, number2 / 2, mod);
number3 *= number3;
number3 %= mod;
if (number2 % 2 == 1) {
number3 *= number1;
number3 %= mod;
}
return number3;
}
}
void YES(bool condition) {
if (condition) {
p("YES");
} else {
p("NO");
}
return;
}
void Yes(bool condition) {
if (condition) {
p("Yes");
} else {
p("No");
}
return;
}
ll fact[fact_table + 5], rfact[fact_table + 5];
void c3_init() {
fact[0] = rfact[0] = 1;
for (ll i = 1; i <= fact_table; i++) {
fact[i] = (fact[i - 1] * i) % mod;
}
rfact[fact_table] = mypow(fact[fact_table], mod - 2, mod);
for (ll i = fact_table; i >= 1; i--) {
rfact[i - 1] = rfact[i] * i;
rfact[i - 1] %= mod;
}
return;
}
ll c3(ll n, ll r) {
return (((fact[n] * rfact[r]) % mod) * rfact[n - r]) % mod;
}
bool multicase = false;
ll n, m, num, a, b, c, d, e, h, q;
ll w, k, ans;
ll x[500005], y[500005];
ll dp[15][500005];
string s;
ll query = 0;
ll calc(ll l, ll r) {
ll res = c3(r + l + 2, r + 1);
res += mod - 1;
res %= mod;
return res;
}
void solve() {
c3_init();
ll r1, r2, c1, c2;
cin >> r1 >> c1 >> r2 >> c2;
ll ans = 0;
ll a = calc(r2, c2);
ans =
calc(r2, c2) - calc(r1 - 1, c2) - calc(r2, c1 - 1) + calc(r1 - 1, c1 - 1);
ans += mod * 10;
ans %= mod;
p(ans);
return;
}
int main() {
// init();
ios::sync_with_stdio(false);
cin.tie(nullptr);
ll q, testcase = 1;
if (multicase) {
cin >> q;
} else {
q = 1;
}
while (q--) {
// pu("Case ");pu("#");pu(testcase);pu(": ");
solve();
testcase++;
}
// solve();
return 0;
}
| #include <bits/stdc++.h>
#include <stdlib.h>
#include <sys/time.h>
#include <unistd.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
typedef pair<P, ll> T;
long long int INF = 2e18;
const ll fact_table = 3200008;
double Pi = 3.1415926535897932384626;
priority_queue<ll> pql;
priority_queue<P> pqp;
priority_queue<P> bag;
// big priority queue
priority_queue<ll, vector<ll>, greater<ll>> pqls;
priority_queue<P, vector<P>, greater<P>> pqps;
// small priority queue
// top pop
ll dx[8] = {1, 0, -1, 0, 1, 1, -1, -1};
ll dy[8] = {0, 1, 0, -1, 1, -1, -1, 1};
char dir[] = "DRUL";
// ↓,→,↑,←
#define endl "\n"
#ifdef ENJAPMA
#undef endl
#endif
#define p(x) cout << x << endl;
#define el cout << endl;
#define pe(x) cout << x << " ";
#define ps(x) cout << fixed << setprecision(25) << x << endl;
#define pu(x) cout << (x);
#define pb push_back
#define lb lower_bound
#define ub upper_bound
#define CLEAR(a) a = decltype(a)();
#define pc(x) cout << x << ",";
// const ll mod = 998244353ll;
const ll mod = 1000000007ll;
ll mypow(ll number1, ll number2, ll mod) {
if (number2 == 0) {
return 1ll;
} else {
ll number3 = mypow(number1, number2 / 2, mod);
number3 *= number3;
number3 %= mod;
if (number2 % 2 == 1) {
number3 *= number1;
number3 %= mod;
}
return number3;
}
}
void YES(bool condition) {
if (condition) {
p("YES");
} else {
p("NO");
}
return;
}
void Yes(bool condition) {
if (condition) {
p("Yes");
} else {
p("No");
}
return;
}
ll fact[fact_table + 5], rfact[fact_table + 5];
void c3_init() {
fact[0] = rfact[0] = 1;
for (ll i = 1; i <= fact_table; i++) {
fact[i] = (fact[i - 1] * i) % mod;
}
rfact[fact_table] = mypow(fact[fact_table], mod - 2, mod);
for (ll i = fact_table; i >= 1; i--) {
rfact[i - 1] = rfact[i] * i;
rfact[i - 1] %= mod;
}
return;
}
ll c3(ll n, ll r) {
return (((fact[n] * rfact[r]) % mod) * rfact[n - r]) % mod;
}
bool multicase = false;
ll n, m, num, a, b, c, d, e, h, q;
ll w, k, ans;
ll x[500005], y[500005];
ll dp[15][500005];
string s;
ll query = 0;
ll calc(ll l, ll r) {
ll res = c3(r + l + 2, r + 1);
res += mod - 1;
res %= mod;
return res;
}
void solve() {
c3_init();
ll r1, r2, c1, c2;
cin >> r1 >> c1 >> r2 >> c2;
ll ans = 0;
ll a = calc(r2, c2);
ans =
calc(r2, c2) - calc(r1 - 1, c2) - calc(r2, c1 - 1) + calc(r1 - 1, c1 - 1);
ans += mod * 10;
ans %= mod;
p(ans);
return;
}
int main() {
// init();
ios::sync_with_stdio(false);
cin.tie(nullptr);
ll q, testcase = 1;
if (multicase) {
cin >> q;
} else {
q = 1;
}
while (q--) {
// pu("Case ");pu("#");pu(testcase);pu(": ");
solve();
testcase++;
}
// solve();
return 0;
}
| replace | 12 | 13 | 12 | 13 | 0 | |
p02782 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>
typedef long long ll;
typedef long double ld;
using namespace std;
ll mod = 1000000007;
const int SIZE = 1000010;
ll fac[SIZE], finv[SIZE], inv[SIZE];
void COMinit(ll m) {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < SIZE; ++i) {
fac[i] = (fac[i - 1] * i) % m;
inv[i] = m - (inv[m % i] * (m / i)) % m;
finv[i] = (finv[i - 1] * inv[i]) % m;
}
}
ll COM(int n, int k, ll m) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return (fac[n] * ((finv[k] * finv[n - k]) % m)) % m;
}
ll solve(int R, int C) { return (COM(R + C + 2, R + 1, mod) + mod - 1) % mod; }
int main() {
int r1, c1, r2, c2;
cin >> r1 >> c1 >> r2 >> c2;
COMinit(mod);
cout << (solve(r2, c2) + solve(r1 - 1, c1 - 1) + mod * 2 - solve(r2, c1 - 1) -
solve(r1 - 1, c2)) %
mod
<< endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>
typedef long long ll;
typedef long double ld;
using namespace std;
ll mod = 1000000007;
const int SIZE = 2000010;
ll fac[SIZE], finv[SIZE], inv[SIZE];
void COMinit(ll m) {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < SIZE; ++i) {
fac[i] = (fac[i - 1] * i) % m;
inv[i] = m - (inv[m % i] * (m / i)) % m;
finv[i] = (finv[i - 1] * inv[i]) % m;
}
}
ll COM(int n, int k, ll m) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return (fac[n] * ((finv[k] * finv[n - k]) % m)) % m;
}
ll solve(int R, int C) { return (COM(R + C + 2, R + 1, mod) + mod - 1) % mod; }
int main() {
int r1, c1, r2, c2;
cin >> r1 >> c1 >> r2 >> c2;
COMinit(mod);
cout << (solve(r2, c2) + solve(r1 - 1, c1 - 1) + mod * 2 - solve(r2, c1 - 1) -
solve(r1 - 1, c2)) %
mod
<< endl;
return 0;
}
| replace | 16 | 17 | 16 | 17 | 0 | |
p02782 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define rep(i, a, b) for (int i = (a); i < (b); i++)
#define rrep(i, a, b) for (int i = (a); i >= (b); i--)
typedef long long ll;
const ll mod = 1000000007;
const int MAX = 2100000;
ll fac[MAX], finv[MAX], inv[MAX];
void cominit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (ll i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % mod;
inv[i] = mod - inv[mod % i] * (mod / i) % mod;
finv[i] = finv[i - 1] * inv[i] % mod;
}
}
ll com(ll n, ll k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % mod) % mod;
}
int main() {
ll r1, c1, r2, c2;
cin >> r1 >> c1 >> r2 >> c2;
cominit();
ll ans = 0;
for (int i = r1; i <= r2; i++) {
for (int j = c1; j <= c2; j++) {
ans = (ans + com(i + j, i)) % mod;
}
}
vector<ll> x(r2 + 1, 0);
for (int i = r1; i <= r2; i++) {
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, a, b) for (int i = (a); i < (b); i++)
#define rrep(i, a, b) for (int i = (a); i >= (b); i--)
typedef long long ll;
const ll mod = 1000000007;
const int MAX = 2100000;
ll fac[MAX], finv[MAX], inv[MAX];
void cominit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (ll i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % mod;
inv[i] = mod - inv[mod % i] * (mod / i) % mod;
finv[i] = finv[i - 1] * inv[i] % mod;
}
}
ll com(ll n, ll k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % mod) % mod;
}
int main() {
ll r1, c1, r2, c2;
cin >> r1 >> c1 >> r2 >> c2;
cominit();
ll ans = 0;
ans += com(r2 + c2 + 2, c2 + 1);
ans -= com(r1 + c2 + 1, r1);
ans -= com(r2 + c1 + 1, r2 + 1);
ans += com(r1 + c1, r1);
ans = (ans + mod) % mod;
cout << ans << endl;
return 0;
}
| replace | 34 | 42 | 34 | 39 | TLE | |
p02782 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
const int MAX = 1000001;
const int MOD = 1000000007;
long long fac[MAX], finv[MAX], inv[MAX];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
long long COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
int main() {
int r1, c1, r2, c2;
cin >> r1 >> c1 >> r2 >> c2;
COMinit();
long long ans = COM(r2 + c2 + 2, r2 + 1) - COM(r1 + c2 + 1, r1) -
COM(r2 + c1 + 1, r2 + 1) + COM(r1 + c1, r1);
ans = (ans + MOD) % MOD;
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
const int MAX = 2000003;
const int MOD = 1000000007;
long long fac[MAX], finv[MAX], inv[MAX];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
long long COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
int main() {
int r1, c1, r2, c2;
cin >> r1 >> c1 >> r2 >> c2;
COMinit();
long long ans = COM(r2 + c2 + 2, r2 + 1) - COM(r1 + c2 + 1, r1) -
COM(r2 + c1 + 1, r2 + 1) + COM(r1 + c1, r1);
ans = (ans + MOD) % MOD;
cout << ans << endl;
} | replace | 2 | 3 | 2 | 3 | 0 | |
p02782 | C++ | Runtime Error | #include <bits/stdc++.h>
#define rep(i, x, y) for (int i = x; i <= y; i++)
using namespace std;
const int N = 1e6 + 10, mod = 1e9 + 7;
typedef long long ll;
ll r1, c1, r2, c2, n;
ll a1, a2, a3, a4;
ll fac[N], inv[N];
ll quick_pow(ll a, ll b) {
ll ret = 1;
for (; b; b >>= 1) {
if (b & 1)
ret = ret * a % mod;
a = a * a % mod;
}
return ret;
}
ll C(ll n, ll m) { return fac[n] * inv[m] % mod * inv[n - m] % mod; }
ll calc(ll r, ll c) {
ll ret = 0;
rep(i, 0, r) ret = (ret + C(i + c + 1, c)) % mod;
return ret;
}
int main() {
cin >> r1 >> c1 >> r2 >> c2;
n = r2 + c2 + 2;
fac[0] = inv[0] = 1;
rep(i, 1, n) fac[i] = (fac[i - 1] * i) % mod;
inv[n] = quick_pow(fac[n], mod - 2);
for (int i = n; i >= 1; i--)
inv[i - 1] = inv[i] * i % mod;
a1 = calc(r2, c2);
a2 = calc(r1 - 1, c2);
a3 = calc(r2, c1 - 1);
a4 = calc(r1 - 1, c1 - 1);
printf("%lld\n", (a1 - a2 - a3 + a4 + mod) % mod);
return 0;
}
| #include <bits/stdc++.h>
#define rep(i, x, y) for (int i = x; i <= y; i++)
using namespace std;
const int N = 2e6 + 10, mod = 1e9 + 7;
typedef long long ll;
ll r1, c1, r2, c2, n;
ll a1, a2, a3, a4;
ll fac[N], inv[N];
ll quick_pow(ll a, ll b) {
ll ret = 1;
for (; b; b >>= 1) {
if (b & 1)
ret = ret * a % mod;
a = a * a % mod;
}
return ret;
}
ll C(ll n, ll m) { return fac[n] * inv[m] % mod * inv[n - m] % mod; }
ll calc(ll r, ll c) {
ll ret = 0;
rep(i, 0, r) ret = (ret + C(i + c + 1, c)) % mod;
return ret;
}
int main() {
cin >> r1 >> c1 >> r2 >> c2;
n = r2 + c2 + 2;
fac[0] = inv[0] = 1;
rep(i, 1, n) fac[i] = (fac[i - 1] * i) % mod;
inv[n] = quick_pow(fac[n], mod - 2);
for (int i = n; i >= 1; i--)
inv[i - 1] = inv[i] * i % mod;
a1 = calc(r2, c2);
a2 = calc(r1 - 1, c2);
a3 = calc(r2, c1 - 1);
a4 = calc(r1 - 1, c1 - 1);
printf("%lld\n", (a1 - a2 - a3 + a4 + mod) % mod);
return 0;
}
| replace | 4 | 5 | 4 | 5 | 0 | |
p02782 | C++ | Runtime Error | #include "bits/stdc++.h"
using namespace std;
const int N = 1e6 + 20, MOD = (int)(1e9) + 7;
int f[N], ie[N], n1, m1, n2, m2;
int power(int a, int b) {
int num = a, ans = 1;
for (int i = 0; i < 31; i++) {
if (b & (1 << i))
ans = (1ll * ans * num) % MOD;
num = (1ll * num * num) % MOD;
}
return ans;
}
int inverse_euler(int n) { return power(n, MOD - 2); }
int ncr(int n, int r) {
return (1LL * f[n] * ((1LL * ie[r] * ie[n - r]) % MOD)) % MOD;
}
void precompute() {
f[0] = 1;
for (int i = 1; i < N; i++)
f[i] = (1LL * f[i - 1] * i) % MOD;
for (int i = 0; i < N; i++)
ie[i] = inverse_euler(f[i]);
}
long long fn(long long n, long long m) {
long long ans = 0;
for (int i = 0; i <= n; i++)
ans = (ans + ncr(i + m + 1, m)) % MOD;
return ans;
}
int main() {
precompute();
cin >> n1 >> m1 >> n2 >> m2;
cout << (fn(n2, m2) - fn(n1 - 1, m2) - fn(n2, m1 - 1) + fn(n1 - 1, m1 - 1) +
3LL * MOD) %
MOD;
} | #include "bits/stdc++.h"
using namespace std;
const int N = 2e6 + 20, MOD = (int)(1e9) + 7;
int f[N], ie[N], n1, m1, n2, m2;
int power(int a, int b) {
int num = a, ans = 1;
for (int i = 0; i < 31; i++) {
if (b & (1 << i))
ans = (1ll * ans * num) % MOD;
num = (1ll * num * num) % MOD;
}
return ans;
}
int inverse_euler(int n) { return power(n, MOD - 2); }
int ncr(int n, int r) {
return (1LL * f[n] * ((1LL * ie[r] * ie[n - r]) % MOD)) % MOD;
}
void precompute() {
f[0] = 1;
for (int i = 1; i < N; i++)
f[i] = (1LL * f[i - 1] * i) % MOD;
for (int i = 0; i < N; i++)
ie[i] = inverse_euler(f[i]);
}
long long fn(long long n, long long m) {
long long ans = 0;
for (int i = 0; i <= n; i++)
ans = (ans + ncr(i + m + 1, m)) % MOD;
return ans;
}
int main() {
precompute();
cin >> n1 >> m1 >> n2 >> m2;
cout << (fn(n2, m2) - fn(n1 - 1, m2) - fn(n2, m1 - 1) + fn(n1 - 1, m1 - 1) +
3LL * MOD) %
MOD;
} | replace | 3 | 4 | 3 | 4 | 0 | |
p02782 | C++ | Runtime Error | #include <bits/stdc++.h>
template <long long mod> class Combination {
std::vector<long long> fact, finv, inv;
public:
Combination(int sz) {
fact.resize(sz);
finv.resize(sz);
inv.resize(sz);
fact[0] = 1;
for (int i = 1; i < sz; ++i) {
fact[i] = fact[i - 1] * i % mod;
}
inv[0] = 0;
inv[1] = 1;
for (int i = 2; i < sz; ++i) {
inv[i] = mod - inv[mod % i] * (mod / i) % mod;
}
finv[0] = 1;
for (int i = 1; i < sz; ++i) {
finv[i] = finv[i - 1] * inv[i] % mod;
}
}
long long C(long long n, long long k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return (fact[n] * finv[k] % mod) * finv[n - k] % mod;
}
long long P(long long n, long long k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fact[n] * finv[n - k] % mod;
}
long long H(long long n, long long k) { return this->C(n + k - 1, k); }
long long getfact(int i) { return fact[i]; }
long long getinv(int i) { return inv[i]; }
long long getfinv(int i) { return finv[i]; }
};
using namespace std;
using ll = long long;
using ld = long double;
using P = pair<int, int>;
using vi = vector<int>;
using vvi = vector<vector<int>>;
using vll = vector<ll>;
using vvll = vector<vector<ll>>;
const double eps = 1e-10;
const ll MOD = 1000000007;
const int INF = 1000000000;
const ll LINF = 1ll << 50;
template <typename T> void printv(const vector<T> &s) {
for (int i = 0; i < (int)(s.size()); ++i) {
cout << s[i];
if (i == (int)(s.size()) - 1)
cout << endl;
else
cout << " ";
}
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> p) {
os << p.first << ":" << p.second;
return os;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
int r1, c1, r2, c2;
cin >> r1 >> c1 >> r2 >> c2;
Combination<MOD> comb(1000010);
ll ans = 0;
ans = comb.C(r2 + c2 + 2, c2 + 1) - 1;
ans += 2 * MOD - comb.C(r1 + c2 + 1, c2 + 1) + 1;
ans %= MOD;
ans += 2 * MOD - comb.C(r2 + c1 + 1, c1) + 1;
ans %= MOD;
ans += comb.C(r1 + c1, c1) - 1;
ans %= MOD;
cout << ans << endl;
}
| #include <bits/stdc++.h>
template <long long mod> class Combination {
std::vector<long long> fact, finv, inv;
public:
Combination(int sz) {
fact.resize(sz);
finv.resize(sz);
inv.resize(sz);
fact[0] = 1;
for (int i = 1; i < sz; ++i) {
fact[i] = fact[i - 1] * i % mod;
}
inv[0] = 0;
inv[1] = 1;
for (int i = 2; i < sz; ++i) {
inv[i] = mod - inv[mod % i] * (mod / i) % mod;
}
finv[0] = 1;
for (int i = 1; i < sz; ++i) {
finv[i] = finv[i - 1] * inv[i] % mod;
}
}
long long C(long long n, long long k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return (fact[n] * finv[k] % mod) * finv[n - k] % mod;
}
long long P(long long n, long long k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fact[n] * finv[n - k] % mod;
}
long long H(long long n, long long k) { return this->C(n + k - 1, k); }
long long getfact(int i) { return fact[i]; }
long long getinv(int i) { return inv[i]; }
long long getfinv(int i) { return finv[i]; }
};
using namespace std;
using ll = long long;
using ld = long double;
using P = pair<int, int>;
using vi = vector<int>;
using vvi = vector<vector<int>>;
using vll = vector<ll>;
using vvll = vector<vector<ll>>;
const double eps = 1e-10;
const ll MOD = 1000000007;
const int INF = 1000000000;
const ll LINF = 1ll << 50;
template <typename T> void printv(const vector<T> &s) {
for (int i = 0; i < (int)(s.size()); ++i) {
cout << s[i];
if (i == (int)(s.size()) - 1)
cout << endl;
else
cout << " ";
}
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> p) {
os << p.first << ":" << p.second;
return os;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
int r1, c1, r2, c2;
cin >> r1 >> c1 >> r2 >> c2;
Combination<MOD> comb(3000010);
ll ans = 0;
ans = comb.C(r2 + c2 + 2, c2 + 1) - 1;
ans += 2 * MOD - comb.C(r1 + c2 + 1, c2 + 1) + 1;
ans %= MOD;
ans += 2 * MOD - comb.C(r2 + c1 + 1, c1) + 1;
ans %= MOD;
ans += comb.C(r1 + c1, c1) - 1;
ans %= MOD;
cout << ans << endl;
}
| replace | 74 | 75 | 74 | 75 | 0 | |
p02782 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> P;
typedef pair<int, int> Pi;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define FOR(i, a, b) for (ll i = a; i < b; i++)
#define fi first
#define se second
#define endl "\n"
template <typename T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename T> ostream &operator<<(ostream &s, const complex<T> &d) {
return s << "(" << d.real() << ", " << d.imag() << ")";
}
template <typename T1, typename T2>
ostream &operator<<(ostream &s, const pair<T1, T2> &d) {
return s << "(" << d.first << ", " << d.second << ")";
}
template <typename T> ostream &operator<<(ostream &s, const vector<T> &d) {
int len = d.size();
rep(i, len) {
s << d[i];
if (i < len - 1)
s << " ";
}
return s;
}
template <typename T>
ostream &operator<<(ostream &s, const vector<vector<T>> &d) {
int len = d.size();
rep(i, len) { s << d[i] << endl; }
return s;
}
template <typename T> ostream &operator<<(ostream &s, const set<T> &v) {
s << "{ ";
for (auto itr = v.begin(); itr != v.end(); ++itr) {
if (itr != v.begin()) {
s << ", ";
}
s << (*itr);
}
s << " }";
return s;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &s, const map<T1, T2> &m) {
s << "{" << endl;
for (auto itr = m.begin(); itr != m.end(); ++itr) {
s << " " << (*itr).first << " : " << (*itr).second << endl;
}
s << "}" << endl;
return s;
}
const ll mod = 1e9 + 7;
const ll inf = 1e17;
const int INF = 1e9;
const double PI = acos(-1);
const double EPS = 1e-10;
struct mint {
ll x;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const {
mint res(*this);
return res += a;
}
mint operator-(const mint a) const {
mint res(*this);
return res -= a;
}
mint operator*(const mint a) const {
mint res(*this);
return res *= a;
}
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
// for prime mod
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint a) { return (*this) *= a.inv(); }
mint operator/(const mint a) const {
mint res(*this);
return res /= a;
}
};
struct combination {
vector<mint> fact, ifact;
combination(int n) : fact(n + 1), ifact(n + 1) {
assert(n < mod);
fact[0] = 1;
for (int i = 1; i <= n; ++i)
fact[i] = fact[i - 1] * i;
ifact[n] = fact[n].inv();
for (int i = n; i >= 1; --i)
ifact[i - 1] = ifact[i] * i;
}
mint operator()(int n, int k) {
if (k < 0 || k > n)
return 0;
return fact[n] * ifact[k] * ifact[n - k];
}
};
combination comb(1000010);
mint solve(int x, int y) {
mint ret = 0;
rep(i, x + 1) { ret += comb(i + 1 + y, y); }
return ret;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
vector<int> r(2), c(2);
cin >> r[0] >> c[0] >> r[1] >> c[1];
mint ans = solve(r[1], c[1]) - solve(r[1], c[0] - 1) -
(solve(r[0] - 1, c[1]) - solve(r[0] - 1, c[0] - 1));
cout << ans.x << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> P;
typedef pair<int, int> Pi;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define FOR(i, a, b) for (ll i = a; i < b; i++)
#define fi first
#define se second
#define endl "\n"
template <typename T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename T> ostream &operator<<(ostream &s, const complex<T> &d) {
return s << "(" << d.real() << ", " << d.imag() << ")";
}
template <typename T1, typename T2>
ostream &operator<<(ostream &s, const pair<T1, T2> &d) {
return s << "(" << d.first << ", " << d.second << ")";
}
template <typename T> ostream &operator<<(ostream &s, const vector<T> &d) {
int len = d.size();
rep(i, len) {
s << d[i];
if (i < len - 1)
s << " ";
}
return s;
}
template <typename T>
ostream &operator<<(ostream &s, const vector<vector<T>> &d) {
int len = d.size();
rep(i, len) { s << d[i] << endl; }
return s;
}
template <typename T> ostream &operator<<(ostream &s, const set<T> &v) {
s << "{ ";
for (auto itr = v.begin(); itr != v.end(); ++itr) {
if (itr != v.begin()) {
s << ", ";
}
s << (*itr);
}
s << " }";
return s;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &s, const map<T1, T2> &m) {
s << "{" << endl;
for (auto itr = m.begin(); itr != m.end(); ++itr) {
s << " " << (*itr).first << " : " << (*itr).second << endl;
}
s << "}" << endl;
return s;
}
const ll mod = 1e9 + 7;
const ll inf = 1e17;
const int INF = 1e9;
const double PI = acos(-1);
const double EPS = 1e-10;
struct mint {
ll x;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const {
mint res(*this);
return res += a;
}
mint operator-(const mint a) const {
mint res(*this);
return res -= a;
}
mint operator*(const mint a) const {
mint res(*this);
return res *= a;
}
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
// for prime mod
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint a) { return (*this) *= a.inv(); }
mint operator/(const mint a) const {
mint res(*this);
return res /= a;
}
};
struct combination {
vector<mint> fact, ifact;
combination(int n) : fact(n + 1), ifact(n + 1) {
assert(n < mod);
fact[0] = 1;
for (int i = 1; i <= n; ++i)
fact[i] = fact[i - 1] * i;
ifact[n] = fact[n].inv();
for (int i = n; i >= 1; --i)
ifact[i - 1] = ifact[i] * i;
}
mint operator()(int n, int k) {
if (k < 0 || k > n)
return 0;
return fact[n] * ifact[k] * ifact[n - k];
}
};
combination comb(3000010);
mint solve(int x, int y) {
mint ret = 0;
rep(i, x + 1) { ret += comb(i + 1 + y, y); }
return ret;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
vector<int> r(2), c(2);
cin >> r[0] >> c[0] >> r[1] >> c[1];
mint ans = solve(r[1], c[1]) - solve(r[1], c[0] - 1) -
(solve(r[0] - 1, c[1]) - solve(r[0] - 1, c[0] - 1));
cout << ans.x << endl;
} | replace | 140 | 141 | 140 | 141 | 0 | |
p02782 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef pair<int, int> PII;
template <class A, class B>
ostream &operator<<(ostream &out, const pair<A, B> &p) {
return out << "(" << p.first << ", " << p.second << ")";
}
template <typename T, size_t N>
ostream &operator<<(ostream &out, const array<T, N> &a) {
out << "[";
bool first = true;
for (auto &v : a) {
out << (first ? "" : ", ");
out << v;
first = 0;
}
out << "]";
return out;
}
template <typename T> ostream &operator<<(ostream &out, const vector<T> &a) {
out << "[";
bool first = true;
for (auto &v : a) {
out << (first ? "" : ", ");
out << v;
first = 0;
}
out << "]";
return out;
}
template <typename T, class Cmp>
ostream &operator<<(ostream &out, const set<T, Cmp> &a) {
out << "{";
bool first = true;
for (auto &v : a) {
out << (first ? "" : ", ");
out << v;
first = 0;
}
out << "}";
return out;
}
template <typename U, typename T, class Cmp>
ostream &operator<<(ostream &out, const map<U, T, Cmp> &a) {
out << "{";
bool first = true;
for (auto &p : a) {
out << (first ? "" : ", ");
out << p.first << ":" << p.second;
first = 0;
}
out << "}";
return out;
}
template <class T> inline void YES(T condition) {
if (condition)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
template <class T> inline void Yes(T condition) {
if (condition)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
template <class T> T gcd(T a, T b) {
if (a && b) {
return gcd(min(a, b), max(a, b) % min(a, b));
} else {
return a;
}
}
template <class T> T lcm(T a, T b) { return a / gcd(a, b) * b; }
long long qpow(long long a, long long b, int MOD) {
if (b == 0)
return 1;
long long res = 1;
while (b) {
if (b & 1)
res = (res * a) % MOD;
a = (a * a) % MOD;
b >>= 1;
}
return res;
}
const int MOD = 1e9 + 7;
const int maxn = 1e6;
int fac[maxn + 5];
int invfac[maxn + 5];
void init() {
fac[0] = 1;
for (int i = 1; i <= maxn; i++)
fac[i] = 1LL * fac[i - 1] * i % MOD;
invfac[maxn] = (int)(qpow(fac[maxn], MOD - 2, MOD));
for (int i = maxn - 1; i >= 0; i--)
invfac[i] = 1LL * invfac[i + 1] * (i + 1) % MOD;
}
int C(int n, int k) {
assert(0 <= k && n >= k);
int tmp = (int)(1LL * invfac[k] * invfac[n - k] % MOD);
return (int)(1LL * fac[n] * tmp % MOD);
}
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
init();
int r1, c1, r2, c2;
cin >> r1 >> c1 >> r2 >> c2;
LL ans = C(r1 + c1, r1);
for (int i = r1 + 1; i <= r2; i++)
ans = (ans + C(c2 + i, c2)) % MOD;
for (int j = c1 + 1; j <= c2; j++)
ans = (ans + C(r2 + j, j)) % MOD;
ans = ((ans % MOD) + MOD) % MOD;
cout << ans << '\n';
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef pair<int, int> PII;
template <class A, class B>
ostream &operator<<(ostream &out, const pair<A, B> &p) {
return out << "(" << p.first << ", " << p.second << ")";
}
template <typename T, size_t N>
ostream &operator<<(ostream &out, const array<T, N> &a) {
out << "[";
bool first = true;
for (auto &v : a) {
out << (first ? "" : ", ");
out << v;
first = 0;
}
out << "]";
return out;
}
template <typename T> ostream &operator<<(ostream &out, const vector<T> &a) {
out << "[";
bool first = true;
for (auto &v : a) {
out << (first ? "" : ", ");
out << v;
first = 0;
}
out << "]";
return out;
}
template <typename T, class Cmp>
ostream &operator<<(ostream &out, const set<T, Cmp> &a) {
out << "{";
bool first = true;
for (auto &v : a) {
out << (first ? "" : ", ");
out << v;
first = 0;
}
out << "}";
return out;
}
template <typename U, typename T, class Cmp>
ostream &operator<<(ostream &out, const map<U, T, Cmp> &a) {
out << "{";
bool first = true;
for (auto &p : a) {
out << (first ? "" : ", ");
out << p.first << ":" << p.second;
first = 0;
}
out << "}";
return out;
}
template <class T> inline void YES(T condition) {
if (condition)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
template <class T> inline void Yes(T condition) {
if (condition)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
template <class T> T gcd(T a, T b) {
if (a && b) {
return gcd(min(a, b), max(a, b) % min(a, b));
} else {
return a;
}
}
template <class T> T lcm(T a, T b) { return a / gcd(a, b) * b; }
long long qpow(long long a, long long b, int MOD) {
if (b == 0)
return 1;
long long res = 1;
while (b) {
if (b & 1)
res = (res * a) % MOD;
a = (a * a) % MOD;
b >>= 1;
}
return res;
}
const int MOD = 1e9 + 7;
const int maxn = 2e6;
int fac[maxn + 5];
int invfac[maxn + 5];
void init() {
fac[0] = 1;
for (int i = 1; i <= maxn; i++)
fac[i] = 1LL * fac[i - 1] * i % MOD;
invfac[maxn] = (int)(qpow(fac[maxn], MOD - 2, MOD));
for (int i = maxn - 1; i >= 0; i--)
invfac[i] = 1LL * invfac[i + 1] * (i + 1) % MOD;
}
int C(int n, int k) {
assert(0 <= k && n >= k);
int tmp = (int)(1LL * invfac[k] * invfac[n - k] % MOD);
return (int)(1LL * fac[n] * tmp % MOD);
}
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
init();
int r1, c1, r2, c2;
cin >> r1 >> c1 >> r2 >> c2;
LL ans = C(r1 + c1, r1);
for (int i = r1 + 1; i <= r2; i++)
ans = (ans + C(c2 + i, c2)) % MOD;
for (int j = c1 + 1; j <= c2; j++)
ans = (ans + C(r2 + j, j)) % MOD;
ans = ((ans % MOD) + MOD) % MOD;
cout << ans << '\n';
return 0;
}
| replace | 89 | 90 | 89 | 90 | 0 | |
p02782 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL_DEBUG
#include "LOCAL_DEBUG.hpp"
#endif
#define int long long
struct Combination {
const int MOD = 1e9 + 7;
vector<int> fact; // fact[i] = iの階乗
void init(int n) {
fact.resize(n + 1);
fact[0] = fact[1] = 1;
for (int i = 2; i <= n; i++) {
fact[i] = i * fact[i - 1] % MOD;
}
}
int nCr(int n, int r) { // nCr = n!/r!(n-r)!
if (n < r)
return 0;
return fact[n] * mod_pow(fact[r] * fact[n - r] % MOD, MOD - 2) % MOD;
}
int mod_pow(int n, int p) { // a/n ≡ a*n^(p-2) nとpは互いに素
int r = 1;
for (; p > 0; p >>= 1) {
if (p & 1LL)
r = (r * n) % MOD;
n = (n * n) % MOD;
}
return r; // r = n^p % MOD
}
} comb;
const int MOD = 1e9 + 7;
signed main() {
int x, y, p, q;
cin >> x >> y >> p >> q;
comb.init(1e6);
int ans = comb.nCr(p + 1 + q + 1, p + 1) - 1 - comb.nCr(x + q + 1, x) + 1 +
MOD - comb.nCr(p + y + 1, y) + 1 + comb.nCr(x + y, x) - 1;
cout << ans % MOD << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL_DEBUG
#include "LOCAL_DEBUG.hpp"
#endif
#define int long long
struct Combination {
const int MOD = 1e9 + 7;
vector<int> fact; // fact[i] = iの階乗
void init(int n) {
fact.resize(n + 1);
fact[0] = fact[1] = 1;
for (int i = 2; i <= n; i++) {
fact[i] = i * fact[i - 1] % MOD;
}
}
int nCr(int n, int r) { // nCr = n!/r!(n-r)!
if (n < r)
return 0;
return fact[n] * mod_pow(fact[r] * fact[n - r] % MOD, MOD - 2) % MOD;
}
int mod_pow(int n, int p) { // a/n ≡ a*n^(p-2) nとpは互いに素
int r = 1;
for (; p > 0; p >>= 1) {
if (p & 1LL)
r = (r * n) % MOD;
n = (n * n) % MOD;
}
return r; // r = n^p % MOD
}
} comb;
const int MOD = 1e9 + 7;
signed main() {
int x, y, p, q;
cin >> x >> y >> p >> q;
comb.init(2e6 + 2);
int ans = comb.nCr(p + 1 + q + 1, p + 1) - 1 - comb.nCr(x + q + 1, x) + 1 -
comb.nCr(p + y + 1, y) + 1 + comb.nCr(x + y, x) - 1;
cout << (ans + MOD * 9) % MOD << endl;
return 0;
}
| replace | 44 | 48 | 44 | 48 | 0 | |
p02782 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define FOR(i, l, r) for (long long i = (l); i < (r); ++i)
#define REP(i, n) FOR(i, 0, n)
#define REPS(i, n) FOR(i, 1, n + 1)
#define RFOR(i, l, r) for (long long i = (l); i >= (r); --i)
#define RREP(i, n) RFOR(i, n - 1, 0)
#define RREPS(i, n) RFOR(i, n, 1)
#define int long long
#define mp make_pair
#define pb push_back
#define eb emplace_back
#define SZ(x) ((int)(x).size())
#define all(x) (x).begin(), (x).end()
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
const int INF = 1e18;
const int MOD = 1e9 + 7;
const int MAX = 300001;
int fac[MAX], finv[MAX], inv[MAX];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
int COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
int powMOD(int n, int r) {
if (r == 0)
return 1;
if (r % 2 == 0)
return powMOD(n, r / 2) * powMOD(n, r / 2) % MOD;
if (r % 2 == 1)
return powMOD(n, r - 1) * n % MOD;
}
signed main() {
COMinit();
int a, b, c, d;
cin >> a >> b >> c >> d;
int ans = 0;
for (int i = a + 1; i <= c + 1; i++) {
ans += COM(i + d, d) - COM(i + b - 1, b - 1);
ans %= MOD;
}
if (ans < 0)
ans += MOD;
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define FOR(i, l, r) for (long long i = (l); i < (r); ++i)
#define REP(i, n) FOR(i, 0, n)
#define REPS(i, n) FOR(i, 1, n + 1)
#define RFOR(i, l, r) for (long long i = (l); i >= (r); --i)
#define RREP(i, n) RFOR(i, n - 1, 0)
#define RREPS(i, n) RFOR(i, n, 1)
#define int long long
#define mp make_pair
#define pb push_back
#define eb emplace_back
#define SZ(x) ((int)(x).size())
#define all(x) (x).begin(), (x).end()
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
const int INF = 1e18;
const int MOD = 1e9 + 7;
const int MAX = 2000010;
int fac[MAX], finv[MAX], inv[MAX];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
int COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
int powMOD(int n, int r) {
if (r == 0)
return 1;
if (r % 2 == 0)
return powMOD(n, r / 2) * powMOD(n, r / 2) % MOD;
if (r % 2 == 1)
return powMOD(n, r - 1) * n % MOD;
}
signed main() {
COMinit();
int a, b, c, d;
cin >> a >> b >> c >> d;
int ans = 0;
for (int i = a + 1; i <= c + 1; i++) {
ans += COM(i + d, d) - COM(i + b - 1, b - 1);
ans %= MOD;
}
if (ans < 0)
ans += MOD;
cout << ans << endl;
}
| replace | 30 | 31 | 30 | 31 | 0 | |
p02782 | C++ | Runtime Error | #include <iostream>
using namespace std;
const int M = 1000000007;
class ModComb {
long long *fact, *facti;
const int mod;
public:
explicit ModComb(int n, int m) : mod(m) {
fact = new long long[n + 1];
facti = new long long[n + 1];
fact[0] = 1;
facti[0] = 1;
for (int i = 1; i <= n; i++)
fact[i] = (fact[i - 1] * i) % m;
// calc 1/n!
long long &inv = facti[n], pw = fact[n];
inv = 1;
for (int e = mod - 2; e > 0; e /= 2) {
if (e & 1)
inv = inv * pw % mod;
pw = pw * pw % mod;
}
for (int i = n - 1; i > 0; i--)
facti[i] = (facti[i + 1] * (i + 1)) % m;
}
~ModComb() {
if (fact)
delete[] fact;
if (facti)
delete[] facti;
}
long long get(int n, int k) const {
if (n < 0 || k < 0 || k > n)
return 0;
return fact[n] * facti[k] % mod * facti[n - k] % mod;
}
long long getPerm(int n, int k) const {
if (n < 0 || k < 0 || k > n)
return 0;
return fact[n] * facti[n - k] % mod;
}
} mc(1001001, M);
long long g(int r, int c) {
long long ret = 0;
for (int a = 0; a <= r; a++)
ret += mc.get(a + c + 1, a + 1);
return ret % M;
}
int main() {
int r1, c1, r2, c2;
cin >> r1 >> c1 >> r2 >> c2;
long long ans = g(r2, c2) - g(r2, c1 - 1) - g(r1 - 1, c2) + g(r1 - 1, c1 - 1);
cout << (ans % M + M) % M << endl;
}
| #include <iostream>
using namespace std;
const int M = 1000000007;
class ModComb {
long long *fact, *facti;
const int mod;
public:
explicit ModComb(int n, int m) : mod(m) {
fact = new long long[n + 1];
facti = new long long[n + 1];
fact[0] = 1;
facti[0] = 1;
for (int i = 1; i <= n; i++)
fact[i] = (fact[i - 1] * i) % m;
// calc 1/n!
long long &inv = facti[n], pw = fact[n];
inv = 1;
for (int e = mod - 2; e > 0; e /= 2) {
if (e & 1)
inv = inv * pw % mod;
pw = pw * pw % mod;
}
for (int i = n - 1; i > 0; i--)
facti[i] = (facti[i + 1] * (i + 1)) % m;
}
~ModComb() {
if (fact)
delete[] fact;
if (facti)
delete[] facti;
}
long long get(int n, int k) const {
if (n < 0 || k < 0 || k > n)
return 0;
return fact[n] * facti[k] % mod * facti[n - k] % mod;
}
long long getPerm(int n, int k) const {
if (n < 0 || k < 0 || k > n)
return 0;
return fact[n] * facti[n - k] % mod;
}
} mc(2001001, M);
long long g(int r, int c) {
long long ret = 0;
for (int a = 0; a <= r; a++)
ret += mc.get(a + c + 1, a + 1);
return ret % M;
}
int main() {
int r1, c1, r2, c2;
cin >> r1 >> c1 >> r2 >> c2;
long long ans = g(r2, c2) - g(r2, c1 - 1) - g(r1 - 1, c2) + g(r1 - 1, c1 - 1);
cout << (ans % M + M) % M << endl;
}
| replace | 46 | 47 | 46 | 47 | 0 | |
p02782 | C++ | Runtime Error | #include <bits/stdc++.h>
#define int long long
#define f first
#define s second
using namespace std;
const int N = 1000009, mod = 1e9 + 7;
int f[N], iv[N];
int pw(int a, int t = mod - 2) {
int x = 1;
while (t) {
if (t & 1)
x = x * a % mod;
a = a * a % mod, t >>= 1;
}
return x;
}
int C(int n, int r) {
int x = (((f[n] * iv[r]) % mod) * iv[n - r]) % mod;
return x;
}
int32_t main() {
if (fopen("input.txt", "r"))
freopen("input.txt", "r", stdin), freopen("output.txt", "w", stdout);
ios::sync_with_stdio(0), cin.tie(0);
f[0] = 1, iv[0] = 1;
for (int i = 1; i < N; i++) {
f[i] = i * f[i - 1] % mod;
iv[i] = pw(f[i]);
}
int r1, r2, c1, c2, sum = 0;
cin >> r1 >> c1 >> r2 >> c2;
for (int i = c1; i <= c2; i++)
sum = (sum + (C(r2 + i + 1, r2) + mod - C(r1 + i, r1 - 1))) % mod;
cout << sum;
} | #include <bits/stdc++.h>
#define int long long
#define f first
#define s second
using namespace std;
const int N = 3000009, mod = 1e9 + 7;
int f[N], iv[N];
int pw(int a, int t = mod - 2) {
int x = 1;
while (t) {
if (t & 1)
x = x * a % mod;
a = a * a % mod, t >>= 1;
}
return x;
}
int C(int n, int r) {
int x = (((f[n] * iv[r]) % mod) * iv[n - r]) % mod;
return x;
}
int32_t main() {
if (fopen("input.txt", "r"))
freopen("input.txt", "r", stdin), freopen("output.txt", "w", stdout);
ios::sync_with_stdio(0), cin.tie(0);
f[0] = 1, iv[0] = 1;
for (int i = 1; i < N; i++) {
f[i] = i * f[i - 1] % mod;
iv[i] = pw(f[i]);
}
int r1, r2, c1, c2, sum = 0;
cin >> r1 >> c1 >> r2 >> c2;
for (int i = c1; i <= c2; i++)
sum = (sum + (C(r2 + i + 1, r2) + mod - C(r1 + i, r1 - 1))) % mod;
cout << sum;
} | replace | 5 | 6 | 5 | 6 | 0 | |
p02782 | C++ | Runtime Error | #include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <complex>
#include <cstdint>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <queue>
#include <random>
#include <regex>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <sys/timeb.h>
#include <vector>
using namespace std;
#define repr(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define rep(i, n) repr(i, 0, n)
#define reprrev(i, a, b) for (int i = (int)(b)-1; i >= (int)(a); i--)
#define reprev(i, n) reprrev(i, 0, n)
#define repi(itr, ds) for (auto itr = ds.begin(); itr != ds.end(); itr++)
#define chmin(mi, value) mi = min(mi, value)
#define chmax(ma, value) ma = max(ma, value)
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define mp make_pair
#define mt make_tuple
#define INF 1050000000
#define INFR INT_MAX
#define INFL (long long)(4e18)
#define INFLR LLONG_MAX
#define EPS (1e-10)
#define MOD 1000000007
// #define MOD 998244353
#define PI 3.141592653589793238
#define RMAX 4294967295
using vi = vector<int>;
using vvi = vector<vector<int>>;
using vvvi = vector<vector<vector<int>>>;
using vvvvi = vector<vector<vector<vector<int>>>>;
using ll = long long;
using vll = vector<ll>;
using vvll = vector<vector<ll>>;
using vvvll = vector<vector<vector<ll>>>;
using vd = vector<double>;
using vvd = vector<vector<double>>;
using vvvd = vector<vector<vector<double>>>;
using vb = vector<bool>;
using vvb = vector<vector<bool>>;
using vc = vector<char>;
using vvc = vector<vector<char>>;
using vs = vector<string>;
using vvs = vector<vector<string>>;
using Pi = pair<int, int>;
using vPi = vector<Pi>;
using vvPi = vector<vector<Pi>>;
using vvvPi = vector<vector<vector<Pi>>>;
using vvvvPi = vector<vector<vector<vector<Pi>>>>;
using Pll = pair<ll, ll>;
using vPll = vector<Pll>;
using Pd = pair<double, double>;
using vPd = vector<Pd>;
template <class T> using vec = vector<T>;
template <class T> using pql = priority_queue<T, vector<T>, greater<T>>;
using Comp = complex<double>;
// vvvvvvvvvvvvvvvvvvvvvvv debug output vvvvvvvvvvvvvvvvvvvvvvv
// vector input
template <typename T> istream &operator>>(istream &is, vector<T> &vec) {
for (T &x : vec)
is >> x;
return is;
}
// pair
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &pair_var) {
os << "(" << pair_var.first << ", " << pair_var.second << ")";
return os;
}
// vector
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec) {
os << "{";
for (int i = 0; i < vec.size(); i++) {
os << vec[i] << (i + 1 == vec.size() ? "" : ", ");
}
os << "}";
return os;
}
// deque
template <typename T> ostream &operator<<(ostream &os, const deque<T> &vec) {
os << "{";
for (int i = 0; i < vec.size(); i++) {
os << vec[i] << (i + 1 == vec.size() ? "" : ", ");
}
os << "}";
return os;
}
// map
template <typename T, typename U>
ostream &operator<<(ostream &os, const map<T, U> &map_var) {
os << "{";
repi(itr, map_var) {
os << *itr;
itr++;
if (itr != map_var.end())
os << ", ";
itr--;
}
os << "}";
return os;
}
// set
template <typename T> ostream &operator<<(ostream &os, const set<T> &set_var) {
os << "{";
repi(itr, set_var) {
os << *itr;
itr++;
if (itr != set_var.end())
os << ", ";
itr--;
}
os << "}";
return os;
}
// multiset
template <typename T>
ostream &operator<<(ostream &os, const multiset<T> &set_var) {
os << "{";
repi(itr, set_var) {
os << *itr;
itr++;
if (itr != set_var.end())
os << ", ";
itr--;
}
os << "}";
return os;
}
#define DUMPOUT cerr
void dump_func() { DUMPOUT << endl; }
template <class Head, class... Tail>
void dump_func(Head &&head, Tail &&...tail) {
DUMPOUT << head;
if (sizeof...(Tail) > 0) {
DUMPOUT << ", ";
}
dump_func(std::move(tail)...);
}
#ifdef DEBUG_
#define DEB
#define dump(...) \
DUMPOUT << " " << string(#__VA_ARGS__) << ": " \
<< "[" << to_string(__LINE__) << ":" << __FUNCTION__ << "]" << endl \
<< " ", \
dump_func(__VA_ARGS__)
#else
#define DEB if (false)
#define dump(...)
#endif
// ^^^^^^^^^^^^^^^^^^^^^^^ debug output ^^^^^^^^^^^^^^^^^^^^^^^
string YN(bool y, int id = 0) {
if (id)
cout << id;
return (y ? "YES" : "NO");
}
string yn(bool y, int id = 0) {
if (id)
cout << id;
return (y ? "Yes" : "No");
}
string ON(bool y, int id = 0) {
if (id)
cout << id;
return (y ? "OK" : "NG");
}
int dir4[4][2] = {{0, -1}, {-1, 0}, {1, 0}, {0, 1}};
int dir8[8][2] = {{-1, -1}, {0, -1}, {1, -1}, {-1, 0},
{1, 0}, {-1, 1}, {0, 1}, {1, 1}};
// [a,b)
int irand(int a, int b) {
static mt19937 Rand(static_cast<unsigned int>(time(nullptr)));
uniform_int_distribution<int> dist(a, b - 1);
return dist(Rand);
}
// [a,b)
double drand(int a, int b) {
static mt19937 Rand(static_cast<unsigned int>(time(nullptr)));
uniform_real_distribution<double> dist(a, b);
return dist(Rand);
}
// https://qiita.com/IgnorantCoder/items/3101d6276e9bdddf872c
template <typename A, typename F> inline auto transform(const A &v, F &&f) {
using result_type =
decltype(std::declval<F>()(std::declval<typename A::value_type>()));
vector<result_type> y(v.size());
std::transform(std::cbegin(v), std::cend(v), std::begin(y), f);
return y;
}
// generate vector which has multiple dimension
template <class T> vector<T> make_v(size_t size, const T &init) {
return vector<T>(size, init);
}
template <class... Ts> auto make_v(size_t size, Ts... rest) {
return vector<decltype(make_v(rest...))>(size, make_v(rest...));
}
template <typename T> T Max(vector<T> a) { return *max_element(all(a)); }
template <typename T> T Min(vector<T> a) { return *min_element(all(a)); }
template <typename T> T Sum(vector<T> a) { return accumulate(all(a), (T)0); }
// for counting using map
template <typename T> void Add(map<T, int> &m, T item) {
if (m.find(item) == m.end()) {
m[item] = 1;
} else {
m[item]++;
}
}
// for counting using map
template <typename T> void Erase(map<T, int> &m, T item) {
if (m.find(item) == m.end()) {
} else {
if (m[item] == 1) {
m.erase(item);
} else {
m[item]--;
}
}
}
// get method for map with default value
template <typename T, typename U> U Get(map<T, U> m, T key, U def) {
if (m.find(key) == m.end()) {
return def;
} else {
return m[key];
}
}
template <typename T> inline bool Contains(const set<T> &t, const T &key) {
return t.find(key) != t.end();
}
template <typename T, typename U>
inline bool Contains(const map<T, U> &t, const T &key) {
return t.find(key) != t.end();
}
template <class T> struct Edge {
int from, to;
T cost;
Edge(int f, int t, T c) : from(f), to(t), cost(c) {}
};
template <class T> bool operator<(const Edge<T> e1, const Edge<T> e2) {
return e1.cost < e2.cost || (e1.cost == e2.cost && e1.from < e2.from) ||
(e1.cost == e2.cost && e1.from == e2.from && e1.to < e2.to);
}
template <class T> ostream &operator<<(ostream &os, const Edge<T> &edge) {
os << "(" << edge.from << "->" << edge.to << ":" << edge.cost << ")";
return os;
}
template <class T = int> class Graph {
int n;
bool directed;
vector<vector<Edge<T>>> edges;
public:
Graph(int n, bool directed)
: n(n), directed(directed), edges(vector<vector<Edge<T>>>(n)) {}
void add_edge(int s, int t, T cost) {
edges[s].emplace_back(s, t, cost);
if (!directed) {
edges[t].emplace_back(t, s, cost);
}
}
Graph() {}
vector<Edge<T>> &operator[](size_t i) { return edges[i]; }
int size() const { return n; }
};
//======================================================
// 階乗・組み合わせのモジュラ逆数
class FactorialMod {
// モジュラ逆数を求める(modが素数と仮定)
void ModInv() {
inv[0] = 0;
inv[1] = 1;
for (int i = 2; i <= n; i++) {
inv[i] = mod - ((mod / i) * inv[mod % i] % mod);
}
}
// n!をmodで割った余り
void FacInv() {
fac[0] = facinv[0] = 1;
for (int i = 1; i <= n; i++) {
fac[i] = (fac[i - 1] * i) % mod;
facinv[i] = (facinv[i - 1] * (int)inv[i]) % mod;
}
}
public:
int n;
int mod;
vector<long long> inv;
vector<long long> fac;
vector<long long> facinv;
FactorialMod(int _n, int _mod)
: n(_n), mod(_mod), inv(vector<long long>(_n + 1)),
fac(vector<long long>(_n + 1)), facinv(vector<long long>(_n + 1)) {
ModInv();
FacInv();
}
ll CombiMod(int r, int k) {
if (r == 0 && k == 0)
return 1;
if (r <= 0 || k < 0 || k > r)
return 0;
if (k == 0)
return 1;
return (((fac[r] * facinv[k]) % mod) * facinv[r - k]) % mod;
}
};
int main(void) {
int r1, c1, r2, c2;
cin >> r1 >> c1 >> r2 >> c2;
FactorialMod fm(200002, MOD);
ll ans = fm.CombiMod(r2 + c2 + 2, r2 + 1);
(ans += MOD - fm.CombiMod(r1 + c2 + 1, r1)) %= MOD;
(ans += MOD - fm.CombiMod(r2 + c1 + 1, r2 + 1)) %= MOD;
(ans += fm.CombiMod(r1 + c1, r1)) %= MOD;
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <complex>
#include <cstdint>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <queue>
#include <random>
#include <regex>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <sys/timeb.h>
#include <vector>
using namespace std;
#define repr(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define rep(i, n) repr(i, 0, n)
#define reprrev(i, a, b) for (int i = (int)(b)-1; i >= (int)(a); i--)
#define reprev(i, n) reprrev(i, 0, n)
#define repi(itr, ds) for (auto itr = ds.begin(); itr != ds.end(); itr++)
#define chmin(mi, value) mi = min(mi, value)
#define chmax(ma, value) ma = max(ma, value)
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define mp make_pair
#define mt make_tuple
#define INF 1050000000
#define INFR INT_MAX
#define INFL (long long)(4e18)
#define INFLR LLONG_MAX
#define EPS (1e-10)
#define MOD 1000000007
// #define MOD 998244353
#define PI 3.141592653589793238
#define RMAX 4294967295
using vi = vector<int>;
using vvi = vector<vector<int>>;
using vvvi = vector<vector<vector<int>>>;
using vvvvi = vector<vector<vector<vector<int>>>>;
using ll = long long;
using vll = vector<ll>;
using vvll = vector<vector<ll>>;
using vvvll = vector<vector<vector<ll>>>;
using vd = vector<double>;
using vvd = vector<vector<double>>;
using vvvd = vector<vector<vector<double>>>;
using vb = vector<bool>;
using vvb = vector<vector<bool>>;
using vc = vector<char>;
using vvc = vector<vector<char>>;
using vs = vector<string>;
using vvs = vector<vector<string>>;
using Pi = pair<int, int>;
using vPi = vector<Pi>;
using vvPi = vector<vector<Pi>>;
using vvvPi = vector<vector<vector<Pi>>>;
using vvvvPi = vector<vector<vector<vector<Pi>>>>;
using Pll = pair<ll, ll>;
using vPll = vector<Pll>;
using Pd = pair<double, double>;
using vPd = vector<Pd>;
template <class T> using vec = vector<T>;
template <class T> using pql = priority_queue<T, vector<T>, greater<T>>;
using Comp = complex<double>;
// vvvvvvvvvvvvvvvvvvvvvvv debug output vvvvvvvvvvvvvvvvvvvvvvv
// vector input
template <typename T> istream &operator>>(istream &is, vector<T> &vec) {
for (T &x : vec)
is >> x;
return is;
}
// pair
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &pair_var) {
os << "(" << pair_var.first << ", " << pair_var.second << ")";
return os;
}
// vector
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec) {
os << "{";
for (int i = 0; i < vec.size(); i++) {
os << vec[i] << (i + 1 == vec.size() ? "" : ", ");
}
os << "}";
return os;
}
// deque
template <typename T> ostream &operator<<(ostream &os, const deque<T> &vec) {
os << "{";
for (int i = 0; i < vec.size(); i++) {
os << vec[i] << (i + 1 == vec.size() ? "" : ", ");
}
os << "}";
return os;
}
// map
template <typename T, typename U>
ostream &operator<<(ostream &os, const map<T, U> &map_var) {
os << "{";
repi(itr, map_var) {
os << *itr;
itr++;
if (itr != map_var.end())
os << ", ";
itr--;
}
os << "}";
return os;
}
// set
template <typename T> ostream &operator<<(ostream &os, const set<T> &set_var) {
os << "{";
repi(itr, set_var) {
os << *itr;
itr++;
if (itr != set_var.end())
os << ", ";
itr--;
}
os << "}";
return os;
}
// multiset
template <typename T>
ostream &operator<<(ostream &os, const multiset<T> &set_var) {
os << "{";
repi(itr, set_var) {
os << *itr;
itr++;
if (itr != set_var.end())
os << ", ";
itr--;
}
os << "}";
return os;
}
#define DUMPOUT cerr
void dump_func() { DUMPOUT << endl; }
template <class Head, class... Tail>
void dump_func(Head &&head, Tail &&...tail) {
DUMPOUT << head;
if (sizeof...(Tail) > 0) {
DUMPOUT << ", ";
}
dump_func(std::move(tail)...);
}
#ifdef DEBUG_
#define DEB
#define dump(...) \
DUMPOUT << " " << string(#__VA_ARGS__) << ": " \
<< "[" << to_string(__LINE__) << ":" << __FUNCTION__ << "]" << endl \
<< " ", \
dump_func(__VA_ARGS__)
#else
#define DEB if (false)
#define dump(...)
#endif
// ^^^^^^^^^^^^^^^^^^^^^^^ debug output ^^^^^^^^^^^^^^^^^^^^^^^
string YN(bool y, int id = 0) {
if (id)
cout << id;
return (y ? "YES" : "NO");
}
string yn(bool y, int id = 0) {
if (id)
cout << id;
return (y ? "Yes" : "No");
}
string ON(bool y, int id = 0) {
if (id)
cout << id;
return (y ? "OK" : "NG");
}
int dir4[4][2] = {{0, -1}, {-1, 0}, {1, 0}, {0, 1}};
int dir8[8][2] = {{-1, -1}, {0, -1}, {1, -1}, {-1, 0},
{1, 0}, {-1, 1}, {0, 1}, {1, 1}};
// [a,b)
int irand(int a, int b) {
static mt19937 Rand(static_cast<unsigned int>(time(nullptr)));
uniform_int_distribution<int> dist(a, b - 1);
return dist(Rand);
}
// [a,b)
double drand(int a, int b) {
static mt19937 Rand(static_cast<unsigned int>(time(nullptr)));
uniform_real_distribution<double> dist(a, b);
return dist(Rand);
}
// https://qiita.com/IgnorantCoder/items/3101d6276e9bdddf872c
template <typename A, typename F> inline auto transform(const A &v, F &&f) {
using result_type =
decltype(std::declval<F>()(std::declval<typename A::value_type>()));
vector<result_type> y(v.size());
std::transform(std::cbegin(v), std::cend(v), std::begin(y), f);
return y;
}
// generate vector which has multiple dimension
template <class T> vector<T> make_v(size_t size, const T &init) {
return vector<T>(size, init);
}
template <class... Ts> auto make_v(size_t size, Ts... rest) {
return vector<decltype(make_v(rest...))>(size, make_v(rest...));
}
template <typename T> T Max(vector<T> a) { return *max_element(all(a)); }
template <typename T> T Min(vector<T> a) { return *min_element(all(a)); }
template <typename T> T Sum(vector<T> a) { return accumulate(all(a), (T)0); }
// for counting using map
template <typename T> void Add(map<T, int> &m, T item) {
if (m.find(item) == m.end()) {
m[item] = 1;
} else {
m[item]++;
}
}
// for counting using map
template <typename T> void Erase(map<T, int> &m, T item) {
if (m.find(item) == m.end()) {
} else {
if (m[item] == 1) {
m.erase(item);
} else {
m[item]--;
}
}
}
// get method for map with default value
template <typename T, typename U> U Get(map<T, U> m, T key, U def) {
if (m.find(key) == m.end()) {
return def;
} else {
return m[key];
}
}
template <typename T> inline bool Contains(const set<T> &t, const T &key) {
return t.find(key) != t.end();
}
template <typename T, typename U>
inline bool Contains(const map<T, U> &t, const T &key) {
return t.find(key) != t.end();
}
template <class T> struct Edge {
int from, to;
T cost;
Edge(int f, int t, T c) : from(f), to(t), cost(c) {}
};
template <class T> bool operator<(const Edge<T> e1, const Edge<T> e2) {
return e1.cost < e2.cost || (e1.cost == e2.cost && e1.from < e2.from) ||
(e1.cost == e2.cost && e1.from == e2.from && e1.to < e2.to);
}
template <class T> ostream &operator<<(ostream &os, const Edge<T> &edge) {
os << "(" << edge.from << "->" << edge.to << ":" << edge.cost << ")";
return os;
}
template <class T = int> class Graph {
int n;
bool directed;
vector<vector<Edge<T>>> edges;
public:
Graph(int n, bool directed)
: n(n), directed(directed), edges(vector<vector<Edge<T>>>(n)) {}
void add_edge(int s, int t, T cost) {
edges[s].emplace_back(s, t, cost);
if (!directed) {
edges[t].emplace_back(t, s, cost);
}
}
Graph() {}
vector<Edge<T>> &operator[](size_t i) { return edges[i]; }
int size() const { return n; }
};
//======================================================
// 階乗・組み合わせのモジュラ逆数
class FactorialMod {
// モジュラ逆数を求める(modが素数と仮定)
void ModInv() {
inv[0] = 0;
inv[1] = 1;
for (int i = 2; i <= n; i++) {
inv[i] = mod - ((mod / i) * inv[mod % i] % mod);
}
}
// n!をmodで割った余り
void FacInv() {
fac[0] = facinv[0] = 1;
for (int i = 1; i <= n; i++) {
fac[i] = (fac[i - 1] * i) % mod;
facinv[i] = (facinv[i - 1] * (int)inv[i]) % mod;
}
}
public:
int n;
int mod;
vector<long long> inv;
vector<long long> fac;
vector<long long> facinv;
FactorialMod(int _n, int _mod)
: n(_n), mod(_mod), inv(vector<long long>(_n + 1)),
fac(vector<long long>(_n + 1)), facinv(vector<long long>(_n + 1)) {
ModInv();
FacInv();
}
ll CombiMod(int r, int k) {
if (r == 0 && k == 0)
return 1;
if (r <= 0 || k < 0 || k > r)
return 0;
if (k == 0)
return 1;
return (((fac[r] * facinv[k]) % mod) * facinv[r - k]) % mod;
}
};
int main(void) {
int r1, c1, r2, c2;
cin >> r1 >> c1 >> r2 >> c2;
FactorialMod fm(2000002, MOD);
ll ans = fm.CombiMod(r2 + c2 + 2, r2 + 1);
(ans += MOD - fm.CombiMod(r1 + c2 + 1, r1)) %= MOD;
(ans += MOD - fm.CombiMod(r2 + c1 + 1, r2 + 1)) %= MOD;
(ans += fm.CombiMod(r1 + c1, r1)) %= MOD;
cout << ans << endl;
return 0;
}
| replace | 357 | 358 | 357 | 358 | 0 | |
p02782 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vb = vector<bool>;
using vvb = vector<vb>;
using vd = vector<double>;
using vvd = vector<vd>;
using vi = vector<int>;
using vvi = vector<vi>;
using vl = vector<ll>;
using vvl = vector<vl>;
using pll = pair<ll, ll>;
using tll = tuple<ll, ll>;
using tlll = tuple<ll, ll, ll>;
using vs = vector<string>;
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define rep(i, n) range(i, 0, n)
#define rrep(i, n) for (ll i = (n)-1; i >= 0; i--)
#define range(i, a, n) for (ll i = (a); i < (n); i++)
#define LINF ((ll)1ll << 60)
#define INF ((int)1 << 30)
#define EPS (1e-9)
#define MOD (1000000007ll)
#define fcout(a) cout << setprecision(a) << fixed
#define fs first
#define sc second
#define PI (3.1415926535897932384)
int dx[] = {1, 0, -1, 0, 1, -1, -1, 1}, dy[] = {0, 1, 0, -1, 1, 1, -1, -1};
template <class T> bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class S> S sum(vector<S> &a) { return accumulate(all(a), S()); }
template <class S> S max(vector<S> &a) { return *max_element(all(a)); }
template <class S> S min(vector<S> &a) { return *min_element(all(a)); }
ll max(int a, ll b) { return max((ll)a, b); }
ll max(ll a, int b) { return max(a, (ll)b); }
int sgn(const double &r) { return (r > EPS) - (r < -EPS); } // a>0 : sgn(a)>0
int sgn(const double &a, const double &b) {
return sgn(a - b);
} // b<=c : sgn(b,c)<=0
template <class T> void puta(T &&t) { cout << t << "\n"; }
template <class H, class... T> void puta(H &&h, T &&...t) {
cout << h << ' ';
puta(t...);
}
template <class S, class T> void tf(bool b, S t, T f) {
if (b)
puta(t);
else
puta(f);
}
void YN(bool b) { tf(b, "YES", "NO"); }
void Yn(bool b) { tf(b, "Yes", "No"); }
void yn(bool b) { tf(b, "yes", "no"); }
template <class S, class T> ostream &operator<<(ostream &os, pair<S, T> p) {
os << "[" << p.first << ", " << p.second << "]";
return os;
};
template <class S> auto &operator<<(ostream &os, vector<S> t) {
bool a = 1;
for (auto s : t) {
os << (a ? "" : " ") << s;
a = 0;
}
return os;
}
template <class S> auto &operator>>(istream &is, vector<S> &t) {
for (S &a : t)
cin >> a;
return is;
}
/*他のライブラリを入れる場所*/
template <int _MOD> struct modint {
ll val;
constexpr static int setModMax = 510000;
static modint<_MOD> fac[setModMax], finv[setModMax], inv[setModMax];
static constexpr ll mod(ll a) { return (a % _MOD + _MOD) % _MOD; }
constexpr modint(ll v = 0) noexcept : val(v % _MOD) {
if (val < 0)
v += _MOD;
}
constexpr int getmod() { return _MOD; }
constexpr modint operator-() const noexcept { return val ? _MOD - val : 0; }
constexpr modint operator+(const modint &r) const noexcept {
return modint(*this) += r;
}
constexpr modint operator-(const modint &r) const noexcept {
return modint(*this) -= r;
}
constexpr modint operator*(const modint &r) const noexcept {
return modint(*this) *= r;
}
constexpr modint operator/(const modint &r) const noexcept {
return modint(*this) /= r;
}
constexpr modint operator^(const modint &r) const noexcept {
return modint(*this) ^= r;
}
constexpr modint &operator+=(const modint &r) noexcept {
val = mod(val + r.val);
return *this;
}
constexpr modint &operator-=(const modint &r) noexcept {
val = mod(val - r.val);
return *this;
}
constexpr modint &operator*=(const modint &r) noexcept {
val = mod(val * r.val);
return *this;
}
constexpr modint &operator/=(const modint &r) noexcept {
ll a = r.val, b = _MOD, u = 1, v = 0;
while (b) {
ll t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
val = val * u % _MOD;
if (val < 0)
val += _MOD;
return *this;
}
constexpr modint &operator^=(const modint &r) noexcept {
val = modpow(val, r.val).val;
return *this;
}
constexpr bool operator<(const modint &r) const noexcept {
return this->val < r.val;
}
constexpr bool operator>(const modint &r) const noexcept { return r < *this; }
constexpr bool operator!=(const modint &r) const noexcept {
return *this < r || *this > r;
}
constexpr bool operator==(const modint &r) const noexcept {
return !(*this != r);
}
constexpr bool operator<=(const modint &r) const noexcept {
return !(*this > r);
}
constexpr bool operator>=(const modint &r) const noexcept {
return !(*this < r);
}
friend constexpr ostream &operator<<(ostream &os,
const modint<_MOD> &x) noexcept {
return os << x.val;
}
friend constexpr istream &operator>>(istream &is, modint<_MOD> &x) noexcept {
return is >> x.val;
}
constexpr modint<_MOD> modpow(const modint<_MOD> &a, ll n) noexcept {
if (n == 0)
return 1;
auto t = modpow(a, n / 2);
t *= t;
if (n & 1)
t *= a;
return t;
}
friend modint<_MOD> operator+(const ll a, const modint &b) {
return modint(a) += b;
}
friend void operator+=(ll &a, const modint &b) { a = modint(a) + b; }
friend modint<_MOD> operator-(const ll a, const modint &b) {
return modint(a) -= b;
}
friend void operator-=(ll &a, const modint &b) { a = modint(a) - b; }
friend modint<_MOD> operator*(const ll a, const modint &b) {
return modint(a) *= b;
}
friend void operator*=(ll &a, const modint &b) { a = modint(a) * b; }
friend modint<_MOD> operator/(const ll a, const modint &b) {
return modint(a) /= b;
}
friend void operator/=(ll &a, const modint &b) { a = modint(a) / b; }
friend modint<_MOD> operator^(const ll a, const modint &b) {
return modint(a) ^= b;
}
friend void operator^=(ll &a, const modint &b) { a = modint(a) ^ b; }
};
using mint = modint<MOD>;
using vm = vector<mint>;
using vvm = vector<vm>;
mint operator""_m(unsigned long long a) { return mint(a); }
mint nCr(ll n, ll r) {
const static int setModMax = 1010000;
static mint fac[setModMax], finv[setModMax], inv[setModMax];
if (fac[0] == 0) {
fac[0] = fac[1] = finv[0] = finv[1] = inv[1] = 1;
for (int i = 2; i < setModMax; i++) {
fac[i] = fac[i - 1] * i;
inv[i] = -inv[MOD % i] * (MOD / i);
finv[i] = finv[i - 1] * inv[i];
}
}
return fac[n] * finv[r] * finv[n - r];
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll a, b, c, d;
cin >> a >> c >> b >> d;
mint ans = 0;
range(i, a, b + 1) {
ans += nCr(i + 1 + d, i + 1) - nCr(i + 1 + c - 1, i + 1);
}
puta(ans);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vb = vector<bool>;
using vvb = vector<vb>;
using vd = vector<double>;
using vvd = vector<vd>;
using vi = vector<int>;
using vvi = vector<vi>;
using vl = vector<ll>;
using vvl = vector<vl>;
using pll = pair<ll, ll>;
using tll = tuple<ll, ll>;
using tlll = tuple<ll, ll, ll>;
using vs = vector<string>;
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define rep(i, n) range(i, 0, n)
#define rrep(i, n) for (ll i = (n)-1; i >= 0; i--)
#define range(i, a, n) for (ll i = (a); i < (n); i++)
#define LINF ((ll)1ll << 60)
#define INF ((int)1 << 30)
#define EPS (1e-9)
#define MOD (1000000007ll)
#define fcout(a) cout << setprecision(a) << fixed
#define fs first
#define sc second
#define PI (3.1415926535897932384)
int dx[] = {1, 0, -1, 0, 1, -1, -1, 1}, dy[] = {0, 1, 0, -1, 1, 1, -1, -1};
template <class T> bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class S> S sum(vector<S> &a) { return accumulate(all(a), S()); }
template <class S> S max(vector<S> &a) { return *max_element(all(a)); }
template <class S> S min(vector<S> &a) { return *min_element(all(a)); }
ll max(int a, ll b) { return max((ll)a, b); }
ll max(ll a, int b) { return max(a, (ll)b); }
int sgn(const double &r) { return (r > EPS) - (r < -EPS); } // a>0 : sgn(a)>0
int sgn(const double &a, const double &b) {
return sgn(a - b);
} // b<=c : sgn(b,c)<=0
template <class T> void puta(T &&t) { cout << t << "\n"; }
template <class H, class... T> void puta(H &&h, T &&...t) {
cout << h << ' ';
puta(t...);
}
template <class S, class T> void tf(bool b, S t, T f) {
if (b)
puta(t);
else
puta(f);
}
void YN(bool b) { tf(b, "YES", "NO"); }
void Yn(bool b) { tf(b, "Yes", "No"); }
void yn(bool b) { tf(b, "yes", "no"); }
template <class S, class T> ostream &operator<<(ostream &os, pair<S, T> p) {
os << "[" << p.first << ", " << p.second << "]";
return os;
};
template <class S> auto &operator<<(ostream &os, vector<S> t) {
bool a = 1;
for (auto s : t) {
os << (a ? "" : " ") << s;
a = 0;
}
return os;
}
template <class S> auto &operator>>(istream &is, vector<S> &t) {
for (S &a : t)
cin >> a;
return is;
}
/*他のライブラリを入れる場所*/
template <int _MOD> struct modint {
ll val;
constexpr static int setModMax = 510000;
static modint<_MOD> fac[setModMax], finv[setModMax], inv[setModMax];
static constexpr ll mod(ll a) { return (a % _MOD + _MOD) % _MOD; }
constexpr modint(ll v = 0) noexcept : val(v % _MOD) {
if (val < 0)
v += _MOD;
}
constexpr int getmod() { return _MOD; }
constexpr modint operator-() const noexcept { return val ? _MOD - val : 0; }
constexpr modint operator+(const modint &r) const noexcept {
return modint(*this) += r;
}
constexpr modint operator-(const modint &r) const noexcept {
return modint(*this) -= r;
}
constexpr modint operator*(const modint &r) const noexcept {
return modint(*this) *= r;
}
constexpr modint operator/(const modint &r) const noexcept {
return modint(*this) /= r;
}
constexpr modint operator^(const modint &r) const noexcept {
return modint(*this) ^= r;
}
constexpr modint &operator+=(const modint &r) noexcept {
val = mod(val + r.val);
return *this;
}
constexpr modint &operator-=(const modint &r) noexcept {
val = mod(val - r.val);
return *this;
}
constexpr modint &operator*=(const modint &r) noexcept {
val = mod(val * r.val);
return *this;
}
constexpr modint &operator/=(const modint &r) noexcept {
ll a = r.val, b = _MOD, u = 1, v = 0;
while (b) {
ll t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
val = val * u % _MOD;
if (val < 0)
val += _MOD;
return *this;
}
constexpr modint &operator^=(const modint &r) noexcept {
val = modpow(val, r.val).val;
return *this;
}
constexpr bool operator<(const modint &r) const noexcept {
return this->val < r.val;
}
constexpr bool operator>(const modint &r) const noexcept { return r < *this; }
constexpr bool operator!=(const modint &r) const noexcept {
return *this < r || *this > r;
}
constexpr bool operator==(const modint &r) const noexcept {
return !(*this != r);
}
constexpr bool operator<=(const modint &r) const noexcept {
return !(*this > r);
}
constexpr bool operator>=(const modint &r) const noexcept {
return !(*this < r);
}
friend constexpr ostream &operator<<(ostream &os,
const modint<_MOD> &x) noexcept {
return os << x.val;
}
friend constexpr istream &operator>>(istream &is, modint<_MOD> &x) noexcept {
return is >> x.val;
}
constexpr modint<_MOD> modpow(const modint<_MOD> &a, ll n) noexcept {
if (n == 0)
return 1;
auto t = modpow(a, n / 2);
t *= t;
if (n & 1)
t *= a;
return t;
}
friend modint<_MOD> operator+(const ll a, const modint &b) {
return modint(a) += b;
}
friend void operator+=(ll &a, const modint &b) { a = modint(a) + b; }
friend modint<_MOD> operator-(const ll a, const modint &b) {
return modint(a) -= b;
}
friend void operator-=(ll &a, const modint &b) { a = modint(a) - b; }
friend modint<_MOD> operator*(const ll a, const modint &b) {
return modint(a) *= b;
}
friend void operator*=(ll &a, const modint &b) { a = modint(a) * b; }
friend modint<_MOD> operator/(const ll a, const modint &b) {
return modint(a) /= b;
}
friend void operator/=(ll &a, const modint &b) { a = modint(a) / b; }
friend modint<_MOD> operator^(const ll a, const modint &b) {
return modint(a) ^= b;
}
friend void operator^=(ll &a, const modint &b) { a = modint(a) ^ b; }
};
using mint = modint<MOD>;
using vm = vector<mint>;
using vvm = vector<vm>;
mint operator""_m(unsigned long long a) { return mint(a); }
mint nCr(ll n, ll r) {
const static int setModMax = 2010000;
static mint fac[setModMax], finv[setModMax], inv[setModMax];
if (fac[0] == 0) {
fac[0] = fac[1] = finv[0] = finv[1] = inv[1] = 1;
for (int i = 2; i < setModMax; i++) {
fac[i] = fac[i - 1] * i;
inv[i] = -inv[MOD % i] * (MOD / i);
finv[i] = finv[i - 1] * inv[i];
}
}
return fac[n] * finv[r] * finv[n - r];
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll a, b, c, d;
cin >> a >> c >> b >> d;
mint ans = 0;
range(i, a, b + 1) {
ans += nCr(i + 1 + d, i + 1) - nCr(i + 1 + c - 1, i + 1);
}
puta(ans);
return 0;
} | replace | 202 | 203 | 202 | 203 | 0 | |
p02782 | C++ | Runtime Error | #include "bits/stdc++.h"
using namespace std;
using ll = long long;
#define rep(i, begin, n) for (int i = begin; i < n; i++)
#define repe(i, begin, n) for (int i = begin; i <= n; i++)
#define repr(i, begin, n) for (int i = begin; i > begin - n; i--)
#define repre(i, begin, end) for (int i = begin; i >= end; i--)
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
const int inf = 1000000007;
const int MOD = 1000000007;
const long long INF = 1000000000000000007;
// -------------------------------------------------------
const int MAX = 1010101;
long long fac[MAX], finv[MAX], inv[MAX];
void binom_init() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
long long binom(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
ll r1, c1, r2, c2;
ll g(ll r, ll c) {
ll res = 0;
for (ll i = 0; i <= r; i++) {
res += binom(i + c + 1, c);
res %= MOD;
}
return res;
}
int main() {
binom_init();
cin >> r1 >> c1 >> r2 >> c2;
ll ans = 0;
ans = g(r2, c2);
ans = (ans + MOD - g(r2, c1 - 1)) % MOD;
ans = (ans + MOD - g(r1 - 1, c2)) % MOD;
ans += g(r1 - 1, c1 - 1);
ans %= MOD;
cout << ans << endl;
}
| #include "bits/stdc++.h"
using namespace std;
using ll = long long;
#define rep(i, begin, n) for (int i = begin; i < n; i++)
#define repe(i, begin, n) for (int i = begin; i <= n; i++)
#define repr(i, begin, n) for (int i = begin; i > begin - n; i--)
#define repre(i, begin, end) for (int i = begin; i >= end; i--)
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
const int inf = 1000000007;
const int MOD = 1000000007;
const long long INF = 1000000000000000007;
// -------------------------------------------------------
const int MAX = 2010101;
long long fac[MAX], finv[MAX], inv[MAX];
void binom_init() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
long long binom(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
ll r1, c1, r2, c2;
ll g(ll r, ll c) {
ll res = 0;
for (ll i = 0; i <= r; i++) {
res += binom(i + c + 1, c);
res %= MOD;
}
return res;
}
int main() {
binom_init();
cin >> r1 >> c1 >> r2 >> c2;
ll ans = 0;
ans = g(r2, c2);
ans = (ans + MOD - g(r2, c1 - 1)) % MOD;
ans = (ans + MOD - g(r1 - 1, c2)) % MOD;
ans += g(r1 - 1, c1 - 1);
ans %= MOD;
cout << ans << endl;
}
| replace | 29 | 30 | 29 | 30 | 0 | |
p02782 | C++ | Runtime Error | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <complex>
#include <cstdio>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <string>
#include <vector>
// #include <prettyprint.hpp>
using namespace std;
#define repi(i, n) for (int i = 0; i < n; ++i)
#define rep(i, n) for (ll i = 0; i < n; ++i)
#define repinvi(i, n) for (int i = n - 1; i >= 0; --i)
#define sll(n) scanf("%lld", &n);
#define sii(n) scanf("%d", &n);
#define slf(n) scanf("%lf", &n);
#define pll pair<ll, ll>
#define pii pair<int, int>
#define psi pair<si, si>
typedef long long ll;
typedef double lf;
typedef short int si;
typedef long long ll;
const int mod = 1000000007;
// const int mod = 998244353;
struct mint {
ll x; // typedef long long ll;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
mint operator-() const { return mint(-x); }
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const { return mint(*this) += a; }
mint operator-(const mint a) const { return mint(*this) -= a; }
mint operator*(const mint a) const { return mint(*this) *= a; }
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
// for prime mod
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint a) { return *this *= a.inv(); }
mint operator/(const mint a) const { return mint(*this) /= a; }
};
istream &operator>>(istream &is, const mint &a) { return is >> a.x; }
ostream &operator<<(ostream &os, const mint &a) { return os << a.x; }
struct combination {
vector<mint> fact, ifact;
combination(int n) : fact(n + 1), ifact(n + 1) {
assert(n < mod);
fact[0] = 1;
for (int i = 1; i <= n; ++i)
fact[i] = fact[i - 1] * i;
ifact[n] = fact[n].inv();
for (int i = n; i >= 1; --i)
ifact[i - 1] = ifact[i] * i;
}
mint operator()(int n, int k) {
if (k < 0 || k > n)
return 0;
return fact[n] * ifact[k] * ifact[n - k];
}
};
static const ll max_n = 1e6 + 10;
combination comb(max_n);
// vector<mint> c1_col(max_n, 1);
// vector<mint> c1_1_col(max_n, 1);
// vector<mint> c2_col(max_n, 1);
// vector<mint> c2_1_col(max_n, 1);
// vector<mint> r1_row(max_n, 1);
// vector<mint> r1_1_row(max_n, 1);
// vector<mint> r1_acm(max_n, 1);
// vector<mint> r2_row(max_n, 1);
// vector<mint> r2_1_row(max_n, 1);
// vector<mint> r2_acm(max_n, 1);
void Main() {
ll r1, c1, r2, c2;
cin >> r1 >> c1 >> r2 >> c2;
// ++ r1;
// ++ r2;
// ++ c1;
// ++ c2;
// for(ll i=0;i<=c2;i++){
// // (r1-1, i);
// r1_1_row[i] = comb(r1-1+i, i);
// r2_1_row[i] = comb(r2-1+i, i);
// if(i>0){
// r1_row[i] = r1_row[i-1] + r1_1_row[i];
// r2_row[i] = r2_row[i-1] + r2_1_row[i];
// r1_acm[i] = r1_acm[i-1] + r1_row[i];
// r2_acm[i] = r2_acm[i-1] + r2_row[i];
// }
// }
mint c1_1r1_1 = comb(r1 + c1, c1);
mint c1_1r2 = comb(r2 + c1 + 1, c1);
mint c2r1_1 = comb(r1 + c2 + 1, c2 + 1);
mint c2r2 = comb(r2 + c2 + 2, c2 + 1);
// cout << c1_1r1_1 << "," << c1_1r2 << "," << c2r1_1 << "," << c2r2 <<endl;
auto ans = c2r2 - c1_1r2 - c2r1_1 + c1_1r1_1;
cout << ans << endl;
// for(ll i=0;i<=r2;i++){
// c1_1_col[i] = comb(c1-1+i, i);
// c2_1_col[i] = comb(c2-1+i, i);
// if(i>0){
// c1_col[i] = c1_col[i-1] + c1_1_col[i];
// c2_col[i] = c2_col[i-1] + c2_1_col[i];
// }
// }
}
int main() {
Main();
// string S = "ksdfjl";
// char v = S[3];
// S[3] = 'a';
// cout << S <<endl;
} | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <complex>
#include <cstdio>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <string>
#include <vector>
// #include <prettyprint.hpp>
using namespace std;
#define repi(i, n) for (int i = 0; i < n; ++i)
#define rep(i, n) for (ll i = 0; i < n; ++i)
#define repinvi(i, n) for (int i = n - 1; i >= 0; --i)
#define sll(n) scanf("%lld", &n);
#define sii(n) scanf("%d", &n);
#define slf(n) scanf("%lf", &n);
#define pll pair<ll, ll>
#define pii pair<int, int>
#define psi pair<si, si>
typedef long long ll;
typedef double lf;
typedef short int si;
typedef long long ll;
const int mod = 1000000007;
// const int mod = 998244353;
struct mint {
ll x; // typedef long long ll;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
mint operator-() const { return mint(-x); }
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const { return mint(*this) += a; }
mint operator-(const mint a) const { return mint(*this) -= a; }
mint operator*(const mint a) const { return mint(*this) *= a; }
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
// for prime mod
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint a) { return *this *= a.inv(); }
mint operator/(const mint a) const { return mint(*this) /= a; }
};
istream &operator>>(istream &is, const mint &a) { return is >> a.x; }
ostream &operator<<(ostream &os, const mint &a) { return os << a.x; }
struct combination {
vector<mint> fact, ifact;
combination(int n) : fact(n + 1), ifact(n + 1) {
assert(n < mod);
fact[0] = 1;
for (int i = 1; i <= n; ++i)
fact[i] = fact[i - 1] * i;
ifact[n] = fact[n].inv();
for (int i = n; i >= 1; --i)
ifact[i - 1] = ifact[i] * i;
}
mint operator()(int n, int k) {
if (k < 0 || k > n)
return 0;
return fact[n] * ifact[k] * ifact[n - k];
}
};
static const ll max_n = 2 * 1e6 + 10;
combination comb(max_n);
// vector<mint> c1_col(max_n, 1);
// vector<mint> c1_1_col(max_n, 1);
// vector<mint> c2_col(max_n, 1);
// vector<mint> c2_1_col(max_n, 1);
// vector<mint> r1_row(max_n, 1);
// vector<mint> r1_1_row(max_n, 1);
// vector<mint> r1_acm(max_n, 1);
// vector<mint> r2_row(max_n, 1);
// vector<mint> r2_1_row(max_n, 1);
// vector<mint> r2_acm(max_n, 1);
void Main() {
ll r1, c1, r2, c2;
cin >> r1 >> c1 >> r2 >> c2;
// ++ r1;
// ++ r2;
// ++ c1;
// ++ c2;
// for(ll i=0;i<=c2;i++){
// // (r1-1, i);
// r1_1_row[i] = comb(r1-1+i, i);
// r2_1_row[i] = comb(r2-1+i, i);
// if(i>0){
// r1_row[i] = r1_row[i-1] + r1_1_row[i];
// r2_row[i] = r2_row[i-1] + r2_1_row[i];
// r1_acm[i] = r1_acm[i-1] + r1_row[i];
// r2_acm[i] = r2_acm[i-1] + r2_row[i];
// }
// }
mint c1_1r1_1 = comb(r1 + c1, c1);
mint c1_1r2 = comb(r2 + c1 + 1, c1);
mint c2r1_1 = comb(r1 + c2 + 1, c2 + 1);
mint c2r2 = comb(r2 + c2 + 2, c2 + 1);
// cout << c1_1r1_1 << "," << c1_1r2 << "," << c2r1_1 << "," << c2r2 <<endl;
auto ans = c2r2 - c1_1r2 - c2r1_1 + c1_1r1_1;
cout << ans << endl;
// for(ll i=0;i<=r2;i++){
// c1_1_col[i] = comb(c1-1+i, i);
// c2_1_col[i] = comb(c2-1+i, i);
// if(i>0){
// c1_col[i] = c1_col[i-1] + c1_1_col[i];
// c2_col[i] = c2_col[i-1] + c2_1_col[i];
// }
// }
}
int main() {
Main();
// string S = "ksdfjl";
// char v = S[3];
// S[3] = 'a';
// cout << S <<endl;
} | replace | 90 | 91 | 90 | 91 | 0 | |
p02782 | C++ | Runtime Error | #include <bits/stdc++.h>
#define ll long long
#define ld long double
#define fastio \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0)
#define debug(x) cerr << #x << " " << x << endl
#define cina(a, n) \
for (ll i = 0; i < n; i++) \
cin >> a[i];
#define couta(a, n) \
for (ll i = 0; i < n; i++) \
cout << a[i] << " ";
#define fauto(ar) \
for (auto x : ar) \
cout << x << " ";
#define mod 1000000007
#define siz 1000005
#define f first
#define s second
#define pb push_back
#define endl "\n"
#define ci cin.ignore()
using namespace std;
ll fact[siz], inv[siz];
ll power(ll a, ll n) {
ll res = 1;
while (n) {
n & 1 ? res *= a, res %= mod : 1;
a *= a;
a %= mod;
n >>= 1;
}
return res;
}
ll ncr(ll n, ll r) {
ll val = fact[n] * inv[r] % mod;
val = val * inv[n - r] % mod;
return val;
}
int main() {
ll n, r1, r2, c1, c2, i;
cin >> r1 >> c1 >> r2 >> c2;
fact[0] = 1;
for (i = 1; i < siz; i++) {
fact[i] = fact[i - 1] * i % mod;
}
inv[siz - 1] = power(fact[siz - 1], mod - 2);
for (i = siz - 2; i >= 0; i--) {
inv[i] = (i + 1) * inv[i + 1] % mod;
}
ll op1 = ncr(r2 + c2 + 2, r2 + 1) - ncr(r2 + c1 + 1, r2 + 1) -
ncr(r1 + c2 + 1, r1) + ncr(r1 + c1, r1);
op1 %= mod;
op1 += mod;
op1 %= mod;
cout << op1;
} | #include <bits/stdc++.h>
#define ll long long
#define ld long double
#define fastio \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0)
#define debug(x) cerr << #x << " " << x << endl
#define cina(a, n) \
for (ll i = 0; i < n; i++) \
cin >> a[i];
#define couta(a, n) \
for (ll i = 0; i < n; i++) \
cout << a[i] << " ";
#define fauto(ar) \
for (auto x : ar) \
cout << x << " ";
#define mod 1000000007
#define siz 2000005
#define f first
#define s second
#define pb push_back
#define endl "\n"
#define ci cin.ignore()
using namespace std;
ll fact[siz], inv[siz];
ll power(ll a, ll n) {
ll res = 1;
while (n) {
n & 1 ? res *= a, res %= mod : 1;
a *= a;
a %= mod;
n >>= 1;
}
return res;
}
ll ncr(ll n, ll r) {
ll val = fact[n] * inv[r] % mod;
val = val * inv[n - r] % mod;
return val;
}
int main() {
ll n, r1, r2, c1, c2, i;
cin >> r1 >> c1 >> r2 >> c2;
fact[0] = 1;
for (i = 1; i < siz; i++) {
fact[i] = fact[i - 1] * i % mod;
}
inv[siz - 1] = power(fact[siz - 1], mod - 2);
for (i = siz - 2; i >= 0; i--) {
inv[i] = (i + 1) * inv[i + 1] % mod;
}
ll op1 = ncr(r2 + c2 + 2, r2 + 1) - ncr(r2 + c1 + 1, r2 + 1) -
ncr(r1 + c2 + 1, r1) + ncr(r1 + c1, r1);
op1 %= mod;
op1 += mod;
op1 %= mod;
cout << op1;
} | replace | 18 | 19 | 18 | 19 | 0 | |
p02782 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define rep(i, j, n) for (int i = (int)(j); i < (int)(n); i++)
#define REP(i, j, n) for (int i = (int)(j); i <= (int)(n); i++)
#define MOD 1000000007
#define int long long
#define ALL(a) (a).begin(), (a).end()
#define vi vector<int>
#define vii vector<vi>
#define pii pair<int, int>
#define priq priority_queue<int>
#define disup(A, key) distance(A.begin(), upper_bound(ALL(A), (int)(key)))
#define dislow(A, key) distance(A.begin(), lower_bound(ALL(A), (int)(key)))
#define tii tuple<int, int, int>
#define Priq priority_queue<int, vi, greater<int>>
#define pb push_back
#define mp make_pair
#define INF (1ll << 60)
const int MAX = 510000;
long long fac[MAX], finv[MAX], inv[MAX];
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
signed main() {
COMinit();
int A, B, C, D;
cin >> A >> B >> C >> D;
int ans = 0;
REP(i, A, C) {
ans += COM(i + 1 + D, D);
ans %= MOD;
ans += MOD;
ans -= COM(i + B, B - 1);
ans %= MOD;
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, j, n) for (int i = (int)(j); i < (int)(n); i++)
#define REP(i, j, n) for (int i = (int)(j); i <= (int)(n); i++)
#define MOD 1000000007
#define int long long
#define ALL(a) (a).begin(), (a).end()
#define vi vector<int>
#define vii vector<vi>
#define pii pair<int, int>
#define priq priority_queue<int>
#define disup(A, key) distance(A.begin(), upper_bound(ALL(A), (int)(key)))
#define dislow(A, key) distance(A.begin(), lower_bound(ALL(A), (int)(key)))
#define tii tuple<int, int, int>
#define Priq priority_queue<int, vi, greater<int>>
#define pb push_back
#define mp make_pair
#define INF (1ll << 60)
const int MAX = 5100000;
long long fac[MAX], finv[MAX], inv[MAX];
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
signed main() {
COMinit();
int A, B, C, D;
cin >> A >> B >> C >> D;
int ans = 0;
REP(i, A, C) {
ans += COM(i + 1 + D, D);
ans %= MOD;
ans += MOD;
ans -= COM(i + B, B - 1);
ans %= MOD;
}
cout << ans << endl;
}
| replace | 18 | 19 | 18 | 19 | 0 | |
p02782 | C++ | Runtime Error | // #define _GLIBCXX_DEBUG
#include "bits/stdc++.h"
using namespace std;
//------------------------------- Type Names -------------------------------//
using i64 = int_fast64_t;
using seika = string;
//{akari : 1D, yukari : 2D, maki : 3D} vector
template <class kizuna> using akari = vector<kizuna>;
template <class yuzuki> using yukari = akari<akari<yuzuki>>;
template <class tsurumaki> using maki = akari<yukari<tsurumaki>>;
//{akane : ascending order, aoi : decending order} priority queue
template <class kotonoha>
using akane = priority_queue<kotonoha, akari<kotonoha>, greater<kotonoha>>;
template <class kotonoha> using aoi = priority_queue<kotonoha>;
//------------------------------- Libraries ---------------------------------//
template <int p> struct Modint {
int value;
Modint() : value(0) {}
Modint(long long x) : value(x >= 0 ? x % p : (p + x % p) % p) {}
inline Modint &operator+=(const Modint &b) {
if ((this->value += b.value) >= p)
this->value -= p;
return (*this);
}
inline Modint &operator-=(const Modint &b) {
if ((this->value += p - b.value) >= p)
this->value -= p;
return (*this);
}
inline Modint &operator*=(const Modint &b) {
this->value = (int)((1LL * this->value * b.value) % p);
return (*this);
}
inline Modint &operator/=(const Modint &b) {
(*this) *= b.inverse();
return (*this);
}
Modint operator+(const Modint &b) const { return Modint(*this) += b; }
Modint operator-(const Modint &b) const { return Modint(*this) -= b; }
Modint operator*(const Modint &b) const { return Modint(*this) *= b; }
Modint operator/(const Modint &b) const { return Modint(*this) /= b; }
inline Modint &operator++(int) { return (*this) += 1; }
inline Modint &operator--(int) { return (*this) -= 1; }
inline bool operator==(const Modint &b) const {
return this->value == b.value;
}
inline bool operator!=(const Modint &b) const {
return this->value != b.value;
}
inline bool operator<(const Modint &b) const { return this->value < b.value; }
inline bool operator<=(const Modint &b) const {
return this->value <= b.value;
}
inline bool operator>(const Modint &b) const { return this->value > b.value; }
inline bool operator>=(const Modint &b) const {
return this->value >= b.value;
}
// requires that "this->value and p are co-prime"
// a_i * v + a_(i+1) * p = r_i
// r_i = r_(i+1) * q_(i+1) * r_(i+2)
// q == 1 (i > 1)
// reference: https://atcoder.jp/contests/agc026/submissions/2845729
// (line:93)
inline Modint inverse() const {
assert(this->value != 0);
int r0 = p, r1 = this->value, a0 = 0, a1 = 1;
while (r1) {
int q = r0 / r1;
r0 -= q * r1;
swap(r0, r1);
a0 -= q * a1;
swap(a0, a1);
}
return Modint(a0);
}
friend istream &operator>>(istream &is, Modint<p> &a) {
long long t;
is >> t;
a = Modint<p>(t);
return is;
}
friend ostream &operator<<(ostream &os, const Modint<p> &a) {
return os << a.value;
}
};
const int MOD = 1e9 + 7;
using Int = Modint<MOD>;
Int modpow(Int e, long x) {
Int res = 1;
while (x > 0) {
if (x & 1)
res *= e;
res *= res;
x >>= 1;
}
return res;
}
class Comb {
public:
vector<Int> fact, finv;
Comb(int n) : fact(n + 1), finv(n + 1) {
fact[0] = Int(1);
for (int i = 1; i <= n; i++) {
fact[i] = fact[i - 1] * Int(i);
}
finv[n] = Int(fact[n]).inverse();
for (int i = n - 1; i >= 0; i--) {
finv[i] = finv[i + 1] * Int(i + 1);
}
}
inline Int nCk(int n, int k) {
if (k < 0 || n < k)
return Int(0);
return Int(fact[n] * finv[n - k] * finv[k]);
}
inline Int nPk(int n, int k) {
if (k < 0 || n < k)
return Int(0);
return Int(fact[n] * finv[n - k]);
}
};
/*
verified @ https://atcoder.jp/contests/abc021/submissions/7096121
*/
//------------------------------- Dubug Functions ---------------------------//
inline void print() { cout << endl; }
template <typename First, typename... Rest>
void print(const First &first, const Rest &...rest) {
cout << first << ' ';
print(rest...);
}
//------------------------------- Solver ------------------------------------//
void solve() {
int r1, r2, c1, c2;
cin >> r1 >> c1 >> r2 >> c2;
Int ans = 0;
Comb comb(200020);
for (int r = r1; r <= r2; r++) {
ans += comb.nCk(r + c2 + 1, r + 1) - comb.nCk(r + c1, r + 1);
}
cout << ans << endl;
}
int main() {
solve();
return 0;
}
| // #define _GLIBCXX_DEBUG
#include "bits/stdc++.h"
using namespace std;
//------------------------------- Type Names -------------------------------//
using i64 = int_fast64_t;
using seika = string;
//{akari : 1D, yukari : 2D, maki : 3D} vector
template <class kizuna> using akari = vector<kizuna>;
template <class yuzuki> using yukari = akari<akari<yuzuki>>;
template <class tsurumaki> using maki = akari<yukari<tsurumaki>>;
//{akane : ascending order, aoi : decending order} priority queue
template <class kotonoha>
using akane = priority_queue<kotonoha, akari<kotonoha>, greater<kotonoha>>;
template <class kotonoha> using aoi = priority_queue<kotonoha>;
//------------------------------- Libraries ---------------------------------//
template <int p> struct Modint {
int value;
Modint() : value(0) {}
Modint(long long x) : value(x >= 0 ? x % p : (p + x % p) % p) {}
inline Modint &operator+=(const Modint &b) {
if ((this->value += b.value) >= p)
this->value -= p;
return (*this);
}
inline Modint &operator-=(const Modint &b) {
if ((this->value += p - b.value) >= p)
this->value -= p;
return (*this);
}
inline Modint &operator*=(const Modint &b) {
this->value = (int)((1LL * this->value * b.value) % p);
return (*this);
}
inline Modint &operator/=(const Modint &b) {
(*this) *= b.inverse();
return (*this);
}
Modint operator+(const Modint &b) const { return Modint(*this) += b; }
Modint operator-(const Modint &b) const { return Modint(*this) -= b; }
Modint operator*(const Modint &b) const { return Modint(*this) *= b; }
Modint operator/(const Modint &b) const { return Modint(*this) /= b; }
inline Modint &operator++(int) { return (*this) += 1; }
inline Modint &operator--(int) { return (*this) -= 1; }
inline bool operator==(const Modint &b) const {
return this->value == b.value;
}
inline bool operator!=(const Modint &b) const {
return this->value != b.value;
}
inline bool operator<(const Modint &b) const { return this->value < b.value; }
inline bool operator<=(const Modint &b) const {
return this->value <= b.value;
}
inline bool operator>(const Modint &b) const { return this->value > b.value; }
inline bool operator>=(const Modint &b) const {
return this->value >= b.value;
}
// requires that "this->value and p are co-prime"
// a_i * v + a_(i+1) * p = r_i
// r_i = r_(i+1) * q_(i+1) * r_(i+2)
// q == 1 (i > 1)
// reference: https://atcoder.jp/contests/agc026/submissions/2845729
// (line:93)
inline Modint inverse() const {
assert(this->value != 0);
int r0 = p, r1 = this->value, a0 = 0, a1 = 1;
while (r1) {
int q = r0 / r1;
r0 -= q * r1;
swap(r0, r1);
a0 -= q * a1;
swap(a0, a1);
}
return Modint(a0);
}
friend istream &operator>>(istream &is, Modint<p> &a) {
long long t;
is >> t;
a = Modint<p>(t);
return is;
}
friend ostream &operator<<(ostream &os, const Modint<p> &a) {
return os << a.value;
}
};
const int MOD = 1e9 + 7;
using Int = Modint<MOD>;
Int modpow(Int e, long x) {
Int res = 1;
while (x > 0) {
if (x & 1)
res *= e;
res *= res;
x >>= 1;
}
return res;
}
class Comb {
public:
vector<Int> fact, finv;
Comb(int n) : fact(n + 1), finv(n + 1) {
fact[0] = Int(1);
for (int i = 1; i <= n; i++) {
fact[i] = fact[i - 1] * Int(i);
}
finv[n] = Int(fact[n]).inverse();
for (int i = n - 1; i >= 0; i--) {
finv[i] = finv[i + 1] * Int(i + 1);
}
}
inline Int nCk(int n, int k) {
if (k < 0 || n < k)
return Int(0);
return Int(fact[n] * finv[n - k] * finv[k]);
}
inline Int nPk(int n, int k) {
if (k < 0 || n < k)
return Int(0);
return Int(fact[n] * finv[n - k]);
}
};
/*
verified @ https://atcoder.jp/contests/abc021/submissions/7096121
*/
//------------------------------- Dubug Functions ---------------------------//
inline void print() { cout << endl; }
template <typename First, typename... Rest>
void print(const First &first, const Rest &...rest) {
cout << first << ' ';
print(rest...);
}
//------------------------------- Solver ------------------------------------//
void solve() {
int r1, r2, c1, c2;
cin >> r1 >> c1 >> r2 >> c2;
Int ans = 0;
Comb comb(2000020);
for (int r = r1; r <= r2; r++) {
ans += comb.nCk(r + c2 + 1, r + 1) - comb.nCk(r + c1, r + 1);
}
cout << ans << endl;
}
int main() {
solve();
return 0;
}
| replace | 160 | 161 | 160 | 161 | 0 | |
p02782 | C++ | Runtime Error | #include <bits/stdc++.h>
#include <ext/hash_map>
#include <ext/numeric>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/detail/standard_policies.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
using namespace __gnu_cxx;
#define REP(i, n) for ((i) = 0; (i) < (n); (i)++)
#define rep(i, x, n) for ((i) = (x); (i) < (n); (i)++)
#define REV(i, n) for ((i) = (n); (i) >= 0; (i)--)
#define FORIT(it, x) for ((it) = (x).begin(); (it) != (x).end(); (it)++)
#define foreach(it, c) \
for (__typeof((c).begin()) it = (c).begin(); it != (c).end(); ++it)
#define rforeach(it, c) \
for (__typeof((c).rbegin()) it = (c).rbegin(); it != (c).rend(); ++it)
#define foreach2d(i, j, v) \
foreach (i, v) \
foreach (j, *i)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define SZ(x) ((int)(x).size())
#define MMS(x, n) memset(x, n, sizeof(x))
#define mms(x, n, s) memset(x, n, sizeof(x) * s)
#define pb push_back
#define mp make_pair
#define NX next_permutation
#define UN(x) sort(all(x)), x.erase(unique(all(x)), x.end())
#define CV(x, n) count(all(x), (n))
#define FIND(x, n) find(all(x), (n)) - (x).begin()
#define ACC(x) accumulate(all(x), 0)
#define PPC(x) __builtin_popcountll(x)
#define LZ(x) __builtin_clz(x)
#define TZ(x) __builtin_ctz(x)
#define mxe(x) *max_element(all(x))
#define mne(x) *min_element(all(x))
#define low(x, i) lower_bound(all(x), i)
#define upp(x, i) upper_bound(all(x), i)
#define NXPOW2(x) (1ll << ((int)log2(x) + 1))
#define PR(x) cout << #x << " = " << (x) << endl;
typedef unsigned long long ull;
typedef long long ll;
typedef vector<int> vi;
typedef vector<vector<int>> vvi;
typedef pair<ll, ll> pii;
typedef tree<int, null_type, less<int>, rb_tree_tag,
tree_order_statistics_node_update>
ordered_set;
const int OO = (int)2e9;
const double eps = 1e-9;
const int N = 1e6 + 6;
const int mod = (int)1e9 + 7;
ll f[N], inv[N], finv[N];
void init() {
f[0] = f[1] = inv[0] = inv[1] = finv[0] = finv[1] = 1;
for (int i = 2; i < N; i++) {
f[i] = (f[i - 1] * i) % mod;
inv[i] = (mod - (mod / i) * inv[mod % i] % mod) % mod;
finv[i] = (finv[i - 1] * inv[i]) % mod;
}
}
ll nCr(ll n, ll r) { return (f[n] * ((finv[r] * finv[n - r]) % mod)) % mod; }
ll c(int n, int r) { return nCr(n + r + 2, r + 1) - 1; }
int main() {
std::ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
#ifndef ONLINE_JUDGE
// freopen("in.txt", "rt", stdin);
// freopen("out.txt", "wt", stdout);
#endif
init();
int r1, c1, r2, c2;
cin >> r1 >> c1 >> r2 >> c2;
r1--, c1--;
ll res = c(r2, c2) - c(r1, c2) - c(r2, c1) + c(r1, c1);
((res %= mod) += mod) %= mod;
cout << res << endl;
return 0;
}
| #include <bits/stdc++.h>
#include <ext/hash_map>
#include <ext/numeric>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/detail/standard_policies.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
using namespace __gnu_cxx;
#define REP(i, n) for ((i) = 0; (i) < (n); (i)++)
#define rep(i, x, n) for ((i) = (x); (i) < (n); (i)++)
#define REV(i, n) for ((i) = (n); (i) >= 0; (i)--)
#define FORIT(it, x) for ((it) = (x).begin(); (it) != (x).end(); (it)++)
#define foreach(it, c) \
for (__typeof((c).begin()) it = (c).begin(); it != (c).end(); ++it)
#define rforeach(it, c) \
for (__typeof((c).rbegin()) it = (c).rbegin(); it != (c).rend(); ++it)
#define foreach2d(i, j, v) \
foreach (i, v) \
foreach (j, *i)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define SZ(x) ((int)(x).size())
#define MMS(x, n) memset(x, n, sizeof(x))
#define mms(x, n, s) memset(x, n, sizeof(x) * s)
#define pb push_back
#define mp make_pair
#define NX next_permutation
#define UN(x) sort(all(x)), x.erase(unique(all(x)), x.end())
#define CV(x, n) count(all(x), (n))
#define FIND(x, n) find(all(x), (n)) - (x).begin()
#define ACC(x) accumulate(all(x), 0)
#define PPC(x) __builtin_popcountll(x)
#define LZ(x) __builtin_clz(x)
#define TZ(x) __builtin_ctz(x)
#define mxe(x) *max_element(all(x))
#define mne(x) *min_element(all(x))
#define low(x, i) lower_bound(all(x), i)
#define upp(x, i) upper_bound(all(x), i)
#define NXPOW2(x) (1ll << ((int)log2(x) + 1))
#define PR(x) cout << #x << " = " << (x) << endl;
typedef unsigned long long ull;
typedef long long ll;
typedef vector<int> vi;
typedef vector<vector<int>> vvi;
typedef pair<ll, ll> pii;
typedef tree<int, null_type, less<int>, rb_tree_tag,
tree_order_statistics_node_update>
ordered_set;
const int OO = (int)2e9;
const double eps = 1e-9;
const int N = 2e6 + 6;
const int mod = (int)1e9 + 7;
ll f[N], inv[N], finv[N];
void init() {
f[0] = f[1] = inv[0] = inv[1] = finv[0] = finv[1] = 1;
for (int i = 2; i < N; i++) {
f[i] = (f[i - 1] * i) % mod;
inv[i] = (mod - (mod / i) * inv[mod % i] % mod) % mod;
finv[i] = (finv[i - 1] * inv[i]) % mod;
}
}
ll nCr(ll n, ll r) { return (f[n] * ((finv[r] * finv[n - r]) % mod)) % mod; }
ll c(int n, int r) { return nCr(n + r + 2, r + 1) - 1; }
int main() {
std::ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
#ifndef ONLINE_JUDGE
// freopen("in.txt", "rt", stdin);
// freopen("out.txt", "wt", stdout);
#endif
init();
int r1, c1, r2, c2;
cin >> r1 >> c1 >> r2 >> c2;
r1--, c1--;
ll res = c(r2, c2) - c(r1, c2) - c(r2, c1) + c(r1, c1);
((res %= mod) += mod) %= mod;
cout << res << endl;
return 0;
}
| replace | 56 | 57 | 56 | 57 | 0 | |
p02783 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define pb push_back
#define F first
#define S second
#define mod 1000000007
#define all(a) a.begin(), a.end()
#define dbg(n) cout << #n << ' ' << n << endl;
#define dbg_v(v) \
cout << #v << ":"; \
for (auto c : v) \
cout << " " << c; \
cout << endl;
int power(ll x, ll y) {
ll res = 1;
while (y > 0) {
if (y & 1)
res = (res * x) % mod;
y = y >> 1;
x = (x * x) % mod;
}
return res;
}
void solve() {
int h, a;
cin >> h >> a;
int ans = (h + a - 1) / a;
cout << ans << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int T = 1;
cin >> T;
while (T--) {
solve();
}
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define pb push_back
#define F first
#define S second
#define mod 1000000007
#define all(a) a.begin(), a.end()
#define dbg(n) cout << #n << ' ' << n << endl;
#define dbg_v(v) \
cout << #v << ":"; \
for (auto c : v) \
cout << " " << c; \
cout << endl;
int power(ll x, ll y) {
ll res = 1;
while (y > 0) {
if (y & 1)
res = (res * x) % mod;
y = y >> 1;
x = (x * x) % mod;
}
return res;
}
void solve() {
int h, a;
cin >> h >> a;
int ans = (h + a - 1) / a;
cout << ans << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int T = 1;
// cin>>T;
while (T--) {
solve();
}
}
| replace | 34 | 35 | 34 | 35 | 0 | |
p02783 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <iostream>
#include <stdio.h>
#include <vector>
#define rep(i, cc, n) for (int i = cc; i <= n; ++i)
#define drep(i, cc, n) for (int i = cc; i >= n; --i)
typedef long long ll;
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int h[n];
rep(i, 0, n - 1) cin >> h[i];
sort(h, h + n);
drep(i, n - 1, n - k) { h[i] = 0; }
ll ans = 0;
rep(i, 0, n - 1) { ans += h[i]; }
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <iostream>
#include <stdio.h>
#include <vector>
#define rep(i, cc, n) for (int i = cc; i <= n; ++i)
#define drep(i, cc, n) for (int i = cc; i >= n; --i)
typedef long long ll;
using namespace std;
int main() {
int h, a;
cin >> h >> a;
if (h % a > 0)
cout << h / a + 1 << endl;
else
cout << h / a << endl;
return 0;
} | replace | 10 | 19 | 10 | 16 | 0 | |
p02783 | C++ | Runtime Error | #include <bits/stdc++.h>
#include <string.h>
#define ll long long int
#define fio \
ios_base::sync_with_stdio(false); \
cin.tie(NULL);
#define MAX_LIMIT 10000000
#define haha(x) x.begin(), x.end()
#define rs resize
#define remove_zero(str) str.erase(0, str.find_first_not_of('0'));
#define br break
const long long kot = LLONG_MAX;
#define pb push_back
#define pi 3.14159265358979323846
#define pp pop_back
#define pf pop_front
using kk = long double;
#define endl "\n"
#define rese(x, y) memset(x, y, sizeof(x))
#define f first
#define ul unsigned long
#define pii pair<ll, ll>
#define cc continue
#define ee end
#define ii insert
#define fr front
#define mod 1000000007
#define ss size
#define b begin
#define up upper_bound
#define pc pop_back()
// #define mp make_pair
// #define r reverse
#define bb back
#define maxu 1000000000
#define CHARS_TOTAL 256
#define INT_BITS 32
// typedef std::pair<std::string,std::string>pair;
const ll alpha = 1e18;
/* For counting number of digits, directly do floor(log10(n)+1)*/
using namespace std;
ll gcd(ll a, ll b) {
// Everything divides 0
if (a == 0)
return b;
if (b == 0)
return a;
// base case
if (a == b)
return a;
// a is greater
if (a > b)
return gcd(a - b, b);
return gcd(a, b - a);
}
ll largest(ll arr[], ll n) { return *max_element(arr, arr + n); }
// Function to return LCM of two numbers
ll lcm(ll a, ll b) { return (a * b) / gcd(a, b); }
void sieve(bool primes[], ll x) {
primes[1] = false;
for (ll i = 2; i * i <= x; i++) {
if (primes[i] == true) {
for (ll j = 2; j * i <= x; j++)
primes[i * j] = false;
}
}
}
// Function to generate mersenne primes less
// than or equal to n
ll power(ll x, unsigned ll y, ll p) {
ll res = 1; // Initialize result
x = x % p; // Update x if it is more than or
// equal to p
while (y > 0) {
// If y is odd, multiply x with result
if (y & 1)
res = (res * x) % p;
// y must be even now
y = y >> 1; // y = y/2
x = (x * x) % p;
}
return res;
}
class gfg {
public:
ll sumDigits(ll no) { return no == 0 ? 0 : no % 10 + sumDigits(no / 10); }
};
bool isPerfectSquare(long double x) {
// Find floating poll value of
// square root of x.
long double sr = sqrt(x);
// If square root is an lleger
return ((sr - floor(sr)) == 0);
}
bool comp(ll a, ll b) { return (a < b); }
vector<ll> ve;
void divisors(ll n) {
// Note that this loop runs till square root
for (ll i = 1; i <= sqrt(n); i++) {
if (n % i == 0) {
// If divisors are equal, print only one
if (n / i == i)
ve.pb(i);
else // Otherwise print both
ve.pb(i);
ve.pb(n / i);
}
}
}
bool isPrime(ll n) {
if (n == 1) {
return false;
}
ll i = 2;
while (i * i <= n) {
if (n % i == 0) {
return false;
}
i += 1;
}
return true;
}
ll gcdofarray(vector<ll> &v, ll n) {
ll result = v[0];
for (ll i = 1; i < n; i++)
result = gcd(v[i], result);
return result;
}
ll sumofdigits(ll n) {
ll sum = 0;
while (n > 0) {
sum += n % 10;
n /= 10;
}
return sum;
}
bool powertwo(ll x) { return x && (!(x & (x - 1))); }
ll finduncommonsubsequence(string str, string s) {
if (!str.compare(s)) {
return 0;
}
return max(str.length(), s.length());
}
void reversec(string str) {
for (ll i = str.length() - 1; i >= 0; i--)
cout << str[i];
}
string removeDuplicatesFromString(string str) {
// keeps track of visited characters
ll counter = 0;
ll i = 0;
ll size = str.size();
// gets character value
ll x;
// keeps track of length of resultant string
ll length = 0;
while (i < size) {
x = str[i] - 97;
// check if Xth bit of counter is unset
if ((counter & (1 << x)) == 0) {
str[length] = 'a' + x;
// mark current character as visited
counter = counter | (1 << x);
length++;
}
i++;
}
return str.substr(0, length);
}
ll commDiv(ll a, ll b) {
// find gcd of a,b
ll n = gcd(a, b);
// Count divisors of n.
ll result = 0;
for (ll i = 1; i <= sqrt(n); i++) {
// if 'i' is factor of n
if (n % i == 0) {
// check if divisors are equal
if (n / i == i)
result += 1;
else
result += 2;
}
}
return result;
}
ll fact(ll n) {
if (n <= 1)
return 1;
return n * fact(n - 1);
}
ll nPr(ll n, ll r) { return fact(n) / fact(n - r); }
ll kash(ll a, ll b) { return (a * b) / gcd(a, b); }
ll maxi(ll a, ll b) { return (a > b) ? a : b; }
ll mini(ll a, ll b) { return (a < b) ? a : b; }
ll nCr(ll n, ll r) { return fact(n) / (fact(r) * fact(n - r)); }
ll nCrModp(ll n, ll r, ll p) {
ll C[r + 1];
memset(C, 0, sizeof(C));
C[0] = 1;
for (ll i = 1; i <= n; i++) {
for (ll j = min(i, r); j > 0; j--)
C[j] = (C[j] + C[j - 1]) % p;
}
return C[r];
}
void Z_algorithm(string str, vector<ll> &Z) {
Z.assign((ll)str.size(), 0);
ll n = str.length();
ll L, R, k;
L = R = 0;
for (ll i = 1; i < n; ++i) {
if (i > R) {
L = R = i;
while (R < n && str[R - L] == str[R])
R++;
Z[i] = R - L;
R--;
} else {
k = i - L;
if (Z[k] < R - i + 1)
Z[i] = Z[k];
else {
L = i;
while (R < n && str[R - L] == str[R])
R++;
Z[i] = R - L;
R--;
}
}
}
}
ll lastdigit(ll n) { return n % 10; }
ll firstdigit(ll n) {
ll dig = (ll)log10(n);
n = (ll)(n / pow(10, dig));
return n;
}
bool ispalindrome(string str) {
string s = str;
reverse(s.begin(), s.end());
if (s == str) {
return true;
}
return false;
}
/*Taken from
* https://www.geeksforgeeks.org/modular-exponentiation-power-in-modular-arithmetic/*/
ll kash(ll x, unsigned ll y, ll p) {
ll res = 1; // Initialize result
x = x % p; // Update x if it is more than or
// equal to p
while (y > 0) {
// If y is odd, multiply x with result
if (y & 1)
res = (res * x) % p;
// y must be even now
y = y >> 1; // y = y/2
x = (x * x) % p;
}
return res;
}
void solve() {
// input
ll t = 1;
// cin>>t;
while (t--) {
double h, a;
cin >> h >> a;
double c = 0;
c = ceil(h / a);
cout << c << endl;
}
}
int main() {
fio;
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
solve();
} | #include <bits/stdc++.h>
#include <string.h>
#define ll long long int
#define fio \
ios_base::sync_with_stdio(false); \
cin.tie(NULL);
#define MAX_LIMIT 10000000
#define haha(x) x.begin(), x.end()
#define rs resize
#define remove_zero(str) str.erase(0, str.find_first_not_of('0'));
#define br break
const long long kot = LLONG_MAX;
#define pb push_back
#define pi 3.14159265358979323846
#define pp pop_back
#define pf pop_front
using kk = long double;
#define endl "\n"
#define rese(x, y) memset(x, y, sizeof(x))
#define f first
#define ul unsigned long
#define pii pair<ll, ll>
#define cc continue
#define ee end
#define ii insert
#define fr front
#define mod 1000000007
#define ss size
#define b begin
#define up upper_bound
#define pc pop_back()
// #define mp make_pair
// #define r reverse
#define bb back
#define maxu 1000000000
#define CHARS_TOTAL 256
#define INT_BITS 32
// typedef std::pair<std::string,std::string>pair;
const ll alpha = 1e18;
/* For counting number of digits, directly do floor(log10(n)+1)*/
using namespace std;
ll gcd(ll a, ll b) {
// Everything divides 0
if (a == 0)
return b;
if (b == 0)
return a;
// base case
if (a == b)
return a;
// a is greater
if (a > b)
return gcd(a - b, b);
return gcd(a, b - a);
}
ll largest(ll arr[], ll n) { return *max_element(arr, arr + n); }
// Function to return LCM of two numbers
ll lcm(ll a, ll b) { return (a * b) / gcd(a, b); }
void sieve(bool primes[], ll x) {
primes[1] = false;
for (ll i = 2; i * i <= x; i++) {
if (primes[i] == true) {
for (ll j = 2; j * i <= x; j++)
primes[i * j] = false;
}
}
}
// Function to generate mersenne primes less
// than or equal to n
ll power(ll x, unsigned ll y, ll p) {
ll res = 1; // Initialize result
x = x % p; // Update x if it is more than or
// equal to p
while (y > 0) {
// If y is odd, multiply x with result
if (y & 1)
res = (res * x) % p;
// y must be even now
y = y >> 1; // y = y/2
x = (x * x) % p;
}
return res;
}
class gfg {
public:
ll sumDigits(ll no) { return no == 0 ? 0 : no % 10 + sumDigits(no / 10); }
};
bool isPerfectSquare(long double x) {
// Find floating poll value of
// square root of x.
long double sr = sqrt(x);
// If square root is an lleger
return ((sr - floor(sr)) == 0);
}
bool comp(ll a, ll b) { return (a < b); }
vector<ll> ve;
void divisors(ll n) {
// Note that this loop runs till square root
for (ll i = 1; i <= sqrt(n); i++) {
if (n % i == 0) {
// If divisors are equal, print only one
if (n / i == i)
ve.pb(i);
else // Otherwise print both
ve.pb(i);
ve.pb(n / i);
}
}
}
bool isPrime(ll n) {
if (n == 1) {
return false;
}
ll i = 2;
while (i * i <= n) {
if (n % i == 0) {
return false;
}
i += 1;
}
return true;
}
ll gcdofarray(vector<ll> &v, ll n) {
ll result = v[0];
for (ll i = 1; i < n; i++)
result = gcd(v[i], result);
return result;
}
ll sumofdigits(ll n) {
ll sum = 0;
while (n > 0) {
sum += n % 10;
n /= 10;
}
return sum;
}
bool powertwo(ll x) { return x && (!(x & (x - 1))); }
ll finduncommonsubsequence(string str, string s) {
if (!str.compare(s)) {
return 0;
}
return max(str.length(), s.length());
}
void reversec(string str) {
for (ll i = str.length() - 1; i >= 0; i--)
cout << str[i];
}
string removeDuplicatesFromString(string str) {
// keeps track of visited characters
ll counter = 0;
ll i = 0;
ll size = str.size();
// gets character value
ll x;
// keeps track of length of resultant string
ll length = 0;
while (i < size) {
x = str[i] - 97;
// check if Xth bit of counter is unset
if ((counter & (1 << x)) == 0) {
str[length] = 'a' + x;
// mark current character as visited
counter = counter | (1 << x);
length++;
}
i++;
}
return str.substr(0, length);
}
ll commDiv(ll a, ll b) {
// find gcd of a,b
ll n = gcd(a, b);
// Count divisors of n.
ll result = 0;
for (ll i = 1; i <= sqrt(n); i++) {
// if 'i' is factor of n
if (n % i == 0) {
// check if divisors are equal
if (n / i == i)
result += 1;
else
result += 2;
}
}
return result;
}
ll fact(ll n) {
if (n <= 1)
return 1;
return n * fact(n - 1);
}
ll nPr(ll n, ll r) { return fact(n) / fact(n - r); }
ll kash(ll a, ll b) { return (a * b) / gcd(a, b); }
ll maxi(ll a, ll b) { return (a > b) ? a : b; }
ll mini(ll a, ll b) { return (a < b) ? a : b; }
ll nCr(ll n, ll r) { return fact(n) / (fact(r) * fact(n - r)); }
ll nCrModp(ll n, ll r, ll p) {
ll C[r + 1];
memset(C, 0, sizeof(C));
C[0] = 1;
for (ll i = 1; i <= n; i++) {
for (ll j = min(i, r); j > 0; j--)
C[j] = (C[j] + C[j - 1]) % p;
}
return C[r];
}
void Z_algorithm(string str, vector<ll> &Z) {
Z.assign((ll)str.size(), 0);
ll n = str.length();
ll L, R, k;
L = R = 0;
for (ll i = 1; i < n; ++i) {
if (i > R) {
L = R = i;
while (R < n && str[R - L] == str[R])
R++;
Z[i] = R - L;
R--;
} else {
k = i - L;
if (Z[k] < R - i + 1)
Z[i] = Z[k];
else {
L = i;
while (R < n && str[R - L] == str[R])
R++;
Z[i] = R - L;
R--;
}
}
}
}
ll lastdigit(ll n) { return n % 10; }
ll firstdigit(ll n) {
ll dig = (ll)log10(n);
n = (ll)(n / pow(10, dig));
return n;
}
bool ispalindrome(string str) {
string s = str;
reverse(s.begin(), s.end());
if (s == str) {
return true;
}
return false;
}
/*Taken from
* https://www.geeksforgeeks.org/modular-exponentiation-power-in-modular-arithmetic/*/
ll kash(ll x, unsigned ll y, ll p) {
ll res = 1; // Initialize result
x = x % p; // Update x if it is more than or
// equal to p
while (y > 0) {
// If y is odd, multiply x with result
if (y & 1)
res = (res * x) % p;
// y must be even now
y = y >> 1; // y = y/2
x = (x * x) % p;
}
return res;
}
void solve() {
// input
ll t = 1;
// cin>>t;
while (t--) {
double h, a;
cin >> h >> a;
double c = 0;
c = ceil(h / a);
cout << c << endl;
}
}
int main() {
fio;
solve();
} | delete | 311 | 315 | 311 | 311 | 0 | |
p02783 | C++ | Runtime Error | #include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <complex>
#include <cstdint>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <queue>
#include <random>
#include <regex>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <sys/timeb.h>
#include <vector>
using namespace std;
#define repr(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define rep(i, n) repr(i, 0, n)
#define reprrev(i, a, b) for (int i = (int)(b)-1; i >= (int)(a); i--)
#define reprev(i, n) reprrev(i, 0, n)
#define repi(itr, ds) for (auto itr = ds.begin(); itr != ds.end(); itr++)
#define chmin(mi, value) mi = min(mi, value)
#define chmax(ma, value) ma = max(ma, value)
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define mp make_pair
#define mt make_tuple
#define INF 1050000000
#define INFR INT_MAX
#define INFL (long long)(4e18)
#define INFLR LLONG_MAX
#define EPS (1e-10)
#define MOD 1000000007
// #define MOD 998244353
#define PI 3.141592653589793238
#define RMAX 4294967295
using vi = vector<int>;
using vvi = vector<vector<int>>;
using vvvi = vector<vector<vector<int>>>;
using vvvvi = vector<vector<vector<vector<int>>>>;
using ll = long long;
using vll = vector<ll>;
using vvll = vector<vector<ll>>;
using vvvll = vector<vector<vector<ll>>>;
using vd = vector<double>;
using vvd = vector<vector<double>>;
using vvvd = vector<vector<vector<double>>>;
using vb = vector<bool>;
using vvb = vector<vector<bool>>;
using vc = vector<char>;
using vvc = vector<vector<char>>;
using vs = vector<string>;
using vvs = vector<vector<string>>;
using Pi = pair<int, int>;
using vPi = vector<Pi>;
using vvPi = vector<vector<Pi>>;
using vvvPi = vector<vector<vector<Pi>>>;
using vvvvPi = vector<vector<vector<vector<Pi>>>>;
using Pll = pair<ll, ll>;
using vPll = vector<Pll>;
using Pd = pair<double, double>;
using vPd = vector<Pd>;
template <class T> using vec = vector<T>;
template <class T> using pql = priority_queue<T, vector<T>, greater<T>>;
using Comp = complex<double>;
// vvvvvvvvvvvvvvvvvvvvvvv debug output vvvvvvvvvvvvvvvvvvvvvvv
// vector input
template <typename T> istream &operator>>(istream &is, vector<T> &vec) {
for (T &x : vec)
is >> x;
return is;
}
// pair
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &pair_var) {
os << "(" << pair_var.first << ", " << pair_var.second << ")";
return os;
}
// vector
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec) {
os << "{";
for (int i = 0; i < vec.size(); i++) {
os << vec[i] << (i + 1 == vec.size() ? "" : ", ");
}
os << "}";
return os;
}
// deque
template <typename T> ostream &operator<<(ostream &os, const deque<T> &vec) {
os << "{";
for (int i = 0; i < vec.size(); i++) {
os << vec[i] << (i + 1 == vec.size() ? "" : ", ");
}
os << "}";
return os;
}
// map
template <typename T, typename U>
ostream &operator<<(ostream &os, const map<T, U> &map_var) {
os << "{";
repi(itr, map_var) {
os << *itr;
itr++;
if (itr != map_var.end())
os << ", ";
itr--;
}
os << "}";
return os;
}
// set
template <typename T> ostream &operator<<(ostream &os, const set<T> &set_var) {
os << "{";
repi(itr, set_var) {
os << *itr;
itr++;
if (itr != set_var.end())
os << ", ";
itr--;
}
os << "}";
return os;
}
// multiset
template <typename T>
ostream &operator<<(ostream &os, const multiset<T> &set_var) {
os << "{";
repi(itr, set_var) {
os << *itr;
itr++;
if (itr != set_var.end())
os << ", ";
itr--;
}
os << "}";
return os;
}
#define DUMPOUT cerr
void dump_func() { DUMPOUT << endl; }
template <class Head, class... Tail>
void dump_func(Head &&head, Tail &&...tail) {
DUMPOUT << head;
if (sizeof...(Tail) > 0) {
DUMPOUT << ", ";
}
dump_func(std::move(tail)...);
}
#ifdef DEBUG_
#define DEB
#define dump(...) \
DUMPOUT << " " << string(#__VA_ARGS__) << ": " \
<< "[" << to_string(__LINE__) << ":" << __FUNCTION__ << "]" << endl \
<< " ", \
dump_func(__VA_ARGS__)
#else
#define DEB if (false)
#define dump(...)
#endif
// ^^^^^^^^^^^^^^^^^^^^^^^ debug output ^^^^^^^^^^^^^^^^^^^^^^^
string YN(bool y, int id = 0) {
if (id)
cout << id;
return (y ? "YES" : "NO");
}
string yn(bool y, int id = 0) {
if (id)
cout << id;
return (y ? "Yes" : "No");
}
string ON(bool y, int id = 0) {
if (id)
cout << id;
return (y ? "OK" : "NG");
}
int dir4[4][2] = {{0, -1}, {-1, 0}, {1, 0}, {0, 1}};
int dir8[8][2] = {{-1, -1}, {0, -1}, {1, -1}, {-1, 0},
{1, 0}, {-1, 1}, {0, 1}, {1, 1}};
// [a,b)
int irand(int a, int b) {
static mt19937 Rand(static_cast<unsigned int>(time(nullptr)));
uniform_int_distribution<int> dist(a, b - 1);
return dist(Rand);
}
// [a,b)
double drand(int a, int b) {
static mt19937 Rand(static_cast<unsigned int>(time(nullptr)));
uniform_real_distribution<double> dist(a, b);
return dist(Rand);
}
// https://qiita.com/IgnorantCoder/items/3101d6276e9bdddf872c
template <typename A, typename F> inline auto transform(const A &v, F &&f) {
using result_type =
decltype(std::declval<F>()(std::declval<typename A::value_type>()));
vector<result_type> y(v.size());
std::transform(std::cbegin(v), std::cend(v), std::begin(y), f);
return y;
}
// generate vector which has multiple dimension
template <class T> vector<T> make_v(size_t size, const T &init) {
return vector<T>(size, init);
}
template <class... Ts> auto make_v(size_t size, Ts... rest) {
return vector<decltype(make_v(rest...))>(size, make_v(rest...));
}
template <typename T> T Max(vector<T> a) { return *max_element(all(a)); }
template <typename T> T Min(vector<T> a) { return *min_element(all(a)); }
template <typename T> T Sum(vector<T> a) { return accumulate(all(a), (T)0); }
// for counting using map
template <typename T> void Add(map<T, int> &m, T item) {
if (m.find(item) == m.end()) {
m[item] = 1;
} else {
m[item]++;
}
}
// for counting using map
template <typename T> void Erase(map<T, int> &m, T item) {
if (m.find(item) == m.end()) {
} else {
if (m[item] == 1) {
m.erase(item);
} else {
m[item]--;
}
}
}
// get method for map with default value
template <typename T, typename U> U Get(map<T, U> m, T key, U def) {
if (m.find(key) == m.end()) {
return def;
} else {
return m[key];
}
}
template <typename T> inline bool Contains(const set<T> &t, const T &key) {
return t.find(key) != t.end();
}
template <typename T, typename U>
inline bool Contains(const map<T, U> &t, const T &key) {
return t.find(key) != t.end();
}
template <class T> struct Edge {
int from, to;
T cost;
Edge(int f, int t, T c) : from(f), to(t), cost(c) {}
};
template <class T> bool operator<(const Edge<T> e1, const Edge<T> e2) {
return e1.cost < e2.cost || (e1.cost == e2.cost && e1.from < e2.from) ||
(e1.cost == e2.cost && e1.from == e2.from && e1.to < e2.to);
}
template <class T> ostream &operator<<(ostream &os, const Edge<T> &edge) {
os << "(" << edge.from << "->" << edge.to << ":" << edge.cost << ")";
return os;
}
template <class T = int> class Graph {
int n;
bool directed;
vector<vector<Edge<T>>> edges;
public:
Graph(int n, bool directed)
: n(n), directed(directed), edges(vector<vector<Edge<T>>>(n)) {}
void add_edge(int s, int t, T cost) {
edges[s].emplace_back(s, t, cost);
if (!directed) {
edges[t].emplace_back(t, s, cost);
}
}
Graph() {}
vector<Edge<T>> &operator[](size_t i) { return edges[i]; }
int size() const { return n; }
};
//======================================================
int main(void) {
int H, A;
cout << (H + A - 1) / A << endl;
return 0;
} | #include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <complex>
#include <cstdint>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <queue>
#include <random>
#include <regex>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <sys/timeb.h>
#include <vector>
using namespace std;
#define repr(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define rep(i, n) repr(i, 0, n)
#define reprrev(i, a, b) for (int i = (int)(b)-1; i >= (int)(a); i--)
#define reprev(i, n) reprrev(i, 0, n)
#define repi(itr, ds) for (auto itr = ds.begin(); itr != ds.end(); itr++)
#define chmin(mi, value) mi = min(mi, value)
#define chmax(ma, value) ma = max(ma, value)
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define mp make_pair
#define mt make_tuple
#define INF 1050000000
#define INFR INT_MAX
#define INFL (long long)(4e18)
#define INFLR LLONG_MAX
#define EPS (1e-10)
#define MOD 1000000007
// #define MOD 998244353
#define PI 3.141592653589793238
#define RMAX 4294967295
using vi = vector<int>;
using vvi = vector<vector<int>>;
using vvvi = vector<vector<vector<int>>>;
using vvvvi = vector<vector<vector<vector<int>>>>;
using ll = long long;
using vll = vector<ll>;
using vvll = vector<vector<ll>>;
using vvvll = vector<vector<vector<ll>>>;
using vd = vector<double>;
using vvd = vector<vector<double>>;
using vvvd = vector<vector<vector<double>>>;
using vb = vector<bool>;
using vvb = vector<vector<bool>>;
using vc = vector<char>;
using vvc = vector<vector<char>>;
using vs = vector<string>;
using vvs = vector<vector<string>>;
using Pi = pair<int, int>;
using vPi = vector<Pi>;
using vvPi = vector<vector<Pi>>;
using vvvPi = vector<vector<vector<Pi>>>;
using vvvvPi = vector<vector<vector<vector<Pi>>>>;
using Pll = pair<ll, ll>;
using vPll = vector<Pll>;
using Pd = pair<double, double>;
using vPd = vector<Pd>;
template <class T> using vec = vector<T>;
template <class T> using pql = priority_queue<T, vector<T>, greater<T>>;
using Comp = complex<double>;
// vvvvvvvvvvvvvvvvvvvvvvv debug output vvvvvvvvvvvvvvvvvvvvvvv
// vector input
template <typename T> istream &operator>>(istream &is, vector<T> &vec) {
for (T &x : vec)
is >> x;
return is;
}
// pair
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &pair_var) {
os << "(" << pair_var.first << ", " << pair_var.second << ")";
return os;
}
// vector
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec) {
os << "{";
for (int i = 0; i < vec.size(); i++) {
os << vec[i] << (i + 1 == vec.size() ? "" : ", ");
}
os << "}";
return os;
}
// deque
template <typename T> ostream &operator<<(ostream &os, const deque<T> &vec) {
os << "{";
for (int i = 0; i < vec.size(); i++) {
os << vec[i] << (i + 1 == vec.size() ? "" : ", ");
}
os << "}";
return os;
}
// map
template <typename T, typename U>
ostream &operator<<(ostream &os, const map<T, U> &map_var) {
os << "{";
repi(itr, map_var) {
os << *itr;
itr++;
if (itr != map_var.end())
os << ", ";
itr--;
}
os << "}";
return os;
}
// set
template <typename T> ostream &operator<<(ostream &os, const set<T> &set_var) {
os << "{";
repi(itr, set_var) {
os << *itr;
itr++;
if (itr != set_var.end())
os << ", ";
itr--;
}
os << "}";
return os;
}
// multiset
template <typename T>
ostream &operator<<(ostream &os, const multiset<T> &set_var) {
os << "{";
repi(itr, set_var) {
os << *itr;
itr++;
if (itr != set_var.end())
os << ", ";
itr--;
}
os << "}";
return os;
}
#define DUMPOUT cerr
void dump_func() { DUMPOUT << endl; }
template <class Head, class... Tail>
void dump_func(Head &&head, Tail &&...tail) {
DUMPOUT << head;
if (sizeof...(Tail) > 0) {
DUMPOUT << ", ";
}
dump_func(std::move(tail)...);
}
#ifdef DEBUG_
#define DEB
#define dump(...) \
DUMPOUT << " " << string(#__VA_ARGS__) << ": " \
<< "[" << to_string(__LINE__) << ":" << __FUNCTION__ << "]" << endl \
<< " ", \
dump_func(__VA_ARGS__)
#else
#define DEB if (false)
#define dump(...)
#endif
// ^^^^^^^^^^^^^^^^^^^^^^^ debug output ^^^^^^^^^^^^^^^^^^^^^^^
string YN(bool y, int id = 0) {
if (id)
cout << id;
return (y ? "YES" : "NO");
}
string yn(bool y, int id = 0) {
if (id)
cout << id;
return (y ? "Yes" : "No");
}
string ON(bool y, int id = 0) {
if (id)
cout << id;
return (y ? "OK" : "NG");
}
int dir4[4][2] = {{0, -1}, {-1, 0}, {1, 0}, {0, 1}};
int dir8[8][2] = {{-1, -1}, {0, -1}, {1, -1}, {-1, 0},
{1, 0}, {-1, 1}, {0, 1}, {1, 1}};
// [a,b)
int irand(int a, int b) {
static mt19937 Rand(static_cast<unsigned int>(time(nullptr)));
uniform_int_distribution<int> dist(a, b - 1);
return dist(Rand);
}
// [a,b)
double drand(int a, int b) {
static mt19937 Rand(static_cast<unsigned int>(time(nullptr)));
uniform_real_distribution<double> dist(a, b);
return dist(Rand);
}
// https://qiita.com/IgnorantCoder/items/3101d6276e9bdddf872c
template <typename A, typename F> inline auto transform(const A &v, F &&f) {
using result_type =
decltype(std::declval<F>()(std::declval<typename A::value_type>()));
vector<result_type> y(v.size());
std::transform(std::cbegin(v), std::cend(v), std::begin(y), f);
return y;
}
// generate vector which has multiple dimension
template <class T> vector<T> make_v(size_t size, const T &init) {
return vector<T>(size, init);
}
template <class... Ts> auto make_v(size_t size, Ts... rest) {
return vector<decltype(make_v(rest...))>(size, make_v(rest...));
}
template <typename T> T Max(vector<T> a) { return *max_element(all(a)); }
template <typename T> T Min(vector<T> a) { return *min_element(all(a)); }
template <typename T> T Sum(vector<T> a) { return accumulate(all(a), (T)0); }
// for counting using map
template <typename T> void Add(map<T, int> &m, T item) {
if (m.find(item) == m.end()) {
m[item] = 1;
} else {
m[item]++;
}
}
// for counting using map
template <typename T> void Erase(map<T, int> &m, T item) {
if (m.find(item) == m.end()) {
} else {
if (m[item] == 1) {
m.erase(item);
} else {
m[item]--;
}
}
}
// get method for map with default value
template <typename T, typename U> U Get(map<T, U> m, T key, U def) {
if (m.find(key) == m.end()) {
return def;
} else {
return m[key];
}
}
template <typename T> inline bool Contains(const set<T> &t, const T &key) {
return t.find(key) != t.end();
}
template <typename T, typename U>
inline bool Contains(const map<T, U> &t, const T &key) {
return t.find(key) != t.end();
}
template <class T> struct Edge {
int from, to;
T cost;
Edge(int f, int t, T c) : from(f), to(t), cost(c) {}
};
template <class T> bool operator<(const Edge<T> e1, const Edge<T> e2) {
return e1.cost < e2.cost || (e1.cost == e2.cost && e1.from < e2.from) ||
(e1.cost == e2.cost && e1.from == e2.from && e1.to < e2.to);
}
template <class T> ostream &operator<<(ostream &os, const Edge<T> &edge) {
os << "(" << edge.from << "->" << edge.to << ":" << edge.cost << ")";
return os;
}
template <class T = int> class Graph {
int n;
bool directed;
vector<vector<Edge<T>>> edges;
public:
Graph(int n, bool directed)
: n(n), directed(directed), edges(vector<vector<Edge<T>>>(n)) {}
void add_edge(int s, int t, T cost) {
edges[s].emplace_back(s, t, cost);
if (!directed) {
edges[t].emplace_back(t, s, cost);
}
}
Graph() {}
vector<Edge<T>> &operator[](size_t i) { return edges[i]; }
int size() const { return n; }
};
//======================================================
int main(void) {
int H, A;
cin >> H >> A;
cout << (H + A - 1) / A << endl;
return 0;
} | insert | 310 | 310 | 310 | 311 | 0 | |
p02783 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define vi vector<long long>
#define vvi vector<vector<long long>>
int main(void) {
int H, A;
cin >> H, A;
cout << H / A + (H % A == 0) ? (0) : (1);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define vi vector<long long>
#define vvi vector<vector<long long>>
int main(void) {
int H, A;
cin >> H;
cin >> A;
int q = H / A;
int r = (H % A == 0) ? (0) : (1);
cout << q + r;
return 0;
} | replace | 6 | 8 | 6 | 11 | 0 | |
p02783 | C++ | Runtime Error | #include <bits/stdc++.h>
#include <cstdio>
using namespace std;
#define deb(x) cout << #x << " " << x << endl;
typedef long long ll;
const ll mod = 1000000007;
#define For(i, n) for (int i = 0; i < n; i++)
int main() {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
int t, i, n, j;
cin >> t >> n;
if (t % n == 0)
cout << t / n;
else {
cout << t / n + 1;
}
return 0;
} | #include <bits/stdc++.h>
#include <cstdio>
using namespace std;
#define deb(x) cout << #x << " " << x << endl;
typedef long long ll;
const ll mod = 1000000007;
#define For(i, n) for (int i = 0; i < n; i++)
int main() {
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
int t, i, n, j;
cin >> t >> n;
if (t % n == 0)
cout << t / n;
else {
cout << t / n + 1;
}
return 0;
} | replace | 13 | 15 | 13 | 15 | 0 | |
p02783 | C++ | Runtime Error | #pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<int, P> P1;
typedef pair<P, P> P2;
#define pu push
#define pb push_back
#define mp make_pair
#define eps 1e-7
#define INF 1000000000
#define mod 1000000007
#define fi first
#define sc second
#define rep(i, x) for (int i = 0; i < x; i++)
#define repn(i, x) for (int i = 1; i <= x; i++)
#define SORT(x) sort(x.begin(), x.end())
#define ERASE(x) x.erase(unique(x.begin(), x.end()), x.end())
#define POSL(x, v) (lower_bound(x.begin(), x.end(), v) - x.begin())
#define POSU(x, v) (upper_bound(x.begin(), x.end(), v) - x.begin())
int main() {
int a, b;
cout << (a + b - 1) / b << endl;
} | #pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<int, P> P1;
typedef pair<P, P> P2;
#define pu push
#define pb push_back
#define mp make_pair
#define eps 1e-7
#define INF 1000000000
#define mod 1000000007
#define fi first
#define sc second
#define rep(i, x) for (int i = 0; i < x; i++)
#define repn(i, x) for (int i = 1; i <= x; i++)
#define SORT(x) sort(x.begin(), x.end())
#define ERASE(x) x.erase(unique(x.begin(), x.end()), x.end())
#define POSL(x, v) (lower_bound(x.begin(), x.end(), v) - x.begin())
#define POSU(x, v) (upper_bound(x.begin(), x.end(), v) - x.begin())
int main() {
int a, b;
cin >> a >> b;
cout << (a + b - 1) / b << endl;
} | insert | 28 | 28 | 28 | 29 | -8 | |
p02783 | C++ | Time Limit Exceeded | #include <iostream>
using namespace std;
int main() {
int h, a, j = 0;
cin >> h >> a;
while (h > 0) {
h = a, j++;
}
cout << j << endl;
} | #include <iostream>
using namespace std;
int main() {
int h, a, j = 0;
cin >> h >> a;
while (h > 0) {
h -= a, j++;
}
cout << j << endl;
} | replace | 6 | 7 | 6 | 7 | TLE | |
p02783 | C++ | Runtime Error | #include <iostream>
using namespace std;
int main() {
int H, A;
cin >> H, A;
if (H % A == 0) {
cout << H / A << endl;
} else {
cout << (H / A) + 1 << endl;
}
}
| #include <iostream>
using namespace std;
int main() {
int H, A;
cin >> H >> A;
if (H % A == 0) {
cout << H / A << endl;
} else {
cout << (H / A) + 1 << endl;
}
}
| replace | 5 | 6 | 5 | 6 | 0 | |
p02783 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define FAST_IO \
ios_base::sync_with_stdio(0); \
cin.tie(0)
#define FOR(i, a, b) for (int i = (a); i <= (b); i++)
#define REP(n) FOR(O, 1, (n))
#define pb push_back
#define f first
#define s second
typedef long double ld;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<int, pii> piii;
typedef vector<int> vi;
typedef vector<pii> vii;
typedef vector<ll> vl;
typedef vector<piii> viii;
const int MAXN = 1000100, MAXK = 30;
const ll MOD = 1e9 + 7;
const ll INF = 1e18;
const ld PI = asin(1) * 2;
int main() {
FAST_IO;
int h, a;
cout << (h + a - 1) / a << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define FAST_IO \
ios_base::sync_with_stdio(0); \
cin.tie(0)
#define FOR(i, a, b) for (int i = (a); i <= (b); i++)
#define REP(n) FOR(O, 1, (n))
#define pb push_back
#define f first
#define s second
typedef long double ld;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<int, pii> piii;
typedef vector<int> vi;
typedef vector<pii> vii;
typedef vector<ll> vl;
typedef vector<piii> viii;
const int MAXN = 1000100, MAXK = 30;
const ll MOD = 1e9 + 7;
const ll INF = 1e18;
const ld PI = asin(1) * 2;
int main() {
FAST_IO;
int h, a;
cin >> h >> a;
cout << (h + a - 1) / a << endl;
return 0;
}
| insert | 30 | 30 | 30 | 31 | 0 | |
p02783 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define ll long long
#define ull unsigned long long
#define F first
#define S second
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V> void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T> void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto &i : x)
cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V> void _print(T t, V... v) {
__print(t);
if (sizeof...(v))
cerr << ", ";
_print(v...);
}
#ifndef ONLINE_JUDGE
#define debug(x...) \
cerr << "[" << #x << "] = ["; \
_print(x)
#else
#define debug(x...)
#endif
const int MOD = 1e9 + 7;
const int N = 1e5 + 10;
int main(void) {
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
#endif
int h, a;
scanf("%d %d", &h, &a);
int ans = 0;
ans += h / a;
if (h % a)
ans++;
printf("%d\n", ans);
return false;
}
| #include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define ll long long
#define ull unsigned long long
#define F first
#define S second
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V> void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T> void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto &i : x)
cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V> void _print(T t, V... v) {
__print(t);
if (sizeof...(v))
cerr << ", ";
_print(v...);
}
#ifndef ONLINE_JUDGE
#define debug(x...) \
cerr << "[" << #x << "] = ["; \
_print(x)
#else
#define debug(x...)
#endif
const int MOD = 1e9 + 7;
const int N = 1e5 + 10;
int main(void) {
#ifndef ONLINE_JUDGE
// freopen("input.txt", "r", stdin);
#endif
int h, a;
scanf("%d %d", &h, &a);
int ans = 0;
ans += h / a;
if (h % a)
ans++;
printf("%d\n", ans);
return false;
}
| replace | 56 | 57 | 56 | 57 | 0 | |
p02783 | C++ | Runtime Error | #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <unistd.h>
#define ll long long
#define lst(x) x.size() - 1
#define ld long double
#define pr pair<ll, ll>
#define loop(i, n) for (int i = 0; i < n; ++i)
#define rep(i, x, n) for (int i = x; i <= n; ++i)
#define iteloop(type, data, name, it) \
for (type<data>::iterator it = name.begin(); it != name.end(); ++it)
using namespace __gnu_pbds;
using namespace std;
template <typename T>
using os = tree<T, null_type, less_equal<T>, rb_tree_tag,
tree_order_statistics_node_update>;
const ll N = 3e5 + 5, M = 1e1 + 5, MOD = 1e9 + 7, OO = 1e13;
double h, a;
int main() {
cin.sync_with_stdio(false), cin.tie(0), cout.tie(0);
#ifndef ONLINE_JUDGE
freopen("in.txt", "rt", stdin);
// freopen("in.txt", "wt" , stdout);
#endif // ONLINE_JUDGE
cin >> h >> a;
int ans = ceil(h / a);
cout << ans << endl;
}
| #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <unistd.h>
#define ll long long
#define lst(x) x.size() - 1
#define ld long double
#define pr pair<ll, ll>
#define loop(i, n) for (int i = 0; i < n; ++i)
#define rep(i, x, n) for (int i = x; i <= n; ++i)
#define iteloop(type, data, name, it) \
for (type<data>::iterator it = name.begin(); it != name.end(); ++it)
using namespace __gnu_pbds;
using namespace std;
template <typename T>
using os = tree<T, null_type, less_equal<T>, rb_tree_tag,
tree_order_statistics_node_update>;
const ll N = 3e5 + 5, M = 1e1 + 5, MOD = 1e9 + 7, OO = 1e13;
double h, a;
int main() {
cin.sync_with_stdio(false), cin.tie(0), cout.tie(0);
#ifndef ONLINE_JUDGE
// freopen("in.txt", "rt" , stdin);
// freopen("in.txt", "wt" , stdout);
#endif // ONLINE_JUDGE
cin >> h >> a;
int ans = ceil(h / a);
cout << ans << endl;
}
| replace | 25 | 26 | 25 | 26 | 0 | |
p02783 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main() {
int H, A;
cin >> H, A;
cout << (H + A - 1) / A << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int H, A;
cin >> H >> A;
cout << (H + A - 1) / A << endl;
}
| replace | 5 | 6 | 5 | 6 | 0 | |
p02783 | C++ | Runtime Error | #include <algorithm>
#include <climits>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
#define sz(x) (int)x.size()
#define all(x) begin(x), end(x)
#define rall(x) rbegin(x), rend(x)
#define cina(s, n, a) \
for (int i = s; i < n; i++) \
cin >> a[i]
#define couta(n, a) \
for (int i = 0; i < n; i++) \
cout << a[i] << ' '
#define copy(s, n, a, b) \
for (int i = s; i < n; i++) \
b[i] = a[i]
#define yesno(ok) cout << (ok ? "YES" : "NO")
#define mod(a, b) (b + (a % b)) % b
#define MOD (ll)1e9 + 7
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<pii> vpii;
void solve() {
int a, b;
cin >> a >> b;
cout << (a + b - 1) / b;
}
int main() {
ios::sync_with_stdio(false);
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
int q = 1;
cin >> q;
for (int i = 1; i <= q; i++) {
solve();
}
}
| #include <algorithm>
#include <climits>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
#define sz(x) (int)x.size()
#define all(x) begin(x), end(x)
#define rall(x) rbegin(x), rend(x)
#define cina(s, n, a) \
for (int i = s; i < n; i++) \
cin >> a[i]
#define couta(n, a) \
for (int i = 0; i < n; i++) \
cout << a[i] << ' '
#define copy(s, n, a, b) \
for (int i = s; i < n; i++) \
b[i] = a[i]
#define yesno(ok) cout << (ok ? "YES" : "NO")
#define mod(a, b) (b + (a % b)) % b
#define MOD (ll)1e9 + 7
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<pii> vpii;
void solve() {
int a, b;
cin >> a >> b;
cout << (a + b - 1) / b;
}
int main() {
ios::sync_with_stdio(false);
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
int q = 1;
// cin >> q;
for (int i = 1; i <= q; i++) {
solve();
}
}
| replace | 53 | 54 | 53 | 54 | 0 | |
p02783 | C++ | Runtime Error | #include <algorithm>
#include <bits/stdc++.h>
#include <iostream>
#define max(a, b) a > b ? a : b
#define min(a, b) a < b ? a : b
#define pb push_back
#define IM_N00B \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0)
using namespace std;
typedef long long ll;
int main() {
IM_N00B;
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
int h, a;
cin >> h >> a;
int ans = h / a;
if (h % a != 0)
cout << ans + 1;
else
cout << ans;
return 0;
}
| #include <algorithm>
#include <bits/stdc++.h>
#include <iostream>
#define max(a, b) a > b ? a : b
#define min(a, b) a < b ? a : b
#define pb push_back
#define IM_N00B \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0)
using namespace std;
typedef long long ll;
int main() {
int h, a;
cin >> h >> a;
int ans = h / a;
if (h % a != 0)
cout << ans + 1;
else
cout << ans;
return 0;
}
| delete | 15 | 21 | 15 | 15 | 0 | |
p02783 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
int main() {
int i, n;
cin >> i >> n;
int result = 0;
while (1) {
i -= n;
if (n <= 0) {
break;
}
}
cout << result << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int i, n;
cin >> i >> n;
int result = 0;
while (1) {
i -= n;
result++;
if (i <= 0) {
break;
}
}
cout << result << endl;
} | replace | 9 | 10 | 9 | 11 | TLE | |
p02783 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int n, m, k;
int main() {
freopen("in.txt", "r", stdin);
cin >> n >> m;
cout << (n - 1) / m + 1 << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int n, m, k;
int main() {
// freopen("in.txt","r",stdin);
cin >> n >> m;
cout << (n - 1) / m + 1 << endl;
return 0;
} | replace | 6 | 7 | 6 | 7 | -8 | |
p02783 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
using namespace std;
int main(void) {
int h, a;
cout << (h + (a - 1)) / a << endl;
return 0;
} | #include <algorithm>
#include <iostream>
using namespace std;
int main(void) {
int h, a;
cin >> h >> a;
cout << (h + (a - 1)) / a << endl;
return 0;
} | insert | 6 | 6 | 6 | 7 | 0 | |
p02783 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, a;
cin >> n >> a;
int c = 0;
for (int i = n; i > 0;) {
c++;
n = n - a;
}
cout << c;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, a;
cin >> n >> a;
int c = 0;
while (n > 0) {
c++;
n = n - a;
}
cout << c;
return 0;
}
| replace | 6 | 7 | 6 | 7 | TLE | |
p02783 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
int main() {
int h, a;
cout << (h + a - 1) / a;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
int main() {
int h, a;
cin >> h >> a;
cout << (h + a - 1) / a;
return 0;
} | insert | 6 | 6 | 6 | 7 | 0 | |
p02783 | Python | Runtime Error | h = int(input()) # Monster health
a = int(input()) # Servant attack
x = a
attack = 1
while h > x:
h -= x
attack += 1
print(attack)
| h, a = input().split()
h = int(h)
a = int(a)
x = a
attack = 1
while h > x:
h -= x
attack += 1
print(attack)
| replace | 0 | 2 | 0 | 3 | ValueError: invalid literal for int() with base 10: '10 4' | Traceback (most recent call last):
File "/home/alex/Documents/bug-detection/input/Project_CodeNet/data/p02783/Python/s514023585.py", line 1, in <module>
h = int(input()) # Monster health
ValueError: invalid literal for int() with base 10: '10 4'
|
p02783 | C++ | Time Limit Exceeded | // 2020.1.26.#153:A
#include <cmath>
#include <iostream>
using namespace std;
int main(int argc, char const *argv[]) {
int i = 0;
unsigned A, H;
do {
cin >> A, H;
if (A <= 10000 && H <= 10000 && A >= 1 && H >= 1) {
break;
}
} while (1);
while (A * (++i) < H) {
}
cout << i << endl;
return 0;
}
| // 2020.1.26.#153:A
#include <cmath>
#include <iostream>
using namespace std;
int main(int argc, char const *argv[]) {
int i = 0;
unsigned A, H;
do {
cin >> H;
cin >> A;
if (A <= 10000 && H <= 10000 && A >= 1 && H >= 1) {
break;
}
} while (1);
while (A * (++i) < H) {
}
cout << i << endl;
return 0;
}
| replace | 9 | 10 | 9 | 11 | TLE | |
p02783 | C++ | Time Limit Exceeded | #include <iostream>
using namespace std;
int main() {
int H, A, b = 0;
cin >> H >> A;
while (H > 0)
;
{
H -= A;
b++;
}
cout << b << endl;
return 0;
} | #include <iostream>
using namespace std;
int main() {
int H, A, b = 0;
cin >> H >> A;
while (H > 0) {
H -= A;
b++;
}
cout << b << endl;
return 0;
} | replace | 6 | 9 | 6 | 7 | TLE | |
p02783 | C++ | Runtime Error | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
const int inf = 2147483647, dx[] = {-1, 0, 1, 0},
dy[] = {0, -1, 0, 1}; // 上 左 下 右
const int N = 100005, M = 1000005, K = 200005, mod = 1000000007;
const long long llinf = 9223372036854775807ll;
// int & long long
int h, a;
int main() {
cin >> h >> a;
cout << h / a + (h % a) / (h % a);
return 0;
} | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
const int inf = 2147483647, dx[] = {-1, 0, 1, 0},
dy[] = {0, -1, 0, 1}; // 上 左 下 右
const int N = 100005, M = 1000005, K = 200005, mod = 1000000007;
const long long llinf = 9223372036854775807ll;
// int & long long
int h, a;
int main() {
cin >> h >> a;
if (h % a == 0)
cout << h / a;
else
cout << h / a + 1;
return 0;
} | replace | 27 | 28 | 27 | 31 | 0 | |
p02783 | C++ | Runtime Error | /*
author : masaow
g++ : 17.3.20
*/
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define forn(i, a, b) for (i = a; i < b; i++)
#define debug(x) cout << #x << " " << x << " -- \n "
#define I__O ios::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL)
#define ll long long
#define p(x) cout << x << "\n";
#define MOD 100000007
#define pi pair<int, int>
#define vi vector<int>
#define pb push_back
#define vp vector<pair<ll, ll>>
#define endl cout << "\n"
#define mi map<int, int>
#define f1 first
#define s1 second
#define in insert
#define all(x) x.begin(), x.end()
using namespace std;
using namespace __gnu_pbds;
typedef tree<int, null_type, less<int>, rb_tree_tag,
tree_order_statistics_node_update>
indexed_set;
const int N = 2e5 + 7;
/*
time : 10 : 14
date : 24.01.2020
*/
// int L,R,mid,target,idx ;
int tests() {
int a, b;
cin >> a >> b;
cout << (a + b - 1) / b << '\n';
return 0;
}
int main() {
I__O;
int cases = 1;
cin >> cases;
while (cases--)
tests();
return 0;
} | /*
author : masaow
g++ : 17.3.20
*/
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define forn(i, a, b) for (i = a; i < b; i++)
#define debug(x) cout << #x << " " << x << " -- \n "
#define I__O ios::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL)
#define ll long long
#define p(x) cout << x << "\n";
#define MOD 100000007
#define pi pair<int, int>
#define vi vector<int>
#define pb push_back
#define vp vector<pair<ll, ll>>
#define endl cout << "\n"
#define mi map<int, int>
#define f1 first
#define s1 second
#define in insert
#define all(x) x.begin(), x.end()
using namespace std;
using namespace __gnu_pbds;
typedef tree<int, null_type, less<int>, rb_tree_tag,
tree_order_statistics_node_update>
indexed_set;
const int N = 2e5 + 7;
/*
time : 10 : 14
date : 24.01.2020
*/
// int L,R,mid,target,idx ;
int tests() {
int a, b;
cin >> a >> b;
cout << (a + b - 1) / b << '\n';
return 0;
}
int main() {
I__O;
int cases = 1;
// cin >> cases;
while (cases--)
tests();
return 0;
} | replace | 44 | 45 | 44 | 45 | 0 | |
p02783 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long int lli;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<lli> vli;
typedef priority_queue<int, vector<int>, greater<int>> min_pq;
const int MOD = 1e9 + 7;
#define fastio \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0)
#define init(a) memset(a, 0, sizeof(a))
#define pb push_back
#define all(a) a.begin(), a.end()
#define loop(i, n) for (int i = 0; i < n; i++)
#define loops(i, s, n) for (int i = s; i < n; i++)
#define rloop(i, n) for (int i = n - 1; i >= 0; i--)
#define rloops(i, s, n) for (int i = n - 1; i >= s; i--)
template <typename T> T gcd(T a, T b) { return (b ? __gcd(a, b) : a); }
template <typename T> T lcm(T a, T b) { return (a * b) / gcd(a, b); }
double tick() {
static clock_t oldt, newt = clock();
double diff = 1.0 * (newt - oldt) / CLOCKS_PER_SEC;
oldt = newt;
return diff;
}
//---------------------------------------------------------------------------------------------
int main() {
fastio;
#ifndef ONLINE_JUDGE
freopen("in.txt", "r", stdin);
#endif
int h, a;
cin >> h >> a;
int ans = ceil((float)(h) / (float)a);
cout << ans << endl;
// cout<<"Execution time : "<<tick()<<"\n";
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long int lli;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<lli> vli;
typedef priority_queue<int, vector<int>, greater<int>> min_pq;
const int MOD = 1e9 + 7;
#define fastio \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0)
#define init(a) memset(a, 0, sizeof(a))
#define pb push_back
#define all(a) a.begin(), a.end()
#define loop(i, n) for (int i = 0; i < n; i++)
#define loops(i, s, n) for (int i = s; i < n; i++)
#define rloop(i, n) for (int i = n - 1; i >= 0; i--)
#define rloops(i, s, n) for (int i = n - 1; i >= s; i--)
template <typename T> T gcd(T a, T b) { return (b ? __gcd(a, b) : a); }
template <typename T> T lcm(T a, T b) { return (a * b) / gcd(a, b); }
double tick() {
static clock_t oldt, newt = clock();
double diff = 1.0 * (newt - oldt) / CLOCKS_PER_SEC;
oldt = newt;
return diff;
}
//---------------------------------------------------------------------------------------------
int main() {
fastio;
int h, a;
cin >> h >> a;
int ans = ceil((float)(h) / (float)a);
cout << ans << endl;
// cout<<"Execution time : "<<tick()<<"\n";
return 0;
} | delete | 37 | 41 | 37 | 37 | 0 | |
p02783 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
int main() {
int a, b, c;
cin >> a, b;
c = a / b;
if (a % b != 0) {
c++;
}
cout << c << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
int main() {
int a, b, c;
cin >> a >> b;
c = a / b;
if (a % b != 0) {
c++;
}
cout << c << endl;
}
| replace | 5 | 6 | 5 | 6 | 0 | |
p02783 | Python | Runtime Error | H, A = map(int, input().split())
print(H // A + min(H % A))
| H, A = map(int, input().split())
print(H // A + min(H % A, 1))
| replace | 2 | 3 | 2 | 3 | TypeError: 'int' object is not iterable | Traceback (most recent call last):
File "/home/alex/Documents/bug-detection/input/Project_CodeNet/data/p02783/Python/s363144861.py", line 3, in <module>
print(H // A + min(H % A))
TypeError: 'int' object is not iterable
|
p02783 | C++ | Runtime Error | #define _CRT_SECURE_NO_WARNINGS
#include <bits/stdc++.h>
#include <unordered_map>
#define endl "\n"
#define all(v) v.begin(), v.end()
#define allr(s) s.rbegin(), s.rend()
#define RT(s) return cout << s, 0
#define watch(x) cout << (#x) << " = " << x << endl
#define sz(s) (int)(s.size())
// #define PI acos(-1)
#define EPS 1e-8
using namespace std;
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
typedef pair<int, int> ii;
typedef vector<int> vi;
typedef vector<ii> vii;
int dy[] = {1, -1, 0, 0, -1, 1, 1, -1};
int dx[] = {0, 0, 1, -1, 1, -1, 1, -1};
void file() {
#ifndef ONLINE_JUDGE
freopen("in.txt", "r", stdin);
// freopen("out.txt", "w", stdout);
#else
// freopen("street.in", "r", stdin);
// freopen("out.txt", "w", stdout);
#endif
}
void fast() {
std::ios_base::sync_with_stdio(0);
cin.tie(NULL);
}
int main() {
file();
fast();
int h, a;
cin >> h >> a;
cout << (h + a - 1) / a << endl;
return 0;
} | #define _CRT_SECURE_NO_WARNINGS
#include <bits/stdc++.h>
#include <unordered_map>
#define endl "\n"
#define all(v) v.begin(), v.end()
#define allr(s) s.rbegin(), s.rend()
#define RT(s) return cout << s, 0
#define watch(x) cout << (#x) << " = " << x << endl
#define sz(s) (int)(s.size())
// #define PI acos(-1)
#define EPS 1e-8
using namespace std;
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
typedef pair<int, int> ii;
typedef vector<int> vi;
typedef vector<ii> vii;
int dy[] = {1, -1, 0, 0, -1, 1, 1, -1};
int dx[] = {0, 0, 1, -1, 1, -1, 1, -1};
void file() {
#ifndef ONLINE_JUDGE
freopen("in.txt", "r", stdin);
// freopen("out.txt", "w", stdout);
#else
// freopen("street.in", "r", stdin);
// freopen("out.txt", "w", stdout);
#endif
}
void fast() {
std::ios_base::sync_with_stdio(0);
cin.tie(NULL);
}
int main() {
// file();
fast();
int h, a;
cin >> h >> a;
cout << (h + a - 1) / a << endl;
return 0;
} | replace | 35 | 36 | 35 | 36 | 0 | |
p02783 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main() {
int h, a;
cin >> h, a;
cout << (h + (a - 1)) / a << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int h, a;
cin >> h >> a;
int ans = (h + (a - 1)) / a;
cout << ans << endl;
return 0;
}
| replace | 4 | 6 | 4 | 8 | 0 | |
p02783 | C++ | Runtime Error | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <vector>
using namespace std;
int main() {
long long int a = 0, b = 0, c = 0, d = 0, n = 0, ans = 0, count = 0, h, w, up,
down, end = 0, idx, m, kuso;
string s;
vector<long long int> x;
vector<long long int>::iterator position;
bool q = false;
cin >> h, a;
ans = h / a;
if (h % a != 0)
ans++;
cout << ans << endl;
} | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <vector>
using namespace std;
int main() {
long long int a = 0, b = 0, c = 0, d = 0, n = 0, ans = 0, count = 0, h, w, up,
down, end = 0, idx, m, kuso;
string s;
vector<long long int> x;
vector<long long int>::iterator position;
bool q = false;
cin >> h >> a;
ans = h / a;
if (h % a != 0)
ans++;
cout << ans << endl;
} | replace | 12 | 13 | 12 | 13 | -8 | |
p02783 | C++ | Runtime Error | #include <cmath>
#include <cstdio>
int main() {
int h, a;
scanf("%d", &h, &a);
printf("%d", (int)ceil(h / a));
return 0;
} | #include <cmath>
#include <cstdio>
int main() {
int h, a;
scanf("%d%d", &h, &a);
printf("%d", (int)ceil((double)h / a));
return 0;
} | replace | 4 | 6 | 4 | 6 | -8 | |
p02783 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
const int N = 3e5 + 50;
int n, m, a[N];
int main() {
#ifdef ONLINE_JUDGE
#else
freopen("r.txt", "r", stdin);
#endif
ios::sync_with_stdio(false);
cin >> n >> m;
cout << (n + m - 1) / m;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
const int N = 3e5 + 50;
int n, m, a[N];
int main() {
ios::sync_with_stdio(false);
cin >> n >> m;
cout << (n + m - 1) / m;
} | delete | 18 | 22 | 18 | 18 | -8 | |
p02783 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main() {
int h, a;
cin >> h >> a;
return h % a ? h / a : ((h / a) + 1);
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int h, a;
cin >> h >> a;
int ans = h % a ? ((h / a) + 1) : h / a;
cout << ans << endl;
return 0;
} | replace | 5 | 6 | 5 | 8 | 2 | |
p02783 | C++ | Runtime Error | #define _CRT_SECURE_NO_WARNINGS
#include <bits/stdc++.h>
#include <unordered_map>
#include <unordered_set>
using namespace std;
typedef long long ll;
#define bay_bay return 0;
#define fori(n) for (int i = 0; i < n; ++i)
#define for1(n) for (int i = 1; i <= n; i += 3)
#define all(v) ((v).begin()), ((v).end())
#define sz(v) v.size()
#define endl "\n"
constexpr auto EPS = 1e-9;
#define ff fflush(stdout);
const int mod = 1000000007;
clock_t T;
#define ctime cerr << "Time : " << double(clock() - T) / CLOCKS_PER_SEC << endl
void GOAT() {
std::ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
#else
#endif
}
int main() {
GOAT();
int h, a;
cin >> h >> a;
(h % a == 0) ? cout << h / a : cout << (h / a) + 1;
} | #define _CRT_SECURE_NO_WARNINGS
#include <bits/stdc++.h>
#include <unordered_map>
#include <unordered_set>
using namespace std;
typedef long long ll;
#define bay_bay return 0;
#define fori(n) for (int i = 0; i < n; ++i)
#define for1(n) for (int i = 1; i <= n; i += 3)
#define all(v) ((v).begin()), ((v).end())
#define sz(v) v.size()
#define endl "\n"
constexpr auto EPS = 1e-9;
#define ff fflush(stdout);
const int mod = 1000000007;
clock_t T;
#define ctime cerr << "Time : " << double(clock() - T) / CLOCKS_PER_SEC << endl
void GOAT() {
std::ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
#else
#endif
}
int main() {
// GOAT();
int h, a;
cin >> h >> a;
(h % a == 0) ? cout << h / a : cout << (h / a) + 1;
} | replace | 29 | 30 | 29 | 30 | 0 | |
p02783 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
int main() {
int H, A;
cin >> H >> A;
for (int i = 0;; i++) {
H = H - i * A;
if (H <= 0) {
cout << i << endl;
}
}
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int H, A;
cin >> H >> A;
if (H % A == 0)
cout << H / A << endl;
else
cout << H / A + 1 << endl;
}
| replace | 5 | 11 | 5 | 9 | TLE | |
p02783 | C++ | Runtime Error | #define _USE_MATH_DEFINES
#include <bits/stdc++.h>
#define ll long long
#define pb push_back
#define mp make_pair
#define ff first
#define ss second
#define vi vector<int>
#define br cout << "\n";
#define all(x) (x).begin(), (x).end()
#define tr(c, i) for (auto i : c)
#define pii pair<int, int>
#define fast_io() \
ios_base::sync_with_stdio(false); \
cin.tie(nullptr)
#define pq \
priority_queue<pair<ll, pii>, vector<pair<ll, pii>>, greater<pair<ll, pii>>> \
p; // container adapter makes ascending q
#define er(x) cout << x << " "
#define err(x, y) cout << x << " " << y
using namespace std;
const ll MAX = 1000 * 1000;
const int dx[] = {1, -1, 0, 0};
const int dy[] = {0, 0, 1, -1};
const int MOD = 1000 * 1000 * 1000 + 7;
const int N = 301;
const int INF = INT_MAX;
const int M = 200005;
int main() {
#ifndef ONLINE_JUDGE
freopen("C:/Users/Abhudya/Desktop/input.txt", "r", stdin);
freopen("C:/Users/Abhudya/Desktop/output.txt", "w", stdout);
#endif
ll h, a;
cin >> h >> a;
cout << ((h + a - 1) / a);
return 0;
}
| #define _USE_MATH_DEFINES
#include <bits/stdc++.h>
#define ll long long
#define pb push_back
#define mp make_pair
#define ff first
#define ss second
#define vi vector<int>
#define br cout << "\n";
#define all(x) (x).begin(), (x).end()
#define tr(c, i) for (auto i : c)
#define pii pair<int, int>
#define fast_io() \
ios_base::sync_with_stdio(false); \
cin.tie(nullptr)
#define pq \
priority_queue<pair<ll, pii>, vector<pair<ll, pii>>, greater<pair<ll, pii>>> \
p; // container adapter makes ascending q
#define er(x) cout << x << " "
#define err(x, y) cout << x << " " << y
using namespace std;
const ll MAX = 1000 * 1000;
const int dx[] = {1, -1, 0, 0};
const int dy[] = {0, 0, 1, -1};
const int MOD = 1000 * 1000 * 1000 + 7;
const int N = 301;
const int INF = INT_MAX;
const int M = 200005;
int main() {
ll h, a;
cin >> h >> a;
cout << ((h + a - 1) / a);
return 0;
}
| delete | 30 | 34 | 30 | 30 | 0 | |
p02784 | Python | Runtime Error | H, N = map(int, input().split())
attacks = [*map(int, input().split())]
if sum(attacks) >= H:
print("Yes")
else:
print("No")
| H, N = map(int, input().split())
attacks = list(map(int, input().split()))
if sum(attacks) >= H:
print("Yes")
else:
print("No")
| replace | 1 | 2 | 1 | 2 | 0 | |
p02784 | C++ | Runtime Error | #include <stdio.h>
int main(void) {
int H;
int N;
int T = 0;
int array[10000];
scanf("%d", &H);
scanf("%d", &N);
for (int i = 0; i < N; i++) {
scanf("%d", &array[i]);
T = T + array[i];
}
if (T >= H) {
printf("Yes");
}
if (T < H) {
printf("No");
}
} | #include <stdio.h>
int main(void) {
int H;
int N;
int T = 0;
int array[100000];
scanf("%d", &H);
scanf("%d", &N);
for (int i = 0; i < N; i++) {
scanf("%d", &array[i]);
T = T + array[i];
}
if (T >= H) {
printf("Yes");
}
if (T < H) {
printf("No");
}
} | replace | 5 | 6 | 5 | 6 | 0 | |
p02784 | C++ | Runtime Error | #include <stdio.h>
#include <string.h>
int main(void) {
int H, N, i;
int A[N];
int s = 0;
scanf("%d %d", &H, &N);
for (i = 0; i < N; i++) {
scanf("%d", &A[i]);
}
for (i = 0; i < N; i++) {
s = s + A[i];
}
if (s >= H) {
printf("Yes\n");
} else {
printf("No\n");
}
return 0;
} | #include <stdio.h>
#include <string.h>
int main(void) {
int H, N, i;
int A[1000001];
int s = 0;
scanf("%d %d", &H, &N);
for (i = 0; i < N; i++) {
scanf("%d", &A[i]);
}
for (i = 0; i < N; i++) {
s = s + A[i];
}
if (s >= H) {
printf("Yes\n");
} else {
printf("No\n");
}
return 0;
} | replace | 4 | 5 | 4 | 5 | 0 | |
p02784 | C++ | Runtime Error | #include <stdio.h>
int main(void) {
int h, n, a[1000], i, m;
m = 0;
scanf("%d %d", &h, &n);
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
for (i = 0; i < n; i++) {
m += a[i];
}
if (m >= h) {
printf("Yes\n");
} else {
printf("No\n");
}
return 0;
} | #include <stdio.h>
int main(void) {
int h, n, a[100000], i, m;
m = 0;
scanf("%d %d", &h, &n);
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
for (i = 0; i < n; i++) {
m += a[i];
}
if (m >= h) {
printf("Yes\n");
} else {
printf("No\n");
}
return 0;
} | replace | 2 | 3 | 2 | 3 | 0 | |
p02784 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <vector>
using namespace std;
typedef pair<int, int> P;
typedef long long ll;
ll mod = 1e9 + 7;
int main() {
ll h;
int n;
ll a[10000];
cin >> h >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
ll sum = 0;
for (int i = 0; i < n; i++) {
sum += a[i];
}
if (sum >= h) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return 0;
}
| #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <vector>
using namespace std;
typedef pair<int, int> P;
typedef long long ll;
ll mod = 1e9 + 7;
int main() {
ll h;
int n;
ll a[100000];
cin >> h >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
ll sum = 0;
for (int i = 0; i < n; i++) {
sum += a[i];
}
if (sum >= h) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return 0;
}
| replace | 20 | 21 | 20 | 21 | 0 | |
p02784 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main() {
int h, N;
int a[10000];
cin >> h >> N;
for (int i = 0; i < N; ++i)
cin >> a[i];
int sum;
for (int i = 0; i < N; ++i)
sum += a[i];
if (h <= sum) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int h, N;
int a[100000];
cin >> h >> N;
for (int i = 0; i < N; ++i)
cin >> a[i];
int sum;
for (int i = 0; i < N; ++i)
sum += a[i];
if (h <= sum) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
}
| replace | 5 | 6 | 5 | 6 | 0 | |
p02784 | C++ | Runtime Error | #include <bits/stdc++.h>
#define ll long long
#define int long long
#define MOD 1000000007
#define MAX 500005
#include <iomanip>
#define Need_for_speed(activated) \
ios_base ::sync_with_stdio(0); \
cin.tie(NULL); \
cout.tie(NULL)
#define satisfy \
ll t; \
cin >> t; \
while (t--)
#define inp(n) \
int n; \
cin >> n
#define mp make_pair
#define pb push_back
#define fore(i, a, b) for (ll i = a; i < b; i++)
#define x first
#define y second
using namespace std;
int gcd(int a, int b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
int32_t main() {
Need_for_speed(activated);
// satisfy
// {}
ll h, n;
cin >> h >> n;
ll s = 0;
ll a[10005];
for (ll i = 0; i < n; i++)
cin >> a[i];
for (ll i = 0; i < n; i++) {
s += a[i];
}
if (s >= h)
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
}
| #include <bits/stdc++.h>
#define ll long long
#define int long long
#define MOD 1000000007
#define MAX 500005
#include <iomanip>
#define Need_for_speed(activated) \
ios_base ::sync_with_stdio(0); \
cin.tie(NULL); \
cout.tie(NULL)
#define satisfy \
ll t; \
cin >> t; \
while (t--)
#define inp(n) \
int n; \
cin >> n
#define mp make_pair
#define pb push_back
#define fore(i, a, b) for (ll i = a; i < b; i++)
#define x first
#define y second
using namespace std;
int gcd(int a, int b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
int32_t main() {
Need_for_speed(activated);
// satisfy
// {}
ll h, n;
cin >> h >> n;
ll s = 0;
ll a[100005];
for (ll i = 0; i < n; i++)
cin >> a[i];
for (ll i = 0; i < n; i++) {
s += a[i];
}
if (s >= h)
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
}
| replace | 37 | 38 | 37 | 38 | 0 | |
p02784 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
int main() {
long long int h, sum = 0;
int n, a[10000];
cin >> h >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
}
if (sum >= h) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return 0;
} | #include <algorithm>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
int main() {
long long int h, sum = 0;
int n, a[100000];
cin >> h >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
}
if (sum >= h) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return 0;
} | replace | 13 | 14 | 13 | 14 | 0 | |
p02784 | C++ | Runtime Error | #include <iostream>
#include <vector>
using namespace std;
int main() {
long long h;
long long n;
cin >> h;
cin >> n;
long long A[10000 + 1];
long long sum = 0;
for (long long i = 0; i < n; i++) {
cin >> A[i];
sum += A[i];
}
if (h - sum <= 0) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return 0;
}
| #include <iostream>
#include <vector>
using namespace std;
int main() {
long long h;
long long n;
cin >> h;
cin >> n;
long long A[100000 + 1];
long long sum = 0;
for (long long i = 0; i < n; i++) {
cin >> A[i];
sum += A[i];
}
if (h - sum <= 0) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return 0;
}
| replace | 8 | 9 | 8 | 9 | 0 | |
p02784 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int h, n;
cin >> h >> n;
int a[n];
for (int i = 0; i < n; i++)
cin >> n;
string ans = "No";
sort(a, a + n, std::greater<int>());
for (int i = 0; i < n; i++) {
h -= a[i];
if (h <= 0) {
ans = "Yes";
break;
}
}
cout << ans << endl;
} | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int h, n;
cin >> h >> n;
int a[n];
for (int i = 0; i < n; i++)
cin >> a[i];
string ans = "No";
sort(a, a + n, std::greater<int>());
for (int i = 0; i < n; i++) {
h -= a[i];
if (h <= 0) {
ans = "Yes";
break;
}
}
cout << ans << endl;
} | replace | 11 | 12 | 11 | 12 | 0 | |
p02784 | C++ | Runtime Error | #include <iostream>
using namespace std;
int main() {
int n, KO, ACE = 0;
cin >> n >> KO;
int a[KO + 1];
for (int i = 1; i <= n; i++) {
cin >> a[i];
ACE += a[i];
}
if (ACE >= n)
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
} | #include <iostream>
using namespace std;
int main() {
int n, KO, ACE = 0;
cin >> n >> KO;
int a[KO + 1];
for (int i = 1; i <= KO; i++) {
cin >> a[i];
ACE += a[i];
}
if (ACE >= n)
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
} | replace | 8 | 9 | 8 | 9 | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.