problem_id stringlengths 6 6 | buggy_code stringlengths 8 526k ⌀ | fixed_code stringlengths 12 526k ⌀ | labels listlengths 0 15 ⌀ | buggy_submission_id int64 1 1.54M ⌀ | fixed_submission_id int64 2 1.54M ⌀ | user_id stringlengths 10 10 ⌀ | language stringclasses 9 values |
|---|---|---|---|---|---|---|---|
p03038 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> i_i;
typedef pair<ll, ll> l_l;
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
// const ll mod = 1000000007;
ll n, m;
ll a[100001], b[100001], c[100001];
l_l cb[100001];
ll ans;
signed main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < m; i++) {
cin >> b[i] >> c[i];
cb[i] = make_pair(c[i], b[i]);
}
sort(a, a + n);
sort(cb, cb + m, greater<l_l>());
int it;
int nit = -1;
for (int i = 0; i < m; i++) {
ll B = cb[i].second;
ll C = cb[i].first;
it = nit;
nit = it + B;
if (nit > n) {
for (int j = it + 1; j < n; j++) {
ans += max(C, a[j]);
}
break;
}
if (a[nit] > C) {
for (int j = it + 1; j < n; j++) {
ans += max(C, a[j]);
}
break;
}
ans += C * B;
// 後半はなくても良い
if (i == m - 1 && nit < n - 1) {
for (int j = nit + 1; j < n; j++) {
ans += a[j];
}
}
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> i_i;
typedef pair<ll, ll> l_l;
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
// const ll mod = 1000000007;
ll n, m;
ll a[100010], b[100010], c[100010];
l_l cb[100010];
ll ans;
signed main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < m; i++) {
cin >> b[i] >> c[i];
cb[i] = make_pair(c[i], b[i]);
}
sort(a, a + n);
sort(cb, cb + m, greater<l_l>());
int it;
int nit = -1;
for (int i = 0; i < m; i++) {
ll B = cb[i].second;
ll C = cb[i].first;
it = nit;
nit = it + B;
if (nit >= n) {
for (int j = it + 1; j < n; j++) {
ans += max(C, a[j]);
}
break;
}
if (a[nit] > C) {
for (int j = it + 1; j < n; j++) {
ans += max(C, a[j]);
}
break;
}
ans += C * B;
// 後半はなくても良い
if (i == m - 1 && nit < n - 1) {
for (int j = nit + 1; j < n; j++) {
ans += a[j];
}
}
}
cout << ans << endl;
}
| [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 854,113 | 854,114 | u263858205 | cpp |
p03038 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
#define REP(NAME, NUM) for (int NAME = 0; NAME < (NUM); ++NAME)
#define BREP(NAME, NUM) for (int NAME = (NUM)-1; NAME >= 0; --NAME)
#define ALL(NAME) (NAME).begin(), (NAME).end()
#define cMOD 1000000007ULL
#define cINF ((1ull << 62) - 1)
#define cINFINT ((1 << 30) - 1)
int main() {
ll n, m;
cin >> n >> m;
map<ll, ll> mp;
REP(i, n) {
ll a;
cin >> a;
mp[a]++;
}
REP(i, m) {
ll b, c;
cin >> b >> c;
mp[c] += b;
}
ll sum = 0;
ll idx = n;
for (auto it = mp.end(); idx > 0; --it) {
sum += (*it).first * min(idx, (*it).second);
idx -= (*it).second;
}
cout << sum;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
#define REP(NAME, NUM) for (int NAME = 0; NAME < (NUM); ++NAME)
#define BREP(NAME, NUM) for (int NAME = (NUM)-1; NAME >= 0; --NAME)
#define ALL(NAME) (NAME).begin(), (NAME).end()
#define cMOD 1000000007ULL
#define cINF ((1ull << 62) - 1)
#define cINFINT ((1 << 30) - 1)
int main() {
ll n, m;
cin >> n >> m;
map<ll, ll> mp;
REP(i, n) {
ll a;
cin >> a;
mp[a]++;
}
REP(i, m) {
ll b, c;
cin >> b >> c;
mp[c] += b;
}
ll sum = 0;
ll idx = n;
for (auto it = mp.rbegin(); idx > 0; ++it) {
sum += (*it).first * min(idx, (*it).second);
idx -= (*it).second;
}
cout << sum;
return 0;
} | [
"call.function.change",
"control_flow.loop.for.initializer.change"
] | 854,120 | 854,121 | u627427672 | cpp |
p03038 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
#define REP(NAME, NUM) for (int NAME = 0; NAME < (NUM); ++NAME)
#define BREP(NAME, NUM) for (int NAME = (NUM)-1; NAME >= 0; --NAME)
#define ALL(NAME) (NAME).begin(), (NAME).end()
#define cMOD 1000000007ULL
#define cINF ((1ull << 62) - 1)
#define cINFINT ((1 << 30) - 1)
int main() {
ll n, m;
cin >> n >> m;
map<ll, ll> mp;
REP(i, n) {
ll a;
cin >> a;
mp[a]++;
}
REP(i, m) {
ll b, c;
cin >> b >> c;
mp[c] += b;
}
ll sum = 0;
ll idx = n;
for (auto it = mp.end(); idx > 0; --it) {
sum += (*it).first * min(idx, (*it).second);
idx -= (*it).second;
}
cout << sum;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
#define REP(NAME, NUM) for (int NAME = 0; NAME < (NUM); ++NAME)
#define BREP(NAME, NUM) for (int NAME = (NUM)-1; NAME >= 0; --NAME)
#define ALL(NAME) (NAME).begin(), (NAME).end()
#define cMOD 1000000007ULL
#define cINF ((1ull << 62) - 1)
#define cINFINT ((1 << 30) - 1)
int main() {
ll n, m;
cin >> n >> m;
map<ll, ll> mp;
REP(i, n) {
ll a;
cin >> a;
mp[a]++;
}
REP(i, m) {
ll b, c;
cin >> b >> c;
mp[c] += b;
}
ll sum = 0;
ll idx = n;
for (auto it = mp.end(); idx > 0;) {
--it;
sum += (*it).first * min(idx, (*it).second);
idx -= (*it).second;
}
cout << sum;
return 0;
} | [
"control_flow.loop.for.update.change",
"expression.unary.arithmetic.add"
] | 854,120 | 854,122 | u627427672 | cpp |
p03038 | #include <algorithm>
#include <functional>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
typedef long long int ll;
typedef pair<int, int> P;
int main() {
int N, M, tmp, b, c, j;
ll total = 0;
cin >> N >> M;
vector<P> data(N + M);
for (int i = 0; i < N; i++) {
cin >> data[i].first;
data[i].second = 1;
}
for (int i = 0; i < M; i++) {
cin >> data[i + N].second >> data[i + N].first;
}
sort(data.begin(), data.end(), greater<P>());
j = N;
for (int i = 0; i < j; i++) {
if (N > data[i].second) {
total += data[i].second * data[i].first;
N -= data[i].second;
} else {
total += N * data[i].first;
break;
}
}
cout << total;
return 0;
} | #include <algorithm>
#include <functional>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
typedef long long int ll;
typedef pair<ll, ll> P;
int main() {
int N, M, tmp, b, c, j;
ll total = 0;
cin >> N >> M;
vector<P> data(N + M);
for (int i = 0; i < N; i++) {
cin >> data[i].first;
data[i].second = 1;
}
for (int i = 0; i < M; i++) {
cin >> data[i + N].second >> data[i + N].first;
}
sort(data.begin(), data.end(), greater<P>());
j = N;
for (int i = 0; i < j; i++) {
if (N > data[i].second) {
total += data[i].second * data[i].first;
N -= data[i].second;
} else {
total += N * data[i].first;
break;
}
}
cout << total;
return 0;
} | [] | 854,129 | 854,130 | u511788770 | cpp |
p03038 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n, j, i = 0, k = 0;
cin >> n >> j;
int a[100000] = {};
while (i < n) {
cin >> a[i];
i++;
}
sort(a, a + n);
vector<pair<int, int>> A(j);
while (i < j) {
cin >> A[i].second >> A[i].first;
i++;
}
sort(A.begin(), A.end(), greater<pair<int, int>>());
i = 0;
while (i < j) {
int b = A[i].second;
while (b > 0) {
if (a[k] < A[i].first) {
a[k] = A[i].first;
k++;
b--;
if (k >= n) {
goto out;
}
} else {
break;
}
}
i++;
}
out:
long long ans = 0;
i = 0;
while (i < n) {
ans += a[i];
i++;
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n, j, i = 0, k = 0;
cin >> n >> j;
int a[100000] = {};
while (i < n) {
cin >> a[i];
i++;
}
sort(a, a + n);
vector<pair<int, int>> A(j);
i = 0;
while (i < j) {
cin >> A[i].second >> A[i].first;
i++;
}
sort(A.begin(), A.end(), greater<pair<int, int>>());
i = 0;
while (i < j) {
int b = A[i].second;
while (b > 0) {
if (a[k] < A[i].first) {
a[k] = A[i].first;
k++;
b--;
if (k >= n) {
goto out;
}
} else {
break;
}
}
i++;
}
out:
long long ans = 0;
i = 0;
while (i < n) {
ans += a[i];
i++;
}
cout << ans << endl;
return 0;
} | [
"assignment.add"
] | 854,131 | 854,132 | u258475646 | cpp |
p03038 | #include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
const int maxn = 123456;
typedef long long ll;
typedef pair<int, int> pii;
ll a[maxn];
map<ll, int> mp;
std::map<ll, int>::iterator it;
int main() {
// freopen("input.txt", "r", stdin);
int N, M;
mp.clear();
cin >> N >> M;
for (int i = 0; i < N; ++i) {
cin >> a[i];
}
sort(a, a + N);
ll c;
int b;
for (int i = 0; i < M; ++i) {
cin >> b >> c;
mp[c] = b;
}
int cur = 0;
ll res = 0;
for (; cur < N;) {
if (!mp.size())
break;
it = mp.end();
it--;
if (it->first > a[cur]) {
res += it->first;
it->second--;
if (!it->second)
mp.erase(it);
cur++;
} else
break;
}
while (cur < N) {
res += a[cur++];
}
cout << res << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
const int maxn = 123456;
typedef long long ll;
typedef pair<int, int> pii;
ll a[maxn];
map<ll, int> mp;
std::map<ll, int>::iterator it;
int main() {
// freopen("input.txt", "r", stdin);
int N, M;
mp.clear();
cin >> N >> M;
for (int i = 0; i < N; ++i) {
cin >> a[i];
}
sort(a, a + N);
ll c;
int b;
for (int i = 0; i < M; ++i) {
cin >> b >> c;
mp[c] += b; // note: there may be duplicated keywords
}
int cur = 0;
ll res = 0;
for (; cur < N;) {
if (!mp.size())
break;
it = mp.end();
it--;
if (it->first > a[cur]) {
res += it->first;
it->second--;
if (!it->second)
mp.erase(it);
cur++;
} else
break;
}
while (cur < N) {
res += a[cur++];
}
cout << res << endl;
return 0;
} | [
"assignment.value.change"
] | 854,139 | 854,140 | u608624039 | cpp |
p03038 | #include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
const int maxn = 123456;
typedef long long ll;
typedef pair<int, int> pii;
ll a[maxn];
map<ll, int> mp;
std::map<ll, int>::iterator it;
int main() {
// freopen("input.txt", "r", stdin);
int N, M;
mp.clear();
cin >> N >> M;
for (int i = 0; i < N; ++i) {
cin >> a[i];
}
sort(a, a + N);
ll c;
int b;
for (int i = 0; i < M; ++i) {
cin >> b >> c;
mp[c] = b;
}
int cur = 0;
ll res = 0;
for (; cur < N;) {
if (!mp.size())
break;
it = mp.end();
it--;
if (it->first > a[cur]) {
res += it->first;
it->second--;
if (!it->second)
mp.erase(it);
cur++;
} else
break;
}
while (cur < N) {
res += a[cur++];
}
cout << res << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
const int maxn = 123456;
typedef long long ll;
typedef pair<int, int> pii;
ll a[maxn];
map<ll, int> mp;
std::map<ll, int>::iterator it;
int main() {
// freopen("input.txt", "r", stdin);
int N, M;
mp.clear();
cin >> N >> M;
for (int i = 0; i < N; ++i) {
cin >> a[i];
}
sort(a, a + N);
ll c;
int b;
for (int i = 0; i < M; ++i) {
cin >> b >> c;
mp[c] += b;
}
int cur = 0;
ll res = 0;
for (; cur < N;) {
if (!mp.size())
break;
it = mp.end();
it--;
if (it->first > a[cur]) {
res += it->first;
it->second--;
if (!it->second)
mp.erase(it);
cur++;
} else
break;
}
while (cur < N) {
res += a[cur++];
}
cout << res << endl;
return 0;
} | [
"assignment.value.change"
] | 854,139 | 854,141 | u608624039 | cpp |
p03038 | #include <bits/stdc++.h>
#define ll long long
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int> A(N + 1, 0);
for (int i = 1; i <= N; i++) {
cin >> A[i];
}
sort(A.begin(), A.end());
vector<pair<int, int>> P(M);
for (int i = 0; i < M; i++) {
cin >> P[i].first >> P[i].second;
}
sort(P.begin(), P.end(),
[](const pair<int, int> &a, const pair<int, int> &b) {
return a.second > b.second;
});
int n = 0;
for (int i = 0; i < M; i++) {
int B = P[i].first;
int C = P[i].second;
while (B > 0 && n + 1 <= N && A[n + 1] < C) {
A[n + 1] = C;
n++;
}
}
ll ans = 0;
for (int i = 1; i <= N; i++) {
ans += A[i];
}
cout << ans << endl;
} | #include <bits/stdc++.h>
#define ll long long
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int> A(N + 1, 0);
for (int i = 1; i <= N; i++) {
cin >> A[i];
}
sort(A.begin(), A.end());
vector<pair<int, int>> P(M);
for (int i = 0; i < M; i++) {
cin >> P[i].first >> P[i].second;
}
sort(P.begin(), P.end(),
[](const pair<int, int> &a, const pair<int, int> &b) {
return a.second > b.second;
});
int n = 0;
for (int i = 0; i < M; i++) {
int B = P[i].first;
int C = P[i].second;
while (B > 0 && n + 1 <= N && A[n + 1] < C) {
A[n + 1] = C;
n++;
B--;
}
}
ll ans = 0;
for (int i = 1; i <= N; i++) {
ans += A[i];
}
cout << ans << endl;
} | [
"expression.unary.arithmetic.add"
] | 854,154 | 854,155 | u119098168 | cpp |
p03038 | #include <algorithm>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
int main() {
int N, M;
cin >> N >> M;
int Ai;
priority_queue<P> p;
for (int i = 0; i < N; i++) {
cin >> Ai;
p.push(make_pair(Ai, 1));
}
for (int i = 0; i < M; i++) {
int b, c;
cin >> b >> c;
p.push(make_pair(c, b));
}
int ans = 0;
for (int i = 0; i < N; i++) {
auto a = p.top();
p.pop();
ans += a.first;
a.second--;
if (a.second > 0) {
p.push(a);
}
}
cout << ans << endl;
} | #include <algorithm>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
int main() {
int N, M;
cin >> N >> M;
int Ai;
priority_queue<P> p;
for (int i = 0; i < N; i++) {
cin >> Ai;
p.push(make_pair(Ai, 1));
}
for (int i = 0; i < M; i++) {
int b, c;
cin >> b >> c;
p.push(make_pair(c, b));
}
ll ans = 0;
for (int i = 0; i < N; i++) {
auto a = p.top();
p.pop();
ans += (ll)a.first;
a.second--;
if (a.second > 0) {
p.push(a);
}
}
cout << ans << endl;
} | [
"variable_declaration.type.change"
] | 854,158 | 854,159 | u904131021 | cpp |
p03038 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <tuple>
#include <utility>
#include <vector>
#define int long long int
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define ALL(x) (x).begin(), (x).end()
#define SZ(x) ((int)(x).size())
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end())
using namespace std;
typedef pair<int, int> P;
const int INF = 1e15;
const int MOD = 1e9 + 7;
template <typename T> using vector2 = vector<vector<T>>;
template <typename T> vector2<T> initVec2(size_t n0, size_t n1, T e = T()) {
return vector2<T>(n0, vector<T>(n1, e));
}
template <typename T> using vector3 = vector<vector<vector<T>>>;
template <typename T>
vector3<T> initVec3(size_t n0, size_t n1, size_t n2, T e = T()) {
return vector3<T>(n0, vector2<T>(n1, vector<T>(n2, e)));
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
vector<int> a(n);
rep(i, n) cin >> a[i];
vector<P> v(m);
rep(i, m) {
int b, c;
cin >> b >> c;
v[i] = {c, b};
}
sort(ALL(v), greater<P>());
sort(ALL(a));
int i = 0;
int j = 0;
int ans = 0;
while (i < n && j < m) {
if (a[i] > v[j].first) {
ans += a[i];
i++;
continue;
}
rep(k, v[j].second) {
if (a[i] > v[j].first) {
break;
}
ans += v[j].first;
i++;
}
j++;
}
for (; i < n; i++) {
ans += a[i];
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cmath>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <tuple>
#include <utility>
#include <vector>
#define int long long int
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define ALL(x) (x).begin(), (x).end()
#define SZ(x) ((int)(x).size())
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end())
using namespace std;
typedef pair<int, int> P;
const int INF = 1e15;
const int MOD = 1e9 + 7;
template <typename T> using vector2 = vector<vector<T>>;
template <typename T> vector2<T> initVec2(size_t n0, size_t n1, T e = T()) {
return vector2<T>(n0, vector<T>(n1, e));
}
template <typename T> using vector3 = vector<vector<vector<T>>>;
template <typename T>
vector3<T> initVec3(size_t n0, size_t n1, size_t n2, T e = T()) {
return vector3<T>(n0, vector2<T>(n1, vector<T>(n2, e)));
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
vector<int> a(n);
rep(i, n) cin >> a[i];
vector<P> v(m);
rep(i, m) {
int b, c;
cin >> b >> c;
v[i] = {c, b};
}
sort(ALL(v), greater<P>());
sort(ALL(a));
int i = 0;
int j = 0;
int ans = 0;
while (i < n && j < m) {
if (a[i] > v[j].first) {
ans += a[i];
i++;
continue;
}
rep(k, v[j].second) {
if (i >= n || a[i] > v[j].first) {
break;
}
ans += v[j].first;
i++;
}
j++;
}
for (; i < n; i++) {
ans += a[i];
}
cout << ans << endl;
return 0;
}
| [
"control_flow.branch.if.condition.change"
] | 854,028 | 854,029 | u558092537 | cpp |
p03039 | #include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <iostream>
#include <string>
#include <unordered_map>
#include <unordered_set>
using namespace std;
#define ll long long
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define FOR(i, a, b) for (ll i = (a); i < (b); i++)
#define FORR(i, a, b) for (ll i = (a); i <= (b); i++)
#define repR(i, n) for (ll i = n; i >= 0; i--)
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define F first
#define S second
#define pb push_back
#define pu push
#define COUT(x) cout << (x) << "\n"
#define PQ priority_queue<ll>
#define PQR priority_queue<ll, vector<ll>, greater<ll>>
#define YES(n) cout << ((n) ? "YES\n" : "NO\n")
#define Yes(n) cout << ((n) ? "Yes\n" : "No\n")
#define mp make_pair
#define sz(x) (ll)(x).size()
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const ll MOD = 1000000007LL;
const ll INF = 1LL << 60;
using vll = vector<ll>;
using vb = vector<bool>;
using vvb = vector<vb>;
using vvll = vector<vll>;
using vstr = vector<string>;
using vc = vector<char>;
using vvc = vector<vc>;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
ll dx[4] = {0, 1, 0, -1};
ll dy[4] = {1, 0, -1, 0};
//二項係数 nCr
const int MAX = 700000;
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() {
ll n, m, k;
cin >> n >> m >> k;
COMinit();
ll ans = 0;
rep(i, m) {
ans += i * (m - i) * n * n;
ans %= MOD;
}
rep(i, n) {
ans += i * (n - i) * m * m;
ans %= MOD;
}
ans *= COM(n + m - 2, k - 2);
ans %= MOD;
COUT(ans);
} | #include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <iostream>
#include <string>
#include <unordered_map>
#include <unordered_set>
using namespace std;
#define ll long long
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define FOR(i, a, b) for (ll i = (a); i < (b); i++)
#define FORR(i, a, b) for (ll i = (a); i <= (b); i++)
#define repR(i, n) for (ll i = n; i >= 0; i--)
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define F first
#define S second
#define pb push_back
#define pu push
#define COUT(x) cout << (x) << "\n"
#define PQ priority_queue<ll>
#define PQR priority_queue<ll, vector<ll>, greater<ll>>
#define YES(n) cout << ((n) ? "YES\n" : "NO\n")
#define Yes(n) cout << ((n) ? "Yes\n" : "No\n")
#define mp make_pair
#define sz(x) (ll)(x).size()
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const ll MOD = 1000000007LL;
const ll INF = 1LL << 60;
using vll = vector<ll>;
using vb = vector<bool>;
using vvb = vector<vb>;
using vvll = vector<vll>;
using vstr = vector<string>;
using vc = vector<char>;
using vvc = vector<vc>;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
ll dx[4] = {0, 1, 0, -1};
ll dy[4] = {1, 0, -1, 0};
//二項係数 nCr
const int MAX = 700000;
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() {
ll n, m, k;
cin >> n >> m >> k;
COMinit();
ll ans = 0;
rep(i, m) {
ans += i * (m - i) * n * n;
ans %= MOD;
}
rep(i, n) {
ans += i * (n - i) * m * m;
ans %= MOD;
}
ans *= COM(n * m - 2, k - 2);
ans %= MOD;
COUT(ans);
}
| [
"expression.operator.arithmetic.change",
"assignment.value.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 854,174 | 854,175 | u103850114 | cpp |
p03039 | #include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <iostream>
#include <string>
#include <unordered_map>
#include <unordered_set>
using namespace std;
#define ll long long
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define FOR(i, a, b) for (ll i = (a); i < (b); i++)
#define FORR(i, a, b) for (ll i = (a); i <= (b); i++)
#define repR(i, n) for (ll i = n; i >= 0; i--)
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define F first
#define S second
#define pb push_back
#define pu push
#define COUT(x) cout << (x) << "\n"
#define PQ priority_queue<ll>
#define PQR priority_queue<ll, vector<ll>, greater<ll>>
#define YES(n) cout << ((n) ? "YES\n" : "NO\n")
#define Yes(n) cout << ((n) ? "Yes\n" : "No\n")
#define mp make_pair
#define sz(x) (ll)(x).size()
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const ll MOD = 1000000007LL;
const ll INF = 1LL << 60;
using vll = vector<ll>;
using vb = vector<bool>;
using vvb = vector<vb>;
using vvll = vector<vll>;
using vstr = vector<string>;
using vc = vector<char>;
using vvc = vector<vc>;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
ll dx[4] = {0, 1, 0, -1};
ll dy[4] = {1, 0, -1, 0};
//二項係数 nCr
const int MAX = 700000;
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() {
ll n, m, k;
cin >> n >> m >> k;
COMinit();
ll ans = 0;
rep(i, m - 1) {
ans += i * (m - i) * n * n;
ans %= MOD;
}
rep(i, n - 1) {
ans += i * (n - i) * m * m;
ans %= MOD;
}
ans *= COM(n + m - 2, k - 2);
ans %= MOD;
COUT(ans);
}
| #include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <iostream>
#include <string>
#include <unordered_map>
#include <unordered_set>
using namespace std;
#define ll long long
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define FOR(i, a, b) for (ll i = (a); i < (b); i++)
#define FORR(i, a, b) for (ll i = (a); i <= (b); i++)
#define repR(i, n) for (ll i = n; i >= 0; i--)
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define F first
#define S second
#define pb push_back
#define pu push
#define COUT(x) cout << (x) << "\n"
#define PQ priority_queue<ll>
#define PQR priority_queue<ll, vector<ll>, greater<ll>>
#define YES(n) cout << ((n) ? "YES\n" : "NO\n")
#define Yes(n) cout << ((n) ? "Yes\n" : "No\n")
#define mp make_pair
#define sz(x) (ll)(x).size()
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const ll MOD = 1000000007LL;
const ll INF = 1LL << 60;
using vll = vector<ll>;
using vb = vector<bool>;
using vvb = vector<vb>;
using vvll = vector<vll>;
using vstr = vector<string>;
using vc = vector<char>;
using vvc = vector<vc>;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
ll dx[4] = {0, 1, 0, -1};
ll dy[4] = {1, 0, -1, 0};
//二項係数 nCr
const int MAX = 700000;
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() {
ll n, m, k;
cin >> n >> m >> k;
COMinit();
ll ans = 0;
rep(i, m) {
ans += i * (m - i) * n * n;
ans %= MOD;
}
rep(i, n) {
ans += i * (n - i) * m * m;
ans %= MOD;
}
ans *= COM(n * m - 2, k - 2);
ans %= MOD;
COUT(ans);
}
| [
"expression.operation.binary.remove",
"expression.operator.arithmetic.change",
"assignment.value.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 854,176 | 854,175 | u103850114 | cpp |
p03039 | #include <bits/stdc++.h>
using namespace std;
#define int ll
#define ll long long
#define I32_MAX 2147483647
#define I64_MAX 9223372036854775807LL
#define I64_MAX2 1223372036854775807LL
#define INF I64_MAX2
#define MOD 1000000007
// #define MOD 998244353
#define MEM_SIZE 101010
#define DEBUG_OUT true
#define ALL(x) (x).begin(), (x).end()
template <typename T> void DEBUG(T e) {
if (DEBUG_OUT == false)
return;
std::cout << e << " ";
}
template <typename T> void DEBUG(const std::vector<T> &v) {
if (DEBUG_OUT == false)
return;
for (const auto &e : v) {
std::cout << e << " ";
}
std::cout << std::endl;
}
template <typename T> void DEBUG(const std::vector<std::vector<T>> &vv) {
if (DEBUG_OUT == false)
return;
for (const auto &v : vv) {
DEBUG(v);
}
}
template <class T, class... Ts> void DEBUG(T d, Ts... e) {
if (DEBUG_OUT == false)
return;
DEBUG(d);
DEBUG(e...);
}
template <class T> void corner(bool flg, T hoge) {
if (flg) {
cout << hoge << endl;
abort();
}
}
template <typename T1, typename T2> inline bool chmax(T1 &a, T2 b) {
return a < b && (a = b, true);
}
template <typename T1, typename T2> inline bool chmin(T1 &a, T2 b) {
return a > b && (a = b, true);
}
// BELOW
struct mint {
int x; // typedef long long int;
mint(int x = 0) : x((x % MOD + MOD) % MOD) {}
mint &operator+=(const mint a) {
if ((x += a.x) >= MOD)
x -= MOD;
return *this;
}
mint &operator-=(const mint a) {
if ((x += MOD - a.x) >= MOD)
x -= MOD;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= MOD;
return *this;
}
mint operator+(const mint a) const {
mint res(*this);
return res += a;
}
mint operator-(const mint a) const {
mint res(*this);
return res -= a;
}
mint operator*(const mint a) const {
mint res(*this);
return res *= a;
}
mint pow(int t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
// for prime MOD
mint inv() const { return pow(MOD - 2); }
mint &operator/=(const mint a) { return (*this) *= a.inv(); }
mint operator/(const mint a) const {
mint res(*this);
return res /= a;
}
};
const int MAX = 510000;
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;
}
}
int COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
int PERM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[n - k] % MOD) % MOD;
}
int MCOM(int n, int k) {
// n個のものから重複を許してr個選ぶ。
// Choose R from N types of things, allowing for duplication.
return COM(n + k - 1, k);
}
// solve
//-----CODE------//
// BELOW
void solve(void) {
int n, m, k;
cin >> n >> m >> k;
mint res = 0;
COMinit();
for (int i = 1; i < n; i++) {
mint x = (n - i);
x *= m;
x *= m;
x *= COM(n * m - 2, k - 2);
res += x;
}
for (int i = 1; i < m; i++) {
mint x = (m - i);
x *= n;
x *= n;
x *= COM(n * m - 2, k - 2);
res += x;
}
cout << res.x << endl;
return;
}
int32_t main(int32_t argc, const char *argv[]) {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
std::cout << std::fixed;
std::cout << std::setprecision(11);
solve();
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define int ll
#define ll long long
#define I32_MAX 2147483647
#define I64_MAX 9223372036854775807LL
#define I64_MAX2 1223372036854775807LL
#define INF I64_MAX2
#define MOD 1000000007
// #define MOD 998244353
#define MEM_SIZE 101010
#define DEBUG_OUT true
#define ALL(x) (x).begin(), (x).end()
template <typename T> void DEBUG(T e) {
if (DEBUG_OUT == false)
return;
std::cout << e << " ";
}
template <typename T> void DEBUG(const std::vector<T> &v) {
if (DEBUG_OUT == false)
return;
for (const auto &e : v) {
std::cout << e << " ";
}
std::cout << std::endl;
}
template <typename T> void DEBUG(const std::vector<std::vector<T>> &vv) {
if (DEBUG_OUT == false)
return;
for (const auto &v : vv) {
DEBUG(v);
}
}
template <class T, class... Ts> void DEBUG(T d, Ts... e) {
if (DEBUG_OUT == false)
return;
DEBUG(d);
DEBUG(e...);
}
template <class T> void corner(bool flg, T hoge) {
if (flg) {
cout << hoge << endl;
abort();
}
}
template <typename T1, typename T2> inline bool chmax(T1 &a, T2 b) {
return a < b && (a = b, true);
}
template <typename T1, typename T2> inline bool chmin(T1 &a, T2 b) {
return a > b && (a = b, true);
}
// BELOW
struct mint {
int x; // typedef long long int;
mint(int x = 0) : x((x % MOD + MOD) % MOD) {}
mint &operator+=(const mint a) {
if ((x += a.x) >= MOD)
x -= MOD;
return *this;
}
mint &operator-=(const mint a) {
if ((x += MOD - a.x) >= MOD)
x -= MOD;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= MOD;
return *this;
}
mint operator+(const mint a) const {
mint res(*this);
return res += a;
}
mint operator-(const mint a) const {
mint res(*this);
return res -= a;
}
mint operator*(const mint a) const {
mint res(*this);
return res *= a;
}
mint pow(int t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
// for prime MOD
mint inv() const { return pow(MOD - 2); }
mint &operator/=(const mint a) { return (*this) *= a.inv(); }
mint operator/(const mint a) const {
mint res(*this);
return res /= a;
}
};
const int MAX = 510000;
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;
}
}
int COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
int PERM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[n - k] % MOD) % MOD;
}
int MCOM(int n, int k) {
// n個のものから重複を許してr個選ぶ。
// Choose R from N types of things, allowing for duplication.
return COM(n + k - 1, k);
}
// solve
//-----CODE------//
// BELOW
void solve(void) {
int n, m, k;
cin >> n >> m >> k;
mint res = 0;
COMinit();
for (int i = 1; i < n; i++) {
mint x = (n - i);
x *= m;
x *= m;
x *= COM(n * m - 2, k - 2);
res += x * i;
}
for (int i = 1; i < m; i++) {
mint x = (m - i);
x *= n;
x *= n;
x *= COM(n * m - 2, k - 2);
res += x * i;
}
cout << res.x << endl;
return;
}
int32_t main(int32_t argc, const char *argv[]) {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
std::cout << std::fixed;
std::cout << std::setprecision(11);
solve();
return 0;
}
| [
"assignment.change"
] | 854,179 | 854,180 | u221285045 | cpp |
p03039 | //インクルード(アルファベット順)
#include <algorithm> //sort,二分探索,など
#include <bitset> //固定長bit集合
#include <cmath> //pow,logなど
#include <complex> //複素数
#include <deque> //両端アクセスのキュー
#include <functional> //sortのgreater
#include <iomanip> //setprecision(浮動小数点の出力の誤差)
#include <iostream> //入出力
#include <iterator> //集合演算(積集合,和集合,差集合など)
#include <map> //map(辞書)
#include <numeric> //iota(整数列の生成),gcdとlcm(c++17)
#include <queue> //キュー
#include <set> //集合
#include <stack> //スタック
#include <string> //文字列
#include <unordered_map> //イテレータあるけど順序保持しないmap
#include <unordered_set> //イテレータあるけど順序保持しないset
#include <utility> //pair
#include <vector> //可変長配列
using namespace std;
typedef long long ll;
//マクロ
// forループ関係
//引数は、(ループ内変数,動く範囲)か(ループ内変数,始めの数,終わりの数)、のどちらか
// Dがついてないものはループ変数は1ずつインクリメントされ、Dがついてるものはループ変数は1ずつデクリメントされる
#define REP(i, n) for (ll i = 0; i < (ll)(n); i++)
#define REPD(i, n) for (ll i = n - 1; i >= 0; i--)
#define FOR(i, a, b) for (ll i = a; i <= (ll)(b); i++)
#define FORD(i, a, b) for (ll i = a; i >= (ll)(b); i--)
// xにはvectorなどのコンテナ
#define ALL(x) (x).begin(), (x).end() // sortなどの引数を省略したい
#define SIZE(x) ((ll)(x).size()) // sizeをsize_tからllに直しておく
#define MAX(x) *max_element(ALL(x)) //最大値を求める
#define MIN(x) *min_element(ALL(x)) //最小値を求める
//定数
#define INF 1000000000000 // 10^12:極めて大きい値,∞
#define MOD 1000000007 // 10^9+7:合同式の法
#define MAXR 300000 // 10^5:配列の最大のrange(素数列挙などで使用)
//略記
#define PB push_back // vectorヘの挿入
#define MP make_pair // pairのコンストラクタ
#define F first // pairの一つ目の要素
#define S second // pairの二つ目の要素
template <ll mod> class modint {
public:
ll val = 0;
//コンストラクタ
modint(ll x = 0) : val(x % mod) {
while (x < 0)
x += mod;
}
//コピーコンストラクタ
modint(const modint &r) : val(r.val) {}
//算術演算子
modint operator-() { return modint(-val); } //単項
modint operator+(const modint &r) { return modint(*this) += r; }
modint operator-(const modint &r) { return modint(*this) -= r; }
modint operator*(const modint &r) { return modint(*this) *= r; }
modint operator/(const modint &r) { return modint(*this) /= r; }
//代入演算子
modint &operator+=(const modint &r) {
val += r.val;
if (val >= mod)
val -= mod;
return *this;
}
modint &operator-=(const modint &r) {
if (val < r.val)
val += mod;
val -= r.val;
return *this;
}
modint &operator*=(const modint &r) {
val = val * r.val % mod;
return *this;
}
modint &operator/=(const modint &r) {
ll a = r.val, b = mod, u = 1, v = 0;
while (b) {
ll t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
val = val * u % mod;
if (val < 0)
val += mod;
return *this;
}
//等価比較演算子
bool operator==(const modint &r) { return this->val == r.val; }
bool operator<(const modint &r) { return this->val < r.val; }
bool operator!=(const modint &r) { return this->val != r.val; }
};
using mint = modint<MOD>;
//入出力ストリーム
istream &operator>>(istream &is, mint &x) { // xにconst付けない
ll t;
is >> t;
x = t;
return (is);
}
ostream &operator<<(ostream &os, const mint &x) { return os << x.val; }
//累乗
mint modpow(const mint &a, ll n) {
if (n == 0)
return 1;
mint t = modpow(a, n / 2);
t = t * t;
if (n & 1)
t = t * a;
return t;
}
mint fac[MAXR + 1], finv[MAXR + 1], inv[MAXR + 1];
//テーブルの作成
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
FOR(i, 2, MAXR) {
fac[i] = fac[i - 1] * mint(i);
inv[i] = -inv[MOD % i] * mint(MOD / i);
finv[i] = finv[i - 1] * inv[i];
}
}
// 二項係数の計算
mint COM(ll n, ll k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * finv[k] * finv[n - k];
}
signed main() {
//入力の高速化用のコード
// ios::sync_with_stdio(false);
// cin.tie(nullptr);
COMinit();
ll n, m, k;
cin >> n >> m >> k;
mint ans1 = COM(n * m - 2, k - 2);
// cout << COM(k,2) << COM(n*m,k) << COM(n,2) << endl;
mint ans1_ = 0;
FOR(i, 1, n - 1) ans1_ += (i * m * m * (n - i));
// cout << ans1_ << endl;
ans1 *= ans1_;
mint ans2 = COM(n * m - 2, k - 2);
// cout << ans2 << endl;
mint ans2_ = 0;
FOR(i, 1, m - 1) ans2_ += (i * n * n * (m - i));
// cout << ans2_ << endl;
ans2 *= ans2_;
cout << ans1 + ans2 << endl;
} | //インクルード(アルファベット順)
#include <algorithm> //sort,二分探索,など
#include <bitset> //固定長bit集合
#include <cmath> //pow,logなど
#include <complex> //複素数
#include <deque> //両端アクセスのキュー
#include <functional> //sortのgreater
#include <iomanip> //setprecision(浮動小数点の出力の誤差)
#include <iostream> //入出力
#include <iterator> //集合演算(積集合,和集合,差集合など)
#include <map> //map(辞書)
#include <numeric> //iota(整数列の生成),gcdとlcm(c++17)
#include <queue> //キュー
#include <set> //集合
#include <stack> //スタック
#include <string> //文字列
#include <unordered_map> //イテレータあるけど順序保持しないmap
#include <unordered_set> //イテレータあるけど順序保持しないset
#include <utility> //pair
#include <vector> //可変長配列
using namespace std;
typedef long long ll;
//マクロ
// forループ関係
//引数は、(ループ内変数,動く範囲)か(ループ内変数,始めの数,終わりの数)、のどちらか
// Dがついてないものはループ変数は1ずつインクリメントされ、Dがついてるものはループ変数は1ずつデクリメントされる
#define REP(i, n) for (ll i = 0; i < (ll)(n); i++)
#define REPD(i, n) for (ll i = n - 1; i >= 0; i--)
#define FOR(i, a, b) for (ll i = a; i <= (ll)(b); i++)
#define FORD(i, a, b) for (ll i = a; i >= (ll)(b); i--)
// xにはvectorなどのコンテナ
#define ALL(x) (x).begin(), (x).end() // sortなどの引数を省略したい
#define SIZE(x) ((ll)(x).size()) // sizeをsize_tからllに直しておく
#define MAX(x) *max_element(ALL(x)) //最大値を求める
#define MIN(x) *min_element(ALL(x)) //最小値を求める
//定数
#define INF 1000000000000 // 10^12:極めて大きい値,∞
#define MOD 1000000007 // 10^9+7:合同式の法
#define MAXR 300000 // 10^5:配列の最大のrange(素数列挙などで使用)
//略記
#define PB push_back // vectorヘの挿入
#define MP make_pair // pairのコンストラクタ
#define F first // pairの一つ目の要素
#define S second // pairの二つ目の要素
template <ll mod> class modint {
public:
ll val = 0;
//コンストラクタ
modint(ll x = 0) : val(x % mod) {
while (x < 0)
x += mod;
}
//コピーコンストラクタ
modint(const modint &r) : val(r.val) {}
//算術演算子
modint operator-() { return modint(-val); } //単項
modint operator+(const modint &r) { return modint(*this) += r; }
modint operator-(const modint &r) { return modint(*this) -= r; }
modint operator*(const modint &r) { return modint(*this) *= r; }
modint operator/(const modint &r) { return modint(*this) /= r; }
//代入演算子
modint &operator+=(const modint &r) {
val += r.val;
if (val >= mod)
val -= mod;
return *this;
}
modint &operator-=(const modint &r) {
if (val < r.val)
val += mod;
val -= r.val;
return *this;
}
modint &operator*=(const modint &r) {
val = val * r.val % mod;
return *this;
}
modint &operator/=(const modint &r) {
ll a = r.val, b = mod, u = 1, v = 0;
while (b) {
ll t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
val = val * u % mod;
if (val < 0)
val += mod;
return *this;
}
//等価比較演算子
bool operator==(const modint &r) { return this->val == r.val; }
bool operator<(const modint &r) { return this->val < r.val; }
bool operator!=(const modint &r) { return this->val != r.val; }
};
using mint = modint<MOD>;
//入出力ストリーム
istream &operator>>(istream &is, mint &x) { // xにconst付けない
ll t;
is >> t;
x = t;
return (is);
}
ostream &operator<<(ostream &os, const mint &x) { return os << x.val; }
//累乗
mint modpow(const mint &a, ll n) {
if (n == 0)
return 1;
mint t = modpow(a, n / 2);
t = t * t;
if (n & 1)
t = t * a;
return t;
}
mint fac[MAXR + 1], finv[MAXR + 1], inv[MAXR + 1];
//テーブルの作成
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
FOR(i, 2, MAXR) {
fac[i] = fac[i - 1] * mint(i);
inv[i] = mint(MOD) - inv[MOD % i] * mint(MOD / i);
finv[i] = finv[i - 1] * inv[i];
}
}
// 二項係数の計算
mint COM(ll n, ll k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * finv[k] * finv[n - k];
}
signed main() {
//入力の高速化用のコード
// ios::sync_with_stdio(false);
// cin.tie(nullptr);
COMinit();
ll n, m, k;
cin >> n >> m >> k;
mint ans1 = COM(n * m - 2, k - 2);
// cout << COM(k,2) << COM(n*m,k) << COM(n,2) << endl;
mint ans1_ = 0;
FOR(i, 1, n - 1) ans1_ += (i * m * m * (n - i));
// cout << ans1_ << endl;
ans1 *= ans1_;
mint ans2 = COM(n * m - 2, k - 2);
// cout << ans2 << endl;
mint ans2_ = 0;
FOR(i, 1, m - 1) ans2_ += (i * n * n * (m - i));
// cout << ans2_ << endl;
ans2 *= ans2_;
cout << ans1 + ans2 << endl;
} | [
"call.add"
] | 854,207 | 854,208 | u989345508 | cpp |
p03039 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define int ll
#define REP(i, n) for (int i = 0; i < n; ++i)
#define SORT(name) sort(name.begin(), name.end())
#define ZERO(p) memset(p, 0, sizeof(p))
#define MINUS(p) memset(p, -1, sizeof(p))
#if 0
#define DBG(fmt, ...) printf(fmt, ##__VA_ARGS__)
#else
#define DBG(fmt, ...)
#endif
const ll LLINF = (1LL << 60);
const int INF = (1LL << 30);
const double DINF = std::numeric_limits<double>::infinity();
const int MOD = 1000000007;
#define MAX_N 200010
class NumberOfCase {
public:
// 初期化 O(n log m) m は素数
// n : 求めたい組み合わせの最大値, m : 剰余(素数)
NumberOfCase(ll n, ll m) : m_Size(n), m_Mod(m) {
m_Fact.resize(m_Size + 1);
m_FInv.resize(m_Size + 1);
m_Inv.resize(m_Size + 1);
// 0! ～ m_Size! までの階乗を保管する配列の作成 (mod m_Mod をとってある)
m_Fact[0] = 1;
for (int i = 1; i <= m_Size; ++i) {
m_Fact[i] = (m_Fact[i - 1] * i) % m_Mod;
}
// m_Size! の逆元 1/m_Size! を二分累乗法で求める
// フェルマーの小定理より a^-1 = a^(p-2) mod p -> (m_Size!)^-1 =
// (m_Size!)^(p-2) mod p
m_FInv[m_Size] = ModPow(m_Fact[m_Size], m_Mod - 2, m_Mod);
// 以下 1 / (N-1)! = N / N! であることを利用
for (int i = m_Size - 1; i >= 0; --i) {
m_FInv[i] = (m_FInv[i + 1] * (i + 1)) % m_Mod;
}
// 逆元の作成（割り算のとき利用）
m_Inv[1] = 1;
for (int i = 2; i <= m_Size; ++i) {
m_Inv[i] = m_Inv[m_Mod % i] * (m_Mod - m_Mod / i) % m_Mod;
}
}
// 階乗 n! の取得 O(1)
ll Factorial(ll n) { return m_Fact[n]; }
// n! の逆元の取得 O(1)
ll FInverse(ll n) { return m_FInv[n]; }
// 逆元の取得 O(1)
ll Inverse(ll n) { return m_Inv[n]; }
// 剰余を考慮した割り算 n / m の結果を返す
ll Div(ll n, ll m) { return (n * m_Inv[m]) % m_Mod; }
// 順列 nPr の取得 O(1)
ll Permutation(ll n, ll r) { return (m_Fact[n] * m_FInv[n - r]) % m_Mod; }
// 組み合わせ nCr の取得 O(1)
ll Combination(ll n, ll r) {
ll ret = (m_Fact[n] * m_FInv[n - r]) % m_Mod;
ret = (ret * m_FInv[r]) % m_Mod;
return ret;
}
// 重複組み合わせ nHr の取得 O(1)
ll Homogen(ll n, ll r) { return Combination(r + n - 1, r); }
private:
// x の n 乗 を m で余りをとったもの O(log n)
ll ModPow(ll x, ll n, ll mod) {
ll res = 1;
while (n > 0) {
if (n & 1) {
res = res * x % mod;
} // 最下位ビットが立っているときに x^(2^i) を掛ける
x = x * x % mod; // x を順次 2 乗していく
n >>= 1;
}
return res;
}
private:
const ll m_Size; // 導出する範囲 (10^5 くらいまでにして欲しい)
const ll m_Mod; // 剰余
vector<ll> m_Fact; // 階乗
vector<ll> m_FInv; // 階乗の逆元
vector<ll> m_Inv; // 逆元
};
ll N, M, K;
signed main() {
cin >> N >> M >> K;
NumberOfCase noc(MAX_N, MOD);
ll ans = 0;
// X 軸方向の距離を考える
for (ll dx = 1; dx < M; ++dx) {
// X の差が dx になる2点を選ぶパターン
// (M - dx) * N^2
ll cur = (M - dx);
cur *= N;
cur %= MOD;
cur *= N;
cur %= MOD;
// このパターン数分だけ、距離 dx が出現する
cur *= dx;
cur %= MOD;
// この 2 点以外の点の選択パターンは NM-2 C K-2
cur *= noc.Combination(N * M - 2, K - 2);
cur %= MOD;
// これで X 方向で距離 dx になる全パターン分の和が出るので
// 答えに加える
ans += cur;
ans %= MOD;
}
// 同様に Y 軸方向の距離を考える
for (ll dy = 1; dy < M; ++dy) {
ll cur = (N - dy);
cur *= M;
cur %= MOD;
cur *= M;
cur %= MOD;
cur *= dy;
cur %= MOD;
cur *= noc.Combination(N * M - 2, K - 2);
cur %= MOD;
ans += cur;
ans %= MOD;
}
printf("%lld\n", ans);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define int ll
#define REP(i, n) for (int i = 0; i < n; ++i)
#define SORT(name) sort(name.begin(), name.end())
#define ZERO(p) memset(p, 0, sizeof(p))
#define MINUS(p) memset(p, -1, sizeof(p))
#if 0
#define DBG(fmt, ...) printf(fmt, ##__VA_ARGS__)
#else
#define DBG(fmt, ...)
#endif
const ll LLINF = (1LL << 60);
const int INF = (1LL << 30);
const double DINF = std::numeric_limits<double>::infinity();
const int MOD = 1000000007;
#define MAX_N 200010
class NumberOfCase {
public:
// 初期化 O(n log m) m は素数
// n : 求めたい組み合わせの最大値, m : 剰余(素数)
NumberOfCase(ll n, ll m) : m_Size(n), m_Mod(m) {
m_Fact.resize(m_Size + 1);
m_FInv.resize(m_Size + 1);
m_Inv.resize(m_Size + 1);
// 0! ～ m_Size! までの階乗を保管する配列の作成 (mod m_Mod をとってある)
m_Fact[0] = 1;
for (int i = 1; i <= m_Size; ++i) {
m_Fact[i] = (m_Fact[i - 1] * i) % m_Mod;
}
// m_Size! の逆元 1/m_Size! を二分累乗法で求める
// フェルマーの小定理より a^-1 = a^(p-2) mod p -> (m_Size!)^-1 =
// (m_Size!)^(p-2) mod p
m_FInv[m_Size] = ModPow(m_Fact[m_Size], m_Mod - 2, m_Mod);
// 以下 1 / (N-1)! = N / N! であることを利用
for (int i = m_Size - 1; i >= 0; --i) {
m_FInv[i] = (m_FInv[i + 1] * (i + 1)) % m_Mod;
}
// 逆元の作成（割り算のとき利用）
m_Inv[1] = 1;
for (int i = 2; i <= m_Size; ++i) {
m_Inv[i] = m_Inv[m_Mod % i] * (m_Mod - m_Mod / i) % m_Mod;
}
}
// 階乗 n! の取得 O(1)
ll Factorial(ll n) { return m_Fact[n]; }
// n! の逆元の取得 O(1)
ll FInverse(ll n) { return m_FInv[n]; }
// 逆元の取得 O(1)
ll Inverse(ll n) { return m_Inv[n]; }
// 剰余を考慮した割り算 n / m の結果を返す
ll Div(ll n, ll m) { return (n * m_Inv[m]) % m_Mod; }
// 順列 nPr の取得 O(1)
ll Permutation(ll n, ll r) { return (m_Fact[n] * m_FInv[n - r]) % m_Mod; }
// 組み合わせ nCr の取得 O(1)
ll Combination(ll n, ll r) {
ll ret = (m_Fact[n] * m_FInv[n - r]) % m_Mod;
ret = (ret * m_FInv[r]) % m_Mod;
return ret;
}
// 重複組み合わせ nHr の取得 O(1)
ll Homogen(ll n, ll r) { return Combination(r + n - 1, r); }
private:
// x の n 乗 を m で余りをとったもの O(log n)
ll ModPow(ll x, ll n, ll mod) {
ll res = 1;
while (n > 0) {
if (n & 1) {
res = res * x % mod;
} // 最下位ビットが立っているときに x^(2^i) を掛ける
x = x * x % mod; // x を順次 2 乗していく
n >>= 1;
}
return res;
}
private:
const ll m_Size; // 導出する範囲 (10^5 くらいまでにして欲しい)
const ll m_Mod; // 剰余
vector<ll> m_Fact; // 階乗
vector<ll> m_FInv; // 階乗の逆元
vector<ll> m_Inv; // 逆元
};
ll N, M, K;
signed main() {
cin >> N >> M >> K;
NumberOfCase noc(MAX_N, MOD);
ll ans = 0;
// X 軸方向の距離を考える
for (ll dx = 1; dx < M; ++dx) {
// X の差が dx になる2点を選ぶパターン
// (M - dx) * N^2
ll cur = (M - dx);
cur *= N;
cur %= MOD;
cur *= N;
cur %= MOD;
// このパターン数分だけ、距離 dx が出現する
cur *= dx;
cur %= MOD;
// この 2 点以外の点の選択パターンは NM-2 C K-2
cur *= noc.Combination(N * M - 2, K - 2);
cur %= MOD;
// これで X 方向で距離 dx になる全パターン分の和が出るので
// 答えに加える
ans += cur;
ans %= MOD;
}
// 同様に Y 軸方向の距離を考える
for (ll dy = 1; dy < N; ++dy) {
ll cur = (N - dy);
cur *= M;
cur %= MOD;
cur *= M;
cur %= MOD;
cur *= dy;
cur %= MOD;
cur *= noc.Combination(N * M - 2, K - 2);
cur %= MOD;
ans += cur;
ans %= MOD;
}
printf("%lld\n", ans);
return 0;
}
| [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 854,209 | 854,210 | u633020228 | cpp |
p03039 | #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] = n - 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;
} | #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;
} | [
"assignment.value.change",
"identifier.change",
"expression.operation.binary.change"
] | 854,223 | 854,224 | u102602414 | cpp |
p03039 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define fr(i, n) for (int i = 0; i < n; i++)
#define ifr(i, n) for (int i = n - 1; i >= 0; i--)
const int MAX = 510000;
const int MOD = 1000000007;
long long fac[MAX], finv[MAX], inv[MAX];
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
int main() {
int n, m, k;
int a = 1000000007;
ll ans = 0;
ll kai = 0;
cin >> n >> m >> k;
fr(i, n) {
kai += i * (n - i) * m * m;
kai %= a;
}
kai *= COM(n * m - 2, k - 2) % a;
ans += kai;
kai = 0;
fr(i, m) {
kai += i * (m - i) * n * n;
kai %= a;
}
kai *= COM(n * m - 2, k - 2) % a;
ans += kai;
ans %= a;
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define fr(i, n) for (int i = 0; i < n; i++)
#define ifr(i, n) for (int i = n - 1; i >= 0; i--)
const int MAX = 510000;
const int MOD = 1000000007;
long long fac[MAX], finv[MAX], inv[MAX];
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
int main() {
COMinit();
ll n, m, k;
ll a = 1000000007;
ll ans = 0;
ll kai = 0;
cin >> n >> m >> k;
fr(i, n) {
kai += i * (n - i) * m * m;
kai %= a;
}
kai *= COM(n * m - 2, k - 2) % a;
ans += kai;
kai = 0;
fr(i, m) {
kai += i * (m - i) * n * n;
kai %= a;
}
kai *= COM(n * m - 2, k - 2) % a;
ans += kai;
ans %= a;
cout << ans << endl;
}
| [
"call.add",
"variable_declaration.type.change"
] | 854,231 | 854,230 | u806159048 | cpp |
p03039 | /*
██████ ██████
██ ██ ██ ██
Author -> ██████ ██ ██
██ ██ ██
██ ██████
nik is love.
nik is motivation.
Ek modulus aapki jindagi barbaad kar sakti hai
Watch for integer overflows.
A dream doesn't become reality through magic; it takes sweat, determination
and hard work" — Colin Powell
*/
#include <bits/stdc++.h>
//#include <ext/pb_ds/assoc_container.hpp>
//#include <ext/pb_ds/tree_policy.hpp>
//#include <functional>
#define pb push_back
#define ll long long
#define ss second
#define ff first
#define rep(i, begin, end) \
for (__typeof(end) i = (begin) - ((begin) > (end)); \
i != (end) - ((begin) > (end)); i += 1 - 2 * ((begin) > (end)))
#define eps 0.000000001
#define sz(a) int((a).size())
#define all(c) (c).begin(), (c).end()
#define present(c, x) ((c).find(x) != (c).end())
#define cpresent(c, x) (find(all(c), x) != (c).end())
#define pi pair<int, int>
#define pll pair<ll, ll>
#define endl '\n'
using namespace std;
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);
}
template <typename T, typename... Args> inline string arrStr(T arr, int n) {
stringstream s;
s << "[";
for (int i = 0; i < n - 1; i++)
s << arr[i] << ",";
s << arr[n - 1] << "]";
return s.str();
}
#define debug(args...) \
{ \
__evars_begin(__LINE__); \
__evars(split(#args, ',').begin(), args); \
}
inline void __evars_begin(int line) { cerr << "#" << line << ": "; }
template <typename T> inline void __evars_out_var(vector<T> val) {
cerr << arrStr(val, val.size());
}
template <typename T> inline void __evars_out_var(T *val) {
cerr << arrStr(val, 10);
}
template <typename T> inline void __evars_out_var(T val) { cerr << val; }
inline void __evars(vector<string>::iterator it) { cerr << endl; }
template <typename T, typename... Args>
inline void __evars(vector<string>::iterator it, T a, Args... args) {
cerr << it->substr((*it)[0] == ' ', it->length()) << "=";
__evars_out_var(a);
cerr << "; ";
__evars(++it, args...);
}
// using namespace __gnu_pbds;
// typedef tree<pair<int,int>, null_type, less<pair<int,int>>,
// rb_tree_tag,tree_order_statistics_node_update> special_map;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
typedef vector<int> vi;
typedef vector<vi> vvi;
int dx[8] = {1, -1, 0, 0, -1, -1, 1, 1};
int dy[8] = {0, 0, -1, 1, -1, 1, -1, 1};
const ll inf = 1000000007;
vector<int> vis(500010, 0), dis(500010, 0), dis1(500010, -1), par(500010, 0),
col(500010, 0);
vector<pair<int, int>> adj[500010];
int myrandom(int i) { return std::rand() % i; }
const int MAX = 200100;
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
// ifstream fin;
// ofstream fout;
// fin.open("input.txt");
// fout.open("output.txt");
// clock_t launch=clock();
ll n, m, k;
cin >> n >> m >> k;
ll fct[MAX], inv[MAX], in[MAX];
fct[0] = 1;
inv[0] = 1;
fct[1] = 1;
inv[1] = 1;
in[1] = 1;
for (int i = 2; i <= 200000; i++) {
fct[i] = (fct[i - 1] * i) % inf;
in[i] = (inf - ((inf / i) * in[inf % i]) % inf) % inf;
inv[i] = (inv[i - 1] * in[i]) % inf;
}
ll tot = 0;
for (ll i = 1; i <= n; i++) {
for (ll j = 1; j <= m; j++) {
ll x1 = ((m - j) * (m - j + 1)) / 2, x2 = ((j - 1) * j) / 2;
ll y1 = ((n - i) * (n - i + 1)) / 2, y2 = ((i - 1) * i) / 2;
tot += (((x1 + x2) * n) % inf + ((y1 + y2) * m) % inf) % inf;
}
}
tot *= fct[n * m - 2];
tot %= inf;
tot *= inv[k - 2];
tot %= inf;
tot *= inv[n * m - k];
tot %= inf;
tot *= in[2];
tot %= inf;
cout << tot << endl;
// clog<<((long double)(clock()-launch)/CLOCKS_PER_SEC)<<"\n";
}
| /*
██████ ██████
██ ██ ██ ██
Author -> ██████ ██ ██
██ ██ ██
██ ██████
nik is love.
nik is motivation.
Ek modulus aapki jindagi barbaad kar sakti hai
Watch for integer overflows.
A dream doesn't become reality through magic; it takes sweat, determination
and hard work" — Colin Powell
*/
#include <bits/stdc++.h>
//#include <ext/pb_ds/assoc_container.hpp>
//#include <ext/pb_ds/tree_policy.hpp>
//#include <functional>
#define pb push_back
#define ll long long
#define ss second
#define ff first
#define rep(i, begin, end) \
for (__typeof(end) i = (begin) - ((begin) > (end)); \
i != (end) - ((begin) > (end)); i += 1 - 2 * ((begin) > (end)))
#define eps 0.000000001
#define sz(a) int((a).size())
#define all(c) (c).begin(), (c).end()
#define present(c, x) ((c).find(x) != (c).end())
#define cpresent(c, x) (find(all(c), x) != (c).end())
#define pi pair<int, int>
#define pll pair<ll, ll>
#define endl '\n'
using namespace std;
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);
}
template <typename T, typename... Args> inline string arrStr(T arr, int n) {
stringstream s;
s << "[";
for (int i = 0; i < n - 1; i++)
s << arr[i] << ",";
s << arr[n - 1] << "]";
return s.str();
}
#define debug(args...) \
{ \
__evars_begin(__LINE__); \
__evars(split(#args, ',').begin(), args); \
}
inline void __evars_begin(int line) { cerr << "#" << line << ": "; }
template <typename T> inline void __evars_out_var(vector<T> val) {
cerr << arrStr(val, val.size());
}
template <typename T> inline void __evars_out_var(T *val) {
cerr << arrStr(val, 10);
}
template <typename T> inline void __evars_out_var(T val) { cerr << val; }
inline void __evars(vector<string>::iterator it) { cerr << endl; }
template <typename T, typename... Args>
inline void __evars(vector<string>::iterator it, T a, Args... args) {
cerr << it->substr((*it)[0] == ' ', it->length()) << "=";
__evars_out_var(a);
cerr << "; ";
__evars(++it, args...);
}
// using namespace __gnu_pbds;
// typedef tree<pair<int,int>, null_type, less<pair<int,int>>,
// rb_tree_tag,tree_order_statistics_node_update> special_map;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
typedef vector<int> vi;
typedef vector<vi> vvi;
int dx[8] = {1, -1, 0, 0, -1, -1, 1, 1};
int dy[8] = {0, 0, -1, 1, -1, 1, -1, 1};
const ll inf = 1000000007;
vector<int> vis(500010, 0), dis(500010, 0), dis1(500010, -1), par(500010, 0),
col(500010, 0);
vector<pair<int, int>> adj[500010];
int myrandom(int i) { return std::rand() % i; }
const int MAX = 200100;
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
// ifstream fin;
// ofstream fout;
// fin.open("input.txt");
// fout.open("output.txt");
// clock_t launch=clock();
ll n, m, k;
cin >> n >> m >> k;
ll fct[MAX], inv[MAX], in[MAX];
fct[0] = 1;
inv[0] = 1;
fct[1] = 1;
inv[1] = 1;
in[1] = 1;
for (int i = 2; i <= 200000; i++) {
fct[i] = (fct[i - 1] * i) % inf;
in[i] = (inf - ((inf / i) * in[inf % i]) % inf) % inf;
inv[i] = (inv[i - 1] * in[i]) % inf;
}
ll tot = 0;
for (ll i = 1; i <= n; i++) {
for (ll j = 1; j <= m; j++) {
ll x1 = ((m - j) * (m - j + 1)) / 2, x2 = ((j - 1) * j) / 2;
ll y1 = ((n - i) * (n - i + 1)) / 2, y2 = ((i - 1) * i) / 2;
tot += (((x1 + x2) * n) % inf + ((y1 + y2) * m) % inf) % inf;
tot %= inf;
}
}
tot *= fct[n * m - 2];
tot %= inf;
tot *= inv[k - 2];
tot %= inf;
tot *= inv[n * m - k];
tot %= inf;
tot *= in[2];
tot %= inf;
cout << tot << endl;
// clog<<((long double)(clock()-launch)/CLOCKS_PER_SEC)<<"\n";
}
| [
"assignment.add"
] | 854,240 | 854,241 | u151137534 | cpp |
p03039 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
const ll INF = 1LL << 60;
const int inf = 1 << 30;
const int mod = 1e9 + 7;
const int MOD = 998244353;
const int nmax = 200005;
ll fac[nmax], finv[nmax], inv[nmax];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < nmax; i++) {
fac[i] = fac[i - 1] * i % mod;
inv[i] = mod - inv[mod % i] * (mod / i) % mod;
finv[i] = finv[i - 1] * inv[i] % mod;
}
}
ll com(int n, int k) {
if (n < k || n < 0 || k < 0) {
return 0;
}
return fac[n] * (finv[k] * finv[n - k] % mod) % mod;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll n, m, k;
cin >> n >> m >> k;
ll ans = 0;
COMinit();
for (ll i = 1; i <= n - 1; i++) {
(ans += i * m % mod * m % mod * (n - i) % mod) %= mod;
}
for (ll i = 1; i <= m - 1; i++) {
(ans += i * n % mod * n % mod * (m - i) % mod) %= mod;
}
(ans *= com(n * m - 2, k - 2));
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
const ll INF = 1LL << 60;
const int inf = 1 << 30;
const int mod = 1e9 + 7;
const int MOD = 998244353;
const int nmax = 200005;
ll fac[nmax], finv[nmax], inv[nmax];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < nmax; i++) {
fac[i] = fac[i - 1] * i % mod;
inv[i] = mod - inv[mod % i] * (mod / i) % mod;
finv[i] = finv[i - 1] * inv[i] % mod;
}
}
ll com(int n, int k) {
if (n < k || n < 0 || k < 0) {
return 0;
}
return fac[n] * (finv[k] * finv[n - k] % mod) % mod;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll n, m, k;
cin >> n >> m >> k;
ll ans = 0;
COMinit();
for (ll i = 1; i <= n - 1; i++) {
(ans += i * m % mod * m % mod * (n - i) % mod) %= mod;
}
for (ll i = 1; i <= m - 1; i++) {
(ans += i * n % mod * n % mod * (m - i) % mod) %= mod;
}
(ans *= com(n * m - 2, k - 2)) %= mod;
cout << ans << endl;
} | [
"assignment.change"
] | 854,272 | 854,273 | u244626757 | cpp |
p03039 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <vector>
typedef long long ll;
using namespace std;
const ll MOD = 1000000007LL;
const int MAX_N = 2000000;
ll inv[MAX_N], fac[MAX_N], fiv[MAX_N];
void COMinit() {
inv[1] = fac[1] = fiv[1] = inv[0] = fac[0] = fiv[0] = 1;
for (ll i = 2; i < MAX_N; i++) {
fac[i] = fac[i - 1] * i % MOD; // n!
inv[i] = inv[MOD % i] * (MOD - MOD / i) % MOD; // n^-1
fiv[i] = fiv[i - 1] * inv[i] % MOD; // (n!)^-1
}
}
ll com(ll n, ll k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * fiv[k] % MOD * fiv[n - k] % MOD;
}
int main() {
cin.sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
ll n, m, K;
cin >> n >> m >> K;
ll X = n * m;
ll tate = 0;
for (ll i = 1; i < m; i++) {
tate += i * (m - i);
tate %= MOD;
}
tate = 2 * m * m % MOD * tate % MOD;
ll yoko = 0;
for (ll i = 1; i < n; i++) {
yoko += i * (n - i);
yoko %= MOD;
}
yoko = 2 * m * m % MOD * yoko % MOD;
ll ans = (yoko + tate) % MOD;
COMinit();
ans = ans * com(X - 2, K - 2) % MOD;
if (ans % 2 == 0)
ans /= 2;
else
ans = (ans + MOD) / 2;
cout << ans << "\n";
return 0;
} | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <vector>
typedef long long ll;
using namespace std;
const ll MOD = 1000000007LL;
const int MAX_N = 400000;
ll inv[MAX_N], fac[MAX_N], fiv[MAX_N];
void COMinit() {
inv[1] = fac[1] = fiv[1] = inv[0] = fac[0] = fiv[0] = 1;
for (ll i = 2; i < MAX_N; i++) {
fac[i] = fac[i - 1] * i % MOD; // n!
inv[i] = inv[MOD % i] * (MOD - MOD / i) % MOD; // n^-1
fiv[i] = fiv[i - 1] * inv[i] % MOD; // (n!)^-1
}
}
ll com(ll n, ll k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * fiv[k] % MOD * fiv[n - k] % MOD;
}
int main() {
cin.sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
ll n, m, K;
cin >> n >> m >> K;
ll X = n * m;
ll tate = 0;
for (ll i = 1; i < m; i++) {
tate += i * (m - i);
tate %= MOD;
}
tate = 2 * n * n % MOD * tate % MOD;
ll yoko = 0;
for (ll i = 1; i < n; i++) {
yoko += i * (n - i);
yoko %= MOD;
}
yoko = 2 * m * m % MOD * yoko % MOD;
ll ans = (yoko + tate) % MOD;
COMinit();
ans = ans * com(X - 2, K - 2) % MOD;
if (ans % 2 == 0)
ans /= 2;
else
ans = (ans + MOD) / 2;
cout << ans << "\n";
return 0;
} | [
"literal.number.change",
"variable_declaration.value.change",
"assignment.value.change",
"identifier.change",
"expression.operation.binary.change"
] | 854,278 | 854,279 | u334624175 | cpp |
p03039 | // BUGSBUNNY
// IIT ROORKEE
// _,add8ba,
// ,d888888888b,
// d8888888888888b _,ad8ba,_
// d888888888888888) ,d888888888b,
// I8888888888888888 _________ ,8888888888888b
// __________`Y88888888888888P"""""""""""baaa,__
// ,888888888888888,
// ,adP"""""""""""9888888888P""^ ^""Y8888888888888888I
// ,a8"^ ,d888P"888P^ ^"Y8888888888P'
// ,a8^ ,d8888' ^Y8888888P'
// a88' ,d8888P' I88P"^
// ,d88' d88888P' "b,
// ,d88' d888888' `b,
// ,d88' d888888I `b,
// d88I ,8888888' ___ `b,
// ,888' d8888888 ,d88888b, ____ `b,
// d888 ,8888888I d88888888b, ,d8888b, `b
// ,8888 I8888888I d8888888888I ,88888888b 8, I8888
// 88888888b d88888888888' 8888888888b 8I d8886
// 888888888 Y888888888P' Y8888888888, ,8b 88888b
// I88888888b `Y8888888^ `Y888888888I d88, Y88888b
// `888888888b, `""""^ `Y8888888P' d888I `888888b
// 88888888888b, `Y8888P^ d88888
// Y888888b ,8888888888888ba,_ _______ `""^ ,d888888
// I8888888b, ,888888888888888888ba,_ d88888888b ,ad8888888I
// `888888888b, I8888888888888888888888b, ^"Y888P"^ ____.,ad88888888888I
// 88888888888b,`888888888888888888888888b, "" ad888888888888888888888'
// 8888888888888698888888888888888888888888b_,ad88ba,_,d88888888888888888888888
// 88888888888888888888888888888888888888888b,`"""^
// d8888888888888888888888888I
// 8888888888888888888888888888888888888888888baaad888888888888888888888888888'
// Y8888888888888888888888888888888888888888888888888888888888888888888888888P
// I888888888888888888888888888888888888888888888P^ ^Y8888888888888888888888'
// `Y88888888888888888P88888888888888888888888888' ^88888888888888888888I
// `Y8888888888888888 `8888888888888888888888888 8888888888888888888P'
// `Y888888888888888 `888888888888888888888888, ,888888888888888888P'
// `Y88888888888888b `88888888888888888888888I I888888888888888888'
// "Y8888888888888b `8888888888888888888888I I88888888888888888'
// "Y88888888888P `888888888888888888888b d8888888888888888'
// ^""""""""^ `Y88888888888888888888, 888888888888888P'
// "8888888888888888888b, Y888888888888P^
// `Y888888888888888888b `Y8888888P"^
// "Y8888888888888888P `""""^
// `"YY88888888888P'
// ^""""""""'
#include <bits/stdc++.h>
using namespace std;
#define fast \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define int long long
#define ll long long
#define ld long double
#define endl '\n'
#define vi vector<int>
#define vvi vector<vi>
#define vs vector<string>
#define vl vector<long long>
#define vpii vector<pii>
#define vpipii vector<pipii>
#define vb vector<bool>
#define pb push_back
#define pob pop_back
#define gcd __gcd
#define mp make_pair
#define pii pair<int, int>
#define pipii pair<int, pii>
#define pll pair<long long, long long>
#define pld pair<long double, long double>
#define mod 1000000007
#define mod2 998244353
#define rep(i, n) for (ll i = 0; i < n; i++)
#define repp(i, a, b) for (ll i = a; i < b; i++)
#define reppr(i, a, b) for (ll i = a - 1; i >= b; i--)
#define repr(i, n) for (ll i = n - 1; i >= 0; i--)
#define ff first
#define ss second
#define pc putchar_unlocked
#define gc getchar_unlocked
#define inf 9223372036854775807
#define infn -9223372036854775807
#define pi 3.14159265358979323846
#define eps 0.0000000001
#define sp << " " <<
#define len(s) s.size()
#define setprecision0 cout << fixed << setprecision(0);
#define setprecision10 cout << fixed << setprecision(10);
#define all(n) n.begin(), n.end()
#define SORT(v) sort(all(v))
int modinv(int a, int m) {
int b = m, u = 1, v = 0;
while (b) {
int t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
return (u + m) % m;
}
int nCr(int n, int m) {
int k = 1;
repp(i, 1, m) k *= (n - i + 1), k %= mod, k *= modinv(i, mod), k %= mod;
return k;
}
signed main() {
int n, m, k;
cin >> n >> m >> k;
int ml = nCr(n * m - 2, k - 2), ans = 0;
repp(i, 1, n) ans += i * m * m * (n - i), ans %= mod;
repp(i, 1, m) ans += i * n * n * (m - i), ans %= mod;
cout << (ans * ml) % mod << endl;
}
| // BUGSBUNNY
// IIT ROORKEE
// _,add8ba,
// ,d888888888b,
// d8888888888888b _,ad8ba,_
// d888888888888888) ,d888888888b,
// I8888888888888888 _________ ,8888888888888b
// __________`Y88888888888888P"""""""""""baaa,__
// ,888888888888888,
// ,adP"""""""""""9888888888P""^ ^""Y8888888888888888I
// ,a8"^ ,d888P"888P^ ^"Y8888888888P'
// ,a8^ ,d8888' ^Y8888888P'
// a88' ,d8888P' I88P"^
// ,d88' d88888P' "b,
// ,d88' d888888' `b,
// ,d88' d888888I `b,
// d88I ,8888888' ___ `b,
// ,888' d8888888 ,d88888b, ____ `b,
// d888 ,8888888I d88888888b, ,d8888b, `b
// ,8888 I8888888I d8888888888I ,88888888b 8, I8888
// 88888888b d88888888888' 8888888888b 8I d8886
// 888888888 Y888888888P' Y8888888888, ,8b 88888b
// I88888888b `Y8888888^ `Y888888888I d88, Y88888b
// `888888888b, `""""^ `Y8888888P' d888I `888888b
// 88888888888b, `Y8888P^ d88888
// Y888888b ,8888888888888ba,_ _______ `""^ ,d888888
// I8888888b, ,888888888888888888ba,_ d88888888b ,ad8888888I
// `888888888b, I8888888888888888888888b, ^"Y888P"^ ____.,ad88888888888I
// 88888888888b,`888888888888888888888888b, "" ad888888888888888888888'
// 8888888888888698888888888888888888888888b_,ad88ba,_,d88888888888888888888888
// 88888888888888888888888888888888888888888b,`"""^
// d8888888888888888888888888I
// 8888888888888888888888888888888888888888888baaad888888888888888888888888888'
// Y8888888888888888888888888888888888888888888888888888888888888888888888888P
// I888888888888888888888888888888888888888888888P^ ^Y8888888888888888888888'
// `Y88888888888888888P88888888888888888888888888' ^88888888888888888888I
// `Y8888888888888888 `8888888888888888888888888 8888888888888888888P'
// `Y888888888888888 `888888888888888888888888, ,888888888888888888P'
// `Y88888888888888b `88888888888888888888888I I888888888888888888'
// "Y8888888888888b `8888888888888888888888I I88888888888888888'
// "Y88888888888P `888888888888888888888b d8888888888888888'
// ^""""""""^ `Y88888888888888888888, 888888888888888P'
// "8888888888888888888b, Y888888888888P^
// `Y888888888888888888b `Y8888888P"^
// "Y8888888888888888P `""""^
// `"YY88888888888P'
// ^""""""""'
#include <bits/stdc++.h>
using namespace std;
#define fast \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define int long long
#define ll long long
#define ld long double
#define endl '\n'
#define vi vector<int>
#define vvi vector<vi>
#define vs vector<string>
#define vl vector<long long>
#define vpii vector<pii>
#define vpipii vector<pipii>
#define vb vector<bool>
#define pb push_back
#define pob pop_back
#define gcd __gcd
#define mp make_pair
#define pii pair<int, int>
#define pipii pair<int, pii>
#define pll pair<long long, long long>
#define pld pair<long double, long double>
#define mod 1000000007
#define mod2 998244353
#define rep(i, n) for (ll i = 0; i < n; i++)
#define repp(i, a, b) for (ll i = a; i < b; i++)
#define reppr(i, a, b) for (ll i = a - 1; i >= b; i--)
#define repr(i, n) for (ll i = n - 1; i >= 0; i--)
#define ff first
#define ss second
#define pc putchar_unlocked
#define gc getchar_unlocked
#define inf 9223372036854775807
#define infn -9223372036854775807
#define pi 3.14159265358979323846
#define eps 0.0000000001
#define sp << " " <<
#define len(s) s.size()
#define setprecision0 cout << fixed << setprecision(0);
#define setprecision10 cout << fixed << setprecision(10);
#define all(n) n.begin(), n.end()
#define SORT(v) sort(all(v))
int modinv(int a, int m) {
int b = m, u = 1, v = 0;
while (b) {
int t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
return (u + m) % m;
}
int nCr(int n, int m) {
int k = 1;
repp(i, 1, m + 1) k *= (n - i + 1), k %= mod, k *= modinv(i, mod), k %= mod;
return k;
}
signed main() {
int n, m, k;
cin >> n >> m >> k;
int ml = nCr(n * m - 2, k - 2), ans = 0;
repp(i, 1, n) ans += i * m * m * (n - i), ans %= mod;
repp(i, 1, m) ans += i * n * n * (m - i), ans %= mod;
cout << (ans * ml) % mod << endl;
}
| [
"assignment.change"
] | 854,284 | 854,285 | u747201517 | cpp |
p03039 | #pragma GCC optimize("Ofast")
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
using ll = long long int;
using pii = pair<int, int>;
using pil = pair<int, ll>;
using pli = pair<ll, int>;
using pll = pair<ll, ll>;
using psi = pair<string, int>;
using pis = pair<int, string>;
using psl = pair<string, ll>;
using pls = pair<ll, string>;
using pss = pair<string, string>;
template <typename T> using vc = vector<T>;
template <typename T> using vvc = vector<vector<T>>;
template <typename T> using vvvc = vector<vector<vector<T>>>;
template <typename T> using vvvvc = vector<vvvc<T>>;
template <typename T> using vvvvvc = vector<vvvvc<T>>;
template <class T, class U> inline constexpr bool chmin(T &a, const U b) {
if (a <= b)
return false;
a = b;
return true;
}
template <class T, class U> inline constexpr bool chmax(T &a, const U b) {
if (a >= b)
return false;
a = b;
return true;
}
#define bit(n, k) ((n >> k) & 1)
inline void bin101() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout << fixed << setprecision(20);
}
template <typename T> inline void Yes(T flag) {
if (flag)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
template <typename T> inline void YES(T flag) {
if (flag)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
// 1-indexed vector cin
template <typename T> inline void vin1(vector<T> &v) {
for (int i = 1; i < v.size(); i++)
cin >> v[i];
}
// 0-indexed vector cin
template <typename T> inline void vin0(vector<T> &v) {
for (int i = 0; i < v.size(); i++)
cin >> v[i];
}
// 1-indexed vector<vector> cin
template <typename T> inline void vin1(vector<vector<T>> &v) {
for (int i = 1; i < v.size(); i++) {
for (int j = 1; j < v[i].size(); j++)
cin >> v[i][j];
}
}
// 0-indexed vector<vector> cin
template <typename T> inline void vin0(vector<vector<T>> &v) {
for (int i = 0; i < v.size(); i++) {
for (int j = 0; j < v[i].size(); j++)
cin >> v[i][j];
}
}
//デバッグ
template <typename T> inline void vout(const vector<T> &v) {
cout << "\nstart\n";
const int sz = v.size();
for (int i = 0; i < sz; i++) {
cout << i << " " << v[i] << '\n';
}
cout << "end\n" << endl;
}
//デバッグ
template <typename T> inline void vout(const vvc<T> &v) {
cout << "\nstart\n";
const int sz = v.size();
for (int i = 0; i < sz; i++) {
int ssz = v[i].size();
for (int j = 0; j < ssz; j++) {
cout << i << " " << j << " " << v[i][j] << '\n';
}
}
cout << "\nend\n" << endl;
}
//デバッグ(グリッド)
template <typename T> inline void gvout(const vector<T> &v) {
cout << "\nstart\n";
const int sz = v.size();
for (int i = 0; i < sz; i++) {
if (i)
cout << " ";
cout << v[i];
}
cout << "\nend\n" << endl;
}
//デバッグ(グリッド)
template <typename T> inline void gvout(const vvc<T> &v) {
cout << "\nstart\n";
const int sz = v.size();
for (int i = 0; i < sz; i++) {
int ssz = v[i].size();
for (int j = 0; j < ssz; j++) {
if (j)
cout << " ";
cout << v[i][j];
}
cout << endl;
}
cout << "end\n" << endl;
}
//デバッグ
template <typename T> inline void vout(const vvvc<T> &v) {
cout << "\nstart\n";
const int sz = v.size();
for (int i = 0; i < sz; i++) {
int ssz = v[i].size();
for (int j = 0; j < ssz; j++) {
int sssz = v[i][j].size();
for (int k = 0; k < sssz; k++) {
cout << i << " " << j << " " << k << " " << v[i][j][k] << '\n';
}
}
}
cout << "end\n" << endl;
}
// pair cout
template <typename T, typename U>
inline ostream &operator<<(ostream &os, const pair<T, U> &p) {
os << p.first << " " << p.second;
return os;
}
// pair cin
template <typename T, typename U>
inline istream &operator>>(istream &is, pair<T, U> &p) {
is >> p.first >> p.second;
return is;
}
//ソート
template <typename T> inline void vsort(vector<T> &v) {
sort(v.begin(), v.end());
}
//逆順ソート
template <typename T> inline void rvsort(vector<T> &v) {
sort(v.rbegin(), v.rend());
}
//要素数a 初期値x
template <typename T> inline vector<T> vmake(int a, T x) {
return vector<T>(a, x);
}
// data[a][b] 初期値x
template <typename T> inline vector<vector<T>> vmake(int a, int b, T x) {
return vector<vector<T>>(a, vector<T>(b, x));
}
// data[a][b][c] 初期値x
template <typename T>
inline vector<vector<vector<T>>> vmake(int a, int b, int c, T x) {
return vector<vector<vector<T>>>(a, vector<vector<T>>(b, vector<T>(c, x)));
}
// data[a][b][c][d] 初期値x
template <typename T>
inline vector<vector<vector<vector<T>>>> vmake(int a, int b, int c, int d,
T x) {
return vector<vector<vector<vector<T>>>>(a,
vvvc<T>(b, vvc<T>(c, vc<T>(d, x))));
}
// data[a][b][c][d][e] 初期値x
template <typename T>
inline vvvvvc<T> vmake(int a, int b, int c, int d, int e, T x) {
return vvvvvc<T>(a, vvvvc<T>(b, vvvc<T>(c, vvc<T>(d, vc<T>(e, x)))));
}
// 1ビットの数を返す
inline int popcount(int x) { return __builtin_popcount(x); }
// 1ビットの数を返す
inline int popcount(ll x) { return __builtin_popcountll(x); }
// queのfront() pop()
template <typename T> inline T pop(queue<T> &que) {
T x = que.front();
que.pop();
return x;
}
// priority_que top() pop()
template <typename T> inline T pop(priority_queue<T> &que) {
T x = que.top();
que.pop();
return x;
}
// stack top() pop()
template <typename T> inline T pop(stack<T> &st) {
T x = st.top();
st.pop();
return x;
}
#define SZ(x) ((int)x.size())
#define pb push_back
/*
満たすものの個数を返す
mode:0 x未満
mode:1 x以下の数
mode:2 x以上の数
mode:3 x超
mode:4 x
*/
template <typename T> inline int count_bound(vector<T> &v, T x, int mode) {
switch (mode) {
case 0:
return lower_bound(v.begin(), v.end(), x) - v.begin();
case 1:
return upper_bound(v.begin(), v.end(), x) - v.begin();
case 2:
return v.end() - lower_bound(v.begin(), v.end(), x);
case 3:
return v.end() - upper_bound(v.begin(), v.end(), x);
case 4:
return upper_bound(v.begin(), v.end(), x) -
lower_bound(v.begin(), v.end(), x);
}
}
/*
mode:0 xより小さい数で最大の数
mode:1 x以下の数で最大の数
mode:2 x以上の数で最小の数
mode:3 xより大きい数で最小の数
*/
template <typename T> inline T value_bound(vector<T> &v, T x, int mode) {
switch (mode) {
case 0:
return *(--lower_bound(v.begin(), v.end(), x));
case 1:
return *(--upper_bound(v.begin(), v.end(), x));
case 2:
return *lower_bound(v.begin(), v.end(), x);
case 3:
return *upper_bound(v.begin(), v.end(), x);
}
}
constexpr int MAX = 1 << 30;
constexpr ll INF = 1LL << 62;
constexpr ll MOD = 1e9 + 7;
int dx[] = {1, -1, 0, 0}, dy[] = {0, 0, -1, 1};
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
struct ModInt {
using u64 = uint_fast64_t;
u64 a;
constexpr ModInt() : a(0) {}
constexpr ModInt(ll x) : a((x >= 0) ? (x % MOD) : (x % MOD + MOD)) {}
inline constexpr ModInt operator+(const ModInt rhs) const noexcept {
return ModInt(*this) += rhs;
}
inline constexpr ModInt operator-(const ModInt rhs) const noexcept {
return ModInt(*this) -= rhs;
}
inline constexpr ModInt operator*(const ModInt rhs) const noexcept {
return ModInt(*this) *= rhs;
}
inline constexpr ModInt operator/(const ModInt rhs) const noexcept {
return ModInt(*this) /= rhs;
}
inline constexpr ModInt operator+(const ll rhs) const noexcept {
return ModInt(*this) += rhs;
}
inline constexpr ModInt operator-(const ll rhs) const noexcept {
return ModInt(*this) -= rhs;
}
inline constexpr ModInt operator*(const ll rhs) const noexcept {
return ModInt(*this) *= rhs;
}
inline constexpr ModInt operator/(const ll rhs) const noexcept {
return ModInt(*this) /= rhs;
}
inline constexpr ModInt &operator+=(const ModInt rhs) noexcept {
a += rhs.a;
if (a >= MOD)
a -= MOD;
return *this;
}
inline constexpr ModInt &operator-=(const ModInt rhs) noexcept {
if (rhs.a > a)
a += MOD;
a -= rhs.a;
return *this;
}
inline constexpr ModInt &operator*=(const ModInt rhs) noexcept {
a = (a * rhs.a) % MOD;
return *this;
}
inline constexpr ModInt &operator/=(ModInt rhs) noexcept {
a = (a * rhs.inverse().a) % MOD;
return *this;
}
inline constexpr ModInt &operator+=(const ll rhs) noexcept {
a += rhs;
if (a >= MOD)
a -= MOD;
return *this;
}
inline constexpr ModInt &operator-=(const ll rhs) noexcept {
if (rhs > a)
a += MOD;
a -= rhs;
return *this;
}
inline constexpr ModInt &operator*=(const ll rhs) noexcept {
a = (a * rhs) % MOD;
return *this;
}
inline constexpr ModInt &operator/=(ll rhs) noexcept {
a = (a * ModInt(rhs).inverse().a) % MOD;
return *this;
}
inline constexpr ModInt operator=(ll x) noexcept {
x %= MOD;
if (x < 0)
x += MOD;
a = x;
return *this;
}
inline constexpr bool operator==(const ModInt p) const noexcept {
return a == p.a;
}
inline constexpr bool operator!=(const ModInt p) const noexcept {
return a != p.a;
}
inline constexpr ModInt pow(ll N) const noexcept {
ModInt ans(1LL), p(a);
while (N > 0) {
if (bit(N, 0)) {
ans *= p;
}
p *= p;
N >>= 1;
}
return ans;
}
inline constexpr ModInt inverse() const noexcept { return pow(MOD - 2); }
};
inline constexpr ModInt operator+(const ll &a, const ModInt &b) noexcept {
return ModInt(a) += b;
}
inline constexpr ModInt operator-(const ll &a, const ModInt &b) noexcept {
return ModInt(a) -= b;
}
inline constexpr ModInt operator*(const ll &a, const ModInt &b) noexcept {
return ModInt(a) *= b;
}
inline constexpr ModInt operator/(const ll &a, const ModInt &b) noexcept {
return ModInt(a) /= b;
}
// cout
inline ostream &operator<<(ostream &os, const ModInt &p) { return os << p.a; }
// cin
inline istream &operator>>(istream &is, ModInt &p) {
ll t;
is >> t;
p = t;
return is;
}
inline constexpr ModInt Mr(ll p) {
p %= MOD;
if (p < 0)
p += MOD;
return ModInt(p);
}
struct Binominal {
vector<ModInt> fac, finv, inv; // fac[n]:n! finv:(n!)の逆元
int sz;
Binominal(int n = 10) : sz(0) {
if (n == 0)
n = 10;
init(n);
}
inline void init(int n) {
fac.resize(n + 1, 1);
finv.resize(n + 1, 1);
inv.resize(n + 1, 1);
for (int i = 2; i <= n; i++) {
fac[i] = fac[i - 1] * i;
inv[i] = MOD - inv[MOD % i] * (MOD / i);
finv[i] = finv[i - 1] * inv[i];
}
sz = n;
}
// nCk(n,k<=N) をO(1)で求める
inline ModInt com(int n, int k) {
if (n < k)
return ModInt(0);
if (n < 0 || k < 0)
return ModInt(0);
if (n > sz)
init(n);
return fac[n] * finv[k] * finv[n - k];
}
// nCk(k<=N) をO(k) で求める
inline ModInt rcom(ll n, int k) {
if (n < 0 || k < 0 || n < k)
return ModInt(0);
if (k > sz)
init(k);
ModInt ret(1);
for (int i = 0; i < k; i++) {
ret *= (n - i);
}
ret *= finv[k];
return ret;
}
//重複組み合わせ n種類のものから重複を許してk個を選ぶ
//〇がn個,|がk個
inline ModInt h(int n, int k) { return com(n + k - 1, k); }
};
signed main() {
bin101();
int N, M, K;
cin >> N >> M >> K;
Binominal B;
ModInt b = B.com(N * M - 2, K - 2);
ModInt ret(0);
for (int i = 1; i <= N - 1; i++) {
ret += b * i * (N - i) * N * N;
}
for (int i = 1; i <= M - 1; i++) {
ret += b * i * (M - i) * M * M;
}
cout << ret << endl;
}
| #pragma GCC optimize("Ofast")
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
using ll = long long int;
using pii = pair<int, int>;
using pil = pair<int, ll>;
using pli = pair<ll, int>;
using pll = pair<ll, ll>;
using psi = pair<string, int>;
using pis = pair<int, string>;
using psl = pair<string, ll>;
using pls = pair<ll, string>;
using pss = pair<string, string>;
template <typename T> using vc = vector<T>;
template <typename T> using vvc = vector<vector<T>>;
template <typename T> using vvvc = vector<vector<vector<T>>>;
template <typename T> using vvvvc = vector<vvvc<T>>;
template <typename T> using vvvvvc = vector<vvvvc<T>>;
template <class T, class U> inline constexpr bool chmin(T &a, const U b) {
if (a <= b)
return false;
a = b;
return true;
}
template <class T, class U> inline constexpr bool chmax(T &a, const U b) {
if (a >= b)
return false;
a = b;
return true;
}
#define bit(n, k) ((n >> k) & 1)
inline void bin101() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout << fixed << setprecision(20);
}
template <typename T> inline void Yes(T flag) {
if (flag)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
template <typename T> inline void YES(T flag) {
if (flag)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
// 1-indexed vector cin
template <typename T> inline void vin1(vector<T> &v) {
for (int i = 1; i < v.size(); i++)
cin >> v[i];
}
// 0-indexed vector cin
template <typename T> inline void vin0(vector<T> &v) {
for (int i = 0; i < v.size(); i++)
cin >> v[i];
}
// 1-indexed vector<vector> cin
template <typename T> inline void vin1(vector<vector<T>> &v) {
for (int i = 1; i < v.size(); i++) {
for (int j = 1; j < v[i].size(); j++)
cin >> v[i][j];
}
}
// 0-indexed vector<vector> cin
template <typename T> inline void vin0(vector<vector<T>> &v) {
for (int i = 0; i < v.size(); i++) {
for (int j = 0; j < v[i].size(); j++)
cin >> v[i][j];
}
}
//デバッグ
template <typename T> inline void vout(const vector<T> &v) {
cout << "\nstart\n";
const int sz = v.size();
for (int i = 0; i < sz; i++) {
cout << i << " " << v[i] << '\n';
}
cout << "end\n" << endl;
}
//デバッグ
template <typename T> inline void vout(const vvc<T> &v) {
cout << "\nstart\n";
const int sz = v.size();
for (int i = 0; i < sz; i++) {
int ssz = v[i].size();
for (int j = 0; j < ssz; j++) {
cout << i << " " << j << " " << v[i][j] << '\n';
}
}
cout << "\nend\n" << endl;
}
//デバッグ(グリッド)
template <typename T> inline void gvout(const vector<T> &v) {
cout << "\nstart\n";
const int sz = v.size();
for (int i = 0; i < sz; i++) {
if (i)
cout << " ";
cout << v[i];
}
cout << "\nend\n" << endl;
}
//デバッグ(グリッド)
template <typename T> inline void gvout(const vvc<T> &v) {
cout << "\nstart\n";
const int sz = v.size();
for (int i = 0; i < sz; i++) {
int ssz = v[i].size();
for (int j = 0; j < ssz; j++) {
if (j)
cout << " ";
cout << v[i][j];
}
cout << endl;
}
cout << "end\n" << endl;
}
//デバッグ
template <typename T> inline void vout(const vvvc<T> &v) {
cout << "\nstart\n";
const int sz = v.size();
for (int i = 0; i < sz; i++) {
int ssz = v[i].size();
for (int j = 0; j < ssz; j++) {
int sssz = v[i][j].size();
for (int k = 0; k < sssz; k++) {
cout << i << " " << j << " " << k << " " << v[i][j][k] << '\n';
}
}
}
cout << "end\n" << endl;
}
// pair cout
template <typename T, typename U>
inline ostream &operator<<(ostream &os, const pair<T, U> &p) {
os << p.first << " " << p.second;
return os;
}
// pair cin
template <typename T, typename U>
inline istream &operator>>(istream &is, pair<T, U> &p) {
is >> p.first >> p.second;
return is;
}
//ソート
template <typename T> inline void vsort(vector<T> &v) {
sort(v.begin(), v.end());
}
//逆順ソート
template <typename T> inline void rvsort(vector<T> &v) {
sort(v.rbegin(), v.rend());
}
//要素数a 初期値x
template <typename T> inline vector<T> vmake(int a, T x) {
return vector<T>(a, x);
}
// data[a][b] 初期値x
template <typename T> inline vector<vector<T>> vmake(int a, int b, T x) {
return vector<vector<T>>(a, vector<T>(b, x));
}
// data[a][b][c] 初期値x
template <typename T>
inline vector<vector<vector<T>>> vmake(int a, int b, int c, T x) {
return vector<vector<vector<T>>>(a, vector<vector<T>>(b, vector<T>(c, x)));
}
// data[a][b][c][d] 初期値x
template <typename T>
inline vector<vector<vector<vector<T>>>> vmake(int a, int b, int c, int d,
T x) {
return vector<vector<vector<vector<T>>>>(a,
vvvc<T>(b, vvc<T>(c, vc<T>(d, x))));
}
// data[a][b][c][d][e] 初期値x
template <typename T>
inline vvvvvc<T> vmake(int a, int b, int c, int d, int e, T x) {
return vvvvvc<T>(a, vvvvc<T>(b, vvvc<T>(c, vvc<T>(d, vc<T>(e, x)))));
}
// 1ビットの数を返す
inline int popcount(int x) { return __builtin_popcount(x); }
// 1ビットの数を返す
inline int popcount(ll x) { return __builtin_popcountll(x); }
// queのfront() pop()
template <typename T> inline T pop(queue<T> &que) {
T x = que.front();
que.pop();
return x;
}
// priority_que top() pop()
template <typename T> inline T pop(priority_queue<T> &que) {
T x = que.top();
que.pop();
return x;
}
// stack top() pop()
template <typename T> inline T pop(stack<T> &st) {
T x = st.top();
st.pop();
return x;
}
#define SZ(x) ((int)x.size())
#define pb push_back
/*
満たすものの個数を返す
mode:0 x未満
mode:1 x以下の数
mode:2 x以上の数
mode:3 x超
mode:4 x
*/
template <typename T> inline int count_bound(vector<T> &v, T x, int mode) {
switch (mode) {
case 0:
return lower_bound(v.begin(), v.end(), x) - v.begin();
case 1:
return upper_bound(v.begin(), v.end(), x) - v.begin();
case 2:
return v.end() - lower_bound(v.begin(), v.end(), x);
case 3:
return v.end() - upper_bound(v.begin(), v.end(), x);
case 4:
return upper_bound(v.begin(), v.end(), x) -
lower_bound(v.begin(), v.end(), x);
}
}
/*
mode:0 xより小さい数で最大の数
mode:1 x以下の数で最大の数
mode:2 x以上の数で最小の数
mode:3 xより大きい数で最小の数
*/
template <typename T> inline T value_bound(vector<T> &v, T x, int mode) {
switch (mode) {
case 0:
return *(--lower_bound(v.begin(), v.end(), x));
case 1:
return *(--upper_bound(v.begin(), v.end(), x));
case 2:
return *lower_bound(v.begin(), v.end(), x);
case 3:
return *upper_bound(v.begin(), v.end(), x);
}
}
constexpr int MAX = 1 << 30;
constexpr ll INF = 1LL << 62;
constexpr ll MOD = 1e9 + 7;
int dx[] = {1, -1, 0, 0}, dy[] = {0, 0, -1, 1};
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
struct ModInt {
using u64 = uint_fast64_t;
u64 a;
constexpr ModInt() : a(0) {}
constexpr ModInt(ll x) : a((x >= 0) ? (x % MOD) : (x % MOD + MOD)) {}
inline constexpr ModInt operator+(const ModInt rhs) const noexcept {
return ModInt(*this) += rhs;
}
inline constexpr ModInt operator-(const ModInt rhs) const noexcept {
return ModInt(*this) -= rhs;
}
inline constexpr ModInt operator*(const ModInt rhs) const noexcept {
return ModInt(*this) *= rhs;
}
inline constexpr ModInt operator/(const ModInt rhs) const noexcept {
return ModInt(*this) /= rhs;
}
inline constexpr ModInt operator+(const ll rhs) const noexcept {
return ModInt(*this) += rhs;
}
inline constexpr ModInt operator-(const ll rhs) const noexcept {
return ModInt(*this) -= rhs;
}
inline constexpr ModInt operator*(const ll rhs) const noexcept {
return ModInt(*this) *= rhs;
}
inline constexpr ModInt operator/(const ll rhs) const noexcept {
return ModInt(*this) /= rhs;
}
inline constexpr ModInt &operator+=(const ModInt rhs) noexcept {
a += rhs.a;
if (a >= MOD)
a -= MOD;
return *this;
}
inline constexpr ModInt &operator-=(const ModInt rhs) noexcept {
if (rhs.a > a)
a += MOD;
a -= rhs.a;
return *this;
}
inline constexpr ModInt &operator*=(const ModInt rhs) noexcept {
a = (a * rhs.a) % MOD;
return *this;
}
inline constexpr ModInt &operator/=(ModInt rhs) noexcept {
a = (a * rhs.inverse().a) % MOD;
return *this;
}
inline constexpr ModInt &operator+=(const ll rhs) noexcept {
a += rhs;
if (a >= MOD)
a -= MOD;
return *this;
}
inline constexpr ModInt &operator-=(const ll rhs) noexcept {
if (rhs > a)
a += MOD;
a -= rhs;
return *this;
}
inline constexpr ModInt &operator*=(const ll rhs) noexcept {
a = (a * rhs) % MOD;
return *this;
}
inline constexpr ModInt &operator/=(ll rhs) noexcept {
a = (a * ModInt(rhs).inverse().a) % MOD;
return *this;
}
inline constexpr ModInt operator=(ll x) noexcept {
x %= MOD;
if (x < 0)
x += MOD;
a = x;
return *this;
}
inline constexpr bool operator==(const ModInt p) const noexcept {
return a == p.a;
}
inline constexpr bool operator!=(const ModInt p) const noexcept {
return a != p.a;
}
inline constexpr ModInt pow(ll N) const noexcept {
ModInt ans(1LL), p(a);
while (N > 0) {
if (bit(N, 0)) {
ans *= p;
}
p *= p;
N >>= 1;
}
return ans;
}
inline constexpr ModInt inverse() const noexcept { return pow(MOD - 2); }
};
inline constexpr ModInt operator+(const ll &a, const ModInt &b) noexcept {
return ModInt(a) += b;
}
inline constexpr ModInt operator-(const ll &a, const ModInt &b) noexcept {
return ModInt(a) -= b;
}
inline constexpr ModInt operator*(const ll &a, const ModInt &b) noexcept {
return ModInt(a) *= b;
}
inline constexpr ModInt operator/(const ll &a, const ModInt &b) noexcept {
return ModInt(a) /= b;
}
// cout
inline ostream &operator<<(ostream &os, const ModInt &p) { return os << p.a; }
// cin
inline istream &operator>>(istream &is, ModInt &p) {
ll t;
is >> t;
p = t;
return is;
}
inline constexpr ModInt Mr(ll p) {
p %= MOD;
if (p < 0)
p += MOD;
return ModInt(p);
}
struct Binominal {
vector<ModInt> fac, finv, inv; // fac[n]:n! finv:(n!)の逆元
int sz;
Binominal(int n = 10) : sz(0) {
if (n == 0)
n = 10;
init(n);
}
inline void init(int n) {
fac.resize(n + 1, 1);
finv.resize(n + 1, 1);
inv.resize(n + 1, 1);
for (int i = 2; i <= n; i++) {
fac[i] = fac[i - 1] * i;
inv[i] = MOD - inv[MOD % i] * (MOD / i);
finv[i] = finv[i - 1] * inv[i];
}
sz = n;
}
// nCk(n,k<=N) をO(1)で求める
inline ModInt com(int n, int k) {
if (n < k)
return ModInt(0);
if (n < 0 || k < 0)
return ModInt(0);
if (n > sz)
init(n);
return fac[n] * finv[k] * finv[n - k];
}
// nCk(k<=N) をO(k) で求める
inline ModInt rcom(ll n, int k) {
if (n < 0 || k < 0 || n < k)
return ModInt(0);
if (k > sz)
init(k);
ModInt ret(1);
for (int i = 0; i < k; i++) {
ret *= (n - i);
}
ret *= finv[k];
return ret;
}
//重複組み合わせ n種類のものから重複を許してk個を選ぶ
//〇がn個,|がk個
inline ModInt h(int n, int k) { return com(n + k - 1, k); }
};
signed main() {
bin101();
int N, M, K;
cin >> N >> M >> K;
Binominal B;
ModInt b = B.com(N * M - 2, K - 2);
ModInt ret(0);
for (int i = 1; i <= N - 1; i++) {
ret += b * i * (N - i) * M * M;
}
for (int i = 1; i <= M - 1; i++) {
ret += b * i * (M - i) * N * N;
}
cout << ret << endl;
}
| [
"assignment.value.change",
"identifier.change",
"expression.operation.binary.change"
] | 854,286 | 854,287 | u591914971 | cpp |
p03039 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <iostream>
#include <limits>
#include <queue>
#include <set>
#include <tuple>
#include <vector>
using namespace std;
#define INF 11000000000
#define MAX 210000
#define MOD 1000000007
typedef long long ll;
typedef pair<int, int> P;
typedef pair<pair<int, int>, int> p;
typedef pair<pair<int, int>, int> p;
#define bit(n, k) ((n >> k) & 1) /*nのk bit目*/
#define rad_to_deg(rad) (((rad) / 2 / M_PI) * 360)
// http://kmjp.hatenablog.jp/entry/2019/05/26/0900
ll fac[MAX], finv[MAX], inv[MAX];
// http://drken1215.hatenablog.com/entry/2018/06/08/210000
//テーブルを作る前処理 O(n)
// pが素数でなくてはならない
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
//二項係数計算
ll COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
int main() {
COMinit();
int N, M, K;
cin >> N >> M >> K;
ll ans = 0;
for (int i = 0; i < N; i++) {
ll d = 1LL * i * (i + 1) / 2 % MOD;
d = d * M % MOD * M % MOD;
ans += d;
}
for (int i = 0; i < M; i++) {
ll d = 1LL * i * (i + 1) / 2 % MOD;
d = d * N % MOD * N % MOD;
ans += d;
}
cout << ans % MOD * COM(N * M - 2, K - 2) << endl;
}
| #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <iostream>
#include <limits>
#include <queue>
#include <set>
#include <tuple>
#include <vector>
using namespace std;
#define INF 11000000000
#define MAX 210000
#define MOD 1000000007
typedef long long ll;
typedef pair<int, int> P;
typedef pair<pair<int, int>, int> p;
typedef pair<pair<int, int>, int> p;
#define bit(n, k) ((n >> k) & 1) /*nのk bit目*/
#define rad_to_deg(rad) (((rad) / 2 / M_PI) * 360)
// http://kmjp.hatenablog.jp/entry/2019/05/26/0900
ll fac[MAX], finv[MAX], inv[MAX];
// http://drken1215.hatenablog.com/entry/2018/06/08/210000
//テーブルを作る前処理 O(n)
// pが素数でなくてはならない
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
//二項係数計算
ll COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
int main() {
COMinit();
int N, M, K;
cin >> N >> M >> K;
ll ans = 0;
for (int i = 0; i < N; i++) {
ll d = 1LL * i * (i + 1) / 2 % MOD;
d = d * M % MOD * M % MOD;
ans += d;
}
for (int i = 0; i < M; i++) {
ll d = 1LL * i * (i + 1) / 2 % MOD;
d = d * N % MOD * N % MOD;
ans += d;
}
cout << ans % MOD * COM(N * M - 2, K - 2) % MOD << endl;
}
| [
"expression.operation.binary.add"
] | 854,288 | 854,289 | u591914971 | cpp |
p03039 | #include <algorithm>
#include <complex>
#include <map>
#include <math.h>
#include <queue>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <vector>
typedef long long int LL;
using namespace std;
// 插入此處
namespace Number {
typedef long long int LL;
// 求取 a, b 的最大公因數
LL gcd(LL a, LL b) {
if (a % b == 0) {
return b;
}
return gcd(b, a % b);
}
// 求取 a, b 的最大公因數 gcd
// 以及 x, y 使得 a*x + b*y = gcd
LL gcd_extend(LL a, LL b, LL *x, LL *y) {
if (a == 0) {
*x = 0, *y = 1;
return b;
}
LL x1, y1; // To store results of recursive call
LL gcd = gcd_extend(b % a, a, &x1, &y1);
*x = y1 - (b / a) * x1;
*y = x1;
return gcd;
}
// 求 a_inv 使得 (a * a_inv) % m = gcd(a, m)
// 若 a, m 互質，即求 a 在 mod m 群的反元素 a_inv
LL mod_inv(LL a, LL m) {
LL x, y;
LL g = gcd_extend(a, m, &x, &y);
// 處理 x 爲負的情形
LL a_inv = (x % m + m) % m;
return a_inv;
}
// 求 x^n % m
LL mod_pow(LL x, LL n, LL m) {
if (n == 0) {
return 1;
} else if (n & 1) {
LL half = mod_pow(x, n / 2, m);
return (half * half % m) * x % m;
} else {
LL half = mod_pow(x, n / 2, m);
return half * half % m;
}
}
// 連乘
LL mul(LL from, LL to, LL m) {
LL ret = 1;
for (LL i = from; i <= to; i++) {
ret *= i;
ret %= m;
}
return ret;
}
// 求 (C n 取 k) % m
LL mod_comb(LL n, LL k, LL m) {
LL mi = k < n - k ? k : n - k;
LL up = mul(n - mi + 1, n, m);
LL down = mul(1, mi, m);
return (up * mod_inv(down, m)) % m;
}
} // namespace Number
const LL M = (LL)1e9 + 7;
LL sum(LL x) { return (1 + x) * x / 2; }
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
LL total = 0;
for (LL i = 0; i < n; i++) {
for (LL j = 0; j < m; j++) {
total += sum(n - 1 - i) * m % M;
total += sum(i) * m % M;
total += sum(m - 1 - j) * n % M;
total += sum(j) * n % M;
}
}
// printf("total = %lld\n", total);
LL l = n * m;
LL ans = Number::mod_comb(l - 2, k - 2, M) * total;
ans %= M;
ans *= Number::mod_inv(2, M);
ans %= M;
printf("%lld\n", ans);
}
| #include <algorithm>
#include <complex>
#include <map>
#include <math.h>
#include <queue>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <vector>
typedef long long int LL;
using namespace std;
// 插入此處
namespace Number {
typedef long long int LL;
// 求取 a, b 的最大公因數
LL gcd(LL a, LL b) {
if (a % b == 0) {
return b;
}
return gcd(b, a % b);
}
// 求取 a, b 的最大公因數 gcd
// 以及 x, y 使得 a*x + b*y = gcd
LL gcd_extend(LL a, LL b, LL *x, LL *y) {
if (a == 0) {
*x = 0, *y = 1;
return b;
}
LL x1, y1; // To store results of recursive call
LL gcd = gcd_extend(b % a, a, &x1, &y1);
*x = y1 - (b / a) * x1;
*y = x1;
return gcd;
}
// 求 a_inv 使得 (a * a_inv) % m = gcd(a, m)
// 若 a, m 互質，即求 a 在 mod m 群的反元素 a_inv
LL mod_inv(LL a, LL m) {
LL x, y;
LL g = gcd_extend(a, m, &x, &y);
// 處理 x 爲負的情形
LL a_inv = (x % m + m) % m;
return a_inv;
}
// 求 x^n % m
LL mod_pow(LL x, LL n, LL m) {
if (n == 0) {
return 1;
} else if (n & 1) {
LL half = mod_pow(x, n / 2, m);
return (half * half % m) * x % m;
} else {
LL half = mod_pow(x, n / 2, m);
return half * half % m;
}
}
// 連乘
LL mul(LL from, LL to, LL m) {
LL ret = 1;
for (LL i = from; i <= to; i++) {
ret *= i;
ret %= m;
}
return ret;
}
// 求 (C n 取 k) % m
LL mod_comb(LL n, LL k, LL m) {
LL mi = k < n - k ? k : n - k;
LL up = mul(n - mi + 1, n, m);
LL down = mul(1, mi, m);
return (up * mod_inv(down, m)) % m;
}
} // namespace Number
const LL M = (LL)1e9 + 7;
LL sum(LL x) { return (1 + x) * x / 2; }
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
LL total = 0;
for (LL i = 0; i < n; i++) {
for (LL j = 0; j < m; j++) {
total += sum(n - 1 - i) * m % M;
total += sum(i) * m % M;
total += sum(m - 1 - j) * n % M;
total += sum(j) * n % M;
total = total % M;
}
}
// printf("total = %lld\n", total);
LL l = n * m;
LL ans = Number::mod_comb(l - 2, k - 2, M) * total;
ans %= M;
ans *= Number::mod_inv(2, M);
ans %= M;
printf("%lld\n", ans);
}
| [
"assignment.add"
] | 854,290 | 854,291 | u360239609 | cpp |
p03039 | #include <chrono>
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <istream>
#include <map>
#include <ostream>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <time.h>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
#define int long long
#define pb push_back
#define all(a) (a).begin(), (a).end()
#define pii pair<int, int>
#define ld long double
ostream &operator<<(ostream &a, const vector<int> &b) {
for (auto k : b)
cout << k << " ";
return a;
}
#ifdef LOCAL
#define dbg(x) cout << #x << " : " << (x) << "\n";
const int INF = 1e18;
// const int mod = 2600000069;
// const int p = 10;
// const ld PI = 3.1415926535;
#else
#define dbg(x)
const int INF = 1e18;
// const int mod = 2600000069;
// const int p = 179;
// const ld PI = 3.1415926535;
#endif
//#pragma GCC optimize("Ofast,no-stack-protector")
//#pragma GCC target("sse,sse2,sse3,sse3,sse4")
//#pragma GCC optimize("unroll-loops")
//#pragma GCC optimize("fast-math")
//#pragma GCC target("avx2")
//#pragma GCC optimize("section-anchors")
//#pragma GCC optimize("profile-values,profile-reorder-functions,tracer")
//#pragma GCC optimize("vpt")
//#pragma GCC optimize("rename-registers")
//#pragma GCC optimize("move-loop-invariants")
//#pragma GCC optimize("unswitch-loops")
//#pragma GCC optimize("function-sections")
//#pragma GCC optimize("data-sections")
const int MAXN = 2e5 + 1;
const int mod = 1e9 + 7;
int f[MAXN];
int powmod(int a, int p) {
if (p == 0)
return 1;
if (p == 1)
return a;
int k = powmod(a, p / 2);
if (p & 1)
return (((k * k) % mod) * a) % mod;
return (k * k) % mod;
}
int inv(int k) { return powmod(k, mod - 2); }
int C(int n, int k) {
int ans = f[n];
ans *= inv(f[n - k]);
ans %= mod;
ans *= inv(f[k]);
ans %= mod;
return ans;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
#ifdef LOCAL
#else
// freopen("capitals.in", "r", stdin);
// freopen("capitals.out", "w", stdout);
#endif
f[0] = 1;
for (int i = 1; i < MAXN; i++) {
f[i] = (f[i - 1] * i) % mod;
}
int n, m, k;
cin >> n >> m >> k;
int ans = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
ans += ((j * (j + 1) / 2 + (m - j) * (m - j - 1) / 2) * n) % mod;
ans %= mod;
ans += ((i * (i + 1) / 2 + (n - i) * (n - i - 1) / 2) * m) % mod;
ans %= mod;
}
}
ans *= C(n * m - 2, k - 2);
ans %= mod;
ans *= inv(2);
ans %= mod;
cout << ans;
}
/*
*/
| #include <chrono>
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <istream>
#include <map>
#include <ostream>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <time.h>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
#define int long long
#define pb push_back
#define all(a) (a).begin(), (a).end()
#define pii pair<int, int>
#define ld long double
ostream &operator<<(ostream &a, const vector<int> &b) {
for (auto k : b)
cout << k << " ";
return a;
}
#ifdef LOCAL
#define dbg(x) cout << #x << " : " << (x) << "\n";
const int INF = 1e18;
// const int mod = 2600000069;
// const int p = 10;
// const ld PI = 3.1415926535;
#else
#define dbg(x)
const int INF = 1e18;
// const int mod = 2600000069;
// const int p = 179;
// const ld PI = 3.1415926535;
#endif
//#pragma GCC optimize("Ofast,no-stack-protector")
//#pragma GCC target("sse,sse2,sse3,sse3,sse4")
//#pragma GCC optimize("unroll-loops")
//#pragma GCC optimize("fast-math")
//#pragma GCC target("avx2")
//#pragma GCC optimize("section-anchors")
//#pragma GCC optimize("profile-values,profile-reorder-functions,tracer")
//#pragma GCC optimize("vpt")
//#pragma GCC optimize("rename-registers")
//#pragma GCC optimize("move-loop-invariants")
//#pragma GCC optimize("unswitch-loops")
//#pragma GCC optimize("function-sections")
//#pragma GCC optimize("data-sections")
const int MAXN = 2e5 + 1;
const int mod = 1e9 + 7;
int f[MAXN];
int powmod(int a, int p) {
if (p == 0)
return 1;
if (p == 1)
return a;
int k = powmod(a, p / 2);
if (p & 1)
return (((k * k) % mod) * a) % mod;
return (k * k) % mod;
}
int inv(int k) { return powmod(k, mod - 2); }
int C(int n, int k) {
int ans = f[n];
ans *= inv(f[n - k]);
ans %= mod;
ans *= inv(f[k]);
ans %= mod;
return ans;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
#ifdef LOCAL
#else
// freopen("capitals.in", "r", stdin);
// freopen("capitals.out", "w", stdout);
#endif
f[0] = 1;
for (int i = 1; i < MAXN; i++) {
f[i] = (f[i - 1] * i) % mod;
}
int n, m, k;
cin >> n >> m >> k;
int ans = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
ans += ((j * (j + 1) / 2 + (m - j) * (m - j - 1) / 2) * n) % mod;
ans %= mod;
ans += ((i * (i + 1) / 2 + (n - i) * (n - i - 1) / 2) * m) % mod;
ans %= mod;
}
}
ans *= C(n * m - 2, k - 2);
ans %= mod;
ans *= inv(2);
ans %= mod;
cout << ans;
}
/*
*/
| [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 854,300 | 854,301 | u168026006 | cpp |
p03039 | #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(m * n - 2, k - 2);
ans %= MOD;
cout << ans << endl;
return 0;
} | [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 854,302 | 854,303 | u366381207 | cpp |
p03039 | #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;
} | [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 854,302 | 854,304 | u366381207 | cpp |
p03039 | //
// 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;
}
| [] | 854,314 | 854,315 | u578938637 | cpp |
p03039 | #include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <complex>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rrep(i, n) for (int i = (int)(n - 1); i >= 0; i--)
#define repi(i, a, b) for (int i = int(a); i < int(b); i++)
#define all(x) (x).begin(), (x).end()
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
typedef long long ll;
using namespace std;
long long modpow(long long x, long long n, long long mod) {
if (n == 0)
return 1;
long long res = modpow(x * x % mod, n / 2, mod);
if (n & 1)
res = res * x % mod;
return res;
}
long long modinv(long long a, long long mod) { return modpow(a, mod - 2, mod); }
vector<long long> fact, inv;
long long mod = 1e9 + 7;
void init(int n) {
fact.resize(n);
inv.resize(n);
fact[0] = 1LL;
rep(i, n - 1) { fact[i + 1] = (long long)fact[i] * (i + 1) % mod; }
inv[n - 1] = modinv(fact[n - 1], mod);
rrep(i, n - 1) { inv[i] = (long long)inv[i + 1] * (i + 1) % mod; }
}
long long comb(ll a, ll b) {
return fact[a] * inv[b] % mod * inv[a - b] % mod;
;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
ll n, m, k;
cin >> n >> m >> k;
ll res = 0;
init(2e5 + 7);
ll com = comb(n * m, k - 2);
rep(d, m) { res += n * n % mod * (m - d) % mod * com % mod * d % mod; }
rep(d, n) { res += m * m % mod * (n - d) % mod * com % mod * d % mod; }
cout << res % mod << endl;
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <complex>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rrep(i, n) for (int i = (int)(n - 1); i >= 0; i--)
#define repi(i, a, b) for (int i = int(a); i < int(b); i++)
#define all(x) (x).begin(), (x).end()
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
typedef long long ll;
using namespace std;
long long modpow(long long x, long long n, long long mod) {
if (n == 0)
return 1;
long long res = modpow(x * x % mod, n / 2, mod);
if (n & 1)
res = res * x % mod;
return res;
}
long long modinv(long long a, long long mod) { return modpow(a, mod - 2, mod); }
vector<long long> fact, inv;
long long mod = 1e9 + 7;
void init(int n) {
fact.resize(n);
inv.resize(n);
fact[0] = 1LL;
rep(i, n - 1) { fact[i + 1] = (long long)fact[i] * (i + 1) % mod; }
inv[n - 1] = modinv(fact[n - 1], mod);
rrep(i, n - 1) { inv[i] = (long long)inv[i + 1] * (i + 1) % mod; }
}
long long comb(ll a, ll b) {
return fact[a] * inv[b] % mod * inv[a - b] % mod;
;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
ll n, m, k;
cin >> n >> m >> k;
ll res = 0;
init(2e5 + 7);
ll com = comb(n * m - 2, k - 2);
rep(d, m) { res += n * n % mod * (m - d) % mod * com % mod * d % mod; }
rep(d, n) { res += m * m % mod * (n - d) % mod * com % mod * d % mod; }
cout << res % mod << endl;
return 0;
}
| [
"assignment.change"
] | 854,354 | 854,355 | u834415466 | cpp |
p03039 | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define double long double
#define FOR(i, a, b) for (ll i = (a); i < (b); ++i)
#define FORR(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))
#define VECCIN(x) \
for (auto &youso_ : (x)) \
cin >> youso_
#define bitcnt(x) __builtin_popcount(x)
#define lbit(x) __builtin_ffsll(x)
#define rbit(x) __builtin_clzll(x)
#define SZ(x) ((ll)(x).size())
#define fi first
#define se second
#define All(a) (a).begin(), (a).end()
#define rAll(a) (a).rbegin(), (a).rend()
template <typename T = long long> inline T IN() {
T x;
cin >> x;
return (x);
}
inline void CIN() {}
template <class Head, class... Tail>
inline void CIN(Head &&head, Tail &&...tail) {
cin >> head;
CIN(move(tail)...);
}
#define CCIN(...) \
char __VA_ARGS__; \
CIN(__VA_ARGS__)
#define DCIN(...) \
double __VA_ARGS__; \
CIN(__VA_ARGS__)
#define LCIN(...) \
ll __VA_ARGS__; \
CIN(__VA_ARGS__)
#define SCIN(...) \
string __VA_ARGS__; \
CIN(__VA_ARGS__)
#define Yes(a) cout << (a ? "Yes" : "No") << "\n"
#define YES(a) cout << (a ? "YES" : "NO") << "\n"
#define Printv(v) \
{ \
FOREACH(x, v) { cout << x << " "; } \
cout << "\n"; \
}
template <typename T = string> inline void eputs(T s) {
cout << s << "\n";
exit(0);
}
template <typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val) {
std::fill((T *)array, (T *)(array + N), val);
}
template <typename T> using PQG = priority_queue<T, vector<T>, greater<T>>;
template <typename T> using PQ = priority_queue<T>;
typedef long long ll;
typedef vector<ll> VL;
typedef vector<VL> VVL;
typedef pair<ll, ll> PL;
typedef vector<PL> VPL;
typedef vector<bool> VB;
typedef vector<double> VD;
typedef vector<string> VS;
const int INF = 1e9;
const int MOD = 1e9 + 7;
// const int MOD = 998244353;
const ll LINF = 1e18;
// const double PI = atan(1.0) * 4.0;
const ll dx[] = {1, 1, 0, -1, -1, -1, 0, 1};
const ll dy[] = {0, 1, 1, 1, 0, -1, -1, -1};
#define PI 3.141592653589793238
// 1000000007 で割ったあまりを扱う構造体
template <int MOD> struct Fp {
long long val;
constexpr Fp(long long v = 0) noexcept : val(v % MOD) {
if (val < 0)
v += MOD;
}
constexpr int getmod() { return MOD; }
constexpr Fp operator-() const noexcept { return val ? MOD - val : 0; }
constexpr Fp operator+(const Fp &r) const noexcept { return Fp(*this) += r; }
constexpr Fp operator-(const Fp &r) const noexcept { return Fp(*this) -= r; }
constexpr Fp operator*(const Fp &r) const noexcept { return Fp(*this) *= r; }
constexpr Fp operator/(const Fp &r) const noexcept { return Fp(*this) /= r; }
constexpr Fp &operator+=(const Fp &r) noexcept {
val += r.val;
if (val >= MOD)
val -= MOD;
return *this;
}
constexpr Fp &operator-=(const Fp &r) noexcept {
val -= r.val;
if (val < 0)
val += MOD;
return *this;
}
constexpr Fp &operator*=(const Fp &r) noexcept {
val = val * r.val % MOD;
return *this;
}
constexpr Fp &operator/=(const Fp &r) noexcept {
long long a = r.val, 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);
}
val = val * u % MOD;
if (val < 0)
val += MOD;
return *this;
}
constexpr bool operator==(const Fp &r) const noexcept {
return this->val == r.val;
}
constexpr bool operator!=(const Fp &r) const noexcept {
return this->val != r.val;
}
friend constexpr ostream &operator<<(ostream &os, const Fp<MOD> &x) noexcept {
return os << x.val;
}
friend constexpr istream &operator>>(istream &is, Fp<MOD> &x) noexcept {
return is >> x.val;
}
friend constexpr Fp<MOD> modpow(const Fp<MOD> &a, long long n) noexcept {
if (n == 0)
return 1;
auto t = modpow(a, n / 2);
t = t * t;
if (n & 1)
t = t * a;
return t;
}
};
using mint = Fp<MOD>;
const ll NMAX = 1e6;
ll fac[NMAX + 1], inv[NMAX + 1], finv[NMAX + 1];
void cominit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
FOR(i, 2, NMAX + 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;
}
}
ll comb(ll n, ll k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
ll hcomb(ll n, ll k) { return comb(n + k - 1, k); }
signed main() {
LCIN(N, M, K);
cominit();
mint ans = 0;
REP(i, N) REP(j, M) {
ans += (mint)2 * (N - i) * (M - j) * (i + j);
if (i or j)
continue;
ans -= (N - i) * (M - j) * (i + j);
}
ans *= comb(N * M - 2, K - 2);
cout << ans << "\n";
} | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define double long double
#define FOR(i, a, b) for (ll i = (a); i < (b); ++i)
#define FORR(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))
#define VECCIN(x) \
for (auto &youso_ : (x)) \
cin >> youso_
#define bitcnt(x) __builtin_popcount(x)
#define lbit(x) __builtin_ffsll(x)
#define rbit(x) __builtin_clzll(x)
#define SZ(x) ((ll)(x).size())
#define fi first
#define se second
#define All(a) (a).begin(), (a).end()
#define rAll(a) (a).rbegin(), (a).rend()
template <typename T = long long> inline T IN() {
T x;
cin >> x;
return (x);
}
inline void CIN() {}
template <class Head, class... Tail>
inline void CIN(Head &&head, Tail &&...tail) {
cin >> head;
CIN(move(tail)...);
}
#define CCIN(...) \
char __VA_ARGS__; \
CIN(__VA_ARGS__)
#define DCIN(...) \
double __VA_ARGS__; \
CIN(__VA_ARGS__)
#define LCIN(...) \
ll __VA_ARGS__; \
CIN(__VA_ARGS__)
#define SCIN(...) \
string __VA_ARGS__; \
CIN(__VA_ARGS__)
#define Yes(a) cout << (a ? "Yes" : "No") << "\n"
#define YES(a) cout << (a ? "YES" : "NO") << "\n"
#define Printv(v) \
{ \
FOREACH(x, v) { cout << x << " "; } \
cout << "\n"; \
}
template <typename T = string> inline void eputs(T s) {
cout << s << "\n";
exit(0);
}
template <typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val) {
std::fill((T *)array, (T *)(array + N), val);
}
template <typename T> using PQG = priority_queue<T, vector<T>, greater<T>>;
template <typename T> using PQ = priority_queue<T>;
typedef long long ll;
typedef vector<ll> VL;
typedef vector<VL> VVL;
typedef pair<ll, ll> PL;
typedef vector<PL> VPL;
typedef vector<bool> VB;
typedef vector<double> VD;
typedef vector<string> VS;
const int INF = 1e9;
const int MOD = 1e9 + 7;
// const int MOD = 998244353;
const ll LINF = 1e18;
// const double PI = atan(1.0) * 4.0;
const ll dx[] = {1, 1, 0, -1, -1, -1, 0, 1};
const ll dy[] = {0, 1, 1, 1, 0, -1, -1, -1};
#define PI 3.141592653589793238
// 1000000007 で割ったあまりを扱う構造体
template <int MOD> struct Fp {
long long val;
constexpr Fp(long long v = 0) noexcept : val(v % MOD) {
if (val < 0)
v += MOD;
}
constexpr int getmod() { return MOD; }
constexpr Fp operator-() const noexcept { return val ? MOD - val : 0; }
constexpr Fp operator+(const Fp &r) const noexcept { return Fp(*this) += r; }
constexpr Fp operator-(const Fp &r) const noexcept { return Fp(*this) -= r; }
constexpr Fp operator*(const Fp &r) const noexcept { return Fp(*this) *= r; }
constexpr Fp operator/(const Fp &r) const noexcept { return Fp(*this) /= r; }
constexpr Fp &operator+=(const Fp &r) noexcept {
val += r.val;
if (val >= MOD)
val -= MOD;
return *this;
}
constexpr Fp &operator-=(const Fp &r) noexcept {
val -= r.val;
if (val < 0)
val += MOD;
return *this;
}
constexpr Fp &operator*=(const Fp &r) noexcept {
val = val * r.val % MOD;
return *this;
}
constexpr Fp &operator/=(const Fp &r) noexcept {
long long a = r.val, 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);
}
val = val * u % MOD;
if (val < 0)
val += MOD;
return *this;
}
constexpr bool operator==(const Fp &r) const noexcept {
return this->val == r.val;
}
constexpr bool operator!=(const Fp &r) const noexcept {
return this->val != r.val;
}
friend constexpr ostream &operator<<(ostream &os, const Fp<MOD> &x) noexcept {
return os << x.val;
}
friend constexpr istream &operator>>(istream &is, Fp<MOD> &x) noexcept {
return is >> x.val;
}
friend constexpr Fp<MOD> modpow(const Fp<MOD> &a, long long n) noexcept {
if (n == 0)
return 1;
auto t = modpow(a, n / 2);
t = t * t;
if (n & 1)
t = t * a;
return t;
}
};
using mint = Fp<MOD>;
const ll NMAX = 1e6;
ll fac[NMAX + 1], inv[NMAX + 1], finv[NMAX + 1];
void cominit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
FOR(i, 2, NMAX + 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;
}
}
ll comb(ll n, ll k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
ll hcomb(ll n, ll k) { return comb(n + k - 1, k); }
signed main() {
LCIN(N, M, K);
cominit();
mint ans = 0;
REP(i, N) REP(j, M) {
ans += (mint)2 * (N - i) * (M - j) * (i + j);
if (i && j)
continue;
ans -= (N - i) * (M - j) * (i + j);
}
ans *= comb(N * M - 2, K - 2);
cout << ans << "\n";
} | [
"control_flow.branch.if.condition.change"
] | 854,356 | 854,357 | u139031151 | cpp |
p03039 | //
// ROIGold.cpp
// Main calisma
//
// Created by Rakhman on 05/02/2019.
// Copyright © 2019 Rakhman. All rights reserved.
//
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <utility>
#include <vector>
#define ios ios_base::sync_with_stdio(0), cout.tie(0), cin.tie(0);
#define S second
#define F first
#define pb push_back
#define nl '\n'
#define NL cout << '\n';
#define EX exit(0)
#define all(s) s.begin(), s.end()
#define FOR(i, start, finish, k) for (int i = start; i <= finish; i += k)
const int MXN = 2e5 + 200;
const long long MNN = 2e3 + 200;
const long long MOD = 1e9 + 7;
const long long INF = 1e18;
const int OO = 1e9 + 500;
typedef long long llong;
typedef unsigned long long ullong;
using namespace std;
llong n, m, k, f[MXN];
llong binpow(llong a, llong b) {
if (b == 0)
return 1;
if (b % 2 == 1)
return binpow(a, b - 1) * a % MOD;
else {
llong x = binpow(a, b / 2);
return x * x % MOD;
}
}
llong C(llong n, llong k) {
llong up = f[n];
llong down = (f[k] * f[n - k]) % MOD;
return (up * binpow(down, MOD - 2)) % MOD;
}
llong d() {
llong num = m - 1;
llong res_x = 0, res_y = 0;
res_x = (num + 1) * (2 * num + 4) * num / 12 % MOD;
res_x = res_x * n * n % MOD;
num = n - 1;
res_y = (num + 1) * (2 * num + 4) * num / 12 % MOD;
res_y = res_y * m * m % MOD;
return (res_x + res_y) % MOD;
}
int main() {
ios;
cin >> n >> m >> k;
f[0] = 1;
for (int i = 1; i <= n * m; i++) {
f[i] = (f[i - 1] * i) % MOD;
}
cout << C(n * m - 2, k - 2) * d();
return 0;
}
| //
// ROIGold.cpp
// Main calisma
//
// Created by Rakhman on 05/02/2019.
// Copyright © 2019 Rakhman. All rights reserved.
//
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <utility>
#include <vector>
#define ios ios_base::sync_with_stdio(0), cout.tie(0), cin.tie(0);
#define S second
#define F first
#define pb push_back
#define nl '\n'
#define NL cout << '\n';
#define EX exit(0)
#define all(s) s.begin(), s.end()
#define FOR(i, start, finish, k) for (int i = start; i <= finish; i += k)
const int MXN = 2e5 + 200;
const long long MNN = 2e3 + 200;
const long long MOD = 1e9 + 7;
const long long INF = 1e18;
const int OO = 1e9 + 500;
typedef long long llong;
typedef unsigned long long ullong;
using namespace std;
llong n, m, k, f[MXN];
llong binpow(llong a, llong b) {
if (b == 0)
return 1;
if (b % 2 == 1)
return binpow(a, b - 1) * a % MOD;
else {
llong x = binpow(a, b / 2);
return x * x % MOD;
}
}
llong C(llong n, llong k) {
llong up = f[n];
llong down = (f[k] * f[n - k]) % MOD;
return (up * binpow(down, MOD - 2)) % MOD;
}
llong d() {
llong num = m - 1;
llong res_x = 0, res_y = 0;
res_x = (num + 1) * (2 * num + 4) * num / 12 % MOD;
res_x = res_x * n * n % MOD;
num = n - 1;
res_y = (num + 1) * (2 * num + 4) * num / 12 % MOD;
res_y = res_y * m * m % MOD;
return (res_x + res_y) % MOD;
}
int main() {
ios;
cin >> n >> m >> k;
f[0] = 1;
for (int i = 1; i <= n * m; i++) {
f[i] = (f[i - 1] * i) % MOD;
}
cout << (C(n * m - 2, k - 2) * d()) % MOD;
return 0;
}
| [
"expression.operation.binary.add"
] | 854,380 | 854,381 | u796195598 | cpp |
p03039 | #define _USE_MATH_DEFINES
#include <bits/stdc++.h>
#define USE_LLONG_AS_INT
#ifdef USE_LLONG_AS_INT
#define int long long
#define inf (1ll << 60)
#else
#define inf (1 << 30)
#endif
#define rep(i, n) for (int i = 0; i < n; i++)
#define Rep(i, a, b) for (int i = a; i < b; i++)
#define REP(i, a, b) for (int i = a; i <= b; i++)
#define rev(i, n) for (int i = (n)-1; i >= 0; i--)
#define vi vector<int>
#define vvi vector<vi>
#define vs vector<string>
#define pb push_back
#define pi pair<int, int>
#define vp vector<pair<int, int>>
#define mp make_pair
#define all(v) (v).begin(), (v).end()
#define fi first
#define se second
#define MEMSET(a) memset(a, 0, sizeof(a))
#define Yes(f) cout << (f ? "Yes" : "No") << endl
#define yes(f) cout << (f ? "yes" : "no") << endl
#define YES(f) cout << (f ? "YES" : "NO") << endl
#define SORT(v) sort(all(v))
#define RSORT(v) sort(all(v), greater<int>())
using namespace std;
const int mod = 1e9 + 7;
const string sp = " ";
void run();
void init() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(12);
}
signed main() {
init();
run();
return 0;
}
class Combination {
private:
vector<int> x, y;
int modpow(int x, int n, int mod = (int)1e9 + 7) {
int ret = 1;
while (n > 0) {
if ((n & 1)) {
ret = ret * x % mod;
}
x = x * x % mod;
n >>= 1;
}
return ret;
}
public:
Combination(int n) {
x.resize(n + 1);
y.resize(n + 1);
x[0] = y[0] = 1;
for (int i = 1; i <= n; i++) {
x[i] = (x[i - 1] * i) % mod;
y[i] = modpow(x[i], mod - 2);
}
}
int get(int n, int r) {
if (n < r)
return 0;
return x[n] * y[n - r] % mod * y[r] % mod;
}
};
void run() {
int n, m, k;
cin >> n >> m >> k;
Combination comb(n * m);
int ans = 0;
rep(i, n - 1) ans = (ans + i * (n - i) % mod * m % mod * m % mod) % mod;
rep(i, m - 1) ans = (ans + i * (m - i) % mod * n % mod * n % mod) % mod;
ans = ans * comb.get(n * m - 2, k - 2);
cout << ans << endl;
} | #define _USE_MATH_DEFINES
#include <bits/stdc++.h>
#define USE_LLONG_AS_INT
#ifdef USE_LLONG_AS_INT
#define int long long
#define inf (1ll << 60)
#else
#define inf (1 << 30)
#endif
#define rep(i, n) for (int i = 0; i < n; i++)
#define Rep(i, a, b) for (int i = a; i < b; i++)
#define REP(i, a, b) for (int i = a; i <= b; i++)
#define rev(i, n) for (int i = (n)-1; i >= 0; i--)
#define vi vector<int>
#define vvi vector<vi>
#define vs vector<string>
#define pb push_back
#define pi pair<int, int>
#define vp vector<pair<int, int>>
#define mp make_pair
#define all(v) (v).begin(), (v).end()
#define fi first
#define se second
#define MEMSET(a) memset(a, 0, sizeof(a))
#define Yes(f) cout << (f ? "Yes" : "No") << endl
#define yes(f) cout << (f ? "yes" : "no") << endl
#define YES(f) cout << (f ? "YES" : "NO") << endl
#define SORT(v) sort(all(v))
#define RSORT(v) sort(all(v), greater<int>())
using namespace std;
const int mod = 1e9 + 7;
const string sp = " ";
void run();
void init() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(12);
}
signed main() {
init();
run();
return 0;
}
class Combination {
private:
vector<int> x, y;
int modpow(int x, int n, int mod = (int)1e9 + 7) {
int ret = 1;
while (n > 0) {
if ((n & 1)) {
ret = ret * x % mod;
}
x = x * x % mod;
n >>= 1;
}
return ret;
}
public:
Combination(int n) {
x.resize(n + 1);
y.resize(n + 1);
x[0] = y[0] = 1;
for (int i = 1; i <= n; i++) {
x[i] = (x[i - 1] * i) % mod;
y[i] = modpow(x[i], mod - 2);
}
}
int get(int n, int r) {
if (n < r)
return 0;
return x[n] * y[n - r] % mod * y[r] % mod;
}
};
void run() {
int n, m, k;
cin >> n >> m >> k;
Combination comb(n * m);
int ans = 0;
rep(i, n) ans = (ans + i * (n - i) % mod * m % mod * m % mod) % mod;
rep(i, m) ans = (ans + i * (m - i) % mod * n % mod * n % mod) % mod;
ans = ans * comb.get(n * m - 2, k - 2) % mod;
cout << ans << endl;
} | [
"expression.operation.binary.remove",
"assignment.change"
] | 854,384 | 854,385 | u128527648 | cpp |
p03039 | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <utility>
#include <vector>
#define INF 1e9 + 7
#define rep(i, n) for (int i = 0; i < n; i++)
#define NO cout << "NO" << endl;
#define YES cout << "YES" << endl;
#define No cout << "No" << endl;
#define Yes cout << "Yes" << endl;
#define all(a) a.begin(), a.end()
#define P pair<int, int>
using namespace std;
typedef long long int ll;
typedef unsigned long long int ull;
//(int)'a'は97 (int)'A'は65 (int)'1'は49
//おまじない
const int maxn = 200000;
ll fac[maxn];
ll rfac[maxn];
ll mod = INF;
ll pow(ll x, ll y) {
if (y == 0) {
return 1;
} else if (y == 1) {
return x;
} else if (y % 2 == 0) {
ll a = pow(x, y / 2);
return (a * a) % mod;
} else {
ll a = pow(x, (y - 1) / 2);
return a * a % mod * x % mod;
}
}
int main() {
ll h, w, k;
ll ans = 0;
cin >> h >> w >> k;
fac[0] = fac[1] = rfac[0] = rfac[1] = 1;
for (ll i = 1; i <= w; i++) {
ans = (ans + (w - i) * i % mod * (h * h) % mod) % mod;
}
for (ll i = 1; i <= w; i++) {
ans = (ans + (h - i) * i % mod * (w * w) % mod) % mod;
}
for (ll i = 1; i <= h * w; i++) {
fac[i] = fac[i - 1] * i % mod;
}
rfac[h * w] = pow(fac[h * w], INF - 2);
for (ll i = h * w; i >= 1; i--) {
rfac[i - 1] = rfac[i] * i % mod;
}
ll comb = fac[h * w - 2] * rfac[h * w - k] % mod * rfac[k - 2] % mod;
ans = ans * comb % mod;
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <utility>
#include <vector>
#define INF 1e9 + 7
#define rep(i, n) for (int i = 0; i < n; i++)
#define NO cout << "NO" << endl;
#define YES cout << "YES" << endl;
#define No cout << "No" << endl;
#define Yes cout << "Yes" << endl;
#define all(a) a.begin(), a.end()
#define P pair<int, int>
using namespace std;
typedef long long int ll;
typedef unsigned long long int ull;
//(int)'a'は97 (int)'A'は65 (int)'1'は49
//おまじない
const int maxn = 200000;
ll fac[maxn];
ll rfac[maxn];
ll mod = INF;
ll pow(ll x, ll y) {
if (y == 0) {
return 1;
} else if (y == 1) {
return x;
} else if (y % 2 == 0) {
ll a = pow(x, y / 2);
return (a * a) % mod;
} else {
ll a = pow(x, (y - 1) / 2);
return a * a % mod * x % mod;
}
}
int main() {
ll h, w, k;
ll ans = 0;
cin >> h >> w >> k;
fac[0] = fac[1] = rfac[0] = rfac[1] = 1;
for (ll i = 1; i <= w; i++) {
ans = (ans + (w - i) * i % mod * (h * h) % mod) % mod;
}
for (ll i = 1; i <= h; i++) {
ans = (ans + (h - i) * i % mod * (w * w) % mod) % mod;
}
for (ll i = 1; i <= h * w; i++) {
fac[i] = fac[i - 1] * i % mod;
}
rfac[h * w] = pow(fac[h * w], INF - 2);
for (ll i = h * w; i >= 1; i--) {
rfac[i - 1] = rfac[i] * i % mod;
}
ll comb = fac[h * w - 2] * rfac[h * w - k] % mod * rfac[k - 2] % mod;
ans = ans * comb % mod;
cout << ans << endl;
return 0;
}
| [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 854,415 | 854,416 | u297203024 | cpp |
p03039 | #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 10001
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;
}
| [
"preprocessor.define.value.change",
"literal.integer.change"
] | 854,425 | 854,424 | u576106056 | cpp |
p03039 | #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 10001
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(d, N - 1) {
int yCombi = mod_mul(mod_mul(N - d, M), M);
ans = mod_add(ans, mod_mul(d, 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;
}
| [
"preprocessor.define.value.change",
"literal.integer.change",
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change",
"assignment.value.change"
] | 854,426 | 854,424 | u576106056 | cpp |
p03039 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll N, M, K;
const ll MAX = 4000010;
const ll MOD = 1e9 + 7;
long long fac[MAX], finv[MAX], inv[MAX];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (ll i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
long long COM(ll n, ll k) {
if (n < k) {
return 0;
}
if (n < 0 || k < 0) {
return 0;
}
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
ll number(ll a, ll b) {
if (a == 0 || b == 0) {
return ((N - a) * (M - b)) % MOD;
} else {
return (2 * (N - a) * (M - b)) % MOD;
}
}
int main() {
cin >> N >> M >> K;
ll ans = 0;
for (ll X = 0; X < N; X++) {
for (ll Y = 0; Y < M; Y++) {
ans += (X + Y) * number(X, Y) * COM(N * M - 2, K - 2);
ans %= MOD;
}
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll N, M, K;
const ll MAX = 4000010;
const ll MOD = 1e9 + 7;
long long fac[MAX], finv[MAX], inv[MAX];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (ll i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
long long COM(ll n, ll k) {
if (n < k) {
return 0;
}
if (n < 0 || k < 0) {
return 0;
}
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
ll number(ll a, ll b) {
if (a == 0 || b == 0) {
return ((N - a) * (M - b)) % MOD;
} else {
return (2 * (N - a) * (M - b)) % MOD;
}
}
int main() {
cin >> N >> M >> K;
COMinit();
ll ans = 0;
for (ll X = 0; X < N; X++) {
for (ll Y = 0; Y < M; Y++) {
ans += (X + Y) * number(X, Y) * COM(N * M - 2, K - 2);
ans %= MOD;
}
}
cout << ans << endl;
return 0;
} | [
"call.add"
] | 854,435 | 854,436 | u904123392 | cpp |
p03039 | //#pragma GCC optimize("O3")
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/rope>
#define mem(a, v) memset((a), (v), sizeof(a))
#define enl printf("\n")
#define case (t) printf("Case #%d: ", (t))
#define ni(n) scanf("%d", &(n))
#define nl(n) scanf("%lld", &(n))
#define nai(a, n) \
for (int i = 0; i < (n); i++) \
ni(a[i])
#define nal(a, n) \
for (int i = 0; i < (n); i++) \
nl(a[i])
#define pri(n) printf("%d\n", (n))
#define prl(n) printf("%lld\n", (n))
#define pii pair<int, int>
#define pil pair<int, long long>
#define pll pair<long long, long long>
#define vii vector<pii>
#define vil vector<pil>
#define vll vector<pll>
#define vi vector<int>
#define vl vector<long long>
#define pb push_back
#define mp make_pair
#define fi first
#define se second
using namespace std;
using namespace __gnu_pbds;
typedef long long ll;
typedef cc_hash_table<int, int, hash<int>> ht;
typedef tree<int, null_type, less<int>, rb_tree_tag,
tree_order_statistics_node_update>
oset;
const double pi = acos(-1);
const int MOD = 1e9 + 7;
const int INF = 1e9 + 7;
const int MAXN = 2e5 + 5;
const double eps = 1e-9;
ll fac[MAXN], ifac[MAXN];
ll pw(ll a, ll b) {
ll r = 1;
while (b)
if (b & 1)
r = (r * a) % MOD, b--;
else
a = (a * a) % MOD, b /= 2ll;
return r;
}
inline ll inv(ll x) { return pw(x, MOD - 2); }
inline ll bin(ll n, ll k) {
return (fac[n] * ifac[k] % MOD) * ifac[n - k] % MOD;
}
int main() {
fac[0] = ifac[0] = 1;
for (ll i = 1; i < MAXN; i++)
fac[i] = fac[i - 1] * i % MOD, ifac[i] = inv(fac[i]);
ll n, m, k;
scanf("%lld %lld %lld", &n, &m, &k);
ll ans = 0, dx = 0, dy = 0;
for (ll i = 1; i < n; i++)
dx = (dx + i * (n - i) % MOD) % MOD;
dx = dx * (m * m % MOD) % MOD;
for (ll i = 1; i < m; i++)
dy = (dy + i * (m - i) % MOD) % MOD;
dy = dy * (m * m % MOD) % MOD;
ans = (dx + dy) % MOD;
ans = (ans * bin(n * m - 2, k - 2)) % MOD;
prl(ans);
return 0;
}
| //#pragma GCC optimize("O3")
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/rope>
#define mem(a, v) memset((a), (v), sizeof(a))
#define enl printf("\n")
#define case (t) printf("Case #%d: ", (t))
#define ni(n) scanf("%d", &(n))
#define nl(n) scanf("%lld", &(n))
#define nai(a, n) \
for (int i = 0; i < (n); i++) \
ni(a[i])
#define nal(a, n) \
for (int i = 0; i < (n); i++) \
nl(a[i])
#define pri(n) printf("%d\n", (n))
#define prl(n) printf("%lld\n", (n))
#define pii pair<int, int>
#define pil pair<int, long long>
#define pll pair<long long, long long>
#define vii vector<pii>
#define vil vector<pil>
#define vll vector<pll>
#define vi vector<int>
#define vl vector<long long>
#define pb push_back
#define mp make_pair
#define fi first
#define se second
using namespace std;
using namespace __gnu_pbds;
typedef long long ll;
typedef cc_hash_table<int, int, hash<int>> ht;
typedef tree<int, null_type, less<int>, rb_tree_tag,
tree_order_statistics_node_update>
oset;
const double pi = acos(-1);
const int MOD = 1e9 + 7;
const int INF = 1e9 + 7;
const int MAXN = 2e5 + 5;
const double eps = 1e-9;
ll fac[MAXN], ifac[MAXN];
ll pw(ll a, ll b) {
ll r = 1;
while (b)
if (b & 1)
r = (r * a) % MOD, b--;
else
a = (a * a) % MOD, b /= 2ll;
return r;
}
inline ll inv(ll x) { return pw(x, MOD - 2); }
inline ll bin(ll n, ll k) {
return (fac[n] * ifac[k] % MOD) * ifac[n - k] % MOD;
}
int main() {
fac[0] = ifac[0] = 1;
for (ll i = 1; i < MAXN; i++)
fac[i] = fac[i - 1] * i % MOD, ifac[i] = inv(fac[i]);
ll n, m, k;
scanf("%lld %lld %lld", &n, &m, &k);
ll ans = 0, dx = 0, dy = 0;
for (ll i = 1; i < n; i++)
dx = (dx + (i * (n - i) % MOD)) % MOD;
dx = dx * (m * m % MOD) % MOD;
for (ll i = 1; i < m; i++)
dy = (dy + (i * (m - i) % MOD)) % MOD;
dy = dy * (n * n % MOD) % MOD;
ans = (dx + dy) % MOD;
ans = (ans * bin(n * m - 2, k - 2)) % MOD;
prl(ans);
return 0;
}
| [
"assignment.value.change",
"identifier.change",
"expression.operation.binary.change"
] | 854,437 | 854,438 | u270920804 | cpp |
p03039 | #include <bits/stdc++.h>
using namespace std;
using Int = long long;
// BEGIN CUT HERE
template <typename T, T MOD = 1000000007> struct Mint {
static constexpr T mod = MOD;
T v;
Mint() : v(0) {}
Mint(signed v) : v(v) {}
Mint(long long t) {
v = t % MOD;
if (v < 0)
v += MOD;
}
Mint pow(long long k) {
Mint res(1), tmp(v);
while (k) {
if (k & 1)
res *= tmp;
tmp *= tmp;
k >>= 1;
}
return res;
}
static Mint add_identity() { return Mint(0); }
static Mint mul_identity() { return Mint(1); }
Mint inv() { return pow(MOD - 2); }
Mint &operator+=(Mint a) {
v += a.v;
if (v >= MOD)
v -= MOD;
return *this;
}
Mint &operator-=(Mint a) {
v += MOD - a.v;
if (v >= MOD)
v -= MOD;
return *this;
}
Mint &operator*=(Mint a) {
v = 1LL * v * a.v % MOD;
return *this;
}
Mint &operator/=(Mint a) { return (*this) *= a.inv(); }
Mint operator+(Mint a) const { return Mint(v) += a; };
Mint operator-(Mint a) const { return Mint(v) -= a; };
Mint operator*(Mint a) const { return Mint(v) *= a; };
Mint operator/(Mint a) const { return Mint(v) /= a; };
Mint operator-() const { return v ? Mint(MOD - v) : Mint(v); }
bool operator==(const Mint a) const { return v == a.v; }
bool operator!=(const Mint a) const { return v != a.v; }
bool operator<(const Mint a) const { return v < a.v; }
// find x s.t. a^x = b
static T log(T a, T b) {
const T sq = 40000;
unordered_map<T, T> dp;
dp.reserve(sq);
Mint res(1);
for (int r = 0; r < sq; r++) {
if (!dp.count(res.v))
dp[res.v] = r;
res *= a;
}
Mint p = Mint(a).inv().pow(sq);
res = b;
for (int q = 0; q <= MOD / sq + 1; q++) {
if (dp.count(res.v)) {
T idx = q * sq + dp[res.v];
if (idx > 0)
return idx;
}
res *= p;
}
assert(0);
return T(-1);
}
static Mint comb(long long n, int k) {
Mint num(1), dom(1);
for (int i = 0; i < k; i++) {
num *= Mint(n - i);
dom *= Mint(i + 1);
}
return num / dom;
}
};
template <typename T, T MOD> constexpr T Mint<T, MOD>::mod;
template <typename T, T MOD> ostream &operator<<(ostream &os, Mint<T, MOD> m) {
os << m;
return os;
}
// END CUT HERE
template <typename R> struct Kitamasa {
using VR = vector<R>;
VR c;
vector<VR> rs;
int m;
Kitamasa(const VR &C) : c(C), rs(1), m(c.size()) {
rs[0].assign(2 * m + 1, R::add_identity());
rs[0][1] = R::mul_identity();
}
VR merge(const VR &x, const VR &y) {
VR z(2 * m + 1, R::add_identity());
for (int i = 1; i <= m; i++)
for (int j = 1; j <= m; j++)
z[i + j] = z[i + j] + (x[i] * y[j]);
for (int i = 2 * m; i > m; z[i--] = R::add_identity())
for (int j = 1; j <= m; j++)
z[i - j] = z[i - j] + (c[m - j] * z[i]);
return z;
}
R calc(const VR &A, long long n) {
assert((int)A.size() == m);
VR res(rs[0]);
for (int i = 0; n; i++, n >>= 1) {
if (i >= (int)rs.size())
rs.emplace_back(merge(rs[i - 1], rs[i - 1]));
if (~n & 1)
continue;
res = merge(res, rs[i]);
}
R ans = R::add_identity();
for (int i = 1; i <= m; i++)
ans = ans + (res[i] * A[i - 1]);
return ans;
}
};
template <typename T> T extgcd(T a, T b, T &x, T &y) {
T d = a;
if (b != 0) {
d = extgcd(b, a % b, y, x);
y -= (a / b) * x;
} else {
x = 1;
y = 0;
}
return d;
}
template <typename T> T mod_inverse(T a, T mod) {
T x, y;
extgcd(a, mod, x, y);
return (mod + x % mod) % mod;
}
// INSERT ABOVE HERE
signed CFR536_F() {
const int MOD = 998244353;
using M = Mint<int, MOD>;
using P = Mint<int, MOD - 1>;
cin.tie(0);
ios::sync_with_stdio(0);
int k;
cin >> k;
vector<P> bs(k);
for (int i = 0; i < k; i++) {
int b;
cin >> b;
bs[i] = P(b);
}
int n, m;
cin >> n >> m;
reverse(bs.begin(), bs.end());
Kitamasa<P> ktms(bs);
vector<P> as(k, 0);
as[k - 1] = 1;
int v = ktms.calc(as, --n).v;
int h = M::log(3, m) % (MOD - 1);
if (v != 0 || h != 0) {
int g = __gcd(v, h);
v /= g;
h /= g;
}
if (h != 0 && __gcd(v, MOD - 1) != 1) {
cout << -1 << endl;
return 0;
}
cout << M(3).pow((long long)h * mod_inverse(v, MOD - 1)).v << endl;
return 0;
}
/*
verified on 2019/05/26
https://codeforces.com/contest/1106/problem/F
*/
signed ABC127_E() {
cin.tie(0);
ios::sync_with_stdio(0);
int h, w, k;
cin >> h >> w >> k;
using M = Mint<int>;
M ans{0};
for (int d = 1; d < h; d++)
ans += M(d) * M(h - d) * M(w) * M(w);
for (int d = 1; d < w; d++)
ans += M(d) * M(w - d) * M(h) * M(h);
ans *= M::comb(h * w - 2, k - 2);
cout << ans << endl;
return 0;
}
/*
verified on 2019/05/26
https://atcoder.jp/contests/abc127/tasks/abc127_e
*/
signed main() {
// CFR536_F();
ABC127_E();
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using Int = long long;
// BEGIN CUT HERE
template <typename T, T MOD = 1000000007> struct Mint {
static constexpr T mod = MOD;
T v;
Mint() : v(0) {}
Mint(signed v) : v(v) {}
Mint(long long t) {
v = t % MOD;
if (v < 0)
v += MOD;
}
Mint pow(long long k) {
Mint res(1), tmp(v);
while (k) {
if (k & 1)
res *= tmp;
tmp *= tmp;
k >>= 1;
}
return res;
}
static Mint add_identity() { return Mint(0); }
static Mint mul_identity() { return Mint(1); }
Mint inv() { return pow(MOD - 2); }
Mint &operator+=(Mint a) {
v += a.v;
if (v >= MOD)
v -= MOD;
return *this;
}
Mint &operator-=(Mint a) {
v += MOD - a.v;
if (v >= MOD)
v -= MOD;
return *this;
}
Mint &operator*=(Mint a) {
v = 1LL * v * a.v % MOD;
return *this;
}
Mint &operator/=(Mint a) { return (*this) *= a.inv(); }
Mint operator+(Mint a) const { return Mint(v) += a; };
Mint operator-(Mint a) const { return Mint(v) -= a; };
Mint operator*(Mint a) const { return Mint(v) *= a; };
Mint operator/(Mint a) const { return Mint(v) /= a; };
Mint operator-() const { return v ? Mint(MOD - v) : Mint(v); }
bool operator==(const Mint a) const { return v == a.v; }
bool operator!=(const Mint a) const { return v != a.v; }
bool operator<(const Mint a) const { return v < a.v; }
// find x s.t. a^x = b
static T log(T a, T b) {
const T sq = 40000;
unordered_map<T, T> dp;
dp.reserve(sq);
Mint res(1);
for (int r = 0; r < sq; r++) {
if (!dp.count(res.v))
dp[res.v] = r;
res *= a;
}
Mint p = Mint(a).inv().pow(sq);
res = b;
for (int q = 0; q <= MOD / sq + 1; q++) {
if (dp.count(res.v)) {
T idx = q * sq + dp[res.v];
if (idx > 0)
return idx;
}
res *= p;
}
assert(0);
return T(-1);
}
static Mint comb(long long n, int k) {
Mint num(1), dom(1);
for (int i = 0; i < k; i++) {
num *= Mint(n - i);
dom *= Mint(i + 1);
}
return num / dom;
}
};
template <typename T, T MOD> constexpr T Mint<T, MOD>::mod;
template <typename T, T MOD> ostream &operator<<(ostream &os, Mint<T, MOD> m) {
os << m.v;
return os;
}
// END CUT HERE
template <typename R> struct Kitamasa {
using VR = vector<R>;
VR c;
vector<VR> rs;
int m;
Kitamasa(const VR &C) : c(C), rs(1), m(c.size()) {
rs[0].assign(2 * m + 1, R::add_identity());
rs[0][1] = R::mul_identity();
}
VR merge(const VR &x, const VR &y) {
VR z(2 * m + 1, R::add_identity());
for (int i = 1; i <= m; i++)
for (int j = 1; j <= m; j++)
z[i + j] = z[i + j] + (x[i] * y[j]);
for (int i = 2 * m; i > m; z[i--] = R::add_identity())
for (int j = 1; j <= m; j++)
z[i - j] = z[i - j] + (c[m - j] * z[i]);
return z;
}
R calc(const VR &A, long long n) {
assert((int)A.size() == m);
VR res(rs[0]);
for (int i = 0; n; i++, n >>= 1) {
if (i >= (int)rs.size())
rs.emplace_back(merge(rs[i - 1], rs[i - 1]));
if (~n & 1)
continue;
res = merge(res, rs[i]);
}
R ans = R::add_identity();
for (int i = 1; i <= m; i++)
ans = ans + (res[i] * A[i - 1]);
return ans;
}
};
template <typename T> T extgcd(T a, T b, T &x, T &y) {
T d = a;
if (b != 0) {
d = extgcd(b, a % b, y, x);
y -= (a / b) * x;
} else {
x = 1;
y = 0;
}
return d;
}
template <typename T> T mod_inverse(T a, T mod) {
T x, y;
extgcd(a, mod, x, y);
return (mod + x % mod) % mod;
}
// INSERT ABOVE HERE
signed CFR536_F() {
const int MOD = 998244353;
using M = Mint<int, MOD>;
using P = Mint<int, MOD - 1>;
cin.tie(0);
ios::sync_with_stdio(0);
int k;
cin >> k;
vector<P> bs(k);
for (int i = 0; i < k; i++) {
int b;
cin >> b;
bs[i] = P(b);
}
int n, m;
cin >> n >> m;
reverse(bs.begin(), bs.end());
Kitamasa<P> ktms(bs);
vector<P> as(k, 0);
as[k - 1] = 1;
int v = ktms.calc(as, --n).v;
int h = M::log(3, m) % (MOD - 1);
if (v != 0 || h != 0) {
int g = __gcd(v, h);
v /= g;
h /= g;
}
if (h != 0 && __gcd(v, MOD - 1) != 1) {
cout << -1 << endl;
return 0;
}
cout << M(3).pow((long long)h * mod_inverse(v, MOD - 1)).v << endl;
return 0;
}
/*
verified on 2019/06/12
https://codeforces.com/contest/1106/problem/F
*/
signed ABC127_E() {
cin.tie(0);
ios::sync_with_stdio(0);
int h, w, k;
cin >> h >> w >> k;
using M = Mint<int>;
M ans{0};
for (int d = 1; d < h; d++)
ans += M(d) * M(h - d) * M(w) * M(w);
for (int d = 1; d < w; d++)
ans += M(d) * M(w - d) * M(h) * M(h);
ans *= M::comb(h * w - 2, k - 2);
cout << ans << endl;
return 0;
}
/*
verified on 2019/06/12
https://atcoder.jp/contests/abc127/tasks/abc127_e
*/
signed main() {
// CFR536_F();
ABC127_E();
return 0;
}
| [] | 854,454 | 854,455 | u687214625 | cpp |
p03039 | #define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <cassert>
#include <complex>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <time.h>
#include <typeinfo>
#include <unordered_map>
#include <utility>
#include <vector>
using namespace std;
#define Ma_PI 3.141592653589793
#define eps 0.00000001
#define LONG_INF 300000000000000000
#define GOLD 1.61803398874989484820458
#define MAX_MOD 1000000007
#define MOD 998244353
#define REP(i, n) for (long long i = 0; i < n; ++i)
#define seg_size 524288
double dot(complex<double> a, complex<double> b) {
return a.real() * b.real() + a.imag() * b.imag();
}
double gyaku_dot(complex<double> a, complex<double> b) {
return a.real() * b.imag() - a.imag() * b.real();
}
double leng(complex<double> a) {
return sqrt(a.real() * a.real() + a.imag() * a.imag());
}
double angles(complex<double> a, complex<double> b) {
double cosine = dot(a, b) / (leng(a) * leng(b));
double sine = gyaku_dot(a, b) / (leng(a) * leng(b));
double kaku = acos(cosine);
if (sine <= 0) {
kaku = 2 * Ma_PI - kaku;
}
return kaku;
}
vector<int> convex_hull(vector<complex<double>> a) {
vector<int> ans;
double now_minnest = a[0].real();
int now_itr = 0;
REP(i, a.size()) {
if (now_minnest > a[i].real()) {
now_minnest = a[i].real();
now_itr = i;
}
}
ans.push_back(now_itr);
complex<double> ba(0, 1);
while (true) {
int now_go = 0;
double now_min = 0;
int starter = ans[ans.size() - 1];
for (int i = 0; i < a.size(); ++i) {
if (i != starter) {
double goa = angles(ba, a[i] - a[starter]);
if (goa > now_min) {
now_min = goa;
now_go = i;
}
}
}
if (now_go == ans[0])
break;
ans.push_back(now_go);
ba = complex<double>(a[now_go] - a[starter]);
}
return ans;
}
unsigned long xor128() {
static unsigned long x = 123456789, y = 362436069, z = 521288629,
w = 88675123;
unsigned long t = (x ^ (x << 11));
x = y;
y = z;
z = w;
return (w = (w ^ (w >> 19)) ^ (t ^ (t >> 8)));
}
long long gcd(long long a, long long b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
pair<long long, long long> seg_tree[seg_size * 4];
pair<long long, long long> seg_find(long long now, long long n_l, long long n_r,
long long w_l, long long w_r) {
if (w_l <= n_l && n_r <= w_r)
return seg_tree[now];
if (n_r <= w_l || w_r <= n_l)
return make_pair(0, 0);
pair<long long, long long> a = seg_find(now * 2, n_l, (n_l + n_r) / 2, w_l,
w_r),
b = seg_find(now * 2 + 1, (n_l + n_r) / 2, n_r,
w_l, w_r);
a.first += b.first;
a.second += b.second;
return a;
}
long long seg_set(int now) {
seg_tree[now] =
make_pair(seg_tree[now * 2].first + seg_tree[now * 2 + 1].first,
seg_tree[now * 2].second + seg_tree[now * 2 + 1].second);
if (now != 1)
seg_set(now / 2);
return 0;
}
long long inv(long long now) {
long long now_go = MAX_MOD - 2LL;
long long ans = 1;
while (now_go != 0) {
if (now_go % 2 == 1) {
ans *= now;
ans %= MAX_MOD;
}
now *= now;
now %= MAX_MOD;
now_go /= 2;
}
return ans;
}
int gcd(int a, int b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
long long combi(long long a, long long b) {
long long ans = 1;
for (long long i = 0; i < b; ++i) {
ans *= a - i;
ans %= MAX_MOD;
ans *= inv(i + 1);
ans %= MAX_MOD;
}
return ans;
}
int main() {
long long n, m, k;
cin >> n >> m >> k;
long long ans = 0;
REP(i, 2) {
long long nya = combi(n * m - 2, k - 2);
for (long long i = 1; i < n; ++i) {
long long geko = m * m * (n - i);
geko %= MAX_MOD;
geko *= nya;
geko %= MAX_MOD;
ans += geko;
ans %= MAX_MOD;
}
swap(n, m);
}
cout << ans << endl;
} | #define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <cassert>
#include <complex>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <time.h>
#include <typeinfo>
#include <unordered_map>
#include <utility>
#include <vector>
using namespace std;
#define Ma_PI 3.141592653589793
#define eps 0.00000001
#define LONG_INF 300000000000000000
#define GOLD 1.61803398874989484820458
#define MAX_MOD 1000000007
#define MOD 998244353
#define REP(i, n) for (long long i = 0; i < n; ++i)
#define seg_size 524288
double dot(complex<double> a, complex<double> b) {
return a.real() * b.real() + a.imag() * b.imag();
}
double gyaku_dot(complex<double> a, complex<double> b) {
return a.real() * b.imag() - a.imag() * b.real();
}
double leng(complex<double> a) {
return sqrt(a.real() * a.real() + a.imag() * a.imag());
}
double angles(complex<double> a, complex<double> b) {
double cosine = dot(a, b) / (leng(a) * leng(b));
double sine = gyaku_dot(a, b) / (leng(a) * leng(b));
double kaku = acos(cosine);
if (sine <= 0) {
kaku = 2 * Ma_PI - kaku;
}
return kaku;
}
vector<int> convex_hull(vector<complex<double>> a) {
vector<int> ans;
double now_minnest = a[0].real();
int now_itr = 0;
REP(i, a.size()) {
if (now_minnest > a[i].real()) {
now_minnest = a[i].real();
now_itr = i;
}
}
ans.push_back(now_itr);
complex<double> ba(0, 1);
while (true) {
int now_go = 0;
double now_min = 0;
int starter = ans[ans.size() - 1];
for (int i = 0; i < a.size(); ++i) {
if (i != starter) {
double goa = angles(ba, a[i] - a[starter]);
if (goa > now_min) {
now_min = goa;
now_go = i;
}
}
}
if (now_go == ans[0])
break;
ans.push_back(now_go);
ba = complex<double>(a[now_go] - a[starter]);
}
return ans;
}
unsigned long xor128() {
static unsigned long x = 123456789, y = 362436069, z = 521288629,
w = 88675123;
unsigned long t = (x ^ (x << 11));
x = y;
y = z;
z = w;
return (w = (w ^ (w >> 19)) ^ (t ^ (t >> 8)));
}
long long gcd(long long a, long long b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
pair<long long, long long> seg_tree[seg_size * 4];
pair<long long, long long> seg_find(long long now, long long n_l, long long n_r,
long long w_l, long long w_r) {
if (w_l <= n_l && n_r <= w_r)
return seg_tree[now];
if (n_r <= w_l || w_r <= n_l)
return make_pair(0, 0);
pair<long long, long long> a = seg_find(now * 2, n_l, (n_l + n_r) / 2, w_l,
w_r),
b = seg_find(now * 2 + 1, (n_l + n_r) / 2, n_r,
w_l, w_r);
a.first += b.first;
a.second += b.second;
return a;
}
long long seg_set(int now) {
seg_tree[now] =
make_pair(seg_tree[now * 2].first + seg_tree[now * 2 + 1].first,
seg_tree[now * 2].second + seg_tree[now * 2 + 1].second);
if (now != 1)
seg_set(now / 2);
return 0;
}
long long inv(long long now) {
long long now_go = MAX_MOD - 2LL;
long long ans = 1;
while (now_go != 0) {
if (now_go % 2 == 1) {
ans *= now;
ans %= MAX_MOD;
}
now *= now;
now %= MAX_MOD;
now_go /= 2;
}
return ans;
}
int gcd(int a, int b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
long long combi(long long a, long long b) {
long long ans = 1;
for (long long i = 0; i < b; ++i) {
ans *= a - i;
ans %= MAX_MOD;
ans *= inv(i + 1);
ans %= MAX_MOD;
}
return ans;
}
int main() {
long long n, m, k;
cin >> n >> m >> k;
long long ans = 0;
REP(tea, 2) {
long long nya = combi(n * m - 2, k - 2);
for (long long i = 1; i < n; ++i) {
long long geko = m * m * (n - i) * i;
geko %= MAX_MOD;
geko *= nya;
geko %= MAX_MOD;
ans += geko;
ans %= MAX_MOD;
}
swap(n, m);
}
cout << ans << endl;
} | [
"identifier.change",
"call.arguments.change"
] | 854,473 | 854,474 | u545022164 | cpp |
p03039 | #include <algorithm>
#include <cmath>
#include <iostream>
// あまり大きな数字を入れると桁溢れする
template <typename T> T comb(T n, T r) {
// 組み合わせ計算時のかぶっている部分を取り除く
r = std::min(n - r, r);
T result = 1;
T div = 1;
for (T i = 1; i <= r; ++i) {
result = (result * (n - i + 1));
// result = result / i;
div = div * i;
}
return result / div;
}
// 値が大きくなる時の対処用のクラス
template <typename T, T MOD> class mod_int {
private:
typedef mod_int<T, MOD> mint;
T inverse(T x) {
T pow = MOD - 2;
T result = 1;
for (; pow; pow >>= 1, x = x * x % MOD) {
if (pow & 1)
result = result * x % MOD;
}
return result;
}
public:
T val;
// コンストラクタ
mod_int() : val(0) {}
mod_int(const mint &o) : val(o.val % MOD) {}
mod_int(const T &o) : val(o % MOD) {}
mint &operator+=(const mint &o) {
val = (val + o.val) % MOD;
return *this;
}
mint &operator-=(const mint &o) {
val = (val + MOD - o.val) % MOD;
return *this;
}
mint &operator*=(const mint &o) {
val = (val * o.val) % MOD;
return *this;
}
mint &operator/=(const mint &o) {
val = (val * inverse(o.val)) % MOD;
return *this;
}
mint &operator++() {
val = (++val) % MOD;
return *this;
}
mint &operator--() {
val = (--val) % MOD;
return *this;
}
mint operator+(const mint &o) const { return mint(*this) += o; }
mint operator-(const mint &o) const { return mint(*this) -= o; }
mint operator*(const mint &o) const { return mint(*this) *= o; }
mint operator/(const mint &o) const { return mint(*this) /= o; }
void operator=(const mint &o) { this->val = o.val; }
void operator=(const int i) { this->val = i; }
void operator=(const T i) { this->val = i; }
bool operator<(const mint &o) const { return val < o.val; }
bool operator<=(const mint &o) const { return val <= o.val; }
bool operator==(const mint &o) const { return val == o.val; }
};
// ioのオーバーライド
template <typename T, T MOD>
std::istream &operator>>(std::istream &i, mod_int<T, MOD> &o) {
i >> o.val;
return i;
}
template <typename T, T MOD>
std::ostream &operator<<(std::ostream &i, mod_int<T, MOD> &o) {
i << o.val;
return i;
}
// 使うクラスのおまじない
typedef mod_int<uint64_t, 1000 * 1000 * 1000 + 7> muint64_t;
int main() {
muint64_t N, M, K;
std::cin >> N >> M >> K;
muint64_t xsum = 0;
muint64_t M2 = M * M;
for (muint64_t xdiff = 1; xdiff <= N; ++xdiff) {
xsum = xsum + xdiff * M2 * (N - xdiff);
}
muint64_t ysum = 0;
muint64_t N2 = N * N;
for (muint64_t ydiff = 1; ydiff <= N; ++ydiff) {
ysum = ysum + ydiff * N2 * (M - ydiff);
}
// uint64_t result = (xsum + ysum) * p / k % (1000 * 1000 * 1000 + 7);
muint64_t result = (xsum + ysum) * comb(N * M - 2, K - 2);
std::cout << result << std::endl;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <iostream>
// あまり大きな数字を入れると桁溢れする
template <typename T> T comb(T n, T r) {
// 組み合わせ計算時のかぶっている部分を取り除く
r = std::min(n - r, r);
T result = 1;
T div = 1;
for (T i = 1; i <= r; ++i) {
result = (result * (n - i + 1));
// result = result / i;
div = div * i;
}
return result / div;
}
// 値が大きくなる時の対処用のクラス
template <typename T, T MOD> class mod_int {
private:
typedef mod_int<T, MOD> mint;
T inverse(T x) {
T pow = MOD - 2;
T result = 1;
for (; pow; pow >>= 1, x = x * x % MOD) {
if (pow & 1)
result = result * x % MOD;
}
return result;
}
public:
T val;
// コンストラクタ
mod_int() : val(0) {}
mod_int(const mint &o) : val(o.val % MOD) {}
mod_int(const T &o) : val(o % MOD) {}
mint &operator+=(const mint &o) {
val = (val + o.val) % MOD;
return *this;
}
mint &operator-=(const mint &o) {
val = (val + MOD - o.val) % MOD;
return *this;
}
mint &operator*=(const mint &o) {
val = (val * o.val) % MOD;
return *this;
}
mint &operator/=(const mint &o) {
val = (val * inverse(o.val)) % MOD;
return *this;
}
mint &operator++() {
val = (++val) % MOD;
return *this;
}
mint &operator--() {
val = (--val) % MOD;
return *this;
}
mint operator+(const mint &o) const { return mint(*this) += o; }
mint operator-(const mint &o) const { return mint(*this) -= o; }
mint operator*(const mint &o) const { return mint(*this) *= o; }
mint operator/(const mint &o) const { return mint(*this) /= o; }
void operator=(const mint &o) { this->val = o.val; }
void operator=(const int i) { this->val = i; }
void operator=(const T i) { this->val = i; }
bool operator<(const mint &o) const { return val < o.val; }
bool operator<=(const mint &o) const { return val <= o.val; }
bool operator==(const mint &o) const { return val == o.val; }
};
// ioのオーバーライド
template <typename T, T MOD>
std::istream &operator>>(std::istream &i, mod_int<T, MOD> &o) {
i >> o.val;
return i;
}
template <typename T, T MOD>
std::ostream &operator<<(std::ostream &i, mod_int<T, MOD> &o) {
i << o.val;
return i;
}
// 使うクラスのおまじない
typedef mod_int<uint64_t, 1000 * 1000 * 1000 + 7> muint64_t;
int main() {
muint64_t N, M, K;
std::cin >> N >> M >> K;
muint64_t xsum = 0;
muint64_t M2 = M * M;
for (muint64_t xdiff = 1; xdiff <= N; ++xdiff) {
xsum = xsum + xdiff * M2 * (N - xdiff);
}
muint64_t ysum = 0;
muint64_t N2 = N * N;
for (muint64_t ydiff = 1; ydiff <= M; ++ydiff) {
ysum = ysum + ydiff * N2 * (M - ydiff);
}
// uint64_t result = (xsum + ysum) * p / k % (1000 * 1000 * 1000 + 7);
muint64_t result = (xsum + ysum) * comb(N * M - 2, K - 2);
std::cout << result << std::endl;
return 0;
}
| [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 854,475 | 854,476 | u477096296 | cpp |
p03039 | #include <iostream>
#include <stdio.h>
#include <vector>
#define lld long long
using namespace std;
const lld MODULO = 1e9 + 7;
const int N = 2e5 + 5;
int n, m, t;
lld d[N], s[N], k[N], res;
vector<lld> F[N];
lld gcd, x, y;
void gener() {
for (int i = 1; i <= m; i++) {
k[i] = (k[i - 1] + (i - 1)) % MODULO;
d[i] = (k[i] + d[i - 1]) % MODULO;
s[i] = (s[i - 1] + k[i] * 2) % MODULO;
}
}
void Clear() {
for (int i = 0; i <= n; i++)
for (int j = 0; j <= m; j++)
F[i].push_back(0);
for (int i = 1; i <= m; i++)
F[1][i] = d[i];
for (int i = 1; i <= n; i++)
F[i][1] = d[i];
}
void print() {
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= m; j++)
cout << F[i][j] << ' ';
cout << '\n';
}
}
void prepa() {
gener();
Clear();
for (int i = 2; i <= n; i++)
for (int j = 2; j <= m; j++) {
lld temp = ((d[i] * j * j) % MODULO + (s[j] * k[i]) % MODULO +
(d[j] * i) % MODULO) %
MODULO;
F[i][j] = temp;
}
}
void extendedEuclid(lld A, lld B) {
if (B == 0) {
gcd = A;
x = 1;
y = 0;
} else {
extendedEuclid(B, A % B);
lld temp = x;
x = y;
y = temp - (A / B) * y;
}
}
void solve() {
int q = t - 2;
int p = n * m - 2;
lld ngt = 1, n_k = 1, kgt = 1;
for (int i = 1; i <= p; i++)
ngt = (ngt * i) % MODULO;
for (int i = 1; i <= q; i++)
kgt = (kgt * i) % MODULO;
for (int i = 1; i <= p - q; i++)
n_k = (n_k * i) % MODULO;
extendedEuclid(kgt, MODULO);
kgt = x;
extendedEuclid(n_k, MODULO);
n_k = x;
kgt = (kgt % MODULO + MODULO) % MODULO;
n_k = (n_k % MODULO + MODULO) % MODULO;
res = ((ngt * kgt % MODULO) * n_k % MODULO) * F[n][m] % MODULO;
printf("%lld", res);
}
int main() {
// freopen("a.inp", "r", stdin);
scanf("%d%d%d", &n, &m, &t);
prepa();
solve();
return 0;
}
| #include <iostream>
#include <stdio.h>
#include <vector>
#define lld long long
using namespace std;
const lld MODULO = 1e9 + 7;
const int N = 2e5 + 5;
int n, m, t;
lld d[N], s[N], k[N], res;
vector<lld> F[N];
lld gcd, x, y;
void gener() {
for (int i = 1; i <= max(m, n); i++) {
k[i] = (k[i - 1] + (i - 1)) % MODULO;
d[i] = (k[i] + d[i - 1]) % MODULO;
s[i] = (s[i - 1] + k[i] * 2) % MODULO;
}
}
void Clear() {
for (int i = 0; i <= n; i++)
for (int j = 0; j <= m; j++)
F[i].push_back(0);
for (int i = 1; i <= m; i++)
F[1][i] = d[i];
for (int i = 1; i <= n; i++)
F[i][1] = d[i];
}
void print() {
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= m; j++)
cout << F[i][j] << ' ';
cout << '\n';
}
}
void prepa() {
gener();
Clear();
for (int i = 2; i <= n; i++)
for (int j = 2; j <= m; j++) {
lld temp = ((d[i] * j * j) % MODULO + (s[j] * k[i]) % MODULO +
(d[j] * i) % MODULO) %
MODULO;
F[i][j] = temp;
}
}
void extendedEuclid(lld A, lld B) {
if (B == 0) {
gcd = A;
x = 1;
y = 0;
} else {
extendedEuclid(B, A % B);
lld temp = x;
x = y;
y = temp - (A / B) * y;
}
}
void solve() {
int q = t - 2;
int p = n * m - 2;
lld ngt = 1, n_k = 1, kgt = 1;
for (int i = 1; i <= p; i++)
ngt = (ngt * i) % MODULO;
for (int i = 1; i <= q; i++)
kgt = (kgt * i) % MODULO;
for (int i = 1; i <= p - q; i++)
n_k = (n_k * i) % MODULO;
extendedEuclid(kgt, MODULO);
kgt = x;
extendedEuclid(n_k, MODULO);
n_k = x;
kgt = (kgt % MODULO + MODULO) % MODULO;
n_k = (n_k % MODULO + MODULO) % MODULO;
res = ((ngt * kgt % MODULO) * n_k % MODULO) * F[n][m] % MODULO;
printf("%lld", res);
}
int main() {
// freopen("a.inp", "r", stdin);
scanf("%d%d%d", &n, &m, &t);
prepa();
solve();
return 0;
} | [
"control_flow.loop.for.condition.change",
"call.add",
"call.arguments.add"
] | 854,477 | 854,478 | u287877771 | cpp |
p03039 | #include <iostream>
#include <stdio.h>
using namespace std;
const int MX = 200005, MOD = 1E9 + 7;
int m, n, k;
long long ans = 0, fct[MX], ivf[MX], inv[MX], d[MX], c[MX];
// n giai thua, nghich dao modulo tung vi tri i, nghich dao modulo nhan lai voi
// nhau
void gener() {
fct[0] = ivf[0] = 1;
fct[1] = ivf[1] = inv[1] = 1;
for (int i = 2; i <= m * n; i++) {
fct[i] = fct[i - 1] * i % MOD;
inv[i] = MOD - MOD / i * inv[MOD % i] % MOD;
ivf[i] = ivf[i - 1] * inv[i] % MOD;
}
}
void solve() {
for (int i = 1; i <= m; i++) {
c[i] = (c[i - 1] + (i - 1)) % MOD;
d[i] = (c[i] + d[i - 1]) % MOD;
}
ans += d[m] * n % MOD * n % MOD;
ans += d[n] * m % MOD * m % MOD;
}
int main() {
scanf("%d%d%d", &n, &m, &k);
gener();
solve();
cout << ans * fct[m * n - 2] % MOD * ivf[k - 2] % MOD * ivf[m * n - k] % MOD;
}
| #include <iostream>
#include <stdio.h>
using namespace std;
const int MX = 200005, MOD = 1E9 + 7;
int m, n, k;
long long ans = 0, fct[MX], ivf[MX], inv[MX], d[MX], c[MX];
// n giai thua, nghich dao modulo tung vi tri i, nghich dao modulo nhan lai voi
// nhau
void gener() {
fct[0] = ivf[0] = 1;
fct[1] = ivf[1] = inv[1] = 1;
for (int i = 2; i <= m * n; i++) {
fct[i] = fct[i - 1] * i % MOD;
inv[i] = MOD - MOD / i * inv[MOD % i] % MOD;
ivf[i] = ivf[i - 1] * inv[i] % MOD;
}
}
void solve() {
for (int i = 1; i <= max(m, n); i++) {
c[i] = (c[i - 1] + (i - 1)) % MOD;
d[i] = (c[i] + d[i - 1]) % MOD;
}
ans += d[m] * n % MOD * n % MOD;
ans += d[n] * m % MOD * m % MOD;
}
int main() {
scanf("%d%d%d", &n, &m, &k);
gener();
solve();
cout << ans * fct[m * n - 2] % MOD * ivf[k - 2] % MOD * ivf[m * n - k] % MOD;
}
| [
"control_flow.loop.for.condition.change",
"call.add",
"call.arguments.add"
] | 854,479 | 854,480 | u287877771 | cpp |
p03039 | #include <bits/stdc++.h>
#define INF (1 << 30)
#define MOD 1000000007
#define l_ength size
using ll = long long;
using namespace std;
const int MAX = 200100;
ll fact[MAX], fact_inv[MAX];
ll power(ll a, ll b) {
ll res = 1;
while (b > 0) {
if (b & 1)
res = res * a % MOD;
a = a * a % MOD;
b >>= 1;
}
return res;
}
ll comb(ll n, ll r) {
return (fact[n] * fact_inv[r]) % MOD * fact_inv[n - r] % MOD;
}
int main() {
ll n, m, k;
cin >> n >> m >> k;
fact[0] = 1;
for (int i = 0; i < m * n + 100; ++i) {
fact[i + 1] = fact[i] * (i + 1) % MOD;
}
fact_inv[m * n + 100] = power(fact[m * n + 100], MOD - 2);
for (int i = m * n + 99; i >= 0; --i) {
fact_inv[i] = fact_inv[i + 1] * (i + 1) % MOD;
}
ll sum = 0;
for (ll d = 1; d < m; ++d) {
sum += d * (n * n) * (n - d);
sum %= MOD;
}
for (ll d = 1; d < n; ++d) {
sum += d * (m * m) * (m - d);
sum %= MOD;
}
cout << (sum * comb(m * n - 2, k - 2)) % MOD << endl;
return 0;
} | #include <bits/stdc++.h>
#define INF (1 << 30)
#define MOD 1000000007
#define l_ength size
using ll = long long;
using namespace std;
const int MAX = 200100;
ll fact[MAX], fact_inv[MAX];
ll power(ll a, ll b) {
ll res = 1;
while (b > 0) {
if (b & 1)
res = res * a % MOD;
a = a * a % MOD;
b >>= 1;
}
return res;
}
ll comb(ll n, ll r) {
return (fact[n] * fact_inv[r]) % MOD * fact_inv[n - r] % MOD;
}
int main() {
ll n, m, k;
cin >> n >> m >> k;
fact[0] = 1;
for (int i = 0; i < m * n + 100; ++i) {
fact[i + 1] = fact[i] * (i + 1) % MOD;
}
fact_inv[m * n + 100] = power(fact[m * n + 100], MOD - 2);
for (int i = m * n + 99; i >= 0; --i) {
fact_inv[i] = fact_inv[i + 1] * (i + 1) % MOD;
}
ll sum = 0;
for (ll d = 1; d < m; ++d) {
sum += d * (n * n) * (m - d);
sum %= MOD;
}
for (ll d = 1; d < n; ++d) {
sum += d * (m * m) * (n - d);
sum %= MOD;
}
cout << (sum * comb(m * n - 2, k - 2)) % MOD << endl;
return 0;
} | [
"assignment.value.change",
"identifier.change",
"expression.operation.binary.change"
] | 854,485 | 854,486 | u268977772 | cpp |
p03039 | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define rrep(i, n) for (int(i) = (n)-1; (i) >= 0; (i)--)
int mod = 1e9 + 7;
struct modCalc {
int mod;
int n;
bool ok;
vector<int> fact, invfact;
modCalc(){};
modCalc(int _mod, int _n) {
mod = _mod, n = _n;
ok = false;
};
void init() {
fact.resize(n + 1, 1);
for (int i = 0; i < n; i++)
fact[i + 1] = fact[i] * (i + 1) % mod;
invfact.resize(n + 1, 1);
invfact[n] = modinv(n);
for (int i = n; i > 1; i--)
invfact[i - 1] = invfact[i] * i % mod;
ok = true;
}
int modpow(int x, int n, int m = -1) {
if (m == -1)
m = mod;
int ret = 1;
while (n > 0) {
if (n & 1)
(ret *= x) %= m;
(x *= x) %= m;
n >>= 1;
}
return ret;
}
int modinv(int x, int m = -1) {
if (m == -1)
m = mod;
return modpow(x, m - 2, m);
}
int nCm(int x, int y) {
if (!ok)
init();
if (y == 0)
return 1;
else
return fact[x] * invfact[y] % mod * invfact[x - y] % mod;
}
int nPm(int x, int y = -1) {
if (y == -1)
y = x;
if (!ok)
init();
return fact[x] * invfact[x - y] % mod;
}
};
signed main() {
int n, m, k;
cin >> n >> m >> k;
modCalc md(mod, n * m);
int combNum = md.nCm(n * m - 2, k - 2);
int ret = 0;
for (int i = 1; i < n; i++)
(ret += i * (n - i) * m * m) %= mod;
for (int i = 1; i < m; i++)
(ret += i * (m - i) * n * n) %= mod;
cout << ret * combNum % mod << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define rrep(i, n) for (int(i) = (n)-1; (i) >= 0; (i)--)
int mod = 1e9 + 7;
struct modCalc {
int mod;
int n;
bool ok;
vector<int> fact, invfact;
modCalc(){};
modCalc(int _mod, int _n) {
mod = _mod, n = _n;
ok = false;
};
void init() {
fact.resize(n + 1, 1);
for (int i = 0; i < n; i++)
fact[i + 1] = fact[i] * (i + 1) % mod;
invfact.resize(n + 1, 1);
invfact[n] = modinv(fact[n]);
for (int i = n; i > 1; i--)
invfact[i - 1] = invfact[i] * i % mod;
ok = true;
}
int modpow(int x, int n, int m = -1) {
if (m == -1)
m = mod;
int ret = 1;
while (n > 0) {
if (n & 1)
(ret *= x) %= m;
(x *= x) %= m;
n >>= 1;
}
return ret;
}
int modinv(int x, int m = -1) {
if (m == -1)
m = mod;
return modpow(x, m - 2, m);
}
int nCm(int x, int y) {
if (!ok)
init();
if (y == 0)
return 1;
else
return fact[x] * invfact[y] % mod * invfact[x - y] % mod;
}
int nPm(int x, int y = -1) {
if (y == -1)
y = x;
if (!ok)
init();
return fact[x] * invfact[x - y] % mod;
}
};
signed main() {
int n, m, k;
cin >> n >> m >> k;
modCalc md(mod, n * m);
int combNum = md.nCm(n * m - 2, k - 2);
int ret = 0;
for (int i = 1; i < n; i++)
(ret += i * (n - i) * m * m) %= mod;
for (int i = 1; i < m; i++)
(ret += i * (m - i) * n * n) %= mod;
cout << ret * combNum % mod << endl;
} | [
"call.arguments.change"
] | 854,498 | 854,499 | u731175398 | cpp |
p03039 | #define _USE_MATH_DEFINES
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <initializer_list>
#include <iostream>
#include <iterator>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <utility>
#include <valarray>
#include <vector>
using namespace std;
#define rep(i, n) for (ll i = 0; i < (ll)(n); ++i)
#define rep1(i, n) for (ll i = 1; i <= (ll)(n); ++i)
#define all(c) (c).begin(), (c).end()
#define mt make_tuple
#define pb push_back
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef tuple<int, int> tii;
template <typename T> ostream &operator<<(ostream &os, set<T> const &s);
template <typename T, typename U>
ostream &operator<<(ostream &os, map<T, U> const &mp);
template <typename T> ostream &operator<<(ostream &os, vector<T> const &v);
template <typename... Types>
ostream &operator<<(ostream &os, tuple<Types...> const &v);
template <typename T> ostream &operator<<(ostream &os, set<T> const &s);
template <typename T> ostream &operator<<(ostream &os, set<T> const &s) {
if (s.size() == 0)
return os << "{}";
os << "{";
decltype(s.begin()) iter;
for (iter = s.begin(), ++iter; iter != s.end(); ++iter) {
--iter;
os << *iter << ", ";
++iter;
}
--iter;
os << *iter << '}';
return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, map<T, U> const &mp) {
if (mp.size() == 0)
return os << "{}";
os << "{" << endl;
decltype(mp.begin()) iter;
for (iter = mp.begin(), ++iter; iter != mp.end(); ++iter) {
--iter;
os << " {" << iter->first << ", " << iter->second << "}," << endl;
++iter;
}
--iter;
os << " {" << iter->first << ", " << iter->second << "}" << endl << '}';
return os;
}
template <typename T> ostream &operator<<(ostream &os, vector<T> const &v) {
os << '[';
rep(i, v.size() - 1) os << v[i] << ", ";
if (v.size() > 0)
os << v[v.size() - 1];
cerr << ']';
return os;
}
template <typename T, unsigned N, unsigned Last> struct TuplePrinter {
static void print(ostream &os, T const &v) {
os << std::get<N>(v) << ", ";
TuplePrinter<T, N + 1, Last>::print(os, v);
}
};
template <typename T, unsigned N> struct TuplePrinter<T, N, N> {
static void print(ostream &os, T const &v) { os << std::get<N>(v); }
};
template <typename... Types>
ostream &operator<<(ostream &os, tuple<Types...> const &v) {
os << "(";
TuplePrinter<tuple<Types...>, 0, sizeof...(Types) - 1>::print(os, v);
os << ")";
return os;
}
template <typename T> void _dbg(T const &t) { cerr << t << endl; }
template <typename T, typename... Args> void _dbg(T const &t, Args... args) {
cerr << t << " ";
_dbg(args...);
}
template <typename... Args> void __dbg(const char *fn, int l, Args... args) {
cerr << "[" << fn << ":" << l << "] ";
_dbg(args...);
}
#define dbg(...) __dbg(__func__, __LINE__, __VA_ARGS__)
const ll infty = 1223372036854775807;
const double eps = 1e-8;
const ll MOD = 1000000007LL;
const ll mod = MOD;
/*
ll modpow(ll x, ll n) {
return n < 2 ? x : modpow(x * x, n / 2) * (n % 2 ? x : 1) % MOD;
}
ll modfact(ll n) { return n < 2 ? 1 : modfact(n - 1) * n % MOD; }
ll modcomb(ll n, ll r) {
dbg(n, r);
dbg(modfact(n - r), modpow(modfact(n - r), MOD - 3));
return modfact(n) * modpow(modfact(r), MOD - 2) % MOD *
modpow(modfact(n - r), MOD - 2) % MOD;
}
*/
long long modpow(long long x, int y) {
if (y == 0)
return 1;
if (y == 1)
return x;
long long z = modpow(x, y / 2);
z = z * z % mod;
if (y % 2)
z = z * x % mod;
return z;
}
long long modinv(long long x) { return modpow(x, mod - 2); }
long long modfact(int n) {
long long r = 1;
for (int i = 1; i <= n; ++i)
r = r * i % mod;
return r;
}
long long modcomb(int n, int k) {
return modfact(n) * modinv(modfact(k)) % mod * modinv(modfact(n - k)) % mod;
}
int main(int argc, char *argv[]) {
// cin.tie(0); cout.sync_with_stdio(false);
ll n, m, k;
cin >> n >> m >> k;
ll mult = modcomb(n * m - 2, k - 2);
ll ans = 0;
ll mm = m * m % MOD;
ll nn = n * n % MOD;
rep1(d, n - 1) {
ll v = d * (n - d);
v %= MOD;
v *= mm;
v %= MOD;
ans += v;
ans %= MOD;
}
rep1(d, m - 1) {
ll v = d * (m - d);
v %= MOD;
v *= mm;
v %= MOD;
ans += v;
ans %= MOD;
}
ans *= mult;
ans %= MOD;
cout << ans << endl;
return 0;
}
| #define _USE_MATH_DEFINES
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <initializer_list>
#include <iostream>
#include <iterator>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <utility>
#include <valarray>
#include <vector>
using namespace std;
#define rep(i, n) for (ll i = 0; i < (ll)(n); ++i)
#define rep1(i, n) for (ll i = 1; i <= (ll)(n); ++i)
#define all(c) (c).begin(), (c).end()
#define mt make_tuple
#define pb push_back
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef tuple<int, int> tii;
template <typename T> ostream &operator<<(ostream &os, set<T> const &s);
template <typename T, typename U>
ostream &operator<<(ostream &os, map<T, U> const &mp);
template <typename T> ostream &operator<<(ostream &os, vector<T> const &v);
template <typename... Types>
ostream &operator<<(ostream &os, tuple<Types...> const &v);
template <typename T> ostream &operator<<(ostream &os, set<T> const &s);
template <typename T> ostream &operator<<(ostream &os, set<T> const &s) {
if (s.size() == 0)
return os << "{}";
os << "{";
decltype(s.begin()) iter;
for (iter = s.begin(), ++iter; iter != s.end(); ++iter) {
--iter;
os << *iter << ", ";
++iter;
}
--iter;
os << *iter << '}';
return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, map<T, U> const &mp) {
if (mp.size() == 0)
return os << "{}";
os << "{" << endl;
decltype(mp.begin()) iter;
for (iter = mp.begin(), ++iter; iter != mp.end(); ++iter) {
--iter;
os << " {" << iter->first << ", " << iter->second << "}," << endl;
++iter;
}
--iter;
os << " {" << iter->first << ", " << iter->second << "}" << endl << '}';
return os;
}
template <typename T> ostream &operator<<(ostream &os, vector<T> const &v) {
os << '[';
rep(i, v.size() - 1) os << v[i] << ", ";
if (v.size() > 0)
os << v[v.size() - 1];
cerr << ']';
return os;
}
template <typename T, unsigned N, unsigned Last> struct TuplePrinter {
static void print(ostream &os, T const &v) {
os << std::get<N>(v) << ", ";
TuplePrinter<T, N + 1, Last>::print(os, v);
}
};
template <typename T, unsigned N> struct TuplePrinter<T, N, N> {
static void print(ostream &os, T const &v) { os << std::get<N>(v); }
};
template <typename... Types>
ostream &operator<<(ostream &os, tuple<Types...> const &v) {
os << "(";
TuplePrinter<tuple<Types...>, 0, sizeof...(Types) - 1>::print(os, v);
os << ")";
return os;
}
template <typename T> void _dbg(T const &t) { cerr << t << endl; }
template <typename T, typename... Args> void _dbg(T const &t, Args... args) {
cerr << t << " ";
_dbg(args...);
}
template <typename... Args> void __dbg(const char *fn, int l, Args... args) {
cerr << "[" << fn << ":" << l << "] ";
_dbg(args...);
}
#define dbg(...) __dbg(__func__, __LINE__, __VA_ARGS__)
const ll infty = 1223372036854775807;
const double eps = 1e-8;
const ll MOD = 1000000007LL;
const ll mod = MOD;
/*
ll modpow(ll x, ll n) {
return n < 2 ? x : modpow(x * x, n / 2) * (n % 2 ? x : 1) % MOD;
}
ll modfact(ll n) { return n < 2 ? 1 : modfact(n - 1) * n % MOD; }
ll modcomb(ll n, ll r) {
dbg(n, r);
dbg(modfact(n - r), modpow(modfact(n - r), MOD - 3));
return modfact(n) * modpow(modfact(r), MOD - 2) % MOD *
modpow(modfact(n - r), MOD - 2) % MOD;
}
*/
long long modpow(long long x, int y) {
if (y == 0)
return 1;
if (y == 1)
return x;
long long z = modpow(x, y / 2);
z = z * z % mod;
if (y % 2)
z = z * x % mod;
return z;
}
long long modinv(long long x) { return modpow(x, mod - 2); }
long long modfact(int n) {
long long r = 1;
for (int i = 1; i <= n; ++i)
r = r * i % mod;
return r;
}
long long modcomb(int n, int k) {
return modfact(n) * modinv(modfact(k)) % mod * modinv(modfact(n - k)) % mod;
}
int main(int argc, char *argv[]) {
// cin.tie(0); cout.sync_with_stdio(false);
ll n, m, k;
cin >> n >> m >> k;
ll mult = modcomb(n * m - 2, k - 2);
ll ans = 0;
ll mm = m * m % MOD;
ll nn = n * n % MOD;
rep1(d, n - 1) {
ll v = d * (n - d);
v %= MOD;
v *= mm;
v %= MOD;
ans += v;
ans %= MOD;
}
rep1(d, m - 1) {
ll v = d * (m - d);
v %= MOD;
v *= nn;
v %= MOD;
ans += v;
ans %= MOD;
}
ans *= mult;
ans %= MOD;
cout << ans << endl;
return 0;
}
| [
"assignment.value.change",
"identifier.change"
] | 854,510 | 854,511 | u890437211 | cpp |
p03039 | #include <bits/stdc++.h>
using namespace std;
const int64_t MOD = 1e9 + 7;
// O(log a)
int64_t powmod(int64_t a, int64_t p) {
int64_t value = 1;
for (int64_t mul = a; p > 0; p >>= 1, mul = (mul * mul) % MOD) {
if (p & 1)
value = (value * mul) % MOD;
}
return value;
}
int64_t invmod(int64_t x) { return powmod(x, MOD - 2); }
struct Factorial {
vector<int64_t> val;
vector<int64_t> inv;
};
// O(N)
Factorial GetFact(int N) {
Factorial fact;
fact.val = vector<int64_t>(N);
fact.inv = vector<int64_t>(N);
fact.val[0] = 1;
for (int i = 1; i < N; i++) {
fact.val[i] = int64_t(fact.val[i - 1] * i) % MOD;
}
fact.inv[0] = 1;
fact.inv[N - 1] = powmod(fact.val[N - 1], MOD - 2);
for (int i = N - 1; i > 0; i--) {
fact.inv[i - 1] = int64_t(fact.inv[i] * i) % MOD;
}
return fact;
}
struct MInt {
static int64_t mod;
int64_t v;
MInt() {}
MInt(int64_t x) : v(x) {}
MInt operator+(const MInt &y) { return (v + y.v) % mod; }
MInt operator-(const MInt &y) { return (v - y.v + mod) % mod; }
MInt operator*(const MInt &y) { return (v * y.v) % mod; }
MInt operator/(const MInt &y) { return (v * invmod(y.v)) % mod; }
void operator+=(const MInt &y) { *this = *this + y; }
void operator-=(const MInt &y) { *this = *this - y; }
void operator*=(const MInt &y) { *this = *this * y; }
void operator/=(const MInt &y) { *this = *this / y; }
friend istream &operator>>(istream &ist, MInt &m) { return ist >> m.v; }
friend ostream &operator<<(ostream &ost, MInt &m) { return ost << m.v; }
};
int64_t MInt::mod = MOD;
int64_t Combination(int n, int m, const Factorial &f) {
if (n < m || m < 0 || n < 0)
return 0;
return ((f.val[n] * f.inv[m] % MOD) * f.inv[n - m]) % MOD;
}
int main() {
#ifdef DEBUG
std::ifstream in("/home/share/inputf.in");
std::cin.rdbuf(in.rdbuf());
#endif
int N, M, K;
cin >> N >> M >> K;
MInt ans = 0;
Factorial f = GetFact(N * M);
for (int i = 0; i < 2; i++) {
ans += MInt(M) * MInt(M) * MInt(Combination(N + 1, 3, f));
swap(N, M);
}
ans *= MInt(Combination(N * M - 2, K - 2, f));
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
const int64_t MOD = 1e9 + 7;
// O(log a)
int64_t powmod(int64_t a, int64_t p) {
int64_t value = 1;
for (int64_t mul = a; p > 0; p >>= 1, mul = (mul * mul) % MOD) {
if (p & 1)
value = (value * mul) % MOD;
}
return value;
}
int64_t invmod(int64_t x) { return powmod(x, MOD - 2); }
struct Factorial {
vector<int64_t> val;
vector<int64_t> inv;
};
// O(N)
Factorial GetFact(int N) {
Factorial fact;
fact.val = vector<int64_t>(N);
fact.inv = vector<int64_t>(N);
fact.val[0] = 1;
for (int i = 1; i < N; i++) {
fact.val[i] = int64_t(fact.val[i - 1] * i) % MOD;
}
fact.inv[0] = 1;
fact.inv[N - 1] = powmod(fact.val[N - 1], MOD - 2);
for (int i = N - 1; i > 0; i--) {
fact.inv[i - 1] = int64_t(fact.inv[i] * i) % MOD;
}
return fact;
}
struct MInt {
static int64_t mod;
int64_t v;
MInt() {}
MInt(int64_t x) : v(x) {}
MInt operator+(const MInt &y) { return (v + y.v) % mod; }
MInt operator-(const MInt &y) { return (v - y.v + mod) % mod; }
MInt operator*(const MInt &y) { return (v * y.v) % mod; }
MInt operator/(const MInt &y) { return (v * invmod(y.v)) % mod; }
void operator+=(const MInt &y) { *this = *this + y; }
void operator-=(const MInt &y) { *this = *this - y; }
void operator*=(const MInt &y) { *this = *this * y; }
void operator/=(const MInt &y) { *this = *this / y; }
friend istream &operator>>(istream &ist, MInt &m) { return ist >> m.v; }
friend ostream &operator<<(ostream &ost, MInt &m) { return ost << m.v; }
};
int64_t MInt::mod = MOD;
int64_t Combination(int n, int m, const Factorial &f) {
if (n < m || m < 0 || n < 0)
return 0;
return ((f.val[n] * f.inv[m] % MOD) * f.inv[n - m]) % MOD;
}
int main() {
#ifdef DEBUG
std::ifstream in("/home/share/inputf.in");
std::cin.rdbuf(in.rdbuf());
#endif
int N, M, K;
cin >> N >> M >> K;
MInt ans = 0;
Factorial f = GetFact(N * M + 10);
for (int i = 0; i < 2; i++) {
ans += MInt(M) * MInt(M) * MInt(Combination(N + 1, 3, f));
swap(N, M);
}
ans *= MInt(Combination(N * M - 2, K - 2, f));
cout << ans << endl;
return 0;
} | [
"assignment.change"
] | 854,512 | 854,513 | u936555566 | cpp |
p03039 | #include <bits/stdc++.h>
using namespace std;
class finite_field {
const int md;
const int sz;
vector<int> fct, fnv;
public:
finite_field(const int md, const int init_factorial_size = 0)
: md(md), sz(init_factorial_size), fct(sz), fnv(sz) {
fct[0] = 1;
for (int i = 1; i < sz; i++)
fct[i] = mul(fct[i - 1], i);
fnv[sz - 1] = inv(fct[sz - 1]);
for (int i = sz - 1; i >= 1; i--)
fnv[i - 1] = mul(fnv[i], i);
}
inline void add(int &a, const int b) const {
a += b;
if (a >= md)
a -= md;
}
inline void sub(int &a, const int b) const {
a -= b;
if (a < 0)
a += md;
}
template <class... A> int mul(A... args) const {
long long ret = 1;
for (int a : std::initializer_list<int>{args...}) {
ret *= a;
ret %= md;
}
return (int)ret;
}
inline int inv(int a) const {
a %= md;
if (a < 0)
a += md;
int b = md, u = 0, v = 1;
while (a) {
int t = b / a;
b -= a * t;
swap(a, b);
u -= v * t;
swap(u, v);
}
assert(b == 1);
if (u < 0)
u += md;
return u;
}
inline int div(int a, int b) const { return mul(a, inv(b)); }
inline int binom(int n, int k) const {
assert(0 <= n && n < sz);
if (k < 0 || n <= k)
return 0;
return mul(fct[n], fnv[k], fnv[n - k]);
}
};
int main() {
cin.tie(0);
cin.sync_with_stdio(false);
int h, w, k;
cin >> h >> w >> k;
finite_field fld(1e9 + 7, h * w + 1);
auto solve = [&](int h, int w, int k) {
int ret = 0, denom = 0;
for (int i = 1; i < h; i++) {
fld.add(ret, fld.mul(i, h - i));
fld.add(denom, i);
}
ret = fld.mul(ret, w, w);
denom = fld.mul(denom, w, w);
fld.add(denom, fld.mul(h, fld.binom(w, 2)));
ret = fld.div(ret, denom);
return ret;
};
int ret = 0;
fld.add(ret, solve(h, w, k));
fld.add(ret, solve(w, h, k));
ret = fld.mul(ret, fld.binom(k, 2));
ret = fld.mul(ret, fld.binom(h * w, k));
cout << ret << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
class finite_field {
const int md;
const int sz;
vector<int> fct, fnv;
public:
finite_field(const int md, const int init_factorial_size = 0)
: md(md), sz(init_factorial_size), fct(sz), fnv(sz) {
fct[0] = 1;
for (int i = 1; i < sz; i++)
fct[i] = mul(fct[i - 1], i);
fnv[sz - 1] = inv(fct[sz - 1]);
for (int i = sz - 1; i >= 1; i--)
fnv[i - 1] = mul(fnv[i], i);
}
inline void add(int &a, const int b) const {
a += b;
if (a >= md)
a -= md;
}
inline void sub(int &a, const int b) const {
a -= b;
if (a < 0)
a += md;
}
template <class... A> int mul(A... args) const {
long long ret = 1;
for (int a : std::initializer_list<int>{args...}) {
ret *= a;
ret %= md;
}
return (int)ret;
}
inline int inv(int a) const {
a %= md;
if (a < 0)
a += md;
int b = md, u = 0, v = 1;
while (a) {
int t = b / a;
b -= a * t;
swap(a, b);
u -= v * t;
swap(u, v);
}
assert(b == 1);
if (u < 0)
u += md;
return u;
}
inline int div(int a, int b) const { return mul(a, inv(b)); }
inline int binom(int n, int k) const {
assert(0 <= n && n < sz);
if (k < 0 || n < k)
return 0;
return mul(fct[n], fnv[k], fnv[n - k]);
}
};
int main() {
cin.tie(0);
cin.sync_with_stdio(false);
int h, w, k;
cin >> h >> w >> k;
finite_field fld(1e9 + 7, h * w + 1);
auto solve = [&](int h, int w, int k) {
int ret = 0, denom = 0;
for (int i = 1; i < h; i++) {
fld.add(ret, fld.mul(i, h - i));
fld.add(denom, i);
}
ret = fld.mul(ret, w, w);
denom = fld.mul(denom, w, w);
fld.add(denom, fld.mul(h, fld.binom(w, 2)));
ret = fld.div(ret, denom);
return ret;
};
int ret = 0;
fld.add(ret, solve(h, w, k));
fld.add(ret, solve(w, h, k));
ret = fld.mul(ret, fld.binom(k, 2));
ret = fld.mul(ret, fld.binom(h * w, k));
cout << ret << endl;
return 0;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 854,520 | 854,521 | u846041485 | cpp |
p03039 | #include <algorithm>
#include <bitset>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <math.h>
#include <queue>
#include <stack>
#include <vector>
using namespace std;
typedef stack<int> IntStack;
typedef queue<int> IntQueue;
const double pi = 3.141592653589793;
int char_to_int(char c) {
if (c == '0')
return 0;
if (c == '1')
return 1;
if (c == '2')
return 2;
if (c == '3')
return 3;
if (c == '4')
return 4;
if (c == '5')
return 5;
if (c == '6')
return 6;
if (c == '7')
return 7;
if (c == '8')
return 8;
if (c == '9')
return 9;
else
return -1;
}
long long int ModPower(long long int a, long long int b, long long int MOD) {
if (b == 0)
return 1;
else if (b % 2 == 0) {
long long int d = ModPower(a, b / 2, MOD);
return (d * d) % MOD;
} else {
return (a * ModPower(a, b - 1, MOD)) % MOD;
}
}
long long int ModCombi(long long int n, long long int r, long long int MOD) {
if (n == 0 || r == 0)
return 1;
long long int Kn, Kr, Knr;
long long int temp = 1;
for (long long int i = 1; i <= n; i++) {
temp *= i;
temp %= MOD;
if (i == n)
Kn = temp;
if (i == r)
Kr = temp;
if (i == n - r)
Knr = temp;
}
long long int x = ModPower(Kr, MOD - 2, MOD);
long long int y = ModPower(Knr, MOD - 2, MOD);
long long int ans;
ans = Kn * x;
ans %= MOD;
ans *= y;
ans %= MOD;
return ans;
}
/*ここまでテンプレ*/ /*ここまでテンプレ*/
/*ここまでテンプレ*/ /*ここまでテンプレ*/
int main() {
long long int N, M, K;
cin >> N >> M >> K;
const long long int MOD = 1000000007;
long long int S1, S2;
S1 = 0;
for (int i = 1; i <= N - 1; i++) {
S1 += i * (N - i);
S1 %= MOD;
}
S1 *= M;
S1 %= MOD;
S1 *= M;
S1 %= MOD;
S2 = 0;
for (int i = 1; i <= M - 1; i++) {
S2 += i * (M - i);
S2 %= MOD;
}
S2 *= N;
S2 %= MOD;
S2 *= N;
S2 %= MOD;
long long int ans = ModCombi(N * M - 2, K - 2, MOD);
ans *= S1 + S2;
ans %= MOD;
cout << ans;
return 0;
} | #include <algorithm>
#include <bitset>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <math.h>
#include <queue>
#include <stack>
#include <vector>
using namespace std;
typedef stack<int> IntStack;
typedef queue<int> IntQueue;
const double pi = 3.141592653589793;
int char_to_int(char c) {
if (c == '0')
return 0;
if (c == '1')
return 1;
if (c == '2')
return 2;
if (c == '3')
return 3;
if (c == '4')
return 4;
if (c == '5')
return 5;
if (c == '6')
return 6;
if (c == '7')
return 7;
if (c == '8')
return 8;
if (c == '9')
return 9;
else
return -1;
}
long long int ModPower(long long int a, long long int b, long long int MOD) {
if (b == 0)
return 1;
else if (b % 2 == 0) {
long long int d = ModPower(a, b / 2, MOD);
return (d * d) % MOD;
} else {
return (a * ModPower(a, b - 1, MOD)) % MOD;
}
}
long long int ModCombi(long long int n, long long int r, long long int MOD) {
if (n == 0 || r == 0)
return 1;
long long int Kn = 1, Kr = 1, Knr = 1;
long long int temp = 1;
for (long long int i = 1; i <= n; i++) {
temp *= i;
temp %= MOD;
if (i == n)
Kn = temp;
if (i == r)
Kr = temp;
if (i == n - r)
Knr = temp;
}
long long int x = ModPower(Kr, MOD - 2, MOD);
long long int y = ModPower(Knr, MOD - 2, MOD);
long long int ans;
ans = Kn * x;
ans %= MOD;
ans *= y;
ans %= MOD;
return ans;
}
/*ここまでテンプレ*/ /*ここまでテンプレ*/
/*ここまでテンプレ*/ /*ここまでテンプレ*/
int main() {
long long int N, M, K;
cin >> N >> M >> K;
const long long int MOD = 1000000007;
long long int S1, S2;
S1 = 0;
for (int i = 1; i <= N - 1; i++) {
S1 += i * (N - i);
S1 %= MOD;
}
S1 *= M;
S1 %= MOD;
S1 *= M;
S1 %= MOD;
S2 = 0;
for (int i = 1; i <= M - 1; i++) {
S2 += i * (M - i);
S2 %= MOD;
}
S2 *= N;
S2 %= MOD;
S2 *= N;
S2 %= MOD;
long long int ans = ModCombi(N * M - 2, K - 2, MOD);
ans *= S1 + S2;
ans %= MOD;
cout << ans;
return 0;
} | [
"variable_declaration.value.change"
] | 854,529 | 854,530 | u397037010 | cpp |
p03039 | #include <algorithm>
#include <cctype>
#include <cmath>
#include <cstring>
#include <fstream>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
using namespace std;
#define ll long long
#define MOD 1000000007
#define INF 2000000000
#define LINF 9000000000000000000
#define rep(i, n) for (int i = 0; i < (int)n; i++)
#define du(x) cout << #x << '=' << x << endl
#define du2(x, y) \
cout << #x << '=' << x << ' ' << #y << '=' << y << '\n' << endl
#define du3(x, y, z) \
cout << #x << '=' << x << ' ' << #y << '=' << y << ' ' << #z << '=' << z \
<< '\n' \
<< endl
#define darr(arr, n) \
rep(i, (n - arr)) { cout << *(arr + i) << ' '; } \
cout << endl
#define ddarr(arr, a, b) \
rep(i, a) { \
rep(j, b) { cout << *(arr + i * b + j) << ' '; } \
cout << endl; \
}
#define ddd \
ifstream in("Text.txt"); \
cin.rdbuf(in.rdbuf());
ll mod_pow(ll n, ll p) {
if (p == 0)
return 1;
ll res = mod_pow(n * n % MOD, p / 2);
if (p % 2 == 1)
res = res * n % MOD;
return res;
}
ll Combination(int n, int r) { //階乗は英語でFactorial
vector<ll> fct(n + 1, 1); // fact[n] = n! の mod
for (int i = 1; i <= n; i++) {
fct[i] = i * fct[i - 1] % MOD;
}
vector<ll> invfct(n + 1); // invfact[n] = 1/n! の mod
invfct[n] = mod_pow(fct[n], MOD - 2) % MOD; // 1/n!を繰り返し二乗法で求める
for (int i = n - 1; i >= 1; i--) {
invfct[i] = (i + 1) * invfct[i + 1] % MOD;
}
// Combination(n,r)を計算
ll Co = (fct[n] * invfct[r] % MOD) * invfct[n - r] % MOD;
return Co;
}
int main() {
int N, M, K;
cin >> N >> M >> K;
ll ans = 0;
for (int dx = 1; dx < M; dx++) {
ll A = (N * N * (M - dx)) % MOD;
ans = (ans + A * dx % MOD) % MOD;
}
for (int dy = 1; dy < N; dy++) {
ll A = (M * M * (N - dy)) % MOD;
ans = (ans + A * dy % MOD) % MOD;
}
cout << ans * (Combination(N * M - 2, K - 2) % MOD) % MOD << endl;
}
| #include <algorithm>
#include <cctype>
#include <cmath>
#include <cstring>
#include <fstream>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
using namespace std;
#define ll long long
#define MOD 1000000007
#define INF 2000000000
#define LINF 9000000000000000000
#define rep(i, n) for (int i = 0; i < (int)n; i++)
#define du(x) cout << #x << '=' << x << endl
#define du2(x, y) \
cout << #x << '=' << x << ' ' << #y << '=' << y << '\n' << endl
#define du3(x, y, z) \
cout << #x << '=' << x << ' ' << #y << '=' << y << ' ' << #z << '=' << z \
<< '\n' \
<< endl
#define darr(arr, n) \
rep(i, (n - arr)) { cout << *(arr + i) << ' '; } \
cout << endl
#define ddarr(arr, a, b) \
rep(i, a) { \
rep(j, b) { cout << *(arr + i * b + j) << ' '; } \
cout << endl; \
}
#define ddd \
ifstream in("Text.txt"); \
cin.rdbuf(in.rdbuf());
ll mod_pow(ll n, ll p) {
if (p == 0)
return 1;
ll res = mod_pow(n * n % MOD, p / 2);
if (p % 2 == 1)
res = res * n % MOD;
return res;
}
ll Combination(int n, int r) { //階乗は英語でFactorial
vector<ll> fct(n + 1, 1); // fact[n] = n! の mod
for (int i = 1; i <= n; i++) {
fct[i] = i * fct[i - 1] % MOD;
}
vector<ll> invfct(n + 1, 1); // invfact[n] = 1/n! の mod
invfct[n] = mod_pow(fct[n], MOD - 2) % MOD; // 1/n!を繰り返し二乗法で求める
for (int i = n - 1; i >= 1; i--) {
invfct[i] = (i + 1) * invfct[i + 1] % MOD;
}
// Combination(n,r)を計算
ll Co = (fct[n] * invfct[r] % MOD) * invfct[n - r] % MOD;
return Co;
}
int main() {
int N, M, K;
cin >> N >> M >> K;
ll ans = 0;
for (int dx = 1; dx < M; dx++) {
ll A = (N * N * (M - dx)) % MOD;
ans = (ans + A * dx % MOD) % MOD;
}
for (int dy = 1; dy < N; dy++) {
ll A = (M * M * (N - dy)) % MOD;
ans = (ans + A * dy % MOD) % MOD;
}
cout << ans * (Combination(N * M - 2, K - 2) % MOD) % MOD << endl;
} | [
"call.arguments.add"
] | 854,533 | 854,534 | u281384315 | cpp |
p03039 | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < n; i++)
#define SORT(v, n) sort(v, v + n);
#define VSORT(v) sort(v.begin(), v.end())
#define VRSORT(v) sort(v.rbegin(), v.rend()) // vectorの降順ソート
#define ll long long
#define pb(a) push_back(a)
#define INF 1000000000
#define LINF 1e18
#define MOD 1000000007
using namespace std;
typedef pair<int, int> P;
typedef pair<ll, ll> LP;
typedef pair<int, P> PP;
typedef pair<ll, LP> LPP;
typedef vector<unsigned int> vec;
typedef vector<vec> mat;
// typedef tuple<ll, ll, ll> T;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
int dy[] = {0, 0, 1, -1, 0};
int dx[] = {1, -1, 0, 0, 0};
const int MAX = 510000;
long long fac[MAX], finv[MAX], inv[MAX];
// テーブルを作る前処理
void comb_init() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
int 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;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, m, k;
cin >> n >> m >> k;
ll ans = 0;
comb_init();
for (int i = 0; i < n; i++) {
ans += i * (n - i) * m % MOD * m % MOD * comb(n * m - 2, k - 2) % MOD;
ans %= MOD;
}
for (int i = 0; i < m; i++) {
ans += i * (m - i) * n % MOD * n % MOD * comb(n * m - 2, k - 2) % MOD;
ans %= MOD;
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < n; i++)
#define SORT(v, n) sort(v, v + n);
#define VSORT(v) sort(v.begin(), v.end())
#define VRSORT(v) sort(v.rbegin(), v.rend()) // vectorの降順ソート
#define ll long long
#define pb(a) push_back(a)
#define INF 1000000000
#define LINF 1e18
#define MOD 1000000007
using namespace std;
typedef pair<int, int> P;
typedef pair<ll, ll> LP;
typedef pair<int, P> PP;
typedef pair<ll, LP> LPP;
typedef vector<unsigned int> vec;
typedef vector<vec> mat;
// typedef tuple<ll, ll, ll> T;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
int dy[] = {0, 0, 1, -1, 0};
int dx[] = {1, -1, 0, 0, 0};
const int MAX = 510000;
long long fac[MAX], finv[MAX], inv[MAX];
// テーブルを作る前処理
void comb_init() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long 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;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll n, m, k;
cin >> n >> m >> k;
ll ans = 0;
comb_init();
for (ll i = 0; i < n; i++) {
ans += i * (n - i) * m % MOD * m % MOD * comb(n * m - 2, k - 2) % MOD;
ans %= MOD;
}
for (ll i = 0; i < m; i++) {
ans += i * (m - i) * n % MOD * n % MOD * comb(n * m - 2, k - 2) % MOD;
ans %= MOD;
}
cout << ans << endl;
}
| [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change",
"variable_declaration.type.change",
"control_flow.loop.for.initializer.change"
] | 854,549 | 854,550 | u493750228 | cpp |
p03039 | #include <bits/stdc++.h>
using namespace std;
#define li long long int
#define rep(i, to) for (li i = 0; i < ((li)(to)); i++)
#define repp(i, start, to) for (li i = (li)(start); i < ((li)(to)); i++)
#define pb push_back
#define sz(v) ((li)(v).size())
#define bgn(v) ((v).begin())
#define eend(v) ((v).end())
#define allof(v) (v).begin(), (v).end()
#define dodp(v, n) memset(v, (li)n, sizeof(v))
#define bit(n) (1ll << (li)(n))
#define mp(a, b) make_pair(a, b)
#define rin rep(i, n)
#define EPS 1e-12
#define ETOL 1e-8
#define MOD 1000000007
typedef pair<li, li> PI;
#define INF bit(60)
#define DBGP 1
#define idp if (DBGP)
#define F first
#define S second
#define p2(a, b) idp cout << a << "\t" << b << endl
#define p3(a, b, c) idp cout << a << "\t" << b << "\t" << c << endl
#define p4(a, b, c, d) \
idp cout << a << "\t" << b << "\t" << c << "\t" << d << endl
#define p5(a, b, c, d, e) \
idp cout << a << "\t" << b << "\t" << c << "\t" << d << "\t" << e << endl
#define p6(a, b, c, d, e, f) \
idp cout << a << "\t" << b << "\t" << c << "\t" << d << "\t" << e << "\t" \
<< f << endl
#define p7(a, b, c, d, e, f, g) \
idp cout << a << "\t" << b << "\t" << c << "\t" << d << "\t" << e << "\t" \
<< f << "\t" << g << endl
#define p8(a, b, c, d, e, f, g, h) \
idp cout << a << "\t" << b << "\t" << c << "\t" << d << "\t" << e << "\t" \
<< f << "\t" << g << "\t" << h << endl
#define p9(a, b, c, d, e, f, g, h, i) \
idp cout << a << "\t" << b << "\t" << c << "\t" << d << "\t" << e << "\t" \
<< f << "\t" << g << "\t" << h << "\t" << i << endl
#define p10(a, b, c, d, e, f, g, h, i, j) \
idp cout << a << "\t" << b << "\t" << c << "\t" << d << "\t" << e << "\t" \
<< f << "\t" << g << "\t" << h << "\t" << i << "\t" << j << endl
#define foreach(it, v) \
for (__typeof((v).begin()) it = (v).begin(); it != (v).end(); ++it)
#define p2p(x) idp p2((x).F, (x).S)
#define dump(x, n) \
idp { \
rep(i, n) { cout << x[i] << " "; } \
puts(""); \
}
#define dump2(x, n) \
idp { \
rep(i, n) { cout << "[" << x[i].F << " , " << x[i].S << "] "; } \
puts(""); \
}
#define dumpi(x) \
idp { \
foreach (it, x) { cout << (*it) << " "; } \
puts(""); \
}
#define dumpi2(x) \
idp { \
foreach (it, x) { cout << "[" << (it)->F << " , " << (it)->S << "] "; } \
puts(""); \
}
#define read2d(a, w, h) rep(i, h) rep(j, w) cin >> a[i][j]
#define dump2d(a, w, h) \
rep(i, h) { \
rep(j, w) cout << a[i][j] << " "; \
puts(""); \
}
typedef pair<li, li> PI;
li fact_mod[200100];
inline void init() {
fact_mod[0] = 1;
fact_mod[1] = 1;
repp(i, 2, 200100) { fact_mod[i] = (fact_mod[i - 1] * i) % MOD; }
}
inline li gcd(li a, li b) { return b != 0 ? gcd(b, a % b) : a; }
// a x + b y = gcd(a, b)
inline li extgcd(li a, li b, li &x, li &y) {
li g = a;
x = 1;
y = 0;
if (b != 0)
g = extgcd(b, a % b, y, x), y -= (a / b) * x;
return g;
}
inline li invMod(li a) {
li x, y;
if (extgcd(a, MOD, x, y) == 1)
return (x + MOD) % MOD;
else
return 0; // unsolvable
}
inline li combi(li n, li k) {
return (((fact_mod[n] * invMod(fact_mod[k])) % MOD) *
invMod(fact_mod[n - k])) %
MOD;
}
// sum of 1,2,3,...,x
li sum(li x) { return x * (x + 1) / 2; }
int main() {
init();
li n, m, k;
cin >> n >> m >> k;
li res = 0;
rin {
rep(j, m) {
res += (((sum(i) + sum(n - 1 - i)) % MOD) * m) % MOD;
res += (((sum(j) + sum(m - 1 - j)) % MOD) * n) % MOD;
}
}
res = (res * combi(n * m - 2, k - 2)) % MOD;
res = (res * invMod(2)) % MOD;
cout << res << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define li long long int
#define rep(i, to) for (li i = 0; i < ((li)(to)); i++)
#define repp(i, start, to) for (li i = (li)(start); i < ((li)(to)); i++)
#define pb push_back
#define sz(v) ((li)(v).size())
#define bgn(v) ((v).begin())
#define eend(v) ((v).end())
#define allof(v) (v).begin(), (v).end()
#define dodp(v, n) memset(v, (li)n, sizeof(v))
#define bit(n) (1ll << (li)(n))
#define mp(a, b) make_pair(a, b)
#define rin rep(i, n)
#define EPS 1e-12
#define ETOL 1e-8
#define MOD 1000000007
typedef pair<li, li> PI;
#define INF bit(60)
#define DBGP 1
#define idp if (DBGP)
#define F first
#define S second
#define p2(a, b) idp cout << a << "\t" << b << endl
#define p3(a, b, c) idp cout << a << "\t" << b << "\t" << c << endl
#define p4(a, b, c, d) \
idp cout << a << "\t" << b << "\t" << c << "\t" << d << endl
#define p5(a, b, c, d, e) \
idp cout << a << "\t" << b << "\t" << c << "\t" << d << "\t" << e << endl
#define p6(a, b, c, d, e, f) \
idp cout << a << "\t" << b << "\t" << c << "\t" << d << "\t" << e << "\t" \
<< f << endl
#define p7(a, b, c, d, e, f, g) \
idp cout << a << "\t" << b << "\t" << c << "\t" << d << "\t" << e << "\t" \
<< f << "\t" << g << endl
#define p8(a, b, c, d, e, f, g, h) \
idp cout << a << "\t" << b << "\t" << c << "\t" << d << "\t" << e << "\t" \
<< f << "\t" << g << "\t" << h << endl
#define p9(a, b, c, d, e, f, g, h, i) \
idp cout << a << "\t" << b << "\t" << c << "\t" << d << "\t" << e << "\t" \
<< f << "\t" << g << "\t" << h << "\t" << i << endl
#define p10(a, b, c, d, e, f, g, h, i, j) \
idp cout << a << "\t" << b << "\t" << c << "\t" << d << "\t" << e << "\t" \
<< f << "\t" << g << "\t" << h << "\t" << i << "\t" << j << endl
#define foreach(it, v) \
for (__typeof((v).begin()) it = (v).begin(); it != (v).end(); ++it)
#define p2p(x) idp p2((x).F, (x).S)
#define dump(x, n) \
idp { \
rep(i, n) { cout << x[i] << " "; } \
puts(""); \
}
#define dump2(x, n) \
idp { \
rep(i, n) { cout << "[" << x[i].F << " , " << x[i].S << "] "; } \
puts(""); \
}
#define dumpi(x) \
idp { \
foreach (it, x) { cout << (*it) << " "; } \
puts(""); \
}
#define dumpi2(x) \
idp { \
foreach (it, x) { cout << "[" << (it)->F << " , " << (it)->S << "] "; } \
puts(""); \
}
#define read2d(a, w, h) rep(i, h) rep(j, w) cin >> a[i][j]
#define dump2d(a, w, h) \
rep(i, h) { \
rep(j, w) cout << a[i][j] << " "; \
puts(""); \
}
typedef pair<li, li> PI;
li fact_mod[200100];
inline void init() {
fact_mod[0] = 1;
fact_mod[1] = 1;
repp(i, 2, 200100) { fact_mod[i] = (fact_mod[i - 1] * i) % MOD; }
}
inline li gcd(li a, li b) { return b != 0 ? gcd(b, a % b) : a; }
// a x + b y = gcd(a, b)
inline li extgcd(li a, li b, li &x, li &y) {
li g = a;
x = 1;
y = 0;
if (b != 0)
g = extgcd(b, a % b, y, x), y -= (a / b) * x;
return g;
}
inline li invMod(li a) {
li x, y;
if (extgcd(a, MOD, x, y) == 1)
return (x + MOD) % MOD;
else
return 0; // unsolvable
}
inline li combi(li n, li k) {
return (((fact_mod[n] * invMod(fact_mod[k])) % MOD) *
invMod(fact_mod[n - k])) %
MOD;
}
// sum of 1,2,3,...,x
li sum(li x) { return x * (x + 1) / 2; }
int main() {
init();
li n, m, k;
cin >> n >> m >> k;
li res = 0;
rin {
rep(j, m) {
res = (res + ((sum(i) + sum(n - 1 - i)) % MOD) * m) % MOD;
res = (res + ((sum(j) + sum(m - 1 - j)) % MOD) * n) % MOD;
}
}
res = (res * combi(n * m - 2, k - 2)) % MOD;
res = (res * invMod(2)) % MOD;
cout << res << endl;
return 0;
} | [
"assignment.value.change",
"assignment.change"
] | 854,554 | 854,555 | u962966398 | cpp |
p03039 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll mod = ll(1e9) + 7;
ll modinv(ll a, ll m) { return a == 1 ? 1 : m - modinv(m % a, a) * m / a; }
ll choose(ll n, ll r) {
r = min(r, n - r);
if (r < 0)
return 0;
ll num = 1, den = 1;
for (int i = 0; i < r; i++) {
num *= (n - i), num %= mod;
den *= i + 1, den %= mod;
}
return num * modinv(den, mod) % mod;
}
int main() {
ll N, M, K;
cin >> N >> M >> K;
ll res = (M + N) % mod * M % mod * N % mod * ((M * N - 1) % mod) % mod;
res *= modinv(6, mod), res %= mod;
res *= choose(N * M - 2, K), res %= mod;
cout << res << '\n';
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll mod = ll(1e9) + 7;
ll modinv(ll a, ll m) { return a == 1 ? 1 : m - modinv(m % a, a) * m / a; }
ll choose(ll n, ll r) {
r = min(r, n - r);
if (r < 0)
return 0;
ll num = 1, den = 1;
for (int i = 0; i < r; i++) {
num *= (n - i), num %= mod;
den *= i + 1, den %= mod;
}
return num * modinv(den, mod) % mod;
}
int main() {
ll N, M, K;
cin >> N >> M >> K;
ll res = (M + N) % mod * M % mod * N % mod * ((M * N - 1) % mod) % mod;
res *= modinv(6, mod), res %= mod;
res *= choose(N * M - 2, K - 2), res %= mod;
cout << res << '\n';
} | [
"assignment.change"
] | 854,562 | 854,563 | u570944601 | cpp |
p03039 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
#define N 1000000007
int main() {
long long n, m, k, cost = 0, t = 0;
cin >> n >> m >> k;
for (long long i = 0; i < n; i++)
cost = (cost + (1 + i) * i / 2 * m % N * m % N) % N;
for (long long i = 0; i < m; i++)
cost = (cost + (1 + i) * i / 2 * n % N * n % N) % N;
for (long long i = 2; i <= n * m - 2; i++)
cost = cost * i % N;
for (long long i = 2; i <= k - 2; i++)
t = t * i % N;
for (long long i = 2; i <= (n * m - k); i++)
t = t * i % N;
for (long long x = N - 2; x > 0; t = t * t % N, x >>= 1)
if (x & 1)
cost = cost * t % N;
cout << cost << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
#define N 1000000007
int main() {
long long n, m, k, cost = 0, t = 1;
cin >> n >> m >> k;
for (long long i = 0; i < n; i++)
cost = (cost + (1 + i) * i / 2 * m % N * m % N) % N;
for (long long i = 0; i < m; i++)
cost = (cost + (1 + i) * i / 2 * n % N * n % N) % N;
for (long long i = 2; i <= n * m - 2; i++)
cost = cost * i % N;
for (long long i = 2; i <= k - 2; i++)
t = t * i % N;
for (long long i = 2; i <= (n * m - k); i++)
t = t * i % N;
for (long long x = N - 2; x > 0; t = t * t % N, x >>= 1)
if (x & 1)
cost = cost * t % N;
cout << cost << endl;
return 0;
} | [
"literal.number.change",
"variable_declaration.value.change"
] | 854,568 | 854,569 | u258475646 | cpp |
p03039 | #include <iostream>
using namespace std;
typedef long long ll;
ll mod = 1e9 + 7;
ll fac[100000000];
ll modinv(ll a) {
ll b = mod, u = 1, v = 0;
while (b) {
ll t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= mod;
if (u < 0)
u += mod;
return u;
}
void modfac() {
fac[0] = 1;
for (ll i = 1; i < 100000000; i++) {
fac[i] = (fac[i - 1] * i) % mod;
}
}
ll modperm(ll n, ll k) {
if (n < 0 || k < 0 || n < k)
return 0;
else
return (fac[n] * modinv(fac[n - k])) % mod;
}
ll modcomb(ll n, ll k) {
if (n < 0 || k < 0 || n < k)
return 0;
else
return ((fac[n] * modinv(fac[k])) % mod * modinv(fac[n - k])) % mod;
}
ll dp[200010];
int main() {
ll n, m, k;
cin >> n >> m >> k;
// 2個の時を求めればOK
ll t = (n * m) % mod;
modfac();
ll p = ((k * (k - 1)) % mod * fac[t - 2]) % mod;
p = ((p * modinv(fac[k])) % mod * modinv(fac[t - k])) % mod;
ll len = 0;
for (int i = 0; i < n; i++) {
len += i * (i + 1) / 2;
len %= mod;
}
dp[1] = len;
for (int i = 2; i <= m; i++) {
dp[i] = (dp[i - 1] + len) % mod;
// 深さ期待値i/2
dp[i] += ((len * 2) % mod * (i - 1)) % mod;
dp[i] %= mod;
dp[i] += ((n * n) % mod * ((i * (i - 1) / 2) % mod)) % mod;
dp[i] %= mod;
}
cout << (dp[m] * p) % mod << endl;
} | #include <iostream>
using namespace std;
typedef long long ll;
ll mod = 1e9 + 7;
ll fac[300010];
ll modinv(ll a) {
ll b = mod, u = 1, v = 0;
while (b) {
ll t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= mod;
if (u < 0)
u += mod;
return u;
}
void modfac() {
fac[0] = 1;
for (ll i = 1; i < 300010; i++) {
fac[i] = (fac[i - 1] * i) % mod;
}
}
ll modperm(ll n, ll k) {
if (n < 0 || k < 0 || n < k)
return 0;
else
return (fac[n] * modinv(fac[n - k])) % mod;
}
ll modcomb(ll n, ll k) {
if (n < 0 || k < 0 || n < k)
return 0;
else
return ((fac[n] * modinv(fac[k])) % mod * modinv(fac[n - k])) % mod;
}
ll dp[200010];
int main() {
ll n, m, k;
cin >> n >> m >> k;
// 2個の時を求めればOK
ll t = (n * m) % mod;
modfac();
ll p = ((k * (k - 1)) % mod * fac[t - 2]) % mod;
p = ((p * modinv(fac[k])) % mod * modinv(fac[t - k])) % mod;
ll len = 0;
for (ll i = 0; i < n; i++) {
len += i * (i + 1) / 2;
len %= mod;
}
dp[1] = len;
for (ll i = 2; i <= m; i++) {
dp[i] = (dp[i - 1] + len) % mod;
dp[i] += ((len * 2) % mod * (i - 1)) % mod;
dp[i] %= mod;
dp[i] += ((n * n) % mod * ((i * (i - 1) / 2) % mod)) % mod;
dp[i] %= mod;
}
cout << (dp[m] * p) % mod << endl;
}
| [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"control_flow.loop.for.initializer.change",
"variable_declaration.type.change"
] | 854,575 | 854,574 | u179970156 | cpp |
p03039 | #include <algorithm>
#include <cstdio>
#define mod 1000000007
using namespace std;
typedef long long ll;
ll kai[200001], inv[200001], sum[200001];
ll n, m, k, ans;
ll gyaku(ll x) {
ll res = x;
ll a = mod - 2;
for (int i = 1; i <= 30; i++) {
x = x * x;
x %= mod;
if (((a << i) & a)) {
res *= x;
res %= mod;
}
}
return res;
}
void kaiinit() {
kai[0] = kai[1] = 1LL;
for (ll i = 2; i <= n * m; i++) {
kai[i] = kai[i - 1] * i;
kai[i] %= mod;
}
inv[n * m] = gyaku(kai[n * m]);
for (ll i = n * m - 1; i >= 0; i--) {
inv[i] = inv[i + 1] * (i + 1LL);
inv[i] %= mod;
}
}
int main() {
scanf("%lld %lld %lld", &n, &m, &k);
for (ll i = 1; i <= 200000; i++) {
sum[i] = sum[i - 1] + i;
sum[i] %= mod;
}
for (ll i = 0; i < m; i++) {
ans += (sum[m - i - 1]) * n * n;
ans %= mod;
}
for (ll i = 0; i < n; i++) {
ans += (sum[n - i - 1]) * m * m;
ans %= mod;
}
if (k != 2) {
kaiinit();
ans *= kai[n * m - 2];
ans %= mod;
ans *= inv[k - 2];
ans %= mod;
ans *= inv[n * m - k + 2];
ans %= mod;
}
printf("%lld\n", ans);
} | #include <algorithm>
#include <cstdio>
#define mod 1000000007
using namespace std;
typedef long long ll;
ll kai[200001], inv[200001], sum[200001];
ll n, m, k, ans;
ll gyaku(ll x) {
ll res = x;
ll a = mod - 2;
for (int i = 1; i < 30; i++) {
x = x * x;
x %= mod;
if (((1 << i) & a)) {
res *= x;
res %= mod;
}
}
return res;
}
void kaiinit() {
kai[0] = kai[1] = 1LL;
for (ll i = 2; i <= n * m; i++) {
kai[i] = kai[i - 1] * i;
kai[i] %= mod;
}
inv[n * m] = gyaku(kai[n * m]);
for (ll i = n * m - 1; i >= 0; i--) {
inv[i] = inv[i + 1] * (i + 1LL);
inv[i] %= mod;
}
}
int main() {
scanf("%lld %lld %lld", &n, &m, &k);
for (ll i = 1; i <= 200000; i++) {
sum[i] = sum[i - 1] + i;
sum[i] %= mod;
}
for (ll i = 0; i < m; i++) {
ans += (sum[m - i - 1]) * n * n;
ans %= mod;
}
for (ll i = 0; i < n; i++) {
ans += (sum[n - i - 1]) * m * m;
ans %= mod;
}
if (k != 2) {
kaiinit();
ans *= kai[n * m - 2];
ans %= mod;
ans *= inv[k - 2];
ans %= mod;
ans *= inv[n * m - k];
ans %= mod;
}
printf("%lld\n", ans);
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"identifier.replace.remove",
"literal.replace.add",
"control_flow.branch.if.condition.change",
"expression.operation.binary.remove"
] | 854,614 | 854,615 | u855429581 | cpp |
p03039 | #include <algorithm>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#define MOD (1000000007l)
#define rep(i, n) for (long i = 0; i < n; i++)
using namespace std;
long modinv(long a) {
long M = MOD, b = M, u = 1, v = 0;
while (b)
u -= a / b * v, swap(u, v), a %= b, swap(a, b);
return (u % M + M) % M;
}
long foo(long N) {
if (N == 0)
return 0;
long result = foo(N - 1) + (N * (N - 1) / 2);
return result % MOD;
}
int main(void) {
cout.precision(12);
long N, M, K;
cin >> N >> M >> K;
vector<long> memo(N * M + 1);
memo[0] = 1;
for (long i = 1; i <= M * M; i++) {
memo[i] = (memo[i - 1] * i) % MOD;
}
// 置き方
long puttings = memo[N * M];
puttings = (puttings * modinv(memo[K])) % MOD;
puttings = (puttings * modinv(memo[N * M - K])) % MOD;
// 期待値
/*
pair<long, long> n_expect = make_pair(foo(N), N*N);
pair<long, long> m_expect = make_pair(foo(M), M*M);
*/
// pair<long, long> expect = make_pair(foo(N) * M * M + foo(M) * N * N, N * N
// * M * M);
// K == N*M のときのコスト
long a = foo(N) * M * M + foo(M) * N * N;
a %= MOD;
a = (a * modinv(memo[2])) % MOD;
long x = (N * M) * (N * M - 1) / 2;
x %= MOD;
long y = K * (K - 1) / 2;
y %= MOD;
y *= puttings;
y %= MOD;
long result = a;
result *= y;
result %= MOD;
result *= modinv(x);
result %= MOD;
result *= 2;
result %= MOD;
cout << result << endl;
return 0;
}
| #include <algorithm>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#define MOD (1000000007l)
#define rep(i, n) for (long i = 0; i < n; i++)
using namespace std;
long modinv(long a) {
long M = MOD, b = M, u = 1, v = 0;
while (b)
u -= a / b * v, swap(u, v), a %= b, swap(a, b);
return (u % M + M) % M;
}
long foo(long N) {
if (N == 0)
return 0;
long result = foo(N - 1) + (N * (N - 1) / 2);
return result % MOD;
}
int main(void) {
cout.precision(12);
long N, M, K;
cin >> N >> M >> K;
vector<long> memo(N * M + 1);
memo[0] = 1;
for (long i = 1; i <= N * M; i++) {
memo[i] = (memo[i - 1] * i) % MOD;
}
// 置き方
long puttings = memo[N * M];
puttings = (puttings * modinv(memo[K])) % MOD;
puttings = (puttings * modinv(memo[N * M - K])) % MOD;
// 期待値
/*
pair<long, long> n_expect = make_pair(foo(N), N*N);
pair<long, long> m_expect = make_pair(foo(M), M*M);
*/
// pair<long, long> expect = make_pair(foo(N) * M * M + foo(M) * N * N, N * N
// * M * M);
// K == N*M のときのコスト
long a = foo(N) * M * M + foo(M) * N * N;
a %= MOD;
a = (a * modinv(memo[2])) % MOD;
long x = (N * M) * (N * M - 1) / 2;
x %= MOD;
long y = K * (K - 1) / 2;
y %= MOD;
y *= puttings;
y %= MOD;
long result = a;
result *= y;
result %= MOD;
result *= modinv(x);
result %= MOD;
result *= 2;
result %= MOD;
/*
cout << "puttings: " << puttings << endl;
cout << "a: " << a << endl;
cout << "x: " << x << endl;
cout << "y: " << y << endl;
*/
cout << result << endl;
return 0;
}
| [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 854,632 | 854,633 | u995792346 | cpp |
p03040 | #include <algorithm>
#include <array>
#include <bitset>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
const ll mod = 1000000007;
#define rep(i, n) for (int i = 0; i < n; i++)
#define Rep(i, n) for (int i = 1; i < n + 1; i++)
void sol(vector<int> vec, int num, ll B) {
ll val = 0;
cout << vec[(num + 1) / 2 - 1] << " ";
rep(i, num) {
if (i < (num + 1) / 2)
val += vec[(num + 1) / 2 - 1] - vec[i];
else
val += vec[i] - vec[(num + 1) / 2 - 1];
}
cout << val + B << endl;
}
int main() {
int Q;
int q, a, b;
ll B = 0;
vector<int> vec;
int num = 0, hoge;
cin >> Q;
ll val = 0;
rep(i, Q) {
cin >> q;
if (q == 2) {
cout << vec[(num + 1) / 2 - 1] << " " << val + B << endl;
} else {
cin >> a >> b;
auto itr = upper_bound(vec.begin(), vec.end(), a);
hoge = itr - vec.begin();
if (num % 2 == 0) {
if (hoge == num / 2)
;
else if (hoge < num / 2) {
val += vec[num / 2 - 1] - a;
} else {
val += a - vec[num / 2 + 1];
}
} else {
if (hoge <= num / 2) {
val += vec[num / 2] - a;
} else {
val += a - vec[num / 2];
}
}
vec.insert(itr, a);
num++;
B += b;
}
}
return 0;
} | #include <algorithm>
#include <array>
#include <bitset>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
const ll mod = 1000000007;
#define rep(i, n) for (int i = 0; i < n; i++)
#define Rep(i, n) for (int i = 1; i < n + 1; i++)
void sol(vector<int> vec, int num, ll B) {
ll val = 0;
cout << vec[(num + 1) / 2 - 1] << " ";
rep(i, num) {
if (i < (num + 1) / 2)
val += vec[(num + 1) / 2 - 1] - vec[i];
else
val += vec[i] - vec[(num + 1) / 2 - 1];
}
cout << val + B << endl;
}
int main() {
int Q;
int q, a, b;
ll B = 0;
vector<int> vec;
int num = 0, hoge;
cin >> Q;
ll val = 0;
rep(i, Q) {
cin >> q;
if (q == 2) {
cout << vec[(num + 1) / 2 - 1] << " " << val + B << endl;
} else {
cin >> a >> b;
auto itr = upper_bound(vec.begin(), vec.end(), a);
hoge = itr - vec.begin();
if (num % 2 == 0) {
if (hoge == num / 2)
;
else if (hoge < num / 2) {
val += vec[num / 2 - 1] - a;
} else {
val += a - vec[num / 2];
}
} else {
if (hoge <= num / 2) {
val += vec[num / 2] - a;
} else {
val += a - vec[num / 2];
}
}
vec.insert(itr, a);
num++;
B += b;
}
}
return 0;
} | [] | 854,638 | 854,639 | u563710899 | cpp |
p03040 | #include <algorithm>
#include <array>
#include <bitset>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
const ll mod = 1000000007;
#define rep(i, n) for (int i = 0; i < n; i++)
#define Rep(i, n) for (int i = 1; i < n + 1; i++)
void sol(vector<int> vec, int num, ll B) {
ll val = 0;
cout << vec[(num + 1) / 2 - 1] << " ";
rep(i, num) {
if (i < (num + 1) / 2)
val += vec[(num + 1) / 2 - 1] - vec[i];
else
val += vec[i] - vec[(num + 1) / 2 - 1];
}
cout << val + B << endl;
}
int main() {
int Q;
int q, a, b;
ll B = 0;
vector<int> vec;
int num = 0, hoge;
cin >> Q;
ll val = 0;
rep(i, Q) {
cin >> q;
if (q == 2) {
cout << vec[(num + 1) / 2 - 1] << " " << val + B << endl;
} else {
cin >> a >> b;
auto itr = upper_bound(vec.begin(), vec.end(), a);
hoge = itr - vec.begin();
if (num % 2 == 0) {
if (hoge == num / 2)
;
else if (hoge < num / 2) {
val += vec[num / 2 - 1] - a;
} else {
val += a - vec[num / 2 - 1];
}
} else {
if (hoge <= num / 2) {
val += vec[num / 2] - a;
} else {
val += a - vec[num / 2];
}
}
vec.insert(itr, a);
num++;
B += b;
}
}
return 0;
} | #include <algorithm>
#include <array>
#include <bitset>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
const ll mod = 1000000007;
#define rep(i, n) for (int i = 0; i < n; i++)
#define Rep(i, n) for (int i = 1; i < n + 1; i++)
void sol(vector<int> vec, int num, ll B) {
ll val = 0;
cout << vec[(num + 1) / 2 - 1] << " ";
rep(i, num) {
if (i < (num + 1) / 2)
val += vec[(num + 1) / 2 - 1] - vec[i];
else
val += vec[i] - vec[(num + 1) / 2 - 1];
}
cout << val + B << endl;
}
int main() {
int Q;
int q, a, b;
ll B = 0;
vector<int> vec;
int num = 0, hoge;
cin >> Q;
ll val = 0;
rep(i, Q) {
cin >> q;
if (q == 2) {
cout << vec[(num + 1) / 2 - 1] << " " << val + B << endl;
} else {
cin >> a >> b;
auto itr = upper_bound(vec.begin(), vec.end(), a);
hoge = itr - vec.begin();
if (num % 2 == 0) {
if (hoge == num / 2)
;
else if (hoge < num / 2) {
val += vec[num / 2 - 1] - a;
} else {
val += a - vec[num / 2];
}
} else {
if (hoge <= num / 2) {
val += vec[num / 2] - a;
} else {
val += a - vec[num / 2];
}
}
vec.insert(itr, a);
num++;
B += b;
}
}
return 0;
} | [] | 854,640 | 854,639 | u563710899 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define mp make_pair
#define fs first
#define sc second
int q;
long long leftsum, rightsum, bsum;
priority_queue<int> maxh;
priority_queue<int, vector<int>, greater<int>> minh;
void print_min() {
long long med = maxh.top();
long long lsize = maxh.size() - 1;
long long rsize = minh.size();
long long res = bsum;
res += med * lsize - (leftsum - med);
res += rightsum - med * rsize;
cout << med << " " << res << "\n";
}
void update(int a, int b) {
bsum += b;
if (maxh.size() == 0 || maxh.top() >= a) {
maxh.push(a);
leftsum += a;
} else {
minh.push(a);
rightsum += a;
}
if (maxh.size() > minh.size() + 1) {
leftsum -= maxh.top();
rightsum += maxh.top();
minh.push(maxh.top());
maxh.pop();
} else if (minh.size() > maxh.size()) {
leftsum += maxh.top();
rightsum -= maxh.top();
maxh.push(minh.top());
minh.pop();
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> q;
for (int t = 0; t < q; ++t) {
int c;
cin >> c;
if (c == 2) {
print_min();
} else {
int a, b;
cin >> a >> b;
update(a, b);
}
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define mp make_pair
#define fs first
#define sc second
int q;
long long leftsum, rightsum, bsum;
priority_queue<int> maxh;
priority_queue<int, vector<int>, greater<int>> minh;
void print_min() {
long long med = maxh.top();
long long lsize = maxh.size() - 1;
long long rsize = minh.size();
long long res = bsum;
res += med * lsize - (leftsum - med);
res += rightsum - med * rsize;
cout << med << " " << res << "\n";
}
void update(int a, int b) {
bsum += b;
if (maxh.size() == 0 || maxh.top() >= a) {
maxh.push(a);
leftsum += a;
} else {
minh.push(a);
rightsum += a;
}
if (maxh.size() > minh.size() + 1) {
leftsum -= maxh.top();
rightsum += maxh.top();
minh.push(maxh.top());
maxh.pop();
} else if (minh.size() > maxh.size()) {
leftsum += minh.top();
rightsum -= minh.top();
maxh.push(minh.top());
minh.pop();
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> q;
for (int t = 0; t < q; ++t) {
int c;
cin >> c;
if (c == 2) {
print_min();
} else {
int a, b;
cin >> a >> b;
update(a, b);
}
}
return 0;
}
| [
"assignment.value.change",
"identifier.change"
] | 854,641 | 854,642 | u870592517 | cpp |
p03040 | #include <algorithm>
#include <cmath>
#include <cstring>
#include <iostream>
#include <set>
#include <string>
#include <vector>
using namespace std;
int main() {
int Q;
cin >> Q;
int cnt = 0;
long long bSum = 0;
pair<int, int> median;
long long leftSum = 0;
long long rightSum = 0;
set<pair<int, int>> s;
for (int i = 0; i < Q; i++) {
int type;
cin >> type;
if (type == 1) {
int a, b;
cin >> a >> b;
cnt++;
s.insert(make_pair(a, cnt));
bSum += b;
if (i == 0) {
median = make_pair(a, cnt);
} else {
if (make_pair(a, cnt) < median) {
if (cnt % 2 == 0) {
// left
auto temp = s.find(median);
temp--;
rightSum += median.first;
leftSum += a;
median = *temp;
} else {
// same
leftSum += a;
rightSum -= median.first;
}
} else {
if (cnt % 2 == 0) {
// same
rightSum += a;
leftSum += median.first;
} else {
// right
auto temp = s.find(median);
temp++;
rightSum += a;
median = *temp;
rightSum -= median.first;
}
}
}
} else {
long long ans = bSum - leftSum + rightSum;
cout << median.first << " " << ans << "\n";
}
}
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstring>
#include <iostream>
#include <set>
#include <string>
#include <vector>
using namespace std;
int main() {
int Q;
cin >> Q;
int cnt = 0;
long long bSum = 0;
pair<int, int> median;
long long leftSum = 0;
long long rightSum = 0;
set<pair<int, int>> s;
for (int i = 0; i < Q; i++) {
int type;
cin >> type;
if (type == 1) {
int a, b;
cin >> a >> b;
cnt++;
s.insert(make_pair(a, cnt));
bSum += b;
if (i == 0) {
median = make_pair(a, cnt);
} else {
if (make_pair(a, cnt) < median) {
if (cnt % 2 == 0) {
// left
auto temp = s.find(median);
temp--;
rightSum += median.first;
leftSum += a;
median = *temp;
} else {
// same
leftSum += a;
leftSum -= median.first;
}
} else {
if (cnt % 2 == 0) {
// same
rightSum += a;
leftSum += median.first;
} else {
// right
auto temp = s.find(median);
temp++;
rightSum += a;
median = *temp;
rightSum -= median.first;
}
}
}
} else {
long long ans = bSum - leftSum + rightSum;
cout << median.first << " " << ans << "\n";
}
}
return 0;
} | [
"assignment.variable.change",
"identifier.change"
] | 854,643 | 854,644 | u048945791 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
int main(void) {
long long Q;
cin >> Q;
set<long long> left, right;
long long bsum = 0;
long long msum = 0;
long long geta = 1E+10;
for (long long q = 0; q < Q; q++) {
int type;
cin >> type;
if (type == 1) {
long long a, b;
cin >> a >> b;
bsum += b;
long long m = 0;
if (left.size() > 0)
m = *(left.rbegin()) / Q - geta;
else {
goto hoge;
}
if ((a + geta) * Q + q < *(left.rbegin())) {
msum += m - a;
hoge:;
left.insert(Q * (a + geta) + q);
} else {
right.insert(Q * (a + geta) + q);
msum += a - m;
}
if (left.size() < right.size()) {
long long rmin = *(right.begin());
right.erase(rmin);
rmin /= Q;
rmin -= geta;
long long lmax = *(left.rbegin());
left.insert((rmin + geta) * Q + q);
lmax /= Q;
lmax -= geta;
msum += rmin - lmax;
} else if (left.size() > right.size() + 1) {
long long lmax = *(left.rbegin());
left.erase(lmax);
lmax /= Q;
lmax -= geta;
long long rmin = *(right.begin());
right.insert((lmax + geta) * Q + q);
rmin /= Q;
rmin -= geta;
// msum += rmin - lmax;
}
// cout << "L: " << left.size() << " R: " << right.size() << endl;
} else {
cout << *(left.rbegin()) / Q - geta << " " << msum + bsum << endl;
}
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main(void) {
long long Q;
cin >> Q;
set<long long> left, right;
long long bsum = 0;
long long msum = 0;
long long geta = 1E+10;
for (long long q = 0; q < Q; q++) {
int type;
cin >> type;
if (type == 1) {
long long a, b;
cin >> a >> b;
bsum += b;
long long m = 0;
if (left.size() > 0)
m = *(left.rbegin()) / Q - geta;
else {
goto hoge;
}
if ((a + geta) * Q + q < *(left.rbegin())) {
msum += m - a;
hoge:;
left.insert(Q * (a + geta) + q);
} else {
right.insert(Q * (a + geta) + q);
msum += a - m;
}
if (left.size() < right.size()) {
long long rmin = *(right.begin());
right.erase(rmin);
rmin /= Q;
rmin -= geta;
long long lmax = *(left.rbegin());
left.insert((rmin + geta) * Q + q);
lmax /= Q;
lmax -= geta;
msum -= rmin - lmax;
} else if (left.size() > right.size() + 1) {
long long lmax = *(left.rbegin());
left.erase(lmax);
lmax /= Q;
lmax -= geta;
long long rmin = *(right.begin());
right.insert((lmax + geta) * Q + q);
rmin /= Q;
rmin -= geta;
// msum += rmin - lmax;
}
// cout << "L: " << left.size() << " R: " << right.size() << endl;
} else {
cout << *(left.rbegin()) / Q - geta << " " << msum + bsum << endl;
}
}
return 0;
} | [
"expression.operator.change"
] | 854,645 | 854,646 | u898331860 | cpp |
p03040 | #include <iostream>
#include <queue>
using namespace std;
int main() {
int Q;
cin >> Q;
priority_queue<int, vector<int>, greater<int>> que2;
priority_queue<int, vector<int>> que1;
long sum1 = 0;
long sum2 = 0;
long sumb = 0;
int cnt = 0;
for (int i = 0; i < Q; i++) {
int t;
cin >> t;
if (t == 1) {
cnt++;
int a, b;
cin >> a >> b;
sumb += b;
if (cnt <= 2) {
que1.push(a);
sum1 += a;
} else {
long t1 = que1.top();
long t2 = que2.top();
if (t2 < a) {
que2.push(a);
sum2 += a;
} else {
que1.push(a);
sum1 += a;
}
}
if (que1.size() > (cnt + 1) / 2) {
long top = que1.top();
que1.pop();
que2.push(top);
sum1 -= top;
sum2 += top;
}
if (que2.size() > cnt / 2) {
long top = que2.top();
que2.pop();
que1.push(top);
sum2 -= top;
sum1 += top;
}
} else {
long m = que1.top();
long ans = 0;
ans = (sum1 - que1.size() * m) + (sum2 - que2.size() * m) + sumb;
cout << m << ' ' << ans << endl;
}
}
} | #include <iostream>
#include <queue>
using namespace std;
int main() {
int Q;
cin >> Q;
priority_queue<int, vector<int>, greater<int>> que2;
priority_queue<int, vector<int>> que1;
long sum1 = 0;
long sum2 = 0;
long sumb = 0;
int cnt = 0;
for (int i = 0; i < Q; i++) {
int t;
cin >> t;
if (t == 1) {
cnt++;
int a, b;
cin >> a >> b;
sumb += b;
if (cnt <= 2) {
que1.push(a);
sum1 += a;
} else {
long t1 = que1.top();
long t2 = que2.top();
if (t2 < a) {
que2.push(a);
sum2 += a;
} else {
que1.push(a);
sum1 += a;
}
}
if (que1.size() > (cnt + 1) / 2) {
long top = que1.top();
que1.pop();
que2.push(top);
sum1 -= top;
sum2 += top;
}
if (que2.size() > cnt / 2) {
long top = que2.top();
que2.pop();
que1.push(top);
sum2 -= top;
sum1 += top;
}
} else {
long m = que1.top();
long ans = 0;
ans = -(sum1 - que1.size() * m) + (sum2 - que2.size() * m) + sumb;
cout << m << ' ' << ans << endl;
}
}
} | [
"expression.operation.unary.add"
] | 854,649 | 854,650 | u693133807 | cpp |
p03040 | #include <bits/stdc++.h>
template <typename InputIterator>
typename InputIterator::value_type summation(InputIterator first,
InputIterator last) {
return std::accumulate(first, last, typename InputIterator::value_type());
}
template <typename T>
std::istream &operator>>(std::istream &stream, std::vector<T> &v);
template <typename T1, typename T2>
std::istream &operator>>(std::istream &stream, std::pair<T1, T2> &p);
template <typename T>
std::istream &operator>>(std::istream &stream, std::vector<T> &v) {
for (auto &i : v) {
stream >> i;
}
return stream;
}
template <typename T1, typename T2>
std::istream &operator>>(std::istream &stream, std::pair<T1, T2> &p) {
stream >> p.first >> p.second;
return stream;
}
int main() {
int64_t q;
std::cin >> q;
std::set<std::pair<int64_t, int64_t>> a;
int64_t b = 0;
int64_t cost = 0;
{
int64_t n, ai, bi;
std::cin >> n >> ai >> bi;
a.insert({ai, 0});
b += bi;
}
auto itr = a.cbegin();
for (int64_t i = 1; i < q; i++) {
int64_t n;
std::cin >> n;
if (n == 1) {
int64_t ai, bi;
std::cin >> ai >> bi;
b += bi;
a.insert({ai, i});
if (itr->first < ai) {
if (a.size() % 2 == 1) {
cost += std::abs(ai - itr->first);
} else {
itr++;
cost += std::abs(ai - itr->first);
}
} else if (itr->first == ai) {
if (a.size() % 2 == 0) {
itr++;
}
} else {
if (a.size() % 2 == 1) {
const auto before = itr->first;
itr--;
cost += std::abs(before - itr->first);
cost += std::abs(ai - itr->first);
} else {
cost += std::abs(ai - itr->first);
}
}
} else {
std::cout << itr->first << " " << cost + b << std::endl;
}
}
return 0;
} | #include <bits/stdc++.h>
template <typename InputIterator>
typename InputIterator::value_type summation(InputIterator first,
InputIterator last) {
return std::accumulate(first, last, typename InputIterator::value_type());
}
template <typename T>
std::istream &operator>>(std::istream &stream, std::vector<T> &v);
template <typename T1, typename T2>
std::istream &operator>>(std::istream &stream, std::pair<T1, T2> &p);
template <typename T>
std::istream &operator>>(std::istream &stream, std::vector<T> &v) {
for (auto &i : v) {
stream >> i;
}
return stream;
}
template <typename T1, typename T2>
std::istream &operator>>(std::istream &stream, std::pair<T1, T2> &p) {
stream >> p.first >> p.second;
return stream;
}
int main() {
int64_t q;
std::cin >> q;
std::set<std::pair<int64_t, int64_t>> a;
int64_t b = 0;
int64_t cost = 0;
{
int64_t n, ai, bi;
std::cin >> n >> ai >> bi;
a.insert({ai, 0});
b += bi;
}
auto itr = a.cbegin();
for (int64_t i = 1; i < q; i++) {
int64_t n;
std::cin >> n;
if (n == 1) {
int64_t ai, bi;
std::cin >> ai >> bi;
b += bi;
a.insert({ai, i});
if (itr->first < ai) {
if (a.size() % 2 == 0) {
cost += std::abs(ai - itr->first);
} else {
itr++;
cost += std::abs(ai - itr->first);
}
} else if (itr->first == ai) {
if (a.size() % 2 == 1) {
itr++;
}
} else {
if (a.size() % 2 == 0) {
const auto before = itr->first;
itr--;
cost += std::abs(before - itr->first);
cost += std::abs(ai - itr->first);
} else {
cost += std::abs(ai - itr->first);
}
}
} else {
std::cout << itr->first << " " << cost + b << std::endl;
}
}
return 0;
} | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 854,651 | 854,652 | u438319362 | cpp |
p03040 | #include <algorithm>
#include <iostream>
#include <map>
#include <vector>
using namespace std;
typedef long long ll;
ll n, t[400010] = {};
void built() {
for (int i = n - 1; i > 0; i--) {
t[i] = t[i << 1] + t[i << 1 | 1];
}
}
void update(ll p, ll a) {
for (t[p += n] += a; p > 1; p >>= 1) {
t[p >> 1] = t[p] + t[p ^ 1];
}
}
ll query(int l, int r) {
ll sum = 0;
for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
if (l & 1)
sum += t[l++];
if (r & 1)
sum += t[--r];
}
return sum;
}
int midi(ll y) {
int l = 0, r = n;
while (r - l > 1) {
int mid = (l + r) / 2;
// cout << "a " << l << " " << mid << " " << query(0,mid) << endl;
if (query(l, mid) >= (y + 1) / 2)
r = mid;
else
l = mid;
}
return r;
}
ll s[400010] = {};
void update2(ll p, ll a) {
for (s[p += n] += a; p > 1; p >>= 1) {
s[p >> 1] = s[p] + s[p ^ 1];
}
}
ll query2(int l, int r) {
ll sum = 0;
for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
if (l & 1)
sum += s[l++];
if (r & 1)
sum += s[--r];
}
return sum;
}
ll a[200010], b[200010], c[200010], inv[200010];
vector<ll> v;
map<ll, int> mp;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int i, q;
cin >> q;
for (i = 0; i < q; i++) {
cin >> c[i];
if (c[i] == 1) {
cin >> a[i] >> b[i];
v.push_back(a[i]);
}
}
sort(v.begin(), v.end());
int now = 0;
mp[v[0]] = now;
inv[0] = v[0];
for (i = 1; i < v.size(); i++) {
if (v[i - 1] < v[i])
now++;
mp[v[i]] = now;
inv[now] = v[i];
}
now++;
n = now;
int cnt = 0;
ll p = 0;
for (i = 0; i < q; i++) {
if (c[i] == 1) {
update(mp[a[i]], 1);
update2(mp[a[i]], a[i]);
cnt++;
p += b[i];
} else {
ll z = midi(cnt);
ll k = query(0, z), l = query(z, now);
// cout << z << " " << k << " " << l << " " << p << endl;
// cout << query2(0,z) << " " << query2(z,now) << endl;
cout << inv[z - 1] << " "
<< -query2(0, z) + query2(z, now) + (k - l) * inv[z - 1] + p << "\n";
}
}
} | #include <algorithm>
#include <iostream>
#include <map>
#include <vector>
using namespace std;
typedef long long ll;
ll n, t[400010] = {};
void built() {
for (int i = n - 1; i > 0; i--) {
t[i] = t[i << 1] + t[i << 1 | 1];
}
}
void update(ll p, ll a) {
for (t[p += n] += a; p > 1; p >>= 1) {
t[p >> 1] = t[p] + t[p ^ 1];
}
}
ll query(int l, int r) {
ll sum = 0;
for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
if (l & 1)
sum += t[l++];
if (r & 1)
sum += t[--r];
}
return sum;
}
int midi(ll y) {
int l = 0, r = n;
while (r - l > 1) {
int mid = (l + r) / 2;
// cout << "a " << l << " " << mid << " " << query(0,mid) << endl;
if (query(0, mid) >= (y + 1) / 2)
r = mid;
else
l = mid;
}
return r;
}
ll s[400010] = {};
void update2(ll p, ll a) {
for (s[p += n] += a; p > 1; p >>= 1) {
s[p >> 1] = s[p] + s[p ^ 1];
}
}
ll query2(int l, int r) {
ll sum = 0;
for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
if (l & 1)
sum += s[l++];
if (r & 1)
sum += s[--r];
}
return sum;
}
ll a[200010], b[200010], c[200010], inv[200010];
vector<ll> v;
map<ll, int> mp;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int i, q;
cin >> q;
for (i = 0; i < q; i++) {
cin >> c[i];
if (c[i] == 1) {
cin >> a[i] >> b[i];
v.push_back(a[i]);
}
}
sort(v.begin(), v.end());
int now = 0;
mp[v[0]] = now;
inv[0] = v[0];
for (i = 1; i < v.size(); i++) {
if (v[i - 1] < v[i])
now++;
mp[v[i]] = now;
inv[now] = v[i];
}
now++;
n = now;
int cnt = 0;
ll p = 0;
for (i = 0; i < q; i++) {
if (c[i] == 1) {
update(mp[a[i]], 1);
update2(mp[a[i]], a[i]);
cnt++;
p += b[i];
} else {
ll z = midi(cnt);
ll k = query(0, z), l = query(z, now);
// cout << z << " " << k << " " << l << " " << p << endl;
// cout << query2(0,z) << " " << query2(z,now) << endl;
cout << inv[z - 1] << " "
<< -query2(0, z) + query2(z, now) + (k - l) * inv[z - 1] + p << "\n";
}
}
} | [
"identifier.replace.remove",
"literal.replace.add",
"control_flow.branch.if.condition.change"
] | 854,661 | 854,662 | u621509943 | cpp |
p03040 | #include <algorithm>
#include <iostream>
#include <map>
#include <vector>
using namespace std;
typedef long long ll;
ll n, t[400010] = {};
void built() {
for (int i = n - 1; i > 0; i--) {
t[i] = t[i << 1] + t[i << 1 | 1];
}
}
void update(ll p, ll a) {
for (t[p += n] += a; p > 1; p >>= 1) {
t[p >> 1] = t[p] + t[p ^ 1];
}
}
ll query(int l, int r) {
ll sum = 0;
for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
if (l & 1)
sum += t[l++];
if (r & 1)
sum += t[--r];
}
return sum;
}
int midi(ll y) {
int l = 0, r = n;
while (r - l > 1) {
int mid = (l + r) / 2;
// cout << "a " << l << " " << mid << " " << query(0,mid) << endl;
if (query(l, mid) >= (y + 1) / 2)
r = mid;
else
l = mid;
}
return r;
}
ll s[400010] = {};
void update2(ll p, ll a) {
for (s[p += n] += a; p > 1; p >>= 1) {
s[p >> 1] = s[p] + s[p ^ 1];
}
}
ll query2(int l, int r) {
ll sum = 0;
for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
if (l & 1)
sum += s[l++];
if (r & 1)
sum += s[--r];
}
return sum;
}
ll a[200010], b[200010], c[200010], inv[200010];
vector<ll> v;
map<ll, int> mp;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int i, q;
cin >> q;
for (i = 0; i < q; i++) {
cin >> c[i];
if (c[i] == 1) {
cin >> a[i] >> b[i];
v.push_back(a[i]);
}
}
sort(v.begin(), v.end());
int now = 0;
mp[v[0]] = now;
inv[0] = v[0];
for (i = 1; i < v.size(); i++) {
if (v[i - 1] < v[i])
now++;
mp[v[i]] = now;
inv[now] = v[i];
}
now++;
n = now;
int cnt = 0;
ll p = 0;
for (i = 0; i < q; i++) {
if (c[i] == 1) {
update(mp[a[i]], 1);
update2(mp[a[i]], a[i]);
cnt++;
p += b[i];
} else {
ll z = midi(cnt);
ll k = query(0, z), l = query(z, now);
// cout << z << " " << k << " " << l << " " << p << endl;
// cout << query2(0,z + 1) << " " << query2(z + 1,now) << endl;
cout << inv[z - 1] << " "
<< -query2(0, z) + query2(z, now) + (k - l) * inv[z] + p << "\n";
}
}
} | #include <algorithm>
#include <iostream>
#include <map>
#include <vector>
using namespace std;
typedef long long ll;
ll n, t[400010] = {};
void built() {
for (int i = n - 1; i > 0; i--) {
t[i] = t[i << 1] + t[i << 1 | 1];
}
}
void update(ll p, ll a) {
for (t[p += n] += a; p > 1; p >>= 1) {
t[p >> 1] = t[p] + t[p ^ 1];
}
}
ll query(int l, int r) {
ll sum = 0;
for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
if (l & 1)
sum += t[l++];
if (r & 1)
sum += t[--r];
}
return sum;
}
int midi(ll y) {
int l = 0, r = n;
while (r - l > 1) {
int mid = (l + r) / 2;
// cout << "a " << l << " " << mid << " " << query(0,mid) << endl;
if (query(0, mid) >= (y + 1) / 2)
r = mid;
else
l = mid;
}
return r;
}
ll s[400010] = {};
void update2(ll p, ll a) {
for (s[p += n] += a; p > 1; p >>= 1) {
s[p >> 1] = s[p] + s[p ^ 1];
}
}
ll query2(int l, int r) {
ll sum = 0;
for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
if (l & 1)
sum += s[l++];
if (r & 1)
sum += s[--r];
}
return sum;
}
ll a[200010], b[200010], c[200010], inv[200010];
vector<ll> v;
map<ll, int> mp;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int i, q;
cin >> q;
for (i = 0; i < q; i++) {
cin >> c[i];
if (c[i] == 1) {
cin >> a[i] >> b[i];
v.push_back(a[i]);
}
}
sort(v.begin(), v.end());
int now = 0;
mp[v[0]] = now;
inv[0] = v[0];
for (i = 1; i < v.size(); i++) {
if (v[i - 1] < v[i])
now++;
mp[v[i]] = now;
inv[now] = v[i];
}
now++;
n = now;
int cnt = 0;
ll p = 0;
for (i = 0; i < q; i++) {
if (c[i] == 1) {
update(mp[a[i]], 1);
update2(mp[a[i]], a[i]);
cnt++;
p += b[i];
} else {
ll z = midi(cnt);
ll k = query(0, z), l = query(z, now);
// cout << z << " " << k << " " << l << " " << p << endl;
// cout << query2(0,z) << " " << query2(z,now) << endl;
cout << inv[z - 1] << " "
<< -query2(0, z) + query2(z, now) + (k - l) * inv[z - 1] + p << "\n";
}
}
} | [
"identifier.replace.remove",
"literal.replace.add",
"control_flow.branch.if.condition.change"
] | 854,663 | 854,662 | u621509943 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
typedef unsigned long long ul;
typedef signed long long ll;
ul over = 1000000007;
mt19937 mt(time(nullptr));
// uniform_int_distribution< int > rand_int(0, 10) // rand[0, 10] inclusive
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed;
int q;
cin >> q;
ll bsum = 0;
multiset<tuple<ll, int>> st;
int s, ai, bi;
cin >> s >> ai >> bi;
st.insert(make_tuple(ai, 0));
bsum += bi;
auto itr = st.begin();
ll diffsum = 0;
for (int i = 1; i < q; ++i) {
int s;
cin >> s;
if (s == 1) {
ll ai, bi;
cin >> ai >> bi;
st.insert(make_tuple(ai, i));
diffsum += abs(get<0>(*itr) - ai);
if (st.size() % 2 == 0 && get<0>(*itr) > ai) {
itr--;
} else if (st.size() % 2 == 1 && get<0>(*itr) <= ai) {
itr++;
auto new_itr = itr;
diffsum += get<0>(*(new_itr--)) - get<0>(*itr);
}
bsum += bi;
} else {
cout << get<0>(*itr) << " " << bsum + diffsum << endl;
}
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef unsigned long long ul;
typedef signed long long ll;
ul over = 1000000007;
mt19937 mt(time(nullptr));
// uniform_int_distribution< int > rand_int(0, 10) // rand[0, 10] inclusive
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed;
int q;
cin >> q;
ll bsum = 0;
multiset<tuple<ll, int>> st;
int s, ai, bi;
cin >> s >> ai >> bi;
st.insert(make_tuple(ai, 0));
bsum += bi;
auto itr = st.begin();
ll diffsum = 0;
for (int i = 1; i < q; ++i) {
int s;
cin >> s;
if (s == 1) {
ll ai, bi;
cin >> ai >> bi;
st.insert(make_tuple(ai, i));
diffsum += abs(get<0>(*itr) - ai);
if (st.size() % 2 == 0 && get<0>(*itr) > ai) {
itr--;
} else if (st.size() % 2 == 1 && get<0>(*itr) <= ai) {
itr++;
auto new_itr = itr;
new_itr--;
// cout << get<0>(*new_itr) << "/" << get<0>(*itr) << endl;
diffsum += get<0>(*(new_itr--)) - get<0>(*itr);
}
bsum += bi;
// cout << bsum << "+" << diffsum << endl;
// cout << get<0>(*itr) << " " << bsum + diffsum << endl;
} else {
// cout << bsum << " " << diffsum << endl;
cout << get<0>(*itr) << " " << bsum + diffsum << endl;
}
}
return 0;
}
| [
"expression.unary.arithmetic.add"
] | 854,672 | 854,673 | u691764803 | cpp |
p03040 | #define _USE_MATH_DEFINES
#include <algorithm>
#include <array>
#include <bitset>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <list>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <regex>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
int main() {
int q;
cin >> q;
multiset<int> ms;
auto it = ms.begin();
long long ans = 0;
while (--q >= 0) {
int type;
cin >> type;
if (type == 2) {
cout << *it << ' ' << ans << endl;
continue;
}
int a, b;
cin >> a >> b;
if (ms.empty()) {
ms.insert(a);
it = ms.begin();
ans = b;
continue;
}
ms.insert(a);
ans += abs(a - *it) + b;
if (ms.size() % 2 == 0 && a < *it) {
--it;
} else if (ms.size() % 2 != 0 && *it <= a) {
ans -= *it;
++it;
ans += *it;
}
}
return 0;
}
| #define _USE_MATH_DEFINES
#include <algorithm>
#include <array>
#include <bitset>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <list>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <regex>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
int main() {
int q;
cin >> q;
multiset<long long> ms;
auto it = ms.begin();
long long ans = 0;
while (--q >= 0) {
int type;
cin >> type;
if (type == 2) {
cout << *it << ' ' << ans << endl;
continue;
}
long long a, b;
cin >> a >> b;
if (ms.empty()) {
ms.insert(a);
it = ms.begin();
ans = b;
continue;
}
ms.insert(a);
ans += abs(a - *it) + b;
if (ms.size() % 2 == 0 && a < *it) {
--it;
} else if (ms.size() % 2 != 0 && *it <= a) {
ans += *it;
++it;
ans -= *it;
}
}
return 0;
}
| [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change",
"expression.operator.change"
] | 854,676 | 854,675 | u917944707 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
unsigned xor128() {
static unsigned x = 123456789, y = 362436069, z = 521288629, w = 88675123;
unsigned t = x ^ (x << 11);
x = y;
y = z;
z = w;
return w = w ^ (w >> 19) ^ (t ^ (t >> 8));
}
namespace randomized_binary_search_tree {
using T = int;
const T id = 0;
T op(T l, T r) { return l + r; }
struct node {
T val, all;
node *lch, *rch;
int size;
node(T v, node *l = nullptr, node *r = nullptr)
: val(v), all(v), lch(l), rch(r), size(1) {}
};
int count(node *t) { return t ? t->size : 0; }
T que(node *t) { return t ? t->all : id; }
node *update(node *t) {
t->size = count(t->lch) + count(t->rch) + 1;
t->all = op(op(que(t->lch), t->val), que(t->rch));
return t;
}
node *merge(node *l, node *r) {
if (!l || !r)
return !l ? r : l;
if (xor128() % (l->size + r->size) < (unsigned)l->size) {
l->rch = merge(l->rch, r);
return update(l);
}
r->lch = merge(l, r->lch);
return update(r);
}
pair<node *, node *> split(node *t, int k) {
if (!t)
return make_pair(nullptr, nullptr);
if (k <= count(t->lch)) {
pair<node *, node *> s = split(t->lch, k);
t->lch = s.second;
return make_pair(s.first, update(t));
}
pair<node *, node *> s = split(t->rch, k - count(t->lch) - 1);
t->rch = s.first;
return make_pair(update(t), s.second);
}
node *insert(node *t, int k, T v) {
pair<node *, node *> s = split(t, k);
node *r = merge(s.first, new node(v));
r = merge(r, s.second);
return r;
}
void update_val(node *t, int k, T v) {
if (!t)
return;
int c = count(t->lch);
if (k < c)
update_val(t->lch, k, v);
else if (k > c)
update_val(t->rch, k - (c + 1), v);
else
t->val = v;
t->all = op(op(que(t->lch), t->val), que(t->rch));
}
T find(node *t, int l, int r) {
if (!t)
return id;
if (r <= 0 || count(t) <= l)
return id;
if (l <= 0 && count(t) <= r)
return t->all;
int c = count(t->lch);
return op(find(t->lch, l, r), op(l <= c && c < r ? t->val : id,
find(t->rch, l - (c + 1), r - (c + 1))));
}
int count_lower(node *t, T v) {
if (!t)
return 0;
if (t->val < v)
return count(t->lch) + 1 + count_lower(t->rch, v);
if (t->val == v)
return count(t->lch);
return count_lower(t->lch, v);
}
} // namespace randomized_binary_search_tree
using namespace randomized_binary_search_tree;
int main() {
ios::sync_with_stdio(false), cin.tie(0);
int Q;
cin >> Q;
node *tree = nullptr;
ll off = 0;
int sz = 0;
while (Q--) {
int com;
cin >> com;
if (com == 1) {
int a, b;
cin >> a >> b;
off += b;
tree = insert(tree, count_lower(tree, a), a);
++sz;
} else {
int p = (sz - 1) / 2;
ll v = find(tree, p, p + 1);
ll ls = find(tree, 0, p + 1);
ll rs = find(tree, p + 1, sz);
ll val = v * (p + 1) - ls + rs - (v * (sz - p - 1)) + off;
cout << v << ' ' << val << '\n';
}
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
unsigned xor128() {
static unsigned x = 123456789, y = 362436069, z = 521288629, w = 88675123;
unsigned t = x ^ (x << 11);
x = y;
y = z;
z = w;
return w = w ^ (w >> 19) ^ (t ^ (t >> 8));
}
namespace randomized_binary_search_tree {
using T = ll;
const T id = 0;
T op(T l, T r) { return l + r; }
struct node {
T val, all;
node *lch, *rch;
int size;
node(T v, node *l = nullptr, node *r = nullptr)
: val(v), all(v), lch(l), rch(r), size(1) {}
};
int count(node *t) { return t ? t->size : 0; }
T que(node *t) { return t ? t->all : id; }
node *update(node *t) {
t->size = count(t->lch) + count(t->rch) + 1;
t->all = op(op(que(t->lch), t->val), que(t->rch));
return t;
}
node *merge(node *l, node *r) {
if (!l || !r)
return !l ? r : l;
if (xor128() % (l->size + r->size) < (unsigned)l->size) {
l->rch = merge(l->rch, r);
return update(l);
}
r->lch = merge(l, r->lch);
return update(r);
}
pair<node *, node *> split(node *t, int k) {
if (!t)
return make_pair(nullptr, nullptr);
if (k <= count(t->lch)) {
pair<node *, node *> s = split(t->lch, k);
t->lch = s.second;
return make_pair(s.first, update(t));
}
pair<node *, node *> s = split(t->rch, k - count(t->lch) - 1);
t->rch = s.first;
return make_pair(update(t), s.second);
}
node *insert(node *t, int k, T v) {
pair<node *, node *> s = split(t, k);
node *r = merge(s.first, new node(v));
r = merge(r, s.second);
return r;
}
void update_val(node *t, int k, T v) {
if (!t)
return;
int c = count(t->lch);
if (k < c)
update_val(t->lch, k, v);
else if (k > c)
update_val(t->rch, k - (c + 1), v);
else
t->val = v;
t->all = op(op(que(t->lch), t->val), que(t->rch));
}
T find(node *t, int l, int r) {
if (!t)
return id;
if (r <= 0 || count(t) <= l)
return id;
if (l <= 0 && count(t) <= r)
return t->all;
int c = count(t->lch);
return op(find(t->lch, l, r), op(l <= c && c < r ? t->val : id,
find(t->rch, l - (c + 1), r - (c + 1))));
}
int count_lower(node *t, T v) {
if (!t)
return 0;
if (t->val < v)
return count(t->lch) + 1 + count_lower(t->rch, v);
if (t->val == v)
return count(t->lch);
return count_lower(t->lch, v);
}
} // namespace randomized_binary_search_tree
using namespace randomized_binary_search_tree;
int main() {
ios::sync_with_stdio(false), cin.tie(0);
int Q;
cin >> Q;
node *tree = nullptr;
ll off = 0;
int sz = 0;
while (Q--) {
int com;
cin >> com;
if (com == 1) {
int a, b;
cin >> a >> b;
off += b;
tree = insert(tree, count_lower(tree, a), a);
++sz;
} else {
int p = (sz - 1) / 2;
ll v = find(tree, p, p + 1);
ll ls = find(tree, 0, p + 1);
ll rs = find(tree, p + 1, sz);
ll val = v * (p + 1) - ls + rs - (v * (sz - p - 1)) + off;
cout << v << ' ' << val << '\n';
}
}
return 0;
}
| [] | 854,677 | 854,678 | u752161277 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
struct fast_ios {
fast_ios() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
};
} fast_ios_;
#define FOR(i, begin, end) for (int i = (begin); i < (end); i++)
#define REP(i, n) FOR(i, 0, n)
#define IFOR(i, begin, end) for (int i = (end)-1; i >= (begin); i--)
#define IREP(i, n) IFOR(i, 0, n)
#define Sort(v) sort(v.begin(), v.end())
#define Reverse(v) reverse(v.begin(), v.end())
#define all(v) v.begin(), v.end()
#define SZ(v) ((int)v.size())
#define Lower_bound(v, x) \
distance(v.begin(), lower_bound(v.begin(), v.end(), x))
#define Upper_bound(v, x) \
distance(v.begin(), upper_bound(v.begin(), v.end(), x))
#define Max(a, b) a = max(a, b)
#define Min(a, b) a = min(a, b)
#define bit(n) (1LL << (n))
#define bit_exist(x, n) ((x >> n) & 1)
#define debug(x) cout << #x << "=" << x << endl;
#define vdebug(v) \
cout << #v << "=" << endl; \
REP(i_debug, v.size()) { cout << v[i_debug] << ","; } \
cout << endl;
#define mdebug(m) \
cout << #m << "=" << endl; \
REP(i_debug, m.size()) { \
REP(j_debug, m[i_debug].size()) { cout << m[i_debug][j_debug] << ","; } \
cout << endl; \
}
#define pb push_back
#define f first
#define s second
#define int long long
#define INF 1000000000000000000
template <typename T> istream &operator>>(istream &is, vector<T> &v) {
for (auto &x : v)
is >> x;
return is;
}
template <typename T> ostream &operator<<(ostream &os, vector<T> &v) {
for (int i = 0; i < v.size(); i++) {
cout << v[i];
if (i != v.size() - 1)
cout << endl;
};
return os;
}
template <typename T> void Out(T x) { cout << x << endl; }
template <typename T1, typename T2> void Ans(bool f, T1 y, T2 n) {
if (f)
Out(y);
else
Out(n);
}
using vec = vector<int>;
using mat = vector<vec>;
using Pii = pair<int, int>;
using PiP = pair<int, Pii>;
using PPi = pair<Pii, int>;
using bools = vector<bool>;
using pairs = vector<Pii>;
// int dx[4] = {1,0,-1,0};
// int dy[4] = {0,1,0,-1};
// char d[4] = {'D','R','U','L'};
const int mod = 1000000007;
// const int mod = 998244353;
#define Add(x, y) x = (x + (y)) % mod
#define Mult(x, y) x = (x * (y)) % mod
struct SegmentTree {
using T = int;
int N;
vector<T> dat;
T id = 0;
T F(T &a, T &b) { return a + b; }
SegmentTree(int n) {
N = 1;
while (n > N)
N = N << 1;
dat = vector<T>(2 * N - 1, id);
}
SegmentTree(int n, vector<T> &v) {
N = 1;
while (n > N)
N = N << 1;
dat = vector<T>(2 * N - 1, id);
for (int i = 0; i < n; i++)
dat[i + N - 1] = v[i];
for (int i = N - 2; i >= 0; i--)
dat[i] = F(dat[i * 2 + 1], dat[i * 2 + 2]);
}
void update(int k, T a) {
k += N - 1;
dat[k] = a;
while (k > 0) {
k = (k - 1) / 2;
dat[k] = F(dat[k * 2 + 1], dat[k * 2 + 2]);
}
}
void reset() { fill(dat.begin(), dat.end(), id); }
T get(int a, int b, int k, int l, int r) {
if (r <= a || b <= l)
return id;
if (a <= l && r <= b)
return dat[k];
else {
T vl = get(a, b, k * 2 + 1, l, (l + r) / 2);
T vr = get(a, b, k * 2 + 2, (l + r) / 2, r);
return F(vl, vr);
}
}
T get(int a, int b) { return get(a, b, 0, 0, N); }
T val(int k) { return dat[k + N - 1]; }
};
signed main() {
int Q;
cin >> Q;
vec t(Q), a(Q), b(Q);
set<int> s;
REP(q, Q) {
cin >> t[q];
if (t[q] == 1) {
cin >> a[q] >> b[q];
s.insert(a[q]);
}
}
vec v;
for (int i : s)
v.pb(i);
int n = SZ(v);
SegmentTree ST1(n), ST2(n);
int B = 0;
pairs ans;
REP(q, Q) {
if (t[q] == 1) {
int i0 = Lower_bound(v, a[q]);
B += b[q];
ST1.update(i0, ST1.val(i0) + 1);
ST2.update(i0, ST2.val(i0) + a[q]);
} else {
int N = ST1.get(0, n);
int i0 = 0, i1 = n;
while (i1 - i0 > 1) {
int i = (i0 + i1) / 2;
if (ST1.get(0, i) <= N / 2)
i0 = i;
else
i1 = i;
}
int tmp = B;
tmp += ST2.get(i0 + 1, n) - ST1.get(i0 + 1, n) * v[i0];
tmp += -ST2.get(0, i0 + 1) + ST1.get(0, i0 + 1) * v[i0];
ans.pb(Pii(v[i0], tmp));
}
}
REP(i, SZ(ans)) { cout << ans[i].f << " " << ans[i].s << endl; }
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
struct fast_ios {
fast_ios() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
};
} fast_ios_;
#define FOR(i, begin, end) for (int i = (begin); i < (end); i++)
#define REP(i, n) FOR(i, 0, n)
#define IFOR(i, begin, end) for (int i = (end)-1; i >= (begin); i--)
#define IREP(i, n) IFOR(i, 0, n)
#define Sort(v) sort(v.begin(), v.end())
#define Reverse(v) reverse(v.begin(), v.end())
#define all(v) v.begin(), v.end()
#define SZ(v) ((int)v.size())
#define Lower_bound(v, x) \
distance(v.begin(), lower_bound(v.begin(), v.end(), x))
#define Upper_bound(v, x) \
distance(v.begin(), upper_bound(v.begin(), v.end(), x))
#define Max(a, b) a = max(a, b)
#define Min(a, b) a = min(a, b)
#define bit(n) (1LL << (n))
#define bit_exist(x, n) ((x >> n) & 1)
#define debug(x) cout << #x << "=" << x << endl;
#define vdebug(v) \
cout << #v << "=" << endl; \
REP(i_debug, v.size()) { cout << v[i_debug] << ","; } \
cout << endl;
#define mdebug(m) \
cout << #m << "=" << endl; \
REP(i_debug, m.size()) { \
REP(j_debug, m[i_debug].size()) { cout << m[i_debug][j_debug] << ","; } \
cout << endl; \
}
#define pb push_back
#define f first
#define s second
#define int long long
#define INF 1000000000000000000
template <typename T> istream &operator>>(istream &is, vector<T> &v) {
for (auto &x : v)
is >> x;
return is;
}
template <typename T> ostream &operator<<(ostream &os, vector<T> &v) {
for (int i = 0; i < v.size(); i++) {
cout << v[i];
if (i != v.size() - 1)
cout << endl;
};
return os;
}
template <typename T> void Out(T x) { cout << x << endl; }
template <typename T1, typename T2> void Ans(bool f, T1 y, T2 n) {
if (f)
Out(y);
else
Out(n);
}
using vec = vector<int>;
using mat = vector<vec>;
using Pii = pair<int, int>;
using PiP = pair<int, Pii>;
using PPi = pair<Pii, int>;
using bools = vector<bool>;
using pairs = vector<Pii>;
// int dx[4] = {1,0,-1,0};
// int dy[4] = {0,1,0,-1};
// char d[4] = {'D','R','U','L'};
const int mod = 1000000007;
// const int mod = 998244353;
#define Add(x, y) x = (x + (y)) % mod
#define Mult(x, y) x = (x * (y)) % mod
struct SegmentTree {
using T = int;
int N;
vector<T> dat;
T id = 0;
T F(T &a, T &b) { return a + b; }
SegmentTree(int n) {
N = 1;
while (n > N)
N = N << 1;
dat = vector<T>(2 * N - 1, id);
}
SegmentTree(int n, vector<T> &v) {
N = 1;
while (n > N)
N = N << 1;
dat = vector<T>(2 * N - 1, id);
for (int i = 0; i < n; i++)
dat[i + N - 1] = v[i];
for (int i = N - 2; i >= 0; i--)
dat[i] = F(dat[i * 2 + 1], dat[i * 2 + 2]);
}
void update(int k, T a) {
k += N - 1;
dat[k] = a;
while (k > 0) {
k = (k - 1) / 2;
dat[k] = F(dat[k * 2 + 1], dat[k * 2 + 2]);
}
}
void reset() { fill(dat.begin(), dat.end(), id); }
T get(int a, int b, int k, int l, int r) {
if (r <= a || b <= l)
return id;
if (a <= l && r <= b)
return dat[k];
else {
T vl = get(a, b, k * 2 + 1, l, (l + r) / 2);
T vr = get(a, b, k * 2 + 2, (l + r) / 2, r);
return F(vl, vr);
}
}
T get(int a, int b) { return get(a, b, 0, 0, N); }
T val(int k) { return dat[k + N - 1]; }
};
signed main() {
int Q;
cin >> Q;
vec t(Q), a(Q), b(Q);
set<int> s;
REP(q, Q) {
cin >> t[q];
if (t[q] == 1) {
cin >> a[q] >> b[q];
s.insert(a[q]);
}
}
vec v;
for (int i : s)
v.pb(i);
int n = SZ(v);
SegmentTree ST1(n), ST2(n);
int B = 0;
pairs ans;
REP(q, Q) {
if (t[q] == 1) {
int i0 = Lower_bound(v, a[q]);
B += b[q];
ST1.update(i0, ST1.val(i0) + 1);
ST2.update(i0, ST2.val(i0) + a[q]);
} else {
int N = ST1.get(0, n);
int i0 = 0, i1 = n;
while (i1 - i0 > 1) {
int i = (i0 + i1) / 2;
if (ST1.get(0, i) < (N + 1) / 2)
i0 = i;
else
i1 = i;
}
int tmp = B;
tmp += ST2.get(i0 + 1, n) - ST1.get(i0 + 1, n) * v[i0];
tmp += -ST2.get(0, i0 + 1) + ST1.get(0, i0 + 1) * v[i0];
ans.pb(Pii(v[i0], tmp));
}
}
REP(i, SZ(ans)) { cout << ans[i].f << " " << ans[i].s << endl; }
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 854,679 | 854,680 | u434231045 | cpp |
p03040 | #include <algorithm>
#include <iostream>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
#define vel vector<long long>
#define vvel vector<vel>
#define int long long
#define rep(i, n) for (long long i = 0; i < n; i++)
#define sor(v) sort(v.begin(), v.end())
#define mmax(a, b) a = max(a, b)
#define mmin(a, b) a = min(a, b)
#define mkp make_pair
#define pin pair<int, int>
#define V vector
long long p = 1000000007;
vel kai(20001, 1);
vel ink(20001, 1);
int le = (1 << 20) + 1;
vel BIT(le, 0);
vel uni(vel &list) {
if (list.size() == 0) {
return list;
}
sort(list.begin(), list.end());
vel ql(1, list[0]);
rep(i, list.size() - 1) {
if (list[i] != list[i + 1]) {
ql.push_back(list[i + 1]);
}
}
list = ql;
return ql;
}
int ru(int a, int r) {
if (r == 0) {
return 1;
}
int ans = ru(a, r / 2);
ans *= ans;
ans %= p;
if (r % 2 == 1) {
ans *= a;
}
return ans % p;
}
int inv(int a) { return ru(a, p - 2); }
void make_kai() {
rep(i, 20000) { kai[i + 1] = (kai[i] * (i + 1)) % p; }
rep(i, 20001) { ink[i] = inv(kai[i]); }
}
int com(int n, int r) {
int ans = kai[n] * ink[r];
ans %= p;
ans *= ink[n - r];
ans %= p;
return ans;
}
int per(int n, int r) {
int ans = kai[n] * ink[n - r];
ans %= p;
return ans;
}
signed main() {
int n;
cin >> n;
priority_queue<int> q0;
priority_queue<int> q1;
int s0 = 0, s1 = 0;
int sm0 = 0, sm1 = 0;
int all_sum = 0;
rep(i, n) {
int s;
cin >> s;
if (s == 1) {
int a, b;
cin >> a >> b;
all_sum += b;
if (s1 == 0 or a < -q1.top()) {
q0.push(a);
sm0 += a;
s0++;
} else {
q1.push(a);
sm1 += a;
s1++;
}
if (s0 > s1 + 1) {
s0--;
s1++;
int tp = q0.top();
q0.pop();
q1.push(tp);
sm0 -= tp;
sm1 += tp;
}
if (s0 < s1) {
s0++;
s1--;
int tp = -q1.top();
q1.pop();
q0.push(tp);
sm0 += tp;
sm1 -= tp;
}
} else {
int tp = q0.top();
cout << tp << " ";
int ans = all_sum;
ans += tp * s0 - sm0;
ans += sm1 - tp * s1;
cout << ans << endl;
}
}
return 0;
}
| #include <algorithm>
#include <iostream>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
#define vel vector<long long>
#define vvel vector<vel>
#define int long long
#define rep(i, n) for (long long i = 0; i < n; i++)
#define sor(v) sort(v.begin(), v.end())
#define mmax(a, b) a = max(a, b)
#define mmin(a, b) a = min(a, b)
#define mkp make_pair
#define pin pair<int, int>
#define V vector
long long p = 1000000007;
vel kai(20001, 1);
vel ink(20001, 1);
int le = (1 << 20) + 1;
vel BIT(le, 0);
vel uni(vel &list) {
if (list.size() == 0) {
return list;
}
sort(list.begin(), list.end());
vel ql(1, list[0]);
rep(i, list.size() - 1) {
if (list[i] != list[i + 1]) {
ql.push_back(list[i + 1]);
}
}
list = ql;
return ql;
}
int ru(int a, int r) {
if (r == 0) {
return 1;
}
int ans = ru(a, r / 2);
ans *= ans;
ans %= p;
if (r % 2 == 1) {
ans *= a;
}
return ans % p;
}
int inv(int a) { return ru(a, p - 2); }
void make_kai() {
rep(i, 20000) { kai[i + 1] = (kai[i] * (i + 1)) % p; }
rep(i, 20001) { ink[i] = inv(kai[i]); }
}
int com(int n, int r) {
int ans = kai[n] * ink[r];
ans %= p;
ans *= ink[n - r];
ans %= p;
return ans;
}
int per(int n, int r) {
int ans = kai[n] * ink[n - r];
ans %= p;
return ans;
}
signed main() {
int n;
cin >> n;
priority_queue<int> q0;
priority_queue<int> q1;
int s0 = 0, s1 = 0;
int sm0 = 0, sm1 = 0;
int all_sum = 0;
rep(i, n) {
int s;
cin >> s;
if (s == 1) {
int a, b;
cin >> a >> b;
all_sum += b;
if (s1 == 0 or a < -q1.top()) {
q0.push(a);
sm0 += a;
s0++;
} else {
q1.push(-a);
sm1 += a;
s1++;
}
if (s0 > s1 + 1) {
s0--;
s1++;
int tp = q0.top();
q0.pop();
q1.push(-tp);
sm0 -= tp;
sm1 += tp;
}
if (s0 < s1) {
s0++;
s1--;
int tp = -q1.top();
q1.pop();
q0.push(tp);
sm0 += tp;
sm1 -= tp;
}
} else {
int tp = q0.top();
cout << tp << " ";
int ans = all_sum;
ans += tp * s0 - sm0;
ans += sm1 - tp * s1;
cout << ans << endl;
}
}
return 0;
}
| [
"expression.operation.unary.add",
"call.arguments.change"
] | 854,689 | 854,690 | u021034020 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef double db;
typedef pair<ll, ll> P;
#define pb push_back
#define ft first
#define sd second
#define mp make_pair
#define fr(i, n) for (int i = 0; i < (n); i++)
#define Fr(i, n) for (int i = 0; i++ < (n);)
#define ifr(i, n) for (int i = (n)-1; i >= 0; i--)
#define iFr(i, n) for (int i = (n); i > 0; i--)
void cc(ll a, map<ll, bool> &ap, map<ll, int> &nm, vector<int> &c) {
if (!ap[a]) {
ap[a] = 1;
nm[a] = c.size();
c.pb(a);
}
}
struct BIT {
vector<ll> bt;
ll n, m;
BIT(ll n_) {
n = n_;
m = 1;
while (m <= n_)
m *= 2;
m /= 2;
bt.resize(n + 1);
}
ll sum(ll i) {
if (!i)
return 0;
return bt[i] + sum(i - (i & -i));
}
ll sum(ll i, ll j) { return sum(j - 1) - sum(i - 1); }
ll ad(ll i, ll x) {
if (i > n)
return i;
bt[i] += x;
ad(i + (i & -i), x);
return i;
}
ll lb(ll k) {
ll x = 0;
for (int i = m; i > 0; i /= 2) {
if (x + i <= n && bt[x + i] < k) {
k -= bt[x + i];
x += i;
}
}
return x + 1;
}
};
int main() {
ll q;
cin >> q;
map<ll, bool> ap;
map<ll, int> nm;
vector<int> c;
vector<ll> t(q), a(q), b(q), sb(q + 1), kaa;
fr(i, q) {
sb[i + 1] = sb[i];
cin >> t[i];
if (!(--t[i])) {
cin >> a[i] >> b[i];
sb[i] += b[i];
kaa.emplace_back(a[i]);
}
}
sort(kaa.begin(), kaa.end());
for (auto i : kaa)
cc(i, ap, nm, c);
ll m = c.size();
BIT bt1(m), bt2(m);
ll cnt = 0, kb = 0;
fr(i, q) {
// cout<<i<<endl;
if (t[i]) {
ll kari = kb, p = bt1.lb((cnt + 1) / 2);
// cout<<bt2.sum(p+1,m+1)<<" "<<bt1.sum(p+1,m+1)<<" "<<c[p-1]<<endl;
kari += bt2.sum(p + 1, m + 1) - bt1.sum(p + 1, m + 1) * c[p - 1];
// cout<<bt2.sum(1,p)<<" "<<bt1.sum(1,p)<<" "<<-c[p-1]<<endl;
kari += bt2.sum(1, p) + bt1.sum(1, p) * c[p - 1];
cout << c[p - 1] << " " << kari << endl;
} else {
bt1.ad(nm[a[i]] + 1, 1);
bt2.ad(nm[a[i]] + 1, a[i]);
cnt++;
kb += b[i];
}
}
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef double db;
typedef pair<ll, ll> P;
#define pb push_back
#define ft first
#define sd second
#define mp make_pair
#define fr(i, n) for (int i = 0; i < (n); i++)
#define Fr(i, n) for (int i = 0; i++ < (n);)
#define ifr(i, n) for (int i = (n)-1; i >= 0; i--)
#define iFr(i, n) for (int i = (n); i > 0; i--)
void cc(ll a, map<ll, bool> &ap, map<ll, int> &nm, vector<int> &c) {
if (!ap[a]) {
ap[a] = 1;
nm[a] = c.size();
c.pb(a);
}
}
struct BIT {
vector<ll> bt;
ll n, m;
BIT(ll n_) {
n = n_;
m = 1;
while (m <= n_)
m *= 2;
m /= 2;
bt.resize(n + 1);
}
ll sum(ll i) {
if (!i)
return 0;
return bt[i] + sum(i - (i & -i));
}
ll sum(ll i, ll j) { return sum(j - 1) - sum(i - 1); }
ll ad(ll i, ll x) {
if (i > n)
return i;
bt[i] += x;
ad(i + (i & -i), x);
return i;
}
ll lb(ll k) {
ll x = 0;
for (int i = m; i > 0; i /= 2) {
if (x + i <= n && bt[x + i] < k) {
k -= bt[x + i];
x += i;
}
}
return x + 1;
}
};
int main() {
ll q;
cin >> q;
map<ll, bool> ap;
map<ll, int> nm;
vector<int> c;
vector<ll> t(q), a(q), b(q), sb(q + 1), kaa;
fr(i, q) {
sb[i + 1] = sb[i];
cin >> t[i];
if (!(--t[i])) {
cin >> a[i] >> b[i];
sb[i] += b[i];
kaa.emplace_back(a[i]);
}
}
sort(kaa.begin(), kaa.end());
for (auto i : kaa)
cc(i, ap, nm, c);
ll m = c.size();
BIT bt1(m), bt2(m);
ll cnt = 0, kb = 0;
fr(i, q) {
// cout<<i<<endl;
if (t[i]) {
ll kari = kb, p = bt1.lb((cnt + 1) / 2);
// cout<<bt2.sum(p+1,m+1)<<" "<<bt1.sum(p+1,m+1)<<" "<<c[p-1]<<endl;
kari += bt2.sum(p + 1, m + 1) - bt1.sum(p + 1, m + 1) * c[p - 1];
// cout<<bt2.sum(1,p)<<" "<<bt1.sum(1,p)<<" "<<-c[p-1]<<endl;
kari += -bt2.sum(1, p) + bt1.sum(1, p) * c[p - 1];
cout << c[p - 1] << " " << kari << endl;
} else {
bt1.ad(nm[a[i]] + 1, 1);
bt2.ad(nm[a[i]] + 1, a[i]);
cnt++;
kb += b[i];
}
}
} | [
"expression.operation.unary.add"
] | 854,693 | 854,694 | u434208140 | cpp |
p03040 | #include <algorithm>
#include <cassert>
#include <chrono>
#include <cmath>
#include <cstdio>
#include <ctime>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
using namespace std;
namespace {
using Integer = long long; //__int128;
template <class T, class S> istream &operator>>(istream &is, pair<T, S> &p) {
return is >> p.first >> p.second;
}
template <class T> istream &operator>>(istream &is, vector<T> &vec) {
for (T &val : vec)
is >> val;
return is;
}
template <class T> istream &operator,(istream &is, T &val) { return is >> val; }
template <class T, class S>
ostream &operator<<(ostream &os, const pair<T, S> &p) {
return os << p.first << " " << p.second;
}
template <class T> ostream &operator<<(ostream &os, const vector<T> &vec) {
for (size_t i = 0; i < vec.size(); i++)
os << vec[i] << (i == vec.size() - 1 ? "" : " ");
return os;
}
template <class T> ostream &operator,(ostream &os, const T &val) {
return os << " " << val;
}
template <class H> void print(const H &head) { cout << head; }
template <class H, class... T> void print(const H &head, const T &...tail) {
cout << head << " ";
print(tail...);
}
template <class... T> void println(const T &...values) {
print(values...);
cout << endl;
}
template <class H> void eprint(const H &head) { cerr << head; }
template <class H, class... T> void eprint(const H &head, const T &...tail) {
cerr << head << " ";
eprint(tail...);
}
template <class... T> void eprintln(const T &...values) {
eprint(values...);
cerr << endl;
}
class range {
Integer start_, end_, step_;
public:
struct range_iterator {
Integer val, step_;
range_iterator(Integer v, Integer step) : val(v), step_(step) {}
Integer operator*() { return val; }
void operator++() { val += step_; }
bool operator!=(range_iterator &x) {
return step_ > 0 ? val < x.val : val > x.val;
}
};
range(Integer len) : start_(0), end_(len), step_(1) {}
range(Integer start, Integer end) : start_(start), end_(end), step_(1) {}
range(Integer start, Integer end, Integer step)
: start_(start), end_(end), step_(step) {}
range_iterator begin() { return range_iterator(start_, step_); }
range_iterator end() { return range_iterator(end_, step_); }
};
inline string operator"" _s(const char *str, size_t size) {
return move(string(str));
}
constexpr Integer my_pow(Integer x, Integer k, Integer z = 1) {
return k == 0 ? z
: k == 1 ? z * x
: (k & 1) ? my_pow(x * x, k >> 1, z * x)
: my_pow(x * x, k >> 1, z);
}
constexpr Integer my_pow_mod(Integer x, Integer k, Integer M, Integer z = 1) {
return k == 0 ? z % M
: k == 1 ? z * x % M
: (k & 1) ? my_pow_mod(x * x % M, k >> 1, M, z * x % M)
: my_pow_mod(x * x % M, k >> 1, M, z);
}
constexpr unsigned long long operator"" _ten(unsigned long long value) {
return my_pow(10, value);
}
inline int k_bit(Integer x, int k) { return (x >> k) & 1; } // 0-indexed
mt19937 mt(chrono::duration_cast<chrono::nanoseconds>(
chrono::steady_clock::now().time_since_epoch())
.count());
template <class T> string join(const vector<T> &v, const string &sep) {
stringstream ss;
for (size_t i = 0; i < v.size(); i++) {
if (i > 0)
ss << sep;
ss << v[i];
}
return ss.str();
}
inline string operator*(string s, int k) {
string ret;
while (k) {
if (k & 1)
ret += s;
s += s;
k >>= 1;
}
return ret;
}
} // namespace
constexpr long long mod = 9_ten + 7;
int main() {
int q;
cin >> q;
priority_queue<int, vector<int>, less<int>> l;
priority_queue<int, vector<int>, greater<int>> r;
long long l0 = -1000000000;
long long r0 = +1000000000;
long long lv = 0;
long long rv = 0;
long long k = 0;
long long c = 0;
// vector<long long> med;
while (q--) {
int t;
cin >> t;
if (t == 1) {
long long a, b;
cin >> a, b;
k += b;
if (l.size() == 0) {
l.push(a);
lv += abs(a - l0);
} else if (l.top() >= a) {
l.push(a);
lv += abs(a - l0);
if (l.size() - r.size() > 1) {
long long tmp = l.top();
lv -= abs(tmp - l0);
l.pop();
r.push(tmp);
rv += abs(r0 - tmp);
}
} else {
r.push(a);
rv += abs(r0 - a);
if (r.size() > l.size()) {
long long tmp = r.top();
rv -= abs(r0 - tmp);
r.pop();
l.push(tmp);
lv += abs(tmp - lv);
}
}
assert((int)l.size() - (int)r.size() >= 0);
assert((int)l.size() - (int)r.size() <= 1);
if (l.size() && r.size())
assert(l.top() <= r.top());
c = l.top();
// med.push_back(a);
// sort(med.begin(), med.end());
// eprintln(med, ":", med[(med.size()-1)/2], c);
// assert(med[(med.size()-1)/2] == c);
} else if (t == 2) {
long long ans = (long long)l.size() * abs(c - l0) - lv;
ans += (long long)r.size() * abs(r0 - c) - rv;
ans += k;
println(c, ans);
}
}
return 0;
}
| #include <algorithm>
#include <cassert>
#include <chrono>
#include <cmath>
#include <cstdio>
#include <ctime>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
using namespace std;
namespace {
using Integer = long long; //__int128;
template <class T, class S> istream &operator>>(istream &is, pair<T, S> &p) {
return is >> p.first >> p.second;
}
template <class T> istream &operator>>(istream &is, vector<T> &vec) {
for (T &val : vec)
is >> val;
return is;
}
template <class T> istream &operator,(istream &is, T &val) { return is >> val; }
template <class T, class S>
ostream &operator<<(ostream &os, const pair<T, S> &p) {
return os << p.first << " " << p.second;
}
template <class T> ostream &operator<<(ostream &os, const vector<T> &vec) {
for (size_t i = 0; i < vec.size(); i++)
os << vec[i] << (i == vec.size() - 1 ? "" : " ");
return os;
}
template <class T> ostream &operator,(ostream &os, const T &val) {
return os << " " << val;
}
template <class H> void print(const H &head) { cout << head; }
template <class H, class... T> void print(const H &head, const T &...tail) {
cout << head << " ";
print(tail...);
}
template <class... T> void println(const T &...values) {
print(values...);
cout << endl;
}
template <class H> void eprint(const H &head) { cerr << head; }
template <class H, class... T> void eprint(const H &head, const T &...tail) {
cerr << head << " ";
eprint(tail...);
}
template <class... T> void eprintln(const T &...values) {
eprint(values...);
cerr << endl;
}
class range {
Integer start_, end_, step_;
public:
struct range_iterator {
Integer val, step_;
range_iterator(Integer v, Integer step) : val(v), step_(step) {}
Integer operator*() { return val; }
void operator++() { val += step_; }
bool operator!=(range_iterator &x) {
return step_ > 0 ? val < x.val : val > x.val;
}
};
range(Integer len) : start_(0), end_(len), step_(1) {}
range(Integer start, Integer end) : start_(start), end_(end), step_(1) {}
range(Integer start, Integer end, Integer step)
: start_(start), end_(end), step_(step) {}
range_iterator begin() { return range_iterator(start_, step_); }
range_iterator end() { return range_iterator(end_, step_); }
};
inline string operator"" _s(const char *str, size_t size) {
return move(string(str));
}
constexpr Integer my_pow(Integer x, Integer k, Integer z = 1) {
return k == 0 ? z
: k == 1 ? z * x
: (k & 1) ? my_pow(x * x, k >> 1, z * x)
: my_pow(x * x, k >> 1, z);
}
constexpr Integer my_pow_mod(Integer x, Integer k, Integer M, Integer z = 1) {
return k == 0 ? z % M
: k == 1 ? z * x % M
: (k & 1) ? my_pow_mod(x * x % M, k >> 1, M, z * x % M)
: my_pow_mod(x * x % M, k >> 1, M, z);
}
constexpr unsigned long long operator"" _ten(unsigned long long value) {
return my_pow(10, value);
}
inline int k_bit(Integer x, int k) { return (x >> k) & 1; } // 0-indexed
mt19937 mt(chrono::duration_cast<chrono::nanoseconds>(
chrono::steady_clock::now().time_since_epoch())
.count());
template <class T> string join(const vector<T> &v, const string &sep) {
stringstream ss;
for (size_t i = 0; i < v.size(); i++) {
if (i > 0)
ss << sep;
ss << v[i];
}
return ss.str();
}
inline string operator*(string s, int k) {
string ret;
while (k) {
if (k & 1)
ret += s;
s += s;
k >>= 1;
}
return ret;
}
} // namespace
constexpr long long mod = 9_ten + 7;
int main() {
int q;
cin >> q;
priority_queue<int, vector<int>, less<int>> l;
priority_queue<int, vector<int>, greater<int>> r;
long long l0 = -2000000000;
long long r0 = +2000000000;
long long lv = 0;
long long rv = 0;
long long k = 0;
long long c = 0;
// vector<long long> med;
while (q--) {
int t;
cin >> t;
if (t == 1) {
long long a, b;
cin >> a, b;
k += b;
if (l.size() == 0) {
l.push(a);
lv += abs(a - l0);
} else if (l.top() >= a) {
l.push(a);
lv += abs(a - l0);
if (l.size() - r.size() > 1) {
long long tmp = l.top();
lv -= abs(tmp - l0);
l.pop();
r.push(tmp);
rv += abs(r0 - tmp);
}
} else {
r.push(a);
rv += abs(r0 - a);
if (r.size() > l.size()) {
long long tmp = r.top();
rv -= abs(r0 - tmp);
r.pop();
l.push(tmp);
lv += abs(tmp - l0);
}
}
assert((int)l.size() - (int)r.size() >= 0);
assert((int)l.size() - (int)r.size() <= 1);
if (l.size() && r.size())
assert(l.top() <= r.top());
c = l.top();
// med.push_back(a);
// sort(med.begin(), med.end());
// eprintln(med, ":", med[(med.size()-1)/2], c);
// assert(med[(med.size()-1)/2] == c);
} else if (t == 2) {
long long ans = (long long)l.size() * abs(c - l0) - lv;
ans += (long long)r.size() * abs(r0 - c) - rv;
ans += k;
println(c, ans);
// long long check = k;
// for(int i=0; i<med.size(); i++){
// check += abs(med[i] - c);
// }
// assert(ans == check);
}
}
return 0;
}
| [
"literal.number.change",
"variable_declaration.value.change",
"assignment.value.change",
"identifier.change",
"call.arguments.change"
] | 854,697 | 854,698 | u075551644 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int q;
cin >> q;
int tmp1, tmp2, tmp3;
cin >> tmp1 >> tmp2 >> tmp3;
map<long long, int> dct;
dct[tmp2] = 1;
int left = 0, right = 0;
long long sum_left = 0, sum_right = 0;
long long constant = tmp3;
auto it = dct.find(tmp2);
int cnt = 1;
while (--q) {
int type;
cin >> type;
if (type == 2) {
cout << (*it).first << ' ' << sum_left + sum_right + constant << '\n';
} else {
++cnt;
int a, b;
cin >> a >> b;
constant += b;
if (a == (*it).first)
++dct[a];
else if (a < (*it).first) {
++left;
sum_left += (*it).first - a;
if (dct.find(a) != dct.end())
++dct[a];
else
dct[a] = 1;
if (2 * left == cnt) {
--it;
sum_left -= left * ((*(next(it))).first - (*it).first);
left -= (*it).second;
right += (*(next(it))).second;
sum_right += right * ((*(next(it))).first - (*it).first);
}
}
else {
++right;
sum_right += (*it).first - a;
if (dct.find(a) != dct.end())
++dct[a];
else
dct[a] = 1;
if (2 * right > cnt) {
sum_right -= right * ((*(next(it))).first - (*it).first);
right -= (*(next(it))).second;
left += (*it).second;
sum_left += left * ((*(next(it))).first - (*it).first);
++it;
}
}
}
}
} | #include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int q;
cin >> q;
int tmp1, tmp2, tmp3;
cin >> tmp1 >> tmp2 >> tmp3;
map<long long, int> dct;
dct[tmp2] = 1;
int left = 0, right = 0;
long long sum_left = 0, sum_right = 0;
long long constant = tmp3;
auto it = dct.find(tmp2);
int cnt = 1;
while (--q) {
int type;
cin >> type;
if (type == 2) {
cout << (*it).first << ' ' << sum_left + sum_right + constant << '\n';
} else {
++cnt;
int a, b;
cin >> a >> b;
constant += b;
if (a == (*it).first)
++dct[a];
else if (a < (*it).first) {
++left;
sum_left += (*it).first - a;
if (dct.find(a) != dct.end())
++dct[a];
else
dct[a] = 1;
if (2 * left == cnt) {
--it;
sum_left -= left * ((*(next(it))).first - (*it).first);
left -= (*it).second;
right += (*(next(it))).second;
sum_right += right * ((*(next(it))).first - (*it).first);
}
}
else {
++right;
sum_right += a - (*it).first;
if (dct.find(a) != dct.end())
++dct[a];
else
dct[a] = 1;
if (2 * right > cnt) {
sum_right -= right * ((*(next(it))).first - (*it).first);
right -= (*(next(it))).second;
left += (*it).second;
sum_left += left * ((*(next(it))).first - (*it).first);
++it;
}
}
}
}
} | [
"assignment.change",
"expression.operation.binary.remove"
] | 854,699 | 854,700 | u776338097 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using ull = unsigned long long;
using uint = unsigned int;
using pcc = pair<char, char>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using pdd = pair<double, double>;
using tuplis = pair<ll, pll>;
using tuplis2 = pair<pll, ll>;
template <class T> using pq = priority_queue<T, vector<T>, greater<T>>;
const ll LINF = 0x1fffffffffffffff;
const int INF = 0x3fffffff;
const ll MOD = 1000000007;
const ll MODD = 998244353;
const ld DINF = numeric_limits<ld>::infinity();
const ld EPS = 1e-9;
const vector<ll> four{0, 1, 0, -1, 0};
#define _overload4(_1, _2, _3, _4, name, ...) name
#define _overload3(_1, _2, _3, name, ...) name
#define _rep1(n) for (ll i = 0; i < n; ++i)
#define _rep2(i, n) for (ll i = 0; i < n; ++i)
#define _rep3(i, a, b) for (ll i = a; i < b; ++i)
#define _rep4(i, a, b, c) for (ll i = a; i < b; i += c)
#define rep(...) \
_overload4(__VA_ARGS__, _rep4, _rep3, _rep2, _rep1)(__VA_ARGS__)
#define _rrep1(n) for (ll i = n - 1; i >= 0; i--)
#define _rrep2(i, n) for (ll i = n - 1; i >= 0; i--)
#define _rrep3(i, a, b) for (ll i = b - 1; i >= a; i--)
#define _rrep4(i, a, b, c) for (ll i = a + (b - a - 1) / c * c; i >= a; i -= c)
#define rrep(...) \
_overload4(__VA_ARGS__, _rrep4, _rrep3, _rrep2, _rrep1)(__VA_ARGS__)
#define each(i, a) for (auto &i : a)
#define sum(...) accumulate(range(__VA_ARGS__), 0LL)
#define dsum(...) accumulate(range(__VA_ARGS__), double(0))
#define _range(i) (i).begin(), (i).end()
#define _range2(i, k) (i).begin(), (i).begin() + k
#define _range3(i, a, b) (i).begin() + a, (i).begin() + b
#define range(...) \
_overload3(__VA_ARGS__, _range3, _range2, _range)(__VA_ARGS__)
#define _rrange(i) (i).rbegin(), (i).rend()
#define _rrange2(i, k) (i).rbegin(), (i).rbegin() + k
#define _rrange3(i, a, b) (i).rbegin() + a, (i).rbegin() + b
#define rrange(...) \
_overload3(__VA_ARGS__, _rrange3, _rrange2, _rrange)(__VA_ARGS__)
#define elif else if
#define unless(a) if (!(a))
#define mp make_pair
#define mt make_tuple
#define INT(...) \
int __VA_ARGS__; \
in(__VA_ARGS__)
#define LL(...) \
ll __VA_ARGS__; \
in(__VA_ARGS__)
#define ULL(...) \
ull __VA_ARGS__; \
in(__VA_ARGS__)
#define STR(...) \
string __VA_ARGS__; \
in(__VA_ARGS__)
#define CHR(...) \
char __VA_ARGS__; \
in(__VA_ARGS__)
#define DBL(...) \
double __VA_ARGS__; \
in(__VA_ARGS__)
#define vec(type, name, ...) vector<type> name(__VA_ARGS__)
#define VEC(type, name, size) \
vector<type> name(size); \
in(name)
#define vv(type, name, h, ...) \
vector<vector<type>> name(h, vector<type>(__VA_ARGS__))
#define VV(type, name, h, ...) \
vector<vector<type>> name(h, vector<type>(__VA_ARGS__)); \
in(name)
#define vvv(type, name, h, w, ...) \
vector<vector<vector<type>>> name( \
h, vector<vector<type>>(w, vector<type>(__VA_ARGS__)))
inline constexpr ll gcd(ll a, ll b) {
if (!a || !b)
return 0;
while (b) {
ll c = b;
b = a % b;
a = c;
}
return a;
}
inline constexpr ll lcm(ll a, ll b) {
if (!a || !b)
return 0;
return a * b / gcd(a, b);
}
template <class T> inline constexpr T min(vector<T> &v) {
return *min_element(range(v));
}
inline char min(string &v) { return *min_element(range(v)); }
template <class T> inline constexpr T max(vector<T> &v) {
return *max_element(range(v));
}
inline char max(string &v) { return *max_element(range(v)); }
inline constexpr ll intpow(ll a, ll b) {
ll ans = 1;
for (ll i = 1; b; i *= 2) {
if (b & i) {
b ^= i;
ans *= a;
}
a *= a;
}
return ans;
}
inline constexpr ll modpow(ll a, ll b, ll mod = MOD) {
ll ans = 1;
for (ll i = 1; b; i *= 2) {
if (b & i) {
b ^= i;
ans *= a;
ans %= mod;
}
a *= a;
a %= mod;
}
return ans;
}
template <typename T> inline constexpr bool update_min(T &mn, const T &cnt) {
if (mn > cnt) {
mn = cnt;
return 1;
} else
return 0;
}
template <typename T> inline constexpr bool update_max(T &mx, const T &cnt) {
if (mx < cnt) {
mx = cnt;
return 1;
} else
return 0;
}
inline int scan() { return getchar(); }
inline void scan(int &a) { scanf("%d", &a); }
inline void scan(unsigned &a) { scanf("%u", &a); }
inline void scan(long &a) { scanf("%ld", &a); }
inline void scan(long long &a) { scanf("%lld", &a); }
inline void scan(unsigned long long &a) { scanf("%llu", &a); }
inline void scan(char &a) { cin >> a; }
inline void scan(float &a) { scanf("%f", &a); }
inline void scan(double &a) { scanf("%lf", &a); }
inline void scan(long double &a) { scanf("%Lf", &a); }
inline void scan(vector<bool> &vec) {
for (unsigned i = 0; i < vec.size(); i++) {
int a;
scan(a);
vec[i] = a;
}
}
inline void scan(string &a) { cin >> a; }
template <class T> inline void scan(vector<T> &vec);
template <class T, size_t size> inline void scan(array<T, size> &vec);
template <class T, class L> inline void scan(pair<T, L> &p);
template <class T, size_t size> inline void scan(T (&vec)[size]);
template <class T> inline void scan(vector<T> &vec) {
for (auto &i : vec)
scan(i);
}
template <class T, size_t size> inline void scan(array<T, size> &vec) {
for (auto &i : vec)
scan(i);
}
template <class T, class L> inline void scan(pair<T, L> &p) {
scan(p.first);
scan(p.second);
}
template <class T, size_t size> inline void scan(T (&vec)[size]) {
for (auto &i : vec)
scan(i);
}
template <class T> inline void scan(T &a) { cin >> a; }
inline void in() {}
template <class Head, class... Tail> inline void in(Head &head, Tail &...tail) {
scan(head);
in(tail...);
}
inline void print() { putchar('\n'); }
inline void print(const bool &a) { printf("%d", a); }
inline void print(const int &a) { printf("%d", a); }
inline void print(const unsigned &a) { printf("%u", a); }
inline void print(const long &a) { printf("%ld", a); }
inline void print(const long long &a) { printf("%lld", a); }
inline void print(const unsigned long long &a) { printf("%llu", a); }
inline void print(const char &a) { printf("%c", a); }
inline void print(const char a[]) { printf("%s", a); }
inline void print(const float &a) { printf("%.10f", a); }
inline void print(const double &a) { printf("%.10f", a); }
inline void print(const long double &a) { printf("%.10Lf", a); }
template <class T> void print(const vector<T> &vec);
template <class T, size_t size> void print(const array<T, size> &vec);
template <class T, class L> void print(const pair<T, L> &p);
template <class T, size_t size> inline void print(const T (&vec)[size]);
template <class T> void print(const vector<T> &vec) {
print(vec[0]);
for (auto i = vec.begin(); ++i != vec.end();) {
putchar(' ');
print(*i);
}
}
template <class T, size_t size> void print(const array<T, size> &vec) {
print(vec[0]);
for (auto i = vec.begin(); ++i != vec.end();) {
putchar(' ');
print(*i);
}
}
template <class T, class L> void print(const pair<T, L> &p) {
print(p.first);
putchar(' ');
print(p.second);
}
template <class T, size_t size> inline void print(const T (&vec)[size]) {
print(vec[0]);
for (auto i = vec; ++i != end(vec);) {
putchar(' ');
print(*i);
}
}
template <class T> inline void print(const T &a) { cout << a; }
inline int out() {
putchar('\n');
return 0;
}
template <class T> inline int out(const T &t) {
print(t);
putchar('\n');
return 0;
}
template <class Head, class... Tail>
inline int out(const Head &head, const Tail &...tail) {
print(head);
putchar(' ');
out(tail...);
return 0;
}
template <class T> inline void err(T t) { cerr << t << '\n'; }
inline void err() { cerr << '\n'; }
inline int yes(const bool &i) { return out(i ? "yes" : "no"); }
inline int Yes(const bool &i) { return out(i ? "Yes" : "No"); }
inline int YES(const bool &i) { return out(i ? "YES" : "NO"); }
inline int Yay(const bool &i) { return out(i ? "Yay!" : ":("); }
inline int Possible(const bool &i) {
return out(i ? "Possible" : "Impossible");
}
inline int POSSIBLE(const bool &i) {
return out(i ? "POSSIBLE" : "IMPOSSIBLE");
}
inline void Case(ll i) { printf("Case #%lld: ", i); }
int main() {
LL(q);
ll ans = 0;
pair<pll, pll> cen = {{-LINF, -LINF}, {-LINF, -LINF}};
multiset<pll> s;
rep(q) {
CHR(c);
if (c == '1') {
LL(a, b);
ans += b;
s.emplace(a, i);
if (cen.first.first == -LINF) {
cen.first = {a, i};
}
elif (cen.second.first == -LINF) {
ans += abs(a - cen.first.first);
auto p = s.find(cen.first);
if (cen.first < mp(a, i)) {
p++;
cen.second = *p;
} else {
p++;
cen.second = cen.first;
cen.first = *p;
}
}
else {
if (mp(a, i) < cen.first) {
cen.second = {-LINF, -LINF};
}
elif (mp(a, i) > cen.second) {
cen.first = cen.second;
cen.second = {-LINF, -LINF};
}
else {
cen.first = {a, i};
cen.second = {-LINF, -LINF};
}
ans += abs(cen.first.first - a);
}
} else {
out(cen.first.first, ans);
}
}
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using ull = unsigned long long;
using uint = unsigned int;
using pcc = pair<char, char>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using pdd = pair<double, double>;
using tuplis = pair<ll, pll>;
using tuplis2 = pair<pll, ll>;
template <class T> using pq = priority_queue<T, vector<T>, greater<T>>;
const ll LINF = 0x1fffffffffffffff;
const int INF = 0x3fffffff;
const ll MOD = 1000000007;
const ll MODD = 998244353;
const ld DINF = numeric_limits<ld>::infinity();
const ld EPS = 1e-9;
const vector<ll> four{0, 1, 0, -1, 0};
#define _overload4(_1, _2, _3, _4, name, ...) name
#define _overload3(_1, _2, _3, name, ...) name
#define _rep1(n) for (ll i = 0; i < n; ++i)
#define _rep2(i, n) for (ll i = 0; i < n; ++i)
#define _rep3(i, a, b) for (ll i = a; i < b; ++i)
#define _rep4(i, a, b, c) for (ll i = a; i < b; i += c)
#define rep(...) \
_overload4(__VA_ARGS__, _rep4, _rep3, _rep2, _rep1)(__VA_ARGS__)
#define _rrep1(n) for (ll i = n - 1; i >= 0; i--)
#define _rrep2(i, n) for (ll i = n - 1; i >= 0; i--)
#define _rrep3(i, a, b) for (ll i = b - 1; i >= a; i--)
#define _rrep4(i, a, b, c) for (ll i = a + (b - a - 1) / c * c; i >= a; i -= c)
#define rrep(...) \
_overload4(__VA_ARGS__, _rrep4, _rrep3, _rrep2, _rrep1)(__VA_ARGS__)
#define each(i, a) for (auto &i : a)
#define sum(...) accumulate(range(__VA_ARGS__), 0LL)
#define dsum(...) accumulate(range(__VA_ARGS__), double(0))
#define _range(i) (i).begin(), (i).end()
#define _range2(i, k) (i).begin(), (i).begin() + k
#define _range3(i, a, b) (i).begin() + a, (i).begin() + b
#define range(...) \
_overload3(__VA_ARGS__, _range3, _range2, _range)(__VA_ARGS__)
#define _rrange(i) (i).rbegin(), (i).rend()
#define _rrange2(i, k) (i).rbegin(), (i).rbegin() + k
#define _rrange3(i, a, b) (i).rbegin() + a, (i).rbegin() + b
#define rrange(...) \
_overload3(__VA_ARGS__, _rrange3, _rrange2, _rrange)(__VA_ARGS__)
#define elif else if
#define unless(a) if (!(a))
#define mp make_pair
#define mt make_tuple
#define INT(...) \
int __VA_ARGS__; \
in(__VA_ARGS__)
#define LL(...) \
ll __VA_ARGS__; \
in(__VA_ARGS__)
#define ULL(...) \
ull __VA_ARGS__; \
in(__VA_ARGS__)
#define STR(...) \
string __VA_ARGS__; \
in(__VA_ARGS__)
#define CHR(...) \
char __VA_ARGS__; \
in(__VA_ARGS__)
#define DBL(...) \
double __VA_ARGS__; \
in(__VA_ARGS__)
#define vec(type, name, ...) vector<type> name(__VA_ARGS__)
#define VEC(type, name, size) \
vector<type> name(size); \
in(name)
#define vv(type, name, h, ...) \
vector<vector<type>> name(h, vector<type>(__VA_ARGS__))
#define VV(type, name, h, ...) \
vector<vector<type>> name(h, vector<type>(__VA_ARGS__)); \
in(name)
#define vvv(type, name, h, w, ...) \
vector<vector<vector<type>>> name( \
h, vector<vector<type>>(w, vector<type>(__VA_ARGS__)))
inline constexpr ll gcd(ll a, ll b) {
if (!a || !b)
return 0;
while (b) {
ll c = b;
b = a % b;
a = c;
}
return a;
}
inline constexpr ll lcm(ll a, ll b) {
if (!a || !b)
return 0;
return a * b / gcd(a, b);
}
template <class T> inline constexpr T min(vector<T> &v) {
return *min_element(range(v));
}
inline char min(string &v) { return *min_element(range(v)); }
template <class T> inline constexpr T max(vector<T> &v) {
return *max_element(range(v));
}
inline char max(string &v) { return *max_element(range(v)); }
inline constexpr ll intpow(ll a, ll b) {
ll ans = 1;
for (ll i = 1; b; i *= 2) {
if (b & i) {
b ^= i;
ans *= a;
}
a *= a;
}
return ans;
}
inline constexpr ll modpow(ll a, ll b, ll mod = MOD) {
ll ans = 1;
for (ll i = 1; b; i *= 2) {
if (b & i) {
b ^= i;
ans *= a;
ans %= mod;
}
a *= a;
a %= mod;
}
return ans;
}
template <typename T> inline constexpr bool update_min(T &mn, const T &cnt) {
if (mn > cnt) {
mn = cnt;
return 1;
} else
return 0;
}
template <typename T> inline constexpr bool update_max(T &mx, const T &cnt) {
if (mx < cnt) {
mx = cnt;
return 1;
} else
return 0;
}
inline int scan() { return getchar(); }
inline void scan(int &a) { scanf("%d", &a); }
inline void scan(unsigned &a) { scanf("%u", &a); }
inline void scan(long &a) { scanf("%ld", &a); }
inline void scan(long long &a) { scanf("%lld", &a); }
inline void scan(unsigned long long &a) { scanf("%llu", &a); }
inline void scan(char &a) { cin >> a; }
inline void scan(float &a) { scanf("%f", &a); }
inline void scan(double &a) { scanf("%lf", &a); }
inline void scan(long double &a) { scanf("%Lf", &a); }
inline void scan(vector<bool> &vec) {
for (unsigned i = 0; i < vec.size(); i++) {
int a;
scan(a);
vec[i] = a;
}
}
inline void scan(string &a) { cin >> a; }
template <class T> inline void scan(vector<T> &vec);
template <class T, size_t size> inline void scan(array<T, size> &vec);
template <class T, class L> inline void scan(pair<T, L> &p);
template <class T, size_t size> inline void scan(T (&vec)[size]);
template <class T> inline void scan(vector<T> &vec) {
for (auto &i : vec)
scan(i);
}
template <class T, size_t size> inline void scan(array<T, size> &vec) {
for (auto &i : vec)
scan(i);
}
template <class T, class L> inline void scan(pair<T, L> &p) {
scan(p.first);
scan(p.second);
}
template <class T, size_t size> inline void scan(T (&vec)[size]) {
for (auto &i : vec)
scan(i);
}
template <class T> inline void scan(T &a) { cin >> a; }
inline void in() {}
template <class Head, class... Tail> inline void in(Head &head, Tail &...tail) {
scan(head);
in(tail...);
}
inline void print() { putchar('\n'); }
inline void print(const bool &a) { printf("%d", a); }
inline void print(const int &a) { printf("%d", a); }
inline void print(const unsigned &a) { printf("%u", a); }
inline void print(const long &a) { printf("%ld", a); }
inline void print(const long long &a) { printf("%lld", a); }
inline void print(const unsigned long long &a) { printf("%llu", a); }
inline void print(const char &a) { printf("%c", a); }
inline void print(const char a[]) { printf("%s", a); }
inline void print(const float &a) { printf("%.10f", a); }
inline void print(const double &a) { printf("%.10f", a); }
inline void print(const long double &a) { printf("%.10Lf", a); }
template <class T> void print(const vector<T> &vec);
template <class T, size_t size> void print(const array<T, size> &vec);
template <class T, class L> void print(const pair<T, L> &p);
template <class T, size_t size> inline void print(const T (&vec)[size]);
template <class T> void print(const vector<T> &vec) {
print(vec[0]);
for (auto i = vec.begin(); ++i != vec.end();) {
putchar(' ');
print(*i);
}
}
template <class T, size_t size> void print(const array<T, size> &vec) {
print(vec[0]);
for (auto i = vec.begin(); ++i != vec.end();) {
putchar(' ');
print(*i);
}
}
template <class T, class L> void print(const pair<T, L> &p) {
print(p.first);
putchar(' ');
print(p.second);
}
template <class T, size_t size> inline void print(const T (&vec)[size]) {
print(vec[0]);
for (auto i = vec; ++i != end(vec);) {
putchar(' ');
print(*i);
}
}
template <class T> inline void print(const T &a) { cout << a; }
inline int out() {
putchar('\n');
return 0;
}
template <class T> inline int out(const T &t) {
print(t);
putchar('\n');
return 0;
}
template <class Head, class... Tail>
inline int out(const Head &head, const Tail &...tail) {
print(head);
putchar(' ');
out(tail...);
return 0;
}
template <class T> inline void err(T t) { cerr << t << '\n'; }
inline void err() { cerr << '\n'; }
inline int yes(const bool &i) { return out(i ? "yes" : "no"); }
inline int Yes(const bool &i) { return out(i ? "Yes" : "No"); }
inline int YES(const bool &i) { return out(i ? "YES" : "NO"); }
inline int Yay(const bool &i) { return out(i ? "Yay!" : ":("); }
inline int Possible(const bool &i) {
return out(i ? "Possible" : "Impossible");
}
inline int POSSIBLE(const bool &i) {
return out(i ? "POSSIBLE" : "IMPOSSIBLE");
}
inline void Case(ll i) { printf("Case #%lld: ", i); }
int main() {
LL(q);
ll ans = 0;
pair<pll, pll> cen = {{-LINF, -LINF}, {-LINF, -LINF}};
multiset<pll> s;
rep(q) {
CHR(c);
if (c == '1') {
LL(a, b);
ans += b;
s.emplace(a, i);
if (cen.first.first == -LINF) {
cen.first = {a, i};
}
elif (cen.second.first == -LINF) {
ans += abs(a - cen.first.first);
auto p = s.find(cen.first);
if (cen.first < mp(a, i)) {
p++;
cen.second = *p;
} else {
p--;
cen.second = cen.first;
cen.first = *p;
}
}
else {
if (mp(a, i) < cen.first) {
cen.second = {-LINF, -LINF};
}
elif (mp(a, i) > cen.second) {
cen.first = cen.second;
cen.second = {-LINF, -LINF};
}
else {
cen.first = {a, i};
cen.second = {-LINF, -LINF};
}
ans += abs(cen.first.first - a);
}
} else {
out(cen.first.first, ans);
}
}
}
| [] | 854,707 | 854,708 | u874644572 | cpp |
p03041 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
void solve() {
int n, k;
string s;
cin >> n >> k >> s;
--n;
s[n] = (char)tolower(s[n]);
cout << s << '\n';
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
solve();
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
void solve() {
int n, k;
string s;
cin >> n >> k >> s;
--k;
s[k] = (char)tolower(s[k]);
cout << s << '\n';
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
solve();
return 0;
} | [
"identifier.change",
"assignment.variable.change",
"variable_access.subscript.index.change",
"assignment.value.change",
"call.arguments.change"
] | 854,711 | 854,712 | u105935673 | cpp |
p03041 | #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;
} | [] | 854,715 | 854,716 | u809967037 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
using ll = long long int;
const int MAX = (int)(1e5 + 5);
const ll INF = (ll)(1e10 + 5);
int q;
int main(void) {
// Here your code !
scanf("%d", &q);
priority_queue<ll> left_set;
priority_queue<ll, vector<ll>, greater<ll>> right_set;
ll current = 0LL;
for (int i = 0; i < q; ++i) {
int type;
scanf("%d", &type);
if (type == 1) {
ll a, b;
scanf(" %lld %lld", &a, &b);
current += b;
if (left_set.empty()) {
left_set.push(a);
right_set.push(a);
continue;
}
ll left = left_set.top();
ll right = right_set.top();
if (left <= a && a <= right) {
left_set.push(a);
right_set.push(a);
} else if (a < left) {
right_set.push(left_set.top());
left_set.pop();
left_set.push(a);
left_set.push(a);
current += left - a;
} else { // right < a
left_set.push(right_set.top());
right_set.pop();
right_set.push(a);
right_set.push(a);
current += a - left;
}
} else {
ll left = left_set.top();
printf("%lld %lld\n", left, current);
}
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long int;
const int MAX = (int)(1e5 + 5);
const ll INF = (ll)(1e10 + 5);
int q;
int main(void) {
// Here your code !
scanf("%d", &q);
priority_queue<ll> left_set;
priority_queue<ll, vector<ll>, greater<ll>> right_set;
ll current = 0LL;
for (int i = 0; i < q; ++i) {
int type;
scanf("%d", &type);
if (type == 1) {
ll a, b;
scanf(" %lld %lld", &a, &b);
current += b;
if (left_set.empty()) {
left_set.push(a);
right_set.push(a);
continue;
}
ll left = left_set.top();
ll right = right_set.top();
if (left <= a && a <= right) {
left_set.push(a);
right_set.push(a);
} else if (a < left) {
right_set.push(left_set.top());
left_set.pop();
left_set.push(a);
left_set.push(a);
current += left - a;
} else { // right < a
left_set.push(right_set.top());
right_set.pop();
right_set.push(a);
right_set.push(a);
current += a - right;
}
} else {
ll left = left_set.top();
printf("%lld %lld\n", left, current);
}
}
return 0;
}
| [
"assignment.value.change",
"identifier.change",
"expression.operation.binary.change"
] | 854,723 | 854,724 | u497422208 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
int Q;
multiset<ll> l, r;
ll ls, rs, bs;
ll x;
int main() {
cin >> Q;
int q;
cin >> q >> x >> bs;
l.insert(x);
ls += x;
for (int i = 1; i < Q; i++) {
cin >> q;
auto it = l.end();
x = *--it;
if (q == 1) {
ll a, b;
cin >> a >> b;
bs += b;
if (l.size() == r.size()) {
if (x < a) {
rs += a;
r.insert(a);
it = r.end();
it--;
rs -= *it;
ls += *it;
l.insert(*it);
r.erase(it);
} else {
ls += a;
l.insert(a);
}
} else {
if (x < a) {
rs += a;
r.insert(a);
} else {
ls += a;
l.insert(a);
it = l.end();
it--;
ls -= *it;
rs += *it;
r.insert(*it);
l.erase(it);
}
}
} else {
ll res = rs - ls + (l.size() == r.size() ? 0 : x);
cout << x << " " << res + bs << endl;
}
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
int Q;
multiset<ll> l, r;
ll ls, rs, bs;
ll x;
int main() {
cin >> Q;
int q;
cin >> q >> x >> bs;
l.insert(x);
ls += x;
for (int i = 1; i < Q; i++) {
cin >> q;
auto it = l.end();
x = *--it;
if (q == 1) {
ll a, b;
cin >> a >> b;
bs += b;
if (l.size() == r.size()) {
if (x < a) {
rs += a;
r.insert(a);
it = r.begin();
rs -= *it;
ls += *it;
l.insert(*it);
r.erase(it);
} else {
ls += a;
l.insert(a);
}
} else {
if (x < a) {
rs += a;
r.insert(a);
} else {
ls += a;
l.insert(a);
it = l.end();
it--;
ls -= *it;
rs += *it;
r.insert(*it);
l.erase(it);
}
}
} else {
ll res = rs - ls + (l.size() == r.size() ? 0 : x);
cout << x << " " << res + bs << endl;
}
}
return 0;
} | [
"assignment.value.change",
"call.function.change",
"expression.unary.arithmetic.remove"
] | 854,736 | 854,737 | u554116180 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define PI 3.141592653589793
#define rep(i, n) for (int i = 0; i < (n); i++)
#define REP(i, a, n) for (int i = a; i < (n); i++)
#define rrep(i, n, k) \
for (int i = (n); i >= (k); i--) \
;
#define all(x) (x).begin(), (x).end()
#define vi vector<int>
template <class T> istream &operator>>(istream &is, vector<T> &v) {
for (auto &elemnt : v)
is >> elemnt;
return is;
}
template <class T, class U> istream &operator>>(istream &is, pair<T, U> &p) {
is >> p.first >> p.second;
return is;
}
template <class T> vector<T> make_vector(size_t a) { return vector<T>(a); }
template <class T, class... Ts> auto make_vector(size_t a, Ts... ts) {
return vector<decltype(make_vector<T>(ts...))>(a, make_vector<T>(ts...));
}
const int MOD = 1e9 + 7;
const int INF = 2e18;
signed main() {
int Q;
cin >> Q;
multiset<int> left, right;
int middle = -1, leftSum = 0, rightSum = 0, delta = 0;
pair<int, int> ans;
auto update = [&](int a, int b) {
delta += b;
auto calc = [&]() {
int mid = middle;
if (mid == -1)
mid = *right.begin();
int temp = mid * (int)left.size() - leftSum;
temp += rightSum - mid * (int)right.size();
ans.first = mid;
ans.second = temp + delta;
};
if (middle == -1) {
if (left.empty() && right.empty()) {
middle = a;
} else {
multiset<int> temp;
temp.insert(a);
{
// left
auto itr = left.end();
--itr;
temp.insert(*itr);
left.erase(itr);
leftSum -= *itr;
}
{
// right
auto itr = right.begin();
temp.insert(*itr);
right.erase(itr);
rightSum -= *itr;
}
left.insert(*temp.begin());
leftSum += *temp.begin();
right.insert(*temp.rbegin());
rightSum += *temp.rbegin();
middle = *next(temp.begin(), 1);
}
calc();
} else {
int down = min(a, middle);
int up = max(a, middle);
left.insert(down);
leftSum += down;
right.insert(up);
rightSum += up;
middle = -1;
calc();
}
};
for (int i = 0; i < Q; i++) {
int q;
cin >> q;
if (q == 1) {
int a, b;
cin >> a >> b;
update(a, b);
} else {
cout << ans.first << " " << ans.second << endl;
}
}
}
| #include <bits/stdc++.h>
using namespace std;
#define int long long
#define PI 3.141592653589793
#define rep(i, n) for (int i = 0; i < (n); i++)
#define REP(i, a, n) for (int i = a; i < (n); i++)
#define rrep(i, n, k) \
for (int i = (n); i >= (k); i--) \
;
#define all(x) (x).begin(), (x).end()
#define vi vector<int>
template <class T> istream &operator>>(istream &is, vector<T> &v) {
for (auto &elemnt : v)
is >> elemnt;
return is;
}
template <class T, class U> istream &operator>>(istream &is, pair<T, U> &p) {
is >> p.first >> p.second;
return is;
}
template <class T> vector<T> make_vector(size_t a) { return vector<T>(a); }
template <class T, class... Ts> auto make_vector(size_t a, Ts... ts) {
return vector<decltype(make_vector<T>(ts...))>(a, make_vector<T>(ts...));
}
const int MOD = 1e9 + 7;
const int INF = 2e18;
signed main() {
int Q;
cin >> Q;
multiset<int> left, right;
int middle = -1, leftSum = 0, rightSum = 0, delta = 0;
pair<int, int> ans;
auto update = [&](int a, int b) {
delta += b;
auto calc = [&]() {
int mid = middle;
if (mid == -1)
mid = *left.rbegin();
int temp = mid * (int)left.size() - leftSum;
temp += rightSum - mid * (int)right.size();
ans.first = mid;
ans.second = temp + delta;
};
if (middle == -1) {
if (left.empty() && right.empty()) {
middle = a;
} else {
multiset<int> temp;
temp.insert(a);
{
// left
auto itr = left.end();
--itr;
temp.insert(*itr);
left.erase(itr);
leftSum -= *itr;
}
{
// right
auto itr = right.begin();
temp.insert(*itr);
right.erase(itr);
rightSum -= *itr;
}
left.insert(*temp.begin());
leftSum += *temp.begin();
right.insert(*temp.rbegin());
rightSum += *temp.rbegin();
middle = *next(temp.begin(), 1);
}
calc();
} else {
int down = min(a, middle);
int up = max(a, middle);
left.insert(down);
leftSum += down;
right.insert(up);
rightSum += up;
middle = -1;
calc();
}
};
for (int i = 0; i < Q; i++) {
int q;
cin >> q;
if (q == 1) {
int a, b;
cin >> a >> b;
update(a, b);
} else {
cout << ans.first << " " << ans.second << endl;
}
}
}
| [
"assignment.value.change",
"identifier.change"
] | 854,738 | 854,739 | u714538557 | cpp |
p03040 | #include "bits/stdc++.h"
using namespace std;
#define int long long
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define RFOR(i, a, b) for (int i = (b - 1); i >= (a); i--)
#define REP(i, n) for (int i = 0; i < (n); i++)
#define RREP(i, n) for (int i = (n - 1); i >= 0; i--)
#define REP1(i, n) for (int i = 1; i <= (n); i++)
#define RREP1(i, n) for (int i = (n); i >= 1; i--)
#define ALL(a) (a).begin(), (a).end()
#define UNIQUE_SORT(l) \
sort(ALL(l)); \
l.erase(unique(ALL(l)), l.end());
#define CONTAIN(a, b) find(ALL(a), (b)) != (a).end()
#define out(...) printf(__VA_ARGS__)
int dxy[] = {0, 1, 0, -1, 0};
void solve();
signed main() {
#if DEBUG
std::ifstream in("input.txt");
std::cin.rdbuf(in.rdbuf());
#endif
cin.tie(0);
ios::sync_with_stdio(false);
solve();
return 0;
}
/*================================*/
int N, M, Q;
void solve() {
cin >> Q;
int a, b, c;
multiset<int> l, r;
int ls = 0, rs = 0, bs = 0;
while (Q--) {
cin >> c;
if (c == 2) {
auto it = l.end();
int lv = *(--it);
int ans = bs;
ans += lv * l.size() - ls;
ans += rs - lv * r.size();
out("%lld %lld\n", lv, ans);
continue;
}
cin >> a >> b;
bs += b;
if (l.empty()) {
l.insert(a);
ls += a;
continue;
}
auto it = l.end();
int lv = *(--it);
if (lv > a) {
l.insert(a);
ls += a;
if (l.size() > r.size() + 1) {
auto it = l.end();
int lv = *(--it);
r.insert(lv);
l.erase(lv);
rs += lv;
ls -= lv;
}
} else if (lv < a) {
r.insert(a);
rs += a;
if (r.size() > l.size()) {
int rv = *r.begin();
l.insert(rv);
r.erase(rv);
ls += rv;
rs -= rv;
}
} else {
if (l.size() > r.size()) {
r.insert(a);
rs += a;
} else {
l.insert(a);
ls += a;
}
}
}
} | #include "bits/stdc++.h"
using namespace std;
#define int long long
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define RFOR(i, a, b) for (int i = (b - 1); i >= (a); i--)
#define REP(i, n) for (int i = 0; i < (n); i++)
#define RREP(i, n) for (int i = (n - 1); i >= 0; i--)
#define REP1(i, n) for (int i = 1; i <= (n); i++)
#define RREP1(i, n) for (int i = (n); i >= 1; i--)
#define ALL(a) (a).begin(), (a).end()
#define UNIQUE_SORT(l) \
sort(ALL(l)); \
l.erase(unique(ALL(l)), l.end());
#define CONTAIN(a, b) find(ALL(a), (b)) != (a).end()
#define out(...) printf(__VA_ARGS__)
int dxy[] = {0, 1, 0, -1, 0};
void solve();
signed main() {
#if DEBUG
std::ifstream in("input.txt");
std::cin.rdbuf(in.rdbuf());
#endif
cin.tie(0);
ios::sync_with_stdio(false);
solve();
return 0;
}
/*================================*/
int N, M, Q;
void solve() {
cin >> Q;
int a, b, c;
multiset<int> l, r;
int ls = 0, rs = 0, bs = 0;
while (Q--) {
cin >> c;
if (c == 2) {
auto it = l.end();
int lv = *(--it);
int ans = bs;
ans += lv * l.size() - ls;
ans += rs - lv * r.size();
out("%lld %lld\n", lv, ans);
continue;
}
cin >> a >> b;
bs += b;
if (l.empty()) {
l.insert(a);
ls += a;
continue;
}
auto it = l.end();
int lv = *(--it);
if (lv > a) {
l.insert(a);
ls += a;
if (l.size() > r.size() + 1) {
auto it = l.end();
int lv = *(--it);
r.insert(lv);
l.erase(it);
rs += lv;
ls -= lv;
}
} else if (lv < a) {
r.insert(a);
rs += a;
if (r.size() > l.size()) {
int rv = *r.begin();
l.insert(rv);
r.erase(r.begin());
ls += rv;
rs -= rv;
}
} else {
if (l.size() > r.size()) {
r.insert(a);
rs += a;
} else {
l.insert(a);
ls += a;
}
}
}
} | [
"identifier.change",
"call.arguments.change",
"call.add"
] | 854,740 | 854,741 | u183175308 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> Pint;
typedef pair<ll, ll> P;
// typedef pair<int, pair<int, int>> P;
// typedef tuple<int,int,int> T;
ll INFL = 1000000000000000010; // 10^18 = 2^60
int INF = 2147483600; // 10^9
ll MOD = 1000000007;
vector<int> dy = {0, 0, 1, -1};
vector<int> dx = {1, -1, 0, 0};
ll N, M, K;
int main(void) {
int Q;
cin >> Q;
ll com, x, y;
cin >> com >> x >> y;
ll ans = y, cnt = 1;
multiset<ll> all;
all.insert(x);
auto mid = all.begin();
for (int i = 1; i < Q; i++) {
cin >> com;
if (com == 1) {
cin >> x >> y;
if (cnt % 2 == 1) {
if (x >= *mid) {
ans += x - *mid;
all.insert(x);
} else {
ans += *mid - x;
all.insert(x);
mid--;
}
} else {
if (x >= *mid) {
all.insert(x);
mid++;
ans += x - *mid;
} else {
ans += x - *mid;
all.insert(x);
}
}
cnt++;
ans += y;
} else {
cout << *mid << " " << ans << endl;
}
}
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> Pint;
typedef pair<ll, ll> P;
// typedef pair<int, pair<int, int>> P;
// typedef tuple<int,int,int> T;
ll INFL = 1000000000000000010; // 10^18 = 2^60
int INF = 2147483600; // 10^9
ll MOD = 1000000007;
vector<int> dy = {0, 0, 1, -1};
vector<int> dx = {1, -1, 0, 0};
ll N, M, K;
int main(void) {
int Q;
cin >> Q;
ll com, x, y;
cin >> com >> x >> y;
ll ans = y, cnt = 1;
multiset<ll> all;
all.insert(x);
auto mid = all.begin();
for (int i = 1; i < Q; i++) {
cin >> com;
if (com == 1) {
cin >> x >> y;
if (cnt % 2 == 1) {
if (x >= *mid) {
ans += x - *mid;
all.insert(x);
} else {
ans += *mid - x;
all.insert(x);
mid--;
}
} else {
if (x >= *mid) {
all.insert(x);
mid++;
ans += x - *mid;
} else {
ans += *mid - x;
all.insert(x);
}
}
cnt++;
ans += y;
} else {
cout << *mid << " " << ans << endl;
}
}
}
| [
"expression.operation.binary.remove",
"assignment.change"
] | 854,746 | 854,747 | u633284019 | cpp |
p03040 | #pragma GCC optimize("Ofast,unroll-loops")
#include <bits/stdc++.h>
#define int long long
#define F first
#define S second
#define P pair
#define FOR(i, a, b) for (int i = a; i <= b; i++)
#define rep(i, a, b) for (int i = a; i < b; i++)
#define V vector
#define RE return
#define ALL(a) a.begin(), a.end()
#define MP make_pair
#define PB push_back
#define PF push_front
#define FILL(a, b) memset(a, b, sizeof(a))
using namespace std;
priority_queue<int> q1;
priority_queue<int, V<int>, greater<int>> q2;
int sum1, sum2, ans, t, ant;
namespace io {
#define in(a) a = read()
#define out(a) write(a), putchar(' ')
#define outn(a) out(a), putchar('\n')
#define I_int int
inline I_int read() {
I_int x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-')
f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return x * f;
}
char F[200];
inline void write(I_int x) {
if (x == 0) {
putchar('0');
return;
}
I_int tmp = x > 0 ? x : -x;
if (x < 0)
putchar('-');
int cnt = 0;
while (tmp > 0) {
F[cnt++] = tmp % 10 + '0';
tmp /= 10;
}
while (cnt > 0)
putchar(F[--cnt]);
}
#undef I_int
} // namespace io
using namespace io;
signed main() {
int q, x, y;
in(q);
FOR(i, 1, q) {
in(x);
if (x == 2) {
if (!q1.size()) {
puts("0");
continue;
}
ant = q1.top();
out(ant);
ans = ant * q1.size() - sum1 + sum2 - ant * q2.size();
outn(ans + t);
} else {
in(x);
in(y);
if (q1.empty() || q1.top() >= x) {
q1.emplace(x);
sum1 += x;
if (q1.size() > q2.size() + 1) {
q2.emplace(q1.top());
sum1 -= q1.top();
sum2 += q1.top();
q1.pop();
}
} else {
q2.emplace(x);
sum2 += x;
if (q2.size() > q1.size() + 1) {
q1.emplace(q2.top());
sum2 -= q2.top();
sum1 += q2.top();
q2.pop();
}
}
t += y;
}
}
RE 0;
} | #pragma GCC optimize("Ofast,unroll-loops")
#include <bits/stdc++.h>
#define int long long
#define F first
#define S second
#define P pair
#define FOR(i, a, b) for (int i = a; i <= b; i++)
#define rep(i, a, b) for (int i = a; i < b; i++)
#define V vector
#define RE return
#define ALL(a) a.begin(), a.end()
#define MP make_pair
#define PB push_back
#define PF push_front
#define FILL(a, b) memset(a, b, sizeof(a))
using namespace std;
priority_queue<int> q1;
priority_queue<int, V<int>, greater<int>> q2;
int sum1, sum2, ans, t, ant;
namespace io {
#define in(a) a = read()
#define out(a) write(a), putchar(' ')
#define outn(a) out(a), putchar('\n')
#define I_int int
inline I_int read() {
I_int x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-')
f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return x * f;
}
char F[200];
inline void write(I_int x) {
if (x == 0) {
putchar('0');
return;
}
I_int tmp = x > 0 ? x : -x;
if (x < 0)
putchar('-');
int cnt = 0;
while (tmp > 0) {
F[cnt++] = tmp % 10 + '0';
tmp /= 10;
}
while (cnt > 0)
putchar(F[--cnt]);
}
#undef I_int
} // namespace io
using namespace io;
signed main() {
int q, x, y;
in(q);
FOR(i, 1, q) {
in(x);
if (x == 2) {
if (!q1.size()) {
puts("0");
continue;
}
ant = q1.top();
out(ant);
ans = ant * q1.size() - sum1 + sum2 - ant * q2.size();
outn(ans + t);
} else {
in(x);
in(y);
if (q1.empty() || q1.top() >= x) {
q1.emplace(x);
sum1 += x;
if (q1.size() > q2.size() + 1) {
q2.emplace(q1.top());
sum1 -= q1.top();
sum2 += q1.top();
q1.pop();
}
} else {
q2.emplace(x);
sum2 += x;
if (q2.size() > q1.size()) {
q1.emplace(q2.top());
sum2 -= q2.top();
sum1 += q2.top();
q2.pop();
}
}
t += y;
}
}
RE 0;
} | [
"expression.operation.binary.remove"
] | 854,748 | 854,749 | u751741878 | cpp |
p03040 | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define REP(i, m, n) for (int i = (int)(m); i < (int)(n); ++i)
#define rep(i, n) REP(i, 0, n)
#define pll pair<ll, ll>
#define pint pll
using ll = long long;
const int inf = 1e9 + 7;
const ll longinf = 1LL << 60;
const ll mod = 1e9 + 7;
int main() {
ll c = 0;
int q;
cin >> q;
priority_queue<ll> front;
priority_queue<ll, vector<ll>, greater<ll>> back;
ll frontSum = 0, backSum = 0;
rep(_, q) {
int op;
cin >> op;
if (op == 1) {
ll a, b;
cin >> a >> b;
c += b;
if (front.size() > back.size()) {
ll fr = front.top();
if (fr <= a) {
back.push(a);
backSum += a;
} else {
frontSum -= front.top();
front.pop();
front.push(a);
frontSum += a;
back.push(fr);
backSum += fr;
}
} else if (front.size() == 0) {
front.push(a);
frontSum += a;
} else {
ll ba = back.top();
if (front.top() >= a) {
front.push(a);
frontSum += a;
} else {
backSum -= back.top();
back.pop();
front.push(ba);
frontSum += ba;
back.push(a);
backSum += a;
}
}
} else {
ll mid = front.top();
ll x = (mid * (ll)front.size()) - frontSum + backSum -
(mid * (ll)back.size());
cout << mid << ' ' << x + c << endl;
}
}
return 0;
} | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define REP(i, m, n) for (int i = (int)(m); i < (int)(n); ++i)
#define rep(i, n) REP(i, 0, n)
#define pll pair<ll, ll>
#define pint pll
using ll = long long;
const int inf = 1e9 + 7;
const ll longinf = 1LL << 60;
const ll mod = 1e9 + 7;
int main() {
ll c = 0;
int q;
cin >> q;
priority_queue<ll> front;
priority_queue<ll, vector<ll>, greater<ll>> back;
ll frontSum = 0, backSum = 0;
rep(_, q) {
int op;
cin >> op;
if (op == 1) {
ll a, b;
cin >> a >> b;
c += b;
if (front.size() > back.size()) {
ll fr = front.top();
if (fr <= a) {
back.push(a);
backSum += a;
} else {
frontSum -= front.top();
front.pop();
front.push(a);
frontSum += a;
back.push(fr);
backSum += fr;
}
} else if (front.size() == 0) {
front.push(a);
frontSum += a;
} else {
ll ba = back.top();
if (ba >= a) {
front.push(a);
frontSum += a;
} else {
backSum -= back.top();
back.pop();
front.push(ba);
frontSum += ba;
back.push(a);
backSum += a;
}
}
} else {
ll mid = front.top();
ll x = (mid * (ll)front.size()) - frontSum + backSum -
(mid * (ll)back.size());
cout << mid << ' ' << x + c << endl;
}
}
return 0;
} | [
"control_flow.branch.if.condition.change",
"call.remove"
] | 854,752 | 854,753 | u906208439 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
#define MOD 1000000007
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define show(x) \
for (auto i : x) { \
cout << i << " "; \
}
#define showm(m) \
for (auto i : m) { \
cout << m.x << " "; \
}
typedef long long ll;
typedef pair<int, int> P;
int main() {
int qn;
cin >> qn;
vector<int> A;
ll B = 0;
ll mid = 0;
priority_queue<int, vector<int>, greater<int>> que_gre;
priority_queue<int, vector<int>, less<int>> que_less;
rep(i, qn) {
int q, a, b;
cin >> q;
if (q == 1)
cin >> a >> b;
if (i == 0) {
que_gre.push(a);
que_less.push(a);
B += b;
continue;
}
if (q == 1) {
que_gre.push(a);
que_less.push(a);
int g_top = que_gre.top();
int l_top = que_less.top();
if (g_top > l_top) {
mid += g_top - l_top;
que_gre.pop();
que_less.pop();
que_gre.push(l_top);
que_less.push(g_top);
}
B += b;
} else {
cout << que_gre.top() << " " << mid + B << endl;
}
}
}
| #include <bits/stdc++.h>
using namespace std;
#define MOD 1000000007
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define show(x) \
for (auto i : x) { \
cout << i << " "; \
}
#define showm(m) \
for (auto i : m) { \
cout << m.x << " "; \
}
typedef long long ll;
typedef pair<int, int> P;
int main() {
int qn;
cin >> qn;
vector<int> A;
ll B = 0;
ll mid = 0;
priority_queue<int, vector<int>, less<int>>
que_gre; //大きいものから取り出したい
priority_queue<int, vector<int>, greater<int>>
que_less; //小さいものから取り出したい
rep(i, qn) {
int q, a, b;
cin >> q;
if (q == 1)
cin >> a >> b;
if (i == 0) {
que_gre.push(a);
que_less.push(a);
B += b;
continue;
}
if (q == 1) {
que_gre.push(a);
que_less.push(a);
int g_top = que_gre.top();
int l_top = que_less.top();
if (g_top > l_top) {
mid += g_top - l_top;
que_gre.pop();
que_less.pop();
que_gre.push(l_top);
que_less.push(g_top);
}
B += b;
} else {
cout << que_gre.top() << " " << mid + B << endl;
}
}
}
| [] | 854,756 | 854,757 | u317715099 | cpp |
p03040 | /**
* code generated by JHelper
* More info: https://github.com/AlexeyDmitriev/JHelper
* @author
*/
#include <fstream>
#include <iostream>
#include "bits/stdc++.h"
#define REP(i, x, y) for (int i = (x); i < (y); i++)
#define RREP(i, x, y) for (int i = (y)-1; i >= (x); i--)
#define all(x) (x).begin(), (x).end()
//#define int long long
using namespace std;
// conversion
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T> inline string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
#define dump(x) cout << #x << " = " << (x) << endl
#define debug(x) \
cout << #x << " = " << (x) << " (L" << __LINE__ << ")" \
<< " " << __FILE__ << endl
typedef long long ll;
const ll MOD = 1e9 + 7;
class FAbsoluteMinima {
public:
void solve(std::istream &in, std::ostream &out) {
priority_queue<int> small;
priority_queue<int, vector<int>, greater<int>> large;
int Q;
in >> Q;
ll answer = 0;
REP(i, 0, Q) {
int type;
in >> type;
if (type == 1) {
int a, b;
in >> a >> b;
const int oldMedian = small.empty() ? 0 : small.top();
const int sizeDiff = small.size() - large.size();
if (small.empty() || small.top() > a) {
small.push(a);
} else {
large.push(a);
}
while (small.size() > large.size() + 1) {
int tmp = small.top();
large.push(tmp);
small.pop();
}
while (small.size() < large.size()) {
int tmp = large.top();
small.push(tmp);
large.pop();
}
const int newMedian = small.top();
answer +=
b + abs(newMedian - a) + sizeDiff * abs(newMedian - oldMedian);
} else {
out << small.top() << " " << answer << "\n";
}
}
}
};
int main() {
FAbsoluteMinima solver;
std::istream &in(std::cin);
std::ostream &out(std::cout);
solver.solve(in, out);
return 0;
}
| /**
* code generated by JHelper
* More info: https://github.com/AlexeyDmitriev/JHelper
* @author
*/
#include <fstream>
#include <iostream>
#include "bits/stdc++.h"
#define REP(i, x, y) for (int i = (x); i < (y); i++)
#define RREP(i, x, y) for (int i = (y)-1; i >= (x); i--)
#define all(x) (x).begin(), (x).end()
#define int long long
using namespace std;
// conversion
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T> inline string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
#define dump(x) cout << #x << " = " << (x) << endl
#define debug(x) \
cout << #x << " = " << (x) << " (L" << __LINE__ << ")" \
<< " " << __FILE__ << endl
typedef long long ll;
const ll MOD = 1e9 + 7;
class FAbsoluteMinima {
public:
void solve(std::istream &in, std::ostream &out) {
priority_queue<int> small;
priority_queue<int, vector<int>, greater<int>> large;
int Q;
in >> Q;
ll answer = 0;
REP(i, 0, Q) {
int type;
in >> type;
if (type == 1) {
int a, b;
in >> a >> b;
const int oldMedian = small.empty() ? 0 : small.top();
const int sizeDiff = small.size() - large.size();
if (small.empty() || small.top() > a) {
small.push(a);
} else {
large.push(a);
}
while (small.size() > large.size() + 1) {
int tmp = small.top();
large.push(tmp);
small.pop();
}
while (small.size() < large.size()) {
int tmp = large.top();
small.push(tmp);
large.pop();
}
const int newMedian = small.top();
answer +=
b + abs(newMedian - a) + sizeDiff * abs(newMedian - oldMedian);
} else {
out << small.top() << " " << answer << "\n";
}
}
}
};
signed main() {
FAbsoluteMinima solver;
std::istream &in(std::cin);
std::ostream &out(std::cout);
solver.solve(in, out);
return 0;
}
| [
"variable_declaration.type.primitive.change"
] | 854,758 | 854,759 | u535555850 | cpp |
p03040 | #include <algorithm>
#include <bits/stdc++.h>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define rep(X, S, E) for (int(X) = (S); (X) < (E); ++(X))
#define rrep(X, S, E) for (int(X) = (E)-1; (X) >= (S); --(X))
#define itrep(X, Y) for (auto(X) = (Y).begin(); (X) != (Y).end(); (X)++)
#define all(X) (X).begin(), (X).end()
#define sortDecending(X) sort(all(X), greater<ll>()) //降順
#define sortAscending(X) sort(all(X)) //昇順
#define pb push_back
#define mp make_pair
#define fi first
#define sc second
#define print(x) cout << x << endl
#define printDouble(x) cout << fixed << setprecision(13) << x << endl
#define chmin(x, y) x = min(x, y)
#define chmax(x, y) x = max(x, y)
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<bool> vb;
typedef priority_queue<ll, vl> decendingQueue; //降順
typedef priority_queue<ll, vl, greater<ll>> ascendingQueue; //昇順
const int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
const ll INF = 9 * 1e18;
const ll MOD = 1e9 + 7;
int main() {
int Q;
cin >> Q;
multiset<ll> less; // 中央値以下の値. less.size() >= more.size()
multiset<ll> more; // 中央値より大きい値
ll fx = 0;
rep(i, 0, Q) {
int q;
cin >> q;
if (q == 1) {
// 更新
int a, b;
cin >> a >> b;
fx += b;
if (less.size() == 0) {
less.insert(a);
continue;
} else {
fx += abs(*--less.end() - a);
}
ll lessv = *--less.end(); // 中央値
if (lessv < a) {
more.insert(a);
if (more.size() > less.size()) {
ll morev = *--more.end();
less.insert(morev);
more.erase(more.lower_bound(morev));
}
} else {
less.insert(a);
if (less.size() > more.size() + 1) {
more.insert(lessv);
less.erase(less.lower_bound(lessv));
}
}
ll lessv_new = *--less.end();
fx += abs(lessv_new - lessv) * (more.size() - less.size());
} else {
// 求値
print(*--less.end() << " " << fx);
}
}
return 0;
}
| #include <algorithm>
#include <bits/stdc++.h>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define rep(X, S, E) for (int(X) = (S); (X) < (E); ++(X))
#define rrep(X, S, E) for (int(X) = (E)-1; (X) >= (S); --(X))
#define itrep(X, Y) for (auto(X) = (Y).begin(); (X) != (Y).end(); (X)++)
#define all(X) (X).begin(), (X).end()
#define sortDecending(X) sort(all(X), greater<ll>()) //降順
#define sortAscending(X) sort(all(X)) //昇順
#define pb push_back
#define mp make_pair
#define fi first
#define sc second
#define print(x) cout << x << endl
#define printDouble(x) cout << fixed << setprecision(13) << x << endl
#define chmin(x, y) x = min(x, y)
#define chmax(x, y) x = max(x, y)
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<bool> vb;
typedef priority_queue<ll, vl> decendingQueue; //降順
typedef priority_queue<ll, vl, greater<ll>> ascendingQueue; //昇順
const int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
const ll INF = 9 * 1e18;
const ll MOD = 1e9 + 7;
int main() {
int Q;
cin >> Q;
multiset<ll> less; // 中央値以下の値. less.size() >= more.size()
multiset<ll> more; // 中央値より大きい値
ll fx = 0;
rep(i, 0, Q) {
int q;
cin >> q;
if (q == 1) {
// 更新
int a, b;
cin >> a >> b;
fx += b;
if (less.size() == 0) {
less.insert(a);
continue;
} else {
fx += abs(*--less.end() - a);
}
ll lessv = *--less.end(); // 中央値
if (lessv < a) {
more.insert(a);
if (more.size() > less.size()) {
ll morev = *more.begin();
less.insert(morev);
more.erase(more.lower_bound(morev));
}
} else {
less.insert(a);
if (less.size() > more.size() + 1) {
more.insert(lessv);
less.erase(less.lower_bound(lessv));
}
}
ll lessv_new = *--less.end();
fx += abs(lessv_new - lessv) * (more.size() - less.size());
} else {
// 求値
print(*--less.end() << " " << fx);
}
}
return 0;
}
| [] | 854,764 | 854,765 | u925940521 | cpp |
p03040 | #include <bits/stdc++.h>
#include <chrono>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#include <random>
using namespace std;
using namespace __gnu_pbds;
#define endl '\n'
typedef long long ll;
typedef pair<int, int> pii;
// typedef tree<int,null_type,less<int>,rb_tree_tag,
// tree_order_statistics_node_update> indexed_set;
// mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
const ll oo = 1e15;
int q;
cin >> q;
ll SL = 0, SR = 0, c = 0;
ll median = oo;
multiset<ll> L, R;
while (q--) {
int t;
cin >> t;
if (t == 1) {
ll a, b;
cin >> a >> b;
c += b;
if (median == oo)
median = a;
else {
if (a > median)
R.insert(a), SR += a;
else
L.insert(a), SL += a;
if ((ll)R.size() - (ll)L.size() == 2) {
L.insert(median);
SL += median;
median = *(R.begin());
R.erase(R.find(median));
SR -= median;
} else if ((ll)L.size() - (ll)R.size() == 2) {
R.insert(median);
SR += median;
median = *(L.rbegin());
L.erase(L.find(median));
SL -= median;
}
}
} else
cout << median << " "
<< median * (ll)L.size() - SL + SR - median * (ll)R.size() + c
<< endl;
}
return 0;
}
| #include <bits/stdc++.h>
#include <chrono>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#include <random>
using namespace std;
using namespace __gnu_pbds;
#define endl '\n'
typedef long long ll;
typedef pair<int, int> pii;
// typedef tree<int,null_type,less<int>,rb_tree_tag,
// tree_order_statistics_node_update> indexed_set;
// mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
const ll oo = 1e15;
int q;
cin >> q;
ll SL = 0, SR = 0, c = 0;
ll median = oo;
multiset<ll> L, R;
while (q--) {
int t;
cin >> t;
if (t == 1) {
ll a, b;
cin >> a >> b;
c += b;
if (median == oo)
median = a;
else {
if (a > median)
R.insert(a), SR += a;
else
L.insert(a), SL += a;
if ((ll)R.size() - (ll)L.size() == 2) {
L.insert(median);
SL += median;
median = *(R.begin());
R.erase(R.find(median));
SR -= median;
} else if ((ll)L.size() - (ll)R.size() == 1) {
R.insert(median);
SR += median;
median = *(L.rbegin());
L.erase(L.find(median));
SL -= median;
}
}
} else
cout << median << " "
<< median * (ll)L.size() - SL + SR - median * (ll)R.size() + c
<< endl;
}
return 0;
}
| [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 854,768 | 854,769 | u045505231 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
using int64 = long long;
constexpr int DEBUG = 0;
class OnlineMedian {
private:
priority_queue<int64, vector<int64>, less<int64>> pq_less;
priority_queue<int64, vector<int64>, greater<int64>> pq_greater;
public:
void Add(int64 x) {
if (pq_less.empty() || x <= pq_less.top()) {
pq_less.push(x);
pq_less.push(x);
} else {
pq_greater.push(x);
pq_greater.push(x);
}
if (pq_less.size() > pq_greater.size()) {
int64 t = pq_less.top();
pq_less.pop();
pq_greater.push(t);
} else if (pq_greater.size() > pq_less.size()) {
int64 t = pq_greater.top();
pq_greater.pop();
pq_less.push(t);
}
}
// Returns a median. When there are two, returns a less one.
int64 LessMedian() { return pq_less.top(); }
// Returns a median. When there are two, returns a greater one.
int64 GreaterMedian() { return pq_greater.top(); }
bool Empty() { return pq_less.empty(); }
};
class OnlineLeastAbsoluteErrors {
private:
OnlineMedian online_median;
int64 sum_of_absolute_errors;
public:
void Add(int64 x) {
if (!online_median.Empty()) {
if (x > online_median.GreaterMedian()) {
sum_of_absolute_errors += x - online_median.GreaterMedian();
} else if (x < online_median.LessMedian()) {
sum_of_absolute_errors += online_median.LessMedian() - x;
}
}
online_median.Add(x);
}
int64 SumOfAbsoluteErrors() { return sum_of_absolute_errors; }
int64 LessMedian() { return online_median.LessMedian(); }
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int num_queries;
cin >> num_queries;
OnlineLeastAbsoluteErrors online_lae;
int64 base = 0;
for (int i = 0; i < num_queries; i++) {
int command;
cin >> command;
if (command == 1) {
int64 a, b;
cin >> a >> b;
base += b;
online_lae.Add(a);
} else {
// Output
cout << online_lae.LessMedian() << " "
<< online_lae.SumOfAbsoluteErrors() + base << endl;
}
}
}
| #include <bits/stdc++.h>
using namespace std;
using int64 = long long;
constexpr int DEBUG = 0;
class OnlineMedian {
private:
priority_queue<int64, vector<int64>, less<int64>> pq_less;
priority_queue<int64, vector<int64>, greater<int64>> pq_greater;
public:
void Add(int64 x) {
if (pq_less.empty() || x <= pq_less.top()) {
pq_less.push(x);
pq_less.push(x);
} else {
pq_greater.push(x);
pq_greater.push(x);
}
if (pq_less.size() > pq_greater.size()) {
int64 t = pq_less.top();
pq_less.pop();
pq_greater.push(t);
} else if (pq_greater.size() > pq_less.size()) {
int64 t = pq_greater.top();
pq_greater.pop();
pq_less.push(t);
}
}
// Returns a median. When there are two, returns a less one.
int64 LessMedian() { return pq_less.top(); }
// Returns a median. When there are two, returns a greater one.
int64 GreaterMedian() { return pq_greater.top(); }
bool Empty() { return pq_less.empty(); }
};
class OnlineLeastAbsoluteErrors {
private:
OnlineMedian online_median;
int64 sum_of_absolute_errors = 0;
public:
void Add(int64 x) {
if (!online_median.Empty()) {
if (x > online_median.GreaterMedian()) {
sum_of_absolute_errors += x - online_median.GreaterMedian();
} else if (x < online_median.LessMedian()) {
sum_of_absolute_errors += online_median.LessMedian() - x;
}
}
online_median.Add(x);
}
int64 SumOfAbsoluteErrors() { return sum_of_absolute_errors; }
int64 LessMedian() { return online_median.LessMedian(); }
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int num_queries;
cin >> num_queries;
OnlineLeastAbsoluteErrors online_lae;
int64 base = 0;
for (int i = 0; i < num_queries; i++) {
int command;
cin >> command;
if (command == 1) {
int64 a, b;
cin >> a >> b;
base += b;
online_lae.Add(a);
} else {
// Output
cout << online_lae.LessMedian() << " "
<< online_lae.SumOfAbsoluteErrors() + base << endl;
}
}
}
| [] | 854,772 | 854,773 | u771276542 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
#define REP(i, a) for (int i = 0; i < (a); i++)
#define ALL(a) (a).begin(), (a).end()
typedef long long ll;
typedef pair<int, int> P;
const int INF = 1e9;
const long long LINF = 1e18;
const long long MOD = 1e9 + 7;
/*
1-indexed であることに注意 !!
*/
template <typename T> struct BIT {
int n;
vector<T> dat;
BIT(int n) : n(n), dat(n + 1, 0) {}
T sum(int a) {
T res = 0;
for (int i = a; i > 0; i -= (i & (-i)))
res += dat[i];
return res;
}
T sum(int a, int b) { return sum(b - 1) - sum(a - 1); }
void add(int k, T x) {
if (k == 0)
return;
for (int i = k; i <= n; i += (i & (-i)))
dat[i] += x;
}
/*
a[0] + a[1] + ... + a[res] >= x
*/
int lower_bound(T x) {
if (x <= 0)
return T(0);
int res = 0, k = 1;
while (k < n)
k <<= 1;
for (; k > 0; k >>= 1) {
if (res + k <= n && dat[res + k] < x) {
x -= dat[res + k];
res += k;
}
}
return res + 1;
}
};
/*
vector<long long> a(n) を座圧する場合 :
auto v = compress(a);
auto m = dict(v);
i番目の要素の取り出し方 :
m[a[i]]
*/
template <typename T> vector<T> compress(vector<T> vec) {
sort(vec.begin(), vec.end());
vec.erase(unique(vec.begin(), vec.end()), vec.end());
return vec;
}
template <typename T> map<T, int> dict(vector<T> &vec) {
map<T, int> res;
for (int i = 0; i < (int)vec.size(); i++) {
res[vec[i]] = i;
}
return res;
}
signed main() {
int q;
cin >> q;
vector<int> Q(q);
vector<ll> a(q), b(q);
vector<ll> t;
REP(i, q) {
cin >> Q[i];
if (Q[i] == 1) {
cin >> a[i] >> b[i];
t.emplace_back(a[i]);
}
}
auto v = compress(t);
auto m = dict(v);
int n = m.size();
BIT<int> bit(n);
BIT<ll> bita(n);
ll sum = 0;
int cnt = 0;
REP(i, q) {
if (Q[i] == 1) {
sum += b[i];
bit.add(m[a[i]] + 1, 1);
bita.add(m[a[i]] + 1, a[i]);
cnt++;
} else {
int itr = bit.lower_bound((cnt + 1) / 2);
ll x = v[itr - 1];
cout << x << " "
<< sum + bita.sum(itr - 1) - x * bit.sum(itr - 1) +
bita.sum(itr + 1, n + 1) - x * bit.sum(itr + 1, n + 1)
<< endl;
}
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define REP(i, a) for (int i = 0; i < (a); i++)
#define ALL(a) (a).begin(), (a).end()
typedef long long ll;
typedef pair<int, int> P;
const int INF = 1e9;
const long long LINF = 1e18;
const long long MOD = 1e9 + 7;
/*
1-indexed であることに注意 !!
*/
template <typename T> struct BIT {
int n;
vector<T> dat;
BIT(int n) : n(n), dat(n + 1, 0) {}
T sum(int a) {
T res = 0;
for (int i = a; i > 0; i -= (i & (-i)))
res += dat[i];
return res;
}
T sum(int a, int b) { return sum(b - 1) - sum(a - 1); }
void add(int k, T x) {
if (k == 0)
return;
for (int i = k; i <= n; i += (i & (-i)))
dat[i] += x;
}
/*
a[0] + a[1] + ... + a[res] >= x
*/
int lower_bound(T x) {
if (x <= 0)
return T(0);
int res = 0, k = 1;
while (k < n)
k <<= 1;
for (; k > 0; k >>= 1) {
if (res + k <= n && dat[res + k] < x) {
x -= dat[res + k];
res += k;
}
}
return res + 1;
}
};
/*
vector<long long> a(n) を座圧する場合 :
auto v = compress(a);
auto m = dict(v);
i番目の要素の取り出し方 :
m[a[i]]
*/
template <typename T> vector<T> compress(vector<T> vec) {
sort(vec.begin(), vec.end());
vec.erase(unique(vec.begin(), vec.end()), vec.end());
return vec;
}
template <typename T> map<T, int> dict(vector<T> &vec) {
map<T, int> res;
for (int i = 0; i < (int)vec.size(); i++) {
res[vec[i]] = i;
}
return res;
}
signed main() {
int q;
cin >> q;
vector<int> Q(q);
vector<ll> a(q), b(q);
vector<ll> t;
REP(i, q) {
cin >> Q[i];
if (Q[i] == 1) {
cin >> a[i] >> b[i];
t.emplace_back(a[i]);
}
}
auto v = compress(t);
auto m = dict(v);
int n = m.size();
BIT<int> bit(n);
BIT<ll> bita(n);
ll sum = 0;
int cnt = 0;
REP(i, q) {
if (Q[i] == 1) {
sum += b[i];
bit.add(m[a[i]] + 1, 1);
bita.add(m[a[i]] + 1, a[i]);
cnt++;
} else {
int itr = bit.lower_bound((cnt + 1) / 2);
ll x = v[itr - 1];
cout << x << " "
<< sum - bita.sum(itr - 1) + x * bit.sum(itr - 1) +
bita.sum(itr + 1, n + 1) - x * bit.sum(itr + 1, n + 1)
<< endl;
}
}
return 0;
} | [
"misc.opposites",
"expression.operator.arithmetic.change",
"io.output.change"
] | 854,774 | 854,775 | u366398972 | cpp |
p03040 | #pragma GCC optimize("O3")
#pragma GCC target("avx")
//#include<bits/stdc++.h>
#include <algorithm>
#include <cstdio>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep1(i, n) for (int i = 1; i <= (n); i++)
#define co(x) cout << (x) << "\n"
#define cosp(x) cout << (x) << " "
#define ce(x) cerr << (x) << "\n"
#define cesp(x) cerr << (x) << " "
#define pb push_back
#define mp make_pair
#define chmin(x, y) x = min(x, y)
#define chmax(x, y) x = max(x, y)
#define Would
#define you
#define please
const int cm = 1 << 17;
char cn[cm], *ci = cn + cm, ct;
inline char getcha() {
if (ci - cn == cm) {
fread_unlocked(cn, 1, cm, stdin);
ci = cn;
}
return *ci++;
}
inline int getint() {
int A = 0;
int pn = 1;
if (ci - cn + 16 > cm) {
if ((ct = getcha()) == '-') {
pn = -1;
ct = getcha();
}
A = ct - '0';
while ((ct = getcha()) >= '0')
A = A * 10 + ct - '0';
;
return pn * A;
} else {
if ((ct = *ci++) == '-') {
pn = -1;
ct = *ci++;
}
A = ct - '0';
while ((ct = *ci++) >= '0')
A = A * 10 + ct - '0';
;
return pn * A;
}
}
const int dm = 1 << 22;
char dn[dm], *di = dn;
inline void putint(ll X, ll X2) {
if (X == 0) {
*di++ = '0';
} else {
if (X < 0) {
*di++ = '-';
X = -X;
}
int keta = 0;
char C[20];
while (X) {
*(C + keta) = '0' + X % 10;
X /= 10;
keta++;
}
for (int i = keta - 1; i >= 0; i--)
*di++ = (*(C + i));
}
*di++ = ' ';
if (X2 == 0) {
*di++ = '0';
} else {
if (X2 < 0) {
*di++ = '-';
X2 = -X2;
}
int keta = 0;
char C[20];
while (X2) {
*(C + keta) = '0' + X2 % 10;
X2 /= 10;
keta++;
}
for (int i = keta - 1; i >= 0; i--)
*di++ = (*(C + i));
}
*di++ = '\n';
}
int tmp[200010], tmp2[200010];
void pakuripair_sort(int N, int A[], int B[]) {
const int b = 8;
rep(k, 4) {
int kazu[1 << b] = {}, kazu2[1 << b] = {};
rep(i, N) kazu[A[i] >> k * b & ((1 << b) - 1)]++;
rep(i, (1 << b) - 1) kazu[i + 1] += kazu[i];
for (int i = N - 1; i >= 0; i--) {
tmp[--kazu[A[i] >> k * b & ((1 << b) - 1)]] = A[i];
tmp2[kazu[A[i] >> k * b & ((1 << b) - 1)]] = B[i];
}
k++;
rep(i, N) kazu2[tmp[i] >> k * b & ((1 << b) - 1)]++;
rep(i, (1 << b) - 1) kazu2[i + 1] += kazu2[i];
for (int i = N - 1; i >= 0; i--) {
A[--kazu2[tmp[i] >> k * b & ((1 << b) - 1)]] = tmp[i];
B[kazu2[tmp[i] >> k * b & ((1 << b) - 1)]] = tmp2[i];
}
}
}
int kueri[200010] = {};
int main() {
// cin.tie(0);
// ios::sync_with_stdio(false);
int Q = getint();
int k = 1;
int A[200010], B[200010], D[200010] = {};
rep(i, Q) {
if (getcha() == '1') {
getcha();
A[k] = getint() ^ 1 << 31;
B[k] = getint();
D[k] = k;
k++;
} else {
getcha();
kueri[k]++;
}
}
pakuripair_sort(k - 1, A + 1, D + 1);
int T[200010];
rep1(i, k - 1) T[D[i]] = i;
rep1(i, k - 1) D[i] = 0;
if (k & 1) {
tmp[k] = k / 2;
tmp2[k] = k / 2 + 1;
} else {
tmp[k] = k / 2;
}
for (int i = k - 1; i >= 1; i--) {
int j = T[i];
int mae = D[j - 1];
if (!mae)
mae = j;
int ato = D[j + 1];
if (!ato)
ato = j;
if (i & 1) {
//たいらからとがってるに
if (j == tmp[i + 1]) {
tmp[i] = mae - 1;
tmp2[i] = ato + 1;
} else if (j < tmp[i + 1]) {
int ato2 = D[tmp[i + 1] + 1];
if (!ato2)
ato2 = tmp[i + 1];
tmp[i] = tmp[i + 1];
tmp2[i] = ato2 + 1;
} else {
int mae2 = D[tmp[i + 1] - 1];
if (!mae2)
mae2 = tmp[i + 1];
tmp[i] = mae2 - 1;
tmp2[i] = tmp[i + 1];
}
} else {
if (j <= tmp[i + 1])
tmp[i] = tmp2[i + 1];
else
tmp[i] = tmp[i + 1];
}
D[mae] = ato;
D[ato] = mae;
}
rep1(i, k - 1) A[i] = A[i] ^ 1 << 31;
ll X = 0;
rep1(i, k - 1) {
if (i & 1) {
if (T[i] < tmp[i])
X += A[tmp[i]] - A[T[i]];
else if (T[i] > tmp2[i])
X += A[T[i]] - A[tmp2[i]];
X += B[i];
} else {
X += abs(A[T[i]] - A[tmp[i]]) + B[i];
}
rep(j, kueri[i + 1]) putint(A[tmp[i + 1]], X);
}
fwrite_unlocked(dn, di - dn, 1, stdout);
Would you please return 0;
} | #pragma GCC optimize("O3")
#pragma GCC target("avx")
//#include<bits/stdc++.h>
#include <algorithm>
#include <cstdio>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep1(i, n) for (int i = 1; i <= (n); i++)
#define co(x) cout << (x) << "\n"
#define cosp(x) cout << (x) << " "
#define ce(x) cerr << (x) << "\n"
#define cesp(x) cerr << (x) << " "
#define pb push_back
#define mp make_pair
#define chmin(x, y) x = min(x, y)
#define chmax(x, y) x = max(x, y)
#define Would
#define you
#define please
const int cm = 1 << 17;
char cn[cm], *ci = cn + cm, ct;
inline char getcha() {
if (ci - cn == cm) {
fread_unlocked(cn, 1, cm, stdin);
ci = cn;
}
return *ci++;
}
inline int getint() {
int A = 0;
int pn = 1;
if (ci - cn + 16 > cm) {
if ((ct = getcha()) == '-') {
pn = -1;
ct = getcha();
}
A = ct - '0';
while ((ct = getcha()) >= '0')
A = A * 10 + ct - '0';
;
return pn * A;
} else {
if ((ct = *ci++) == '-') {
pn = -1;
ct = *ci++;
}
A = ct - '0';
while ((ct = *ci++) >= '0')
A = A * 10 + ct - '0';
;
return pn * A;
}
}
const int dm = 1 << 22;
char dn[dm], *di = dn;
inline void putint(ll X, ll X2) {
if (X == 0) {
*di++ = '0';
} else {
if (X < 0) {
*di++ = '-';
X = -X;
}
int keta = 0;
char C[20];
while (X) {
*(C + keta) = '0' + X % 10;
X /= 10;
keta++;
}
for (int i = keta - 1; i >= 0; i--)
*di++ = (*(C + i));
}
*di++ = ' ';
if (X2 == 0) {
*di++ = '0';
} else {
if (X2 < 0) {
*di++ = '-';
X2 = -X2;
}
int keta = 0;
char C[20];
while (X2) {
*(C + keta) = '0' + X2 % 10;
X2 /= 10;
keta++;
}
for (int i = keta - 1; i >= 0; i--)
*di++ = (*(C + i));
}
*di++ = '\n';
}
int tmp[200010], tmp2[200010];
void pakuripair_sort(int N, int A[], int B[]) {
const int b = 8;
rep(k, 4) {
int kazu[1 << b] = {}, kazu2[1 << b] = {};
rep(i, N) kazu[A[i] >> k * b & ((1 << b) - 1)]++;
rep(i, (1 << b) - 1) kazu[i + 1] += kazu[i];
for (int i = N - 1; i >= 0; i--) {
tmp[--kazu[A[i] >> k * b & ((1 << b) - 1)]] = A[i];
tmp2[kazu[A[i] >> k * b & ((1 << b) - 1)]] = B[i];
}
k++;
rep(i, N) kazu2[tmp[i] >> k * b & ((1 << b) - 1)]++;
rep(i, (1 << b) - 1) kazu2[i + 1] += kazu2[i];
for (int i = N - 1; i >= 0; i--) {
A[--kazu2[tmp[i] >> k * b & ((1 << b) - 1)]] = tmp[i];
B[kazu2[tmp[i] >> k * b & ((1 << b) - 1)]] = tmp2[i];
}
}
}
int kueri[200010] = {};
int main() {
// cin.tie(0);
// ios::sync_with_stdio(false);
int Q = getint();
int k = 1;
int A[200010], B[200010], D[200010] = {};
rep(i, Q) {
if (getcha() == '1') {
getcha();
A[k] = getint() ^ 1 << 31;
B[k] = getint();
D[k] = k;
k++;
} else {
getcha();
kueri[k]++;
}
}
pakuripair_sort(k - 1, A + 1, D + 1);
int T[200010];
rep1(i, k - 1) T[D[i]] = i;
rep1(i, k - 1) D[i] = 0;
if (k & 1) {
tmp[k] = k / 2;
tmp2[k] = k / 2 + 1;
} else {
tmp[k] = k / 2;
}
for (int i = k - 1; i >= 1; i--) {
int j = T[i];
int mae = D[j - 1];
if (!mae)
mae = j;
int ato = D[j + 1];
if (!ato)
ato = j;
if (i & 1) {
//たいらからとがってるに
if (j == tmp[i + 1]) {
tmp[i] = mae - 1;
tmp2[i] = ato + 1;
} else if (j < tmp[i + 1]) {
int ato2 = D[tmp[i + 1] + 1];
if (!ato2)
ato2 = tmp[i + 1];
tmp[i] = tmp[i + 1];
tmp2[i] = ato2 + 1;
} else {
int mae2 = D[tmp[i + 1] - 1];
if (!mae2)
mae2 = tmp[i + 1];
tmp[i] = mae2 - 1;
tmp2[i] = tmp[i + 1];
}
} else {
if (j <= tmp[i + 1])
tmp[i] = tmp2[i + 1];
else
tmp[i] = tmp[i + 1];
}
D[mae] = ato;
D[ato] = mae;
}
rep1(i, k - 1) A[i] = A[i] ^ 1 << 31;
ll X = 0;
rep1(i, k - 1) {
if (i & 1) {
if (T[i] < tmp[i])
X += A[tmp[i]] - A[T[i]];
else if (T[i] > tmp2[i])
X += A[T[i]] - A[tmp2[i]];
X += B[i];
} else {
X += abs(A[T[i]] - A[tmp[i]]);
X += B[i];
}
rep(j, kueri[i + 1]) putint(A[tmp[i + 1]], X);
}
fwrite_unlocked(dn, di - dn, 1, stdout);
Would you please return 0;
} | [
"expression.operation.binary.change",
"assignment.change"
] | 854,776 | 854,777 | u096883693 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep1(i, n) for (int i = 1; i <= (n); i++)
#define co(x) cout << (x) << "\n"
#define cosp(x) cout << (x) << " "
#define ce(x) cerr << (x) << "\n"
#define cesp(x) cerr << (x) << " "
#define pb push_back
#define mp make_pair
#define Would
#define you
#define please
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int Q;
cin >> Q;
ll maeX = 0;
ll atoX = 0;
priority_queue<int> mae;
priority_queue<int, vector<int>, greater<int>> ato;
mae.push(-2e9);
ato.push(2e9);
int maeN = 0;
int atoN = 0;
ll B = 0;
rep(i, Q) {
int q;
cin >> q;
if (q == 1) {
int a, b;
cin >> a >> b;
B += b;
if (atoN != maeN) {
int k = mae.top();
if (a < k) {
mae.pop();
ato.push(k);
mae.push(a);
maeX += a - k;
atoX += k;
} else {
ato.push(a);
atoX += a;
}
atoN++;
} else {
int k = ato.top();
if (a > k) {
ato.pop();
mae.push(k);
ato.push(a);
maeX += k;
atoX += a - k;
} else {
mae.push(a);
maeX += a;
}
maeN++;
}
} else {
int k = mae.top();
ll ans = (ll)maeN * k - maeX + atoX - (ll)atoN * k + B;
cesp(k);
co(ans);
}
}
Would you please return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep1(i, n) for (int i = 1; i <= (n); i++)
#define co(x) cout << (x) << "\n"
#define cosp(x) cout << (x) << " "
#define ce(x) cerr << (x) << "\n"
#define cesp(x) cerr << (x) << " "
#define pb push_back
#define mp make_pair
#define Would
#define you
#define please
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int Q;
cin >> Q;
ll maeX = 0;
ll atoX = 0;
priority_queue<int> mae;
priority_queue<int, vector<int>, greater<int>> ato;
mae.push(-2e9);
ato.push(2e9);
int maeN = 0;
int atoN = 0;
ll B = 0;
rep(i, Q) {
int q;
cin >> q;
if (q == 1) {
int a, b;
cin >> a >> b;
B += b;
if (atoN != maeN) {
int k = mae.top();
if (a < k) {
mae.pop();
ato.push(k);
mae.push(a);
maeX += a - k;
atoX += k;
} else {
ato.push(a);
atoX += a;
}
atoN++;
} else {
int k = ato.top();
if (a > k) {
ato.pop();
mae.push(k);
ato.push(a);
maeX += k;
atoX += a - k;
} else {
mae.push(a);
maeX += a;
}
maeN++;
}
} else {
int k = mae.top();
ll ans = (ll)maeN * k - maeX + atoX - (ll)atoN * k + B;
cosp(k);
co(ans);
}
}
Would you please return 0;
} | [
"identifier.change",
"call.function.change"
] | 854,778 | 854,779 | u096883693 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
ll q;
scanf("%lld", &q);
priority_queue<ll> L;
priority_queue<ll, vector<ll>, greater<ll>> R;
ll ret = 0;
ll t, a, b;
scanf("%lld%lld%lld", &t, &a, &b);
L.push(a);
ret = b;
q--;
for (; q > 0; q--) {
scanf("%lld", &t);
if (t == 1) {
scanf("%lld%lld", &a, &b);
if (a <= L.top()) {
ret += abs(a - L.top());
L.push(a);
if (L.size() >= R.size() + 2) {
R.push(L.top());
L.pop();
}
} else {
ret += abs(a - L.top());
R.push(a);
if (L.size() < R.size()) {
ret += R.top() - L.top();
L.push(R.top());
R.pop();
}
}
ret += b;
} else {
printf("%lld %lld\n", L.top(), ret);
}
}
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
ll q;
scanf("%lld", &q);
priority_queue<ll> L;
priority_queue<ll, vector<ll>, greater<ll>> R;
ll ret = 0;
ll t, a, b;
scanf("%lld%lld%lld", &t, &a, &b);
L.push(a);
ret = b;
q--;
for (; q > 0; q--) {
scanf("%lld", &t);
if (t == 1) {
scanf("%lld%lld", &a, &b);
if (a <= L.top()) {
ret += abs(a - L.top());
L.push(a);
if (L.size() >= R.size() + 2) {
R.push(L.top());
L.pop();
}
} else {
ret += abs(a - L.top());
R.push(a);
if (L.size() < R.size()) {
ret -= R.top() - L.top();
L.push(R.top());
R.pop();
}
}
ret += b;
} else {
printf("%lld %lld\n", L.top(), ret);
}
}
} | [
"expression.operator.change"
] | 854,780 | 854,781 | u957457849 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main() {
ll Q;
cin >> Q;
ll type, a, b, n, mn = 0;
multiset<ll> l, r;
auto resize = [&]() {
if (ll(l.size()) - ll(r.size()) > 1) {
auto mv = --l.end();
r.insert(*mv);
l.erase(mv);
} else if (ll(r.size()) - ll(l.size()) > 0) {
auto mv = r.begin();
l.insert(*mv);
r.erase(mv);
}
};
auto insert = [&](ll a) {
if (l.size() == 0 || a < *l.rbegin()) {
l.insert(a);
} else {
r.insert(a);
}
resize();
};
rep(q, Q) {
cin >> type;
if (type == 1) {
cin >> a >> b;
n++;
insert(a);
if (n % 2 == 0) {
if (a <= *l.rbegin())
mn += *r.begin() - a + b;
else
mn += a - *l.rbegin() + b;
} else {
mn += *l.rbegin() - a + b;
}
} else if (type == 2) {
cout << *l.rbegin() << ' ' << mn << '\n';
}
}
cout << flush;
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++)
int main() {
ll Q;
cin >> Q;
ll type, a, b, n, mn = 0;
multiset<ll> l, r;
auto resize = [&]() {
if (ll(l.size()) - ll(r.size()) > 1) {
auto mv = --l.end();
r.insert(*mv);
l.erase(mv);
} else if (ll(r.size()) - ll(l.size()) > 0) {
auto mv = r.begin();
l.insert(*mv);
r.erase(mv);
}
};
auto insert = [&](ll a) {
if (l.size() == 0 || a <= *l.rbegin()) {
l.insert(a);
} else {
r.insert(a);
}
resize();
};
rep(q, Q) {
cin >> type;
if (type == 1) {
cin >> a >> b;
n++;
insert(a);
if (n % 2 == 0) {
if (a <= *l.rbegin())
mn += *r.begin() - a + b;
else
mn += a - *l.rbegin() + b;
} else {
mn += abs(*l.rbegin() - a) + b;
}
} else if (type == 2) {
cout << *l.rbegin() << ' ' << mn << '\n';
}
}
cout << flush;
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"call.add",
"call.arguments.change"
] | 854,784 | 854,785 | u526974618 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, s, t) for (int i = s; i < t; i++)
typedef long long ll;
#define pii pair<ll, ll>
#define mid (l + r) / 2
#define lnode now * 2
#define rnode now * 2 + 1
#define MAXNUM 222222
ll tree[MAXNUM * 4];
ll sum[MAXNUM * 4], num[MAXNUM], add[MAXNUM * 4];
int allx[MAXNUM], xsize;
void pushit(int now, int num) { add[now] += num, tree[now] = sum[now] * num; }
void pushdown(int now) {
if (add[now])
pushit(lnode, add[now]), pushit(rnode, add[now]), add[now] = 0;
}
void change(int now, int l, int r, int ql, int qr, ll num) {
if (l == ql && r == qr) {
pushit(now, num);
return;
}
pushdown(now);
if (qr <= mid)
change(lnode, l, mid, ql, qr, num);
else if (ql > mid)
change(rnode, mid + 1, r, ql, qr, num);
else
change(lnode, l, mid, ql, mid, num),
change(rnode, mid + 1, r, mid + 1, qr, num);
tree[now] = tree[lnode] + tree[rnode];
}
ll query(int now, int l, int r, int pos) {
if (l == r)
return tree[now];
pushdown(now);
if (pos <= mid)
return query(lnode, l, mid, pos);
else
return tree[lnode] + query(rnode, mid + 1, r, pos);
}
void create(int now, int l, int r) {
if (l == r) {
sum[now] = num[l];
return;
}
create(lnode, l, mid), create(rnode, mid + 1, r);
sum[now] = sum[lnode] + sum[rnode];
}
const ll inf = 1e18;
pii allq[MAXNUM];
int main() {
ll allb = 0, allnum = 0;
int q, a, b;
scanf("%d", &q);
rep(i, 1, q + 1) {
scanf("%d", &a);
if (a == 1) {
scanf("%d%d", &a, &b);
allq[i] = {a, b};
allx[++xsize] = a;
} else
allq[i] = {inf, inf};
}
sort(allx + 1, allx + xsize + 1);
xsize = unique(allx + 1, allx + xsize + 1) - allx - 1;
rep(i, 2, xsize + 1) num[i] = allx[i] - allx[i - 1];
create(1, 1, xsize);
rep(i, 1, q + 1) {
if (allq[i].first != inf) {
allb += (allq[i].first - allx[1]) + allq[i].second;
allq[i].first =
lower_bound(allx + 1, allx + xsize + 1, allq[i].first) - allx;
change(1, 1, xsize, 1, allq[i].first, -1);
if (allq[i].first != xsize)
change(1, 1, xsize, allq[i].first + 1, xsize, 1);
} else {
ll l = 1, r = xsize - 1, res = xsize;
while (l <= r) {
if (query(1, 1, xsize, mid) <= query(1, 1, xsize, mid + 1))
res = mid, r = mid - 1;
else
l = mid + 1;
}
printf("%d %lld\n", allx[res], allb + query(1, 1, xsize, res));
}
}
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, s, t) for (int i = s; i < t; i++)
typedef long long ll;
#define pii pair<ll, ll>
#define mid (l + r) / 2
#define lnode now * 2
#define rnode now * 2 + 1
#define MAXNUM 222222
ll tree[MAXNUM * 4];
ll sum[MAXNUM * 4], num[MAXNUM], add[MAXNUM * 4];
int allx[MAXNUM], xsize;
void pushit(int now, int num) { add[now] += num, tree[now] += sum[now] * num; }
void pushdown(int now) {
if (add[now])
pushit(lnode, add[now]), pushit(rnode, add[now]), add[now] = 0;
}
void change(int now, int l, int r, int ql, int qr, ll num) {
if (l == ql && r == qr) {
pushit(now, num);
return;
}
pushdown(now);
if (qr <= mid)
change(lnode, l, mid, ql, qr, num);
else if (ql > mid)
change(rnode, mid + 1, r, ql, qr, num);
else
change(lnode, l, mid, ql, mid, num),
change(rnode, mid + 1, r, mid + 1, qr, num);
tree[now] = tree[lnode] + tree[rnode];
}
ll query(int now, int l, int r, int pos) {
if (l == r)
return tree[now];
pushdown(now);
if (pos <= mid)
return query(lnode, l, mid, pos);
else
return tree[lnode] + query(rnode, mid + 1, r, pos);
}
void create(int now, int l, int r) {
if (l == r) {
sum[now] = num[l];
return;
}
create(lnode, l, mid), create(rnode, mid + 1, r);
sum[now] = sum[lnode] + sum[rnode];
}
const ll inf = 1e18;
pii allq[MAXNUM];
int main() {
ll allb = 0;
int q, a, b;
scanf("%d", &q);
rep(i, 1, q + 1) {
scanf("%d", &a);
if (a == 1) {
scanf("%d%d", &a, &b);
allq[i] = {a, b};
allx[++xsize] = a;
} else
allq[i] = {inf, inf};
}
sort(allx + 1, allx + xsize + 1);
xsize = unique(allx + 1, allx + xsize + 1) - allx - 1;
rep(i, 2, xsize + 1) num[i] = allx[i] - allx[i - 1];
create(1, 1, xsize);
rep(i, 1, q + 1) {
if (allq[i].first != inf) {
allb += (allq[i].first - allx[1]) + allq[i].second;
allq[i].first =
lower_bound(allx + 1, allx + xsize + 1, allq[i].first) - allx;
change(1, 1, xsize, 1, allq[i].first, -1);
if (allq[i].first != xsize)
change(1, 1, xsize, allq[i].first + 1, xsize, 1);
} else {
ll l = 1, r = xsize - 1, res = xsize;
while (l <= r) {
if (query(1, 1, xsize, mid) <= query(1, 1, xsize, mid + 1))
res = mid, r = mid - 1;
else
l = mid + 1;
}
printf("%d %lld\n", allx[res], allb + query(1, 1, xsize, res));
}
}
}
| [
"assignment.value.change",
"variable_declaration.remove"
] | 854,792 | 854,793 | u930038564 | cpp |
p03040 | #include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <cstdint>
#include <cstdlib>
#include <iostream>
#include <list>
#include <queue>
#include <set>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep_r(i, n) for (int i = n - 1; i >= 0; i--)
#define rep1(i, n) for (int i = 1; i <= (int)(n); i++)
#define REP(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define all(x) (x).begin(), (x).end()
#define SZ(x) ((ll)(x).size())
#define bit(n) (1LL << (n))
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
#define INF bit(60)
#define pb push_back
#define mod 1000000007
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
using namespace std;
using uif = uint_fast64_t;
using ll = long long int;
int qp(int a, ll b) {
int ans = 1;
do {
if (b & 1)
ans = 1ll * ans * a % mod;
a = 1ll * a * a % mod;
} while (b >>= 1);
return ans;
}
int 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};
#define FACSIZE 2002
ll invfac[FACSIZE];
ll fac[FACSIZE];
ll mod_pow(ll, ll);
ll mod_add(ll, ll);
ll mod_mul(ll, ll);
ll mod_div(ll, ll);
void make_fact(ll);
void make_invfact(ll);
int main(void) {
ll n;
cin >> n;
priority_queue<ll> pql;
priority_queue<ll, vector<ll>, greater<ll>> pqh;
ll sumB = 0;
ll sumL = 0, sumH = 0;
ll numEle = 0;
ll center;
rep(i, n) {
ll q;
cin >> q;
if (q == 1) {
ll a, b;
cin >> a >> b;
numEle++;
sumB += b;
if (numEle % 2 == 0) {
if (numEle == 2) {
pql.push(min(center, a));
pqh.push(max(center, a));
sumL = min(center, a);
sumH = max(center, a);
} else {
if (a < center) {
pql.push(a);
pqh.push(center);
sumL += a;
sumH += center;
} else {
pql.push(center);
pqh.push(a);
sumL += center;
sumH += a;
}
}
} else {
if (numEle == 1) {
center = a;
} else {
if (pql.top() > a) {
pql.push(a);
center = pql.top();
pql.pop();
sumL += a - center;
} else if (a >= pql.top() && a < pqh.top()) {
center = a;
} else {
pqh.push(a);
center = pql.top();
pqh.pop();
sumH += a - center;
}
}
}
} else {
if (numEle % 2 == 0) {
cout << pql.top() << " " << sumH - sumL + sumB << endl;
} else {
cout << center << " " << sumH - sumL + sumB << endl;
}
}
}
return 0;
}
ll mod_pow(ll x, ll r) {
if (r == 0)
return 1;
else if (r == 1)
return x % mod;
else if (r % 2 == 0) {
ll t = mod_pow(x, r / 2) % mod;
return t * t % mod;
} else {
ll t = mod_pow(x, r / 2) % mod;
ll k = t * t % mod;
return k * x % mod;
}
}
ll mod_add(ll a, ll b) { return (a + b) % mod; }
ll mod_mul(ll a, ll b) { return (a * b) % mod; }
ll mod_div(ll a, ll b) { return mod_mul(a, mod_pow(b, mod - 2)); }
void make_fact(ll n) {
fac[0] = 1;
rep(i, n) { fac[i + 1] = mod_mul(fac[i], i + 1); }
}
void make_invfact(ll n) {
invfac[n] = mod_pow(fac[n], mod - 2);
for (int i = n - 1; i >= 0; i--) {
invfac[i] = mod_mul(invfac[i + 1], i + 1);
}
} | #include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <cstdint>
#include <cstdlib>
#include <iostream>
#include <list>
#include <queue>
#include <set>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep_r(i, n) for (int i = n - 1; i >= 0; i--)
#define rep1(i, n) for (int i = 1; i <= (int)(n); i++)
#define REP(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define all(x) (x).begin(), (x).end()
#define SZ(x) ((ll)(x).size())
#define bit(n) (1LL << (n))
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
#define INF bit(60)
#define pb push_back
#define mod 1000000007
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
using namespace std;
using uif = uint_fast64_t;
using ll = long long int;
int qp(int a, ll b) {
int ans = 1;
do {
if (b & 1)
ans = 1ll * ans * a % mod;
a = 1ll * a * a % mod;
} while (b >>= 1);
return ans;
}
int 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};
#define FACSIZE 2002
ll invfac[FACSIZE];
ll fac[FACSIZE];
ll mod_pow(ll, ll);
ll mod_add(ll, ll);
ll mod_mul(ll, ll);
ll mod_div(ll, ll);
void make_fact(ll);
void make_invfact(ll);
int main(void) {
ll n;
cin >> n;
priority_queue<ll> pql;
priority_queue<ll, vector<ll>, greater<ll>> pqh;
ll sumB = 0;
ll sumL = 0, sumH = 0;
ll numEle = 0;
ll center;
rep(i, n) {
ll q;
cin >> q;
if (q == 1) {
ll a, b;
cin >> a >> b;
numEle++;
sumB += b;
if (numEle % 2 == 0) {
if (numEle == 2) {
pql.push(min(center, a));
pqh.push(max(center, a));
sumL = min(center, a);
sumH = max(center, a);
} else {
if (a < center) {
pql.push(a);
pqh.push(center);
sumL += a;
sumH += center;
} else {
pql.push(center);
pqh.push(a);
sumL += center;
sumH += a;
}
}
} else {
if (numEle == 1) {
center = a;
} else {
if (pql.top() > a) {
pql.push(a);
center = pql.top();
pql.pop();
sumL += a - center;
} else if (a >= pql.top() && a < pqh.top()) {
center = a;
} else {
pqh.push(a);
center = pqh.top();
pqh.pop();
sumH += a - center;
}
}
}
} else {
if (numEle % 2 == 0) {
cout << pql.top() << " " << sumH - sumL + sumB << endl;
} else {
cout << center << " " << sumH - sumL + sumB << endl;
}
}
}
return 0;
}
ll mod_pow(ll x, ll r) {
if (r == 0)
return 1;
else if (r == 1)
return x % mod;
else if (r % 2 == 0) {
ll t = mod_pow(x, r / 2) % mod;
return t * t % mod;
} else {
ll t = mod_pow(x, r / 2) % mod;
ll k = t * t % mod;
return k * x % mod;
}
}
ll mod_add(ll a, ll b) { return (a + b) % mod; }
ll mod_mul(ll a, ll b) { return (a * b) % mod; }
ll mod_div(ll a, ll b) { return mod_mul(a, mod_pow(b, mod - 2)); }
void make_fact(ll n) {
fac[0] = 1;
rep(i, n) { fac[i + 1] = mod_mul(fac[i], i + 1); }
}
void make_invfact(ll n) {
invfac[n] = mod_pow(fac[n], mod - 2);
for (int i = n - 1; i >= 0; i--) {
invfac[i] = mod_mul(invfac[i + 1], i + 1);
}
} | [
"identifier.change"
] | 854,802 | 854,803 | u297007413 | cpp |
p03040 | #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;
}
if (r.size() != 0) {
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;
}
if (r.size() != 0) {
auto itrl = --l.end();
auto itrr = r.begin();
ll x = *itrl;
ll y = *itrr;
if (x > y) {
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;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 854,808 | 854,809 | u624678037 | cpp |
p03040 | #include <functional>
#include <queue>
#include <stdio.h>
#include <vector>
using lli = long long int;
int main(void) {
int Q;
scanf("%d", &Q);
lli B = 0, SL = 0, SU = 0;
std::priority_queue<int> L;
std::priority_queue<int, std::vector<int>, std::greater<int>> U;
while (Q--) {
int k;
scanf("%d", &k);
if (k == 1) {
int a, b;
scanf("%d%d", &a, &b);
B += b;
if (L.size() == U.size()) {
if (U.empty()) {
L.push(a);
SL += a;
} else if (U.top() < a) {
int v = U.top();
U.pop();
U.push(a);
SU += a - v;
L.push(v);
SL += v;
} else {
L.push(a);
SL += a;
}
} else {
if (L.top() > a) {
int v = L.top();
L.pop();
L.push(v);
SL += a - v;
U.push(v);
SU += v;
} else {
U.push(a);
SU += a;
}
}
} else {
if (L.empty()) {
puts("0 0");
continue;
}
int arg = L.top();
lli val = SU - SL + B;
if (L.size() > U.size())
val += arg;
printf("%d %lld\n", arg, val);
}
}
return 0;
} | #include <functional>
#include <queue>
#include <stdio.h>
#include <vector>
using lli = long long int;
int main(void) {
int Q;
scanf("%d", &Q);
lli B = 0, SL = 0, SU = 0;
std::priority_queue<int> L;
std::priority_queue<int, std::vector<int>, std::greater<int>> U;
while (Q--) {
int k;
scanf("%d", &k);
if (k == 1) {
int a, b;
scanf("%d%d", &a, &b);
B += b;
if (L.size() == U.size()) {
if (U.empty()) {
L.push(a);
SL += a;
} else if (U.top() < a) {
int v = U.top();
U.pop();
U.push(a);
SU += a - v;
L.push(v);
SL += v;
} else {
L.push(a);
SL += a;
}
} else {
if (L.top() > a) {
int v = L.top();
L.pop();
L.push(a);
SL += a - v;
U.push(v);
SU += v;
} else {
U.push(a);
SU += a;
}
}
} else {
if (L.empty()) {
puts("0 0");
continue;
}
int arg = L.top();
lli val = SU - SL + B;
if (L.size() > U.size())
val += arg;
printf("%d %lld\n", arg, val);
}
}
return 0;
} | [
"identifier.change",
"call.arguments.change"
] | 854,810 | 854,811 | u394853232 | cpp |
p03040 | #include <algorithm>
#include <cstdio>
#include <vector>
#define ll long long
using namespace std;
ll a[200010][3];
ll n;
ll seg[800000];
ll seg1[800000];
ll update(ll pos, ll val, ll node, ll x, ll y) {
if (pos < x || y < pos)
return seg[node];
if (x == y) {
return seg[node] += val;
}
ll mid = (x + y) / 2;
return seg[node] = update(pos, val, node * 2, x, mid) +
update(pos, val, node * 2 + 1, mid + 1, y);
}
ll update1(ll pos, ll val, ll node, ll x, ll y) {
if (pos < x || y < pos)
return seg1[node];
if (x == y)
return seg1[node] += val;
ll mid = (x + y) / 2;
return seg1[node] = update1(pos, val, node * 2, x, mid) +
update1(pos, val, node * 2 + 1, mid + 1, y);
}
ll check(ll val, ll node, ll x, ll y) {
if (x == y)
return x;
ll mid = (x + y) / 2;
if (seg[node * 2] >= val)
return check(val, node * 2, x, mid);
else
return check(val - seg[node * 2], node * 2 + 1, mid + 1, y);
}
ll query(ll lo, ll hi, ll node, ll x, ll y) {
if (hi < x || y < lo)
return 0;
if (lo <= x && y <= hi)
return seg[node];
ll mid = (x + y) / 2;
return query(lo, hi, node * 2, x, mid) +
query(lo, hi, node * 2 + 1, mid + 1, y);
}
ll query1(ll lo, ll hi, ll node, ll x, ll y) {
if (hi < x || y < lo)
return 0;
if (lo <= x && y <= hi)
return seg1[node];
ll mid = (x + y) / 2;
return query1(lo, hi, node * 2, x, mid) +
query1(lo, hi, node * 2 + 1, mid + 1, y);
}
vector<ll> vt;
ll getidx(ll x) { return lower_bound(vt.begin(), vt.end(), x) - vt.begin(); }
int main() {
scanf("%lld", &n);
for (int i = 0; i < n; i++) {
scanf("%lld", &a[i][0]);
if (a[i][0] == 1) {
scanf("%lld %lld", &a[i][1], &a[i][2]);
}
vt.push_back(a[i][1]);
}
sort(vt.begin(), vt.end());
ll sum = 0;
ll xx = 0;
vt.erase(unique(vt.begin(), vt.end()), vt.end());
for (int i = 0; i < n; i++) {
if (a[i][0] == 1) {
sum += a[i][2];
xx++;
update(getidx(a[i][1]), 1, 1, 0, vt.size());
update1(getidx(a[i][1]), a[i][1], 1, 0, vt.size());
} else {
ll ch = (xx + 1) / 2;
ll oo = check(ch, 1, 0, vt.size());
ll dap = sum;
dap +=
(query(0, oo, 1, 0, vt.size()) * oo - query1(0, oo, 1, 0, vt.size()));
dap += (query1(oo, vt.size(), 1, 0, vt.size()) -
query(oo, vt.size(), 1, 0, vt.size()) * oo);
printf("%lld %lld\n", vt[oo], dap);
}
}
} | #include <algorithm>
#include <cstdio>
#include <vector>
#define ll long long
using namespace std;
ll a[200010][3];
ll n;
ll seg[800000];
ll seg1[800000];
ll update(ll pos, ll val, ll node, ll x, ll y) {
if (pos < x || y < pos)
return seg[node];
if (x == y) {
return seg[node] += val;
}
ll mid = (x + y) / 2;
return seg[node] = update(pos, val, node * 2, x, mid) +
update(pos, val, node * 2 + 1, mid + 1, y);
}
ll update1(ll pos, ll val, ll node, ll x, ll y) {
if (pos < x || y < pos)
return seg1[node];
if (x == y)
return seg1[node] += val;
ll mid = (x + y) / 2;
return seg1[node] = update1(pos, val, node * 2, x, mid) +
update1(pos, val, node * 2 + 1, mid + 1, y);
}
ll check(ll val, ll node, ll x, ll y) {
if (x == y)
return x;
ll mid = (x + y) / 2;
if (seg[node * 2] >= val)
return check(val, node * 2, x, mid);
else
return check(val - seg[node * 2], node * 2 + 1, mid + 1, y);
}
ll query(ll lo, ll hi, ll node, ll x, ll y) {
if (hi < x || y < lo)
return 0;
if (lo <= x && y <= hi)
return seg[node];
ll mid = (x + y) / 2;
return query(lo, hi, node * 2, x, mid) +
query(lo, hi, node * 2 + 1, mid + 1, y);
}
ll query1(ll lo, ll hi, ll node, ll x, ll y) {
if (hi < x || y < lo)
return 0;
if (lo <= x && y <= hi)
return seg1[node];
ll mid = (x + y) / 2;
return query1(lo, hi, node * 2, x, mid) +
query1(lo, hi, node * 2 + 1, mid + 1, y);
}
vector<ll> vt;
ll getidx(ll x) { return lower_bound(vt.begin(), vt.end(), x) - vt.begin(); }
int main() {
scanf("%lld", &n);
for (int i = 0; i < n; i++) {
scanf("%lld", &a[i][0]);
if (a[i][0] == 1) {
scanf("%lld %lld", &a[i][1], &a[i][2]);
}
vt.push_back(a[i][1]);
}
sort(vt.begin(), vt.end());
ll sum = 0;
ll xx = 0;
vt.erase(unique(vt.begin(), vt.end()), vt.end());
for (int i = 0; i < n; i++) {
if (a[i][0] == 1) {
sum += a[i][2];
xx++;
update(getidx(a[i][1]), 1, 1, 0, vt.size());
update1(getidx(a[i][1]), a[i][1], 1, 0, vt.size());
} else {
ll ch = (xx + 1) / 2;
ll oo = check(ch, 1, 0, vt.size());
ll dap = sum;
dap += (query(0, oo, 1, 0, vt.size()) * vt[oo] -
query1(0, oo, 1, 0, vt.size()));
dap += (query1(oo, vt.size(), 1, 0, vt.size()) -
query(oo, vt.size(), 1, 0, vt.size()) * vt[oo]);
printf("%lld %lld\n", vt[oo], dap);
}
}
} | [] | 854,816 | 854,817 | u266602249 | cpp |
p03040 | #define _USE_MATH_DEFINES
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define rep(i, a, b) for (int i = (a), i##_len = (b); i < i##_len; i++)
#define rrep(i, a, b) for (int i = (b)-1; i >= (a); i--)
#define all(c) begin(c), end(c)
#define int ll
#define SZ(x) ((int)(x).size())
#define pb push_back
#define mp make_pair
typedef long long ll;
// typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<ll, int> pli;
typedef pair<double, double> pdd;
typedef vector<vector<int>> mat;
// typedef unsigned int uint;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
const int INF =
sizeof(int) == sizeof(long long) ? 0x3f3f3f3f3f3f3f3fLL : 0x3f3f3f3f;
const int MOD = (int)1e9 + 7;
const double EPS = 1e-9;
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
int Q;
priority_queue<int> lpq;
priority_queue<int, vector<int>, greater<int>> rpq;
int sl = 0, sr = 0;
int m = INF;
int B = 0;
int q, a, b;
cin >> Q;
rep(i, 0, Q) {
cin >> q;
if (q == 1) {
cin >> a >> b;
B += b;
if (m == INF) {
m = a;
} else {
if (a <= m) {
lpq.push(a);
sl += m - a;
} else {
rpq.push(a);
sr += a - m;
}
if (SZ(lpq) < SZ(rpq)) {
int t = rpq.top();
lpq.push(m);
sl += (t - m) * SZ(lpq);
sr -= (t - m) * SZ(rpq);
m = t;
rpq.pop();
}
if (SZ(lpq) > SZ(rpq) + 1) {
int t = lpq.top();
rpq.push(m);
sr += (m - t) * SZ(rpq);
sl -= (m - t) * SZ(lpq);
m = t;
lpq.pop();
}
}
} else {
cout << m << " " << sl + sr + B << endl;
}
}
return 0;
}
| #define _USE_MATH_DEFINES
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define rep(i, a, b) for (int i = (a), i##_len = (b); i < i##_len; i++)
#define rrep(i, a, b) for (int i = (b)-1; i >= (a); i--)
#define all(c) begin(c), end(c)
#define int ll
#define SZ(x) ((int)(x).size())
#define pb push_back
#define mp make_pair
typedef long long ll;
// typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<ll, int> pli;
typedef pair<double, double> pdd;
typedef vector<vector<int>> mat;
// typedef unsigned int uint;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
const int INF =
sizeof(int) == sizeof(long long) ? 0x3f3f3f3f3f3f3f3fLL : 0x3f3f3f3f;
const int MOD = (int)1e9 + 7;
const double EPS = 1e-9;
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
int Q;
priority_queue<int> lpq;
priority_queue<int, vector<int>, greater<int>> rpq;
int sl = 0, sr = 0;
int m = INF;
int B = 0;
int q, a, b;
cin >> Q;
rep(i, 0, Q) {
cin >> q;
if (q == 1) {
cin >> a >> b;
B += b;
if (m == INF) {
m = a;
} else {
if (a <= m) {
lpq.push(a);
sl += m - a;
} else {
rpq.push(a);
sr += a - m;
}
if (SZ(lpq) + 1 < SZ(rpq)) {
int t = rpq.top();
lpq.push(m);
sl += (t - m) * SZ(lpq);
sr -= (t - m) * SZ(rpq);
m = t;
rpq.pop();
}
if (SZ(lpq) > SZ(rpq)) {
int t = lpq.top();
rpq.push(m);
sr += (m - t) * SZ(rpq);
sl -= (m - t) * SZ(lpq);
m = t;
lpq.pop();
}
}
} else {
cout << m << " " << sl + sr + B << endl;
}
}
return 0;
}
| [
"control_flow.branch.if.condition.change",
"expression.operation.binary.remove"
] | 854,818 | 854,819 | u874947858 | cpp |
p03040 | #define _USE_MATH_DEFINES
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define rep(i, a, b) for (int i = (a), i##_len = (b); i < i##_len; i++)
#define rrep(i, a, b) for (int i = (b)-1; i >= (a); i--)
#define all(c) begin(c), end(c)
#define int ll
#define SZ(x) ((int)(x).size())
#define pb push_back
#define mp make_pair
typedef long long ll;
// typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<ll, int> pli;
typedef pair<double, double> pdd;
typedef vector<vector<int>> mat;
// typedef unsigned int uint;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
const int INF =
sizeof(int) == sizeof(long long) ? 0x3f3f3f3f3f3f3f3fLL : 0x3f3f3f3f;
const int MOD = (int)1e9 + 7;
const double EPS = 1e-9;
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
int Q;
priority_queue<int> lpq;
priority_queue<int, vector<int>, greater<int>> rpq;
int sl = 0, sr = 0;
int m = INF;
int B = 0;
int q, a, b;
cin >> Q;
rep(i, 0, Q) {
cin >> q;
if (q == 1) {
cin >> a >> b;
B += b;
if (m == INF) {
m = a;
} else {
if (a <= m) {
lpq.push(a);
sl += m - a;
} else {
rpq.push(a);
sr += a - m;
}
if (SZ(lpq) > SZ(rpq) + 1) {
int t = lpq.top();
rpq.push(m);
sr += (m - t) * SZ(rpq);
sl -= (m - t) * SZ(lpq);
m = t;
lpq.pop();
}
if (SZ(lpq) < SZ(rpq)) {
int t = rpq.top();
lpq.push(m);
sl += (t - m) * SZ(lpq);
sr -= (t - m) * SZ(rpq);
m = t;
rpq.pop();
}
}
} else {
cout << m << " " << sl + sr + B << endl;
}
}
return 0;
}
| #define _USE_MATH_DEFINES
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define rep(i, a, b) for (int i = (a), i##_len = (b); i < i##_len; i++)
#define rrep(i, a, b) for (int i = (b)-1; i >= (a); i--)
#define all(c) begin(c), end(c)
#define int ll
#define SZ(x) ((int)(x).size())
#define pb push_back
#define mp make_pair
typedef long long ll;
// typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<ll, int> pli;
typedef pair<double, double> pdd;
typedef vector<vector<int>> mat;
// typedef unsigned int uint;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
const int INF =
sizeof(int) == sizeof(long long) ? 0x3f3f3f3f3f3f3f3fLL : 0x3f3f3f3f;
const int MOD = (int)1e9 + 7;
const double EPS = 1e-9;
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
int Q;
priority_queue<int> lpq;
priority_queue<int, vector<int>, greater<int>> rpq;
int sl = 0, sr = 0;
int m = INF;
int B = 0;
int q, a, b;
cin >> Q;
rep(i, 0, Q) {
cin >> q;
if (q == 1) {
cin >> a >> b;
B += b;
if (m == INF) {
m = a;
} else {
if (a <= m) {
lpq.push(a);
sl += m - a;
} else {
rpq.push(a);
sr += a - m;
}
if (SZ(lpq) > SZ(rpq)) {
int t = lpq.top();
rpq.push(m);
sr += (m - t) * SZ(rpq);
sl -= (m - t) * SZ(lpq);
m = t;
lpq.pop();
}
if (SZ(lpq) + 1 < SZ(rpq)) {
int t = rpq.top();
lpq.push(m);
sl += (t - m) * SZ(lpq);
sr -= (t - m) * SZ(rpq);
m = t;
rpq.pop();
}
}
} else {
cout << m << " " << sl + sr + B << endl;
}
}
return 0;
}
| [
"expression.operation.binary.remove",
"control_flow.branch.if.condition.change"
] | 854,820 | 854,821 | u874947858 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.