text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 1;
vector<int> g[N];
pair<pair<int, int>, int> dfs(int v, int k, int &best, int hv = 0) {
if (g[v].empty()) {
best = max(best, 1);
return {{1, hv}, 1};
}
pair<int, int> sum = {0, N};
int bestdp = 0;
for (auto u : g[v]) {
auto res = dfs(u, k, best, hv + 1);
if (res.first.second - hv > k) {
bestdp = max(bestdp, res.second);
continue;
}
sum.first += res.first.first;
sum.second = min(sum.second, res.first.second);
bestdp = max(bestdp, res.second - res.first.first);
}
best = max(best, sum.first + bestdp);
return {sum, sum.first + bestdp};
}
void solve() {
int n, k;
cin >> n >> k;
for (int i = 2; i <= n; i++) {
int p;
cin >> p;
g[p].push_back(i);
}
int res = 0;
dfs(1, k, res);
cout << res;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
void init() { ios_base::sync_with_stdio(0); }
const int duzo = 1000007;
vector<int> g[duzo];
int uciek[duzo], max_uciek[duzo], max_zost[duzo];
int n, k;
void dfs(int w) {
if ((int)g[w].size() == 0) {
uciek[w] = k;
max_uciek[w] = max_zost[w] = 1;
return;
}
int suma_uciek = 0;
int gz = 0, gz_ucieki = 0;
for (auto x : g[w]) {
dfs(x);
if (uciek[x]) {
suma_uciek += max_uciek[x];
gz = max(gz, max_zost[x] - max_uciek[x]);
gz_ucieki = max(gz_ucieki, uciek[x]);
} else {
gz = max(gz, max_zost[x]);
}
}
if (gz_ucieki) uciek[w] = gz_ucieki - 1;
max_uciek[w] = suma_uciek;
max_zost[w] = suma_uciek + gz;
}
int main() {
init();
cin >> n >> k;
int oj;
for (int i = 2; i <= n; ++i) {
cin >> oj;
g[oj].push_back(i);
}
dfs(1);
cout << max_zost[1];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000005;
struct strongly_connected {
vector<int> gph[MAXN];
vector<int> rev[MAXN];
int comp[MAXN], p;
bool vis[MAXN];
vector<int> dfn;
void add_edge(int s, int e) {
gph[s].push_back(e);
rev[e].push_back(s);
}
void dfs(int x) {
if (vis[x]) return;
vis[x] = 1;
for (auto &i : gph[x]) dfs(i);
dfn.push_back(x);
}
void rdfs(int x, int p) {
if (comp[x]) return;
comp[x] = p;
for (auto &i : rev[x]) rdfs(i, p);
}
void get_scc(int n) {
for (int i = 0; i < n; i++) {
if (!vis[i]) dfs(i);
}
reverse(dfn.begin(), dfn.end());
for (auto &i : dfn) {
if (!comp[i]) rdfs(i, ++p);
}
}
} scc;
int n, k, par[MAXN], anc[MAXN], dp[MAXN];
vector<int> gph[MAXN], dag[MAXN];
vector<int> stk;
void dfs(int x) {
stk.push_back(x);
anc[x] = (stk.size() >= k + 1 ? stk[stk.size() - k - 1] : 1);
for (auto &i : gph[x]) dfs(i);
stk.pop_back();
}
int main() {
scanf("%d %d", &n, &k);
for (int i = 2; i <= n; i++) {
scanf("%d", &par[i]);
gph[par[i]].push_back(i);
}
dfs(1);
for (int i = 2; i <= n; i++) {
scc.add_edge(par[i], i);
if (gph[i].size() == 0) {
scc.add_edge(i, anc[i]);
}
}
scc.get_scc(n + 1);
int m = scc.p;
for (int i = 1; i <= n; i++) {
if (gph[i].size() == 0) dp[scc.comp[i]]++;
for (auto &j : scc.gph[i]) {
int l = scc.comp[i];
int r = scc.comp[j];
if (l != r) {
dag[l].push_back(r);
}
}
}
for (int i = m; i; i--) {
int cnt = dp[i];
dp[i] = 0;
for (auto &j : dag[i]) dp[i] = max(dp[i], dp[j]);
dp[i] += cnt;
}
cout << *max_element(dp, dp + m + 1) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace IO {
char buf[1 << 21], *p1 = buf, *p2 = buf;
char getch() {
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin), p1 == p2)
? EOF
: *p1++;
}
template <typename T>
void read(T &x) {
char ch = getch();
int fl = 1;
x = 0;
while (ch > '9' || ch < '0') {
if (ch == '-') fl = -1;
ch = getch();
}
while (ch <= '9' && ch >= '0') {
x = x * 10 + ch - 48;
ch = getch();
}
x *= fl;
}
template <typename T, typename... Args>
void read(T &x, Args &...args) {
read(x);
read(args...);
}
} // namespace IO
using namespace IO;
int n, K;
int son[1000010], bro[1000010];
int dm[1000010], dep[1000010];
int f[1000010], ans[1000010];
void dfs(int u, int d) {
dep[u] = d;
dm[u] = 0x3f3f3f3f;
if (!son[u]) dm[u] = d;
for (int v = son[u]; v; v = bro[v]) dfs(v, d + 1), dm[u] = min(dm[u], dm[v]);
}
void dp(int u) {
if (!son[u]) f[u] = 1;
for (int v = son[u]; v; v = bro[v]) {
dp(v);
if (dm[v] - dep[u] <= K) f[u] += f[v], f[v] = 0;
}
}
void dfs2(int u) {
for (int v = son[u]; v; v = bro[v]) dfs2(v), ans[u] = max(ans[u], ans[v]);
ans[u] += f[u];
}
int main() {
read(n, K);
for (int i = 2; i <= n; i++) {
int fa;
read(fa);
bro[i] = son[fa];
son[fa] = i;
}
dfs(1, 1);
dp(1);
dfs2(1);
printf("%d\n", ans[1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const double PI = acos(-1.);
const double eps = 1e-10;
const int INF = 0x3f3f3f3f;
const long long INFLL = 0x3f3f3f3f3f3f3f3f;
const int MAXN = 1e6 + 5;
vector<int> G[MAXN];
int dep[MAXN];
int fa[MAXN][22];
pair<int, int> mi[MAXN];
void dfs1(int now, int d, int par) {
fa[now][0] = par;
dep[now] = d;
if (G[now].size())
mi[now] = {INF, 0};
else
mi[now] = {d, now};
for (int i = 0; i <= 20; i++) fa[now][i + 1] = fa[fa[now][i]][i];
for (int i : G[now]) {
dfs1(i, d + 1, now);
mi[now] = min(mi[now], mi[i]);
}
}
int lca(int x, int dis) {
for (int i = 20; i >= 0; i--)
if ((dis >> i) & 1) x = fa[x][i];
return x;
}
int v[MAXN];
int n, k;
int dfs2(int now) {
int maxn = 0;
for (int i : G[now]) maxn = max(maxn, dfs2(i));
return maxn + v[now];
}
int p[MAXN];
pair<int, int> w[MAXN];
int main() {
scanf("%d %d", &n, &k);
for (int i = 2; i <= n; i++) {
int p;
scanf("%d", &p);
G[p].push_back(i);
}
dfs1(1, 0, 0);
for (int i = 1; i <= n; i++) {
if (!G[i].size()) p[i] = lca(i, min(dep[i], k));
w[i] = {dep[i], i};
}
sort(w + 1, w + 1 + n);
for (int i = 1; i <= n; i++) {
int u = w[i].second;
if (!G[u].size()) {
if (mi[p[u]].second != u) p[u] = p[mi[p[u]].second];
v[p[u]]++;
}
}
int ret = dfs2(1);
printf("%d\n", ret);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int tot, fa[1000005][20], in[1000005], ans, dp[1000005], st[1000005], hd, cl, x,
n, k, i, j, deg[1000005], dfn[1000005], low[1000005], sum[1000005],
col[1000005], vis[1000005];
vector<int> son[1000005], to[1000005];
queue<int> q;
void add(int x, int y) { son[x].push_back(y); }
inline int find(int x, int y) {
for (int i = 19; ~i; --i)
if ((y >> i) & 1) x = fa[x][i];
return x;
}
void tarjan(int now) {
dfn[now] = low[now] = ++tot;
st[++hd] = now;
vis[now] = 1;
for (int T, i = 0; i < son[now].size(); ++i) {
if (!dfn[T = son[now][i]])
tarjan(T), low[now] = min(low[now], low[T]);
else if (vis[T])
low[now] = min(low[now], low[T]);
}
if (low[now] == dfn[now]) {
++cl;
while (now != st[hd + 1]) {
sum[cl] += in[st[hd]];
vis[st[hd]] = 0;
col[st[hd]] = cl;
--hd;
}
}
}
int main() {
ios::sync_with_stdio(0);
cin >> n >> k;
for (i = 2; i <= n; ++i) cin >> fa[i][0], ++in[fa[i][0]], add(fa[i][0], i);
fa[1][0] = 1;
for (i = 1; i <= 19; ++i)
for (j = 1; j <= n; ++j) fa[j][i] = fa[fa[j][i - 1]][i - 1];
for (i = 1; i <= n; in[i] = (in[i] == 0), ++i)
if (!in[i]) add(i, find(i, k));
for (tarjan(i = 1); i <= n; ++i) {
for (j = 0; j < son[i].size(); ++j) {
if (col[son[i][j]] != col[i]) {
to[col[i]].push_back(col[son[i][j]]);
++deg[col[son[i][j]]];
}
}
}
for (i = 1; i <= cl; ++i)
if (!deg[i]) q.push(i);
while (q.size()) {
x = q.front();
q.pop();
dp[x] += sum[x];
ans = max(ans, dp[x]);
for (i = 0; i < to[x].size(); ++i) {
if (!--deg[to[x][i]]) q.push(to[x][i]);
dp[to[x][i]] = max(dp[to[x][i]], dp[x]);
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void Read(int &val) {
val = 0;
char c;
do {
c = getchar();
} while (!isdigit(c));
while (isdigit(c)) {
val = val * 10 + c - '0';
c = getchar();
}
}
struct dataQues {
int l, r, h;
dataQues(){};
dataQues(int l, int r, int h) : l(l), r(r), h(h){};
bool operator<(const dataQues &a) const {
if (h != a.h) return h < a.h;
if (l != a.l) return l < a.l;
return r < a.r;
}
bool operator==(const dataQues &a) const {
return (h == a.h && l == a.l && r == a.r);
}
};
const int N = 1e6 + 4, LOG = 20;
int n, k;
vector<int> adj[N];
int Next[N];
bool Spe_ver[N];
int numET, L[N], R[N], hei[N];
vector<int> V[N];
struct Interval_Tree {
int node[4 * N], lazy[4 * N];
void clear() {
memset(node, 0, sizeof(node));
memset(lazy, 0, sizeof(lazy));
}
void Down(int i) {
if (lazy[i] == 0) return;
node[2 * i] = node[2 * i + 1] = lazy[i];
lazy[2 * i] = lazy[2 * i + 1] = lazy[i];
lazy[i] = 0;
}
void update(int i, int l, int r, int x, int y, int ver) {
if (l > y || x > r) return;
if (x <= l && r <= y) {
node[i] = lazy[i] = ver;
return;
}
Down(i);
int mid = (l + r) / 2;
update(2 * i, l, mid, x, y, ver);
update(2 * i + 1, mid + 1, r, x, y, ver);
node[i] = max(node[2 * i], node[2 * i + 1]);
}
int get(int i, int l, int r, int x, int y) {
if (l > y || x > r) return -10000;
if (x <= l && r <= y) return node[i];
Down(i);
int mid = (l + r) / 2;
int tmp1 = get(2 * i, l, mid, x, y),
tmp2 = get(2 * i + 1, mid + 1, r, x, y);
return max(tmp1, tmp2);
}
void add(int i, int l, int r, int x, int y, int val) {
if (l > y || x > r) return;
if (x <= l && r <= y) {
node[i] += val;
return;
}
int mid = (l + r) / 2;
add(2 * i, l, mid, x, y, val);
add(2 * i + 1, mid + 1, r, x, y, val);
node[i] = max(node[2 * i], node[2 * i + 1]);
}
} IT;
void DFS(int dad, int u) {
L[u] = ++numET;
hei[u] = hei[dad] + 1;
for (int v : adj[u]) DFS(u, v);
R[u] = numET;
if (adj[u].empty()) {
int need = max(1, hei[u] - k);
V[need].push_back(u);
}
while (V[hei[u]].size()) {
int v = V[hei[u]].back();
Next[v] = u;
Spe_ver[u] = true;
V[hei[u]].pop_back();
}
}
void DFS_getNext(int u) {
if (Spe_ver[u]) IT.update(1, 1, n, L[u] + 1, R[u], u);
for (int v : adj[u]) DFS_getNext(v);
}
vector<dataQues> ques;
void get_Query() {
for (int u = 1; u <= n; ++u) {
if (!Spe_ver[u]) continue;
ques.push_back(dataQues(L[u], R[u], hei[u] + k));
int dad = Next[u];
if (dad == 0) continue;
ques.push_back(dataQues(L[u], R[u], hei[dad] + k));
}
}
struct Binary_Indexed_Tree {
int node[N];
void update(int pos, int val) {
for (int i = pos; i < N; i += i & (-i)) node[i] += val;
}
int get(int pos) {
int ans = 0;
for (int i = pos; i > 0; i -= i & (-i)) ans += node[i];
return ans;
}
} BIT;
int ansQ[2 * N];
map<dataQues, int> Map;
void answer_Query() {
for (int i = 1; i <= n; ++i)
if (adj[i].empty()) V[hei[i]].push_back(i);
sort(ques.begin(), ques.end());
ques.resize(unique(ques.begin(), ques.end()) - ques.begin());
int curHei = 1, Time = 0;
for (dataQues foo : ques) {
int l = foo.l, r = foo.r, h = foo.h;
++Time;
Map[dataQues(l, r, h)] = Time;
while (curHei <= h) {
for (int u : V[curHei]) BIT.update(L[u], 1);
++curHei;
}
ansQ[Time] = BIT.get(r) - BIT.get(l - 1);
}
}
int best, Bonus[N];
void dp_on_tree(int u) {
for (int v : adj[u]) dp_on_tree(v);
if (adj[u].empty()) {
int dad = Next[u];
Bonus[dad]++;
return;
}
if (Spe_ver[u]) {
int dad = Next[u];
int id1 = Map[dataQues(L[u], R[u], hei[u] + k)];
int id2 = Map[dataQues(L[u], R[u], hei[dad] + k)];
int res = IT.get(1, 1, n, L[u], R[u]) + Bonus[u];
best = max(best, res);
if (dad != 0 && ansQ[id2] >= 1)
Bonus[dad] += Bonus[u];
else if (dad != 0)
IT.update(1, 1, n, L[u], L[u], res);
}
}
void sol() {
DFS(0, 1);
DFS_getNext(1);
for (int v = 1; v <= n; ++v) {
if (Spe_ver[v] || adj[v].empty()) {
int u = IT.get(1, 1, n, L[v], L[v]);
Next[v] = u;
}
}
get_Query();
answer_Query();
IT.clear();
dp_on_tree(1);
cout << best << '\n';
}
int main() {
if (fopen("input.txt", "r")) {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
Read(n);
Read(k);
for (int v = 2; v <= n; ++v) {
int u;
Read(u);
adj[u].push_back(v);
}
sol();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int next, to;
} e[1000005];
int f[1000005][2], mn[1000005], head[1000005], dep[1000005], g, n, k;
int read() {
int A;
bool K;
char C;
C = A = K = 0;
while (C < '0' || C > '9') K |= C == '-', C = getchar();
while (C > '/' && C < ':') A = (A << 3) + (A << 1) + (C ^ 48), C = getchar();
return (K ? -A : A);
}
inline void add(int u, int v) {
e[++g].to = v;
e[g].next = head[u];
head[u] = g;
}
void dfs(int u) {
if (!head[u]) {
f[u][0] = f[u][1] = 1;
mn[u] = dep[u];
return;
}
int i, v;
mn[u] = n;
for (i = head[u]; i; i = e[i].next) {
v = e[i].to;
dep[v] = dep[u] + 1;
dfs(v);
mn[u] = ((mn[u]) < (mn[v]) ? mn[u] : mn[v]);
if (mn[v] - dep[u] <= k)
f[u][1] += f[v][1],
f[u][0] =
((f[u][0]) > (f[v][0] - f[v][1]) ? f[u][0] : f[v][0] - f[v][1]);
else
f[u][0] = ((f[u][0]) > (f[v][0]) ? f[u][0] : f[v][0]);
}
f[u][0] += f[u][1];
}
int main() {
int i;
n = read(), k = read();
for (i = 2; i <= (n); i++) add(read(), i);
dfs(1);
cout << f[1][0];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e6 + 7;
const int INF = 1e9 + 7;
int n, k;
vector<int> g[MAXN];
void read() {
cin >> n >> k;
for (int i = 1; i < n; ++i) {
int p;
cin >> p;
--p;
g[i].push_back(p);
g[p].push_back(i);
}
}
int h[MAXN];
void dfs1(int u, int parent, int d) {
h[u] = d;
for (int v : g[u]) {
if (v == parent) continue;
dfs1(v, u, d + 1);
}
}
int dp1[MAXN], besth[MAXN];
int dp2[MAXN];
void calc(int u, int parent) {
bool lief = 1;
for (int v : g[u]) {
if (v == parent) continue;
lief = 0;
}
if (lief) {
besth[u] = h[u] - k;
dp1[u] = dp2[u] = 1;
return;
}
besth[u] = INF;
for (int v : g[u]) {
if (v == parent) continue;
besth[u] = min(besth[u], besth[v]);
}
for (int v : g[u]) {
if (v == parent) continue;
if (besth[v] <= h[u]) dp1[u] += dp1[v];
}
for (int v : g[u]) {
if (v == parent) continue;
int t = 0;
if (besth[v] <= h[u]) t = dp1[v];
dp2[u] = max(dp2[u], dp1[u] - t + dp2[v]);
}
}
void dfs2(int u, int parent) {
for (int v : g[u]) {
if (v == parent) continue;
dfs2(v, u);
}
calc(u, parent);
}
void solve() {
dfs1(0, 0, 0);
dfs2(0, 0);
}
void print() { cout << dp2[0] << '\n'; }
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
read();
solve();
print();
return 0;
}
|
#include <bits/stdc++.h>
const int N = 1000005, LG = 20;
int n, k;
std::vector<int> E[N];
int fa[N];
int dis[N], g[N], f[N];
void dfs1(int u) {
if (E[u].empty()) {
g[u] = 1;
dis[u] = 0;
return;
}
g[u] = 0;
dis[u] = N;
for (int v : E[u]) {
dfs1(v);
dis[u] = std::min(dis[u], dis[v] + 1);
if (dis[v] < k) {
g[u] += g[v];
}
}
}
void dfs2(int u) {
f[u] = g[u];
for (int v : E[u]) {
dfs2(v);
int t = dis[v] < k ? g[v] : 0;
f[u] = std::max(f[u], g[u] - t + f[v]);
}
}
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(0);
std::cin >> n >> k;
for (int i = 2; i <= n; ++i) {
std::cin >> fa[i];
E[fa[i]].push_back(i);
}
dfs1(1);
dfs2(1);
std::cout << f[1] << std::endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
int p[1000001];
int dep[1000001];
int f[1000001];
int cyc[1000001];
int val[1000001];
vector<int> adj[1000001];
void dfs1(int cur) {
for (auto e : adj[cur]) {
f[e] = dep[e] = dep[cur] + 1;
dfs1(e);
}
}
set<int> dfs2(int cur) {
set<int> ret = set<int>();
for (auto e : adj[cur]) {
auto V = dfs2(e);
if (V.size() > ret.size()) ret.swap(V);
for (auto u : V) ret.insert(u);
}
if (adj[cur].empty()) ret.insert(dep[cur]);
f[cur] = min(f[cur], (*ret.begin()) - k);
return ret;
}
void dfs3(int cur) {
for (auto e : adj[cur]) {
dfs3(e);
if (f[e] <= dep[cur]) cyc[cur] += cyc[e];
}
if (adj[cur].empty()) cyc[cur] = 1;
}
void dfs4(int cur) {
for (auto e : adj[cur]) {
dfs4(e);
if (f[e] > dep[cur])
val[cur] = max(val[cur], val[e]);
else
val[cur] = max(val[cur], val[e] - cyc[e]);
}
val[cur] += cyc[cur];
}
int main() {
cout << setprecision(10);
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
for (int i = 2; i <= n; i++) {
cin >> p[i];
adj[p[i]].push_back(i);
}
dfs1(1);
dfs2(1);
dfs3(1);
dfs4(1);
cout << val[1] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct DSU {
vector<int> pa;
DSU(int n = 1) { pa = vector<int>(n + 3, -1); }
int root(int i) {
if (pa[i] < 0) return i;
return pa[i] = root(pa[i]);
}
int size(int i) { return -pa[root(i)]; }
int merge(int a, int b) {
if (a < 0 || b < 0) return 0;
a = root(a);
b = root(b);
if (a == b) return a;
if (pa[a] < pa[b]) swap(a, b);
pa[b] += pa[a];
pa[a] = b;
return b;
}
};
int n, k;
vector<int> adj[1000002];
int fr[1000002];
int to[1000002];
int d[1000002];
int parr[1000002];
int timer = 0;
vector<int> DFS;
void dfs(int i) {
if (DFS.size() < k)
parr[i] = 1;
else
parr[i] = DFS[DFS.size() - k];
DFS.push_back(i);
fr[i] = to[i] = timer++;
for (int j : adj[i]) {
d[j] = d[i] + 1;
dfs(j);
to[i] = max(to[i], to[j]);
}
DFS.pop_back();
}
DSU dsu(1000002);
int X[1000002];
void dfs1(int i) {
X[i] = -1;
if (adj[i].empty()) X[i] = i;
for (int j : adj[i]) {
dfs1(j);
if (X[i] == -1) {
X[i] = X[j];
if (X[i] != -1 && d[X[i]] - d[i] > k) X[i] = -1;
continue;
}
if (X[j] != -1) {
if (d[X[j]] - d[i] <= k) {
dsu.merge(X[i], X[j]);
}
if (d[X[j]] < d[X[i]]) X[i] = X[j];
}
}
if (X[i] != -1 && d[X[i]] - d[i] > k) X[i] = -1;
}
vector<int> lygy[1000009];
struct SegTree {
int l, r;
int maxi = -1;
SegTree *left, *right;
SegTree(int l, int r) : l(l), r(r) {
if (l < r) {
left = new SegTree(l, (l + r) / 2);
right = new SegTree((l + r) / 2 + 1, r);
}
}
void set(int i, int w) {
if (!(l <= i && i <= r)) return;
if (l == r) {
maxi = w;
return;
}
left->set(i, w);
right->set(i, w);
maxi = max(left->maxi, right->maxi);
}
int get(int a, int b) {
if (a <= l && r <= b) return maxi;
if (b < l || r < a) return -1;
return max(left->get(a, b), right->get(a, b));
}
};
int par(int a, int k) { return parr[a]; }
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
cin >> n >> k;
d[1] = 0;
for (int i = 2; i <= n; i++) {
int p;
cin >> p;
adj[p].push_back(i);
}
dfs(1);
dfs1(1);
for (int i = 1; i <= n; i++)
if (adj[i].size() == 0) lygy[d[i]].push_back(i);
SegTree XXX(0, n + 5);
vector<int> visi[n + 4];
int atsak = -1;
for (int dep = n + 1; dep >= 0; dep--) {
for (int i : lygy[dep]) {
visi[dsu.root(i)].push_back(i);
if (dsu.size(i) == visi[dsu.root(i)].size()) {
int ans = 0;
for (int j : visi[dsu.root(i)]) {
XXX.set(fr[j], -1);
}
for (int j : visi[dsu.root(i)]) {
int c = par(j, k);
ans = max(ans, XXX.get(fr[c], to[c]));
}
ans += visi[dsu.root(i)].size();
atsak = max(atsak, ans);
for (int j : visi[dsu.root(i)]) {
XXX.set(fr[j], ans);
}
}
}
}
cout << atsak << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
int n, K;
const int nax = 1000005;
const int lgnax = 22;
int lca[nax][lgnax] = {{0}}, depth[nax];
vector<int> g[nax];
int dsu[nax], size[nax], leaf[nax], head[nax];
int dp[nax] = {0};
int findSet(int x) {
if (dsu[x] != x) dsu[x] = findSet(dsu[x]);
return dsu[x];
}
void mergeSet(int u, int v) {
u = findSet(u);
v = findSet(v);
if (u == v) return;
if (size[u] < size[v]) swap(u, v);
dsu[v] = u;
size[u] += size[v];
leaf[u] += leaf[v];
head[u] = (depth[head[u]] < depth[head[v]]) ? head[u] : head[v];
}
int climb(int u, int d) {
d = min(d, depth[u]);
for (int i = lgnax; i >= 0; i--)
if ((1 << i) <= d) {
d -= (1 << i);
u = lca[u][i];
}
return u;
}
int dfs1(int u = 1, int p = 0, int d = 0) {
depth[u] = d;
lca[u][0] = p;
for (int i = 1; i < lgnax; i++) lca[u][i] = lca[lca[u][i - 1]][i - 1];
int mx = 0;
for (auto &k : g[u])
if (k != p) {
int r = dfs1(k, u, d + 1);
if (mx == 0 || depth[r] < depth[mx]) mx = r;
}
if (mx == 0) mx = climb(u, K), leaf[u] = 1;
if (depth[mx] < depth[u]) mergeSet(u, mx);
return mx;
}
int dfs2(int u = 1, int p = 0) {
int mx = 0;
for (auto &k : g[u])
if (k != p) mx = max(mx, dfs2(k, u));
if (head[findSet(u)] == u) {
dp[u] = leaf[findSet(u)] + mx;
mx = dp[u];
}
return mx;
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
for (int i = 1; i < nax; i++) {
dsu[i] = i;
size[i] = 1;
leaf[i] = 0;
head[i] = i;
}
cin >> n >> K;
for (int i = 2; i <= n; i++) {
int p;
cin >> p;
g[p].push_back(i);
}
dfs1();
dfs2();
cout << dp[1] << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000020, INF = (int)1e9;
const int LOG_N = 20;
int root = 0;
int n, m, a, b;
int val[N];
vector<int> G[N];
int dp[2][N];
int up[N], down[N];
void get(int v) {
dp[0][v] = val[v];
for (int nxt : G[v]) {
get(nxt);
dp[0][v] += dp[0][nxt];
dp[1][v] = max(dp[1][v], dp[1][nxt]);
}
if (up[v] == -1) {
dp[1][v] = dp[1][v] + dp[0][v];
dp[0][v] = 0;
}
}
int dfs_val(int v, int p) {
if (G[v].size() == 0) {
down[v] = 0;
val[v] = 1;
} else {
down[v] = INF;
for (int nxt : G[v]) {
if (nxt != p) {
down[v] = min(down[v], dfs_val(nxt, v) + 1);
}
}
}
up[v] = (down[v] < m ? 1 : -1);
return down[v];
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i < n; i++) {
int x;
scanf("%d", &x);
x--;
G[x].push_back(i);
}
dfs_val(0, -1);
get(0);
cout << dp[0][0] + dp[1][0] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, x, K, kk, ans, g[2000005], sz[2000005], dp[2000005], dep[2000005],
dis[2000005], head[2000005];
struct Tree {
int nxt, to;
} e[2000005];
inline void link(int x, int y) {
e[++kk].nxt = head[x];
e[kk].to = y;
head[x] = kk;
}
void dfs1(int u, int fa) {
bool lev = 1;
sz[u] = 1;
dis[u] = 1e9;
for (int i = head[u]; i; i = e[i].nxt) {
int v = e[i].to;
if (v == fa) continue;
dep[v] = dep[u] + 1;
dfs1(v, u);
lev = 0;
sz[u] += sz[v];
dis[u] = min(dis[u], dis[v]);
}
if (lev) dis[u] = dep[u];
}
void dfs2(int u, int fa) {
dp[u] = (sz[u] == 1);
if (sz[u] == 1) return;
for (int i = head[u]; i; i = e[i].nxt) {
int v = e[i].to;
if (v == fa) continue;
dfs2(v, u);
if (dis[v] - K <= dep[u]) {
dp[u] += dp[v];
g[u] = max(g[u], g[v] - dp[v]);
} else
g[u] = max(g[u], g[v]);
}
g[u] += dp[u];
ans = max(ans, g[u]);
}
int main() {
scanf("%d%d", &n, &K);
for (int i = 2; i <= n; i++) {
scanf("%d", &x);
link(x, i);
}
dfs1(1, -1);
dfs2(1, -1);
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int nn = 1e6 + 8;
vector<int> G[nn];
int low[nn], f[nn][2];
int n, k;
void dfs(int u, int d) {
low[u] = n;
if (G[u].empty()) {
low[u] = d;
f[u][0] = 1;
}
int last = 0;
for (int v : G[u]) {
dfs(v, d + 1);
if (low[v] - d <= k) {
f[u][0] += f[v][0];
} else {
last = max(last, f[v][1]);
}
low[u] = min(low[u], low[v]);
}
for (int v : G[u]) {
last = max(last, f[v][1] - f[v][0]);
}
f[u][1] = f[u][0] + last;
}
int main() {
scanf("%d %d", &n, &k);
for (int i = 2; i <= n; i++) {
int u;
scanf("%d", &u);
G[u].push_back(i);
}
dfs(1, 0);
cout << f[1][1];
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k;
long long up[1000006], lvl[1000006], last[1000006];
pair<long long, long long> dp[1000006];
vector<long long> child[1000006];
long long b[1000006];
void bfs() {
long long st = 1, en = 1;
b[st] = 1;
lvl[1] = 1;
while (st <= en) {
long long node = b[st];
st++;
for (long long i = 1; i <= child[node].size(); i++) {
en++;
b[en] = child[node][i - 1];
lvl[b[en]] = lvl[node] + 1;
}
if (!child[node].size()) {
dp[node].first = 1;
dp[node].second = lvl[node];
last[node] = 1;
}
}
}
signed main() {
ios::sync_with_stdio(false);
cin >> n >> k;
if (n == 1) {
cout << 0;
return 0;
}
lvl[1] = 1;
for (long long i = 1; i <= n; i++) {
dp[i].first = 0, dp[i].second = 999999999;
}
for (long long i = 2; i <= n; i++) {
cin >> up[i];
child[up[i]].push_back(i);
}
bfs();
long long ans = 0;
for (long long i = n; i > 1; i--) {
if (dp[b[i]].second - lvl[up[b[i]]] <= k) {
dp[up[b[i]]].first += dp[b[i]].first;
dp[up[b[i]]].second = min(dp[up[b[i]]].second, dp[b[i]].second);
}
}
for (long long i = n; i >= 1; i--) {
for (long long j = 0; j < child[b[i]].size(); j++) {
long long temp = 0;
if (dp[child[b[i]][j]].second - lvl[b[i]] <= k) {
temp = dp[child[b[i]][j]].first;
}
last[b[i]] =
max(last[b[i]], last[child[b[i]][j]] + dp[b[i]].first - temp);
ans = max(ans, last[b[i]]);
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int tot;
int head[1000050], edge[1000050], nxt[1000050];
int fa[21][1000050];
void join(int u, int v) {
edge[tot] = v;
nxt[tot] = head[u];
head[u] = tot++;
}
void init() {
tot = 0;
memset(head, -1, sizeof(head));
scanf("%d%d", &n, &m);
for (int i = 2; i <= n; ++i) {
scanf("%d", &fa[0][i]);
join(fa[0][i], i);
}
}
int Fk(int v) {
for (int i = 0; i < 21; ++i)
if (m >> i & 1) v = fa[i][v];
return v;
}
int dep[1000050] = {1000050};
int leaf[1000050];
int dp[1000050][2];
int Min(int i, int j) { return dep[i] < dep[j] ? i : j; }
int dfs(int i) {
for (int j = 1; fa[j - 1][i]; ++j) fa[j][i] = fa[j - 1][fa[j - 1][i]];
int mx = 0;
for (int k = head[i]; ~k; k = nxt[k]) {
int j = edge[k];
dep[j] = dep[i] + 1;
dfs(j);
if (dep[leaf[j]] - dep[i] <= m) {
dp[i][0] += dp[j][0];
mx = max(mx, dp[j][1] - dp[j][0]);
leaf[i] = Min(leaf[j], leaf[i]);
} else
mx = max(mx, dp[j][1]);
}
if (!~head[i]) leaf[i] = i, dp[i][0] = 1;
dp[i][1] = max(dp[i][1], dp[i][0] + mx);
return leaf[i];
}
void solve() {
dfs(1);
printf("%d\n", dp[1][1]);
}
int main() {
init();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1);
const double eps = 1e-6;
inline int lowbit(int x) { return x & (-x); }
inline int read() {
int f = 1, x = 0;
char ch;
do {
ch = getchar();
if (ch == '-') f = -1;
} while (ch < '0' || ch > '9');
do {
x = x * 10 + ch - '0';
ch = getchar();
} while (ch >= '0' && ch <= '9');
return f * x;
}
template <typename T>
inline T max(T x, T y, T z) {
return max(max(x, y), z);
}
template <typename T>
inline T min(T x, T y, T z) {
return min(min(x, y), z);
}
template <typename T>
inline T sqr(T x) {
return x * x;
}
template <typename T>
inline void checkmax(T &x, T y) {
x = max(x, y);
}
template <typename T>
inline void checkmin(T &x, T y) {
x = min(x, y);
}
template <typename T>
inline void read(T &x) {
x = 0;
T f = 1;
char ch;
do {
ch = getchar();
if (ch == '-') f = -1;
} while (ch < '0' || ch > '9');
do x = x * 10 + ch - '0', ch = getchar();
while (ch <= '9' && ch >= '0');
x *= f;
}
template <typename A, typename B, typename C>
inline A fpow(A x, B p, C yql) {
A ans = 1;
for (; p; p >>= 1, x = 1LL * x * x % yql)
if (p & 1) ans = 1LL * x * ans % yql;
return ans;
}
struct FastIO {
static const int S = 1310720;
int wpos;
char wbuf[S];
FastIO() : wpos(0) {}
inline int xchar() {
static char buf[S];
static int len = 0, pos = 0;
if (pos == len) pos = 0, len = fread(buf, 1, S, stdin);
if (pos == len) return -1;
return buf[pos++];
}
inline int read() {
int c = xchar(), x = 0;
while (c <= 32 && ~c) c = xchar();
if (c == -1) return -1;
for (; '0' <= c && c <= '9'; c = xchar()) x = x * 10 + c - '0';
return x;
}
} io;
const int N = 1e6 + 10;
int head[N], tot = 0, size[N], n, m, fa[N], dep[N], k, dp[N];
struct Edge {
int u, v, next;
} G[N << 1];
inline void addedge(int u, int v) {
G[++tot].u = u;
G[tot].v = v;
G[tot].next = head[u];
head[u] = tot;
G[++tot].u = v;
G[tot].v = u;
G[tot].next = head[v];
head[v] = tot;
}
inline void dfs1(int u, int f) {
int d0 = dep[u];
for (int i = head[u]; i; i = G[i].next) {
int v = G[i].v;
if (v == f) continue;
dfs1(v, u);
size[u] += size[v];
checkmin(dep[u], dep[v] + 1);
checkmax(dp[u], dp[v] - size[v]);
}
dp[u] += size[u];
if (dep[u] == d0) {
dp[u] = 1;
size[u] = 1;
dep[u] = 0;
}
if (dep[u] >= k) size[u] = 0;
}
int main() {
n = read();
k = read();
memset(dep, 127, sizeof(dep));
for (int i = 2; i <= n; i++) {
int u = i, v = read();
fa[u] = v;
addedge(u, v);
}
dfs1(1, 0);
printf("%d\n", dp[1]);
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return a * (b / gcd(a, b)); }
pair<int, int> rev[1000005];
int h[1000005];
int d[1000005];
vector<int> g[1000005];
int N, K;
void pre_dfs(int u, int p = -1) {
rev[u] = pair<int, int>(1000005, 0);
for (int v : g[u]) {
if (v == p) continue;
h[v] = h[u] + 1;
pre_dfs(v, u);
if (rev[v].first <= h[u]) {
rev[u].first = min(rev[u].first, rev[v].first);
rev[u].second += rev[v].second;
}
}
if (p >= 0 && g[u].size() == 1) {
rev[u].first = h[u] - K;
rev[u].second = 1;
}
}
void sol(int u, int p = -1) {
d[u] = p >= 0 && g[u].size() == 1;
for (int v : g[u]) {
if (v == p) continue;
sol(v, u);
int temp = rev[u].second;
if (rev[v].first <= h[u]) temp -= rev[v].second;
d[u] = max(d[u], temp + d[v]);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> N >> K;
for (int i = 1; i <= N - 1; i++) {
int u;
cin >> u;
u--;
g[i].push_back(u);
g[u].push_back(i);
}
h[0] = 0;
pre_dfs(0);
sol(0);
cout << d[0] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000005;
int n, k, D, q[N], S[N], sz[N], ans;
vector<int> e[N];
void dfs1(int x) {
q[++*q] = x;
if (!e[x].size()) {
++S[x];
++sz[x];
if (*q > k) --S[q[*q - k]];
}
for (auto i : e[x]) {
dfs1(i);
S[x] += S[i];
if (S[i]) {
sz[x] += sz[i];
sz[i] = 0;
}
}
--*q;
}
void dfs2(int x, int s) {
ans = max(ans, s += sz[x]);
for (auto i : e[x]) dfs2(i, s);
}
int main() {
scanf("%d%d", &n, &k);
for (int i = (int)(2); i <= (int)(n); i++) {
int x;
scanf("%d", &x);
e[x].push_back(i);
}
dfs1(1);
dfs2(1, 0);
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e6 + 5;
int n, K, tot, head[MAX], d[MAX], cnt[MAX], cnt_[MAX];
struct P {
int to, nxt;
} e[MAX];
void init() {
memset(head, -1, sizeof(head));
tot = 0;
}
void adde(int u, int v) {
e[tot].to = v;
e[tot].nxt = head[u];
head[u] = tot++;
}
void dfs(int u) {
if (~head[u]) {
cnt[u] = cnt_[u] = 0;
d[u] = 0x3f3f3f3f;
int tmp = 0;
for (int i = head[u]; ~i; i = e[i].nxt) {
int v = e[i].to;
dfs(v);
if (d[v] > K)
cnt_[u] = max(cnt_[u], cnt[v] + cnt_[v]);
else {
cnt[u] += cnt[v];
cnt_[u] = max(cnt_[u], cnt_[v]);
}
d[u] = min(d[u], d[v]);
}
++d[u];
} else {
d[u] = 1;
cnt[u] = 1;
cnt_[u] = 0;
}
}
int main() {
int x;
while (~scanf("%d%d", &n, &K)) {
init();
for (int i = 2; i <= n; ++i) {
scanf("%d", &x);
adde(x, i);
}
dfs(1);
printf("%d\n", cnt_[1] + cnt[1]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct IO {
char buf[(1 << 20)], *p1, *p2;
char pbuf[(1 << 20)], *pp;
IO() : p1(buf), p2(buf), pp(pbuf) {}
inline char gc() {
return getchar();
if (p1 == p2) p2 = (p1 = buf) + fread(buf, 1, (1 << 20), stdin);
return p1 == p2 ? ' ' : *p1++;
}
inline bool blank(char ch) {
return ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t';
}
template <class T>
inline void read(T &x) {
register double tmp = 1;
register bool sign = 0;
x = 0;
register char ch = gc();
for (; !(ch >= '0' && ch <= '9'); ch = gc())
if (ch == '-') sign = 1;
for (; (ch >= '0' && ch <= '9'); ch = gc()) x = x * 10 + (ch - '0');
if (ch == '.')
for (ch = gc(); (ch >= '0' && ch <= '9'); ch = gc())
tmp /= 10.0, x += tmp * (ch - '0');
if (sign) x = -x;
}
inline void read(char *s) {
register char ch = gc();
for (; blank(ch); ch = gc())
;
for (; !blank(ch); ch = gc()) *s++ = ch;
*s = 0;
}
inline void read(char &c) {
for (c = gc(); blank(c); c = gc())
;
}
template <class t>
inline void write(t x) {
if (x < 0)
putchar('-'), write(-x);
else {
if (x > 9) write(x / 10);
putchar('0' + x % 10);
}
}
} io;
const int mod = 1e9 + 7;
const int mo = 998244353;
const int N = 1e6 + 5;
int n, m, x, Mx, father[N], md[N], siz[N], dep[N];
vector<int> h[N];
inline void dfs(int u) {
int sz = (int)h[u].size() - 1;
for (int i = (0); i <= (sz); i++) {
int v = h[u][i];
if (v == father[u]) continue;
dep[v] = dep[u] + 1;
dfs(v);
}
}
inline void dfs1(int u) {
int sz = (int)h[u].size() - 1;
md[u] = 1e9;
if (u != 1 && !sz) md[u] = dep[u];
for (int i = (0); i <= (sz); i++) {
int v = h[u][i];
if (v == father[u]) continue;
dfs1(v);
md[u] = min(md[u], md[v]);
}
}
inline void dfs2(int u) {
int sz = (int)h[u].size() - 1;
if (u != 1 && !sz) siz[u] = 1;
for (int i = (0); i <= (sz); i++) {
int v = h[u][i];
if (v == father[u]) continue;
dfs2(v);
if (md[v] - dep[u] <= m) siz[u] += siz[v], siz[v] = 0;
}
}
inline int dfs3(int u) {
int sz = (int)h[u].size() - 1;
int mx = 0;
for (int i = (0); i <= (sz); i++) {
int v = h[u][i];
if (v == father[u]) continue;
mx = max(mx, dfs3(v));
}
return siz[u] + mx;
}
int main() {
io.read(n), io.read(m);
for (int i = (2); i <= (n); i++)
io.read(father[i]), h[father[i]].push_back(i), h[i].push_back(father[i]);
dfs(1);
dfs1(1);
dfs2(1);
int sz = (int)h[1].size() - 1;
for (int i = (0); i <= (sz); i++) Mx = max(Mx, dfs3(h[1][i]));
io.write(siz[1] + Mx), puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Tree {
vector<int> child;
};
int ans[1000005] = {0};
long deep[1000005];
void dfs(int x, Tree t[], int dp[], int k) {
int temp = 0;
if (t[x].child.size() == 0) {
dp[x] = 1;
deep[x] = 0;
return;
}
for (int i : t[x].child) {
dfs(i, t, dp, k);
if (deep[i] < k) dp[x] += dp[i];
temp = max(temp, ans[i] - (deep[i] < k ? dp[i] : 0));
deep[x] = min(deep[x], deep[i] + 1);
}
ans[x] = dp[x] + temp;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long n;
long k;
cin >> n >> k;
fill(deep, deep + n + 1, 1000000);
Tree t[n + 1];
int dp[n + 1];
fill(dp, dp + n + 1, 0);
for (long i = 2; i < n + 1; i++) {
long p;
cin >> p;
t[p].child.push_back(i);
}
dfs(1, t, dp, k);
cout << ans[1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 998244353, INF = 1 << 30, N = 1000005;
int n, m, i, j, u, v, head[N], Next[N], adj[N], k, vis[N], dfn[N], low[N],
dep[N], siz[N];
void Push(int u, int v) {
Next[++k] = head[u];
head[u] = k;
adj[k] = v;
}
void dfs2(int i, int d) {
dep[i] = d;
int j;
low[i] = 1 << 30;
if (vis[i] == 0) low[i] = d;
for (j = head[i]; j != 0; j = Next[j]) {
dfs2(adj[j], d + 1);
low[i] = min(low[i], low[adj[j]]);
}
}
void dfs3(int i) {
int j;
if (vis[i] == 0) siz[i] = 1;
for (j = head[i]; j != 0; j = Next[j]) {
dfs3(adj[j]);
if (low[adj[j]] - dep[i] <= m) {
siz[i] += siz[adj[j]];
siz[adj[j]] = 0;
}
}
}
int dfs(int i) {
int j, s = 0;
for (j = head[i]; j != 0; j = Next[j]) s = max(s, dfs(adj[j]));
return s + siz[i];
}
int main() {
scanf("%d %d", &n, &m);
for (i = 2; i <= n; i++) {
scanf("%d", &u);
Push(u, i);
vis[u] = 1;
}
dfs2(1, 0);
dfs3(1);
printf("%d", dfs(1));
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000010;
int n, k;
int p[maxn];
vector<int> G[maxn];
int dep[maxn];
int min_dep[maxn];
bool is_leaf[maxn];
int dp[maxn];
void pre_dfs(int u) {
int sz = G[u].size();
is_leaf[u] = 1;
for (int i = 0; i < sz; i++) {
int v = G[u][i];
dep[v] = dep[u] + 1;
is_leaf[u] = 0;
pre_dfs(v);
min_dep[u] = min(min_dep[u], min_dep[v]);
}
if (is_leaf[u]) min_dep[u] = dep[u];
}
int last_dep = 0;
int tmp = 0;
int ans = 0;
int que[maxn];
int que_size = 0;
int dfs(int u) {
int re = is_leaf[u];
int sz = G[u].size();
for (int i = 0; i < sz; i++) {
int v = G[u][i];
if (min_dep[v] - dep[v] >= k) {
que[que_size++] = v;
continue;
} else {
re += dfs(v);
}
}
dp[u] = re;
return re;
}
int dfs2(int u) {
int re = is_leaf[u];
int sz = G[u].size();
int mx = 0;
for (int i = 0; i < sz; i++) {
int v = G[u][i];
if (min_dep[v] - dep[v] >= k) {
mx = max(mx, dfs2(v));
} else {
int tmp = dfs2(v);
mx = max(mx, tmp - dp[v]);
re += dp[v];
}
}
re += mx;
return re;
}
int main() {
cin >> n >> k;
for (int i = 2; i <= n; i++) {
scanf("%d", &p[i]);
G[p[i]].push_back(i);
}
for (int i = 1; i <= n; i++) min_dep[i] = 1e9;
pre_dfs(1);
que[que_size++] = 1;
for (int i = 0; i < que_size; i++) {
dfs(que[i]);
}
cout << dfs2(1) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000010;
int head[maxn], Next[maxn], ver[maxn];
int d[maxn], dp[maxn], re[maxn];
int tot;
int n, k;
void add(int x, int y) {
ver[++tot] = y;
Next[tot] = head[x];
head[x] = tot;
}
void dfs(int x) {
d[x] = 0x3f3f3f3f;
int y;
for (int i = head[x]; i; i = Next[i]) {
y = ver[i];
dfs(y);
d[x] = min(d[x], d[y] + 1);
re[x] += re[y];
dp[x] = max(dp[x], dp[y] - re[y]);
}
dp[x] += re[x];
if (d[x] == 0x3f3f3f3f) {
d[x] = 0;
dp[x] = re[x] = 1;
}
if (d[x] >= k) {
re[x] = 0;
}
}
int main() {
scanf("%d%d", &n, &k);
int x;
for (int i = 2; i <= n; i++) {
scanf("%d", &x);
add(x, i);
}
dfs(1);
printf("%d\n", dp[1]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N_MAX = 1e6 + 5;
int n, k, ans = 1;
vector<int> a[N_MAX];
int f[N_MAX][2];
set<int, greater<int>> l[N_MAX];
void dfs1(int u, int h) {
if (a[u].empty()) {
f[u][0] = f[u][1] = 1;
l[u].insert(h);
return;
}
for (int v : a[u]) {
dfs1(v, h + 1);
while (!l[v].empty() && *(l[v].begin()) - h > k) l[v].erase(l[v].begin());
if (!l[v].empty()) f[u][0] += f[v][0];
}
for (int v : a[u]) {
int temp = f[u][0];
if (!l[v].empty()) temp -= f[v][0];
f[u][1] = max(f[u][1], temp + f[v][1]);
}
for (int v : a[u]) {
if ((int)l[u].size() < (int)l[v].size()) swap(l[u], l[v]);
for (auto it = l[v].begin(); it != l[v].end(); ++it) l[u].insert(*it);
l[v].clear();
}
ans = max(ans, f[u][1]);
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> k;
for (int i = 2; i <= n; ++i) {
int p;
cin >> p;
a[p].push_back(i);
}
dfs1(1, 0);
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 69, L = 22;
int n, k, lift[N][L], dp[N], dep[N], shallow[N], sz[N], up[N];
vector<int> adj[N];
void dfs(int v = 1, int d = 0) {
dep[v] = d;
if (adj[v].empty()) shallow[v] = d;
for (int u : adj[v]) {
dfs(u, d + 1);
shallow[v] = min(shallow[v], shallow[u]);
}
}
void build() {
for (int j = 1; j < L; ++j)
for (int i = 1; i <= n; ++i) lift[i][j] = lift[lift[i][j - 1]][j - 1];
}
int jump(int v, int k) {
for (int i = L - 1; ~i; --i)
if (k & (1 << i)) v = lift[v][i];
return v;
}
void go(int v = 1) {
int mx = 0;
for (int u : adj[v]) {
go(u);
mx = max(mx, dp[u]);
}
dp[v] += mx;
}
int main() {
cin.tie(0)->sync_with_stdio(0);
cin >> n >> k;
for (int i = 2; i <= n; ++i) {
cin >> lift[i][0];
++sz[lift[i][0]];
}
for (int i = 1; i <= n; ++i) adj[i].reserve(sz[i]);
for (int i = 1; i <= n; ++i) adj[lift[i][0]].push_back(i);
lift[1][0] = 1;
build();
memset(shallow, 0x3f, sizeof(shallow));
dfs();
for (int i = 1; i <= n; ++i) {
int dif = shallow[i] - dep[i];
if (dif <= k) up[i] = jump(i, k - dif);
}
for (int i = 1; i <= n; ++i) lift[i][0] = up[i];
build();
for (int i = 1; i <= n; ++i) {
if (adj[i].size()) continue;
int v = i;
for (int j = L - 1; ~j; --j)
if (lift[v][j]) v = lift[v][j];
++dp[v];
}
go();
cout << dp[1] << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a;
pair<int, int> dp[1000005];
int out[1000005], k;
int height[1000005];
vector<int> v[1000005];
void dfs1(int node, int prev) {
dp[node] = {10000000, 0};
if (v[node].size() == 1 and prev >= 0) {
dp[node] = {height[node] - k, 1};
}
for (auto it : v[node]) {
if (it == prev) continue;
height[it] = height[node] + 1;
dfs1(it, node);
if (dp[it].first <= height[node]) {
dp[node].first = min(dp[node].first, dp[it].first);
dp[node].second += dp[it].second;
}
}
}
void dfs2(int node, int prev) {
out[node] = 0;
for (auto it : v[node]) {
if (it == prev) continue;
dfs2(it, node);
int ha = dp[node].second;
if (dp[it].first <= height[node]) ha -= dp[it].second;
out[node] = max(out[node], ha + out[it]);
}
if (prev >= 0 and v[node].size() == 1) out[node] = 1;
}
int main() {
cin >> n >> k;
for (int i = 0; n - 1 > i; i++) {
cin >> a;
v[i + 2].push_back(a);
v[a].push_back(i + 2);
}
dfs1(1, -1);
dfs2(1, -1);
cout << out[1];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, f[1000005], g[1000005], dep[1000005], x, dp[1000005];
vector<int> v[1000005];
void dfs1(int x, int y) {
f[x] = 2e9;
dep[x] = y;
for (int i = 0; i < v[x].size(); i++)
dfs1(v[x][i], y + 1), f[x] = min(f[x], f[v[x][i]]);
if (v[x].size() == 0) f[x] = y;
}
void dfs2(int x) {
g[x] = v[x].size() == 0;
for (int i = 0; i < v[x].size(); i++) {
int h = v[x][i];
dfs2(h);
if (f[h] - dep[x] <= k) g[x] += g[h], g[h] = 0;
}
}
int dfs3(int x) {
int nx = 0;
for (int i = 0; i < v[x].size(); i++) {
int h = v[x][i];
nx = max(nx, dfs3(h));
}
return g[x] + nx;
}
signed main() {
ios::sync_with_stdio(0);
cin >> n >> k;
for (int i = 2; i <= n; i++) cin >> x, v[x].push_back(i);
dfs1(1, 1), dfs2(1);
printf("%d", dfs3(1));
}
|
#include <bits/stdc++.h>
using namespace std;
int inf = 1000000007;
int k;
int dp[1000000 + 50];
vector<int> adj[1000000 + 50];
int h[1000000 + 50];
pair<int, int> p[1000000 + 50];
void hei(int v, int par, int curh) {
h[v] = curh;
for (auto bc : adj[v]) {
if (bc == par) continue;
hei(bc, v, curh + 1);
}
}
void pre(int v, int par) {
p[v] = make_pair(inf, 0);
for (auto bc : adj[v]) {
if (bc == par) continue;
h[bc] = h[v] + 1;
pre(bc, v);
if (p[bc].first <= h[v]) {
p[v].second += p[bc].second;
p[v].first = min(p[v].first, p[bc].first);
}
}
if (adj[v].size() == 1 && v != 1) {
p[v] = make_pair(h[v] - k, 1);
}
}
void calc(int v, int par) {
dp[v] = (v >= 1 && adj[v].size() == 1);
for (auto bc : adj[v]) {
if (bc == par) continue;
calc(bc, v);
int tmp = p[v].second;
if (p[bc].first <= h[v]) tmp -= p[bc].second;
dp[v] = max(dp[v], tmp + dp[bc]);
}
}
int main() {
int n, x;
cin >> n >> k;
for (int i = 2; i <= n; i++) {
cin >> x;
adj[i].push_back(x);
adj[x].push_back(i);
}
pre(1, 0);
calc(1, 0);
cout << dp[1];
}
|
#include <bits/stdc++.h>
template <class Cost = int>
struct Edge {
int src, dst;
Edge(int src = -1, int dst = -1) : src(src), dst(dst){};
};
template <class Cost = int>
struct Graph {
std::vector<std::vector<Edge<Cost>>> graph;
Graph(int n = 0) : graph(n) {}
void span(bool direct, int src, int dst) {
graph[src].emplace_back(src, dst);
if (!direct) graph[dst].emplace_back(dst, src);
}
int size() const { return graph.size(); }
void clear() { graph.clear(); }
void resize(int n) { graph.resize(n); }
std::vector<Edge<Cost>>& operator[](int v) { return graph[v]; }
std::vector<Edge<Cost>> operator[](int v) const { return graph[v]; }
};
constexpr int N = 1000000;
int par[21][N];
template <class Cost = int>
struct LevelAncestor {
Graph<Cost> tree;
int kmax;
void dfs(int v, int p = -1) {
par[0][v] = p;
for (const auto& e : tree[v]) {
if (e.dst == p) continue;
dfs(e.dst, v);
}
}
LevelAncestor(const Graph<Cost>& tree, int root) : tree(tree) {
kmax = 0;
while ((1 << kmax) < (int)tree.size()) ++kmax;
dfs(root);
for (int k = 1; k <= kmax; ++k) {
for (int v = 0; v < (int)tree.size(); ++v) {
int p = par[k - 1][v];
par[k][v] = (p == -1 ? -1 : par[k - 1][p]);
}
}
}
int climb(int v, int d) const {
for (int k = kmax; k >= 0 && v != -1; --k) {
if ((1 << k) > d) continue;
v = par[k][v];
d -= (1 << k);
}
return v;
}
};
int up[N], upto[N], szs[N];
void solve() {
int n, k;
std::cin >> n >> k;
Graph<> graph(n);
for (int v = 1; v < n; ++v) {
int p;
std::cin >> p;
graph.span(true, --p, v);
}
std::vector<int> vs;
{
std::queue<int> que;
que.push(0);
while (!que.empty()) {
int v = que.front();
que.pop();
vs.push_back(v);
for (auto e : graph[v]) {
que.push(e.dst);
}
}
}
auto rvs = vs;
std::reverse(rvs.begin(), rvs.end());
for (auto v : rvs) {
if (graph[v].empty()) {
up[v] = k;
continue;
}
for (auto e : graph[v]) {
up[v] = std::max(up[v], up[e.dst] - 1);
}
}
{
LevelAncestor<> la(graph, 0);
for (auto v : vs) {
int u = la.climb(v, up[v]);
if (u == -1) u = 0;
upto[v] = (u == v ? u : upto[u]);
}
}
for (auto v : vs) {
if (graph[v].empty()) ++szs[upto[v]];
}
for (auto v : rvs) {
int max = 0;
for (auto e : graph[v]) max = std::max(max, szs[e.dst]);
szs[v] += max;
}
std::cout << szs[0] << "\n";
}
int main() {
std::cin.tie(nullptr);
std::ios::sync_with_stdio(false);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma warning(disable : 4996)
const int N = 1e6 + 6, INF = 2e9;
vector<int> v[N];
long long int t[N * 4], up[N * 4], z[N], mx[N], lb[N], rb[N];
int timer = 0;
int n, k;
void push(int v, int L, int R) {
if (up[v]) {
if (L != R) {
up[v * 2] += up[v];
up[v * 2 + 1] += up[v];
}
t[v] += up[v];
up[v] = 0;
}
}
void upd(int l, int r, int x, int v = 1, int L = 0, int R = n - 1) {
push(v, L, R);
if (l > r) return;
if (l == L && r == R) {
up[v] += x;
push(v, L, R);
} else {
int m = (L + R) >> 1;
upd(l, min(m, r), x, v * 2, L, m);
upd(max(m + 1, l), r, x, v * 2 + 1, m + 1, R);
t[v] = max(t[v * 2], t[v * 2 + 1]);
}
}
long long int que(int l, int r, int v = 1, int L = 0, int R = n - 1) {
push(v, L, R);
if (l > r) return -INF;
if (l == L && r == R) return t[v];
int m = (L + R) >> 1;
return max(que(l, min(m, r), v * 2, L, m),
que(max(m + 1, l), r, v * 2 + 1, m + 1, R));
}
set<pair<int, int>>* dfs(int node, int h) {
lb[node] = timer++;
if (v[node].empty()) {
mx[node] = 1;
auto st = new set<pair<int, int>>();
st->insert({-h, node});
upd(lb[node], lb[node], 1);
rb[node] = timer - 1;
return st;
}
upd(lb[node], lb[node], -INF);
vector<set<pair<int, int>>*> t;
long long int sum = 0;
for (int to : v[node]) {
t.push_back(dfs(to, h + 1));
z[to] = max(0ll, que(lb[to], rb[to]));
sum += z[to];
}
rb[node] = timer - 1;
for (int to : v[node]) {
long long int cs = sum - z[to];
upd(lb[to], rb[to], cs);
mx[node] = max(mx[node], cs + mx[to]);
}
for (int i = 1; i < t.size(); i++) {
if (t[0]->size() < t[i]->size()) swap(t[0], t[i]);
}
for (int i = 1; i < t.size(); i++) {
t[0]->insert(t[i]->begin(), t[i]->end());
}
while (!t[0]->empty() && -t[0]->begin()->first - h >= k) {
int a = t[0]->begin()->second;
upd(lb[a], lb[a], -INF);
t[0]->erase(t[0]->begin());
}
return t[0];
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i < n; i++) {
int p;
scanf("%d", &p);
v[p - 1].push_back(i);
}
dfs(0, 0);
printf("%d", mx[0]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, h[1000100], ret[1000100], nonret[1000100], up[1000100];
vector<int> child[1000100];
void dfs(int u) {
int ok = 1;
nonret[u] = 0;
ret[u] = 0;
up[u] = h[u];
for (int i = 0; i < child[u].size(); i++) {
int v = child[u][i];
ok = 0;
h[v] = h[u] + 1;
dfs(v);
up[u] = min(up[u], up[v]);
if (up[v] <= h[u])
ret[u] += ret[v], nonret[u] = max(nonret[u], nonret[v]);
else
nonret[u] = max(nonret[u], ret[v] + nonret[v]);
}
if (ok) up[u] = h[u] - k, ret[u] = 1;
}
int main() {
scanf("%d%d", &n, &k);
h[1] = 0;
for (int i = 2; i <= n; i++) {
int a;
scanf("%d", &a);
child[a].push_back(i);
}
dfs(1);
printf("%d\n", ret[1] + nonret[1]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 3;
int n, k;
vector<int> AdjList[maxn];
int die[maxn];
int cnt[maxn];
int ans[maxn];
const int inf = 1e9 + 7;
void dfs(int st) {
die[st] = inf;
for (int u : AdjList[st]) {
dfs(u);
cnt[st] += cnt[u];
die[st] = min(die[st], die[u] + 1);
ans[st] = max(ans[st], ans[u] - cnt[u]);
}
ans[st] += cnt[st];
if (die[st] == inf) {
die[st] = 0;
ans[st] = cnt[st] = 1;
}
if (die[st] >= k) cnt[st] = 0;
}
signed main() {
cin >> n >> k;
for (int i = 2; i <= n; i++) {
int p;
cin >> p;
AdjList[p].push_back(i);
}
dfs(1);
cout << ans[1];
}
|
#include <bits/stdc++.h>
const int N = 1000001;
int n, k, dilen[N], ditiep[N], diluon[N];
std::vector<int> adj[N];
void dfs(int u) {
if (adj[u].empty()) {
dilen[u] = k;
ditiep[u] = 1;
}
for (int v : adj[u]) {
dfs(v);
if (dilen[v] == 0)
ditiep[v] = 0;
else {
dilen[u] = std::max(dilen[u], dilen[v] - 1);
ditiep[u] += ditiep[v];
}
diluon[u] = std::max(diluon[u], diluon[v] - ditiep[v]);
}
diluon[u] += ditiep[u];
}
int main() {
std::cin >> n;
if (n == 1) {
std::cout << '0';
return 0;
}
std::cin >> k;
for (int i = 2; i <= n; ++i) {
int p;
std::cin >> p;
adj[p].push_back(i);
}
dfs(1);
std::cout << diluon[1];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 gen(chrono::system_clock::now().time_since_epoch().count());
const int M = 1e9 + 7;
const int N = 1e6 + 7;
int n, k, p, kol[N], d[N], h[N], dp[N];
vector<int> g[N];
void dfs(int v, int p) {
int leaf = 1;
h[v] = 1e9;
dp[v] = -1e9;
d[v] = d[p] + 1;
for (auto to : g[v]) {
if (to == p) continue;
dfs(to, v);
h[v] = min(h[v], h[to]);
kol[v] += kol[to];
dp[v] = max(dp[v], dp[to] - kol[to]);
leaf = 0;
}
if (leaf && v) {
dp[v] = 1;
kol[v] = 1;
h[v] = d[v];
} else {
dp[v] += kol[v];
if (h[v] - d[v] >= k) kol[v] = 0;
}
return;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
if (n == 1) {
cout << 0;
return 0;
}
for (int i = 1; i < n; i++) {
cin >> p;
p--;
g[i].push_back(p);
g[p].push_back(i);
}
dfs(0, 0);
cout << dp[0];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double PI = 3.14159265359;
const long long MOD = (long long)998244353ll;
const long long MAXN = (long long)1e6 + 10;
const long long INF = (long long)2242545357980376863;
const long double EPS = (long double)1e-8;
long long n, k;
long long val[MAXN], par[MAXN], dp[MAXN];
vector<long long> G[MAXN], H[MAXN], R[MAXN], vis, ord, topol;
vector<pair<long long, long long> > to_add, E;
bitset<1000010> lf, mk1, mk2;
void DFS(long long u) {
long long dep = vis.size();
vis.push_back(u);
long long p = vis[max(dep - k, 0ll)];
lf[u] = true;
for (auto adj : G[u]) {
DFS(adj);
lf[u] = false;
}
if (lf[u]) to_add.push_back({u, p});
vis.pop_back();
}
void DFS1(long long u) {
mk1[u] = true;
for (auto adj : G[u]) {
if (!mk1[adj]) DFS1(adj);
}
ord.push_back(u);
}
void DFS2(long long u, long long p) {
mk2[u] = true;
par[u] = p;
val[p] += (lf[u] ? 1 : 0);
for (auto adj : H[u]) {
if (!mk2[adj]) DFS2(adj, p);
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
long long u, v;
for (int i = 2; i <= n; i++) {
cin >> u;
G[u].push_back(i);
H[i].push_back(u);
E.push_back({i, u});
}
DFS(1);
for (auto edge : to_add) {
u = edge.first;
v = edge.second;
G[u].push_back(v);
H[v].push_back(u);
E.push_back({v, u});
}
DFS1(1);
reverse(ord.begin(), ord.end());
for (auto node : ord) {
if (!mk2[node]) {
DFS2(node, node);
topol.push_back(node);
}
}
for (auto edge : E) {
u = edge.first;
v = edge.second;
u = par[u];
v = par[v];
if (u != v) R[u].push_back(v);
}
for (auto node : topol) {
dp[node] = val[node];
for (auto adj : R[node]) {
dp[node] = max(dp[node], dp[adj] + val[node]);
}
}
cout << *max_element(dp + 1, dp + n + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void chmin(T &x, const T &y) {
if (x > y) x = y;
}
template <typename T>
void chmax(T &x, const T &y) {
if (x < y) x = y;
}
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - 48;
ch = getchar();
}
return x * f;
}
const int N = 1e6 + 10;
int n, k, dep[N], head[N], cnt, low[N], sz[N];
struct node {
int to, next;
} edge[N << 1];
inline void add(int u, int v) {
edge[++cnt] = {v, head[u]};
head[u] = cnt;
}
inline void dfs(int u, int fa) {
dep[u] = dep[fa] + 1;
low[u] = 0x3f3f3f3f;
if (!head[u]) low[u] = dep[u];
for (int i = head[u]; i; i = edge[i].next) {
int v = edge[i].to;
dfs(v, u);
chmin(low[u], low[v]);
}
}
inline void work(int u, int fa) {
if (!head[u]) sz[u] = 1;
for (int i = head[u]; i; i = edge[i].next) {
int v = edge[i].to;
work(v, u);
if (low[v] - dep[u] <= k) sz[u] += sz[v], sz[v] = 0;
}
}
inline int solve(int u, int fa) {
int ret = 0;
for (int i = head[u]; i; i = edge[i].next) {
int v = edge[i].to;
chmax(ret, solve(v, u));
}
return ret + sz[u];
}
int main() {
n = read(), k = read();
for (int i = 2; i <= n; i++) add(read(), i);
dfs(1, 0);
work(1, 0);
cout << solve(1, 0);
return 0;
;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool upmin(T &x, T y) {
return y <= x ? x = y, 1 : 0;
}
template <typename T>
inline bool upmax(T &x, T y) {
return x <= y ? x = y, 1 : 0;
}
const long double eps = 1e-9;
const long double pi = acos(-1);
const int oo = 1 << 30;
const long long loo = 1ll << 60;
const int MAXN = 1000005;
const int MAXM = 2000005;
const int MX = 5000;
const int mods = 998244353;
const int SZ = 131;
const int inv2 = (mods + 1) >> 1;
const int INF = 0x3f3f3f3f;
namespace FastIO {
constexpr int SIZE = (1 << 21) + 1;
int num = 0, f;
char ibuf[SIZE], obuf[SIZE], que[65], *iS, *iT, *oS = obuf,
*oT = obuf + SIZE - 1, c;
inline void flush() {
fwrite(obuf, 1, oS - obuf, stdout);
oS = obuf;
}
inline void putc(char c) {
*oS++ = c;
if (oS == oT) flush();
}
inline void getc(char &c) {
for (c = (iS == iT ? (iT = ((iS = ibuf) + fread(ibuf, 1, SIZE, stdin)),
(iS == iT ? EOF : *iS++))
: *iS++);
!isalpha(c) && c != EOF;
c = (iS == iT ? (iT = ((iS = ibuf) + fread(ibuf, 1, SIZE, stdin)),
(iS == iT ? EOF : *iS++))
: *iS++))
;
}
inline void reads(char *st) {
char c;
int n = 0;
getc(st[++n]);
for (c = (iS == iT ? (iT = ((iS = ibuf) + fread(ibuf, 1, SIZE, stdin)),
(iS == iT ? EOF : *iS++))
: *iS++);
isalpha(c);
c = (iS == iT ? (iT = ((iS = ibuf) + fread(ibuf, 1, SIZE, stdin)),
(iS == iT ? EOF : *iS++))
: *iS++))
st[++n] = c;
st[++n] = '\0';
}
template <class I>
inline void read(I &x) {
for (f = 1, c = (iS == iT ? (iT = ((iS = ibuf) + fread(ibuf, 1, SIZE, stdin)),
(iS == iT ? EOF : *iS++))
: *iS++);
c < '0' || c > '9';
c = (iS == iT ? (iT = ((iS = ibuf) + fread(ibuf, 1, SIZE, stdin)),
(iS == iT ? EOF : *iS++))
: *iS++))
if (c == '-') f = -1;
for (x = 0; c >= '0' && c <= '9';
c = (iS == iT ? (iT = ((iS = ibuf) + fread(ibuf, 1, SIZE, stdin)),
(iS == iT ? EOF : *iS++))
: *iS++))
x = (x << 3) + (x << 1) + (c & 15);
x *= f;
}
template <class I>
inline void print(I x) {
if (x < 0) putc('-'), x = -x;
if (!x) putc('0');
while (x) que[++num] = x % 10 + 48, x /= 10;
while (num) putc(que[num--]);
}
inline void putstr(string st) {
for (int i = 0; i < (int)st.size(); ++i) putc(st[i]);
}
struct Flusher_ {
~Flusher_() { flush(); }
} io_Flusher_;
} // namespace FastIO
using FastIO ::print;
using FastIO ::putc;
using FastIO ::putstr;
using FastIO ::read;
using FastIO ::reads;
vector<int> e[MAXN];
int ans = 0, n, m, mn[MAXN], f[MAXN];
void tree_dp(int x) {
for (auto v : e[x]) tree_dp(v);
if (!e[x].size()) {
f[x] = 1, mn[x] = 0;
return;
}
f[x] = 0, mn[x] = INF;
for (auto v : e[x]) {
upmin(mn[x], mn[v] + 1);
if (mn[v] < m) f[x] += f[v], f[v] = 0;
}
}
void getans(int x, int sum) {
sum += f[x], upmax(ans, sum);
for (auto v : e[x]) getans(v, sum);
}
int main() {
read(n), read(m);
for (int i = 2, x; i <= n; ++i) read(x), e[x].push_back(i);
tree_dp(1), getans(1, 0);
print(ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
int vet[N], nxt[N], head[N], num;
int cest[N], d[N], sum[N], n, k, is[N], x, ans;
inline int read() {
int s = 0, f = 1;
char c = getchar();
while (!isdigit(c)) f = c == '-' ? -1 : 1, c = getchar();
while (isdigit(c)) s = (s << 3) + (s << 1) + c - '0', c = getchar();
return s * f;
}
void add(int xx, int yy) {
vet[++num] = yy;
nxt[num] = head[xx];
head[xx] = num;
}
void dfs(int t, int dep) {
cest[t] = 1e9;
d[t] = dep;
if (!is[t]) cest[t] = dep, sum[t] = 1;
for (register int i = head[t]; i; i = nxt[i]) {
int v = vet[i];
dfs(v, dep + 1);
cest[t] = min(cest[t], cest[v]);
if (cest[v] <= k + d[t]) sum[t] += sum[v], sum[v] = 0;
}
}
int getsum(int t) {
int temp = 0;
for (register int i = head[t]; i; i = nxt[i])
temp = max(temp, getsum(vet[i]));
temp += sum[t];
return temp;
}
int main() {
n = read();
k = read();
for (register int i = 1; i < n; i++) x = read(), add(x, i + 1), is[x] = 1;
dfs(1, 0);
printf("%d", getsum(1));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2000000;
int n, k, head[MAXN], ver[MAXN], next1[MAXN], tot, f[MAXN], num[MAXN],
deep[MAXN];
void add(int x, int y) {
ver[++tot] = y;
next1[tot] = head[x];
head[x] = tot;
}
void dfs(int x, int fa) {
deep[x] = 10000000;
for (int i = head[x]; i; i = next1[i]) {
int y = ver[i];
if (y == fa) continue;
dfs(y, x);
deep[x] = min(deep[x], deep[y] + 1);
num[x] += num[y];
f[x] = max(f[x], f[y] - num[y]);
}
f[x] += num[x];
if (deep[x] == 10000000) {
f[x] = 1;
num[x] = 1;
deep[x] = 0;
}
if (deep[x] >= k) num[x] = 0;
}
int main() {
cin >> n >> k;
for (int i = 2; i <= n; i++) {
int x;
scanf("%d", &x);
add(x, i);
}
dfs(1, 0);
cout << f[1] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
inline char gc() {
static char buf[100000], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? EOF
: *p1++;
}
inline long long read() {
long long x = 0;
char ch = getchar();
bool positive = 1;
for (; !isdigit(ch); ch = getchar())
if (ch == '-') positive = 0;
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - '0';
return positive ? x : -x;
}
inline void write(long long a) {
if (a < 0) {
a = -a;
putchar('-');
}
if (a >= 10) write(a / 10);
putchar('0' + a % 10);
}
inline void writeln(long long a) {
write(a);
puts("");
}
inline void wri(long long a) {
write(a);
putchar(' ');
}
const int N = 1000005;
int n, k, fa[N], f[N], g[N], h[N];
vector<int> v[N];
void dfs(int p) {
if (v[p].size() == 0) {
f[p] = g[p] = 1;
return;
}
int mx = 0;
h[p] = N;
for (auto i : v[p]) {
dfs(i);
if (++h[i] > k) {
g[i] = 0;
}
g[p] += g[i];
h[p] = min(h[p], h[i]);
mx = max(mx, f[i] - g[i]);
}
f[p] = g[p] + mx;
}
int main() {
n = read();
k = read();
for (int i = 2; i <= n; i++) {
fa[i] = read();
v[fa[i]].push_back(i);
}
dfs(1);
cout << f[1] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long fpow(long long n, long long k, int p = 998244353) {
long long r = 1;
for (; k; k >>= 1) {
if (k & 1) r = r * n % p;
n = n * n % p;
}
return r;
}
inline long long inv(long long a, long long p = 998244353) {
return fpow(a, p - 2, p);
}
inline long long addmod(long long a, long long val, long long p = 998244353) {
{
if ((a = (a + val)) >= p) a -= p;
}
return a;
}
inline long long submod(long long a, long long val, long long p = 998244353) {
{
if ((a = (a - val)) < 0) a += p;
}
return a;
}
inline long long mult(long long a, long long b, long long p = 998244353) {
return (long long)a * b % p;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
bool greater = false;
cout << "? 0 0" << endl;
int x, y;
cin >> x;
if (x == 1) greater = true;
int cura = 0, curb = 0;
for (int i = 29; i >= 0; i--) {
cout << "? " << (cura ^ (1 << i)) << " " << curb << endl;
cin >> x;
cout << "? " << cura << " " << (curb ^ (1 << i)) << endl;
cin >> y;
if (x != y) {
if (y == 1) {
cura |= (1 << i);
curb |= (1 << i);
}
} else {
if (greater)
cura |= (1 << i);
else
curb |= (1 << i);
if (x == 1)
greater = true;
else
greater = false;
}
}
cout << "! " << cura << " " << curb << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int p;
int ask(int x, int y) {
if (p > 0) swap(x, y);
cout << "? " << x << " " << y << "\n";
cin >> x;
if (p > 0) x = -x;
return x;
}
int main() {
ios_base::sync_with_stdio(0);
p = ask(0, 0);
int X = 0, Y = 0;
for (int i = 29; i >= 0; --i) {
int x = ask(X ^ (1 << i), Y ^ (1 << i));
if (x == 0) {
if (p > 0) swap(X, Y), p = 0;
for (; i >= 0; --i) {
cout << "? " << (X ^ (1 << i)) << " " << Y << "\n";
cin >> x;
if (x < 0) X ^= (1 << i), Y ^= (1 << i);
}
break;
}
if (x > 0) {
Y ^= (1 << i);
if (ask(X, Y) > 0) {
swap(X, Y);
p *= (-1);
}
continue;
}
if (ask(X ^ (1 << i), Y) < 0) X ^= (1 << i), Y ^= (1 << i);
}
if (p > 0) swap(X, Y);
cout << "! " << X << " " << Y;
}
|
#include <bits/stdc++.h>
using namespace std;
struct keycompare {
bool operator()(const pair<long long, long long>& v, const long long& k) {
return (v.first < k);
}
bool operator()(const long long& k, const pair<long long, long long>& v) {
return (k < v.first);
}
};
long long mod1 = 998244353, mod2 = 1000000007, limit = 9223372036854775807;
long double pi = 3.1415926535897932;
long long modpow(long long x, long long n, long long m) {
if (x > m) {
x %= m;
}
if (n == 0) return 1 % m;
long long u = modpow(x, n / 2, m);
u = (u * u) % m;
if (n % 2 == 1) u = (u * x) % m;
return u;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
bool isprime(long long n) {
if (n == 2) return true;
for (long long i = 2; i * i <= n; i++) {
if (n % i == 0) return false;
}
return true;
}
long long power(long long x, long long n) {
long long x_n = 1;
for (long long i = 0; i < n; i++) {
x_n *= x;
}
return x_n;
}
long long ask(long long c, long long d) {
cout << "? " << c << ' ' << d << endl;
long long ans;
cin >> ans;
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long temp = ask(0, 0);
string larger = "aa";
if (temp == -1) {
larger = "bb";
}
long long a = 0, b = 0;
for (long long i = 0; i < 30; i++) {
long long temp1 = ask((a + (power(2, 29 - i))), b);
long long temp2 = ask(a, (b + (power(2, 29 - i))));
if (temp1 == temp2) {
if (larger == "aa") {
a += power(2, 29 - i);
if (temp1 == -1) {
larger = "bb";
}
} else {
b += power(2, 29 - i);
if (temp1 == 1) {
larger = "aa";
}
}
} else {
if (temp1 == -1) {
a += power(2, 29 - i);
b += power(2, 29 - i);
}
}
}
cout << "! " << a << " " << b << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int mod = 1000000007;
const double eps = 1e-8;
const double pi = acos(-1.0);
void file() {
freopen("in.txt", "r", stdin);
freopen("out.txt", "w", stdout);
}
const int maxn = 105;
int a, b;
int op[2];
int judge(int c, int d) {
int res;
printf("? %d %d\n", c, d);
fflush(stdout);
scanf("%d", &res);
return res;
}
namespace BakuretsuMahou {
void Explosion() {
int flag = ((judge(a, b) < 0) ? 0 : 1);
for (int i = 30; i >= 1; i--) {
int x = judge(a ^ (1 << (i - 1)), b);
int y = judge(a, b ^ (1 << (i - 1)));
if (x == y) {
if (flag)
a ^= (1 << (i - 1));
else
b ^= (1 << (i - 1));
flag = (x == 1);
} else if (x == -1 && y == 1)
a ^= (1 << (i - 1)), b ^= (1 << (i - 1));
}
printf("! %d %d\n", a, b);
fflush(stdout);
}
} // namespace BakuretsuMahou
int main() {
BakuretsuMahou::Explosion();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e4 + 10;
const int maxm = 1e5 + 10;
const int mod = 1e9 + 7;
int a[maxn], a1 = 7, b1 = 7;
int ask(int x, int y) {
cout << '?' << ' ' << x << ' ' << y << endl;
fflush(stdout);
int ans;
cin >> ans;
return ans;
}
int main() {
int tmp, a = 0, b = 0, big;
tmp = ask(0, 0);
big = tmp;
for (int i = 1 << 29; i; i >>= 1) {
tmp = ask(a | i, b | i);
if (tmp == 0) {
if (big == 0) {
tmp = ask(a | i, b);
if (tmp == 1) {
continue;
} else {
a |= i;
b |= i;
}
continue;
}
a |= i;
b |= i;
continue;
}
if (tmp != big) {
if (big > 0) {
a |= i;
} else {
b |= i;
}
big = ask(a, b);
continue;
}
tmp = ask(a | i, b);
if (big > 0) {
if (tmp != big) {
b |= i;
a |= i;
} else {
continue;
}
} else {
if (tmp != big) {
continue;
} else {
b |= i;
a |= i;
}
}
}
cout << '!' << ' ' << a << ' ' << b << endl;
fflush(stdout);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int k = 29, x1, x2, x3, t;
int ans1, ans2;
int main() {
bool ok = false;
while (k >= 0) {
if (!ok) {
printf("? %d %d\n", 0 + ans1, 0 + ans2);
fflush(stdout);
scanf("%d", &x1);
ok = 1;
}
printf("? %d %d\n", (1 << k) + ans1, (1 << k) + ans2);
fflush(stdout);
scanf("%d", &x2);
if (x1 == x2) {
if (x1 == 1) {
printf("? %d %d\n", 0 + ans1, (1 << k) + ans2);
fflush(stdout);
scanf("%d", &x3);
} else {
printf("? %d %d\n", ans1 + (1 << k), ans2 + 0);
fflush(stdout);
scanf("%d", &x3);
}
if (x1 == 0) {
if (x3 == 1)
;
else
ans1 |= (1 << k), ans2 |= (1 << k);
t = x1;
} else {
if (x3 != x2)
;
else
ans1 |= (1 << k), ans2 |= (1 << k);
t = x1;
}
} else {
if (x1 == -1 && x2 == 1) {
printf("? %d %d\n", 0 + ans1, (1 << k) + ans2);
ans2 |= (1 << k);
fflush(stdout);
scanf("%d", &x3);
t = x3;
} else {
printf("? %d %d\n", (1 << k) + ans1, 0 + ans2);
ans1 |= (1 << k);
fflush(stdout);
scanf("%d", &x3);
t = x3;
}
}
k--;
x1 = t;
}
printf("! %d %d\n", ans1, ans2);
fflush(stdout);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int kMaxBits = 30;
enum class Result { Less, Equal, Greater };
struct Answer {
Answer() = default;
Answer(int a, int b) : m_a(a), m_b(b) {}
int m_a = 0;
int m_b = 0;
};
Result Ask(int c, int d) {
cout << "? " << c << " " << d << endl;
int result;
cin >> result;
if (result == -2) {
cerr << "Number of guesses exceeded" << endl;
exit(0);
}
if (result == -1) return Result::Less;
if (result == 0) return Result::Equal;
if (result == 1) return Result::Greater;
cerr << "Unknown result: " << result << endl;
exit(0);
}
Answer SolveEqual() {
int answer = 0;
for (int bit = 0; bit < kMaxBits; ++bit) {
const auto result = Ask(1 << bit, 0);
switch (result) {
case Result::Less:
answer = answer | (1 << bit);
break;
case Result::Equal:
cerr << "Impossible" << endl;
exit(0);
break;
case Result::Greater:
break;
}
}
return {answer, answer};
}
Answer Solve(Result curr) {
int amask = 0;
int bmask = 0;
for (int bit = kMaxBits - 1; bit >= 0; --bit) {
switch (curr) {
case Result::Less: {
const auto r10 = Ask(amask | (1 << bit), bmask);
const auto r11 = Ask(amask | (1 << bit), bmask | (1 << bit));
switch (r11) {
case Result::Less:
switch (r10) {
case Result::Less:
amask = amask | (1 << bit);
bmask = bmask | (1 << bit);
break;
case Result::Equal:
assert(false);
break;
case Result::Greater:
break;
}
break;
case Result::Equal:
assert(false);
break;
case Result::Greater:
bmask = bmask | (1 << bit);
curr = r10;
break;
}
break;
}
case Result::Equal: {
switch (Ask(amask | (1 << bit), bmask)) {
case Result::Less:
amask = amask | (1 << bit);
bmask = bmask | (1 << bit);
break;
case Result::Equal:
assert(false);
break;
case Result::Greater:
break;
}
curr = Result::Equal;
break;
}
case Result::Greater: {
const auto r10 = Ask(amask | (1 << bit), bmask);
const auto r11 = Ask(amask | (1 << bit), bmask | (1 << bit));
switch (r11) {
case Result::Less:
amask = amask | (1 << bit);
curr = r10;
break;
case Result::Equal:
assert(false);
break;
case Result::Greater:
switch (r10) {
case Result::Greater:
break;
case Result::Equal:
assert(false);
break;
case Result::Less:
amask = amask | (1 << bit);
bmask = bmask | (1 << bit);
break;
}
}
break;
}
}
}
return {amask, bmask};
}
int main() {
ios_base::sync_with_stdio(false);
const auto answer = Solve(Ask(0, 0));
cout << "! " << answer.m_a << " " << answer.m_b << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void read(int &x) {
int v = 0, f = 1;
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-')
f = -1;
else
v = v * 10 + c - '0';
while (isdigit(c = getchar())) v = v * 10 + c - '0';
x = v * f;
}
void read(long long &x) {
long long v = 0ll, f = 1ll;
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-')
f = -1;
else
v = v * 10 + c - '0';
while (isdigit(c = getchar())) v = v * 10 + c - '0';
x = v * f;
}
void readc(char &x) {
char c;
while ((c = getchar()) == ' ')
;
x = c;
}
void writes(string s) { puts(s.c_str()); }
void writeln() { writes(""); }
void writei(int x) {
if (x < 0) {
putchar('-');
x = abs(x);
}
if (!x) putchar('0');
char a[25];
int top = 0;
while (x) {
a[++top] = (x % 10) + '0';
x /= 10;
}
while (top) {
putchar(a[top]);
top--;
}
}
void writell(long long x) {
if (x < 0) {
putchar('-');
x = abs(x);
}
if (!x) putchar('0');
char a[25];
int top = 0;
while (x) {
a[++top] = (x % 10) + '0';
x /= 10;
}
while (top) {
putchar(a[top]);
top--;
}
}
inline long long inc(int &x) { return ++x; }
inline long long inc(long long &x) { return ++x; }
inline long long inc(int &x, long long y) { return x += y; }
inline long long inc(long long &x, long long y) { return x += y; }
inline double inc(double &x, double y) { return x += y; }
inline long long dec(int &x) { return --x; }
inline long long dec(long long &x) { return --x; }
inline long long dec(int &x, long long y) { return x -= y; }
inline long long dec(long long &x, long long y) { return x -= y; }
inline double dec(double &x, double y) { return x -= y; }
inline long long mul(int &x) { return x = ((long long)x) * x; }
inline long long mul(long long &x) { return x = x * x; }
inline long long mul(int &x, long long y) { return x *= y; }
inline long long mul(long long &x, long long y) { return x *= y; }
inline double mul(double &x, double y) { return x *= y; }
inline long long divi(const int &x) {
long long ans, l, r, mid;
ans = 0;
l = 0;
r = 0x3fffffff;
while (l < r) {
mid = (l + r) / 2;
if (mid * mid <= x) {
ans = mid;
l = mid + 1;
} else
r = mid;
}
return ans;
}
inline long long divi(const long long &x) {
long long ans, l, r, mid;
ans = 0;
l = 0;
r = 0x3fffffff;
while (l < r) {
mid = (l + r) / 2;
if (mid * mid <= x) {
ans = mid;
l = mid + 1;
} else
r = mid;
}
return ans;
}
inline long long divi(int &x, long long y) { return x /= y; }
inline long long divi(long long &x, long long y) { return x /= y; }
inline double divi(double &x, double y) { return x /= y; }
inline long long mod(int &x, long long y) { return x %= y; }
inline long long mod(long long &x, long long y) { return x %= y; }
int n, m, s1, s2, t, i, j, s, suf[35];
int query(int x, int y) {
printf("? %d %d\n", x, y);
fflush(stdout);
int s;
scanf("%d", &s);
return s;
}
void solve(int x) {
while (x >= 0) {
if (query(s1 ^ (1 << x), s2) == -1) {
s1 |= (1 << x);
s2 |= (1 << x);
}
x--;
}
printf("! %d %d\n", s1, s2);
exit(0);
}
int main() {
s = query(0, 0);
if (s == 1) t = 1;
if (s == -1) t = 2;
if (s == 0) solve(29);
suf[0] = 1;
if ((1) <= ((29)))
for (((i)) = (1); ((i)) <= ((29)); ((i))++)
suf[i] = (suf[i - 1] | (1 << i));
if ((29) >= (0))
for ((i) = (29); (i) >= (0); (i)--) {
if (t == 1) {
int t1 = query((s1 ^ (1 << i)), s2);
if (t1 == 0) {
s1 |= (1 << i);
solve(i - 1);
}
int t2 = query((s1 ^ suf[i]), (s2 ^ (1 << i) ^ suf[i]));
t1 += t2;
if (t1 == 0) {
s1 |= (1 << i);
if (t1 - t2 == -1) {
t = 2;
}
}
if (t1 == -2) {
s1 |= (1 << i);
s2 |= (1 << i);
}
} else {
int t2 = query(s1, (s2 ^ (1 << i)));
if (t2 == 0) {
s2 |= (1 << i);
solve(i - 1);
}
int t1 = query((s1 ^ (1 << i) ^ suf[i]), (s2 ^ suf[i]));
t2 *= -1;
t1 *= -1;
t2 += t1;
if (t2 == 0) {
s2 |= (1 << i);
if (t2 - t1 == -1) {
t = 1;
}
}
if (t2 == -2) {
s2 |= (1 << i);
s1 |= (1 << i);
}
}
}
printf("! %d %d\n", s1, s2);
fflush(stdout);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, i, check, f, check1, check2, s, p, j, h;
long long checki = 1073741823;
int d[35];
int pow(int j) {
p = 1;
for (s = 1; s <= j - 1; s++) {
p *= 2;
}
return p;
}
int main() {
cout << "? 0 0\n" << flush;
cin >> f;
h = f;
for (i = 1; i <= 31; i++) {
d[i] = pow(i);
}
for (i = 30; i >= 2; i--) {
if (h == -1) {
check2 += d[i];
printf("? %d %d\n", check1, check2);
fflush(stdout);
cin >> f;
if (f == -1) {
check1 += d[i] - 1;
check2 += d[i] - 1;
printf("? %d %d\n", check1, check2);
fflush(stdout);
cin >> f;
if (f == -1) {
check2 -= 2 * d[i] - 1;
check1 -= d[i] - 1;
h = -1;
} else if (f == 1) {
h = -1;
check2 -= d[i] - 1;
check1 -= d[i] - 1;
} else {
check2 -= d[i] - 1;
check1 -= d[i] - 1;
h = 0;
}
} else if (f == 1) {
check1 += d[i];
printf("? %d %d\n", check1, check2);
fflush(stdout);
cin >> f;
if (f == 1) {
check1 -= d[i];
h = 1;
}
} else if (f == 0) {
h = 0;
}
} else if (h == 1) {
check1 += d[i];
printf("? %d %d\n", check1, check2);
fflush(stdout);
cin >> f;
if (f == 1) {
check1 += d[i] - 1;
check2 += d[i] - 1;
printf("? %d %d\n", check1, check2);
fflush(stdout);
cin >> f;
if (f == 1) {
check1 -= 2 * d[i] - 1;
check2 -= d[i] - 1;
h = 1;
} else if (f == -1) {
h = 1;
check1 -= d[i] - 1;
check2 -= d[i] - 1;
} else {
check1 -= d[i] - 1;
check2 -= d[i] - 1;
h = 0;
}
} else if (f == -1) {
check2 += d[i];
printf("? %d %d\n", check1, check2);
fflush(stdout);
cin >> f;
if (f == -1) {
check2 -= d[i];
h = -1;
}
} else if (f == 0) {
h = 0;
}
} else if (h == 0) {
check1 += d[i];
printf("? %d %d\n", check1, check2);
fflush(stdout);
cin >> f;
if (f == 1) {
check1 -= d[i];
} else if (f == -1) {
check2 += d[i];
}
}
}
if (h == 0) {
check1 += 1;
printf("? %d %d\n", check1, check2);
fflush(stdout);
cin >> f;
if (f == 1) {
check1 -= 1;
} else {
check2 += 1;
}
} else if (h == 1) {
check1 += 1;
} else {
check2 += 1;
}
printf("! %d %d\n", check1, check2);
fflush(stdout);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
bool f[3];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int a = 0, b = 0, ret, ret1, ret2;
cout << "? 0 0" << endl;
cin >> ret;
f[1 - ret] = 1;
for (int i = 29; i >= 0; i--) {
int tmp1 = (1 << i), tmp2 = (0 << i);
if (ret == 1) {
cout << "? " << (a ^ tmp1) << " " << (b ^ tmp2) << endl;
cin >> ret1;
cout << "? " << (a ^ tmp2) << " " << (b ^ tmp1) << endl;
cin >> ret2;
if (ret1 == 0) {
ret = 0;
a ^= tmp1;
b ^= tmp2;
} else if (ret1 == -1) {
if (ret2 == 1) {
a ^= tmp1;
b ^= tmp1;
} else if (ret2 == -1) {
ret = -1;
a ^= tmp1;
b ^= tmp2;
}
} else if (ret1 == 1) {
if (ret2 == 1) {
a ^= tmp1;
b ^= tmp2;
ret = 1;
} else if (ret2 == -1) {
a ^= tmp2;
b ^= tmp2;
}
}
} else if (ret == 0) {
cout << "? " << (a ^ tmp1) << " " << (b ^ tmp2) << endl;
cin >> ret1;
if (ret1 == 1) {
a ^= tmp2;
b ^= tmp2;
} else if (ret1 == -1) {
a ^= tmp1;
b ^= tmp1;
}
} else if (ret == -1) {
cout << "? " << (a ^ tmp1) << " " << (b ^ tmp2) << endl;
cin >> ret1;
cout << "? " << (a ^ tmp2) << " " << (b ^ tmp1) << endl;
cin >> ret2;
if (ret1 == 0) {
ret = 0;
a ^= tmp2;
b ^= tmp1;
} else if (ret1 == -1) {
if (ret2 == 1) {
a ^= tmp1;
b ^= tmp1;
} else if (ret2 == -1) {
ret = -1;
a ^= tmp2;
b ^= tmp1;
}
} else if (ret1 == 1) {
if (ret2 == 1) {
a ^= tmp2;
b ^= tmp1;
ret = 1;
} else if (ret2 == -1) {
a ^= tmp2;
b ^= tmp2;
}
}
}
}
cout << "! " << a << " " << b << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long i, j, n, m, k, cnt = 0, ans = 0, t = 1;
long long l = 0, r = 0, a = 0, b = 0;
cout << "? " << 0 << " " << 0 << endl;
cin >> k;
for (i = 29; i >= 0; i--) {
long long c = ((1 << i) + l), d = r, a1, a2;
cout << "? " << c << " " << d << endl;
cin >> a1;
c = l, d = ((1 << i) + r);
cout << "? " << c << " " << d << endl;
cin >> a2;
if (a1 == a2) {
if (k == 1)
a += (1 << i), l += (1 << i);
else
b += (1 << i), r += (1 << i);
if (a1 == 1)
k = 1;
else
k = -1;
} else {
if (a1 == -1 && a2 == 1)
a += (1 << i), b += (1 << i), l += (1 << i), r += (1 << i);
}
}
cout << "! " << a << " " << b << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a = 0, b = 0;
int play(int id, int nw, int &cur) {
int x, y;
cout << "? " << cur + (1 << id) << ' ' << (1 << id) << endl;
cin >> x;
cout << "? " << cur + (1 << id) << ' ' << 0 << endl;
cin >> y;
if (x == nw &&
(nw == -1 && y == nw || nw == 1 && y != nw || nw == 0 && y == -1) ||
x != nw && nw == 1)
a += (1 << id);
if (x != nw && nw == -1 ||
x == nw &&
(nw == -1 && y == nw || nw == 1 && y != nw || nw == 0 && y == -1))
b += (1 << id);
if (x != nw) cur += (1 << id);
if (x == nw) return x;
return y;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
cout << "? " << 0 << ' ' << 0 << endl;
int nw, cur = 0;
cin >> nw;
for (int i = 29; i >= 0; i--) nw = play(i, nw, cur);
cout << "! " << a << ' ' << b << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
int a = 0, b = 0;
int ask(int x, int y) {
cout << "? " << (a | x) << " " << (b | y) << endl;
int t;
cin >> t;
return t;
}
signed main() {
ios::sync_with_stdio(false);
cout.precision(17);
int s = ask(0, 0);
for (int i = 29; i >= 0; i--) {
int t = ask(1 << i, 1 << i);
if (t == s) {
if (s >= 0) {
t = ask(1 << i, 0);
if (t < 0) {
a ^= (1 << i);
b ^= (1 << i);
}
} else {
t = ask(0, 1 << i);
if (t > 0) {
a ^= (1 << i);
b ^= (1 << i);
}
}
} else {
if (s > 0)
a ^= (1 << i);
else
b ^= (1 << i);
s = ask(0, 0);
}
}
cout << "! " << a << " " << b << endl;
;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using namespace std;
int a = 0;
int b = 0;
int n;
bool shouldSwap = false;
int A = 83886724;
int B = 83886724;
int ask(int x, int y) {
if (shouldSwap) swap(x, y);
cout << "? " << x << " " << y << endl;
int ans = 0;
int q = A ^ x;
int v = B ^ y;
if (q < v) ans = -1;
if (q > v) ans = 1;
cin >> ans;
if (shouldSwap) ans = -ans;
return ans;
}
void runEq() {
for (int i = n + 1 - 1; i >= 0; --i) {
int a1 = a | (1 << i);
int bit = 1;
if (ask(a1, b) == 1) {
bit = 0;
}
a |= (bit << i);
b |= (bit << i);
}
}
void runSimple() {
while (n >= 0) {
int a1 = a | (1 << n);
int b1 = b | (1 << n);
int ans = ask(a1, b1);
if (ans == 1) {
b |= (1 << n);
int alb = ask(a, b);
if (alb == 0) {
--n;
runEq();
return;
} else if (alb == 1) {
swap(a, b);
shouldSwap = !shouldSwap;
}
} else {
a1 = a | (1 << n);
b1 = b;
int ans = ask(a1, b1);
int bit = 1;
if (ans == 1) {
bit = 0;
}
a |= (bit << n);
b |= (bit << n);
}
--n;
}
}
int main() {
ios_base::sync_with_stdio(false);
n = 29;
int alb = ask(0, 0);
if (alb == 0) {
runEq();
cout << "! " << a << " " << b << endl;
return 0;
}
if (alb == 1) {
shouldSwap = true;
}
runSimple();
if (shouldSwap) swap(a, b);
cout << "! " << a << " " << b << endl;
return 0;
}
|
#include <bits/stdc++.h>
int cnt, ca, cb;
int ask(int a, int b) {
printf("? %d %d\n", a, b);
fflush(stdout);
int tem;
scanf("%d", &tem);
return tem;
}
int main() {
cnt = ask(0, 0);
for (int i = 29; i >= 0; i--) {
if (cnt == 0) {
if (ask(ca | (1 << i), cb) == -1) {
ca |= (1 << i), cb |= (1 << i);
}
continue;
}
int t1 = ask(ca | (1 << i), cb | (1 << i));
if (t1 != cnt) {
if (cnt == 1)
ca |= (1 << i);
else
cb |= (1 << i);
cnt = ask(ca, cb);
continue;
} else {
if (ask(ca | (1 << i), cb) == -1) {
ca |= (1 << i), cb |= (1 << i);
}
}
}
printf("! %d %d\n", ca, cb);
fflush(stdout);
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int prev_flag = 99;
long long int kc = 0, kd = 0;
long long int c, d;
long long int i1, i2;
for (int i = 29; i >= 0; i--) {
if (prev_flag == 99) {
c = kc;
d = kd;
printf("? %lld %lld\n", c, d);
fflush(stdout);
scanf("%lld", &i1);
} else
i1 = prev_flag;
c = (long long int)pow(2, i) + kc;
d = (long long int)pow(2, i) + kd;
printf("? %lld %lld\n", c, d);
fflush(stdout);
scanf("%lld", &i2);
if (i1 == -1 && i2 == 1) {
kc = kc;
kd += ((long long int)pow(2, i));
prev_flag = 99;
} else if (i1 == 1 && i2 == -1) {
kc += ((long long int)pow(2, i));
kd = kd;
prev_flag = 99;
} else if (i1 == i2) {
prev_flag = i1;
long long int i3;
c = kc;
d = ((long long int)pow(2, i)) + kd;
printf("? %lld %lld\n", c, d);
fflush(stdout);
scanf("%lld", &i3);
if (i3 == -1) {
kc = kc;
kd = kd;
} else if (i3 == 1) {
kc = ((long long int)pow(2, i)) + kc;
kd = ((long long int)pow(2, i)) + kd;
}
}
}
printf("! %lld %lld\n", kc, kd);
fflush(stdout);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 30;
long long a, b, res1, res2, last, tmp;
int32_t main() {
cout << "?"
<< " " << 0 << " " << 0 << endl;
cin >> last;
for (long long i = N - 1; i >= 0; i--) {
long long ans1, pw = (1LL << i);
cout << "?"
<< " " << res1 + pw << " " << res2 + pw << endl;
cin >> tmp;
ans1 = tmp;
if (!tmp) {
cout << "?"
<< " " << res1 + pw << " " << res2 << endl;
cin >> tmp;
if (tmp == -1) {
res1 += pw;
res2 += pw;
}
last = 0;
} else if (tmp == last) {
cout << "?"
<< " " << res1 + pw << " " << res2 << endl;
cin >> tmp;
if (tmp == 1)
;
else if (tmp == 0)
return -1;
else {
res1 += pw;
res2 += pw;
}
last = ans1;
} else {
tmp = last;
if (tmp == 1) {
res1 += pw;
} else if (!tmp) {
return -1;
} else {
res2 += pw;
}
cout << "?"
<< " " << res1 << " " << res2 << endl;
cin >> last;
}
}
cout << '!' << " " << res1 << " " << res2 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int question(int c, int d) {
cout << "? " << c << " " << d << endl;
int ret;
cin >> ret;
return ret;
}
int main() {
int c = 0, d = 0;
int stat = question(c, d);
for (int k = 29; k >= 0; --k) {
int ret = question(c + (1 << k), d + (1 << k));
if (ret == stat) {
int ret = question(c, d + (1 << k));
if (ret == 1) {
c += (1 << k);
d += (1 << k);
}
} else {
if (stat == 1) {
c += (1 << k);
} else {
d += (1 << k);
}
stat = question(c, d);
}
}
cout << "! " << c << " " << d << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1100000;
int mod = 998244353;
int ask(int a, int b) {
printf("? %d %d\n", a, b);
fflush(stdout);
int t;
scanf("%d", &t);
return t;
}
void sol() {
int ax = 0, bx = 0;
int flag = -2;
for (int i = 29; i >= 0; --i) {
int a1 = ax | (1 << i);
int b1 = bx | (1 << i);
int ret = ask(a1, bx);
if (ret == 1) {
int ret = ask(ax, b1);
if (ret == -1) {
continue;
}
if (flag == -2) {
flag = ask(ax, bx);
}
if (flag == 1) {
ax = a1;
flag = 1;
} else if (flag == -1) {
bx = b1;
flag = 1;
}
} else if (ret == -1) {
int ret = ask(ax, b1);
if (ret == 1) {
ax = a1;
bx = b1;
continue;
} else {
if (flag == -2) {
flag = ask(ax, bx);
}
if (flag == 1) {
ax = a1;
flag = -1;
} else if (flag == -1) {
bx = b1;
flag = -1;
}
}
} else if (ret == 0) {
if (flag == -2) {
flag = ask(ax, bx);
}
if (flag == -1) {
bx = b1;
flag = 0;
} else if (flag == 1) {
ax = a1;
flag = 0;
} else if (flag == 0) {
}
}
}
printf("! %d %d\n", ax, bx);
fflush(stdout);
}
int main() { sol(); }
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int stat, num, a = 0, b = 0, c, d;
cout << "? 0 0\n";
cin >> stat;
fflush(stdout);
for (long long int i = 29; i >= 0; i--) {
num = 1 << i;
cout << "? " << (a ^ num) << " " << b << endl;
cin >> c;
fflush(stdout);
cout << "? " << a << " " << (b ^ num) << endl;
cin >> d;
fflush(stdout);
if (c == d) {
if (stat == 1)
a += num;
else
b += num;
stat = c;
} else {
if (d == 1) {
a += num;
b += num;
}
}
}
cout << "! " << a << " " << b << endl;
fflush(stdout);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int ask(int c, int d) {
printf("? %d %d\n", c, d);
fflush(stdout);
int res;
scanf("%d", &res);
return res;
}
int main() {
int cur = ask(0, 0);
int a = 0, b = 0;
for (int i = 29; i >= 0; --i) {
int res1 = ask(a, b | 1 << i);
int res2 = ask(a | 1 << i, b);
if (res1 != res2) {
if (res1 > 0) {
a |= 1 << i;
b |= 1 << i;
}
} else {
if (cur > 0) {
a |= 1 << i;
} else {
b |= 1 << i;
}
cur = res1;
}
}
printf("! %d %d\n", a, b), fflush(stdout);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int ques(int a, int b) {
printf("? %d %d\n", a, b);
fflush(stdout);
int rep = 0;
scanf("%d", &rep);
assert(rep != -2);
return rep;
}
int main() {
int c = 0, d = 0;
int a = 0, b = 0;
int i = 29;
while (i >= 0) {
printf("? %d %d\n", a, b);
fflush(stdout);
int rep1 = 0;
scanf("%d", &rep1);
assert(rep1 != -2);
if (rep1 == 1) {
bool flag = false;
for (; i >= 0; i--) {
if (flag == false) {
c = ((1 << i) | a);
d = ((1 << i) | b);
printf("? %d %d\n", c, d);
fflush(stdout);
int rep = 0;
scanf("%d", &rep);
assert(rep != -2);
if (rep == rep1) {
c = ((1 << i) | a);
d = (0 | b);
int rep2 = ques(c, d);
if (rep2 == -1) {
b |= (1 << i);
a |= (1 << i);
}
} else {
flag = true;
a |= (1 << i);
i--;
break;
}
}
}
} else if (rep1 == -1) {
bool flag = false;
for (; i >= 0; i--) {
if (flag == false) {
c = ((1 << i) | a);
d = ((1 << i) | b);
printf("? %d %d\n", c, d);
fflush(stdout);
int rep = 0;
scanf("%d", &rep);
assert(rep != -2);
if (rep == rep1) {
c = ((1 << i) | a);
d = (0 | b);
int rep2 = ques(c, d);
if (rep2 == -1) {
b |= (1 << i);
a |= (1 << i);
}
} else {
flag = true;
b |= (1 << i);
i--;
break;
}
}
}
} else if (rep1 == 0) {
for (; i >= 0; i--) {
c = (0 | a);
d = ((1 << i) | b);
int rep2 = ques(c, d);
if (rep2 == 1) {
a |= (1 << i);
b |= (1 << i);
}
}
}
}
printf("! %d %d\n", a, b);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, T, k, d;
const long long big = 1000000007;
int ask(long long x, long long y) {
cout << "? " << x << " " << y << "\n";
fflush(stdout);
int res;
cin >> res;
return res;
}
int main() {
int a, b, c, e;
int prev = ask(0, 0);
a = 0;
b = 0;
long long x = 0;
long long y = 0;
for (int c1 = 29; c1 >= 0; c1--) {
if (prev == 0) {
e = ask(a + (1 << c1), b);
if (e == -1) {
x += (1 << c1);
y += (1 << c1);
a += (1 << c1);
b += (1 << c1);
}
} else {
if (prev == 1) {
e = ask(a + (1 << c1), b + (1 << c1));
if (e != prev) {
x += (1 << c1);
a += (1 << c1);
prev = ask(a, b);
} else {
e = ask(a + (1 << c1), b);
if (e != prev) {
x += (1 << c1);
y += (1 << c1);
a += (1 << c1);
b += (1 << c1);
}
}
} else {
e = ask(a + (1 << c1), b + (1 << c1));
if (e != prev) {
y += (1 << c1);
b += (1 << c1);
prev = ask(a, b);
} else {
e = ask(a, b + (1 << c1));
if (e != prev) {
x += (1 << c1);
y += (1 << c1);
a += (1 << c1);
b += (1 << c1);
}
}
}
}
}
cout << "! " << x << " " << y << "\n";
fflush(stdout);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int ma = 0, mb = 0;
int N;
void solveLt();
void solveGt();
void solveEq();
int ask(int c, int d) {
int askc = (c << N) | (ma << (N + 1));
int askd = (d << N) | (mb << (N + 1));
cout << "? " << askc << " " << askd << endl;
int res;
cin >> res;
return res;
}
void addM(int a, int b) {
ma <<= 1;
mb <<= 1;
ma |= a;
mb |= b;
}
void solveGt() {
if (N == 0) return;
N--;
int res1 = ask(1, 0);
if (res1 == 1) {
int res2 = ask(0, 1);
if (res2 == 1) {
addM(1, 0);
solveGt();
} else {
addM(0, 0);
solveGt();
}
} else if (res1 == 0) {
addM(1, 0);
solveEq();
} else {
int res2 = ask(0, 1);
if (res2 == 1) {
addM(1, 1);
solveGt();
} else {
addM(1, 0);
solveLt();
}
}
}
void solveLt() {
if (N == 0) return;
N--;
int res1 = ask(0, 1);
if (res1 == 1) {
int res2 = ask(1, 0);
if (res2 == 1) {
addM(0, 1);
solveGt();
} else {
addM(1, 1);
solveLt();
}
} else if (res1 == 0) {
addM(0, 1);
solveEq();
} else {
int res2 = ask(1, 0);
if (res2 == 1) {
addM(0, 0);
solveLt();
} else {
addM(0, 1);
solveLt();
}
}
}
void solveEq() {
if (N == 0) return;
N--;
if (ask(1, 0) == 1) {
addM(0, 0);
} else {
addM(1, 1);
}
solveEq();
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
N = 30;
int res = ask(0, 0);
if (res == 1) {
solveGt();
} else if (res == 0) {
solveEq();
} else {
solveLt();
}
cout << "! " << ma << " " << mb << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int a = 0, b = 0, f, x1, x2;
cout << "? " << a << " " << b << endl;
cin >> f;
for (int i = 29; i >= 0; i--) {
cout << "? " << ((1 << i) | a) << " " << b << endl;
cin >> x1;
cout << "? " << a << " " << ((1 << i) | b) << endl;
cin >> x2;
if (x1 != x2) {
if (x1 == -1) {
a += 1 << i;
b += 1 << i;
}
} else {
if (f == 1)
a += 1 << i;
else if (f == -1)
b += 1 << i;
f = x1;
}
}
cout << "! " << a << " " << b << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 310000;
void ff() { fflush(stdout); }
int n;
int num[MAXN][2];
int com[MAXN];
int flag = 0;
int nowa = 0, nowb = 0;
void getans(int i) {
if (i == -1) {
return;
}
int f1, f2;
printf("? %d %d\n", nowa, nowb + (1 << i));
ff();
scanf("%d", &f1);
printf("? %d %d\n", nowa + (1 << i) - 1, nowb + (1 << i) - 1);
ff();
scanf("%d", &f2);
if (flag == 0) {
if (f1 == 1)
nowa += (1 << i), nowb += (1 << i);
else if (f1 == -1)
nowa += 0, nowb += 0;
} else if (flag == -1) {
if (f1 == -1) {
if (f2 == -1) {
nowa += 0, nowb += (1 << i);
flag = -1;
} else if (f2 == 1) {
nowa += 0, nowb += 0;
flag = -1;
} else {
}
} else if (f1 == 1) {
if (f2 == -1) {
nowa += 0, nowb += (1 << i);
flag = 1;
} else if (f2 == 1) {
nowa += (1 << i), nowb += (1 << i);
flag = -1;
} else {
}
} else {
nowa += 0, nowb += (1 << i);
flag = 0;
}
} else if (flag == 1) {
if (f1 == -1) {
if (f2 == -1) {
nowa += 0, nowb += 0;
flag = 1;
} else if (f2 == 1) {
nowa += (1 << i), nowb += 0;
flag = -1;
} else {
}
} else if (f1 == 1) {
if (f2 == -1) {
nowa += (1 << i), nowb += (1 << i);
flag = 1;
} else if (f2 == 1) {
nowa += (1 << i), nowb += 0;
flag = 1;
} else {
}
} else {
nowa += (1 << i), nowb += 0;
flag = 0;
}
}
getans(i - 1);
}
int main() {
printf("? 0 0\n");
ff();
scanf("%d", &flag);
getans(29);
printf("! %d %d\n", nowa, nowb);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
using namespace std;
const long long INF = 1e7;
signed main() {
cin.tie(0), ios_base::sync_with_stdio(false);
;
long long fl = 0;
cout << "? " << 0 << " " << 0 << endl;
long long x;
cin >> x;
if (x == -1) {
fl = 1;
}
long long a = 0, b = 0;
long long c = 0, d = 0;
for (long long i = 29; i >= 0; i--) {
cout << "? " << c + (1 << i) << " " << d + (1 << i) << endl;
long long x;
cin >> x;
if (x == -1 && fl == 0) {
a += (1 << i);
cout << "? " << c + (1 << i) << " " << d << endl;
cin >> x;
if (x == -1) {
fl = 1;
}
c += (1 << i);
} else if (x == 1 && fl == 1) {
b += (1 << i);
cout << "? " << c << " " << d + (1 << i) << endl;
cin >> x;
if (x == 1) {
fl = 0;
}
d += (1 << i);
} else {
cout << "? " << c + (1 << i) << " " << d << endl;
cin >> x;
if (x == -1) {
a += (1 << i);
b += (1 << i);
}
}
}
cout << "! " << a << " " << b << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
constexpr int BITS = 30;
int ask(int c, int d) {
cout << "? " << c << " " << d << endl;
int resp;
cin >> resp;
return resp;
}
void do_eq(int *abit, int *bbit, int pa, int pb) {
for (int i = 0; i < BITS; i++) {
if (abit[i] < 0) {
if (ask(pa | (1 << i), pb) == -1) {
abit[i] = 1;
bbit[i] = 1;
} else {
abit[i] = 0;
bbit[i] = 0;
}
}
}
}
void do_continue(int *abit, int *bbit, int pa, int pb, int n);
void do_lt(int *abit, int *bbit, int pa, int pb, int n) {
for (int i = n; i >= 0; i--) {
if (ask(pa | (1 << i), pb | (1 << i)) == 1) {
abit[i] = 0;
bbit[i] = 1;
pb |= 1 << i;
return do_continue(abit, bbit, pa, pb, i - 1);
}
}
return do_eq(abit, bbit, pa, pb);
}
void do_gt(int *abit, int *bbit, int pa, int pb, int n) {
for (int i = n; i >= 0; i--) {
if (ask(pa | (1 << i), pb | (1 << i)) == -1) {
abit[i] = 1;
bbit[i] = 0;
pa |= 1 << i;
return do_continue(abit, bbit, pa, pb, i - 1);
}
}
return do_eq(abit, bbit, pa, pb);
}
int val(int *b) {
int res = 0;
for (int i = 0, p2 = 1; i < BITS; i++, p2 *= 2) res += p2 * b[i];
return res;
}
void do_continue(int *abit, int *bbit, int pa, int pb, int n) {
if (n >= 0) {
switch (ask(pa, pb)) {
case -1:
return do_lt(abit, bbit, pa, pb, n);
case 1:
return do_gt(abit, bbit, pa, pb, n);
default:
return do_eq(abit, bbit, pa, pb);
}
}
return do_eq(abit, bbit, pa, pb);
}
int main(int argc, char **argv) {
int abit[BITS], bbit[BITS];
fill(abit, abit + BITS, -1);
fill(bbit, bbit + BITS, -1);
do_continue(abit, bbit, 0, 0, BITS - 1);
cout << "! " << val(abit) << " " << val(bbit) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int ask(int a, int b) {
cout << "? " << a << " " << b << endl;
fflush(stdout);
int res;
cin >> res;
return res;
}
void answer(int a, int b) {
cout << "! " << a << " " << b << endl;
fflush(stdout);
exit(0);
}
void solveEqual(int ans1, int ans2, int bit) {
for (int i = bit; i >= 0; --i) {
if (ask(ans1 | (1 << i), ans2) == -1) ans1 |= 1 << i, ans2 |= 1 << i;
}
answer(ans1, ans2);
}
void solve(int ma, int mb, int bit, int flag) {
if (bit == -1) {
answer(ma, mb);
}
if (flag > 0) {
int res = ask(ma | (1 << bit), mb);
if (res == 1) {
int res2 = ask(ma | (1 << bit), mb | (1 << bit));
if (res2 == 1) {
solve(ma, mb, bit - 1, flag);
} else {
solve(ma | (1 << bit), mb, bit - 1, flag);
}
} else if (res == 0) {
solveEqual(ma | (1 << bit), mb, bit - 1);
} else {
int res2 = ask(ma | (1 << bit), mb | (1 << bit));
if (res2 == 1) {
solve(ma | (1 << bit), mb | (1 << bit), bit - 1, flag);
} else {
solve(ma | (1 << bit), mb, bit - 1, flag * -1);
}
}
} else {
int res = ask(ma, mb | (1 << bit));
if (res == -1) {
int res = ask(ma | (1 << bit), mb | (1 << bit));
if (res == -1) {
solve(ma, mb, bit - 1, flag);
} else {
solve(ma, mb | (1 << bit), bit - 1, flag);
}
} else if (res == 0) {
solveEqual(ma, mb | (1 << bit), bit - 1);
} else {
int res2 = ask(ma | (1 << bit), mb | (1 << bit));
if (res2 == -1) {
solve(ma | (1 << bit), mb | (1 << bit), bit - 1, flag);
} else {
solve(ma, mb | (1 << bit), bit - 1, flag * -1);
}
}
}
}
int main() {
int res = ask(0, 0);
if (res == 0) {
solveEqual(0, 0, 29);
} else {
solve(0, 0, 29, res);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int mod = 1000000007;
const double eps = 1e-8;
const double pi = acos(-1.0);
void file() {
freopen("in.txt", "r", stdin);
freopen("out.txt", "w", stdout);
}
const int maxn = 105;
int a, b;
int op[2];
int judge(int c, int d) {
int res;
printf("? %d %d\n", c, d);
fflush(stdout);
scanf("%d", &res);
return res;
}
namespace BakuretsuMahou {
void Explosion() {
int flag = ((judge(a, b) < 0) ? 0 : 1);
for (int i = 30; i >= 1; i--) {
int x = judge(a ^ (1 << (i - 1)), b);
int y = judge(a, b ^ (1 << (i - 1)));
if (x == y) {
if (flag)
a ^= (1 << (i - 1));
else
b ^= (1 << (i - 1));
flag = (x == 1);
} else if (x == -1 && y == 1)
a ^= (1 << (i - 1)), b ^= (1 << (i - 1));
}
printf("! %d %d\n", a, b);
}
} // namespace BakuretsuMahou
int main() {
BakuretsuMahou::Explosion();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a, b, n, g;
int ask(int a, int b) {
cout << "? " << a << ' ' << b << endl;
cin >> n;
return n;
}
int main() {
g = ask(0, 0);
for (int i = 29; ~i; --i) {
int c1 = ask(a ^ (1 << i), b), c2 = ask(a, b ^ (1 << i));
if (c1 == c2) {
if (g == 1)
a |= (1 << i);
else
b |= (1 << i);
g = c1;
} else if (c1 == -1) {
a |= (1 << i);
b |= (1 << i);
}
}
cout << "! " << a << ' ' << b << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[100999];
int bitA[100];
int main() {
int i, c, d, r, maskB;
maskB = 0;
for (i = 29; i >= 0; i--) {
printf("? %d %d\n", 0, maskB);
fflush(stdout);
scanf("%d", &r);
if (r == 0) break;
int r2;
do {
c = 1 << i;
d = (1 << i) | maskB;
printf("? %d %d\n", c, d);
fflush(stdout);
scanf("%d", &r2);
i--;
} while (r2 == r);
i++;
maskB = maskB | (1 << i);
if (r == 1)
bitA[i] = 1;
else
bitA[i] = -1;
}
for (i = 29; i >= 0; i--) {
if (bitA[i]) continue;
printf("? %d %d\n", 1 << i, maskB);
fflush(stdout);
scanf("%d", &r);
if (r < 0)
bitA[i] = 1;
else
bitA[i] = -1;
}
int a, b;
a = b = 0;
for (i = 29; i >= 0; i--) {
if (bitA[i] == 1) a = a | (1 << i);
}
b = a ^ maskB;
printf("! %d %d\n", a, b);
fflush(stdout);
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int flag, x;
printf("? 0 0\n");
fflush(stdout);
scanf("%d", &flag);
int tempa = 0, tempb = 0;
for (int i = 1 << 29; i; i >>= 1) {
if (flag == 0) {
printf("? %d %d\n", tempa | i, tempb);
fflush(stdout);
scanf("%d", &x);
if (x == -1) tempa |= i, tempb |= i;
} else if (flag == -1) {
printf("? %d %d\n", tempa | i, tempb | i);
fflush(stdout);
scanf("%d", &x);
if (x == 1) {
tempb |= i;
printf("? %d %d\n", tempa, tempb);
fflush(stdout);
scanf("%d", &flag);
} else {
printf("? %d %d\n", tempa | i, tempb);
fflush(stdout);
scanf("%d", &x);
if (x == -1) tempa |= i, tempb |= i;
}
} else {
printf("? %d %d\n", tempa | i, tempb | i);
fflush(stdout);
scanf("%d", &x);
if (x == -1) {
tempa |= i;
printf("? %d %d\n", tempa, tempb);
fflush(stdout);
scanf("%d", &flag);
} else {
printf("? %d %d\n", tempa, tempb | i);
fflush(stdout);
scanf("%d", &x);
if (x == 1) tempa |= i, tempb |= i;
}
}
}
printf("! %d %d\n", tempa, tempb);
fflush(stdout);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int query(int a, int b) {
cout << "? " << a << " " << b << endl;
fflush(stdout);
int x = 0;
cin >> x;
return x;
}
int main() {
int a = 0, b = 0;
bool f = 1;
if (query(a, b) < 0) f = 0;
for (int i = 29; ~i; i--) {
int x, y;
x = query(a ^ (1 << i), b);
y = query(a, b ^ (1 << i));
if (x == y) {
if (f)
a ^= (1 << i);
else
b ^= (1 << i);
f = (x == 1);
} else if (x == -1 && y == 1) {
a ^= (1 << i);
b ^= (1 << i);
}
}
cout << "! " << a << " " << b << endl;
fflush(stdout);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int a, b;
void print(long long int a, long long int b) {
cout << "! " << a << " " << b << endl;
}
long long int ask(long long int c, long long int d) {
cout << "? " << c << " " << d << endl;
long long int ret;
cin >> ret;
return ret;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long int ret = ask(0, 0);
if (ret == 0) {
long long int val = 0;
for (long long int i = 0; i <= 29; ++i) {
long long int rr = ask(0, (1LL << i));
if (rr == 1) val += (1LL << i);
}
print(val, val);
return 0;
}
long long int sa = 0, sb = 0, va = 0, vb = 0;
for (long long int i = 29; i >= 0; i--) {
long long int rr = ask(sa + (1LL << i), sb + (1LL << i));
if (rr == ret) {
if (ret == 1) {
long long int cc = ask(sa + (1LL << i), sb);
if (cc == -1) {
va += (1LL << i);
vb += (1LL << i);
}
} else {
long long int cc = ask(sa, sb + (1LL << i));
if (cc == 1) {
va += (1LL << i);
vb += (1LL << i);
}
}
continue;
}
if (ret == 1) {
va += (1LL << i);
sa += (1LL << i);
} else {
vb += (1LL << i);
sb += (1LL << i);
}
if (!i) break;
rr = ask(sa, sb);
if (rr == 0) {
long long int val = 0;
for (long long int j = 0; j <= i - 1; ++j) {
long long int rr = ask(sa, sb + (1LL << j));
if (rr == 1) val += (1LL << j);
}
va += val;
vb += val;
break;
} else
ret = rr;
}
print(va, vb);
}
|
#include <bits/stdc++.h>
int main() {
int n, n1, n2;
int i = 1 << 29;
printf("? 0 0\n");
fflush(stdout);
scanf("%d", &n);
int a = 0, b = 0;
while (i) {
printf("? %d %d\n", a + i, b);
fflush(stdout);
scanf("%d", &n1);
printf("? %d %d\n", a, b + i);
fflush(stdout);
scanf("%d", &n2);
if (n1 == -1 && n2 == 1) {
a += i;
b += i;
} else if (n1 == n2) {
if (n == 1) {
a += i;
} else {
b += i;
}
n = n1;
}
i >>= 1;
}
printf("! %d %d\n", a, b);
fflush(stdout);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void qq(long long int a, long long int b) {
cout << "? ";
cout << a << " " << b;
cout << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
long long int a = 0, b = 0;
int st;
qq(0, 0);
cin >> st;
for (int i = 29; i >= 0; i--) {
long long int x = (1ll << i);
if (st == 0) {
qq(a, b + x);
int kk;
cin >> kk;
if (kk == 1) a += x, b += x;
} else if (st == -1) {
qq(a, b + x);
int kk;
cin >> kk;
if (kk == 0) {
b += x;
st = kk;
} else if (kk == -1) {
qq(a + x, b + x);
int k1;
cin >> k1;
if (k1 == 1) b += x;
st = kk;
} else {
qq(a + x, b + x);
int k1;
cin >> k1;
st = kk;
if (k1 == 1)
b += x;
else
a += x, b += x, st = -1;
}
} else {
qq(a + x, b);
int kk;
cin >> kk;
if (kk == 0) {
a += x;
st = kk;
} else if (kk == -1) {
qq(a + x, b + x);
int k1;
cin >> k1;
if (k1 == -1) {
a += x;
st = kk;
} else {
a += x;
b += x;
st = 1;
}
} else {
qq(a + x, b + x);
int k1;
cin >> k1;
if (k1 == -1) {
a += x;
st = kk;
} else {
st = kk;
}
}
}
}
cout << "! ";
cout << a << " " << b;
cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a, b, c, d, tot, pw, t;
int ask(int x, int y) {
printf("? %d %d\n", x, y);
fflush(stdout);
int res = 0;
scanf("%d", &res);
return res;
}
int main() {
t = ask(0, 0);
for (int i = 29; i >= 0; i--) {
int fi, se;
pw = (1 << i);
fi = c + pw;
se = d + pw;
tot = ask(fi, se);
if (tot == t) {
int re = ask(c, se);
if (re == 1) {
a |= pw;
b |= pw;
c |= pw;
d |= pw;
}
} else {
if (t == -1) {
b |= pw;
c |= pw;
} else {
a |= pw;
d |= pw;
}
t = ask(c, d);
}
}
printf("! %d %d\n", a, b);
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
unsigned int c = 0;
unsigned int d = 0;
unsigned int a = 0;
unsigned int b = 0;
int ans;
cout << "? " << c << " " << d << endl;
cin >> ans;
for (long long i = 29; i >= 0; --i) {
if (ans == 0) break;
unsigned int mask = 1 << i;
unsigned int tc = c | mask;
unsigned int td = d | mask;
int tmp;
cout << "? " << tc << " " << td << endl;
cin >> tmp;
if (ans != tmp) {
if (ans == 1) {
a = a | mask;
c = tc;
} else {
b = b | mask;
d = td;
}
cout << "? " << c << " " << d << endl;
cin >> ans;
}
}
for (long long i = 29; i >= 0; --i) {
unsigned int mask = 1 << i;
if (((a & mask) > 0) || ((b & mask) > 0)) continue;
unsigned int tc = c | mask;
cout << "? " << tc << " " << d << endl;
cin >> ans;
if (ans == -1) {
a = a | mask;
b = b | mask;
}
}
cout << "! " << a << " " << b << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int query(int c, int d) {
cout << "? " << c << ' ' << d << endl;
int res;
cin >> res;
return res;
}
int res_glob = query(0, 0);
int main() {
ios::sync_with_stdio(false);
int a = 0, b = 0;
for (int i = 29; i >= 0; i--) {
int res01 = query(a, b | 1 << i);
int res10 = query(a | 1 << i, b);
if (res01 == res10) {
if (res_glob == -1)
b |= 1 << i;
else
a |= 1 << i;
res_glob = res01;
} else if (res01 == 1)
a |= 1 << i, b |= 1 << i;
}
cout << "! " << a << ' ' << b << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int last, ans1 = 0, ans2 = 0, dig, key, k1, k2;
cout << "? 0 0" << endl;
cin >> key;
last = key;
for (int i = 29; i >= 0; i--) {
dig = 1 << i;
if (last == 0) {
cout << "? " << dig + ans1 << " " << ans2 << endl;
cin >> k1;
cout << "? " << ans1 << " " << dig + ans2 << endl;
cin >> k2;
if (k1 == -1 && k2 == 1) ans1 += dig, ans2 += dig;
} else if (last == 1) {
cout << "? " << dig + ans1 << " " << dig + ans2 << endl;
cin >> k1;
if (k1 == -1) {
ans1 += dig;
cout << "? " << ans1 << " " << ans2 << endl;
cin >> k2;
last = k2;
} else {
cout << "? " << ans1 << " " << dig + ans2 << endl;
cin >> k2;
if (k2 == 1) ans1 += dig, ans2 += dig;
}
} else if (last == -1) {
cout << "? " << dig + ans1 << " " << dig + ans2 << endl;
cin >> k1;
if (k1 == 1) {
ans2 += dig;
cout << "? " << ans1 << " " << ans2 << endl;
cin >> k2;
last = k2;
} else {
cout << "? " << dig + ans1 << " " << ans2 << endl;
cin >> k2;
if (k2 == -1) ans1 += dig, ans2 += dig;
}
}
}
cout << "! " << ans1 << " " << ans2 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const int INF = 0x3f3f3f3f;
using namespace std;
const int mxn = 1e3 + 7;
long long n, t, m, k, l, r;
long long mat[mxn][mxn], prime[mxn], isprime[mxn], phi[mxn];
pair<int, int> a[mxn][mxn];
string str;
char ch;
int check(int l, int r) {
cout << "? " << l << ' ' << r << endl;
cin >> k;
return k;
}
int main() {
n = 0, m = 0;
long long res = check(n, m);
for (int i = 29; i >= 0; i--) {
l = check(n ^ (1 << i), m);
r = check(n, m ^ (1 << i));
if (l == r) {
if (res == 1)
n ^= (1 << i);
else if (res == -1)
m ^= (1 << i);
res = l;
} else if (l == -1)
n ^= (1 << i), m ^= (1 << i);
}
cout << "! " << n << ' ' << m << endl;
}
|
#include <bits/stdc++.h>
int ask(int a, int b) {
printf("? %d %d\n", a, b);
fflush(stdout);
scanf("%d", &a);
return a;
}
int main(void) {
int i, a, b, big, f1, f2;
for (a = b = 0, big = ask(0, 0), i = 29; i >= 0; i--) {
f1 = ask(a | (1 << i), b);
f2 = ask(a, b | (1 << i));
if (f1 == f2) {
if (big == 1)
a |= 1 << i;
else
b |= 1 << i;
big = f1;
} else {
if (f1 == -1) {
a |= 1 << i;
b |= 1 << i;
}
}
}
printf("! %d %d\n", a, b);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
bool DEBUGGING = 0;
void useiostream() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cerr.tie(0);
}
ll gcd(ll a, ll b) { return b == 0 ? a : gcd(b, a % b); }
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
ld const pi = acos(-1.0);
ld const eps = 0.000000001;
template <class T>
bool mi(T &a, T b) {
return a > b ? (a = b, true) : false;
}
template <class T>
bool ma(T &a, T b) {
return a < b ? (a = b, true) : false;
}
void ans(int a, int b) {
printf("! %d %d\n", a, b);
fflush(stdout);
exit(0);
}
int ask(int c, int d) {
printf("? %d %d\n", c, d);
fflush(stdout);
int a;
scanf("%d", &a);
return a;
}
int main() {
int pp = ask(0, 0);
int a, b;
a = b = 0;
for (int j = 29; j >= 0; j--) {
int p, q;
p = ask((1 << j) ^ a, b);
q = ask(a, (1 << j) ^ b);
if (p == q) {
if (pp == 1)
a ^= 1 << j;
else
b ^= 1 << j;
pp = p;
} else {
if (p == -1) a ^= 1 << j, b ^= 1 << j;
}
}
ans(a, b);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a, b, c, d, st, ed, tp, i;
int main() {
a = b = c = d = 0;
cout << "? " << a << " " << b << endl;
fflush(stdout);
cin >> st;
for (i = 29; i >= 0; i--) {
if (st == 0) {
cout << "? " << (a ^ (1 << i)) << " " << b << endl;
fflush(stdout);
cin >> tp;
if (tp < 0) {
c += (1 << i);
d += (1 << i);
}
} else {
cout << "? " << (a ^ (1 << i)) << " " << (b ^ (1 << i)) << endl;
fflush(stdout);
cin >> ed;
if (st < 0) {
if (ed > 0) {
d += (1 << i);
a += (1 << i);
cout << "? " << a << " " << b << endl;
fflush(stdout);
cin >> st;
} else {
cout << "? " << a << " " << (b ^ (1 << i)) << endl;
fflush(stdout);
cin >> tp;
if (tp != ed) {
c += (1 << i);
d += (1 << i);
}
}
} else {
if (ed < 0) {
c += (1 << i);
b += (1 << i);
cout << "? " << a << " " << b << endl;
fflush(stdout);
cin >> st;
} else {
cout << "? " << (a ^ (1 << i)) << " " << b << endl;
fflush(stdout);
cin >> tp;
if (tp != ed) {
c += (1 << i);
d += (1 << i);
}
}
}
}
}
cout << "! " << c << " " << d << endl;
fflush(stdout);
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int tmp, n, a = 0, b = 0;
printf("? 0 0\n");
fflush(stdout);
scanf("%d", &n);
for (int i = 29; i >= 0; --i) {
if (n == 0) {
printf("? %d %d\n", (a | (1 << i)), b);
fflush(stdout);
scanf("%d", &tmp);
if (tmp == -1) a |= (1 << i), b |= (1 << i);
} else {
printf("? %d %d\n", (a | (1 << i)), (b | (1 << i)));
fflush(stdout);
scanf("%d", &tmp);
if (tmp == n) {
printf("? %d %d\n", (a | (1 << i)), b);
fflush(stdout);
scanf("%d", &tmp);
if (tmp == -1) a |= (1 << i), b |= (1 << i);
} else {
if (n == 1)
a |= (1 << i);
else
b |= (1 << i);
printf("? %d %d\n", a, b);
fflush(stdout);
scanf("%d", &n);
}
}
}
printf("! %d %d\n", a, b);
fflush(stdout);
return 0;
}
|
#include <bits/stdc++.h>
int A, B;
void ask(int x, int y) {
printf("? %d %d\n", x, y);
fflush(stdout);
}
void succ(int x, int y) {
printf("! %d %d\n", x, y);
fflush(stdout);
exit(0);
}
int main() {
ask(0, 0);
int cmp;
scanf("%d", &cmp);
for (int i = 29; ~i; --i) {
ask(1 << i | A, 1 << i | B);
int x;
scanf("%d", &x);
if (x == cmp) {
ask(1 << i | A, B);
scanf("%d", &x);
if (x == -1) A |= 1 << i, B |= 1 << i;
} else {
if (cmp == 1)
A |= 1 << i;
else
B |= 1 << i;
ask(A, B);
scanf("%d", &cmp);
}
}
succ(A, B);
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
bool same[50];
int k = 29, c = 0, d = 0, a = 0, b = 0;
int s;
cout << "?" << ' ' << c << ' ' << d << endl;
fflush(stdout);
cin >> s;
int last = s;
while (k >= 0) {
if (last == 0) {
while (k >= 0) {
same[k] = true;
k--;
}
break;
}
cout << "?" << ' ' << (c + (1 << k)) << ' ' << (d + (1 << k)) << endl;
fflush(stdout);
cin >> s;
if (s == last) {
same[k] = true;
} else {
same[k] = false;
if (s == 1) {
a += 0;
b += (1 << k);
c += 0;
d += (1 << k);
} else if (s == -1) {
a += (1 << k);
b += 0;
c += (1 << k);
d += 0;
}
cout << "?" << ' ' << c << ' ' << d << endl;
fflush(stdout);
cin >> last;
}
k--;
}
k = 29;
while (k >= 0) {
if (!same[k]) {
k--;
continue;
}
cout << "?" << ' ' << (c + (1 << k)) << ' ' << d << endl;
fflush(stdout);
cin >> s;
if (s == 1) {
a += 0;
b += 0;
} else {
a += (1 << k);
b += (1 << k);
}
k--;
}
cout << "!" << ' ' << a << ' ' << b << endl;
fflush(stdout);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a, b, op, t;
void solve(int A, int B, int i) {
if (i < 0) {
cout << "! " << A << " " << B << endl;
return;
}
cout << "? " << A << " " << B << endl;
cin >> op;
if (op) {
for (; ~i; --i) {
cout << "? " << (A ^ (1 << i)) << " " << (B ^ (1 << i)) << endl;
cin >> t;
if (op != t) {
if (op == 1)
A ^= (1 << i);
else
B ^= (1 << i);
break;
} else {
cout << "? " << A << " " << (B ^ (1 << i)) << endl;
cin >> t;
if (t == 1) A ^= (1 << i), B ^= (1 << i);
}
}
solve(A, B, --i);
} else {
cout << "? " << A << " " << (B ^ (1 << i)) << endl;
cin >> t;
if (t == 1) A ^= (1 << i), B ^= (1 << i);
solve(A, B, --i);
}
}
int main() {
solve(0, 0, 29);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int res1, res2;
int curra = 0, currb = 0;
int g;
cout << "? "
<< "0 "
<< "0" << endl;
cout.flush();
cin >> g;
for (int i = 1 << 29; i >= 1; i >>= 1) {
cout << "? " << curra + i << " " << currb << endl;
cout.flush();
cin >> res1;
cout << "? " << curra << " " << currb + i << endl;
cout.flush();
cin >> res2;
if (res1 == -1 && res2 == 1) {
curra += i;
currb += i;
} else if (res1 == res2) {
if (g == 1)
curra += i;
else
currb += i;
g = res1;
}
}
cout << "! " << curra << " " << currb << endl;
cout.flush();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long to_int(string s) {
long long ans = 0;
long long x = 1;
for (int i = 29; i >= 0; i--) {
if (s[i] == '1') ans += x;
x *= 2;
}
return ans;
}
void read_input(int &x) {
int t;
cin >> t;
x = t;
}
int main() {
cout.flush();
string a = string(30, '0');
string b = string(30, '0');
cout << "? 0 0" << endl;
int sign;
read_input(sign);
for (int i = 0; i < 30; i++) {
int temp1, temp2;
if (sign == 1) {
a[i] = '1';
b[i] = '1';
cout << "? " << to_int(a) << " " << to_int(b) << endl;
read_input(temp1);
a[i] = '0';
b[i] = '1';
cout << "? " << to_int(a) << " " << to_int(b) << endl;
read_input(temp2);
if (temp1 == -1) {
a[i] = '1';
b[i] = '0';
sign = temp2;
} else if (temp2 == -1) {
a[i] = '0';
b[i] = '0';
} else {
a[i] = '1';
b[i] = '1';
}
} else if (sign == -1) {
a[i] = '1';
b[i] = '1';
cout << "? " << to_int(a) << " " << to_int(b) << endl;
read_input(temp1);
a[i] = '0';
b[i] = '1';
cout << "? " << to_int(a) << " " << to_int(b) << endl;
read_input(temp2);
if (temp1 == 1) {
a[i] = '0';
b[i] = '1';
sign = temp2;
} else if (temp2 == -1) {
a[i] = '0';
b[i] = '0';
} else {
a[i] = '1';
b[i] = '1';
}
} else {
a[i] = '1';
b[i] = '0';
cout << "? " << to_int(a) << " " << to_int(b) << endl;
read_input(temp1);
if (temp1 > 0) {
a[i] = '0';
b[i] = '0';
} else {
a[i] = '1';
b[i] = '1';
}
}
}
cout << "! " << to_int(a) << " " << to_int(b) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-ffloat-store")
#pragma GCC optimize("-fno-defer-pop")
long int power(long int a, long int b, long int m) {
if (b == 0) return 1;
if (b == 1) return a % m;
long int t = power(a, b / 2, m) % m;
t = (t * t) % m;
if (b & 1) t = ((t % m) * (a % m)) % m;
return t;
}
long int modInverse(long int a, long int m) { return power(a, m - 2, m); }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long int i, j, k, l, n;
long int a = 0, b = 0;
cout << "? " << a << " " << b << "\n";
cout.flush();
;
cin >> k;
for (i = 29; i >= 0; i--) {
long int f, s;
cout << "? " << (a ^ (1ll << i)) << " " << b << "\n";
cout.flush();
;
cin >> f;
cout << "? " << a << " " << (b ^ (1ll << i)) << "\n";
cout.flush();
;
cin >> s;
if (f == s) {
if (k == 1)
a = (a ^ (1ll << i));
else
b = (b ^ (1ll << i));
k = f;
} else {
if (f == -1) {
a = (a ^ (1ll << i));
b = (b ^ (1ll << i));
}
}
}
cout << "! " << a << " " << b << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int ask(int c, int d) {
cout << "? " << c << ' ' << d << endl;
int ans;
cin >> ans;
return ans;
}
int main() {
cout.flush();
int a = 0, b = 0, big = ask(0, 0);
for (int i = 29; i >= 0; i--) {
int f = ask(a ^ (1 << i), b), s = ask(a, b ^ (1 << i));
if (f == s) {
if (big == 1)
a ^= (1 << i);
else
b ^= (1 << i);
big = f;
} else if (f == -1) {
a ^= (1 << i);
b ^= (1 << i);
}
}
cout << "! " << a << ' ' << b << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int query(int c, int d, int ret = 0) {
printf("? %d %d\n", c, d);
fflush(stdout);
scanf("%d", &ret);
return ret;
}
int main() {
int a = 0, b = 0;
int aIsBigger = 1;
if (query(0, 0) < 0) aIsBigger = 0;
for (int i = 29; i >= 0; i--) {
int x = query(a ^ (1 << i), b), y = query(a, b ^ (1 << i));
if (x == y) {
if (aIsBigger)
a ^= (1 << i);
else
b ^= (1 << i);
aIsBigger = (x == 1);
} else if (x == -1 && y == 1) {
a ^= (1 << i);
b ^= (1 << i);
}
}
printf("! %d %d\n", a, b);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
void dbs(string str, T t) {
cerr << str << " : " << t << "\n";
}
template <class T, class... S>
void dbs(string str, T t, S... s) {
int idx = str.find(',');
cerr << str.substr(0, idx) << " : " << t << ", ";
dbs(str.substr(idx + 1), s...);
}
template <class S, class T>
ostream& operator<<(ostream& os, const pair<S, T>& p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <class T>
ostream& operator<<(ostream& os, const vector<T>& p) {
os << "[ ";
for (auto& it : p) os << it << " ";
return os << "]";
}
template <class T>
ostream& operator<<(ostream& os, const set<T>& p) {
os << "[ ";
for (auto& it : p) os << it << " ";
return os << "]";
}
template <class S, class T>
ostream& operator<<(ostream& os, const map<S, T>& p) {
os << "[ ";
for (auto& it : p) os << it << " ";
return os << "]";
}
template <class T>
void prc(T a, T b) {
cerr << "[";
for (T i = a; i != b; ++i) {
if (i != a) cerr << ", ";
cerr << *i;
}
cerr << "]\n";
}
void code() {
long long a, b, x, c, d, y;
a = b = 0;
cout << "? " << a << " " << b << "\n";
fflush(stdout);
cin >> x;
vector<long long> v;
for (long long i = 29; i >= 0; i--) {
if (x != 0) {
c = a ^ (1 << i), d = b ^ (1 << i);
cout << "? " << c << " " << d << "\n";
fflush(stdout);
cin >> y;
if (y == -x) {
long long bit = (x == 1) ? 1 : 0;
a = a ^ (bit << i), b = b ^ ((1 - bit) << i);
cout << "? " << a << " " << b << "\n";
fflush(stdout);
cin >> x;
continue;
} else
v.push_back(i);
} else
v.push_back(i);
x = y;
}
for (auto i : v) {
c = a ^ (0 << i), d = b ^ (1 << i);
cout << "? " << c << " " << d << "\n";
fflush(stdout);
cin >> y;
long long bit = (y == 1) ? 1 : 0;
a = a ^ (bit << i), b = b ^ (bit << i);
}
cout << "! " << a << " " << b << "\n";
fflush(stdout);
}
int main() {
int t = 1;
for (auto i = (1); i != (t + 1); i++) {
code();
}
return 0;
}
|
#include <bits/stdc++.h>
using pii = std::pair<int, int>;
using pll = std::pair<long long, long long>;
std::map<pii, int> cache;
int prefix_a = 0, prefix_b = 0;
int ask(int m1, int m2) {
m1 += prefix_a;
m2 += prefix_b;
if (cache.count({m1, m2})) return cache[{m1, m2}];
std::cout << "?"
<< " " << m1 << " " << m2 << std::endl;
std::cout.flush();
int a;
std::cin >> a;
cache[{m1, m2}] = a;
return a;
}
void ans() {
std::cout << "!"
<< " " << prefix_a << " " << prefix_b << std::endl;
std::cout.flush();
}
void same(int i) {
for (int o = i; o >= 0; o--) {
if (ask(1 << o, 0) == -1) {
prefix_a += (1 << o);
prefix_b += (1 << o);
}
}
}
void play(int i) {
if (i < 0) return;
if (ask(0, 0) == 0) return same(i);
if (ask(0, 0) == -1) {
int r1 = ask((1 << i), 0);
if (r1 == 0) {
prefix_b |= (1 << i);
return play(i - 1);
}
int r2 = ask(0, (1 << i));
if (r2 == 0) {
prefix_b |= (1 << i);
return same(i - 1);
}
if (r1 != r2) {
if (r1 == -1) {
prefix_a |= (1 << i);
prefix_b |= (1 << i);
}
cache[{prefix_a, prefix_b}] = -1;
}
if (r1 == r2) {
prefix_b |= (1 << i);
cache[{prefix_a, prefix_b}] = r1;
}
return play(i - 1);
}
if (ask(0, 0) == 1) {
int r1 = ask(0, (1 << i));
if (r1 == 0) {
prefix_a |= (1 << i);
return play(i - 1);
}
int r2 = ask((1 << i), 0);
if (r2 == 0) {
prefix_a |= (1 << i);
return same(i - 1);
}
if (r1 != r2) {
if (r1 == 1) {
prefix_a |= (1 << i);
prefix_b |= (1 << i);
}
cache[{prefix_a, prefix_b}] = 1;
}
if (r1 == r2) {
prefix_a |= (1 << i);
cache[{prefix_a, prefix_b}] = r1;
}
return play(i - 1);
}
}
int main() {
std::ios::sync_with_stdio(false);
play(29);
ans();
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.