text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
int n, answer;
bool p1[2005], p2[2005], used[2005];
int x1[2005], x2[2005];
vector<vector<int>> g(1005);
void dfs(int v) {
if (p1[v]) {
answer = v;
return;
}
used[v] = 1;
for (int i = 0; i < g[v].size(); i++)
if (!used[g[v][i]]) dfs(g[v][i]);
return;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
cin >> n;
for (int i = 0; i <= n; i++) {
g[i].clear();
p1[i] = 0;
p2[i] = 0;
used[i] = 0;
}
for (int i = 0; i < n - 1; i++) {
int x, y;
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
int k1, k2;
cin >> k1;
for (int i = 0; i < k1; i++) {
cin >> x1[i];
p1[x1[i]] = 1;
}
cin >> k2;
for (int i = 0; i < k2; i++) {
cin >> x2[i];
p2[x2[i]] = 1;
}
cout << "B " << x2[0] << endl;
int f;
cin >> f;
dfs(f);
int ans = answer;
cout << "A " << ans << endl;
int f1;
cin >> f1;
if (p2[f1])
cout << "C " << ans << endl;
else
cout << "C -1" << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = (5e5) + 322;
const int INF = (int)(1e9);
const long long mod = 998244353;
const double eps = 1e-9;
int n, m, test, used[1111], col1[1111], par[1111], col[1111], ver;
vector<int> v[1111];
void dfs(int x, int p = -1) {
if (col[x]) {
ver = x;
return;
}
for (auto it : v[x]) {
if (it == p) continue;
dfs(it, x);
}
}
int getB(int x) {
cout << "B ";
fflush(stdout);
cout << x << "\n";
fflush(stdout);
int ans;
cin >> ans;
return ans;
}
int getA(int x) {
cout << "A ";
fflush(stdout);
cout << x << "\n";
fflush(stdout);
int ans;
cin >> ans;
return ans;
}
int main() {
cin >> test;
while (test--) {
cin >> n;
memset(used, 0, sizeof used);
memset(col1, 0, sizeof col1);
memset(par, 0, sizeof par);
memset(col, 0, sizeof col);
for (int i = 1; i <= n; ++i) v[i].clear();
for (int i = 1; i <= n - 1; ++i) {
int x, y;
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
dfs(1);
int k1;
cin >> k1;
for (int i = 1; i <= k1; ++i) {
int x;
cin >> x;
col[x] = 1;
}
int k2;
cin >> k2;
int start = 0;
for (int i = 1; i <= k2; ++i) {
int x;
cin >> x;
col1[x] = 1;
start = x;
}
int cur = getB(start);
dfs(cur);
if (col1[getA(ver)]) {
cout << "C ";
fflush(stdout);
cout << ver << "\n";
fflush(stdout);
} else {
cout << "C ";
fflush(stdout);
cout << -1 << "\n";
fflush(stdout);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> g[1002];
bool vis[1002];
bool my[1002], chen[1002];
int dfs(int n) {
if (my[n] == 1) return n;
vis[n] = 1;
for (int i = 0; i < g[n].size(); i++) {
int v = g[n][i];
if (!vis[v]) {
int ans = dfs(v);
if (ans != -1) return ans;
}
}
return -1;
}
void make() {
memset((vis), 0, sizeof(vis));
memset((my), 0, sizeof(my));
memset((chen), 0, sizeof(chen));
for (int i = 0; i < 1002; i++) g[i].clear();
}
int main() {
int t, i, j;
cin >> t;
while (t--) {
make();
int n, k1, k2;
cin >> n;
for (i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
cin >> k1;
for (i = 0; i < k1; i++) {
int u;
cin >> u;
my[u] = 1;
}
cin >> k2;
for (i = 0; i < k2; i++) {
int u;
cin >> u;
chen[u] = 1;
}
int q;
for (i = 1; i <= n; i++)
if (chen[i] == 1) break;
cout << "B " << i << endl;
cout.flush();
cin >> q;
if (my[q] == 1) {
cout << "C " << q << endl;
cout.flush();
continue;
}
int ans = dfs(q);
cout << "A " << ans << endl;
cout.flush();
cin >> q;
if (chen[q] == 1) {
cout << "C " << ans << endl;
cout.flush();
} else {
cout << "C " << -1 << endl;
cout.flush();
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2000010, mod = 1e9 + 7;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 1) + (x << 3) + (ch ^ 48);
ch = getchar();
}
return x * f;
}
vector<int> g[N];
int vis1[N], vis2[N], get, d[N], p[N];
void dfs(int u, int pre, int dep) {
d[u] = dep;
for (auto e : g[u]) {
if (e == pre) continue;
dfs(e, u, dep + 1);
}
}
void solve() {
int n = read();
for (int i = 1; i <= n; ++i) g[i].clear(), vis1[i] = vis2[i] = 0;
for (int i = 1; i < n; ++i) {
int x = read(), y = read();
g[x].push_back(y);
g[y].push_back(x);
}
int k1 = read();
for (int i = 1; i <= k1; ++i) {
p[i] = read();
vis1[p[i]] = 1;
}
int k2 = read();
int p2;
for (int i = 1; i <= k2; ++i) {
int x = read();
vis2[x] = 1;
p2 = x;
}
cout << 'B' << ' ' << p2 << endl;
int p1 = read();
dfs(p1, 0, 0);
int dep = 1e8, ans;
for (int i = 1; i <= k1; ++i) {
if (d[p[i]] < dep) dep = d[p[i]], ans = p[i];
}
cout << 'A' << ' ' << ans << endl;
int get = read();
if (vis2[get])
cout << 'C' << ' ' << ans << endl;
else
cout << 'C' << ' ' << -1 << endl;
}
int main() {
int T = read();
while (T--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int mod = (1ll << 63);
vector<vector<int> > adj(1005);
vector<int> dis(1005);
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
for (int i = 0; i < n; i++) adj[i].clear();
for (int i = 0; i < n - 1; i++) {
int x, y;
cin >> x >> y;
x--, y--;
adj[x].push_back(y);
adj[y].push_back(x);
}
int k1;
cin >> k1;
vector<int> v1(k1);
for (int i = 0; i < k1; i++) cin >> v1[i];
int k2;
cin >> k2;
vector<int> v2(k2);
for (int i = 0; i < k2; i++) cin >> v2[i];
cout << "B " << v2[0] << endl;
int st;
cin >> st;
st--;
for (int i = 0; i < n; i++) dis[i] = n + 2;
queue<int> qu;
qu.push(st);
dis[st] = 0;
while (qu.size()) {
int cr = qu.front();
for (int x : adj[cr]) {
if (dis[x] > dis[cr] + 1) {
dis[x] = dis[cr] + 1;
qu.push(x);
}
}
qu.pop();
}
int mind = n + 1, vrt = -1;
for (int i = 0; i < k1; i++) {
if (dis[v1[i] - 1] < mind) {
mind = dis[v1[i] - 1];
vrt = v1[i];
}
}
cout << "A " << vrt << endl;
cin >> st;
int yes = 0;
for (int i = 0; i < k2; i++) {
if (v2[i] == st) yes = 1;
}
if (yes) {
cout << "C " << vrt << endl;
} else {
cout << "C -1" << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
const long long inf = std::numeric_limits<long long>::max();
const long long mod = 1e9 + 7;
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
stack<int> s;
vector<int> g[1100];
int xx, yy;
bool done;
void dfs(int v, int p) {
if (done) return;
for (auto i : g[v]) {
if (i == p) continue;
if (i == yy || done) {
done = true;
break;
}
s.push(i);
dfs(i, v);
if (!done) s.pop();
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
for (int i = 0; i < 1100; i++) g[i].clear();
while (!s.empty()) s.pop();
set<int> x, y;
xx = yy = 0;
done = false;
int n;
cin >> n;
for (int i = 0; i < n - 1; i++) {
int x1, y1;
cin >> x1 >> y1;
x1--, y1--;
g[x1].push_back(y1);
g[y1].push_back(x1);
}
int k1, k2;
cin >> k1;
for (int i = 0; i < k1; i++) {
int v;
cin >> v;
v--;
x.insert(v);
}
cin >> k2;
for (int i = 0; i < k2; i++) {
int v;
cin >> v;
v--;
y.insert(v);
}
yy = *y.begin();
cout << "B " << yy + 1 << endl;
cin >> yy;
yy--;
xx = *x.begin();
s.push(xx);
if (x.find(yy) != x.end()) {
cout << "C " << yy + 1 << endl;
continue;
}
dfs(xx, -1);
while (!s.empty() && x.find(s.top()) == x.end()) s.pop();
cout << "A " << s.top() + 1 << endl;
int ccc;
cin >> ccc;
ccc--;
if (y.find(ccc) == y.end()) {
cout << "C -1" << endl;
} else {
cout << "C " << s.top() + 1 << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 11;
vector<int> v[N];
int a[N], b[N], d[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
v[i].clear();
d[i] = -1;
}
for (int i = 1; i < n; i++) {
int l, r;
cin >> l >> r;
v[l].push_back(r);
v[r].push_back(l);
}
int k1, k2;
cin >> k1;
for (int i = 1; i <= k1; i++) cin >> a[i];
cin >> k2;
for (int i = 1; i <= k2; i++) cin >> b[i];
cout << "B " << b[1] << endl;
int x;
cin >> x;
vector<int> vv;
vv.push_back(x);
d[x] = 0;
for (int j = 0; j < vv.size(); j++) {
int l = vv[j];
for (int j = 0; j < v[l].size(); j++)
if (d[v[l][j]] == -1) {
d[v[l][j]] = d[l] + 1;
vv.push_back(v[l][j]);
}
}
int p = a[1];
for (int i = 1; i <= k1; i++)
if (d[a[i]] < d[p]) p = a[i];
cout << "A " << p << endl;
cin >> x;
int y = 0;
for (int i = 1; i <= k2; i++)
if (b[i] == x) {
y = 1;
break;
}
if (y == 1)
cout << "C " << p << endl;
else
cout << "C " << -1 << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000;
vector<int> g[maxn];
bool was[maxn];
int n;
set<int> s1, s2;
void Read() {
s1.clear();
s2.clear();
for (int i = 0; i < maxn; ++i) g[i].clear(), was[i] = false;
scanf("%d", &n);
int a, b;
for (int i = 1; i < n; ++i) {
scanf("%d%d", &a, &b);
--a, --b;
g[a].push_back(b);
g[b].push_back(a);
}
int k1, k2;
scanf("%d", &k1);
for (int i = 0; i < k1; ++i) {
scanf("%d", &a);
--a;
s1.insert(a);
}
scanf("%d", &k2);
for (int i = 0; i < k2; ++i) {
scanf("%d", &a);
--a;
s2.insert(a);
}
}
int dfs(int v) {
if (s1.count(v)) return v;
was[v] = true;
int ans = -1;
for (int j : g[v])
if (!was[j]) ans = max(ans, dfs(j));
return ans;
}
void calc() {
int start = *s2.begin();
cout << "B " << start + 1 << endl;
cin >> start;
start--;
int v = dfs(start);
cout << "A " << v + 1 << endl;
int have;
cin >> have;
have--;
if (s2.count(have))
cout << "C " << v + 1 << endl;
else
cout << "C " << -1 << endl;
}
void alg() {
Read();
calc();
}
int main() {
int t;
scanf("%d", &t);
for (int i = 0; i < t; ++i) alg();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int>> g;
bool istree[1001], istree2[1001];
vector<int> tr1, tr2;
int dfs(int u, int p) {
if (istree[u]) {
cout << "A " << u + 1 << endl;
int q;
cin >> q;
if (istree2[q - 1]) return u + 1;
return 0;
}
for (int i = 0; i < g[u].size(); ++i) {
if (g[u][i] == p) continue;
int x = dfs(g[u][i], u);
if (x) return x;
}
return 0;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int T;
cin >> T;
while (T--) {
int n;
cin >> n;
g.clear();
g.resize(n + 1);
tr1.clear();
tr2.clear();
memset(istree, 0, sizeof(istree));
memset(istree2, 0, sizeof(istree2));
for (int i = 0; i < n - 1; ++i) {
int a, b;
cin >> a >> b;
g[--a].push_back(--b);
g[b].push_back(a);
}
int k;
cin >> k;
for (int i = 0; i < k; ++i) {
int x;
cin >> x;
istree[--x] = 1;
tr1.push_back(x);
}
cin >> k;
for (int i = 0; i < k; ++i) {
int x;
cin >> x;
istree2[--x] = 1;
tr2.push_back(x);
}
cout << "B " << tr2[0] + 1 << endl;
int q;
cin >> q;
int x = dfs(q - 1, -1);
cout << "C " << (x ? x : -1) << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int H[1000], M[1000], P[1000], Lim[1000];
vector<vector<int> > edges(1000);
queue<int> Q;
void fill(int n) {
for (int i = 0; i < n; i++) {
H[i] = 0;
M[i] = 0;
P[i] = 0;
Lim[i] = 0;
}
}
void bfs() {
while (!Q.empty()) {
int a = Q.front();
Q.pop();
int n = edges[a].size();
for (int i = 0; i < n; i++)
if (M[edges[a][i]] == 0) {
M[edges[a][i]] = 1;
H[edges[a][i]] = H[a] + 1;
P[edges[a][i]] = P[a];
Q.push(edges[a][i]);
}
}
}
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
fill(n);
for (int i = 1; i < n; i++) {
int x, y;
cin >> x >> y;
edges[x - 1].push_back(y - 1);
edges[y - 1].push_back(x - 1);
}
int k1, k2;
cin >> k1;
for (int i = 0; i < k1; i++) {
int x;
cin >> x;
M[x - 1] = 1;
P[x - 1] = x - 1;
Q.push(x - 1);
}
bfs();
cin >> k2;
int minil = 1001;
for (int i = 0; i < k2; i++) {
int x;
cin >> x;
Lim[x - 1] = 1;
minil = min(minil, x - 1);
}
cout << "B " << minil + 1 << "\n";
int response;
cin >> response;
if (response == -1) exit(0);
response--;
if (H[response] >= k2) {
cout << "C -1\n";
} else if (H[response] == 0) {
cout << "C " << response + 1 << "\n";
} else {
cout << "A " << P[response] + 1 << "\n";
int response1;
cin >> response1;
if (response1 == -1) exit(0);
response1--;
if (Lim[response1] == 1)
cout << "C " << P[response] + 1 << "\n";
else
cout << "C -1\n";
}
cout.flush();
for (int i = 0; i < n; i++) edges[i].clear();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const long long INF = 1e18;
const int MX = 100001;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int T;
cin >> T;
while (T--) {
int N;
cin >> N;
vector<int> edges[N + 1];
int a, b;
for (int i = 0; i < N - 1; ++i) {
cin >> a >> b;
edges[a].push_back(b);
edges[b].push_back(a);
}
int k;
cin >> k;
vector<bool> mano(N + 1, false);
for (int i = 0; i < k; ++i) {
cin >> a;
mano[a] = true;
}
cin >> k;
vector<bool> jo(N + 1, false);
for (int i = 0; i < k; ++i) {
cin >> a;
jo[a] = true;
}
cout << "B " << a << endl;
int ans;
cin >> ans;
if (mano[ans]) {
cout << "C " << ans << endl;
continue;
}
queue<int> q;
q.push(ans);
int c;
vector<bool> buvau(N + 1, false);
while (!q.empty()) {
c = q.front();
q.pop();
buvau[c] = true;
if (mano[c]) break;
for (auto u : edges[c])
if (!buvau[u]) q.push(u);
}
cout << "A " << c << endl;
cin >> ans;
if (jo[ans]) {
cout << "C " << c << endl;
} else
cout << "C -1" << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
char _;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long fpow(long long b, long long exp, long long mod) {
if (exp == 0) return 1;
long long t = fpow(b, exp / 2, mod);
if (exp & 1) return t * t % mod * b % mod;
return t * t % mod;
}
int num_cases, num_nodes, num_A, num_B;
bool marked[1005], vis[1005];
vector<int> connections[1005];
unordered_set<int> A, B;
int main() {
scanf("%d", &num_cases);
for (int t = 0; t < num_cases; t++) {
scanf(" %d", &num_nodes);
for (int i = 1; i <= num_nodes; i++) connections[i].clear();
for (int i = 0; i < num_nodes - 1; i++) {
int a, b;
scanf(" %d %d", &a, &b);
connections[a].push_back(b);
connections[b].push_back(a);
}
scanf(" %d", &num_A);
A.clear(), B.clear();
memset(marked, false, sizeof marked);
for (int i = 1; i <= num_A; i++) {
int n;
scanf(" %d", &n);
A.insert(n);
marked[n] = true;
}
scanf(" %d", &num_B);
for (int i = 1; i <= num_B; i++) {
int n;
scanf(" %d", &n);
B.insert(n);
}
int first = *B.begin();
printf("B %d\n", first);
fflush(stdout);
int ans;
scanf(" %d", &ans);
if (A.count(ans)) {
printf("C %d\n", ans);
fflush(stdout);
continue;
}
memset(vis, false, sizeof vis);
queue<int> q;
q.push(ans);
vis[ans] = true;
bool done = false;
while (!q.empty()) {
int node = q.front();
q.pop();
if (marked[node]) {
printf("A %d\n", node);
fflush(stdout);
scanf(" %d", &ans);
if (B.count(ans)) {
printf("C %d\n", node);
done = true;
break;
}
break;
}
for (int check : connections[node]) {
if (!vis[check]) {
vis[check] = true;
q.push(check);
}
}
}
if (!done) printf("C -1\n");
fflush(stdout);
}
}
|
#include <bits/stdc++.h>
using std::deque;
using std::make_pair;
using std::map;
using std::max;
using std::min;
using std::pair;
using std::set;
using std::string;
using std::vector;
int getCloses(int his, std::vector<int>& mine,
std::vector<std::vector<int> >& edges, int gs) {
--his;
vector<bool> reached(gs, false);
static vector<int> process;
process.clear();
process.push_back(his);
int processIdx = 0;
reached[his] = true;
while (process.size() > processIdx) {
auto x = process[processIdx];
++processIdx;
if (std::find(mine.begin(), mine.end(), x + 1) != mine.end()) {
return x + 1;
}
for (auto y : edges[x]) {
if (!reached[y]) {
reached[y] = true;
process.push_back(y);
}
}
}
}
int main() {
int t;
scanf("%d", &t);
std::vector<std::vector<int> > g(1000);
std::vector<int> mine, his;
for (int ddd = 0; ddd < t; ++ddd) {
int n;
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
g[i].clear();
}
for (int i = 0; i < n - 1; ++i) {
int x, y;
scanf("%d%d", &x, &y);
--x;
--y;
g[x].push_back(y);
g[y].push_back(x);
}
int ms;
scanf("%d", &ms);
mine.resize(ms);
for (auto& x : mine) {
scanf("%d", &x);
}
scanf("%d", &ms);
his.resize(ms);
for (auto& x : his) {
scanf("%d", &x);
}
std::cout << "B " << his.front() << std::endl;
std::cout.flush();
int ownedByHim;
scanf("%d", &ownedByHim);
if (std::find(mine.begin(), mine.end(), ownedByHim) != mine.end()) {
std::cout << "C " << ownedByHim << std::endl;
std::cout.flush();
continue;
}
int closest = getCloses(ownedByHim, mine, g, n);
std::cout << "A " << closest << std::endl;
std::cout.flush();
int closesInHim;
scanf("%d", &closesInHim);
if (std::find(his.begin(), his.end(), closesInHim) != his.end()) {
std::cout << "C " << closest << std::endl;
std::cout.flush();
} else {
std::cout << "C " << -1 << std::endl;
std::cout.flush();
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
bool mark[1005];
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<vector<int>> adj(n + 1);
for (int i = 1, u, v; i < n; ++i) {
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
memset(mark, 0, sizeof mark);
int k1, k2;
cin >> k1;
vector<int> my(k1);
for (auto &i : my) cin >> i, mark[i] = true;
cin >> k2;
vector<int> ot(k2);
for (auto &i : ot) cin >> i;
cout << "B " << ot[0] << "\n";
fflush(stdout);
int to;
cin >> to;
int from = my[0];
function<int(int, int)> dfs = [&](int u, int p) {
if (u == to) return mark[u] ? u : (1 << 30);
int ans = -1;
for (auto v : adj[u])
if (v != p) ans = max(ans, dfs(v, u));
if (ans == 1 << 30 && mark[u]) ans = u;
return ans;
};
int x = dfs(from, -1), a;
cout << "A " << x << "\n";
fflush(stdout);
cin >> a;
bool ok = false;
for (auto i : ot) ok |= i == a;
if (ok)
cout << "C " << x << "\n";
else
cout << "C -1\n";
fflush(stdout);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int T, x, y, n, m, k, v[400000];
bool t[400000];
vector<int> p[400000];
int dfs(int x) {
if (v[x] == 2) return x;
v[x] = 0;
for (auto i : p[x])
if (v[i]) {
int r = dfs(i);
if (r) return r;
}
return 0;
}
int main() {
for (scanf("%d", &T); T; T--) {
scanf("%d", &n);
for (int i = (1); i <= (n); ++i) {
p[i].clear();
t[i] = 0;
v[i] = 1;
}
for (int i = (1); i <= (n - 1); ++i) {
scanf("%d%d", &x, &y);
p[x].push_back(y);
p[y].push_back(x);
}
scanf("%d", &m);
for (int i = (1); i <= (m); ++i) {
scanf("%d", &x);
v[x] = 2;
}
scanf("%d", &k);
for (int i = (1); i <= (k); ++i) {
scanf("%d", &x);
t[x] = 1;
}
printf("B %d\n", x);
fflush(stdout);
scanf("%d", &x);
x = dfs(x);
printf("A %d\n", x);
fflush(stdout);
scanf("%d", &y);
if (t[y])
printf("C %d\n", x);
else
printf("C -1\n");
fflush(stdout);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int getInt();
int getNegInt();
int T, N;
int get_nearest(int p, int a, vector<vector<int> >& path,
unordered_set<int>& me) {
if (me.find(a) != me.end()) return a;
for (auto b : path[a]) {
if (b == p) continue;
int tar = get_nearest(a, b, path, me);
if (tar != -1) return tar;
}
return -1;
}
int main(int argc, char** argv) {
int a, b, k1, k2;
T = getInt();
while (T--) {
unordered_set<int> me, he;
N = getInt();
vector<vector<int> > path(N + 1, vector<int>());
for (int i = 1; i < N; i++) {
scanf("%d%d", &a, &b);
path[a].push_back(b);
path[b].push_back(a);
}
k1 = getInt();
int start;
for (int i = 1; i <= k1; i++) {
a = getInt();
me.insert(a);
}
k2 = getInt();
for (int i = 1; i <= k2; i++) {
b = getInt();
start = b;
he.insert(b);
}
int ans = -1;
for (int i = 1; i <= 1; i++) {
cout << "B " << start << endl;
fflush(stdout);
int index = getInt();
if (me.find(index) != me.end()) {
ans = index;
break;
}
int nearest = get_nearest(index, index, path, me);
cout << "A " << nearest << endl;
fflush(stdout);
index = getInt();
if (he.find(index) != he.end()) {
ans = nearest;
break;
}
}
cout << "C " << ans << endl;
fflush(stdout);
}
return 0;
}
int getInt() {
int ret = 0;
char c = getchar();
while (c < '0' || c > '9') c = getchar();
while (c >= '0' && c <= '9') ret *= 10, ret += c - '0', c = getchar();
return ret;
}
int getNegInt() {
int ret = 0, sign = 1;
char c = getchar();
while ((c < '0' && c != '-') || c > '9') c = getchar();
if (c == '-') sign = -1, c = getchar();
while (c >= '0' && c <= '9') ret *= 10, ret += c - '0', c = getchar();
return ret * sign;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 100;
const int mod = 998244353;
int t, n, A[1010], B[1010], vis[1010];
vector<int> adj[1010];
void solve() {
cin >> n;
for (int i = 1; i < 1010; i++) adj[i].clear();
memset(A, 0, sizeof A);
memset(B, 0, sizeof B);
memset(vis, 0, sizeof vis);
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
}
int k;
cin >> k;
for (int i = 0; i < k; i++) {
int a;
cin >> a;
A[a] = true;
}
cin >> k;
for (int i = 0; i < k; i++) {
int a;
cin >> a;
B[a] = true;
}
for (int i = 1; i <= n; i++)
if (B[i]) {
cout << "B " << i << endl;
break;
}
int st;
cin >> st;
queue<int> Q;
Q.push(st);
while ((int)Q.size()) {
int v = Q.front();
Q.pop();
if (A[v]) {
cout << "A " << v << endl;
cin >> st;
if (B[st])
cout << "C " << v << endl;
else
cout << "C -1" << endl;
break;
}
for (int to : adj[v])
if (!vis[to]) {
vis[to] = true;
Q.push(to);
}
}
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0);
cin >> t;
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> G[1010];
vector<int> label1, label2;
int dfs(int v, int parent) {
for (auto num : label1) {
if (v == num) return v;
}
for (auto to : G[v]) {
if (to == parent) continue;
int tmp = dfs(to, v);
if (tmp != -1) return tmp;
}
return -1;
}
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
int t;
cin >> t;
for (int cnt = 0; cnt < t; cnt++) {
for (int i = 0; i < 1010; i++) G[i].clear();
label1.clear();
label2.clear();
int n;
cin >> n;
for (int i = 0; i < n - 1; i++) {
int s, t;
cin >> s >> t;
G[s].push_back(t);
G[t].push_back(s);
}
int k1;
cin >> k1;
for (int i = 0; i < k1; i++) {
int tmp;
cin >> tmp;
label1.push_back(tmp);
}
int k2;
cin >> k2;
for (int i = 0; i < k2; i++) {
int tmp;
cin >> tmp;
label2.push_back(tmp);
}
cout << "B " << label2[0] << endl << flush;
int v;
cin >> v;
int s = dfs(v, -1);
cout << "A " << dfs(v, -1) << endl << flush;
cin >> v;
bool find = false;
for (auto num : label2) {
if (v == num) {
cout << "C " << s << endl << flush;
find = true;
break;
}
}
if (!find) cout << "C -1" << endl << flush;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int size1;
int size2;
int myNodes[1000];
int liNodes[1000];
vector<int> graph[1000];
int makeQuery(char s, int n) {
int v;
printf("%c %d\n", s, n);
fflush(stdout);
scanf("%d", &v);
if (v == -1) exit(0);
return v;
}
int BFS(int p1) {
pair<int, int> node1;
set<int> visited;
queue<pair<int, int> > toVisit;
toVisit.push({p1, 1});
visited.insert(p1);
while (!toVisit.empty()) {
node1 = toVisit.front();
toVisit.pop();
if (node1.second > size2) return -1;
for (int node2 : graph[node1.first - 1]) {
if (visited.insert(node2).second) {
if (binary_search(myNodes, (myNodes + size1), node2)) return node2;
toVisit.push({node2, node1.second + 1});
}
}
}
return -1;
}
int getCommonNode() {
int v1;
int v2;
sort(myNodes, (myNodes + size1));
sort(liNodes, (liNodes + size2));
v1 = makeQuery('B', liNodes[0]);
if (binary_search(myNodes, (myNodes + size1), v1)) return v1;
v1 = BFS(v1);
if (v1 == -1) return -1;
v2 = makeQuery('A', v1);
if (binary_search(liNodes, (liNodes + size2), v2)) return v1;
return -1;
}
int main() {
int t;
int n;
int v1;
int v2;
scanf("%d", &t);
for (int i = 0; i < t; i++) {
scanf("%d", &n);
for (int j = 0; j < n; j++) graph[j].clear();
for (int j = 0; j < (n - 1); j++) {
scanf("%d", &v1);
scanf("%d", &v2);
graph[v1 - 1].push_back(v2);
graph[v2 - 1].push_back(v1);
}
scanf("%d", &size1);
for (int j = 0; j < size1; j++) scanf("%d", &myNodes[j]);
scanf("%d", &size2);
for (int j = 0; j < size2; j++) scanf("%d", &liNodes[j]);
printf("C %d\n", getCommonNode());
fflush(stdout);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 200000;
long long t, n, k1, k2, dis[N], ans, anns;
vector<long long> g[N];
set<long long> a, b;
void dfs(long long v, long long par) {
if (a.find(v) != a.end() and dis[v] <= anns) {
anns = dis[v];
ans = v;
}
for (long long i = 0; i < g[v].size(); i++) {
long long u = g[v][i];
if (u == par) continue;
dis[u] = dis[v] + 1;
dfs(u, v);
}
}
int main() {
cin >> t;
while (t--) {
for (long long i = 0; i < 1331; i++) {
g[i].clear();
dis[i] = 0;
}
cin >> n;
for (long long i = 1; i < n; i++) {
long long u, v;
cin >> v >> u;
g[v].push_back(u), g[u].push_back(v);
}
a.clear();
b.clear();
long long now = 0;
cin >> k1;
for (long long i = 1; i <= k1; i++) {
long long p;
cin >> p;
a.insert(p);
}
cin >> k2;
for (long long i = 1; i <= k2; i++) {
long long p;
cin >> p;
b.insert(p);
now = p;
}
cout << "B " << now << endl;
cin >> now;
if (a.find(now) != a.end()) {
cout << "C " << now << endl;
continue;
}
anns = 1e18;
dfs(now, 0);
cout << "A " << ans << endl;
cin >> now;
if (b.find(now) != b.end()) {
cout << "C " << ans << endl;
continue;
}
cout << "C -1\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
using vi = vector<int>;
using vvi = vector<vi>;
struct Testcase {
set<int> me, him;
vvi g;
vi near;
void dfs(int from, int nearest, int p = -1) {
if (me.count(from) != 0) {
near[from] = from;
} else {
near[from] = nearest;
}
for (int to : g[from]) {
if (p == to) continue;
dfs(to, near[from], from);
}
}
void solve() {
int n;
cin >> n;
g.assign(n, vi());
near.assign(n, -1);
for (int i = 0; i < n - 1; ++i) {
int x, y;
cin >> x >> y;
x--, y--;
g[x].push_back(y);
g[y].push_back(x);
}
int k1, k2;
cin >> k1;
for (int i = 0; i < k1; ++i) {
int x;
cin >> x;
me.insert(x - 1);
}
cin >> k2;
for (int i = 0; i < k2; ++i) {
int x;
cin >> x;
him.insert(x);
}
auto root = *me.begin();
dfs(root, root);
auto y1 = *him.begin();
cout << "B " << y1 << endl;
cout << flush;
int x1;
cin >> x1;
if (me.count(x1 - 1) == 1) {
cout << "C " << x1 << endl;
cout << flush;
return;
}
int x2 = near[x1 - 1] + 1;
cout << "A " << x2 << endl;
cout << flush;
int y2;
cin >> y2;
if (him.count(y2) == 1) {
cout << "C " << x2 << endl;
cout << flush;
} else {
cout << "C -1" << endl;
cout << flush;
}
}
};
int main() {
int t;
cin >> t;
while (t--) {
Testcase().solve();
cerr << "SOLVED" << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int size1;
int size2;
int myNodes[1000];
int liNodes[1000];
vector<int> graph[1000];
int makeQuery(char s, int n) {
int v;
printf("%c %d\n", s, n);
fflush(stdout);
scanf("%d", &v);
if (v == -1) exit(0);
return v;
}
int BFS(int p1) {
pair<int, int> node1;
set<int> visited;
queue<pair<int, int> > toVisit;
toVisit.push({p1, 1});
visited.insert(p1);
while (!toVisit.empty()) {
node1 = toVisit.front();
toVisit.pop();
if (node1.second > size2) return -1;
for (int node2 : graph[node1.first - 1]) {
if (visited.insert(node2).second) {
if (binary_search(myNodes, (myNodes + size1), node2)) return node2;
toVisit.push({node2, node1.second + 1});
}
}
}
return -1;
}
int getCommonNode() {
int v1;
int v2;
sort(myNodes, (myNodes + size1));
sort(liNodes, (liNodes + size2));
v1 = makeQuery('B', liNodes[0]);
if (binary_search(myNodes, (myNodes + size1), v1)) return v1;
v1 = BFS(v1);
if (v1 == -1) return -1;
v2 = makeQuery('A', v1);
if (binary_search(liNodes, (liNodes + size2), v2)) return v1;
return -1;
}
int main() {
int t;
int n;
int v1;
int v2;
scanf("%d", &t);
for (int i = 0; i < t; i++) {
scanf("%d", &n);
for (int j = 0; j < n; j++) graph[j].clear();
for (int j = 0; j < (n - 1); j++) {
scanf("%d", &v1);
scanf("%d", &v2);
graph[v1 - 1].push_back(v2);
graph[v2 - 1].push_back(v1);
}
scanf("%d", &size1);
for (int j = 0; j < size1; j++) scanf("%d", &myNodes[j]);
scanf("%d", &size2);
for (int j = 0; j < size2; j++) scanf("%d", &liNodes[j]);
printf("C %d\n", getCommonNode());
fflush(stdout);
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
void read(T& x) {
cin >> x;
}
template <class H, class... T>
void read(H& h, T&... t) {
read(h);
read(t...);
}
template <class A>
void read(A* x, int size) {
for (int i = (0); (1) > 0 ? i < (size) : i > (size); i += (1)) read(x[i]);
}
template <class A>
void read(vector<A>& x) {
for (auto& a : x) read(a);
}
template <class T>
void print(T& x) {
cout << x << ' ';
}
template <class H, class... T>
void print(H h, T... t) {
print(h);
print(t...);
}
template <class A>
void print(A* x, int size) {
for (int i = (0); (1) > 0 ? i < (size) : i > (size); i += (1)) print(x[i]);
cout << '\n';
}
template <class A>
void print(vector<A>& x) {
for (auto& a : x) print(a);
}
template <class H, class... T>
void debug(H h, T... t) {
print(h, t...);
cout << endl;
}
const int d4i[4] = {-1, 0, 1, 0}, d4j[4] = {0, 1, 0, -1};
const int d8i[8] = {-1, -1, 0, 1, 1, 1, 0, -1},
d8j[8] = {0, 1, 1, 1, 0, -1, -1, -1};
const int N = 1010, mod = 1e9 + 7;
vector<vector<int>> g;
int n;
unordered_set<int> st1, st2;
int dfs(int s, int p, int u) {
if (s == u) return s;
int ans = -1;
for (int v : g[s]) {
if (v != p) {
int x = dfs(v, s, u);
if (x == -1) continue;
ans = x;
}
}
if (ans == -1) return -1;
if (st1.find(ans) != st1.end()) return ans;
return s;
}
void solve() {
read(n);
int u, v, k1, k2;
g.clear();
st1.clear();
st2.clear();
g.resize(n + 1);
for (int i = (0); (1) > 0 ? i < (n - 1) : i > (n - 1); i += (1)) {
read(u, v);
g[u].push_back(v);
g[v].push_back(u);
}
read(k1);
for (int i = (0); (1) > 0 ? i < (k1) : i > (k1); i += (1)) {
read(u);
st1.insert(u);
}
read(k2);
for (int i = (0); (1) > 0 ? i < (k2) : i > (k2); i += (1)) {
read(u);
st2.insert(u);
}
cout << "A " << (*st1.begin()) << endl;
cin >> u;
if (st2.find(u) != st2.end()) {
cout << "C " << (*st1.begin()) << endl;
return;
}
cout << "B " << (*st2.begin()) << endl;
cin >> u;
if (st1.find(u) != st1.end()) {
cout << "C " << u << endl;
return;
}
u = dfs(*(st1.begin()), 0, u);
int x = u;
cout << "A " << u << endl;
cin >> u;
if (st2.find(u) != st2.end())
cout << "C " << x << endl;
else
cout << "C " << -1 << endl;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int _t;
cin >> _t;
while (_t--) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
int ask(string q, int x) {
cout << q << " " << x << endl;
int ret;
cin >> ret;
return ret;
}
int getclosestnode(vector<vector<int>> &adj, set<int> &me, int node) {
bool visited[1001];
memset(visited, 0, sizeof visited);
queue<int> q;
q.push(node);
while (!q.empty()) {
int u = q.front();
q.pop();
if (me.count(u) != 0)
return u;
else
for (auto x : adj[u])
if (!visited[x]) {
q.push(x);
visited[x] = 1;
}
}
return -1;
}
void solve() {
int n;
vector<vector<int>> adj(1001);
cin >> n;
for (int i = 0; i < (int)(n - 1); i++) {
int a, b;
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
}
set<int> me, li;
int k;
cin >> k;
for (int i = 0; i < (int)(k); i++) {
int a;
cin >> a;
me.insert(a);
}
cin >> k;
for (int i = 0; i < (int)(k); i++) {
int a;
cin >> a;
li.insert(a);
}
int node = ask("B", *li.begin());
if (me.count(node) != 0)
cout << "C " << node << endl;
else {
int closest = getclosestnode(adj, me, node);
int liclose = ask("A", closest);
if (li.count(liclose) != 0) {
cout << "C " << closest << endl;
} else
cout << "C " << -1 << endl;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int tc;
cin >> tc;
for (int i = 0; i < (int)(tc); i++) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > e;
int d[1000], pr[1000];
void DFS(int x, int p, int dp) {
d[x] = dp;
pr[x] = p;
for (int i = 0; i < e[x].size(); i++)
if (e[x][i] != p) DFS(e[x][i], x, dp + 1);
}
int main() {
int t;
cin >> t;
for (int i = 0; i < t; i++) {
int n, a, b, k1, k2, ba[1000] = {}, c[1000] = {}, mn = 1001, ind = -1, x, y;
cin >> n;
e.resize(n);
for (int j = 0; j < n; j++) e[j].clear();
for (int j = 0; j < n - 1; j++) {
cin >> a >> b;
a--;
b--;
e[a].push_back(b);
e[b].push_back(a);
}
DFS(0, -1, 0);
cin >> k1;
for (int j = 0; j < k1; j++) {
cin >> x;
ba[x - 1] = 1;
}
cin >> k2;
for (int j = 0; j < k2; j++) {
cin >> x;
c[x - 1] = 1;
}
for (int j = 0; j < n; j++)
if (ba[j] && d[j] < mn) {
mn = d[j];
ind = j;
}
cout << "B " << x << endl;
cin >> x;
x--;
if (ba[x]) {
cout << "C " << x + 1 << endl;
continue;
}
while (x >= 0 && !ba[x]) x = pr[x];
if (x >= 0) {
cout << "A " << x + 1 << endl;
cin >> y;
y--;
if (c[y])
cout << "C " << x + 1 << endl;
else
cout << "C -1" << endl;
continue;
}
cout << "A " << ind + 1 << endl;
cin >> y;
y--;
if (c[y])
cout << "C " << ind + 1 << endl;
else
cout << "C -1" << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000 + 1;
int T, n, mark1[maxn], mark2[maxn], k, q, ch, w;
vector<int> e[maxn];
void dfs(int v, int p) {
if (mark1[v] == 1 && ch == 0) {
ch = v;
}
for (auto u : e[v]) {
if (u != p) {
dfs(u, v);
}
}
return;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> T;
for (int i = 1; i <= T; i++) {
for (int i = 1; i < maxn; i++) {
e[i].clear();
mark1[i] = 0;
mark2[i] = 0;
}
cin >> n;
for (int i = 1; i < n; i++) {
int tmp1, tmp2;
cin >> tmp1 >> tmp2;
e[tmp1].push_back(tmp2);
e[tmp2].push_back(tmp1);
}
cin >> k;
for (int i = 1; i <= k; i++) {
int tmp1;
cin >> tmp1;
mark1[tmp1] = 1;
}
cin >> k;
for (int i = 1; i <= k; i++) {
int tmp1;
cin >> tmp1;
q = tmp1;
mark2[tmp1] = 1;
}
cout << "B " << q << endl;
cout << flush;
cin >> w;
ch = 0;
dfs(w, 0);
cout << "A " << ch << endl;
cout << flush;
cin >> w;
if (mark2[w] == 1) {
cout << "C " << ch << endl;
} else {
cout << "C " << -1 << endl;
}
cout << flush;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int M = 2e5 + 10;
const long long int mod = 1e9 + 7;
const long long int infi = LLONG_MAX;
long long int ans, k, n, x, y, m, mymax = LLONG_MIN, mymin = LLONG_MAX, b, c, z,
sum;
vector<long long int> v[M];
vector<long long int> vx, vy;
set<long long int> sx, sy;
long long int query(long long int node, long long int type) {
if (type == 1) {
cout << "A " << node << endl;
} else
cout << "B " << node << endl;
long long int val;
cin >> val;
return val;
}
long long int dfs(long long int node, long long int parent,
long long int target) {
long long int curr_dist = n;
if (node == target) {
return 0;
}
for (auto kk : v[node]) {
if (kk != parent) {
curr_dist = min(1 + dfs(kk, node, target), curr_dist);
}
}
return curr_dist;
}
long long int dist(long long int node1, long long int node2) {
return dfs(node1, node1, node2);
}
void solve() {
long long int i, j;
cin >> n;
for (i = 1; i < n + 1; i++) v[i].clear();
for (i = 1; i < n; i++) {
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
vx.clear();
vy.clear();
sx.clear();
sy.clear();
cin >> k;
for (i = 1; i < k + 1; i++) {
cin >> x;
vx.push_back(x);
sx.insert(x);
}
cin >> k;
for (i = 1; i < k + 1; i++) {
cin >> x;
vy.push_back(x);
sy.insert(x);
}
long long int node_in_x = query(vy[0], 2);
if (sx.find(node_in_x) != sx.end()) {
cout << "C " << node_in_x << endl;
return;
}
long long int curr_node = -1, min_dist = n;
for (auto node : vx) {
long long int curr_dist = dist(node, node_in_x);
if (curr_dist < min_dist) {
min_dist = curr_dist;
curr_node = node;
}
}
long long int node_in_y = query(curr_node, 1);
if (sy.find(node_in_y) != sy.end()) {
cout << "C " << curr_node << endl;
} else {
cout << "C -1" << endl;
}
}
int main() {
long long int i, t, j;
cin.tie(NULL);
cin >> t;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> g[1005];
int x[1005], y[1005];
int t, n, i, u, v, m, ans, tp;
void dfs(int u, int fa) {
if (x[u]) {
cout << "A " << u << endl;
fflush(stdout);
cin >> tp;
if (y[tp])
ans = u;
else
ans = -1;
return;
}
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (v == fa) continue;
dfs(v, u);
if (ans) return;
}
}
int main() {
cin >> t;
while (t--) {
cin >> n;
for (i = 1; i <= n; i++) {
g[i].clear();
x[i] = y[i] = 0;
}
for (i = 0; i < n - 1; i++) {
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
cin >> m;
for (i = 0; i < m; i++) {
cin >> u;
x[u] = 1;
}
cin >> m;
for (i = 0; i < m; i++) {
cin >> u;
y[u] = 1;
}
cout << "B " << u << endl;
fflush(stdout);
cin >> u;
ans = 0;
dfs(u, 0);
cout << "C " << ans << endl;
fflush(stdout);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k1, k2, u[1001], q[1001], start, x, y;
vector<int> vec[1001];
int a, b;
int f(int v, int pr) {
if (u[v] == 1) {
return v;
}
int yy = 0;
for (int i = 0; i < vec[v].size(); i++) {
if (vec[v][i] != pr) {
yy = max(yy, f(vec[v][i], v));
}
}
return yy;
}
pair<int, int> get(int v, int pr) {
pair<int, int> ans = make_pair(0, 0);
if (v == y) {
ans.first = 1;
return ans;
}
if (u[v] == 1) {
ans.second = v;
}
pair<int, int> yy = make_pair(0, 0);
for (int i = 0; i < vec[v].size(); i++) {
if (vec[v][i] != pr) {
yy = max(yy, get(vec[v][i], v));
}
}
if (yy.first != 0) {
ans.first = 1;
}
if (yy.first != 0 && yy.second != 0) {
ans = yy;
}
return ans;
}
void solve() {
for (int i = 0; i < 1001; i++) {
vec[i].clear();
u[i] = 0;
q[i] = 0;
}
cin >> n;
for (int i = 1; i < n; i++) {
scanf("%d%d", &a, &b);
vec[a].push_back(b);
vec[b].push_back(a);
}
cin >> k1;
for (int i = 0; i < k1; i++) {
scanf("%d", &x);
u[x] = 1;
}
cin >> k2;
for (int i = 0; i < k2; i++) {
scanf("%d", &x);
q[x] = 1;
}
start = f(1, -1);
cout << "A " << start << endl;
fflush(stdout);
cin >> y;
if (q[y] == 1) {
cout << "C " << start << endl;
fflush(stdout);
return;
} else {
cout << "B " << x << endl;
fflush(stdout);
cin >> y;
if (u[y] == 1) {
cout << "C " << y << endl;
fflush(stdout);
return;
} else {
pair<int, int> ppp = get(1, -1);
if (ppp.second == 0) {
cout << "C -1" << endl;
fflush(stdout);
return;
}
start = ppp.second;
cout << "A " << start << endl;
fflush(stdout);
cin >> y;
if (q[y] == 1) {
cout << "C " << start << endl;
fflush(stdout);
return;
} else {
cout << "C -1" << endl;
fflush(stdout);
return;
}
}
}
}
int main() {
int test;
cin >> test;
while (test--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int>> graph;
vector<bool> used;
set<int> tree1;
set<int> tree2;
int dfs(int u) {
if (used[u]) {
return 0;
}
used[u] = true;
if (tree1.find(u) != tree1.end()) {
return u;
}
for (int x : graph[u]) {
int k = dfs(x);
if (k != 0) {
return k;
}
}
return 0;
}
int main() {
ios::sync_with_stdio(0);
int t;
cin >> t;
for (int i = 0; i < t; i++) {
int n;
cin >> n;
graph.assign(n + 1, vector<int>(0));
used.assign(n + 1, false);
tree1.clear();
tree2.clear();
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
graph[u].push_back(v);
graph[v].push_back(u);
}
int k1;
cin >> k1;
for (int i = 0; i < k1; i++) {
int u;
cin >> u;
tree1.insert(u);
}
int k2;
cin >> k2;
for (int i = 0; i < k2; i++) {
int u;
cin >> u;
tree2.insert(u);
}
cout << "B " << *tree2.begin() << endl;
int x;
cin >> x;
int t1 = dfs(x);
cout << "A " << t1 << endl;
int y;
cin >> y;
if (tree2.find(y) != tree2.end()) {
cout << "C " << t1 << endl;
} else {
cout << "C " << -1 << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
const int K = 200;
const int mod = 998244353;
int power(int a, int b) {
int res = 1;
while (b) {
if (b & 1) {
res = 1LL * res * a % mod;
}
a = 1LL * a * a % mod;
b >>= 1;
}
return res;
}
vector<int> adj[1005];
int par[1005];
void dfs(int node, int p) {
par[node] = p;
for (auto child : adj[node]) {
if (child == p) continue;
dfs(child, node);
}
}
int main() {
int test, n, u, v, k1, k2, val;
scanf("%d", &test);
while (test--) {
set<int> s1, s2;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
adj[i].clear();
par[i] = -1;
}
for (int i = 1; i < n; i++) {
scanf("%d %d", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
}
scanf("%d", &k1);
for (int i = 1; i <= k1; i++) {
scanf("%d", &val);
s1.insert(val);
}
scanf("%d", &k2);
for (int i = 1; i <= k2; i++) {
scanf("%d", &val);
s2.insert(val);
}
int a1 = *s1.begin(), a2, b1, b2;
printf("A %d\n", a1);
fflush(stdout);
scanf("%d", &b1);
if (s2.find(b1) != s2.end()) {
printf("C %d\n", a1);
fflush(stdout);
continue;
}
b2 = *s2.begin();
printf("B %d\n", b2);
fflush(stdout);
scanf("%d", &a2);
if (s1.find(a2) != s1.end()) {
printf("C %d\n", a2);
fflush(stdout);
continue;
}
dfs(a1, 0);
while (a2) {
if (s1.find(a2) != s1.end()) {
break;
}
a2 = par[a2];
}
if (a2) {
printf("A %d\n", a2);
fflush(stdout);
scanf("%d", &b2);
if (s2.find(b2) != s2.end()) {
printf("C %d\n", a2);
fflush(stdout);
continue;
}
}
printf("C -1\n");
fflush(stdout);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1007;
const int inf = INT_MAX;
const long long inff = 1e18;
const long long mod = 1e9 + 7;
int t;
int n;
vector<int> G[maxn];
vector<int> a, b;
int ret, nnow = 0;
int dfs(int now, int p) {
if (now == ret) return 1;
int rr = 0;
for (int i : G[now]) {
if (i != p) {
rr = max(rr, dfs(i, now));
}
}
if (rr == 1 && lower_bound((a).begin(), (a).end(), now) != a.end() &&
(*lower_bound((a).begin(), (a).end(), now)) == now && nnow == 0) {
nnow = now;
}
return rr;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> t;
while (t--) {
cin >> n;
for (int i = 1; i <= 1000; i++) G[i].clear();
a.clear();
b.clear();
nnow = 0;
ret = 0;
for (int i = 1; i <= n - 1; i++) {
int x, y;
cin >> x >> y;
G[x].push_back(y);
G[y].push_back(x);
}
int x;
int A, B;
cin >> A;
while (A--) {
cin >> x;
a.push_back(x);
}
sort((a).begin(), (a).end());
cin >> B;
while (B--) {
cin >> x;
b.push_back(x);
}
sort((b).begin(), (b).end());
cout << "B " << b[0] << endl;
cout << flush;
cin >> ret;
if (lower_bound((a).begin(), (a).end(), ret) != a.end() &&
(*lower_bound((a).begin(), (a).end(), ret)) == ret) {
cout << "C " << ret << endl;
cout << flush;
} else {
dfs(a[0], -1);
cout << "A " << nnow << endl;
cout << flush;
cin >> ret;
if (lower_bound((b).begin(), (b).end(), ret) != b.end() &&
(*lower_bound((b).begin(), (b).end(), ret)) == ret) {
cout << "C " << nnow << endl;
cout << flush;
} else {
cout << "C " << -1 << endl;
cout << flush;
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007ll;
long long powmod(long long a, long long b) {
long long res = 1;
a %= MOD;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) res = res * a % MOD;
a = a * a % MOD;
}
return res;
}
template <typename t1, typename t2>
inline bool upmax(t1 &a, t2 b) {
if (a < (t1)b) {
a = (t1)b;
return true;
} else
return false;
}
template <typename t1, typename t2>
inline bool upmin(t1 &a, t2 b) {
if (a > (t1)b) {
a = (t1)b;
return true;
} else
return false;
}
template <typename T>
inline T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
template <typename T>
inline T lcm(T a, T b) {
return a * (b / gcd(a, b));
}
template <typename T>
inline T sqr(T a) {
return a * a;
}
int dx[] = {1, 0, -1, 0, 1, 1, -1, -1};
int dy[] = {0, 1, 0, -1, 1, -1, 1, -1};
const int INF = 1000000404;
const long long LINF = 4000000000000000404ll;
const long double PI = acos(-1.0);
const long double EPS = 1e-9;
int SQ = 318;
int timer = 0;
const int N = 1100;
int a[N];
int b[N];
int col[N];
int col2[N];
int d[N];
void solve() {
vector<int> g[N];
int n;
cin >> n;
for (int i = 1; i < n; i++) {
int a, b;
cin >> a >> b;
g[a].push_back(b);
g[b].push_back(a);
}
for (int i = 1; i <= n; i++) {
col[i] = 0;
col2[i] = 0;
d[i] = INF;
}
int k1, k2;
cin >> k1;
for (int i = 0; i < k1; i++) {
cin >> a[i];
col[a[i]] = 1;
}
cin >> k2;
for (int i = 0; i < k2; i++) {
cin >> b[i];
col2[b[i]] = 1;
}
cout << "B " << b[0] << endl;
int v;
cin >> v;
queue<int> q;
d[v] = 0;
q.push(v);
while (!q.empty()) {
int x = q.front();
q.pop();
for (auto y : g[x]) {
if (d[y] > d[x] + 1) {
d[y] = d[x] + 1;
q.push(y);
}
}
}
int x = a[0];
for (int i = 0; i < k1; i++) {
if (d[a[i]] < d[x]) x = a[i];
}
cout << "A " << x << endl;
int r;
cin >> r;
if (col2[r]) {
cout << "C " << x << endl;
} else {
cout << "C " << -1 << endl;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
cin >> t;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
float inf = std::numeric_limits<double>::infinity();
long long int INF = std::numeric_limits<long long int>::max();
const int N = 1005;
set<int> X, Y;
vector<int> G[N];
int dfs(int x, int pre) {
if (X.count(x)) return x;
int ret;
for (auto v : G[x]) {
if (v == pre) continue;
ret = dfs(v, x);
if (ret) return ret;
}
return 0;
}
int getinput() {
int x;
cin >> x;
if (x == -1) exit(0);
return x;
}
int main() {
int t;
cin >> t;
;
while (t--) {
int n;
n = getinput();
for (int i = 1; i <= n; i++) G[i].clear();
X.clear(), Y.clear();
int a, b;
for (int i = 1; i < n; i++) {
cin >> a >> b;
G[a].push_back(b);
G[b].push_back(a);
}
int k1, k2, v;
cin >> k1;
for (int i = 0; i < k1; i++) cin >> v, X.insert(v);
cin >> k2;
for (int i = 0; i < k2; i++) cin >> v, Y.insert(v);
cout << "B " << *(Y.begin()) << endl;
cout.flush();
int x1, x2, y2;
x1 = getinput();
x2 = dfs(x1, 0);
cout << "A " << x2 << endl;
cout.flush();
y2 = getinput();
if (Y.count(y2))
cout << "C " << x2 << endl;
else
cout << "C -1" << endl;
cout.flush();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3fLL;
const double pi = acos(-1.0);
const int maxn = 100000 + 10;
const int mod = 1e9 + 7;
inline char _getchar() {
static const int BUFSIZE = 100001;
static char buf[BUFSIZE];
static char *psta = buf, *pend = buf;
if (psta >= pend) {
psta = buf;
pend = buf + fread(buf, 1, BUFSIZE, stdin);
if (psta >= pend) return -1;
}
return *psta++;
}
void dfs(int x, int fa, vector<vector<int> > &g, vector<int> &p,
vector<int> &vis) {
for (int i = 0; i < g[x].size(); i++) {
if (g[x][i] != fa && !vis[g[x][i]]) {
p[g[x][i]] = p[x];
dfs(g[x][i], x, g, p, vis);
}
}
}
void gao(int n) {
vector<vector<int> > g;
vector<int> p;
vector<int> vis;
g.resize(n + 2);
p.resize(n + 2);
vis.resize(n + 2);
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d", &u), scanf("%d", &v);
g[u].push_back(v), g[v].push_back(u);
}
int k1;
scanf("%d", &k1);
for (int i = 0; i < k1; i++) {
int u;
scanf("%d", &u);
vis[u] = 1;
p[u] = u;
}
for (int i = 1; i <= n; i++) {
if (vis[i]) dfs(i, 0, g, p, vis);
}
int k2;
scanf("%d", &k2);
vector<int> q(k2);
for (int i = 0; i < k2; i++) {
scanf("%d", &q[i]);
}
sort(q.begin(), q.end());
printf("B %d\n", q[0]);
fflush(stdout);
int id;
scanf("%d", &id);
printf("A %d\n", p[id]);
fflush(stdout);
int ret;
scanf("%d", &ret);
int w = lower_bound(q.begin(), q.end(), ret) - q.begin();
if (w != q.size() && q[w] == ret)
printf("C %d\n", p[id]), fflush(stdout);
else
printf("C -1\n"), fflush(stdout);
}
int main() {
int T;
scanf("%d", &T);
for (int cas = 1; cas <= T; cas++) {
int n;
scanf("%d", &n);
gao(n);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[1009];
bool visited[1009], vis[1009], has[1009];
int common = -1;
void init() {
common = -1;
for (int i = 0; i < 1009; i++) {
visited[i] = false;
vis[i] = false;
has[i] = false;
adj[i].clear();
}
}
void DFS(int node) {
if (common != -1) return;
if (visited[node]) {
common = node;
return;
}
vis[node] = true;
for (int i = 0; i < adj[node].size(); i++) {
if (!vis[adj[node][i]]) DFS(adj[node][i]);
}
}
int main() {
int test;
cin >> test;
while (test--) {
init();
int n;
cin >> n;
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
int k1;
cin >> k1;
for (int i = 0; i < k1; i++) {
int x;
cin >> x;
visited[x] = true;
}
int k2, node;
cin >> k2;
for (int i = 0; i < k2; i++) {
cin >> node;
has[node] = true;
}
cout << "B " << node << "\n";
int res;
cin >> res;
if (visited[res]) {
cout << "C " << res << "\n";
cout.flush();
continue;
}
DFS(res);
cout << "A " << common << "\n";
cin >> res;
if (has[res])
cout << "C " << common << "\n";
else
cout << "C -1\n";
cout.flush();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MD = 1000000007;
const int INF = 1e9 + 9;
const int N = 1e3 + 33;
long long n, m, k;
vector<int> g[N];
int my[N], opp[N];
int mark[N];
int main() {
ios_base::sync_with_stdio(false);
cout.tie(nullptr);
cin.tie(nullptr);
int t;
cin >> t;
while (t--) {
cin >> n;
for (int i = 0; i < n; i++) {
g[i].clear();
mark[i] = 0;
my[i] = 0;
opp[i] = 0;
}
for (int i = 1; i < n; i++) {
int a, b;
cin >> a >> b;
g[a - 1].push_back(b - 1);
g[b - 1].push_back(a - 1);
}
cin >> k;
while (k--) {
int a;
cin >> a;
my[a - 1] = 1;
}
cin >> k;
int qq;
while (k--) {
int a;
cin >> a;
qq = a;
opp[a - 1] = 1;
}
cout << "B " << qq << endl;
int x;
cin >> x;
if (my[x - 1] == 1) {
cout << "C " << x << endl;
continue;
}
queue<int> bfsq;
bfsq.push(x - 1);
while (!bfsq.empty()) {
int v = bfsq.front();
mark[v] = 1;
bfsq.pop();
for (int u : g[v]) {
if (my[u] == 1) {
cout << "A " << u + 1 << endl;
int y;
cin >> y;
if (opp[y - 1] == 1) {
cout << "C " << u + 1 << endl;
break;
} else {
cout << "C " << -1 << endl;
break;
}
}
if (mark[u] == 0) bfsq.push(u);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int>> g;
bool istree[1001], istree2[1001];
vector<int> tr1, tr2;
int dfs(int u, int p) {
if (istree[u]) {
cout << "A " << u + 1 << endl;
int q;
cin >> q;
if (istree2[q - 1]) return u + 1;
return -1;
}
for (int i = 0; i < g[u].size(); ++i) {
if (g[u][i] == p) continue;
int x = dfs(g[u][i], u);
if (x) return x;
}
return 0;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int T;
cin >> T;
while (T--) {
int n;
cin >> n;
g.clear();
g.resize(n + 1);
tr1.clear();
tr2.clear();
memset(istree, 0, sizeof(istree));
memset(istree2, 0, sizeof(istree2));
for (int i = 0; i < n - 1; ++i) {
int a, b;
cin >> a >> b;
g[--a].push_back(--b);
g[b].push_back(a);
}
int k;
cin >> k;
for (int i = 0; i < k; ++i) {
int x;
cin >> x;
istree[--x] = 1;
tr1.push_back(x);
}
cin >> k;
for (int i = 0; i < k; ++i) {
int x;
cin >> x;
istree2[--x] = 1;
tr2.push_back(x);
}
cout << "B " << tr2[0] + 1 << endl;
int q;
cin >> q;
cout << "C " << dfs(q - 1, -1) << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> adj[300001];
set<long long> my, his;
long long dfs(long long x, long long p) {
long long i, ch, k;
if (my.find(x) != my.end()) {
return x;
}
for (i = 0; i < adj[x].size(); i++) {
ch = adj[x][i];
if (ch != p) {
k = dfs(ch, x);
if (k != 0) return k;
}
}
return 0;
}
int main() {
long long m, z, i, j, lt, x, y, d, r, q, k, g, t, n;
vector<long long> a(300001), b(300001), c(300001), tx, ps;
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> t;
while (t--) {
cin >> n;
for (i = 1; i <= n; i++) adj[i].clear();
my.clear();
his.clear();
for (i = 1; i < n; i++) {
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
long long km, kh;
cin >> km;
for (i = 0; i < km; i++) {
cin >> x;
my.insert(x);
}
cin >> kh;
for (i = 0; i < kh; i++) {
cin >> x;
his.insert(x);
}
cout << "B " << x << endl;
cin >> x;
if (my.find(x) != my.end()) {
cout << "C " << x << endl;
continue;
}
k = dfs(x, 0);
if (k == 0)
cout << -1 << endl;
else {
cout << "A " << k << endl;
cin >> x;
if (his.find(x) != his.end())
cout << "C " << k << endl;
else
cout << "C -1" << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T, class R>
istream& operator>>(istream& in, pair<T, R>& p) {
in >> p.first >> p.second;
return in;
}
template <class T>
istream& operator>>(istream& in, vector<T>& v) {
for (auto& x : v) {
in >> x;
}
return in;
}
const long long int mx = 210005;
vector<long long int> a, b, v;
vector<vector<long long int> > g;
long long int n, k1, k2;
long long int findClosest(const long long int& x) {
v[x] = 1;
if (a[x]) {
return x;
}
for (const auto& nx : g[x]) {
if (!v[nx]) {
int vl;
if ((vl = findClosest(nx)) != -1) {
return vl;
}
}
}
return -1;
}
void read(long long int& x) {
cin >> x;
x--;
}
void print(const char& c, const long long int& x) {
cout << c << " " << x + 1 << endl;
cout.flush();
}
void testcase() {
cin >> n;
g.clear();
g.resize(n, vector<long long int>());
a.clear();
a.resize(n, 0);
b.clear();
b.resize(n, 0);
v.clear();
v.resize(n, 0);
for (long long int i = 0; i < (n - 1); i++) {
long long int x, y;
read(x);
read(y);
g[x].push_back(y);
g[y].push_back(x);
}
cin >> k1;
for (long long int i = 0; i < (k1); i++) {
long long int x;
read(x);
a[x] = 1;
}
cin >> k2;
long long int nd2, nd1;
for (long long int i = 0; i < (k2); i++) {
long long int x;
read(x);
b[x] = 1;
nd2 = x;
}
print('B', nd2);
read(nd1);
nd1 = findClosest(nd1);
print('A', nd1);
read(nd2);
if (b[nd2]) {
print('C', nd1);
} else {
cout << "C -1\n";
cout.flush();
}
return;
}
int main() {
ios_base::sync_with_stdio(0);
long long int t;
cin >> t;
while (t--) {
testcase();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int t, n;
vector<int> graph[1005];
bool st1[1005], st2[1005];
bool visited[1005];
bool finished;
void dfs(int node) {
if (st1[node]) {
cout << "A " << node << "\n";
int node1;
cin >> node1;
cout << "C ";
if (st2[node1]) {
cout << node << "\n";
} else {
cout << -1 << "\n";
}
finished = true;
cout.flush();
return;
}
visited[node] = true;
for (auto c : graph[node]) {
if (!visited[c]) {
dfs(c);
if (finished) {
return;
}
}
}
}
int main() {
cin >> t;
while (t--) {
for (int i = 1; i <= n; ++i) {
graph[i].clear();
st1[i] = false;
st2[i] = false;
visited[i] = false;
finished = false;
}
cin >> n;
for (int i = 0; i < n - 1; ++i) {
int u, v;
cin >> u >> v;
graph[u].push_back(v);
graph[v].push_back(u);
}
int k1;
cin >> k1;
for (int i = 0; i < k1; ++i) {
int x;
cin >> x;
st1[x] = true;
}
int k2;
cin >> k2;
int s;
for (int i = 0; i < k2; ++i) {
int x;
cin >> x;
st2[x] = true;
if (i == 0) {
s = x;
}
}
cout << "B " << s << "\n";
cin >> s;
dfs(s);
}
return 0;
}
|
#include <bits/stdc++.h>
template <typename T1, typename T2>
inline void chmin(T1 &a, T2 b) {
if (a > b) a = b;
}
template <typename T1, typename T2>
inline void chmax(T1 &a, T2 b) {
if (a < b) a = b;
}
using namespace std;
class Solve {
public:
int n;
vector<vector<int>> treeone;
vector<int> dist;
vector<int> tapu;
vector<int> tapi;
void input() {
cin >> n;
treeone.resize(n + 1);
for (int i = int(0); i < int(n - 1); i++) {
int a, b;
cin >> a >> b;
treeone[a].push_back(b);
treeone[b].push_back(a);
}
int k;
cin >> k;
for (int i = int(0); i < int(k); i++) {
int tmp;
cin >> tmp;
tapu.push_back(tmp);
}
cin >> k;
for (int i = int(0); i < int(k); i++) {
int tmp;
cin >> tmp;
tapi.push_back(tmp);
}
}
void query(char c, int n) { cout << c << " " << n << endl; }
void bfs(int s) {
dist.resize(n + 1, (1 << 30) - 1);
queue<int> que;
dist[s] = 0;
que.push(s);
while (!que.empty()) {
int top = que.front();
que.pop();
for (auto e : treeone[top]) {
int nd = dist[top] + 1;
if (dist[e] > nd) {
dist[e] = nd;
que.push(e);
}
}
}
}
void solve() {
input();
query('B', tapi[0]);
int start;
cin >> start;
bfs(start);
int r = -1;
int min_dist = (1 << 30) - 1;
for (auto e : tapu) {
if (dist[e] < min_dist) {
r = e;
min_dist = dist[e];
}
}
if (r == -1) {
query('C', -1);
return;
}
query('A', r);
int tapya;
cin >> tapya;
if (find(begin(tapi), end(tapi), tapya) != tapi.end()) {
query('C', r);
} else {
query('C', -1);
}
}
};
int main() {
int t;
cin >> t;
while (t--) {
Solve().solve();
}
return 0;
}
|
#include <bits/stdc++.h>
clock_t t_;
using namespace std;
int main(int argc, const char* argv[]) {
t_ = clock();
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> edges[1010];
int a, b;
for (int i = int(0); i < int(n - 1); i++) {
cin >> a >> b;
edges[a].push_back(b);
edges[b].push_back(a);
}
int k1;
cin >> k1;
set<int> xs;
for (int i = int(0); i < int(k1); i++) {
cin >> a;
xs.insert(a);
}
int k2;
set<int> ys;
cin >> k2;
for (int i = int(0); i < int(k2); i++) {
cin >> a;
ys.insert(a);
}
int resp;
cout << "B " << a << endl;
cout << flush;
cin >> resp;
if (xs.find(resp) != xs.end()) {
cout << "C " << resp << endl;
cout << flush;
} else {
queue<int> q;
vector<int> dist(n + 7, -1);
q.push(resp);
dist[resp] = 0;
while (xs.find(q.front()) == xs.end()) {
int fr = q.front();
q.pop();
for (int i = int(0); i < int(edges[fr].size()); i++) {
int to = edges[fr][i];
if (dist[to] == -1) {
dist[to] = dist[fr] + 1;
q.push(to);
}
}
}
a = q.front();
cout << "A " << a << endl;
cout << flush;
cin >> resp;
if (ys.find(resp) != ys.end()) {
cout << "C " << a << endl;
cout << flush;
} else {
cout << "C " << -1 << endl;
cout << flush;
}
}
}
t_ = clock() - t_;
cerr << setprecision(9) << fixed << ((float)t_ / CLOCKS_PER_SEC) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 7, M = 998244353, N = 1e5 + 7;
int f[N], inv[N], fi[N];
int INV(int i) {
if (i == 1) return 1;
return M - (long long)M / i * INV(M % i) % M;
}
int C(int n, int k) { return (long long)f[n] * fi[k] % M * fi[n - k] % M; }
int H(int n, int k) {
if (n == 0) return k == 0;
return C(n + k - 1, k);
}
void add(int& a, int b) {
a += b;
if (a >= M) a -= M;
}
signed main() {
std::ios::sync_with_stdio(0);
std::cin.tie(0);
;
f[0] = 1;
for (int i = 1; i < N; i++) f[i] = (long long)f[i - 1] * i % M;
inv[1] = 1;
for (int i = 2; i < N; i++) inv[i] = M - (long long)M / i * inv[M % i] % M;
fi[0] = 1;
for (int i = 1; i < N; i++) fi[i] = (long long)fi[i - 1] * inv[i] % M;
int p, s, r;
cin >> p >> s >> r;
if (p == 1) return cout << 1 << endl, 0;
auto go = [&](int score, int cnt, int sum) {
if (cnt == 0) return sum ? 0 : 1;
if (score == 0) return cnt ? 0 : 1;
int ans = 0;
for (int illegal = 0; illegal <= cnt; illegal++) {
int ways = C(cnt, illegal);
int rem_sum = sum - score * illegal;
if (rem_sum < 0) continue;
ways = (long long)ways * H(cnt, rem_sum) % M;
if (illegal & 1) ways = M - ways;
add(ans, ways);
}
return ans;
};
int yes = 0, all = 0;
for (int score = r; score <= s; score++) {
int tot_ways = H(p - 1, s - score);
add(all, tot_ways);
for (int same = 0; same <= p - 1; same++) {
int rem_sum = s - (same + 1) * score, rem_cnt = p - 1 - same;
if (rem_sum < 0) continue;
int ways = (long long)go(score, rem_cnt, rem_sum) * C(p - 1, same) % M;
ways = (long long)ways * inv[same + 1] % M;
add(yes, ways);
}
}
int ans = (long long)yes * INV(all) % M;
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int64_t MOD = 998244353;
void add(int64_t& a, int64_t b) { a = (a + b) % MOD; }
void mul(int64_t& a, int64_t b) { a = a * b % MOD; }
vector<int64_t> fact, seq_inv, fact_inv;
void create_fact_mod(int num) {
fact[0] = 1;
fact[1] = 1;
for (int i = 2; i <= num; i++) {
fact[i] = fact[i - 1] * i % MOD;
}
}
void create_seq_inv_mod(int num) {
seq_inv[0] = 1;
seq_inv[1] = 1;
for (int i = 2; i <= num; i++) {
seq_inv[i] = (MOD - MOD / i) * seq_inv[MOD % i] % MOD;
}
}
void create_fact_inv_mod(int num) {
fact_inv[0] = 1;
fact_inv[1] = 1;
for (int i = 2; i <= num; i++) {
fact_inv[i] = fact_inv[i - 1] * seq_inv[i] % MOD;
}
}
void create_mod_tables(int num) {
fact.resize(num + 1);
seq_inv.resize(num + 1);
fact_inv.resize(num + 1);
create_fact_mod(num);
create_seq_inv_mod(num);
create_fact_inv_mod(num);
}
int64_t comb_mod(int n, int k) {
return fact[n] * fact_inv[n - k] % MOD * fact_inv[k] % MOD;
}
int64_t perm_mod(int n, int k) { return fact[n] * fact_inv[n - k] % MOD; }
int64_t power_mod(int64_t num, int64_t power) {
int64_t prod = 1;
num %= MOD;
while (power > 0) {
if (power & 1) prod = prod * num % MOD;
num = num * num % MOD;
power >>= 1;
}
return prod;
}
int64_t extgcd(int64_t a, int64_t b, int64_t& x, int64_t& y) {
int64_t d = a;
if (b != 0) {
d = extgcd(b, a % b, y, x);
y -= (a / b) * x;
} else {
x = 1;
y = 0;
}
return d;
}
int64_t inv_mod(int64_t a) {
int64_t x, y;
extgcd(a, MOD, x, y);
return (MOD + x % MOD) % MOD;
}
int P, S, R;
int64_t calc(int people, int sum, int limit) {
if (people == 0) return (sum == 0 ? 1 : 0);
int64_t ret = 0;
for (int over = 0; over <= people && over * limit <= sum; over++) {
int64_t result = comb_mod(people, over);
int64_t rest = sum - over * limit;
mul(result, comb_mod(rest + people - 1, people - 1));
add(ret, (over % 2 ? MOD - result : result));
}
return ret;
}
int main() {
cin >> P >> S >> R;
create_mod_tables(10000);
int64_t ans = 0;
for (int a = R; a <= S; a++) {
for (int b = 1; b <= P && a * b <= S; b++) {
int64_t result = comb_mod(P - 1, b - 1) * calc(P - b, S - a * b, a) % MOD;
mul(result, inv_mod(b));
add(ans, result);
}
}
mul(ans, inv_mod(comb_mod(S - R + P - 1, P - 1)));
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int C[5500][5500];
class Solution {
const int MOD = 998244353;
int inv(int x) {
return x == 1 ? 1 : 1ll * (MOD - MOD / x) * inv(MOD % x) % MOD;
}
void init() {
for (int i = 0; i < 5500; ++i) {
C[i][i] = C[i][0] = 1;
for (int j = 1; j < i; ++j) {
C[i][j] = C[i - 1][j] + C[i - 1][j - 1];
if (C[i][j] >= MOD) C[i][j] -= MOD;
}
}
}
int dp(int p, int s, int m) {
if (p == 0) return s == 0;
int ans = 0;
for (int i = 0; p - 1 + s - i * m >= 0 and i <= p; ++i) {
ans += 1ll * C[p - 1 + s - i * m][p - 1] * (i & 1 ? MOD - 1 : 1) % MOD *
C[p][i] % MOD;
if (ans >= MOD) ans -= MOD;
}
return ans;
}
int p, s, r;
public:
void run(istream &in, ostream &out) {
in >> p >> s >> r;
if (p == 1) return out << 1 << '\n', void();
init();
long long ans = 0;
const int ALL = C[p - 1 + s - r][p - 1];
for (int score = r; score <= s; ++score) {
for (int i = 1; i <= p; ++i) {
ans += 1ll * inv(i) * C[p - 1][i - 1] % MOD *
dp(p - i, s - score * i, score) % MOD;
cerr << dp(p - i, s - score * i, score) << '\n';
if (ans >= MOD) ans -= MOD;
}
}
out << 1ll * ans * inv(ALL) % MOD << '\n';
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
Solution().run(cin, cout);
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9')
x = (x << 3) + (x << 1) + (c ^ '0'), c = getchar();
return x * f;
}
const int N = 6e3 + 5, M = 205, mod = 998244353;
inline int inc(int x, int y) {
x += y - mod;
return x + (x >> 31 & mod);
}
inline int del(int x, int y) {
x -= y;
return x + (x >> 31 & mod);
}
inline int mul(int x, int y) { return 1ll * x * y % mod; }
inline void Inc(int &x, int y) { x = inc(x, y); }
inline void Del(int &x, int y) { x = del(x, y); }
inline long long Pow(long long x, int k) {
long long res = 1;
while (k) {
if (k & 1) res = res * x % mod;
x = x * x % mod;
k >>= 1;
}
return res;
}
int c[N][N];
void init(int n, int m) {
c[0][0] = 1;
for (int i = 1; i <= n; i++) {
c[i][0] = 1;
for (int j = 1; j <= min(i, m); j++)
c[i][j] = inc(c[i - 1][j - 1], c[i - 1][j]);
}
}
inline int C(const int n, const int m) {
if (n < m || n < 0 || m < 0) return 0;
return c[n][m];
}
inline int calc(const int n, const int m, const int x) {
if (n == 0) return 1;
if (n < 0) return 0;
int res = 0;
for (int i = 0, k = -1; i <= m; i++) {
k *= -1;
if (k > 0)
Inc(res, mul(C(m, i), C(n - i * x + m - 1, m - 1)));
else
Del(res, mul(C(m, i), C(n - i * x + m - 1, m - 1)));
}
return res;
}
int p, s, r, ans, inv[M];
int main() {
p = read(), s = read(), r = read();
init(s + p, 100);
for (int i = 1; i <= p; i++) inv[i] = Pow(i, mod - 2);
for (int x = r; x <= s; x++)
for (int i = 1; i <= p; i++) {
if ((p - i) * (x - 1) + i * x < s) continue;
Inc(ans, mul(mul(C(p - 1, i - 1), calc(s - i * x, p - i, x)), inv[i]));
}
printf("%d\n", mul(ans, Pow(C(s - r + p - 1, p - 1), mod - 2)));
return 0;
}
|
#include <bits/stdc++.h>
std::mt19937 rng(
(int)std::chrono::steady_clock::now().time_since_epoch().count());
const int ms = 100100;
const long long MOD = 998244353;
long long fexp(long long x, long long e = MOD - 2) {
long long ans = 1;
for (; e > 0; e /= 2) {
if (e & 1) ans = ans * x % MOD;
x = x * x % MOD;
}
return ans;
}
long long inv[ms];
long long fat[ms], ifat[ms];
long long comb(int n, int a) {
if (a < 0 || a > n)
return 0;
else
return fat[n] * ifat[a] % MOD * ifat[n - a] % MOD;
}
long long sum(int S, int K, int m) {
if (S == 0 && K == 0) return 1;
long long ans = 0;
for (int i = 0; i <= K && i * m <= S; i++) {
long long cur = comb(S - i * m + K - 1, K - 1) * comb(K, i) % MOD;
if (i % 2 == 1) {
cur = (MOD - cur) % MOD;
}
ans = (ans + cur) % MOD;
}
return ans;
}
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(NULL);
int p, s, r;
std::cin >> p >> s >> r;
fat[0] = ifat[0] = 1;
for (int i = 1; i < ms; i++) {
inv[i] = fexp(i);
fat[i] = fat[i - 1] * i % MOD;
ifat[i] = ifat[i - 1] * inv[i] % MOD;
}
long long q = 0;
long long ans = 0;
for (int v = r; v <= s; v++) {
for (int o = 0; o + 1 <= p && v * (o + 1) <= s; o++) {
int x = p - (o + 1);
if (x > 0 && v == 0) continue;
ans = (ans +
sum(s - v * (o + 1), x, v) * comb(p - 1, o) % MOD * inv[o + 1]) %
MOD;
}
q = (q + sum(s - v, p - 1, s + 1)) % MOD;
}
std::cout << ans * fexp(q) % MOD << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
int n, s, r, ans;
int inv[10010], fac[10010];
template <typename T>
void chkmin(T &x, T y) {
x = min(x, y);
}
template <typename T>
void chkmax(T &x, T y) {
x = max(x, y);
}
template <typename T>
void read(T &x) {
x = 0;
int f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
x *= f;
}
void update(int &x, int y) {
x = (x + y >= 998244353) ? (x + y - 998244353) : (x + y);
}
int mul(int x, int y) { return 1ll * x * y % 998244353; }
int inc(int x, int y) {
return (x + y >= 998244353) ? (x + y - 998244353) : (x + y);
}
int dec(int x, int y) { return (x - y < 0) ? (x - y + 998244353) : (x - y); }
int qpow(int a, int b) {
int ret = 1;
while (b) {
if (b & 1) ret = 1ll * ret * a % 998244353;
a = 1ll * a * a % 998244353;
b >>= 1;
}
return ret;
}
void init(int n) {
fac[0] = inv[0] = 1;
for (int i = 1; i <= n; ++i) fac[i] = mul(fac[i - 1], i);
inv[n] = qpow(fac[n], 998244353 - 2);
for (int i = n - 1; i >= 1; --i) inv[i] = mul(inv[i + 1], i + 1);
}
int C(int n, int m) {
if (m < 0 || m > n) return 0;
return mul(fac[n], mul(inv[m], inv[n - m]));
}
int calc(int n, int m) {
if (n == 0 && m == 0) return 1;
return C(n + m - 1, m - 1);
}
int work(int n, int s, int lim) {
if (s < 0) return 0;
if (s == 0) return 1;
int ret = 0;
for (int i = 0; i <= n; ++i) {
int tmp = mul(C(n, i), calc(s - i * (lim + 1), n));
if (i & 1)
ret = dec(ret, tmp);
else
ret = inc(ret, tmp);
}
return ret;
}
int main() {
read(n), read(s), read(r);
init(10010 - 2);
if (r == 0 && s == 0) update(ans, qpow(n, 998244353 - 2));
for (int i = max(r, 1); i <= s; ++i)
for (int j = 1; j <= n; ++j) {
int tmp = work(n - j, s - i * j, i - 1);
int coef = C(n - 1, j - 1);
coef = mul(coef, qpow(j, 998244353 - 2));
update(ans, mul(coef, tmp));
}
int tim = 0;
for (int i = r; i <= s; ++i) update(tim, calc(s - i, n - 1));
ans = mul(ans, qpow(tim, 998244353 - 2));
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const int mod = 998244353;
const double eps = 1e-8;
long long comb[5201][5201], p, s, r;
long long fastPow(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a % mod;
a = a * a % mod;
b >>= 1;
}
return ans;
}
long long calc(long long p, long long up, long long sum) {
if (p == 0) return sum == 0;
long long ans = 0;
for (int i = 0; i <= p; i++) {
if (i * up > sum) break;
if (i & 1)
ans = (ans - comb[p][i] * comb[sum - i * up + p - 1][p - 1] % mod + mod) %
mod;
else
ans = (ans + comb[p][i] * comb[sum - i * up + p - 1][p - 1] % mod) % mod;
}
return ans;
}
int main() {
for (int i = 0; i <= 5200; i++)
for (int j = comb[i][0] = 1; j <= i; j++)
comb[i][j] = (comb[i - 1][j] + comb[i - 1][j - 1]) % mod;
scanf("%lld%lld%lld", &p, &s, &r);
if (p == 1) {
puts("1");
} else if (s == 0) {
printf("%d\n", fastPow(p, mod - 2));
} else {
long long Q = 0, P = 0;
for (int i = r; i <= s; i++) {
Q = (Q + comb[s - i + p - 2][p - 2]) % mod;
for (int j = 0; j < p && j * i + i <= s; j++) {
long long cnt1 = comb[p - 1][j];
long long cnt2 = calc(p - j - 1, i, s - (j * i + i));
P = (P + cnt1 * cnt2 % mod * fastPow(j + 1, mod - 2) % mod) % mod;
}
}
printf("%lld\n", P * fastPow(Q, mod - 2) % mod);
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
#pragma GCC optimize("unroll-loops")
using namespace std;
const long double eps = 1e-7;
const int inf = 1000000010;
const long long INF = 10000000000000010LL;
const int mod = 998244353;
const int MAXN = 5110, LOG = 20;
long long n, s, r, u, v, x, y, t, a, b, ans;
long long F[MAXN], I[MAXN];
long long dp[110];
long long powmod(long long a, long long b) {
if (!b) return 1;
if (b & 1) return a * powmod(a * a % mod, b >> 1) % mod;
return powmod(a * a % mod, b >> 1);
}
long long C(long long n, long long r) {
if (n < 0 || n < r) return 0;
return (F[n] * I[r] % mod) * I[n - r] % mod;
}
long long count(long long k, long long n) {
if (!k && !n) return 1;
return C(n + k - 1, k - 1);
}
long long f(long long n, long long sum, long long lim) {
long long res = 0;
for (int i = 0; i <= n && i * lim <= sum; i++) {
long long tmp = count(n, sum - lim * i) * C(n, i) % mod;
if (i & 1) tmp = -tmp;
res += tmp;
}
return res % mod;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
F[0] = 1;
for (int i = 1; i < MAXN; i++) F[i] = F[i - 1] * i % mod;
I[MAXN - 1] = powmod(F[MAXN - 1], mod - 2);
for (int i = MAXN - 1; i; i--) I[i - 1] = I[i] * i % mod;
cin >> n >> s >> r;
for (int x = r; x <= s; x++)
for (int t = 1; t <= n && t * x <= s; t++)
ans += C(n, t) * f(n - t, s - t * x, x) % mod;
ans %= mod;
ans = ans * powmod(C(s - r + n - 1, n - 1), mod - 2) % mod;
ans = ans * powmod(n, mod - 2) % mod;
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
long long p, r, s, ans, fact[6010];
long long winHasMoreThanr, oneHasMoreThanr;
long long pw(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) {
res *= a;
res %= mod;
}
a *= a;
a %= mod;
b >>= 1;
}
return res;
}
void precalc() {
fact[0] = fact[1] = 1;
for (long long i = 2; i <= 6000; ++i) {
fact[i] = fact[i - 1] * i;
fact[i] %= mod;
}
}
long long aCb(long long a, long long b) {
if (a < b or b < 0) {
return 0;
}
return ((fact[a] * pw((fact[b] * fact[a - b]) % mod, mod - 2)) % mod);
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
precalc();
cin >> p >> s >> r;
for (long long i = 1, sgn = 1; i <= p; ++i, sgn *= -1) {
winHasMoreThanr +=
sgn * ((aCb(p, i) * aCb(s - i * r + p - 1, p - 1)) % mod);
winHasMoreThanr %= mod;
if (winHasMoreThanr < 0) {
winHasMoreThanr += mod;
}
}
oneHasMoreThanr = aCb(s - r + p - 1, p - 1);
ans = winHasMoreThanr;
ans *= pw(p, mod - 2);
ans %= mod;
ans *= pw(oneHasMoreThanr, mod - 2);
ans %= mod;
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
using minpq = priority_queue<T, vector<T>, greater<T>>;
template <int m>
struct mod {
long long x;
mod() : x(0) {}
mod(long long xx) : x(xx) {
if (abs(x) >= m) x %= m;
if (x < 0) x += m;
}
mod operator+(const mod &a) const {
mod n;
n.x = x + a.x;
if (n.x >= m) n.x -= m;
return n;
}
mod operator-(const mod &a) const {
mod n;
n.x = x - a.x;
if (n.x < 0) n.x += m;
return n;
}
mod operator*(const mod &a) const { return x * a.x; }
mod operator+=(const mod &a) {
x += a.x;
if (x >= m) x -= m;
return *this;
}
mod operator-=(const mod &a) {
x -= a.x;
if (x < 0) x += m;
return *this;
}
mod operator*=(const mod &a) {
x = (x * a.x) % m;
return *this;
}
mod pow(long long b) const {
mod ans = 1;
mod a = *this;
while (b > 0) {
if (b & 1) ans *= a;
a *= a;
b /= 2;
}
return ans;
}
mod inv() const { return pow(m - 2); }
mod operator/(const mod &a) const { return (*this) * a.inv(); }
mod operator/=(const mod &a) { return (*this) *= a.inv(); }
bool operator==(const mod &o) const { return x == o.x; }
bool operator!=(const mod &o) const { return x != o.x; }
long long operator()() const { return x; }
};
template <int m>
istream &operator>>(istream &is, mod<m> &n) {
long long x;
is >> x;
n = x;
return is;
}
const int M = 998244353;
using base = mod<M>;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int p, s, r;
cin >> p >> s >> r;
int P = p + s + 5;
vector<vector<base>> choose(P, vector<base>(P));
for (int i = (0); i < (P); i++) {
for (int j = (0); j < (P); j++) {
if (j == 0)
choose[i][j] = 1;
else if (i == 0)
choose[i][j] = 0;
else
choose[i][j] = choose[i - 1][j] + choose[i - 1][j - 1];
}
}
base ans = 0;
vector<base> f;
for (int i = (1); i < (p + 1); i++) {
for (int k = r; k * i <= s; k++) {
base add = 0;
int sum = s - i * k;
int people = p - i;
int mx = k - 1;
if (people == 0) {
if (sum == 0) add += 1;
} else if (mx >= 0) {
for (int j = 0; (mx + 1) * j <= sum && j <= people; j++) {
base x = choose[people][j] *
choose[sum - (mx + 1) * j + people - 1][people - 1];
if (j % 2 == 0)
add += x;
else
add -= x;
}
}
ans += choose[p - 1][i - 1] * add / i;
}
}
base tot = choose[s - r + p - 1][p - 1];
ans /= tot;
cout << ans() << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void read(T &x) {
x = 0;
char c = getchar();
int f = 1;
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) x = x * 10 - '0' + c, c = getchar();
x *= f;
}
const int mod = 998244353;
long long frac[6100], inv[6100];
long long Pow(long long x, long long y) {
long long res = 1;
while (y) {
if (y & 1) res = res * x % mod;
x = x * x % mod, y >>= 1;
}
return res;
}
void predo(int n) {
frac[0] = 1;
for (int i = 1; i <= n; ++i) frac[i] = frac[i - 1] * i % mod;
inv[n] = Pow(frac[n], mod - 2);
for (int i = n - 1; i >= 0; --i) inv[i] = inv[i + 1] * (i + 1) % mod;
}
long long C(int n, int m) {
if (m > n || n < 0 || m < 0) return 0;
return frac[n] * inv[m] % mod * inv[n - m] % mod;
}
long long solve(int s, int n, int m) {
if (!n) return !s;
if (n * m < s) return 0;
long long ans = 0, f = -1;
for (int i = 0; i <= n; ++i)
f = -f, ans = (ans + f * C(n, i) * C(s - i * (m + 1) + n - 1, n - 1)) % mod;
return ans;
}
int main() {
int p, s, r;
read(p), read(s), read(r);
if (p == 1) return puts("1"), 0;
predo(p + s);
long long ans = 0;
for (int j = r; j <= s; ++j)
for (int k = 1; k * j <= s && k <= p; ++k)
ans = (ans + solve(s - (k * j), p - k, j - 1) * C(p - 1, k - 1) % mod *
Pow(k, mod - 2)) %
mod;
ans = ans * Pow(C(s - r + p - 1, p - 1), mod - 2) % mod;
printf("%lld\n", (ans + mod) % mod);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int hgs = 998244353, N = 5500;
int fac[N], inv[N], n = 5200, s, p, r, inv2[N];
int qpow(int A, int B) {
int C = 1;
for (; B; B >>= 1, A = 1ll * A * A % hgs)
if (B & 1) C = 1ll * A * C % hgs;
return C;
}
void prep() {
fac[0] = inv[0] = 1;
for (register int i = (1); i <= (n); ++i) fac[i] = 1ll * i * fac[i - 1] % hgs;
inv[n] = qpow(fac[n], hgs - 2);
for (register int i = (n - 1); i >= (1); --i)
inv[i] = 1ll * (i + 1) * inv[i + 1] % hgs;
for (register int i = (1); i <= (n); ++i) inv2[i] = qpow(i, hgs - 2);
}
void upd(int &x, int y) { x = (x + y) % hgs; }
void ret(int &x) { x = (x % hgs + hgs) % hgs; }
int C(int A, int B) {
if (A < 0 || B < 0 || B - A < 0) return 0;
return 1ll * fac[B] * inv[A] % hgs * inv[B - A] % hgs;
}
int S(int A, int B) { return C(B - 1, A + B - 1); }
int calc(int rs, int rsp, int ove) {
if (rs == 0) return 1;
int ans = 0;
long long nw = 1;
for (register int i = (0); i <= (rsp); ++i) {
if (i * ove > rs) break;
upd(ans, 1ll * nw * S(rs - i * ove, rsp) * C(i, rsp) % hgs);
ret(ans);
nw = -nw;
}
return ans;
}
int g(int x) {
int rs = s - x, ans = 0;
for (register int i = (0); i <= (p - 1); ++i) {
if (i * x > rs) break;
if ((p - 1 - i) * (x - 1) + (i + 1) * x < s) continue;
upd(ans, 1ll * inv2[i + 1] * calc(rs - i * x, p - (i + 1), x) % hgs *
C(i, p - 1) % hgs);
}
return ans;
}
signed main() {
int ans = 0;
cin >> p >> s >> r;
prep();
for (register int i = (r); i <= (s); ++i) upd(ans, g(i));
int t = S(s - r, p);
cout << 1ll * ans * qpow(t, hgs - 2) % hgs << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, s, r;
const long long mod = 998244353;
long long dp[105][5005], pw[105][5005], fact[50005], invfact[50005];
long long inv(long long a) {
long long b = mod - 2;
long long rez = 1;
while (b) {
if (b & 1) rez = (rez * a) % mod;
a = (a * a) % mod;
b /= 2;
}
return rez;
}
long long comb(long long a, long long b) {
if (a < b) return 0;
long long rez = fact[a];
rez = (rez * invfact[b]) % mod;
rez = (rez * invfact[a - b]) % mod;
return rez;
}
long long stars_and_bars(long long bile, long long urne) {
return comb(bile + urne - 1, urne - 1);
}
int main() {
cin >> n >> s >> r;
for (long long i = 1; i <= n; i++) {
pw[i][0] = 1;
for (int j = 1; j <= s; j++) pw[i][j] = (pw[i][j - 1] * 1LL * i) % mod;
}
fact[0] = 1;
invfact[0] = 1;
for (long long i = 1; i <= 50000; i++) {
fact[i] = (fact[i - 1] * i) % mod;
invfact[i] = inv(fact[i]) % mod;
}
for (int i = 1; i <= n; i++)
for (int x = 1; x <= s + 1; x++) {
bool ok = 0;
if (i == 2 && x == 4) ok = 1;
long long lft = s - (n - i) * x;
for (int nums = 0; nums <= i; nums++) {
long long suma = lft - nums * x;
if (suma < 0) break;
long long val = (stars_and_bars(suma, i) * comb(i, nums)) % mod;
if (nums % 2 == 0) {
dp[i][x] = (dp[i][x] + val);
if (dp[i][x] >= mod) dp[i][x] -= mod;
} else {
dp[i][x] = (dp[i][x] - val);
if (dp[i][x] < 0) dp[i][x] += mod;
}
}
}
long long ans = 0;
long long total = stars_and_bars(s - r, n);
for (int nr = 1; nr < n; nr++)
for (int val = r; val <= s; val++) {
long long lft = n - nr;
long long slft = s - val * nr;
if (slft < 0) continue;
long long states = (dp[lft][val] * comb(n - 1, nr - 1)) % mod;
states = (states * inv(nr)) % mod;
states = (states * inv(total)) % mod;
ans = (ans + states) % mod;
}
if (s % n == 0 && s / n >= r) {
long long val = (inv(n) * inv(total)) % mod;
ans = (ans + val) % mod;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 998244353;
long long mod_inv(long long a, long long m = MOD) {
return a == 1 ? 1 : m - mod_inv(m % a, a) * m / a;
}
int mod_add(int a, int b) {
int sum = a + b;
return sum >= MOD ? sum - MOD : sum;
}
int mod_sub(int a, int b) {
int diff = a - b;
return diff < 0 ? diff + MOD : diff;
}
vector<vector<long long>> choose;
void prepare_choose(int max) {
choose.resize(max + 1);
for (int n = 0; n <= max; n++) {
choose[n].resize(n + 1);
choose[n][0] = choose[n][n] = 1;
for (int r = 1; r < n; r++)
choose[n][r] = mod_add(choose[n - 1][r - 1], choose[n - 1][r]);
}
}
int ways_to_distribute(int score, int players) {
if (score <= 0 || players <= 0) return score == 0 ? 1 : 0;
return choose[score + players - 1][score];
}
int ways_to_distribute_bounded(int players, int me, int sum) {
int total = 0;
for (int p = 0; p <= players; p++) {
int ways = (long long)choose[players][p] *
ways_to_distribute(sum - me * p, players) % MOD;
if (p % 2 == 0)
total = mod_add(total, ways);
else
total = mod_sub(total, ways);
}
return total;
}
int main() {
int P, S, R;
cin >> P >> S >> R;
prepare_choose(S + P);
if (P == 1) {
cout << 1 << '\n';
return 0;
}
if (S == 0) {
cout << mod_inv(P) << '\n';
return 0;
}
long long total = 0, denominator = 0;
for (int me = R; me <= S; me++) {
long long ways = ways_to_distribute(S - me, P - 1);
denominator = (denominator + ways) % MOD;
if (me > S - me) {
total = (total + ways) % MOD;
continue;
}
if (me * P < S) continue;
int max_same = S / me;
assert(max_same >= 2 && max_same <= P);
for (int same = max_same; same > 0; same--) {
long long less_than =
ways_to_distribute_bounded(P - same, me, S - same * me);
total =
(total + less_than * choose[P - 1][same - 1] % MOD * mod_inv(same)) %
MOD;
}
}
total %= MOD;
total = total * mod_inv(denominator) % MOD;
cout << total << '\n';
}
|
#include <bits/stdc++.h>
const int Mod = 998244353;
inline int chk(int x) {
if (x < 0) x += Mod;
if (x >= Mod) x -= Mod;
return x;
}
inline int qPow(int b, int e) {
int a = 1;
for (; e; b = (long long)b * b % Mod, e >>= 1)
if (e & 1) a = (long long)a * b % Mod;
return a;
}
int p, s, r, c[5105][105];
void Init() {
for (int i = 0; i <= 5100; ++i) c[i][0] = 1;
for (int i = 0; i <= 5100; ++i)
for (int j = 1; j <= i && j <= 100; ++j)
c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % Mod;
}
inline int Calc(int n, int m, int x) {
long long S = 0;
for (int i = 0; i <= m && i * x <= n; ++i) {
long long s = (long long)c[m][i] * c[n - x * i + m - 1][m - 1] % Mod;
S += i & 1 ? -s : s;
}
return (S % Mod + Mod) % Mod;
}
int Sum1, Sum2;
int main() {
scanf("%d%d%d", &p, &s, &r);
if (p == 1) return puts("1"), 0;
Init();
for (int x = r; x <= s; ++x) {
if (x * p < s) continue;
for (int i = 1; i <= p; ++i) {
if (i * x > s || (p - i) * (x - 1) + i * x < s) continue;
if (i == p) {
Sum2 = (Sum2 + (i * x == s ? qPow(i, Mod - 2) : 0)) % Mod;
continue;
}
Sum2 = (Sum2 + (long long)c[p - 1][i - 1] * Calc(s - i * x, p - i, x) %
Mod * qPow(i, Mod - 2)) %
Mod;
}
}
Sum1 = c[s - r + p - 1][p - 1];
printf("%lld\n", (long long)Sum2 * qPow(Sum1, Mod - 2) % Mod);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 10006, M = 106, P = 998244353;
int jc[N], jcinv[N];
inline int ksm(int a, int b) {
int ans = 1;
while (b) {
if (b & 1) ans = (long long)ans * a % P;
a = (long long)a * a % P;
b >>= 1;
}
return ans;
}
inline int C(int b, int a) {
if (a == b) return 1;
if (a < 0 || a > b) return 0;
return (long long)jc[b] * jcinv[a] % P * jcinv[b - a] % P;
}
inline int g(int s, int p, int x) {
int ans = 0;
for (int i = 0; i <= p; i++)
ans = (ans + (long long)((i & 1) ? P - 1 : 1) * C(p, i) % P *
C(s + p - 1 - i * (x + 1), p - 1) % P) %
P;
return ans;
}
inline int inv(int x) { return (long long)jc[x - 1] * jcinv[x] % P; }
int main() {
jc[0] = 1;
for (int i = 1; i <= 10000; i++) jc[i] = (long long)jc[i - 1] * i % P;
jcinv[10000] = ksm(jc[10000], P - 2);
for (int i = 10000; i; i--) jcinv[i - 1] = (long long)jcinv[i] * i % P;
int p, s, r;
cin >> p >> s >> r;
int ans = 0;
for (int i = r; i <= s; i++)
for (int j = 1; j <= p; j++)
ans = (ans + (long long)C(p - 1, j - 1) * inv(j) % P *
g(s - i * j, p - j, i - 1) % P) %
P;
cout << ((long long)ans * ksm(C(s - r + p - 1, p - 1), P - 2) % P + P) % P
<< endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int p, s, r, M = 998244353;
long long iv[5100], f1[5100], f2[5100], ans;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
iv[1] = f1[0] = f1[1] = f2[0] = f2[1] = 1;
for (int i = 2; i < 5100; ++i) {
iv[i] = (M - M / i) * iv[M % i] % M;
f1[i] = f1[i - 1] * i % M;
f2[i] = f2[i - 1] * iv[i] % M;
}
cin >> p >> s >> r;
for (int i = 1; i <= p && s - r * i >= 0; ++i)
ans += (i & 1 ? 1 : -1) * f1[s - r * i + p - 1] * f2[s - r * i] % M *
f2[i] % M * f2[p - i] % M;
ans = (ans % M + M) * f1[p - 1] % M * f1[s - r] % M * f2[s - r + p - 1] % M;
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
long long fast(long long a, long long b) {
if (a == 0) return 0;
long long res = 1;
while (b) {
if (b & 1) res = res * a % 998244353;
a = a * a % 998244353;
b >>= 1;
}
return res;
}
long long frac[20005], inv[20005];
void init() {
frac[1] = frac[0] = 1;
for (long long i = 2; i < 20005; i++) frac[i] = frac[i - 1] * i % 998244353;
inv[20005 - 1] = fast(frac[20005 - 1], 998244353 - 2);
for (long long i = 20005 - 2; i >= 0; i--)
inv[i] = inv[i + 1] * (i + 1) % 998244353;
}
long long C(long long a, long long b) {
if (a == b) return 1;
if (b < 0 || b > a) return 0;
return frac[a] * inv[b] % 998244353 * inv[a - b] % 998244353;
}
long long cal(long long s, long long p, long long m) {
long long res = 0;
for (long long i = 0; i <= p; i++) {
res += (((i & 1 ? 998244353 - 1 : 1) *
(C(p, i) % 998244353 * C(s + p - 1 - i * (m + 1), p - 1) %
998244353) %
998244353) +
998244353) %
998244353;
res %= 998244353;
}
return res;
}
signed main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
init();
long long p, s, r;
cin >> p >> s >> r;
long long ans = 0;
long long tmp2 = fast(C(s - r + p - 1, p - 1), 998244353 - 2);
for (long long t = r; t <= s; t++) {
for (long long q = 1; q <= p; q++) {
long long tmp1 = cal(s - q * t, p - q, t - 1);
ans += C(p - 1, q - 1) % 998244353 * fast(q, 998244353 - 2) % 998244353 *
tmp1 % 998244353;
ans %= 998244353;
}
}
cout << ans * tmp2 % 998244353 << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long C[5210][5010], inv[110];
long long solve(int a, int b, int lim) {
if (lim < 0) return 0;
if (a == 0) return 1;
int i;
long long tot = 0, x = 1;
for (i = 0; i <= b; ++i) {
if (a + b - 1 - (lim + 1) * i >= 0 && b - 1 >= 0)
(tot += C[a + b - 1 - (lim + 1) * i][b - 1] * C[b][i] % 998244353ll *
x) %= 998244353ll,
(tot += 998244353ll) %= 998244353ll;
x = -x;
}
return tot;
}
long long ksm(long long x, long long y) {
long long qwq = 1;
while (y) {
if (y & 1) (qwq *= x) %= 998244353ll;
(x *= x) %= 998244353ll, y >>= 1;
}
return qwq;
}
int main() {
int s, r, p, i, j, k;
long long P = 0, Q, x;
scanf("%d", &p), scanf("%d", &s), scanf("%d", &r);
inv[1] = 1;
C[0][0] = 1;
for (i = 1; i <= s + p - 1; ++i) {
C[i][0] = 1;
for (j = 1; j <= p; ++j) {
if (j > i)
C[i][j] = 0;
else
C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % 998244353ll;
}
}
for (i = 2; i <= p; ++i)
inv[i] = (1ll * 998244353ll - 1ll * 998244353ll / i) *
inv[998244353ll % i] % 998244353ll;
Q = C[s + p - 1 - r][p - 1];
for (i = max(r, s / p); i <= s; ++i) {
for (j = 1; j <= p; ++j) {
if (i * j > s) break;
if (j == p && i * p == s) {
(P += inv[p]) %= 998244353ll;
continue;
}
(P += solve(s - i * j, p - j, i - 1) * C[p - 1][j - 1] % 998244353ll *
inv[j] % 998244353ll) %= 998244353ll;
}
}
cout << P * ksm(Q, 998244353ll - 2) % 998244353ll;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void chkmin(T &a, T b) {
if (a > b) a = b;
}
template <class T>
inline void chkmax(T &a, T b) {
if (a < b) a = b;
}
inline int read() {
int s = 0, f = 1;
char ch = getchar();
while (!isdigit(ch) && ch != '-') ch = getchar();
if (ch == '-') ch = getchar(), f = -1;
while (isdigit(ch)) s = s * 10 + ch - '0', ch = getchar();
return ~f ? s : -s;
}
const int mod = 998244353;
int inv[50020], jc[50020], jcn[50020];
inline int power(int a, int b) {
int ans = 1;
while (b) {
if (b & 1) ans = (long long)ans * a % mod;
b >>= 1;
a = (long long)a * a % mod;
}
return ans;
}
inline int C(int n, int m) {
if (n < 0 || n < m) return 0;
return 1ll * jc[n] * jcn[m] % mod * jcn[n - m] % mod;
}
int n, m, r;
inline void init() {
jc[0] = jc[1] = jcn[0] = jcn[1] = inv[1] = 1;
for (int i = (2), _end_ = (5e4); i <= _end_; i++)
inv[i] = (long long)(mod - mod / i) * inv[mod % i] % mod,
jc[i] = (long long)jc[i - 1] * i % mod,
jcn[i] = (long long)jcn[i - 1] * inv[i] % mod;
n = read();
m = read();
r = read();
}
inline void doing() {
int ans = 0, fas = 0;
fas = C(m - r + n - 1, n - 1);
for (int x = (r), _end_ = (m); x <= _end_; x++) {
for (int num = (1), _end_ = (n); num <= _end_; num++)
if (num * x <= m) {
int rest = m - num * x, renum = n - num,
xs = (long long)inv[num] * C(n - 1, num - 1) % mod;
if (renum == 0) {
if (rest == 0) ans = (ans + xs) % mod;
} else {
for (int j = (0), _end_ = (n - num); j <= _end_; j++) {
int re = rest - j * x;
if (re >= 0)
ans = (ans + (j & 1 ? -1 : 1) *
(long long)C(re + renum - 1, renum - 1) * xs %
mod * C(renum, j)) %
mod;
}
}
}
}
ans = (ans + mod) % mod;
ans = (long long)ans * power(fas, mod - 2) % mod;
printf("%d\n", ans);
}
int main() {
init();
doing();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long read() {
long long nm = 0, fh = 1;
char cw = getchar();
for (; !isdigit(cw); cw = getchar())
if (cw == '-') fh = -fh;
for (; isdigit(cw); cw = getchar()) nm = nm * 10 + (cw - '0');
return nm * fh;
}
long long n, m, fac[100020], ifac[100020], S, R, sum, ans;
long long qpow(long long x, long long sq) {
long long res = 1;
for (; sq; sq >>= 1, x = x * x % 998244353)
if (sq & 1) res = res * x % 998244353;
return res;
}
long long C(long long tot, long long tk) {
if (tot < 0 || tk < 0 || tot < tk) return 0ll;
return fac[tot] * ifac[tk] % 998244353 * ifac[tot - tk] % 998244353;
}
long long dev(long long tot, long long tk) {
if (!tk) {
return (tot != 0 ? 0 : 1);
}
if (tot < 0) return 0;
return C(tot + tk - 1, tk - 1);
}
int main() {
n = read(), m = read(), R = read(), fac[0] = 1;
for (long long i = 1; i < 100020; i++) fac[i] = fac[i - 1] * i % 998244353;
ifac[100020 - 1] = qpow(fac[100020 - 1], 998244353 - 2);
for (long long i = 100020 - 1; i; i--) ifac[i - 1] = ifac[i] * i % 998244353;
for (long long gg = R; gg <= m; gg++) {
long long res = 0, rem = m - gg;
for (long long ev = 0; ev < n; ev++) {
long long now = 0, rst = rem - ev * gg;
if (rst < 0) break;
for (long long i = 0, kd = 1; i <= n - ev - 1; i++, kd = -kd)
now +=
kd * C(n - 1 - ev, i) * dev(rst - i * gg, n - 1 - ev) % 998244353,
now %= 998244353;
ans += qpow(ev + 1, 998244353 - 2) * C(n - 1, ev) % 998244353 *
(now + 998244353) % 998244353,
(ans >= 998244353) ? (ans -= 998244353) : 0;
}
}
printf("%lld\n", ans * qpow(dev(m - R, n), 998244353 - 2) % 998244353);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 233;
int fac[maxn], inv[maxn];
const int mod = 998244353;
int p, s, r;
void add(int &x, int y) {
x += y;
if (x >= mod) x -= mod;
}
void sub(int &x, int y) {
x -= y;
if (x < 0) x += mod;
}
int pow_mod(int q, int w) {
int ret = 1;
while (w) {
if (w & 1) ret = 1ll * ret * q % mod;
q = 1ll * q * q % mod;
w >>= 1;
}
return ret;
}
int rev(int x) { return 1ll * inv[x] * fac[x - 1] % mod; }
int C(int x, int y) {
if (x < 0 || y < 0) return 0;
if (x < y) return 0;
return 1ll * fac[x] * inv[y] % mod * inv[x - y] % mod;
}
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
fac[0] = inv[0] = 1;
for (int i = 1; i < maxn; i++) {
fac[i] = 1ll * fac[i - 1] * i % mod;
inv[i] = pow_mod(fac[i], mod - 2);
}
cin >> p >> s >> r;
if (s == 0) {
cout << pow_mod(p, mod - 2) << "\n";
return 0;
}
int all = 0;
int res = 0;
for (int mx = r; mx <= s; mx++) {
if (p == 1) {
if (mx == s) add(all, 1);
} else
add(all, C(s - mx + p - 2, p - 2));
if (mx == 0) {
continue;
}
for (int cnt = 1; cnt <= min(p, s / mx); cnt++) {
int left = s - cnt * mx;
int y = p - cnt;
if (y == 0) {
if (left == 0) {
add(res, rev(cnt));
}
continue;
}
int tmp = 0;
for (int t = left % mx; t <= left; t += mx) {
assert((left - t) % mx == 0);
int times = 1ll * C(y + t - 1, t) * C(y, (left - t) / mx) % mod *
C(p - 1, cnt - 1) % mod;
if (((left - t) / mx) % 2)
sub(tmp, times);
else
add(tmp, times);
}
add(res, 1ll * tmp * rev(cnt) % mod);
}
}
cout << 1ll * res * pow_mod(all, mod - 2) % mod << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
const int N = 5001;
int ans;
int ni[101];
int a[N * 2], nia[N * 2], f[N + 10];
int n, r, s;
long long calc(long long x, long long y) {
long long z = 1;
while (y) {
if (y & 1) z = z * x % mod;
x = x * x % mod, y /= 2;
}
return z;
}
long long CC(int x, int y) {
return y < 0 || x < y ? 0 : 1ll * a[x] * nia[y] % mod * nia[x - y] % mod;
}
int add(int x, int y) {
x += y;
return x >= mod ? x - mod : x;
}
int sub(int x, int y) {
x -= y;
return x < 0 ? x + mod : x;
}
int mul(int x, int y) { return 1ll * x * y % mod; }
int get(int n, int s, int k) {
if (s < 0 || s > k * n) return 0;
if (!n && !s) return 1;
int v = 0;
int nn = (k >= 0 ? max(min(n, s / (k + 1)), 0) + 1 : 0);
for (int i = 0; i <= nn; i++) f[i] = 0;
for (int i = nn; i >= 0; i--) {
f[i] = mul(CC(n, i), CC(s - (k + 1) * i + n - 1, n - 1));
for (int j = i + 1; j <= nn; j++) f[i] = sub(f[i], mul(f[j], CC(j, i)));
}
v = f[0];
return v;
}
int main() {
scanf("%d %d %d", &n, &s, &r);
a[0] = 1;
for (int i = 1; i < N * 2; i++) a[i] = 1ll * a[i - 1] * i % mod;
nia[N * 2 - 1] = calc(a[N * 2 - 1], mod - 2);
for (int i = N * 2 - 2; i >= 0; i--)
nia[i] = 1ll * nia[i + 1] * (i + 1) % mod;
ni[0] = ni[1] = 1;
for (int i = 2; i <= n; i++)
ni[i] = 1ll * ni[mod % i] * (mod - mod / i) % mod;
for (int i = n; i >= 1; i--) {
for (int j = r; j * i <= s; j++)
ans = (ans + 1ll * CC(n - 1, i - 1) *
get(n - i, s - j * i, min(j - 1, s - j * i)) % mod *
ni[i]) %
mod;
}
long long all = 0;
if (n == 1 && r <= s) all = 1;
for (int j = r; j <= s; j++) all = add(all, CC(s - j + n - 2, n - 2));
printf("%lld\n", ans * calc(all, mod - 2) % mod);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline void read(long long &x) {
char ch;
bool flag = false;
for (ch = getchar(); !isdigit(ch); ch = getchar())
if (ch == '-') flag = true;
for (x = 0; isdigit(ch); x = x * 10 + ch - '0', ch = getchar())
;
x = flag ? -x : x;
}
inline void write(long long x) {
static const long long maxlen = 100;
static char s[maxlen];
if (x < 0) {
putchar('-');
x = -x;
}
if (!x) {
putchar('0');
return;
}
long long len = 0;
for (; x; x /= 10) s[len++] = x % 10 + '0';
for (long long i = len - 1; i >= 0; --i) putchar(s[i]);
}
inline void read(int &x) {
char ch;
bool flag = false;
for (ch = getchar(); !isdigit(ch); ch = getchar())
if (ch == '-') flag = true;
for (x = 0; isdigit(ch); x = x * 10 + ch - '0', ch = getchar())
;
x = flag ? -x : x;
}
template <typename T>
T gcd(T m, T n) {
if (!m || !n) return m | n;
if (m < 0) m = -m;
if (n < 0) n = -n;
long long p = 0;
while (!(m & 1) && !(n & 1)) m >>= 1, n >>= 1, ++p;
while (n) {
while (!(m & 1)) m >>= 1;
while (!(n & 1)) n >>= 1;
if (m >= n) std::swap(m, n);
n = (n - m) >> 1;
}
return m << p;
}
template <typename T>
std::pair<T, std::pair<T, T> > exgcd(T m, T n) {
using std::make_pair;
T x = 0, y = 1, xp = 1, yp = 0, xt, yt;
for (T r = m % n, q = m / n; r;) {
xt = xp - q * x, xp = x, x = xt;
yt = yp - q * y, yp = y, y = yt;
m = n, n = r, r = m % n, q = m / n;
}
return make_pair(n, make_pair(x, y));
}
template <typename T>
T modinv(T m, T n) {
std::pair<T, std::pair<T, T> > gxy = exgcd(m, n);
T loop = n / gxy.first;
T inv = gxy.second.first;
inv = inv % loop;
return inv < 0 ? inv + loop : inv;
}
const long long MAX_S = 5500;
long long C[MAX_S][MAX_S];
const long long P = 998244353;
long long get_C(long long n, long long m) {
if (n < m) return 0;
if (n < 0) return 0;
if (m < 0) return 0;
return C[n][m];
}
void prepare() {
C[0][0] = 1;
for (long long i = 1; i < MAX_S; i++) {
for (long long j = 0; j <= i; j++)
C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % P;
}
}
long long get_ans(long long n, long long s, long long lim) {
if (n == 0) return (s == 0) ? 1 : 0;
if (lim < 0) return 0;
if (n < 0) return 0;
if (s < 0) return 0;
long long ans = get_C(s + n - 1, n - 1);
long long op = -1;
for (long long m = 1; m <= n; m++) {
ans = ((ans +
op * get_C(s - (lim + 1) * m + n - 1, n - 1) * get_C(n, m) % P) %
P +
P) %
P;
op = -op;
}
return ans;
}
long long n, s, r;
int main() {
prepare();
read(n);
read(s);
read(r);
long long ans = 0;
for (long long i = r; i <= s; i++)
for (long long j = 1; (i * j <= s) && (j <= n); j++) {
ans = ((ans + 1ll * get_ans(n - j, s - i * j, i - 1) *
get_C(n - 1, j - 1) % P * modinv(j, P) % P) %
P +
P) %
P;
}
ans = 1ll * ans * modinv(get_C((s - r) + n - 1, n - 1), P) % P;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long M = 10006;
long long f[M], inv[M];
long long expo(long long base, long long exponent, long long mod) {
long long ans = 1;
while (exponent != 0) {
if (exponent & 1) ans = (1LL * ans * base) % mod;
base = (1LL * base * base) % mod;
exponent >>= 1;
}
return ans % mod;
}
void compute() {
f[0] = 1;
for (long long i = 1; i < M; i++) {
f[i] = (1LL * i * f[i - 1]) % 998244353;
}
inv[M - 1] = expo(f[M - 1], 998244353 - 2, 998244353);
for (long long i = M - 2; i >= 0; i--) {
inv[i] = (1LL * (i + 1) * inv[i + 1]) % 998244353;
}
}
long long C(long long n, long long r) {
return (1LL * ((1LL * f[n] * inv[r]) % 998244353) * inv[n - r]) % 998244353;
}
long long ff(long long n, long long s, long long u) {
if (n == 0) return s == 0;
if (s < 0 or u < 0) return 0;
long long ans = 0;
for (long long r = 0; r < n + 1; r++) {
long long k = s - (u + 1) * r;
if (k < 0) break;
if (r % 2) {
ans =
(ans - C(n, r) * C(n + k - 1, k) % 998244353 + 998244353) % 998244353;
} else {
ans =
(ans + C(n, r) * C(n + k - 1, k) % 998244353 + 998244353) % 998244353;
}
}
return ans;
}
long long inverse[1001];
void solve() {
compute();
for (long long i = 1; i < 1001; i++)
inverse[i] = expo(i, 998244353 - 2, 998244353);
long long p, s, r, ans = 0, den = 0;
cin >> p >> s >> r;
for (long long i = r; i < s + 1; i++) {
for (long long j = 1; j < p + 1; j++) {
ans = (ans + C(p - 1, j - 1) * ff(p - j, s - j * i, i - 1) % 998244353 *
inverse[j] % 998244353) %
998244353;
}
den = (den + ff(p - 1, s - i, s)) % 998244353;
}
ans = ans * expo(den, 998244353 - 2, 998244353) % 998244353;
cout << ans << '\n';
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
const int N = 6010;
const int moder = 998244353;
int comb[N][N];
void init() {
for (int i = 0; i < N; ++i) {
comb[i][0] = 1;
for (int j = 1; j <= i; ++j) {
comb[i][j] = (comb[i - 1][j - 1] + comb[i - 1][j]) % moder;
}
}
}
int sol(int n, int sum) { return comb[n + sum - 1][n - 1]; }
int powermod(int a, int exp) {
int ret = 1;
for (; exp > 0; exp >>= 1) {
if (exp & 1) {
ret = 1ll * ret * a % moder;
}
a = 1ll * a * a % moder;
}
return ret;
}
int main() {
init();
int p, s, r;
scanf("%d%d%d", &p, &s, &r);
int ans = 0;
for (int i = r; i <= s; ++i) {
for (int j = 0; j < p && (j + 1) * i <= s; ++j) {
int sum = 0, cnt = p - j - 1, left = s - (j + 1) * i;
if (!cnt) {
if (!left) {
sum = 1;
}
} else {
for (int k = 0; k <= cnt && k * i <= left; ++k) {
sum = (sum +
(k & 1 ? -1ll : 1ll) * comb[cnt][k] * sol(cnt, left - k * i)) %
moder;
}
}
ans = (ans +
1ll * sum * comb[p - 1][j] % moder * powermod(j + 1, moder - 2)) %
moder;
}
}
ans += ans < 0 ? moder : 0;
ans = 1ll * ans * powermod(sol(p, s - r), moder - 2) % moder;
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
long long C[5110][110], ans;
void pre() {
for (int i = 0; i <= 5100; i++) {
C[i][0] = 1;
for (int j = 1; j <= i && j <= 100; j++) {
C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % mod;
}
}
}
long long qpow(long long a, long long x) {
long long res = 1;
while (x) {
if (x & 1) {
res = res * a % mod;
}
a = a * a % mod;
x >>= 1;
}
return res;
}
long long Comb(int n, int m) {
if (n < m) return 0;
return C[n][m];
}
long long calc(int s, int n, int r) {
long long res = 0;
for (int i = 0; i <= n; i++) {
long long tmp = C[n][i] * Comb(s - i * r + n - 1, n - 1) % mod;
if (i & 1) {
res -= tmp;
if (res < 0) res += mod;
} else {
res += tmp;
if (res >= mod) res -= mod;
}
}
return res;
}
int n, s, r;
int main() {
scanf("%d %d %d", &n, &s, &r);
pre();
if (n == 1) {
printf("1\n");
return 0;
}
for (int i = r; i <= s; i++) {
for (int j = 0; j < n; j++) {
if (j == n - 1) {
ans += i * n == s ? qpow(j + 1, mod - 2) : 0;
if (ans >= mod) ans -= mod;
continue;
}
ans += (C[n - 1][j] * calc(s - i * (j + 1), n - j - 1, i) % mod) *
qpow(j + 1, mod - 2) % mod;
if (ans >= mod) ans -= mod;
}
}
printf("%lld\n", ans * qpow(Comb(s - r + n - 1, n - 1), mod - 2) % mod);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
int p, s, r;
long long fac[10005];
long long qpow(long long x, int y) {
long long sum = 1;
while (y) {
if (y & 1) {
sum = sum * x % mod;
}
x = x * x % mod;
y >>= 1;
}
return sum;
}
long long ny(int x) { return qpow(x, mod - 2); }
long long C(int n, int m) {
if (n < m || n < 0 || m < 0) return 0;
return fac[n] * ny(fac[m]) % mod * ny(fac[n - m]) % mod;
}
long long f(int n, int m, int lim) {
if (n == 0) return 1;
if (n < 0) return 0;
long long sum = 0;
for (int i = 0; i <= m; i++) {
long long t = (i & 1) ? (mod - 1ll) : 1ll;
sum = (sum + t * C(m, i) % mod * C(n - i * lim + m - 1ll, m - 1ll) % mod) %
mod;
}
return sum;
}
int main() {
scanf("%d%d%d", &p, &s, &r);
fac[0] = 1;
for (int i = 1; i <= 6000; i++) {
fac[i] = fac[i - 1] * i % mod;
}
long long ans = 0;
for (int i = r; i <= s; i++) {
for (int j = 1; j <= p; j++) {
if ((p - j) * (i - 1) + j * i < s) continue;
ans =
(ans + f(s - i * j, p - j, i) * C(p - 1, j - 1) % mod * ny(j) % mod) %
mod;
}
}
printf("%lld", ans * ny(C(s - r + p - 1, p - 1)) % mod);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 998244353;
const int MAXN = 5555;
long long fac[MAXN], ifac[MAXN];
long long binom(long long n, long long k) {
if (k > n || k < 0) return 0;
long long ans = (ifac[k] * ifac[n - k]) % MOD;
return (ans * fac[n]) % MOD;
}
long long inv(long long b) {
long long e = MOD - 2, res = 1;
for (long long k = 1; k <= e; k *= 2) {
if (k & e) res = (res * b) % MOD;
b = (b * b) % MOD;
}
return res;
}
long long awoo(long long p, long long ts, long long bn) {
if (p == 0) {
if (ts == 0)
return 1;
else
return 0;
}
long long res = 0;
for (long long meanies = 0; meanies * bn <= ts; meanies++) {
if (meanies > p) break;
long long cnt =
(binom(p, meanies) * binom(ts - meanies * bn + p - 1, p - 1)) % MOD;
if (meanies % 2)
res = (res - cnt) % MOD;
else
res = (res + cnt) % MOD;
}
return (res + MOD) % MOD;
}
int main() {
fac[0] = 1;
for (int i = 1; i < MAXN; i++) fac[i] = (i * fac[i - 1]) % MOD;
ifac[MAXN - 1] = inv(fac[MAXN - 1]);
for (int i = MAXN - 1; i >= 1; i--) ifac[i - 1] = (i * ifac[i]) % MOD;
long long p, s, r, ans = 0, ways = 0;
cin >> p >> s >> r;
if (p == 1) {
cout << "1\n";
return 0;
}
if (r == 0) {
cout << inv(p) << '\n';
return 0;
}
for (long long sc = r; sc <= s; sc++) {
ways = (ways + binom(s - sc + p - 2, p - 2)) % MOD;
for (long long np = 1; np * sc <= s; np++) {
if (np > p) break;
long long res = (awoo(p - np, s - np * sc, sc) * inv(np)) % MOD;
res = (res * binom(p - 1, np - 1)) % MOD;
ans += res;
if (ans >= MOD) ans -= MOD;
}
}
cout << (ans * inv(ways)) % MOD << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
long long pw(long long x, long long y) {
if (y == 0) return 1;
if (y % 2) return x * pw(x, y - 1) % mod;
long long res = pw(x, y / 2);
return res * res % mod;
}
long long f[10001];
long long inf[10001];
long long inv[10001];
long long C(int x, int y) { return f[x] * inf[y] % mod * inf[x - y] % mod; }
int p, r, s;
long long dp[101];
int main() {
ios::sync_with_stdio(false);
f[0] = inf[0] = 1;
for (int i = 1; i <= 10000; i++) {
f[i] = f[i - 1] * i % mod;
inf[i] = pw(f[i], mod - 2);
inv[i] = pw(i, mod - 2);
}
cin >> p >> s >> r;
if (p == 1) {
cout << 1 << endl;
return 0;
}
long long ans = 0;
p--;
long long ways = 0;
for (int i = r; i <= s; i++) {
if (i == 0) {
if (s == 0) ans = (ans + inv[p + 1]) % mod;
ways = (ways + C(s - i + p - 1, p - 1)) % mod;
continue;
}
for (int j = 0; j <= p; j++) {
int cs = s - i * (j + 1);
int cp = p - j;
if (cs < 0) continue;
for (int k = min(cp, cs / i); k >= 0; k--) {
int ccs = cs - k * i;
if (cp > 0)
dp[k] = C(ccs + cp - 1, cp - 1) * C(cp, k) % mod;
else
dp[k] = (cs == 0);
for (int l = min(cp, cs / i); l > k; l--) {
dp[k] = (dp[k] + (mod - C(l, k)) * dp[l]) % mod;
}
}
ans = (ans + dp[0] * C(p, j) % mod * inv[j + 1]) % mod;
}
ways = (ways + C(s - i + p - 1, p - 1)) % mod;
}
cout << ans * pw(ways, mod - 2) % mod << endl;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
using namespace std;
const int N = 1e6 + 10;
const long long mod2 = 1e9 + 7;
const long long mod = 998244353;
const long long inf = 8e18;
const int LOG = 22;
long long pw(long long a, long long b, long long M) {
return (!b ? 1
: (b & 1 ? (a * pw(a * a % M, b / 2, M)) % M
: pw(a * a % M, b / 2, M)));
}
long long first[N], I[N];
inline long long E(long long r, long long n) {
if (r > n || r < 0) return 0ll;
return first[n] * I[r] % mod * I[n - r] % mod;
}
long long calc(int n, int m, int s) {
if (n == 0 && m == 0) return 1;
long long ret = 0;
for (int i = 0; i <= n; i++) {
if (m < s * i) continue;
long long z = (i % 2 == 0 ? 1 : -1);
long long cu = E(i, n) * E(n - 1, m - s * i + n - 1) % mod;
ret = (ret + z * cu + 2 * mod) % mod;
}
return ret;
}
int main() {
int n, second, R;
first[0] = 1;
for (int i = 1; i < N; i++) {
first[i] = first[i - 1] * i % mod;
}
I[N - 1] = pw(first[N - 1], mod - 2, mod);
for (int i = N - 2; ~i; i--) I[i] = I[i + 1] * (i + 1) % mod;
scanf("%d%d%d", &n, &second, &R);
if (n == 1) {
return !printf("1");
}
long long kol = 0, win = 0;
for (int T = R; T <= second; T++) {
for (int i = 0; i < n; i++) {
if ((i + 1) * T > second) continue;
long long cu = E(i, n - 1);
cu = cu * calc(n - i - 1, second - (i + 1) * T, T) % mod;
win = (win + cu * pw(i + 1, mod - 2, mod)) % mod;
}
kol = (kol + E(n - 2, second - T + n - 2)) % mod;
}
long long tot = win * pw(kol, mod - 2, mod) % mod;
printf("%lld ", tot);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
const int N = 1e5 + 5;
long long fac[N], inv[N];
long long bp(long long a, long long p) {
long long r = 1;
while (p > 0) {
if (p & 1) r = r * a % mod;
p >>= 1;
a = a * a % mod;
}
return r;
}
long long c(int n, int k) { return fac[n] * inv[k] % mod * inv[n - k] % mod; }
long long f(int s, int p, int u) {
if (p == 0) {
if (s == 0) return 1;
return 0;
}
long long a = 0;
for (int j = 0; j <= min(p, s / u); j++) {
a = (a + c(p, j) * c(s - j * u + p - 1, p - 1) % mod * ((j & 1) ? -1 : 1) +
mod) %
mod;
}
return a;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
fac[0] = inv[0] = 1;
for (int i = 1; i < N; i++) {
fac[i] = fac[i - 1] * i % mod;
inv[i] = bp(fac[i], mod - 2);
}
int p, s, r;
cin >> p >> s >> r;
if (r == 0 && s == 0) {
cout << bp(p, mod - 2);
return 0;
}
long long Q = c(s - r + p - 1, p - 1), P = 0;
for (int i = max(r, 1); i <= s; i++) {
for (int j = 1; j <= s / i; j++) {
P = (P +
c(p - 1, j - 1) * f(s - j * i, p - j, i) % mod * bp(j, mod - 2)) %
mod;
}
}
cout << P * bp(Q, mod - 2) % mod;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void fastIO() {
std::ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
template <typename T, typename U>
inline void mnze(T &x, U y) {
if (y < x) x = y;
}
template <typename T, typename U>
inline void mxze(T &x, U y) {
if (x < y) x = y;
}
void _scan(int &x) { scanf("%d", &x); }
void _scan(long long &x) { scanf("%lld", &x); }
void _scan(double &x) { scanf("%lf", &x); }
void _scan(char &x) { scanf(" %c", &x); }
void _scan(char *x) { scanf("%s", x); }
void scan() {}
template <typename T, typename... U>
void scan(T &head, U &...tail) {
_scan(head);
scan(tail...);
}
template <typename T>
void _dbg(const char *sdbg, T h) {
cerr << sdbg << "=" << h << "\n";
}
template <typename T, typename... U>
void _dbg(const char *sdbg, T h, U... t) {
while (*sdbg != ',') cerr << *sdbg++;
cerr << "=" << h << ",";
_dbg(sdbg + 1, t...);
}
const long long MOD = 998244353;
const int MAXN = 2e5;
long long sq(long long x) { return x * x % MOD; }
long long pot(long long b, long long e) {
return e ? sq(pot(b, e >> 1)) * (e & 1 ? b : 1) % MOD : 1;
}
long long inv(long long x) { return pot(x, MOD - 2); }
long long fact[MAXN], ifact[MAXN];
long long comb(int n, int k) {
if (k > n) return 0;
return fact[n] * ifact[n - k] % MOD * ifact[k] % MOD;
}
long long d(int k, int n) { return comb(n + k - 1, k - 1); }
void pre() {
fact[0] = 1;
for (int i = 1; i < (int)MAXN; i++) fact[i] = (fact[i - 1] * i) % MOD;
for (int i = 0; i < (int)MAXN; i++) ifact[i] = inv(fact[i]);
}
long long p, r, s;
int main() {
pre();
scan(p, s, r);
long long totalw = d(p, s - r);
long long P = 0;
for (int x = r; x < (int)s + 1; x++) {
for (int k = 0; k < (int)p; k++) {
long long n = p - 1 - k, y = s - (k + 1) * x;
long long PP = comb(p - 1, k) * inv(k + 1) % MOD;
if (n == 0) {
if (y == 0) {
P += PP;
P %= MOD;
}
} else {
long long ret = 0, sig = 1;
for (int i = 0; i < (int)n + 1; i++) {
long long r = (sig * comb(n, i) + MOD) % MOD;
r = r * d(n, y - i * x) % MOD;
ret = (ret + r) % MOD;
sig *= -1;
}
assert(y >= 0 || ret == 0);
P += ret * PP % MOD;
P %= MOD;
}
}
}
long long PQ = P * inv(totalw);
printf("%lld\n", (PQ % MOD + MOD) % MOD);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 998244353;
int powerMod(int a, int n, int m) {
if (!n) return 1;
int t = powerMod(a, n >> 1, m);
t = (1LL * t * t) % m;
if (n & 1) t = (1LL * t * a) % m;
return t;
}
const int maxN = 1e4 + 5;
int fac[maxN], inv[maxN];
void computeFactorials(int n) {
fac[0] = 1;
for (int i = 1; i <= n; i++) fac[i] = (1LL * i * fac[i - 1]) % MOD;
inv[n] = powerMod(fac[n], MOD - 2, MOD);
for (int i = n - 1; i >= 0; i--) inv[i] = (1LL * inv[i + 1] * (i + 1)) % MOD;
}
int combi(int n, int k) {
if (n == k) return 1;
int res = (1LL * inv[k] * inv[n - k]) % MOD;
res = (1LL * res * fac[n]) % MOD;
return res;
}
int star(int n, int k) { return combi(n + k - 1, k - 1); }
int countGame(int n, int k, int x) {
int ans = 0, sign = +1;
bool debug = k == 0;
int remain = n;
for (int i = 0; i <= k and remain >= 0; i++) {
int cnt = (1LL * combi(k, i) * star(remain, k)) % MOD;
(ans += sign * cnt) %= MOD;
(ans += MOD) %= MOD;
remain -= x;
sign *= -1;
}
return ans;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
computeFactorials(maxN - 3);
int p, s, r;
cin >> p >> s >> r;
int gameSize = star(s - r, p);
int answer = 0;
for (int x = r; x <= s; x++) {
int sum = x;
for (int i = 0; sum <= s and i + 1 <= p; i++) {
int pick = combi(p - 1, i);
int prob = (1LL * pick * countGame(s - sum, p - 1 - i, x)) % MOD;
prob = (1LL * prob * powerMod(gameSize, MOD - 2, MOD)) % MOD;
prob = (1LL * prob * powerMod(i + 1, MOD - 2, MOD)) % MOD;
(answer += prob) %= MOD;
sum += x;
}
}
cout << answer;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 998244353;
const int N = 10000 + 10;
int p, s, r;
long long fac[N], inv[N], rev[N];
long long mpow(long long a, long long x) {
if (x == 0) return 1;
long long t = mpow(a, x >> 1);
if (x % 2 == 0) return t * t % MOD;
return t * t % MOD * a % MOD;
}
long long c(int a, int b) {
if (a < b) return 0;
if (a == b) return 1;
return fac[a] * inv[b] % MOD * inv[a - b] % MOD;
}
long long cac(int n, int m, int k) {
long long ret = 0;
for (int i = 0; i <= n; i++) {
if (m >= (k + 1) * i) {
long long tmp = c(n, i) * c(m - (k + 1) * i + n - 1, n - 1) % MOD;
if (i % 2 == 1)
ret = (ret - tmp + MOD) % MOD;
else
ret = (ret + tmp) % MOD;
}
}
return ret;
}
int main() {
fac[0] = 1;
inv[0] = 1;
rev[0] = 1;
for (int i = 1; i < N; i++) {
rev[i] = mpow(i, MOD - 2);
fac[i] = fac[i - 1] * i % MOD;
inv[i] = mpow(fac[i], MOD - 2);
}
cin >> p >> s >> r;
long long tot = 0;
for (int i = r; i <= s; i++) {
tot = (tot + c(s - i + (p - 2), (p - 2))) % MOD;
}
tot = mpow(tot, MOD - 2);
long long res = 0;
for (int i = r; i <= s; i++) {
for (int j = 0; j <= p - 1; j++) {
if (s - i - j * i >= 0) {
res = res + rev[j + 1] * c(p - 1, j) % MOD *
cac(p - 1 - j, s - i - j * i, i - 1) % MOD * tot % MOD;
res %= MOD;
}
}
}
cout << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5210;
const long long mod = 998244353;
long long C[maxn][maxn];
long long f(int n, int m, int x) {
long long ans = 0;
if (!m) return (n == 0 && x > 0);
for (int i = 0, s = 1; i <= m; i++, s *= -1) {
if (n - i * x < 0) break;
ans += s * (C[m][i] * C[n - i * x + m - 1][m - 1] % mod),
(ans += mod) %= mod;
}
return ans;
}
long long poww(long long a, int b) {
long long res = 1;
while (b) {
if (b & 1) res *= a, res %= mod;
a *= a, a %= mod;
b >>= 1;
}
return res;
}
int main() {
for (int i = 0; i <= 5200; i++)
for (int j = 0; j <= i; j++)
C[i][j] = (j == 0 || j == i) ? 1 : (C[i - 1][j - 1] + C[i - 1][j]) % mod;
int r, p, s;
cin >> p >> s >> r;
long long ans = 0;
if (p == 1) {
puts("1");
return 0;
}
if (s == 0 && r == 0) {
printf("%lld\n", poww(p, mod - 2));
return 0;
}
for (int x = r; x <= s; x++) {
for (int i = 1; i <= p; i++) {
if (i * x > s) break;
ans += C[p - 1][i - 1] * f(s - i * x, p - i, x) % mod * poww(i, mod - 2) %
mod;
ans %= mod;
}
}
cout << ans * poww(C[s - r + p - 1][p - 1], mod - 2) % mod << endl;
return 0;
}
|
#include <bits/stdc++.h>
const int Mod = 998244353;
inline int chk(int x) {
if (x < 0) x += Mod;
if (x >= Mod) x -= Mod;
return x;
}
inline int qPow(int b, int e) {
int a = 1;
for (; e; b = (long long)b * b % Mod, e >>= 1)
if (e & 1) a = (long long)a * b % Mod;
return a;
}
int p, s, r, c[5105][105];
void Init() {
for (int i = 0; i <= 5100; ++i) c[i][0] = 1;
for (int i = 0; i <= 5100; ++i)
for (int j = 1; j <= i && j <= 100; ++j)
c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % Mod;
}
inline int Calc(int n, int m, int x) {
long long S = 0;
for (int i = 0; i <= m && i * x <= n; ++i) {
long long s = (long long)c[m][i] * c[n - x * i + m - 1][m - 1] % Mod;
S += i & 1 ? -s : s;
}
return (S % Mod + Mod) % Mod;
}
int Sum1, Sum2;
int main() {
scanf("%d%d%d", &p, &s, &r);
if (p == 1) return puts("1"), 0;
Init();
for (int x = r; x <= s; ++x) {
if (x * p < s) continue;
for (int i = 1; i <= p; ++i) {
if (i * x > s || (p - i) * (x - 1) + i * x < s) continue;
if (i == p) {
Sum2 = (Sum2 + (i * x == s ? qPow(i, Mod - 2) : 0)) % Mod;
continue;
}
Sum2 = (Sum2 + (long long)c[p - 1][i - 1] * Calc(s - i * x, p - i, x) %
Mod * qPow(i, Mod - 2)) %
Mod;
}
}
Sum1 = c[s - r + p - 1][p - 1];
printf("%lld\n", (long long)Sum2 * qPow(Sum1, Mod - 2) % Mod);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using lint = long long;
template <class T = int>
using V = vector<T>;
template <class T = int>
using VV = V<V<T> >;
template <unsigned P>
struct ModInt {
using M = ModInt;
unsigned v;
ModInt() : v(0) {}
template <class Int>
ModInt(Int x) : v(x >= 0 ? x % P
: -x % P ? P - -x % P
: 0) {}
constexpr ModInt(unsigned v, int) : v(v) {}
static constexpr unsigned p() { return P; }
M operator+() const { return *this; }
M operator-() const { return {v ? P - v : 0, 0}; }
explicit operator bool() const noexcept { return v; }
bool operator!() const noexcept { return !(bool)*this; }
M operator*(M rhs) const { return M(*this) *= rhs; }
M operator/(M rhs) const { return M(*this) /= rhs; }
M operator+(M rhs) const { return M(*this) += rhs; }
M operator-(M rhs) const { return M(*this) -= rhs; }
bool operator==(M rhs) const { return v == rhs.v; }
bool operator!=(M rhs) const { return !(*this == rhs); }
M& operator*=(M rhs) {
v = (unsigned long long)v * rhs.v % P;
return *this;
}
M& operator/=(M rhs) { return *this *= rhs.inv(); }
M& operator+=(M rhs) {
v = rhs.v < P - v ? v + rhs.v : v - (P - rhs.v);
return *this;
}
M& operator-=(M rhs) {
v = rhs.v <= v ? v - rhs.v : v + (P - rhs.v);
return *this;
}
M inv() const {
int a = v, b = P, x = 1, u = 0;
while (b) {
int q = a / b;
swap(a -= q * b, b);
swap(x -= q * u, u);
}
assert(a == 1);
return x;
}
template <class Int>
M pow(Int n) const {
n = n >= 0 ? n % (P - 1) : P - 1 - -n % (P - 1);
M res = 1;
for (M a = *this; n; a *= a, n >>= 1)
if (n & 1) res *= a;
return res;
}
template <class Int>
friend M operator*(Int lhs, M rhs) {
return M(lhs) *= rhs;
}
template <class Int>
friend M operator/(Int lhs, M rhs) {
return M(lhs) /= rhs;
}
template <class Int>
friend M operator+(Int lhs, M rhs) {
return M(lhs) += rhs;
}
template <class Int>
friend M operator-(Int lhs, M rhs) {
return M(lhs) -= rhs;
}
friend ostream& operator<<(ostream& os, M rhs) { return os << rhs.v; }
friend istream& operator>>(istream& is, M& rhs) {
lint x;
is >> x;
rhs = x;
return is;
}
template <class Int>
friend bool operator==(Int lhs, M rhs) {
return M(lhs) == rhs;
}
template <class Int>
friend bool operator!=(Int lhs, M rhs) {
return !(lhs == rhs);
}
};
using Mint = ModInt<998244353>;
V<Mint> fact, ifact;
void init(int n) {
fact.resize(n + 1);
fact[0] = 1;
for (int i = 1; i <= n; ++i) {
fact[i] = i * fact[i - 1];
}
ifact.resize(n + 1);
ifact[n] = fact[n].inv();
for (int i = n; i > 0; --i) {
ifact[i - 1] = i * ifact[i];
}
}
Mint comb(int n, int r) {
if (r < 0 or r > n) return 0;
return fact[n] * ifact[r] * ifact[n - r];
}
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int n, s, l;
cin >> n >> s >> l;
if (n == 1) return cout << 1 << '\n', 0;
init(s + n);
Mint res = 0;
for (int a = l; a <= s; ++a)
for (int x = 1; x <= n; ++x) {
if (a * x > s or a * x + (a - 1) * (n - x) < s) continue;
Mint curr = 0;
for (int k = 0; k <= n - x; ++k) {
curr += (k & 1 ? -1 : 1) * comb(n - x, k) *
comb(s - a * (x + k) + max(n - x - 1, 0), s - a * (x + k));
}
curr *= comb(n - 1, x - 1);
res += curr / x;
}
Mint sum = 0;
for (int a = l; a <= s; ++a) {
sum += comb(s - a + max(n - 2, 0), s - a);
}
res /= sum;
cout << res << '\n';
}
|
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
const int mod = 998244353;
struct Mod {
public:
int num;
Mod() : Mod(0) { ; }
Mod(long long int n) : num((n % mod + mod) % mod) {
static_assert(mod < INT_MAX / 2,
"mod is too big, please make num 'long long int' from 'int'");
}
Mod(int n) : Mod(static_cast<long long int>(n)) { ; }
operator int() { return num; }
};
Mod operator+(const Mod a, const Mod b) { return Mod((a.num + b.num) % mod); }
Mod operator+(const long long int a, const Mod b) { return Mod(a) + b; }
Mod operator+(const Mod a, const long long int b) { return b + a; }
Mod operator++(Mod &a) { return a + Mod(1); }
Mod operator-(const Mod a, const Mod b) {
return Mod((mod + a.num - b.num) % mod);
}
Mod operator-(const long long int a, const Mod b) { return Mod(a) - b; }
Mod operator--(Mod &a) { return a - Mod(1); }
Mod operator*(const Mod a, const Mod b) {
return Mod(((long long)a.num * b.num) % mod);
}
Mod operator*(const long long int a, const Mod b) { return Mod(a) * b; }
Mod operator*(const Mod a, const long long int b) { return Mod(b) * a; }
Mod operator*(const Mod a, const int b) { return Mod(b) * a; }
Mod operator+=(Mod &a, const Mod b) { return a = a + b; }
Mod operator+=(long long int &a, const Mod b) { return a = a + b; }
Mod operator-=(Mod &a, const Mod b) { return a = a - b; }
Mod operator-=(long long int &a, const Mod b) { return a = a - b; }
Mod operator*=(Mod &a, const Mod b) { return a = a * b; }
Mod operator*=(long long int &a, const Mod b) { return a = a * b; }
Mod operator*=(Mod &a, const long long int &b) { return a = a * b; }
Mod operator^(const Mod a, const int n) {
if (n == 0) return Mod(1);
Mod res = (a * a) ^ (n / 2);
if (n % 2) res = res * a;
return res;
}
Mod mod_pow(const Mod a, const long long int n) {
if (n == 0) return Mod(1);
Mod res = mod_pow((a * a), (n / 2));
if (n % 2) res = res * a;
return res;
}
Mod inv(const Mod a) { return a ^ (mod - 2); }
Mod operator/(const Mod a, const Mod b) {
assert(b.num != 0);
return a * inv(b);
}
Mod operator/(const long long int a, const Mod b) { return Mod(a) / b; }
Mod operator/=(Mod &a, const Mod b) { return a = a / b; }
Mod fact[10240], factinv[10240];
void init(const int amax = 10240) {
fact[0] = Mod(1);
factinv[0] = 1;
for (int i = 0; i < amax - 1; ++i) {
fact[i + 1] = fact[i] * Mod(i + 1);
factinv[i + 1] = factinv[i] / Mod(i + 1);
}
}
Mod comb(const int a, const int b) {
return fact[a] * factinv[b] * factinv[a - b];
}
int main() {
init();
int N, S, R;
cin >> N >> S >> R;
Mod answer = 0;
for (int num = 1; num <= N; ++num) {
int rest = S - num * R;
if (rest < 0)
break;
else {
Mod nanswer = 0;
nanswer = comb(N, num);
nanswer *= comb(rest + N - 1, rest);
Mod plus = Mod(num % 2 == 1 ? 1 : -1);
answer += plus * nanswer;
}
}
{
Mod fst = 1;
fst = comb(S - R + N - 1, N - 1);
answer /= fst;
answer /= N;
}
cout << answer.num << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5500, mod = 998244353;
int p, s, r, ans, fac[N], inv[N];
void exGCD(int a, int b, int &x, int &y) {
if (!b) {
x = 1, y = 0;
return;
}
exGCD(b, a % b, y, x), y -= a / b * x;
}
int Inv(int x) {
int xx, yy;
exGCD(x, mod, xx, yy);
return (xx % mod + mod) % mod;
}
void Prework() {
fac[0] = inv[0] = 1;
for (int i = 1; i <= 5200; i++) fac[i] = 1ll * fac[i - 1] * i % mod;
inv[5200] = Inv(fac[5200]);
for (int i = 5199; i; i--) inv[i] = 1ll * inv[i + 1] * (i + 1) % mod;
}
int C(int n, int m) {
if (n == m) return 1;
if (n < m) return 0;
return 1ll * fac[n] * inv[m] % mod * inv[n - m] % mod;
}
int Calc(int cnt, int lim, int tot) {
int ret = C(tot + cnt - 1, cnt - 1);
for (int i = 1, j; i <= cnt; i++, ret %= mod)
j = i % 2 ? mod - 1 : 1, ret += 1ll * j * C(cnt, i) % mod *
C(tot - i * lim + cnt - 1, cnt - 1) % mod;
return (ret + mod) % mod;
}
int main() {
scanf("%d%d%d", &p, &s, &r), Prework();
for (int i = r; i <= s; i++)
for (int j = 1; j <= p && i * j <= s; j++, ans %= mod)
ans += 1ll * C(p - 1, j - 1) * Inv(j) % mod * Calc(p - j, i, s - i * j) %
mod;
printf("%lld", 1ll * ans * Inv(C(s - r + p - 1, p - 1)) % mod);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 10000;
const int MOD = 998244353;
int p, s, r;
long long f[N + 10], invf[N + 10];
long long getInv(long long base) {
long long ret = 1;
int tmp = MOD - 2;
while (tmp) {
if (tmp & 1) ret = ret * base % MOD;
base = base * base % MOD;
tmp >>= 1;
}
return ret;
}
inline long long C(int m, int n) {
if (m < n) return 0;
return f[m] * invf[n] % MOD * invf[m - n] % MOD;
}
long long calc(int rest, int n, int ub) {
if (!n) return (rest == 0);
long long ret = 0;
for (int i = 0; i <= n; i++) {
long long tmp =
C(rest - i * ub + n - 1, n - 1) * C(n, i) * ((i & 1) ? -1 : 1) % MOD;
if (!tmp) break;
ret = (ret + tmp) % MOD;
}
return ret;
}
int main() {
ios::sync_with_stdio(false);
cin >> p >> s >> r;
f[0] = invf[0] = 1;
for (int i = 1; i <= N; i++) {
f[i] = f[i - 1] * i % MOD;
invf[i] = getInv(f[i]);
}
long long ans = 0;
for (int i = r; i <= s; i++)
for (int j = 1; j <= p && i * j <= s; j++) {
ans = (ans +
C(p - 1, j - 1) * calc(s - i * j, p - j, i) % MOD * getInv(j)) %
MOD;
}
ans = ans * getInv(C(s - r + p - 1, p - 1)) % MOD;
cout << (ans + MOD) % MOD << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int sz = 10007;
const int p = 998244353;
int a[sz], b[sz], inv[sz];
void init() {
a[0] = b[0] = 1;
a[1] = b[1] = inv[1] = 1;
for (int i = 2; i < sz; i++) {
inv[i] = 1ll * (p - p / i) * inv[p % i] % p;
a[i] = 1ll * a[i - 1] * i % p;
b[i] = 1ll * b[i - 1] * inv[i] % p;
}
}
int C(int n, int m) {
if (n < m) return 0;
if (n == 0) return 0;
return 1ll * a[n] * b[m] % p * b[n - m] % p;
}
int qpow(int x, int y) {
int ret = 1;
for (; y; y >>= 1, x = 1ll * x * x % p)
if (y & 1) ret = 1ll * ret * x % p;
return ret;
}
int solve(int s, int m, int x) {
int ret = 0;
if (s == 0) return 1;
for (int i = 0; i <= m && i * x <= s; i++) {
int val = 1ll * C(m, i) * C(s - x * i + m - 1, m - 1) % p;
ret = (ret + (i & 1 ? p - val : val)) % p;
}
return ret;
}
int main() {
init();
int n, s, r;
scanf("%d%d%d", &n, &s, &r);
if (n == 1) {
printf("1\n");
return 0;
}
int ans = 0;
for (int x = r; x <= s; x++) {
if (x * n < s) continue;
for (int i = 1; i <= n; i++) {
if (i * x > s || (n - i) * (x - 1) + i * x < s) continue;
if (i == n) {
ans = (ans + (i * x == s ? inv[i] : 0)) % p;
continue;
}
ans = (ans + 1ll * solve(s - i * x, n - i, x) * C(n - 1, i - 1) % p *
inv[i] % p) %
p;
}
}
int ny = qpow(C(s - r + n - 1, n - 1), p - 2);
ans = 1ll * ans * ny % p;
printf("%d", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 103, maxs = 5003, mo = 998244353;
int n, s, r, ans, C[maxn + maxs][maxn + maxs];
inline int qpow(int a, int b) {
int res = 1;
for (; b; b >>= 1, a = (long long)a * a % mo)
if (b & 1) res = (long long)res * a % mo;
return res;
}
inline int cbn(int a, int b) {
if (a < b) return 0;
if (b < 0 || a < 0) return 0;
if (C[a][b]) return C[a][b];
return C[a][b] = (cbn(a - 1, b) + cbn(a - 1, b - 1)) % mo;
}
inline int getdp(int m, int sm, int x) {
if (m == 0) return sm == 0;
if (x == 0) return 0;
int res = 0;
for (register int i = 0; i <= m; ++i)
if (i & 1)
res = (res - (long long)cbn(m, i) * cbn(sm - x * i + m - 1, m - 1)) % mo;
else
res = (res + (long long)cbn(m, i) * cbn(sm - x * i + m - 1, m - 1)) % mo;
return res;
}
int main() {
scanf("%d%d%d", &n, &s, &r);
C[0][0] = 1;
for (register int i = r; i <= s; ++i)
for (register int j = 1; j <= n; ++j) {
ans = (ans + (long long)cbn(n - 1, j - 1) * getdp(n - j, s - i * j, i) %
mo * qpow(j, mo - 2)) %
mo;
}
ans = (long long)ans * qpow(cbn(s - r + n - 1, n - 1), mo - 2) % mo;
if (ans < 0) ans += mo;
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long nCr[5500][150];
const long long mod = (119 << 23) + 1, root = 3;
long long modpow(long long a, long long e) {
if (e == 0) return 1;
long long x = modpow(a * a % mod, e >> 1);
return e & 1 ? x * a % mod : x;
}
long long inv(long long a) { return modpow(a, mod - 2); }
long long binom(long long n, long long k) {
if (n == -1 && k == -1) return 1;
if (k < 0 || k > n || n < 0) return 0;
return nCr[n][k];
}
int main() {
nCr[0][0] = 1;
for (int i = (1); i < int(5500); ++i)
for (int j = (0); j < int(150); ++j) {
nCr[i][j] = nCr[i - 1][j];
if (j) {
nCr[i][j] += nCr[i - 1][j - 1];
nCr[i][j] %= mod;
}
}
ios::sync_with_stdio(0);
int p, s, r;
cin >> p >> s >> r;
long long succeeding = 0;
long long total = 0;
for (int a1 = (r); a1 < int(s + 1); ++a1) {
total += binom(s + p - 2 - a1, p - 2);
total %= mod;
long long states = 0;
vector<long long> counted(p);
for (int numSame = (0); numSame < int(p); ++numSame) {
if (s + p - numSame - 2 - (numSame + 1) * a1 < -1) break;
for (int numLargerOrEqual = (0); numLargerOrEqual < int(p - numSame);
++numLargerOrEqual) {
if (s + p - numSame - 2 - (numSame + 1 + numLargerOrEqual) * a1 < -1)
break;
long long mul = (numLargerOrEqual % 2 ? -1 : 1);
long long t = mul * binom(p - 1, numSame);
t *= binom(p - 1 - numSame, numLargerOrEqual);
t %= mod;
t *= binom(s + p - numSame - 2 - (numSame + 1 + numLargerOrEqual) * a1,
p - 2 - numSame);
t %= mod;
t *= inv(numSame + 1);
states += t;
states %= mod;
}
}
if (states < 0) states += mod;
succeeding += states;
succeeding %= mod;
}
long long ans = succeeding * inv(total);
ans %= mod;
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const long MOD = 998244353;
long long fact[6000], invfact[6000], inv[1000];
long long pow(long long a, long long n) {
if (n == 0) return 1;
long long p = pow(a, n / 2);
p = (p * p) % MOD;
return (n % 2 == 0 ? p : (a * p) % MOD);
}
long long modinv(long long a) { return pow(a, MOD - 2); }
long long choose(int n, int k) {
if (n < 0 || k < 0 || n < k) return 0;
return (((fact[n] * invfact[k]) % MOD) * invfact[n - k]) % MOD;
}
long long g(int s, int p, int m) {
if (p == 0) return (s == 0 ? 1 : 0);
long long ans = 0;
for (int k = 0; k <= p; k++) {
ans += (k % 2 == 0 ? choose(p, k) : MOD - choose(p, k)) *
choose(s - k * (m + 1) + p - 1, p - 1);
ans %= MOD;
}
return ans;
}
int main() {
int p, s, r;
cin >> p >> s >> r;
fact[0] = 1;
invfact[0] = 1;
for (int i = 1; i <= s + p - 1; i++) {
fact[i] = (fact[i - 1] * i) % MOD;
invfact[i] = modinv(fact[i]);
}
for (int i = 1; i <= p; i++) inv[i] = modinv(i);
long long ans = 0;
for (int a = r; a <= s; a++) {
for (int k = 1; k <= p; k++) {
ans +=
((choose(p - 1, k - 1) * g(s - k * a, p - k, a - 1)) % MOD) * inv[k];
ans %= MOD;
}
}
ans *= modinv(choose(s - r + p - 1, p - 1));
ans %= MOD;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void dbg_out() { cerr << endl; }
template <typename Head, typename... Tail>
void dbg_out(Head H, Tail... T) {
cerr << ' ' << H;
dbg_out(T...);
}
pair<int, int> operator*(const pair<int, int> &p, const pair<int, int> &x) {
pair<int, int> np = make_pair(p.first * x.first, p.second * x.second);
return np;
}
pair<long long, long long> operator%(const pair<long long, long long> &p,
const pair<long long, long long> &x) {
pair<long long, long long> np =
make_pair(p.first % x.first, p.second % x.second);
return np;
}
pair<long long, long long> operator*(const pair<long long, long long> &p,
const pair<int, int> &x) {
pair<long long, long long> np =
make_pair(p.first * x.first, p.second * x.second);
return np;
}
pair<long long, long long> operator*(const pair<long long, long long> &p,
const pair<long long, long long> &x) {
pair<long long, long long> np =
make_pair(p.first * x.first, p.second * x.second);
return np;
}
pair<long long, long long> operator+(const pair<long long, long long> &p,
const pair<long long, long long> &x) {
pair<long long, long long> np =
make_pair(p.first + x.first, p.second + x.second);
return np;
}
pair<long long, long long> operator-(const pair<long long, long long> &p,
const pair<long long, long long> &x) {
pair<long long, long long> np =
make_pair(p.first - x.first, p.second - x.second);
return np;
}
pair<int, int> operator+(const pair<int, int> &p, const pair<int, int> &x) {
pair<int, int> np = make_pair(p.first + x.first, p.second + x.second);
return np;
}
pair<int, int> operator-(const pair<int, int> &p, const pair<int, int> &x) {
pair<int, int> np = make_pair(p.first - x.first, p.second - x.second);
return np;
}
vector<int> prime;
bool sortinrev(const pair<int, int> &a, const pair<int, int> &b) {
return (a.first > b.first);
}
bool sortbysecdesc(const pair<int, int> &a, const pair<int, int> &b) {
return a.second > b.second;
}
bool sortbysec(const pair<int, int> &a, const pair<int, int> &b) {
return (a.second < b.second);
}
long long powerm(long long a, long long k) {
if (!k) {
return 1;
}
long long b = powerm(a, k / 2);
b = b * b % 998244353;
if (k % 2) {
return a * b % 998244353;
} else {
return b;
}
}
long long power(long long a, long long b) {
if (b == 1) return a;
if (b == 0) return 1;
long long m1 = power(a, b / 2);
if (b % 2) return m1 * m1 * a;
return m1 * m1;
}
void PFactor(int x) {
prime.clear();
for (int i = 2; i <= x / i; i++)
if (x % i == 0) {
while (x % i == 0) x /= i, prime.push_back(i);
}
if (x > 1) prime.push_back(x);
}
bool isprime(long long a) {
if (a <= 1) return false;
if (a == 2 || a == 3) return true;
if (a % 2 == 0 || a % 3 == 0) return false;
for (long long i = 5; i * i <= a; i = i + 6) {
if (a % i == 0 || a % (i + 2) == 0) return false;
}
return true;
}
long long read() {
long long a = 0;
char b = 1, c;
do
if ((c = getchar()) == 45) b = -1;
while (c < 48 || c > 57);
do a = (a << 3) + (a << 1) + (c & 15);
while ((c = getchar()) > 47 && c < 58);
return a * b;
}
void write(long long x, char c) {
if (x < 0) putchar(45), x = -x;
char a[20], s = 0;
do a[++s] = x % 10 | 48;
while (x /= 10);
do putchar(a[s]);
while (--s);
putchar(c);
}
const int N = 2e6 + 20;
vector<int> g[N];
int n = 0, m = 0, s = 0;
int d[N] = {0};
long long c[5201][5201];
inline long long f(int x, int sum, int maxx) {
if (x * maxx < sum) return 0ll;
if (x == 0 || sum == 0) return 1ll;
long long ans = 0;
for (int k = 0; k * (maxx + 1) <= sum && k <= x; k++) {
if (k % 2)
ans += (998244353 -
((c[sum - k * (maxx + 1) + x - 1][x - 1] * c[x][k]) % 998244353));
else
ans += c[sum - k * (maxx + 1) + x - 1][x - 1] * c[x][k];
ans %= 998244353;
}
return ans;
}
int main() {
for (int i = 0; i <= 5200; i++) {
c[i][0] = 1;
for (int j = 1; j <= i; j++) {
c[i][j] = c[i - 1][j] + c[i - 1][j - 1];
c[i][j] %= 998244353;
}
}
cin >> n >> s >> m;
if (s == 0) {
cout << powerm(n, 998244353 - 2ll);
return 0;
}
long long ans = powerm(c[s - m + n - 1][n - 1], 998244353 - 2ll);
m--;
long long summ = 0;
while (++m <= s) {
if (m == 0) continue;
for (int t = 1; t * m <= s; t++) {
long long tans = powerm(t, 998244353 - 2ll);
tans = (tans * f(n - t, s - t * m, m - 1)) % 998244353;
tans = (tans * c[n - 1][t - 1]) % 998244353;
summ += tans;
summ %= 998244353;
}
}
cout << (ans * summ) % 998244353;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
long long fac[10005], ifac[10005], n, s, r;
inline long long Pow(long long x, long long y) {
long long ret = 1;
while (y) {
if (y & 1) ret = ret * 1ll * x % mod;
x = x * 1ll * x % mod;
y >>= 1;
}
return ret % mod;
}
inline long long inv(long long x) { return Pow(x, mod - 2); }
inline long long C(long long n, long long m) {
if (m > n || m < 0) return 0;
return fac[n] * 1ll * ifac[n - m] % mod * ifac[m] % mod;
}
inline long long F(long long n, long long m) {
if (m < 0) return 0;
return C(n + m - 1, n - 1);
}
inline long long Mod(long long x) {
if (x >= mod)
x -= mod;
else if (x < 0)
x += mod;
return x;
}
inline long long F1(long long n, long long m, long long r) {
if (!n && !m) return 1;
long long ret = 0, sign = (n & 1) ? -1 : 1;
for (long long i = 0; i <= n; ++i, sign *= -1)
if (m - (r + 1) * (n - i) >= 0)
(ret += sign * C(n, i) % mod * F(n, m - (r + 1) * (n - i)) % mod) %= mod;
return ret;
}
int main() {
fac[0] = 1;
for (long long i = 1; i <= 10000; ++i) fac[i] = fac[i - 1] * 1ll * i % mod;
ifac[10000] = Pow(fac[10000], mod - 2);
for (long long i = 9999; i >= 0; --i)
ifac[i] = ifac[i + 1] * 1ll * (i + 1) % mod;
cin >> n >> s >> r;
long long ans = 0;
for (long long x = r; x <= s; ++x) {
for (long long y = 0; (y + 1) * x <= s && y + 1 <= n; ++y) {
long long m = n - y - 1, ss = s - (y + 1) * x;
ans = Mod(ans +
F1(m, ss, x - 1) * 1ll * C(n - 1, y) % mod * inv(y + 1) % mod);
}
}
cout << ans * 1ll * inv(C(s - r + n - 1, n - 1)) % mod;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int Pow(int a, int b, int md, int ret = 1) {
for (; b; b >>= 1, a = 1ll * a * a % md) {
if (b & 1) ret = 1ll * ret * a % md;
}
return ret;
}
const int N = 5e4 + 10, MOD = 998244353;
int first[N], I[N], inv[N], m, n, r;
int C(int x, int y) {
if (x < y || y < 0) return 0;
return 1ll * first[x] * I[y] % MOD * I[x - y] % MOD;
}
int main() {
scanf("%d%d%d", &n, &m, &r);
first[0] = 1;
for (int i = 1; i < N; i++) inv[i] = Pow(i, MOD - 2, MOD);
for (int i = 1; i < N; i++) first[i] = 1ll * first[i - 1] * i % MOD;
I[N - 1] = Pow(first[N - 1], MOD - 2, MOD);
for (int i = N - 1; i; i--) {
I[i - 1] = 1ll * I[i] * i % MOD;
}
int ret = 0;
for (int i = 0; i < n; i++) {
for (int j = r; j <= m; j++) {
int a = n - i - 1, b = m - (i + 1) * j, c = j - 1;
int tot = 0;
if (b < 0) continue;
if (!a) {
tot = (!b);
} else {
for (int d = 0; d <= a; d++) {
int x = 1ll * C(a, d) * C(a + b - 1 - d * (c + 1), a - 1) % MOD;
tot = (tot + (d & 1 ? -x : x) + (d & 1) * MOD) % MOD;
}
}
ret = (ret + 1ll * C(n - 1, i) * tot % MOD * inv[i + 1]) % MOD;
}
}
ret = 1ll * ret * Pow(C(m + n - 1 - r, n - 1), MOD - 2, MOD) % MOD;
printf("%d\n", ret);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int c[10007][5007];
const long long mod = 998244353;
long long pown(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans = (ans * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return ans;
}
int C(int x, int y) {
if (x < 0 || y < 0)
return 0;
else
return c[x][y];
}
int main() {
int n, s, r;
scanf("%d%d%d", &n, &s, &r);
if (n == 1) {
printf("1");
return 0;
}
c[0][0] = 1;
for (int i = 1; i <= 10000; i++) {
c[i][0] = 1;
for (int k = 1; k <= min(i, 5000); k++)
c[i][k] = (c[i - 1][k] + c[i - 1][k - 1]) % mod;
}
long long x = 0, y = 0;
for (int i = r; i <= s; i++) {
int end = (i == 0) ? n : min(s / i, n);
for (int k = 1; k <= end; k++) {
if (k == n) {
long long sum = (k * i == s);
x += sum;
x %= mod;
y += (sum * pown(k, mod - 2)) % mod;
y %= mod;
continue;
}
int flag = 1;
long long now = 0;
for (int z = 0; z <= end - k; z++) {
now += C(n - k, z) *
(C(s - i * (k + z) + n - k - 1, n - k - 1) * flag + mod) % mod;
now %= mod;
flag = -flag;
}
now *= C(n - 1, k - 1);
now %= mod;
now = (now * pown(k, mod - 2)) % mod;
y += now;
y %= mod;
}
}
printf("%lld", y * pown(C(s - r + n - 1, n - 1), mod - 2) % mod);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long ksm(long long x, long long t) {
long long ans = 1;
for (; t; t >>= 1, x = (x * x) % 998244353)
if (t & 1) ans = (ans * x) % 998244353;
return ans;
}
int p, s, r;
long long fac[6005], invf[6005];
void pre() {
fac[0] = 1;
for (int i = 1; i <= p + s; i++) fac[i] = (fac[i - 1] * i) % 998244353;
invf[p + s] = ksm(fac[p + s], 998244353 - 2);
for (int i = p + s - 1; i >= 0; i--)
invf[i] = (invf[i + 1] * (i + 1)) % 998244353;
}
long long C(long long n, long long m) {
if (n < 0 || m < 0 || m > n) return 0;
return ((fac[n] * invf[n - m]) % 998244353 * invf[m]) % 998244353;
}
long long ans;
long long g(long long s, long long p, long long m) {
if (p == 0 && s == 0) return 1;
long long tot = 0;
for (int i = 0, t = 1; i <= p; i++) {
tot += t * (C(p, i) * C(s + p - 1 - i * (m + 1), p - 1) % 998244353);
tot = (tot + 998244353) % 998244353;
t *= -1;
}
return tot;
}
int main() {
scanf("%d%d%d", &p, &s, &r);
pre();
for (int t = r; t <= s; t++)
for (int q = 1; q <= p; q++) {
ans += ((C(p - 1, q - 1) * ksm(q, 998244353 - 2) % 998244353) *
g(s - q * t, p - q, t - 1)) %
998244353;
ans %= 998244353;
}
ans *= ksm(C(s + p - 1 - r, p - 1), 998244353 - 2);
ans %= 998244353;
printf("%lld", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long poww(long long x, long long y) {
long long res = 1;
while (y > 0) {
if (y & 1) res = (res * x) % 998244353ll;
y = y >> 1;
x = (x * x) % 998244353ll;
}
return res;
}
long long p, s, r;
long long fac[100005], inv[100005], num[100005];
long long func(long long, long long, long long),
calc(long long, long long, long long), C(long long, long long);
int main() {
cin >> p >> s >> r;
fac[0] = inv[0] = 1;
for (int i = 1; i < 10005; i++) {
num[i] = poww(i, 998244353ll - 2);
fac[i] = (fac[i - 1] * i) % 998244353ll;
inv[i] = poww(fac[i], 998244353ll - 2);
}
long long ans = 0, div = poww(C(s - r + p - 1, s - r), 998244353ll - 2);
for (int i = r; i < s + 1; i++) {
ans = (ans + func(p, s, i)) % 998244353ll;
}
cout << ((ans * div) % 998244353ll);
}
long long func(long long p, long long s, long long top) {
long long ans = 0;
for (int i = 0; i < p; i++) {
long long rem = s - (i + 1) * top;
long long left = (p - i - 1);
if (rem < 0 || left * (top - 1) < rem) continue;
ans = (ans + num[i + 1] * C(p - 1, i) % 998244353ll * calc(left, rem, top) %
998244353ll) %
998244353ll;
}
return ans;
}
long long calc(long long left, long long rem, long long top) {
long long ans = 0;
long long p = 1;
for (int i = 0; i < rem + 1; i++) {
long long rr = (rem - top * i);
if (rr < 0) break;
ans = ((ans + p * C(left, i) * (rr == 0 ? 1 : C(left - 1 + rr, rr))) %
998244353ll +
998244353ll) %
998244353ll;
p *= -1;
}
return ans;
}
long long C(long long x, long long y) {
return fac[x] * inv[y] % 998244353ll * inv[x - y] % 998244353ll;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
int n, S, r;
long long C[5205][5205], ans;
long long power(long long x, long long y) {
long long ret = 1;
for (; y; y >>= 1, x = x * x % mod)
if (y & 1) ret = ret * x % mod;
return ret;
}
long long inv(long long x) { return power(x, mod - 2); }
int main() {
C[0][0] = 1;
for (int i = 1; i <= 5200; i++) {
C[i][0] = 1;
for (int j = 1; j <= i; j++)
C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % mod;
}
scanf("%d%d%d", &n, &S, &r);
for (int i = r; i <= S; i++)
for (int j = 0; j < n; j++) {
int rest = S - (j + 1) * i;
long long tmp = 0;
if (j + 1 == n)
tmp = (rest == 0);
else {
for (int k = 0; k <= n - j - 1; k++)
if (rest - k * i >= 0) {
if (k & 1)
tmp = (tmp -
C[n - j - 1][k] * C[rest - k * i + n - j - 2][n - j - 2] %
mod +
mod) %
mod;
else
tmp = (tmp + C[n - j - 1][k] *
C[rest - k * i + n - j - 2][n - j - 2] % mod) %
mod;
}
}
ans = (ans + tmp * C[n - 1][j] % mod * inv(j + 1)) % mod;
}
printf("%lld\n", ans * inv(C[S - r + n - 1][n - 1]) % mod);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
const int maxn = 10000 + 10;
long long mypow(long long x, long long res) {
if (res == 0) return 1;
long long cur = mypow(x, res >> 1);
cur = cur * cur % mod;
if (res & 1) cur = cur * x % mod;
return cur;
}
long long fac[maxn], rev[maxn];
void pre() {
fac[0] = fac[1] = rev[0] = rev[1] = 1;
for (int i = 2; i < maxn; i++) {
fac[i] = fac[i - 1] * i % mod;
rev[i] = ((mod - mod / i * rev[mod % i]) % mod + mod) % mod;
}
for (int i = 2; i < maxn; i++) rev[i] = rev[i - 1] * rev[i] % mod;
}
long long C(int m, int n) {
if (m < n) return 0;
return fac[m] * rev[n] % mod * rev[m - n] % mod;
}
long long cal(int n, int lim, int s) {
if (s < 0 || lim == 0) return 0;
if (n == 0) return s == 0;
long long ans = 0;
for (int i = 0; i <= min(n, s / lim); i++) {
if (i & 1)
ans = ((ans - C(n, i) * C(s - i * lim + n - 1, n - 1)) % mod + mod) % mod;
else
ans = (ans + C(n, i) * C(s - i * lim + n - 1, n - 1)) % mod;
}
return ans;
}
int main() {
pre();
int p, s, r;
scanf("%d%d%d", &p, &s, &r);
if (s == 0) {
printf("%lld", rev[p] * fac[p - 1] % mod);
return 0;
}
long long ans = 0;
for (int i = r; i <= s; i++)
for (int j = 1; j <= p; j++)
ans = (ans + C(p - 1, j - 1) * cal(p - j, i, s - i * j) % mod * rev[j] %
mod * fac[j - 1]) %
mod;
ans = ans * mypow(cal(p, s + 1, s - r), mod - 2) % mod;
printf("%lld", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long power(long long b, long long e, long long m) {
if (e == 0) return 1;
if (e & 1) return b * power(b * b % m, e / 2, m) % m;
return power(b * b % m, e / 2, m);
}
long long power(long long b, long long e) {
if (e == 0) return 1;
if (e & 1) return b * power(b * b, e / 2);
return power(b * b, e / 2);
}
long long inv[10000 + 5], fac_inv[10000 + 5], fac[10000 + 5];
void initialize() {
long long i;
inv[1] = 1;
for (i = 2; i <= 10000; i++)
inv[i] = (998244353 - 998244353 / i) * inv[998244353 % i] % 998244353;
fac[0] = fac[1] = 1;
for (i = 2; i <= 10000; i++) fac[i] = i * fac[i - 1] % 998244353;
fac_inv[0] = fac_inv[1] = 1;
for (i = 2; i <= 10000; i++) fac_inv[i] = inv[i] * fac_inv[i - 1] % 998244353;
}
long long ncr(long long n, long long r) {
if (n < 0 || r < 0) return 0;
if (n < r) return 0;
return (fac[n] * fac_inv[r] % 998244353) * fac_inv[n - r] % 998244353;
}
long long solve(long long sc, long long n, long long s) {
if (s < 0) return 0;
if (n == 0 && s == 0) return 1LL;
long long ret = ncr(s + n - 1, n - 1);
for (long long i = 1; i <= n; ++i) {
long long kk = ncr(s - i * sc + n - 1, n - 1);
kk *= ncr(n, i);
kk %= 998244353;
if (i & 1)
ret -= kk;
else
ret += kk;
ret += 998244353;
ret %= 998244353;
}
return ret;
}
int _runtimeTerror_() {
long long p, s, r, i;
cin >> p >> s >> r;
long long ans = 0;
for (i = r; i <= s; ++i) {
for (long long j = 1; j <= p; ++j) {
long long fuck = solve(i, p - j, s - i * j);
ans += fuck * power(j, 998244353 - 2, 998244353) % 998244353 *
ncr(p - 1, j - 1) % 998244353;
ans %= 998244353;
}
}
long long tt = ncr(s - r + p - 1, p - 1);
cout << ans * power(tt, 998244353 - 2, 998244353) % 998244353 << "\n";
return 0;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
initialize();
int TESTS = 1;
while (TESTS--) _runtimeTerror_();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long mod = 998244353;
long long cd, s, r, fact[10001], sf[10001], invmod[10001];
void inp() { cin >> cd >> s >> r; }
long long bigmod(long long base, long long hat) {
if (hat == 0) return 1;
long long k = bigmod(base, hat / 2);
if (hat % 2 == 0) return k * k % mod;
return k * k % mod * base % mod;
}
void create() {
for (long long i = 0; i <= 10000; i++) {
if (i == 0)
fact[i] = 1;
else
fact[i] = fact[i - 1] * i % mod;
sf[i] = bigmod(fact[i], mod - 2);
invmod[i] = bigmod(i, mod - 2);
}
}
long long C(long long k, long long n) {
if (k > n || k < 0 || n < 0) return 0;
return fact[n] * sf[k] % mod * sf[n - k] % mod;
}
void do_it() {
create();
long long all = 0, kq = 0;
for (long long i = r; i <= s; i++) {
all += C(cd - 2, s - i + cd - 1 - 1);
all %= mod;
if (cd * i == s) kq += invmod[cd], kq %= mod;
for (long long e = 1; e < cd; e++) {
if (e * i > s) break;
long long remain = s - e * i, inv = 0;
remain += cd - e;
long long space = C(e - 1, cd - 1) * C(cd - e - 1, remain - 1) % mod;
for (long long f = 1; f <= cd - e; f++) {
long long t = remain - i * f;
if (t < 0 || cd - e - 1 > t - 1) break;
if (f % 2 == 1)
inv += C(cd - e - 1, t - 1) * C(f, cd - e) % mod;
else
inv -= C(cd - e - 1, t - 1) * C(f, cd - e) % mod;
inv += mod * 5, inv %= mod;
}
inv *= C(cd - e, cd - 1);
space -= inv, space += mod * 5, space %= mod;
kq += space * invmod[e] % mod, kq %= mod;
}
}
if (cd == 1) kq = 1, all = 1;
cout << kq * bigmod(all, mod - 2) % mod << endl;
}
int main() {
inp();
do_it();
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void ckmax(T& x, T y) {
x = (y > x ? y : x);
}
template <typename T>
inline void ckmin(T& x, T y) {
x = (y < x ? y : x);
}
const int MAXN = 100, MAXM = 5000;
const int MOD = 998244353;
inline int mod1(int x) { return x < MOD ? x : x - MOD; }
inline int mod2(int x) { return x < 0 ? x + MOD : x; }
inline void add(int& x, int y) { x = mod1(x + y); }
inline void sub(int& x, int y) { x = mod2(x - y); }
inline int pow_mod(int x, int i) {
int y = 1;
while (i) {
if (i & 1) y = (long long)y * x % MOD;
x = (long long)x * x % MOD;
i >>= 1;
}
return y;
}
int fac[MAXM + MAXN + 5], ifac[MAXM + MAXN + 5];
inline int comb(int n, int k) {
if (n < k) return 0;
return (long long)fac[n] * ifac[k] % MOD * ifac[n - k] % MOD;
}
void facinit(int lim) {
fac[0] = 1;
for (int i = 1; i <= lim; ++i) fac[i] = (long long)fac[i - 1] * i % MOD;
ifac[lim] = pow_mod(fac[lim], MOD - 2);
for (int i = lim - 1; i >= 0; --i)
ifac[i] = (long long)ifac[i + 1] * (i + 1) % MOD;
}
int n, m, low;
int main() {
facinit(MAXM + MAXN);
cin >> n >> m >> low;
int ans = 0;
for (int v = low; v <= m; ++v) {
for (int i = 1; i < n; ++i) {
if (i * v > m) break;
int curans = 0;
for (int j = 0; j <= n - i; ++j) {
if ((i + j) * v > m) break;
int tmp = (long long)comb(n - 1, i - 1) * comb(n - i, j) % MOD *
comb(m - (i + j) * v + (n - i) - 1, n - i - 1) % MOD;
if (j & 1)
sub(curans, tmp);
else
add(curans, tmp);
}
add(ans, (long long)curans * ifac[i] % MOD * fac[i - 1] % MOD);
}
if (n * v == m) {
add(ans, (long long)ifac[n] * fac[n - 1] % MOD);
}
}
ans = (long long)ans * pow_mod(comb(m - low + n - 1, n - 1), MOD - 2) % MOD;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int setBit(int N, int pos) { return N = N | (1 << pos); }
inline int resetBit(int N, int pos) { return N = N & ~(1 << pos); }
inline bool checkBit(int N, int pos) { return (bool)(N & (1 << pos)); }
const long long int MOD = 998244353;
inline long long int add(long long int a, long long int b) {
a += b;
if (a >= MOD) a -= MOD;
return a;
}
inline long long int sub(long long int a, long long int b) {
a -= b;
if (a < 0) a += MOD;
return a;
}
inline long long int mul(long long int a, long long int b) {
a *= b;
a %= MOD;
return a;
}
long long int fact[100010], inv[100010];
long long int nCr(int n, int r) {
if (r > n) return 0;
long long int ret = mul(inv[r], inv[n - r]);
ret = mul(ret, fact[n]);
return ret;
}
long long int f(int n, int k) {
if (k == 0) return 1;
return nCr(n + k - 1, n - 1);
}
long long int g(int n, int make, int high) {
if (n == 0 && make == 0) return 1;
if (high < 0) return 0;
if (make < 0) return 0;
if (high * n < make) return 0;
if (make == 0) return 1;
long long int ret = f(n, make);
for (int i = 1; i <= n; i++) {
long long int done = i * (high + 1);
if (done > make) break;
long long int cur = mul(nCr(n, i), f(n, make - done));
if (i & 1)
ret = sub(ret, cur);
else
ret = add(ret, cur);
}
return ret;
}
long long int exp(int a, int b) {
if (b == 0) return 1;
if (b & 1) return mul(a, exp(a, b - 1));
long long int ret = exp(a, b / 2);
return mul(ret, ret);
}
long long int I[100010];
int main() {
fact[0] = inv[0] = I[0] = 1;
for (int i = 1; i <= 100000; i++)
fact[i] = mul(fact[i - 1], i), inv[i] = exp(fact[i], MOD - 2),
I[i] = exp(i, MOD - 2);
int n, sum, low;
scanf("%d %d %d", &n, &sum, &low);
if (n == 1) {
printf("1\n");
return 0;
}
long long int total = 0;
long long int ans = 0;
for (int i = low; i <= sum; i++) {
total = add(total, f(n - 1, sum - i));
ans = add(ans, g(n - 1, sum - i, i - 1));
for (int k = 2; k <= n; k++) {
if (i * k > sum) break;
long long int nw = mul(g(n - k, sum - (i * k), i - 1), nCr(n - 1, k - 1));
nw = mul(nw, I[k]);
ans = add(ans, nw);
}
}
ans = mul(ans, exp(total, MOD - 2));
cout << ans << endl;
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.