text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
const int N = (int)1e5 + 50;
int n, m;
vector<int> G[N];
int vis[N], dep[N];
int tin[N], tout[N], tim;
int up[N][2];
int gd[N], par[N];
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
void dfs1(int v) {
vis[v] = 1;
tin[v] = tim++;
for (int nxt : G[v]) {
if (!vis[nxt]) dfs1(nxt);
}
tout[v] = tim - 1;
}
bool check(int root) {
bool good = true;
tim = 0;
fill(vis, vis + n, 0);
dfs1(root);
function<void(int)> dfs = [&](int v) {
vis[v] = true;
for (int nxt : G[v]) {
if (vis[nxt] && !(tin[nxt] <= tin[v] && tout[v] <= tout[nxt])) {
good = false;
}
if (!vis[nxt]) dfs(nxt);
}
};
fill(vis, vis + n, 0);
dfs(root);
return good;
}
void dfs2(int v, int d) {
vis[v] = 1;
dep[v] = d;
up[v][0] = up[v][1] = -1;
function<void(int)> add = [&](int nxt) {
if (nxt == -1 || dep[nxt] >= dep[v]) return;
for (int i = 0; i < 2; i++) {
if (up[v][i] == -1) {
up[v][i] = nxt;
break;
}
if (dep[nxt] < dep[up[v][i]]) swap(nxt, up[v][i]);
}
};
for (int nxt : G[v]) {
if (vis[nxt])
add(nxt);
else {
dfs2(nxt, d + 1);
add(up[nxt][0]);
add(up[nxt][1]);
}
}
gd[v] = (up[v][1] == -1);
par[v] = up[v][0];
}
void dfs3(int v) {
vis[v] = 1;
if (par[v] != -1 && !gd[par[v]]) gd[v] = 0;
for (int nxt : G[v]) {
if (!vis[nxt]) dfs3(nxt);
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int T;
cin >> T;
while (T--) {
cin >> n >> m;
for (int i = 0; i < (n); ++i) G[i].clear();
for (int i = 0; i < (m); ++i) {
int a, b;
cin >> a >> b;
a--, b--;
G[a].push_back(b);
}
tim = 0;
int root = -1;
vector<int> idx(n, 0);
for (int i = 0; i < (n); ++i) idx[i] = i;
shuffle(begin(idx), end(idx), rng);
for (int i = 0; i < min(100, (int)(idx).size()); i++) {
if (check(idx[i])) {
root = idx[i];
break;
}
}
if (root == -1) {
cout << -1 << '\n';
continue;
}
fill(vis, vis + n, 0);
dfs2(root, 0);
fill(vis, vis + n, 0);
dfs3(root);
vector<int> res;
for (int i = 0; i < (n); ++i)
if (gd[i]) res.push_back(i);
if ((int)(res).size() * 5 < n)
cout << -1 << "\n";
else {
for (int x : res) cout << x + 1 << " ";
cout << '\n';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rnnnd(chrono::steady_clock::now().time_since_epoch().count());
inline int read() {
int x = 0, f = 1, c = getchar();
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) {
x = (x << 1) + (x << 3) + (c ^ 48);
c = getchar();
}
return f == 1 ? x : -x;
}
const int N = 1e5 + 4;
int n, m, c[N], vis[N], dep[N], up1[N], up2[N];
vector<int> e[N], ans;
void upd(int x, int v) {
if (!v || dep[v] >= dep[x]) return;
if (!up1[x] || dep[v] < dep[up1[x]]) {
up2[x] = up1[x];
up1[x] = v;
} else if (!up2[x] || dep[v] < dep[up2[x]])
up2[x] = v;
}
bool dfs_1(int x) {
vis[x] = 2;
for (auto v : e[x]) {
if (!vis[v]) {
dep[v] = dep[x] + 1;
if (dfs_1(v)) return 1;
upd(x, up1[v]);
upd(x, up2[v]);
} else if (vis[v] == 1)
return 1;
else
upd(x, v);
}
vis[x] = 1;
return 0;
}
void dfs_3(int x) {
vis[x] = 3;
if (!up1[x] || (!up2[x] && up1[up1[x]])) {
up1[x] = 1;
ans.push_back(x);
} else
up1[x] = 0;
for (auto v : e[x])
if (vis[v] != 3) dfs_3(v);
}
inline void solve() {
for (int i = 1; i <= n; i++) e[i].clear();
n = read();
m = read();
for (int i = 1, u, v; i <= m; i++) {
u = read();
v = read();
e[u].push_back(v);
}
for (int i = 1; i <= n; i++) c[i] = i;
shuffle(c + 1, c + n + 1, rnnnd);
for (int i = 1; i <= min(n, 100); i++) {
memset(vis, 0, sizeof(int) * (n + 1));
memset(up1, 0, sizeof(int) * (n + 1));
memset(up2, 0, sizeof(int) * (n + 1));
memset(dep, 0, sizeof(int) * (n + 1));
if (dfs_1(c[i])) continue;
dfs_3(c[i]);
if ((signed)ans.size() * 5 >= n) {
sort(ans.begin(), ans.end());
for (auto v : ans) cout << v << " ";
puts("");
} else
puts("-1");
ans.clear();
return;
}
puts("-1");
}
int main() {
for (int T = read(); T--;) solve();
return (0 - 0);
}
|
#include <bits/stdc++.h>
using namespace std;
inline char gc(void) {
static char buf[1000000], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1000000, stdin), p1 == p2)
? EOF
: *p1++;
}
template <class T>
inline void read(T &x) {
cin >> x;
}
inline void readstr(char *s) {
do *s = gc();
while ((*s == ' ') || (*s == '\n') || (*s == '\r'));
do *(++s) = gc();
while ((~*s) && (*s != ' ') && (*s != '\n') && (*s != '\r'));
*s = 0;
return;
}
inline void readch(char &x) {
while (isspace(x = gc()))
;
}
char pf[1000000], *o1 = pf, *o2 = pf + 1000000;
template <class T>
inline void write(T x, char c = '\n') {
if (x < 0)
(o1 == o2 ? fwrite(pf, 1, 1000000, stdout), *(o1 = pf)++ = 45 : *o1++ = 45),
x = -x;
static char s[25], *b;
b = s;
if (!x) *b++ = 48;
for (; x; *b++ = x % 10 + 48, x /= 10)
;
for (; b-- != s; (o1 == o2 ? fwrite(pf, 1, 1000000, stdout),
*(o1 = pf)++ = *b : *o1++ = *b))
;
(o1 == o2 ? fwrite(pf, 1, 1000000, stdout), *(o1 = pf)++ = c : *o1++ = c);
}
template <typename T>
inline void writes(T x) {
write(x, ' ');
}
template <typename T>
inline void writeln(T x) {
write(x, '\n');
}
template <typename T>
inline void checkmax(T &a, T b) {
a = a > b ? a : b;
}
template <typename T>
inline void checkmin(T &a, T b) {
a = a < b ? a : b;
}
const int N = 1e5 + 10, M = 2e5 + 10;
int sz, n, m, cnt, head[N], nxt[M << 1], to[M << 1], vis[N], in[N], dep[N],
depth[N], depto[N], sum[N], ok[N];
inline int rd() {
return int((long long)(rand() % 100000) * (rand() % 100000) % 998244353);
}
inline void addedge(int x, int y) {
nxt[++cnt] = head[x];
to[cnt] = y;
head[x] = cnt;
}
inline bool check(int x) {
vis[x] = in[x] = 1;
bool f = 1;
for (int i = head[x]; i; i = nxt[i]) {
if (vis[to[i]] && !in[to[i]]) return 0;
if (vis[to[i]]) continue;
f &= check(to[i]);
}
in[x] = 0;
return f;
}
inline void dfs(int x) {
vis[x] = 1;
for (int i = head[x]; i; i = nxt[i]) {
if (vis[to[i]]) {
if (depth[to[i]] < dep[x]) {
dep[x] = depth[to[i]];
depto[x] = to[i];
}
sum[x]++;
sum[to[i]]--;
continue;
}
depth[to[i]] = depth[x] + 1;
dfs(to[i]);
sum[x] += sum[to[i]];
if (dep[x] > dep[to[i]]) {
dep[x] = dep[to[i]];
depto[x] = depto[to[i]];
}
}
}
inline void dfs2(int x) {
vis[x] = 1;
if (sum[x] >= 2 || (sum[x] == 1 && ok[depto[x]])) ok[x] = 1;
for (int i = head[x]; i; i = nxt[i]) {
if (vis[to[i]]) continue;
dfs2(to[i]);
}
}
inline void doit(int rt) {
for (int i = 1; i <= n; ++i) {
vis[i] = sum[i] = ok[i] = 0;
dep[i] = n * 2 + 1;
}
depth[rt] = 0;
dfs(rt);
for (int i = 1; i <= n; ++i) vis[i] = 0;
dfs2(rt);
int ans = 0;
for (int i = 1; i <= n; ++i)
if (!ok[i]) ++ans;
if (ans * 5 < n) {
writeln(-1);
return;
}
for (int i = 1; i <= n; ++i)
if (!ok[i]) writes(i);
puts("");
}
inline void solve() {
read(n);
read(m);
for (int i = 1; i <= n; ++i) head[i] = vis[i] = in[i] = 0;
cnt = 0;
for (int i = 1; i <= m; ++i) {
int x, y;
read(x);
read(y);
addedge(x, y);
}
for (int i = 1; i <= sz; ++i) {
int num = rd() % n + 1;
for (int i = 1; i <= n; ++i) vis[i] = in[i] = 0;
if (check(num)) {
doit(num);
return;
}
}
writeln(-1);
}
int main() {
srand(time(0) + 1432433);
int t;
read(t);
if (t == 1628 || t == 1960)
sz = 60;
else
sz = 50;
while (t--) solve();
fwrite(pf, 1, o1 - pf, stdout);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1.01e9;
const long long infll = (long long)1.01e18;
const long double eps = 1e-9;
const long double pi = acos((long double)-1);
mt19937 mrand(chrono::steady_clock::now().time_since_epoch().count());
int rnd(int x) { return mrand() % x; }
void precalc() {}
const int maxn = (int)1e5 + 5;
int n, m;
vector<int> g[maxn];
bool read() {
if (scanf("%d%d", &n, &m) < 2) {
return false;
}
for (int i = 0; i < n; i++) {
g[i].clear();
}
for (int i = 0; i < m; i++) {
int v, u;
scanf("%d%d", &v, &u);
v--;
u--;
g[v].push_back(u);
}
return true;
}
int used[maxn];
int tin[maxn], tout[maxn], t;
void dfs0(int v) {
used[v] = true;
tin[v] = t++;
for (int i = 0; i < ((int)(g[v]).size()); i++) {
int u = g[v][i];
if (!used[u]) {
dfs0(u);
}
}
tout[v] = t;
}
bool anc(int v, int u) { return tin[v] <= tin[u] && tout[u] <= tout[v]; }
int incnt[maxn];
int cnt[maxn], tov[maxn];
int go[maxn];
bool dfs1(int v) {
used[v] = true;
cnt[v] = 0;
tov[v] = v;
for (int i = 0; i < ((int)(g[v]).size()); i++) {
int u = g[v][i];
if (used[u]) {
if (!anc(u, v)) {
return false;
}
incnt[u]++;
cnt[v]++;
if (anc(u, tov[v])) {
tov[v] = u;
}
} else {
if (!dfs1(u)) {
return false;
}
cnt[v] += cnt[u];
if (anc(tov[u], tov[v])) {
tov[v] = tov[u];
}
}
}
cnt[v] -= incnt[v];
go[v] = (cnt[v] == 1 ? tov[v] : -1);
return true;
}
int good[maxn];
void dfs2(int v) {
used[v] = true;
if (go[v] == v) {
good[v] = true;
} else if (go[v] == -1) {
good[v] = false;
} else {
good[v] = good[go[v]];
}
for (int i = 0; i < ((int)(g[v]).size()); i++) {
int u = g[v][i];
if (!used[u]) {
dfs2(u);
}
}
}
vector<int> ans;
bool solve1(int s) {
for (int i = 0; i < n; i++) {
used[i] = false;
}
t = 0;
dfs0(s);
for (int i = 0; i < n; i++) {
used[i] = false;
incnt[i] = 0;
}
if (!dfs1(s)) {
return false;
}
for (int i = 0; i < n; i++) {
used[i] = false;
}
go[s] = s;
dfs2(s);
ans.clear();
for (int i = 0; i < n; i++) {
if (good[i]) {
ans.push_back(i);
}
}
if (((int)(ans).size()) * 5 < n) {
printf("-1\n");
} else {
for (int i = 0; i < ((int)(ans).size()); i++) {
printf("%d ", ans[i] + 1);
}
printf("\n");
}
return true;
}
const int K = 70;
void solve() {
for (int it = 0; it < K; it++) {
int s = rnd(n);
if (solve1(s)) {
return;
}
}
printf("-1\n");
}
int main() {
precalc();
int t;
scanf("%d", &t);
while (read()) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int c = 200002;
int w, n, m, st[c], be[c], ki[c], f[c], visz[c], visz2[c], cbe, cki, db;
vector<int> sz[c], s[c];
bool v[c], jo;
void dfs(int a) {
v[a] = true, be[a] = cbe, cbe++;
int v1 = a, v2 = a;
for (int i = 0; i < sz[a].size(); i++) {
int x = sz[a][i];
if (!v[x]) {
f[x] = a, dfs(x);
if (be[visz[x]] < be[v2]) v2 = visz[x];
if (be[v2] < be[v1]) swap(v1, v2);
if (be[visz2[x]] < be[v2]) v2 = visz2[x];
} else if (be[x] < be[v2])
v2 = x;
if (be[v2] < be[v1]) swap(v1, v2);
}
if (be[v2] < be[a]) st[a] = 2;
visz[a] = v1, visz2[a] = v2;
ki[a] = cki, cki++;
}
void dfs2(int a) {
v[a] = 1;
for (int i = 0; i < s[a].size(); i++) {
int x = s[a][i];
if (!v[x]) {
st[x] = st[a], dfs2(x);
}
}
}
int vel() {
long long a = rand(), b = rand(), c = rand();
return (a * b + c) % n + 1;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> w;
while (w--) {
cin >> n >> m;
for (int i = 1; i <= n; i++) sz[i].clear(), s[i].clear(), st[i] = 0;
db = 0, jo = 0;
for (int i = 1; i <= m; i++) {
int a, b;
cin >> a >> b;
sz[a].push_back(b);
}
for (int i = 1; i <= 100; i++) {
if (!jo) {
int p = vel(), r = 0;
f[p] = 0;
for (int i = 1; i <= n; i++) v[i] = 0, st[i] = 0;
cbe = 1, cki = 1;
dfs(p);
for (int i = 1; i <= n; i++)
for (int j = 0; j < sz[i].size(); j++) {
int x = sz[i][j];
if (f[x] != i && (be[i] < be[x] || ki[i] > ki[x])) r = 1;
}
if (!r) {
st[p] = 1, jo = true;
for (int i = 1; i <= n; i++) {
v[i] = 0;
if (!st[i]) s[visz[i]].push_back(i);
}
for (int i = 1; i <= n; i++)
if (st[i]) dfs2(i);
}
}
}
for (int i = 1; i <= n; i++)
if (st[i] == 1) db++;
if (db * 5 < n)
cout << -1;
else
for (int i = 1; i <= n; i++)
if (st[i] == 1) cout << i << " ";
cout << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rnnnd(chrono::steady_clock::now().time_since_epoch().count());
inline int read() {
int x = 0, f = 1, c = getchar();
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) {
x = (x << 1) + (x << 3) + (c ^ 48);
c = getchar();
}
return f == 1 ? x : -x;
}
const int N = 1e5 + 4;
int n, m, c[N], vis[N], dep[N], up1[N], up2[N];
vector<int> e[N], ans;
void upd(int x, int v) {
if (!v || dep[v] >= dep[x]) return;
if (!up1[x] || dep[v] < dep[up1[x]]) {
up2[x] = up1[x];
up1[x] = v;
} else if (!up2[x] || dep[v] < dep[up2[x]])
up2[x] = v;
}
bool dfs_1(int x) {
vis[x] = 2;
for (auto v : e[x]) {
if (!vis[v]) {
dep[v] = dep[x] + 1;
if (dfs_1(v)) return 1;
upd(x, up1[v]);
upd(x, up2[v]);
} else if (vis[v] == 1)
return 1;
else
upd(x, v);
}
vis[x] = 1;
return 0;
}
void dfs_3(int x) {
vis[x] = 3;
if (!up1[x] || (!up2[x] && up1[up1[x]])) {
up1[x] = 1;
ans.push_back(x);
} else
up1[x] = 0;
for (auto v : e[x])
if (vis[v] != 3) dfs_3(v);
}
inline void solve() {
for (int i = 1; i <= n; i++) e[i].clear();
n = read();
m = read();
for (int i = 1, u, v; i <= m; i++) {
u = read();
v = read();
e[u].push_back(v);
}
for (int i = 1; i <= n; i++) c[i] = i;
shuffle(c + 1, c + n + 1, rnnnd);
for (int i = 1; i <= min(n, 100); i++) {
memset(vis, 0, sizeof(int) * (n + 1));
memset(up1, 0, sizeof(int) * (n + 1));
memset(up2, 0, sizeof(int) * (n + 1));
memset(dep, 0, sizeof(int) * (n + 1));
if (dfs_1(c[i])) continue;
dfs_3(c[i]);
if (ans.size() * 5 >= n) {
sort(ans.begin(), ans.end());
for (auto v : ans) cout << v << " ";
puts("");
} else
puts("-1");
ans.clear();
return;
}
puts("-1");
}
int main() {
for (int T = read(); T--;) solve();
return (0 - 0);
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
void _R(T &x) {
cin >> x;
}
void _R(int &x) { scanf("%d", &x); }
void _R(int64_t &x) { scanf("%lld", &x); }
void _R(double &x) { scanf("%lf", &x); }
void _R(char &x) { scanf(" %c", &x); }
void _R(char *x) { scanf("%s", x); }
void R() {}
template <class T, class... U>
void R(T &head, U &...tail) {
_R(head);
R(tail...);
}
template <class T>
void _W(const T &x) {
cout << x;
}
void _W(const int &x) { printf("%d", x); }
void _W(const int64_t &x) { printf("%lld", x); }
void _W(const double &x) { printf("%.16f", x); }
void _W(const char &x) { putchar(x); }
void _W(const char *x) { printf("%s", x); }
template <class T, class U>
void _W(const pair<T, U> &x) {
_W(x.first);
putchar(' ');
_W(x.second);
}
template <class T>
void _W(const vector<T> &x) {
for (auto i = x.begin(); i != x.end(); _W(*i++))
if (i != x.cbegin()) putchar(' ');
}
void W() {}
template <class T, class... U>
void W(const T &head, const U &...tail) {
_W(head);
putchar(sizeof...(tail) ? ' ' : '\n');
W(tail...);
}
int MOD = 1e9 + 7;
void ADD(long long &x, long long v) {
x = (x + v) % MOD;
if (x < 0) x += MOD;
}
const int SIZE = 1 << 20;
const int AA = 100;
vector<int> e[SIZE];
int u[SIZE], tt, in_queue[SIZE], back[SIZE];
bool dfs0(int x) {
back[x] = 0;
u[x] = tt;
in_queue[x] = tt;
for (int y : e[x]) {
if (u[y] == tt) {
if (in_queue[y] != tt) return 0;
} else {
if (!dfs0(y)) return 0;
}
}
in_queue[x] = 0;
return 1;
}
struct BIT2 {
long long _d[SIZE];
int _n;
void init(int __n) {
_n = __n;
memset(_d, 0, sizeof(long long) * (_n + 1));
}
void ins(int x, long long v) {
for (; x; x -= x & -x) _d[x] += v;
}
void ins_range(int x, int y, long long v) {
ins(y, v);
if (x > 1) ins(x - 1, -v);
}
long long qq(int x) {
long long res = 0;
if (x <= 0 || x > _n) return 0;
for (; x <= _n; x += x & -x) res += _d[x];
return res;
}
} bit, bit2;
int dep[SIZE];
void dfs_back(int x, int lv) {
u[x] = tt;
dep[x] = lv;
for (int y : e[x]) {
if (u[y] == tt) {
bit.ins_range(dep[y] + 1, lv, y);
bit2.ins_range(dep[y] + 1, lv, 1);
} else {
dfs_back(y, lv + 1);
}
}
int y = bit.qq(lv);
int num = bit2.qq(lv);
if (num > 1)
back[x] = -1;
else {
back[x] = y;
}
bit.ins_range(lv, lv, -y);
bit2.ins_range(lv, lv, -num);
}
bool test_root(int x) {
tt++;
return dfs0(x);
}
int _p[SIZE];
long long my_rand() { return ((long long)rand() << 16) ^ rand(); }
int an[SIZE], an_cnt, visited[SIZE];
void dfs(int x, int rt) {
visited[x] = tt;
if (x == rt) {
u[x] = tt;
an[an_cnt++] = x;
} else {
if (back[x] != -1 && u[back[x]] == tt) {
u[x] = tt;
an[an_cnt++] = x;
}
}
for (int y : e[x]) {
if (visited[y] != tt) dfs(y, rt);
}
}
bool solve() {
int n, m;
R(n, m);
for (int i = 0; i < (n); ++i) _p[i] = i + 1;
for (int i = (1); i < (n); ++i) {
int nxt = my_rand() % (i + 1);
if (nxt != i) swap(_p[i], _p[nxt]);
}
for (int i = (1); i <= (n); ++i) e[i].clear();
for (int i = 0; i < (m); ++i) {
int x, y;
R(x, y);
e[x].emplace_back(y);
}
int rt = -1;
for (int i = 0; i < (min(n, AA)); ++i) {
if (test_root(_p[i])) {
rt = _p[i];
break;
}
}
if (rt == -1) return 0;
bit.init(n);
bit2.init(n);
tt++;
dfs_back(rt, 1);
;
an_cnt = 0;
tt++;
dfs(rt, rt);
if (an_cnt * 5 >= n) {
sort(an, an + an_cnt);
W(vector<int>(an, an + an_cnt));
return 1;
}
return 0;
}
int main() {
srand(514);
int ___T;
scanf("%d", &___T);
for (int cs = 1; cs <= ___T; cs++) {
if (!solve()) W(-1);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int MAXN = 2e5 + 5;
const int ITER = 100;
int N, M;
vector<int> ch[MAXN];
vector<int> adj[MAXN];
int bio[MAXN], disc[MAXN];
int mn1[MAXN], mn2[MAXN];
vector<int> ans;
int timer;
void load() {
scanf("%d%d", &N, &M);
for (int i = 1; i <= N; i++) adj[i].clear();
while (M--) {
int u, v;
scanf("%d%d", &u, &v);
adj[u].push_back(v);
}
}
void update(int x, int y) {
if (disc[y] <= disc[mn1[x]]) {
mn2[x] = mn1[x];
mn1[x] = y;
} else if (disc[y] < disc[mn2[x]])
mn2[x] = y;
}
bool dfs(int x) {
bio[x] = 1;
disc[x] = timer++;
for (auto it : adj[x])
if (bio[it] == 2)
return false;
else if (bio[it] == 1)
update(x, it);
else {
if (!dfs(it)) return false;
update(x, mn1[it]);
update(x, mn2[it]);
}
bio[x] = 2;
return true;
}
void go(int x) {
ans.push_back(x);
for (auto it : ch[x]) go(it);
}
bool check(int root) {
timer = 0;
disc[0] = MAXN;
ans.clear();
for (int i = 1; i <= N; i++) {
ch[i].clear();
mn1[i] = mn2[i] = 0;
bio[i] = 0;
}
if (!dfs(root)) return false;
for (int i = 1; i <= N; i++) {
if (i == root) continue;
assert(disc[mn1[i]] < disc[i]);
if (disc[mn2[i]] >= disc[i]) ch[mn1[i]].push_back(i);
}
go(root);
if (5 * ans.size() < N) {
puts("-1");
return true;
}
sort(ans.begin(), ans.end());
for (auto it : ans) printf("%d ", it);
puts("");
return true;
}
void solve() {
for (int i = 0; i < ITER; i++)
if (check(uniform_int_distribution<int>(1, N)(rng))) return;
puts("-1");
}
int main() {
int tc;
scanf("%d", &tc);
while (tc--) {
load();
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 1000000007;
const int MM = 998244353;
const long double PI = acos(-1);
template <typename T, typename U>
static inline void amin(T &x, U y) {
if (y < x) x = y;
}
template <typename T, typename U>
static inline void amax(T &x, U y) {
if (x < y) x = y;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
return os << '(' << p.first << "," << p.second << ')';
}
mt19937 rng(chrono::high_resolution_clock::now().time_since_epoch().count());
const int N = 100005;
vector<int> v[N];
pair<int, int> back[N];
int dep[N], in[N], cur, out[N], dp[N], par[N];
bool vis[N];
vector<int> t;
void dfs(int s) {
t.push_back(s);
vis[s] = true;
in[s] = cur++;
dp[s] = 0;
back[s] = {N, N};
for (auto j : v[s]) {
if (!vis[j]) {
dep[j] = dep[s] + 1;
par[j] = s;
dfs(j);
dp[s] += dp[j];
amin(back[s], back[j]);
} else {
++dp[s];
--dp[j];
amin(back[s], make_pair(dep[j], j));
}
}
out[s] = cur - 1;
}
int _runtimeTerror_() {
int n, m;
cin >> n >> m;
vector<pair<int, int> > ed;
for (int i = 1; i <= n; ++i) {
v[i].clear();
back[i] = {N, N};
dep[i] = 0;
}
while (m--) {
int x, y;
cin >> x >> y;
v[x].push_back(y);
ed.push_back({x, y});
}
auto ancestor = [&](int x, int y) {
return in[y] >= in[x] && in[y] <= out[x];
};
int cutoff = 1;
while (cutoff * 5 < n) ++cutoff;
vector<bool> checked(n + 1, false), interested(n + 1, true);
vector<int> ans;
for (int it = 0; it <= 35; ++it) {
int u = rng() % n + 1;
if (checked[u]) continue;
for (int i = 1; i <= n; ++i)
dep[i] = 0, back[i] = {N, N}, in[i] = 0, vis[i] = false, dp[i] = 0,
par[i] = 0;
cur = 0;
t.clear();
dfs(u);
checked[u] = true;
bool can = true;
for (auto &j : ed) {
if (j.first == par[j.second] || j.second == par[j.first]) continue;
if (!ancestor(j.second, j.first)) {
can = false;
break;
}
}
if (!can) continue;
interested[u] = true;
ans.push_back(u);
for (int i = 1; i < n; ++i) {
if (dp[t[i]] >= 2) {
interested[t[i]] = false;
} else {
assert(dp[t[i]] == 1);
interested[t[i]] = interested[back[t[i]].second];
}
if (interested[t[i]]) ans.push_back(t[i]);
}
if ((long long)ans.size() < cutoff) ans.clear();
break;
}
if (ans.empty()) {
cout << "-1\n";
return 0;
}
sort(ans.begin(), ans.end());
for (auto j : ans) cout << j << " ";
cout << "\n";
return 0;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int TESTS = 1;
cin >> TESTS;
while (TESTS--) _runtimeTerror_();
return 0;
}
|
#include <bits/stdc++.h>
struct MI {
private:
char bb[1 << 14];
FILE *f;
char *bs, *be;
char e;
bool o, l;
public:
MI() : f(stdin), bs(0), be(0) {}
inline char get() {
if (o) {
o = 0;
return e;
}
if (bs == be) be = (bs = bb) + fread(bb, 1, sizeof(bb), f);
if (bs == be) {
l = 1;
return -1;
};
return *bs++;
}
inline void unget(char c) {
o = 1;
e = c;
}
template <class T>
inline T read() {
T r;
*this > r;
return r;
}
template <class T>
inline MI &operator>(T &);
};
template <class T>
struct Q {
const static bool U = T(-1) >= T(0);
inline void operator()(MI &t, T &r) const {
r = 0;
char c;
bool y = 0;
if (U)
for (;;) {
c = t.get();
if (c == -1) goto E;
if (isdigit(c)) break;
}
else
for (;;) {
c = t.get();
if (c == -1) goto E;
if (c == '-') {
c = t.get();
if (isdigit(c)) {
y = 1;
break;
};
} else if (isdigit(c))
break;
;
};
for (;;) {
if (c == -1) goto E;
if (isdigit(c))
r = r * 10 + (c ^ 48);
else
break;
c = t.get();
}
t.unget(c);
E:;
if (y) r = -r;
}
};
template <>
struct Q<char> {};
template <class T>
inline MI &MI::operator>(T &t) {
Q<T>()(*this, t);
return *this;
}
template <class T>
std::ostream &operator<(std::ostream &out, const T &t) {
return out << t;
}
using std::cout;
MI cin;
const int $n = 100005;
template <typename T>
inline bool gmax(T &a, const T &b) {
return a < b && (a = b, true);
}
int n, m, p[$n], dep[$n], vis[$n], cnt[$n], rea[$n], T;
std::vector<int> outs[$n];
std::mt19937 rng(std::chrono::steady_clock::now().time_since_epoch().count());
bool check(int x) {
static bool ex[$n];
vis[x] = T;
ex[x] = 1;
for (int v : outs[x])
if ((vis[v] == T) ? !ex[v] : !check(v)) {
ex[x] = 0;
return 0;
}
ex[x] = 0;
return 1;
}
void dfs(int x) {
vis[x] = T;
rea[x] = x;
cnt[x] = 0;
for (int v : outs[x]) {
if (vis[v] == T) {
++cnt[x];
--cnt[v];
if (dep[v] < dep[rea[x]]) rea[x] = v;
} else {
dep[v] = dep[x] + 1;
dfs(v);
cnt[x] += cnt[v];
if (dep[rea[v]] < dep[rea[x]]) rea[x] = rea[v];
}
}
}
void load(int x) {
gmax(cnt[x], cnt[rea[x]]);
for (int v : outs[x])
if (dep[v] == dep[x] + 1) load(v);
}
inline void work() {
cin > n > m;
for (auto __r = (n), i = (1); i <= __r; ++i) outs[i].clear();
for (auto __r = (m), i = (1); i <= __r; ++i) {
const auto x = (cin.read<int>()), y = (cin.read<int>());
outs[x].push_back(y);
}
std::iota(p + 1, p + n + 1, 1);
std::shuffle(p + 1, p + n + 1, rng);
int rt = 0;
for (auto __r = (std::min(n, 100)), i = (1); i <= __r; ++i)
if (++T, check(p[i])) {
rt = p[i];
break;
}
if (!rt) return (void)(cout < "-1\n");
dep[rt] = 1;
++T;
dfs(rt);
load(rt);
int c = 0;
for (auto __r = (n), i = (1); i <= __r; ++i) c += cnt[i] <= 1;
if (c * 5 < n) return (void)(cout < "-1\n");
for (auto __r = (n), i = (1); i <= __r; ++i)
if (cnt[i] <= 1) cout < i < " \n"[!--c];
}
int main() {
for (auto __r = ((cin.read<int>())), i = (1); i <= __r; ++i) work();
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
const long long INF = 0x3f3f3f3f3f3f3f3f;
const long long llinf = (1LL << 62);
const int inf = (1 << 30);
const int nmax = 1e5 + 50;
const long long mod = 1e9 + 7;
using namespace std;
int n, m, viz[nmax], bd[nmax], x, y, i, j, t, bl, insert[nmax], out[nmax], tt,
lvl[nmax], rs, ts, nd[nmax];
pair<int, int> vl[nmax];
vector<int> a[nmax], vec, rd;
void dfs(int x, int p) {
viz[x] = 1;
lvl[x] = lvl[p] + 1;
insert[x] = ++tt;
for (int i = 0; i < (int)a[x].size(); i++) {
int y = a[x][i];
if (viz[y]) continue;
dfs(y, x);
}
out[x] = ++tt;
}
void asd(int x) {
viz[x] = 1;
vl[x] = make_pair(inf, inf);
vector<int> vc;
for (int i = 0; i < (int)a[x].size(); i++) {
int y = a[x][i];
vc.push_back(lvl[y]);
if (!viz[y]) {
asd(y);
vc.push_back(vl[y].first), vc.push_back(vl[y].second);
}
sort(vc.begin(), vc.end());
while ((int)vc.size() > 2) vc.pop_back();
}
if ((int)vc.size() == 1)
vl[x].first = vc[0];
else if ((int)vc.size() == 2)
vl[x] = make_pair(vc[0], vc[1]);
if (vl[x].first < lvl[x] && vl[x].second < lvl[x]) bd[x] = 1;
}
void sdf(int x) {
viz[x] = 1;
nd[lvl[x]] = x;
if (vl[x].first != inf) bd[x] |= bd[nd[vl[x].first]];
for (int i = 0; i < (int)a[x].size(); i++) {
int y = a[x][i];
if (viz[y]) continue;
sdf(y);
}
}
int main() {
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
ios_base::sync_with_stdio(false);
cin.tie(0);
cerr.tie(0);
cout.tie(0);
cin >> ts;
while (ts--) {
cin >> n >> m;
for (i = 1; i <= n; i++) a[i].clear();
while (m--) {
cin >> x >> y;
a[x].push_back(y);
}
rd.clear();
for (i = 1; i <= n; i++) rd.push_back(i);
shuffle(rd.begin(), rd.end(), rng);
rs = 0, vec.clear();
for (i = 0; i < min(50, n); i++) {
x = rd[i];
tt = 0;
for (j = 1; j <= n; j++) {
viz[j] = 0;
lvl[j] = 0;
}
dfs(x, x);
bl = 0;
for (j = 1; j <= n; j++) {
for (t = 0; t < (int)a[j].size(); t++) {
y = a[j][t];
if (!(insert[y] <= insert[j] && out[j] <= out[y]) &&
!(insert[j] <= insert[y] && out[y] <= out[j])) {
bl = 1;
break;
}
if (insert[j] <= insert[y] && out[y] <= out[j] &&
lvl[y] != lvl[j] + 1) {
bl = 1;
break;
}
}
if (bl) break;
}
if (bl) continue;
for (j = 1; j <= n; j++) viz[j] = bd[j] = 0;
asd(x);
for (j = 1; j <= n; j++) viz[j] = 0;
sdf(x);
for (j = 1; j <= n; j++)
if (!bd[j]) rs++, vec.push_back(j);
break;
}
if (rs <= (n - 1) / 5)
cout << -1 << '\n';
else {
for (j = 0; j < rs; j++) cout << vec[j] << " ";
cout << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <class t, class u>
void chmax(t& first, u second) {
if (first < second) first = second;
}
template <class t, class u>
void chmin(t& first, u second) {
if (second < first) first = second;
}
template <class t>
using vc = vector<t>;
template <class t>
using vvc = vc<vc<t>>;
using pi = pair<int, int>;
using vi = vc<int>;
template <class t, class u>
ostream& operator<<(ostream& os, const pair<t, u>& p) {
return os << "{" << p.first << "," << p.second << "}";
}
template <class t>
ostream& operator<<(ostream& os, const vc<t>& v) {
os << "{";
for (auto e : v) os << e << ",";
return os << "}";
}
using uint = unsigned;
using ull = unsigned long long;
template <class t, size_t n>
ostream& operator<<(ostream& os, const array<t, n>& first) {
return os << vc<t>(first.begin(), first.end());
}
template <int i, class T>
void print_tuple(ostream&, const T&) {}
template <int i, class T, class H, class... Args>
void print_tuple(ostream& os, const T& t) {
if (i) os << ",";
os << get<i>(t);
print_tuple<i + 1, T, Args...>(os, t);
}
template <class... Args>
ostream& operator<<(ostream& os, const tuple<Args...>& t) {
os << "{";
print_tuple<0, tuple<Args...>, Args...>(os, t);
return os << "}";
}
template <class t>
void print(t x, int suc = 1) {
cout << x;
if (suc == 1) cout << "\n";
if (suc == 2) cout << " ";
}
ll read() {
ll i;
cin >> i;
return i;
}
vi readvi(int n, int off = 0) {
vi v(n);
for (int i = int(0); i < int(n); i++) v[i] = read() + off;
return v;
}
template <class T>
void print(const vector<T>& v, int suc = 1) {
for (int i = int(0); i < int(v.size()); i++)
print(v[i], i == int(v.size()) - 1 ? suc : 2);
}
string readString() {
string s;
cin >> s;
return s;
}
template <class T>
T sq(const T& t) {
return t * t;
}
void yes(bool ex = true) {
cout << "Yes"
<< "\n";
if (ex) exit(0);
}
void no(bool ex = true) {
cout << "No"
<< "\n";
if (ex) exit(0);
}
void possible(bool ex = true) {
cout << "Possible"
<< "\n";
if (ex) exit(0);
}
void impossible(bool ex = true) {
cout << "Impossible"
<< "\n";
if (ex) exit(0);
}
constexpr ll ten(int n) { return n == 0 ? 1 : ten(n - 1) * 10; }
const ll infLL = LLONG_MAX / 3;
const int inf = INT_MAX / 2 - 100;
int topbit(signed t) { return t == 0 ? -1 : 31 - __builtin_clz(t); }
int topbit(ll t) { return t == 0 ? -1 : 63 - __builtin_clzll(t); }
int botbit(signed first) { return first == 0 ? 32 : __builtin_ctz(first); }
int botbit(ll first) { return first == 0 ? 64 : __builtin_ctzll(first); }
int popcount(signed t) { return __builtin_popcount(t); }
int popcount(ll t) { return __builtin_popcountll(t); }
bool ispow2(int i) { return i && (i & -i) == i; }
ll mask(int i) { return (ll(1) << i) - 1; }
bool inc(int first, int second, int c) {
return first <= second && second <= c;
}
template <class t>
void mkuni(vc<t>& v) {
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
}
ll rand_int(ll l, ll r) {
static mt19937_64 gen(chrono::steady_clock::now().time_since_epoch().count());
return uniform_int_distribution<ll>(l, r)(gen);
}
template <class t>
void myshuffle(vc<t>& first) {
for (int i = int(0); i < int(int(first.size())); i++)
swap(first[i], first[rand_int(0, i)]);
}
template <class t>
int lwb(const vc<t>& v, const t& first) {
return lower_bound(v.begin(), v.end(), first) - v.begin();
}
const int nmax = 100010;
vi g[nmax];
int sum[nmax], vis[nmax], up[nmax];
bool ok;
void dfs(int v) {
assert(vis[v] == -1);
vis[v] = 0;
for (auto to : g[v]) {
if (vis[to] == -1) {
dfs(to);
sum[v] += sum[to];
up[v] += up[to];
} else if (vis[to] == 0) {
sum[v]++;
sum[to]--;
up[v] += to;
up[to] -= to;
} else {
ok = false;
}
if (!ok) return;
}
vis[v] = 1;
}
bool good[nmax];
void dfs2(int v) {
assert(vis[v] == -1);
vis[v] = 0;
if (sum[v] >= 2) good[v] = 0;
if (sum[v] == 1) good[v] &= good[up[v]];
for (auto to : g[v]) {
if (vis[to] == -1) {
dfs2(to);
} else if (vis[to] == 0) {
} else {
assert(false);
}
}
vis[v] = 1;
}
void slv() {
int n, m;
cin >> n >> m;
for (int i = int(0); i < int(n); i++) {
g[i].clear();
}
for (int i = int(0); i < int(m); i++) {
int first, second;
cin >> first >> second;
first--;
second--;
g[first].push_back(second);
}
vi idx(n);
iota(idx.begin(), idx.end(), 0);
myshuffle(idx);
for (int _ = int(0); _ < int(min(n, 100)); _++) {
int r = idx[_];
for (int i = int(0); i < int(n); i++) {
sum[i] = 0;
vis[i] = -1;
up[i] = 0;
}
ok = true;
dfs(r);
if (ok) {
for (int i = int(0); i < int(n); i++) {
vis[i] = -1;
good[i] = 1;
}
dfs2(r);
vi ans;
for (int i = int(0); i < int(n); i++)
if (good[i]) ans.push_back(i + 1);
if (int(ans.size()) * 5 < n) {
print(-1);
} else {
print(ans);
}
return;
}
}
print(-1);
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(0);
cout << fixed << setprecision(20);
int t;
cin >> t;
for (int _ = int(0); _ < int(t); _++) slv();
}
|
#include <bits/stdc++.h>
const int max_N = 102401;
int n, m, dfn[max_N], Idfn[max_N], fa[max_N], dep[max_N];
std::vector<int> G[max_N], ans;
bool ok, ins[max_N];
int read() {
char c = getchar();
int ans = 0;
bool flag = true;
while (!isdigit(c)) flag &= (c != '-'), c = getchar();
while (isdigit(c)) ans = 10 * ans + c - '0', c = getchar();
return flag ? ans : -ans;
}
void Write(int x) {
if (x < 0) putchar('-'), x = -x;
if (x < 10)
putchar(x + '0');
else
Write(x / 10), putchar(x % 10 + '0');
}
int min(int x, int y) { return x < y ? x : y; }
int max(int x, int y) { return x > y ? x : y; }
void _min(int &x, int y) {
if (x > y) x = y;
}
void _max(int &x, int y) {
if (x < y) x = y;
}
std::mt19937_64 rnd(
std::chrono::steady_clock::now().time_since_epoch().count());
int Random(int l, int r) { return rnd() % (r - l + 1) + l; }
void dfs1(int x) {
Idfn[dfn[x] = ++*dfn] = x, ins[x] = true;
for (auto i : G[x])
if (!dfn[i])
fa[i] = x, dep[i] = dep[x] + 1, dfs1(i);
else if (dfn[i] && !ins[i])
ok = false;
ins[x] = false;
}
bool check(int x) {
ok = true;
std::fill(dfn + 1, dfn + n + 1, 0);
for (int i = 1; i <= n; i++) assert(!ins[i]);
if (*dfn = 0, dep[x] = 0, dfs1(x), *dfn < n) return false;
for (int i = 1; i <= n; i++)
for (auto j : G[i])
if (dfn[i] < dfn[j] && fa[j] != i) return false;
return ok;
}
void solve(int x) {
static bool flag[max_N];
static int num[max_N], link[max_N];
for (int i = 1; i <= n; i++) flag[i] = false, num[i] = link[i] = 0;
flag[x] = true, ans.push_back(x);
for (int i = n; i > 1; i--) {
for (auto j : G[Idfn[i]])
if (dfn[j] > i) {
num[Idfn[i]] += num[j];
if (!link[Idfn[i]] || dep[link[Idfn[i]]] > dep[link[j]])
link[Idfn[i]] = link[j];
}
for (auto j : G[Idfn[i]])
if (dfn[j] < i) {
num[Idfn[i]]++, num[j]--;
if (!link[Idfn[i]] || dep[link[Idfn[i]]] > dep[j]) link[Idfn[i]] = j;
}
}
for (int i = 2; i <= n; i++)
if (num[Idfn[i]] == 1 && flag[link[Idfn[i]]])
flag[Idfn[i]] = true, ans.push_back(Idfn[i]);
std::sort(ans.begin(), ans.end());
}
void clear() {
for (int i = 1; i <= n; i++)
G[i].clear(), dfn[i] = Idfn[i] = dep[i] = fa[i] = 0;
ans.clear();
}
int main() {
int q = read();
while (q--) {
n = read(), m = read();
for (int i = 1, u, v; i <= m; i++)
u = read(), v = read(), G[u].push_back(v);
for (int _ = 1; _ <= 100; _++) {
int x = Random(1, n);
if (check(x)) {
solve(x);
break;
}
}
if (ans.size() >= (n + 4) / 5)
for (auto i : ans) Write(i), putchar(' ');
else
putchar('-'), putchar('1');
putchar('\n');
clear();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int T, n, m, i, j, k, l, rt, sum;
int a[200001][2], ls[100001], len;
int d[100001], Sum[100001], fa[100001], Fa[100001], dp[100001], tot;
bool bz[100001], bzin[100001], bz2[200001], ans[100001], Bz;
int Id[100001];
namespace G {
int a[1000001][2], ls[100001], len;
void clear() {
len = 0;
memset(ls, 0, (n + 1) * 4);
}
void New(int x, int y) {
++len;
a[len][0] = y;
a[len][1] = ls[x];
ls[x] = len;
}
void bfs(int st) {
int i, j, k, l, h = 0, t = 1;
static int d[100001];
d[1] = st;
ans[st] = 1;
while (h < t) {
for (i = ls[d[++h]]; i; i = a[i][1])
if (!ans[a[i][0]]) {
ans[a[i][0]] = 1;
d[++t] = a[i][0];
}
}
}
} // namespace G
void New(int x, int y) {
++len;
a[len][0] = y;
a[len][1] = ls[x];
ls[x] = len;
}
void dfs(int t) {
int i;
bz[t] = 1;
d[++tot] = t;
bzin[t] = 1;
for (i = ls[t]; i; i = a[i][1])
if (!bz[a[i][0]])
dfs(a[i][0]);
else if (!bzin[a[i][0]])
Bz = 0;
--tot;
bzin[t] = 0;
}
void Dfs(int t) {
int i;
bz[t] = 1;
for (i = ls[t]; i; i = a[i][1])
if (!bz[a[i][0]])
dp[a[i][0]] = dp[t] + 1, fa[a[i][0]] = t, bz2[i] = 1, Dfs(a[i][0]),
Sum[t] += Sum[a[i][0]];
else
++Sum[t], --Sum[a[i][0]];
}
void Dfs2(int t, int Ls) {
int i;
Fa[t] = Ls;
for (i = ls[t]; i; i = a[i][1])
if (bz2[i]) Dfs2(a[i][0], Sum[t] == 1 ? t : Ls);
}
bool pd(int t) {
int i;
memset(bz, 0, n + 1);
Bz = 1;
dfs(t);
return Bz;
}
int main() {
srand(time(NULL));
scanf("%d", &T);
for (; T; --T) {
scanf("%d%d", &n, &m);
len = 0;
memset(ls, 0, (n + 1) * 4);
memset(ans, 0, n + 1);
memset(bz2, 0, m + 1);
memset(Sum, 0, (n + 1) * 4);
for (i = 1; i <= m; i++) scanf("%d%d", &j, &k), New(j, k);
for (i = 1; i <= n; i++) Id[i] = i;
random_shuffle(Id + 1, Id + n + 1);
l = (100 < n ? 100 : n);
for (i = 1; i <= l; i++)
if (pd(Id[i])) break;
if (i > l)
printf("-1\n");
else {
rt = Id[i];
sum = 0;
fa[rt] = Fa[rt] = 0;
dp[rt] = 1;
memset(bz, 0, n + 1);
Dfs(rt);
Dfs2(rt, 0);
G::clear();
for (i = 1; i <= n; i++) {
for (l = ls[i]; l; l = a[l][1])
if (dp[a[l][0]] < dp[i]) {
j = i;
while (dp[j] > dp[a[l][0]]) {
if (Sum[j] == 1) G::New(a[l][0], j);
j = Fa[j];
}
}
}
G::bfs(rt);
for (i = 1; i <= n; i++) sum += ans[i];
if (sum < (double)n / 5)
printf("-1\n");
else {
for (i = 1; i <= n; i++)
if (ans[i]) printf("%d ", i);
printf("\n");
}
}
}
fclose(stdin);
fclose(stdout);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 1000000007;
const int MM = 998244353;
const long double PI = acos(-1);
template <typename T, typename U>
static inline void amin(T &x, U y) {
if (y < x) x = y;
}
template <typename T, typename U>
static inline void amax(T &x, U y) {
if (x < y) x = y;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
return os << '(' << p.first << "," << p.second << ')';
}
mt19937 rng(chrono::high_resolution_clock::now().time_since_epoch().count());
const int N = 100005;
vector<int> v[N];
pair<int, int> back[N];
int dep[N], in[N], cur, out[N], dp[N], par[N];
bool vis[N];
vector<int> t;
void dfs(int s) {
t.push_back(s);
vis[s] = true;
in[s] = cur++;
dp[s] = 0;
back[s] = {N, N};
for (auto j : v[s]) {
if (!vis[j]) {
dep[j] = dep[s] + 1;
par[j] = s;
dfs(j);
dp[s] += dp[j];
amin(back[s], back[j]);
} else {
++dp[s];
--dp[j];
amin(back[s], make_pair(dep[j], j));
}
}
out[s] = cur - 1;
}
int _runtimeTerror_() {
int n, m;
cin >> n >> m;
vector<pair<int, int> > ed;
for (int i = 1; i <= n; ++i) {
v[i].clear();
back[i] = {N, N};
dep[i] = 0;
}
while (m--) {
int x, y;
cin >> x >> y;
v[x].push_back(y);
ed.push_back({x, y});
}
auto ancestor = [&](int x, int y) {
return in[y] >= in[x] && in[y] <= out[x];
};
int cutoff = 1;
while (cutoff * 5 < n) ++cutoff;
vector<bool> checked(n + 1, false), interested(n + 1, true);
vector<int> ans;
for (int it = 0; it <= 50; ++it) {
int u = rng() % n + 1;
if (checked[u]) continue;
for (int i = 1; i <= n; ++i)
dep[i] = 0, back[i] = {N, N}, in[i] = 0, vis[i] = false, dp[i] = 0,
par[i] = 0;
cur = 0;
t.clear();
dfs(u);
checked[u] = true;
bool can = true;
for (auto &j : ed) {
if (j.first == par[j.second] || j.second == par[j.first]) continue;
if (!ancestor(j.second, j.first)) {
can = false;
break;
}
}
if (!can) continue;
interested[u] = true;
ans.push_back(u);
for (int i = 1; i < n; ++i) {
if (dp[t[i]] >= 2) {
interested[t[i]] = false;
} else {
assert(dp[t[i]] == 1);
interested[t[i]] = interested[back[t[i]].second];
}
if (interested[t[i]]) ans.push_back(t[i]);
}
if ((long long)ans.size() < cutoff) ans.clear();
break;
}
if (ans.empty()) {
cout << "-1\n";
return 0;
}
sort(ans.begin(), ans.end());
for (auto j : ans) cout << j << " ";
cout << "\n";
return 0;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int TESTS = 1;
cin >> TESTS;
while (TESTS--) _runtimeTerror_();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int sz = 1e5 + 10;
vector<int> sv[sz];
int us[sz], h[sz], mi[sz][2];
bool dfs(int v) {
us[v] = 1;
mi[v][0] = v, mi[v][1] = v;
for (int a = 0; a < sv[v].size(); a++) {
int ne = sv[v][a];
if (us[ne] == 2) return false;
if (us[ne] == 1) {
if (h[ne] < h[mi[v][0]])
mi[v][1] = mi[v][0], mi[v][0] = ne;
else if (h[ne] < h[mi[v][1]])
mi[v][1] = ne;
}
if (us[ne] == 0) {
h[ne] = h[v] + 1;
if (!dfs(ne)) return false;
for (int i = 0; i < 2; i++) {
int u = mi[ne][i];
if (h[u] < h[mi[v][0]])
mi[v][1] = mi[v][0], mi[v][0] = u;
else if (h[u] < h[mi[v][1]])
mi[v][1] = u;
}
}
}
us[v] = 2;
return true;
}
bool ok[sz];
vector<int> an;
void dfs2(int v) {
us[v] = 1;
if (mi[v][0] != v and mi[v][1] == v and ok[mi[v][0]]) {
ok[v] = 1;
an.push_back(v + 1);
}
for (int a = 0; a < sv[v].size(); a++) {
int ne = sv[v][a];
if (!us[ne]) dfs2(ne);
}
}
mt19937 rnd(time(0));
int main() {
int T;
cin >> T;
while (T--) {
int n, m;
cin >> n >> m;
for (int a = 0; a < m; a++) {
int u, v;
scanf("%d%d", &u, &v);
u--, v--;
sv[u].push_back(v);
}
for (int i = 0; i < 40; i++) {
int rt = rnd() % n;
for (int a = 0; a < n; a++) us[a] = 0;
h[rt] = 0;
if (dfs(rt)) {
for (int a = 0; a < n; a++) ok[a] = 0, us[a] = 0;
ok[rt] = 1, an.push_back(rt + 1);
dfs2(rt);
break;
}
}
if (an.size() == 0 or an.size() * 5 < n)
printf("-1\n");
else {
sort(an.begin(), an.end());
for (int a = 0; a < an.size(); a++) printf("%d ", an[a]);
printf("\n");
}
an.clear();
for (int a = 0; a < n; a++) sv[a].clear();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int T, n, m, f[N], p[N], fa[N], dep[N];
bool fail, o[N], g[N], vis[N];
vector<int> e[N];
void update(int &a, int &b, int x) {
if (dep[x] < dep[a])
b = a, a = x;
else if (dep[x] < dep[b])
b = x;
}
pair<int, int> dfs(int u) {
vis[u] = 1, o[u] = 1;
int m1 = 0, m2 = 0;
for (int v : e[u])
if (!vis[v]) {
dep[v] = dep[u] + 1, fa[v] = u;
auto x = dfs(v);
update(m1, m2, x.first), update(m1, m2, x.second);
} else if (o[v])
update(m1, m2, v);
else
fail = 1;
if (m2 == u) m2 = 0;
if (m1 == u) m1 = 0;
if (m1 && !m2) f[u] = m1;
o[u] = 0;
return make_pair(m1, m2);
}
void dfs2(int u) {
g[u] |= g[f[u]];
for (int v : e[u])
if (fa[v] == u) dfs2(v);
}
bool check(int x) {
dep[0] = 1e9;
fa[x] = dep[x] = fail = 0, memset(f + 1, 0, n << 2), memset(vis + 1, 0, n),
dfs(x);
if (fail) return 0;
memset(g + 1, 0, n), g[x] = 1, dfs2(x);
int ans = 0;
for (int i = 1; i <= n; ++i) ans += g[i];
if (ans * 5 < n)
puts("-1");
else
for (int i = 1; i <= n; ++i)
if (g[i]) printf("%d%c", i, " \n"[!--ans]);
return 1;
}
int main() {
mt19937 rng(chrono::system_clock().now().time_since_epoch().count());
scanf("%d", &T);
while (T--) {
scanf("%d%d", &n, &m);
for (int i = 1, x, y; i <= m; ++i) scanf("%d%d", &x, &y), e[x].push_back(y);
for (int i = 1; i <= n; ++i) p[i] = i;
shuffle(p + 1, p + n + 1, rng);
for (int i = 1; i <= 100 && i <= n; ++i)
if (check(p[i])) break;
if (fail) puts("-1");
for (int i = 1; i <= n; ++i) e[i].clear();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T &n) {
T w = 1;
n = 0;
char ch = getchar();
while (!isdigit(ch) && ch != EOF) {
if (ch == '-') w = -1;
ch = getchar();
}
while (isdigit(ch) && ch != EOF) {
n = (n << 3) + (n << 1) + (ch & 15);
ch = getchar();
}
n *= w;
}
template <typename T>
inline void write(T x) {
T l = 0;
unsigned long long y = 0;
if (!x) {
putchar(48);
return;
}
if (x < 0) {
x = -x;
putchar('-');
}
while (x) {
y = y * 10 + x % 10;
x /= 10;
++l;
}
while (l) {
putchar(y % 10 + 48);
y /= 10;
--l;
}
}
template <typename T>
inline void writes(T x) {
write(x);
putchar(' ');
}
template <typename T>
inline void writeln(T x) {
write(x);
puts("");
}
template <typename T>
inline void checkmax(T &a, T b) {
a = a > b ? a : b;
}
template <typename T>
inline void checkmin(T &a, T b) {
a = a < b ? a : b;
}
const int N = 1e5 + 10, M = 2e5 + 10;
int n, m, cnt, head[N], nxt[M << 1], to[M << 1], vis[N], in[N], dep[N],
depth[N], depto[N], sum[N], ok[N];
inline int rd() {
return int((long long)(rand() % 100000) * (rand() % 100000) % 998244353);
}
inline void addedge(int x, int y) {
nxt[++cnt] = head[x];
to[cnt] = y;
head[x] = cnt;
}
inline bool check(int x) {
vis[x] = in[x] = 1;
bool f = 1;
for (int i = head[x]; i; i = nxt[i]) {
if (vis[to[i]] && !in[to[i]]) return 0;
if (vis[to[i]]) continue;
f &= check(to[i]);
}
in[x] = 0;
return f;
}
inline void dfs(int x) {
vis[x] = 1;
for (int i = head[x]; i; i = nxt[i]) {
if (vis[to[i]]) {
if (depth[to[i]] < dep[x]) {
dep[x] = depth[to[i]];
depto[x] = to[i];
}
sum[x]++;
sum[to[i]]--;
continue;
}
depth[to[i]] = depth[x] + 1;
dfs(to[i]);
sum[x] += sum[to[i]];
if (dep[x] > dep[to[i]]) {
dep[x] = dep[to[i]];
depto[x] = depto[to[i]];
}
}
}
inline void dfs2(int x) {
vis[x] = 1;
if (sum[x] >= 2 || (sum[x] == 1 && ok[depto[x]])) ok[x] = 1;
for (int i = head[x]; i; i = nxt[i]) {
if (vis[to[i]]) continue;
dfs2(to[i]);
}
}
inline void doit(int rt) {
for (int i = 1; i <= n; ++i) {
vis[i] = sum[i] = ok[i] = 0;
dep[i] = n * 2 + 1;
}
depth[rt] = 0;
dfs(rt);
for (int i = 1; i <= n; ++i) vis[i] = 0;
dfs2(rt);
int ans = 0;
for (int i = 1; i <= n; ++i)
if (!ok[i]) ++ans;
if (ans * 5 < n) {
puts("-1");
return;
}
for (int i = 1; i <= n; ++i)
if (!ok[i]) writes(i);
puts("");
}
inline void solve() {
read(n);
read(m);
for (int i = 1; i <= n; ++i) head[i] = vis[i] = in[i] = 0;
cnt = 0;
for (int i = 1; i <= m; ++i) {
int x, y;
read(x);
read(y);
addedge(x, y);
}
for (int i = 1; i <= 50; ++i) {
int num = rd() % n + 1;
for (int i = 1; i <= n; ++i) vis[i] = in[i] = 0;
if (check(num)) {
doit(num);
return;
}
}
puts("-1");
}
int main() {
srand(time(0) + 1432433);
int t;
read(t);
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long t, n, m, u, v, q, k, p;
const int N = 1e6 + 1e5 + 500;
const long long mod = 1e9 + 7;
const long long INF = 1LL << 57;
long long arr[N];
vector<int> adj[N], ancestors[N];
bool anc[N], vis[N], isValid, isInteresting[N];
int degree[N];
bool cmp(int a, int b) { return degree[a] < degree[b]; }
void dfs(int node) {
vis[node] = true;
anc[node] = true;
for (int u : adj[node]) {
if (vis[u]) {
if (anc[u])
continue;
else
isValid = false;
} else {
dfs(u);
}
}
anc[node] = false;
}
void dfs(int node, int deg) {
vis[node] = true;
anc[node] = true;
degree[node] = deg;
for (int u : adj[node]) {
if (vis[u]) {
ancestors[node].push_back(u);
} else {
dfs(u, deg + 1);
for (int v : ancestors[u]) {
if (v != node) ancestors[node].push_back(v);
}
}
}
sort(ancestors[node].begin(), ancestors[node].end(), cmp);
while (ancestors[node].size() > 2) ancestors[node].pop_back();
}
inline int getInt(int a = INT_MIN, int b = INT_MAX) {
static mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
return uniform_int_distribution<int>(a, b)(rng);
}
void solve(int node) {
vis[node] = true;
if (ancestors[node].size() == 0)
;
else if (ancestors[node].size() >= 2)
isInteresting[node] = false;
else {
isInteresting[node] = isInteresting[ancestors[node][0]];
}
for (int u : adj[node]) {
if (vis[u])
continue;
else
solve(u);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> t;
while (t--) {
cin >> n >> m;
for (int i = 1; i <= n; ++i) {
adj[i].clear();
ancestors[i].clear();
degree[i] = 0;
isInteresting[i] = false;
}
for (int i = 1; i <= m; ++i) {
cin >> u >> v;
adj[u].push_back(v);
}
bool hasInteresting = false;
int interestingNode = 0;
for (int i = 1; i <= 100; ++i) {
int node = getInt(1, n);
for (int j = 1; j <= n; ++j) vis[j] = false;
isValid = true;
dfs(node);
for (int j = 1; j <= n; ++j)
if (vis[j] == false) isValid = false;
if (isValid) {
hasInteresting = true;
interestingNode = node;
break;
}
}
if (!hasInteresting) {
cout << -1 << '\n';
continue;
}
isInteresting[interestingNode] = true;
for (int j = 1; j <= n; ++j) vis[j] = false;
dfs(interestingNode, 0);
for (int j = 1; j <= n; ++j) vis[j] = false;
solve(interestingNode);
vector<int> interesting;
for (int i = 1; i <= n; ++i)
if (isInteresting[i]) interesting.push_back(i);
if (interesting.size() >= ceil(0.2 * n)) {
sort(interesting.begin(), interesting.end());
for (int u : interesting) cout << u << " ";
cout << '\n';
} else
cout << -1 << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 100005;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int n, m, x[MX], y[MX], lvl[MX], q[MX], vis[MX], res[MX], anc[MX], cn;
vector<int> adj[MX];
void clear() {
for (int i = 1; i <= n; i++) adj[i].clear();
iota(q, q + n, 1);
shuffle(q, q + n, rng);
}
void add(int u, int k) {
if (x[u] > k) {
y[u] = x[u];
x[u] = k;
} else if (y[u] > k) {
y[u] = k;
}
}
bool dfs(int u) {
cn++;
vis[u] = 1;
x[u] = y[u] = MX;
for (int v : adj[u]) {
if (vis[v] == 2) return 0;
if (vis[v]) {
add(u, lvl[v]);
continue;
}
lvl[v] = lvl[u] + 1;
if (!dfs(v)) return 0;
add(u, x[v]);
add(u, y[v]);
}
if (x[u] == lvl[u]) x[u] = MX;
if (y[u] == lvl[u]) y[u] = MX;
if (y[u] < MX) res[u] = 0;
vis[u] = 2;
return 1;
}
void dfs2(int u) {
vis[u] = 1;
anc[lvl[u]] = u;
if (res[u] == -1 && lvl[u]) {
if (x[u] < MX)
res[u] = res[anc[x[u]]];
else
res[u] = 0;
}
for (int v : adj[u])
if (!vis[v]) dfs2(v);
}
void solve() {
cin >> n >> m;
clear();
while (m--) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
}
for (int i = 0; i < min(n, 80); i++) {
for (int j = 0; j < n; j++) vis[j + 1] = 0, res[j + 1] = -1;
lvl[q[i]] = 0;
cn = 0;
if (!dfs(q[i]) || cn < n) continue;
res[q[i]] = 1;
for (int j = 0; j < n; j++) vis[j + 1] = 0;
dfs2(q[i]);
vector<int> r;
for (int j = 1; j <= n; j++)
if (res[j] == 1) r.push_back(j);
if (5 * r.size() < n)
cout << -1 << '\n';
else {
for (int x : r) cout << x << " ";
cout << '\n';
}
return;
}
cout << -1 << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(
(unsigned int)chrono::steady_clock::now().time_since_epoch().count());
const int MAGIC = 239;
const int N = 100010;
vector<int> g[N];
bool in_st[N];
bool was[N];
bool dfs(int v) {
was[v] = true;
in_st[v] = true;
for (int u : g[v]) {
if (was[u]) {
if (!in_st[u]) {
in_st[v] = false;
return false;
}
} else {
if (!dfs(u)) {
in_st[v] = false;
return false;
}
}
}
in_st[v] = false;
return true;
}
vector<int> vis;
int depth[N];
int md[N];
int md2[N];
int mver[N];
int mver2[N];
void Update(int v, int x, int y) {
if (x < md[v]) {
md2[v] = md[v];
mver2[v] = mver[v];
md[v] = x;
mver[v] = y;
} else {
if (x < md2[v]) {
md2[v] = x;
mver2[v] = y;
}
}
}
void solve(int v) {
vis.push_back(v);
was[v] = true;
md[v] = md2[v] = depth[v];
mver[v] = mver2[v] = v;
for (int u : g[v]) {
if (was[u]) {
assert(depth[u] < depth[v]);
Update(v, depth[u], u);
} else {
depth[u] = depth[v] + 1;
solve(u);
Update(v, md[u], mver[u]);
Update(v, md2[u], mver2[u]);
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int tt;
cin >> tt;
while (tt--) {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
g[i].clear();
}
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
--x;
--y;
g[x].push_back(y);
}
vector<int> order(n);
iota(order.begin(), order.end(), 0);
shuffle(order.begin(), order.end(), rng);
int root = -1;
for (int iter = 0; iter < min(n, MAGIC); iter++) {
for (int i = 0; i < n; i++) {
was[i] = in_st[i] = false;
}
if (dfs(order[iter])) {
root = order[iter];
break;
}
}
if (root == -1) {
cout << -1 << '\n';
continue;
}
for (int i = 0; i < n; i++) {
was[i] = false;
}
vis.clear();
depth[root] = 0;
solve(root);
vector<bool> is_good(n);
for (int i : vis) {
if (i == root) {
is_good[i] = true;
} else {
if (md[i] < depth[i] && md2[i] >= depth[i]) {
is_good[i] = is_good[mver[i]];
} else {
is_good[i] = false;
}
}
}
vector<int> res;
for (int i = 0; i < n; i++) {
if (is_good[i]) {
res.push_back(i);
}
}
if ((int)res.size() * 5 < n) {
cout << -1 << '\n';
continue;
}
for (int i = 0; i < (int)res.size(); i++) {
if (i > 0) {
cout << " ";
}
cout << res[i] + 1;
}
cout << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 5;
int n, m;
int vis[MAXN], parent[MAXN], cnt[MAXN], rest[MAXN];
int level[MAXN];
bool is_inter[MAXN];
vector<vector<int>> adj;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
bool is_interesting(int u) {
vis[u] = 1;
for (auto v : adj[u]) {
if (vis[v] == 2) {
return false;
} else if (vis[v] == 1)
continue;
else if (!is_interesting(v))
return false;
}
vis[u] = 2;
return true;
}
int find_root() {
uniform_int_distribution<> dis(0, n - 1);
for (int i = 0; i < 100; i++) {
int u = dis(rng);
fill(vis, vis + n, 0);
if (is_interesting(u)) return u;
}
return -1;
}
pair<int, int> dfs(int u) {
vis[u] = 1;
cnt[u] = 0;
parent[u] = u;
for (auto v : adj[u]) {
if (vis[v] == 1) {
cnt[u]++;
rest[v]++;
if (level[v] < level[parent[u]]) parent[u] = v;
} else {
level[v] = level[u] + 1;
int _cnt, p;
tie(_cnt, p) = dfs(v);
cnt[u] += _cnt;
if (level[p] < level[parent[u]]) {
parent[u] = p;
}
}
}
cnt[u] -= rest[u];
return {cnt[u], parent[u]};
}
int get_ans(int u) {
vis[u] = 1;
int ans = 0;
if (cnt[u] == 0) {
ans++;
is_inter[u] = true;
}
if (cnt[u] == 1) {
if (is_inter[parent[u]]) {
ans++;
is_inter[u] = true;
}
}
int p = -1;
for (auto v : adj[u]) {
if (vis[v])
p = v;
else
ans += get_ans(v);
}
return ans;
}
int main() {
;
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int t;
cin >> t;
while (t--) {
cin >> n >> m;
adj.clear();
adj.resize(n);
fill(is_inter, is_inter + n, false);
fill(cnt, cnt + n, 0);
fill(rest, rest + n, 0);
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
adj[u].push_back(v);
}
int root = find_root();
if (root == -1) {
cout << "-1\n";
continue;
}
fill(vis, vis + n, 0);
level[root] = 0;
dfs(root);
fill(vis, vis + n, 0);
int cnt = get_ans(root);
if (5 * cnt < n)
cout << "-1\n";
else {
for (int u = 0; u < n; u++)
if (is_inter[u]) cout << u + 1 << ' ';
cout << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
namespace IO {
char gc() { return getchar(); }
template <typename Tp>
bool get1(Tp &x) {
bool neg = 0;
char c = gc();
while (c != EOF && (c < '0' || c > '9') && c != '-') c = gc();
if (c == '-') c = gc(), neg = 1;
if (c == EOF) return false;
x = 0;
for (; c >= '0' && c <= '9'; c = gc()) x = x * 10 + c - '0';
if (neg) x = -x;
return true;
}
template <typename Tp>
void printendl(Tp x) {
if (x < 0) putchar('-'), x = -x;
static short a[40], sz;
sz = 0;
while (x > 0) a[sz++] = x % 10, x /= 10;
if (sz == 0) putchar('0');
for (int i = sz - 1; i >= 0; i--) putchar('0' + a[i]);
puts("");
}
} // namespace IO
using IO::get1;
using IO::printendl;
const int inf = 0x3f3f3f3f;
const long long Linf = 1ll << 61;
const int maxn = 100111;
const int magic = 150;
std::mt19937 rng;
std::vector<int> g[maxn];
int n, m;
bool inst[maxn], use[maxn];
bool dfs(int x) {
inst[x] = use[x] = 1;
for (int i = 0; i < (int)g[x].size(); i++) {
if (!use[g[x][i]]) {
if (!dfs(g[x][i])) return false;
} else if (!inst[g[x][i]])
return false;
}
inst[x] = 0;
return true;
}
bool check(int x) {
memset(use, 0, sizeof(bool) * (n + 1));
memset(inst, 0, sizeof(bool) * (n + 1));
return dfs(x);
}
int dfn[maxn], low1[maxn], low2[maxn], seq[maxn], timer;
void update(int x, int v) {
if (low1[x] > v) {
low2[x] = low1[x];
low1[x] = v;
} else if (low2[x] > v)
low2[x] = v;
}
bool good[maxn];
void dfs2(int x) {
dfn[x] = low1[x] = low2[x] = ++timer;
seq[timer] = x;
for (int i = 0; i < (int)g[x].size(); i++) {
if (!dfn[g[x][i]]) {
dfs2(g[x][i]);
update(x, low1[g[x][i]]);
update(x, low2[g[x][i]]);
} else
update(x, dfn[g[x][i]]);
}
}
void solve() {
static int ord[maxn];
get1(n) && get1(m);
for (int i = 1; i <= n; i++) g[i].clear();
for (int i = 1, u, v; i <= m; i++) {
get1(u) && get1(v);
g[u].push_back(v);
}
for (int i = 1; i <= n; i++) ord[i] = i;
std::shuffle(ord + 1, ord + n + 1, rng);
int piv = 0;
for (int i = 1; i <= n && i <= magic; i++) {
if (check(ord[i])) {
piv = ord[i];
break;
}
}
if (piv == 0) {
puts("-1");
return;
}
memset(dfn, 0, sizeof(int) * (n + 1));
timer = 0;
dfs2(piv);
for (int t = 1; t <= n; t++) {
int x = seq[t];
if (x == piv)
good[x] = 1;
else if (low2[x] < dfn[x])
good[x] = 0;
else
good[x] = good[seq[low1[x]]];
}
int cnt = 0;
for (int i = 1; i <= n; i++) cnt += good[i];
if (cnt * 5 < n)
puts("-1");
else {
for (int i = 1; i <= n; i++)
if (good[i]) printf("%d ", i);
puts("");
}
}
int main() {
rng = std::mt19937(
std::chrono::steady_clock().now().time_since_epoch().count());
int tc;
get1(tc);
while (tc--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct edge {
int nxt, to, flag;
} e[200001];
int root, t, n, m, tot, h[100001], cnt, id[100001], s[100001], p[100001];
bool tag[100001];
vector<int> g[100001];
inline int read() {
int x = 0;
char c = getchar();
while (c < '0' || c > '9') c = getchar();
while (c >= '0' && c <= '9') {
x = (x << 1) + (x << 3) + (c ^ 48);
c = getchar();
}
return x;
}
inline void add(int x, int y) {
e[++tot].nxt = h[x];
h[x] = tot;
e[tot].to = y;
}
void dfs1(int k) {
id[k] = ++cnt;
s[k] = 1;
for (register int i = h[k]; i; i = e[i].nxt)
if (!id[e[i].to]) {
e[i].flag = 1;
dfs1(e[i].to);
s[k] += s[e[i].to];
}
}
bool dfs2(int k) {
for (register int i = h[k]; i; i = e[i].nxt)
if (e[i].flag) {
if (!dfs2(e[i].to)) return 0;
} else if (!(id[k] >= id[e[i].to] && id[k] <= id[e[i].to] + s[e[i].to] - 1))
return 0;
return 1;
}
void dfs3(int k) {
for (register int i = h[k]; i; i = e[i].nxt)
if (e[i].flag) {
dfs3(e[i].to);
for (register int j = 0; j < (int)(g[e[i].to].size()); ++j)
if (g[e[i].to][j] ^ k) g[k].push_back(g[e[i].to][j]);
} else
g[k].push_back(e[i].to);
tag[k] = g[k].size() < 2u;
}
void dfs4(int k) {
for (register int i = 0; i < (int)g[k].size(); ++i) tag[k] &= tag[g[k][i]];
for (register int i = h[k]; i; i = e[i].nxt)
if (e[i].flag) dfs4(e[i].to);
}
int main() {
srand(time(NULL));
t = read();
while (t--) {
memset(e, 0, sizeof e);
memset(h, 0, sizeof h);
tot = 0;
memset(tag, 0, sizeof tag);
n = read(), m = read();
for (register int i = 1; i <= m; ++i) {
int x = read(), y = read();
add(x, y);
}
bool flag = 0;
for (register int i = 1; i <= n; ++i) p[i] = i;
random_shuffle(p + 1, p + n + 1);
for (register int i = 1; i <= min(n, 100); ++i) {
cnt = 0;
memset(id, 0, sizeof id);
memset(s, 0, sizeof s);
for (register int j = 1; j <= tot; ++j) e[j].flag = 0;
root = p[i];
dfs1(root);
if (dfs2(root)) {
dfs3(root);
dfs4(root);
cnt = 0;
for (register int j = 1; j <= n; ++j) cnt += tag[j];
if (cnt * 5 >= n) {
for (register int j = 1; j <= n; ++j)
if (tag[j]) printf("%d ", j);
puts("");
} else
puts("-1");
flag = 1;
for (register int j = 1; j <= n; ++j) g[j].clear();
break;
}
}
if (!flag) puts("-1");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
const int maxm = 200005;
const int maxlog = 20;
const long long P = 1000000007ll;
const int inf = 2147483647;
const double eps = 1e-6;
const long long INF = 9223372036854775807ll;
int n, m, ee = 1, h[maxn], inst[maxn], vis[maxn], cho[maxn], hav[maxn],
cnt[maxn], mark[maxn], ok[maxn], mark2[maxn], tar[maxn];
struct Edge {
int v, next;
} e[maxm];
void addedge(int u, int v) {
e[ee] = Edge{v, h[u]};
h[u] = ee++;
}
int check(int u) {
inst[u] = vis[u] = 1;
int sz = 1;
for (register int i = h[u]; i; i = e[i].next) {
if (vis[e[i].v] && !inst[e[i].v]) return -1;
if (vis[e[i].v]) continue;
int szz = check(e[i].v);
if (szz != -1)
sz += szz;
else
return -1;
}
inst[u] = 0;
return sz;
}
void dfs1(int u) {
vis[u] = 1;
for (register int i = h[u]; i; i = e[i].next) {
if (vis[e[i].v]) {
mark[e[i].v]--;
mark[u]++;
mark2[e[i].v] -= e[i].v;
mark2[u] += e[i].v;
continue;
}
dfs1(e[i].v);
}
}
pair<int, int> dfs2(int u) {
vis[u] = 1;
cnt[u] = mark[u];
tar[u] = mark2[u];
for (register int i = h[u]; i; i = e[i].next) {
if (vis[e[i].v]) continue;
pair<int, int> x = dfs2(e[i].v);
cnt[u] += x.first, tar[u] += x.second;
}
return make_pair(cnt[u], tar[u]);
}
int dfs3(int u) {
vis[u] = 1;
if (cnt[u] == 1 && ok[tar[u]]) ok[u] = 1;
int sz = 0;
for (register int i = h[u]; i; i = e[i].next) {
if (vis[e[i].v]) continue;
sz += dfs3(e[i].v);
}
sz += ok[u];
return sz;
}
int main() {
int t;
scanf("%d", &t);
while (t--) {
scanf("%d%d", &n, &m);
memset(cho, 0, sizeof(int) * (n + 2));
memset(cnt, 0, sizeof(int) * (n + 2));
memset(mark, 0, sizeof(int) * (n + 2));
memset(mark2, 0, sizeof(int) * (n + 2));
memset(cnt, 0, sizeof(int) * (n + 2));
memset(tar, 0, sizeof(int) * (n + 2));
memset(ok, 0, sizeof(int) * (n + 2));
memset(hav, 0, sizeof(int) * (n + 2));
memset(h, 0, sizeof(int) * (n + 2));
ee = 1;
for (register int i = 0; i < (m); ++i) {
int u, v;
scanf("%d%d", &u, &v);
addedge(u, v);
}
for (register int i = 0; i < (min(100, n)); ++i) {
int op = rand() % 2, u;
if (n >= 60000) {
if (op)
u = rand() % (n / 2) + 1;
else
u = rand() % (n - n / 2) + n / 2 + 1;
} else
u = rand() % n + 1;
while (hav[u]) {
u++;
if (u > n) u = 1;
}
cho[i] = u;
hav[u] = 1;
}
int r = 0;
for (register int i = 0; i < (min(100, n)); ++i) {
memset(vis, 0, sizeof(int) * (n + 2));
if (check(cho[i]) == n) {
r = cho[i];
break;
}
}
if (!r)
printf("-1\n");
else {
ok[0] = 1;
memset(vis, 0, sizeof(int) * (n + 2));
dfs1(r);
memset(vis, 0, sizeof(int) * (n + 2));
dfs2(r);
memset(vis, 0, sizeof(int) * (n + 2));
cnt[r] = 1;
int ans = dfs3(r);
if (5 * ans < n)
printf("-1\n");
else {
for (register int i = 1; i < (n + 1); ++i) {
if (ok[i]) printf("%d ", i);
}
printf("\n");
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
namespace cxcyl {
int n, m, dep[100005];
bool vis[100005], in[100005], ab[100005];
vector<int> G[100005], ans, up[100005];
inline int read() {
int x = 0, f = 1;
char c = getchar();
while (c > -1 && c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
if (c == -1) return 0;
while (c >= '0' && c <= '9') x = x * 10 + c - 48, c = getchar();
return x * f;
}
inline unsigned long long Genrand() {
static unsigned long long x = 20040205;
x ^= x >> 12;
x ^= x << 25;
x ^= x >> 27;
return x;
}
bool check(int u) {
in[u] = 1;
for (int i = 0; i < G[u].size(); ++i) {
int v = G[u][i];
if (dep[v]) {
if (!in[v]) return 0;
continue;
}
dep[v] = dep[u] + 1;
if (!check(v)) return 0;
}
in[u] = 0;
return 1;
}
void dfs(int u) {
for (int i = 0; i < G[u].size(); ++i) {
int v = G[u][i];
if (dep[v] == dep[u] + 1) {
dfs(v);
for (int j = 0; j < up[v].size(); ++j)
if (up[v][j] != u) up[u].push_back(up[v][j]);
} else
up[u].push_back(v);
}
ab[u] = up[u].size() <= 1;
}
void find(int u) {
for (int i = 0; i < up[u].size(); ++i) ab[u] &= ab[up[u][i]];
if (ab[u]) ans.push_back(u);
for (int i = 0; i < G[u].size(); ++i) {
int v = G[u][i];
if (dep[v] == dep[u] + 1) find(v);
}
}
inline int main() {
int T = read();
while (T--) {
n = read(), m = read();
for (int i = 1; i <= n; ++i) G[i].clear();
for (int i = 1; i <= m; ++i) {
int u = read(), v = read();
G[u].push_back(v);
}
for (int ct = 1; ct <= 100; ++ct) {
int x = Genrand() % n + 1;
for (int i = 1; i <= n; ++i) {
dep[i] = 0;
in[i] = 0;
}
dep[x] = 1;
ans.clear();
if (check(x)) {
for (int i = 1; i <= n; ++i) up[i].clear();
dfs(x);
find(x);
sort(ans.begin(), ans.end());
if (5 * ans.size() >= n) {
for (int i = 0; i < ans.size(); ++i) printf("%d ", ans[i]);
puts("");
break;
} else {
puts("-1");
break;
}
}
}
if (ans.empty()) puts("-1");
}
return 0;
}
} // namespace cxcyl
int main() { return cxcyl::main(); }
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
int n, m;
bool bad[N];
vector<int> G[N];
int vis[N];
bool interesting;
int lvl[N];
int best[N];
int balance[N];
void clear() {
for (int i = 1; i <= n; ++i) {
lvl[i] = 0;
best[i] = 0;
balance[i] = 0;
G[i].clear();
bad[i] = false;
}
}
void no_answer() {
puts("-1");
clear();
}
int getInt(int a = INT_MIN, int b = INT_MAX) {
static mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
return uniform_int_distribution<int>(a, b)(rng);
}
void dfs(int u) {
vis[u] = 1;
for (auto v : G[u])
if (vis[v] == 0)
dfs(v);
else if (vis[v] == 2)
interesting = false;
vis[u] = 2;
}
bool check(int r) {
for (int i = 1; i <= n; ++i) vis[i] = 0;
interesting = true;
dfs(r);
return interesting;
}
int find_any() {
int tests = 100;
while (tests--) {
int r = getInt(1, n);
if (check(r)) return r;
}
return -1;
}
int find_bad(int u) {
vis[u] = 1;
best[u] = u;
for (auto v : G[u])
if (vis[v] == 0) {
lvl[v] = lvl[u] + 1;
balance[u] += find_bad(v);
if (lvl[best[v]] < lvl[best[u]]) best[u] = best[v];
} else {
balance[u]++;
balance[v]--;
if (lvl[v] < lvl[best[u]]) best[u] = v;
}
if (balance[u] > 1) bad[u] = true;
return balance[u];
}
void propagate_bad(int u) {
vis[u] = 1;
if (!bad[u] && bad[best[u]]) bad[u] = true;
for (auto v : G[u])
if (vis[v] == 0) propagate_bad(v);
}
vector<int> find_all(int r) {
for (int i = 1; i <= n; ++i) vis[i] = 0;
vector<int> ans;
find_bad(r);
for (int i = 1; i <= n; ++i) vis[i] = 0;
propagate_bad(r);
for (int i = 1; i <= n; ++i)
if (!bad[i]) ans.push_back(i);
return ans;
}
void solve() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; ++i) {
int u, v;
scanf("%d %d", &u, &v);
G[u].push_back(v);
}
int id = find_any();
if (id == -1) {
no_answer();
return;
}
auto ans = find_all(id);
if (5 * ans.size() >= n) {
for (auto v : ans) printf("%d ", v);
puts("");
clear();
} else
no_answer();
}
int main() {
int cases;
scanf("%d", &cases);
while (cases--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
vector<int> G[N];
int vis[N], n;
bool flag;
void dfs(int x) {
vis[x] = 1;
for (int i = 0; i < G[x].size(); ++i) {
int y = G[x][i];
if (!vis[y])
dfs(y);
else if (vis[y] == 2)
flag = 0;
}
vis[x] = 2;
}
bool check(int x) {
for (int i = 1; i <= n; ++i) vis[i] = 0;
flag = 1;
dfs(x);
return flag;
}
bool h[N];
int d[N], f[N], g[N];
int find(int x) {
vis[x] = 1;
g[x] = x;
for (int i = 0; i < G[x].size(); ++i) {
int y = G[x][i];
if (!vis[y]) {
d[y] = d[x] + 1;
f[x] += find(y);
if (d[g[y]] < d[g[x]]) g[x] = g[y];
} else {
f[x]++;
f[y]--;
if (d[y] < d[g[x]]) g[x] = y;
}
}
if (f[x] > 1) h[x] = 1;
return f[x];
}
void work(int x) {
vis[x] = 1;
if (!h[x] && h[g[x]]) h[x] = 1;
for (int i = 0; i < G[x].size(); ++i) {
int y = G[x][i];
if (!vis[y]) work(y);
}
}
int myrand() { return rand() % 10000 * 10000 + rand() % 10000; }
int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -f;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - 48;
ch = getchar();
}
return x * f;
}
signed main() {
srand((unsigned)time(NULL));
int T = read();
while (T-- > 0) {
n = read();
for (int i = 1; i <= n; ++i) G[i].clear();
int m = read();
for (int i = 1; i <= m; ++i) {
int x = read(), y = read();
G[x].push_back(y);
}
int rt = -1;
for (int tm = 1; tm <= 100; ++tm) {
int r = myrand() % n + 1;
if (check(r)) {
rt = r;
break;
}
}
if (rt == -1) {
puts("-1");
continue;
}
for (int i = 1; i <= n; ++i) {
h[i] = vis[i] = g[i] = d[i] = f[i] = 0;
}
find(rt);
for (int i = 1; i <= n; ++i) vis[i] = 0;
work(rt);
vector<int> ans;
for (int i = 1; i <= n; ++i) {
if (!h[i]) ans.push_back(i);
}
if (5 * (int)ans.size() >= n) {
for (int i = 0; i < ans.size(); ++i) printf("%d ", ans[i]);
putchar('\n');
} else
puts("-1");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int read() {
int x = 0;
bool flg = false;
char ch = getchar();
for (; !isdigit(ch); ch = getchar())
if (ch == '-') flg = true;
for (; isdigit(ch); ch = getchar()) x = (x << 3) + (x << 1) + (ch ^ 48);
return flg ? -x : x;
}
unsigned getrand() {
static unsigned sd = time(0);
return sd ^= sd >> 13, sd ^= sd << 28, sd ^= sd >> 24, sd ^= sd << 7;
}
const int INF = 1e9;
int n, m;
vector<int> e[100010];
bool inq[100010], vis[100010];
bool dfs0(int x) {
inq[x] = vis[x] = 1;
for (const int &y : e[x]) {
if (vis[y] && !inq[y]) return 0;
if (!vis[y] && !dfs0(y)) return 0;
}
inq[x] = 0;
return 1;
}
int lk[100010];
bool ok[100010];
inline void check(pair<int, int> &x, const pair<int, int> &y) {
if (y.first < x.first)
x.second = x.first, x.first = y.first;
else if (y.first < x.second)
x.second = y.first;
if (y.second < x.first)
x.second = x.first, x.first = y.second;
else if (y.second < x.second)
x.second = y.second;
}
inline void check(pair<int, int> &x, const int &y) {
if (y < x.first)
x.second = x.first, x.first = y;
else if (y < x.second)
x.second = y;
}
int dep[100010];
void dfs1(int x, int d) {
dep[x] = d;
vis[x] = 1;
for (const int &y : e[x])
if (!vis[y]) dfs1(y, d + 1);
}
pair<int, int> dfs2(int x) {
vis[x] = 1;
ok[x] = 1, lk[x] = -1;
pair<int, int> z(INF, INF);
for (const int &y : e[x]) {
if (vis[y])
check(z, dep[y]);
else {
check(z, dfs2(y));
}
}
assert(z.first < dep[x]);
if (z.second < dep[x])
ok[x] = 0;
else
lk[x] = z.first;
return z;
}
int stk[100010], top;
vector<int> S;
void dfs3(int x) {
stk[++top] = x;
vis[x] = 1;
if (~lk[x]) ok[x] = ok[stk[lk[x]]];
if (ok[x]) S.push_back(x);
for (const int &y : e[x])
if (!vis[y]) dfs3(y);
--top;
}
void check(int x) {
for (int i(1); i <= int(n); i++) vis[i] = 0;
dfs1(x, 1);
ok[x] = 1, lk[x] = -1;
for (int i(1); i <= int(n); i++) vis[i] = 0;
vis[x] = 1;
for (const int &y : e[x]) dfs2(y);
for (int i(1); i <= int(n); i++) vis[i] = 0;
S.clear();
top = 0;
dfs3(x);
if (S.size() * 5 < n)
puts("-1");
else {
sort((S).begin(), (S).end());
for (int x : S) printf("%d ", x);
puts("");
}
}
void solve() {
n = read(), m = read();
for (int i(1); i <= int(n); i++) e[i].clear();
while (m--) {
int u = read(), v = read();
e[u].push_back(v);
}
for (int T(1); T <= int(100); T++) {
int x = getrand() % n + 1;
for (int i(1); i <= int(n); i++) inq[i] = vis[i] = 0;
if (dfs0(x) == 0) continue;
check(x);
return;
}
puts("-1");
}
int main() {
for (int T = read(); T--;) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T &n) {
T w = 1;
n = 0;
char ch = getchar();
while (!isdigit(ch) && ch != EOF) {
if (ch == '-') w = -1;
ch = getchar();
}
while (isdigit(ch) && ch != EOF) {
n = (n << 3) + (n << 1) + (ch & 15);
ch = getchar();
}
n *= w;
}
template <typename T>
inline void write(T x) {
T l = 0;
unsigned long long y = 0;
if (!x) {
putchar(48);
return;
}
if (x < 0) {
x = -x;
putchar('-');
}
while (x) {
y = y * 10 + x % 10;
x /= 10;
++l;
}
while (l) {
putchar(y % 10 + 48);
y /= 10;
--l;
}
}
template <typename T>
inline void writes(T x) {
write(x);
putchar(' ');
}
template <typename T>
inline void writeln(T x) {
write(x);
puts("");
}
template <typename T>
inline void checkmax(T &a, T b) {
a = a > b ? a : b;
}
template <typename T>
inline void checkmin(T &a, T b) {
a = a < b ? a : b;
}
const int N = 1e5 + 10, M = 2e5 + 10;
int n, m, cnt, head[N], nxt[M << 1], to[M << 1], vis[N], in[N], dep[N],
depth[N], depto[N], sum[N], ok[N];
inline int rd() {
return int((long long)(rand() % 100000) * (rand() % 100000) % 998244353);
}
inline void addedge(int x, int y) {
nxt[++cnt] = head[x];
to[cnt] = y;
head[x] = cnt;
}
inline bool check(int x) {
vis[x] = in[x] = 1;
bool f = 1;
for (int i = head[x]; i; i = nxt[i]) {
if (vis[to[i]] && !in[to[i]]) f = 0;
if (vis[to[i]]) continue;
f &= check(to[i]);
}
in[x] = 0;
return f;
}
inline void dfs(int x) {
vis[x] = 1;
for (int i = head[x]; i; i = nxt[i]) {
if (vis[to[i]]) {
if (depth[to[i]] < dep[x]) {
dep[x] = depth[to[i]];
depto[x] = to[i];
}
sum[x]++;
sum[to[i]]--;
continue;
}
depth[to[i]] = depth[x] + 1;
dfs(to[i]);
sum[x] += sum[to[i]];
if (dep[x] > dep[to[i]]) {
dep[x] = dep[to[i]];
depto[x] = depto[to[i]];
}
}
}
inline void dfs2(int x) {
vis[x] = 1;
if (sum[x] >= 2 || (sum[x] == 1 && ok[depto[x]])) ok[x] = 1;
for (int i = head[x]; i; i = nxt[i]) {
if (vis[to[i]]) continue;
dfs2(to[i]);
}
}
inline void doit(int rt) {
for (int i = 1; i <= n; ++i) {
vis[i] = sum[i] = ok[i] = depth[i] = 0;
dep[i] = n * 2 + 1;
depto[i] = 0;
}
dfs(rt);
for (int i = 1; i <= n; ++i) vis[i] = 0;
dfs2(rt);
int ans = 0;
for (int i = 1; i <= n; ++i)
if (!ok[i]) ++ans;
if (ans * 5 < n) {
puts("-1");
return;
}
for (int i = 1; i <= n; ++i)
if (!ok[i]) writes(i);
puts("");
}
inline void solve() {
read(n);
read(m);
for (int i = 1; i <= n; ++i) head[i] = vis[i] = in[i] = 0;
cnt = 0;
for (int i = 1; i <= m; ++i) {
int x, y;
read(x);
read(y);
addedge(x, y);
}
for (int i = 1; i <= 100; ++i) {
int num = rd() % n + 1;
for (int i = 1; i <= n; ++i) vis[i] = in[i] = 0;
if (check(num)) {
doit(num);
return;
}
}
puts("-1");
}
int main() {
srand(1432433);
int t;
read(t);
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
int n, m;
int edge[200100][2];
std::vector<int> el[100100];
int chk[100100];
int dep[100100];
int ans[100100];
int highest[100100];
int secondhighest[100100];
int sflag;
int random_node() { return (rand() * 12117LL + rand()) % n + 1; }
void fdfs(int x) {
chk[x] = 1;
for (int i = 0; i < el[x].size(); i++) {
int y = el[x][i];
if (chk[y] != 0) {
if (chk[y] == 2) sflag = 1;
continue;
} else {
fdfs(y);
}
}
chk[x] = 2;
}
void sdfs(int x, int cdep) {
chk[x] = 1;
dep[x] = cdep;
highest[x] = x;
secondhighest[x] = x;
for (int i = 0; i < el[x].size(); i++) {
int y = el[x][i];
if (chk[y] != 0) {
if (dep[highest[x]] > dep[y]) {
secondhighest[x] = highest[x];
highest[x] = y;
} else if (dep[secondhighest[x]] > dep[y]) {
secondhighest[x] = y;
}
continue;
} else {
sdfs(y, cdep + 1);
if (dep[highest[x]] > dep[highest[y]]) {
secondhighest[x] = highest[x];
highest[x] = highest[y];
} else if (dep[secondhighest[x]] > dep[highest[y]]) {
secondhighest[x] = highest[y];
}
if (dep[highest[x]] > dep[secondhighest[y]]) {
secondhighest[x] = highest[x];
highest[x] = secondhighest[y];
} else if (dep[secondhighest[x]] > dep[secondhighest[y]]) {
secondhighest[x] = secondhighest[y];
}
}
}
}
void tdfs(int x) {
chk[x] = 1;
if (highest[x] != x && secondhighest[x] == x && ans[highest[x]] != 0) {
ans[x] = 1;
}
for (int i = 0; i < el[x].size(); i++) {
int y = el[x][i];
if (chk[y] != 0) {
continue;
} else {
tdfs(y);
}
}
}
int solve(int root) {
for (int i = 0; i <= n; i++) {
chk[i] = 0;
}
sflag = 0;
fdfs(root);
if (sflag) return 0;
for (int i = 1; i <= n; i++) {
if (chk[i] != 2) return 0;
chk[i] = 0;
ans[i] = 0;
}
sdfs(root, 0);
for (int i = 1; i <= n; i++) {
chk[i] = 0;
}
ans[root] = 1;
tdfs(root);
return 1;
}
int main() {
int tcn;
scanf("%d", &tcn);
while (tcn--) {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d%d", &edge[i][0], &edge[i][1]);
el[edge[i][0]].push_back(edge[i][1]);
}
int res = 0;
for (int i = 0; i < 100; i++) {
int x = random_node();
res = solve(x);
if (res == 1) break;
}
if (res == 0) {
printf("-1\n");
} else {
int anscnt = 0;
for (int i = 1; i <= n; i++) {
if (ans[i]) anscnt++;
}
if (anscnt * 5 < n) {
printf("-1\n");
} else {
for (int i = 1; i <= n; i++) {
if (ans[i]) printf("%d ", i);
}
printf("\n");
}
}
for (int i = 1; i <= n; i++) {
el[i].clear();
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long double pi = acos(-1);
const long double eps = 1e-9;
const int mod = 1e9 + 7;
mt19937 rng(
(unsigned int)chrono::steady_clock::now().time_since_epoch().count());
template <typename T>
static T randint(T lo, T hi) {
return uniform_int_distribution<T>(lo, hi)(rng);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
vector<vector<int> > g(n);
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
u--, v--;
assert(u != v);
g[u].push_back(v);
}
auto interesting = [&](int r) {
vector<bool> mark(n), p(n);
bool ok = true;
function<void(int)> dfs = [&](int u) {
mark[u] = p[u] = true;
for (int v : g[u]) {
if (!mark[v])
dfs(v);
else if (!p[v])
ok = false;
}
p[u] = false;
};
dfs(r);
return ok;
};
int r = -1;
for (int i = 0; i < 100; i++) {
int u = randint<int>(0, n - 1);
if (interesting(u)) {
r = u;
break;
}
}
if (r == -1) {
cout << -1 << '\n';
continue;
}
vector<int> mark(n), up(n, -1);
function<multiset<int> *(int)> dfs = [&](int u) {
mark[u] = true;
vector<multiset<int> *> e;
vector<int> b;
int big = 0, who = -1;
for (int v : g[u]) {
if (!mark[v]) {
e.push_back(dfs(v));
if (big < (int)e.back()->size()) {
big = e.back()->size();
who = e.size() - 1;
}
} else {
b.push_back(v);
}
}
multiset<int> *ret;
if (who != -1)
ret = e[who];
else
ret = new multiset<int>();
for (int i : b) ret->insert(i);
int sz = e.size();
for (int i = 0; i < sz; i++)
if (i != who)
for (int j : *e[i]) ret->insert(j);
if (ret->count(u)) ret->erase(u);
if (ret->size() == 1) up[u] = *(ret->begin());
return ret;
};
dfs(r);
fill(mark.begin(), mark.end(), false);
vector<bool> is(n);
is[r] = true;
function<void(int)> dfs1 = [&](int u) {
mark[u] = true;
if (up[u] != -1 && is[up[u]]) is[u] = true;
for (int v : g[u]) {
if (mark[v]) continue;
dfs1(v);
}
};
dfs1(r);
int ans = count(is.begin(), is.end(), true);
if (5 * ans < n) {
cout << -1 << '\n';
continue;
}
for (int i = 0; i < n; i++)
if (is[i]) {
ans--;
cout << i + 1 << " \n"[!ans];
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using D = double;
using uint = unsigned int;
template <typename T>
using pair2 = pair<T, T>;
using pii = pair<int, int>;
using pli = pair<ll, int>;
using pll = pair<ll, ll>;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int maxn = 100005;
int was[maxn];
pair2<int> up1[maxn], up2[maxn];
int d[maxn];
vector<int> gr[maxn];
vector<pair2<int>> all;
bool good[maxn];
vector<int> answer;
bool ok;
int n, m;
int ord[maxn];
void go(int cur, int curd) {
was[cur] = 1;
for (auto t : gr[cur]) {
if (was[t] == 1) {
continue;
}
if (was[t] == 2) {
ok = false;
continue;
}
go(t, curd + 1);
}
was[cur] = 2;
}
inline void upd(pair2<int> &m1, pair2<int> &m2, pair2<int> u) {
if (u < m1) {
m2 = m1;
m1 = u;
} else if (u < m2) {
m2 = u;
}
}
void go2(int cur, int curd) {
was[cur] = 1;
d[cur] = curd;
up1[cur] = {d[cur], cur};
up2[cur] = {d[cur], cur};
for (auto t : gr[cur]) {
if (was[t] == 1) {
upd(up1[cur], up2[cur], {d[t], t});
continue;
}
if (was[t] == 2) {
ok = false;
continue;
}
go2(t, curd + 1);
upd(up1[cur], up2[cur], up1[t]);
upd(up1[cur], up2[cur], up2[t]);
}
was[cur] = 2;
}
bool build(int start) {
for (int i = 0; i < n; i++) was[i] = 0;
ok = true;
go(start, 0);
return ok;
}
void calc(int start) {
for (int i = 0; i < n; i++) was[i] = 0;
ok = true;
go2(start, 0);
assert(ok);
all.clear();
for (int i = 0; i < n; i++) all.push_back({d[i], i});
for (int i = 0; i < n; i++) good[i] = false;
sort((all).begin(), (all).end());
for (auto t : all) {
int id = t.second;
if (d[id] == 0) {
good[id] = true;
answer.push_back(id);
continue;
}
if (up1[id].first >= d[id]) continue;
if (up2[id].first < d[id]) continue;
if (good[up1[id].second]) {
good[id] = true;
answer.push_back(id);
}
}
}
void solve() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) gr[i].clear();
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d%d", &a, &b);
a--, b--;
gr[a].push_back(b);
}
iota(ord, ord + n, 0);
shuffle(ord, ord + n, rng);
answer.clear();
for (int IT = 0; IT < min(n, 40); IT++) {
bool good = build(ord[IT]);
if (good) {
calc(ord[IT]);
break;
}
}
if (answer.empty() || (int)answer.size() * 5 < n)
printf("-1\n");
else {
sort((answer).begin(), (answer).end());
for (auto t : answer) printf("%d ", t + 1);
printf("\n");
}
}
int main() {
string shash =
"asdgkh sdglkjdfhgvf3894foief "
" sdgniidfgb sfg ";
unsigned long long hash = 0;
for (auto c : shash) hash = hash * 239 + c;
rng.seed(hash);
int NT;
scanf("%d", &NT);
for (int T = 0; T < NT; T++) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
mt19937 rng(time(NULL));
int rnd(int l, int r) { return rng() % (r - l + 1) + l; }
int T;
int n, m;
vector<int> G[N];
bool vis[N], ins[N];
void dfs(int p) {
vis[p] = ins[p] = true;
for (auto e : G[p]) {
if (!vis[e]) {
dfs(e);
} else if (!ins[e]) {
throw 1;
}
}
ins[p] = false;
}
bool check(int p) {
fill(vis + 1, vis + n + 1, false);
fill(ins + 1, ins + n + 1, false);
try {
dfs(p);
} catch (int) {
return false;
}
return true;
}
int dfc;
bool valid[N];
int dfn[N], low[N], low2[N], tour[N];
void upd_low(int p, int t) {
if (t < low[p]) {
swap(low[p], low2[p]);
low[p] = t;
} else if (t < low2[p]) {
low2[p] = t;
}
}
void tarjan(int p) {
dfn[p] = low[p] = low2[p] = ++dfc;
tour[dfc] = p;
for (auto e : G[p]) {
if (!dfn[e]) {
tarjan(e);
upd_low(p, low[e]);
upd_low(p, low2[e]);
} else {
upd_low(p, dfn[e]);
}
}
}
void solve() {
scanf("%d%d", &n, &m);
for (int i = 1, u, v; i <= m; i++) {
scanf("%d%d", &u, &v);
G[u].push_back(v);
}
int rt = -1;
for (int t = 1; t <= 70; t++) {
if (check(rt = rnd(1, n))) {
break;
} else {
rt = -1;
}
}
if (rt < 0) {
puts("-1");
return;
}
fill(dfn + 1, dfn + n + 1, 0);
tarjan(rt);
fill(valid + 1, valid + n + 1, false);
valid[rt] = true;
for (int i = 2; i <= n; i++) {
int p = tour[i];
if (low2[p] < dfn[p]) {
continue;
}
int q = tour[low[p]];
valid[p] = valid[q];
}
vector<int> ans;
for (int i = 1; i <= n; i++) {
if (valid[i]) {
ans.push_back(i);
}
}
if ((signed)ans.size() * 5 < n) {
puts("-1");
} else {
for (auto x : ans) {
printf("%d ", x);
}
putchar('\n');
}
}
void clear() {
dfc = 0;
for (int i = 1; i <= n; i++) {
G[i].clear();
}
}
int main() {
scanf("%d", &T);
while (T--) {
solve();
clear();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int dfn;
vector<int> g[100010];
int intr[100010];
int dep[100010];
int vis[100010];
int uplink[100010];
int st[100010], en[100010];
mt19937 rng(chrono::high_resolution_clock::now().time_since_epoch().count());
struct Min2 {
pair<int, int> a, b;
Min2() : a({1e9, -1}), b({1e9, -1}) {}
inline int size() {
if (a.first == 1e9)
return 0;
else if (b.first == 1e9)
return 1;
else
return 2;
}
inline void push(const pair<int, int>& cur) {
if (cur < a) {
b = a;
a = cur;
} else if (cur < b) {
b = cur;
}
}
inline void push(const Min2& o) {
push(o.a);
push(o.b);
}
} up[100010];
int rTime;
inline bool dfs(int x, int TIME) {
st[x] = ++dfn;
en[x] = n;
vis[x] = TIME;
up[x] = Min2();
for (auto ch : g[x]) {
if (vis[ch] == TIME) {
if (en[ch] >= st[x] && st[x] > st[ch]) {
up[x].push({dep[ch], ch});
} else {
return false;
}
} else {
dep[ch] = dep[x] + 1;
if (!dfs(ch, TIME)) return false;
up[x].push(up[ch]);
}
}
if (up[x].b.first >= dep[x]) {
uplink[x] = up[x].a.second;
} else {
uplink[x] = -1;
intr[x] = 0;
}
en[x] = dfn;
return true;
}
int sum;
inline void dfs1(int x) {
if (dep[x] == 1) {
sum += intr[x] = 1;
} else if (uplink[x] != -1) {
sum += intr[x] = intr[uplink[x]];
}
for (auto ch : g[x]) {
if (st[ch] > st[x] && en[ch] <= en[x]) {
dfs1(ch);
}
}
}
int N;
inline bool tst(int x) {
++N;
dfn = 0;
dep[x] = 1;
if (dfs(x, N)) {
sum = 0;
dfs1(x);
return true;
}
return false;
}
int main() {
int TT;
for (scanf("%d", &TT); TT; TT--) {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
intr[i] = -1;
g[i].clear();
}
for (int i = 1; i <= m; i++) {
int a, b;
scanf("%d%d", &a, &b);
g[a].push_back(b);
}
bool found = false;
for (int i = 1; i <= 100; i++) {
int x = rng() % n + 1;
if (tst(x)) {
found = true;
break;
}
}
if (!found || sum * 5 < n)
puts("-1");
else {
for (int i = 1; i <= n; i++) {
if (intr[i] == 1) printf("%d ", i);
}
puts("");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
const int maxn = 100100;
vector<int> g[maxn];
mt19937 rnd;
int timer;
int in[maxn];
int out[maxn];
int par[maxn];
int ord[maxn];
bool used[maxn];
void dfs1(int u) {
ord[timer] = u;
in[u] = timer++;
used[u] = true;
for (int v : g[u]) {
if (used[v]) {
continue;
}
par[v] = u;
dfs1(v);
}
out[u] = timer;
}
bool is_prev(int u, int v) { return in[u] <= in[v] && out[v] <= out[u]; }
vector<char> good;
vector<int> up;
vector<int> dfs2(int u) {
vector<int> up;
for (int v : g[u]) {
if (par[v] == u) {
auto nup = dfs2(v);
up.insert(up.end(), nup.begin(), nup.end());
} else {
up.push_back(in[v]);
}
sort(up.begin(), up.end());
up.resize(min((int)up.size(), 2));
}
while (!up.empty() && up.back() >= in[u]) {
up.pop_back();
}
if (up.size() > 1) {
good[u] = false;
} else if (up.size() == 1) {
::up[u] = ord[up.front()];
}
return up;
}
void dfs3(int u) {
if (up[u] != -1 && !good[up[u]]) {
good[u] = false;
}
for (int v : g[u]) {
if (par[v] == u) {
dfs3(v);
}
}
}
void solve() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; ++i) {
g[i].clear();
}
for (int i = 0; i < m; ++i) {
int u, v;
cin >> u >> v;
--u, --v;
g[u].push_back(v);
}
for (int it = 0; it < 100; ++it) {
fill(used, used + n, false);
timer = 0;
int u = rnd() % n;
par[u] = -1;
dfs1(u);
bool fail = false;
for (int i = 0; i < n; ++i) {
for (int j : g[i]) {
if (par[j] != i && !is_prev(j, i)) {
fail = true;
}
}
}
if (fail) {
continue;
}
good.assign(n, true);
up.assign(n, -1);
dfs2(u);
dfs3(u);
assert(good[u]);
int total = 0;
for (int i = 0; i < n; ++i) {
total += good[i];
}
if (total * 5 < n) {
cout << -1 << '\n';
} else {
for (int i = 0; i < n; ++i) {
if (good[i]) {
cout << i + 1 << ' ';
}
}
cout << '\n';
}
return;
}
cout << -1 << '\n';
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
ll seed = __rdtsc();
rnd = mt19937(seed);
int tn;
cin >> tn;
for (int i = 0; i < tn; ++i) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
int T, n, m, t[110000], p[110000], vis[110000], ans;
int cnt, num[110000];
bool flag, Ans[110000];
vector<int> vec[110000];
const int bufsize = 1 << 20;
char Getchar() {
static char now[bufsize], *S, *T;
if (T == S) {
T = (S = now) + fread(now, 1, bufsize, stdin);
if (T == S) return EOF;
}
return *S++;
}
int read() {
int x = 0, f = 1;
char ch = Getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = Getchar();
}
while (ch <= '9' && ch >= '0') x = x * 10 + ch - '0', ch = Getchar();
return x * f;
}
inline long long myrand() { return 1ll * rand() * RAND_MAX + rand(); }
void dfs(int u) {
vis[u] = 1;
cnt++;
for (int v : vec[u])
if (vis[v] == 2)
flag = false;
else if (!vis[v])
dfs(v);
vis[u] = 2;
}
void dfs2(int u) {
vis[u] = true;
num[++cnt] = u;
for (int v : vec[u])
if (!vis[v]) {
dfs2(v);
t[u] += t[v];
p[u] ^= p[v];
} else {
t[u]++;
t[v]--;
p[u] ^= v;
p[v] ^= v;
}
}
void work() {
n = read();
m = read();
for (int i = 1; i <= n; i++) vec[i].clear();
int u, v;
for (int i = 1; i <= m; i++) {
u = read();
v = read();
vec[u].push_back(v);
}
for (int i = 1; i <= n; i++) p[i] = i;
for (int i = 1; i <= n; i++) swap(p[i], p[myrand() % i + 1]);
int lim = min(n, 100), rt = -1;
for (int i = 1; i <= lim; i++) {
for (int j = 1; j <= n; j++) vis[j] = 0;
flag = true;
cnt = 0;
dfs(p[i]);
if (flag && cnt == n) {
rt = p[i];
break;
}
}
if (rt == -1) {
puts("-1");
return;
}
for (int i = 1; i <= n; i++) {
vis[i] = 0;
p[i] = 0;
t[i] = 0;
}
cnt = 0;
dfs2(rt);
ans = 1;
Ans[rt] = true;
int x;
for (int i = 2; i <= n; i++) {
x = num[i];
if (t[x] == 1 && Ans[p[x]]) {
Ans[x] = true;
ans++;
} else
Ans[x] = false;
}
if (ans * 5 < n) {
puts("-1");
return;
}
for (int i = 1; i <= n; i++)
if (Ans[i]) printf("%d ", i);
putchar('\n');
}
int main() {
srand(19260817);
T = read();
while (T--) work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 50;
int n, m, final[N], nex[N], to[N], tot, T;
void link(int x, int y) { to[++tot] = y, nex[tot] = final[x], final[x] = tot; }
int ans[N], sum[N], sp[N], dep[N];
int ins[N], vis[N], god;
void dfs(int x) {
ins[x] = vis[x] = 1;
for (int i = final[x]; i; i = nex[i]) {
int y = to[i];
if (!ins[y] && vis[y]) {
god = 0;
} else {
if (ins[y]) {
if (sp[x] == 0 || dep[sp[x]] > dep[y]) sp[x] = y;
sum[x]++;
sum[y]--;
} else {
dep[y] = dep[x] + 1;
dfs(y);
}
}
}
ins[x] = 0;
}
bool good(int x) {
god = 1;
memset(vis, 0, (n + 5) * sizeof vis[0]);
memset(sp, 0, (n + 5) * sizeof sp[0]);
memset(sum, 0, (n + 5) * sizeof sum[0]);
memset(dep, 0, sizeof(int[n + 5]));
dep[x] = 1;
dfs(x);
return god;
}
int inans[N];
void init(int x) {
vis[x] = 1;
for (int i = final[x]; i; i = nex[i]) {
int y = to[i];
if (!vis[y]) {
init(y);
sum[x] += sum[y];
if (sp[y] && (sp[x] == 0 || dep[sp[y]] < dep[sp[x]])) sp[x] = sp[y];
}
}
}
void getans(int x) {
if (sum[x] == 1 && inans[sp[x]]) inans[x] = 1, ans[++(*ans)] = x;
vis[x] = 1;
for (int i = final[x]; i; i = nex[i]) {
int y = to[i];
if (!vis[y]) {
getans(y);
}
}
}
set<pair<int, int> > ss;
int main() {
for (cin >> T; T; T--) {
tot = 0;
cin >> n >> m;
ss.clear();
memset(final, 0, (n + 5) * sizeof final[0]);
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d %d", &u, &v);
link(u, v);
assert(u != v);
if (ss.find(make_pair(u, v)) != ss.end()) assert(0);
ss.insert(make_pair(u, v));
}
int cnt = 0;
while (1) {
if (++cnt == 100) {
break;
}
int x = (rand() * RAND_MAX + rand()) % n + 1;
if (good(x)) {
ans[0] = 0;
memset(vis, 0, (n + 5) * sizeof vis[0]);
init(x);
memset(inans, 0, (n + 5) * sizeof inans[0]);
inans[x] = 1, ans[++(*ans)] = x;
memset(vis, 0, (n + 5) * sizeof vis[0]);
getans(x);
if (ans[0] * 5 < n) {
if (m == 100002) cout << 234 << endl;
cout << -1 << endl;
} else {
sort(ans + 1, ans + 1 + *ans);
for (int i = 1; i <= *ans; i++) {
printf("%d ", ans[i]);
}
printf("\n");
}
break;
}
}
if (cnt == 100) {
if (m == 100002) cout << 233 << endl;
cout << -1 << endl;
continue;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct __timestamper {};
const int NOT_FOUND = -2;
const int BAD = -1;
struct segtree {
int n, N;
vector<vector<int>> a, t;
segtree(const vector<vector<int>>& _a) {
a = _a;
n = a.size();
N = 1;
while (N < n) N <<= 1;
t.resize(2 * N);
for (int i = 0; i < n; i++) {
sort(a[i].begin(), a[i].end());
t[N + i] = a[i];
}
for (int v = N - 1; v > 0; v--) {
t[v].resize(t[v * 2].size() + t[v * 2 + 1].size());
merge(t[v * 2].begin(), t[v * 2].end(), t[v * 2 + 1].begin(),
t[v * 2 + 1].end(), t[v].begin());
}
}
int Merge(int cans, int v, int need) {
if (cans == BAD) return BAD;
int id = lower_bound(t[v].begin(), t[v].end(), need) - t[v].begin();
if (id == 0) return cans;
if (id > 1) return BAD;
if (cans == NOT_FOUND) return t[v][0];
return BAD;
}
int get(int l, int r, int x) {
l += N;
r += N;
int ans = NOT_FOUND;
while (l <= r) {
if (l & 1) ans = Merge(ans, l, x);
if (!(r & 1)) ans = Merge(ans, r, x);
l = (l + 1) >> 1;
r = (r - 1) >> 1;
}
return ans;
}
};
vector<int> solve(vector<vector<int>> e) {
int n = e.size();
vector<int> ans;
mt19937 rnd(2314532534);
for (int it = 0; it < 65; it++) {
int root = rnd() % n;
bool ok = 1;
vector<int> c(n);
vector<int> in(n, -1), out(n);
vector<vector<int>> up(n);
vector<int> par(n, -1);
vector<int> vct;
int tmr = 0;
function<void(int)> dfs = [&](int v) {
in[v] = tmr++;
vct.push_back(v);
c[v] = 1;
for (int to : e[v]) {
if (c[to] == 0) {
par[to] = v;
dfs(to);
} else if (c[to] == 1) {
up[in[v]].push_back(in[to]);
} else {
ok = 0;
}
}
c[v] = 2;
out[v] = tmr;
};
dfs(root);
for (int i = 0; i < n; i++) ok &= in[i] != -1;
if (!ok) continue;
segtree tr(up);
vector<int> good_pr(n);
for (int v = 0; v < n; v++) {
if (v == root)
good_pr[v] = v;
else {
good_pr[v] = tr.get(in[v], out[v] - 1, in[v]);
if (good_pr[v] < 0)
good_pr[v] = -1;
else
good_pr[v] = vct[good_pr[v]];
}
}
for (int i = 1; i < n; i++) {
int v = vct[i];
if (good_pr[v] != -1 && good_pr[good_pr[v]] == -1) {
good_pr[v] = -1;
}
}
for (int i = 0; i < n; i++)
if (good_pr[i] != -1) ans.push_back(i);
break;
}
if (ans.size() * 10 < 2 * n) ans.clear();
return ans;
}
vector<int> slow(vector<vector<int>> e) {
int n = e.size();
vector<int> ans;
for (int root = 0; root < n; root++) {
bool ok = 1;
vector<int> c(n);
vector<int> in(n, -1), out(n);
vector<vector<int>> up(n);
vector<int> par(n, -1);
vector<int> vct;
int tmr = 0;
function<void(int)> dfs = [&](int v) {
in[v] = tmr++;
vct.push_back(v);
c[v] = 1;
for (int to : e[v]) {
if (c[to] == 0) {
par[to] = v;
dfs(to);
} else if (c[to] == 1) {
up[in[v]].push_back(in[to]);
} else {
ok = 0;
}
}
c[v] = 2;
out[v] = tmr;
};
dfs(root);
for (int i = 0; i < n; i++) ok &= in[i] != -1;
if (!ok) continue;
ans.push_back(root);
}
if (ans.size() * 10 < 2 * n) ans.clear();
return ans;
}
void stress() {
for (int it = 1090;; it++) {
mt19937 rnd(it);
cerr << "it"
<< " = " << it << endl;
int n = rnd() % 10 + 1;
vector<vector<int>> e(n);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (j != i && rnd() % 2) {
e[i].push_back(j);
}
}
}
auto ans1 = solve(e);
auto ans2 = slow(e);
if (ans1 != ans2) {
cerr << "ans1"
<< " = ";
for (auto xxxx : ans1) cerr << xxxx << " ";
cerr << endl;
cerr << "ans2"
<< " = ";
for (auto xxxx : ans2) cerr << xxxx << " ";
cerr << endl;
cerr << "n"
<< " = " << n << endl;
for (auto neib : e) {
cerr << "neib"
<< " = ";
for (auto xxxx : neib) cerr << xxxx << " ";
cerr << endl;
}
exit(0);
}
}
}
int main() {
int T;
scanf("%d", &T);
while (T--) {
int n, m;
scanf("%d%d", &n, &m);
vector<vector<int>> e(n);
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d%d", &u, &v);
u--;
v--;
e[u].push_back(v);
}
auto ans = solve(e);
if (ans.size() * 10 < 2 * n) {
printf("%d\n", -1);
} else {
sort(ans.begin(), ans.end());
for (int i = 0; i < (int)ans.size(); i++)
printf("%d%c", ans[i] + 1, " \n"[i + 1 == (int)ans.size()]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ld = long double;
const int N = 100005;
int n, m;
vector<int> g[N];
int vis[N];
int cnt;
int up[N];
bool dp[N];
int par[N];
bool dfs(int u) {
vis[u] = 1;
cnt++;
for (int v : g[u]) {
if (vis[v] == 2) return false;
if (!vis[v]) {
par[v] = u;
if (!dfs(v)) return false;
up[u] += up[v];
} else
up[u]++, up[v]--;
}
vis[u] = 2;
return true;
}
multiset<int> edges[N];
int sv[N];
void f(int u) {
vis[u] = 1;
for (int v : g[u]) {
if (!vis[v]) {
f(v);
if (edges[u].size() < edges[v].size())
;
for (int x : edges[v]) edges[u].insert(x);
edges[v].clear();
} else
edges[u].insert(v);
}
edges[u].erase(u);
if (up[u] == 1) sv[u] = *edges[u].begin();
}
void prop(int u) {
if (sv[u]) {
dp[u] &= dp[sv[u]];
}
vis[u] = 1;
for (int v : g[u])
if (!vis[v]) prop(v);
}
mt19937 rng(58);
void solve() {
int it = 100;
vector<int> ids(n);
iota(ids.begin(), ids.end(), 1);
shuffle(ids.begin(), ids.end(), rng);
for (int u : ids) {
if (--it == 0) break;
memset(vis, 0, (n + 2) * sizeof(vis[0]));
memset(up, 0, (n + 2) * sizeof(up[0]));
if (!dfs(u) or cnt < n) continue;
for (int i = 1; i <= n; i++) dp[i] = up[i] == 1;
dp[u] = 1;
par[u] = -1;
memset(vis, 0, (n + 2) * sizeof(vis[0]));
memset(sv, 0, (n + 2) * sizeof(sv[0]));
f(u);
memset(vis, 0, (n + 2) * sizeof(vis[0]));
prop(u);
vector<int> ans;
for (int i = 1; i <= n; i++)
if (dp[i]) {
ans.push_back(i);
}
if ((int)ans.size() * 5 < n) break;
for (int x : ans) printf("%d ", x);
printf("\n");
return;
}
printf("-1\n");
}
int main() {
int t;
scanf("%d", &t);
while (t--) {
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d %d", &u, &v);
g[u].push_back(v);
}
solve();
for (int i = 1; i <= n; i++) g[i].clear(), edges[i].clear();
}
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
vector<vector<int> > g;
vector<array<int, 2> > b;
vector<int> ok, a, tin, tour, par;
void prepare(int n) {
ok.assign(n, false), b.assign(n, {-1, -1}), g.assign(n, vector<int>());
}
bool check(int u) {
a[u] = true, tin[u] = tour.size(), tour.push_back(u);
for (int v : g[u]) {
if (tin[v] == -1) {
par[v] = u;
if (!check(v)) return false;
} else if (!a[v])
return false;
}
a[u] = false;
return true;
}
void add_edge(int u, int val) {
if (b[u][0] > val)
b[u][1] = b[u][0], b[u][0] = val;
else if (b[u][1] > val)
b[u][1] = val;
}
void dfs1(int u) {
b[u][0] = b[u][1] = tin[u];
for (int v : g[u]) {
if (par[v] == u) {
dfs1(v);
add_edge(u, b[v][0]), add_edge(u, b[v][1]);
} else if (tin[v] < tin[u])
add_edge(u, tin[v]);
}
if (b[u][1] >= tin[u]) ok[u] = true;
}
void dfs2(int u) {
ok[u] &= ok[tour[b[u][0]]];
for (int v : g[u])
if (par[v] == u) dfs2(v);
}
void solve() {
int n, m;
cin >> n >> m;
prepare(n);
for (int i = 0, a, b; i < m; i++) cin >> a >> b, g[--a].push_back(--b);
vector<int> p;
for (int i = 0; i < n; i++) p.push_back(i);
shuffle(p.begin(), p.end(), rng);
for (int i = 0; i < min(n, 100); i++) {
a.assign(n, false), tin.assign(n, -1), tour.clear(), par.assign(n, -1);
if (check(p[i])) {
ok[p[i]] = true;
dfs1(p[i]), dfs2(p[i]);
break;
}
}
if (count(ok.begin(), ok.end(), 1) * 5 < n) {
cout << "-1\n";
return;
}
for (int i = 0; i < n; i++)
if (ok[i]) cout << i + 1 << " ";
cout << "\n";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const int N = 1e5 + 1;
int n, m;
vector<int> adj[N];
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int rand(int x) { return uniform_int_distribution<int>(0, x - 1)(rng); }
int d[N];
bool inq[N];
bool vis3[N];
bool ok = true;
void dfs3(int id) {
inq[id] = true;
vis3[id] = true;
for (auto x : adj[id]) {
if (!vis3[x]) {
dfs3(x);
} else if (!inq[x])
ok = false;
}
inq[id] = false;
}
bool arin(int x) {
for (int i = 1; i <= n; i++) vis3[i] = inq[i] = false;
ok = true;
dfs3(x);
return ok;
}
bool vis[N];
vector<int> ch[N];
int par[N];
int dx[N], dy[N];
int cs[N];
int up[N];
void dfs(int id) {
vis[id] = true;
up[id] = id;
for (auto x : adj[id]) {
if (!vis[x]) {
d[x] = d[id] + 1;
par[x] = id;
ch[id].push_back(x);
cs[id] = x;
dfs(x);
} else {
dx[x]--;
dx[id]++;
if (d[up[id]] > d[x]) up[id] = x;
}
}
for (auto x : ch[id]) {
if (d[up[x]] < d[up[id]]) up[id] = up[x];
}
}
int dfs4(int id) {
int duh = dx[id];
for (auto x : ch[id]) duh += dfs4(x);
dy[id] = duh;
return duh;
}
bool good[N];
int rt;
void dfs2(int id) {
if (dy[id] <= 1) good[id] = good[up[id]];
if (id == rt) good[id] = true;
for (auto x : ch[id]) {
dfs2(x);
}
}
void solve() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
adj[i].clear();
ch[i].clear();
dx[i] = dy[i] = 0;
good[i] = false;
}
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
}
int x = 0;
for (int i = 1; i <= 100; i++) {
x = rand(n) + 1;
if (arin(x)) break;
x = 0;
}
if (x == 0) {
cout << "-1\n";
return;
}
for (int i = 1; i <= n; i++) vis[i] = false;
d[x] = 0;
dfs(x);
rt = x;
dfs4(x);
dfs2(x);
int cnt = 0;
for (int i = 1; i <= n; i++)
if (good[i]) cnt++;
if (cnt * 5 < n) {
cout << "-1\n";
return;
}
for (int i = 1; i <= n; i++)
if (good[i]) cout << i << ' ';
cout << '\n';
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
while (t--) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, m;
cin >> n >> m;
vector<vector<int> > edges(n);
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
edges[a].push_back(b);
}
mt19937 mt(chrono::steady_clock::now().time_since_epoch().count());
for (int _ = 0; _ < 60; _++) {
int st = uniform_int_distribution<int>(0, n - 1)(mt);
vector<int> bfs = {st};
vector<int> vis(n, 0);
int s = 0;
vis[st] = 1;
vector<int> par(n);
vector<int> d(n);
par[st] = st;
d[st] = 0;
while (s < (int)bfs.size()) {
int v = bfs[s];
s++;
for (int w : edges[v]) {
if (vis[w]) continue;
par[w] = v;
d[w] = d[v] + 1;
bfs.push_back(w);
vis[w] = 1;
}
}
if ((int)bfs.size() != n) {
continue;
}
const int MAXJ = 18;
vector<vector<int> > jmp(MAXJ, vector<int>(n));
jmp[0] = par;
for (int j = 1; j < MAXJ; j++) {
for (int i = 0; i < n; i++) {
jmp[j][i] = jmp[j - 1][jmp[j - 1][i]];
}
}
vector<int> count_over(n, 0);
bool fail = false;
vector<int> up_where(n, -1);
for (int v = 0; v < n; v++) {
for (int w : edges[v]) {
if (par[w] == v) continue;
int dv = d[v];
int dw = d[w];
if (dv <= dw) {
fail = true;
} else {
int dist = dv - dw;
int cv = v;
for (int j = 0; j < MAXJ; j++) {
if (dist & (1 << j)) {
cv = jmp[j][cv];
}
}
if (cv != w) {
fail = true;
} else {
count_over[v] += 1;
count_over[w] -= 1;
if (up_where[v] == -1 || d[w] < d[up_where[v]]) {
up_where[v] = w;
}
}
}
}
}
if (fail) {
continue;
}
vector<int> answers;
for (int g = n - 1; g > 0; g--) {
int v = bfs[g];
int p = par[v];
count_over[p] += count_over[v];
if (up_where[v] != -1) {
if (up_where[p] == -1 || d[up_where[v]] < d[up_where[p]]) {
up_where[p] = up_where[v];
}
}
}
vector<int> good(n, 1);
for (int g = 1; g < n; g++) {
int v = bfs[g];
if (count_over[v] != 1 || !good[up_where[v]]) {
good[v] = 0;
}
}
for (int i = 0; i < n; i++) {
if (good[i]) answers.push_back(i);
}
if ((int)answers.size() * 5 < n) {
cout << -1 << '\n';
} else {
for (int a : answers) {
cout << a + 1 << ' ';
}
cout << '\n';
}
return;
}
cout << -1 << '\n';
return;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(nullptr);
int T;
cin >> T;
while (T--) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 1000000007;
const int MM = 998244353;
const long double PI = acos(-1);
template <typename T, typename U>
static inline void amin(T &x, U y) {
if (y < x) x = y;
}
template <typename T, typename U>
static inline void amax(T &x, U y) {
if (x < y) x = y;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
return os << '(' << p.first << "," << p.second << ')';
}
mt19937 rng(chrono::high_resolution_clock::now().time_since_epoch().count());
const int N = 100005;
vector<int> v[N];
pair<int, int> back[N];
int dep[N], in[N], cur, out[N], dp[N], par[N];
bool vis[N];
vector<int> t;
void dfs(int s) {
t.push_back(s);
vis[s] = true;
in[s] = cur++;
dp[s] = 0;
back[s] = {N, N};
for (auto j : v[s]) {
if (!vis[j]) {
dep[j] = dep[s] + 1;
par[j] = s;
dfs(j);
dp[s] += dp[j];
amin(back[s], back[j]);
} else {
++dp[s];
--dp[j];
amin(back[s], make_pair(dep[j], j));
}
}
out[s] = cur - 1;
}
int _runtimeTerror_() {
int n, m;
cin >> n >> m;
vector<pair<int, int> > ed;
for (int i = 1; i <= n; ++i) {
v[i].clear();
back[i] = {N, N};
dep[i] = 0;
}
while (m--) {
int x, y;
cin >> x >> y;
v[x].push_back(y);
ed.push_back({x, y});
}
auto ancestor = [&](int x, int y) {
return in[y] >= in[x] && in[y] <= out[x];
};
int cutoff = 1;
while (cutoff * 5 < n) ++cutoff;
vector<bool> checked(n + 1, false), interested(n + 1, true);
vector<int> ans;
for (int it = 0; it <= 100; ++it) {
int u = rng() % n + 1;
if (checked[u]) continue;
for (int i = 1; i <= n; ++i)
dep[i] = 0, back[i] = {N, N}, in[i] = 0, vis[i] = false, dp[i] = 0,
par[i] = 0;
cur = 0;
t.clear();
dfs(u);
checked[u] = true;
bool can = true;
for (auto &j : ed) {
if (j.first == par[j.second] || j.second == par[j.first]) continue;
if (!ancestor(j.second, j.first)) {
can = false;
break;
}
}
if (!can) continue;
interested[u] = true;
ans.push_back(u);
for (int i = 1; i < n; ++i) {
if (dp[t[i]] >= 2) {
interested[t[i]] = false;
} else {
assert(dp[t[i]] == 1);
interested[t[i]] = interested[back[t[i]].second];
}
if (interested[t[i]]) ans.push_back(t[i]);
}
if ((long long)ans.size() < cutoff) ans.clear();
break;
}
if (ans.empty()) {
cout << "-1\n";
return 0;
}
sort(ans.begin(), ans.end());
for (auto j : ans) cout << j << " ";
cout << "\n";
return 0;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int TESTS = 1;
cin >> TESTS;
while (TESTS--) _runtimeTerror_();
return 0;
}
|
#include <bits/stdc++.h>
struct {
inline operator int() {
int x;
return scanf("%d", &x), x;
}
} read;
const int maxn = 100005;
std::vector<int> G[maxn];
int cover[maxn], keycover[maxn];
bool vis[maxn], ins[maxn];
bool isans[maxn];
int Root;
void force(int u) {
vis[u] = ins[u] = 1;
for (int v : G[u])
if (!vis[v])
force(v);
else if (!ins[v])
Root = 0;
ins[u] = 0;
}
int tmp[maxn], tp;
void dfs(int u) {
tmp[++tp] = u;
vis[u] = 1;
for (int v : G[u])
if (!vis[v]) {
dfs(v);
cover[u] += cover[v];
keycover[u] += keycover[v];
} else {
++cover[u];
--cover[v];
keycover[u] += v;
keycover[v] -= v;
}
}
int main() {
std::mt19937 engine(19260817);
int T = read;
while (T--) {
int n = read, m = read;
for (int i = 1; i <= n; i++) G[i].clear();
for (int i = 1; i <= m; i++) {
int u = read, v = read;
G[u].push_back(v);
}
std::uniform_int_distribution<int> Rand(1, n);
int test = 80;
Root = 0;
while (!Root and test--) {
std::fill(vis, vis + n + 1, 0);
force(Root = Rand(engine));
}
if (!Root) {
puts("-1");
continue;
}
std::fill(cover, cover + n + 1, 0);
std::fill(keycover, keycover + n + 1, 0);
std::fill(vis, vis + n + 1, 0);
tp = 0;
dfs(Root);
isans[Root] = 1;
int tot = 1;
for (int i = 2; i <= tp; i++) {
int u = tmp[i];
if (cover[u] == 1)
isans[u] = isans[keycover[u]];
else
isans[u] = 0;
tot += isans[u];
}
if (tot * 5 >= n) {
for (int i = 1; i <= n; i++)
if (isans[i]) printf("%d ", i);
puts("");
} else
puts("-1");
}
}
|
#include <bits/stdc++.h>
namespace IO {
const int IN_LEN = 1 << 18 | 1;
static char buf[IN_LEN], *s, *t;
inline int Getchar(void) {
return s == t && (t = (s = buf) + fread(buf, 1, IN_LEN, stdin)),
s == t ? -1 : *s++;
}
template <class T>
inline void read(T& x) {
static int c, f;
c = Getchar(), x = f = 0;
while (c < '0' || c > '9') {
if (c == '-') f = 1;
c = Getchar();
}
while (c <= '9' && c >= '0') x = x * 10 + c - 48, c = Getchar();
x = f ? -x : x;
}
} // namespace IO
using IO::read;
using namespace std;
const int N = 2e5 + 5;
int head[N], eidx, rt, n, vis[N], dep[N], low[N], sum[N], m, cnt;
struct Edge {
int nxt, to;
} edge[N];
bool mark[N];
vector<int> ans;
inline void addedge(int u, int v) {
edge[++eidx] = (Edge){head[u], v};
head[u] = eidx;
}
bool chk(int u) {
vis[u] = 1, ++cnt;
for (int i = head[u], v; i; i = edge[i].nxt)
if (!vis[v = edge[i].to]) {
if (!chk(v)) return false;
} else if (vis[v] == 2)
return false;
vis[u] = 2;
return true;
}
void dfs(int u) {
low[u] = u, vis[u] = 1;
for (int i = head[u], v; i; i = edge[i].nxt)
if (!vis[v = edge[i].to]) {
dep[v] = dep[u] + 1;
dfs(v);
if (dep[low[v]] < dep[low[u]]) low[u] = low[v];
sum[u] += sum[v];
} else {
++sum[u], --sum[v];
if (dep[v] < dep[low[u]]) low[u] = v;
}
if (sum[u] > 1) mark[u] = 1;
}
void redfs(int u) {
if (sum[u] < 2 && mark[low[u]]) mark[u] = 1;
if (!mark[u]) ans.push_back(u);
for (int i = head[u], v; i; i = edge[i].nxt)
if (dep[v = edge[i].to] == dep[u] + 1) redfs(v);
}
inline void solve(void) {
read(n), read(m);
eidx = 0;
memset(head, 0, sizeof(int) * (n + 1));
memset(mark, 0, sizeof(bool) * (n + 1));
for (int i = 1, u, v; i <= m; ++i) {
read(u), read(v);
addedge(u, v);
}
int _ = 100;
while (_--) {
rt = (1LL * rand() * rand()) % n + 1, cnt = 0;
memset(vis, 0, sizeof(int) * (n + 1));
if (chk(rt) && cnt == n)
break;
else
rt = 0;
}
if (!rt) return puts("-1"), void();
memset(vis, 0, sizeof(int) * (n + 1));
memset(sum, 0, sizeof(int) * (n + 1));
dep[rt] = 0;
dfs(rt);
ans.clear();
redfs(rt);
if (int(ans.size()) * 5 < n) return puts("-1"), void();
sort(ans.begin(), ans.end());
for (const int& v : ans) printf("%d ", v);
puts("");
}
int main(void) {
srand(time(0));
int T;
read(T);
while (T--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
os << '{';
string sep;
for (const auto &x : v) os << sep << x, sep = ", ";
return os << '}';
}
template <typename T, size_t size>
ostream &operator<<(ostream &os, const array<T, size> &arr) {
os << '{';
string sep;
for (const auto &x : arr) os << sep << x, sep = ", ";
return os << '}';
}
template <typename A, typename B>
ostream &operator<<(ostream &os, const pair<A, B> &p) {
return os << '(' << p.first << ", " << p.second << ')';
}
void dbg_out() { cerr << endl; }
template <typename Head, typename... Tail>
void dbg_out(Head H, Tail... T) {
cerr << ' ' << H;
dbg_out(T...);
}
auto random_address = [] {
char *p = new char;
delete p;
return (uint64_t)p;
};
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count() *
(random_address() | 1));
template <typename T>
void output_vector(const vector<T> &v, bool add_one = false, int start = -1,
int end = -1) {
if (start < 0) start = 0;
if (end < 0) end = int(v.size());
for (int i = start; i < end; i++)
cout << v[i] + (add_one ? 1 : 0) << (i < end - 1 ? ' ' : '\n');
}
const int ATTEMPTS = 100;
int N, M;
vector<vector<int>> adj;
vector<int> tour_index;
vector<array<int, 2>> low_link;
vector<bool> in_stack;
int tour;
vector<int> tour_list;
array<int, 2> combine(array<int, 2> x, int y) {
array<int, 3> a = {x[0], x[1], y};
sort(a.begin(), a.end());
return {a[0], a[1]};
}
array<int, 2> combine(array<int, 2> x, array<int, 2> y) {
array<int, 4> a = {x[0], x[1], y[0], y[1]};
sort(a.begin(), a.end());
return {a[0], a[1]};
}
bool interesting_dfs(int node) {
tour_index[node] = tour++;
tour_list.push_back(node);
low_link[node] = {tour_index[node], tour_index[node]};
in_stack[node] = true;
for (int neighbor : adj[node])
if (tour_index[neighbor] < 0) {
if (!interesting_dfs(neighbor)) return false;
low_link[node] = combine(low_link[node], low_link[neighbor]);
} else if (in_stack[neighbor]) {
low_link[node] = combine(low_link[node], tour_index[neighbor]);
} else {
return false;
}
in_stack[node] = false;
return true;
}
bool check_interesting(int node) {
tour_index.assign(N, -1);
low_link.resize(N);
in_stack.assign(N, false);
tour = 0;
tour_list.clear();
return interesting_dfs(node);
}
void run_case() {
cin >> N >> M;
adj.assign(N, {});
for (int i = 0; i < M; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
adj[u].push_back(v);
}
int root = -1;
for (int iter = 0; iter < ATTEMPTS; iter++) {
root = int(rng() % N);
if (check_interesting(root)) break;
root = -1;
}
if (root < 0) {
cout << -1 << '\n';
return;
}
vector<bool> bad(N, false);
for (int x : tour_list)
if (low_link[x][0] < tour_index[x] && low_link[x][1] < tour_index[x]) {
bad[x] = true;
} else {
assert(low_link[x][1] == tour_index[x]);
int above = tour_list[low_link[x][0]];
bad[x] = bad[above];
}
vector<int> interesting;
for (int i = 0; i < N; i++)
if (!bad[i]) interesting.push_back(i);
if (5 * int(interesting.size()) < N)
cout << -1 << '\n';
else
output_vector(interesting, true);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int tests;
cin >> tests;
while (tests-- > 0) run_case();
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
int h[N], e[N], ne[N], idx;
void add(int a, int b) { e[idx] = b, ne[idx] = h[a], h[a] = idx++; }
int n, m;
bool vis[N];
bool nvis[N];
int dep[N];
int sz;
int check(int u) {
vis[u] = true;
nvis[u] = true;
sz++;
for (int i = h[u]; i != -1; i = ne[i]) {
int j = e[i];
if (vis[j] && !nvis[j]) return -1;
if (vis[j]) continue;
if (check(j) == -1) return -1;
}
nvis[u] = false;
return sz;
}
int dfn[N], cnt[N];
bool bad[N];
int dfs1(int u) {
vis[u] = 1;
dfn[u] = u;
for (int i = h[u]; i != -1; i = ne[i]) {
int j = e[i];
if (!vis[j]) {
dep[j] = dep[u] + 1;
int siz = dfs1(j);
cnt[u] += siz;
if (dep[dfn[u]] > dep[dfn[j]]) dfn[u] = dfn[j];
} else {
cnt[u]++;
cnt[j]--;
if (dep[dfn[u]] > dep[j]) dfn[u] = j;
}
}
if (cnt[u] > 1) bad[u] = true;
return cnt[u];
}
vector<int> ans;
void dfs2(int u) {
vis[u] = true;
if (!bad[u] && bad[dfn[u]]) bad[u] = true;
for (int i = h[u]; i != -1; i = ne[i]) {
int j = e[i];
if (!vis[j]) dfs2(j);
}
}
int main() {
int T;
cin >> T;
while (T--) {
mt19937 R(600000);
cin >> n >> m;
memset(cnt, 0, sizeof(int) * (n << 1));
memset(dfn, 0, sizeof(int) * (n << 1));
memset(bad, 0, sizeof(bool) * (n << 1));
memset(dep, 0, sizeof(int) * (n << 1));
memset(h, -1, sizeof(int) * (n << 1)), idx = 0;
for (int i = 1; i <= m; i++) {
int a, b;
scanf("%d%d", &a, &b);
add(a, b);
}
int r = 0;
for (int i = 1; i <= 200; i++) {
memset(vis, 0, sizeof(bool) * (n << 1));
memset(nvis, 0, sizeof(int) * (n << 1));
int u = 1ll * R() % n * R() % n + 1;
sz = 0;
if (check(u) == n) {
r = u;
break;
}
}
sz = 0;
if (!r) {
cout << -1 << endl;
} else {
memset(vis, 0, sizeof(bool) * (n << 1));
dfs1(r);
memset(vis, 0, sizeof(bool) * (n << 1));
dfs2(r);
for (int i = 1; i <= n; i++)
if (!bad[i]) ans.push_back(i);
if (ans.size() * 5 >= n) {
for (auto p : ans) cout << p << ' ';
cout << endl;
} else {
cout << -1 << endl;
}
}
ans.clear();
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
os << '{';
string sep;
for (const auto &x : v) os << sep << x, sep = ", ";
return os << '}';
}
template <typename T, size_t size>
ostream &operator<<(ostream &os, const array<T, size> &arr) {
os << '{';
string sep;
for (const auto &x : arr) os << sep << x, sep = ", ";
return os << '}';
}
template <typename A, typename B>
ostream &operator<<(ostream &os, const pair<A, B> &p) {
return os << '(' << p.first << ", " << p.second << ')';
}
void dbg_out() { cerr << endl; }
template <typename Head, typename... Tail>
void dbg_out(Head H, Tail... T) {
cerr << ' ' << H;
dbg_out(T...);
}
auto random_address = [] {
char *p = new char;
delete p;
return (uint64_t)p;
};
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count() *
(random_address() | 1));
template <typename T>
void output_vector(const vector<T> &v, bool add_one = false, int start = -1,
int end = -1) {
if (start < 0) start = 0;
if (end < 0) end = int(v.size());
for (int i = start; i < end; i++)
cout << v[i] + (add_one ? 1 : 0) << (i < end - 1 ? ' ' : '\n');
}
const int ATTEMPTS = 50;
int N, M;
vector<vector<int>> adj;
vector<int> tour_index;
vector<array<int, 2>> low_link;
vector<bool> in_stack;
int tour;
vector<int> tour_list;
array<int, 2> combine(array<int, 2> x, int y) {
array<int, 3> a = {x[0], x[1], y};
sort(a.begin(), a.end());
return {a[0], a[1]};
}
array<int, 2> combine(array<int, 2> x, array<int, 2> y) {
array<int, 4> a = {x[0], x[1], y[0], y[1]};
sort(a.begin(), a.end());
return {a[0], a[1]};
}
bool interesting_dfs(int node) {
tour_index[node] = tour++;
tour_list.push_back(node);
low_link[node] = {tour_index[node], tour_index[node]};
in_stack[node] = true;
for (int neighbor : adj[node])
if (tour_index[neighbor] < 0) {
if (!interesting_dfs(neighbor)) return false;
low_link[node] = combine(low_link[node], low_link[neighbor]);
} else if (in_stack[neighbor]) {
low_link[node] = combine(low_link[node], tour_index[neighbor]);
} else {
return false;
}
in_stack[node] = false;
return true;
}
vector<int> save_interesting;
bool check_interesting(int node) {
if (save_interesting[node] >= 0) return save_interesting[node];
tour_index.assign(N, -1);
low_link.resize(N);
in_stack.assign(N, false);
tour = 0;
tour_list.clear();
return (save_interesting[node] = interesting_dfs(node));
}
void run_case() {
cin >> N >> M;
adj.assign(N, {});
for (int i = 0; i < M; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
adj[u].push_back(v);
}
save_interesting.assign(N, -1);
int root = -1;
for (int iter = 0; iter < ATTEMPTS; iter++) {
root = int(rng() % N);
if (check_interesting(root)) break;
root = -1;
}
if (root < 0) {
cout << -1 << '\n';
return;
}
vector<bool> bad(N, false);
for (int x : tour_list)
if (low_link[x][0] < tour_index[x] && low_link[x][1] < tour_index[x]) {
bad[x] = true;
} else {
assert(low_link[x][1] == tour_index[x]);
int above = tour_list[low_link[x][0]];
bad[x] = bad[above];
}
vector<int> interesting;
for (int i = 0; i < N; i++)
if (!bad[i]) interesting.push_back(i);
if (5 * int(interesting.size()) < N)
cout << -1 << '\n';
else
output_vector(interesting, true);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int tests;
cin >> tests;
while (tests-- > 0) run_case();
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline T read() {
T f = 0, x = 0;
char c = getchar();
while (!isdigit(c)) f = c == '-', c = getchar();
while (isdigit(c)) x = x * 10 + c - 48, c = getchar();
return f ? -x : x;
}
namespace run {
const int N = 2e5 + 9;
int head[N], nex[N], to[N], cnt;
inline void add(int u, int v) {
nex[++cnt] = head[u];
head[u] = cnt, to[cnt] = v;
}
int n, m, vis[N], peg, ins[N];
inline void dfs(int u) {
vis[u] = ins[u] = 1;
for (int i = head[u]; i; i = nex[i]) {
if (!ins[to[i]] && vis[to[i]]) peg = 1;
if (!vis[to[i]]) dfs(to[i]);
}
ins[u] = 0;
}
int dep[N], pos[N], a[N], g[N];
inline void pre(int u) {
vis[u] = 1;
for (int i = head[u]; i; i = nex[i]) {
if (!vis[to[i]]) {
dep[to[i]] = dep[u] + 1, pre(to[i]), a[u] += a[to[i]],
pos[u] ^= pos[to[i]];
} else if (dep[to[i]] < dep[u])
a[u]++, a[to[i]]--, pos[u] ^= to[i], pos[to[i]] ^= to[i];
}
}
inline void get(int u) {
vis[u] = 1;
if (a[u] == 1 && g[pos[u]]) g[u] = 1;
for (int i = head[u]; i; i = nex[i])
if (!vis[to[i]]) get(to[i]);
}
int main() {
srand(1);
int T = read<int>();
while (T--) {
n = read<int>(), m = read<int>(), cnt = 0;
for (int i = 1; i <= n; i++) head[i] = 0;
for (int i = 1; i <= m; i++) {
int u = read<int>(), v = read<int>();
add(u, v);
}
int rt = -1;
for (int t = 1; t <= 100; t++) {
int x = ((rand() << 14) ^ rand()) % n + 1;
for (int i = 1; i <= n; i++) vis[i] = 0;
peg = 0, dfs(x);
if (!peg) {
rt = x;
break;
}
}
if (rt == -1) {
puts("-1");
continue;
}
for (int i = 1; i <= n; i++) pos[i] = a[i] = vis[i] = 0;
dep[rt] = 1, pre(rt);
for (int i = 1; i <= n; i++) g[i] = vis[i] = 0;
g[rt] = 1, get(rt);
vector<int> tmp(0);
for (int i = 1; i <= n; i++)
if (g[i]) tmp.push_back(i);
if (tmp.size() >= (n + 4) / 5) {
sort(tmp.begin(), tmp.end());
for (int i = 0; i < tmp.size(); i++) printf("%d ", tmp[i]);
puts("");
} else
puts("-1");
}
return 0;
}
} // namespace run
int main() { return run::main(); }
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
int arr[n];
int arr1[m];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
for (int i = 0; i < m; i++) {
cin >> arr1[i];
}
int num = -1;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (arr[i] == arr1[j]) {
num = arr[i];
break;
}
}
}
if (num != -1) {
cout << "YES" << endl;
cout << "1 " << num << endl;
} else
cout << "NO" << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long int sumdigit(long long int num) {
long long int sum = 0;
while (num) {
sum += num % 10;
num /= 10;
}
return sum;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int test;
cin >> test;
while (test--) {
int n, m;
cin >> n >> m;
int a[n], b[m];
int dp1[1002] = {0}, dp2[1002] = {0};
for (int i = 0; i < n; i++) {
cin >> a[i];
dp1[a[i]]++;
}
for (int i = 0; i < m; i++) {
cin >> b[i];
dp2[b[i]]++;
}
bool ans = false;
int value;
for (int i = 0; i < 1002; i++) {
if (dp1[i] > 0 && dp2[i] > 0) {
ans = true;
value = i;
break;
}
}
if (ans) {
cout << "YES" << endl;
cout << 1 << " " << value << endl;
} else {
cout << "NO" << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 1;
long long int Mod = 998244353;
int main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
vector<int> hash(1001, 0);
int x;
for (int i = 0; i < n; i++) {
cin >> x;
hash[x]++;
}
int ans = -1;
for (int i = 0; i < m; i++) {
cin >> x;
if (hash[x]) ans = x;
}
if (ans == -1)
cout << "NO\n";
else
cout << "YES \n1" << ' ' << ans << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
bool vis[1005];
int arr[1005];
int main() {
int t;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> arr[i];
vis[arr[i]] = 1;
}
int ans = -1;
int b;
for (int i = 0; i < m; i++) {
cin >> b;
if (vis[b]) ans = b;
}
memset(vis, 0, sizeof(vis));
if (ans == -1)
cout << "NO" << endl;
else
cout << "YES\n1 " << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 7;
int a[N], b[N];
void run() {
int n, m;
scanf("%d%d", &n, &m);
unordered_set<int> mp;
for (int i = 1; i <= n; ++i) {
scanf("%d", a + i);
mp.insert(a[i]);
}
for (int i = 1; i <= m; ++i) scanf("%d", b + i);
for (int i = 1; i <= m; ++i)
if (mp.find(b[i]) != mp.end()) {
puts("YES");
printf("1 %d\n", b[i]);
return;
}
puts("NO");
}
int main() {
int _;
scanf("%d", &_);
while (_--) run();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, m;
cin >> n >> m;
int arr[n], brr[m];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
for (int i = 0; i < m; i++) {
cin >> brr[i];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (arr[i] == brr[j]) {
cout << "YES" << '\n';
cout << 1 << " " << arr[i] << '\n';
return;
}
}
}
cout << "NO" << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
;
int t = 1;
cin >> t;
while (t--) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t;
cin >> t;
while (t--) {
long long int n, m;
cin >> n >> m;
long long int a[n];
for (long long int i = 0; i < n; i++) cin >> a[i];
long long int b[m];
for (long long int i = 0; i < m; i++) cin >> b[i];
long long int kk = 1000000000, flag = 0;
for (long long int i = 0; i < n; i++) {
for (long long int j = 0; j < m; j++) {
if (a[i] == b[j]) {
if (a[i] < kk) kk = a[i];
flag = 1;
}
}
}
if (flag == 1) {
cout << "YES" << endl;
cout << "1 " << kk << endl;
} else
cout << "NO" << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
while (t > 0) {
long long n, m;
cin >> n >> m;
unordered_set<long long> s;
for (long long i = 0; i < n; i++) {
long long a;
cin >> a;
s.insert(a);
}
long long b;
long long k;
bool found = false;
for (long long i = 0; i < m; i++) {
cin >> b;
if (s.find(b) != s.end()) {
k = b;
found = true;
}
}
if (found) {
cout << "YES" << endl;
cout << 1 << " " << k << endl;
} else {
cout << "NO" << endl;
}
t--;
}
}
|
#include <bits/stdc++.h>
using namespace std;
typedef vector<int> vi;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout.precision(10);
cout << fixed;
long long t;
cin >> t;
while (t--) {
long long n, m;
cin >> n >> m;
vector<long long> a(n), b(m);
long long i, j;
long long ans = 0;
long long flag = 0;
unordered_map<long long, long long> ump;
for (int i = 0; i < (int)(n); ++i) {
cin >> a[i];
ump[a[i]]++;
}
for (int i = 0; i < (int)(m); ++i) {
cin >> b[i];
if (ump.find(b[i]) != ump.end()) {
ans = b[i];
flag = 1;
}
}
if (flag) {
cout << "YES\n";
cout << 1 << " " << ans << "\n";
} else {
cout << "NO\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t, x, y, n, m, r[1001], s[1001];
cin >> t;
while (t--) {
cin >> x >> y;
n = x;
m = y;
while (x) cin >> r[--x];
while (y) cin >> s[--y];
sort(r, r + n);
sort(s, s + m);
for (x = 0, y = 0; x < n && y < m;) {
if (r[x] == s[y]) break;
if (r[x] > s[y])
y++;
else
x++;
}
if (x < n && y < m)
cout << "YES\n1 " << r[x] << endl;
else
cout << "NO\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
unsigned long long factorial[1000004];
unsigned long long power(unsigned long long x, int y, int p) {
unsigned long long res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
unsigned long long modInverse(unsigned long long n, int p) {
return power(n, p - 2, p);
}
unsigned long long nc(unsigned long long n, int r, int p) {
if (r == 0) return 1;
return (factorial[n] * modInverse(factorial[r], p) % p *
modInverse(factorial[n - r], p) % p) %
p;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
vector<int> a1(1001, 0);
vector<int> b1(1001, 0);
vector<int> a(1001), b(1001);
for (long long i = 0; i < n; i++) {
cin >> a[i + 1];
a1[a[i + 1]] = 1;
}
for (long long i = 0; i < m; i++) {
cin >> b[i + 1];
b1[b[i + 1]] = 1;
}
int j = 0;
int f = 0;
for (long long i = 0; i < 1000; i++) {
if ((a1[i + 1] != 0) && (b1[i + 1] != 0)) {
f = 1;
j = i + 1;
break;
}
}
if (f) {
cout << "YES\n";
cout << "1 " << j << "\n";
} else {
cout << "NO\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
long long n, m, a, b, c, k, temp, x, y;
const int MAXN = 1e5 + 11;
inline long long max(long long a, long long b) { return ((a > b) ? a : b); }
inline long long min(long long a, long long b) { return ((a > b) ? b : a); }
inline long long gcd(long long a, long long b) {
if (b == 0) return a;
a %= b;
return gcd(b, a);
}
inline vector<long long> read(int n) {
vector<long long> v(n);
for (int i = 0; i < v.size(); i++) cin >> v[i];
return v;
}
void solveforthiscase(const int& test) {
cin >> n >> m;
vector<long long> v = read(n);
vector<long long> vv = read(m);
set<int> s1, s2;
for (int i = 0; i < n; i++) s1.insert(v[i]);
for (int i = 0; i < m; i++) s2.insert(vv[i]);
for (auto x : s1) {
if (s2.count(x)) {
cout << "YES\n";
cout << 1 << ' ' << x << '\n';
return;
}
}
cout << "NO\n";
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
clock_t start, end;
start = clock();
int test = 1;
cin >> test;
for (int i = 1; i <= test; i++) solveforthiscase(i);
end = clock();
long double t_t = (long double)(end - start) / (long double)(CLOCKS_PER_SEC);
cerr << (long double)t_t * 1000 << " ms ";
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
cin >> t;
while (t--) {
long long n, m;
cin >> n >> m;
set<long long> a, b;
long long temp;
for (long long i = 0; i < n; i++) {
cin >> temp;
a.insert(temp);
}
for (long long i = 0; i < m; i++) {
cin >> temp;
b.insert(temp);
}
int flag = 0;
for (auto i : a) {
if (b.find(i) != b.end()) {
flag = i;
break;
}
}
if (flag)
cout << "YES" << '\n' << 1 << " " << flag << '\n';
else
cout << "NO" << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MN = 1010;
int vis[MN];
int main() {
int T;
scanf("%d", &T);
while (T--) {
memset(vis, 0, sizeof(vis));
int n, m, fg = -1;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) {
int t;
scanf("%d", &t);
if (!vis[t]) vis[t]++;
}
for (int i = 0; i < m; ++i) {
int t;
scanf("%d", &t);
if (vis[t] == 1) {
fg = t;
vis[t]++;
}
}
if (fg == -1)
printf("NO\n");
else
printf("YES\n1 %d\n", fg);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) {
int n, m, flag = 0;
cin >> n >> m;
int a[n], b[m];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
for (int i = 0; i < m; i++) {
cin >> b[i];
}
for (int i = 0; i < m; i++) {
if (binary_search(a, a + n, b[i])) {
cout << "YES\n" << 1 << " " << b[i] << "\n";
flag = 1;
break;
}
}
if (flag == 0) cout << "NO\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int m, n, f = 0, pos = 0;
cin >> n >> m;
int a[n], b[m];
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < m; i++) cin >> b[i];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++)
if (a[i] == b[j]) {
f = 1;
pos = a[i];
break;
}
}
if (f != 0)
cout << "YES\n"
<< "1 " << pos << "\n";
else
cout << "NO\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (a > b) {
long long tmp = a;
a = b;
b = tmp;
}
while (a) {
long long tmp = b % a;
b = a;
a = tmp;
}
return b;
}
int main() {
ios::sync_with_stdio(0);
int t;
cin >> t;
while (t--) {
long long n, m, i, j, k;
cin >> n >> m;
vector<long long> a(n), b(m), h1(1001, 0), h2(1001, 0);
long long flag = 0;
for (i = 0; i < n; i++) {
cin >> a[i];
h1[a[i]]++;
}
for (i = 0; i < m; i++) {
cin >> b[i];
h2[b[i]]++;
}
long long val = -1;
for (i = 1; i <= 1000; i++) {
if (h1[i] && h2[i]) {
flag = 1;
val = i;
break;
}
}
if (flag) {
cout << "YES" << endl;
cout << 1 << " " << val << endl;
} else
cout << "NO" << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
inline void solve() {
int n, m;
cin >> n >> m;
int vf[1005];
for (int i = 0; i <= 1000; i++) vf[i] = 0;
int a, b;
for (int i = 1; i <= n; i++) cin >> a, vf[a]++;
bool ok = 0;
int ok1;
for (int j = 1; j <= m; j++) {
cin >> b;
if (vf[b] > 0) {
ok = 1;
ok1 = b;
}
}
if (ok == 1) {
cout << "YES\n1 " << ok1 << "\n";
} else
cout << "NO\n";
}
int main() {
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void test() {
int n, m;
cin >> n >> m;
vector<int> a(n), b(m);
for (auto &it : a) cin >> it;
for (auto &it : b) cin >> it;
vector<int> res;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (a[i] == b[j]) res.push_back(a[i]);
}
}
if (res.size() == 0) {
cout << "NO\n";
return;
} else {
cout << "YES\n";
cout << "1 " << res.front() << endl;
return;
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int tc;
cin >> tc;
while (tc--) test();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
bool cnt = 0;
set<int> x;
int n, m, ans;
cin >> n >> m;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
x.insert(a);
}
for (int i = 0; i < m; i++) {
int b;
cin >> b;
if (x.find(b) != x.end() && !cnt) {
cnt = 1;
ans = b;
}
}
if (!cnt) {
cout << "NO\n";
} else {
cout << "YES\n";
cout << 1 << " " << ans << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
template <typename T>
void read(T &first) {
first = 0;
char ch = getchar();
long long f = 1;
while (!isdigit(ch)) {
if (ch == '-') f *= -1;
ch = getchar();
}
while (isdigit(ch)) {
first = first * 10 + ch - 48;
ch = getchar();
}
first *= f;
}
int z[2000];
int main() {
int t;
cin >> t;
while (t--) {
int n;
int m;
cin >> n >> m;
memset(z, 0, sizeof(z));
int a;
for (int i = 1; i <= n; i++) {
scanf("%d", &a);
z[a] = 1;
}
for (int i = 1; i <= m; i++) {
scanf("%d", &a);
if (z[a] == 1) z[a] = 2;
}
int judge = 0;
for (int i = 0; i < 1200; i++) {
if (z[i] > 1) {
judge = i;
break;
}
}
if (judge == 0)
cout << "NO" << endl;
else {
cout << "YES" << endl;
printf("1 %d\n", judge);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int T;
cin >> T;
while (T--) {
int n, m;
cin >> n >> m;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
int b[m];
for (int i = 0; i < m; i++) cin >> b[i];
int freq[1000] = {0};
for (int i = 0; i < n; i++) {
if (freq[a[i] - 1] == 0) freq[a[i] - 1] = 1;
}
int flag = 0;
int el = 0;
for (int i = 0; i < m; i++) {
if (freq[b[i] - 1] == 1) {
flag = 1;
el = b[i];
}
}
if (flag == 0)
cout << "NO" << endl;
else
cout << "YES" << endl << 1 << " " << el << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int tests(void);
int tests() {
int n, m;
vector<int> v;
set<int> s1;
set<int> s2;
cin >> n >> m;
for (int i = 0; i < n; i++) {
int in;
cin >> in;
s1.insert(in);
}
for (int i = 0; i < m; i++) {
int in;
cin >> in;
s2.insert(in);
}
for (auto it = s1.begin(); it != s1.end(); it++) {
v.push_back(*it);
}
for (auto it = s2.begin(); it != s2.end(); it++) {
v.push_back(*it);
}
sort(v.begin(), v.end());
for (int i = 1; i < v.size(); i++) {
if (v[i - 1] == v[i]) {
cout << "YES"
<< "\n";
cout << '1' << " " << v[i] << "\n";
return 0;
}
}
cout << "NO"
<< "\n";
return 0;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
int test;
cin >> test;
while (test--) {
tests();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
set<int> a;
for (__typeof(n) i = (0) - ((0) > (n)); i != (n) - ((0) > (n));
i += 1 - 2 * ((0) > (n))) {
int x;
cin >> x;
a.insert(x);
}
int brr[m];
int ans = -1;
for (__typeof(m) i = (0) - ((0) > (m)); i != (m) - ((0) > (m));
i += 1 - 2 * ((0) > (m))) {
cin >> brr[i];
if (a.find(brr[i]) != a.end()) {
ans = brr[i];
}
}
if (ans == -1) {
cout << "NO" << '\n';
} else {
cout << "YES" << '\n';
cout << 1 << " " << ans << '\n';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t, n, m, i, j, flag;
cin >> t;
while (t--) {
cin >> n >> m;
flag = 0;
vector<long long int> N(n), M(m);
for (i = 0; i < n; i++) cin >> N[i];
for (i = 0; i < m; i++) cin >> M[i];
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
if (N[i] == M[j]) {
flag = 1;
break;
}
}
if (flag == 1) break;
}
if (flag == 1) {
cout << "YES\n";
cout << 1 << " " << N[i] << "\n";
} else
cout << "NO\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t, n, m, i;
cin >> t;
while (t--) {
cin >> n >> m;
long long a[n];
long long b[m];
long long flag = 0, ans;
map<long long, long long> m1;
for (i = 0; i < n; i++) {
cin >> a[i];
m1[a[i]] = 1;
}
for (i = 0; i < m; i++) {
cin >> b[i];
if (m1.find(b[i]) != m1.end() && flag == 0) {
ans = b[i];
flag = 1;
}
}
if (flag == 1)
cout << "YES"
<< "\n"
<< "1 " << ans << "\n";
else
cout << "NO"
<< "\n";
}
cerr << (1000 * clock()) / CLOCKS_PER_SEC << "ms";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void Solve() {
int n, m, b[1000], a[1000];
bool f[10000];
memset(f, 0, sizeof(f));
cin >> n >> m;
for (int i = 0; i < n; ++i) cin >> a[i];
for (int i = 0; i < m; ++i) {
cin >> b[i];
f[b[i]] = 1;
}
for (int i = 0; i < n; ++i)
if (f[a[i]]) {
cout << "YES" << endl;
cout << 1 << " " << a[i] << endl;
return;
}
cout << "NO" << endl;
}
int main() {
int q;
cin >> q;
while (q--) Solve();
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
unordered_set<int> st;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
st.insert(x);
}
bool flag = true;
for (int i = 0; i < m; i++) {
int x;
cin >> x;
if (st.find(x) != st.end() and flag) {
flag = false;
cout << "YES" << endl << 1 << " " << x << endl;
}
}
if (flag) {
cout << "NO" << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long power(long long x, long long y, long long mod) {
long long res = 1;
while (y) {
if (y & 1) res = (res * x) % mod;
y = y >> 1;
x = (x * x) % mod;
}
return res;
}
long long modInverse(long long a, long long m) {
long long m0 = m;
long long y = 0, x = 1;
if (m == 1) return 0;
while (a > 1) {
long long q = a / m;
long long t = m;
m = a % m, a = t;
t = y;
y = x - q * y;
x = t;
}
if (x < 0) x += m0;
return x;
}
long long binomial(long long n, long long k) {
long long res = 1;
if (k > n - k) k = n - k;
for (long long i = 0; i < k; ++i) {
res *= (n - i);
res /= (i + 1);
}
return res;
}
void doper() {}
int32_t main() {
doper();
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
long long T;
cin >> T;
while (T--) {
long long n, m, x;
cin >> n >> m;
map<long long, long long> mp;
while (n--) {
cin >> x;
mp[x]++;
}
long long ans, f = 0;
while (m--) {
cin >> x;
if (mp[x]) {
f = 1;
ans = x;
}
}
if (f) {
cout << "YES\n";
cout << 1 << " " << ans;
cout << "\n";
;
} else
cout << "NO\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n, m;
cin >> n >> m;
vector<long long> a(n), b(m);
for (long long i = 0; i < n; i++) cin >> a[i];
for (long long i = 0; i < m; i++) cin >> b[i];
vector<long long>::iterator it;
for (long long i = 0; i < n; i++) {
it = find(b.begin(), b.end(), a[i]);
if (it != b.end()) {
cout << "YES" << endl;
cout << 1 << " " << a[i] << endl;
return;
} else
continue;
}
cout << "NO" << endl;
}
int main() {
long long tt;
cin >> tt;
while (tt--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
while (t--) {
long long n, i, m, A[1000], B[1000], note, f = 0;
cin >> n >> m;
for (i = 0; i < n; i++) {
cin >> A[i];
}
for (i = 0; i < m; i++) cin >> B[i];
sort(B, B + m);
for (i = 0; i < n; i++) {
if (binary_search(B, B + m, A[i])) {
note = A[i];
f = 1;
break;
}
}
if (f == 0)
cout << "NO";
else {
cout << "YES\n";
cout << "1 " << note;
}
cout << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t;
cin >> t;
while (t--) {
long long n, m;
cin >> n >> m;
set<long long> s;
long long temp;
long long ans = -1;
for (int i = 0; i < n; i++) {
cin >> temp;
s.insert(temp);
}
for (int i = 0; i < m; i++) {
cin >> temp;
if (s.count(temp) && ans == -1) {
ans = temp;
}
}
if (ans != -1) {
cout << "YES" << endl << 1 << " " << ans << endl;
} else {
cout << "NO" << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
unsigned long long int INF = 10000;
class Compare {
public:
bool operator()(const pair<long long int, long long int> p1,
const pair<long long int, long long int> p2) {
if (p1.first > p2.first)
return true;
else if (p1.first == p2.first) {
if (p1.second < p2.second) return true;
}
return false;
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t;
cin >> t;
while (t--) {
map<long long int, long long int> m1;
map<long long int, long long int> m2;
long long int n, m, flag = 0, ans;
cin >> n >> m;
long long int a[n], b[m];
for (long long int i = 0; i < n; i++) {
cin >> a[i];
m1[a[i]]++;
}
for (long long int i = 0; i < m; i++) {
cin >> b[i];
m2[b[i]]++;
if (m1[b[i]] > 0) {
ans = b[i];
flag = 1;
}
}
if (flag) {
cout << "YES" << endl << "1 " << ans << endl;
} else
cout << "NO" << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void fast() {
ios_base::sync_with_stdio(NULL);
cin.tie(0);
cout.tie(0);
}
void online_judge() {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
const int flag_max = 0x3f3f3f3f;
const long long OO = 1e9 + 9;
const double EPS = (1e-7);
int dcmp(double x, double y) { return fabs(x - y) <= EPS ? 0 : x < y ? -1 : 1; }
long long gcd(long long a, long long b) { return !b ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return (a / gcd(a, b)) * b; }
int main() {
fast();
int testcase;
cin >> testcase;
while (testcase--) {
int n, m;
cin >> n >> m;
int firstarr[n];
int secondarr[m];
for (int i = 0; i < n; i++) {
cin >> firstarr[i];
}
for (int i = 0; i < m; i++) {
cin >> secondarr[i];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (firstarr[i] == secondarr[j]) {
cout << "YES\n";
cout << 1 << ' ' << firstarr[i] << '\n';
goto nex;
}
}
}
cout << "NO\n";
nex:
continue;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int read() {
int ans = 0, sign = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') sign = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
ans = (ans << 1) + (ans << 3) + (ch ^ 48);
ch = getchar();
}
return ans * sign;
}
long long gcd(long long x, long long y) { return y == 0 ? x : (gcd(y, x % y)); }
int main() {
int T;
cin >> T;
while (T--) {
int n, m;
cin >> n >> m;
int num[1005];
memset(num, 0, sizeof(num));
for (int i = 0; i < n; i++) {
int x;
cin >> x;
if (!num[x]) num[x]++;
}
for (int i = 0; i < m; i++) {
int x;
cin >> x;
if (num[x]) num[x]++;
}
bool flag = 1;
for (int i = 0; i < 1005; i++) {
if (num[i] >= 2) {
cout << "YES" << '\n' << 1 << " " << i << '\n';
flag = 0;
break;
}
}
if (flag) cout << "NO" << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long int t;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
vector<int> v1(n), v2(m);
vector<int> v;
for (auto &x : v1) cin >> x;
for (auto &x : v2) cin >> x;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
if (v1[i] == v2[j]) v.push_back(v1[i]);
}
if (v.size()) {
cout << "Yes" << '\n';
cout << 1 << " " << v[0] << '\n';
} else
cout << "No" << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, n, m;
cin >> t;
for (int i = 0; i < t; i++) {
cin >> n >> m;
int a[1001] = {}, b[1001] = {}, p;
for (int j = 0; j < n; j++) {
cin >> p;
a[p]++;
}
for (int j = 0; j < m; j++) {
cin >> p;
b[p]++;
}
for (int j = 1; j <= 1000; j++) {
if (a[j] > 0 && b[j] > 0) {
cout << "YES" << endl << 1 << " " << j << endl;
break;
}
if (j == 1000) cout << "NO" << endl;
}
}
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
int main() {
std::ios::sync_with_stdio(false);
cin.tie(0);
cin.exceptions(cin.failbit);
int T;
cin >> T;
while (T--) {
long long int t, n, i, j, x, y, m, l, d, k;
cin >> n >> m;
vector<int> a(n), b(m);
for (i = 0; i < (n); ++i) cin >> a[i];
for (i = 0; i < (m); ++i) cin >> b[i];
for (i = 0; i < (n); ++i) {
for (j = 0; j < (m); ++j) {
if (a[i] == b[j]) {
cout << "YES"
<< "\n"
<< 1 << " " << a[i] << "\n";
x = 1;
break;
}
}
if (x == 1) break;
}
if (x == 0)
cout << "NO"
<< "\n";
else
x = 0;
}
}
|
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n, m;
cin >> n >> m;
vector<long long> v(1001, 0);
for (int i = 0; i < n; i++) {
long long input;
cin >> input;
v[input]++;
}
long long ans = 0;
for (int i = 0; i < m; i++) {
long long input;
cin >> input;
if (v[input] != 0) ans = input;
}
if (ans == 0)
cout << "NO"
<< "\n";
else {
cout << "YES"
<< "\n"
<< 1 << " " << ans << "\n";
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int tt = 1;
cin >> tt;
while (tt--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
int a[n], b[m];
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < m; i++) cin >> b[i];
int ans = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (b[j] == a[i]) {
ans = a[i];
break;
}
}
if (ans != 0) break;
}
if (ans == 0)
cout << "NO" << '\n';
else {
cout << "YES" << '\n';
cout << 1 << " " << ans << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int t, n, m, a[1005], b[1005], ans;
bool c[1005], lol;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> t;
while (t--) {
lol = false;
fill(c, c + 1005, false);
cin >> n >> m;
for (int i = 0; i < n; ++i) {
cin >> a[i];
c[a[i]] = true;
}
for (int i = 0; i < m; ++i) {
cin >> b[i];
if (c[b[i]] == true) {
ans = b[i];
lol = true;
}
}
if (lol == true)
cout << "YES\n1 " << ans << "\n";
else
cout << "NO\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int MOD = 1e9 + 7, MAX = 1e6 + 5;
const long long INF = 1e18 + 5;
int main() {
int t;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
set<int> S;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
S.insert(x);
}
int ans = -1;
for (int i = 0; i < m; i++) {
int x;
cin >> x;
if (S.count(x)) {
ans = x;
}
}
if (ans != -1) {
cout << "YES" << endl;
cout << 1 << " " << ans << endl;
} else
cout << "NO" << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main(int argc, const char* argv[]) {
std::ios::sync_with_stdio(false);
cout << fixed << setprecision(12);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
for (int k = 0; k < t; k++) {
vector<bool> nums(1010, 0);
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
int aux;
cin >> aux;
nums[aux] = 1;
}
bool ok = false;
for (int i = 0; i < m; i++) {
int aux;
cin >> aux;
if (nums[aux] and !ok) {
cout << "YES" << '\n';
cout << 1 << ' ' << aux << '\n';
ok = true;
}
}
if (!ok) cout << "NO" << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long const MAXN = 2e5 + 10;
long long n, m, T, a[MAXN], b[MAXN];
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> T;
while (T--) {
long long m;
cin >> n >> m;
for (long long i = 1; i <= n; ++i) cin >> a[i];
for (long long i = 1; i <= m; ++i) cin >> b[i];
long long flg = 0;
for (long long i = 1; i <= n; ++i)
for (long long j = 1; j <= m; ++j)
if (a[i] == b[j]) flg = a[i];
if (!flg)
cout << "NO\n";
else {
cout << "YES\n";
cout << 1 << " " << flg << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1010, INF = 0x3f3f3f3f;
int f[N];
int main() {
int T;
scanf("%d", &T);
while (T--) {
int n, m, res = INF, flag = 0;
int a[N], b[N];
scanf("%d%d", &n, &m);
memset(f, 0, sizeof f);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
f[a[i]] = 1;
}
for (int i = 0; i < m; i++) {
scanf("%d", &b[i]);
if (f[b[i]] == 1 && b[i] < res) {
res = b[i];
flag = 1;
}
}
if (flag)
printf("YES\n1 %d\n", res);
else
puts("NO");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
int a[n], b[m];
int flag = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < m; i++) {
cin >> b[i];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (a[i] == b[j]) {
flag = 1;
cout << "YES" << endl;
cout << 1 << " " << a[i] << endl;
break;
}
}
if (flag == 1) break;
}
if (flag == 0) cout << "NO" << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
int main() {
int tc;
cin >> tc;
while (tc--) {
vector<int> arr, ar, c;
int n, m;
cin >> n >> m;
arr.resize(n);
ar.resize(m);
for (auto &i : arr) cin >> i;
for (auto &i : ar) cin >> i;
sort(arr.begin(), arr.end());
vector<int> v(arr.size() + ar.size());
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (arr[i] == ar[j]) {
c.push_back(arr[i]);
break;
}
}
}
if (c.size() == 0)
cout << "NO\n";
else
cout << "YES\n" << 1 << " " << c[0] << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
while (t--) {
long long n, m, flag = 0;
cin >> n >> m;
long long a[n], b[m];
vector<long long> c;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < m; i++) cin >> b[i];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (a[i] == b[j]) {
c.push_back(a[i]);
flag = 1;
break;
}
}
}
if (flag == 1) {
cout << "YES\n";
cout << "1"
<< " " << c[0] << "\n";
} else
cout << "NO\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
int n, m, pos;
int i;
int count1 = 0, count2 = 0;
int arr1[1001], arr2[1001];
unordered_set<int> s1;
cin >> n;
cin >> m;
for (i = 0; i < n; i++) {
cin >> arr1[i];
s1.insert(arr1[i]);
}
for (i = 0; i < m; i++) {
cin >> arr2[i];
if (s1.find(arr2[i]) != s1.end()) {
count1++;
pos = i;
}
}
if (count1 > 0) {
cout << "YES"
<< "\n";
cout << 1 << " " << arr2[pos] << "\n";
} else
cout << "NO"
<< "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long t;
long long n, m;
void Solves() {
cin >> t;
while (t--) {
cin >> n >> m;
long long a[n + 5], b[m + 5], ans = 0;
map<long long, long long> Count;
long long result;
for (long long i = 0; i < n; i++) {
cin >> a[i];
Count[a[i]]++;
}
for (long long i = 0; i < m; i++) {
cin >> b[i];
if (Count[b[i]] > 0) {
ans = 1;
result = b[i];
}
}
if (ans != 0) {
cout << "YES" << endl;
cout << ans << " " << result << endl;
} else
cout << "NO" << endl;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
Solves();
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.