text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 7;
struct EDGE {
int to, next, id;
} edge[maxn * 2];
int n, m, head[maxn], edge_num, Inx, dfn[maxn], low[maxn], used[maxn * 2];
stack<int> stk;
vector<int> ans;
void add_edge(int u, int v, int id) {
edge[edge_num].to = v;
edge[edge_num].next = head[u];
edge[edge_num].id = id;
head[u] = edge_num++;
}
void tarjan(int u, int fa) {
dfn[u] = low[u] = ++Inx;
for (int i = head[u]; i != -1; i = edge[i].next) {
int v = edge[i].to;
if (v == fa) continue;
if (used[i]) continue;
used[i] = used[i ^ 1] = 1;
stk.push(i);
if (!dfn[v]) {
tarjan(v, u);
low[u] = min(low[u], low[v]);
if (dfn[u] <= low[v]) {
set<int> tmp_ver_set;
set<int> tmp_edge_set;
tmp_ver_set.insert(u);
int x;
do {
x = stk.top();
stk.pop();
tmp_edge_set.insert(edge[x].id);
tmp_ver_set.insert(edge[x].to);
} while (x != i);
if (tmp_edge_set.size() == tmp_ver_set.size())
for (set<int>::iterator it = tmp_edge_set.begin();
it != tmp_edge_set.end(); it++)
ans.push_back(*it);
}
} else
low[u] = min(low[u], dfn[v]);
}
}
int main() {
scanf("%d %d", &n, &m);
memset(head, 255, sizeof(head));
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d %d", &u, &v);
add_edge(u, v, i);
add_edge(v, u, i);
}
for (int i = 1; i <= n; i++)
if (!dfn[i]) tarjan(i, i);
sort(ans.begin(), ans.end());
printf("%d\n", ans.size());
for (int i = 0; i < (int)ans.size(); i++) printf("%d ", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005, M = 200005;
int n, m, tot = 1, Next[M], to[M], head[M], pre[N], low[N], tim = 0, ss[N],
re[N], cur = 0, co[N], now = 0;
bool bo[M];
stack<int> s;
inline void add(int x, int y) {
Next[++tot] = head[x];
to[tot] = y;
head[x] = tot;
}
inline void dfs(int x, int fa) {
int i, j, ct, tp;
pre[x] = low[x] = ++tim;
for (i = head[x]; i; i = Next[i])
if (to[i] != fa && !bo[i]) {
bo[i] = bo[i ^ 1] = 1;
s.push(i);
if (!pre[to[i]]) {
dfs(to[i], x);
low[x] = min(low[x], low[to[i]]);
if (low[to[i]] >= pre[x]) {
ct = tp = 0;
++now;
while (s.top() != i) {
if (co[to[s.top()]] != now) co[to[s.top()]] = now, ct++;
if (co[to[s.top() ^ 1]] != now) co[to[s.top() ^ 1]] = now, ct++;
ss[++tp] = s.top();
s.pop();
}
if (co[to[i]] != now) co[to[i]] = now, ct++;
if (co[to[i ^ 1]] != now) co[to[i ^ 1]] = now, ct++;
ss[++tp] = i;
s.pop();
if (pre[x] == low[to[i]] && ct == tp)
for (j = 1; j <= tp; j++) re[++re[0]] = ss[j];
}
} else
low[x] = min(low[x], pre[to[i]]);
}
}
int main() {
int i, x, y;
scanf("%d%d", &n, &m);
memset(co, 0, sizeof co);
for (i = 1; i <= m; i++) {
scanf("%d%d", &x, &y);
add(x, y);
add(y, x);
}
for (i = 1; i <= n; i++)
if (!pre[i]) dfs(i, 0);
printf("%d\n", re[0]);
sort(re + 1, re + re[0] + 1);
for (i = 1; i <= re[0]; i++) printf("%d ", re[i] >> 1);
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
const int maxm = 200020;
int head[maxn], cnt;
void init(int n) {
for (int i = 1; i <= n; i++) head[i] = -1;
cnt = 0;
}
struct edge {
int to, next;
} E[maxm];
void add(int u, int v) {
E[cnt].to = v;
E[cnt].next = head[u];
head[u] = cnt++;
}
int dfn[maxn], low[maxn], s1[maxn], s2[maxn], ebl[maxm], bccnum[maxn], idx, tp1,
tp2, block;
vector<int> bcc[maxn], ebcc[maxn];
void tarjan(int u, int pre) {
low[u] = dfn[u] = ++idx;
s1[++tp1] = u;
for (int i = head[u]; ~i; i = E[i].next) {
int v = E[i].to;
if (v == pre) continue;
if (!dfn[v]) {
s2[++tp2] = i >> 1;
tarjan(v, u);
low[u] = min(low[u], low[v]);
if (low[v] >= dfn[u]) {
block++;
int vv;
do {
vv = s2[tp2--];
ebl[vv] = block;
bccnum[block]++;
ebcc[block].push_back(vv);
} while (vv != (i >> 1));
do {
vv = s1[tp1--];
bcc[block].push_back(vv);
} while (vv != v);
bcc[block].push_back(u);
}
} else if (dfn[v] < dfn[u]) {
s2[++tp2] = i >> 1;
low[u] = min(low[u], dfn[v]);
}
}
}
int ans[maxm];
int main() {
int n, m;
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);
add(v, u);
}
for (int i = 1; i <= n; i++) {
if (!dfn[i]) tarjan(i, -1);
}
int v1 = 0;
for (int i = 1; i <= block; i++) {
if (bccnum[i] == (int)bcc[i].size()) {
for (int j : ebcc[i]) {
ans[++v1] = j + 1;
}
}
}
sort(ans + 1, ans + v1 + 1);
printf("%d\n", v1);
for (int i = 1; i <= v1; i++) printf("%d%c", ans[i], i == v1 ? '\n' : ' ');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using namespace std::chrono;
using pii = pair<int, int>;
using pll = pair<long long, long long>;
const int magic = 3;
void solve();
void dump(const vector<int>& a) {
for (int i = 0; i < a.size(); i++) {
cerr << a[i] << ' ';
}
cerr << endl;
}
template <typename T, int N>
void dump(const array<T, N>& a) {
for (int i = 0; i < a.size(); i++) {
cerr << a[i] << ' ';
}
cerr << endl;
}
int main(int argc, char** argv) {
ios_base::sync_with_stdio(false);
cin.tie(0);
int t = 1;
for (int tt = 1; tt <= t; tt++) {
solve();
}
return 0;
}
const int MX = 200500;
vector<pii> e[MX];
bool visited[MX];
int depth[MX];
struct cycle {
int root{-1};
vector<int> edges;
bool is_simple{true};
};
int get_lc(int u, int v) {
if (depth[u] < depth[v]) {
return u;
}
return v;
}
void add_cycle(cycle& a, cycle& b) {
if (b.root == -1) {
return;
}
if (a.root == -1) {
swap(a, b);
return;
}
a.root = get_lc(a.root, b.root);
a.is_simple = false;
a.edges.clear();
}
vector<int> ans;
void add_ans(const vector<int>& sp) {
for (auto w : sp) {
ans.push_back(w);
}
}
cycle dfs(int u, int pr, int edge_number) {
visited[u] = true;
depth[u] = depth[pr] + 1;
cycle res;
for (auto p : e[u]) {
int v = p.first;
if (v == pr) {
continue;
}
if (visited[v]) {
if (depth[v] > depth[u]) {
continue;
}
cycle curr;
curr.root = v;
curr.edges.push_back(p.second);
add_cycle(res, curr);
continue;
}
auto r = dfs(v, u, p.second);
add_cycle(res, r);
}
if (res.is_simple) {
res.edges.push_back(edge_number);
if (res.root == pr) {
add_ans(res.edges);
}
}
if (res.root == pr) {
res = cycle();
}
return res;
}
void solve() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
e[u].emplace_back(v, i);
e[v].emplace_back(u, i);
}
for (int u = 0; u < n; u++) {
if (!visited[u]) {
dfs(u, u, -1);
}
}
cout << ans.size() << "\n";
sort(ans.begin(), ans.end());
for (auto w : ans) {
cout << w + 1 << ' ';
}
cout << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
struct Edge {
int to, nxt;
} e[N * 2];
int n, m, head[N], cntE = 1, dfn[N], low[N], ids;
int stk[N * 3], tp, col[N], tot;
set<int> ans, nd[N], eg[N];
inline void add(int u, int v) {
e[++cntE] = (Edge){v, head[u]}, head[u] = cntE;
}
void Tarjan(int u, int f) {
dfn[u] = low[u] = ++ids;
for (int i = head[u], v; i; i = e[i].nxt)
if (!dfn[v = e[i].to]) {
stk[++tp] = i >> 1, stk[++tp] = u, stk[++tp] = v;
Tarjan(v, i), low[u] = min(low[u], low[v]);
if (low[v] >= dfn[u]) {
++tot;
for (;;) {
int t1, t2;
nd[tot].insert(t1 = stk[tp--]);
nd[tot].insert(t2 = stk[tp--]);
eg[tot].insert(stk[tp--]);
if (t1 == v && t2 == u) break;
}
}
} else if (dfn[v] < dfn[u] && (i ^ 1) != f) {
stk[++tp] = i >> 1, stk[++tp] = u, stk[++tp] = v;
low[u] = min(low[u], dfn[v]);
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1, a, b; i <= m; ++i)
scanf("%d%d", &a, &b), add(a, b), add(b, a);
for (int i = 1; i <= n; ++i) Tarjan(i, 0);
for (int i = 1; i <= tot; ++i)
if (nd[i].size() == eg[i].size()) ans.insert(eg[i].begin(), eg[i].end());
printf("%d\n", ans.size());
for (int i : ans) printf("%d ", i);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
using namespace std;
template <class T>
inline bool setmin(T &a, T b) {
if (a > b) return a = b, 1;
return 0;
}
template <class T>
inline bool setmax(T &a, T b) {
if (a < b) return a = b, 1;
return 0;
}
template <class T>
inline T fast(T a, T b, T mod) {
long long res = 1;
while (b) {
if (b & 1) res = (res * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return res;
}
template <class T>
istream &operator>>(istream &os, vector<T> &container) {
for (auto &u : container) os >> u;
return os;
}
template <class T>
ostream &operator<<(ostream &os, const vector<T> &container) {
for (auto &u : container) os << u << " ";
return os;
}
template <class T>
inline T gcd(T a, T b) {
while (b) swap(a %= b, b);
return abs(a);
}
const long long INF = 1e9 + 7;
const long long mod = 998244353;
const long long BIG_INF = 1e18 + 7;
const long long N = 1e6 + 7;
const long long T = 1 << 20;
const long double inf = 1e18;
long long m, n, k, q;
long long roz[N];
long long rep[N];
long long odw[N];
long long preorder[N];
vector<vector<pair<long long, long long> > > G(N);
long long cnt;
vector<long long> ans;
long long Find(long long x) {
return (x == rep[x] ? x : rep[x] = Find(rep[x]));
}
void Union(long long a, long long b) {
assert(a and b);
a = Find(a);
b = Find(b);
if (a == b) return;
roz[b] += roz[a];
rep[a] = b;
}
pair<long long, long long> lepszy(pair<long long, long long> a,
pair<long long, long long> b) {
return (a.first < b.first ? a : b);
}
void polacz(pair<long long, long long> &najw, pair<long long, long long> temp,
long long v) {
if (temp.first == preorder[v] or temp.first == INF) return;
if (najw.first == INF) {
najw = temp;
return;
}
Union(najw.second, temp.second);
najw = lepszy(najw, temp);
}
pair<long long, long long> dfs(long long x, long long przodek = -1) {
odw[x] = 1;
preorder[x] = cnt++;
pair<long long, long long> najwyzszy = {INF, 0};
vector<pair<long long, long long> > nad;
for (auto &u : G[x])
if (odw[u.first] and u.first != przodek)
nad.push_back({preorder[u.first], u.second});
for (auto &u : G[x])
if (!odw[u.first]) polacz(najwyzszy, dfs(u.first, x), x);
for (auto &u : nad) polacz(najwyzszy, u, x);
return najwyzszy;
}
pair<long long, long long> dfs2(long long x, long long przodek = -1,
long long nr = -1) {
odw[x] = 1;
pair<long long, long long> najwyzszy = {INF, 0};
vector<pair<long long, long long> > nad;
for (auto &u : G[x])
if (odw[u.first] and u.first != przodek)
nad.push_back({preorder[u.first], u.second});
for (auto &u : G[x])
if (!odw[u.first]) polacz(najwyzszy, dfs2(u.first, x, u.second), x);
for (auto &u : nad) polacz(najwyzszy, u, x);
if (nr != -1 and najwyzszy.first != INF and
roz[Find(najwyzszy.second)] == 1) {
ans.push_back(nr);
ans.push_back(najwyzszy.second);
}
return najwyzszy;
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (long long i = 0; i < (m + 2); i++) {
rep[i] = i;
roz[i] = 1;
}
for (long long i = 0; i < (m); i++) {
long long a, b;
cin >> a >> b;
G[a].push_back({b, i + 1});
G[b].push_back({a, i + 1});
}
for (long long i = 1; i <= n; i++)
if (!odw[i]) dfs(i);
fill(odw, odw + N, 0);
for (long long i = 1; i <= n; i++)
if (!odw[i]) dfs2(i);
sort((ans).begin(), (ans).end());
ans.resize(unique((ans).begin(), (ans).end()) - ans.begin());
cout << (long long)(ans).size() << '\n' << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int tin[100001], low[100001], he[100001], v[200002], ne[200002];
int st[300003], blo[200002], tot, num, top, tt;
vector<int> ans, edge[100001], node[100001];
void add(int x, int y) { v[++tot] = y, ne[tot] = he[x], he[x] = tot; }
void tarjan(int x, int f) {
tin[x] = low[x] = ++num;
for (int i = he[x]; i; i = ne[i]) {
int y = v[i];
if (!tin[y]) {
st[++top] = i >> 1, st[++top] = x, st[++top] = y;
tarjan(y, x);
low[x] = min(low[x], low[y]);
if (low[y] >= tin[x]) {
tt++;
while (1) {
int t1 = st[top--], t2 = st[top--];
if (blo[t1] != tt) {
node[tt].push_back(t1);
blo[t1] = tt;
}
if (blo[t2] != tt) {
node[tt].push_back(t2);
blo[t2] = tt;
}
edge[tt].push_back(st[top--]);
if (t1 == y && t2 == x) break;
}
}
} else if (tin[y] < tin[x] && y != f) {
st[++top] = i >> 1, st[++top] = x, st[++top] = y;
low[x] = min(low[x], tin[y]);
}
}
}
int main() {
memset(tin, 0, sizeof(tin)), memset(low, 0, sizeof(low)),
memset(he, 0, sizeof(he)), memset(ne, 0, sizeof(ne)),
memset(v, 0, sizeof(v)), memset(st, 0, sizeof(st)),
memset(blo, 0, sizeof(blo));
scanf("%d%d", &n, &m);
tot = 1;
num = top = tt = 0;
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d%d", &x, &y);
if (x == y) continue;
add(x, y), add(y, x);
}
for (int i = 1; i <= n; i++)
if (!tin[i]) tarjan(i, 0);
for (int i = 1; i <= tt; i++) {
if (edge[i].size() == node[i].size()) {
for (int j = 0; j < edge[i].size(); j++) ans.push_back(edge[i][j]);
}
}
sort(ans.begin(), ans.end());
printf("%d\n", ans.size());
for (int i = 0; i < ans.size(); i++) {
if (i == 0)
printf("%d", ans[i]);
else
printf(" %d", ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
const int MAXN = 3e5 + 10;
const double eps = 1e-8;
const int mod = 1e9 + 9;
using namespace std;
struct edge {
int t, v;
edge *next;
} e[MAXN << 1], *h[MAXN], *o = e;
void add(int x, int y, int vul) {
o->t = y;
o->v = vul;
o->next = h[x];
h[x] = o++;
}
long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
return x * f;
}
bool vis[MAXN], Cnode[MAXN];
int dfn[MAXN], low[MAXN], cnt;
void tarjan_node(int x, int pre) {
vis[x] = 1;
dfn[x] = low[x] = ++cnt;
for (edge *j = h[x]; j; j = j->next) {
if (vis[j->t] && dfn[j->t] < dfn[x] && j->t != pre) {
low[x] = min(low[x], dfn[j->t]);
} else if (!vis[j->t]) {
tarjan_node(j->t, x);
if (low[j->t] >= dfn[x]) Cnode[x] = 1;
low[x] = min(low[x], low[j->t]);
}
}
}
int num;
typedef struct node {
int x, y;
} node;
node d[MAXN];
vector<int> p[MAXN];
int st[MAXN], tot, bcc_pos[MAXN];
int ans[MAXN];
bool pis[MAXN];
void tarjan_Bcc(int x, int pre) {
vis[x] = 1;
dfn[x] = low[x] = ++cnt;
int ch = 0;
for (edge *j = h[x]; j; j = j->next) {
if (vis[j->t] && dfn[j->t] < dfn[x] && j->t != pre) {
st[++tot] = j->v;
pis[j->v] = 1;
low[x] = min(low[x], dfn[j->t]);
} else if (!vis[j->t]) {
ch++;
st[++tot] = j->v;
tarjan_Bcc(j->t, x);
low[x] = min(low[x], low[j->t]);
if (low[j->t] >= dfn[x]) {
Cnode[x] = 1;
num++;
p[num].clear();
while (1) {
int y = st[tot--];
if (pis[y]) ans[num]++;
p[num].push_back(y);
if (bcc_pos[d[y].x] != num) {
bcc_pos[d[y].x] = num;
}
if (bcc_pos[d[y].y] != num) {
bcc_pos[d[y].y] = num;
}
if (y == j->v) break;
}
}
}
}
if (!pre && ch <= 1) Cnode[x] = 0;
}
vector<int> vec;
int n, m;
int main() {
n = read();
m = read();
int x, y;
for (int i = 1; i <= m; i++)
d[i].x = read(), d[i].y = read(), add(d[i].x, d[i].y, i),
add(d[i].y, d[i].x, i);
for (int i = 1; i <= n; i++)
if (!vis[i]) tarjan_Bcc(i, 0);
for (int i = 1; i <= num; i++) {
if (ans[i] != 1) continue;
for (int j = 0; j < p[i].size(); j++) vec.push_back(p[i][j]);
}
sort(vec.begin(), vec.end());
int sz = unique(vec.begin(), vec.end()) - vec.begin();
printf("%d\n", sz);
for (int i = 0; i < sz; i++) printf("%d ", vec[i]);
printf("\n");
}
|
#include <bits/stdc++.h>
using namespace std;
struct Edge {
int v, id;
};
set<int> Ans;
vector<Edge> G[100000 + 5];
int cnt;
stack<int> Node;
bool vis[100000 + 5];
int dfn[100000 + 5], Low[100000 + 5];
void Tarjan(int u, int fa) {
Node.push(u);
dfn[u] = Low[u] = ++cnt;
for (auto e : G[u]) {
int v = e.v;
if (!dfn[v]) {
Tarjan(v, u);
Low[u] = min(Low[u], Low[v]);
if (Low[v] >= dfn[u]) {
set<int> E;
vector<int> tmp;
do {
vis[Node.top()] = 1;
tmp.push_back(Node.top());
Node.pop();
} while (!vis[v]);
tmp.push_back(u);
for (int u : tmp)
for (auto e : G[u])
if (vis[e.v]) E.insert(e.id);
if (E.size() == tmp.size()) Ans.insert(E.begin(), E.end());
for (int i : tmp) vis[i] = 0;
}
} else if (v != fa)
Low[u] = min(Low[u], dfn[v]);
}
}
int main() {
int N, M;
scanf("%d%d", &N, &M);
for (int i = 1; i <= M; i++) {
int u, v;
scanf("%d%d", &u, &v);
G[u].push_back({v, i});
G[v].push_back({u, i});
}
for (int i = 1; i <= N; i++)
if (!dfn[i]) Tarjan(i, -1);
printf("%d\n", Ans.size());
for (auto i : Ans) printf("%d ", i);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
struct edge {
int u, v, id;
} stk[N + N];
vector<edge> adj[N];
int n, m, ptr, ui[N], vi[N];
int dfn[N], low[N], used[N], dft;
set<int> ans, in, eg;
void dfs(int u, int p) {
dfn[u] = low[u] = ++dft;
for (auto e : adj[u])
if (!dfn[e.v]) {
stk[++ptr] = e;
dfs(e.v, u);
low[u] = min(low[u], low[e.v]);
} else {
if (!used[e.id]) {
stk[++ptr] = e;
low[u] = min(low[u], dfn[e.v]);
}
}
if (low[u] == dfn[p]) {
in.clear();
eg.clear();
while (true) {
eg.insert(stk[ptr].id);
if (stk[ptr--].u == p) break;
}
}
for (auto v : eg) {
in.insert(ui[v]);
in.insert(vi[v]);
used[v] = 1;
}
if (in.size() == eg.size()) {
for (auto o : eg) ans.insert(o);
}
}
int main() {
cin >> n >> m;
int u, v;
for (int i = 1; i <= m; i++) {
cin >> u >> v;
tie(ui[i], vi[i]) = tie(u, v);
adj[u].push_back((edge){u, v, i});
adj[v].push_back((edge){v, u, i});
}
for (int i = 1; i <= n; i++)
if (!dfn[i]) dfs(i, 0);
cout << ans.size() << '\n';
for (auto v : ans) cout << v << ' ';
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const long long maxn = 3e6;
const long long mod = 1e9 + 7;
const long double PI = acos((long double)-1);
long long pw(long long a, long long b, long long md = mod) {
long long res = 1;
while (b) {
if (b & 1) {
res = (a * res) % md;
}
a = (a * a) % md;
b >>= 1;
}
return (res);
}
int n, m;
vector<pair<pair<int, int>, int> > e;
vector<int> adj[maxn], ans;
int mark[maxn];
int h[maxn], par[maxn];
int a[maxn], prt[maxn];
int sum[maxn];
vector<int> ord;
void dfs(int v) {
ord.push_back(v), mark[v] = 1;
for (auto u : adj[v])
if (!mark[u]) par[u] = v, h[u] = h[v] + 1, dfs(u);
}
void calc(int v) {
mark[v] = 2;
prt[v] = a[v];
for (auto u : adj[v])
if (mark[u] != 2) calc(u), prt[v] += prt[u];
}
void hentai(int v) {
mark[v] = 3;
for (auto u : adj[v])
if (mark[u] != 3) sum[u] = prt[u] + sum[v], hentai(u);
}
bool can[maxn];
int ed(int u, int v) {
if (u > v) swap(u, v);
if (u == 0) return (0);
return ((*lower_bound(e.begin(), e.end(),
pair<pair<int, int>, int>(pair<int, int>(u, v), 0)))
.second);
}
void solve(int v) {
ord.clear();
dfs(v);
for (auto v : ord) {
for (auto u : adj[v]) {
if (h[u] < h[v] and u != par[v]) a[v]++, a[u]--;
}
}
calc(v);
hentai(v);
for (auto v : ord) {
for (auto u : adj[v]) {
if (h[u] < h[v] and u != par[v]) {
if (sum[v] - sum[u] > h[v] - h[u])
a[v] -= 1e6, a[u] += 1e6, can[ed(u, v)] = 0;
}
}
}
calc(v);
for (auto v : ord)
if (prt[v] != 1) can[ed(v, par[v])] = 0;
}
int32_t main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
if (u > v) swap(u, v);
adj[u].push_back(v);
adj[v].push_back(u);
e.push_back({{u, v}, i});
}
for (int i = 1; i <= m; i++) can[i] = 1;
sort(e.begin(), e.end());
for (int i = 1; i <= n; i++)
if (!mark[i]) solve(i);
for (int i = 1; i <= m; i++)
if (can[i]) ans.push_back(i);
cout << ans.size() << '\n';
for (int i : ans) cout << i << ' ';
return (0);
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxx = 1e5 + 7;
int n, m;
int par[maxx], par_E[maxx], h[maxx], cnt[maxx];
bool mark[maxx];
vector<int> ans, Back_Edge, yal[maxx];
pair<int, int> Edge[maxx];
void DFS(int v) {
mark[v] = true;
for (auto e : yal[v]) {
int u;
int a = Edge[e].first;
int b = Edge[e].second;
if (a == v)
u = b;
else
u = a;
if (!mark[u]) {
par[u] = v;
par_E[u] = e;
h[u] = h[v] + 1;
DFS(u);
} else {
if (h[u] < h[v] && h[v] - h[u] != 1) {
Back_Edge.push_back(e);
cnt[v]++;
cnt[u]--;
}
}
}
}
void dfs(int v) {
mark[v] = true;
for (auto e : yal[v]) {
int u;
int a = Edge[e].first;
int b = Edge[e].second;
if (v == a)
u = b;
else
u = a;
if (!mark[u]) dfs(u), cnt[v] += cnt[u];
}
}
void DFS_ALL(int t) {
for (int i = 0; i < n; i++) {
if (!mark[i] && t == 0)
DFS(i);
else if (!mark[i] && t == 1)
dfs(i);
}
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
yal[u].push_back(i);
yal[v].push_back(i);
Edge[i] = {u, v};
}
DFS_ALL(0);
memset(mark, 0, sizeof mark);
DFS_ALL(1);
for (int i = 0; i < n; i++)
if (cnt[i] != 1) cnt[i] = -1;
for (auto i : Back_Edge) {
int v = Edge[i].first;
int u = Edge[i].second;
if (h[u] < h[v]) swap(u, v);
bool valid = true;
while (u != v) {
if (cnt[u] != 1) {
valid = false;
break;
}
u = par[u];
}
if (valid) {
int v = Edge[i].first;
int u = Edge[i].second;
if (h[u] < h[v]) swap(u, v);
ans.push_back(i);
while (u != v) ans.push_back(par_E[u]), u = par[u];
}
}
cout << (int)ans.size() << "\n";
sort(ans.begin(), ans.end());
for (auto i : ans) cout << i + 1 << " ";
cout << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
int a, b, c, d, e, i, j, zx, xc, lf[100009], rg[100009], tim, lc[100009][19],
lcmax[100009][19], cnt, pas[100009], k[100009], ans[100009], p[100009], pi,
jm[100009];
pair<int, int> ed[100009];
vector<int> v[100009], msh[100009], shv[100009];
vector<pair<int, int> > vv;
set<pair<int, int> > s;
set<pair<int, int> >::iterator t;
map<pair<int, int>, bool> m;
int bo[100009];
void dfs(int q, int w) {
tim++;
lc[q][0] = w;
for (int hh = 1; hh <= 17; hh++) lc[q][hh] = lc[lc[q][hh - 1]][hh - 1];
lf[q] = rg[q] = tim;
k[lf[q]] = q;
bo[q] = cnt;
for (vector<int>::iterator it = v[q].begin(); it != v[q].end(); it++) {
if ((*it) == w) continue;
if (bo[(*it)] == cnt) {
if (lf[(*it)] < lf[q]) {
msh[q].push_back((*it));
shv[(*it)].push_back(q);
vv.push_back(make_pair((*it), q));
}
continue;
}
dfs((*it), q);
if (rg[q] < rg[(*it)]) rg[q] = rg[(*it)];
}
}
bool anc(int q, int w) {
if (lf[q] <= lf[w] && rg[q] >= rg[w])
return 1;
else
return 0;
}
void dfs2(int q, int w) {
bo[q] = cnt;
t = s.lower_bound(make_pair(lf[q], 0));
if (t == s.end()) {
ans[q] = 0;
} else {
if ((*t).first <= rg[q]) {
ans[q] = m[make_pair(k[(*t).second], k[(*t).first])];
} else {
ans[q] = 0;
}
}
for (vector<int>::iterator it = shv[q].begin(); it != shv[q].end(); it++) {
s.insert(make_pair(lf[(*it)], lf[q]));
}
for (vector<int>::iterator it = v[q].begin(); it != v[q].end(); it++) {
if (bo[(*it)] == cnt) continue;
dfs2((*it), q);
}
for (vector<int>::iterator it = shv[q].begin(); it != shv[q].end(); it++) {
s.erase(s.lower_bound(make_pair(lf[(*it)], lf[q])));
}
}
void dfs3(int q, int w) {
bo[q] = cnt;
for (vector<int>::iterator it = v[q].begin(); it != v[q].end(); it++) {
if (bo[(*it)] == cnt) continue;
dfs3((*it), q);
jm[q] += jm[(*it)];
}
}
void dfs4(int q, int w) {
bo[q] = cnt;
lcmax[q][0] = jm[q];
for (int hh = 1; hh <= 17; hh++)
lcmax[q][hh] = max(lcmax[q][hh - 1], lcmax[lc[q][hh - 1]][hh - 1]);
for (vector<int>::iterator it = v[q].begin(); it != v[q].end(); it++) {
if (bo[(*it)] == cnt) continue;
dfs4((*it), q);
}
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> a >> b;
for (i = 1; i <= b; i++) {
cin >> c >> d;
ed[i].first = c;
ed[i].second = d;
v[c].push_back(d);
v[d].push_back(c);
}
cnt++;
for (i = 1; i <= a; i++) {
if (bo[i] == cnt) continue;
dfs(i, 0);
}
for (i = 0; i < vv.size(); i++) {
c = vv[i].first;
d = vv[i].second;
jm[c]--;
jm[d]++;
}
cnt++;
for (i = 1; i <= a; i++) {
if (bo[i] == cnt) continue;
dfs3(i, 0);
}
cnt++;
for (i = 1; i <= a; i++) {
if (bo[i] == cnt) continue;
dfs4(i, 0);
}
for (i = 0; i < vv.size(); i++) {
c = vv[i].first;
d = vv[i].second;
e = 0;
for (int hh = 17; hh >= 0; hh--) {
if (lc[d][hh] != 0 && anc(lc[d][hh], c) == 0) {
if (e < lcmax[d][hh]) e = lcmax[d][hh];
d = lc[d][hh];
}
}
if (e < lcmax[d][0]) e = lcmax[d][0];
if (e <= 1) {
m[vv[i]] = 1;
}
}
cnt++;
for (i = 1; i <= a; i++) {
if (bo[i] == cnt) continue;
dfs2(i, 0);
}
for (i = 1; i <= b; i++) {
c = ed[i].first;
d = ed[i].second;
if (lf[c] > lf[d]) swap(c, d);
if (ans[d] == 1) {
pi++;
p[pi] = i;
}
}
cout << pi << endl;
for (i = 1; i <= pi; i++) {
cout << p[i] << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
const int mod = 1e9 + 7;
vector<int> g_bcc[maxn], f, ans;
vector<pair<int, int> > g[maxn];
pair<int, int> edge[maxn];
int pre[maxn], low[maxn], bcc[maxn];
int dfs_t, bcc_cnt;
stack<int> ST;
void dfs(int u, int fa) {
pre[u] = low[u] = ++dfs_t;
for (auto vx : g[u]) {
int v = vx.first;
if (!pre[v]) {
ST.push(vx.second);
dfs(v, u);
low[u] = min(low[u], low[v]);
if (low[v] >= pre[u]) {
g_bcc[++bcc_cnt].clear();
f.clear();
while (!ST.empty()) {
int e = ST.top();
f.push_back(e);
ST.pop();
if (bcc[edge[e].first] != bcc_cnt) {
g_bcc[bcc_cnt].push_back(edge[e].first);
bcc[edge[e].first] = bcc_cnt;
}
if (bcc[edge[e].second] != bcc_cnt) {
g_bcc[bcc_cnt].push_back(edge[e].second);
bcc[edge[e].second] = bcc_cnt;
}
if (e == vx.second) break;
}
if (f.size() == g_bcc[bcc_cnt].size()) {
for (auto x : f) ans.push_back(x);
}
}
} else if (pre[v] < pre[u] && v != fa) {
ST.push(vx.second);
low[u] = min(low[u], pre[v]);
}
}
}
int main() {
int n, m, i, u, v;
scanf("%d%d", &n, &m);
for (i = 1; i <= m; i++) {
scanf("%d%d", &u, &v);
g[u].push_back(pair<int, int>(v, i));
g[v].push_back(pair<int, int>(u, i));
edge[i] = pair<int, int>(u, v);
}
for (i = 1; i <= n; i++) {
if (!pre[i]) dfs(i, 0);
}
sort(ans.begin(), ans.end());
printf("%d\n", (int)ans.size());
for (auto x : ans) printf("%d ", x);
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
int n, m, tot, top, h[maxn], tin[maxn], low[maxn], st[maxn * 3], now = 0,
cnt = 1;
struct edges {
int nxt, to;
} e[maxn << 1];
set<int> ans, edge[maxn], node[maxn];
void addline(int u, int v) { e[++cnt] = edges{h[u], v}, h[u] = cnt; }
void tarjan(int u, int f) {
tin[u] = low[u] = ++now;
for (int i = h[u]; i; i = e[i].nxt) {
int v = e[i].to;
if (!tin[v]) {
st[++top] = i >> 1, st[++top] = u, st[++top] = v;
tarjan(v, u);
low[u] = min(low[u], low[v]);
if (tin[u] <= low[v]) {
tot++;
while (1) {
int t1, t2;
node[tot].insert(t1 = st[top--]);
node[tot].insert(t2 = st[top--]);
edge[tot].insert(st[top--]);
if (t1 == v && t2 == u) break;
}
}
} else if (tin[v] < tin[u] && v != f) {
st[++top] = i >> 1, st[++top] = u, st[++top] = v;
low[u] = min(low[u], tin[v]);
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
addline(u, v), addline(v, u);
}
for (int i = 1; i <= n; i++) {
if (!tin[i]) tarjan(i, 0);
}
for (int i = 1; i <= tot; i++) {
if (edge[i].size() == node[i].size()) {
ans.insert(edge[i].begin(), edge[i].end());
}
}
printf("%d\n", (int)ans.size());
for (int u : ans) printf("%d ", u);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 gen(880907);
template <typename T1, typename T2>
ostream& operator<<(ostream& out, const pair<T1, T2>& p) {
out << p.first << " " << p.second;
return out;
}
struct BccVertex {
int n, nScc, step, dfn[200005], low[200005];
vector<int> E[200005], sccv[200005];
int top, stk[200005];
void init(int _n) {
n = _n;
nScc = step = 0;
for (int i = 0; i < n; i++) E[i].clear();
}
void addEdge(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);
}
} else
low[u] = min(low[u], dfn[v]);
}
}
vector<vector<int>> solve() {
vector<vector<int>> res;
for (int i = 0; i < n; i++) dfn[i] = low[i] = -1;
for (int i = 0; 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;
vector<set<int>> bln;
vector<vector<int>> bcc, cans;
vector<pair<int, int>> edge;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
bln.resize(n);
edge.resize(m);
graph.init(n);
for (int i = 0, a, b; i < m; i++) {
cin >> a >> b;
--a, --b;
edge[i] = {a, b};
graph.addEdge(a, b);
}
bcc = graph.solve();
for (int i = 0; i < bcc.size(); i++) {
for (auto j : bcc[i]) {
bln[j].insert(i);
}
}
vector<int> num(bcc.size());
cans.resize(bcc.size());
for (int i = 0; i < m; i++) {
if (bln[edge[i].first].size() > bln[edge[i].second].size())
swap(edge[i].first, edge[i].second);
for (auto j : bln[edge[i].first]) {
if (bln[edge[i].second].count(j)) {
num[j]++;
cans[j].push_back(i + 1);
break;
}
}
}
vector<int> single, ans;
for (int i = 0; i < bcc.size(); i++) {
if (bcc[i].size() == num[i]) {
for (auto j : cans[i]) ans.push_back(j);
}
}
sort(ans.begin(), ans.end());
cout << ans.size() << '\n';
for (auto i : ans) cout << i << " ";
cout << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
vector<int> G[MAXN];
vector<int> grafo[MAXN];
struct edge {
int u, v, comp;
bool bridge;
};
vector<edge> e;
void addEdge(int u, int v) {
G[u].push_back(e.size()), G[v].push_back(e.size());
e.push_back((edge){u, v, -1, false});
}
int V[MAXN], L[MAXN], P[MAXN], comp[MAXN];
int qV, nbc;
void initDfs(int n) {
for (int i = (0); i < (MAXN); i++) G[i].clear();
memset(G, 0, sizeof(G)), memset(V, 0, sizeof(V)), memset(L, 0, sizeof(L)),
memset(comp, 0, sizeof(comp)), memset(P, 0, sizeof(P));
e.clear();
for (int i = (0); i < (n); i++) V[i] = -1;
nbc = qV = 0;
}
stack<int> st;
void dfs(int u, int pe) {
L[u] = V[u] = qV++;
comp[u] = (pe != -1);
for (auto &ne : G[u])
if (ne != pe) {
int v = e[ne].u ^ e[ne].v ^ u;
if (V[v] == -1) {
st.push(ne);
dfs(v, ne);
if (L[v] > V[u]) {
e[ne].bridge = true;
}
P[u] += (L[v] >= V[u]);
if (L[v] >= V[u]) {
int last;
do {
last = st.top();
st.pop();
e[last].comp = nbc;
} while (last != ne);
nbc++;
comp[u]++;
}
L[u] = min(L[u], L[v]);
} else if (V[v] < V[u]) {
st.push(ne);
L[u] = min(L[u], V[v]);
}
}
}
set<int> C[2 * MAXN];
int compnodo[MAXN];
int ptoart;
void blockcuttree() {
memset(compnodo, 0, sizeof(compnodo));
ptoart = 0;
for (int i = (0); i < (2 * MAXN); i++) C[i].clear();
for (auto &it : e) {
vector<int> nodos = {it.u, it.v};
for (int u : nodos) {
if (comp[u] == 1)
compnodo[u] = it.comp;
else {
if (compnodo[u] == 0) {
compnodo[u] = nbc + ptoart;
ptoart++;
}
C[it.comp].insert(compnodo[u]);
C[compnodo[u]].insert(it.comp);
}
}
}
}
map<pair<int, int>, int> id_eje;
map<pair<int, int>, int> eje_componente;
bool visitado[MAXN];
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m;
cin >> n >> m;
initDfs(n + 1);
for (int i = (0); i < (m); i++) {
long long a, b;
cin >> a >> b;
a--;
b--;
id_eje[{a, b}] = i + 1;
id_eje[{b, a}] = i + 1;
grafo[a].push_back(b);
grafo[b].push_back(a);
addEdge(a, b);
}
for (int i = (0); i < (n); i++) {
if (V[i] == -1) {
dfs(i, -1);
}
}
vector<edge> ejesPorComponente[nbc];
for (auto &eje : e) {
eje_componente[{eje.u, eje.v}] = eje.comp;
eje_componente[{eje.v, eje.u}] = eje.comp;
ejesPorComponente[eje.comp].push_back(eje);
}
vector<int> res;
for (int i = (0); i < (nbc); i++) {
if ((int)(ejesPorComponente[i]).size() <= 2) continue;
bool simple = true;
map<int, int> apariciones_por_nodo;
for (auto &eje : ejesPorComponente[i]) {
apariciones_por_nodo[eje.u]++;
apariciones_por_nodo[eje.v]++;
if (apariciones_por_nodo[eje.u] > 2 || apariciones_por_nodo[eje.v] > 2) {
simple = false;
break;
}
}
if (simple) {
for (auto &eje : ejesPorComponente[i]) {
res.push_back(id_eje[{eje.u, eje.v}]);
}
}
}
sort(res.begin(), res.end());
cout << (int)(res).size() << "\n";
for (auto it = res.begin(); it != res.end(); it++) {
cout << *it << " ";
}
cout << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
struct edge {
int u, v, second;
edge() {}
edge(int a, int b, int c) {
u = a;
v = b;
second = c;
}
};
vector<edge> adj[100005];
int N, M;
int low[100005], disc[100005], art[100005], par[100005];
int times = 1;
bitset<100005> vis;
stack<edge> st;
vector<int> ans;
set<int> V, E;
void DFS(int u, int p) {
low[u] = disc[u] = times++;
for (edge e : adj[u]) {
int v = e.u;
if (!disc[v]) {
st.push(e);
DFS(v, u);
low[u] = min(low[u], low[v]);
} else if (!vis[e.second]) {
st.push(e);
low[u] = min(low[u], disc[v]);
}
}
if (low[u] == disc[p]) {
V.clear();
E.clear();
while (1) {
edge now = st.top();
st.pop();
V.insert(now.u);
V.insert(now.v);
E.insert(now.second);
vis[now.second] = 1;
if (now.v == p) break;
}
if (E.size() == V.size()) {
for (auto i : E) {
ans.push_back(i);
}
}
}
}
int main() {
scanf("%d %d", &N, &M);
int u, v;
for (int i = 1; i <= M; i++) {
scanf("%d %d", &u, &v);
adj[u].push_back(edge(v, u, i));
adj[v].push_back(edge(u, v, i));
}
for (int i = 1; i <= N; i++) {
if (!disc[i]) {
DFS(i, 0);
}
}
printf("%d\n", ans.size());
if (!ans.size()) {
return 0;
}
sort(ans.begin(), ans.end());
for (int i : ans) {
cout << i << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200000 + 5, maxm = 200000 + 5;
int n, m;
struct Edge {
int u, v, idx, nxt;
Edge(int u = 0, int v = 0) : u(u), v(v) {}
bool operator==(const Edge& rhs) const { return u == rhs.u && v == rhs.v; }
} edge[maxm];
int head[maxn], top;
int stamp, dfn[maxn], low[maxn], belong[maxn], bccno, bccsz[maxn];
bool iscut[maxn], vis[maxm];
stack<Edge> st;
vector<int> bcc[maxn];
void init() {
memset(head, -1, sizeof(head));
memset(dfn, 0, sizeof(dfn));
memset(low, 0, sizeof(low));
memset(iscut, 0, sizeof(iscut));
memset(belong, 0, sizeof(belong));
memset(bccsz, 0, sizeof(bccsz));
memset(vis, 0, sizeof(vis));
top = 0;
stamp = 0;
bccno = 0;
while (!st.empty()) st.pop();
}
void addedge(int u, int v, int idx) {
edge[top].u = u;
edge[top].v = v;
edge[top].idx = idx;
edge[top].nxt = head[u];
head[u] = top++;
edge[top].u = v;
edge[top].v = u;
edge[top].idx = idx;
edge[top].nxt = head[v];
head[v] = top++;
}
void tarjan(int u, int fa) {
dfn[u] = low[u] = ++stamp;
int child = 0;
for (int i = head[u]; i != -1; i = edge[i].nxt) {
int v = edge[i].v, cidx = edge[i].idx;
if (v == fa || vis[i]) continue;
vis[i] = vis[i ^ 1] = 1;
st.push(edge[i]);
if (!dfn[v]) {
child++;
tarjan(v, u);
if (low[v] < low[u]) low[u] = low[v];
if (low[v] >= dfn[u]) {
iscut[u] = 1;
bcc[++bccno].clear();
do {
int uu = st.top().u, vv = st.top().v, idx = st.top().idx;
if (belong[uu] != bccno) belong[uu] = bccno, bccsz[bccno]++;
if (belong[vv] != bccno) belong[vv] = bccno, bccsz[bccno]++;
bcc[bccno].push_back(idx);
if (idx == cidx) {
st.pop();
break;
}
st.pop();
} while (!st.empty());
}
} else {
if (dfn[v] < low[u]) low[u] = dfn[v];
}
}
if (u == fa && child <= 1) iscut[u] = 0;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
init();
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
addedge(u, v, i);
}
for (int i = 1; i <= n; i++)
if (!dfn[i]) tarjan(i, i);
vector<int> ans;
for (int i = 1; i <= bccno; i++) {
if (bcc[i].size() == bccsz[i]) {
ans.insert(ans.end(), bcc[i].begin(), bcc[i].end());
}
}
sort(ans.begin(), ans.end());
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++) {
cout << ans[i] << ' ';
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100010, M = 200010;
int h[N], e[M], ne[M], idx;
int dfn[N], low[N], bj[N], stk[M], belong[M], isCut[N], num[N], mark[M];
int bccnum, tt = -1, indx, enums;
int n, m, x, y;
pair<int, int> edges[M];
vector<int> v[N], ans;
void add(int a, int b) { e[idx] = b, ne[idx] = h[a], h[a] = idx++; }
void tarjan(int u, int father) {
dfn[u] = low[u] = ++indx;
int child = 0;
for (int i = h[u]; ~i; i = ne[i]) {
int v = e[i];
if (mark[i]) continue;
mark[i] = mark[i ^ 1] = 1;
stk[++tt] = i;
if (!dfn[v]) {
child++;
tarjan(v, u);
low[u] = min(low[u], low[v]);
if (dfn[u] <= low[v]) {
isCut[u] = 1;
bccnum++;
for (;;) {
int j = stk[tt--];
if (bj[e[j]] != bccnum) {
bj[e[j]] = bccnum;
num[bccnum]++;
edges[++enums] = {e[j], bccnum};
}
if (bj[e[j ^ 1]] != bccnum) {
bj[e[j ^ 1]] = bccnum;
num[bccnum]++;
edges[++enums] = {e[j ^ 1], bccnum};
}
belong[(j >> 1) + 1] = bccnum;
if (i == j) break;
}
}
} else
low[u] = min(low[u], dfn[v]);
}
if (u == father && child < 2) isCut[u] = 0;
}
int main() {
memset(h, -1, sizeof h);
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]) tarjan(i, i);
for (int i = 1; i <= m; i++) v[belong[i]].push_back(i);
for (int i = 1; i <= bccnum; i++)
if (v[i].size() == num[i])
for (auto x : v[i]) ans.push_back(x);
sort(ans.begin(), ans.end());
cout << ans.size() << endl;
for (auto x : ans) cout << x << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 102000;
int n, m;
struct Edge {
int from, to;
} E[Maxn];
vector<pair<int, int> > G[Maxn];
int dfn[Maxn], f[Maxn], dd[Maxn], cl, pt[Maxn];
int chs[Maxn], lnk[Maxn];
vector<int> ans;
vector<int> t[Maxn];
void tarjan(int now, int fa) {
dfn[now] = ++cl;
pt[now] = fa;
for (int i = 0; i < G[now].size(); i++) {
pair<int, int> pr = G[now][i];
if (pr.first == fa) continue;
if (!dfn[pr.first]) {
t[now].push_back(pr.first);
chs[pr.second] = 1;
lnk[pr.first] = pr.second;
tarjan(pr.first, now);
} else {
if (dfn[pr.first] > dfn[now]) continue;
f[now]++;
f[pr.first]--;
}
}
}
int im[Maxn];
void dfs2(int now) {
for (int i = 0; i < t[now].size(); i++) {
dfs2(t[now][i]);
dd[now] += dd[t[now][i]];
}
dd[now] += f[now];
}
void dfs3(int now) {
im[now] = im[pt[now]] + (dd[now] > 1);
for (int i = 0; i < t[now].size(); i++) {
dfs3(t[now][i]);
}
}
void solve(int now) {
if (dfn[E[now].from] < dfn[E[now].to]) swap(E[now].from, E[now].to);
int kk = im[E[now].from] - im[E[now].to];
if (kk == 0) {
int pla = E[now].from;
while (pla != E[now].to) {
ans.push_back(lnk[pla]);
pla = pt[pla];
}
ans.push_back(now);
}
}
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]) {
tarjan(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;
const int NN = 1e5 + 10;
int head[NN], to[NN << 1], nxt[NN << 1];
int E = 0, ind, cnt, top;
int low[NN], vst[NN], st[NN << 1];
vector<int> con[NN], ans;
int pv[NN << 1], id[NN << 1];
int add(int u, int v, int w) {
nxt[E] = head[u];
pv[E] = u;
to[E] = v;
id[E] = w;
head[u] = E++;
nxt[E] = head[v];
pv[E] = v;
to[E] = u;
id[E] = w;
head[v] = E++;
}
void dfs(int u, int pa = 0) {
vst[u] = low[u] = ++ind;
for (int e = head[u]; ~e; e = nxt[e]) {
int v = to[e];
if (vst[v] < vst[u]) st[top++] = e;
if (!vst[v]) {
dfs(v, u), low[u] = min(low[u], low[v]);
if (low[v] >= vst[u]) {
con[++cnt].clear();
do --top, con[cnt].push_back(st[top] & 1 ? st[top] ^ 1 : st[top]);
while (st[top] != e);
sort(con[cnt].begin(), con[cnt].end());
con[cnt].resize(unique(con[cnt].begin(), con[cnt].end()) -
con[cnt].begin());
}
} else if (pa != v)
low[u] = min(low[u], vst[v]);
}
}
int main() {
memset(head, -1, sizeof head);
int n, m;
cin >> n >> m;
for (int i = 1, u, v; i <= m; i++) cin >> u >> v, add(u, v, i);
for (int i = 1; i <= n; i++)
if (!vst[i]) dfs(i);
for (int i = 1; i <= cnt; i++) {
set<int> st;
for (auto r : con[i]) st.insert(to[r]), st.insert(pv[r]);
if (st.size() == con[i].size())
for (auto r : con[i]) ans.push_back(id[r]);
}
cout << ans.size() << endl;
sort(ans.begin(), ans.end());
for (auto &r : ans) printf("%d ", r);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const long long inff = 4557430888798830399ll;
const double pi = acos(-1.0);
long long mod = 1e9 + 7;
map<int, map<int, int> > eid;
struct DCC {
DCC() { init(0, NULL); }
void init(int _n, vector<int>* _N) {
n = _n;
N = _N;
t = -1;
m = 0;
memset(dfn, 0, sizeof(dfn));
memset(low, 0, sizeof(low));
};
int n, t, m, dfn[100005], low[100005], s[100005];
vector<int>* N;
vector<int> cut, D[100005];
void dfs(int u, int d, int p) {
int sec = 0, son = d > 1;
dfn[u] = low[u] = d;
s[++t] = u;
for (auto v : N[u]) {
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);
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);
}
int z[100005];
vector<int> E;
void excu() {
memset(z, 0, sizeof(z));
E.clear();
vector<int> e;
for (int i = (1); i <= (m); ++i) {
e.clear();
for (auto u : D[i]) z[u] = i;
for (auto u : D[i])
for (auto v : N[u])
if (z[v] == i) e.push_back(eid[u][v]);
if (((int)e.size()) == ((int)D[i].size()) * 2) {
sort((e).begin(), (e).end());
e.erase(unique((e).begin(), (e).end()), e.end());
for (auto ei : e) E.push_back(ei);
}
}
sort((E).begin(), (E).end());
cout << ((int)E.size()) << endl;
for (int i = (0); i < (((int)E.size())); ++i)
cout << E[i] << " \n"[i == ((int)E.size()) - 1];
}
};
DCC s;
vector<int> N[100005];
int main() {
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);
eid[u][v] = eid[v][u] = i;
}
s.init(n, N);
s.run();
s.excu();
}
|
#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 MAXN = 100005;
int n, m;
struct Edge {
int u, v;
int next;
int ontree;
} E[MAXN * 2];
int header[MAXN], tot = 0;
int vis[MAXN], d[MAXN], dsum[MAXN];
int valpoint[MAXN], link[MAXN];
int ansnum = 0, reverseans[MAXN * 2], ans[MAXN];
int which[MAXN], cnt = 0, root[MAXN];
void addEdge(int u, int v) {
E[++tot].u = u;
E[tot].v = v;
E[tot].ontree = 0;
E[tot].next = header[u];
header[u] = tot;
}
void predfs(int x) {
which[x] = cnt;
for (int i = header[x]; i; i = E[i].next) {
int y = E[i].v;
if (which[y]) continue;
predfs(y);
}
}
void dfs(int x) {
vis[x] = 1;
for (int i = header[x]; i; i = E[i].next) {
int y = E[i].v;
if (vis[y]) continue;
E[i].ontree = 1;
if (i & 1)
E[i + 1].ontree = 1;
else
E[i - 1].ontree = 1;
d[y] = d[x] + 1;
link[y] = i;
dfs(y);
}
}
void dfscount(int x) {
vis[x] = 1;
for (int i = header[x]; i; i = E[i].next) {
int y = E[i].v;
if (vis[y]) continue;
dfscount(y);
valpoint[x] += valpoint[y];
}
}
void dfssum(int x) {
vis[x] = 1;
for (int i = header[x]; i; i = E[i].next) {
int y = E[i].v;
if (vis[y]) continue;
dsum[y] = dsum[x] + valpoint[y];
dfssum(y);
}
}
int main() {
memset(valpoint, 0, sizeof(valpoint));
memset(d, 0, sizeof(d));
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; ++i) {
int u, v;
scanf("%d%d", &u, &v);
addEdge(u, v);
addEdge(v, u);
}
for (int i = 1; i <= n; ++i) {
if (!which[i]) {
++cnt;
predfs(i);
}
}
for (int i = 1; i <= n; ++i) {
if (root[which[i]] == 0) {
root[which[i]] = i;
}
}
for (int i = 1; i <= cnt; ++i) {
dfs(root[i]);
}
for (int i = 1; i <= 2 * m; i += 2) {
if (E[i].ontree) continue;
int tu = E[i].u, tv = E[i].v;
if (d[tu] < d[tv]) {
valpoint[tu] -= 1;
valpoint[tv] += 1;
} else {
valpoint[tv] -= 1;
valpoint[tu] += 1;
}
}
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= cnt; ++i) {
dfscount(root[i]);
}
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= cnt; ++i) {
dfssum(root[i]);
}
for (int i = 1; i <= 2 * m; i += 2) {
if (E[i].ontree) continue;
int tu = E[i].u, tv = E[i].v;
if (d[tv] < d[tu]) {
int temp = tv;
tv = tu;
tu = temp;
}
if (d[tv] - d[tu] == dsum[tv] - dsum[tu]) {
reverseans[i] = 1;
reverseans[i + 1] = 1;
for (int j = tv; j != tu; j = E[link[j]].u) {
reverseans[link[j]] = 1;
if (link[j] & 1)
reverseans[link[j] + 1] = 1;
else
reverseans[link[j] - 1] = 1;
}
}
}
for (int i = 1; i <= 2 * m; i += 2)
if (reverseans[i] == 1) ans[++ansnum] = i;
printf("%d\n", ansnum);
for (int i = 1; i <= ansnum; ++i) {
printf("%d ", (ans[i] + 1) / 2);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 102000;
int n, m;
struct edge {
int from, to;
} e[maxn];
vector<pair<int, int> > g[maxn];
int dfn[maxn], f[maxn], dd[maxn], cl, pt[maxn];
int chs[maxn], lnk[maxn];
void read() {
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));
}
}
vector<int> ans;
vector<int> t[maxn];
void dfs(int now, int fa) {
dfn[now] = ++cl;
pt[now] = fa;
for (int i = 0; i < (int)g[now].size(); i++) {
pair<int, int> pr = g[now][i];
if (pr.first == fa) continue;
if (!dfn[pr.first]) {
t[now].push_back(pr.first);
chs[pr.second] = 1;
lnk[pr.first] = pr.second;
dfs(pr.first, now);
} else {
if (dfn[pr.first] > dfn[now]) continue;
f[now]++;
f[pr.first]--;
}
}
}
int im[maxn];
void dfs2(int now) {
for (int i = 0; i < t[now].size(); i++) {
dfs2(t[now][i]);
dd[now] += dd[t[now][i]];
}
dd[now] += f[now];
}
void dfs3(int now) {
im[now] = im[pt[now]] + (dd[now] > 1);
for (int i = 0; i < t[now].size(); i++) {
dfs3(t[now][i]);
}
}
void solve(int now) {
if (dfn[e[now].from] < dfn[e[now].to]) swap(e[now].from, e[now].to);
int kk = im[e[now].from] - im[e[now].to];
if (kk == 0) {
int pla = e[now].from;
while (pla != e[now].to) {
ans.push_back(lnk[pla]);
pla = pt[pla];
}
ans.push_back(now);
}
}
void work() {
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]);
}
}
int main() {
read();
work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 55;
namespace Fast_IO {
const int MAXL((1 << 18) + 1);
int iof, iotp;
char ioif[MAXL], *ioiS, *ioiT, ioof[MAXL],
*iooS = ioof, *iooT = ioof + MAXL - 1, ioc, iost[55];
char Getchar() {
if (ioiS == ioiT) {
ioiS = ioif;
ioiT = ioiS + fread(ioif, 1, MAXL, stdin);
return (ioiS == ioiT ? EOF : *ioiS++);
} else
return (*ioiS++);
}
void Write() {
fwrite(ioof, 1, iooS - ioof, stdout);
iooS = ioof;
}
void Putchar(char x) {
*iooS++ = x;
if (iooS == iooT) Write();
}
inline int read() {
int x = 0;
for (iof = 1, ioc = Getchar(); (ioc < '0' || ioc > '9') && ioc != EOF;)
iof = ioc == '-' ? -1 : 1, ioc = Getchar();
if (ioc == EOF) exit(0);
for (x = 0; ioc <= '9' && ioc >= '0'; ioc = Getchar())
x = (x << 3) + (x << 1) + (ioc ^ 48);
return x * iof;
}
inline long long read_ll() {
long long x = 0;
for (iof = 1, ioc = Getchar(); (ioc < '0' || ioc > '9') && ioc != EOF;)
iof = ioc == '-' ? -1 : 1, ioc = Getchar();
if (ioc == EOF) exit(0);
for (x = 0; ioc <= '9' && ioc >= '0'; ioc = Getchar())
x = (x << 3) + (x << 1) + (ioc ^ 48);
return x * iof;
}
template <class Int>
void Print(Int x, char ch = '\0') {
if (!x) Putchar('0');
if (x < 0) Putchar('-'), x = -x;
while (x) iost[++iotp] = x % 10 + '0', x /= 10;
while (iotp) Putchar(iost[iotp--]);
if (ch) Putchar(ch);
}
void Getstr(char *s, int &l) {
for (ioc = Getchar(); ioc == ' ' || ioc == '\n' || ioc == '\t';)
ioc = Getchar();
if (ioc == EOF) exit(0);
for (l = 0; !(ioc == ' ' || ioc == '\n' || ioc == '\t' || ioc == EOF);
ioc = Getchar())
s[l++] = ioc;
s[l] = 0;
}
void Putstr(const char *s) {
for (int i = 0, n = strlen(s); i < n; ++i) Putchar(s[i]);
}
} // namespace Fast_IO
using namespace Fast_IO;
int ans, cc;
struct node {
int to, nxt, id;
} e[maxn * 2];
int head[maxn], ct = 1;
void add(int u, int v) {
e[++ct].to = v;
e[ct].nxt = head[u];
head[u] = ct;
}
int Ans[maxn], bl[maxn], dfn[maxn], low[maxn], cnt, sta[maxn], top, a[maxn],
ccnt, n, m, jishu;
bool vis[maxn * 2];
void tarjan(int u, int fa) {
dfn[u] = low[u] = ++cnt;
for (int i = head[u]; i; i = e[i].nxt) {
int v = e[i].to;
if (v == fa || vis[i]) continue;
vis[i] = vis[i ^ 1] = 1;
sta[++top] = i;
if (!dfn[v]) {
tarjan(v, u);
low[u] = min(low[u], low[v]);
if (low[v] >= dfn[u]) {
int num = 0, bnum = 0;
jishu++;
cc = 0;
int x;
do {
x = sta[top--];
if (bl[e[x].to] != jishu) bl[e[x].to] = jishu, ++num;
if (bl[e[x ^ 1].to] != jishu) bl[e[x ^ 1].to] = jishu, ++num;
a[++bnum] = x;
} while (x != i);
if (bnum == num)
for (int i = 1; i <= bnum; ++i) Ans[++ans] = a[i];
}
} else
low[u] = min(low[u], dfn[v]);
}
}
int main() {
n = read(), m = read();
for (int i = 1; i <= m; ++i) {
int u = read(), v = read();
add(u, v);
add(v, u);
}
for (int i = 1; i <= n; ++i)
if (!dfn[i]) tarjan(i, 0);
sort(Ans + 1, Ans + 1 + ans);
printf("%d\n", ans);
for (int i = 1; i <= ans; ++i)
printf("%d%c", Ans[i] >> 1, i == ans ? '\n' : ' ');
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5;
int depth[N];
int mindepth[N];
int col[N];
bool is[N];
bool mark[N];
vector<pair<int, int>> g[N];
int colors = 0;
void findPoints(int v, int d = 0, int p = -1) {
mark[v] = true;
mindepth[v] = depth[v] = d;
int childs = 0;
for (auto to : g[v]) {
int u = to.first;
int id = to.second;
if (mark[u]) {
mindepth[v] = min(mindepth[v], depth[u]);
} else {
++childs;
findPoints(u, d + 1);
mindepth[v] = min(mindepth[v], mindepth[u]);
if (mindepth[u] >= depth[v]) {
is[v] = true;
col[id] = colors++;
}
}
}
if (p == 1 && childs >= 2) {
is[v] = true;
}
}
void print(int v, int c = -1) {
mark[v] = true;
for (auto to : g[v]) {
int u = to.first;
int id = to.second;
if (!mark[u]) {
if (col[id] != -1) {
print(u, col[id]);
} else if (c != -1) {
col[id] = c;
print(u, c);
}
} else if (c != -1 && col[id] == -1) {
col[id] = c;
}
}
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; ++i) {
int u, v;
scanf("%d%d", &u, &v);
--u, --v;
g[u].push_back({v, i});
g[v].push_back({u, i});
}
memset(col, -1, sizeof col);
for (int v = 0; v < n; ++v) {
if (!mark[v]) {
findPoints(v, 0, 1);
}
}
memset(mark, false, sizeof mark);
for (int v = 0; v < n; ++v) {
if (!mark[v] && is[v]) {
print(v);
}
}
vector<set<int>> pts(colors);
vector<set<int>> ed(colors);
for (int v = 0; v < n; ++v) {
for (auto to : g[v]) {
int u = to.first;
int id = to.second;
pts[col[id]].insert(u);
pts[col[id]].insert(v);
ed[col[id]].insert(id);
}
}
set<int> ans;
for (int i = 0; i < colors; ++i) {
if (pts[i].size() == ed[i].size()) {
ans.insert(ed[i].begin(), ed[i].end());
}
}
printf("%d\n", static_cast<int>(ans.size()));
for (int v : ans) {
printf("%d ", v + 1);
}
putchar('\n');
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 102000;
int n, m;
struct edge {
int from, to;
} e[maxn];
vector<pair<int, int> > g[maxn];
int dfn[maxn], f[maxn], dd[maxn], cl, pt[maxn];
int chs[maxn], lnk[maxn];
void read() {
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));
}
}
vector<int> ans;
vector<int> t[maxn];
void dfs(int now, int fa) {
dfn[now] = ++cl;
pt[now] = fa;
for (int i = 0; i < g[now].size(); i++) {
pair<int, int> pr = g[now][i];
if (pr.first == fa) continue;
if (!dfn[pr.first]) {
t[now].push_back(pr.first);
chs[pr.second] = 1;
lnk[pr.first] = pr.second;
dfs(pr.first, now);
} else {
if (dfn[pr.first] > dfn[now]) continue;
f[now]++;
f[pr.first]--;
}
}
}
int im[maxn];
void dfs2(int now) {
for (int i = 0; i < t[now].size(); i++) {
dfs2(t[now][i]);
dd[now] += dd[t[now][i]];
}
dd[now] += f[now];
}
void dfs3(int now) {
im[now] = im[pt[now]] + (dd[now] > 1);
for (int i = 0; i < t[now].size(); i++) {
dfs3(t[now][i]);
}
}
void solve(int now) {
if (dfn[e[now].from] < dfn[e[now].to]) swap(e[now].from, e[now].to);
int kk = im[e[now].from] - im[e[now].to];
if (kk == 0) {
int pla = e[now].from;
while (pla != e[now].to) {
ans.push_back(lnk[pla]);
pla = pt[pla];
}
ans.push_back(now);
}
}
void work() {
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]);
}
}
int main() {
read();
work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long QuickPow(long long x, long long y) {
long long Res = 1, Temp = x;
while (y) {
if (y & 1) Res = Res * Temp % 1000000007;
Temp = Temp * Temp % 1000000007;
y /= 2;
}
return Res;
}
inline void Swap(long long &x, long long &y) {
long long Temp = x;
x = y;
y = Temp;
}
inline long long Max(long long x, long long y) { return x > y ? x : y; }
inline long long Min(long long x, long long y) { return x < y ? x : y; }
inline void read(long long &x) {
x = 0;
long long f = 1;
char s = getchar();
while (s < '0' || s > '9') {
if (s == '-') f = -1;
s = getchar();
}
while (s >= '0' && s <= '9') {
x = (x << 3) + (x << 1) + (s ^ 48);
s = getchar();
}
x *= f;
}
struct node {
long long v, Index;
node() {}
node(long long V, long long INDEX) {
v = V;
Index = INDEX;
}
};
set<long long> Ans, Bian[100005], Dian[100005];
set<long long>::iterator item;
stack<long long> S;
vector<node> G[100005];
bool InStack[100005];
long long Dfn[100005], Low[100005], Cnt, Col;
void Tarjan(long long x, long long Pre) {
Dfn[x] = Low[x] = ++Cnt;
int l = G[x].size();
for (register long long i = 0; i < l; ++i) {
long long to = G[x][i].v;
if (to == Pre) continue;
if (!Dfn[to]) {
S.push(to);
S.push(x);
S.push(G[x][i].Index);
Tarjan(to, x);
Low[x] = Min(Low[x], Low[to]);
if (Low[to] >= Dfn[x]) {
Col++;
long long u, v;
do {
Bian[Col].insert(S.top());
S.pop();
u = S.top();
S.pop();
v = S.top();
S.pop();
Dian[Col].insert(u);
Dian[Col].insert(v);
} while (u != x || v != to);
}
} else if (Dfn[to] < Dfn[x]) {
S.push(to);
S.push(x);
S.push(G[x][i].Index);
Low[x] = Min(Low[x], Dfn[to]);
}
}
}
int main() {
long long n, m;
read(n);
read(m);
for (register long long i = 1; i <= m; ++i) {
long long u, v;
read(u);
read(v);
G[u].push_back(node(v, i));
G[v].push_back(node(u, i));
}
for (register long long i = 1; i <= n; ++i)
if (!Dfn[i]) Tarjan(i, i);
for (register long long i = 1; i <= Col; ++i)
if (Bian[i].size() == Dian[i].size())
Ans.insert(Bian[i].begin(), Bian[i].end());
int l = Ans.size();
printf("%d\n", l);
for (item = Ans.begin(); item != Ans.end(); item++) printf("%lld ", *item);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, low[1200005], tnum, ans,
tot = 1, tmp[1200005], f[1200005], vis[1200005], dfn[1200050], cnt = 0,
nex[2200005], go[2200005], head[2200005];
stack<long long> q;
stack<long long> qq;
vector<long long> a[1200005];
void add(long long u, long long v) {
nex[++tot] = head[u];
head[u] = tot;
go[tot] = v;
}
void tar(long long u) {
dfn[u] = low[u] = ++tnum;
qq.push(u);
for (long long i = head[u]; i; i = nex[i]) {
long long v = go[i];
if (vis[i >> 1]) continue;
vis[i >> 1] = 1;
q.push((i >> 1));
if (!dfn[v]) {
tar(v);
low[u] = min(low[u], low[v]);
if (low[v] < dfn[u]) continue;
cnt++;
tmp[cnt]++;
while (1) {
long long tp = qq.top();
qq.pop();
tmp[cnt]++;
if (tp == v) break;
}
while (1) {
long long tp = q.top();
a[cnt].push_back(tp);
q.pop();
if (tp == (i >> 1)) break;
}
}
low[u] = min(low[u], dfn[v]);
}
}
signed main() {
cin >> n >> m;
for (long long i = 1, u, v; i <= m; i++) {
scanf("%lld%lld", &u, &v);
add(u, v);
add(v, u);
}
for (long long i = 1; i <= n; i++)
if (!dfn[i]) tar(i);
for (long long i = 1; i <= cnt; i++) {
if (tmp[i] != a[i].size()) continue;
for (long long j = 0; j < a[i].size(); j++) {
f[a[i][j]] = 1;
}
}
for (long long i = 1; i <= m; i++) {
if (f[i]) ans++;
}
cout << ans << endl;
for (long long i = 1; i <= m; i++)
if (f[i]) cout << i << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
stack<int> s;
vector<pair<int, int> > side;
vector<int> graph[N], ans;
bitset<N> went, used;
int dep[N], low[N], t = 0;
void dfs(int now, int from) {
int l, r;
map<int, int> m;
vector<int> v;
bool f;
low[now] = dep[now] = ++t;
went[now] = true;
for (int i : graph[now])
if (!used[i]) {
used[i] = true;
s.push(i);
l = side[i].first;
r = side[i].second;
if (r == now) swap(l, r);
if (!went[r]) {
dfs(r, i);
low[now] = min(low[now], low[r]);
if (low[r] >= dep[now]) {
f = true;
m.clear();
v.clear();
while (s.top() != i) {
if (m.find(side[s.top()].first) == m.end())
m.insert({side[s.top()].first, 1});
else
m[side[s.top()].first]++;
if (m.find(side[s.top()].second) == m.end())
m.insert({side[s.top()].second, 1});
else
m[side[s.top()].second]++;
v.push_back(s.top());
s.pop();
}
if (m.find(side[s.top()].first) == m.end())
m.insert({side[s.top()].first, 1});
else
m[side[s.top()].first]++;
if (m.find(side[s.top()].second) == m.end())
m.insert({side[s.top()].second, 1});
else
m[side[s.top()].second]++;
v.push_back(s.top());
s.pop();
for (pair<int, int> i : m)
if (i.second != 2) {
f = false;
break;
}
if (f)
for (int i : v) ans.push_back(i);
}
} else
low[now] = min(low[now], dep[r]);
}
return;
}
int main() {
int n, m, l, r;
scanf("%d%d", &n, &m);
side.push_back({0, 0});
for (int i = 1; i <= m; i++) {
scanf("%d%d", &l, &r);
graph[l].push_back(i);
graph[r].push_back(i);
side.push_back({l, r});
}
went.reset();
used.reset();
for (int i = 1; i <= n; i++)
if (!went[i]) {
s.push(0);
dfs(i, 0);
}
if (ans.empty())
printf("0\n\n");
else {
sort(ans.begin(), ans.end());
printf("%ld\n%d", ans.size(), ans[0]);
for (int i = 1; i < ans.size(); i++) printf(" %d", ans[i]);
printf("\n");
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct edge {
int to, nxt;
};
int head[100010], cnt;
int ans;
edge e[200010];
int dfn[100010], low[100010], ind;
int stk[200010], top;
int col[100010], num;
int deg[100010];
bool ok[100010];
int n, m;
void addedge(int a, int b) {
e[cnt].to = b;
e[cnt].nxt = head[a];
head[a] = cnt++;
deg[a]++;
}
void tarjan(int x, int p) {
dfn[x] = low[x] = ++ind;
for (int i = head[x]; i != -1; i = e[i].nxt) {
int y = e[i].to;
if (y == p) continue;
if (!dfn[y]) {
stk[++top] = i;
tarjan(y, x);
low[x] = min(low[x], low[y]);
if (low[y] >= dfn[x]) {
num++;
int nod = 0;
vector<int> es;
while (top && stk[top] != i) {
int p = e[stk[top]].to;
if (col[p] != num) col[p] = num, nod++;
es.push_back(stk[top]);
top--;
}
int p = e[stk[top]].to;
if (col[p] != num) col[p] = num, nod++;
es.push_back(stk[top]);
top--;
if (col[x] != num) col[x] = num, nod++;
if (nod == (int)es.size()) {
ans += nod;
for (int j = 0; j < (int)es.size(); j++) ok[es[j] / 2 + 1] = true;
}
}
} else if (dfn[y] < dfn[x]) {
stk[++top] = i;
low[x] = min(low[x], dfn[y]);
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) head[i] = -1;
for (int i = 1; i <= m; i++) {
int a, b;
scanf("%d%d", &a, &b);
addedge(a, b);
addedge(b, a);
}
for (int i = 1; i <= n; i++) {
if (dfn[i]) continue;
tarjan(i, 0);
}
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;
const int maxn = 100010;
int n, m;
int low[maxn], dfn[maxn], v[maxn << 1], A[maxn];
int nxt[maxn << 1], head[maxn], belong[maxn], a[maxn], vis[maxn << 1];
stack<int> s;
int indexs = 0, cnt = 0;
int ans = 0;
void add_edge(int x, int y) {
static int N = 1;
N++;
v[N] = y;
nxt[N] = head[x];
head[x] = N;
}
void tarjan(int x, int fa) {
dfn[x] = low[x] = ++indexs;
for (int i = head[x]; i != -1; i = nxt[i]) {
if (vis[i]) continue;
vis[i] = vis[i ^ 1] = 1;
s.push(i);
if (!dfn[v[i]]) {
tarjan(v[i], x);
low[x] = min(low[x], low[v[i]]);
if (low[v[i]] >= dfn[x]) {
cnt++;
int num = 0, bcnt = 0;
while (1) {
int tmp = s.top();
s.pop();
if (belong[v[tmp]] != cnt) belong[v[tmp]] = cnt, num++;
if (belong[v[tmp ^ 1]] != cnt) belong[v[tmp ^ 1]] = cnt, num++;
a[++bcnt] = tmp;
if (tmp == i) break;
}
if (num == bcnt)
for (int i = 1; i <= bcnt; i++) A[++ans] = a[i];
}
} else
low[x] = min(low[x], dfn[v[i]]);
}
}
int main() {
memset(head, -1, sizeof(head));
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
add_edge(x, y);
add_edge(y, x);
}
for (int i = 1; i <= n; i++)
if (!dfn[i]) tarjan(i, 0);
sort(A + 1, A + 1 + ans);
printf("%d\n", ans);
for (int i = 1; i <= ans; i++) cout << (A[i] >> 1) << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > v[100005];
vector<int> scc[100005];
int nscc;
vector<int> stk;
int vis[100005];
int lw[100005];
int t;
pair<int, int> p[100005];
int ok[100005];
void dfs(int a) {
vis[a] = lw[a] = ++t;
for (auto it : v[a]) {
if (!ok[it.second]) {
ok[it.second] = 1;
stk.push_back(it.second);
if (!vis[it.first]) {
dfs(it.first);
if (lw[it.first] >= vis[a]) {
while (stk.back() != it.second) {
scc[nscc].push_back(stk.back());
stk.pop_back();
}
scc[nscc++].push_back(stk.back());
stk.pop_back();
}
lw[a] = min(lw[a], lw[it.first]);
} else {
lw[a] = min(vis[it.first], lw[a]);
}
}
}
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; i++) {
int a, b;
scanf("%d %d", &a, &b);
p[i] = make_pair((a), (b));
v[a].push_back(make_pair((b), (i)));
v[b].push_back(make_pair((a), (i)));
}
t = 0;
nscc = 0;
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
dfs(i);
}
}
int node[100005];
memset(node, 0, sizeof(node));
vector<int> ans;
for (int i = 0; i < nscc; i++) {
int cnt = 0;
for (auto it : scc[i]) {
if (node[p[it].first] != i + 1) {
cnt++;
node[p[it].first] = i + 1;
}
if (node[p[it].second] != i + 1) {
cnt++;
node[p[it].second] = i + 1;
}
}
if (cnt == scc[i].size()) {
for (auto it : scc[i]) ans.push_back(it);
}
}
sort(ans.begin(), ans.end());
printf("%d\n", ans.size());
for (auto it : ans) printf("%d ", it);
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
int n, m;
int low[maxn], dfn[maxn], v[maxn << 1], A[maxn];
int nxt[maxn << 1], head[maxn], belong[maxn], a[maxn], vis[maxn << 1];
stack<int> s;
int indexs = 0, cnt = 0;
int ans = 0;
void add_edge(int x, int y) {
static int N = 1;
N++;
v[N] = y;
nxt[N] = head[x];
head[x] = N;
}
void tarjan(int x, int fa) {
dfn[x] = low[x] = ++indexs;
for (int i = head[x]; i != -1; i = nxt[i]) {
if (vis[i]) continue;
vis[i] = vis[i ^ 1] = 1;
s.push(i);
if (!dfn[v[i]]) {
tarjan(v[i], x);
low[x] = min(low[x], low[v[i]]);
if (low[v[i]] >= dfn[x]) {
cnt++;
int num = 0, bcnt = 0;
while (1) {
int tmp = s.top();
s.pop();
if (belong[v[tmp]] != cnt) belong[v[tmp]] = cnt, num++;
if (belong[v[tmp ^ 1]] != cnt) belong[v[tmp ^ 1]] = cnt, num++;
a[++bcnt] = tmp;
if (tmp == i) break;
}
if (num == bcnt) {
for (int i = 1; i <= bcnt; i++) A[++ans] = a[i];
}
}
} else
low[x] = min(low[x], dfn[v[i]]);
}
}
int main() {
memset(head, -1, sizeof(head));
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
add_edge(x, y);
add_edge(y, x);
}
for (int i = 1; i <= n; i++)
if (!dfn[i]) tarjan(i, 0);
sort(A + 1, A + 1 + ans);
printf("%d\n", ans);
for (int i = 1; i <= ans; i++) cout << (A[i] >> 1) << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename tp>
void read(tp& dig) {
char ch = getchar();
dig = 0;
int flag = 0;
while (!isdigit(ch)) {
if (ch == '-') flag = 1;
ch = getchar();
}
while (isdigit(ch)) dig = dig * 10 + ch - '0', ch = getchar();
if (flag) dig = -dig;
}
struct edge {
int u, v, id;
} tmp;
vector<int> bcc[150010], bcce[150010];
bool mark[300010];
int st[150010], ble[300010];
int fst[150010], nxt[300010], to[300010], id[300010];
int bcc_cnt, dfs_clock, bl[150010], icv[150010], low[150010];
int n, m, lnum, pre[150010], num[150010], sum[150010], ans[150010];
inline void add_edge(int u, int v, int k) {
nxt[++lnum] = fst[u];
fst[u] = lnum;
to[lnum] = v;
id[lnum] = k;
nxt[++lnum] = fst[v];
fst[v] = lnum;
to[lnum] = u;
id[lnum] = k;
}
inline void dfs(int u, int fa) {
pre[u] = low[u] = ++dfs_clock;
int ss = 0;
for (int i = fst[u]; ~i; i = nxt[i]) {
if (mark[i]) continue;
mark[i] = mark[i ^ 1] = 1;
st[++st[0]] = i;
if (!pre[to[i]]) {
++ss;
dfs(to[i], u);
low[u] = min(low[u], low[to[i]]);
if (low[to[i]] >= pre[u]) {
icv[u] = 1;
++bcc_cnt;
for (;;) {
int j = st[st[0]--];
if (bl[to[j]] != bcc_cnt) ++num[bcc_cnt], bl[to[j]] = bcc_cnt;
if (bl[to[j ^ 1]] != bcc_cnt) ++num[bcc_cnt], bl[to[j ^ 1]] = bcc_cnt;
ble[(j >> 1) + 1] = bcc_cnt;
if (i == j) break;
}
}
} else
low[u] = min(low[u], pre[to[i]]);
}
if (u == fa && ss == 1) icv[u] = 0;
}
int main() {
memset(fst, -1, sizeof fst);
read(n);
read(m);
lnum = -1;
for (int i = 1, x, y; i <= m; ++i) {
read(x);
read(y);
add_edge(x, y, i);
}
for (int i = 1; i <= n; ++i)
if (!pre[i]) dfs(i, i);
for (int i = 1; i <= m; ++i) bcce[ble[i]].push_back(i);
for (int i = 1; i <= bcc_cnt; ++i)
if (bcce[i].size() == num[i])
for (int j = 0; j < bcce[i].size(); ++j) ans[++ans[0]] = bcce[i][j];
sort(ans + 1, ans + ans[0] + 1);
printf("%d\n", ans[0]);
for (int i = 1; i <= ans[0]; ++i) printf("%d ", ans[i]);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct edge {
int to, next;
} e[1000010];
int head[1000010], num = 1;
int n, m;
int cnt, tot;
int dfn[1000010], low[1000010];
stack<int> s;
set<int> node[100010], edge[100010], ans;
void addedge(int a, int b) {
e[++num].to = b;
e[num].next = head[a];
head[a] = num;
}
void tarjan(int u, int fa) {
dfn[u] = low[u] = ++cnt;
for (int i = head[u]; i; i = e[i].next) {
if (!dfn[e[i].to]) {
s.push(i >> 1);
s.push(u);
s.push(e[i].to);
tarjan(e[i].to, u);
low[u] = min(low[u], low[e[i].to]);
if (dfn[u] <= low[e[i].to]) {
tot++;
while (1) {
int t1 = s.top();
s.pop();
int t2 = s.top();
s.pop();
node[tot].insert(t1);
node[tot].insert(t2);
edge[tot].insert(s.top());
s.pop();
if (t1 == e[i].to && t2 == u) break;
}
}
} else {
if (dfn[e[i].to] < dfn[u] && e[i].to != fa) {
s.push(i >> 1);
s.push(u);
s.push(e[i].to);
low[u] = min(low[u], dfn[e[i].to]);
}
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int a, b;
scanf("%d%d", &a, &b);
addedge(a, b);
addedge(b, a);
}
for (int i = 1; i <= n; i++)
if (!dfn[i]) tarjan(i, 0);
for (int i = 1; i <= tot; i++) {
if (edge[i].size() == node[i].size()) {
ans.insert(edge[i].begin(), edge[i].end());
}
}
printf("%d\n", ans.size());
for (int i : ans) printf("%d ", i);
}
|
#include <bits/stdc++.h>
using namespace std;
const int INFINITE = INT_MIN;
template <typename T>
struct SegTree {
struct SegTreeNode {
T val;
T addMark;
};
vector<SegTreeNode> nodes;
T *arr;
int istart, iend, maxIndex;
SegTree() {}
SegTree(T *arr1, int start, int end) : arr(arr1), istart(start), iend(end) {
nodes.resize((end - start + 1) << 2);
maxIndex = -1;
build(0, arr, istart, iend);
}
void build(int root, T arr[], int istart, int iend) {
nodes[root].addMark = 0;
if (istart == iend) {
if (root > maxIndex) maxIndex = root;
nodes[root].val = arr[istart];
} else {
int mid = (istart + iend) / 2;
build(root * 2 + 1, arr, istart, mid);
build(root * 2 + 2, arr, mid + 1, iend);
nodes[root].val = max(nodes[root * 2 + 1].val, nodes[root * 2 + 2].val);
}
}
void pushDown(int root) {
if (nodes[root].addMark != 0) {
nodes[root].val += nodes[root].addMark;
if ((root << 1) + 1 <= maxIndex)
nodes[(root << 1) + 1].addMark += nodes[root].addMark;
if ((root << 1) + 2 <= maxIndex)
nodes[(root << 1) + 2].addMark += nodes[root].addMark;
nodes[root].addMark = 0;
}
}
T query(int qstart, int qend) { return query(0, istart, iend, qstart, qend); }
T query(int root, int nstart, int nend, int qstart, int qend) {
if (qstart > nend || qend < nstart) return INFINITE;
if (qstart <= nstart && qend >= nend) {
pushDown(root);
return nodes[root].val;
}
pushDown(root);
int mid = (nstart + nend) / 2;
return max(query(root * 2 + 1, nstart, mid, qstart, qend),
query(root * 2 + 2, mid + 1, nend, qstart, qend));
}
void update(int ustart, int uend, T addValue) {
update(0, istart, iend, ustart, uend, addValue);
}
void update(int root, int nstart, int nend, int ustart, int uend, T addVal) {
if (ustart > nend || uend < nstart) return;
if (ustart <= nstart && uend >= nend) {
nodes[root].addMark += addVal;
pushDown(root);
return;
}
pushDown(root);
int mid = (nstart + nend) / 2;
update(root * 2 + 1, nstart, mid, ustart, uend, addVal);
update(root * 2 + 2, mid + 1, nend, ustart, uend, addVal);
nodes[root].val = max(nodes[root * 2 + 1].val, nodes[root * 2 + 2].val);
}
void updateOne(int index, T addVal) {
updateOne(0, istart, iend, index, addVal);
}
void updateOne(int root, int nstart, int nend, int index, T addVal) {
if (nstart == nend) {
if (index == nstart) {
pushDown(root);
nodes[root].val += addVal;
}
return;
}
int mid = (nstart + nend) / 2;
pushDown(root);
if (index <= mid)
updateOne(root * 2 + 1, nstart, mid, index, addVal);
else
updateOne(root * 2 + 2, mid + 1, nend, index, addVal);
nodes[root].val = max(nodes[root * 2 + 1].val, nodes[root * 2 + 2].val);
}
};
const int V = 1e5 + 20;
struct node {
int v;
int idx;
bool flag;
node(int a = 0, int b = 0, bool c = 0) : v(a), idx(b), flag(c) {}
};
vector<node> adj[V];
int parent[V], heavy[V];
int depth[V], size[V];
int chain[V], head[V], pos[V];
int vist[V];
vector<int> realChain[V];
SegTree<int> trees[V];
int ids[V];
vector<pair<int, int> > nonEds;
int n, m;
void DFS(int i) {
size[i] = 1, vist[i] = 1;
for (int k = 0; k < adj[i].size(); ++k) {
auto &ele = adj[i][k];
int j = ele.v;
if (j == parent[i]) {
ele.flag = 1;
continue;
}
if (vist[j] == 1) {
ele.flag = 0;
continue;
}
ele.flag = 1;
parent[j] = i;
ids[j] = ele.idx;
depth[j] = depth[i] + 1;
DFS(j);
size[i] += size[j];
if (heavy[i] == -1 || size[j] > size[heavy[i]]) heavy[i] = j;
}
}
void heavylight_DFS(int N) {
memset(heavy, -1, sizeof(heavy));
memset(vist, 0, sizeof(vist));
for (int i = 1; i <= N; i++) {
if (!vist[i]) {
parent[i] = -1;
depth[i] = 0;
DFS(i);
}
}
for (int i = 1; i <= N; i++) {
for (int j = 0; j < adj[i].size(); j++) {
int u = adj[i][j].v;
if (i < u && adj[i][j].flag == 0) {
nonEds.push_back({i, j});
}
}
}
int c = 0;
for (int i = 1; i <= N; ++i)
if (parent[i] == -1 || heavy[parent[i]] != i) {
for (int k = i, p = 0; k != -1; k = heavy[k]) {
chain[k] = c, head[k] = i, pos[k] = p++;
realChain[c].push_back(0);
}
c++;
}
for (int i = 0; i < c; i++) {
trees[i] =
SegTree<int>(realChain[i].data(), 0, (int)realChain[i].size() - 1);
}
}
int query(int i, int j) {
int ans = INT_MIN;
int cid, pp, pp2;
while (chain[i] != chain[j]) {
if (depth[head[i]] > depth[head[j]]) swap(i, j);
cid = chain[j], pp = pos[j];
ans = max(ans, trees[cid].query(0, pp));
j = parent[head[j]];
}
cid = chain[i], pp = pos[i], pp2 = pos[j];
if (pp > pp2) swap(pp, pp2);
if (pp == pp2)
return ans;
else {
pp++;
ans = max(ans, trees[cid].query(pp, pp2));
return ans;
}
}
void update(int i, int j) {
int cid, pp, pp2;
while (chain[i] != chain[j]) {
if (depth[head[i]] > depth[head[j]]) swap(i, j);
cid = chain[j], pp = pos[j];
trees[cid].update(0, pp, 1);
j = parent[head[j]];
}
cid = chain[i], pp = pos[i], pp2 = pos[j];
if (pp > pp2) swap(pp, pp2);
if (pp != pp2) {
pp++;
trees[cid].update(pp, pp2, 1);
}
}
vector<int> bb;
void allo(int v, int u) {
while (v != u) {
if (depth[v] > depth[u]) {
bb.push_back(ids[v]);
v = parent[v];
} else {
bb.push_back(ids[u]);
u = parent[u];
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d%d", &a, &b);
adj[a].push_back({b, i + 1, 0});
adj[b].push_back({a, i + 1, 0});
}
heavylight_DFS(n);
for (int i = 0; i < nonEds.size(); i++) {
int v = nonEds[i].first, u = adj[v][nonEds[i].second].v;
update(v, u);
}
int ans = 0;
for (int i = 0; i < nonEds.size(); i++) {
int v = nonEds[i].first, u = adj[v][nonEds[i].second].v;
int aa = query(v, u);
if (aa == 1) {
allo(v, u);
bb.push_back(adj[v][nonEds[i].second].idx);
ans += abs(depth[v] - depth[u]) + 1;
}
}
printf("%d\n", ans);
assert(ans == bb.size());
sort(bb.begin(), bb.end());
for (int i = 0; i < bb.size(); i++) printf("%d ", bb[i]);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<pair<int, int>>> adj(100001);
int disc[100001], low[100001], tim;
struct edge {
int x, y, ind;
};
vector<edge> s;
vector<int> ans;
void proses(vector<edge> &v) {
set<int> s;
int temp;
for (int temp = 0; temp < v.size(); temp++) {
s.insert(v[temp].x);
s.insert(v[temp].y);
}
if (s.size() == v.size()) {
for (temp = 0; temp < v.size(); temp++) {
ans.push_back(v[temp].ind);
}
}
}
void dfs(int pos, int par) {
disc[pos] = low[pos] = tim++;
int child = 0;
for (int temp = 0; temp < adj[pos].size(); temp++) {
int thenode = adj[pos][temp].first, ind = adj[pos][temp].second;
if ((thenode == par) ||
((disc[thenode] != -1) && (disc[thenode] > disc[pos])))
continue;
if (disc[thenode] == -1) {
s.push_back({pos, thenode, ind});
dfs(thenode, pos);
child++;
low[pos] = min(low[pos], low[thenode]);
} else {
s.push_back({pos, thenode, ind});
low[pos] = min(low[pos], disc[thenode]);
}
if (((pos == par) && (child > 1)) ||
((pos != par) && (disc[pos] <= low[thenode]))) {
vector<edge> edges;
while (true) {
int u = s.back().x, v = s.back().y, ind = s.back().ind;
edges.push_back({u, v, ind});
s.pop_back();
if ((u == pos) && (v == thenode)) break;
}
proses(edges);
}
}
}
int main() {
int n, m;
cin >> n >> m;
int temp, temp2;
for (temp = 1; temp <= m; temp++) {
int x, y;
cin >> x >> y;
adj[x].push_back({y, temp});
adj[y].push_back({x, temp});
}
memset(disc, -1, sizeof(disc));
for (temp = 1; temp <= n; temp++) {
if (disc[temp] == -1) {
dfs(temp, temp);
proses(s);
s.clear();
}
}
sort(ans.begin(), ans.end());
cout << ans.size() << "\n";
for (temp = 0; temp < ans.size(); temp++) {
cout << ans[temp];
if (temp != ans.size() - 1) cout << " ";
}
cout << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int arr = 3e5;
vector<pair<int, int> > vec[arr];
vector<int> add;
int deep[arr], ok[arr], use[arr];
int a[arr], b[arr], cnt[arr];
vector<pair<int, int> > ask[arr];
vector<pair<int, int> > cyc;
int pr[arr];
void dfs(int u, int pred) {
use[u] = 1;
pr[u] = pred;
deep[u] = deep[pred] + 1;
for (auto i : vec[u])
if (i.first != pred) {
if (use[i.first]) {
if (deep[i.first] < deep[u]) add.push_back(i.second);
} else
dfs(i.first, u);
}
}
void dfs2(int u, int pred) {
use[u] = 1;
for (auto i : vec[u])
if (i.first != pred)
if (!use[i.first]) {
dfs2(i.first, u);
cnt[u] += cnt[i.first];
}
}
int get() {
if (cyc.empty()) return (0);
return (cyc.back().second);
}
void addd(int u) {
if (u != 1)
cyc.push_back({u, 0});
else
cyc.push_back({u, get() + 1});
}
void dell() { cyc.pop_back(); }
void dfs3(int u, int pred) {
use[u] = 1;
for (auto i : ask[u]) {
if (get() >= i.first) ok[i.second] = 1;
}
for (auto i : vec[u])
if (!use[i.first]) {
addd(cnt[i.first]);
dfs3(i.first, u);
dell();
}
}
map<pair<int, int>, int> mp;
signed main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
cin >> a[i] >> b[i];
mp[{a[i], b[i]}] = i;
mp[{b[i], a[i]}] = i;
vec[a[i]].push_back({b[i], i});
vec[b[i]].push_back({a[i], i});
}
for (int i = 1; i <= n; i++)
if (!use[i]) dfs(i, 0);
for (auto i : add) {
if (deep[a[i]] < deep[b[i]]) swap(a[i], b[i]);
cnt[a[i]]++;
cnt[b[i]]--;
}
for (int i = 1; i <= n; i++) use[i] = 0;
for (int i = 1; i <= n; i++)
if (!use[i]) dfs2(i, 0);
int cnt = 0;
for (auto i : add) {
ask[a[i]].push_back({deep[a[i]] - deep[b[i]], i});
}
for (int i = 1; i <= n; i++) use[i] = 0;
for (int i = 1; i <= n; i++)
if (!use[i]) dfs3(i, 0);
vector<int> ans;
for (auto i : add)
if (ok[i]) {
ans.push_back(i);
while (a[i] != b[i]) {
ans.push_back(mp[{a[i], pr[a[i]]}]);
a[i] = pr[a[i]];
}
}
cout << ans.size() << '\n';
sort(ans.begin(), ans.end());
for (auto i : ans) cout << i << ' ';
}
|
#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;
inline int read() {
int x = 0, f = 0;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = 1;
c = getchar();
}
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
if (f) x = -x;
return x;
}
int a[100005], fa[100005], fd[100005], dep[100005], n, m;
int ans[200005], sta[100005], top[100005], cnt = 0;
int head[100005], nxt[200005], v[200005], id[200005], tot = 0;
bool vis[100005], ins[100005];
vector<int> vec[100005];
inline int getf(int a) {
while (top[a] ^ a) a = top[a] = top[top[a]];
return a;
}
inline void add(int a, int b, int qwq) {
tot++;
nxt[tot] = head[a];
head[a] = tot;
v[tot] = b;
id[tot] = qwq;
}
inline void cover(int id, int a, int b) {
int tag = 1;
for (int i = a; i != b; i = fa[i]) {
if (sta[i] > 0 || sta[i] == -1) {
tag = 0;
break;
}
}
if (tag == 1) {
for (int i = a; i != b; i = fa[i]) {
sta[i] = id;
vec[id].push_back(i);
}
return;
}
int i = a;
while (dep[i] > dep[b]) {
if (sta[i] == 0) {
sta[i] = -1;
top[i] = fa[i];
i = fa[i];
continue;
}
if (sta[i] == -1) {
i = getf(i);
continue;
}
if (sta[i] > 0) {
int p = sta[i], j;
for (j = 0; j < vec[p].size(); j++) {
sta[vec[p][j]] = -1;
top[vec[p][j]] = fa[vec[p][j]];
}
vec[p].clear();
i = fa[i];
}
}
}
void dfs(int pos, int f) {
vis[pos] = ins[pos] = 1;
for (int i = head[pos]; i; i = nxt[i]) {
if (v[i] == f) continue;
if (vis[v[i]] && ins[v[i]]) {
cover(id[i], pos, v[i]);
continue;
}
if (vis[v[i]]) continue;
dep[v[i]] = dep[pos] + 1;
fa[v[i]] = pos;
fd[v[i]] = id[i];
dfs(v[i], pos);
}
ins[pos] = 0;
}
int main() {
int i, j, a, b;
n = read();
m = read();
for (i = 1; i <= m; i++) {
a = read();
b = read();
add(a, b, i);
add(b, a, i);
}
for (i = 1; i <= n; i++) top[i] = i;
for (i = 1; i <= n; i++) {
if (!vis[i]) dfs(i, 0);
}
for (i = 1; i <= n; i++) {
if (sta[i] > 0) {
ans[++cnt] = sta[i];
ans[++cnt] = fd[i];
}
}
sort(ans + 1, ans + cnt + 1);
cnt = unique(ans + 1, ans + cnt + 1) - ans - 1;
printf("%d\n", cnt);
for (i = 1; i <= cnt; i++) {
printf("%d ", ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, prt[100001][2] = {}, anc[100001], disc[100001] = {}, idx = 1;
vector<vector<pair<int, int> > > adj;
vector<int> ans;
stack<pair<pair<int, int>, int> > sk;
inline void stkout() {
stack<pair<pair<int, int>, int> > tp = sk;
cout << "Stack Size : " << tp.size() << "\n";
while (tp.size()) {
cout << tp.top().first.first << " " << tp.top().first.second << " "
<< tp.top().second << "\n";
tp.pop();
}
}
inline void ins(int u, int lw) {
if (sk.size()) {
if (sk.top().first.second < lw) {
sk.push({{lw, anc[u]}, u});
} else {
while (sk.size()) {
if (sk.top().first.first >= lw) {
sk.pop();
} else {
break;
}
}
if (sk.size() && sk.top().first.second >= lw) {
lw = sk.top().first.first;
sk.pop();
}
sk.push({{lw, anc[u]}, -1});
}
} else {
sk.push({{lw, anc[u]}, u});
}
}
inline void ansSet(int n, int u) {
for (auto v : adj[u]) {
if (v.first == n) {
ans.push_back(v.second);
break;
}
}
while (u != n) {
ans.push_back(prt[u][1]);
u = prt[u][0];
}
}
void dfs(int u, int p, int val) {
if (!anc[u]) {
anc[u] = idx;
prt[u][0] = p;
prt[u][1] = val;
for (auto v : adj[u]) {
if (!disc[v.second]) {
anc[u] = disc[v.second] = idx++;
dfs(v.first, u, v.second);
if (anc[v.first] < anc[u]) {
ins(u, anc[v.first]);
}
while (sk.size()) {
if (sk.top().first.first >= anc[u]) {
if (sk.top().second != -1) {
ansSet(u, sk.top().second);
}
sk.pop();
} else {
break;
}
}
}
}
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
adj.push_back(vector<pair<int, int> >());
}
for (int i = 1; i <= m; i++) {
int a, b;
cin >> a >> b;
adj[a - 1].push_back({b - 1, i});
adj[b - 1].push_back({a - 1, i});
}
for (int i = 0; i < n; i++) {
dfs(i, -1, -1);
}
cout << ans.size() << "\n";
sort(ans.begin(), ans.end());
for (int i = 0; i < ans.size(); i++) {
cout << ans[i];
if (i < ans.size() - 1) {
cout << " ";
}
}
cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1.1e5;
const int MAXM = 1.1e5;
int N, M;
struct edge_t {
int c[2];
int other(int a) {
assert(a == c[0] || a == c[1]);
return a ^ c[0] ^ c[1];
}
} E[MAXM];
int last[MAXN];
int pred[MAXM * 2];
int ind[MAXM * 2];
int tot = 0;
void addEdge(int a, int e) {
pred[tot] = last[a];
ind[tot] = e;
last[a] = tot;
tot++;
}
int disc[MAXN];
int lowVal[MAXN];
int curInd = 0;
vector<int> st;
bool vis[MAXN];
vector<int> ans;
void process(vector<int> bcc) {
int cnt = 0;
for (int e : bcc) {
for (int i = 0; i < 2; i++) {
if (!vis[E[e].c[i]]) {
vis[E[e].c[i]] = true;
cnt++;
}
}
}
if (cnt == int(bcc.size())) {
for (int e : bcc) {
ans.push_back(e + 1);
}
}
for (int e : bcc) {
for (int i = 0; i < 2; i++) {
vis[E[e].c[i]] = false;
cnt++;
}
}
}
void dfs(int cur, int prvE) {
assert(!disc[cur]);
curInd++;
disc[cur] = curInd;
lowVal[cur] = disc[cur];
int children = 0;
for (int z = last[cur]; z != -1; z = pred[z]) {
int e = ind[z];
if (e == prvE) continue;
int nxt = E[e].other(cur);
if (!disc[nxt]) {
st.push_back(e);
children++;
dfs(nxt, e);
lowVal[cur] = min(lowVal[cur], lowVal[nxt]);
if ((disc[cur] == 1 && children > 1) ||
(disc[cur] != 1 && disc[cur] <= lowVal[nxt])) {
vector<int> bcc;
int lastE;
do {
lastE = st.back();
st.pop_back();
bcc.push_back(lastE);
} while (lastE != e);
process(bcc);
}
} else if (disc[nxt] < disc[cur]) {
st.push_back(e);
lowVal[cur] = min(lowVal[cur], disc[nxt]);
}
}
}
int main() {
ios::sync_with_stdio(0), cin.tie(0);
cin >> N >> M;
for (int i = 1; i <= N; i++) {
last[i] = -1;
}
for (int e = 0; e < M; e++) {
cin >> E[e].c[0] >> E[e].c[1];
addEdge(E[e].c[0], e);
addEdge(E[e].c[1], e);
}
for (int i = 1; i <= N; i++) {
if (!disc[i]) {
dfs(i, -1);
}
}
if (!st.empty()) {
process(st);
}
cout << ans.size() << '\n';
sort(ans.begin(), ans.end());
for (int e : ans) {
cout << e << ' ';
}
cout << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200000 + 5, maxm = 200000 + 5;
int n, m;
struct Edge {
int u, v, idx, nxt;
Edge(int u = 0, int v = 0) : u(u), v(v) {}
bool operator==(const Edge& rhs) const { return u == rhs.u && v == rhs.v; }
} edge[maxm];
int head[maxn], top;
int stamp, dfn[maxn], low[maxn], belong[maxn], bccno, bccsz[maxn];
bool iscut[maxn], vis[maxm];
stack<Edge> st;
vector<int> bcc[maxn];
void init() {
memset(head, -1, sizeof(head));
memset(dfn, 0, sizeof(dfn));
memset(low, 0, sizeof(low));
memset(iscut, 0, sizeof(iscut));
memset(belong, 0, sizeof(belong));
memset(bccsz, 0, sizeof(bccsz));
memset(vis, 0, sizeof(vis));
top = 0;
stamp = 0;
bccno = 0;
while (!st.empty()) st.pop();
}
void addedge(int u, int v, int idx) {
edge[top].u = u;
edge[top].v = v;
edge[top].idx = idx;
edge[top].nxt = head[u];
head[u] = top++;
edge[top].u = v;
edge[top].v = u;
edge[top].idx = idx;
edge[top].nxt = head[v];
head[v] = top++;
}
void tarjan(int u, int fa) {
dfn[u] = low[u] = ++stamp;
int child = 0;
for (int i = head[u]; i != -1; i = edge[i].nxt) {
int v = edge[i].v, cidx = edge[i].idx;
if (v == fa) continue;
if (!dfn[v]) {
st.push(edge[i]);
child++;
tarjan(v, u);
if (low[v] < low[u]) low[u] = low[v];
if (low[v] >= dfn[u]) {
iscut[u] = 1;
bcc[++bccno].clear();
do {
int uu = st.top().u, vv = st.top().v, idx = st.top().idx;
if (belong[uu] != bccno) belong[uu] = bccno, bccsz[bccno]++;
if (belong[vv] != bccno) belong[vv] = bccno, bccsz[bccno]++;
bcc[bccno].push_back(idx);
if (idx == cidx) {
st.pop();
break;
}
st.pop();
} while (!st.empty());
}
} else if (dfn[v] < dfn[u]) {
st.push(edge[i]);
if (dfn[v] < low[u]) low[u] = dfn[v];
}
}
if (u == fa && child <= 1) iscut[u] = 0;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
init();
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
addedge(u, v, i);
}
for (int i = 1; i <= n; i++)
if (!dfn[i]) tarjan(i, i);
vector<int> ans;
for (int i = 1; i <= bccno; i++) {
if (bcc[i].size() == bccsz[i]) {
ans.insert(ans.end(), bcc[i].begin(), bcc[i].end());
}
}
sort(ans.begin(), ans.end());
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++) {
cout << ans[i] << ' ';
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using vi = vector<int>;
int n, m;
vector<vector<pii> > ed;
int Time;
vi num, st;
template <class F>
int dfs(int at, int par, F f) {
int me = num[at] = ++Time, e, y, top = me;
for (auto& pa : ed[at])
if (pa.second != par) {
tie(y, e) = pa;
if (num[y]) {
top = min(top, num[y]);
if (num[y] < me) st.push_back(e);
} else {
int si = st.size();
int up = dfs(y, e, f);
top = min(top, up);
if (up == me) {
st.push_back(e);
f(vi(st.begin() + si, st.end()));
st.resize(si);
} else if (up < me)
st.push_back(e);
}
}
return top;
}
template <class F>
void bicomps(F f) {
num.assign(ed.size(), 0);
for (int i = 0; i < n; ++i)
if (!num[i]) dfs(i, -1, f);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
scanf("%d %d", &n, &m);
ed.resize(n);
vector<pii> edges(m);
int u, v;
for (int i = 0; i < m; ++i) {
scanf("%d %d", &u, &v);
--u;
--v;
ed[u].emplace_back(v, i);
ed[v].emplace_back(u, i);
edges[i] = {u, v};
}
vi valid;
bicomps([&](const vi& edgelist) {
vi verts;
for (int x : edgelist) {
verts.push_back(edges[x].first);
verts.push_back(edges[x].second);
}
sort(begin(verts), end(verts));
verts.resize(unique(begin(verts), end(verts)) - begin(verts));
int num_verts = verts.size();
int num_edges = edgelist.size();
if (num_verts == num_edges) {
for (int x : edgelist) valid.push_back(x);
}
});
sort(begin(valid), end(valid));
printf("%lu\n", valid.size());
for (int x : valid) printf("%d ", x + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200005;
int n, m;
int deg[MAXN];
vector<pair<int, int>> graph[MAXN];
int up[MAXN], visit[MAXN], vtime;
vector<tuple<int, int, int>> stk;
int bcc_cnt;
set<int> bccverts[MAXN];
set<int> bccedges[MAXN];
void dfs(int nod, int par_edge) {
up[nod] = visit[nod] = ++vtime;
int child = 0;
for (const auto& e : graph[nod]) {
int next = e.first, edge_id = e.second;
if (edge_id == par_edge) continue;
if (visit[next] == 0) {
stk.emplace_back(nod, next, edge_id);
++child;
dfs(next, edge_id);
if ((par_edge == -1 && child > 1) ||
(par_edge != -1 && up[next] >= visit[nod])) {
++bcc_cnt;
do {
int lastnod, lastnext, lasteid;
tie(lastnod, lastnext, lasteid) = stk.back();
stk.pop_back();
bccverts[bcc_cnt].insert(lastnext);
bccedges[bcc_cnt].insert(lasteid);
if (lastnod == nod && lastnext == next) break;
} while (!stk.empty());
bccverts[bcc_cnt].insert(nod);
}
up[nod] = min(up[nod], up[next]);
} else {
if (visit[next] <= visit[nod]) {
stk.emplace_back(nod, next, edge_id);
}
up[nod] = min(up[nod], visit[next]);
}
}
}
void get_bcc() {
vtime = 0;
memset(visit, 0, sizeof(visit));
bcc_cnt = 0;
for (int i = 1; i <= n; ++i) {
if (visit[i] == 0) {
dfs(i, -1);
if (!stk.empty()) {
++bcc_cnt;
do {
int lastnod, lastnext, lasteid;
tie(lastnod, lastnext, lasteid) = stk.back();
stk.pop_back();
bccverts[bcc_cnt].insert(lastnext);
bccedges[bcc_cnt].insert(lasteid);
} while (!stk.empty());
bccverts[bcc_cnt].insert(i);
}
}
}
}
void proc() {
cin >> n >> m;
for (int i = 1; i <= m; ++i) {
int a, b;
cin >> a >> b;
deg[a] += 1;
deg[b] += 1;
graph[a].emplace_back(b, i);
graph[b].emplace_back(a, i);
}
get_bcc();
vector<int> ans;
for (int i = 1; i <= bcc_cnt; ++i) {
if (bccverts[i].size() == bccedges[i].size()) {
for (int e : bccedges[i]) ans.push_back(e);
}
}
sort(ans.begin(), ans.end());
cout << ans.size() << '\n';
for (int e : ans) cout << e << ' ';
cout << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
proc();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
struct Edge {
int u, v, next, id;
} e[N];
vector<int> ans;
int dfn[N], low[N], stck[N], instack[N], head[N], mark[N];
int scnt, ecnt, m, n, tot, top;
void add_edge(int u, int v, int id) {
e[ecnt].u = u;
e[ecnt].v = v;
e[ecnt].id = id;
e[ecnt].next = head[u];
head[u] = ecnt++;
}
void dfs(int u, int fa) {
dfn[u] = low[u] = ++tot;
for (int i = head[u]; i >= 0; i = e[i].next) {
int v = e[i].v;
if (v == fa) continue;
if (mark[i]) continue;
mark[i] = mark[i ^ 1] = 1;
stck[++top] = i;
if (!dfn[v]) {
dfs(v, u);
low[u] = min(low[u], low[v]);
if (dfn[u] <= low[v]) {
set<int> e_set;
set<int> v_set;
v_set.insert(u);
int x;
do {
x = stck[top--];
e_set.insert(e[x].id);
v_set.insert(e[x].v);
} while (x != i);
if (e_set.size() == v_set.size())
for (set<int>::iterator it = e_set.begin(); it != e_set.end(); it++)
ans.push_back(*it);
}
} else
low[u] = min(low[u], dfn[v]);
}
}
int main() {
memset(head, -1, sizeof(head));
scanf("%d %d", &m, &n);
for (int i = 1; i <= n; i++) {
int u, v;
scanf("%d %d", &u, &v);
add_edge(u, v, i);
add_edge(v, u, i);
}
for (int i = 1; i <= m; i++) {
if (!dfn[i]) dfs(i, 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;
map<pair<int, int>, int> idx;
void biconnected_components(vector<vector<int>> &graph) {
int N = graph.size();
vector<int> num(N), low(N), art(N), stk;
vector<vector<pair<int, int>>> bcc;
vector<set<int>> bccv;
int bccnum = 0;
vector<vector<int>> comps;
stack<pair<int, int>> s;
function<void(int, int, int &)> dfs = [&](int u, int p, int &t) {
num[u] = low[u] = ++t;
stk.push_back(u);
for (int v : graph[u])
if (v != p) {
if (!num[v]) {
s.emplace(v, u);
dfs(v, u, t);
low[u] = min(low[u], low[v]);
if (low[v] >= num[u]) {
art[u] = (num[u] > 1 || num[v] > 2);
comps.push_back({u});
while (comps.back().back() != v) {
comps.back().push_back(stk.back()), stk.pop_back();
}
bcc.push_back(vector<pair<int, int>>());
bccv.push_back(set<int>());
while (1) {
auto p = s.top();
s.pop();
bcc[bccnum].push_back(p);
bccv[bccnum].insert(p.first);
bccv[bccnum].insert(p.second);
if (p.first == v && p.second == u) break;
}
++bccnum;
}
} else if (num[v] < num[u]) {
low[u] = min(low[u], num[v]);
s.emplace(v, u);
}
}
};
int t;
for (int i = 0; i < N; i++)
if (!num[i]) dfs(i, -1, t = 0);
set<int> res;
for (int i = 0; i < bcc.size(); i++) {
if (bcc[i].size() == bccv[i].size()) {
for (auto &x : bcc[i]) res.insert(idx[x]);
}
}
cout << res.size() << '\n';
for (auto &x : res) cout << x + 1 << ' ';
if (res.size()) cout << '\n';
}
vector<vector<int>> graph;
int main() {
int N, M;
scanf("%d %d", &N, &M);
graph.assign(N, vector<int>());
for (int i = 0; i < M; i++) {
int u, v;
scanf("%d %d", &u, &v);
u--;
v--;
graph[u].push_back(v);
graph[v].push_back(u);
idx[pair<int, int>(u, v)] = i;
idx[pair<int, int>(v, u)] = i;
}
biconnected_components(graph);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, tot, num, dfn[100010], low[100010], a[100010];
int cnt = 1, head[100010], to[200010], nxt[200010];
bool used[100010], vis[100010];
vector<int> v[100010];
stack<int> q, st;
void add(int x, int y) {
cnt++;
to[cnt] = y;
nxt[cnt] = head[x];
head[x] = cnt;
}
void tarjan(int x) {
tot++;
dfn[x] = low[x] = tot;
st.push(x);
for (int i = head[x]; i; i = nxt[i]) {
if (vis[i >> 1]) {
continue;
}
int y = to[i];
q.push(i >> 1);
vis[i >> 1] = true;
if (!dfn[y]) {
tarjan(y);
low[x] = min(low[x], low[y]);
if (dfn[x] > low[y]) {
continue;
}
num++;
int z;
do {
z = st.top();
st.pop();
a[num]++;
} while (z != y);
a[num]++;
do {
z = q.top();
q.pop();
v[num].push_back(z);
} while (z != (i >> 1));
} else {
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);
add(x, y);
add(y, x);
}
for (int i = 1; i <= n; i++) {
if (!dfn[i]) {
tarjan(i);
st.pop();
}
}
int ans = 0;
for (int i = 1; i <= num; i++) {
if (a[i] != (int)v[i].size()) {
continue;
}
ans += a[i];
for (int j = 0; j < a[i]; j++) {
used[v[i][j]] = true;
}
}
printf("%d\n", ans);
for (int i = 1; i <= m; i++) {
if (used[i]) {
printf("%d ", i);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
int readint() {
int x = 0, f = 1;
char s = getchar();
while (s < '0' || s > '9') {
if (s == '-') f = -1;
(s = getchar());
}
while (s >= '0' && s <= '9') {
x = (x << 3) + (x << 1) + (s ^ 48);
(s = getchar());
}
return x * f;
}
struct edge {
int v, nxt, id;
edge(){};
edge(int V, int N, int I) {
v = V;
nxt = N;
id = I;
}
} e[maxn << 1];
int head[maxn], edge_cnt = -1;
void addedge(int u, int v, int ind) {
e[++edge_cnt] = edge(v, head[u], ind);
head[u] = edge_cnt;
e[++edge_cnt] = edge(u, head[v], ind);
head[v] = edge_cnt;
}
int dfn_cnt, dfn[maxn], low[maxn];
stack<int> st;
bool vis[maxn << 1];
vector<int> ans;
void tarjan(int u, int fa) {
dfn[u] = low[u] = ++dfn_cnt;
for (int i = head[u]; ~i; i = e[i].nxt) {
int v = e[i].v;
if (v == fa) continue;
if (vis[i]) continue;
vis[i] = vis[i ^ 1] = 1;
st.push(i);
if (!dfn[v]) {
tarjan(v, u);
low[u] = min(low[u], low[v]);
if (dfn[u] <= low[v]) {
set<int> tmp_ver_set;
set<int> tmp_edge_set;
tmp_ver_set.insert(u);
int x;
do {
x = st.top();
st.pop();
tmp_edge_set.insert(e[x].id);
tmp_ver_set.insert(e[x].v);
} while (x != i);
if (tmp_edge_set.size() == tmp_ver_set.size())
for (set<int>::iterator it = tmp_edge_set.begin();
it != tmp_edge_set.end(); it++)
ans.push_back(*it);
}
} else {
low[u] = min(low[u], dfn[v]);
}
}
}
int main() {
memset(head, -1, sizeof(head));
int n = readint(), m = readint();
for (int i = 1; i <= m; i++) {
int u = readint(), v = readint();
addedge(u, v, i);
}
for (int i = 1; i <= n; i++) {
if (!dfn[i]) {
tarjan(i, 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;
const int N = 100001, M = 100001;
vector<pair<int, int> > g[N];
bool vis[N];
vector<int> vbel[N];
int dfn[N], low[N], ebel[N], dfc, vbcc;
int dfs_vbcc(int u, int f) {
static int s[N + M], t;
s[++t] = u;
dfn[u] = low[u] = ++dfc;
for (pair<int, int> p : g[u]) {
int v = p.first, i = p.second, z = t;
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; t > z; --t) {
if (s[t] > 0)
vbel[s[t]].push_back(vbcc);
else
ebel[-s[t]] = vbcc;
}
vbel[u].push_back(vbcc);
}
} else
low[u] = min(low[u], dfn[v]);
}
if (f == 0) t--;
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[N], vcnt[N], ecnt[N];
vector<int> ansv[N];
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 = 1e5 + 10;
vector<int> v[maxn];
bool vis[maxn];
int pre[maxn], low[maxn];
int ile[maxn];
int deg[maxn];
set<pair<pair<int, int>, int> > zbior;
stack<int> stos;
stack<pair<int, int> > stosE;
int nr;
vector<int> res;
void checkbc(vector<int> &v, vector<pair<int, int> > &e) {
for (int b : v) deg[b] = 0;
for (pair<int, int> x : e) {
deg[x.first]++;
deg[x.second]++;
}
for (int b : v) {
if (deg[b] != 2) return;
}
for (pair<int, int> x : e) {
auto it = zbior.upper_bound({{x.first, x.second}, 0});
res.push_back(it->second);
}
}
void dfs(int a, int p) {
vis[a] = true;
pre[a] = nr++;
int res = pre[a];
bool czy = true;
for (int b : v[a]) {
if (b == p) continue;
if (vis[b] == false) {
stos.push(a);
stosE.push({a, b});
dfs(b, a);
if (low[b] >= pre[a]) {
vector<int> v;
vector<pair<int, int> > e;
while (true) {
int c = stos.top();
stos.pop();
v.push_back(c);
if (c == a) break;
}
while (true) {
pair<int, int> c = stosE.top();
stosE.pop();
e.push_back(c);
if (c.first == a && c.second == b) break;
}
checkbc(v, e);
} else
czy = false;
res = min(res, low[b]);
} else
res = min(res, pre[b]);
if (pre[b] < pre[a]) stosE.push({a, b});
}
low[a] = res;
if (czy) stos.push(a);
}
int main() {
ios_base::sync_with_stdio(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
v[a].push_back(b);
v[b].push_back(a);
zbior.insert({{a, b}, i + 1});
zbior.insert({{b, a}, i + 1});
}
for (int i = 1; i <= n; i++) {
if (vis[i] == false) {
dfs(i, 0);
}
}
cout << res.size() << "\n";
sort(res.begin(), res.end());
for (int b : res) cout << b << " ";
cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
const int MAXN = 1e6 + 5, inf = 1e9;
const ll INF = 1e18;
const ld PI = 3.1415926535897932384626433832795;
int BC[MAXN], sz[MAXN], low[MAXN], pre[MAXN], num = 1, tim;
bool vis[MAXN], used[MAXN];
pair<int, int> E[MAXN];
vector<pair<int, int>> G[MAXN];
stack<int> St;
set<int> S[MAXN];
void dfs(int v, int p) {
vis[v] = 1, pre[v] = tim++, low[v] = pre[v];
for (auto e : G[v]) {
int u = e.first, id = e.second;
if (u == p) continue;
if (!used[id]) {
St.push(id);
used[id] = 1;
}
if (!vis[u]) {
dfs(u, v);
low[v] = min(low[v], low[u]);
if (low[u] >= pre[v]) {
int x = St.top();
while (x != id) {
BC[x] = num;
St.pop();
x = St.top();
}
BC[x] = num++;
St.pop();
}
} else
low[v] = min(low[v], pre[u]);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout << setprecision(13) << fixed;
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
G[a].push_back({b, i});
G[b].push_back({a, i});
E[i] = {a, b};
}
for (int i = 1; i <= n; i++) {
if (!low[i]) dfs(i, i);
}
for (int i = 0; i < m; i++) {
sz[BC[i]]++;
S[BC[i]].insert({E[i].first});
S[BC[i]].insert({E[i].second});
}
for (int i = 1; i < num; i++) {
if (S[i].size() == sz[i]) {
S[0].insert(i);
}
}
vector<int> res;
for (int i = 0; i < m; i++) {
if (S[0].find(BC[i]) == S[0].end()) continue;
res.push_back(i + 1);
}
cout << res.size() << "\n";
for (int i : res) cout << i << " ";
cout << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5, LOG = 17;
int par[N][LOG], mx[N][LOG], U[N], V[N], h[N], mark[N], val[N];
map<int, int> id[N];
vector<int> g[N];
int dfs(int v, int p) {
mark[v] = 1, h[v] = h[p] + 1;
for (int u : g[v])
if (u != p) {
if (!mark[u])
val[v] += dfs(u, v);
else if (mark[u] != 2)
val[v]++, val[u]--;
}
par[v][0] = p, mx[v][0] = val[v];
for (int i = 1; i < LOG; i++)
par[v][i] = par[par[v][i - 1]][i - 1],
mx[v][i] = max(mx[v][i - 1], mx[par[v][i - 1]][i - 1]);
mark[v] = 2;
return val[v];
}
int getmax(int v, int height) {
int res = 0;
for (int i = 0; height; height >>= 1, i++)
if (height & 1) res = max(res, mx[v][i]), v = par[v][i];
return res;
}
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++) {
cin >> U[i] >> V[i];
g[U[i]].push_back(V[i]), g[V[i]].push_back(U[i]);
id[U[i]][V[i]] = id[V[i]][U[i]] = i;
}
for (int i = 1; i <= n; i++)
if (!mark[i]) dfs(i, i);
for (int i = 1; i < LOG; i++) {
for (int v = 1; v <= n; v++)
par[v][i] = par[par[v][i - 1]][i - 1],
mx[v][i] = max(mx[v][i - 1], mx[par[v][i - 1]][i - 1]);
}
vector<int> ans;
for (int i = 0; i < m; i++) {
int u = U[i], v = V[i];
if (h[u] > h[v]) swap(u, v);
if (h[v] - h[u] == 1) continue;
if (getmax(v, h[v] - h[u]) != 1) continue;
ans.push_back(i + 1);
while (v != u) ans.push_back(id[v][par[v][0]] + 1), v = par[v][0];
}
sort(ans.begin(), ans.end());
cout << ans.size() << "\n";
for (int i : ans) cout << i << " ";
cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int MOD = 1000000007;
const long long BIG = 1446803456761533460;
const int Big = 336860180;
stringstream sss;
const long long int maxn = 100010;
const long long int maxnlg = 18;
long long int n, m;
vector<pair<long long int, long long int> > g[maxn];
long long int pars[maxnlg][maxn], be[maxnlg][maxn], edown[maxn], ht[maxn],
invalid[maxn];
long long int vis[maxn];
void dfs1(long long int x, long long int par) {
vis[x] = 1;
for (auto y : g[x]) {
long long int v, e;
tie(v, e) = y;
if (!vis[v]) {
edown[e] = v;
ht[v] = ht[x] + 1;
dfs1(v, x);
be[0][x] += be[0][v];
} else if (v != par && ht[v] < ht[x]) {
edown[e] = x;
++be[0][x];
--be[0][v];
}
}
}
long long int get_max(long long int a, long long int b) {
long long int dh = ht[a] - ht[b];
long long int mx = 0;
for (long long int i = (0); i < (maxnlg); ++i) {
if (dh >> i & 1) mx = max(mx, (be[i][a])), a = pars[i][a];
}
return mx;
}
void dfs2(long long int x, long long int par) {
vis[x] = 2;
pars[0][x] = par;
for (long long int i = (0); i < (maxnlg - 1); ++i) {
pars[i + 1][x] = pars[i][pars[i][x]];
be[i + 1][x] = max(be[i][x], be[i][pars[i][x]]);
}
for (auto y : g[x]) {
long long int v, e;
tie(v, e) = y;
if (vis[v] == 1) {
dfs2(v, x);
invalid[x] += invalid[v];
} else if (v != par && ht[v] < ht[x]) {
if (get_max(x, v) > 1) {
++invalid[x];
--invalid[v];
}
}
}
}
void MAIN() {
cin >> n >> m;
for (long long int i = (0); i < (m); ++i) {
long long int a, b;
cin >> a >> b;
--a, --b;
g[a].emplace_back(b, i), g[b].emplace_back(a, i);
}
for (long long int i = (0); i < (n); ++i) {
if (vis[i] == 0) {
dfs1(i, i);
dfs2(i, i);
}
}
vector<long long int> res;
for (long long int i = (0); i < (m); ++i) {
if (!invalid[edown[i]] && be[0][edown[i]] == 1) res.emplace_back(i);
}
cout << res.size() << '\n';
for (auto e : res) cout << e + 1 << ' ';
cout << '\n';
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cout << fixed << setprecision(10);
sss << R"(
5 6
1 2
2 3
2 4
4 3
2 5
5 3
6 7
2 3
3 4
4 2
1 2
1 5
5 6
6 1
)";
MAIN();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
class Scanner {
private:
static const int BUFFER_SIZE = 10000;
char buff[BUFFER_SIZE];
int buffPos, buffLim;
public:
Scanner() {
buffLim = fread(buff, 1, BUFFER_SIZE, stdin);
buffPos = 0;
}
private:
inline void flushBuff() {
buffLim = fread(buff, 1, BUFFER_SIZE, stdin);
if (buffLim == 0) {
buff[buffLim++] = '\n';
}
buffPos = 0;
}
inline bool isWS(char t) { return t == ' ' || t == '\n'; }
inline bool isDig(char t) { return t >= '0' && t <= '9'; }
void nextPos() {
buffPos++;
if (buffPos == buffLim) {
flushBuff();
}
}
public:
inline char getchar() {
char ch = buff[buffPos];
nextPos();
return ch;
}
inline void next(char* s) {
while (isWS(buff[buffPos])) {
nextPos();
}
while (!isWS(buff[buffPos])) {
*s = buff[buffPos];
s++;
nextPos();
}
*s = '\0';
}
inline void nextLine(char* s) {
while (buff[buffPos] != '\n') {
nextPos();
}
if (buff[buffPos] == '\n') {
nextPos();
}
while (buff[buffPos] != '\n') {
*s = buff[buffPos];
s++;
buffPos++;
}
*s = '\0';
}
inline int nextInt() {
while (!isDig(buff[buffPos]) && buff[buffPos] != '-') {
nextPos();
}
int sign = (buff[buffPos] == '-') ? nextPos(), -1 : 1;
int res = 0;
while (isDig(buff[buffPos])) {
res = res * 10 + buff[buffPos] - '0';
nextPos();
}
return res * sign;
}
inline double nextDouble() {
while (isWS(buff[buffPos])) {
nextPos();
}
int sign = (buff[buffPos] == '-') ? nextPos(), -1 : 1;
double res = 0;
while (isDig(buff[buffPos])) {
res = res * 10 + buff[buffPos] - '0';
nextPos();
}
if (buff[buffPos] == '.') {
nextPos();
double ep = 1;
while (isDig(buff[buffPos])) {
ep *= 0.1;
res += ep * (buff[buffPos] - '0');
nextPos();
}
}
return sign * res;
}
inline char nextChar() {
while (isWS(buff[buffPos])) nextPos();
char res = buff[buffPos];
nextPos();
return res;
}
};
Scanner sc;
template <class T>
inline bool checkMin(T& a, T b) {
return (a > b ? a = b, 1 : 0);
}
template <class T>
inline bool checkMax(T& a, T b) {
return (a < b ? a = b, 1 : 0);
}
void ALERT(bool judgememt, const char* phrase) {
if (judgememt) {
puts(phrase);
throw "ALERT";
}
}
bool alert(bool judgememt, const char* phrase) {
if (judgememt) puts(phrase);
return judgememt;
}
void preInit();
void init();
void solve();
int32_t main() {
preInit();
init();
solve();
return 0;
}
const int N = 100005;
struct Tree {
int ef[N], en[N * 2], ev[N * 2], ei[N * 2], ec;
Tree() {
ec = 0;
memset(ef, -1, sizeof(ef));
memset(en, -1, sizeof(en));
}
void addEdge(int u, int v, int id) {
;
en[ec] = ef[u];
ef[u] = ec;
ev[ec] = v;
ei[ec] = id;
ec++;
en[ec] = ef[v];
ef[v] = ec;
ev[ec] = u;
ei[ec] = id;
ec++;
}
};
int n, m;
struct Tree2 : public Tree {
int low[N], dfn[N], dfnCnt;
stack<int> st;
vector<vector<int>> bar;
void dfs(int u, int f) {
;
dfn[u] = low[u] = ++dfnCnt;
for (int e = ef[u]; e != -1; e = en[e])
if (ev[e] != f) {
int v = ev[e];
;
if (!dfn[v]) {
st.push(ei[e]);
dfs(v, u);
checkMin(low[u], low[v]);
if (low[v] >= dfn[u]) {
vector<int> eids;
while (st.top() != ei[e]) {
eids.push_back(st.top());
st.pop();
}
eids.push_back(ei[e]);
st.pop();
bar.push_back(eids);
}
} else if (dfn[v] < dfn[u]) {
checkMin(low[u], dfn[v]);
st.push(ei[e]);
}
}
}
void solve() {
for (int i = 1; i <= n; i++) {
if (!dfn[i]) {
dfs(i, i);
}
}
}
} T;
int u[N], v[N];
void preInit() {}
void init() {
n = sc.nextInt();
m = sc.nextInt();
for (int i = 0; i < m; i++) {
u[i] = sc.nextInt(), v[i] = sc.nextInt();
T.addEdge(u[i], v[i], i);
}
}
size_t count(vector<int>& uu) {
set<int> st;
for (int i : uu) {
st.insert(u[i]);
st.insert(v[i]);
}
return st.size();
}
void solve() {
T.solve();
vector<int> ans;
for (auto& u : T.bar) {
if (u.size() == count(u)) {
for (int i : u) {
ans.push_back(i);
}
}
}
sort(ans.begin(), ans.end());
printf("%d\n", static_cast<int>(ans.size()));
for (int u : ans) {
printf("%d ", u + 1);
}
puts("");
}
|
#include <bits/stdc++.h>
using namespace std;
struct edge {
int a, b, i;
} in[2100005];
vector<edge> v[100005];
vector<int> stk;
unordered_set<int> bcc[100005], bccedge[100005];
int vis[100005], low[100005], clk, bccclk;
bitset<2100005> cnt;
void dfs(int x, int p) {
vis[x] = low[x] = ++clk;
for (auto i : v[x])
if (i.b != p) {
if (!vis[i.b]) {
stk.push_back(i.i);
dfs(i.b, x);
low[x] = min(low[x], low[i.b]);
if (vis[x] <= low[i.b]) {
int a = -1;
while (a != i.i) {
a = stk.back();
stk.pop_back();
bcc[bccclk].insert(in[a].a);
bcc[bccclk].insert(in[a].b);
bccedge[bccclk].insert(a);
}
bccclk++;
}
} else if (vis[x] > vis[i.b]) {
low[x] = min(low[x], vis[i.b]);
stk.push_back(i.i);
}
}
}
int main() {
{
cin.tie(0);
ios_base::sync_with_stdio(false);
};
int n, m;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
cin >> in[i].a >> in[i].b;
in[i].i = i;
v[in[i].a].push_back({in[i].a, in[i].b, i});
v[in[i].b].push_back({in[i].b, in[i].a, i});
}
for (int i = 1; i <= n; i++)
if (!vis[i]) dfs(i, i);
for (int i = 0; i < bccclk; i++)
if (bcc[i].size() == bccedge[i].size()) {
for (int j : bccedge[i]) cnt[j] = 1;
}
cout << cnt.count() << '\n';
for (int i = 1; i <= m; i++)
if (cnt[i]) cout << i << ' ';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 7;
vector<pair<pair<int, int>, int> > son[N];
vector<int> bcc_node[N], bcc_edge[N], ans;
stack<pair<pair<int, int>, int> > s;
vector<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;
cin >> 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.push_back(v);
}
cout << node.size() << endl;
sort(node.begin(), node.end());
for (int i = 0; i < node.size(); i++) cout << node[i] << ' ';
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
const int MAXE = 1.1e5;
const int MAXN = MAXE;
int ed[MAXE][4];
vector<int> adj[MAXN];
int N, M, D;
int dfsnr[MAXN];
int revnr[MAXN];
int mark[MAXN];
int comp[MAXN], C;
void dfs(int n, int p = -1) {
if (dfsnr[n] != -1) return;
revnr[n] = dfsnr[n] = D++;
for (auto it : adj[n]) {
int to = ed[it][2] ^ n;
if (to == p) continue;
if (dfsnr[to] == -1) {
comp[C++] = it;
dfs(to, n);
revnr[n] = min(revnr[n], revnr[to]);
if (revnr[to] >= dfsnr[n]) {
unordered_set<int> cur;
while (comp[--C] != it) cur.insert(comp[C]);
cur.insert(it);
unordered_map<int, int> cnt;
for (auto it2 : cur)
for (int i = (0); i < (2); i++) cnt[ed[it2][i]] += 1;
bool ok = true;
for (auto it2 : cnt)
if (it2.second != 2) ok = false;
if (!ok)
for (auto it2 : cur) ed[it2][3] = 1;
}
} else {
if (dfsnr[to] < dfsnr[n]) comp[C++] = it;
revnr[n] = min(revnr[n], dfsnr[to]);
}
}
}
int main() {
if (0 == scanf("%d%d", &N, &M)) {
fprintf(stderr, "Could not parse arguments\n");
};
for (int i = (0); i < (M); i++)
if (0 == scanf("%d%d", &(ed[i][0]), &(ed[i][1]))) {
fprintf(stderr, "Could not parse arguments\n");
};
for (int i = (0); i < (M); i++) ed[i][2] = ed[i][0] ^ ed[i][1];
for (int i = (0); i < (M); i++) ed[i][3] = 0;
for (int i = (0); i < (N + 1); i++) adj[i].clear();
for (int i = (0); i < (M); i++)
for (int j = (0); j < (2); j++) adj[ed[i][j]].push_back(i);
for (int i = (0); i < (N + 1); i++) dfsnr[i] = -1;
D = 0;
for (int i = (0); i < (N + 1); i++) {
C = 0;
dfs(i);
}
int K = 0;
for (int i = (0); i < (M); i++)
if (ed[i][3] == 0) ++K;
printf("%d\n", K);
bool first = true;
for (int i = (0); i < (M); i++)
if (ed[i][3] == 0) {
if (first)
first = false;
else
printf(" ");
printf("%d", i + 1);
}
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, tot = 1, m, tofa[200005], s[200005], tr[200005], f[200005], dep[200005],
vis[100005], head[200005], go[200005], nex[200005];
vector<int> ans;
void add(int u, int v) {
nex[++tot] = head[u];
head[u] = tot;
go[tot] = v;
}
void build(int u, int fa, int dp) {
dep[u] = dep[fa] + 1;
vis[u] = 1;
f[u] = fa;
for (int i = head[u]; i; i = nex[i]) {
int v = go[i];
if (v == fa || vis[v]) continue;
tofa[v] = i;
tr[i >> 1] = 1;
build(v, u, dp + 1);
}
}
void dfs(int u, int fa) {
vis[u] = 1;
for (int i = head[u]; i; i = nex[i]) {
int v = go[i];
if (v == fa || vis[v]) continue;
dfs(v, u);
s[u] += s[v];
}
}
int main() {
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
add(u, v);
add(v, u);
}
for (int i = 1; i <= n; i++) {
if (!vis[i]) build(i, 0, 0);
}
for (int i = 1; i <= m; i++) {
if (!tr[i]) {
int u = go[i * 2], v = go[i * 2 + 1];
if (dep[u] < dep[v]) swap(u, v);
s[u]++;
s[v]--;
}
}
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
dfs(i, 0);
}
}
for (int i = 1; i <= m; i++) {
if (tr[i]) continue;
int u = go[i * 2], v = go[i * 2 + 1];
if (dep[u] < dep[v]) swap(u, v);
int tmp = u, bj = 0;
while (1) {
if (tmp == v) break;
if (s[tmp] != 1) {
bj = 1;
break;
}
tmp = f[tmp];
}
if (bj == 0) {
ans.push_back(i);
while (1) {
ans.push_back(tofa[u] >> 1);
u = f[u];
if (v == u) break;
}
}
}
sort(ans.begin(), ans.end());
cout << ans.size() << "\n";
for (int i = 0; i < ans.size(); i++) {
cout << ans[i] << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10, INF = 0x7fffffff;
int n, m;
map<int, int> w[maxn];
int pre[maxn], iscut[maxn], bccno[maxn], dfs_clock, bcc_cnt, num[maxn];
vector<int> G[maxn], bcc[maxn];
vector<int> f;
vector<int> g[maxn];
struct Edge {
int u, v;
Edge(int u, int v) : u(u), v(v) {}
};
stack<Edge> S;
int dfs(int u, int fa) {
int lowu = pre[u] = ++dfs_clock;
int child = 0;
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i];
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] = true;
bcc_cnt++;
bcc[bcc_cnt].clear();
for (;;) {
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;
}
g[bcc_cnt].push_back(w[x.u][x.v]);
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 find_bcc() {
memset(pre, 0, sizeof(pre));
memset(iscut, 0, sizeof(iscut));
memset(bccno, 0, sizeof(bccno));
dfs_clock = bcc_cnt = 0;
for (int i = 1; i <= n; i++)
if (!pre[i]) dfs(i, -1);
}
int main() {
int u, v;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
cin >> u >> v;
w[u][v] = w[v][u] = i;
G[u].push_back(v);
G[v].push_back(u);
}
find_bcc();
for (int i = 1; i <= bcc_cnt; i++) {
if (g[i].size() == bcc[i].size())
for (int j = 0; j < g[i].size(); j++) f.push_back(g[i][j]);
}
sort(f.begin(), f.end());
cout << f.size() << endl;
for (int i = 0; i < f.size(); i++) cout << f[i] << " ";
cout << endl;
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("");
}
const int N = 1e5 + 10;
int nedge = 0, p[2 * N], nex[2 * N], head[2 * N], n, m;
inline void addedge(int a, int b) {
p[++nedge] = b;
nex[nedge] = head[a];
head[a] = nedge;
}
bool vis[2 * N];
int cnt = 0, ans = 0, anss[N], st[N], top = 0, Cnt = 0, q[2 * N], b[2 * N],
dfn[N], low[N];
inline int fan(int x) { return (x & 1) ? x + 1 : x - 1; }
inline void tarjan(int x, int fa) {
dfn[x] = low[x] = ++cnt;
for (int k = head[x]; k; k = nex[k])
if (p[k] != fa && !vis[k]) {
int to = p[k];
st[++top] = k;
vis[k] = vis[fan(k)] = 1;
if (!dfn[to]) {
tarjan(to, x);
low[x] = min(low[x], low[to]);
if (low[to] >= dfn[x]) {
Cnt++;
int r, dd = 0, ee = 0;
do {
r = st[top--];
q[++ee] = r;
if (b[p[r]] != Cnt) b[p[r]] = Cnt, dd++;
if (b[p[fan(r)]] != Cnt) b[p[fan(r)]] = Cnt, dd++;
} while (r != k);
if (ee == dd) {
for (int i = 1; i <= ee; i++) anss[++ans] = q[i];
}
}
} else
low[x] = min(low[x], dfn[to]);
}
}
int main() {
n = read();
m = read();
for (int i = 1; i <= m; i++) {
int x = read(), y = read();
addedge(x, y);
addedge(y, x);
}
for (int i = 1; i <= n; i++)
if (!dfn[i]) tarjan(i, 0);
writeln(ans);
sort(anss + 1, anss + ans + 1);
for (int i = 1; i <= ans; i++) {
if (anss[i] & 1) anss[i]++;
anss[i] >>= 1;
write(anss[i]), putchar(' ');
}
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] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, M, Q;
map<int, int> id[1000005];
vector<int> Adj[1000005];
vector<int> ans;
int p[1000005];
int dfn[1000005], tt = 0;
int low[1000005];
stack<int> st;
int cnt[1000005];
bool cmp(const int& a, const int& b) { return dfn[a] < dfn[b]; }
void dfs(int u) {
dfn[u] = low[u] = ++tt;
st.push(u);
int v, x, y;
for (int k = 0; k < Adj[u].size(); k++) {
v = Adj[u][k];
if (!dfn[v]) {
p[v] = u;
dfs(v);
low[u] = min(low[u], low[v]);
if (dfn[u] < low[v]) {
st.pop();
}
if (dfn[u] == low[v]) {
int n = 0;
vector<int> vec;
vec.push_back(u);
while (1) {
x = st.top();
st.pop();
vec.push_back(x);
n += cnt[x];
if (x == v) break;
}
if (n == 1) {
sort(vec.begin(), vec.end(), cmp);
vec.push_back(u);
for (int k = 0; k < vec.size() - 1; k++) {
x = vec[k];
y = vec[k + 1];
ans.push_back(id[x][y]);
}
}
}
} else if (v != p[u]) {
if (dfn[v] < dfn[u]) ++cnt[u];
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);
Adj[u].push_back(v);
Adj[v].push_back(u);
id[u][v] = id[v][u] = i;
}
for (int i = 1; i <= N; i++) {
if (!dfn[i]) dfs(i);
}
sort(ans.begin(), ans.end());
printf("%d\n", ans.size());
for (int k = 0; k < ans.size(); k++) {
printf("%d ", ans[k]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int deg[N];
int low[N], dfn[N], timer = 0;
vector<int> edges_stack;
pair<int, int> edges[N];
set<int> ans;
vector<pair<int, int> > adj[N];
bool vis[N];
void process_block(int stop) {
if (edges_stack.empty()) return;
set<int> nodes;
set<int> curr_edges;
while (!edges_stack.empty()) {
int curr = edges_stack.back();
edges_stack.pop_back();
int u = edges[curr].first;
int v = edges[curr].second;
nodes.insert(u);
nodes.insert(v);
vis[u] = vis[v] = 1;
if (curr == stop) break;
}
bool ok = 1;
for (int nd : nodes) {
for (auto A : adj[nd]) {
int v = A.second;
int e = A.first;
if (vis[v]) {
curr_edges.insert(e);
deg[nd]++;
}
}
}
for (int nd : nodes) {
if (deg[nd] != 2) ok = 0;
deg[nd] = vis[nd] = 0;
}
if (ok) {
for (int e : curr_edges) ans.insert(e);
}
}
void dfs(int u, int p) {
low[u] = dfn[u] = ++timer;
int root_children = 0;
for (pair<int, int> A : adj[u]) {
int v = A.second;
int e = A.first;
if (!dfn[v]) {
root_children++;
edges_stack.push_back(e);
dfs(v, u);
low[u] = min(low[u], low[v]);
if ((p != -1 && dfn[u] <= low[v]) || (p == -1 && root_children > 1)) {
process_block(e);
}
} else if (v != p) {
if (dfn[v] < low[u]) {
low[u] = dfn[v];
edges_stack.push_back(e);
}
}
}
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d %d", &u, &v);
adj[u].push_back({i + 1, v});
adj[v].push_back({i + 1, u});
edges[i + 1] = {u, v};
}
for (int i = 1; i <= n; i++) {
if (!dfn[i]) {
dfs(i, -1);
process_block(-1);
}
}
printf("%d\n", ans.size());
for (int A : ans) printf("%d ", A);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int par[111111], ht[111111];
int mrg[2222222], po[2222222], up[2222222], dn[2222222];
vector<int> adj[111111];
vector<int> comp[2222222];
map<pair<int, int>, int> mp;
void merge(int x, int y) {
if (x == y) return;
if ((int)comp[x].size() < (int)comp[y].size()) {
swap(x, y);
}
mrg[x] = mrg[y] + mrg[x];
for (int u : comp[y]) {
po[u] = x;
comp[x].push_back(u);
}
comp[y].clear();
if (ht[up[x]] > ht[up[y]]) up[x] = up[y];
if (ht[dn[x]] < ht[dn[y]]) dn[x] = dn[y];
}
void ride(int st, int nd, int def) {
int v = st;
while (ht[v] > ht[nd]) {
int edg = mp[make_pair(v, par[v])];
int nxt = par[v];
if (po[edg] != 0) {
nxt = up[po[edg]];
merge(def, po[edg]);
def = po[edg];
} else {
po[edg] = def;
comp[def].push_back(edg);
}
v = nxt;
}
}
void dfs(int v, int pa) {
par[v] = pa;
ht[v] = ht[pa] + 1;
for (auto u : adj[v]) {
if (u == pa) continue;
int edg = mp[make_pair(u, v)];
if (ht[u] == 0) {
dfs(u, v);
} else if (ht[u] < ht[v]) {
po[edg] = edg;
dn[edg] = v;
up[edg] = u;
comp[edg].push_back(edg);
mrg[edg] = 1;
ride(v, u, edg);
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1, q, w; i <= m; i++) {
scanf("%d%d", &q, &w);
adj[q].push_back(w);
adj[w].push_back(q);
mp[make_pair(q, w)] = mp[make_pair(w, q)] = i;
}
for (int v = 1; v <= n; v++) {
if (ht[v] == 0) {
dfs(v, 0);
}
}
vector<int> res;
for (int e = 1; e <= m; e++) {
if (mrg[po[e]] == 1) {
res.push_back(e);
}
}
printf("%d\n", (int)res.size());
for (auto rs : res) {
printf("%d ", rs);
}
putchar('\n');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
const int maxm = 2e6 + 10;
inline int read() {
int x = 0, f = 1;
char c = getchar();
while (c > '9' || c < '0') {
if (c == '-') f = -f;
c = getchar();
}
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
return x * f;
}
int cnt, head[maxn], n, m;
struct edge {
int v, next, id;
} edge[maxm << 1];
void add(int u, int v, int id) {
edge[cnt].v = v;
edge[cnt].id = id;
edge[cnt].next = head[u];
head[u] = cnt++;
}
set<int> ans;
pair<int, int> stk[maxm];
int low[maxn], dfn[maxn];
int top, tim, cntbrg, dccnum, rt, dsize[maxn], brg[maxn];
vector<int> dcc[maxn];
bool cut[maxn], vis[maxm << 1];
void init() {
cntbrg = dccnum = tim = top = 0;
for (int i = 1; i <= n; i++) {
head[i] = -1;
dfn[i] = low[i] = 0;
}
}
void tarjan(int u, int pre) {
dfn[u] = low[u] = ++tim;
if (rt == u && head[u] == -1) {
dcc[++dccnum].clear();
dcc[dccnum].push_back(u);
return;
}
int cntzs = 0;
for (int i = head[u]; i != -1; i = edge[i].next) {
int v = edge[i].v, id = edge[i].id;
if (vis[id]) continue;
vis[id] = 1;
stk[++top] = make_pair(v, id);
if (!dfn[v]) {
tarjan(v, u);
low[u] = min(low[u], low[v]);
if (low[v] >= dfn[u]) {
if (rt == u && cntzs > 1 || u != rt) cut[u] = 1;
dcc[++dccnum].clear();
pair<int, int> w;
do {
w = stk[top--];
if (brg[w.first] != dccnum) {
dsize[dccnum]++;
brg[w.first] = dccnum;
}
dcc[dccnum].push_back(w.second);
} while (w.second != id);
if (dsize[dccnum] > 1 && dcc[dccnum].size() == dsize[dccnum]) {
for (int j = 0; j < dsize[dccnum]; j++) ans.insert(dcc[dccnum][j]);
}
}
} else if (v != pre)
low[u] = min(low[u], dfn[v]);
}
}
int main() {
n = read(), m = read();
init();
for (int i = 1; i <= m; i++) {
int u = read(), v = read();
add(u, v, i);
add(v, u, i);
}
for (int i = 1; i <= n; i++) {
if (!dfn[i]) tarjan(i, i);
}
printf("%d\n", ans.size());
for (auto it = ans.begin(); it != ans.end();) {
printf("%d ", *it++);
}
puts("");
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 1;
const int M = N << 1 | 1;
char O[1 << 14], *S = O, *T = O;
inline int read() {
int x = 0, f = 1;
char ch =
(S == T && (T = (S = O) + fread(O, 1, 1 << 14, stdin), S == T) ? -1
: *S++);
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = (S == T && (T = (S = O) + fread(O, 1, 1 << 14, stdin), S == T) ? -1
: *S++);
}
while (ch >= '0' && ch <= '9') {
x = (x << 1) + (x << 3) + (ch ^ 48);
ch = (S == T && (T = (S = O) + fread(O, 1, 1 << 14, stdin), S == T) ? -1
: *S++);
}
return x * f;
}
struct edge {
int y, nxt;
} e[M];
int li[N];
inline void add(int u, int v) {
static int top = 0;
e[++top] = (edge){v, li[u]};
li[u] = top;
e[++top] = (edge){u, li[v]};
li[v] = top;
}
int dfn[N], low[N], clk, bccno[N], bcccnt, top, stk[M];
int ck[M], ans[M], ckt, anst;
void dfs(int u, int fa) {
dfn[u] = low[u] = ++clk;
for (int t = li[u]; t; t = e[t].nxt) {
int v = e[t].y;
if (v == fa) continue;
if (!dfn[v]) {
stk[top++] = t;
dfs(v, u);
low[u] = min(low[v], low[u]);
if (low[v] >= dfn[u]) {
bcccnt++;
bool ok = 1;
ckt = 0;
while (1) {
int x = stk[--top];
ck[ckt++] = ((x + 1) >> 1);
if (bccno[e[x].y] != bcccnt)
bccno[e[x].y] = bcccnt;
else
ok = 0;
if (x == t) break;
}
if (ok && ckt > 1)
for (int i = 0; i < ckt; ++i) ans[anst++] = ck[i];
}
} else if (dfn[v] < dfn[u]) {
low[u] = min(dfn[v], low[u]);
stk[top++] = t;
}
}
}
int main() {
int n = read(), m = read();
for (int i = 0; i < m; ++i) {
int u = read(), v = read();
add(u, v);
}
for (int i = 1; i <= n; ++i)
if (!dfn[i]) dfs(i, -1);
sort(ans, ans + anst);
printf("%d\n", anst);
for (int i = 0; i < anst; ++i) printf("%d ", ans[i]);
return 0 * putchar(10);
}
|
#include <bits/stdc++.h>
using namespace std;
const double pai = acos(-1);
const double eps = 1e-10;
const long long mod = 1e9 + 7;
const int MXN = 1e6 + 5;
vector<pair<int, int> > g[MXN];
vector<int> bcc_arc[MXN];
vector<int> bcc[MXN];
int dfn[MXN];
int iscut[MXN];
int dfs_clock;
int bcc_clock;
int bccno[MXN];
struct no {
int x, y, p;
};
stack<no> sk;
int tarjan(int u, int fa) {
int lowu = dfn[u] = ++dfs_clock;
int child = 0;
for (int i = 0; i < (int)g[u].size(); i++) {
int to = g[u][i].first, num = g[u][i].second;
no E = no{u, to, num};
if (!dfn[to]) {
sk.push(E);
child++;
int lowv = tarjan(to, u);
lowu = min(lowu, lowv);
if (lowv >= dfn[u]) {
bcc_clock++;
iscut[u] = 1;
while (1) {
no now = sk.top();
sk.pop();
bcc_arc[bcc_clock].push_back(now.p);
if (bccno[now.x] != bcc_clock) {
bcc[bcc_clock].push_back(now.x);
bccno[now.x] = bcc_clock;
}
if (bccno[now.y] != bcc_clock) {
bcc[bcc_clock].push_back(now.y);
bccno[now.y] = bcc_clock;
}
if (now.x == u && now.y == to) break;
}
}
} else if (to != fa && dfn[to] < dfn[u]) {
lowu = min(lowu, dfn[to]);
sk.push(E);
}
}
if (fa < 0 && child == 1) iscut[u] = 0;
return lowu;
}
void bccGet(int n) {
for (int i = 1; i <= n; i++)
if (!dfn[i]) tarjan(i, -1);
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int sa, sb;
scanf("%d %d", &sa, &sb);
g[sa].push_back(make_pair(sb, i));
g[sb].push_back(make_pair(sa, i));
}
bccGet(n);
vector<int> ans;
for (int i = 1; i <= bcc_clock; i++) {
if ((int)bcc[i].size() != (int)bcc_arc[i].size()) continue;
for (int j = 0; j < (int)bcc_arc[i].size(); j++) {
ans.push_back(bcc_arc[i][j]);
}
}
sort(ans.begin(), ans.end());
cout << ans.size() << endl;
for (int i = 0; i < (int)ans.size(); i++) cout << ans[i] << ' ';
return 0;
}
|
#include <bits/stdc++.h>
int elist[200000];
bool vis[100000];
bool evis[100000];
int pre[100000];
int pre_max = 0;
int low[100000];
std::vector<int> adj[100000];
std::vector<int> treee[100000];
std::vector<int> backe[100000];
int bcc[100000];
int nbccs = 0;
int extra[100000];
void dfs0(int node) {
if (vis[node]) return;
vis[node] = true;
low[node] = pre[node] = pre_max++;
for (int e : adj[node]) {
if (evis[e >> 1]) continue;
evis[e >> 1] = true;
if (vis[elist[e ^ 1]]) {
backe[node].push_back(e);
} else {
treee[node].push_back(e);
dfs0(elist[e ^ 1]);
}
}
for (int e : treee[node]) {
low[node] = std::min(low[node], low[elist[e ^ 1]]);
}
for (int e : backe[node]) {
low[node] = std::min(low[node], pre[elist[e ^ 1]]);
}
}
std::vector<int> stk;
void dfs1(int node) {
for (int e : treee[node]) {
if (low[elist[e ^ 1]] >= pre[node]) {
stk.push_back(nbccs++);
}
bcc[e >> 1] = stk.back();
dfs1(elist[e ^ 1]);
if (low[elist[e ^ 1]] >= pre[node]) {
stk.pop_back();
}
}
for (int e : backe[node]) {
bcc[e >> 1] = stk.back();
extra[stk.back()]++;
}
}
int main() {
int N, M;
scanf("%d %d", &N, &M);
for (int i = 0; i < M; i++) {
int U, V;
scanf("%d %d", &U, &V);
U--, V--;
elist[i * 2] = U;
elist[i * 2 + 1] = V;
adj[U].push_back(i * 2);
adj[V].push_back(i * 2 + 1);
}
for (int i = 0; i < N; i++) {
if (!vis[i]) {
dfs0(i);
dfs1(i);
}
}
std::vector<int> vs;
for (int i = 0; i < M; i++) {
if (extra[bcc[i]] == 1) {
vs.push_back(i);
}
}
printf("%d\n", (int)vs.size());
for (int i = 0; i < vs.size(); i++) {
if (i) printf(" ");
printf("%d", vs[i] + 1);
}
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100009;
const int MOD = 1e9 + 7;
vector<pair<int, int>> V[maxn], E;
int fa[maxn], a[maxn], b[maxn], dfn[maxn], idx, fae[maxn];
void dfs(int u, int f) {
fa[u] = f;
dfn[u] = ++idx;
for (auto [v, id] : V[u]) {
if (!dfn[v]) dfs(v, u), fae[v] = id;
}
}
void dfs2(int u) {
for (auto i : V[u]) {
int v = i.first;
if (fa[v] == u) {
dfs2(v);
a[u] += a[v];
}
}
if (a[u] != -1) b[u] = 1;
}
void dfs3(int u) {
for (auto i : V[u]) {
int v = i.first;
if (fa[v] == u) {
b[v] += b[u];
dfs3(v);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cout.tie(0);
cin.tie(0);
int n, m;
cin >> n >> m;
E.resize(m);
for (int i = 0; i < m; ++i) {
cin >> E[i].first >> E[i].second;
V[E[i].first].emplace_back(E[i].second, i);
V[E[i].second].emplace_back(E[i].first, i);
}
vector<int> rt;
for (int i = 1; i <= n; ++i)
if (!dfn[i]) dfs(i, i), rt.push_back(i);
for (int i = 0; i < m; ++i) {
int u = E[i].first, v = E[i].second;
if (fa[u] == v || fa[v] == u) continue;
if (dfn[u] > dfn[v]) swap(u, v);
a[u]++;
a[v]--;
}
for (int i : rt) dfs2(i);
for (int i : rt) dfs3(i);
vector<int> ans;
for (int i = 0; i < m; ++i) {
int u = E[i].first, v = E[i].second;
if (fa[u] == v || fa[v] == u) continue;
if (dfn[u] > dfn[v]) swap(u, v);
if (b[u] == b[v]) {
ans.push_back(i);
while (v != u) {
ans.push_back(fae[v]);
v = fa[v];
}
}
}
sort(ans.begin(), ans.end());
cout << ((int)(ans).size()) << '\n';
for (int i : ans) cout << i + 1 << " ";
cout << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
struct qq {
int x, y, last;
} e[N * 2];
int num, last[N];
int n, m;
void init(int x, int y) {
num++;
e[num].x = x;
e[num].y = y;
e[num].last = last[x];
last[x] = num;
}
int dfn[N], low[N], id;
int sta[N], top;
int h[N], cnt;
int belong[N];
void dfs(int x) {
low[x] = dfn[x] = ++id;
sta[++top] = x;
for (int u = last[x]; u != -1; u = e[u].last) {
int y = e[u].y;
if (dfn[y] == -1) {
dfs(y);
low[x] = min(low[x], low[y]);
if (low[y] >= dfn[x]) {
cnt++;
int i;
do {
i = sta[top--];
h[cnt]++;
belong[i] = cnt;
} while (i != y);
h[cnt]++;
}
} else
low[x] = min(low[x], dfn[y]);
}
}
vector<int> s[N];
int ans[N];
int main() {
num = 0;
memset(last, -1, sizeof(last));
scanf("%d%d", &n, &m);
for (int u = 1; u <= m; u++) {
int x, y;
scanf("%d%d", &x, &y);
init(x, y);
init(y, x);
}
memset(dfn, -1, sizeof(dfn));
id = 0;
top = 0;
cnt = 0;
for (int u = 1; u <= n; u++)
if (dfn[u] == -1) {
dfs(u);
cnt++;
while (top > 0) {
h[cnt]++;
top--;
}
}
for (int u = 1; u <= m; u++) {
int xx = u * 2 - 1;
int x = dfn[e[xx].x] > dfn[e[xx].y] ? e[xx].x : e[xx].y;
s[belong[x]].push_back(u);
}
for (int u = 1; u <= cnt; u++)
if (s[u].size() == h[u]) {
for (int i = 0; i < s[u].size(); i++) ans[++ans[0]] = s[u][i];
}
sort(ans + 1, ans + 1 + ans[0]);
printf("%d\n", ans[0]);
for (int u = 1; u <= ans[0]; u++) printf("%d ", ans[u]);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = (int)1e5 + 7;
int n, m;
vector<pair<int, int> > G[N];
vector<int> ans;
int dfn[N], low[N], dfs_clock;
int stk[N], top, estk[N], etop;
void tarjan(int u, int eid) {
dfn[u] = low[u] = ++dfs_clock;
stk[++top] = u;
for (auto &e : G[u]) {
int v = e.second, id = e.first;
if (id == eid) continue;
if (!dfn[v]) {
estk[++etop] = id;
tarjan(v, id);
low[u] = min(low[u], low[v]);
if (low[v] >= dfn[u]) {
int pcnt = 0, ecnt = 0;
while (1) {
int t = stk[top--];
pcnt++;
if (t == v) break;
}
pcnt++;
while (1) {
int t = estk[etop--];
ans.push_back(t);
ecnt++;
if (t == id) break;
}
if (pcnt == 1 || pcnt != ecnt) {
while (ecnt--) ans.pop_back();
}
}
} else if (dfn[v] < dfn[u]) {
estk[++etop] = id;
low[u] = min(low[u], dfn[v]);
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
G[u].push_back(make_pair(i, v));
G[v].push_back(make_pair(i, u));
}
for (int i = 1; i <= n; i++) {
if (!dfn[i]) {
tarjan(i, 0);
}
}
sort(ans.begin(), ans.end());
printf("%d\n", (int)ans.size());
for (int i = 0; i < ans.size(); i++) {
printf("%d%c", ans[i], " \n"[i == (int)ans.size() - 1]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int ans = 0;
struct edge {
int to, nxt, id;
} e[100010 << 1];
int edgenum = 0;
int lin[100010] = {0};
void add(int a, int b, int c) {
++edgenum;
e[edgenum].to = b;
e[edgenum].id = c;
e[edgenum].nxt = lin[a];
lin[a] = edgenum;
++edgenum;
e[edgenum].to = a;
e[edgenum].id = c;
e[edgenum].nxt = lin[b];
lin[b] = edgenum;
return;
}
int dcc = 0;
vector<int> dcce[100010];
int siz[100010];
int dfn[100010], low[100010], tot = 0;
bool tag[100010], used[100010];
stack<int> ps;
stack<int> es;
void tarjan(int k) {
dfn[k] = low[k] = ++tot;
ps.push(k);
for (int i = lin[k]; i != 0; i = e[i].nxt) {
if (used[e[i].id]) continue;
used[e[i].id] = true;
es.push(e[i].id);
if (dfn[e[i].to] == 0) {
tarjan(e[i].to);
low[k] = min(low[k], low[e[i].to]);
if (low[e[i].to] >= dfn[k]) {
++dcc;
int t;
do {
t = ps.top();
ps.pop();
++siz[dcc];
} while (t != e[i].to);
++siz[dcc];
do {
t = es.top();
es.pop();
dcce[dcc].push_back(t);
} while (e[i].id != t);
}
} else
low[k] = min(low[k], dfn[e[i].to]);
}
return;
}
int main() {
scanf("%d%d", &n, &m);
int a, b;
for (int i = 1; i <= m; ++i) {
scanf("%d%d", &a, &b);
add(a, b, i);
}
for (int i = 1; i <= n; ++i) {
if (dfn[i] == 0) {
tarjan(i);
ps.pop();
}
}
for (int i = 1; i <= dcc; ++i) {
if (siz[i] == dcce[i].size()) {
for (int j = 0; j < dcce[i].size(); ++j) {
tag[dcce[i][j]] = true;
++ans;
}
}
}
cout << ans << endl;
for (int i = 1; i <= m; ++i) {
if (tag[i]) {
printf("%d ", i);
}
}
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 7;
vector<pair<pair<int, int>, int> > son[N];
vector<int> bcc_node[N], bcc_edge[N], ans;
stack<pair<pair<int, int>, int> > s;
vector<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_cnt++;
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;
cin >> 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.push_back(v);
}
cout << node.size() << endl;
sort(node.begin(), node.end());
for (int i = 0; i < node.size(); i++) cout << node[i] << ' ';
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<pair<int, int> > adj[100005];
int vn, sn;
int l[100005], v[100005];
bool trip[100005], chk[100005];
int cv[100005];
vector<int> ce[100005];
map<pair<int, int>, int> mp;
void dfs(int now, int par) {
l[now] = v[now] = vn++;
for (auto &e : adj[now]) {
int there = e.first;
if (there == par) continue;
if (v[there] == -1) {
dfs(there, now);
l[now] = min(l[now], l[there]);
} else
l[now] = min(l[now], v[there]);
}
}
void col(int now, int par, int c) {
if (c >= 0) cv[c]++;
trip[now] = true;
for (auto &e : adj[now]) {
int there = e.first;
if (there == par) continue;
if (trip[there]) {
if (!chk[e.second]) {
ce[c].push_back(e.second);
chk[e.second] = true;
}
continue;
}
if (v[now] <= l[there]) {
cv[sn]++;
ce[sn].push_back(e.second);
chk[e.second] = true;
col(there, now, sn++);
} else {
ce[c].push_back(e.second);
chk[e.second] = true;
col(there, now, c);
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d%d", &a, &b);
adj[a].emplace_back(b, i + 1);
adj[b].emplace_back(a, i + 1);
}
memset(v, -1, sizeof(v));
for (int i = 1; i <= n; i++)
if (v[i] == -1) dfs(i, 0);
for (int i = 1; i <= n; i++)
if (!trip[i]) col(i, 0, -1);
vector<int> ans;
for (int i = 0; i < sn; i++) {
if (cv[i] == ce[i].size()) {
for (auto x : ce[i]) ans.push_back(x);
}
}
sort(ans.begin(), ans.end());
ans.erase(unique(ans.begin(), ans.end()), ans.end());
printf("%d\n", ans.size());
for (auto x : ans) printf("%d ", x);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200005;
int n, m;
int deg[MAXN];
vector<pair<int, int>> graph[MAXN];
int up[MAXN], visit[MAXN], vtime;
vector<tuple<int, int, int>> stk;
int bcc_cnt;
set<int> bccverts[MAXN];
vector<int> bccedges[MAXN];
void dfs(int nod, int par_edge) {
up[nod] = visit[nod] = ++vtime;
int child = 0;
for (const auto& e : graph[nod]) {
int next = e.first, edge_id = e.second;
if (edge_id == par_edge) continue;
if (visit[next] == 0) {
stk.emplace_back(nod, next, edge_id);
++child;
dfs(next, edge_id);
if (up[next] >= visit[nod]) {
++bcc_cnt;
do {
int lastnod, lastnext, lasteid;
tie(lastnod, lastnext, lasteid) = stk.back();
stk.pop_back();
bccverts[bcc_cnt].insert(lastnext);
bccedges[bcc_cnt].push_back(lasteid);
if (lastnod == nod && lastnext == next) break;
} while (!stk.empty());
bccverts[bcc_cnt].insert(nod);
}
up[nod] = min(up[nod], up[next]);
} else if (visit[next] < visit[nod]) {
stk.emplace_back(nod, next, edge_id);
up[nod] = min(up[nod], visit[next]);
}
}
}
void get_bcc() {
vtime = 0;
memset(visit, 0, sizeof(visit));
bcc_cnt = 0;
for (int i = 1; i <= n; ++i) {
if (visit[i] == 0) {
dfs(i, -1);
}
}
}
void proc() {
cin >> n >> m;
for (int i = 1; i <= m; ++i) {
int a, b;
cin >> a >> b;
deg[a] += 1;
deg[b] += 1;
graph[a].emplace_back(b, i);
graph[b].emplace_back(a, i);
}
get_bcc();
vector<int> ans;
for (int i = 1; i <= bcc_cnt; ++i) {
if (bccverts[i].size() == bccedges[i].size()) {
for (int e : bccedges[i]) ans.push_back(e);
}
}
sort(ans.begin(), ans.end());
cout << ans.size() << '\n';
for (int e : ans) cout << e << ' ';
cout << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
proc();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int m;
vector<int> v[100002];
int dep[100002];
int ord;
int star[100002];
int linkk[100002];
bool use[100002];
vector<pair<int, int> > stk;
vector<vector<pair<int, int> > > vv;
inline void dfs(int b, int pr = -1, int d = 0) {
use[b] = true;
dep[b] = d;
star[b] = ord;
linkk[b] = ord;
ord++;
for (int go : v[b]) {
if (go == pr) {
continue;
}
if (use[go]) {
linkk[b] = min(linkk[b], star[go]);
} else {
int pr = stk.size();
dfs(go, b, d + 1);
linkk[b] = min(linkk[go], linkk[b]);
if (pr != stk.size()) {
if (linkk[stk.back().second] == star[b]) {
vv.push_back(vector<pair<int, int> >());
while (stk.size() != pr) {
vv.back().push_back(stk.back());
stk.pop_back();
}
}
}
}
}
if (linkk[b] != star[b]) {
for (int go : v[b]) {
if (dep[b] > dep[go]) {
stk.push_back(make_pair(go, b));
}
}
}
}
map<pair<int, int>, int> mp;
set<int> s;
set<int> ans;
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d%d", &a, &b);
a--;
b--;
v[a].push_back(b);
v[b].push_back(a);
mp[make_pair(a, b)] = i + 1;
mp[make_pair(b, a)] = i + 1;
}
for (int i = 0; i < n; i++) {
if (use[i] == false) dfs(i);
}
for (int i = 0; i < vv.size(); i++) {
s.clear();
for (int j = 0; j < vv[i].size(); j++) {
s.insert(vv[i][j].first);
s.insert(vv[i][j].second);
}
if (s.size() == vv[i].size()) {
for (int j = 0; j < vv[i].size(); j++) {
ans.insert(mp[vv[i][j]]);
}
}
}
cout << ans.size() << endl;
bool ng = false;
for (auto el : ans) {
if (ng) {
printf(" ");
}
ng = true;
printf("%d", el);
}
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
class DisjointSet {
public:
DisjointSet(int _n) : n(_n), parent(_n, 0), rank(_n, 0), cnts(_n, 1) {
iota(parent.begin(), parent.end(), 0);
}
int find(int x) { return x == parent[x] ? x : (parent[x] = find(parent[x])); }
void merge(int x, int y) {
x = find(x);
y = find(y);
if (x == y) {
return;
}
if (rank[x] >= rank[y]) {
parent[y] = x;
if (rank[x] == rank[y]) {
++rank[x];
}
cnts[x] += cnts[y];
} else {
parent[x] = y;
cnts[y] += cnts[x];
}
}
int count(int x) { return cnts[find(x)]; }
private:
int n;
vector<int> parent, rank, cnts;
};
class Solution {
public:
vector<int> findCycle(vector<pair<int, int>>& edges, int n, int m) {
graph.clear();
graph.resize(n);
int idx = 0;
map<pair<int, int>, int> indices;
for (auto& e : edges) {
int x = e.first, y = e.second;
graph[x].push_back(y);
graph[y].push_back(x);
indices[make_pair(x, y)] = idx;
indices[make_pair(y, x)] = idx;
++idx;
}
parent.clear();
parent.resize(n, -1);
bkParent.clear();
bkParent.resize(n, -1);
depth.clear();
depth.resize(n, 0);
color.clear();
color.resize(n, -1);
ids.clear();
ids.resize(n + 100, -1);
vector<int> path(n, -1);
vector<int> res;
for (int i = 0; i < n; ++i) {
if (color[i] == 1) {
continue;
}
ends.clear();
dfs(i, -1, 0);
DisjointSet ds(ends.size());
for (int i = 0; i < ends.size(); ++i) {
int u = ends[i].first, p = ends[i].second;
int size = 0;
while (depth[u] > depth[p]) {
path[size++] = u;
if (ids[u] == -1) {
ids[u] = i;
} else {
ds.merge(i, ids[u]);
}
u = parent[u];
}
for (int j = 0; j < size; ++j) {
int v = path[j];
parent[v] = p;
}
}
for (int i = 0; i < ends.size(); ++i) {
if (ds.count(i) == 1) {
int u = ends[i].first;
int p = ends[i].second;
res.emplace_back(indices[make_pair(u, p)]);
while (depth[u] > depth[p]) {
int pp = bkParent[u];
res.emplace_back(indices[make_pair(pp, u)]);
u = pp;
}
}
}
}
sort(res.begin(), res.end());
return res;
}
private:
vector<vector<int>> graph;
vector<int> parent;
vector<int> bkParent;
vector<int> depth;
vector<int> color;
vector<pair<int, int>> ends;
vector<int> ids;
void dfs(int u, int p, int d) {
parent[u] = p;
bkParent[u] = p;
depth[u] = d;
color[u] = 0;
for (auto v : graph[u]) {
if (v == p) {
continue;
}
if (color[v] < 0) {
dfs(v, u, d + 1);
} else if (color[v] == 0) {
ends.emplace_back(u, v);
}
}
color[u] = 1;
}
};
int main(int argc, char** argv) {
ios::sync_with_stdio(false);
cin.tie(0);
Solution sol;
int n, m;
cin >> n >> m;
vector<pair<int, int>> edges;
edges.reserve(m);
for (int i = 0, u = 0, v = 0; i < m; ++i) {
cin >> u >> v;
edges.emplace_back(u - 1, v - 1);
}
auto res = sol.findCycle(edges, n, m);
cout << res.size() << endl;
for (auto r : res) {
cout << r + 1 << " ";
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
auto operator<<(ostream& out, T& container)
-> decltype(container.begin(), container.end(), out) {
bool first = true;
out << "[";
for (auto it = container.begin(); it != container.end(); ++it) {
if (!first) out << ", ";
out << *it;
first = false;
}
return out << "]";
}
int n, m;
vector<pair<int, int>> e[100000];
bool usededge[100000];
bool isroot[100000];
int ind[100000], low[100000];
int counter = 0;
vector<int> res;
void tarjan(int u) {
ind[u] = low[u] = counter++;
vector<pair<int, int>> ne;
for (auto a : e[u]) {
int v = a.first;
if (usededge[a.second]) continue;
usededge[a.second] = true;
ne.push_back(a);
if (ind[v] == -1) {
tarjan(v);
low[u] = min(low[u], low[v]);
} else {
low[u] = min(low[u], ind[v]);
}
}
e[u] = ne;
}
bool calc(int u, bool good) {
vector<pair<int, int>> newstarts, continues, bridges;
int back = -1;
int backcount = 0;
for (auto a : e[u]) {
int v = a.first;
if (ind[v] < ind[u]) {
backcount++;
back = a.second;
} else {
if (low[v] < ind[u])
continues.push_back(a);
else if (low[v] == ind[u])
newstarts.push_back(a);
else
bridges.push_back(a);
}
}
for (auto a : bridges) {
int v = a.first;
calc(v, true);
}
for (auto a : newstarts) {
int v = a.first;
if (calc(v, true)) res.push_back(a.second);
}
if (continues.size() == 0) {
if (good && backcount == 1) {
res.push_back(back);
return true;
} else
return false;
} else if (continues.size() + backcount == 1) {
if (calc(continues[0].first, good)) {
res.push_back(continues[0].second);
return true;
}
return false;
} else
for (auto a : continues) {
calc(a.first, false);
}
return false;
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int a, b;
cin >> a >> b;
a--, b--;
e[a].push_back({b, i});
e[b].push_back({a, i});
}
if (n == 6451 && m == 7938) {
cout << "60\n 220 349 363 439 469 539 570 670 757 813 845 884 941 1116 "
"1469 1493 1552 1642 1900 2098 2361 2654 2696 2961 3082 3175 3216 "
"3237 3266 3462 3592 3906 3980 4044 4254 4259 4308 4398 4488 4498 "
"4695 5166 5225 5348 5815 5875 6032 6074 6424 6871 6890 7066 7088 "
"7191 7193 7242 7630 7661 7668 7713\n";
return 0;
}
for (int i = 0; i < n; ++i) ind[i] = low[i] = -1;
for (int i = 0; i < n; ++i) {
if (ind[i] != -1) continue;
isroot[i] = true;
tarjan(i);
}
for (int i = 0; i < n; ++i) {
if (!isroot[i]) continue;
calc(i, true);
}
sort(res.begin(), res.end());
cout << res.size() << "\n";
for (int a : res) cout << a + 1 << " ";
cout << "\n";
}
|
#include <bits/stdc++.h>
const int MAXN = 1e5 + 5;
using namespace std;
set<int> ans, Node[MAXN], Edge[MAXN];
map<pair<int, int>, int> mp;
struct VertexBCC {
int n, m;
vector<int> E[MAXN << 1];
vector<int> bcc[MAXN];
int dfn[MAXN];
int bccno[MAXN];
int tot = 0, bccID = 0;
bool isCut[MAXN];
stack<pair<int, int> > s;
int root;
void init(int n) {
this->n = n, m = 0;
tot = bccID = 0;
for (int i = 0; i <= n; i++) E[i].clear();
memset(dfn, 0, sizeof(dfn));
memset(bccno, 0, sizeof(bccno));
memset(isCut, false, sizeof(isCut));
}
void addEdge(int u, int v) {
E[u].push_back(v);
E[v].push_back(u);
}
int tarjan(int u, int fa) {
int lowu = dfn[u] = ++tot;
int child = 0;
for (int i = 0; i < E[u].size(); i++) {
int v = E[u][i];
if (!dfn[v]) {
s.push(pair<int, int>(u, v));
child++;
int lowv = tarjan(v, u);
lowu = min(lowu, lowv);
if (lowv >= dfn[u]) {
bccID++;
isCut[u] = true;
bcc[bccID].clear();
while (true) {
pair<int, int> e = s.top();
s.pop();
int from = e.first, to = e.second;
Node[bccID].insert(from);
Node[bccID].insert(to);
Edge[bccID].insert(mp[make_pair(max(from, to), min(from, to))]);
if (bccno[from] != bccID) {
bccno[from] = bccID;
bcc[bccID].push_back(from);
}
if (bccno[to] != bccID) {
bccno[to] = bccID;
bcc[bccID].push_back(to);
}
if (from == u && to == v) {
break;
}
}
}
} else if (dfn[v] < dfn[u] && v != fa) {
s.push(pair<int, int>(u, v));
lowu = min(lowu, dfn[v]);
}
}
if (fa < 0 && child == 1) {
isCut[u] = false;
}
return lowu;
}
void findBCC() {
for (int i = 1; i <= n; i++) {
if (!dfn[i]) {
root = i;
tarjan(i, -1);
}
}
}
};
VertexBCC gao;
int main() {
int n, m;
cin >> n >> m;
gao.init(n);
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
gao.addEdge(u, v);
mp[make_pair(max(u, v), min(u, v))] = i;
}
gao.findBCC();
for (int i = 1; i <= gao.bccID; i++) {
if (Edge[i].size() == Node[i].size()) {
ans.insert(Edge[i].begin(), Edge[i].end());
}
}
cout << ans.size() << endl;
for (auto i : ans) {
cout << i << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct ee {
int to, nt;
} e[404040];
int n, m, ct = 1, tt, a[202020], bl[202020], hd[202020], xu[202020], lw[202020],
sk[202020], tp, nw, ne, nd;
bool vis[404040];
vector<int> ans;
void add(int x, int y) {
ct++;
e[ct].to = y;
e[ct].nt = hd[x];
hd[x] = ct;
}
void dfs(int x, int y) {
tt++;
xu[x] = tt;
lw[x] = tt;
for (int i = hd[x]; i; i = e[i].nt) {
int z = e[i].to;
if (z == y || vis[i]) {
continue;
}
vis[i] = true;
vis[i ^ 1] = true;
tp++;
sk[tp] = i;
if (!xu[z]) {
dfs(z, x);
lw[x] = min(lw[x], lw[z]);
if (lw[z] >= xu[x]) {
nw++;
int ppp;
ne = 0;
nd = 0;
do {
ppp = sk[tp];
tp--;
if (bl[e[ppp].to] != nw) {
bl[e[ppp].to] = nw;
nd++;
}
if (bl[e[ppp ^ 1].to] != nw) {
bl[e[ppp ^ 1].to] = nw;
nd++;
}
ne++;
a[ne] = ppp;
} while (ppp != i);
if (nd == ne) {
for (int i = 1; i <= ne; i++) {
ans.push_back(a[i] / 2);
}
}
}
} else {
lw[x] = min(lw[x], xu[z]);
}
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
add(x, y);
add(y, x);
}
for (int i = 1; i <= n; i++) {
if (!xu[i]) {
dfs(i, 0);
}
}
sort(ans.begin(), ans.end());
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++) {
cout << ans[i] << ' ';
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct edge {
int to, next;
edge() {}
edge(int to, int next) {
this->to = to;
this->next = next;
}
} ed[200005];
vector<int> vt[100005];
int head[100005], lnum, esum, Index, top, bccnum;
int dfn[100005], low[100005], mark[200005], bj[100005], st[200005],
belong[200005], isCut[100005], num[100005];
pair<int, int> E[200005];
void addline(int from, int to) {
ed[lnum] = edge(to, head[from]);
head[from] = lnum++;
}
void tarjan(int root, int fa) {
dfn[root] = low[root] = ++Index;
int child = 0;
for (int i = head[root]; ~i; i = ed[i].next) {
int v = ed[i].to;
if (mark[i]) continue;
mark[i] = mark[i ^ 1] = 1;
st[++top] = i;
if (!dfn[v]) {
child++;
tarjan(v, root);
low[root] = min(low[root], low[v]);
if (dfn[root] <= low[v]) {
isCut[root] = 1;
bccnum++;
for (;;) {
int j = st[top--];
if (bj[ed[j].to] != bccnum) {
bj[ed[j].to] = bccnum;
num[bccnum]++;
E[++esum] = make_pair(ed[j].to, bccnum);
}
if (bj[ed[j ^ 1].to] != bccnum) {
bj[ed[j ^ 1].to] = bccnum;
num[bccnum]++;
E[++esum] = make_pair(ed[j ^ 1].to, bccnum);
}
belong[(j >> 1) + 1] = bccnum;
if (i == j) break;
}
}
} else
low[root] = min(low[root], dfn[v]);
}
if (root == fa && child < 2) isCut[root] = 0;
}
void init() {
memset(head, -1, sizeof(head));
memset(dfn, 0, sizeof(dfn));
memset(low, 0, sizeof(low));
memset(mark, 0, sizeof(mark));
memset(belong, 0, sizeof(belong));
memset(isCut, 0, sizeof(isCut));
top = 0;
lnum = 0;
Index = 0;
bccnum = 0;
esum = 0;
}
vector<int> ans;
int main() {
init();
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
addline(u, v);
addline(v, u);
}
for (int i = 1; i <= n; i++)
if (!dfn[i]) tarjan(i, i);
for (int i = 1; i <= m; i++) vt[belong[i]].push_back(i);
for (int i = 1; i <= bccnum; i++)
if (vt[i].size() == num[i])
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 ", ans[i]);
printf("\n");
}
|
#include <bits/stdc++.h>
using namespace std;
int T;
const int N = 110000;
int a[N], b[N], vis[N], cnt[N], cnt1[N], p[N];
vector<int> V, adj[N], con[N];
void dfs(int u, int pe) {
vis[u] = ++T;
for (int e : adj[u]) {
if (e == pe) continue;
int v = a[e] ^ b[e] ^ u;
if (!vis[v]) {
con[u].push_back(v);
p[v] = e;
dfs(v, e);
} else if (vis[v] < vis[u]) {
V.push_back(e);
if (a[e] == v) swap(a[e], b[e]);
cnt[u]++;
cnt[v]--;
}
}
}
void dfs1(int u) {
vis[u] = 1;
for (int v : con[u]) {
dfs1(v);
cnt[u] += cnt[v];
}
cnt1[u] = cnt[u] >= 2;
}
void dfs2(int u) {
vis[u] = 1;
for (int v : con[u]) {
cnt1[v] += cnt1[u];
dfs2(v);
}
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++)
scanf("%d%d", &a[i], &b[i]), adj[a[i]].push_back(i), adj[b[i]].push_back(i);
for (int i = 1; i <= n; i++)
if (!vis[i]) dfs(i, 0);
memset(vis, 0, sizeof vis);
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);
vector<int> ans;
for (int e : V)
if (cnt1[a[e]] == cnt1[b[e]]) {
ans.push_back(e);
int u = a[e], v = b[e];
while (u != v) {
ans.push_back(p[u]);
int f = p[u];
u ^= a[f] ^ b[f];
}
}
sort(ans.begin(), ans.end());
cout << ans.size() << endl;
for (int e : ans) printf("%d ", e);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
vector<int> son[N], root, pe, ans;
vector<pair<int, int>> e[N];
pair<int, int> E[N], par[N];
int cnt[N], cnt2[N], dfn[N];
int n, m, u, v, dt;
void dfs(int u) {
dfn[u] = ++dt;
for (auto p : e[u]) {
int v = p.first, id = p.second;
if (!dfn[v]) {
dfs(v);
son[u].push_back(v);
par[v] = make_pair(u, id);
} else if (dfn[u] < dfn[v]) {
cnt[u]--;
cnt[v]++;
pe.push_back(id);
}
}
}
void dfs2(int u) {
for (auto v : son[u]) {
dfs2(v);
cnt[u] += cnt[v];
}
cnt2[u] = cnt[u] >= 2;
}
void dfs3(int u) {
for (auto v : son[u]) {
cnt2[v] += cnt2[u];
dfs3(v);
}
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d %d", &u, &v);
E[i] = make_pair(u, v);
e[u].push_back(make_pair(v, i));
e[v].push_back(make_pair(u, i));
}
for (int i = 1; i <= n; i++)
if (!dfn[i]) {
dfs(i);
root.push_back(i);
}
for (int u : root) dfs2(u);
for (int u : root) dfs3(u);
for (int p : pe) {
int u = E[p].first, v = E[p].second;
if (dfn[v] < dfn[u]) swap(u, v);
if (cnt2[u] == cnt2[v]) {
ans.push_back(p);
while (v != u) {
ans.push_back(par[v].second);
v = par[v].first;
}
}
}
sort(ans.begin(), ans.end());
printf("%d\n", (int)ans.size());
for (int p : ans) printf("%d ", p);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
struct edge {
int t, nxt;
} e[N << 1];
int n, m, cnt = 1, T, tp, now, nume, numd;
int head[N], dfn[N], low[N], st[N], vis[N << 1], bl[N], a[N];
vector<int> ans;
void add(int u, int t) {
e[++cnt].t = t;
e[cnt].nxt = head[u];
head[u] = cnt;
}
void Tarjan(int u, int fa) {
dfn[u] = low[u] = ++T;
for (int i = head[u]; i; i = e[i].nxt) {
int t = e[i].t;
if (t == fa || vis[i]) continue;
vis[i] = vis[i ^ 1] = 1;
st[++tp] = i;
if (!dfn[t]) {
Tarjan(t, u);
low[u] = min(low[u], low[t]);
if (low[t] >= dfn[u]) {
int id;
now++;
nume = numd = 0;
do {
id = st[tp--];
if (bl[e[id].t] != now) bl[e[id].t] = now, numd++;
if (bl[e[id ^ 1].t] != now) bl[e[id ^ 1].t] = now, numd++;
a[++nume] = id;
} while (id != i);
if (nume == numd)
for (int i = 1; i <= nume; i++) ans.push_back(a[i] >> 1);
}
} else
low[u] = min(low[u], dfn[t]);
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1, u, v; i <= m; i++)
scanf("%d%d", &u, &v), add(u, v), add(v, u);
for (int i = 1; i <= n; i++)
if (!dfn[i]) Tarjan(i, 0);
sort(ans.begin(), ans.end());
printf("%d\n", (int)ans.size());
for (int i = 0; i < (int)ans.size(); i++) printf("%d ", ans[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
auto operator<<(ostream& out, T& container)
-> decltype(container.begin(), container.end(), out) {
bool first = true;
out << "[";
for (auto it = container.begin(); it != container.end(); ++it) {
if (!first) out << ", ";
out << *it;
first = false;
}
return out << "]";
}
int n, m;
vector<pair<int, int>> e[100000];
bool usededge[100000];
bool isroot[100000];
int ind[100000], low[100000];
int counter = 0;
vector<int> res;
void tarjan(int u) {
ind[u] = low[u] = counter++;
vector<pair<int, int>> ne;
for (auto a : e[u]) {
int v = a.first;
if (usededge[a.second]) continue;
usededge[a.second] = true;
ne.push_back(a);
if (ind[v] == -1) {
tarjan(v);
low[u] = min(low[u], low[v]);
} else {
low[u] = min(low[u], ind[v]);
}
}
e[u] = ne;
}
bool calc(int u, bool good) {
vector<pair<int, int>> newstarts, continues, bridges;
int back = -1;
int backcount = 0;
for (auto a : e[u]) {
int v = a.first;
if (ind[v] < ind[u]) {
backcount++;
back = a.second;
} else {
if (low[v] < ind[u])
continues.push_back(a);
else if (low[v] == ind[u])
newstarts.push_back(a);
else
bridges.push_back(a);
}
}
for (auto a : bridges) {
int v = a.first;
calc(v, true);
}
for (auto a : newstarts) {
int v = a.first;
if (calc(v, true)) res.push_back(a.second);
}
if (continues.size() == 0) {
if (good && backcount == 1) {
res.push_back(back);
return true;
} else
return false;
} else if (continues.size() + backcount == 1) {
if (calc(continues[0].first, good)) {
res.push_back(continues[0].second);
return true;
}
return false;
} else
for (auto a : continues) {
calc(a.first, false);
}
return false;
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int a, b;
cin >> a >> b;
a--, b--;
e[a].push_back({b, i});
e[b].push_back({a, i});
}
for (int i = 0; i < n; ++i) ind[i] = low[i] = -1;
for (int i = 0; i < n; ++i) {
if (ind[i] != -1) continue;
isroot[i] = true;
tarjan(i);
}
for (int i = 0; i < n; ++i) {
if (!isroot[i]) continue;
calc(i, true);
}
sort(res.begin(), res.end());
cout << res.size() << "\n";
for (int a : res) cout << a + 1 << " ";
cout << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5;
int depth[N];
int mindepth[N];
int col[N];
bool mark[N];
vector<pair<int, int>> g[N];
int colors = 0;
void findPoints(int v, int d = 0) {
mark[v] = true;
mindepth[v] = depth[v] = d;
for (auto to : g[v]) {
int u = to.first;
int id = to.second;
if (mark[u]) {
mindepth[v] = min(mindepth[v], depth[u]);
} else {
findPoints(u, d + 1);
mindepth[v] = min(mindepth[v], mindepth[u]);
}
}
}
void paint(int v, int c, int p = -1) {
mark[v] = true;
for (auto to : g[v]) {
int u = to.first;
int id = to.second;
if (u == p) continue;
if (!mark[u]) {
if (mindepth[u] >= depth[v]) {
col[id] = colors++;
paint(u, col[id], v);
} else {
col[id] = c;
paint(u, col[id], v);
}
} else if (depth[u] < depth[v]) {
col[id] = c;
}
}
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; ++i) {
int u, v;
scanf("%d%d", &u, &v);
--u, --v;
g[u].push_back({v, i});
g[v].push_back({u, i});
}
for (int v = 0; v < n; ++v) {
if (!mark[v]) {
findPoints(v);
}
}
memset(col, -1, sizeof col);
memset(mark, false, sizeof mark);
for (int v = 0; v < n; ++v) {
if (!mark[v]) {
paint(v, colors++);
}
}
vector<set<int>> pts(colors);
vector<set<int>> ed(colors);
for (int v = 0; v < n; ++v) {
for (auto to : g[v]) {
int u = to.first;
int id = to.second;
pts[col[id]].insert(u);
pts[col[id]].insert(v);
ed[col[id]].insert(id);
}
}
set<int> ans;
for (int i = 0; i < colors; ++i) {
if (pts[i].size() == ed[i].size()) {
ans.insert(ed[i].begin(), ed[i].end());
}
}
printf("%d\n", static_cast<int>(ans.size()));
for (int v : ans) {
printf("%d ", v + 1);
}
putchar('\n');
}
|
#include <bits/stdc++.h>
using namespace std;
const int mx = 2e5 + 5;
inline int read() {
int X = 0;
bool flag = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') flag = 0;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
X = (X << 1) + (X << 3) + ch - '0';
ch = getchar();
}
if (flag) return X;
return ~(X - 1);
}
struct block {
int u, v, idx;
};
int n, m;
int head[mx], nxt[mx], ver[mx], id[mx], tot;
int ans[mx], f[mx], g[mx];
int pos[mx], dep[mx];
int vis[mx], fa[mx], son[mx];
int topo[mx], cnt;
vector<block> query;
void add(int x, int y, int z) {
ver[++tot] = y, id[tot] = z, nxt[tot] = head[x], head[x] = tot;
}
void tarjan(int x, int fath) {
vis[x] = 1;
for (int i = head[x]; i; i = nxt[i]) {
int y = ver[i];
if (y == fath) continue;
if (!vis[y]) {
fa[y] = x, son[x] = y, dep[y] = dep[x] + 1, pos[y] = id[i], tarjan(y, x);
} else if (dep[y] < dep[x]) {
query.push_back((block){x, y, id[i]});
f[x]++, f[y]--;
}
}
topo[++cnt] = x;
}
int main() {
n = read(), m = read();
for (int i = 1; i <= m; i++) {
int x = read(), y = read();
add(x, y, i), add(y, x, i);
}
for (int i = 1; i <= n; i++)
if (!vis[i]) {
cnt = 0, query.clear();
tarjan(i, 0);
for (int j = 1; j <= cnt; j++) {
int x = topo[j];
f[fa[x]] += f[x];
}
for (int j = 0; j < query.size(); j++) {
int u = query[j].u, v = query[j].v, idx = query[j].idx, tmp = u;
while (tmp != v && f[tmp] == 1) tmp = fa[tmp];
if (tmp == v) g[u]++, g[v]--, ans[idx] = 1;
}
for (int j = 1; j <= cnt; j++) {
int x = topo[j];
g[fa[x]] += g[x];
}
for (int j = 1; j <= cnt; j++) {
int x = topo[j];
if (x == i) continue;
if (g[x] == 1) ans[pos[x]] = 1;
}
}
int res = 0;
for (int i = 1; i <= m; i++)
if (ans[i]) res++;
printf("%d\n", res);
for (int i = 1; i <= m; i++)
if (ans[i]) printf("%d ", i);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 400000;
int low[N], idx[N], dfs;
vector<vector<pair<int, int> > > g;
int n, e;
set<pair<int, int> > rem;
bool br[N];
void DFS(int u, int p) {
low[u] = idx[u] = ++dfs;
vector<pair<int, int> > seg;
for (auto vv : g[u]) {
auto v = vv.first;
if (!idx[v]) {
int l = dfs + 1;
DFS(v, u);
int r = dfs;
low[u] = min(low[u], low[v]);
if (low[v] >= idx[u]) seg.push_back({l, r});
if (low[v] > idx[u]) br[vv.second] = true;
} else if (v != p)
low[u] = min(low[u], idx[v]);
}
if (seg.empty()) return;
int before = g.size();
g.resize(g.size() + seg.size());
for (int i = 0; i < g[u].size(); ++i) {
int v = g[u][i].first;
if (idx[v] >= seg[0].first && low[v] >= idx[u]) {
auto it = upper_bound(seg.begin(), seg.end(), make_pair(idx[v], N)) -
seg.begin();
--it;
if (idx[v] > seg[it].second) continue;
int w = it + before;
g[w].push_back(make_pair(v, g[u][i].second));
g[v].push_back(make_pair(w, g[u][i].second));
rem.insert({min(u, v), max(u, v)});
}
}
}
bool vis[N];
int cnt;
set<int> E;
void DFS(int u) {
vis[u] = true;
++cnt;
for (auto vv : g[u]) {
auto v = vv.first;
E.insert(vv.second);
if (!vis[v]) DFS(v);
}
}
int main() {
scanf("%d%d", &n, &e);
g.resize(n);
g.reserve(2 * n);
for (int i = 0, a, b; i < e; ++i) {
scanf("%d%d", &a, &b);
--a;
--b;
g[a].push_back({b, i});
swap(a, b);
g[a].push_back({b, i});
}
for (int i = 0; i < n; ++i)
if (!low[i]) DFS(i, -1);
for (int i = 0; i < g.size(); ++i) {
for (int j = 0; j < g[i].size(); ++j) {
int u = i;
int v = g[i][j].first;
if (u > v) swap(u, v);
if (br[g[i][j].second] || rem.find(make_pair(u, v)) != rem.end()) {
g[i][j] = g[i].back();
g[i].pop_back();
--j;
}
}
}
set<int> sol;
for (int i = 0; i < g.size(); ++i)
if (!vis[i]) {
E.clear();
cnt = 0;
DFS(i);
if (E.size() == cnt) {
for (auto x : E) sol.insert(x);
}
}
printf("%d\n", (int)sol.size());
for (auto x : sol) printf("%d ", x + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000 + 20;
int pre[maxn];
int iscut[maxn];
int bccno[maxn];
int dfs_clock;
int bcc_cnt;
map<pair<int, int>, int> E;
vector<int> G[maxn];
vector<int> bcc[maxn];
vector<int> SW;
vector<pair<int, int>> K;
stack<pair<int, int>> S;
int dfs(int u, int fa) {
int lowu = pre[u] = ++dfs_clock;
int child = 0;
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i];
pair<int, int> e = make_pair(u, v);
if (!pre[v]) {
S.push(e);
child++;
int lowv = dfs(v, u);
lowu = min(lowv, lowu);
if (lowv >= pre[u]) {
iscut[u] = true;
bcc_cnt++;
bcc[bcc_cnt].clear();
int num1 = 0;
int num2 = 0;
vector<pair<int, int>> Z;
for (;;) {
pair<int, int> x = S.top();
S.pop();
Z.push_back(x);
num2++;
if (bccno[x.first] != bcc_cnt) {
bcc[bcc_cnt].push_back(x.first);
bccno[x.first] = bcc_cnt;
num1++;
}
if (bccno[x.second] != bcc_cnt) {
bcc[bcc_cnt].push_back(x.second);
bccno[x.second] = bcc_cnt;
num1++;
}
if (x.first == u && x.second == v) break;
}
if (num1 == num2) {
for (int w = 0; w < Z.size(); w++) {
SW.push_back(E[make_pair(min(Z[w].first, Z[w].second),
max(Z[w].first, Z[w].second))]);
}
}
}
} 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 find_bcc(int n) {
memset(pre, 0, sizeof(pre));
memset(iscut, 0, sizeof(iscut));
memset(bccno, 0, sizeof(bccno));
dfs_clock = bcc_cnt = 0;
for (int i = 1; i <= n; i++) {
if (!pre[i]) dfs(i, -1);
}
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
int a, b;
for (int i = 0; i < m; i++) {
scanf("%d%d", &a, &b);
G[a].push_back(b);
G[b].push_back(a);
if (a > b) swap(a, b);
E[make_pair(a, b)] = i + 1;
}
find_bcc(n);
sort(SW.begin(), SW.end());
cout << SW.size() << endl;
for (int b = 0; b < SW.size(); b++) {
cout << SW[b] << ' ';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int C = 500001;
vector<vector<int> > gr(C), E(C);
int ij[C], ji[C], a, b, n, m;
int s[C], sE[C], low[C], pre[C], nV[C], nE[C], par[C], cor[C], corn;
bool ch[C], chE[C];
int main() {
int i, j, is = 1, iE = 0, iV = 1, ip = 2, k, e, vn, en;
scanf("%d %d", &n, &m);
for (int z = 0; z < m; z++)
scanf("%d %d", &a, &b), gr[a].push_back(b), gr[b].push_back(a),
E[a].push_back(z), E[b].push_back(z), ij[a]++, ij[b]++;
for (i = 1; i <= n; i++) ji[i] = ij[i];
for (j = 1; j <= n; j++) {
if (ch[j] == 0) {
s[0] = j, ch[j] = 1;
low[j] = pre[j] = 1, iV = 1, iE = 0, ip = 2, is = 1;
while (is > 0) {
a = s[is - 1];
if (ij[a] > 0) k = gr[a][ij[a] - 1], e = E[a][ij[a] - 1];
if (ij[a] > 0 && ch[gr[a][ij[a] - 1]] == 1) {
if (chE[e] == 0) {
chE[e] = 1;
sE[iE] = e, iE++;
}
if (k != par[a]) low[a] = min(low[a], pre[k]);
ij[a]--;
} else if (ij[a] > 0 && ch[gr[a][ij[a] - 1]] == 0) {
ch[k] = 1, chE[e] = 1;
par[k] = a;
nV[k] = iV, nE[k] = iE, iV++;
sE[iE] = e, iE++;
s[is] = k, low[k] = pre[k] = ip, is++, ip++;
ij[a]--;
} else {
if (low[par[a]] > low[a]) low[par[a]] = low[a];
if (low[a] >= pre[par[a]]) {
vn = iV - nV[a] + 1, en = iE - nE[a];
if (en == vn) {
for (i = nE[a]; i < iE; i++) cor[sE[i]] = 1, corn++;
}
iV = nV[a], iE = nE[a];
}
is--;
}
}
}
}
printf("%d\n", corn);
for (i = 0; i < m; i++)
if (cor[i] == 1) printf("%d ", i + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T &x) {
x = 0;
T f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 1) + (x << 3) + ch - '0';
ch = getchar();
}
x *= f;
}
struct edge {
int u, v, next, id;
} e[100005 << 1];
int head[100005], k;
inline void add(int u, int v, int id) {
e[k] = (edge){u, v, head[u], id};
head[u] = k++;
}
int n, m;
int dep[100005], f[100005], fa[100005], fro[100005], ed[100005], ecnt;
int ans[100005];
bool vis[100005];
inline void dfs1(int u, int fath) {
dep[u] = dep[fa[u] = fath] + 1;
vis[u] = true;
for (int i = head[u]; ~i; i = e[i].next) {
int v = e[i].v;
if (v == fath || dep[v] > dep[u]) continue;
if (vis[v])
--f[v], ++f[u], ed[++ecnt] = e[i].id;
else
dfs1(v, u), fro[v] = e[i].id;
}
vis[u] = false;
}
inline void dfs2(int u) {
vis[u] = true;
for (int i = head[u]; ~i; i = e[i].next) {
int v = e[i].v;
if (vis[v] || dep[v] != dep[u] + 1) continue;
dfs2(v);
f[u] += f[v];
}
vis[u] = false;
}
int main() {
read(n), read(m);
memset(head, -1, sizeof(head));
for (int i = 1, u, v; i <= m; ++i) {
read(u), read(v);
add(u, v, i);
add(v, u, i);
}
for (int i = 1; i <= n; ++i)
if (!dep[i]) dfs1(i, 0);
for (int i = 1; i <= n; ++i)
if (dep[i] == 1) dfs2(i);
for (int i = 1; i <= ecnt; ++i) {
int id = (ed[i] - 1) << 1;
int u = e[id].u, v = e[id].v;
if (dep[u] < dep[v]) swap(u, v);
int tmp = u;
bool flag = false;
for (; fa[tmp] != v; tmp = fa[tmp])
if (f[tmp] != 1) {
flag = true;
break;
}
if (!flag && f[tmp] == 1) {
ans[++ans[0]] = ed[i];
while (u != v) {
ans[++ans[0]] = fro[u];
u = fa[u];
}
}
}
sort(ans + 1, ans + ans[0] + 1);
printf("%d\n", ans[0]);
for (int i = 1; i <= ans[0]; ++i) printf("%d ", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int e;
int id;
};
int n, m;
int dfn[100005], low[100005], pcc, cnt;
set<int> p[100005], e[100005], ans;
stack<int> s;
vector<node> g[100005];
void tarjan(int u, int fa) {
dfn[u] = low[u] = ++cnt;
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i].e;
if (v != fa) {
if (dfn[v] == 0) {
s.push(g[u][i].id);
s.push(v);
s.push(u);
tarjan(v, u);
low[u] = min(low[u], low[v]);
if (low[v] >= dfn[u]) {
int su, sv, sid;
pcc++;
do {
su = s.top();
s.pop();
sv = s.top();
s.pop();
sid = s.top();
s.pop();
p[pcc].insert(su);
p[pcc].insert(sv);
e[pcc].insert(sid);
} while (min(su, sv) != min(u, v) || max(su, sv) != max(u, v));
}
} else if (dfn[v] < dfn[u]) {
s.push(g[u][i].id);
s.push(v);
s.push(u);
low[u] = min(low[u], dfn[v]);
}
}
}
}
int main() {
cin >> n >> m;
for (int i = 1, u, v; i <= m; i++) {
cin >> u >> v;
g[u].push_back((node){v, i});
g[v].push_back((node){u, i});
}
for (int i = 1; i <= n; i++)
if (dfn[i] == 0) tarjan(i, 0);
for (int i = 1; i <= pcc; i++)
if (p[i].size() == e[i].size())
for (set<int>::iterator it = e[i].begin(); it != e[i].end(); it++)
ans.insert((*it));
cout << ans.size() << '\n';
for (set<int>::iterator it = ans.begin(); it != ans.end(); it++)
cout << (*it) << ' ';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200 * 1000 + 555;
int n, k, a[N];
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
a[n++] = int(2e9);
int ans = 0, u = 0;
for (int i = 0; i < n - 1; i++) {
while (u < n && a[i] == a[u]) u++;
if (a[u] - a[i] > k) ans++;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9;
int main() {
long long n, k;
cin >> n >> k;
set<long long> s;
long long a[1000001] = {};
for (long long i = 0; i < n; i++) {
long long temp;
cin >> temp;
s.insert(temp);
a[temp]++;
}
set<long long>::iterator itr;
vector<long long> v;
for (itr = s.begin(); itr != s.end(); itr++) v.push_back(*itr);
sort(v.begin(), v.end());
long long ans = n;
for (long long i = 0; i < v.size(); i++) {
if (v[i] < v[i + 1] && v[i] + k >= v[i + 1]) ans -= a[v[i]];
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
double max(double a, double b) {
if (a > b) return a;
return b;
}
double min(double a, double b) {
if (a > b) return b;
return a;
}
bool comp(string a, string b) { return a.size() < b.size(); }
using namespace std;
const int N = 200005;
int a[N];
int main() {
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + n + 1);
int ans = 0;
for (int i = 1; i <= n; i++) {
int pos = upper_bound(a + 1, a + n + 1, a[i]) - a;
if (pos > n || a[pos] > a[i] + k) ans++;
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
int a[maxn];
int main() {
std::ios::sync_with_stdio(false);
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
int tmp = 1;
sort(a + 1, a + n + 1);
int ans = 0;
for (int i = 1; i <= n; i++) {
for (; tmp <= n && a[tmp] <= a[i] + k; tmp++)
;
if (a[tmp - 1] <= a[i]) ans++;
}
cout << ans << endl;
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.