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 |
|---|---|---|---|---|---|---|---|
p02986 | #include <cstdio>
#include <cstdlib>
#include <cstring>
#include <tuple>
#include <vector>
using namespace std;
const int N = 100'009;
int ct;
vector<tuple<int, int, int>> g[N];
int pa[N];
int tin[N];
int tout[N];
void dfs1(int x) {
tin[x] = ct++;
for (auto &e : g[x]) {
int y = get<0>(e);
if (y != pa[x]) {
pa[y] = x;
dfs1(y);
}
}
tout[x] = ct++;
}
bool anc(int x, int y) { return tin[x] <= tin[y] && tout[x] >= tout[y]; }
const int LG = 20;
int kp[LG][N];
int lca(int x, int y) {
if (anc(x, y)) {
return x;
}
for (int i = LG - 1; i >= 0; --i) {
if (!anc(kp[i][x], y)) {
x = kp[i][x];
}
}
return pa[x];
}
int qc[N];
int qd[N];
vector<int> q[N];
int cnt[N];
int sum[N];
int ans[N];
void dfs2(int x, int dist) {
for (int i : q[x]) {
int j = abs(i);
int cur = dist - sum[qc[j]] + cnt[qc[j]] * qd[j];
if (i < 0) {
cur = -cur;
}
ans[j] += cur;
}
for (auto &e : g[x]) {
int y = get<0>(e);
if (y == pa[x]) {
continue;
}
int c = get<1>(e);
int d = get<2>(e);
++cnt[c];
sum[c] += d;
dfs2(y, dist + d);
--cnt[c];
sum[c] -= d;
}
}
int main() {
int n, qq;
scanf("%d%d", &n, &qq);
for (int i = 0; i < n; ++i) {
g[i].clear();
}
for (int i = 0; i < n - 1; ++i) {
int x, y, c, d;
scanf("%d%d%d%d", &x, &y, &c, &d);
--x;
--y;
--c;
g[x].emplace_back(y, c, d);
g[y].emplace_back(x, c, d);
}
memset(pa, -1, sizeof pa);
pa[0] = 0;
ct = 0;
dfs1(0);
for (int i = 0; i < n; ++i) {
kp[0][i] = pa[i];
}
for (int j = 1; j < LG; ++j) {
for (int i = 0; i < n; ++i) {
kp[j][i] = kp[j - 1][kp[j - 1][i]];
}
}
for (int i = 0; i <= qq; ++i) {
q[i].clear();
}
for (int i = 1; i <= qq; ++i) {
int x, y;
scanf("%d%d%d%d", qc + i, qd + i, &x, &y);
--qc[i];
--x;
--y;
q[x].push_back(i);
q[y].push_back(i);
q[lca(x, y)].push_back(-i);
}
memset(cnt, 0, sizeof cnt);
memset(sum, 0, sizeof sum);
memset(ans, 0, sizeof ans);
dfs2(0, 0);
for (int i = 1; i <= qq; ++i) {
printf("%d\n", ans[i]);
}
}
| #include <cstdio>
#include <cstdlib>
#include <cstring>
#include <tuple>
#include <vector>
using namespace std;
const int N = 100'009;
int ct;
vector<tuple<int, int, int>> g[N];
int pa[N];
int tin[N];
int tout[N];
void dfs1(int x) {
tin[x] = ct++;
for (auto &e : g[x]) {
int y = get<0>(e);
if (y != pa[x]) {
pa[y] = x;
dfs1(y);
}
}
tout[x] = ct++;
}
bool anc(int x, int y) { return tin[x] <= tin[y] && tout[x] >= tout[y]; }
const int LG = 20;
int kp[LG][N];
int lca(int x, int y) {
if (anc(x, y)) {
return x;
}
for (int i = LG - 1; i >= 0; --i) {
if (!anc(kp[i][x], y)) {
x = kp[i][x];
}
}
return pa[x];
}
int qc[N];
int qd[N];
vector<int> q[N];
int cnt[N];
int sum[N];
int ans[N];
void dfs2(int x, int dist) {
for (int i : q[x]) {
int j = abs(i);
int cur = dist - sum[qc[j]] + cnt[qc[j]] * qd[j];
if (i < 0) {
cur = -2 * cur;
}
ans[j] += cur;
}
for (auto &e : g[x]) {
int y = get<0>(e);
if (y == pa[x]) {
continue;
}
int c = get<1>(e);
int d = get<2>(e);
++cnt[c];
sum[c] += d;
dfs2(y, dist + d);
--cnt[c];
sum[c] -= d;
}
}
int main() {
int n, qq;
scanf("%d%d", &n, &qq);
for (int i = 0; i < n; ++i) {
g[i].clear();
}
for (int i = 0; i < n - 1; ++i) {
int x, y, c, d;
scanf("%d%d%d%d", &x, &y, &c, &d);
--x;
--y;
--c;
g[x].emplace_back(y, c, d);
g[y].emplace_back(x, c, d);
}
memset(pa, -1, sizeof pa);
pa[0] = 0;
ct = 0;
dfs1(0);
for (int i = 0; i < n; ++i) {
kp[0][i] = pa[i];
}
for (int j = 1; j < LG; ++j) {
for (int i = 0; i < n; ++i) {
kp[j][i] = kp[j - 1][kp[j - 1][i]];
}
}
for (int i = 0; i <= qq; ++i) {
q[i].clear();
}
for (int i = 1; i <= qq; ++i) {
int x, y;
scanf("%d%d%d%d", qc + i, qd + i, &x, &y);
--qc[i];
--x;
--y;
q[x].push_back(i);
q[y].push_back(i);
q[lca(x, y)].push_back(-i);
}
memset(cnt, 0, sizeof cnt);
memset(sum, 0, sizeof sum);
memset(ans, 0, sizeof ans);
dfs2(0, 0);
for (int i = 1; i <= qq; ++i) {
printf("%d\n", ans[i]);
}
}
| [
"assignment.change"
] | 798,108 | 798,109 | u127130661 | cpp |
p02986 | #include <bits/stdc++.h>
#define mset(a, b) memset(a, b, sizeof a)
#define rep(i, a, b) for (int i(a), i##_END_(b); i <= i##_END_; i++)
#define drep(i, a, b) for (int i(a), i##_END_(b); i >= i##_END_; i--)
using namespace std;
template <class T> inline bool tomax(T &a, T b) { return a < b ? a = b, 1 : 0; }
template <class T> inline bool tomin(T &a, T b) { return b < a ? a = b, 1 : 0; }
typedef long long ll;
typedef double db;
const int N = 1e5 + 5;
template <int N, int M, class T> struct Link {
#define erep(k, G, o) for (int k(G.HEAD[o]); k; k = G.NXT[k])
int HEAD[N], NXT[M], tot;
T W[M];
void add(int x, T w) {
NXT[++tot] = HEAD[x];
W[HEAD[x] = tot] = w;
}
T &operator[](int x) { return W[x]; }
};
struct Edge {
int to, w;
};
Link<N, N * 2, Edge> G;
struct Data {
int u, v, d;
};
vector<Data> col[N];
struct Query {
int u, v, y, id;
};
vector<Query> qry[N];
struct Segment {
#define mid (L + R >> 1)
#define ls (o << 1)
#define rs (o << 1 | 1)
#define lson ls, L, mid
#define rson rs, mid + 1, R
int seg[N << 2];
void build(int a[], int o, int L, int R) {
if (L == R) {
seg[o] = a[L];
return;
}
build(a, lson);
build(a, rson);
}
int qry(int x, int o, int L, int R) {
if (L == R)
return seg[o];
if (x <= mid)
return qry(x, lson) + seg[o];
else
return qry(x, rson) + seg[o];
}
void upd(int l, int r, int v, int o, int L, int R) {
if (l == L && r == R) {
seg[o] += v;
return;
}
if (r <= mid)
upd(l, r, v, lson);
else if (l > mid)
upd(l, r, v, rson);
else
upd(l, mid, v, lson), upd(mid + 1, r, v, rson);
}
} sum, tag;
int sz[N], hs[N], fa[N], dfn[N], dep[N], dis[N], cur, en[N], tp[N];
void dfs1(int o, int f) {
sz[o] = 1;
fa[o] = f;
dep[o] = dep[f] + 1;
erep(k, G, o) {
Edge e = G[k];
if (e.to == f)
continue;
dis[e.to] = dis[o] + e.w;
dfs1(e.to, o);
sz[o] += sz[e.to];
if (sz[hs[o]] < sz[e.to])
hs[o] = e.to;
}
}
void dfs2(int o, int f, int t) {
dfn[o] = ++cur;
tp[o] = t;
if (hs[o])
dfs2(hs[o], o, t);
erep(k, G, o) {
int v = G[k].to;
if (v == f || v == hs[o])
continue;
dfs2(v, o, v);
}
en[o] = cur;
}
int lca(int u, int v) {
while (tp[u] != tp[v]) {
if (dep[fa[tp[u]]] < dep[fa[tp[v]]])
swap(u, v);
u = fa[tp[u]];
}
return dep[u] < dep[v] ? u : v;
}
int a[N];
int ans[N];
int main() {
int n, q;
scanf("%d%d", &n, &q);
rep(i, 2, n) {
int u, v, d, c;
scanf("%d%d%d%d", &u, &v, &c, &d);
G.add(u, (Edge){v, d});
G.add(v, (Edge){u, d});
col[c].push_back((Data){u, v, d});
}
rep(i, 1, q) {
int x, y, u, v;
scanf("%d%d%d%d", &x, &y, &u, &v);
qry[x].push_back((Query){u, v, y, i});
}
dfs1(1, 0);
dfs2(1, 0, 1);
rep(i, 1, n) a[dfn[i]] = dis[i];
sum.build(a, 1, 1, n);
rep(i, 1, n - 1) {
for (Data d : col[i]) {
int o = (fa[d.u] == d.v ? d.u : d.v);
sum.upd(dfn[o], en[o], -d.d, 1, 1, n);
tag.upd(dfn[o], en[o], 1, 1, 1, n);
}
for (Query d : qry[i]) {
int p = lca(d.u, d.v);
int s = sum.qry(dfn[d.u], 1, 1, n) + sum.qry(dfn[d.v], 1, 1, n) -
sum.qry(dfn[p], 1, 1, n);
int t = tag.qry(dfn[d.u], 1, 1, n) + tag.qry(dfn[d.v], 1, 1, n) -
tag.qry(dfn[p], 1, 1, n);
ans[d.id] = s + t * d.y;
}
for (Data d : col[i]) {
int o = (fa[d.u] == d.v ? d.u : d.v);
sum.upd(dfn[o], en[o], d.d, 1, 1, n);
tag.upd(dfn[o], en[o], -1, 1, 1, n);
}
}
rep(i, 1, q) printf("%d\n", ans[i]);
return 0;
}
| #include <bits/stdc++.h>
#define mset(a, b) memset(a, b, sizeof a)
#define rep(i, a, b) for (int i(a), i##_END_(b); i <= i##_END_; i++)
#define drep(i, a, b) for (int i(a), i##_END_(b); i >= i##_END_; i--)
using namespace std;
template <class T> inline bool tomax(T &a, T b) { return a < b ? a = b, 1 : 0; }
template <class T> inline bool tomin(T &a, T b) { return b < a ? a = b, 1 : 0; }
typedef long long ll;
typedef double db;
const int N = 1e5 + 5;
template <int N, int M, class T> struct Link {
#define erep(k, G, o) for (int k(G.HEAD[o]); k; k = G.NXT[k])
int HEAD[N], NXT[M], tot;
T W[M];
void add(int x, T w) {
NXT[++tot] = HEAD[x];
W[HEAD[x] = tot] = w;
}
T &operator[](int x) { return W[x]; }
};
struct Edge {
int to, w;
};
Link<N, N * 2, Edge> G;
struct Data {
int u, v, d;
};
vector<Data> col[N];
struct Query {
int u, v, y, id;
};
vector<Query> qry[N];
struct Segment {
#define mid (L + R >> 1)
#define ls (o << 1)
#define rs (o << 1 | 1)
#define lson ls, L, mid
#define rson rs, mid + 1, R
int seg[N << 2];
void build(int a[], int o, int L, int R) {
if (L == R) {
seg[o] = a[L];
return;
}
build(a, lson);
build(a, rson);
}
int qry(int x, int o, int L, int R) {
if (L == R)
return seg[o];
if (x <= mid)
return qry(x, lson) + seg[o];
else
return qry(x, rson) + seg[o];
}
void upd(int l, int r, int v, int o, int L, int R) {
if (l == L && r == R) {
seg[o] += v;
return;
}
if (r <= mid)
upd(l, r, v, lson);
else if (l > mid)
upd(l, r, v, rson);
else
upd(l, mid, v, lson), upd(mid + 1, r, v, rson);
}
} sum, tag;
int sz[N], hs[N], fa[N], dfn[N], dep[N], dis[N], cur, en[N], tp[N];
void dfs1(int o, int f) {
sz[o] = 1;
fa[o] = f;
dep[o] = dep[f] + 1;
erep(k, G, o) {
Edge e = G[k];
if (e.to == f)
continue;
dis[e.to] = dis[o] + e.w;
dfs1(e.to, o);
sz[o] += sz[e.to];
if (sz[hs[o]] < sz[e.to])
hs[o] = e.to;
}
}
void dfs2(int o, int f, int t) {
dfn[o] = ++cur;
tp[o] = t;
if (hs[o])
dfs2(hs[o], o, t);
erep(k, G, o) {
int v = G[k].to;
if (v == f || v == hs[o])
continue;
dfs2(v, o, v);
}
en[o] = cur;
}
int lca(int u, int v) {
while (tp[u] != tp[v]) {
if (dep[fa[tp[u]]] < dep[fa[tp[v]]])
swap(u, v);
u = fa[tp[u]];
}
return dep[u] < dep[v] ? u : v;
}
int a[N];
int ans[N];
int main() {
int n, q;
scanf("%d%d", &n, &q);
rep(i, 2, n) {
int u, v, d, c;
scanf("%d%d%d%d", &u, &v, &c, &d);
G.add(u, (Edge){v, d});
G.add(v, (Edge){u, d});
col[c].push_back((Data){u, v, d});
}
rep(i, 1, q) {
int x, y, u, v;
scanf("%d%d%d%d", &x, &y, &u, &v);
qry[x].push_back((Query){u, v, y, i});
}
dfs1(1, 0);
dfs2(1, 0, 1);
rep(i, 1, n) a[dfn[i]] = dis[i];
sum.build(a, 1, 1, n);
rep(i, 1, n - 1) {
for (Data d : col[i]) {
int o = (fa[d.u] == d.v ? d.u : d.v);
sum.upd(dfn[o], en[o], -d.d, 1, 1, n);
tag.upd(dfn[o], en[o], 1, 1, 1, n);
}
for (Query d : qry[i]) {
int p = lca(d.u, d.v);
int s = sum.qry(dfn[d.u], 1, 1, n) + sum.qry(dfn[d.v], 1, 1, n) -
2 * sum.qry(dfn[p], 1, 1, n);
int t = tag.qry(dfn[d.u], 1, 1, n) + tag.qry(dfn[d.v], 1, 1, n) -
2 * tag.qry(dfn[p], 1, 1, n);
ans[d.id] = s + t * d.y;
}
for (Data d : col[i]) {
int o = (fa[d.u] == d.v ? d.u : d.v);
sum.upd(dfn[o], en[o], d.d, 1, 1, n);
tag.upd(dfn[o], en[o], -1, 1, 1, n);
}
}
rep(i, 1, q) printf("%d\n", ans[i]);
return 0;
}
| [
"assignment.change"
] | 798,125 | 798,126 | u226153407 | cpp |
p02986 | #include <bits/stdc++.h>
// #include <boost/multiprecision/cpp_int.hpp>
#define int long long
#define inf 1000000007
#define pa pair<int, int>
#define ll long long
#define pal pair<double, double>
#define ppap pair<pa, int>
#define PI 3.14159265358979323846
#define paa pair<int, char>
#define mp make_pair
#define pb push_back
#define EPS (1e-10)
int dx[8] = {0, 1, 0, -1, 1, 1, -1, -1};
int dy[8] = {1, 0, -1, 0, -1, 1, 1, -1};
using namespace std;
class pa3 {
public:
int x;
int y, z;
pa3(int x = 0, int y = 0, int z = 0) : x(x), y(y), z(z) {}
bool operator<(const pa3 &p) const {
if (x != p.x)
return x < p.x;
if (y != p.y)
return y < p.y;
return z < p.z;
// return x != p.x ? x<p.x: y<p.y;
}
bool operator>(const pa3 &p) const {
if (x != p.x)
return x > p.x;
if (y != p.y)
return y > p.y;
return z > p.z;
// return x != p.x ? x<p.x: y<p.y;
}
bool operator==(const pa3 &p) const {
return x == p.x && y == p.y && z == p.z;
}
bool operator!=(const pa3 &p) const {
return !(x == p.x && y == p.y && z == p.z);
}
};
class pa4 {
public:
int x;
int y, z, w;
pa4(int x = 0, int y = 0, int z = 0, int w = 0) : x(x), y(y), z(z), w(w) {}
bool operator<(const pa4 &p) const {
if (x != p.x)
return x < p.x;
if (y != p.y)
return y < p.y;
if (z != p.z)
return z < p.z;
return w < p.w;
// return x != p.x ? x<p.x: y<p.y;
}
bool operator>(const pa4 &p) const {
if (x != p.x)
return x > p.x;
if (y != p.y)
return y > p.y;
if (z != p.z)
return z > p.z;
return w > p.w;
// return x != p.x ? x<p.x: y<p.y;
}
bool operator==(const pa4 &p) const {
return x == p.x && y == p.y && z == p.z && w == p.w;
}
};
class pa2 {
public:
int x, y;
pa2(int x = 0, int y = 0) : x(x), y(y) {}
pa2 operator+(pa2 p) { return pa2(x + p.x, y + p.y); }
pa2 operator-(pa2 p) { return pa2(x - p.x, y - p.y); }
bool operator<(const pa2 &p) const { return y != p.y ? y < p.y : x < p.x; }
bool operator>(const pa2 &p) const { return x != p.x ? x < p.x : y < p.y; }
bool operator==(const pa2 &p) const {
return abs(x - p.x) == 0 && abs(y - p.y) == 0;
}
bool operator!=(const pa2 &p) const {
return !(abs(x - p.x) == 0 && abs(y - p.y) == 0);
}
};
string itos(int i) {
ostringstream s;
s << i;
return s.str();
}
int gcd(int v, int b) {
if (v > b)
return gcd(b, v);
if (v == b)
return b;
if (b % v == 0)
return v;
return gcd(v, b % v);
}
int mod;
int extgcd(int a, int b, int &x, int &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
int d = extgcd(b, a % b, y, x);
y -= a / b * x;
return d;
}
pa operator+(const pa &l, const pa &r) {
return {l.first + r.first, l.second + r.second};
}
pa operator-(const pa &l, const pa &r) {
return {l.first - r.first, l.second - r.second};
}
int pr[200010];
int inv[200010];
int beki(int wa, int rr, int warukazu) {
if (rr == 0)
return 1 % warukazu;
if (rr == 1)
return wa % warukazu;
wa %= warukazu;
if (rr % 2 == 1)
return ((ll)beki(wa, rr - 1, warukazu) * (ll)wa) % warukazu;
ll zx = beki(wa, rr / 2, warukazu);
return (zx * zx) % warukazu;
}
int comb(int nn, int rr) {
if (rr < 0 || rr > nn || nn < 0)
return 0;
int r = pr[nn] * inv[rr];
r %= mod;
r *= inv[nn - rr];
r %= mod;
return r;
}
void gya(int ert) {
pr[0] = 1;
for (int i = 1; i <= ert; i++) {
pr[i] = (pr[i - 1] * i) % mod;
}
inv[ert] = beki(pr[ert], mod - 2, mod);
for (int i = ert - 1; i >= 0; i--) {
inv[i] = inv[i + 1] * (i + 1) % mod;
}
}
// cin.tie(0);
// ios::sync_with_stdio(false);
// priority_queue<pa3,vector<pa3>,greater<pa3>> pq;
// sort(ve.begin(),ve.end(),greater<int>());
// mt19937(clock_per_sec);
// mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count()) ;
//----------------kokomade tenpure------------
vector<pa3> G[100020], G2[100020];
int s[100020], t[100020];
vector<int> oi;
vector<int> dis;
vector<int> col;
vector<int> zen;
int depth[100020];
int dp[22][100020];
void dfs(int r, int p, int len = 0, int iro = 0, int d = 0) {
depth[r] = d;
s[r] = oi.size();
t[r] = oi.size();
oi.pb(r);
dis.pb(len);
col.pb(iro);
dp[0][r] = p;
for (auto v : G[r])
if (v.x != p) {
dfs(v.x, r, v.z, v.y, d + 1);
G2[r].pb(v);
t[r] = oi.size();
oi.pb(r);
dis.pb(-v.z);
col.pb(v.y);
}
}
int lca(int x, int y) {
if (depth[x] < depth[y])
swap(x, y);
int sa = depth[x] - depth[y];
for (int i = 0; i <= 21; i++)
if (sa & (1 << i))
x = dp[i][x];
if (x == y)
return x;
for (int i = 21; i >= 0; i--) {
if (dp[i][x] != dp[i][y]) {
x = dp[i][x];
y = dp[i][y];
}
}
return dp[0][x];
}
vector<pa3> rui[100020];
void ch() {
int e = oi.size();
zen.pb(0);
for (int i = 1; i < e; i++) {
zen.pb(zen.back() + dis[i]);
}
for (int i = 0; i < e; i++) {
if (rui[col[i]].size() == 0) {
rui[col[i]].pb({i, dis[i], 0});
if (dis[i] > 0)
rui[col[i]].back().z = 1;
else
rui[col[i]].back().z = -1;
} else {
int ima = rui[col[i]].back().z;
rui[col[i]].pb({i, dis[i] + rui[col[i]].back().y, 0});
if (dis[i] > 0)
rui[col[i]].back().z = ima + 1;
else
rui[col[i]].back().z = ima - 1;
}
}
}
int solve(int x, int u, int v) {
int moto = zen[s[x]];
pa3 p = (pa3){s[x] + 1, -1, -1};
int it = lower_bound(rui[u].begin(), rui[u].end(), p) - rui[u].begin();
int kosu = it;
int naga;
if (kosu == 0)
naga = 0;
else
naga = rui[u][it - 1].y;
if (kosu)
kosu = rui[u][it - 1].z;
return moto - naga + kosu * v;
}
signed main() {
// cin.tie(0);
// ios::sync_with_stdio(false);
// dis.pb(0);
int n, Q;
cin >> n >> Q;
for (int i = 0; i < n - 1; i++) {
int y, yy, x, xx;
cin >> y >> yy >> x >> xx;
G[y].pb({yy, x, xx});
G[yy].pb({y, x, xx});
}
dfs(1, 1);
// for(int i=1;i<=n;i++)cout<<i<<" "<<s[i]<<endl;
for (int i = 1; i < 22; i++)
for (int j = 1; j <= n; j++) {
dp[i][j] = dp[i - 1][dp[i - 1][j]];
}
ch();
/*
for(auto v:oi)cout<<v<<" ";
cout<<endl;
for(auto v:dis)cout<<v<<" ";
cout<<endl;
for(auto v:col)cout<<v<<" ";
cout<<endl;
for(auto v:zen)cout<<v<<" ";
cout<<endl;
*/
for (int i = 0; i < Q; i++) {
int x, y, u, v;
cin >> u >> v >> x >> y;
int med = lca(x, y);
int ans = solve(x, u, v) + solve(y, u, v) - solve(med, u, v);
cout << ans << endl;
}
return 0;
}
| #include <bits/stdc++.h>
// #include <boost/multiprecision/cpp_int.hpp>
#define int long long
#define inf 1000000007
#define pa pair<int, int>
#define ll long long
#define pal pair<double, double>
#define ppap pair<pa, int>
#define PI 3.14159265358979323846
#define paa pair<int, char>
#define mp make_pair
#define pb push_back
#define EPS (1e-10)
int dx[8] = {0, 1, 0, -1, 1, 1, -1, -1};
int dy[8] = {1, 0, -1, 0, -1, 1, 1, -1};
using namespace std;
class pa3 {
public:
int x;
int y, z;
pa3(int x = 0, int y = 0, int z = 0) : x(x), y(y), z(z) {}
bool operator<(const pa3 &p) const {
if (x != p.x)
return x < p.x;
if (y != p.y)
return y < p.y;
return z < p.z;
// return x != p.x ? x<p.x: y<p.y;
}
bool operator>(const pa3 &p) const {
if (x != p.x)
return x > p.x;
if (y != p.y)
return y > p.y;
return z > p.z;
// return x != p.x ? x<p.x: y<p.y;
}
bool operator==(const pa3 &p) const {
return x == p.x && y == p.y && z == p.z;
}
bool operator!=(const pa3 &p) const {
return !(x == p.x && y == p.y && z == p.z);
}
};
class pa4 {
public:
int x;
int y, z, w;
pa4(int x = 0, int y = 0, int z = 0, int w = 0) : x(x), y(y), z(z), w(w) {}
bool operator<(const pa4 &p) const {
if (x != p.x)
return x < p.x;
if (y != p.y)
return y < p.y;
if (z != p.z)
return z < p.z;
return w < p.w;
// return x != p.x ? x<p.x: y<p.y;
}
bool operator>(const pa4 &p) const {
if (x != p.x)
return x > p.x;
if (y != p.y)
return y > p.y;
if (z != p.z)
return z > p.z;
return w > p.w;
// return x != p.x ? x<p.x: y<p.y;
}
bool operator==(const pa4 &p) const {
return x == p.x && y == p.y && z == p.z && w == p.w;
}
};
class pa2 {
public:
int x, y;
pa2(int x = 0, int y = 0) : x(x), y(y) {}
pa2 operator+(pa2 p) { return pa2(x + p.x, y + p.y); }
pa2 operator-(pa2 p) { return pa2(x - p.x, y - p.y); }
bool operator<(const pa2 &p) const { return y != p.y ? y < p.y : x < p.x; }
bool operator>(const pa2 &p) const { return x != p.x ? x < p.x : y < p.y; }
bool operator==(const pa2 &p) const {
return abs(x - p.x) == 0 && abs(y - p.y) == 0;
}
bool operator!=(const pa2 &p) const {
return !(abs(x - p.x) == 0 && abs(y - p.y) == 0);
}
};
string itos(int i) {
ostringstream s;
s << i;
return s.str();
}
int gcd(int v, int b) {
if (v > b)
return gcd(b, v);
if (v == b)
return b;
if (b % v == 0)
return v;
return gcd(v, b % v);
}
int mod;
int extgcd(int a, int b, int &x, int &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
int d = extgcd(b, a % b, y, x);
y -= a / b * x;
return d;
}
pa operator+(const pa &l, const pa &r) {
return {l.first + r.first, l.second + r.second};
}
pa operator-(const pa &l, const pa &r) {
return {l.first - r.first, l.second - r.second};
}
int pr[200010];
int inv[200010];
int beki(int wa, int rr, int warukazu) {
if (rr == 0)
return 1 % warukazu;
if (rr == 1)
return wa % warukazu;
wa %= warukazu;
if (rr % 2 == 1)
return ((ll)beki(wa, rr - 1, warukazu) * (ll)wa) % warukazu;
ll zx = beki(wa, rr / 2, warukazu);
return (zx * zx) % warukazu;
}
int comb(int nn, int rr) {
if (rr < 0 || rr > nn || nn < 0)
return 0;
int r = pr[nn] * inv[rr];
r %= mod;
r *= inv[nn - rr];
r %= mod;
return r;
}
void gya(int ert) {
pr[0] = 1;
for (int i = 1; i <= ert; i++) {
pr[i] = (pr[i - 1] * i) % mod;
}
inv[ert] = beki(pr[ert], mod - 2, mod);
for (int i = ert - 1; i >= 0; i--) {
inv[i] = inv[i + 1] * (i + 1) % mod;
}
}
// cin.tie(0);
// ios::sync_with_stdio(false);
// priority_queue<pa3,vector<pa3>,greater<pa3>> pq;
// sort(ve.begin(),ve.end(),greater<int>());
// mt19937(clock_per_sec);
// mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count()) ;
//----------------kokomade tenpure------------
vector<pa3> G[100020], G2[100020];
int s[100020], t[100020];
vector<int> oi;
vector<int> dis;
vector<int> col;
vector<int> zen;
int depth[100020];
int dp[22][100020];
void dfs(int r, int p, int len = 0, int iro = 0, int d = 0) {
depth[r] = d;
s[r] = oi.size();
t[r] = oi.size();
oi.pb(r);
dis.pb(len);
col.pb(iro);
dp[0][r] = p;
for (auto v : G[r])
if (v.x != p) {
dfs(v.x, r, v.z, v.y, d + 1);
G2[r].pb(v);
t[r] = oi.size();
oi.pb(r);
dis.pb(-v.z);
col.pb(v.y);
}
}
int lca(int x, int y) {
if (depth[x] < depth[y])
swap(x, y);
int sa = depth[x] - depth[y];
for (int i = 0; i <= 21; i++)
if (sa & (1 << i))
x = dp[i][x];
if (x == y)
return x;
for (int i = 21; i >= 0; i--) {
if (dp[i][x] != dp[i][y]) {
x = dp[i][x];
y = dp[i][y];
}
}
return dp[0][x];
}
vector<pa3> rui[100020];
void ch() {
int e = oi.size();
zen.pb(0);
for (int i = 1; i < e; i++) {
zen.pb(zen.back() + dis[i]);
}
for (int i = 0; i < e; i++) {
if (rui[col[i]].size() == 0) {
rui[col[i]].pb({i, dis[i], 0});
if (dis[i] > 0)
rui[col[i]].back().z = 1;
else
rui[col[i]].back().z = -1;
} else {
int ima = rui[col[i]].back().z;
rui[col[i]].pb({i, dis[i] + rui[col[i]].back().y, 0});
if (dis[i] > 0)
rui[col[i]].back().z = ima + 1;
else
rui[col[i]].back().z = ima - 1;
}
}
}
int solve(int x, int u, int v) {
int moto = zen[t[x]];
pa3 p = (pa3){t[x] + 1, -1, -1};
int it = lower_bound(rui[u].begin(), rui[u].end(), p) - rui[u].begin();
int kosu = it;
int naga;
if (kosu == 0)
naga = 0;
else
naga = rui[u][it - 1].y;
if (kosu)
kosu = rui[u][it - 1].z;
return moto - naga + kosu * v;
}
signed main() {
// cin.tie(0);
// ios::sync_with_stdio(false);
// dis.pb(0);
int n, Q;
cin >> n >> Q;
for (int i = 0; i < n - 1; i++) {
int y, yy, x, xx;
cin >> y >> yy >> x >> xx;
G[y].pb({yy, x, xx});
G[yy].pb({y, x, xx});
}
dfs(1, 1);
// for(int i=1;i<=n;i++)cout<<i<<" "<<s[i]<<endl;
for (int i = 1; i < 22; i++)
for (int j = 1; j <= n; j++) {
dp[i][j] = dp[i - 1][dp[i - 1][j]];
}
ch();
/*
for(auto v:oi)cout<<v<<" ";
cout<<endl;
for(auto v:dis)cout<<v<<" ";
cout<<endl;
for(auto v:col)cout<<v<<" ";
cout<<endl;
for(auto v:zen)cout<<v<<" ";
cout<<endl;
*/
for (int i = 0; i < Q; i++) {
int x, y, u, v;
cin >> u >> v >> x >> y;
int med = lca(x, y);
// cout<<x<<" "<<y<<" "<<med<<endl;
// cout<<solve(x,u,v)<<endl;
// cout<<solve(y,u,v)<<endl;
int ans = solve(x, u, v) + solve(y, u, v) - 2 * solve(med, u, v);
cout << ans << endl;
}
return 0;
}
| [
"identifier.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change"
] | 798,131 | 798,132 | u834777932 | cpp |
p02986 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <deque>
#include <fstream>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#define popcount __builtin_popcount
using namespace std;
typedef long long int ll;
typedef pair<int, int> P;
int n;
vector<P> g[100000];
int d[100000];
int p[17][100000];
bool used[100000];
void dfs0(int x) {
used[x] = 1;
for (auto pr : g[x]) {
int y = pr.first;
if (!used[y]) {
d[y] = d[x] + 1;
p[0][y] = x;
dfs0(y);
}
}
}
void init_lca() {
dfs0(0);
for (int i = 1; i < 17; i++) {
for (int x = 0; x < n; x++) {
p[i][x] = p[i - 1][p[i - 1][x]];
}
}
}
int lca(int a, int b) {
if (d[a] > d[b])
swap(a, b);
int a1 = a, b1 = b;
int dd = d[b] - d[a], i = 0;
while (dd > 0) {
if (dd % 2 == 1) {
b1 = p[i][b1];
}
dd /= 2;
i++;
}
if (a1 == b1)
return a1;
for (int i = 16; i >= 0; i--) {
if (p[i][a1] != p[i][b1]) {
a1 = p[i][a1], b1 = p[i][b1];
}
}
return p[0][a1];
}
vector<int> v[100010];
vector<int> vm[100010];
int c[100010];
ll dist[100010];
int cx[100010];
ll y[100010];
ll cnt[100010], dc[100010], ds;
ll ans[100010];
void dfs(int x) {
used[x] = 1;
for (auto i : v[x]) {
ans[i] += (ds - dc[cx[i]] + cnt[cx[i]] * y[i]);
}
for (auto i : vm[x]) {
ans[i] -= 2 * (ds - dc[cx[i]] + cnt[cx[i]] * y[i]);
}
for (auto pr : g[x]) {
int y = pr.first;
if (used[y])
continue;
int i = pr.second;
cnt[c[i]]++;
dc[c[i]] += dist[i];
ds += dist[i];
dfs(y);
cnt[c[i]]--;
dc[c[i]] -= dist[i];
ds -= dist[i];
}
}
int main() {
int q;
cin >> n >> q;
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b >> c[i] >> dist[i];
a--;
b--;
g[a].push_back({b, i});
g[b].push_back({a, i});
}
init_lca();
for (int i = 0; i < q; i++) {
int ui, vi;
cin >> cx[i] >> y[i] >> ui >> vi;
ui--;
vi--;
v[ui].push_back(i);
v[vi].push_back(i);
v[lca(ui, vi)].push_back(i);
}
fill(used, used + n, 0);
dfs(0);
for (int i = 0; i < q; i++)
cout << ans[i] << endl;
return 0;
} | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <deque>
#include <fstream>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#define popcount __builtin_popcount
using namespace std;
typedef long long int ll;
typedef pair<int, int> P;
int n;
vector<P> g[100000];
int d[100000];
int p[17][100000];
bool used[100000];
void dfs0(int x) {
used[x] = 1;
for (auto pr : g[x]) {
int y = pr.first;
if (!used[y]) {
d[y] = d[x] + 1;
p[0][y] = x;
dfs0(y);
}
}
}
void init_lca() {
dfs0(0);
for (int i = 1; i < 17; i++) {
for (int x = 0; x < n; x++) {
p[i][x] = p[i - 1][p[i - 1][x]];
}
}
}
int lca(int a, int b) {
if (d[a] > d[b])
swap(a, b);
int a1 = a, b1 = b;
int dd = d[b] - d[a], i = 0;
while (dd > 0) {
if (dd % 2 == 1) {
b1 = p[i][b1];
}
dd /= 2;
i++;
}
if (a1 == b1)
return a1;
for (int i = 16; i >= 0; i--) {
if (p[i][a1] != p[i][b1]) {
a1 = p[i][a1], b1 = p[i][b1];
}
}
return p[0][a1];
}
vector<int> v[100010];
vector<int> vm[100010];
int c[100010];
ll dist[100010];
int cx[100010];
ll y[100010];
ll cnt[100010], dc[100010], ds;
ll ans[100010];
void dfs(int x) {
used[x] = 1;
for (auto i : v[x]) {
ans[i] += (ds - dc[cx[i]] + cnt[cx[i]] * y[i]);
}
for (auto i : vm[x]) {
ans[i] -= 2 * (ds - dc[cx[i]] + cnt[cx[i]] * y[i]);
}
for (auto pr : g[x]) {
int y = pr.first;
if (used[y])
continue;
int i = pr.second;
cnt[c[i]]++;
dc[c[i]] += dist[i];
ds += dist[i];
dfs(y);
cnt[c[i]]--;
dc[c[i]] -= dist[i];
ds -= dist[i];
}
}
int main() {
int q;
cin >> n >> q;
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b >> c[i] >> dist[i];
a--;
b--;
g[a].push_back({b, i});
g[b].push_back({a, i});
}
init_lca();
for (int i = 0; i < q; i++) {
int ui, vi;
cin >> cx[i] >> y[i] >> ui >> vi;
ui--;
vi--;
v[ui].push_back(i);
v[vi].push_back(i);
vm[lca(ui, vi)].push_back(i);
}
fill(used, used + n, 0);
dfs(0);
for (int i = 0; i < q; i++)
cout << ans[i] << endl;
return 0;
} | [
"identifier.change"
] | 798,133 | 798,134 | u930898631 | cpp |
p02987 | #include <stdio.h>
char a[5];
int main() {
while (scanf("%s", &a) != EOF) {
int t = 0, y = 0;
for (int i = 0; i < 4; i++) {
for (int j = i + 1; j < 4; j++) {
if (a[i] == a[j])
t++;
if (a[i] != a[j])
y++;
}
}
if (y != 0 && t == 2)
printf("YES\n");
else
printf("NO\n");
}
return 0;
} | #include <stdio.h>
char a[5];
int main() {
while (scanf("%s", &a) != EOF) {
int t = 0, y = 0;
for (int i = 0; i < 4; i++) {
for (int j = i + 1; j < 4; j++) {
if (a[i] == a[j])
t++;
if (a[i] != a[j])
y++;
}
}
if (y != 0 && t == 2)
printf("Yes\n");
else
printf("No\n");
}
return 0;
} | [
"literal.string.change",
"literal.string.case.change",
"call.arguments.change",
"io.output.change"
] | 798,155 | 798,156 | u863370423 | cpp |
p02987 | #include <bits/stdc++.h>
#define LL long long
#define PB push_back
using namespace std;
int main() {
string s;
cin >> s;
for (int i = 0; i < 4; i++) {
if (count(s.begin(), s.end(), s[i]) != 2) {
cout << "N0";
return 0;
}
}
cout << "Yes";
} | #include <bits/stdc++.h>
#define LL long long
#define PB push_back
using namespace std;
int main() {
string s;
cin >> s;
for (int i = 0; i < 4; i++) {
if (count(s.begin(), s.end(), s[i]) != 2) {
cout << "No";
return 0;
}
}
cout << "Yes";
} | [
"literal.string.change",
"io.output.change"
] | 798,157 | 798,158 | u018679195 | cpp |
p02987 | #include <bits/stdc++.h> //abc177-C
using namespace std;
int main() {
string s;
cin >> s;
if ((s[0] == s[1] && s[2] == s[3] && s[0] != s[2]) ||
(s[0] == s[2] || s[1] == s[3] && s[0] != s[1]) ||
(s[0] == s[3] && s[1] == s[2] && s[0] != s[1])) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
}
| #include <bits/stdc++.h> //abc177-C
using namespace std;
int main() {
string s;
cin >> s;
if ((s[0] == s[1] && s[2] == s[3] && s[0] != s[2]) ||
(s[0] == s[2] && s[1] == s[3] && s[0] != s[1]) ||
(s[0] == s[3] && s[1] == s[2] && s[0] != s[1])) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
}
| [
"misc.opposites",
"control_flow.branch.if.condition.change"
] | 798,161 | 798,162 | u334623794 | cpp |
p02990 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
// https://youtu.be/L8grWxBlIZ4?t=9858
// https://youtu.be/ERZuLAxZffQ?t=4765
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 c[4005][4005]; // パスカルの三角形 (4000ちょいあれば十分 (5
// はどこから来るのだろう...)))
void init() {
c[0][0] = 1;
for (int i = 0; i <= 4000; i++) {
for (int j = 0; j <= i; j++) {
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;
return f2(n - k, k); // (解説で導入した) f' を f2() として実装する
}
int main() {
init();
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
mint blue = f(k, i); // k 個を i グループに分ける
mint red = 0;
{
red += f(n - k, i - 1);
red += f(n - k, i);
red += f(n - k, i);
red += f(n - k, i + 1);
}
mint ans = blue * red;
printf("%lld\n", ans.x);
}
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
// https://youtu.be/L8grWxBlIZ4?t=9858
// https://youtu.be/ERZuLAxZffQ?t=4765
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 c[4005][4005]; // パスカルの三角形 (4000ちょいあれば十分 (5
// はどこから来るのだろう...)))
void init() {
c[0][0] = 1;
for (int i = 0; i <= 4000; i++) {
for (int j = 0; j <= i; j++) {
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;
return f2(n - k, k); // (解説で導入した) f' を f2() として実装する
}
int main() {
init();
int n, k;
cin >> n >> k;
for (int i = 1; i <= k; i++) {
mint blue = f(k, i); // k 個を i グループに分ける
mint red = 0;
{
red += f(n - k, i - 1);
red += f(n - k, i);
red += f(n - k, i);
red += f(n - k, i + 1);
}
mint ans = blue * red;
printf("%lld\n", ans.x);
}
return 0;
} | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 798,177 | 798,178 | u786793781 | cpp |
p02990 | #include <cstdio>
template <int N, typename T, T M> struct factorial_mod {
T mod[N + 1];
T inv_mod[N + 1];
constexpr factorial_mod() : mod(), inv_mod() {
mod[0] = 1;
for (int i = 0; i < N; ++i) {
mod[i + 1] = (mod[i] * (i + 1)) % M;
}
inv_mod[N] = power(mod[N], M - 2);
for (int i = N - 1; i >= 0; --i) {
inv_mod[i] = (inv_mod[i + 1] * (i + 1)) % M;
}
}
constexpr T power(T a, T b) {
T r = 1;
while (b > 0) {
if ((b & 1) != 0)
r = (r * a) % M;
a = (a * a) % M;
b >>= 1;
}
return r;
}
constexpr T comb(T n, T r) {
if (r > n || n < 0)
return 0;
return (((mod[n] * inv_mod[r]) % M) * inv_mod[n - r]) % M;
}
};
factorial_mod<5000, long long, 1000000007> fmod;
int main() {
long long n, k;
scanf("%lld%lld", &n, &k);
for (long long i = 1; i <= k; ++i) {
printf("%lld\n", fmod.comb(n - k + 1, i) * fmod.comb(k - 1, k - i));
}
return 0;
} | #include <cstdio>
template <int N, typename T, T M> struct factorial_mod {
T mod[N + 1];
T inv_mod[N + 1];
constexpr factorial_mod() : mod(), inv_mod() {
mod[0] = 1;
for (int i = 0; i < N; ++i) {
mod[i + 1] = (mod[i] * (i + 1)) % M;
}
inv_mod[N] = power(mod[N], M - 2);
for (int i = N - 1; i >= 0; --i) {
inv_mod[i] = (inv_mod[i + 1] * (i + 1)) % M;
}
}
constexpr T power(T a, T b) {
T r = 1;
while (b > 0) {
if ((b & 1) != 0)
r = (r * a) % M;
a = (a * a) % M;
b >>= 1;
}
return r;
}
constexpr T comb(T n, T r) {
if (r > n || n < 0)
return 0;
return (((mod[n] * inv_mod[r]) % M) * inv_mod[n - r]) % M;
}
};
factorial_mod<5000, long long, 1000000007> fmod;
int main() {
long long n, k;
scanf("%lld%lld", &n, &k);
for (long long i = 1; i <= k; ++i) {
printf("%lld\n",
fmod.comb(n - k + 1, i) * fmod.comb(k - 1, k - i) % 1000000007);
}
return 0;
} | [
"expression.operation.binary.add"
] | 798,179 | 798,180 | u931819817 | cpp |
p02990 | #include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
vector<vector<ll>> com(ll n, ll r) {
const long long _MOD = 1000000007;
vector<vector<ll>> v(n + 1, vector<ll>(n + 1, 0));
ll tmp = v.size();
for (int i = 0; i < tmp; i++) {
v[i][0] = 1;
v[i][i] = 1;
}
for (int j = 1; j < tmp; j++) {
for (int k = 1; k < j; k++) {
v[j][k] = v[j - 1][k - 1] + v[j - 1][k];
if (v[j][k] > _MOD)
v[j][k] %= _MOD;
}
}
return v;
}
int main() {
ll N, K;
ll div_N = 1000000007;
cin >> N >> K;
vector<vector<ll>> v(2019, vector<ll>(2019, 0));
ll tmp = K;
if (N - K + 1 < K)
tmp = N - K + 1;
v = com(2019, 2019);
for (int i = 1; i <= tmp; i++) {
ll ans = v[N - K + 1][i] * v[K - 1][i - 1];
if (ans > div_N)
ans %= div_N;
cout << ans << endl;
}
return 0;
} | #include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
vector<vector<ll>> com(ll n, ll r) {
const long long _MOD = 1000000007;
vector<vector<ll>> v(n + 1, vector<ll>(n + 1, 0));
ll tmp = v.size();
for (int i = 0; i < tmp; i++) {
v[i][0] = 1;
v[i][i] = 1;
}
for (int j = 1; j < tmp; j++) {
for (int k = 1; k < j; k++) {
v[j][k] = v[j - 1][k - 1] + v[j - 1][k];
if (v[j][k] > _MOD)
v[j][k] %= _MOD;
}
}
return v;
}
int main() {
ll N, K;
ll div_N = 1000000007;
cin >> N >> K;
vector<vector<ll>> v(2019, vector<ll>(2019, 0));
ll tmp = K;
if (N - K + 1 < K)
tmp = N - K + 1;
v = com(2019, 2019);
for (int i = 1; i <= K; i++) {
ll ans = v[N - K + 1][i] * v[K - 1][i - 1];
if (ans > div_N)
ans %= div_N;
cout << ans << endl;
}
return 0;
} | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 798,181 | 798,182 | u432088501 | cpp |
p02990 | #include <algorithm>
#include <iostream>
#include <math.h>
#include <string>
#include <vector>
using namespace std;
using std::swap;
// priceをキーに降順でソート
// sort(fruits.begin(), fruits.end(),
// [](const fruit& x, const fruit& y) { return x.price > y.price;});
/*
int main() {
vector<char> s;
string S;
std::cin >> S;
for(int i=0; i<4; i++){
s.push_back(S[i]);
}
std::sort(s.begin(), s.end());
if(s[0]==s[1] && s[2]==s[3] && s[1]!=s[3]){
std::cout << "Yes" << std::endl;
return 0;
}
else{
std::cout << "No" << std::endl;
return 0;
}
}
*/
/*
int main(){
int N;
std::cin >> N;
int a[N];
int count =0;
for(int i=0; i<N; i++){
std::cin >> a[i];
}
for(int i=1; i<N-1; i++){
if((a[i]-a[i-1])*(a[i]-a[i+1])<0){
count++;
}
}
std::cout << count << std::endl;
return 0;
}
*/
/*
int main(){
int a,N;
std::cin >> N;
vector<int> q;
for(int i=0; i<N; i++){
std::cin >> a;
q.push_back(a);
}
std::sort(q.begin(), q.end());
std::cout << q[N/2]-q[N/2-1]<< std::endl;
return 0;
}
*/
int main() {
int N, K;
unsigned int q = pow(10, 9) + 7;
unsigned int red, blue;
std::cin >> N >> K;
unsigned int **C = new unsigned int *[N + 1];
for (int i = 0; i < N + 1; i++) {
C[i] = new unsigned int[N + 1];
}
for (int i = 0; i < N + 1; i++) {
for (int j = 0; j < N + 1; j++) {
C[i][j] = 0;
}
}
C[0][0] = 1;
for (int i = 1; i < N + 1; i++) {
C[i][0] = 1;
for (int j = 1; j < i + 1; j++) {
C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % q;
}
}
for (int i = 1; i <= K; i++) {
if (i > (N + 1) / 2) {
std::cout << 0 << std::endl;
} else {
red = C[N - K + 1][i];
blue = C[K - 1][i - 1];
std::cout << (red * blue) % q << std::endl;
}
}
for (int i = 0; i < N + 1; i++) {
delete[] C[i];
}
delete[] C;
return 0;
} | #include <algorithm>
#include <iostream>
#include <math.h>
#include <string>
#include <vector>
using namespace std;
using std::swap;
// priceをキーに降順でソート
// sort(fruits.begin(), fruits.end(),
// [](const fruit& x, const fruit& y) { return x.price > y.price;});
/*
int main() {
vector<char> s;
string S;
std::cin >> S;
for(int i=0; i<4; i++){
s.push_back(S[i]);
}
std::sort(s.begin(), s.end());
if(s[0]==s[1] && s[2]==s[3] && s[1]!=s[3]){
std::cout << "Yes" << std::endl;
return 0;
}
else{
std::cout << "No" << std::endl;
return 0;
}
}
*/
/*
int main(){
int N;
std::cin >> N;
int a[N];
int count =0;
for(int i=0; i<N; i++){
std::cin >> a[i];
}
for(int i=1; i<N-1; i++){
if((a[i]-a[i-1])*(a[i]-a[i+1])<0){
count++;
}
}
std::cout << count << std::endl;
return 0;
}
*/
/*
int main(){
int a,N;
std::cin >> N;
vector<int> q;
for(int i=0; i<N; i++){
std::cin >> a;
q.push_back(a);
}
std::sort(q.begin(), q.end());
std::cout << q[N/2]-q[N/2-1]<< std::endl;
return 0;
}
*/
int main() {
int N, K;
unsigned int q = pow(10, 9) + 7;
long long int red, blue;
std::cin >> N >> K;
unsigned int **C = new unsigned int *[N + 1];
for (int i = 0; i < N + 1; i++) {
C[i] = new unsigned int[N + 1];
}
for (int i = 0; i < N + 1; i++) {
for (int j = 0; j < N + 1; j++) {
C[i][j] = 0;
}
}
C[0][0] = 1;
for (int i = 1; i < N + 1; i++) {
C[i][0] = 1;
for (int j = 1; j < i + 1; j++) {
C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % q;
}
}
for (int i = 1; i <= K; i++) {
if (i > (N + 1) / 2) {
std::cout << 0 << std::endl;
} else {
red = C[N - K + 1][i];
blue = C[K - 1][i - 1];
std::cout << (red * blue) % q << std::endl;
}
}
for (int i = 0; i < N + 1; i++) {
delete[] C[i];
}
delete[] C;
return 0;
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 798,191 | 798,192 | u786283792 | cpp |
p02990 | #include <bits/stdc++.h> // ver2.1.7
#define int long long
#define endl "\n"
#define ALL(v) (v).begin(), (v).end()
#define Vi vector<int>
#define Pii pair<int, int>
#define Tiii tuple<int, int, int>
#define PQi priority_queue<int>
#define PQir priority_queue<int, vector<int>, greater<int>>
#define pb push_back
#define mp make_pair
#define mt make_tuple
#define cYES cout << "YES" << endl
#define cNO cout << "NO" << endl
#define cYes cout << "Yes" << endl
#define cNo cout << "No" << endl
#define sortr(v) sort(v, greater<>())
#define rep(i, a, b) for (int i = a; i < b; i++)
#define repeq(i, a, b) for (int i = a; i <= b; i++)
#define repr(i, a, b) for (int i = a; i > b; i--)
#define repreq(i, a, b) for (int i = a; i >= b; i--)
#define leng(n) (int)(log10(n) + 1)
#define dem(a, b) ((a + b - 1) / (b))
#define Vout(a) \
rep(Z, 0, a.size() - 1) cout << a[Z] << ' '; \
cout << a.back() << endl
#define VVout(a) \
rep(lW, 0, a.size()) { Vout(a[lW]); }
#define INF 9000000000000000000 // 9.0 * 10^18
#define MOD 1000000007 // 10^9 + 7
using namespace std;
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; } // 最大公約数gcd
int lcm(int a, int b) { return a / gcd(a, b) * b; } // 最小公倍数lcm
int mypow(int x, int n, int m) { // 累乗x^n(mod m) O(log(n))
if (n == 0)
return 1;
if (n % 2 == 0)
return mypow(x * x % m, n / 2, m);
else
return x * mypow(x, n - 1, m) % m;
}
int comb(int n, int r) { // nCr (MOD環境下)
int a = 1;
for (int i = n; i > n - r; --i) {
a = a * i % MOD;
}
for (int i = 1; i < r + 1; ++i) {
a = a * mypow(i, MOD - 2, MOD) % MOD;
}
return a % MOD;
}
signed main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(12);
int n, b, r;
cin >> n >> b;
r = n - b;
int ans = 1;
rep(i, 0, b) {
ans = 1;
ans *= comb(b - 1, i);
if (r - i < 0)
ans = 0;
else
ans *= comb(r + 1, r - i) % MOD;
cout << ans << endl;
}
return 0;
} | #include <bits/stdc++.h> // ver2.1.7
#define int long long
#define endl "\n"
#define ALL(v) (v).begin(), (v).end()
#define Vi vector<int>
#define Pii pair<int, int>
#define Tiii tuple<int, int, int>
#define PQi priority_queue<int>
#define PQir priority_queue<int, vector<int>, greater<int>>
#define pb push_back
#define mp make_pair
#define mt make_tuple
#define cYES cout << "YES" << endl
#define cNO cout << "NO" << endl
#define cYes cout << "Yes" << endl
#define cNo cout << "No" << endl
#define sortr(v) sort(v, greater<>())
#define rep(i, a, b) for (int i = a; i < b; i++)
#define repeq(i, a, b) for (int i = a; i <= b; i++)
#define repr(i, a, b) for (int i = a; i > b; i--)
#define repreq(i, a, b) for (int i = a; i >= b; i--)
#define leng(n) (int)(log10(n) + 1)
#define dem(a, b) ((a + b - 1) / (b))
#define Vout(a) \
rep(Z, 0, a.size() - 1) cout << a[Z] << ' '; \
cout << a.back() << endl
#define VVout(a) \
rep(lW, 0, a.size()) { Vout(a[lW]); }
#define INF 9000000000000000000 // 9.0 * 10^18
#define MOD 1000000007 // 10^9 + 7
using namespace std;
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; } // 最大公約数gcd
int lcm(int a, int b) { return a / gcd(a, b) * b; } // 最小公倍数lcm
int mypow(int x, int n, int m) { // 累乗x^n(mod m) O(log(n))
if (n == 0)
return 1;
if (n % 2 == 0)
return mypow(x * x % m, n / 2, m);
else
return x * mypow(x, n - 1, m) % m;
}
int comb(int n, int r) { // nCr (MOD環境下)
int a = 1;
for (int i = n; i > n - r; --i) {
a = a * i % MOD;
}
for (int i = 1; i < r + 1; ++i) {
a = a * mypow(i, MOD - 2, MOD) % MOD;
}
return a % MOD;
}
signed main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(12);
int n, b, r;
cin >> n >> b;
r = n - b;
int ans = 1;
rep(i, 0, b) {
ans = 1;
ans *= comb(b - 1, i);
if (r - i < 0)
ans = 0;
else
ans *= comb(r + 1, r - i) % MOD;
cout << ans % MOD << endl;
}
return 0;
} | [
"expression.operation.binary.add"
] | 798,197 | 798,198 | u095453583 | cpp |
p02990 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
int dp[2001][2001];
int mod = 1000000007;
int nCr(int n, int r) {
if (n == r)
return dp[n][r] = 1;
if (r == 0)
return dp[n][r] = 1;
if (r == 1)
return dp[n][r] = n;
if (dp[n][r])
return dp[n][r];
dp[n][r] = (nCr(n - 1, r) % mod + nCr(n - 1, r - 1) % mod) % mod;
return dp[n][r];
}
int main() {
int n, k;
cin >> n >> k;
for (int i = 1; i <= k; i++) {
if (i > (n - k + 1)) {
puts("0");
} else {
ll ans;
ans = (ll)(nCr(n - k + 1, i) * nCr(k - 1, i - 1)) % mod;
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;
int dp[2001][2001];
int mod = 1000000007;
int nCr(int n, int r) {
if (n == r)
return dp[n][r] = 1;
if (r == 0)
return dp[n][r] = 1;
if (r == 1)
return dp[n][r] = n;
if (dp[n][r])
return dp[n][r];
dp[n][r] = (nCr(n - 1, r) % mod + nCr(n - 1, r - 1) % mod) % mod;
return dp[n][r];
}
int main() {
int n, k;
cin >> n >> k;
for (int i = 1; i <= k; i++) {
if (i > (n - k + 1)) {
puts("0");
} else {
int ans;
ans = ((ll)nCr(n - k + 1, i) * nCr(k - 1, i - 1)) % mod;
cout << ans << endl;
}
}
return 0;
} | [
"variable_declaration.type.change",
"call.arguments.change"
] | 798,199 | 798,200 | u915797797 | cpp |
p02990 | #include <algorithm>
#include <cmath>
#include <cstring>
#include <iostream>
#include <limits>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define LL long long
#define MOD (1000000007)
// 132
// mod. m �ł� a �̋t�� a^{-1} ���v�Z����
LL modinv(LL a, LL m) {
LL b = m, u = 1, v = 0;
while (b) {
LL t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= m;
if (u < 0)
u += m;
return u;
}
LL calcCombinationMOD(LL n, LL r, LL mod) {
LL num = 1;
for (LL i = 1; i <= r; i++) {
num = num * (n - i + 1);
num = num % mod;
num = (num * modinv(i, mod)) % mod;
}
return num;
}
LL calcHomogeneousProductMOD(LL n, LL r, LL mod) {
return calcCombinationMOD(n + r - 1, r, mod);
}
int main() {
LL N, B;
scanf("%lld %lld", &N, &B);
LL R = N - B;
for (LL i = 1; i <= B; i++) {
LL lastB = B - i;
LL lastR = R - (i - 1);
if (lastR < 0) {
printf("0\n");
}
LL boxB = i;
LL boxR = i + 1;
LL patternB = calcHomogeneousProductMOD(boxB, lastB, MOD);
LL patternR = calcHomogeneousProductMOD(boxR, lastR, MOD);
LL result = (patternB * patternR) % MOD;
printf("%lld\n", result);
}
}
// 131
/*
struct LLPair {
LL A, B;
};
int main() {
LL N;
scanf("%lld", &N);
vector<LLPair> A(N);
for (int i = 0; i < N; i++) {
LL a, b;
scanf("%lld %lld", &a, &b);
A[i].A = a;
A[i].B = b;
}
std::sort(A.begin(), A.end(), [](const LLPair &a, const LLPair &b) {
return a.B < b.B;
});
LL time = 0;
bool success = true;
for (auto item : A) {
time += item.A;
if (time > item.B) {
success = false;
}
}
if (success) {
printf("Yes\n");
}
else {
printf("No\n");
}
return 0;
}
*/
// 130
/*
int main() {
LL N, K;
scanf("%lld %lld", &N, &K);
vector<LL> a(N);
for (int i = 0; i < N; i++) {
scanf("%lld", &a[i]);
}
LL result = 0;
LL begin = 0, end = 0;
LL total = a[0];
while (true) {
if (total >= K) {
if (total >= K) {
result++;
result += N - end - 1;
}
//�[�����Ă���̂�begin��i�߂�
if (begin == end) {
begin++;
end++;
total = a[begin];
}
else {
total -= a[begin];
begin++;
}
}
else {
//�[�����Ă��Ȃ��̂�end��i�߂�
end++;
if (end >= N) {
break;
}
else {
total += a[end];
}
}
}
printf("%lld\n", result);
return 0;
}
*/
// 129
/*
int main() {
LL H, W;
scanf("%lld %lld", &H, &W);
static int hor_label[2020][2020];
static int var_label[2020][2020];
static int hor_label_to_count[2020 * 2020];
static int var_label_to_count[2020 * 2020];
memset(hor_label, 0, sizeof(hor_label));
memset(var_label, 0, sizeof(var_label));
memset(hor_label_to_count, 0, sizeof(hor_label_to_count));
memset(var_label_to_count, 0, sizeof(var_label_to_count));
char s[2020];
int hor_curr_label = 1;
int var_curr_label = 1;
for (int j = 0; j < H; j++) {
scanf("%s", &s);
for (int i = 0; i < W; i++) {
if (s[i] == '.') {
hor_label[j][i] = hor_curr_label;
hor_label_to_count[hor_curr_label]++;
if (j == 0) {
var_label[j][i] = var_curr_label;
var_label_to_count[var_curr_label]++;
var_curr_label++;
}
else {
int abobe_label = var_label[j - 1][i];
if (abobe_label > 0) {
var_label[j][i] = abobe_label;
var_label_to_count[abobe_label]++;
}
else {
var_label[j][i] =
var_curr_label; var_label_to_count[var_curr_label]++; var_curr_label++;
}
}
}
else {
hor_curr_label++;
}
}
hor_curr_label++;
}
LL result = 0;
for (int j = 0; j < H; j++) {
for (int i = 0; i < W; i++) {
if (hor_label[j][i] == 0) {
continue;
}
LL count = hor_label_to_count[hor_label[j][i]] +
var_label_to_count[var_label[j][i]] - 1;
result = max(count, result);
}
}
printf("%lld\n", result);
return 0;
}
*/
// 128
/*
int main() {
LL N, K;
scanf("%lld %lld", &N, &K);
vector<LL> V(N);
vector<LL> Lval(N + 1);
Lval[0] = 0;
for (int i = 0; i < N; i++) {
scanf("%lld", &V[i]);
Lval[i + 1] = Lval[i] + V[i];
}
vector<LL> Rval(N + 1);
Rval[0] = 0;
for (int i = 0; i < N; i++) {
Rval[i + 1] = Rval[i] + V[N - i - 1];
}
vector<vector<vector<LL>>> Dq(N + 1, vector<vector<LL>>(N + 1,
vector<LL>(0)));
for (int i = 0; i <= N; i++) { //L
for (int j = 0; j <= N - i; j++) { //R
for (int l = 0; l < i; l++) {
if (V[l] < 0) {
Dq[i][j].push_back(V[l]);
}
}
for (int r = 0; r < j; r++) {
if (V[N - r - 1] < 0) {
Dq[i][j].push_back(V[N - r - 1]);
}
}
if (Dq[i][j].size() > 0) {
std::sort(Dq[i][j].begin(), Dq[i][j].end());
}
}
}
LL result = 0;
LL max_get = min(N, K);
for (int l = 0; l <= max_get; l++) {
for (int r = 0; r <= max_get - l; r++) {
for (int d = 0; d <= K - l - r; d++) {
LL value = Lval[l] + Rval[r];
int dis = min(d, (int)Dq[l][r].size());
for (int i = 0; i < dis; i++) {
value -= Dq[l][r][i];
}
result = max(result, value);
}
}
}
printf("%lld\n", result);
return 0;
}
*/
// 127
/*
struct IntPair {
LL B, C;
};
int main() {
LL N, M;
scanf("%lld %lld", &N, &M);
vector<LL> A;
for (int i = 0; i < N; i++) {
LL val;
scanf("%lld", &val);
A.push_back(val);
}
vector<IntPair> P;
for (int i = 0; i < M; i++) {
LL val1, val2;
scanf("%lld %lld", &val1, &val2);
IntPair pair;
pair.B = val1;
pair.C = val2;
P.push_back(pair);
}
std::sort(A.begin(), A.end());
std::sort(P.begin(), P.end(), [](const IntPair &a, const IntPair &b) {
return a.C > b.C;
});
LL indexA = 0;
bool finish = false;
for (auto item : P) {
for (int i = 0; i < item.B; i++) {
if (item.C > A[indexA]) {
A[indexA] = item.C;
}
else {
finish = true;
break;
}
indexA++;
if (indexA >= N) {
finish = true;
break;
}
}
if (finish) {
break;
}
}
LL result = 0;
for (auto item : A) {
result += item;
}
printf("%lld\n", result);
return 0;
}
*/
// 126
/*
struct Node {
unsigned int connect;
unsigned int weight;
};
int main() {
LL N;
scanf("%lld", &N);
static vector<Node> node[100010];
static char color[100010];
for (int i = 0; i < N - 1; i++) {
unsigned int u, v, w;
scanf("%d %d %d", &u, &v, &w);
Node n1;
n1.connect = v;
n1.weight = w;
node[u].push_back(n1);
Node n2;
n2.connect = u;
n2.weight = w;
node[v].push_back(n2);
}
for (int i = 0; i <= N; i++) {
color[i] = -1;
}
std::queue<unsigned int> q;
color[1] = 0;
q.push(1);
//���D��T��
while (q.size() > 0) {
unsigned int index = q.front();
q.pop();
char c = color[index];
for (auto item : node[index]) {
if (color[item.connect] < 0) {
//�܂��ʂ��Ă��Ȃ��m�[�h
color[item.connect] = item.weight % 2 == 0 ? c :
1 - c; q.push(item.connect);
}
}
}
for (int i = 1; i <= N; i++) {
printf("%d\n", color[i]);
}
return 0;
}
*/ | #include <algorithm>
#include <cmath>
#include <cstring>
#include <iostream>
#include <limits>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define LL long long
#define MOD (1000000007)
// 132
// mod. m �ł� a �̋t�� a^{-1} ���v�Z����
LL modinv(LL a, LL m) {
LL b = m, u = 1, v = 0;
while (b) {
LL t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= m;
if (u < 0)
u += m;
return u;
}
LL calcCombinationMOD(LL n, LL r, LL mod) {
LL num = 1;
for (LL i = 1; i <= r; i++) {
num = num * (n - i + 1);
num = num % mod;
num = (num * modinv(i, mod)) % mod;
}
return num;
}
LL calcHomogeneousProductMOD(LL n, LL r, LL mod) {
return calcCombinationMOD(n + r - 1, r, mod);
}
int main() {
LL N, B;
scanf("%lld %lld", &N, &B);
LL R = N - B;
for (LL i = 1; i <= B; i++) {
LL lastB = B - i;
LL lastR = R - (i - 1);
if (lastR < 0) {
printf("0\n");
continue;
}
LL boxB = i;
LL boxR = i + 1;
LL patternB = calcHomogeneousProductMOD(boxB, lastB, MOD);
LL patternR = calcHomogeneousProductMOD(boxR, lastR, MOD);
LL result = (patternB * patternR) % MOD;
printf("%lld\n", result);
}
}
// 131
/*
struct LLPair {
LL A, B;
};
int main() {
LL N;
scanf("%lld", &N);
vector<LLPair> A(N);
for (int i = 0; i < N; i++) {
LL a, b;
scanf("%lld %lld", &a, &b);
A[i].A = a;
A[i].B = b;
}
std::sort(A.begin(), A.end(), [](const LLPair &a, const LLPair &b) {
return a.B < b.B;
});
LL time = 0;
bool success = true;
for (auto item : A) {
time += item.A;
if (time > item.B) {
success = false;
}
}
if (success) {
printf("Yes\n");
}
else {
printf("No\n");
}
return 0;
}
*/
// 130
/*
int main() {
LL N, K;
scanf("%lld %lld", &N, &K);
vector<LL> a(N);
for (int i = 0; i < N; i++) {
scanf("%lld", &a[i]);
}
LL result = 0;
LL begin = 0, end = 0;
LL total = a[0];
while (true) {
if (total >= K) {
if (total >= K) {
result++;
result += N - end - 1;
}
//�[�����Ă���̂�begin��i�߂�
if (begin == end) {
begin++;
end++;
total = a[begin];
}
else {
total -= a[begin];
begin++;
}
}
else {
//�[�����Ă��Ȃ��̂�end��i�߂�
end++;
if (end >= N) {
break;
}
else {
total += a[end];
}
}
}
printf("%lld\n", result);
return 0;
}
*/
// 129
/*
int main() {
LL H, W;
scanf("%lld %lld", &H, &W);
static int hor_label[2020][2020];
static int var_label[2020][2020];
static int hor_label_to_count[2020 * 2020];
static int var_label_to_count[2020 * 2020];
memset(hor_label, 0, sizeof(hor_label));
memset(var_label, 0, sizeof(var_label));
memset(hor_label_to_count, 0, sizeof(hor_label_to_count));
memset(var_label_to_count, 0, sizeof(var_label_to_count));
char s[2020];
int hor_curr_label = 1;
int var_curr_label = 1;
for (int j = 0; j < H; j++) {
scanf("%s", &s);
for (int i = 0; i < W; i++) {
if (s[i] == '.') {
hor_label[j][i] = hor_curr_label;
hor_label_to_count[hor_curr_label]++;
if (j == 0) {
var_label[j][i] = var_curr_label;
var_label_to_count[var_curr_label]++;
var_curr_label++;
}
else {
int abobe_label = var_label[j - 1][i];
if (abobe_label > 0) {
var_label[j][i] = abobe_label;
var_label_to_count[abobe_label]++;
}
else {
var_label[j][i] =
var_curr_label; var_label_to_count[var_curr_label]++; var_curr_label++;
}
}
}
else {
hor_curr_label++;
}
}
hor_curr_label++;
}
LL result = 0;
for (int j = 0; j < H; j++) {
for (int i = 0; i < W; i++) {
if (hor_label[j][i] == 0) {
continue;
}
LL count = hor_label_to_count[hor_label[j][i]] +
var_label_to_count[var_label[j][i]] - 1;
result = max(count, result);
}
}
printf("%lld\n", result);
return 0;
}
*/
// 128
/*
int main() {
LL N, K;
scanf("%lld %lld", &N, &K);
vector<LL> V(N);
vector<LL> Lval(N + 1);
Lval[0] = 0;
for (int i = 0; i < N; i++) {
scanf("%lld", &V[i]);
Lval[i + 1] = Lval[i] + V[i];
}
vector<LL> Rval(N + 1);
Rval[0] = 0;
for (int i = 0; i < N; i++) {
Rval[i + 1] = Rval[i] + V[N - i - 1];
}
vector<vector<vector<LL>>> Dq(N + 1, vector<vector<LL>>(N + 1,
vector<LL>(0)));
for (int i = 0; i <= N; i++) { //L
for (int j = 0; j <= N - i; j++) { //R
for (int l = 0; l < i; l++) {
if (V[l] < 0) {
Dq[i][j].push_back(V[l]);
}
}
for (int r = 0; r < j; r++) {
if (V[N - r - 1] < 0) {
Dq[i][j].push_back(V[N - r - 1]);
}
}
if (Dq[i][j].size() > 0) {
std::sort(Dq[i][j].begin(), Dq[i][j].end());
}
}
}
LL result = 0;
LL max_get = min(N, K);
for (int l = 0; l <= max_get; l++) {
for (int r = 0; r <= max_get - l; r++) {
for (int d = 0; d <= K - l - r; d++) {
LL value = Lval[l] + Rval[r];
int dis = min(d, (int)Dq[l][r].size());
for (int i = 0; i < dis; i++) {
value -= Dq[l][r][i];
}
result = max(result, value);
}
}
}
printf("%lld\n", result);
return 0;
}
*/
// 127
/*
struct IntPair {
LL B, C;
};
int main() {
LL N, M;
scanf("%lld %lld", &N, &M);
vector<LL> A;
for (int i = 0; i < N; i++) {
LL val;
scanf("%lld", &val);
A.push_back(val);
}
vector<IntPair> P;
for (int i = 0; i < M; i++) {
LL val1, val2;
scanf("%lld %lld", &val1, &val2);
IntPair pair;
pair.B = val1;
pair.C = val2;
P.push_back(pair);
}
std::sort(A.begin(), A.end());
std::sort(P.begin(), P.end(), [](const IntPair &a, const IntPair &b) {
return a.C > b.C;
});
LL indexA = 0;
bool finish = false;
for (auto item : P) {
for (int i = 0; i < item.B; i++) {
if (item.C > A[indexA]) {
A[indexA] = item.C;
}
else {
finish = true;
break;
}
indexA++;
if (indexA >= N) {
finish = true;
break;
}
}
if (finish) {
break;
}
}
LL result = 0;
for (auto item : A) {
result += item;
}
printf("%lld\n", result);
return 0;
}
*/
// 126
/*
struct Node {
unsigned int connect;
unsigned int weight;
};
int main() {
LL N;
scanf("%lld", &N);
static vector<Node> node[100010];
static char color[100010];
for (int i = 0; i < N - 1; i++) {
unsigned int u, v, w;
scanf("%d %d %d", &u, &v, &w);
Node n1;
n1.connect = v;
n1.weight = w;
node[u].push_back(n1);
Node n2;
n2.connect = u;
n2.weight = w;
node[v].push_back(n2);
}
for (int i = 0; i <= N; i++) {
color[i] = -1;
}
std::queue<unsigned int> q;
color[1] = 0;
q.push(1);
//���D��T��
while (q.size() > 0) {
unsigned int index = q.front();
q.pop();
char c = color[index];
for (auto item : node[index]) {
if (color[item.connect] < 0) {
//�܂��ʂ��Ă��Ȃ��m�[�h
color[item.connect] = item.weight % 2 == 0 ? c :
1 - c; q.push(item.connect);
}
}
}
for (int i = 1; i <= N; i++) {
printf("%d\n", color[i]);
}
return 0;
}
*/ | [] | 798,201 | 798,202 | u572472538 | cpp |
p02990 | #include <iostream>
#include <vector>
using namespace std;
int main() {
int n, k, red;
long long const mod = 1e9 + 7;
vector<vector<long long>> comb;
cin >> n >> k;
red = n - k;
comb.assign(n * 2, vector<long long>());
for (int i = 0; i < n * 2; i++) {
comb[i].assign(i + 1, 0);
comb[i][0] = comb[i][i] = 1;
for (int j = 1; j < i; j++) {
comb[i][j] = (comb[i - 1][j] + comb[i - 1][j - 1]) % mod;
}
}
for (int i = 1; i <= k; i++) {
int res = k - i;
// i H res
long long ans = comb[i + res + 1][res];
//
res = red - i + 1;
if (res < 0) {
ans = 0;
} else {
ans *= comb[i + 1 + res + 1][res];
}
cout << ans % mod << endl;
}
return 0;
} | #include <iostream>
#include <vector>
using namespace std;
int main() {
int n, k, red;
long long const mod = 1e9 + 7;
vector<vector<long long>> comb;
cin >> n >> k;
red = n - k;
comb.assign(n * 2, vector<long long>());
for (int i = 0; i < n * 2; i++) {
comb[i].assign(i + 1, 0);
comb[i][0] = comb[i][i] = 1;
for (int j = 1; j < i; j++) {
comb[i][j] = (comb[i - 1][j] + comb[i - 1][j - 1]) % mod;
}
}
for (int i = 1; i <= k; i++) {
int res = k - i;
// i H res
long long ans = comb[i + res - 1][res];
//
res = red - i + 1;
if (res < 0) {
ans = 0;
} else {
ans *= comb[i + 1 + res - 1][res];
}
cout << ans % mod << endl;
}
return 0;
}
| [
"misc.opposites",
"expression.operator.arithmetic.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change",
"assignment.value.change"
] | 798,205 | 798,206 | u024809932 | cpp |
p02990 | #include <algorithm>
#include <array>
#include <bitset>
#include <cmath>
#include <complex>
#include <cstdio>
#include <deque>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define REP(i, n) for (int i = 0; i < n; ++i)
#define FOR(i, a, b) for (int i = a; i <= b; ++i)
#define FORR(i, a, b) for (int i = a; i >= b; --i)
#define ALL(c) (c).begin(), (c).end()
typedef long long ll;
typedef vector<int> VI;
typedef vector<ll> VL;
typedef vector<long double> VD;
typedef vector<VI> VVI;
typedef vector<VL> VVL;
typedef vector<VD> VVD;
typedef pair<int, int> P;
typedef pair<ll, ll> PL;
template <typename T> void chmin(T &a, T b) {
if (a > b)
a = b;
}
template <typename T> void chmax(T &a, T b) {
if (a < b)
a = b;
}
int in() {
int x;
scanf("%d", &x);
return x;
}
ll lin() {
ll x;
scanf("%lld", &x);
return x;
}
#define INF 1LL << 60
ll mod = 1e9 + 7;
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;
}
ll comb(ll n, ll r) {
ll num = 1;
for (ll i = 1; i <= r; i++) {
num = num * (n - i + 1) * modinv(i, mod);
num %= mod;
}
return num;
}
int main() {
ll N, K;
cin >> N >> K;
for (ll i = 1; i <= K; ++i) {
// cerr << "i: " << i << endl;
if (N - K - i + 1 < 0) {
cout << 0 << endl;
continue;
}
ll tmp1 = comb(K - 1, i - 1);
ll tmp2 = 1;
// cerr << "N-K-(i-1) = " << N-K-(i-1) << " i+1 = " << (i+1) << endl;
if (N - K - i + 1 >= 0)
tmp2 = comb(N - K - (i - 1) + (i + 1) - 1, i);
// cerr << "tmp1: " << tmp1 <<" tmp2: " << tmp2 << endl;
ll ans = (tmp1 * tmp2) % mod;
cout << ans << endl;
}
return 0;
} | #include <algorithm>
#include <array>
#include <bitset>
#include <cmath>
#include <complex>
#include <cstdio>
#include <deque>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define REP(i, n) for (int i = 0; i < n; ++i)
#define FOR(i, a, b) for (int i = a; i <= b; ++i)
#define FORR(i, a, b) for (int i = a; i >= b; --i)
#define ALL(c) (c).begin(), (c).end()
typedef long long ll;
typedef vector<int> VI;
typedef vector<ll> VL;
typedef vector<long double> VD;
typedef vector<VI> VVI;
typedef vector<VL> VVL;
typedef vector<VD> VVD;
typedef pair<int, int> P;
typedef pair<ll, ll> PL;
template <typename T> void chmin(T &a, T b) {
if (a > b)
a = b;
}
template <typename T> void chmax(T &a, T b) {
if (a < b)
a = b;
}
int in() {
int x;
scanf("%d", &x);
return x;
}
ll lin() {
ll x;
scanf("%lld", &x);
return x;
}
#define INF 1LL << 60
ll mod = 1e9 + 7;
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;
}
ll comb(ll n, ll r) {
ll num = 1;
for (ll i = 1; i <= r; i++) {
num = (num * (n - i + 1) % mod) * modinv(i, mod);
num %= mod;
}
return num;
}
int main() {
ll N, K;
cin >> N >> K;
for (ll i = 1; i <= K; ++i) {
// cerr << "i: " << i << endl;
if (N - K - i + 1 < 0) {
cout << 0 << endl;
continue;
}
ll tmp1 = comb(K - 1, i - 1);
ll tmp2 = 1;
// cerr << "N-K-(i-1) = " << N-K-(i-1) << " i+1 = " << (i+1) << endl;
if (N - K - i + 1 >= 0)
tmp2 = comb(N - K - (i - 1) + (i + 1) - 1, i);
// cerr << "tmp1: " << tmp1 <<" tmp2: " << tmp2 << endl;
ll ans = (tmp1 * tmp2) % mod;
cout << ans << endl;
}
return 0;
} | [
"assignment.change"
] | 798,209 | 798,210 | u941028483 | cpp |
p02990 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define reps(i, n) for (int i = 1; i <= (n); ++i)
#define repr(i, n) for (int i = (n); i >= 0; --i)
#define cinv(n, v) \
VL v(n); \
rep(i, n) cin >> v[i]
#define int long long
#define itn int
#define pb push_back
#define eb emplace_back
#define m_p make_pair
#define m_t make_tuple
#define p_p(a, b) pb(m_p(a, b))
#define all(a) a.begin(), a.end()
#define SORT(a) sort(all(a))
#define RSORT(a) sort(all(a), greater<>())
#define UNIQUE(a) a.erase(unique(all(a)), a.end())
#define SZ(a) (signed)(a.size())
#define debg(a) cout << #a << " " << a << endl;
#define debgp(a) cout << #a << " " << a.fi << " : " << a.se << endl
#define call(a) \
for (auto i : a) \
cout << i << " "; \
cout << endl
#define callp(a) \
for (auto [k, v] : a) \
cout << k << ":" << v << endl
#define show(a) \
for (cont & y : a) { \
for (cont & x : y) { \
cout << x << " "; \
} \
cout << endl; \
}
#define out(a) cout << (a) << endl
#define ENDL cout << endl
#define YES cout << "YES" << endl
#define NO cout << "NO" << endl
#define Yes cout << "Yes" << endl
#define No cout << "No" << endl
#define LINE puts("------------------")
#define fi first
#define se second
#define V vector
#define P pair
#define T tuple
#define PQ priority_queue
#define cont const auto
#define VV(type, name, y, x, a) \
vector<vector<type>> name = vector<vector<type>>(y, vector<type>(x, a))
typedef long long ll;
typedef double D;
typedef long double LD;
typedef string str;
typedef vector<ll> VL;
typedef pair<ll, ll> PL;
typedef vector<pair<ll, ll>> VP;
typedef tuple<ll, ll, ll> T3;
typedef tuple<ll, ll, ll, ll> T4;
typedef struct {
ll to;
ll cost;
} Graphs;
typedef V<V<Graphs>> AdjList;
const signed INF = (1LL << 30);
const long long MOD = (1e9 + 7);
const long long LINF = (1LL << 60);
const long long LMAX = LLONG_MAX;
void YN(bool b) { cout << (b ? "Yes" : "No") << endl; }
template <class T> inline T gcd(T a, T b) {
if (b == 0)
return a;
return (gcd(b, a % b));
}
template <class T> inline T lcm(T a, T b) { return a / gcd(a, b) * b; }
template <class T> inline bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> T center(T a, T b, T c) {
if ((a <= b && b <= c) || (a >= b && b >= c))
return b;
if ((b >= a && a >= c) || (b <= a && a <= c))
return a;
return c;
}
void print() {}
template <class Head, class... Tail> void print(Head &&head, Tail &&...tail) {
cout << head << endl;
print(forward<Tail>(tail)...);
}
void input() {}
template <class Head, class... Tail> void input(Head &&head, Tail &&...tail) {
cin >> head;
input(forward<Tail>(tail)...);
}
template <typename T> ostream &operator<<(ostream &out, const vector<T> &v) {
if (!v.empty()) {
copy(v.begin(), v.end(), ostream_iterator<T>(out, ", "));
out << "\b\b";
}
return out;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &out, const pair<T1, T2> &p) {
out << p.first << ", " << p.second;
return out;
}
const ll MAX = (ll)1e6 + 10;
vector<ll> fac(MAX), finv(MAX), inv(MAX);
// 前処理
void comb_init() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; ++i) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
ll comb(ll n, ll k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
comb_init();
ll n, k, r, b;
cin >> n >> k;
r = n - k;
reps(i, k) {
ll red = comb(r + 1, i);
ll blue = comb(k - 1, i - 1);
out(red * blue);
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define reps(i, n) for (int i = 1; i <= (n); ++i)
#define repr(i, n) for (int i = (n); i >= 0; --i)
#define cinv(n, v) \
VL v(n); \
rep(i, n) cin >> v[i]
#define int long long
#define itn int
#define pb push_back
#define eb emplace_back
#define m_p make_pair
#define m_t make_tuple
#define p_p(a, b) pb(m_p(a, b))
#define all(a) a.begin(), a.end()
#define SORT(a) sort(all(a))
#define RSORT(a) sort(all(a), greater<>())
#define UNIQUE(a) a.erase(unique(all(a)), a.end())
#define SZ(a) (signed)(a.size())
#define debg(a) cout << #a << " " << a << endl;
#define debgp(a) cout << #a << " " << a.fi << " : " << a.se << endl
#define call(a) \
for (auto i : a) \
cout << i << " "; \
cout << endl
#define callp(a) \
for (auto [k, v] : a) \
cout << k << ":" << v << endl
#define show(a) \
for (cont & y : a) { \
for (cont & x : y) { \
cout << x << " "; \
} \
cout << endl; \
}
#define out(a) cout << (a) << endl
#define ENDL cout << endl
#define YES cout << "YES" << endl
#define NO cout << "NO" << endl
#define Yes cout << "Yes" << endl
#define No cout << "No" << endl
#define LINE puts("------------------")
#define fi first
#define se second
#define V vector
#define P pair
#define T tuple
#define PQ priority_queue
#define cont const auto
#define VV(type, name, y, x, a) \
vector<vector<type>> name = vector<vector<type>>(y, vector<type>(x, a))
typedef long long ll;
typedef double D;
typedef long double LD;
typedef string str;
typedef vector<ll> VL;
typedef pair<ll, ll> PL;
typedef vector<pair<ll, ll>> VP;
typedef tuple<ll, ll, ll> T3;
typedef tuple<ll, ll, ll, ll> T4;
typedef struct {
ll to;
ll cost;
} Graphs;
typedef V<V<Graphs>> AdjList;
const signed INF = (1LL << 30);
const long long MOD = (1e9 + 7);
const long long LINF = (1LL << 60);
const long long LMAX = LLONG_MAX;
void YN(bool b) { cout << (b ? "Yes" : "No") << endl; }
template <class T> inline T gcd(T a, T b) {
if (b == 0)
return a;
return (gcd(b, a % b));
}
template <class T> inline T lcm(T a, T b) { return a / gcd(a, b) * b; }
template <class T> inline bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> T center(T a, T b, T c) {
if ((a <= b && b <= c) || (a >= b && b >= c))
return b;
if ((b >= a && a >= c) || (b <= a && a <= c))
return a;
return c;
}
void print() {}
template <class Head, class... Tail> void print(Head &&head, Tail &&...tail) {
cout << head << endl;
print(forward<Tail>(tail)...);
}
void input() {}
template <class Head, class... Tail> void input(Head &&head, Tail &&...tail) {
cin >> head;
input(forward<Tail>(tail)...);
}
template <typename T> ostream &operator<<(ostream &out, const vector<T> &v) {
if (!v.empty()) {
copy(v.begin(), v.end(), ostream_iterator<T>(out, ", "));
out << "\b\b";
}
return out;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &out, const pair<T1, T2> &p) {
out << p.first << ", " << p.second;
return out;
}
const ll MAX = (ll)1e6 + 10;
vector<ll> fac(MAX), finv(MAX), inv(MAX);
// 前処理
void comb_init() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; ++i) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
ll comb(ll n, ll k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
comb_init();
ll n, k, r, b;
cin >> n >> k;
r = n - k;
reps(i, k) {
ll red = comb(r + 1, i);
ll blue = comb(k - 1, i - 1);
out((red * blue) % MOD);
}
return 0;
}
| [
"call.arguments.change",
"call.arguments.add"
] | 798,227 | 798,228 | u423624748 | cpp |
p02990 | #include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define rep(i, n) FOR(i, 0, n)
#define pb emplace_back
typedef long long ll;
typedef pair<int, int> pint;
const int MAX_N = 4001;
const int mod = 1000000007;
ll fact[MAX_N + 1];
ll inv[MAX_N + 1], finv[MAX_N + 1];
int inv_init(ll n, ll p) {
inv[1] = 1;
FOR(i, 2, n + 1) inv[i] = p - (p / i) * inv[p % i] % p;
fact[0] = finv[0] = 1;
FOR(i, 1, n + 1) {
fact[i] = fact[i - 1] * i % p;
finv[i] = finv[i - 1] * inv[i] % p;
}
return 0;
}
ll comb_mod(ll n, ll k, ll p) {
if (k < 0 || n < k)
return 0;
return finv[k] * finv[n - k] % p * fact[n] % p;
}
int main() {
int n, k;
cin >> n >> k;
inv_init(n * 2, mod);
FOR(i, 1, k + 1) {
ll ans = comb_mod(n - k + 1, i, mod) * comb_mod(k - i + i - 1, k - i, mod);
cout << ans << endl;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define rep(i, n) FOR(i, 0, n)
#define pb emplace_back
typedef long long ll;
typedef pair<int, int> pint;
const int MAX_N = 4001;
const int mod = 1000000007;
ll fact[MAX_N + 1];
ll inv[MAX_N + 1], finv[MAX_N + 1];
int inv_init(ll n, ll p) {
inv[1] = 1;
FOR(i, 2, n + 1) inv[i] = p - (p / i) * inv[p % i] % p;
fact[0] = finv[0] = 1;
FOR(i, 1, n + 1) {
fact[i] = fact[i - 1] * i % p;
finv[i] = finv[i - 1] * inv[i] % p;
}
return 0;
}
ll comb_mod(ll n, ll k, ll p) {
if (k < 0 || n < k)
return 0;
return finv[k] * finv[n - k] % p * fact[n] % p;
}
int main() {
int n, k;
cin >> n >> k;
inv_init(n * 2, mod);
FOR(i, 1, k + 1) {
ll ans = comb_mod(n - k + 1, i, mod) * comb_mod(k - i + i - 1, k - i, mod);
cout << ans % mod << endl;
}
return 0;
}
| [
"expression.operation.binary.add"
] | 798,237 | 798,238 | u526367939 | 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(n - k + 1, i) * COM(k - 1, i - 1) << 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();
//青球の選び方K個のボールをi個のグループに分ける... k-1個の隙間からi個選ぶ
//赤球の選び方N-K個のボールをk+1このグループに分ける...k-1個(ボールの隙間)には必ず一つ以上のボールが入るが2こ(青球の両端)にはボールが入らなくてもよい.
// N-K-1+2個の隙間にiこのグループを割り付ける...n-k+1Ci
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"
] | 798,239 | 798,240 | u108540384 | 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(n - k + 1, i) * COM(k - 1, i - 1) << 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++) {
cout << COM(n - k + 1, i) * COM(k - 1, i - 1) % MOD << endl;
}
return 0;
} | [
"expression.operation.binary.add"
] | 798,239 | 798,241 | u108540384 | cpp |
p02990 | #include <bits/stdc++.h>
#define maxn 2005
using namespace std;
typedef long long ll;
ll inv[maxn], F[maxn], Finv[maxn];
ll mod = 1e9 + 7;
void init() {
inv[1] = 1;
for (int i = 2; i < maxn; i++) {
inv[i] = (mod - mod / i) * inv[mod % i] % mod;
}
F[0] = 1;
Finv[0] = 1;
for (int i = 1; i <= maxn; i++) {
F[i] = F[i - 1] * i % mod;
Finv[i] = Finv[i - 1] * inv[i] % mod;
}
}
ll C(ll n, ll m) {
if (n < 0 || m < 0 || m > n)
return 1;
return F[n] * Finv[m] % mod * Finv[n - m] % mod;
}
int main() {
int n, k;
init();
scanf("%d%d", &n, &k);
for (int i = 1; i <= k; i++) {
ll a = C(n - k + 1, i);
ll b = C(k - 1, i - 1);
printf("%lld\n", a * b % mod);
}
return 0;
} | #include <bits/stdc++.h>
#define maxn 2005
using namespace std;
typedef long long ll;
ll inv[maxn], F[maxn], Finv[maxn];
ll mod = 1e9 + 7;
void init() {
inv[1] = 1;
for (int i = 2; i < maxn; i++) {
inv[i] = (mod - mod / i) * inv[mod % i] % mod;
}
F[0] = 1;
Finv[0] = 1;
for (int i = 1; i <= maxn; i++) {
F[i] = F[i - 1] * i % mod;
Finv[i] = Finv[i - 1] * inv[i] % mod;
}
}
ll C(ll n, ll m) {
if (n < 0 || m < 0 || m > n)
return 0;
return F[n] * Finv[m] % mod * Finv[n - m] % mod;
}
int main() {
int n, k;
init();
scanf("%d%d", &n, &k);
for (int i = 1; i <= k; i++) {
ll a = C(n - k + 1, i);
ll b = C(k - 1, i - 1);
printf("%lld\n", a * b % mod);
}
return 0;
} | [
"literal.number.change",
"function.return_value.change"
] | 798,244 | 798,245 | u907481435 | cpp |
p02990 | #include <iostream>
using namespace std;
long long MOD = 1e9 + 7;
long long N, K;
long long C[2001][2001];
long long comb(long long a, long long b) {
if (b == 0) {
return C[a][b] = 1;
}
if (a == b) {
return C[a][b] = 1;
}
if (C[a][b] != -1)
return C[a][b];
return C[a][b] = (comb(a - 1, b - 1) + comb(a - 1, b)) % MOD;
}
int main() {
cin >> N >> K;
for (int i = 0; i < 2001; i++) {
for (int j = 0; j < 2001; j++) {
C[i][j] = -1;
}
}
for (long long i = 1; i <= K; i++) {
if (N - K + 1 < i) {
cout << 0 << endl;
return 0;
}
cout << (comb(N - K + 1, i) * comb(K - 1, i - 1)) % MOD << endl;
}
return 0;
} | #include <iostream>
using namespace std;
long long MOD = 1e9 + 7;
long long N, K;
long long C[2001][2001];
long long comb(long long a, long long b) {
if (b == 0) {
return C[a][b] = 1;
}
if (a == b) {
return C[a][b] = 1;
}
if (C[a][b] != -1)
return C[a][b];
return C[a][b] = (comb(a - 1, b - 1) + comb(a - 1, b)) % MOD;
}
int main() {
cin >> N >> K;
for (int i = 0; i < 2001; i++) {
for (int j = 0; j < 2001; j++) {
C[i][j] = -1;
}
}
for (long long i = 1; i <= K; i++) {
if (N - K + 1 < i) {
cout << 0 << endl;
continue;
}
cout << (comb(N - K + 1, i) * comb(K - 1, i - 1)) % MOD << endl;
}
return 0;
} | [
"control_flow.return.remove",
"control_flow.continue.add"
] | 798,248 | 798,249 | u705230587 | cpp |
p02990 | // ABC 132 D Blue and Red Balls
#include <iostream>
typedef long long ll;
using namespace std;
ll MOD = 1e9 + 7;
int dp[2001][2001];
int main() {
int N, K;
cin >> N >> K;
dp[0][0] = 1;
for (int i = 1; i < 2001; i++) {
for (int j = 0; j <= i; j++) {
if (i == j || 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;
}
return 0;
}
| // ABC 132 D Blue and Red Balls
#include <iostream>
typedef long long ll;
using namespace std;
ll MOD = 1e9 + 7;
int dp[2001][2001];
int main() {
int N, K;
cin >> N >> K;
dp[0][0] = 1;
for (int i = 1; i < 2001; i++) {
for (int j = 0; j <= i; j++) {
if (i == j || 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 << ((ll)dp[N - K + 1][i] * (ll)dp[K - 1][i - 1]) % MOD << endl;
}
return 0;
}
/*
for(int i=1; i<=k; i++)
n-k+1 C i * k-1 C i-1
*/
| [
"type_conversion.add"
] | 798,250 | 798,251 | u069877747 | cpp |
p02990 | // ABC 132 D Blue and Red Balls
#include <iostream>
typedef long long ll;
using namespace std;
ll MOD = 1e9 + 7;
int dp[2001][2001];
int main() {
int N, K;
cin >> N >> K;
dp[0][0] = 1;
for (int i = 1; i < 2001; i++) {
for (int j = 0; j <= i; j++) {
if (i == j || 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++) {
if (N - K + 1 < i)
cout << '0' << endl;
else
cout << (dp[N - K + 1][i] * dp[K - 1][i - 1]) % MOD << endl;
}
return 0;
}
/*
for(int i=1; i<=k; i++)
n-k+1 C i * k-1 C i-1
*/
| // ABC 132 D Blue and Red Balls
#include <iostream>
typedef long long ll;
using namespace std;
ll MOD = 1e9 + 7;
int dp[2001][2001];
int main() {
int N, K;
cin >> N >> K;
dp[0][0] = 1;
for (int i = 1; i < 2001; i++) {
for (int j = 0; j <= i; j++) {
if (i == j || 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++) {
if (N - K + 1 < i)
cout << '0' << endl;
else
cout << ((ll)dp[N - K + 1][i] * (ll)dp[K - 1][i - 1]) % MOD << endl;
}
return 0;
}
/*
for(int i=1; i<=k; i++)
n-k+1 C i * k-1 C i-1
*/
| [
"type_conversion.add"
] | 798,252 | 798,253 | u069877747 | cpp |
p02990 | #include <bits/stdc++.h>
#define mp make_pair
#define fi first
#define se second
#define pb push_back
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define forn(i, n) for (int i = 0; i < n; i++)
#define for1(i, n) for (int i = 1; i <= n; i++)
#define ford(i, n) for (int i = n - 1; i >= 0; i--)
#define fore(i, a, b) for (int i = a; i <= b; i++)
using namespace std;
typedef long long ll;
typedef double ld;
typedef vector<int> vi;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<ll> vll;
const int MAX = 2000;
const long long INF = 1e18;
const long long mod = 1e9 + 7;
int arr[MAX + 5][MAX + 5];
void ncr() {
arr[0][0] = 1;
for (int i = 1; i <= MAX; i++) {
arr[i][0] = 1;
for (int j = 1; j <= i; j++) {
arr[i][j] = (arr[i - 1][j - 1] + arr[i - 1][j]) % mod;
}
}
}
int main() {
ll n, k;
cin >> n >> k;
ncr();
for (int i = 1; i <= k; i++) {
ll ans = ((arr[n - k + 1][i]) * (arr[k - 1][i - 1])) % mod;
// cout<<solve(3,1,mod)<<endl;
cout << ans << endl;
}
}
| #include <bits/stdc++.h>
#define mp make_pair
#define fi first
#define se second
#define pb push_back
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define forn(i, n) for (int i = 0; i < n; i++)
#define for1(i, n) for (int i = 1; i <= n; i++)
#define ford(i, n) for (int i = n - 1; i >= 0; i--)
#define fore(i, a, b) for (int i = a; i <= b; i++)
using namespace std;
typedef long long ll;
typedef double ld;
typedef vector<int> vi;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<ll> vll;
const int MAX = 2000;
const long long INF = 1e18;
const long long mod = 1e9 + 7;
ll arr[MAX + 5][MAX + 5];
void ncr() {
arr[0][0] = 1;
for (int i = 1; i <= MAX; i++) {
arr[i][0] = 1;
for (int j = 1; j <= i; j++) {
arr[i][j] = (arr[i - 1][j - 1] + arr[i - 1][j]) % mod;
}
}
}
int main() {
ll n, k;
cin >> n >> k;
ncr();
for (int i = 1; i <= k; i++) {
ll ans = ((arr[n - k + 1][i]) * (arr[k - 1][i - 1])) % mod;
// cout<<solve(3,1,mod)<<endl;
cout << ans << endl;
}
}
| [
"variable_declaration.type.change"
] | 798,258 | 798,259 | u930706982 | cpp |
p02990 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
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;
}
#define all(x) (x).begin(), (x).end()
#define pll pair<ll, ll>
#define rep(i, n) for (int i = 0; i < n; i++)
const ll INF = 1LL << 60;
const ll mod = (int)1e9 + 7;
void comb(vector<vector<ll>> &v) {
for (int i = 0; i < v.size(); i++) {
v[i][0] = 1;
v[i][i] = 1;
}
for (int k = 1; k < v.size(); k++) {
for (int j = 1; j < k; j++) {
v[k][j] = (v[k - 1][j - 1] + v[k - 1][j]) % mod;
}
}
}
int main() {
ll N;
cin >> N;
// ll N,M; cin >> N >> M;
// string S; cin >> S;
// ll H,W; cin >> H >> W;
ll K;
cin >> K;
ll M = max(N - K + 1, K - 1);
vector<vector<ll>> vec(M + 1, vector<ll>(M + 1, 0));
comb(vec);
rep(i, K) { cout << vec[N - K + 1][i + 1] * vec[K - 1][i] % mod << endl; }
}
/*
*/
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
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;
}
#define all(x) (x).begin(), (x).end()
#define pll pair<ll, ll>
#define rep(i, n) for (int i = 0; i < n; i++)
const ll INF = 1LL << 60;
const ll mod = (int)1e9 + 7;
void comb(vector<vector<ll>> &v) {
for (int i = 0; i < v.size(); i++) {
v[i][0] = 1;
v[i][i] = 1;
}
for (int k = 1; k < v.size(); k++) {
for (int j = 1; j < k; j++) {
v[k][j] = (v[k - 1][j - 1] + v[k - 1][j]) % mod;
}
}
}
int main() {
ll N;
cin >> N;
// ll N,M; cin >> N >> M;
// string S; cin >> S;
// ll H,W; cin >> H >> W;
ll K;
cin >> K;
ll M = max(N - K + 1, K - 1);
vector<vector<ll>> vec(M + 100, vector<ll>(M + 100, 0));
comb(vec);
rep(i, K) { cout << vec[N - K + 1][i + 1] * vec[K - 1][i] % mod << endl; }
}
/*
*/
| [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 798,267 | 798,268 | u593555034 | cpp |
p02990 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
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;
}
#define all(x) (x).begin(), (x).end()
#define pll pair<ll, ll>
#define rep(i, n) for (int i = 0; i < n; i++)
const ll INF = 1LL << 60;
const ll mod = (int)1e9 + 7;
void comb(vector<vector<long long int>> &v) {
for (int i = 0; i < v.size(); i++) {
v[i][0] = 1;
v[i][i] = 1;
}
for (int k = 1; k < v.size(); k++) {
for (int j = 1; j < k; j++) {
v[k][j] = (v[k - 1][j - 1] + v[k - 1][j]) % mod;
}
}
}
int main() {
ll N;
cin >> N;
// ll N,M; cin >> N >> M;
// string S; cin >> S;
// ll H,W; cin >> H >> W;
ll K;
cin >> K;
ll M = max(N - K + 1, K - 1);
vector<vector<ll>> vec(M + 1, vector<ll>(M + 1, 0));
comb(vec);
rep(i, K) { cout << vec[N - K + 1][i + 1] * vec[K - 1][i] % mod << endl; }
}
/*
*/
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
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;
}
#define all(x) (x).begin(), (x).end()
#define pll pair<ll, ll>
#define rep(i, n) for (int i = 0; i < n; i++)
const ll INF = 1LL << 60;
const ll mod = (int)1e9 + 7;
void comb(vector<vector<ll>> &v) {
for (int i = 0; i < v.size(); i++) {
v[i][0] = 1;
v[i][i] = 1;
}
for (int k = 1; k < v.size(); k++) {
for (int j = 1; j < k; j++) {
v[k][j] = (v[k - 1][j - 1] + v[k - 1][j]) % mod;
}
}
}
int main() {
ll N;
cin >> N;
// ll N,M; cin >> N >> M;
// string S; cin >> S;
// ll H,W; cin >> H >> W;
ll K;
cin >> K;
ll M = max(N - K + 1, K - 1);
vector<vector<ll>> vec(M + 100, vector<ll>(M + 100, 0));
comb(vec);
rep(i, K) { cout << vec[N - K + 1][i + 1] * vec[K - 1][i] % mod << endl; }
}
/*
*/
| [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 798,269 | 798,268 | u593555034 | cpp |
p02990 |
#include <bits/stdc++.h>
#define mem(ar, num) memset(ar, num, sizeof(ar))
#define me(ar) memset(ar, 0, sizeof(ar))
#define lowbit(x) (x & (-x))
#define Pb push_back
#define FI first
#define SE second
#define rep(i, a, n) for (int i = a; i < n; i++)
#define per(i, a, n) for (int i = n - 1; i >= a; i--)
#define IOS ios::sync_with_stdio(false)
#define DEBUG cout << endl << "DEBUG" << endl;
using namespace std;
typedef long long LL;
typedef unsigned long long ULL;
const int prime = 999983;
const int INF = 0x7FFFFFFF;
const LL INFF = 0x7FFFFFFFFFFFFFFF;
const double pi = acos(-1.0);
const double inf = 1e18;
const double eps = 1e-6;
const LL mod = 1e9 + 7;
LL qpow(LL a, LL b) {
LL s = 1;
while (b > 0) {
if (b & 1)
s = s * a % mod;
a = a * a % mod;
b >>= 1;
}
return s;
}
LL gcd(LL a, LL b) { return b ? gcd(b, a % b) : a; }
int dr[2][4] = {1, -1, 0, 0, 0, 0, -1, 1};
typedef pair<int, int> P;
const int maxn = 2000 + 10;
int fac[maxn], invfac[maxn];
void init() {
int n = maxn - 1;
fac[0] = 1;
for (int i = 1; i <= n; ++i)
fac[i] = 1ll * fac[i - 1] * i % mod;
invfac[n] = qpow(fac[n], mod - 2);
for (int i = n - 1; i >= 0; --i) {
invfac[i] = 1ll * invfac[i + 1] * (i + 1) % mod;
}
}
LL C(int n, int m) {
if (n < m)
return 0;
return 1ll * fac[n] * invfac[m] % mod * invfac[n - m] % mod;
}
int main(void) {
init();
int N, K;
cin >> N >> K;
for (int i = 1; i <= K; ++i) {
cout << C(K - 1, i - 1) * C(N - K + 1, i) << endl;
}
return 0;
} |
#include <bits/stdc++.h>
#define mem(ar, num) memset(ar, num, sizeof(ar))
#define me(ar) memset(ar, 0, sizeof(ar))
#define lowbit(x) (x & (-x))
#define Pb push_back
#define FI first
#define SE second
#define rep(i, a, n) for (int i = a; i < n; i++)
#define per(i, a, n) for (int i = n - 1; i >= a; i--)
#define IOS ios::sync_with_stdio(false)
#define DEBUG cout << endl << "DEBUG" << endl;
using namespace std;
typedef long long LL;
typedef unsigned long long ULL;
const int prime = 999983;
const int INF = 0x7FFFFFFF;
const LL INFF = 0x7FFFFFFFFFFFFFFF;
const double pi = acos(-1.0);
const double inf = 1e18;
const double eps = 1e-6;
const LL mod = 1e9 + 7;
LL qpow(LL a, LL b) {
LL s = 1;
while (b > 0) {
if (b & 1)
s = s * a % mod;
a = a * a % mod;
b >>= 1;
}
return s;
}
LL gcd(LL a, LL b) { return b ? gcd(b, a % b) : a; }
int dr[2][4] = {1, -1, 0, 0, 0, 0, -1, 1};
typedef pair<int, int> P;
const int maxn = 2000 + 10;
int fac[maxn], invfac[maxn];
void init() {
int n = maxn - 1;
fac[0] = 1;
for (int i = 1; i <= n; ++i)
fac[i] = 1ll * fac[i - 1] * i % mod;
invfac[n] = qpow(fac[n], mod - 2);
for (int i = n - 1; i >= 0; --i) {
invfac[i] = 1ll * invfac[i + 1] * (i + 1) % mod;
}
}
LL C(int n, int m) {
if (n < m)
return 0;
return 1ll * fac[n] * invfac[m] % mod * invfac[n - m] % mod;
}
int main(void) {
init();
int N, K;
cin >> N >> K;
for (int i = 1; i <= K; ++i) {
cout << C(K - 1, i - 1) * C(N - K + 1, i) % mod << endl;
}
return 0;
} | [
"expression.operation.binary.add"
] | 798,270 | 798,271 | u592068888 | cpp |
p02990 | #include <iostream>
using namespace std;
using ll = long long;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define IN(v) \
if (scanf("%d", &v) < 1) \
;
const int MOD = 1e9 + 7;
const int MAX = 2001;
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 comb(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
int main() {
int N, K;
IN(N);
IN(K);
COMinit();
int red = N - K, blue = K;
FOR(i, 1, K + 1) {
printf("%d\n",
(int)(comb(red + 1, i) * comb((blue - i) + (i - 1), i - 1)) % MOD);
}
return 0;
}
| #include <iostream>
using namespace std;
using ll = long long;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define IN(v) \
if (scanf("%d", &v) < 1) \
;
const int MOD = 1e9 + 7;
const int MAX = 2001;
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 comb(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
int main() {
int N, K;
IN(N);
IN(K);
COMinit();
int red = N - K, blue = K;
FOR(i, 1, K + 1) {
printf("%d\n",
(int)((comb(red + 1, i) * comb((blue - i) + (i - 1), i - 1)) % MOD));
}
return 0;
}
| [
"call.arguments.change"
] | 798,276 | 798,277 | u025592199 | cpp |
p02990 | #include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
int fact[10004];
inline int mul(int a, int b) {
long long ret = 1ll * a * b;
return ret % mod;
}
inline int power(int a, int p) {
if (p == 0)
return 1;
int ret = power(a, p / 2);
ret = mul(ret, ret);
if (p % 2)
ret = mul(ret, a);
return ret;
}
inline int divide(int a, int b) { return mul(a, power(b, mod - 2)); }
inline int comb(int n, int r) {
return divide(fact[n], mul(fact[n - r], fact[r]));
}
int main() {
fact[0] = 1;
for (int i = 1; i <= 10000; i++)
fact[i] = mul(fact[i - 1], i);
int n, k;
cin >> n >> k;
int slot = n - k + 1;
for (int i = 1; i <= k; i++) {
if (slot < i) {
cout << "0\n";
continue;
}
cout << mul(comb(slot, i), power(i, k - i)) << '\n';
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
int fact[10004];
inline int mul(int a, int b) {
long long ret = 1ll * a * b;
return ret % mod;
}
inline int power(int a, int p) {
if (p == 0)
return 1;
int ret = power(a, p / 2);
ret = mul(ret, ret);
if (p % 2)
ret = mul(ret, a);
return ret;
}
inline int divide(int a, int b) { return mul(a, power(b, mod - 2)); }
inline int comb(int n, int r) {
return divide(fact[n], mul(fact[n - r], fact[r]));
}
int main() {
fact[0] = 1;
for (int i = 1; i <= 10000; i++)
fact[i] = mul(fact[i - 1], i);
int n, k;
cin >> n >> k;
int slot = n - k + 1;
for (int i = 1; i <= k; i++) {
if (slot < i) {
cout << "0\n";
continue;
}
cout << mul(comb(slot, i), comb(k - 1, k - i)) << '\n';
}
return 0;
} | [
"identifier.change",
"call.function.change",
"io.output.change"
] | 798,280 | 798,281 | u541786453 | cpp |
p02990 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int N = 2005, mod = 1000000007;
int c[2005][2005];
int main() {
// cout << "hell0" << endl;
int n, k;
c[0][0] = 1;
for (int i = 1; i < 2005; i++) {
for (int j = 0; j <= i; j++) {
if (j == i or j == 0)
c[i][j] = 1;
else
c[i][j] = c[i - 1][j] + c[i - 1][j - 1];
c[i][j] %= mod;
}
}
// cout << "yep" << endl;
/* for(int i = 1 ; i < 10 ; i++){
for(int j = 0 ; j <= i ;j++){
cout << c[i][j] << " ";
}
cout << endl;
}*/
cin >> n >> k;
int red = n - k, blue = k, ans = 0;
for (int i = 1; i <= blue; i++) {
ans = (c[red + 1][i] * c[blue - 1][i - 1]) % mod;
cout << ans << endl;
}
// cout << "end" << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int N = 2005, mod = 1000000007;
int c[2005][2005];
int main() {
// cout << "hell0" << endl;
int n, k;
c[0][0] = 1;
for (int i = 1; i < 2005; i++) {
for (int j = 0; j <= i; j++) {
if (j == i or j == 0)
c[i][j] = 1;
else
c[i][j] = c[i - 1][j] + c[i - 1][j - 1];
c[i][j] %= mod;
}
}
// cout << "yep" << endl;
/* for(int i = 1 ; i < 10 ; i++){
for(int j = 0 ; j <= i ;j++){
cout << c[i][j] << " ";
}
cout << endl;
}*/
cin >> n >> k;
int red = n - k, blue = k, ans = 0;
for (int i = 1; i <= blue; i++) {
ans = (1LL * c[red + 1][i] * c[blue - 1][i - 1]) % mod;
cout << ans << endl;
}
// cout << "end" << endl;
return 0;
} | [
"assignment.change"
] | 798,282 | 798,283 | u708590262 | cpp |
p02990 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int64_t mod = 1E9 + 7;
vector<vector<int64_t>> cont(n + 1, vector<int64_t>(n + 1));
cont.at(1).at(1) = 1;
for (int i = 1; i < n; i++) {
cont.at(i).at(0) = 1;
}
for (int i = 2; i <= n; i++) {
for (int j = 1; j <= k; j++) {
cont.at(i).at(j) =
cont.at(i - 1).at(j) % mod + cont.at(i - 1).at(j - 1) % mod;
}
}
for (int i = 1; i <= k; i++) {
if (n - k + 1 < i) {
cout << 0 << endl;
} else {
int64_t a = cont.at(n - k + 1).at(i) % mod;
int64_t b = cont.at(k - 1).at(i - 1) % mod;
cout << a * b % mod << endl;
}
}
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int64_t mod = 1E9 + 7;
vector<vector<int64_t>> cont(n + 1, vector<int64_t>(n + 1));
cont.at(1).at(1) = 1;
for (int i = 0; i <= n; i++) {
cont.at(i).at(0) = 1;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= i; j++) {
cont.at(i).at(j) =
cont.at(i - 1).at(j) % mod + cont.at(i - 1).at(j - 1) % mod;
}
}
for (int i = 1; i <= k; i++) {
if (n - k + 1 < i) {
cout << 0 << endl;
} else {
int64_t a = cont.at(n - k + 1).at(i) % mod;
int64_t b = cont.at(k - 1).at(i - 1) % mod;
cout << a * b % mod << endl;
}
}
} | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"identifier.change"
] | 798,288 | 798,287 | u408053928 | cpp |
p02990 | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define pie 3.141592653589793238462643383279
#define int long long
#define mod 1000000007
#define INF 1145141919364364
#define all(vec) vec.begin(), vec.end()
#define P pair<int, int>
#define S second
#define F first
int gcd(int x, int y) {
if (y == 0)
return x;
return gcd(y, x % y);
}
int lcm(int x, int y) { return x / gcd(x, y) * y; }
bool prime(int x) {
for (int i = 2; i <= sqrt(x); i++) {
if (x % i == 0)
return false;
}
return true;
}
int kai(int x) {
if (x == 0)
return 1;
return kai(x - 1) * x % mod;
}
int mod_pow(int x, int y, int mood) {
int res = 1;
while (y > 0) {
if (y & 1)
res = res * x % mood;
x = x * x % mood;
y >>= 1;
}
return res;
}
int comb(int x, int y) {
return kai(x) * mod_pow(kai(x - y), mod - 2, mod) % mod *
mod_pow(kai(y), mod - 2, mod) % mod;
}
int n, k;
signed main() {
cin >> n >> k;
for (int i = 1; i <= k; i++) {
if (n - k + 1 < i)
cout << 1 << endl;
else
cout << comb(n - k + 1, i) * comb(k - 1, i - 1) % mod << endl;
}
} | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define pie 3.141592653589793238462643383279
#define int long long
#define mod 1000000007
#define INF 1145141919364364
#define all(vec) vec.begin(), vec.end()
#define P pair<int, int>
#define S second
#define F first
int gcd(int x, int y) {
if (y == 0)
return x;
return gcd(y, x % y);
}
int lcm(int x, int y) { return x / gcd(x, y) * y; }
bool prime(int x) {
for (int i = 2; i <= sqrt(x); i++) {
if (x % i == 0)
return false;
}
return true;
}
int kai(int x) {
if (x == 0)
return 1;
return kai(x - 1) * x % mod;
}
int mod_pow(int x, int y, int mood) {
int res = 1;
while (y > 0) {
if (y & 1)
res = res * x % mood;
x = x * x % mood;
y >>= 1;
}
return res;
}
int comb(int x, int y) {
return kai(x) * mod_pow(kai(x - y), mod - 2, mod) % mod *
mod_pow(kai(y), mod - 2, mod) % mod;
}
int n, k;
signed main() {
cin >> n >> k;
for (int i = 1; i <= k; i++) {
if (n - k + 1 < i)
cout << 0 << endl;
else
cout << comb(n - k + 1, i) * comb(k - 1, i - 1) % mod << endl;
}
} | [
"literal.number.change",
"io.output.change"
] | 798,291 | 798,292 | u277153875 | cpp |
p02990 | #include <bits/stdc++.h>
using namespace std;
const int infI = 1e9 + 5;
const long long infL = 1e18;
const int MOD = 1e9 + 7;
const int MAX = 1e5 + 5;
#define mp make_pair
#define pb push_back
#define ii pair<int, int>
#define iii pair<ii, int>
#define ll long long
#define pll pair<ll, ll>
#define vl vector<vector<ll>>
#define vi vector<vector<int>>
#define eb emplace_back
#define forn(i, a, b) for (int i = a; i < b; i++)
#define fastio \
ios_base::sync_with_stdio(0); \
cin.tie(0)
#define endl '\n'
#define popb pop_back();
#define se second
#define fi first
int dp[2001][2001];
int main() {
int n, k;
ll ans = 0;
cin >> n >> k;
forn(i, 0, n + 1) { dp[i][0] = dp[i][i] = 1; }
forn(i, 1, n + 1) {
forn(j, 1, i + 1) { dp[i][j] = (dp[i - 1][j] + dp[i - 1][j - 1]) % MOD; }
}
forn(i, 1, k + 1) {
ans = dp[k - 1][i - 1] *
dp[n - k + 1][i]; // we need non empty partitions for k balls,
// therefore, we have k-1 positions
// for i-1 partitions, then we have n-k+1 positions to place these i
// partitions.
ans %= MOD;
cout << ans << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
const int infI = 1e9 + 5;
const long long infL = 1e18;
const int MOD = 1e9 + 7;
const int MAX = 1e5 + 5;
#define mp make_pair
#define pb push_back
#define ii pair<int, int>
#define iii pair<ii, int>
#define ll long long
#define pll pair<ll, ll>
#define vl vector<vector<ll>>
#define vi vector<vector<int>>
#define eb emplace_back
#define forn(i, a, b) for (int i = a; i < b; i++)
#define fastio \
ios_base::sync_with_stdio(0); \
cin.tie(0)
#define endl '\n'
#define popb pop_back();
#define se second
#define fi first
ll dp[2001][2001];
int main() {
int n, k;
ll ans = 0;
cin >> n >> k;
forn(i, 0, n + 1) { dp[i][0] = dp[i][i] = 1; }
forn(i, 1, n + 1) {
forn(j, 1, i + 1) { dp[i][j] = (dp[i - 1][j] + dp[i - 1][j - 1]) % MOD; }
}
forn(i, 1, k + 1) {
ans = dp[k - 1][i - 1] *
dp[n - k + 1][i]; // we need non empty partitions for k balls,
// therefore, we have k-1 positions
// for i-1 partitions, then we have n-k+1 positions to place these i
// partitions.
ans %= MOD;
cout << ans << endl;
}
return 0;
} | [
"variable_declaration.type.change"
] | 798,303 | 798,304 | u416354178 | cpp |
p02990 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll MOD = 1e9 + 7;
ll C[2100][2100];
int main() {
int N, K;
cin >> N >> K;
for (int i = 0; i < N; i++) {
for (int j = 0; j <= i; j++) {
if (j == 0)
C[i][j] = 1;
else
C[i][j] = C[i - 1][j] + C[i - 1][j - 1];
C[i][j] %= MOD;
}
}
for (int i = 1; i <= K; i++) {
cout << C[N - K + 1][i] * C[K - 1][i - 1] % MOD << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll MOD = 1e9 + 7;
ll C[2100][2100];
int main() {
int N, K;
cin >> N >> K;
for (int i = 0; i <= N; i++) {
for (int j = 0; j <= i; j++) {
if (j == 0)
C[i][j] = 1;
else
C[i][j] = C[i - 1][j] + C[i - 1][j - 1];
C[i][j] %= MOD;
}
}
for (int i = 1; i <= K; i++) {
cout << C[N - K + 1][i] * C[K - 1][i - 1] % MOD << endl;
}
return 0;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 798,305 | 798,306 | u146779775 | cpp |
p02990 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll MOD = 1e9 + 7;
ll C[2001][2001];
int main() {
int N, K;
cin >> N >> K;
for (int i = 0; i < N; i++) {
for (int j = 0; j <= i; j++) {
if (j == 0)
C[i][j] = 1;
else
C[i][j] = C[i - 1][j] + C[i - 1][j - 1];
C[i][j] %= MOD;
}
}
for (int i = 1; i <= K; i++) {
cout << C[N - K + 1][i] * C[K - 1][i - 1] % MOD << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll MOD = 1e9 + 7;
ll C[2100][2100];
int main() {
int N, K;
cin >> N >> K;
for (int i = 0; i <= N; i++) {
for (int j = 0; j <= i; j++) {
if (j == 0)
C[i][j] = 1;
else
C[i][j] = C[i - 1][j] + C[i - 1][j - 1];
C[i][j] %= MOD;
}
}
for (int i = 1; i <= K; i++) {
cout << C[N - K + 1][i] * C[K - 1][i - 1] % MOD << endl;
}
return 0;
} | [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 798,307 | 798,306 | u146779775 | cpp |
p02990 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)n; i++)
#define all(c) (c).begin(), (c).end()
#define pb push_back
#define dbg(...) \
do { \
cerr << __LINE__ << ": "; \
dbgprint(#__VA_ARGS__, __VA_ARGS__); \
} while (0);
using namespace std;
namespace std {
template <class S, class T> struct hash<pair<S, T>> {
size_t operator()(const pair<S, T> &p) const {
return ((size_t)1e9 + 7) * hash<S>()(p.first) + hash<T>()(p.second);
}
};
template <class T> struct hash<vector<T>> {
size_t operator()(const vector<T> &v) const {
size_t h = 0;
for (auto i : v)
h = h * ((size_t)1e9 + 7) + hash<T>()(i) + 1;
return h;
}
};
} // namespace std
template <class T> ostream &operator<<(ostream &os, const vector<T> &v) {
os << "[ ";
rep(i, v.size()) os << v[i] << (i == v.size() - 1 ? " ]" : ", ");
return os;
}
template <class T> ostream &operator<<(ostream &os, const set<T> &v) {
os << "{ ";
for (const auto &i : v)
os << i << ", ";
return os << "}";
}
template <class T, class U>
ostream &operator<<(ostream &os, const map<T, U> &v) {
os << "{";
for (const auto &i : v)
os << " " << i.first << ": " << i.second << ",";
return os << "}";
}
template <class T, class U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
return os << "(" << p.first << ", " << p.second << ")";
}
void dbgprint(const string &fmt) { cerr << endl; }
template <class H, class... T>
void dbgprint(const string &fmt, const H &h, const T &...r) {
cerr << fmt.substr(0, fmt.find(",")) << "= " << h << " ";
dbgprint(fmt.substr(fmt.find(",") + 1), r...);
}
typedef long long ll;
typedef vector<int> vi;
typedef pair<int, int> pi;
const int inf = (int)1e9;
const double INF = 1e12, EPS = 1e-9;
const int mod = 1e9 + 7;
const int MX = 10000;
ll inv[MX], f[MX], invf[MX];
void calc() {
inv[0] = inv[1] = f[0] = f[1] = invf[0] = invf[1] = 1;
for (int i = 2; i < MX; i++) {
inv[i] = mod - mod / i * inv[mod % i] % mod;
f[i] = f[i - 1] * i % mod;
invf[i] = invf[i - 1] * inv[i] % mod;
}
}
inline ll C(ll n, ll k) {
if (k < 0 || n < k)
return 0;
return f[n] * invf[k] % mod * invf[n - k] % mod;
}
int main() {
cin.tie(0);
cin.sync_with_stdio(0);
calc();
int n, k;
cin >> n >> k;
for (int i = 1; i <= k; i++) {
ll ans = 0;
// B - R - B
ans += C(k - 1, i - 1) * C(n - k - 1, i - 2) % mod;
// B - R or R - B
ans += C(k - 1, i - 1) * C(n - k - 1, i - 1) * 2 % mod;
// R - B - R
ans += C(k - 1, i - 1) * C(n - k - 1, i) % mod;
if (n == k && i == 1)
ans++;
cout << ans << endl;
}
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)n; i++)
#define all(c) (c).begin(), (c).end()
#define pb push_back
#define dbg(...) \
do { \
cerr << __LINE__ << ": "; \
dbgprint(#__VA_ARGS__, __VA_ARGS__); \
} while (0);
using namespace std;
namespace std {
template <class S, class T> struct hash<pair<S, T>> {
size_t operator()(const pair<S, T> &p) const {
return ((size_t)1e9 + 7) * hash<S>()(p.first) + hash<T>()(p.second);
}
};
template <class T> struct hash<vector<T>> {
size_t operator()(const vector<T> &v) const {
size_t h = 0;
for (auto i : v)
h = h * ((size_t)1e9 + 7) + hash<T>()(i) + 1;
return h;
}
};
} // namespace std
template <class T> ostream &operator<<(ostream &os, const vector<T> &v) {
os << "[ ";
rep(i, v.size()) os << v[i] << (i == v.size() - 1 ? " ]" : ", ");
return os;
}
template <class T> ostream &operator<<(ostream &os, const set<T> &v) {
os << "{ ";
for (const auto &i : v)
os << i << ", ";
return os << "}";
}
template <class T, class U>
ostream &operator<<(ostream &os, const map<T, U> &v) {
os << "{";
for (const auto &i : v)
os << " " << i.first << ": " << i.second << ",";
return os << "}";
}
template <class T, class U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
return os << "(" << p.first << ", " << p.second << ")";
}
void dbgprint(const string &fmt) { cerr << endl; }
template <class H, class... T>
void dbgprint(const string &fmt, const H &h, const T &...r) {
cerr << fmt.substr(0, fmt.find(",")) << "= " << h << " ";
dbgprint(fmt.substr(fmt.find(",") + 1), r...);
}
typedef long long ll;
typedef vector<int> vi;
typedef pair<int, int> pi;
const int inf = (int)1e9;
const double INF = 1e12, EPS = 1e-9;
const int mod = 1e9 + 7;
const int MX = 10000;
ll inv[MX], f[MX], invf[MX];
void calc() {
inv[0] = inv[1] = f[0] = f[1] = invf[0] = invf[1] = 1;
for (int i = 2; i < MX; i++) {
inv[i] = mod - mod / i * inv[mod % i] % mod;
f[i] = f[i - 1] * i % mod;
invf[i] = invf[i - 1] * inv[i] % mod;
}
}
inline ll C(ll n, ll k) {
if (k < 0 || n < k)
return 0;
return f[n] * invf[k] % mod * invf[n - k] % mod;
}
int main() {
cin.tie(0);
cin.sync_with_stdio(0);
calc();
int n, k;
cin >> n >> k;
for (int i = 1; i <= k; i++) {
ll ans = 0;
// B - R - B
ans += C(k - 1, i - 1) * C(n - k - 1, i - 2) % mod;
// B - R or R - B
ans += C(k - 1, i - 1) * C(n - k - 1, i - 1) * 2 % mod;
// R - B - R
ans += C(k - 1, i - 1) * C(n - k - 1, i) % mod;
if (n == k && i == 1)
ans++;
cout << ans % mod << endl;
}
return 0;
} | [
"expression.operation.binary.add"
] | 798,313 | 798,314 | u525288965 | cpp |
p02990 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
// freopen("in.txt", "r",stdin);
int N, K;
cin >> N >> K;
const int modulo = 1e9 + 7;
int M = max(K, N - K);
vector<vector<int>> C(N + 1, vector<int>(M + 1));
for (int i = 0; i <= N; ++i) {
for (int j = 0; j <= min(M, i); ++j) {
if (i == j || j == 0)
C[i][j] = 1;
else if (j == 1)
C[i][j] = (ll)i;
else {
C[i][j] = C[i - 1][j - 1] + C[i - 1][j];
C[i][j] %= modulo;
}
}
}
int B = K, R = N - K;
for (int i = 1; i <= K; ++i) {
ll ans = C[B - 1][i - 1] * C[R + 1][i];
ans %= modulo;
cout << ans << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
// freopen("in.txt", "r",stdin);
int N, K;
cin >> N >> K;
const int modulo = 1e9 + 7;
int M = max(K, N - K);
vector<vector<ll>> C(N + 1, vector<ll>(M + 1));
for (int i = 0; i <= N; ++i) {
for (int j = 0; j <= min(M, i); ++j) {
if (i == j || j == 0)
C[i][j] = 1;
else if (j == 1)
C[i][j] = (ll)i;
else {
C[i][j] = C[i - 1][j - 1] + C[i - 1][j];
C[i][j] %= modulo;
}
}
}
int B = K, R = N - K;
for (int i = 1; i <= K; ++i) {
ll ans = C[B - 1][i - 1] * C[R + 1][i];
ans %= modulo;
cout << ans << endl;
}
return 0;
} | [
"call.arguments.change"
] | 798,315 | 798,316 | u781659997 | cpp |
p02990 | #pragma GCC optimize("O3")
#include <bits/stdc++.h>
using namespace std;
uint64_t n, k, ndiv = 1000000007;
uint64_t pt[2001][2001];
int main(void) {
uint64_t i, j, x, y;
cin >> n >> k;
pt[0][0] = 1;
for (i = 1; i <= 2000; i++) {
for (j = 0; j <= i; j++) {
if (j == 0 || j == i) {
pt[i][j] = 1;
continue;
}
pt[i][j] = (pt[i - 1][j - 1] + pt[i - 1][j]) % ndiv;
}
}
for (i = 1; i <= k; i++) {
x = pt[n - k + 1][i];
y = pt[k - 1][i - 1];
cout << x * y << endl;
}
return 0;
}
| #pragma GCC optimize("O3")
#include <bits/stdc++.h>
using namespace std;
uint64_t n, k, ndiv = 1000000007;
uint64_t pt[2001][2001];
int main(void) {
uint64_t i, j, x, y;
cin >> n >> k;
pt[0][0] = 1;
for (i = 1; i <= 2000; i++) {
for (j = 0; j <= i; j++) {
if (j == 0 || j == i) {
pt[i][j] = 1;
continue;
}
pt[i][j] = (pt[i - 1][j - 1] + pt[i - 1][j]) % ndiv;
}
}
for (i = 1; i <= k; i++) {
x = pt[n - k + 1][i];
y = pt[k - 1][i - 1];
cout << x * y % ndiv << endl;
}
return 0;
}
| [
"expression.operation.binary.add"
] | 798,319 | 798,320 | u940654002 | cpp |
p02990 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll MOD = 1e9 + 7;
const int N = 2005;
ll n, k, fac[N], inv[N];
ll bpow(ll a, ll b) {
ll res = 1LL;
while (b) {
if (b & 1LL)
res *= a;
a *= a;
b >>= 1LL;
if (a >= MOD)
a %= MOD;
if (res >= MOD)
res %= MOD;
}
return res;
}
void calc() {
fac[0] = 1LL;
for (int i = 1; i <= 2000; i++) {
fac[i] = fac[i - 1] * 1LL * i % MOD;
}
for (int i = 0; i <= 2000; i++) {
inv[i] = bpow(fac[i], MOD - 2);
}
}
ll nCr(ll a, ll b) {
if (a < b || b < 0)
return 0;
return fac[a] * inv[b] % MOD * inv[a - b] % MOD;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
calc();
cin >> n >> k;
for (int i = 1; i <= k; i++) {
cout << nCr(k - 1, i - 1) * nCr(n - k + 1, i) << "\n";
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll MOD = 1e9 + 7;
const int N = 2005;
ll n, k, fac[N], inv[N];
ll bpow(ll a, ll b) {
ll res = 1LL;
while (b) {
if (b & 1LL)
res *= a;
a *= a;
b >>= 1LL;
if (a >= MOD)
a %= MOD;
if (res >= MOD)
res %= MOD;
}
return res;
}
void calc() {
fac[0] = 1LL;
for (int i = 1; i <= 2000; i++) {
fac[i] = fac[i - 1] * 1LL * i % MOD;
}
for (int i = 0; i <= 2000; i++) {
inv[i] = bpow(fac[i], MOD - 2);
}
}
ll nCr(ll a, ll b) {
if (a < b || b < 0)
return 0;
return fac[a] * inv[b] % MOD * inv[a - b] % MOD;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
calc();
cin >> n >> k;
for (int i = 1; i <= k; i++) {
cout << nCr(k - 1, i - 1) * nCr(n - k + 1, i) % MOD << "\n";
}
return 0;
}
| [
"expression.operation.binary.add"
] | 798,321 | 798,322 | u891061025 | cpp |
p02990 | // list(map(int, input().rstrip().split()))
//' '.join(map(str, res))
#include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <stack>
#include <stdio.h> //per fare input output con scanf and printf
#include <stdlib.h> //per fare qsort e bsearch
#include <string.h> // per fare strcpy(sarrivo, spartenza) strcat(str, aggiungo) strcmp(a,b) che da 0 se sono uguali
#include <vector>
using namespace std;
#define ld long double
#define ll long long int
#define vi vector<ll>
#define pi pair<int, int>
#define binary(v, el) binary_search((v).begin(), (v).end(), (el))
#define PB push_back
#define MP make_pair
#define MT make_tuple
#define G(n, t) get<(n)>((t)) // get element of a tuple
#define F first
#define S second
#define input(type, n) \
type n; \
cin >> n
#define FORN(n) for (ll i = 0; i < (n); i++)
#define print(x) cout << x << endl
#include <iomanip> // std::setprecision
/*struct missione {
int s;
int g;
};
missione v[1000000];
bool Ordina (missione a, missione b) {
return a.s < b.s;
}*/
ll powermodp(ll x, ll y, ll p) {
// x^y mod p
if (y == 0)
return 1;
ll a = powermodp(x, y / 2, p) % p;
a = (a * a) % p;
if (y % 2)
return (a * x) % p;
return a;
}
ll inverse(ll a, ll p) {
if (a % p == 0)
return 0;
else
return powermodp(a, p - 2, p);
}
ll fatt(ll n, ll p) {
ll res = 1;
for (ll i = 1; i < n + 1; ++i) {
res *= i;
res = res % p;
}
return res;
}
ll bin(ll n, ll k, ll p) {
ll res = (fatt(n, p) % p) * inverse((fatt(n - k, p) * fatt(k, p)), p);
res = res % p;
return res;
}
int main() {
ll N, K;
cin >> N >> K;
ll p = 1000000007;
for (ll i = 1; i < K + 1; ++i) {
if (N - K - (i - 1) >= 0) {
ll res = (bin(K - 1, i - 1, p) % p) * (bin(N - K + 1, i, p) % p);
res = res % p;
if (res < 0) {
res = p - res;
}
cout << res << endl;
} else {
cout << 0 << endl;
}
}
} | // list(map(int, input().rstrip().split()))
//' '.join(map(str, res))
#include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <stack>
#include <stdio.h> //per fare input output con scanf and printf
#include <stdlib.h> //per fare qsort e bsearch
#include <string.h> // per fare strcpy(sarrivo, spartenza) strcat(str, aggiungo) strcmp(a,b) che da 0 se sono uguali
#include <vector>
using namespace std;
#define ld long double
#define ll long long int
#define vi vector<ll>
#define pi pair<int, int>
#define binary(v, el) binary_search((v).begin(), (v).end(), (el))
#define PB push_back
#define MP make_pair
#define MT make_tuple
#define G(n, t) get<(n)>((t)) // get element of a tuple
#define F first
#define S second
#define input(type, n) \
type n; \
cin >> n
#define FORN(n) for (ll i = 0; i < (n); i++)
#define print(x) cout << x << endl
#include <iomanip> // std::setprecision
/*struct missione {
int s;
int g;
};
missione v[1000000];
bool Ordina (missione a, missione b) {
return a.s < b.s;
}*/
ll powermodp(ll x, ll y, ll p) {
// x^y mod p
if (y == 0)
return 1;
ll a = powermodp(x, y / 2, p) % p;
a = (a * a) % p;
if (y % 2)
return (a * x) % p;
return a;
}
ll inverse(ll a, ll p) {
if (a % p == 0)
return 0;
else
return powermodp(a, p - 2, p);
}
ll fatt(ll n, ll p) {
ll res = 1;
for (ll i = 1; i < n + 1; ++i) {
res *= i;
res = res % p;
}
return res;
}
ll bin(ll n, ll k, ll p) {
ll res = (fatt(n, p) % p) * inverse((fatt(n - k, p) * fatt(k, p)) % p, p);
res = res % p;
return res;
}
int main() {
ll N, K;
cin >> N >> K;
ll p = 1000000007;
for (ll i = 1; i < K + 1; ++i) {
if (N - K - (i - 1) >= 0) {
ll res = (bin(K - 1, i - 1, p) % p) * (bin(N - K + 1, i, p) % p);
res = res % p;
if (res < 0) {
res = p - res;
}
cout << res << endl;
} else {
cout << 0 << endl;
}
}
} | [
"assignment.change"
] | 798,323 | 798,324 | u044976777 | cpp |
p02990 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
const int MAX = 510000;
const int MOD = 1000000007;
typedef long long ll;
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;
for (int i = 1; i <= K; i++) {
cout << (COM(K - 1, i - 1) * COM(N - K + 1, i)) % MOD << endl;
}
return 0;
}
| #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
const int MAX = 510000;
const int MOD = 1000000007;
typedef long long ll;
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;
}
return 0;
}
| [
"call.add"
] | 798,325 | 798,326 | u904123392 | cpp |
p02990 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
const int MAX = 510000;
const int MOD = 1000000007;
typedef long long ll;
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;
for (int i = 1; i <= K; i++) {
cout << (COM(K - 1, i - 1) * COM(N - K, i)) % MOD << endl;
}
return 0;
}
| #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
const int MAX = 510000;
const int MOD = 1000000007;
typedef long long ll;
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;
}
return 0;
}
| [
"call.add",
"expression.operation.binary.add"
] | 798,327 | 798,326 | u904123392 | cpp |
p02990 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
const int MAX = 510000;
const int MOD = 1000000007;
typedef long long ll;
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;
for (int i = 1; i <= K; i++) {
cout << (COM(K - 1, i - 1) * COM(N - K + 1, i)) % MOD << endl;
}
return 0;
}
| #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
const int MAX = 510000;
const int MOD = 1000000007;
typedef long long ll;
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;
}
return 0;
} | [
"call.add"
] | 798,325 | 798,328 | u904123392 | cpp |
p02990 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
const int MAX = 510000;
const int MOD = 1000000007;
typedef long long ll;
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;
for (int i = 1; i <= K; i++) {
cout << (COM(K - 1, i - 1) * COM(N - K, i)) % MOD << endl;
}
return 0;
}
| #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
const int MAX = 510000;
const int MOD = 1000000007;
typedef long long ll;
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;
}
return 0;
} | [
"call.add",
"expression.operation.binary.add"
] | 798,327 | 798,328 | u904123392 | cpp |
p02990 | #define _USE_MATH_DEFINES
#include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
const int dx[] = {1, 0, -1, 0, 0};
const int dy[] = {0, 1, 0, -1, 0};
const int MAX_N = 2010;
ll fact[MAX_N], finv[MAX_N], inv[MAX_N];
void init_combination(ll p) {
fact[0] = fact[1] = finv[0] = finv[1] = inv[1] = 1;
for (int i = 2; i < MAX_N; ++i) {
inv[i] = inv[p % i] * (p - p / i) % p;
fact[i] = fact[i - 1] * i % p;
finv[i] = finv[i - 1] * inv[i] % p;
}
}
ll comb(int n, int k, ll p) {
if (n < k || n < 0 || k < 0)
return 0;
return fact[n] * (finv[k] * finv[n - k] % p) % p;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
ll n, k, p = (ll)1e9 + 7;
cin >> n >> k;
init_combination(p);
for (ll i = 1; i <= k; ++i) {
cout << comb(k - 1, i - 1, p) * comb(n - k + 1, i, p) << "\n";
}
} | #define _USE_MATH_DEFINES
#include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
const int dx[] = {1, 0, -1, 0, 0};
const int dy[] = {0, 1, 0, -1, 0};
const int MAX_N = 2010;
ll fact[MAX_N], finv[MAX_N], inv[MAX_N];
void init_combination(ll p) {
fact[0] = fact[1] = finv[0] = finv[1] = inv[1] = 1;
for (int i = 2; i < MAX_N; ++i) {
inv[i] = inv[p % i] * (p - p / i) % p;
fact[i] = fact[i - 1] * i % p;
finv[i] = finv[i - 1] * inv[i] % p;
}
}
ll comb(int n, int k, ll p) {
if (n < k || n < 0 || k < 0)
return 0;
return fact[n] * (finv[k] * finv[n - k] % p) % p;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
ll n, k, p = (ll)1e9 + 7;
cin >> n >> k;
init_combination(p);
for (ll i = 1; i <= k; ++i) {
cout << comb(k - 1, i - 1, p) * comb(n - k + 1, i, p) % p << "\n";
}
} | [
"expression.operation.binary.add"
] | 798,334 | 798,335 | u456333842 | cpp |
p02990 | #include <bits/stdc++.h>
using namespace std;
#define MOD (1000000007)
int C[2015][2015];
void pascal() {
// パスカルの三角形。 2010まで埋める
C[0][0] = 1;
for (int i = 1; i < 2010; i++) {
C[i][0] = 1;
for (int j = 1; j < i; j++) {
C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % MOD;
}
C[i][i] = 1;
}
}
int main() {
pascal();
int N;
int K;
cin >> N >> K;
int res;
for (int i = 1; i <= K; i++) {
// Kの塊がi個になるパターン
// N-Kの隙間(+1)にKの塊を差し込む
// C(N-K+1, i) = (N-K+1)!/(i!(N-K+1-i)!)
// Kをi個の塊に分割したそれぞれの個数パターン
// Kの隙間(-1)に区切りを差し込む
// C(K-1, i-1) = (K-1)!/((i-1)!(K-i)!)
res = C[N - K + 1][i] * C[K - 1][i - 1] % MOD;
cout << res << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define MOD (1000000007)
int64_t C[2015][2015];
void pascal() {
// パスカルの三角形。 2010まで埋める
C[0][0] = 1;
for (int i = 1; i < 2010; i++) {
C[i][0] = 1;
for (int j = 1; j < i; j++) {
C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % MOD;
}
C[i][i] = 1;
}
}
int main() {
pascal();
int N;
int K;
cin >> N >> K;
int64_t res;
for (int i = 1; i <= K; i++) {
// Kの塊がi個になるパターン
// N-Kの隙間(+1)にKの塊を差し込む
// C(N-K+1, i) = (N-K+1)!/(i!(N-K+1-i)!)
// Kをi個の塊に分割したそれぞれの個数パターン
// Kの隙間(-1)に区切りを差し込む
// C(K-1, i-1) = (K-1)!/((i-1)!(K-i)!)
res = C[N - K + 1][i] * C[K - 1][i - 1] % MOD;
cout << res << endl;
}
return 0;
} | [
"variable_declaration.type.primitive.change"
] | 798,340 | 798,341 | u557168336 | cpp |
p02990 | #include <bits/stdc++.h>
using namespace std;
const int sz = 2005;
long long c[sz][sz];
int n, k;
int r, b;
long long m = 1e9 + 7;
long long add(long long a, long long b) { return (a % m + b % m) % m; }
long long mul(long long a, long long b) { return (a % m * b % m) % m; }
int main() {
// freopen("in.txt","r",stdin);
// freopen("out.txt","w",stdout);
scanf("%d %d", &n, &k);
b = k;
r = n - k;
int av = r + 1;
for (int i = 0; i <= 2005; i++)
c[i][0] = c[i][i] = 1;
for (int i = 1; i <= 2005; i++) {
for (int j = 1; j <= i; j++)
c[i][j] = add(c[i - 1][j], c[i - 1][j - 1]);
}
for (int i = 1; i <= b; i++)
printf("%I64d\n", mul(c[av][i], c[b - 1][i - 1]));
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
const int sz = 2005;
long long c[sz][sz];
int n, k;
int r, b;
long long m = 1e9 + 7;
long long add(long long a, long long b) { return (a % m + b % m) % m; }
long long mul(long long a, long long b) { return (a % m * b % m) % m; }
int main() {
// freopen("in.txt","r",stdin);
// freopen("out.txt","w",stdout);
scanf("%d %d", &n, &k);
b = k;
r = n - k;
int av = r + 1;
for (int i = 0; i < sz; i++)
c[i][0] = c[i][i] = 1;
for (int i = 1; i < sz; i++) {
for (int j = 1; j <= i; j++)
c[i][j] = add(c[i - 1][j], c[i - 1][j - 1]);
}
for (int i = 1; i <= b; i++)
printf("%I64d\n", mul(c[av][i], c[b - 1][i - 1]));
return 0;
}
| [
"control_flow.loop.for.condition.change"
] | 798,342 | 798,343 | u353783395 | cpp |
p02990 | #include <bits/stdc++.h>
using namespace std;
const int sz = 2005;
long long c[sz][sz];
int n, k;
int r, b;
long long m = 1e9 + 7;
long long add(long long a, long long b) { return (a % m + b % m) % m; }
long long mul(long long a, long long b) { return (a % m * b % m) % m; }
int main() {
// freopen("in.txt","r",stdin);
// freopen("out.txt","w",stdout);
scanf("%d %d", &n, &k);
b = k;
r = n - k;
int av = r + 1;
for (int i = 0; i <= sz; i++)
c[i][0] = c[i][i] = 1;
for (int i = 1; i <= 2000; i++) {
for (int j = 1; j <= i; j++)
c[i][j] = add(c[i - 1][j], c[i - 1][j - 1]);
}
for (int i = 1; i <= b; i++)
printf("%I64d\n", mul(c[av][i], c[b - 1][i - 1]));
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
const int sz = 2005;
long long c[sz][sz];
int n, k;
int r, b;
long long m = 1e9 + 7;
long long add(long long a, long long b) { return (a % m + b % m) % m; }
long long mul(long long a, long long b) { return (a % m * b % m) % m; }
int main() {
// freopen("in.txt","r",stdin);
// freopen("out.txt","w",stdout);
scanf("%d %d", &n, &k);
b = k;
r = n - k;
int av = r + 1;
for (int i = 0; i < sz; i++)
c[i][0] = c[i][i] = 1;
for (int i = 1; i < sz; i++) {
for (int j = 1; j <= i; j++)
c[i][j] = add(c[i - 1][j], c[i - 1][j - 1]);
}
for (int i = 1; i <= b; i++)
printf("%I64d\n", mul(c[av][i], c[b - 1][i - 1]));
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 798,344 | 798,343 | u353783395 | cpp |
p02990 | #include <bits/stdc++.h>
using namespace std;
using lint = long long int;
using pint = pair<int, int>;
using plint = pair<lint, lint>;
#define ALL(x) (x).begin(), (x).end()
#define SZ(x) ((lint)(x).size())
#define POW2(n) (1LL << (n))
#define FOR(i, begin, end) \
for (int i = (begin), i##_end_ = (end); i < i##_end_; i++)
#define IFOR(i, begin, end) \
for (int i = (end)-1, i##_begin_ = (begin); i >= i##_begin_; i--)
#define REP(i, n) FOR(i, 0, n)
#define IREP(i, n) IFOR(i, 0, n)
#ifdef LOCAL
#define eprintf(...) fprintf(stderr, __VA_ARGS__)
#else
#define eprintf(...) 42
#endif
lint mod = 1e9 + 7;
void comb(vector<vector<long long int>> &v) {
for (int i = 0; i < v.size(); i++) {
v[i][0] = 1;
v[i][i] = 1;
}
for (int k = 1; k < v.size(); k++) {
for (int j = 1; j < k; j++) {
v[k][j] = (v[k - 1][j - 1] + v[k - 1][j]);
}
}
}
int main() {
lint n, k;
cin >> n >> k;
lint ans;
lint x, N;
N = n - k + 1;
vector<vector<long long int>> v(N + 1, vector<long long int>(N + 1, 0));
comb(v);
N = k - 1;
vector<vector<long long int>> v2(N + 1, vector<long long int>(N + 1, 0));
comb(v2);
FOR(i, 0, k) {
x = i + 1;
// v = comb(n - k + 1, x);
// v2 = comb(k - 1, x - 1);
ans = (v[n - k + 1][x] % mod) * (v2[k - 1][x - 1] % mod) % mod;
if (i >= n - k + 1) {
ans = 0;
}
cout << ans << "\n";
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using lint = long long int;
using pint = pair<int, int>;
using plint = pair<lint, lint>;
#define ALL(x) (x).begin(), (x).end()
#define SZ(x) ((lint)(x).size())
#define POW2(n) (1LL << (n))
#define FOR(i, begin, end) \
for (int i = (begin), i##_end_ = (end); i < i##_end_; i++)
#define IFOR(i, begin, end) \
for (int i = (end)-1, i##_begin_ = (begin); i >= i##_begin_; i--)
#define REP(i, n) FOR(i, 0, n)
#define IREP(i, n) IFOR(i, 0, n)
#ifdef LOCAL
#define eprintf(...) fprintf(stderr, __VA_ARGS__)
#else
#define eprintf(...) 42
#endif
lint mod = 1e9 + 7;
void comb(vector<vector<long long int>> &v) {
for (int i = 0; i < v.size(); i++) {
v[i][0] = 1;
v[i][i] = 1;
}
for (int k = 1; k < v.size(); k++) {
for (int j = 1; j < k; j++) {
v[k][j] = (v[k - 1][j - 1] % mod + v[k - 1][j] % mod);
}
}
}
int main() {
lint n, k;
cin >> n >> k;
lint ans;
lint x, N;
N = n - k + 1;
vector<vector<long long int>> v(N + 1, vector<long long int>(N + 1, 0));
comb(v);
N = k - 1;
vector<vector<long long int>> v2(N + 1, vector<long long int>(N + 1, 0));
comb(v2);
FOR(i, 0, k) {
x = i + 1;
ans = (v[n - k + 1][x] % mod) * (v2[k - 1][x - 1] % mod) % mod;
if (x > n - k + 1) {
ans = 0;
}
cout << ans << "\n";
}
return 0;
} | [
"assignment.change"
] | 798,345 | 798,346 | u517411077 | cpp |
p02990 | #include <bits/stdc++.h>
using namespace std;
const int64_t mod = 1e9 + 7;
std::vector<vector<int64_t>> comb(2010);
int main() {
int64_t n, k;
cin >> n >> k;
comb[1] = {1, 1};
for (int i = 2; i < 2010; ++i) {
comb[i].resize(i + 1);
comb[i][0] = comb[i][i] = 1;
for (int j = 1; j < i; ++j) {
comb[i][j] = comb[i - 1][j - 1] + comb[i - 1][j];
comb[i][j] %= mod;
}
}
for (int i = 1; i <= k; ++i) {
if (i == 1)
cout << n - k + 1 << endl;
else if (i > n - k + 1)
cout << 0 << endl;
else
cout << comb[k - 1][i - 1] * comb[n - k + 1][i] << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
const int64_t mod = 1e9 + 7;
std::vector<vector<int64_t>> comb(2010);
int main() {
int64_t n, k;
cin >> n >> k;
comb[1] = {1, 1};
for (int i = 2; i < 2010; ++i) {
comb[i].resize(i + 1);
comb[i][0] = comb[i][i] = 1;
for (int j = 1; j < i; ++j) {
comb[i][j] = comb[i - 1][j - 1] + comb[i - 1][j];
comb[i][j] %= mod;
}
}
for (int i = 1; i <= k; ++i) {
if (i == 1)
cout << n - k + 1 << endl;
else if (i > n - k + 1)
cout << 0 << endl;
else
cout << comb[k - 1][i - 1] * comb[n - k + 1][i] % mod << endl;
}
} | [
"expression.operation.binary.add"
] | 798,347 | 798,348 | u849073847 | cpp |
p02990 | // abc132d.cpp : Blue and Red Balls
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define upto(i, s, e, d) for (int i = (s); i < (e); i += (d))
#define oute(x) cout << (x) << endl
const ll MOD = 1000000007;
ll c[2001][2001];
void init(int N) {
rep(i, N + 1) rep(j, N - i) c[i][j] =
(i == 0 || j == 0) ? 1 : (c[i][j - 1] + c[i - 1][j]) % MOD;
}
ll comb(int n, int r) {
if (n < 0)
return 0;
return c[n - r][r];
}
int main() {
int N, K;
cin >> N >> K;
int red = N - K, blue = K;
init(N + 1);
upto(i, 1, blue + 1, 1)
oute((comb(red + 1, i) * comb(blue - 1, i - 1)) % MOD);
} | // abc132d.cpp : Blue and Red Balls
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define upto(i, s, e, d) for (int i = (s); i < (e); i += (d))
#define oute(x) cout << (x) << endl
const ll MOD = 1000000007;
ll c[2001][2001];
void init(int N) {
rep(i, N + 1) rep(j, N - i) c[i][j] =
(i == 0 || j == 0) ? 1 : (c[i][j - 1] + c[i - 1][j]) % MOD;
}
ll comb(int n, int r) {
if (n < r)
return 0;
return c[n - r][r];
}
int main() {
int N, K;
cin >> N >> K;
int red = N - K, blue = K;
init(N + 1);
upto(i, 1, blue + 1, 1)
oute((comb(red + 1, i) * comb(blue - 1, i - 1)) % MOD);
} | [
"identifier.replace.add",
"literal.replace.remove",
"control_flow.branch.if.condition.change"
] | 798,352 | 798,353 | u525065967 | cpp |
p02990 | #include <bits/stdc++.h>
#define LLI long long int
#define FOR(v, a, b) for (LLI v = (a); v < (b); ++v)
#define FORE(v, a, b) for (LLI v = (a); v <= (b); ++v)
#define REP(v, n) FOR(v, 0, n)
#define REPE(v, n) FORE(v, 0, n)
#define REV(v, a, b) for (LLI v = (a); v >= (b); --v)
#define ALL(x) (x).begin(), (x).end()
#define RALL(x) (x).rbegin(), (x).rend()
#define ITR(it, c) for (auto it = (c).begin(); it != (c).end(); ++it)
#define RITR(it, c) for (auto it = (c).rbegin(); it != (c).rend(); ++it)
#define EXIST(c, x) ((c).find(x) != (c).end())
#define fst first
#define snd second
#define popcount __builtin_popcount
#define UNIQ(v) (v).erase(unique(ALL(v)), (v).end())
#define bit(i) (1LL << (i))
#define sz(v) ((LLI)(v).size())
#ifdef DEBUG
#include <misc/C++/Debug.cpp>
#else
#define dump(...) ((void)0)
#endif
#define gcd __gcd
using namespace std;
template <class T> constexpr T lcm(T m, T n) { return m / gcd(m, n) * n; }
template <typename I> void join(ostream &ost, I s, I t, string d = " ") {
for (auto i = s; i != t; ++i) {
if (i != s)
ost << d;
ost << *i;
}
ost << endl;
}
template <typename T> istream &operator>>(istream &is, vector<T> &v) {
for (auto &a : v)
is >> a;
return is;
}
template <typename T, typename U>
istream &operator>>(istream &is, pair<T, U> &p) {
is >> p.first >> p.second;
return is;
}
template <typename T, typename U> bool chmin(T &a, const U &b) {
return (a > b ? a = b, true : false);
}
template <typename T, typename U> bool chmax(T &a, const U &b) {
return (a < b ? a = b, true : false);
}
template <typename T, size_t N, typename U>
void fill_array(T (&a)[N], const U &v) {
fill((U *)a, (U *)(a + N), v);
}
const LLI mod = 1e9 + 7;
template <int MOD> vector<vector<LLI>> binomial_pascal(int n, int k) {
vector<vector<LLI>> ret(n + 1, vector<LLI>(k + 1));
ret[0][0] = 1;
FORE(i, 1, n) {
ret[i][0] = 1;
FORE(j, 1, k) { ret[i][j] = (ret[i - 1][j - 1] + ret[i - 1][j]) % MOD; }
}
return ret;
}
auto C = binomial_pascal<mod>(6000, 6000);
LLI H(int n, int k) {
if (n == 0 and k == 0)
return 1;
if (n + k - 1 < 0)
return 0;
return C[n + k - 1][k];
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N, K;
while (cin >> N >> K) {
FORE(i, 1, K) {
LLI x = C[K - 1][i - 1];
LLI y = H(i + 1, N - K - (i - 1));
LLI ans = x * y % mod;
cout << ans << endl;
}
}
return 0;
}
| #include <bits/stdc++.h>
#define LLI long long int
#define FOR(v, a, b) for (LLI v = (a); v < (b); ++v)
#define FORE(v, a, b) for (LLI v = (a); v <= (b); ++v)
#define REP(v, n) FOR(v, 0, n)
#define REPE(v, n) FORE(v, 0, n)
#define REV(v, a, b) for (LLI v = (a); v >= (b); --v)
#define ALL(x) (x).begin(), (x).end()
#define RALL(x) (x).rbegin(), (x).rend()
#define ITR(it, c) for (auto it = (c).begin(); it != (c).end(); ++it)
#define RITR(it, c) for (auto it = (c).rbegin(); it != (c).rend(); ++it)
#define EXIST(c, x) ((c).find(x) != (c).end())
#define fst first
#define snd second
#define popcount __builtin_popcount
#define UNIQ(v) (v).erase(unique(ALL(v)), (v).end())
#define bit(i) (1LL << (i))
#define sz(v) ((LLI)(v).size())
#ifdef DEBUG
#include <misc/C++/Debug.cpp>
#else
#define dump(...) ((void)0)
#endif
#define gcd __gcd
using namespace std;
template <class T> constexpr T lcm(T m, T n) { return m / gcd(m, n) * n; }
template <typename I> void join(ostream &ost, I s, I t, string d = " ") {
for (auto i = s; i != t; ++i) {
if (i != s)
ost << d;
ost << *i;
}
ost << endl;
}
template <typename T> istream &operator>>(istream &is, vector<T> &v) {
for (auto &a : v)
is >> a;
return is;
}
template <typename T, typename U>
istream &operator>>(istream &is, pair<T, U> &p) {
is >> p.first >> p.second;
return is;
}
template <typename T, typename U> bool chmin(T &a, const U &b) {
return (a > b ? a = b, true : false);
}
template <typename T, typename U> bool chmax(T &a, const U &b) {
return (a < b ? a = b, true : false);
}
template <typename T, size_t N, typename U>
void fill_array(T (&a)[N], const U &v) {
fill((U *)a, (U *)(a + N), v);
}
const LLI mod = 1e9 + 7;
template <int MOD> vector<vector<LLI>> binomial_pascal(int n, int k) {
vector<vector<LLI>> ret(n + 1, vector<LLI>(k + 1));
ret[0][0] = 1;
FORE(i, 1, n) {
ret[i][0] = 1;
FORE(j, 1, k) { ret[i][j] = (ret[i - 1][j - 1] + ret[i - 1][j]) % MOD; }
}
return ret;
}
auto C = binomial_pascal<mod>(6000, 6000);
LLI H(int n, int k) {
if (n == 0 and k == 0)
return 1;
if (n + k - 1 < 0 or k < 0)
return 0;
return C[n + k - 1][k];
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N, K;
while (cin >> N >> K) {
FORE(i, 1, K) {
LLI x = C[K - 1][i - 1];
LLI y = H(i + 1, N - K - (i - 1));
LLI ans = x * y % mod;
cout << ans << endl;
}
}
return 0;
}
| [
"control_flow.branch.if.condition.change"
] | 798,356 | 798,357 | u543167400 | cpp |
p02990 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll MOD = 1e9 + 7;
ll N, K;
vector<ll> ans;
ll fuct(ll n) {
if (n == 0 or n == 1)
return 1;
else
return n * fuct(n - 1) % MOD;
}
// aのb乗
ll calc(ll a, ll b) {
if (b == 0) {
return 1;
} else if (b == 1) {
return a;
} else if (b % 2 == 0) {
ll tmp = calc(a, b / 2);
return tmp * tmp % MOD;
} else {
return a * calc(a, b - 1) % MOD;
}
}
ll comb(ll n, ll k) {
ll retval =
((fuct(n) * calc(fuct(k), MOD - 2)) % MOD * calc(fuct(n - k), MOD - 2)) %
MOD;
return retval;
}
int main() {
cin >> N >> K;
ans = vector<ll>(N + 1);
ll key = min(N - K + 1, K);
// i回の操作で,
for (int i = 1; i <= key; i++) {
ans[i - 1] = (comb(N - K + 1, i) * comb(K - 1, i - 1)) % MOD;
}
for (int i = 0; i < key; i++) {
cout << ans[i] << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll MOD = 1e9 + 7;
ll N, K;
vector<ll> ans;
ll fuct(ll n) {
if (n == 0 or n == 1)
return 1;
else
return n * fuct(n - 1) % MOD;
}
// aのb乗
ll calc(ll a, ll b) {
if (b == 0) {
return 1;
} else if (b == 1) {
return a;
} else if (b % 2 == 0) {
ll tmp = calc(a, b / 2);
return tmp * tmp % MOD;
} else {
return a * calc(a, b - 1) % MOD;
}
}
ll comb(ll n, ll k) {
ll retval =
((fuct(n) * calc(fuct(k), MOD - 2)) % MOD * calc(fuct(n - k), MOD - 2)) %
MOD;
return retval;
}
int main() {
cin >> N >> K;
ans = vector<ll>(K, 0);
ll key = min(N - K + 1, K);
// i回の操作で,
for (int i = 1; i <= key; i++) {
ans[i - 1] = (comb(N - K + 1, i) * comb(K - 1, i - 1)) % MOD;
}
for (int i = 0; i < K; i++) {
cout << ans[i] << endl;
}
} | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 798,362 | 798,363 | u003019316 | cpp |
p02990 | #include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
int comb[2001][2001];
void solve() {
memset(comb, 0, sizeof(comb));
comb[0][0] = 1;
comb[1][0] = 1;
comb[1][1] = 1;
for (int cnt0 = 2; cnt0 < 2001; cnt0++) {
for (int cnt1 = 0; cnt1 <= cnt0; cnt1++) {
if (cnt1 == 0 || cnt1 == cnt0)
comb[cnt0][cnt1] = 1;
else
comb[cnt0][cnt1] =
(comb[cnt0 - 1][cnt1 - 1] + comb[cnt0 - 1][cnt1]) % mod;
}
}
/*
for(int cnt0=1; cnt0<10; cnt0++){
for(int cnt1=0; cnt1<=cnt0; cnt1++){
cout << "comb[" << cnt0 << "][" << cnt1 << "]: " << comb[cnt0][cnt1] << "
";
}
cout << endl;
}
*/
}
int main(int argc, char **argv) {
int N, K;
cin >> N >> K;
solve();
for (int i = 1; i <= K; i++) {
if (N - K + 1 < i) {
printf("0\n");
continue;
}
printf("%d\n", comb[K - 1][i - 1] * comb[N - K + 1][i] % mod);
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
long long comb[2001][2001];
void solve() {
memset(comb, 0, sizeof(comb));
comb[0][0] = 1;
comb[1][0] = 1;
comb[1][1] = 1;
for (int cnt0 = 2; cnt0 < 2001; cnt0++) {
for (int cnt1 = 0; cnt1 <= cnt0; cnt1++) {
if (cnt1 == 0 || cnt1 == cnt0)
comb[cnt0][cnt1] = 1;
else
comb[cnt0][cnt1] =
(comb[cnt0 - 1][cnt1 - 1] + comb[cnt0 - 1][cnt1]) % mod;
}
}
/*
for(int cnt0=1; cnt0<10; cnt0++){
for(int cnt1=0; cnt1<=cnt0; cnt1++){
cout << "comb[" << cnt0 << "][" << cnt1 << "]: " << comb[cnt0][cnt1] << "
";
}
cout << endl;
}
*/
}
int main(int argc, char **argv) {
int N, K;
cin >> N >> K;
solve();
for (int i = 1; i <= K; i++) {
if (N - K + 1 < i) {
printf("0\n");
continue;
}
printf("%lld\n", comb[K - 1][i - 1] * comb[N - K + 1][i] % mod);
}
return 0;
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change",
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 798,372 | 798,373 | u998251394 | cpp |
p02990 | #include <iostream>
using namespace std;
long long mod = 1e9 + 7;
long long fact_arr[2007], inv_fact_arr[2007];
long long pow(long long n, long long r) {
if (r == 0) {
return 1;
}
n %= mod;
if (r % 2) {
return pow(n * n % mod, r / 2) % mod * n % mod;
} else {
return pow(n * n % mod, r / 2) % mod;
}
}
long long inv(long long n) { return pow(n % mod, mod - 2) % mod; }
long long comb(long long n, long long k) {
if (n < k || n < 0) {
return 0;
}
return fact_arr[n] * inv_fact_arr[n - k] % mod * inv_fact_arr[k] % mod;
}
int K, N;
int main() {
cin >> N >> K;
fact_arr[0] = 1;
inv_fact_arr[0] = 1;
for (int i = 1; i < 2007; i++) {
fact_arr[i] = i * fact_arr[i - 1] % mod;
inv_fact_arr[i] = inv(fact_arr[i]);
}
for (int i = 1; i <= K; i++) {
// 青い玉の配置: K個のボールを空でないi個のグループにわける
// K - i 個のボールを空でもよいi個のグループにわける
// comb(K - i + (i - 1), i - 1)
long long blue_comb = comb(K - 1, i - 1);
// 赤い玉の配置: N - K 個のボールを、i -
// 1個の空でないグループと2個の空でもよいグループにわける N - K - (i -
// 1)個のボールを i + 1個の空でもよいグループにわける comb(N - K - i + 1 + i
// + 1 - 1, i)
long long red_comb = comb(N - K + 1, i);
cout << blue_comb * red_comb << endl;
}
}
| #include <iostream>
using namespace std;
long long mod = 1e9 + 7;
long long fact_arr[2007], inv_fact_arr[2007];
long long pow(long long n, long long r) {
if (r == 0) {
return 1;
}
n %= mod;
if (r % 2) {
return pow(n * n % mod, r / 2) % mod * n % mod;
} else {
return pow(n * n % mod, r / 2) % mod;
}
}
long long inv(long long n) { return pow(n % mod, mod - 2) % mod; }
long long comb(long long n, long long k) {
if (n < k || n < 0) {
return 0;
}
return fact_arr[n] * inv_fact_arr[n - k] % mod * inv_fact_arr[k] % mod;
}
int K, N;
int main() {
cin >> N >> K;
fact_arr[0] = 1;
inv_fact_arr[0] = 1;
for (int i = 1; i < 2007; i++) {
fact_arr[i] = i * fact_arr[i - 1] % mod;
inv_fact_arr[i] = inv(fact_arr[i]);
}
for (int i = 1; i <= K; i++) {
// 青い玉の配置: K個のボールを空でないi個のグループにわける
// K - i 個のボールを空でもよいi個のグループにわける
// comb(K - i + (i - 1), i - 1)
long long blue_comb = comb(K - 1, i - 1);
// 赤い玉の配置: N - K 個のボールを、i -
// 1個の空でないグループと2個の空でもよいグループにわける N - K - (i -
// 1)個のボールを i + 1個の空でもよいグループにわける comb(N - K - i + 1 + i
// + 1 - 1, i)
long long red_comb = comb(N - K + 1, i);
cout << blue_comb * red_comb % mod << endl;
}
}
| [
"expression.operation.binary.add"
] | 798,374 | 798,375 | u425351967 | cpp |
p02990 | #include <cmath>
#include <cstdio>
#include <iomanip>
#include <iostream>
using namespace std;
const long long MOD = 1e9 + 7;
long long c[2005][2005];
int n, k;
long long C(int N, int M) {
if (N < M)
return 0;
return c[N][M];
}
void woh(int N) {
for (int i = 1; i <= N; i++)
c[i][0] = c[i][i] = 1;
for (int i = 1; i <= N; i++)
for (int j = 1; j <= i - 1; j++)
c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % MOD;
}
int main() {
cin >> n >> k;
woh(n);
for (int i = 1; i <= k; i++) {
long long ans = C(n - k + 1, i) * C(k - 1, i - 1) % MOD;
cout << ans << endl;
}
return 0;
} | #include <cmath>
#include <cstdio>
#include <iomanip>
#include <iostream>
using namespace std;
const long long MOD = 1e9 + 7;
long long c[2005][2005];
int n, k;
long long C(int N, int M) {
if (N < M)
return 0;
return c[N][M];
}
void woh(int N) {
for (int i = 0; i <= N; i++)
c[i][0] = c[i][i] = 1;
for (int i = 1; i <= N; i++)
for (int j = 1; j <= i - 1; j++)
c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % MOD;
}
int main() {
cin >> n >> k;
woh(n);
for (int i = 1; i <= k; i++) {
long long ans = C(n - k + 1, i) * C(k - 1, i - 1) % MOD;
cout << ans << endl;
}
return 0;
} | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 798,388 | 798,389 | u516021252 | cpp |
p02990 | #include <cstdio>
using namespace std;
int c[2005][2005];
long long C(int n, int m) {
if (n > m) {
return 0;
}
return c[n][m];
}
int p = 1e9 + 7;
int main() {
int ans;
int n;
int k;
scanf("%d%d", &n, &k);
for (int i = 0; i <= n; i++) {
c[i][0] = 1;
c[i][i] = 1;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= i - 1; j++) {
c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % p;
}
}
for (int i = 1; i <= k; i++) {
printf("%d\n", C(n - k + 1, i) * C(k - 1, i - 1) % p);
}
return 0;
} | #include <cstdio>
using namespace std;
int c[2005][2005];
long long C(int n, int m) {
if (n < m) {
return 0;
}
return c[n][m];
}
int p = 1e9 + 7;
int main() {
int ans;
int n;
int k;
scanf("%d%d", &n, &k);
for (int i = 0; i <= n; i++) {
c[i][0] = 1;
c[i][i] = 1;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= i - 1; j++) {
c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % p;
}
}
for (int i = 1; i <= k; i++) {
printf("%d\n", C(n - k + 1, i) * C(k - 1, i - 1) % p);
}
return 0;
} | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 798,390 | 798,391 | u099913313 | cpp |
p02990 | #include <cstdio>
using namespace std;
int c[2005][2005];
long long C(int n, int m) {
if (n > m) {
return 0;
}
return c[n][m];
}
int p = 1e9 + 7;
int main() {
int ans;
int n;
int k;
scanf("%d%d", &n, &k);
for (int i = 0; i <= n; i++) {
c[i][0] = 1;
c[i][i] = 1;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= i - 1; j++) {
c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % p;
}
}
for (int i = 1; i <= k; i++) {
printf("%d", C(n - k + 1, i) * C(k - 1, i - 1) % p);
}
return 0;
} | #include <cstdio>
using namespace std;
int c[2005][2005];
long long C(int n, int m) {
if (n < m) {
return 0;
}
return c[n][m];
}
int p = 1e9 + 7;
int main() {
int ans;
int n;
int k;
scanf("%d%d", &n, &k);
for (int i = 0; i <= n; i++) {
c[i][0] = 1;
c[i][i] = 1;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= i - 1; j++) {
c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % p;
}
}
for (int i = 1; i <= k; i++) {
printf("%d\n", C(n - k + 1, i) * C(k - 1, i - 1) % p);
}
return 0;
} | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"literal.string.change",
"call.arguments.change",
"io.output.change",
"io.output.newline.add"
] | 798,392 | 798,391 | u099913313 | cpp |
p02990 | #include <cstdio>
#include <iostream>
using namespace std;
int N, K;
const long long mod = 1e9 + 7;
long long c[2010][2010];
int C(int n, int m) {
if (m > n)
return 0;
return c[n][m];
}
void q(int n) {
for (int i = 0; i <= n; i++)
c[i][0] = c[i][i] = 1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= (i - 1); j++) {
c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % mod;
}
}
int main() {
cin >> N >> K;
q(N);
for (int i = 1; i <= K; i++)
cout << C(N - K + 1, i) * C(K - 1, i - 1) % mod << endl;
return 0;
} | #include <cstdio>
#include <iostream>
using namespace std;
int N, K;
const long long mod = 1e9 + 7;
long long c[2010][2010];
long long C(int n, int m) {
if (m > n)
return 0;
return c[n][m];
}
void q(int n) {
for (int i = 0; i <= n; i++)
c[i][0] = c[i][i] = 1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= (i - 1); j++) {
c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % mod;
}
}
int main() {
cin >> N >> K;
q(N);
for (int i = 1; i <= K; i++)
cout << C(N - K + 1, i) * C(K - 1, i - 1) % mod << endl;
return 0;
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 798,393 | 798,394 | u352610594 | cpp |
p02990 | /*silu1:dp
ba bLue rengdiaohou n-k+1 gekong,chakong,fencheng i fen;
ba k ge blueball fencheng i-1 fen,gong k-1 gekong;
Step1:zai redballs zhongxuancharu blueballs deweizhi;
Step2:zai blueballs zhongxuancharu redballs deweizhi;
Step3:qu i cidefanganshuji c[n-k+1][i]*c[k-1][i-1] zaiqu mod
*/
#include <iostream>
using namespace std;
const long long mod = 1e9 + 7;
long long c[2010][2010];
int n, k;
int check(int n, int m) {
if (n > m)
return 0;
return c[n][m];
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> k;
for (int i = 1; i <= n; i++)
c[i][0] = c[i][i] = 1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= i - 1; j++)
c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % mod;
for (int i = 1; i <= k; i++)
cout << c[n - k + 1][i] * c[k - 1][i - 1] % mod << endl;
return 0;
} | /*silu1:dp
ba bLue rengdiaohou n-k+1 gekong,chakong,fencheng i fen;
ba k ge blueball fencheng i-1 fen,gong k-1 gekong;
Step1:zai redballs zhongxuancharu blueballs deweizhi;
Step2:zai blueballs zhongxuancharu redballs deweizhi;
Step3:qu i cidefanganshuji c[n-k+1][i]*c[k-1][i-1] zaiqu mod
*/
#include <iostream>
using namespace std;
const long long mod = 1e9 + 7;
long long c[2010][2010];
int n, k;
int check(int n, int m) {
if (n > m)
return 0;
return c[n][m];
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> k;
for (int i = 0; i <= n; i++)
c[i][0] = c[i][i] = 1; // cong 0 kaishi
for (int i = 1; i <= n; i++)
for (int j = 1; j <= i - 1; j++)
c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % mod;
for (int i = 1; i <= k; i++)
cout << (c[n - k + 1][i] * c[k - 1][i - 1]) % mod << endl;
return 0;
} | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 798,395 | 798,396 | u570203502 | cpp |
p02990 | // Author: Vamsi Krishna Reddy Satti
// With love for Competitive Programming!
#include <bits/stdc++.h>
using namespace std;
#define fast_io \
ios_base::sync_with_stdio(false); \
cin.tie(nullptr); \
cout.tie(nullptr);
using ll = int64_t;
using vll = vector<ll>;
using vvll = vector<vll>;
using pll = pair<ll, ll>;
using vpll = vector<pll>;
using vvpll = vector<vpll>;
// ------------------------------------------------------------------------------------------------
const ll MOD = 1e9 + 7;
ll n, k, ans;
ll bin_exp(ll b, ll e, ll mod) {
ll ret = 1;
while (e > 0) {
if (e & 1) {
ret *= b;
ret %= mod;
}
b *= b;
b %= mod;
e >>= 1;
}
return ret;
}
void func() {
cin >> n >> k;
ans = n - k + 1;
cout << ans << endl;
for (ll i = 2, a = n - k, b = k - 1; i <= k; i++, a--, b--) {
ans *= a * b;
a %= MOD;
ans *= bin_exp(i * (i - 1), MOD - 2, MOD);
ans %= MOD;
cout << ans << endl;
}
}
int main() {
fast_io;
cout.precision(32);
ll t = 1; // cin >> t;
for (ll i = 1; i <= t; i++) {
func();
}
}
| // Author: Vamsi Krishna Reddy Satti
// With love for Competitive Programming!
#include <bits/stdc++.h>
using namespace std;
#define fast_io \
ios_base::sync_with_stdio(false); \
cin.tie(nullptr); \
cout.tie(nullptr);
using ll = int64_t;
using vll = vector<ll>;
using vvll = vector<vll>;
using pll = pair<ll, ll>;
using vpll = vector<pll>;
using vvpll = vector<vpll>;
// ------------------------------------------------------------------------------------------------
const ll MOD = 1e9 + 7;
ll n, k, ans;
ll bin_exp(ll b, ll e, ll mod) {
ll ret = 1;
while (e > 0) {
if (e & 1) {
ret *= b;
ret %= mod;
}
b *= b;
b %= mod;
e >>= 1;
}
return ret;
}
void func() {
cin >> n >> k;
ans = n - k + 1;
cout << ans << endl;
for (ll i = 2, a = n - k, b = k - 1; i <= k; i++, a--, b--) {
ans *= a * b;
ans %= MOD;
ans *= bin_exp(i * (i - 1), MOD - 2, MOD);
ans %= MOD;
cout << ans << endl;
}
}
int main() {
fast_io;
cout.precision(32);
ll t = 1; // cin >> t;
for (ll i = 1; i <= t; i++) {
func();
}
}
| [
"assignment.variable.change",
"identifier.change"
] | 798,397 | 798,398 | u060072952 | cpp |
p02990 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <string>
#include <vector>
#define CHMAX(a, b) a = std::max(a, b)
#define CHMIN(a, b) a = std::min(a, b)
#define CHABS(a) a = std::abs(a)
#define COUT(a) std::cout << a << std::endl
#define CERR(a) std::cerr << a << std::endl
#define FOR(n) for (lli i = 0; i < n; i++)
using namespace std;
using lli = long long int;
using pll = pair<lli, lli>;
using tlll = tuple<lli, lli, lli>;
lli mod197 = 1000000007LL;
// ax + by = gcd(a,b) 最大公約数
template <typename T> T extgcd(T a, T b, T &x, T &y) {
T d = a;
if (b != 0) {
d = extgcd(b, a % b, y, x);
y -= (a / b) * x;
} else {
x = 1;
y = 0;
}
return d;
}
lli dp[2001][2001] = {};
lli combi[2001] = {};
template <int mod> struct ModInt {
int x;
ModInt() : x(0) {}
ModInt(int64_t y) : x(y >= 0 ? y % mod : (mod - (-y) % mod) % mod) {}
ModInt &operator+=(const ModInt &p) {
if ((x += p.x) >= mod)
x -= mod;
return *this;
}
ModInt &operator-=(const ModInt &p) {
if ((x += mod - p.x) >= mod)
x -= mod;
return *this;
}
ModInt &operator*=(const ModInt &p) {
x = (int)(1LL * x * p.x % mod);
return *this;
}
ModInt &operator/=(const ModInt &p) {
*this *= p.inverse();
return *this;
}
ModInt operator-() const { return ModInt(-x); }
ModInt operator+(const ModInt &p) const { return ModInt(*this) += p; }
ModInt operator-(const ModInt &p) const { return ModInt(*this) -= p; }
ModInt operator*(const ModInt &p) const { return ModInt(*this) *= p; }
ModInt operator/(const ModInt &p) const { return ModInt(*this) /= p; }
bool operator==(const ModInt &p) const { return x == p.x; }
bool operator!=(const ModInt &p) const { return x != p.x; }
ModInt inverse() const {
int a = x, b = mod, u = 1, v = 0, t;
while (b > 0) {
t = a / b;
swap(a -= t * b, b);
swap(u -= t * v, v);
}
return ModInt(u);
}
ModInt pow(int64_t n) const {
ModInt ret(1), mul(x);
while (n > 0) {
if (n & 1)
ret *= mul;
mul *= mul;
n >>= 1;
}
return ret;
}
friend ostream &operator<<(ostream &os, const ModInt &p) { return os << p.x; }
friend istream &operator>>(istream &is, ModInt &a) {
int64_t t;
is >> t;
a = ModInt<mod>(t);
return (is);
}
static int get_mod() { return mod; }
};
using modint = ModInt<1000000007>;
template <typename T> struct Combination {
vector<T> _fact, _rfact, _inv;
Combination(int sz) : _fact(sz + 1), _rfact(sz + 1), _inv(sz + 1) {
_fact[0] = _rfact[sz] = _inv[0] = 1;
for (int i = 1; i <= sz; i++)
_fact[i] = _fact[i - 1] * i;
_rfact[sz] /= _fact[sz];
for (int i = sz - 1; i >= 0; i--)
_rfact[i] = _rfact[i + 1] * (i + 1);
for (int i = 1; i <= sz; i++)
_inv[i] = _rfact[i] * _fact[i - 1];
}
inline T fact(int k) const { return _fact[k]; }
inline T rfact(int k) const { return _rfact[k]; }
inline T inv(int k) const { return _inv[k]; }
T P(int n, int r) const {
if (r < 0 || n < r)
return 0;
return fact(n) * rfact(n - r);
}
T C(int p, int q) const {
if (q < 0 || p < q)
return 0;
return fact(p) * rfact(q) * rfact(p - q);
}
T H(int n, int r) const {
if (n < 0 || r < 0)
return (0);
return r == 0 ? 1 : C(n + r - 1, r);
}
};
int main(void) {
lli N, K;
cin >> N >> K;
lli R = N - K;
lli B = K;
if (R == 1 && B == 1) {
COUT(1);
return 0;
}
dp[1][B] = 1;
for (int i = 2; i < N; i++) {
for (int j = B - 1; j >= 1; j--) {
dp[i][j] = dp[i - 1][j + 1] + dp[i][j + 1];
dp[i][j] %= mod197;
}
}
for (int i = 1; i < N; i++) {
for (int j = B; j >= 0; j--) {
combi[i] += dp[i][j];
combi[i] %= mod197;
}
}
modint ans = 0;
Combination<modint> c(3000);
for (int i = 1; i <= B; i++) {
ans = c.C(R + 1, i) * modint(combi[i]);
COUT(ans);
}
return 0;
} | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <string>
#include <vector>
#define CHMAX(a, b) a = std::max(a, b)
#define CHMIN(a, b) a = std::min(a, b)
#define CHABS(a) a = std::abs(a)
#define COUT(a) std::cout << a << std::endl
#define CERR(a) std::cerr << a << std::endl
#define FOR(n) for (lli i = 0; i < n; i++)
using namespace std;
using lli = long long int;
using pll = pair<lli, lli>;
using tlll = tuple<lli, lli, lli>;
lli mod197 = 1000000007LL;
// ax + by = gcd(a,b) 最大公約数
template <typename T> T extgcd(T a, T b, T &x, T &y) {
T d = a;
if (b != 0) {
d = extgcd(b, a % b, y, x);
y -= (a / b) * x;
} else {
x = 1;
y = 0;
}
return d;
}
lli dp[2001][2001] = {};
lli combi[2001] = {};
template <int mod> struct ModInt {
int x;
ModInt() : x(0) {}
ModInt(int64_t y) : x(y >= 0 ? y % mod : (mod - (-y) % mod) % mod) {}
ModInt &operator+=(const ModInt &p) {
if ((x += p.x) >= mod)
x -= mod;
return *this;
}
ModInt &operator-=(const ModInt &p) {
if ((x += mod - p.x) >= mod)
x -= mod;
return *this;
}
ModInt &operator*=(const ModInt &p) {
x = (int)(1LL * x * p.x % mod);
return *this;
}
ModInt &operator/=(const ModInt &p) {
*this *= p.inverse();
return *this;
}
ModInt operator-() const { return ModInt(-x); }
ModInt operator+(const ModInt &p) const { return ModInt(*this) += p; }
ModInt operator-(const ModInt &p) const { return ModInt(*this) -= p; }
ModInt operator*(const ModInt &p) const { return ModInt(*this) *= p; }
ModInt operator/(const ModInt &p) const { return ModInt(*this) /= p; }
bool operator==(const ModInt &p) const { return x == p.x; }
bool operator!=(const ModInt &p) const { return x != p.x; }
ModInt inverse() const {
int a = x, b = mod, u = 1, v = 0, t;
while (b > 0) {
t = a / b;
swap(a -= t * b, b);
swap(u -= t * v, v);
}
return ModInt(u);
}
ModInt pow(int64_t n) const {
ModInt ret(1), mul(x);
while (n > 0) {
if (n & 1)
ret *= mul;
mul *= mul;
n >>= 1;
}
return ret;
}
friend ostream &operator<<(ostream &os, const ModInt &p) { return os << p.x; }
friend istream &operator>>(istream &is, ModInt &a) {
int64_t t;
is >> t;
a = ModInt<mod>(t);
return (is);
}
static int get_mod() { return mod; }
};
using modint = ModInt<1000000007>;
template <typename T> struct Combination {
vector<T> _fact, _rfact, _inv;
Combination(int sz) : _fact(sz + 1), _rfact(sz + 1), _inv(sz + 1) {
_fact[0] = _rfact[sz] = _inv[0] = 1;
for (int i = 1; i <= sz; i++)
_fact[i] = _fact[i - 1] * i;
_rfact[sz] /= _fact[sz];
for (int i = sz - 1; i >= 0; i--)
_rfact[i] = _rfact[i + 1] * (i + 1);
for (int i = 1; i <= sz; i++)
_inv[i] = _rfact[i] * _fact[i - 1];
}
inline T fact(int k) const { return _fact[k]; }
inline T rfact(int k) const { return _rfact[k]; }
inline T inv(int k) const { return _inv[k]; }
T P(int n, int r) const {
if (r < 0 || n < r)
return 0;
return fact(n) * rfact(n - r);
}
T C(int p, int q) const {
if (q < 0 || p < q)
return 0;
return fact(p) * rfact(q) * rfact(p - q);
}
T H(int n, int r) const {
if (n < 0 || r < 0)
return (0);
return r == 0 ? 1 : C(n + r - 1, r);
}
};
int main(void) {
lli N, K;
cin >> N >> K;
lli R = N - K;
lli B = K;
if (R == 0 && B == 1) {
COUT(1);
return 0;
}
dp[1][B] = 1;
for (int i = 2; i < N; i++) {
for (int j = B - 1; j >= 1; j--) {
dp[i][j] = dp[i - 1][j + 1] + dp[i][j + 1];
dp[i][j] %= mod197;
}
}
for (int i = 1; i < N; i++) {
for (int j = B; j >= 0; j--) {
combi[i] += dp[i][j];
combi[i] %= mod197;
}
}
modint ans = 0;
Combination<modint> c(3000);
for (int i = 1; i <= B; i++) {
ans = c.C(R + 1, i) * modint(combi[i]);
COUT(ans);
}
return 0;
} | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 798,403 | 798,404 | u155216115 | cpp |
p02990 | #include <iostream>
#define NMAX 2001
#define MOD 1000000007
using namespace std;
int n, k;
int pascal[NMAX][NMAX];
int main() {
cin >> n >> k;
int blueBalls = k;
int redBalls = n - k;
pascal[0][0] = 1;
for (int i = 1; i <= n; i++)
for (int j = 0; j <= n; j++)
if (j - 1 >= 0)
pascal[i][j] = (pascal[i - 1][j] + pascal[i - 1][j - 1]) % MOD;
else
pascal[i][j] = pascal[i - 1][j];
for (int i = 1; i <= k; i++)
cout << pascal[redBalls + 1][i] * pascal[blueBalls - 1][i - 1] % MOD
<< '\n';
return 0;
} | #include <iostream>
#define NMAX 2001
#define MOD 1000000007
using namespace std;
int n, k;
long long pascal[NMAX][NMAX];
int main() {
cin >> n >> k;
int blueBalls = k;
int redBalls = n - k;
pascal[0][0] = 1;
for (int i = 1; i <= n; i++)
for (int j = 0; j <= n; j++)
if (j - 1 >= 0)
pascal[i][j] = (pascal[i - 1][j] + pascal[i - 1][j - 1]) % MOD;
else
pascal[i][j] = pascal[i - 1][j];
for (int i = 1; i <= k; i++)
cout << pascal[redBalls + 1][i] * pascal[blueBalls - 1][i - 1] % MOD
<< '\n';
return 0;
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 798,423 | 798,424 | u885932660 | cpp |
p02990 | #include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
vector<vector<long>> c(2003, vector<long>(2003, -1));
long com(int m, int l);
int main(void) {
int n, k, i;
cin >> n >> k;
for (i = 1; i <= k; i++)
cout << (com(k - 1, i - 1) * com(n - k + 1, i)) % mod << endl;
return 0;
}
long com(int m, int l) {
if (m < 0)
return 0;
if (m == 0 || l == 0 || l == m)
return 1;
if (c.at(m).at(l) != -1)
return c.at(m).at(l);
else
return c.at(m).at(l) = (com(m - 1, l - 1) + com(m - 1, l)) % mod;
} | #include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
vector<vector<long>> c(2003, vector<long>(2003, -1));
long com(int m, int l);
int main(void) {
int n, k, i;
cin >> n >> k;
for (i = 1; i <= k; i++)
cout << (com(k - 1, i - 1) * com(n - k + 1, i)) % mod << endl;
return 0;
}
long com(int m, int l) {
if (m < 0 || m < l)
return 0;
if (m == 0 || l == 0 || l == m)
return 1;
if (c.at(m).at(l) != -1)
return c.at(m).at(l);
else
return c.at(m).at(l) = (com(m - 1, l - 1) + com(m - 1, l)) % mod;
} | [
"control_flow.branch.if.condition.change"
] | 798,425 | 798,426 | u088895504 | cpp |
p02990 | #include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
vector<vector<long>> c(2003, vector<long>(2003, -1));
long com(int m, int l);
int main(void) {
int n, k, i;
cin >> n >> k;
for (i = 1; i <= k; i++)
cout << com(k - 1, i - 1) * com(n - k + 1, i) % mod << endl;
return 0;
}
long com(int m, int l) {
if (m < 0 || l < 0)
return 0;
if (m == 0 || l == 0 || l == m)
return 1;
if (c.at(m).at(l) != -1)
return c.at(m).at(l);
else
return c.at(m).at(l) = (com(m - 1, l - 1) + com(m - 1, l)) % mod;
} | #include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
vector<vector<long>> c(2003, vector<long>(2003, -1));
long com(int m, int l);
int main(void) {
int n, k, i;
cin >> n >> k;
for (i = 1; i <= k; i++)
cout << (com(k - 1, i - 1) * com(n - k + 1, i)) % mod << endl;
return 0;
}
long com(int m, int l) {
if (m < 0 || m < l)
return 0;
if (m == 0 || l == 0 || l == m)
return 1;
if (c.at(m).at(l) != -1)
return c.at(m).at(l);
else
return c.at(m).at(l) = (com(m - 1, l - 1) + com(m - 1, l)) % mod;
} | [
"call.arguments.change",
"identifier.change",
"control_flow.branch.if.condition.change",
"identifier.replace.add",
"literal.replace.remove"
] | 798,427 | 798,426 | u088895504 | cpp |
p02990 | //↓template↓
#include "bits/stdc++.h"
using namespace std;
#define Would
#define you
#define all(n) n.begin(), n.end()
#define rall(n) n.rbegin(), n.rend()
typedef long long ll;
const ll INF = 1e18;
const ll MOD = 1e9 + 7;
const double pi = acos(-1);
const ll SIZE = 1 << 17;
int dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1}, alp[30];
ll fac[200005], finv[200005], inv[200005];
vector<ll> dij;
struct edge {
ll to, cost;
};
vector<vector<edge>> G;
ll mod_pow(ll a, ll b) {
ll res = 1, mul = a;
for (int i = 0; i < 31; ++i) {
if (b >> i & 1) {
res *= mul;
res %= MOD;
}
mul = (mul * mul) % MOD;
}
return res;
}
void addedge(int from, int to, int cost) {
G[from].push_back({to, cost});
G[to].push_back({from, cost});
}
template <typename T> vector<T> make_v(size_t a) { return vector<T>(a); }
template <typename T, typename... Ts> auto make_v(size_t a, Ts... ts) {
return vector<decltype(make_v<T>(ts...))>(a, make_v<T>(ts...));
}
template <typename T, typename V>
typename enable_if<is_class<T>::value == 0>::type fill_v(T &t, const V &v) {
t = v;
}
template <typename T, typename V>
typename enable_if<is_class<T>::value != 0>::type fill_v(T &t, const V &v) {
for (auto &e : t)
fill_v(e, v);
}
template <typename T> void outp(vector<T> v) {
for (int i = 0; i < v.size(); ++i) {
cout << v[i];
if (i != v.size() - 1) {
cout << " ";
}
}
}
//↑template↑
void COMinit() {
fac[0] = 1, fac[1] = 1, finv[0] = 1, finv[1] = 1, inv[1] = 1;
for (int i = 2; i < 100005; ++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;
}
}
// calc
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() {
COMinit();
ll a, b;
cin >> a >> b;
for (int i = 0; i < b; ++i) {
cout << (ll)(COM(a - b + 1, i + 1) % MOD) * (COM(b - 1, i) % MOD) << endl;
;
}
} | //↓template↓
#include "bits/stdc++.h"
using namespace std;
#define Would
#define you
#define all(n) n.begin(), n.end()
#define rall(n) n.rbegin(), n.rend()
typedef long long ll;
const ll INF = 1e18;
const ll MOD = 1e9 + 7;
const double pi = acos(-1);
const ll SIZE = 1 << 17;
int dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1}, alp[30];
ll fac[200005], finv[200005], inv[200005];
vector<ll> dij;
struct edge {
ll to, cost;
};
vector<vector<edge>> G;
ll mod_pow(ll a, ll b) {
ll res = 1, mul = a;
for (int i = 0; i < 31; ++i) {
if (b >> i & 1) {
res *= mul;
res %= MOD;
}
mul = (mul * mul) % MOD;
}
return res;
}
void addedge(int from, int to, int cost) {
G[from].push_back({to, cost});
G[to].push_back({from, cost});
}
template <typename T> vector<T> make_v(size_t a) { return vector<T>(a); }
template <typename T, typename... Ts> auto make_v(size_t a, Ts... ts) {
return vector<decltype(make_v<T>(ts...))>(a, make_v<T>(ts...));
}
template <typename T, typename V>
typename enable_if<is_class<T>::value == 0>::type fill_v(T &t, const V &v) {
t = v;
}
template <typename T, typename V>
typename enable_if<is_class<T>::value != 0>::type fill_v(T &t, const V &v) {
for (auto &e : t)
fill_v(e, v);
}
template <typename T> void outp(vector<T> v) {
for (int i = 0; i < v.size(); ++i) {
cout << v[i];
if (i != v.size() - 1) {
cout << " ";
}
}
}
//↑template↑
void COMinit() {
fac[0] = 1, fac[1] = 1, finv[0] = 1, finv[1] = 1, inv[1] = 1;
for (int i = 2; i < 100005; ++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;
}
}
// calc
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() {
COMinit();
ll a, b;
cin >> a >> b;
for (int i = 0; i < b; ++i) {
cout << (ll)COM(a - b + 1, i + 1) * COM(b - 1, i) % MOD << endl;
;
}
} | [
"call.arguments.change"
] | 798,430 | 798,431 | u539402331 | cpp |
p02990 | //↓template↓
#include "bits/stdc++.h"
using namespace std;
#define Would
#define you
#define all(n) n.begin(), n.end()
#define rall(n) n.rbegin(), n.rend()
typedef long long ll;
const ll INF = 1e18;
const ll MOD = 1e9 + 7;
const double pi = acos(-1);
const ll SIZE = 1 << 17;
int dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1}, alp[30];
ll fac[200005], finv[200005], inv[200005];
vector<ll> dij;
struct edge {
ll to, cost;
};
vector<vector<edge>> G;
ll mod_pow(ll a, ll b) {
ll res = 1, mul = a;
for (int i = 0; i < 31; ++i) {
if (b >> i & 1) {
res *= mul;
res %= MOD;
}
mul = (mul * mul) % MOD;
}
return res;
}
void addedge(int from, int to, int cost) {
G[from].push_back({to, cost});
G[to].push_back({from, cost});
}
template <typename T> vector<T> make_v(size_t a) { return vector<T>(a); }
template <typename T, typename... Ts> auto make_v(size_t a, Ts... ts) {
return vector<decltype(make_v<T>(ts...))>(a, make_v<T>(ts...));
}
template <typename T, typename V>
typename enable_if<is_class<T>::value == 0>::type fill_v(T &t, const V &v) {
t = v;
}
template <typename T, typename V>
typename enable_if<is_class<T>::value != 0>::type fill_v(T &t, const V &v) {
for (auto &e : t)
fill_v(e, v);
}
template <typename T> void outp(vector<T> v) {
for (int i = 0; i < v.size(); ++i) {
cout << v[i];
if (i != v.size() - 1) {
cout << " ";
}
}
}
//↑template↑
void COMinit() {
fac[0] = 1, fac[1] = 1, finv[0] = 1, finv[1] = 1, inv[1] = 1;
for (int i = 2; i < 100005; ++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;
}
}
// calc
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() {
COMinit();
ll a, b;
cin >> a >> b;
for (int i = 0; i < b; ++i) {
cout << (ll)COM(a - b + 1, i + 1) * COM(b - 1, i) << endl;
;
}
} | //↓template↓
#include "bits/stdc++.h"
using namespace std;
#define Would
#define you
#define all(n) n.begin(), n.end()
#define rall(n) n.rbegin(), n.rend()
typedef long long ll;
const ll INF = 1e18;
const ll MOD = 1e9 + 7;
const double pi = acos(-1);
const ll SIZE = 1 << 17;
int dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1}, alp[30];
ll fac[200005], finv[200005], inv[200005];
vector<ll> dij;
struct edge {
ll to, cost;
};
vector<vector<edge>> G;
ll mod_pow(ll a, ll b) {
ll res = 1, mul = a;
for (int i = 0; i < 31; ++i) {
if (b >> i & 1) {
res *= mul;
res %= MOD;
}
mul = (mul * mul) % MOD;
}
return res;
}
void addedge(int from, int to, int cost) {
G[from].push_back({to, cost});
G[to].push_back({from, cost});
}
template <typename T> vector<T> make_v(size_t a) { return vector<T>(a); }
template <typename T, typename... Ts> auto make_v(size_t a, Ts... ts) {
return vector<decltype(make_v<T>(ts...))>(a, make_v<T>(ts...));
}
template <typename T, typename V>
typename enable_if<is_class<T>::value == 0>::type fill_v(T &t, const V &v) {
t = v;
}
template <typename T, typename V>
typename enable_if<is_class<T>::value != 0>::type fill_v(T &t, const V &v) {
for (auto &e : t)
fill_v(e, v);
}
template <typename T> void outp(vector<T> v) {
for (int i = 0; i < v.size(); ++i) {
cout << v[i];
if (i != v.size() - 1) {
cout << " ";
}
}
}
//↑template↑
void COMinit() {
fac[0] = 1, fac[1] = 1, finv[0] = 1, finv[1] = 1, inv[1] = 1;
for (int i = 2; i < 100005; ++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;
}
}
// calc
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() {
COMinit();
ll a, b;
cin >> a >> b;
for (int i = 0; i < b; ++i) {
cout << (ll)COM(a - b + 1, i + 1) * COM(b - 1, i) % MOD << endl;
;
}
} | [
"expression.operation.binary.add"
] | 798,432 | 798,431 | u539402331 | cpp |
p02990 | //↓template↓
#include "bits/stdc++.h"
using namespace std;
#define Would
#define you
#define all(n) n.begin(), n.end()
#define rall(n) n.rbegin(), n.rend()
typedef long long ll;
const ll INF = 1e18;
const ll MOD = 1e9 + 7;
const double pi = acos(-1);
const ll SIZE = 1 << 17;
int dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1}, alp[30];
ll fac[200005], finv[200005], inv[200005];
vector<ll> dij;
struct edge {
ll to, cost;
};
vector<vector<edge>> G;
ll mod_pow(ll a, ll b) {
ll res = 1, mul = a;
for (int i = 0; i < 31; ++i) {
if (b >> i & 1) {
res *= mul;
res %= MOD;
}
mul = (mul * mul) % MOD;
}
return res;
}
void addedge(int from, int to, int cost) {
G[from].push_back({to, cost});
G[to].push_back({from, cost});
}
template <typename T> vector<T> make_v(size_t a) { return vector<T>(a); }
template <typename T, typename... Ts> auto make_v(size_t a, Ts... ts) {
return vector<decltype(make_v<T>(ts...))>(a, make_v<T>(ts...));
}
template <typename T, typename V>
typename enable_if<is_class<T>::value == 0>::type fill_v(T &t, const V &v) {
t = v;
}
template <typename T, typename V>
typename enable_if<is_class<T>::value != 0>::type fill_v(T &t, const V &v) {
for (auto &e : t)
fill_v(e, v);
}
template <typename T> void outp(vector<T> v) {
for (int i = 0; i < v.size(); ++i) {
cout << v[i];
if (i != v.size() - 1) {
cout << " ";
}
}
}
//↑template↑
void COMinit() {
fac[0] = 1, fac[1] = 1, finv[0] = 1, finv[1] = 1, inv[1] = 1;
for (int i = 2; i < 100005; ++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;
}
}
// calc
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() {
COMinit();
int a, b;
cin >> a >> b;
for (int i = 0; i < b; ++i) {
cout << (ll)COM(a - b + 1, i + 1) * COM(b - 1, i) << endl;
;
}
} | //↓template↓
#include "bits/stdc++.h"
using namespace std;
#define Would
#define you
#define all(n) n.begin(), n.end()
#define rall(n) n.rbegin(), n.rend()
typedef long long ll;
const ll INF = 1e18;
const ll MOD = 1e9 + 7;
const double pi = acos(-1);
const ll SIZE = 1 << 17;
int dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1}, alp[30];
ll fac[200005], finv[200005], inv[200005];
vector<ll> dij;
struct edge {
ll to, cost;
};
vector<vector<edge>> G;
ll mod_pow(ll a, ll b) {
ll res = 1, mul = a;
for (int i = 0; i < 31; ++i) {
if (b >> i & 1) {
res *= mul;
res %= MOD;
}
mul = (mul * mul) % MOD;
}
return res;
}
void addedge(int from, int to, int cost) {
G[from].push_back({to, cost});
G[to].push_back({from, cost});
}
template <typename T> vector<T> make_v(size_t a) { return vector<T>(a); }
template <typename T, typename... Ts> auto make_v(size_t a, Ts... ts) {
return vector<decltype(make_v<T>(ts...))>(a, make_v<T>(ts...));
}
template <typename T, typename V>
typename enable_if<is_class<T>::value == 0>::type fill_v(T &t, const V &v) {
t = v;
}
template <typename T, typename V>
typename enable_if<is_class<T>::value != 0>::type fill_v(T &t, const V &v) {
for (auto &e : t)
fill_v(e, v);
}
template <typename T> void outp(vector<T> v) {
for (int i = 0; i < v.size(); ++i) {
cout << v[i];
if (i != v.size() - 1) {
cout << " ";
}
}
}
//↑template↑
void COMinit() {
fac[0] = 1, fac[1] = 1, finv[0] = 1, finv[1] = 1, inv[1] = 1;
for (int i = 2; i < 100005; ++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;
}
}
// calc
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() {
COMinit();
ll a, b;
cin >> a >> b;
for (int i = 0; i < b; ++i) {
cout << (ll)COM(a - b + 1, i + 1) * COM(b - 1, i) % MOD << endl;
;
}
} | [
"variable_declaration.type.change"
] | 798,433 | 798,431 | u539402331 | cpp |
p02990 | #include <algorithm>
#include <iostream>
#include <stdio.h>
using namespace std;
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define INF 1e9
#define llINF 1e18
#define MOD 1000000007
#define pb push_back
#define ll long long
#define ull unsigned long long
#define vint vector<int>
#define vll vector<ll>
//#include <stack>
//#include <queue>
/*
#include <math.h>
int standerd = int(pow(10.0,9.0)) + 7;
*/
string ans_Yes = "Yes";
string ans_No = "No";
string ans_yes = "yes";
string ans_no = "no";
int N, K;
vector<vector<long long>> combination(int n, int r, int mod = 0) {
vector<vector<long long>> v(n + 1, vector<long long>(n + 1, 0));
for (int i = 0; i < v.size(); i++) {
v[i][0] = 1;
v[i][i] = 1;
}
for (int j = 1; j < v.size(); j++) {
for (int k = 1; k < j; k++) {
v[j][k] = (v[j - 1][k - 1] + v[j - 1][k]);
if (mod > 0)
v[j][k] %= mod;
}
}
return v;
}
vector<vector<long long>> combi;
int main() {
cin >> N >> K;
ll ans;
combi = combination(2010, 2010, MOD);
for (int sousa = 1; sousa <= K; sousa++) {
ans = 1;
ans *= combi[N - K + 1][sousa];
ans *= combi[K - 1][sousa - 1];
cout << ans << endl;
}
} | #include <algorithm>
#include <iostream>
#include <stdio.h>
using namespace std;
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define INF 1e9
#define llINF 1e18
#define MOD 1000000007
#define pb push_back
#define ll long long
#define ull unsigned long long
#define vint vector<int>
#define vll vector<ll>
//#include <stack>
//#include <queue>
/*
#include <math.h>
int standerd = int(pow(10.0,9.0)) + 7;
*/
string ans_Yes = "Yes";
string ans_No = "No";
string ans_yes = "yes";
string ans_no = "no";
int N, K;
vector<vector<long long>> combination(int n, int r, int mod = 0) {
vector<vector<long long>> v(n + 1, vector<long long>(n + 1, 0));
for (int i = 0; i < v.size(); i++) {
v[i][0] = 1;
v[i][i] = 1;
}
for (int j = 1; j < v.size(); j++) {
for (int k = 1; k < j; k++) {
v[j][k] = (v[j - 1][k - 1] + v[j - 1][k]);
if (mod > 0)
v[j][k] %= mod;
}
}
return v;
}
vector<vector<long long>> combi;
int main() {
cin >> N >> K;
ll ans;
combi = combination(2010, 2010, MOD);
for (int sousa = 1; sousa <= K; sousa++) {
ans = 1;
ans *= combi[N - K + 1][sousa];
ans *= combi[K - 1][sousa - 1];
cout << ans % MOD << endl;
}
} | [
"expression.operation.binary.add"
] | 798,434 | 798,435 | u756614568 | cpp |
p02990 | #include <bits/stdc++.h>
using namespace std;
const int64_t mod = 1e9 + 7;
int64_t modinv(int64_t x, int64_t m) {
int64_t y = m, u = 1, v = 0;
while (y) {
int64_t t = x / y;
x -= t * y;
swap(x, y);
u -= t * v;
swap(u, v);
}
u %= m;
if (u < 0)
u += m;
return u;
}
int64_t cm(int n, int k) {
int i;
int64_t r = 1, x = 1, y = 1;
if (n < k)
return 0;
else if (n == k)
return 1;
else if (k == 1)
return n;
if (k > n - k)
k = n - k;
for (i = 0; i < k; i++) {
x *= n - i;
y *= k - i;
x %= mod;
y %= mod;
}
return (x * modinv(y, mod)) % mod;
}
int main() {
int N, K, i;
cin >> N >> K;
for (i = 0; i < K; i++)
cout << cm(N - K + 1, i + 1) * cm(K - 1, i) << endl;
} | #include <bits/stdc++.h>
using namespace std;
const int64_t mod = 1e9 + 7;
int64_t modinv(int64_t x, int64_t m) {
int64_t y = m, u = 1, v = 0;
while (y) {
int64_t t = x / y;
x -= t * y;
swap(x, y);
u -= t * v;
swap(u, v);
}
u %= m;
if (u < 0)
u += m;
return u;
}
int64_t cm(int n, int k) {
int i;
int64_t r = 1, x = 1, y = 1;
if (n < k)
return 0;
else if (n == k)
return 1;
else if (k == 1)
return n;
if (k > n - k)
k = n - k;
for (i = 0; i < k; i++) {
x *= n - i;
y *= k - i;
x %= mod;
y %= mod;
}
return x * modinv(y, mod) % mod;
}
int main() {
int N, K, i;
cin >> N >> K;
for (i = 0; i < K; i++)
cout << (cm(N - K + 1, i + 1) * cm(K - 1, i)) % mod << endl;
} | [
"call.arguments.change"
] | 798,437 | 798,438 | u211109468 | cpp |
p02990 | #include <bits/stdc++.h>
#define me(a, x) memset(a, x, sizeof(a))
#define sc scanf
#define itn int
using namespace std;
const int N = 1e6;
const long long mod = 1e9 + 7;
const int oo = 0x7fffffff;
const int sup = 0x80000000;
typedef long long ll;
typedef unsigned long long ull;
template <typename it> void db(it *begin, it *end) {
while (begin != end)
cout << (*begin++) << " ";
puts("");
}
template <typename it> string to_str(it n) {
string s = "";
while (n)
s += n % 10 + '0', n /= 10;
reverse(s.begin(), s.end());
return s;
}
template <typename it> int o(it a) {
cout << a << endl;
return 0;
}
ll mul(ll a, ll b, ll c) {
ll ans = 0;
for (; b; b >>= 1, a = (a + a) % c)
if (b & 1)
ans = (ans + a) % c;
return ans;
}
ll ksm(ll a, ll b, ll c) {
ll ans = 1;
for (; b; b >>= 1, a = mul(a, a, c))
if (b & 1)
ans = mul(ans, a, c);
return ans;
}
int n, k;
ll dp[3005][3005];
int main() {
for (int i = 1; i < 3005; i++)
dp[i][0] = 1;
for (int i = 1; i < 3005; i++)
for (int j = 1; j <= i; j++)
dp[i][j] = (dp[i - 1][j] + dp[i - 1][j - 1]) % mod;
cin >> n >> k;
for (itn i = 0; i < k; i++)
o(dp[k - 1][i] * dp[n - k + 1][i + 1] % mod);
}
| #include <bits/stdc++.h>
#define me(a, x) memset(a, x, sizeof(a))
#define sc scanf
#define itn int
using namespace std;
const int N = 1e6;
const long long mod = 1e9 + 7;
const int oo = 0x7fffffff;
const int sup = 0x80000000;
typedef long long ll;
typedef unsigned long long ull;
template <typename it> void db(it *begin, it *end) {
while (begin != end)
cout << (*begin++) << " ";
puts("");
}
template <typename it> string to_str(it n) {
string s = "";
while (n)
s += n % 10 + '0', n /= 10;
reverse(s.begin(), s.end());
return s;
}
template <typename it> int o(it a) {
cout << a << endl;
return 0;
}
ll mul(ll a, ll b, ll c) {
ll ans = 0;
for (; b; b >>= 1, a = (a + a) % c)
if (b & 1)
ans = (ans + a) % c;
return ans;
}
ll ksm(ll a, ll b, ll c) {
ll ans = 1;
for (; b; b >>= 1, a = mul(a, a, c))
if (b & 1)
ans = mul(ans, a, c);
return ans;
}
int n, k;
ll dp[3005][3005];
int main() {
for (int i = 0; i < 3005; i++)
dp[i][0] = 1;
for (int i = 1; i < 3005; i++)
for (int j = 1; j <= i; j++)
dp[i][j] = (dp[i - 1][j] + dp[i - 1][j - 1]) % mod;
cin >> n >> k;
for (itn i = 0; i < k; i++)
o(dp[k - 1][i] * dp[n - k + 1][i + 1] % mod);
}
| [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 798,439 | 798,440 | u433172603 | cpp |
p02990 | #include <bits/stdc++.h>
#define me(a, x) memset(a, x, sizeof(a))
#define sc scanf
#define itn int
using namespace std;
const int N = 1e6;
const long long mod = 1e9 + 7;
const int oo = 0x7fffffff;
const int sup = 0x80000000;
typedef long long ll;
typedef unsigned long long ull;
template <typename it> void db(it *begin, it *end) {
while (begin != end)
cout << (*begin++) << " ";
puts("");
}
template <typename it> string to_str(it n) {
string s = "";
while (n)
s += n % 10 + '0', n /= 10;
reverse(s.begin(), s.end());
return s;
}
template <typename it> int o(it a) {
cout << a << endl;
return 0;
}
ll mul(ll a, ll b, ll c) {
ll ans = 0;
for (; b; b >>= 1, a = (a + a) % c)
if (b & 1)
ans = (ans + a) % c;
return ans;
}
ll ksm(ll a, ll b, ll c) {
ll ans = 1;
for (; b; b >>= 1, a = mul(a, a, c))
if (b & 1)
ans = mul(ans, a, c);
return ans;
}
int n, k;
ll dp[3005][3005];
int main() {
for (int i = 1; i < 3005; i++)
dp[i][0] = 1;
for (int i = 1; i < 3005; i++)
for (int j = 1; j <= i; j++)
dp[i][j] = (dp[i - 1][j] + dp[i - 1][j - 1]) % mod;
cin >> n >> k;
for (itn i = 0; i < k; i++)
o(dp[k - 1][i] * dp[n - k + 1][i + 1] % mod);
}
| #include <bits/stdc++.h>
#define me(a, x) memset(a, x, sizeof(a))
#define sc scanf
#define itn int
using namespace std;
const int N = 1e6;
const long long mod = 1e9 + 7;
const int oo = 0x7fffffff;
const int sup = 0x80000000;
typedef long long ll;
typedef unsigned long long ull;
template <typename it> void db(it *begin, it *end) {
while (begin != end)
cout << (*begin++) << " ";
puts("");
}
template <typename it> string to_str(it n) {
string s = "";
while (n)
s += n % 10 + '0', n /= 10;
reverse(s.begin(), s.end());
return s;
}
template <typename it> int o(it a) {
cout << a << endl;
return 0;
}
ll mul(ll a, ll b, ll c) {
ll ans = 0;
for (; b; b >>= 1, a = (a + a) % c)
if (b & 1)
ans = (ans + a) % c;
return ans;
}
ll ksm(ll a, ll b, ll c) {
ll ans = 1;
for (; b; b >>= 1, a = mul(a, a, c))
if (b & 1)
ans = mul(ans, a, c);
return ans;
}
int n, k;
ll dp[3005][3005];
int main() {
for (int i = 0; i < 3005; i++)
dp[i][0] = 1;
for (int i = 1; i < 3005; i++)
for (int j = 1; j <= i; j++)
dp[i][j] = (dp[i - 1][j] + dp[i - 1][j - 1]) % mod;
cin >> n >> k;
for (itn i = 0; i < k; i++)
o(1ll * dp[k - 1][i] * dp[n - k + 1][i + 1] % mod);
}
| [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 798,439 | 798,441 | u433172603 | cpp |
p02990 | #include <bits/stdc++.h>
#define FOR(i, a, b) for (int i = (a); i < (int)(b); ++i)
#define REP(i, n) FOR(i, 0, n)
using namespace std;
typedef long long ll;
// https://youtu.be/L8grWxBlIZ4?t=9858
// https://youtu.be/ERZuLAxZffQ?t=4765
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 c[4005][4005];
void init() {
c[0][0] = 1;
REP(i, 40001) {
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 (n < 1)
return 0;
return f2(n - k, k);
}
int main() {
init();
int n, k;
cin >> n >> k;
for (int i = 1; i <= k; i++) {
mint blue = f(k, i);
mint red = 0;
{
red += f(n - k, i - 1);
red += f(n - k, i);
red += f(n - k, i);
red += f(n - k, i + 1);
}
mint ans = blue * red;
cout << ans.x << endl;
}
}
| #include <bits/stdc++.h>
#define FOR(i, a, b) for (int i = (a); i < (int)(b); ++i)
#define REP(i, n) FOR(i, 0, n)
using namespace std;
typedef long long ll;
// https://youtu.be/L8grWxBlIZ4?t=9858
// https://youtu.be/ERZuLAxZffQ?t=4765
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 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 (n < 1)
return 0;
return f2(n - k, k);
}
int main() {
init();
int n, k;
cin >> n >> k;
for (int i = 1; i <= k; i++) {
mint blue = f(k, i);
mint red = 0;
{
red += f(n - k, i - 1);
red += f(n - k, i);
red += f(n - k, i);
red += f(n - k, i + 1);
}
mint ans = blue * red;
cout << ans.x << endl;
}
}
| [
"literal.number.change",
"call.arguments.change"
] | 798,446 | 798,447 | u538853954 | cpp |
p02990 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<int, P> P1;
typedef pair<P, P> P2;
#define pu push
#define pb push_back
#define mp make_pair
#define eps 1e-7
#define INF 1000000000
#define fi first
#define sc second
#define rep(i, x) for (int i = 0; i < x; i++)
#define repn(i, x) for (int i = 1; i <= x; i++)
#define SORT(x) sort(x.begin(), x.end())
#define ERASE(x) x.erase(unique(x.begin(), x.end()), x.end())
#define POSL(x, v) (lower_bound(x.begin(), x.end(), v) - x.begin())
#define POSU(x, v) (upper_bound(x.begin(), x.end(), v) - x.begin())
const int MAX = 510000;
const int MOD = 1000000007;
long long fac[MAX], finv[MAX], inv[MAX];
// a^n mod を計算する
long long modpow(long long a, long long n, long long mod) {
long long res = 1;
while (n > 0) {
if (n & 1)
res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
// テーブルを作る前処理
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;
ll i, j, k, l;
// 前処理
COMinit();
ll ans;
repn(i, K) {
if (i > N - K + 1)
cout << 0 << endl;
else {
ll tmp1, tmp2;
tmp1 = COM(N - K + 1, i);
tmp2 = COM(K - 1, i - 1);
ans = tmp1 * tmp2;
cout << ans << endl;
}
}
}
| #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<int, P> P1;
typedef pair<P, P> P2;
#define pu push
#define pb push_back
#define mp make_pair
#define eps 1e-7
#define INF 1000000000
#define fi first
#define sc second
#define rep(i, x) for (int i = 0; i < x; i++)
#define repn(i, x) for (int i = 1; i <= x; i++)
#define SORT(x) sort(x.begin(), x.end())
#define ERASE(x) x.erase(unique(x.begin(), x.end()), x.end())
#define POSL(x, v) (lower_bound(x.begin(), x.end(), v) - x.begin())
#define POSU(x, v) (upper_bound(x.begin(), x.end(), v) - x.begin())
const int MAX = 510000;
const int MOD = 1000000007;
long long fac[MAX], finv[MAX], inv[MAX];
// a^n mod を計算する
long long modpow(long long a, long long n, long long mod) {
long long res = 1;
while (n > 0) {
if (n & 1)
res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
// テーブルを作る前処理
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;
ll i, j, k, l;
// 前処理
COMinit();
ll ans;
repn(i, K) {
if (i > N - K + 1)
cout << 0 << endl;
else {
ll tmp1, tmp2;
tmp1 = COM(N - K + 1, i);
tmp2 = COM(K - 1, i - 1);
ans = tmp1 * tmp2 % MOD;
cout << ans << endl;
}
}
}
| [
"assignment.change"
] | 798,448 | 798,449 | u284045566 | cpp |
p02990 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<int, P> P1;
typedef pair<P, P> P2;
#define pu push
#define pb push_back
#define mp make_pair
#define eps 1e-7
#define INF 1000000000
#define fi first
#define sc second
#define rep(i, x) for (int i = 0; i < x; i++)
#define repn(i, x) for (int i = 1; i <= x; i++)
#define SORT(x) sort(x.begin(), x.end())
#define ERASE(x) x.erase(unique(x.begin(), x.end()), x.end())
#define POSL(x, v) (lower_bound(x.begin(), x.end(), v) - x.begin())
#define POSU(x, v) (upper_bound(x.begin(), x.end(), v) - x.begin())
const int MAX = 510000;
const int MOD = 1000000007;
long long fac[MAX], finv[MAX], inv[MAX];
// a^n mod を計算する
long long modpow(long long a, long long n, long long mod) {
long long res = 1;
while (n > 0) {
if (n & 1)
res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
// テーブルを作る前処理
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;
ll i, j, k, l;
// 前処理
COMinit();
ll ans;
repn(i, K) {
if (i >= N - K + 1)
cout << 0 << endl;
else {
ll tmp1, tmp2;
tmp1 = COM(N - K + 1, i);
tmp2 = COM(K - 1, i - 1);
ans = tmp1 * tmp2;
cout << ans << endl;
}
}
}
| #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<int, P> P1;
typedef pair<P, P> P2;
#define pu push
#define pb push_back
#define mp make_pair
#define eps 1e-7
#define INF 1000000000
#define fi first
#define sc second
#define rep(i, x) for (int i = 0; i < x; i++)
#define repn(i, x) for (int i = 1; i <= x; i++)
#define SORT(x) sort(x.begin(), x.end())
#define ERASE(x) x.erase(unique(x.begin(), x.end()), x.end())
#define POSL(x, v) (lower_bound(x.begin(), x.end(), v) - x.begin())
#define POSU(x, v) (upper_bound(x.begin(), x.end(), v) - x.begin())
const int MAX = 510000;
const int MOD = 1000000007;
long long fac[MAX], finv[MAX], inv[MAX];
// a^n mod を計算する
long long modpow(long long a, long long n, long long mod) {
long long res = 1;
while (n > 0) {
if (n & 1)
res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
// テーブルを作る前処理
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;
ll i, j, k, l;
// 前処理
COMinit();
ll ans;
repn(i, K) {
if (i > N - K + 1)
cout << 0 << endl;
else {
ll tmp1, tmp2;
tmp1 = COM(N - K + 1, i);
tmp2 = COM(K - 1, i - 1);
ans = tmp1 * tmp2 % MOD;
cout << ans << endl;
}
}
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"assignment.change"
] | 798,450 | 798,449 | u284045566 | cpp |
p02990 | #include <iostream>
using namespace std;
const int M = 1000000007;
int a[2001][2001];
int n, k;
int main() {
cin >> n >> k;
a[0][0] = 1;
for (int i = 1; i <= n; i++) {
a[i][0] = 1;
for (int j = 1; j <= i; j++)
a[i][j] = (a[i - 1][j - 1] + a[i - 1][j]) % M;
}
for (int i = 1; i <= k; i++) {
long long t = (a[k - 1][i - 1] * a[n - k + 1][i]) % M;
cout << t << endl;
}
return 0;
} | #include <iostream>
using namespace std;
const int M = 1000000007;
long long a[2001][2001];
int n, k;
int main() {
cin >> n >> k;
a[0][0] = 1;
for (int i = 1; i <= n; i++) {
a[i][0] = 1;
for (int j = 1; j <= i; j++)
a[i][j] = (a[i - 1][j - 1] + a[i - 1][j]) % M;
}
for (int i = 1; i <= k; i++) {
long long t = (a[k - 1][i - 1] * a[n - k + 1][i]) % M;
cout << t << endl;
}
return 0;
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 798,451 | 798,452 | u597243424 | cpp |
p02990 | #include <bits/stdc++.h>
#define nmax_def 2200
#define mod_def 1000000007
using namespace std;
typedef long long ll;
ll nCm_array[nmax_def][nmax_def];
void nCm(int N) {
int i, j;
for (i = 0; i < N; i++) {
for (j = 0; j <= i; j++) {
ll ans;
if ((j == 0) || (j == i))
ans = 1;
else if ((j == 1) || (j == i - 1))
ans = i;
else
ans = nCm_array[i - 1][j] + nCm_array[i - 1][j - 1];
ans %= mod_def;
nCm_array[i][j] = ans;
}
}
}
int main() {
ll i, j;
ll N, K;
cin >> N >> K;
nCm(N);
for (i = 1; i <= K; i++) {
ll ans;
if (N - K + 1 >= i)
ans = nCm_array[N - K + 1][i] * nCm_array[K - 1][i - 1];
else
ans = 0;
ans %= mod_def;
cout << ans << endl;
}
return 0;
} | #include <bits/stdc++.h>
#define nmax_def 2200
#define mod_def 1000000007
using namespace std;
typedef long long ll;
ll nCm_array[nmax_def][nmax_def];
void nCm(int N) {
ll i, j;
for (i = 0; i < N; i++) {
for (j = 0; j <= i; j++) {
ll ans;
if ((j == 0) || (j == i))
ans = 1;
else if ((j == 1) || (j == i - 1))
ans = i;
else
ans = nCm_array[i - 1][j] + nCm_array[i - 1][j - 1];
ans %= mod_def;
nCm_array[i][j] = ans;
}
}
}
int main() {
ll i, j;
ll N, K;
cin >> N >> K;
nCm(N + 10);
for (i = 1; i <= K; i++) {
ll ans;
if (N - K + 1 >= i)
ans = nCm_array[N - K + 1][i] * nCm_array[K - 1][i - 1];
else
ans = 0;
ans %= mod_def;
cout << ans << endl;
}
return 0;
} | [
"variable_declaration.type.change"
] | 798,453 | 798,454 | u541884637 | cpp |
p02990 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <numeric>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
using pll = pair<ll, ll>;
const auto INF = static_cast<ll>(1e15);
const auto MOD = static_cast<ll>(1e9 + 7);
/*********** Variables ***********/
ll N, K;
ll fac[2001], finv[2001], inv[2001];
/*********** Functions ***********/
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (ll i = 2; i < 2001; 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)
return 0;
if (n < 0 || r < 0)
return 0;
return fac[n] * (finv[r] * finv[n - r] % MOD) % MOD;
}
int main() {
COMinit();
cin >> N >> K;
for (int i = 1; i <= K; i++) {
ll ret = comb(K - 1, i - 1);
if (N - K < i - 1) {
cout << 0 << endl;
continue;
}
ret *= comb(N - K + 1, i) % MOD;
cout << ret << endl;
}
return 0;
}
| #include <algorithm>
#include <cmath>
#include <iostream>
#include <numeric>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
using pll = pair<ll, ll>;
const auto INF = static_cast<ll>(1e15);
const auto MOD = static_cast<ll>(1e9 + 7);
/*********** Variables ***********/
ll N, K;
ll fac[2001], finv[2001], inv[2001];
/*********** Functions ***********/
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (ll i = 2; i < 2001; 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)
return 0;
if (n < 0 || r < 0)
return 0;
return fac[n] * (finv[r] * finv[n - r] % MOD) % MOD;
}
int main() {
COMinit();
cin >> N >> K;
for (int i = 1; i <= K; i++) {
ll ret = comb(K - 1, i - 1);
if (N - K < i - 1) {
cout << 0 << endl;
continue;
}
ret *= comb(N - K + 1, i) % MOD;
cout << ret % MOD << endl;
}
return 0;
}
| [
"expression.operation.binary.add"
] | 798,455 | 798,456 | u634208461 | cpp |
p02990 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <numeric>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
using pll = pair<ll, ll>;
const auto INF = static_cast<ll>(1e15);
const auto MOD = static_cast<ll>(1e9 + 7);
/*********** Variables ***********/
ll N, K;
ll fac[2001], finv[2001], inv[2001];
/*********** Functions ***********/
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (ll i = 2; i < 2001; 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)
return 0;
if (n < 0 || r < 0)
return 0;
return fac[n] * (finv[r] * finv[n - r] % MOD) % MOD;
}
int main() {
COMinit();
cin >> N >> K;
for (int i = 1; i <= K; i++) {
ll ret = comb(K - 1, i - 1);
ret *= comb(N - K + 1, i) % MOD;
cout << ret << endl;
}
return 0;
}
| #include <algorithm>
#include <cmath>
#include <iostream>
#include <numeric>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
using pll = pair<ll, ll>;
const auto INF = static_cast<ll>(1e15);
const auto MOD = static_cast<ll>(1e9 + 7);
/*********** Variables ***********/
ll N, K;
ll fac[2001], finv[2001], inv[2001];
/*********** Functions ***********/
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (ll i = 2; i < 2001; 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)
return 0;
if (n < 0 || r < 0)
return 0;
return fac[n] * (finv[r] * finv[n - r] % MOD) % MOD;
}
int main() {
COMinit();
cin >> N >> K;
for (int i = 1; i <= K; i++) {
ll ret = comb(K - 1, i - 1);
ret *= comb(N - K + 1, i) % MOD;
cout << ret % MOD << endl;
}
return 0;
}
| [
"expression.operation.binary.add"
] | 798,457 | 798,458 | u634208461 | cpp |
p02990 | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <vector>
using namespace std;
#define MAXN 2000
#define MOD 1000000007
#define LL long long
int n, k, r;
LL Comb[MAXN + 5][MAXN + 5];
int main() {
scanf("%d%d", &n, &k);
r = n - k;
for (int i = 0; i <= MAXN; i++)
for (int j = 0; j <= i; j++)
if (!j || i == j)
Comb[i][j] = 1;
else
Comb[i][j] = (Comb[i - 1][j] + Comb[i][j - 1]) % MOD;
for (int i = 0; i < k; i++) {
if (i == 0) {
printf("%d\n", r + 1);
continue;
}
LL ans = 0;
for (int j = i; j <= r; j++)
ans = (ans +
(Comb[k - 1][i] * (r - j + 1)) % MOD * Comb[j - 1][i - 1] % MOD) %
MOD;
printf("%lld\n", ans);
}
} | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <vector>
using namespace std;
#define MAXN 2000
#define MOD 1000000007
#define LL long long
int n, k, r;
LL Comb[MAXN + 5][MAXN + 5];
int main() {
scanf("%d%d", &n, &k);
r = n - k;
for (int i = 0; i <= MAXN; i++)
for (int j = 0; j <= i; j++)
if (!j || i == j)
Comb[i][j] = 1;
else
Comb[i][j] = (Comb[i - 1][j] + Comb[i - 1][j - 1]) % MOD;
for (int i = 0; i < k; i++) {
if (i == 0) {
printf("%d\n", r + 1);
continue;
}
LL ans = 0;
for (int j = i; j <= r; j++)
ans = (ans +
(Comb[k - 1][i] * (r - j + 1)) % MOD * Comb[j - 1][i - 1] % MOD) %
MOD;
printf("%lld\n", ans);
}
}
| [
"assignment.change"
] | 798,459 | 798,460 | u294179241 | cpp |
p02990 | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <vector>
using namespace std;
#define MAXN 2000
#define MOD 1000000007
#define LL long long
int n, k, r;
LL Comb[MAXN + 5][MAXN + 5];
int main() {
scanf("%d%d", &n, &k);
r = n - k;
for (int i = 0; i <= MAXN; i++)
for (int j = 0; j <= MAXN; j++)
if (!j || i == j)
Comb[i][j] = 1;
else
Comb[i][j] = (Comb[i - 1][j] + Comb[i][j - 1]) % MOD;
for (int i = 0; i < k; i++) {
if (i == 0) {
printf("%d\n", r + 1);
continue;
}
LL ans = 0;
for (int j = i; j <= r; j++)
ans = (ans +
(Comb[k - 1][i] * (r - j + 1)) % MOD * Comb[j - 1][i - 1] % MOD) %
MOD;
printf("%lld\n", ans);
}
} | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <vector>
using namespace std;
#define MAXN 2000
#define MOD 1000000007
#define LL long long
int n, k, r;
LL Comb[MAXN + 5][MAXN + 5];
int main() {
scanf("%d%d", &n, &k);
r = n - k;
for (int i = 0; i <= MAXN; i++)
for (int j = 0; j <= i; j++)
if (!j || i == j)
Comb[i][j] = 1;
else
Comb[i][j] = (Comb[i - 1][j] + Comb[i - 1][j - 1]) % MOD;
for (int i = 0; i < k; i++) {
if (i == 0) {
printf("%d\n", r + 1);
continue;
}
LL ans = 0;
for (int j = i; j <= r; j++)
ans = (ans +
(Comb[k - 1][i] * (r - j + 1)) % MOD * Comb[j - 1][i - 1] % MOD) %
MOD;
printf("%lld\n", ans);
}
}
| [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"assignment.change"
] | 798,461 | 798,460 | u294179241 | cpp |
p02990 | #include <bits/stdc++.h>
using namespace std;
const int N = 100 * 1000 + 17;
const int MOD = 1000 * 1000 * 1000 + 7;
int n, k;
long long F[N];
bool read() {
if (!(cin >> n >> k))
return false;
return true;
}
long long binpow(long long a, int n) {
auto res = 1ll;
for (; n > 0; n /= 2, a = a * a % MOD)
if (n & 1)
res = res * a % MOD;
return res;
}
long long rev(long long x) { return binpow(x, MOD - 2); }
long long binomial(int n, int k) {
return n < k ? 0ll : F[n] * rev(F[k] * F[n - k]) % MOD;
}
void solve() {
F[0] = 1;
for (int i = 1; i <= n; ++i)
F[i] = i * F[i - 1] % MOD;
for (int i = 1; i <= k; ++i)
cout << binomial(k - 1, i - 1) * binomial(n - k + 1, i) % MOD << endl;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
while (read())
solve();
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
const int N = 100 * 1000 + 17;
const int MOD = 1000 * 1000 * 1000 + 7;
int n, k;
long long F[N];
bool read() {
if (!(cin >> n >> k))
return false;
return true;
}
long long binpow(long long a, int n) {
auto res = 1ll;
for (; n > 0; n /= 2, a = a * a % MOD)
if (n & 1)
res = res * a % MOD;
return res;
}
long long rev(long long x) { return binpow(x, MOD - 2); }
long long binomial(int n, int k) {
return n < k ? 0ll : F[n] * rev(F[k] * F[n - k] % MOD) % MOD;
}
void solve() {
F[0] = 1;
for (int i = 1; i <= n; ++i)
F[i] = i * F[i - 1] % MOD;
for (int i = 1; i <= k; ++i)
cout << binomial(k - 1, i - 1) * binomial(n - k + 1, i) % MOD << endl;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
while (read())
solve();
return 0;
}
| [
"expression.operation.binary.add"
] | 798,462 | 798,463 | u138919616 | cpp |
p02990 | #include <bits/stdc++.h>
#define int long long
using namespace std;
typedef long long ll;
const int mod = 1e9 + 7;
ll factorial[10000];
void fac() {
factorial[0] = 1;
for (ll i = 1; i <= 2000; i++) {
factorial[i] = (factorial[i - 1] * i) % mod;
}
}
ll pow(ll a, ll b, ll MOD) {
ll x = 1, y = a;
while (b > 0) {
if (b % 2 == 1) {
x = (x * y);
if (x > MOD)
x %= MOD;
}
y = (y * y);
if (y > MOD)
y %= MOD;
b /= 2;
}
return x;
}
ll Inverse(ll n, ll MOD) { return pow(n, MOD - 2, MOD); }
ll binomial_coefficient(ll n, ll k) {
return (factorial[n] % mod * (Inverse(factorial[k], mod)) % mod *
(Inverse(factorial[n - k], mod)) % mod) %
mod;
}
signed main() {
int n, k;
cin >> n >> k;
fac();
int ans = 1;
for (int i = 1; i <= k; i++) {
if (n - k + 1 >= i)
ans = binomial_coefficient(n - k + 1, i);
if (k - 1 >= i - 1) {
ans = ans * binomial_coefficient(k - 1, i - 1);
ans = ans % mod;
}
cout << ans << endl;
}
} | #include <bits/stdc++.h>
#define int long long
using namespace std;
typedef long long ll;
const int mod = 1e9 + 7;
ll factorial[10000];
void fac() {
factorial[0] = 1;
for (ll i = 1; i <= 2000; i++) {
factorial[i] = (factorial[i - 1] * i) % mod;
}
}
ll pow(ll a, ll b, ll MOD) {
ll x = 1, y = a;
while (b > 0) {
if (b % 2 == 1) {
x = (x * y);
if (x > MOD)
x %= MOD;
}
y = (y * y);
if (y > MOD)
y %= MOD;
b /= 2;
}
return x;
}
ll Inverse(ll n, ll MOD) { return pow(n, MOD - 2, MOD); }
ll binomial_coefficient(ll n, ll k) {
return (factorial[n] % mod * (Inverse(factorial[k], mod)) % mod *
(Inverse(factorial[n - k], mod)) % mod) %
mod;
}
signed main() {
int n, k;
cin >> n >> k;
fac();
int ans = 1;
for (int i = 1; i <= k; i++) {
ans = 0;
if (n - k + 1 >= i)
ans = binomial_coefficient(n - k + 1, i);
if (k - 1 >= i - 1) {
ans = ans * binomial_coefficient(k - 1, i - 1);
ans = ans % mod;
}
cout << ans << endl;
}
} | [
"assignment.add"
] | 798,471 | 798,472 | u428805520 | cpp |
p02990 | #include <bits/stdc++.h>
#include <cassert>
using namespace std;
typedef unsigned long long ll;
const ll MOD = 1e9 + 7;
ll ModPow(ll base, ll exp, ll mod) {
ll ret = 1;
base %= mod;
while (exp > 0) {
if (exp & 1)
ret = (ret * base) % mod;
base = (base * base) % mod;
exp >>= 1;
}
return ret;
}
ll ModInv(ll base, ll mod) { return ModPow(base, mod - 2, mod); }
ll Comb(ll n, ll r, ll fct[][4001]) {
assert(n > 2000);
return fct[0][n] * (fct[1][r] * fct[1][n - r] % MOD) % MOD;
}
int main() {
ll n, k;
cin >> n >> k;
ll fct[2][4001];
fct[0][0] = fct[0][1] = 1;
for (ll i = 2; i <= n; fct[0][i] %= MOD, i++)
fct[0][i] = fct[0][i - 1] * (i % MOD);
for (ll i = 0; i <= n; i++)
fct[1][i] = ModPow(fct[0][i], MOD - 2, MOD);
for (ll i = 0; i < k; i++)
cout << (Comb(k - 1, i, fct) * Comb(n - k + 1, i + 1, fct)) % MOD << endl;
return 0;
} | #include <bits/stdc++.h>
#include <cassert>
using namespace std;
typedef unsigned long long ll;
const ll MOD = 1e9 + 7;
ll ModPow(ll base, ll exp, ll mod) {
ll ret = 1;
base %= mod;
while (exp > 0) {
if (exp & 1)
ret = (ret * base) % mod;
base = (base * base) % mod;
exp >>= 1;
}
return ret;
}
ll ModInv(ll base, ll mod) { return ModPow(base, mod - 2, mod); }
ll Comb(ll n, ll r, ll fct[][4001]) {
assert(n <= 2000);
return fct[0][n] * (fct[1][r] * fct[1][n - r] % MOD) % MOD;
}
int main() {
ll n, k;
cin >> n >> k;
ll fct[2][4001];
fct[0][0] = fct[0][1] = 1;
for (ll i = 2; i <= n; fct[0][i] %= MOD, i++)
fct[0][i] = fct[0][i - 1] * (i % MOD);
for (ll i = 0; i <= n; i++)
fct[1][i] = ModPow(fct[0][i], MOD - 2, MOD);
for (ll i = 0; i < k; i++)
cout << (Comb(k - 1, i, fct) * Comb(n - k + 1, i + 1, fct)) % MOD << endl;
return 0;
} | [
"expression.operator.compare.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 798,478 | 798,479 | u581018765 | cpp |
p02990 | #include <iostream>
using namespace std;
typedef long long ll;
const ll MOD = 1e9 + 7;
ll ModPow(ll base, ll exp, ll mod) {
ll ret = 1;
base %= mod;
while (exp > 0) {
if (exp & 1)
ret = (ret * base) % mod;
base = (base * base) % mod;
exp >>= 1;
}
return ret;
}
ll ModInv(ll base, ll mod) { return ModPow(base, mod - 2, mod); }
ll Comb(ll n, ll r, ll *fct, ll *fct_inv) {
return fct[n] * (fct_inv[r] * fct_inv[n - r] % MOD) % MOD;
}
int main() {
ll n, k;
cin >> n >> k;
ll fct[5001];
fct[0] = fct[1] = 1;
for (ll i = 2; i <= n * 2; fct[i] %= MOD, i++)
fct[i] = fct[i - 1] * (i % MOD);
ll fct_inv[5001];
for (ll i = 0; i <= n * 2; i++)
fct_inv[i] = ModPow(fct[i], MOD - 2, MOD);
for (ll i = 0; i < k; i++)
cout << (Comb(k - 1, i, fct, fct_inv) *
Comb(n - k + 1, i + 1, fct, fct_inv)) %
MOD
<< endl;
return 0;
}
| #include <iostream>
using namespace std;
typedef long long ll;
const ll MOD = 1e9 + 7;
ll ModPow(ll base, ll exp, ll mod) {
ll ret = 1;
base %= mod;
while (exp > 0) {
if (exp & 1)
ret = (ret * base) % mod;
base = (base * base) % mod;
exp >>= 1;
}
return ret;
}
ll ModInv(ll base, ll mod) { return ModPow(base, mod - 2, mod); }
ll Comb(ll n, ll r, ll *fct, ll *fct_inv) {
return fct[n] * (fct_inv[r] * fct_inv[n - r] % MOD) % MOD;
}
int main() {
ll n, k;
cin >> n >> k;
ll fct[10001];
fct[0] = fct[1] = 1;
for (ll i = 2; i <= n * 4; fct[i] %= MOD, i++)
fct[i] = fct[i - 1] * (i % MOD);
ll fct_inv[10001];
for (ll i = 0; i <= n * 4; i++)
fct_inv[i] = ModPow(fct[i], MOD - 2, MOD);
for (ll i = 0; i < k; i++)
cout << (Comb(k - 1, i, fct, fct_inv) *
Comb(n - k + 1, i + 1, fct, fct_inv)) %
MOD
<< endl;
return 0;
} | [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 798,483 | 798,484 | u581018765 | cpp |
p02990 | #include <iostream>
using namespace std;
typedef long long ll;
const ll MOD = 1e9 + 7;
ll ModPow(ll base, ll exp, ll mod) {
ll ret = 1;
base %= mod;
while (exp > 0) {
if (exp & 1)
ret = (ret * base) % mod;
base = (base * base) % mod;
exp >>= 1;
}
return ret;
}
ll ModInv(ll base, ll mod) { return ModPow(base, mod - 2, mod); }
ll Comb(ll n, ll r, ll *fct, ll *fct_inv) {
return fct[n] * (fct_inv[r] * fct_inv[n - r] % MOD) % MOD;
}
int main() {
ll n, k;
cin >> n >> k;
ll fct[4001];
fct[0] = fct[1] = 1;
for (ll i = 2; i <= n * 2; fct[i] %= MOD, i++)
fct[i] = fct[i - 1] * (i % MOD);
ll fct_inv[4001];
for (ll i = 0; i <= n * 2; i++)
fct_inv[i] = ModPow(fct[i], MOD - 2, MOD);
for (ll i = 0; i < k; i++)
cout << (Comb(k - 1, i, fct, fct_inv) *
Comb(n - k + 1, i + 1, fct, fct_inv)) %
MOD
<< endl;
return 0;
}
| #include <iostream>
using namespace std;
typedef long long ll;
const ll MOD = 1e9 + 7;
ll ModPow(ll base, ll exp, ll mod) {
ll ret = 1;
base %= mod;
while (exp > 0) {
if (exp & 1)
ret = (ret * base) % mod;
base = (base * base) % mod;
exp >>= 1;
}
return ret;
}
ll ModInv(ll base, ll mod) { return ModPow(base, mod - 2, mod); }
ll Comb(ll n, ll r, ll *fct, ll *fct_inv) {
return fct[n] * (fct_inv[r] * fct_inv[n - r] % MOD) % MOD;
}
int main() {
ll n, k;
cin >> n >> k;
ll fct[10001];
fct[0] = fct[1] = 1;
for (ll i = 2; i <= n * 4; fct[i] %= MOD, i++)
fct[i] = fct[i - 1] * (i % MOD);
ll fct_inv[10001];
for (ll i = 0; i <= n * 4; i++)
fct_inv[i] = ModPow(fct[i], MOD - 2, MOD);
for (ll i = 0; i < k; i++)
cout << (Comb(k - 1, i, fct, fct_inv) *
Comb(n - k + 1, i + 1, fct, fct_inv)) %
MOD
<< endl;
return 0;
} | [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 798,485 | 798,484 | u581018765 | cpp |
p02990 | #include <iostream>
using namespace std;
typedef long long ll;
const ll MOD = 1e9 + 7;
ll ModPow(ll base, ll exp, ll mod) {
ll ret = 1;
base %= mod;
while (exp > 0) {
if (exp & 1)
ret = (ret * base) % mod;
base = (base * base) % mod;
exp >>= 1;
}
return ret;
}
ll ModInv(ll base, ll mod) { return ModPow(base, mod - 2, mod); }
ll Comb(ll n, ll r, ll *fct, ll *fct_inv) {
return fct[n] * (fct_inv[r] * fct_inv[n - r] % MOD) % MOD;
}
int main() {
ll n, k;
cin >> n >> k;
ll fct[10001];
fct[0] = fct[1] = 1;
for (ll i = 2; i <= n; fct[i] %= MOD, i++)
fct[i] = fct[i - 1] * (i % MOD);
ll fct_inv[10001];
for (ll i = 0; i <= n; i++)
fct_inv[i] = ModPow(fct[i], MOD - 2, MOD);
for (ll i = 0; i < k; i++)
cout << (Comb(k - 1, i, fct, fct_inv) *
Comb(n - k + 1, i + 1, fct, fct_inv)) %
MOD
<< endl;
return 0;
} | #include <iostream>
using namespace std;
typedef long long ll;
const ll MOD = 1e9 + 7;
ll ModPow(ll base, ll exp, ll mod) {
ll ret = 1;
base %= mod;
while (exp > 0) {
if (exp & 1)
ret = (ret * base) % mod;
base = (base * base) % mod;
exp >>= 1;
}
return ret;
}
ll ModInv(ll base, ll mod) { return ModPow(base, mod - 2, mod); }
ll Comb(ll n, ll r, ll *fct, ll *fct_inv) {
return fct[n] * (fct_inv[r] * fct_inv[n - r] % MOD) % MOD;
}
int main() {
ll n, k;
cin >> n >> k;
ll fct[10001];
fct[0] = fct[1] = 1;
for (ll i = 2; i <= n * 4; fct[i] %= MOD, i++)
fct[i] = fct[i - 1] * (i % MOD);
ll fct_inv[10001];
for (ll i = 0; i <= n * 4; i++)
fct_inv[i] = ModPow(fct[i], MOD - 2, MOD);
for (ll i = 0; i < k; i++)
cout << (Comb(k - 1, i, fct, fct_inv) *
Comb(n - k + 1, i + 1, fct, fct_inv)) %
MOD
<< endl;
return 0;
} | [
"control_flow.loop.for.condition.change"
] | 798,486 | 798,484 | u581018765 | cpp |
p02990 | #include <iostream>
using namespace std;
typedef long long ll;
const ll MOD = 1e9 + 7;
ll ModPow(ll base, ll exp, ll mod) {
ll ret = 1;
base %= mod;
while (exp > 0) {
if (exp & 1)
ret = (ret * base) % mod;
base = (base * base) % mod;
exp >>= 1;
}
return ret;
}
ll ModInv(ll base, ll mod) { return ModPow(base, mod - 2, mod); }
ll Comb(ll n, ll r, ll *fct, ll *fct_inv) {
return fct[n] * (fct_inv[r] * fct_inv[n - r] % MOD) % MOD;
}
int main() {
ll n, k;
cin >> n >> k;
ll fct[5001];
fct[0] = fct[1] = 1;
for (ll i = 2; i <= n; fct[i] %= MOD, i++)
fct[i] = fct[i - 1] * (i % MOD);
ll fct_inv[5001];
for (ll i = 0; i <= n; i++)
fct_inv[i] = ModPow(fct[i], MOD - 2, MOD);
for (ll i = 0; i < k; i++)
cout << (Comb(k - 1, i, fct, fct_inv) *
Comb(n - k + 1, i + 1, fct, fct_inv)) %
MOD
<< endl;
return 0;
} | #include <iostream>
using namespace std;
typedef long long ll;
const ll MOD = 1e9 + 7;
ll ModPow(ll base, ll exp, ll mod) {
ll ret = 1;
base %= mod;
while (exp > 0) {
if (exp & 1)
ret = (ret * base) % mod;
base = (base * base) % mod;
exp >>= 1;
}
return ret;
}
ll ModInv(ll base, ll mod) { return ModPow(base, mod - 2, mod); }
ll Comb(ll n, ll r, ll *fct, ll *fct_inv) {
return fct[n] * (fct_inv[r] * fct_inv[n - r] % MOD) % MOD;
}
int main() {
ll n, k;
cin >> n >> k;
ll fct[10001];
fct[0] = fct[1] = 1;
for (ll i = 2; i <= n * 4; fct[i] %= MOD, i++)
fct[i] = fct[i - 1] * (i % MOD);
ll fct_inv[10001];
for (ll i = 0; i <= n * 4; i++)
fct_inv[i] = ModPow(fct[i], MOD - 2, MOD);
for (ll i = 0; i < k; i++)
cout << (Comb(k - 1, i, fct, fct_inv) *
Comb(n - k + 1, i + 1, fct, fct_inv)) %
MOD
<< endl;
return 0;
} | [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"control_flow.loop.for.condition.change"
] | 798,487 | 798,484 | u581018765 | cpp |
p02990 | #include <iostream>
using namespace std;
typedef long long ll;
const ll MOD = 1e9 + 7;
ll ModPow(ll base, ll exp, ll mod) {
ll ret = 1;
base %= mod;
while (exp > 0) {
if (exp & 1)
ret = (ret * base) % mod;
base = (base * base) % mod;
exp >>= 1;
}
return ret;
}
ll ModInv(ll base, ll mod) { return ModPow(base, mod - 2, mod); }
ll Comb(ll n, ll r, ll *fct, ll *fct_inv) {
return fct[n] * (fct_inv[r] * fct_inv[n - r] % MOD) % MOD;
}
int main() {
ll n, k;
cin >> n >> k;
ll fct[4001];
fct[0] = fct[1] = 1;
for (ll i = 2; i <= n; fct[i] %= MOD, i++)
fct[i] = fct[i - 1] * (i % MOD);
ll fct_inv[4001];
for (ll i = 0; i <= n; i++)
fct_inv[i] = ModPow(fct[i], MOD - 2, MOD);
for (ll i = 0; i < k; i++)
cout << (Comb(k - 1, i, fct, fct_inv) *
Comb(n - k + 1, i + 1, fct, fct_inv)) %
MOD
<< endl;
return 0;
} | #include <iostream>
using namespace std;
typedef long long ll;
const ll MOD = 1e9 + 7;
ll ModPow(ll base, ll exp, ll mod) {
ll ret = 1;
base %= mod;
while (exp > 0) {
if (exp & 1)
ret = (ret * base) % mod;
base = (base * base) % mod;
exp >>= 1;
}
return ret;
}
ll ModInv(ll base, ll mod) { return ModPow(base, mod - 2, mod); }
ll Comb(ll n, ll r, ll *fct, ll *fct_inv) {
return fct[n] * (fct_inv[r] * fct_inv[n - r] % MOD) % MOD;
}
int main() {
ll n, k;
cin >> n >> k;
ll fct[10001];
fct[0] = fct[1] = 1;
for (ll i = 2; i <= n * 4; fct[i] %= MOD, i++)
fct[i] = fct[i - 1] * (i % MOD);
ll fct_inv[10001];
for (ll i = 0; i <= n * 4; i++)
fct_inv[i] = ModPow(fct[i], MOD - 2, MOD);
for (ll i = 0; i < k; i++)
cout << (Comb(k - 1, i, fct, fct_inv) *
Comb(n - k + 1, i + 1, fct, fct_inv)) %
MOD
<< endl;
return 0;
} | [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"control_flow.loop.for.condition.change"
] | 798,488 | 798,484 | u581018765 | cpp |
p02990 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
const ll MOD = 1e9 + 7;
long long factorial(long long n, long long mod) {
long long ret = 1;
for (long long i = 1; i <= n; i++) {
ret = (ret * i) % mod;
}
return ret;
}
long long inv_mod(long long n, long long mod) {
long long a = n % mod, b = mod - 2, ret = 1;
while (b > 0) {
if (b & 1)
ret = (ret * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return ret;
}
long long nPr(long long n, long long r, long long mod) {
long long ret = 1;
for (long long i = n; i >= n - r + 1; i--) {
ret = ret * (i % mod) % mod;
}
return ret;
}
long long nCr(long long n, long long r, long long mod) {
return nPr(n, r, mod) * inv_mod(factorial(r, mod), mod) % mod;
}
int main(int argc, char const *argv[]) {
ll n, k;
cin >> n >> k;
ll r = n - k;
for (int i = 1; i <= k; ++i) {
cout << nCr(r + 1, i, MOD) * nCr(k - 1, i - 1, MOD) << endl;
}
return 0;
} | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
const ll MOD = 1e9 + 7;
long long factorial(long long n, long long mod) {
long long ret = 1;
for (long long i = 1; i <= n; i++) {
ret = (ret * i) % mod;
}
return ret;
}
long long inv_mod(long long n, long long mod) {
long long a = n % mod, b = mod - 2, ret = 1;
while (b > 0) {
if (b & 1)
ret = (ret * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return ret;
}
long long nPr(long long n, long long r, long long mod) {
long long ret = 1;
for (long long i = n; i >= n - r + 1; i--) {
ret = ret * (i % mod) % mod;
}
return ret;
}
long long nCr(long long n, long long r, long long mod) {
return nPr(n, r, mod) * inv_mod(factorial(r, mod), mod) % mod;
}
int main(int argc, char const *argv[]) {
ll n, k;
cin >> n >> k;
ll r = n - k;
for (int i = 1; i <= k; ++i) {
cout << nCr(r + 1, i, MOD) * nCr(k - 1, i - 1, MOD) % MOD << endl;
}
return 0;
} | [
"expression.operation.binary.add"
] | 798,497 | 798,498 | u391752022 | cpp |
p02990 | #include <bits/stdc++.h>
#define rep(i, a, n) for (ll i = a; i < n; i++)
#define per(i, a, n) for (ll i = n - 1; i >= a; i--)
#define fill0(n) setfill('0') << right << setw(n)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define LONGMAX 1e18
#define intMAX 1000000000
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
const ll mod = 10e+7;
int n, k;
ll c[2001][2001];
void init() {
for (int i = 0; i < 2001; i++)
c[i][0] = 1;
for (int i = 1; i < 2001; i++) {
for (int j = 1; j < i + 1; j++) {
c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % mod;
}
// cout << n << endl;
}
}
int main() {
cin >> n >> k;
init();
for (int i = 1; i < k + 1; i++) {
// cout << c[n-k+1][i] << endl;
// cout << c[k-1][i-1] << endl;
ll ans = c[n - k + 1][i] * c[k - 1][i - 1];
// cout << ans << endl;
cout << ans % 1000000007 << endl;
}
} | #include <bits/stdc++.h>
#define rep(i, a, n) for (ll i = a; i < n; i++)
#define per(i, a, n) for (ll i = n - 1; i >= a; i--)
#define fill0(n) setfill('0') << right << setw(n)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define LONGMAX 1e18
#define intMAX 1000000000
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
const ll mod = 1e9 + 7;
ll n, k;
ll c[2001][2001];
void init() {
for (int i = 0; i < 2001; i++)
c[i][0] = 1;
for (int i = 1; i < 2001; i++) {
for (int j = 1; j < i + 1; j++) {
c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % mod;
}
}
// cout << c[5][2] << endl;
}
int main() {
cin >> n >> k;
init();
for (int i = 1; i < k + 1; i++) {
ll ans = c[n - k + 1][i] * c[k - 1][i - 1];
cout << ans % mod << endl;
}
} | [
"literal.number.change",
"variable_declaration.type.change",
"identifier.replace.add",
"literal.replace.remove",
"io.output.change"
] | 798,501 | 798,502 | u255001744 | cpp |
p02990 | #include <algorithm>
#include <cstring>
#include <iostream>
#include <vector>
#define SIZE 2001
#define MOD 1000000007
using namespace std;
long long dp[SIZE][SIZE];
void makePasTri(int n) {
dp[0][0] = 1;
for (int i = 1; i <= n + 1; i++) {
dp[i][0] = 1;
for (int j = 1; j <= i; j++) {
dp[i][j] = (dp[i - 1][j] + dp[i - 1][j - 1]) % MOD;
}
}
}
int main() {
int N, K;
cin >> N >> K;
makePasTri(N);
for (int i = 1; i <= K; i++) {
cout << dp[N - K + 1][i] * dp[K - 1][i - 1] % MOD << endl;
}
}
| #include <algorithm>
#include <cstring>
#include <iostream>
#include <vector>
#define SIZE 2001
#define MOD 1000000007
using namespace std;
long long dp[SIZE][SIZE];
void makePasTri(int n) {
dp[0][0] = 1;
for (int i = 1; i <= n; i++) {
dp[i][0] = 1;
for (int j = 1; j <= i; j++) {
dp[i][j] = (dp[i - 1][j] + dp[i - 1][j - 1]) % MOD;
}
}
}
int main() {
int N, K;
cin >> N >> K;
makePasTri(N);
for (int i = 1; i <= K; i++) {
cout << dp[N - K + 1][i] * dp[K - 1][i - 1] % MOD << endl;
}
}
| [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 798,507 | 798,508 | u817999507 | cpp |
p02990 | #include <bits/stdc++.h>
typedef long long ll;
using namespace std;
const int inf = 1e9;
const ll linf = 1e18;
const ll mod = 1e9 + 7;
int main() {
int N, K;
cin >> N >> K;
// combinationを計算
vector<vector<int>> comb(N + 1, vector<int>(N + 1, 1));
for (int i = 2; i <= N; i++) {
for (int j = 1; j <= i - 1; j++) {
comb[i][j] = (comb[i - 1][j - 1] + comb[i - 1][j]) % mod;
}
}
for (int i = 1; i <= K; i++) {
int ans =
(N - K + 1 >= i) ? (comb[K - 1][i - 1] * comb[N - K + 1][i]) % mod : 0;
cout << ans << endl;
}
return 0;
} | #include <bits/stdc++.h>
typedef long long ll;
using namespace std;
const int inf = 1e9;
const ll linf = 1e18;
const ll mod = 1e9 + 7;
int main() {
int N, K;
cin >> N >> K;
// combinationを計算
vector<vector<ll>> comb(N + 1, vector<ll>(N + 1, 1));
for (int i = 2; i <= N; i++) {
for (int j = 1; j <= i - 1; j++) {
comb[i][j] = (comb[i - 1][j - 1] + comb[i - 1][j]) % mod;
}
}
for (int i = 1; i <= K; i++) {
ll ans =
(N - K + 1 >= i) ? (comb[K - 1][i - 1] * comb[N - K + 1][i]) % mod : 0;
cout << ans << endl;
}
return 0;
}
| [
"call.arguments.change",
"variable_declaration.type.change"
] | 798,517 | 798,518 | u469953228 | cpp |
p02990 | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define pb push_back
#define mp make_pair
#define pii pair<int, int>
#define in freopen("input.txt", "r", stdin)
#define out freopen("output.txt", "w", stdout)
#define rep(i, n) for (int(i) = 0; (i) < (n); ++(i))
#define ref(i, a, b) for (int(i) = (a); (i) <= (b); ++(i))
#define INF 0xFFFFFF
#define endl '\n'
#define pp printf("Case %d: \n", t)
const unsigned int mod = 1e9 + 7;
const int mx = 2005;
const int maxInt = 2147483647;
ll pascal[mx][mx];
ll k, n;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> k;
for (int i = 0; i < mx; ++i) {
pascal[i][0] = 1;
for (int j = 1; j <= i; ++j) {
pascal[i][j] = pascal[i - 1][j] + pascal[i - 1][j - 1];
}
}
for (int i = 1; i <= k; ++i) {
cout << (pascal[n - k + 1][i] * pascal[k - 1][i - 1]) % mod << endl;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define pb push_back
#define mp make_pair
#define pii pair<int, int>
#define in freopen("input.txt", "r", stdin)
#define out freopen("output.txt", "w", stdout)
#define rep(i, n) for (int(i) = 0; (i) < (n); ++(i))
#define ref(i, a, b) for (int(i) = (a); (i) <= (b); ++(i))
#define INF 0xFFFFFF
#define endl '\n'
#define pp printf("Case %d: \n", t)
const unsigned int mod = 1e9 + 7;
const int mx = 2005;
const int maxInt = 2147483647;
ll pascal[mx][mx];
ll k, n;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> k;
for (int i = 0; i < mx; ++i) {
pascal[i][0] = 1;
for (int j = 1; j <= i; ++j) {
pascal[i][j] = (pascal[i - 1][j] + pascal[i - 1][j - 1]) % mod;
}
}
for (int i = 1; i <= k; ++i) {
cout << (pascal[n - k + 1][i] * pascal[k - 1][i - 1]) % mod << endl;
}
return 0;
}
| [
"assignment.change"
] | 798,525 | 798,526 | u361726856 | cpp |
p02990 | #include <iostream>
#include <vector>
using namespace std;
int main() {
int n;
int k;
cin >> n >> k;
int M = 1;
for (int i = 0; i < 9; i++) {
M *= 10;
}
M += 7;
int c[2][2000];
int d[2][2000];
for (int i = 0; i <= 2000; i++) {
for (int j = 0; j <= i; j++) {
if (j == 0 || j == i) {
c[i % 2][j] = 1;
} else {
c[i % 2][j] = (c[(i - 1) % 2][j - 1] + c[(i - 1) % 2][j]) % M;
}
if (i == k - 1) {
d[0][j] = c[i % 2][j];
}
if (i == n - k + 1) {
d[1][j] = c[i % 2][j];
}
}
if (i >= k - 1 && i >= n - k + 1) {
break;
}
}
for (int i = 1; i <= k; i++) {
if (k >= i - 1 && k <= n - i + 1) {
cout << (d[0][k - i] * d[1][i]) % M << endl;
} else {
cout << "0" << endl;
}
}
} | #include <iostream>
#include <vector>
using namespace std;
int main() {
int n;
int k;
cin >> n >> k;
int M = 1;
for (int i = 0; i < 9; i++) {
M *= 10;
}
M += 7;
long long int c[2][2000];
long long int d[2][2000];
for (int i = 0; i <= 2000; i++) {
for (int j = 0; j <= i; j++) {
if (j == 0 || j == i) {
c[i % 2][j] = 1;
} else {
c[i % 2][j] = (c[(i - 1) % 2][j - 1] + c[(i - 1) % 2][j]) % M;
}
if (i == k - 1) {
d[0][j] = c[i % 2][j];
}
if (i == n - k + 1) {
d[1][j] = c[i % 2][j];
}
}
if (i >= k - 1 && i >= n - k + 1) {
break;
}
}
for (int i = 1; i <= k; i++) {
if (k >= i - 1 && k <= n - i + 1) {
cout << (d[0][k - i] * d[1][i]) % M << endl;
} else {
cout << "0" << endl;
}
}
} | [
"variable_declaration.type.widen.change"
] | 798,533 | 798,534 | u045575753 | cpp |
p02990 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef int _loop_int;
#define REP(i, n) for (_loop_int i = 0; i < (_loop_int)(n); ++i)
#define FOR(i, a, b) for (_loop_int i = (_loop_int)(a); i < (_loop_int)(b); ++i)
#define FORR(i, a, b) \
for (_loop_int i = (_loop_int)(b)-1; i >= (_loop_int)(a); --i)
#define DEBUG(x) cout << #x << ": " << x << endl
#define DEBUG_VEC(v) \
cout << #v << ":"; \
REP(i, v.size()) cout << " " << v[i]; \
cout << endl
#define ALL(a) (a).begin(), (a).end()
// mod
const ll MOD = 1000000007ll;
#define FIX(a) ((a) % MOD + MOD) % MOD
const ll COMBMAX = 210000;
ll fact[COMBMAX];
ll inv[COMBMAX];
ll finv[COMBMAX];
void combinit() {
fact[0] = finv[0] = 1;
inv[1] = 1;
for (int i = 2; i < COMBMAX; i++) {
inv[i] = (MOD - (MOD / i) * inv[MOD % i] % MOD) % MOD;
}
for (int i = 1; i < COMBMAX; i++) {
fact[i] = fact[i - 1] * i % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
ll comb(int a, int b) {
if (a < b || b < 0)
return 0;
return fact[a] * finv[b] % MOD * finv[a - b] % MOD;
}
ll ans = 0;
int main() {
int n, k;
cin >> n >> k;
int blue = k;
int red = n - k;
combinit();
FOR(i, 1, blue + 1) {
ans = 0;
ans += comb(red + 1, i) * comb(blue - 1, i - 1);
cout << ans << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef int _loop_int;
#define REP(i, n) for (_loop_int i = 0; i < (_loop_int)(n); ++i)
#define FOR(i, a, b) for (_loop_int i = (_loop_int)(a); i < (_loop_int)(b); ++i)
#define FORR(i, a, b) \
for (_loop_int i = (_loop_int)(b)-1; i >= (_loop_int)(a); --i)
#define DEBUG(x) cout << #x << ": " << x << endl
#define DEBUG_VEC(v) \
cout << #v << ":"; \
REP(i, v.size()) cout << " " << v[i]; \
cout << endl
#define ALL(a) (a).begin(), (a).end()
// mod
const ll MOD = 1000000007ll;
#define FIX(a) ((a) % MOD + MOD) % MOD
const ll COMBMAX = 210000;
ll fact[COMBMAX];
ll inv[COMBMAX];
ll finv[COMBMAX];
void combinit() {
fact[0] = finv[0] = 1;
inv[1] = 1;
for (int i = 2; i < COMBMAX; i++) {
inv[i] = (MOD - (MOD / i) * inv[MOD % i] % MOD) % MOD;
}
for (int i = 1; i < COMBMAX; i++) {
fact[i] = fact[i - 1] * i % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
ll comb(int a, int b) {
if (a < b || b < 0)
return 0;
return fact[a] * finv[b] % MOD * finv[a - b] % MOD;
}
ll ans = 0;
int main() {
int n, k;
cin >> n >> k;
int blue = k;
int red = n - k;
combinit();
FOR(i, 1, blue + 1) {
ans = 0;
ans += comb(red + 1, i) * comb(blue - 1, i - 1);
cout << ans % MOD << endl;
}
return 0;
} | [
"expression.operation.binary.add"
] | 798,535 | 798,536 | u568353080 | cpp |
p02990 | #include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int i = a; i < b; i++)
#define REP(i, b) FOR(i, 0, b)
#define RFOR(i, a, b) for (int i = a - 1; i >= b; i--)
#define RREP(i, a) RFOR(i, a, 0)
#define REPALL(i, v) for (int i = 0; i < v.size(); i++)
#define RREPALL(i, v) for (int i = v.size() - 1; i >= 0; i--)
#define ALL(v) v.begin(), v.end()
#define SORT(v) sort(v.begin(), v.end())
#define MIN_ELEMENT(v) min_element(v.begin(), v.end())
#define MAX_ELEMENT(v) max_element(v.begin(), v.end())
#define COUNT(v, n) count(v.begin(), v.end(), n)
void YES(bool flag) { cout << (flag ? "YES" : "NO") << endl; }
void Yes(bool flag) { cout << (flag ? "Yes" : "No") << endl; }
void yes(bool flag) { cout << (flag ? "yes" : "no") << endl; }
typedef long long ll;
typedef unsigned long long ull;
const int INF = 1e7;
const ll MOD = 1e9 + 7;
//最大公約数
ll GCD(ll a, ll b) {
if (a == b || b == 0) {
return a;
} else if (a < b) {
return GCD(b, a);
} else {
return GCD(b, a % b);
}
}
//最小公倍数
ll LCM(ll a, ll b) { return a * b / GCD(a, b); }
vector<ll> primenum;
void get_prime_nembers(ll n) {
ll m = n;
FOR(i, 2, m + 1) {
bool flag = true;
REPALL(j, primenum) {
if (i % primenum[j] == 0) {
flag = false;
break;
}
}
if (flag) {
primenum.push_back(i);
while (m % i == 0) {
m /= i;
}
}
if (i > sqrt(n) + 1) {
primenum.push_back(m);
break;
}
}
}
vector<pair<int, int>> prime_factorization(ll n) {
if (primenum.empty())
get_prime_nembers(n);
vector<pair<int, int>> rtn;
REPALL(i, primenum) {
int num = 0;
ll tmpn = n;
while (tmpn % primenum[i] == 0) {
num++;
tmpn /= primenum[i];
}
if (num > 0)
rtn.push_back(make_pair(primenum[i], num));
}
return rtn;
}
ll mypow(ll a, ll b) {
ll r = 1ll;
while (b != 0) {
if (b & 1)
r = r * a % MOD;
a = a * a % MOD;
b /= 2;
}
return r;
}
vector<ll> fac;
vector<ll> ifac;
void factorial_init(ll n) {
fac.resize(n + 1);
ifac.resize(n + 1);
fac[0] = 1;
ifac[0] = 1;
REP(i, n) {
fac[i + 1] = fac[i] * (i + 1) % MOD;
ifac[i + 1] = ifac[i] * mypow(i + 1, MOD - 2) % MOD;
}
}
ll Combination(ll a, ll b) {
if (a == 0 && b == 0)
return 1;
if (a < b || a < 0)
return 0;
ll r = ifac[a - b] * ifac[b] % MOD;
return r * fac[a] % MOD;
}
int main() {
int n, k;
cin >> n >> k;
factorial_init(22);
ll ans;
FOR(i, 1, k + 1) {
ans = 0ll;
ans += Combination(n - k + 1, i) * Combination(k - 1, i - 1);
ans %= MOD;
cout << ans << endl;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int i = a; i < b; i++)
#define REP(i, b) FOR(i, 0, b)
#define RFOR(i, a, b) for (int i = a - 1; i >= b; i--)
#define RREP(i, a) RFOR(i, a, 0)
#define REPALL(i, v) for (int i = 0; i < v.size(); i++)
#define RREPALL(i, v) for (int i = v.size() - 1; i >= 0; i--)
#define ALL(v) v.begin(), v.end()
#define SORT(v) sort(v.begin(), v.end())
#define MIN_ELEMENT(v) min_element(v.begin(), v.end())
#define MAX_ELEMENT(v) max_element(v.begin(), v.end())
#define COUNT(v, n) count(v.begin(), v.end(), n)
void YES(bool flag) { cout << (flag ? "YES" : "NO") << endl; }
void Yes(bool flag) { cout << (flag ? "Yes" : "No") << endl; }
void yes(bool flag) { cout << (flag ? "yes" : "no") << endl; }
typedef long long ll;
typedef unsigned long long ull;
const int INF = 1e7;
const ll MOD = 1e9 + 7;
//最大公約数
ll GCD(ll a, ll b) {
if (a == b || b == 0) {
return a;
} else if (a < b) {
return GCD(b, a);
} else {
return GCD(b, a % b);
}
}
//最小公倍数
ll LCM(ll a, ll b) { return a * b / GCD(a, b); }
vector<ll> primenum;
void get_prime_nembers(ll n) {
ll m = n;
FOR(i, 2, m + 1) {
bool flag = true;
REPALL(j, primenum) {
if (i % primenum[j] == 0) {
flag = false;
break;
}
}
if (flag) {
primenum.push_back(i);
while (m % i == 0) {
m /= i;
}
}
if (i > sqrt(n) + 1) {
primenum.push_back(m);
break;
}
}
}
vector<pair<int, int>> prime_factorization(ll n) {
if (primenum.empty())
get_prime_nembers(n);
vector<pair<int, int>> rtn;
REPALL(i, primenum) {
int num = 0;
ll tmpn = n;
while (tmpn % primenum[i] == 0) {
num++;
tmpn /= primenum[i];
}
if (num > 0)
rtn.push_back(make_pair(primenum[i], num));
}
return rtn;
}
ll mypow(ll a, ll b) {
ll r = 1ll;
while (b != 0) {
if (b & 1)
r = r * a % MOD;
a = a * a % MOD;
b /= 2;
}
return r;
}
vector<ll> fac;
vector<ll> ifac;
void factorial_init(ll n) {
fac.resize(n + 1);
ifac.resize(n + 1);
fac[0] = 1;
ifac[0] = 1;
REP(i, n) {
fac[i + 1] = fac[i] * (i + 1) % MOD;
ifac[i + 1] = ifac[i] * mypow(i + 1, MOD - 2) % MOD;
}
}
ll Combination(ll a, ll b) {
if (a == 0 && b == 0)
return 1;
if (a < b || a < 0)
return 0;
ll r = ifac[a - b] * ifac[b] % MOD;
return r * fac[a] % MOD;
}
int main() {
int n, k;
cin >> n >> k;
factorial_init(2222);
ll ans;
FOR(i, 1, k + 1) {
ans = 0ll;
ans += Combination(n - k + 1, i) * Combination(k - 1, i - 1);
ans %= MOD;
cout << ans << endl;
}
return 0;
}
| [
"literal.number.change",
"call.arguments.change"
] | 798,539 | 798,540 | u007637377 | cpp |
p02990 | #include <bits/stdc++.h>
using namespace std;
#define s 1000000007
long inverse(long n, long mod) {
long m = mod - 2;
long ans = 1;
long prod = n;
while (m != 0) {
if (m & 1) {
ans *= prod;
ans %= mod;
}
m >>= 1;
prod *= prod;
prod %= mod;
}
return ans;
}
long C(long n, long m) {
long N = 1;
for (int i = n - m + 1; i <= n; i++) {
N *= i;
n %= s;
}
long M = 1;
for (int i = 1; i <= m; i++) {
M *= i;
M %= s;
}
return (N * inverse(M, s)) % s;
}
int main() {
long K, N;
cin >> N >> K;
for (int i = 1; i <= K; i++) {
if (N - K + 1 >= i)
cout << (C(K - 1, i - 1) * C(N - K + 1, i)) % s << endl;
else
cout << 0 << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
#define s 1000000007
long inverse(long n, long mod) {
long m = mod - 2;
long ans = 1;
long prod = n;
while (m != 0) {
if (m & 1) {
ans *= prod;
ans %= mod;
}
m >>= 1;
prod *= prod;
prod %= mod;
}
return ans;
}
long C(long n, long m) {
long N = 1;
for (int i = n - m + 1; i <= n; i++) {
N *= i;
N %= s;
}
long M = 1;
for (int i = 1; i <= m; i++) {
M *= i;
M %= s;
}
return (N * inverse(M, s)) % s;
}
int main() {
long K, N;
cin >> N >> K;
for (int i = 1; i <= K; i++) {
if (N - K + 1 >= i)
cout << (C(K - 1, i - 1) * C(N - K + 1, i)) % s << endl;
else
cout << 0 << endl;
}
} | [
"assignment.variable.change",
"identifier.change"
] | 798,543 | 798,544 | u801530021 | cpp |
p02990 | //
// Created by nhatminh2947 on 7/3/19.
//
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
int dp[2001][2001];
int n, k;
int main() {
cin >> n >> k;
int blue = k;
int red = n - k;
for (int i = 0; i <= 2000; ++i) {
dp[i][0] = 1;
}
for (int i = 1; i <= 2000; ++i) {
for (int j = 1; j <= 2000; ++j) {
dp[i][j] = (dp[i - 1][j - 1] % MOD + dp[i - 1][j] % MOD) % MOD;
}
}
for (int i = 1; i <= k; ++i) {
cout << (dp[blue - 1][i - 1] % MOD * dp[red + 1][i] % MOD) % MOD << endl;
}
return 0;
} | //
// Created by nhatminh2947 on 7/3/19.
//
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
long long dp[2001][2001];
int n, k;
int main() {
cin >> n >> k;
int blue = k;
int red = n - k;
for (int i = 0; i <= 2000; ++i) {
dp[i][0] = 1;
}
for (int i = 1; i <= 2000; ++i) {
for (int j = 1; j <= 2000; ++j) {
dp[i][j] = (dp[i - 1][j - 1] % MOD + dp[i - 1][j] % MOD) % MOD;
}
}
for (int i = 1; i <= k; ++i) {
cout << (dp[blue - 1][i - 1] % MOD * dp[red + 1][i] % MOD) % MOD << endl;
}
return 0;
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 798,546 | 798,547 | u694239956 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.