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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
p03038 | C++ | Time Limit Exceeded | #include <algorithm>
#include <iostream>
#include <set>
#define LIMIT 100000
using namespace std;
struct card {
long b;
long c;
};
bool cmp(const card left, const card right) { return left.c < right.c; }
int main() {
int n, m;
long tmp;
struct card input[LIMIT];
long b, c;
multiset<long> a;
int i, j;
cin >> n >> m;
for (i = 0; i < n; i++) {
cin >> tmp;
a.insert(tmp);
}
for (i = 0; i < m; i++) {
cin >> input[i].b >> input[i].c;
}
sort(input, input + m, cmp);
for (i = 0; i < m; i++) {
// cin >> b >> c;
b = input[i].b;
c = input[i].c;
multiset<long>::iterator k = a.begin();
for (j = 0; j < b; j++) {
if (*k >= c) {
break;
}
a.erase(k++);
a.insert(c);
}
}
/*
auto itr = a.begin();
for (i = 0; i < n; i++, itr++) {
cout << *itr << endl;
}
cout << endl;
*/
auto itr = a.begin();
long ans = 0;
for (i = 0; i < n; i++) {
ans += *itr;
itr++;
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <iostream>
#include <set>
#define LIMIT 100000
using namespace std;
struct card {
long b;
long c;
};
bool cmp(const card left, const card right) { return right.c < left.c; }
int main() {
int n, m;
long tmp;
struct card input[LIMIT];
long b, c;
multiset<long> a;
int i, j;
cin >> n >> m;
for (i = 0; i < n; i++) {
cin >> tmp;
a.insert(tmp);
}
for (i = 0; i < m; i++) {
cin >> input[i].b >> input[i].c;
}
sort(input, input + m, cmp);
for (i = 0; i < m; i++) {
// cin >> b >> c;
b = input[i].b;
c = input[i].c;
multiset<long>::iterator k = a.begin();
for (j = 0; j < b; j++) {
if (*k >= c) {
break;
}
a.erase(k++);
a.insert(c);
}
}
/*
auto itr = a.begin();
for (i = 0; i < n; i++, itr++) {
cout << *itr << endl;
}
cout << endl;
*/
auto itr = a.begin();
long ans = 0;
for (i = 0; i < n; i++) {
ans += *itr;
itr++;
}
cout << ans << endl;
return 0;
}
| replace | 11 | 12 | 11 | 12 | TLE | |
p03038 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MAXN = 1e5 + 5;
struct line {
int num, v;
} a[MAXN];
int cmp(line i, line j) { return i.v > j.v; }
int main() {
int m, n, i;
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) {
cin >> a[i].v;
a[i].num = 1;
}
for (i; i <= n + m; i++) {
cin >> a[i].num;
cin >> a[i].v;
}
sort(a + 1, a + n + m + 1, cmp);
ll s = 0;
int k = 0;
for (i = 1; i <= n + m + 1; i++) {
if (k + a[i].num <= n) {
k += a[i].num;
s += (ll)a[i].num * a[i].v;
} else {
s += (ll)(n - k) * a[i].v;
break;
}
}
cout << s << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MAXN = 1e5 + 5;
struct line {
int num, v;
} a[MAXN * 2];
int cmp(line i, line j) { return i.v > j.v; }
int main() {
int m, n, i;
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) {
cin >> a[i].v;
a[i].num = 1;
}
for (i; i <= n + m; i++) {
cin >> a[i].num;
cin >> a[i].v;
}
sort(a + 1, a + n + m + 1, cmp);
ll s = 0;
int k = 0;
for (i = 1; i <= n + m + 1; i++) {
if (k + a[i].num <= n) {
k += a[i].num;
s += (ll)a[i].num * a[i].v;
} else {
s += (ll)(n - k) * a[i].v;
break;
}
}
cout << s << endl;
return 0;
} | replace | 6 | 7 | 6 | 7 | 0 | |
p03038 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int N, M;
int long sum = 0;
int count = 0;
cin >> N >> M;
vector<long int> A(N);
vector<pair<long int, int>> BC(M);
vector<long int> D(0);
for (int i = 0; i < N; i++) {
cin >> A.at(i);
}
for (int i = 0; i < M; i++) {
cin >> BC.at(i).second >> BC.at(i).first;
}
sort(BC.begin(), BC.end());
reverse(BC.begin(), BC.end());
sort(A.begin(), A.end());
for (int j = 0; j < M; j++) {
for (int k = 0; k < BC.at(j).second; k++) {
count++;
D.push_back(BC.at(j).first);
if (count == N) {
break;
}
}
if (count == N) {
break;
}
}
// for (int i = 0; i < N; i++) {
// D.push_back(0);
//}
for (int i = 0; i < N; i++) {
sum += max(D.at(i), A.at(i));
}
cout << sum << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int N, M;
int long sum = 0;
int count = 0;
cin >> N >> M;
vector<long int> A(N);
vector<pair<long int, int>> BC(M);
vector<long int> D(0);
for (int i = 0; i < N; i++) {
cin >> A.at(i);
}
for (int i = 0; i < M; i++) {
cin >> BC.at(i).second >> BC.at(i).first;
}
sort(BC.begin(), BC.end());
reverse(BC.begin(), BC.end());
sort(A.begin(), A.end());
for (int j = 0; j < M; j++) {
for (int k = 0; k < BC.at(j).second; k++) {
count++;
D.push_back(BC.at(j).first);
if (count == N) {
break;
}
}
if (count == N) {
break;
}
}
for (int i = 0; i < N; i++) {
D.push_back(0);
}
for (int i = 0; i < N; i++) {
sum += max(D.at(i), A.at(i));
}
cout << sum << endl;
return 0;
} | replace | 37 | 40 | 37 | 40 | 0 | |
p03038 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 100;
int n, m, a[N], z;
pair<int, int> v[N];
long long int sum = 0;
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
v[i] = make_pair(y, x);
}
sort(v, v + m);
reverse(v, v + m);
for (int i = 0; i < m; i++) {
int c = 0;
while (a[z] < v[i].first && c < v[i].second) {
z++;
c++;
}
sum += 1LL * c * v[i].first;
}
for (int i = z; i < n; i++)
sum += a[i];
cout << sum;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 100;
int n, m, a[N], z;
pair<int, int> v[N];
long long int sum = 0;
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
v[i] = make_pair(y, x);
}
sort(v, v + m);
reverse(v, v + m);
for (int i = 0; i < m; i++) {
int c = 0;
while (a[z] < v[i].first && c < v[i].second && z < n) {
z++;
c++;
}
sum += 1LL * c * v[i].first;
}
for (int i = z; i < n; i++)
sum += a[i];
cout << sum;
return 0;
} | replace | 21 | 22 | 21 | 22 | 0 | |
p03038 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> lpair;
const ll MOD = 1e9 + 7;
const ll INF = 1e18;
#define rep(i, m, n) for (ll i = (m); i < (n); i++)
#define rrep(i, m, n) for (ll i = (m); i >= (n); i--)
#define print(x) cout << (x) << endl;
#define print2(x, y) cout << (x) << " " << (y) << endl;
#define printa(x, n) \
for (ll i = 0; i < n; i++) { \
cout << (x[i]) << " "; \
} \
cout << endl;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll N, M;
ll A[100010];
cin >> N >> M;
rep(i, 0, N) cin >> A[i];
ll B[100010], C[100010];
rep(i, 0, M) { cin >> B[i] >> C[i]; }
sort(A, A + N);
vector<lpair> lp;
rep(i, 0, N) { lp.push_back(make_pair(C[i], B[i])); }
sort(lp.begin(), lp.end(), greater<lpair>());
ll pos = 0;
rep(i, 0, M) {
ll b = lp[i].second;
ll c = lp[i].first;
ll cnt = 0;
while (cnt < b) {
if (pos >= N)
break;
if (A[pos] < c) {
A[pos] = c;
pos++;
} else {
break;
}
cnt++;
}
}
ll ans = 0;
rep(i, 0, N) ans += A[i];
print(ans);
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> lpair;
const ll MOD = 1e9 + 7;
const ll INF = 1e18;
#define rep(i, m, n) for (ll i = (m); i < (n); i++)
#define rrep(i, m, n) for (ll i = (m); i >= (n); i--)
#define print(x) cout << (x) << endl;
#define print2(x, y) cout << (x) << " " << (y) << endl;
#define printa(x, n) \
for (ll i = 0; i < n; i++) { \
cout << (x[i]) << " "; \
} \
cout << endl;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll N, M;
ll A[100010];
cin >> N >> M;
rep(i, 0, N) cin >> A[i];
ll B[100010], C[100010];
rep(i, 0, M) { cin >> B[i] >> C[i]; }
sort(A, A + N);
vector<lpair> lp;
rep(i, 0, M) { lp.push_back(make_pair(C[i], B[i])); }
sort(lp.begin(), lp.end(), greater<lpair>());
ll pos = 0;
rep(i, 0, M) {
ll b = lp[i].second;
ll c = lp[i].first;
ll cnt = 0;
while (cnt < b) {
if (pos >= N)
break;
if (A[pos] < c) {
A[pos] = c;
pos++;
} else {
break;
}
cnt++;
}
}
ll ans = 0;
rep(i, 0, N) ans += A[i];
print(ans);
} | replace | 26 | 27 | 26 | 27 | 0 | |
p03039 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <iostream>
#include <numeric>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
using ll = long long;
void _cin() {}
template <class Head, class... Tail> void _cin(Head &&head, Tail &&...tail) {
cin >> head;
_cin(forward<Tail>(tail)...);
}
void _cout() { cout << "\n"; }
template <class Head, class... Tail> void _cout(Head &&head, Tail &&...tail) {
cout << head;
_cout(forward<Tail>(tail)...);
}
int gcd(int a, int b) { return (b == 0) ? a : gcd(b, a % b); }
#define Sq(x) (x) * (x)
#define For(i, n) for (int i = 0; i < (n); i++)
#define Rep(n) For(_, n)
#define Range(c) c.begin(), c.end()
#define RevRange(c) c.rbegin(), c.rend()
#define Contains(c, x) (find(Range(c), x) != c.end())
#define Search(rb, re, x) distance(rb, find(rb, re, x))
#define Sort(a) sort(Range(a))
#define DeSort(a) sort(RevRange(a))
#define Reverse(c) reverse(Range(c))
#define Unique(a) a.erase(unique(Range(a)), a.end())
#define Vec2(T, n, m, xs) vector<vector<T>> xs(n, vector<T>(m))
#define Sum(a) accumulate(Range(a), 0)
#define Cusum(T, xs, sxs) \
vector<T> sxs(xs.size() + 1); \
For(i, (int)xs.size()) sxs[i + 1] = sxs[i] + xs[i]
#define Cin(T, ...) \
T __VA_ARGS__; \
_cin(__VA_ARGS__)
#define Cins(T, n, xs) \
vector<T> xs(n); \
For(i, n) cin >> xs[i]
#define Cins2(T, n, xs, ys) \
vector<T> xs(n), ys(n); \
For(i, n) cin >> xs[i] >> ys[i]
#define Cins3(T, n, xs, ys, zs) \
vector<T> xs(n), ys(n), zs(n); \
For(i, n) cin >> xs[i] >> ys[i] >> zs[i]
#define Cinss(T, n, m, xs) \
Vec2(T, n, m, xs); \
For(i, n) For(j, m) cin >> xs[i][j]
#define Cinm(T, n, map) \
unordered_map<T, int> map; \
Rep(n) { \
Cin(T, x); \
map[x]++; \
}
#define Cout(...) _cout(__VA_ARGS__)
#define Couts(xs) \
for (const auto &e : xs) \
cout << e << " "; \
cout << "\n"
#define Coutyn(cond) Cout((cond) ? "yes" : "no")
#define CoutYn(cond) Cout((cond) ? "Yes" : "No")
#define CoutYN(cond) Cout((cond) ? "YES" : "NO")
constexpr int MOD = 1e9 + 7;
constexpr int COMB_MAX = 110000;
ll fac[COMB_MAX], finv[COMB_MAX], inv[COMB_MAX];
void initComb() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < COMB_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 comb(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 sum(int n) { return (ll)n * (n + 1) / 2 % MOD; }
int main(void) {
Cin(int, h, w, k);
initComb();
ll ans = 0;
For(i, h) For(j, w) {
ans = (ans + (sum(i) + sum(h - i - 1)) % MOD * w % MOD) % MOD;
ans = (ans + (sum(j) + sum(w - j - 1)) % MOD * h % MOD) % MOD;
}
if (ans % 2 == 0)
ans /= 2;
else
ans = (ans + MOD) / 2;
Cout(comb(w * h - 2, k - 2) * ans % MOD);
}
| #include <algorithm>
#include <cmath>
#include <iostream>
#include <numeric>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
using ll = long long;
void _cin() {}
template <class Head, class... Tail> void _cin(Head &&head, Tail &&...tail) {
cin >> head;
_cin(forward<Tail>(tail)...);
}
void _cout() { cout << "\n"; }
template <class Head, class... Tail> void _cout(Head &&head, Tail &&...tail) {
cout << head;
_cout(forward<Tail>(tail)...);
}
int gcd(int a, int b) { return (b == 0) ? a : gcd(b, a % b); }
#define Sq(x) (x) * (x)
#define For(i, n) for (int i = 0; i < (n); i++)
#define Rep(n) For(_, n)
#define Range(c) c.begin(), c.end()
#define RevRange(c) c.rbegin(), c.rend()
#define Contains(c, x) (find(Range(c), x) != c.end())
#define Search(rb, re, x) distance(rb, find(rb, re, x))
#define Sort(a) sort(Range(a))
#define DeSort(a) sort(RevRange(a))
#define Reverse(c) reverse(Range(c))
#define Unique(a) a.erase(unique(Range(a)), a.end())
#define Vec2(T, n, m, xs) vector<vector<T>> xs(n, vector<T>(m))
#define Sum(a) accumulate(Range(a), 0)
#define Cusum(T, xs, sxs) \
vector<T> sxs(xs.size() + 1); \
For(i, (int)xs.size()) sxs[i + 1] = sxs[i] + xs[i]
#define Cin(T, ...) \
T __VA_ARGS__; \
_cin(__VA_ARGS__)
#define Cins(T, n, xs) \
vector<T> xs(n); \
For(i, n) cin >> xs[i]
#define Cins2(T, n, xs, ys) \
vector<T> xs(n), ys(n); \
For(i, n) cin >> xs[i] >> ys[i]
#define Cins3(T, n, xs, ys, zs) \
vector<T> xs(n), ys(n), zs(n); \
For(i, n) cin >> xs[i] >> ys[i] >> zs[i]
#define Cinss(T, n, m, xs) \
Vec2(T, n, m, xs); \
For(i, n) For(j, m) cin >> xs[i][j]
#define Cinm(T, n, map) \
unordered_map<T, int> map; \
Rep(n) { \
Cin(T, x); \
map[x]++; \
}
#define Cout(...) _cout(__VA_ARGS__)
#define Couts(xs) \
for (const auto &e : xs) \
cout << e << " "; \
cout << "\n"
#define Coutyn(cond) Cout((cond) ? "yes" : "no")
#define CoutYn(cond) Cout((cond) ? "Yes" : "No")
#define CoutYN(cond) Cout((cond) ? "YES" : "NO")
constexpr int MOD = 1e9 + 7;
constexpr int COMB_MAX = 200010;
ll fac[COMB_MAX], finv[COMB_MAX], inv[COMB_MAX];
void initComb() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < COMB_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 comb(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 sum(int n) { return (ll)n * (n + 1) / 2 % MOD; }
int main(void) {
Cin(int, h, w, k);
initComb();
ll ans = 0;
For(i, h) For(j, w) {
ans = (ans + (sum(i) + sum(h - i - 1)) % MOD * w % MOD) % MOD;
ans = (ans + (sum(j) + sum(w - j - 1)) % MOD * h % MOD) % MOD;
}
if (ans % 2 == 0)
ans /= 2;
else
ans = (ans + MOD) / 2;
Cout(comb(w * h - 2, k - 2) * ans % MOD);
}
| replace | 71 | 72 | 71 | 72 | 0 | |
p03039 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
constexpr int MOD = 1'000'000'007;
constexpr int MAX = 100'000;
template <int mod> struct ModInt {
int x;
ModInt() : x(0) {}
ModInt(long long y) : x(y >= 0 ? y % mod : (mod - (-y) % mod) % mod) {}
ModInt &operator+=(const ModInt &p) {
if ((x += p.x) >= mod)
x -= mod;
return *this;
}
ModInt &operator-=(const ModInt &p) {
if ((x += mod - p.x) >= mod)
x -= mod;
return *this;
}
ModInt &operator*=(const ModInt &p) {
x = (int)(1LL * x * p.x % mod);
return *this;
}
ModInt &operator/=(const ModInt &p) {
*this *= p.inverse();
return *this;
}
ModInt operator-() const { return ModInt(-x); }
ModInt operator+(const ModInt &p) const { return ModInt(*this) += p; }
ModInt operator-(const ModInt &p) const { return ModInt(*this) -= p; }
ModInt operator*(const ModInt &p) const { return ModInt(*this) *= p; }
ModInt operator/(const ModInt &p) const { return ModInt(*this) /= p; }
bool operator==(const ModInt &p) const { return x == p.x; }
bool operator!=(const ModInt &p) const { return x != p.x; }
ModInt inverse() const {
int a = x, b = mod, u = 1, v = 0, t;
while (b > 0) {
t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
return ModInt(u);
}
ModInt pow(int e) {
long long a = 1, p = x;
while (e > 0) {
if (e % 2 == 0) {
p = (p * p) % mod;
e /= 2;
} else {
a = (a * p) % mod;
e--;
}
}
return ModInt(a);
}
friend ostream &operator<<(ostream &os, const ModInt<mod> &p) {
return os << p.x;
}
friend istream &operator>>(istream &is, ModInt<mod> &a) {
long long x;
is >> x;
a = ModInt<mod>(x);
return (is);
}
};
template <int mod> struct Combination {
vector<ModInt<mod>> fact, ifact;
Combination(int n) : fact(n + 1), ifact(n + 1) {
fact[0] = 1;
for (int i = 1; i <= n; i++)
fact[i] = (fact[i - 1] * i);
ifact[n] = fact[n].inverse();
for (int i = n; i > 0; i--)
ifact[i - 1] = ifact[i] * i;
}
ModInt<mod> operator()(int n, int r) {
if (r < 0 or r > n)
return 0;
return fact[n] * ifact[n - r] * ifact[r];
}
const ModInt<mod> &operator[](int i) const { return fact[i]; }
};
int main() {
using mint = ModInt<MOD>;
Combination<MOD> com(MAX);
long long n, m, k;
cin >> n >> m >> k;
mint ans = 0;
for (int i = 0; i < 2; i++) {
for (int d = 1; d < n; d++) {
mint res = (n - d) * m * m;
res *= com(n * m - 2, k - 2);
res *= d;
ans += res;
}
swap(n, m);
}
cout << ans << '\n';
return 0;
} | #include <bits/stdc++.h>
using namespace std;
constexpr int MOD = 1'000'000'007;
constexpr int MAX = 200'200;
template <int mod> struct ModInt {
int x;
ModInt() : x(0) {}
ModInt(long long y) : x(y >= 0 ? y % mod : (mod - (-y) % mod) % mod) {}
ModInt &operator+=(const ModInt &p) {
if ((x += p.x) >= mod)
x -= mod;
return *this;
}
ModInt &operator-=(const ModInt &p) {
if ((x += mod - p.x) >= mod)
x -= mod;
return *this;
}
ModInt &operator*=(const ModInt &p) {
x = (int)(1LL * x * p.x % mod);
return *this;
}
ModInt &operator/=(const ModInt &p) {
*this *= p.inverse();
return *this;
}
ModInt operator-() const { return ModInt(-x); }
ModInt operator+(const ModInt &p) const { return ModInt(*this) += p; }
ModInt operator-(const ModInt &p) const { return ModInt(*this) -= p; }
ModInt operator*(const ModInt &p) const { return ModInt(*this) *= p; }
ModInt operator/(const ModInt &p) const { return ModInt(*this) /= p; }
bool operator==(const ModInt &p) const { return x == p.x; }
bool operator!=(const ModInt &p) const { return x != p.x; }
ModInt inverse() const {
int a = x, b = mod, u = 1, v = 0, t;
while (b > 0) {
t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
return ModInt(u);
}
ModInt pow(int e) {
long long a = 1, p = x;
while (e > 0) {
if (e % 2 == 0) {
p = (p * p) % mod;
e /= 2;
} else {
a = (a * p) % mod;
e--;
}
}
return ModInt(a);
}
friend ostream &operator<<(ostream &os, const ModInt<mod> &p) {
return os << p.x;
}
friend istream &operator>>(istream &is, ModInt<mod> &a) {
long long x;
is >> x;
a = ModInt<mod>(x);
return (is);
}
};
template <int mod> struct Combination {
vector<ModInt<mod>> fact, ifact;
Combination(int n) : fact(n + 1), ifact(n + 1) {
fact[0] = 1;
for (int i = 1; i <= n; i++)
fact[i] = (fact[i - 1] * i);
ifact[n] = fact[n].inverse();
for (int i = n; i > 0; i--)
ifact[i - 1] = ifact[i] * i;
}
ModInt<mod> operator()(int n, int r) {
if (r < 0 or r > n)
return 0;
return fact[n] * ifact[n - r] * ifact[r];
}
const ModInt<mod> &operator[](int i) const { return fact[i]; }
};
int main() {
using mint = ModInt<MOD>;
Combination<MOD> com(MAX);
long long n, m, k;
cin >> n >> m >> k;
mint ans = 0;
for (int i = 0; i < 2; i++) {
for (int d = 1; d < n; d++) {
mint res = (n - d) * m * m;
res *= com(n * m - 2, k - 2);
res *= d;
ans += res;
}
swap(n, m);
}
cout << ans << '\n';
return 0;
} | replace | 4 | 5 | 4 | 5 | 0 | |
p03039 | C++ | Runtime Error | //
// main.cpp
//
#include <algorithm>
#include <array>
#include <assert.h>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <math.h>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
using ll = int64_t;
using ull = uint64_t;
constexpr ll LL_MAX = numeric_limits<ll>::max();
constexpr ull ULL_MAX = numeric_limits<ull>::max();
template <typename T> vector<T> make_vec_nd(T init, ll size) {
return vector<T>(size, init);
}
template <typename T, typename... Args>
auto make_vec_nd(T init, ll size, Args... rest) {
auto inner = make_vec_nd(init, rest...);
return vector<decltype(inner)>(size, inner);
}
#define rep(i, a, b) for (ll i = (a); i < (b); i++)
#define rrep(i, a, b) for (ll i = (a)-1; i >= (b); i--)
struct Mod {
static uint64_t PRIME;
uint64_t value = 0;
Mod() : value(0) {}
Mod(ll v) {
if (v >= 0) {
value = v % PRIME;
} else {
value = PRIME - (-v) % PRIME;
}
}
Mod operator+(const Mod &rhs) const { return Mod(*this) += rhs; }
Mod &operator+=(const Mod &rhs) {
value += rhs.value;
if (value >= PRIME) {
value -= PRIME;
}
return *this;
}
Mod operator-(const Mod &rhs) const { return Mod(*this) -= rhs; }
Mod &operator-=(const Mod &rhs) {
if (value < rhs.value) {
value += PRIME;
}
value -= rhs.value;
return *this;
}
Mod operator*(const Mod &rhs) const { return Mod(*this) *= rhs; }
Mod &operator*=(const Mod &rhs) {
value = (value * rhs.value) % PRIME;
return *this;
}
Mod inv() const { return power(*this, PRIME - 2); }
Mod operator/(const Mod &rhs) const { return Mod(*this) /= rhs; }
Mod &operator/=(const Mod &rhs) {
*this *= rhs.inv();
return *this;
}
static Mod power(Mod rhs, ll exp) {
Mod ans = 1;
while (exp > 0) {
if (exp % 2) {
ans *= rhs;
}
rhs *= rhs;
exp /= 2;
}
return ans;
}
};
uint64_t Mod::PRIME = 1000000007;
vector<Mod> fact;
Mod binom(ll n, ll r) {
if (!(0 <= n && 0 <= r && r <= n)) {
return 0;
} else {
return fact[n] / fact[r] / fact[n - r];
}
}
int main() {
ll N, M, K;
cin >> N >> M >> K;
fact.resize(max(N * M - 2, max(N + 1, M + 1)) + 1, 1);
rep(n, 1, N * M + 1) { fact[n] = fact[n - 1] * n; }
Mod ans = 0;
rep(i, 0, 2) {
ans += Mod(M) * Mod(M) * binom(N + 1, 3) * binom(N * M - 2, K - 2);
swap(N, M);
}
cout << ans.value << endl;
}
| //
// main.cpp
//
#include <algorithm>
#include <array>
#include <assert.h>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <math.h>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
using ll = int64_t;
using ull = uint64_t;
constexpr ll LL_MAX = numeric_limits<ll>::max();
constexpr ull ULL_MAX = numeric_limits<ull>::max();
template <typename T> vector<T> make_vec_nd(T init, ll size) {
return vector<T>(size, init);
}
template <typename T, typename... Args>
auto make_vec_nd(T init, ll size, Args... rest) {
auto inner = make_vec_nd(init, rest...);
return vector<decltype(inner)>(size, inner);
}
#define rep(i, a, b) for (ll i = (a); i < (b); i++)
#define rrep(i, a, b) for (ll i = (a)-1; i >= (b); i--)
struct Mod {
static uint64_t PRIME;
uint64_t value = 0;
Mod() : value(0) {}
Mod(ll v) {
if (v >= 0) {
value = v % PRIME;
} else {
value = PRIME - (-v) % PRIME;
}
}
Mod operator+(const Mod &rhs) const { return Mod(*this) += rhs; }
Mod &operator+=(const Mod &rhs) {
value += rhs.value;
if (value >= PRIME) {
value -= PRIME;
}
return *this;
}
Mod operator-(const Mod &rhs) const { return Mod(*this) -= rhs; }
Mod &operator-=(const Mod &rhs) {
if (value < rhs.value) {
value += PRIME;
}
value -= rhs.value;
return *this;
}
Mod operator*(const Mod &rhs) const { return Mod(*this) *= rhs; }
Mod &operator*=(const Mod &rhs) {
value = (value * rhs.value) % PRIME;
return *this;
}
Mod inv() const { return power(*this, PRIME - 2); }
Mod operator/(const Mod &rhs) const { return Mod(*this) /= rhs; }
Mod &operator/=(const Mod &rhs) {
*this *= rhs.inv();
return *this;
}
static Mod power(Mod rhs, ll exp) {
Mod ans = 1;
while (exp > 0) {
if (exp % 2) {
ans *= rhs;
}
rhs *= rhs;
exp /= 2;
}
return ans;
}
};
uint64_t Mod::PRIME = 1000000007;
vector<Mod> fact;
Mod binom(ll n, ll r) {
if (!(0 <= n && 0 <= r && r <= n)) {
return 0;
} else {
return fact[n] / fact[r] / fact[n - r];
}
}
int main() {
ll N, M, K;
cin >> N >> M >> K;
fact.resize(max(N * M - 2, max(N + 1, M + 1)) + 1, 1);
rep(n, 1, fact.size()) { fact[n] = fact[n - 1] * n; }
Mod ans = 0;
rep(i, 0, 2) {
ans += Mod(M) * Mod(M) * binom(N + 1, 3) * binom(N * M - 2, K - 2);
swap(N, M);
}
cout << ans.value << endl;
}
| replace | 110 | 111 | 110 | 111 | 0 | |
p03039 | C++ | Runtime Error | #include <algorithm>
#include <array>
#include <cassert>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
constexpr ll infl = 1000000000000000007LL;
constexpr int inf = 1000000007;
/*
nCk, nPk, 階乗をmodをとりつつ求めるライブラリ
*/
template <int MAX_N = 100000, long long MOD = 1000000007LL> class Combination {
array<long long, MAX_N + 1> _fact;
array<long long, MAX_N + 1> _fact_inv;
public:
// xの逆元
// https://qiita.com/drken/items/3b4fdf0a78e7a138cd9a
long long inv(long long a) const {
long long b = MOD, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= MOD;
if (u < 0)
u += MOD;
return u;
}
// n!
long long fact(long long n) const { return _fact[n]; }
// 1 / n!
long long fact_inv(long long n) const { return _fact_inv[n]; }
// nPk
long long perm(long long n, long long k) const {
return fact(n) * fact_inv(n - k) % MOD;
}
// nCk
long long comb(long long n, long long k) const {
return perm(n, k) * fact_inv(k) % MOD;
}
Combination() : _fact{}, _fact_inv{} {
_fact[0] = _fact[1] = 1LL;
for (int i = 2; i <= MAX_N; ++i) {
_fact[i] = _fact[i - 1] * i % MOD;
}
_fact_inv[MAX_N] = inv(_fact[MAX_N]);
for (int i = MAX_N - 1; i >= 0; --i) {
_fact_inv[i] = _fact_inv[i + 1] * (i + 1) % MOD;
}
}
};
constexpr ll mod = inf;
Combination<> cm;
int main() {
ll n, m, k;
cin >> n >> m >> k;
ll ans = 0;
for (ll d = 1; d <= n - 1; ++d) {
ans += (n - d) * m * m * d;
ans %= mod;
}
for (ll d = 1; d <= m - 1; ++d) {
ans += (m - d) * n * n * d;
ans %= mod;
}
cout << ans * cm.comb(n * m - 2, k - 2) % mod << endl;
return 0;
} | #include <algorithm>
#include <array>
#include <cassert>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
constexpr ll infl = 1000000000000000007LL;
constexpr int inf = 1000000007;
/*
nCk, nPk, 階乗をmodをとりつつ求めるライブラリ
*/
template <int MAX_N = 100000, long long MOD = 1000000007LL> class Combination {
array<long long, MAX_N + 1> _fact;
array<long long, MAX_N + 1> _fact_inv;
public:
// xの逆元
// https://qiita.com/drken/items/3b4fdf0a78e7a138cd9a
long long inv(long long a) const {
long long b = MOD, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= MOD;
if (u < 0)
u += MOD;
return u;
}
// n!
long long fact(long long n) const { return _fact[n]; }
// 1 / n!
long long fact_inv(long long n) const { return _fact_inv[n]; }
// nPk
long long perm(long long n, long long k) const {
return fact(n) * fact_inv(n - k) % MOD;
}
// nCk
long long comb(long long n, long long k) const {
return perm(n, k) * fact_inv(k) % MOD;
}
Combination() : _fact{}, _fact_inv{} {
_fact[0] = _fact[1] = 1LL;
for (int i = 2; i <= MAX_N; ++i) {
_fact[i] = _fact[i - 1] * i % MOD;
}
_fact_inv[MAX_N] = inv(_fact[MAX_N]);
for (int i = MAX_N - 1; i >= 0; --i) {
_fact_inv[i] = _fact_inv[i + 1] * (i + 1) % MOD;
}
}
};
constexpr ll mod = inf;
Combination<200000> cm;
int main() {
ll n, m, k;
cin >> n >> m >> k;
ll ans = 0;
for (ll d = 1; d <= n - 1; ++d) {
ans += (n - d) * m * m * d;
ans %= mod;
}
for (ll d = 1; d <= m - 1; ++d) {
ans += (m - d) * n * n * d;
ans %= mod;
}
cout << ans * cm.comb(n * m - 2, k - 2) % mod << endl;
return 0;
} | replace | 71 | 72 | 71 | 72 | 0 | |
p03039 | C++ | Runtime Error | #include "bits/stdc++.h"
typedef long long ll;
#define int ll
#define fi first
#define se second
#define SORT(a) sort(a.begin(), a.end())
#define rep(i, n) for (int i = 0; i < (n); i++)
#define REP(i, n) for (int i = 0; i < (n); i++)
#define MP(a, b) make_pair(a, b)
#define pb(a) push_back(a)
#define INF LLONG_MAX / 2
#define all(x) (x).begin(), (x).end()
#define debug(x) cerr << #x << ": " << x << endl
#define debug_vec(v) \
cerr << #v << ":"; \
rep(i, v.size()) cerr << " " << v[i]; \
cerr << endl
using namespace std;
int MOD = 1000000007;
ll bitpow(ll x, ll n) {
ll ans = 1;
while (n > 0) {
if (n % 2 == 1)
ans = ans * x % MOD;
x = x * x % MOD;
n = n >> 1;
}
return ans;
}
#define N 100001
int fac[N + 1];
int inv[N + 1];
ll COM(ll n, ll k) { return fac[n] * inv[k] % MOD * inv[n - k] % MOD; }
signed main() {
int n, m, k;
cin >> n >> m >> k;
fac[0] = 1;
inv[0] = 1;
for (int i = 1; i <= N; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = bitpow(fac[i], MOD - 2) % MOD;
}
int ans = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
ans += (n - i + 1) * (m - j + 1) * (i + j - 2) % MOD;
ans %= MOD;
if (i != 1 && j != 1) {
ans += (n - i + 1) * (m - j + 1) * (i + j - 2) % MOD;
ans %= MOD;
}
}
}
ans *= COM(n * m - 2, k - 2);
cout << ans % MOD << endl;
return 0;
}
// g++ -std=c++14 code1.cpp
// rm -r -f test;oj dl
// https://cf17-final-open.contest.atcoder.jp/tasks/cf17_final_a rm -r -f
// test;oj dl http://abc127.contest.atcoder.jp/tasks/abc127_a | #include "bits/stdc++.h"
typedef long long ll;
#define int ll
#define fi first
#define se second
#define SORT(a) sort(a.begin(), a.end())
#define rep(i, n) for (int i = 0; i < (n); i++)
#define REP(i, n) for (int i = 0; i < (n); i++)
#define MP(a, b) make_pair(a, b)
#define pb(a) push_back(a)
#define INF LLONG_MAX / 2
#define all(x) (x).begin(), (x).end()
#define debug(x) cerr << #x << ": " << x << endl
#define debug_vec(v) \
cerr << #v << ":"; \
rep(i, v.size()) cerr << " " << v[i]; \
cerr << endl
using namespace std;
int MOD = 1000000007;
ll bitpow(ll x, ll n) {
ll ans = 1;
while (n > 0) {
if (n % 2 == 1)
ans = ans * x % MOD;
x = x * x % MOD;
n = n >> 1;
}
return ans;
}
#define N 200001
int fac[N + 1];
int inv[N + 1];
ll COM(ll n, ll k) { return fac[n] * inv[k] % MOD * inv[n - k] % MOD; }
signed main() {
int n, m, k;
cin >> n >> m >> k;
fac[0] = 1;
inv[0] = 1;
for (int i = 1; i <= N; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = bitpow(fac[i], MOD - 2) % MOD;
}
int ans = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
ans += (n - i + 1) * (m - j + 1) * (i + j - 2) % MOD;
ans %= MOD;
if (i != 1 && j != 1) {
ans += (n - i + 1) * (m - j + 1) * (i + j - 2) % MOD;
ans %= MOD;
}
}
}
ans *= COM(n * m - 2, k - 2);
cout << ans % MOD << endl;
return 0;
}
// g++ -std=c++14 code1.cpp
// rm -r -f test;oj dl
// https://cf17-final-open.contest.atcoder.jp/tasks/cf17_final_a rm -r -f
// test;oj dl http://abc127.contest.atcoder.jp/tasks/abc127_a | replace | 30 | 31 | 30 | 31 | 0 | |
p03039 | C++ | Runtime Error | #include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <vector>
using namespace std;
using lint = long long;
constexpr int MOD = 1000000007, INF = 1010101010;
constexpr lint LINF = 1LL << 60;
template <class T> ostream &operator<<(ostream &os, const vector<T> &vec) {
for (const auto &e : vec)
os << e << (&e == &vec.back() ? "\n" : " ");
return os;
}
#ifdef _DEBUG
template <class T> void dump(const char *str, T &&h) {
cerr << str << " = " << h << "\n";
};
template <class Head, class... Tail>
void dump(const char *str, Head &&h, Tail &&...t) {
while (*str != ',')
cerr << *str++;
cerr << " = " << h << "\n";
dump(str + (*(str + 1) == ' ' ? 2 : 1), t...);
}
#define DMP(...) dump(#__VA_ARGS__, __VA_ARGS__)
#else
#define DMP(...) ((void)0)
#endif
template <int Modulo = MOD> struct Mint {
lint val;
constexpr Mint(lint v = 0) noexcept : val(v % Modulo) {
if (val < 0)
val += Modulo;
}
constexpr Mint &operator+=(const Mint &r) noexcept {
val += r.val;
if (val >= Modulo)
val -= Modulo;
return *this;
}
constexpr Mint &operator-=(const Mint &r) noexcept {
val -= r.val;
if (val < 0)
val += Modulo;
return *this;
}
constexpr Mint &operator*=(const Mint &r) noexcept {
val = val * r.val % Modulo;
return *this;
}
constexpr Mint &operator/=(const Mint &r) noexcept {
lint a = r.val, b = Modulo, u = 1, v = 0;
while (b) {
lint t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
val = val * u % Modulo;
if (val < 0)
val += Modulo;
return *this;
}
constexpr Mint operator+(const Mint &r) const noexcept {
return Mint(*this) += r;
}
constexpr Mint operator-(const Mint &r) const noexcept {
return Mint(*this) -= r;
}
constexpr Mint operator*(const Mint &r) const noexcept {
return Mint(*this) *= r;
}
constexpr Mint operator/(const Mint &r) const noexcept {
return Mint(*this) /= r;
}
constexpr int getmod() { return Modulo; }
constexpr Mint operator-() const noexcept { return val ? Modulo - val : 0; }
constexpr bool operator==(const Mint &r) const noexcept {
return val == r.val;
}
constexpr bool operator!=(const Mint &r) const noexcept {
return val != r.val;
}
friend ostream &operator<<(ostream &os, const Mint<Modulo> &x) noexcept {
return os << x.val;
}
friend istream &operator>>(istream &is, Mint<Modulo> &x) noexcept {
lint tmp;
is >> tmp;
x = Mint<Modulo>(tmp);
return is;
}
friend constexpr Mint<Modulo> modpow(const Mint<Modulo> &a, lint n) noexcept {
Mint res(1), tmp = a;
while (n > 0) {
if (n & 1)
res *= tmp;
tmp *= tmp;
n >>= 1;
}
return res;
}
};
using mint = Mint<>;
class Factorial {
private:
vector<mint> fac, inv, finv;
void build(int N) {
fac[0] = fac[1] = 1;
inv[1] = 1;
finv[0] = finv[1] = 1;
for (int i = 2; i < N; i++) {
fac[i] = fac[i - 1] * i;
inv[i] = -inv[MOD % i] * (MOD / i);
finv[i] = finv[i - 1] * inv[i];
}
}
public:
Factorial(int N = 110000) : fac(N + 1), inv(N + 1), finv(N + 1) {
build(N + 1);
}
mint operator()(int n, int k) {
if (n < k || k < 0)
return 0LL;
return fac[n] * (finv[k] * finv[n - k]);
}
mint Pmod(int n, int k) {
if (n < k || k < 0)
return 0LL;
return fac[n] * finv[n - k];
}
};
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int N, M, K;
cin >> N >> M >> K;
mint ans = 0;
ans += mint(1) * M * M * (N - 1) * N * (N + 1) / 6;
ans += mint(1) * N * N * (M - 1) * M * (M + 1) / 6;
ans *= Factorial()(N * M - 2, K - 2);
cout << ans << "\n";
return 0;
} | #include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <vector>
using namespace std;
using lint = long long;
constexpr int MOD = 1000000007, INF = 1010101010;
constexpr lint LINF = 1LL << 60;
template <class T> ostream &operator<<(ostream &os, const vector<T> &vec) {
for (const auto &e : vec)
os << e << (&e == &vec.back() ? "\n" : " ");
return os;
}
#ifdef _DEBUG
template <class T> void dump(const char *str, T &&h) {
cerr << str << " = " << h << "\n";
};
template <class Head, class... Tail>
void dump(const char *str, Head &&h, Tail &&...t) {
while (*str != ',')
cerr << *str++;
cerr << " = " << h << "\n";
dump(str + (*(str + 1) == ' ' ? 2 : 1), t...);
}
#define DMP(...) dump(#__VA_ARGS__, __VA_ARGS__)
#else
#define DMP(...) ((void)0)
#endif
template <int Modulo = MOD> struct Mint {
lint val;
constexpr Mint(lint v = 0) noexcept : val(v % Modulo) {
if (val < 0)
val += Modulo;
}
constexpr Mint &operator+=(const Mint &r) noexcept {
val += r.val;
if (val >= Modulo)
val -= Modulo;
return *this;
}
constexpr Mint &operator-=(const Mint &r) noexcept {
val -= r.val;
if (val < 0)
val += Modulo;
return *this;
}
constexpr Mint &operator*=(const Mint &r) noexcept {
val = val * r.val % Modulo;
return *this;
}
constexpr Mint &operator/=(const Mint &r) noexcept {
lint a = r.val, b = Modulo, u = 1, v = 0;
while (b) {
lint t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
val = val * u % Modulo;
if (val < 0)
val += Modulo;
return *this;
}
constexpr Mint operator+(const Mint &r) const noexcept {
return Mint(*this) += r;
}
constexpr Mint operator-(const Mint &r) const noexcept {
return Mint(*this) -= r;
}
constexpr Mint operator*(const Mint &r) const noexcept {
return Mint(*this) *= r;
}
constexpr Mint operator/(const Mint &r) const noexcept {
return Mint(*this) /= r;
}
constexpr int getmod() { return Modulo; }
constexpr Mint operator-() const noexcept { return val ? Modulo - val : 0; }
constexpr bool operator==(const Mint &r) const noexcept {
return val == r.val;
}
constexpr bool operator!=(const Mint &r) const noexcept {
return val != r.val;
}
friend ostream &operator<<(ostream &os, const Mint<Modulo> &x) noexcept {
return os << x.val;
}
friend istream &operator>>(istream &is, Mint<Modulo> &x) noexcept {
lint tmp;
is >> tmp;
x = Mint<Modulo>(tmp);
return is;
}
friend constexpr Mint<Modulo> modpow(const Mint<Modulo> &a, lint n) noexcept {
Mint res(1), tmp = a;
while (n > 0) {
if (n & 1)
res *= tmp;
tmp *= tmp;
n >>= 1;
}
return res;
}
};
using mint = Mint<>;
class Factorial {
private:
vector<mint> fac, inv, finv;
void build(int N) {
fac[0] = fac[1] = 1;
inv[1] = 1;
finv[0] = finv[1] = 1;
for (int i = 2; i < N; i++) {
fac[i] = fac[i - 1] * i;
inv[i] = -inv[MOD % i] * (MOD / i);
finv[i] = finv[i - 1] * inv[i];
}
}
public:
Factorial(int N = 110000) : fac(N + 1), inv(N + 1), finv(N + 1) {
build(N + 1);
}
mint operator()(int n, int k) {
if (n < k || k < 0)
return 0LL;
return fac[n] * (finv[k] * finv[n - k]);
}
mint Pmod(int n, int k) {
if (n < k || k < 0)
return 0LL;
return fac[n] * finv[n - k];
}
};
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int N, M, K;
cin >> N >> M >> K;
mint ans = 0;
ans += mint(1) * M * M * (N - 1) * N * (N + 1) / 6;
ans += mint(1) * N * N * (M - 1) * M * (M + 1) / 6;
ans *= Factorial(N * M)(N * M - 2, K - 2);
cout << ans << "\n";
return 0;
} | replace | 171 | 172 | 171 | 172 | 0 | |
p03039 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define pb push_back
#define IOS \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0)
#define ll long long int
#define ld long double
#define el '\n'
#define PI (ld)3.141592653589793238462643383279502884197169399375105820974944
#define inf (ll)1000000000
#define mod (ll)1000000007
#define mod1 (ll)998244353
#define fo(i, n) for (long long i = 0; i < int(n); i++)
#define pll pair<ll, ll>
#define ml map<ll, ll>
#define vli vector<pair<ll, int>>
#define vpl vector<pll>
#define vvl vector<vector<ll>>
#define vvpl vector<vector<pll>>
#define ff first
#define ss second
#define pqueue priority_queue<ll>
#define pdqueue priority_queue<ll, vl, greater<ll>>
#define mem(a, b) memset(a, b, sizeof(a));
// mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
#define sz(a) (ll) a.size()
#define f(i, a, b) for (ll i = a; i < b; i++)
#define fd(i, a, b) for (ll i = a; i >= b; i--)
#define all(a) a.begin(), a.end()
#define vl vector<ll>
// #define x ff
// #define y ss
#define pt(a) \
for (auto it : a) \
cout << it << " "; \
cout << endl;
unsigned seed = std::chrono::system_clock::now().time_since_epoch().count();
using namespace std;
double gcd(double a, double b) { return a < 0.01 ? b : gcd(fmod(b, a), a); }
vector<ll> parent, rak;
void make_set(int f) {
fo(i, f + 1) parent.pb(i);
rak.assign(f + 1, 1);
}
ll find_set(ll v) {
if (v == parent[v])
return v;
return parent[v] = find_set(parent[v]);
}
ll union_sets(ll a, ll b) {
a = find_set(a);
b = find_set(b);
if (a != b) {
if (rak[a] < rak[b])
swap(a, b);
parent[b] = a;
rak[a] += rak[b];
return (rak[a] - rak[b]) * (rak[b]);
}
return 0;
}
long long bpow(long long a, long long b, long long m) {
a %= m;
long long res = 1;
while (b > 0) {
if (b & 1)
res = res * a % m;
a = a * a % m;
b >>= 1;
}
return res;
}
ll extend_gcd(ll a, ll b, ll &x, ll &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
ll x1, y1;
ll ans = extend_gcd(b, a % b, x1, y1);
x = y1;
y = x1 - (a / b) * y1;
return ans;
}
ll inverse(ll a, ll m) {
ll x, y;
extend_gcd(m, a, x, y);
y %= m;
y += m;
y %= m;
return y;
}
unsigned long long fhash(vector<ll> p, ll len) {
unsigned long long h = 0xcbf29ce484222325ULL; // cout<<0x100000001b3ULL<<endl;
for (ll i = 0; i < len; i++)
h = (h ^ p[i]) * 0x100000001b3ULL; // cout<<h<<endl;
return h;
}
/*const int N = 1000001;
int lp[N+1];
vector<int> pr;
void s(){
for (int i=2; i<=N; ++i) {
if (lp[i] == 0) {
lp[i] = i;
pr.push_back (i);
}
for (int j=0; j<(int)pr.size() && pr[j]<=lp[i] && i*pr[j]<=N; ++j)
lp[i * pr[j]] = pr[j];
}
}*/
ll kv;
ll t, n, x, y, h, k, z, p, q, w;
string s, s1, s2;
// vvl v;
// vl vis,d;
int main() {
IOS;
cin >> n >> k >> h;
ll a[n + 1][k + 1];
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= k; j++) {
a[i][j] = (n + 1 - i) * (k + 1 - j);
}
}
vl v(n + k, 0);
for (int i = 1; i <= n + k - 2; i++) {
x = i + 2;
for (int j = 1; j < x; j++) {
if (j > n || x - j > k)
continue;
kv += a[j][x - j] * (2 - (j == 1 || j == x - 1)) % mod * i % mod;
kv %= mod;
}
}
p = n * k - 2;
h -= 2;
ll f[1000005];
f[0] = 1;
fo(i, 1000000) f[i + 1] = f[i] * (i + 1) % mod;
// cout<<kv<<endl;
kv =
kv * f[p] % mod * inverse(f[p - h], mod) % mod * inverse(f[h], mod) % mod;
cout << kv;
return 0;
}
| #include <bits/stdc++.h>
#define pb push_back
#define IOS \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0)
#define ll long long int
#define ld long double
#define el '\n'
#define PI (ld)3.141592653589793238462643383279502884197169399375105820974944
#define inf (ll)1000000000
#define mod (ll)1000000007
#define mod1 (ll)998244353
#define fo(i, n) for (long long i = 0; i < int(n); i++)
#define pll pair<ll, ll>
#define ml map<ll, ll>
#define vli vector<pair<ll, int>>
#define vpl vector<pll>
#define vvl vector<vector<ll>>
#define vvpl vector<vector<pll>>
#define ff first
#define ss second
#define pqueue priority_queue<ll>
#define pdqueue priority_queue<ll, vl, greater<ll>>
#define mem(a, b) memset(a, b, sizeof(a));
// mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
#define sz(a) (ll) a.size()
#define f(i, a, b) for (ll i = a; i < b; i++)
#define fd(i, a, b) for (ll i = a; i >= b; i--)
#define all(a) a.begin(), a.end()
#define vl vector<ll>
// #define x ff
// #define y ss
#define pt(a) \
for (auto it : a) \
cout << it << " "; \
cout << endl;
unsigned seed = std::chrono::system_clock::now().time_since_epoch().count();
using namespace std;
double gcd(double a, double b) { return a < 0.01 ? b : gcd(fmod(b, a), a); }
vector<ll> parent, rak;
void make_set(int f) {
fo(i, f + 1) parent.pb(i);
rak.assign(f + 1, 1);
}
ll find_set(ll v) {
if (v == parent[v])
return v;
return parent[v] = find_set(parent[v]);
}
ll union_sets(ll a, ll b) {
a = find_set(a);
b = find_set(b);
if (a != b) {
if (rak[a] < rak[b])
swap(a, b);
parent[b] = a;
rak[a] += rak[b];
return (rak[a] - rak[b]) * (rak[b]);
}
return 0;
}
long long bpow(long long a, long long b, long long m) {
a %= m;
long long res = 1;
while (b > 0) {
if (b & 1)
res = res * a % m;
a = a * a % m;
b >>= 1;
}
return res;
}
ll extend_gcd(ll a, ll b, ll &x, ll &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
ll x1, y1;
ll ans = extend_gcd(b, a % b, x1, y1);
x = y1;
y = x1 - (a / b) * y1;
return ans;
}
ll inverse(ll a, ll m) {
ll x, y;
extend_gcd(m, a, x, y);
y %= m;
y += m;
y %= m;
return y;
}
unsigned long long fhash(vector<ll> p, ll len) {
unsigned long long h = 0xcbf29ce484222325ULL; // cout<<0x100000001b3ULL<<endl;
for (ll i = 0; i < len; i++)
h = (h ^ p[i]) * 0x100000001b3ULL; // cout<<h<<endl;
return h;
}
/*const int N = 1000001;
int lp[N+1];
vector<int> pr;
void s(){
for (int i=2; i<=N; ++i) {
if (lp[i] == 0) {
lp[i] = i;
pr.push_back (i);
}
for (int j=0; j<(int)pr.size() && pr[j]<=lp[i] && i*pr[j]<=N; ++j)
lp[i * pr[j]] = pr[j];
}
}*/
ll kv;
ll t, n, x, y, h, k, z, p, q, w;
string s, s1, s2;
// vvl v;
// vl vis,d;
int main() {
IOS;
cin >> n >> k >> h;
ll a[n + 1][k + 1];
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= k; j++) {
a[i][j] = (n + 1 - i) * (k + 1 - j);
}
}
vl v(n + k, 0);
for (int i = 1; i <= n + k - 2; i++) {
x = i + 2;
int j = 1;
if (x > k + 1)
j = x - k;
for (; j < min(n + 1, x); j++) {
if (j > n || x - j > k)
continue;
kv += a[j][x - j] * (2 - (j == 1 || j == x - 1)) % mod * i % mod;
kv %= mod;
}
}
p = n * k - 2;
h -= 2;
ll f[1000005];
f[0] = 1;
fo(i, 1000000) f[i + 1] = f[i] * (i + 1) % mod;
// cout<<kv<<endl;
kv =
kv * f[p] % mod * inverse(f[p - h], mod) % mod * inverse(f[h], mod) % mod;
cout << kv;
return 0;
}
| replace | 141 | 142 | 141 | 145 | TLE | |
p03039 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7, maxn = 1e5 + 9;
int64_t gt[maxn + 1], n, m, k;
int64_t Pow(int x, int y) {
if (y == 0)
return 1;
else {
int64_t tmp = Pow(x, y / 2);
int64_t res = (tmp % MOD * tmp % MOD) % MOD;
if (y % 2 == 0)
return res;
else
return (res * x % MOD) % MOD;
}
}
int64_t Comb(int n, int k) {
int64_t a = gt[n];
int64_t b = (gt[k] % MOD * gt[n - k] % MOD) % MOD;
int64_t c =
(a * Pow(b, MOD - 2)) % MOD; /// (a / b) % MOD = a * inverse(b) % MOD
return c;
}
void Enter() { cin >> n >> m >> k; }
void Init() {
gt[0] = 1;
for (int i = 1; i <= maxn; i++)
gt[i] = (gt[i - 1] % MOD * i % MOD) % MOD;
}
int64_t SumX() {
int64_t s = 0;
for (int i = 1; i <= m; i++) {
int64_t l = i - 1, r = m - i;
s = (s + l * i - r * i) % MOD;
}
s = (s % MOD * Pow(n, 2)) % MOD;
return s;
}
int64_t SumY() {
int64_t s = 0;
for (int i = 1; i <= n; i++) {
int64_t l = i - 1, r = n - i;
s = (s + l * i - r * i) % MOD;
}
s = (s % MOD * Pow(m, 2)) % MOD;
return s;
}
void Solve() {
cout << ((SumX() + SumY()) % MOD * Comb(m * n - 2, k - 2)) % MOD;
}
int main() {
Enter();
Init();
Solve();
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7, maxn = 2e5 + 9;
int64_t gt[maxn + 1], n, m, k;
int64_t Pow(int x, int y) {
if (y == 0)
return 1;
else {
int64_t tmp = Pow(x, y / 2);
int64_t res = (tmp % MOD * tmp % MOD) % MOD;
if (y % 2 == 0)
return res;
else
return (res * x % MOD) % MOD;
}
}
int64_t Comb(int n, int k) {
int64_t a = gt[n];
int64_t b = (gt[k] % MOD * gt[n - k] % MOD) % MOD;
int64_t c =
(a * Pow(b, MOD - 2)) % MOD; /// (a / b) % MOD = a * inverse(b) % MOD
return c;
}
void Enter() { cin >> n >> m >> k; }
void Init() {
gt[0] = 1;
for (int i = 1; i <= maxn; i++)
gt[i] = (gt[i - 1] % MOD * i % MOD) % MOD;
}
int64_t SumX() {
int64_t s = 0;
for (int i = 1; i <= m; i++) {
int64_t l = i - 1, r = m - i;
s = (s + l * i - r * i) % MOD;
}
s = (s % MOD * Pow(n, 2)) % MOD;
return s;
}
int64_t SumY() {
int64_t s = 0;
for (int i = 1; i <= n; i++) {
int64_t l = i - 1, r = n - i;
s = (s + l * i - r * i) % MOD;
}
s = (s % MOD * Pow(m, 2)) % MOD;
return s;
}
void Solve() {
cout << ((SumX() + SumY()) % MOD * Comb(m * n - 2, k - 2)) % MOD;
}
int main() {
Enter();
Init();
Solve();
return 0;
}
| replace | 4 | 5 | 4 | 5 | 0 | |
p03039 | C++ | Runtime Error | #include <bits/stdc++.h>
#define syosu(x) fixed << setprecision(x)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> P;
typedef pair<double, double> pdd;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<double> vd;
typedef vector<vd> vvd;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<string> vs;
typedef vector<P> vp;
typedef vector<vp> vvp;
typedef vector<pll> vpll;
typedef pair<int, P> pip;
typedef vector<pip> vip;
const int inf = 1 << 30;
const ll INF = 1ll << 60;
const double pi = acos(-1);
const double eps = 1e-8;
const ll mod = 1e9 + 7;
const int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, -1, 0, 1};
ll Pow(ll n, ll p) {
ll r = 1;
for (; p > 0; p >>= 1) {
if (p & 1)
r = (r * n) % mod;
n = (n * n) % mod;
}
return r;
}
const int M = 200005;
ll F[M];
void Init() {
F[0] = 1;
for (int i = 1; i < M; i++)
F[i] = F[i - 1] * i % mod;
}
ll Div(ll n, ll m) { return n * Pow(m, mod - 2) % mod; }
ll nCk(ll n, ll k) { return Div(F[n], F[n - k] * F[k] % mod); }
ll n, m, k;
int main() {
Init();
cin >> n >> m >> k;
assert(n == 1 || m == 1);
if (n == 1)
swap(n, m);
// cout<<Div(nCk(n*m,k)*k%mod*(k-1)%mod*((n-1)*(n+1)*m+(m-1)*(m+1)*n)%mod,6*(n*m-1))<<endl;
cout << Div(nCk(n, k) * k % mod * (k - 1) % mod * (n + 1) % mod, 6) << endl;
} | #include <bits/stdc++.h>
#define syosu(x) fixed << setprecision(x)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> P;
typedef pair<double, double> pdd;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<double> vd;
typedef vector<vd> vvd;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<string> vs;
typedef vector<P> vp;
typedef vector<vp> vvp;
typedef vector<pll> vpll;
typedef pair<int, P> pip;
typedef vector<pip> vip;
const int inf = 1 << 30;
const ll INF = 1ll << 60;
const double pi = acos(-1);
const double eps = 1e-8;
const ll mod = 1e9 + 7;
const int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, -1, 0, 1};
ll Pow(ll n, ll p) {
ll r = 1;
for (; p > 0; p >>= 1) {
if (p & 1)
r = (r * n) % mod;
n = (n * n) % mod;
}
return r;
}
const int M = 200005;
ll F[M];
void Init() {
F[0] = 1;
for (int i = 1; i < M; i++)
F[i] = F[i - 1] * i % mod;
}
ll Div(ll n, ll m) { return n * Pow(m, mod - 2) % mod; }
ll nCk(ll n, ll k) { return Div(F[n], F[n - k] * F[k] % mod); }
ll n, m, k;
int main() {
Init();
cin >> n >> m >> k;
cout << Div(((n - 1) * (n + 1) * m + (m - 1) * (m + 1) * n) % mod *
nCk(n * m, k) % mod * k % mod * (k - 1) % mod,
6 * (n * m - 1))
<< endl;
} | replace | 55 | 60 | 55 | 59 | -6 | cf155a8c-2a97-4e05-a7b0-15f525cee305.out: /home/alex/Documents/bug-detection/input/Project_CodeNet/data/p03039/C++/s395541686.cpp:58: int main(): Assertion `n==1||m==1' failed.
|
p03039 | C++ | Runtime Error |
#include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <vector>
using namespace std;
const long long mod = 1e9 + 7;
const long long MAX_P = 1e5;
typedef long long ll;
long long qp(int a, ll b) {
int ans = 1;
do {
if (b & 1)
ans = 1ll * ans * a;
a = 1ll * a * a;
} while (b >>= 1);
return ans;
}
long long qp(int a, ll b, int mo) {
int ans = 1;
do {
if (b & 1)
ans = 1ll * ans * a % mo;
a = 1ll * a * a % mo;
} while (b >>= 1);
return ans;
}
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
long long INF = 1e10;
class combination {
public:
ll fact[MAX_P]; // n! mod pのテーブル(O(p))
ll p;
// factテーブルを初期化する
combination(ll x) { // x : 余り(1e9 + 7など)
p = x;
fact[0] = 1;
for (ll i = 1; i < MAX_P; i++) {
fact[i] = fact[i - 1] * i % p;
}
}
// 拡張ユークリッドの互除法
ll extgcd(ll a, ll b, ll &x, ll &y) {
ll d = a;
if (b != 0) {
d = extgcd(b, a % b, y, x);
y -= (a / b) * x;
} else {
x = 1;
y = 0;
}
return d;
}
// mod上の逆元
ll mod_inverse(ll a, ll m) {
ll x, y;
extgcd(a, m, x, y); // extgcdが必要
return (m + x % m) % m;
}
// n! = a p^eとしたときの a mod pを求める O(log_p a)
ll mod_fact(ll n, ll p, ll &e) {
e = 0;
if (n == 0)
return 1;
// pの倍数の部分を計算
ll res = mod_fact(n / p, p, e);
e += n / p;
//(p - 1)!≡-1なので、(p-1)!^(n/p)はn/pの偶奇だけで計算できる
if (n / p % 2 != 0)
return res * (p - fact[n % p]) % p;
return res * fact[n % p] % p;
}
// mod p 上の二項係数
ll mod_comb(ll n, ll k) {
if (n < 0 || k < 0 || n < k)
return 0;
ll e1, e2, e3;
ll a1 = mod_fact(n, p, e1), a2 = mod_fact(k, p, e2),
a3 = mod_fact(n - k, p, e3);
if (e1 > e2 + e3)
return 0;
return a1 * mod_inverse(a2 * a3 % p, p) % p;
}
};
int main() {
ll n, m, k;
cin >> n >> m >> k;
combination c(mod);
ll lyn, rn;
lyn = 0;
rn = 0;
for (int i = 1; i < n; i++) {
lyn += qp(m, 2, mod) * (n - i) * i;
lyn %= mod;
}
for (int i = 1; i < m; i++) {
rn += qp(n, 2, mod) * (m - i) * i;
rn %= mod;
}
cout << c.mod_comb(n * m - 2, k - 2) * (lyn + rn) % mod << endl;
return 0;
} |
#include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <vector>
using namespace std;
const long long mod = 1e9 + 7;
const long long MAX_P = 200010;
typedef long long ll;
long long qp(int a, ll b) {
int ans = 1;
do {
if (b & 1)
ans = 1ll * ans * a;
a = 1ll * a * a;
} while (b >>= 1);
return ans;
}
long long qp(int a, ll b, int mo) {
int ans = 1;
do {
if (b & 1)
ans = 1ll * ans * a % mo;
a = 1ll * a * a % mo;
} while (b >>= 1);
return ans;
}
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
long long INF = 1e10;
class combination {
public:
ll fact[MAX_P]; // n! mod pのテーブル(O(p))
ll p;
// factテーブルを初期化する
combination(ll x) { // x : 余り(1e9 + 7など)
p = x;
fact[0] = 1;
for (ll i = 1; i < MAX_P; i++) {
fact[i] = fact[i - 1] * i % p;
}
}
// 拡張ユークリッドの互除法
ll extgcd(ll a, ll b, ll &x, ll &y) {
ll d = a;
if (b != 0) {
d = extgcd(b, a % b, y, x);
y -= (a / b) * x;
} else {
x = 1;
y = 0;
}
return d;
}
// mod上の逆元
ll mod_inverse(ll a, ll m) {
ll x, y;
extgcd(a, m, x, y); // extgcdが必要
return (m + x % m) % m;
}
// n! = a p^eとしたときの a mod pを求める O(log_p a)
ll mod_fact(ll n, ll p, ll &e) {
e = 0;
if (n == 0)
return 1;
// pの倍数の部分を計算
ll res = mod_fact(n / p, p, e);
e += n / p;
//(p - 1)!≡-1なので、(p-1)!^(n/p)はn/pの偶奇だけで計算できる
if (n / p % 2 != 0)
return res * (p - fact[n % p]) % p;
return res * fact[n % p] % p;
}
// mod p 上の二項係数
ll mod_comb(ll n, ll k) {
if (n < 0 || k < 0 || n < k)
return 0;
ll e1, e2, e3;
ll a1 = mod_fact(n, p, e1), a2 = mod_fact(k, p, e2),
a3 = mod_fact(n - k, p, e3);
if (e1 > e2 + e3)
return 0;
return a1 * mod_inverse(a2 * a3 % p, p) % p;
}
};
int main() {
ll n, m, k;
cin >> n >> m >> k;
combination c(mod);
ll lyn, rn;
lyn = 0;
rn = 0;
for (int i = 1; i < n; i++) {
lyn += qp(m, 2, mod) * (n - i) * i;
lyn %= mod;
}
for (int i = 1; i < m; i++) {
rn += qp(n, 2, mod) * (m - i) * i;
rn %= mod;
}
cout << c.mod_comb(n * m - 2, k - 2) * (lyn + rn) % mod << endl;
return 0;
} | replace | 10 | 11 | 10 | 11 | 0 | |
p03039 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
#define INF 1000000007
#define LINF (1LL << 62)
typedef long long i64;
typedef pair<i64, i64> P;
i64 n, m, k;
// コンビネーション
// けんちょんさんありがとう
const int MAX = 101010, MOD = INF;
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 C(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() {
cin >> n >> m >> k;
i64 ans = 0, cnt = 0;
for (i64 i = 1; i < n; i++) {
cnt = i * (i + 1) / 2 % INF;
cnt = cnt * m % INF * m % INF;
ans += cnt;
ans %= INF;
}
for (i64 i = 1; i < m; i++) {
cnt = i * (i + 1) / 2 % INF;
cnt = cnt * n % INF * n % INF;
ans += cnt;
ans %= INF;
}
COMinit();
cout << C(n * m - 2, k - 2) * ans % INF << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
#define INF 1000000007
#define LINF (1LL << 62)
typedef long long i64;
typedef pair<i64, i64> P;
i64 n, m, k;
// コンビネーション
// けんちょんさんありがとう
const int MAX = 202020, MOD = INF;
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 C(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() {
cin >> n >> m >> k;
i64 ans = 0, cnt = 0;
for (i64 i = 1; i < n; i++) {
cnt = i * (i + 1) / 2 % INF;
cnt = cnt * m % INF * m % INF;
ans += cnt;
ans %= INF;
}
for (i64 i = 1; i < m; i++) {
cnt = i * (i + 1) / 2 % INF;
cnt = cnt * n % INF * n % INF;
ans += cnt;
ans %= INF;
}
COMinit();
cout << C(n * m - 2, k - 2) * ans % INF << endl;
return 0;
} | replace | 21 | 22 | 21 | 22 | 0 | |
p03039 | C++ | Runtime Error | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <vector>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define rep(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define reps(i, n) for (int i = 1, i##_len = (n); i <= i##_len; ++i)
#define rrep(i, n) for (int i = ((int)((n)-1)); i >= 0; --i)
#define rreps(i, n) for (int i = ((int)(n)); i > 0; --i)
#define ALL(x) (x).begin(), (x).end()
#define SZ(x) ((int)(x).size())
#define ZERO(a) memset(a, 0, sizeof(a))
#define BIT(n) (1LL << (n))
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
#ifdef LOCAL
#define eprintf(...) fprintf(stderr, __VA_ARGS__)
#else
#define eprintf(...) 4545
#endif
typedef long long int lli;
using namespace std;
typedef pair<int, int> ii;
typedef priority_queue<int, vector<int>, greater<int>> heapq;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
#define int long long int
struct aaa {
aaa() {
cin.tie(0);
ios::sync_with_stdio(0);
cout << fixed << setprecision(20);
};
} aaaaaaa;
const lli MOD = 1000000007LL;
inline lli mod_add(lli x, lli y) { return (x + y) % MOD; }
inline lli mod_mul(lli x, lli y) { return (x * y) % MOD; }
inline lli mod_sub(lli x, lli y) {
return x - y >= 0 ? (x - y) % MOD : (x - y + MOD) % MOD;
}
inline lli mod_pow(lli x, lli y) {
lli ret = 1;
while (y > 0) {
if (y & 1)
ret = ret * x % MOD;
x = x * x % MOD;
y = y >> 1;
}
return ret;
}
inline lli mod_inv(lli x) { return mod_pow(x, MOD - 2); }
inline lli mod_div(lli x, lli y) { return x * mod_inv(y) % MOD; }
#define MAX_FAC 100001
lli fac[MAX_FAC], finv[MAX_FAC];
void init_fac() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
for (int i = 2; i < MAX_FAC; i++) {
fac[i] = fac[i - 1] * i % MOD;
finv[i] = finv[i - 1] * mod_inv(i) % MOD;
}
}
inline lli com(int n, int k) {
if (n < k || n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
signed main() {
int N, M, K;
cin >> N >> M >> K;
init_fac();
int combi = com(mod_mul(N, M) - 2, K - 2);
int ans = 0;
// X座標から求める
reps(d, M - 1) {
int xCombi = mod_mul(mod_mul(M - d, N), N);
ans = mod_add(ans, mod_mul(d, xCombi));
}
// Y座標から求める
reps(dy, N - 1) {
int yCombi = mod_mul(mod_mul(N - dy, M), M);
ans = mod_add(ans, mod_mul(dy, yCombi));
}
cout << mod_mul(ans, combi) << endl;
return 0;
}
| #include <algorithm>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <vector>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define rep(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define reps(i, n) for (int i = 1, i##_len = (n); i <= i##_len; ++i)
#define rrep(i, n) for (int i = ((int)((n)-1)); i >= 0; --i)
#define rreps(i, n) for (int i = ((int)(n)); i > 0; --i)
#define ALL(x) (x).begin(), (x).end()
#define SZ(x) ((int)(x).size())
#define ZERO(a) memset(a, 0, sizeof(a))
#define BIT(n) (1LL << (n))
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
#ifdef LOCAL
#define eprintf(...) fprintf(stderr, __VA_ARGS__)
#else
#define eprintf(...) 4545
#endif
typedef long long int lli;
using namespace std;
typedef pair<int, int> ii;
typedef priority_queue<int, vector<int>, greater<int>> heapq;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
#define int long long int
struct aaa {
aaa() {
cin.tie(0);
ios::sync_with_stdio(0);
cout << fixed << setprecision(20);
};
} aaaaaaa;
const lli MOD = 1000000007LL;
inline lli mod_add(lli x, lli y) { return (x + y) % MOD; }
inline lli mod_mul(lli x, lli y) { return (x * y) % MOD; }
inline lli mod_sub(lli x, lli y) {
return x - y >= 0 ? (x - y) % MOD : (x - y + MOD) % MOD;
}
inline lli mod_pow(lli x, lli y) {
lli ret = 1;
while (y > 0) {
if (y & 1)
ret = ret * x % MOD;
x = x * x % MOD;
y = y >> 1;
}
return ret;
}
inline lli mod_inv(lli x) { return mod_pow(x, MOD - 2); }
inline lli mod_div(lli x, lli y) { return x * mod_inv(y) % MOD; }
#define MAX_FAC 200001
lli fac[MAX_FAC], finv[MAX_FAC];
void init_fac() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
for (int i = 2; i < MAX_FAC; i++) {
fac[i] = fac[i - 1] * i % MOD;
finv[i] = finv[i - 1] * mod_inv(i) % MOD;
}
}
inline lli com(int n, int k) {
if (n < k || n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
signed main() {
int N, M, K;
cin >> N >> M >> K;
init_fac();
int combi = com(mod_mul(N, M) - 2, K - 2);
int ans = 0;
// X座標から求める
reps(d, M - 1) {
int xCombi = mod_mul(mod_mul(M - d, N), N);
ans = mod_add(ans, mod_mul(d, xCombi));
}
// Y座標から求める
reps(dy, N - 1) {
int yCombi = mod_mul(mod_mul(N - dy, M), M);
ans = mod_add(ans, mod_mul(dy, yCombi));
}
cout << mod_mul(ans, combi) << endl;
return 0;
}
| replace | 68 | 69 | 68 | 69 | 0 | |
p03039 | C++ | Runtime Error | #include <cstdio>
#include <iostream>
#define MN 200000
#define mod 1000000007
int fac[MN + 5], Inv[MN + 5], inv[MN + 5];
int n, m, k;
int C(int a, int b) {
if (a < b)
return 0;
return 1ll * fac[a] * inv[b] % mod * inv[a - b] % mod;
}
int solve(int n, int m) {
int ans = 0;
int w = 0;
for (int b = 1; b <= n; b++)
w = (w + 1ll * b * (k - b) % mod * C(n * (m - 1), k - b) % mod * C(n, b)) %
mod;
for (int a = 1; a <= m; a++) {
int P = 1ll * Inv[m - 1] * (a - 1 - (m - a) + mod) % mod;
ans = (ans + 1ll * w * P % mod * a) % mod;
}
return ans;
}
int main() {
scanf("%d%d%d", &n, &m, &k);
fac[0] = Inv[0] = Inv[1] = inv[0] = 1;
for (int i = 1; i <= MN; i++)
fac[i] = 1ll * fac[i - 1] * i % mod;
for (int i = 2; i <= MN; i++)
Inv[i] = 1ll * (mod - mod / i) * Inv[mod % i] % mod;
for (int i = 1; i <= MN; i++)
inv[i] = 1ll * Inv[i] * inv[i - 1] % mod;
printf("%d\n", (solve(n, m) + solve(m, n)) % mod);
} | #include <cstdio>
#include <iostream>
#define MN 200000
#define mod 1000000007
int fac[MN + 5], Inv[MN + 5], inv[MN + 5];
int n, m, k;
int C(int a, int b) {
if (a < b)
return 0;
return 1ll * fac[a] * inv[b] % mod * inv[a - b] % mod;
}
int solve(int n, int m) {
int ans = 0;
int w = 0;
for (int b = 1; b <= std::min(n, k); b++)
w = (w + 1ll * b * (k - b) % mod * C(n * (m - 1), k - b) % mod * C(n, b)) %
mod;
for (int a = 1; a <= m; a++) {
int P = 1ll * Inv[m - 1] * (a - 1 - (m - a) + mod) % mod;
ans = (ans + 1ll * w * P % mod * a) % mod;
}
return ans;
}
int main() {
scanf("%d%d%d", &n, &m, &k);
fac[0] = Inv[0] = Inv[1] = inv[0] = 1;
for (int i = 1; i <= MN; i++)
fac[i] = 1ll * fac[i - 1] * i % mod;
for (int i = 2; i <= MN; i++)
Inv[i] = 1ll * (mod - mod / i) * Inv[mod % i] % mod;
for (int i = 1; i <= MN; i++)
inv[i] = 1ll * Inv[i] * inv[i - 1] % mod;
printf("%d\n", (solve(n, m) + solve(m, n)) % mod);
} | replace | 17 | 18 | 17 | 18 | 0 | |
p03039 | C++ | Runtime Error | #include <algorithm>
#include <cctype>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stdio.h>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
#define REP(i, b, e) for (ll i = (ll)b; i < (ll)e; i++)
#define rep0(i, n) REP(i, 0ll, n)
#define rep1(i, n) REP(i, 1ll, n + 1)
#define shosu setprecision(10)
typedef long long ll;
typedef pair<ll, ll> P;
typedef pair<P, ll> Q;
typedef pair<Q, ll> R;
ll longinf = 1ll << 60;
int inf = 1 << 29;
// mleしなければぜんぶllでかく。
// ↑はあんまり気にしなくていい。
const ll MOD = 1e9 + 7;
const int index = 1e5 + 1;
ll add(ll a, ll b) { return ((a % MOD) + (b % MOD)) % MOD; }
ll mul(ll a, ll b) { return ((a % MOD) * (b % MOD)) % MOD; }
ll power(ll a, ll b) {
if (b == 0)
return 1;
else if (b % 2 == 0) {
ll ret = power(a, b / 2);
return ((ret % MOD) * (ret % MOD)) % MOD;
} else
return ((power(a, b - 1) % MOD) * (a % MOD)) % MOD;
}
ll dive(ll a, ll b) { return ((a % MOD) * (power(b, MOD - 2) % MOD)) % MOD; }
ll frac[index + 1];
void calc() { // main関数内にcalc();を入れること
frac[0] = 1;
rep0(i, index) { frac[i + 1] = mul(frac[i], i + 1); }
}
int main() {
int n, m, k;
cin >> n >> m >> k;
ll ans = 0;
calc();
rep0(i, n) {
ans += mul(mul(mul(m, m), mul(i, n - i)),
dive(frac[m * n - 2], mul(frac[m * n - k], frac[k - 2])));
ans %= MOD;
}
swap(n, m);
rep0(i, n) {
ans += mul(mul(mul(m, m), mul(i, n - i)),
dive(frac[m * n - 2], mul(frac[m * n - k], frac[k - 2])));
ans %= MOD;
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <cctype>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stdio.h>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
#define REP(i, b, e) for (ll i = (ll)b; i < (ll)e; i++)
#define rep0(i, n) REP(i, 0ll, n)
#define rep1(i, n) REP(i, 1ll, n + 1)
#define shosu setprecision(10)
typedef long long ll;
typedef pair<ll, ll> P;
typedef pair<P, ll> Q;
typedef pair<Q, ll> R;
ll longinf = 1ll << 60;
int inf = 1 << 29;
// mleしなければぜんぶllでかく。
// ↑はあんまり気にしなくていい。
const ll MOD = 1e9 + 7;
const int index = 2 * 1e5 + 1;
ll add(ll a, ll b) { return ((a % MOD) + (b % MOD)) % MOD; }
ll mul(ll a, ll b) { return ((a % MOD) * (b % MOD)) % MOD; }
ll power(ll a, ll b) {
if (b == 0)
return 1;
else if (b % 2 == 0) {
ll ret = power(a, b / 2);
return ((ret % MOD) * (ret % MOD)) % MOD;
} else
return ((power(a, b - 1) % MOD) * (a % MOD)) % MOD;
}
ll dive(ll a, ll b) { return ((a % MOD) * (power(b, MOD - 2) % MOD)) % MOD; }
ll frac[index + 1];
void calc() { // main関数内にcalc();を入れること
frac[0] = 1;
rep0(i, index) { frac[i + 1] = mul(frac[i], i + 1); }
}
int main() {
int n, m, k;
cin >> n >> m >> k;
ll ans = 0;
calc();
rep0(i, n) {
ans += mul(mul(mul(m, m), mul(i, n - i)),
dive(frac[m * n - 2], mul(frac[m * n - k], frac[k - 2])));
ans %= MOD;
}
swap(n, m);
rep0(i, n) {
ans += mul(mul(mul(m, m), mul(i, n - i)),
dive(frac[m * n - 2], mul(frac[m * n - k], frac[k - 2])));
ans %= MOD;
}
cout << ans << endl;
return 0;
} | replace | 28 | 29 | 28 | 29 | 0 | |
p03039 | C++ | Runtime Error | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rrep(i, n) for (int i = 1; i < (n); ++i)
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define maxs(a, b) a = max(a, b)
#define mins(a, b) a = min(a, b)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const ll linf = (1ll << 61);
const int inf = 1001001001;
const int mod = 1000000007;
struct mint {
ll x;
mint(ll x = 0) : x(x % 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) {
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(100005);
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m, k;
cin >> n >> m >> k;
// 1組につきn*m-2 C k-2 個使われる
mint ans = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
mint tmp = mint(n - i) * mint(m - j) * mint(i + j);
if (i && j)
tmp *= 2;
ans += tmp;
}
}
ans *= comb(n * m - 2, k - 2);
printf("%d\n", ans);
return 0;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rrep(i, n) for (int i = 1; i < (n); ++i)
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define maxs(a, b) a = max(a, b)
#define mins(a, b) a = min(a, b)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const ll linf = (1ll << 61);
const int inf = 1001001001;
const int mod = 1000000007;
struct mint {
ll x;
mint(ll x = 0) : x(x % 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) {
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(200005);
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m, k;
cin >> n >> m >> k;
// 1組につきn*m-2 C k-2 個使われる
mint ans = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
mint tmp = mint(n - i) * mint(m - j) * mint(i + j);
if (i && j)
tmp *= 2;
ans += tmp;
}
}
ans *= comb(n * m - 2, k - 2);
printf("%d\n", ans);
return 0;
}
| replace | 77 | 78 | 77 | 78 | 0 | |
p03039 | C++ | Runtime Error | #include <bits/stdc++.h>
#define ll long long
#define fornum(A, B, C) for (A = B; A < C; A++)
#define mp make_pair
#define pii pair<int, int>
#define pll pair<ll, ll>
using namespace std;
/////////////////////////////////////////////////////
#define MOD ((ll)1e9 + 7)
ll N, M, K, fa[101010];
ll i, j, k, l;
ll moddiv(ll a, ll b) {
for (ll m = MOD - 2; m > 0; m /= 2) {
if (m & 1) {
a = a * b % MOD;
}
b = b * b % MOD;
}
return a;
}
int main() {
scanf("%lld%lld%lld", &N, &M, &K);
fa[0] = 1;
fornum(i, 0, N * M) { fa[i + 1] = fa[i] * (i + 1) % MOD; }
ll n = moddiv(((N * (N + 1) % MOD * (2 * N + 1) % MOD) + MOD -
(3 * N * (N + 1) % MOD)) %
MOD,
12) *
M % MOD * M % MOD;
ll m = moddiv(((M * (M + 1) % MOD * (2 * M + 1) % MOD) + MOD -
(3 * M * (M + 1) % MOD)) %
MOD,
12) *
N % MOD * N % MOD;
// printf("%lld %lld ", n, m);
printf("%lld", (n + m) % MOD *
moddiv(fa[N * M - 2], fa[K - 2] * fa[N * M - K] % MOD) %
MOD);
return 0;
}
| #include <bits/stdc++.h>
#define ll long long
#define fornum(A, B, C) for (A = B; A < C; A++)
#define mp make_pair
#define pii pair<int, int>
#define pll pair<ll, ll>
using namespace std;
/////////////////////////////////////////////////////
#define MOD ((ll)1e9 + 7)
ll N, M, K, fa[202020];
ll i, j, k, l;
ll moddiv(ll a, ll b) {
for (ll m = MOD - 2; m > 0; m /= 2) {
if (m & 1) {
a = a * b % MOD;
}
b = b * b % MOD;
}
return a;
}
int main() {
scanf("%lld%lld%lld", &N, &M, &K);
fa[0] = 1;
fornum(i, 0, N * M) { fa[i + 1] = fa[i] * (i + 1) % MOD; }
ll n = moddiv(((N * (N + 1) % MOD * (2 * N + 1) % MOD) + MOD -
(3 * N * (N + 1) % MOD)) %
MOD,
12) *
M % MOD * M % MOD;
ll m = moddiv(((M * (M + 1) % MOD * (2 * M + 1) % MOD) + MOD -
(3 * M * (M + 1) % MOD)) %
MOD,
12) *
N % MOD * N % MOD;
// printf("%lld %lld ", n, m);
printf("%lld", (n + m) % MOD *
moddiv(fa[N * M - 2], fa[K - 2] * fa[N * M - K] % MOD) %
MOD);
return 0;
}
| replace | 13 | 14 | 13 | 14 | 0 | |
p03039 | C++ | Runtime Error | #include <bits/stdc++.h>
#include <bitset>
using namespace std;
#define M 1000000007
#define pb push_back
#define f first
#define s second
#define rep(i, st, ed) for (ll i = st; i < ed; i++)
#define repn(i, st, ed) for (ll i = st; i <= ed; i++)
#define repb(i, ed, st) for (ll i = ed; i >= st; i--)
#define all(v) v.begin(), v.end()
typedef long long ll;
typedef unsigned long long int llt;
typedef long double ld;
const long double PI = 3.141592653589793238463;
const int N = 1e5 + 10;
const ll INF = 1LL << 60;
template <class T> void chmax(T &a, T b) {
if (a < b)
a = b;
}
template <class T> void chmin(T &a, T b) {
if (a > b)
a = b;
}
// Main Code
ll ppow(ll x, ll y, ll mod) {
ll res = 1;
while (y > 0) {
if (y & 1)
res = (res * x) % mod;
y = y >> 1;
x = (x * x) % mod;
}
return res;
}
// Factorial with dp
ll factdp[N];
ll fact(ll x) {
if (x == 0)
return 1;
if (x == 1)
return 1;
if (factdp[x] != 0)
return factdp[x];
return factdp[x] = (x * fact(x - 1)) % M;
}
// Combination
ll modcomb(ll n, ll r) {
if (n < r)
return 0;
ll res = fact(n);
(res *= ppow(fact(r), M - 2, M)) %= M;
(res *= ppow(fact(n - r), M - 2, M)) %= M;
return res;
}
int main() {
ll n, m, k;
cin >> n >> m >> k;
ll ansn = 0;
ll ansb = 0;
ll ans = 1;
rep(i, 1, n) { ansn = (ansn + (n - i) * i) % M; }
ansn = (ansn * (m * m) % M) % M;
rep(i, 1, m) { ansb = (ansb + (m - i) * i) % M; }
ansb = (ansb * (n * n) % M) % M;
ans = (ansb + ansn) % M;
ans = (ans * modcomb(n * m - 2, k - 2)) % M;
cout << ans << endl;
}
| #include <bits/stdc++.h>
#include <bitset>
using namespace std;
#define M 1000000007
#define pb push_back
#define f first
#define s second
#define rep(i, st, ed) for (ll i = st; i < ed; i++)
#define repn(i, st, ed) for (ll i = st; i <= ed; i++)
#define repb(i, ed, st) for (ll i = ed; i >= st; i--)
#define all(v) v.begin(), v.end()
typedef long long ll;
typedef unsigned long long int llt;
typedef long double ld;
const long double PI = 3.141592653589793238463;
const int N = 2e5 + 10;
const ll INF = 1LL << 60;
template <class T> void chmax(T &a, T b) {
if (a < b)
a = b;
}
template <class T> void chmin(T &a, T b) {
if (a > b)
a = b;
}
// Main Code
ll ppow(ll x, ll y, ll mod) {
ll res = 1;
while (y > 0) {
if (y & 1)
res = (res * x) % mod;
y = y >> 1;
x = (x * x) % mod;
}
return res;
}
// Factorial with dp
ll factdp[N];
ll fact(ll x) {
if (x == 0)
return 1;
if (x == 1)
return 1;
if (factdp[x] != 0)
return factdp[x];
return factdp[x] = (x * fact(x - 1)) % M;
}
// Combination
ll modcomb(ll n, ll r) {
if (n < r)
return 0;
ll res = fact(n);
(res *= ppow(fact(r), M - 2, M)) %= M;
(res *= ppow(fact(n - r), M - 2, M)) %= M;
return res;
}
int main() {
ll n, m, k;
cin >> n >> m >> k;
ll ansn = 0;
ll ansb = 0;
ll ans = 1;
rep(i, 1, n) { ansn = (ansn + (n - i) * i) % M; }
ansn = (ansn * (m * m) % M) % M;
rep(i, 1, m) { ansb = (ansb + (m - i) * i) % M; }
ansb = (ansb * (n * n) % M) % M;
ans = (ansb + ansn) % M;
ans = (ans * modcomb(n * m - 2, k - 2)) % M;
cout << ans << endl;
}
| replace | 18 | 19 | 18 | 19 | 0 | |
p03039 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define crap \
ios::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL)
typedef long long int ll;
typedef unsigned long long ull;
typedef std::vector<int> vi;
typedef std::vector<ll> vll;
typedef std::vector<vi> vvi;
typedef std::vector<vll> vvll;
typedef std::pair<int, int> ii;
typedef std::pair<ll, ll> lp;
typedef std::vector<ii> vii;
typedef std::vector<vii> vvii;
#define pb emplace_back
#define PB pop_back
#define pf push_front
#define PF pop_front
#define mp make_pair
#define ub(a, b) upper_bound(all(a), b)
#define lb(a, b) lower_bound(all(a), b)
#define bs(a, b) binary_search(all(a), b)
#define mem(a, b) memset(a, b, sizeof(a))
#define in(a, n) F(i, 0, n - 1) cin >> a[i]
#define in1(a, n) F(i, 1, n) cin >> a[i]
#define out(a, n) \
F(i, 0, n - 1) cout << a[i] << "\n"; \
cout << endl
#define ff first
#define ss second
#define F(i, a, b) for (ll i = a; i <= b; i++)
#define RF(i, a, b) for (ll i = a; i >= b; i--)
#define rep(i, n) F(i, 0, n - 1)
#define clr(a) (a).clear()
#define rz resize
#define sqr(a) ((a) * (a))
#define sz(a) int((a).size())
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define endl '\n'
#define mod 1000000007
ll add(ll a, ll b) { return (a % mod + b % mod) % mod; }
ll sub(ll a, ll b) { return (a % mod - b % mod + mod) % mod; }
ll mul(ll a, ll b) { return (a % mod * b % mod) % mod; }
ull poww(ull a, ull b) {
ull res = 1;
while (b) {
if (b & 1) {
res *= a;
}
a = a * a;
b >>= 1;
}
return res;
}
ll poww(ll a, ll b, ll MOD) {
ll res = 1;
while (b) {
if (b & 1) {
res *= a;
res %= MOD;
}
a = a * a;
a %= MOD;
b >>= 1;
}
return res;
}
#define dbg(x) cout << #x << " :: " << x << endl;
#define dbg2(x, y) \
cout << #x << " :: " << x << "\t" << #y << " :: " << y << endl;
#define dbg3(x, y, z) \
cout << #x << " :: " << x << "\t" << #y << " :: " << y << "\t" << #z \
<< " :: " << z << endl;
#define dbg4(x, y, z, w) \
cout << #x << " :: " << x << "\t" << #y << " :: " << y << "\t" << #z \
<< " :: " << z << "\t" << #w << " :: " << w << endl;
// end of template
const int N = 1e5 + 5;
ll fac[N];
ll ifac[N];
ll ncr(ll n, ll r) { return mul(fac[n], mul(ifac[r], ifac[n - r])); }
void pre() {
ifac[0] = fac[0] = 1;
F(i, 1, N - 1) {
fac[i] = mul(fac[i - 1], i);
ifac[i] = mul(ifac[i - 1], poww(i, mod - 2, mod));
}
}
int main(int argc, char const *argv[]) {
crap;
ll n, m, k;
cin >> n >> m >> k;
pre();
ll ans = ncr(n * m - 2, k - 2);
ll d1 = 0, d2 = 0, d = 0;
vll x, y;
F(i, 1, n) {
F(j, 1, m) {
x.pb(i);
y.pb(j);
}
}
sort(all(x));
sort(all(y));
ll prev = 0;
rep(i, sz(x)) {
d1 = add(d1, sub(mul(i, x[i]), prev));
prev += x[i];
}
prev = 0;
rep(i, sz(y)) {
d2 = add(d2, sub(mul(i, y[i]), prev));
prev += y[i];
}
d = add(d1, d2);
ans = mul(ans, d);
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define crap \
ios::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL)
typedef long long int ll;
typedef unsigned long long ull;
typedef std::vector<int> vi;
typedef std::vector<ll> vll;
typedef std::vector<vi> vvi;
typedef std::vector<vll> vvll;
typedef std::pair<int, int> ii;
typedef std::pair<ll, ll> lp;
typedef std::vector<ii> vii;
typedef std::vector<vii> vvii;
#define pb emplace_back
#define PB pop_back
#define pf push_front
#define PF pop_front
#define mp make_pair
#define ub(a, b) upper_bound(all(a), b)
#define lb(a, b) lower_bound(all(a), b)
#define bs(a, b) binary_search(all(a), b)
#define mem(a, b) memset(a, b, sizeof(a))
#define in(a, n) F(i, 0, n - 1) cin >> a[i]
#define in1(a, n) F(i, 1, n) cin >> a[i]
#define out(a, n) \
F(i, 0, n - 1) cout << a[i] << "\n"; \
cout << endl
#define ff first
#define ss second
#define F(i, a, b) for (ll i = a; i <= b; i++)
#define RF(i, a, b) for (ll i = a; i >= b; i--)
#define rep(i, n) F(i, 0, n - 1)
#define clr(a) (a).clear()
#define rz resize
#define sqr(a) ((a) * (a))
#define sz(a) int((a).size())
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define endl '\n'
#define mod 1000000007
ll add(ll a, ll b) { return (a % mod + b % mod) % mod; }
ll sub(ll a, ll b) { return (a % mod - b % mod + mod) % mod; }
ll mul(ll a, ll b) { return (a % mod * b % mod) % mod; }
ull poww(ull a, ull b) {
ull res = 1;
while (b) {
if (b & 1) {
res *= a;
}
a = a * a;
b >>= 1;
}
return res;
}
ll poww(ll a, ll b, ll MOD) {
ll res = 1;
while (b) {
if (b & 1) {
res *= a;
res %= MOD;
}
a = a * a;
a %= MOD;
b >>= 1;
}
return res;
}
#define dbg(x) cout << #x << " :: " << x << endl;
#define dbg2(x, y) \
cout << #x << " :: " << x << "\t" << #y << " :: " << y << endl;
#define dbg3(x, y, z) \
cout << #x << " :: " << x << "\t" << #y << " :: " << y << "\t" << #z \
<< " :: " << z << endl;
#define dbg4(x, y, z, w) \
cout << #x << " :: " << x << "\t" << #y << " :: " << y << "\t" << #z \
<< " :: " << z << "\t" << #w << " :: " << w << endl;
// end of template
const int N = 2e5 + 5;
ll fac[N];
ll ifac[N];
ll ncr(ll n, ll r) { return mul(fac[n], mul(ifac[r], ifac[n - r])); }
void pre() {
ifac[0] = fac[0] = 1;
F(i, 1, N - 1) {
fac[i] = mul(fac[i - 1], i);
ifac[i] = mul(ifac[i - 1], poww(i, mod - 2, mod));
}
}
int main(int argc, char const *argv[]) {
crap;
ll n, m, k;
cin >> n >> m >> k;
pre();
ll ans = ncr(n * m - 2, k - 2);
ll d1 = 0, d2 = 0, d = 0;
vll x, y;
F(i, 1, n) {
F(j, 1, m) {
x.pb(i);
y.pb(j);
}
}
sort(all(x));
sort(all(y));
ll prev = 0;
rep(i, sz(x)) {
d1 = add(d1, sub(mul(i, x[i]), prev));
prev += x[i];
}
prev = 0;
rep(i, sz(y)) {
d2 = add(d2, sub(mul(i, y[i]), prev));
prev += y[i];
}
d = add(d1, d2);
ans = mul(ans, d);
cout << ans << endl;
return 0;
} | replace | 86 | 87 | 86 | 87 | 0 | |
p03039 | C++ | Time Limit Exceeded | // i ll be the king
#include <bits/stdc++.h>
#define ll long long int
#define ld long double
#define sync \
ios_base::sync_with_stdio(false); \
cin.tie(NULL)
#define input(arr, n) \
for (ll i1 = 0; i1 < n; i1++) \
cin >> arr[i1]
#define rep(n) for (ll i2 = 0; i2 < n; i2++)
#define vmp(v, a, b) v.push_back(make_pair(a, b))
#define si(a) scanf("%lld", &a)
#define pi(a) printf("%lld", a)
#define aset(a, n, k) \
for (ll i3 = 0; i3 < n; i3++) \
a[i3] = k;
#define mod 1000000007
#define mp(a, b) make_pair(a, b)
#define f first
#define s second
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
#define ordered_set \
tree<ll, null_type, greater_equal<ll>, rb_tree_tag, \
tree_order_statistics_node_update> // s.order_of_key(val)
// *s.find_by_orde(ind)
using namespace std;
ll manhattan(ll n) {
ll ans = 0;
for (ll i = 1; i <= n; i++) {
for (ll j = i + 1; j <= n; j++) {
ans += j - i;
ans %= mod;
}
}
return ans;
}
ll modexp(ll a, ll b) {
if (a == 0)
return 0;
if (b == 0)
return 1;
if (a == 1)
return 1;
if (b % 2 == 0) {
ll val = modexp(a, b / 2);
return (val * val) % mod;
}
return (a * modexp(a, b - 1)) % mod;
}
int main() {
sync;
ll n, m, k;
cin >> n >> m >> k;
ll dis = (manhattan(n) * (m * m) % mod + manhattan(m) * (n * n) % mod) % mod;
ll invf[n * m], fact[n * m];
invf[0] = invf[1] = fact[0] = fact[1] = 1;
for (ll i = 2; i <= n * m; i++)
invf[i] = (invf[i - 1] * modexp(i, mod - 2)) % mod,
fact[i] = (fact[i - 1] * i) % mod;
ll ncr = (invf[k - 2] * invf[n * m - k]) % mod;
ncr = (ncr * fact[n * m - 2]) % mod;
// cout<<dis<<" "<<ncr<<" "<<manhattan(n)<<" "<<fact[n*m-2]<<"
// "<<invf[k-2]<<" "<<invf[n*m-k]<<endl;
cout << (ncr * dis) % mod;
}
| // i ll be the king
#include <bits/stdc++.h>
#define ll long long int
#define ld long double
#define sync \
ios_base::sync_with_stdio(false); \
cin.tie(NULL)
#define input(arr, n) \
for (ll i1 = 0; i1 < n; i1++) \
cin >> arr[i1]
#define rep(n) for (ll i2 = 0; i2 < n; i2++)
#define vmp(v, a, b) v.push_back(make_pair(a, b))
#define si(a) scanf("%lld", &a)
#define pi(a) printf("%lld", a)
#define aset(a, n, k) \
for (ll i3 = 0; i3 < n; i3++) \
a[i3] = k;
#define mod 1000000007
#define mp(a, b) make_pair(a, b)
#define f first
#define s second
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
#define ordered_set \
tree<ll, null_type, greater_equal<ll>, rb_tree_tag, \
tree_order_statistics_node_update> // s.order_of_key(val)
// *s.find_by_orde(ind)
using namespace std;
ll manhattan(ll n) {
ll ans = 0;
for (ll i = 1; i <= n; i++) {
ans += (i * (i - 1)) / 2;
ans %= mod;
}
return ans;
}
ll modexp(ll a, ll b) {
if (a == 0)
return 0;
if (b == 0)
return 1;
if (a == 1)
return 1;
if (b % 2 == 0) {
ll val = modexp(a, b / 2);
return (val * val) % mod;
}
return (a * modexp(a, b - 1)) % mod;
}
int main() {
sync;
ll n, m, k;
cin >> n >> m >> k;
ll dis = (manhattan(n) * (m * m) % mod + manhattan(m) * (n * n) % mod) % mod;
ll invf[n * m], fact[n * m];
invf[0] = invf[1] = fact[0] = fact[1] = 1;
for (ll i = 2; i <= n * m; i++)
invf[i] = (invf[i - 1] * modexp(i, mod - 2)) % mod,
fact[i] = (fact[i - 1] * i) % mod;
ll ncr = (invf[k - 2] * invf[n * m - k]) % mod;
ncr = (ncr * fact[n * m - 2]) % mod;
// cout<<dis<<" "<<ncr<<" "<<manhattan(n)<<" "<<fact[n*m-2]<<"
// "<<invf[k-2]<<" "<<invf[n*m-k]<<endl;
cout << (ncr * dis) % mod;
}
| replace | 32 | 36 | 32 | 34 | TLE | |
p03039 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define rep(i, m) for (long long i = 0; i < m; i++)
#define per(i, m) for (long long i = m - 1; i >= 0; i--)
#define FOR(i, n, m) for (long long i = n; i < m; i++)
#define ROF(i, n, m) for (long long i = m - 1; i >= n; i--)
#define SORT(v, n) \
do { \
sort(v, v + n); \
reverse(v, v + n); \
} while (0)
#define all(x) (x).begin(), (x).end()
#define EPS (1e-7)
#define INF (1e18)
#define PI (acos(-1))
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) \
cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" \
<< " " << __FILE__ << endl;
using namespace std;
typedef long long ll;
const ll MOD = 1000000007;
typedef pair<ll, ll> LP;
ll POW(ll x, ll n) {
if (n == 0)
return 1;
if (n % 2 == 0)
return POW(x * x, n / 2) % MOD;
return x % MOD * POW(x, n - 1) % MOD;
}
ll POW2(ll x, ll n) {
if (n == 0)
return 1;
if (n % 2 == 0)
return POW2(x * x, n / 2);
return x * POW2(x, n - 1);
}
ll gcd(ll u, ll v) {
ll r;
while (0 != v) {
r = u % v;
u = v;
v = r;
}
return u;
}
ll lcm(ll u, ll v) { return u * v / gcd(u, v); }
ll KAI(ll m) {
if (m < 0)
return 0;
if (m == 0)
return 1;
return m * KAI(m - 1) % MOD;
}
ll KAI2(ll m) {
if (m < 0)
return 0;
if (m == 0)
return 1;
return m * KAI2(m - 1);
}
ll extGCD(ll a, ll b, ll &x, ll &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
ll d = extGCD(b, a % b, y, x);
y -= a / b * x;
return d;
}
inline ll mod(ll a, ll m) { return (a % m + m) % m; }
ll modinv(ll a) {
ll x, y;
extGCD(a, MOD, x, y);
return mod(x, MOD);
}
ll COM(ll m, ll n) {
if (m < n)
return 0;
if (n < 0)
return 0;
if (n == 0)
return 1;
if (m == n)
return 1;
return KAI(m) % MOD * modinv(KAI(n) % MOD * KAI(m - n) % MOD) % MOD;
}
ll COM2(ll m, ll n) {
if (m < n)
return 0;
if (n < 0)
return 0;
if (n == 0)
return 1;
if (m == n)
return 1;
return KAI2(m) / KAI2(n) / KAI2(m - n);
}
ll DEC(ll x, ll m, ll n) { return x % POW(m, n + 1) / POW(m, n); }
ll keta(ll x, ll n) {
if (x == 0)
return 0;
return keta(x / n, n) + 1;
}
ll DIV(ll x, ll n) {
if (x == 0)
return 0;
return x / n + DIV(x / n, n);
}
ll ORD(ll x, ll n) {
if (x == 0)
return INF;
if (x % n != 0)
return 0;
return 1 + ORD(x / n, n);
}
int main() {
ll n, m, k, ans, q = 0;
cin >> n >> m >> k;
rep(i, n) { q = (q + (COM(i + 1, 2) + COM(n - i, 2)) * m % MOD * m) % MOD; }
rep(j, m) { q = (q + (COM(j + 1, 2) + COM(m - j, 2)) * n % MOD * n) % MOD; }
q = q * modinv(COM(m * n, 2)) % MOD * modinv(2) % MOD;
ans = (COM(n * m, k) * COM(k, 2) % MOD * q % MOD + MOD) % MOD;
printf("%lld", ans);
} | #include <bits/stdc++.h>
#define rep(i, m) for (long long i = 0; i < m; i++)
#define per(i, m) for (long long i = m - 1; i >= 0; i--)
#define FOR(i, n, m) for (long long i = n; i < m; i++)
#define ROF(i, n, m) for (long long i = m - 1; i >= n; i--)
#define SORT(v, n) \
do { \
sort(v, v + n); \
reverse(v, v + n); \
} while (0)
#define all(x) (x).begin(), (x).end()
#define EPS (1e-7)
#define INF (1e18)
#define PI (acos(-1))
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) \
cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" \
<< " " << __FILE__ << endl;
using namespace std;
typedef long long ll;
const ll MOD = 1000000007;
typedef pair<ll, ll> LP;
ll POW(ll x, ll n) {
if (n == 0)
return 1;
if (n % 2 == 0)
return POW(x * x, n / 2) % MOD;
return x % MOD * POW(x, n - 1) % MOD;
}
ll POW2(ll x, ll n) {
if (n == 0)
return 1;
if (n % 2 == 0)
return POW2(x * x, n / 2);
return x * POW2(x, n - 1);
}
ll gcd(ll u, ll v) {
ll r;
while (0 != v) {
r = u % v;
u = v;
v = r;
}
return u;
}
ll lcm(ll u, ll v) { return u * v / gcd(u, v); }
ll KAI(ll m) {
if (m < 0)
return 0;
if (m == 0)
return 1;
return m * KAI(m - 1) % MOD;
}
ll KAI2(ll m) {
if (m < 0)
return 0;
if (m == 0)
return 1;
return m * KAI2(m - 1);
}
ll extGCD(ll a, ll b, ll &x, ll &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
ll d = extGCD(b, a % b, y, x);
y -= a / b * x;
return d;
}
inline ll mod(ll a, ll m) { return (a % m + m) % m; }
ll modinv(ll a) {
ll x, y;
extGCD(a, MOD, x, y);
return mod(x, MOD);
}
ll COM(ll m, ll n) {
if (m < n)
return 0;
if (n < 0)
return 0;
if (n == 0)
return 1;
if (m == n)
return 1;
return KAI(m) % MOD * modinv(KAI(n) % MOD * KAI(m - n) % MOD) % MOD;
}
ll COM2(ll m, ll n) {
if (m < n)
return 0;
if (n < 0)
return 0;
if (n == 0)
return 1;
if (m == n)
return 1;
return KAI2(m) / KAI2(n) / KAI2(m - n);
}
ll DEC(ll x, ll m, ll n) { return x % POW(m, n + 1) / POW(m, n); }
ll keta(ll x, ll n) {
if (x == 0)
return 0;
return keta(x / n, n) + 1;
}
ll DIV(ll x, ll n) {
if (x == 0)
return 0;
return x / n + DIV(x / n, n);
}
ll ORD(ll x, ll n) {
if (x == 0)
return INF;
if (x % n != 0)
return 0;
return 1 + ORD(x / n, n);
}
int main() {
ll n, m, k, ans, q = 0;
cin >> n >> m >> k;
q = (q + (COM(n + 1, 3) + COM(n + 1, 3)) * m % MOD * m) % MOD;
q = (q + (COM(m + 1, 3) + COM(m + 1, 3)) * n % MOD * n) % MOD;
q = q * modinv(COM(m * n, 2)) % MOD * modinv(2) % MOD;
ans = (COM(n * m, k) * COM(k, 2) % MOD * q % MOD + MOD) % MOD;
printf("%lld", ans);
} | replace | 135 | 137 | 135 | 137 | TLE | |
p03039 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
const int INF = 1e9;
const int MOD = 1e9 + 7;
const long long LINF = 1e18;
#define dump(x) cout << 'x' << ' = ' << (x) << ` `;
#define FOR(i, a, b) for (ll i = (a); i < (b); ++i)
#define rep(i, n) for (ll i = 0; i < (n); ++i)
#define REPR(i, n) for (ll i = n; i >= 0; i--)
#define FOREACH(x, a) for (auto &(x) : (a))
typedef long long ll;
using namespace std;
typedef pair<ll, ll> P;
template <typename T> void print(const vector<T> &x) {
int n = x.size();
rep(i, n) {
cout << x[i];
if (i != n - 1)
cout << " ";
else
cout << endl;
}
}
template <typename T> void print(const vector<vector<T>> &x) {
int n = x.size();
rep(i, n) {
rep(j, x[i].size()) { cout << x[i][j] << " "; }
cout << endl;
}
}
template <typename T> void print(const vector<T> &x, int n) {
rep(i, n) {
cout << x[i];
if (i != n - 1)
cout << " ";
else
cout << endl;
}
}
template <typename T> void print(const vector<vector<T>> &x, int n, int m) {
rep(i, n) {
rep(j, m) { cout << x[i][j] << " "; }
cout << endl;
}
}
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;
}
void input_init() {
cin.tie(0);
ios::sync_with_stdio(false);
}
template <int mod> struct ModInt {
int x;
ModInt() : x(0) {}
ModInt(int64_t y) : x(y >= 0 ? y % mod : (mod - (-y) % mod) % mod) {}
ModInt &operator+=(const ModInt &p) {
if ((x += p.x) >= mod)
x -= mod;
return *this;
}
ModInt &operator-=(const ModInt &p) {
if ((x += mod - p.x) >= mod)
x -= mod;
return *this;
}
ModInt &operator*=(const ModInt &p) {
x = (int)(1LL * x * p.x % mod);
return *this;
}
ModInt &operator/=(const ModInt &p) {
*this *= p.inverse();
return *this;
}
ModInt operator-() const { return ModInt(-x); }
ModInt operator+(const ModInt &p) const { return ModInt(*this) += p; }
ModInt operator-(const ModInt &p) const { return ModInt(*this) -= p; }
ModInt operator*(const ModInt &p) const { return ModInt(*this) *= p; }
ModInt operator/(const ModInt &p) const { return ModInt(*this) /= p; }
bool operator==(const ModInt &p) const { return x == p.x; }
bool operator!=(const ModInt &p) const { return x != p.x; }
ModInt inverse() const {
int a = x, b = mod, u = 1, v = 0, t;
while (b > 0) {
t = a / b;
swap(a -= t * b, b);
swap(u -= t * v, v);
}
return ModInt(u);
}
ModInt pow(int64_t n) const {
ModInt ret(1), mul(x);
while (n > 0) {
if (n & 1)
ret *= mul;
mul *= mul;
n >>= 1;
}
return ret;
}
friend ostream &operator<<(ostream &os, const ModInt &p) { return os << p.x; }
friend istream &operator>>(istream &is, ModInt &a) {
int64_t t;
is >> t;
a = ModInt<mod>(t);
return (is);
}
static int get_mod() { return mod; }
};
using modint = ModInt<MOD>;
class combM {
private:
vector<ll> fac; // n!(mod M)
vector<ll> ifac; // k!^{M-2} (mod M)
public:
ll mpow(ll x, ll n);
combM();
ll com(ll a, ll b);
};
// x^n(mod M)
ll combM::mpow(ll x, ll n) {
ll ans = 1ll;
while (n != 0) {
if (n & 1)
ans = ans * x % MOD;
x = x * x % MOD;
n = n >> 1;
}
return ans;
}
// aCb をmod計算
ll combM::com(ll a, ll b) {
if (a == 0 && b == 0)
return 1;
if (a < b || a < 0)
return 0;
ll tmp = ifac[a - b] * ifac[b] % MOD;
return tmp * fac[a] % MOD;
}
combM::combM() {
fac.resize(500001);
ifac.resize(500001);
fac[0] = 1;
ifac[0] = 1;
for (ll i = 0; i < 500000; ++i) {
fac[i + 1] = fac[i] * (i + 1) % MOD;
ifac[i + 1] = ifac[i] * mpow(i + 1, MOD - 2) % MOD;
}
}
ll mpow(ll x, ll n) {
ll ans = 1ll;
while (n != 0) {
if (n & 1)
ans = ans * x % MOD;
x = x * x % MOD;
n = n >> 1;
}
return ans;
}
int main(int argc, char const *argv[]) {
ll n, m, k;
cin >> n >> m >> k;
modint N = n, M = m;
combM C;
modint x = 0, y = 0;
for (int i = 0; i < m; ++i) {
for (int j = i; j < m; ++j) {
modint A = j - i;
x += A * N * N * (C.com(n * m - 2, k - 2));
}
}
for (int i = 0; i < n; ++i) {
for (int j = i; j < n; ++j) {
modint A = j - i;
y += A * M * M * (C.com(n * m - 2, k - 2));
}
}
cout << x + y << '\n';
return 0;
} | #include <bits/stdc++.h>
const int INF = 1e9;
const int MOD = 1e9 + 7;
const long long LINF = 1e18;
#define dump(x) cout << 'x' << ' = ' << (x) << ` `;
#define FOR(i, a, b) for (ll i = (a); i < (b); ++i)
#define rep(i, n) for (ll i = 0; i < (n); ++i)
#define REPR(i, n) for (ll i = n; i >= 0; i--)
#define FOREACH(x, a) for (auto &(x) : (a))
typedef long long ll;
using namespace std;
typedef pair<ll, ll> P;
template <typename T> void print(const vector<T> &x) {
int n = x.size();
rep(i, n) {
cout << x[i];
if (i != n - 1)
cout << " ";
else
cout << endl;
}
}
template <typename T> void print(const vector<vector<T>> &x) {
int n = x.size();
rep(i, n) {
rep(j, x[i].size()) { cout << x[i][j] << " "; }
cout << endl;
}
}
template <typename T> void print(const vector<T> &x, int n) {
rep(i, n) {
cout << x[i];
if (i != n - 1)
cout << " ";
else
cout << endl;
}
}
template <typename T> void print(const vector<vector<T>> &x, int n, int m) {
rep(i, n) {
rep(j, m) { cout << x[i][j] << " "; }
cout << endl;
}
}
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;
}
void input_init() {
cin.tie(0);
ios::sync_with_stdio(false);
}
template <int mod> struct ModInt {
int x;
ModInt() : x(0) {}
ModInt(int64_t y) : x(y >= 0 ? y % mod : (mod - (-y) % mod) % mod) {}
ModInt &operator+=(const ModInt &p) {
if ((x += p.x) >= mod)
x -= mod;
return *this;
}
ModInt &operator-=(const ModInt &p) {
if ((x += mod - p.x) >= mod)
x -= mod;
return *this;
}
ModInt &operator*=(const ModInt &p) {
x = (int)(1LL * x * p.x % mod);
return *this;
}
ModInt &operator/=(const ModInt &p) {
*this *= p.inverse();
return *this;
}
ModInt operator-() const { return ModInt(-x); }
ModInt operator+(const ModInt &p) const { return ModInt(*this) += p; }
ModInt operator-(const ModInt &p) const { return ModInt(*this) -= p; }
ModInt operator*(const ModInt &p) const { return ModInt(*this) *= p; }
ModInt operator/(const ModInt &p) const { return ModInt(*this) /= p; }
bool operator==(const ModInt &p) const { return x == p.x; }
bool operator!=(const ModInt &p) const { return x != p.x; }
ModInt inverse() const {
int a = x, b = mod, u = 1, v = 0, t;
while (b > 0) {
t = a / b;
swap(a -= t * b, b);
swap(u -= t * v, v);
}
return ModInt(u);
}
ModInt pow(int64_t n) const {
ModInt ret(1), mul(x);
while (n > 0) {
if (n & 1)
ret *= mul;
mul *= mul;
n >>= 1;
}
return ret;
}
friend ostream &operator<<(ostream &os, const ModInt &p) { return os << p.x; }
friend istream &operator>>(istream &is, ModInt &a) {
int64_t t;
is >> t;
a = ModInt<mod>(t);
return (is);
}
static int get_mod() { return mod; }
};
using modint = ModInt<MOD>;
class combM {
private:
vector<ll> fac; // n!(mod M)
vector<ll> ifac; // k!^{M-2} (mod M)
public:
ll mpow(ll x, ll n);
combM();
ll com(ll a, ll b);
};
// x^n(mod M)
ll combM::mpow(ll x, ll n) {
ll ans = 1ll;
while (n != 0) {
if (n & 1)
ans = ans * x % MOD;
x = x * x % MOD;
n = n >> 1;
}
return ans;
}
// aCb をmod計算
ll combM::com(ll a, ll b) {
if (a == 0 && b == 0)
return 1;
if (a < b || a < 0)
return 0;
ll tmp = ifac[a - b] * ifac[b] % MOD;
return tmp * fac[a] % MOD;
}
combM::combM() {
fac.resize(500001);
ifac.resize(500001);
fac[0] = 1;
ifac[0] = 1;
for (ll i = 0; i < 500000; ++i) {
fac[i + 1] = fac[i] * (i + 1) % MOD;
ifac[i + 1] = ifac[i] * mpow(i + 1, MOD - 2) % MOD;
}
}
ll mpow(ll x, ll n) {
ll ans = 1ll;
while (n != 0) {
if (n & 1)
ans = ans * x % MOD;
x = x * x % MOD;
n = n >> 1;
}
return ans;
}
int main(int argc, char const *argv[]) {
ll n, m, k;
cin >> n >> m >> k;
modint N = n, M = m;
combM C;
modint x = 0, y = 0;
map<int, int> mpn, mpm;
for (int i = 1; i < n; ++i) {
mpn[i] = n - i;
}
for (int i = 1; i < m; ++i) {
mpm[i] = m - i;
}
for (auto &&e : mpm) {
modint A = e.first;
modint B = e.second;
x += A * N * N * (C.com(n * m - 2, k - 2)) * B;
}
for (auto &&e : mpn) {
modint A = e.first;
modint B = e.second;
y += A * M * M * (C.com(n * m - 2, k - 2)) * B;
}
cout << x + y << '\n';
return 0;
} | replace | 207 | 218 | 207 | 226 | TLE | |
p03039 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
const int INF = 1e9;
const int MOD = 1e9 + 7;
const long long LINF = 1e18;
#define dump(x) cout << 'x' << ' = ' << (x) << ` `;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOREACH(x, a) for (auto &(x) : (a))
typedef long long ll;
using namespace std;
typedef pair<ll, ll> P;
template <typename T> void print(const vector<T> &x) {
int n = x.size();
rep(i, n) {
cout << x[i];
if (i != n - 1)
cout << " ";
else
cout << endl;
}
}
template <typename T> void print(const vector<vector<T>> &x) {
int n = x.size();
rep(i, n) {
rep(j, x[i].size()) { cout << x[i][j] << " "; }
cout << endl;
}
}
template <typename T> void print(const vector<T> &x, int n) {
rep(i, n) {
cout << x[i];
if (i != n - 1)
cout << " ";
else
cout << endl;
}
}
template <typename T> void print(const vector<vector<T>> &x, int n, int m) {
rep(i, n) {
rep(j, m) { cout << x[i][j] << " "; }
cout << endl;
}
}
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;
}
void input_init() {
cin.tie(0);
ios::sync_with_stdio(false);
}
template <int mod> struct ModInt {
int x;
ModInt() : x(0) {}
ModInt(int64_t y) : x(y >= 0 ? y % mod : (mod - (-y) % mod) % mod) {}
ModInt &operator+=(const ModInt &p) {
if ((x += p.x) >= mod)
x -= mod;
return *this;
}
ModInt &operator-=(const ModInt &p) {
if ((x += mod - p.x) >= mod)
x -= mod;
return *this;
}
ModInt &operator*=(const ModInt &p) {
x = (int)(1LL * x * p.x % mod);
return *this;
}
ModInt &operator/=(const ModInt &p) {
*this *= p.inverse();
return *this;
}
ModInt operator-() const { return ModInt(-x); }
ModInt operator+(const ModInt &p) const { return ModInt(*this) += p; }
ModInt operator-(const ModInt &p) const { return ModInt(*this) -= p; }
ModInt operator*(const ModInt &p) const { return ModInt(*this) *= p; }
ModInt operator/(const ModInt &p) const { return ModInt(*this) /= p; }
bool operator==(const ModInt &p) const { return x == p.x; }
bool operator!=(const ModInt &p) const { return x != p.x; }
ModInt inverse() const {
int a = x, b = mod, u = 1, v = 0, t;
while (b > 0) {
t = a / b;
swap(a -= t * b, b);
swap(u -= t * v, v);
}
return ModInt(u);
}
ModInt pow(int64_t n) const {
ModInt ret(1), mul(x);
while (n > 0) {
if (n & 1)
ret *= mul;
mul *= mul;
n >>= 1;
}
return ret;
}
friend ostream &operator<<(ostream &os, const ModInt &p) { return os << p.x; }
friend istream &operator>>(istream &is, ModInt &a) {
int64_t t;
is >> t;
a = ModInt<mod>(t);
return (is);
}
static int get_mod() { return mod; }
};
using modint = ModInt<MOD>;
class combM {
private:
vector<ll> fac; // n!(mod M)
vector<ll> ifac; // k!^{M-2} (mod M)
ll mpow(ll x, ll n);
public:
combM();
ll com(ll a, ll b);
};
// x^n(mod M)
ll combM::mpow(ll x, ll n) {
ll ans = 1ll;
while (n != 0) {
if (n & 1)
ans = ans * x % MOD;
x = x * x % MOD;
n = n >> 1;
}
return ans;
}
// aCb をmod計算
ll combM::com(ll a, ll b) {
if (a == 0 && b == 0)
return 1;
if (a < b || a < 0)
return 0;
ll tmp = ifac[a - b] * ifac[b] % MOD;
return tmp * fac[a] % MOD;
}
combM::combM() {
fac.resize(300001);
ifac.resize(300001);
fac[0] = 1;
ifac[0] = 1;
for (ll i = 0; i < 300000; ++i) {
fac[i + 1] = fac[i] * (i + 1) % MOD;
ifac[i + 1] = ifac[i] * mpow(i + 1, MOD - 2) % MOD;
}
}
modint calc(ll n, ll m, modint all) {
modint ret = 0;
for (int i = 1; i < n; ++i) {
for (int j = i; j <= n; ++j) {
modint tmp = abs(i - j) * m * m;
ret += tmp * all;
}
}
return ret;
}
int main(int argc, char const *argv[]) {
ll n, m, k;
cin >> n >> m >> k;
modint ans = 0;
combM C;
modint all_nm = C.com(n * m - 2, k - 2);
ans += calc(n, m, all_nm);
ans += calc(m, n, all_nm);
cout << ans << '\n';
return 0;
} | #include <bits/stdc++.h>
const int INF = 1e9;
const int MOD = 1e9 + 7;
const long long LINF = 1e18;
#define dump(x) cout << 'x' << ' = ' << (x) << ` `;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOREACH(x, a) for (auto &(x) : (a))
typedef long long ll;
using namespace std;
typedef pair<ll, ll> P;
template <typename T> void print(const vector<T> &x) {
int n = x.size();
rep(i, n) {
cout << x[i];
if (i != n - 1)
cout << " ";
else
cout << endl;
}
}
template <typename T> void print(const vector<vector<T>> &x) {
int n = x.size();
rep(i, n) {
rep(j, x[i].size()) { cout << x[i][j] << " "; }
cout << endl;
}
}
template <typename T> void print(const vector<T> &x, int n) {
rep(i, n) {
cout << x[i];
if (i != n - 1)
cout << " ";
else
cout << endl;
}
}
template <typename T> void print(const vector<vector<T>> &x, int n, int m) {
rep(i, n) {
rep(j, m) { cout << x[i][j] << " "; }
cout << endl;
}
}
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;
}
void input_init() {
cin.tie(0);
ios::sync_with_stdio(false);
}
template <int mod> struct ModInt {
int x;
ModInt() : x(0) {}
ModInt(int64_t y) : x(y >= 0 ? y % mod : (mod - (-y) % mod) % mod) {}
ModInt &operator+=(const ModInt &p) {
if ((x += p.x) >= mod)
x -= mod;
return *this;
}
ModInt &operator-=(const ModInt &p) {
if ((x += mod - p.x) >= mod)
x -= mod;
return *this;
}
ModInt &operator*=(const ModInt &p) {
x = (int)(1LL * x * p.x % mod);
return *this;
}
ModInt &operator/=(const ModInt &p) {
*this *= p.inverse();
return *this;
}
ModInt operator-() const { return ModInt(-x); }
ModInt operator+(const ModInt &p) const { return ModInt(*this) += p; }
ModInt operator-(const ModInt &p) const { return ModInt(*this) -= p; }
ModInt operator*(const ModInt &p) const { return ModInt(*this) *= p; }
ModInt operator/(const ModInt &p) const { return ModInt(*this) /= p; }
bool operator==(const ModInt &p) const { return x == p.x; }
bool operator!=(const ModInt &p) const { return x != p.x; }
ModInt inverse() const {
int a = x, b = mod, u = 1, v = 0, t;
while (b > 0) {
t = a / b;
swap(a -= t * b, b);
swap(u -= t * v, v);
}
return ModInt(u);
}
ModInt pow(int64_t n) const {
ModInt ret(1), mul(x);
while (n > 0) {
if (n & 1)
ret *= mul;
mul *= mul;
n >>= 1;
}
return ret;
}
friend ostream &operator<<(ostream &os, const ModInt &p) { return os << p.x; }
friend istream &operator>>(istream &is, ModInt &a) {
int64_t t;
is >> t;
a = ModInt<mod>(t);
return (is);
}
static int get_mod() { return mod; }
};
using modint = ModInt<MOD>;
class combM {
private:
vector<ll> fac; // n!(mod M)
vector<ll> ifac; // k!^{M-2} (mod M)
ll mpow(ll x, ll n);
public:
combM();
ll com(ll a, ll b);
};
// x^n(mod M)
ll combM::mpow(ll x, ll n) {
ll ans = 1ll;
while (n != 0) {
if (n & 1)
ans = ans * x % MOD;
x = x * x % MOD;
n = n >> 1;
}
return ans;
}
// aCb をmod計算
ll combM::com(ll a, ll b) {
if (a == 0 && b == 0)
return 1;
if (a < b || a < 0)
return 0;
ll tmp = ifac[a - b] * ifac[b] % MOD;
return tmp * fac[a] % MOD;
}
combM::combM() {
fac.resize(300001);
ifac.resize(300001);
fac[0] = 1;
ifac[0] = 1;
for (ll i = 0; i < 300000; ++i) {
fac[i + 1] = fac[i] * (i + 1) % MOD;
ifac[i + 1] = ifac[i] * mpow(i + 1, MOD - 2) % MOD;
}
}
modint calc(ll n, ll m, modint all_nm) {
modint pair_sum = 0;
for (ll i = n - 1; i >= 1; --i) {
modint tmp = i;
modint M = m * m;
tmp *= (n - i);
tmp *= M;
pair_sum += tmp;
}
modint ret = all_nm * pair_sum;
return ret;
}
int main(int argc, char const *argv[]) {
ll n, m, k;
cin >> n >> m >> k;
modint ans = 0;
combM C;
modint all_nm = C.com(n * m - 2, k - 2);
ans += calc(n, m, all_nm);
ans += calc(m, n, all_nm);
cout << ans << '\n';
return 0;
} | replace | 191 | 199 | 191 | 201 | TLE | |
p03039 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vll = vector<ll>;
using vvll = vector<vll>;
using vvvll = vector<vvll>;
#define REP(i, n, m) for (ll i = n; i < (ll)m; ++i)
#define IREP(i, n, m) for (ll i = n - 1; i >= m; --i)
#define rep(i, n) REP(i, 0, n)
#define irep(i, n) IREP(i, n, 0)
#define all(v) v.begin(), v.end()
ll pow_mod(ll n, ll m, ll mod = 1000000007) {
ll a = 1;
while (m > 0) {
if (m & 1)
a = a * n % mod;
n = n * n % mod;
m >>= 1;
}
return a;
}
ll combi(ll n, ll m, ll mod = 1000000007) {
static const ll N_MAX = 100000;
static vll fac(N_MAX + 1, -1);
static vll ifac(N_MAX + 1, -1);
if (fac[0] < 0) {
fac[0] = ifac[0] = 1;
rep(i, N_MAX) {
fac[i + 1] = fac[i] * (i + 1) % mod;
ifac[i + 1] = ifac[i] * pow_mod(i + 1, mod - 2, mod) % mod;
}
}
if (n <= 0 && m <= 0)
return 1;
if (n < m || n < 0)
return 0;
return (ifac[n - m] * ifac[m] % mod) * fac[n] % mod;
}
int main() {
cout << setprecision(20);
ll n, m, k;
cin >> n >> m >> k;
ll count = 0;
REP(d, 1, n) {
ll a = d * (n - d) * m * m % 1000000007;
a = a * combi(n * m - 2, k - 2) % 1000000007;
count = (count + a) % 1000000007;
}
REP(d, 1, m) {
ll a = d * (m - d) * n * n % 1000000007;
a = a * combi(n * m - 2, k - 2) % 1000000007;
count = (count + a) % 1000000007;
}
cout << count << endl;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vll = vector<ll>;
using vvll = vector<vll>;
using vvvll = vector<vvll>;
#define REP(i, n, m) for (ll i = n; i < (ll)m; ++i)
#define IREP(i, n, m) for (ll i = n - 1; i >= m; --i)
#define rep(i, n) REP(i, 0, n)
#define irep(i, n) IREP(i, n, 0)
#define all(v) v.begin(), v.end()
ll pow_mod(ll n, ll m, ll mod = 1000000007) {
ll a = 1;
while (m > 0) {
if (m & 1)
a = a * n % mod;
n = n * n % mod;
m >>= 1;
}
return a;
}
ll combi(ll n, ll m, ll mod = 1000000007) {
static const ll N_MAX = 200000;
static vll fac(N_MAX + 1, -1);
static vll ifac(N_MAX + 1, -1);
if (fac[0] < 0) {
fac[0] = ifac[0] = 1;
rep(i, N_MAX) {
fac[i + 1] = fac[i] * (i + 1) % mod;
ifac[i + 1] = ifac[i] * pow_mod(i + 1, mod - 2, mod) % mod;
}
}
if (n <= 0 && m <= 0)
return 1;
if (n < m || n < 0)
return 0;
return (ifac[n - m] * ifac[m] % mod) * fac[n] % mod;
}
int main() {
cout << setprecision(20);
ll n, m, k;
cin >> n >> m >> k;
ll count = 0;
REP(d, 1, n) {
ll a = d * (n - d) * m * m % 1000000007;
a = a * combi(n * m - 2, k - 2) % 1000000007;
count = (count + a) % 1000000007;
}
REP(d, 1, m) {
ll a = d * (m - d) * n * n % 1000000007;
a = a * combi(n * m - 2, k - 2) % 1000000007;
count = (count + a) % 1000000007;
}
cout << count << endl;
}
| replace | 26 | 27 | 26 | 27 | 0 | |
p03039 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, N) for (int i = 0; i < (int)N; ++i)
#define all(a) (a).begin(), (a).end()
template <int MOD> class ModInt {
long long x;
public:
ModInt(long long v = 0) : x(v % MOD) {
if (x < 0)
x += MOD;
}
ModInt &operator+=(const ModInt &r) {
x += r.x;
if (x >= MOD)
x -= MOD;
return *this;
}
ModInt &operator-=(const ModInt &r) {
x -= r.x;
if (x < 0)
x += MOD;
return *this;
}
ModInt &operator*=(const ModInt &r) {
x = (x * r.x) % MOD;
return *this;
}
ModInt &operator/=(const ModInt &r) {
*this *= r.inverse();
return *this;
}
ModInt operator-() const { return ModInt(-x); }
ModInt operator+(const ModInt &r) const { return ModInt(*this) += r; }
ModInt operator-(const ModInt &r) const { return ModInt(*this) -= r; }
ModInt operator*(const ModInt &r) const { return ModInt(*this) *= r; }
ModInt operator/(const ModInt &r) const { return ModInt(*this) /= r; }
bool operator==(const ModInt &r) const { return x == r.x; }
bool operator!=(const ModInt &r) const { return x != r.x; }
ModInt inverse() const {
long long a = x, b = MOD, u = 1, v = 0, t;
while (b > 0) {
t = a / b;
swap(a -= t * b, b);
swap(u -= t * v, v);
}
return ModInt(u);
}
ModInt<MOD> pow(long long n) const {
ModInt ret(1), mul(x);
while (n > 0) {
if (n & 1)
ret *= mul;
mul *= mul;
n >>= 1;
}
return ret;
}
friend ostream &operator<<(ostream &os, const ModInt &x) { return os << x.x; }
friend istream &operator>>(istream &is, ModInt &x) { return is >> x.x; }
int getMod() { return MOD; }
long long val() { return x; }
};
using mint = ModInt<1000000007>;
int N, M, K;
int main() {
cin >> N >> M >> K;
vector<mint> fact(N * M - 1), ifact(N * M - 1);
fact[0] = 1;
rep(i, N * M) fact[i + 1] = fact[i] * (i + 1);
rep(i, N * M - 1) ifact[i] = fact[i].inverse();
auto comb = [&](int n, int k) { return fact[n] * ifact[k] * ifact[n - k]; };
mint ans = 0;
rep(i, M) ans += comb(N * M - 2, K - 2) * i * (M - i) * N * N;
rep(i, N) ans += comb(N * M - 2, K - 2) * i * (N - i) * M * M;
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, N) for (int i = 0; i < (int)N; ++i)
#define all(a) (a).begin(), (a).end()
template <int MOD> class ModInt {
long long x;
public:
ModInt(long long v = 0) : x(v % MOD) {
if (x < 0)
x += MOD;
}
ModInt &operator+=(const ModInt &r) {
x += r.x;
if (x >= MOD)
x -= MOD;
return *this;
}
ModInt &operator-=(const ModInt &r) {
x -= r.x;
if (x < 0)
x += MOD;
return *this;
}
ModInt &operator*=(const ModInt &r) {
x = (x * r.x) % MOD;
return *this;
}
ModInt &operator/=(const ModInt &r) {
*this *= r.inverse();
return *this;
}
ModInt operator-() const { return ModInt(-x); }
ModInt operator+(const ModInt &r) const { return ModInt(*this) += r; }
ModInt operator-(const ModInt &r) const { return ModInt(*this) -= r; }
ModInt operator*(const ModInt &r) const { return ModInt(*this) *= r; }
ModInt operator/(const ModInt &r) const { return ModInt(*this) /= r; }
bool operator==(const ModInt &r) const { return x == r.x; }
bool operator!=(const ModInt &r) const { return x != r.x; }
ModInt inverse() const {
long long a = x, b = MOD, u = 1, v = 0, t;
while (b > 0) {
t = a / b;
swap(a -= t * b, b);
swap(u -= t * v, v);
}
return ModInt(u);
}
ModInt<MOD> pow(long long n) const {
ModInt ret(1), mul(x);
while (n > 0) {
if (n & 1)
ret *= mul;
mul *= mul;
n >>= 1;
}
return ret;
}
friend ostream &operator<<(ostream &os, const ModInt &x) { return os << x.x; }
friend istream &operator>>(istream &is, ModInt &x) { return is >> x.x; }
int getMod() { return MOD; }
long long val() { return x; }
};
using mint = ModInt<1000000007>;
int N, M, K;
int main() {
cin >> N >> M >> K;
vector<mint> fact(N * M - 1), ifact(N * M - 1);
fact[0] = 1;
rep(i, N * M - 2) fact[i + 1] = fact[i] * (i + 1);
rep(i, N * M - 1) ifact[i] = fact[i].inverse();
auto comb = [&](int n, int k) { return fact[n] * ifact[k] * ifact[n - k]; };
mint ans = 0;
rep(i, M) ans += comb(N * M - 2, K - 2) * i * (M - i) * N * N;
rep(i, N) ans += comb(N * M - 2, K - 2) * i * (N - i) * M * M;
cout << ans << endl;
return 0;
}
| replace | 84 | 85 | 84 | 85 | -6 | munmap_chunk(): invalid pointer
|
p03039 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i, l, r) for (int i = (int)(l); i < (int)(r); i++)
#define all(x) (x).begin(), (x).end()
#define pb push_back
template <class T> bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<vi> vvi;
const int inf = 1LL << 60;
const int mod = 1e9 + 7;
const double eps = 1e-9;
/*{
}*/
template <int M> class Combination {
public:
int n;
vector<int> fac, finv;
Combination(int n_) : n(n_), fac(n_), finv(n_) {
fac[0] = 1;
for (int i = 1; i < n; i++)
fac[i] = fac[i - 1] * i % M;
finv[n - 1] = pow(fac[n - 1], M - 2);
for (int i = n - 1; i > 0; i--)
finv[i - 1] = finv[i] * i % M;
}
int pow(int a, int b) {
if (b == 0)
return 1;
return pow(a * a % M, b / 2) * (b % 2 ? a : 1) % M;
}
int C(int a, int b) {
if (b < 0 or a < b)
return 0;
return fac[a] * finv[a - b] % M * finv[b] % M;
}
int P(int a, int b) {
if (b < 0 or a < b)
return 0;
return fac[a] * finv[a - b] % M;
}
int H(int a, int b) {
if (a == 0 and b == 0)
return 1;
return C(a + b - 1, b);
}
};
signed main() {
Combination<mod> comb(100010);
int n, m, k;
cin >> n >> m >> k;
int ans = 0;
rep(i, 0, n) {
int d = i * (i + 1) / 2 % mod;
d = d * m % mod * m % mod;
ans += d;
}
rep(i, 0, m) {
int d = i * (i + 1) / 2 % mod;
d = d * n % mod * n % mod;
ans += d;
}
cout << ans % mod * comb.C(n * m - 2, k - 2) % mod << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i, l, r) for (int i = (int)(l); i < (int)(r); i++)
#define all(x) (x).begin(), (x).end()
#define pb push_back
template <class T> bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<vi> vvi;
const int inf = 1LL << 60;
const int mod = 1e9 + 7;
const double eps = 1e-9;
/*{
}*/
template <int M> class Combination {
public:
int n;
vector<int> fac, finv;
Combination(int n_) : n(n_), fac(n_), finv(n_) {
fac[0] = 1;
for (int i = 1; i < n; i++)
fac[i] = fac[i - 1] * i % M;
finv[n - 1] = pow(fac[n - 1], M - 2);
for (int i = n - 1; i > 0; i--)
finv[i - 1] = finv[i] * i % M;
}
int pow(int a, int b) {
if (b == 0)
return 1;
return pow(a * a % M, b / 2) * (b % 2 ? a : 1) % M;
}
int C(int a, int b) {
if (b < 0 or a < b)
return 0;
return fac[a] * finv[a - b] % M * finv[b] % M;
}
int P(int a, int b) {
if (b < 0 or a < b)
return 0;
return fac[a] * finv[a - b] % M;
}
int H(int a, int b) {
if (a == 0 and b == 0)
return 1;
return C(a + b - 1, b);
}
};
signed main() {
Combination<mod> comb(200010);
int n, m, k;
cin >> n >> m >> k;
int ans = 0;
rep(i, 0, n) {
int d = i * (i + 1) / 2 % mod;
d = d * m % mod * m % mod;
ans += d;
}
rep(i, 0, m) {
int d = i * (i + 1) / 2 % mod;
d = d * n % mod * n % mod;
ans += d;
}
cout << ans % mod * comb.C(n * m - 2, k - 2) % mod << endl;
return 0;
}
| replace | 73 | 74 | 73 | 74 | 0 | |
p03039 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define _GLIBCXX_DEBUG
#define rep2(i, m, n) for (int i = int(m); i < int(n); i++)
#define rep(i, n) rep2(i, 0, n)
#define all(a) a.begin(), a.end()
using ll = long long;
using ld = long double;
using V = vector<int>;
using Vll = vector<ll>;
using Vld = vector<ld>;
using VV = vector<V>;
using VVll = vector<Vll>;
using VVld = vector<Vld>;
using P = pair<int, int>;
using Pll = pair<ll, ll>;
using Pld = pair<ld, ld>;
const int INF = 1 << 30;
const ll INFll = 1ll << 62;
const ld EPS = 1e-10;
const int MOD = int(1e9) + 7;
template <typename T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
// initialization
const int MAX = int(2e2) + 10;
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;
}
}
// binom mod 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() {
// initialize
COMinit();
ll n, m, k;
cin >> n >> m >> k;
ll ans = 0;
ll a = (((m * m) % MOD) * COM(n + 1, 3)) % MOD;
ll b = (((n * n) % MOD) * COM(m + 1, 3)) % MOD;
ans = (a + b) % MOD;
// ans *= COM(k, 2);
// ans %= MOD;
ans *= COM(m * n - 2, k - 2);
ans %= MOD;
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define _GLIBCXX_DEBUG
#define rep2(i, m, n) for (int i = int(m); i < int(n); i++)
#define rep(i, n) rep2(i, 0, n)
#define all(a) a.begin(), a.end()
using ll = long long;
using ld = long double;
using V = vector<int>;
using Vll = vector<ll>;
using Vld = vector<ld>;
using VV = vector<V>;
using VVll = vector<Vll>;
using VVld = vector<Vld>;
using P = pair<int, int>;
using Pll = pair<ll, ll>;
using Pld = pair<ld, ld>;
const int INF = 1 << 30;
const ll INFll = 1ll << 62;
const ld EPS = 1e-10;
const int MOD = int(1e9) + 7;
template <typename T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
// initialization
const int MAX = int(2e5) + 10;
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;
}
}
// binom mod 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() {
// initialize
COMinit();
ll n, m, k;
cin >> n >> m >> k;
ll ans = 0;
ll a = (((m * m) % MOD) * COM(n + 1, 3)) % MOD;
ll b = (((n * n) % MOD) * COM(m + 1, 3)) % MOD;
ans = (a + b) % MOD;
// ans *= COM(k, 2);
// ans %= MOD;
ans *= COM(m * n - 2, k - 2);
ans %= MOD;
cout << ans << endl;
return 0;
} | replace | 37 | 38 | 37 | 38 | 0 | |
p03039 | C++ | Runtime Error | #include <iostream>
#include <vector>
using namespace std;
#define int long long
int INF = 1e9 + 7;
int myPow(int n, int m) {
int res = 1;
while (m > 0) {
if (m & 1) {
res *= n;
res %= INF;
}
n = n * n % INF;
m >>= 1;
}
return res;
}
// n^(INF-2)
int invMod(int n) { return myPow(n, INF - 2); }
vector<int> frac((int)1e5);
void set_frac() {
frac[0] = 1;
for (int i = 1; i < frac.size(); i++) {
frac[i] = frac[i - 1] * i % INF;
}
}
// nCm = n!/m!/(n-m)!
int comb(int n, int m) {
int res = frac[n];
res = res * invMod(frac[m]) % INF;
res = res * invMod(frac[n - m]) % INF;
return res;
}
signed main() {
int N, M, K;
cin >> N >> M >> K;
int sum_cost = 0;
for (int i = 1; i < M; i++) {
for (int j = 1; j < N; j++) {
// diag
sum_cost += (i + j) * (M - i) * (N - j) * 2;
sum_cost %= INF;
}
}
for (int i = 1; i < N; i++) {
sum_cost += i * M * (N - i);
sum_cost %= INF;
}
for (int i = 1; i < M; i++) {
sum_cost += i * N * (M - i);
sum_cost %= INF;
}
set_frac();
cout << sum_cost * comb(N * M - 2, K - 2) % INF << endl;
} | #include <iostream>
#include <vector>
using namespace std;
#define int long long
int INF = 1e9 + 7;
int myPow(int n, int m) {
int res = 1;
while (m > 0) {
if (m & 1) {
res *= n;
res %= INF;
}
n = n * n % INF;
m >>= 1;
}
return res;
}
// n^(INF-2)
int invMod(int n) { return myPow(n, INF - 2); }
vector<int> frac((int)1e6);
void set_frac() {
frac[0] = 1;
for (int i = 1; i < frac.size(); i++) {
frac[i] = frac[i - 1] * i % INF;
}
}
// nCm = n!/m!/(n-m)!
int comb(int n, int m) {
int res = frac[n];
res = res * invMod(frac[m]) % INF;
res = res * invMod(frac[n - m]) % INF;
return res;
}
signed main() {
int N, M, K;
cin >> N >> M >> K;
int sum_cost = 0;
for (int i = 1; i < M; i++) {
for (int j = 1; j < N; j++) {
// diag
sum_cost += (i + j) * (M - i) * (N - j) * 2;
sum_cost %= INF;
}
}
for (int i = 1; i < N; i++) {
sum_cost += i * M * (N - i);
sum_cost %= INF;
}
for (int i = 1; i < M; i++) {
sum_cost += i * N * (M - i);
sum_cost %= INF;
}
set_frac();
cout << sum_cost * comb(N * M - 2, K - 2) % INF << endl;
} | replace | 25 | 26 | 25 | 26 | 0 | |
p03039 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
const ll MOD = 1e9 + 7;
ll kai[200001];
ll gyaku[200001];
// aのp乗を求める
ll jou(ll a, ll p) {
ll ret = 1;
ll b2[40];
b2[0] = a;
for (int i = 1; i < 40; i++) {
b2[i] = b2[i - 1] * b2[i - 1];
b2[i] %= MOD;
if (b2[i] < 0)
b2[i] += MOD;
}
for (ll bit = 0; bit < 40; bit++) {
ll tmp = (p & (1LL << bit));
if (tmp > 0) {
ret *= b2[bit];
ret %= MOD;
if (ret < 0)
ret += MOD;
}
}
return ret;
}
int main() {
int n, m, k;
ll ans = 0;
int cnt = 0;
cin >> n >> m >> k;
// 階乗
kai[0] = 1;
for (ll i = 1; i < 200001; i++) {
kai[i] = kai[i - 1] * i;
kai[i] %= MOD;
if (kai[i] < 0)
kai[i] += MOD;
}
// 逆元
for (int i = 0; i < 200001; i++)
gyaku[i] = jou(kai[i], MOD - 2);
for (int i = 0; i < n * m; i++) {
for (int j = i + 1; j < n * m; j++) {
ll tmp = abs(i % m - j % m) + abs(i / m - j / m); // コストを求める
// cerr<<tmp<<" ";
tmp *= kai[n * m - 2];
tmp %= MOD;
tmp *= gyaku[k - 2];
tmp %= MOD;
tmp *= gyaku[n * m - k];
tmp %= MOD;
// cerr<<tmp<<endl;
if (tmp < 0)
tmp += MOD;
ans += tmp;
ans %= MOD;
}
}
if (ans < 0)
ans += MOD;
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
const ll MOD = 1e9 + 7;
ll kai[200001];
ll gyaku[200001];
// aのp乗を求める
ll jou(ll a, ll p) {
ll ret = 1;
ll b2[40];
b2[0] = a;
for (int i = 1; i < 40; i++) {
b2[i] = b2[i - 1] * b2[i - 1];
b2[i] %= MOD;
if (b2[i] < 0)
b2[i] += MOD;
}
for (ll bit = 0; bit < 40; bit++) {
ll tmp = (p & (1LL << bit));
if (tmp > 0) {
ret *= b2[bit];
ret %= MOD;
if (ret < 0)
ret += MOD;
}
}
return ret;
}
int main() {
int n, m, k;
ll ans = 0;
int cnt = 0;
cin >> n >> m >> k;
// 階乗
kai[0] = 1;
for (ll i = 1; i < 200001; i++) {
kai[i] = kai[i - 1] * i;
kai[i] %= MOD;
if (kai[i] < 0)
kai[i] += MOD;
}
// 逆元
for (int i = 0; i < 200001; i++)
gyaku[i] = jou(kai[i], MOD - 2);
for (int i = 1; i < n * m; i++) {
ll tmp = abs(i % m - 0 % m) + abs(i / m - 0 / m); // コストを求める
// cerr<<tmp<<" ";
tmp *= kai[n * m - 2];
tmp %= MOD;
tmp *= gyaku[k - 2];
tmp %= MOD;
tmp *= gyaku[n * m - k];
tmp %= MOD;
// cerr<<tmp<<endl;
// 個数はこの四角形が入る個数分
tmp *= (ll)(m - i % m);
tmp %= MOD;
tmp *= (ll)(n - i / m);
tmp %= MOD;
if (i % m > 0 && i / m > 0)
tmp *= 2;
tmp %= MOD;
if (tmp < 0)
tmp += MOD;
ans += tmp;
ans %= MOD;
}
if (ans < 0)
ans += MOD;
cout << ans << endl;
return 0;
} | replace | 53 | 69 | 53 | 75 | TLE | |
p03039 | C++ | Time Limit Exceeded |
#include <algorithm>
#include <cstdio>
#include <iostream>
#include <queue>
#include <vector>
#define REP(i, n) for (int i = 0; i < (int)(n); ++i)
using namespace std;
typedef long long ll;
const ll MOD = 1000000007;
const int N = 200000;
ll fac[N * 2 + 10];
ll invfac[N * 2 + 10];
ll mypow(ll x, ll n) {
if (n == 0)
return 1;
if (n % 2 == 0)
return mypow(x * x % MOD, n / 2);
return mypow(x * x % MOD, n / 2) * x % MOD;
}
inline ll cmb(ll n, ll k) {
if (k < 0 || n < k)
return 0;
return fac[n] * invfac[k] % MOD * invfac[n - k] % MOD;
}
int main(void) {
fac[0] = 1;
REP(i, N * 2) { fac[i + 1] = fac[i] * (i + 1) % MOD; }
invfac[N * 2] = mypow(fac[N * 2], MOD - 2);
for (int i = N * 2; i > 0; --i) {
invfac[i - 1] = invfac[i] * i % MOD;
}
ll n, m, k;
cin >> n >> m >> k;
ll res = 0;
for (ll d = 1; d <= n + m - 2; ++d) {
ll num = 0;
REP(i, d + 1) {
num = (num + max(0LL, (n - i) * (m - d + i))) % MOD;
if (i != 0 && i != d) {
num = (num + max(0LL, (n - i) * (m - d + i))) % MOD;
}
}
res = (res + num * d) % MOD;
}
cout << res * cmb(n * m - 2, k - 2) % MOD << endl;
return 0;
}
|
#include <algorithm>
#include <cstdio>
#include <iostream>
#include <queue>
#include <vector>
#define REP(i, n) for (int i = 0; i < (int)(n); ++i)
using namespace std;
typedef long long ll;
const ll MOD = 1000000007;
const int N = 200000;
ll fac[N * 2 + 10];
ll invfac[N * 2 + 10];
ll mypow(ll x, ll n) {
if (n == 0)
return 1;
if (n % 2 == 0)
return mypow(x * x % MOD, n / 2);
return mypow(x * x % MOD, n / 2) * x % MOD;
}
inline ll cmb(ll n, ll k) {
if (k < 0 || n < k)
return 0;
return fac[n] * invfac[k] % MOD * invfac[n - k] % MOD;
}
int main(void) {
fac[0] = 1;
REP(i, N * 2) { fac[i + 1] = fac[i] * (i + 1) % MOD; }
invfac[N * 2] = mypow(fac[N * 2], MOD - 2);
for (int i = N * 2; i > 0; --i) {
invfac[i - 1] = invfac[i] * i % MOD;
}
ll n, m, k;
cin >> n >> m >> k;
ll res = 0;
for (ll d = 1; d <= n - 1; ++d) {
res = (res + d * m % MOD * m % MOD * (n - d) % MOD) % MOD;
}
for (ll d = 1; d <= m - 1; ++d) {
res = (res + d * n % MOD * n % MOD * (m - d) % MOD) % MOD;
}
cout << res * cmb(n * m - 2, k - 2) % MOD << endl;
return 0;
}
| replace | 40 | 49 | 40 | 45 | TLE | |
p03039 | C++ | Runtime Error | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define rep(i, s, n) for (int i = s; i < (int)(n); i++)
typedef long long int ll;
using namespace std;
// 分割数
ll n;
const int MAX_N = 100010;
const int M = 1000000007;
ll f[MAX_N], rf[MAX_N];
ll inv(ll x) {
ll res = 1;
ll k = M - 2;
ll y = x;
while (k) {
if (k & 1)
res = (res * y) % M;
y = (y * y) % M;
k /= 2;
}
return res;
}
void init() {
f[0] = 1;
rep(i, 1, MAX_N) f[i] = (f[i - 1] * i) % M;
rep(i, 0, MAX_N) rf[i] = inv(f[i]);
}
//---------------------------------------------------------------------------------------------------
ll C(int n, int k) {
ll a = f[n]; // = n!
ll b = rf[n - k]; // = (n-k)!
ll c = rf[k]; // = k!
ll bc = (b * c) % M;
return (a * bc) % M;
}
int main() {
init();
ll k, m;
cin >> n >> m >> k;
ll x = 0;
ll y = 0;
REP(i, m) {
ll t = (i * (m - i)) % M;
t = (t * ((n * n) % M)) % M;
x += t;
x %= M;
}
x *= C(n * m - 2, k - 2);
x %= M;
REP(i, n) {
ll t = (i * (n - i)) % M;
t = (t * ((m * m) % M)) % M;
y += t;
y %= M;
}
y *= C(n * m - 2, k - 2);
cout << (x + y) % M << endl;
} | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define rep(i, s, n) for (int i = s; i < (int)(n); i++)
typedef long long int ll;
using namespace std;
// 分割数
ll n;
const int MAX_N = 200010;
const int M = 1000000007;
ll f[MAX_N], rf[MAX_N];
ll inv(ll x) {
ll res = 1;
ll k = M - 2;
ll y = x;
while (k) {
if (k & 1)
res = (res * y) % M;
y = (y * y) % M;
k /= 2;
}
return res;
}
void init() {
f[0] = 1;
rep(i, 1, MAX_N) f[i] = (f[i - 1] * i) % M;
rep(i, 0, MAX_N) rf[i] = inv(f[i]);
}
//---------------------------------------------------------------------------------------------------
ll C(int n, int k) {
ll a = f[n]; // = n!
ll b = rf[n - k]; // = (n-k)!
ll c = rf[k]; // = k!
ll bc = (b * c) % M;
return (a * bc) % M;
}
int main() {
init();
ll k, m;
cin >> n >> m >> k;
ll x = 0;
ll y = 0;
REP(i, m) {
ll t = (i * (m - i)) % M;
t = (t * ((n * n) % M)) % M;
x += t;
x %= M;
}
x *= C(n * m - 2, k - 2);
x %= M;
REP(i, n) {
ll t = (i * (n - i)) % M;
t = (t * ((m * m) % M)) % M;
y += t;
y %= M;
}
y *= C(n * m - 2, k - 2);
cout << (x + y) % M << endl;
} | replace | 7 | 8 | 7 | 8 | 0 | |
p03039 | Python | Time Limit Exceeded | import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10**9)
INF = 1 << 60
MOD = 1000000007
def main():
N, M, K = map(int, readline().split())
COM_MAX = N * M
fac, finv, inv = [0] * (COM_MAX + 1), [0] * (COM_MAX + 1), [0] * (COM_MAX + 1)
fac[0] = fac[1] = finv[0] = finv[1] = inv[1] = 1
for i in range(2, COM_MAX + 1):
fac[i] = fac[i - 1] * i % MOD
inv[i] = MOD - inv[MOD % i] * (MOD // i) % MOD
finv[i] = finv[i - 1] * inv[i] % MOD
def com(n, r):
if n < 0 or r < 0 or n < r:
return 0
return fac[n] * (finv[r] * finv[n - r] % MOD) % MOD
def solve(n, m, k):
ans = 0
for j in range(1, k):
tmp = 0
for i in range(1, n):
tmp = (tmp + com(m * i, j) * com(m * (n - i), k - j)) % MOD
ans = (ans + tmp * j * (k - j)) % MOD
return ans
ans = (solve(N, M, K) + solve(M, N, K)) % MOD
print(ans)
return
if __name__ == "__main__":
main()
| import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10**9)
INF = 1 << 60
MOD = 1000000007
def main():
N, M, K = map(int, readline().split())
COM_MAX = N * M
fac, finv, inv = [0] * (COM_MAX + 1), [0] * (COM_MAX + 1), [0] * (COM_MAX + 1)
fac[0] = fac[1] = finv[0] = finv[1] = inv[1] = 1
for i in range(2, COM_MAX + 1):
fac[i] = fac[i - 1] * i % MOD
inv[i] = MOD - inv[MOD % i] * (MOD // i) % MOD
finv[i] = finv[i - 1] * inv[i] % MOD
def com(n, r):
if n < 0 or r < 0 or n < r:
return 0
return fac[n] * (finv[r] * finv[n - r] % MOD) % MOD
def solve(n, m, k):
ans = 0
for d in range(1, n):
ans = (ans + com(n * m - 2, k - 2) * (m**2) * (n - d) * d) % MOD
return ans
ans = (solve(N, M, K) + solve(M, N, K)) % MOD
print(ans)
return
if __name__ == "__main__":
main()
| replace | 30 | 35 | 30 | 32 | TLE | |
p03039 | Python | Time Limit Exceeded | def comb(n, k, mod=10**9 + 7):
from functools import reduce
from operator import mul
k = min(k, n - k)
x = reduce(mul, range(n - k + 1, n + 1), 1) % mod
y = reduce(mul, range(1, k + 1), 1) % mod
return x * pow(y, mod - 2, mod) % mod
def solve(string):
n, m, k = map(int, string.split())
mod = 10**9 + 7
base = n * m * (n + m) * (n * m - 1) // 6 % mod
return str(base * comb(n * m - 2, k - 2) % mod)
if __name__ == "__main__":
print(solve(input()))
| def comb(n, k, mod=10**9 + 7):
from functools import reduce
from operator import mul
k = min(k, n - k)
def calc(x, y):
return x * y % mod
x = reduce(calc, range(n - k + 1, n + 1), 1) % mod
y = reduce(calc, range(1, k + 1), 1) % mod
return x * pow(y, mod - 2, mod) % mod
def solve(string):
n, m, k = map(int, string.split())
mod = 10**9 + 7
base = n * m * (n + m) * (n * m - 1) // 6 % mod
return str(base * comb(n * m - 2, k - 2) % mod)
if __name__ == "__main__":
print(solve(input()))
| replace | 5 | 7 | 5 | 11 | TLE | |
p03039 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
#define MOD (long)(1e9 + 7)
#define MAX 100000
using namespace std;
class modlong;
void computeAll(long n);
modlong modComb(long n, long k);
class modlong {
long val;
const long mod = MOD;
public:
// 初期化 値を引数に与えなかった場合はval=0としておく
modlong(long init = 0) {
while (init < 0)
init += mod; // 0以上であることを保証
val = init % mod;
}
// longへのキャスト operator long()で定義すると modlong +
// longとかができなくなる
long tol() { return this->val; }
// 代入
void operator=(const modlong &r) { this->val = r.val; }
void operator=(const long &r) {
long rr = r;
while (rr < 0)
rr += mod; // 0以上であることを保証
this->val = rr % mod;
}
// 比較
bool operator<(const modlong &r) { return this->val < r.val; }
bool operator>(const modlong &r) { return this->val > r.val; }
bool operator==(const modlong &r) { return this->val == r.val; }
bool operator!=(const modlong &r) { return !(*this == r); }
bool operator<=(const modlong &r) { return !(*this > r); }
bool operator>=(const modlong &r) { return !(*this < r); }
// 足し算; 符号反転; 引き算
modlong operator+(const modlong &r) {
long aval = (this->val + r.val) % mod;
modlong ans(aval);
return ans;
}
modlong operator-() {
long aval = (mod - this->val) % mod;
modlong ans(aval);
return ans;
}
modlong operator-(const modlong &r) {
modlong rr = r;
return *this + (-rr);
}
// かけ算; 逆元; わり算
modlong operator*(const modlong &r) {
long aval = (this->val * r.val) % mod;
modlong ans(aval);
return ans;
}
modlong inv() {
if (*this == 1)
return modlong(1);
modlong p, q = *this, m(0), n(1), r, c;
p.val = mod; // p=modとかくとp.val=mod%mod=0となってしまう
while (q > 1) {
r = p.val % q.val; // r.val=p.val / q.val
// とかくよりもこのほうが代入時に%modされるので安全
c = m.val - n.val * (p.val / q.val);
p = q, q = r, m = n, n = c;
}
return n;
}
modlong operator/(const modlong &r) {
modlong rr = r;
return *this * rr.inv();
}
// ++ -- 前付きと後ろ付き
void operator++() { ++this->val; }
void operator++(int a) { this->val++; }
void operator--() { --this->val; }
void operator--(int a) { this->val--; }
// 四則演算&代入
void operator+=(const modlong &r) { *this = *this + r; }
void operator-=(const modlong &r) { *this = *this - r; }
void operator*=(const modlong &r) { *this = *this * r; }
void operator/=(const modlong &r) { *this = *this / r; }
// べき乗
modlong pow(long n) {
if (n < 0)
return inv().pow(-n); // 逆元の-n乗
else if (n == 0)
return modlong(1);
modlong half = pow(n / 2);
if (n % 2)
return *this * half * half;
else
return half * half;
}
// コンビネーション modCombは少し下に書いてある
modlong C(modlong k) { return modComb(this->val, k.val); }
friend ostream &operator<<(ostream &os, const modlong &out);
friend istream &operator>>(istream &is, modlong &out);
};
// cout、cerr、cin用の演算子たち
ostream &operator<<(ostream &os, const modlong &out) {
os << out.val;
return os;
}
istream &operator>>(istream &is, modlong &in) {
long inl;
is >> inl;
in.val = inl % MOD;
return is;
}
////// 階乗を全て求める -> 二項係数を求める
modlong invs[MAX], facts[MAX], finvs[MAX];
long listlen = 0; // invs, facts, finvsの配列長
void computeAll(long n) {
long i;
if (listlen == 0) {
invs[1] = 1;
facts[0] = 1;
facts[1] = 1;
finvs[0] = 1;
finvs[1] = 1;
i = 2;
} else {
i = listlen;
}
for (; i <= n; i++) {
invs[i] = -invs[MOD % i] * modlong(MOD / i);
facts[i] = facts[i - 1] * i;
finvs[i] = finvs[i - 1] * invs[i];
}
listlen = n + 1; // 次呼び出すときはn+1以降から再開すれば良い
}
modlong modComb(long n, long k) {
if (k < 0 || n < k)
return 0;
if (k == 0 || k == n)
return 1;
if (listlen <= n)
computeAll(n); // 毎回足りない分だけ補う
return facts[n] * finvs[k] * finvs[n - k];
}
int main() {
long n, m, k;
cin >> n >> m >> k;
modlong sum = 0, comb = modComb(n * m - 2, k - 2);
for (long d = 1; d < n; d++)
sum += comb * d * (n - d) * m * m;
for (long d = 1; d < m; d++)
sum += comb * d * (m - d) * n * n;
cout << sum << '\n';
return 0;
}
| #include <algorithm>
#include <iostream>
#define MOD (long)(1e9 + 7)
#define MAX 1000000
using namespace std;
class modlong;
void computeAll(long n);
modlong modComb(long n, long k);
class modlong {
long val;
const long mod = MOD;
public:
// 初期化 値を引数に与えなかった場合はval=0としておく
modlong(long init = 0) {
while (init < 0)
init += mod; // 0以上であることを保証
val = init % mod;
}
// longへのキャスト operator long()で定義すると modlong +
// longとかができなくなる
long tol() { return this->val; }
// 代入
void operator=(const modlong &r) { this->val = r.val; }
void operator=(const long &r) {
long rr = r;
while (rr < 0)
rr += mod; // 0以上であることを保証
this->val = rr % mod;
}
// 比較
bool operator<(const modlong &r) { return this->val < r.val; }
bool operator>(const modlong &r) { return this->val > r.val; }
bool operator==(const modlong &r) { return this->val == r.val; }
bool operator!=(const modlong &r) { return !(*this == r); }
bool operator<=(const modlong &r) { return !(*this > r); }
bool operator>=(const modlong &r) { return !(*this < r); }
// 足し算; 符号反転; 引き算
modlong operator+(const modlong &r) {
long aval = (this->val + r.val) % mod;
modlong ans(aval);
return ans;
}
modlong operator-() {
long aval = (mod - this->val) % mod;
modlong ans(aval);
return ans;
}
modlong operator-(const modlong &r) {
modlong rr = r;
return *this + (-rr);
}
// かけ算; 逆元; わり算
modlong operator*(const modlong &r) {
long aval = (this->val * r.val) % mod;
modlong ans(aval);
return ans;
}
modlong inv() {
if (*this == 1)
return modlong(1);
modlong p, q = *this, m(0), n(1), r, c;
p.val = mod; // p=modとかくとp.val=mod%mod=0となってしまう
while (q > 1) {
r = p.val % q.val; // r.val=p.val / q.val
// とかくよりもこのほうが代入時に%modされるので安全
c = m.val - n.val * (p.val / q.val);
p = q, q = r, m = n, n = c;
}
return n;
}
modlong operator/(const modlong &r) {
modlong rr = r;
return *this * rr.inv();
}
// ++ -- 前付きと後ろ付き
void operator++() { ++this->val; }
void operator++(int a) { this->val++; }
void operator--() { --this->val; }
void operator--(int a) { this->val--; }
// 四則演算&代入
void operator+=(const modlong &r) { *this = *this + r; }
void operator-=(const modlong &r) { *this = *this - r; }
void operator*=(const modlong &r) { *this = *this * r; }
void operator/=(const modlong &r) { *this = *this / r; }
// べき乗
modlong pow(long n) {
if (n < 0)
return inv().pow(-n); // 逆元の-n乗
else if (n == 0)
return modlong(1);
modlong half = pow(n / 2);
if (n % 2)
return *this * half * half;
else
return half * half;
}
// コンビネーション modCombは少し下に書いてある
modlong C(modlong k) { return modComb(this->val, k.val); }
friend ostream &operator<<(ostream &os, const modlong &out);
friend istream &operator>>(istream &is, modlong &out);
};
// cout、cerr、cin用の演算子たち
ostream &operator<<(ostream &os, const modlong &out) {
os << out.val;
return os;
}
istream &operator>>(istream &is, modlong &in) {
long inl;
is >> inl;
in.val = inl % MOD;
return is;
}
////// 階乗を全て求める -> 二項係数を求める
modlong invs[MAX], facts[MAX], finvs[MAX];
long listlen = 0; // invs, facts, finvsの配列長
void computeAll(long n) {
long i;
if (listlen == 0) {
invs[1] = 1;
facts[0] = 1;
facts[1] = 1;
finvs[0] = 1;
finvs[1] = 1;
i = 2;
} else {
i = listlen;
}
for (; i <= n; i++) {
invs[i] = -invs[MOD % i] * modlong(MOD / i);
facts[i] = facts[i - 1] * i;
finvs[i] = finvs[i - 1] * invs[i];
}
listlen = n + 1; // 次呼び出すときはn+1以降から再開すれば良い
}
modlong modComb(long n, long k) {
if (k < 0 || n < k)
return 0;
if (k == 0 || k == n)
return 1;
if (listlen <= n)
computeAll(n); // 毎回足りない分だけ補う
return facts[n] * finvs[k] * finvs[n - k];
}
int main() {
long n, m, k;
cin >> n >> m >> k;
modlong sum = 0, comb = modComb(n * m - 2, k - 2);
for (long d = 1; d < n; d++)
sum += comb * d * (n - d) * m * m;
for (long d = 1; d < m; d++)
sum += comb * d * (m - d) * n * n;
cout << sum << '\n';
return 0;
}
| replace | 4 | 5 | 4 | 5 | 0 | |
p03039 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define rep2(i, x, n) for (int i = x; i <= n; i++)
#define rep3(i, x, n) for (int i = x; i >= n; i--)
#define elif else if
#define sp(x) fixed << setprecision(x)
#define pb(x) push_back(x)
#define all(x) x.begin(), x.end()
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pil = pair<int, ll>;
using pli = pair<ll, int>;
using pll = pair<ll, ll>;
const ll MOD = 1e9 + 7;
// const ll MOD = 998244353;
const int inf = 1e9;
const ll INF = 1e18;
const ld EPS = 1e-10;
template <ll mod> struct Mod_Int {
ll x;
Mod_Int() {}
Mod_Int(ll y) : x(y >= 0 ? y % mod : (mod - (-y) % mod) % mod) {}
Mod_Int &operator+=(const Mod_Int &p) {
x = (x + p.x) % mod;
return *this;
}
Mod_Int &operator-=(const Mod_Int &p) {
x = (x + mod - p.x) % mod;
return *this;
}
Mod_Int &operator*=(const Mod_Int &p) {
x = (x * p.x) % mod;
return *this;
}
Mod_Int &operator/=(const Mod_Int &p) {
*this *= p.inverse();
return *this;
}
Mod_Int operator-() const { return Mod_Int(-x); }
Mod_Int operator+(const Mod_Int &p) const { return Mod_Int(*this) += p; }
Mod_Int operator-(const Mod_Int &p) const { return Mod_Int(*this) -= p; }
Mod_Int operator*(const Mod_Int &p) const { return Mod_Int(*this) *= p; }
Mod_Int operator/(const Mod_Int &p) const { return Mod_Int(*this) /= p; }
bool operator==(const Mod_Int &p) const { return x == p.x; }
bool operator!=(const Mod_Int &p) const { return x != p.x; }
Mod_Int pow(ll n) const {
Mod_Int now = *this, ret = 1;
while (n > 0) {
if (n & 1)
ret *= now;
now *= now, n >>= 1;
}
return ret;
}
Mod_Int inverse() const { return pow(mod - 2); }
};
using mint = Mod_Int<MOD>;
const int MAX_N = 1e5;
mint fac[MAX_N + 1];
void init() {
fac[0] = {1};
rep2(i, 1, MAX_N) { fac[i] = fac[i - 1] * mint(i); }
}
mint comb(mint n, mint k) { return fac[n.x] / (fac[n.x - k.x] * fac[k.x]); }
mint perm(mint n, mint k) { return fac[n.x] / fac[n.x - k.x]; }
int main() {
int N, M, K;
cin >> N >> M >> K;
init();
mint ans = comb(N * M - 2, K - 2);
mint sum = comb(M + 1, 3) * N * N + comb(N + 1, 3) * M * M;
ans *= sum;
cout << ans.x << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define rep2(i, x, n) for (int i = x; i <= n; i++)
#define rep3(i, x, n) for (int i = x; i >= n; i--)
#define elif else if
#define sp(x) fixed << setprecision(x)
#define pb(x) push_back(x)
#define all(x) x.begin(), x.end()
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pil = pair<int, ll>;
using pli = pair<ll, int>;
using pll = pair<ll, ll>;
const ll MOD = 1e9 + 7;
// const ll MOD = 998244353;
const int inf = 1e9;
const ll INF = 1e18;
const ld EPS = 1e-10;
template <ll mod> struct Mod_Int {
ll x;
Mod_Int() {}
Mod_Int(ll y) : x(y >= 0 ? y % mod : (mod - (-y) % mod) % mod) {}
Mod_Int &operator+=(const Mod_Int &p) {
x = (x + p.x) % mod;
return *this;
}
Mod_Int &operator-=(const Mod_Int &p) {
x = (x + mod - p.x) % mod;
return *this;
}
Mod_Int &operator*=(const Mod_Int &p) {
x = (x * p.x) % mod;
return *this;
}
Mod_Int &operator/=(const Mod_Int &p) {
*this *= p.inverse();
return *this;
}
Mod_Int operator-() const { return Mod_Int(-x); }
Mod_Int operator+(const Mod_Int &p) const { return Mod_Int(*this) += p; }
Mod_Int operator-(const Mod_Int &p) const { return Mod_Int(*this) -= p; }
Mod_Int operator*(const Mod_Int &p) const { return Mod_Int(*this) *= p; }
Mod_Int operator/(const Mod_Int &p) const { return Mod_Int(*this) /= p; }
bool operator==(const Mod_Int &p) const { return x == p.x; }
bool operator!=(const Mod_Int &p) const { return x != p.x; }
Mod_Int pow(ll n) const {
Mod_Int now = *this, ret = 1;
while (n > 0) {
if (n & 1)
ret *= now;
now *= now, n >>= 1;
}
return ret;
}
Mod_Int inverse() const { return pow(mod - 2); }
};
using mint = Mod_Int<MOD>;
const int MAX_N = 3e5;
mint fac[MAX_N + 1];
void init() {
fac[0] = {1};
rep2(i, 1, MAX_N) { fac[i] = fac[i - 1] * mint(i); }
}
mint comb(mint n, mint k) { return fac[n.x] / (fac[n.x - k.x] * fac[k.x]); }
mint perm(mint n, mint k) { return fac[n.x] / fac[n.x - k.x]; }
int main() {
int N, M, K;
cin >> N >> M >> K;
init();
mint ans = comb(N * M - 2, K - 2);
mint sum = comb(M + 1, 3) * N * N + comb(N + 1, 3) * M * M;
ans *= sum;
cout << ans.x << endl;
} | replace | 74 | 75 | 74 | 75 | 0 | |
p03039 | Python | Runtime Error | import sys
readline = sys.stdin.readline
MOD = 10**9 + 7
INF = float("INF")
sys.setrecursionlimit(10**5)
def comb_mod(n, r):
res = 1
r = min(n - r, r)
for i in range(r):
res *= n - i
res %= MOD
res *= pow((r - i), -1, MOD)
return res
def main():
n, m, k = list(map(int, readline().split()))
com = comb_mod(n * m - 2, k - 2)
x = 0
y = 0
for i in range(n):
right = n - 1 - i
x += (right + 1) * right // 2
x %= MOD
for i in range(m):
down = m - 1 - i
y += (down + 1) * down // 2
y %= MOD
ans = 0
ans += m**2 * x * com
ans += n**2 * y * com
ans %= MOD
print(ans)
if __name__ == "__main__":
main()
| import sys
readline = sys.stdin.readline
MOD = 10**9 + 7
INF = float("INF")
sys.setrecursionlimit(10**5)
def comb_mod(n, r):
res = 1
r = min(n - r, r)
for i in range(r):
res *= n - i
res %= MOD
res *= pow((r - i), MOD - 2, MOD)
return res
def main():
n, m, k = list(map(int, readline().split()))
com = comb_mod(n * m - 2, k - 2)
x = 0
y = 0
for i in range(n):
right = n - 1 - i
x += (right + 1) * right // 2
x %= MOD
for i in range(m):
down = m - 1 - i
y += (down + 1) * down // 2
y %= MOD
ans = 0
ans += m**2 * x * com
ans += n**2 * y * com
ans %= MOD
print(ans)
if __name__ == "__main__":
main()
| replace | 15 | 16 | 15 | 16 | 0 | |
p03039 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<ll, ll> Pl;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define repr(i, n) for (int i = n; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define FORR(i, m, n) for (int i = m; i >= n; i--)
ll const INF = 1000000000000000000;
int const I_MAX = 2147483647;
ll const MOD = 1e9 + 7;
int const POW_MAX = 1e5;
// nCr
ll po[POW_MAX + 2];
ll mod_pow(ll x, ll n) {
ll res = 1;
while (n > 0) {
if (n & 1)
res = res * x % MOD;
x = x * x % MOD;
n >>= 1;
}
return res;
}
ll mod_inv(ll x) { return mod_pow(x, MOD - 2) % MOD; }
ll comb(ll n, ll r) {
if (!po[n]) {
po[0] = 1;
FOR(i, 1, n + 1) po[i] = po[i - 1] * i % MOD;
}
return (((po[n] * mod_inv(po[r])) % MOD) * mod_inv(po[n - r])) % MOD;
}
// greatest common divisor
ll gcd(ll a, ll b) {
while (a % b != 0) {
ll tmp = a;
a = b;
b = tmp % b;
}
return b;
}
int N, M;
ll K;
int main() {
scanf("%d %d %lld", &N, &M, &K);
ll comb_v = comb(N * M - 2, K - 2);
ll sum = 0;
FOR(i, 1, N) {
ll m = (N - i) * M * M % MOD;
sum += i * m * comb_v % MOD;
sum %= MOD;
}
FOR(i, 1, M) {
ll m = (M - i) * N * N % MOD;
sum += i * m * comb_v % MOD;
sum %= MOD;
}
printf("%lld\n", sum);
}
| #include <algorithm>
#include <cmath>
#include <cstdio>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<ll, ll> Pl;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define repr(i, n) for (int i = n; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define FORR(i, m, n) for (int i = m; i >= n; i--)
ll const INF = 1000000000000000000;
int const I_MAX = 2147483647;
ll const MOD = 1e9 + 7;
int const POW_MAX = 1e5;
// nCr
map<ll, ll> po;
ll mod_pow(ll x, ll n) {
ll res = 1;
while (n > 0) {
if (n & 1)
res = res * x % MOD;
x = x * x % MOD;
n >>= 1;
}
return res;
}
ll mod_inv(ll x) { return mod_pow(x, MOD - 2) % MOD; }
ll comb(ll n, ll r) {
if (!po[n]) {
po[0] = 1;
FOR(i, 1, n + 1) po[i] = po[i - 1] * i % MOD;
}
return (((po[n] * mod_inv(po[r])) % MOD) * mod_inv(po[n - r])) % MOD;
}
// greatest common divisor
ll gcd(ll a, ll b) {
while (a % b != 0) {
ll tmp = a;
a = b;
b = tmp % b;
}
return b;
}
int N, M;
ll K;
int main() {
scanf("%d %d %lld", &N, &M, &K);
ll comb_v = comb(N * M - 2, K - 2);
ll sum = 0;
FOR(i, 1, N) {
ll m = (N - i) * M * M % MOD;
sum += i * m * comb_v % MOD;
sum %= MOD;
}
FOR(i, 1, M) {
ll m = (M - i) * N * N % MOD;
sum += i * m * comb_v % MOD;
sum %= MOD;
}
printf("%lld\n", sum);
}
| replace | 28 | 29 | 28 | 29 | 0 | |
p03039 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pll = pair<ll, ll>;
using vl = vector<ll>;
using vvl = vector<vector<ll>>;
/* short */
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define Fi first
#define Se second
#define ALL(v) begin(v), end(v)
#define RALL(v) rbegin(v), rend(v)
/* REPmacro */
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define REP(i, n) for (int i = 0; i < (n); i++)
/* exchange */
#define chmin(a, b) (a) = min((ll)(a), (ll)(b))
#define chmax(a, b) (a) = max((ll)(a), (ll)(b))
/* output */
#define I(x) cin >> x;
#define D(x) cerr << (x) << " ";
#define BR cerr << "\n";
#define P(x) cout << (x) << endl;
#define FIX cout << fixed << setprecision(10);
/* const */
const int ARRAY = 100005;
const int INF = 1001001001; // 10^9
const ll LINF = 1001001001001001001; // 10^18
const int MOD = 1e9 + 7;
ll N = 0, M, K;
ll ret = 0;
ll fact[ARRAY];
ll inv_fact[ARRAY];
ll inv[ARRAY];
void combiInit() {
fact[0] = fact[1] = 1;
inv_fact[0] = inv_fact[1] = 1;
inv[1] = 1;
FOR(i, 2, ARRAY) {
fact[i] = fact[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
inv_fact[i] = inv_fact[i - 1] * inv[i] % MOD;
}
}
ll combi(ll n, ll r) {
if (n < r)
return 0;
if (n < 0 || r < 0)
return 0;
return fact[n] * (inv_fact[r] * inv_fact[n - r] % MOD) % MOD;
}
int main(void) {
I(N);
I(M);
I(K);
combiInit();
ll dx = 0;
FOR(i, 1, N) {
dx += (i * (N - i)) % MOD;
dx %= MOD;
}
dx *= (M * M) % MOD;
dx %= MOD;
ll dy = 0;
FOR(j, 1, M) {
dy += (j * (M - j)) % MOD;
dy %= MOD;
}
dy *= (N * N) % MOD;
dy %= MOD;
ll dist = (dx + dy) % MOD;
D(dist);
ret = (dist * combi(N * M - 2, K - 2)) % MOD;
P(ret);
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pll = pair<ll, ll>;
using vl = vector<ll>;
using vvl = vector<vector<ll>>;
/* short */
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define Fi first
#define Se second
#define ALL(v) begin(v), end(v)
#define RALL(v) rbegin(v), rend(v)
/* REPmacro */
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define REP(i, n) for (int i = 0; i < (n); i++)
/* exchange */
#define chmin(a, b) (a) = min((ll)(a), (ll)(b))
#define chmax(a, b) (a) = max((ll)(a), (ll)(b))
/* output */
#define I(x) cin >> x;
#define D(x) cerr << (x) << " ";
#define BR cerr << "\n";
#define P(x) cout << (x) << endl;
#define FIX cout << fixed << setprecision(10);
/* const */
const int ARRAY = 200005;
const int INF = 1001001001; // 10^9
const ll LINF = 1001001001001001001; // 10^18
const int MOD = 1e9 + 7;
ll N = 0, M, K;
ll ret = 0;
ll fact[ARRAY];
ll inv_fact[ARRAY];
ll inv[ARRAY];
void combiInit() {
fact[0] = fact[1] = 1;
inv_fact[0] = inv_fact[1] = 1;
inv[1] = 1;
FOR(i, 2, ARRAY) {
fact[i] = fact[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
inv_fact[i] = inv_fact[i - 1] * inv[i] % MOD;
}
}
ll combi(ll n, ll r) {
if (n < r)
return 0;
if (n < 0 || r < 0)
return 0;
return fact[n] * (inv_fact[r] * inv_fact[n - r] % MOD) % MOD;
}
int main(void) {
I(N);
I(M);
I(K);
combiInit();
ll dx = 0;
FOR(i, 1, N) {
dx += (i * (N - i)) % MOD;
dx %= MOD;
}
dx *= (M * M) % MOD;
dx %= MOD;
ll dy = 0;
FOR(j, 1, M) {
dy += (j * (M - j)) % MOD;
dy %= MOD;
}
dy *= (N * N) % MOD;
dy %= MOD;
ll dist = (dx + dy) % MOD;
D(dist);
ret = (dist * combi(N * M - 2, K - 2)) % MOD;
P(ret);
}
| replace | 32 | 33 | 32 | 33 | 0 | 8 |
p03039 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define ALL(obj) (obj).begin(), (obj).end()
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define RREP(i, n) for (int i = (n)-1; i >= 0; --i)
#define endl '\n'
#define pb push_back
#define eb emplace_back
#define prique priority_queue
#define umap unordered_map
#define BIG 2000000000
#define VERYBIG 1000000000000000ll
#define PI 3.1415926
#define coutdb cout << fixed << setprecision(15)
const int dx[] = {1, 0, -1, 0, 1, 1, -1, -1},
dy[] = {0, -1, 0, 1, 1, -1, 1, -1};
const long long MOD = 1e9 + 7;
// typedef int_fast64_t ll;
#define int int_fast64_t
using Graph = vector<vector<int>>;
typedef pair<int, int> P;
template <typename T> inline T GCD(T a, T b) {
T c;
while (b != 0) {
c = a % b;
a = b;
b = c;
}
return a;
}
template <typename T> inline T LCM(T a, T b) {
T c = GCD(a, b);
a /= c;
return a * b;
}
template <typename T> inline T nCr(T a, T b) {
T i, r = 1;
for (i = 1; i <= b; i++) {
r *= (a + 1 - i);
r /= i;
}
return r;
}
template <typename T> inline T nHr(T a, T b) { return nCr(a + b - 1, b); }
const int MAX_N = 128000;
int fact[MAX_N], revfact[MAX_N];
int powmod(int a, int p) {
int res = 1, tmp = a;
while (p != 0) {
if (p % 2)
res = (res * tmp) % MOD;
tmp = (tmp * tmp) % MOD;
p /= 2;
}
return res;
}
void factmod() {
fact[0] = revfact[0] = 1;
for (int i = 1; i < MAX_N; i++) {
fact[i] = (fact[i - 1] * i) % MOD;
revfact[i] = (revfact[i - 1] * powmod(i, MOD - 2)) % MOD;
}
}
int nCrmod(int n, int r) { // nCr % MOD
return (((fact[n] * revfact[r]) % MOD) * revfact[n - r]) % MOD;
}
signed main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
int N, M, K;
cin >> N >> M >> K;
factmod();
int ans = 0;
for (int d = 1; d < N; d++) {
int num = d * (N - d) * M * M % MOD;
ans += num;
ans %= MOD;
}
for (int d = 1; d < M; d++) {
int num = d * (M - d) * N * N % MOD;
ans += num;
ans %= MOD;
}
cout << (ans * nCrmod(N * M - 2, K - 2)) % MOD << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define ALL(obj) (obj).begin(), (obj).end()
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define RREP(i, n) for (int i = (n)-1; i >= 0; --i)
#define endl '\n'
#define pb push_back
#define eb emplace_back
#define prique priority_queue
#define umap unordered_map
#define BIG 2000000000
#define VERYBIG 1000000000000000ll
#define PI 3.1415926
#define coutdb cout << fixed << setprecision(15)
const int dx[] = {1, 0, -1, 0, 1, 1, -1, -1},
dy[] = {0, -1, 0, 1, 1, -1, 1, -1};
const long long MOD = 1e9 + 7;
// typedef int_fast64_t ll;
#define int int_fast64_t
using Graph = vector<vector<int>>;
typedef pair<int, int> P;
template <typename T> inline T GCD(T a, T b) {
T c;
while (b != 0) {
c = a % b;
a = b;
b = c;
}
return a;
}
template <typename T> inline T LCM(T a, T b) {
T c = GCD(a, b);
a /= c;
return a * b;
}
template <typename T> inline T nCr(T a, T b) {
T i, r = 1;
for (i = 1; i <= b; i++) {
r *= (a + 1 - i);
r /= i;
}
return r;
}
template <typename T> inline T nHr(T a, T b) { return nCr(a + b - 1, b); }
const int MAX_N = 210000;
int fact[MAX_N], revfact[MAX_N];
int powmod(int a, int p) {
int res = 1, tmp = a;
while (p != 0) {
if (p % 2)
res = (res * tmp) % MOD;
tmp = (tmp * tmp) % MOD;
p /= 2;
}
return res;
}
void factmod() {
fact[0] = revfact[0] = 1;
for (int i = 1; i < MAX_N; i++) {
fact[i] = (fact[i - 1] * i) % MOD;
revfact[i] = (revfact[i - 1] * powmod(i, MOD - 2)) % MOD;
}
}
int nCrmod(int n, int r) { // nCr % MOD
return (((fact[n] * revfact[r]) % MOD) * revfact[n - r]) % MOD;
}
signed main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
int N, M, K;
cin >> N >> M >> K;
factmod();
int ans = 0;
for (int d = 1; d < N; d++) {
int num = d * (N - d) * M * M % MOD;
ans += num;
ans %= MOD;
}
for (int d = 1; d < M; d++) {
int num = d * (M - d) * N * N % MOD;
ans += num;
ans %= MOD;
}
cout << (ans * nCrmod(N * M - 2, K - 2)) % MOD << endl;
}
| replace | 49 | 50 | 49 | 50 | 0 | |
p03039 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define int long long
using namespace std;
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 mod = 1e9 + 7;
const int sz = 200005;
int fact[sz], inv[sz], ifact[sz];
void make() {
fact[0] = fact[1] = inv[1] = ifact[0] = ifact[1] = 1;
for (int i = 2; i < sz; i++) {
fact[i] = fact[i - 1] * i % mod;
inv[i] = inv[mod % i] * (mod - mod / i) % mod;
ifact[i] = ifact[i - 1] * inv[i] % mod;
}
}
int comb(int n, int k) {
if (n < k)
return 0;
return fact[n] * ifact[k] % mod * ifact[n - k] % mod;
}
void add(int &a, int b) { a = (a + b) % mod; }
signed main() {
make();
int N, M, K;
cin >> N >> M >> K;
int ans = 0;
for (int i = 0; i < N * M - 1; i++) {
for (int j = i + 1; j < N * M; j++) {
int y1 = i / M, x1 = i % M;
int y2 = j / M, x2 = j % M;
int tmp = (abs(y1 - y2) + abs(x1 - x2)) * comb(N * M - 2, K - 2) % mod;
add(ans, tmp);
}
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
#define int long long
using namespace std;
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 mod = 1e9 + 7;
const int sz = 200005;
int fact[sz], inv[sz], ifact[sz];
void make() {
fact[0] = fact[1] = inv[1] = ifact[0] = ifact[1] = 1;
for (int i = 2; i < sz; i++) {
fact[i] = fact[i - 1] * i % mod;
inv[i] = inv[mod % i] * (mod - mod / i) % mod;
ifact[i] = ifact[i - 1] * inv[i] % mod;
}
}
int comb(int n, int k) {
if (n < k)
return 0;
return fact[n] * ifact[k] % mod * ifact[n - k] % mod;
}
void add(int &a, int b) { a = (a + b) % mod; }
signed main() {
make();
int N, M, K;
cin >> N >> M >> K;
int ans = 0;
for (int d = 1; d < N; d++) {
int tmp =
d * (N - d) % mod * M % mod * M % mod * comb(N * M - 2, K - 2) % mod;
add(ans, tmp);
}
for (int d = 1; d < M; d++) {
int tmp =
d * (M - d) % mod * N % mod * N % mod * comb(N * M - 2, K - 2) % mod;
add(ans, tmp);
}
cout << ans << endl;
} | replace | 46 | 53 | 46 | 55 | TLE | |
p03039 | C++ | Runtime Error | #include <iostream>
#include <vector>
using namespace std;
const int MOD = 1e9 + 7;
const int MAX = 1e5 + 10;
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 N, M, K;
cin >> N >> M >> K;
long long ans = 0;
COMinit();
for (int i = 1; i < M; i++) {
ans = (ans +
((((COM(N * M - 2, K - 2) * (M - i) % MOD) * N % MOD) * N % MOD) *
i % MOD)) %
MOD;
}
for (int i = 1; i < N; i++) {
ans = (ans +
((((COM(N * M - 2, K - 2) * (N - i) % MOD) * M % MOD) * M % MOD) *
i % MOD)) %
MOD;
}
cout << ans << endl;
} | #include <iostream>
#include <vector>
using namespace std;
const int MOD = 1e9 + 7;
const int MAX = 2e5 + 10;
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 N, M, K;
cin >> N >> M >> K;
long long ans = 0;
COMinit();
for (int i = 1; i < M; i++) {
ans = (ans +
((((COM(N * M - 2, K - 2) * (M - i) % MOD) * N % MOD) * N % MOD) *
i % MOD)) %
MOD;
}
for (int i = 1; i < N; i++) {
ans = (ans +
((((COM(N * M - 2, K - 2) * (N - i) % MOD) * M % MOD) * M % MOD) *
i % MOD)) %
MOD;
}
cout << ans << endl;
} | replace | 5 | 6 | 5 | 6 | 0 | |
p03040 | C++ | Runtime Error | #include <float.h>
#include <inttypes.h>
#include <limits.h>
#include <math.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
#ifdef __cplusplus
#include <bits/stdc++.h>
#endif
int comp(const void *a, const void *b) {
return (*(int *)a > *(int *)b) - (*(int *)a < *(int *)b);
}
int compr(const void *a, const void *b) {
return (*(int *)a < *(int *)b) - (*(int *)a > *(int *)b);
}
uint32_t nextpint(void) {
char c = getchar();
while (c < '0' || '9' < c)
c = getchar();
uint32_t x = 0;
while ('0' <= c && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return x;
}
uint64_t nextplong(void) {
char c = getchar();
while (c < '0' || '9' < c)
c = getchar();
uint64_t x = 0;
while ('0' <= c && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return x;
}
uint32_t nextstr(char *s) {
char c = getchar();
while (c == ' ' || c == '\n')
c = getchar();
uint32_t len = 0;
while (c != ' ' && c != '\n') {
*s++ = c;
len++;
c = getchar();
}
*s = '\0';
return len;
}
inline int max2(const int a, const int b) { return a > b ? a : b; }
inline int min2(const int a, const int b) { return a > b ? b : a; }
inline int dif2(const int a, const int b) { return a > b ? a - b : b - a; }
inline int abs2(const int a) { return a >= 0 ? a : -a; }
std::multiset<int> r;
std::multiset<int, std::greater<int>> l;
int main(void) {
int q = nextpint();
int L = INT_MIN;
int R = INT_MAX;
l.insert(L);
r.insert(R);
long b = 0;
long x = 0;
for (int i = 0; i < q; i++) {
int Q = nextpint();
if (Q == 1) {
int A, B;
scanf("%d%d", &A, &B);
b += B;
if (A < L) {
l.erase(l.find(L));
r.insert(L);
l.insert(A);
l.insert(A);
x += L - A;
R = L;
L = *l.begin();
} else if (A > R) {
r.erase(r.find(R));
l.insert(L);
r.insert(A);
r.insert(A);
x += A - R;
L = R;
R = *r.begin();
} else {
l.insert(A);
r.insert(A);
L = R = A;
}
} else {
printf("%d %ld\n", L, x + b);
}
}
}
| #include <float.h>
#include <inttypes.h>
#include <limits.h>
#include <math.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
#ifdef __cplusplus
#include <bits/stdc++.h>
#endif
int comp(const void *a, const void *b) {
return (*(int *)a > *(int *)b) - (*(int *)a < *(int *)b);
}
int compr(const void *a, const void *b) {
return (*(int *)a < *(int *)b) - (*(int *)a > *(int *)b);
}
uint32_t nextpint(void) {
char c = getchar();
while (c < '0' || '9' < c)
c = getchar();
uint32_t x = 0;
while ('0' <= c && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return x;
}
uint64_t nextplong(void) {
char c = getchar();
while (c < '0' || '9' < c)
c = getchar();
uint64_t x = 0;
while ('0' <= c && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return x;
}
uint32_t nextstr(char *s) {
char c = getchar();
while (c == ' ' || c == '\n')
c = getchar();
uint32_t len = 0;
while (c != ' ' && c != '\n') {
*s++ = c;
len++;
c = getchar();
}
*s = '\0';
return len;
}
inline int max2(const int a, const int b) { return a > b ? a : b; }
inline int min2(const int a, const int b) { return a > b ? b : a; }
inline int dif2(const int a, const int b) { return a > b ? a - b : b - a; }
inline int abs2(const int a) { return a >= 0 ? a : -a; }
std::multiset<int> r;
std::multiset<int, std::greater<int>> l;
int main(void) {
int q = nextpint();
int L = INT_MIN;
int R = INT_MAX;
l.insert(L);
r.insert(R);
long b = 0;
long x = 0;
for (int i = 0; i < q; i++) {
int Q = nextpint();
if (Q == 1) {
int A, B;
scanf("%d%d", &A, &B);
b += B;
if (A < L) {
l.erase(l.find(L));
r.insert(L);
l.insert(A);
l.insert(A);
x += L - A;
R = L;
L = *l.begin();
} else if (A > R) {
r.erase(r.find(R));
l.insert(R);
r.insert(A);
r.insert(A);
x += A - R;
L = R;
R = *r.begin();
} else {
l.insert(A);
r.insert(A);
L = R = A;
}
} else {
printf("%d %ld\n", L, x + b);
}
}
}
| replace | 89 | 90 | 89 | 90 | 0 | |
p03040 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
/*{{{*/ // template
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rrep(i, n) for (int i = (n)-1; i >= 0; i--)
constexpr int INF = numeric_limits<int>::max() / 2;
constexpr long long LINF = numeric_limits<long long>::max() / 3;
#define pb push_back
#define eb emplace_back
#define fi first
#define se second
#define all(v) (v).begin(), (v).end()
#define sz(x) (int)(x).size()
#define debug(x) cerr << #x << ":" << x << endl
#define debug2(x, y) cerr << #x << "," << #y ":" << x << "," << y << endl
// struct fin{ fin(){ cin.tie(0); ios::sync_with_stdio(false); } } fin_;
struct Double {
double d;
explicit Double(double x) : d(x) {}
};
ostream &operator<<(ostream &os, const Double x) {
os << fixed << setprecision(20) << x.d;
return os;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec) {
os << "[";
for (const auto &v : vec) {
os << v << ",";
}
os << "]";
return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const map<T, U> &mp) {
os << "{";
for (auto &p : mp) {
os << p << ",";
}
os << "}";
return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
os << "(" << p.first << "," << p.second << ")";
return os;
}
template <typename T> ostream &operator<<(ostream &os, const set<T> &st) {
os << "{";
for (T v : st)
os << v << ",";
os << "}";
return os;
}
template <typename T, typename U> inline void chmax(T &x, U y) {
if (y > x)
x = y;
}
template <typename T, typename U> inline void chmin(T &x, U y) {
if (y < x)
x = y;
}
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<vi> vvi;
ll gcd(ll a, ll b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
// constexpr double eps = 1e-14;
constexpr double eps = 1e-10;
constexpr ll mod = 1e9 + 7;
const int dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1};
/*}}}*/
/* 0-indexed BIT */
struct BIT {
using T = long long;
int n;
vector<T> bit;
BIT() {}
BIT(int n_) {
n = n_;
bit.assign(n, 0);
}
// sum of data[0] + ... + data[i-1]
T sum(int a) {
T ret = 0;
for (int x = a - 1; x >= 0; x = (x & (x + 1)) - 1) {
ret += bit[x];
}
return ret;
}
void add(int a, int w) {
for (int x = a; x < n; x |= x + 1) {
bit[x] += w;
}
}
// sum(i) >= xとなる最小のiを返す
// sum(all) < xの場合はnを返す
int lower_bound(T x) {
int l = 0;
int r = n;
while (r - l > 1) {
const int m = (l + r) / 2;
if (sum(m) >= x)
r = m;
else
l = m;
}
return r;
}
};
struct Query {
int i;
ll a, b;
};
int main() {
int Q;
cin >> Q;
vector<Query> qs(Q);
set<ll> st;
for (int i = 0; i < Q; i++) {
cin >> qs[i].i;
if (qs[i].i == 1) {
cin >> qs[i].a >> qs[i].b;
st.insert(qs[i].a);
}
}
vector<ll> pd(st.size());
int idx = 0;
for (auto &&v : st) {
pd[idx++] = v;
}
// debug(pd);
BIT bit(pd.size());
BIT sum(pd.size());
ll bs = 0;
int n = 0;
rep(i, Q) {
if (qs[i].i == 1) {
bs += qs[i].b;
int idx = lower_bound(pd.begin(), pd.end(), qs[i].a) - pd.begin();
assert(idx >= 0);
bit.add(idx, 1);
sum.add(idx, pd[idx]);
n++;
} else if (qs[i].i == 2) {
const int idx = bit.lower_bound((n + 1) / 2) - 1;
assert(idx >= 0);
const ll value = pd[idx];
ll left = sum.sum(idx + 1);
ll lc = bit.sum(idx + 1);
ll right = sum.sum(n) - left;
ll rc = bit.sum(n) - lc;
cout << value << " " << lc * value - left + right - rc * value + bs
<< endl;
}
}
}
| #include <bits/stdc++.h>
using namespace std;
/*{{{*/ // template
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rrep(i, n) for (int i = (n)-1; i >= 0; i--)
constexpr int INF = numeric_limits<int>::max() / 2;
constexpr long long LINF = numeric_limits<long long>::max() / 3;
#define pb push_back
#define eb emplace_back
#define fi first
#define se second
#define all(v) (v).begin(), (v).end()
#define sz(x) (int)(x).size()
#define debug(x) cerr << #x << ":" << x << endl
#define debug2(x, y) cerr << #x << "," << #y ":" << x << "," << y << endl
// struct fin{ fin(){ cin.tie(0); ios::sync_with_stdio(false); } } fin_;
struct Double {
double d;
explicit Double(double x) : d(x) {}
};
ostream &operator<<(ostream &os, const Double x) {
os << fixed << setprecision(20) << x.d;
return os;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec) {
os << "[";
for (const auto &v : vec) {
os << v << ",";
}
os << "]";
return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const map<T, U> &mp) {
os << "{";
for (auto &p : mp) {
os << p << ",";
}
os << "}";
return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
os << "(" << p.first << "," << p.second << ")";
return os;
}
template <typename T> ostream &operator<<(ostream &os, const set<T> &st) {
os << "{";
for (T v : st)
os << v << ",";
os << "}";
return os;
}
template <typename T, typename U> inline void chmax(T &x, U y) {
if (y > x)
x = y;
}
template <typename T, typename U> inline void chmin(T &x, U y) {
if (y < x)
x = y;
}
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<vi> vvi;
ll gcd(ll a, ll b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
// constexpr double eps = 1e-14;
constexpr double eps = 1e-10;
constexpr ll mod = 1e9 + 7;
const int dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1};
/*}}}*/
/* 0-indexed BIT */
struct BIT {
using T = long long;
int n;
vector<T> bit;
BIT() {}
BIT(int n_) {
n = n_;
bit.assign(n, 0);
}
// sum of data[0] + ... + data[i-1]
T sum(int a) {
T ret = 0;
for (int x = a - 1; x >= 0; x = (x & (x + 1)) - 1) {
ret += bit[x];
}
return ret;
}
void add(int a, int w) {
for (int x = a; x < n; x |= x + 1) {
bit[x] += w;
}
}
// sum(i) >= xとなる最小のiを返す
// sum(all) < xの場合はnを返す
int lower_bound(T x) {
int l = 0;
int r = n;
while (r - l > 1) {
const int m = (l + r) / 2;
if (sum(m) >= x)
r = m;
else
l = m;
}
return r;
}
};
struct Query {
int i;
ll a, b;
};
int main() {
int Q;
cin >> Q;
vector<Query> qs(Q);
set<ll> st;
for (int i = 0; i < Q; i++) {
cin >> qs[i].i;
if (qs[i].i == 1) {
cin >> qs[i].a >> qs[i].b;
st.insert(qs[i].a);
}
}
vector<ll> pd(st.size());
int idx = 0;
for (auto &&v : st) {
pd[idx++] = v;
}
// debug(pd);
BIT bit(pd.size());
BIT sum(pd.size());
ll bs = 0;
int n = 0;
rep(i, Q) {
if (qs[i].i == 1) {
bs += qs[i].b;
int idx = lower_bound(pd.begin(), pd.end(), qs[i].a) - pd.begin();
assert(idx >= 0);
bit.add(idx, 1);
sum.add(idx, pd[idx]);
n++;
} else if (qs[i].i == 2) {
const int idx = bit.lower_bound((n + 1) / 2) - 1;
assert(idx >= 0);
const ll value = pd[idx];
ll left = sum.sum(idx + 1);
ll lc = bit.sum(idx + 1);
ll right = sum.sum(pd.size()) - left;
ll rc = bit.sum(pd.size()) - lc; // RE
cout << value << " " << lc * value - left + right - rc * value + bs
<< endl;
}
}
}
| replace | 160 | 162 | 160 | 162 | 0 | |
p03040 | C++ | Runtime Error | /*input
4
1 4 2
2
1 1 -8
2
*/
#pragma GCC optimize("Ofast")
#pragma GCC target( \
"sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,tune=native")
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
mt19937 gen;
struct node;
using pnode = node *;
int sz(pnode a);
ll dd(pnode a);
struct node {
node *l = NULL, *r = NULL;
int w;
int val;
int dyd = 1;
ll dyd1;
node(int val) : val(val) {
w = gen();
dyd1 = val;
}
void fixS() {
dyd = 1 + sz(l) + sz(r);
dyd1 = val + dd(l) + dd(r);
}
};
int sz(pnode a) {
if (a)
return a->dyd;
return 0;
}
ll dd(pnode a) {
if (a)
return a->dyd1;
return 0;
}
pnode merge(pnode a, pnode b) {
if (a == NULL)
return b;
if (b == NULL)
return a;
if (a->w < b->w) {
a->r = merge(a->r, b);
a->fixS();
return a;
} else {
b->l = merge(a, b->l);
b->fixS();
return b;
}
}
pnode merge(pnode a, pnode b, pnode c) { return merge(merge(a, b), c); }
void split(pnode a, int v, pnode &x, pnode &y) { // (x <= v), (y > v)
if (a == NULL) {
x = NULL;
y = NULL;
return;
}
if (a->val <= v) {
split(a->r, v, a->r, y);
x = a;
} else {
split(a->l, v, x, a->l);
y = a;
}
a->fixS();
}
void split_(pnode a, int k, pnode &x, pnode &y) { // (x->sz = min(a->sz, k))
if (a == NULL) {
x = NULL;
y = NULL;
} else {
if (k <= 0) {
x = NULL;
y = a;
} else if (a->dyd < k) {
x = a;
y = NULL;
} else {
if (sz(a->l) + 1 <= k) {
split_(a->r, k - 1 - sz(a->l), a->r, y);
x = a;
} else {
split_(a->l, k, x, a->l);
y = a;
}
a->fixS();
}
}
}
void print(pnode a, char g = '\n') {
if (a == NULL) {
if (g != ' ')
cout << g;
return;
}
print(a->l, ' ');
cout << a->val << ' ';
print(a->r, g);
}
int main() {
ios_base::sync_with_stdio(false);
ll sumb = 0;
pnode x = NULL;
int Q;
cin >> Q;
int kiek = 0;
while (Q--) {
int t;
cin >> t;
if (t == 1) {
kiek++;
ll a, b;
cin >> a >> b;
sumb += b;
pnode l, r;
split(x, a, l, r);
x = merge(l, new node(a), r);
} else {
pnode a, b, c;
ll k = (kiek - 1) / 2;
split_(x, k, a, b);
split_(b, 1, b, c);
ll X = b->val;
ll Y = sumb;
Y += dd(c);
Y -= dd(a);
Y += X * (sz(a) - sz(c));
cout << X << " " << Y << "\n";
x = merge(a, b, c);
}
// cout << "x: ";
// print(x);
}
} | /*input
4
1 4 2
2
1 1 -8
2
*/
#pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
mt19937 gen;
struct node;
using pnode = node *;
int sz(pnode a);
ll dd(pnode a);
struct node {
node *l = NULL, *r = NULL;
int w;
int val;
int dyd = 1;
ll dyd1;
node(int val) : val(val) {
w = gen();
dyd1 = val;
}
void fixS() {
dyd = 1 + sz(l) + sz(r);
dyd1 = val + dd(l) + dd(r);
}
};
int sz(pnode a) {
if (a)
return a->dyd;
return 0;
}
ll dd(pnode a) {
if (a)
return a->dyd1;
return 0;
}
pnode merge(pnode a, pnode b) {
if (a == NULL)
return b;
if (b == NULL)
return a;
if (a->w < b->w) {
a->r = merge(a->r, b);
a->fixS();
return a;
} else {
b->l = merge(a, b->l);
b->fixS();
return b;
}
}
pnode merge(pnode a, pnode b, pnode c) { return merge(merge(a, b), c); }
void split(pnode a, int v, pnode &x, pnode &y) { // (x <= v), (y > v)
if (a == NULL) {
x = NULL;
y = NULL;
return;
}
if (a->val <= v) {
split(a->r, v, a->r, y);
x = a;
} else {
split(a->l, v, x, a->l);
y = a;
}
a->fixS();
}
void split_(pnode a, int k, pnode &x, pnode &y) { // (x->sz = min(a->sz, k))
if (a == NULL) {
x = NULL;
y = NULL;
} else {
if (k <= 0) {
x = NULL;
y = a;
} else if (a->dyd < k) {
x = a;
y = NULL;
} else {
if (sz(a->l) + 1 <= k) {
split_(a->r, k - 1 - sz(a->l), a->r, y);
x = a;
} else {
split_(a->l, k, x, a->l);
y = a;
}
a->fixS();
}
}
}
void print(pnode a, char g = '\n') {
if (a == NULL) {
if (g != ' ')
cout << g;
return;
}
print(a->l, ' ');
cout << a->val << ' ';
print(a->r, g);
}
int main() {
ios_base::sync_with_stdio(false);
ll sumb = 0;
pnode x = NULL;
int Q;
cin >> Q;
int kiek = 0;
while (Q--) {
int t;
cin >> t;
if (t == 1) {
kiek++;
ll a, b;
cin >> a >> b;
sumb += b;
pnode l, r;
split(x, a, l, r);
x = merge(l, new node(a), r);
} else {
pnode a, b, c;
ll k = (kiek - 1) / 2;
split_(x, k, a, b);
split_(b, 1, b, c);
ll X = b->val;
ll Y = sumb;
Y += dd(c);
Y -= dd(a);
Y += X * (sz(a) - sz(c));
cout << X << " " << Y << "\n";
x = merge(a, b, c);
}
// cout << "x: ";
// print(x);
}
} | delete | 8 | 10 | 8 | 8 | 0 | |
p03040 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(v) begin(v), end(v)
#define fi first
#define se second
template <typename A, typename B> inline bool chmax(A &a, B b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <typename A, typename B> inline bool chmin(A &a, B b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
using ll = long long;
using pii = pair<int, int>;
constexpr ll INF = 1ll << 30;
constexpr ll longINF = 1ll << 60;
constexpr ll MOD = 1000000007;
constexpr bool debug = 0;
//---------------------------------//
template <typename T> struct BIT {
vector<T> bit;
int n;
BIT() {}
BIT(int n) : bit(vector<T>(n + 2, 0)), n(n) {}
T sum(int i) {
i++;
T s = 0;
while (i > 0) {
s += bit[i];
i -= i & -i;
}
return s;
}
void add(int i, T x) {
i++;
while (i <= n) {
bit[i] += x;
i += i & -i;
}
}
T pquery(int i) { return sum(i) - sum(i - 1); }
int lower_bound(T x) {
int l = -1, r = bit.size();
while (r - l > 1) {
int m = (l + r) / 2;
if (sum(m) >= x)
r = m;
else
l = m;
}
if (r == bit.size())
r = -1;
return r;
}
};
int Q;
int query[21235];
int A[212345], B[212345];
int main() {
int Q;
cin >> Q;
REP(i, Q) {
scanf("%d", query + i);
if (query[i] == 1)
scanf("%d %d", A + i, B + i);
}
vector<int> cx;
REP(i, Q) if (query[i] == 1) cx.push_back(A[i]);
sort(ALL(cx));
BIT<ll> popcnt(Q + 10), sum(Q + 10); // 1-indexed
ll bsum = 0;
REP(q, Q) {
if (query[q] == 1) {
int idx = lower_bound(ALL(cx), A[q]) - cx.begin() + 1;
popcnt.add(idx, 1);
sum.add(idx, A[q]);
bsum += B[q];
} else {
int size = popcnt.sum(Q);
if (size == 0) {
puts("0 0");
continue;
}
int idx = popcnt.lower_bound((size + 1) / 2); // 1-indexed
ll x = cx[idx - 1];
ll ans =
-x * (popcnt.sum(Q) - popcnt.sum(idx)) + (sum.sum(Q) - sum.sum(idx));
ans += x * popcnt.sum(idx) - sum.sum(idx);
ans += bsum;
printf("%lld %lld\n", x, ans);
}
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(v) begin(v), end(v)
#define fi first
#define se second
template <typename A, typename B> inline bool chmax(A &a, B b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <typename A, typename B> inline bool chmin(A &a, B b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
using ll = long long;
using pii = pair<int, int>;
constexpr ll INF = 1ll << 30;
constexpr ll longINF = 1ll << 60;
constexpr ll MOD = 1000000007;
constexpr bool debug = 0;
//---------------------------------//
template <typename T> struct BIT {
vector<T> bit;
int n;
BIT() {}
BIT(int n) : bit(vector<T>(n + 2, 0)), n(n) {}
T sum(int i) {
i++;
T s = 0;
while (i > 0) {
s += bit[i];
i -= i & -i;
}
return s;
}
void add(int i, T x) {
i++;
while (i <= n) {
bit[i] += x;
i += i & -i;
}
}
T pquery(int i) { return sum(i) - sum(i - 1); }
int lower_bound(T x) {
int l = -1, r = bit.size();
while (r - l > 1) {
int m = (l + r) / 2;
if (sum(m) >= x)
r = m;
else
l = m;
}
if (r == bit.size())
r = -1;
return r;
}
};
int Q;
int query[212345];
int A[212345], B[212345];
int main() {
int Q;
cin >> Q;
REP(i, Q) {
scanf("%d", query + i);
if (query[i] == 1)
scanf("%d %d", A + i, B + i);
}
vector<int> cx;
REP(i, Q) if (query[i] == 1) cx.push_back(A[i]);
sort(ALL(cx));
BIT<ll> popcnt(Q + 10), sum(Q + 10); // 1-indexed
ll bsum = 0;
REP(q, Q) {
if (query[q] == 1) {
int idx = lower_bound(ALL(cx), A[q]) - cx.begin() + 1;
popcnt.add(idx, 1);
sum.add(idx, A[q]);
bsum += B[q];
} else {
int size = popcnt.sum(Q);
if (size == 0) {
puts("0 0");
continue;
}
int idx = popcnt.lower_bound((size + 1) / 2); // 1-indexed
ll x = cx[idx - 1];
ll ans =
-x * (popcnt.sum(Q) - popcnt.sum(idx)) + (sum.sum(Q) - sum.sum(idx));
ans += x * popcnt.sum(idx) - sum.sum(idx);
ans += bsum;
printf("%lld %lld\n", x, ans);
}
}
return 0;
}
| replace | 74 | 75 | 74 | 75 | 0 | |
p03040 | C++ | Runtime Error | #include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cfenv>
#include <chrono>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdint>
#include <cstdio>
#include <cstring>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <time.h>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
// #include <bits/stdc++.h>
using namespace std;
using LL = long long;
using ULL = unsigned long long;
long long MOD =
1000000000 + 7; // ;//1000000000 + 7 998244353 924844033 1000000000 + 9;
constexpr long long INF = numeric_limits<LL>::max();
constexpr long long DINF = 1000000000000;
const double PI = acos(-1);
#define fir first
#define sec second
#define thi third
#define debug(x) cerr << #x << ": " << x << '\n'
typedef pair<LL, LL> Pll;
typedef pair<double, double> Dll;
typedef pair<LL, pair<LL, LL>> Ppll;
typedef pair<LL, pair<LL, bitset<100001>>> Pbll;
typedef pair<LL, pair<LL, vector<LL>>> Pvll;
typedef pair<LL, LL> Vec2;
struct Tll {
LL first, second, third;
};
struct Fll {
LL first, second, third, fourth;
};
typedef pair<LL, Tll> Ptll;
#define rep(i, rept) for (LL i = 0; i < rept; i++)
#define Rrep(i, mf) for (LL i = mf - 1; i >= 0; i--)
void YN(bool f) {
if (f)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
void yn(bool f) {
if (f)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
struct Edge {
LL to, cost;
};
struct edge {
LL from, to, cost;
};
vector<vector<Edge>> g;
vector<edge> ed;
vector<Pll> pv;
map<LL, LL> ma;
set<LL> st;
int di[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
LL n, m, k, p, q, w, h, ans, cnt, sum, a[310000], b[310000];
string str;
struct query {
int flag, a, b;
};
bool f;
// char c[1100][1100];
query qu[100000];
map<LL, LL> zip;
int unzip[210000];
int compress(vector<LL> &x) {
sort(x.begin(), x.end());
x.erase(unique(x.begin(), x.end()), x.end());
for (int i = 0; i < x.size(); i++) {
zip[x[i]] = i;
unzip[i] = x[i];
}
return x.size();
}
class BIT {
public:
vector<LL> Bit;
LL M;
BIT(LL M) : Bit(vector<LL>(M + 1, 0)), M(M) {}
LL sum(LL i) {
LL s = 0;
while (i > 0) {
s += Bit[i];
i -= (i & (-i));
}
return s;
}
LL sum(LL i, LL j) { return sum(j) - sum(i - 1); }
// 1-index
void add(LL i, LL x) {
while (i <= M) {
Bit[i] += x;
i += (i & (-i));
}
}
// 初めてk以上になる、index
int lower_bound(LL k) {
int l = -1, r = n + 1, m;
while (r - l > 1) {
m = (l + r) / 2;
if (sum(m) >= k)
r = m;
else
l = m;
}
return (r == n + 1 ? -1 : r);
}
// 初めてkより大きくなる、index
int upper_bound(LL k) {
int l = -1, r = M + 1, m;
while (r - l > 1) {
m = (l + r) / 2;
if (sum(m) > k)
r = m;
else
l = m;
}
return (r == M + 1 ? M + 1 : r);
}
};
BIT bi1(210000), bi2(210000);
int main() {
cin >> n;
vector<LL> ve;
rep(i, n) {
LL x, y, z;
cin >> qu[i].flag;
if (qu[i].flag == 1) {
cin >> qu[i].a >> qu[i].b;
ve.push_back(qu[i].a);
}
}
ve.push_back(-INF / 1000);
compress(ve);
rep(i, n) {
if (qu[i].flag == 1) {
bi1.add(zip[qu[i].a], 1);
bi2.add(zip[qu[i].a], qu[i].a);
cnt++;
sum += qu[i].b;
} else {
LL num = bi1.lower_bound((cnt + 1) / 2), cur = unzip[num];
cout << cur << " "
<< (bi1.sum(num) * cur - bi2.sum(num)) +
(bi2.sum(num + 1, n) - bi1.sum(num + 1, n) * cur) + sum
<< endl;
}
}
return 0;
}
| #include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cfenv>
#include <chrono>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdint>
#include <cstdio>
#include <cstring>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <time.h>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
// #include <bits/stdc++.h>
using namespace std;
using LL = long long;
using ULL = unsigned long long;
long long MOD =
1000000000 + 7; // ;//1000000000 + 7 998244353 924844033 1000000000 + 9;
constexpr long long INF = numeric_limits<LL>::max();
constexpr long long DINF = 1000000000000;
const double PI = acos(-1);
#define fir first
#define sec second
#define thi third
#define debug(x) cerr << #x << ": " << x << '\n'
typedef pair<LL, LL> Pll;
typedef pair<double, double> Dll;
typedef pair<LL, pair<LL, LL>> Ppll;
typedef pair<LL, pair<LL, bitset<100001>>> Pbll;
typedef pair<LL, pair<LL, vector<LL>>> Pvll;
typedef pair<LL, LL> Vec2;
struct Tll {
LL first, second, third;
};
struct Fll {
LL first, second, third, fourth;
};
typedef pair<LL, Tll> Ptll;
#define rep(i, rept) for (LL i = 0; i < rept; i++)
#define Rrep(i, mf) for (LL i = mf - 1; i >= 0; i--)
void YN(bool f) {
if (f)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
void yn(bool f) {
if (f)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
struct Edge {
LL to, cost;
};
struct edge {
LL from, to, cost;
};
vector<vector<Edge>> g;
vector<edge> ed;
vector<Pll> pv;
map<LL, LL> ma;
set<LL> st;
int di[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
LL n, m, k, p, q, w, h, ans, cnt, sum, a[310000], b[310000];
string str;
struct query {
int flag, a, b;
};
bool f;
// char c[1100][1100];
query qu[210000];
map<LL, LL> zip;
int unzip[210000];
int compress(vector<LL> &x) {
sort(x.begin(), x.end());
x.erase(unique(x.begin(), x.end()), x.end());
for (int i = 0; i < x.size(); i++) {
zip[x[i]] = i;
unzip[i] = x[i];
}
return x.size();
}
class BIT {
public:
vector<LL> Bit;
LL M;
BIT(LL M) : Bit(vector<LL>(M + 1, 0)), M(M) {}
LL sum(LL i) {
LL s = 0;
while (i > 0) {
s += Bit[i];
i -= (i & (-i));
}
return s;
}
LL sum(LL i, LL j) { return sum(j) - sum(i - 1); }
// 1-index
void add(LL i, LL x) {
while (i <= M) {
Bit[i] += x;
i += (i & (-i));
}
}
// 初めてk以上になる、index
int lower_bound(LL k) {
int l = -1, r = n + 1, m;
while (r - l > 1) {
m = (l + r) / 2;
if (sum(m) >= k)
r = m;
else
l = m;
}
return (r == n + 1 ? -1 : r);
}
// 初めてkより大きくなる、index
int upper_bound(LL k) {
int l = -1, r = M + 1, m;
while (r - l > 1) {
m = (l + r) / 2;
if (sum(m) > k)
r = m;
else
l = m;
}
return (r == M + 1 ? M + 1 : r);
}
};
BIT bi1(210000), bi2(210000);
int main() {
cin >> n;
vector<LL> ve;
rep(i, n) {
LL x, y, z;
cin >> qu[i].flag;
if (qu[i].flag == 1) {
cin >> qu[i].a >> qu[i].b;
ve.push_back(qu[i].a);
}
}
ve.push_back(-INF / 1000);
compress(ve);
rep(i, n) {
if (qu[i].flag == 1) {
bi1.add(zip[qu[i].a], 1);
bi2.add(zip[qu[i].a], qu[i].a);
cnt++;
sum += qu[i].b;
} else {
LL num = bi1.lower_bound((cnt + 1) / 2), cur = unzip[num];
cout << cur << " "
<< (bi1.sum(num) * cur - bi2.sum(num)) +
(bi2.sum(num + 1, n) - bi1.sum(num + 1, n) * cur) + sum
<< endl;
}
}
return 0;
}
| replace | 94 | 95 | 94 | 95 | 0 | |
p03040 | C++ | Runtime Error | #include <bits/stdc++.h>
#include <sys/types.h>
#include <unistd.h>
#define _overload(_1, _2, _3, name, ...) name
#define _rep(i, n) _range(i, 0, n)
#define _range(i, a, b) for (int i = int(a); i < int(b); ++i)
#define rep(...) _overload(__VA_ARGS__, _range, _rep, )(__VA_ARGS__)
#define _rrep(i, n) _rrange(i, n, 0)
#define _rrange(i, a, b) for (int i = int(a) - 1; i >= int(b); --i)
#define rrep(...) _overload(__VA_ARGS__, _rrange, _rrep, )(__VA_ARGS__)
#define _all(arg) begin(arg), end(arg)
#define uniq(arg) sort(_all(arg)), (arg).erase(unique(_all(arg)), end(arg))
#define getidx(ary, key) lower_bound(_all(ary), key) - begin(ary)
#define clr(a, b) memset((a), (b), sizeof(a))
#define bit(n) (1LL << (n))
#define popcount(n) (__builtin_popcountll(n))
using namespace std;
template <class T> bool chmax(T &a, const T &b) {
return (a < b) ? (a = b, 1) : 0;
}
template <class T> bool chmin(T &a, const T &b) {
return (b < a) ? (a = b, 1) : 0;
}
using ll = long long;
using R = long double;
const R EPS = 1e-9L; // [-1000,1000]->EPS=1e-8 [-10000,10000]->EPS=1e-7
inline int sgn(const R &r) { return (r > EPS) - (r < -EPS); }
inline R sq(R x) { return sqrt(max(x, 0.0L)); }
template <typename T> vector<T> make_vector(size_t sz) { return vector<T>(sz); }
template <typename T, typename... Ts> auto make_vector(size_t sz, Ts... ts) {
return vector<decltype(make_vector<T>(ts...))>(sz, make_vector<T>(ts...));
}
template <typename T, typename U, typename... V>
typename enable_if<is_same<T, U>::value != 0>::type fill_value(U &u,
const V... v) {
u = U(v...);
}
template <typename T, typename U, typename... V>
typename enable_if<is_same<T, U>::value == 0>::type fill_value(U &u,
const V... v) {
for (auto &e : u) {
fill_value<T>(e, v...);
}
}
const int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
const int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
const pid_t pid = getpid();
// Problem Specific Parameter:
template <int depth> struct Binary_indexed_tree {
using T = int;
const static int h = depth;
const static int n = 1 << h;
T data[n];
void init() { fill_n(data, n, 0); }
void update(int i, T x) {
for (i++; i < n; i += i & -i) {
data[i] += x;
}
}
int lower_bound(T x) {
if (x <= 0)
return 0;
int i = 0;
for (int k = n; k > 0; k >>= 1) {
if (i + k < n and data[i + k] < x)
x -= data[i + k], i += k;
}
return i + 1;
}
};
const int limit = 100010;
int t[limit], a[limit], b[limit];
vector<int> ary;
#define error(args...) \
{ \
vector<string> _debug = split(#args, ','); \
err(begin(_debug), args); \
}
vector<string> split(const string &s, char c) {
vector<string> v;
stringstream ss(s);
string x;
while (getline(ss, x, c))
v.emplace_back(x);
return move(v);
}
void err(vector<string>::iterator it) { cerr << endl; }
template <typename T, typename... Args>
void err(vector<string>::iterator it, T aa, Args... args) {
cerr << it->substr((*it)[0] == ' ', it->length()) << " = " << aa << " ",
err(++it, args...);
}
int main(void) {
int q;
cin >> q;
rep(i, q) {
cin >> t[i];
if (t[i] == 1) {
cin >> a[i] >> b[i];
ary.push_back(a[i]);
}
}
sort(begin(ary), end(ary));
ary.erase(unique(begin(ary), end(ary)), end(ary));
Binary_indexed_tree<18> bit;
bit.init();
int cnt = 0;
const int inf = 1 << 30;
int ans_pos_l = -inf;
int ans_pos_r = inf;
ll ans_min = 0LL;
rep(i, q) {
if (t[i] == 1) {
ans_min += b[i];
const int idx = lower_bound(begin(ary), end(ary), a[i]) - begin(ary);
bit.update(idx, 1);
cnt++;
const int half_l = (cnt + 1) / 2;
const int half_r = (cnt + 2) / 2;
const int tar_idx_l = bit.lower_bound(half_l) - 1;
const ll tar_val_l = ary[tar_idx_l];
const int tar_idx_r = bit.lower_bound(half_r) - 1;
const ll tar_val_r = ary[tar_idx_r];
if (a[i] <= ans_pos_l) {
ans_min += abs(ans_pos_l - a[i]);
}
if (ans_pos_r <= a[i]) {
ans_min += abs(ans_pos_r - a[i]);
}
ans_pos_l = tar_val_l;
ans_pos_r = tar_val_r;
// error(ans_pos_l, ans_pos_r, ans_min);
} else {
cout << ans_pos_l << " " << ans_min << endl;
}
}
return 0;
}
// |x - 1| + |x - 3| == 2
// |x - 1| + |x - 3| + |x - 5| == 4
| #include <bits/stdc++.h>
#include <sys/types.h>
#include <unistd.h>
#define _overload(_1, _2, _3, name, ...) name
#define _rep(i, n) _range(i, 0, n)
#define _range(i, a, b) for (int i = int(a); i < int(b); ++i)
#define rep(...) _overload(__VA_ARGS__, _range, _rep, )(__VA_ARGS__)
#define _rrep(i, n) _rrange(i, n, 0)
#define _rrange(i, a, b) for (int i = int(a) - 1; i >= int(b); --i)
#define rrep(...) _overload(__VA_ARGS__, _rrange, _rrep, )(__VA_ARGS__)
#define _all(arg) begin(arg), end(arg)
#define uniq(arg) sort(_all(arg)), (arg).erase(unique(_all(arg)), end(arg))
#define getidx(ary, key) lower_bound(_all(ary), key) - begin(ary)
#define clr(a, b) memset((a), (b), sizeof(a))
#define bit(n) (1LL << (n))
#define popcount(n) (__builtin_popcountll(n))
using namespace std;
template <class T> bool chmax(T &a, const T &b) {
return (a < b) ? (a = b, 1) : 0;
}
template <class T> bool chmin(T &a, const T &b) {
return (b < a) ? (a = b, 1) : 0;
}
using ll = long long;
using R = long double;
const R EPS = 1e-9L; // [-1000,1000]->EPS=1e-8 [-10000,10000]->EPS=1e-7
inline int sgn(const R &r) { return (r > EPS) - (r < -EPS); }
inline R sq(R x) { return sqrt(max(x, 0.0L)); }
template <typename T> vector<T> make_vector(size_t sz) { return vector<T>(sz); }
template <typename T, typename... Ts> auto make_vector(size_t sz, Ts... ts) {
return vector<decltype(make_vector<T>(ts...))>(sz, make_vector<T>(ts...));
}
template <typename T, typename U, typename... V>
typename enable_if<is_same<T, U>::value != 0>::type fill_value(U &u,
const V... v) {
u = U(v...);
}
template <typename T, typename U, typename... V>
typename enable_if<is_same<T, U>::value == 0>::type fill_value(U &u,
const V... v) {
for (auto &e : u) {
fill_value<T>(e, v...);
}
}
const int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
const int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
const pid_t pid = getpid();
// Problem Specific Parameter:
template <int depth> struct Binary_indexed_tree {
using T = int;
const static int h = depth;
const static int n = 1 << h;
T data[n];
void init() { fill_n(data, n, 0); }
void update(int i, T x) {
for (i++; i < n; i += i & -i) {
data[i] += x;
}
}
int lower_bound(T x) {
if (x <= 0)
return 0;
int i = 0;
for (int k = n; k > 0; k >>= 1) {
if (i + k < n and data[i + k] < x)
x -= data[i + k], i += k;
}
return i + 1;
}
};
const int limit = 200010;
int t[limit], a[limit], b[limit];
vector<int> ary;
#define error(args...) \
{ \
vector<string> _debug = split(#args, ','); \
err(begin(_debug), args); \
}
vector<string> split(const string &s, char c) {
vector<string> v;
stringstream ss(s);
string x;
while (getline(ss, x, c))
v.emplace_back(x);
return move(v);
}
void err(vector<string>::iterator it) { cerr << endl; }
template <typename T, typename... Args>
void err(vector<string>::iterator it, T aa, Args... args) {
cerr << it->substr((*it)[0] == ' ', it->length()) << " = " << aa << " ",
err(++it, args...);
}
int main(void) {
int q;
cin >> q;
rep(i, q) {
cin >> t[i];
if (t[i] == 1) {
cin >> a[i] >> b[i];
ary.push_back(a[i]);
}
}
sort(begin(ary), end(ary));
ary.erase(unique(begin(ary), end(ary)), end(ary));
Binary_indexed_tree<18> bit;
bit.init();
int cnt = 0;
const int inf = 1 << 30;
int ans_pos_l = -inf;
int ans_pos_r = inf;
ll ans_min = 0LL;
rep(i, q) {
if (t[i] == 1) {
ans_min += b[i];
const int idx = lower_bound(begin(ary), end(ary), a[i]) - begin(ary);
bit.update(idx, 1);
cnt++;
const int half_l = (cnt + 1) / 2;
const int half_r = (cnt + 2) / 2;
const int tar_idx_l = bit.lower_bound(half_l) - 1;
const ll tar_val_l = ary[tar_idx_l];
const int tar_idx_r = bit.lower_bound(half_r) - 1;
const ll tar_val_r = ary[tar_idx_r];
if (a[i] <= ans_pos_l) {
ans_min += abs(ans_pos_l - a[i]);
}
if (ans_pos_r <= a[i]) {
ans_min += abs(ans_pos_r - a[i]);
}
ans_pos_l = tar_val_l;
ans_pos_r = tar_val_r;
// error(ans_pos_l, ans_pos_r, ans_min);
} else {
cout << ans_pos_l << " " << ans_min << endl;
}
}
return 0;
}
// |x - 1| + |x - 3| == 2
// |x - 1| + |x - 3| + |x - 5| == 4
| replace | 88 | 89 | 88 | 89 | 0 | |
p03040 | C++ | Runtime Error | #include <bits/stdc++.h>
#define lson l, m, rt << 1
#define rson m + 1, r, rt << 1 | 1
using namespace std;
typedef long long ll;
const int MAXN = 25 + 5;
const ll INF = 1e18;
const ll MOD = 998244353;
const double pi = 3.1415926;
ll n, sum[2][(MAXN * 3) << 2], lazy[2][(MAXN * 3) << 2], rec[MAXN][3],
bb[MAXN * 3], cnt;
multiset<ll> ms;
multiset<ll>::iterator midit;
ll midpos;
void init() {
ms.clear();
memset(sum, 0, sizeof(sum));
cnt = 0;
memset(lazy, 0, sizeof(lazy));
}
ll Hash(ll x) { return lower_bound(bb + 1, bb + 1 + cnt, x) - bb; }
void pushdown(ll op, ll l, ll r, ll rt) {
if (lazy[op][rt]) {
lazy[op][rt << 1] += lazy[op][rt];
lazy[op][rt << 1 | 1] += lazy[op][rt];
ll m = (l + r) / 2;
sum[op][rt << 1] += lazy[op][rt] * (m - l + 1);
sum[op][rt << 1 | 1] += lazy[op][rt] * (r - (m + 1) + 1);
lazy[op][rt] = 0;
}
}
void pushup(ll op, ll rt) {
sum[op][rt] = sum[op][rt << 1] + sum[op][rt << 1 | 1];
}
void update(ll op, ll L, ll R, ll c, ll l, ll r, ll rt) {
if (L <= l && r <= R) {
lazy[op][rt] += c; //***注意是+=不是=
sum[op][rt] += (r - l + 1) * c;
return;
}
ll m = (l + r) / 2;
pushdown(op, l, r, rt);
if (L <= m) {
update(op, L, R, c, lson);
}
if (R > m) {
update(op, L, R, c, rson);
}
pushup(op, rt);
}
ll query(ll op, ll p, ll l, ll r, ll rt) {
if (l == r) {
return sum[op][rt];
}
ll m = (l + r) / 2;
pushdown(op, l, r, rt);
if (p <= m) {
return query(op, p, lson);
} else {
return query(op, p, rson);
}
}
void updmid(ll x) {
if (ms.empty()) {
ms.insert(x);
midpos = 1;
midit = ms.begin();
} else {
ms.insert(x);
if (x < *midit) {
midpos++;
}
ll newpos = (ms.size() + 1) / 2;
if (newpos > midpos) {
midit++;
}
if (newpos < midpos) {
midit--;
}
midpos = newpos;
}
update(0, 1, Hash(x - 1), x, 1, cnt, 1);
update(1, 1, Hash(x - 1), -1, 1, cnt, 1);
update(0, Hash(x + 1), cnt, -x, 1, cnt, 1);
update(1, Hash(x + 1), cnt, 1, 1, cnt, 1);
}
ll getmid() { return *midit; }
ll getans(ll x) {
ll p = Hash(x);
ll k = query(1, p, 1, cnt, 1);
ll a = query(0, p, 1, cnt, 1);
return k * x + a;
}
void solve() {
sort(bb + 1, bb + 1 + cnt);
cnt = unique(bb + 1, bb + 1 + cnt) - bb - 1;
ll sum = 0;
for (ll i = 1; i <= n; i++) {
ll op = rec[i][0];
if (op == 1) {
ll a = rec[i][1], b = rec[i][2];
sum += b;
updmid(a);
} else {
ll p = getmid();
ll ans1 = getans(p);
printf("%lld %lld\n", p, ans1 + sum);
}
}
}
int main() {
// freopen("c://duipai//data.txt","r",stdin);
// freopen("c://duipai//wa.txt","w",stdout);
// printf("%d",1^2^3^4^5^6^7^8^9^10^11^12^13^14^15);
while (~scanf("%lld", &n)) {
// string str;
// cin>>str;
// cout<<str<<endl;
init();
for (ll i = 1; i <= n; i++) {
ll op;
scanf("%lld", &op);
rec[i][0] = op;
if (op == 1) {
ll a, b;
scanf("%lld %lld", &a, &b);
rec[i][1] = a;
rec[i][2] = b;
bb[++cnt] = a;
bb[++cnt] = a - 1;
bb[++cnt] = a + 1;
}
}
solve();
}
}
/*
3
第-205
1 -3 3
1 0 8
2
*/
| #include <bits/stdc++.h>
#define lson l, m, rt << 1
#define rson m + 1, r, rt << 1 | 1
using namespace std;
typedef long long ll;
const int MAXN = 2e5 + 5;
const ll INF = 1e18;
const ll MOD = 998244353;
const double pi = 3.1415926;
ll n, sum[2][(MAXN * 3) << 2], lazy[2][(MAXN * 3) << 2], rec[MAXN][3],
bb[MAXN * 3], cnt;
multiset<ll> ms;
multiset<ll>::iterator midit;
ll midpos;
void init() {
ms.clear();
memset(sum, 0, sizeof(sum));
cnt = 0;
memset(lazy, 0, sizeof(lazy));
}
ll Hash(ll x) { return lower_bound(bb + 1, bb + 1 + cnt, x) - bb; }
void pushdown(ll op, ll l, ll r, ll rt) {
if (lazy[op][rt]) {
lazy[op][rt << 1] += lazy[op][rt];
lazy[op][rt << 1 | 1] += lazy[op][rt];
ll m = (l + r) / 2;
sum[op][rt << 1] += lazy[op][rt] * (m - l + 1);
sum[op][rt << 1 | 1] += lazy[op][rt] * (r - (m + 1) + 1);
lazy[op][rt] = 0;
}
}
void pushup(ll op, ll rt) {
sum[op][rt] = sum[op][rt << 1] + sum[op][rt << 1 | 1];
}
void update(ll op, ll L, ll R, ll c, ll l, ll r, ll rt) {
if (L <= l && r <= R) {
lazy[op][rt] += c; //***注意是+=不是=
sum[op][rt] += (r - l + 1) * c;
return;
}
ll m = (l + r) / 2;
pushdown(op, l, r, rt);
if (L <= m) {
update(op, L, R, c, lson);
}
if (R > m) {
update(op, L, R, c, rson);
}
pushup(op, rt);
}
ll query(ll op, ll p, ll l, ll r, ll rt) {
if (l == r) {
return sum[op][rt];
}
ll m = (l + r) / 2;
pushdown(op, l, r, rt);
if (p <= m) {
return query(op, p, lson);
} else {
return query(op, p, rson);
}
}
void updmid(ll x) {
if (ms.empty()) {
ms.insert(x);
midpos = 1;
midit = ms.begin();
} else {
ms.insert(x);
if (x < *midit) {
midpos++;
}
ll newpos = (ms.size() + 1) / 2;
if (newpos > midpos) {
midit++;
}
if (newpos < midpos) {
midit--;
}
midpos = newpos;
}
update(0, 1, Hash(x - 1), x, 1, cnt, 1);
update(1, 1, Hash(x - 1), -1, 1, cnt, 1);
update(0, Hash(x + 1), cnt, -x, 1, cnt, 1);
update(1, Hash(x + 1), cnt, 1, 1, cnt, 1);
}
ll getmid() { return *midit; }
ll getans(ll x) {
ll p = Hash(x);
ll k = query(1, p, 1, cnt, 1);
ll a = query(0, p, 1, cnt, 1);
return k * x + a;
}
void solve() {
sort(bb + 1, bb + 1 + cnt);
cnt = unique(bb + 1, bb + 1 + cnt) - bb - 1;
ll sum = 0;
for (ll i = 1; i <= n; i++) {
ll op = rec[i][0];
if (op == 1) {
ll a = rec[i][1], b = rec[i][2];
sum += b;
updmid(a);
} else {
ll p = getmid();
ll ans1 = getans(p);
printf("%lld %lld\n", p, ans1 + sum);
}
}
}
int main() {
// freopen("c://duipai//data.txt","r",stdin);
// freopen("c://duipai//wa.txt","w",stdout);
// printf("%d",1^2^3^4^5^6^7^8^9^10^11^12^13^14^15);
while (~scanf("%lld", &n)) {
// string str;
// cin>>str;
// cout<<str<<endl;
init();
for (ll i = 1; i <= n; i++) {
ll op;
scanf("%lld", &op);
rec[i][0] = op;
if (op == 1) {
ll a, b;
scanf("%lld %lld", &a, &b);
rec[i][1] = a;
rec[i][2] = b;
bb[++cnt] = a;
bb[++cnt] = a - 1;
bb[++cnt] = a + 1;
}
}
solve();
}
}
/*
3
第-205
1 -3 3
1 0 8
2
*/
| replace | 5 | 6 | 5 | 6 | 0 | |
p03040 | C++ | Runtime Error | #include <algorithm>
#include <cassert>
#include <cctype>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
// #define cerr if(false) cerr
#ifdef DEBUG
#define show(...) cerr << #__VA_ARGS__ << " = ", debug(__VA_ARGS__);
#else
#define show(...) 42
#endif
using namespace std;
using ll = long long;
using pii = pair<int, int>;
template <typename T, typename S>
ostream &operator<<(ostream &os, pair<T, S> a) {
os << '(' << a.first << ',' << a.second << ')';
return os;
}
template <typename T> ostream &operator<<(ostream &os, vector<T> v) {
for (auto x : v)
os << x << ' ';
return os;
}
void debug() { cerr << '\n'; }
template <typename H, typename... T> void debug(H a, T... b) {
cerr << a;
if (sizeof...(b))
cerr << ", ";
debug(b...);
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int q;
cin >> q;
multiset<ll> st1, st2;
ll x = 0, y = 0;
ll sum = 0;
int t = 0;
rep(i, q) {
int k;
cin >> k;
if (k == 1) {
ll a, b;
cin >> a >> b;
sum += b;
st2.insert(a);
y += a;
if (t % 2 == 0) {
auto itr = st2.end();
itr--;
x += *itr;
y -= *itr;
st1.insert(*itr);
st2.erase(itr);
} else {
auto itr1 = st1.begin();
auto itr2 = st2.end();
itr2--;
if (*itr1 < *itr2) {
x += *itr2;
y -= *itr2;
x -= *itr1;
y += *itr1;
st1.insert(*itr1);
st2.erase(itr1);
st2.insert(*itr2);
st1.erase(itr2);
}
}
t++;
} else {
ll num;
if (st1.size() == st2.size()) {
num = *(--st2.end());
} else {
num = *st1.begin();
}
show(num);
ll a = (ll)st1.size();
ll b = (ll)st2.size();
cout << num << " " << abs(x - a * num) + abs(y - b * num) + sum << "\n";
}
}
}
| #include <algorithm>
#include <cassert>
#include <cctype>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
// #define cerr if(false) cerr
#ifdef DEBUG
#define show(...) cerr << #__VA_ARGS__ << " = ", debug(__VA_ARGS__);
#else
#define show(...) 42
#endif
using namespace std;
using ll = long long;
using pii = pair<int, int>;
template <typename T, typename S>
ostream &operator<<(ostream &os, pair<T, S> a) {
os << '(' << a.first << ',' << a.second << ')';
return os;
}
template <typename T> ostream &operator<<(ostream &os, vector<T> v) {
for (auto x : v)
os << x << ' ';
return os;
}
void debug() { cerr << '\n'; }
template <typename H, typename... T> void debug(H a, T... b) {
cerr << a;
if (sizeof...(b))
cerr << ", ";
debug(b...);
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int q;
cin >> q;
multiset<ll> st1, st2;
ll x = 0, y = 0;
ll sum = 0;
int t = 0;
rep(i, q) {
int k;
cin >> k;
if (k == 1) {
ll a, b;
cin >> a >> b;
sum += b;
st2.insert(a);
y += a;
if (t % 2 == 0) {
auto itr = st2.end();
itr--;
x += *itr;
y -= *itr;
st1.insert(*itr);
st2.erase(itr);
} else {
auto itr1 = st1.begin();
auto itr2 = st2.end();
itr2--;
if (*itr1 < *itr2) {
x += *itr2;
y -= *itr2;
x -= *itr1;
y += *itr1;
st1.insert(*itr2);
st2.erase(itr2);
st2.insert(*itr1);
st1.erase(itr1);
}
}
t++;
} else {
ll num;
if (st1.size() == st2.size()) {
num = *(--st2.end());
} else {
num = *st1.begin();
}
show(num);
ll a = (ll)st1.size();
ll b = (ll)st2.size();
cout << num << " " << abs(x - a * num) + abs(y - b * num) + sum << "\n";
}
}
}
| replace | 82 | 86 | 82 | 86 | 0 | |
p03040 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define all(v) v.begin(), v.end()
typedef long long ll;
typedef pair<ll, ll> P;
typedef vector<ll> vec;
typedef vector<vec> mat;
const int MAX_N = 200000;
int bit[MAX_N + 1] = {0}, n;
int sum(int i) {
int s = 0;
while (i > 0) {
s += bit[i];
i -= i & -i;
}
return s;
}
void add(int i, int x) {
while (i <= n) {
bit[i] += x;
i += i & -i;
}
}
int search(int k) {
ll ok = 200000, ng = -1;
while (abs(ok - ng) > 1) {
ll mid = (ok + ng) / 2;
if (sum(mid) >= k)
ok = mid;
else
ng = mid;
}
return ok;
}
int main() {
int q, Q[200001][3];
cin >> q;
n = MAX_N;
vector<P> A;
vec B(200001, -1), C(200001);
rep(i, q) {
int c, a, b;
cin >> c;
Q[i][0] = c;
if (c == 1)
cin >> a >> b, Q[i][1] = a, Q[i][2] = b, A.push_back(P(a, i));
}
sort(all(A));
rep(i, A.size()) B[A[i].second] = i + 1;
rep(i, B.size()) if (B[i] != -1) C[B[i]] = i;
ll ans = 0, x, c = 0;
rep(i, q) {
if (Q[i][0] == 1) {
c++;
if (c == 1)
;
else if (c % 2 == 0)
ans += abs(Q[i][1] - Q[C[search(c / 2)]][1]);
else {
int a = Q[C[search(c / 2)]][1], b = Q[C[search(c / 2 + 1)]][1];
if (Q[i][1] < a)
ans += abs(Q[i][1] - a);
if (b < Q[i][q])
ans += abs(Q[i][1] - b);
}
add(B[i], 1);
x = Q[C[search((c + 1) / 2)]][1];
ans += Q[i][2];
} else {
cout << x << " " << ans << "\n";
}
}
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define all(v) v.begin(), v.end()
typedef long long ll;
typedef pair<ll, ll> P;
typedef vector<ll> vec;
typedef vector<vec> mat;
const int MAX_N = 200000;
int bit[MAX_N + 1] = {0}, n;
int sum(int i) {
int s = 0;
while (i > 0) {
s += bit[i];
i -= i & -i;
}
return s;
}
void add(int i, int x) {
while (i <= n) {
bit[i] += x;
i += i & -i;
}
}
int search(int k) {
ll ok = 200000, ng = -1;
while (abs(ok - ng) > 1) {
ll mid = (ok + ng) / 2;
if (sum(mid) >= k)
ok = mid;
else
ng = mid;
}
return ok;
}
int main() {
int q, Q[200001][3];
cin >> q;
n = MAX_N;
vector<P> A;
vec B(200001, -1), C(200001);
rep(i, q) {
int c, a, b;
cin >> c;
Q[i][0] = c;
if (c == 1)
cin >> a >> b, Q[i][1] = a, Q[i][2] = b, A.push_back(P(a, i));
}
sort(all(A));
rep(i, A.size()) B[A[i].second] = i + 1;
rep(i, B.size()) if (B[i] != -1) C[B[i]] = i;
ll ans = 0, x, c = 0;
rep(i, q) {
if (Q[i][0] == 1) {
c++;
if (c == 1)
;
else if (c % 2 == 0)
ans += abs(Q[i][1] - Q[C[search(c / 2)]][1]);
else {
int a = Q[C[search(c / 2)]][1], b = Q[C[search(c / 2 + 1)]][1];
if (Q[i][1] < a)
ans += abs(Q[i][1] - a);
if (b < Q[i][1])
ans += abs(Q[i][1] - b);
}
add(B[i], 1);
x = Q[C[search((c + 1) / 2)]][1];
ans += Q[i][2];
} else {
cout << x << " " << ans << "\n";
}
}
} | replace | 63 | 64 | 63 | 64 | 0 | |
p03040 | C++ | Runtime Error | #include <iostream>
#include <set>
using namespace std;
multiset<long long> A, B;
long long bs, as, q, sz;
void lax() {
while (A.size() > (sz + 1) / 2) {
multiset<long long>::iterator it = A.end();
it--;
as += 2 * (*it);
B.insert(*it);
A.erase(*it);
}
while (!B.empty()) {
multiset<long long>::iterator it = A.end();
it--;
if (*it > *B.begin()) {
long long a = *it, b = *B.begin();
A.erase(it);
B.erase(B.begin());
as += 2 * a;
as -= 2 * b;
A.insert(b);
B.insert(a);
} else
break;
}
}
long long geten() {
multiset<long long>::iterator it = A.end();
it--;
return *it;
}
int main() {
cin >> q;
for (int i = 0; i < q; i++) {
int t, a, b;
cin >> t;
if (t == 1) {
cin >> a >> b;
sz++;
A.insert(a);
as -= a;
bs += b;
lax();
} else
cout << geten() << ' ' << +geten() * (sz % 2) + as + bs << '\n';
}
} | #include <iostream>
#include <set>
using namespace std;
multiset<long long> A, B;
long long bs, as, q, sz;
void lax() {
while (A.size() > (sz + 1) / 2) {
multiset<long long>::iterator it = A.end();
it--;
as += 2 * (*it);
B.insert(*it);
A.erase(it);
}
while (!B.empty()) {
multiset<long long>::iterator it = A.end();
it--;
if (*it > *B.begin()) {
long long a = *it, b = *B.begin();
A.erase(it);
B.erase(B.begin());
as += 2 * a;
as -= 2 * b;
A.insert(b);
B.insert(a);
} else
break;
}
}
long long geten() {
multiset<long long>::iterator it = A.end();
it--;
return *it;
}
int main() {
cin >> q;
for (int i = 0; i < q; i++) {
int t, a, b;
cin >> t;
if (t == 1) {
cin >> a >> b;
sz++;
A.insert(a);
as -= a;
bs += b;
lax();
} else
cout << geten() << ' ' << +geten() * (sz % 2) + as + bs << '\n';
}
} | replace | 13 | 14 | 13 | 14 | 0 | |
p03040 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
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;
}
void print() { cout << "\n"; }
template <class T> void print(const T &x) { cout << x << "\n"; }
template <class T, class... Args> void print(const T &x, const Args &...args) {
cout << x << " ";
print(args...);
}
template <class T> void printVector(const vector<T> &v) {
for (const T &x : v) {
cout << x << " ";
}
cout << "\n";
}
using ll = long long;
#define ALL(v) (v).begin(), (v).end()
#define RALL(v) (v).rbegin(), (v).rend()
const double EPS = 1e-7;
const int INF = 1 << 30;
const ll LLINF = 1LL << 60;
const double PI = acos(-1);
constexpr int MOD = 1000000007;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
//-------------------------------------
template <typename T> struct BIT {
int n;
vector<T> bit;
BIT(int _n) { init(_n); }
void init(int _n) {
n = _n + 1;
bit.resize(n + 1, 0);
}
// [0, k)
T sum(int k) {
T res = 0;
for (int i = k - 1; i >= 0; i = (i & (i + 1)) - 1) {
res += bit[i];
}
return res;
}
// [l, r]
T sum(int l, int r) { return (l <= r ? sum(r + 1) - sum(l) : 0); }
// bit[k] += x
void add(int k, T x) {
for (int i = k; i < n; i |= i + 1) {
bit[i] += x;
}
}
// v[0] + ... + v[res] >= x
int lower_bound(T x) {
int res = -1;
int k = 1;
while (2 * k <= n) {
k <<= 1;
}
for (; k > 0; k >>= 1) {
if (res + k < n && bit[res + k] < x) {
x -= bit[res + k];
res += k;
}
}
return res + 1;
}
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int q;
cin >> q;
vector<ll> t(q), a(q), b(q);
vector<ll> As;
for (int i = 0; i < q; i++) {
cin >> t[i];
if (t[i] == 1) {
cin >> a[i] >> b[i];
As.emplace_back(a[i]);
}
}
sort(ALL(As));
As.erase(unique(ALL(As)), end(As));
map<ll, int> mp;
for (int i = 0; i < As.size(); i++) {
mp[As[i]] = i;
}
BIT<ll> bcnt(As.size()), bsum(As.size());
ll sum = 0;
int sz = 0;
for (int i = 0; i < q; i++) {
if (t[i] == 1) {
int id = mp[a[i]];
bsum.add(id, a[i]), bcnt.add(id, 1);
sum += b[i];
sz++;
} else {
ll res = sum;
int id = bcnt.lower_bound((sz + 1) / 2);
res += bsum.sum(id + 1, sz - 1);
res -= As[id] * bcnt.sum(id + 1, sz - 1);
res += As[id] * bcnt.sum(0, id - 1);
res -= bsum.sum(0, id - 1);
print(As[id], res);
}
}
} | #include <bits/stdc++.h>
using namespace std;
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;
}
void print() { cout << "\n"; }
template <class T> void print(const T &x) { cout << x << "\n"; }
template <class T, class... Args> void print(const T &x, const Args &...args) {
cout << x << " ";
print(args...);
}
template <class T> void printVector(const vector<T> &v) {
for (const T &x : v) {
cout << x << " ";
}
cout << "\n";
}
using ll = long long;
#define ALL(v) (v).begin(), (v).end()
#define RALL(v) (v).rbegin(), (v).rend()
const double EPS = 1e-7;
const int INF = 1 << 30;
const ll LLINF = 1LL << 60;
const double PI = acos(-1);
constexpr int MOD = 1000000007;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
//-------------------------------------
template <typename T> struct BIT {
int n;
vector<T> bit;
BIT(int _n) { init(_n); }
void init(int _n) {
n = _n + 1;
bit.resize(n + 1, 0);
}
// [0, k)
T sum(int k) {
T res = 0;
for (int i = k - 1; i >= 0; i = (i & (i + 1)) - 1) {
res += bit[i];
}
return res;
}
// [l, r]
T sum(int l, int r) { return (l <= r ? sum(r + 1) - sum(l) : 0); }
// bit[k] += x
void add(int k, T x) {
for (int i = k; i < n; i |= i + 1) {
bit[i] += x;
}
}
// v[0] + ... + v[res] >= x
int lower_bound(T x) {
int res = -1;
int k = 1;
while (2 * k <= n) {
k <<= 1;
}
for (; k > 0; k >>= 1) {
if (res + k < n && bit[res + k] < x) {
x -= bit[res + k];
res += k;
}
}
return res + 1;
}
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int q;
cin >> q;
vector<ll> t(q), a(q), b(q);
vector<ll> As;
for (int i = 0; i < q; i++) {
cin >> t[i];
if (t[i] == 1) {
cin >> a[i] >> b[i];
As.emplace_back(a[i]);
}
}
sort(ALL(As));
As.erase(unique(ALL(As)), end(As));
map<ll, int> mp;
for (int i = 0; i < As.size(); i++) {
mp[As[i]] = i;
}
BIT<ll> bcnt(As.size()), bsum(As.size());
ll sum = 0;
int sz = 0;
for (int i = 0; i < q; i++) {
if (t[i] == 1) {
int id = mp[a[i]];
bsum.add(id, a[i]), bcnt.add(id, 1);
sum += b[i];
sz++;
} else {
ll res = sum;
int id = bcnt.lower_bound((sz + 1) / 2);
res += bsum.sum(id + 1, (int)As.size() - 1);
res -= As[id] * bcnt.sum(id + 1, (int)As.size() - 1);
res += As[id] * bcnt.sum(0, id - 1);
res -= bsum.sum(0, id - 1);
print(As[id], res);
}
}
} | replace | 115 | 117 | 115 | 117 | 0 | |
p03040 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define REP(i, a, n) for (int i = (a); i < (int)(n); i++)
#define rep(i, n) REP(i, 0, n)
#define FOR(it, c) \
for (__typeof((c).begin()) it = (c).begin(); it != (c).end(); ++it)
#define ALLOF(c) (c).begin(), (c).end()
typedef long long ll;
typedef unsigned long long ull;
int main() {
int Q;
cin >> Q;
ll bsum = 0;
multiset<ll> l, r;
ll lsum = 0, rsum = 0;
rep(i, Q) {
int x;
cin >> x;
if (x == 1) {
ll a, b;
cin >> a >> b;
bsum += b;
l.insert(a);
lsum += a;
if (l.size() - r.size() > 1) {
auto itr = --l.end();
ll x = *itr;
l.erase(itr);
lsum -= x;
r.insert(x);
rsum += x;
}
while (true) {
auto itrl = --l.end();
auto itrr = r.begin();
ll x = *itrl;
ll y = *itrr;
if (x <= y)
break;
l.erase(itrl);
lsum -= x;
r.erase(itrr);
rsum -= y;
l.insert(y);
lsum += y;
r.insert(x);
rsum += x;
}
} else {
if (l.size() == 0) {
cout << 0 << endl;
} else {
auto itr = --l.end();
ll x = *itr;
ll N = l.size();
ll M = r.size();
// cout << N << " " << M << " " << x << endl;
cout << x << " " << bsum + N * x - lsum + rsum - M * x << endl;
}
}
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define REP(i, a, n) for (int i = (a); i < (int)(n); i++)
#define rep(i, n) REP(i, 0, n)
#define FOR(it, c) \
for (__typeof((c).begin()) it = (c).begin(); it != (c).end(); ++it)
#define ALLOF(c) (c).begin(), (c).end()
typedef long long ll;
typedef unsigned long long ull;
int main() {
int Q;
cin >> Q;
ll bsum = 0;
multiset<ll> l, r;
ll lsum = 0, rsum = 0;
rep(i, Q) {
int x;
cin >> x;
if (x == 1) {
ll a, b;
cin >> a >> b;
bsum += b;
l.insert(a);
lsum += a;
if (l.size() - r.size() > 1) {
auto itr = --l.end();
ll x = *itr;
l.erase(itr);
lsum -= x;
r.insert(x);
rsum += x;
}
while (true) {
if (r.size() == 0)
break;
auto itrl = --l.end();
auto itrr = r.begin();
ll x = *itrl;
ll y = *itrr;
if (x <= y)
break;
l.erase(itrl);
lsum -= x;
r.erase(itrr);
rsum -= y;
l.insert(y);
lsum += y;
r.insert(x);
rsum += x;
}
} else {
if (l.size() == 0) {
cout << 0 << endl;
} else {
auto itr = --l.end();
ll x = *itr;
ll N = l.size();
ll M = r.size();
// cout << N << " " << M << " " << x << endl;
cout << x << " " << bsum + N * x - lsum + rsum - M * x << endl;
}
}
}
return 0;
}
| insert | 36 | 36 | 36 | 38 | TLE | |
p03040 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
typedef long long LL;
const int nn = 1e6 + 5;
int main() {
LL q, a, b, tipe, l1 = 0, l2 = 0;
LL tot_l = 0, tot_r = 0, tot = 0;
priority_queue<LL> pq1, pq2;
scanf("%d", &q);
while (q--) {
scanf("%lld", &tipe);
if (tipe == 1) {
scanf("%lld %lld", &a, &b);
tot += b;
if (pq1.empty() || a <= pq1.top()) {
pq1.push(a);
l1++;
tot_l += a;
} else {
pq2.push(-a);
l2++;
tot_r += a;
}
if (l1 - l2 > 1) {
l1--;
tot_l -= pq1.top();
tot_r += pq1.top();
l2++;
pq2.push(-pq1.top());
pq1.pop();
} else if (l2 - l1 > 1) {
l2--;
tot_l -= pq2.top();
tot_r += pq2.top();
l1++;
pq1.push(-pq2.top());
pq2.pop();
}
} else {
if (l1 >= l2) {
LL ans = pq1.top() * l1 - tot_l + tot_r - l2 * pq1.top() + tot;
printf("%lld %lld\n", pq1.top(), ans);
} else {
LL ans = -pq2.top() * l1 - tot_l + tot_r - l2 * -pq2.top() + tot;
printf("%lld %lld\n", -pq2.top(), ans);
}
}
}
} | #include <bits/stdc++.h>
using namespace std;
typedef long long LL;
const int nn = 1e6 + 5;
int main() {
LL q, a, b, tipe, l1 = 0, l2 = 0;
LL tot_l = 0, tot_r = 0, tot = 0;
priority_queue<LL> pq1, pq2;
scanf("%lld", &q);
while (q--) {
scanf("%lld", &tipe);
if (tipe == 1) {
scanf("%lld %lld", &a, &b);
tot += b;
if (pq1.empty() || a <= pq1.top()) {
pq1.push(a);
l1++;
tot_l += a;
} else {
pq2.push(-a);
l2++;
tot_r += a;
}
if (l1 - l2 > 1) {
l1--;
tot_l -= pq1.top();
tot_r += pq1.top();
l2++;
pq2.push(-pq1.top());
pq1.pop();
} else if (l2 - l1 > 1) {
l2--;
tot_l -= pq2.top();
tot_r += pq2.top();
l1++;
pq1.push(-pq2.top());
pq2.pop();
}
} else {
if (l1 >= l2) {
LL ans = pq1.top() * l1 - tot_l + tot_r - l2 * pq1.top() + tot;
printf("%lld %lld\n", pq1.top(), ans);
} else {
LL ans = -pq2.top() * l1 - tot_l + tot_r - l2 * -pq2.top() + tot;
printf("%lld %lld\n", -pq2.top(), ans);
}
}
}
} | replace | 10 | 11 | 10 | 11 | TLE | |
p03040 | C++ | Runtime Error | /*
* じょえチャンネル
* 高評価・チャンネル登録よろしくおねがいします！
* https://www.youtube.com/channel/UCRXsI3FL_kvaVL9zoolBfbQ
*/
#include <bits/stdc++.h>
// GCC
// #define _GLIBCXX_DEBUG
// Clang
// #define _LIBCPP_DEBUG 0
#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#define f(i, n) for (int i = 0; i < (n); i++)
// here!!!
// define int long long !!!!!
#define int long long
// define int long long !!!!!
#define mod (int)((1e9) + 7)
// constexpr int mod = 998244353ll;
#ifdef int
#define inf (int)(3e18)
#else
#define inf (int)(5e8)
#endif
#define intt long long
#define itn long long
#define P pair<long long, long long>
#define rep(i, n) for (int i = 0; i < n; i++)
#define REP(i, n) for (int i = 1; i <= n; i++)
#define ALL(v) v.begin(), v.end()
using namespace std;
// Library
// モッドパウ
inline int modpow(int x, int y, int m = mod) {
int res = 1;
while (y) {
if (y & 1) {
res *= x;
res %= m;
}
x = x * x % m;
y /= 2;
}
return res;
}
int mypow(int x, int y) {
int res = 1;
while (y) {
if (y % 2) {
res *= x;
}
x = x * x;
y /= 2;
}
return res;
}
// is the number (x) a prime number?
bool prime(int x) {
if (!x || x == 1) {
return false;
}
for (int i = 2; i * i <= x; i++) {
if (!(x % i)) {
return false;
}
}
return true;
}
// saidai-kouyakusuu
inline int gcd(int x, int y) {
if (!y) {
return x;
}
return gcd(y, x % y);
}
// number of keta
int keta(int x) {
int ans = 0;
while (x) {
x /= 10;
ans++;
}
return ans;
}
// sum of keta
int ketasum(int x) {
int ans = 0;
while (x) {
ans += x % 10;
x /= 10;
}
return ans;
}
inline int lcm(int x, int y) {
int ans = x / gcd(x, y) * y;
return ans;
}
int twobeki(int x) {
int ans = 0;
while (1) {
if (!(x & 1)) {
ans++;
x /= 2;
} else {
break;
}
}
return ans;
}
template <class T, class U> inline bool chmax(T &lhs, const U &rhs) {
if (lhs < rhs) {
lhs = rhs;
return 1;
}
return 0;
}
template <class T, class U> inline bool chmin(T &lhs, const U &rhs) {
if (lhs > rhs) {
lhs = rhs;
return 1;
}
return 0;
}
void Yes() { cout << "Yes" << endl; }
void No() { cout << "No" << endl; }
void YES() { cout << "YES" << endl; }
void NO() { cout << "NO" << endl; }
#define fin(i) scanf("%lld", &i)
#define fout(i) printf("%lld", i)
#define fendl printf("\n")
int kai(int x, int y) {
int res = 1;
for (int i = x - y + 1; i <= x; i++) {
res *= i;
res %= mod;
}
return res;
}
int comb(int x, int y) {
if (y > x)
return 0;
// cout<<kai(x, y)<<' '<<modpow(kai(y, y), mod - 2)<<endl;
return kai(x, y) * modpow(kai(y, y), mod - 2) % mod;
}
// Library-End
#define vecin(v) \
for (int i = 0; i < v.size(); i++) \
scanf("%lld", &v[i]);
#define vecout(v) \
{ \
for (int i = 0; i < (int)v.size(); i++) \
printf("%lld ", v[i]); \
printf("\n"); \
}
// template<typename T, typename U>
// class SegTree {
// protected:
// unsigned int n = 1, rank = 0;
// std::vector<T> node;
// T nodee;
// virtual T nodef(const T&, const T&)const = 0;
// public:
// SegTree(unsigned int m, T init, T nodee):nodee(nodee) {
// while (n < m) {
// n *= 2;
// rank++;
// }
// node.resize(2 * n);
// for (unsigned int i = n; i < 2 * n; i++)node[i] = init;
// }
// SegTree(const std::vector<T>& initvec, T nodee):nodee(nodee) {
// unsigned int m = initvec.size();
// while (n < m) {
// n *= 2;
// rank++;
// }
// node.resize(2 * n);
// for (unsigned int i = n; i < 2 * n; i++) {
// if (i - n < m)node[i] = initvec[i - n];
// }
// }
// virtual void update(int i, U x) {
// i += n;
// node[i] = x;
// while (i != 1) {
// i >>= 1;
// node[i] = nodef(node[2 * i], node[2 * i + 1]);
// }
// }
// virtual T query(int l, int r) {
// l += n; r += n;
// int ls = nodee, rs = nodee;
// while (l < r) {
// if (l & 1) {
// ls = nodef(ls, node[l]);
// l++;
// }
// if (r & 1) {
// r--;
// rs = nodef(node[r], rs);
// }
// l >>= 1; r >>= 1;
// }
// return nodef(ls, rs);
// }
// virtual T operator[](const int& x) {
// return node[n + x];
// }
// void fill(T x) {
// std::fill(all(node), x);
// }
// void print() {
// rep(i, n)std::cout << operator[](i) << " ";
// std::cout << std::endl;
// }
// };
// class RSQ :public SegTree<int, int> {
// int nodef(const int& lhs,const int& rhs){return lhs+rhs;}
// public:
// RSQ(int size, const int& def = 0) :SegTree<int, int>(size, def, 0) {}
// RSQ(const std::vector<int>& initvec) :SegTree<int, int>(initvec, 0) {}
// };
// class RMiQ :public SegTree<int, int> {
// int nodef(const int& lhs,const int& rhs){return std::min(lhs,rhs);}
// public:
// RMiQ(int size, const int& def = 0) :SegTree<int, int>(size, def, 0) {}
// RMiQ(const std::vector<int>& initvec) :SegTree<int, int>(initvec, 0) {}
// };
// class RMaQ :public SegTree<int, int> {
// int nodef(const int& lhs,const int& rhs){return std::max(lhs,rhs);}
// public:
// RMaQ(int size, const int& def = 0) :SegTree<int, int>(size, def, 0) {}
// RMaQ(const std::vector<int>& initvec) :SegTree<int, int>(initvec, 0) {}
// };
// template<typename T, typename U>
// class IntervalSegTree :public SegTree<T, U> {
// protected:
// using SegTree<T, U>::n;
// using SegTree<T, U>::rank;
// using SegTree<T, U>::node;
// using SegTree<T, U>::nodef;
// using SegTree<T, U>::nodee;
// std::vector<U> lazy;
// std::vector<bool> lazyflag;
// std::vector<int> width;
// virtual void lazyf(U&, const U&) = 0;
// virtual void updf(T&, const U&, const unsigned int&) = 0;
// void eval(int k) {
// for (int i = rank; i > 0; i--) {
// int nk = k >> i;
// if (lazyflag[nk]) {
// updf(node[2 * nk], lazy[nk], width[2 * nk]);
// updf(node[2 * nk + 1], lazy[nk], width[2 * nk + 1]);
// if (lazyflag[2 * nk])lazyf(lazy[2 * nk], lazy[nk]);
// else lazy[2 * nk] = lazy[nk];
// if (lazyflag[2 * nk + 1])lazyf(lazy[2 * nk + 1], lazy[nk]);
// else lazy[2 * nk + 1] = lazy[nk];
// lazyflag[2 * nk] = lazyflag[2 * nk + 1] = true;
// lazyflag[nk] = false;
// }
// }
// }
// public:
// IntervalSegTree(unsigned int m, T init, T nodee) :SegTree<T, U>(m, init,
// nodee) {
// lazy.resize(2 * n); lazyflag.resize(2 * n); width.resize(2 * n);
// width[1] = n;
// for (unsigned int i = 2; i < 2 * n; i++) {
// width[i] = width[i >> 1] >> 1;
// }
// }
// IntervalSegTree(T nodee, const std::vector<T>& initvec) :SegTree<T,
// U>(initvec, nodee) {
// lazy.resize(2 * n); lazyflag.resize(2 * n); width.resize(2 * n);
// width[1] = n;
// for (unsigned int i = 2; i < 2 * n; i++) {
// width[i] = width[i >> 1] >> 1;
// }
// }
// void update(int i, U x) {
// i += n;
// eval(i);
// updf(node[i], x, width[i]);
// if (lazyflag[i])lazyf(lazy[i], x);
// else {
// lazyflag[i] = true;
// lazy[i] = x;
// }
// while (i /= 2)node[i] = nodef(node[2 * i], node[2 * i + 1]);
// }
// void update(int l, int r, U x) {
// l += n; r += n;
// int nl = l, nr = r;
// while (!(nl & 1))nl >>= 1;
// while (!(nr & 1))nr >>= 1;
// nr--;
// eval(nl); eval(nr);
// while (l < r) {
// if (l & 1) {
// updf(node[l], x, width[l]);
// if (lazyflag[l])lazyf(lazy[l], x);
// else {
// lazyflag[l] = true;
// lazy[l] = x;
// }
// l++;
// }
// if (r & 1) {
// r--;
// updf(node[r], x, width[r]);
// if (lazyflag[r])lazyf(lazy[r], x);
// else {
// lazyflag[r] = true;
// lazy[r] = x;
// }
// }
// l >>= 1; r >>= 1;
// }
// while (nl >>= 1)node[nl] = nodef(node[2 * nl], node[2 * nl + 1]);
// while (nr >>= 1)node[nr] = nodef(node[2 * nr], node[2 * nr + 1]);
// }
// T query(int l, int r) {
// l += n; r += n;
// eval(l); eval(r - 1);
// int ls = nodee, rs = nodee;
// while (l < r) {
// if (l & 1) {
// ls = nodef(ls, node[l]);
// l++;
// }
// if (r & 1) {
// r--;
// rs = nodef(node[r], rs);
// }
// l >>= 1; r >>= 1;
// }
// return nodef(ls, rs);
// }
// T operator[](const int& x) {
// eval(n + x);
// return node[n + x];
// }
// T queryForAll() {
// return node[1];
// }
// };
// class RAQRSQ :public IntervalSegTree<int, int> {
// int nodef(const int& a, const int& b)const { return a + b; }
// void lazyf(int& a, const int& b) { a += b; }
// void updf(int& a, const int& b, const unsigned int& width) { a += width *
// b; }
// public:
// RAQRSQ(int size, const int& def = 0) :IntervalSegTree<int, int>(size,
// def, 0) {
// for (int i = n - 1; i > 0; i--)node[i] = nodef(node[2 * i], node[2 *
// i + 1]);
// }
// RAQRSQ(const std::vector<int>& initvec) :IntervalSegTree<int,
// int>((int)0, initvec) {
// for (int i = n - 1; i > 0; i--)node[i] = nodef(node[2 * i], node[2 *
// i + 1]);
// }
// };
// class RAQRMiQ :public IntervalSegTree<int, int> {
// int nodef(const int& a, const int& b)const { return std::min(a, b); }
// void lazyf(int& a, const int& b) { a += b; }
// void updf(int& a, const int& b, const unsigned int& width) { a += b; }
// public:
// RAQRMiQ(int size, const int& def = 0) :IntervalSegTree<int, int>(size,
// def, inf) {
// for (int i = n - 1; i > 0; i--)node[i] = nodef(node[2 * i], node[2 *
// i + 1]);
// }
// RAQRMiQ(const std::vector<int>& initvec) :IntervalSegTree<int, int>(inf,
// initvec) {
// for (int i = n - 1; i > 0; i--)node[i] = nodef(node[2 * i], node[2 *
// i + 1]);
// }
// };
// class RAQRMaQ :public IntervalSegTree<int, int> {
// int nodef(const int& a, const int& b)const { return std::max(a, b); }
// void lazyf(int& a, const int& b) { a += b; }
// void updf(int& a, const int& b, const unsigned int& width) { a += b; }
// public:
// RAQRMaQ(unsigned int size, const int& def = 0) :IntervalSegTree<int,
// int>(size, def, -inf) {
// for (int i = n - 1; i > 0; i--)node[i] = nodef(node[2 * i], node[2 *
// i + 1]);
// }
// RAQRMaQ(const std::vector<int>& initvec) :IntervalSegTree<int, int>(-inf,
// initvec) {
// for (int i = n - 1; i > 0; i--)node[i] = nodef(node[2 * i], node[2 *
// i + 1]);
// }
// };
// class RUQRSQ :public IntervalSegTree<int, int> {
// int nodef(const int& a, const int& b)const { return a + b; }
// void lazyf(int& a, const int& b) { a = b; }
// void updf(int& a, const int& b, const unsigned int& width) { a = width *
// b; }
// public:
// RUQRSQ(int size, const int& def = 0) :IntervalSegTree<int, int>(size,
// def, 0) {
// for (int i = n - 1; i > 0; i--)node[i] = nodef(node[2 * i], node[2 *
// i + 1]);
// }
// RUQRSQ(const std::vector<int>& initvec) :IntervalSegTree<int,
// int>((int)0, initvec) {
// for (int i = n - 1; i > 0; i--)node[i] = nodef(node[2 * i], node[2 *
// i + 1]);
// }
// };
// class RUQRMiQ :public IntervalSegTree<int, int> {
// int nodef(const int& a, const int& b)const { return std::min(a, b); }
// void lazyf(int& a, const int& b) { a = b; }
// void updf(int& a, const int& b, const unsigned int& width) { a = b; }
// public:
// RUQRMiQ(int size, const int& def = 0) :IntervalSegTree<int, int>(size,
// def, inf) {
// for (int i = n - 1; i > 0; i--)node[i] = nodef(node[2 * i], node[2 *
// i + 1]);
// }
// RUQRMiQ(const std::vector<int>& initvec) :IntervalSegTree<int, int>(inf,
// initvec) {
// for (int i = n - 1; i > 0; i--)node[i] = nodef(node[2 * i], node[2 *
// i + 1]);
// }
// };
// class RUQRMaQ :public IntervalSegTree<int, int> {
// int nodef(const int& a, const int& b)const { return std::max(a, b); }
// void lazyf(int& a, const int& b) { a = b; }
// void updf(int& a, const int& b, const unsigned int& width) { a = b; }
// public:
// RUQRMaQ(int size, const int& def = 0) :IntervalSegTree<int, int>(size,
// def, -inf) {
// for (int i = n - 1; i > 0; i--)node[i] = nodef(node[2 * i], node[2 *
// i + 1]);
// }
// RUQRMaQ(const std::vector<int>& initvec) :IntervalSegTree<int, int>(-inf,
// initvec) {
// for (int i = n - 1; i > 0; i--)node[i] = nodef(node[2 * i], node[2 *
// i + 1]);
// }
// };
// SegTree
template <class T> class SegTree {
int n; // 葉の数
vector<T> data; // データを格納するvector
T def; // 初期値かつ単位元
function<T(T, T)> operation; // 区間クエリで使う処理
function<T(T, T)> update; // 点更新で使う処理
// 区間[a,b)の総和。ノードk=[l,r)に着目している。
T _query(int a, int b, int k, int l, int r) {
if (r <= a || b <= l)
return def; // 交差しない
if (a <= l && r <= b)
return data[k]; // a,l,r,bの順で完全に含まれる
else {
T c1 = _query(a, b, 2 * k + 1, l, (l + r) / 2); // 左の子
T c2 = _query(a, b, 2 * k + 2, (l + r) / 2, r); // 右の子
return operation(c1, c2);
}
}
public:
// _n:必要サイズ, _def:初期値かつ単位元, _operation:クエリ関数,
// _update:更新関数
SegTree(size_t _n, T _def, function<T(T, T)> _operation,
function<T(T, T)> _update)
: def(_def), operation(_operation), update(_update) {
n = 1;
while (n < _n) {
n *= 2;
}
data = vector<T>(2 * n - 1, def);
}
// 場所i(0-indexed)の値をxで更新
void change(int i, T x) {
i += n - 1;
data[i] = update(data[i], x);
while (i > 0) {
i = (i - 1) / 2;
data[i] = operation(data[i * 2 + 1], data[i * 2 + 2]);
}
}
// [a, b)の区間クエリを実行
T query(int a, int b) { return _query(a, b, 0, 0, n); }
// 添字でアクセス
T operator[](int i) { return data[i + n - 1]; }
};
#define R_MIN ([](long long a, long long b) { return min(a, b); })
#define R_MAX ([](long long a, long long b) { return max(a, b); })
#define R_SUM ([](long long a, long long b) { return a + b; })
#define NORMAL_UPDATE ([](long long a, long long b) { return b; })
#define ADD_UPDATE ([](long long a, long long b) { return a + b; })
#define MINUS_UPDATE ([](long long a, long long b) { return a - b; }
class Union_Find {
vector<int> par;
vector<int> rankmy;
vector<int> ookisa;
public:
Union_Find(int size) {
par = vector<int>(size);
rankmy = vector<int>(size);
ookisa = vector<int>(size);
for (int i = 0; i < size; i++) {
par[i] = i;
ookisa[i] = 1;
}
}
int find(int x) {
if (par[x] == x) {
return x;
}
return par[x] = find(par[x]);
}
void unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y) {
return;
}
if (rankmy[x] < rankmy[y]) {
par[x] = y;
ookisa[y] += ookisa[x];
ookisa[x] = 0;
} else {
par[y] = x;
ookisa[x] += ookisa[y];
ookisa[y] = 0;
if (rankmy[x] == rankmy[y]) {
rankmy[x]++;
}
}
}
int size(int i) {
i = find(i);
return ookisa[i];
}
bool same(int x, int y) { return find(x) == find(y); }
};
class BIT {
vector<int> data;
int size = 0;
public:
BIT(int _size) {
data = vector<int>(_size + 1);
size = _size;
}
void add(int i, int x) {
while (i <= size) {
data[i] += x;
i += i & -i;
}
}
int sum(int i) {
assert(i <= size);
int s = 0;
while (i > 0) {
s += data[i];
i -= i & -i;
}
return s;
}
int lower_bound(int x) {
if (x <= 0) {
return 0;
} else {
int i = 0;
int r = 1;
while (r < size)
r = r << 1;
for (int len = r; len > 0; len = len >> 1) {
if (i + len < size && data[i + len] < x) {
x -= data[i + len];
i += len;
}
}
return i + 1;
}
}
};
// Union-Find-End
int perm[1000005];
void init_perm() {
perm[0] = 1;
REP(i, 1000000) { perm[i] = perm[i - 1] * i % mod; }
}
int nCk(int x, int y) {
return perm[x] * modpow(perm[x - y], mod - 2) % mod *
modpow(perm[y], mod - 2) % mod;
}
double kyori(pair<int, int> f, pair<int, int> s) {
double ans = 0;
double t = fabs(f.first - s.first);
double y = fabs(f.second - s.second);
ans = sqrt(t * t + y * y);
return ans;
}
inline string stringmax(string &x, string &y) {
if (x.size() > y.size()) {
return x;
}
if (x.size() < y.size()) {
return y;
}
rep(i, x.size()) {
if (x[i] > y[i]) {
return x;
}
if (x[i] < y[i]) {
return y;
}
}
return x;
}
vector<int> RollingHash(string &s, string &t) {
vector<int> ans;
__int128 h = 0, hamod = 0, ki = 0, kim = 0, hikaku = 0, one = 0;
one = 1;
ki = 1000000007ll;
hamod = (one << 61) - 1;
kim = 1;
rep(i, t.size()) {
hikaku *= ki;
h *= ki;
kim *= ki;
hikaku += t[i];
h += s[i];
hikaku %= hamod;
h %= hamod;
kim %= hamod;
}
rep(i, (int)s.size() - (int)t.size() + 1) {
if (h == hikaku) {
ans.emplace_back(i);
}
h *= ki;
h %= hamod;
h += s[i + (int)t.size()];
h %= hamod;
h += hamod;
h -= s[i] * kim % hamod;
h %= hamod;
}
return ans;
}
#define endl "\n" // interactive の時に注意！！！
#define printd cout << fixed << setprecision(10)
#define smallpriority_queue(x) priority_queue<x, vector<x>, greater<x>>
int q, b;
vector<pair<int, P>> v;
map<int, vector<int>> mp;
int gya[200004];
signed main() {
ios::sync_with_stdio(false);
std::cin.tie(nullptr);
cin >> q;
BIT bits(q);
SegTree<int> seg(q + 1, 0, R_SUM, NORMAL_UPDATE);
rep(i, q) {
int j;
cin >> j;
if (j == 1) {
int a, b;
cin >> a >> b;
v.push_back({1, {a, b}});
mp[a].push_back(1);
} else {
v.push_back({0, {0, 0}});
}
}
int cnt = 1;
for (auto &i : mp) {
rep(j, i.second.size()) {
i.second[j] = cnt;
gya[cnt] = i.first;
cnt++;
}
}
cnt = 0;
rep(i, q) {
if (v[i].first) {
bits.add(mp[v[i].second.first].back(), 1);
// cout<<mp[v[i].second.first]<<endl;
seg.change(mp[v[i].second.first].back(), v[i].second.first);
mp[v[i].second.first].pop_back();
cnt++;
b += v[i].second.second;
} else {
int l = 1, r = q;
while (l + 1 != r) {
int m = (l + r) / 2;
int c = bits.sum(m - 1);
// cout<<bits.sum(1)<<endl;
int k = cnt - c;
if (k >= (cnt + 2) / 2) {
l = m;
} else {
r = m;
}
}
int c = bits.sum(l - 1);
int k = cnt - c;
int ans = gya[l] * c - seg.query(0, l);
ans += seg.query(l, q + 1) - gya[l] * k;
cout << gya[l] << ' ' << ans + b << endl;
}
}
}
| /*
* じょえチャンネル
* 高評価・チャンネル登録よろしくおねがいします！
* https://www.youtube.com/channel/UCRXsI3FL_kvaVL9zoolBfbQ
*/
#include <bits/stdc++.h>
// GCC
// #define _GLIBCXX_DEBUG
// Clang
// #define _LIBCPP_DEBUG 0
#pragma GCC target("avx")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#define f(i, n) for (int i = 0; i < (n); i++)
// here!!!
// define int long long !!!!!
#define int long long
// define int long long !!!!!
#define mod (int)((1e9) + 7)
// constexpr int mod = 998244353ll;
#ifdef int
#define inf (int)(3e18)
#else
#define inf (int)(5e8)
#endif
#define intt long long
#define itn long long
#define P pair<long long, long long>
#define rep(i, n) for (int i = 0; i < n; i++)
#define REP(i, n) for (int i = 1; i <= n; i++)
#define ALL(v) v.begin(), v.end()
using namespace std;
// Library
// モッドパウ
inline int modpow(int x, int y, int m = mod) {
int res = 1;
while (y) {
if (y & 1) {
res *= x;
res %= m;
}
x = x * x % m;
y /= 2;
}
return res;
}
int mypow(int x, int y) {
int res = 1;
while (y) {
if (y % 2) {
res *= x;
}
x = x * x;
y /= 2;
}
return res;
}
// is the number (x) a prime number?
bool prime(int x) {
if (!x || x == 1) {
return false;
}
for (int i = 2; i * i <= x; i++) {
if (!(x % i)) {
return false;
}
}
return true;
}
// saidai-kouyakusuu
inline int gcd(int x, int y) {
if (!y) {
return x;
}
return gcd(y, x % y);
}
// number of keta
int keta(int x) {
int ans = 0;
while (x) {
x /= 10;
ans++;
}
return ans;
}
// sum of keta
int ketasum(int x) {
int ans = 0;
while (x) {
ans += x % 10;
x /= 10;
}
return ans;
}
inline int lcm(int x, int y) {
int ans = x / gcd(x, y) * y;
return ans;
}
int twobeki(int x) {
int ans = 0;
while (1) {
if (!(x & 1)) {
ans++;
x /= 2;
} else {
break;
}
}
return ans;
}
template <class T, class U> inline bool chmax(T &lhs, const U &rhs) {
if (lhs < rhs) {
lhs = rhs;
return 1;
}
return 0;
}
template <class T, class U> inline bool chmin(T &lhs, const U &rhs) {
if (lhs > rhs) {
lhs = rhs;
return 1;
}
return 0;
}
void Yes() { cout << "Yes" << endl; }
void No() { cout << "No" << endl; }
void YES() { cout << "YES" << endl; }
void NO() { cout << "NO" << endl; }
#define fin(i) scanf("%lld", &i)
#define fout(i) printf("%lld", i)
#define fendl printf("\n")
int kai(int x, int y) {
int res = 1;
for (int i = x - y + 1; i <= x; i++) {
res *= i;
res %= mod;
}
return res;
}
int comb(int x, int y) {
if (y > x)
return 0;
// cout<<kai(x, y)<<' '<<modpow(kai(y, y), mod - 2)<<endl;
return kai(x, y) * modpow(kai(y, y), mod - 2) % mod;
}
// Library-End
#define vecin(v) \
for (int i = 0; i < v.size(); i++) \
scanf("%lld", &v[i]);
#define vecout(v) \
{ \
for (int i = 0; i < (int)v.size(); i++) \
printf("%lld ", v[i]); \
printf("\n"); \
}
// template<typename T, typename U>
// class SegTree {
// protected:
// unsigned int n = 1, rank = 0;
// std::vector<T> node;
// T nodee;
// virtual T nodef(const T&, const T&)const = 0;
// public:
// SegTree(unsigned int m, T init, T nodee):nodee(nodee) {
// while (n < m) {
// n *= 2;
// rank++;
// }
// node.resize(2 * n);
// for (unsigned int i = n; i < 2 * n; i++)node[i] = init;
// }
// SegTree(const std::vector<T>& initvec, T nodee):nodee(nodee) {
// unsigned int m = initvec.size();
// while (n < m) {
// n *= 2;
// rank++;
// }
// node.resize(2 * n);
// for (unsigned int i = n; i < 2 * n; i++) {
// if (i - n < m)node[i] = initvec[i - n];
// }
// }
// virtual void update(int i, U x) {
// i += n;
// node[i] = x;
// while (i != 1) {
// i >>= 1;
// node[i] = nodef(node[2 * i], node[2 * i + 1]);
// }
// }
// virtual T query(int l, int r) {
// l += n; r += n;
// int ls = nodee, rs = nodee;
// while (l < r) {
// if (l & 1) {
// ls = nodef(ls, node[l]);
// l++;
// }
// if (r & 1) {
// r--;
// rs = nodef(node[r], rs);
// }
// l >>= 1; r >>= 1;
// }
// return nodef(ls, rs);
// }
// virtual T operator[](const int& x) {
// return node[n + x];
// }
// void fill(T x) {
// std::fill(all(node), x);
// }
// void print() {
// rep(i, n)std::cout << operator[](i) << " ";
// std::cout << std::endl;
// }
// };
// class RSQ :public SegTree<int, int> {
// int nodef(const int& lhs,const int& rhs){return lhs+rhs;}
// public:
// RSQ(int size, const int& def = 0) :SegTree<int, int>(size, def, 0) {}
// RSQ(const std::vector<int>& initvec) :SegTree<int, int>(initvec, 0) {}
// };
// class RMiQ :public SegTree<int, int> {
// int nodef(const int& lhs,const int& rhs){return std::min(lhs,rhs);}
// public:
// RMiQ(int size, const int& def = 0) :SegTree<int, int>(size, def, 0) {}
// RMiQ(const std::vector<int>& initvec) :SegTree<int, int>(initvec, 0) {}
// };
// class RMaQ :public SegTree<int, int> {
// int nodef(const int& lhs,const int& rhs){return std::max(lhs,rhs);}
// public:
// RMaQ(int size, const int& def = 0) :SegTree<int, int>(size, def, 0) {}
// RMaQ(const std::vector<int>& initvec) :SegTree<int, int>(initvec, 0) {}
// };
// template<typename T, typename U>
// class IntervalSegTree :public SegTree<T, U> {
// protected:
// using SegTree<T, U>::n;
// using SegTree<T, U>::rank;
// using SegTree<T, U>::node;
// using SegTree<T, U>::nodef;
// using SegTree<T, U>::nodee;
// std::vector<U> lazy;
// std::vector<bool> lazyflag;
// std::vector<int> width;
// virtual void lazyf(U&, const U&) = 0;
// virtual void updf(T&, const U&, const unsigned int&) = 0;
// void eval(int k) {
// for (int i = rank; i > 0; i--) {
// int nk = k >> i;
// if (lazyflag[nk]) {
// updf(node[2 * nk], lazy[nk], width[2 * nk]);
// updf(node[2 * nk + 1], lazy[nk], width[2 * nk + 1]);
// if (lazyflag[2 * nk])lazyf(lazy[2 * nk], lazy[nk]);
// else lazy[2 * nk] = lazy[nk];
// if (lazyflag[2 * nk + 1])lazyf(lazy[2 * nk + 1], lazy[nk]);
// else lazy[2 * nk + 1] = lazy[nk];
// lazyflag[2 * nk] = lazyflag[2 * nk + 1] = true;
// lazyflag[nk] = false;
// }
// }
// }
// public:
// IntervalSegTree(unsigned int m, T init, T nodee) :SegTree<T, U>(m, init,
// nodee) {
// lazy.resize(2 * n); lazyflag.resize(2 * n); width.resize(2 * n);
// width[1] = n;
// for (unsigned int i = 2; i < 2 * n; i++) {
// width[i] = width[i >> 1] >> 1;
// }
// }
// IntervalSegTree(T nodee, const std::vector<T>& initvec) :SegTree<T,
// U>(initvec, nodee) {
// lazy.resize(2 * n); lazyflag.resize(2 * n); width.resize(2 * n);
// width[1] = n;
// for (unsigned int i = 2; i < 2 * n; i++) {
// width[i] = width[i >> 1] >> 1;
// }
// }
// void update(int i, U x) {
// i += n;
// eval(i);
// updf(node[i], x, width[i]);
// if (lazyflag[i])lazyf(lazy[i], x);
// else {
// lazyflag[i] = true;
// lazy[i] = x;
// }
// while (i /= 2)node[i] = nodef(node[2 * i], node[2 * i + 1]);
// }
// void update(int l, int r, U x) {
// l += n; r += n;
// int nl = l, nr = r;
// while (!(nl & 1))nl >>= 1;
// while (!(nr & 1))nr >>= 1;
// nr--;
// eval(nl); eval(nr);
// while (l < r) {
// if (l & 1) {
// updf(node[l], x, width[l]);
// if (lazyflag[l])lazyf(lazy[l], x);
// else {
// lazyflag[l] = true;
// lazy[l] = x;
// }
// l++;
// }
// if (r & 1) {
// r--;
// updf(node[r], x, width[r]);
// if (lazyflag[r])lazyf(lazy[r], x);
// else {
// lazyflag[r] = true;
// lazy[r] = x;
// }
// }
// l >>= 1; r >>= 1;
// }
// while (nl >>= 1)node[nl] = nodef(node[2 * nl], node[2 * nl + 1]);
// while (nr >>= 1)node[nr] = nodef(node[2 * nr], node[2 * nr + 1]);
// }
// T query(int l, int r) {
// l += n; r += n;
// eval(l); eval(r - 1);
// int ls = nodee, rs = nodee;
// while (l < r) {
// if (l & 1) {
// ls = nodef(ls, node[l]);
// l++;
// }
// if (r & 1) {
// r--;
// rs = nodef(node[r], rs);
// }
// l >>= 1; r >>= 1;
// }
// return nodef(ls, rs);
// }
// T operator[](const int& x) {
// eval(n + x);
// return node[n + x];
// }
// T queryForAll() {
// return node[1];
// }
// };
// class RAQRSQ :public IntervalSegTree<int, int> {
// int nodef(const int& a, const int& b)const { return a + b; }
// void lazyf(int& a, const int& b) { a += b; }
// void updf(int& a, const int& b, const unsigned int& width) { a += width *
// b; }
// public:
// RAQRSQ(int size, const int& def = 0) :IntervalSegTree<int, int>(size,
// def, 0) {
// for (int i = n - 1; i > 0; i--)node[i] = nodef(node[2 * i], node[2 *
// i + 1]);
// }
// RAQRSQ(const std::vector<int>& initvec) :IntervalSegTree<int,
// int>((int)0, initvec) {
// for (int i = n - 1; i > 0; i--)node[i] = nodef(node[2 * i], node[2 *
// i + 1]);
// }
// };
// class RAQRMiQ :public IntervalSegTree<int, int> {
// int nodef(const int& a, const int& b)const { return std::min(a, b); }
// void lazyf(int& a, const int& b) { a += b; }
// void updf(int& a, const int& b, const unsigned int& width) { a += b; }
// public:
// RAQRMiQ(int size, const int& def = 0) :IntervalSegTree<int, int>(size,
// def, inf) {
// for (int i = n - 1; i > 0; i--)node[i] = nodef(node[2 * i], node[2 *
// i + 1]);
// }
// RAQRMiQ(const std::vector<int>& initvec) :IntervalSegTree<int, int>(inf,
// initvec) {
// for (int i = n - 1; i > 0; i--)node[i] = nodef(node[2 * i], node[2 *
// i + 1]);
// }
// };
// class RAQRMaQ :public IntervalSegTree<int, int> {
// int nodef(const int& a, const int& b)const { return std::max(a, b); }
// void lazyf(int& a, const int& b) { a += b; }
// void updf(int& a, const int& b, const unsigned int& width) { a += b; }
// public:
// RAQRMaQ(unsigned int size, const int& def = 0) :IntervalSegTree<int,
// int>(size, def, -inf) {
// for (int i = n - 1; i > 0; i--)node[i] = nodef(node[2 * i], node[2 *
// i + 1]);
// }
// RAQRMaQ(const std::vector<int>& initvec) :IntervalSegTree<int, int>(-inf,
// initvec) {
// for (int i = n - 1; i > 0; i--)node[i] = nodef(node[2 * i], node[2 *
// i + 1]);
// }
// };
// class RUQRSQ :public IntervalSegTree<int, int> {
// int nodef(const int& a, const int& b)const { return a + b; }
// void lazyf(int& a, const int& b) { a = b; }
// void updf(int& a, const int& b, const unsigned int& width) { a = width *
// b; }
// public:
// RUQRSQ(int size, const int& def = 0) :IntervalSegTree<int, int>(size,
// def, 0) {
// for (int i = n - 1; i > 0; i--)node[i] = nodef(node[2 * i], node[2 *
// i + 1]);
// }
// RUQRSQ(const std::vector<int>& initvec) :IntervalSegTree<int,
// int>((int)0, initvec) {
// for (int i = n - 1; i > 0; i--)node[i] = nodef(node[2 * i], node[2 *
// i + 1]);
// }
// };
// class RUQRMiQ :public IntervalSegTree<int, int> {
// int nodef(const int& a, const int& b)const { return std::min(a, b); }
// void lazyf(int& a, const int& b) { a = b; }
// void updf(int& a, const int& b, const unsigned int& width) { a = b; }
// public:
// RUQRMiQ(int size, const int& def = 0) :IntervalSegTree<int, int>(size,
// def, inf) {
// for (int i = n - 1; i > 0; i--)node[i] = nodef(node[2 * i], node[2 *
// i + 1]);
// }
// RUQRMiQ(const std::vector<int>& initvec) :IntervalSegTree<int, int>(inf,
// initvec) {
// for (int i = n - 1; i > 0; i--)node[i] = nodef(node[2 * i], node[2 *
// i + 1]);
// }
// };
// class RUQRMaQ :public IntervalSegTree<int, int> {
// int nodef(const int& a, const int& b)const { return std::max(a, b); }
// void lazyf(int& a, const int& b) { a = b; }
// void updf(int& a, const int& b, const unsigned int& width) { a = b; }
// public:
// RUQRMaQ(int size, const int& def = 0) :IntervalSegTree<int, int>(size,
// def, -inf) {
// for (int i = n - 1; i > 0; i--)node[i] = nodef(node[2 * i], node[2 *
// i + 1]);
// }
// RUQRMaQ(const std::vector<int>& initvec) :IntervalSegTree<int, int>(-inf,
// initvec) {
// for (int i = n - 1; i > 0; i--)node[i] = nodef(node[2 * i], node[2 *
// i + 1]);
// }
// };
// SegTree
template <class T> class SegTree {
int n; // 葉の数
vector<T> data; // データを格納するvector
T def; // 初期値かつ単位元
function<T(T, T)> operation; // 区間クエリで使う処理
function<T(T, T)> update; // 点更新で使う処理
// 区間[a,b)の総和。ノードk=[l,r)に着目している。
T _query(int a, int b, int k, int l, int r) {
if (r <= a || b <= l)
return def; // 交差しない
if (a <= l && r <= b)
return data[k]; // a,l,r,bの順で完全に含まれる
else {
T c1 = _query(a, b, 2 * k + 1, l, (l + r) / 2); // 左の子
T c2 = _query(a, b, 2 * k + 2, (l + r) / 2, r); // 右の子
return operation(c1, c2);
}
}
public:
// _n:必要サイズ, _def:初期値かつ単位元, _operation:クエリ関数,
// _update:更新関数
SegTree(size_t _n, T _def, function<T(T, T)> _operation,
function<T(T, T)> _update)
: def(_def), operation(_operation), update(_update) {
n = 1;
while (n < _n) {
n *= 2;
}
data = vector<T>(2 * n - 1, def);
}
// 場所i(0-indexed)の値をxで更新
void change(int i, T x) {
i += n - 1;
data[i] = update(data[i], x);
while (i > 0) {
i = (i - 1) / 2;
data[i] = operation(data[i * 2 + 1], data[i * 2 + 2]);
}
}
// [a, b)の区間クエリを実行
T query(int a, int b) { return _query(a, b, 0, 0, n); }
// 添字でアクセス
T operator[](int i) { return data[i + n - 1]; }
};
#define R_MIN ([](long long a, long long b) { return min(a, b); })
#define R_MAX ([](long long a, long long b) { return max(a, b); })
#define R_SUM ([](long long a, long long b) { return a + b; })
#define NORMAL_UPDATE ([](long long a, long long b) { return b; })
#define ADD_UPDATE ([](long long a, long long b) { return a + b; })
#define MINUS_UPDATE ([](long long a, long long b) { return a - b; }
class Union_Find {
vector<int> par;
vector<int> rankmy;
vector<int> ookisa;
public:
Union_Find(int size) {
par = vector<int>(size);
rankmy = vector<int>(size);
ookisa = vector<int>(size);
for (int i = 0; i < size; i++) {
par[i] = i;
ookisa[i] = 1;
}
}
int find(int x) {
if (par[x] == x) {
return x;
}
return par[x] = find(par[x]);
}
void unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y) {
return;
}
if (rankmy[x] < rankmy[y]) {
par[x] = y;
ookisa[y] += ookisa[x];
ookisa[x] = 0;
} else {
par[y] = x;
ookisa[x] += ookisa[y];
ookisa[y] = 0;
if (rankmy[x] == rankmy[y]) {
rankmy[x]++;
}
}
}
int size(int i) {
i = find(i);
return ookisa[i];
}
bool same(int x, int y) { return find(x) == find(y); }
};
class BIT {
vector<int> data;
int size = 0;
public:
BIT(int _size) {
data = vector<int>(_size + 1);
size = _size;
}
void add(int i, int x) {
while (i <= size) {
data[i] += x;
i += i & -i;
}
}
int sum(int i) {
assert(i <= size);
int s = 0;
while (i > 0) {
s += data[i];
i -= i & -i;
}
return s;
}
int lower_bound(int x) {
if (x <= 0) {
return 0;
} else {
int i = 0;
int r = 1;
while (r < size)
r = r << 1;
for (int len = r; len > 0; len = len >> 1) {
if (i + len < size && data[i + len] < x) {
x -= data[i + len];
i += len;
}
}
return i + 1;
}
}
};
// Union-Find-End
int perm[1000005];
void init_perm() {
perm[0] = 1;
REP(i, 1000000) { perm[i] = perm[i - 1] * i % mod; }
}
int nCk(int x, int y) {
return perm[x] * modpow(perm[x - y], mod - 2) % mod *
modpow(perm[y], mod - 2) % mod;
}
double kyori(pair<int, int> f, pair<int, int> s) {
double ans = 0;
double t = fabs(f.first - s.first);
double y = fabs(f.second - s.second);
ans = sqrt(t * t + y * y);
return ans;
}
inline string stringmax(string &x, string &y) {
if (x.size() > y.size()) {
return x;
}
if (x.size() < y.size()) {
return y;
}
rep(i, x.size()) {
if (x[i] > y[i]) {
return x;
}
if (x[i] < y[i]) {
return y;
}
}
return x;
}
vector<int> RollingHash(string &s, string &t) {
vector<int> ans;
__int128 h = 0, hamod = 0, ki = 0, kim = 0, hikaku = 0, one = 0;
one = 1;
ki = 1000000007ll;
hamod = (one << 61) - 1;
kim = 1;
rep(i, t.size()) {
hikaku *= ki;
h *= ki;
kim *= ki;
hikaku += t[i];
h += s[i];
hikaku %= hamod;
h %= hamod;
kim %= hamod;
}
rep(i, (int)s.size() - (int)t.size() + 1) {
if (h == hikaku) {
ans.emplace_back(i);
}
h *= ki;
h %= hamod;
h += s[i + (int)t.size()];
h %= hamod;
h += hamod;
h -= s[i] * kim % hamod;
h %= hamod;
}
return ans;
}
#define endl "\n" // interactive の時に注意！！！
#define printd cout << fixed << setprecision(10)
#define smallpriority_queue(x) priority_queue<x, vector<x>, greater<x>>
int q, b;
vector<pair<int, P>> v;
map<int, vector<int>> mp;
int gya[200004];
signed main() {
ios::sync_with_stdio(false);
std::cin.tie(nullptr);
cin >> q;
BIT bits(q);
SegTree<int> seg(q + 1, 0, R_SUM, NORMAL_UPDATE);
rep(i, q) {
int j;
cin >> j;
if (j == 1) {
int a, b;
cin >> a >> b;
v.push_back({1, {a, b}});
mp[a].push_back(1);
} else {
v.push_back({0, {0, 0}});
}
}
int cnt = 1;
for (auto &i : mp) {
rep(j, i.second.size()) {
i.second[j] = cnt;
gya[cnt] = i.first;
cnt++;
}
}
cnt = 0;
rep(i, q) {
if (v[i].first) {
bits.add(mp[v[i].second.first].back(), 1);
// cout<<mp[v[i].second.first]<<endl;
seg.change(mp[v[i].second.first].back(), v[i].second.first);
mp[v[i].second.first].pop_back();
cnt++;
b += v[i].second.second;
} else {
int l = 1, r = q;
while (l + 1 != r) {
int m = (l + r) / 2;
int c = bits.sum(m - 1);
// cout<<bits.sum(1)<<endl;
int k = cnt - c;
if (k >= (cnt + 2) / 2) {
l = m;
} else {
r = m;
}
}
int c = bits.sum(l - 1);
int k = cnt - c;
int ans = gya[l] * c - seg.query(0, l);
ans += seg.query(l, q + 1) - gya[l] * k;
cout << gya[l] << ' ' << ans + b << endl;
}
}
}
| replace | 12 | 13 | 12 | 13 | 0 | |
p03040 | Python | Runtime Error | from heapq import heappush, heappushpop
Q = int(input())
b = 0
la = []
sl = 0
ra = []
sr = 0
cnt = 0
for _ in range(Q):
q = map(int, input().split())
# print(la, ra)
if q[0] == 2:
# 求値
x = -la[0]
cl = (cnt + 1) // 2
cr = cnt - cl
print(x, (cl * x - sl) + (sr - cr * x) + b)
else:
# 更新
b += q[2]
cnt += 1
if cnt % 2 == 1:
sr += q[1]
x = heappushpop(ra, q[1])
sr -= x
sl += x
heappush(la, -x)
else:
sl += q[1]
x = heappushpop(la, -q[1])
x *= -1
sl -= x
sr += x
heappush(ra, x)
| from heapq import heappush, heappushpop
Q = int(input())
b = 0
la = []
sl = 0
ra = []
sr = 0
cnt = 0
for _ in range(Q):
q = tuple(map(int, input().split()))
# print(la, ra)
if q[0] == 2:
# 求値
x = -la[0]
cl = (cnt + 1) // 2
cr = cnt - cl
print(x, (cl * x - sl) + (sr - cr * x) + b)
else:
# 更新
b += q[2]
cnt += 1
if cnt % 2 == 1:
sr += q[1]
x = heappushpop(ra, q[1])
sr -= x
sl += x
heappush(la, -x)
else:
sl += q[1]
x = heappushpop(la, -q[1])
x *= -1
sl -= x
sr += x
heappush(ra, x)
| replace | 12 | 13 | 12 | 13 | TypeError: 'map' object is not subscriptable | Traceback (most recent call last):
File "/home/alex/Documents/bug-detection/input/Project_CodeNet/data/p03040/Python/s771493021.py", line 15, in <module>
if q[0] == 2:
TypeError: 'map' object is not subscriptable
|
p03040 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
template <typename T>
using ordered_set =
tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<ll, ll> pl;
typedef pair<int, int> pii;
#define LOCAL 0
#define dbg(x) cout << #x << " is " << x << "\n"
#define gll(x) scanf("%d", &x)
#define gll2(x, y) scanf("%d%d", &x, &y)
#define gll3(x, y, z) scanf("%d%d%d", &x, &y, &z)
#define gllarr(arr, n) f(i, n) gll(arr[i]);
#define sz(x) ((int)x.size())
#define s(x) sort(x.begin(), x.end())
#define all(v) v.begin(), v.end()
#define rs(v) \
{ \
s(v); \
r(v); \
}
#define r(v) \
{ reverse(all(v)); }
#define pb push_back
#define f(i, n) for (int i = 0; i < n; i++)
#define fr(i, n) for (int i = n - 1; i >= 0; i--)
#define rep(i, a, b) for (int i = a; i <= b; i++)
#define repr(i, a, b) for (int i = a; i >= b; i--)
const ll mod = (ll)1e9 + 7;
const ll inf = (ll)1e16;
const ld eps = 1e-12;
const ll N = (int)1e5 + 5;
const ll LOGN = 19;
const ld PI = 3.14159265358979323846;
inline ll mul(ll a, ll b, ll m = mod) { return (ll)(a * b) % m; }
inline ll add(ll a, ll b, ll m = mod) {
a += b;
if (a >= m)
a -= m;
if (a < 0)
a += m;
return a;
}
inline ll power(ll a, ll b, ll m = mod) {
if (b == 0)
return 1;
if (b == 1)
return (a % m);
ll x = power(a, b / 2, m);
x = mul(x, x, m);
if (b % 2)
x = mul(x, a, m);
return x;
}
map<ll, ll> mapper, first, last;
vector<tuple<int, ll, ll>> queries;
/* Segtree - point update, range query
* a - Initializer array. Building is done based on array a[].
* Each function assumes 0-based indexing.
*/
struct node {
ll val;
ll dist;
node() {
val = 0;
dist = 0;
}
void init(ll x) {
val = x;
dist = 1;
}
void merge(node &l, node &r) {
val = l.val + r.val;
dist = l.dist + r.dist;
}
void no_use() {
// Fill up the values that do not affect the answer.
val = 0;
dist = 0;
}
};
node segtree[N << 2];
// Point update - Here : change value at index = idx to val -> a[idx] = val.
// In case of tight TL, create idx and val as global variables.
void update(int num, int start, int end, int idx, int val) {
if (start == end) {
segtree[num].init(val);
return;
}
int lc = num + num + 1, rc = lc + 1;
int mid = (start + end) >> 1;
if (start <= idx && idx <= mid)
update(lc, start, mid, idx, val);
else
update(rc, mid + 1, end, idx, val);
segtree[num].merge(segtree[lc], segtree[rc]);
}
// Range Query - Returns the answer of query in O(logn) time.
node query(int num, int start, int end, int qs, int qe) {
if (start > qe || end < qs) {
node junk;
junk.no_use();
return junk;
}
if (start >= qs && end <= qe) {
return segtree[num];
}
int lc = num + num + 1, rc = lc + 1;
int mid = (start + end) >> 1;
node lf = query(lc, start, mid, qs, qe);
node rg = query(rc, mid + 1, end, qs, qe);
node ret;
ret.merge(lf, rg);
return ret;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
if (LOCAL) {
freopen("C:\\Users\\Dishant\\Desktop\\Collection-DEV c++\\input.txt", "r",
stdin);
freopen("C:\\Users\\Dishant\\Desktop\\Collection-DEV c++\\output.txt", "w",
stdout);
}
int q;
cin >> q;
ordered_set<pair<ll, int>> S;
vector<ll> vec;
f(i, q) {
int ty;
cin >> ty;
ll a = 0, b = 0;
if (ty == 1)
cin >> a >> b, vec.pb(a);
queries.pb(make_tuple(ty, a, b));
}
s(vec);
int ptr = 0;
f(i, sz(vec)) {
int to = vec[i];
if (first.find(to) == first.end())
first[to] = ptr;
last[to] = ptr;
if (mapper.find(to) == mapper.end())
mapper[to] = ptr;
ptr++;
}
ll sum = 0, terms = 0;
f(tt, q) {
int ty = get<0>(queries[tt]);
if (ty == 1) {
ll a, b;
a = get<1>(queries[tt]);
b = get<2>(queries[tt]);
sum += b;
terms++;
S.insert({a, terms});
update(0, 0, sz(vec) - 1, mapper[a], a);
mapper[a]++;
} else {
ll to = terms / 2;
if (terms % 2 == 0)
to--;
pair<ll, int> chk = *(S.find_by_order(to));
ll num = chk.first;
ll ub = first[num] - 1;
ll lb = last[num] + 1;
node ff = query(0, 0, sz(vec) - 1, 0, ub);
node ss = query(0, 0, sz(vec) - 1, lb, sz(vec) - 1);
ll cans = ss.val - ss.dist * num + ff.dist * num - ff.val;
cout << num << ' ' << cans + sum << "\n";
}
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
template <typename T>
using ordered_set =
tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<ll, ll> pl;
typedef pair<int, int> pii;
#define LOCAL 0
#define dbg(x) cout << #x << " is " << x << "\n"
#define gll(x) scanf("%d", &x)
#define gll2(x, y) scanf("%d%d", &x, &y)
#define gll3(x, y, z) scanf("%d%d%d", &x, &y, &z)
#define gllarr(arr, n) f(i, n) gll(arr[i]);
#define sz(x) ((int)x.size())
#define s(x) sort(x.begin(), x.end())
#define all(v) v.begin(), v.end()
#define rs(v) \
{ \
s(v); \
r(v); \
}
#define r(v) \
{ reverse(all(v)); }
#define pb push_back
#define f(i, n) for (int i = 0; i < n; i++)
#define fr(i, n) for (int i = n - 1; i >= 0; i--)
#define rep(i, a, b) for (int i = a; i <= b; i++)
#define repr(i, a, b) for (int i = a; i >= b; i--)
const ll mod = (ll)1e9 + 7;
const ll inf = (ll)1e16;
const ld eps = 1e-12;
const ll N = (int)2e5 + 5;
const ll LOGN = 19;
const ld PI = 3.14159265358979323846;
inline ll mul(ll a, ll b, ll m = mod) { return (ll)(a * b) % m; }
inline ll add(ll a, ll b, ll m = mod) {
a += b;
if (a >= m)
a -= m;
if (a < 0)
a += m;
return a;
}
inline ll power(ll a, ll b, ll m = mod) {
if (b == 0)
return 1;
if (b == 1)
return (a % m);
ll x = power(a, b / 2, m);
x = mul(x, x, m);
if (b % 2)
x = mul(x, a, m);
return x;
}
map<ll, ll> mapper, first, last;
vector<tuple<int, ll, ll>> queries;
/* Segtree - point update, range query
* a - Initializer array. Building is done based on array a[].
* Each function assumes 0-based indexing.
*/
struct node {
ll val;
ll dist;
node() {
val = 0;
dist = 0;
}
void init(ll x) {
val = x;
dist = 1;
}
void merge(node &l, node &r) {
val = l.val + r.val;
dist = l.dist + r.dist;
}
void no_use() {
// Fill up the values that do not affect the answer.
val = 0;
dist = 0;
}
};
node segtree[N << 2];
// Point update - Here : change value at index = idx to val -> a[idx] = val.
// In case of tight TL, create idx and val as global variables.
void update(int num, int start, int end, int idx, int val) {
if (start == end) {
segtree[num].init(val);
return;
}
int lc = num + num + 1, rc = lc + 1;
int mid = (start + end) >> 1;
if (start <= idx && idx <= mid)
update(lc, start, mid, idx, val);
else
update(rc, mid + 1, end, idx, val);
segtree[num].merge(segtree[lc], segtree[rc]);
}
// Range Query - Returns the answer of query in O(logn) time.
node query(int num, int start, int end, int qs, int qe) {
if (start > qe || end < qs) {
node junk;
junk.no_use();
return junk;
}
if (start >= qs && end <= qe) {
return segtree[num];
}
int lc = num + num + 1, rc = lc + 1;
int mid = (start + end) >> 1;
node lf = query(lc, start, mid, qs, qe);
node rg = query(rc, mid + 1, end, qs, qe);
node ret;
ret.merge(lf, rg);
return ret;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
if (LOCAL) {
freopen("C:\\Users\\Dishant\\Desktop\\Collection-DEV c++\\input.txt", "r",
stdin);
freopen("C:\\Users\\Dishant\\Desktop\\Collection-DEV c++\\output.txt", "w",
stdout);
}
int q;
cin >> q;
ordered_set<pair<ll, int>> S;
vector<ll> vec;
f(i, q) {
int ty;
cin >> ty;
ll a = 0, b = 0;
if (ty == 1)
cin >> a >> b, vec.pb(a);
queries.pb(make_tuple(ty, a, b));
}
s(vec);
int ptr = 0;
f(i, sz(vec)) {
int to = vec[i];
if (first.find(to) == first.end())
first[to] = ptr;
last[to] = ptr;
if (mapper.find(to) == mapper.end())
mapper[to] = ptr;
ptr++;
}
ll sum = 0, terms = 0;
f(tt, q) {
int ty = get<0>(queries[tt]);
if (ty == 1) {
ll a, b;
a = get<1>(queries[tt]);
b = get<2>(queries[tt]);
sum += b;
terms++;
S.insert({a, terms});
update(0, 0, sz(vec) - 1, mapper[a], a);
mapper[a]++;
} else {
ll to = terms / 2;
if (terms % 2 == 0)
to--;
pair<ll, int> chk = *(S.find_by_order(to));
ll num = chk.first;
ll ub = first[num] - 1;
ll lb = last[num] + 1;
node ff = query(0, 0, sz(vec) - 1, 0, ub);
node ss = query(0, 0, sz(vec) - 1, lb, sz(vec) - 1);
ll cans = ss.val - ss.dist * num + ff.dist * num - ff.val;
cout << num << ' ' << cans + sum << "\n";
}
}
return 0;
} | replace | 39 | 40 | 39 | 40 | 0 | |
p03040 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<double, double> pdd;
const ull mod = 1e9 + 7;
#define REP(i, n) for (int i = 0; i < (int)n; ++i)
// debug
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) \
cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" \
<< " " << __FILE__ << endl;
template <class S, class T>
ostream &operator<<(ostream &os, const pair<S, T> v) {
os << "(" << v.first << ", " << v.second << ")";
return os;
}
template <class T> ostream &operator<<(ostream &os, const vector<T> v) {
for (int i = 0; i < v.size(); i++) {
if (i > 0) {
os << " ";
}
os << v[i];
}
return os;
}
template <class T> ostream &operator<<(ostream &os, const vector<vector<T>> v) {
for (int i = 0; i < v.size(); i++) {
if (i > 0) {
os << endl;
}
os << v[i];
}
return os;
}
template <class V, int ME> class BIT {
public:
V bit[1 << ME];
V total(int e) {
if (e < 0)
return 0;
V s = 0;
e++;
while (e)
s += bit[e - 1], e -= e & -e;
return s;
}
void add(int e, V val) {
e++;
while (e <= 1 << ME)
bit[e - 1] += val, e += e & -e;
}
};
const ll MA = 16;
const ll len = (1 << MA);
map<ll, ll> zip;
ll unzip[len];
typedef pair<ll, pll> plll;
ll compress(vector<ll> &x) {
sort(x.begin(), x.end());
x.erase(unique(x.begin(), x.end()), x.end());
for (ll i = 0; i < x.size(); i++) {
zip[x[i]] = i;
unzip[i] = x[i];
}
return x.size();
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll Q;
cin >> Q;
vector<plll> query;
vector<ll> A;
REP(i, Q) {
ll type;
cin >> type;
if (type == 1) {
ll a, b;
cin >> a >> b;
query.push_back({1, {a, b}});
A.push_back(a);
} else {
query.push_back({2, {0, 0}});
}
}
BIT<ll, MA> bit1, bit2;
REP(i, len) bit1.bit[i] = 0;
REP(i, len) bit2.bit[i] = 0;
compress(A);
ll B = 0, cnt = 0;
REP(i, Q) {
// dump(i)
ll type = query[i].first;
if (type == 1) {
ll val = query[i].second.first;
B += query[i].second.second;
cnt++;
bit1.add(zip[val], val);
bit2.add(zip[val], 1);
} else {
ll lb = -1, ub = len;
while (ub - lb > 1) {
ll m = (ub + lb) / 2;
if (bit2.total(m) >= (cnt + 1) / 2)
ub = m;
else
lb = m;
}
ll med = ub;
ll med_val = unzip[med];
ll P = (bit1.total(len - 1) - bit1.total(med));
ll Q = med_val * (bit2.total(len - 1) - bit2.total(med));
ll R = (bit1.total(med - 1));
ll S = med_val * (bit2.total(med - 1));
/*
dump(B)
dump(P)
dump(Q)
dump(R)
dump(S)
*/
ll res = B + P + S - Q - R;
cout << med_val << " " << res << endl;
}
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<double, double> pdd;
const ull mod = 1e9 + 7;
#define REP(i, n) for (int i = 0; i < (int)n; ++i)
// debug
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) \
cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" \
<< " " << __FILE__ << endl;
template <class S, class T>
ostream &operator<<(ostream &os, const pair<S, T> v) {
os << "(" << v.first << ", " << v.second << ")";
return os;
}
template <class T> ostream &operator<<(ostream &os, const vector<T> v) {
for (int i = 0; i < v.size(); i++) {
if (i > 0) {
os << " ";
}
os << v[i];
}
return os;
}
template <class T> ostream &operator<<(ostream &os, const vector<vector<T>> v) {
for (int i = 0; i < v.size(); i++) {
if (i > 0) {
os << endl;
}
os << v[i];
}
return os;
}
template <class V, int ME> class BIT {
public:
V bit[1 << ME];
V total(int e) {
if (e < 0)
return 0;
V s = 0;
e++;
while (e)
s += bit[e - 1], e -= e & -e;
return s;
}
void add(int e, V val) {
e++;
while (e <= 1 << ME)
bit[e - 1] += val, e += e & -e;
}
};
const ll MA = 18;
const ll len = (1 << MA);
map<ll, ll> zip;
ll unzip[len];
typedef pair<ll, pll> plll;
ll compress(vector<ll> &x) {
sort(x.begin(), x.end());
x.erase(unique(x.begin(), x.end()), x.end());
for (ll i = 0; i < x.size(); i++) {
zip[x[i]] = i;
unzip[i] = x[i];
}
return x.size();
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll Q;
cin >> Q;
vector<plll> query;
vector<ll> A;
REP(i, Q) {
ll type;
cin >> type;
if (type == 1) {
ll a, b;
cin >> a >> b;
query.push_back({1, {a, b}});
A.push_back(a);
} else {
query.push_back({2, {0, 0}});
}
}
BIT<ll, MA> bit1, bit2;
REP(i, len) bit1.bit[i] = 0;
REP(i, len) bit2.bit[i] = 0;
compress(A);
ll B = 0, cnt = 0;
REP(i, Q) {
// dump(i)
ll type = query[i].first;
if (type == 1) {
ll val = query[i].second.first;
B += query[i].second.second;
cnt++;
bit1.add(zip[val], val);
bit2.add(zip[val], 1);
} else {
ll lb = -1, ub = len;
while (ub - lb > 1) {
ll m = (ub + lb) / 2;
if (bit2.total(m) >= (cnt + 1) / 2)
ub = m;
else
lb = m;
}
ll med = ub;
ll med_val = unzip[med];
ll P = (bit1.total(len - 1) - bit1.total(med));
ll Q = med_val * (bit2.total(len - 1) - bit2.total(med));
ll R = (bit1.total(med - 1));
ll S = med_val * (bit2.total(med - 1));
/*
dump(B)
dump(P)
dump(Q)
dump(R)
dump(S)
*/
ll res = B + P + S - Q - R;
cout << med_val << " " << res << endl;
}
}
return 0;
} | replace | 60 | 61 | 60 | 61 | 0 | |
p03041 | C++ | Runtime Error | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
int main() {
int n, k;
scanf("%d %d", &n, &k);
char s[5];
scanf("%s", &s);
s[k - 1] = 'a' + s[k - 1] - 'A';
printf("%s", s);
}
| #include <bits/stdc++.h>
#include <iostream>
using namespace std;
int main() {
int n, k;
scanf("%d %d", &n, &k);
char s[100];
scanf("%s", &s);
s[k - 1] = 'a' + s[k - 1] - 'A';
printf("%s", s);
}
| replace | 7 | 8 | 7 | 8 | 0 | |
p03041 | C++ | Runtime Error | #include <algorithm>
#include <cstdlib>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
char tolower(char c) { return (c + 0x20); }
int main() {
int N, K;
string S;
cin >> N >> K;
cin >> S;
S.at(K) = tolower(S.at(K));
cout << S << endl;
} | #include <algorithm>
#include <cstdlib>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
char tolower(char c) { return (c + 0x20); }
int main() {
int N, K;
string S;
cin >> N >> K;
cin >> S;
S.at(K - 1) = tolower(S.at(K - 1));
cout << S << endl;
} | replace | 16 | 17 | 16 | 17 | 0 | |
p03041 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
string s;
cin >> s;
s.at(k) = tolower(s.at(k));
cout << s << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
string s;
cin >> s;
s.at(k - 1) = s.at(k - 1) + 32;
cout << s << endl;
} | replace | 8 | 9 | 8 | 9 | 0 | |
p03041 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <vector>
const long long INF = 1e9 + 7;
using namespace std;
map<int, int> mp;
int main() {
int n, k;
string s;
cin >> n >> k;
if (s.at(k - 1) == 'A')
s.at(k - 1) = 'a';
else if (s.at(k - 1) == 'B')
s.at(k - 1) = 'b';
else
s.at(k - 1) = 'c';
cout << s << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <vector>
const long long INF = 1e9 + 7;
using namespace std;
map<int, int> mp;
int main() {
int n, k;
string s;
cin >> n >> k;
cin >> s;
if (s.at(k - 1) == 'A')
s.at(k - 1) = 'a';
else if (s.at(k - 1) == 'B')
s.at(k - 1) = 'b';
else
s.at(k - 1) = 'c';
cout << s << endl;
return 0;
} | insert | 23 | 23 | 23 | 24 | -6 | terminate called after throwing an instance of 'std::out_of_range'
what(): basic_string::at: __n (which is 0) >= this->size() (which is 0)
|
p03041 | C++ | Runtime Error | #include <stdio.h>
int main() {
int N, K;
char string[20];
scanf("%d %d\n", &N, &K);
scanf("%s", &string);
string[K - 1] += 32;
printf("%s\n", string);
return 0;
} | #include <stdio.h>
int main() {
int N, K;
char nama[52];
scanf("%d%d %s", &N, &K, nama);
nama[K - 1] = nama[K - 1] + 32;
printf("%s\n", nama);
return 0;
} | replace | 3 | 12 | 3 | 7 | 0 | |
p03041 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, K;
string S;
cin >> N >> K >> S;
S.at(K) += 'a' - 'A';
cout << S << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, K;
string S;
cin >> N >> K >> S;
S.at(K - 1) += 'a' - 'A';
cout << S << endl;
} | replace | 6 | 7 | 6 | 7 | 0 | |
p03041 | C++ | Runtime Error | #include <bits/stdc++.h>
#include <cmath>
#include <cstdlib>
#include <iostream>
#include <math.h>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
#define P = pair<int, int>;
using namespace std;
using ll = long long;
using vll = vector<ll>;
using vvll = vector<vector<ll>>;
int main() {
int n, k;
cin >> n >> k;
string s;
cin >> s;
if (s.at(k) == 'A')
s.at(k) = 'a';
if (s.at(k) == 'B')
s.at(k) = 'b';
if (s.at(k) == 'C')
s.at(k) = 'c';
cout << s << endl;
}
| #include <bits/stdc++.h>
#include <cmath>
#include <cstdlib>
#include <iostream>
#include <math.h>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
#define P = pair<int, int>;
using namespace std;
using ll = long long;
using vll = vector<ll>;
using vvll = vector<vector<ll>>;
int main() {
int n, k;
cin >> n >> k;
string s;
cin >> s;
if (s.at(k - 1) == 'A')
s.at(k - 1) = 'a';
if (s.at(k - 1) == 'B')
s.at(k - 1) = 'b';
if (s.at(k - 1) == 'C')
s.at(k - 1) = 'c';
cout << s << endl;
}
| replace | 18 | 24 | 18 | 24 | 0 | |
p03041 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define rep(i, n) for (int i = 0; i < n; i++)
#define P pair<int, int>
#define pb push_back
int main() {
string s;
cin >> s;
int k;
cin >> k;
k--;
if (s[k] == 'A') {
s[k] = 'a';
} else if (s[k] == 'B') {
s[k] = 'b';
} else {
s[k] = 'c';
}
cout << s << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define rep(i, n) for (int i = 0; i < n; i++)
#define P pair<int, int>
#define pb push_back
int main() {
string s;
int n, k;
cin >> n >> k >> s;
k--;
if (s[k] == 'A') {
s[k] = 'a';
} else if (s[k] == 'B') {
s[k] = 'b';
} else {
s[k] = 'c';
}
cout << s << endl;
}
| replace | 8 | 11 | 8 | 11 | 0 | |
p03041 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, K;
string S;
cin >> N >> K;
cin >> S;
if (S.at(K) == 'A') {
S.at(K) = 'a';
} else if (S.at(K) == 'B') {
S.at(K) = 'b';
} else {
S.at(K) = 'c';
}
cout << S << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N, K;
string S;
cin >> N >> K;
K -= 1;
cin >> S;
if (S.at(K) == 'A') {
S.at(K) = 'a';
} else if (S.at(K) == 'B') {
S.at(K) = 'b';
} else {
S.at(K) = 'c';
}
cout << S << endl;
}
| insert | 7 | 7 | 7 | 8 | 0 | |
p03041 | 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;
string s;
cin >> a >> b >> s;
s.at(b) += 32;
cout << s << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
int main() {
int a, b;
string s;
cin >> a >> b >> s;
s.at(b - 1) += 32;
cout << s << endl;
}
| replace | 7 | 8 | 7 | 8 | 0 | |
p03041 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
string s;
cin >> s;
if (s.at(K) == 'A')
s.at(K) = 'a';
if (s.at(K) == 'B')
s.at(K) = 'b';
if (s.at(K) == 'C')
s.at(K) = 'c';
cout << s << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
string s;
cin >> s;
K--;
if (s.at(K) == 'A')
s.at(K) = 'a';
if (s.at(K) == 'B')
s.at(K) = 'b';
if (s.at(K) == 'C')
s.at(K) = 'c';
cout << s << endl;
}
| insert | 8 | 8 | 8 | 9 | 0 | |
p03041 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, K;
string S;
cin >> N >> K >> S;
if (S.at(K) == 'A')
S.at(K) = 'a';
if (S.at(K) == 'B')
S.at(K) = 'b';
if (S.at(K) == 'C')
S.at(K) = 'c';
cout << S << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, K;
string S;
cin >> N >> K >> S;
if (S.at(K - 1) == 'A')
S.at(K - 1) = 'a';
if (S.at(K - 1) == 'B')
S.at(K - 1) = 'b';
if (S.at(K - 1) == 'C')
S.at(K - 1) = 'c';
cout << S << endl;
} | replace | 7 | 13 | 7 | 13 | 0 | |
p03041 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
typedef long long ll;
int main() {
int n, k;
string s;
cin >> n >> k;
cin >> s;
if (s.at(k) == 'A')
s.at(k) = 'a';
if (s.at(k) == 'B')
s.at(k) = 'b';
if (s.at(k) == 'C')
s.at(k) = 'c';
cout << s << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
typedef long long ll;
int main() {
int n, k;
string s;
cin >> n >> k;
cin >> s;
if (s.at(k - 1) == 'A')
s.at(k - 1) = 'a';
if (s.at(k - 1) == 'B')
s.at(k - 1) = 'b';
if (s.at(k - 1) == 'C')
s.at(k - 1) = 'c';
cout << s << endl;
} | replace | 10 | 16 | 10 | 16 | 0 | |
p03041 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
#define fastio() \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0)
#define loop(i, a, b) for (ll i = a; i < b; i++)
#define loope(i, a, b) for (ll i = a; i <= b; i++)
#define test() \
ull t; \
cin >> t; \
while (t--)
#define puu pair<ull, ull>
#define f first
#define s second
#define pb push_back
#define mkp make_pair
#define ins insert
#define Vint vector<int>
#define Vull vector<ull>
#define nl cout << endl
#define sp cout << " "
#define MOD 1000000007
#define all(x) x.begin(), x.end()
int main() {
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
fastio();
ll n, k;
cin >> n >> k;
string s;
cin >> s;
s[k - 1] = tolower(s[k - 1]);
cout << s;
} | #include <bits/stdc++.h>
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
#define fastio() \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0)
#define loop(i, a, b) for (ll i = a; i < b; i++)
#define loope(i, a, b) for (ll i = a; i <= b; i++)
#define test() \
ull t; \
cin >> t; \
while (t--)
#define puu pair<ull, ull>
#define f first
#define s second
#define pb push_back
#define mkp make_pair
#define ins insert
#define Vint vector<int>
#define Vull vector<ull>
#define nl cout << endl
#define sp cout << " "
#define MOD 1000000007
#define all(x) x.begin(), x.end()
int main() {
// #ifndef ONLINE_JUDGE
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
// #endif
// fastio();
ll n, k;
cin >> n >> k;
string s;
cin >> s;
s[k - 1] = tolower(s[k - 1]);
cout << s;
} | replace | 28 | 33 | 28 | 33 | -11 | |
p03041 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#include <iostream>
int main() {
int N, K;
cin >> N >> K;
string S;
cin >> S;
if (S.at(K) == 'A') {
S.at(K) = 'a';
} else if (S.at(K) == 'B') {
S.at(K) = 'b';
} else if (S.at(K) == 'C') {
S.at(K) = 'c';
}
cout << S << endl;
} | #include <bits/stdc++.h>
using namespace std;
#include <iostream>
int main() {
int N, K;
cin >> N >> K;
string S;
cin >> S;
if (S.at(K - 1) == 'A') {
S.at(K - 1) = 'a';
} else if (S.at(K - 1) == 'B') {
S.at(K - 1) = 'b';
} else if (S.at(K - 1) == 'C') {
S.at(K - 1) = 'c';
}
cout << S << endl;
} | replace | 10 | 16 | 10 | 16 | 0 | |
p03041 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
int n;
cin >> n;
char s[n];
int k;
cin >> k;
cin >> s;
s[k - 1] = s[k - 1] + 32;
cout << s;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
char s[n];
int k;
cin >> k;
cin >> s;
s[k - 1] = s[k - 1] + 32;
cout << s;
} | replace | 7 | 11 | 7 | 8 | -11 | |
p03041 | C++ | Runtime Error | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <vector>
using namespace std;
int main(void) {
int n, k;
string s;
cin >> n >> k >> s;
s.at(k) += 'a' - 'A';
cout << s << endl;
return 0;
}
| #include <algorithm>
#include <iomanip>
#include <iostream>
#include <vector>
using namespace std;
int main(void) {
int n, k;
string s;
cin >> n >> k >> s;
s.at(k - 1) += 'a' - 'A';
cout << s << endl;
return 0;
}
| replace | 11 | 12 | 11 | 12 | 0 | |
p03041 | Python | Runtime Error | n, k = map(int, input().split())
s = input()
print(s.replace(s[k], s[k].lower()))
| n, k = map(int, input().split())
s = input()
print(s[: k - 1] + s[k - 1].lower() + s[k:])
| replace | 2 | 4 | 2 | 3 | 0 | |
p03041 | Python | Runtime Error | # -*- coding: utf-8 -*-
def main():
_, K = map(int, input().split(" "))
S = input()
S[K - 1] = S[K - 1].lower()
print(S)
if __name__ == "__main__":
main()
| # -*- coding: utf-8 -*-
def main():
_, K = map(int, input().split(" "))
S = input()
print(S[: K - 1] + S[K - 1].lower() + S[K:])
if __name__ == "__main__":
main()
| replace | 7 | 10 | 7 | 8 | TypeError: 'str' object does not support item assignment | Traceback (most recent call last):
File "/home/alex/Documents/bug-detection/input/Project_CodeNet/data/p03041/Python/s201072546.py", line 13, in <module>
main()
File "/home/alex/Documents/bug-detection/input/Project_CodeNet/data/p03041/Python/s201072546.py", line 7, in main
S[K - 1] = S[K - 1].lower()
TypeError: 'str' object does not support item assignment
|
p03041 | C++ | Runtime Error | #include <algorithm>
#include <cassert>
#include <cmath>
#include <fstream>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>
using namespace std;
int main() {
ifstream in("input.txt");
cin.rdbuf(in.rdbuf());
int n, k;
string s;
cin >> n >> k >> s;
k--;
if (s[k] == 'A') {
s[k] = 'a';
}
if (s[k] == 'B') {
s[k] = 'b';
}
if (s[k] == 'C') {
s[k] = 'c';
}
cout << s << endl;
return 0;
}
| #include <algorithm>
#include <cassert>
#include <cmath>
#include <fstream>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>
using namespace std;
int main() {
int n, k;
string s;
cin >> n >> k >> s;
k--;
if (s[k] == 'A') {
s[k] = 'a';
}
if (s[k] == 'B') {
s[k] = 'b';
}
if (s[k] == 'C') {
s[k] = 'c';
}
cout << s << endl;
return 0;
} | delete | 15 | 18 | 15 | 15 | -11 | |
p03041 | C++ | Runtime Error | #include <stdio.h>
int main() {
int n;
int k;
char s[n + 1];
scanf("%d", &n);
scanf("%d", &k);
scanf("%s", &s);
char j = k - 1;
s[j] += 32;
printf("%s\n", s);
return 0;
}
| #include <stdio.h>
int main() {
char name[52];
int b;
int c;
scanf("%d %d", &c, &b);
getchar();
scanf("%[^\n]", name);
name[b - 1] += 32;
printf("%s", name);
return 0;
} | replace | 3 | 17 | 3 | 11 | 0 | |
p03041 | C++ | Runtime Error | /*coderanant*/
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define ll long long
#define f1(i, a, b) for (i = a; i < b; i++)
#define f2(i, a, b) for (i = a; i >= b; i--)
#define endl '\n'
#define pb push_back
#define gp " "
#define ff first
#define ss second
#define mp make_pair
const int mod = 1000000007;
int i, j;
ll temp;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
#ifndef ONLINE_JUDGE
freopen("in.txt", "r", stdin);
freopen("out.txt", "w", stdout);
#endif
int n, k;
cin >> n >> k;
string s;
cin >> s;
f1(i, 0, n) {
if (i == k - 1)
cout << char(s[i] - 'A' + 'a');
else
cout << s[i];
}
return 0;
} | /*coderanant*/
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define ll long long
#define f1(i, a, b) for (i = a; i < b; i++)
#define f2(i, a, b) for (i = a; i >= b; i--)
#define endl '\n'
#define pb push_back
#define gp " "
#define ff first
#define ss second
#define mp make_pair
const int mod = 1000000007;
int i, j;
ll temp;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
// #ifndef ONLINE_JUDGE
// freopen("in.txt","r",stdin);
// freopen("out.txt","w",stdout);
// #endif
int n, k;
cin >> n >> k;
string s;
cin >> s;
f1(i, 0, n) {
if (i == k - 1)
cout << char(s[i] - 'A' + 'a');
else
cout << s[i];
}
return 0;
} | replace | 22 | 26 | 22 | 26 | -11 | |
p03041 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define IOS \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define Max(x, y, z) max(x, max(y, z))
#define Min(x, y, z) min(x, min(y, z))
#define pb push_back
#define mp make_pair
#define MOD 1000000007
int Please_accept_my_solution_;
/*
Don't be like my girlfriend
Accept me🙏🙏 ;) !
*/
int main() {
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
IOS int n, k;
string s;
cin >> n >> k;
cin >> s;
for (int i = 0; i < s.length(); i++) {
if (k == i + 1)
cout << char(32 + s[i]);
else
cout << s[i];
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define IOS \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define Max(x, y, z) max(x, max(y, z))
#define Min(x, y, z) min(x, min(y, z))
#define pb push_back
#define mp make_pair
#define MOD 1000000007
int Please_accept_my_solution_;
/*
Don't be like my girlfriend
Accept me🙏🙏 ;) !
*/
int main() {
IOS int n, k;
string s;
cin >> n >> k;
cin >> s;
for (int i = 0; i < s.length(); i++) {
if (k == i + 1)
cout << char(32 + s[i]);
else
cout << s[i];
}
return 0;
}
| replace | 21 | 25 | 21 | 22 | 0 | |
p03041 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int n, k;
char s[n];
cin >> n >> k >> s;
s[k - 1] += 32;
printf("%s\n", s);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int n, k;
char s[100];
cin >> n >> k;
cin >> s;
s[k - 1] += 32;
printf("%s\n", s);
return 0;
} | replace | 6 | 8 | 6 | 9 | -11 | |
p03041 | C++ | Runtime Error | #include <cctype>
#include <iostream>
#include <string>
using namespace std;
int main() {
int size, th;
string thing;
cin >> size >> th;
for (int i = 0; i < size; i++) {
cin >> thing[i];
}
for (int i = 0; i < size; i++) {
if (i == th - 1) {
putchar(tolower(thing[th - 1]));
} else {
cout << thing[i];
}
}
} | #include <cctype>
#include <iostream>
#include <string>
using namespace std;
int main() {
int size, th;
string thing;
cin >> size >> th >> thing;
for (int i = 0; i < size; i++) {
if (i == th - 1) {
putchar(tolower(thing[th - 1]));
} else {
cout << thing[i];
}
}
} | replace | 9 | 14 | 9 | 10 | 0 | |
p03041 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main() {
string S;
int N, K;
cin >> N >> K >> S;
if (S.at(K) == 'A') {
S.at(K) = 'a';
} else if (S.at(K) == 'B') {
S.at(K) = 'b';
} else if (S.at(K) == 'C') {
S.at(K) = 'c';
}
cout << S << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
string S;
int N, K;
cin >> N >> K >> S;
if (S.at(K - 1) == 'A') {
S.at(K - 1) = 'a';
} else if (S.at(K - 1) == 'B') {
S.at(K - 1) = 'b';
} else if (S.at(K - 1) == 'C') {
S.at(K - 1) = 'c';
}
cout << S << endl;
} | replace | 9 | 15 | 9 | 15 | 0 | |
p03041 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B;
string X, Atoa;
cin >> A >> B >> X;
Atoa = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
for (int i = 0; i < 26; i++) {
if (X.at(B) == Atoa.at(i)) {
X.at(B) = Atoa.at(i + 26);
break;
}
}
cout << X << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B;
string X, Atoa;
cin >> A >> B >> X;
Atoa = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
for (int i = 0; i < 26; i++) {
if (X.at(B - 1) == Atoa.at(i)) {
X.at(B - 1) = Atoa.at(i + 26);
break;
}
}
cout << X << endl;
}
| replace | 8 | 10 | 8 | 10 | 0 | |
p03041 | C++ | Runtime Error | #include <bits/stdc++.h>
typedef long long int ll;
typedef unsigned long long int ull;
typedef long double ld;
typedef std::pair<int, int> pii;
typedef std::pair<ll, ll> pll;
typedef std::pair<double, double> pdd;
using namespace std;
#define fastio() \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0)
#define loop(i, a, b) for (ll i = a; i < b; i++)
#define loope(i, a, b) for (ll i = a; i <= b; i++)
#define test() \
ull testcase; \
cin >> testcase; \
while (testcase--)
#define pb push_back
#define mkp make_pair
#define nl cout << "\n"
#define prime 1000000007
#define debug(x) cout << (#x) << " : " << x, nl
#define debug2(x, y) cout << (#x) << " : " << x << " " << (#y) << " : " << y, nl
#define debug3(x, y, z) \
cout << (#x) << " : " << x << " " << (#y) << " : " << y << " " << (#z) \
<< " : " << z, \
nl
#define f first
#define s second
#define oa(a, n) \
loop(i, 0, n) cout << a[i] << " "; \
nl;
#define ov(a) \
loop(i, 0, a.size()) cout << a[i] << " "; \
nl;
#define MOD(a) (((a % prime) + prime) % prime)
int main() {
#ifndef ONLINE_JUDGE
// for getting input from input.txt
freopen("input.txt", "r", stdin);
// for writing output to output.txt
freopen("output.txt", "w", stdout);
#endif
ll n, k, i;
cin >> n >> k;
string s;
cin >> s;
if (islower(s[k - 1]) == 0) {
s[k - 1] = s[k - 1] + 32;
}
cout << s;
} | #include <bits/stdc++.h>
typedef long long int ll;
typedef unsigned long long int ull;
typedef long double ld;
typedef std::pair<int, int> pii;
typedef std::pair<ll, ll> pll;
typedef std::pair<double, double> pdd;
using namespace std;
#define fastio() \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0)
#define loop(i, a, b) for (ll i = a; i < b; i++)
#define loope(i, a, b) for (ll i = a; i <= b; i++)
#define test() \
ull testcase; \
cin >> testcase; \
while (testcase--)
#define pb push_back
#define mkp make_pair
#define nl cout << "\n"
#define prime 1000000007
#define debug(x) cout << (#x) << " : " << x, nl
#define debug2(x, y) cout << (#x) << " : " << x << " " << (#y) << " : " << y, nl
#define debug3(x, y, z) \
cout << (#x) << " : " << x << " " << (#y) << " : " << y << " " << (#z) \
<< " : " << z, \
nl
#define f first
#define s second
#define oa(a, n) \
loop(i, 0, n) cout << a[i] << " "; \
nl;
#define ov(a) \
loop(i, 0, a.size()) cout << a[i] << " "; \
nl;
#define MOD(a) (((a % prime) + prime) % prime)
int main() {
ll n, k, i;
cin >> n >> k;
string s;
cin >> s;
if (islower(s[k - 1]) == 0) {
s[k - 1] = s[k - 1] + 32;
}
cout << s;
} | delete | 40 | 46 | 40 | 40 | -11 | |
p03041 | C++ | Runtime Error | #include <iostream>
using namespace std;
int main() {
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
int n, k;
cin >> n >> k;
char A[n];
cin >> A;
A[k - 1] = A[k - 1] + 32;
cout << A << "\n";
return 0;
} | #include <iostream>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
char A[n];
cin >> A;
A[k - 1] = A[k - 1] + 32;
cout << A << "\n";
return 0;
} | delete | 4 | 8 | 4 | 4 | -11 | |
p03041 | Python | Runtime Error | n, k = map(int, input().split())
s = input()
s[k - 1] = s[k - 1].lower()
print(s)
| n, k = map(int, input().split())
s = input()
print(s[: k - 1] + s[k - 1].lower() + s[k:])
| replace | 2 | 4 | 2 | 3 | TypeError: 'str' object does not support item assignment | Traceback (most recent call last):
File "/home/alex/Documents/bug-detection/input/Project_CodeNet/data/p03041/Python/s255611980.py", line 3, in <module>
s[k - 1] = s[k - 1].lower()
TypeError: 'str' object does not support item assignment
|
p03041 | Python | Runtime Error | N = int(input())
K = int(input())
S = input()
s1 = S[: K - 1]
s2 = S[K:]
if S[K - 1] == "A":
s = s1 + "a" + s2
elif S[K - 1] == "B":
s = s1 + "b" + s2
else:
s = s1 + "c" + s2
print(s)
| nums = input().split()
N = int(nums[0])
K = int(nums[1])
S = input()
s1 = S[: K - 1]
s2 = S[K:]
if S[K - 1] == "A":
s = s1 + "a" + s2
elif S[K - 1] == "B":
s = s1 + "b" + s2
else:
s = s1 + "c" + s2
print(s)
| replace | 0 | 2 | 0 | 3 | ValueError: invalid literal for int() with base 10: '3 1' | Traceback (most recent call last):
File "/home/alex/Documents/bug-detection/input/Project_CodeNet/data/p03041/Python/s245648699.py", line 1, in <module>
N = int(input())
ValueError: invalid literal for int() with base 10: '3 1'
|
p03041 | Python | Runtime Error | N, K = map(int, input().split())
S = str(input())
if S[K - 1] == "A":
S[K - 1] = "a"
print("".join(S))
elif S[K - 1] == "B":
S[K - 1] = "b"
print("".join(S))
else:
S[K - 1] = "c"
print("".join(S))
| N, K = map(int, input().split())
S = list(input())
if S[K - 1] == "A":
S[K - 1] = "a"
print("".join(S))
elif S[K - 1] == "B":
S[K - 1] = "b"
print("".join(S))
else:
S[K - 1] = "c"
print("".join(S))
| replace | 1 | 2 | 1 | 2 | TypeError: 'str' object does not support item assignment | Traceback (most recent call last):
File "/home/alex/Documents/bug-detection/input/Project_CodeNet/data/p03041/Python/s243214892.py", line 4, in <module>
S[K - 1] = "a"
TypeError: 'str' object does not support item assignment
|
p03041 | Python | Runtime Error | N = input()
K = input()
S = list(input())
S[K - 1] = S[K - 1].lower()
print("".join(S))
| N, K = (int(i) for i in input().split())
S = list(input())
S[K - 1] = S[K - 1].lower()
print("".join(S))
| replace | 0 | 2 | 0 | 1 | EOFError: EOF when reading a line | Traceback (most recent call last):
File "/home/alex/Documents/bug-detection/input/Project_CodeNet/data/p03041/Python/s060420090.py", line 3, in <module>
S = list(input())
EOFError: EOF when reading a line
|
p03041 | C++ | Runtime Error | #include <stdio.h>
int main() {
int N, K, X;
char nama[12];
scanf("%d %d %d", &N, &K, &X);
scanf("%s", &nama);
X = K - 1;
nama[X] = nama[X] + 32;
printf("%s", nama);
return 0;
} | #include <stdio.h>
int main() {
int n, k;
char s[52];
scanf("%d%d", &n, &k);
scanf("%s", &s);
s[k - 1] += 32;
printf("%s\n", s);
return 0;
}
| replace | 3 | 13 | 3 | 9 | 0 | |
p03041 | C++ | Runtime Error | #include <iostream>
#include <string>
int main() {
int N;
int K;
int cnt = 0;
std::cin >> N >> K;
if (N < 1 || 50 < N)
std::cout << "Error!(1 <= N <= 50)" << std::endl;
if (K > N)
std::cout << "Error!3(K > N)" << std::endl;
char *s;
std ::cin >> s;
std::string tmp = std::string(s);
if (std::islower(s[K - 1])) {
s[K - 1] = toupper(s[K - 1]);
} else {
s[K - 1] = tolower(s[K - 1]);
}
std::cout << s << std::endl;
return 0;
} | #include <iostream>
#include <string>
int main() {
int N;
int K;
char s[50];
std::cin >> N >> K >> s;
std::string tmp = std::string(s);
if (std::islower(s[K - 1])) {
s[K - 1] = toupper(s[K - 1]);
} else {
s[K - 1] = tolower(s[K - 1]);
}
std::cout << s << std::endl;
return 0;
} | replace | 7 | 15 | 7 | 9 | 0 | |
p03041 | Python | Runtime Error | n, k = map(int, input().split())
s = list(input())
s[k] = s[k].lower()
print("".join(s))
| n, k = map(int, input().split())
s = list(input())
s[k - 1] = s[k - 1].lower()
print("".join(s))
| replace | 2 | 3 | 2 | 3 | 0 | |
p03041 | C++ | Time Limit Exceeded | #pragma warning(disable : 4996)
#include <stdio.h>
int main() {
int n, k;
char s[51];
scanf("%d %d", &n, &k);
scanf("%s", s);
/*
printf("%d %d", 'a', 'A');
while (1);
*/
s[k - 1] += 32;
printf("%s", s);
while (1)
;
} | #pragma warning(disable : 4996)
#include <stdio.h>
int main() {
int n, k;
char s[51];
scanf("%d %d", &n, &k);
scanf("%s", s);
/*
printf("%d %d", 'a', 'A');
while (1);
*/
s[k - 1] += 32;
printf("%s", s);
} | delete | 15 | 17 | 15 | 15 | TLE | |
p03041 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n, k;
string s;
cin >> n >> k;
cin >> s;
s.at(k) = tolower(s.at(k));
cout << s << endl;
} | #include <algorithm>
#include <cmath>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n, k;
string s;
cin >> n >> k;
cin >> s;
s.at(k - 1) = tolower(s.at(k - 1));
cout << s << endl;
} | replace | 12 | 13 | 12 | 13 | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.