text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:268435456")
using namespace std;
template <typename T1, typename T2>
istream& operator>>(istream& in, pair<T1, T2>& t) {
return in >> t.first >> t.second;
}
template <typename T1, typename T2>
ostream& operator<<(ostream& out, pair<T1, T2>& t) {
return out << t.first << " " << t.second;
}
template <typename T>
istream& operator>>(istream& in, vector<T>& t) {
for (long long i = 0; i < t.size(); i++) in >> t[i];
return in;
}
template <typename T>
ostream& operator<<(ostream& out, vector<T>& t) {
for (long long i = 0; i < t.size(); i++) out << t[i] << " ";
return out;
}
struct G {
vector<long long> to, rev;
long long stat[2] = {-1, -1};
long long left[2] = {-1, -1};
long long p[2] = {-1, -1};
};
vector<G> g;
void bfs() {
queue<pair<long long, long long> > que;
for (long long i = 0; i < g.size(); i++) {
g[i].left[0] = g[i].left[1] = g[i].to.size();
if (g[i].to.size() == 0) {
g[i].stat[0] = 0;
g[i].stat[1] = 0;
que.push({i, 0});
que.push({i, 1});
}
}
while (!que.empty()) {
long long v = que.front().first;
long long who = que.front().second;
que.pop();
long long stat = g[v].stat[who];
for (long long u : g[v].rev) {
if (g[u].stat[!who] != -1) continue;
if (who == 1) {
if (stat == 1) {
g[u].stat[!who] = 0;
g[u].p[!who] = v;
que.push({u, !who});
} else {
g[u].left[!who]--;
if (g[u].left[!who] == 0) {
g[u].stat[!who] = 1;
g[u].p[!who] = v;
que.push({u, !who});
}
}
} else {
if (stat == 0) {
g[u].stat[!who] = 1;
g[u].p[!who] = v;
que.push({u, !who});
} else {
g[u].left[!who]--;
if (g[u].left[!who] == 0) {
g[u].stat[!who] = 0;
g[u].p[!who] = v;
que.push({u, !who});
}
}
}
}
}
}
void res(long long v, long long who) {
if (v == -1) return;
cout << v + 1 << " ";
res(g[v].p[who], !who);
}
signed main() {
long long n, m;
cin >> n >> m;
g.resize(n);
for (long long i = 0; i < n; i++) {
long long sz;
scanf("%lld", &sz);
for (long long j = 0; j < sz; j++) {
long long to;
scanf("%lld", &to);
to--;
g[i].to.push_back(to);
g[to].rev.push_back(i);
}
}
bfs();
long long s;
cin >> s;
s--;
if (g[s].stat[1] == 1) {
puts("Win");
res(s, 1);
cout << endl;
} else if (g[s].stat[1] == -1) {
puts("Draw");
} else if (g[s].stat[1] == 0) {
puts("Lose");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
struct point {
int to;
int nxt;
} edge[maxn];
int n, m, k, tot, sta, is_draw;
int head[maxn], vis[maxn][2], out[maxn];
vector<int> st;
inline void add(int u, int v) {
tot++;
edge[tot].nxt = head[u];
edge[tot].to = v;
head[u] = tot;
}
inline void dfs(int x, int col) {
if (vis[x][col]) return;
st.push_back(x);
vis[x][col] = 1;
if (!out[x]) {
if (col) {
printf("Win\n");
int mm = st.size();
for (int i = 0; i < mm; i++) printf("%d ", st[i]);
exit(0);
}
}
for (int i = head[x]; i; i = edge[i].nxt) {
int v = edge[i].to;
if (vis[v][!col] == 1) is_draw = 1;
dfs(v, !col);
}
st.pop_back();
vis[x][col] = 2;
}
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> k;
for (int j = 1; j <= k; j++) {
int u;
cin >> u;
add(i, u);
out[i]++;
}
}
cin >> sta;
dfs(sta, 0);
if (is_draw)
printf("Draw");
else
printf("Lose");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 2e5 + 5;
int vs[MX][4], path[MX], s;
vector<int> g[MX];
void go(int u, int win, int id) {
if (g[u].size() == 0) {
if (win) {
cout << "Win" << endl;
for (int i = 0; i < id; i++) cout << path[i] << " ";
cout << u << endl;
exit(0);
}
}
if (vs[u][win]) return;
vs[u][win] = 1;
path[id] = u;
for (auto v : g[u]) {
{ go(v, win ^ 1, id + 1); }
}
}
int visit[MX];
void cycle(int u) {
if (visit[u] == 1) {
cout << "Draw" << endl;
exit(0);
}
visit[u] = 1;
for (auto v : g[u]) {
cycle(v);
}
visit[u] = 0;
}
int main() {
int m, n, c, x;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> c;
for (int j = 0; j < c; j++) {
cin >> x;
g[i].push_back(x);
}
}
cin >> s;
go(s, 0, 0);
cycle(s);
cout << "Lose" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
long long nod, d;
node(long long a, long long b) {
nod = a;
d = b;
}
bool operator<(const node &p) const { return p.d < d; }
};
long long Set(long long n, long long pos) { return n = n | (1LL << pos); }
long long reset(long long n, long long pos) { return n = n & ~(1LL << pos); }
bool check(long long n, long long pos) { return (bool)(n & (1LL << pos)); }
long long mul(long long a, long long b) {
long long c;
c = (a % 1000000007 * b % 1000000007) % 1000000007;
return c;
}
long long add(long long a, long long b) {
long long c;
c = (a % 1000000007 + b % 1000000007) % 1000000007;
return c;
}
long long sub(long long a, long long b) {
long long c;
c = ((a % 1000000007 - b % 1000000007) % 1000000007 + 1000000007) %
1000000007;
return c;
}
long long power(long long x, long long y) {
long long res = 1;
x = x;
while (y > 0) {
if (y & 1) res = (res * x);
y = y >> 1;
x = (x * x);
}
return res;
}
long long s2, s1, t2, t1;
long long egcd(long long a, long long b) {
long long temp;
if (a % b == 0) {
return s1;
}
temp = s2 - (a / b) * s1;
s2 = s1;
s1 = temp;
temp = t2 - (a / b) * t1;
t2 = t1;
t1 = temp;
return egcd(b, a % b);
}
long long exgcd(long long x, long long y, long long &a, long long &b) {
int flag = 0;
long long t, la = 1, lb = 0, ra = 0, rb = 1;
while (x % y) {
if (flag == 0)
la -= x / y * ra, lb -= x / y * rb;
else
ra -= x / y * la, rb -= x / y * lb;
t = x, x = y, y = t % y;
flag = 1 - flag;
}
if (flag == 0)
a = ra, b = rb;
else
a = la, b = lb;
return y;
}
long long n, m, s;
vector<long long> graph[200005];
long long vis[200005][2];
long long win[200005][2];
pair<long long, long long> win_asche[200005][2];
void dfs(long long src, long long kar_chal) {
if (vis[src][kar_chal] == 2) return;
if (graph[src].size() == 0) {
vis[src][kar_chal] = 2;
if (kar_chal == 0)
win[src][kar_chal] = 0;
else
win[src][kar_chal] = 1;
return;
}
vis[src][kar_chal] = 1;
win[src][kar_chal] = 0;
for (long long i = 0; i < graph[src].size(); i++) {
long long adj = graph[src][i];
if (vis[adj][kar_chal ^ 1LL] == 1) {
if (win[src][kar_chal] == 0) win[src][kar_chal] = 2;
continue;
}
dfs(adj, kar_chal ^ 1LL);
if (win[adj][kar_chal ^ 1LL] == 1 && win[src][kar_chal] != 1) {
win[src][kar_chal] = 1;
win_asche[src][kar_chal] =
pair<long long, long long>(adj, kar_chal ^ 1LL);
} else if (win[adj][kar_chal ^ 1LL] == 2 && win[src][kar_chal] == 0) {
win[src][kar_chal] = 2;
}
}
vis[src][kar_chal] = 2;
}
void dfs2(long long src, long long kar_chal) {
printf("%lld ", src);
if (win_asche[src][kar_chal].first != -1) {
dfs2(win_asche[src][kar_chal].first, win_asche[src][kar_chal].second);
}
}
int main() {
memset((win_asche), (-1), sizeof(win_asche));
scanf("%lld", &n);
scanf("%lld", &m);
for (long long i = 1; i <= n; i++) {
long long out;
scanf("%lld", &out);
for (long long j = 1; j <= out; j++) {
long long nod;
scanf("%lld", &nod);
graph[i].push_back(nod);
}
}
scanf("%lld", &s);
dfs(s, 0);
if (win[s][0] == 0) {
printf("Lose\n");
return 0;
} else if (win[s][0] == 2) {
printf("Draw\n");
return 0;
} else if (win[s][0] == 1) {
printf("Win\n");
dfs2(s, 0);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
stack<int> st;
vector<int> v[100005], rv[100005], ans;
int nodes, vis[100005], dp[100005][2], par[100005];
bool chk, dpv[100005][2];
void dfs(int n) {
nodes++;
vis[n] = 1;
for (int i = 0; i < v[n].size(); i = i + 1) {
if (vis[v[n][i]] != 1) dfs(v[n][i]);
}
if (v[n].size() == 0) chk = 1;
st.push(n);
}
void dfs1(int n, int p) {
par[n] = p;
vis[n] = 2;
for (int i = 0; i < rv[n].size(); i = i + 1) {
if (vis[rv[n][i]] == 1) {
dfs1(rv[n][i], p);
}
}
}
int dfs2(int n, bool c) {
if (dpv[n][c]) return dp[n][c];
dpv[n][c] = 1;
dp[n][c] = 1000000000;
if (v[n].size() == 0) {
if (c)
dp[n][1] = 1;
else
dp[n][0] = 1000000000;
}
for (int i = 0; i < v[n].size(); i = i + 1) {
if (par[n] == par[v[n][i]]) continue;
dp[n][c] = min(dp[n][c], 1 + dfs2(v[n][i], !c));
}
for (int i = 0; i < v[n].size(); i = i + 1) {
if (par[n] != par[v[n][i]]) continue;
dp[n][c] = min(dp[n][c], 1 + dfs2(v[n][i], !c));
}
return dp[n][c];
}
void path(int n, bool c) {
ans.push_back(n);
for (int i = 0; i < v[n].size(); i = i + 1) {
if (dp[v[n][i]][!c] + 1 == dp[n][c]) {
path(v[n][i], !c);
return;
}
}
}
int main() {
bool draw;
int n, m, c, a, s;
scanf("%d %d", &n, &m);
for (int i = 1; i < n + 1; i = i + 1) {
scanf("%d", &c);
while (c--) {
scanf("%d", &a);
v[i].push_back(a);
rv[a].push_back(i);
}
}
scanf("%d", &s);
dfs(s);
if (!chk) {
printf("Draw\n");
return 0;
}
c = 1;
while (!st.empty()) {
a = st.top();
st.pop();
if (vis[a] == 2) continue;
dfs1(a, c);
c++;
}
if (nodes > (c - 1))
draw = 1;
else
draw = 0;
if (dfs2(s, 0) < 1000000000) {
path(s, 0);
printf("Win\n");
for (int i = 0; i < ans.size(); i = i + 1) printf("%d ", ans[i]);
return 0;
} else {
if (draw) {
printf("Draw\n");
return 0;
} else {
printf("Lose\n");
return 0;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long powm(long long base, long long exp, long long mod = 998244353) {
base %= mod;
long long ans = 1;
while (exp) {
if (exp & 1LL) ans = (ans * base) % mod;
exp >>= 1LL, base = (base * base) % mod;
}
return ans;
}
vector<long long> ed[100005];
int a[100005];
int v[100005][2];
int fd = 0;
stack<long long> ans;
int dfs(int x, int curr) {
if (v[x][curr]) {
if (v[x][curr] == 1) {
fd = 1;
}
return 0;
}
v[x][curr] = 1;
if (ed[x].size() == 0) {
v[x][curr] = 2;
if (curr == 2) {
ans.push(x);
return 1;
} else
return 0;
}
for (auto it : ed[x]) {
int t = dfs(it, 3 - curr);
if (t == 1) {
ans.push(x);
return 1;
}
}
v[x][curr] = 2;
return 0;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, m;
cin >> n >> m;
for (long long i = 1; i <= n; i++) {
long long c;
cin >> c;
for (long long j = 0; j < c; j++) {
long long a;
cin >> a;
ed[i].push_back(a);
}
}
int s;
cin >> s;
bool t = dfs(s, 1);
if (t) {
cout << "Win" << '\n';
while (!ans.empty()) {
cout << ans.top() << " ";
ans.pop();
}
} else if (fd)
cout << "Draw" << '\n';
else
cout << "Lose" << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100007;
struct edge {
int c;
int *p;
} e[maxn];
int vis[maxn][3];
int color[maxn];
bool rch[maxn];
bool is_DAG = 1;
void dfs(int u, int st) {
for (int i = 1; i <= e[u].c; i++) {
if (!vis[e[u].p[i]][(st + 1) % 2]) {
vis[e[u].p[i]][(st + 1) % 2] = u;
dfs(e[u].p[i], st + 1);
}
}
}
void find_rch(int u) {
rch[u] = 1;
for (int i = 1; i <= e[u].c; ++i) {
if (!rch[e[u].p[i]]) {
find_rch(e[u].p[i]);
}
}
}
void coloring(int u) {
color[u] = -1;
for (int i = 1; i <= e[u].c; ++i) {
if (color[e[u].p[i]] == -1) {
is_DAG = false;
} else {
if (color[e[u].p[i]] == 0) coloring(e[u].p[i]);
}
}
color[u] = 1;
}
int main() {
memset(color, 0, sizeof(color));
memset(rch, 0, sizeof(rch));
memset(vis, 0, sizeof(vis));
int n, m, s;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) {
int c;
scanf("%d", &c);
e[i].c = c;
e[i].p = new int[c + 1];
for (int j = 1; j <= c; ++j) {
scanf("%d", &e[i].p[j]);
}
}
scanf("%d", &s);
vis[s][0] = -1;
dfs(s, 0);
bool fg = false;
for (int i = 1; i <= n; ++i) {
if (!e[i].c) {
fg = 1;
if (vis[i][1]) {
printf("Win\n");
int u = i;
int z = 1, ans[maxn], cnt = 0;
while (u != -1) {
ans[++cnt] = u;
u = vis[u][z];
z = 1 - z;
}
for (int i = cnt; i > 0; --i) {
printf("%d ", ans[i]);
}
return 0;
}
}
}
if (fg) {
find_rch(s);
for (int i = 1; i <= n; ++i) {
if (rch[i] && !color[i]) {
coloring(i);
}
}
if (!is_DAG) {
printf("Draw");
} else {
printf("Lose");
}
} else {
printf("Draw");
}
return 0;
}
|
#include <bits/stdc++.h>
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3fll;
using namespace std;
const double eps = 1e-6;
const long long mod = 1e9 + 7;
const int maxn = 1e5 + 100;
const int maxe = 1e6 + 100;
struct node {
int y, Next;
} data[maxn << 1];
bool dp[maxn][2], cir;
int h[maxn], num, vis[maxn][2], out[maxn], Next[maxn][2], n, m;
inline bool dfs(int x, int s) {
if (!out[x]) return s == 1;
if (vis[x][s] == 2) return dp[x][s];
vis[x][s] = 1;
bool t = 0;
for (int i = h[x]; i; i = data[i].Next) {
int y = data[i].y;
if (vis[y][s ^ 1] == 1) {
cir = 1;
continue;
}
if (dfs(y, s ^ 1)) {
t = 1;
Next[x][s] = y;
}
}
vis[x][s] = 2;
return dp[x][s] = t;
}
inline void print(int x, int s) {
printf("%d ", x);
if (Next[x][s]) {
print(Next[x][s], s ^ 1);
}
}
void Solve() {
cin >> n >> m;
int to, xx;
for (int i = 1; i <= n; i++) {
cin >> xx;
while (xx--) {
cin >> to;
++out[i];
data[++num].y = to;
data[num].Next = h[i];
h[i] = num;
}
}
int st;
cin >> st;
if (dfs(st, 0)) {
printf("Win\n");
print(st, 0);
} else if (cir) {
printf("Draw\n");
} else {
printf("Lose\n");
}
return;
}
int main() {
int Case = 1, cases;
while (Case--) {
Solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> vv[100005];
bool vis[100005], inpath[100005], VIS[100005][2];
int dp[100005][2];
bool dfs1(int u) {
vis[u] = 1;
inpath[u] = 1;
int ret = 0;
for (int i = 0; i < vv[u].size(); i++) {
int v = vv[u][i];
if (vis[v] == 0) {
ret |= dfs1(v);
} else if (inpath[v])
ret = 1;
}
inpath[u] = 0;
return ret;
}
int solve(int u, int st) {
if (vv[u].size() == 0 && st == 0) {
VIS[u][st] = 1;
return dp[u][st] = 1;
}
if (vv[u].size() == 0 && st == 1) return 0;
if (VIS[u][st]) return dp[u][st];
int ret = 0;
VIS[u][st] = 1;
for (int i = 0; i < vv[u].size(); i++) {
int v = vv[u][i];
ret |= solve(v, st ^ 1);
}
return dp[u][st] = ret;
}
void print(int u, int st) {
printf("%d ", u);
if (vv[u].size() == 0) return;
VIS[u][st] = 0;
for (int i = 0; i < vv[u].size(); i++) {
int v = vv[u][i];
if (dp[v][st ^ 1] && VIS[v][st ^ 1]) {
print(v, st ^ 1);
return;
}
}
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) {
int c;
scanf("%d", &c);
for (int j = 1; j <= c; j++) {
int v;
scanf("%d", &v);
vv[i].push_back(v);
}
}
bool draw = 0;
int s;
scanf("%d", &s);
draw = dfs1(s);
int ans = solve(s, 1);
if (ans) {
printf("Win\n");
print(s, 1);
} else if (draw)
printf("Draw");
else
printf("Lose");
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100002;
int n, m, s, _prev[maxn][2];
bool visited[maxn][2], passed[maxn], done[maxn];
vector<int> g[maxn];
void dfs(int u, int x) {
visited[u][x] = true;
for (int i = 0; i < g[u].size(); ++i) {
int v = g[u][i];
if (!visited[v][x ^ 1]) {
dfs(v, x ^ 1);
_prev[v][x ^ 1] = u;
}
}
}
void trace(int u, int x) {
if (u == 0) return;
trace(_prev[u][x], x ^ 1);
cout << u << ' ';
}
bool isWin() {
dfs(s, 1);
for (int u = 1; u <= n; ++u) {
if (g[u].size() == 0 && visited[u][0]) {
cout << "Win\n";
trace(u, 0);
return true;
}
}
return false;
}
bool isDraw(int u) {
if (passed[u] && !done[u]) return true;
if (passed[u]) return false;
passed[u] = true;
for (int i = 0; i < g[u].size(); ++i) {
int v = g[u][i];
if (isDraw(v)) return true;
}
done[u] = true;
return false;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int u = 1; u <= n; ++u) {
int k;
cin >> k;
while (k--) {
int v;
cin >> v;
g[u].push_back(v);
}
}
cin >> s;
if (!isWin()) {
if (isDraw(s))
cout << "Draw";
else
cout << "Lose";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int len = 1e5 + 5;
int vis[len][2], low[len], num[len], vi[len], cnt, is[len];
vector<int> adj[len], vec, out, second;
void dfs(int u, int t) {
vis[u][t] = 1;
vec.push_back(u);
if (adj[u].size() == 0 && t && out.size() == 0) {
for (int j = 0; j < vec.size(); j++) out.push_back(vec[j]);
}
for (int j = 0; j < adj[u].size(); j++) {
int v = adj[u][j];
if (!vis[v][1 - t]) dfs(v, 1 - t);
}
vec.pop_back();
}
int draw(int u) {
int ans = 0;
vi[u] = 1;
for (int j = 0; j < adj[u].size(); j++) {
int v = adj[u][j];
if (vi[v] == 1)
ans = 1;
else if (vi[v] == 0)
ans = ans | draw(v);
}
vi[u] = 2;
return ans;
}
int main() {
int n, m, s;
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) {
int k, temp;
scanf("%d", &k);
while (k--) {
scanf("%d", &temp);
adj[i].push_back(temp);
}
}
scanf("%d", &s);
dfs(s, 0);
if (out.size() != 0) {
printf("Win\n");
for (int i = 0; i < out.size(); i++) printf("%d ", out[i]);
printf("\n");
return 0;
}
if (draw(s))
printf("Draw\n");
else
printf("Lose\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int k = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
k = k * 10 + ch - '0';
ch = getchar();
}
return k * f;
}
inline void write(int x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
inline void writeln(int x) {
write(x);
puts("");
}
int f[100010][2], n, m;
bool b[100010];
int nedge = 0, p[200010], nex[200010], head[200010];
inline void addedge(int a, int b) {
p[++nedge] = b;
nex[nedge] = head[a];
head[a] = nedge;
}
bool flag = 0;
bool vis[100010];
inline void dfs(int x, int v) {
vis[x] = 1;
for (int k = head[x]; k; k = nex[k]) {
if (vis[p[k]]) flag = 1;
if (f[p[k]][v ^ 1] == -1) {
f[p[k]][v ^ 1] = x;
dfs(p[k], v ^ 1);
}
}
vis[x] = 0;
}
inline void dfss(int x, int v) {
if (!x) return;
dfss(f[x][v], v ^ 1);
write(x);
putchar(' ');
}
int main() {
memset(f, -1, sizeof f);
n = read();
m = read();
for (int i = 1; i <= n; i++) {
int mm = read();
for (int j = 1; j <= mm; j++) {
int x = read();
addedge(i, x);
}
if (!mm) b[i] = 1;
}
int rt = read();
f[rt][0] = 0;
dfs(rt, 0);
for (int i = 1; i <= n; i++)
if (b[i] && f[i][1] > 0) {
puts("Win");
dfss(i, 1);
return 0;
}
if (flag)
puts("Draw");
else
puts("Lose");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;
using vi = vector<int>;
using ll = long long;
using ull = unsigned long long;
vi G[100001];
vi GT[100001];
bool vis[100001];
int topo[100001];
int tim;
void dfs(int v) {
if (vis[v]) return;
vis[v] = true;
for (auto u : G[v]) dfs(u);
topo[--tim] = v;
}
int scc[100001];
bool marked[100001];
int sccsize[100001];
void dfsscc(int v, int s) {
if (vis[v]) return;
vis[v] = true;
scc[v] = s;
sccsize[s]++;
for (auto u : GT[v]) dfsscc(u, s);
}
void markscc(int v) {
if (vis[v]) return;
vis[v] = true;
marked[scc[v]] = true;
for (auto u : G[v]) markscc(u);
}
bool vis2[100001][2];
int parent[100001][2];
void dfs3(int v, int p, bool k = false) {
if (vis2[v][k]) return;
vis2[v][k] = true;
parent[v][k] = p;
for (auto u : GT[v]) dfs3(u, v, !k);
}
void solve() {
int n, m, c, s;
cin >> n >> m;
for (int i = 0; i < (n); ++i) {
cin >> c;
G[i + 1].resize(c);
for (int j = 0; j < (c); ++j) {
cin >> G[i + 1][j];
GT[G[i + 1][j]].push_back(i + 1);
}
}
cin >> s;
tim = n;
for (int i = 0; i < (n); ++i) dfs(i + 1);
fill(vis, vis + n + 1, false);
int sccnum = 0;
for (int i = 0; i < (n); ++i)
if (!vis[topo[i]]) dfsscc(topo[i], sccnum++);
fill(vis, vis + n + 1, false);
markscc(s);
bool draw = false;
for (int i = scc[s]; i < sccnum; ++i)
if (marked[i] && sccsize[i] > 1) draw = true;
for (int i = 0; i < (n); ++i)
if (marked[scc[i + 1]] && G[i + 1].empty()) dfs3(i + 1, -1);
if (vis2[s][1]) {
cout << "Win\n";
int xd = 1;
while (!G[s].empty()) {
cout << s << ' ';
s = parent[s][xd];
xd = 1 - xd;
}
cout << s << '\n';
} else
cout << (draw ? "Draw" : "Lose") << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 1e5 + 9;
int res[MAX_N][2], point[MAX_N], num_s, st[MAX_N * 4], vis[MAX_N];
vector<int> vec[MAX_N];
int N, M, x;
void init() {
num_s = 0;
memset(st, 0, sizeof(st));
memset(vis, 0, sizeof(vis));
memset(res, 0, sizeof(res));
memset(point, 0, sizeof(point));
for (int i = 0; i < MAX_N; i++) vec[i].clear();
}
bool dfs(int pos, int x) {
if (res[pos][x ^ 1] == 1) return false;
res[pos][x ^ 1] = 1;
st[num_s++] = pos;
if (vec[pos].size() == 0 && res[pos][1]) {
return true;
}
for (int i = 0; i < vec[pos].size(); i++) {
if (dfs(vec[pos][i], x ^ 1)) return true;
}
num_s--;
return false;
}
bool cheak(int pos) {
vis[pos] = 1;
bool f = false;
for (int i = 0; i < vec[pos].size(); i++) {
if (vis[vec[pos][i]] == 1)
f = true;
else if (vis[vec[pos][i]] == 0)
f = cheak(vec[pos][i]);
if (f) return true;
}
vis[pos] = 2;
return false;
}
int main() {
cin >> N >> M;
init();
for (int i = 1; i <= N; i++) {
int num, temp;
scanf("%d", &num);
for (int j = 0; j < num; j++) {
scanf("%d", &temp);
vec[i].push_back(temp);
}
}
int pos;
cin >> pos;
if (dfs(pos, 1)) {
cout << "Win" << endl;
for (int i = 0; i < num_s; i++) {
printf("%d ", st[i]);
}
cout << endl;
} else if (cheak(pos))
cout << "Draw" << endl;
else
cout << "Lose" << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
struct point {
int to;
int nxt;
} edge[maxn];
int n, m, k, tot, sta, is_draw;
int head[maxn], vis[maxn][2], out[maxn];
vector<int> st;
inline void add(int u, int v) {
tot++;
edge[tot].nxt = head[u];
edge[tot].to = v;
head[u] = tot;
}
inline void dfs(int x, int col) {
if (vis[x][col]) return;
st.push_back(x);
vis[x][col] = 1;
if (!out[x]) {
if (col) {
printf("Win\n");
int mm = st.size();
for (int i = 0; i < mm; i++) printf("%d ", st[i]);
exit(0);
}
}
for (int i = head[x]; i; i = edge[i].nxt) {
int v = edge[i].to;
if (vis[v][!col] == 1) is_draw = 1;
dfs(v, !col);
}
st.pop_back();
vis[x][col] = 2;
}
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> k;
for (int j = 1; j <= k; j++) {
int u;
cin >> u;
add(i, u);
out[i]++;
}
}
cin >> sta;
dfs(sta, 0);
if (is_draw)
printf("Draw");
else
printf("Lose");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
vector<int> adj[100005];
int v[100005][2];
bool cycle;
void f(int i, int parity, vector<int> &path) {
path.push_back(i);
v[i][parity] = 1;
if (adj[i].size() == 0 && parity) {
cout << "Win\n";
for (int x : path) cout << x << ' ';
exit(0);
}
for (int x : adj[i]) {
if (v[x][!parity] == 1)
cycle = true;
else if (v[x][!parity] == 0)
f(x, !parity, path);
}
path.pop_back();
v[i][parity] = 2;
}
void solve() {
ll i, j;
ll n, m;
cin >> n >> m;
for (i = 1; i <= n; i++) {
int c;
cin >> c;
for (j = 0; j < c; j++) {
int x;
cin >> x;
adj[i].push_back(x);
}
}
int s;
cin >> s;
vector<int> path;
f(s, 0, path);
if (cycle)
cout << "Draw";
else
cout << "Lose";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int t = 1;
while (t--) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> ans;
int visited[100001][2], vis[100001];
vector<vector<int> > node;
bool draw;
bool cycle(int v, bool turn) {
if (vis[v]) return vis[v] == 1;
vis[v] = 1;
for (auto i : node[v]) {
if (cycle(i, !turn)) return true;
}
vis[v] = 2;
return false;
}
bool dfs(int v, bool turn) {
if (node[v].empty()) {
if (turn) ans.push_back(v);
return turn;
}
visited[v][turn] = 1;
for (auto i : node[v]) {
if (!visited[i][!turn] && dfs(i, !turn)) {
ans.push_back(v);
return true;
}
}
return false;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
node = vector<vector<int> >(n + 1);
for (auto i = 1; i <= (long long)(n); i++) {
int x;
cin >> x;
for (auto j = 0; j < (long long)(x); j++) {
int u;
cin >> u;
node[i].push_back(u);
}
}
int src;
cin >> src;
if (dfs(src, 0)) {
cout << "Win\n";
for (int i = ((int)((ans).size())) - 1; i >= 0; i--) cout << ans[i] << " ";
} else if (cycle(src, 0))
cout << "Draw";
else
cout << "Lose";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
int n, m;
int s[100009], nt[200009], e[200009];
int out[100009], vis[100009][2], v, ss;
int cnt, flag[100009];
struct node {
int x, y;
} pre, nt1;
int dfs(int k) {
flag[k] = 1;
for (int i = s[k]; ~i; i = nt[i]) {
if (flag[e[i]] == 1)
return 1;
else if (flag[e[i]] == 0) {
if (dfs(e[i])) return 1;
}
}
flag[k] = 2;
return 0;
}
int main() {
while (~scanf("%d %d", &n, &m)) {
cnt = 0;
memset(s, -1, sizeof s);
for (int i = 1; i <= n; i++) {
scanf("%d", &out[i]);
for (int j = 0; j < out[i]; j++) {
scanf("%d", &v);
nt[cnt] = s[i], s[i] = cnt, e[cnt++] = v;
}
}
scanf("%d", &ss);
memset(vis, 0, sizeof vis);
memset(flag, 0, sizeof flag);
pre.x = ss, pre.y = 0;
vis[ss][0] = -1;
queue<node> q;
q.push(pre);
while (!q.empty()) {
pre = q.front();
q.pop();
for (int i = s[pre.x]; ~i; i = nt[i]) {
if (!vis[e[i]][pre.y ^ 1]) {
vis[e[i]][pre.y ^ 1] = pre.x;
nt1.x = e[i], nt1.y = pre.y ^ 1;
q.push(nt1);
}
}
}
int flag = 0;
for (int i = 1; i <= n; i++) {
if ((!out[i]) && vis[i][1]) {
printf("Win\n");
int now = 1, k = i;
vector<int> ans;
while (k != -1) {
ans.push_back(k);
k = vis[k][now];
now ^= 1;
}
for (int j = ans.size() - 1; j >= 0; j--) {
if (j)
printf("%d ", ans[j]);
else
printf("%d\n", ans[j]);
}
flag = 1;
break;
}
}
if (!flag) {
if (dfs(ss))
printf("Draw\n");
else
printf("Lose\n");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void TxtRead() {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
const int N = 2e5 + 5;
vector<int> path, g[N];
char mark[N];
bool noWay, used[N][2];
int n, m, x, c, s;
void dfs(int v, bool state) {
path.push_back(v);
used[v][state] = 1;
for (int i = 0; i < g[v].size(); i++) {
int to = g[v][i];
if (!used[to][!state]) dfs(to, !state);
}
if (g[v].empty() && state) {
cout << "Win\n";
for (int i = 0; i < path.size(); i++) cout << path[i] << " ";
exit(0);
}
path.pop_back();
}
void bfs(int v) {
mark[v] = 1;
for (int i = 0; i < g[v].size(); i++) {
int to = g[v][i];
if (mark[to] == 1) noWay = 1;
if (!mark[to]) bfs(to);
}
mark[v] = 2;
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> c;
for (int j = 0; j < c; j++) {
cin >> x;
g[i].push_back(x);
}
}
cin >> s;
bfs(s);
dfs(s, 0);
if (noWay)
cout << "Draw";
else
cout << "Lose";
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 200;
const long long MOD = 1e9 + 7;
const long long LIM = N;
vector<long long> rec, v[N];
set<long long> flex;
long long f[N][2], PISOS, n, m, k, x, top;
void dfs(long long x, long long form) {
rec.push_back(x);
flex.insert(x);
f[x][form] = 1;
for (auto to : v[x]) {
if (flex.find(to) != flex.end()) PISOS = 1;
if (!f[to][form ^ 1]) dfs(to, form ^ 1);
}
if (v[x].empty() && form == 1) {
cout << "Win"
<< "\n";
for (auto x : rec) cout << x << " ";
cout << "\n";
exit(0);
}
flex.erase(x);
rec.pop_back();
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> k;
while (k--) {
cin >> x;
v[i].push_back(x);
}
}
cin >> top;
dfs(top, 0);
if (PISOS) return cout << "Draw", 0;
cout << "Lose";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 5;
bool vis[MAX][3];
bool call_stack[MAX];
vector<vector<int> > adj;
stack<int> s;
bool flag;
bool dfs(int node, int turn) {
int sz = adj[node].size();
if (sz == 0 && turn == 2) return 1;
for (int i = 0; i < sz; i++) {
int v = adj[node][i];
if (call_stack[v]) flag = 1;
if (!vis[v][3 - turn]) {
vis[v][3 - turn] = 1;
call_stack[v] = 1;
if (dfs(v, 3 - turn)) {
s.push(v);
return 1;
}
}
call_stack[v] = 0;
}
return 0;
}
int main() {
adj.resize(MAX);
int n, m;
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
for (int j = 0; j < x; j++) {
int vtx;
scanf("%d", &vtx);
adj[i].push_back(vtx);
}
}
int st;
scanf("%d", &st);
vis[st][1] = 1;
call_stack[st] = 1;
if (dfs(st, 1)) {
printf("Win\n%d", st);
while (!s.empty()) {
printf(" %d", s.top());
s.pop();
}
} else {
if (flag)
puts("Draw");
else
puts("Lose");
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > graph;
stack<int> dfs;
vector<int> visited[2];
vector<pair<int, int> > paths;
int recurr(int v, int l) {
dfs.push(v);
visited[l][v] = 1;
int ret = -2, t;
if (graph[v].size() == 0 && l == 1) {
return 0;
}
for (int i = 0; i < graph[v].size(); i++) {
if (visited[!l][graph[v][i]] == 0) {
t = recurr(graph[v][i], !l);
if (t == 0) {
return 0;
} else if (t == -1) {
ret = -1;
}
}
if (visited[0][graph[v][i]] == 1 || visited[1][graph[v][i]] == 1) {
ret = -1;
}
}
visited[l % 2][v] = 2;
dfs.pop();
return ret;
}
void printStack() {
if (dfs.size() > 0) {
int t = dfs.top() + 1;
dfs.pop();
printStack();
cout << t << " ";
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m, c, s;
cin >> n >> m;
graph.resize(n);
visited[0].resize(n, 0);
visited[1].resize(n, 0);
for (int i = 0; i < n; i++) {
cin >> c;
graph[i].resize(c);
for (int j = 0; j < c; j++) {
cin >> graph[i][j];
graph[i][j]--;
}
}
cin >> s;
s--;
switch (recurr(s, 0)) {
case 0:
cout << "Win" << endl;
printStack();
cout << endl;
break;
case -1:
cout << "Draw" << endl;
break;
case -2:
cout << "Lose" << endl;
break;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100001;
const long long MOD = 1e9 + 7;
int n, m, s, outd[N], p_e[N], p_o[N];
vector<vector<int> > g;
bool in_stack[N], vis_e[N], vis_o[N], vis[N];
bool dfs(int u) {
in_stack[u] = 1;
vis[u] = 1;
bool ans = 0;
for (int i = 0; i < g[u].size(); i++) {
if (in_stack[g[u][i]])
return 1;
else if (!vis[g[u][i]])
ans = ans || dfs(g[u][i]);
}
in_stack[u] = 0;
return ans;
}
void dfs2(int u, int d) {
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i], d2 = d ^ 1;
if (d2 == 0) {
if (!vis_e[v]) {
vis_e[v] = 1;
p_e[v] = u;
dfs2(v, d2);
}
} else {
if (!vis_o[v]) {
vis_o[v] = 1;
p_o[v] = u;
dfs2(v, d2);
}
}
}
}
int main() {
scanf("%d%d", &n, &m);
g.resize(n);
for (int i = 0; i < n; i++) {
int x, v;
scanf("%d", &x);
outd[i] = x;
while (x--) {
scanf("%d", &v);
v--;
g[i].push_back(v);
}
}
scanf("%d", &s);
s--;
bool cycle = dfs(s);
vis_o[s] = 1;
p_e[s] = -1;
p_o[s] = -1;
dfs2(s, 1);
for (int i = 0; i < n; i++)
if (!outd[i] && vis_e[i]) {
int u = i, c = 0;
vector<int> res;
int cnt = 0;
while (u != -1) {
cnt++;
res.push_back(u);
if (!c)
u = p_e[u];
else
u = p_o[u];
c ^= 1;
}
reverse(res.begin(), res.end());
puts("Win");
for (int j = 0; j < res.size(); j++)
printf("%s%d", (j ? " " : ""), res[j] + 1);
puts("");
return 0;
}
if (cycle)
puts("Draw");
else
puts("Lose");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, c, s;
vector<int> g[100005], gn[3 * 100005];
stack<int> st;
bool recst[3 * 100005] = {};
bool visited[3 * 100005] = {};
bool flag = 0, cycle = 0;
void printst() {
vector<int> temp;
while (!st.empty()) {
int tx = st.top();
temp.push_back(tx);
st.pop();
}
reverse(temp.begin(), temp.end());
cout << "Win" << endl;
for (int i = 0; i < temp.size(); i++) {
cout << temp[i] / 2 << " ";
st.push(temp[i]);
}
cout << endl;
flag = 1;
return;
}
void dfs(int u) {
visited[u] = 1;
st.push(u);
recst[u] = 1;
if (u % 2 == 0 && g[u / 2].size() == 0 && !flag) {
printst();
}
for (int i = 0; i < gn[u].size(); i++) {
int v = gn[u][i];
if (recst[v]) {
cycle = 1;
}
if (!visited[v]) dfs(v);
}
st.pop();
recst[u] = 0;
return;
}
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> c;
while (c--) {
int v;
cin >> v;
g[i].push_back(v);
gn[2 * i].push_back(2 * v + 1);
gn[2 * i + 1].push_back(2 * v);
}
}
cin >> s;
dfs(2 * s + 1);
if (!flag) {
if (cycle)
cout << "Draw" << endl;
else
cout << "Lose" << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, s;
int even_odd[100005][2];
int visited[100005];
vector<int> ans;
vector<int> v[100005];
int dfs(int s, int p) {
if (v[s].empty() && p) {
ans.push_back(s);
return 1;
}
for (auto it : v[s]) {
if (even_odd[it][p ^ 1] == 0) {
even_odd[it][p ^ 1] = s;
if (dfs(it, p ^ 1) == 1) {
ans.push_back(s);
return 1;
}
}
}
return 0;
}
bool dfs2(int source) {
visited[source] = 1;
for (auto it : v[source])
if (visited[it] == 1 || (visited[it] == 0 && dfs2(it))) return true;
visited[source] = 2;
return false;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 0; i < n; i++) {
int k;
cin >> k;
for (int j = 0; j < k; j++) {
int a;
cin >> a;
v[i + 1].push_back(a);
}
}
cin >> s;
if (dfs(s, 0)) {
cout << "Win\n";
for (int i = ans.size() - 1; i >= 0; i--) cout << ans[i] << " ";
return 0;
}
if (dfs2(s)) {
cout << "Draw\n";
return 0;
}
cout << "Lose\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
std::vector<int> adj[100005];
int rec[100005], last, vis[100005];
int dp[100005][2];
bool found_cycle(int x, int dir, int p) {
if (rec[x]) return true;
if (vis[x]) return false;
vis[x] = 1;
rec[x] = true;
for (int i = 0; i < adj[x].size(); ++i) {
if (found_cycle(adj[x][i], !dir, x)) return true;
}
rec[x] = false;
return false;
}
bool dfs(int x, int dir, int p) {
if (dp[x][dir] != -1) {
if (dp[x][dir] == -2) return false;
return true;
}
dp[x][dir] = -2;
for (int i = 0; i < adj[x].size(); ++i) {
if (dfs(adj[x][i], !dir, x)) {
dp[x][dir] = adj[x][i];
return true;
}
}
if (adj[x].size() == 0) {
if (dir == 1) {
dp[x][dir] = 1000001;
return true;
}
}
return false;
}
int n, m, v, s, l;
int main(int argc, char const *argv[]) {
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> l;
for (int j = 0; j < l; j++) {
cin >> v;
v--;
adj[i].push_back(v);
}
}
cin >> s;
s--;
for (int i = 0; i < n; i++) dp[i][0] = dp[i][1] = -1;
for (int i = 0; i < n; ++i) rec[i] = false;
string ans = "Lose";
if (found_cycle(s, 0, 0)) ans = "Draw";
if (dfs(s, 0, 0)) ans = "Win";
if (ans == "Win") {
cout << ans << "\n";
int dir = 0, last = s;
while (last != 1000001) {
cout << last + 1 << " ";
last = dp[last][dir];
dir = !dir;
}
} else
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200004;
int vs[N][2];
int vis[N];
int path[10 * N];
vector<int> g[N];
void dfs(int u, int win, int id) {
if (g[u].size() == 0) {
if (win) {
printf("Win\n");
for (int i = 0; i < id; i++) printf("%d ", path[i]);
printf("%d\n", u);
exit(0);
}
}
path[id] = u;
if (vs[u][win]) return;
vs[u][win] = 1;
int i;
for (i = 0; i < g[u].size(); i++) {
int v = g[u][i];
dfs(v, win ^ 1, id + 1);
}
}
void cycle(int u) {
vis[u] = 2;
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (vis[v] == 1)
continue;
else if (vis[v] == 2) {
printf("Draw\n");
exit(0);
}
cycle(v);
}
vis[u] = 1;
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
int i, j;
for (i = 1; i <= n; i++) {
int c;
scanf("%d", &c);
for (j = 1; j <= c; j++) {
int v;
scanf("%d", &v);
g[i].push_back(v);
}
}
int s;
scanf("%d", &s);
dfs(s, 0, 0);
cycle(s);
printf("Lose\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, r[200005][3], col[200005];
set<long long> g[200005], gr[200005];
bool can[200005][3];
bool used[200005], t;
pair<long long, long long> p[200005][3];
void isCycle(int v) {
col[v] = 1;
for (long long x : g[v]) {
if (col[x] == 1) {
t = true;
} else if (col[x] == 0) {
isCycle(x);
}
}
col[v] = 2;
}
int main() {
cin >> n >> m;
for (int i = 1; i <= n; ++i) {
int k;
cin >> k;
p[i][0] = p[i][1] = make_pair(-1, -1);
r[i][0] = r[i][1] = 1e9;
for (int j = 0; j < k; ++j) {
int a;
cin >> a;
g[i].insert(a);
gr[a].insert(i);
}
}
int s;
cin >> s;
queue<pair<long long, long long> > q;
for (int i = 1; i <= n; ++i) {
can[i][0] = can[i][1] = false;
}
for (int i = 1; i <= n; ++i) {
if ((int)g[i].size() == 0) {
q.push(make_pair(i, 0));
can[i][0] = true;
r[i][0] = 0;
}
}
while (!q.empty()) {
pair<long long, long long> v = q.front();
q.pop();
for (long long x : gr[v.first]) {
if (!can[x][v.second ^ 1]) {
can[x][v.second ^ 1] = true;
r[x][v.second ^ 1] = r[v.first][v.second] + 1;
p[x][v.second ^ 1] = make_pair(v.first, v.second);
q.push(make_pair(x, v.second ^ 1));
} else if (r[v.first][v.second] + 1 < r[x][v.second ^ 1]) {
r[x][v.second ^ 1] = r[v.first][v.second] + 1;
p[x][v.second ^ 1] = make_pair(v.first, v.second);
q.push(make_pair(x, v.second ^ 1));
}
}
}
if (!can[s][1]) {
for (int i = 1; i <= n; ++i) {
col[i] = 0;
}
t = false;
isCycle(s);
if (t) {
cout << "Draw" << endl;
return 0;
} else {
cout << "Lose" << endl;
return 0;
}
} else {
for (int i = 1; i <= n; ++i) {
used[i] = false;
}
vector<int> ans;
pair<long long, long long> cur = make_pair(s, 1);
while (cur.first != -1) {
ans.push_back(cur.first);
cur = p[cur.first][cur.second];
}
if ((int)ans.size() > 1000000) {
cout << "Draw" << endl;
return 0;
}
cout << "Win" << endl;
for (int i = 0; i < (int)ans.size(); ++i) {
cout << ans[i] << ' ';
}
cout << endl;
return 0;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 10;
vector<int> G[MAXN], path;
int n, m, ans, s;
bool draw, vis[MAXN][2];
bool ins[MAXN];
void dfs(int u, int step, int who) {
ins[u] = vis[u][who] = 1;
path.push_back(u);
if (G[u].empty()) {
if ((step & 1) && who) {
cout << "Win\n";
for (auto x : path) {
cout << x << ' ';
}
exit(0);
}
}
for (auto v : G[u]) {
if (ins[v]) {
draw = 1;
}
if (vis[v][who ^ 1]) {
continue;
}
dfs(v, step + 1, who ^ 1);
}
ins[u] = 0;
path.pop_back();
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
for (int c, x, i = 1; i <= n; ++i) {
cin >> c;
for (int j = 0; j < c; ++j) {
cin >> x;
G[i].push_back(x);
}
}
cin >> s;
dfs(s, 0, 0);
if (draw) {
cout << "Draw\n";
} else {
cout << "Lose\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100000;
vector<int> r[N + 1], r2[N + 1];
bool no_outdeg[N + 1];
int start_v;
bool cycle_visited[N + 1], cycle_dead[N + 1];
bool visited[N + 1][2];
stack<int> paths;
bool cycle_dfs(int);
void dfs(int, bool);
int main() {
int n;
scanf("%d%*d", &n);
for (int u = 1; u <= n; ++u) {
int m;
scanf("%d", &m);
no_outdeg[u] = (m == 0);
while (m--) {
int v;
scanf("%d", &v);
r[u].push_back(v);
r2[v].push_back(u);
}
}
scanf("%d", &start_v);
bool lose = !cycle_dfs(start_v);
for (int u = 1; u <= n; ++u) {
if (no_outdeg[u]) {
dfs(u, false);
}
}
printf("%s\n", lose ? "Lose" : "Draw");
exit(EXIT_SUCCESS);
}
bool cycle_dfs(int u) {
if (cycle_dead[u]) {
return false;
}
if (cycle_visited[u]) {
return true;
}
cycle_visited[u] = true;
for (int v : r[u]) {
if (cycle_dfs(v)) {
return true;
}
}
cycle_visited[u] = false;
cycle_dead[u] = true;
return false;
}
void dfs(int u, bool is_win) {
if (visited[u][is_win]) {
return;
}
visited[u][is_win] = true;
paths.push(u);
if (u == start_v && is_win) {
printf("Win\n");
while (!paths.empty()) {
printf("%d ", paths.top());
paths.pop();
}
printf("\n");
exit(EXIT_SUCCESS);
}
for (int v : r2[u]) {
dfs(v, !is_win);
}
paths.pop();
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 300005;
struct edge {
int to, next;
} e[N << 1];
int h[N], xb, dfn[N], low[N], n, m, i, j, x, y, w, stx[N], sty[N], ste[N];
vector<int> ans;
bool b[N], cant[N];
inline void addedge(int x, int y) {
e[++xb] = (edge){y, h[x]};
h[x] = xb;
e[++xb] = (edge){x, h[y]};
h[y] = xb;
}
void dfs(int x, int fa) {
dfn[x] = low[x] = ++xb;
int i = h[x], j;
for (; i; i = e[i].next)
if (e[i].to != fa) {
if (!dfn[e[i].to]) {
stx[++w] = x, sty[w] = e[i].to;
ste[w] = i;
dfs(e[i].to, x);
if (low[e[i].to] < low[x]) low[x] = low[e[i].to];
if (low[e[i].to] >= dfn[x]) {
int cnt = 0, ow = w;
for (; stx[w] != x || sty[w] != e[i].to; --w) {
if (!b[stx[w]]) ++cnt, b[stx[w]] = 1;
if (!b[sty[w]]) ++cnt, b[sty[w]] = 1;
}
if (!b[stx[w]]) ++cnt, b[stx[w]] = 1;
if (!b[sty[w]]) ++cnt, b[sty[w]] = 1;
if (ow - w + 1 > cnt || cnt == 2) {
for (j = w; j <= ow; ++j) cant[ste[j] >> 1] = 1;
}
for (j = w; j <= ow; ++j) b[stx[j]] = b[sty[j]] = 0;
--w;
}
} else {
if (dfn[e[i].to] < dfn[x]) stx[++w] = x, sty[w] = e[i].to, ste[w] = i;
if (dfn[e[i].to] < low[x]) low[x] = dfn[e[i].to];
}
}
}
int main() {
cin >> n >> m;
xb = 1;
for (i = 1; i <= m; ++i) {
cin >> x >> y;
addedge(x, y);
}
xb = 0;
for (i = 1; i <= n; ++i)
if (!dfn[i]) dfs(i, 0);
for (i = 1; i <= m; ++i)
if (!cant[i]) ans.push_back(i);
cout << ans.size() << '\n';
for (i = 0; i < int(ans.size()); ++i) cout << ans[i] << ' ';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double g = 10.0, eps = 1e-12;
const int N = 100000 + 10, maxn = 200000 + 10, inf = 0x3f3f3f3f,
INF = 0x3f3f3f3f3f3f3f3f;
vector<pair<int, int> > v[N];
int dfn[N], low[N];
int ind, iscut[N], n, m;
vector<int> ans;
struct edge {
int u, v, id;
};
stack<edge> s;
int bcccnt, bccno[N], ed[N];
vector<int> bcc[N], bb[N];
void tarjan(int u, int f) {
dfn[u] = low[u] = ++ind;
int ch = 0;
for (int i = 0; i < v[u].size(); i++) {
int x = v[u][i].first;
if (x == f) continue;
edge e = {u, x, v[u][i].second};
if (!dfn[x]) {
s.push(e);
ch++;
tarjan(x, u);
low[u] = min(low[u], low[x]);
if (low[x] >= dfn[u]) {
iscut[u] = 1;
bcccnt++;
bcc[bcccnt].clear();
while (1) {
edge now = s.top();
s.pop();
ed[bcccnt]++;
bb[bcccnt].push_back(now.id);
if (bccno[now.u] != bcccnt) {
bcc[bcccnt].push_back(now.u);
bccno[now.u] = bcccnt;
}
if (bccno[now.v] != bcccnt) {
bcc[bcccnt].push_back(now.v);
bccno[now.v] = bcccnt;
}
if (now.u == u && now.v == x) break;
}
}
} else if (dfn[x] < dfn[u]) {
s.push(e);
low[u] = min(low[u], dfn[x]);
}
}
if (f < 0 && ch == 1) iscut[u] = 0;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int a, b;
scanf("%d%d", &a, &b);
v[a].push_back(make_pair(b, i)), v[b].push_back(make_pair(a, i));
}
ind = 0;
for (int i = 1; i <= n; i++)
if (!dfn[i]) tarjan(i, -1);
memset(dfn, 0, sizeof dfn);
for (int i = 1; i <= bcccnt; i++) {
if (ed[i] == bcc[i].size() && ed[i]) {
for (int j = 0; j < bb[i].size(); j++) ans.push_back(bb[i][j]);
}
}
sort(ans.begin(), ans.end());
printf("%d\n", ans.size());
for (int i = 0; i < ans.size(); i++) printf("%d ", ans[i]);
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 100;
int first[maxn], des[maxn * 2], nxt[maxn * 2], tot;
int cnt_n[maxn], cnt_e[maxn], bcc_no[maxn], bcc_cnt;
int dfn[maxn], low[maxn], dfs_clock;
int st[maxn * 2], top;
vector<int> ans;
vector<int> temp;
int m, n;
inline void addEdge(int x, int y) {
tot++;
des[tot] = y;
nxt[tot] = first[x];
first[x] = tot;
}
void input() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d%d", &u, &v);
addEdge(u, v);
addEdge(v, u);
}
}
void dfs(int u, int fa, int Eid) {
dfn[u] = low[u] = ++dfs_clock;
for (int t = first[u]; t; t = nxt[t]) {
int v = des[t];
if (v == fa) continue;
if (!dfn[v]) {
st[top++] = t;
dfs(v, u, t);
low[u] = min(low[u], low[v]);
if (low[v] == dfn[u]) {
bool ok = true;
bcc_cnt++;
temp.clear();
while (true) {
int tt = st[--top];
temp.push_back((tt + 1) / 2);
if (bcc_no[des[tt]] != bcc_cnt) {
bcc_no[des[tt]] = bcc_cnt;
} else {
ok = false;
}
if (tt == t) {
break;
}
}
if (ok) {
for (int i = 0; i < temp.size(); i++) {
ans.push_back(temp[i]);
}
}
}
} else if (dfn[v] < dfn[u]) {
st[top++] = t;
low[u] = min(low[u], dfn[v]);
}
}
if (st[top - 1] == Eid) top--;
}
void solve() {
for (int i = 1; i <= n; i++) {
if (!dfn[i]) dfs(i, -1, -1);
}
sort(ans.begin(), ans.end());
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++) {
printf("%d ", ans[i]);
}
}
int main() {
input();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int inf_ = 0x7fffffff;
const long long inff = 4557430888798830399ll;
const double pi = acos(-1.0);
long long mod = 1e9 + 7;
map<int, int> id[100005];
struct DCC {
DCC() { init(0, 0); }
int n, t, h, m, dfn[100005], low[100005], s[100005], e[100005], g[100005];
vector<int>*N, cut, D[100005], F[100005];
bool mark[100005];
void init(int _n, vector<int>* _N) {
n = _n;
N = _N;
t = h = -1;
m = 0;
memset(dfn, 0, sizeof(dfn));
memset(low, 0, sizeof(low));
memset(mark, 0, sizeof(mark));
cut.clear();
}
void dfs(int u, int d, int p) {
int sec = 0, son = d > 1, e;
dfn[u] = low[u] = d;
s[++t] = u;
for (auto v : N[u]) {
if (!mark[e = id[u][v]]) g[++h] = e, mark[e] = 1;
if (!dfn[v]) {
dfs(v, d + 1, u);
low[u] = min(low[u], low[v]);
if (low[v] >= dfn[u]) {
if (++son == 2) cut.push_back(u);
m += 1;
D[m].clear();
D[m].push_back(u);
F[m].clear();
do F[m].push_back(g[h]);
while (g[h--] != e);
do D[m].push_back(s[t]);
while (s[t--] != v);
}
} else if (v != p || sec++)
low[u] = min(low[u], dfn[v]);
}
}
void run() {
for (int i = (1); i <= (n); ++i)
if (!dfn[i]) dfs(i, 1, 0);
gen();
}
void gen() {
vector<int> z;
for (int i = (1); i <= (m); ++i)
if (((int)F[i].size()) == ((int)D[i].size()) && ((int)D[i].size()) > 2)
for (auto e : F[i]) z.push_back(e);
sort((z).begin(), (z).end());
z.erase(unique((z).begin(), (z).end()), z.end());
cout << ((int)z.size()) << endl;
for (int i = (0); i < (((int)z.size())); ++i)
cout << z[i] << " \n"[i == ((int)z.size()) - 1];
}
};
vector<int> N[100005];
DCC t;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m, u, v;
cin >> n >> m;
for (int i = (1); i <= (m); ++i) {
cin >> u >> v;
N[u].push_back(v);
N[v].push_back(u);
id[u][v] = id[v][u] = i;
}
t.init(n, N);
t.run();
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int n, m, cnt = 1, timer = 0, bcc = 0, ans = 0;
int h[N], dfn[N], low[N], sz[N];
bool f[N], vis[N];
struct edge {
int to, nxt;
} e[N << 1];
vector<int> a[N];
stack<int> vst, est;
void add(int x, int y) {
cnt++;
e[cnt].to = y;
e[cnt].nxt = h[x];
h[x] = cnt;
}
void init() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
add(x, y);
add(y, x);
}
}
void tarjan(int u) {
dfn[u] = low[u] = ++timer;
vst.push(u);
for (int i = h[u]; i != 0; i = e[i].nxt) {
int v = e[i].to;
if (vis[i >> 1]) continue;
vis[i >> 1] = 1;
est.push(i >> 1);
if (dfn[v] == 0) {
tarjan(v);
low[u] = min(low[u], low[v]);
if (low[v] < dfn[u]) continue;
++bcc;
while (1) {
int mn = vst.top();
vst.pop();
sz[bcc]++;
if (mn == v) break;
}
sz[bcc]++;
while (1) {
int mn = est.top();
est.pop();
a[bcc].push_back(mn);
if (mn == i >> 1) break;
}
continue;
}
low[u] = min(low[u], dfn[v]);
}
}
void work() {
for (int i = 1; i <= n; i++) dfn[i] = 0;
timer = 0;
for (int i = 1; i <= n; i++) {
if (!dfn[i]) tarjan(i), vst.pop();
}
for (int i = 1; i <= bcc; i++) {
if (sz[i] != a[i].size()) continue;
for (int j = 0; j < sz[i]; j++) f[a[i][j]] = 1, ans++;
}
printf("%d\n", ans);
for (int i = 1; i <= m; i++) {
if (f[i]) printf("%d ", i);
}
printf("\n");
}
int main() {
init();
work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double g = 10.0, eps = 1e-12;
const int N = 100000 + 10, maxn = 200000 + 10, inf = 0x3f3f3f3f,
INF = 0x3f3f3f3f3f3f3f3f;
vector<pair<int, int> > v[N];
int dfn[N], low[N];
int ind, iscut[N], n, m;
vector<int> ans;
struct edge {
int u, v, id;
};
stack<edge> s;
int bcccnt, bccno[N], ed[N];
vector<int> bcc[N], bb[N];
void tarjan(int u, int f) {
dfn[u] = low[u] = ++ind;
int ch = 0;
for (int i = 0; i < v[u].size(); i++) {
int x = v[u][i].first;
if (x == f) continue;
edge e = {u, x, v[u][i].second};
if (!dfn[x]) {
s.push(e);
ch++;
tarjan(x, u);
low[u] = min(low[u], low[x]);
if (low[x] >= dfn[u]) {
iscut[u] = 1;
bcccnt++;
bcc[bcccnt].clear();
while (1) {
edge now = s.top();
s.pop();
ed[bcccnt]++;
bb[bcccnt].push_back(now.id);
if (bccno[now.u] != bcccnt) {
bcc[bcccnt].push_back(now.u);
bccno[now.u] = bcccnt;
}
if (bccno[now.v] != bcccnt) {
bcc[bcccnt].push_back(now.v);
bccno[now.v] = bcccnt;
}
if (now.u == u && now.v == x) break;
}
}
} else if (dfn[x] < dfn[u]) {
s.push(e);
low[u] = min(low[u], dfn[x]);
}
}
if (f < 0 && ch == 1) iscut[u] = 0;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int a, b;
scanf("%d%d", &a, &b);
v[a].push_back(make_pair(b, i)), v[b].push_back(make_pair(a, i));
}
ind = 0;
for (int i = 1; i <= n; i++)
if (!dfn[i]) tarjan(i, -1);
memset(dfn, 0, sizeof dfn);
for (int i = 1; i <= bcccnt; i++) {
if (bb[i].size() == bcc[i].size() && bb[i].size()) {
for (int j = 0; j < bb[i].size(); j++) ans.push_back(bb[i][j]);
}
}
sort(ans.begin(), ans.end());
printf("%d\n", ans.size());
for (int i = 0; i < ans.size(); i++) printf("%d ", ans[i]);
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
int n, m, x, y, low[N], dfn[N], cnt;
int q[N], l, H[N], to[N << 1], nxt[N << 1], tot = 1;
int bl[N], scnt;
bool vis[N << 1];
int a[N], A[N], ans;
void add(int x, int y) {
to[++tot] = y;
nxt[tot] = H[x];
H[x] = tot;
}
void dfs(int x, int y) {
dfn[x] = low[x] = ++cnt;
for (int i = H[x]; i; i = nxt[i]) {
if (to[i] == y || vis[i]) continue;
vis[i] = vis[i ^ 1] = 1;
q[l++] = i;
int v = to[i];
if (!dfn[v]) {
dfs(v, x);
low[x] = min(low[x], low[v]);
if (dfn[x] <= low[v]) {
int t, num = 0, bnum = 0;
++scnt;
do {
t = q[--l];
if (bl[to[t]] != scnt) bl[to[t]] = scnt, ++num;
if (bl[to[t ^ 1]] != scnt) bl[to[t ^ 1]] = scnt, ++num;
a[++bnum] = t;
} while (t != i);
if (num == bnum)
for (int i = 1; i <= bnum; ++i) A[++ans] = a[i];
}
} else
low[x] = min(low[x], dfn[v]);
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; ++i) {
scanf("%d%d", &x, &y);
add(x, y);
add(y, x);
}
for (int i = 1; i <= n; ++i)
if (!dfn[i]) dfs(i, 0);
sort(A + 1, A + ans + 1);
printf("%d\n", ans);
for (int i = 1; i <= ans; ++i) printf("%d ", A[i] >> 1);
}
|
#include <bits/stdc++.h>
const double Pi = 3.14159265;
const int M = 1e5 + 10;
const int N = 2e5 + 10;
const unsigned long long base = 163;
const int INF = 0x3f3f3f3f;
const int mod = 1e8;
const double eps = 1e-9;
const double pi = acos(-1);
using namespace std;
int n, m;
int head[M], to[N], nx[N], id[N];
int sta[N], top = 0, sz = 0;
vector<int> edge_belong[N];
int mark[N];
int node_belong[N];
int dfn[M], low[M];
int subnet[M], iscut[M];
int bcc_node_size[N];
int tot, step;
void add(int u, int v, int ID) {
to[tot] = v;
nx[tot] = head[u];
id[tot] = ID;
head[u] = tot++;
}
void dfs(int u) {
dfn[u] = low[u] = ++step;
for (int i = head[u]; ~i; i = nx[i]) {
if (mark[i]) continue;
mark[i] = mark[i ^ 1] = 1;
int v = to[i];
sta[++top] = i;
if (dfn[v])
low[u] = min(low[u], dfn[v]);
else {
dfs(v);
low[u] = min(low[u], low[v]);
if (low[v] >= dfn[u]) {
++subnet[u];
iscut[u] = 1;
++sz;
int now;
do {
now = sta[top--];
edge_belong[sz].push_back(id[now]);
if (node_belong[to[now]] != sz) {
node_belong[to[now]] = sz;
bcc_node_size[sz] += 1;
}
if (node_belong[to[now ^ 1]] != sz) {
node_belong[to[now ^ 1]] = sz;
bcc_node_size[sz] += 1;
}
} while (now != i);
}
}
}
}
void tarjan() {
for (int i = 1; i <= n; ++i) {
if (!dfn[i]) {
dfs(i);
if (subnet[i] < 2) iscut[i] = 0;
}
}
}
void init(int n) {
memset(head, -1, sizeof(head));
memset(mark, 0, sizeof(mark));
tot = step = top = sz = 0;
}
int main() {
scanf("%d%d", &n, &m);
init(n);
for (int i = 1; i <= m; ++i) {
int u, v;
scanf("%d%d", &u, &v);
add(u, v, i);
add(v, u, i);
}
tarjan();
vector<int> ans;
for (int i = 1; i <= sz; ++i) {
if (edge_belong[i].size() == bcc_node_size[i]) {
for (auto u : edge_belong[i]) ans.push_back(u);
}
}
sort(ans.begin(), ans.end());
printf("%d\n", (int)ans.size());
for (auto p : ans) printf("%d ", p);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
struct graph {
int n, m;
int v[N][2];
vector<int> e[N];
int depth[N];
int pa[N][20], pe[N];
int f[N];
int ans[N];
int in_tree[N], sub[N];
int LCA(int x, int y) {
if (depth[x] < depth[y]) swap(x, y);
for (int i = 0, val = depth[x] - depth[y]; val; i++, val >>= 1)
if (val & 1) x = pa[x][i];
if (x == y) return x;
for (int i = int(log2(depth[x])); i >= 0; i--)
if (pa[x][i] != pa[y][i]) x = pa[x][i], y = pa[y][i];
return pa[x][0];
}
void prepare() {
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int x, y;
cin >> x >> y;
v[i][0] = x;
v[i][1] = y;
e[x].push_back(i);
e[y].push_back(i);
}
}
int q[N];
void BFS(int st) {
static int top = 1, bot = 0;
q[++bot] = st;
pa[st][0] = 0;
depth[st] = 1;
while (top <= bot) {
int x = q[top++];
for (auto i : e[x]) {
int y = v[i][0] + v[i][1] - x;
if (depth[y]) continue;
pa[y][0] = x;
pe[y] = i;
depth[y] = depth[x] + 1;
q[++bot] = y;
}
}
}
void answer() {
prepare();
for (int i = 1; i <= n; i++)
if (!depth[i]) BFS(i);
for (int j = 1; j < 20; j++)
for (int i = 1; i <= n; i++) pa[i][j] = pa[pa[i][j - 1]][j - 1];
for (int i = 1; i <= n; i++) in_tree[pe[i]] = 1;
for (int i = 1; i <= m; i++)
if (!in_tree[i]) {
sub[v[i][0]]++;
sub[v[i][1]]++;
sub[LCA(v[i][0], v[i][1])] -= 2;
}
for (int i = n; i >= 1; i--) {
int x = q[i];
sub[pa[x][0]] += sub[x];
}
for (int i = 1; i <= n; i++) {
int x = q[i];
f[x] = f[pa[x][0]];
if (sub[x] == 1)
f[x]++;
else
f[x] = 0;
}
for (int i = 1; i <= m; i++)
if (!in_tree[i]) {
int z = LCA(v[i][0], v[i][1]);
if (f[v[i][0]] < depth[v[i][0]] - depth[z]) continue;
if (f[v[i][1]] < depth[v[i][1]] - depth[z]) continue;
ans[i] = 1;
}
memset(sub, 0, sizeof(sub));
for (int i = 1; i <= m; i++)
if (ans[i]) {
sub[v[i][0]]++;
sub[v[i][1]]++;
sub[LCA(v[i][0], v[i][1])] -= 2;
}
for (int i = n; i >= 1; i--) {
int x = q[i];
if (sub[x] == 1) ans[pe[x]] = 1;
sub[pa[x][0]] += sub[x];
}
int nans = count(ans + 1, ans + m + 1, 1);
cout << nans << '\n';
for (int i = 1; i <= m; i++)
if (ans[i]) cout << i << " ";
}
} mgr;
int main() { mgr.answer(); }
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
int k, n, m, x, y;
int low[N], dfn[N], tc;
int st[N], top;
int h[N], t[N << 1], nx[N << 1], num = 1;
int vis[N], cur;
bool b[N << 1];
int a[N], A[N], ncnt;
void Add(int x, int y) {
t[++num] = y;
nx[num] = h[x];
h[x] = num;
}
void Dfs(int x, int y) {
dfn[x] = low[x] = ++tc;
for (int i = h[x]; i; i = nx[i])
if (t[i] != y && !b[i]) {
b[i] = b[i ^ 1] = 1;
st[++top] = i;
int v = t[i];
if (!dfn[v]) {
Dfs(v, x);
low[x] = min(low[x], low[v]);
if (dfn[x] <= low[v]) {
int cnt = 0, Top = 0;
++cur;
while (st[top] != i) {
int x = st[top--];
if (vis[t[x]] != cur) vis[t[x]] = cur, ++cnt;
if (vis[t[x ^ 1]] != cur) vis[t[x ^ 1]] = cur, ++cnt;
a[++Top] = x;
}
if (vis[t[i]] != cur) vis[t[i]] = cur, ++cnt;
if (vis[t[i ^ 1]] != cur) vis[t[i ^ 1]] = cur, ++cnt;
a[++Top] = i;
--top;
if (dfn[x] == low[v] && cnt == Top) {
for (int i = 1; i <= Top; i++) A[++ncnt] = a[i];
}
}
} else
low[x] = min(low[x], dfn[v]);
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) scanf("%d%d", &x, &y), Add(x, y), Add(y, x);
for (int i = 1; i <= n; i++)
if (!dfn[i]) Dfs(i, 0);
cout << ncnt << endl;
sort(A + 1, A + ncnt + 1);
for (int i = 1; i <= ncnt; i++) printf("%d ", A[i] >> 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200005;
struct Edge {
int u, v;
Edge(int uu, int vv) {
u = uu;
v = vv;
}
};
stack<Edge> s;
struct edge {
int v, next;
} edges[maxn];
int n, m;
int e, head[maxn];
int pre[maxn];
int dfs_clock;
int iscut[maxn];
int bcc_cnt;
int bccno[maxn];
vector<int> bcc[maxn];
vector<int> ecnt[maxn];
map<pair<int, int>, int> f;
void addedges(int u, int v, int no) {
if (u > v) swap(u, v);
f[{u, v}] = no;
edges[e].v = v;
edges[e].next = head[u];
head[u] = e++;
edges[e].v = u;
edges[e].next = head[v];
head[v] = e++;
}
int dfs(int u, int fa) {
int lowu = pre[u] = ++dfs_clock;
int child = 0;
for (int i = head[u]; i != -1; i = edges[i].next) {
int v = edges[i].v;
Edge e = (Edge){u, v};
if (!pre[v]) {
s.push(e);
child++;
int lowv = dfs(v, u);
lowu = min(lowu, lowv);
if (lowv >= pre[u]) {
iscut[u] = 1;
bcc_cnt++;
bcc[bcc_cnt].clear();
for (;;) {
Edge x = s.top();
s.pop();
ecnt[bcc_cnt].push_back(f[{min(x.u, x.v), max(x.u, x.v)}]);
if (bccno[x.u] != bcc_cnt) {
bcc[bcc_cnt].push_back(x.u);
bccno[x.u] = bcc_cnt;
}
if (bccno[x.v] != bcc_cnt) {
bcc[bcc_cnt].push_back(x.v);
bccno[x.v] = bcc_cnt;
}
if (x.u == u && x.v == v) break;
}
}
} else if (pre[v] < pre[u] && v != fa) {
s.push(e);
lowu = min(lowu, pre[v]);
}
}
if (fa < 0 && child == 1) iscut[u] = 0;
return lowu;
}
void init() {
memset(pre, 0, sizeof(pre));
memset(iscut, 0, sizeof(iscut));
memset(head, -1, sizeof(head));
memset(bccno, 0, sizeof(bccno));
e = 0;
dfs_clock = 0;
bcc_cnt = 0;
}
pair<int, int> E[maxn];
int num[300005];
vector<int> cnt[maxn];
int main() {
int u, v;
scanf("%d%d", &n, &m);
init();
for (int i = 0; i < m; i++) {
scanf("%d%d", &u, &v);
addedges(u, v, i + 1);
}
for (int i = 1; i <= n; i++)
if (!pre[i]) dfs(i, -1);
vector<int> ans;
for (int i = 1; i <= bcc_cnt; i++) {
if (bcc[i].size() == ecnt[i].size()) {
for (int j = 0; j < ecnt[i].size(); j++) ans.push_back(ecnt[i][j]);
}
}
sort(ans.begin(), ans.end());
printf("%d\n", ans.size());
for (int i = 0; i < ans.size(); i++) printf("%d ", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
pair<int, int> edg[100100];
vector<int> lis[100100];
bool visit[100100];
bool tre[100100];
int dep[100100];
int val[100100];
int par[100100];
int pi[100100];
int sps[100100][20];
int pps[100100][20];
int dfs(int here, int p) {
dep[here] = ((~p) ? dep[p] + 1 : 0);
visit[here] = 1;
par[here] = p;
for (int &vi : lis[here]) {
int there = edg[vi].first + edg[vi].second - here;
if (!visit[there]) {
tre[vi] = 1;
pi[there] = vi;
val[here] += dfs(there, here);
} else {
if (there == p)
;
else if (dep[there] > dep[here]) {
val[here]--;
} else
val[here]++;
}
}
sps[here][0] = val[here];
pps[here][0] = p;
return val[here];
}
vector<int> vec;
int main() {
int i;
scanf("%d%d", &n, &m);
for (i = 0; i < m; i++) {
int a, b;
scanf("%d%d", &a, &b);
a--;
b--;
lis[a].push_back(i);
lis[b].push_back(i);
edg[i] = pair<int, int>(a, b);
}
for (i = 0; i < n; i++) {
if (!visit[i]) dfs(i, -1);
}
int j;
for (j = 1; j < 20; j++) {
for (i = 0; i < n; i++) {
pps[i][j] = ((~pps[i][j - 1]) ? pps[pps[i][j - 1]][j - 1] : -1);
}
for (i = 0; i < n; i++) {
sps[i][j] = max(sps[i][j - 1],
((~pps[i][j - 1]) ? sps[pps[i][j - 1]][j - 1] : 0));
}
}
for (i = 0; i < m; i++) {
if (tre[i]) continue;
int a = edg[i].first, b = edg[i].second;
if (dep[a] > dep[b]) swap(a, b);
int t = dep[b] - dep[a], maxi = 0, cur = b;
for (j = 0; j < 20; j++) {
if ((t >> j) & 1) {
maxi = max(maxi, sps[cur][j]);
cur = pps[cur][j];
}
}
if (maxi == 1) {
cur = b;
while (cur != a) {
vec.push_back(pi[cur]);
cur = par[cur];
}
vec.push_back(i);
}
}
sort(vec.begin(), vec.end());
printf("%d\n", vec.size());
for (int &v : vec) {
printf("%d ", v + 1);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
const int M = 1e5 + 10;
int n, m;
int dfs_clock, ecnt;
int head[N];
int low[N];
int dfn[N];
int vis[N];
int ans[N];
struct Edge {
int to, next, ind;
} e[M << 1];
inline void adde(int x, int y, int z) {
e[++ecnt].to = y;
e[ecnt].next = head[x];
head[x] = ecnt;
e[ecnt].ind = z;
}
stack<int> S, E;
void tarjan(int x) {
dfn[x] = low[x] = ++dfs_clock;
S.push(x);
for (int i = head[x]; i; i = e[i].next) {
int v = e[i].to;
int cur = E.size();
if (!vis[e[i].ind]) {
vis[e[i].ind] = 1;
E.push(e[i].ind);
}
if (!dfn[v]) {
tarjan(v);
low[x] = min(low[v], low[x]);
if (low[v] >= dfn[x]) {
int sum = 1;
int z;
do {
z = S.top();
S.pop();
sum++;
} while (z != v);
int ok = (sum == (E.size() - cur));
while (E.size() > cur) {
ans[E.top()] = ok;
E.pop();
}
}
} else
low[x] = min(low[x], dfn[v]);
}
return;
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; ++i) {
int la, lb;
scanf("%d %d", &la, &lb);
adde(la, lb, i);
adde(lb, la, i);
}
for (int i = 1; i <= n; ++i) {
if (!dfn[i]) {
tarjan(i);
}
}
cout << accumulate(ans + 1, ans + 1 + m, 0) << endl;
for (int i = 1; i <= m; ++i) {
if (ans[i]) cout << i << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC optimize("Ofast,no-stack-protector")
using namespace std;
function<void(void)> ____ = []() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
};
template <typename T>
vector<T> &operator<<(vector<T> &__container, T x) {
__container.push_back(x);
return __container;
}
template <typename T>
ostream &operator<<(ostream &out, vector<T> &__container) {
for (T _ : __container) out << _ << ' ';
return out;
}
const int MAXN = 2e5 + 7;
map<pair<int, int>, int> msk;
vector<int> G[MAXN];
stack<pair<int, int> > stk;
int dfn[MAXN], low[MAXN], idx;
vector<int> vec;
void tarjan(int u, int f) {
dfn[u] = low[u] = ++idx;
for (int v : G[u]) {
if (v == f) continue;
if (!dfn[v] or dfn[v] < dfn[u]) stk.push(make_pair(min(u, v), max(u, v)));
if (!dfn[v]) {
tarjan(v, u);
((low[u]) = (low[u]) < (low[v]) ? (low[u]) : (low[v]));
if (low[v] > dfn[u])
stk.pop();
else if (low[v] == dfn[u]) {
pair<int, int> tp;
vector<pair<int, int> > edge;
do {
tp = stk.top();
stk.pop();
edge << tp;
} while (tp != make_pair(min(u, v), max(u, v)));
vector<int> point;
for (auto &e : edge) point << e.first << e.second;
sort(point.begin(), point.end());
point.erase(unique(point.begin(), point.end()), point.end());
if (point.size() == edge.size())
for (auto &e : edge) vec << msk[e];
}
} else
((low[u]) = (low[u]) < (dfn[v]) ? (low[u]) : (dfn[v]));
}
}
void solve() {
int n, m;
scanf("%d", &n);
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d", &u);
scanf("%d", &v);
G[u] << v;
G[v] << u;
msk[pair<int, int>(min(u, v), max(u, v))] = i;
}
for (int i = 1; i <= n; i++)
if (!dfn[i]) tarjan(i, 0);
sort(vec.begin(), vec.end());
cout << vec.size() << "\n" << vec << "\n";
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
vector<int> h[maxn];
int dfn[maxn], low[maxn];
int n, m, k = 0;
stack<int> s;
int cnt = 0;
struct node {
int to, nxt, id;
} edge[maxn * 2];
int ecnt = 0;
int head[maxn];
void add(int from, int to, int id) {
edge[ecnt].to = to;
edge[ecnt].nxt = head[from];
edge[ecnt].id = id;
head[from] = ecnt++;
}
bool iscut[maxn], mark[maxn];
void tarjan(int u, int fa) {
dfn[u] = low[u] = ++k;
int child = 0;
for (int i = head[u]; i != -1; i = edge[i].nxt) {
int v = edge[i].to;
if (mark[edge[i].id]) continue;
mark[edge[i].id] = 1;
s.push(edge[i].id);
if (!dfn[v]) {
child++;
tarjan(v, edge[i].id);
low[u] = min(low[u], low[v]);
if (low[v] >= dfn[u]) {
cnt++;
iscut[u] = 1;
while (true) {
int x = s.top();
s.pop();
h[cnt].push_back(x);
if (x == edge[i].id) break;
}
}
} else
low[u] = min(low[u], dfn[v]);
}
if (fa == -1 && child < 2) iscut[u] = 0;
}
int x[maxn], y[maxn];
set<int> t;
int indeg[maxn];
bool check(int id) {
t.clear();
for (int i = 0; i < h[id].size(); i++) {
int p = h[id][i];
t.insert(x[p]);
t.insert(y[p]);
}
return t.size() == h[id].size();
}
int main() {
scanf("%d%d", &n, &m);
int u, v;
for (int i = 1; i <= n; i++) head[i] = -1;
for (int i = 1; i <= m; i++) {
scanf("%d%d", &u, &v);
add(u, v, i);
add(v, u, i);
x[i] = u;
y[i] = v;
}
for (int i = 1; i <= n; i++) {
if (!dfn[i]) tarjan(i, -1);
}
vector<int> ans;
for (int i = 1; i <= cnt; i++) {
if (check(i)) {
for (int j = 0; j < h[i].size(); j++) ans.push_back(h[i][j]);
}
}
sort(ans.begin(), ans.end());
printf("%d\n", ans.size());
for (int i = 0; i < ans.size(); i++) printf("%d ", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline char gc() {
static char now[1 << 16], *S, *T;
if (T == S) {
T = (S = now) + fread(now, 1, 1 << 16, stdin);
if (T == S) return EOF;
}
return *S++;
}
inline int read() {
int x = 0, f = 1;
char ch = gc();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = gc();
}
while (isdigit(ch)) x = x * 10 + ch - '0', ch = gc();
return x * f;
}
const int N = 1e5 + 10;
struct node {
int y, next, id;
} data[N << 1];
struct node1 {
int x, y, id;
} q[N];
int top, n, m, num, ans[N], h[N], dfn[N], low[N], size[N], s, b[N];
vector<int> eg[N];
inline void tarjan(int x, int fa) {
dfn[x] = low[x] = ++num;
for (int i = h[x]; i; i = data[i].next) {
int y = data[i].y;
if (y == fa) continue;
if (dfn[y] && (dfn[y] < dfn[x])) q[++top] = (node1){x, y, data[i].id};
if (!dfn[y]) {
q[++top] = (node1){x, y, data[i].id};
tarjan(y, x);
low[x] = min(low[x], low[y]);
if (low[y] >= dfn[x]) {
++s;
node1 now;
while (1) {
now = q[top--];
eg[s].push_back(now.id);
if (b[now.x] != s) ++size[s], b[now.x] = s;
if (b[now.y] != s) ++size[s], b[now.y] = s;
if (now.x == x && now.y == y) break;
}
}
} else
low[x] = min(low[x], dfn[y]);
}
}
int main() {
n = read();
m = read();
for (int i = 1; i <= m; ++i) {
int x = read(), y = read();
data[++num].y = y;
data[num].next = h[x];
h[x] = num;
data[num].id = i;
data[++num].y = x;
data[num].next = h[y];
h[y] = num;
data[num].id = i;
}
num = 0;
for (int i = 1; i <= n; ++i)
if (!dfn[i]) tarjan(i, i);
top = 0;
for (int i = 1; i <= s; ++i)
if (eg[i].size() == size[i])
for (int j = 0; j < eg[i].size(); ++j) ans[++top] = eg[i][j];
sort(ans + 1, ans + top + 1);
printf("%d\n", top);
for (int i = 1; i <= top; ++i) printf("%d ", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Edge {
int u, v;
Edge() {}
Edge(int u, int v) : u(u), v(v) {}
};
const int maxn = 100001;
int pre[maxn], iscut[maxn], bccno[maxn], dfs_clock, bcc_cnt;
vector<pair<int, int> > G[maxn];
vector<int> bcc[maxn];
int edge_cnt[maxn];
stack<Edge> S;
int n, m, x[maxn], y[maxn];
int vis[maxn];
int ans, ok[maxn];
int dfs(int u, int fa) {
int lowu = pre[u] = ++dfs_clock;
int child = 0;
for (auto p : G[u]) {
int v = p.first;
Edge e(u, v);
if (!pre[v]) {
S.push(e);
child++;
int lowv = dfs(v, u);
lowu = min(lowu, lowv);
if (lowv >= pre[u]) {
iscut[u] = true;
bcc_cnt++;
while (1) {
Edge x = S.top();
S.pop();
if (bccno[x.u] != bcc_cnt) {
bcc[bcc_cnt].push_back(x.u);
bccno[x.u] = bcc_cnt;
}
if (bccno[x.v] != bcc_cnt) {
bcc[bcc_cnt].push_back(x.v);
bccno[x.v] = bcc_cnt;
}
if (x.u == u && x.v == v) break;
}
}
} else if (pre[v] < pre[u] && v != fa) {
S.push(e);
lowu = min(lowu, pre[v]);
}
}
if (fa < 0 && child == 1) iscut[u] = 0;
return lowu;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &x[i], &y[i]);
G[x[i]].emplace_back(y[i], i);
G[y[i]].emplace_back(x[i], i);
}
for (int i = 1; i <= n; i++) {
if (!bccno[i]) dfs(i, -1);
}
vector<int> edges;
for (int i = 1; i <= bcc_cnt; i++) {
for (auto x : bcc[i]) bccno[x] = i;
edges.clear();
for (auto x : bcc[i]) {
for (auto y : G[x]) {
if (bccno[y.first] == i) {
edges.push_back(y.second);
}
}
}
if (edges.size() == bcc[i].size() * 2) {
for (auto x : edges) ok[x] = 1;
}
}
for (int i = 1; i <= m; i++) ans += ok[i];
printf("%d\n", ans);
for (int i = 1; i <= m; i++)
if (ok[i]) printf("%d ", i);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
struct mzls {
int from, to;
} e[100005];
vector<pair<int, int> > g[100005];
int dfn[100005], f[100005], dd[100005], ncnt, pt[100005];
int chs[100005], lnk[100005];
vector<int> t[100005], ans;
inline void dfs(int x, int fa) {
dfn[x] = ++ncnt;
pt[x] = fa;
for (int i = 0; i < g[x].size(); i++) {
pair<int, int> pr = g[x][i];
if (pr.first == fa) continue;
if (!dfn[pr.first]) {
t[x].push_back(pr.first);
chs[pr.second] = 1;
lnk[pr.first] = pr.second;
dfs(pr.first, x);
} else {
if (dfn[pr.first] > dfn[x]) continue;
f[x]++, f[pr.first]--;
}
}
}
int im[100005];
inline void dfs2(int x) {
for (int i = 0; i < t[x].size(); i++) {
dfs2(t[x][i]);
dd[x] += dd[t[x][i]];
}
dd[x] += f[x];
}
inline void dfs3(int x) {
im[x] = im[pt[x]] + (dd[x] > 1);
for (int i = 0; i < t[x].size(); i++) dfs3(t[x][i]);
}
inline void solve(int x) {
if (dfn[e[x].from] < dfn[e[x].to]) swap(e[x].from, e[x].to);
int kk = im[e[x].from] - im[e[x].to];
if (kk == 0) {
int pla = e[x].from;
while (pla != e[x].to) {
ans.push_back(lnk[pla]);
pla = pt[pla];
}
ans.push_back(x);
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &e[i].from, &e[i].to);
g[e[i].from].push_back(make_pair(e[i].to, i));
g[e[i].to].push_back(make_pair(e[i].from, i));
}
for (int i = 1; i <= n; i++)
if (!dfn[i]) dfs(i, 0), dfs2(i), dfs3(i);
for (int i = 1; i <= m; i++)
if (!chs[i]) solve(i);
sort(ans.begin(), ans.end());
printf("%d\n", ans.size());
for (int i = 0; i < ans.size(); i++) printf("%d ", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a, b, c, d, i, e, f, g, n, m, k, l, ans1;
long long fix[500005], don[500005], P[25][500005], ans[500005], B[500005],
A[500005], edge[500005];
map<pair<long long, long long>, long long> idx;
vector<long long> v[500005];
long long get_col(long long x) {
if (B[x] == x) return x;
B[x] = get_col(B[x]);
return B[x];
}
void col(long long x, long long y) { B[get_col(x)] = get_col(y); }
void gaferadeba(long long x, long long y) {
edge[get_col(y)] = idx[{x, P[0][y]}];
x = get_col(x);
y = get_col(y);
while (x != y) {
col(x, y);
A[y] += A[x];
x = get_col(P[0][x]);
}
A[y]++;
}
long long aweva(long long x, long long simagle) {
for (long long i = 20; i >= 0; i--) {
if ((1 << i) > simagle) continue;
simagle -= (1 << i);
x = P[i][x];
}
return x;
}
void dfs(long long x, long long y) {
fix[x] = 1;
don[x] = don[y] + 1;
P[0][x] = y;
for (long long i = 1; i <= 20; i++) {
P[i][x] = P[i - 1][P[i - 1][x]];
}
for (long long i = 0; i < v[x].size(); i++) {
if (v[x][i] == y) continue;
if (fix[v[x][i]] == 0) dfs(v[x][i], x);
}
}
void dfs1(long long x, long long y) {
fix[x] = 1;
for (long long i = 0; i < v[x].size(); i++) {
if (v[x][i] == y) continue;
if (fix[v[x][i]] == 0)
dfs1(v[x][i], x);
else {
if (don[x] > don[v[x][i]]) {
gaferadeba(x, aweva(x, don[x] - don[v[x][i]] - 1));
}
}
}
}
int main() {
cin >> n >> m;
for (long long i = 1; i <= n; i++) B[i] = i;
for (long long i = 1; i <= m; i++) {
cin >> a >> b;
v[a].push_back(b);
v[b].push_back(a);
idx[{a, b}] = i;
idx[{b, a}] = i;
}
for (long long i = 1; i <= n; i++)
if (fix[i] == 0) dfs(i, 0);
for (long long i = 1; i <= n; i++) fix[i] = 0;
for (long long i = 1; i <= n; i++)
if (fix[i] == 0) dfs1(i, 0);
for (long long i = 1; i <= n; i++) {
a = get_col(i);
if (A[a] == 1) {
ans[idx[{i, P[0][i]}]] = 1;
ans[edge[a]] = 1;
}
}
for (long long i = 1; i <= m; i++)
if (ans[i] == 1) ans1++;
cout << ans1 << endl;
for (long long i = 1; i <= m; i++)
if (ans[i] == 1) cout << i << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 5;
int head[MAXN], tot;
int DFN[MAXN], LOW[MAXN], cut[MAXN];
int bcc_num, bel_bcc[MAXN], bcc[MAXN], cnt;
struct node {
int to, next, id;
} e[MAXN * 3];
struct edge {
int x, y;
};
stack<pair<edge, int> > s;
vector<int> ans[MAXN];
void add(int x, int y, int id) {
e[tot].next = head[x];
e[tot].to = y;
e[tot].id = id;
head[x] = tot++;
}
void tarjan(int u, int fa) {
DFN[u] = LOW[u] = ++cnt;
int child = 0;
for (int i = head[u]; i != -1; i = e[i].next) {
int temp = e[i].to;
edge E;
E.x = u, E.y = temp;
if (!DFN[temp]) {
s.push(make_pair(E, e[i].id));
child++;
tarjan(temp, u);
LOW[u] = min(LOW[u], LOW[temp]);
if (LOW[temp] >= DFN[u]) {
cut[u] = 1;
bcc_num++;
edge t;
int sum = 0;
while (1) {
t = s.top().first;
int id = s.top().second;
s.pop();
if (bel_bcc[t.x] != bcc_num) sum++, bel_bcc[t.x] = bcc_num;
if (bel_bcc[t.y] != bcc_num) sum++, bel_bcc[t.y] = bcc_num;
ans[bcc_num].push_back(id);
if (t.x == u && t.y == temp) break;
}
bcc[bcc_num] = sum;
}
} else if (DFN[temp] < DFN[u] && temp != fa) {
s.push(make_pair(E, e[i].id));
LOW[u] = min(LOW[u], DFN[temp]);
}
}
if (fa == -1 && child == 1) cut[u] = 0;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
memset(head, -1, sizeof(head));
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
add(x, y, i);
add(y, x, i);
}
for (int i = 1; i <= n; i++) {
if (!DFN[i]) tarjan(i, -1);
}
vector<int> o;
for (int i = 1; i <= bcc_num; i++) {
if (bcc[i] == ans[i].size()) {
for (int j = 0; j < ans[i].size(); j++) o.push_back(ans[i][j]);
}
}
sort(o.begin(), o.end());
printf("%d\n", o.size());
for (int i = 0; i < o.size(); i++)
printf("%d%c", o[i], i == o.size() - 1 ? '\n' : ' ');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MN = 100010;
int N, M;
vector<int> adj[MN], U, V;
int tin[MN], bck[MN], id[MN], timer, bcnt;
stack<int> stk;
void dfs(int u, int fe, bool root) {
tin[u] = timer++;
bck[u] = tin[u];
for (int i = 0; i < adj[u].size(); i++) {
int e = adj[u][i];
int v = U[e] + V[e] - u;
if (tin[v] == -1) {
stk.push(e);
dfs(v, e, false);
bck[u] = min(bck[u], bck[v]);
if (bck[v] >= tin[u]) {
while (1) {
int t = stk.top();
stk.pop();
id[t] = bcnt;
if (t == e) break;
}
bcnt++;
}
} else if (tin[v] < tin[u]) {
if (e != fe) stk.push(e);
bck[u] = min(bck[u], tin[v]);
}
}
}
vector<int> C[MN], X, sol;
int main() {
scanf("%d %d", &N, &M);
for (int i = 0; i < M; i++) {
int u, v;
scanf("%d %d", &u, &v);
u--;
v--;
adj[u].push_back(i);
adj[v].push_back(i);
U.push_back(u);
V.push_back(v);
}
memset(tin, -1, sizeof(tin));
for (int i = 0; i < N; i++)
if (tin[i] == -1) {
dfs(i, -1, true);
}
for (int i = 0; i < M; i++) {
C[id[i]].push_back(i);
}
int ans = 0;
for (int i = 0; i < bcnt; i++) {
X.clear();
for (int j = 0; j < C[i].size(); j++) {
X.push_back(U[C[i][j]]);
X.push_back(V[C[i][j]]);
}
sort(X.begin(), X.end());
X.resize(unique(X.begin(), X.end()) - X.begin());
if (X.size() == C[i].size()) {
for (int j = 0; j < C[i].size(); j++) sol.push_back(C[i][j]);
}
}
sort(sol.begin(), sol.end());
printf("%d\n", sol.size());
for (int i = 0; i < sol.size(); i++) {
printf("%d ", sol[i] + 1);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 6;
int n, m, num[100005], ncyc = 0, cycIn[100005], result[100005], cnt = 0;
int dd[N], head[N];
vector<pair<int, int> > a[100005];
set<int> In[100005];
int re(int h, int k) {
if (h == 0) return k;
if (k == 0) return h;
dd[h] = 1, dd[k] = 1;
return (head[h] < head[k] ? h : k);
}
int dfs(int h, int id) {
int n = a[h].size() - 1, x, res = 0;
for (int i = 0; i <= n; ++i) {
if (num[a[h][i].first] >= num[h] - 1) continue;
if (!num[a[h][i].first]) {
num[a[h][i].first] = num[h] + 1;
x = dfs(a[h][i].first, a[h][i].second);
if (!In[h].count(x)) res = re(res, x);
} else {
head[++ncyc] = num[a[h][i].first];
cycIn[a[h][i].second] = ncyc;
In[a[h][i].first].insert(ncyc);
res = re(res, ncyc);
}
}
return (cycIn[id] = res);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
int x, y;
for (int i = 1; i <= m; ++i) {
cin >> x >> y;
a[x].push_back(make_pair(y, i));
a[y].push_back(make_pair(x, i));
}
for (int i = 1; i <= n; ++i) {
if (!num[i]) num[i] = 2, dfs(i, 0);
}
for (int i = 1; i <= m; ++i) {
if (cycIn[i] && !dd[cycIn[i]]) result[++cnt] = i;
}
cout << cnt << '\n';
for (int i = 1; i <= cnt; ++i) cout << result[i] << ' ';
}
|
#include <bits/stdc++.h>
using namespace std;
int head[100005], v[100005 * 2], suc[100005 * 2], en = 1;
void addedge(int iu, int iv) {
en++;
v[en] = iv;
suc[en] = head[iu];
head[iu] = en;
}
int pre[100005], iscut[100005], bccno[100005], dfs_clk, bcc_cnt;
int st[100005], ts;
vector<int> bcc[100005];
int num[100005];
int dfs(int s, int fa) {
int lows = pre[s] = ++dfs_clk;
int ch = 0;
for (int i = head[s]; i; i = suc[i]) {
if (!pre[v[i]]) {
st[++ts] = i;
ch++;
int lowv = dfs(v[i], s);
lows = min(lows, lowv);
if (lowv >= pre[s]) {
iscut[s] = 1;
bcc_cnt++;
bcc[bcc_cnt].clear();
while (1) {
int x = st[ts--];
for (int y = 0; y <= 1; y++)
if (bccno[v[x ^ y]] != bcc_cnt) {
bccno[v[x ^ y]] = bcc_cnt;
num[bcc_cnt]++;
}
bcc[bcc_cnt].push_back(x >> 1);
if (x == i) break;
}
}
} else if (pre[v[i]] < pre[s] && v[i] != fa) {
st[++ts] = i;
lows = min(lows, pre[v[i]]);
}
}
if (fa < 0 && ch == 1) iscut[s] = 0;
return lows;
}
int ans[100005], ans_cnt;
int main() {
int i, j, k;
int n, m, iv, iu;
scanf("%d%d", &n, &m);
for (i = 1; i <= m; i++) {
scanf("%d%d", &iu, &iv);
addedge(iu, iv);
addedge(iv, iu);
}
for (i = 1; i <= n; i++)
if (!pre[i]) dfs(i, -1);
for (i = 1; i <= bcc_cnt; i++)
if (bcc[i].size() == num[i])
for (j = 0; j < bcc[i].size(); j++) ans[++ans_cnt] = bcc[i][j];
sort(ans + 1, ans + ans_cnt + 1);
printf("%d\n", ans_cnt);
for (i = 1; i <= ans_cnt; i++) printf("%d ", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int const N = 100000;
vector<pair<int, int> > g[N + 1];
vector<int> an;
int dp[N + 1], mndp[N + 1];
int vis[N + 1];
int V;
void ad(int v, int p = V) {
if (v == V) return;
for (int i = 0; i < (int)(g[v].size()); ++i) {
int u = g[v][i].first;
if (u == p || (mndp[u] != dp[V] && u != V)) continue;
an.push_back(g[v][i].second);
ad(u, v);
return;
}
}
bool go(int v, int p = 0) {
vis[v] = 1;
mndp[v] = dp[v] = dp[p] + 1;
bool good = true;
int cy = 0;
for (int i = 0; i < (int)(g[v].size()); ++i) {
int u = g[v][i].first;
if (u == p) continue;
if (vis[u] == 2) {
if (mndp[u] < dp[v]) good = false;
continue;
}
if (vis[u] == 0) {
bool t = go(u, v);
if (t && mndp[u] == dp[v]) {
an.push_back(g[v][i].second);
V = v;
ad(u);
} else if (mndp[u] < dp[v])
good &= t;
mndp[v] = min(mndp[v], mndp[u]);
}
if (mndp[u] < dp[v]) ++cy;
if (vis[u] == 1) mndp[v] = min(mndp[v], dp[u]);
}
good &= cy <= 1;
vis[v] = 2;
return good;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i < (int)(m + 1); ++i) {
int a, b;
scanf("%d%d", &a, &b);
g[a].push_back(make_pair(b, i));
g[b].push_back(make_pair(a, i));
}
for (int i = 1; i < (int)(n + 1); ++i)
if (!vis[i]) go(i);
sort(an.begin(), an.end());
printf("%d\n", (int)an.size());
for (int i = 0; i < (int)(an.size()); ++i) {
if (i) printf(" ");
printf("%d", an[i]);
}
printf("\n");
}
|
#include <bits/stdc++.h>
using namespace std;
struct edge1 {
long long to, num;
};
struct edge2 {
long long v1, v2;
};
vector<edge1> a[100009];
vector<edge2> edges;
vector<long long> res, nums;
set<long long> vertex, point;
stack<long long> s;
long long i, j, k, l, n, m, timer;
long long tin[100009], tmin[100009], vis[100009];
void draw(long long edge) {
vertex.clear();
nums.clear();
while (!s.empty()) {
vertex.insert(edges[s.top()].v1);
vertex.insert(edges[s.top()].v2);
nums.push_back(s.top());
if (s.top() == edge) {
s.pop();
break;
}
s.pop();
}
if (nums.size() == vertex.size()) {
for (auto i : nums) res.push_back(i);
}
}
void dfs(long long v, long long parent) {
vis[v] = 1;
tin[v] = tmin[v] = ++timer;
long long to, edge, child = 0;
for (auto i : a[v]) {
to = i.to;
edge = i.num;
if (to == parent) continue;
if (vis[to] == 0) {
s.push(edge);
dfs(to, v);
child++;
tmin[v] = min(tmin[v], tmin[to]);
if (tmin[to] >= tin[v]) {
draw(edge);
}
} else {
tmin[v] = min(tmin[v], tin[to]);
if (tin[to] < tin[v]) {
s.push(edge);
}
}
}
}
int main() {
cin >> n >> m;
for (i = 1; i <= m; i++) {
cin >> k >> l;
a[k].push_back({l, i - 1});
a[l].push_back({k, i - 1});
edges.push_back({k, l});
}
for (i = 1; i <= n; i++) {
if (vis[i] == 0) {
dfs(i, -1);
draw(-1);
}
}
sort(res.begin(), res.end());
cout << res.size() << endl;
for (auto i : res) {
cout << i + 1 << ' ';
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int limite = 1000000;
int n, m;
vector<pair<int, int> > g[limite], gini[limite];
int visto[limite];
vector<int> sol;
int profant[limite];
int profundidad[limite];
vector<pair<int, int> > a[limite];
void eliminapadre(int u, int p, int prof) {
visto[u] = 1;
profundidad[u] = prof;
vector<pair<int, int> > &ar = g[u];
vector<pair<int, int> > nextar;
for (int i = 0; i < int(ar.size()); i++) {
int v = ar[i].first;
if (v != p) nextar.push_back(ar[i]);
if (not visto[v]) {
a[u].push_back(ar[i]);
eliminapadre(v, u, prof + 1);
}
}
ar = nextar;
}
void computacomponente(int u, vector<int> &c) {
if (visto[u]) return;
visto[u] = 1;
c.push_back(u);
vector<pair<int, int> > &ar = a[u];
for (int i = 0; i < int(ar.size()); i++) computacomponente(ar[i].first, c);
}
int tiempo = 0;
int numcomp[limite];
void computa(int uini, vector<int> lista) {
tiempo++;
int n = int(lista.size());
vector<int> act;
for (int i = 0; i < int(lista.size()); i++) numcomp[lista[i]] = tiempo;
for (int i = 0; i < int(lista.size()); i++) {
int u = lista[i];
if (u == uini) continue;
vector<pair<int, int> > &ar = gini[u];
for (int j = 0; j < int(ar.size()); j++) {
int v = ar[j].first;
if (numcomp[v] == tiempo and (v == uini or u < v))
act.push_back(ar[j].second);
}
}
if (int(act.size()) == n) {
for (int i = 0; i < int(act.size()); i++) sol.push_back(act[i]);
}
}
void calcula(int u) {
profant[u] = profundidad[u];
{
vector<pair<int, int> > &ar = a[u];
for (int i = 0; i < int(ar.size()); i++) {
int v = ar[i].first;
calcula(v);
profant[u] = min(profant[u], profant[v]);
if (profant[v] == profundidad[u]) {
vector<int> c;
c.push_back(u);
computacomponente(v, c);
computa(u, c);
}
}
}
{
vector<pair<int, int> > &ar = g[u];
for (int i = 0; i < int(ar.size()); i++) {
int v = ar[i].first;
if (profundidad[v] < profundidad[u])
profant[u] = min(profant[u], profundidad[v]);
}
}
if (profant[u] == profundidad[u]) visto[u] = 1;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
g[u].push_back(pair<int, int>(v, i));
g[v].push_back(pair<int, int>(u, i));
gini[u].push_back(pair<int, int>(v, i));
gini[v].push_back(pair<int, int>(u, i));
}
for (int u = 1; u <= n; u++)
if (not visto[u]) eliminapadre(u, 0, 0);
for (int u = 1; u <= n; u++) visto[u] = 0;
for (int u = 1; u <= n; u++)
if (not visto[u]) calcula(u);
sort(sol.begin(), sol.end());
cout << int(sol.size()) << endl;
for (int i = 0; i < int(sol.size()); i++) {
if (i > 0) cout << " ";
cout << sol[i];
}
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
struct edge {
long long from;
long long to;
long long id;
};
vector<pair<long long, long long>> edgeList;
vector<long long> res;
vector<set<long long>> neighbour;
vector<vector<edge>> adjlist;
vector<edge> edgeStack;
vector<bool> isArt;
vector<int> d, low;
int counter, rootCount, root;
vector<vector<long long>> blocks;
void dfs(int v, int parent = -1) {
d[v] = low[v] = ++counter;
if (parent == root) ++rootCount;
for (edge& e : adjlist[v]) {
if (e.to != parent && (!d[e.to] || d[e.to] < d[v])) {
edgeStack.push_back(e);
}
if (!d[e.to]) {
dfs(e.to, v);
low[v] = min(low[v], low[e.to]);
if (low[e.to] >= d[v]) {
isArt[v] = true;
blocks.push_back({});
while (edgeStack.back().to != e.to || edgeStack.back().from != v) {
blocks.back().push_back(edgeStack.back().id);
edgeStack.pop_back();
}
blocks.back().push_back(edgeStack.back().id);
edgeStack.pop_back();
}
} else if (e.to != parent && d[e.to] < low[v]) {
low[v] = min(low[v], d[e.to]);
}
}
}
void findArticulationPoints() {
counter = 0;
low.resize(adjlist.size());
d.assign(adjlist.size(), 0);
isArt.assign(adjlist.size(), false);
for (int v = 0; v < (int)adjlist.size(); v++) {
if (!d[v]) {
root = v;
rootCount = 0;
dfs(v);
isArt[v] = rootCount > 1;
if (!edgeStack.empty()) {
blocks.push_back({});
while (!edgeStack.empty()) {
blocks.back().push_back(edgeStack.back().id);
edgeStack.pop_back();
}
}
}
}
}
void checkBlock() {
for (long long i = 0; i < blocks.size(); i++) {
map<long long, long long> block;
for (long long x : blocks[i]) {
block[edgeList[x].first]++;
block[edgeList[x].second]++;
}
bool isSimple = true;
for (auto x : block) {
isSimple &= x.second == 2;
}
if (isSimple) {
for (long long x : blocks[i]) {
res.push_back(x);
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
long long n, m;
cin >> n >> m;
neighbour.resize(n);
adjlist.resize(n);
edgeList.resize(m);
for (long long i = 0; i < m; i++) {
cin >> edgeList[i].first >> edgeList[i].second;
edgeList[i].first--;
edgeList[i].second--;
neighbour[edgeList[i].first].insert(edgeList[i].second);
adjlist[edgeList[i].first].push_back(
{edgeList[i].first, edgeList[i].second, i});
neighbour[edgeList[i].second].insert(edgeList[i].first);
adjlist[edgeList[i].second].push_back(
{edgeList[i].second, edgeList[i].first, i});
}
findArticulationPoints();
checkBlock();
sort(res.begin(), res.end());
cout << res.size() << endl;
for (auto x : res) {
cout << (x + 1) << " ";
}
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 5e5 + 50;
const long long mod = 1e9 + 7;
const long long base = maxn * 2;
long long low[maxn];
long long id[maxn];
long long cnt = 0;
long long cntnw = 0;
vector<long long> gr[maxn];
long long par[maxn];
pair<long long, long long> a[maxn];
vector<long long> adj[maxn];
bool dd[maxn];
long long sl[maxn];
stack<long long> st;
vector<long long> adj1[maxn];
long long anc[maxn][22];
long long n, m;
long long siz[maxn];
void dfs(long long u, long long par1) {
dd[u] = 1;
low[u] = id[u] = cnt++;
st.push(u);
for (auto to : adj[u]) {
long long x = a[to].first;
long long y = a[to].second;
long long nxt = x + y - u;
if (nxt == par1) continue;
if (dd[nxt]) {
low[u] = min(low[u], id[nxt]);
} else {
dfs(nxt, u);
low[u] = min(low[u], low[nxt]);
if (low[nxt] >= id[u]) {
cntnw++;
adj1[u].push_back(cntnw);
siz[cntnw] = 1;
vector<long long> vt;
while (1) {
long long p1 = st.top();
st.pop();
adj1[cntnw].push_back(p1);
siz[cntnw]++;
if (p1 == nxt) break;
}
}
}
}
}
vector<long long> topo;
bool kt[maxn];
void dfs1(long long u) {
kt[u] = 1;
for (auto to : adj1[u]) {
if (kt[to]) continue;
dfs1(to);
}
topo.push_back(u);
}
long long dep[maxn];
void dfs2(long long u, long long par) {
anc[u][0] = par;
kt[u] = 1;
for (int i = 1; i < 20; i++) {
anc[u][i] = anc[anc[u][i - 1]][i - 1];
}
for (auto to : adj1[u]) {
if (kt[to]) continue;
dep[to] = dep[u] + 1;
dfs2(to, u);
}
}
long long lca(long long x, long long y) {
if (dep[x] < dep[y]) swap(x, y);
long long kc = dep[x] - dep[y];
for (int i = 20; i >= 0; i--) {
if (kc & (1ll << i)) {
x = anc[x][i];
}
}
if (x == y) return x;
for (int i = 20; i >= 0; i--) {
if (anc[x][i] != anc[y][i]) {
x = anc[x][i];
y = anc[y][i];
}
}
return anc[x][0];
}
long long lca1(long long x, long long y) {
if (dep[x] < dep[y]) swap(x, y);
long long kc = dep[x] - dep[y] - 1;
for (int i = 20; i >= 0; i--) {
if (kc & (1ll << i)) {
x = anc[x][i];
}
}
return x;
}
vector<long long> e[maxn];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
if (fopen("t.inp", "r")) {
freopen("test.inp", "r", stdin);
freopen("test.out", "w", stdout);
}
cin >> n >> m;
for (int i = 1; i <= m; i++) {
cin >> a[i].first >> a[i].second;
adj[a[i].first].push_back(i);
adj[a[i].second].push_back(i);
}
cntnw = n;
for (int i = 1; i <= n; i++) {
if (!dd[i]) {
dfs(i, -1);
}
}
for (int i = 1; i <= n; i++) {
if (!kt[i]) {
dfs1(i);
}
}
reverse(topo.begin(), topo.end());
memset(kt, 0, sizeof(kt));
for (auto to : topo) {
if (kt[to]) continue;
dfs2(to, 0);
}
for (int i = 1; i <= m; i++) {
if (dep[a[i].first] < dep[a[i].second]) swap(a[i].first, a[i].second);
long long l = lca(a[i].first, a[i].second);
if (l == a[i].second) {
e[lca1(a[i].first, a[i].second)].push_back(i);
} else {
e[l].push_back(i);
}
}
vector<long long> ans;
for (int i = n + 1; i <= cntnw; i++) {
if (siz[i] == e[i].size()) {
for (auto to : e[i]) {
ans.push_back(to);
}
}
}
sort(ans.begin(), ans.end());
cout << ans.size() << endl;
for (auto to : ans) {
cout << to << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod1 = 1e5 + 7;
const int N = 1e6 + 7;
const int mod2 = 1e9 + 7;
const long long mod3 = 1e12;
vector<pair<pair<int, int>, int> > son[N];
vector<int> bcc_node[N], bcc_edge[N], ans;
stack<pair<pair<int, int>, int> > s;
set<int> node;
int bcc_cnt, belong[N], is_cnt[N], now_time, tin[N], low[N];
void dfs(int o, int fa) {
tin[o] = low[o] = ++now_time;
int ch = 0;
for (int i = 0; i < son[o].size(); ++i) {
int v = son[o][i].first.first;
if (v == fa) continue;
pair<pair<int, int>, int> edge = {{o, v}, son[o][i].second};
if (!tin[v]) {
s.push(edge);
dfs(v, o);
low[o] = min(low[o], low[v]);
if (low[v] >= tin[o]) {
ch++;
is_cnt[o] = true;
bcc_node[++bcc_cnt].clear();
bcc_edge[bcc_cnt].clear();
while (true) {
pair<pair<int, int>, int> now = s.top();
s.pop();
bcc_edge[bcc_cnt].push_back(now.second);
if (belong[now.first.first] != bcc_cnt) {
belong[now.first.first] = bcc_cnt;
bcc_node[bcc_cnt].push_back(now.first.first);
}
if (belong[now.first.second] != bcc_cnt) {
belong[now.first.second] = bcc_cnt;
bcc_node[bcc_cnt].push_back(now.first.second);
}
if (now.first.first == o && now.first.second == v) break;
}
}
} else if (tin[v] < tin[o]) {
s.push(edge);
low[o] = min(tin[v], low[o]);
}
}
if (!fa && ch == 1) is_cnt[o] = false;
}
int main() {
int n, m, u, v;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &u, &v);
son[u].push_back({{v, u}, i});
son[v].push_back({{u, v}, i});
}
for (int i = 1; i <= n; i++) dfs(i, i);
for (int i = 1; i <= bcc_cnt; i++)
if (bcc_node[i].size() == bcc_edge[i].size()) {
for (auto v : bcc_edge[i]) node.insert(v);
}
printf("%d\n", node.size());
if (node.size() > 0) {
auto p = node.begin();
printf("%d", *p);
while (++p != node.end()) printf(" %d", *p);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 100;
int first[maxn], des[maxn * 2], nxt[maxn * 2], tot;
int bcc_cnt, cnt_n[maxn], cnt_e[maxn], bcc_no[maxn];
int dfn[maxn], low[maxn], dfs_clock;
int st[maxn * 2], top;
bool ok[maxn];
vector<int> ans;
vector<int> temp;
int m, n;
inline void addEdge(int x, int y) {
tot++;
des[tot] = y;
nxt[tot] = first[x];
first[x] = tot;
}
void input() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d%d", &u, &v);
addEdge(u, v);
addEdge(v, u);
}
}
void dfs(int u, int fa) {
dfn[u] = low[u] = ++dfs_clock;
for (int t = first[u]; t; t = nxt[t]) {
int v = des[t];
if (v == fa) continue;
if (!dfn[v]) {
st[top++] = t;
dfs(v, u);
low[u] = min(low[u], low[v]);
if (low[v] >= dfn[u]) {
bcc_cnt++;
ok[bcc_cnt] = true;
temp.clear();
while (true) {
int tt = st[--top];
temp.push_back((tt + 1) / 2);
if (bcc_no[des[tt]] != bcc_cnt) {
bcc_no[des[tt]] = bcc_cnt;
cnt_n[bcc_cnt]++;
} else {
ok[bcc_cnt] = false;
}
cnt_e[bcc_cnt]++;
if (tt == t) {
break;
}
}
if (ok[bcc_cnt] && temp.size() > 1) {
for (int i = 0; i < temp.size(); i++) {
ans.push_back(temp[i]);
}
}
}
} else if (dfn[v] < dfn[u]) {
st[top++] = t;
low[u] = min(low[u], dfn[v]);
}
}
}
void solve() {
for (int i = 1; i <= n; i++) {
if (!dfn[i]) dfs(i, -1);
}
sort(ans.begin(), ans.end());
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++) {
printf("%d ", ans[i]);
}
}
int main() {
input();
solve();
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
using namespace std;
const int N = 1e6 + 10;
const long long mod = 1e9 + 7;
const long long mod2 = 998244353;
const long long inf = 8e18;
const int LOG = 22;
long long pw(long long a, long long b, long long M) {
return (!b ? 1
: (b & 1 ? (a * pw(a * a % M, b / 2, M)) % M
: pw(a * a % M, b / 2, M)));
}
int n, m, par[N], sz[N], H[N], mark[N], Mn[N];
vector<pair<int, int> > G[N];
int get(int x) { return ((x == par[x]) ? x : par[x] = get(par[x])); }
void unify(int v, int u) {
v = get(v), u = get(u);
if (v == u) return;
if (sz[u] > sz[v]) swap(u, v);
par[u] = v;
sz[v] += sz[u];
}
void dfs(int v, int P = 0, int last = 0) {
Mn[v] = H[v] = H[P] + 1;
mark[v] = 1;
for (auto y : G[v]) {
int u = y.first, id = y.second;
if (u == P || (mark[u] == 1 && H[u] >= H[v])) continue;
if (mark[u]) {
Mn[v] = min(Mn[v], H[u]);
sz[get(id)]++;
unify(id, last);
} else {
dfs(u, v, id);
Mn[v] = min(Mn[v], Mn[u]);
if (Mn[u] <= H[P]) unify(id, last);
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int a, b;
scanf("%d%d", &a, &b);
G[a].push_back(make_pair(b, i));
G[b].push_back(make_pair(a, i));
}
for (int i = 1; i <= m; i++) {
par[i] = i;
}
for (int i = 1; i <= n; i++) {
if (!mark[i]) {
dfs(i);
}
}
vector<int> tot;
for (int i = 1; i <= m; i++) {
if (sz[get(i)] == 1) tot.push_back(i);
}
printf("%d\n", (int)tot.size());
for (auto x : tot) {
printf("%d ", x);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct wf {
int to, nxt;
} edge[100005 << 1];
int h[100005], vis[100005], is_top[200005], st[200005];
int val[100005], dep[100005], whe[200005], fa[100005];
int n, m, cnt, pos, flag, top;
void add(int u, int v) {
edge[++cnt].nxt = h[u];
edge[cnt].to = v;
h[u] = cnt;
}
void dfs(int u, int ff, int dd) {
dep[u] = dd;
fa[u] = ff;
vis[u] = 1;
for (int i = h[u]; i != -1; i = edge[i].nxt) {
int v = edge[i].to;
if (!vis[v]) is_top[i] = 1, whe[v] = i, dfs(v, u, dd + 1);
}
}
void DFS(int u) {
vis[u] = 1;
for (int i = h[u]; i != -1; i = edge[i].nxt) {
int v = edge[i].to;
if (is_top[i]) DFS(v), val[u] += val[v];
}
}
int main() {
cnt = -1;
scanf("%d%d", &n, &m);
int u, v;
memset(edge, -1, sizeof(edge));
memset(h, -1, sizeof(h));
for (int i = 1; i <= m; i++) {
scanf("%d%d", &u, &v);
add(u, v);
add(v, u);
}
for (int i = 1; i <= n; i++)
if (!vis[i]) {
dfs(i, 0, 1);
}
for (int i = 0; i <= cnt; i += 2)
if (is_top[i] == 0 && is_top[i + 1] == 0) {
int u = edge[i].to;
int v = edge[i + 1].to;
if (dep[v] > dep[u]) swap(u, v);
++val[u];
--val[v];
}
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= n; i++)
if (!vis[i]) DFS(i);
for (int i = 0; i <= cnt; i += 2)
if (is_top[i] == 0 && is_top[i + 1] == 0) {
flag = 0;
int u = edge[i].to;
int v = edge[i + 1].to;
if (dep[v] > dep[u]) swap(u, v);
pos = u;
while (1) {
if (fa[pos] == v) break;
if (val[pos] != 1) {
flag = 1;
break;
}
pos = fa[pos];
}
if (val[pos] == 1 && flag == 0) {
st[++top] = i + 2 >> 1;
while (u != v) {
st[++top] = whe[u] + 2 >> 1;
u = fa[u];
}
}
}
printf("%d\n", top);
sort(st + 1, st + top + 1);
for (int i = 1; i <= top; i++) printf("%d ", st[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int N = 2e5 + 10;
int g[N], v[N << 1], nxt[N << 1], ed;
int dfn[N], low[N], q[N], cut[N], t, sub, num;
int al;
void add(int x, int y) { v[++ed] = y, nxt[ed] = g[x], g[x] = ed; }
vector<int> scc[N];
void ADD(int id, int x) { scc[id].push_back(x); }
map<pair<int, int>, int> mp;
set<int> s;
void tarjan(int x, int f) {
dfn[x] = low[x] = ++num, q[++t] = x;
for (int i = g[x]; i; i = nxt[i])
if (!dfn[v[i]]) {
int y = v[i];
tarjan(y, x);
if (low[x] > low[y]) low[x] = low[y];
if (!f) sub++;
if (dfn[x] <= low[y] && f || !f && sub > 1) {
cut[x] = 1;
s.clear();
ADD(++al, x);
s.insert(x);
while (1) {
int z = q[t--];
ADD(al, z);
for (int j = g[z]; j; j = nxt[j]) {
int to = v[j];
if (s.count(to)) {
if (to < z)
mp[{to, z}] = al;
else
mp[{z, to}] = al;
}
}
s.insert(z);
if (z == y) break;
}
}
} else if (low[x] > dfn[v[i]])
low[x] = dfn[v[i]];
}
pair<int, int> e[N];
int cnt[N], vis[N];
int main() {
std::ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int n, m;
cin >> n >> m;
for (int i = 1, x, y; i <= m; i++) {
cin >> x >> y;
e[i].first = x;
e[i].second = y;
add(x, y);
add(y, x);
}
for (int i = 1; i <= n; i++)
if (!dfn[i]) {
sub = 0, tarjan(i, 0);
if (t) {
al++;
s.clear();
while (t) {
int x = q[t];
ADD(al, q[t--]);
for (int j = g[x]; j; j = nxt[j]) {
int to = v[j];
if (s.count(to)) {
if (x < to)
mp[{x, to}] = al;
else
mp[{to, x}] = al;
}
}
s.insert(x);
}
}
}
for (int i = 1; i <= m; i++) {
int x = e[i].first, y = e[i].second;
if (x > y) swap(x, y);
cnt[mp[{x, y}]]++;
}
vector<int> res;
for (int i = 1; i <= m; i++) {
int x = e[i].first, y = e[i].second;
if (y < x) swap(x, y);
int sc = mp[{x, y}];
if (cnt[sc] == (int)scc[sc].size()) res.push_back(i);
}
cout << (int)res.size() << '\n';
for (int it : res) cout << it << ' ';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = (int)1e9 + 7;
const int maxn = (int)1e5 + 10;
const long long int inf = std::numeric_limits<long long int>::max();
vector<pair<int, int> > adj[maxn];
pair<int, int> parent[maxn];
int dp1[maxn], lvl[maxn], dp2[maxn], root;
vector<int> ans;
void dfs(int u) {
for (auto e : adj[u]) {
int v, id;
tie(v, id) = e;
if (v == parent[u].first) continue;
if (lvl[v] != 0 && lvl[v] < lvl[u]) {
dp1[v]--;
dp1[u]++;
} else if (lvl[v] == 0) {
lvl[v] = lvl[u] + 1;
parent[v] = {u, id};
dfs(v);
dp1[u] += dp1[v];
}
}
}
void dfs2(int u, vector<int> &acum) {
int pos = acum.size();
acum.push_back(dp1[u] + (acum.empty() ? 0 : acum.back()));
for (auto e : adj[u]) {
int v, id;
tie(v, id) = e;
if (v == parent[u].first) continue;
if (lvl[v] != 0 && lvl[v] < lvl[u]) {
int dif = lvl[u] - lvl[v];
assert(pos - dif >= 0);
int cuantas = acum[pos] - acum[pos - dif];
if (cuantas == dif) {
ans.push_back(id);
dp2[v]--;
dp2[u]++;
}
} else if (lvl[v] == 0) {
lvl[v] = lvl[u] + 1;
parent[v] = {u, id};
dfs2(v, acum);
dp2[u] += dp2[v];
}
}
if (u != root && dp2[u] == 1) {
ans.push_back(parent[u].second);
}
acum.pop_back();
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
adj[u].push_back({v, i});
adj[v].push_back({u, i});
}
for (int i = 1; i <= n; i++) {
if (lvl[i] == 0) {
root = i;
lvl[i] = 1;
dfs(i);
}
}
for (int i = 1; i <= n; i++) {
lvl[i] = 0;
parent[i] = {0, 0};
}
vector<int> aux, aux2;
for (int i = 1; i <= n; i++) {
if (lvl[i] == 0) {
root = i;
lvl[i] = 1;
aux.clear();
dfs2(i, aux);
}
}
sort((ans).begin(), (ans).end());
cout << ans.size() << '\n';
for (int x : ans) cout << x << " ";
cout << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int inf_ = 0x7fffffff;
const long long inff = 4557430888798830399ll;
const double pi = acos(-1.0);
long long mod = 1e9 + 7;
unordered_map<int, int> id[100005];
struct DCC {
DCC() { init(0, 0); }
int n, t, h, m, dfn[100005], low[100005], s[100005], e[100005], g[100005];
vector<int>*N, cut, D[100005], F[100005];
bool mark[100005];
void init(int _n, vector<int>* _N) {
n = _n;
N = _N;
t = h = -1;
m = 0;
memset(dfn, 0, sizeof(dfn));
memset(low, 0, sizeof(low));
memset(mark, 0, sizeof(mark));
cut.clear();
}
void dfs(int u, int d, int p) {
int sec = 0, son = d > 1, e;
dfn[u] = low[u] = d;
s[++t] = u;
for (auto v : N[u]) {
if (!mark[e = id[u][v]]) g[++h] = e, mark[e] = 1;
if (!dfn[v]) {
dfs(v, d + 1, u);
low[u] = min(low[u], low[v]);
if (low[v] >= dfn[u]) {
if (++son == 2) cut.push_back(u);
m += 1;
D[m].clear();
D[m].push_back(u);
F[m].clear();
do F[m].push_back(g[h]);
while (g[h--] != e);
do D[m].push_back(s[t]);
while (s[t--] != v);
}
} else if (v != p || sec++)
low[u] = min(low[u], dfn[v]);
}
}
void run() {
for (int i = (1); i <= (n); ++i)
if (!dfn[i]) dfs(i, 1, 0);
gen();
}
void gen() {
vector<int> z;
for (int i = (1); i <= (m); ++i)
if (((int)F[i].size()) == ((int)D[i].size()) && ((int)D[i].size()) > 2)
for (auto e : F[i]) z.push_back(e);
sort((z).begin(), (z).end());
z.erase(unique((z).begin(), (z).end()), z.end());
cout << ((int)z.size()) << endl;
for (int i = (0); i < (((int)z.size())); ++i)
cout << z[i] << " \n"[i == ((int)z.size()) - 1];
}
};
vector<int> N[100005];
DCC t;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m, u, v;
cin >> n >> m;
for (int i = (1); i <= (m); ++i) {
cin >> u >> v;
N[u].push_back(v);
N[v].push_back(u);
id[u][v] = id[v][u] = i;
}
t.init(n, N);
t.run();
}
|
#include <bits/stdc++.h>
const int N = 100005;
int n, m, cnt, last[N], num[N], dep[N], s[N], f[N], g[N], fa[N];
bool vis[N];
struct edge {
int to, next;
bool tag;
} e[N * 2];
int find(int x) {
if (f[x] == x)
return x;
else
return f[x] = find(f[x]);
}
void addedge(int u, int v) {
e[++cnt].to = v;
e[cnt].next = last[u];
last[u] = cnt;
e[++cnt].to = u;
e[cnt].next = last[v];
last[v] = cnt;
}
void dfs1(int x) {
vis[x] = 1;
dep[x] = dep[fa[x]] + 1;
for (int i = last[x]; i; i = e[i].next) {
if (e[i].to == fa[x]) continue;
if (!vis[e[i].to])
fa[e[i].to] = x, num[e[i].to] = i, dfs1(e[i].to);
else if (dep[e[i].to] < dep[x])
s[x]++, s[e[i].to]--;
}
}
void dfs2(int x) {
vis[x] = 1;
for (int i = last[x]; i; i = e[i].next) {
if (e[i].to == fa[x]) continue;
if (!vis[e[i].to]) dfs2(e[i].to), s[x] += s[e[i].to];
}
}
void dfs3(int x) {
vis[x] = 1;
g[x] = (s[x] > 1) + g[fa[x]];
for (int i = last[x]; i; i = e[i].next) {
if (e[i].to == fa[x]) continue;
if (!vis[e[i].to])
dfs3(e[i].to);
else if (dep[e[i].to] < dep[x] && g[x] - g[e[i].to] == 0) {
int y = find(x);
e[i].tag = e[i ^ 1].tag = 1;
while (dep[y] > dep[e[i].to]) {
e[num[y]].tag = e[num[y] ^ 1].tag = 1;
f[y] = find(fa[y]);
y = find(y);
}
}
}
}
int main() {
scanf("%d%d", &n, &m);
cnt = 1;
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
addedge(x, y);
}
for (int i = 1; i <= n; i++)
if (!vis[i]) dfs1(i);
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= n; i++)
if (!vis[i]) dfs2(i);
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= n; i++) f[i] = i;
for (int i = 1; i <= n; i++)
if (!vis[i]) dfs3(i);
int ans = 0;
for (int i = 2; i <= cnt; i += 2) ans += e[i].tag;
printf("%d\n", ans);
for (int i = 2; i <= cnt; i += 2)
if (e[i].tag) printf("%d ", i / 2);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 10;
int n, m, from[MAXN], to[MAXN], h[MAXN];
vector<int> adj[MAXN];
bool vis[MAXN];
void fix(int e) {
if (h[from[e]] > h[to[e]]) swap(from[e], to[e]);
}
bool better(int e1, int e2) {
if (e2 == -1) return true;
if (e1 == -1) return false;
fix(e1), fix(e2);
return h[from[e1]] < h[from[e2]];
}
void upd(pair<int, int> &a, int b) {
if (better(b, a.second)) {
a.second = b;
if (better(a.second, a.first)) swap(a.first, a.second);
}
}
pair<int, int> g[MAXN];
bool in[MAXN];
int c[MAXN];
pair<int, int> dfs(int v, int p) {
vis[v] = true;
pair<int, int> res(-1, -1);
for (int e : adj[v])
if (e ^ p) {
int u = from[e] ^ to[e] ^ v;
if (vis[u])
upd(res, e);
else {
h[u] = h[v] + 1;
auto x = dfs(u, e);
upd(res, x.first);
upd(res, x.second);
}
}
fix(res.second);
if (h[from[res.second]] >= h[v]) res.second = -1;
fix(res.first);
if (h[from[res.first]] >= h[v]) res.first = -1;
g[v] = res;
return res;
}
void dfs2(int v, int p) {
vis[v] = true;
c[v] += g[v].second != -1;
for (int e : adj[v]) {
int u = from[e] ^ to[e] ^ v;
if (!vis[u]) {
c[u] = c[v];
dfs2(u, v);
}
}
}
void dfs3(int v, int p) {
vis[v] = true;
for (int e : adj[v]) {
int u = from[e] ^ to[e] ^ v;
if (!vis[u]) {
in[e] = (g[u].first != -1 && in[g[u].first]);
dfs3(u, v);
}
}
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d %d", &from[i], &to[i]);
from[i]--, to[i]--;
adj[from[i]].push_back(i);
adj[to[i]].push_back(i);
}
for (int v = 0; v < n; v++)
if (!vis[v]) dfs(v, -1);
memset(vis, 0, sizeof(vis));
for (int v = 0; v < n; v++)
if (!vis[v]) dfs2(v, -1);
for (int e = 0; e < m; e++) {
fix(e);
if (h[from[e]] + 1 != h[to[e]]) in[e] = (c[to[e]] - c[from[e]] == 0);
}
memset(vis, 0, sizeof(vis));
for (int v = 0; v < n; v++)
if (!vis[v]) dfs3(v, -1);
int t = 0;
for (int e = 0; e < m; e++)
if (in[e]) t++;
printf("%d\n", t);
for (int e = 0; e < m; e++)
if (in[e]) printf("%d ", e + 1);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
class Graph {
public:
struct edge {
edge()
: u(-1),
v(-1),
w(0),
index(-1),
deleted(false),
bi_edge(false),
ctx(0) {}
edge(int _u, int _v, int _w, int _index, int _bi_edge, int _ctx)
: u(_u),
v(_v),
w(_w),
index(_index),
deleted(false),
bi_edge(_bi_edge),
ctx(_ctx) {}
int u;
int v;
int w;
int index;
bool deleted;
bool bi_edge;
int ctx;
bool existed() { return !deleted; }
int to(int _u) {
if (!bi_edge) {
return v;
} else {
return _u == u ? v : u;
}
}
};
Graph(int _n, bool _need_unique_edge = false)
: n(_n),
need_unique_edge(_need_unique_edge),
need_count_edge(false),
support_circle_edge(false) {
g.resize(n);
for (int i = 0; i < n; i++) {
g[i].reserve(5);
}
edges.reserve(n * 2);
edge_count.resize(n);
}
void SetUseRepeatEdge(bool use) {
if (use) {
need_count_edge = true;
need_unique_edge = false;
} else {
need_count_edge = false;
need_unique_edge = true;
}
}
void SetSupportCircleEdge(bool support) { support_circle_edge = support; }
bool CheckNeedAdd(int u, int v) {
assert(u < n);
assert(v < n);
if (!support_circle_edge) {
if (u == v) {
return false;
}
}
if (need_unique_edge) {
if (edge_count[u][v] > 0) {
return false;
}
}
return true;
}
void AddEdge(int u, int v, int w = 0, int ctx = 0) {
int edge_index = (int)edges.size();
edges.push_back(edge(u, v, w, edge_index, false, ctx));
if (!CheckNeedAdd(u, v)) {
return;
}
if (need_unique_edge || need_count_edge) {
edge_count[u][v]++;
}
g[u].push_back(edge_index);
}
void AddBiEdge(int u, int v, int w = 0, int ctx = 0) {
int edge_index = (int)edges.size();
edges.push_back(edge(u, v, w, edge_index, true, ctx));
if (!CheckNeedAdd(u, v)) {
return;
}
if (need_unique_edge || need_count_edge) {
edge_count[u][v]++;
if (u != v) {
edge_count[v][u]++;
}
}
g[u].push_back(edge_index);
if (u != v) {
g[v].push_back(edge_index);
}
}
void SetEdgeDeleted(int edge_index, bool deleted) {
if (edge_index >= (int)edges.size()) {
return;
}
auto& e = edges[edge_index];
if (e.deleted != deleted) {
e.deleted = deleted;
if (need_count_edge) {
int delta = deleted ? -1 : 1;
edge_count[e.u][e.v] += delta;
if (e.bi_edge && e.u != e.v) {
edge_count[e.v][e.u] += delta;
}
}
}
}
void RandEdge() {
for (auto& es : g) {
random_shuffle(es.begin(), es.end());
}
}
public:
int Tarjan_VBCC(vector<int>& cut_vertices, vector<int>& edge_component);
public:
int n;
vector<vector<int>> g;
vector<edge> edges;
vector<map<int, int>> edge_count;
bool need_unique_edge;
bool need_count_edge;
bool support_circle_edge;
};
int Graph ::Tarjan_VBCC(vector<int>& cut_vertices,
vector<int>& edge_component) {
edge_component.resize(edges.size(), -1);
vector<int> dfn(n, 0);
vector<int> low(n, 0);
vector<bool> visited(n, false);
stack<int> s;
function<void(int, int)> dfs;
int visit_index = 0;
int component_index = 0;
dfs = [&](int u, int parent) {
dfn[u] = low[u] = visit_index++;
visited[u] = true;
int found_cp_count = 0;
for (auto ei : g[u]) {
auto& e = edges[ei];
if (!e.existed()) continue;
int v = e.to(u);
if (!visited[v]) {
s.push(e.index);
dfs(v, u);
low[u] = min(low[u], low[v]);
if (low[v] >= dfn[u]) {
found_cp_count++;
while (!s.empty()) {
auto edge_index = s.top();
s.pop();
edge_component[edge_index] = component_index;
if (edge_index == e.index) {
break;
}
}
component_index++;
}
} else if (v != parent) {
if (dfn[v] < dfn[u]) {
s.push(e.index);
}
low[u] = min(low[u], dfn[v]);
}
}
if ((parent != -1 && found_cp_count > 0) || found_cp_count > 1) {
cut_vertices.push_back(u);
}
};
for (int u = 0; u < n; u++) {
if (!visited[u]) {
dfs(u, -1);
}
}
return component_index;
}
void Solve() {
int n, m;
cin >> n >> m;
Graph g(n);
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
g.AddBiEdge(u - 1, v - 1);
}
vector<int> cut_vertices;
vector<int> edge_component;
int component_count = g.Tarjan_VBCC(cut_vertices, edge_component);
vector<set<int>> component_vertex_count(component_count);
vector<int> component_edge_count(component_count);
for (int ei = 0; ei < m; ei++) {
component_edge_count[edge_component[ei]]++;
auto& e = g.edges[ei];
component_vertex_count[edge_component[ei]].insert(e.u);
component_vertex_count[edge_component[ei]].insert(e.v);
}
vector<int> ans;
for (int ei = 0; ei < m; ei++) {
auto cp = edge_component[ei];
if (component_vertex_count[cp].size() == component_edge_count[cp]) {
ans.push_back(ei + 1);
}
}
printf("%d\n", (int)ans.size());
for (auto v1 : ans) printf("%d ", (int)v1);
;
}
int main(int argc, char** argv) {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int t = 1;
while (t--) {
Solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
const long long mod = 1e9 + 7;
const long long inf = 1e18 + 10;
int mark[N], h[N], f[N], g[N], ps[N], res[N];
vector<pair<int, int> > adj[N];
void dfs0(int v) {
mark[v] = 1;
for (pair<int, int> e : adj[v]) {
int u = e.first;
if (!mark[u])
h[u] = h[v] + 1, dfs0(u);
else if (h[v] < h[u])
f[u]++, f[v]--;
}
}
void dfs1(int v) {
mark[v] = 1;
for (pair<int, int> e : adj[v])
if (!mark[e.first]) dfs1(e.first), f[v] += f[e.first];
}
void dfs2(int v) {
mark[v] = 1;
ps[v] += (2 <= f[v]);
for (pair<int, int> e : adj[v])
if (!mark[e.first]) ps[e.first] = ps[v], dfs2(e.first);
}
void dfs3(int v) {
mark[v] = 1;
for (pair<int, int> e : adj[v]) {
int u = e.first;
if (!mark[u])
dfs3(u);
else if (h[v] < h[u] && 1 <= ps[u] - ps[v])
g[u]++, g[v]--;
}
}
void dfs4(int v) {
mark[v] = 1;
for (pair<int, int> e : adj[v])
if (!mark[e.first]) dfs4(e.first), g[v] += g[e.first];
}
void dfs5(int v) {
mark[v] = 1;
for (pair<int, int> e : adj[v]) {
int u = e.first, id = e.second;
if (!mark[u])
dfs5(u), res[id] = (f[u] == 1 && g[u] == 0);
else if (h[v] < h[u])
res[id] = (f[u] == 1 && g[u] == 0);
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
adj[u].push_back(make_pair(v, i));
adj[v].push_back(make_pair(u, i));
}
for (int i = 1; i <= n; i++)
if (!mark[i]) dfs0(i);
memset(mark, 0, sizeof mark);
for (int i = 1; i <= n; i++)
if (!mark[i]) dfs1(i);
memset(mark, 0, sizeof mark);
for (int i = 1; i <= n; i++)
if (!mark[i]) dfs2(i);
memset(mark, 0, sizeof mark);
for (int i = 1; i <= n; i++)
if (!mark[i]) dfs3(i);
memset(mark, 0, sizeof mark);
for (int i = 1; i <= n; i++)
if (!mark[i]) dfs4(i);
memset(mark, 0, sizeof mark);
for (int i = 1; i <= n; i++)
if (!mark[i]) dfs5(i);
int cnt = 0;
for (int i = 1; i <= m; i++)
if (res[i]) cnt++;
cout << cnt << '\n';
for (int i = 1; i <= m; i++)
if (res[i]) cout << i << ' ';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long maxn = 1e5 + 7;
const long long maxm = 2e5 + 7;
int low[maxn], tin[maxn], head[maxm], vis[maxn * 2];
int cnt = 0, times = 0, totn = 0;
set<int> ans;
struct EDGE {
int to, next, id;
} p[maxm * 2];
stack<int> Skeg;
void add(int u, int v, int i) {
p[cnt].to = v;
p[cnt].next = head[u];
p[cnt].id = i;
head[u] = cnt++;
}
void tarjan(int k, int fa) {
low[k] = tin[k] = ++times;
int v;
for (int i = head[k]; i != -1; i = p[i].next) {
v = p[i].to;
if (v == fa) continue;
if (vis[i]) continue;
vis[i] = vis[i ^ 1] = 1;
Skeg.push(i);
if (!tin[v]) {
tarjan(v, k);
low[k] = min(low[k], low[v]);
if (low[v] >= tin[k]) {
totn++;
int t;
set<int> ve, eg;
ve.insert(k);
do {
t = Skeg.top();
Skeg.pop();
ve.insert(p[t].to);
eg.insert(p[t].id);
} while (t != i);
if (ve.size() == eg.size()) {
ans.insert(eg.begin(), eg.end());
}
}
} else if (tin[v] < tin[k]) {
low[k] = min(low[k], tin[v]);
}
}
}
int main() {
memset(head, -1, sizeof(head));
int n, m, u, v;
scanf("%d", &n);
scanf("%d", &m);
for (register int i = 1; i <= m; i = i + 1) {
scanf("%d", &u);
scanf("%d", &v);
add(u, v, i);
add(v, u, i);
}
for (register int i = 1; i <= n; i = i + 1) {
if (!tin[i]) tarjan(i, -1);
}
printf("%d", ans.size());
printf("\n");
;
for (auto i : ans) {
printf("%d", i);
printf("%s", " ");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
int n, m, h[N], num = 1, dfn[N], low[N], timer = 0, bcc = 0, sz[N], ans = 0;
bool f[N], used[N];
struct edge {
int to, next;
};
edge data[N << 1];
vector<int> a[N];
stack<int> vstack;
stack<int> estack;
inline void tarjan(int x) {
dfn[x] = low[x] = ++timer;
vstack.push(x);
for (int i = h[x]; i != 0; i = data[i].next) {
int y = data[i].to;
if (used[i >> 1]) continue;
used[i >> 1] = true;
estack.push(i >> 1);
if (!dfn[y]) {
tarjan(y);
low[x] = min(low[x], low[y]);
if (low[y] < dfn[x]) continue;
++bcc;
while (true) {
int z = vstack.top();
vstack.pop();
sz[bcc]++;
if (z == y) break;
}
sz[bcc]++;
while (1) {
int j = estack.top();
estack.pop();
a[bcc].push_back(j);
if (j == (i >> 1)) break;
}
continue;
}
low[x] = min(low[x], dfn[y]);
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
data[++num].to = y;
data[num].next = h[x];
h[x] = num;
data[++num].to = x;
data[num].next = h[y];
h[y] = num;
}
for (int i = 1; i <= n; i++)
if (!dfn[i]) tarjan(i), vstack.pop();
for (int i = 1; i <= bcc; i++) {
if (sz[i] != a[i].size()) continue;
for (int j = 0; j < a[i].size(); j++) f[a[i][j]] = 1, ++ans;
}
printf("%d\n", ans);
for (int i = 1; i <= m; i++)
if (f[i]) printf("%d ", i);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 100005;
int read() {
int x = 0, f = 1;
char c;
while ((c = getchar()) < '0' || c > '9') {
if (c == '-') f = -1;
}
while (c >= '0' && c <= '9') {
x = (x << 3) + (x << 1) + (c ^ 48);
c = getchar();
}
return x * f;
}
int n, m, tot, Index, cnt, top, f[M], dfn[M], low[M], st[3 * M];
set<int> nd[M], eg[M], ans;
struct edge {
int v, next;
} e[2 * M];
void dfs(int u, int p) {
dfn[u] = low[u] = ++Index;
for (int i = f[u]; i; i = e[i].next) {
int v = e[i].v;
if (v == p) continue;
if (!dfn[v]) {
st[++top] = i >> 1;
st[++top] = u;
st[++top] = v;
dfs(v, u);
low[u] = min(low[u], low[v]);
if (low[v] >= dfn[u]) {
cnt++;
while (1) {
int t1 = st[top--], t2 = st[top--];
nd[cnt].insert(t1);
nd[cnt].insert(t2);
eg[cnt].insert(st[top--]);
if (t1 == v && t2 == u) break;
}
}
} else if (dfn[v] < dfn[u]) {
st[++top] = i >> 1;
st[++top] = u;
st[++top] = v;
low[u] = min(low[u], dfn[v]);
}
}
}
signed main() {
n = read();
m = read();
tot = 1;
for (int i = 1; i <= m; i++) {
int u = read(), v = read();
e[++tot] = edge{v, f[u]}, f[u] = tot;
e[++tot] = edge{u, f[v]}, f[v] = tot;
}
for (int i = 1; i <= n; i++)
if (!dfn[i]) dfs(i, 0);
for (int i = 1; i <= cnt; i++) {
if (eg[i].size() == nd[i].size()) ans.insert(eg[i].begin(), eg[i].end());
}
printf("%d\n", ans.size());
for (set<int>::iterator i = ans.begin(); i != ans.end(); i++)
printf("%d ", *i);
}
|
#include <bits/stdc++.h>
#pragma GCC optimize "-O3"
using namespace std;
const int MAXN = 120000;
int was[MAXN];
vector<pair<int, int>> eds[MAXN];
vector<int> go[MAXN];
int pe[MAXN];
int p[MAXN];
int h[MAXN];
int ad[MAXN];
vector<pair<int, int>> vv;
int cc[MAXN];
int n, m;
int dfs1(int v) {
int cur = 0;
was[v] = 1;
for (auto e : eds[v]) {
int u = e.first;
if (was[u]) {
if (h[u] < h[v] - 1) {
--ad[u];
vv.push_back(make_pair(v, u));
go[v].push_back(e.second);
++cur;
}
} else {
h[u] = h[v] + 1;
p[u] = v;
pe[u] = e.second;
cur += dfs1(u);
}
}
cur += ad[v];
if (h[v] != 0) {
cc[pe[v]] = cur;
}
return cur;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int a, b;
cin >> a >> b;
--a, --b;
eds[a].push_back(make_pair(b, i));
eds[b].push_back(make_pair(a, i));
}
for (int i = 0; i < n; ++i)
if (!was[i]) dfs1(i);
vector<int> ans;
for (auto e : vv) {
int a, b;
tie(a, b) = e;
int fl = 0;
while (a != b) {
if (cc[pe[a]] != 1) {
fl = 1;
break;
}
a = p[a];
}
if (!fl) {
tie(a, b) = e;
ans.push_back(go[a][0]);
while (a != b) {
ans.push_back(pe[a]);
a = p[a];
}
}
}
sort(ans.begin(), ans.end());
cout << ans.size() << "\n";
for (int i : ans) cout << i + 1 << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
const int MAXN = 100000;
const int MAXM = 100000;
const int MAXCOMP = MAXN;
int n, m;
vector<int> adj[MAXN];
map<pair<int, int>, int> emp;
bool res[MAXM];
int ret[MAXM], nret;
int ncomp;
vector<int> comps[MAXN];
vector<int> compnodes[MAXCOMP];
vector<pair<int, int> > compedges[MAXCOMP];
bool done[MAXN];
int id[MAXN], mnid[MAXN], nid;
int nodestck[MAXN], nnodestck;
pair<int, int> edgestck[2 * MAXM];
int nedgestck;
void dfs(int at, int par) {
id[at] = mnid[at] = nid++;
nodestck[nnodestck++] = at;
for (int i = (0); i < (((int)(adj[at]).size())); ++i) {
int to = adj[at][i];
if (!done[to]) edgestck[nedgestck++] = make_pair(at, to);
if (to == par) continue;
if (id[to] == -1) {
dfs(to, at);
mnid[at] = min(mnid[at], mnid[to]);
} else {
mnid[at] = min(mnid[at], id[to]);
}
}
if (par != -1 && mnid[at] >= id[par] ||
par == -1 && ((int)(adj[at]).size()) == 0) {
int c = ncomp++;
compnodes[c].clear(), compedges[c].clear();
while (!done[at]) {
int u = nodestck[--nnodestck];
comps[u].push_back(c);
compnodes[c].push_back(u);
done[u] = true;
}
if (par != -1) comps[par].push_back(c), compnodes[c].push_back(par);
if (par != -1)
while (true) {
pair<int, int> e = edgestck[--nedgestck];
compedges[c].push_back(e);
if (e.first != at && e.second == par)
compedges[c].push_back(make_pair(e.second, e.first));
if (e.first == par && e.second == at) break;
}
}
}
void run() {
scanf("%d%d", &n, &m);
for (int i = (0); i < (m); ++i) {
int a, b;
scanf("%d%d", &a, &b);
--a, --b;
adj[a].push_back(b);
adj[b].push_back(a);
emp[make_pair(min(a, b), max(a, b))] = i;
}
ncomp = 0, nid = 0, nnodestck = 0, nedgestck = 0;
for (int i = (0); i < (n); ++i) id[i] = -1, comps[i].clear(), done[i] = false;
for (int i = (0); i < (n); ++i)
if (!done[i]) dfs(i, -1);
for (int i = (0); i < (m); ++i) res[i] = false;
for (int i = (0); i < (ncomp); ++i) {
if (((int)(compnodes[i]).size()) == 1) {
assert(((int)(compedges[i]).size()) == 0);
continue;
}
if (((int)(compnodes[i]).size()) == 2) {
assert(((int)(compedges[i]).size()) == 2);
continue;
}
if (((int)(compnodes[i]).size()) >= 3 &&
((int)(compedges[i]).size()) == ((int)(compnodes[i]).size()) * 2) {
for (int j = (0); j < (((int)(compedges[i]).size())); ++j) {
int a = compedges[i][j].first, b = compedges[i][j].second;
if (a >= b) continue;
assert(emp.count(make_pair(a, b)));
res[emp[make_pair(a, b)]] = true;
}
}
}
nret = 0;
for (int i = (0); i < (m); ++i)
if (res[i]) ret[nret++] = i;
printf("%d\n", nret);
for (int i = (0); i < (nret); ++i) {
if (i != 0) printf(" ");
printf("%d", ret[i] + 1);
}
puts("");
}
int main() {
run();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
int disc[MAXN], low[MAXN];
vector<int> adj[MAXN];
stack<pair<int, int> > S;
vector<vector<pair<int, int> > > allcomponent;
map<pair<int, int>, int> urutan;
void dfs(int now, int par) {
disc[now] = low[now] = disc[par] + 1;
for (auto nxt : adj[now]) {
if (nxt == par) continue;
if (disc[now] > disc[nxt]) S.push({now, nxt});
if (disc[nxt] != 0)
low[now] = min(low[now], disc[nxt]);
else {
dfs(nxt, now);
low[now] = min(low[now], low[nxt]);
if (low[nxt] >= disc[now]) {
vector<pair<int, int> > component;
while (!S.empty() && (S.top().first != now || S.top().second != nxt)) {
component.push_back(S.top());
S.pop();
}
component.push_back(S.top());
S.pop();
allcomponent.push_back(component);
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m, u, v;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
urutan[{u, v}] = i;
urutan[{v, u}] = i;
}
for (int i = 1; i <= n; i++)
if (disc[i] == 0) dfs(i, 0);
vector<int> ans;
for (auto isi : allcomponent) {
set<int> node;
for (auto edge : isi) {
node.insert(edge.first);
node.insert(edge.second);
}
if (node.size() == isi.size()) {
for (auto edge : isi) ans.push_back(urutan[edge]);
}
}
sort(ans.begin(), ans.end());
ans.erase(unique(ans.begin(), ans.end()), ans.end());
cout << ans.size() << '\n';
for (auto isi : ans) cout << isi << " ";
cout << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1234567;
inline int read() {
int p = 0;
int f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
p = p * 10 + ch - '0';
ch = getchar();
}
return p * f;
}
struct node {
int x, y, next;
} edge[N];
int len, first[N];
void ins(int x, int y) {
len++;
edge[len].x = x;
edge[len].y = y;
edge[len].next = first[x];
first[x] = len;
}
int dfn[N], low[N], id = 0, cnt = 0;
stack<int> s;
int n, m;
vector<int> scc[N];
int bel[N];
void dfs(int x) {
dfn[x] = low[x] = ++id;
s.push(x);
for (int k = first[x]; k != -1; k = edge[k].next) {
int y = edge[k].y;
if (dfn[y] == -1) {
dfs(y);
low[x] = min(low[x], low[y]);
if (low[y] >= dfn[x]) {
cnt++;
scc[cnt].push_back(x);
int i;
do {
i = s.top();
scc[cnt].push_back(i);
bel[i] = cnt;
s.pop();
} while (i != y);
}
} else
low[x] = min(low[x], dfn[y]);
}
}
vector<int> siz[N];
vector<int> v;
int main() {
len = 1;
memset(first, -1, sizeof(first));
n = read();
m = read();
for (int i = 1; i <= m; i++) {
int x = read();
int y = read();
ins(x, y);
ins(y, x);
}
memset(dfn, -1, sizeof(dfn));
memset(low, -1, sizeof(low));
cnt = 0;
for (int i = 1; i <= n; i++)
if (dfn[i] == -1) {
while (!s.empty()) s.pop();
dfs(i);
}
for (int i = 2; i <= len; i += 2) {
int p = dfn[edge[i].x] > dfn[edge[i].y] ? edge[i].x : edge[i].y;
siz[bel[p]].push_back(i / 2);
}
for (int i = 1; i <= cnt; i++) {
if (scc[i].size() == siz[i].size())
for (auto j : siz[i]) v.push_back(j);
}
printf("%d\n", v.size());
sort(v.begin(), v.end());
for (int i = 0; i < v.size(); i++)
printf("%d%c", v[i], " \n"[i == v.size() - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename num_t>
inline void addmod(num_t& a, const long long& b, const int& m) {
a = (a + b) % m;
if (a < 0) a += m;
}
template <typename num_t>
inline void update_max(num_t& a, const num_t& b) {
a = max(a, b);
}
template <typename num_t>
inline void update_min(num_t& a, const num_t& b) {
a = min(a, b);
}
template <typename num_t>
num_t gcd(num_t lhs, num_t rhs) {
return !lhs ? rhs : gcd(rhs % lhs, lhs);
}
template <typename num_t>
num_t pw(num_t n, num_t k, num_t mod) {
long long res = 1;
for (; k; k >>= 1) {
if (k & 1) res = res * n % mod;
n = 1ll * n * n % mod;
}
return (num_t)res;
}
const int inf = 1e9 + 7;
const long long ll_inf = 1ll * inf * inf;
const int MAX_N = 100000 + 7;
const int mod = inf;
int n, m;
vector<pair<int, int>> adj[MAX_N];
bool tree_edge[MAX_N];
bool check[MAX_N];
int nxt[MAX_N];
class DisjoinSet {
public:
vector<int> r;
vector<int> cnt;
int component;
int nodes;
void init(int n) {
r.resize(n + 1);
cnt.resize(n + 1);
for (int j = 0; j < n + 1; ++j)
if (!tree_edge[j]) cnt[j] = 1;
fill(r.begin(), r.end(), -1);
component = nodes = n;
}
int get(int u) { return r[u] < 0 ? u : r[u] = get(r[u]); }
bool is_root(int u) {
assert(u >= 0 && r.size());
return u == get(u);
}
bool join(int u, int v) {
u = get(u);
v = get(v);
if (u == v) return false;
if (r[u] > r[v]) swap(u, v);
r[u] += r[v];
cnt[u] += cnt[v];
r[v] = u;
return true;
}
bool connected(int u, int v) { return get(u) == get(v); }
int build(const vector<pair<int, int>>& edges) {
component = nodes;
for (const auto& edge : edges) {
int u = edge.first;
int v = edge.second;
if (join(u, v)) {
--component;
}
}
for (const auto& edge : edges) {
int u = edge.first, v = edge.second;
r[u] = r[v] = -1;
}
return component;
}
} dsu;
int depth[MAX_N];
int parent_edge[MAX_N];
void dfs(int u) {
check[u] = true;
for (auto& p : adj[u])
if (!check[p.first]) {
tree_edge[p.second] = true;
int v = p.first;
nxt[v] = u;
depth[v] = depth[u] + 1;
parent_edge[v] = p.second;
dfs(v);
}
}
vector<pair<int, int>> edge;
void solve() {
cin >> n >> m;
for (int i = (0), _b = (m); i < _b; ++i) {
int u, v;
cin >> u >> v;
adj[u].push_back({v, i});
adj[v].push_back({u, i});
edge.push_back({u, v});
}
for (int i = 1; i <= n; ++i)
if (!nxt[i]) {
nxt[i] = -1;
dfs(i);
}
dsu.init(m);
for (int j = 0; j < m; ++j)
if (!tree_edge[j]) {
int u = edge[j].first, v = edge[j].second;
vector<int> temp;
while (u != v) {
if (depth[u] < depth[v]) swap(u, v);
dsu.join(parent_edge[u], j);
temp.push_back(u);
u = nxt[u];
}
for (auto x : temp) nxt[x] = u;
}
vector<int> ans;
for (int j = 0; j < m; ++j)
if (dsu.cnt[dsu.get(j)] == 1 && -dsu.r[dsu.get(j)] >= 3) {
ans.push_back(j + 1);
}
cout << ans.size() << '\n';
for (int x : ans) cout << x << ' ';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
const bool multiple_test = false;
int test = 1;
if (multiple_test) cin >> test;
for (int i = 0; i < test; ++i) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100010, MAXM = 500010;
vector<int> bcc[MAXN];
vector<int> ans[MAXN];
vector<int> ANS;
int low[MAXN], dfn[MAXN];
int head[MAXN], to[MAXM], NEXT[MAXM];
int id[MAXM];
int bccno[MAXN];
int sta[MAXN];
bool iscut[MAXN];
int cnt, top, tot = 1;
int bcccnt;
void make_list(int u, int v, int ID) {
NEXT[++tot] = head[u], head[u] = tot, to[tot] = v, id[tot] = ID;
}
void tarjan(int u, int f) {
low[u] = dfn[u] = ++cnt;
int ch = 0;
for (int p = head[u]; p; p = NEXT[p]) {
int v = to[p];
int e = p;
if (!dfn[v]) {
sta[top++] = e;
ch++;
tarjan(v, u);
low[u] = min(low[u], low[v]);
if (low[v] >= dfn[u]) {
iscut[u] = 1, bcc[++bcccnt].clear();
while (1) {
int x = sta[--top];
ans[bcccnt].push_back(id[x]);
if (bccno[to[x ^ 1]] != bcccnt)
bcc[bcccnt].push_back(to[x ^ 1]), bccno[to[x ^ 1]] = bcccnt;
if (bccno[to[x]] != bcccnt)
bcc[bcccnt].push_back(to[x]), bccno[to[x]] = bcccnt;
if (to[x ^ 1] == u && to[x] == v) break;
}
}
} else if (dfn[v] < dfn[u] && v != f)
sta[top++] = e, low[u] = min(low[u], dfn[v]);
}
if (f < 0 && ch == 1) iscut[u] = 0;
}
int main() {
int n, m;
int u, v;
cin >> n >> m;
for (int i = 1; i <= m; i++)
scanf("%d%d", &u, &v), make_list(u, v, i), make_list(v, u, i);
for (int i = 1; i <= n; i++)
if (!dfn[i]) tarjan(i, -1);
for (int i = 1; i <= bcccnt; i++) {
if (bcc[i].size() == ans[i].size())
for (int j : ans[i]) ANS.push_back(j);
}
cout << ANS.size() << endl;
sort(ANS.begin(), ANS.end());
for (int i : ANS) cout << i << ' ';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> ans;
int tmp, tp, a, b, u, v, n, m, to[500010], deep[500010], nxt[500010],
hd[500010], fa[100010], tofa[500010], num = -1, cf[500010];
bool tree[500010], vis[100010], flag;
void add(int u, int v) {
nxt[++num] = hd[u], to[num] = v, hd[u] = num;
nxt[++num] = hd[v], to[num] = u, hd[v] = num;
}
void dfs1(int pos, int f, int dp) {
fa[pos] = f;
vis[pos] = 1;
deep[pos] = dp;
for (int i = hd[pos]; i != -1; i = nxt[i]) {
if (!vis[to[i]]) {
tofa[to[i]] = i, tree[i] = 1;
dfs1(to[i], pos, dp + 1);
}
}
}
void dfs(int pos) {
vis[pos] = 1;
for (int i = hd[pos]; i != -1; i = nxt[i]) {
if (tree[i]) dfs(to[i]), cf[pos] += cf[to[i]];
}
}
int main() {
memset(hd, -1, sizeof hd);
memset(nxt, -1, sizeof nxt);
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &a, &b);
add(a, b);
}
for (int i = 1; i <= n; i++)
if (!vis[i]) dfs1(i, 0, 1);
for (int i = 0; i <= num; i += 2) {
if (tree[i] || tree[i + 1])
continue;
else
u = to[i], v = to[i + 1];
if (deep[u] < deep[v]) swap(u, v);
cf[u]++;
cf[v]--;
}
memset(vis, 0, sizeof vis);
for (int i = 1; i <= n; i++)
if (!vis[i]) dfs(i);
for (int i = 0; i <= num; i += 2) {
if (tree[i] || tree[i + 1])
continue;
else
u = to[i], v = to[i + 1];
if (deep[u] < deep[v]) swap(u, v);
flag = 0;
tmp = u;
for (; fa[tmp] != v; tmp = fa[tmp]) {
if (cf[tmp] != 1) {
flag = 1;
break;
}
}
if (!flag && cf[tmp] == 1) {
ans.push_back((i + 2) / 2);
while (u != v) {
ans.push_back((tofa[u] + 2) / 2);
u = fa[u];
}
}
}
sort(ans.begin(), ans.end());
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++) cout << ans[i] << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 15;
vector<int> graph[N];
int a[N], b[N];
set<int> bcc[N];
int dfn[N], low[N];
int piv = 1, par[N];
void dfs(int x, int p) {
dfn[x] = low[x] = ++piv;
par[x] = p;
for (int i = 0; i < graph[x].size(); i++) {
int id = graph[x][i];
int w = a[id] ^ b[id] ^ x;
if (w == p) continue;
if (!dfn[w]) {
dfs(w, x);
low[x] = min(low[x], low[w]);
} else {
low[x] = min(low[x], dfn[w]);
}
}
}
map<pair<int, int>, int> G;
bool ban[N], vis[N];
int cpiv = 1, maxi[N];
vector<int> Edge[N];
void color(int x, int c) {
if (c > 0) bcc[x].insert(c);
vis[x] = 1;
pair<int, int> temp;
for (int i = 0; i < graph[x].size(); i++) {
int id = graph[x][i];
int w = a[id] ^ b[id] ^ x;
if (vis[w]) {
continue;
}
if (dfn[x] <= low[w]) {
bcc[x].insert(++cpiv);
color(w, cpiv);
} else {
color(w, c);
}
}
}
int main() {
int n, m, x, y;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; ++i) {
scanf("%d%d", &a[i], &b[i]);
graph[a[i]].push_back(i);
graph[b[i]].push_back(i);
}
for (int i = 1; i <= n; ++i)
if (!dfn[i]) dfs(i, 0);
for (int i = 1; i <= n; ++i) {
if (!vis[i]) color(i, 0);
}
vector<int> ret;
for (int i = 1; i <= n; ++i) {
if (bcc[i].size() == 1) {
int color = *bcc[i].begin();
for (int j = 0; j < graph[i].size(); ++j) {
int id = graph[i][j];
int w = a[id] ^ b[id] ^ i;
if (bcc[w].count(color) &&
(bcc[w].size() >= 2 || (bcc[w].size() == 1 && i < w))) {
pair<int, int> temp = make_pair(w, color);
int C = ++G[temp];
maxi[color] = max(maxi[color], C);
temp = make_pair(i, color);
C = ++G[temp];
maxi[color] = max(maxi[color], C);
Edge[color].push_back(id);
}
}
} else {
}
}
for (int i = 1; i <= n; ++i) {
if (bcc[i].size() == 1) continue;
for (int j = 0; j < graph[i].size(); ++j) {
int id = graph[i][j];
int w = a[id] ^ b[id] ^ i;
if (bcc[w].size() >= 2 && (bcc[w].size() > bcc[i].size() ||
(bcc[w].size() == bcc[i].size() && w < i))) {
bool is = 0;
for (auto it = bcc[i].begin(); it != bcc[i].end(); ++it)
if (bcc[w].count(*it)) {
int color = *it;
pair<int, int> temp = make_pair(w, color);
int C = ++G[temp];
maxi[color] = max(maxi[color], C);
temp = make_pair(i, color);
C = ++G[temp];
maxi[color] = max(maxi[color], C);
Edge[color].push_back(id);
}
}
}
}
for (int i = 1; i <= cpiv; ++i) {
if (maxi[i] == 2) {
for (int j = 0; j < Edge[i].size(); ++j) ret.push_back(Edge[i][j]);
}
}
sort(ret.begin(), ret.end());
cout << ret.size() << endl;
for (int i = 0; i < ret.size(); ++i) printf("%d ", ret[i]);
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void load() {}
const int N = 1e5 + 123;
int lab[N], pr[N], dep[N], sz[N], l[N], r[N];
vector<int> ed[N];
map<int, int> Map[N], Map1[N];
bool vis[N];
int Findset(int u) { return (u == lab[u]) ? u : lab[u] = Findset(lab[u]); }
void dfs(int u, int p) {
vis[u] = 1;
for (int v : ed[u]) {
if (v == p) continue;
if (!vis[v]) {
Map1[u][v] = v;
Map1[v][u] = v;
dep[v] = dep[u] + 1;
pr[v] = u;
dfs(v, u);
} else {
int tmp = u;
if (dep[tmp] > dep[v]) ++sz[Findset(tmp)], Map[v][u] = u, Map[u][v] = u;
tmp = Findset(tmp);
while (dep[tmp] > dep[v]) {
int l = Findset(tmp), r = Findset(pr[tmp]);
if (dep[pr[tmp]] > dep[v]) lab[l] = r, sz[r] += sz[l];
tmp = r;
}
}
}
}
void trungtt() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; ++i) {
int u, v;
scanf("%d%d", &u, &v);
ed[u].push_back(v), ed[v].push_back(u);
Map[u][v] = Map[v][u] = -1;
l[i] = u, r[i] = v;
}
for (int i = 1; i <= n; ++i) lab[i] = i;
for (int i = 1; i <= n; ++i)
if (!vis[i]) dfs(i, 0);
vector<int> ans;
for (int i = 1; i <= m; ++i) {
int u = l[i], v = r[i];
if (Map[u][v] != -1 && sz[Findset(Map[u][v])] == 1) ans.push_back(i);
if (Map[u][v] == -1 && sz[Findset(Map1[u][v])] == 1) ans.push_back(i);
}
printf("%d\n", (int)ans.size());
for (int v : ans) printf("%d ", v);
}
int main() {
load();
trungtt();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int to, id;
node *nxt;
} edges[100000 * 2 + 5];
node *ncnt = &edges[0], *Adj[100000 + 5];
int n, m;
int fro[100000 + 5], to[100000 + 5];
int dfn[100000 + 5], low[100000 + 5], tcnt = 0;
stack<int> sta;
set<int> st;
vector<int> need, ans;
void AddEdge(int u, int v, int id) {
node *p = ++ncnt;
p->to = v;
p->id = id;
p->nxt = Adj[u];
Adj[u] = p;
node *q = ++ncnt;
q->to = u;
q->id = id;
q->nxt = Adj[v];
Adj[v] = q;
}
void Tarjan(int u, int fa) {
dfn[u] = low[u] = ++tcnt;
for (node *p = Adj[u]; p != NULL; p = p->nxt) {
int v = p->to;
if (dfn[v] == 0) {
sta.push(p->id);
Tarjan(v, u);
low[u] = min(low[u], low[v]);
if (low[v] >= dfn[u]) {
int tp;
st.clear();
need.clear();
do {
tp = sta.top();
sta.pop();
st.insert(fro[tp]);
st.insert(to[tp]);
need.push_back(tp);
} while (sta.empty() == false &&
(fro[tp] != fro[p->id] || to[tp] != to[p->id]));
if (st.size() == need.size())
for (int i = 0; i < (int)need.size(); i++) ans.push_back(need[i]);
}
} else if (v != fa) {
if (dfn[u] > dfn[v]) sta.push(p->id);
low[u] = min(low[u], dfn[v]);
}
}
}
int main() {
scanf("%d %d", &n, &m);
int u, v;
for (int i = 1; i <= m; i++) {
scanf("%d %d", &u, &v);
AddEdge(u, v, i);
fro[i] = u, to[i] = v;
}
for (int i = 1; i <= n; i++)
if (dfn[i] == 0) Tarjan(i, -1);
printf("%d\n", (int)ans.size());
sort(ans.begin(), ans.end());
for (int i = 0; i < (int)ans.size(); i++)
if (i == 0)
printf("%d", ans[i]);
else
printf(" %d", ans[i]);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int>> g;
vector<vector<int>> vg, gv;
vector<int> st, tt;
int dfs(int id, int p, int t) {
st.push_back(id);
int v, e, r = tt[id] = t;
for (int n : g[id])
if (n != p) {
if (~tt[n]) {
r = min(v = tt[n], r);
continue;
}
r = min(v = dfs(n, id, t + 1), r);
if (v == tt[n] || v == tt[n] - 1) {
int gr = gv.size();
gv.push_back(vector<int>());
do {
e = st.back();
st.pop_back();
gv[gr].push_back(e);
vg[e].push_back(gr);
} while (e != n);
e = id;
gv[gr].push_back(e);
vg[e].push_back(gr);
}
}
return r;
}
void get2Components() {
int N = g.size();
vg = vector<vector<int>>(N);
gv = vector<vector<int>>();
tt = vector<int>(N, -1);
for (int i = 0; i < N; ++i) {
if (tt[i] == -1) {
dfs(i, i, 0);
}
}
}
struct Edge {
int f, t, id, group;
bool operator<(const Edge &e) const { return id < e.id; }
};
int findSame(vector<int> &a, vector<int> &b) {
int ai = 0, bi = 0;
while (ai != a.size() && bi != b.size()) {
if (a[ai] < b[bi]) {
ai++;
} else if (a[ai] > b[bi]) {
bi++;
} else {
return a[ai];
}
}
assert(false);
}
int main() {
ios::sync_with_stdio(false);
int N, M;
scanf("%d%d", &N, &M);
g = vector<vector<int>>(N);
vector<Edge> e;
for (int i = (0); i < (int)(M); ++i) {
int a, b;
scanf("%d%d", &a, &b);
a--;
b--;
g[a].push_back(b);
g[b].push_back(a);
e.push_back({a, b, i});
}
get2Components();
vector<int> ge(gv.size());
for (Edge &el : e) {
int group = findSame(vg[el.f], vg[el.t]);
ge[group]++;
el.group = group;
}
vector<int> good(gv.size(), 0);
for (int i = 0; i < gv.size(); ++i) {
good[i] = ge[i] == gv[i].size();
}
vector<Edge> res;
for (Edge &el : e) {
if (good[el.group]) {
res.push_back(el);
}
}
printf("%d\n", (int)res.size());
for (Edge n : res) {
printf("%d ", n.id + 1);
}
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
struct BccVertex {
int n, nScc, step, dfn[101010], low[101010];
vector<int> E[101010], sccv[101010];
int top, stk[101010];
void init(int _n) {
n = _n;
nScc = step = 0;
for (int i = 1; i <= n; i++) E[i].clear();
}
void add_edge(int u, int v) {
E[u].push_back(v);
E[v].push_back(u);
}
void DFS(int u, int f) {
dfn[u] = low[u] = step++;
stk[top++] = u;
for (auto v : E[u]) {
if (v == f) continue;
if (dfn[v] == -1) {
DFS(v, u);
low[u] = min(low[u], low[v]);
if (low[v] >= dfn[u]) {
int z;
sccv[nScc].clear();
do {
z = stk[--top];
sccv[nScc].push_back(z);
} while (z != v);
sccv[nScc].push_back(u);
nScc++;
}
} else {
low[u] = min(low[u], dfn[v]);
}
}
}
vector<vector<int>> solve() {
vector<vector<int>> res;
for (int i = 1; i <= n; i++) {
dfn[i] = low[i] = -1;
}
for (int i = 1; i <= n; i++) {
if (dfn[i] == -1) {
top = 0;
DFS(i, i);
}
}
for (int i = 0; i < nScc; i++) res.push_back(sccv[i]);
return res;
}
} graph;
int n, m;
map<pair<int, int>, int> id;
unordered_set<int> S[101010];
bool on[101010];
void solve() {
vector<vector<int>> ret = graph.solve();
for (auto&& i : ret) {
int sz = i.size();
vector<int> eid;
if ((long long)sz * sz < 101010) {
for (size_t j = 0; j < i.size(); j++)
for (size_t k = j + 1; k < i.size(); k++)
if (S[i[j]].find(i[k]) != S[i[j]].end())
eid.push_back(id[{i[j], i[k]}]);
} else {
unordered_set<int> cur;
for (auto ii : i) cur.insert(ii);
for (auto ii : i) {
for (auto j : S[ii])
if (cur.find(j) != cur.end()) eid.push_back(id[{ii, j}]);
}
sort(eid.begin(), eid.end());
eid.resize(unique(eid.begin(), eid.end()) - eid.begin());
}
if (eid.size() == i.size()) {
for (auto j : eid) on[j] = true;
}
}
vector<int> ans;
for (int i = 1; i <= m; i++)
if (on[i]) ans.push_back(i);
printf("%d\n", (int)ans.size());
for (auto x : ans) printf("%d ", x);
puts("");
}
int main() {
scanf("%d%d", &n, &m);
graph.init(n);
for (int i = 1; i <= m; i++) {
int ui, vi;
scanf("%d%d", &ui, &vi);
graph.add_edge(ui, vi);
S[ui].insert(vi);
S[vi].insert(ui);
id[{ui, vi}] = id[{vi, ui}] = i;
}
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100100;
const int M = 100100;
namespace BCC {
int vcompNum, ecompNum, I, m;
int first[N], low[N], vis[N], ecomp[N];
int nxt[2 * M], ep[2 * M], vcomp[2 * M];
stack<int> edges, verts;
void init() {
m = 0;
memset(first, -1, sizeof(first));
}
void add_edge(int a, int b) {
nxt[m] = first[ep[m] = a], first[ep[m]] = m, ++m;
nxt[m] = first[ep[m] = b], first[ep[m]] = m;
++m;
}
void biconnected(int u, int par) {
int v, E;
low[u] = vis[u] = ++I;
verts.push(u);
for (int e = first[u]; e != -1; e = nxt[e]) {
v = ep[e ^ 1];
if (!vis[v]) {
edges.push(e);
biconnected(v, e);
low[u] = min(low[u], low[v]);
if (vis[u] <= low[v]) {
do {
E = edges.top();
edges.pop();
vcomp[E] = vcomp[E ^ 1] = vcompNum;
} while (e != E && e != (E ^ 1));
++vcompNum;
}
} else if (vis[v] < vis[u] && e != (par ^ 1)) {
low[u] = min(low[u], vis[v]);
edges.push(e);
} else if (v == u)
vcomp[e] = vcomp[e ^ 1] = vcompNum++;
}
if (vis[u] <= low[u]) {
do {
v = verts.top();
verts.pop();
ecomp[v] = ecompNum;
} while (v != u);
++ecompNum;
}
}
void get_bcc(int n) {
memset(vis, 0, sizeof vis);
vcompNum = ecompNum = I = 0;
for (int i = 0; i < n; ++i)
if (!vis[i]) biconnected(i, -1);
}
bool isCutVertex(int u) {
for (int e = first[u]; e != -1; e = nxt[e])
if (vcomp[e] != vcomp[first[u]]) return true;
return false;
}
bool isCutEdge(int e) { return ecomp[ep[e]] != ecomp[ep[e ^ 1]]; }
} // namespace BCC
int ecount[N];
int esz[N];
unordered_set<int> cont[N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
BCC::init();
vector<pair<int, int>> e;
for (int i = 1; i <= m; ++i) {
int a, b;
cin >> a >> b;
e.emplace_back(a, b);
BCC::add_edge(a, b);
}
BCC::get_bcc(n + 1);
for (int i = 0; i < m * 2; i += 2) {
++esz[BCC::vcomp[i]];
cont[BCC::vcomp[i]].insert(e[i / 2].first);
cont[BCC::vcomp[i]].insert(e[i / 2].second);
}
for (int i = 0; i < BCC::vcompNum; ++i) {
ecount[i] = cont[i].size();
}
vector<int> g;
for (int i = 0; i < m; ++i) {
auto [a, b] = e[i];
if (ecount[BCC::vcomp[i * 2]] == esz[BCC::vcomp[i * 2]]) {
g.push_back(i + 1);
}
}
cout << g.size() << endl;
for (auto& x : g) {
cout << x << " ";
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
map<pair<int, int>, int> M;
int root;
int root_children;
set<int> adj[N];
vector<int> toRemove[N];
int dfs_num[N], dfs_low[N], is_arti[N];
vector<int> T;
void dfs(int v, int p, int &k) {
T.push_back(v);
dfs_num[v] = dfs_low[v] = ++k;
if (p == root) root_children++;
for (auto it : adj[v]) {
if (it == p) continue;
if (dfs_num[it] == 0) {
dfs(it, v, k);
if (dfs_low[it] >= dfs_num[v]) is_arti[v] = 1;
if (dfs_low[it] > dfs_num[v]) {
toRemove[v].push_back(it);
toRemove[it].push_back(v);
}
dfs_low[v] = min(dfs_low[v], dfs_low[it]);
} else {
dfs_low[v] = min(dfs_low[v], dfs_num[it]);
}
}
}
int U[N], V[N], disc[N], low[N], comp[N];
vector<int> g[N];
int tym;
bool is_bridge[N];
int adj2(int src, int edgeid) { return U[edgeid] ^ V[edgeid] ^ src; }
void tarjan(int src, int par_edge) {
++tym;
disc[src] = low[src] = tym;
for (int i = 0; i < (int)g[src].size(); ++i) {
int edgeid = g[src][i];
int to = adj2(src, edgeid);
if (edgeid != par_edge) {
if (!disc[to]) {
tarjan(to, edgeid);
low[src] = min(low[src], low[to]);
if (low[to] > disc[src]) is_bridge[edgeid] = 1;
} else {
low[src] = min(low[src], disc[to]);
}
}
}
}
int ec = 0;
pair<int, int> vis[N], vedge[N];
map<pair<int, int>, int> VF, EF;
map<pair<int, int>, int> hasAdded;
void arti_dfs(int v, int p, int k) {
for (auto it : adj[v]) {
if (it == p) continue;
int eid = M[make_pair(v, it)];
if (vedge[eid].first) {
vedge[eid].second = k;
EF[vedge[eid]]++;
} else
vedge[eid].first = k;
if (is_arti[it]) {
if (it == k) continue;
int x = k, y = it;
if (hasAdded[make_pair(x, y)]) continue;
hasAdded[make_pair(x, y)] = hasAdded[make_pair(y, x)] = 1;
ec++;
U[ec] = x, V[ec] = y;
g[x].push_back(ec);
g[y].push_back(ec);
is_bridge[ec] = 0;
continue;
}
if (vis[it].first != k and vis[it].second != k) {
if (vis[it].first)
vis[it].second = k;
else
vis[it].first = k;
arti_dfs(it, v, k);
}
}
}
map<pair<int, int>, int> ok;
vector<int> ans;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int a, b;
cin >> a >> b;
adj[a].insert(b), adj[b].insert(a);
M[make_pair(a, b)] = M[make_pair(b, a)] = i;
}
int k = 0;
for (int i = 1; i <= n; i++) {
if (dfs_num[i] == 0) {
T.clear();
dfs(i, 0, k);
for (auto v : T) {
for (auto it : toRemove[v]) {
adj[v].erase(it);
}
toRemove[v].clear();
}
}
}
memset(dfs_num, 0, sizeof dfs_num);
memset(dfs_low, 0, sizeof dfs_low);
memset(is_arti, 0, sizeof is_arti);
k = 0;
for (int i = 1; i <= n; i++) {
if (dfs_num[i] == 0) {
T.clear();
root = i, root_children = 0;
dfs(i, 0, k);
is_arti[i] = (root_children > 1);
for (auto v : T) {
assert(toRemove[v].empty());
}
ec = 0;
for (auto it : T) {
if (is_arti[it]) {
arti_dfs(it, 0, it);
}
}
for (auto it : T) {
if (not is_arti[it] and not vis[it].second) {
is_arti[it] = 1;
arti_dfs(it, 0, it);
}
}
for (auto it : T) {
if (is_arti[it] and not disc[it]) {
tarjan(it, 0);
}
}
for (auto it : T) {
if (vis[it].second) VF[vis[it]]++;
}
for (int i = 1; i <= ec; i++) {
if (is_bridge[i]) {
auto itl = make_pair(U[i], V[i]);
auto itr = make_pair(V[i], U[i]);
if (VF[itl] + 2 == EF[itl])
ok[itl] = 1;
else if (VF[itr] + 2 == EF[itr])
ok[itr] = 1;
}
}
}
}
for (int i = 1; i <= m; i++) {
if (ok[vedge[i]]) ans.push_back(i);
}
cout << ans.size() << "\n";
for (auto it : ans) {
cout << it << " ";
}
cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(3, "inline", "Ofast")
using namespace std;
vector<int> ans;
int n, m, to[500010], deep[500010];
int nxt[500010], hd[500010], fa[100010], tofa[500010], num = -1, cf[500010];
bool tree[500010], vis[100010];
void add(int u, int v) {
nxt[++num] = hd[u];
to[num] = v;
hd[u] = num;
nxt[++num] = hd[v];
to[num] = u;
hd[v] = num;
}
void dfs1(int pos, int f, int dp) {
fa[pos] = f;
vis[pos] = 1;
deep[pos] = dp;
for (int i = hd[pos]; i != -1; i = nxt[i])
if (!vis[to[i]]) {
tofa[to[i]] = i, tree[i] = 1;
dfs1(to[i], pos, dp + 1);
}
return;
}
void dfs(int pos) {
vis[pos] = 1;
for (int i = hd[pos]; i != -1; i = nxt[i])
if (tree[i]) {
dfs(to[i]);
cf[pos] += cf[to[i]];
}
return;
}
int main() {
memset(hd, -1, sizeof hd);
memset(nxt, -1, sizeof nxt);
scanf("%d%d", &n, &m);
for (int i = 1, a, b; i <= m; i++) {
scanf("%d%d", &a, &b);
add(a, b);
}
for (int i = 1; i <= n; i++)
if (!vis[i]) dfs1(i, 0, 1);
for (int i = 0, u, v; i <= num; i += 2) {
if (tree[i] || tree[i + 1])
continue;
else
u = to[i], v = to[i + 1];
if (deep[u] < deep[v]) swap(u, v);
cf[u]++;
cf[v]--;
}
memset(vis, 0, sizeof vis);
for (int i = 1; i <= n; i++)
if (!vis[i]) dfs(i);
for (int i = 0, u, v; i <= num; i += 2) {
if (tree[i] || tree[i + 1]) continue;
u = to[i], v = to[i + 1];
if (deep[u] < deep[v]) swap(u, v);
if ([u, v]() {
for (int tmp = u; tmp != v; tmp = fa[tmp])
if (cf[tmp] != 1) return false;
return true;
}()) {
ans.push_back((i + 2) / 2);
while (u != v) {
ans.push_back((tofa[u] + 2) / 2);
u = fa[u];
}
}
}
sort(ans.begin(), ans.end());
std::cout << ans.size() << std::endl;
for (const int &e : ans) printf("%d ", e);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > g[600001];
bool vis[600001];
vector<int> vbel[600001];
int dfn[600001], low[600001], ebel[600001], dfc, vbcc;
int dfs_vbcc(int u, int f) {
static int s[600001];
static int t;
s[++t] = u;
dfn[u] = low[u] = ++dfc;
for (pair<int, int> p : g[u]) {
int v = p.first, i = p.second;
if (vis[i]) continue;
vis[i] = 1;
s[++t] = -i;
if (!dfn[v]) {
low[u] = min(low[u], dfs_vbcc(v, i));
if (dfn[u] <= low[v]) {
for (++vbcc; s[t + 1] != -i; --t)
s[t] > 0 ? vbel[s[t]].push_back(vbcc), 0 : ebel[-s[t]] = vbcc;
vbel[u].push_back(vbcc);
}
} else
low[u] = min(low[u], dfn[v]);
}
return low[u];
}
void tarjan_vbcc(int n, int m) {
dfc = vbcc = 0;
fill_n(vis + 1, m, 0);
fill_n(ebel + 1, m, 0);
fill_n(dfn + 1, n, 0);
for (int u = 1; u <= n; ++u) vbel[u].resize(0);
for (int u = 1; u <= n; ++u)
if (!dfn[u]) dfs_vbcc(u, 0);
}
int ew[600001], vcnt[600001], ecnt[600001];
vector<int> ansv[600001];
int main(void) {
ios::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
for (int i = 1; i <= m; ++i) {
int u, v;
cin >> u >> v;
g[u].emplace_back(v, i);
g[v].emplace_back(u, i);
}
tarjan_vbcc(n, m);
for (int i = 1; i <= n; ++i)
for (int b : vbel[i]) vcnt[b]++;
for (int i = 1; i <= m; ++i) ecnt[ebel[i]]++, ansv[ebel[i]].push_back(i);
vector<int> ans;
ans.reserve(m);
for (int i = 1; i <= vbcc; ++i)
if (vcnt[i] == ecnt[i])
ans.insert(ans.end(), ansv[i].begin(), ansv[i].end());
sort(ans.begin(), ans.end());
cout << ans.size() << endl;
for (int ei : ans) cout << ei << ' ';
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
int low[maxn], tim[maxn], now_time, iscut[maxn], belong[maxn], bcc_cnt,
nodecnt[maxn], bccno[maxn], mark[maxn];
int n, m;
vector<int> vec[maxn], vt[maxn], ans;
struct edge {
int u, v;
edge() {}
edge(int uu, int vv) : u(uu), v(vv) {}
} ed[maxn];
void init() {
for (int i = 1; i <= n; i++) {
vec[i].clear();
vt[i].clear();
}
ans.clear();
memset(low, 0, sizeof(low));
memset(tim, 0, sizeof(tim));
memset(belong, 0, sizeof(belong));
memset(iscut, 0, sizeof(iscut));
memset(nodecnt, 0, sizeof(nodecnt));
memset(bccno, 0, sizeof(bccno));
memset(mark, 0, sizeof(mark));
now_time = bcc_cnt = 0;
}
stack<int> s;
void tarjan(int o, int fa) {
tim[o] = low[o] = ++now_time;
int child = 0;
for (int i = 0; i < vec[o].size(); i++) {
int tmp = ed[vec[o][i]].v;
if (mark[vec[o][i]]) continue;
mark[vec[o][i]] = mark[vec[o][i] ^ 1] = 1;
s.push(vec[o][i]);
if (!tim[tmp]) {
child++;
tarjan(tmp, o);
low[o] = min(low[o], low[tmp]);
if (low[tmp] >= tim[o]) {
iscut[o] = 1;
++bcc_cnt;
while (1) {
int t = s.top();
s.pop();
if (bccno[ed[t].u] != bcc_cnt) {
bccno[ed[t].u] = bcc_cnt;
nodecnt[bcc_cnt]++;
}
if (bccno[ed[t].v] != bcc_cnt) {
bccno[ed[t].v] = bcc_cnt;
nodecnt[bcc_cnt]++;
}
belong[(t >> 1) + 1] = bcc_cnt;
if (vec[o][i] == t) break;
}
}
} else
low[o] = min(tim[tmp], low[o]);
}
if (child == 1 && fa < 0) iscut[o] = 0;
}
int main(void) {
while (scanf("%d%d", &n, &m) != EOF) {
init();
for (int i = 0; i < 2 * m; i += 2) {
int u, v;
scanf("%d%d", &u, &v);
ed[i] = edge(u, v);
ed[i + 1] = edge(v, u);
vec[u].push_back(i);
vec[v].push_back(i + 1);
}
for (int i = 1; i <= n; i++)
if (!tim[i]) tarjan(i, -1);
for (int i = 1; i <= m; i++) {
vt[belong[i]].push_back(i);
}
for (int i = 1; i <= bcc_cnt; i++) {
if (nodecnt[i] == vt[i].size()) {
for (int j = 0; j < vt[i].size(); j++) ans.push_back(vt[i][j]);
}
}
sort(ans.begin(), ans.end());
printf("%d\n", ans.size());
for (int i = 0; i < ans.size(); i++)
printf("%d%c", ans[i], i == ans.size() - 1 ? '\n' : ' ');
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100500;
int parent[maxn], sz[maxn], lev[maxn], p[maxn], cp[maxn], id[maxn], sz_c[maxn],
ed[maxn];
bool in[maxn];
vector<pair<int, int> > g[maxn];
vector<pair<pair<int, int>, int> > back_ed;
int find_set(int v) {
if (v == parent[v]) return v;
return parent[v] = find_set(parent[v]);
}
void make_set(int v) {
parent[v] = v;
sz[v] = 1;
}
void union_sets(int a, int b) {
a = find_set(a);
b = find_set(b);
if (a != b) {
if (sz[a] < sz[b]) swap(a, b);
parent[b] = a;
sz[a] += sz[b];
}
}
void init(int u, int par = 0, int lvl = 0, int edge = -1) {
lev[u] = lvl;
p[u] = cp[u] = par;
ed[u] = edge;
in[u] = true;
for (auto v : g[u]) {
if (v.first == par) continue;
if (p[v.first] == -1)
init(v.first, u, lvl + 1, v.second);
else if (in[v.first])
back_ed.push_back({{u, v.first}, v.second});
}
in[u] = false;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int u, v;
cin >> u >> v;
--u;
--v;
g[u].push_back({v, i + 1});
g[v].push_back({u, i + 1});
}
for (int i = 0; i < n; ++i) p[i] = id[i] = -1;
for (int i = 0; i < n; ++i)
if (p[i] == -1) init(i);
for (int i = 0; i < (int)back_ed.size(); ++i) make_set(i);
for (int i = 0; i < (int)back_ed.size(); ++i) {
int u, v;
tie(u, v) = back_ed[i].first;
int cur = u;
while (lev[cur] > lev[v]) {
if (id[cur] == -1)
id[cur] = i;
else
union_sets(id[cur], i);
int tmp = cur;
cur = p[cur];
p[tmp] = v;
}
}
for (int i = 0; i < (int)back_ed.size(); ++i) sz_c[find_set(i)]++;
vector<int> ans;
for (int i = 0; i < (int)back_ed.size(); ++i)
if (sz_c[find_set(i)] == 1) {
int u, v;
tie(u, v) = back_ed[i].first;
ans.push_back(back_ed[i].second);
int cur = u;
while (cur != v) {
ans.push_back(ed[cur]);
cur = cp[cur];
}
}
cout << (int)ans.size() << '\n';
sort(ans.begin(), ans.end());
for (auto e : ans) cout << e << ' ';
cout << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100006;
vector<int> G[N];
int e[N];
int x[N], y[N];
bool vis[N];
int low[N];
int depth[N];
vector<int> ans;
vector<int> bcc[N];
int bcc_cnt;
stack<int> sta;
int dfs_clock;
void dfs(int now, int par) {
vis[now] = true;
depth[now] = low[now] = (++dfs_clock);
for (int ii : G[now]) {
int i = (e[ii] ^ now);
if (i == par) continue;
if (!vis[i]) {
sta.push(ii);
dfs(i, now);
low[now] = min(low[now], low[i]);
if (low[i] >= depth[now]) {
++bcc_cnt;
while (!sta.empty()) {
int t = sta.top();
sta.pop();
bcc[bcc_cnt].push_back(t);
if (t == ii) break;
}
}
} else if (vis[i] && depth[i] < depth[now]) {
sta.push(ii);
low[now] = min(low[now], depth[i]);
}
}
}
void go(int root) { dfs(root, root); }
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 1; m >= i; i++) {
scanf("%d %d", &x[i], &y[i]);
e[i] = (x[i] ^ y[i]);
G[x[i]].push_back(i);
G[y[i]].push_back(i);
}
for (int i = 1; n >= i; i++) {
if (!vis[i]) go(i);
}
for (int i = 1; bcc_cnt >= i; i++) {
set<int> st;
for (int j : bcc[i]) {
st.insert(x[j]);
st.insert(y[j]);
}
if ((int)st.size() == (int)bcc[i].size()) {
for (int j : bcc[i]) {
ans.push_back(j);
}
}
}
sort(ans.begin(), ans.end());
printf("%d\n", (int)ans.size());
for (int i = 0; (int)ans.size() > i; i++) {
if (i) printf(" ");
printf("%d", ans[i]);
}
puts("");
}
|
#include <bits/stdc++.h>
using namespace std;
bool ind[100009];
int n, m, hd[100009], cnt, ans[100009], sa;
int dfn[100009], low[100009], sd, q[100009], sq, L[100009], sl;
struct Edge {
int to, nxt, i;
} edge[100009 << 1];
int read();
void add(int u, int v, int i) {
edge[++cnt] = (Edge){v, hd[u], i};
hd[u] = cnt;
edge[++cnt] = (Edge){u, hd[v], i};
hd[v] = cnt;
}
void Tarjan(int u) {
dfn[u] = low[u] = ++sd;
q[++sq] = u;
for (int i = hd[u], v; i; i = edge[i].nxt) {
int NL = sl;
if (!ind[edge[i].i]) {
L[++sl] = edge[i].i;
ind[edge[i].i] = true;
}
if (!dfn[v = edge[i].to]) {
Tarjan(v);
low[u] = (low[u]) < (low[v]) ? (low[u]) : (low[v]);
if (low[v] == dfn[u]) {
int sum = 1;
while (q[sq + 1] != v) ++sum, --sq;
if (sum != sl - NL)
while (sl > NL) --sl;
else
while (sl > NL) ans[++sa] = L[sl--];
}
} else
low[u] = (low[u]) < (dfn[v]) ? (low[u]) : (dfn[v]);
}
}
int main() {
n = read(), m = read();
for (int i = 1, u, v; i <= m; ++i) u = read(), v = read(), add(u, v, i);
for (int i = 1; i <= n; ++i)
if (!dfn[i]) Tarjan(i);
sort(ans + 1, ans + 1 + sa);
printf("%d\n", sa);
for (int i = 1; i <= sa; ++i) printf("%d ", ans[i]);
puts("");
return 0;
}
int read() {
int x = 0, f = 1;
char c = getchar();
while (c > '9' || c < '0') f = (c == '-') ? -1 : f, c = getchar();
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
return x * f;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10, M = 2e6 + 10;
int head[N], ver[M], nxt[M], tot = 1;
void add(int x, int y) {
ver[++tot] = y;
nxt[tot] = head[x];
head[x] = tot;
}
int st[N], low[N], cnt = 0, num = 0, dfn[N], rt, top, st1[N], top1;
bool cut[N];
vector<int> dcc[N];
int col[N];
int c[N];
set<int> v[N], e[N];
void tarjan(int x, int fa) {
dfn[x] = low[x] = ++num;
int c = 0;
for (int i = head[x]; i; i = nxt[i]) {
int y = ver[i];
if (!dfn[y]) {
st[++top] = x;
st[++top] = y;
st[++top] = i / 2;
tarjan(y, x);
low[x] = min(low[x], low[y]);
if (low[y] >= dfn[x]) {
c++;
if (x != rt || c > 1) cut[x] = 1;
cnt++;
while (1) {
int pos = st[top--], V = st[top--], U = st[top--];
v[cnt].insert(U);
v[cnt].insert(V);
e[cnt].insert(pos);
if (x == U && V == y) break;
}
}
} else if (dfn[y] < dfn[x] && y != fa) {
low[x] = min(low[x], dfn[y]);
st[++top] = x;
st[++top] = y;
st[++top] = i / 2;
}
}
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d %d", &x, &y);
add(x, y);
add(y, x);
}
for (int i = 1; i <= n; i++)
if (!dfn[i]) {
rt = i;
tarjan(i, 0);
}
int ans = 0;
set<int> Ans;
for (int i = 1; i <= cnt; i++)
if (e[i].size() == v[i].size())
for (set<int>::iterator it = e[i].begin(); it != e[i].end(); it++)
Ans.insert(*it);
printf("%d\n", (int)Ans.size());
for (set<int>::iterator it = Ans.begin(); it != Ans.end(); it++)
printf("%d ", *it);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
vector<pair<int, int> > son[N];
vector<int> bcc_node[N], bcc_edge[N], ans;
stack<pair<pair<int, int>, int> > s;
int bcc_cnt, belong[N], is_cnt[N], now_time, dfn[N], low[N];
void dfs(int o, int fa) {
dfn[o] = low[o] = ++now_time;
int ch = 0;
for (int i = 0; i < son[o].size(); ++i) {
int v = son[o][i].first;
if (v == fa) continue;
pair<pair<int, int>, int> edge = {{o, v}, son[o][i].second};
if (!dfn[v]) {
s.push(edge);
dfs(v, o);
low[o] = min(low[o], low[v]);
if (low[v] >= dfn[o]) {
ch++, is_cnt[o] = true;
bcc_node[++bcc_cnt].clear();
bcc_edge[bcc_cnt].clear();
while (true) {
pair<pair<int, int>, int> now = s.top();
s.pop();
bcc_edge[bcc_cnt].push_back(now.second);
if (belong[now.first.first] != bcc_cnt)
belong[now.first.first] = bcc_cnt,
bcc_node[bcc_cnt].push_back(now.first.first);
if (belong[now.first.second] != bcc_cnt)
belong[now.first.second] = bcc_cnt,
bcc_node[bcc_cnt].push_back(now.first.second);
if (now.first.first == o && now.first.second == v) break;
}
}
} else if (dfn[v] < dfn[o]) {
s.push(edge);
low[o] = min(dfn[v], low[o]);
}
}
if (!fa && ch == 1) is_cnt[o] = false;
}
int main() {
int n, m;
int u, v;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; ++i) {
scanf("%d%d", &u, &v);
son[u].push_back(make_pair(v, i));
son[v].push_back(make_pair(u, i));
}
for (int i = 1; i <= n; ++i)
if (!dfn[i]) dfs(i, 0);
int tot = 0;
set<int> as;
for (int i = 1; i <= bcc_cnt; ++i) {
if (bcc_node[i].size() == bcc_edge[i].size()) {
for (int j = 0; j < bcc_node[i].size(); ++j)
as.insert(bcc_edge[i][j]), tot++;
}
}
printf("%d\n", tot);
for (int i : as) printf("%d ", i);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 202020;
int n, m, tot;
int V[N], E[N];
vector<int> g[N], e[N];
namespace DCC {
const int N = ::N;
vector<int> key, dcc[N];
int dfn[N], low[N], st[N], _st, _;
void dfs(int c, int dep, const vector<int> g[]) {
int cc = 0, out = 1 < dep;
st[_st++] = c;
dfn[c] = low[c] = dep;
for (auto t : g[c])
if (!dfn[t]) {
dfs(t, dep + 1, g);
low[c] = min(low[c], low[t]);
if (low[t] >= dfn[c]) {
if (++out == 2) key.push_back(c);
while (st[--_st] != t) dcc[st[_st]].push_back(_);
dcc[c].push_back(_);
dcc[t].push_back(_++);
}
} else if (dfn[t] != dfn[c] - 1 || cc++)
low[c] = min(low[c], dfn[t]);
}
int solve(int n, const vector<int> g[]) {
fill_n(dfn, n, _ = 0);
fill_n(low, n, _st = 0);
fill_n(dcc, n, key = vector<int>());
for (int i = (0); i < (n); ++i)
if (!dfn[i]) dfs(i, 1, g);
for (int i = (0); i < (n); ++i)
if ((int)dcc[i].size() == 0) dcc[i].push_back(_++);
return _;
}
} // namespace DCC
void add(int u, int v) {
--u, --v;
g[u].push_back(v), g[v].push_back(u);
}
int main() {
std::ios::sync_with_stdio(0);
std::cin.tie(0);
cin >> n >> m;
for (int i = (1); i < (m + 1); ++i) {
int u, v;
cin >> u >> v;
add(u, i + n);
add(v, i + n);
}
tot = DCC::solve(n + m, g);
for (int i = (0); i < (n + m); ++i) {
for (auto t : DCC::dcc[i]) {
if (i < n) {
++V[t];
} else {
++E[t];
e[t].push_back(i - n + 1);
}
}
}
vector<int> ans;
for (int i = (0); i < (tot); ++i)
if (V[i] == E[i]) {
if (V[i] == 1) continue;
for (auto u : e[i]) ans.push_back(u);
}
sort(ans.begin(), ans.end());
cout << (int)ans.size() << "\n";
for (int i = (0); i < ((int)ans.size()); ++i)
cout << ans[i] << " \n"[i == (int)ans.size() - 1];
return 0;
}
|
#include <bits/stdc++.h>
using namespace ::std;
const long long maxn = 2e5 + 500;
const long long mod = 1e9 + 7;
const long long inf = 1e9 + 500;
vector<long long> ger[maxn];
pair<long long, long long> yal[maxn];
bool vis[maxn];
long long s[maxn];
vector<long long> backe;
long long par[maxn];
long long epar[maxn];
long long h[maxn];
void dfs(long long a) {
vis[a] = 1;
for (auto e : ger[a]) {
long long v = yal[e].first ^ yal[e].second ^ a;
if (vis[v]) {
if (h[v] < h[a] && abs(h[a] - h[v]) != 1) {
backe.push_back(e);
s[a]++;
s[v]--;
}
} else {
par[v] = a;
epar[v] = e;
h[v] = h[a] + 1;
dfs(v);
}
}
}
void dfs_pr(long long a) {
vis[a] = 1;
for (auto e : ger[a]) {
long long v = yal[e].first ^ yal[e].second ^ a;
if (!vis[v]) {
dfs_pr(v);
s[a] += s[v];
}
}
}
int main() {
long long n, m;
cin >> n >> m;
for (long long i = 0; i < m; i++) {
long long v, u;
cin >> v >> u;
v--;
u--;
ger[u].push_back(i);
ger[v].push_back(i);
yal[i] = make_pair(v, u);
}
for (long long i = 0; i < n; i++) {
if (vis[i] == 0) {
h[i] = 1;
dfs(i);
}
}
fill(vis, vis + maxn, 0);
for (long long i = 0; i < n; i++) {
if (vis[i] == 0) {
dfs_pr(i);
}
}
fill(vis, vis + maxn, 0);
for (long long i = 0; i < n; i++) {
if (s[i] != 1) {
s[i] = 0;
}
}
vector<long long> ans;
for (auto e : backe) {
long long v = yal[e].first;
long long u = yal[e].second;
if (h[v] < h[u]) {
swap(v, u);
}
bool good = 1;
while (v != u) {
if (!s[v]) {
good = 0;
break;
}
v = par[v];
}
if (good) {
v = yal[e].first;
u = yal[e].second;
if (h[v] < h[u]) {
swap(v, u);
}
ans.push_back(e);
while (v != u) {
ans.push_back(epar[v]);
v = par[v];
}
}
}
cout << ans.size() << endl;
sort(ans.begin(), ans.end());
for (auto e : ans) {
cout << e + 1 << ' ';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int nmax = 1e5;
const int inf = 1 << 30;
bool viz[nmax + 1], f[nmax + 1];
int h[nmax + 1];
int d[nmax + 1];
int nrc;
int noduri[nmax + 1][2];
vector<int> c[nmax + 1];
vector<pair<int, int> > g[nmax + 1];
void dfs(int nod, int mtata) {
viz[nod] = 1;
d[nod] = inf;
for (auto i : g[nod]) {
if (i.second != mtata) {
if (viz[i.first] == 0) {
h[i.first] = h[nod] + 1;
dfs(i.first, i.second);
d[nod] = min(d[nod], d[i.first]);
} else {
d[nod] = min(d[nod], h[i.first]);
}
}
}
}
void comp(int nod, int ind, int mtata) {
viz[nod] = 1;
for (auto i : g[nod]) {
if (viz[i.first] == 0) {
if (d[i.first] >= h[nod]) {
++nrc;
c[nrc].push_back(i.second);
comp(i.first, nrc, i.second);
} else {
c[ind].push_back(i.second);
comp(i.first, ind, i.second);
}
} else if (i.second != mtata && h[i.first] < h[nod]) {
c[ind].push_back(i.second);
}
}
}
int main() {
int n, m;
fscanf(stdin, "%d%d", &n, &m);
for (int i = 1; i <= m; ++i) {
int x, y;
fscanf(stdin, "%d%d", &x, &y);
g[x].push_back({y, i});
g[y].push_back({x, i});
noduri[i][0] = x;
noduri[i][1] = y;
}
for (int i = 1; i <= n; ++i) {
if (viz[i] == 0) {
dfs(i, 0);
}
}
memset(viz, 0, sizeof(viz));
nrc = 0;
for (int i = 1; i <= n; ++i) {
if (viz[i] == 0) {
comp(i, 0, 0);
}
}
vector<int> ans;
for (int i = 1; i <= nrc; ++i) {
int cnt = 0;
sort(c[i].begin(), c[i].end());
c[i].erase(unique(c[i].begin(), c[i].end()), c[i].end());
m -= (int)c[i].size();
for (auto j : c[i]) {
for (int k = 0; k < 2; ++k) {
int x = noduri[j][k];
if (f[x] == 0) ++cnt;
f[x] = 1;
}
}
if (cnt == (int)c[i].size()) {
for (auto j : c[i]) ans.push_back(j);
}
for (auto j : c[i]) {
for (int k = 0; k < 2; ++k) {
int x = noduri[j][k];
f[x] = 0;
}
}
}
assert(m == 0);
sort(ans.begin(), ans.end());
fprintf(stdout, "%d\n", (int)ans.size());
for (auto i : ans) fprintf(stdout, "%d ", i);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
int n, m, cnt, head[N], dfn[N], dep[N], s[N], f[N], g[N], fa[N];
bool vis[N];
struct edge {
int to, next;
bool tag;
} e[N << 1];
int find(int x) {
if (f[x] == x)
return x;
else
return f[x] = find(f[x]);
}
void add(int u, int v) {
e[++cnt].to = v;
e[cnt].next = head[u];
head[u] = cnt;
}
void dfs1(int x, int fu, int d) {
vis[x] = 1;
dep[x] = d;
for (int i = head[x]; i; i = e[i].next) {
int v = e[i].to;
if (v == fu) continue;
if (!vis[v])
fa[v] = x, dfn[v] = i, dfs1(v, x, d + 1);
else if (dep[v] < dep[x])
s[x]++, s[v]--;
}
}
void dfs2(int x, int fu) {
vis[x] = 1;
for (int i = head[x]; i; i = e[i].next) {
int v = e[i].to;
if (v == fu) continue;
if (!vis[v]) dfs2(v, x), s[x] += s[v];
}
}
void dfs3(int x, int fu) {
vis[x] = 1;
g[x] = (s[x] > 1) + g[fu];
for (int i = head[x]; i; i = e[i].next) {
int v = e[i].to;
if (v == fu) continue;
if (!vis[v])
dfs3(v, x);
else if (dep[v] < dep[x] && g[x] == g[v]) {
int y = find(x);
e[i].tag = e[i ^ 1].tag = 1;
while (dep[y] > dep[v]) {
e[dfn[y]].tag = e[dfn[y] ^ 1].tag = 1;
f[y] = find(fa[y]);
y = find(y);
}
}
}
}
int main() {
ios::sync_with_stdio(0);
cin >> n >> m;
cnt = 1;
for (int i = 1, x, y; i <= m; i++) cin >> x >> y, add(x, y), add(y, x);
for (int i = 1; i <= n; i++)
if (!vis[i]) dfs1(i, 0, 1);
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= n; i++)
if (!vis[i]) dfs2(i, 0);
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= n; i++) f[i] = i;
for (int i = 1; i <= n; i++)
if (!vis[i]) dfs3(i, 0);
int ans = 0;
for (int i = 2; i <= cnt; i += 2) ans += e[i].tag;
cout << ans << endl;
for (int i = 2; i <= cnt; i += 2)
if (e[i].tag) cout << i / 2 << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <int SZ>
struct BCC {
int N, ti = 0;
vector<int> adj[SZ];
int disc[SZ], low[SZ], comp[SZ], par[SZ];
vector<vector<pair<int, int>>> fin;
vector<pair<int, int>> st;
void addEdge(int u, int v) { adj[u].push_back(v), adj[v].push_back(u); }
void BCCutil(int u) {
disc[u] = low[u] = ti++;
int child = 0;
for (int i : adj[u])
if (i != par[u]) {
if (disc[i] == -1) {
child++;
par[i] = u;
st.push_back({u, i});
BCCutil(i);
low[u] = min(low[u], low[i]);
if ((disc[u] == 0 && child > 1) ||
(disc[u] != 0 && disc[u] <= low[i])) {
vector<pair<int, int>> tmp;
while (st.back() != make_pair(u, i))
tmp.push_back(st.back()), st.pop_back();
tmp.push_back(st.back()), st.pop_back();
fin.push_back(tmp);
}
} else if (disc[i] < disc[u]) {
low[u] = min(low[u], disc[i]);
st.push_back({u, i});
}
}
}
void bcc() {
for (int i = 1; i < N + 1; i++) par[i] = disc[i] = low[i] = -1;
for (int i = 1; i < N + 1; i++)
if (disc[i] == -1) {
BCCutil(i);
if (!st.empty()) fin.push_back(st);
st.clear();
}
}
};
const int MAX_N = 100010;
int n, m;
map<pair<int, int>, int> ed;
bool works[MAX_N];
BCC<MAX_N> thing;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
if (a > b) swap(a, b);
thing.addEdge(a, b);
ed[make_pair(a, b)] = i + 1;
}
thing.N = n;
thing.bcc();
vector<int> res;
for (auto v : thing.fin) {
set<int> s;
for (pair<int, int>& p : v) {
if (p.first > p.second) swap(p.first, p.second);
s.insert(p.first);
s.insert(p.second);
}
if ((int)s.size() == (int)v.size()) {
for (pair<int, int> p : v) works[ed[p]] = 1;
}
}
for (int i = 1; i < m + 1; i++)
if (works[i]) res.push_back(i);
cout << (int)res.size() << "\n";
for (int i = 0; i < (int)res.size(); i++) {
if (i != 0) cout << " ";
cout << res[i];
}
cout << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
inline char gc() {
static char now[1 << 16], *S, *T;
if (T == S) {
T = (S = now) + fread(now, 1, 1 << 16, stdin);
if (T == S) return EOF;
}
return *S++;
}
inline int read() {
int x = 0, f = 1;
char ch = gc();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = gc();
}
while (isdigit(ch)) x = x * 10 + ch - '0', ch = gc();
return x * f;
}
const int N = 1e5 + 10;
struct node {
int y, next, id;
} data[N << 1];
struct node1 {
int x, y, id;
} q[N];
int top, n, m, num, ans[N], h[N], dfn[N], low[N], size[N], s, b[N];
vector<int> eg[N];
inline void tarjan(int x, int fa) {
dfn[x] = low[x] = ++num;
for (int i = h[x]; i; i = data[i].next) {
int y = data[i].y;
if (y == fa) continue;
if (dfn[y] && (dfn[y] < dfn[x])) q[++top] = (node1){x, y, data[i].id};
if (!dfn[y]) {
q[++top] = (node1){x, y, data[i].id};
tarjan(y, x);
low[x] = min(low[x], low[y]);
if (low[y] >= dfn[x]) {
++s;
node1 now;
while (1) {
now = q[top--];
eg[s].push_back(now.id);
if (b[now.x] != s) ++size[s], b[now.x] = s;
if (b[now.y] != s) ++size[s], b[now.y] = s;
if (now.x == x && now.y == y) break;
}
}
} else
low[x] = min(low[x], dfn[y]);
}
}
int main() {
n = read();
m = read();
for (int i = 1; i <= m; ++i) {
int x = read(), y = read();
data[++num].y = y;
data[num].next = h[x];
h[x] = num;
data[num].id = i;
data[++num].y = x;
data[num].next = h[y];
h[y] = num;
data[num].id = i;
}
num = 0;
for (int i = 1; i <= n; ++i)
if (!dfn[i]) tarjan(i, i);
top = 0;
for (int i = 1; i <= s; ++i)
if (eg[i].size() == size[i])
for (int j = 0; j < eg[i].size(); ++j) ans[++top] = eg[i][j];
sort(ans + 1, ans + top + 1);
printf("%d\n", top);
for (int i = 1; i <= top; ++i) printf("%d ", ans[i]);
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.