text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
int map[55][55];
int to[55][55][4][2];
int rx[] = {0, -1, 0, 1};
int ry[] = {1, 0, -1, 0};
struct node {
int x, y, dp, cp;
};
int main() {
memset(map, 0, sizeof(map));
int n, m, step, i, j;
char str[55];
node now;
now.x = 1, now.y = 1;
now.dp = 0, now.cp = 1;
scanf("%d %d", &n, &step);
scanf("%s", str + 1);
m = strlen(str + 1);
for (i = 1; i <= m; i++) map[1][i] = str[i] - '0';
for (i = 2; i <= n; i++) {
for (j = 1; j <= m; j++) scanf("%1d", &map[i][j]);
}
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) {
if (map[i][j] == 0) continue;
for (int dir = 0; dir < 4; dir++) {
int x = i;
int y = j;
while (1) {
x += rx[dir];
y += ry[dir];
if (map[x][y] != map[i][j]) {
x -= rx[dir];
y -= ry[dir];
break;
}
}
to[i][j][dir][0] = x;
to[i][j][dir][1] = y;
}
}
for (i = 0; i < step; i++) {
int x = to[now.x][now.y][now.dp][0];
int y = to[now.x][now.y][now.dp][1];
now.x = x, now.y = y;
now.x = to[x][y][(now.dp + now.cp + 4) % 4][0];
now.y = to[x][y][(now.dp + now.cp + 4) % 4][1];
x = now.x + rx[now.dp];
y = now.y + ry[now.dp];
if (map[x][y]) {
now.x = x, now.y = y;
} else {
if (now.cp == 1) {
now.cp = -1;
} else {
now.cp = 1;
now.dp = (now.dp - 1 + 4) % 4;
}
}
}
printf("%d\n", map[now.x][now.y]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dc[] = {1, 0, -1, 0};
int dr[] = {0, 1, 0, -1};
string b[55];
int *nxt[4][55];
int main() {
int m, n;
cin >> m >> n;
for (int i = 0; i < m; i++) {
cin >> b[i];
nxt[0][i] = new int[b[i].size()];
nxt[1][i] = new int[b[i].size()];
nxt[2][i] = new int[b[i].size()];
nxt[3][i] = new int[b[i].size()];
}
for (int i = 0; i < m; i++)
for (int j = b[i].size() - 1; j >= 0; j--)
nxt[0][i][j] = (j == b[i].size() - 1)
? j
: ((b[i][j] != b[i][j + 1]) ? j : nxt[0][i][j + 1]);
for (int i = 0; i < m; i++)
for (int j = b[i].size() - 1; j >= 0; j--)
nxt[3][i][j] =
(i == 0) ? i : ((b[i][j] != b[i - 1][j]) ? i : nxt[3][i - 1][j]);
for (int i = 0; i < m; i++)
for (int j = 0; j < b[i].size(); j++)
nxt[2][i][j] =
(j == 0) ? j : ((b[i][j] != b[i][j - 1]) ? j : nxt[2][i][j - 1]);
for (int i = m - 1; i >= 0; i--)
for (int j = b[i].size() - 1; j >= 0; j--)
nxt[1][i][j] =
(i == m - 1) ? i : ((b[i][j] != b[i + 1][j]) ? i : nxt[1][i + 1][j]);
int r = 0, c = 0;
int dp = 0;
int cp = -1;
for (int step = 0; step < n; step++) {
if (dp == 0 || dp == 2) {
c = nxt[dp][r][c];
r = nxt[(dp + cp + 4) % 4][r][c];
} else {
r = nxt[dp][r][c];
c = nxt[(dp + cp + 4) % 4][r][c];
}
int nextr = r + dr[dp];
int nextc = c + dc[dp];
if (nextr >= 0 && nextr < m && nextc >= 0 && nextc < b[0].size() &&
b[nextr][nextc] != '0')
r = nextr, c = nextc;
else {
if (cp == -1)
cp = 1;
else
cp = -1, dp = (dp + 1) % 4;
}
}
cout << b[r][c] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char a[52][52];
int vrh[52][52][4];
int u[] = {0, 0, 1, -1};
int v[] = {1, -1, 0, 0};
int main() {
int m, n, s;
scanf("%d%d", &m, &n);
for (int i = 0; i < m; i++) scanf("%s", a[i]);
s = strlen(a[0]);
for (int i = 0; i < m; i++)
for (int j = 0; j < s; j++)
if (a[i][j] != '0') {
int l = j, r = j, u = i, d = i;
while (l >= 0 && a[i][l] == a[i][j]) l--;
while (r < s && a[i][r] == a[i][j]) r++;
while (u >= 0 && a[u][j] == a[i][j]) u--;
while (d < m && a[d][j] == a[i][j]) d++;
l++;
r--;
u++;
d--;
vrh[i][j][0] = r;
vrh[i][j][1] = l;
vrh[i][j][2] = u;
vrh[i][j][3] = d;
}
int x = 0, y = 0, dp = 0, cp = -1;
while (n--) {
int nx, ny;
if (dp == 0 && cp == -1 || dp == 3 && cp == 1) {
nx = vrh[x][y][2];
ny = vrh[x][y][0];
} else if (dp == 3 && cp == -1 || dp == 1 && cp == 1) {
nx = vrh[x][y][2];
ny = vrh[x][y][1];
} else if (dp == 2 && cp == -1 || dp == 0 && cp == 1) {
nx = vrh[x][y][3];
ny = vrh[x][y][0];
} else if (dp == 1 && cp == -1 || dp == 2 && cp == 1) {
nx = vrh[x][y][3];
ny = vrh[x][y][1];
}
nx += u[dp];
ny += v[dp];
if (nx >= 0 && nx < m && ny >= 0 && ny < s && a[nx][ny] != '0') {
x = nx;
y = ny;
continue;
}
if (cp == -1)
cp = 1;
else {
cp = -1;
if (dp == 0)
dp = 2;
else if (dp == 2)
dp = 1;
else if (dp == 1)
dp = 3;
else if (dp == 3)
dp = 0;
}
}
cout << a[x][y] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > s;
struct block {
int u;
int l;
int d;
int r;
};
vector<block> bl;
void step(int &bp, int &state) {
int dx, dy, x, y;
x = bl[bp].u;
y = bl[bp].l;
dx = -1;
dy = -1;
if (state / 2 == 0) {
y = bl[bp].r;
dy = 1;
} else if (state / 2 == 1) {
x = bl[bp].d;
y = bl[bp].r;
dx = 1;
dy = 1;
} else if (state / 2 == 2) {
x = bl[bp].d;
dx = 1;
}
if (state / 2 % 2 == 0) {
if (state % 2 == 0) {
dy = 0;
} else {
dx = 0;
}
} else {
if (state % 2 != 0) {
dy = 0;
} else {
dx = 0;
}
}
if (s[x + dx][y + dy] == -1) {
state++;
state %= 8;
} else {
bp = s[x + dx][y + dy];
}
}
int main() {
int n, m;
cin >> m >> n;
vector<vector<char> > p(m + 2, vector<char>(52, '0'));
s = vector<vector<int> >(m + 2, vector<int>(52, -1));
int bp = 0;
int state = 1;
int d = -1;
getchar();
int t;
for (int i = 1; i <= m; i++) {
char c = getchar();
t = 1;
while (c != '\n' && c != EOF) {
p[i][t] = c;
c = getchar();
if (p[i][t] == p[i - 1][t]) {
s[i][t] = s[i - 1][t];
} else if (p[i][t] == p[i][t - 1]) {
s[i][t] = s[i][t - 1];
} else if (p[i][t] != '0') {
d++;
s[i][t] = d;
}
t++;
}
}
bl = vector<block>(d + 1);
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= 50; j++) {
if (p[i][j] != p[i - 1][j] && p[i][j] != p[i][j - 1] && p[i][j] != '0') {
bl[s[i][j]].u = i;
bl[s[i][j]].l = j;
}
if (p[i][j] != p[i + 1][j] && p[i][j] != p[i][j + 1] && p[i][j] != '0') {
bl[s[i][j]].d = i;
bl[s[i][j]].r = j;
}
}
}
for (int i = 0; i < n; i++) {
step(bp, state);
}
cout << p[bl[bp].u][bl[bp].l];
return 0;
}
|
#include <bits/stdc++.h>
using std::cin;
using std::cout;
using std::endl;
using std::min;
using std::sort;
using std::sqrt;
using std::stack;
using std::string;
using std::vector;
void go(int x, int y, int* x1, int* y1, int dp) {
*x1 = x;
*y1 = y;
if (dp == 0) (*x1)++;
if (dp == 1) (*y1)++;
if (dp == 2) (*x1)--;
if (dp == 3) (*y1)--;
return;
}
bool check(int x1, int y1, int m, int l) {
return ((x1 >= 0) && (x1 < l) && (y1 >= 0) && (y1 < m));
}
int main() {
int m, n;
string s;
cin >> m >> n;
vector<vector<int> > data(m);
for (int i = 0; i < m; ++i) {
cin >> s;
data[i].resize(s.size());
for (int j = 0; j < s.size(); ++j) data[i][j] = (s[j] - '0');
}
int l = s.size();
vector<vector<vector<int> > > move(
m, vector<vector<int> >(s.size(), vector<int>(8, -1)));
int cp = 0;
int dp = 0;
int x = 0;
int y = 0;
int mov = 0;
int per = 0;
while (mov < n) {
int x1, y1;
while (mov < n) {
while (true) {
go(x, y, &x1, &y1, dp);
if ((check(x1, y1, m, l)) && (data[y][x] == data[y1][x1])) {
if ((move[y][x][cp + 2 * dp] != mov) &&
(move[y][x][cp + 2 * dp] != -1)) {
per = mov - move[y][x][cp + 2 * dp];
while (n - per > mov) n -= per;
} else
move[y][x][cp + 2 * dp] = mov;
x = x1;
y = y1;
} else {
if ((move[y][x][cp + 2 * dp] != mov) &&
(move[y][x][cp + 2 * dp] != -1)) {
per = mov - move[y][x][cp + 2 * dp];
while (n - per > mov) n -= per;
} else
move[y][x][cp + 2 * dp] = mov;
break;
}
}
while (true) {
int cdp = (dp + 3 + 2 * cp) % 4;
go(x, y, &x1, &y1, cdp);
if ((check(x1, y1, m, l)) && (data[y][x] == data[y1][x1])) {
if ((move[y][x][cp + 2 * dp] != mov) &&
(move[y][x][cp + 2 * dp] != -1)) {
per = mov - move[y][x][cp + 2 * dp];
while (n - per > mov) n -= per;
} else
move[y][x][cp + 2 * dp] = mov;
x = x1;
y = y1;
} else {
if ((move[y][x][cp + 2 * dp] != mov) &&
(move[y][x][cp + 2 * dp] != -1)) {
per = mov - move[y][x][cp + 2 * dp];
while (n - per > mov) n -= per;
} else
move[y][x][cp + 2 * dp] = mov;
break;
}
}
go(x, y, &x1, &y1, dp);
if (check(x1, y1, m, l) && (data[y1][x1] != 0)) {
if ((move[y][x][cp + 2 * dp] != mov) &&
(move[y][x][cp + 2 * dp] != -1)) {
per = mov - move[y][x][cp + 2 * dp];
while (n - per > mov) n -= per;
} else
move[y][x][cp + 2 * dp] = mov;
x = x1;
y = y1;
++mov;
break;
} else {
if ((move[y][x][cp + 2 * dp] != mov) &&
(move[y][x][cp + 2 * dp] != -1)) {
per = mov - move[y][x][cp + 2 * dp];
while (n - per > mov) n -= per;
} else
move[y][x][cp + 2 * dp] = mov;
++cp;
if (cp == 2) {
cp = 0;
++dp;
}
dp = dp % 4;
++mov;
}
}
}
cout << data[y][x] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> move(const vector<string> &f, int bpx, int bpy, int cp, int dp) {
int dx, dy;
switch (cp) {
case 0:
dx = 1;
dy = 0;
break;
case 1:
dx = 0;
dy = 1;
break;
case 2:
dx = -1;
dy = 0;
break;
case 3:
dx = 0;
dy = -1;
break;
}
while (1) {
int nx = bpx + dx;
int ny = bpy + dy;
if (nx < 0 || f[0].size() <= nx || ny < 0 || f.size() <= ny ||
f[ny][nx] != f[bpy][bpx]) {
break;
}
bpx = nx;
bpy = ny;
}
int ddx, ddy;
switch (dp) {
case 0:
ddx = dy;
ddy = -dx;
break;
case 1:
ddx = -dy;
ddy = dx;
break;
}
while (1) {
int nx = bpx + ddx;
int ny = bpy + ddy;
if (nx < 0 || f[0].size() <= nx || ny < 0 || f.size() <= ny ||
f[ny][nx] != f[bpy][bpx]) {
break;
}
bpx = nx;
bpy = ny;
}
int nx = bpx + dx;
int ny = bpy + dy;
if (nx < 0 || f[0].size() <= nx || ny < 0 || f.size() <= ny ||
f[ny][nx] == '0') {
if (dp == 1) {
cp = (cp + 1) % 4;
}
dp = (dp + 1) % 2;
} else {
bpx = nx;
bpy = ny;
}
vector<int> v(4);
v[0] = bpx;
v[1] = bpy;
v[2] = cp;
v[3] = dp;
return v;
}
int solve(const vector<string> &f, int n, int bpx, int bpy, int cp, int dp) {
static map<vector<int>, int> before;
vector<int> v(4);
v[0] = bpx;
v[1] = bpy;
v[2] = cp;
v[3] = dp;
if (before.find(v) != before.end()) {
int sub = before[v] - n;
n %= sub;
}
before[v] = n;
if (n == 0) return f[bpy][bpx] - '0';
vector<int> next = move(f, bpx, bpy, cp, dp);
return solve(f, n - 1, next[0], next[1], next[2], next[3]);
}
int main(int argc, char *argv[]) {
int m, n;
cin >> m >> n;
vector<string> vs(m);
for (int i = 0; i < m; i++) {
cin >> vs[i];
}
int bpx = 0;
int bpy = 0;
int cp = 0;
int dp = 0;
int res = solve(vs, n, bpx, bpy, cp, dp);
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, k, d[5][2][100][100], kk;
int a[100][100];
bool was[100][100], done = false, was2[100][100][2][5];
string s;
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> s;
m = s.length();
for (int j = 0; j < m; j++) {
a[i][j] = s[j] - '0';
if (a[i][j] == 0) was[i][j] = true;
}
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (!was[i][j]) {
int ii = i, jj = j;
while (jj < m && a[i][jj] == a[i][j] && ii < n && a[ii][j] == a[i][j])
jj++, ii++;
while (ii < n && a[ii][j] == a[i][j]) ii++;
ii--;
while (jj < m && a[i][jj] == a[i][j]) jj++;
jj--;
for (int g = i; g <= ii; g++)
for (int h = j; h <= jj; h++) {
was[g][h] = true;
d[1][0][g][h] = ii * 100 + jj;
d[1][1][g][h] = i * 100 + jj;
d[2][0][g][h] = ii * 100 + j;
d[2][1][g][h] = ii * 100 + jj;
d[3][0][g][h] = i * 100 + j;
d[3][1][g][h] = ii * 100 + j;
d[4][0][g][h] = i * 100 + jj;
d[4][1][g][h] = i * 100 + j;
}
}
int in = 0, jn = 0, cp = 1, dp = 1, iin, jjn;
kk = k;
was2[0][0][1][1] = true;
while (k) {
bool flag = false;
k--;
iin = in, jjn = jn;
in = d[dp][cp][iin][jjn] / 100;
jn = d[dp][cp][iin][jjn] % 100;
if (dp == 1 && jn < m - 1 && a[in][jn + 1] != 0)
jn++, flag = true;
else if (dp == 2 && in < n - 1 && a[in + 1][jn] != 0)
in++, flag = true;
else if (dp == 3 && jn > 0 && a[in][jn - 1] != 0)
jn--, flag = true;
else if (dp == 4 && in > 0 && a[in - 1][jn] != 0)
in--, flag = true;
if (!flag)
if (cp == 1)
cp = 0;
else
cp = 1, dp = dp % 4 + 1;
if (was2[in][jn][cp][dp] && !done) k = k % (kk - k), done = true;
}
cout << a[in][jn];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void file_open() {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
const int di[] = {-1, 0, 1, 0}, dj[] = {0, 1, 0, -1},
dk[4][2] = {3, 1, 0, 2, 1, 3, 2, 0};
const int MAX = 60;
typedef int kieu[MAX][MAX];
struct point {
int x, y;
};
point tinh(kieu a, int i, int j, int dir) {
int t = a[i][j];
int u = i, v = j;
while (a[u][v] == t) {
u += di[dir];
v += dj[dir];
}
u -= di[dir];
v -= dj[dir];
point tmp = {u, v};
return tmp;
}
int main() {
int m, n, u, v, p;
kieu a = {};
char buff[100] = {};
int tr[MAX][MAX][8] = {};
point track[MAX * MAX * 8 + 1] = {};
scanf("%d%d\n", &m, &n);
u = v = 0;
for (int i = 1; i <= m; ++i) {
gets(buff);
p = strlen(buff);
for (int j = 1; j <= p; ++j) {
a[i][j] = buff[j - 1] - '0';
}
}
int bp, dp, cp, cost;
point tmp;
u = v = 1;
bp = a[u][v];
dp = 1;
cp = 0;
tr[u][v][dp * 2 + cp] = cost = 1;
track[1].x = 1;
track[1].y = 1;
while (n) {
int r1, r2, c1, c2, k;
k = dk[dp][cp];
tmp = tinh(a, u, v, dp);
r1 = tmp.x;
c1 = tmp.y;
tmp = tinh(a, r1, c1, k);
r2 = tmp.x;
c2 = tmp.y;
r1 = r2 + di[dp];
c1 = c2 + dj[dp];
if (a[r1][c1] == 0) {
r1 -= di[dp];
c1 -= dj[dp];
dp = (dp + cp) % 4;
cp = (cp + 1) % 2;
}
u = r1;
v = c1;
bp = a[u][v];
--n;
++cost;
if (tr[u][v][dp * 2 + cp]) {
cost = cost - tr[u][v][dp * 2 + cp];
n = n % cost;
tmp = track[tr[u][v][dp * 2 + cp] + n];
bp = a[tmp.x][tmp.y];
break;
} else {
tr[u][v][dp * 2 + cp] = cost;
tmp.x = u;
tmp.y = v;
track[cost] = tmp;
}
}
printf("%d", bp);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const char UP = '1';
const char DOWN = '2';
const char LEFT = '3';
const char RIGHT = '4';
const int MAX_N = 55;
string a[MAX_N];
int mas[MAX_N][MAX_N][7];
int bp_x, bp_y, bp_new_x, bp_new_y, m, n;
char dp, cp;
int way_up(int x, int y) {
int ans = 0;
char w = a[x][y];
while ((x >= 0) && (a[x][y] == w)) {
x--;
ans++;
}
ans--;
return (-ans);
}
int way_down(int x, int y) {
int ans = 0;
char w = a[x][y];
while ((x < m) && (a[x][y] == w)) {
x++;
ans++;
}
ans--;
return ans;
}
int way_right(int x, int y) {
int ans = 0;
char w = a[x][y];
string s = a[x];
while ((y < (int)s.length()) && (a[x][y] == w)) {
y++;
ans++;
}
ans--;
return ans;
}
int way_left(int x, int y) {
int ans = 0;
char w = a[x][y];
while ((y >= 0) && (a[x][y] == w)) {
y--;
ans++;
}
ans--;
return (-ans);
}
void change_way() {
if ((dp == RIGHT) && (cp == UP))
cp = DOWN;
else if ((dp == DOWN) && (cp == RIGHT))
cp = LEFT;
else if ((dp == LEFT) && (cp == DOWN))
cp = UP;
else if ((dp == UP) && (cp == LEFT))
cp = RIGHT;
else if ((dp == RIGHT) && (cp == DOWN)) {
dp = DOWN;
cp = RIGHT;
} else if ((dp == DOWN) && (cp == LEFT)) {
dp = LEFT;
cp = DOWN;
} else if ((dp == LEFT) && (cp == UP)) {
dp = UP;
cp = LEFT;
} else if ((dp == UP) && (cp == RIGHT)) {
dp = RIGHT;
cp = UP;
}
return;
}
int main() {
cin >> m >> n;
for (int i = 0; i < m; i++) cin >> a[i];
for (int i = 0; i < m; i++) {
string s = a[i];
for (int j = 0; j < (int)s.length(); j++)
if (a[i][j] != '0') {
mas[i][j][UP - '0'] = way_up(i, j);
mas[i][j][DOWN - '0'] = way_down(i, j);
mas[i][j][LEFT - '0'] = way_left(i, j);
mas[i][j][RIGHT - '0'] = way_right(i, j);
}
}
bp_x = 0;
bp_y = 0;
bp_new_x = 0;
bp_new_y = 0;
dp = RIGHT;
cp = UP;
for (int i = 0; i < n; i++) {
if ((dp == LEFT) || (dp == RIGHT))
bp_y += mas[bp_x][bp_y][dp - '0'];
else
bp_x += mas[bp_x][bp_y][dp - '0'];
if ((cp == LEFT) || (cp == RIGHT))
bp_y += mas[bp_x][bp_y][cp - '0'];
else
bp_x += mas[bp_x][bp_y][cp - '0'];
if (dp == RIGHT) {
if ((bp_y == (int)a[bp_x].length() - 1) || (a[bp_x][bp_y + 1] == '0'))
change_way();
else
bp_y++;
} else if (dp == LEFT) {
if ((bp_y == 0) || (a[bp_x][bp_y - 1] == '0'))
change_way();
else
bp_y--;
} else if (dp == UP) {
if ((bp_x == 0) || (a[bp_x - 1][bp_y] == '0'))
change_way();
else
bp_x--;
} else {
if ((bp_x == m - 1) || (a[bp_x + 1][bp_y] == '0'))
change_way();
else
bp_x++;
}
}
cout << a[bp_x][bp_y];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, M, L;
char board[100][100];
int dy[] = {-1, 0, 1, 0};
int dx[] = {0, 1, 0, -1};
int save_r[100][100][4];
int save_c[100][100][4];
int R, C, DP, CP;
bool on_board(int r, int c) { return 0 <= r && r < M && 0 <= c && c < L; }
void move_in_dir(int dir) {
int *mem_r = &save_r[R][C][dir];
int *mem_c = &save_c[R][C][dir];
if (*mem_r == -1) {
int next_r = R + dy[dir];
int next_c = C + dx[dir];
while (on_board(next_r, next_c) && board[next_r][next_c] == board[R][C]) {
R = next_r;
C = next_c;
next_r += dy[dir];
next_c += dx[dir];
}
*mem_r = R;
*mem_c = C;
} else {
R = *mem_r;
C = *mem_c;
}
}
void step() {
move_in_dir(DP);
move_in_dir((DP + CP) % 4);
int next_r = R + dy[DP];
int next_c = C + dx[DP];
if (!on_board(next_r, next_c) || board[next_r][next_c] == '0') {
if (CP == 3)
CP = 1;
else {
CP = 3;
DP = (DP + 1) % 4;
}
} else {
R = next_r;
C = next_c;
}
}
int main() {
scanf("%d %d ", &M, &N);
for (int i = 0; i < M; i++) gets(board[i]);
L = strlen(board[0]);
memset(save_r, -1, sizeof(save_r));
memset(save_c, -1, sizeof(save_c));
R = C = 0;
DP = 1;
CP = 3;
for (int i = 0; i < N; i++) step();
printf("%c\n", board[R][C]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = INT_MAX;
const double EPS = 1e-10;
inline double SQR(double x) { return x * x; }
inline long long SQR(long long x) { return x * x; }
inline int SQR(int x) { return x * x; }
inline double SQR3(double x) { return x * x * x; }
inline void DEBUG() { puts("jackie"); }
inline bool zero(double x) { return abs(x) < EPS; }
inline int inInt() {
int x = 0, c;
while ((unsigned int)((c = getchar()) - '0') >= 10) {
if ('-' == c) return -inInt();
}
do {
x = (x << 3) + (x << 1) + (c - '0');
} while ((unsigned int)((c = getchar()) - '0') < 10);
return x;
}
inline void outInt(int x) {
if (x < 0) {
putchar('-');
x = -x;
}
if (x >= 10) outInt(x / 10);
putchar((x % 10) + '0');
}
char mat[100][100];
pair<int, int> dir[100][100][4][2];
int M, N;
int len;
int DP, BPy, BPx, CP;
inline bool isValid(int x, int y) {
return (x >= 0 && x < M && y >= 0 && y < len);
}
int main() {
scanf("%d %d", &M, &N);
for (int i = 0; i < M; i++) {
scanf("%s", mat[i]);
}
len = strlen(mat[0]);
for (int i = 0; i < M; i++) {
for (int j = 0; j < len; j++) mat[i][j] -= '0';
}
int tmp;
for (int i = 0; i < M; i++) {
for (int j = 0; j < len; j++) {
int x = i, y = j;
while (isValid(x, y) && mat[x][y] == mat[i][j]) {
y++;
}
y--;
tmp = x;
while (isValid(x, y) && mat[x][y] == mat[i][j]) {
x--;
}
x++;
dir[i][j][0][0] = make_pair(x, y);
x = tmp;
while (isValid(x, y) && mat[x][y] == mat[i][j]) {
x++;
}
x--;
dir[i][j][0][1] = make_pair(x, y);
x = i, y = j;
while (isValid(x, y) && mat[x][y] == mat[i][j]) {
x++;
}
x--;
tmp = y;
while (isValid(x, y) && mat[x][y] == mat[i][j]) {
y++;
}
y--;
dir[i][j][1][0] = make_pair(x, y);
y = tmp;
while (isValid(x, y) && mat[x][y] == mat[i][j]) {
y--;
}
y++;
dir[i][j][1][1] = make_pair(x, y);
x = i, y = j;
while (isValid(x, y) && mat[x][y] == mat[i][j]) {
y--;
}
y++;
tmp = x;
while (isValid(x, y) && mat[x][y] == mat[i][j]) {
x++;
}
x--;
dir[i][j][2][0] = make_pair(x, y);
x = tmp;
while (isValid(x, y) && mat[x][y] == mat[i][j]) {
x--;
}
x++;
dir[i][j][2][1] = make_pair(x, y);
x = i, y = j;
while (isValid(x, y) && mat[x][y] == mat[i][j]) {
x--;
}
x++;
tmp = y;
while (isValid(x, y) && mat[x][y] == mat[i][j]) {
y--;
}
y++;
dir[i][j][3][0] = make_pair(x, y);
y = tmp;
while (isValid(x, y) && mat[x][y] == mat[i][j]) {
y++;
}
y--;
dir[i][j][3][1] = make_pair(x, y);
}
}
BPx = 0, BPy = 0;
DP = 0;
CP = 0;
int tx, ty;
for (int i = 0; i < N; i++) {
tx = dir[BPx][BPy][DP][CP].first;
ty = dir[BPx][BPy][DP][CP].second;
switch (DP) {
case 0: {
ty++;
break;
}
case 1: {
tx++;
break;
}
case 2: {
ty--;
break;
}
case 3: {
tx--;
break;
}
}
if (isValid(tx, ty) && 0 != mat[tx][ty]) {
BPx = tx, BPy = ty;
} else {
if (CP == 0)
CP = 1;
else {
CP = 0;
DP = (DP + 1) % 4;
}
}
}
printf("%d\n", mat[BPx][BPy]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int e[4];
int c;
} blocks[60][60];
struct node2 {
int x;
int y;
} current;
int main() {
int i, n, m, k;
char a[1000];
scanf("%d%d", &n, &m);
for (i = 0; i < 52; i++) {
blocks[0][i].c = 0;
}
for (i = 1; i <= n; i++) {
scanf("%s", a);
k = strlen(a);
blocks[i][0].c = 0;
int j;
for (j = 1; j <= k; j++) {
blocks[i][j].c = a[j - 1] - '0';
}
blocks[i][j + 1].c = 0;
}
for (int j = 0; j < 52; j++) blocks[i + 1][j].c = 0;
int cp = 0;
int dp = 1;
current.x = 1;
current.y = 1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= k; j++) {
if (blocks[i - 1][j].c == 0)
blocks[i][j].e[0] = 1;
else
blocks[i][j].e[0] = 0;
if (blocks[i + 1][j].c == 0)
blocks[i][j].e[2] = 1;
else
blocks[i][j].e[2] = 0;
if (blocks[i][j - 1].c == 0)
blocks[i][j].e[3] = 1;
else
blocks[i][j].e[3] = 0;
if (blocks[i][j + 1].c == 0)
blocks[i][j].e[1] = 1;
else
blocks[i][j].e[1] = 0;
}
while (m > 0) {
if (dp == 0) {
while (blocks[current.x][current.y].c ==
blocks[current.x - 1][current.y].c)
current.x--;
if (cp == 0)
while (blocks[current.x][current.y].c ==
blocks[current.x][current.y - 1].c)
current.y--;
if (cp == 1)
while (blocks[current.x][current.y].c ==
blocks[current.x][current.y + 1].c)
current.y++;
}
if (dp == 1) {
while (blocks[current.x][current.y].c ==
blocks[current.x][current.y + 1].c)
current.y++;
if (cp == 0)
while (blocks[current.x][current.y].c ==
blocks[current.x - 1][current.y].c)
current.x--;
if (cp == 1)
while (blocks[current.x][current.y].c ==
blocks[current.x + 1][current.y].c)
current.x++;
}
if (dp == 2) {
while (blocks[current.x][current.y].c ==
blocks[current.x + 1][current.y].c)
current.x++;
if (cp == 0)
while (blocks[current.x][current.y].c ==
blocks[current.x][current.y + 1].c)
current.y++;
if (cp == 1)
while (blocks[current.x][current.y].c ==
blocks[current.x][current.y - 1].c)
current.y--;
}
if (dp == 3) {
while (blocks[current.x][current.y].c ==
blocks[current.x][current.y - 1].c)
current.y--;
if (cp == 0)
while (blocks[current.x][current.y].c ==
blocks[current.x + 1][current.y].c)
current.x++;
if (cp == 1)
while (blocks[current.x][current.y].c ==
blocks[current.x - 1][current.y].c)
current.x--;
}
if (blocks[current.x][current.y].e[dp] != 1) {
if (dp == 0) current.x--;
if (dp == 1) current.y++;
if (dp == 2) current.x++;
if (dp == 3) current.y--;
m--;
} else {
if (cp == 1) dp = (dp + 1) % 4;
cp = 1 - cp;
m--;
}
}
cout << blocks[current.x][current.y].c;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int ix[4] = {0, 1, 0, -1};
int iy[4] = {1, 0, -1, 0};
int main() {
int n, r;
cin >> n >> r;
string s;
cin >> s;
int m = s.size();
vector<vector<int> > M(n + 2, vector<int>(m + 2, 0));
for (int j = 1; j <= m; ++j) M[1][j] = s[j - 1] - '0';
for (int i = 2; i <= n; ++i)
for (int j = 1; j <= m; ++j) {
char c;
cin >> c;
M[i][j] = c - '0';
}
vector<vector<vector<vector<int> > > > D(
n + 2, vector<vector<vector<int> > >(
m + 2, vector<vector<int> >(4, vector<int>(2, 0))));
bool primer = true;
int i = 1;
int j = 1;
int d = 0;
int c = 0;
for (int t = 1; t <= r; ++t) {
if (D[i][j][d][c] and primer) {
primer = false;
int cic = t - D[i][j][d][c];
t += (r - t) / cic * cic;
}
D[i][j][d][c] = t;
int b = M[i][j];
while (M[i][j] == b) {
i += ix[d];
j += iy[d];
}
i -= ix[d];
j -= iy[d];
int d2 = (d + 2 * c + 3) % 4;
while (M[i][j] == b) {
i += ix[d2];
j += iy[d2];
}
i -= ix[d2];
j -= iy[d2];
int i2 = i + ix[d];
int j2 = j + iy[d];
if (M[i2][j2]) {
i = i2;
j = j2;
} else {
if (c == 0)
c = 1;
else {
c = 0;
d = (d + 1) % 4;
}
}
}
cout << M[i][j] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int m, n, a[100][100], DP, CP;
struct P {
int x, y;
} BP;
void change_CP() { CP = abs(CP - 1); }
void change_DP() { DP = (DP + 1) % 4; }
void move() {
int tmp = a[BP.x][BP.y];
if (DP == 0) {
if (!CP) {
while (a[BP.x][BP.y + 1] == tmp) BP.y++;
while (a[BP.x - 1][BP.y] == tmp) BP.x--;
} else {
while (a[BP.x][BP.y + 1] == tmp) BP.y++;
while (a[BP.x + 1][BP.y] == tmp) BP.x++;
}
if (a[BP.x][BP.y + 1]) {
BP.y++;
return;
}
} else if (DP == 1) {
if (!CP) {
while (a[BP.x + 1][BP.y] == tmp) BP.x++;
while (a[BP.x][BP.y + 1] == tmp) BP.y++;
} else {
while (a[BP.x + 1][BP.y] == tmp) BP.x++;
while (a[BP.x][BP.y - 1] == tmp) BP.y--;
}
if (a[BP.x + 1][BP.y]) {
BP.x++;
return;
}
} else if (DP == 2) {
if (!CP) {
while (a[BP.x][BP.y - 1] == tmp) BP.y--;
while (a[BP.x + 1][BP.y] == tmp) BP.x++;
} else {
while (a[BP.x][BP.y - 1] == tmp) BP.y--;
while (a[BP.x - 1][BP.y] == tmp) BP.x--;
}
if (a[BP.x][BP.y - 1]) {
BP.y--;
return;
}
} else if (DP == 3) {
if (!CP) {
while (a[BP.x - 1][BP.y] == tmp) BP.x--;
while (a[BP.x][BP.y - 1] == tmp) BP.y--;
} else {
while (a[BP.x - 1][BP.y] == tmp) BP.x--;
while (a[BP.x][BP.y + 1] == tmp) BP.y++;
}
if (a[BP.x - 1][BP.y]) {
BP.x--;
return;
}
}
if (!CP) {
change_CP();
} else {
change_CP();
change_DP();
}
}
int main() {
cin >> m >> n;
string s;
for (int i = 1; i <= m; i++) {
cin >> s;
for (int j = 0; j < s.length(); j++) {
a[i][j + 1] = s[j] - '0';
}
}
BP.x = 1;
BP.y = 1;
while (n) {
move();
n--;
}
cout << a[BP.x][BP.y];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void prepare() {}
inline int get_(int i, int j, vector<vector<int> > &used) {
if (i < 0 || i >= used.size() || j < 0 || j >= used[0].size()) return -1;
return used[i][j];
}
void solve() {
int n, m;
cin >> n >> m;
string s;
cin >> s;
vector<char> color(1);
vector<vector<char> > v(n, vector<char>(s.size()));
vector<vector<int> > used(n, vector<int>(s.size()));
for (int j = 0; j < s.size(); ++j) {
v[0][j] = s[j];
if (v[0][j] == '0') used[0][j] = -1;
}
for (int i = 1; i < n; ++i) {
cin >> s;
for (int j = 0; j < s.size(); ++j) {
v[i][j] = s[j];
if (v[i][j] == '0') used[i][j] = -1;
}
}
int id = 1;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < v[0].size(); ++j)
if (!used[i][j]) {
int d = i + 1, r = j + 1;
while (d < n && v[i][j] == v[d][j]) ++d;
while (r < v[0].size() && v[i][j] == v[i][r]) ++r;
for (int q = i; q < d; ++q)
for (int p = j; p < r; ++p) used[q][p] = id;
color.push_back(v[i][j]);
++id;
}
}
vector<vector<int> > g(id, vector<int>(8));
;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < v[0].size(); ++j)
if (used[i][j] > 0 && v[i][j] != '0') {
int d = i + 1, r = j + 1;
while (d < n && used[i][j] == used[d][j]) ++d;
while (r < used[0].size() && used[i][j] == used[i][r]) ++r;
id = used[i][j];
for (int q = i; q < d; ++q)
for (int p = j; p < r; ++p) v[q][p] = '0';
g[id][0] = get_(d - 1, j - 1, used);
g[id][1] = get_(i, r, used);
g[id][2] = get_(i - 1, j, used);
g[id][3] = get_(d, r - 1, used);
g[id][4] = get_(i, j - 1, used);
g[id][5] = get_(d - 1, r, used);
g[id][6] = get_(i - 1, r - 1, used);
g[id][7] = get_(d, j, used);
}
}
id = 1;
int dp = 1, cp = 0;
for (int i = 0; i < m; ++i) {
if (g[id][cp * 4 + dp] != -1)
id = g[id][cp * 4 + dp];
else {
if (cp == 0)
cp = 1;
else {
cp = 0;
if (dp == 0)
dp = 2;
else if (dp == 1)
dp = 3;
else if (dp == 2)
dp = 1;
else
dp = 0;
}
}
}
cout << color[id] << endl;
}
int main() {
prepare();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void file_open() {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
const int di[] = {-1, 0, 1, 0}, dj[] = {0, 1, 0, -1},
dk[4][2] = {3, 1, 0, 2, 1, 3, 2, 0};
const int MAX = 60;
typedef int kieu[MAX][MAX];
struct point {
int x, y;
};
point tinh(kieu a, int i, int j, int dir) {
int t = a[i][j];
int u = i, v = j;
while (a[u][v] == t) {
u += di[dir];
v += dj[dir];
}
u -= di[dir];
v -= dj[dir];
point tmp = {u, v};
return tmp;
}
int main() {
int m, n, u, v, p;
kieu a = {};
point d[MAX][MAX][4] = {};
char buff[100] = {};
int tr[MAX][MAX][8] = {};
point track[MAX * MAX * 8 + 1] = {};
scanf("%d%d\n", &m, &n);
u = v = 0;
for (int i = 1; i <= m; ++i) {
gets(buff);
p = strlen(buff);
for (int j = 1; j <= p; ++j) {
a[i][j] = buff[j - 1] - '0';
}
}
for (int i = 1; i <= m; ++i)
for (int j = 1; j <= p; ++j)
for (int k = 0; k < 4; ++k)
if (a[i][j]) d[i][j][k] = tinh(a, i, j, k);
int bp, dp, cp, cost;
point tmp;
u = v = 1;
bp = a[u][v];
dp = 1;
cp = 0;
tr[u][v][dp * 2 + cp] = cost = 1;
track[1].x = 1;
track[1].y = 1;
while (n) {
int r1, r2, c1, c2, k;
k = dk[dp][cp];
r1 = d[u][v][dp].x;
c1 = d[u][v][dp].y;
r2 = d[r1][c1][k].x;
c2 = d[r1][c1][k].y;
r1 = r2 + di[dp];
c1 = c2 + dj[dp];
if (a[r1][c1] == 0) {
r1 -= di[dp];
c1 -= dj[dp];
dp = (dp + cp) % 4;
cp = (cp + 1) % 2;
}
u = r1;
v = c1;
bp = a[u][v];
--n;
++cost;
if (tr[u][v][dp * 2 + cp]) {
cost = cost - tr[u][v][dp * 2 + cp];
n = n % cost;
tmp = track[tr[u][v][dp * 2 + cp] + n];
bp = a[tmp.x][tmp.y];
break;
} else {
tr[u][v][dp * 2 + cp] = cost;
tmp.x = u;
tmp.y = v;
track[cost] = tmp;
}
}
printf("%d", bp);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int corners[4][2][2] = {
{{0, 3}, {2, 3}}, {{2, 3}, {2, 1}}, {{2, 1}, {0, 1}}, {{0, 1}, {0, 3}}};
int steps[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
struct block {
int data[4];
block(int x, int y) {
data[0] = x;
data[1] = y;
data[2] = 0;
data[3] = 0;
}
};
int m;
vector<block *> blocks[60];
string program[60];
vector<block *> cache;
bool ok(int a, int b) {
return a >= 0 && a < m && b >= 0 && b < (int)program[0].size();
}
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> m >> n;
for (int i = 0; i < m; ++i) cin >> program[i];
for (int i = 0; i < m; ++i)
for (size_t j = 0; j < program[i].size(); ++j)
if (program[i][j] != '0') {
char a = ok(i - 1, j) ? program[i - 1][j] : '0';
char b = ok(i, j - 1) ? program[i][j - 1] : '0';
if (a == program[i][j])
blocks[i].push_back(blocks[i - 1][j]);
else if (b == program[i][j])
blocks[i].push_back(blocks[i][j - 1]);
else {
blocks[i].push_back(new block(i, j));
cache.push_back(blocks[i][j]);
}
a = ok(i + 1, j) ? program[i + 1][j] : '0';
b = ok(i, j + 1) ? program[i][j + 1] : '0';
if (a != program[i][j] && b != program[i][j]) {
blocks[i][j]->data[2] = i;
blocks[i][j]->data[3] = j;
}
} else
blocks[i].push_back(0);
block *bp = blocks[0][0];
int dp = 0;
int cp = 0;
for (int i = 0; i < n; ++i) {
int x = bp->data[corners[dp][cp][0]] + steps[dp][0];
int y = bp->data[corners[dp][cp][1]] + steps[dp][1];
char c = ok(x, y) ? program[x][y] : '0';
if (c != '0')
bp = blocks[x][y];
else {
if (cp == 0)
cp = 1;
else {
cp = 0;
dp = (dp + 1) % 4;
}
}
}
cout << program[bp->data[0]][bp->data[1]] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int BP;
int DP = 2;
int CP = 1;
int col = 1;
int row = 1;
int mat[52][52];
int m;
long long n;
void up() {
while (mat[row - 1][col] == BP) {
row--;
}
}
void down() {
while (mat[row + 1][col] == BP) {
row++;
}
}
void left() {
while (mat[row][col - 1] == BP) {
col--;
}
}
void right() {
while (mat[row][col + 1] == BP) {
col++;
}
}
void move() {
BP = mat[row][col];
int trow = row, tcol = col;
switch (DP) {
case 0:
left();
if (CP)
down();
else
up();
col--;
break;
case 1:
up();
if (CP)
left();
else
right();
row--;
break;
case 2:
right();
if (CP)
up();
else
down();
col++;
break;
case 3:
down();
if (CP)
right();
else
left();
row++;
}
if (mat[row][col] <= 0) {
row = trow;
col = tcol;
if (CP) {
CP = 0;
} else {
CP = 1;
DP = (DP + 1) % 4;
}
}
}
int main() {
cin >> m >> n;
memset(mat, -1, sizeof(mat));
for (int i = 1; i <= m; i++) {
string s;
cin >> s;
for (int j = 1; j <= s.size(); j++) mat[i][j] = s[j - 1] - '0';
}
map<pair<pair<int, int>, pair<int, int>>, int> mymap;
row = 1;
col = 1;
DP = 2;
CP = 1;
bool find = true;
for (int i = 0; i < n; i++) {
move();
pair<pair<int, int>, pair<int, int>> a =
make_pair(make_pair(row, col), make_pair(DP, CP));
if (find) {
if (mymap.find(a) != mymap.end()) {
find = false;
i += ((n - 1 - i) / (i - mymap[a])) * (i - mymap[a]);
} else
mymap[a] = i;
}
}
cout << mat[row][col] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = numeric_limits<int>::max();
const double eps = 1.0e-12;
const double pi = 3.141592653589793238462643383279;
inline string readln() {
string _s;
getline(cin, _s);
return _s;
}
int main() {
int m, n;
cin >> m >> n;
readln();
string s = readln();
int p = s.length();
int c[m][p];
for (int j = 0; j < p; j++) c[0][j] = s[j] - '0';
for (int i = 1; i <= m - 1; i++)
for (int j = 0; j < p; j++) {
char a;
cin >> a;
c[i][j] = a - '0';
}
pair<int, int> f[m][p][4][2];
for (int i = 0; i < m; i++) {
for (int j = 0; j < p; j++) {
for (int h = 0; h < 4; h++) {
for (int k = 0; k < 2; k++) {
int y = i;
int x = j;
while (x >= 0 && x < p && y >= 0 && y < m && c[y][x] == c[i][j]) {
if (h == 0) {
x++;
} else if (h == 1) {
y++;
} else if (h == 2) {
x--;
} else if (h == 3) {
y--;
}
}
if (h == 0) {
x--;
} else if (h == 1) {
y--;
} else if (h == 2) {
x++;
} else if (h == 3) {
y++;
}
int d;
if (h == 0 && k == 0)
d = 3;
else if (h == 0 && k == 1)
d = 1;
else if (h == 1 && k == 0)
d = 0;
else if (h == 1 && k == 1)
d = 2;
else if (h == 2 && k == 0)
d = 1;
else if (h == 2 && k == 1)
d = 3;
else if (h == 3 && k == 0)
d = 2;
else if (h == 3 && k == 1)
d = 0;
while (x >= 0 && x < p && y >= 0 && y < m && c[y][x] == c[i][j]) {
if (d == 0) {
x++;
} else if (d == 1) {
y++;
} else if (d == 2) {
x--;
} else if (d == 3) {
y--;
}
}
if (d == 0) {
x--;
} else if (d == 1) {
y--;
} else if (d == 2) {
x++;
} else if (d == 3) {
y++;
}
f[i][j][h][k] = make_pair(y, x);
}
}
}
}
int x = 0, y = 0;
int h = 0, k = 0;
for (int i = 0; i < n; i++) {
y = f[y][x][h][k].first;
x = f[y][x][h][k].second;
if (h == 0) {
x++;
} else if (h == 1) {
y++;
} else if (h == 2) {
x--;
} else if (h == 3) {
y--;
}
if (x >= 0 && x < p && y >= 0 && y < m && c[y][x] > 0)
;
else {
if (h == 0) {
x--;
} else if (h == 1) {
y--;
} else if (h == 2) {
x++;
} else if (h == 3) {
y++;
}
if (k) h = (h + 1) % 4;
k = (k + 1) % 2;
;
}
}
cout << c[y][x] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 55 * 55;
int g[55][55], Set[55 * 55], mx[MaxN][2], my[MaxN][2], n, m, K;
int nxt[MaxN][8];
char s[55];
int dx[4] = {0, 1, 0, -1};
int dy[4] = {1, 0, -1, 0};
bool check(int x, int y) {
if (x < 0 || y < 0 || x >= n || y >= m || g[x][y] == 0) return 0;
return 1;
}
int find(int x) {
if (x == Set[x]) return x;
return Set[x] = find(Set[x]);
}
int main() {
scanf("%d%d", &n, &K);
for (int i = 0; i < n; i++) {
scanf("%s", s);
m = strlen(s);
for (int j = 0; j < m; j++) {
Set[i * m + j] = i * m + j;
g[i][j] = s[j] - '0';
}
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (g[i][j]) {
for (int d = 0; d < 2; d++) {
int x = i + dx[d], y = j + dy[d];
if (check(x, y) && g[x][y] == g[i][j])
Set[find(x * m + y)] = find(i * m + j);
}
}
for (int i = 0; i < n * m; i++) {
mx[i][0] = MaxN;
mx[i][1] = -MaxN;
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (g[i][j]) {
int s = find(i * m + j);
if (i < mx[s][0] || i == mx[s][0] && j < my[s][0])
mx[s][0] = i, my[s][0] = j;
if (i > mx[s][1] || i == mx[s][1] && j > my[s][1])
mx[s][1] = i, my[s][1] = j;
}
memset(nxt, -1, sizeof(nxt));
for (int i = 0; i < n * m; i++)
if (i == find(i)) {
int x, y;
x = mx[i][0], y = my[i][1] + 1;
if (check(x, y)) nxt[i][0] = find(x * m + y);
x = mx[i][1], y = my[i][1] + 1;
if (check(x, y)) nxt[i][1] = find(x * m + y);
x = mx[i][1] + 1, y = my[i][1];
if (check(x, y)) nxt[i][2] = find(x * m + y);
x = mx[i][1] + 1, y = my[i][0];
if (check(x, y)) nxt[i][3] = find(x * m + y);
x = mx[i][1], y = my[i][0] - 1;
if (check(x, y)) nxt[i][4] = find(x * m + y);
x = mx[i][0], y = my[i][0] - 1;
if (check(x, y)) nxt[i][5] = find(x * m + y);
x = mx[i][0] - 1, y = my[i][0];
if (check(x, y)) nxt[i][6] = find(x * m + y);
x = mx[i][0] - 1, y = my[i][1];
if (check(x, y)) nxt[i][7] = find(x * m + y);
}
int D = 0, pos = find(0);
for (int i = 0; i < K; i++) {
if (nxt[pos][D] == -1)
D = (D + 1) % 8;
else
pos = nxt[pos][D];
}
printf("%d\n", g[pos / m][pos % m]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int px[60][60][8], py[60][60][8], pz[60][60][8];
int m, n, p;
char g[60][60];
int dir[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
inline bool valid(int x, int y) { return (0 <= x && x < m && 0 <= y && y < n); }
int main() {
cin >> m >> p;
for (int i = 0; i < m; ++i) cin >> g[i];
n = strlen(g[0]);
int i, j, k, d1, d2, x, y, x1, y1;
for (i = 0; i < m; ++i)
for (j = 0; j < n; ++j)
for (k = 0; k < 8; ++k) {
d1 = k / 2, d2 = ((k & 1) ? d1 + 1 : d1 + 3) & 3;
x1 = i, y1 = j;
while (1) {
x = x1 + dir[d1][0], y = y1 + dir[d1][1];
if (!valid(x, y) || g[x][y] == '0' || g[x][y] != g[i][j]) break;
x1 = x, y1 = y;
}
while (1) {
x = x1 + dir[d2][0], y = y1 + dir[d2][1];
if (!valid(x, y) || g[x][y] == '0' || g[x][y] != g[i][j]) break;
x1 = x, y1 = y;
}
x = x1 + dir[d1][0], y = y1 + dir[d1][1];
if (!valid(x, y) || g[x][y] == '0') {
px[i][j][k] = x1, py[i][j][k] = y1;
if (k & 1)
pz[i][j][k] = ((k / 2 + 1) & 3) * 2;
else
pz[i][j][k] = k ^ 1;
} else
px[i][j][k] = x, py[i][j][k] = y, pz[i][j][k] = k;
}
int wx = 0, wy = 0, wz = 0, wx1, wy1, wz1;
while (p--) {
wx1 = px[wx][wy][wz];
wy1 = py[wx][wy][wz];
wz1 = pz[wx][wy][wz];
wx = wx1, wy = wy1, wz = wz1;
}
cout << g[wx][wy] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 55;
int n, m;
int t;
string ss[maxn];
bool mark[maxn][maxn][8];
int d[maxn][maxn][8];
int cp, bpx, bpy, dp;
int it;
bool isvalid(int i, int j) {
return i >= 0 && j >= 0 && i < n && j < m && ss[i][j] != '0';
}
void next(int& nx, int& ny, int di) {
if (di == 0) nx--;
if (di == 1) ny++;
if (di == 2) nx++;
if (di == 3) ny--;
}
bool bo;
void mov() {
if (t == it) {
cout << ss[bpx][bpy] << endl;
exit(0);
}
int nx, ny;
while (true) {
nx = bpx;
ny = bpy;
next(nx, ny, dp);
if (!isvalid(nx, ny) || ss[nx][ny] != ss[bpx][bpy]) break;
bpx = nx;
bpy = ny;
}
while (true) {
nx = bpx;
ny = bpy;
next(nx, ny, (4 + dp + (cp * 2 - 1)) % 4);
if (!isvalid(nx, ny) || ss[nx][ny] != ss[bpx][bpy]) break;
bpx = nx;
bpy = ny;
}
if (mark[bpx][bpy][cp * 4 + dp] && !bo) {
int tim = d[bpx][bpy][cp * 4 + dp];
int ans = (t - tim) % (it - tim);
it = 0;
t = ans;
if (t == 0) {
cout << ss[bpx][bpy] << endl;
exit(0);
}
bo = true;
}
mark[bpx][bpy][cp * 4 + dp] = true;
d[bpx][bpy][cp * 4 + dp] = it++;
nx = bpx;
ny = bpy;
next(nx, ny, dp);
if (isvalid(nx, ny)) {
bpx = nx;
bpy = ny;
} else {
if (cp) dp = (dp + 1) % 4;
cp = !cp;
}
}
int main() {
ios::sync_with_stdio(false);
dp = 1;
cin >> n >> t;
for (int i = 0; i < n; ++i) cin >> ss[i];
m = ss[0].size();
while (mov(), true)
;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int m, n;
char M[52][52];
int col = 1, row = 1;
int DP = 1;
int CP = 3;
void move_up() {
while (M[row][col] == M[row - 1][col]) --row;
}
void move_down() {
while (M[row][col] == M[row + 1][col]) ++row;
}
void move_left() {
while (M[row][col] == M[row][col - 1]) --col;
}
void move_right() {
while (M[row][col] == M[row][col + 1]) ++col;
}
void move_to(int nrow, int ncol) {
if (M[nrow][ncol] == 0 || M[nrow][ncol] == '0') {
if (CP == 3)
CP = 1;
else {
CP = 3;
DP = (DP + 1) % 4;
}
} else {
col = ncol;
row = nrow;
}
}
void move() {
switch (DP) {
case 0:
move_up();
if (CP == 3)
move_left();
else
move_right();
move_to(row - 1, col);
break;
case 2:
move_down();
if (CP == 3)
move_right();
else
move_left();
move_to(row + 1, col);
break;
case 3:
move_left();
if (CP == 3)
move_down();
else
move_up();
move_to(row, col - 1);
break;
case 1:
move_right();
if (CP == 3)
move_up();
else
move_down();
move_to(row, col + 1);
break;
}
}
int main() {
scanf("%i %i", &m, &n);
for (int i = 1; i <= m; ++i) scanf("%s", M[i] + 1);
while (n--) move();
printf("%c\n", M[row][col]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void file_open() {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
const int di[] = {-1, 0, 1, 0}, dj[] = {0, 1, 0, -1},
dk[4][2] = {3, 1, 0, 2, 1, 3, 2, 0};
const int MAX = 60;
typedef char kieu[MAX][MAX];
struct point {
int x, y;
};
point tinh(kieu a, int i, int j, int dir) {
int t = a[i][j];
int u = i, v = j;
while (a[u][v] == t) {
u += di[dir];
v += dj[dir];
}
u -= di[dir];
v -= dj[dir];
point tmp = {u, v};
return tmp;
}
int main() {
int m, n, u, v, p;
kieu a = {};
int tr[MAX][MAX][8] = {};
memset(tr, sizeof(tr), 0);
scanf("%d%d", &m, &n);
for (int i = 1; i <= m; ++i) {
scanf("%s", a[i] + 1);
p = strlen(a[i] + 1);
for (int j = 1; j <= p; ++j) {
a[i][j] = a[i][j] - '0';
}
}
int bp, dp, cp, cost, cycle = 0;
u = v = 1;
bp = a[u][v];
dp = 1;
cp = 0;
tr[u][v][dp * 2 + cp] = cost = 1;
point tmp;
while (n) {
int r1, r2, c1, c2, k;
k = dk[dp][cp];
tmp = tinh(a, u, v, dp);
r1 = tmp.x;
c1 = tmp.y;
tmp = tinh(a, r1, c1, k);
r2 = tmp.x;
c2 = tmp.y;
r1 = r2 + di[dp];
c1 = c2 + dj[dp];
if (a[r1][c1] == 0) {
r1 -= di[dp];
c1 -= dj[dp];
dp = (dp + cp) % 4;
cp = (cp + 1) % 2;
}
u = r1;
v = c1;
bp = a[u][v];
--n;
if (!cycle) {
++cost;
if (tr[u][v][dp * 2 + cp]) {
n = n % (cost - tr[u][v][dp * 2 + cp]);
cycle = 1;
} else
tr[u][v][dp * 2 + cp] = cost;
}
}
printf("%d", bp);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = 4 * atan(1.0);
void fast_stream() { std::ios_base::sync_with_stdio(0); }
vector<string> field;
const int lt = 2;
const int rt = 0;
const int up = 3;
const int down = 1;
const int dy[] = {-1, 0, 0, 1};
const int dx[] = {0, -1, 1, 0};
int h, w;
int color[101][101];
struct block {
pair<int, int> ru, rd, lu, ld;
int cl;
};
block blocks[10000];
void dfs(int x, int y, int cl) {
color[y][x] = cl;
if (blocks[cl].lu.first >= y && blocks[cl].lu.second >= x)
blocks[cl].lu = make_pair(y, x);
if (blocks[cl].ru.first >= y && blocks[cl].ru.second <= x)
blocks[cl].ru = make_pair(y, x);
if (blocks[cl].rd.first <= y && blocks[cl].rd.second <= x)
blocks[cl].rd = make_pair(y, x);
if (blocks[cl].ld.first <= y && blocks[cl].ld.second >= x)
blocks[cl].ld = make_pair(y, x);
for (int i = 0; i < 4; i++) {
int ny = y + dy[i];
int nx = x + dx[i];
if (ny >= 0 && nx >= 0 && ny < h && nx < w) {
char c1 = field[y][x];
char c2 = field[ny][nx];
if (color[ny][nx] == -1 && field[y][x] == field[ny][nx]) {
dfs(nx, ny, cl);
}
}
}
}
const int INF = 1000000000;
void solve() {
int m, n;
cin >> m >> n;
string s;
getline(cin, s);
for (int i = 0; i < 10000; i++) {
block &b = blocks[i];
b.lu.first = INF;
b.lu.second = INF;
b.ru.first = INF;
b.ru.second = -INF;
b.rd.first = -INF;
b.rd.second = -INF;
b.ld.first = -INF;
b.ld.second = INF;
}
for (int i = 0; i < m; i++) {
getline(cin, s);
field.push_back(s);
}
h = field.size();
w = field[0].size();
int num = 0;
memset(color, -1, sizeof(color));
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
if (color[i][j] == -1 && field[i][j] != '0') {
dfs(j, i, num);
num++;
}
}
}
pair<int, int> bp = make_pair(0, 0);
int cp = lt;
int dp = rt;
for (int i = 0; i < n; i++) {
int nb = color[bp.first][bp.second];
pair<int, int> nbp;
if (dp == 0) {
if (cp == lt) {
nbp = blocks[nb].ru;
} else
nbp = blocks[nb].rd;
nbp.second++;
} else if (dp == 1) {
if (cp == lt) {
nbp = blocks[nb].rd;
} else
nbp = blocks[nb].ld;
nbp.first++;
} else if (dp == 2) {
if (cp == lt) {
nbp = blocks[nb].ld;
} else
nbp = blocks[nb].lu;
nbp.second--;
} else if (dp == 3) {
if (cp == lt) {
nbp = blocks[nb].lu;
} else
nbp = blocks[nb].ru;
nbp.first--;
}
int ny = nbp.first;
int nx = nbp.second;
if (!(ny >= 0 && nx >= 0 && ny < h && nx < w) || field[ny][nx] == '0') {
if (cp == lt) {
cp = rt;
} else {
cp = lt;
dp++;
dp %= 4;
}
} else {
bp = nbp;
}
}
int res = field[bp.first][bp.second];
cout << res - '0' << endl;
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 gene(233);
inline char GET_CHAR() {
const int maxn = 131072;
static char buf[maxn], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, maxn, stdin), p1 == p2)
? EOF
: *p1++;
}
inline int getInt() {
int res(0);
char c = getchar();
while (c < '0') c = getchar();
while (c >= '0') {
res = res * 10 + (c - '0');
c = getchar();
}
return res;
}
inline long long fastpo(long long x, long long n, long long mod) {
long long res(1);
while (n) {
if (n & 1) {
res = res * (long long)x % mod;
}
x = x * (long long)x % mod;
n /= 2;
}
return res;
}
inline string itoa(int x, int width = 0) {
string res;
if (x == 0) res.push_back('0');
while (x) {
res.push_back('0' + x % 10);
x /= 10;
}
while ((int)res.size() < width) res.push_back('0');
reverse(res.begin(), res.end());
return res;
}
template <const long long mod>
struct MI {
long long a;
MI operator+(const MI& b) {
MI res{a + b.a};
if (res.a >= mod) res.a -= mod;
return res;
}
MI operator-(const MI& b) {
MI res{a - b.a};
if (res.a <= 0) res.a += mod;
return res;
}
MI operator*(const MI& b) { return MI{a * b.a % mod}; }
MI operator/(const MI& b) { return MI{a * fastpo(b.a, mod - 2, mod) % mod}; }
};
const int N = 100033;
const int LOG = 20;
const int mod = 1e9 + 7;
const int inf = 1e9 + 7;
int n, m;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
int dep[N], vst[N];
set<pair<int, int> > s[N];
vector<int> e[N];
bool ans[N];
int anc[N], o[N];
int cur[N];
int insert[N];
bool dfs(int v) {
vst[v] = true;
insert[v] = true;
for (int y : e[v]) {
if (!vst[y]) {
dep[y] = dep[v] + 1;
if (!dfs(y)) return false;
} else {
if (insert[y] == false || dep[y] > dep[v]) {
return false;
}
}
}
insert[v] = false;
return true;
}
int _ = 0;
void d1(int v) {
vst[v] = true;
cur[dep[v]] = v;
for (int y : e[v]) {
if (!vst[y]) {
dep[y] = dep[v] + 1;
d1(y);
if (s[v].size() < s[y].size()) {
swap(s[v], s[y]);
}
for (auto tmp : s[y]) {
s[v].insert(tmp);
}
s[y].clear();
} else {
s[v].insert(make_pair(dep[y], ++_));
}
}
while (!s[v].empty() && s[v].rbegin()->first >= dep[v]) {
s[v].erase(*s[v].rbegin());
}
anc[v] = -1;
if (s[v].size() >= 2) {
ans[v] = false;
} else if (s[v].size() == 1) {
anc[v] = cur[s[v].begin()->first];
}
}
void d2(int v) {
vst[v] = true;
if (anc[v] != -1) {
ans[v] &= ans[anc[v]];
}
for (int y : e[v]) {
if (!vst[y]) {
dep[y] = dep[v] + 1;
d2(y);
}
}
}
void run() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
e[x].push_back(y);
}
for (int i = 1; i <= n; i++) {
o[i] = i;
swap(o[i], o[gene() % i + 1]);
}
int LIM = 100;
for (int j = 1; j <= min(LIM, n); j++) {
int v = o[j];
fill(insert + 1, insert + 1 + n, false);
fill(vst + 1, vst + 1 + n, false);
dep[v] = 1;
if (dfs(v)) {
fill(vst + 1, vst + 1 + n, false);
fill(ans + 1, ans + 1 + n, true);
d1(v);
fill(vst + 1, vst + 1 + n, false);
d2(v);
int cnt = 0;
for (int i = 1; i <= n; i++) cnt += ans[i];
for (int i = 1; i <= n; i++) s[i].clear();
if (cnt * 5 < n) {
printf("-1\n");
return;
} else {
for (int i = 1; i <= n; i++) {
if (ans[i]) {
cnt--;
printf("%d%c", i, cnt ? ' ' : '\n');
}
}
return;
}
}
}
printf("-1\n");
}
int main() {
int t;
scanf("%d", &t);
for (int qq = 1; qq <= t; qq++) {
run();
for (int i = 1; i <= n; i++) e[i].clear();
}
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(420);
const int N = (int)1e5 + 100;
vector<int> T[N];
int vis[N];
int dep[N];
int deg[N];
vector<int> ord;
void shuffle() {
int q = ord.size();
int pi, qi;
for (int i = 0; i < 2 * q; i++) {
pi = ((int)rng() % q + q) % q;
qi = ((int)rng() % q + q) % q;
swap(ord[pi], ord[qi]);
}
}
bool valid;
void dfs(int u) {
vis[u] = 1;
for (auto x : T[u]) {
if (vis[x] == 0) {
dep[x] = dep[u] + 1;
dfs(x);
} else if (vis[x] == 2) {
valid = false;
}
}
vis[u] = 2;
}
bool good[N];
bool cons[N];
int par[N];
int dfs1(int u) {
vis[u] = true;
int cnt = 0;
int nx;
par[u] = u;
for (auto x : T[u]) {
if (!vis[x]) {
cnt += dfs1(x);
if (dep[par[x]] < dep[par[u]]) par[u] = par[x];
} else {
if (dep[x] < dep[par[u]]) par[u] = x;
cnt++;
}
}
cnt -= (deg[u] - 1);
if (cnt > 1) {
cons[u] = false;
} else {
cons[u] = true;
}
return cnt;
}
vector<int> out;
void dfs2(int u) {
vis[u] = true;
if (cons[u]) {
if (good[par[u]]) {
good[u] = true;
}
}
if (good[u]) {
out.push_back(u);
}
for (auto x : T[u]) {
if (!vis[x]) {
dfs2(x);
}
}
}
void solve() {
int n, m;
cin >> n >> m;
int u, v;
for (int i = 1; i <= n; i++) {
T[i].clear();
vis[i] = false;
deg[i] = 0;
good[i] = false;
}
for (int i = 1; i <= m; i++) {
cin >> u >> v;
T[u].push_back(v);
deg[v]++;
}
ord.clear();
for (int i = 1; i <= n; i++) {
ord.push_back(i);
}
shuffle();
int root = -1;
int cur;
for (int T = 0; T < 100; T++) {
if (ord.empty()) break;
cur = ord.back();
ord.pop_back();
for (int i = 1; i <= n; i++) {
vis[i] = 0;
dep[i] = -1;
}
valid = true;
dep[cur] = 0;
dfs(cur);
if (valid) {
root = cur;
break;
}
}
if (root == -1) {
cout << "-1\n";
return;
}
for (int i = 1; i <= n; i++) {
good[i] = false;
par[i] = -1;
vis[i] = false;
}
good[root] = true;
dfs1(root);
for (int i = 1; i <= n; i++) {
vis[i] = false;
}
out.clear();
dfs2(root);
if (out.size() < (n + 4) / 5) {
cout << "-1\n";
} else {
sort(out.begin(), out.end());
for (auto x : out) cout << x << " ";
cout << "\n";
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int tc;
cin >> tc;
for (int t = 1; t <= tc; t++) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000 + 10;
const int LIM = 300;
int n, m, h[maxn], ecnt;
struct enode {
int v, n;
enode() {}
enode(int _v, int _n) : v(_v), n(_n) {}
} e[maxn << 1];
inline void addedge(int u, int v) {
ecnt++;
e[ecnt] = enode(v, h[u]);
h[u] = ecnt;
}
int ans[maxn], acnt, val[maxn], vis[maxn], flag, inS[maxn];
void dfs(int u) {
vis[u] = 1;
inS[u] = 1;
for (int i = h[u]; ~i; i = e[i].n) {
int v = e[i].v;
if (!vis[v]) {
dfs(v);
} else if (!inS[v])
flag = 0;
}
inS[u] = 0;
}
inline bool check(int r) {
memset(vis, 0, (n + 5) * sizeof(int));
memset(inS, 0, (n + 5) * sizeof(int));
flag = 1;
dfs(r);
return flag;
}
int dfn[maxn], low[maxn], tim, tid[maxn], tag[maxn];
void dfs1(int u) {
dfn[u] = low[u] = ++tim;
tid[tim] = u;
vis[u] = 1;
for (int i = h[u]; ~i; i = e[i].n) {
int v = e[i].v;
if (!vis[v]) {
dfs1(v);
low[u] = min(low[u], low[v]);
tag[u] += tag[v];
} else {
low[u] = min(low[u], dfn[v]);
tag[u]++;
tag[v]--;
}
}
val[u] = (tag[u] <= 1);
}
void dfs2(int u) {
vis[u] = 1;
val[u] &= val[tid[low[u]]];
for (int i = h[u]; ~i; i = e[i].n) {
int v = e[i].v;
if (vis[v]) continue;
dfs2(v);
}
}
int lis[maxn];
inline void solve() {
srand(time(NULL));
scanf("%d%d", &n, &m);
ecnt = 0;
memset(h, -1, (n + 5) * sizeof(int));
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
addedge(u, v);
}
int r = -1;
for (int i = 1; i <= n; i++) lis[i] = i;
random_shuffle(lis + 1, lis + n + 1);
for (int i = 1; i <= LIM; i++) {
r = lis[i];
if (check(r)) break;
r = -1;
}
if (r == -1) {
puts("-1");
return;
}
tim = 0;
memset(vis, 0, (n + 5) * sizeof(int));
memset(tag, 0, (n + 5) * sizeof(int));
memset(val, 0, (n + 5) * sizeof(int));
dfs1(r);
memset(vis, 0, (n + 5) * sizeof(int));
dfs2(r);
acnt = 0;
for (int i = 1; i <= n; i++)
if (val[i]) ans[++acnt] = i;
if (acnt * 5 < n)
puts("-1");
else {
for (int i = 1; i < acnt; i++) printf("%d ", ans[i]);
printf("%d\n", ans[acnt]);
}
}
int main() {
int cas;
scanf("%d", &cas);
while (cas--) {
solve();
}
return 0;
}
|
#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;
};
vector<int> v(n);
for (int i = 0; i < n; i++) v[i] = i;
shuffle(v.begin(), v.end(), rng);
int r = -1;
for (int i = 0; i < 200 && i < n; i++) {
int u = v[i];
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;
template <typename tp>
inline void read(tp& x) {
x = 0;
char tmp;
bool key = 0;
for (tmp = getchar(); !isdigit(tmp); tmp = getchar()) key = (tmp == '-');
for (; isdigit(tmp); tmp = getchar()) x = (x << 3) + (x << 1) + (tmp ^ '0');
if (key) x = -x;
}
template <typename tp>
inline void ckmn(tp& x, tp y) {
x = x < y ? x : y;
}
template <typename tp>
inline void ckmx(tp& x, tp y) {
x = x < y ? y : x;
}
const int N = 100010;
struct edge {
int la, b;
} con[N << 1];
int tot, first[N];
void add_edge(int from, int to) {
con[++tot] = (edge){first[from], to};
first[from] = tot;
}
int n, m;
vector<int> ans;
void clear() {
tot = 0;
for (int i = (1); i <= (n); ++i) first[i] = 0;
}
int key = 0;
int dep[N], vis[N], inp[N], num[N], mnv[N], dp[N];
void dfs(int pos) {
vis[pos] = 1;
inp[pos] = 1;
mnv[pos] = pos;
for (int i = first[pos]; i; i = con[i].la) {
if (vis[con[i].b]) {
if (inp[con[i].b]) {
if (dep[con[i].b] < dep[mnv[pos]]) mnv[pos] = con[i].b;
++num[pos];
--num[con[i].b];
} else
key = 1;
} else {
dep[con[i].b] = dep[pos] + 1;
dfs(con[i].b);
num[pos] += num[con[i].b];
if (dep[mnv[con[i].b]] < dep[mnv[pos]]) mnv[pos] = mnv[con[i].b];
}
}
inp[pos] = 0;
}
void fsd(int pos) {
vis[pos] = 1;
if (dep[pos] > 0) {
if (num[pos] == 1) {
dp[pos] = dp[mnv[pos]];
}
}
for (int i = first[pos]; i; i = con[i].la)
if (!vis[con[i].b]) fsd(con[i].b);
}
bool doit(int rt) {
key = 0;
for (int i = (1); i <= (n); ++i) vis[i] = 0;
for (int i = (1); i <= (n); ++i) num[i] = 0;
dfs(rt);
if (key) return false;
for (int i = (1); i <= (n); ++i) dp[i] = 0;
dp[rt] = 1;
for (int i = (1); i <= (n); ++i) vis[i] = 0;
fsd(rt);
for (int i = (1); i <= (n); ++i)
if (dp[i]) ans.push_back(i);
return true;
}
void solve() {
int x, y;
int sed = 0;
read(n), read(m);
for (int i = (1); i <= (m); ++i) {
read(x), read(y);
add_edge(x, y);
sed = (sed + (long long)233 * x) % 998244353;
}
srand(sed);
ans.clear();
for (int _ = (1); _ <= (100); ++_) {
int rt = ((rand() << 16ll) | rand()) % n + 1;
if (doit(rt)) break;
}
if ((int)ans.size() * 5 < n) {
puts("-1");
} else {
for (int i = (0); i <= ((int)ans.size() - 1); ++i) printf("%d ", ans[i]);
puts("");
}
clear();
}
int main() {
int T;
read(T);
while (T--) solve();
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast", "unroll-loops", "no-stack-protector")
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using uint = unsigned int;
using ull = unsigned long long;
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
default_random_engine generator;
void solve();
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout << setprecision(16) << fixed;
cerr << setprecision(16) << fixed;
int tests = 1;
cin >> tests;
for (int test = 1; test <= tests; ++test) {
solve();
}
}
const int MAXN = 100100;
vector<int> g[MAXN];
int used[MAXN];
bool dfs(int v) {
used[v] = 1;
for (int u : g[v]) {
if (used[u] == 2) {
return false;
} else if (!used[u] && !dfs(u)) {
return false;
}
}
used[v] = 2;
return true;
}
int good[MAXN];
int up[MAXN][2];
int tin[MAXN];
int timer = 0;
int f[MAXN];
void update(int v, int x) {
if (x == 0 || tin[v] == x) {
return;
}
if (up[v][0] == 0 || up[v][0] > x) {
up[v][1] = up[v][0];
up[v][0] = x;
} else if (up[v][1] == 0 || up[v][1] > x) {
up[v][1] = x;
}
}
void dfs1(int v) {
used[v] = 1;
tin[v] = ++timer;
f[tin[v]] = v;
for (int u : g[v]) {
if (!used[u]) {
dfs1(u);
update(v, up[u][0]);
update(v, up[u][1]);
} else {
update(v, tin[u]);
}
}
}
void dfs2(int v) {
used[v] = 1;
good[v] = true;
if (up[v][1] != 0 || up[v][0] == 0) {
good[v] = false;
} else {
good[v] = good[f[up[v][0]]];
}
for (int u : g[v]) {
if (!used[u]) {
dfs2(u);
}
}
}
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);
}
int root = -1;
for (int t = 0; t < 100; ++t) {
memset(used, 0, sizeof(int) * n);
int v = rnd() % n;
if (dfs(v)) {
root = v;
break;
}
}
if (root == -1) {
cout << "-1\n";
return;
}
timer = 0;
memset(used, 0, sizeof(int) * n);
memset(up, 0, sizeof(up[0]) * n);
dfs1(root);
up[root][0] = tin[root];
memset(used, 0, sizeof(int) * n);
memset(good, 0, sizeof(int) * n);
dfs2(root);
vector<int> res;
for (int i = 0; i < n; ++i) {
if (good[i]) {
res.push_back(i);
}
}
if ((int)(res).size() * 5 >= n) {
for (int v : res) {
cout << v + 1 << " ";
}
cout << "\n";
} else {
cout << "-1\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<int> graph[100005];
bool vis[100005];
bool invis[100005];
vector<int> tree[100005];
vector<int> upedge[100005];
int upcnt[100005];
int psum[100005];
bool good[100005];
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
int bad_edges = 0;
void dfs(int node) {
vis[node] = true;
invis[node] = true;
for (int i = 0; i < graph[node].size(); i++) {
int nxt = graph[node][i];
if (!vis[nxt]) {
tree[node].push_back(nxt);
dfs(nxt);
} else if (invis[nxt]) {
upedge[node].push_back(nxt);
upcnt[nxt]++;
psum[node]++;
psum[nxt]--;
} else {
bad_edges++;
}
}
invis[node] = false;
}
int upnode[100005];
long long dfs2(int node) {
long long val = 0;
for (int i = 0; i < tree[node].size(); i++) {
val += dfs2(tree[node][i]);
psum[node] += psum[tree[node][i]];
}
val -= (long long)node * (long long)upcnt[node];
for (int i = 0; i < upedge[node].size(); i++) {
val += (long long)upedge[node][i];
}
if (psum[node] == 1) upnode[node] = val;
return val;
}
void dfs3(int node, bool root) {
good[node] = root || (psum[node] == 1 && good[upnode[node]]);
for (int i = 0; i < tree[node].size(); i++) {
dfs3(tree[node][i], false);
}
}
bool solve(int root) {
dfs(root);
if (bad_edges) return false;
dfs2(root);
dfs3(root, true);
vector<int> ans;
for (int i = 1; i <= n; i++) {
if (good[i]) ans.push_back(i);
}
if (ans.size() * 5 < n) {
printf("-1\n");
} else {
for (int i = 0; i < ans.size(); i++) {
printf("%d ", ans[i]);
}
printf("\n");
}
return true;
}
void work(void) {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
graph[u].push_back(v);
}
bool found = false;
for (int at = 1; at <= 120; at++) {
for (int i = 1; i <= n; i++) vis[i] = false;
for (int i = 1; i <= n; i++) good[i] = false;
for (int i = 1; i <= n; i++) tree[i].clear();
for (int i = 1; i <= n; i++) upedge[i].clear();
for (int i = 1; i <= n; i++) upcnt[i] = 0;
for (int i = 1; i <= n; i++) psum[i] = 0;
bad_edges = 0;
if (solve((rng() % n) + 1)) {
found = true;
break;
}
}
if (!found) {
printf("-1\n");
}
for (int i = 1; i <= n; i++) graph[i].clear();
}
int main() {
int T;
scanf("%d", &T);
for (int i = 1; i <= T; i++) work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
char ch = getchar();
int w = 1, c = 0;
for (; !isdigit(ch); ch = getchar())
if (ch == '-') w = -1;
for (; isdigit(ch); ch = getchar()) c = (c << 1) + (c << 3) + (ch ^ 48);
return w * c;
}
const int M = 2e5 + 10;
vector<int> v[M];
int n, m, dep[M], t[M], s[M], stk[M];
bool bad[M], flag, in[M];
void clr() {
for (int i = (1); i <= (n); ++i) v[i].clear(), bad[i] = 0;
}
void dfs(int x, int fa) {
in[x] = 1;
dep[x] = dep[fa] + 1;
bool fl = 0;
for (int y : v[x]) {
if (dep[y]) {
if (!in[y]) {
flag = 1;
} else {
if (dep[y] < dep[x]) {
t[x] = min(t[x], dep[y]);
s[x]++;
s[y]--;
}
}
} else
dfs(y, x);
}
in[x] = 0;
}
void ga(int x, int fa) {
for (int y : v[x]) {
if (dep[y] > dep[x]) {
ga(y, x);
t[x] = min(t[y], t[x]);
s[x] += s[y];
}
}
}
int num;
void dfs1(int x, int fa) {
stk[dep[x]] = x;
if (s[x] >= 2)
bad[x] = 1;
else if (t[x] < 1e9)
bad[x] = bad[stk[t[x]]];
num += !bad[x];
for (int y : v[x]) {
if (dep[y] > dep[x]) {
dfs1(y, x);
}
}
}
void doit(int x) {
num = 0;
ga(x, 0);
dfs1(x, 0);
int lim = n / 5;
if (n % 5 == 0) lim--;
if (num <= lim) {
puts("-1");
return;
}
for (int i = (1); i <= (n); ++i) {
if (!bad[i]) cout << i << " ";
}
cout << "\n";
}
void work() {
clr();
n = read();
m = read();
for (int i = (1); i <= (m); ++i) {
int x = read(), y = read();
v[x].push_back(y);
}
for (int T = (1); T <= (188); ++T) {
int x = 1ll * rand() * rand() % n + 1;
flag = 0;
for (int i = (1); i <= (n); ++i) dep[i] = s[i] = 0, t[i] = 1e9;
dfs(x, 0);
if (!flag) {
doit(x);
return;
}
}
puts("-1");
}
int main() {
int T = read();
srand(19260817);
while (T--) work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int n, m, fl[N];
int vis[N], op[N];
int S[N], dep[N];
vector<int> e[N];
void dfs_JUD(int x) {
++op[x];
if (op[x] > 1) return;
vis[x] = 1;
for (auto i : e[x])
if (!vis[i]) dfs_JUD(i);
vis[x] = 0;
}
bool JUD(int x) {
for (int i = (int)(1); i <= (int)(n); i++) vis[i] = op[i] = 0;
dfs_JUD(x);
for (int i = (int)(1); i <= (int)(n); i++)
if (op[i] != 1) return 0;
return 1;
}
void jud_1(int x) {
vis[x] = 1;
op[x] = 0;
for (auto i : e[x])
if (!vis[i]) {
dep[i] = dep[x] + 1;
jud_1(i);
if (dep[op[i]] < dep[op[x]]) op[x] = op[i];
S[x] += S[i];
} else {
S[x]++, S[i]--;
if (dep[i] < dep[op[x]]) op[x] = i;
}
vis[x] = 0;
}
void jud_2(int x) {
vis[x] = 1;
if (S[x] == 1) fl[x] |= fl[op[x]];
for (auto i : e[x])
if (!vis[i]) jud_2(i);
vis[x] = 0;
}
int rnd() {
int x = 0;
for (int i = (int)(1); i <= (int)(9); i++) x = x * 10 + rand() % 10;
return x;
}
void solve() {
scanf("%d%d", &n, &m);
for (int i = (int)(1); i <= (int)(n); i++) e[i].resize(0);
for (int i = (int)(1); i <= (int)(m); i++) {
int x, y;
scanf("%d%d", &x, &y);
e[x].push_back(y);
}
for (int i = (int)(1); i <= (int)(n); i++) fl[i] = 0;
int p = -1;
for (int i = (int)(1); i <= (int)(200); i++) {
int x = rnd() % n + 1;
if (JUD(x)) {
p = x;
break;
}
}
if (p == -1) {
cout << -1 << endl;
return;
}
fl[p] = 1;
dep[0] = 1 << 30;
for (int i = (int)(1); i <= (int)(n); i++) vis[i] = op[i] = S[i] = 0;
jud_1(p);
jud_2(p);
int sum = 0;
for (int i = (int)(1); i <= (int)(n); i++) sum += fl[i];
if (sum * 5 < n)
cout << -1 << endl;
else {
for (int i = (int)(1); i <= (int)(n); i++)
if (fl[i]) cout << i << ' ';
cout << endl;
}
}
int main() {
srand(time(NULL));
int T;
scanf("%d", &T);
while (T--) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 eng(chrono::high_resolution_clock::now().time_since_epoch().count());
int n;
basic_string<int> e[100005], sol;
bool st[100005];
int t[100005], dt;
int c[100005], d[100005];
long long h[100005];
bool ok;
vector<pair<int, int>> bck;
basic_string<int> f[100005];
void be(int x, int y) {
bck.emplace_back(x, y);
f[x] += y;
}
void dfs1(int x) {
st[x] = 1;
t[x] = dt++;
for (int y : e[x]) {
if (st[y]) {
be(x, y);
} else if (t[y] != -1) {
ok = 0;
} else {
dfs1(y);
}
}
st[x] = 0;
}
void dfs2(int x) {
for (int y : e[x]) {
if (t[y] > t[x]) {
dfs2(y);
c[x] += c[y];
h[x] += h[y];
}
}
}
void dfs3(int x) {
d[x] = c[x];
if (c[x] == 1) {
int anc = h[x];
if (d[anc] > 1) {
d[x] = 2;
}
}
for (int y : e[x]) {
if (t[y] > t[x]) {
dfs3(y);
}
}
}
void dfs4(int x) {
for (int y : e[x]) {
if (t[y] > t[x]) {
if (d[x] == 0) {
d[y] = 0;
}
dfs4(y);
}
}
}
bool rundfs(int r) {
dt = 0;
ok = 1;
bck = {};
for (int i = 0; i < n; i++) {
st[i] = 0;
t[i] = -1;
c[i] = 0;
h[i] = 0;
f[i] = {};
}
dfs1(r);
if (!ok) return 0;
for (int i = 0; i < n; i++)
if (t[i] == -1) return 0;
for (auto [x, y] : bck) {
c[x]++;
h[x] += y;
c[y]--;
h[y] -= y;
}
sol = {};
dfs2(r);
c[r] = 1;
h[r] = r;
dfs3(r);
dfs4(r);
for (int i = 0; i < n; i++)
if (d[i] == 1) sol += i;
return true;
}
int main() {
ios::sync_with_stdio(!cin.tie(0));
int t;
cin >> t;
while (t--) {
int m;
cin >> n >> m;
for (int i = 0; i < n; i++) e[i] = {};
sol = {};
while (m--) {
int x, y;
cin >> x >> y;
x--, y--;
e[x] += y;
}
int rep = 60;
while (rep > 0) {
rep--;
int x = uniform_int_distribution<int>(0, n - 1)(eng);
if (rundfs(x)) {
if ((int)sol.size() * 5 < n) {
cout << "-1\n";
rep = 1;
break;
}
sort(begin(sol), end(sol));
for (int x : sol) cout << x + 1 << ' ';
cout << '\n';
rep = 1;
break;
}
}
if (!rep) {
cout << "-1\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
std::istream& operator>>(std::istream& i, pair<T, U>& p) {
i >> p.first >> p.second;
return i;
}
template <typename T>
std::istream& operator>>(std::istream& i, vector<T>& t) {
for (auto& v : t) {
i >> v;
}
return i;
}
template <typename T, typename U>
std::ostream& operator<<(std::ostream& o, const pair<T, U>& p) {
o << p.first << ' ' << p.second;
return o;
}
template <typename T>
std::ostream& operator<<(std::ostream& o, const vector<T>& t) {
if (t.empty()) o << '\n';
for (size_t i = 0; i < t.size(); ++i) {
o << t[i] << " \n"[i == t.size() - 1];
}
return o;
}
template <typename T>
using minheap = priority_queue<T, vector<T>, greater<T>>;
template <typename T>
using maxheap = priority_queue<T, vector<T>, less<T>>;
unsigned int logceil(long long first) {
return first ? 8 * sizeof(long long) - __builtin_clzll(first) : 0;
}
namespace std {
template <typename T, typename U>
struct hash<pair<T, U>> {
hash<T> t;
hash<U> u;
size_t operator()(const pair<T, U>& p) const {
return t(p.first) ^ (u(p.second) << 7);
}
};
} // namespace std
template <typename T, typename F>
T bsh(T l, T h, const F& f) {
T r = -1, m;
while (l <= h) {
m = (l + h) / 2;
if (f(m)) {
l = m + 1;
r = m;
} else {
h = m - 1;
}
}
return r;
}
template <typename F>
double bshd(double l, double h, const F& f, double p = 1e-9) {
unsigned int r = 3 + (unsigned int)log2((h - l) / p);
while (r--) {
double m = (l + h) / 2;
if (f(m)) {
l = m;
} else {
h = m;
}
}
return (l + h) / 2;
}
template <typename T, typename F>
T bsl(T l, T h, const F& f) {
T r = -1, m;
while (l <= h) {
m = (l + h) / 2;
if (f(m)) {
h = m - 1;
r = m;
} else {
l = m + 1;
}
}
return r;
}
template <typename F>
double bsld(double l, double h, const F& f, double p = 1e-9) {
unsigned int r = 3 + (unsigned int)log2((h - l) / p);
while (r--) {
double m = (l + h) / 2;
if (f(m)) {
h = m;
} else {
l = m;
}
}
return (l + h) / 2;
}
template <typename T>
T gcd(T a, T b) {
if (a < b) swap(a, b);
return b ? gcd(b, a % b) : a;
}
template <typename T>
class vector2 : public vector<vector<T>> {
public:
vector2() {}
vector2(size_t a, size_t b, T t = T())
: vector<vector<T>>(a, vector<T>(b, t)) {}
};
template <typename T>
class vector3 : public vector<vector2<T>> {
public:
vector3() {}
vector3(size_t a, size_t b, size_t c, T t = T())
: vector<vector2<T>>(a, vector2<T>(b, c, t)) {}
};
template <typename T>
class vector4 : public vector<vector3<T>> {
public:
vector4() {}
vector4(size_t a, size_t b, size_t c, size_t d, T t = T())
: vector<vector3<T>>(a, vector3<T>(b, c, d, t)) {}
};
template <typename T>
class vector5 : public vector<vector4<T>> {
public:
vector5() {}
vector5(size_t a, size_t b, size_t c, size_t d, size_t e, T t = T())
: vector<vector4<T>>(a, vector4<T>(b, c, d, e, t)) {}
};
auto seed = chrono::high_resolution_clock::now().time_since_epoch().count();
std::mt19937 rng(seed);
using random_int = std::uniform_int_distribution<int>;
using random_ll = std::uniform_int_distribution<long long>;
struct TimeLimit {
TimeLimit(double seconds) : s(seconds - 0.2), last(clock()), mx(0) {}
operator bool() const {
clock_t cur = clock();
mx = max(mx, cur - last);
last = cur;
return clock() < s * CLOCKS_PER_SEC - 1.5 * mx;
}
double s;
mutable clock_t last, mx;
};
constexpr int ATTEMPTS = 100;
class E {
public:
int N, M;
vector<vector<int>> E;
vector<bool> Visited, OnStack;
vector<int> Stack, Order;
vector<int> StackId;
vector<pair<std::pair<int, int>, std::pair<int, int>>> Bad;
bool isInteresting(int v) {
if (Visited[v]) return OnStack[v];
Visited[v] = true;
OnStack[v] = true;
Stack.push_back(v);
for (int w : E[v]) {
if (!isInteresting(w)) return false;
}
Stack.pop_back();
OnStack[v] = false;
return true;
}
void add(int i, std::pair<int, int> first) {
if (first.first < Bad[i].first.first) {
Bad[i].second = Bad[i].first;
Bad[i].first = first;
} else if (first.first < Bad[i].second.first) {
Bad[i].second = first;
}
}
void dfs(int v) {
Order.push_back(v);
StackId[v] = Stack.size();
Bad[v] = {{StackId[v], v}, {StackId[v], v}};
Visited[v] = true;
OnStack[v] = true;
Stack.push_back(v);
for (int w : E[v]) {
if (Visited[w]) {
add(v, {StackId[w], w});
} else {
dfs(w);
add(v, Bad[w].first);
add(v, Bad[w].second);
}
}
Stack.pop_back();
OnStack[v] = false;
}
void solve(istream& cin, ostream& cout) {
int T;
cin >> T;
for (int t = 0; t < T; ++t) {
cin >> N >> M;
E.clear();
E.resize(N);
for (int i = 0; i < M; ++i) {
int a, b;
cin >> a >> b;
--a;
--b;
E[a].push_back(b);
}
int interesting = -1;
random_int R(0, N - 1);
for (int att = 0; att < ATTEMPTS; ++att) {
int start = R(rng);
Stack.clear();
Visited.assign(N, false);
OnStack.assign(N, false);
if (isInteresting(start)) {
interesting = start;
break;
}
}
if (interesting == -1) {
cout << "-1\n";
continue;
}
Stack.clear();
StackId.resize(N);
Visited.assign(N, false);
OnStack.assign(N, false);
Bad.resize(N);
Order.clear();
dfs(interesting);
vector<int> IsG(N, false);
for (int w : Order) {
if (w == interesting) {
IsG[w] = true;
} else if (Bad[w].second.first >= StackId[w]) {
IsG[w] = IsG[Bad[w].first.second];
}
}
vector<int> Good;
for (int i = 0; i < N; ++i)
if (IsG[i]) Good.push_back(i + 1);
if (Good.size() * 5 < N) {
cout << "-1\n";
} else {
cout << Good;
}
}
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
E solver;
std::istream& in(std::cin);
std::ostream& out(std::cout);
solver.solve(in, out);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool bo[200010];
int n, m, T, hd[200010], cnt, siz[200010], x, y, rt, fa[200010], f[200010],
dep[200010];
struct node {
int to, next;
} e[200010];
int ran() { return rand() % 1000 * 1000 + rand() % 1000; }
bool dfs(int x) {
bo[x] = 1;
for (int i = hd[x]; i; i = e[i].next)
if (e[i].to == rt || fa[e[i].to]) {
if (!bo[e[i].to]) return 0;
} else {
fa[e[i].to] = x;
if (!dfs(e[i].to)) return 0;
}
bo[x] = 0;
return 1;
}
void Dfs(int x) {
for (int i = hd[x]; i; i = e[i].next)
if (fa[e[i].to] == x)
dep[e[i].to] = dep[x] + 1, Dfs(e[i].to), siz[x] += siz[e[i].to];
}
void getans(int x) {
for (int i = hd[x]; i; i = e[i].next)
if (fa[e[i].to] == x) {
getans(e[i].to);
if (dep[f[e[i].to]] < dep[f[x]]) f[x] = f[e[i].to];
} else if (dep[e[i].to] < dep[f[x]])
f[x] = e[i].to;
}
void Getans(int x) {
if (siz[x] == 1) bo[x] &= bo[f[x]];
for (int i = hd[x]; i; i = e[i].next)
if (fa[e[i].to] == x) Getans(e[i].to);
}
int main() {
scanf("%d", &T);
while (T--) {
bool boo = 0;
scanf("%d%d", &n, &m), cnt = 0, dep[0] = n + 1;
for (int i = 1; i <= n; i++) hd[i] = siz[i] = f[i] = 0;
for (int i = 1; i <= m; i++)
scanf("%d%d", &x, &y), e[++cnt] = (node){y, hd[x]}, hd[x] = cnt;
for (int c = 1; c <= 100; c++) {
rt = ran() % n + 1;
for (int i = 1; i <= n; i++) bo[i] = 0, fa[i] = 0;
if (dfs(rt)) {
boo = 1;
break;
}
}
if (!boo) {
puts("-1");
continue;
}
for (int i = 1; i <= n; i++)
for (int j = hd[i]; j; j = e[j].next)
if (fa[e[j].to] != i) siz[i]++, siz[e[j].to]--;
dep[rt] = 0, Dfs(rt);
for (int i = 1; i <= n; i++) bo[i] = (siz[i] < 2);
getans(rt), Getans(rt), cnt = 0;
for (int i = 1; i <= n; i++) cnt += bo[i];
if (cnt * 5 < n)
puts("-1");
else {
for (int i = 1; i <= n; i++)
if (bo[i]) printf("%d ", i);
puts("");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
const int maxN = 1e5 + 10;
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
vector<int> g[maxN];
bool used[maxN];
int timer = 0;
int tin[maxN];
int tout[maxN];
int h[maxN];
int par[maxN];
void dfs(int v) {
used[v] = true;
tin[v] = timer++;
for (int to : g[v]) {
if (used[to]) continue;
h[to] = h[v] + 1;
par[to] = v;
dfs(to);
}
tout[v] = timer++;
}
int mn[maxN][2];
int to_who[maxN][2];
const int INF = (int)1e9;
void upd(int v, int val, int vert) {
if (val < mn[v][0]) {
mn[v][1] = mn[v][0];
to_who[v][1] = to_who[v][0];
mn[v][0] = val;
to_who[v][0] = vert;
} else if (val < mn[v][1]) {
mn[v][1] = val;
to_who[v][1] = vert;
}
}
bool is_bad[maxN];
void sec_dfs(int v) {
mn[v][0] = INF;
mn[v][1] = INF;
for (int to : g[v]) {
if (par[to] == v) {
sec_dfs(to);
for (int j = 0; j < 2; j++) {
upd(v, mn[to][j], to_who[to][j]);
}
} else {
int his_h = h[to];
upd(v, his_h, to);
}
}
if (par[v] != -1) {
assert(mn[v][0] < h[v]);
if (mn[v][1] < h[v]) {
is_bad[v] = true;
}
}
}
void last_dfs(int v) {
if (par[v] != -1) {
is_bad[v] |= is_bad[to_who[v][0]];
}
for (int to : g[v]) {
if (par[to] == v) {
last_dfs(to);
}
}
}
void solve() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
g[i].clear();
is_bad[i] = false;
}
for (int i = 1; i <= m; i++) {
int a, b;
cin >> a >> b;
g[a].emplace_back(b);
}
int C = -1;
for (int BUBEN = 0; BUBEN < 70; BUBEN++) {
timer = 0;
int who = rnd() % n + 1;
for (int i = 1; i <= n; i++) {
used[i] = false;
par[i] = -1;
}
h[who] = 0;
dfs(who);
bool all_ok = true;
for (int i = 1; i <= n; i++) {
if (!all_ok) break;
for (int to : g[i]) {
if (par[to] != i && (!(tin[to] <= tin[i] && tout[i] <= tout[to]))) {
all_ok = false;
break;
}
}
}
if (all_ok) {
C = who;
break;
}
}
if (C == -1) {
cout << -1 << '\n';
return;
}
sec_dfs(C);
last_dfs(C);
vector<int> ans;
for (int i = 1; i <= n; i++) {
if (!is_bad[i]) ans.emplace_back(i);
}
int at_least = (n + 4) / 5;
if ((int)ans.size() >= at_least) {
for (int v : ans) cout << v << " ";
cout << '\n';
} else {
cout << -1 << '\n';
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int tst;
cin >> tst;
while (tst--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast", "unroll-loops", "omit-frame-pointer", "inline")
#pragma GCC option("arch=native", "tune=native", "no-zero-upper")
#pragma GCC target("avx2")
using namespace std;
template <typename T>
void maxtt(T& t1, T t2) {
t1 = max(t1, t2);
}
template <typename T>
void mintt(T& t1, T t2) {
t1 = min(t1, t2);
}
bool debug = 0;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
string direc = "RDLU";
const long long MOD2 = (long long)1000000007 * (long long)1000000007;
long long ln, lk, lm;
void etp(bool f = 0) {
puts(f ? "YES" : "NO");
exit(0);
}
void addmod(int& x, int y, int mod = 1000000007) {
x += y;
if (x >= mod) x -= mod;
if (x < 0) x += mod;
assert(x >= 0 && x < mod);
}
void et(int x = -1) {
printf("%d\n", x);
exit(0);
}
long long fastPow(long long x, long long y, int mod = 1000000007) {
long long ans = 1;
while (y > 0) {
if (y & 1) ans = (x * ans) % mod;
x = x * x % mod;
y >>= 1;
}
return ans;
}
long long gcd1(long long x, long long y) { return y ? gcd1(y, x % y) : x; }
vector<int> mp[(100035)];
int d[(100035)];
int dp[(100035)][2];
bool ins[(100035)], vis[(100035)];
bool ck(int x, int pa) {
d[x] = d[pa] + 1;
vis[x] = 1;
ins[x] = 1;
for (int c : mp[x]) {
if (!vis[c]) {
if (!ck(c, x)) return 0;
} else {
if (!ins[c]) return 0;
}
}
ins[x] = 0;
return 1;
}
void add(int x, int dis) {
if (dis == (1 << 30)) return;
if (d[dis] >= d[x]) return;
if (dp[x][0] == (1 << 30) || d[dis] < d[dp[x][0]]) {
dp[x][1] = dp[x][0];
dp[x][0] = dis;
} else if (dp[x][1] == (1 << 30) || d[dis] < d[dp[x][1]]) {
dp[x][1] = dis;
}
}
void dfs(int x) {
for (int c : mp[x]) {
if (d[c] > d[x]) {
dfs(c);
add(x, dp[c][0]);
add(x, dp[c][1]);
} else {
add(x, c);
}
}
}
void dfs2(int x, int rt) {
if (x != rt) assert(dp[x][0] < (1 << 30));
if (!vis[x] && dp[x][1] == (1 << 30)) {
int w = dp[x][0];
if (vis[w]) {
vis[x] = 1;
}
}
for (int c : mp[x])
if (d[c] > d[x]) dfs2(c, rt);
}
void fmain(int tid) {
scanf("%d%d", &n, &m);
for (int(i) = 1; (i) <= (int)(n); (i)++) {
mp[i].clear();
}
for (int(i) = 1; (i) <= (int)(m); (i)++) {
int u, v;
scanf("%d%d", &u, &v);
mp[u].push_back(v);
}
if (m == 0) {
puts("1");
return;
}
mt19937 ttrand((int)time(0));
for (int(z) = 1; (z) <= (int)(100); (z)++) {
int x = n <= 100 ? z : uniform_int_distribution<int>(1, n)(ttrand);
for (int(i) = 1; (i) <= (int)(n); (i)++) {
d[i] = 0;
ins[i] = 0;
vis[i] = 0;
}
bool fg = ck(x, 0);
if (!fg) continue;
for (int(i) = 1; (i) <= (int)(n); (i)++) dp[i][0] = dp[i][1] = (1 << 30);
for (int(i) = 1; (i) <= (int)(n); (i)++) vis[i] = 0;
dfs(x);
vis[x] = 1;
dfs2(x, x);
int cnt = 0;
for (int(i) = 1; (i) <= (int)(n); (i)++)
if (vis[i]) cnt++;
if (cnt * 5 < n) {
puts("-1");
return;
}
for (int(i) = 1; (i) <= (int)(n); (i)++)
if (vis[i]) printf("%d ", i);
puts("");
return;
}
puts("-1");
}
int main() {
int t = 1;
scanf("%d", &t);
for (int(i) = 1; (i) <= (int)(t); (i)++) {
fmain(i);
}
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;
void per() { cerr << endl; }
template <typename Head, typename... Tail>
void per(Head H, Tail... T) {
cerr << H << ' ';
per(T...);
}
template <class T>
bool uin(T& a, T b) {
return a > b ? (a = b, true) : false;
}
template <class T>
bool uax(T& a, T b) {
return a < b ? (a = b, true) : false;
}
template <class U, class V>
ostream& operator<<(ostream& out, const pair<U, V>& a) {
return out << "(" << a.first << ", " << a.second << ")";
}
template <class U, class V>
istream& operator>>(istream& in, pair<U, V>& a) {
return in >> a.first >> a.second;
}
template <typename W,
typename T = typename enable_if<!is_same<W, string>::value,
typename W::value_type>::type>
ostream& operator<<(ostream& out, const W& v) {
out << "{ ";
for (const auto& first : v) out << first << ", ";
return out << '}';
}
template <class T>
void readArr(T from, T to) {
for (auto i = from; i != to; ++i) cin >> *i;
}
mt19937 mrand(1337);
unsigned int myRand32() { return mrand() & (unsigned int)(-1); }
unsigned long long myRand64() {
return ((unsigned long long)myRand32() << 32) ^ myRand32();
}
const int mod = 1000000007;
void add(int& a, int b) {
a += b;
if (a >= mod) a -= mod;
}
void dec(int& a, int b) {
a -= b;
if (a < 0) a += mod;
}
int mult(int a, int b) { return a * (long long)b % mod; }
int bp(int a, int b) {
int res = 1;
while (b > 0) {
if (b & 1) res = mult(res, a);
a = mult(a, a);
b >>= 1;
}
return res;
}
int n, m;
vector<int> g[100007];
int was[100007];
int h[100007];
int tin[100007];
int tout[100007];
int tt = 0;
void dfs(int v, int hh = 0) {
was[v] = 1;
tin[v] = tt++;
h[v] = hh;
for (int to : g[v])
if (!was[to]) {
dfs(to, hh + 1);
}
tout[v] = tt++;
}
bool isPred(int a, int b) { return tin[a] <= tin[b] && tout[b] <= tout[a]; }
int dd[100007];
int dp[100007];
int bad[100007];
void go(int v) {
dp[v] = dd[v];
for (int to : g[v])
if (h[to] == h[v] + 1) {
go(to);
dp[v] += dp[to];
}
}
int jump[100007];
set<int> se[100007];
void kek(int v) {
bad[v] = dp[v] >= 2;
for (int to : g[v])
if (h[to] == h[v] + 1) {
kek(to);
if (se[to].size() < se[v].size()) swap(se[to], se[v]);
for (int first : se[to]) se[v].insert(first);
se[v].erase(v);
} else
se[v].insert(to);
if (se[v].size() == 1) jump[v] = *se[v].begin();
}
void kek2(int v) {
if (dp[v] == 1 && bad[jump[v]]) bad[v] = 1;
for (int to : g[v])
if (h[to] == h[v] + 1) {
kek2(to);
}
}
void solve() {
cin >> n >> m;
for (int i = 0; i < n; ++i) g[i].clear(), se[i].clear();
for (int i = 0; i < m; ++i) {
int w1, w2;
cin >> w1 >> w2;
--w1;
--w2;
g[w1].push_back(w2);
}
int start = -1;
for (int it = 0; it < 99; ++it) {
int v = myRand32() % n;
fill(was, was + n, 0);
tt = 0;
dfs(v);
int ok = 1;
for (int v = 0; v < n; ++v) {
for (int to : g[v]) {
if (!isPred(v, to) && !isPred(to, v)) ok = 0;
if (h[v] + 1 < h[to]) ok = 0;
}
}
if (ok) {
start = v;
break;
}
}
if (start == -1) {
cout << "-1\n";
return;
}
fill(dd, dd + n, 0);
fill(dp, dp + n, 0);
fill(bad, bad + n, 0);
for (int v = 0; v < n; ++v) {
for (int to : g[v])
if (h[v] > h[to]) {
dd[v]++;
dd[to]--;
}
}
go(start);
kek(start);
kek2(start);
for (int v = 0; v < n; ++v) {
}
vector<int> res;
for (int v = 0; v < n; ++v)
if (!bad[v]) res.push_back(v);
if (res.size() * 5 < n) {
cout << "-1\n";
} else {
for (int v : res) cout << v + 1 << ' ';
cout << "\n";
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int tt;
cin >> tt;
while (tt--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<int> nxt[500001];
vector<int> sol;
int vis[500001], sta[500001], par[500001], h[500001];
int ok;
void DFS(int u, int he) {
vis[u] = sta[u] = 1;
h[u] = he;
for (int i = 0; i < nxt[u].size(); i++) {
int nt = nxt[u][i];
if (!vis[nt]) {
par[nt] = u;
DFS(nt, he + 1);
} else if (!sta[nt]) {
ok = 0;
}
}
sta[u] = 0;
}
int sum[500001];
int has[500001], tars[500001];
pair<int, int> DFS2(int u) {
int cnt = 0, tar = -1;
for (int i = 0; i < nxt[u].size(); i++) {
int nt = nxt[u][i];
if (par[nt] == u) {
pair<int, int> res = DFS2(nt);
cnt += res.first;
if (tar == -1 || h[tar] > h[res.second]) tar = res.second;
} else {
cnt++;
if (tar == -1 || h[tar] > h[nt]) tar = nt;
sum[nt]++;
}
}
cnt -= sum[u];
if (cnt == 0) tar = -1;
has[u] = (cnt == 1);
tars[u] = tar;
return make_pair(cnt, tar);
}
void DFS3(int u, int ori) {
if (u == ori) {
has[u] = 1;
} else if (has[u]) {
has[u] = has[tars[u]];
}
for (int i = 0; i < nxt[u].size(); i++) {
int nt = nxt[u][i];
if (par[nt] == u) DFS3(nt, ori);
}
}
bool check(int u) {
ok = 1;
for (int i = 1; i <= n; i++) vis[i] = sta[i] = 0;
DFS(u, 0);
return ok;
}
void others(int u) {
par[u] = -1;
for (int i = 1; i <= n; i++) sum[i] = 0;
DFS2(u);
DFS3(u, u);
for (int i = 1; i <= n; i++)
if (i != u && has[i]) sol.push_back(i);
}
void solve() {
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
sol.clear();
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
nxt[u].push_back(v);
}
int good = -1;
if (n <= 100) {
for (int i = 1; i <= n; i++)
if (check(i)) {
good = i;
break;
}
} else {
for (int i = 1; i <= 100; i++) {
int x = (rng() % n) + 1;
if (check(x)) {
good = x;
break;
}
}
}
if (good == -1) {
puts("-1");
for (int i = 1; i <= n; i++) nxt[i].clear();
for (int i = 1; i <= n; i++) par[i] = -1;
return;
}
sol.push_back(good);
others(good);
sort(sol.begin(), sol.end());
if (sol.size() * 5 < n) {
puts("-1");
} else {
for (int i = 0; i < sol.size(); i++)
printf("%d%c", sol[i], (i + 1 == sol.size() ? '\n' : ' '));
}
for (int i = 1; i <= n; i++) nxt[i].clear();
for (int i = 1; i <= n; i++) par[i] = -1;
}
int main() {
int t;
scanf("%d", &t);
while (t--) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-14;
struct edge {
int v, nxt;
} e[300001];
vector<int> gen[300001];
int head[300001], cnt, fz[300001], rt, sum, n, m, id[300001], dfn[300001], tot,
low[300001], low1[300001], rk[300001], used[100001];
bool vis[300001], al[300001], flag = 0, interest[300001];
inline void add(int u, int v) {
e[++cnt].v = v, e[cnt].nxt = head[u], head[u] = cnt;
}
inline void check(int u) {
vis[u] = 1;
al[u] = 1;
for (int i = head[u]; i; i = e[i].nxt) {
int to = e[i].v;
if (al[to] && !vis[to]) {
flag = 1;
continue;
} else if (al[to]) {
fz[u]++, gen[u].push_back(to);
continue;
}
check(to);
}
vis[u] = 0;
}
int tmptmptmp;
inline void dfs(int u) {
dfn[u] = low[u] = low1[u] = ++tot;
rk[tot] = u;
al[u] = 1;
for (int i = head[u]; i; i = e[i].nxt) {
int v = e[i].v;
if (!al[v]) {
dfs(v);
if (low[v] < low[u])
low1[u] = low[u], low[u] = low[v];
else if (low[v] < low1[u])
low1[u] = low[v];
if (low1[v] < low[u])
low1[u] = low[u], low[u] = low1[v];
else if (low1[v] < low1[u])
low1[u] = low1[v];
} else {
if (dfn[v] < low[u])
low1[u] = low[u], low[u] = dfn[v];
else if (dfn[v] < low1[u])
low1[u] = dfn[v];
}
}
}
inline void dfs1(int now) {
al[now] = 1;
if (!(low[now] < dfn[now] && low1[now] < dfn[now]) && interest[rk[low[now]]])
interest[now] = 1;
for (int i = head[now]; i; i = e[i].nxt) {
int to = e[i].v;
if (al[to]) continue;
dfs1(to);
}
}
int main() {
int T;
cin >> T;
while (T--) {
cin >> n >> m;
cnt = 0;
flag = 0;
rt = sum = 0;
for (int i = 1; i <= n; i++) {
head[i] = 0;
fz[i] = 0;
id[i] = i;
used[i] = 0;
interest[i] = 0;
gen[i].clear();
dfn[i] = 0;
low[i] = low1[i] = rk[i] = vis[i] = 0;
al[i] = 0;
}
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d%d", &u, &v);
add(u, v);
}
if (m == 0) {
printf("1\n");
continue;
}
int Sum = 0;
for (int i = 1; i <= 100; i++) {
random_shuffle(id + 1, id + 1 + n);
for (int j = 1; j <= n; j++) vis[j] = al[j] = 0;
flag = 0;
if (used[id[1]]) continue;
used[id[1]] = 1;
check(id[1]);
if (!flag) {
rt = id[1];
break;
}
}
if (!rt) {
cout << "-1" << endl;
continue;
}
interest[rt] = 1;
tot = 0;
for (int i = 1; i <= n; i++) al[i] = 0;
dfs(rt);
for (int i = 1; i <= n; i++) al[i] = 0;
dfs1(rt);
int temp = 0;
for (int i = 1; i <= n; i++) {
if (interest[i]) temp++;
}
if (1.0 * temp / n - 0.2 < -eps) {
printf("-1\n");
continue;
}
for (int i = 1; i <= n; i++) {
if (interest[i]) {
printf("%d ", i);
}
}
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long ksm(long long a, long long b) {
if (!b) return 1;
long long ns = ksm(a, b >> 1);
ns = ns * ns % 998244353;
if (b & 1) ns = ns * a % 998244353;
return ns;
}
int t;
int fa[100010];
int dfn[100010], low[100010], sz[100010];
int dfcnt;
vector<int> eg[100010];
int n, m;
int ans = 0;
void dfs1(int a) {
dfn[a] = ++dfcnt;
sz[a] = 1;
for (auto v : eg[a]) {
if (dfn[v]) continue;
fa[v] = a;
dfs1(v);
sz[a] += sz[v];
}
}
int fe[100010][2];
bool check(int v) {
for (int i = 1; i <= n; i++) fa[i] = 0, sz[i] = 0, dfn[i] = 0;
dfcnt = 0;
dfs1(v);
for (int i = 1; i <= n; i++)
for (auto v : eg[i]) {
if (fa[v] == i) continue;
if (dfn[i] >= dfn[v] && dfn[i] < dfn[v] + sz[v]) continue;
return 0;
}
for (int i = 1; i <= n; i++)
if (!dfn[i]) return 0;
return 1;
}
int tp[100010], to[100010];
int bk[100010];
void ins(int id, int t) {
if (t <= fe[id][0])
fe[id][1] = fe[id][0], fe[id][0] = t;
else if (t <= fe[id][1])
fe[id][1] = t;
}
void dfs2(int a) {
fe[a][0] = fe[a][1] = dfn[a];
low[a] = dfn[a];
for (auto v : eg[a])
if (dfn[v] < dfn[a]) {
low[a] = min(low[a], dfn[v]);
ins(a, dfn[v]);
} else {
dfs2(v);
low[a] = min(low[a], low[v]);
for (int j = 0; j < 2; j++) ins(a, fe[v][j]);
}
}
void work(int pl) {
for (int i = 1; i <= n; i++) bk[dfn[i]] = i;
dfs2(pl);
for (int i = 1; i <= n; i++) {
int id = bk[i];
tp[id] = 1;
if (fe[id][1] < dfn[id]) tp[id] = 0;
if (fe[id][0] < dfn[id] && !tp[bk[fe[id][0]]]) tp[id] = 0;
}
for (int i = 1; i <= n; i++) {
int id = bk[i];
if (i == 1)
to[id] = 1;
else {
to[id] = 0;
int e = bk[fe[id][0]];
if (to[e]) to[id] = 1;
}
}
}
int main() {
int t;
cin >> t;
while (t--) {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) eg[i].clear();
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
eg[u].push_back(v);
}
int pl = 0, fl = 0;
for (int t = 0; t < 80; t++) {
pl = (rand() % 32768) * 32768 + rand() % 32768;
pl = pl % n + 1;
if (check(pl)) {
fl = 1;
break;
}
}
if (!fl)
cout << -1 << endl;
else {
work(pl);
int ans = 0;
for (int i = 1; i <= n; i++)
if (tp[i] && to[i]) ans++;
if (ans * 5 < n)
cout << -1 << endl;
else {
for (int i = 1; i <= n; i++)
if (tp[i] && to[i]) {
printf("%d ", i);
}
printf("\n");
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,unroll-loops")
using namespace std;
mt19937 rng((int)std::chrono::steady_clock::now().time_since_epoch().count());
const int N = 1e5 + 3;
int ok[N], tsz[N], dep[N];
vector<int> adj[N], g[N];
multiset<int> mset[N];
int vis[N];
bool flag;
void dfs2(int u) {
vis[u] = 1;
for (auto v : adj[u]) {
if (vis[v] == 2) flag = false;
if (!vis[v]) dfs2(v);
}
vis[u] = 2;
}
void dfs(int u, int keep) {
vis[u] = 1;
int bigchild = -1, high = -1;
for (auto v : adj[u]) {
if (!vis[v] and tsz[v] > high) {
high = tsz[v];
bigchild = v;
}
}
multiset<int> backEdge;
for (auto v : adj[u]) {
if (!vis[v] and v != bigchild)
dfs(v, 0);
else if (vis[v] == 1)
backEdge.insert(v);
}
if (bigchild != -1) {
dfs(bigchild, 1);
swap(mset[u], mset[bigchild]);
}
for (auto x : backEdge) mset[u].insert(x);
for (auto v : adj[u]) {
if (v != bigchild) {
for (auto x : mset[v]) {
mset[u].insert(x);
}
}
}
mset[u].erase(u);
if (int(mset[u].size()) == 1) {
g[*mset[u].begin()].push_back(u);
}
vis[u] = 2;
}
bool interesting(int u) {
flag = true;
dfs2(u);
return flag;
}
void dfs4(int u) {
vis[u] = 1;
ok[u] = 1;
for (int v : g[u]) {
if (!vis[v]) dfs4(v);
}
vis[u] = 2;
}
int dfs3(int u, int d = 0) {
vis[u] = 1;
dep[u] = d;
for (auto v : adj[u]) {
if (!vis[v]) tsz[u] += dfs3(v, d + 1);
}
vis[u] = 2;
return tsz[u] + 1;
}
void solve() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; ++i)
adj[i].clear(), tsz[i] = 0, mset[i].clear(), ok[i] = 0, g[i].clear();
for (int i = 0; i < m; ++i) {
int a, b;
cin >> a >> b;
adj[a].push_back(b);
}
int root = -1;
for (int t = 0; t < 100; ++t) {
int u = rng() % n + 1;
if (interesting(u)) {
root = u;
}
for (int i = 1; i <= n; ++i) vis[i] = 0;
if (root != -1) break;
}
if (root == -1) {
cout << -1 << endl;
return;
}
dfs3(root);
for (int i = 1; i <= n; ++i) vis[i] = 0;
dfs(root, 0);
for (int i = 1; i <= n; ++i) vis[i] = 0;
dfs4(root);
vector<int> ans;
for (int i = 1; i <= n; ++i)
if (ok[i]) ans.push_back(i);
if (5 * int(ans.size()) < n)
cout << -1 << endl;
else {
for (auto x : ans) cout << x << " ";
cout << endl;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename G>
struct triple {
G first, S1, S2, T;
};
mt19937 rng(chrono::high_resolution_clock::now().time_since_epoch().count());
template <typename T>
static T randint(T lo, T hi) {
return uniform_int_distribution<T>(lo, hi)(rng);
}
struct DS {
vector<int> parent, cont;
vector<bool> interesting;
DS(int n) : parent(n), cont(n, 1), interesting(n, true) {
for (int i = 0; i < n; i++) parent[i] = i;
}
int SetOf(int x) {
return parent[x] = (parent[x] == x ? x : SetOf(parent[x]));
}
void Merge(int x, int y) {
x = SetOf(x);
y = SetOf(y);
if (x == y) return;
if (cont[x] > cont[y]) swap(x, y);
parent[x] = y;
cont[y] += cont[x];
interesting[y] = (interesting[y] & interesting[x]);
}
};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.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 x, y;
cin >> x >> y;
--x;
--y;
g[x].push_back(y);
}
vector<int> seen(n);
function<bool(int)> dfs1 = [&](int c) {
bool ok = true;
seen[c] = -1;
for (auto v : g[c]) ok &= (seen[v] == -1 || (seen[v] == 0 && dfs1(v)));
seen[c] = 1;
return ok;
};
bool found = false;
int r = -1;
for (int i = 0; i < 100; i++) {
r = randint(0, n - 1);
if (dfs1(r)) {
found = true;
break;
}
for (int j = 0; j < n; j++) seen[j] = 0;
}
if (!found) {
cout << "-1\n";
continue;
}
for (int i = 0; i < n; i++) seen[i] = 0;
vector<int> p(n);
vector<int> a(n);
function<void(int)> dfs2 = [&](int c) {
seen[c] = -1;
for (auto v : g[c])
if (seen[v] == 0) {
p[v] = p[c] + 1;
dfs2(v);
a[c] += a[v];
} else {
++a[c];
--a[v];
}
seen[c] = 1;
};
dfs2(r);
DS ds(n);
for (int i = 0; i < n; i++)
if (a[i] > 1) ds.interesting[i] = false;
for (auto &i : seen) i = 0;
function<int(int)> dfs3 = [&](int c) {
int up = -1;
seen[c] = -1;
for (auto v : g[c])
if (seen[v] == 0) {
int temp = dfs3(v);
if (p[temp] < p[c] && (up == -1 || p[up] > p[temp])) up = temp;
} else {
int temp = v;
if (up == -1 || p[up] > p[temp]) up = temp;
}
seen[c] = 1;
if (up != -1 && a[c] <= 1) {
ds.Merge(c, up);
}
return up;
};
dfs3(r);
vector<int> ans;
for (int i = 0; i < n; i++)
if (ds.interesting[ds.SetOf(i)]) ans.push_back(i);
sort(ans.begin(), ans.end());
if (ans.size() * 5 < n)
cout << "-1\n";
else
for (int i = 0; i < ans.size(); i++)
cout << ans[i] + 1 << " \n"[i == ans.size() - 1];
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
default_random_engine e;
int n, m, vis[N];
vector<int> v[N];
bool ok;
void dfs(int pos) {
vis[pos] = 1;
for (auto &i : v[pos])
if (!vis[i])
dfs(i);
else if (vis[i] == 2)
ok = 0;
vis[pos] = 2;
}
bool check(int pos) {
for (int i = 1; i <= n; i++) vis[i] = 0;
ok = 1;
dfs(pos);
return ok;
}
bool bad[N];
int dep[N], low[N], val[N];
int find_bad(int pos) {
vis[pos] = 1;
low[pos] = pos;
for (auto &i : v[pos])
if (!vis[i]) {
dep[i] = dep[pos] + 1, val[pos] += find_bad(i);
if (dep[low[i]] < dep[low[pos]]) low[pos] = low[i];
} else {
++val[pos];
--val[i];
if (dep[i] < dep[low[pos]]) low[pos] = i;
}
if (val[pos] > 1) bad[pos] = 1;
return val[pos];
}
void pushdown(int pos) {
vis[pos] = 1;
if (bad[low[pos]]) bad[pos] = 1;
for (auto &i : v[pos])
if (!vis[i]) pushdown(i);
}
int main() {
ios::sync_with_stdio(false);
e.seed(time(0));
int T;
cin >> T;
while (T--) {
cin >> n >> m;
for (int i = 1; i <= n; i++) v[i].clear();
uniform_int_distribution<int> u(1, n);
int t1, t2, rt = -1;
for (int i = 1; i <= m; i++) {
cin >> t1 >> t2;
v[t1].push_back(t2);
}
for (int t = 100; t > 0; --t) {
int cur = u(e);
if (check(cur)) {
rt = cur;
break;
}
}
if (rt == -1) {
cout << -1 << endl;
continue;
}
for (int i = 1; i <= n; i++) vis[i] = dep[i] = low[i] = val[i] = bad[i] = 0;
find_bad(rt);
for (int i = 1; i <= n; i++) vis[i] = 0;
pushdown(rt);
vector<int> ans;
for (int i = 1; i <= n; i++)
if (!bad[i]) ans.push_back(i);
if (5 * int(ans.size()) >= n) {
for (auto &i : ans) cout << i << ' ';
cout << endl;
continue;
}
cout << -1 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using uint = unsigned int;
using ull = unsigned long long;
template <typename T>
using pair2 = pair<T, T>;
using pii = pair<int, int>;
using pli = pair<ll, int>;
using pll = pair<ll, ll>;
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
ll myRand(ll B) { return (ull)rng() % B; }
clock_t startTime;
double getCurrentTime() {
return (double)(clock() - startTime) / CLOCKS_PER_SEC;
}
const int N = 100100;
int n, m;
vector<int> g[N];
vector<int> ANS;
int used[N];
int h[N];
int minH[N][2];
int st[N];
bool good[N];
bool dfs(int v) {
used[v] = 1;
for (int u : g[v]) {
if (used[u] == 1) {
int x = h[u];
for (int i = 0; i < 2; i++)
if (x < minH[v][i]) swap(x, minH[v][i]);
continue;
}
if (used[u] == 2) return false;
h[u] = h[v] + 1;
if (!dfs(u)) return false;
for (int j = 0; j < 2; j++) {
int x = minH[u][j];
for (int i = 0; i < 2; i++) {
if (x < minH[v][i]) swap(x, minH[v][i]);
}
}
}
used[v] = 2;
return true;
}
void dfsGood(int v) {
st[h[v]] = v;
if (h[v] > 0) {
assert(minH[v][0] < h[v]);
good[v] = minH[v][1] >= h[v] && good[st[minH[v][0]]];
}
for (int u : g[v])
if (h[u] == h[v] + 1) dfsGood(u);
}
bool solve(int root) {
for (int i = 0; i < n; i++) {
used[i] = 0;
h[i] = -1;
minH[i][0] = minH[i][1] = N;
}
h[root] = 0;
if (!dfs(root)) return false;
for (int i = 0; i < n; i++) good[i] = false;
good[root] = true;
dfsGood(root);
for (int v = 0; v < n; v++)
if (good[v]) ANS.push_back(v);
return true;
}
void solve() {
scanf("%d%d", &n, &m);
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);
}
ANS.clear();
vector<int> ord(n);
for (int i = 0; i < n; i++) ord[i] = i;
shuffle((ord).begin(), (ord).end(), rng);
for (int i = 0; i < n && i < 150; i++) {
if (solve(ord[i])) break;
}
if ((int)ANS.size() * 5 < n) {
printf("-1\n");
} else {
sort((ANS).begin(), (ANS).end());
for (int x : ANS) printf("%d ", x + 1);
printf("\n");
}
}
int main() {
startTime = clock();
int t;
scanf("%d", &t);
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const int K = 70;
int n, m;
vector<int> v[N];
int h[N];
bool dfs_check(int x) {
h[x] = 1;
for (auto u : v[x]) {
if (!h[u]) {
if (!dfs_check(u)) return 0;
} else if (h[u] == 1) {
} else if (h[u] == 2) {
return 0;
}
}
h[x] = 2;
return 1;
}
int tick;
int st[N];
int back[N], top1[N], top2[N];
void upgrade(int x, int u) {
if (top1[x] == -1 or st[u] < st[top1[x]]) {
top2[x] = top1[x];
top1[x] = u;
} else if (top2[x] == -1 or st[u] < st[top2[x]])
top2[x] = u;
}
void dfs(int x) {
st[x] = ++tick;
h[x] = 1;
for (auto u : v[x]) {
assert(h[u] <= 1);
if (!h[u]) {
dfs(u);
if (top1[u] != -1) upgrade(x, top1[u]);
if (top2[u] != -1) upgrade(x, top2[u]);
} else if (h[u] == 1) {
upgrade(x, u);
}
}
h[x] = 2;
}
int dp[N];
void dfs_solve(int x) {
if (top1[x] != -1 and st[top1[x]] <= st[x]) {
if (top2[x] == -1 or st[top2[x]] >= st[x]) {
dp[x] = (top1[x] == -1 or top1[x] == x ? 1 : dp[top1[x]]);
} else {
dp[x] = 0;
}
} else {
dp[x] = 1;
}
h[x] = 1;
for (auto u : v[x]) {
if (!h[u]) {
dfs_solve(u);
}
}
}
void solve() {
srand(time(0));
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) {
v[i].clear();
}
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d %d", &x, &y);
v[x].push_back(y);
}
int root = -1;
for (int it = 0; it < K; it++) {
int x = (long long)rand() * rand() % n + 1;
for (int i = 1; i <= n; i++) {
h[i] = 0;
}
if (dfs_check(x)) {
root = x;
break;
}
}
if (root == -1) {
puts("-1");
return;
}
for (int i = 1; i <= n; i++) {
h[i] = 0;
back[i] = 0;
st[i] = 0;
top1[i] = top2[i] = -1;
}
tick = 0;
dfs(root);
for (int i = 1; i <= n; i++) {
h[i] = 0;
dp[i] = 0;
}
dp[root] = 1;
dfs_solve(root);
vector<int> ans;
for (int i = 1; i <= n; i++) {
if (dp[i]) {
ans.push_back(i);
}
}
if (ans.size() * 5 < n) {
puts("-1");
} else {
for (auto x : ans) {
printf("%d ", x);
}
puts("");
}
}
int main() {
int t;
cin >> t;
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int mxn = 100000, k = 100;
int n, m;
int it[mxn], d[mxn], first[mxn], vis[mxn], p[mxn];
vector<int> g[mxn];
vector<int> ans;
bool dfs(int c) {
bool ret = 1;
vis[c] = d[c] = 1;
for (int i : g[c]) {
if (!vis[i]) {
ret &= dfs(i);
first[c] += first[i];
p[c] ^= p[i];
} else if (!d[i]) {
return 0;
} else {
first[i]--;
first[c]++;
p[c] ^= i;
p[i] ^= i;
}
}
d[c] = 0;
return ret;
}
void dfs2(int c) {
vis[c] = 1;
if (!first[c] || (!~-first[c] && d[p[c]])) {
d[c] = 1;
ans.push_back(c + 1);
}
for (int i : g[c])
if (!vis[i]) dfs2(i);
}
void answer() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
it[i] = i;
g[i].clear();
}
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
u--, v--;
g[u].push_back(v);
}
shuffle(it, it + n, rng);
ans.clear();
for (int i = 0; i < min(n, k); i++) {
memset(vis, 0, sizeof(vis));
memset(d, 0, n * sizeof(int));
memset(first, 0, n * sizeof(int));
memset(p, 0, n * sizeof(int));
if (dfs(it[i])) {
memset(vis, 0, n * sizeof(int));
memset(d, 0, n * sizeof(int));
dfs2(it[i]);
break;
}
}
int ret = ans.size();
if (5 * ret < n) {
cout << -1 << '\n';
} else {
sort(ans.begin(), ans.end());
cout << ans[0];
for (int i = 1; i < ret; i++) cout << " " << ans[i];
cout << '\n';
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
for (int i = 0; i < t; i++) answer();
return 0;
}
|
#include <bits/stdc++.h>
template <typename T>
bool ckmax(T &x, T y) {
return x < y ? x = y, true : false;
}
template <typename T>
bool ckmin(T &x, T y) {
return x > y ? x = y, true : false;
}
using namespace std;
const long long inf = 1000000000;
const double Pi = acos(-1);
const long long mod = 998244353;
const double eps = 1e-6;
inline long long fpow(long long a, long long b = mod - 2, long long p = mod) {
a %= p;
long long res = 1;
while (b) {
if (b & 1) res = 1ll * res * a % p;
a = 1ll * a * a % p;
b >>= 1;
}
return res;
}
inline long long read() {
char c = getchar();
long long x = 0;
bool f = 0;
for (; !isdigit(c); c = getchar()) f ^= !(c ^ 45);
for (; isdigit(c); c = getchar()) x = (x << 1) + (x << 3) + (c ^ 48);
if (f) x = -x;
return x;
}
inline void write(long long x) {
if (x < 0) {
putchar('-');
write(-x);
return;
}
if (x >= 10) write(x / 10);
putchar(x % 10 + '0');
}
inline void writesp(long long x) { write(x), putchar(' '); }
inline void writeln(long long x) {
write(x);
putchar('\n');
}
unsigned seed = std::chrono::system_clock::now().time_since_epoch().count();
mt19937 rand_num(seed);
uniform_int_distribution<long long> dist(0, 1223344556616251);
long long n, m, rt;
vector<long long> e[111111], g[111111], fz[111111], ans;
multiset<long long> st[111111];
long long fa[111111], bg[111111], en[111111], tim;
long long dp[111111], ffa[111111];
long long hson[111111];
void dfs1(long long u) {
bg[u] = ++tim;
for (long long v : e[u])
if (!bg[v]) fa[v] = u, dfs1(v);
en[u] = tim;
}
long long check(long long rt) {
tim = fa[rt] = 0;
for (long long i = (1), iE = (n); i <= iE; i++) bg[i] = 0;
dfs1(rt);
for (long long u = (1), uE = (n); u <= uE; u++) {
for (long long v : e[u])
if (fa[v] ^ u)
if (bg[v] > bg[u] || en[v] < en[u]) return 0;
}
return 1;
}
void dfs2(long long u) {
hson[u] = -1;
for (long long v : g[u]) {
dfs2(v);
if (!~hson[u] || st[v].size() > st[hson[u]].size()) hson[u] = v;
}
if (~hson[u]) swap(st[u], st[hson[u]]);
for (long long v : g[u])
if (v ^ hson[u]) {
for (auto it = st[v].begin(); it != st[v].end(); it++) st[u].insert(*it);
}
for (long long v : fz[u]) st[u].insert(v);
while (st[u].find(u) != st[u].end()) st[u].erase(st[u].find(u));
if ((long long)st[u].size() > 1)
ffa[u] = 0;
else if ((long long)st[u].size() == 1)
ffa[u] = *st[u].begin();
}
void dfs3(long long u) {
if (ffa[u] == -1)
dp[u] = 1, ans.push_back(u);
else if (!ffa[u])
dp[u] = 0;
else {
dp[u] = dp[ffa[u]];
if (dp[u]) ans.push_back(u);
}
for (long long v : g[u]) dfs3(v);
}
signed main() {
for (long long _ = read(); _; _--) {
n = read(), m = read();
for (long long i = (1), iE = (n); i <= iE; i++) e[i].clear();
long long u, v;
for (long long i = (1), iE = (m); i <= iE; i++)
u = read(), v = read(), e[u].push_back(v);
rt = 0;
for (long long i = 1; i <= 100 && (!rt); i++) {
static long long u;
u = dist(rand_num) % n + 1;
if (check(u)) rt = u;
}
if (!rt) {
puts("-1");
continue;
}
ans.clear();
for (long long i = (1), iE = (n); i <= iE; i++)
g[i].clear(), fz[i].clear(), st[i].clear(), ffa[i] = -1, dp[i] = 0;
for (long long u = (1), uE = (n); u <= uE; u++) {
if (u ^ rt) g[fa[u]].push_back(u);
for (long long v : e[u])
if (fa[v] ^ u) fz[u].push_back(v);
}
dfs2(rt);
dfs3(rt);
if ((long long)ans.size() * 5 < n) {
puts("-1");
continue;
}
sort(ans.begin(), ans.end());
for (long long x : ans) writesp(x);
puts("");
}
}
|
#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(200, 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;
const long long maxn = 2e5 + 100;
const long long inf = 0x3f3f3f3f;
const long long iinf = 1 << 30;
const long long linf = 2e18;
const long long mod = 998244353;
const double eps = 1e-7;
template <class T = long long>
T chmin(T &a, T b) {
return a = min(a, b);
}
template <class T = long long>
T chmax(T &a, T b) {
return a = max(a, b);
}
template <class T = long long>
inline void red(T &x) {
x -= mod, x += x >> 31 & mod;
}
template <class T = long long>
T read() {
T f = 1, a = 0;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
a = (a << 3) + (a << 1) + ch - '0';
ch = getchar();
}
return a * f;
}
mt19937 mrand(chrono::high_resolution_clock::now().time_since_epoch().count());
long long rnd(long long x) { return mrand() % x + 1; }
long long rnd(long long l, long long r) { return l + rnd(r - l) - 1; }
long long t, n, m, flag;
vector<long long> edge[maxn], ans;
long long vis[maxn];
void dfs(long long now) {
vis[now] = 1;
for (long long to : edge[now]) {
if (!vis[to])
dfs(to);
else if (vis[to] == 2)
flag = 0;
}
vis[now] = 2;
}
long long bad[maxn];
long long dep[maxn], top[maxn], cnt[maxn];
void dfs2(long long now) {
vis[now] = 1, top[now] = now;
for (long long to : edge[now]) {
if (vis[to]) {
++cnt[now], --cnt[to];
if (dep[to] < dep[top[now]]) top[now] = to;
} else {
dep[to] = dep[now] + 1;
dfs2(to);
cnt[now] += cnt[to];
if (dep[top[to]] < dep[top[now]]) top[now] = top[to];
}
}
if (cnt[now] > 1) bad[now] = 1;
}
void dfs3(long long now) {
vis[now] = 1;
if (!bad[now] && bad[top[now]]) bad[now] = 1;
for (long long to : edge[now]) {
if (vis[to]) continue;
dfs3(to);
}
}
void solve() {
for (long long i = (1); i <= (n); ++i)
vis[i] = bad[i] = dep[i] = top[i] = cnt[i] = 0,
vector<long long>().swap(edge[i]);
n = read(), m = read();
for (long long i = (1); i <= (m); ++i) {
long long u = read(), v = read();
edge[u].push_back(v);
}
long long rt = -1;
for (long long i = (1); i <= (100); ++i) {
long long now = rnd(n);
for (long long j = (1); j <= (n); ++j) vis[j] = 0;
flag = 1;
dfs(now);
if (flag) {
rt = now;
break;
}
}
if (rt == -1) return (void)(puts("-1"));
for (long long i = (1); i <= (n); ++i) vis[i] = 0;
dfs2(rt);
for (long long i = (1); i <= (n); ++i) vis[i] = 0;
dfs3(rt);
vector<long long>().swap(ans);
for (long long i = (1); i <= (n); ++i)
if (!bad[i]) ans.push_back(i);
if (5 * ((long long)ans.size()) >= n) {
for (long long i : ans) printf("%lld ", i);
putchar('\n');
return;
}
puts("-1");
}
signed main() {
t = read();
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7, inf = 1061109567;
const long long infll = 4557430888798830399;
const int N = 1e5 + 5, MAX = 8888;
int n, m;
vector<int> g[N];
int d[N], cnt[N];
void add(int &x, int y) {
x += y;
if (x >= MAX) x = MAX;
}
bool vis[N], realVis[N];
bool good;
void dfs2(int u) {
if (!good) return;
realVis[u] = vis[u] = 1;
for (auto v : g[u]) {
if (!realVis[v])
dfs2(v);
else {
if (!vis[v]) {
good = 0;
return;
}
}
}
vis[u] = 0;
}
bool dp[N];
int root, dep[N], backCnt[N], backLead[N], atDep[N];
vector<int> child[N];
priority_queue<int> pq[N];
void dfs0(int u) {
atDep[dep[u]] = u;
for (auto v : g[u]) {
if (dep[v] == -1) {
dep[v] = dep[u] + 1;
dfs0(v);
child[u].push_back(v);
if (pq[v].size() > pq[u].size()) pq[u].swap(pq[v]);
while (pq[v].size()) {
pq[u].push(pq[v].top());
pq[v].pop();
}
} else {
if (dep[v] < dep[u]) {
pq[u].push(dep[v]);
}
}
}
while (pq[u].size() && pq[u].top() == dep[u]) pq[u].pop();
backCnt[u] = pq[u].size();
if (pq[u].size())
backLead[u] = atDep[pq[u].top()];
else
backLead[u] = -1;
}
void dfs1(int u) {
if (u == root)
dp[u] = 1;
else {
if (backCnt[u] != 1)
dp[u] = 0;
else
dp[u] = dp[backLead[u]];
}
for (auto v : child[u]) dfs1(v);
}
void proc() {
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);
}
int cnt = min(n, 100);
root = -1;
vector<int> vers;
for (int i = 0; i < n; i++) vers.push_back(i);
for (int i = 0; i < n; i++) {
int other = rand() % vers.size();
swap(vers[i], vers[other]);
}
for (int i = 0; i < cnt; i++) {
for (int j = 0; j < n; j++) realVis[j] = vis[j] = 0;
good = 1;
dfs2(vers[i]);
if (good) {
root = vers[i];
break;
}
}
if (root == -1) {
cout << "-1\n";
return;
}
for (int i = 0; i < n; i++) {
dep[i] = -1;
dp[i] = 0;
backCnt[i] = 0;
backLead[i] = -1;
child[i].clear();
while (pq[i].size()) pq[i].pop();
}
dep[root] = 0;
dfs0(root);
dfs1(root);
int ans = 0;
for (int i = 0; i < n; i++)
if (dp[i]) ans++;
if (ans * 5 >= n) {
for (int i = 0; i < n; i++)
if (dp[i]) cout << i + 1 << " ";
cout << "\n";
} else
cout << "-1\n";
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
srand(time(0));
int t;
cin >> t;
while (t--) proc();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 9, Q = 120, inf = 1e8 + 9;
int n, m, u, v, c, T, s[N], t[N], dp[N], sub[N], par[N], dist[N];
pair<int, int> p, a[N], bcke[N], edge[N];
vector<int> ans, g[N];
void clear() {
ans.clear();
for (int i = 1; i < n + 1; i++) g[i].clear(), dp[i] = 0;
}
int solve(int x) {
for (int i = 1; i < n + 1; i++) a[i].first = dist[i], a[i].second = i;
sort(a + 1, a + 1 + n);
for (int i = 1; i < n + 1; i++)
if ((sub[a[i].second] == 1 && dp[bcke[a[i].second].second]) || (i == 1))
dp[a[i].second] = 1;
for (int i = 1; i < n + 1; i++)
if (dp[i]) ans.push_back(i);
return 1;
}
bool check(int x, int fa) {
bool ans = 1;
sub[x] = 0, bcke[x].first = N;
s[x] = c++, dist[x] = fa;
for (int i = 0; i < g[x].size(); i++)
if (s[g[x][i]] && !t[g[x][i]]) {
p = make_pair(dist[g[x][i]], g[x][i]);
if (p < bcke[x]) bcke[x] = p;
sub[x]++, sub[g[x][i]]--;
}
for (int i = 0; i < g[x].size(); i++)
if (!s[g[x][i]]) {
par[g[x][i]] = x, check(g[x][i], fa + 1);
if (bcke[g[x][i]] < bcke[x]) bcke[x] = bcke[g[x][i]];
sub[x] += sub[g[x][i]];
}
t[x] = c - 1;
if (fa == 0) {
par[x] = 0;
for (int i = 0; i < m; i++)
if ((s[edge[i].first] < s[edge[i].second] ||
t[edge[i].second] < s[edge[i].first]) &&
(par[edge[i].second] != edge[i].first))
ans = 0;
}
return ans;
}
int mv() {
cin >> n >> m;
clear();
for (int i = 0; i < m; i++) {
scanf("%d%d", &u, &v);
;
edge[i].first = u, edge[i].second = v;
g[u].push_back(v);
}
for (int i = 0; i < Q; i++) {
fill(s, s + n + 1, 0);
fill(t, t + n + 1, 0);
u = ((1ll * rand() * 1ll * rand() + rand()) % n) + 1, c = 1;
if (check(u, 0)) {
solve(u);
break;
}
}
if (ans.size() < n / 5 + (n % 5 > 0))
cout << -1 << '\n';
else
for (int i = 0; i < ans.size(); i++) cout << ans[i] << " ";
cout << endl;
;
return 0;
}
int main() {
srand(time(NULL));
for (scanf("%d", &T); T--;) mv();
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<int> g[100055], rg[100055];
int in_stack[100055];
vector<int> res;
bool bad[100055];
int d[100055];
int t;
int dfn[100055];
inline void add_edge(int from, int to) {
g[from].push_back(to);
rg[to].push_back(from);
}
bool dfs(int v) {
in_stack[v] = 1;
for (auto u : g[v]) {
if (in_stack[u] == 2) {
return false;
}
if (in_stack[u]) continue;
if (!dfs(u)) {
return false;
}
}
in_stack[v] = 2;
return true;
}
int depth[100055];
int low[100055];
vector<int> sta;
void rdfs(int v, int dep = 0) {
in_stack[v] = 1;
low[v] = depth[v] = dep;
sta.push_back(v);
vector<int> vec;
for (auto u : g[v]) {
if (in_stack[u] == 0) {
rdfs(u, dep + 1);
d[v] += d[u];
low[v] = min(low[v], low[u]);
vec.push_back(low[u]);
} else {
low[v] = min(low[v], depth[u]);
vec.push_back(depth[u]);
}
}
sort(vec.begin(), vec.end());
if (vec.size() > 1 && vec[1] < depth[v]) {
d[v]++;
d[sta[vec[1]]]--;
}
sta.pop_back();
in_stack[v] = 2;
}
void rrdfs(int v) {
sta.push_back(v);
in_stack[v] = 1;
if (d[v] == 0 && d[sta[low[v]]] == 0) {
res.push_back(v);
} else {
d[v] = 1;
}
for (auto u : g[v]) {
if (in_stack[u]) continue;
rrdfs(u);
}
sta.pop_back();
in_stack[v] = 2;
}
int main() {
mt19937 rng(19990520);
int _t;
cin >> _t;
while (_t--) {
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) {
g[i].clear();
rg[i].clear();
}
while (m--) {
int x, y;
scanf("%d %d", &x, &y);
x--, y--;
add_edge(x, y);
}
res.clear();
for (int t = 0; t < 100; t++) {
::t = 0;
for (int i = 0; i < n; i++) {
in_stack[i] = 0;
bad[i] = false;
d[i] = 0;
}
int v = uniform_int_distribution<int>(0, n - 1)(rng);
if (!dfs(v)) {
continue;
}
for (int i = 0; i < n; i++) in_stack[i] = 0;
rdfs(v);
for (int i = 0; i < n; i++) in_stack[i] = 0;
rrdfs(v);
break;
}
if (res.empty() || (int)res.size() * 5 < n) {
puts("-1");
continue;
}
sort(res.begin(), res.end());
for (int v : res) printf("%d ", v + 1);
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -1;
for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
return x * f;
}
const int MAXN = 400010;
const int INF = 1e9;
int T, N, M;
int Node[MAXN << 1], Next[MAXN << 1], Root[MAXN + 1], cnt;
inline void insert(int u, int v) {
Node[++cnt] = v;
Next[cnt] = Root[u];
Root[u] = cnt;
return;
}
vector<int> vec[MAXN + 1];
bool fnd[MAXN + 1], in[MAXN + 1];
int sz[MAXN + 1];
bool chs[MAXN + 1];
bool vis[MAXN + 1];
inline bool dfs(int k) {
in[k] = 1;
fnd[k] = 1;
for (int x = Root[k]; x; x = Next[x]) {
int v = Node[x];
if (fnd[v] && !in[v]) {
return 0;
}
if (!fnd[v] && !dfs(v)) return 0;
}
in[k] = 0;
return 1;
}
int dep[MAXN + 1], mn[MAXN + 1];
inline void dfs2(int k) {
in[k] = 1;
fnd[k] = 1;
sz[k] = 0;
mn[k] = 0;
for (int x = Root[k]; x; x = Next[x]) {
int v = Node[x];
if (fnd[v]) {
sz[k]++;
sz[v]--;
if (dep[v] < dep[mn[k]]) mn[k] = v;
continue;
} else {
dep[v] = dep[k] + 1;
dfs2(v), sz[k] += sz[v];
if (dep[mn[v]] < dep[mn[k]]) mn[k] = mn[v];
}
}
if (dep[mn[k]] < dep[k]) vec[mn[k]].push_back(k);
in[k] = 0;
return;
}
inline void dfs3(int k) {
in[k] = 1;
fnd[k] = 1;
if (sz[k] > 1) chs[k] = 0;
if (!chs[k])
for (auto v : vec[k]) {
chs[v] = 0;
}
for (int x = Root[k]; x; x = Next[x]) {
int v = Node[x];
if (fnd[v]) {
continue;
} else
dfs3(v);
}
in[k] = 0;
return;
}
inline int rnd() {
long long u = 0;
for (int i = 1; i <= 9; i++) u = u * 10 + rand() % 9;
return u;
}
inline void solve() {
N = read(), M = read();
for (int i = 1; i <= N; i++) Root[i] = 0, vis[i] = 0, vec[i].clear();
cnt = 0;
for (int i = 1; i <= M; i++) {
int u = read(), v = read();
insert(u, v);
}
int tms = 100;
int root = -1;
while (tms--) {
int u = rnd() % N + 1;
if (vis[u]) continue;
vis[u] = 1;
for (int i = 1; i <= N; i++) in[i] = 0, fnd[i] = 0;
if (dfs(u)) {
root = u;
break;
}
}
if (root == -1) {
puts("-1");
return;
}
int u = root;
for (int i = 1; i <= N; i++) in[i] = 0, fnd[i] = 0, dep[i] = mn[i] = 0;
dep[u] = 1;
dep[0] = INF;
dfs2(u);
for (int i = 1; i <= N; i++) in[i] = 0, fnd[i] = 0, chs[i] = 1;
dfs3(u);
int all = 0;
for (int i = 1; i <= N; i++) all += chs[i];
if (all * 5 < N) {
puts("-1");
return;
}
for (int i = 1; i <= N; i++)
if (chs[i]) printf("%d ", i);
printf("\n");
}
int main() {
srand((int)time(0));
T = read();
while (T--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200000 + 77, TOF = 100;
mt19937 RNG;
inline int GetRand(int l, int r) { return RNG() % (r - l + 1) + l; }
int n, m, st[N], en[N], d[N], P[N], tim;
bool M[N];
vector<int> adj[N];
bool valid, A[N];
pair<int, int> B[N];
void dfs(int v) {
st[v] = tim++;
M[v] = 1;
for (int u : adj[v]) {
valid &= ((!M[u]) || (st[u] <= st[v] && en[u] == 0));
if (!M[u]) dfs(u);
}
en[v] = tim;
}
inline void Apply(int v, int u) {
if (u == 0 || d[u] >= d[v]) return;
if (B[v].second == 0 || d[B[v].second] > d[u]) B[v].second = u;
if (B[v].first == 0 || d[B[v].first] > d[B[v].second])
swap(B[v].first, B[v].second);
}
void dfscalc(int v) {
M[v] = 1;
for (int u : adj[v]) {
if (M[u]) Apply(v, u);
if (!M[u]) {
d[u] = d[v] + 1;
dfscalc(u);
Apply(v, B[u].first);
Apply(v, B[u].second);
}
}
}
inline void Test() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; ++i)
adj[i].clear(), d[i] = 0, A[i] = 0, B[i] = make_pair(0, 0);
for (int v, u, i = 1; i <= m; ++i)
scanf("%d %d", &v, &u), adj[v].push_back(u);
int tof = TOF;
int vr = -1;
while (tof--) {
int root = GetRand(1, n);
valid = 1;
for (int i = 1; i <= n; ++i) M[i] = st[i] = en[i] = 0;
tim = 1;
dfs(root);
if (valid) {
vr = root;
break;
}
}
if (vr == -1) {
printf("-1\n");
return;
}
for (int i = 1; i <= n; ++i) M[i] = 0;
dfscalc(vr);
for (int i = 1; i <= n; ++i) P[i] = i;
sort(P + 1, P + 1 + n, [&](int x, int y) { return d[x] < d[y]; });
A[vr] = 1;
for (int i = 2; i <= n; ++i) {
int id = P[i];
if (B[id].second > 0) continue;
A[id] = A[B[id].first];
}
int cnt = 0;
for (int i = 1; i <= n; ++i) cnt += A[i];
if (cnt < (n + 4) / 5) {
printf("-1\n");
return;
}
for (int i = 1; i <= n; ++i)
if (A[i]) printf("%d ", i);
printf("\n");
}
int main() {
RNG.seed(time(0));
int T;
scanf("%d", &T);
while (T--) Test();
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
template <class T>
inline bool setmin(T &a, T b) {
if (a > b) return a = b, 1;
return 0;
}
template <class T>
inline bool setmax(T &a, T b) {
if (a < b) return a = b, 1;
return 0;
}
template <class T>
inline T fast(T a, T b, T mod) {
long long res = 1;
while (b) {
if (b & 1) res = (res * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return res;
}
template <class T>
istream &operator>>(istream &os, vector<T> &container) {
for (auto &u : container) os >> u;
return os;
}
template <class T>
ostream &operator<<(ostream &os, const vector<T> &container) {
for (auto &u : container) os << u << " ";
return os;
}
template <class T>
inline T gcd(T a, T b) {
while (b) swap(a %= b, b);
return a;
}
const long long INF = 1e9 + 7;
const long long mod = 998244353;
const long long BIG_INF = 1e18 + 7;
const long long N = 1e6 + 7;
const long long T = 1 << 20;
const long double inf = 1e18;
long long m, n, k, q;
vector<int> ans, odw, preorder, good, skok;
int cnt;
vector<vector<int> > G(N);
void dodaj(pair<pair<int, int>, pair<int, int> > &akt, pair<int, int> syn,
int v) {
if (syn.first >= preorder[v]) return;
if (syn.first < akt.first.first) {
akt.second = akt.first;
akt.first = syn;
} else if (syn.first < akt.second.first) {
akt.second = syn;
}
}
pair<pair<int, int>, pair<int, int> > polacz(
pair<pair<int, int>, pair<int, int> > akt,
pair<pair<int, int>, pair<int, int> > syn, int v) {
dodaj(akt, syn.first, v);
dodaj(akt, syn.second, v);
return akt;
}
void dfs3(int v) {
odw[v] = 1;
if (!good[v] and skok[v]) good[v] = good[skok[v]];
for (auto &u : G[v])
if (!odw[u]) dfs3(u);
}
pair<pair<int, int>, pair<int, int> > dfs2(int v) {
preorder[v] = cnt++;
odw[v] = 1;
pair<pair<int, int>, pair<int, int> > ret = {{INF, 0}, {INF, 0}};
for (auto &u : G[v])
if (odw[u] == 0)
ret = polacz(ret, dfs2(u), v);
else
dodaj(ret, {preorder[u], u}, v);
if (ret.second.second == 0 and ret.first.first != INF)
skok[v] = ret.first.second;
return ret;
}
void finish(int v) {
if (v == 0) return;
cnt = 0;
fill((odw).begin(), (odw).end(), 0);
dfs2(v);
fill((odw).begin(), (odw).end(), 0);
fill((good).begin(), (good).end(), 0);
good[v] = 1;
dfs3(v);
int ile = accumulate(good.begin(), good.end(), 0);
if (ile * 5 < n) {
cout << -1 << '\n';
return;
}
for (int i = 1; i <= n; i++)
if (good[i]) cout << i << ' ';
cout << '\n';
}
int dfs(int v) {
odw[v] = 1;
bool ret = 1;
for (auto &u : G[v]) {
if (odw[u] == 2)
return false;
else if (odw[u] == 0)
ret &= dfs(u);
}
odw[v] = 2;
return ret;
}
int Find(int v) {
fill((odw).begin(), (odw).end(), 0);
return v * dfs(v);
}
void solve() {
cin >> n >> m;
odw.resize(n + 1);
preorder.resize(n + 1);
good.resize(n + 1);
skok.resize(n + 1);
fill((skok).begin(), (skok).end(), 0);
ans.clear();
for (int i = 1; i <= n; i++) G[i].clear();
for (int i = 0; i < (m); i++) {
int a, b;
cin >> a >> b;
G[a].push_back(b);
}
bool ok = 0;
for (int i = 0; i < (100); i++) {
int v = Find(uniform_int_distribution<long long>(1, n)(rng));
if (v) {
ok = 1;
finish(v);
break;
}
}
if (!ok) cout << -1 << '\n';
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> q;
for (int i = 0; i < (q); i++) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long power(long long a, long long b, long long md) {
return (!b ? 1
: (b & 1 ? a * power(a * a % md, b / 2, md) % md
: power(a * a % md, b / 2, md) % md));
}
const int xn = 1e5 + 10;
const int xm = -20 + 10;
const int SQ = 320;
const int sq = 320 + 10;
const int inf = 1e9 + 10;
const long long INF = 1e18 + 10;
const int MOD = 1e9 + 7;
const int TM = 30;
const int BASE = 257;
int qq, n, m, num[xn], mark[xn], ted, mn[2][xn], H[xn], root;
vector<int> adj[2][xn];
bool flag, dp[xn], flag2;
void DFS3(int v) {
mark[v] = 1;
dp[v] &= (mn[0][v] < inf && H[mn[0][v]] < H[v]);
dp[v] &= (mn[1][v] == inf || H[mn[1][v]] >= H[v]);
if (mn[0][v] < inf && H[mn[0][v]] < H[v]) dp[v] &= (dp[mn[0][v]]);
if (v == root) dp[v] = true;
for (int u : adj[1][v])
if (!mark[u]) DFS3(u);
}
void DFS2(int v) {
mark[v] = 1;
for (int u : adj[1][v]) {
if (mark[u]) {
if (mn[1][v] == inf || H[u] < H[mn[1][v]]) mn[1][v] = u;
if (mn[1][v] < inf && (mn[0][v] == inf || H[mn[1][v]] < H[mn[0][v]]))
swap(mn[0][v], mn[1][v]);
continue;
}
H[u] = H[v] + 1;
DFS2(u);
if (mn[1][v] == inf || (mn[0][u] < inf && H[mn[0][u]] < H[mn[1][v]]))
mn[1][v] = mn[0][u];
if (mn[1][v] < inf && (mn[0][v] == inf || H[mn[1][v]] < H[mn[0][v]]))
swap(mn[0][v], mn[1][v]);
if (mn[1][v] == inf || (mn[1][u] < inf && H[mn[1][u]] < H[mn[1][v]]))
mn[1][v] = mn[1][u];
if (mn[1][v] < inf && (mn[0][v] == inf || H[mn[1][v]] < H[mn[0][v]]))
swap(mn[0][v], mn[1][v]);
}
}
void DFS(int v) {
mark[v] = 1;
for (int u : adj[1][v]) {
flag |= mark[u] == 2;
if (!mark[u]) DFS(u);
}
mark[v] = 2;
}
void solve(int v) {
root = v;
for (int i = 1; i <= n; ++i) mark[i] = 0;
flag = false;
DFS(v);
for (int i = 1; i <= n; ++i) flag |= !mark[i];
if (flag) return;
flag2 = true;
H[v] = 0;
for (int i = 1; i <= n; ++i)
mark[i] = 0, dp[i] = true, mn[0][i] = mn[1][i] = inf;
DFS2(v);
for (int i = 1; i <= n; ++i) mark[i] = 0;
DFS3(v);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
srand(time(0));
cin >> qq;
while (qq--) {
cin >> n >> m;
for (int i = 1; i <= n; ++i) adj[0][i].clear(), adj[1][i].clear();
for (int i = 1; i <= m; ++i) {
int v, u;
cin >> v >> u;
adj[1][v].push_back(u);
adj[0][u].push_back(v);
}
for (int i = 0; i < n; ++i) num[i] = i + 1;
random_shuffle(num, num + n);
flag2 = false;
for (int i = 0; i < min(n, TM); ++i) {
solve(num[i]);
if (flag2) break;
}
ted = 0;
for (int i = 1; i <= n; ++i) ted += dp[i];
if (!flag2 || ted < (n + 4) / 5) {
cout << -1 << '\n';
continue;
}
for (int i = 1; i <= n; ++i)
if (dp[i]) cout << i << ' ';
cout << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
const int N = 5e5 + 50;
int n, m, p[N], fa[N];
int head[N], nxt[N], ver[N], up[N], val[N], cnt;
bool vis[N], vs[N], ok[N];
inline void add(int u, int v) {
nxt[++cnt] = head[u];
ver[cnt] = v;
head[u] = cnt;
}
bool check(int x, int f = 0) {
assert(!vs[x]);
vs[x] = vis[x] = true;
for (int i = head[x]; i; i = nxt[i]) {
int y = ver[i];
if (!vis[y]) {
if (check(y, x) == false) {
vs[x] = false;
return false;
}
} else if (!vs[y]) {
vs[x] = false;
return false;
}
}
vs[x] = false;
return true;
}
void dfs(int x, int f = 0) {
vis[x] = true;
for (int i = head[x]; i; i = nxt[i]) {
int y = ver[i];
if (!vis[y]) {
fa[y] = x;
dfs(y, x);
} else {
int z = x;
while (z != y) {
assert(z);
if (!val[z])
val[z] = y;
else
val[z] = -1;
z = fa[z];
}
}
}
}
std::vector<int> ans;
std::mt19937 rng(std::chrono::steady_clock::now().time_since_epoch().count());
void calc(int x, int f = 0) {
vis[x] = true;
if (val[x] != -1) {
ok[x] = ok[val[x]];
if (ok[x]) ans.push_back(x);
}
for (int i = head[x]; i; i = nxt[i]) {
int y = ver[i];
if (!vis[y]) {
calc(y, x);
}
}
}
inline char nc() {
static char buf[1000000], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1000000, stdin), p1 == p2)
? EOF
: *p1++;
}
inline int read() {
int res = 0;
char ch;
do ch = nc();
while (ch < 48 || ch > 57);
do res = res * 10 + ch - 48, ch = nc();
while (ch >= 48 && ch <= 57);
return res;
}
int main() {
int t = read();
while (t--) {
memset(ok, 0, (n + 1) * sizeof(bool));
ans.clear();
ok[0] = true;
memset(head, 0, (n + 1) * sizeof(int));
cnt = 0;
n = read(), m = read();
for (int i = 1; i <= n; ++i) p[i] = i;
std::shuffle(p + 1, p + n + 1, rng);
for (int i = 1; i <= m; ++i) {
int u = read(), v = read();
add(u, v);
}
int rt = -1;
for (int i = 1; i <= n && i <= 50; ++i) {
memset(vis, 0, (n + 1) * sizeof(bool));
if (check(p[i])) {
rt = p[i];
break;
}
}
if (rt == -1)
puts("-1");
else {
memset(vis, 0, (n + 1) * sizeof(bool));
memset(val, 0, (n + 1) * sizeof(int));
dfs(rt);
memset(vis, 0, (n + 1) * sizeof(bool));
ok[rt] = true;
calc(rt);
if (5 * ans.size() < n) {
puts("-1");
} else {
std::sort(ans.begin(), ans.end());
for (int z : ans) printf("%d ", z);
putchar('\n');
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, x[100010], y[100010], lvl[100010], q[100010], vis[100010],
res[100010], pre[100010], cn;
vector<int> G[100010];
void clear() {
for (int i = 1; i <= n; i++) G[i].clear();
for (int i = 0; i < n; i++) q[i] = i + 1;
random_shuffle(q, q + n);
}
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] = 100003;
for (int v : G[u]) {
if (vis[v] == 2) return false;
if (vis[v]) {
add(u, lvl[v]);
continue;
}
lvl[v] = lvl[u] + 1;
if (!dfs(v)) return false;
add(u, x[v]);
add(u, y[v]);
}
if (x[u] == lvl[u]) x[u] = 100003;
if (y[u] == lvl[u]) y[u] = 100003;
if (y[u] < 100003) res[u] = 0;
vis[u] = 2;
return true;
}
void dfs2(int u) {
vis[u] = 1;
pre[lvl[u]] = u;
if (res[u] == -1 && lvl[u]) {
if (x[u] < 100003)
res[u] = res[pre[x[u]]];
else
res[u] = 0;
}
for (int v : G[u])
if (!vis[v]) dfs2(v);
}
void solve() {
cin >> n >> m;
clear();
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
G[a].push_back(b);
}
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 << endl;
else {
for (int x : r) cout << x << ' ';
cout << endl;
}
return;
}
cout << -1 << endl;
}
int main() {
srand(20021117);
ios_base::sync_with_stdio(false);
int T;
cin >> T;
while (T--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int T, n, m, x, y, i, j, dfn[N], dcnt, aa[N], dad[N], t1[N], t2[N], p[N];
bool ins[N], fl, bb[N];
vector<int> e[N], ans;
void dfs(int x) {
dfn[x] = ++dcnt;
ins[x] = 1;
for (int y : e[x])
if (!dfn[y])
dfs(y);
else
fl |= !ins[y];
ins[x] = 0;
}
void dfs2(int x) {
dfn[x] = ++dcnt;
aa[dcnt] = x;
for (int y : e[x]) {
if (!dfn[y])
dad[y] = x, dfs2(y), t1[x] += t1[y], t2[x] ^= t2[y];
else
++t1[x], --t1[y], t2[x] ^= y, t2[y] ^= y;
}
}
int main() {
mt19937 R(time(0));
for (scanf("%d", &T); T--;) {
scanf("%d%d", &n, &m);
for (i = 1; i <= n; ++i) e[i].clear();
for (i = 1; i <= m; ++i) scanf("%d%d", &x, &y), e[x].push_back(y);
for (i = 1; i <= n; ++i) p[i] = i, swap(p[R() % i + 1], p[i]);
int lim = min(200, n);
for (i = 1; i <= lim; ++i) {
dcnt = fl = 0;
memset(dfn + 1, 0, n << 2);
dfs(p[i]);
if (dcnt == n && !fl) break;
}
if (i > lim) {
puts("-1");
continue;
}
dcnt = 0;
memset(dfn + 1, 0, n << 2);
memset(t1 + 1, 0, n << 2);
memset(t2 + 1, 0, n << 2);
dfs2(p[i]);
bb[p[i]] = 1;
for (j = 2; j <= n; ++j) x = aa[j], bb[x] = t1[x] == 1 && bb[t2[x]];
ans.clear();
for (i = 1; i <= n; ++i)
if (bb[i]) ans.push_back(i);
if (ans.size() * 5 < n)
puts("-1");
else {
for (int x : ans) printf("%d ", x);
puts("");
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
inline char ch() {
static char s[1 << 16], *S, *T;
return (S == T) && (T = (S = s) + fread(s, 1, 1 << 16, stdin), S == T) ? EOF
: *S++;
}
template <typename T>
void read(T &x) {
x = 0;
int f(1);
char c = ch();
for (; !isdigit(c); c = ch())
if (c == '-') f = -1;
for (; isdigit(c); c = ch()) x = x * 10 + c - '0';
x *= f;
}
template <typename T, typename... Args>
inline void read(T &x, Args &...args) {
read(x);
read(args...);
}
template <typename T>
void write(T x, char f = '\n') {
if (x < 0) putchar('-'), x = -x;
if (x > 9) write(x / 10, '\0');
putchar('0' + x % 10);
if (f != '\0') putchar(f);
}
const int maxn = 100003;
const int maxm = 200005;
int n, m, hd[maxn], cnt, Ok;
int tested[maxn], vis[maxn], fg[maxn];
int Cant[maxn], dep[maxn], low[maxn];
struct edge {
int ed, nxt;
} e[maxm];
inline void star(int u, int v) {
e[++cnt] = (edge){v, hd[u]};
hd[u] = cnt;
}
void Dfs(int x) {
vis[x] = 1;
for (int i = hd[x]; i; i = e[i].nxt) {
int y = e[i].ed;
if (vis[y] == 2)
return Ok = 0, void();
else if (!vis[y])
Dfs(y);
if (!Ok) return;
}
vis[x] = 2;
}
void Dfs1(int x) {
vis[x] = 1;
low[x] = x;
for (int i = hd[x]; i; i = e[i].nxt) {
int y = e[i].ed;
if (!vis[y]) {
dep[y] = dep[x] + 1;
Dfs1(y);
fg[x] += fg[y];
if (dep[low[y]] < dep[low[x]]) low[x] = low[y];
} else {
++fg[x];
--fg[y];
if (dep[y] < dep[low[x]]) low[x] = y;
}
}
if (fg[x] > 1) Cant[x] = 1;
}
void Dfs2(int x) {
vis[x] = 1;
if (low[x] == x && x != Ok) Cant[x] = 1;
if (!Cant[x] && Cant[low[x]]) Cant[x] = 1;
for (int i = hd[x]; i; i = e[i].nxt) {
int y = e[i].ed;
if (!vis[y]) Dfs2(y);
}
}
void Calc(int x) {
Ok = x;
for (int i(1); i <= n; ++i) vis[i] = 0;
Dfs1(x);
for (int i(1); i <= n; ++i) vis[i] = 0;
Dfs2(x);
int Num = 0;
for (int i(1); i <= n; ++i)
if (!Cant[i]) ++Num;
if (5 * Num >= n) {
for (int i(1); i <= n; ++i)
if (!Cant[i]) write(i, ' ');
puts("");
} else
puts("-1");
}
bool Judge(int x) {
for (int i(1); i <= n; ++i) vis[i] = 0;
Ok = 1;
Dfs(x);
if (!Ok) return 0;
for (int i(1); i <= n; ++i)
if (!vis[i]) return 0;
return 1;
}
void Init() {
for (int i(1); i <= n; ++i)
hd[i] = tested[i] = vis[i] = 0, low[i] = fg[i] = Cant[i] = dep[i] = 0;
cnt = Ok = 0;
}
void Solve() {
read(n, m);
for (int i(1); i <= m; ++i) {
int u, v;
read(u, v);
star(u, v);
}
for (int zzt(1); zzt <= 100; ++zzt) {
int x = 1LL * rand() * rand() % n + 1;
while (tested[x]) x = rand() % n + 1;
if (Judge(x)) return Calc(x), Init(), void();
}
puts("-1");
Init();
}
int main() {
srand(time(0));
int T;
read(T);
while (T--) Solve();
return 0;
}
|
#include <bits/stdc++.h>
template <typename T>
inline void read(T &x) {
x = 0;
char c = getchar();
bool flag = false;
while (!isdigit(c)) {
if (c == '-') flag = true;
c = getchar();
}
while (isdigit(c)) x = x * 10 + (c ^ 48), c = getchar();
if (flag) x = -x;
}
using namespace std;
inline int Rand(int mod) { return 1ull * rand() * rand() % mod; }
int n, m;
struct edge {
int nxt, to;
edge() {}
edge(int jzp, int zzz) { nxt = jzp, to = zzz; }
} e[101000 << 1];
int head[101000], ecnt;
inline void addedge(int from, int to) {
e[++ecnt] = edge(head[from], to);
head[from] = ecnt;
}
int vtot, dep[101000], fa[101000];
bool vis[101000], instk[101000];
bool dfs_check(int cur) {
vis[cur] = true;
instk[cur] = true;
++vtot;
for (int i = head[cur]; i; i = e[i].nxt) {
int to = e[i].to;
if (instk[to]) continue;
if (vis[to]) return instk[cur] = false;
dep[to] = dep[cur] + 1;
fa[to] = cur;
if (!dfs_check(to)) return instk[cur] = false;
}
instk[cur] = false;
return true;
}
inline bool check(int rt) {
dep[rt] = fa[rt] = vtot = 0;
for (int i = 1; i <= n; ++i) vis[i] = false;
if (!dfs_check(rt)) return false;
return vtot == n;
}
int fath[101000];
int find(int cur) {
return fath[cur] == cur ? cur : fath[cur] = find(fath[cur]);
}
int anc[101000];
void Update(int cur, int jzp) {
cur = find(cur);
while (dep[cur] > dep[jzp]) {
if (anc[cur])
fath[cur] = fa[cur], cur = find(fa[cur]);
else
anc[cur] = jzp, cur = find(fa[cur]);
}
}
void dfs_fan(int cur) {
instk[cur] = true;
for (int i = head[cur]; i; i = e[i].nxt) {
int to = e[i].to;
if (dep[to] > dep[cur] + 1) continue;
if (instk[to])
Update(cur, to);
else
dfs_fan(to);
}
instk[cur] = false;
}
bool isans[101000];
int ans[101000], atot;
void dfs_ans(int cur) {
if (fath[cur] == cur && anc[cur] && isans[anc[cur]])
isans[cur] = true, ans[++atot] = cur;
for (int i = head[cur]; i; i = e[i].nxt) {
int to = e[i].to;
if (dep[to] != dep[cur] + 1) continue;
dfs_ans(to);
}
}
inline void work() {
read(n), read(m);
for (int i = 1; i <= m; ++i) {
int u, v;
read(u), read(v);
addedge(u, v);
}
int rt = Rand(n) + 1, ct = 0;
while (!check(rt) && ct <= 90) ++ct, rt = Rand(n) + 1;
if (check(rt)) {
for (int i = 1; i <= n; ++i) fath[i] = i;
dfs_fan(rt);
isans[rt] = true;
ans[atot = 1] = rt;
dfs_ans(rt);
sort(ans + 1, ans + 1 + atot);
if (atot * 5 < n)
puts("-1");
else
for (int i = 1; i <= atot; ++i)
printf("%d%c", ans[i], i == atot ? '\n' : ' ');
} else {
puts("-1");
}
}
inline void clear() {
for (int i = 1; i <= n; ++i) {
isans[i] = vis[i] = instk[i] = false;
anc[i] = head[i] = dep[i] = fa[i] = 0;
}
ecnt = 0;
}
int main() {
srand((long long)new char);
int _;
read(_);
while (_--) work(), clear();
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);
int rand(int a, int b) { return uniform_int_distribution<int>(a, b)(rng); }
void solve() {
int it = 100;
while (it--) {
memset(vis, 0, (n + 2) * sizeof(vis[0]));
memset(up, 0, (n + 2) * sizeof(up[0]));
cnt = 0;
int u = rand(1, n);
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;
const int maxn = 1e5, t = 100;
int T, n, m, lim, cnt[maxn + 5], tot, dfn[maxn + 5], low[maxn + 5],
rev[maxn + 5], is[maxn + 5];
bool fl, in[maxn + 5], vis[maxn + 5];
vector<int> G[maxn + 5];
void dfs(int u) {
vis[u] = true, in[u] = true;
for (int i = 0, v; i < G[u].size(); i++) {
v = G[u][i];
if (!vis[v])
dfs(v);
else
fl &= in[v];
}
in[u] = false;
}
bool check(int x) {
fl = true, fill(vis + 1, vis + n + 1, false);
dfs(x);
return fl;
}
void work(int u) {
in[u] = true, dfn[u] = low[u] = ++tot, rev[tot] = u;
for (int i = 0, v; i < G[u].size(); i++) {
v = G[u][i];
if (!in[v])
work(v), low[u] = min(low[u], low[v]), cnt[u] += cnt[v];
else
low[u] = min(low[u], dfn[v]), cnt[u]++, cnt[v]--;
}
in[u] = false;
}
void solve(int u) {
in[u] = true;
for (int i = 0, v; i < G[u].size(); i++) {
v = G[u][i];
if (!in[v]) {
is[v] = (cnt[v] == 1) & is[rev[low[v]]];
solve(v);
}
}
in[u] = false;
}
int main() {
srand(time(0) ^ (unsigned long long)(new char));
scanf("%d", &T);
while (T-- > 0) {
scanf("%d %d", &n, &m);
lim = (n - 1) / 5 + 1;
for (int i = (1); i <= int(n); i++) vector<int>().swap(G[i]);
for (int i = 0, u, v; i < m; i++) {
scanf("%d %d", &u, &v), G[u].push_back(v);
}
int rt = 0;
for (int k = (1); k <= int(t); k++) {
int x = (rand() ^ (rand() << 10)) % n + 1;
if (check(x)) {
rt = x;
break;
}
}
if (!rt) {
puts("-1");
continue;
}
tot = 0, fill(cnt + 1, cnt + n + 1, 0);
work(rt), is[rt] = true, solve(rt);
vector<int> vec;
for (int i = (1); i <= int(n); i++)
if (is[i]) vec.push_back(i);
if (vec.size() > (n - 1) / 5) {
for (int i = (0); i <= int(vec.size() - 1); i++)
printf("%d%c", vec[i], " \n"[i == vec.size() - 1]);
} else {
puts("-1");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int inf = 1e9 + 10;
const ll inf_ll = 1e18 + 10;
vector<int> toposort(vector<vector<int>> adj) {
vector<int> out, stk, in(adj.size(), 0);
for (int i = 0; i < adj.size(); i++)
for (int j : adj[i]) in[j]++;
for (int i = 0; i < adj.size(); i++)
if (!in[i]) stk.push_back(i);
while (!stk.empty()) {
out.push_back(stk.back());
stk.pop_back();
for (int j : adj[out.back()])
if (!--in[j]) stk.push_back(j);
}
return out;
}
mt19937 randint(chrono::steady_clock::now().time_since_epoch().count());
inline int uniform_randint(const int a, const int b) {
return uniform_int_distribution<int>(a, b)(randint);
}
inline double rand01() { return uniform_randint(0, INT_MAX) / double(INT_MAX); }
vector<int> random_sample(int k, int n) {
vector<int> r(k);
std::iota(r.begin(), r.end(), 0);
double w = exp(log(rand01()) / k);
int i = k - 1;
while (i < n) {
i += 1 + floor(log(rand01()) / log(1 - w));
if (i < n) {
r[uniform_randint(0, k - 1)] = i;
w *= exp(log(rand01()) / k);
}
}
return r;
}
vector<vector<int>> adj, tadj, badj;
vector<int> vin, vout, v, dp, p, d;
int tt;
void dfs(int i) {
vin[i] = tt++;
v[i] = 1;
for (int j : adj[i]) {
if (!v[j]) {
tadj[i].push_back(j);
d[j] = d[i] + 1;
dfs(j);
if (d[p[i]] > d[p[j]]) p[i] = p[j];
dp[i] += dp[j];
} else {
dp[i]++, dp[j]--;
badj[i].push_back(j);
if (d[p[i]] > d[j]) p[i] = j;
}
}
vout[i] = tt - 1;
}
void dfs3(int i) {
dp[i] = dp[i] > 1;
dp[i] = dp[i] || dp[p[i]];
for (int j : tadj[i]) {
dfs3(j);
}
}
bool solve() {
int n = adj.size();
int r = uniform_randint(0, n - 1);
v.assign(n, 0);
dp.assign(n, 0);
p.assign(n, -1);
iota((p).begin(), (p).end(), 0);
d.assign(n, 0);
vin.assign(n, 0);
vout.assign(n, 0);
tadj.assign(n, {});
badj.assign(n, {});
tt = 0;
dfs(r);
for (int i = 0; i < n; i++)
for (int j : badj[i]) {
if (!(vin[j] <= vin[i] && vout[i] <= vout[j])) {
return 0;
}
}
0;
0;
dfs3(r);
0;
0;
vector<int> ans;
for (int i = 0; i < n; i++)
if (!dp[i]) ans.push_back(i);
0;
if (ans.size() * 5 < n) {
cout << "-1\n";
return 1;
} else {
sort((ans).begin(), (ans).end());
for (int i = 0; i < ans.size(); i++)
cout << ans[i] + 1 << " \n"[i + 1 == ans.size()];
return 1;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
adj.assign(n, {});
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
x--, y--;
adj[x].push_back(y);
}
bool ok = 0;
for (int i = 0; i < 60; i++) {
ok = ok || solve();
if (ok) break;
}
if (!ok) cout << "-1\n";
}
}
|
#include <bits/stdc++.h>
inline int rint() {
int x = 0, f = 1;
char s = getchar();
for (; s < '0' || '9' < s; s = getchar()) f = s == '-' ? -f : f;
for (; '0' <= s && s <= '9'; s = getchar()) x = x * 10 + (s ^ '0');
return x * f;
}
template <typename Tp>
inline void wint(Tp x) {
if (x < 0) putchar('-'), x = ~x + 1;
if (9 < x) wint(x / 10);
putchar(x % 10 ^ '0');
}
const int MAXN = 1e5, MAXM = 2e5;
int n, m, ecnt, head[MAXN + 5], vtag[MAXN + 5], upc[MAXN + 5], top[MAXN + 5];
bool bad[MAXN + 5];
std::mt19937 rnd(20050913);
struct Edge {
int to, nxt;
} graph[MAXM + 5];
inline void link(const int s, const int t) {
graph[++ecnt] = {t, head[s]};
head[s] = ecnt;
}
inline bool check(const int u) {
vtag[u] = 1;
for (int i = head[u], v; i; i = graph[i].nxt) {
if (!vtag[v = graph[i].to]) {
if (!check(v)) return false;
} else if (vtag[v] == 2) {
return false;
}
}
vtag[u] = 2;
return true;
}
inline void mark(const int u) {
top[u] = u;
for (int i = head[u], v; i; i = graph[i].nxt) {
if (!vtag[v = graph[i].to]) {
vtag[v] = vtag[u] + 1;
mark(v), upc[u] += upc[v];
if (vtag[top[v]] < vtag[top[u]]) top[u] = top[v];
} else {
++upc[u], --upc[v];
if (vtag[v] < vtag[top[u]]) top[u] = v;
}
}
}
inline int spread(const int u) {
vtag[u] = 1, bad[u] = upc[u] > 1;
int ret = !(bad[u] |= bad[top[u]]);
for (int i = head[u], v; i; i = graph[i].nxt) {
if (!vtag[v = graph[i].to]) {
ret += spread(v);
}
}
return ret;
}
inline void clear() {
ecnt = 0;
for (int i = 1; i <= n; ++i) {
head[i] = vtag[i] = upc[i] = top[i] = bad[i] = 0;
}
}
int main() {
for (int T = rint(); T--;) {
clear();
n = rint(), m = rint();
for (int i = 1, u, v; i <= m; ++i) {
u = rint(), v = rint();
link(u, v);
}
int rt = 0;
for (int i = 1; i <= 100 && !rt; ++i) {
int u = rnd() % n + 1;
for (int i = 1; i <= n; ++i) vtag[i] = 0;
if (check(u)) rt = u;
}
if (!rt) {
puts("-1");
continue;
}
for (int i = 1; i <= n; ++i) vtag[i] = 0;
vtag[rt] = 1, mark(rt);
for (int i = 1; i <= n; ++i) vtag[i] = 0;
int cnt = spread(rt);
if (cnt * 5 < n) {
puts("-1");
continue;
}
for (int i = 1, f = 0; i <= n; ++i) {
if (!bad[i]) {
if (f) putchar(' ');
f = 1, printf("%d", i);
}
}
putchar('\n');
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
constexpr int maxn = 1e5 + 100;
struct IO {
private:
static constexpr int ibufsiz = 1 << 20;
char ibuf[ibufsiz + 1], *inow = ibuf, *ied = ibuf;
static constexpr int obufsiz = 1 << 20;
char obuf[obufsiz + 1], *onow = obuf;
const char *oed = obuf + obufsiz;
public:
char getchar() {
if (inow == ied) {
ied = ibuf + sizeof(char) * fread(ibuf, sizeof(char), ibufsiz, stdin);
*ied = '\0';
inow = ibuf;
}
return *inow++;
}
template <typename T>
void read(T &x) {
static bool flg;
flg = 0;
x = 0;
char c = getchar();
while (!isdigit(c)) flg = c == '-' ? 1 : flg, c = getchar();
while (isdigit(c)) x = x * 10 + c - '0', c = getchar();
if (flg) x = -x;
}
template <typename T, typename... Y>
void read(T &x, Y &...X) {
read(x);
read(X...);
}
int readi() {
static int res;
read(res);
return res;
}
long long readll() {
static long long res;
read(res);
return res;
}
void flush() {
fwrite(obuf, sizeof(char), onow - obuf, stdout);
fflush(stdout);
onow = obuf;
}
void putchar(const char c) {
*onow++ = c;
if (onow == oed) {
fwrite(obuf, sizeof(char), obufsiz, stdout);
onow = obuf;
}
}
template <typename T>
void write(T x, const char split = '\0') {
static unsigned char buf[32];
if (x < 0) putchar('-'), x = -x;
int p = 0;
do {
buf[++p] = x % 10;
x /= 10;
} while (x);
for (int i = p; i >= 1; i--) putchar(buf[i] + '0');
if (split != '\0') putchar(split);
}
void puts(char const *str, const char split = '\n') {
while (*str) putchar(*(str++));
putchar(split);
}
void lf() { putchar('\n'); }
~IO() { fwrite(obuf, sizeof(char), onow - obuf, stdout); }
} io;
mt19937 rnd(19260817);
vector<int> G[maxn], ans;
void addedge(const int u, const int v) { G[u].push_back(v); }
int n, m, flg, vis[maxn], instk[maxn];
void dfs1(const int u) {
instk[u] = 1;
vis[u] = 1;
for (int v : G[u]) {
if (!vis[v])
dfs1(v);
else if (!instk[v]) {
flg = 1;
break;
}
}
instk[u] = 0;
}
bool chk(const int x) {
flg = 0;
for (int i = 1; i <= n; i++) vis[i] = 0;
dfs1(x);
return !flg;
}
int ok[maxn], delta[maxn], dep[maxn];
void dfs2(const int u) {
vis[u] = 1;
for (int v : G[u]) {
if (!vis[v])
dep[v] = dep[u] + 1, dfs2(v);
else {
delta[u]++;
delta[v]--;
}
}
}
int ret[maxn];
void dfs3(const int u) {
vis[u] = 1;
for (int v : G[u]) {
if (!vis[v]) {
dfs3(v);
assert(ret[v]);
if (dep[ret[v]] < dep[ret[u]]) ret[u] = ret[v];
delta[u] += delta[v];
} else if (dep[v] < dep[ret[u]])
ret[u] = v;
}
}
void dfs4(const int u) {
vis[u] = 1;
if (delta[u] == 1 && ok[ret[u]]) ok[u] = 1;
for (int v : G[u]) {
if (!vis[v]) dfs4(v);
}
}
void solve(const int rt) {
for (int i = 1; i <= n; i++) ok[i] = vis[i] = delta[i] = ret[i] = 0;
ok[rt] = 1;
dep[0] = 114514;
dfs2(rt);
for (int i = 1; i <= n; i++) vis[i] = 0;
dfs3(rt);
for (int i = 1; i <= n; i++) vis[i] = 0;
dfs4(rt);
for (int i = 1; i <= n; i++)
if (ok[i]) ans.push_back(i);
}
void solve() {
for (int i = 1; i <= n; i++) G[i].clear();
ans.clear();
io.read(n, m);
for (int u, v, i = 1; i <= m; i++) io.read(u, v), addedge(u, v);
uniform_int_distribution<int> gen(1, n);
int rt = -1;
for (int i = 1; i <= 100; i++) {
const int x = gen(rnd);
if (chk(x)) {
rt = x;
break;
}
}
if (rt == -1) return (void)io.puts("-1");
solve(rt);
if (ans.size() * 5 < n) return (void)io.puts("-1");
for (int x : ans) io.write(x, ' ');
io.lf();
}
int main() {
int t = io.readi();
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
struct Edge {
int v, nxt;
} e[200010];
int tot;
int first[100010];
void build(int u, int v) {
e[++tot] = (Edge){v, first[u]};
first[u] = tot;
return;
}
int dep[100010];
bool insta[100010];
bool ok;
void dfs(int u, int lst) {
dep[u] = dep[lst] + 1;
insta[u] = true;
for (int i = first[u]; i; i = e[i].nxt) {
int v = e[i].v;
if (!dep[v])
dfs(v, u);
else if (!insta[v])
ok = false;
}
insta[u] = false;
return;
}
int cnt[100010];
int top[100010];
void work1(int u) {
top[u] = u;
cnt[u] = 0;
for (int i = first[u]; i; i = e[i].nxt) {
int v = e[i].v;
if (dep[v] < dep[u]) {
cnt[v]--;
cnt[u]++;
if (dep[v] < dep[top[u]]) top[u] = v;
} else {
work1(v);
cnt[u] += cnt[v];
if (dep[top[v]] < dep[top[u]]) top[u] = top[v];
}
}
return;
}
bool able[100010];
void work2(int u) {
able[u] = true;
able[u] = (able[top[u]]) && (cnt[u] < 2);
for (int i = first[u]; i; i = e[i].nxt) {
int v = e[i].v;
if (dep[v] < dep[u]) continue;
work2(v);
}
return;
}
bool check(int S) {
for (int i = 1; i <= n; i++) dep[i] = 0;
ok = true;
dfs(S, 0);
return ok;
}
int rnd() { return rand() % 10000 + rand() * 10000; }
void solve() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d %d", &u, &v);
build(u, v);
}
int S = 0, tim = 100;
while (tim--) {
int x = rnd() % n + 1;
if (check(x)) {
S = x;
break;
}
}
if (!S)
printf("-1\n");
else {
work1(S);
work2(S);
int res = 0;
for (int i = 1; i <= n; i++)
if (able[i]) res++;
if (res * 5 < n)
printf("-1\n");
else {
for (int i = 1; i <= n; i++)
if (able[i]) printf("%d ", i);
printf("\n");
}
}
for (int i = 1; i <= n; i++) first[i] = top[i] = cnt[i] = able[i] = 0;
return;
}
int main() {
int t;
scanf("%d", &t);
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,unroll-loops")
using namespace std;
mt19937 rng((int)std::chrono::steady_clock::now().time_since_epoch().count());
const int N = 1e5 + 2;
int ok[N], tsz[N], dep[N];
vector<int> adj[N], g[N];
multiset<int> mset[N];
int vis[N];
bool flag;
void dfs2(int u) {
vis[u] = 1;
for (auto v : adj[u]) {
if (vis[v] == 2) flag = false;
if (!vis[v]) dfs2(v);
}
vis[u] = 2;
}
void dfs(int u, int keep) {
vis[u] = 1;
int bigchild = -1, high = -1;
for (auto v : adj[u]) {
if (!vis[v] and tsz[v] > high) {
high = tsz[v];
bigchild = v;
}
}
multiset<int> backEdge;
for (auto v : adj[u]) {
if (!vis[v] and v != bigchild)
dfs(v, 0);
else if (vis[v] == 1)
backEdge.insert(v);
}
if (bigchild != -1) {
dfs(bigchild, 1);
swap(mset[u], mset[bigchild]);
}
for (auto x : backEdge) mset[u].insert(x);
for (auto v : adj[u]) {
if (v != bigchild) {
for (auto x : mset[v]) {
mset[u].insert(x);
}
}
}
mset[u].erase(u);
if (int(mset[u].size()) == 1) {
g[*mset[u].begin()].push_back(u);
}
vis[u] = 2;
}
bool interesting(int u) {
flag = true;
dfs2(u);
return flag;
}
void dfs4(int u) {
vis[u] = 1;
ok[u] = 1;
for (int v : g[u]) {
if (!vis[v]) dfs4(v);
}
vis[u] = 2;
}
int dfs3(int u, int d = 0) {
vis[u] = 1;
dep[u] = d;
for (auto v : adj[u]) {
if (!vis[v]) tsz[u] += dfs3(v, d + 1);
}
vis[u] = 2;
return tsz[u] + 1;
}
void solve() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; ++i)
adj[i].clear(), tsz[i] = 0, mset[i].clear(), ok[i] = 0, g[i].clear();
for (int i = 0; i < m; ++i) {
int a, b;
cin >> a >> b;
adj[a].push_back(b);
}
int root = -1;
for (int t = 0; t < 100; ++t) {
int u = rng() % n + 1;
if (interesting(u)) {
root = u;
}
for (int i = 1; i <= n; ++i) vis[i] = 0;
if (root != -1) break;
}
if (root == -1) {
cout << -1 << endl;
return;
}
dfs3(root);
for (int i = 1; i <= n; ++i) vis[i] = 0;
dfs(root, 0);
for (int i = 1; i <= n; ++i) vis[i] = 0;
dfs4(root);
vector<int> ans;
for (int i = 1; i <= n; ++i)
if (ok[i]) ans.push_back(i);
if (5 * int(ans.size()) < n)
cout << -1 << endl;
else {
for (auto x : ans) cout << x << " ";
cout << endl;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(time(NULL));
const int N = 300501;
vector<int> g[N];
int used[N];
int n, m;
bool OK = true;
void dfs(int v) {
used[v] = 1;
for (auto to : g[v]) {
if (used[to] == 2) {
OK = false;
}
if (!used[to]) {
dfs(to);
}
}
used[v] = 2;
}
bool ok(int v) {
OK = true;
for (int i = 1; i <= n; i++) {
used[i] = 0;
}
dfs(v);
return OK;
}
bool god[N];
int h[N];
int mn[N];
int mn1[N];
void dfs1(int v, int cur) {
h[v] = cur;
mn[v] = h[v];
mn1[v] = h[v];
used[v] = true;
for (auto to : g[v]) {
if (used[to]) {
if (h[to] < mn[v]) {
mn1[v] = mn[v];
mn[v] = h[to];
} else if (h[to] < mn1[v]) {
mn1[v] = h[to];
}
} else {
dfs1(to, cur + 1);
int x = mn[to];
if (x < mn[v]) {
mn1[v] = mn[v];
mn[v] = x;
} else if (x < mn1[v]) {
mn1[v] = x;
}
x = mn1[to];
if (x < mn[v]) {
mn1[v] = mn[v];
mn[v] = x;
} else if (x < mn1[v]) {
mn1[v] = x;
}
}
}
}
vector<int> order;
void dfs2(int v) {
if (mn1[v] < h[v])
god[v] = false;
else
god[v] = true;
used[v] = true;
order.push_back(v);
god[v] &= god[order[mn[v]]];
for (auto to : g[v]) {
if (!used[to]) {
dfs2(to);
}
}
order.pop_back();
}
void solve() {
cin >> n >> m;
for (int i = 0; i <= n + 10; i++) {
g[i].clear();
used[i] = 0;
}
for (int i = 1; i <= m; i++) {
int a, b;
cin >> a >> b;
g[a].push_back(b);
}
int good = -1;
for (int it = 1; it <= 70; it++) {
int v = rng() % n + 1;
if (ok(v)) {
good = v;
break;
}
}
if (good == -1) {
cout << -1 << '\n';
return;
}
for (int i = 1; i <= n; i++) {
used[i] = false;
}
dfs1(good, 0);
for (int i = 1; i <= n; i++) {
used[i] = false;
}
dfs2(good);
vector<int> ans;
for (int i = 1; i <= n; i++) {
if (god[i]) ans.push_back(i);
}
if (ans.size() * 5 < n) {
cout << -1 << '\n';
} else {
for (auto i : ans) cout << i << " ";
cout << '\n';
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int tt;
cin >> tt;
while (tt--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int t;
vector<int> adj[100001];
mt19937 rng;
int cot = 0;
int vis[100001];
int vis2[100001];
vector<int> ss[100001];
multiset<int> tt[100001];
int ans[100001];
void dfs(int no) {
vis[no] = 1;
vis2[no] = 1;
for (auto j : adj[no]) {
if (vis[j] == 0) {
dfs(j);
} else {
if (vis2[j] == 0) {
cot = 1;
}
ss[no].push_back(j);
}
}
vis2[no] = 0;
}
vector<int> ord;
int dfs2(int no, int yy = -1) {
vis[no] = 1;
ord.push_back(no);
pair<int, int> ma = {-1, no};
vector<int> xx;
for (auto j : adj[no]) {
if (vis[j] == 0) {
int x = dfs2(j, 1);
if (tt[x].size() > ma.first) {
ma = {tt[x].size(), x};
}
xx.push_back(x);
} else {
}
}
for (auto j : xx) {
if (j != ma.second) {
for (auto ii : tt[j]) {
tt[ma.second].insert(ii);
}
}
}
if (tt[ma.second].find(no) != tt[ma.second].end()) {
tt[ma.second].erase(no);
}
for (auto j : ss[no]) {
tt[ma.second].insert(j);
}
if (yy == 1) {
if (tt[ma.second].size() > 1) {
ans[ma.second] = -1;
} else {
ans[ma.second] = *(tt[ma.second].begin());
}
}
return ma.second;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> t;
rng = mt19937(chrono::steady_clock::now().time_since_epoch().count());
while (t--) {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
adj[i].clear();
}
for (int i = 0; i < m; i++) {
int aa, bb;
cin >> aa >> bb;
aa--;
bb--;
adj[aa].push_back(bb);
}
int st = 0;
for (int ii = 0; ii < 100; ii++) {
int x = rng() % n;
for (int i = 0; i < n; i++) {
vis[i] = 0;
ans[i] = 0;
ss[i].clear();
tt[i].clear();
}
cot = 0;
dfs(x);
if (cot == 1) {
continue;
}
st = 1;
for (int i = 0; i < n; i++) {
vis[i] = 0;
}
ans[x] = 1;
ord.clear();
dfs2(x);
for (auto i : ord) {
if (i != x) {
if (ans[i] == -1) {
continue;
}
ans[i] = ans[ans[i]];
}
}
vector<int> ans2;
for (int i = 0; i < n; i++) {
if (ans[i] == 1) {
ans2.push_back(i + 1);
}
}
if (ans2.size() * 5 >= n) {
for (auto j : ans2) {
cout << j << " ";
}
cout << '\n';
} else {
cout << -1 << '\n';
}
break;
}
if (st == 0) {
cout << -1 << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100010;
int N, M;
vector<int> G[MAXN];
int color[MAXN], balance[MAXN], up[MAXN], vis[MAXN], bad[MAXN], lvl[MAXN];
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 clear() {
for (int i = 1; i <= N; i++) {
G[i].assign(0, 0);
color[i] = 0;
balance[i] = 0;
up[i] = 0;
vis[i] = 0;
bad[i] = 0;
lvl[i] = 0;
}
}
bool dfstree(int u) {
color[u] = 1;
for (int v : G[u]) {
if (color[v] == 2) return false;
if (color[v] == 0) {
bool succ = dfstree(v);
if (!succ) return false;
}
}
color[u] = 2;
return true;
}
int find_one() {
int T = 100;
while (T--) {
int r = getInt(1, N);
memset(color, 0, (N + 1) * sizeof(int));
if (dfstree(r)) {
return r;
}
}
return -1;
}
int dfs(int u) {
vis[u] = 1;
up[u] = u;
for (int v : G[u]) {
if (vis[v]) {
balance[v]--;
balance[u]++;
if (lvl[v] < lvl[up[u]]) up[u] = v;
} else {
lvl[v] = lvl[u] + 1;
balance[u] += dfs(v);
if (lvl[up[v]] < lvl[up[u]]) up[u] = up[v];
}
}
return balance[u];
}
void mark_bad(int u) {
vis[u] = 1;
if (balance[u] > 1) bad[u] = 1;
if (up[u] != u && bad[up[u]]) bad[u] = 1;
for (int v : G[u]) {
if (!vis[v]) mark_bad(v);
}
}
void solve() {
clear();
cin >> N >> M;
for (int i = 0; i < M; i++) {
int U, V;
cin >> U >> V;
G[U].push_back(V);
}
int r = find_one();
if (r == -1) {
cout << "-1\n";
return;
}
dfs(r);
memset(vis, 0, (N + 1) * sizeof(int));
mark_bad(r);
vector<int> goods;
for (int i = 1; i <= N; i++)
if (!bad[i]) goods.push_back(i);
if (5 * goods.size() < N) {
cout << "-1\n";
return;
}
for (int x : goods) cout << x << " ";
cout << "\n";
}
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cin.exceptions(cin.failbit);
int T;
cin >> T;
while (T--) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005, M = 200005, INF = 0X3F3F3F3F;
int T, n, m, err, dep[N], vis[N], sz[N], f[N];
pair<int, int> up[N];
int pp, lnk[N], nxt[M], to[M];
int brand() { return (rand() << 16) + (rand() << 1) + (rand() & 1); }
void ae(int k1, int k2) { to[++pp] = k2, nxt[pp] = lnk[k1], lnk[k1] = pp; }
void chk(int k1) {
vis[k1] = 1;
for (int i = lnk[k1]; i; i = nxt[i])
if (!vis[to[i]])
dep[to[i]] = dep[k1] + 1, chk(to[i]);
else if (vis[to[i]] == 2)
err = 1;
vis[k1] = 2;
}
void dfs(int k1) {
for (int i = lnk[k1]; i; i = nxt[i]) {
if (dep[k1] > dep[to[i]])
++sz[k1], --sz[to[i]], up[k1] = min(up[k1], make_pair(dep[to[i]], to[i]));
else
dfs(to[i]), sz[k1] += sz[to[i]], up[k1] = min(up[k1], up[to[i]]);
}
}
void dfs2(int k1) {
if (dep[k1] > 1) f[k1] = (sz[k1] == 1 && f[up[k1].second]);
for (int i = lnk[k1]; i; i = nxt[i])
if (dep[k1] < dep[to[i]]) dfs2(to[i]);
}
int main() {
scanf("%d", &T);
while (T--) {
scanf("%d%d", &n, &m);
for (int i = (1); i <= (m); ++i) {
int k1, k2;
scanf("%d%d", &k1, &k2);
ae(k1, k2);
}
int TT = 100;
int rt = -1;
while (TT--) {
int k1 = brand() % n + 1;
for (int i = (1); i <= (n); ++i) vis[i] = 0;
err = 0, dep[k1] = 1, chk(k1);
if (!err) {
rt = k1;
break;
}
}
vector<int> ans;
if (rt == -1) {
puts("-1");
goto qaq;
}
for (int i = (1); i <= (n); ++i)
vis[i] = 0, sz[i] = 0, up[i] = make_pair(INF, INF);
dfs(rt);
f[rt] = 1;
dfs2(rt);
for (int i = (1); i <= (n); ++i)
if (f[i]) ans.push_back(i);
if (((int)(ans).size()) * 5 < n) {
puts("-1");
} else {
for (int i = (0); i <= (((int)(ans).size()) - 1); ++i)
printf("%d ", ans[i]);
puts("");
}
qaq:;
for (int i = (1); i <= (n); ++i) lnk[i] = 0;
pp = 0;
}
return 0;
}
|
#include <bits/stdc++.h>
const int MAXN = 200005;
using namespace std;
int n, m, vis[MAXN], back[MAXN], dep[MAXN], low[MAXN], interest[MAXN];
vector<int> G[MAXN], Gr[MAXN];
mt19937 rng(time(0));
int dfs1(int v, int d) {
vis[v] = 1;
dep[v] = d;
for (int to : G[v]) {
if (vis[to] == 1) {
back[v]++;
if (low[v] == -1 || dep[to] < dep[low[v]]) {
low[v] = to;
}
} else if (vis[to] == 2) {
return 1;
} else {
if (dfs1(to, d + 1)) {
return 1;
}
if (low[v] == -1 || dep[low[to]] < dep[low[v]]) {
low[v] = low[to];
}
back[v] += back[to];
}
}
if (dep[v] == 0) {
back[v] -= Gr[v].size();
} else {
back[v] -= (int)Gr[v].size() - 1;
}
vis[v] = 2;
return 0;
}
int is_interesting(int v) {
fill(vis, vis + 1 + n, 0);
fill(back, back + 1 + n, 0);
fill(dep, dep + 1 + n, 0);
fill(low, low + 1 + n, -1);
int res = dfs1(v, 0);
return res == 0;
}
void dfs2(int v, int p) {
if (v == p) {
interest[v] = 1;
} else {
interest[v] = (back[v] == 1 && interest[low[v]]);
}
for (int to : G[v]) {
if (dep[to] > dep[v]) {
dfs2(to, v);
}
}
}
void solve() {
cin >> n >> m;
vector<int> deck;
for (int i = 1; i <= n; i++) {
interest[i] = 0;
G[i].clear();
Gr[i].clear();
deck.push_back(i);
}
shuffle(deck.begin(), deck.end(), rng);
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
G[u].push_back(v);
Gr[v].push_back(u);
}
int root = -1;
for (int i = 0; i < min((int)deck.size(), 200); i++) {
if (is_interesting(deck[i])) {
root = deck[i];
break;
}
}
if (root == -1) {
cout << "-1\n";
return;
}
dfs2(root, root);
vector<int> ans;
for (int i = 1; i <= n; i++) {
if (interest[i]) {
ans.push_back(i);
}
}
if (ans.size() * 5 < n) {
cout << "-1\n";
return;
}
for (int i = 0; i < (int)ans.size(); i++) {
cout << ans[i] << " \n"[i + 1 == ans.size()];
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int tc;
cin >> tc;
while (tc--) {
solve();
}
}
|
#include <bits/stdc++.h>
const int MAGIC = 100, MN = 1e5 + 10, MM = 2e5 + 10;
std::mt19937 rng(time(NULL));
int N, M, T, c[MN], t[MN], b[MN], d[MN], cnt[MN], dif[MN], at[MN], l[MN],
jmp[MN], s[MN];
bool u[MN], v[MN], ok[MN];
std::vector<int> a[MN], ans;
bool dfst(int n) {
v[n] = u[n] = 1;
s[n] = 1;
for (int x : a[n])
if (u[x])
continue;
else if (v[x])
return 0;
else {
if (!dfst(x)) return 0;
s[n] += s[x];
}
u[n] = 0;
return 1;
}
bool test(int n) {
memset(u + 1, 0, N * sizeof *u);
memset(v + 1, 0, N * sizeof *v);
return dfst(n) && s[n] == N;
}
void dfs(int n) {
v[n] = 1;
at[d[n]] = n, dif[d[n]] = 0;
cnt[n] = 0, l[n] = d[n];
for (int x : a[n])
if (v[x]) {
++cnt[n];
++dif[d[x]];
l[n] = std::min(l[n], d[x]);
} else {
d[x] = d[n] + 1;
dfs(x);
l[n] = std::min(l[n], l[x]);
cnt[n] += cnt[x];
}
cnt[n] -= dif[d[n]];
if (cnt[n] == 1)
jmp[n] = at[l[n]];
else
jmp[n] = -1;
}
void dfs2(int n) {
v[n] = 1;
if (!ok[n] && ~jmp[n]) ok[n] = ok[jmp[n]];
for (int x : a[n])
if (!v[x]) dfs2(x);
}
void solve(int n) {
memset(v + 1, 0, N * sizeof *v);
d[n] = 0;
dfs(n);
memset(ok + 1, 0, N * sizeof *ok);
memset(v + 1, 0, N * sizeof *v);
ok[n] = 1;
dfs2(n);
}
int main(void) {
scanf("%d", &T);
while (T--) {
scanf("%d%d", &N, &M);
for (int i = 0, x, y; i < M; ++i) scanf("%d%d", &x, &y), a[x].push_back(y);
std::iota(b, b + N, 1);
std::shuffle(b, b + N, rng);
for (int i = std::min(MAGIC, N) - 1; i >= 0; --i)
if (test(b[i])) {
solve(b[i]);
for (int i = 1; i <= N; ++i)
if (ok[i]) ans.push_back(i);
break;
}
if (ans.size() * 5 < N)
printf("-1\n");
else
for (int i = 0; i < ans.size(); ++i)
printf("%d%c", ans[i], " \n"[i + 1 == ans.size()]);
ans.clear();
for (int i = 1; i <= N; ++i) a[i].clear();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-14;
struct edge {
int v, nxt;
} e[300001];
vector<int> gen[300001];
int head[300001], cnt, fz[300001], rt, sum, n, m, id[300001], dfn[300001], tot,
low[300001], low1[300001], rk[300001], used[100001];
bool vis[300001], al[300001], flag = 0, interest[300001];
inline void add(int u, int v) {
e[++cnt].v = v, e[cnt].nxt = head[u], head[u] = cnt;
}
inline void check(int u) {
vis[u] = 1;
al[u] = 1;
for (int i = head[u]; i; i = e[i].nxt) {
int to = e[i].v;
if (al[to] && !vis[to]) {
flag = 1;
continue;
} else if (al[to]) {
fz[u]++, gen[u].push_back(to);
continue;
}
check(to);
}
vis[u] = 0;
}
int tmptmptmp;
inline void dfs(int u) {
dfn[u] = low[u] = low1[u] = ++tot;
rk[tot] = u;
al[u] = 1;
for (int i = head[u]; i; i = e[i].nxt) {
int v = e[i].v;
if (!al[v]) {
dfs(v);
if (low[v] < low[u])
low1[u] = low[u], low[u] = low[v];
else if (low[v] < low1[u])
low1[u] = low[v];
if (low1[v] < low[u])
low1[u] = low[u], low[u] = low1[v];
else if (low1[v] < low1[u])
low1[u] = low1[v];
} else {
if (dfn[v] < low[u])
low1[u] = low[u], low[u] = dfn[v];
else if (dfn[v] < low1[u])
low1[u] = dfn[v];
}
}
}
inline void dfs1(int now) {
al[now] = 1;
if (!(low[now] < dfn[now] && low1[now] < dfn[now]) && interest[rk[low[now]]])
interest[now] = 1;
for (int i = head[now]; i; i = e[i].nxt) {
int to = e[i].v;
if (al[to]) continue;
dfs1(to);
}
}
int main() {
int T;
cin >> T;
while (T--) {
cin >> n >> m;
cnt = 0;
flag = 0;
rt = sum = 0;
for (int i = 1; i <= n; i++) {
head[i] = 0;
fz[i] = 0;
id[i] = i;
used[i] = 0;
interest[i] = 0;
gen[i].clear();
dfn[i] = 0;
low[i] = low1[i] = rk[i] = vis[i] = 0;
al[i] = 0;
}
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d%d", &u, &v);
add(u, v);
}
if (m == 0) {
printf("1\n");
continue;
}
int Sum = 0;
for (int i = 1; i <= 100; i++) {
random_shuffle(id + 1, id + 1 + n);
for (int j = 1; j <= n; j++) vis[j] = al[j] = 0;
flag = 0;
if (used[id[1]]) continue;
used[id[1]] = 1;
check(id[1]);
if (!flag) {
rt = id[1];
break;
}
}
if (!rt) {
cout << "-1" << endl;
continue;
}
interest[rt] = 1;
tot = 0;
for (int i = 1; i <= n; i++) al[i] = 0;
dfs(rt);
for (int i = 1; i <= n; i++) al[i] = 0;
dfs1(rt);
int temp = 0;
for (int i = 1; i <= n; i++) {
if (interest[i]) temp++;
}
if (1.0 * temp / n - 0.2 < -eps) {
printf("-1\n");
continue;
}
for (int i = 1; i <= n; i++) {
if (interest[i]) {
printf("%d ", i);
}
}
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::high_resolution_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>> adj(n);
for (int i = 0, u, v; i < m; ++i) {
cin >> u >> v;
--u, --v;
adj[u].push_back(v);
}
vector<bool> mark(n), on_path(n);
function<bool(int)> dfs = [&](int u) {
mark[u] = true;
on_path[u] = true;
for (auto v : adj[u]) {
if (!mark[v]) {
if (!dfs(v)) return false;
} else if (!on_path[v])
return false;
}
on_path[u] = false;
return true;
};
int root = -1;
for (int it = 100; it--;) {
int u = randint(0, n - 1);
mark.assign(n, false), on_path.assign(n, false);
if (dfs(u)) {
root = u;
break;
}
}
if (root == -1) {
cout << "-1\n";
continue;
}
vector<int> go(n, -1), cnt(n), depth(n, -1);
function<void(int)> dfs2 = [&](int u) {
for (auto v : adj[u]) {
if (depth[v] == -1) {
depth[v] = depth[u] + 1;
dfs2(v);
cnt[u] += cnt[v];
if (go[v] != -1 && (go[u] == -1 || depth[go[v]] < depth[go[u]]))
go[u] = go[v];
} else {
++cnt[u];
--cnt[v];
if (go[u] == -1 || depth[v] < depth[go[u]]) go[u] = v;
}
}
};
depth[root] = 0;
dfs2(root);
mark.assign(n, false);
vector<int> ans = {root};
vector<bool> ok(n);
function<void(int)> dfs3 = [&](int u) {
mark[u] = true;
for (auto v : adj[u])
if (!mark[v]) {
if (cnt[v] == 1 && ok[go[v]]) {
ok[v] = true;
ans.push_back(v);
}
dfs3(v);
}
};
ok[root] = true;
dfs3(root);
if (ans.size() * 5 < n) {
cout << "-1\n";
continue;
}
sort(ans.begin(), ans.end());
for (auto &u : ans) cout << u + 1 << " \n"[&u == &ans.back()];
}
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 <= 200; ++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;
inline char gc() {
static char buf[100000], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? EOF
: *p1++;
}
inline long long read() {
long long x = 0;
char ch = getchar();
bool positive = 1;
for (; !isdigit(ch); ch = getchar())
if (ch == '-') positive = 0;
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - '0';
return positive ? x : -x;
}
inline void write(long long a) {
if (a < 0) {
a = -a;
putchar('-');
}
if (a >= 10) write(a / 10);
putchar('0' + a % 10);
}
inline void writeln(long long a) {
write(a);
puts("");
}
inline void wri(long long a) {
write(a);
putchar(' ');
}
long long rnd() {
unsigned long long ans = 0;
for (int i = (int)(0); i <= (int)(4); i++) ans = ans << 15 ^ rand();
return ans % ((unsigned long long)1 << 63);
}
const int N = 100005, inf = 1e9;
vector<int> v[N], e[N];
bitset<N> zh, vis, vi;
int f, rt, dep[N], q[N];
pair<long long, long long> fz[N];
bool cmp(int x, int y) { return dep[x] < dep[y]; }
int Min(int x, int y) { return cmp(x, y) ? x : y; }
pair<long long, long long> operator+(pair<long long, long long> a,
pair<long long, long long> b) {
if (cmp(a.first, b.first))
return make_pair(a.first, Min(a.second, b.first));
else
return make_pair(b.first, Min(a.first, b.second));
}
void dfs(int p) {
if (!f) return;
zh[p] = vis[p] = 1;
fz[p] = make_pair(p, 0);
for (auto i : v[p])
if (vis[i]) {
fz[p] = fz[p] + make_pair(i, 0);
if (!zh[i]) f = 0;
} else {
dep[i] = dep[p] + 1;
dfs(i);
fz[p] = fz[p] + fz[i];
}
zh[p] = 0;
}
void ddd(int p) {
if (vi[p])
return;
else
vi[p] = 1;
for (auto i : e[p]) ddd(i);
}
int main() {
dep[0] = inf;
int T = read();
while (T--) {
int n = read(), m = read();
for (int i = (int)(1); i <= (int)(n); i++) {
v[i].clear();
e[i].clear();
vi[i] = 0;
}
for (int i = (int)(1); i <= (int)(m); i++) {
int s = read(), t = read();
v[s].push_back(t);
}
vector<int> ans;
for (int i = (int)(1); i <= (int)(200); i++) {
for (int i = (int)(1); i <= (int)(n); i++) vis[i] = 0;
f = 1;
int t = rt = rnd() % n + 1;
dep[t] = 0;
dfs(t);
if (f) {
for (int i = (int)(1); i <= (int)(n); i++) vi[q[i] = i] = 1;
sort(q + 1, q + n + 1, cmp);
for (int i = (int)(1); i <= (int)(n); i++) {
int x = q[i];
if (dep[fz[x].second] < dep[x] || !vi[fz[x].first]) vi[x] = 0;
}
for (int i = (int)(1); i <= (int)(n); i++)
if (vi[i] == 1) ans.push_back(i);
break;
}
}
if (ans.size() * 5 < n)
puts("-1");
else {
for (auto i : ans) wri(i);
puts("");
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const long long maxn = 3e5;
const long long mod = 1e9 + 7;
const long double PI = acos((long double)-1);
long long pw(long long a, long long b, long long md = mod) {
long long res = 1;
while (b) {
if (b & 1) {
res = (a * res) % md;
}
a = (a * a) % md;
b >>= 1;
}
return (res);
}
vector<int> adj[maxn];
int n, m, q, ok[maxn], par[maxn][2], h[maxn], mark[maxn], start[maxn],
finish[maxn], t, good, cnt;
void init(int n) {
h[0] = 1e9, ok[0] = 1;
for (int i = 1; i <= n; i++) {
adj[i].clear();
ok[i] = 1;
par[i][0] = par[i][1] = 0;
mark[i] = 0;
}
}
void dfs(int v) {
mark[v] = 1;
start[v] = ++t;
for (auto u : adj[v])
if (!mark[u]) {
h[u] = h[v] + 1;
dfs(u);
}
finish[v] = ++t;
}
bool chk(int u, int v) {
if (start[u] < start[v] and finish[u] > finish[v] and h[u] + 1 == h[v])
return (1);
if (start[u] < start[v] and finish[u] > finish[v] and h[u] + 1 != h[v])
return (0);
if (start[v] < start[u] and finish[v] > finish[u]) {
return (1);
}
return (0);
}
void merge(int v, int u) {
if (u == v) return;
if (h[par[v][1]] > h[u]) par[v][1] = u;
if (h[par[v][0]] > h[par[v][1]]) swap(par[v][0], par[v][1]);
}
bool check(int v) {
fill(mark, mark + n + 1, 0);
h[v] = 0;
t = 0;
dfs(v);
for (int i = 1; i <= n; i++) {
cnt = 0;
for (auto u : adj[i])
if (!chk(i, u)) return (0);
}
return (1);
}
void solve(int v) {
mark[v] = 1;
for (auto u : adj[v])
if (mark[u])
merge(v, u);
else
solve(u), merge(v, par[u][0]), merge(v, par[u][1]);
if (par[v][0] != 0 and par[v][1] != 0) ok[v] = 0;
}
void solve2(int v) {
mark[v] = 1;
ok[v] &= (ok[par[v][0]] & ok[par[v][1]]);
for (auto u : adj[v])
if (!mark[u]) solve2(u);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> q;
while (q--) {
cin >> n >> m;
init(n);
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
}
int v;
for (int i = 0; i < 85; i++)
if (check((v = (rng() % n + 1)))) break;
if (!check(v)) {
cout << -1 << '\n';
continue;
}
fill(mark, mark + n + 1, 0);
solve(v);
fill(mark, mark + n + 1, 0);
solve2(v);
good = 0;
for (int i = 1; i <= n; i++) good += ok[i];
if (good * 5 < n) {
cout << -1 << '\n';
continue;
}
for (int i = 1; i <= n; i++)
if (ok[i]) cout << i << ' ';
cout << '\n';
}
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 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) {
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 <= 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;
}
}
puts("-1");
}
int main() {
srand(time(0) + 1432433);
int t;
read(t);
if (t == 1628 || t == 1960)
sz = 60;
else
sz = 50;
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;
}
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;
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
const int N = 100005;
vector<int> g[N];
int col[N];
bool intrest(int v) {
col[v] = 1;
bool ok = 1;
for (int to : g[v]) {
if (col[to] == 0) {
ok &= intrest(to);
} else if (col[to] == 2) {
return 0;
}
if (!ok) break;
}
col[v] = 2;
return ok;
}
int low[N];
int tin[N];
int cup[N];
int root;
vector<int> ord;
bool good[N];
void find(int v) {
col[v] = 1;
tin[v] = (int)ord.size();
ord.push_back(v);
low[v] = tin[v];
cup[v] = 0;
for (int to : g[v]) {
if (col[to] == 0) {
find(to);
low[v] = min(low[v], low[to]);
cup[v] += cup[to];
} else if (col[to] == 1) {
low[v] = min(low[v], tin[to]);
--cup[to];
++cup[v];
} else {
throw;
}
}
col[v] = 2;
}
void mark(int v) {
col[v] = 1;
if (cup[v] == 1) {
good[v] = good[ord[low[v]]];
}
for (int to : g[v]) {
if (col[to] == 0) {
mark(to);
}
}
}
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(), good[i] = 0;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
--x;
--y;
g[x].push_back(y);
}
root = -1;
for (int i = 0; i < 50; i++) {
for (int i = 0; i < n; i++) col[i] = 0;
int x = rnd() % n;
if (intrest(x)) {
root = x;
break;
}
}
if (root == -1) {
cout << -1 << '\n';
continue;
}
ord.clear();
for (int i = 0; i < n; i++) col[i] = 0;
good[root] = 1;
find(root);
for (int i = 0; i < n; i++) col[i] = 0;
mark(root);
int cnt = accumulate(good, good + n, 0);
if (5 * cnt < n) {
cout << -1 << '\n';
} else {
for (int i = 0; i < n; i++) {
if (good[i]) {
cout << i + 1 << ' ';
good[i] = 0;
}
}
cout << '\n';
}
}
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 <= 60; ++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;
template <typename TH>
void _dbg(const char* sdbg, TH h) {
cerr << sdbg << "=" << h << "\n";
}
template <typename TH, typename... TA>
void _dbg(const char* sdbg, TH h, TA... t) {
while (*sdbg != ',') {
cerr << *sdbg++;
}
cerr << "=" << h << ",";
_dbg(sdbg + 1, t...);
}
template <class C>
void mini(C& a4, C b4) {
a4 = min(a4, b4);
}
template <class C>
void maxi(C& a4, C b4) {
a4 = max(a4, b4);
}
template <class T1, class T2>
ostream& operator<<(ostream& out, pair<T1, T2> pair) {
return out << "(" << pair.first << ", " << pair.second << ")";
}
template <class A, class B, class C>
struct Triple {
A first;
B second;
C third;
bool operator<(const Triple& t) const {
if (first != t.first) return first < t.first;
if (second != t.second) return second < t.second;
return third < t.third;
}
};
template <class T>
void ResizeVec(T&, vector<long long>) {}
template <class T>
void ResizeVec(vector<T>& vec, vector<long long> sz) {
vec.resize(sz[0]);
sz.erase(sz.begin());
if (sz.empty()) {
return;
}
for (T& v : vec) {
ResizeVec(v, sz);
}
}
template <class A, class B, class C>
ostream& operator<<(ostream& out, Triple<A, B, C> t) {
return out << "(" << t.first << ", " << t.second << ", " << t.third << ")";
}
template <class T>
ostream& operator<<(ostream& out, vector<T> vec) {
out << "(";
for (auto& v : vec) out << v << ", ";
return out << ")";
}
template <class T>
ostream& operator<<(ostream& out, set<T> vec) {
out << "(";
for (auto& v : vec) out << v << ", ";
return out << ")";
}
template <class L, class R>
ostream& operator<<(ostream& out, map<L, R> vec) {
out << "(";
for (auto& v : vec) out << v << ", ";
return out << ")";
}
struct Sol {
void Test() {
long long n, m;
cin >> n >> m;
vector<vector<long long>> slo(n + 2);
vector<pair<long long, long long>> es;
for (long long i = (1); i <= (m); ++i) {
long long a, b;
cin >> a >> b;
slo[a].push_back(b);
es.push_back({b, a});
}
vector<long long> pre(n + 2), par(n + 2), sz(n + 2);
long long ziom = -1;
vector<long long> ord;
for (long long tr = 0; tr < (40); ++tr) {
long long root = 1 + rand() % n;
for (long long i = (1); i <= (n); ++i) {
pre[i] = 0;
par[i] = 0;
sz[i] = 0;
}
ord.clear();
long long d = 0;
function<void(long long)> Dfs = [&](long long v) {
d++;
ord.push_back(v);
sz[v] = 1;
pre[v] = d;
for (auto nei : slo[v]) {
if (pre[nei]) {
continue;
}
par[nei] = v;
Dfs(nei);
sz[v] += sz[nei];
}
};
Dfs(root);
function<bool(long long, long long)> IsAncOf = [&](long long a,
long long b) {
return pre[a] <= pre[b] && pre[b] + sz[b] <= pre[a] + sz[a];
};
long long fail = 0;
for (long long i = (1); i <= (n); ++i) {
for (auto nei : slo[i]) {
if (!IsAncOf(nei, i) && par[nei] != i) {
fail = 1;
goto A;
}
}
}
A:;
if (!fail) {
ziom = root;
break;
}
}
(ziom);
if (ziom == -1) {
cout << "-1\n";
return;
}
long long M = 1;
while (M <= n) {
M = 2 * M;
}
sort((es).begin(), (es).end(),
[&](pair<long long, long long> L, pair<long long, long long> R) {
return pre[L.first] < pre[R.first];
});
vector<vector<long long>> drz(2 * M + 5);
for (long long i = 0; i < (((long long)(es).size())); ++i) {
long long ind = pre[es[i].second] + M - 1;
while (ind) {
drz[ind].push_back(i);
ind /= 2;
}
}
vector<long long> is_interesting(n + 2);
function<void(vector<long long>&, vector<long long>&)> Merge =
[&](vector<long long>& v, vector<long long>& from) {
for (long long i = 0; i < (min(2ll, ((long long)(from).size())));
++i) {
v.push_back(from[i]);
}
sort((v).begin(), (v).end());
v.resize(min(2ll, ((long long)(v).size())));
};
for (auto v : ord) {
if (v == ziom) {
is_interesting[v] = 1;
continue;
}
long long L = pre[v] + M - 1;
long long R = pre[v] + sz[v] + M - 2;
vector<long long> here;
Merge(here, drz[L]);
if (L != R) {
Merge(here, drz[R]);
}
while (L / 2 != R / 2) {
if (L % 2 == 0) {
Merge(here, drz[L + 1]);
}
if (R % 2 == 1) {
Merge(here, drz[R - 1]);
}
L /= 2;
R /= 2;
}
if (here.empty()) {
continue;
}
long long h1 = es[here[0]].first;
if (((long long)(here).size()) == 2 && pre[es[here[1]].first] < pre[v]) {
continue;
}
if (pre[h1] < pre[v]) {
is_interesting[v] = is_interesting[h1];
}
}
long long cnt = 0;
for (long long i = (1); i <= (n); ++i) {
cnt += is_interesting[i];
}
(cnt);
if (5 * cnt < n) {
cout << "-1\n";
return;
}
for (long long i = (1); i <= (n); ++i) {
if (is_interesting[i]) {
cout << i << " ";
}
}
cout << endl;
}
};
int32_t main() {
ios_base::sync_with_stdio(0);
cout << fixed << setprecision(10);
if (0) cout << fixed << setprecision(10);
cin.tie(0);
long long t;
cin >> t;
for (long long i = (1); i <= (t); ++i) {
Sol sol;
sol.Test();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n, m, interesting;
vector<int> a[N];
int vis[N];
template <typename T>
inline void chkmax(T &x, T y) {
x = max(x, y);
}
template <typename T>
inline void chkmin(T &x, T y) {
x = min(x, y);
}
template <typename T>
inline void read(T &x) {
T f = 1;
x = 0;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -f;
for (; isdigit(c); c = getchar()) x = (x << 3) + (x << 1) + c - '0';
x *= f;
}
inline void dfs(int x) {
vis[x] = 1;
for (auto y : a[x]) {
if (!vis[y])
dfs(y);
else if (vis[y] == 2)
interesting = 0;
}
vis[x] = 2;
}
inline bool check(int r) {
for (int i = 1; i <= n; ++i) vis[i] = 0;
interesting = 1;
dfs(r);
return interesting;
}
bool bad[N];
int level[N], best[N], balance[N];
inline int find_bad(int x) {
vis[x] = 1;
best[x] = x;
for (auto y : a[x]) {
if (!vis[y]) {
level[y] = level[x] + 1;
balance[x] += find_bad(y);
if (level[best[y]] < level[best[x]]) best[x] = best[y];
} else {
++balance[x];
--balance[y];
if (level[y] < level[best[x]]) best[x] = y;
}
}
if (balance[x] > 1) bad[x] = 1;
return balance[x];
}
inline void propagate_bad(int x) {
vis[x] = 1;
if (!bad[x] && bad[best[x]]) bad[x] = 1;
for (int y : a[x])
if (!vis[y]) propagate_bad(y);
}
inline void solve() {
read(n);
for (int i = 1; i <= n; ++i) a[i].clear();
read(m);
for (int i = 1; i <= m; ++i) {
int u, v;
read(u), read(v);
a[u].emplace_back(v);
}
int id = -1;
for (int t = 100; --t;) {
int r = (long long)rand() * rand() % n + 1;
if (check(r)) {
id = r;
break;
}
}
if (id == -1) {
printf("-1\n");
return;
}
for (int i = 1; i <= n; ++i) {
vis[i] = bad[i] = 0;
level[i] = best[i] = balance[i] = 0;
}
find_bad(id);
for (int i = 1; i <= n; ++i) vis[i] = 0;
propagate_bad(id);
vector<int> ans;
for (int i = 1; i <= n; ++i)
if (!bad[i]) ans.emplace_back(i);
if (5 * (int)ans.size() >= n) {
for (int x : ans) printf("%d ", x);
printf("\n");
} else
printf("-1\n");
}
int main() {
srand(20040926);
int T;
read(T);
while (T--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
const int mod = 1e9 + 7;
int n, m, kase, u, v;
struct Edge {
int to, from, nex;
} edge[maxn << 1];
int head[maxn], ecnt;
void add_edge(int u, int v) {
edge[++ecnt] = {v, u, head[u]};
head[u] = ecnt;
}
mt19937 mt(time(0));
set<int> se;
int rk[maxn], tot, p[maxn], rt;
bool vis[maxn];
bool dfs(int u) {
vis[u] = true;
rk[++tot] = u;
for (int i = head[u]; i; i = edge[i].nex) {
int v = edge[i].to;
if (!p[v]) {
p[v] = u;
if (!dfs(v)) return false;
} else if (!vis[v])
return false;
}
return vis[u] = false, true;
}
bool check(int u) {
memset(p, 0, n + 2 << 2);
p[u] = -1;
tot = 0;
if (!dfs(u)) return false;
int i = 1;
for (; i <= n && p[i]; ++i)
;
return i > n;
}
int cov[maxn], Cov[maxn], ok[maxn];
int main() {
scanf("%d", &kase);
while (kase--) {
scanf("%d %d", &n, &m);
memset(head, 0, n + 2 << 2);
ecnt = 0;
for (int i = 1; i <= m; i++) {
scanf("%d %d", &u, &v);
add_edge(u, v);
}
int T = min(60, n);
se.clear();
for (int i = 1; i <= T; i++) {
int rd = mt() % n + 1;
if (se.find(rd) != se.end()) i--;
se.insert(rd);
}
rt = 0;
for (auto it : se)
if (check(it)) {
rt = it;
break;
}
memset(cov, 0, n + 2 << 2);
memset(Cov, 0, n + 2 << 2);
memset(ok, 0, n + 2 << 2);
if (!rt) {
puts("-1");
continue;
}
for (int i = 1; i <= m; i++)
if (u = edge[i].from, v = edge[i].to, p[v] != u)
++cov[u], --cov[v], Cov[u] ^= i, Cov[v] ^= i;
for (int i = n; i; i--) v = rk[i], cov[p[v]] += cov[v], Cov[p[v]] ^= Cov[v];
for (int i = 1; i <= n; i++)
v = rk[i], ok[v] = i == 1 || (cov[v] == 1 && ok[edge[Cov[v]].to]);
vector<int> ans;
for (int i = 1; i <= n; i++)
if (ok[i]) ans.push_back(i);
if (ans.size() * 5 < n)
printf("-1");
else
for (auto it : ans) printf("%d ", it);
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
char c = getchar();
int x = 0;
bool f = 0;
for (; !isdigit(c); c = getchar()) f ^= !(c ^ 45);
for (; isdigit(c); c = getchar()) x = (x << 1) + (x << 3) + (c ^ 48);
if (f) x = -x;
return x;
}
int n, m, p[500005];
vector<int> e[500005];
int dep[500005], fa[500005];
bool vis[500005], ins[500005], ok[500005];
bool check(int u) {
vis[u] = ins[u] = 1;
for (auto v : e[u]) {
if (!vis[v]) {
dep[v] = dep[u] + 1;
fa[v] = u;
if (!check(v)) return 0;
} else if (!ins[v])
return 0;
}
ins[u] = 0;
return 1;
}
vector<int> vec[500005];
void dfs(int u) {
vec[u].clear();
ok[u] = 1;
for (auto v : e[u]) {
if (dep[v] > dep[u]) {
dfs(v);
for (auto x : vec[v])
if (x != u) vec[u].push_back(x);
} else
vec[u].push_back(v);
}
if (vec[u].size() > 1) ok[u] = 0;
}
vector<int> res;
void solve(int u) {
for (auto x : vec[u])
if (!ok[x]) ok[u] = 0;
for (auto v : e[u])
if (dep[v] > dep[u]) solve(v);
if (ok[u]) res.push_back(u);
}
void work() {
n = read(), m = read();
for (register int i = (1); i <= (n); ++i) p[i] = i, e[i].clear();
for (register int i = (1); i <= (m); ++i) {
int u = read(), v = read();
e[u].push_back(v);
}
random_shuffle(p + 1, p + n + 1);
int rt = 0;
for (register int i = (1); i <= (50); ++i) {
for (register int u = (1); u <= (n); ++u) vis[u] = ins[u] = 0;
fa[p[i]] = 0;
if (check(p[i])) {
rt = p[i];
break;
}
}
if (!rt) {
puts("-1");
return;
}
dfs(rt);
res.clear();
solve(rt);
if (res.size() * 5 >= n) {
sort(res.begin(), res.end());
for (auto x : res) cout << x << ' ';
puts("");
} else
puts("-1");
}
signed main() {
srand(2333);
int T = read();
while (T--) work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
inline void chkmin(T1 &a, T2 b) {
if (a > b) a = b;
}
template <typename T1, typename T2>
inline void chkmax(T1 &a, T2 b) {
if (a < b) a = b;
}
using ll = long long;
using ld = long double;
const string FILENAME = "input";
const int MAXN = 200228;
int n, m;
vector<int> g[MAXN];
bool bad[MAXN];
int used[MAXN];
int deep[MAXN];
int opt[MAXN];
int bal[MAXN];
bool ok = false;
mt19937 as(272727);
void dfs(int u) {
used[u] = 1;
for (auto h : g[u]) {
if (used[h] == 0) {
dfs(h);
} else if (used[h] == 2) {
ok = false;
}
}
used[u] = 2;
}
bool check(int u) {
fill(used, used + n + 1, 0);
ok = true;
dfs(u);
return ok;
}
int dfs1(int u) {
used[u] = 1;
opt[u] = u;
for (auto v : g[u]) {
if (used[v] == 0) {
deep[v] = deep[u] + 1;
bal[u] += dfs1(v);
if (deep[opt[v]] < deep[opt[u]]) {
opt[u] = opt[v];
}
} else {
bal[u]++;
bal[v]--;
if (deep[v] < deep[opt[u]]) {
opt[u] = v;
}
}
}
if (bal[u] > 1) {
bad[u] = true;
}
return bal[u];
}
void dfs2(int u) {
used[u] = 1;
if (!bad[u] && bad[opt[u]]) {
bad[u] = true;
}
for (auto v : g[u]) {
if (used[v] == 0) {
dfs2(v);
}
}
}
void solve() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
g[a].push_back(b);
}
int id = -1;
for (int it = 0; it < 100; it++) {
int u = as() % n + 1;
if (check(u)) {
id = u;
break;
}
}
if (id == -1) {
cout << -1 << '\n';
} else {
fill(used, used + n + 1, 0);
dfs1(id);
fill(used, used + n + 1, 0);
dfs2(id);
vector<int> ans;
for (int i = 1; i <= n; i++) {
if (!bad[i]) {
ans.push_back(i);
}
}
if ((int)(ans).size() * 5 >= n) {
for (auto x : ans) {
cout << x << ' ';
}
cout << '\n';
} else {
cout << -1 << '\n';
}
}
for (int i = 0; i <= n; i++) {
g[i].clear();
deep[i] = 0;
opt[i] = 0;
bad[i] = false;
used[i] = 0;
bal[i] = 0;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
vector<int> g[N], tree[N], link[N];
int r[N], c[N];
int ptr = 1;
int add[N];
bool dfs1(int u) {
c[u] = 1;
r[u] = ptr;
for (int v : g[u]) {
if (r[v] < r[u]) {
tree[u].push_back(v);
if (!dfs1(v)) return 0;
} else if (c[v] == 2) {
return 0;
} else {
link[u].push_back(v);
--add[v];
++add[u];
}
}
c[u] = 2;
return 1;
}
int h[N], up[N];
int getup(int u, int v) {
if (u == -1) return v;
if (v == -1) return u;
if (h[u] < h[v])
return u;
else
return v;
}
void dfs2(int u) {
up[u] = -1;
for (auto e : link[u]) up[u] = getup(up[u], e);
for (int v : tree[u]) {
h[v] = h[u] + 1;
dfs2(v);
add[u] += add[v];
up[u] = getup(up[u], up[v]);
}
}
bool bad[N];
void dfs3(int u, vector<int> &ans) {
if (h[u]) {
bad[u] = (add[u] > 1) || bad[up[u]];
}
if (!bad[u]) ans.push_back(u);
for (int v : tree[u]) dfs3(v, ans);
}
mt19937 rnd(2007);
void solve() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; ++i) {
g[i].clear();
tree[i].clear();
link[i].clear();
add[i] = 0;
bad[i] = 0;
}
for (int i = 0; i < m; ++i) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
}
vector<int> ord;
for (int i = 1; i <= n; ++i) ord.push_back(i);
shuffle(ord.begin(), ord.end(), rnd);
int root = -1;
for (int p = 0; p < min(100, n); ++p) {
for (int i = 1; i <= n; ++i) {
tree[i].clear();
link[i].clear();
add[i] = 0;
bad[i] = 0;
}
int u = ord[p];
++ptr;
if (dfs1(u)) {
root = u;
break;
}
}
if (root == -1) {
cout << -1 << endl;
return;
}
vector<int> ans;
h[root] = 0;
dfs2(root);
dfs3(root, ans);
if (ans.size() * 5 < n) {
cout << -1 << endl;
return;
}
sort(ans.begin(), ans.end());
for (auto e : ans) cout << e << ' ';
cout << endl;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
solve();
}
}
|
#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];
bool flag;
mt19937 rng(chrono::high_resolution_clock::now().time_since_epoch().count());
inline priority_queue<pair<int, int> > dfs(int x, int TIME) {
priority_queue<pair<int, int> > temp;
st[x] = ++dfn;
en[x] = n;
vis[x] = TIME;
for (auto ch : g[x]) {
if (vis[ch] == TIME) {
if (en[ch] >= st[x] && st[x] > st[ch])
temp.push({dep[ch], ch});
else {
flag = false;
}
} else {
dep[ch] = dep[x] + 1;
priority_queue<pair<int, int> > temp1 = dfs(ch, TIME);
while (!temp1.empty()) {
if (temp1.top().first < dep[x]) temp.push(temp1.top());
temp1.pop();
}
}
}
while (temp.size() > 2) temp.pop();
if (temp.size() == 1) {
uplink[x] = temp.top().second;
} else {
uplink[x] = -1;
intr[x] = 0;
}
en[x] = dfn;
return temp;
}
int sum;
inline void dfs1(int x) {
if (dep[x] == 1) {
intr[x] = 1;
sum++;
} 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;
flag = true;
dfs(x, N);
if (flag) {
sum = 0;
dfs1(x);
}
return flag;
}
int main() {
srand((unsigned)time(NULL));
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;
if (n <= 100) {
for (int i = 1; i <= n; i++) {
if (tst(i)) {
found = true;
break;
}
}
} else {
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;
const int MAX = 1 << 18;
const int ITER = 60;
vector<int> V[MAX];
int good[MAX];
int n, m;
int col[MAX];
bool dfs(int node) {
col[node] = 1;
for (auto it : V[node]) {
if (col[it] == 0) {
if (!dfs(it)) return false;
} else if (col[it] == 2)
return false;
}
col[node] = 2;
return true;
}
bool check(int root) {
for (int i = (0); i < (n); i++) col[i] = 0;
if (!dfs(root)) return false;
for (int i = (0); i < (n); i++)
if (!col[i]) return false;
return true;
}
pair<int, int> links[MAX];
int dub[MAX];
void dfs_calc(int node) {
col[node] = 1;
for (auto it : V[node]) {
if (col[it] == 0) {
dub[it] = dub[node] + 1;
dfs_calc(it);
vector<int> T = vector<int>{links[node].first, links[node].second,
links[it].first, links[it].second};
sort(T.begin(), T.end(), [](int a, int b) {
if (a == MAX || b == MAX) return a < b;
return dub[a] < dub[b];
});
if (T[0] < n && dub[T[0]] < dub[node]) links[node].first = T[0];
if (T[1] < n && dub[T[1]] < dub[node]) links[node].second = T[1];
} else {
assert(col[it] == 1);
vector<int> T = vector<int>{links[node].first, links[node].second, it};
sort(T.begin(), T.end(), [](int a, int b) {
if (a == MAX || b == MAX) return a < b;
return dub[a] < dub[b];
});
if (T[0] < n && dub[T[0]] < dub[node]) links[node].first = T[0];
if (T[1] < n && dub[T[1]] < dub[node]) links[node].second = T[1];
}
}
col[node] = 2;
}
int per[MAX];
void calc(int root) {
for (int i = (0); i < (n); i++) {
col[i] = 0;
links[i] = pair<int, int>(MAX, MAX);
}
dub[root] = 0;
dfs_calc(root);
for (int i = (0); i < (n); i++) per[i] = i;
good[root] = 1;
sort(per, per + n, [](int a, int b) { return dub[a] < dub[b]; });
for (int iii = (1); iii < (n); iii++) {
int i = per[iii];
if (links[i].second == MAX && links[i].first < n && good[links[i].first])
good[i] = 1;
}
good[root] = 1;
}
int main() {
srand(1341);
int tt;
scanf("%d", &tt);
while (tt--) {
scanf("%d%d", &n, &m);
for (int i = (0); i < (m); i++) {
int a, b;
scanf("%d%d", &a, &b);
a--;
b--;
V[a].push_back(b);
}
if (m < n - 1) {
for (int i = (0); i < (n); i++) V[i].clear();
printf("-1\n");
continue;
}
int yes = 0;
for (int i = (0); i < (n); i++) good[i] = 0;
for (int i = (0); i < (ITER); i++) {
int root = (int)(((((long long)rand()) << 15) + rand()) % n);
if (check(root)) {
calc(root);
if (accumulate(good, good + n, 0) * 5 < n)
printf("-1");
else
for (int j = (0); j < (n); j++)
if (good[j]) printf("%d ", j + 1);
printf("\n");
yes = 1;
break;
}
}
for (int i = (0); i < (n); i++) V[i].clear();
if (!yes) printf("-1\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 7;
bool fl[N];
vector<int> v[N];
int t, n, m, tot, p[N], fa[N], da[N], db[N], vac[N], vat[N], dep[N];
inline int read() {
int num = 0;
char t = '+', g = getchar();
while (g < 48 || 57 < g) t = g, g = getchar();
while (47 < g && g < 58)
num = (num << 1) + (num << 3) + g - 48, g = getchar();
if (t == '-') return -num;
return num;
}
inline void dfs(int u) {
da[u] = db[u] = ++tot;
for (int i = 0; i < v[u].size(); i++) {
int x = v[u][i];
if (!fa[x]) fa[x] = u, dep[x] = dep[u] + 1, dfs(x), db[u] = db[x];
}
}
inline void dft(int u) {
vat[u] = -1;
for (int i = 0; i < v[u].size(); i++) {
int x = v[u][i];
if (fa[x] == u) {
dft(x), vac[u] += vac[x];
if (vat[u] == -1)
vat[u] = vat[x];
else if (dep[vat[x]] <= dep[vat[u]])
vat[u] = vat[x];
} else if (vat[u] == -1)
vat[u] = v[u][i];
else if (dep[v[u][i]] <= dep[vat[u]])
vat[u] = v[u][i];
}
if (vac[u] >= 2) fl[u] = 0;
}
inline void dfq(int u) {
if (vac[u] <= 1) fl[u] |= fl[vat[u]];
for (int i = 0; i < v[u].size(); i++) {
int x = v[u][i];
if (fa[x] == u) dfq(x);
}
}
inline bool solve(int u) {
tot = 0, dep[u] = 0;
for (int i = 1; i <= n; i++) fa[i] = 0, fl[i] = 0, vac[i] = 0;
fa[u] = -1, dfs(u);
for (int i = 1; i <= n; i++)
for (int c = 0; c < v[i].size(); c++) {
int x = v[i][c];
if ((!(da[x] <= da[i] && da[i] <= db[x])) && (fa[x] != i)) return false;
if (fa[x] != i) {
vac[i]++, vac[x]--;
}
}
fl[u] = 1, dft(u), dfq(u);
int cnt = 0;
for (int i = 1; i <= n; i++)
if (fl[i]) cnt++;
if (cnt <= ((n - 1) / 5))
puts("-1");
else {
for (int i = 1; i <= n; i++)
if (fl[i]) printf("%d ", i);
putchar('\n');
}
return true;
}
int main() {
srand(19260817), t = read();
int g = 0;
while (t--) {
n = read(), m = read(), g++;
int a, b;
bool fs = 0;
for (int i = 1; i <= n; i++) v[i].resize(0), p[i] = i;
for (int i = 1; i <= m; i++) {
a = read(), b = read(), v[a].push_back(b);
}
random_shuffle(p + 1, p + n + 1);
for (int i = 1; i <= min(100, n); i++)
if (solve(p[i])) {
fs = 1;
break;
}
if (!fs) puts("-1");
}
}
|
#include <bits/stdc++.h>
using namespace std;
void file(string s) {
freopen((s + ".in").c_str(), "r", stdin);
freopen((s + ".out").c_str(), "w", stdout);
}
template <typename Tp>
void read(Tp &x) {
int fh = 1;
char c = getchar();
x = 0;
while (c > '9' || c < '0') {
if (c == '-') {
fh = -1;
}
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 1) + (x << 3) + (c & 15);
c = getchar();
}
x *= fh;
}
int n, m;
vector<int> G[1000005];
namespace Tarjan {
int dfn[1000005], ndfn[1000005], low[1000005], ins[1000005], tot;
stack<int> stk;
int FLG;
int l2[1000005];
void dfs0(int x) {
dfn[x] = low[x] = ++tot;
ins[x] = 1;
stk.push(x);
for (auto y : G[x]) {
if (dfn[y]) {
if (ins[y])
low[x] = min(low[x], dfn[y]);
else
FLG = -1;
} else {
dfs0(y);
low[x] = min(low[x], low[y]);
}
}
ins[x] = 0;
stk.pop();
}
void dfs(int x) {
dfn[x] = low[x] = l2[x] = ++tot;
ndfn[tot] = x;
ins[x] = 1;
stk.push(x);
for (auto y : G[x]) {
if (dfn[y]) {
if (ins[y]) {
if (dfn[y] < low[x]) {
swap(low[x], l2[x]);
low[x] = dfn[y];
} else {
if (dfn[y] < l2[x]) l2[x] = dfn[y];
}
}
} else {
dfs(y);
if (low[y] < low[x]) {
swap(low[x], l2[x]);
low[x] = low[y];
} else {
if (low[y] < l2[x]) l2[x] = low[y];
}
if (l2[y] < low[x]) {
swap(low[x], l2[x]);
low[x] = l2[y];
} else {
if (l2[y] < l2[x]) l2[x] = l2[y];
}
}
}
if (dfn[x] == low[x]) {
int y = stk.top();
stk.pop();
ins[y] = 0;
while (y != x) {
y = stk.top();
stk.pop();
ins[y] = 0;
}
}
}
bool chk_good(int RT, int tp = 0) {
for (int i = 1; i <= n; ++i) dfn[i] = low[i] = l2[i] = ins[i] = 0;
tot = 0;
FLG = 0;
dfs0(RT);
if (tot != n || FLG == -1) return 0;
if (tp) {
for (int i = 1; i <= n; ++i) dfn[i] = low[i] = l2[i] = ins[i] = 0;
tot = 0;
FLG = 0;
dfs(RT);
}
return 1;
}
} // namespace Tarjan
int ans[1000005];
int ta[1000005];
signed main() {
srand(time(0));
int CasT;
read(CasT);
while (CasT--) {
read(n);
read(m);
for (int i = 1; i <= n; ++i) ans[i] = 0, G[i].clear();
for (int i = 1, u, v; i <= m; ++i) {
read(u);
read(v);
G[u].push_back(v);
}
for (int i = 1; i <= n; ++i) ta[i] = i;
random_shuffle(ta + 1, ta + n + 1);
int RT = -1;
for (int i = 1; i <= n && i <= 100; ++i) {
if (Tarjan::chk_good(i)) RT = i;
}
random_shuffle(ta + 1, ta + n + 1);
for (int i = n; i >= 1 && i >= n - 100; --i) {
if (Tarjan::chk_good(i)) RT = i;
}
if (n >= 104 && Tarjan::chk_good(104)) RT = 104;
if (n >= 80000 && Tarjan::chk_good(80000)) RT = 80000;
if (RT == -1) {
puts("-1");
continue;
}
Tarjan::chk_good(RT, 1);
ans[RT] = 1;
for (int i = 2; i <= Tarjan::tot; ++i) {
int x = Tarjan::ndfn[i];
if (Tarjan::dfn[x] == Tarjan::low[x])
ans[x] = -1;
else {
if (Tarjan::dfn[x] != Tarjan::l2[x])
ans[x] = -1;
else
ans[x] = ans[Tarjan::ndfn[Tarjan::low[x]]];
}
}
int cnt = 0;
for (int i = 1; i <= n; ++i)
if (ans[i] == 1) ++cnt;
if (cnt * 5 >= n) {
for (int i = 1; i <= n; ++i) {
if (ans[i] == 1) printf("%d ", i);
}
puts("");
} else {
puts("-1");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
vector<bool> vs, bs;
vector<int> en, ex, lev, ror, go, wa;
int vos;
bool ye;
int dord;
vector<vector<int> > g, h;
void dfa(int u) {
bs[u] = true;
en[u] = dord;
dord++;
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (vs[v]) {
if (!bs[v]) {
ye = false;
}
} else {
vos++;
vs[v] = true;
lev[v] = lev[u] + 1;
dfa(v);
}
}
bs[u] = false;
ex[u] = dord;
dord++;
}
void hh(int u) {
for (int i = 0; i < h[u].size(); i++) {
int v = h[u][i];
if (!vs[v]) {
vs[v] = true;
hh(v);
}
}
}
int dfb(int u) {
int mu = -1, ma = 1e9;
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (lev[v] < lev[u]) {
go[en[v]]++;
go[ex[u] - 1]--;
if (lev[v] < ma) {
mu = v;
ma = lev[v];
}
} else {
int ok = dfb(v);
if (ok != -1 && lev[ok] < ma) {
ma = lev[ok];
mu = ok;
}
}
}
if (mu != -1 && lev[mu] < lev[u]) {
wa[u] = mu;
} else {
wa[u] = -1;
}
return mu;
}
void dfc(int u, int r) {
if (wa[u] >= 0) {
vs[u] = (vs[u] && vs[wa[u]]);
} else {
vs[u] = 0;
}
if (u == r) {
vs[u] = true;
}
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (lev[v] > lev[u]) {
dfc(v, r);
}
}
}
bool det(int u) {
dord = 0;
vos = 1;
vs.assign(g.size(), 0);
vs[u] = true;
ye = true;
lev[u] = 0;
dfa(u);
if (vos < g.size()) {
return false;
}
return ye;
}
int main() {
int N;
cin >> N;
while (N--) {
int n, m;
cin >> n >> m;
g.assign(n, vector<int>());
h.assign(n, vector<int>());
lev.assign(g.size(), 0);
en.assign(g.size(), 0);
ex.assign(g.size(), 0);
vs.assign(g.size(), 0);
bs.assign(g.size(), 0);
go.assign(g.size(), 0);
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
g[a].push_back(b);
h[b].push_back(a);
}
ror.clear();
for (int i = 0; i < n; i++) {
ror.push_back(i);
}
shuffle(ror.begin(), ror.end(), rng);
int te = min(70, int(ror.size()));
int ro = -1;
for (int i = 0; i < te; i++) {
if (det(ror[i])) {
ro = ror[i];
break;
}
}
vector<int> ans;
if (ro != -1) {
go.assign(dord, 0);
vs.assign(n, 0);
wa.assign(n, 0);
hh(ro);
dfb(ro);
int rs = 0;
for (int i = 0; i < dord; i++) {
int te = rs + go[i];
go[i] = rs;
rs = te;
}
for (int i = 0; i < n; i++) {
if (go[en[i]] - go[ex[i]] != 1) {
vs[i] = false;
}
}
vs[ro] = 1;
dfc(ro, ro);
vs[ro] = 1;
for (int i = 0; i < n; i++) {
if (vs[i]) {
ans.push_back(i);
}
}
}
if (ans.size() * 5 < n) {
cout << -1 << '\n';
} else {
for (int i = 0; i < ans.size(); i++) {
if (i > 0) {
cout << " ";
}
cout << ans[i] + 1;
}
cout << '\n';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int test, n, m, x, y, rt, pa[111111], beg[111111], en[111111], cnt, ff[111111];
vector<int> g[111111], ng[111111];
vector<int> to_add[111111], ans;
bool dp[111111];
multiset<int> s[111111];
int Get(int x) { return ((rand() << 10) + rand()) % x + 1; }
void dfs(int i, int fa) {
beg[i] = ++cnt;
pa[i] = fa;
for (int j = 0; j < g[i].size(); j++) {
int to = g[i][j];
if (beg[to]) continue;
dfs(to, i);
}
en[i] = cnt;
}
bool check(int rt) {
cnt = 0;
for (int i = 1; i <= n; i++) beg[i] = pa[i] = 0;
dfs(rt, 0);
for (int i = 1; i <= n; i++) {
for (int j = 0; j < g[i].size(); j++) {
int to = g[i][j];
if (pa[to] == i) continue;
if (beg[to] <= beg[i] && en[to] >= en[i])
;
else
return 0;
}
}
return 1;
}
void dft(int i) {
int mxp = -1;
for (int j = 0; j < ng[i].size(); j++) {
int to = ng[i][j];
dft(to);
if (mxp == -1 || (int)s[to].size() > (int)s[mxp].size()) mxp = to;
}
if (mxp != -1) swap(s[i], s[mxp]);
for (int j = 0; j < ng[i].size(); j++) {
int to = ng[i][j];
if (to == mxp) continue;
for (multiset<int>::iterator it = s[to].begin(); it != s[to].end(); it++) {
s[i].insert(*it);
}
}
for (int j = 0; j < to_add[i].size(); j++) s[i].insert(to_add[i][j]);
while (s[i].find(i) != s[i].end()) {
s[i].erase(s[i].find(i));
}
if (s[i].size() > 1)
ff[i] = 0;
else if (s[i].size() == 1)
ff[i] = *s[i].begin();
}
void calc(int i) {
if (!~ff[i]) {
dp[i] = 1;
ans.push_back(i);
} else if (ff[i]) {
dp[i] = dp[ff[i]];
if (dp[i]) ans.push_back(i);
} else
dp[i] = 0;
for (int j = 0; j < ng[i].size(); j++) {
int to = ng[i][j];
calc(to);
}
}
int main() {
srand(993217);
scanf("%d", &test);
while (test--) {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) g[i].clear();
for (int i = 1; i <= m; i++) {
scanf("%d%d", &x, &y);
g[x].push_back(y);
}
rt = 0;
for (int i = 1; i <= 100; i++) {
x = Get(n);
if (check(x)) {
rt = x;
break;
}
}
if (!rt) {
printf("-1\n");
continue;
}
ans.clear();
for (int i = 1; i <= n; i++) {
ng[i].clear();
to_add[i].clear();
s[i].clear();
}
for (int i = 1; i <= n; i++) {
if (i != rt) ng[pa[i]].push_back(i);
for (int j = 0; j < g[i].size(); j++) {
int to = g[i][j];
if (pa[to] == i) continue;
to_add[i].push_back(to);
}
}
for (int i = 1; i <= n; i++) ff[i] = -1;
dft(rt);
for (int i = 1; i <= n; i++) dp[i] = 0;
calc(rt);
if ((int)ans.size() * 5 < n) {
printf("-1\n");
continue;
}
sort(ans.begin(), ans.end());
for (int i = 0; i < ans.size(); i++) printf("%d ", ans[i]);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 6;
mt19937 rnd(0);
int dfn[N], low[N], id[N], vis[N], dc, cnt;
vector<int> G[N];
bool dfs1(int u) {
dfn[u] = low[u] = ++dc, id[dc] = u, vis[u] = -1, ++cnt;
for (int i = 0, iend = G[u].size(); i < iend; ++i) {
int v = G[u][i];
if (!dfn[v]) {
if (dfs1(v)) return true;
low[u] = min(low[u], low[v]);
} else if (vis[v] == -1)
low[u] = min(low[u], dfn[v]);
else
return true;
}
vis[u] = 1;
return false;
}
int tg[N];
void dfs2(int u) {
for (int i = 0, iend = G[u].size(); i < iend; ++i) {
int v = G[u][i];
if (dfn[v] > dfn[u]) dfs2(v), tg[u] += tg[v];
}
}
int k, ok[N];
void solve(int u) {
if (ok[u]) ++k;
for (int i = 0, iend = G[u].size(); i < iend; ++i) {
int v = G[u][i];
if (dfn[v] > dfn[u]) {
if (tg[v] >= 2)
ok[v] = false, solve(v);
else if (!tg[v])
continue;
else
ok[v] = ok[id[low[v]]], solve(v);
}
}
}
int main() {
int T;
scanf("%d", &T);
while (T--) {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) G[i].clear(), tg[i] = 0;
for (int i = 1; i <= m; ++i) {
int u, v;
scanf("%d%d", &u, &v);
G[u].push_back(v);
}
int rt = 0;
for (int t = 1; t <= 100; ++t) {
int u = rnd() % n + 1;
for (int i = 1; i <= n; ++i) dfn[i] = 0;
dc = cnt = 0;
if (!dfs1(u) && cnt == n) {
rt = u;
break;
}
}
for (int u = 1; u <= n; ++u)
for (int i = 0, iend = G[u].size(); i < iend; ++i)
if (dfn[G[u][i]] < dfn[u]) ++tg[u], --tg[G[u][i]];
k = 0;
dfs2(rt), ok[rt] = true, solve(rt);
if (!rt || 5 * k < n)
puts("-1");
else {
for (int i = 1; i <= n; ++i)
if (ok[i]) printf("%d ", i);
putchar('\n');
}
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.