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 |
|---|---|---|---|---|---|---|---|
p02990 | #include <array>
#include <iostream>
#include <iostream>
#include <vector>
using namespace std;
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;
}
std::vector<long long> solve_blue_and_red_balls(int n, int k) {
COMinit();
vector<long long> ans(k);
for (int i = 1; i <= k; i++) {
// cout << "=====" << endl;
// cout << "n-k+1: " << n-k+1 << " " << " i: " << i << " -> " << COM(n-k+1,
// i) << endl; cout << "k-1: " << k-1 << " " << " i-1: " << i -1 << " -> " <<
// COM(k-1, i-1) << endl;
ans[i - 1] = (COM(n - k + 1, i) * COM(k - 1, i - 1)) % MOD;
// cout << "ans " << i << " -> " << ans[i-1] << endl;
// cout << "=====" << endl;
}
return ans;
}
int main() {
int n, k;
cin >> n;
cin >> k;
vector<long long> ans = solve_blue_and_red_balls(n, k);
for (int i = 0; i < k; i++) {
cout << ans[i];
}
} | #include <array>
#include <iostream>
#include <iostream>
#include <vector>
using namespace std;
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;
}
std::vector<long long> solve_blue_and_red_balls(int n, int k) {
COMinit();
vector<long long> ans(k);
for (int i = 1; i <= k; i++) {
// cout << "=====" << endl;
// cout << "n-k+1: " << n-k+1 << " " << " i: " << i << " -> " << COM(n-k+1,
// i) << endl; cout << "k-1: " << k-1 << " " << " i-1: " << i -1 << " -> " <<
// COM(k-1, i-1) << endl;
ans[i - 1] = (COM(n - k + 1, i) * COM(k - 1, i - 1)) % MOD;
// cout << "ans " << i << " -> " << ans[i-1] << endl;
// cout << "=====" << endl;
}
return ans;
}
int main() {
int n, k;
cin >> n;
cin >> k;
vector<long long> ans = solve_blue_and_red_balls(n, k);
for (int i = 0; i < k; i++) {
cout << ans[i] << endl;
}
} | [
"io.output.newline.add"
] | 797,668 | 797,669 | u570229212 | cpp |
p02990 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll l, n, k, x, a, b, c, d, sum;
vector<int> v;
const ll MOD = 1e9 + 7;
const ll N = 2000;
const ll K = 2000;
ll C[N + 2][K + 2];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
memset(C, 0, sizeof C);
C[0][0] = 1;
C[1][0] = 1;
for (int i = 0; i <= N; i++) {
C[i][0] = 1;
}
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= K; j++) {
C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]);
}
}
cin >> n >> k;
a = n - k + 1;
for (int i = 1; i <= k; i++) {
b = C[a][i] % MOD;
c = C[k - 1][i - 1] & MOD;
if (i == 1) {
c = 1;
}
cout << (b * c) % MOD << "\n";
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll l, n, k, x, a, b, c, d, sum;
vector<int> v;
const ll MOD = 1e9 + 7;
const ll N = 2000;
const ll K = 2000;
ll C[N + 2][K + 2];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
memset(C, 0, sizeof C);
C[0][0] = 1;
C[1][0] = 1;
for (int i = 0; i <= N; i++) {
C[i][0] = 1;
}
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= K; j++) {
C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % MOD;
}
}
cin >> n >> k;
a = n - k + 1;
for (int i = 1; i <= k; i++) {
b = C[a][i] % MOD;
c = C[k - 1][i - 1] % MOD;
if (i == 1) {
c = 1;
}
cout << (b * c) % MOD << "\n";
}
return 0;
} | [
"assignment.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 797,670 | 797,671 | u353919145 | cpp |
p02990 | #include <bits/stdc++.h>
using namespace std;
struct Fast {
Fast() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
}
} fast;
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
long long mod = 1000000007;
#define REP(i, n) for (long long i = 0; i < (n); i++)
#define rep(i, a, n) for (long long i = a; i < (n); i++)
long long modpow(long long m, long long n) {
if (n == 0)
return 1;
if (n % 2 == 0) {
long long t = modpow(m, n / 2);
return (t * t) % mod;
} else {
return (modpow(m, n - 1) * m) % mod;
}
}
template <typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val) {
std::fill((T *)array, (T *)(array + N), val);
}
// long long mod = 998244353;
long long power(long long m, long long n) {
if (n == 0)
return 1;
if (n % 2 == 0) {
long long t = modpow(m, n / 2);
return t * t;
} else {
return modpow(m, n - 1) * m;
}
}
long long moddiv(long long a, long long b) {
return (a * modpow(b, mod - 2)) % mod;
}
const ll INF = 1LL << 60;
void print_binary(long long a) {
for (int i = 31; i >= 0; i--) {
cout << (a >> i & 1);
}
cout << endl;
}
ll nCkmod(ll n, ll k) {
ll denomi = 1;
for (int i = n; i > n - k; i--) {
denomi *= i;
denomi %= mod;
}
ll numera = 1;
REP(i, k) {
numera *= (i + 1);
numera %= mod;
}
return moddiv(denomi, numera);
}
map<ll, ll> cnt;
void primeFactors(long long n) {
while (n % 2 == 0) {
cnt[2]++;
n = n / 2;
}
for (int i = 3; i <= sqrt(n); i = i + 2) {
while (n % i == 0) {
cnt[i]++;
n = n / i;
}
}
if (n > 2) {
cnt[n]++;
}
}
int main() {
ll n, k;
cin >> n >> k;
rep(i, 1, k + 1) {
ll ans = 0;
ans += 2 * (nCkmod(k - 1, i - 1)) * (nCkmod(n - k - 1, i - 1));
ans += (nCkmod(k - 1, i - 1)) * (nCkmod(n - k - 1, i - 2));
ans += (nCkmod(k - 1, i - 1)) * (nCkmod(n - k - 1, i));
if (i == 1) {
ans--;
}
cout << ans << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
struct Fast {
Fast() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
}
} fast;
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
long long mod = 1000000007;
#define REP(i, n) for (long long i = 0; i < (n); i++)
#define rep(i, a, n) for (long long i = a; i < (n); i++)
long long modpow(long long m, long long n) {
if (n == 0)
return 1;
if (n % 2 == 0) {
long long t = modpow(m, n / 2);
return (t * t) % mod;
} else {
return (modpow(m, n - 1) * m) % mod;
}
}
template <typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val) {
std::fill((T *)array, (T *)(array + N), val);
}
// long long mod = 998244353;
long long power(long long m, long long n) {
if (n == 0)
return 1;
if (n % 2 == 0) {
long long t = modpow(m, n / 2);
return t * t;
} else {
return modpow(m, n - 1) * m;
}
}
long long moddiv(long long a, long long b) {
return (a * modpow(b, mod - 2)) % mod;
}
const ll INF = 1LL << 60;
void print_binary(long long a) {
for (int i = 31; i >= 0; i--) {
cout << (a >> i & 1);
}
cout << endl;
}
ll nCkmod(ll n, ll k) {
ll denomi = 1;
for (int i = n; i > n - k; i--) {
denomi *= i;
denomi %= mod;
}
ll numera = 1;
REP(i, k) {
numera *= (i + 1);
numera %= mod;
}
return moddiv(denomi, numera);
}
map<ll, ll> cnt;
void primeFactors(long long n) {
while (n % 2 == 0) {
cnt[2]++;
n = n / 2;
}
for (int i = 3; i <= sqrt(n); i = i + 2) {
while (n % i == 0) {
cnt[i]++;
n = n / i;
}
}
if (n > 2) {
cnt[n]++;
}
}
int main() {
ll n, k;
cin >> n >> k;
rep(i, 1, k + 1) {
ll ans = 0;
ans += 2 * (nCkmod(k - 1, i - 1)) * (nCkmod(n - k - 1, i - 1));
ans += (nCkmod(k - 1, i - 1)) * (nCkmod(n - k - 1, i - 2));
ans += (nCkmod(k - 1, i - 1)) * (nCkmod(n - k - 1, i));
if (i == 1) {
ans--;
}
ans %= mod;
cout << ans << endl;
}
} | [
"assignment.add"
] | 797,674 | 797,675 | u687204015 | cpp |
p02990 | #include <bits/stdc++.h>
using namespace std;
struct Fast {
Fast() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
}
} fast;
template <typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val) {
std::fill((T *)array, (T *)(array + N), val);
}
// long long mod = 998244353;
#define REP(i, n) for (long long i = 0; i < (n); i++)
#define rep(i, a, n) for (long long i = a; i < (n); i++)
typedef long long ll;
typedef pair<ll, ll> P;
long long mod = 1000000007;
long long modpow(long long m, long long n, long long modvalue) {
if (n == 0)
return 1;
if (n % 2 == 0) {
long long t = modpow(m, n / 2, modvalue);
return t * t % modvalue;
} else {
return modpow(m, n - 1, modvalue) * m % modvalue;
}
}
long long moddiv(long long a, long long b, ll modvalue) {
return (a * modpow(b, mod - 2, modvalue)) % modvalue;
}
const ll INF = 1LL << 60;
string change_binary(long long a) {
string ret;
for (int i = 31; i >= 0; i--) {
ret += (a >> i & 1) + '0';
}
return ret;
}
ll nCkmod(ll n, ll k, ll modvalue) {
ll numera = 1;
for (int i = n; i > n - k; i--) {
numera *= i;
numera %= modvalue;
}
ll denomi = 1;
REP(i, k) {
denomi *= (i + 1);
denomi %= modvalue;
}
return moddiv(numera, denomi, modvalue);
}
map<ll, ll> cnt;
void primeFactors(long long n) {
while (n % 2 == 0) {
cnt[2]++;
n = n / 2;
}
for (int i = 3; i <= sqrt(n); i = i + 2) {
while (n % i == 0) {
cnt[i]++;
n = n / i;
}
}
if (n > 2) {
cnt[n]++;
}
}
int main() {
ll n, k;
cin >> n >> k;
rep(i, 1, k + 1) {
ll ans = 0;
ans += (nCkmod(k - 1, i - 1, mod)) * (nCkmod(n - k + 1, i, mod));
cout << ans << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
struct Fast {
Fast() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
}
} fast;
template <typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val) {
std::fill((T *)array, (T *)(array + N), val);
}
// long long mod = 998244353;
#define REP(i, n) for (long long i = 0; i < (n); i++)
#define rep(i, a, n) for (long long i = a; i < (n); i++)
typedef long long ll;
typedef pair<ll, ll> P;
long long mod = 1000000007;
long long modpow(long long m, long long n, long long modvalue) {
if (n == 0)
return 1;
if (n % 2 == 0) {
long long t = modpow(m, n / 2, modvalue);
return t * t % modvalue;
} else {
return modpow(m, n - 1, modvalue) * m % modvalue;
}
}
long long moddiv(long long a, long long b, ll modvalue) {
return (a * modpow(b, mod - 2, modvalue)) % modvalue;
}
const ll INF = 1LL << 60;
string change_binary(long long a) {
string ret;
for (int i = 31; i >= 0; i--) {
ret += (a >> i & 1) + '0';
}
return ret;
}
ll nCkmod(ll n, ll k, ll modvalue) {
ll numera = 1;
for (int i = n; i > n - k; i--) {
numera *= i;
numera %= modvalue;
}
ll denomi = 1;
REP(i, k) {
denomi *= (i + 1);
denomi %= modvalue;
}
return moddiv(numera, denomi, modvalue);
}
map<ll, ll> cnt;
void primeFactors(long long n) {
while (n % 2 == 0) {
cnt[2]++;
n = n / 2;
}
for (int i = 3; i <= sqrt(n); i = i + 2) {
while (n % i == 0) {
cnt[i]++;
n = n / i;
}
}
if (n > 2) {
cnt[n]++;
}
}
int main() {
ll n, k;
cin >> n >> k;
// cout << nCkmod(3, 5, mod) << endl;
rep(i, 1, k + 1) {
ll ans = 0;
ans += (nCkmod(k - 1, i - 1, mod)) * (nCkmod(n - k + 1, i, mod));
ans %= mod;
cout << ans << endl;
}
} | [
"assignment.add"
] | 797,676 | 797,677 | u687204015 | cpp |
p02990 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define INF 1LL << 62
#define inf 1000000007
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, k;
cin >> n >> k;
for (ll i = 1; i <= k; i++) {
cout << COM(n - k + 1, i) * COM(k - 1, i - 1) << endl;
}
// 計算例
// cout << COM(100000, 50000) << endl;
// your code goes here
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define INF 1LL << 62
#define inf 1000000007
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, k;
cin >> n >> k;
for (ll i = 1; i <= k; i++) {
cout << (COM(n - k + 1, i) * COM(k - 1, i - 1)) % inf << endl;
}
// 計算例
// cout << COM(100000, 50000) << endl;
// your code goes here
return 0;
} | [
"expression.operation.binary.add"
] | 797,686 | 797,687 | u166378830 | cpp |
p02990 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define INF 1LL << 62
#define inf 1000000007
ll a[2005][2005];
int main() {
a[0][0] = 1;
for (int i = 1; i < 2005; i++) {
for (int j = 0; j <= i; j++) {
a[i][j] = a[i - 1][j - 1] + a[i - 1][j];
a[i][j] %= inf;
}
}
ll n, k;
cin >> n >> k;
for (int i = 1; i <= k; i++) {
cout << a[k - 1][i - 1] * a[k][i] % inf << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define INF 1LL << 62
#define inf 1000000007
ll a[2005][2005];
int main() {
a[0][0] = 1;
for (int i = 1; i < 2005; i++) {
for (int j = 0; j <= i; j++) {
a[i][j] = a[i - 1][j - 1] + a[i - 1][j];
a[i][j] %= inf;
}
}
ll n, k;
cin >> n >> k;
for (int i = 1; i <= k; i++) {
cout << a[k - 1][i - 1] * a[n - k + 1][i] % inf << endl;
}
} | [
"expression.operation.binary.add"
] | 797,688 | 797,689 | u166378830 | cpp |
p02990 | #include <bits/stdc++.h>
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
#define rep(i, cc, n) for (int i = cc; i < n; ++i)
#define lrep(i, cc, n) for (long long i = cc; i < n; ++i)
#define sqrep(i, cc, n) for (long long i = cc; i * i <= n; ++i)
#define rrep(i, cc, n) for (long i = cc; i > n; --i)
#define pii pair<int, int>
#define pll pair<long long, long long>
using ll = long long;
const vector<int> dx = {1, 0, -1, 0};
const vector<int> dy = {0, 1, 0, -1};
const double PI = 3.1415926535;
const ll inf = 1001001001;
const ll e9 = 1000000000;
const ll mod = 1000000007;
const int MAX = 3000;
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, k;
cin >> n >> k;
COMinit();
rep(i, 1, k + 1) { cout << COM(n - k + 1, i) * COM(k - 1, i - 1) << endl; }
} | #include <bits/stdc++.h>
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
#define rep(i, cc, n) for (int i = cc; i < n; ++i)
#define lrep(i, cc, n) for (long long i = cc; i < n; ++i)
#define sqrep(i, cc, n) for (long long i = cc; i * i <= n; ++i)
#define rrep(i, cc, n) for (long i = cc; i > n; --i)
#define pii pair<int, int>
#define pll pair<long long, long long>
using ll = long long;
const vector<int> dx = {1, 0, -1, 0};
const vector<int> dy = {0, 1, 0, -1};
const double PI = 3.1415926535;
const ll inf = 1001001001;
const ll e9 = 1000000000;
const ll mod = 1000000007;
const int MAX = 3000;
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, k;
cin >> n >> k;
COMinit();
rep(i, 1, k + 1) {
cout << COM(n - k + 1, i) * COM(k - 1, i - 1) % MOD << endl;
}
} | [
"expression.operation.binary.add"
] | 797,690 | 797,691 | u330518333 | cpp |
p02990 | #include <bits/stdc++.h>
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
#define rep(i, cc, n) for (int i = cc; i < n; ++i)
#define lrep(i, cc, n) for (long long i = cc; i < n; ++i)
#define sqrep(i, cc, n) for (long long i = cc; i * i <= n; ++i)
#define rrep(i, cc, n) for (long i = cc; i > n; --i)
#define pii pair<int, int>
#define pll pair<long long, long long>
using ll = long long;
const vector<int> dx = {1, 0, -1, 0};
const vector<int> dy = {0, 1, 0, -1};
const double PI = 3.1415926535;
const ll inf = 1001001001;
const ll e9 = 1000000000;
const ll mod = 1000000007;
const int MAX = 3000;
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, k;
cin >> n >> k;
COMinit();
rep(i, 1, k + 1) { cout << COM(n - k + 1, i) * COM(k - 1, i - 1) << endl; }
} | #include <bits/stdc++.h>
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
#define rep(i, cc, n) for (int i = cc; i < n; ++i)
#define lrep(i, cc, n) for (long long i = cc; i < n; ++i)
#define sqrep(i, cc, n) for (long long i = cc; i * i <= n; ++i)
#define rrep(i, cc, n) for (long i = cc; i > n; --i)
#define pii pair<int, int>
#define pll pair<long long, long long>
using ll = long long;
const vector<int> dx = {1, 0, -1, 0};
const vector<int> dy = {0, 1, 0, -1};
const double PI = 3.1415926535;
const ll inf = 1001001001;
const ll e9 = 1000000000;
const ll mod = 1000000007;
const int MAX = 1000000;
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, k;
cin >> n >> k;
COMinit();
rep(i, 1, k + 1) {
cout << COM(n - k + 1, i) * COM(k - 1, i - 1) % MOD << endl;
}
} | [
"literal.number.change",
"variable_declaration.value.change"
] | 797,690 | 797,692 | u330518333 | cpp |
p02990 | #include <bits/stdc++.h>
#pragma GCC optimize("unroll-loops,no-stack-protector")
#pragma GCC target("sse,sse2,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#define watch(x) cout << (#x) << " is " << (x) << endl
#define debug cout << "hi" << endl
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
const int MOD = 1e9 + 7;
const int INF32 = 1 << 30;
const ll INF64 = 1LL << 60;
ll modpow(ll b, ll i) {
ll s = 1;
while (i) {
if (i % 2)
s = (s * b) % MOD;
b = (b * b) % MOD;
i /= 2;
}
return s;
}
ll nCr(ll n, ll r) {
ll m1 = 1, m2 = 1;
r = min(r, n - r);
for (int i = 0; i < r; i++) {
m1 = (m1 * (n - i)) % MOD;
m2 = (m2 * (r - i)) % MOD;
}
return (m1 * modpow(m2, MOD - 2)) % MOD;
}
void solve() {
int n, k;
cin >> n >> k;
for (int i = 0; i < k; i++) {
if (k > n - k + 1)
cout << 0 << endl;
else
cout << nCr(k - 1, i) * nCr(n - k + 1, i + 1) % MOD << endl;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
solve();
return 0;
} | #include <bits/stdc++.h>
#pragma GCC optimize("unroll-loops,no-stack-protector")
#pragma GCC target("sse,sse2,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#define watch(x) cout << (#x) << " is " << (x) << endl
#define debug cout << "hi" << endl
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
const int MOD = 1e9 + 7;
const int INF32 = 1 << 30;
const ll INF64 = 1LL << 60;
ll modpow(ll b, ll i) {
ll s = 1;
while (i) {
if (i % 2)
s = (s * b) % MOD;
b = (b * b) % MOD;
i /= 2;
}
return s;
}
ll nCr(ll n, ll r) {
ll m1 = 1, m2 = 1;
r = min(r, n - r);
for (int i = 0; i < r; i++) {
m1 = (m1 * (n - i)) % MOD;
m2 = (m2 * (r - i)) % MOD;
}
return (m1 * modpow(m2, MOD - 2)) % MOD;
}
void solve() {
int n, k;
cin >> n >> k;
for (int i = 0; i < k; i++) {
if (n - k < i)
cout << 0 << endl;
else
cout << nCr(k - 1, i) * nCr(n - k + 1, i + 1) % MOD << endl;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
solve();
return 0;
} | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 797,693 | 797,694 | u311090179 | cpp |
p02990 | /*
* atcoder/abc132_3rd/d.cpp
*/
// C++ 14
#include <algorithm>
#include <cassert>
#include <cmath>
#include <cstring> // memset
#include <iostream>
#include <vector>
using namespace std;
#define ll long long
#define loop(__x, __start, __end) for (int __x = __start; __x < __end; __x++)
template <class T> ostream &operator<<(ostream &out, vector<T> const &v) {
for (auto &&a : v)
out << a << " ";
out << endl;
return out;
}
template <class T> void dump(T &a) { cout << a << endl; }
template <class T> bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
/* Mod */
#define MOD 1000000007
template <class T> void madd(T &a, T b) {
if ((a += b) >= MOD)
a -= MOD;
}
template <class T> void msub(T &a, T b) {
if ((a += MOD - b) >= MOD)
a -= MOD;
}
struct mint {
ll x;
mint() : x(0) {}
mint(ll x) : x((x % MOD + MOD) % MOD) {}
// mint(ll x):x(x){}
mint &fix() {
x = (x % MOD + MOD) % MOD;
return *this;
}
mint operator-() const { return mint(0) - *this; }
mint &operator+=(const mint &a) {
if ((x += a.x) >= MOD)
x -= MOD;
return *this;
}
mint &operator-=(const mint &a) {
if ((x += MOD - a.x) >= MOD)
x -= MOD;
return *this;
}
mint &operator*=(const mint &a) {
(x *= a.x) %= MOD;
return *this;
}
mint operator+(const mint &a) const { return mint(*this) += a; }
mint operator-(const mint &a) const { return mint(*this) -= a; }
mint operator*(const mint &a) const { return mint(*this) *= a; }
bool operator<(const mint &a) const { return x < a.x; }
bool operator==(const mint &a) const { return x == a.x; }
};
ostream &operator<<(ostream &out, mint const &v) {
out << v.x;
return out;
}
/* nCk */
template <class T> struct BiCoef {
vector<T> fact_, inv_, finv_;
constexpr BiCoef() {}
constexpr BiCoef(int n) noexcept : fact_(n, 1), inv_(n, 1), finv_(n, 1) {
init(n);
}
constexpr void init(int n) noexcept {
fact_.assign(n, 1), inv_.assign(n, 1), finv_.assign(n, 1);
for (int i = 2; i < n; i++) {
fact_[i] = fact_[i - 1] * i;
inv_[i] = -inv_[MOD % i] * (MOD / i);
finv_[i] = finv_[i - 1] * inv_[i];
}
}
constexpr T com(int n, int k) const noexcept {
if (n < k || n < 0 || k < 0)
return 0;
return fact_[n] * finv_[k] * finv_[n - k];
}
constexpr T fact(int n) const noexcept {
if (n < 0)
return 0;
return fact_[n];
}
constexpr T inv(int n) const noexcept {
if (n < 0)
return 0;
return inv_[n];
}
constexpr T finv(int n) const noexcept {
if (n < 0)
return 0;
return finv_[n];
}
};
int N, K;
BiCoef<mint> bc;
void solve() {
cin >> N >> K;
bc.init(2001);
loop(k, 0, K) { cout << bc.com(K - 1, K - k) * bc.com(N - K + 1, k) << endl; }
}
int main() {
// cout.precision(15); cout << fixed;
solve();
return 0;
}
| /*
* atcoder/abc132_3rd/d.cpp
*/
// C++ 14
#include <algorithm>
#include <cassert>
#include <cmath>
#include <cstring> // memset
#include <iostream>
#include <vector>
using namespace std;
#define ll long long
#define loop(__x, __start, __end) for (int __x = __start; __x < __end; __x++)
template <class T> ostream &operator<<(ostream &out, vector<T> const &v) {
for (auto &&a : v)
out << a << " ";
out << endl;
return out;
}
template <class T> void dump(T &a) { cout << a << endl; }
template <class T> bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
/* Mod */
#define MOD 1000000007
template <class T> void madd(T &a, T b) {
if ((a += b) >= MOD)
a -= MOD;
}
template <class T> void msub(T &a, T b) {
if ((a += MOD - b) >= MOD)
a -= MOD;
}
struct mint {
ll x;
mint() : x(0) {}
mint(ll x) : x((x % MOD + MOD) % MOD) {}
// mint(ll x):x(x){}
mint &fix() {
x = (x % MOD + MOD) % MOD;
return *this;
}
mint operator-() const { return mint(0) - *this; }
mint &operator+=(const mint &a) {
if ((x += a.x) >= MOD)
x -= MOD;
return *this;
}
mint &operator-=(const mint &a) {
if ((x += MOD - a.x) >= MOD)
x -= MOD;
return *this;
}
mint &operator*=(const mint &a) {
(x *= a.x) %= MOD;
return *this;
}
mint operator+(const mint &a) const { return mint(*this) += a; }
mint operator-(const mint &a) const { return mint(*this) -= a; }
mint operator*(const mint &a) const { return mint(*this) *= a; }
bool operator<(const mint &a) const { return x < a.x; }
bool operator==(const mint &a) const { return x == a.x; }
};
ostream &operator<<(ostream &out, mint const &v) {
out << v.x;
return out;
}
/* nCk */
template <class T> struct BiCoef {
vector<T> fact_, inv_, finv_;
constexpr BiCoef() {}
constexpr BiCoef(int n) noexcept : fact_(n, 1), inv_(n, 1), finv_(n, 1) {
init(n);
}
constexpr void init(int n) noexcept {
fact_.assign(n, 1), inv_.assign(n, 1), finv_.assign(n, 1);
for (int i = 2; i < n; i++) {
fact_[i] = fact_[i - 1] * i;
inv_[i] = -inv_[MOD % i] * (MOD / i);
finv_[i] = finv_[i - 1] * inv_[i];
}
}
constexpr T com(int n, int k) const noexcept {
if (n < k || n < 0 || k < 0)
return 0;
return fact_[n] * finv_[k] * finv_[n - k];
}
constexpr T fact(int n) const noexcept {
if (n < 0)
return 0;
return fact_[n];
}
constexpr T inv(int n) const noexcept {
if (n < 0)
return 0;
return inv_[n];
}
constexpr T finv(int n) const noexcept {
if (n < 0)
return 0;
return finv_[n];
}
};
int N, K;
BiCoef<mint> bc;
void solve() {
cin >> N >> K;
bc.init(2001);
loop(k, 1, K + 1) {
cout << bc.com(K - 1, K - k) * bc.com(N - K + 1, k) << endl;
}
}
int main() {
// cout.precision(15); cout << fixed;
solve();
return 0;
}
| [
"literal.number.change",
"call.arguments.change"
] | 797,695 | 797,696 | u823862638 | cpp |
p02990 | #include <iostream>
using namespace std;
static const long long MOD = 1e9 + 7;
long long C[2005][2005];
void COMB() {
for (int i = 1; i < 2005; ++i) {
C[i][0] = 1;
C[i][i] = 1;
}
for (int i = 2; i < 2005; ++i) {
for (int j = 1; j < i; ++j) {
C[i][j] = C[i - 1][j - 1] % MOD + C[i - 1][j] % MOD;
C[i][j] = C[i][j] % MOD;
}
}
}
int main() {
int n, k;
cin >> n >> k;
COMB();
for (int i = 1; i <= k; ++i) {
long long ans = C[n - k + 1][i] * C[k - 1][i - 1] % MOD;
cout << ans << endl;
}
} | #include <iostream>
using namespace std;
static const long long MOD = 1e9 + 7;
long long C[2005][2005];
void COMB() {
for (int i = 0; i < 2005; ++i) {
C[i][0] = 1;
C[i][i] = 1;
}
for (int i = 2; i < 2005; ++i) {
for (int j = 1; j < i; ++j) {
C[i][j] = C[i - 1][j - 1] % MOD + C[i - 1][j] % MOD;
C[i][j] = C[i][j] % MOD;
}
}
}
int main() {
int n, k;
cin >> n >> k;
COMB();
for (int i = 1; i <= k; ++i) {
long long ans = C[n - k + 1][i] * C[k - 1][i - 1] % MOD;
cout << ans << endl;
}
} | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 797,697 | 797,698 | u159943174 | cpp |
p02990 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define MOD 1000000007
struct Mcomb {
vector<ll> fac;
vector<ll> inv;
vector<ll> finv;
// nCnまで対応できる
Mcomb(int n) {
fac.resize(n + 1), inv.resize(n + 1), finv.resize(n + 1);
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i <= n; 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 ncr(int n, int r) {
if (n < r)
return 0;
if (n < 0 || r < 0)
return 0;
return fac[n] * (finv[r] * finv[n - r] % MOD) % MOD;
}
ll npr(int n, int r) {
if (n < r)
return 0;
if (n < 0 || r < 0)
return 0;
return (fac[n] * inv[n - r]) % MOD;
}
};
int main() {
Mcomb comb(10000);
int n, blue;
cin >> n >> blue;
int red = n - blue;
for (int i = 1; i <= blue; i++) {
ll cur = comb.ncr(blue - 1, i - 1);
cur %= MOD;
// cerr << "cur : " << cur << " curred : " << red - (i - 1) << endl;
cur *= comb.ncr(red - (i - 1) + i, i);
cur %= MOD;
cerr << cur << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define MOD 1000000007
struct Mcomb {
vector<ll> fac;
vector<ll> inv;
vector<ll> finv;
// nCnまで対応できる
Mcomb(int n) {
fac.resize(n + 1), inv.resize(n + 1), finv.resize(n + 1);
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i <= n; 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 ncr(int n, int r) {
if (n < r)
return 0;
if (n < 0 || r < 0)
return 0;
return fac[n] * (finv[r] * finv[n - r] % MOD) % MOD;
}
ll npr(int n, int r) {
if (n < r)
return 0;
if (n < 0 || r < 0)
return 0;
return (fac[n] * inv[n - r]) % MOD;
}
};
int main() {
Mcomb comb(10000);
int n, blue;
cin >> n >> blue;
int red = n - blue;
for (int i = 1; i <= blue; i++) {
ll cur = comb.ncr(blue - 1, i - 1);
cur %= MOD;
// cerr << "cur : " << cur << " curred : " << red - (i - 1) << endl;
cur *= comb.ncr(red - (i - 1) + i, i);
cur %= MOD;
cout << cur << endl;
}
} | [
"identifier.change",
"io.output.change"
] | 797,701 | 797,702 | u543584809 | cpp |
p02990 | #include <bits/stdc++.h>
int mod = 1000000007;
std::vector<long long> fac(1000100), inv(1000100),
finv(1000100); //階乗 / 逆元 / inv * fac
void comb_init() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < 1000100; 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 r) {
if (n < r)
return 0;
if (n < 0 || r < 0)
return 0;
return fac[n] * (finv[r] * finv[n - r] % mod) % mod;
}
int main() {
comb_init();
int n, k;
std::cin >> n >> k;
for (int i = 1; i <= k; i++) {
int tmp = comb(n - k + 1, i) % mod;
int tmp2 = comb(k - 1, i - 1) % mod;
std::cout << tmp * tmp2 % mod << std::endl;
}
} | #include <bits/stdc++.h>
long long mod = 1000000007;
std::vector<long long> fac(1000100), inv(1000100),
finv(1000100); //階乗 / 逆元 / inv * fac
void comb_init() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < 1000100; 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 r) {
if (n < r)
return 0;
if (n < 0 || r < 0)
return 0;
return fac[n] * (finv[r] * finv[n - r] % mod) % mod;
}
int main() {
comb_init();
int n, k;
std::cin >> n >> k;
for (int i = 1; i <= k; i++) {
long long tmp = comb(n - k + 1, i) % mod;
long long tmp2 = comb(k - 1, i - 1) % mod;
std::cout << tmp * tmp2 % mod << std::endl;
}
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 797,703 | 797,704 | u543584809 | cpp |
p02990 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
ll power(ll X, ll Y, ll P) {
vector<ll> digit2(1000), XX(1000);
ll I, N, mod;
I = 0;
while (Y != 0) {
digit2.at(I) = Y % 2;
Y = Y / 2;
I++;
}
N = I;
XX.at(0) = X % P;
for (I = 1; I < N; I++) {
XX.at(I) = (XX.at(I - 1) * XX.at(I - 1)) % P;
}
mod = 1;
for (I = 0; I < N; I++) {
if (digit2.at(I) == 1) {
mod = (mod * XX.at(I)) % P;
}
}
if (mod < 0) {
mod = mod + P;
}
return mod;
}
int main() {
ll n, k;
cin >> n >> k;
if (k == 1) {
cout << n + 1 << endl;
} else {
ll i, s = n - k + 1, p = 1000000007;
cout << s << endl;
for (i = 2; i <= k; i++) {
s = (s * (k - i + 1) * (n - k - i + 2)) % p;
s = (s * power(i * (i - 1), p - 2, p)) % p;
cout << s << endl;
}
}
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
ll power(ll X, ll Y, ll P) {
vector<ll> digit2(1000), XX(1000);
ll I, N, mod;
I = 0;
while (Y != 0) {
digit2.at(I) = Y % 2;
Y = Y / 2;
I++;
}
N = I;
XX.at(0) = X % P;
for (I = 1; I < N; I++) {
XX.at(I) = (XX.at(I - 1) * XX.at(I - 1)) % P;
}
mod = 1;
for (I = 0; I < N; I++) {
if (digit2.at(I) == 1) {
mod = (mod * XX.at(I)) % P;
}
}
if (mod < 0) {
mod = mod + P;
}
return mod;
}
int main() {
ll n, k;
cin >> n >> k;
if (k == 1) {
cout << n << endl;
} else {
ll i, s = n - k + 1, p = 1000000007;
cout << s << endl;
for (i = 2; i <= k; i++) {
s = (s * (k - i + 1) * (n - k - i + 2)) % p;
s = (s * power(i * (i - 1), p - 2, p)) % p;
cout << s << endl;
}
}
} | [
"expression.operation.binary.remove"
] | 797,708 | 797,709 | u666712170 | cpp |
p02990 | #include <algorithm>
#include <bits/stdc++.h>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
const long double EPS = 1e-9;
const ll mod = 1e9 + 7;
const ll INF = 1e9;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define For(i, a, b) for (ll i = (a); i < (b); i++)
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
const ll MAX_N = 2000;
ll power_mod(ll a, ll power) {
ll value = 1;
while (power != 0) {
if (power & 1)
value = (value * a) % mod;
a = (a * a) % mod;
power = power >> 1;
}
return value % mod;
}
ll combination(ll n, ll r) {
ll numerator = 1;
ll denomenator = 1;
for (ll i = 0; i < r; i++) {
(numerator *= ll(n - i)) %= mod;
(denomenator *= power_mod(ll(i + 1), ll(mod - 2))) %= mod;
}
return (numerator * denomenator) % mod;
}
int main(void) {
ll N, K;
ll answer;
cin >> N >> K;
rep(i, K) {
ll c1 = combination(K - 1, i);
ll c2 = combination(N - K - 1, i - 1);
ll c3 = combination(N - K - 1, i);
ll c4 = combination(N - K - 1, i + 1);
ll a1 = c1 * c2 % mod;
ll a2 = c1 * c3 % mod * 2 % mod;
ll a3 = c1 * c4 % mod;
answer = ((a1 + a2) % mod + a3) % mod;
if (i == 0)
cout << answer - 1 << endl;
else
cout << answer - 1 << endl;
}
return 0;
} | #include <algorithm>
#include <bits/stdc++.h>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
const long double EPS = 1e-9;
const ll mod = 1e9 + 7;
const ll INF = 1e9;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define For(i, a, b) for (ll i = (a); i < (b); i++)
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
const ll MAX_N = 2000;
ll power_mod(ll a, ll power) {
ll value = 1;
while (power != 0) {
if (power & 1)
value = (value * a) % mod;
a = (a * a) % mod;
power = power >> 1;
}
return value % mod;
}
ll combination(ll n, ll r) {
ll numerator = 1;
ll denomenator = 1;
for (ll i = 0; i < r; i++) {
(numerator *= ll(n - i)) %= mod;
(denomenator *= power_mod(ll(i + 1), ll(mod - 2))) %= mod;
}
return (numerator * denomenator) % mod;
}
int main(void) {
ll N, K;
ll answer;
cin >> N >> K;
rep(i, K) {
ll c1 = combination(K - 1, i);
ll c2 = combination(N - K - 1, i - 1);
ll c3 = combination(N - K - 1, i);
ll c4 = combination(N - K - 1, i + 1);
ll a1 = c1 * c2 % mod;
ll a2 = c1 * c3 % mod * 2 % mod;
ll a3 = c1 * c4 % mod;
answer = ((a1 + a2) % mod + a3) % mod;
if (i == 0)
cout << answer - 1 << endl;
else
cout << answer << endl;
}
return 0;
} | [
"expression.operation.binary.remove"
] | 797,710 | 797,711 | u767543103 | cpp |
p02990 | #include <iostream>
using namespace std;
const int MOD = 1e9 + 7, N = 2005;
int dp[N][N];
int main() {
int n, k;
cin >> n >> k;
dp[0][0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= i; j++) {
if (j == 0)
dp[i][j] = 1;
else
dp[i][j] = (dp[i - 1][j - 1] + dp[i - 1][j]) % MOD;
}
}
for (int i = 1; i <= k; i++) {
cout << (dp[n - k + 1][i] * dp[k - 1][i - 1]) % MOD << endl;
}
}
| #include <iostream>
using namespace std;
const int MOD = 1e9 + 7, N = 2005;
long long dp[N][N];
int main() {
int n, k;
cin >> n >> k;
dp[0][0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= i; j++) {
if (j == 0)
dp[i][j] = 1;
else
dp[i][j] = (dp[i - 1][j - 1] + dp[i - 1][j]) % MOD;
}
}
for (int i = 1; i <= k; i++) {
cout << (dp[n - k + 1][i] * dp[k - 1][i - 1]) % MOD << endl;
}
}
| [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 797,723 | 797,724 | u448570453 | cpp |
p02990 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
#define MOD 1000000007LL
#define rep(i, n) for (ll(i) = 0LL; (i) < (ll)(n); (i)++)
#define rep2(i, s, e) for (ll(i) = (ll)(s); (i) < (ll)(e); (i)++)
#define repi(i, n) for (ll(i) = 0LL; (i) <= (ll)(n); (i)++)
#define repi2(i, s, e) for (ll(i) = (ll)(s); (i) <= (ll)(e); (i)++)
#define per(i, n) for (ll(i) = (ll)(n)-1LL; (i) >= 0LL; (i)--)
#define per2(i, s, e) for (ll(i) = (ll)(s)-1LL; (i) >= (ll)(e); (i)--)
#define peri(i, n) for (ll(i) = (ll)(n); (i) >= 0LL; (i)--)
#define peri2(i, s, e) for (ll(i) = (ll)(s); (i) >= (ll)(e); (i)--)
#define iter(i, it) for (auto &(i) : (it))
template <typename T, typename U>
ostream &operator<<(ostream &s, const pair<T, U> m) {
cout << "(" << m.first << ", " << m.second << ")";
return s;
}
template <typename T, typename U>
ostream &operator<<(ostream &s, const map<T, U> m) {
ll c = 0;
cout << "{ ";
iter(i, m) cout << i << (c++ == m.size() - 1 ? " " : ", ");
cout << "}";
return s;
}
template <typename T> ostream &operator<<(ostream &s, const vector<T> &v) {
cout << "{ ";
rep(i, v.size()) cout << v[i] << (i == v.size() - 1 ? " " : ", ");
cout << "}";
return s;
}
template <typename T> ostream &operator<<(ostream &s, const list<T> &v) {
ll c = 0;
cout << "{ ";
iter(i, v) cout << i << (c++ == v.size() - 1 ? " " : ", ");
cout << "}";
return s;
}
ll po(ll x, ll y) {
ll ans = 1;
while (y) {
if (y % 2)
(ans *= x) %= MOD;
(x *= x) %= MOD;
y >>= 1;
}
return ans;
}
ll fact(ll x) {
ll ans = 1;
repi2(i, 2, x)(ans *= i) %= MOD;
return ans;
}
ll gyakugen(ll x) { return po(x, MOD - 2); }
map<ll, pair<ll, ll>> mae;
void prepare() {
repi(i, 2000) {
ll temp = fact(i);
ll gyaku = gyakugen(temp);
mae[i] = pair<ll, ll>{temp, gyaku};
}
}
ll comb(ll n, ll r) {
return mae[n].first * mae[r].second % MOD * mae[n - r].second % MOD;
}
int main(void) {
prepare();
ll N, K;
cin >> N >> K;
repi2(i, 1, K) cout << comb(N - K + 1, i) * comb(K - 1, i - 1) << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
#define MOD 1000000007LL
#define rep(i, n) for (ll(i) = 0LL; (i) < (ll)(n); (i)++)
#define rep2(i, s, e) for (ll(i) = (ll)(s); (i) < (ll)(e); (i)++)
#define repi(i, n) for (ll(i) = 0LL; (i) <= (ll)(n); (i)++)
#define repi2(i, s, e) for (ll(i) = (ll)(s); (i) <= (ll)(e); (i)++)
#define per(i, n) for (ll(i) = (ll)(n)-1LL; (i) >= 0LL; (i)--)
#define per2(i, s, e) for (ll(i) = (ll)(s)-1LL; (i) >= (ll)(e); (i)--)
#define peri(i, n) for (ll(i) = (ll)(n); (i) >= 0LL; (i)--)
#define peri2(i, s, e) for (ll(i) = (ll)(s); (i) >= (ll)(e); (i)--)
#define iter(i, it) for (auto &(i) : (it))
template <typename T, typename U>
ostream &operator<<(ostream &s, const pair<T, U> m) {
cout << "(" << m.first << ", " << m.second << ")";
return s;
}
template <typename T, typename U>
ostream &operator<<(ostream &s, const map<T, U> m) {
ll c = 0;
cout << "{ ";
iter(i, m) cout << i << (c++ == m.size() - 1 ? " " : ", ");
cout << "}";
return s;
}
template <typename T> ostream &operator<<(ostream &s, const vector<T> &v) {
cout << "{ ";
rep(i, v.size()) cout << v[i] << (i == v.size() - 1 ? " " : ", ");
cout << "}";
return s;
}
template <typename T> ostream &operator<<(ostream &s, const list<T> &v) {
ll c = 0;
cout << "{ ";
iter(i, v) cout << i << (c++ == v.size() - 1 ? " " : ", ");
cout << "}";
return s;
}
ll po(ll x, ll y) {
ll ans = 1;
while (y) {
if (y % 2)
(ans *= x) %= MOD;
(x *= x) %= MOD;
y >>= 1;
}
return ans;
}
ll fact(ll x) {
ll ans = 1;
repi2(i, 2, x)(ans *= i) %= MOD;
return ans;
}
ll gyakugen(ll x) { return po(x, MOD - 2); }
map<ll, pair<ll, ll>> mae;
void prepare() {
repi(i, 2000) {
ll temp = fact(i);
ll gyaku = gyakugen(temp);
mae[i] = pair<ll, ll>{temp, gyaku};
}
}
ll comb(ll n, ll r) {
return mae[n].first * mae[r].second % MOD * mae[n - r].second % MOD;
}
int main(void) {
prepare();
ll N, K;
cin >> N >> K;
repi2(i, 1, K) cout << comb(N - K + 1, i) * comb(K - 1, i - 1) % MOD << endl;
return 0;
}
| [
"expression.operation.binary.add"
] | 797,725 | 797,726 | u196953553 | cpp |
p02990 | #include <bits/stdc++.h>
#define int long long
#define ll long long
#define FLASH \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define rep(i, begin, end) \
for (__typeof(end) i = (begin) - ((begin) > (end)); \
i != (end) - ((begin) > (end)); \
i += 1 - 2 * ((begin) > \
(end))) // rep(i, 1, 5) --> {1,2,3,4} // rep(i, 5, 1) -->
// {4,3,2,1} // rep(it, end(v), begin(v)) --> *it
using namespace std;
const int MAX = 3000000;
const int P = 1000000007;
long long fac[MAX], finv[MAX], inv[MAX];
void COMBinit() {
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 % P;
inv[i] = P - inv[P % i] * (P / i) % P;
finv[i] = finv[i - 1] * inv[i] % P;
}
}
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] % P) % P;
}
signed main() {
int n, k;
cin >> n >> k;
COMBinit();
rep(i, 1, k + 1) cout << (COMB(n - k + 1, i) % P) * (COMB(k - 1, i - 1) % P)
<< endl;
return 0;
} | #include <bits/stdc++.h>
#define int long long
#define ll long long
#define FLASH \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define rep(i, begin, end) \
for (__typeof(end) i = (begin) - ((begin) > (end)); \
i != (end) - ((begin) > (end)); \
i += 1 - 2 * ((begin) > \
(end))) // rep(i, 1, 5) --> {1,2,3,4} // rep(i, 5, 1) -->
// {4,3,2,1} // rep(it, end(v), begin(v)) --> *it
using namespace std;
const int MAX = 3000000;
const int P = 1000000007;
long long fac[MAX], finv[MAX], inv[MAX];
void COMBinit() {
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 % P;
inv[i] = P - inv[P % i] * (P / i) % P;
finv[i] = finv[i - 1] * inv[i] % P;
}
}
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] % P) % P;
}
signed main() {
int n, k;
cin >> n >> k;
COMBinit();
rep(i, 1, k + 1) cout << ((COMB(n - k + 1, i) % P) *
(COMB(k - 1, i - 1) % P)) %
P
<< endl;
return 0;
} | [
"expression.operation.binary.add"
] | 797,727 | 797,728 | u494904817 | cpp |
p02990 | //#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
#define INF 100000000
#define rep(i, s, n) for (int i = (int)(s); i < (int)(n); i++)
#define repp(i, n, s) for (int i = (int)(n); i >= (int)(s); i--)
#define mp make_pair
ll mod = 1000000007;
ll mod2 = 998244353;
ll modpow(ll a, ll b) {
ll r = 1;
while (b) {
r = r * ((b % 2) ? a : 1) % mod;
a = a * a % mod;
b >>= 1;
}
return r;
}
ll comb(ll N_, ll C_) {
const int NUM_ = 400001;
static ll fact[NUM_ + 1], factr[NUM_ + 1], inv[NUM_ + 1];
if (fact[0] == 0) {
inv[1] = fact[0] = factr[0] = 1;
for (int i = 2; i <= NUM_; ++i)
inv[i] = inv[mod % i] * (mod - mod / i) % mod;
for (int i = 1; i <= NUM_; ++i)
fact[i] = fact[i - 1] * i % mod, factr[i] = factr[i - 1] * inv[i] % mod;
}
if (C_ < 0 || C_ > N_)
return 0;
return factr[C_] * fact[N_] % mod * factr[N_ - C_] % mod;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll n, k;
cin >> n >> k;
rep(i, 0, k) {
if (n - k < i)
cout << 0 << endl;
else {
cout << comb(n - k + 1, i + 1) * comb(k + i - 3, i) % mod << endl;
}
}
} | //#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
#define INF 100000000
#define rep(i, s, n) for (int i = (int)(s); i < (int)(n); i++)
#define repp(i, n, s) for (int i = (int)(n); i >= (int)(s); i--)
#define mp make_pair
ll mod = 1000000007;
ll mod2 = 998244353;
ll modpow(ll a, ll b) {
ll r = 1;
while (b) {
r = r * ((b % 2) ? a : 1) % mod;
a = a * a % mod;
b >>= 1;
}
return r;
}
ll comb(ll N_, ll C_) {
const int NUM_ = 400001;
static ll fact[NUM_ + 1], factr[NUM_ + 1], inv[NUM_ + 1];
if (fact[0] == 0) {
inv[1] = fact[0] = factr[0] = 1;
for (int i = 2; i <= NUM_; ++i)
inv[i] = inv[mod % i] * (mod - mod / i) % mod;
for (int i = 1; i <= NUM_; ++i)
fact[i] = fact[i - 1] * i % mod, factr[i] = factr[i - 1] * inv[i] % mod;
}
if (C_ < 0 || C_ > N_)
return 0;
return factr[C_] * fact[N_] % mod * factr[N_ - C_] % mod;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll n, k;
cin >> n >> k;
rep(i, 0, k) {
if (n - k < i)
cout << 0 << endl;
else {
cout << comb(n - k + 1, i + 1) * comb(k - 1, i) % mod << endl;
}
}
} | [
"expression.operation.binary.remove",
"literal.number.change",
"io.output.change"
] | 797,735 | 797,736 | u590825760 | cpp |
p02990 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define REP(i, m, n) for (int i = (int)(m); i < (int)(n); i++)
#define rep(i, n) REP(i, 0, n)
#define RREP(i, m, n) for (int i = (int)(m); i >= (int)(n); i--)
#define rrep(i, n) RREP(i, n - 1, 0)
#define all(v) v.begin(), v.end()
const int inf = 1e9 + 7;
const ll longinf = 1LL << 60;
const ll mod = 1e9 + 7;
#define MAX_N 2000005
ll inv[MAX_N], fac[MAX_N], finv[MAX_N];
void make() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX_N; i++) {
inv[i] = mod - inv[mod % i] * (mod / i) % mod;
fac[i] = fac[i - 1] * (ll)i % mod;
finv[i] = finv[i - 1] * inv[i] % mod;
}
}
ll perm(ll n, ll r) {
if (n < 0)
return 0;
else if (n < r)
return 0;
else
return (fac[n] * finv[n - r]) % mod;
}
ll comb(ll n, ll r) {
ll ans = 1;
ans = perm(n, r); // n * (n-1) * ... * (n-r+1)
ans = (ans * finv[r]) % mod; // フェルマーの小定理
return ans;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
make();
int N, K;
cin >> N >> K;
for (int i = 1; i <= K; i++) {
cout << comb(K - i + i - 1, i - 1) * comb(N - K - (i - 1) + i, i) << "\n";
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define REP(i, m, n) for (int i = (int)(m); i < (int)(n); i++)
#define rep(i, n) REP(i, 0, n)
#define RREP(i, m, n) for (int i = (int)(m); i >= (int)(n); i--)
#define rrep(i, n) RREP(i, n - 1, 0)
#define all(v) v.begin(), v.end()
const int inf = 1e9 + 7;
const ll longinf = 1LL << 60;
const ll mod = 1e9 + 7;
#define MAX_N 2000005
ll inv[MAX_N], fac[MAX_N], finv[MAX_N];
void make() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX_N; i++) {
inv[i] = mod - inv[mod % i] * (mod / i) % mod;
fac[i] = fac[i - 1] * (ll)i % mod;
finv[i] = finv[i - 1] * inv[i] % mod;
}
}
ll perm(ll n, ll r) {
if (n < 0)
return 0;
else if (n < r)
return 0;
else
return (fac[n] * finv[n - r]) % mod;
}
ll comb(ll n, ll r) {
ll ans = 1;
ans = perm(n, r); // n * (n-1) * ... * (n-r+1)
ans = (ans * finv[r]) % mod; // フェルマーの小定理
return ans;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
make();
int N, K;
cin >> N >> K;
for (int i = 1; i <= K; i++) {
cout << comb(K - i + i - 1, i - 1) * comb(N - K - (i - 1) + i, i) % mod
<< "\n";
}
return 0;
}
| [
"expression.operation.binary.add"
] | 797,737 | 797,738 | u137747137 | cpp |
p02990 | #include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <iostream>
#include <math.h>
#include <queue>
#include <sstream>
#include <stdexcept>
#include <stdio.h>
#include <string>
#include <vector>
// for(int i=0;i<n;i++)
#define cinf(n, x) \
for (int i = 0; i < n; i++) \
cin >> x[i];
#define pi pair<int, int>
using namespace std;
using ll = long long;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
const int MAX = 3000;
const int MOD = 1000000007;
ll fac[MAX], finv[MAX], inv[MAX];
void COMint() { //前処理
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; // n! * (k!)^-1 * ((n-k)!)^-1
}
int main() {
COMint();
int n, k;
cin >> n >> k;
for (int i = 1; i <= k; i++) {
cout << COM(k - 1, i - 1) * COM(n - k + 1, i) << endl;
}
return 0;
} | #include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <iostream>
#include <math.h>
#include <queue>
#include <sstream>
#include <stdexcept>
#include <stdio.h>
#include <string>
#include <vector>
// for(int i=0;i<n;i++)
#define cinf(n, x) \
for (int i = 0; i < n; i++) \
cin >> x[i];
#define pi pair<int, int>
using namespace std;
using ll = long long;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
const int MAX = 3000;
const int MOD = 1000000007;
ll fac[MAX], finv[MAX], inv[MAX];
void COMint() { //前処理
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; // n! * (k!)^-1 * ((n-k)!)^-1
}
int main() {
COMint();
int n, k;
cin >> n >> k;
for (int i = 1; i <= k; i++) {
cout << COM(k - 1, i - 1) * COM(n - k + 1, i) % 1000000007 << endl;
}
return 0;
} | [
"expression.operation.binary.add"
] | 797,741 | 797,742 | u139300044 | cpp |
p02990 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
using P = pair<int, int>;
const int mod = 1e9 + 7;
long long calc(long long a, long long b, long long p) {
if (b == 0)
return 1;
if (b % 2 == 0) {
long long d = calc(a, b / 2, p);
return (d * d) % p;
} else
return (a * calc(a, b - 1, p)) % p;
}
long long nCr(long long n, long long r) {
long long x = 1;
long long y = 1;
for (long long i = 1; i <= r; ++i) {
x *= (n - i + 1);
x %= mod;
y *= i;
y %= mod;
}
return x * calc(y, mod - 2, mod) % mod;
}
signed main(void) {
int n, k;
ll ans;
cin >> n >> k;
ans = 0;
for (int i = 1; i <= k; i++) {
ans = nCr(n - k + 1, i);
ans *= nCr(k - 1, i - 1);
cout << ans << endl;
}
return 0;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
using P = pair<int, int>;
const int mod = 1e9 + 7;
long long calc(long long a, long long b, long long p) {
if (b == 0)
return 1;
if (b % 2 == 0) {
long long d = calc(a, b / 2, p);
return (d * d) % p;
} else
return (a * calc(a, b - 1, p)) % p;
}
long long nCr(long long n, long long r) {
long long x = 1;
long long y = 1;
for (long long i = 1; i <= r; ++i) {
x *= (n - i + 1);
x %= mod;
y *= i;
y %= mod;
}
return x * calc(y, mod - 2, mod) % mod;
}
signed main(void) {
int n, k;
ll ans;
cin >> n >> k;
ans = 0;
for (int i = 1; i <= k; i++) {
ans = nCr(n - k + 1, i);
ans *= nCr(k - 1, i - 1);
ans %= mod;
cout << ans << endl;
}
return 0;
}
| [
"assignment.add"
] | 797,750 | 797,751 | u890331732 | cpp |
p02990 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using Pi = pair<int, int>;
using Pl = pair<ll, ll>;
using vint = vector<int>;
using vvint = vector<vint>;
using vvvint = vector<vvint>;
using vdouble = vector<double>;
using vvdouble = vector<vdouble>;
using vvvdouble = vector<vvdouble>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vvvll = vector<vvll>;
using uint = unsigned int;
using ull = unsigned long long;
template <typename T> using uset = unordered_set<T>;
template <typename T1, typename T2> using umap = unordered_map<T1, T2>;
constexpr int INF = (1 << 30) - 1;
constexpr ll LLINF = 1LL << 60;
constexpr int dy[] = {1, 0, -1, 0, 1, -1, -1, 1};
constexpr int dx[] = {0, 1, 0, -1, 1, 1, -1, -1};
constexpr char el = '\n';
constexpr int mod = 1000000007;
constexpr int mod2 = 998244353;
template <typename T> T gcd(T a, T b) { return (b ? gcd(b, a % b) : a); }
template <typename T> T lcm(T a, T b) { return (a / gcd(a, b) * b); }
template <typename T1, typename T2> inline bool chmin(T1 &a, T2 b) {
return (a > b && (a = b, true));
}
template <typename T1, typename T2> inline bool chmax(T1 &a, T2 b) {
return (a < b && (a = b, true));
}
template <typename T> vector<T> makeVector(size_t a, T b) {
return (vector<T>(a, b));
}
template <typename... Ts> auto makeVector(size_t a, Ts... ts) {
return (vector<decltype(makeVector(ts...))>(a, makeVector(ts...)));
}
template <typename T> bool isin(T y, T x, T h, T w) {
return (0 <= y && 0 <= x && y < h && x < w);
}
template <typename T> bool isin1(T y, T x, T h, T w) {
return (0 < y && 0 < x && y <= h && x <= w);
}
template <typename T> ostream &operator<<(ostream &os, vector<T> &v) {
os << v[0];
for (int i = 1; i < v.size(); i++)
os << " " << v[i];
return (os);
}
template <typename T> istream &operator>>(istream &is, vector<T> &v) {
for (auto &u : v)
is >> u;
return (is);
}
template <typename T1, typename T2>
istream &operator>>(istream &is, pair<T1, T2> &p) {
return (is >> p.first >> p.second);
}
constexpr int MAX = 3010000;
constexpr int MOD = 1000000007;
// Please set MAX and MOD!!========================================
ll fac[MAX], finv[MAX], inv[MAX];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
ll COM(int n, int k) {
if (n < k || n < 0 || k < 0)
return (0);
return (fac[n] * (finv[k] * finv[n - k] % MOD) % MOD);
}
ll PERM(int n, int k) {
if (n < k || n < 0 || k < 0)
return (0);
return (fac[n] * finv[n - k] % MOD);
}
void Main() {
int N, K;
cin >> N >> K;
auto dp = makeVector(K, K + 1, 0ll);
COMinit();
dp[0][1] = 1;
for (int i = 0; i < K; i++) {
for (int j = 0; j < K; j++) {
if (i + 1 < K)
(dp[i + 1][j + 1] += dp[i][j]) %= mod;
(dp[i][j + 1] += dp[i][j]) %= mod;
}
cout << dp[i][K] * COM(N - K + 1, i + 1) << el;
}
}
int main() {
cin.tie(0);
ios::sync_with_stdio(0);
cout << fixed << setprecision(20);
Main();
return (0);
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using Pi = pair<int, int>;
using Pl = pair<ll, ll>;
using vint = vector<int>;
using vvint = vector<vint>;
using vvvint = vector<vvint>;
using vdouble = vector<double>;
using vvdouble = vector<vdouble>;
using vvvdouble = vector<vvdouble>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vvvll = vector<vvll>;
using uint = unsigned int;
using ull = unsigned long long;
template <typename T> using uset = unordered_set<T>;
template <typename T1, typename T2> using umap = unordered_map<T1, T2>;
constexpr int INF = (1 << 30) - 1;
constexpr ll LLINF = 1LL << 60;
constexpr int dy[] = {1, 0, -1, 0, 1, -1, -1, 1};
constexpr int dx[] = {0, 1, 0, -1, 1, 1, -1, -1};
constexpr char el = '\n';
constexpr int mod = 1000000007;
constexpr int mod2 = 998244353;
template <typename T> T gcd(T a, T b) { return (b ? gcd(b, a % b) : a); }
template <typename T> T lcm(T a, T b) { return (a / gcd(a, b) * b); }
template <typename T1, typename T2> inline bool chmin(T1 &a, T2 b) {
return (a > b && (a = b, true));
}
template <typename T1, typename T2> inline bool chmax(T1 &a, T2 b) {
return (a < b && (a = b, true));
}
template <typename T> vector<T> makeVector(size_t a, T b) {
return (vector<T>(a, b));
}
template <typename... Ts> auto makeVector(size_t a, Ts... ts) {
return (vector<decltype(makeVector(ts...))>(a, makeVector(ts...)));
}
template <typename T> bool isin(T y, T x, T h, T w) {
return (0 <= y && 0 <= x && y < h && x < w);
}
template <typename T> bool isin1(T y, T x, T h, T w) {
return (0 < y && 0 < x && y <= h && x <= w);
}
template <typename T> ostream &operator<<(ostream &os, vector<T> &v) {
os << v[0];
for (int i = 1; i < v.size(); i++)
os << " " << v[i];
return (os);
}
template <typename T> istream &operator>>(istream &is, vector<T> &v) {
for (auto &u : v)
is >> u;
return (is);
}
template <typename T1, typename T2>
istream &operator>>(istream &is, pair<T1, T2> &p) {
return (is >> p.first >> p.second);
}
constexpr int MAX = 3010000;
constexpr int MOD = 1000000007;
// Please set MAX and MOD!!========================================
ll fac[MAX], finv[MAX], inv[MAX];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
ll COM(int n, int k) {
if (n < k || n < 0 || k < 0)
return (0);
return (fac[n] * (finv[k] * finv[n - k] % MOD) % MOD);
}
ll PERM(int n, int k) {
if (n < k || n < 0 || k < 0)
return (0);
return (fac[n] * finv[n - k] % MOD);
}
void Main() {
int N, K;
cin >> N >> K;
auto dp = makeVector(K, K + 1, 0ll);
COMinit();
dp[0][1] = 1;
for (int i = 0; i < K; i++) {
for (int j = 0; j < K; j++) {
if (i + 1 < K)
(dp[i + 1][j + 1] += dp[i][j]) %= mod;
(dp[i][j + 1] += dp[i][j]) %= mod;
}
cout << dp[i][K] * COM(N - K + 1, i + 1) % mod << el;
}
}
int main() {
cin.tie(0);
ios::sync_with_stdio(0);
cout << fixed << setprecision(20);
Main();
return (0);
}
| [
"expression.operation.binary.add"
] | 797,752 | 797,753 | u239239546 | cpp |
p02989 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> p(N);
for (int i = 0; i < N; i++) {
cin >> p[i];
}
if (N % 2 == 1) {
cout << 0 << endl;
return 0;
}
sort(p.begin(), p.end());
int halfu, halfl;
halfu = p[N / 2 - 1];
halfl = p[N / 2];
if (halfl != halfu) {
if (halfu == p[N / 2] && halfl == p[N / 2 + 1]) {
cout << halfl - halfu - 2 << endl;
} else if (halfu != p[N / 2] && halfl != p[N / 2 + 1]) {
cout << halfl - halfu << endl;
} else {
cout << halfl - halfu - 1 << endl;
}
return 0;
}
cout << 0 << endl;
return 0;
} |
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> p(N);
for (int i = 0; i < N; i++) {
cin >> p[i];
}
if (N % 2 == 1) {
cout << 0 << endl;
return 0;
}
sort(p.begin(), p.end());
int halfu, halfl;
halfu = p[N / 2 - 1];
halfl = p[N / 2];
if (halfl != halfu) {
if (halfu == p[N / 2] && halfl == p[N / 2 + 1]) {
cout << halfl - halfu - 2 << endl;
} else if (halfu != p[N / 2] && halfl != p[N / 2 + 1]) {
cout << halfl - halfu << endl;
} else {
cout << halfl - halfu << endl;
}
return 0;
}
cout << 0 << endl;
return 0;
} | [
"expression.operation.binary.remove"
] | 797,758 | 797,759 | u047450022 | cpp |
p02989 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> d(n);
for (int i = 0; i < n; i++)
cin >> d.at(i);
sort(d.begin(), d.end());
cout << d.at(n / 2 + 1) - d.at(n / 2) << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> d(n);
for (int i = 0; i < n; i++)
cin >> d.at(i);
sort(d.begin(), d.end());
cout << d.at(n / 2) - d.at((n / 2) - 1) << endl;
} | [
"expression.operation.binary.remove",
"call.arguments.change"
] | 797,762 | 797,763 | u704064492 | cpp |
p02989 | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int n = 0;
cin >> n;
vector<int> d(n);
for (int i = 0; i < n; i++) {
cin >> d.at(i);
}
sort(d.begin(), d.end());
cout << d.at(n / 2 + 1) - d.at(n / 2) << endl;
return 0;
}
| #include <algorithm>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int n = 0;
cin >> n;
vector<int> d(n);
for (int i = 0; i < n; i++) {
cin >> d.at(i);
}
sort(d.begin(), d.end());
cout << d.at(n / 2) - d.at(n / 2 - 1) << endl;
return 0;
}
| [
"expression.operation.binary.remove"
] | 797,772 | 797,773 | u324549724 | cpp |
p02989 | #include <iostream>
#include <string>
using namespace std;
void swap(int *x, int *y) {
int temp;
temp = *x;
*x = *y;
*y = temp;
}
int partition(int array[], int left, int right) {
int i, j, pivot;
i = left;
j = right + 1;
pivot = left;
do {
do {
i++;
} while (array[i] < array[pivot]);
do {
j--;
} while (array[pivot] < array[j]);
if (i < j) {
swap(&array[i], &array[j]);
}
} while (i < j);
swap(&array[pivot], &array[j]);
return j;
}
void quick_sort(int array[], int left, int right) {
int pivot;
if (left < right) {
pivot = partition(array, left, right);
quick_sort(array, left, pivot - 1);
quick_sort(array, pivot + 1, right);
}
}
int main(void) {
int number;
int middle_number;
int d[100000];
cin >> number;
for (int i = 0; i < number; ++i)
cin >> d[i];
quick_sort(d, 0, 0);
middle_number = number / 2;
cout << d[middle_number + 1] - d[middle_number] << endl;
} | #include <iostream>
#include <string>
using namespace std;
void swap(int *x, int *y) {
int temp;
temp = *x;
*x = *y;
*y = temp;
}
int partition(int array[], int left, int right) {
int i, j, pivot;
i = left;
j = right + 1;
pivot = left;
do {
do {
i++;
} while (array[i] < array[pivot]);
do {
j--;
} while (array[pivot] < array[j]);
if (i < j) {
swap(&array[i], &array[j]);
}
} while (i < j);
swap(&array[pivot], &array[j]);
return j;
}
void quick_sort(int array[], int left, int right) {
int pivot;
if (left < right) {
pivot = partition(array, left, right);
quick_sort(array, left, pivot - 1);
quick_sort(array, pivot + 1, right);
}
}
int main(void) {
int number;
int middle_number;
int d[100000];
cin >> number;
for (int i = 0; i < number; ++i)
cin >> d[i];
quick_sort(d, 0, number);
middle_number = number / 2;
cout << d[middle_number + 1] - d[middle_number] << endl;
} | [
"identifier.replace.add",
"literal.replace.remove",
"call.arguments.change"
] | 797,778 | 797,779 | u321719888 | cpp |
p02989 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a;
cin >> a;
vector<int> b(a);
for (int i = 0; i < a; i++)
cin >> b.at(i);
sort(b.begin(), b.end());
if (b.at(a / 2 - 1) == b.at(a / 2))
cout << 0;
else
cout << b.at(a / 2) - b.at(a / 2 - 1) + 1;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int a;
cin >> a;
vector<int> b(a);
for (int i = 0; i < a; i++)
cin >> b.at(i);
sort(b.begin(), b.end());
if (b.at(a / 2 - 1) == b.at(a / 2))
cout << 0;
else
cout << b.at(a / 2) - b.at(a / 2 - 1);
} | [
"expression.operation.binary.remove"
] | 797,790 | 797,791 | u341447450 | cpp |
p02989 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n + 5];
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
sort(a, a + (n + 1));
int g = n / 2;
int k = a[g + 1] - a[g];
cout << k << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n + 5] = {};
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
sort(a, a + (n + 1));
/*for(int i=1;i<=n;i++){
cout<<a[i]<<endl;
}*/
int g = n / 2;
int k = a[g + 1] - a[g];
cout << k << endl;
}
| [
"variable_declaration.value.change"
] | 797,793 | 797,794 | u758406624 | cpp |
p02989 | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> vec(N);
for (int i = 0; i < N; i++) {
cin >> vec.at(i);
}
sort(vec.begin(), vec.end());
int ans = 0;
for (int i = 0; i < vec.size(); i++) {
if (vec.at((N - 2) / 2) < i && i <= vec.at(N / 2)) {
ans++;
}
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> vec(N);
for (int i = 0; i < N; i++) {
cin >> vec.at(i);
}
sort(vec.begin(), vec.end());
int ans = 0;
for (int i = 0; i < vec.at(N - 1) + 1; i++) {
if (vec.at((N - 2) / 2) < i && i <= vec.at(N / 2)) {
ans++;
}
}
cout << ans << endl;
return 0;
}
| [
"call.function.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"misc.off_by_one"
] | 797,797 | 797,796 | u469953228 | cpp |
p02989 | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> vec(N);
for (int i = 0; i < N; i++) {
cin >> vec.at(i);
}
sort(vec.begin(), vec.end());
int ans = 0;
for (int i = 0; i < vec.at(N - 1); i++) {
if (vec.at((N - 2) / 2) < i && i <= vec.at((N + 2) / 2)) {
ans++;
}
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> vec(N);
for (int i = 0; i < N; i++) {
cin >> vec.at(i);
}
sort(vec.begin(), vec.end());
int ans = 0;
for (int i = 0; i < vec.at(N - 1) + 1; i++) {
if (vec.at((N - 2) / 2) < i && i <= vec.at(N / 2)) {
ans++;
}
}
cout << ans << endl;
return 0;
}
| [
"control_flow.loop.for.condition.change",
"misc.off_by_one",
"control_flow.branch.if.condition.change"
] | 797,798 | 797,796 | u469953228 | cpp |
p02989 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define MAX_N 100000
void solve() {}
int main() {
int n;
cin >> n;
int d[n];
REP(i, n)
cin >> d[i];
sort(d, d + n - 1);
if (n % 2)
cout << 0 << endl;
else {
cout << d[n / 2] - d[n / 2 - 1] << endl;
}
return 0;
} | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define MAX_N 100000
void solve() {}
int main() {
int n;
cin >> n;
int d[n];
REP(i, n)
cin >> d[i];
sort(d, d + n);
if (n % 2)
cout << 0 << endl;
else {
cout << d[n / 2] - d[n / 2 - 1] << endl;
}
return 0;
} | [
"expression.operation.binary.remove"
] | 797,799 | 797,800 | u754909749 | cpp |
p02989 | #include <algorithm>
#include <functional>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
//3<=n<=10^5\
//N guusuu
int n = 0;
cin >> n;
// int p[10^5];
vector<int> v;
for (int i = 0; i < n; i++) {
// cin >> p[i];
int tmp;
cin >> tmp;
v.push_back(tmp);
}
// for (int i = 0; i < n; i++){
// cout << v[i] << endl;
//}
std::sort(v.begin(), v.end(), std::greater<int>());
// for (int i = 0; i < n; i++){
// cout << v[i] << endl;
//}
// int count = 0;
// for (int i = 0; i < n; i++){
// ;
//}
cout << v[n / 2] - v[n / 2 - 1] << endl;
// system("pause");
return 0;
} | #include <algorithm>
#include <functional>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
//3<=n<=10^5\
//N guusuu
int n = 0;
cin >> n;
// int p[10^5];
vector<int> v;
for (int i = 0; i < n; i++) {
// cin >> p[i];
int tmp;
cin >> tmp;
v.push_back(tmp);
}
// for (int i = 0; i < n; i++){
// cout << v[i] << endl;
//}
std::sort(v.begin(), v.end(), std::greater<int>());
// for (int i = 0; i < n; i++){
// cout << v[i] << endl;
//}
// int count = 0;
// for (int i = 0; i < n; i++){
// ;
//}
cout << v[(n / 2) - 1] - v[n / 2] << endl;
// system("pause");
return 0;
} | [
"expression.operation.binary.remove"
] | 797,803 | 797,804 | u913604515 | cpp |
p02989 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n;
vector<int> vec(n);
for (int i = 0; i < n; i++) {
cin >> vec.at(i);
}
sort(vec.begin(), vec.end());
int a = vec.at(n / 2 - 1);
int b = vec.at(n / 2);
cout << b - a << endl;
} | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> vec(n);
for (int i = 0; i < n; i++) {
cin >> vec.at(i);
}
sort(vec.begin(), vec.end());
int a = vec.at(n / 2 - 1);
int b = vec.at(n / 2);
cout << b - a << endl;
} | [] | 797,807 | 797,808 | u656568465 | cpp |
p02990 | #include <iostream>
#include <vector>
using namespace std;
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int mod = 1000000007;
struct mint {
ll x; // typedef long long ll;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
mint operator-() const { return mint(-x); }
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const {
mint res(*this);
return res += a;
}
mint operator-(const mint a) const {
mint res(*this);
return res -= a;
}
mint operator*(const mint a) const {
mint res(*this);
return res *= a;
}
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
// for prime mod
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint a) { return (*this) *= a.inv(); }
mint operator/(const mint a) const {
mint res(*this);
return res /= a;
}
};
struct combination {
vector<mint> fact, ifact;
combination(int n) : fact(n + 1), ifact(n + 1) {
assert(n < mod);
fact[0] = 1;
for (int i = 1; i <= n; ++i)
fact[i] = fact[i - 1] * i;
ifact[n] = fact[n].inv();
for (int i = n; i >= 1; --i)
ifact[i - 1] = ifact[i] * i;
}
mint operator()(int n, int k) {
if (k < 0 || k > n)
return 0;
return fact[n] * ifact[k] * ifact[n - k];
}
};
int main() {
int N, K;
cin >> N >> K;
combination c(3000); // 二項係数ライブラリを初期化
// 求める
for (int k = 1; k <= K; ++k)
// blue * red
cout << c(K - 1, k - 1).x * c(N - K + 1, k).x << endl;
} | #include <iostream>
#include <vector>
using namespace std;
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int mod = 1000000007;
struct mint {
ll x; // typedef long long ll;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
mint operator-() const { return mint(-x); }
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const {
mint res(*this);
return res += a;
}
mint operator-(const mint a) const {
mint res(*this);
return res -= a;
}
mint operator*(const mint a) const {
mint res(*this);
return res *= a;
}
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
// for prime mod
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint a) { return (*this) *= a.inv(); }
mint operator/(const mint a) const {
mint res(*this);
return res /= a;
}
};
struct combination {
vector<mint> fact, ifact;
combination(int n) : fact(n + 1), ifact(n + 1) {
assert(n < mod);
fact[0] = 1;
for (int i = 1; i <= n; ++i)
fact[i] = fact[i - 1] * i;
ifact[n] = fact[n].inv();
for (int i = n; i >= 1; --i)
ifact[i - 1] = ifact[i] * i;
}
mint operator()(int n, int k) {
if (k < 0 || k > n)
return 0;
return fact[n] * ifact[k] * ifact[n - k];
}
};
int main() {
int N, K;
cin >> N >> K;
combination c(3000); // 二項係数ライブラリを初期化
// 求める
for (int k = 1; k <= K; ++k)
// blue * red
cout << c(K - 1, k - 1).x * c(N - K + 1, k).x % mod << endl;
} | [
"expression.operation.binary.add"
] | 797,816 | 797,817 | u620269708 | cpp |
p02990 | #include <bits/stdc++.h>
#define fi first
#define se second
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rrep(i, n) for (int i = 1; i <= (n); ++i)
#define drep(i, n) for (int i = (n)-1; i >= 0; --i)
#define srep(i, s, t) for (int i = s; i < t; ++i)
#define rng(a) a.begin(), a.end()
#define maxs(x, y) (x = max(x, y))
#define mins(x, y) (x = min(x, y))
#define pb push_back
#define sz(x) (int)(x).size()
#define PQ(T) priority_queue<T, v(T), greater<T>>
#define bn(x) ((1 << x) - 1)
#define v(T) vector<T>
#define vv(T) v(v(T))
using namespace std;
typedef long long int ll;
typedef unsigned uint;
typedef unsigned long long ull;
typedef pair<int, int> P;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<P> vp;
const double eps = 1e-10;
const ll LINF = 1001002003004005006ll;
const int INF = 1001001001;
const int mod = 1000000007;
struct mint {
ll x;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
mint operator-() const { return mint(-x); }
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) % mod;
return *this;
}
mint operator+(const mint a) const {
mint res(*this);
return res += a;
}
mint operator-(const mint a) const {
mint res(*this);
return res -= a;
}
mint operator*(const mint a) const {
mint res(*this);
return res *= a;
}
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
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;
}
};
mint c[4005][4005];
void init() {
c[0][0] = 1;
rep(i, 4002) {
rep(j, i + 1) {
c[i + 1][j] += c[i][j];
c[i + 1][j + 1] += c[i][j];
}
}
}
mint comb(int n, int k) { return c[n][k]; }
mint f2(int n, int k) { return comb(n + k - 1, k - 1); }
mint f(int n, int k) {
if (n < k)
return 0;
if (n == 0 && k == 0)
return 1;
if (k < 1)
return 0;
return f2(n - k, k);
}
int main() {
init();
int k, n;
cin >> n >> k;
mint b;
mint r;
rrep(i, k) {
b = f(k, i);
r = f(n - k, i - 1) + f(n - k, i) * 2 + f(n - k, i + 1);
mint ans = b * r;
cout << ans.x << endl;
}
return 0;
}
| #include <bits/stdc++.h>
#define fi first
#define se second
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rrep(i, n) for (int i = 1; i <= (n); ++i)
#define drep(i, n) for (int i = (n)-1; i >= 0; --i)
#define srep(i, s, t) for (int i = s; i < t; ++i)
#define rng(a) a.begin(), a.end()
#define maxs(x, y) (x = max(x, y))
#define mins(x, y) (x = min(x, y))
#define pb push_back
#define sz(x) (int)(x).size()
#define PQ(T) priority_queue<T, v(T), greater<T>>
#define bn(x) ((1 << x) - 1)
#define v(T) vector<T>
#define vv(T) v(v(T))
using namespace std;
typedef long long int ll;
typedef unsigned uint;
typedef unsigned long long ull;
typedef pair<int, int> P;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<P> vp;
const double eps = 1e-10;
const ll LINF = 1001002003004005006ll;
const int INF = 1001001001;
const int mod = 1000000007;
struct mint {
ll x;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
mint operator-() const { return mint(-x); }
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const {
mint res(*this);
return res += a;
}
mint operator-(const mint a) const {
mint res(*this);
return res -= a;
}
mint operator*(const mint a) const {
mint res(*this);
return res *= a;
}
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
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;
}
};
mint c[4005][4005];
void init() {
c[0][0] = 1;
rep(i, 4001) {
rep(j, i + 1) {
c[i + 1][j] += c[i][j];
c[i + 1][j + 1] += c[i][j];
}
}
}
mint comb(int n, int k) { return c[n][k]; }
mint f2(int n, int k) { return comb(n + k - 1, k - 1); }
mint f(int n, int k) {
if (n < k)
return 0;
if (n == 0 && k == 0)
return 1;
if (k < 1)
return 0;
return f2(n - k, k);
}
int main() {
init();
int k, n;
cin >> n >> k;
mint b;
mint r;
rrep(i, k) {
b = f(k, i);
r = f(n - k, i - 1) + f(n - k, i) * 2 + f(n - k, i + 1);
mint ans = b * r;
cout << ans.x << endl;
}
return 0;
}
| [
"assignment.compound.arithmetic.replace.add",
"expression.operator.arithmetic.replace.remove",
"expression.operation.binary.change",
"literal.number.change",
"call.arguments.change"
] | 797,818 | 797,819 | u577393547 | cpp |
p02990 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <numeric>
#include <string>
#include <vector>
using namespace std;
const int MAX = 3000;
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(void) {
int N, K;
cin >> N >> K;
COMinit();
for (int i = 1; i <= K; i++) {
cout << COM(N - K + 1, i) * COM(K - 1, i - 1) << endl;
}
return 0;
} | #include <algorithm>
#include <cmath>
#include <iostream>
#include <numeric>
#include <string>
#include <vector>
using namespace std;
const int MAX = 3000;
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(void) {
int N, K;
cin >> N >> K;
COMinit();
for (int i = 1; i <= K; i++) {
cout << (COM(N - K + 1, i) * COM(K - 1, i - 1)) % MOD << endl;
}
return 0;
} | [
"expression.operation.binary.add"
] | 797,821 | 797,822 | u976833038 | cpp |
p02990 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <numeric>
#include <string>
#include <vector>
using namespace std;
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(void) {
int N, K;
cin >> N >> K;
COMinit();
for (int i = 1; i <= K; i++) {
cout << COM(N - K + 1, i) * COM(K - 1, i - 1) << endl;
}
return 0;
} | #include <algorithm>
#include <cmath>
#include <iostream>
#include <numeric>
#include <string>
#include <vector>
using namespace std;
const int MAX = 3000;
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(void) {
int N, K;
cin >> N >> K;
COMinit();
for (int i = 1; i <= K; i++) {
cout << (COM(N - K + 1, i) * COM(K - 1, i - 1)) % MOD << endl;
}
return 0;
} | [
"literal.number.change",
"variable_declaration.value.change"
] | 797,823 | 797,822 | u976833038 | cpp |
p02990 |
// D - Blue and Red Balls
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
// const int INF = 2147483647;
// const ll INF = 9223372036854775807;
const int MOD = 1e9 + 7;
class Comb {
private:
int MOD;
long long *fac;
long long *finv;
long long *inv;
public:
// 事前にテーブルを作成
Comb(int MAX, int MOD) {
this->MOD = MOD;
fac = new long long[MAX + 1];
finv = new long long[MAX + 1];
inv = new long long[MAX + 1];
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;
}
}
~Comb() { delete[] fac, finv, inv; }
// 二項係数計算
long long calc(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, K;
cin >> N >> K;
Comb comb = Comb(N, MOD);
for (int i = 1; i <= K; i++) {
// 赤の並べ方
int red = comb.calc(N - K + 1, i);
// 青の並べ方
int blue = comb.calc(K - 1, i - 1);
cout << (red * blue) % MOD << endl;
}
return 0;
} |
// D - Blue and Red Balls
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
// const int INF = 2147483647;
// const ll INF = 9223372036854775807;
const int MOD = 1e9 + 7;
class Comb {
private:
int MOD;
long long *fac;
long long *finv;
long long *inv;
public:
// 事前にテーブルを作成
Comb(int MAX, int MOD) {
this->MOD = MOD;
fac = new long long[MAX + 1];
finv = new long long[MAX + 1];
inv = new long long[MAX + 1];
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;
}
}
~Comb() { delete[] fac, finv, inv; }
// 二項係数計算
long long calc(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, K;
cin >> N >> K;
Comb comb = Comb(N, MOD);
for (int i = 1; i <= K; i++) {
// 赤の並べ方
// (N - (K + i - 1))個を(i + 1)ヶ所に分配（0も可）
ll red = comb.calc(N - K + 1, i);
// 青の並べ方
// K個をiヶ所に分配（0は不可）
ll blue = comb.calc(K - 1, i - 1);
cout << (red * blue) % MOD << endl;
}
return 0;
} | [
"variable_declaration.type.change"
] | 797,824 | 797,825 | u790272146 | cpp |
p02990 | #include <bits/stdc++.h>
using namespace std;
#define int long long
struct Fast {
Fast() {
std::cin.tie(0);
ios::sync_with_stdio(false);
}
} fast;
/* short */
#define pb push_back
#define mp make_pair
#define fst first
#define snd second
#define F first
#define S second
#define ALL(v) begin(v), end(v)
/* REPmacro */
#define FOR(i, s, n) for (int i = (s); i < (n); i++)
#define RFOR(i, s, n) for (int i = (s); i >= (n); i--)
#define rep(i, n) FOR(i, 0, n)
#define repi(i, n) FOR(i, 1, n + 1)
#define rrep(i, n) RFOR(i, n - 1, 0)
#define rrepi(i, n) RFOR(i, n, 1)
/* alias */
using ll = long long;
using ull = unsigned long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vvvi = vector<vvi>;
using vd = vector<double>;
using vvd = vector<vd>;
using vvvd = vector<vvd>;
using pii = pair<int, int>;
using vpii = vector<pii>;
using vvpii = vector<pii>;
using mii = map<int, int>;
using vs = vector<string>;
using vb = vector<bool>;
template <typename T> using PQ = priority_queue<T>;
template <typename T> using minPQ = priority_queue<T, vector<T>, greater<T>>;
/* iostream */
template <typename T> istream &operator>>(istream &is, vector<T> &vec) {
for (auto &v : vec)
is >> v;
return is;
}
template <typename T> istream &operator>>(istream &is, pair<T, T> &p) {
int a, b;
is >> a >> b;
p = mp(a, b);
return is;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec) {
os << "[";
for (auto v : vec)
os << v << ",";
os << "]";
return os;
}
template <typename T> ostream &operator<<(ostream &os, const deque<T> &vec) {
os << "deq[";
for (auto v : vec)
os << v << ",";
os << "]";
return os;
}
template <typename T> ostream &operator<<(ostream &os, const set<T> &vec) {
os << "{";
for (auto v : vec)
os << v << ",";
os << "}";
return os;
}
template <typename T> ostream &operator<<(ostream &os, const multiset<T> &vec) {
os << "{";
for (auto v : vec)
os << v << ",";
os << "}";
return os;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &pa) {
os << "(" << pa.first << "," << pa.second << ")";
return os;
}
template <typename TK, typename TV>
ostream &operator<<(ostream &os, const map<TK, TV> &mp) {
os << "{";
for (auto v : mp)
os << v.first << "=>" << v.second << ",";
os << "}";
return os;
}
template <typename T> istream &operator>>(istream &is, complex<T> &c) {
T x, y;
is >> x >> y;
c = complex<T>(x, y);
return is;
}
/* input */
#define _overload(_1, _2, _3, _4, _5, _6, name, ...) name
#define _g1(a) \
int a; \
cin >> a;
#define _g2(a, b) \
int a, b; \
cin >> a >> b;
#define _g3(a, b, c) \
int a, b, c; \
cin >> a >> b >> c;
#define _g4(a, b, c, d) \
int a, b, c, d; \
cin >> a >> b >> c >> d;
#define _g5(a, b, c, d, e) \
int a, b, c, d, e; \
cin >> a >> b >> c >> d >> e;
#define _g6(a, b, c, d, e, f) \
int a, b, c, d, e, f; \
cin >> a >> b >> c >> d >> e >> f;
#define in(...) \
_overload(__VA_ARGS__, _g6, _g5, _g4, _g3, _g2, _g1)(__VA_ARGS__)
/* debug */
#define _pp_overload(_1, _2, _3, _4, _5, _6, name, ...) name
#define _p1(a) cerr << #a "=" << (a) << endl;
#define _p2(a, b) cerr << #a "=" << (a) << "," #b "=" << (b) << endl;
#define _p3(a, b, c) \
cerr << #a "=" << (a) << "," #b "=" << (b) << "," #c "=" << (c) << endl;
#define _p4(a, b, c, d) \
cerr << #a "=" << (a) << "," #b "=" << (b) << "," #c "=" << (c) \
<< "," #d "=" << (d) << endl;
#define _p5(a, b, c, d, e) \
cerr << #a "=" << (a) << "," #b "=" << (b) << "," #c "=" << (c) \
<< "," #d "=" << (d) << "," #e "=" << (e) << endl;
#define _p6(a, b, c, d, e, f) \
cerr << #a "=" << (a) << "," #b "=" << (b) << "," #c "=" << (c) \
<< "," #d "=" << (d) << "," #e "=" << (e) << "," #f "=" << (f) << endl;
#define pp(...) \
_pp_overload(__VA_ARGS__, _p6, _p5, _p4, _p3, _p2, _p1)(__VA_ARGS__)
/* const */
// const int INF = 1001001001;
const ll INF = 1001001001001001001ll;
const int MOD = 1e9 + 7;
/* func */
#define UNIQUE(v) v.erase(unique(ALL(v)), v.end());
#define TIME system("date +%M:%S.%N")
inline bool inside(int y, int x, int H, int W) {
return y >= 0 && x >= 0 && y < H && x < W;
}
inline bool odd(int x) { return x % 2 == 1; }
inline bool even(int x) { return x % 2 == 0; }
inline int sum(vi a) { return accumulate(ALL(a), 0); }
inline void yn(bool ans) { cout << (ans ? "Yes" : "No") << endl; }
inline void YN(bool ans) { cout << (ans ? "YES" : "NO") << endl; }
template <typename T> inline bool chmin(T &a, const T &b) {
if (a > b)
a = b;
return a > b;
}
template <typename T> inline bool chmax(T &a, const T &b) {
if (a < b)
a = b;
return a < b;
}
template <class T> T gcd(const T &a, const T &b) {
return a < b ? gcd(b, a) : b ? gcd(b, a % b) : a;
}
template <class T> T lcm(const T &a, const T &b) { return a / gcd(a, b) * b; }
template <class T> T div_ceil(const T &a, const T &b) {
return (a + b - 1) / b;
}
template <class T> bool by_snd(const T &a, const T &b) { return a.snd < b.snd; }
inline void print_and_exit(int x) {
cout << x << endl;
exit(0);
}
const int dx[] = {0, 1, 0, -1, 1, -1, 1, -1},
dy[] = {1, 0, -1, 0, 1, -1, -1, 1};
// https://gist.github.com/ttsuki/f3bb54694c90fa9031a7
// Mod な n! nCr nPr nHr を求める。
// 初期化に O(n) sizeof(ll) * n * 3 のメモリを要する 1000万(10^7)で256MBギリ
// 初期化してしまえば、あとは O(1)
struct ModCombination {
// modFact[n] = MODを法とした n!
vector<ll> modFact{};
void initModFact(int N, ll MOD) {
modFact.clear();
modFact.reserve(N + 1);
ll r = 1;
modFact.push_back(r);
FOR(i, 1, N + 1) {
r = r * i % MOD;
modFact.push_back(r);
}
}
// modInv[n] = MODを法とした n の逆元
vector<ll> modInv{};
void initModInv(int N, ll MOD) {
modInv.clear();
modInv.reserve(N + 1);
modInv.push_back(0);
modInv.push_back(1);
FOR(i, 2, N + 1) {
modInv.push_back(modInv[MOD % i] * (MOD - MOD / i) % MOD);
}
}
// modFactInv[n] = MODを法とした n! の逆元
vector<ll> modFactInv{};
void initModFactInv(int N, ll MOD) {
modFactInv.clear();
modFactInv.reserve(N + 1);
ll r = 1;
modFactInv.push_back(r);
FOR(i, 1, N + 1) {
r = r * modInv[i] % MOD;
modFactInv.push_back(r);
}
}
int N;
ll MOD;
ModCombination(int N, ll MOD) : N(N), MOD(MOD) {
initModFact(N + 1, MOD);
initModInv(N + 1, MOD);
initModFactInv(N + 1, MOD);
}
ll Fact(int n) { return modFact[n]; }
ll Permutation(int n, int k) {
return k >= 0 && n >= k ? modFact[n] * modFactInv[n - k] % MOD : 0;
}
ll Combination(int n, int k) {
return k >= 0 && n >= k ? Permutation(n, k) * modFactInv[k] % MOD : 0;
}
ll HomogeneousProduct(int n, int k) {
return n == 0 && k == 0 ? 1 : Combination(n + k - 1, k);
}
};
signed main() {
in(n, k);
ModCombination m(3000, MOD);
repi(i, k) {
int ans = m.Combination(n - k + 1, i) * m.Combination(k - 1, i - 1);
cout << ans << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
#define int long long
struct Fast {
Fast() {
std::cin.tie(0);
ios::sync_with_stdio(false);
}
} fast;
/* short */
#define pb push_back
#define mp make_pair
#define fst first
#define snd second
#define F first
#define S second
#define ALL(v) begin(v), end(v)
/* REPmacro */
#define FOR(i, s, n) for (int i = (s); i < (n); i++)
#define RFOR(i, s, n) for (int i = (s); i >= (n); i--)
#define rep(i, n) FOR(i, 0, n)
#define repi(i, n) FOR(i, 1, n + 1)
#define rrep(i, n) RFOR(i, n - 1, 0)
#define rrepi(i, n) RFOR(i, n, 1)
/* alias */
using ll = long long;
using ull = unsigned long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vvvi = vector<vvi>;
using vd = vector<double>;
using vvd = vector<vd>;
using vvvd = vector<vvd>;
using pii = pair<int, int>;
using vpii = vector<pii>;
using vvpii = vector<pii>;
using mii = map<int, int>;
using vs = vector<string>;
using vb = vector<bool>;
template <typename T> using PQ = priority_queue<T>;
template <typename T> using minPQ = priority_queue<T, vector<T>, greater<T>>;
/* iostream */
template <typename T> istream &operator>>(istream &is, vector<T> &vec) {
for (auto &v : vec)
is >> v;
return is;
}
template <typename T> istream &operator>>(istream &is, pair<T, T> &p) {
int a, b;
is >> a >> b;
p = mp(a, b);
return is;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec) {
os << "[";
for (auto v : vec)
os << v << ",";
os << "]";
return os;
}
template <typename T> ostream &operator<<(ostream &os, const deque<T> &vec) {
os << "deq[";
for (auto v : vec)
os << v << ",";
os << "]";
return os;
}
template <typename T> ostream &operator<<(ostream &os, const set<T> &vec) {
os << "{";
for (auto v : vec)
os << v << ",";
os << "}";
return os;
}
template <typename T> ostream &operator<<(ostream &os, const multiset<T> &vec) {
os << "{";
for (auto v : vec)
os << v << ",";
os << "}";
return os;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &pa) {
os << "(" << pa.first << "," << pa.second << ")";
return os;
}
template <typename TK, typename TV>
ostream &operator<<(ostream &os, const map<TK, TV> &mp) {
os << "{";
for (auto v : mp)
os << v.first << "=>" << v.second << ",";
os << "}";
return os;
}
template <typename T> istream &operator>>(istream &is, complex<T> &c) {
T x, y;
is >> x >> y;
c = complex<T>(x, y);
return is;
}
/* input */
#define _overload(_1, _2, _3, _4, _5, _6, name, ...) name
#define _g1(a) \
int a; \
cin >> a;
#define _g2(a, b) \
int a, b; \
cin >> a >> b;
#define _g3(a, b, c) \
int a, b, c; \
cin >> a >> b >> c;
#define _g4(a, b, c, d) \
int a, b, c, d; \
cin >> a >> b >> c >> d;
#define _g5(a, b, c, d, e) \
int a, b, c, d, e; \
cin >> a >> b >> c >> d >> e;
#define _g6(a, b, c, d, e, f) \
int a, b, c, d, e, f; \
cin >> a >> b >> c >> d >> e >> f;
#define in(...) \
_overload(__VA_ARGS__, _g6, _g5, _g4, _g3, _g2, _g1)(__VA_ARGS__)
/* debug */
#define _pp_overload(_1, _2, _3, _4, _5, _6, name, ...) name
#define _p1(a) cerr << #a "=" << (a) << endl;
#define _p2(a, b) cerr << #a "=" << (a) << "," #b "=" << (b) << endl;
#define _p3(a, b, c) \
cerr << #a "=" << (a) << "," #b "=" << (b) << "," #c "=" << (c) << endl;
#define _p4(a, b, c, d) \
cerr << #a "=" << (a) << "," #b "=" << (b) << "," #c "=" << (c) \
<< "," #d "=" << (d) << endl;
#define _p5(a, b, c, d, e) \
cerr << #a "=" << (a) << "," #b "=" << (b) << "," #c "=" << (c) \
<< "," #d "=" << (d) << "," #e "=" << (e) << endl;
#define _p6(a, b, c, d, e, f) \
cerr << #a "=" << (a) << "," #b "=" << (b) << "," #c "=" << (c) \
<< "," #d "=" << (d) << "," #e "=" << (e) << "," #f "=" << (f) << endl;
#define pp(...) \
_pp_overload(__VA_ARGS__, _p6, _p5, _p4, _p3, _p2, _p1)(__VA_ARGS__)
/* const */
// const int INF = 1001001001;
const ll INF = 1001001001001001001ll;
const int MOD = 1e9 + 7;
/* func */
#define UNIQUE(v) v.erase(unique(ALL(v)), v.end());
#define TIME system("date +%M:%S.%N")
inline bool inside(int y, int x, int H, int W) {
return y >= 0 && x >= 0 && y < H && x < W;
}
inline bool odd(int x) { return x % 2 == 1; }
inline bool even(int x) { return x % 2 == 0; }
inline int sum(vi a) { return accumulate(ALL(a), 0); }
inline void yn(bool ans) { cout << (ans ? "Yes" : "No") << endl; }
inline void YN(bool ans) { cout << (ans ? "YES" : "NO") << endl; }
template <typename T> inline bool chmin(T &a, const T &b) {
if (a > b)
a = b;
return a > b;
}
template <typename T> inline bool chmax(T &a, const T &b) {
if (a < b)
a = b;
return a < b;
}
template <class T> T gcd(const T &a, const T &b) {
return a < b ? gcd(b, a) : b ? gcd(b, a % b) : a;
}
template <class T> T lcm(const T &a, const T &b) { return a / gcd(a, b) * b; }
template <class T> T div_ceil(const T &a, const T &b) {
return (a + b - 1) / b;
}
template <class T> bool by_snd(const T &a, const T &b) { return a.snd < b.snd; }
inline void print_and_exit(int x) {
cout << x << endl;
exit(0);
}
const int dx[] = {0, 1, 0, -1, 1, -1, 1, -1},
dy[] = {1, 0, -1, 0, 1, -1, -1, 1};
// https://gist.github.com/ttsuki/f3bb54694c90fa9031a7
// Mod な n! nCr nPr nHr を求める。
// 初期化に O(n) sizeof(ll) * n * 3 のメモリを要する 1000万(10^7)で256MBギリ
// 初期化してしまえば、あとは O(1)
struct ModCombination {
// modFact[n] = MODを法とした n!
vector<ll> modFact{};
void initModFact(int N, ll MOD) {
modFact.clear();
modFact.reserve(N + 1);
ll r = 1;
modFact.push_back(r);
FOR(i, 1, N + 1) {
r = r * i % MOD;
modFact.push_back(r);
}
}
// modInv[n] = MODを法とした n の逆元
vector<ll> modInv{};
void initModInv(int N, ll MOD) {
modInv.clear();
modInv.reserve(N + 1);
modInv.push_back(0);
modInv.push_back(1);
FOR(i, 2, N + 1) {
modInv.push_back(modInv[MOD % i] * (MOD - MOD / i) % MOD);
}
}
// modFactInv[n] = MODを法とした n! の逆元
vector<ll> modFactInv{};
void initModFactInv(int N, ll MOD) {
modFactInv.clear();
modFactInv.reserve(N + 1);
ll r = 1;
modFactInv.push_back(r);
FOR(i, 1, N + 1) {
r = r * modInv[i] % MOD;
modFactInv.push_back(r);
}
}
int N;
ll MOD;
ModCombination(int N, ll MOD) : N(N), MOD(MOD) {
initModFact(N + 1, MOD);
initModInv(N + 1, MOD);
initModFactInv(N + 1, MOD);
}
ll Fact(int n) { return modFact[n]; }
ll Permutation(int n, int k) {
return k >= 0 && n >= k ? modFact[n] * modFactInv[n - k] % MOD : 0;
}
ll Combination(int n, int k) {
return k >= 0 && n >= k ? Permutation(n, k) * modFactInv[k] % MOD : 0;
}
ll HomogeneousProduct(int n, int k) {
return n == 0 && k == 0 ? 1 : Combination(n + k - 1, k);
}
};
signed main() {
in(n, k);
ModCombination m(3000, MOD);
repi(i, k) {
int ans = m.Combination(n - k + 1, i) * m.Combination(k - 1, i - 1) % MOD;
cout << ans << endl;
}
}
| [
"assignment.change"
] | 797,828 | 797,829 | u106964380 | cpp |
p02990 | // g++ -std=c++14 test.cpp -o test.out
#include <algorithm>
#include <cassert>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <map>
#include <math.h>
#include <queue>
#include <stdlib.h>
#include <string.h>
#include <utility>
#include <vector>
using namespace std;
// https://github.com/atcoder-live/library/blob/master/mint.cpp
#define ll long long int
const ll mod = 1000000007ll;
struct mint {
ll x; // typedef long long ll;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const {
mint res(*this);
return res += a;
}
mint operator-(const mint a) const {
mint res(*this);
return res -= a;
}
mint operator*(const mint a) const {
mint res(*this);
return res *= a;
}
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
// for prime mod
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint a) { return (*this) *= a.inv(); }
mint operator/(const mint a) const {
mint res(*this);
return res /= a;
}
};
struct combination {
vector<mint> fact, ifact; // factに階乗を計算、ifactはその各々に対する逆元
combination(ll n) : fact(n + 1), ifact(n + 1) {
assert(n < mod);
fact[0] = 1;
for (ll i = 1; i <= n; ++i)
fact[i] = fact[i - 1] * i;
ifact[n] = fact[n].inv();
for (ll i = n; i >= 1; --i)
ifact[i - 1] = ifact[i] * i;
}
mint operator()(ll n, ll k) {
if (k < 0 || k > n)
return 0;
return fact[n] * ifact[k] * ifact[n - k];
}
};
int N, K;
vector<ll> numcase;
void solve() {
combination blue(K - 1); // struct combinationのコンストラクタを呼び出す
combination red(N - K + 1); // struct combinationのコンストラクタを呼び出す
for (int i = 1; i <= K; i++) {
ll cases = red(N - K + 1, i).x * blue(K - 1, i - 1).x;
numcase.push_back(cases);
}
}
int main() {
cin >> N >> K;
solve();
for (int i = 0; i < numcase.size(); i++)
cout << numcase[i] << endl;
return 0;
}
| // g++ -std=c++14 test.cpp -o test.out
#include <algorithm>
#include <cassert>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <map>
#include <math.h>
#include <queue>
#include <stdlib.h>
#include <string.h>
#include <utility>
#include <vector>
using namespace std;
// https://github.com/atcoder-live/library/blob/master/mint.cpp
#define ll long long int
const ll mod = 1000000007ll;
struct mint {
ll x; // typedef long long ll;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const {
mint res(*this);
return res += a;
}
mint operator-(const mint a) const {
mint res(*this);
return res -= a;
}
mint operator*(const mint a) const {
mint res(*this);
return res *= a;
}
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
// for prime mod
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint a) { return (*this) *= a.inv(); }
mint operator/(const mint a) const {
mint res(*this);
return res /= a;
}
};
struct combination {
vector<mint> fact, ifact; // factに階乗を計算、ifactはその各々に対する逆元
combination(ll n) : fact(n + 1), ifact(n + 1) {
assert(n < mod);
fact[0] = 1;
for (ll i = 1; i <= n; ++i)
fact[i] = fact[i - 1] * i;
ifact[n] = fact[n].inv();
for (ll i = n; i >= 1; --i)
ifact[i - 1] = ifact[i] * i;
}
mint operator()(ll n, ll k) {
if (k < 0 || k > n)
return 0;
return fact[n] * ifact[k] * ifact[n - k];
}
};
int N, K;
vector<ll> numcase;
void solve() {
combination blue(K - 1); // struct combinationのコンストラクタを呼び出す
combination red(N - K + 1); // struct combinationのコンストラクタを呼び出す
for (int i = 1; i <= K; i++) {
ll cases = red(N - K + 1, i).x * blue(K - 1, i - 1).x;
numcase.push_back(cases % mod);
}
}
int main() {
cin >> N >> K;
solve();
for (int i = 0; i < numcase.size(); i++)
cout << numcase[i] << endl;
return 0;
}
| [
"expression.operation.binary.add"
] | 797,834 | 797,835 | u302000346 | cpp |
p02990 | #include <bits/stdc++.h>
using namespace std;
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, K;
cin >> N >> K;
COMinit();
for (int i = 1; i <= K; i++) {
if (i - 1 <= N - K) {
cout << COM(K - 1, i - 1) * COM(N - K + 1, i) << endl;
} else {
cout << 0 << endl;
}
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
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, K;
cin >> N >> K;
COMinit();
for (int i = 1; i <= K; i++) {
if (i - 1 <= N - K) {
cout << (COM(K - 1, i - 1) * COM(N - K + 1, i)) % MOD << endl;
} else {
cout << 0 << endl;
}
}
return 0;
} | [
"expression.operation.binary.add"
] | 797,836 | 797,837 | u239087789 | cpp |
p02990 | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define double long double
#define fo(a, b) for (int a = 0; a < b; a++)
#define Sort(a) sort(a.begin(), a.end())
#define rev(a) reverse(a.begin(), a.end())
#define fi first
#define se second
#define sz size()
#define bgn begin()
#define en end()
#define pb push_back
#define pp() pop_back()
#define V vector
#define P pair
#define yuko(a) setprecision(a)
#define uni(a) a.erase(unique(a.begin(), a.end()), a.end())
#define Q queue
#define pri priority_queue
#define Pri priority_queue<int, vector<int>, greater<int>>
#define PriP \
priority_queue<P<int, int>, vector<P<int, int>>, greater<P<int, int>>>
#define ff first.first
#define fs first.second
#define sf second.first
#define ss second.second
#define all(a) (a).begin(), (a).end()
#define elif else if
int low(V<int> a, int b) {
decltype(a)::iterator c = lower_bound(a.begin(), a.end(), b);
int d = c - a.bgn;
return d;
}
int upp(V<int> a, int b) {
decltype(a)::iterator c = upper_bound(a.begin(), a.end(), b);
int d = c - a.bgn;
return d;
}
template <class T> void cou(vector<vector<T>> a) {
int b = a.size();
int c = a[0].size();
fo(i, b) {
fo(j, c) {
cout << a[i][j];
if (j == c - 1)
cout << endl;
else
cout << ' ';
}
}
}
int wari(int a, int b) {
if (a % b == 0)
return a / b;
else
return a / b + 1;
}
int keta(int a) {
double b = a;
b = log10(b);
int c = b;
return c + 1;
}
int souwa(int a) { return a * (a + 1) / 2; }
int gcm(int a, int b) {
if (a % b == 0)
return b;
return gcm(b, a % b);
}
bool prime(int a) {
if (a < 2)
return false;
else if (a == 2)
return true;
else if (a % 2 == 0)
return false;
for (int i = 3; i <= sqrt(a) + 1; i += 2) {
if (a % i == 0)
return false;
}
return true;
}
struct Union {
vector<int> par;
Union(int a) { par = vector<int>(a, -1); }
int find(int a) {
if (par[a] < 0)
return a;
else
return par[a] = find(par[a]);
}
bool same(int a, int b) { return find(a) == find(b); }
int Size(int a) { return -par[find(a)]; }
void unite(int a, int b) {
a = find(a);
b = find(b);
if (a == b)
return;
if (Size(b) > Size(a))
swap<int>(a, b);
par[a] += par[b];
par[b] = a;
}
};
int ketas(int a) {
string b = to_string(a);
int c = 0;
fo(i, keta(a)) { c += b[i] - '0'; }
return c;
}
bool fe(int a, int b) {
a %= 10;
b %= 10;
if (a == 0)
a = 10;
if (b == 0)
b = 10;
if (a > b)
return true;
else
return false;
}
int INF = 1000000007;
struct edge {
int s, t, d;
};
V<int> mojisyu(string a) {
V<int> b(26, 0);
fo(i, a.sz) { b[a[i] - 'a']++; }
return b;
}
int wa2(int a) {
if (a % 2 == 1)
return a / 2;
return a / 2 - 1;
}
/*signed main(){
int a,b,c;
cin>>a>>b>>c;
V<V<edge>> d(a);
fo(i,b){
edge e;
cin>>e.s>>e.t>>e.d;
d[e.s].pb(e);
}
V<int> e(a,INF);
e[c]=0;
priority_queue<P<int,int>,V<P<int,int>>,greater<P<int,int>>> f;
f.push({0,c});
int h=INF;
while(!f.empty()){
P<int,int> g;
g=f.top();
f.pop();
int v = g.second, i = g.first;
for(edge l : d[v]){
if(e[l.t] > i + l.d){
e[l.t] = i + l.d;
f.push({i+l.d , l.t});
}
}
}
fo(i,a){
if(e[i]==INF)
cout<<"INF"<<endl;
else
cout<<e[i]<<endl;
}
}
?*/
int nCr(int n, int r) {
int a = 1;
r = min(r, n - r);
for (int i = n; i > n - r; i--) {
a *= i;
a /= n - i + 1;
}
return a;
}
/*void sea(int x,int y){
if(x<0||a<=x||y<0||b<=y||c[x][y]=='#')
return;
if(d[x][y])
return;
d[x][y]++;
sea(x+1,y);
sea(x-1,y);
sea(x,y+1);
sea(x,y-1);
}*/
int kaijou(int a) {
int b = 1;
fo(i, a) b *= i + 1;
return b;
}
int nPr(int a, int b) {
if (a < b)
return 0;
if (b == 0)
return 1;
int c = 1;
for (int i = a; i > a - b; i--) {
c *= i;
c %= INF;
}
return c;
}
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);
}
u %= m;
if (u < 0)
u += m;
return u;
}
int lcm(int a, int b) {
int c = modinv(gcm(a, b), INF);
return ((a * c) % INF) * (b % INF) % INF;
}
int MOD = INF;
int fac[1000010], finv[1000010], inv[1000010];
// テーブルを作る前処理
//先にCOMinit()で前処理をする
// ABC145D
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < 1000010; 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;
}
bool naka(int a, int b, V<V<char>> c) {
return (a >= 0 && b >= 0 && a < c.sz && b < c[0].sz);
}
V<P<int, int>> mawari8 = {{0, -1}, {0, 1}, {1, 0}, {-1, 0},
{-1, -1}, {1, 1}, {1, -1}, {-1, -1}};
int inf = 1000000000000000007;
/*
signed main(){
int a,b,c;
cin>>a>>b>>c;
V<V<edge>> d(a);
fo(i,b){
edge e;
cin>>e.s>>e.t>>e.d;
d[e.s].pb(e);
}
V<int> e(a,INF);
e[c]=0;
priority_queue<P<int,int>,V<P<int,int>>,greater<P<int,int>>> f;
f.push({0,c});
int h=INF;
while(!f.empty()){
P<int,int> g;
g=f.top();
f.pop();
int v = g.second, i = g.first;
for(edge l : d[v]){
if(e[l.t] > i + l.d){
e[l.t] = i + l.d;
f.push({i+l.d , l.t});
}
}
}
fo(i,a){
if(e[i]==INF)
cout<<"INF"<<endl;
else
cout<<e[i]<<endl;
}
}*/
V<P<int, int>> mawari4 = {{0, -1}, {0, 1}, {1, 0}, {-1, 0}};
//最短経路の表 a(全部INFで初期化)
//縦横 x,y
//迷路 f
//スタートsx,sy
//ゴールgx,gy
//文字はgから使おうね
/*int bfs_haba(){
Q<P<int,int>> b;
a[sx][sy]=0;
b.push({sx,sy});
while(!b.empty()){
P<int,int> c=b.front();
b.pop();
if(c.fi==gx&&c.se==gy){
break;
}
fo(i,4){
int d=c.fi+mawari4[i].fi;
int e=c.se+mawari4[i].se;
if(0<=d&&0<=e&&d<x&&e<y&&f[d][e]!='#'&&a[d][e]==INF){
b.push({d,e});
a[d][e]=1+a[c.fi][c.se];
}
}
}
return a[gx][gy];
}*/
V<int> onajibubun(string a) {
V<int> b(a.sz);
for (int i = 1, j = 0; i < a.sz; i++) {
if (i + b[i - j] < j + b[j])
b[i] = b[i - j];
else {
int c = max<int>(0, j + b[j] - i);
while (i + c < a.sz && a[c] == a[i + c])
c++;
b[i] = c;
j = i;
}
}
b[0] = a.sz;
return b;
}
signed main() {
int a, b;
cin >> a >> b;
V<int> c(b);
COMinit();
fo(i, b) { c[i] = COM(a - b + 1, i + 1); }
fo(i, b) {
c[i] *= COM(b - 1, i);
c[i] %= INF;
}
fo(i, a) { cout << c[i] << endl; }
} | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define double long double
#define fo(a, b) for (int a = 0; a < b; a++)
#define Sort(a) sort(a.begin(), a.end())
#define rev(a) reverse(a.begin(), a.end())
#define fi first
#define se second
#define sz size()
#define bgn begin()
#define en end()
#define pb push_back
#define pp() pop_back()
#define V vector
#define P pair
#define yuko(a) setprecision(a)
#define uni(a) a.erase(unique(a.begin(), a.end()), a.end())
#define Q queue
#define pri priority_queue
#define Pri priority_queue<int, vector<int>, greater<int>>
#define PriP \
priority_queue<P<int, int>, vector<P<int, int>>, greater<P<int, int>>>
#define ff first.first
#define fs first.second
#define sf second.first
#define ss second.second
#define all(a) (a).begin(), (a).end()
#define elif else if
int low(V<int> a, int b) {
decltype(a)::iterator c = lower_bound(a.begin(), a.end(), b);
int d = c - a.bgn;
return d;
}
int upp(V<int> a, int b) {
decltype(a)::iterator c = upper_bound(a.begin(), a.end(), b);
int d = c - a.bgn;
return d;
}
template <class T> void cou(vector<vector<T>> a) {
int b = a.size();
int c = a[0].size();
fo(i, b) {
fo(j, c) {
cout << a[i][j];
if (j == c - 1)
cout << endl;
else
cout << ' ';
}
}
}
int wari(int a, int b) {
if (a % b == 0)
return a / b;
else
return a / b + 1;
}
int keta(int a) {
double b = a;
b = log10(b);
int c = b;
return c + 1;
}
int souwa(int a) { return a * (a + 1) / 2; }
int gcm(int a, int b) {
if (a % b == 0)
return b;
return gcm(b, a % b);
}
bool prime(int a) {
if (a < 2)
return false;
else if (a == 2)
return true;
else if (a % 2 == 0)
return false;
for (int i = 3; i <= sqrt(a) + 1; i += 2) {
if (a % i == 0)
return false;
}
return true;
}
struct Union {
vector<int> par;
Union(int a) { par = vector<int>(a, -1); }
int find(int a) {
if (par[a] < 0)
return a;
else
return par[a] = find(par[a]);
}
bool same(int a, int b) { return find(a) == find(b); }
int Size(int a) { return -par[find(a)]; }
void unite(int a, int b) {
a = find(a);
b = find(b);
if (a == b)
return;
if (Size(b) > Size(a))
swap<int>(a, b);
par[a] += par[b];
par[b] = a;
}
};
int ketas(int a) {
string b = to_string(a);
int c = 0;
fo(i, keta(a)) { c += b[i] - '0'; }
return c;
}
bool fe(int a, int b) {
a %= 10;
b %= 10;
if (a == 0)
a = 10;
if (b == 0)
b = 10;
if (a > b)
return true;
else
return false;
}
int INF = 1000000007;
struct edge {
int s, t, d;
};
V<int> mojisyu(string a) {
V<int> b(26, 0);
fo(i, a.sz) { b[a[i] - 'a']++; }
return b;
}
int wa2(int a) {
if (a % 2 == 1)
return a / 2;
return a / 2 - 1;
}
/*signed main(){
int a,b,c;
cin>>a>>b>>c;
V<V<edge>> d(a);
fo(i,b){
edge e;
cin>>e.s>>e.t>>e.d;
d[e.s].pb(e);
}
V<int> e(a,INF);
e[c]=0;
priority_queue<P<int,int>,V<P<int,int>>,greater<P<int,int>>> f;
f.push({0,c});
int h=INF;
while(!f.empty()){
P<int,int> g;
g=f.top();
f.pop();
int v = g.second, i = g.first;
for(edge l : d[v]){
if(e[l.t] > i + l.d){
e[l.t] = i + l.d;
f.push({i+l.d , l.t});
}
}
}
fo(i,a){
if(e[i]==INF)
cout<<"INF"<<endl;
else
cout<<e[i]<<endl;
}
}
?*/
int nCr(int n, int r) {
int a = 1;
r = min(r, n - r);
for (int i = n; i > n - r; i--) {
a *= i;
a /= n - i + 1;
}
return a;
}
/*void sea(int x,int y){
if(x<0||a<=x||y<0||b<=y||c[x][y]=='#')
return;
if(d[x][y])
return;
d[x][y]++;
sea(x+1,y);
sea(x-1,y);
sea(x,y+1);
sea(x,y-1);
}*/
int kaijou(int a) {
int b = 1;
fo(i, a) b *= i + 1;
return b;
}
int nPr(int a, int b) {
if (a < b)
return 0;
if (b == 0)
return 1;
int c = 1;
for (int i = a; i > a - b; i--) {
c *= i;
c %= INF;
}
return c;
}
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);
}
u %= m;
if (u < 0)
u += m;
return u;
}
int lcm(int a, int b) {
int c = modinv(gcm(a, b), INF);
return ((a * c) % INF) * (b % INF) % INF;
}
int MOD = INF;
int fac[1000010], finv[1000010], inv[1000010];
// テーブルを作る前処理
//先にCOMinit()で前処理をする
// ABC145D
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < 1000010; 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;
}
bool naka(int a, int b, V<V<char>> c) {
return (a >= 0 && b >= 0 && a < c.sz && b < c[0].sz);
}
V<P<int, int>> mawari8 = {{0, -1}, {0, 1}, {1, 0}, {-1, 0},
{-1, -1}, {1, 1}, {1, -1}, {-1, -1}};
int inf = 1000000000000000007;
/*
signed main(){
int a,b,c;
cin>>a>>b>>c;
V<V<edge>> d(a);
fo(i,b){
edge e;
cin>>e.s>>e.t>>e.d;
d[e.s].pb(e);
}
V<int> e(a,INF);
e[c]=0;
priority_queue<P<int,int>,V<P<int,int>>,greater<P<int,int>>> f;
f.push({0,c});
int h=INF;
while(!f.empty()){
P<int,int> g;
g=f.top();
f.pop();
int v = g.second, i = g.first;
for(edge l : d[v]){
if(e[l.t] > i + l.d){
e[l.t] = i + l.d;
f.push({i+l.d , l.t});
}
}
}
fo(i,a){
if(e[i]==INF)
cout<<"INF"<<endl;
else
cout<<e[i]<<endl;
}
}*/
V<P<int, int>> mawari4 = {{0, -1}, {0, 1}, {1, 0}, {-1, 0}};
//最短経路の表 a(全部INFで初期化)
//縦横 x,y
//迷路 f
//スタートsx,sy
//ゴールgx,gy
//文字はgから使おうね
/*int bfs_haba(){
Q<P<int,int>> b;
a[sx][sy]=0;
b.push({sx,sy});
while(!b.empty()){
P<int,int> c=b.front();
b.pop();
if(c.fi==gx&&c.se==gy){
break;
}
fo(i,4){
int d=c.fi+mawari4[i].fi;
int e=c.se+mawari4[i].se;
if(0<=d&&0<=e&&d<x&&e<y&&f[d][e]!='#'&&a[d][e]==INF){
b.push({d,e});
a[d][e]=1+a[c.fi][c.se];
}
}
}
return a[gx][gy];
}*/
V<int> onajibubun(string a) {
V<int> b(a.sz);
for (int i = 1, j = 0; i < a.sz; i++) {
if (i + b[i - j] < j + b[j])
b[i] = b[i - j];
else {
int c = max<int>(0, j + b[j] - i);
while (i + c < a.sz && a[c] == a[i + c])
c++;
b[i] = c;
j = i;
}
}
b[0] = a.sz;
return b;
}
signed main() {
int a, b;
cin >> a >> b;
V<int> c(b);
COMinit();
fo(i, b) { c[i] = COM(a - b + 1, i + 1); }
fo(i, b) {
c[i] *= COM(b - 1, i);
c[i] %= INF;
}
fo(i, b) { cout << c[i] << endl; }
} | [] | 797,842 | 797,843 | u322177979 | cpp |
p02990 | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define double long double
#define fo(a, b) for (int a = 0; a < b; a++)
#define Sort(a) sort(a.begin(), a.end())
#define rev(a) reverse(a.begin(), a.end())
#define fi first
#define se second
#define sz size()
#define bgn begin()
#define en end()
#define pb push_back
#define pp() pop_back()
#define V vector
#define P pair
#define yuko(a) setprecision(a)
#define uni(a) a.erase(unique(a.begin(), a.end()), a.end())
#define Q queue
#define pri priority_queue
#define Pri priority_queue<int, vector<int>, greater<int>>
#define PriP \
priority_queue<P<int, int>, vector<P<int, int>>, greater<P<int, int>>>
#define ff first.first
#define fs first.second
#define sf second.first
#define ss second.second
#define all(a) (a).begin(), (a).end()
#define elif else if
int low(V<int> a, int b) {
decltype(a)::iterator c = lower_bound(a.begin(), a.end(), b);
int d = c - a.bgn;
return d;
}
int upp(V<int> a, int b) {
decltype(a)::iterator c = upper_bound(a.begin(), a.end(), b);
int d = c - a.bgn;
return d;
}
template <class T> void cou(vector<vector<T>> a) {
int b = a.size();
int c = a[0].size();
fo(i, b) {
fo(j, c) {
cout << a[i][j];
if (j == c - 1)
cout << endl;
else
cout << ' ';
}
}
}
int wari(int a, int b) {
if (a % b == 0)
return a / b;
else
return a / b + 1;
}
int keta(int a) {
double b = a;
b = log10(b);
int c = b;
return c + 1;
}
int souwa(int a) { return a * (a + 1) / 2; }
int gcm(int a, int b) {
if (a % b == 0)
return b;
return gcm(b, a % b);
}
bool prime(int a) {
if (a < 2)
return false;
else if (a == 2)
return true;
else if (a % 2 == 0)
return false;
for (int i = 3; i <= sqrt(a) + 1; i += 2) {
if (a % i == 0)
return false;
}
return true;
}
struct Union {
vector<int> par;
Union(int a) { par = vector<int>(a, -1); }
int find(int a) {
if (par[a] < 0)
return a;
else
return par[a] = find(par[a]);
}
bool same(int a, int b) { return find(a) == find(b); }
int Size(int a) { return -par[find(a)]; }
void unite(int a, int b) {
a = find(a);
b = find(b);
if (a == b)
return;
if (Size(b) > Size(a))
swap<int>(a, b);
par[a] += par[b];
par[b] = a;
}
};
int ketas(int a) {
string b = to_string(a);
int c = 0;
fo(i, keta(a)) { c += b[i] - '0'; }
return c;
}
bool fe(int a, int b) {
a %= 10;
b %= 10;
if (a == 0)
a = 10;
if (b == 0)
b = 10;
if (a > b)
return true;
else
return false;
}
int INF = 1000000007;
struct edge {
int s, t, d;
};
V<int> mojisyu(string a) {
V<int> b(26, 0);
fo(i, a.sz) { b[a[i] - 'a']++; }
return b;
}
int wa2(int a) {
if (a % 2 == 1)
return a / 2;
return a / 2 - 1;
}
/*signed main(){
int a,b,c;
cin>>a>>b>>c;
V<V<edge>> d(a);
fo(i,b){
edge e;
cin>>e.s>>e.t>>e.d;
d[e.s].pb(e);
}
V<int> e(a,INF);
e[c]=0;
priority_queue<P<int,int>,V<P<int,int>>,greater<P<int,int>>> f;
f.push({0,c});
int h=INF;
while(!f.empty()){
P<int,int> g;
g=f.top();
f.pop();
int v = g.second, i = g.first;
for(edge l : d[v]){
if(e[l.t] > i + l.d){
e[l.t] = i + l.d;
f.push({i+l.d , l.t});
}
}
}
fo(i,a){
if(e[i]==INF)
cout<<"INF"<<endl;
else
cout<<e[i]<<endl;
}
}
?*/
int nCr(int n, int r) {
int a = 1;
r = min(r, n - r);
for (int i = n; i > n - r; i--) {
a *= i;
a /= n - i + 1;
}
return a;
}
/*void sea(int x,int y){
if(x<0||a<=x||y<0||b<=y||c[x][y]=='#')
return;
if(d[x][y])
return;
d[x][y]++;
sea(x+1,y);
sea(x-1,y);
sea(x,y+1);
sea(x,y-1);
}*/
int kaijou(int a) {
int b = 1;
fo(i, a) b *= i + 1;
return b;
}
int nPr(int a, int b) {
if (a < b)
return 0;
if (b == 0)
return 1;
int c = 1;
for (int i = a; i > a - b; i--) {
c *= i;
c %= INF;
}
return c;
}
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);
}
u %= m;
if (u < 0)
u += m;
return u;
}
int lcm(int a, int b) {
int c = modinv(gcm(a, b), INF);
return ((a * c) % INF) * (b % INF) % INF;
}
int MOD = INF;
int fac[1000010], finv[1000010], inv[1000010];
// テーブルを作る前処理
//先にCOMinit()で前処理をする
// ABC145D
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < 1000010; 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;
}
bool naka(int a, int b, V<V<char>> c) {
return (a >= 0 && b >= 0 && a < c.sz && b < c[0].sz);
}
V<P<int, int>> mawari8 = {{0, -1}, {0, 1}, {1, 0}, {-1, 0},
{-1, -1}, {1, 1}, {1, -1}, {-1, -1}};
int inf = 1000000000000000007;
/*
signed main(){
int a,b,c;
cin>>a>>b>>c;
V<V<edge>> d(a);
fo(i,b){
edge e;
cin>>e.s>>e.t>>e.d;
d[e.s].pb(e);
}
V<int> e(a,INF);
e[c]=0;
priority_queue<P<int,int>,V<P<int,int>>,greater<P<int,int>>> f;
f.push({0,c});
int h=INF;
while(!f.empty()){
P<int,int> g;
g=f.top();
f.pop();
int v = g.second, i = g.first;
for(edge l : d[v]){
if(e[l.t] > i + l.d){
e[l.t] = i + l.d;
f.push({i+l.d , l.t});
}
}
}
fo(i,a){
if(e[i]==INF)
cout<<"INF"<<endl;
else
cout<<e[i]<<endl;
}
}*/
V<P<int, int>> mawari4 = {{0, -1}, {0, 1}, {1, 0}, {-1, 0}};
//最短経路の表 a(全部INFで初期化)
//縦横 x,y
//迷路 f
//スタートsx,sy
//ゴールgx,gy
//文字はgから使おうね
/*int bfs_haba(){
Q<P<int,int>> b;
a[sx][sy]=0;
b.push({sx,sy});
while(!b.empty()){
P<int,int> c=b.front();
b.pop();
if(c.fi==gx&&c.se==gy){
break;
}
fo(i,4){
int d=c.fi+mawari4[i].fi;
int e=c.se+mawari4[i].se;
if(0<=d&&0<=e&&d<x&&e<y&&f[d][e]!='#'&&a[d][e]==INF){
b.push({d,e});
a[d][e]=1+a[c.fi][c.se];
}
}
}
return a[gx][gy];
}*/
V<int> onajibubun(string a) {
V<int> b(a.sz);
for (int i = 1, j = 0; i < a.sz; i++) {
if (i + b[i - j] < j + b[j])
b[i] = b[i - j];
else {
int c = max<int>(0, j + b[j] - i);
while (i + c < a.sz && a[c] == a[i + c])
c++;
b[i] = c;
j = i;
}
}
b[0] = a.sz;
return b;
}
signed main() {
int a, b;
cin >> a >> b;
V<int> c(a);
COMinit();
fo(i, a) { c[i] = COM(a - b + 1, i + 1); }
fo(i, a) {
c[i] *= COM(b - 1, i);
c[i] %= INF;
}
fo(i, a) { cout << c[i] << endl; }
} | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define double long double
#define fo(a, b) for (int a = 0; a < b; a++)
#define Sort(a) sort(a.begin(), a.end())
#define rev(a) reverse(a.begin(), a.end())
#define fi first
#define se second
#define sz size()
#define bgn begin()
#define en end()
#define pb push_back
#define pp() pop_back()
#define V vector
#define P pair
#define yuko(a) setprecision(a)
#define uni(a) a.erase(unique(a.begin(), a.end()), a.end())
#define Q queue
#define pri priority_queue
#define Pri priority_queue<int, vector<int>, greater<int>>
#define PriP \
priority_queue<P<int, int>, vector<P<int, int>>, greater<P<int, int>>>
#define ff first.first
#define fs first.second
#define sf second.first
#define ss second.second
#define all(a) (a).begin(), (a).end()
#define elif else if
int low(V<int> a, int b) {
decltype(a)::iterator c = lower_bound(a.begin(), a.end(), b);
int d = c - a.bgn;
return d;
}
int upp(V<int> a, int b) {
decltype(a)::iterator c = upper_bound(a.begin(), a.end(), b);
int d = c - a.bgn;
return d;
}
template <class T> void cou(vector<vector<T>> a) {
int b = a.size();
int c = a[0].size();
fo(i, b) {
fo(j, c) {
cout << a[i][j];
if (j == c - 1)
cout << endl;
else
cout << ' ';
}
}
}
int wari(int a, int b) {
if (a % b == 0)
return a / b;
else
return a / b + 1;
}
int keta(int a) {
double b = a;
b = log10(b);
int c = b;
return c + 1;
}
int souwa(int a) { return a * (a + 1) / 2; }
int gcm(int a, int b) {
if (a % b == 0)
return b;
return gcm(b, a % b);
}
bool prime(int a) {
if (a < 2)
return false;
else if (a == 2)
return true;
else if (a % 2 == 0)
return false;
for (int i = 3; i <= sqrt(a) + 1; i += 2) {
if (a % i == 0)
return false;
}
return true;
}
struct Union {
vector<int> par;
Union(int a) { par = vector<int>(a, -1); }
int find(int a) {
if (par[a] < 0)
return a;
else
return par[a] = find(par[a]);
}
bool same(int a, int b) { return find(a) == find(b); }
int Size(int a) { return -par[find(a)]; }
void unite(int a, int b) {
a = find(a);
b = find(b);
if (a == b)
return;
if (Size(b) > Size(a))
swap<int>(a, b);
par[a] += par[b];
par[b] = a;
}
};
int ketas(int a) {
string b = to_string(a);
int c = 0;
fo(i, keta(a)) { c += b[i] - '0'; }
return c;
}
bool fe(int a, int b) {
a %= 10;
b %= 10;
if (a == 0)
a = 10;
if (b == 0)
b = 10;
if (a > b)
return true;
else
return false;
}
int INF = 1000000007;
struct edge {
int s, t, d;
};
V<int> mojisyu(string a) {
V<int> b(26, 0);
fo(i, a.sz) { b[a[i] - 'a']++; }
return b;
}
int wa2(int a) {
if (a % 2 == 1)
return a / 2;
return a / 2 - 1;
}
/*signed main(){
int a,b,c;
cin>>a>>b>>c;
V<V<edge>> d(a);
fo(i,b){
edge e;
cin>>e.s>>e.t>>e.d;
d[e.s].pb(e);
}
V<int> e(a,INF);
e[c]=0;
priority_queue<P<int,int>,V<P<int,int>>,greater<P<int,int>>> f;
f.push({0,c});
int h=INF;
while(!f.empty()){
P<int,int> g;
g=f.top();
f.pop();
int v = g.second, i = g.first;
for(edge l : d[v]){
if(e[l.t] > i + l.d){
e[l.t] = i + l.d;
f.push({i+l.d , l.t});
}
}
}
fo(i,a){
if(e[i]==INF)
cout<<"INF"<<endl;
else
cout<<e[i]<<endl;
}
}
?*/
int nCr(int n, int r) {
int a = 1;
r = min(r, n - r);
for (int i = n; i > n - r; i--) {
a *= i;
a /= n - i + 1;
}
return a;
}
/*void sea(int x,int y){
if(x<0||a<=x||y<0||b<=y||c[x][y]=='#')
return;
if(d[x][y])
return;
d[x][y]++;
sea(x+1,y);
sea(x-1,y);
sea(x,y+1);
sea(x,y-1);
}*/
int kaijou(int a) {
int b = 1;
fo(i, a) b *= i + 1;
return b;
}
int nPr(int a, int b) {
if (a < b)
return 0;
if (b == 0)
return 1;
int c = 1;
for (int i = a; i > a - b; i--) {
c *= i;
c %= INF;
}
return c;
}
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);
}
u %= m;
if (u < 0)
u += m;
return u;
}
int lcm(int a, int b) {
int c = modinv(gcm(a, b), INF);
return ((a * c) % INF) * (b % INF) % INF;
}
int MOD = INF;
int fac[1000010], finv[1000010], inv[1000010];
// テーブルを作る前処理
//先にCOMinit()で前処理をする
// ABC145D
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < 1000010; 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;
}
bool naka(int a, int b, V<V<char>> c) {
return (a >= 0 && b >= 0 && a < c.sz && b < c[0].sz);
}
V<P<int, int>> mawari8 = {{0, -1}, {0, 1}, {1, 0}, {-1, 0},
{-1, -1}, {1, 1}, {1, -1}, {-1, -1}};
int inf = 1000000000000000007;
/*
signed main(){
int a,b,c;
cin>>a>>b>>c;
V<V<edge>> d(a);
fo(i,b){
edge e;
cin>>e.s>>e.t>>e.d;
d[e.s].pb(e);
}
V<int> e(a,INF);
e[c]=0;
priority_queue<P<int,int>,V<P<int,int>>,greater<P<int,int>>> f;
f.push({0,c});
int h=INF;
while(!f.empty()){
P<int,int> g;
g=f.top();
f.pop();
int v = g.second, i = g.first;
for(edge l : d[v]){
if(e[l.t] > i + l.d){
e[l.t] = i + l.d;
f.push({i+l.d , l.t});
}
}
}
fo(i,a){
if(e[i]==INF)
cout<<"INF"<<endl;
else
cout<<e[i]<<endl;
}
}*/
V<P<int, int>> mawari4 = {{0, -1}, {0, 1}, {1, 0}, {-1, 0}};
//最短経路の表 a(全部INFで初期化)
//縦横 x,y
//迷路 f
//スタートsx,sy
//ゴールgx,gy
//文字はgから使おうね
/*int bfs_haba(){
Q<P<int,int>> b;
a[sx][sy]=0;
b.push({sx,sy});
while(!b.empty()){
P<int,int> c=b.front();
b.pop();
if(c.fi==gx&&c.se==gy){
break;
}
fo(i,4){
int d=c.fi+mawari4[i].fi;
int e=c.se+mawari4[i].se;
if(0<=d&&0<=e&&d<x&&e<y&&f[d][e]!='#'&&a[d][e]==INF){
b.push({d,e});
a[d][e]=1+a[c.fi][c.se];
}
}
}
return a[gx][gy];
}*/
V<int> onajibubun(string a) {
V<int> b(a.sz);
for (int i = 1, j = 0; i < a.sz; i++) {
if (i + b[i - j] < j + b[j])
b[i] = b[i - j];
else {
int c = max<int>(0, j + b[j] - i);
while (i + c < a.sz && a[c] == a[i + c])
c++;
b[i] = c;
j = i;
}
}
b[0] = a.sz;
return b;
}
signed main() {
int a, b;
cin >> a >> b;
V<int> c(b);
COMinit();
fo(i, b) { c[i] = COM(a - b + 1, i + 1); }
fo(i, b) {
c[i] *= COM(b - 1, i);
c[i] %= INF;
}
fo(i, b) { cout << c[i] << endl; }
} | [] | 797,845 | 797,843 | u322177979 | cpp |
p02990 | /*
24 January 2020
islingr
*/
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vi = vector<int>;
using vl = vector<ll>;
#define sz(x) (int)x.size()
#define all(x) begin(x), end(x)
#define rall(x) (x).rbegin(), (x).rend()
#define rsz resize
#define ins insert
#define ft front
#define bk back
#define pf push_front
#define pb push_back
#define eb emplace_back
#define lb lower_bound
#define ub upper_bound
#define fi first
#define se second
#define rep(i, a, b) for (auto i = (a); i < (b); ++i) // [a, b)
#define per(i, a, b) for (auto i = (b)-1; i >= (a); --i) // (b, a]
#define trav(e, x) for (auto &e : x)
template <class T> bool ckmin(T &a, const T &b) { return a > b ? a = b, 1 : 0; }
template <class T> bool ckmax(T &a, const T &b) { return a < b ? a = b, 1 : 0; }
mt19937 rng((uint32_t)chrono::steady_clock::now().time_since_epoch().count());
template <class T>
using Tree =
tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
#define ook order_of_key
#define fbo find_by_order
namespace helper {
template <class T, class = decltype(begin(declval<T>()))>
inline constexpr auto is_iterable(int) {
return true_type{};
}
template <class> inline constexpr auto is_iterable(unsigned) {
return false_type{};
}
} // namespace helper
namespace input {
void re(string &s) { cin >> s; }
template <class T> void re(T &x);
template <class P, class Q> void re(pair<P, Q> &);
template <class T, class... Ts> void re(T &t, Ts &...ts);
template <class T> void re(T &x, false_type) { cin >> x; }
template <class T> void re(T &x, true_type) {
for (auto &v : x)
re(v);
}
template <class T> void re(T &x) { re(x, helper::is_iterable<T>(0)); }
template <class P, class Q> void re(pair<P, Q> &p) { re(p.first, p.second); }
template <class T, class... Ts> void re(T &t, Ts &...ts) {
re(t);
re(ts...);
}
} // namespace input
namespace output {
template <typename T> void pr(const T &);
template <class T, class... Ts> void pr(const T &, const Ts &...);
template <class S, class T> void pr(const pair<S, T> &p) {
pr("(", p.first, ",", p.second, ")");
}
template <class T> void pr(queue<T> q) {
pr("{");
bool c = false;
while (!q.empty())
pr(c ? ", " : "", q.front()), q.pop(), c = true;
pr("}");
}
template <class T> void pr(priority_queue<T> q) {
pr("{");
bool c = false;
while (!q.empty())
pr(c ? ", " : "", q.top()), q.pop(), c = true;
pr("}");
}
template <class T> void pr(stack<T> s) {
pr("{");
bool c = false;
while (!s.empty())
pr(c ? ", " : "", s.top()), s.pop(), c = true;
pr("}");
}
void pr(const string &s) { cout << s; }
template <typename T> void pr(const T &x, false_type) { cout << x; }
template <typename T> void pr(const T &x, true_type) {
pr("{");
bool f = false;
for (const auto &v : x)
pr(f ? ", " : "", v), f = true;
pr("}");
}
template <typename T> void pr(const T &x) { pr(x, helper::is_iterable<T>(0)); }
template <class T, class... Ts> void pr(const T &t, const Ts &...ts) {
pr(t);
pr(ts...);
}
void pc() { pr("]\n"); } // debug w/ commas
template <class T, class... Ts> void pc(const T &t, const Ts &...ts) {
pr(t);
if (sizeof...(ts))
pr(", ");
pc(ts...);
}
#define dbg(x...) pr("[", #x, "] = ["), pc(x);
} // namespace output
struct IO {
IO(bool b) {
if (b)
fastio();
}
IO(bool b, string s) {
if (b)
fastio();
setIn(s + ".in");
setOut(s + ".out");
}
void fastio() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
}
void setIn(string s) { freopen(s.c_str(), "r", stdin); }
void setOut(string s) { freopen(s.c_str(), "w", stdout); }
};
using namespace input;
using namespace output;
IO io = IO(true);
constexpr int N = 1 << 11;
constexpr ll M = 1e9 + 7;
int inv[N] = {1, 1}, fac[2][N] = {{1, 1}, {1, 1}};
int bin(int n, int k) {
if (k < 0 || k > n)
return 0;
return 1LL * fac[0][n] * fac[1][k] % M * fac[1][n - k] % M;
}
signed main() {
rep(i, 2, N) {
inv[i] = (M - M / i * inv[M % i] % M) % M;
fac[0][i] = 1LL * fac[0][i - 1] * i % M;
fac[1][i] = 1LL * fac[1][i - 1] * inv[i] % M;
}
int n, k;
re(n, k);
rep(i, 1, k + 1) pr(bin(k - 1, i - 1) * bin(n - k + 1, i) % M, '\n');
}
| /*
24 January 2020
islingr
*/
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vi = vector<int>;
using vl = vector<ll>;
#define sz(x) (int)x.size()
#define all(x) begin(x), end(x)
#define rall(x) (x).rbegin(), (x).rend()
#define rsz resize
#define ins insert
#define ft front
#define bk back
#define pf push_front
#define pb push_back
#define eb emplace_back
#define lb lower_bound
#define ub upper_bound
#define fi first
#define se second
#define rep(i, a, b) for (auto i = (a); i < (b); ++i) // [a, b)
#define per(i, a, b) for (auto i = (b)-1; i >= (a); --i) // (b, a]
#define trav(e, x) for (auto &e : x)
template <class T> bool ckmin(T &a, const T &b) { return a > b ? a = b, 1 : 0; }
template <class T> bool ckmax(T &a, const T &b) { return a < b ? a = b, 1 : 0; }
mt19937 rng((uint32_t)chrono::steady_clock::now().time_since_epoch().count());
template <class T>
using Tree =
tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
#define ook order_of_key
#define fbo find_by_order
namespace helper {
template <class T, class = decltype(begin(declval<T>()))>
inline constexpr auto is_iterable(int) {
return true_type{};
}
template <class> inline constexpr auto is_iterable(unsigned) {
return false_type{};
}
} // namespace helper
namespace input {
void re(string &s) { cin >> s; }
template <class T> void re(T &x);
template <class P, class Q> void re(pair<P, Q> &);
template <class T, class... Ts> void re(T &t, Ts &...ts);
template <class T> void re(T &x, false_type) { cin >> x; }
template <class T> void re(T &x, true_type) {
for (auto &v : x)
re(v);
}
template <class T> void re(T &x) { re(x, helper::is_iterable<T>(0)); }
template <class P, class Q> void re(pair<P, Q> &p) { re(p.first, p.second); }
template <class T, class... Ts> void re(T &t, Ts &...ts) {
re(t);
re(ts...);
}
} // namespace input
namespace output {
template <typename T> void pr(const T &);
template <class T, class... Ts> void pr(const T &, const Ts &...);
template <class S, class T> void pr(const pair<S, T> &p) {
pr("(", p.first, ",", p.second, ")");
}
template <class T> void pr(queue<T> q) {
pr("{");
bool c = false;
while (!q.empty())
pr(c ? ", " : "", q.front()), q.pop(), c = true;
pr("}");
}
template <class T> void pr(priority_queue<T> q) {
pr("{");
bool c = false;
while (!q.empty())
pr(c ? ", " : "", q.top()), q.pop(), c = true;
pr("}");
}
template <class T> void pr(stack<T> s) {
pr("{");
bool c = false;
while (!s.empty())
pr(c ? ", " : "", s.top()), s.pop(), c = true;
pr("}");
}
void pr(const string &s) { cout << s; }
template <typename T> void pr(const T &x, false_type) { cout << x; }
template <typename T> void pr(const T &x, true_type) {
pr("{");
bool f = false;
for (const auto &v : x)
pr(f ? ", " : "", v), f = true;
pr("}");
}
template <typename T> void pr(const T &x) { pr(x, helper::is_iterable<T>(0)); }
template <class T, class... Ts> void pr(const T &t, const Ts &...ts) {
pr(t);
pr(ts...);
}
void pc() { pr("]\n"); } // debug w/ commas
template <class T, class... Ts> void pc(const T &t, const Ts &...ts) {
pr(t);
if (sizeof...(ts))
pr(", ");
pc(ts...);
}
#define dbg(x...) pr("[", #x, "] = ["), pc(x);
} // namespace output
struct IO {
IO(bool b) {
if (b)
fastio();
}
IO(bool b, string s) {
if (b)
fastio();
setIn(s + ".in");
setOut(s + ".out");
}
void fastio() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
}
void setIn(string s) { freopen(s.c_str(), "r", stdin); }
void setOut(string s) { freopen(s.c_str(), "w", stdout); }
};
using namespace input;
using namespace output;
IO io = IO(true);
constexpr int N = 1 << 11;
constexpr ll M = 1e9 + 7;
int inv[N] = {1, 1}, fac[2][N] = {{1, 1}, {1, 1}};
ll bin(int n, int k) {
if (k < 0 || k > n)
return 0;
return 1LL * fac[0][n] * fac[1][k] % M * fac[1][n - k] % M;
}
signed main() {
rep(i, 2, N) {
inv[i] = (M - M / i * inv[M % i] % M) % M;
fac[0][i] = 1LL * fac[0][i - 1] * i % M;
fac[1][i] = 1LL * fac[1][i - 1] * inv[i] % M;
}
int n, k;
re(n, k);
rep(i, 1, k + 1) pr(bin(k - 1, i - 1) * bin(n - k + 1, i) % M, '\n');
}
| [] | 797,848 | 797,849 | u883745615 | cpp |
p02990 | #include <bits/stdc++.h>
#define int long long
#define ll long long
#define rep(i, a, b) for (signed i = a; i < (b); ++i)
#define erep(i, a, b) for (signed i = a; i <= (b); ++i)
#define per(i, a, b) for (signed i = (a); i > (b); --i)
#define eper(i, a, b) for (signed i = (a); i >= b; --i)
#define fore(i, x, a) for (auto &&x : a)
#define ITR(i, b, e) for (auto i = (b); i != (e); ++i)
#define pb emplace_back
#define mp make_pair
#define ALL(x) begin(x), end(x)
#define F first
#define S second
#define debug(x) cout << #x << ": " << (x) << '\n';
const long long INF = 1001001001001001001;
const int MOD = (int)1e9 + 7;
const double EPS = 1e-9;
using namespace std;
using Pii = pair<int, int>;
using vii = vector<int>;
template <class T> using PS_queue = priority_queue<T, vector<T>, greater<T>>;
template <class T> using vv = vector<T>;
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;
}
template <typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val) {
fill((T *)array, (T *)(array + N), val);
}
template <class T> ostream &operator<<(ostream &os, const vector<T> &v) {
ITR(i, begin(v), end(v)) os << *i << (i == end(v) - 1 ? "" : " ");
return os;
}
template <class T>
ostream &operator<<(ostream &os, const vector<vector<T>> &v) {
ITR(u, begin(v), end(v))
ITR(w, begin(*u), end(*u)) os << *w << (w == end(*u) - 1 ? "\n" : " ");
return os;
}
template <class T> istream &operator>>(istream &is, vector<T> &v) {
ITR(i, begin(v), end(v)) is >> *i;
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> T gcd(T a, T b) { return b ? gcd(b, a % b) : a; }
template <class T> T lcm(T a, T b) { return a / gcd(a, b) * b; }
struct edge {
int from, to, cost;
};
int dy[] = {0, 1, -1, 0};
int dx[] = {1, 0, 0, -1};
// cout << fixed << setprecision(10) << val;
template <typename T> class Combination {
private:
vector<T> _fact, _rfact;
private:
int mpow(int x, int y) {
int res = 1;
x %= MOD;
while (y > 0) {
if (y & 1)
res = res * x % MOD;
x = x * x % MOD;
y >>= 1;
}
return res;
}
public:
Combination(int sz) : _fact(sz + 1), _rfact(sz + 1) {
_fact[0] = _rfact[sz] = 1;
for (int i = 1; i <= sz; i++)
_fact[i] = _fact[i - 1] * i % MOD;
_rfact[sz] = mpow(_fact[sz], MOD - 2);
for (int i = sz - 1; i >= 0; i--)
_rfact[i] = _rfact[i + 1] * (i + 1) % MOD;
}
inline T fact(int k) const { return _fact[k]; }
inline T rfact(int k) const { return _rfact[k]; }
T C(int n, int r) const {
if (r < 0 || n < r)
return 0;
return fact(n) * rfact(r) % MOD * rfact(n - r) % MOD;
}
};
int n, k;
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n >> k;
Combination<int> cmb(2005);
erep(i, 1, k) { cout << cmb.C(n - k + 1, i) * cmb.C(k - 1, i - 1) << endl; }
return 0;
}
| #include <bits/stdc++.h>
#define int long long
#define ll long long
#define rep(i, a, b) for (signed i = a; i < (b); ++i)
#define erep(i, a, b) for (signed i = a; i <= (b); ++i)
#define per(i, a, b) for (signed i = (a); i > (b); --i)
#define eper(i, a, b) for (signed i = (a); i >= b; --i)
#define fore(i, x, a) for (auto &&x : a)
#define ITR(i, b, e) for (auto i = (b); i != (e); ++i)
#define pb emplace_back
#define mp make_pair
#define ALL(x) begin(x), end(x)
#define F first
#define S second
#define debug(x) cout << #x << ": " << (x) << '\n';
const long long INF = 1001001001001001001;
const int MOD = (int)1e9 + 7;
const double EPS = 1e-9;
using namespace std;
using Pii = pair<int, int>;
using vii = vector<int>;
template <class T> using PS_queue = priority_queue<T, vector<T>, greater<T>>;
template <class T> using vv = vector<T>;
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;
}
template <typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val) {
fill((T *)array, (T *)(array + N), val);
}
template <class T> ostream &operator<<(ostream &os, const vector<T> &v) {
ITR(i, begin(v), end(v)) os << *i << (i == end(v) - 1 ? "" : " ");
return os;
}
template <class T>
ostream &operator<<(ostream &os, const vector<vector<T>> &v) {
ITR(u, begin(v), end(v))
ITR(w, begin(*u), end(*u)) os << *w << (w == end(*u) - 1 ? "\n" : " ");
return os;
}
template <class T> istream &operator>>(istream &is, vector<T> &v) {
ITR(i, begin(v), end(v)) is >> *i;
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> T gcd(T a, T b) { return b ? gcd(b, a % b) : a; }
template <class T> T lcm(T a, T b) { return a / gcd(a, b) * b; }
struct edge {
int from, to, cost;
};
int dy[] = {0, 1, -1, 0};
int dx[] = {1, 0, 0, -1};
// cout << fixed << setprecision(10) << val;
template <typename T> class Combination {
private:
vector<T> _fact, _rfact;
private:
int mpow(int x, int y) {
int res = 1;
x %= MOD;
while (y > 0) {
if (y & 1)
res = res * x % MOD;
x = x * x % MOD;
y >>= 1;
}
return res;
}
public:
Combination(int sz) : _fact(sz + 1), _rfact(sz + 1) {
_fact[0] = _rfact[sz] = 1;
for (int i = 1; i <= sz; i++)
_fact[i] = _fact[i - 1] * i % MOD;
_rfact[sz] = mpow(_fact[sz], MOD - 2);
for (int i = sz - 1; i >= 0; i--)
_rfact[i] = _rfact[i + 1] * (i + 1) % MOD;
}
inline T fact(int k) const { return _fact[k]; }
inline T rfact(int k) const { return _rfact[k]; }
T C(int n, int r) const {
if (r < 0 || n < r)
return 0;
return fact(n) * rfact(r) % MOD * rfact(n - r) % MOD;
}
};
int n, k;
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n >> k;
Combination<int> cmb(2005);
erep(i, 1, k) {
cout << cmb.C(n - k + 1, i) * cmb.C(k - 1, i - 1) % MOD << endl;
}
return 0;
}
| [
"expression.operation.binary.add"
] | 797,852 | 797,853 | u394919721 | cpp |
p02990 | #include <iostream>
#include <vector>
using namespace std;
const int MOD = 1000000007;
int main() {
int N, K;
cin >> N >> K;
vector<vector<int>> dp(N + 1, vector<int>(N + 1));
for (int i = 0; i <= N; i++) {
dp[i][0] = 1;
dp[i][i] = 1;
for (int j = 1; j < i; j++) {
dp[i][j] = (dp[i - 1][j] + dp[i - 1][j - 1]) % MOD;
}
}
for (int i = 1; i <= K; i++) {
if (N - K + 1 < i) {
cout << 0 << endl;
continue;
}
cout << (dp[N - K + 1][i] * dp[K - 1][i - 1]) % MOD << endl;
}
return 0;
} | #include <iostream>
#include <vector>
using namespace std;
const int MOD = 1000000007;
int main() {
int N, K;
cin >> N >> K;
vector<vector<long long>> dp(N + 1, vector<long long>(N + 1));
for (int i = 0; i <= N; i++) {
dp[i][0] = 1;
dp[i][i] = 1;
for (int j = 1; j < i; j++) {
dp[i][j] = (dp[i - 1][j] + dp[i - 1][j - 1]) % MOD;
}
}
for (int i = 1; i <= K; i++) {
if (N - K + 1 < i) {
cout << 0 << endl;
continue;
}
cout << (dp[N - K + 1][i] * dp[K - 1][i - 1]) % MOD << endl;
}
return 0;
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 797,860 | 797,861 | u188117876 | cpp |
p02990 | #include <bits/stdc++.h>
#include <cmath>
#include <numeric>
using namespace std;
#define rep(i, a, b) for (int64_t i = (a); i < (b); ++i) // a ≦ i < b
#define Rrep(i, a, b) \
for (int64_t i = (a); i >= (b); --i) // reverse repeat. a から b まで減少．
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend() //逆イテレータ
#define INF 100000000000000
#define MOD 1000000007LL
#define RANGE(a, b, c) (a).begin() + (b), (a).begin() + (c) // [b,c) イテレータ
using PII = pair<int64_t, int64_t>;
using VI = vector<int64_t>;
using VVI = vector<VI>;
using VS = vector<string>;
using VP = vector<PII>;
using i64 = int64_t;
// input vector
template <typename T> void invec(vector<T> &A) {
for (T &a : A)
cin >> a;
}
#define MAX 10000
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() {
cin.tie(0);
ios::sync_with_stdio(false);
i64 N, K;
cin >> N >> K;
int R = N - K;
COMinit();
// (Kをi分割する方法数)*COM(R+1, i)
rep(i, 1, K + 1) {
if (R + 1 < i)
cout << "0\n";
cout << COM(K - 1, i - 1) * COM(R + 1, i) % MOD << "\n";
}
}
// 書いて考える．場合分け
// 境界，出力文字列 チェック．行末にスペース入れない．
// 可読性優先．高速化次点．
// まずは全探索，分割統治，次にDP
// 制限を見る．境界に注意．求めたい量の変域．動かせる量．
// 偶奇，逆から，ソート，出現回数，出現位置，DP， 余事象，包除
// データ構造． 問題の特徴量．単調性，二分探索
// 存在判定：構成方法，入力の特徴
// gcd, lcm ,素因数分解．
// 例外を十分に含む一般化．想像力の限界
// 小さい系から例示
// 代数的処理．前処理によるクエリ高速化．
// 始めは過剰に例示・場合分けしてもいい．各場合を確実に対処．
// 自明な例から処理，除外．
// 小数のときは，精度の設定する．doubel 変数に数値を入力するときは 123. とする．
// テストケース作成は数表あり
// 実行エラー：vector添え字超え．0割り．
| #include <bits/stdc++.h>
#include <cmath>
#include <numeric>
using namespace std;
#define rep(i, a, b) for (int64_t i = (a); i < (b); ++i) // a ≦ i < b
#define Rrep(i, a, b) \
for (int64_t i = (a); i >= (b); --i) // reverse repeat. a から b まで減少．
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend() //逆イテレータ
#define INF 100000000000000
#define MOD 1000000007LL
#define RANGE(a, b, c) (a).begin() + (b), (a).begin() + (c) // [b,c) イテレータ
using PII = pair<int64_t, int64_t>;
using VI = vector<int64_t>;
using VVI = vector<VI>;
using VS = vector<string>;
using VP = vector<PII>;
using i64 = int64_t;
// input vector
template <typename T> void invec(vector<T> &A) {
for (T &a : A)
cin >> a;
}
#define MAX 10000
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() {
cin.tie(0);
ios::sync_with_stdio(false);
i64 N, K;
cin >> N >> K;
int R = N - K;
COMinit();
// (Kをi分割する方法数)*COM(R+1, i)
rep(i, 1, K + 1) {
if (R + 1 < i)
cout << "0\n";
else
cout << COM(K - 1, i - 1) * COM(R + 1, i) % MOD << "\n";
}
}
// 書いて考える．場合分け
// 境界，出力文字列 チェック．行末にスペース入れない．
// 可読性優先．高速化次点．
// まずは全探索，分割統治，次にDP
// 制限を見る．境界に注意．求めたい量の変域．動かせる量．
// 偶奇，逆から，ソート，出現回数，出現位置，DP， 余事象，包除
// データ構造． 問題の特徴量．単調性，二分探索
// 存在判定：構成方法，入力の特徴
// gcd, lcm ,素因数分解．
// 例外を十分に含む一般化．想像力の限界
// 小さい系から例示
// 代数的処理．前処理によるクエリ高速化．
// 始めは過剰に例示・場合分けしてもいい．各場合を確実に対処．
// 自明な例から処理，除外．
// 小数のときは，精度の設定する．doubel 変数に数値を入力するときは 123. とする．
// テストケース作成は数表あり
// 実行エラー：vector添え字超え．0割り．
| [
"control_flow.branch.else_if.replace.remove",
"control_flow.branch.if.replace.add"
] | 797,862 | 797,863 | u421426760 | cpp |
p02990 | #include <bits/stdc++.h>
#include <cmath>
#include <numeric>
using namespace std;
#define rep(i, a, b) for (int64_t i = (a); i < (b); ++i) // a ≦ i < b
#define Rrep(i, a, b) \
for (int64_t i = (a); i >= (b); --i) // reverse repeat. a から b まで減少．
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend() //逆イテレータ
#define INF 100000000000000
#define MOD 1000000007LL
#define RANGE(a, b, c) (a).begin() + (b), (a).begin() + (c) // [b,c) イテレータ
using PII = pair<int64_t, int64_t>;
using VI = vector<int64_t>;
using VVI = vector<VI>;
using VS = vector<string>;
using VP = vector<PII>;
using i64 = int64_t;
// input vector
template <typename T> void invec(vector<T> &A) {
for (T &a : A)
cin >> a;
}
#define MAX 10000
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() {
cin.tie(0);
ios::sync_with_stdio(false);
i64 N, K;
cin >> N >> K;
int R = N - K;
COMinit();
// (Kをi分割する方法数)*COM(R+1, i)
rep(i, 1, K + 1) {
if (R + 1 < i) {
cout << "1\n";
return 0;
}
cout << COM(K - 1, i - 1) * COM(R + 1, i) % MOD << "\n";
}
}
// 書いて考える．場合分け
// 境界，出力文字列 チェック．行末にスペース入れない．
// 可読性優先．高速化次点．
// まずは全探索，分割統治，次にDP
// 制限を見る．境界に注意．求めたい量の変域．動かせる量．
// 偶奇，逆から，ソート，出現回数，出現位置，DP， 余事象，包除
// データ構造． 問題の特徴量．単調性，二分探索
// 存在判定：構成方法，入力の特徴
// gcd, lcm ,素因数分解．
// 例外を十分に含む一般化．想像力の限界
// 小さい系から例示
// 代数的処理．前処理によるクエリ高速化．
// 始めは過剰に例示・場合分けしてもいい．各場合を確実に対処．
// 自明な例から処理，除外．
// 小数のときは，精度の設定する．doubel 変数に数値を入力するときは 123. とする．
// テストケース作成は数表あり
// 実行エラー：vector添え字超え．0割り．
| #include <bits/stdc++.h>
#include <cmath>
#include <numeric>
using namespace std;
#define rep(i, a, b) for (int64_t i = (a); i < (b); ++i) // a ≦ i < b
#define Rrep(i, a, b) \
for (int64_t i = (a); i >= (b); --i) // reverse repeat. a から b まで減少．
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend() //逆イテレータ
#define INF 100000000000000
#define MOD 1000000007LL
#define RANGE(a, b, c) (a).begin() + (b), (a).begin() + (c) // [b,c) イテレータ
using PII = pair<int64_t, int64_t>;
using VI = vector<int64_t>;
using VVI = vector<VI>;
using VS = vector<string>;
using VP = vector<PII>;
using i64 = int64_t;
// input vector
template <typename T> void invec(vector<T> &A) {
for (T &a : A)
cin >> a;
}
#define MAX 10000
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() {
cin.tie(0);
ios::sync_with_stdio(false);
i64 N, K;
cin >> N >> K;
int R = N - K;
COMinit();
// (Kをi分割する方法数)*COM(R+1, i)
rep(i, 1, K + 1) {
if (R + 1 < i)
cout << "0\n";
else
cout << COM(K - 1, i - 1) * COM(R + 1, i) % MOD << "\n";
}
}
// 書いて考える．場合分け
// 境界，出力文字列 チェック．行末にスペース入れない．
// 可読性優先．高速化次点．
// まずは全探索，分割統治，次にDP
// 制限を見る．境界に注意．求めたい量の変域．動かせる量．
// 偶奇，逆から，ソート，出現回数，出現位置，DP， 余事象，包除
// データ構造． 問題の特徴量．単調性，二分探索
// 存在判定：構成方法，入力の特徴
// gcd, lcm ,素因数分解．
// 例外を十分に含む一般化．想像力の限界
// 小さい系から例示
// 代数的処理．前処理によるクエリ高速化．
// 始めは過剰に例示・場合分けしてもいい．各場合を確実に対処．
// 自明な例から処理，除外．
// 小数のときは，精度の設定する．doubel 変数に数値を入力するときは 123. とする．
// テストケース作成は数表あり
// 実行エラー：vector添え字超え．0割り．
| [
"literal.string.change",
"io.output.change",
"function.return_value.change"
] | 797,864 | 797,863 | u421426760 | cpp |
p02990 | #include <bits/stdc++.h>
#include <cmath>
#include <numeric>
using namespace std;
#define rep(i, a, b) for (int64_t i = (a); i < (b); ++i) // a ≦ i < b
#define Rrep(i, a, b) \
for (int64_t i = (a); i >= (b); --i) // reverse repeat. a から b まで減少．
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend() //逆イテレータ
#define INF 100000000000000
#define MOD 1000000007LL
#define RANGE(a, b, c) (a).begin() + (b), (a).begin() + (c) // [b,c) イテレータ
using PII = pair<int64_t, int64_t>;
using VI = vector<int64_t>;
using VVI = vector<VI>;
using VS = vector<string>;
using VP = vector<PII>;
using i64 = int64_t;
// input vector
template <typename T> void invec(vector<T> &A) {
for (T &a : A)
cin >> a;
}
#define MAX 100000
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() {
cin.tie(0);
ios::sync_with_stdio(false);
i64 N, K;
cin >> N >> K;
int R = N - K;
COMinit();
// (Kをi分割する方法数)*COM(R+1, i)
rep(i, 1, K + 1) {
if (R + 1 < i) {
cout << "0\n";
return 0;
}
cout << COM(K - 1, i - 1) * COM(R + 1, i) % MOD << "\n";
}
}
// 書いて考える．場合分け
// 境界，出力文字列 チェック．行末にスペース入れない．
// 可読性優先．高速化次点．
// まずは全探索，分割統治，次にDP
// 制限を見る．境界に注意．求めたい量の変域．動かせる量．
// 偶奇，逆から，ソート，出現回数，出現位置，DP， 余事象，包除
// データ構造． 問題の特徴量．単調性，二分探索
// 存在判定：構成方法，入力の特徴
// gcd, lcm ,素因数分解．
// 例外を十分に含む一般化．想像力の限界
// 小さい系から例示
// 代数的処理．前処理によるクエリ高速化．
// 始めは過剰に例示・場合分けしてもいい．各場合を確実に対処．
// 自明な例から処理，除外．
// 小数のときは，精度の設定する．doubel 変数に数値を入力するときは 123. とする．
// テストケース作成は数表あり
// 実行エラー：vector添え字超え．0割り．
| #include <bits/stdc++.h>
#include <cmath>
#include <numeric>
using namespace std;
#define rep(i, a, b) for (int64_t i = (a); i < (b); ++i) // a ≦ i < b
#define Rrep(i, a, b) \
for (int64_t i = (a); i >= (b); --i) // reverse repeat. a から b まで減少．
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend() //逆イテレータ
#define INF 100000000000000
#define MOD 1000000007LL
#define RANGE(a, b, c) (a).begin() + (b), (a).begin() + (c) // [b,c) イテレータ
using PII = pair<int64_t, int64_t>;
using VI = vector<int64_t>;
using VVI = vector<VI>;
using VS = vector<string>;
using VP = vector<PII>;
using i64 = int64_t;
// input vector
template <typename T> void invec(vector<T> &A) {
for (T &a : A)
cin >> a;
}
#define MAX 10000
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() {
cin.tie(0);
ios::sync_with_stdio(false);
i64 N, K;
cin >> N >> K;
int R = N - K;
COMinit();
// (Kをi分割する方法数)*COM(R+1, i)
rep(i, 1, K + 1) {
if (R + 1 < i)
cout << "0\n";
else
cout << COM(K - 1, i - 1) * COM(R + 1, i) % MOD << "\n";
}
}
// 書いて考える．場合分け
// 境界，出力文字列 チェック．行末にスペース入れない．
// 可読性優先．高速化次点．
// まずは全探索，分割統治，次にDP
// 制限を見る．境界に注意．求めたい量の変域．動かせる量．
// 偶奇，逆から，ソート，出現回数，出現位置，DP， 余事象，包除
// データ構造． 問題の特徴量．単調性，二分探索
// 存在判定：構成方法，入力の特徴
// gcd, lcm ,素因数分解．
// 例外を十分に含む一般化．想像力の限界
// 小さい系から例示
// 代数的処理．前処理によるクエリ高速化．
// 始めは過剰に例示・場合分けしてもいい．各場合を確実に対処．
// 自明な例から処理，除外．
// 小数のときは，精度の設定する．doubel 変数に数値を入力するときは 123. とする．
// テストケース作成は数表あり
// 実行エラー：vector添え字超え．0割り．
| [
"preprocessor.define.value.change",
"literal.integer.change",
"function.return_value.change"
] | 797,865 | 797,863 | u421426760 | cpp |
p02990 | #include <bits/stdc++.h>
#include <cmath>
#include <numeric>
using namespace std;
#define rep(i, a, b) for (int64_t i = (a); i < (b); ++i) // a ≦ i < b
#define Rrep(i, a, b) \
for (int64_t i = (a); i >= (b); --i) // reverse repeat. a から b まで減少．
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend() //逆イテレータ
#define INF 100000000000000
#define MOD 1000000007LL
#define RANGE(a, b, c) (a).begin() + (b), (a).begin() + (c) // [b,c) イテレータ
using PII = pair<int64_t, int64_t>;
using VI = vector<int64_t>;
using VVI = vector<VI>;
using VS = vector<string>;
using VP = vector<PII>;
using i64 = int64_t;
// input vector
template <typename T> void invec(vector<T> &A) {
for (T &a : A)
cin >> a;
}
#define MAX 10000
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() {
cin.tie(0);
ios::sync_with_stdio(false);
i64 N, K;
cin >> N >> K;
int R = N - K;
COMinit();
// (Kをi分割する方法数)*COM(R+1, i)
rep(i, 1, K + 1) {
if (R + 1 < i) {
cout << "0\n";
return 0;
}
cout << COM(K - 1, i - 1) * COM(R + 1, i) % MOD << "\n";
}
}
// 書いて考える．場合分け
// 境界，出力文字列 チェック．行末にスペース入れない．
// 可読性優先．高速化次点．
// まずは全探索，分割統治，次にDP
// 制限を見る．境界に注意．求めたい量の変域．動かせる量．
// 偶奇，逆から，ソート，出現回数，出現位置，DP， 余事象，包除
// データ構造． 問題の特徴量．単調性，二分探索
// 存在判定：構成方法，入力の特徴
// gcd, lcm ,素因数分解．
// 例外を十分に含む一般化．想像力の限界
// 小さい系から例示
// 代数的処理．前処理によるクエリ高速化．
// 始めは過剰に例示・場合分けしてもいい．各場合を確実に対処．
// 自明な例から処理，除外．
// 小数のときは，精度の設定する．doubel 変数に数値を入力するときは 123. とする．
// テストケース作成は数表あり
// 実行エラー：vector添え字超え．0割り．
| #include <bits/stdc++.h>
#include <cmath>
#include <numeric>
using namespace std;
#define rep(i, a, b) for (int64_t i = (a); i < (b); ++i) // a ≦ i < b
#define Rrep(i, a, b) \
for (int64_t i = (a); i >= (b); --i) // reverse repeat. a から b まで減少．
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend() //逆イテレータ
#define INF 100000000000000
#define MOD 1000000007LL
#define RANGE(a, b, c) (a).begin() + (b), (a).begin() + (c) // [b,c) イテレータ
using PII = pair<int64_t, int64_t>;
using VI = vector<int64_t>;
using VVI = vector<VI>;
using VS = vector<string>;
using VP = vector<PII>;
using i64 = int64_t;
// input vector
template <typename T> void invec(vector<T> &A) {
for (T &a : A)
cin >> a;
}
#define MAX 10000
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() {
cin.tie(0);
ios::sync_with_stdio(false);
i64 N, K;
cin >> N >> K;
int R = N - K;
COMinit();
// (Kをi分割する方法数)*COM(R+1, i)
rep(i, 1, K + 1) {
if (R + 1 < i)
cout << "0\n";
else
cout << COM(K - 1, i - 1) * COM(R + 1, i) % MOD << "\n";
}
}
// 書いて考える．場合分け
// 境界，出力文字列 チェック．行末にスペース入れない．
// 可読性優先．高速化次点．
// まずは全探索，分割統治，次にDP
// 制限を見る．境界に注意．求めたい量の変域．動かせる量．
// 偶奇，逆から，ソート，出現回数，出現位置，DP， 余事象，包除
// データ構造． 問題の特徴量．単調性，二分探索
// 存在判定：構成方法，入力の特徴
// gcd, lcm ,素因数分解．
// 例外を十分に含む一般化．想像力の限界
// 小さい系から例示
// 代数的処理．前処理によるクエリ高速化．
// 始めは過剰に例示・場合分けしてもいい．各場合を確実に対処．
// 自明な例から処理，除外．
// 小数のときは，精度の設定する．doubel 変数に数値を入力するときは 123. とする．
// テストケース作成は数表あり
// 実行エラー：vector添え字超え．0割り．
| [
"function.return_value.change"
] | 797,867 | 797,863 | u421426760 | cpp |
p02990 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define repr(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define rep(i, n) repr(i, 0, n)
#define INF 2e9
#define MOD 1000000007
//#define MOD 998244353
#define LINF (long long)4e18
#define jck 3.141592
using ll = long long;
using Pi = pair<int, int>;
using Pl = pair<ll, ll>;
struct Combination {
vector<long long> _fac, _finv, _inv;
const int m = MOD;
Combination(int sz) : _fac(sz), _finv(sz), _inv(sz) {
_fac[0] = _fac[1] = 1;
_finv[0] = _finv[1] = 1;
_inv[1] = 1;
for (int i = 2; i <= sz; i++) {
_fac[i] = _fac[i - 1] * i % m;
_inv[i] = m - _inv[m % i] * (m / i) % m;
_finv[i] = _finv[i - 1] * _inv[i] % m;
}
}
inline int fac(int n) { return _fac[n]; }
inline int inv(int n) { return _inv[n]; }
inline int finv(int n) { return _finv[n]; }
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] % m) % m;
}
};
int main() {
int N, K;
cin >> N >> K;
Combination C(2020);
repr(i, 1, K + 1) {
ll ans = C.comb(K - 1, i - 1) * C.comb(N - K + 1, i) % MOD;
cout << ans << endl;
}
}
| #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define repr(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define rep(i, n) repr(i, 0, n)
#define INF 2e9
#define MOD 1000000007
//#define MOD 998244353
#define LINF (long long)4e18
#define jck 3.141592
using ll = long long;
using Pi = pair<int, int>;
using Pl = pair<ll, ll>;
struct Combination {
vector<long long> _fac, _finv, _inv;
const int m = MOD;
Combination(int sz) : _fac(sz), _finv(sz), _inv(sz) {
_fac[0] = _fac[1] = 1;
_finv[0] = _finv[1] = 1;
_inv[1] = 1;
for (int i = 2; i <= sz; i++) {
_fac[i] = _fac[i - 1] * i % m;
_inv[i] = m - _inv[m % i] * (m / i) % m;
_finv[i] = _finv[i - 1] * _inv[i] % m;
}
}
inline int fac(int n) { return _fac[n]; }
inline int inv(int n) { return _inv[n]; }
inline int finv(int n) { return _finv[n]; }
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] % m) % m;
}
};
int main() {
int N, K;
cin >> N >> K;
Combination C(2020);
repr(i, 1, K + 1) {
int ans = C.comb(K - 1, i - 1) * C.comb(N - K + 1, i) % MOD;
cout << ans << endl;
}
}
| [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change",
"variable_declaration.type.change"
] | 797,868 | 797,869 | u314008046 | cpp |
p02990 | #include <iostream>
#include <stdio.h>
using namespace std;
#define REP(a, i, n) for (int i = a; i < n; ++i)
const int limitation = 2005;
long C[limitation][limitation]; // C[n][k] = n! / (k! * (n - k)!)
long calc(int i, int j) {
if (C[i][j] != 0)
return C[i][j];
if (i < j) {
return 1;
} else if (i == j) {
C[i][j] = 1;
return 1;
} else if (j == 0) {
C[i][j] = 1;
return 1;
} else {
C[i][j] = (calc(i - 1, j - 1) + calc(i - 1, j)) % 1000000007;
return C[i][j];
}
}
int main() {
// 1 <= K <= N <= 2000
int N; // ボール数
int K; // 青いボール数
cin >> N >> K;
REP(0, i, limitation) REP(0, j, limitation) C[i][j] = 0;
REP(1, i, K + 1) {
cout << (calc(N - K + 1, i) * calc(K - 1, i - 1)) % 1000000007 << endl;
}
return 0;
}
| #include <iostream>
#include <stdio.h>
using namespace std;
#define REP(a, i, n) for (int i = a; i < n; ++i)
const int limitation = 2005;
long C[limitation][limitation]; // C[n][k] = n! / (k! * (n - k)!)
long calc(int i, int j) {
if (C[i][j] != 0)
return C[i][j];
if (i < j) {
return 0;
} else if (i == j) {
C[i][j] = 1;
return 1;
} else if (j == 0) {
C[i][j] = 1;
return 1;
} else {
C[i][j] = (calc(i - 1, j - 1) + calc(i - 1, j)) % 1000000007;
return C[i][j];
}
}
int main() {
// 1 <= K <= N <= 2000
int N; // ボール数
int K; // 青いボール数
cin >> N >> K;
REP(0, i, limitation) REP(0, j, limitation) C[i][j] = 0;
REP(1, i, K + 1) {
cout << (calc(N - K + 1, i) * calc(K - 1, i - 1)) % 1000000007 << endl;
}
return 0;
}
| [
"literal.number.change",
"function.return_value.change"
] | 797,878 | 797,879 | u392294962 | cpp |
p02990 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define REP(i, m, n) for (int i = (int)(m); i < (int)(n); i++)
#define rep(i, n) REP(i, 0, n)
#define REPL(i, m, n) for (ll i = (ll)(m); i < (ll)(n); i++)
#define repl(i, n) REP(i, 0, n)
#define all(v) v.begin(), v.end()
const int inf = 1e9 + 7;
const ll longinf = 1LL << 60;
const ll mod = 1e9 + 7;
ll p = 1000000000 + 7;
#define MAX_N 100000
ll inv[MAX_N], fac[MAX_N], finv[MAX_N];
void make() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX_N; i++) {
inv[i] = mod - inv[mod % i] * (mod / i) % mod;
fac[i] = fac[i - 1] * (ll)i % mod;
finv[i] = finv[i - 1] * inv[i] % mod;
}
}
ll perm(ll n, ll r) {
if (n < 0)
return 0;
else if (n < r)
return 0;
else
return (fac[n] * finv[n - r]) % mod;
}
ll comb(ll n, ll r) {
ll ans = 1;
ans = perm(n, r); // n * (n-1) * ... * (n-r+1)
ans = (ans * finv[r]) % mod; // フェルマーの小定理
return ans;
}
ll combination(ll n, ll r) {
if (r * 2 > n)
r = n - r;
ll dividend = 1;
ll divisor = 1;
for (ll i = 1; i <= r; ++i) {
dividend *= (n - i + 1);
divisor *= i;
}
return (dividend / divisor) % p;
}
long long combi(long long n, long long k) {
if (n == k || k == 0)
return 1;
else {
return (combi(n - 1, k - 1) + combi(n - 1, k)) % p;
}
}
int main() {
ll N, K;
cin >> N;
cin >> K;
ll ans;
REP(i, 1, K + 1) { // 1 <= i <= K
ll comb1 = combination((N - K + 1), i);
comb1 = comb1 % p;
ll comb2 = combination(K - 1, i - 1);
comb2 = comb2 % p;
ans = comb1 * comb2;
ans = ans % p;
// cout << "i: " << i << ", combi: " << comb << endl;
// cout << "mod_pow: " << ans << endl;
cout << ans << endl;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define REP(i, m, n) for (int i = (int)(m); i < (int)(n); i++)
#define rep(i, n) REP(i, 0, n)
#define REPL(i, m, n) for (ll i = (ll)(m); i < (ll)(n); i++)
#define repl(i, n) REP(i, 0, n)
#define all(v) v.begin(), v.end()
const int inf = 1e9 + 7;
const ll longinf = 1LL << 60;
const ll mod = 1e9 + 7;
ll p = 1000000000 + 7;
#define MAX_N 100000
ll inv[MAX_N], fac[MAX_N], finv[MAX_N];
void make() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX_N; i++) {
inv[i] = mod - inv[mod % i] * (mod / i) % mod;
fac[i] = fac[i - 1] * (ll)i % mod;
finv[i] = finv[i - 1] * inv[i] % mod;
}
}
ll perm(ll n, ll r) {
if (n < 0)
return 0;
else if (n < r)
return 0;
else
return (fac[n] * finv[n - r]) % mod;
}
ll comb(ll n, ll r) {
ll ans = 1;
ans = perm(n, r); // n * (n-1) * ... * (n-r+1)
ans = (ans * finv[r]) % mod; // フェルマーの小定理
return ans;
}
ll combination(ll n, ll r) {
if (r * 2 > n)
r = n - r;
ll dividend = 1;
ll divisor = 1;
for (ll i = 1; i <= r; ++i) {
dividend *= (n - i + 1);
divisor *= i;
}
return (dividend / divisor) % p;
}
long long combi(long long n, long long k) {
if (n == k || k == 0)
return 1;
else {
return (combi(n - 1, k - 1) + combi(n - 1, k)) % p;
}
}
int main() {
ll N, K;
cin >> N;
cin >> K;
ll ans;
make();
REP(i, 1, K + 1) { // 1 <= i <= K
ll comb1 = comb((N - K + 1), i);
comb1 = comb1 % p;
ll comb2 = comb(K - 1, i - 1);
comb2 = comb2 % p;
ans = comb1 * comb2;
ans = ans % p;
// cout << "i: " << i << ", combi: " << comb << endl;
// cout << "mod_pow: " << ans << endl;
cout << ans << endl;
}
return 0;
}
| [
"call.add",
"identifier.change",
"call.function.change"
] | 797,882 | 797,883 | u764013649 | cpp |
p02990 | #include <bits/stdc++.h>
using namespace std;
long long modinv(long long a, long long m) {
long long b = m, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= m;
if (u < 0)
u += m;
return u;
}
long long cob(long long a, long long b) {
long long over = 1;
long long under = 1;
for (int i = 0; i < b; i++) {
over *= a - i;
over %= 1000000007;
}
for (int i = 1; i < b + 1; i++) {
under *= i;
// under %= 1000000007;
}
return over * modinv(under, 1000000007) % 1000000007;
}
int main() {
long long n, k;
cin >> n >> k;
vector<long long> out(k);
for (int i = 1; i < k + 1; i++) {
if (n - k < i - 1) {
cout << 0 << endl;
continue;
}
long long b = cob(k - 1, i - 1);
long long r = cob(n - k + 1, i);
cout << b * r % 1000000007 << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
long long modinv(long long a, long long m) {
long long b = m, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= m;
if (u < 0)
u += m;
return u;
}
long long cob(long long a, long long b) {
long long over = 1;
long long under = 1;
for (int i = 0; i < b; i++) {
over *= a - i;
over %= 1000000007;
}
for (int i = 1; i < b + 1; i++) {
under *= i;
under %= 1000000007;
}
return over * modinv(under, 1000000007) % 1000000007;
}
int main() {
long long n, k;
cin >> n >> k;
vector<long long> out(k);
for (int i = 1; i < k + 1; i++) {
if (n - k < i - 1) {
cout << 0 << endl;
continue;
}
long long b = cob(k - 1, i - 1);
long long r = cob(n - k + 1, i);
cout << b * r % 1000000007 << endl;
}
} | [
"assignment.add"
] | 797,884 | 797,885 | u431602218 | cpp |
p02990 | #include <bits/stdc++.h>
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) << endl
#define PQ priority_queue<ll>
#define PQR priority_queue<ll, vector<ll>, greater<ll>>
#define YES(n) cout << ((n) ? "YES" : "NO") << endl
#define Yes(n) cout << ((n) ? "Yes" : "No") << endl
#define mp make_pair
#define maxs(x, y) (x = max(x, y))
#define mins(x, y) (x = min(x, y))
#define sz(x) (int)(x).size()
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const ll INF = 1LL << 60;
using vll = vector<ll>;
using vvll = vector<vll>;
using vstr = vector<string>;
using pll = pair<ll, ll>;
const int MAX = 700000;
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, k;
cin >> n >> k;
int a = n - k;
for (int i = 0; i <= k; i++) {
COUT(COM(a + 1, i) * COM(k - 1, i - 1) % MOD);
}
} | #include <bits/stdc++.h>
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) << endl
#define PQ priority_queue<ll>
#define PQR priority_queue<ll, vector<ll>, greater<ll>>
#define YES(n) cout << ((n) ? "YES" : "NO") << endl
#define Yes(n) cout << ((n) ? "Yes" : "No") << endl
#define mp make_pair
#define maxs(x, y) (x = max(x, y))
#define mins(x, y) (x = min(x, y))
#define sz(x) (int)(x).size()
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const ll INF = 1LL << 60;
using vll = vector<ll>;
using vvll = vector<vll>;
using vstr = vector<string>;
using pll = pair<ll, ll>;
const int MAX = 700000;
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, k;
cin >> n >> k;
int a = n - k;
for (int i = 1; i <= k; i++) {
COUT(COM(a + 1, i) * COM(k - 1, i - 1) % MOD);
}
}
| [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 797,886 | 797,887 | u103850114 | cpp |
p02990 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
typedef long long ll;
#define mop 1000000007
using namespace std;
long long extGCD(long long a, long long b, long long &x, long long &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
long long d = extGCD(b, a % b, y, x); // 再帰的に解く
y -= a / b * x;
return d;
}
// 負の数にも対応した mod (a = -11 とかでも OK)
inline long long mod(long long a, long long m) { return (a % m + m) % m; }
// 逆元計算 (ここでは a と m が互いに素であることが必要)
long long modinv(long long a, long long m) {
long long x, y;
extGCD(a, m, x, y);
return mod(x, m); // 気持ち的には x % m だが、x が負かもしれないので
}
unsigned long long nCr(long n, long r) {
unsigned long long ans = 1;
for (long i = 1; i < r + 1; ++i) {
ans = ans * (n - i + 1) % mop;
// cout << ans << endl;
ans = ans * modinv(i, mop) % mop;
// cout << ans << endl;
}
// cout << ans << endl;
return ans;
}
int main() {
ll n, k;
cin >> n >> k;
// cout << nCr(3,2) << endl;
for (ll i = 1; i <= k; i++) {
cout << nCr(n - k + 1, i) * nCr(k - 1, i - 1) << endl;
}
} | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
typedef long long ll;
#define mop 1000000007
using namespace std;
long long extGCD(long long a, long long b, long long &x, long long &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
long long d = extGCD(b, a % b, y, x); // 再帰的に解く
y -= a / b * x;
return d;
}
// 負の数にも対応した mod (a = -11 とかでも OK)
inline long long mod(long long a, long long m) { return (a % m + m) % m; }
// 逆元計算 (ここでは a と m が互いに素であることが必要)
long long modinv(long long a, long long m) {
long long x, y;
extGCD(a, m, x, y);
return mod(x, m); // 気持ち的には x % m だが、x が負かもしれないので
}
unsigned long long nCr(long n, long r) {
unsigned long long ans = 1;
for (long i = 1; i < r + 1; ++i) {
ans = ans * (n - i + 1) % mop;
// cout << ans << endl;
ans = ans * modinv(i, mop) % mop;
// cout << ans << endl;
}
// cout << ans << endl;
return ans;
}
int main() {
ll n, k;
cin >> n >> k;
// cout << nCr(3,2) << endl;
for (ll i = 1; i <= k; i++) {
cout << nCr(n - k + 1, i) * nCr(k - 1, i - 1) % mop << endl;
}
} | [
"expression.operation.binary.add"
] | 797,892 | 797,893 | u099918199 | cpp |
p02990 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
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;
}
void solve(long long N, long long K) {
COMinit();
for (int i = 1; i <= K; i++) {
ll red = N - K;
ll blue = K;
if (red < i - 1) {
cout << 0 << endl;
continue;
} else if (red == i - 1) {
cout << 1 << endl;
continue;
}
cout << 1LL *
(((red < i + 1 ? 0 : COM(red - 1, i)) % MOD +
(red < i ? 0 : 2 * COM(red - 1, i - 1)) % MOD +
COM(red - 1, i - 2)) %
MOD * COM(blue - 1, i - 1) % MOD) %
MOD
<< endl;
;
}
}
int main() {
long long N;
scanf("%lld", &N);
long long K;
scanf("%lld", &K);
solve(N, K);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
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;
}
void solve(long long N, long long K) {
COMinit();
for (int i = 1; i <= K; i++) {
ll red = N - K;
ll blue = K;
if (red < i - 1) {
cout << 0 << endl;
continue;
} else if (red == i - 1 && red == 0) {
cout << 1 << endl;
continue;
}
cout << 1LL *
(((red < i + 1 ? 0 : COM(red - 1, i)) % MOD +
(red < i ? 0 : 2 * COM(red - 1, i - 1)) % MOD +
COM(red - 1, i - 2)) %
MOD * COM(blue - 1, i - 1) % MOD) %
MOD
<< endl;
;
}
}
int main() {
long long N;
scanf("%lld", &N);
long long K;
scanf("%lld", &K);
solve(N, K);
return 0;
}
| [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 797,894 | 797,895 | u580402951 | cpp |
p02990 | #include <bits/stdc++.h>
using namespace std;
#define SZ(x) (int)(x.size())
using ll = long long;
using ld = long double;
using P = pair<int, int>;
using vi = vector<int>;
using vvi = vector<vector<int>>;
using vll = vector<ll>;
using vvll = vector<vector<ll>>;
const double eps = 1e-10;
const int MOD = 1000000007;
const int INF = 1000000000;
const ll LINF = 1ll << 50;
template <typename T> void printv(const vector<T> &s) {
for (int i = 0; i < (int)(s.size()); ++i) {
cout << s[i];
if (i == (int)(s.size()) - 1)
cout << endl;
else
cout << " ";
}
}
template <int mod> class Combination {
std::vector<long long> fact, finv, inv;
public:
Combination(int sz) {
fact.resize(sz);
finv.resize(sz);
inv.resize(sz);
fact[0] = 1;
for (int i = 1; i < sz; ++i) {
fact[i] = fact[i - 1] * i % mod;
}
inv[0] = 0;
inv[1] = 1;
for (int i = 2; i < sz; ++i) {
inv[i] = mod - inv[mod % i] * (mod / i) % mod;
}
finv[0] = 1;
for (int i = 1; i < sz; ++i) {
finv[i] = finv[i - 1] * inv[i] % mod;
}
}
long long C(long long n, long long k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return (fact[n] * finv[k] % mod) * finv[n - k] % mod;
}
long long P(long long n, long long k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fact[n] * finv[n - k] % mod;
}
long long H(long long n, long long k) { return this->C(n + k - 1, k); }
long long getfact(int i) { return fact[i]; }
long long getinv(int i) { return inv[i]; }
long long getfinv(int i) { return finv[i]; }
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
Combination<MOD> comb(100000);
ll n, k;
cin >> n >> k;
for (int i = 1; i <= k; ++i) {
cout << comb.C(n - k + 1, i) * comb.C(k - 1, i - 1) << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
#define SZ(x) (int)(x.size())
using ll = long long;
using ld = long double;
using P = pair<int, int>;
using vi = vector<int>;
using vvi = vector<vector<int>>;
using vll = vector<ll>;
using vvll = vector<vector<ll>>;
const double eps = 1e-10;
const int MOD = 1000000007;
const int INF = 1000000000;
const ll LINF = 1ll << 50;
template <typename T> void printv(const vector<T> &s) {
for (int i = 0; i < (int)(s.size()); ++i) {
cout << s[i];
if (i == (int)(s.size()) - 1)
cout << endl;
else
cout << " ";
}
}
template <int mod> class Combination {
std::vector<long long> fact, finv, inv;
public:
Combination(int sz) {
fact.resize(sz);
finv.resize(sz);
inv.resize(sz);
fact[0] = 1;
for (int i = 1; i < sz; ++i) {
fact[i] = fact[i - 1] * i % mod;
}
inv[0] = 0;
inv[1] = 1;
for (int i = 2; i < sz; ++i) {
inv[i] = mod - inv[mod % i] * (mod / i) % mod;
}
finv[0] = 1;
for (int i = 1; i < sz; ++i) {
finv[i] = finv[i - 1] * inv[i] % mod;
}
}
long long C(long long n, long long k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return (fact[n] * finv[k] % mod) * finv[n - k] % mod;
}
long long P(long long n, long long k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fact[n] * finv[n - k] % mod;
}
long long H(long long n, long long k) { return this->C(n + k - 1, k); }
long long getfact(int i) { return fact[i]; }
long long getinv(int i) { return inv[i]; }
long long getfinv(int i) { return finv[i]; }
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
Combination<MOD> comb(100000);
ll n, k;
cin >> n >> k;
for (int i = 1; i <= k; ++i) {
cout << comb.C(n - k + 1, i) * comb.C(k - 1, i - 1) % MOD << endl;
}
}
| [
"expression.operation.binary.add"
] | 797,896 | 797,897 | u334351654 | cpp |
p02990 | #include <algorithm>
#include <assert.h>
#include <bits/stdc++.h>
#include <bitset>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <vector>
using namespace std;
typedef long long ll;
constexpr long long int INFLL = 1001001001001001LL;
constexpr int INF = 1000000007;
const int mod = 1000000007;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
struct mint {
ll x; // typedef long long ll;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const {
mint res(*this);
return res += a;
}
mint operator-(const mint a) const {
mint res(*this);
return res -= a;
}
mint operator*(const mint a) const {
mint res(*this);
return res *= a;
}
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
// for prime mod
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint a) { return (*this) *= a.inv(); }
mint operator/(const mint a) const {
mint res(*this);
return res /= a;
}
};
// mint N;
struct combination {
vector<mint> fact, ifact;
combination(int n) : fact(n + 1), ifact(n + 1) {
assert(n < mod);
fact[0] = 1;
for (int i = 1; i <= n; ++i)
fact[i] = fact[i - 1] * i;
ifact[n] = fact[n].inv();
for (int i = n; i >= 1; --i)
ifact[i - 1] = ifact[i] * i;
}
mint operator()(int n, int k) {
if (k < 0 || k > n)
return 0;
return fact[n] * ifact[k] * ifact[n - k];
}
};
// combination c(N);
// mint ans = c(N,n);
// cout << ans.x << endl;
// -------------------------------------------------------------
int main() {
ll N, K;
cin >> N >> K;
combination c(N - K + 1);
combination c2(K - 1);
for (ll i = 1; i <= K; i++) {
mint ans1, ans2;
ans1 = c(N - K + 1, i);
ans2 = c2(K - 1, i - 1);
cout << ans1.x * ans2.x << endl;
}
return 0;
}
| #include <algorithm>
#include <assert.h>
#include <bits/stdc++.h>
#include <bitset>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <vector>
using namespace std;
typedef long long ll;
constexpr long long int INFLL = 1001001001001001LL;
constexpr int INF = 1000000007;
const int mod = 1000000007;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
struct mint {
ll x; // typedef long long ll;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const {
mint res(*this);
return res += a;
}
mint operator-(const mint a) const {
mint res(*this);
return res -= a;
}
mint operator*(const mint a) const {
mint res(*this);
return res *= a;
}
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
// for prime mod
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint a) { return (*this) *= a.inv(); }
mint operator/(const mint a) const {
mint res(*this);
return res /= a;
}
};
// mint N;
struct combination {
vector<mint> fact, ifact;
combination(int n) : fact(n + 1), ifact(n + 1) {
assert(n < mod);
fact[0] = 1;
for (int i = 1; i <= n; ++i)
fact[i] = fact[i - 1] * i;
ifact[n] = fact[n].inv();
for (int i = n; i >= 1; --i)
ifact[i - 1] = ifact[i] * i;
}
mint operator()(int n, int k) {
if (k < 0 || k > n)
return 0;
return fact[n] * ifact[k] * ifact[n - k];
}
};
// combination c(N);
// mint ans = c(N,n);
// cout << ans.x << endl;
// -------------------------------------------------------------
int main() {
ll N, K;
cin >> N >> K;
combination c(N - K + 1);
combination c2(K - 1);
for (ll i = 1; i <= K; i++) {
mint ans1, ans2;
ans1 = c(N - K + 1, i);
ans2 = c2(K - 1, i - 1);
cout << (ans1.x * ans2.x) % mod << endl;
}
return 0;
}
| [
"expression.operation.binary.add"
] | 797,898 | 797,899 | u550014122 | cpp |
p02990 | #include <algorithm>
#include <assert.h>
#include <bits/stdc++.h>
#include <bitset>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <vector>
using namespace std;
typedef long long ll;
constexpr long long int INFLL = 1001001001001001LL;
constexpr int INF = 1000000007;
const int mod = 1000000007;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
struct mint {
ll x; // typedef long long ll;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const {
mint res(*this);
return res += a;
}
mint operator-(const mint a) const {
mint res(*this);
return res -= a;
}
mint operator*(const mint a) const {
mint res(*this);
return res *= a;
}
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
// for prime mod
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint a) { return (*this) *= a.inv(); }
mint operator/(const mint a) const {
mint res(*this);
return res /= a;
}
};
// mint N;
struct combination {
vector<mint> fact, ifact;
combination(int n) : fact(n + 1), ifact(n + 1) {
assert(n < mod);
fact[0] = 1;
for (int i = 1; i <= n; ++i)
fact[i] = fact[i - 1] * i;
ifact[n] = fact[n].inv();
for (int i = n; i >= 1; --i)
ifact[i - 1] = ifact[i] * i;
}
mint operator()(int n, int k) {
if (k < 0 || k > n)
return 0;
return fact[n] * ifact[k] * ifact[n - k];
}
};
// combination c(N);
// mint ans = c(N,n);
// cout << ans.x << endl;
// -------------------------------------------------------------
int main() {
ll N, K;
cin >> N >> K;
combination c(N - K + 1);
combination c2(K - 1);
for (ll i = 1; i <= K; i++) {
mint ans1, ans2;
ans1 = c(N - K + 1, i);
ans2 = c(K - 1, i - 1);
cout << ans1.x * ans2.x << endl;
}
return 0;
}
| #include <algorithm>
#include <assert.h>
#include <bits/stdc++.h>
#include <bitset>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <vector>
using namespace std;
typedef long long ll;
constexpr long long int INFLL = 1001001001001001LL;
constexpr int INF = 1000000007;
const int mod = 1000000007;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
struct mint {
ll x; // typedef long long ll;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const {
mint res(*this);
return res += a;
}
mint operator-(const mint a) const {
mint res(*this);
return res -= a;
}
mint operator*(const mint a) const {
mint res(*this);
return res *= a;
}
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
// for prime mod
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint a) { return (*this) *= a.inv(); }
mint operator/(const mint a) const {
mint res(*this);
return res /= a;
}
};
// mint N;
struct combination {
vector<mint> fact, ifact;
combination(int n) : fact(n + 1), ifact(n + 1) {
assert(n < mod);
fact[0] = 1;
for (int i = 1; i <= n; ++i)
fact[i] = fact[i - 1] * i;
ifact[n] = fact[n].inv();
for (int i = n; i >= 1; --i)
ifact[i - 1] = ifact[i] * i;
}
mint operator()(int n, int k) {
if (k < 0 || k > n)
return 0;
return fact[n] * ifact[k] * ifact[n - k];
}
};
// combination c(N);
// mint ans = c(N,n);
// cout << ans.x << endl;
// -------------------------------------------------------------
int main() {
ll N, K;
cin >> N >> K;
combination c(N - K + 1);
combination c2(K - 1);
for (ll i = 1; i <= K; i++) {
mint ans1, ans2;
ans1 = c(N - K + 1, i);
ans2 = c2(K - 1, i - 1);
cout << (ans1.x * ans2.x) % mod << endl;
}
return 0;
}
| [
"assignment.value.change",
"identifier.change",
"call.function.change"
] | 797,900 | 797,899 | u550014122 | cpp |
p02990 | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair<int, int> P;
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define repi(i, a, b) for (int i = int(a); i < (b); i++)
#define repr(i, b, a) for (int i = int(b); i >= (a); i--)
#define all(x) x.begin(), x.end()
const ll mod = 1e9 + 7;
const ll INF = 1e9;
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
bool valid(int lx, int ux, int ly, int uy, int x, int y) {
return lx <= x && x < ux && ly <= y && y < uy;
}
ll power(ll x, ll p) {
if (p == 0)
return 1;
ll res = power(x * x % mod, p / 2);
if (p % 2 == 1)
res = res * x % mod;
return res;
}
vector<ll> fact, inv;
ll f(ll a, ll b, ll p) { // a^b mod pを求める
if (b == 0)
return 1;
else if (b % 2 == 0) {
ll d = f(a, b / 2, p); // a^b = a^(2k) = (a^k)^2 k = b / 2
return d * d % mod;
} else {
return a * f(a, b - 1, p) % mod;
}
}
void init(ll n) {
fact.resize(n + 1, 1);
inv.resize(n + 1, 1);
for (int i = 2; i <= n; i++) // nまでの階乗を求める
fact[i] = fact[i - 1] * i % mod;
for (int i = 2; i <= n;
i++) // a^(-1) mod p = a^(p-2) mod p ここをもう少し早くできるぽい
inv[i] = f(fact[i], mod - 2, mod) % mod;
}
ll comb(ll n, ll k) { // n_C_k
if (n < k)
return 0;
return (fact[n] * inv[k] % mod) * inv[n - k] % mod;
}
ll func(ll k, ll i) {
if (k < i)
return 0;
if (i == 1)
return 1;
return comb(i, k - i);
}
int main() {
ll n, k;
cin >> n >> k;
init(2 * n);
repi(i, 1, k + 1) {
ll ans = comb(n - k + 1, i);
ans *= func(k, i);
cout << ans % mod << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair<int, int> P;
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define repi(i, a, b) for (int i = int(a); i < (b); i++)
#define repr(i, b, a) for (int i = int(b); i >= (a); i--)
#define all(x) x.begin(), x.end()
const ll mod = 1e9 + 7;
const ll INF = 1e9;
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
bool valid(int lx, int ux, int ly, int uy, int x, int y) {
return lx <= x && x < ux && ly <= y && y < uy;
}
ll power(ll x, ll p) {
if (p == 0)
return 1;
ll res = power(x * x % mod, p / 2);
if (p % 2 == 1)
res = res * x % mod;
return res;
}
vector<ll> fact, inv;
ll f(ll a, ll b, ll p) { // a^b mod pを求める
if (b == 0)
return 1;
else if (b % 2 == 0) {
ll d = f(a, b / 2, p); // a^b = a^(2k) = (a^k)^2 k = b / 2
return d * d % mod;
} else {
return a * f(a, b - 1, p) % mod;
}
}
void init(ll n) {
fact.resize(n + 1, 1);
inv.resize(n + 1, 1);
for (int i = 2; i <= n; i++) // nまでの階乗を求める
fact[i] = fact[i - 1] * i % mod;
for (int i = 2; i <= n;
i++) // a^(-1) mod p = a^(p-2) mod p ここをもう少し早くできるぽい
inv[i] = f(fact[i], mod - 2, mod) % mod;
}
ll comb(ll n, ll k) { // n_C_k
if (n < k)
return 0;
return (fact[n] * inv[k] % mod) * inv[n - k] % mod;
}
ll func(ll k, ll i) {
if (k < i)
return 0;
if (i == 1)
return 1;
return comb(k - 1, i - 1);
}
int main() {
ll n, k;
cin >> n >> k;
init(2 * n);
repi(i, 1, k + 1) {
ll ans = comb(n - k + 1, i);
ans *= func(k, i);
cout << ans % mod << endl;
}
return 0;
} | [
"call.arguments.change",
"call.arguments.add"
] | 797,901 | 797,902 | u700986952 | cpp |
p02990 | // include
//------------------------------------------
#include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
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();
}
// math
//-------------------------------------------
template <class T> inline T sqr(T x) { return x * x; }
// typedef
//------------------------------------------
typedef long long ll;
typedef long long LL;
typedef vector<long long> VLL;
typedef vector<long long> vll;
typedef pair<long long, long long> pll;
typedef pair<long long, long long> PLL;
// container util
//------------------------------------------
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define VECMAX(x) *max_element(ALL(x))
#define VECMIN(x) *min_element(ALL(x))
#define PB push_back
#define MP make_pair
#define SZ(a) int((a).size())
#define EACH(i, c) \
for (typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define EXIST(s, e) ((s).find(e) != (s).end())
#define SORT(c) sort((c).begin(), (c).end())
// repetition
//------------------------------------------
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define MULTIPLE(i, n, k) for (int i = (k); i < (n); i += k + 1) //倍数ループ
// constant
//------------------------------------------
const double EPS = 1e-10;
const double PI = acos(-1.0);
// clear memory
#define CLR(a) memset((a), 0, sizeof(a))
// debug
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) \
cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" \
<< " " << __FILE__ << endl;
#define SIZEOF(x) sizeof(x) / sizeof(x[0])
const long long INF = 100000000000000;
const long long NINF = -100000000000000;
//----------------search for specific figure--------------------
//--------------------------------------------------------------
// firstが最大値（最小値） , second が index
pair<LL, LL> maxP(vll a, ll size) {
pair<ll, ll> p;
vll::iterator iter = max_element(a.begin(), a.end());
p.first = *iter;
p.second = distance(a.begin(), iter);
return p;
}
pair<LL, LL> minP(vll a, ll size) {
pair<ll, ll> p;
vll::iterator iter = min_element(a.begin(), a.end());
p.first = *iter;
p.second = distance(a.begin(), iter);
return p;
}
ll sumL(vll a, ll size) {
ll sum = 0;
REP(i, size) { sum += a[i]; }
return sum;
}
// aのなかにtがいくつあるか
ll counT(VLL a, ll t) {
sort(a.begin(), a.end());
return upper_bound(a.begin(), a.end(), t) -
lower_bound(a.begin(), a.end(), t);
}
#define COUNT(a, b) counT((a), (b))
#define MAX(x) maxP(x, x.size())
#define MIN(x) minP(x, x.size())
#define SUM(x) sumL(x, x.size())
//-------------------DIVIDE----------------------
// DIV[i][j] は i の j分割数 j == 0 && i != 0 なら 0
//並び順を区別しない
ll DIV[1000 + 1][1000 + 1];
void divide(ll n, ll m) {
DIV[0][0] = 1;
FOR(i, 1, n + 1) { DIV[i][0] = 0; }
REP(i, n + 1) { DIV[i][1] = 1; }
FOR(i, 1, m + 1) {
FOR(t, 0, n + 1) {
if (DIV[t][i] > 0)
continue;
if (t >= i) {
DIV[t][i] = DIV[t - i][i] + DIV[t][i - 1];
} else {
DIV[t][i] = DIV[t][i - 1];
}
}
}
}
#define DIVIDE(a, b) (DIV[a][b] - DIV[a][(b)-1])
//-------要素を見つける-----------
ll search(vll &a, ll n) { // a内のnのindexを返す
std::vector<ll>::iterator iter = std::find(a.begin(), a.end(), n);
size_t index = distance(a.begin(), iter);
return index;
}
//------------素数判定-----------------
//------------素数判定-----------------
vector<bool> IS_PRIME_CONTAINER(1000005, true);
//メモリを圧迫する可能性あり
void IsPrime_Contain(ll num) {
IS_PRIME_CONTAINER[0] = false;
IS_PRIME_CONTAINER[1] = false;
FOR(i, 2, sqrt(num) + 1) {
if (IS_PRIME_CONTAINER[i]) {
FOR(j, 2, num / i + 1) {
if (j * i <= num) {
IS_PRIME_CONTAINER[i * j] = false;
}
}
}
}
}
inline bool IsPrime(ll num) { return IS_PRIME_CONTAINER[num]; }
//---------ベルマンフォード----------
struct E {
ll from, to, cost;
};
ll DIST[100005];
// start と 辺の数 m 辺の情報 x を入力
void shortest(LL s, vector<E> &x, ll m) {
REP(i, 100000) { DIST[i] = INF; }
DIST[s] = 0;
while (1) {
bool t = false;
REP(i, m) {
E h = x[i];
if (DIST[h.from] != INF && DIST[h.to] > DIST[h.from] + h.cost) {
DIST[h.to] = DIST[h.from] + h.cost;
t = true;
}
}
if (!t) {
break;
}
}
}
//----UnionFind-----
class UnionFind {
public:
vll par;
vll rank; // rankが高いほど上の親である
UnionFind(LL N) : par(N), rank(N) {
REP(i, N) par[i] = i;
REP(i, N) rank[i] = 0;
}
~UnionFind() {}
LL root(LL x) {
if (par[x] == x)
return x;
else {
par[x] = root(par[x]);
return par[x];
}
}
void unite(LL x, LL y) {
LL rx = root(x);
LL ry = root(y);
if (rx == ry)
return;
if (rank[rx] < rank[ry]) {
par[rx] = ry; // rankの高い方を親にする
} else {
par[ry] = rx;
if (rank[rx] == rank[ry]) {
// rankがどちらも同じ時、どちらか好きな方を親にしてそのrankを1上げる
rank[rx]++;
}
}
}
bool same(LL x, LL y) {
LL rx = root(x);
LL ry = root(y);
return rx == ry;
}
};
//--------BFS---------
class BFS_shortestDistance {
public:
BFS_shortestDistance(vector<vector<char>> p_, ll h_, ll w_) {
p = p_;
h = h_;
w = w_;
initial_number = h * w * 2;
REP(i, h) {
vector<LL> k(w);
REP(t, w) k[t] = initial_number;
field.push_back(k);
}
}
vector<vector<char>> p;
ll h;
ll w;
ll initial_number; //初期化用数値
vector<vector<LL>> field; //この変数に書き込む
pair<LL, LL> plus(pair<LL, LL> &a, pair<LL, LL> &b) {
pair<LL, LL> p;
p.first = a.first + b.first;
p.second = a.second + b.second;
return p;
}
bool equal(pair<LL, LL> &a, pair<LL, LL> &b) {
return (a.first == b.first && a.second == b.second);
}
bool is_in_field(int h, int w, const pair<LL, LL> &point) {
const int c = point.second;
const int r = point.first;
return (0 <= c && c < w) && (0 <= r && r < h);
}
// fieldの中身を初期化
//最短距離がh*w*2になることはないのでこれで初期化する
void init() {
REP(i, field.size()) {
REP(t, field[i].size()) { field[i][t] = initial_number; }
}
}
// sy , sx はスタート位置の 『INDEX』!!
// syが縦 sx が横
void shortest(ll sy, ll sx) {
//初期化
init();
pair<LL, LL> c[4];
c[0].first = 0;
c[0].second = 1;
c[1].first = 0;
c[1].second = -1;
c[2].first = 1;
c[2].second = 0;
c[3].first = -1;
c[3].second = 0;
queue<pair<LL, LL>> Q;
pair<LL, LL> s;
s.first = sy;
s.second = sx;
field[sy][sx] = 0; //スタート位置のみ0で初期化
Q.push(s);
while (Q.empty() == false) {
pair<LL, LL> now = Q.front();
Q.pop();
for (int u = 0; u < 4; u++) {
pair<LL, LL> x = c[u];
pair<LL, LL> next = plus(now, x);
if (is_in_field(h, w, next)) {
if (p[next.first][next.second] == '.') {
//まだ到達してない ＝＝ field の値が initial_number
if (field[next.first][next.second] == initial_number) {
field[next.first][next.second] = field[now.first][now.second] + 1;
Q.push(next);
} else {
//すでに到達済みである＝＝これ以前にQueueから出てきたpairがすでに
//到達している＝＝すでにfieldの値が最小値であることは明らか;
}
}
}
}
}
}
};
//-----------DP---------------//
// b < a => true , a = b;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
// b > a => true , a = b;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
//-----------MODつきCombination------------//
const int MAX = 1000007;
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;
}
//-----------MAIN------------//
ll P(ll n, ll k) {
ll j = 1;
REP(i, k) { j *= n - i; }
return j;
}
ll C(ll n, ll k) {
ll j = 1;
j *= P(n, k);
j /= P(k, k);
return j;
}
int main() {
LL n, k;
cin >> n >> k;
COMinit();
// cout << P(2,2) << " " << C(1 , 1);
ll ans = 1;
REP(i, k) {
ll in = i + 1;
ans *= COM(k - 1, in - 1) * C(n - k + 1, in);
// debug(COM(n-k+1,in))
// debug(P(k-1,in-1))
ans %= MOD;
cout << ans << endl;
ans = 1;
}
return 0;
}
| // include
//------------------------------------------
#include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
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();
}
// math
//-------------------------------------------
template <class T> inline T sqr(T x) { return x * x; }
// typedef
//------------------------------------------
typedef long long ll;
typedef long long LL;
typedef vector<long long> VLL;
typedef vector<long long> vll;
typedef pair<long long, long long> pll;
typedef pair<long long, long long> PLL;
// container util
//------------------------------------------
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define VECMAX(x) *max_element(ALL(x))
#define VECMIN(x) *min_element(ALL(x))
#define PB push_back
#define MP make_pair
#define SZ(a) int((a).size())
#define EACH(i, c) \
for (typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define EXIST(s, e) ((s).find(e) != (s).end())
#define SORT(c) sort((c).begin(), (c).end())
// repetition
//------------------------------------------
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define MULTIPLE(i, n, k) for (int i = (k); i < (n); i += k + 1) //倍数ループ
// constant
//------------------------------------------
const double EPS = 1e-10;
const double PI = acos(-1.0);
// clear memory
#define CLR(a) memset((a), 0, sizeof(a))
// debug
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) \
cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" \
<< " " << __FILE__ << endl;
#define SIZEOF(x) sizeof(x) / sizeof(x[0])
const long long INF = 100000000000000;
const long long NINF = -100000000000000;
//----------------search for specific figure--------------------
//--------------------------------------------------------------
// firstが最大値（最小値） , second が index
pair<LL, LL> maxP(vll a, ll size) {
pair<ll, ll> p;
vll::iterator iter = max_element(a.begin(), a.end());
p.first = *iter;
p.second = distance(a.begin(), iter);
return p;
}
pair<LL, LL> minP(vll a, ll size) {
pair<ll, ll> p;
vll::iterator iter = min_element(a.begin(), a.end());
p.first = *iter;
p.second = distance(a.begin(), iter);
return p;
}
ll sumL(vll a, ll size) {
ll sum = 0;
REP(i, size) { sum += a[i]; }
return sum;
}
// aのなかにtがいくつあるか
ll counT(VLL a, ll t) {
sort(a.begin(), a.end());
return upper_bound(a.begin(), a.end(), t) -
lower_bound(a.begin(), a.end(), t);
}
#define COUNT(a, b) counT((a), (b))
#define MAX(x) maxP(x, x.size())
#define MIN(x) minP(x, x.size())
#define SUM(x) sumL(x, x.size())
//-------------------DIVIDE----------------------
// DIV[i][j] は i の j分割数 j == 0 && i != 0 なら 0
//並び順を区別しない
ll DIV[1000 + 1][1000 + 1];
void divide(ll n, ll m) {
DIV[0][0] = 1;
FOR(i, 1, n + 1) { DIV[i][0] = 0; }
REP(i, n + 1) { DIV[i][1] = 1; }
FOR(i, 1, m + 1) {
FOR(t, 0, n + 1) {
if (DIV[t][i] > 0)
continue;
if (t >= i) {
DIV[t][i] = DIV[t - i][i] + DIV[t][i - 1];
} else {
DIV[t][i] = DIV[t][i - 1];
}
}
}
}
#define DIVIDE(a, b) (DIV[a][b] - DIV[a][(b)-1])
//-------要素を見つける-----------
ll search(vll &a, ll n) { // a内のnのindexを返す
std::vector<ll>::iterator iter = std::find(a.begin(), a.end(), n);
size_t index = distance(a.begin(), iter);
return index;
}
//------------素数判定-----------------
//------------素数判定-----------------
vector<bool> IS_PRIME_CONTAINER(1000005, true);
//メモリを圧迫する可能性あり
void IsPrime_Contain(ll num) {
IS_PRIME_CONTAINER[0] = false;
IS_PRIME_CONTAINER[1] = false;
FOR(i, 2, sqrt(num) + 1) {
if (IS_PRIME_CONTAINER[i]) {
FOR(j, 2, num / i + 1) {
if (j * i <= num) {
IS_PRIME_CONTAINER[i * j] = false;
}
}
}
}
}
inline bool IsPrime(ll num) { return IS_PRIME_CONTAINER[num]; }
//---------ベルマンフォード----------
struct E {
ll from, to, cost;
};
ll DIST[100005];
// start と 辺の数 m 辺の情報 x を入力
void shortest(LL s, vector<E> &x, ll m) {
REP(i, 100000) { DIST[i] = INF; }
DIST[s] = 0;
while (1) {
bool t = false;
REP(i, m) {
E h = x[i];
if (DIST[h.from] != INF && DIST[h.to] > DIST[h.from] + h.cost) {
DIST[h.to] = DIST[h.from] + h.cost;
t = true;
}
}
if (!t) {
break;
}
}
}
//----UnionFind-----
class UnionFind {
public:
vll par;
vll rank; // rankが高いほど上の親である
UnionFind(LL N) : par(N), rank(N) {
REP(i, N) par[i] = i;
REP(i, N) rank[i] = 0;
}
~UnionFind() {}
LL root(LL x) {
if (par[x] == x)
return x;
else {
par[x] = root(par[x]);
return par[x];
}
}
void unite(LL x, LL y) {
LL rx = root(x);
LL ry = root(y);
if (rx == ry)
return;
if (rank[rx] < rank[ry]) {
par[rx] = ry; // rankの高い方を親にする
} else {
par[ry] = rx;
if (rank[rx] == rank[ry]) {
// rankがどちらも同じ時、どちらか好きな方を親にしてそのrankを1上げる
rank[rx]++;
}
}
}
bool same(LL x, LL y) {
LL rx = root(x);
LL ry = root(y);
return rx == ry;
}
};
//--------BFS---------
class BFS_shortestDistance {
public:
BFS_shortestDistance(vector<vector<char>> p_, ll h_, ll w_) {
p = p_;
h = h_;
w = w_;
initial_number = h * w * 2;
REP(i, h) {
vector<LL> k(w);
REP(t, w) k[t] = initial_number;
field.push_back(k);
}
}
vector<vector<char>> p;
ll h;
ll w;
ll initial_number; //初期化用数値
vector<vector<LL>> field; //この変数に書き込む
pair<LL, LL> plus(pair<LL, LL> &a, pair<LL, LL> &b) {
pair<LL, LL> p;
p.first = a.first + b.first;
p.second = a.second + b.second;
return p;
}
bool equal(pair<LL, LL> &a, pair<LL, LL> &b) {
return (a.first == b.first && a.second == b.second);
}
bool is_in_field(int h, int w, const pair<LL, LL> &point) {
const int c = point.second;
const int r = point.first;
return (0 <= c && c < w) && (0 <= r && r < h);
}
// fieldの中身を初期化
//最短距離がh*w*2になることはないのでこれで初期化する
void init() {
REP(i, field.size()) {
REP(t, field[i].size()) { field[i][t] = initial_number; }
}
}
// sy , sx はスタート位置の 『INDEX』!!
// syが縦 sx が横
void shortest(ll sy, ll sx) {
//初期化
init();
pair<LL, LL> c[4];
c[0].first = 0;
c[0].second = 1;
c[1].first = 0;
c[1].second = -1;
c[2].first = 1;
c[2].second = 0;
c[3].first = -1;
c[3].second = 0;
queue<pair<LL, LL>> Q;
pair<LL, LL> s;
s.first = sy;
s.second = sx;
field[sy][sx] = 0; //スタート位置のみ0で初期化
Q.push(s);
while (Q.empty() == false) {
pair<LL, LL> now = Q.front();
Q.pop();
for (int u = 0; u < 4; u++) {
pair<LL, LL> x = c[u];
pair<LL, LL> next = plus(now, x);
if (is_in_field(h, w, next)) {
if (p[next.first][next.second] == '.') {
//まだ到達してない ＝＝ field の値が initial_number
if (field[next.first][next.second] == initial_number) {
field[next.first][next.second] = field[now.first][now.second] + 1;
Q.push(next);
} else {
//すでに到達済みである＝＝これ以前にQueueから出てきたpairがすでに
//到達している＝＝すでにfieldの値が最小値であることは明らか;
}
}
}
}
}
}
};
//-----------DP---------------//
// b < a => true , a = b;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
// b > a => true , a = b;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
//-----------MODつきCombination------------//
const int MAX = 1000007;
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;
}
//-----------MAIN------------//
ll P(ll n, ll k) {
ll j = 1;
REP(i, k) { j *= n - i; }
return j;
}
ll C(ll n, ll k) {
ll j = 1;
j *= P(n, k);
j /= P(k, k);
return j;
}
int main() {
LL n, k;
cin >> n >> k;
COMinit();
// cout << P(2,2) << " " << C(1 , 1);
ll ans = 1;
REP(i, k) {
ll in = i + 1;
ans *= COM(k - 1, in - 1) * COM(n - k + 1, in);
// debug(COM(n-k+1,in))
// debug(P(k-1,in-1))
ans %= MOD;
cout << ans << endl;
ans = 1;
}
return 0;
}
| [
"assignment.value.change",
"identifier.change",
"call.function.change",
"expression.operation.binary.change"
] | 797,905 | 797,906 | u089668660 | cpp |
p02990 | #include <bits/stdc++.h>
#define l_ength size
const int inf = (1 << 30);
const int mod = 1000000007;
using ll = long long;
using namespace std;
ll memo[2500][2500];
ll comb(int x, int y) {
if (memo[x][y])
return memo[x][y];
if (y == 0 || y == x)
return memo[x][y] = 1;
return memo[x][y] = (comb(x - 1, y) + comb(x - 1, y - 1)) % mod;
}
int main() {
int n, k;
cin >> n >> k;
for (int i = 1; i <= k; ++i) {
cout << comb(k - 1, i - 1) * comb(n - k + 1, i) % mod << endl;
}
return 0;
} | #include <bits/stdc++.h>
#define l_ength size
const int inf = (1 << 30);
const int mod = 1000000007;
using ll = long long;
using namespace std;
ll memo[2500][2500];
ll comb(int x, int y) {
if (x < y || memo[x][y])
return memo[x][y];
if (y == 0 || y == x)
return memo[x][y] = 1;
return memo[x][y] = (comb(x - 1, y) + comb(x - 1, y - 1)) % mod;
}
int main() {
int n, k;
cin >> n >> k;
for (int i = 1; i <= k; ++i) {
cout << comb(k - 1, i - 1) * comb(n - k + 1, i) % mod << endl;
}
return 0;
} | [
"control_flow.branch.if.condition.change"
] | 797,907 | 797,908 | u268977772 | cpp |
p02990 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <vector>
using namespace std;
typedef pair<int, int> P;
typedef long long ll;
ll mod = 1e9 + 7;
ll comb[5001][5001];
int main() {
ll k, n;
cin >> n >> k;
for (int i = 1; i <= 5000; i++) {
for (int j = 0; j <= i; j++) {
if (j == 0 || j == i)
comb[i][j] = 1;
else {
comb[i][j] = comb[i - 1][j - 1] + comb[i - 1][j];
comb[i][j] %= mod;
}
}
}
for (ll i = 1; i <= k; i++) {
if (i > n - i + 1) {
cout << "0" << endl;
continue;
}
ll ans = 1;
ans *= comb[k - 1][i - 1];
ans %= mod;
ans *= comb[n - k + 1][i];
ans %= mod;
cout << ans << endl;
}
return 0;
}
| #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <vector>
using namespace std;
typedef pair<int, int> P;
typedef long long ll;
ll mod = 1e9 + 7;
ll comb[5001][5001];
int main() {
ll k, n;
cin >> n >> k;
for (int i = 0; i <= 5000; i++) {
for (int j = 0; j <= i; j++) {
if (j == 0 || j == i)
comb[i][j] = 1;
else {
comb[i][j] = comb[i - 1][j - 1] + comb[i - 1][j];
comb[i][j] %= mod;
}
}
}
for (ll i = 1; i <= k; i++) {
if (i > n - i + 1 && k != n) {
cout << "0" << endl;
continue;
}
ll ans = 1;
ans *= comb[k - 1][i - 1];
ans %= mod;
ans *= comb[n - k + 1][i];
ans %= mod;
cout << ans << endl;
}
return 0;
}
| [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 797,913 | 797,914 | u790614328 | cpp |
p02990 | #include <algorithm>
#include <iostream>
#include <string>
#define llint long long
#define mod 1000000007
using namespace std;
llint n, k;
const int FACT_MAX = 200005;
llint fact[FACT_MAX], fact_inv[FACT_MAX];
llint modpow(llint a, llint n) {
if (n == 0)
return 1;
if (n % 2) {
return ((a % mod) * (modpow(a, n - 1) % mod)) % mod;
} else {
return modpow((a * a) % mod, n / 2) % mod;
}
}
void make_fact() {
llint val = 1;
fact[0] = 1;
for (int i = 1; i < FACT_MAX; i++) {
val *= i;
val %= mod;
fact[i] = val;
}
fact_inv[FACT_MAX - 1] = modpow(fact[FACT_MAX - 1], mod - 2);
for (int i = FACT_MAX - 2; i >= 0; i--) {
fact_inv[i] = fact_inv[i + 1] * (i + 1) % mod;
}
}
llint comb(llint n, llint k) {
llint ret = 1;
ret *= fact[n];
ret *= fact_inv[k], ret %= mod;
ret *= fact_inv[n - k], ret %= mod;
return ret;
}
int main(void) {
cin >> n >> k;
make_fact();
for (int i = 1; i <= k; i++) {
if (n - k + 1 < 0)
cout << 0 << endl;
else
cout << comb(k - 1, i - 1) * comb(n - k + 1, i) % mod << endl;
}
return 0;
} | #include <algorithm>
#include <iostream>
#include <string>
#define llint long long
#define mod 1000000007
using namespace std;
llint n, k;
const int FACT_MAX = 200005;
llint fact[FACT_MAX], fact_inv[FACT_MAX];
llint modpow(llint a, llint n) {
if (n == 0)
return 1;
if (n % 2) {
return ((a % mod) * (modpow(a, n - 1) % mod)) % mod;
} else {
return modpow((a * a) % mod, n / 2) % mod;
}
}
void make_fact() {
llint val = 1;
fact[0] = 1;
for (int i = 1; i < FACT_MAX; i++) {
val *= i;
val %= mod;
fact[i] = val;
}
fact_inv[FACT_MAX - 1] = modpow(fact[FACT_MAX - 1], mod - 2);
for (int i = FACT_MAX - 2; i >= 0; i--) {
fact_inv[i] = fact_inv[i + 1] * (i + 1) % mod;
}
}
llint comb(llint n, llint k) {
llint ret = 1;
ret *= fact[n];
ret *= fact_inv[k], ret %= mod;
ret *= fact_inv[n - k], ret %= mod;
return ret;
}
int main(void) {
cin >> n >> k;
make_fact();
for (int i = 1; i <= k; i++) {
if (n - k < i - 1)
cout << 0 << endl;
else
cout << comb(k - 1, i - 1) * comb(n - k + 1, i) % mod << endl;
}
return 0;
} | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove",
"identifier.replace.add",
"literal.replace.remove",
"control_flow.branch.if.condition.change",
"misc.off_by_one"
] | 797,917 | 797,918 | u319282133 | cpp |
p02990 | #include <bits/stdc++.h>
using namespace std;
const long long MAX = 510000;
const long long 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(long long n, long long 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() {
long long N, K;
cin >> N >> K;
for (long long i = 1; i <= K; i++) {
COMinit();
long long a = COM(N - K + 1, i);
COMinit();
long long b = COM(K - 1, i - 1);
cout << a * b << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
const long long MAX = 10000;
const long long 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(long long n, long long 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() {
long long N, K;
cin >> N >> K;
for (long long i = 1; i <= K; i++) {
COMinit();
long long a = COM(N - K + 1, i);
COMinit();
long long b = COM(K - 1, i - 1);
cout << a * b % MOD << endl;
}
return 0;
} | [
"literal.number.change",
"variable_declaration.value.change"
] | 797,919 | 797,920 | u523303964 | cpp |
p02990 | #include <bits/stdc++.h>
using namespace std;
const long long MAX = 2010;
const long long 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(long long n, long long 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() {
long long N, K;
cin >> N >> K;
for (long long i = 1; i <= K; i++) {
COMinit();
long long a = COM(N - K + 1, i);
COMinit();
long long b = COM(K - 1, i - 1);
cout << a * b << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
const long long MAX = 10000;
const long long 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(long long n, long long 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() {
long long N, K;
cin >> N >> K;
for (long long i = 1; i <= K; i++) {
COMinit();
long long a = COM(N - K + 1, i);
COMinit();
long long b = COM(K - 1, i - 1);
cout << a * b % MOD << endl;
}
return 0;
} | [
"literal.number.change",
"variable_declaration.value.change"
] | 797,921 | 797,920 | u523303964 | cpp |
p02990 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define sz(x) int(x.size())
using namespace std;
typedef long long ll;
const int MOD = 1000000007;
int main() {
ll n, k, ans = 0;
cin >> n >> k;
vector<vector<ll>> dp(n + 1, vector<ll>(k + 1, 0));
rep(i, n + 1) dp[i][0] = 1;
for (int j = 0; j < k; j++) {
for (int i = 0; i < n; i++) {
dp[i + 1][j + 1] = dp[i][j + 1] + dp[i][j];
dp[i + 1][j + 1] %= MOD;
}
}
for (int i = 1; i <= k; i++) {
ans = dp[n - k + 1][i] * dp[k - 1][i - 1];
cout << ans << endl;
}
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define sz(x) int(x.size())
using namespace std;
typedef long long ll;
const int MOD = 1000000007;
int main() {
ll n, k, ans = 0;
cin >> n >> k;
vector<vector<ll>> dp(n + 1, vector<ll>(k + 1, 0));
rep(i, n + 1) dp[i][0] = 1;
for (int j = 0; j < k; j++) {
for (int i = 0; i < n; i++) {
dp[i + 1][j + 1] = dp[i][j + 1] + dp[i][j];
dp[i + 1][j + 1] %= MOD;
}
}
for (int i = 1; i <= k; i++) {
ans = dp[n - k + 1][i] * dp[k - 1][i - 1];
cout << ans % MOD << endl;
}
return 0;
} | [
"expression.operation.binary.add"
] | 797,931 | 797,932 | u199343957 | cpp |
p02990 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define sz(x) int(x.size())
using namespace std;
typedef long long ll;
const int MOD = 1000000007;
int main() {
int n, k, ans = 0;
cin >> n >> k;
vector<vector<int>> dp(n + 1, vector<int>(k + 1, 0));
rep(i, n + 1) dp[i][0] = 1;
for (int j = 0; j < k; j++) {
for (int i = 0; i < n; i++) {
dp[i + 1][j + 1] = dp[i][j + 1] + dp[i][j];
dp[i + 1][j + 1] %= MOD;
}
}
for (int i = 1; i <= k; i++) {
ans = dp[n - k + 1][i] * dp[k - 1][i - 1];
cout << ans << endl;
}
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define sz(x) int(x.size())
using namespace std;
typedef long long ll;
const int MOD = 1000000007;
int main() {
ll n, k, ans = 0;
cin >> n >> k;
vector<vector<ll>> dp(n + 1, vector<ll>(k + 1, 0));
rep(i, n + 1) dp[i][0] = 1;
for (int j = 0; j < k; j++) {
for (int i = 0; i < n; i++) {
dp[i + 1][j + 1] = dp[i][j + 1] + dp[i][j];
dp[i + 1][j + 1] %= MOD;
}
}
for (int i = 1; i <= k; i++) {
ans = dp[n - k + 1][i] * dp[k - 1][i - 1];
cout << ans % MOD << endl;
}
return 0;
} | [
"variable_declaration.type.change",
"call.arguments.change"
] | 797,933 | 797,932 | u199343957 | cpp |
p02990 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define MOD 1000000007
#define MAX 10000
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, K;
cin >> N >> K;
COMinit();
for (ll i = 1; i <= K; ++i)
cout << COM(N - K + 1, i) * min(i, K - i + 1) % MOD << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define MOD 1000000007
#define MAX 10000
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, K;
cin >> N >> K;
COMinit();
for (ll i = 1; i <= K; ++i)
cout << COM(N - K + 1, i) * COM(K - 1, i - 1) % MOD << endl;
return 0;
} | [
"identifier.change",
"call.function.change",
"io.output.change",
"call.arguments.change",
"call.arguments.add",
"misc.opposites",
"expression.operator.arithmetic.change"
] | 797,934 | 797,935 | u656771711 | cpp |
p02990 | #include <bits/stdc++.h>
using namespace std;
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, K;
cin >> N >> K;
// 前処理
COMinit();
for (int i = 1; i <= K; i++) {
cout << COM(K - 1, i - 1) * COM(N - K + 1, i) << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
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, K;
cin >> N >> K;
// 前処理
COMinit();
for (int i = 1; i <= K; i++) {
cout << (COM(K - 1, i - 1) * COM(N - K + 1, i)) % MOD << endl;
}
} | [
"expression.operation.binary.add"
] | 797,936 | 797,937 | u736788838 | cpp |
p02990 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
static const ll mod = 1000000007;
#define INF (1 << 29)
/* ちゃんと考えて実装して問題なくACできた時嬉しいよ！！ */
ll C[2001][2001];
void pascal_shower() {
for (int i = 0; i <= 2000; i++) {
C[i][0] = 1;
C[i][i] = 1;
}
for (int i = 2; i <= 2000; i++) {
for (int j = 1; j <= i - 1; j++) {
C[i][j] = C[i - 1][j - 1] + C[i - 1][j];
}
}
}
int main(void) {
int n, k;
cin >> n >> k;
pascal_shower();
for (int i = 1; i <= k; i++) {
ll tmp_1 = C[n - k + 1][i] % mod;
ll tmp_2 = C[k - 1][i - 1] % mod;
ll ans = (tmp_1) * (tmp_2) % mod;
cout << ans << "\n";
}
return 0;
}
// 並べる方法色々あるね(順列、数え上げの考え方に慣れたい) | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
static const ll mod = 1000000007;
#define INF (1 << 29)
/* ちゃんと考えて実装して問題なくACできた時嬉しいよ！！ */
ll C[2001][2001];
void pascal_shower() {
for (int i = 0; i <= 2000; i++) {
C[i][0] = 1;
C[i][i] = 1;
}
for (int i = 2; i <= 2000; i++) {
for (int j = 1; j <= i - 1; j++) {
C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % mod;
}
}
}
int main(void) {
int n, k;
cin >> n >> k;
pascal_shower();
for (int i = 1; i <= k; i++) {
ll tmp_1 = C[n - k + 1][i] % mod;
ll tmp_2 = C[k - 1][i - 1] % mod;
ll ans = (tmp_1) * (tmp_2) % mod;
cout << ans << "\n";
}
return 0;
}
// 並べる方法色々あるね(順列、数え上げの考え方に慣れたい) | [
"assignment.change"
] | 797,938 | 797,939 | u900688325 | cpp |
p02990 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (n); i++)
const int MOD = 1e9 + 7;
const int MAX_N = 2000000;
ll inv[MAX_N + 10];
ll fac[MAX_N + 10], facInv[MAX_N + 10];
class MATH {
public:
MATH() {
inverse();
factroial();
}
ll nCk(ll n, ll k) { // n! / k!*(n-k)!
// cout << "nCk " << n << " " << k << endl;
if (k < 0 || k > n)
return 0;
ll ret = fac[n];
(ret *= facInv[k]) %= MOD;
(ret *= facInv[n - k]) %= MOD;
return ret;
}
ll nHk(ll n, ll k) { // nHk = n+k-1 C k = (n+k-1)! / k! * (n-1)!
if (n == 0 && k == 0)
return 1;
ll ret = fac[n + k - 1];
(ret *= facInv[k]) %= MOD;
(ret *= facInv[n - 1]) %= MOD;
return ret;
}
ll nPk(ll n, ll k) { // nPk = n! / (n-k)!
if (k < 0 || k > n)
return 0;
ll ret = fac[n];
(ret *= facInv[n - k]) %= MOD;
return ret;
}
private:
void inverse(void) {
inv[1] = 1;
for (int i = 2; i <= MAX_N; ++i) {
// inv[i] = MOD - (MOD / i) * inv[MOD % i] % MOD;
inv[i] = inv[MOD % i] * (MOD - MOD / i) % MOD;
}
}
void factroial(void) {
fac[0] = facInv[0] = 1;
for (int i = 1; i <= MAX_N; ++i) {
fac[i] = (fac[i - 1] * i) % MOD;
facInv[i] = (facInv[i - 1] * inv[i]) % MOD;
}
}
};
int main(int argc, char const *argv[]) {
int n, k;
cin >> n >> k;
MATH ma;
int b = k, r = n - k;
for (int i = 1; i <= k; ++i) { // b を i 個にわける
int numb = ma.nCk(b - 1, i - 1); // bをi個に分ける (空なし)
int numr =
ma.nCk(r - (i - 1) + i, i); // r - (i - 1) を i+1 個に分ける (空あり)
cout << numb * numr << endl;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (n); i++)
const int MOD = 1e9 + 7;
const int MAX_N = 2000000;
ll inv[MAX_N + 10];
ll fac[MAX_N + 10], facInv[MAX_N + 10];
class MATH {
public:
MATH() {
inverse();
factroial();
}
ll nCk(ll n, ll k) { // n! / k!*(n-k)!
// cout << "nCk " << n << " " << k << endl;
if (k < 0 || k > n)
return 0;
ll ret = fac[n];
(ret *= facInv[k]) %= MOD;
(ret *= facInv[n - k]) %= MOD;
return ret;
}
ll nHk(ll n, ll k) { // nHk = n+k-1 C k = (n+k-1)! / k! * (n-1)!
if (n == 0 && k == 0)
return 1;
ll ret = fac[n + k - 1];
(ret *= facInv[k]) %= MOD;
(ret *= facInv[n - 1]) %= MOD;
return ret;
}
ll nPk(ll n, ll k) { // nPk = n! / (n-k)!
if (k < 0 || k > n)
return 0;
ll ret = fac[n];
(ret *= facInv[n - k]) %= MOD;
return ret;
}
private:
void inverse(void) {
inv[1] = 1;
for (int i = 2; i <= MAX_N; ++i) {
// inv[i] = MOD - (MOD / i) * inv[MOD % i] % MOD;
inv[i] = inv[MOD % i] * (MOD - MOD / i) % MOD;
}
}
void factroial(void) {
fac[0] = facInv[0] = 1;
for (int i = 1; i <= MAX_N; ++i) {
fac[i] = (fac[i - 1] * i) % MOD;
facInv[i] = (facInv[i - 1] * inv[i]) % MOD;
}
}
};
int main(int argc, char const *argv[]) {
int n, k;
cin >> n >> k;
MATH ma;
int b = k, r = n - k;
for (int i = 1; i <= k; ++i) { // b を i 個にわける
ll numb = ma.nCk(b - 1, i - 1); // bをi個に分ける (空なし)
ll numr =
ma.nCk(r - (i - 1) + i, i); // r - (i - 1) を i+1 個に分ける (空あり)
cout << (numb * numr) % MOD << endl;
}
return 0;
}
| [
"variable_declaration.type.change"
] | 797,942 | 797,943 | u029876051 | cpp |
p02990 | #include <algorithm>
#include <bitset>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
#define INF 110000000000
#define MOD 1000000007
typedef long long ll;
typedef pair<ll, int> P;
ll C[2100][2100];
int main() {
for (int i = 1; i < 2100; i++) {
C[i][0] = 1;
}
C[1][1] = 1;
for (int i = 2; i < 2100; i++) {
for (int j = 1; j <= i; j++) {
C[i][j] = C[i - 1][j] + C[i - 1][j - 1];
C[i][j] %= MOD;
}
}
int N, K;
cin >> N >> K;
for (int i = 1; i <= K; i++) {
cout << C[N - K + 1][i] * C[K - 1][i - 1] % MOD << endl;
}
}
| #include <algorithm>
#include <bitset>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
#define INF 110000000000
#define MOD 1000000007
typedef long long ll;
typedef pair<ll, int> P;
ll C[2100][2100];
int main() {
for (int i = 0; i < 2100; i++) {
C[i][0] = 1;
}
C[1][1] = 1;
for (int i = 2; i < 2100; i++) {
for (int j = 1; j <= i; j++) {
C[i][j] = C[i - 1][j] + C[i - 1][j - 1];
C[i][j] %= MOD;
}
}
int N, K;
cin >> N >> K;
for (int i = 1; i <= K; i++) {
cout << C[N - K + 1][i] * C[K - 1][i - 1] % MOD << endl;
}
}
| [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 797,950 | 797,951 | u591914971 | cpp |
p02990 | /*
∫ ∫ ∫
ノヽ
（＿ ）
（＿ ）
（＿＿＿＿＿＿ ）
ヽ(´･ω･)ﾉ
| /
UU
*/
#include <bits/stdc++.h>
typedef long long ll;
using namespace std;
using P = pair<ll, ll>;
typedef vector<int> vi;
const int MOD = (int)1e9 + 7;
const ll INF = 1LL << 60;
const int inf = 1 << 30;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
#define REP(i, n) for (int i = 0; i < (n); i++)
#define FOR(i, s, n) for (int i = s; i < (n); i++)
#define ALL(obj) (obj).begin(), (obj).end() //コンテナじゃないと使えない!!
#define debug(x) cerr << #x << ": " << x << "\n";
#define mp make_pair
template <typename T> ostream &operator<<(ostream &os, vector<T> &V) {
int N = V.size();
REP(i, N) {
os << V[i];
if (i != N - 1)
os << " ";
}
os << "\n";
return os;
}
template <typename T> ostream &operator<<(ostream &os, pair<T, T> const &P) {
os << P.first;
os << " ";
os << P.second;
return os;
}
template <typename T> ostream &operator<<(ostream &os, set<T> &S) {
auto it = S.begin();
while (it != S.end()) {
os << *it;
os << " ";
it++;
}
os << "\n";
return os;
}
template <typename T> ostream &operator<<(ostream &os, deque<T> &q) {
for (auto it = q.begin(); it < q.end(); it++) {
os << *it;
os << " ";
}
os << endl;
return os;
}
const int MAX = 510000;
ll fac[MAX], finv[MAX], inv[MAX];
void init_comb() {
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 comb(ll n, ll r) {
if (n < r || n < 0 || r < 0)
return 0;
return fac[n] * (finv[r] * finv[n - r] % MOD) % MOD;
}
// fixed<<setprecision(10)<<ans<<endl;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N, K;
cin >> N >> K;
init_comb();
int ans;
for (int i = 1; i <= K; i++) {
ans = comb(N - K + 1, i) * comb(K - 1, i - 1);
cout << ans << endl;
}
} | /*
∫ ∫ ∫
ノヽ
（＿ ）
（＿ ）
（＿＿＿＿＿＿ ）
ヽ(´･ω･)ﾉ
| /
UU
*/
#include <bits/stdc++.h>
typedef long long ll;
using namespace std;
using P = pair<ll, ll>;
typedef vector<int> vi;
const int MOD = (int)1e9 + 7;
const ll INF = 1LL << 60;
const int inf = 1 << 30;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
#define REP(i, n) for (int i = 0; i < (n); i++)
#define FOR(i, s, n) for (int i = s; i < (n); i++)
#define ALL(obj) (obj).begin(), (obj).end() //コンテナじゃないと使えない!!
#define debug(x) cerr << #x << ": " << x << "\n";
#define mp make_pair
template <typename T> ostream &operator<<(ostream &os, vector<T> &V) {
int N = V.size();
REP(i, N) {
os << V[i];
if (i != N - 1)
os << " ";
}
os << "\n";
return os;
}
template <typename T> ostream &operator<<(ostream &os, pair<T, T> const &P) {
os << P.first;
os << " ";
os << P.second;
return os;
}
template <typename T> ostream &operator<<(ostream &os, set<T> &S) {
auto it = S.begin();
while (it != S.end()) {
os << *it;
os << " ";
it++;
}
os << "\n";
return os;
}
template <typename T> ostream &operator<<(ostream &os, deque<T> &q) {
for (auto it = q.begin(); it < q.end(); it++) {
os << *it;
os << " ";
}
os << endl;
return os;
}
const int MAX = 510000;
ll fac[MAX], finv[MAX], inv[MAX];
void init_comb() {
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 comb(ll n, ll r) {
if (n < r || n < 0 || r < 0)
return 0;
return fac[n] * (finv[r] * finv[n - r] % MOD) % MOD;
}
// fixed<<setprecision(10)<<ans<<endl;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N, K;
cin >> N >> K;
init_comb();
int ans;
for (int i = 1; i <= K; i++) {
ans = (comb(N - K + 1, i) * comb(K - 1, i - 1)) % MOD;
cout << ans << endl;
}
} | [
"assignment.change"
] | 797,953 | 797,954 | u788137651 | cpp |
p02990 | #include <iostream>
//#include <math.h>
#include <algorithm>
#include <iomanip>
#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>
#define space ' '
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 = 2000;
int n, k;
ll fac[maxn + 1];
ll rfac[maxn + 1];
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 s = pow(x, y / 2);
return (s * s) % mod;
} else {
ll s = pow(x, (y - 1) / 2);
return s * s % mod * x % mod;
}
}
int main() {
cin >> n >> k;
fac[0] = fac[1] = rfac[0] = rfac[1] = 1;
for (ll i = 1; i <= n; i++) {
fac[i] = fac[i - 1] * i % mod;
}
rfac[n] = pow(fac[n], INF - 2);
for (ll i = n; i >= 1; i--) {
rfac[i - 1] = rfac[i] * i % mod;
}
for (ll i = 1; i <= k; i++) {
if (n - k + 1 < i) {
cout << 0 << endl;
continue;
}
ll Vp = fac[n - k + 1] * rfac[i] % mod * rfac[n - k + 1 - i] % mod;
ll ans = ans * (fac[k - 1] * rfac[i - 1] % mod * rfac[k - i] % mod) % mod;
cout << ans << endl;
}
return 0;
}
| #include <iostream>
//#include <math.h>
#include <algorithm>
#include <iomanip>
#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>
#define space ' '
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 = 2000;
int n, k;
ll fac[maxn + 1];
ll rfac[maxn + 1];
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 s = pow(x, y / 2);
return (s * s) % mod;
} else {
ll s = pow(x, (y - 1) / 2);
return s * s % mod * x % mod;
}
}
int main() {
cin >> n >> k;
fac[0] = fac[1] = rfac[0] = rfac[1] = 1;
for (ll i = 1; i <= n; i++) {
fac[i] = fac[i - 1] * i % mod;
}
rfac[n] = pow(fac[n], INF - 2);
for (ll i = n; i >= 1; i--) {
rfac[i - 1] = rfac[i] * i % mod;
}
for (ll i = 1; i <= k; i++) {
if (n - k + 1 < i) {
cout << 0 << endl;
continue;
}
ll Vp = fac[n - k + 1] * rfac[i] % mod * rfac[n - k + 1 - i] % mod;
ll ans = Vp * (fac[k - 1] * rfac[i - 1] % mod * rfac[k - i] % mod) % mod;
cout << ans << endl;
}
return 0;
}
| [
"identifier.change",
"expression.operation.binary.change"
] | 797,959 | 797,960 | u297203024 | cpp |
p02990 | #include <algorithm>
#include <iostream>
#include <list>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef vector<ll> vl;
typedef list<ll> listl;
typedef string str;
#define min(A, B) min(static_cast<ll>(A), static_cast<ll>(B))
#define max(A, B) max(static_cast<ll>(A), static_cast<ll>(B))
#define all(x) (x).begin(), (x).end()
#define mp make_pair
#define rep(i, m) for (ll i = 0, i_max = m; i < i_max; i++)
#define REP(i, b, m) for (ll i = b, i_max = m; i < i_max; i++)
#define rrep(i, m) for (ll i = m; i >= 0; i--)
#define rerep(i, b, e) for (ll i = b; i >= e; i--)
#define MOD 1000000007
#define COMBINATION 2000
#ifdef MOD
class mint {
public:
mint() : v(0) {}
mint(ll x) : v((x + MOD) % MOD) {}
mint operator=(ll r) {
this->v = (r + MOD) % MOD;
return *this;
}
ll v = 0;
};
ostream &operator<<(ostream &os, mint m) { return os << m.v; }
#endif
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return a * b / gcd(a, b); }
void in(ll &I) { cin >> I; }
void in(vl &I) {
for (auto &i : I) {
cin >> i;
}
}
void in(listl &I) {
for (auto &i : I) {
cin >> i;
}
}
void in(str &s) { cin >> s; }
void out(ll O) { cout << O; }
void out(vl &O) {
for (auto &o : O) {
cout << o;
}
}
void rout(bool b, str True, str False) {
if (b)
cout << True.c_str();
else
cout << False.c_str();
}
#ifdef COMBINATION
ll c[COMBINATION][COMBINATION];
#endif
void init() {
#ifdef COMBINATION
c[0][0] = 1;
for (int i = 1; i < COMBINATION; i++) {
c[i][0] = 1;
for (int j = 1; j <= i; j++) {
mint mc = c[i - 1][j - 1] + c[i - 1][j];
c[i][j] = mc.v;
}
}
#endif
}
int main() {
ll k, n;
in(n);
in(k);
init();
for (int i = 1; i <= k; i++) {
mint ans = c[n - k + 1][i] * c[k - 1][i - 1];
cout << ans << endl;
}
return 0;
}
| #include <algorithm>
#include <iostream>
#include <list>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef vector<ll> vl;
typedef list<ll> listl;
typedef string str;
#define min(A, B) min(static_cast<ll>(A), static_cast<ll>(B))
#define max(A, B) max(static_cast<ll>(A), static_cast<ll>(B))
#define all(x) (x).begin(), (x).end()
#define mp make_pair
#define rep(i, m) for (ll i = 0, i_max = m; i < i_max; i++)
#define REP(i, b, m) for (ll i = b, i_max = m; i < i_max; i++)
#define rrep(i, m) for (ll i = m; i >= 0; i--)
#define rerep(i, b, e) for (ll i = b; i >= e; i--)
#define MOD 1000000007
#define COMBINATION 2010
#ifdef MOD
class mint {
public:
mint() : v(0) {}
mint(ll x) : v((x + MOD) % MOD) {}
mint operator=(ll r) {
this->v = (r + MOD) % MOD;
return *this;
}
ll v = 0;
};
ostream &operator<<(ostream &os, mint m) { return os << m.v; }
#endif
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return a * b / gcd(a, b); }
void in(ll &I) { cin >> I; }
void in(vl &I) {
for (auto &i : I) {
cin >> i;
}
}
void in(listl &I) {
for (auto &i : I) {
cin >> i;
}
}
void in(str &s) { cin >> s; }
void out(ll O) { cout << O; }
void out(vl &O) {
for (auto &o : O) {
cout << o;
}
}
void rout(bool b, str True, str False) {
if (b)
cout << True.c_str();
else
cout << False.c_str();
}
#ifdef COMBINATION
ll c[COMBINATION][COMBINATION];
#endif
void init() {
#ifdef COMBINATION
c[0][0] = 1;
for (int i = 1; i < COMBINATION; i++) {
c[i][0] = 1;
for (int j = 1; j <= i; j++) {
mint mc = c[i - 1][j - 1] + c[i - 1][j];
c[i][j] = mc.v;
}
}
#endif
}
int main() {
ll k, n;
in(n);
in(k);
init();
for (int i = 1; i <= k; i++) {
mint ans = c[n - k + 1][i] * c[k - 1][i - 1];
cout << ans << endl;
}
return 0;
}
| [
"preprocessor.define.value.change",
"literal.integer.change"
] | 797,961 | 797,962 | u288035794 | cpp |
p02990 | #include <bits/stdc++.h>
using namespace std;
#define repr(i, a, b) for (int i = a; i < b; i++)
#define rep(i, n) for (int i = 0; i < n; i++)
#define reprrev(i, a, b) for (int i = b - 1; i >= a; i--) // [a, b)
#define reprev(i, n) reprrev(i, 0, n)
typedef long long ll;
typedef unsigned long long ull;
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;
}
const ll mod = 1e9 + 7;
void chmod(ll &M) {
if (M >= mod)
M %= mod;
else if (M < 0) {
M += (abs(M) / mod + 1) * mod;
M %= mod;
}
}
ll modpow(ll x, ll n) {
if (n == 0)
return 1;
ll res = modpow(x, n / 2);
if (n % 2 == 0)
return res * res % mod;
else
return res * res % mod * x % mod;
}
int getl(int i, int N) { return i == 0 ? N - 1 : i - 1; };
int getr(int i, int N) { return i == N - 1 ? 0 : i + 1; };
// 線分 ab の偏角 返り値は[-π, π]
double argument(const pair<double, double> &a, const pair<double, double> &b) {
double ax = a.first, ay = a.second, bx = b.first, by = b.second;
return atan2(by - ay, bx - ax);
}
/* <----------------------------------------------------------------------------------->
*/
/* <----------------------------------------------------------------------------------->
*/
/* <----------------------------------------------------------------------------------->
*/
/* <----------------------------------------------------------------------------------->
*/
const int MAX = 1000005;
// 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() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int n, k;
cin >> n >> k;
COMinit();
repr(i, 1, k + 1) {
if (i > k || n - k - i + 1 < 0)
cout << 0 << endl;
else
cout << COM(k - 1, i - 1) * COM(n - k + 1, i) << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define repr(i, a, b) for (int i = a; i < b; i++)
#define rep(i, n) for (int i = 0; i < n; i++)
#define reprrev(i, a, b) for (int i = b - 1; i >= a; i--) // [a, b)
#define reprev(i, n) reprrev(i, 0, n)
typedef long long ll;
typedef unsigned long long ull;
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;
}
const ll mod = 1e9 + 7;
void chmod(ll &M) {
if (M >= mod)
M %= mod;
else if (M < 0) {
M += (abs(M) / mod + 1) * mod;
M %= mod;
}
}
ll modpow(ll x, ll n) {
if (n == 0)
return 1;
ll res = modpow(x, n / 2);
if (n % 2 == 0)
return res * res % mod;
else
return res * res % mod * x % mod;
}
int getl(int i, int N) { return i == 0 ? N - 1 : i - 1; };
int getr(int i, int N) { return i == N - 1 ? 0 : i + 1; };
// 線分 ab の偏角 返り値は[-π, π]
double argument(const pair<double, double> &a, const pair<double, double> &b) {
double ax = a.first, ay = a.second, bx = b.first, by = b.second;
return atan2(by - ay, bx - ax);
}
/* <----------------------------------------------------------------------------------->
*/
/* <----------------------------------------------------------------------------------->
*/
/* <----------------------------------------------------------------------------------->
*/
/* <----------------------------------------------------------------------------------->
*/
const int MAX = 1000005;
// 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() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int n, k;
cin >> n >> k;
COMinit();
repr(i, 1, k + 1) {
if (i > k || n - k - i + 1 < 0)
cout << 0 << endl;
else
cout << (COM(k - 1, i - 1) * COM(n - k + 1, i)) % mod << endl;
}
return 0;
} | [
"expression.operation.binary.add"
] | 797,969 | 797,970 | u052332717 | cpp |
p02990 | #include <bits/stdc++.h>
#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(i, 0, (n))
#define REPS(i, n) FOR(i, 1, (n) + 1)
#define RREP(i, n) RFOR(i, 0, (n))
#define rng(x) (x).begin(), (x).end()
#define rrng(x) (x).rbegin(), (x).rend()
#define debug(x) cout << #x << " = " << (x) << endl;
#define SORT(x) sort(rng(x))
#define RSORT(x) sort(rrng(x))
#define SUM(x) accumulate(rng(x), 0)
#define fi first
#define se second
#define pb push_back
#define eb emplace_back
#define sz(x) (int)(x).size()
#define bn(x) ((1 << x) - 1)
#define dup(x, y) (((x) + (y)-1) / (y))
#define uni(x) x.erase(unique(rng(x)), x.end())
#define SP << " " <<
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using pii = pair<int, int>;
using tiii = tuple<int, int, int>;
const int mod = 1000000007;
const double EPS = 1e-9;
const int INF = (1 << 30) - 1;
const ll INFLL = (1LL << 62) - 1;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
// cout << fixed << setprecision(10);
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 gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
// const int mod = 1000000007;
struct mint {
ll x;
mint(ll x = 0) : x(x % mod) {}
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const {
mint res(*this);
return res += a;
}
mint operator-(const mint a) const {
mint res(*this);
return res -= a;
}
mint operator*(const mint a) const {
mint res(*this);
return res *= a;
}
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
// for prime mod
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint a) { return (*this) *= a.inv(); }
mint operator/(const mint a) const {
mint res(*this);
return res /= a;
}
};
struct combination {
vector<mint> fact, ifact;
combination(int n) : fact(n + 1), ifact(n + 1) {
fact[0] = 1;
for (int i = 1; i <= n; ++i)
fact[i] = fact[i - 1] * i;
ifact[n] = fact[n].inv();
for (int i = n; i >= 1; --i)
ifact[i - 1] = ifact[i] * i;
}
mint operator()(int n, int k) {
if (k < 0 || k > n)
return 0;
return fact[n] * ifact[k] * ifact[n - k];
}
} comb(100005);
// comb(n,k)ならcomb(n+k+5)とかにしておく
mint f(int n, int k) {
if (n < 0)
return 0;
mint res = comb(n, k);
// nPk = nCk * k!
// res *= comb.fact[k]; // <- nPk求めたいときは必要
return res;
}
// f(n,k).x で nCk か nPk が計算される
int main() {
int n, k;
cin >> n >> k;
for (int i = 1; i <= k; ++i) {
ll ans = f(n - k + 1, i).x * f(k - 1, i - 1).x;
cout << ans << '\n';
}
return 0;
} | #include <bits/stdc++.h>
#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(i, 0, (n))
#define REPS(i, n) FOR(i, 1, (n) + 1)
#define RREP(i, n) RFOR(i, 0, (n))
#define rng(x) (x).begin(), (x).end()
#define rrng(x) (x).rbegin(), (x).rend()
#define debug(x) cout << #x << " = " << (x) << endl;
#define SORT(x) sort(rng(x))
#define RSORT(x) sort(rrng(x))
#define SUM(x) accumulate(rng(x), 0)
#define fi first
#define se second
#define pb push_back
#define eb emplace_back
#define sz(x) (int)(x).size()
#define bn(x) ((1 << x) - 1)
#define dup(x, y) (((x) + (y)-1) / (y))
#define uni(x) x.erase(unique(rng(x)), x.end())
#define SP << " " <<
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using pii = pair<int, int>;
using tiii = tuple<int, int, int>;
const int mod = 1000000007;
const double EPS = 1e-9;
const int INF = (1 << 30) - 1;
const ll INFLL = (1LL << 62) - 1;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
// cout << fixed << setprecision(10);
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 gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
// const int mod = 1000000007;
struct mint {
ll x;
mint(ll x = 0) : x(x % mod) {}
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const {
mint res(*this);
return res += a;
}
mint operator-(const mint a) const {
mint res(*this);
return res -= a;
}
mint operator*(const mint a) const {
mint res(*this);
return res *= a;
}
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
// for prime mod
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint a) { return (*this) *= a.inv(); }
mint operator/(const mint a) const {
mint res(*this);
return res /= a;
}
};
struct combination {
vector<mint> fact, ifact;
combination(int n) : fact(n + 1), ifact(n + 1) {
fact[0] = 1;
for (int i = 1; i <= n; ++i)
fact[i] = fact[i - 1] * i;
ifact[n] = fact[n].inv();
for (int i = n; i >= 1; --i)
ifact[i - 1] = ifact[i] * i;
}
mint operator()(int n, int k) {
if (k < 0 || k > n)
return 0;
return fact[n] * ifact[k] * ifact[n - k];
}
} comb(100005);
// comb(n,k)ならcomb(n+k+5)とかにしておく
mint f(int n, int k) {
if (n < 0)
return 0;
mint res = comb(n, k);
// nPk = nCk * k!
// res *= comb.fact[k]; // <- nPk求めたいときは必要
return res;
}
// f(n,k).x で nCk か nPk が計算される
int main() {
int n, k;
cin >> n >> k;
for (int i = 1; i <= k; ++i) {
mint ans = f(n - k + 1, i).x * f(k - 1, i - 1).x;
cout << (ll)ans.x << '\n';
}
return 0;
} | [
"variable_declaration.type.change"
] | 797,973 | 797,974 | u850516963 | cpp |
p02990 | #include <bits/stdc++.h>
#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(i, 0, (n))
#define REPS(i, n) FOR(i, 1, (n) + 1)
#define RREP(i, n) RFOR(i, 0, (n))
#define rng(x) (x).begin(), (x).end()
#define rrng(x) (x).rbegin(), (x).rend()
#define debug(x) cout << #x << " = " << (x) << endl;
#define SORT(x) sort(rng(x))
#define RSORT(x) sort(rrng(x))
#define SUM(x) accumulate(rng(x), 0)
#define fi first
#define se second
#define pb push_back
#define eb emplace_back
#define sz(x) (int)(x).size()
#define bn(x) ((1 << x) - 1)
#define dup(x, y) (((x) + (y)-1) / (y))
#define uni(x) x.erase(unique(rng(x)), x.end())
#define SP << " " <<
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using pii = pair<int, int>;
using tiii = tuple<int, int, int>;
const int mod = 1000000007;
const double EPS = 1e-9;
const int INF = (1 << 30) - 1;
const ll INFLL = (1LL << 62) - 1;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
// cout << fixed << setprecision(10);
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 gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
// const int mod = 1000000007;
struct mint {
ll x;
mint(ll x = 0) : x(x % mod) {}
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const {
mint res(*this);
return res += a;
}
mint operator-(const mint a) const {
mint res(*this);
return res -= a;
}
mint operator*(const mint a) const {
mint res(*this);
return res *= a;
}
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
// for prime mod
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint a) { return (*this) *= a.inv(); }
mint operator/(const mint a) const {
mint res(*this);
return res /= a;
}
};
struct combination {
vector<mint> fact, ifact;
combination(int n) : fact(n + 1), ifact(n + 1) {
fact[0] = 1;
for (int i = 1; i <= n; ++i)
fact[i] = fact[i - 1] * i;
ifact[n] = fact[n].inv();
for (int i = n; i >= 1; --i)
ifact[i - 1] = ifact[i] * i;
}
mint operator()(int n, int k) {
if (k < 0 || k > n)
return 0;
return fact[n] * ifact[k] * ifact[n - k];
}
} comb(100005);
// comb(n,k)ならcomb(n+k+5)とかにしておく
mint f(int n, int k) {
if (n < 0)
return 0;
mint res = comb(n, k);
// nPk = nCk * k!
// res *= comb.fact[k]; // <- nPk求めたいときは必要
return res;
}
// f(n,k).x で nCk か nPk が計算される
int main() {
int n, k;
cin >> n >> k;
FOR(i, 1, k + 1) {
ll ans = f(n - k + 1, i).x * f(k - 1, i - 1).x;
printf("%d\n", ans);
}
return 0;
} | #include <bits/stdc++.h>
#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(i, 0, (n))
#define REPS(i, n) FOR(i, 1, (n) + 1)
#define RREP(i, n) RFOR(i, 0, (n))
#define rng(x) (x).begin(), (x).end()
#define rrng(x) (x).rbegin(), (x).rend()
#define debug(x) cout << #x << " = " << (x) << endl;
#define SORT(x) sort(rng(x))
#define RSORT(x) sort(rrng(x))
#define SUM(x) accumulate(rng(x), 0)
#define fi first
#define se second
#define pb push_back
#define eb emplace_back
#define sz(x) (int)(x).size()
#define bn(x) ((1 << x) - 1)
#define dup(x, y) (((x) + (y)-1) / (y))
#define uni(x) x.erase(unique(rng(x)), x.end())
#define SP << " " <<
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using pii = pair<int, int>;
using tiii = tuple<int, int, int>;
const int mod = 1000000007;
const double EPS = 1e-9;
const int INF = (1 << 30) - 1;
const ll INFLL = (1LL << 62) - 1;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
// cout << fixed << setprecision(10);
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 gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
// const int mod = 1000000007;
struct mint {
ll x;
mint(ll x = 0) : x(x % mod) {}
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const {
mint res(*this);
return res += a;
}
mint operator-(const mint a) const {
mint res(*this);
return res -= a;
}
mint operator*(const mint a) const {
mint res(*this);
return res *= a;
}
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
// for prime mod
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint a) { return (*this) *= a.inv(); }
mint operator/(const mint a) const {
mint res(*this);
return res /= a;
}
};
struct combination {
vector<mint> fact, ifact;
combination(int n) : fact(n + 1), ifact(n + 1) {
fact[0] = 1;
for (int i = 1; i <= n; ++i)
fact[i] = fact[i - 1] * i;
ifact[n] = fact[n].inv();
for (int i = n; i >= 1; --i)
ifact[i - 1] = ifact[i] * i;
}
mint operator()(int n, int k) {
if (k < 0 || k > n)
return 0;
return fact[n] * ifact[k] * ifact[n - k];
}
} comb(100005);
// comb(n,k)ならcomb(n+k+5)とかにしておく
mint f(int n, int k) {
if (n < 0)
return 0;
mint res = comb(n, k);
// nPk = nCk * k!
// res *= comb.fact[k]; // <- nPk求めたいときは必要
return res;
}
// f(n,k).x で nCk か nPk が計算される
int main() {
int n, k;
cin >> n >> k;
FOR(i, 1, k + 1) {
mint ans = f(n - k + 1, i).x * f(k - 1, i - 1).x;
printf("%d\n", ans);
}
return 0;
} | [
"variable_declaration.type.change"
] | 797,975 | 797,976 | u850516963 | cpp |
p02990 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long LL;
typedef unsigned long long ULL;
#define MEM(a, b) memset((a), (b), sizeof(a))
const LL INF = 1e9 + 7;
const int N = 2e3 + 10;
LL dp[N][N];
void init() {
for (int i = 1; i < N; i++)
dp[i][0] = dp[i][i] = 1;
for (int i = 1; i < N; i++) {
for (int j = 1; j < i; j++) {
dp[i][j] = dp[i - 1][j] + dp[i - 1][j - 1];
if (dp[i][j] >= INF)
dp[i][j] -= INF;
}
}
}
int main() {
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
int n, k;
cin >> n >> k;
init();
for (int i = 1; i <= k; i++) {
printf("%lld\n", dp[n - k + 1][i] * dp[k - 1][i - 1] % INF);
}
return 0;
} | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long LL;
typedef unsigned long long ULL;
#define MEM(a, b) memset((a), (b), sizeof(a))
const LL INF = 1e9 + 7;
const int N = 2e3 + 10;
LL dp[N][N];
void init() {
for (int i = 0; i < N; i++)
dp[i][0] = dp[i][i] = 1;
for (int i = 1; i < N; i++) {
for (int j = 1; j < i; j++) {
dp[i][j] = dp[i - 1][j] + dp[i - 1][j - 1];
if (dp[i][j] >= INF)
dp[i][j] -= INF;
}
}
}
int main() {
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
int n, k;
cin >> n >> k;
init();
for (int i = 1; i <= k; i++) {
printf("%lld\n", dp[n - k + 1][i] * dp[k - 1][i - 1] % INF);
}
return 0;
} | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 797,979 | 797,980 | u861345985 | cpp |
p02990 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
typedef long long ll;
constexpr int mod = 1e9 + 7;
int comb[2010][2010];
void init(int n) {
comb[0][0] = 1;
rep(i, n) {
rep(j, i + 1) {
comb[i + 1][j] += comb[i][j];
comb[i + 1][j] %= mod;
comb[i + 1][j + 1] += comb[i][j];
comb[i + 1][j + 1] %= mod;
}
}
}
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << setprecision(20);
int n, k;
cin >> n >> k;
init(2005);
const int num_red = n - k;
for (int i = 1; i <= k; ++i) {
int c_blue = comb[k - 1][i - 1];
int c_red = comb[num_red + 1][i];
ll ans = c_blue * c_red;
ans %= mod;
cout << ans << endl;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
typedef long long ll;
constexpr int mod = 1e9 + 7;
ll comb[2010][2010];
void init(int n) {
comb[0][0] = 1;
rep(i, n) {
rep(j, i + 1) {
comb[i + 1][j] += comb[i][j];
comb[i + 1][j] %= mod;
comb[i + 1][j + 1] += comb[i][j];
comb[i + 1][j + 1] %= mod;
}
}
}
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << setprecision(20);
int n, k;
cin >> n >> k;
init(2005);
const int num_red = n - k;
for (int i = 1; i <= k; ++i) {
ll c_blue = comb[k - 1][i - 1];
ll c_red = comb[num_red + 1][i];
ll ans = c_blue * c_red;
ans %= mod;
cout << ans << endl;
}
return 0;
}
| [
"variable_declaration.type.change"
] | 797,983 | 797,984 | u292106243 | cpp |
p02990 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (long long i = 0; i < (long long)(n); i++)
typedef long long ll;
typedef pair<ll, ll> P;
using vi = vector<ll>;
using vvi = vector<vector<ll>>;
using vc = vector<char>;
using vvc = vector<vector<char>>;
const int inf = 1000000007;
const int mod = 1000000007;
void chmin(auto &a, auto b) {
if (b < a)
a = b;
}
void chmax(auto &a, auto b) {
if (a < b)
a = b;
}
ll modpower(ll a, ll b) { // aのb乗
ll ans = 1;
while (b > 0) {
a %= mod;
if ((b & 1) == 1) {
ans = ans * a % mod;
}
b >>= 1;
a *= a;
}
return ans;
}
ll modfacts(ll a) { // aの階乗
ll ans = 1;
for (ll i = 2; i <= a; i++)
ans = ans * i % mod;
return ans;
}
ll inv(ll a) { // aの逆元
return modpower(a, mod - 2);
}
ll modcom(ll a, ll b) { // aCb
if (b > a)
return 0;
if (a < 0 || b < 0)
return 0;
if (b * 2 > a)
b = a - b;
ll ans = inv(modfacts(b));
rep(i, b) ans = ans * (a - i) % mod;
return ans;
}
int main() {
int n, k;
cin >> n >> k;
rep(i, k) cout << modcom(n - k + 1, i + 1) * modcom(k + i, i) % mod << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (long long i = 0; i < (long long)(n); i++)
typedef long long ll;
typedef pair<ll, ll> P;
using vi = vector<ll>;
using vvi = vector<vector<ll>>;
using vc = vector<char>;
using vvc = vector<vector<char>>;
const int inf = 1000000007;
const int mod = 1000000007;
void chmin(auto &a, auto b) {
if (b < a)
a = b;
}
void chmax(auto &a, auto b) {
if (a < b)
a = b;
}
ll modpower(ll a, ll b) { // aのb乗
ll ans = 1;
while (b > 0) {
a %= mod;
if ((b & 1) == 1) {
ans = ans * a % mod;
}
b >>= 1;
a *= a;
}
return ans;
}
ll modfacts(ll a) { // aの階乗
ll ans = 1;
for (ll i = 2; i <= a; i++)
ans = ans * i % mod;
return ans;
}
ll inv(ll a) { // aの逆元
return modpower(a, mod - 2);
}
ll modcom(ll a, ll b) { // aCb
if (b > a)
return 0;
if (a < 0 || b < 0)
return 0;
if (b * 2 > a)
b = a - b;
ll ans = inv(modfacts(b));
rep(i, b) ans = ans * (a - i) % mod;
return ans;
}
int main() {
int n, k;
cin >> n >> k;
rep(i, k) cout << modcom(n - k + 1, i + 1) * modcom(k - 1, i) % mod << endl;
}
| [] | 797,985 | 797,986 | u422633119 | cpp |
p02990 |
//けんちょんさんに感謝！！！！！！！！！！！（2回目）
// http://drken1215.hatenablog.com/entry/2019/06/30/183400
#include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#define rep(i, n) for (long long i = 0; (i) < (n); (i)++)
using namespace std;
using ll = long long;
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 * v;
swap(a, b);
u -= t * v;
swap(a, b);
}
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;
}
};
template <class T> struct BiCoef {
vector<T> fact_, inv_, finv_;
constexpr BiCoef() {}
constexpr BiCoef(int n) noexcept : fact_(n, 1), inv_(n, 1), finv_(n, 1) {
init(n);
}
constexpr void init(int n) noexcept {
fact_.assign(n, 1), inv_.assign(n, 1), finv_.assign(n, 1);
int MOD = fact_[0].getmod();
for (int i = 2; i < n; i++) {
fact_[i] = fact_[i - 1] * i;
inv_[i] = -inv_[MOD % i] * (MOD / i);
finv_[i] = finv_[i - 1] * inv_[i];
}
}
constexpr T com(int n, int k) const noexcept {
if (n < k || n < 0 || k < 0)
return 0;
return fact_[n] * finv_[k] * finv_[n - k];
}
constexpr T fact(int n) const noexcept {
if (n < 0)
return 0;
return fact_[n];
}
constexpr T inv(int n) const noexcept {
if (n < 0)
return 0;
return inv_[n];
}
constexpr T finv(int n) const noexcept {
if (n < 0)
return 0;
return finv_[n];
}
};
const int MOD = 10000000007;
using mint = Fp<MOD>;
BiCoef<mint> bc;
int main() {
int N, K;
cin >> N >> K;
bc.init(110000);
for (int k = 1; k <= K; ++k)
cout << bc.com(K - 1, k - 1) * bc.com(N - K + 1, k) << endl;
}
|
//けんちょんさんに感謝！！！！！！！！！！！（2回目）
// http://drken1215.hatenablog.com/entry/2019/06/30/183400
#include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#define rep(i, n) for (long long i = 0; (i) < (n); (i)++)
using namespace std;
using ll = long long;
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 * v;
swap(a, b);
u -= t * v;
swap(a, b);
}
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;
}
};
template <class T> struct BiCoef {
vector<T> fact_, inv_, finv_;
constexpr BiCoef() {}
constexpr BiCoef(int n) noexcept : fact_(n, 1), inv_(n, 1), finv_(n, 1) {
init(n);
}
constexpr void init(int n) noexcept {
fact_.assign(n, 1), inv_.assign(n, 1), finv_.assign(n, 1);
int MOD = fact_[0].getmod();
for (int i = 2; i < n; i++) {
fact_[i] = fact_[i - 1] * i;
inv_[i] = -inv_[MOD % i] * (MOD / i);
finv_[i] = finv_[i - 1] * inv_[i];
}
}
constexpr T com(int n, int k) const noexcept {
if (n < k || n < 0 || k < 0)
return 0;
return fact_[n] * finv_[k] * finv_[n - k];
}
constexpr T fact(int n) const noexcept {
if (n < 0)
return 0;
return fact_[n];
}
constexpr T inv(int n) const noexcept {
if (n < 0)
return 0;
return inv_[n];
}
constexpr T finv(int n) const noexcept {
if (n < 0)
return 0;
return finv_[n];
}
};
const int MOD = 1000000007;
using mint = Fp<MOD>;
BiCoef<mint> bc;
int main() {
int N, K;
cin >> N >> K;
bc.init(110000);
for (int k = 1; k <= K; ++k)
cout << bc.com(K - 1, k - 1) * bc.com(N - K + 1, k) << endl;
}
| [
"literal.number.change",
"variable_declaration.value.change"
] | 797,989 | 797,990 | u378155378 | cpp |
p02990 | #include <bits/stdc++.h>
#define rep(i, x, N) for (int i = x; i < (N); i++)
#define swap(a, b) (a += b, b = a - b, a -= b)
using namespace std;
typedef long long ll;
const ll mod = 1000000007;
ll combi[2001][2001] = {0};
int main() {
int n, r;
cin >> n >> r;
rep(i, 0, 2001) {
rep(j, 0, 2001) {
if (i == j || j == 0) {
combi[i][j] = 1;
} else if (j > i) {
combi[i][j] = 0;
} else {
combi[i][j] = (combi[i - 1][j - 1] + combi[i - 1][j]) % mod;
}
}
}
rep(i, 1, r + 1) {
cout << combi[n - r + 1][i] * combi[r - 1][i - 1] << endl;
}
}
| #include <bits/stdc++.h>
#define rep(i, x, N) for (int i = x; i < (N); i++)
#define swap(a, b) (a += b, b = a - b, a -= b)
using namespace std;
typedef long long ll;
const ll mod = 1000000007;
ll combi[2001][2001] = {0};
int main() {
int n, r;
cin >> n >> r;
rep(i, 0, 2001) {
rep(j, 0, 2001) {
if (i == j || j == 0) {
combi[i][j] = 1;
} else if (j > i) {
combi[i][j] = 0;
} else {
combi[i][j] = (combi[i - 1][j - 1] + combi[i - 1][j]) % mod;
}
}
}
rep(i, 1, r + 1) {
cout << combi[n - r + 1][i] * combi[r - 1][i - 1] % mod << endl;
}
}
| [
"expression.operation.binary.add"
] | 797,993 | 797,994 | u466393447 | cpp |
p02986 | /*input
*/
#include <bits/stdc++.h>
using namespace std;
#define all(a) a.begin(), a.end()
#define ff first
#define ss second
#define pb push_back
using ll = long long;
using pii = pair<ll, ll>;
template <typename T> using V = vector<T>;
// dist(a, b) = D(a) + D(b) - 2 * D(L)
// Traverse the tree using a DFS. For current node store the following values:
// freq_till[i] - denotes the frequency of color i from root till current node
// sum_till[i] - denotes the sum of weights of color i from root till current
// node
const int MAXN = 1e5 + 10, LOG = log2(MAXN) + 2;
typedef struct {
int x, y, u, v;
} Query;
vector<pair<int, pii>> adj[MAXN];
vector<int> qry_idx[MAXN];
Query qrs[MAXN];
ll sum_till[MAXN], freq_till[MAXN], ans[MAXN];
int dep[MAXN], up[LOG][MAXN];
int N, Q;
void dfslca(int cur, int par) {
up[0][cur] = par;
for (int i = 1; i < LOG; ++i)
up[i][cur] = up[i - 1][up[i - 1][cur]];
for (auto nxt : adj[cur])
if (nxt.ff != par) {
dep[nxt.ff] = dep[cur] + 1;
dfslca(nxt.ff, cur);
}
}
int getlca(int u, int v) {
if (dep[u] > dep[v])
swap(u, v);
for (int i = LOG - 1; i >= 0; --i)
if (dep[v] - (1 << i) >= dep[u])
v = up[i][v];
if (u == v)
return u;
for (int i = LOG - 1; i >= 0; --i)
if (up[i][u] != up[i][v])
u = up[i][u], v = up[i][v];
return up[0][u];
}
void dfs(int cur, int par, ll tsum) {
for (int i : qry_idx[cur]) {
ll add = 1;
if (i < 0)
add = 2;
i = abs(i);
ll sum = tsum - sum_till[qrs[i].x] + (freq_till[qrs[i].x] * qrs[i].y);
ans[i] += add * sum;
}
for (auto nxt : adj[cur]) {
if (nxt.ff == par)
continue;
++freq_till[nxt.ss.ff];
sum_till[nxt.ss.ff] += nxt.ss.ss;
dfs(nxt.ff, cur, tsum + nxt.ss.ss);
sum_till[nxt.ss.ff] -= nxt.ss.ss;
--freq_till[nxt.ss.ff];
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> N >> Q;
for (int i = 1; i < N; ++i) {
int a, b, c, d;
cin >> a >> b >> c >> d;
adj[a].pb({b, {c, d}});
adj[b].pb({a, {c, d}});
}
dfslca(1, 0);
for (int i = 1; i <= Q; ++i) {
cin >> qrs[i].x >> qrs[i].y >> qrs[i].u >> qrs[i].v;
int L = getlca(qrs[i].u, qrs[i].v);
// cerr << L << '\n';
qry_idx[qrs[i].u].pb(i);
qry_idx[qrs[i].v].pb(i);
qry_idx[L].pb(-i);
}
dfs(1, 0, 0LL);
for (int i = 1; i <= Q; ++i) {
cout << ans[i] << '\n';
}
return 0;
} | /*input
*/
#include <bits/stdc++.h>
using namespace std;
#define all(a) a.begin(), a.end()
#define ff first
#define ss second
#define pb push_back
using ll = long long;
using pii = pair<int, int>;
template <typename T> using V = vector<T>;
// dist(a, b) = D(a) + D(b) - 2 * D(L)
// Traverse the tree using a DFS. For current node store the following values:
// freq_till[i] - denotes the frequency of color i from root till current node
// sum_till[i] - denotes the sum of weights of color i from root till current
// node
const int MAXN = 1e5 + 10, LOG = log2(MAXN) + 2;
typedef struct {
int x, y, u, v;
} Query;
vector<pair<int, pii>> adj[MAXN];
vector<int> qry_idx[MAXN];
Query qrs[MAXN];
int sum_till[MAXN], freq_till[MAXN], ans[MAXN];
int dep[MAXN], up[LOG][MAXN];
int N, Q;
void dfslca(int cur, int par) {
up[0][cur] = par;
for (int i = 1; i < LOG; ++i)
up[i][cur] = up[i - 1][up[i - 1][cur]];
for (auto nxt : adj[cur])
if (nxt.ff != par) {
dep[nxt.ff] = dep[cur] + 1;
dfslca(nxt.ff, cur);
}
}
int getlca(int u, int v) {
if (dep[u] > dep[v])
swap(u, v);
for (int i = LOG - 1; i >= 0; --i)
if (dep[v] - (1 << i) >= dep[u])
v = up[i][v];
if (u == v)
return u;
for (int i = LOG - 1; i >= 0; --i)
if (up[i][u] != up[i][v])
u = up[i][u], v = up[i][v];
return up[0][u];
}
void dfs(int cur, int par, ll tsum) {
for (int i : qry_idx[cur]) {
ll add = 1;
if (i < 0)
add = -2;
i = abs(i);
ll sum = tsum - sum_till[qrs[i].x] + (freq_till[qrs[i].x] * qrs[i].y);
ans[i] += add * sum;
}
for (auto nxt : adj[cur]) {
if (nxt.ff == par)
continue;
++freq_till[nxt.ss.ff];
sum_till[nxt.ss.ff] += nxt.ss.ss;
dfs(nxt.ff, cur, tsum + nxt.ss.ss);
sum_till[nxt.ss.ff] -= nxt.ss.ss;
--freq_till[nxt.ss.ff];
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> N >> Q;
for (int i = 1; i < N; ++i) {
int a, b, c, d;
cin >> a >> b >> c >> d;
adj[a].pb({b, {c, d}});
adj[b].pb({a, {c, d}});
}
dfslca(1, 0);
for (int i = 1; i <= Q; ++i) {
cin >> qrs[i].x >> qrs[i].y >> qrs[i].u >> qrs[i].v;
int L = getlca(qrs[i].u, qrs[i].v);
// cerr << L << '\n';
qry_idx[qrs[i].u].pb(i);
qry_idx[qrs[i].v].pb(i);
qry_idx[L].pb(-i);
}
dfs(1, 0, 0LL);
for (int i = 1; i <= Q; ++i) {
cout << ans[i] << '\n';
}
return 0;
} | [
"variable_declaration.type.change",
"expression.operation.unary.arithmetic.add"
] | 798,003 | 798,004 | u704703586 | cpp |
p02986 | /*input
*/
#include <bits/stdc++.h>
using namespace std;
#define all(a) a.begin(), a.end()
#define ff first
#define ss second
#define pb push_back
using ll = long long;
using pii = pair<ll, ll>;
template <typename T> using V = vector<T>;
// dist(a, b) = D(a) + D(b) - 2 * D(L)
// Traverse the tree using a DFS. For current node store the following values:
// freq_till[i] - denotes the frequency of color i from root till current node
// sum_till[i] - denotes the sum of weights of color i from root till current
// node
const int MAXN = 1e5 + 10, LOG = log2(MAXN) + 2;
typedef struct {
int x, y, u, v;
} Query;
vector<pair<int, pii>> adj[MAXN];
vector<int> qry_idx[MAXN];
Query qrs[MAXN];
ll sum_till[MAXN], freq_till[MAXN], ans[MAXN];
int dep[MAXN], up[LOG][MAXN];
int N, Q;
void dfslca(int cur, int par) {
up[0][cur] = par;
for (int i = 1; i < LOG; ++i)
up[i][cur] = up[i - 1][up[i - 1][cur]];
for (auto nxt : adj[cur])
if (nxt.ff != par) {
dep[nxt.ff] = dep[cur] + 1;
dfslca(nxt.ff, cur);
}
}
int getlca(int u, int v) {
if (dep[u] > dep[v])
swap(u, v);
for (int i = LOG - 1; i >= 0; --i)
if (dep[v] - (1 << i) >= dep[u])
v = up[i][v];
if (u == v)
return u;
for (int i = LOG - 1; i >= 0; --i)
if (up[i][u] != up[i][v])
u = up[i][u], v = up[i][v];
return up[0][u];
}
void dfs(int cur, int par, ll tsum) {
for (int i : qry_idx[cur]) {
ll add = 1;
if (i < 0)
add = 2;
i = abs(i);
ll sum = tsum - sum_till[qrs[i].x] + (freq_till[qrs[i].x] * qrs[i].y);
ans[i] += add * sum;
}
for (auto nxt : adj[cur]) {
if (nxt.ff == par)
continue;
++freq_till[nxt.ss.ff];
sum_till[nxt.ss.ff] += nxt.ss.ss;
dfs(nxt.ff, cur, tsum + nxt.ss.ss);
sum_till[nxt.ss.ff] -= nxt.ss.ss;
--freq_till[nxt.ss.ff];
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> N >> Q;
for (int i = 1; i < N; ++i) {
int a, b, c, d;
cin >> a >> b >> c >> d;
adj[a].pb({b, {c, d}});
adj[b].pb({a, {c, d}});
}
dfslca(1, 0);
for (int i = 1; i <= Q; ++i) {
cin >> qrs[i].x >> qrs[i].y >> qrs[i].u >> qrs[i].v;
int L = getlca(qrs[i].u, qrs[i].v);
// cerr << L << '\n';
qry_idx[qrs[i].u].pb(i);
qry_idx[qrs[i].v].pb(i);
qry_idx[L].pb(-i);
}
dfs(1, 0, 0LL);
for (int i = 1; i <= Q; ++i) {
cout << ans[i] << '\n';
}
return 0;
} | /*input
*/
#include <bits/stdc++.h>
using namespace std;
#define all(a) a.begin(), a.end()
#define ff first
#define ss second
#define pb push_back
using ll = long long;
using pii = pair<int, int>;
template <typename T> using V = vector<T>;
// dist(a, b) = D(a) + D(b) - 2 * D(L)
// Traverse the tree using a DFS. For current node store the following values:
// freq_till[i] - denotes the frequency of color i from root till current node
// sum_till[i] - denotes the sum of weights of color i from root till current
// node
const int MAXN = 1e5 + 10, LOG = log2(MAXN) + 2;
typedef struct {
int x, y, u, v;
} Query;
vector<pair<int, pii>> adj[MAXN];
vector<int> qry_idx[MAXN];
Query qrs[MAXN];
ll sum_till[MAXN], freq_till[MAXN], ans[MAXN];
int dep[MAXN], up[LOG][MAXN];
int N, Q;
void dfslca(int cur, int par) {
up[0][cur] = par;
for (int i = 1; i < LOG; ++i)
up[i][cur] = up[i - 1][up[i - 1][cur]];
for (auto nxt : adj[cur])
if (nxt.ff != par) {
dep[nxt.ff] = dep[cur] + 1;
dfslca(nxt.ff, cur);
}
}
int getlca(int u, int v) {
if (dep[u] > dep[v])
swap(u, v);
for (int i = LOG - 1; i >= 0; --i)
if (dep[v] - (1 << i) >= dep[u])
v = up[i][v];
if (u == v)
return u;
for (int i = LOG - 1; i >= 0; --i)
if (up[i][u] != up[i][v])
u = up[i][u], v = up[i][v];
return up[0][u];
}
void dfs(int cur, int par, ll tsum) {
for (int i : qry_idx[cur]) {
ll add = 1;
if (i < 0)
add = -2;
i = abs(i);
ll sum = tsum - sum_till[qrs[i].x] + (freq_till[qrs[i].x] * qrs[i].y);
ans[i] += add * sum;
}
for (auto nxt : adj[cur]) {
if (nxt.ff == par)
continue;
++freq_till[nxt.ss.ff];
sum_till[nxt.ss.ff] += nxt.ss.ss;
dfs(nxt.ff, cur, tsum + nxt.ss.ss);
sum_till[nxt.ss.ff] -= nxt.ss.ss;
--freq_till[nxt.ss.ff];
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> N >> Q;
for (int i = 1; i < N; ++i) {
int a, b, c, d;
cin >> a >> b >> c >> d;
adj[a].pb({b, {c, d}});
adj[b].pb({a, {c, d}});
}
dfslca(1, 0);
for (int i = 1; i <= Q; ++i) {
cin >> qrs[i].x >> qrs[i].y >> qrs[i].u >> qrs[i].v;
int L = getlca(qrs[i].u, qrs[i].v);
// cerr << L << '\n';
qry_idx[qrs[i].u].pb(i);
qry_idx[qrs[i].v].pb(i);
qry_idx[L].pb(-i);
}
dfs(1, 0, 0LL);
for (int i = 1; i <= Q; ++i) {
cout << ans[i] << '\n';
}
return 0;
} | [
"expression.operation.unary.arithmetic.add"
] | 798,003 | 798,005 | u704703586 | cpp |
p02986 | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define pii pair<int, int>
#define mp make_pair
int n, q;
struct edge {
int v, c, w;
edge(int vv, int cc, int ww) {
v = vv;
c = cc;
w = ww;
}
};
vector<edge> G[123456];
int cnt[123456], in[123456], out[123456], tim = 0;
int pa[18][123456];
bool anc(int x, int y) { return in[x] <= in[y] && out[x] >= out[y]; }
void dfs(int cur, int pre) {
in[cur] = ++tim;
pa[0][cur] = pre;
for (edge tmp : G[cur]) {
int nxt = tmp.v, col = tmp.c, w = tmp.w;
if (nxt == pre)
continue;
dfs(nxt, cur);
}
out[cur] = ++tim;
}
void build() {
for (int i = 1; i < 18; i++)
for (int j = 1; j <= n; j++)
pa[i][j] = pa[i - 1][pa[i - 1][j]];
}
int lca(int x, int y) {
if (anc(x, y))
return x;
if (anc(y, x))
return y;
for (int i = 17; i >= 0; i--)
if (!anc(pa[i][x], y))
x = pa[i][x];
return pa[0][x];
}
int ans[123456], q_col[123456], q_val[123456], dist[123456];
vector<int> query[123456];
void solve(int cur, int pre, int cur_dis) {
for (int id : query[cur]) {
int mul = 1;
if (id < 0)
mul = -2, id = -id;
ans[id] += mul * (cur_dis + cnt[q_col[id]] * q_val[id] - dist[q_col[id]]);
}
for (edge tmp : G[cur]) {
int nxt = tmp.v, col = tmp.c, w = tmp.w;
if (nxt == pre)
continue;
cnt[col]++;
dist[col] += w;
solve(nxt, cur, cur_dis + w);
dist[col] -= w;
cnt[col]--;
}
}
int32_t main() {
ios::sync_with_stdio();
cin.tie(0);
cin >> n >> q;
for (int i = 0; i < n - 1; i++) {
int u, v, c, w;
cin >> u >> v >> c >> w;
G[u].push_back(edge(v, c, w));
G[v].push_back(edge(u, c, w));
}
dfs(1, 0);
build();
for (int i = 1; i <= q; i++) {
int u, v;
cin >> q_col[i] >> q_val[i] >> u >> v;
query[u].push_back(i);
query[v].push_back(i);
query[lca(u, v)].push_back(-i);
}
solve(1, 0, 0);
for (int i = 1; i <= q; i++)
cout << ans[i] << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define pii pair<int, int>
#define mp make_pair
int n, q;
struct edge {
int v, c, w;
edge(int vv, int cc, int ww) {
v = vv;
c = cc;
w = ww;
}
};
vector<edge> G[123456];
int cnt[123456], in[123456], out[123456], tim = 0;
int pa[18][123456];
bool anc(int x, int y) { return in[x] <= in[y] && out[x] >= out[y]; }
void dfs(int cur, int pre) {
in[cur] = ++tim;
pa[0][cur] = pre;
for (edge tmp : G[cur]) {
int nxt = tmp.v, col = tmp.c, w = tmp.w;
if (nxt == pre)
continue;
dfs(nxt, cur);
}
out[cur] = ++tim;
}
void build() {
for (int i = 1; i < 18; i++)
for (int j = 1; j <= n; j++)
pa[i][j] = pa[i - 1][pa[i - 1][j]];
}
int lca(int x, int y) {
if (anc(x, y))
return x;
if (anc(y, x))
return y;
for (int i = 17; i >= 0; i--)
if (!anc(pa[i][x], y))
x = pa[i][x];
return pa[0][x];
}
int ans[123456], q_col[123456], q_val[123456], dist[123456];
vector<int> query[123456];
void solve(int cur, int pre, int cur_dis) {
for (int id : query[cur]) {
int mul = 1;
if (id < 0)
mul = -2, id = -id;
ans[id] += mul * (cur_dis + cnt[q_col[id]] * q_val[id] - dist[q_col[id]]);
}
for (edge tmp : G[cur]) {
int nxt = tmp.v, col = tmp.c, w = tmp.w;
if (nxt == pre)
continue;
cnt[col]++;
dist[col] += w;
solve(nxt, cur, cur_dis + w);
dist[col] -= w;
cnt[col]--;
}
}
int32_t main() {
ios::sync_with_stdio();
cin.tie(0);
cin >> n >> q;
for (int i = 0; i < n - 1; i++) {
int u, v, c, w;
cin >> u >> v >> c >> w;
G[u].push_back(edge(v, c, w));
G[v].push_back(edge(u, c, w));
}
dfs(1, 1);
build();
for (int i = 1; i <= q; i++) {
int u, v;
cin >> q_col[i] >> q_val[i] >> u >> v;
query[u].push_back(i);
query[v].push_back(i);
query[lca(u, v)].push_back(-i);
}
solve(1, 1, 0);
for (int i = 1; i <= q; i++)
cout << ans[i] << endl;
} | [
"literal.number.change",
"call.arguments.change"
] | 798,020 | 798,017 | u594742844 | cpp |
p02986 | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define pii pair<int, int>
#define mp make_pair
int n, q;
struct edge {
int v, c, w;
edge(int vv, int cc, int ww) {
v = vv;
c = cc;
w = ww;
}
};
vector<edge> G[123456];
int cnt[123456], in[123456], out[123456], tim = 0;
int pa[18][123456];
bool anc(int x, int y) { return in[x] <= in[y] && out[x] >= out[y]; }
void dfs(int cur, int pre) {
in[cur] = ++tim;
pa[0][cur] = pre;
for (edge tmp : G[cur]) {
int nxt = tmp.v, col = tmp.c, w = tmp.w;
if (nxt == pre)
continue;
dfs(nxt, cur);
}
out[cur] = ++tim;
}
void build() {
for (int i = 1; i < 18; i++)
for (int j = 1; j <= n; j++)
pa[i][j] = pa[i - 1][pa[i - 1][j]];
}
int lca(int x, int y) {
if (anc(x, y))
return x;
if (anc(y, x))
return y;
for (int i = 17; i >= 0; i--)
if (!anc(pa[i][x], y))
x = pa[i][x];
return pa[0][x];
}
int ans[123456], q_col[123456], q_val[123456], dist[123456];
vector<int> query[123456];
void solve(int cur, int pre, int cur_dis) {
for (int id : query[cur]) {
int mul = 1;
if (id < 0)
mul = -2, id = -id;
ans[id] += mul * (cur_dis + cnt[q_col[id]] * q_val[id] - dist[q_col[id]]);
}
for (edge tmp : G[cur]) {
int nxt = tmp.v, col = tmp.c, w = tmp.w;
if (nxt == pre)
continue;
cnt[col]++;
dist[col] += w;
solve(nxt, cur, cur_dis + w);
dist[col] -= w;
cnt[col]--;
}
}
int32_t main() {
ios::sync_with_stdio();
cin.tie(0);
cin >> n >> q;
for (int i = 0; i < n - 1; i++) {
int u, v, c, w;
cin >> u >> v >> c >> w;
G[u].push_back(edge(v, c, w));
G[v].push_back(edge(u, c, w));
}
dfs(1, 0);
build();
for (int i = 1; i <= q; i++) {
int u, v;
cin >> q_col[i] >> q_val[i] >> u >> v;
query[u].push_back(i);
query[v].push_back(i);
query[lca(u, v)].push_back(-i);
}
solve(1, 0, 0);
for (int i = 1; i <= q; i++)
cout << ans[i] << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define pii pair<int, int>
#define mp make_pair
int n, q;
struct edge {
int v, c, w;
edge(int vv, int cc, int ww) {
v = vv;
c = cc;
w = ww;
}
};
vector<edge> G[123456];
int cnt[123456], in[123456], out[123456], tim = 0;
int pa[18][123456];
bool anc(int x, int y) { return in[x] <= in[y] && out[x] >= out[y]; }
void dfs(int cur, int pre) {
in[cur] = ++tim;
pa[0][cur] = pre;
for (edge tmp : G[cur]) {
int nxt = tmp.v, col = tmp.c, w = tmp.w;
if (nxt == pre)
continue;
dfs(nxt, cur);
}
out[cur] = ++tim;
}
void build() {
for (int i = 1; i < 18; i++)
for (int j = 1; j <= n; j++)
pa[i][j] = pa[i - 1][pa[i - 1][j]];
}
int lca(int x, int y) {
if (anc(x, y))
return x;
if (anc(y, x))
return y;
for (int i = 17; i >= 0; i--)
if (!anc(pa[i][x], y))
x = pa[i][x];
return pa[0][x];
}
int ans[123456], q_col[123456], q_val[123456], dist[123456];
vector<int> query[123456];
void solve(int cur, int pre, int cur_dis) {
for (int id : query[cur]) {
int mul = 1;
if (id < 0)
mul = -2, id = -id;
ans[id] += mul * (cur_dis + cnt[q_col[id]] * q_val[id] - dist[q_col[id]]);
}
for (edge tmp : G[cur]) {
int nxt = tmp.v, col = tmp.c, w = tmp.w;
if (nxt == pre)
continue;
cnt[col]++;
dist[col] += w;
solve(nxt, cur, cur_dis + w);
dist[col] -= w;
cnt[col]--;
}
}
int32_t main() {
ios::sync_with_stdio();
cin.tie(0);
cin >> n >> q;
for (int i = 0; i < n - 1; i++) {
int u, v, c, w;
cin >> u >> v >> c >> w;
G[u].push_back(edge(v, c, w));
G[v].push_back(edge(u, c, w));
}
dfs(1, 1);
build();
for (int i = 1; i <= q; i++) {
int u, v;
cin >> q_col[i] >> q_val[i] >> u >> v;
query[u].push_back(i);
query[v].push_back(i);
query[lca(u, v)].push_back(-i);
}
solve(1, 0, 0);
for (int i = 1; i <= q; i++)
cout << ans[i] << endl;
} | [
"literal.number.change",
"call.arguments.change"
] | 798,020 | 798,021 | u594742844 | cpp |
p02986 | #include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> pii;
typedef pair<int, pii> pipii;
vector<pipii> g[100005];
int ans[100005];
int par[17][100005], depth[100005], dp[100005];
void dfs(int u, int p, int d, int val) {
depth[u] = d;
par[0][u] = p;
dp[u] = val;
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i].first, c = g[u][i].second.first, d = g[u][i].second.second;
if (v == p)
continue;
dfs(v, u, d + 1, val + d);
}
}
int LCA(int a, int b) {
if (depth[b] > depth[a])
swap(a, b);
int diff = depth[a] - depth[b];
for (int i = 17 - 1; i >= 0; i--) {
if ((diff >> i) & 1)
a = par[i][a];
}
if (a == b)
return a;
for (int i = 17 - 1; i >= 0; i--) {
if (par[i][a] != par[i][b])
a = par[i][a], b = par[i][b];
}
return par[0][a];
}
int dist(int a, int b) { return dp[a] + dp[b] - 2 * dp[LCA(a, b)]; }
vector<pipii> cur[100005];
int dis[100005], cnt[100005];
void dfs2(int u, int p) {
for (int i = 0; i < cur[u].size(); i++) {
int j = cur[u][i].first, x = cur[u][i].second.first,
y = cur[u][i].second.second;
if (j < 0) {
j = -j;
ans[j] -= 2 * (y * cnt[x] - dis[x]);
} else {
ans[j] += y * cnt[x] - dis[x];
}
}
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i].first, c = g[u][i].second.first, d = g[u][i].second.second;
if (v == p)
continue;
dis[c] += d;
cnt[c]++;
dfs2(v, u);
dis[c] -= d;
cnt[c]--;
}
}
int main() {
int n, q, a, b, c, d;
scanf("%d%d", &n, &q);
for (int i = 1; i <= n - 1; i++) {
scanf("%d%d%d%d", &a, &b, &c, &d);
g[a].push_back(pipii(b, pii(c, d)));
g[b].push_back(pipii(a, pii(c, d)));
}
dfs(1, 0, 0, 0);
for (int j = 1; j < 17; j++) {
for (int i = 1; i <= n; i++) {
if (par[j - 1][i] != 0)
par[j][i] = par[j - 1][par[j - 1][i]];
}
}
for (int i = 1; i <= q; i++) {
int x, y, u, v, lca;
scanf("%d%d%d%d", &x, &y, &u, &v);
lca = LCA(u, v);
ans[i] = dist(u, v);
cur[lca].push_back(pipii(-i, pii(x, y)));
cur[u].push_back(pipii(i, pii(x, y)));
cur[v].push_back(pipii(i, pii(x, y)));
}
dfs2(1, 0);
for (int i = 1; i <= q; i++)
printf("%d\n", ans[i]);
} | #include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> pii;
typedef pair<int, pii> pipii;
vector<pipii> g[100005];
int ans[100005];
int par[17][100005], depth[100005], dp[100005];
void dfs(int u, int p, int d, int val) {
depth[u] = d;
par[0][u] = p;
dp[u] = val;
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i].first, c = g[u][i].second.first, l = g[u][i].second.second;
if (v == p)
continue;
dfs(v, u, d + 1, val + l);
}
}
int LCA(int a, int b) {
if (depth[b] > depth[a])
swap(a, b);
int diff = depth[a] - depth[b];
for (int i = 17 - 1; i >= 0; i--) {
if ((diff >> i) & 1)
a = par[i][a];
}
if (a == b)
return a;
for (int i = 17 - 1; i >= 0; i--) {
if (par[i][a] != par[i][b])
a = par[i][a], b = par[i][b];
}
return par[0][a];
}
int dist(int a, int b) { return dp[a] + dp[b] - 2 * dp[LCA(a, b)]; }
vector<pipii> cur[100005];
int dis[100005], cnt[100005];
void dfs2(int u, int p) {
for (int i = 0; i < cur[u].size(); i++) {
int j = cur[u][i].first, x = cur[u][i].second.first,
y = cur[u][i].second.second;
if (j < 0) {
j = -j;
ans[j] -= 2 * (y * cnt[x] - dis[x]);
} else {
ans[j] += y * cnt[x] - dis[x];
}
}
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i].first, c = g[u][i].second.first, d = g[u][i].second.second;
if (v == p)
continue;
dis[c] += d;
cnt[c]++;
dfs2(v, u);
dis[c] -= d;
cnt[c]--;
}
}
int main() {
int n, q, a, b, c, d;
scanf("%d%d", &n, &q);
for (int i = 1; i <= n - 1; i++) {
scanf("%d%d%d%d", &a, &b, &c, &d);
g[a].push_back(pipii(b, pii(c, d)));
g[b].push_back(pipii(a, pii(c, d)));
}
dfs(1, 0, 0, 0);
for (int j = 1; j < 17; j++) {
for (int i = 1; i <= n; i++) {
if (par[j - 1][i] != 0)
par[j][i] = par[j - 1][par[j - 1][i]];
}
}
for (int i = 1; i <= q; i++) {
int x, y, u, v, lca;
scanf("%d%d%d%d", &x, &y, &u, &v);
lca = LCA(u, v);
ans[i] = dist(u, v);
cur[lca].push_back(pipii(-i, pii(x, y)));
cur[u].push_back(pipii(i, pii(x, y)));
cur[v].push_back(pipii(i, pii(x, y)));
}
dfs2(1, 0);
for (int i = 1; i <= q; i++)
printf("%d\n", ans[i]);
} | [
"variable_declaration.name.change",
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 798,067 | 798,068 | u854367220 | cpp |
p02986 | #include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> pii;
typedef pair<int, pii> pipii;
vector<pipii> g[100005];
int ans[100005];
int par[17][100005], depth[100005], dp[100005];
void dfs(int u, int p, int d, int val) {
depth[u] = d;
par[0][u] = p;
dp[u] = val;
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i].first, c = g[u][i].second.first, d = g[u][i].second.second;
if (v == p)
continue;
dfs(v, u, d + 1, val + d);
}
}
int LCA(int a, int b) {
if (depth[b] > depth[a])
swap(a, b);
int diff = depth[a] - depth[b];
for (int i = 17 - 1; i >= 0; i--) {
if ((diff >> i) & 1)
a = par[i][a];
}
if (a == b)
return a;
for (int i = 17 - 1; i >= 0; i--) {
if (par[i][a] != par[i][b])
a = par[i][a], b = par[i][b];
}
return par[0][a];
}
int dist(int a, int b) { return dp[a] + dp[b] - 2 * dp[LCA(a, b)]; }
vector<pipii> cur[100005];
int dis[100005], cnt[100005];
void dfs2(int u, int p) {
for (int i = 0; i < cur[u].size(); i++) {
int j = cur[u][i].first, x = cur[u][i].second.first,
y = cur[u][i].second.second;
if (j < 0) {
j = -j;
ans[j] -= y * cnt[x] - dis[x];
} else {
ans[j] += y * cnt[x] - dis[x];
}
}
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i].first, c = g[u][i].second.first, d = g[u][i].second.second;
if (v == p)
continue;
dis[c] += d;
cnt[c]++;
dfs2(v, u);
dis[c] -= d;
cnt[c]--;
}
}
int main() {
int n, q, a, b, c, d;
scanf("%d%d", &n, &q);
for (int i = 1; i <= n - 1; i++) {
scanf("%d%d%d%d", &a, &b, &c, &d);
g[a].push_back(pipii(b, pii(c, d)));
g[b].push_back(pipii(a, pii(c, d)));
}
dfs(1, 0, 0, 0);
for (int j = 1; j < 17; j++) {
for (int i = 1; i <= n; i++) {
if (par[j - 1][i] != 0)
par[j][i] = par[j - 1][par[j - 1][i]];
}
}
for (int i = 1; i <= q; i++) {
int x, y, u, v, lca;
scanf("%d%d%d%d", &x, &y, &u, &v);
lca = LCA(u, v);
ans[i] = dist(u, v);
cur[lca].push_back(pipii(-i, pii(x, y)));
cur[u].push_back(pipii(i, pii(x, y)));
cur[v].push_back(pipii(i, pii(x, y)));
}
dfs2(1, 0);
for (int i = 1; i <= q; i++)
printf("%d\n", ans[i]);
} | #include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> pii;
typedef pair<int, pii> pipii;
vector<pipii> g[100005];
int ans[100005];
int par[17][100005], depth[100005], dp[100005];
void dfs(int u, int p, int d, int val) {
depth[u] = d;
par[0][u] = p;
dp[u] = val;
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i].first, c = g[u][i].second.first, l = g[u][i].second.second;
if (v == p)
continue;
dfs(v, u, d + 1, val + l);
}
}
int LCA(int a, int b) {
if (depth[b] > depth[a])
swap(a, b);
int diff = depth[a] - depth[b];
for (int i = 17 - 1; i >= 0; i--) {
if ((diff >> i) & 1)
a = par[i][a];
}
if (a == b)
return a;
for (int i = 17 - 1; i >= 0; i--) {
if (par[i][a] != par[i][b])
a = par[i][a], b = par[i][b];
}
return par[0][a];
}
int dist(int a, int b) { return dp[a] + dp[b] - 2 * dp[LCA(a, b)]; }
vector<pipii> cur[100005];
int dis[100005], cnt[100005];
void dfs2(int u, int p) {
for (int i = 0; i < cur[u].size(); i++) {
int j = cur[u][i].first, x = cur[u][i].second.first,
y = cur[u][i].second.second;
if (j < 0) {
j = -j;
ans[j] -= 2 * (y * cnt[x] - dis[x]);
} else {
ans[j] += y * cnt[x] - dis[x];
}
}
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i].first, c = g[u][i].second.first, d = g[u][i].second.second;
if (v == p)
continue;
dis[c] += d;
cnt[c]++;
dfs2(v, u);
dis[c] -= d;
cnt[c]--;
}
}
int main() {
int n, q, a, b, c, d;
scanf("%d%d", &n, &q);
for (int i = 1; i <= n - 1; i++) {
scanf("%d%d%d%d", &a, &b, &c, &d);
g[a].push_back(pipii(b, pii(c, d)));
g[b].push_back(pipii(a, pii(c, d)));
}
dfs(1, 0, 0, 0);
for (int j = 1; j < 17; j++) {
for (int i = 1; i <= n; i++) {
if (par[j - 1][i] != 0)
par[j][i] = par[j - 1][par[j - 1][i]];
}
}
for (int i = 1; i <= q; i++) {
int x, y, u, v, lca;
scanf("%d%d%d%d", &x, &y, &u, &v);
lca = LCA(u, v);
ans[i] = dist(u, v);
cur[lca].push_back(pipii(-i, pii(x, y)));
cur[u].push_back(pipii(i, pii(x, y)));
cur[v].push_back(pipii(i, pii(x, y)));
}
dfs2(1, 0);
for (int i = 1; i <= q; i++)
printf("%d\n", ans[i]);
} | [
"variable_declaration.name.change",
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change",
"assignment.change"
] | 798,069 | 798,068 | u854367220 | cpp |
p02986 | #include <bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef pair<int, int> pii;
typedef pair<int, pii> pipii;
vector<pipii> g[100005];
LL ans[100005];
int par[17][100005], depth[100005];
LL dp[100005];
void dfs(int u, int p, int d, LL val) {
depth[u] = d;
par[0][u] = p;
dp[u] = val;
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i].first, c = g[u][i].second.first, d = g[u][i].second.second;
if (v == p)
continue;
dfs(v, u, d + 1, val + d);
}
}
int LCA(int a, int b) {
if (depth[b] > depth[a])
swap(a, b);
int diff = depth[a] - depth[b];
for (int i = 17 - 1; i >= 0; i--) {
if ((diff >> i) & 1)
a = par[i][a];
}
if (a == b)
return a;
for (int i = 17 - 1; i >= 0; i--) {
if (par[i][a] != par[i][b])
a = par[i][a], b = par[i][b];
}
return par[0][a];
}
LL dist(int a, int b) { return dp[a] + dp[b] - 2 * dp[LCA(a, b)]; }
vector<pipii> cur[100005];
LL dis[100005], cnt[100005];
void dfs2(int u, int p) {
for (int i = 0; i < cur[u].size(); i++) {
int j = cur[u][i].first, x = cur[u][i].second.first,
y = cur[u][i].second.second;
if (j < 0) {
j = -j;
ans[j] -= 2 * (y * 1ll * cnt[x] - dis[x]);
} else {
ans[j] += y * 1ll * cnt[x] - dis[x];
}
}
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i].first, c = g[u][i].second.first, d = g[u][i].second.second;
if (v == p)
continue;
dis[c] += d;
cnt[c]++;
dfs2(v, u);
dis[c] -= d;
cnt[c]--;
}
}
int main() {
int n, q, a, b, c, d;
scanf("%d%d", &n, &q);
for (int i = 1; i <= n - 1; i++) {
scanf("%d%d%d%d", &a, &b, &c, &d);
g[a].push_back(pipii(b, pii(c, d)));
g[b].push_back(pipii(a, pii(c, d)));
}
dfs(1, 0, 0, 0);
for (int j = 1; j < 17; j++) {
for (int i = 1; i <= n; i++) {
if (par[j - 1][i] != 0)
par[j][i] = par[j - 1][par[j - 1][i]];
}
}
for (int i = 1; i <= q; i++) {
int x, y, u, v, lca;
scanf("%d%d%d%d", &x, &y, &u, &v);
lca = LCA(u, v);
ans[i] = dist(u, v);
cur[lca].push_back(pipii(-i, pii(x, y)));
cur[u].push_back(pipii(i, pii(x, y)));
cur[v].push_back(pipii(i, pii(x, y)));
}
dfs2(1, 0);
for (int i = 1; i <= q; i++)
printf("%lld\n", ans[i]);
} | #include <bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef pair<int, int> pii;
typedef pair<int, pii> pipii;
vector<pipii> g[100005];
LL ans[100005];
int par[17][100005], depth[100005];
LL dp[100005];
void dfs(int u, int p, int d, LL val) {
depth[u] = d;
par[0][u] = p;
dp[u] = val;
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i].first, c = g[u][i].second.first, l = g[u][i].second.second;
if (v == p)
continue;
dfs(v, u, d + 1, val + l);
}
}
int LCA(int a, int b) {
if (depth[b] > depth[a])
swap(a, b);
int diff = depth[a] - depth[b];
for (int i = 17 - 1; i >= 0; i--) {
if ((diff >> i) & 1)
a = par[i][a];
}
if (a == b)
return a;
for (int i = 17 - 1; i >= 0; i--) {
if (par[i][a] != par[i][b])
a = par[i][a], b = par[i][b];
}
return par[0][a];
}
LL dist(int a, int b) { return dp[a] + dp[b] - 2 * dp[LCA(a, b)]; }
vector<pipii> cur[100005];
LL dis[100005], cnt[100005];
void dfs2(int u, int p) {
for (int i = 0; i < cur[u].size(); i++) {
int j = cur[u][i].first, x = cur[u][i].second.first,
y = cur[u][i].second.second;
if (j < 0) {
j = -j;
ans[j] -= 2 * (y * 1ll * cnt[x] - dis[x]);
} else {
ans[j] += y * 1ll * cnt[x] - dis[x];
}
}
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i].first, c = g[u][i].second.first, d = g[u][i].second.second;
if (v == p)
continue;
dis[c] += d;
cnt[c]++;
dfs2(v, u);
dis[c] -= d;
cnt[c]--;
}
}
int main() {
int n, q, a, b, c, d;
scanf("%d%d", &n, &q);
for (int i = 1; i <= n - 1; i++) {
scanf("%d%d%d%d", &a, &b, &c, &d);
g[a].push_back(pipii(b, pii(c, d)));
g[b].push_back(pipii(a, pii(c, d)));
}
dfs(1, 0, 0, 0);
for (int j = 1; j < 17; j++) {
for (int i = 1; i <= n; i++) {
if (par[j - 1][i] != 0)
par[j][i] = par[j - 1][par[j - 1][i]];
}
}
for (int i = 1; i <= q; i++) {
int x, y, u, v, lca;
scanf("%d%d%d%d", &x, &y, &u, &v);
lca = LCA(u, v);
ans[i] = dist(u, v);
cur[lca].push_back(pipii(-i, pii(x, y)));
cur[u].push_back(pipii(i, pii(x, y)));
cur[v].push_back(pipii(i, pii(x, y)));
}
dfs2(1, 0);
for (int i = 1; i <= q; i++)
printf("%lld\n", ans[i]);
} | [
"variable_declaration.name.change",
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 798,070 | 798,071 | u854367220 | cpp |
p02986 | #include <bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef pair<int, int> pii;
typedef pair<int, pii> pipii;
vector<pipii> g[100005];
LL ans[100005];
int par[17][100005], depth[100005];
LL dp[100005];
void dfs(int u, int p, int d, LL val) {
depth[u] = d;
par[0][u] = p;
dp[u] = val;
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i].first, c = g[u][i].second.first, d = g[u][i].second.second;
if (v == p)
continue;
dfs(v, u, d + 1, val + d);
}
}
int LCA(int a, int b) {
if (depth[b] > depth[a])
swap(a, b);
int diff = depth[a] - depth[b];
for (int i = 17 - 1; i >= 0; i--) {
if ((diff >> i) & 1)
a = par[i][a];
}
if (a == b)
return a;
for (int i = 17 - 1; i >= 0; i--) {
if (par[i][a] != par[i][b])
a = par[i][a], b = par[i][b];
}
return par[0][a];
}
LL dist(int a, int b) { return dp[a] + dp[b] - 2 * dp[LCA(a, b)]; }
vector<pipii> cur[100005];
int dis[100005], cnt[100005];
void dfs2(int u, int p) {
for (int i = 0; i < cur[u].size(); i++) {
int j = cur[u][i].first, x = cur[u][i].second.first,
y = cur[u][i].second.second;
if (j < 0) {
j = -j;
ans[j] -= 2 * (y * 1ll * cnt[x] - dis[x]);
} else {
ans[j] += y * 1ll * cnt[x] - dis[x];
}
}
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i].first, c = g[u][i].second.first, d = g[u][i].second.second;
if (v == p)
continue;
dis[c] += d;
cnt[c]++;
dfs2(v, u);
dis[c] -= d;
cnt[c]--;
}
}
int main() {
int n, q, a, b, c, d;
scanf("%d%d", &n, &q);
for (int i = 1; i <= n - 1; i++) {
scanf("%d%d%d%d", &a, &b, &c, &d);
g[a].push_back(pipii(b, pii(c, d)));
g[b].push_back(pipii(a, pii(c, d)));
}
dfs(1, 0, 0, 0);
for (int j = 1; j < 17; j++) {
for (int i = 1; i <= n; i++) {
if (par[j - 1][i] != 0)
par[j][i] = par[j - 1][par[j - 1][i]];
}
}
for (int i = 1; i <= q; i++) {
int x, y, u, v, lca;
scanf("%d%d%d%d", &x, &y, &u, &v);
lca = LCA(u, v);
ans[i] = dist(u, v);
cur[lca].push_back(pipii(-i, pii(x, y)));
cur[u].push_back(pipii(i, pii(x, y)));
cur[v].push_back(pipii(i, pii(x, y)));
}
dfs2(1, 0);
for (int i = 1; i <= q; i++)
printf("%lld\n", ans[i]);
} | #include <bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef pair<int, int> pii;
typedef pair<int, pii> pipii;
vector<pipii> g[100005];
LL ans[100005];
int par[17][100005], depth[100005];
LL dp[100005];
void dfs(int u, int p, int d, LL val) {
depth[u] = d;
par[0][u] = p;
dp[u] = val;
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i].first, c = g[u][i].second.first, l = g[u][i].second.second;
if (v == p)
continue;
dfs(v, u, d + 1, val + l);
}
}
int LCA(int a, int b) {
if (depth[b] > depth[a])
swap(a, b);
int diff = depth[a] - depth[b];
for (int i = 17 - 1; i >= 0; i--) {
if ((diff >> i) & 1)
a = par[i][a];
}
if (a == b)
return a;
for (int i = 17 - 1; i >= 0; i--) {
if (par[i][a] != par[i][b])
a = par[i][a], b = par[i][b];
}
return par[0][a];
}
LL dist(int a, int b) { return dp[a] + dp[b] - 2 * dp[LCA(a, b)]; }
vector<pipii> cur[100005];
LL dis[100005], cnt[100005];
void dfs2(int u, int p) {
for (int i = 0; i < cur[u].size(); i++) {
int j = cur[u][i].first, x = cur[u][i].second.first,
y = cur[u][i].second.second;
if (j < 0) {
j = -j;
ans[j] -= 2 * (y * 1ll * cnt[x] - dis[x]);
} else {
ans[j] += y * 1ll * cnt[x] - dis[x];
}
}
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i].first, c = g[u][i].second.first, d = g[u][i].second.second;
if (v == p)
continue;
dis[c] += d;
cnt[c]++;
dfs2(v, u);
dis[c] -= d;
cnt[c]--;
}
}
int main() {
int n, q, a, b, c, d;
scanf("%d%d", &n, &q);
for (int i = 1; i <= n - 1; i++) {
scanf("%d%d%d%d", &a, &b, &c, &d);
g[a].push_back(pipii(b, pii(c, d)));
g[b].push_back(pipii(a, pii(c, d)));
}
dfs(1, 0, 0, 0);
for (int j = 1; j < 17; j++) {
for (int i = 1; i <= n; i++) {
if (par[j - 1][i] != 0)
par[j][i] = par[j - 1][par[j - 1][i]];
}
}
for (int i = 1; i <= q; i++) {
int x, y, u, v, lca;
scanf("%d%d%d%d", &x, &y, &u, &v);
lca = LCA(u, v);
ans[i] = dist(u, v);
cur[lca].push_back(pipii(-i, pii(x, y)));
cur[u].push_back(pipii(i, pii(x, y)));
cur[v].push_back(pipii(i, pii(x, y)));
}
dfs2(1, 0);
for (int i = 1; i <= q; i++)
printf("%lld\n", ans[i]);
} | [
"variable_declaration.name.change",
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change",
"variable_declaration.type.change"
] | 798,072 | 798,071 | u854367220 | cpp |
p02986 | #pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ld, ld> pdd;
#define fi first
#define se second
#define mp make_pair
#define fastIO \
ios::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
const int N = (int)1e5 + 9;
const int LOG = 20;
int par[LOG][N];
ll dist[N];
int tin[N];
int tout[N];
int tt;
vector<pii> T[N];
void dfs(int u, int pr) {
par[0][u] = pr;
tin[u] = ++tt;
for (int i = 1; i < LOG; i++) {
par[i][u] = par[i - 1][par[i - 1][u]];
}
for (auto x : T[u]) {
if (x.fi == pr)
continue;
dist[x.fi] = dist[u] + x.se;
dfs(x.fi, u);
}
tout[u] = tt;
}
bool is(int a, int b) { return tin[a] <= tin[b] && tout[a] >= tout[b]; }
int lca(int a, int b) {
if (is(a, b))
return a;
if (is(b, a))
return b;
for (int i = LOG - 1; i >= 0; i--) {
if (is(par[i][a], b)) {
a = par[i][a];
}
}
return par[0][a];
}
ll sum[N];
ll cs[N];
ll ti[N];
struct Edge {
ll A;
ll B;
ll D;
};
struct Query {
ll nd;
ll u;
ll v;
ll id;
};
vector<Edge> P[N];
vector<Query> vv[N];
struct Node {
ll value;
ll lazy;
};
ll nw[N];
Node TR[N * 4 + 512];
void push(int node, int cl, int cr) {
TR[node].value += (cr - cl + 1) * 1ll * TR[node].lazy;
if (cl != cr) {
TR[node * 2].lazy += TR[node].lazy;
TR[node * 2 + 1].lazy += TR[node].lazy;
}
TR[node].lazy = 0;
}
void update(int node, int cl, int cr, int tl, int tr, ll v) {
push(node, cl, cr);
if (cr < tl)
return;
if (cl > tr)
return;
if (cl >= tl && cr <= tr) {
TR[node].lazy = v;
push(node, cl, cr);
return;
}
int mid = (cl + cr) / 2;
update(node * 2, cl, mid, tl, tr, v);
update(node * 2 + 1, mid + 1, cr, tl, tr, v);
TR[node].value = TR[node * 2].value + TR[node * 2 + 1].value;
}
int ask(int node, int cl, int cr, int ps) {
push(node, cl, cr);
if (cl == cr)
return TR[node].value;
int mid = (cl + cr) / 2;
if (mid >= ps)
return ask(node * 2, cl, mid, ps);
else
return ask(node * 2 + 1, mid + 1, cr, ps);
}
int main() {
fastIO;
int n, q;
cin >> n >> q;
ll u, v, cl, d;
for (int i = 1; i < n; i++) {
cin >> u >> v >> cl >> d;
T[u].push_back(mp(v, d));
T[v].push_back(mp(u, d));
P[cl].push_back({u, v, d});
}
dfs(1, 1);
ll ci, di, x, y;
for (int i = 0; i < q; i++) {
cin >> ci >> di >> x >> y;
sum[i] = dist[x] + dist[y] - 2ll * dist[lca(x, y)];
vv[ci].push_back({di, x, y, i});
nw[i] = di;
}
for (int i = 1; i < N; i++) {
for (auto &x : P[i]) {
if (tin[x.A] > tin[x.B])
swap(x.A, x.B);
}
for (auto x : P[i]) {
update(1, 1, n, tin[x.B], tout[x.B], +1);
}
for (auto x : vv[i]) {
cs[x.id] = ask(1, 1, n, tin[x.u]) + ask(1, 1, n, tin[x.v]) -
2ll * ask(1, 1, n, tin[lca(x.u, x.v)]);
}
for (auto x : P[i]) {
update(1, 1, n, tin[x.B], tout[x.B], -1);
}
for (auto x : P[i]) {
update(1, 1, n, tin[x.B], tout[x.B], x.D);
}
for (auto x : vv[i]) {
ti[x.id] = ask(1, 1, n, tin[x.u]) + ask(1, 1, n, tin[x.v]) -
2ll * ask(1, 1, n, tin[lca(x.u, x.v)]);
}
for (auto x : P[i]) {
update(1, 1, n, tin[x.B], tout[x.B], -x.D);
}
}
for (int i = 0; i < q; i++) {
cout << sum[i] - ti[i] + cs[i] * nw[i] << "\n";
}
return 0;
}
| #pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ld, ld> pdd;
#define fi first
#define se second
#define mp make_pair
#define fastIO \
ios::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
const int N = (int)1e5 + 9;
const int LOG = 20;
int par[LOG][N];
ll dist[N];
int tin[N];
int tout[N];
int tt;
vector<pii> T[N];
void dfs(int u, int pr) {
par[0][u] = pr;
tin[u] = ++tt;
for (int i = 1; i < LOG; i++) {
par[i][u] = par[i - 1][par[i - 1][u]];
}
for (auto x : T[u]) {
if (x.fi == pr)
continue;
dist[x.fi] = dist[u] + x.se;
dfs(x.fi, u);
}
tout[u] = tt;
}
bool is(int a, int b) { return tin[a] <= tin[b] && tout[a] >= tout[b]; }
int lca(int a, int b) {
if (is(a, b))
return a;
if (is(b, a))
return b;
for (int i = LOG - 1; i >= 0; i--) {
if (!is(par[i][a], b)) {
a = par[i][a];
}
}
return par[0][a];
}
ll sum[N];
ll cs[N];
ll ti[N];
struct Edge {
ll A;
ll B;
ll D;
};
struct Query {
ll nd;
ll u;
ll v;
ll id;
};
vector<Edge> P[N];
vector<Query> vv[N];
struct Node {
ll value;
ll lazy;
};
ll nw[N];
Node TR[N * 4 + 512];
void push(int node, int cl, int cr) {
TR[node].value += (cr - cl + 1) * 1ll * TR[node].lazy;
if (cl != cr) {
TR[node * 2].lazy += TR[node].lazy;
TR[node * 2 + 1].lazy += TR[node].lazy;
}
TR[node].lazy = 0;
}
void update(int node, int cl, int cr, int tl, int tr, ll v) {
push(node, cl, cr);
if (cr < tl)
return;
if (cl > tr)
return;
if (cl >= tl && cr <= tr) {
TR[node].lazy = v;
push(node, cl, cr);
return;
}
int mid = (cl + cr) / 2;
update(node * 2, cl, mid, tl, tr, v);
update(node * 2 + 1, mid + 1, cr, tl, tr, v);
TR[node].value = TR[node * 2].value + TR[node * 2 + 1].value;
}
int ask(int node, int cl, int cr, int ps) {
push(node, cl, cr);
if (cl == cr)
return TR[node].value;
int mid = (cl + cr) / 2;
if (mid >= ps)
return ask(node * 2, cl, mid, ps);
else
return ask(node * 2 + 1, mid + 1, cr, ps);
}
int main() {
fastIO;
int n, q;
cin >> n >> q;
ll u, v, cl, d;
for (int i = 1; i < n; i++) {
cin >> u >> v >> cl >> d;
T[u].push_back(mp(v, d));
T[v].push_back(mp(u, d));
P[cl].push_back({u, v, d});
}
dfs(1, 1);
ll ci, di, x, y;
for (int i = 0; i < q; i++) {
cin >> ci >> di >> x >> y;
sum[i] = dist[x] + dist[y] - 2ll * dist[lca(x, y)];
vv[ci].push_back({di, x, y, i});
nw[i] = di;
}
for (int i = 1; i < N; i++) {
for (auto &x : P[i]) {
if (tin[x.A] > tin[x.B])
swap(x.A, x.B);
}
for (auto x : P[i]) {
update(1, 1, n, tin[x.B], tout[x.B], +1);
}
for (auto x : vv[i]) {
cs[x.id] = ask(1, 1, n, tin[x.u]) + ask(1, 1, n, tin[x.v]) -
2ll * ask(1, 1, n, tin[lca(x.u, x.v)]);
}
for (auto x : P[i]) {
update(1, 1, n, tin[x.B], tout[x.B], -1);
}
for (auto x : P[i]) {
update(1, 1, n, tin[x.B], tout[x.B], x.D);
}
for (auto x : vv[i]) {
ti[x.id] = ask(1, 1, n, tin[x.u]) + ask(1, 1, n, tin[x.v]) -
2ll * ask(1, 1, n, tin[lca(x.u, x.v)]);
}
for (auto x : P[i]) {
update(1, 1, n, tin[x.B], tout[x.B], -x.D);
}
}
for (int i = 0; i < q; i++) {
cout << sum[i] - ti[i] + cs[i] * nw[i] << "\n";
}
return 0;
}
| [
"expression.operation.unary.add",
"control_flow.branch.if.condition.change"
] | 798,073 | 798,074 | u722777218 | cpp |
p02986 | #pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ld, ld> pdd;
#define fi first
#define se second
#define mp make_pair
#define fastIO \
ios::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
const int N = (int)1e5 + 9;
const int LOG = 20;
int par[LOG][N];
ll dist[N];
int tin[N];
int tout[N];
int tt;
vector<pii> T[N];
void dfs(int u, int pr) {
par[0][u] = pr;
tin[u] = ++tt;
for (int i = 1; i < LOG; i++) {
par[i][u] = par[i - 1][par[i - 1][u]];
}
for (auto x : T[u]) {
if (x.fi == pr)
continue;
dist[x.fi] = dist[u] + x.se;
dfs(x.fi, u);
}
tout[u] = tt;
}
bool is(int a, int b) { return tin[a] <= tin[b] && tout[a] >= tout[b]; }
int lca(int a, int b) {
if (is(a, b))
return a;
if (is(b, a))
return b;
for (int i = LOG - 1; i >= 0; i--) {
if (is(par[i][a], b)) {
a = par[i][a];
}
}
return par[0][a];
}
ll sum[N];
ll cs[N];
ll ti[N];
struct Edge {
ll A;
ll B;
ll D;
};
struct Query {
ll nd;
ll u;
ll v;
ll id;
};
vector<Edge> P[N];
vector<Query> vv[N];
struct Node {
ll value;
ll lazy;
};
ll nw[N];
Node TR[N * 4 + 512];
void push(int node, int cl, int cr) {
TR[node].value += (cr - cl + 1) * 1ll * TR[node].lazy;
if (cl != cr) {
TR[node * 2].lazy += TR[node].lazy;
TR[node * 2 + 1].lazy += TR[node].lazy;
}
TR[node].lazy = 0;
}
void update(int node, int cl, int cr, int tl, int tr, ll v) {
push(node, cl, cr);
if (cr < tl)
return;
if (cl > tr)
return;
if (cl >= tl && cr <= tr) {
TR[node].lazy = v;
push(node, cl, cr);
return;
}
int mid = (cl + cr) / 2;
update(node * 2, cl, mid, tl, tr, v);
update(node * 2 + 1, mid + 1, cr, tl, tr, v);
TR[node].value = TR[node * 2].value + TR[node * 2 + 1].value;
}
int ask(int node, int cl, int cr, int ps) {
push(node, cl, cr);
if (cl == cr)
return TR[node].value;
int mid = (cl + cr) / 2;
if (mid >= ps)
return ask(node * 2, cl, mid, ps);
else
return ask(node * 2 + 1, mid + 1, cr, ps);
}
int main() {
fastIO;
int n, q;
cin >> n >> q;
ll u, v, cl, d;
for (int i = 1; i < n; i++) {
cin >> u >> v >> cl >> d;
T[u].push_back(mp(v, d));
T[v].push_back(mp(u, d));
P[cl].push_back({u, v, d});
}
dfs(1, 1);
ll ci, di, x, y;
for (int i = 0; i < q; i++) {
cin >> ci >> di >> x >> y;
sum[i] = dist[x] + dist[y] - 2 * dist[lca(x, y)];
vv[ci].push_back({di, x, y, i});
nw[i] = di;
}
for (int i = 1; i < N; i++) {
for (auto &x : P[i]) {
if (tin[x.A] > tin[x.B])
swap(x.A, x.B);
}
for (auto x : P[i]) {
update(1, 1, n, tin[x.B], tout[x.B], +1);
}
for (auto x : vv[i]) {
cs[x.id] = ask(1, 1, n, tin[x.u]) + ask(1, 1, n, tin[x.v]) -
2 * ask(1, 1, n, tin[lca(x.u, x.v)]);
}
for (auto x : P[i]) {
update(1, 1, n, tin[x.B], tout[x.B], -1);
}
for (auto x : P[i]) {
update(1, 1, n, tin[x.B], tout[x.B], x.D);
}
for (auto x : vv[i]) {
ti[x.id] = ask(1, 1, n, tin[x.u]) + ask(1, 1, n, tin[x.v]) -
2 * ask(1, 1, n, tin[lca(x.u, x.v)]);
}
for (auto x : P[i]) {
update(1, 1, n, tin[x.B], tout[x.B], -x.D);
}
}
for (int i = 0; i < q; i++) {
cout << sum[i] - ti[i] + cs[i] * nw[i] << "\n";
}
return 0;
}
| #pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ld, ld> pdd;
#define fi first
#define se second
#define mp make_pair
#define fastIO \
ios::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
const int N = (int)1e5 + 9;
const int LOG = 20;
int par[LOG][N];
ll dist[N];
int tin[N];
int tout[N];
int tt;
vector<pii> T[N];
void dfs(int u, int pr) {
par[0][u] = pr;
tin[u] = ++tt;
for (int i = 1; i < LOG; i++) {
par[i][u] = par[i - 1][par[i - 1][u]];
}
for (auto x : T[u]) {
if (x.fi == pr)
continue;
dist[x.fi] = dist[u] + x.se;
dfs(x.fi, u);
}
tout[u] = tt;
}
bool is(int a, int b) { return tin[a] <= tin[b] && tout[a] >= tout[b]; }
int lca(int a, int b) {
if (is(a, b))
return a;
if (is(b, a))
return b;
for (int i = LOG - 1; i >= 0; i--) {
if (!is(par[i][a], b)) {
a = par[i][a];
}
}
return par[0][a];
}
ll sum[N];
ll cs[N];
ll ti[N];
struct Edge {
ll A;
ll B;
ll D;
};
struct Query {
ll nd;
ll u;
ll v;
ll id;
};
vector<Edge> P[N];
vector<Query> vv[N];
struct Node {
ll value;
ll lazy;
};
ll nw[N];
Node TR[N * 4 + 512];
void push(int node, int cl, int cr) {
TR[node].value += (cr - cl + 1) * 1ll * TR[node].lazy;
if (cl != cr) {
TR[node * 2].lazy += TR[node].lazy;
TR[node * 2 + 1].lazy += TR[node].lazy;
}
TR[node].lazy = 0;
}
void update(int node, int cl, int cr, int tl, int tr, ll v) {
push(node, cl, cr);
if (cr < tl)
return;
if (cl > tr)
return;
if (cl >= tl && cr <= tr) {
TR[node].lazy = v;
push(node, cl, cr);
return;
}
int mid = (cl + cr) / 2;
update(node * 2, cl, mid, tl, tr, v);
update(node * 2 + 1, mid + 1, cr, tl, tr, v);
TR[node].value = TR[node * 2].value + TR[node * 2 + 1].value;
}
int ask(int node, int cl, int cr, int ps) {
push(node, cl, cr);
if (cl == cr)
return TR[node].value;
int mid = (cl + cr) / 2;
if (mid >= ps)
return ask(node * 2, cl, mid, ps);
else
return ask(node * 2 + 1, mid + 1, cr, ps);
}
int main() {
fastIO;
int n, q;
cin >> n >> q;
ll u, v, cl, d;
for (int i = 1; i < n; i++) {
cin >> u >> v >> cl >> d;
T[u].push_back(mp(v, d));
T[v].push_back(mp(u, d));
P[cl].push_back({u, v, d});
}
dfs(1, 1);
ll ci, di, x, y;
for (int i = 0; i < q; i++) {
cin >> ci >> di >> x >> y;
sum[i] = dist[x] + dist[y] - 2ll * dist[lca(x, y)];
vv[ci].push_back({di, x, y, i});
nw[i] = di;
}
for (int i = 1; i < N; i++) {
for (auto &x : P[i]) {
if (tin[x.A] > tin[x.B])
swap(x.A, x.B);
}
for (auto x : P[i]) {
update(1, 1, n, tin[x.B], tout[x.B], +1);
}
for (auto x : vv[i]) {
cs[x.id] = ask(1, 1, n, tin[x.u]) + ask(1, 1, n, tin[x.v]) -
2ll * ask(1, 1, n, tin[lca(x.u, x.v)]);
}
for (auto x : P[i]) {
update(1, 1, n, tin[x.B], tout[x.B], -1);
}
for (auto x : P[i]) {
update(1, 1, n, tin[x.B], tout[x.B], x.D);
}
for (auto x : vv[i]) {
ti[x.id] = ask(1, 1, n, tin[x.u]) + ask(1, 1, n, tin[x.v]) -
2ll * ask(1, 1, n, tin[lca(x.u, x.v)]);
}
for (auto x : P[i]) {
update(1, 1, n, tin[x.B], tout[x.B], -x.D);
}
}
for (int i = 0; i < q; i++) {
cout << sum[i] - ti[i] + cs[i] * nw[i] << "\n";
}
return 0;
}
| [
"expression.operation.unary.add",
"control_flow.branch.if.condition.change"
] | 798,075 | 798,074 | u722777218 | cpp |
p02986 | // Daniel Grzegorzewski
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#pragma GCC optimize("O3")
#define MP make_pair
#define PB push_back
#define ST first
#define ND second
using namespace __gnu_pbds;
using namespace std;
template <typename T>
using ordered_set =
tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
typedef pair<int, int> PII;
typedef vector<int> VI;
typedef vector<PII> VII;
typedef long long LL;
void init_ios() {
ios_base::sync_with_stdio(0);
cin.tie(0);
}
const int N = (1 << 17);
const int LG = 18;
const int SQ = 318;
int n, q, a[N], b[N], c[N], d[N], oj[N];
int qt = 1, hm[N], qh[N], qin[N], qout[2 * N], qpar[N][LG], qsum[N][LG],
qsiz[N];
int re, bla, who[SQ], id[N];
PII cur[N], wyn[SQ][N];
bool qvis[N];
VII qchild[N];
void dfs1(int v) {
qvis[v] = true;
qsiz[v] = 1;
qin[v] = qt++;
for (int i = 1; i < LG; ++i) {
qpar[v][i] = qpar[qpar[v][i - 1]][i - 1];
qsum[v][i] = qsum[v][i - 1] + qsum[qpar[v][i - 1]][i - 1];
}
for (auto x : qchild[v])
if (!qvis[x.ST]) {
qpar[x.ST][0] = v;
qsum[x.ST][0] = d[x.ND];
qh[x.ST] = 1 + qh[v];
oj[x.ST] = x.ND;
dfs1(x.ST);
qsiz[v] += qsiz[x.ST];
}
qout[v] = qt++;
}
bool ancestor(int u, int v) {
if (u == 0)
return true;
return (qin[u] <= qin[v] && qout[v] <= qout[u]);
}
int lca(int u, int v) {
if (ancestor(u, v))
return u;
if (ancestor(v, u))
return v;
for (int i = LG - 1; i >= 0; --i) {
while (i && ancestor(qpar[u][i], v))
--i;
if (i >= 0)
u = qpar[u][i];
}
return qpar[u][0];
}
// u - anc v
int sum(int u, int v) {
int d = qh[v] - qh[u];
int res = 0;
for (int i = LG - 1; i >= 0; --i)
if (d & (1 << i)) {
res += qsum[v][i];
v = qpar[v][i];
}
return res;
}
void dfs2(int v) {
if (qh[v] % SQ == re) {
for (int i = 1; i < n; ++i)
wyn[bla][i] = cur[i];
who[bla] = v;
id[v] = bla++;
}
for (auto p : qchild[v])
if (p.ST != qpar[v][0]) {
cur[c[p.ND]].ST += d[p.ND];
cur[c[p.ND]].ND++;
dfs2(p.ST);
cur[c[p.ND]].ST -= d[p.ND];
cur[c[p.ND]].ND--;
}
}
PII operator+(PII x, PII y) { return {x.ST + y.ST, x.ND + y.ND}; }
PII ans(int v, int kol) {
PII res = {0, 0};
while (v && qh[v] % SQ != re) {
int nr = oj[v];
if (c[nr] == kol)
res = res + MP(d[nr], 1);
v = qpar[v][0];
}
if (v)
res = res + wyn[id[v]][kol];
return res;
}
int main() {
init_ios();
cin >> n >> q;
for (int i = 1; i < n; ++i) {
cin >> a[i] >> b[i] >> c[i] >> d[i];
qchild[a[i]].PB({b[i], i});
qchild[b[i]].PB({a[i], i});
}
dfs1(1);
for (int i = 1; i <= n; ++i)
++hm[qh[i] % SQ];
for (int i = 0; i < SQ; ++i)
if (hm[i] < SQ)
re = i;
dfs2(1);
while (q--) {
int x, y, u, v;
cin >> x >> y >> u >> v;
int z = lca(u, v);
PII ile = ans(u, x) + ans(v, x);
PII bla = ans(z, x);
ile.ST -= 2 * bla.ST;
ile.ND -= 2 * bla.ND;
int suma = sum(z, u) + sum(z, v);
suma -= ile.ST;
suma += y * ile.ND;
cout << suma << "\n";
}
} | // Daniel Grzegorzewski
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#pragma GCC optimize("O3")
#define MP make_pair
#define PB push_back
#define ST first
#define ND second
using namespace __gnu_pbds;
using namespace std;
template <typename T>
using ordered_set =
tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
typedef pair<int, int> PII;
typedef vector<int> VI;
typedef vector<PII> VII;
typedef long long LL;
void init_ios() {
ios_base::sync_with_stdio(0);
cin.tie(0);
}
const int N = (1 << 17);
const int LG = 18;
const int SQ = 318;
int n, q, a[N], b[N], c[N], d[N], oj[N];
int qt = 1, hm[N], qh[N], qin[N], qout[2 * N], qpar[N][LG], qsum[N][LG],
qsiz[N];
int re, bla, who[SQ], id[N];
PII cur[N], wyn[SQ][N];
bool qvis[N];
VII qchild[N];
void dfs1(int v) {
qvis[v] = true;
qsiz[v] = 1;
qin[v] = qt++;
for (int i = 1; i < LG; ++i) {
qpar[v][i] = qpar[qpar[v][i - 1]][i - 1];
qsum[v][i] = qsum[v][i - 1] + qsum[qpar[v][i - 1]][i - 1];
}
for (auto x : qchild[v])
if (!qvis[x.ST]) {
qpar[x.ST][0] = v;
qsum[x.ST][0] = d[x.ND];
qh[x.ST] = 1 + qh[v];
oj[x.ST] = x.ND;
dfs1(x.ST);
qsiz[v] += qsiz[x.ST];
}
qout[v] = qt++;
}
bool ancestor(int u, int v) {
if (u == 0)
return true;
return (qin[u] <= qin[v] && qout[v] <= qout[u]);
}
int lca(int u, int v) {
if (ancestor(u, v))
return u;
if (ancestor(v, u))
return v;
for (int i = LG - 1; i >= 0; --i) {
while (i >= 0 && ancestor(qpar[u][i], v))
--i;
if (i >= 0)
u = qpar[u][i];
}
return qpar[u][0];
}
// u - anc v
int sum(int u, int v) {
int d = qh[v] - qh[u];
int res = 0;
for (int i = LG - 1; i >= 0; --i)
if (d & (1 << i)) {
res += qsum[v][i];
v = qpar[v][i];
}
return res;
}
void dfs2(int v) {
if (qh[v] % SQ == re) {
for (int i = 1; i < n; ++i)
wyn[bla][i] = cur[i];
who[bla] = v;
id[v] = bla++;
}
for (auto p : qchild[v])
if (p.ST != qpar[v][0]) {
cur[c[p.ND]].ST += d[p.ND];
cur[c[p.ND]].ND++;
dfs2(p.ST);
cur[c[p.ND]].ST -= d[p.ND];
cur[c[p.ND]].ND--;
}
}
PII operator+(PII x, PII y) { return {x.ST + y.ST, x.ND + y.ND}; }
PII ans(int v, int kol) {
PII res = {0, 0};
while (v && qh[v] % SQ != re) {
int nr = oj[v];
if (c[nr] == kol)
res = res + MP(d[nr], 1);
v = qpar[v][0];
}
if (v)
res = res + wyn[id[v]][kol];
return res;
}
int main() {
init_ios();
cin >> n >> q;
for (int i = 1; i < n; ++i) {
cin >> a[i] >> b[i] >> c[i] >> d[i];
qchild[a[i]].PB({b[i], i});
qchild[b[i]].PB({a[i], i});
}
dfs1(1);
for (int i = 1; i <= n; ++i)
++hm[qh[i] % SQ];
for (int i = 0; i < SQ; ++i)
if (hm[i] < SQ)
re = i;
dfs2(1);
while (q--) {
int x, y, u, v;
cin >> x >> y >> u >> v;
int z = lca(u, v);
PII ile = ans(u, x) + ans(v, x);
PII bla = ans(z, x);
ile.ST -= 2 * bla.ST;
ile.ND -= 2 * bla.ND;
int suma = sum(z, u) + sum(z, v);
suma -= ile.ST;
suma += y * ile.ND;
cout << suma << "\n";
}
} | [
"control_flow.loop.condition.change",
"control_flow.loop.for.condition.change"
] | 798,076 | 798,077 | u413886749 | cpp |
p02986 | /*
Rathin Bhargava
IIIT Bangalore
*/
#include <bits/stdc++.h>
#define mt make_tuple
#define mp make_pair
#define pu push_back
#define INF 1000000001
#define MOD 1000000007
// #define ll long long int
#define int long long int
#define ld long double
#define fi first
#define se second
#define pr(v) \
{ \
for (int i = 0; i < v.size(); i++) { \
v[i] == INF ? cout << "INF " : cout << v[i] << " "; \
} \
cout << endl; \
}
#define t1(x) cerr << #x << " : " << x << endl
#define t2(x, y) cerr << #x << " : " << x << " " << #y << " : " << y << endl
#define t3(x, y, z) \
cerr << #x << " : " << x << " " << #y << " : " << y << " " << #z << " : " \
<< z << endl
#define t4(a, b, c, d) \
cerr << #a << " : " << a << " " << #b << " : " << b << " " << #c << " : " \
<< c << " " << #d << " : " << d << endl
#define t5(a, b, c, d, e) \
cerr << #a << " : " << a << " " << #b << " : " << b << " " << #c << " : " \
<< c << " " << #d << " : " << d << " " << #e << " : " << e << endl
#define t6(a, b, c, d, e, f) \
cerr << #a << " : " << a << " " << #b << " : " << b << " " << #c << " : " \
<< c << " " << #d << " : " << d << " " << #e << " : " << e << " " << #f \
<< " : " << f << endl
#define GET_MACRO(_1, _2, _3, _4, _5, _6, NAME, ...) NAME
#define t(...) GET_MACRO(__VA_ARGS__, t6, t5, t4, t3, t2, t1)(__VA_ARGS__)
#define _ cerr << "here" << endl;
#define __ \
{ \
ios::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL); \
}
using namespace std;
template <class A, class B>
ostream &operator<<(ostream &out, const pair<A, B> &a) {
return out << "(" << a.first << ", " << a.second << ")";
}
template <int> ostream &operator<<(ostream &os, const vector<int> &v) {
os << "[";
for (int i = 0; i < v.size(); ++i) {
if (v[i] != INF)
os << v[i];
else
os << "INF";
if (i != v.size() - 1)
os << ", ";
}
os << "]\n";
return os;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
os << "[";
for (int i = 0; i < v.size(); ++i) {
os << v[i];
;
if (i != v.size() - 1)
os << ", ";
}
os << "]\n";
return os;
}
const int N = 2e5 + 1;
vector<int> adj[N] = {};
vector<int> adj2[N] = {};
int MAXN = 2e5 + 1, MAXLOG = 25;
int parent[N][25] = {0};
int height[N] = {0};
struct pair_hash {
template <class T1, class T2>
std::size_t operator()(const std::pair<T1, T2> &p) const {
auto h1 = std::hash<T1>{}(p.first);
auto h2 = std::hash<T2>{}(p.second);
// Mainly for demonstration purposes, i.e. works but is overly simple
// In the real world, use sth. like boost.hash_combine
return h1 ^ h2;
}
};
void dfsLCA(int u = 0, int p = -1) {
// t(u);
if (p + 1)
height[u] = height[p] + 1;
parent[u][0] = p;
for (int i = 1; i < MAXLOG; i++) {
if (parent[u][i - 1] + 1) {
parent[u][i] = parent[parent[u][i - 1]][i - 1];
}
}
for (auto v : adj[u])
if (p - v)
dfsLCA(v, u);
}
int lca(int u, int v) {
// height means depth here
if (height[v] > height[u])
swap(u, v);
for (int i = MAXLOG - 1; i >= 0; i--) {
if (parent[u][i] + 1 && height[parent[u][i]] >= height[v])
u = parent[u][i];
}
// height[u]==height[v]
if (u == v)
return u;
for (int i = MAXLOG - 1; i >= 0; i--) {
if (parent[u][i] != parent[v][i]) {
u = parent[u][i];
v = parent[v][i];
}
}
return parent[v][0];
}
int colour[N] = {0};
int dist[N] = {0};
int distcol[N] = {0};
unordered_map<pair<int, int>, int, pair_hash> d;
unordered_map<pair<int, int>, int, pair_hash> col;
unordered_map<pair<int, int>, int, pair_hash> answercol;
unordered_map<pair<int, int>, int, pair_hash> answerdcol;
void dfs3(int u = 0, int p = -1) {
// Answer queries for u here
// t(u);
for (auto v : adj2[u]) {
answercol[mp(u, v)] = colour[v];
answerdcol[mp(u, v)] = distcol[v];
}
for (auto v : adj[u]) {
if (v - p) {
colour[col[mp(u, v)]]++;
distcol[col[mp(u, v)]] += d[mp(u, v)];
dfs3(v, u);
colour[col[mp(u, v)]]--;
distcol[col[mp(u, v)]] -= d[mp(u, v)];
}
}
}
int dfs2(int u = 0, int p = -1, int val = 0) {
dist[u] = val;
for (auto v : adj[u])
if (v - p)
dfs2(v, u, val + d[mp(u, v)]);
return dist[u];
}
int32_t main() {
__;
int n, q;
cin >> n >> q;
vector<vector<int>> ans;
for (int i = 0; i < n - 1; i++) {
int a, b, c, di;
cin >> a >> b >> c >> di;
a--;
b--;
adj[a].pu(b);
adj[b].pu(a);
col[mp(a, b)] = col[mp(b, a)] = c;
d[mp(a, b)] = d[mp(b, a)] = di;
}
dfsLCA();
for (int h = 1; h <= q; h++) {
int a, b, c, d;
cin >> a >> b >> c >> d;
c--;
d--;
ans.pu({a, b, c, d});
adj2[c].pu(a);
adj2[d].pu(a);
adj2[lca(c, d)].pu(a);
}
dfs2();
dfs3();
for (int i = 0; i < ans.size(); i++) {
int x = ans[i][2], y = ans[i][3], z = lca(x, y);
int co = ans[i][0], change = ans[i][1];
int a = dist[x], b = dist[y], c = dist[z];
a += answercol[mp(x, co)] * change - answerdcol[mp(x, co)];
b += answercol[mp(y, co)] * change - answerdcol[mp(y, co)];
c += answercol[mp(z, co)] * change - answerdcol[mp(z, co)];
cout << a + b - c << endl;
}
return 0;
}
| /*
Rathin Bhargava
IIIT Bangalore
*/
#include <bits/stdc++.h>
#define mt make_tuple
#define mp make_pair
#define pu push_back
#define INF 1000000001
#define MOD 1000000007
#define ll long long int
#define ld long double
#define fi first
#define se second
#define pr(v) \
{ \
for (int i = 0; i < v.size(); i++) { \
v[i] == INF ? cout << "INF " : cout << v[i] << " "; \
} \
cout << endl; \
}
#define t1(x) cerr << #x << " : " << x << endl
#define t2(x, y) cerr << #x << " : " << x << " " << #y << " : " << y << endl
#define t3(x, y, z) \
cerr << #x << " : " << x << " " << #y << " : " << y << " " << #z << " : " \
<< z << endl
#define t4(a, b, c, d) \
cerr << #a << " : " << a << " " << #b << " : " << b << " " << #c << " : " \
<< c << " " << #d << " : " << d << endl
#define t5(a, b, c, d, e) \
cerr << #a << " : " << a << " " << #b << " : " << b << " " << #c << " : " \
<< c << " " << #d << " : " << d << " " << #e << " : " << e << endl
#define t6(a, b, c, d, e, f) \
cerr << #a << " : " << a << " " << #b << " : " << b << " " << #c << " : " \
<< c << " " << #d << " : " << d << " " << #e << " : " << e << " " << #f \
<< " : " << f << endl
#define GET_MACRO(_1, _2, _3, _4, _5, _6, NAME, ...) NAME
#define t(...) GET_MACRO(__VA_ARGS__, t6, t5, t4, t3, t2, t1)(__VA_ARGS__)
#define _ cerr << "here" << endl;
#define __ \
{ \
ios::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL); \
}
using namespace std;
template <class A, class B>
ostream &operator<<(ostream &out, const pair<A, B> &a) {
return out << "(" << a.first << ", " << a.second << ")";
}
template <int> ostream &operator<<(ostream &os, const vector<int> &v) {
os << "[";
for (int i = 0; i < v.size(); ++i) {
if (v[i] != INF)
os << v[i];
else
os << "INF";
if (i != v.size() - 1)
os << ", ";
}
os << "]\n";
return os;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
os << "[";
for (int i = 0; i < v.size(); ++i) {
os << v[i];
;
if (i != v.size() - 1)
os << ", ";
}
os << "]\n";
return os;
}
const int N = 2e5 + 1;
vector<int> adj[N] = {};
vector<int> adj2[N] = {};
int MAXN = 2e5 + 1, MAXLOG = 25;
int parent[N][25] = {0};
int height[N] = {0};
struct pair_hash {
template <class T1, class T2>
std::size_t operator()(const std::pair<T1, T2> &p) const {
auto h1 = std::hash<T1>{}(p.first);
auto h2 = std::hash<T2>{}(p.second);
// Mainly for demonstration purposes, i.e. works but is overly simple
// In the real world, use sth. like boost.hash_combine
return h1 ^ h2;
}
};
void dfsLCA(int u = 0, int p = -1) {
// t(u);
if (p + 1)
height[u] = height[p] + 1;
parent[u][0] = p;
for (int i = 1; i < MAXLOG; i++) {
if (parent[u][i - 1] + 1) {
parent[u][i] = parent[parent[u][i - 1]][i - 1];
}
}
for (auto v : adj[u])
if (p - v)
dfsLCA(v, u);
}
int lca(int u, int v) {
// height means depth here
if (height[v] > height[u])
swap(u, v);
for (int i = MAXLOG - 1; i >= 0; i--) {
if (parent[u][i] + 1 && height[parent[u][i]] >= height[v])
u = parent[u][i];
}
// height[u]==height[v]
if (u == v)
return u;
for (int i = MAXLOG - 1; i >= 0; i--) {
if (parent[u][i] != parent[v][i]) {
u = parent[u][i];
v = parent[v][i];
}
}
return parent[v][0];
}
int colour[N] = {0};
int dist[N] = {0};
int distcol[N] = {0};
unordered_map<pair<int, int>, int, pair_hash> d;
unordered_map<pair<int, int>, int, pair_hash> col;
unordered_map<pair<int, int>, int, pair_hash> answercol;
unordered_map<pair<int, int>, int, pair_hash> answerdcol;
void dfs3(int u = 0, int p = -1) {
// Answer queries for u here
// t(u);
for (auto v : adj2[u]) {
answercol[mp(u, v)] = colour[v];
answerdcol[mp(u, v)] = distcol[v];
}
for (auto v : adj[u]) {
if (v - p) {
colour[col[mp(u, v)]]++;
distcol[col[mp(u, v)]] += d[mp(u, v)];
dfs3(v, u);
colour[col[mp(u, v)]]--;
distcol[col[mp(u, v)]] -= d[mp(u, v)];
}
}
}
int dfs2(int u = 0, int p = -1, int val = 0) {
dist[u] = val;
for (auto v : adj[u])
if (v - p)
dfs2(v, u, val + d[mp(u, v)]);
return dist[u];
}
int main() {
__;
int n, q;
cin >> n >> q;
vector<vector<int>> ans;
for (int i = 0; i < n - 1; i++) {
int a, b, c, di;
cin >> a >> b >> c >> di;
a--;
b--;
adj[a].pu(b);
adj[b].pu(a);
col[mp(a, b)] = col[mp(b, a)] = c;
d[mp(a, b)] = d[mp(b, a)] = di;
}
dfsLCA();
for (int h = 1; h <= q; h++) {
int a, b, c, d;
cin >> a >> b >> c >> d;
c--;
d--;
ans.pu({a, b, c, d});
adj2[c].pu(a);
adj2[d].pu(a);
adj2[lca(c, d)].pu(a);
}
dfs2();
dfs3();
for (int i = 0; i < ans.size(); i++) {
int x = ans[i][2], y = ans[i][3], z = lca(x, y);
int co = ans[i][0], change = ans[i][1];
int a = dist[x], b = dist[y], c = dist[z];
a += answercol[mp(x, co)] * change - answerdcol[mp(x, co)];
b += answercol[mp(y, co)] * change - answerdcol[mp(y, co)];
c += answercol[mp(z, co)] * change - answerdcol[mp(z, co)];
cout << a + b - 2 * c << endl;
}
return 0;
}
| [
"identifier.change",
"function.return_type.change"
] | 798,098 | 798,099 | u760425207 | cpp |
p02986 | #include <bits/stdc++.h>
using namespace std;
const int maxn = 100100, lg = 20;
struct query {
int i, x, y, sig;
};
vector<tuple<int, int, int>> e[maxn];
vector<query> que[maxn];
int par[lg][maxn], dep[maxn];
void dfs(int u, int p) {
par[0][u] = p;
for (auto ee : e[u]) {
int to, b, c;
tie(to, b, c);
if (to != p) {
dep[to] = dep[u] + 1;
dfs(to, u);
}
}
}
int lca(int u, int v) {
if (dep[u] < dep[v])
swap(u, v);
for (int i = lg - 1; i >= 0; i--)
if ((dep[u] - dep[v]) & (1 << i))
u = par[i][u];
if (u == v)
return u;
for (int i = lg - 1; i >= 0; i--)
if (par[i][u] != par[i][v])
u = par[i][u], v = par[i][v];
return par[0][u];
}
int ans[maxn], tot[maxn], amn[maxn];
void solve(int u, int p, int d) {
for (auto q : que[u]) {
ans[q.i] += q.sig * (d - tot[q.x] + q.y * amn[q.x]);
}
for (auto ee : e[u]) {
int to, c, di;
tie(to, c, di) = ee;
if (to == p)
continue;
tot[c] += di;
amn[c] += 1;
solve(to, u, d + di);
tot[c] -= di;
amn[c] -= 1;
}
}
int main() {
int n, q;
cin >> n >> q;
for (int i = 0; i < n - 1; i++) {
int a, b, c, d;
cin >> a >> b >> c >> d;
e[a].push_back(make_tuple(b, c, d));
e[b].push_back(make_tuple(a, c, d));
}
dfs(1, 0);
for (int i = 1; i < lg; i++) {
for (int j = 1; j <= n; j++)
if (par[i - 1][j])
par[i][j] = par[i - 1][par[i - 1][j]];
}
for (int i = 0; i < q; i++) {
int x, y, u, v;
cin >> x >> y >> u >> v;
que[u].push_back({i, x, y, 1});
que[v].push_back({i, x, y, 1});
que[lca(u, v)].push_back({i, x, y, -2});
}
solve(1, 0, 0);
for (int i = 0; i < q; i++)
cout << ans[i] << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
const int maxn = 100100, lg = 20;
struct query {
int i, x, y, sig;
};
vector<tuple<int, int, int>> e[maxn];
vector<query> que[maxn];
int par[lg][maxn], dep[maxn];
void dfs(int u, int p) {
par[0][u] = p;
for (auto ee : e[u]) {
int to, b, c;
tie(to, b, c) = ee;
if (to != p) {
dep[to] = dep[u] + 1;
dfs(to, u);
}
}
}
int lca(int u, int v) {
if (dep[u] < dep[v])
swap(u, v);
for (int i = lg - 1; i >= 0; i--)
if ((dep[u] - dep[v]) & (1 << i))
u = par[i][u];
if (u == v)
return u;
for (int i = lg - 1; i >= 0; i--)
if (par[i][u] != par[i][v])
u = par[i][u], v = par[i][v];
return par[0][u];
}
int ans[maxn], tot[maxn], amn[maxn];
void solve(int u, int p, int d) {
for (auto q : que[u]) {
ans[q.i] += q.sig * (d - tot[q.x] + q.y * amn[q.x]);
}
for (auto ee : e[u]) {
int to, c, di;
tie(to, c, di) = ee;
if (to == p)
continue;
tot[c] += di;
amn[c] += 1;
solve(to, u, d + di);
tot[c] -= di;
amn[c] -= 1;
}
}
int main() {
int n, q;
cin >> n >> q;
for (int i = 0; i < n - 1; i++) {
int a, b, c, d;
cin >> a >> b >> c >> d;
e[a].push_back(make_tuple(b, c, d));
e[b].push_back(make_tuple(a, c, d));
}
dfs(1, 0);
for (int i = 1; i < lg; i++) {
for (int j = 1; j <= n; j++)
if (par[i - 1][j])
par[i][j] = par[i - 1][par[i - 1][j]];
}
for (int i = 0; i < q; i++) {
int x, y, u, v;
cin >> x >> y >> u >> v;
que[u].push_back({i, x, y, 1});
que[v].push_back({i, x, y, 1});
que[lca(u, v)].push_back({i, x, y, -2});
}
solve(1, 0, 0);
for (int i = 0; i < q; i++)
cout << ans[i] << endl;
return 0;
}
| [
"assignment.change"
] | 798,100 | 798,101 | u251828455 | cpp |
p02986 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <queue>
#include <utility>
#include <vector>
#define maxn 100005
#define maxq 100005
#define mp make_pair
using namespace std;
typedef long long ll;
const int LEN = 100000;
typedef pair<int, int> P;
struct fastio {
char s[LEN + 5];
int len, it;
fastio() { it = len = 0; }
char get() {
if (it < len)
return s[it++];
it = 0, len = fread(s, 1, LEN, stdin);
return len ? s[it++] : EOF;
}
bool notend() {
char c;
for (c = get(); c == ' ' || c == '\n'; c = get())
;
if (it)
it--;
return c != EOF;
}
void put(char c) {
if (len == LEN)
fwrite(s, 1, LEN, stdout), len = 0;
s[len++] = c;
}
void flush() {
fwrite(s, 1, len, stdout);
len = 0;
}
} buff, bufo;
inline int getint() {
char c;
int res = 0, sig = 1;
for (c = buff.get(); c < '0' || c > '9'; c = buff.get())
if (c == '-')
sig = -1;
for (; c >= '0' && c <= '9'; c = buff.get())
res = (res << 3) + (res << 1) + (c - '0');
return sig * res;
}
inline void putll(ll x) {
if (!x)
bufo.put('0');
else if (x < 0)
bufo.put('-'), x = -x;
char s[25];
int k = 0;
while (x) {
s[++k] = x % 10 + '0';
x /= 10;
}
for (int i = k; i >= 1; i--)
bufo.put(s[i]);
}
int n, q;
struct edge {
int to, id;
edge(int to = 0, int id = 0) : to(to), id(id) {}
};
vector<edge> adj[maxn];
int cst[maxn];
int maxlog = 17, t[18][maxn << 2], k, row[maxn << 1], dep[maxn], sum[maxn], lk;
int id[maxn];
int eid[maxn][2], bit2[maxn << 1], bit1[maxn << 1];
void add(int *bit, int pos, int x) {
for (int i = pos; i <= n; i += i & -i)
bit[i] += x;
}
int query(int *bit, int pos) {
int res = 0;
for (int i = pos; i; i -= i & -i)
res += bit[i];
return res;
}
int min_(int a, int b) { return dep[a] < dep[b] ? a : b; }
void dfs(int u, int f) {
t[0][++lk] = u;
id[u] = lk;
dep[u] = (f == -1) ? 0 : dep[f] + 1;
for (int i = 0; i < (int)adj[u].size(); i++) {
edge e = adj[u][i];
if (e.to == f)
continue;
eid[e.id][0] = lk + 1;
sum[e.to] = sum[u] + cst[e.id];
dfs(e.to, u);
t[0][++lk] = u;
eid[e.id][1] = lk;
}
}
void rmq_ini() {
int st = 2;
for (int i = 1; i <= lk; i++) {
if (i == st) {
row[i] = row[i - 1] + 1;
st <<= 1;
} else {
row[i] = row[i - 1];
}
}
for (int i = 1; i <= maxlog; i++) {
for (int j = 1; j + (1 << i) - 1 <= lk; j++) {
t[i][j] = min_(t[i - 1][j], t[i - 1][j + (1 << (i - 1))]);
}
}
}
int lca(int u, int v) {
u = id[u], v = id[v];
if (u == v)
return t[0][u];
if (u > v)
swap(u, v);
int ro = row[v - u];
return min_(t[ro][u], t[ro][v - (1 << ro) + 1]);
}
vector<int> color[maxn]; // edge ids.
struct Query {
int y, u, v, id;
Query(int y = 0, int u = 0, int v = 0, int id = 0)
: y(y), u(u), v(v), id(id) {}
};
vector<Query> qcol[maxn];
ll ans[maxq];
int main() {
n = getint(), q = getint();
for (int i = 1; i < n; i++) {
int u = getint(), v = getint(), c = getint(), d = getint();
color[c].push_back(i);
cst[i] = d;
adj[u].push_back(edge(v, i));
adj[v].push_back(edge(u, i));
}
dfs(1, -1);
rmq_ini();
for (int i = 1; i <= q; i++) {
int x = getint(), y = getint(), u = getint(), v = getint();
qcol[x].push_back(Query(y, u, v, i));
}
for (int i = 1; i < n; i++) {
if (qcol[i].size() == 0)
continue;
for (int j = 0; j < (int)color[i].size(); j++) {
int id = color[i][j];
add(bit1, eid[id][0], 1);
add(bit1, eid[id][1], -1);
add(bit2, eid[id][0], cst[id]);
add(bit2, eid[id][1], -cst[id]);
}
for (int j = 0; j < (int)qcol[i].size(); j++) {
Query q1 = qcol[i][j];
int p = lca(q1.u, q1.v);
ll res = (ll)sum[q1.u] + sum[q1.v] - 2ll * sum[p];
res -= (ll)query(bit2, id[q1.u]) + query(bit2, id[q1.v]) -
2ll * query(bit2, id[p]);
res += (ll)q1.y * (query(bit1, id[q1.u]) + query(bit1, id[q1.v]) -
2 * query(bit1, id[p]));
ans[q1.id] = res;
}
for (int j = 0; j < (int)color[i].size(); j++) {
int id = color[i][j];
add(bit1, eid[id][0], -1);
add(bit1, eid[id][1], 1);
add(bit2, eid[id][0], -cst[id]);
add(bit2, eid[id][1], cst[id]);
}
}
for (int i = 1; i <= q; i++) {
putll(ans[i]);
bufo.put('\n');
}
bufo.flush();
return 0;
}
| #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <queue>
#include <utility>
#include <vector>
#define maxn 100005
#define maxq 100005
#define mp make_pair
using namespace std;
typedef long long ll;
const int LEN = 100000;
typedef pair<int, int> P;
struct fastio {
char s[LEN + 5];
int len, it;
fastio() { it = len = 0; }
char get() {
if (it < len)
return s[it++];
it = 0, len = fread(s, 1, LEN, stdin);
return len ? s[it++] : EOF;
}
bool notend() {
char c;
for (c = get(); c == ' ' || c == '\n'; c = get())
;
if (it)
it--;
return c != EOF;
}
void put(char c) {
if (len == LEN)
fwrite(s, 1, LEN, stdout), len = 0;
s[len++] = c;
}
void flush() {
fwrite(s, 1, len, stdout);
len = 0;
}
} buff, bufo;
inline int getint() {
char c;
int res = 0, sig = 1;
for (c = buff.get(); c < '0' || c > '9'; c = buff.get())
if (c == '-')
sig = -1;
for (; c >= '0' && c <= '9'; c = buff.get())
res = (res << 3) + (res << 1) + (c - '0');
return sig * res;
}
inline void putll(ll x) {
if (!x)
bufo.put('0');
else if (x < 0)
bufo.put('-'), x = -x;
char s[25];
int k = 0;
while (x) {
s[++k] = x % 10 + '0';
x /= 10;
}
for (int i = k; i >= 1; i--)
bufo.put(s[i]);
}
int n, q;
struct edge {
int to, id;
edge(int to = 0, int id = 0) : to(to), id(id) {}
};
vector<edge> adj[maxn];
int cst[maxn];
int maxlog = 17, t[18][maxn << 1], k, row[maxn << 1], dep[maxn], sum[maxn], lk;
int id[maxn];
int eid[maxn][2], bit2[maxn << 1], bit1[maxn << 1];
void add(int *bit, int pos, int x) {
for (int i = pos; i <= lk; i += i & -i)
bit[i] += x;
}
int query(int *bit, int pos) {
int res = 0;
for (int i = pos; i; i -= i & -i)
res += bit[i];
return res;
}
int min_(int a, int b) { return dep[a] < dep[b] ? a : b; }
void dfs(int u, int f) {
t[0][++lk] = u;
id[u] = lk;
dep[u] = (f == -1) ? 0 : dep[f] + 1;
for (int i = 0; i < (int)adj[u].size(); i++) {
edge e = adj[u][i];
if (e.to == f)
continue;
eid[e.id][0] = lk + 1;
sum[e.to] = sum[u] + cst[e.id];
dfs(e.to, u);
t[0][++lk] = u;
eid[e.id][1] = lk;
}
}
void rmq_ini() {
int st = 2;
for (int i = 1; i <= lk; i++) {
if (i == st) {
row[i] = row[i - 1] + 1;
st <<= 1;
} else {
row[i] = row[i - 1];
}
}
for (int i = 1; i <= maxlog; i++) {
for (int j = 1; j + (1 << i) - 1 <= lk; j++) {
t[i][j] = min_(t[i - 1][j], t[i - 1][j + (1 << (i - 1))]);
}
}
}
int lca(int u, int v) {
u = id[u], v = id[v];
if (u == v)
return t[0][u];
if (u > v)
swap(u, v);
int ro = row[v - u];
return min_(t[ro][u], t[ro][v - (1 << ro) + 1]);
}
vector<int> color[maxn]; // edge ids.
struct Query {
int y, u, v, id;
Query(int y = 0, int u = 0, int v = 0, int id = 0)
: y(y), u(u), v(v), id(id) {}
};
vector<Query> qcol[maxn];
ll ans[maxq];
int main() {
n = getint(), q = getint();
for (int i = 1; i < n; i++) {
int u = getint(), v = getint(), c = getint(), d = getint();
color[c].push_back(i);
cst[i] = d;
adj[u].push_back(edge(v, i));
adj[v].push_back(edge(u, i));
}
dfs(1, -1);
rmq_ini();
for (int i = 1; i <= q; i++) {
int x = getint(), y = getint(), u = getint(), v = getint();
qcol[x].push_back(Query(y, u, v, i));
}
for (int i = 1; i < n; i++) {
if (qcol[i].size() == 0)
continue;
for (int j = 0; j < (int)color[i].size(); j++) {
int id = color[i][j];
add(bit1, eid[id][0], 1);
add(bit1, eid[id][1], -1);
add(bit2, eid[id][0], cst[id]);
add(bit2, eid[id][1], -cst[id]);
}
for (int j = 0; j < (int)qcol[i].size(); j++) {
Query q1 = qcol[i][j];
int p = lca(q1.u, q1.v);
ll res = (ll)sum[q1.u] + sum[q1.v] - 2ll * sum[p];
res -= (ll)query(bit2, id[q1.u]) + query(bit2, id[q1.v]) -
2ll * query(bit2, id[p]);
res += (ll)q1.y * (query(bit1, id[q1.u]) + query(bit1, id[q1.v]) -
2 * query(bit1, id[p]));
ans[q1.id] = res;
}
for (int j = 0; j < (int)color[i].size(); j++) {
int id = color[i][j];
add(bit1, eid[id][0], -1);
add(bit1, eid[id][1], 1);
add(bit2, eid[id][0], -cst[id]);
add(bit2, eid[id][1], cst[id]);
}
}
for (int i = 1; i <= q; i++) {
putll(ans[i]);
bufo.put('\n');
}
bufo.flush();
return 0;
}
| [
"literal.number.change",
"expression.operation.binary.change",
"identifier.change",
"control_flow.loop.for.condition.change"
] | 798,104 | 798,105 | u002547574 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.