text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
struct SCC {
int n, d = 0;
stack<int> S;
vector<vector<int>> edg;
vector<int> dfn, low, com;
SCC(int _n) : n(_n), edg(n + 1), dfn(n + 1, 0), low(n + 1), com(n + 1, 0) {}
void add(int u, int v) { edg[u].push_back(v); }
void operator()() {
int ans = -1;
vector<int> cnt(n + 1, 0), deg(n + 1, 0);
for (int u = 1; u <= n; u++) {
if (!dfn[u]) dfs(u);
for (int v : edg[u])
if (com[u] != com[v]) deg[com[u]]++;
cnt[com[u]]++;
}
for (int i = 1; i <= n; i++)
if (cnt[i] > 0 && deg[i] == 0 && (ans < 0 || cnt[ans] > cnt[i])) ans = i;
printf("%d\n", cnt[ans]);
for (int i = 1; i <= n; i++)
if (com[i] == ans) printf(cnt[ans]-- == 1 ? "%d\n" : "%d ", i);
}
void dfs(int u) {
dfn[u] = low[u] = ++d;
S.push(u);
for (int v : edg[u]) {
if (!dfn[v]) dfs(v);
if (!com[v]) low[u] = min(low[u], low[v]);
}
if (dfn[u] == low[u])
for (int v; v = S.top(), S.pop(), com[v] = u, v != u;)
;
}
};
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
vector<int> a(n + 1);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
SCC S(n);
for (; m > 0; m--) {
int u, v;
scanf("%d%d", &u, &v);
if (a[v] == (a[u] + 1) % k) S.add(u, v);
if (a[u] == (a[v] + 1) % k) S.add(v, u);
}
S();
}
|
#include <bits/stdc++.h>
using namespace std;
const int Inf = 1e9 + 5;
const int Dim = 1e6 + 5;
int grad[Dim], cmp[Dim], val[Dim];
int n, m, h, nrc, ans = Inf, pos;
bool viz[Dim], vizback[Dim];
vector<int> v[Dim], vt[Dim], ctc[Dim], sortop;
void dfs(int node) {
viz[node] = 1;
for (vector<int>::iterator it = v[node].begin(); it != v[node].end(); ++it) {
if (viz[*it] == 0) {
dfs(*it);
}
}
sortop.push_back(node);
}
void dfs_back(int node) {
vizback[node] = 1;
ctc[nrc].push_back(node);
cmp[node] = nrc;
for (vector<int>::iterator it = vt[node].begin(); it != vt[node].end();
++it) {
if (vizback[*it] == 0) {
dfs_back(*it);
}
}
}
void calc_ctc() {
for (int i = 1; i <= n; ++i) {
if (viz[i] == 0) {
dfs(i);
}
}
for (int i = sortop.size() - 1; i >= 0; --i) {
if (vizback[sortop[i]] == 0) {
++nrc;
dfs_back(sortop[i]);
}
}
for (int i = 1; i <= n; ++i) {
for (vector<int>::iterator it = v[i].begin(); it != v[i].end(); ++it) {
int p = *it;
if (cmp[p] != cmp[i]) {
++grad[cmp[i]];
}
}
}
n = nrc;
}
int main() {
cin >> n >> m >> h;
for (int i = 1; i <= n; ++i) {
cin >> val[i];
}
int x, y;
for (int i = 1; i <= m; ++i) {
cin >> x >> y;
if ((val[x] + 1) % h == val[y]) {
v[x].push_back(y);
vt[y].push_back(x);
}
if ((val[y] + 1) % h == val[x]) {
v[y].push_back(x);
vt[x].push_back(y);
}
}
calc_ctc();
for (int i = 1; i <= n; ++i) {
if (grad[i] == 0) {
if (ctc[i].size() < ans) {
ans = ctc[i].size();
pos = i;
}
}
}
cout << ans << '\n';
for (vector<int>::iterator it = ctc[pos].begin(); it != ctc[pos].end();
++it) {
cout << *it << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100001;
const int INF = 0x7fffffff;
int fir[MAXN], nxt[MAXN << 1], to[MAXN << 1], from[MAXN << 1], cnt;
int dfn[MAXN], low[MAXN], tim;
int sta[MAXN], top;
bool vis[MAXN];
int scc[MAXN], size[MAXN], num;
int t[MAXN], du[MAXN];
inline int read() {
int k = 0;
char ch = getchar();
while (ch < '0' || ch > '9') ch = getchar();
while (ch >= '0' && ch <= '9') {
k = k * 10 + ch - '0';
ch = getchar();
}
return k;
}
inline void add_edge(int a, int b) {
from[++cnt] = a;
to[cnt] = b;
nxt[cnt] = fir[a];
fir[a] = cnt;
}
void Tarjan(int u) {
dfn[u] = low[u] = ++tim;
sta[++top] = u;
vis[u] = true;
for (int i = fir[u]; i != -1; i = nxt[i]) {
int v = to[i];
if (!dfn[v]) {
Tarjan(v);
low[u] = min(low[u], low[v]);
} else if (vis[v])
low[u] = min(low[u], dfn[v]);
}
if (low[u] == dfn[u]) {
num++;
do {
scc[sta[top]] = num;
size[num]++;
vis[sta[top--]] = false;
} while (sta[top + 1] != u);
}
}
int main() {
memset(fir, -1, sizeof(fir));
int n = read(), m = read(), h = read(), rec;
for (int i = 1; i <= n; i++) t[i] = read();
for (int i = 1; i <= m; i++) {
int u = read(), v = read();
if ((t[u] + 1) % h == t[v]) add_edge(u, v);
if ((t[v] + 1) % h == t[u]) add_edge(v, u);
}
for (int i = 1; i <= n; i++)
if (!dfn[i]) Tarjan(i);
for (int i = 1; i <= cnt; ++i)
if (scc[from[i]] != scc[to[i]]) du[scc[from[i]]]++;
size[rec] = INF;
for (int i = 1; i <= num; ++i) {
if (!du[i] && size[i] < size[rec]) rec = i;
}
printf("%d\n", size[rec]);
for (int i = 1; i <= n; i++)
if (scc[i] == rec) printf("%d ", i);
return 0;
}
|
#include <bits/stdc++.h>
using std ::max;
using std ::min;
template <class T>
bool chkmin(T &x, const T &y) {
return y < x ? x = y, true : false;
}
template <class T>
bool chkmax(T &x, const T &y) {
return y > x ? x = y, true : false;
}
class FastInput {
private:
static const int L = 1 << 15 | 1;
char buffer[L], *_, *__;
inline void Next(char &ch) {
if (_ == __) __ = (_ = buffer) + fread(buffer, 1, L, stdin);
ch = _ == __ ? EOF : *_++;
}
public:
template <class T>
void operator()(T &in) {
char ch;
int f = 1;
for (Next(ch); !isdigit(ch); Next(ch))
if (ch == '-') f = -1;
for (in = 0; isdigit(ch); Next(ch)) in = in * 10 + ch - '0';
in *= f;
}
};
const int maxx = 200000 + 25;
int n, m, x, y, z, k, num = 1;
int cnt, tot, front, back, mx, mn;
int len, t1, t2, h, top, ans;
int a[maxx], vis[maxx], u[maxx], v[maxx];
int head[maxx], to[maxx], nxt[maxx];
int low[maxx], ddf[maxx], ink[maxx], vest[maxx], skt[maxx], size[maxx];
void Ins(int, int);
void Tarjan(int);
int main() {
scanf("%d%d%d", &n, &m, &h);
for (int i = (1), i_END = (n); i <= (i_END); ++i) scanf("%d", &a[i]);
for (int i = (1), i_END = (m); i <= (i_END); ++i) {
scanf("%d%d", &x, &y);
if (a[x] == (a[y] + 1) % h) Ins(y, x);
if (a[y] == (a[x] + 1) % h) Ins(x, y);
}
for (int i = (1), i_END = (n); i <= (i_END); ++i)
if (!ddf[i]) Tarjan(i);
for (int i = (1), i_END = (u[0]); i <= (i_END); ++i)
if (vest[u[i]] != vest[v[i]]) vis[vest[u[i]]] = 1;
ans = 20011025;
for (int i = (1), i_END = (tot); i <= (i_END); ++i) {
if (!vis[i]) {
if (chkmin(ans, size[i])) cnt = i;
}
}
printf("%d\n", ans);
for (int i = (1), i_END = (n); i <= (i_END); ++i)
if (vest[i] == cnt) printf("%d ", i);
printf("\n");
return 0;
}
void Ins(int x, int y) {
u[++u[0]] = x;
v[++v[0]] = y;
to[++num] = y;
nxt[num] = head[x];
head[x] = num;
}
void Tarjan(int x) {
ink[skt[++top] = x] = 1;
ddf[x] = low[x] = ++cnt;
for (int i = head[x]; i; i = nxt[i])
if (!ddf[to[i]])
Tarjan(to[i]), low[x] = min(low[x], low[to[i]]);
else if (ink[to[i]])
low[x] = min(low[x], low[to[i]]);
if (ddf[x] == low[x]) {
++tot;
while (x != skt[top + 1])
ink[skt[top]] = 0, size[tot]++, vest[skt[top--]] = tot;
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> _sz, dsu;
vector<vector<int> > g, g1;
vector<set<int> > g2, g3;
vector<int> u;
vector<int> tout;
vector<int> used;
int timer = 0;
void dfs(int v) {
used[v] = 1;
timer++;
for (int i = 0; i < g[v].size(); i++) {
int to = g[v][i];
if (!used[to]) {
dfs(to);
}
}
tout[v] = timer++;
}
int pred(int a) {
if (a == dsu[a])
return a;
else
return dsu[a] = pred(dsu[a]);
}
void unite(int a, int b) {
a = pred(a);
b = pred(b);
if (a != b) {
if (_sz[a] < _sz[b]) {
swap(a, b);
}
dsu[b] = a;
_sz[a] += _sz[b];
}
}
vector<int> comp;
void dfs1(int v) {
used[v] = 1;
comp.push_back(v);
for (int i = 0; i < g1[v].size(); i++) {
int to = g1[v][i];
if (!used[to]) {
dfs1(to);
}
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m, h;
cin >> n >> m >> h;
_sz.resize(n);
dsu.resize(n);
for (int i = 0; i < n; i++) {
dsu[i] = i;
_sz[i] = 1;
}
g.resize(n);
u.resize(n);
g2.resize(n);
g3.resize(n);
used.resize(n);
g1.resize(n);
tout.resize(n);
for (int i = 0; i < n; i++) {
cin >> u[i];
}
vector<pair<int, int> > vec(m);
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
vec[i] = {a, b};
if ((u[a] + 1) % h == u[b]) {
g[a].push_back(b);
g1[b].push_back(a);
}
if ((u[b] + 1) % h == u[a]) {
g1[a].push_back(b);
g[b].push_back(a);
}
}
for (int i = 0; i < n; i++) {
if (!used[i]) {
dfs(i);
}
}
vector<pair<int, int> > mass;
for (int i = 0; i < n; i++) {
used[i] = 0;
mass.push_back({tout[i], i});
}
sort(mass.begin(), mass.end());
for (int i = n - 1; i >= 0; i--) {
if (!used[mass[i].second]) {
dfs1(mass[i].second);
for (int j = 0; j < comp.size() - 1; j++) {
unite(comp[j], comp[j + 1]);
}
comp.clear();
}
}
vector<int> cnt(n);
for (int i = 0; i < m; i++) {
int a1 = vec[i].first;
int b1 = vec[i].second;
int a = pred(vec[i].first);
int b = pred(vec[i].second);
if (a == b) {
continue;
}
if ((u[a1] + 1) % h == u[b1]) {
g2[a].insert(b);
g3[b].insert(a);
}
if ((u[b1] + 1) % h == u[a1]) {
g3[a].insert(b);
g2[b].insert(a);
}
}
int ans = 1e9;
for (int i = 0; i < n; i++) {
if (g2[pred(i)].size() == 0 && _sz[pred(i)] < ans) {
ans = _sz[pred(i)];
}
}
for (int i = 0; i < n; i++) {
used[i] = 0;
}
for (int i = 0; i < n; i++) {
if (_sz[pred(i)] == ans && g2[pred(i)].size() == 0) {
vector<int> ans;
queue<int> q1;
q1.push(i);
used[i] = 1;
while (q1.size() != 0) {
int v = q1.front();
q1.pop();
ans.push_back(v);
for (int j = 0; j < g[v].size(); j++) {
if (!used[g[v][j]]) {
used[g[v][j]] = 1;
q1.push(g[v][j]);
}
}
}
cout << ans.size() << "\n";
for (int j = 0; j < ans.size(); j++) {
cout << ans[j] + 1 << " ";
}
return 0;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k, x, y, a[500005];
int tot, to[500005], ne[500005], la[500005];
int dfn[500005], low[500005], num;
int z[500005], top, p[500005];
int cnt, color[500005], size[500005];
int q[500005], ans;
void read(int &x) {
x = 0;
int k = 1;
char c = getchar();
while ((c != '-') && (c < '0' || c > '9')) c = getchar();
if (c == '-') k = -1, c = getchar();
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
x = x * k;
}
void write(int x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
void link(int u, int v) { to[++tot] = v, ne[tot] = la[u], la[u] = tot; }
void init() { freopen("e.in", "r", stdin); }
void tarjan(int x) {
dfn[x] = low[x] = ++num;
z[++top] = x, p[x] = 1;
for (int i = la[x]; i; i = ne[i]) {
int y = to[i];
if (!dfn[y]) {
tarjan(y);
low[x] = min(low[x], low[y]);
} else if (p[y]) {
low[x] = min(low[x], dfn[y]);
}
}
if (dfn[x] == low[x]) {
p[x] = 0;
color[x] = ++cnt;
int t = 1;
while (x != z[top]) {
t++;
p[z[top]] = 0;
color[z[top]] = cnt;
z[top] = 0;
top--;
}
z[top--] = 0;
size[cnt] = t;
}
}
int main() {
read(n), read(m), read(k);
for (int i = 1; i <= n; i++) read(a[i]);
for (int i = 1; i <= m; i++) {
read(x), read(y);
if ((a[x] + 1) % k == a[y]) link(x, y);
if ((a[y] + 1) % k == a[x]) link(y, x);
}
for (int i = 1; i <= n; i++) {
if (!dfn[i]) tarjan(i);
}
for (int i = 1; i <= n; i++) {
for (int j = la[i]; j; j = ne[j]) {
int y = to[j];
if (color[i] != color[y]) {
q[color[i]] = 1;
}
}
}
ans = -1;
for (int i = 1; i <= n; i++) {
if (q[color[i]]) continue;
if (ans == -1)
ans = i;
else if (size[color[i]] < size[color[ans]])
ans = i;
}
write(size[color[ans]]), printf("\n");
for (int i = 1; i <= n; i++)
if (color[i] == color[ans]) write(i), printf(" ");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int hours[100007], konta[100007];
bool vis[100007];
vector<int> v[100007], v2[100007];
vector<int> scc[100007], graph[100007];
vector<int> topsort;
void dfs(int s) {
vis[s] = true;
for (int i = 0; i < v[s].size(); i++) {
int ve = v[s][i];
if (!vis[ve]) {
dfs(ve);
}
}
topsort.push_back(s);
}
void dfs2(int s, int cnt) {
vis[s] = true;
for (int i = 0; i < v2[s].size(); i++) {
int ve = v2[s][i];
if (!vis[ve]) {
dfs2(ve, cnt);
}
}
scc[cnt].push_back(s);
konta[s] = cnt;
}
int main() {
int n, m, h, i, j, k, l, x, y;
scanf("%d%d%d", &n, &m, &h);
for (i = 1; i <= n; i++) {
scanf("%d", &hours[i]);
}
for (i = 0; i < m; i++) {
scanf("%d%d", &x, &y);
if (hours[y] == (hours[x] + 1) % h) {
v[x].push_back(y);
v2[y].push_back(x);
}
if (hours[x] == (hours[y] + 1) % h) {
v[y].push_back(x);
v2[x].push_back(y);
}
}
for (i = 1; i <= n; i++) {
if (!vis[i]) {
dfs(i);
}
}
reverse(topsort.begin(), topsort.end());
memset(vis, false, sizeof(vis));
int cnt = 0;
for (i = 0; i < n; i++) {
int s = topsort[i];
if (!vis[s]) {
dfs2(s, cnt);
cnt++;
}
}
for (i = 1; i <= n; i++) {
for (j = 0; j < v[i].size(); j++) {
x = i;
y = v[i][j];
if (konta[x] != konta[y]) {
graph[konta[x]].push_back(konta[y]);
}
}
}
int minn = 100007;
int ke;
for (i = 0; i < cnt; i++) {
if ((int)graph[i].size() == 0) {
if ((int)scc[i].size() < minn) {
minn = (int)scc[i].size();
ke = i;
}
}
}
printf("%d\n", minn);
for (i = 0; i < scc[ke].size(); i++) {
printf("%d ", scc[ke][i]);
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
vector<int> g[N], group_elems[N];
vector<pair<int, int> > edges;
int ctr[N], u[N];
struct SCC {
int V, group_cnt;
vector<vector<int> > adj, radj;
vector<int> group_num, vis;
stack<int> stk;
SCC(int V) : V(V), group_cnt(0), group_num(V), vis(V), adj(V), radj(V) {}
void add_edge(int v1, int v2) {
edges.push_back({v1, v2});
adj[v1].push_back(v2);
radj[v2].push_back(v1);
}
void fill_forward(int x) {
vis[x] = true;
for (int i = 0; i < adj[x].size(); i++) {
if (!vis[adj[x][i]]) {
fill_forward(adj[x][i]);
}
}
stk.push(x);
}
void fill_backward(int x) {
vis[x] = false;
group_num[x] = group_cnt;
for (int i = 0; i < radj[x].size(); i++) {
if (vis[radj[x][i]]) {
fill_backward(radj[x][i]);
}
}
}
int get_scc() {
for (int i = 0; i < V; i++) {
if (!vis[i]) fill_forward(i);
}
group_cnt = 0;
while (!stk.empty()) {
if (vis[stk.top()]) {
fill_backward(stk.top());
group_cnt++;
}
stk.pop();
}
return group_cnt;
}
};
int main() {
int n, m, h;
cin >> n >> m >> h;
for (int i = 0; i < n; ++i) {
cin >> u[i];
}
SCC scc(n);
while (m--) {
int x, y;
cin >> x >> y;
--x;
--y;
if ((u[x] + 1) % h == u[y]) {
scc.add_edge(x, y);
}
if ((u[y] + 1) % h == u[x]) {
scc.add_edge(y, x);
}
}
int k = scc.get_scc();
for (auto &e : edges) {
int x = scc.group_num[e.first];
int y = scc.group_num[e.second];
if (x != y) {
g[x].push_back(y);
}
}
int best = n + 5, best_group = -1;
for (int i = 0; i < n; ++i) {
ctr[scc.group_num[i]]++;
group_elems[scc.group_num[i]].push_back(i);
}
for (int i = 0; i < k; ++i) {
if (g[i].empty() and ctr[i] < best) {
best = ctr[i];
best_group = i;
}
}
cout << best << endl;
for (auto &i : group_elems[best_group]) {
cout << i + 1 << ' ';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 100;
int n, m, h, timer, cnt;
int a[maxn], dfn[maxn], low[maxn], scc[maxn], sz[maxn];
bool vis[maxn], exist[maxn], fuck[maxn];
vector<int> g[maxn], stk;
void tarjan(int u) {
dfn[u] = low[u] = ++timer;
vis[u] = 1;
exist[u] = 1;
stk.push_back(u);
for (int v : g[u]) {
if (vis[v]) {
if (exist[v] && low[u] > dfn[v]) {
low[u] = dfn[v];
}
} else {
tarjan(v);
low[u] = min(low[u], low[v]);
}
}
if (dfn[u] == low[u]) {
++cnt;
int v;
do {
v = stk.back();
stk.pop_back();
exist[v] = 0;
scc[v] = cnt;
++sz[cnt];
} while (stk.size() && u != v);
}
return;
}
int main() {
scanf("%d%d%d", &n, &m, &h);
for (int i = 1; i <= n; ++i) {
scanf("%d", a + i);
}
while (m--) {
int u, v;
scanf("%d%d", &u, &v);
if (a[v] == (a[u] + 1) % h) {
g[u].push_back(v);
}
swap(u, v);
if (a[v] == (a[u] + 1) % h) {
g[u].push_back(v);
}
}
for (int i = 1; i <= n; ++i) {
if (!dfn[i]) {
tarjan(i);
}
}
for (int u = 1; u <= n; ++u) {
for (int v : g[u]) {
if (scc[v] != scc[u]) {
fuck[scc[u]] = 1;
}
}
}
int ans = n + 1, rem;
for (int i = 1; i <= cnt; ++i) {
if (!fuck[i] && sz[i] < ans) {
ans = sz[i];
rem = i;
}
}
printf("%d\n", ans);
for (int i = 1; i <= n; ++i) {
if (scc[i] == rem) {
printf("%d ", i);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int U[100005];
int n, m, H;
vector<int> vec[100005];
vector<int> rvec[100005];
vector<int> nd[100005];
vector<int> vs;
bool use[100005];
int cmb[100005];
bool bad[100005];
void add(int s, int e) {
vec[s].push_back(e);
rvec[e].push_back(s);
}
void dfs(int v) {
use[v] = true;
for (int i = 0; i < vec[v].size(); i++)
if (!use[vec[v][i]]) dfs(vec[v][i]);
vs.push_back(v);
}
void rdfs(int v, int k) {
use[v] = true;
cmb[v] = k;
nd[k].push_back(v);
for (int i = 0; i < rvec[v].size(); i++)
if (!use[rvec[v][i]]) rdfs(rvec[v][i], k);
}
int scc() {
memset(use, false, sizeof(use));
for (int i = 0; i < n; i++)
if (!use[i]) dfs(i);
memset(use, false, sizeof(use));
int k = 0;
for (int i = vs.size() - 1; i >= 0; i--)
if (!use[vs[i]]) rdfs(vs[i], k++);
for (int i = 0; i < n; i++) {
for (int j = 0; j < vec[i].size(); j++) {
int to = vec[i][j];
if (cmb[to] != cmb[i]) {
bad[cmb[i]] = true;
}
}
}
return k;
}
int main() {
scanf("%d %d %d", &n, &m, &H);
for (int i = 0; i < n; i++) scanf("%d", &U[i]);
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d %d", &a, &b);
a--, b--;
if ((U[a] + 1) % H == U[b]) add(a, b);
if ((U[b] + 1) % H == U[a]) add(b, a);
}
int sz = scc();
int mn = n;
for (int i = 0; i < sz; i++) {
if (!bad[i]) {
mn = min(mn, (int)nd[i].size());
}
}
for (int i = 0; i < sz; i++) {
if (!bad[i] && nd[i].size() == mn) {
printf("%d\n", mn);
for (int j = 0; j < nd[i].size(); j++) {
if (j != 0) printf(" ");
printf("%d", nd[i][j] + 1);
}
puts("");
break;
}
}
return 0;
}
|
#include <bits/stdc++.h>
std::stack<int> stk;
int n, m, h, a[200005], low[200005], dfn[200005], idx, sccno, size[200005],
in[200005], v1[200005], tl, u1[200005];
std::vector<int> ch[200005];
void tarjan(int u, int fa) {
stk.push(u);
dfn[u] = ++idx;
low[u] = idx;
for (int v : ch[u]) {
if (!dfn[v]) {
tarjan(v, u);
low[u] = std::min(low[u], low[v]);
} else if (!in[v]) {
low[u] = std::min(low[u], dfn[v]);
}
}
if (dfn[u] == low[u]) {
sccno++;
while (stk.top() != u) {
if (!in[stk.top()]) {
in[stk.top()] = sccno;
size[sccno] += 1;
}
stk.pop();
}
in[u] = sccno;
size[sccno]++;
}
}
int main() {
scanf("%d%d%d", &n, &m, &h);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (int i = 1; i <= m; ++i) {
int u, v;
scanf("%d%d", &u, &v);
if (a[u] == (a[v] + 1) % h) {
v1[++tl] = v;
u1[tl] = u;
ch[v].push_back(u);
}
if (a[v] == (a[u] + 1) % h) {
v1[++tl] = u;
u1[tl] = v;
ch[u].push_back(v);
}
}
for (int i = 1; i <= n; ++i)
if (!dfn[i]) tarjan(i, 0);
int ans = 1e9;
for (int i = 1; i <= tl; ++i)
if (in[u1[i]] != in[v1[i]]) size[in[v1[i]]] = 1e8;
for (int i = 1; i <= sccno; ++i)
if (size[i] < ans) ans = size[i];
printf("%d\n", ans);
for (int i = 1; i <= sccno; ++i) {
if (size[i] == ans) {
for (int j = 1; j <= n; ++j)
if (in[j] == i) printf("%d ", j);
return 0;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100000 + 17;
int U[MAXN];
vector<int> Adj[MAXN], Adv[MAXN];
stack<int> S;
bool instack[MAXN];
int DFN[MAXN], LOW[MAXN], sccno[MAXN], siz[MAXN], scccnt, dtim;
void Tarjan(int u) {
++dtim;
DFN[u] = LOW[u] = dtim;
instack[u] = 1;
S.push(u);
for (int v : Adj[u])
if (!DFN[v]) {
Tarjan(v);
LOW[u] = min(LOW[u], LOW[v]);
} else if (instack[u])
LOW[u] = min(LOW[u], DFN[v]);
if (DFN[u] == LOW[u]) {
int x;
++scccnt;
do {
x = S.top();
S.pop();
sccno[x] = scccnt;
++siz[scccnt];
instack[x] = 0;
} while (x != u);
}
}
int main() {
int n, m, h;
cin >> n >> m >> h;
for (int i = 1; i <= n; ++i) cin >> U[i];
for (int i = 1; i <= m; ++i) {
int a, b;
cin >> a >> b;
if ((U[a] + 1) % h == U[b]) Adj[a].push_back(b);
if ((U[b] + 1) % h == U[a]) Adj[b].push_back(a);
}
for (int i = 1; i <= n; ++i)
if (!DFN[i]) Tarjan(i);
for (int u = 1; u <= n; ++u)
for (int v : Adj[u])
if (sccno[u] != sccno[v]) Adv[sccno[u]].push_back(sccno[v]);
int res = INT_MAX, pos;
for (int i = 1; i <= scccnt; ++i)
if (Adv[i].size() == 0)
if (siz[i] < res) {
res = siz[i];
pos = i;
}
cout << res << "\n";
for (int i = 1; i <= n; ++i)
if (sccno[i] == pos) cout << i << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
const double eps = 10e-7;
const int sz = 300;
const double pi = 3.14159265359;
int n, m, h, a[100000], f, s, components[100000], k, count_of_nodes[100000],
cnt_n;
pair<int, int> color_of_res_comp;
vector<int> adj_list[100000], radj_list[100000], res, sorted_g;
bool used[100000], is_stok[100000];
void top_sort(int v) {
used[v] = true;
for (int i = 0; i < adj_list[v].size(); ++i) {
if (!used[adj_list[v][i]]) top_sort(adj_list[v][i]);
}
sorted_g.push_back(v);
}
void dfs(int v) {
used[v] = true;
++cnt_n;
components[v] = k;
for (int i = 0; i < radj_list[v].size(); ++i) {
if (!used[radj_list[v][i]]) {
dfs(radj_list[v][i]);
}
}
}
int main() {
scanf("%d%d%d", &n, &m, &h);
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
for (int i = 0; i < m; ++i) {
scanf("%d%d", &f, &s);
--f;
--s;
if ((a[f] + 1) % h == a[s]) {
radj_list[s].push_back(f);
adj_list[f].push_back(s);
}
if ((a[s] + 1) % h == a[f]) {
adj_list[s].push_back(f);
radj_list[f].push_back(s);
}
}
for (int i = 0; i < n; ++i) {
if (!used[i]) top_sort(i);
}
reverse(sorted_g.begin(), sorted_g.end());
fill(used, used + n, false);
for (int i = 0; i < n; ++i) {
if (!used[sorted_g[i]]) {
cnt_n = 0;
dfs(sorted_g[i]);
count_of_nodes[k] = cnt_n;
++k;
}
}
fill(is_stok, is_stok + k, true);
for (int i = 0; i < n; ++i) {
if (!is_stok[components[i]]) continue;
for (int j = 0; j < adj_list[i].size(); ++j) {
if (components[i] != components[adj_list[i][j]]) {
is_stok[components[i]] = false;
break;
}
}
}
color_of_res_comp.first = MOD;
for (int i = 0; i < k; ++i) {
if (is_stok[i] && count_of_nodes[i] < color_of_res_comp.first) {
color_of_res_comp.first = count_of_nodes[i];
color_of_res_comp.second = i;
}
}
for (int i = 0; i < n; ++i) {
if (components[i] == color_of_res_comp.second) res.push_back(i + 1);
}
printf("%d\n", res.size());
for (int i = 0; i < res.size(); ++i) printf("%d ", res[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 1;
const int INF = 1e9;
int n, m, h, a[N];
vector<int> adj[N];
int num[N], low[N], Time, root[N], sz[N];
stack<int> st;
void tarjan(int u) {
num[u] = low[u] = ++Time;
st.push(u);
for (int v : adj[u])
if (!num[v]) {
tarjan(v);
low[u] = min(low[u], low[v]);
} else {
low[u] = min(low[u], num[v]);
}
if (low[u] == num[u])
while (1) {
int v = st.top();
st.pop();
root[v] = u;
sz[u]++;
num[v] = low[v] = INF;
if (v == u) break;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> h;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
if ((a[u] + 1) % h == a[v]) adj[u].push_back(v);
if ((a[v] + 1) % h == a[u]) adj[v].push_back(u);
}
for (int i = 1; i <= n; i++)
if (!num[i]) tarjan(i);
for (int u = 1; u <= n; u++)
for (int v : adj[u])
if (root[v] != root[u]) num[root[u]] = 0;
int best = 0;
sz[0] = INF;
for (int i = 1; i <= n; i++)
if (root[i] == i && num[i] == INF && sz[best] > sz[i]) best = i;
assert(best > 0);
cout << sz[best] << '\n';
for (int i = 1; i <= n; i++)
if (root[i] == best) cout << i << ' ';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
int n;
vector<int> adj[maxn], bac[maxn], has[maxn];
int order[maxn], vs[maxn], comp[maxn];
int cnt, m, h, a[maxn];
map<pair<int, int>, int> mm;
vector<pair<int, int> > edge;
int ra[maxn];
void dfs1(int u) {
vs[u] = 1;
for (auto v : adj[u]) {
if (vs[v]) continue;
dfs1(v);
}
order[cnt++] = u;
}
void dfs2(int u, int c) {
comp[u] = c;
has[c].push_back(u);
for (auto v : bac[u]) {
if (~comp[v]) continue;
dfs2(v, c);
}
}
int main() {
cin >> n >> m >> h;
for (int i = (0); i < (n); i++) {
cin >> a[i];
}
for (int i = (0); i < (m); i++) {
int x, y;
cin >> x >> y;
x--;
y--;
if ((a[x] + 1) % h == a[y]) {
if (!mm.count(make_pair(x, y))) {
adj[x].push_back(y);
bac[y].push_back(x);
mm[make_pair(x, y)] = 1;
edge.push_back(make_pair(x, y));
}
}
if ((a[y] + 1) % h == a[x]) {
if (!mm.count(make_pair(y, x))) {
adj[y].push_back(x);
bac[x].push_back(y);
mm[make_pair(y, x)] = 1;
edge.push_back(make_pair(y, x));
}
}
}
for (int i = (0); i < (n); i++) {
if (!vs[i]) dfs1(i);
comp[i] = -1;
}
int c = 0;
for (int i = (n)-1; i >= 0; i--) {
int u = order[i];
if (!~comp[u]) dfs2(u, c++);
}
for (int i = (0); i < (((int)edge.size())); i++) {
int c1 = comp[edge[i].first];
int c2 = comp[edge[i].second];
if (c1 != c2) {
ra[c1] = 1;
}
}
int found = -1;
for (int i = (0); i < (c); i++) {
if (ra[i]) continue;
if (!~found || ((int)has[i].size()) < ((int)has[found].size())) {
found = i;
}
}
printf("%d\n", ((int)has[found].size()));
for (auto u : has[found]) {
printf("%d ", u + 1);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 10;
int n, m, h, cnt, idx, tot;
int mt[MAX], head[MAX], dfn[MAX], low[MAX], vis[MAX], belong[MAX], hasout[MAX];
stack<int> s;
vector<int> vec[MAX];
struct edge {
int v, nt, u;
} e[MAX * 2];
void add(int u, int v) {
e[cnt].v = v;
e[cnt].u = u;
e[cnt].nt = head[u];
head[u] = cnt;
++cnt;
}
void tarjan(int x) {
dfn[x] = low[x] = ++idx;
vis[x] = 1;
s.push(x);
for (int i = head[x]; i; i = e[i].nt) {
int v = e[i].v;
if (!dfn[v]) {
tarjan(v);
low[x] = min(low[x], low[v]);
} else if (vis[v]) {
low[x] = min(low[x], dfn[v]);
}
}
if (low[x] == dfn[x]) {
while (1) {
int now = s.top();
vis[now] = 0;
s.pop();
belong[now] = tot;
vec[tot].push_back(now);
if (x == now) break;
}
++tot;
}
}
int main() {
memset(dfn, 0, sizeof dfn);
memset(head, 0, sizeof head);
memset(vis, 0, sizeof vis);
memset(hasout, 0, sizeof hasout);
cnt = 1;
idx = 0;
tot = 0;
scanf("%d%d%d", &n, &m, &h);
for (int i = 1; i <= n; i++) {
scanf("%d", &mt[i]);
}
int u, v;
for (int i = 1; i <= m; i++) {
scanf("%d%d", &u, &v);
if (mt[v] - mt[u] == 1 || mt[u] - mt[v] == h - 1) add(u, v);
if (mt[u] - mt[v] == 1 || mt[v] - mt[u] == h - 1) add(v, u);
}
for (int i = 1; i <= n; i++) {
if (!dfn[i]) tarjan(i);
}
int ans = 0x3f3f3f3f, id = -1;
for (int i = 1; i < cnt; i++) {
if (belong[e[i].u] != belong[e[i].v]) {
hasout[belong[e[i].u]] = 1;
}
}
for (int i = 0; i < tot; i++) {
if (!hasout[belong[vec[i][0]]] && vec[i].size() < ans) {
id = i;
ans = vec[i].size();
}
}
printf("%d\n", ans);
for (int a : vec[id]) {
printf("%d ", a);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, h, tim[100010], x, y, mark, scc[100010], idd[100010], id;
vector<int> tab[100010], bat[100010];
bool met[100010], out[100010];
vector<int> vec;
void dfs(int w) {
met[w] = 1;
for (int v : bat[w]) {
if (!met[v]) dfs(v);
}
vec.push_back(w);
}
void dfs2(int w) {
met[w] = 1;
scc[mark]++;
idd[w] = mark;
for (int v : tab[w]) {
if (met[v]) {
if (idd[v] != mark) out[mark] = 1;
} else
dfs2(v);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> h;
for (int a = 1; a <= n; a++) {
cin >> tim[a];
}
for (int a = 1; a <= m; a++) {
cin >> x >> y;
if ((tim[x] + 1) % h == tim[y]) {
tab[x].push_back(y);
bat[y].push_back(x);
}
swap(x, y);
if ((tim[x] + 1) % h == tim[y]) {
tab[x].push_back(y);
bat[y].push_back(x);
}
}
for (int a = 1; a <= n; a++) {
if (!met[a]) dfs(a);
}
for (int a = 1; a <= n; a++) met[a] = 0;
reverse(vec.begin(), vec.end());
for (int v : vec) {
if (!met[v]) {
++mark;
dfs2(v);
}
}
int ans = 1e9;
for (int a = 1; a <= mark; a++) {
if (out[a] == 0) {
if (scc[a] < ans) {
ans = scc[a];
id = a;
}
}
}
cout << ans << endl;
for (int a = 1; a <= n; a++) {
if (idd[a] == id) cout << a << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
int head[100010], to[100010 << 1], next[100010 << 1], tot = 0;
inline void $(int u, int v) {
next[tot] = head[u], to[tot] = v, head[u] = tot++;
}
int n, m, mod, a[100010];
int dfn[100010], low[100010], stk[100010], ins[100010], bel[100010],
top = 0, dtk = 0, scc = 0, size[100010], count[100010];
int ans = 0x3F3F3F3F, fuck;
void Tarjin(int x) {
dfn[x] = low[x] = ++dtk;
ins[stk[++top] = x] = 1;
for (int i = head[x]; ~i; i = next[i]) {
if (dfn[to[i]]) {
if (ins[to[i]]) low[x] = std::min(low[x], dfn[to[i]]);
} else {
Tarjin(to[i]);
low[x] = std::min(low[x], low[to[i]]);
}
}
if (dfn[x] == low[x]) {
scc++;
do {
ins[stk[top]] = 0;
bel[stk[top]] = scc;
size[scc]++;
} while (stk[top--] != x);
}
}
int main() {
memset(head, -1, sizeof(head));
scanf("%d%d%d", &n, &m, &mod);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), a[i] %= mod;
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
if ((a[u] + 1) % mod == a[v]) $(u, v);
if ((a[v] + 1) % mod == a[u]) $(v, u);
}
for (int i = 1; i <= n; i++)
if (!dfn[i]) Tarjin(i);
for (int x = 1; x <= n; x++) {
for (int i = head[x]; ~i; i = next[i]) {
if (bel[to[i]] != bel[x]) count[bel[x]]++;
}
}
for (int i = 1; i <= scc; i++) {
if (!count[i] && size[i] < ans) {
ans = size[i];
fuck = i;
}
}
printf("%d\n", ans);
for (int i = 1; i <= n; i++)
if (bel[i] == fuck) printf("%d ", i);
puts("");
return 0;
}
|
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
namespace Xrocks {}
using namespace Xrocks;
namespace Xrocks {
class in {
} user_input;
class out {
} output;
in& operator>>(in& X, int& Y) {
scanf("%d", &Y);
return X;
}
in& operator>>(in& X, char* Y) {
scanf("%s", Y);
return X;
}
in& operator>>(in& X, float& Y) {
scanf("%f", &Y);
return X;
}
in& operator>>(in& X, double& Y) {
scanf("%lf", &Y);
return X;
}
in& operator>>(in& X, char& C) {
scanf("%c", &C);
return X;
}
in& operator>>(in& X, string& Y) {
cin >> Y;
return X;
}
in& operator>>(in& X, long long& Y) {
scanf("%lld", &Y);
return X;
}
template <typename T>
in& operator>>(in& X, vector<T>& Y) {
for (auto& x : Y) user_input >> x;
return X;
}
template <typename T>
out& operator>>(out& X, vector<T>& Y) {
for (auto& x : Y) output << x;
return X;
}
out& operator<<(out& X, const int& Y) {
printf("%d", Y);
return X;
}
out& operator<<(out& X, const char& C) {
printf("%c", C);
return X;
}
out& operator<<(out& X, string& Y) {
printf("%s", Y.c_str());
return X;
}
out& operator<<(out& X, const long long& Y) {
printf("%lld", Y);
return X;
}
out& operator<<(out& X, const float& Y) {
printf("%f", Y);
return X;
}
out& operator<<(out& X, const double& Y) {
printf("%lf", Y);
return X;
}
out& operator<<(out& X, const char Y[]) {
printf("%s", Y);
return X;
}
template <typename T>
T max(T A) {
return A;
}
template <typename T, typename... args>
T max(T A, T B, args... S) {
return max(A > B ? A : B, S...);
}
template <typename T>
T min(T A) {
return A;
}
template <typename T, typename... args>
T min(T A, T B, args... S) {
return min(A < B ? A : B, S...);
}
long long fast(long long a, long long b, long long pr) {
if (b == 0) return 1 % pr;
long long ans = 1 % pr;
while (b) {
if (b & 1) ans = (ans * a) % pr;
b >>= 1;
a = (a * a) % pr;
}
return ans;
}
int readInt() {
int n = 0;
scanf("%d", &n);
return n;
int ch = getchar_unlocked();
int sign = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') sign = -1;
ch = getchar_unlocked();
}
while (ch >= '0' && ch <= '9')
n = (n << 3) + (n << 1) + ch - '0', ch = getchar_unlocked();
n = n * sign;
return n;
}
long long readLong() {
long long n = 0;
int ch = getchar_unlocked();
int sign = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') sign = -1;
ch = getchar_unlocked();
}
while (ch >= '0' && ch <= '9')
n = (n << 3) + (n << 1) + ch - '0', ch = getchar_unlocked();
n = n * sign;
return n;
}
long long inv_(long long val, long long pr = static_cast<long long>(1e9 + 7)) {
return fast(val, pr - 2, pr);
}
} // namespace Xrocks
class solve {
vector<vector<int>> Iadj, Oadj;
vector<int> u;
int n, m, h;
vector<vector<int>> A;
public:
solve() {
user_input >> n >> m >> h;
A.resize(n + 2);
u.resize(n);
Iadj.resize(n);
Oadj.resize(n);
user_input >> u;
for (int i = 0; i < m; i++) {
int x, y;
user_input >> x >> y;
--x, --y;
if ((u[x] + 1) % h == u[y]) {
Iadj[x].push_back(y);
Oadj[y].push_back(x);
}
if ((u[y] + 1) % h == u[x]) {
Iadj[y].push_back(x);
Oadj[x].push_back(y);
}
}
for (int i = 0; i < n; i++) {
if (Iadj[i].size() == 0) {
output << 1 << "\n" << i + 1;
return;
}
}
int k = scc();
vector<int> idx(n + 2);
for (auto& x : idx) x = &x - &idx[0];
sort(idx.begin(), idx.end(),
[&](const int& a, const int& b) { return A[a].size() < A[b].size(); });
for (int i = 0; i < A.size(); i++) {
if (A[idx[i]].size()) {
int take = true;
for (auto& x : A[idx[i]]) {
for (auto& y : Iadj[x]) {
if (vis[x] != vis[y]) {
take = false;
break;
}
}
if (!take) break;
}
if (take) {
output << static_cast<int>(A[idx[i]].size()) << "\n";
for (auto& x : A[idx[i]]) {
output << x + 1 << " ";
}
return;
}
}
}
}
void dfs1(vector<vector<int>>& g, vector<int>& vis, stack<int>& s, int c) {
vis[c] = 1;
for (auto i : g[c])
if (!vis[i]) dfs1(g, vis, s, i);
s.push(c);
}
int dfs2(vector<vector<int>>& g, vector<int>& vis, int c, int t) {
vis[c] = t;
int sz2 = 1;
A[t].push_back(c);
for (auto i : g[c])
if (vis[i] == 1) sz2 += dfs2(g, vis, i, t);
return sz2;
}
vector<int> vis;
int scc() {
int ans = n;
stack<int> s;
vis.resize(n, 0);
for (int i = 0; i < n; i++)
if (!vis[i]) dfs1(Iadj, vis, s, i);
int t = 1;
while (!s.empty()) {
int z = s.top();
s.pop();
if (vis[z] == 1) {
t++;
ans = min(ans, dfs2(Oadj, vis, z, t));
}
}
return ans;
}
};
int32_t main() {
int t = 1, i = 1;
if (0) scanf("%d", &t);
while (t--) {
if (0) printf("Case #%d: ", i++);
new solve;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const long long MAXN = 1e6 + 5;
const long long INF = 1e6 + 5;
const double PI = 3.14159265359;
bool u[MAXN], Del[MAXN];
int n, m, cnt, mn = INF, h, col[MAXN], a[MAXN];
vector<int> tp;
vector<vector<int> > g(MAXN), gr(MAXN), comp(MAXN);
void dfs(int v) {
u[v] = true;
for (auto to : g[v])
if (!u[to]) dfs(to);
tp.push_back(v);
}
void dfs2(int v) {
col[v] = cnt;
comp[cnt].push_back(v);
for (auto to : gr[v]) {
if (col[to] != cnt) {
Del[col[to]] = true;
}
if (!col[to]) dfs2(to);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m >> h;
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 1; i <= m; ++i) {
int u, v;
cin >> u >> v;
if ((a[u] - a[v] + h) % h == 1) g[v].push_back(u), gr[u].push_back(v);
if ((a[v] - a[u] + h) % h == 1) g[u].push_back(v), gr[v].push_back(u);
}
for (int i = 1; i <= n; ++i)
if (!u[i]) dfs(i);
for (int i = 1; i <= n; ++i) {
if (!col[tp[n - i]]) {
++cnt;
dfs2(tp[n - i]);
}
}
for (int i = 1; i <= cnt; ++i)
if (!Del[i]) mn = min(mn, (int)comp[i].size());
cout << mn << "\n";
for (int i = 1; i <= cnt; ++i) {
if (comp[i].size() == mn && !Del[i]) {
for (auto it : comp[i]) {
cout << it << " ";
}
return 0;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
int n, m, h, tot, dft, scc, ans;
int t[maxn], dfn[maxn], low[maxn], flag[maxn], cnt[maxn], d[maxn];
int fst[maxn << 1], nxt[maxn << 1], des[maxn << 1];
stack<int> stk;
void add(int x, int y) {
tot++;
des[tot] = y;
nxt[tot] = fst[x];
fst[x] = tot;
}
void tarjan(int node) {
dfn[node] = low[node] = ++dft;
stk.push(node);
for (int t = fst[node]; t; t = nxt[t]) {
int v = des[t];
if (!dfn[v]) tarjan(v);
low[node] = min(low[node], low[v]);
}
if (dfn[node] == low[node]) {
scc++;
while (true) {
int temp = stk.top();
stk.pop();
flag[temp] = scc;
cnt[scc]++;
if (temp == node) break;
}
}
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> m >> h;
for (int i = 1; i <= n; i++) cin >> t[i];
for (int i = 0; i < m; i++) {
int u1, u2;
cin >> u1 >> u2;
if (t[u1] == (t[u2] + 1) % h) add(u2, u1);
if (t[u2] == (t[u1] + 1) % h) add(u1, u2);
}
for (int i = 1; i <= n; i++)
if (!dfn[i]) tarjan(i);
for (int i = 1; i <= n; i++) {
for (int t = fst[i]; t; t = nxt[t]) {
if (flag[i] == flag[des[t]]) continue;
d[flag[i]]++;
}
}
cnt[0] = n + 1;
for (int i = 1; i <= scc; i++)
if (d[i] == 0 && cnt[i] < cnt[ans]) ans = i;
cout << cnt[ans] << endl;
for (int i = 1; i <= n; i++)
if (flag[i] == ans) cout << i << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 5;
int h, n, m, cnt, out[MAXN], ans, a[MAXN];
bool vis[MAXN];
struct Edge {
int nxt, from, ver;
} e[MAXN * 2];
int head[MAXN], tot;
void add(int u, int v) {
e[++tot].from = u;
e[tot].ver = v;
e[tot].nxt = head[u];
head[u] = tot;
}
stack<int> s;
int dfn[MAXN], low[MAXN], sc[MAXN], sn, sz[MAXN];
void tarjan(int u) {
low[u] = dfn[u] = ++cnt;
vis[u] = 1;
s.push(u);
int i;
for (i = head[u]; i; i = e[i].nxt) {
int v = e[i].ver;
if (!dfn[v]) {
tarjan(v);
low[u] = min(low[u], low[v]);
} else if (vis[v])
low[u] = min(low[u], dfn[v]);
}
if (low[u] == dfn[u]) {
int tp;
sn++;
while (1) {
tp = s.top();
s.pop();
sc[tp] = sn;
vis[tp] = 0;
sz[sn]++;
if (tp == u) return;
}
}
}
int main() {
int i;
scanf("%d %d %d", &n, &m, &h);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
for (i = 1; i <= m; i++) {
int u, v;
scanf("%d %d", &u, &v);
if ((a[u] + 1) % h == a[v]) add(u, v);
if ((a[v] + 1) % h == a[u]) add(v, u);
}
for (i = 1; i <= n; i++)
if (!dfn[i]) tarjan(i);
for (i = 1; i <= tot; i++) {
int u = sc[e[i].from], v = sc[e[i].ver];
if (u != v) out[u]++;
}
sz[0] = 0x3f3f3f3f;
for (i = 1; i <= sn; i++)
if (!out[i]) {
if (sz[i] < sz[ans]) ans = i;
}
printf("%d\n", sz[ans]);
for (i = 1; i <= n; i++)
if (sc[i] == ans) printf("%d ", i);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
const long double EPS = 1e-7;
vector<set<long long> > g, rg, new_g;
vector<long long> u, comp;
vector<vector<long long> > ver_in_comp;
long long n, m, h, cc = 0;
long long nxt(long long t) {
if (t == h - 1) {
return 0;
}
return t + 1;
}
void add_edge(long long a, long long b) {
if (nxt(u[a]) == u[b]) {
g[a].insert(b);
rg[b].insert(a);
}
}
void dfs_order(long long v, vector<bool>& used, vector<long long>& order) {
used[v] = true;
for (long long to : g[v]) {
if (!used[to]) {
dfs_order(to, used, order);
}
}
order.push_back(v);
}
void dfs_comp(long long v) {
comp[v] = cc;
for (long long to : rg[v]) {
if (comp[to] == -1) {
dfs_comp(to);
}
}
}
void set_comp() {
comp.resize(n, -1);
vector<long long> order;
vector<bool> used(n, false);
for (long long i = 0; i < n; ++i) {
if (!used[i]) {
dfs_order(i, used, order);
}
}
for (long long i = n - 1; i >= 0; --i) {
if (comp[order[i]] == -1) {
dfs_comp(order[i]);
++cc;
}
}
}
void set_new_g() {
new_g.resize(cc);
for (long long i = 0; i < n; ++i) {
for (long long to : g[i]) {
if (comp[i] != comp[to]) {
new_g[comp[i]].insert(comp[to]);
}
}
}
}
void set_ver_in_comp() {
ver_in_comp.resize((signed)new_g.size());
for (long long i = 0; i < n; ++i) {
ver_in_comp[comp[i]].push_back(i);
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> h;
g.resize(n);
rg.resize(n);
u.resize(n);
for (long long& it : u) {
cin >> it;
}
for (long long i = 0; i < m; ++i) {
long long a, b;
cin >> a >> b;
--a;
--b;
add_edge(a, b);
add_edge(b, a);
}
set_comp();
set_new_g();
set_ver_in_comp();
long long p_ans = -1;
for (long long i = 0; i < (signed)new_g.size(); ++i) {
if (new_g[i].empty()) {
if (p_ans == -1 ||
(signed)ver_in_comp[i].size() < (signed)ver_in_comp[p_ans].size()) {
p_ans = i;
}
}
}
cout << (signed)ver_in_comp[p_ans].size() << endl;
for (long long it : ver_in_comp[p_ans]) {
cout << it + 1 << " ";
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int u[100005];
vector<int> g[100005], gf[100005];
bool vis[100005];
stack<int> s;
int scc[100005];
int idx = 1;
vector<int> res;
void dfs1(int u) {
vis[u] = 1;
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (vis[v]) continue;
dfs1(v);
}
s.push(u);
}
void dfs2(int u) {
vis[u] = 1;
for (int i = 0; i < gf[u].size(); i++) {
int v = gf[u][i];
if (vis[v]) continue;
dfs2(v);
}
scc[u] = idx;
res.push_back(u);
}
int main() {
int n, m, h;
scanf("%d%d%d", &n, &m, &h);
for (int i = 1; i <= n; i++) scanf("%d", &u[i]);
for (int i = 0; i < m; i++) {
int c1, c2;
scanf("%d%d", &c1, &c2);
if ((u[c1] + 1) % h == u[c2]) g[c1].push_back(c2), gf[c2].push_back(c1);
if ((u[c2] + 1) % h == u[c1]) g[c2].push_back(c1), gf[c1].push_back(c2);
}
for (int i = 1; i <= n; i++) {
if (g[i].size() == 0) return !printf("1\n%d\n", i);
}
for (int i = 1; i <= n; i++) {
if (vis[i]) continue;
dfs1(i);
}
memset(vis, 0, sizeof(vis));
int mn = 1e9, mi = 0;
while (!s.empty()) {
int u = s.top();
s.pop();
if (vis[u]) continue;
res.clear();
dfs2(u);
bool ok = 1;
for (int i = 0; i < res.size(); i++) {
int u = res[i];
for (int j = 0; j < g[u].size(); j++) {
int v = g[u][j];
if (scc[v] != scc[u]) {
ok = 0;
break;
}
}
}
if (ok)
if (mn > res.size()) mn = res.size(), mi = idx;
idx++;
}
printf("%d\n", mn);
for (int i = 1; i <= n; i++) {
if (scc[i] == mi) printf("%d ", i);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
int n, m, h;
int u[MAXN];
int c[2][MAXN];
vector<int> g[MAXN];
vector<int> scc[MAXN];
int scctot;
int stk[MAXN], tp;
int dfn[MAXN], low[MAXN], tot;
bool son[MAXN], mark[MAXN];
void Tarjan(int x) {
dfn[x] = low[x] = ++tot;
stk[tp++] = x;
for (int i = 0, iend = g[x].size(); i < iend; ++i) {
int t = g[x][i];
if (dfn[t])
low[x] = min(low[x], dfn[t]);
else
Tarjan(t), low[x] = min(low[x], low[t]);
if (mark[t]) son[x] = true;
}
if (dfn[x] == low[x]) {
scctot++;
vector<int> &S = scc[scctot];
while (true) {
int now = stk[--tp];
mark[now] = true;
S.push_back(now);
if (now == x) break;
}
}
}
int main() {
scanf("%d %d %d", &n, &m, &h);
for (int i = 1, iend = n; i <= iend; ++i) scanf("%d", &u[i]);
for (int i = 1, iend = m; i <= iend; ++i) {
scanf("%d %d", &c[0][i], &c[1][i]);
int x = c[0][i], y = c[1][i];
if ((u[x] + 1) % h == u[y]) g[x].push_back(y);
if ((u[y] + 1) % h == u[x]) g[y].push_back(x);
}
for (int i = 1, iend = n; i <= iend; ++i)
if (!dfn[i]) Tarjan(i);
int misz = n + 1, id = -1;
for (int i = 1, iend = scctot; i <= iend; ++i) {
bool chk = true;
for (int j = 0, jend = scc[i].size(); j < jend; ++j)
if (son[scc[i][j]]) chk = false;
if (chk && (int)scc[i].size() < misz) misz = scc[i].size(), id = i;
}
cout << scc[id].size() << endl;
for (int i = 0, iend = scc[id].size(); i < iend; ++i)
printf("%d ", scc[id][i]);
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = (int)5e5 + 228;
const char nxtl = '\n';
const int mod = (int)1e9 + 7;
const double eps = (double)1e-7;
template <typename T>
inline bool updmin(T &a, const T &b) {
return a > b ? a = b, 1 : 0;
}
template <typename T>
inline bool updmax(T &a, const T &b) {
return a < b ? a = b, 1 : 0;
}
int n, m, u[MAXN], h, been[MAXN], timer;
vector<int> g[MAXN], gr[MAXN], ts;
void dfs(int v) {
been[v] = timer;
for (auto &to : g[v]) {
if (been[to] != timer) dfs(to);
}
ts.push_back(v);
}
int all[MAXN], comp[MAXN], sz;
void dfs2(int v) {
been[v] = timer;
comp[v] = sz;
all[sz]++;
for (auto &to : gr[v]) {
if (been[to] != timer) dfs2(to);
}
}
set<int> ng[MAXN];
int dp[MAXN];
int calc(int v) {
if (~dp[v]) return dp[v];
dp[v] = all[v];
for (auto &to : ng[v]) {
dp[v] += calc(to);
}
return dp[v];
}
bool take[MAXN];
void go(int v) {
take[v] = 1;
for (auto &to : ng[v]) go(to);
}
bool lst[MAXN];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m >> h;
for (int i = 1; i <= n; ++i) cin >> u[i];
for (int i = 1; i <= m; ++i) {
int x, y;
cin >> x >> y;
if ((u[x] + 1) % h == u[y]) {
g[x].push_back(y);
gr[y].push_back(x);
}
if ((u[y] + 1) % h == u[x]) {
g[y].push_back(x);
gr[x].push_back(y);
}
}
timer = 1;
for (int i = 1; i <= n; ++i)
if (been[i] != timer) dfs(i);
reverse(ts.begin(), ts.end());
timer++;
for (int i = 1; i <= n; ++i)
if (been[ts[i - 1]] != timer) {
sz++;
dfs2(ts[i - 1]);
}
for (int i = 1; i <= n; ++i) {
for (auto &to : g[i]) {
if (comp[i] != comp[to]) {
ng[comp[i]].insert(comp[to]);
lst[comp[i]] = 1;
}
}
}
memset(dp, 255, sizeof dp);
int mn = INT_MAX, id = 1;
for (int i = 1; i <= sz; ++i) {
if (!lst[i] && updmin(mn, all[i])) id = i;
}
go(id);
assert(mn < INT_MAX && mn > 0);
cout << mn << nxtl;
for (int i = 1; i <= n; ++i)
if (take[comp[i]]) cout << i << ' ';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
struct dabt {
int next, to;
} e[N << 1];
int n, m, h, head[N], k, a[N], dfn[N], cnt, lw[N], col[N], stk[N], top, sz[N],
tim, chu[N], minn = 2e9, pos;
inline void add(int from, int to) {
e[++k] = (dabt){head[from], to};
head[from] = k;
}
template <typename I>
inline void read(I &ot) {
I ch = getchar(), x = 0, f = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
ot = x * f;
}
template <typename I, typename... U>
inline void read(I &x, U &...y) {
read(x);
read(y...);
}
template <typename I>
inline I mi(const I &a, const I &b) {
return a < b ? a : b;
}
void tarjan(int st) {
dfn[st] = lw[st] = ++tim;
stk[++top] = st;
for (register int i = head[st]; i; i = e[i].next) {
int v = e[i].to;
if (!dfn[v]) {
tarjan(v);
lw[st] = mi(lw[st], lw[v]);
}
if (!col[v]) lw[st] = mi(lw[st], dfn[v]);
}
if (dfn[st] == lw[st]) {
cnt++;
while (stk[top + 1] != st) sz[col[stk[top--]] = cnt]++;
}
}
int main() {
read(n, m, h);
for (register int i = 1; i <= n; i++) read(a[i]);
for (int i = 1, x, y; i <= m; i++) {
read(x, y);
if ((a[x] + 1) % h == a[y]) add(x, y);
if ((a[y] + 1) % h == a[x]) add(y, x);
}
for (register int i = 1; i <= n; i++)
if (!dfn[i]) tarjan(i);
for (register int i = 1; i <= n; i++)
for (register int j = head[i]; j; j = e[j].next)
if (col[e[j].to] != col[i]) chu[col[i]]++;
for (register int i = 1; i <= cnt; i++)
if (!chu[i] && sz[i] < minn) minn = sz[i], pos = i;
printf("%d\n", minn);
for (register int i = 1; i <= n; i++)
if (col[i] == pos) printf("%d ", i);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
struct node {
int v, nxt;
} a[N << 1];
int head[N], cnt = 0;
inline void add(int u, int v) {
a[++cnt].v = v;
a[cnt].nxt = head[u];
head[u] = cnt;
}
int t[N];
int dfn[N], low[N], col[N], tot = 0, dep = 0, s[N], top = 0;
int size[N];
void tarjan(int u) {
low[u] = dfn[u] = ++dep;
s[++top] = u;
for (int i = head[u]; i; i = a[i].nxt) {
int v = a[i].v;
if (!dfn[v])
tarjan(v), low[u] = min(low[u], low[v]);
else if (!col[v])
low[u] = min(low[u], dfn[v]);
}
if (low[u] == dfn[u])
for (tot++; s[top + 1] ^ u; top--) col[s[top]] = tot, size[tot]++;
}
int in[N], out[N];
int main() {
int n, m, h;
cin >> n >> m >> h;
for (int i = 1; i <= n; i++) scanf("%d", &t[i]);
for (int i = 1, u, v; i <= m; i++) {
scanf("%d%d", &u, &v);
if ((t[u] + 1) % h == t[v]) add(u, v);
if ((t[v] + 1) % h == t[u]) add(v, u);
}
for (int i = 1; i <= n; i++)
if (!dfn[i]) tarjan(i);
for (int u = 1; u <= n; u++)
for (int i = head[u]; i; i = a[i].nxt) {
int v = a[i].v;
if (col[v] ^ col[u]) in[col[v]]++, out[col[u]]++;
}
int ans = 1e9, res;
for (int i = 1; i <= tot; i++)
if (size[i] < ans && !out[i]) res = i, ans = size[i];
cout << ans << endl;
for (int i = 1; i <= n; i++)
if (col[i] == res) printf("%d ", i);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
vector<int> G[N];
vector<int> R[N];
int color[N];
int dfs_hit[N] = {};
vector<int> order;
vector<int> checkme;
set<int> all_ccs;
void dfs(int v, int lab) {
dfs_hit[v] = lab;
for (int u : G[v]) {
if (dfs_hit[u] == 0) {
dfs(u, lab);
}
}
order.push_back(v);
}
int id[N] = {};
map<int, int> id_count;
void dfs2(int v, int lab) {
all_ccs.insert(lab);
id[v] = lab;
++id_count[lab];
for (int u : R[v]) {
if (id[u] != 0) continue;
dfs2(u, lab);
}
}
int main() {
int n, m, h;
cin >> n >> m >> h;
for (int i = 1; i <= n; ++i) cin >> color[i];
for (int i = 0; i < m; ++i) {
int u, v;
cin >> u >> v;
if (color[v] == ((color[u] + 1) % h)) {
G[u].push_back(v);
}
if (color[u] == (color[v] + 1) % h) G[v].push_back(u);
}
for (int v = 1; v <= n; ++v) {
for (auto u : G[v]) {
R[u].push_back(v);
}
}
for (int i = 1; i <= n; ++i) {
if (dfs_hit[i]) continue;
dfs(i, i);
}
for (int i = order.size() - 1; i >= 0; --i) {
if (id[order[i]] == 0) dfs2(order[i], i + 1);
}
for (int v = 1; v <= n; ++v) {
for (int u : G[v]) {
if (id[v] != id[u]) all_ccs.erase(id[v]);
}
}
int mn = *all_ccs.begin();
for (int cc : all_ccs) {
if (id_count[mn] > id_count[cc]) mn = cc;
}
cout << id_count[mn] << "\n";
for (int i = 1; i <= n; ++i)
if (id[i] == mn) cout << i << " ";
cout << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = (int)1e5 + 11;
int n, m, h;
int cost[N], c[N][3];
vector<int> q_in[N], q_out[N], g_in[N], g_out[N], order;
int color[N], cnt_comp, cnt[N];
bool used[N];
void dfs1(int v) {
used[v] = 1;
for (int i = 0; i < g_out[v].size(); i++) {
int to = g_out[v][i];
if (!used[to]) dfs1(to);
}
order.push_back(v);
}
void dfs2(int v) {
color[v] = cnt_comp;
used[v] = 1;
cnt[cnt_comp]++;
for (int i = 0; i < g_in[v].size(); i++) {
int to = g_in[v][i];
if (!used[to]) dfs2(to);
}
}
void dfs_color(int v) {
used[v] = 1;
for (int i = 0; i < g_out[v].size(); i++) {
int to = g_out[v][i];
if (color[v] != color[to])
q_out[color[v]].push_back(color[to]), q_in[color[to]].push_back(color[v]);
if (!used[to]) {
dfs_color(to);
}
}
}
int main() {
;
ios_base::sync_with_stdio(0);
cin.tie();
cout.tie();
;
cin >> n >> m >> h;
for (int i = 1; i <= n; i++) cin >> cost[i];
for (int i = 1; i <= m; i++) cin >> c[i][1] >> c[i][2];
for (int i = 1; i <= m; i++) {
int x = c[i][1], y = c[i][2];
if ((cost[x] + 1) % h == cost[y])
g_out[x].push_back(y), g_in[y].push_back(x);
if ((cost[y] + 1) % h == cost[x])
g_out[y].push_back(x), g_in[x].push_back(y);
}
for (int i = 1; i <= n; i++)
if (!used[i]) dfs1(i);
memset(used, 0, sizeof(used));
for (int i = 0; i < n; i++) {
int v = order[n - 1 - i];
if (!used[v]) {
cnt_comp++;
dfs2(v);
}
}
memset(used, 0, sizeof(used));
for (int i = 1; i <= n; i++)
if (!used[i]) dfs_color(i);
int ans = (int)1e9;
int color_v = 0;
for (int i = 1; i <= cnt_comp; i++)
if (q_out[i].size() == 0)
if (cnt[i] < ans) {
ans = cnt[i];
color_v = i;
}
cout << (ans == (int)1e9 ? 0 : ans) << "\n";
for (int i = 1; i <= n; i++)
if (color_v == color[i]) cout << i << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
stack<int> s;
vector<int> e[100005], sct[100005];
int dfn[100005], low[100005], tim, bel[100005], scc;
bool vis[100005];
void tarjan(int u) {
dfn[u] = low[u] = ++tim;
vis[u] = 1;
s.push(u);
for (int v, i = 0; i < e[u].size(); ++i)
if (!dfn[v = e[u][i]]) {
tarjan(v);
low[u] = min(low[v], low[u]);
} else if (vis[v])
low[u] = min(dfn[v], low[u]);
if (dfn[u] == low[u]) {
++scc;
do {
u = s.top();
s.pop();
vis[u] = 0;
bel[u] = scc;
sct[scc].push_back(u);
} while (dfn[u] != low[u]);
}
}
int n, deg[100005];
inline void shrink_point() {
for (int i = 1; i <= n; ++i)
for (int j = 0; j < e[i].size(); ++j)
if (bel[i] != bel[e[i][j]]) ++deg[bel[i]];
}
int m, h, t[100005], ans, siz = 100005;
int main() {
scanf("%d %d %d", &n, &m, &h);
for (int i = 1; i <= n; ++i) scanf("%d", &t[i]);
for (int u, v, i = 1; i <= m; ++i) {
scanf("%d %d", &u, &v);
if ((t[u] + 1) % h == t[v]) e[u].push_back(v);
if ((t[v] + 1) % h == t[u]) e[v].push_back(u);
}
for (int i = 1; i <= n; ++i)
if (!dfn[i]) tarjan(i);
shrink_point();
for (int i = 1; i <= scc; ++i)
if (deg[i] == 0 && sct[i].size() < siz) {
ans = i;
siz = sct[i].size();
}
printf("%d\n", sct[ans].size());
sort(sct[ans].begin(), sct[ans].end());
for (int i = 0; i < sct[ans].size(); ++i) printf("%d ", sct[ans][i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int counter, sccCounter;
vector<bool> visited, inStack;
vector<vector<int>> adjlist;
vector<int> d, low, sccs;
stack<int> s;
void visit(int v) {
visited[v] = true;
d[v] = low[v] = counter++;
s.push(v);
inStack[v] = true;
for (auto u : adjlist[v]) {
if (!visited[u]) {
visit(u);
low[v] = min(low[v], low[u]);
} else if (inStack[u]) {
low[v] = min(low[v], low[u]);
}
}
if (d[v] == low[v]) {
int u;
do {
u = s.top();
s.pop();
inStack[u] = false;
sccs[u] = sccCounter;
} while (u != v);
sccCounter++;
}
}
void scc() {
visited.assign(adjlist.size(), false);
d.assign(adjlist.size(), -1);
low.assign(adjlist.size(), -1);
inStack.assign(adjlist.size(), false);
sccs.resize(adjlist.size(), -1);
counter = sccCounter = 0;
for (int i = 0; i < (int)adjlist.size(); i++) {
if (!visited[i]) {
visit(i);
}
}
}
int u[100007];
bool sccNotOkay[100007];
int sccSize[100007];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n, m, h;
cin >> n >> m >> h;
adjlist.resize(n);
for (int i = 0; i < n; i++) cin >> u[i];
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
--a;
--b;
if ((u[a] + 1) % h == u[b]) adjlist[a].push_back(b);
if ((u[b] + 1) % h == u[a]) adjlist[b].push_back(a);
}
scc();
for (int i = 0; i < n; i++) {
++sccSize[sccs[i]];
for (const auto &next : adjlist[i]) {
if (sccs[i] != sccs[next]) sccNotOkay[sccs[i]] = true;
}
}
int res = 10000000;
int minScc = -1;
for (int i = 0; i < sccCounter; i++) {
if (sccNotOkay[i]) continue;
if (sccSize[i] < res) {
res = sccSize[i];
minScc = i;
}
}
cout << res << endl;
for (int i = 0; i < n; i++) {
if (sccs[i] == minScc) {
cout << (i + 1) << " ";
}
}
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int low[100010], depth[100010], timer, cyc, mp[100010];
vector<int> a[100010], scc[100010];
stack<int> stck;
bool vis[100010], sccs[100010], in[100010];
void dfs(int x) {
low[x] = depth[x] = timer++;
stck.push(x);
vis[x] = 1;
in[x] = 1;
int nxt;
for (int i = 0; i < a[x].size(); ++i) {
nxt = a[x][i];
if (!vis[nxt]) {
dfs(nxt);
low[x] = min(low[x], low[nxt]);
} else {
if (in[nxt]) {
low[x] = min(low[x], depth[nxt]);
}
}
}
if (low[x] >= depth[x]) {
while (1) {
nxt = stck.top();
scc[cyc].push_back(nxt);
mp[nxt] = cyc;
stck.pop();
in[nxt] = 0;
if (nxt == x) break;
}
++cyc;
}
}
int hh[100010];
int main() {
int n, m, x, y, nxt, ans, h;
while (cin >> n >> m >> h) {
for (int i = 1; i <= n; ++i) {
a[i].clear();
scc[i - 1].clear();
}
for (int i = 1; i <= n; ++i) {
scanf("%d", hh + i);
}
for (int i = 0; i < m; ++i) {
scanf("%d %d", &x, &y);
if ((hh[y] + 1) % h == hh[x]) {
a[y].push_back(x);
}
if ((hh[x] + 1) % h == hh[y]) {
a[x].push_back(y);
}
}
memset(vis, 0, sizeof vis);
memset(sccs, 0, sizeof sccs);
timer = 0;
cyc = 0;
for (int i = 1; i <= n; ++i) {
if (!vis[i]) dfs(i);
}
int mn = n, ans = 0;
for (int i = 0; i < cyc; ++i) {
bool l = 1;
for (int j = 0; j < scc[i].size(); ++j) {
for (int k = 0; k < a[scc[i][j]].size(); ++k) {
if (mp[a[scc[i][j]][k]] != i) {
l = 0;
}
}
}
if (l) {
if (scc[i].size() < mn) {
mn = scc[i].size();
ans = i;
}
}
}
cout << mn << endl;
for (int i = 0; i < scc[ans].size(); ++i) {
cout << scc[ans][i] << " ";
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100044;
const int INF = 1e9 + 44;
struct data {
int to, next;
} tu[N * 2];
struct sav {
int a, b;
} edgsav[N * 2];
int head[N];
int ip;
int dfn[N], low[N];
int sccno[N];
int step;
int scc_cnt;
int n, m, h, u[N];
int ind[N], outd[N];
int edgnum;
void init() {
ip = 0;
edgnum = 0;
memset(head, -1, sizeof(head));
memset(ind, 0, sizeof(ind));
memset(outd, 0, sizeof(outd));
}
void add(int u, int v) {
edgnum++, edgsav[edgnum].a = u, edgsav[edgnum].b = v;
tu[ip].to = v, tu[ip].next = head[u], head[u] = ip++;
}
vector<int> scc[N];
stack<int> S;
void dfs(int u) {
dfn[u] = low[u] = ++step;
S.push(u);
for (int i = head[u]; i != -1; i = tu[i].next) {
int v = tu[i].to;
if (!dfn[v]) {
dfs(v);
low[u] = min(low[u], low[v]);
} else if (!sccno[v])
low[u] = min(low[u], dfn[v]);
}
if (low[u] == dfn[u]) {
scc_cnt += 1;
scc[scc_cnt].clear();
while (1) {
int x = S.top();
S.pop();
if (sccno[x] != scc_cnt) scc[scc_cnt].push_back(x);
sccno[x] = scc_cnt;
if (x == u) break;
}
}
}
void tarjan(int n) {
memset(sccno, 0, sizeof(sccno));
memset(dfn, 0, sizeof(dfn));
step = scc_cnt = 0;
for (int i = 1; i <= n; i++)
if (!dfn[i]) dfs(i);
}
inline int trans(int x) { return (x + 1) % h; }
int main() {
int a, b;
init();
scanf("%d%d%d", &n, &m, &h);
for (int i = 1; i <= n; i++) scanf("%d", &u[i]);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &a, &b);
if (trans(u[a]) == u[b]) add(a, b);
if (trans(u[b]) == u[a]) add(b, a);
}
tarjan(n);
for (int i = 1; i <= edgnum; i++)
if (sccno[edgsav[i].a] != sccno[edgsav[i].b]) {
outd[sccno[edgsav[i].a]]++;
ind[sccno[edgsav[i].b]]++;
}
int the, tmp = INF;
for (int i = 1; i <= scc_cnt; i++)
if (outd[i] == 0 && scc[i].size() < tmp) the = i, tmp = scc[i].size();
printf("%d\n", tmp);
for (int i = 0; i < scc[the].size(); i++) {
printf("%d", scc[the][i]);
if (i == scc[the].size() - 1)
puts("");
else
printf(" ");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100003;
int SCCtag, n, m, h, a, b, t = 1, ans = INT_MAX, mySCC;
int disctime[maxn], mintime[maxn], horas[maxn], DAGnode[maxn], SCCsize[maxn];
bool vis[maxn], instack[maxn], vis2[maxn];
stack<int> scc;
set<pair<int, int>> edges;
vector<int> ady[maxn];
set<int> DAGady[maxn];
void procesa(int node) {
++SCCtag;
int tp;
do {
SCCsize[SCCtag]++;
tp = scc.top();
scc.pop();
instack[tp] = false;
DAGnode[tp] = SCCtag;
} while (tp != node);
}
void Tarjan(int node) {
if (vis[node]) return;
vis[node] = true;
instack[node] = true;
scc.push(node);
mintime[node] = disctime[node] = t++;
for (auto vec : ady[node]) {
Tarjan(vec);
if (instack[vec]) mintime[node] = min(mintime[node], mintime[vec]);
}
if (disctime[node] == mintime[node]) procesa(node);
return;
}
int main() {
scanf("%d %d %d", &n, &m, &h);
for (int i = 1; i <= n; i++) scanf("%d", &horas[i]);
for (int i = 0; i < m; i++) {
scanf("%d %d", &a, &b);
if ((horas[a] + 1) % h == horas[b]) {
if (edges.find({a, b}) == edges.end()) {
ady[a].push_back(b);
edges.insert({a, b});
}
}
if ((horas[b] + 1) % h == horas[a]) {
if (edges.find({b, a}) == edges.end()) {
ady[b].push_back(a);
edges.insert({b, a});
}
}
}
for (int i = 1; i <= n; i++) {
Tarjan(i);
}
for (set<pair<int, int>>::iterator it = edges.begin(); it != edges.end();
it++) {
a = (*it).first;
b = (*it).second;
if (DAGnode[a] != DAGnode[b]) DAGady[DAGnode[a]].insert(DAGnode[b]);
}
for (int i = 1; i <= SCCtag; i++) {
if (DAGady[i].size() == 0) {
if (SCCsize[i] < ans) {
ans = SCCsize[i];
mySCC = i;
}
}
}
printf("%d\n", ans);
for (int i = 1; i <= n; i++)
if (DAGnode[i] == mySCC) printf("%d ", i);
return 0;
}
|
#include <bits/stdc++.h>
inline int pidorand() { return ((rand() & 32767) << 15) | (rand() & 32767); }
using namespace std;
inline int nxt() {
int x;
scanf("%d", &x);
return x;
}
const int N = 111111;
vector<int> a[N];
int color[N];
char used[N];
int curcolor = 0;
int lowlink[N];
int jshhlsdf[N];
int idx = 0;
vector<int> st;
vector<vector<int>> comps;
void dfs(int v) {
used[v] = 1;
st.push_back(v);
jshhlsdf[v] = lowlink[v] = idx++;
for (int x : a[v]) {
if (used[x] == 2) {
continue;
} else if (used[x] == 1) {
lowlink[v] = min(lowlink[v], jshhlsdf[x]);
} else {
dfs(x);
lowlink[v] = min(lowlink[v], lowlink[x]);
}
}
if (jshhlsdf[v] == lowlink[v]) {
comps.push_back({});
int x = -1;
while (x != v) {
x = st.back();
st.pop_back();
used[x] = 2;
comps.back().push_back(x);
color[x] = curcolor;
}
++curcolor;
}
}
int main() {
int n = nxt(), m = nxt(), h = nxt();
vector<int> c(n);
for (int i = 0; i < n; ++i) {
c[i] = nxt();
}
for (int i = 0; i < m; ++i) {
int u = nxt() - 1, v = nxt() - 1;
if ((c[u] + 1) % h == c[v]) {
a[u].push_back(v);
}
swap(u, v);
if ((c[u] + 1) % h == c[v]) {
a[u].push_back(v);
}
}
for (int i = 0; i < n; ++i) {
if (!used[i]) {
dfs(i);
}
}
vector<int> out_deg(curcolor);
for (int i = 0; i < n; ++i) {
for (int x : a[i]) {
if (color[x] != color[i]) {
out_deg[color[i]] += 1;
}
}
}
int opt = -1;
for (int i = 0; i < curcolor; ++i) {
if (out_deg[i]) {
continue;
}
if (opt == -1 || comps[i].size() < comps[opt].size()) {
opt = i;
}
}
printf("%d\n", (int)comps[opt].size());
for (int x : comps[opt]) {
printf("%d ", x + 1);
}
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int INF = 0x3f3f3f3f3f3f3f3f;
const int N = 3e6 + 7;
const int M = 3013;
int n, m, h, dindex, all, cnt, t[N], dfn[N], low[N], st[N], id[N], dg[N];
bool inst[N];
vector<int> edge[N], ans[N];
void tarjan(int v) {
dindex++;
dfn[v] = low[v] = dindex;
st[all++] = v;
inst[v] = true;
for (int nx : edge[v]) {
if (!dfn[nx]) {
tarjan(nx);
low[v] = min(low[v], low[nx]);
} else if (inst[nx])
low[v] = min(low[v], low[nx]);
}
if (dfn[v] == low[v]) {
cnt++;
while (1) {
int cur = st[--all];
inst[cur] = false;
id[cur] = cnt;
ans[cnt].push_back(cur);
if (cur == v) break;
}
}
}
int main() {
scanf("%d", &n);
scanf("%d", &m);
scanf("%d", &h);
for (int i = 1; i <= n; i++) scanf("%d", &t[i]);
for (int i = 1; i <= m; i++) {
int c1, c2;
scanf("%d", &c1);
scanf("%d", &c2);
if ((t[c1] + 1) % h == t[c2]) edge[c1].push_back(c2);
if ((t[c2] + 1) % h == t[c1]) edge[c2].push_back(c1);
}
for (int i = 1; i <= n; i++)
if (!dfn[i]) tarjan(i);
for (int i = 1; i <= n; i++)
for (int j : edge[i])
if (id[i] != id[j]) dg[id[i]]++;
int ret = inf, pos;
for (int i = 1; i <= cnt; i++)
if (dg[i] == 0 && ans[i].size() < ret) ret = ans[i].size(), pos = i;
printf("%d\n", ret);
for (int i : ans[pos]) printf("%d ", i);
puts("");
return 0;
}
|
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
vector<vector<int>> g;
vector<vector<int>> gt;
vector<int> used1, used2, order;
void dfs1(int v) {
used1[v] = 1;
for (int i = 0; i < g[v].size(); i++) {
int to = g[v][i];
if (!used1[to]) dfs1(to);
}
order.push_back(v);
}
int cnt_comp = 0;
vector<int> comp;
vector<set<int>> component;
vector<vector<int>> comp_g;
void dfs2(int v) {
comp[v] = cnt_comp;
used2[v] = true;
component[cnt_comp].insert(v);
for (int i = 0; i < gt[v].size(); i++) {
int to = gt[v][i];
if (!used2[to]) dfs2(to);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(0);
;
int n, m, h;
cin >> n >> m >> h;
vector<int> vertex(n);
for (int i = 0; i < n; i++) cin >> vertex[i];
g.resize(n);
gt.resize(n);
used1.resize(n);
used2.resize(n);
comp.resize(n);
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
if ((vertex[a] + 1) % h == vertex[b]) {
g[a].push_back(b);
gt[b].push_back(a);
}
if ((vertex[b] + 1) % h == vertex[a]) {
g[b].push_back(a);
gt[a].push_back(b);
}
}
for (int i = 0; i < n; i++)
if (!used1[i]) dfs1(i);
reverse(order.begin(), order.end());
for (int i = 0; i < order.size(); i++)
if (!used2[order[i]]) {
component.push_back({});
dfs2(order[i]);
cnt_comp++;
}
comp_g.resize(cnt_comp);
for (int i = 0; i < n; i++)
for (int j = 0; j < g[i].size(); j++) {
int to = g[i][j];
if (comp[i] != comp[to]) comp_g[comp[i]].push_back(comp[to]);
}
int ans = -1;
for (int i = 0; i < cnt_comp; i++)
if (comp_g[i].size() == 0 &&
(ans == -1 || component[ans].size() > component[i].size()))
ans = i;
cout << component[ans].size() << '\n';
for (int x : component[ans]) cout << x + 1 << ' ';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, h, cc, tot, res, i, j, x, y, a[100100], all[100100], c[100100],
cnt[100100];
vector<int> g[100100], o[100100];
bool u[100100], w[100100];
void dfs(int i) {
u[i] = true;
for (int j = 0; j < g[i].size(); j++)
if (!u[g[i][j]]) dfs(g[i][j]);
all[++tot] = i;
}
void ofs(int i) {
c[i] = cc;
cnt[cc]++;
for (int j = 0; j < o[i].size(); j++)
if (!c[o[i][j]]) ofs(o[i][j]);
}
int main() {
scanf("%d%d%d", &n, &m, &h);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
while (m--) {
scanf("%d%d", &x, &y);
if ((a[x] + 1) % h == a[y]) {
g[x].push_back(y);
o[y].push_back(x);
}
if ((a[y] + 1) % h == a[x]) {
g[y].push_back(x);
o[x].push_back(y);
}
}
for (i = 1; i <= n; i++)
if (!u[i]) dfs(i);
for (i = tot; i > 0; i--)
if (!c[all[i]]) {
++cc;
ofs(all[i]);
}
for (i = 1; i <= n; i++)
for (j = 0; j < g[i].size(); j++)
if (c[i] != c[g[i][j]]) w[c[i]] = true;
for (i = 1; i <= cc; i++)
if (!w[i] && (res == 0 || cnt[i] < cnt[res])) res = i;
printf("%d\n", cnt[res]);
for (i = 1; i <= n; i++)
if (c[i] == res) printf("%d ", i);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, h, u[100005], u1[100005], cur_color, col[100005];
set<int> g[100005], g1[100005], gr[100005], g_cond[100005];
set<int> ind[100005];
bool used[100005];
vector<int> order, comp[100005];
void dfs1(int v) {
u1[v] = u[v] + 1;
if (u1[v] == h) {
u1[v] = 0;
}
for (int i : g[v]) {
if (u1[v] == u[i]) {
if (u1[i] == u[i]) {
dfs1(i);
}
g1[v].insert(i);
}
}
}
void top_sort(int v) {
used[v] = true;
for (int i : g1[v]) {
if (!used[i]) {
top_sort(i);
}
}
order.push_back(v);
}
void get_comps(int v) {
col[v] = cur_color;
comp[cur_color].push_back(v);
used[v] = true;
for (int i : gr[v]) {
if (!used[i]) {
get_comps(i);
}
}
}
void condensate(int v) {
used[v] = true;
for (int i : g1[v]) {
if (col[v] != col[i]) {
g_cond[col[v]].insert(col[i]);
}
if (!used[i]) {
condensate(i);
}
}
}
int main() {
cin >> n >> m >> h;
for (int i = 1; i <= n; ++i) {
cin >> u[i];
u1[i] = u[i];
}
for (int i = 1; i <= m; ++i) {
int a, b;
cin >> a >> b;
g[a].insert(b);
g[b].insert(a);
}
for (int i = 1; i <= n; ++i) {
if (u[i] == u1[i]) {
dfs1(i);
}
}
for (int i = 1; i <= n; ++i) {
used[i] = false;
}
for (int i = 1; i <= n; ++i) {
if (!used[i]) {
top_sort(i);
}
}
for (int i = 1; i <= n; ++i) {
for (int j : g1[i]) {
gr[j].insert(i);
}
}
for (int i = 1; i <= n; ++i) {
used[i] = false;
}
cur_color = 0;
for (int i = n - 1; i >= 0; --i) {
int v = order[i];
if (!used[v]) {
cur_color++;
get_comps(v);
}
}
for (int i = 1; i <= n; ++i) {
used[i] = false;
}
for (int i = 1; i <= n; ++i) {
if (!used[i]) {
condensate(i);
}
}
int minv = 1e6;
for (int i = 1; i <= cur_color; ++i) {
if ((int)g_cond[i].size() == 0) {
minv = min(minv, (int)comp[i].size());
}
}
for (int i = 1; i <= cur_color; ++i) {
if ((int)g_cond[i].size() == 0) {
if ((int)comp[i].size() == minv) {
cout << minv << endl;
for (int j = 0; j < minv; ++j) {
cout << comp[i][j] << ' ';
}
cout << endl;
return 0;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, h;
int a[300005];
int cnt[300005];
bool nope[300005];
vector<int> edge[300005];
class SCC {
public:
int n;
int lv;
vector<int> num, low, cid;
vector<int> vis;
vector<vector<int> > comp;
stack<int> s;
SCC(int n, vector<int> edge[]) : n(n), lv(0), num(n), low(n), cid(n), vis(n) {
for (int v = 0; v < n; v++) {
cid[v] = -1;
num[v] = -1;
}
for (int v = 0; v < n; v++) {
if (num[v] == -1) dfs(v, edge, comp);
}
}
void dfs(int v, vector<int> edge[], vector<vector<int> > &r) {
num[v] = low[v] = lv++;
vis[v] = true;
s.push(v);
for (int i = 0; i < edge[v].size(); ++i) {
int u = edge[v][i];
if (num[u] == -1) {
dfs(u, edge, r);
low[v] = min(low[v], low[u]);
} else if (vis[u]) {
low[v] = min(low[v], low[u]);
}
}
if (num[v] == low[v]) {
int u;
vector<int> nc;
do {
u = s.top();
s.pop();
vis[u] = false;
cid[u] = r.size();
nc.push_back(u);
} while (v != u);
r.push_back(nc);
}
}
};
int main() {
scanf("%d%d%d", &n, &m, &h);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d%d", &x, &y);
--x;
--y;
if ((a[x] + 1) % h == a[y]) edge[x].push_back(y);
if ((a[y] + 1) % h == a[x]) edge[y].push_back(x);
}
SCC scc(n, edge);
for (int i = 0; i < scc.comp.size(); i++) {
for (int j = 0; j < scc.comp[i].size(); j++) {
int v = scc.comp[i][j];
for (int k = 0; k < edge[v].size(); k++) {
int u = edge[v][k];
if (i != scc.cid[u]) nope[i] = true;
}
}
}
int best = -1;
for (int i = 0; i < scc.comp.size(); i++) {
if (nope[i]) continue;
if (best == -1 || scc.comp[i].size() < scc.comp[best].size()) best = i;
}
printf("%d\n", scc.comp[best].size());
vector<int> ans_v;
for (int i = 0; i < n; i++) {
if (scc.cid[i] == best) {
ans_v.push_back(i + 1);
}
}
for (int i = 0; i < ans_v.size(); i++) {
if (i) printf(" ");
printf("%d", ans_v[i]);
}
puts("");
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("-O3")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
using namespace std;
const int MAXN = 1123456;
const int N = 2e5;
const long long inf = 1e18;
mt19937_64 rnd(chrono::system_clock::now().time_since_epoch().count());
template <typename T>
void vout(T s) {
cout << s << endl;
exit(0);
}
vector<long long> v[MAXN], cnt, g[MAXN], order, used, c;
int r;
void dfs(long long x) {
if (used[x]) return;
used[x] = 1;
for (auto to : v[x]) dfs(to);
}
void top_sort(long long x) {
if (used[x]) return;
used[x] = 1;
for (auto to : v[x]) top_sort(to);
order.push_back(x);
}
void build_component(long long x) {
if (used[x]) {
if (c[x] != r) cnt[c[x]] = inf;
return;
}
used[x] = 1;
c[x] = r;
cnt[r]++;
for (auto to : g[x]) build_component(to);
}
void main_solve() {
long long n, m, h;
cin >> n >> m >> h;
vector<long long> u(n + 1);
cnt.clear();
cnt.resize(n + 1);
c.clear();
c.resize(n + 1);
for (int i = 1; i <= n; i++) {
cin >> u[i];
v[i].clear();
}
while (m--) {
long long a, b;
cin >> a >> b;
if ((u[a] + 1) % h == u[b]) {
v[a].push_back(b);
g[b].push_back(a);
}
if ((u[b] + 1) % h == u[a]) {
v[b].push_back(a);
g[a].push_back(b);
}
}
used.clear();
used.resize(n + 1);
for (int i = 1; i <= n; i++) {
if (!used[i]) top_sort(i);
}
reverse(order.begin(), order.end());
used.clear();
used.resize(n + 1);
r = 0;
for (auto i : order)
if (!used[i]) {
r++;
build_component(i);
}
pair<long long, long long> ans = {n + 1, 0};
for (int i = 1; i <= n; i++) ans = min(ans, {cnt[c[i]], i});
used.clear();
used.resize(n + 1);
dfs(ans.second);
cout << ans.first << "\n";
for (int i = 1; i <= n; i++)
if (used[i]) cout << i << " ";
cout << "\n";
}
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
main_solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
void chkmax(T &a, T b) {
if (a < b) a = b;
}
template <class T>
void chkmin(T &a, T b) {
if (a > b) a = b;
}
const int inf = 0x3f3f3f3f;
vector<int> v[200010];
stack<int> stk;
int n, tot, G, sz, m, h;
int dt[200010], low[200010], u[200010], rt[200010];
int nxt[200010], head[200010], to[200010];
void add_edge(int first, int second) {
tot++;
nxt[tot] = head[first];
to[tot] = second;
head[first] = tot;
return;
}
void dfs(int k) {
dt[k] = low[k] = ++G;
stk.push(k);
for (int i = head[k]; i; i = nxt[i]) {
int first = to[i];
if (!dt[first]) {
dfs(first);
chkmin(low[k], low[first]);
} else
chkmin(low[k], dt[first]);
}
if (dt[k] == low[k]) {
int first;
while (!stk.empty()) {
first = stk.top();
stk.pop();
rt[first] = k;
v[k].push_back(first);
if (first == k) break;
}
}
return;
}
int main() {
scanf("%d %d %d", &n, &m, &h);
int first, second;
for (int i = 1; i <= n; i++) scanf("%d", &u[i]);
for (int i = 1; i <= m; i++) {
scanf("%d %d", &first, &second);
if ((u[first] + 1) % h == u[second]) add_edge(first, second);
if ((u[second] + 1) % h == u[first]) add_edge(second, first);
}
for (int i = 1; i <= n; i++)
if (!dt[i]) dfs(i);
memset(dt, 0, sizeof dt);
for (int i = 1; i <= n; i++) {
for (int first = head[i]; first; first = nxt[first]) {
if (rt[to[first]] != rt[i]) dt[rt[i]] = 1;
}
}
int ans = inf, id;
for (int i = 1; i <= n; i++)
if (!dt[i] && v[i].size() > 0 && ans > v[i].size()) {
id = i;
ans = v[i].size();
}
printf("%d\n", ans);
for (int i = 0; i < v[id].size(); i++) printf("%d ", v[id][i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 100005;
struct edge {
int to, nxt;
} e[MX << 1];
int n, m, h, val[MX], head[MX], tot, dfn[MX], low[MX], cnt, stk[MX], top;
int num, blt[MX], siz[MX], out[MX], ans = 1e9, id;
bool ins[MX];
inline void add(int u, int v) { e[++tot] = (edge){v, head[u]}, head[u] = tot; }
inline void Tarjan(int u) {
low[u] = dfn[u] = ++cnt;
stk[++top] = u, ins[u] = 1;
for (int i = head[u]; i; i = e[i].nxt)
if (!dfn[e[i].to])
Tarjan(e[i].to), low[u] = min(low[u], low[e[i].to]);
else if (ins[e[i].to])
low[u] = min(low[u], dfn[e[i].to]);
if (dfn[u] == low[u]) {
++num;
do blt[stk[top]] = num, siz[num]++;
while (stk[top--] != u);
}
}
int main() {
ios::sync_with_stdio(0);
scanf("%d%d%d", &n, &m, &h);
for (int i = 1; i <= n; i++) scanf("%d", val + i);
for (int i = 1, u, v; i <= m; i++) {
scanf("%d%d", &u, &v);
if ((val[u] + 1) % h == val[v]) add(u, v);
if ((val[v] + 1) % h == val[u]) add(v, u);
}
for (int i = 1; i <= n; i++)
if (!dfn[i]) Tarjan(i);
for (int i = 1; i <= n; i++)
for (int j = head[i]; j; j = e[j].nxt)
if (blt[i] != blt[e[j].to]) out[blt[i]]++;
for (int i = 1; i <= num; i++)
if (!out[i])
if (ans > siz[i]) ans = siz[i], id = i;
cout << ans << endl;
for (int i = 1; i <= n; i++)
if (blt[i] == id) cout << i << ' ';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int to, next;
};
const int maxn = 200005;
int f[maxn];
int all;
int n, m, book[maxn], c;
int cnt1, cnt2;
int id[maxn];
node a[maxn];
node b[maxn];
int head1[maxn], head2[maxn];
int q[maxn];
int cd[maxn];
int t[maxn];
vector<int> ans[maxn];
void init() {
cnt1 = cnt2 = 0;
for (int i = 1; i <= n; i++) {
head1[i] = head2[i] = -1;
}
}
void addedge(int x, int y) {
cnt1++;
a[cnt1].to = y;
a[cnt1].next = head1[x];
head1[x] = cnt1;
cnt2++;
b[cnt2].to = x;
b[cnt2].next = head2[y];
head2[y] = cnt2;
}
void dfs1(int x) {
book[x] = 1;
for (int i = head1[x]; i != -1; i = a[i].next) {
if (book[a[i].to] == 0) dfs1(a[i].to);
}
q[++c] = x;
}
void dfs2(int x) {
book[x] = 1;
id[x] = all;
ans[all].push_back(x);
for (int i = head2[x]; i != -1; i = b[i].next) {
if (book[b[i].to] == 0) dfs2(b[i].to);
}
}
int main() {
int sum;
scanf("%d%d%d", &n, &m, &sum);
init();
memset(book, 0, sizeof(book));
for (int i = 1; i <= n; i++) {
scanf("%d", &f[i]);
}
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
if ((f[x] + 1) % sum == f[y]) addedge(x, y);
if ((f[y] + 1) % sum == f[x]) addedge(y, x);
}
c = 0;
for (int i = 1; i <= n; i++) {
if (book[i] == 0) dfs1(i);
}
memset(book, 0, sizeof(book));
all = 0;
for (int i = n; i >= 1; i--) {
if (book[q[i]] == 0) {
all++;
dfs2(q[i]);
}
}
memset(cd, 0, sizeof(cd));
for (int i = 1; i <= n; i++) {
for (int j = head1[i]; j != -1; j = a[j].next) {
if (id[i] != id[a[j].to]) {
cd[id[i]]++;
}
}
}
int minm = -1;
for (int i = 1; i <= all; i++) {
if (cd[i] == 0) {
if (minm == -1)
minm = i;
else {
if (ans[minm].size() > ans[i].size()) {
minm = i;
}
}
}
}
int l = ans[minm].size();
printf("%d\n", l);
for (int i = 0; i < l; i++) {
printf("%d ", ans[minm][i]);
}
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 101010, MAXM = 202020;
int n, m, h, u[MAXN], c[MAXN][2];
class Edge {
public:
int to, next;
} e[MAXM], e2[MAXM];
int head[MAXN], en = 0, head2[MAXN], en2 = 0;
void insert(int u, int v) {
e[++en].to = v;
e[en].next = head[u];
head[u] = en;
}
void insert2(int u, int v) {
e2[++en2].to = v;
e2[en2].next = head2[u];
head2[u] = en2;
}
int dfn[MAXN], low[MAXN], dfsnum = 0;
stack<int> st;
int block[MAXN], bls[MAXN], bln = 0;
int ansblk = 0, ans;
bool instack[MAXN];
void tarjan(int p) {
dfn[p] = low[p] = ++dfsnum;
st.push(p);
instack[p] = true;
for (int i = head[p]; i > 0; i = e[i].next) {
if (!dfn[e[i].to]) tarjan(e[i].to);
if (low[e[i].to] < low[p] && instack[e[i].to]) low[p] = low[e[i].to];
}
if (low[p] == dfn[p]) {
bln++;
bls[bln] = 0;
while (st.top() != p) {
block[st.top()] = bln;
instack[st.top()] = false;
bls[bln]++;
st.pop();
}
block[p] = bln;
instack[p] = false;
bls[bln]++;
st.pop();
}
}
int main() {
scanf("%d%d%d", &n, &m, &h);
for (int i = 1; i <= n; i++) scanf("%d", &u[i]);
memset(head, -1, sizeof(head));
for (int i = 1; i <= m; i++) {
scanf("%d%d", &c[i][0], &c[i][1]);
if ((u[c[i][0]] + 1) % h == u[c[i][1]]) insert(c[i][0], c[i][1]);
if ((u[c[i][1]] + 1) % h == u[c[i][0]]) insert(c[i][1], c[i][0]);
}
memset(instack, false, sizeof(instack));
memset(dfn, 0, sizeof(dfn));
for (int i = 1; i <= n; i++)
if (!dfn[i]) tarjan(i);
memset(head2, -1, sizeof(head2));
for (int i = 1; i <= n; i++)
for (int j = head[i]; j > 0; j = e[j].next)
if (block[i] != block[e[j].to]) insert2(block[i], block[e[j].to]);
ans = n + 1;
for (int i = 1; i <= bln; i++)
if (head2[i] == -1) {
if (bls[i] < ans) {
ans = bls[i];
ansblk = i;
}
}
printf("%d\n", ans);
for (int i = 1; i <= n; i++)
if (block[i] == ansblk) printf("%d ", i);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200200;
const int mod = 1e9 + 7;
int n, m, h, a[N];
vector<int> gr[N], g[N], comp[N], e[N];
int used[N];
int color;
int col[N];
vector<int> order;
vector<int> ans;
inline void upd(vector<int> &ans, vector<int> cur) {
if (cur.size() < ans.size() || ans.size() == 0) ans.swap(cur);
}
inline void dfs(int v) {
used[v] = 1;
for (int to : g[v])
if (!used[to]) dfs(to);
order.push_back(v);
}
inline void go(int v, int c) {
used[v] = c;
comp[c].push_back(v);
for (int to : gr[v])
if (!used[to]) go(to, c);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> h;
for (int i = 0; i < n; ++i) cin >> a[i];
for (int i = 0; i < m; ++i) {
int u, v;
cin >> u >> v;
u--, v--;
if ((a[u] + 1) % h == a[v]) g[u].push_back(v);
if ((a[v] + 1) % h == a[u]) g[v].push_back(u);
}
for (int i = 0; i < n; ++i) {
sort(g[i].begin(), g[i].end());
int x = unique(g[i].begin(), g[i].end()) - g[i].begin();
g[i].resize(x);
}
for (int i = 0; i < n; ++i)
for (int to : g[i]) {
gr[to].push_back(i);
}
for (int i = 0; i < n; ++i)
if (!used[i]) dfs(i);
reverse(order.begin(), order.end());
memset(used, 0, sizeof used);
for (int i = 0; i < n; ++i) {
int v = order[i];
if (!used[v]) {
go(v, ++color);
}
}
for (int i = 0; i < n; ++i)
for (int to : g[i]) {
if (used[i] != used[to]) {
int u = used[i];
int v = used[to];
e[u].push_back(v);
}
}
for (int i = 1; i <= color; ++i) {
sort(e[i].begin(), e[i].end());
int x = unique(e[i].begin(), e[i].end()) - e[i].begin();
e[i].resize(x);
}
for (int i = 1; i <= color; ++i)
if (e[i].size() == 0) {
upd(ans, comp[i]);
}
cout << ans.size() << '\n';
for (int x : ans) cout << x + 1 << ' ';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int s = 0, w = 1;
char ch = getchar();
while (ch < '0' || '9' < ch) {
if (ch == '-') w = -1;
ch = getchar();
}
while ('0' <= ch && ch <= '9') {
s = s * 10 + ch - '0';
ch = getchar();
}
return s * w;
}
const int MAXN = 300005;
struct Edge {
int from, to, next;
} edge[MAXN * 2];
int head[MAXN], num_edge;
void add_edge(int from, int to) {
edge[++num_edge].to = to;
edge[num_edge].next = head[from];
edge[num_edge].from = from;
head[from] = num_edge;
}
int lowlink[MAXN], pre[MAXN], sccno[MAXN], dfs_clock, scc_cnt;
stack<int> s;
void dfs(int x) {
s.push(x);
lowlink[x] = pre[x] = ++dfs_clock;
for (int i = head[x]; i; i = edge[i].next) {
Edge e = edge[i];
if (!pre[e.to]) {
dfs(e.to);
lowlink[x] = min(lowlink[x], lowlink[e.to]);
} else if (!sccno[e.to]) {
lowlink[x] = min(lowlink[x], pre[e.to]);
}
}
if (lowlink[x] == pre[x]) {
scc_cnt++;
while (1) {
int y = s.top();
s.pop();
sccno[y] = scc_cnt;
if (y == x) break;
}
}
}
void find_scc(int n) {
for (int i = 1; i <= n; i++)
if (!pre[i]) dfs(i);
}
int n, ans, _min;
int deg[MAXN], sz[MAXN];
void solve() {
for (int i = 1; i <= num_edge; i++) {
Edge e = edge[i];
if (sccno[e.from] != sccno[e.to]) deg[sccno[e.from]]++;
}
for (int i = 1; i <= n; i++) sz[sccno[i]]++;
_min = 2139062143;
for (int i = 1; i <= scc_cnt; i++) {
if (sz[i] < _min && !deg[i]) ans = i, _min = sz[i];
}
}
int t[MAXN];
int main() {
int m, h;
scanf("%d%d%d", &n, &m, &h);
for (int i = 1; i <= n; i++) scanf("%d", &t[i]);
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
if ((t[u] + 1) % h == t[v]) add_edge(u, v);
if ((t[v] + 1) % h == t[u]) add_edge(v, u);
}
find_scc(n);
solve();
printf("%d\n", _min);
for (int i = 1; i <= n; i++) {
if (sccno[i] == ans) printf("%d ", i);
}
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 5;
namespace SCC {
const int N = 101010;
int dfn[N], low[N], st[N], top, id[N], col, cnt, big[N];
void dfs(int u, vector<int> g[]) {
dfn[u] = low[u] = ++cnt;
st[top++] = u;
for (auto v : g[u]) {
if (!dfn[v]) {
dfs(v, g);
low[u] = min(low[u], low[v]);
} else if (!id[v])
low[u] = min(low[u], dfn[v]);
}
if (low[u] == dfn[u]) {
++col;
do {
id[st[--top]] = col;
big[col]++;
} while (st[top] != u);
}
}
int out[N];
int solve(int n, vector<int> g[]) {
fill_n(big, n + 1, 0);
fill_n(dfn, n + 1, top = 0);
fill_n(low, n + 1, col = 0);
fill_n(id, n + 1, cnt = 0);
for (int i = (1); i < (n + 1); i++)
if (!dfn[i]) dfs(i, g);
fill_n(out, col + 1, 0);
for (int i = (1); i < (n + 1); i++)
for (int v = 0; v < (int)g[i].size(); ++v) {
int j = g[i][v];
if (id[i] != id[j]) out[id[i]]++;
}
return col;
}
vector<int> gao(int n) {
int mn = 1e9, ans;
for (int i = (1); i < (col + 1); i++) {
if (out[i] == 0 && big[i] < mn) ans = i, mn = min(mn, big[i]);
}
vector<int> t;
for (int i = (1); i < (n + 1); i++)
if (id[i] == ans) t.push_back(i);
return t;
}
} // namespace SCC
int a[N];
vector<int> g[N];
int main() {
int n, m, h;
cin >> n >> m >> h;
int u, v;
for (int i = (1); i < (n + 1); i++) cin >> a[i];
for (int i = (1); i < (m + 1); i++) {
cin >> u >> v;
if ((a[u] + 1) % h == a[v]) g[u].push_back(v);
if ((a[v] + 1) % h == a[u]) g[v].push_back(u);
}
SCC::solve(n, g);
vector<int> ans = SCC::gao(n);
cout << (int)ans.size() << "\n";
for (auto v : ans) cout << v << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1010000;
const int INF = 1e9;
int n, m, p;
int a[MAXN];
int tot, front[MAXN], to[MAXN], nxt[MAXN];
int dfn_clock, pre[MAXN], low[MAXN], sccno[MAXN], num[MAXN], indo[MAXN],
outdo[MAXN];
int s[MAXN], top;
void init(int u, int v) {
to[++tot] = v;
nxt[tot] = front[u];
front[u] = tot;
}
void tarjan_ccp(int u) {
pre[u] = low[u] = ++dfn_clock;
s[++top] = u;
for (int i = front[u]; i; i = nxt[i]) {
int v = to[i];
if (!pre[v]) {
tarjan_ccp(v);
low[u] = min(low[u], low[v]);
} else if (!sccno[v])
low[u] = min(low[u], pre[v]);
}
if (low[u] == pre[u]) {
sccno[0]++;
for (;;) {
int x = s[top--];
sccno[x] = sccno[0];
num[sccno[0]]++;
if (x == u) break;
}
}
}
int main() {
scanf("%d%d%d", &n, &m, &p);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
if (a[x] > a[y]) swap(x, y);
if (a[x] + 1 == a[y]) init(x, y);
if ((a[y] + 1) % p == a[x]) init(y, x);
}
for (int i = 1; i <= n; i++) {
if (!pre[i]) tarjan_ccp(i);
}
for (int i = 1; i <= n; i++) {
for (int j = front[i]; j; j = nxt[j]) {
int v = to[j];
if (sccno[v] != sccno[i]) {
outdo[sccno[i]]++;
indo[sccno[v]]++;
}
}
}
int ans1 = INF, ans2 = 0;
for (int i = 1; i <= sccno[0]; i++)
if (outdo[i] == 0)
if (ans1 > num[i]) {
ans1 = num[i];
ans2 = i;
}
printf("%d\n", ans1);
for (int i = 1; i <= n; i++)
if (sccno[i] == ans2) printf("%d ", i);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Scc {
int n, nScc, vst[100005], bln[100005];
vector<int> E[100005], rE[100005], vec;
void init(int _n) {
n = _n;
for (int i = 0; i < 100005; i++) {
E[i].clear();
rE[i].clear();
}
}
void add_edge(int u, int v) {
E[u].push_back(v);
rE[v].push_back(u);
}
void DFS(int u) {
vst[u] = 1;
for (auto v : E[u])
if (!vst[v]) DFS(v);
vec.push_back(u);
}
void rDFS(int u) {
vst[u] = 1;
bln[u] = nScc;
for (auto v : rE[u])
if (!vst[v]) rDFS(v);
}
void solve() {
nScc = 0;
vec.clear();
memset(vst, 0, sizeof(vst));
for (int i = 1; i <= n; i++)
if (!vst[i]) DFS(i);
reverse(vec.begin(), vec.end());
memset(vst, 0, sizeof(vst));
for (auto v : vec) {
if (!vst[v]) {
rDFS(v);
nScc++;
}
}
}
} graph;
int u[100005], siz[100005], out[100005];
int main() {
int n, m, h, fr, to;
scanf("%d%d%d", &n, &m, &h);
for (int i = 1; i <= n; i++) {
scanf("%d", &u[i]);
}
graph.init(n);
while (m--) {
scanf("%d%d", &fr, &to);
if ((u[fr] + 1) % h == u[to]) graph.add_edge(fr, to);
if ((u[to] + 1) % h == u[fr]) graph.add_edge(to, fr);
}
graph.solve();
for (int i = 1; i <= n; i++) {
siz[graph.bln[i]]++;
}
for (int i = 1; i <= n; i++) {
for (auto j : graph.E[i]) {
if (graph.bln[j] != graph.bln[i]) out[graph.bln[i]]++;
}
}
int ans = 1e9, id;
for (int i = 0; i < graph.nScc; i++) {
if (out[i]) continue;
if (siz[i] < ans) {
id = i;
ans = siz[i];
}
}
printf("%d\n", ans);
for (int i = 1; i <= n; i++) {
if (graph.bln[i] == id) printf("%d ", i);
}
puts("");
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
vector<int> G[N];
stack<int> S;
bool vis[N];
int belong[N], low[N], dfn[N], num[N], b[N], a[N];
int dfn_max = 0, scc = 0, n, m, k;
void Tarjan(int now) {
dfn[now] = low[now] = ++dfn_max;
S.push(now), vis[now] = true;
for (int i = 0; i < G[now].size(); i++) {
int to = G[now][i];
if (!dfn[to]) {
Tarjan(to);
low[now] = min(low[now], low[to]);
} else if (vis[to])
low[now] = min(low[now], dfn[to]);
}
if (dfn[now] == low[now]) {
scc++;
while (1) {
int x = S.top();
S.pop();
belong[x] = scc;
num[scc]++;
if (x == now) break;
}
}
return;
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
if ((a[u] + 1) % k == a[v]) G[u].push_back(v);
if ((a[v] + 1) % k == a[u]) G[v].push_back(u);
}
for (int i = 1; i <= n; i++)
if (!dfn[i]) Tarjan(i);
for (int i = 1; i <= n; i++) {
for (int j = 0; j < G[i].size(); j++) {
int x = G[i][j];
if (belong[x] != belong[i]) b[belong[i]]++;
}
}
int ans, MINI = 1e9 + 7;
for (int i = 1; i <= n; i++) {
if (!b[belong[i]] && num[belong[i]] < MINI) {
MINI = num[belong[i]];
ans = belong[i];
}
}
printf("%d\n", MINI);
for (int i = 1; i <= n; i++)
if (ans == belong[i]) printf("%d ", i);
return 0;
}
|
#include <bits/stdc++.h>
struct r {
int to, last;
} e[200050];
int dfn[100050], low[100050], sta[100050], bn, t,
num = 1, head[100050], st, b[100050], bnum[200050], ti[100050];
void add(int u, int v) {
e[num].to = v;
e[num].last = head[u];
head[u] = num++;
}
bool insta[100050], f[100050];
void tarjan(int u) {
dfn[u] = low[u] = ++t;
sta[++st] = u;
insta[u] = 1;
int y;
for (int i = head[u]; i; i = e[i].last) {
if (!dfn[y = e[i].to]) {
tarjan(y);
low[u] = std::min(low[u], low[y]);
} else if (insta[y])
low[u] = std::min(low[u], dfn[y]);
}
if (low[u] == dfn[u]) {
int j;
bn++;
do {
j = sta[st--];
b[j] = bn;
insta[j] = 0;
bnum[bn]++;
} while (j != u);
}
}
int main() {
int n, m, u, v, h;
scanf("%d%d%d", &n, &m, &h);
for (int i = 1; i <= n; i++) scanf("%d", &ti[i]);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &u, &v);
if ((ti[u] + 1) % h == ti[v]) add(u, v);
if ((ti[v] + 1) % h == ti[u]) add(v, u);
}
for (int i = 1; i <= n; i++)
if (!dfn[i]) tarjan(i);
for (int i = 1; i <= n; i++)
if (!f[b[i]])
for (int j = head[i]; j; j = e[j].last)
if (b[i] != b[e[j].to]) {
f[b[i]] = 1;
continue;
}
int ans = 2147483647, p;
for (int i = 1; i <= bn; i++)
if (!f[i] && ans > bnum[i]) ans = bnum[i], p = i;
printf("%d\n", ans);
for (int i = 1; i <= n; i++)
if (b[i] == p) printf("%d ", i);
}
|
#include <bits/stdc++.h>
using namespace std;
long long int n = 0, m = 0, h = 0;
vector<vector<long long int>> data, data_t;
vector<long long int> u;
vector<bool> used;
vector<long long int> order;
vector<long long int> components;
long long int Mod(long long int a, long long int b) { return (a % b + b) % b; }
long long int Add(long long int a, long long int b) { return Mod(a + b, h); }
void DFS1(long long int v) {
used[v] = true;
for (auto it : data[v])
if (!used[it]) DFS1(it);
order.push_back(v);
}
void DFS2(long long int v, long long int color) {
used[v] = true;
components[v] = color;
for (auto it : data_t[v])
if (!used[it]) DFS2(it, color);
}
void DFS3(vector<vector<long long int>>& next, vector<bool>& check,
vector<long long int>& sz, vector<long long int>& dp,
long long int v) {
check[v] = true;
for (auto it : next[v])
if (!check[it]) DFS3(next, check, sz, dp, it);
dp[v] = sz[v];
for (auto it : next[v]) dp[v] += dp[it];
}
void DFS4(vector<vector<long long int>>& next, vector<bool>& check,
vector<long long int>& sz, vector<long long int>& dp,
set<long long int>& answer, long long int v) {
check[v] = true;
answer.insert(v);
for (auto it : next[v])
if (!check[it]) DFS4(next, check, sz, dp, answer, it);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cin >> n >> m >> h;
data.resize(n);
data_t.resize(n);
u.resize(n);
used.resize(n);
components.resize(n);
for (auto& it : u) cin >> it;
for (long long int i = 0; i < m; i++) {
long long int x = 0, y = 0;
cin >> x >> y;
x--, y--;
if (Add(u[x], 1) == u[y]) {
data[x].push_back(y);
data_t[y].push_back(x);
}
if (Add(u[y], 1) == u[x]) {
data[y].push_back(x);
data_t[x].push_back(y);
}
}
for (long long int i = 0; i < n; i++)
if (!used[i]) DFS1(i);
reverse(order.begin(), order.end());
used.assign(n, false);
long long int color = 0;
for (long long int i = 0; i < order.size(); i++) {
if (!used[order[i]]) {
DFS2(order[i], color);
color++;
}
}
vector<set<long long int>> next(color);
for (long long int i = 0; i < data.size(); i++) {
for (auto it : data[i]) {
if (components[i] != components[it])
next[components[i]].insert(components[it]);
}
}
vector<vector<long long int>> graph(color);
for (long long int i = 0; i < next.size(); i++) {
for (auto it : next[i]) graph[i].push_back(it);
}
vector<long long int> sz(color);
for (auto it : components) sz[it]++;
vector<bool> check(color);
vector<long long int> dp(color, -1);
for (long long int i = 0; i < color; i++) {
if (!check[i]) DFS3(graph, check, sz, dp, i);
}
long long int index = 0;
for (long long int i = 1; i < dp.size(); i++) {
if (dp[i] < dp[index]) index = i;
}
check.assign(color, false);
set<long long int> answer;
DFS4(graph, check, sz, dp, answer, index);
cout << dp[index] << '\n';
for (long long int i = 0; i < components.size(); i++) {
if (answer.count(components[i]) > 0) cout << i + 1 << ' ';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int x, y, z, a, b, dis[100005], low[100005], sz = 2e18, s, ss;
vector<int> q[100005], pq, v;
void dfs(int n) {
static int indx = 1;
dis[n] = low[n] = indx++;
pq.push_back(n);
for (auto i : q[n]) {
if (!dis[i]) {
dfs(i);
low[n] = min(low[n], low[i]);
} else {
low[n] = min(low[n], dis[i]);
}
}
if (dis[n] == low[n]) {
int index = pq.size() - 1, sz2 = 1;
while (pq[index] != n) {
index--, sz2++;
}
if (sz2 < sz) {
sz = sz2;
s = index, ss = pq.size() - 1;
}
}
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
;
scanf("%d%d%d", &x, &y, &z);
for (int i = 0; i < x; i++) {
scanf("%d", &a);
v.push_back(a);
}
for (int i = 0; i < y; i++) {
scanf("%d%d", &a, &b);
int fn = (v[a - 1] + 1) % z, fs = (v[b - 1] + 1) % z;
if (fn == v[b - 1]) {
q[a].push_back(b);
}
if (v[a - 1] == fs) {
q[b].push_back(a);
}
}
for (int i = 1; i <= x; i++) {
if (!dis[i]) {
dfs(i);
}
}
cout << sz << endl;
for (; s <= ss; s++) {
printf("%d ", pq[s]);
}
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int read() {
int data = 0, w = 1;
char ch = 0;
while (ch != '-' && (ch < '0' || ch > '9')) ch = getchar();
if (ch == '-') {
w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
data = (data << 3) + (data << 1) + ch - '0';
ch = getchar();
}
data *= w;
return data;
}
void write(int x) {
if (x < 0) {
putchar('-');
x = -x;
}
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
void wrs(int x) {
write(x);
putchar(' ');
}
int bb[1000005][4], h[1000005], scc, belong[100005], cnt, r, n, m, sz[1000005],
dfn[1000005], vis[1000005], ans = 0x3f3f3f3f, low[1000005], top,
stk[1000005], mo, kk, a[1000005];
void add(int x, int y) {
bb[++r][0] = y;
bb[r][1] = h[x];
bb[r][2] = x;
h[x] = r;
}
void dfs(int k) {
dfn[k] = low[k] = ++cnt;
stk[++top] = k;
for (int i = h[k]; i; i = bb[i][1])
if (!dfn[bb[i][0]]) {
dfs(bb[i][0]);
low[k] = min(low[bb[i][0]], low[k]);
} else if (!belong[bb[i][0]])
low[k] = min(low[bb[i][0]], low[k]);
if (low[k] == dfn[k]) {
scc++;
while (stk[top + 1] != k) {
belong[stk[top--]] = scc;
sz[scc]++;
}
}
}
int main() {
n = read();
m = read();
mo = read();
for (int i = 1; i <= n; a[i++] = read())
;
for (int i = 0; i < m; i++) {
int x = read(), y = read();
if ((a[x] + 1) % mo == a[y]) add(x, y);
if ((a[y] + 1) % mo == a[x]) add(y, x);
}
for (int i = 1; i <= n; i++)
if (!dfn[i]) dfs(i);
for (int i = 1; i <= m; i++)
if (belong[bb[i][2]] != belong[bb[i][0]]) vis[belong[bb[i][2]]] = 1;
for (int i = 1; i <= scc; i++)
if (!vis[i] && sz[i] < ans) {
kk = i;
ans = sz[i];
}
write(ans);
putchar('\n');
for (int i = 1; i <= n; i++)
if (belong[i] == kk) wrs(i);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using uint = unsigned int;
using ll = long long;
using pii = pair<int, int>;
int nr;
int u[100010], comp[100010], sz[100010];
bool vis[100010], bad[100010];
vector<int> ord;
vector<int> adj[100010], adjt[100010];
void addEdge(int a, int b) {
adj[a].push_back(b);
adjt[b].push_back(a);
}
void dfs(int v) {
if (vis[v]) return;
vis[v] = true;
for (auto u : adj[v]) dfs(u);
ord.push_back(v);
}
void getComp(int v) {
if (vis[v]) return;
vis[v] = true;
comp[v] = nr;
++sz[nr];
for (auto u : adjt[v]) getComp(u);
}
int main() {
ios_base::sync_with_stdio(false);
int i, n, m, h, c1, c2, ans;
cin >> n >> m >> h;
for (i = 1; i <= n; ++i) cin >> u[i];
for (i = 1; i <= m; ++i) {
cin >> c1 >> c2;
if ((u[c1] + 1) % h == u[c2]) addEdge(c1, c2);
if ((u[c2] + 1) % h == u[c1]) addEdge(c2, c1);
}
for (i = 1; i <= n; ++i) dfs(i);
memset(vis, 0, sizeof vis);
reverse(ord.begin(), ord.end());
nr = 0;
for (auto v : ord) {
++nr;
getComp(v);
}
for (i = 1; i <= n; ++i)
for (auto j : adj[i])
if (comp[i] != comp[j]) bad[comp[i]] = true;
ans = -1;
for (i = 1; i <= n; ++i)
if (sz[i] > 0 && !bad[i]) {
if (ans == -1 || sz[ans] > sz[i]) ans = i;
}
cout << sz[ans] << '\n';
for (i = 1; i <= n; ++i)
if (comp[i] == ans) cout << i << ' ';
cout << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200050;
int d[N], tim, t[N], siz[N], bl[N], st[N], dfn[N], low[N], ins[N], top, tot;
struct graph {
int nn[N][2], cnt, head[N];
void link(int u, int v) {
nn[++cnt][1] = v, nn[cnt][0] = head[u], head[u] = cnt;
return;
}
void tarjan(int x) {
dfn[x] = low[x] = ++tim, st[++top] = x, ins[x] = 1;
for (int i = head[x], y; i; i = nn[i][0])
if (!dfn[y = nn[i][1]])
tarjan(y), low[x] = (low[x] < low[y] ? low[x] : low[y]);
else if (ins[y])
low[x] = (low[x] < dfn[y] ? low[x] : dfn[y]);
if (low[x] == dfn[x]) {
++tot;
do bl[st[top]] = tot, ++siz[tot], ins[st[top]] = 0;
while (st[top--] != x);
}
return;
}
} G[2];
int main() {
int n, m, h, u, v;
cin >> n >> m >> h;
for (int i = 1; i <= n; ++i) scanf("%d", &t[i]);
for (int i = 1; i <= m; ++i) {
scanf("%d%d", &u, &v);
if ((t[u] + 1) % h == t[v]) G[0].link(u, v);
if ((t[v] + 1) % h == t[u]) G[0].link(v, u);
}
for (int i = 1; i <= n; ++i)
if (!dfn[i]) G[0].tarjan(i);
for (int x = 1; x <= n; ++x)
for (int i = G[0].head[x], y; i; i = G[0].nn[i][0])
if (bl[y = G[0].nn[i][1]] != bl[x]) ++d[bl[x]];
int mn = 1e9, id = 0;
for (int i = 1; i <= tot; ++i)
if (!d[i] && siz[i] < mn) mn = siz[i], id = i;
cout << siz[id] << endl;
for (int i = 1; i <= n; ++i)
if (bl[i] == id) printf("%d ", i);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int t[110000], c[110000][2];
struct node {
int y, next;
} a[210000];
int len, last[110000], d[110000];
int dfn[110000], low[110000], ans2[110000];
int f[110000], size[110000];
int mymin(int x, int y) { return x < y ? x : y; }
void ins(int x, int y) {
a[++len].y = y;
a[len].next = last[x];
last[x] = len;
}
int sum = 0, tot = 0, ans = 999999999;
void dfs(int x) {
dfn[x] = low[x] = ++sum;
d[++tot] = x;
for (int k = last[x]; k; k = a[k].next) {
int y = a[k].y;
if (dfn[y] == 0) dfs(y);
low[x] = mymin(low[x], low[y]);
}
if (dfn[x] == low[x]) {
int sum1 = 0;
while (d[tot] != x) {
f[d[tot]] = x;
sum1++;
tot--;
}
tot--;
sum1++;
size[x] = sum1;
f[x] = x;
}
}
int main() {
int n, m, h;
scanf("%d%d%d", &n, &m, &h);
for (int i = 1; i <= n; i++) scanf("%d", &t[i]);
len = 0;
memset(last, 0, sizeof(last));
for (int i = 1; i <= m; i++) {
scanf("%d%d", &c[i][0], &c[i][1]);
if ((t[c[i][0]] + 1) % h == t[c[i][1]]) ins(c[i][0], c[i][1]);
if ((t[c[i][1]] + 1) % h == t[c[i][0]]) ins(c[i][1], c[i][0]);
}
memset(dfn, 0, sizeof(dfn));
for (int i = 1; i <= n; i++)
if (dfn[i] == 0) dfs(i);
len = 0;
memset(last, 0, sizeof(last));
for (int i = 1; i <= m; i++) {
int x = f[c[i][0]], y = f[c[i][1]];
if (x != y) {
if ((t[c[i][0]] + 1) % h == t[c[i][1]]) ins(x, y);
if ((t[c[i][1]] + 1) % h == t[c[i][0]]) ins(y, x);
}
}
int ans = 999999999, ans2;
for (int i = 1; i <= n; i++) {
if (f[i] == i && last[i] == 0 && ans > size[i]) ans = size[i], ans2 = i;
}
printf("%d\n", size[ans2]);
for (int i = 1; i <= n; i++)
if (f[i] == ans2) printf("%d\n", i);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int hr[100100];
long long dp[100100];
int n, m, h;
vector<vector<int> > gr(100100);
vector<vector<int> > inv(100100);
vector<vector<int> > GR(100100);
bool used[100100];
vector<int> ord;
vector<int> erase;
void dfs(int nod) {
used[nod] = true;
for (auto &x : gr[nod]) {
if (!used[x]) {
dfs(x);
}
}
ord.push_back(nod);
}
vector<int> ctc[100100];
int cul[100100];
void DFS(int nod, int col) {
used[nod] = true;
ctc[col].push_back(nod);
cul[nod] = col;
for (auto &x : inv[nod]) {
if (!used[x]) {
DFS(x, col);
}
}
}
void Dfs(int nod) {
used[nod] = true;
dp[nod] = 1LL * ctc[nod].size();
for (auto &x : GR[nod]) {
if (!used[x]) {
Dfs(x);
}
dp[nod] += dp[x];
}
}
void ddffss(int nod) {
used[nod] = true;
for (auto &x : ctc[nod]) {
cout << x << " ";
}
for (auto &x : GR[nod]) {
if (!used[x]) {
ddffss(x);
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> m >> h;
for (int i = 1; i <= n; i++) {
cin >> hr[i];
}
for (int i = 1; i <= m; i++) {
int a, b;
cin >> a >> b;
int A = hr[a] + 1;
int B = hr[b] + 1;
A %= h;
B %= h;
if (A == hr[b]) {
gr[a].push_back(b);
inv[b].push_back(a);
}
if (B == hr[a]) {
gr[b].push_back(a);
inv[a].push_back(b);
}
}
for (int i = 1; i <= n; i++) {
if (!used[i]) {
dfs(i);
}
}
reverse(ord.begin(), ord.end());
for (int i = 1; i <= n; i++) {
used[i] = false;
}
int cont = 0;
for (auto &x : ord) {
if (!used[x]) {
cont++;
DFS(x, cont);
}
}
for (int i = 1; i <= n; i++) {
used[i] = false;
}
for (int i = 1; i <= cont; i++) {
erase.clear();
used[i] = true;
erase.push_back(i);
for (auto &x : ctc[i]) {
for (auto &y : gr[x]) {
if (!used[cul[y]]) {
erase.push_back(cul[y]);
used[cul[y]] = true;
GR[i].push_back(cul[y]);
}
}
}
for (auto &x : erase) {
used[x] = false;
}
}
for (int i = 1; i <= cont; i++) {
if (!used[i]) {
Dfs(i);
}
}
long long MIN = 1e18;
int go = 0;
for (int i = 1; i <= cont; i++) {
if (MIN > dp[i]) {
MIN = dp[i];
go = i;
}
}
for (int i = 1; i <= cont; i++) {
used[i] = false;
}
cout << MIN << '\n';
ddffss(go);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int NMAX = 100010;
int N, M, H;
int V[NMAX];
vector<int> G[NMAX];
stack<int> path;
vector<vector<int>> SCC;
bool inStack[NMAX];
int where[NMAX], DFT[NMAX], lowLink[NMAX], currTime;
void doTarjan(int node) {
DFT[node] = lowLink[node] = ++currTime;
path.push(node);
inStack[node] = 1;
for (int next : G[node]) {
if (!DFT[next]) {
doTarjan(next);
lowLink[node] = min(lowLink[node], lowLink[next]);
} else if (inStack[next]) {
lowLink[node] = min(lowLink[node], lowLink[next]);
}
}
if (lowLink[node] == DFT[node]) {
int kCurrScc = SCC.size();
vector<int> currScc;
int currNode;
do {
currNode = path.top();
path.pop();
inStack[currNode] = 0;
where[currNode] = kCurrScc;
currScc.push_back(currNode);
} while (currNode != node);
SCC.push_back(currScc);
}
}
int main() {
cin >> N >> M >> H;
for (int i = 1; i <= N; ++i) cin >> V[i];
for (int i = 0; i < M; ++i) {
int x, y;
cin >> x >> y;
if ((V[x] + 1) % H == V[y]) {
G[x].push_back(y);
}
if ((V[y] + 1) % H == V[x]) {
G[y].push_back(x);
}
}
for (int i = 1; i <= N; ++i)
if (!DFT[i]) doTarjan(i);
int minScc = -1;
for (int i = 0; i < (int)SCC.size(); ++i) {
if (minScc == -1 || SCC[i].size() < SCC[minScc].size()) {
bool ok = 1;
for (int node : SCC[i]) {
for (int next : G[node]) {
if (where[next] != i) {
ok = 0;
break;
}
}
if (!ok) break;
}
if (ok) minScc = i;
}
}
cout << SCC[minScc].size() << '\n';
for (int i : SCC[minScc]) cout << i << ' ';
cout << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int low[100000 + 10], dfn[100000 + 10], sta[100000 + 10], t, clo,
sccno[100000 + 10], scnt, outd[100000 + 10];
struct EDGE {
int u, v, next;
void deal() {
if (sccno[u] != sccno[v]) outd[sccno[u]]++;
}
} edge[2 * 100000 + 10];
int head[100000 + 10], pp, sz[100000 + 10];
void adde(int u, int v) {
edge[++pp] = (EDGE){u, v, head[u]};
head[u] = pp;
}
void dfs(int u) {
dfn[u] = low[u] = ++clo;
sta[++t] = u;
for (int i = head[u]; i; i = edge[i].next) {
int v = edge[i].v;
if (!dfn[v])
dfs(v), low[u] = min(low[u], low[v]);
else if (!sccno[v])
low[u] = min(low[u], dfn[v]);
}
if (low[u] == dfn[u]) {
scnt++;
for (;;) {
int v = sta[t--];
sccno[v] = scnt;
sz[scnt]++;
if (u == v) break;
}
}
}
int c[100000 + 10];
bool judge(int u, int v, int h) { return (c[u] + 1) % h == c[v]; }
int main() {
int n, m, h;
scanf("%d%d%d", &n, &m, &h);
for (int i = 1; i <= n; i++) scanf("%d", c + i);
while (m--) {
int u, v;
scanf("%d%d", &u, &v);
if (judge(u, v, h)) adde(u, v);
if (judge(v, u, h)) adde(v, u);
}
for (int i = 1; i <= n; i++)
if (!dfn[i]) dfs(i);
for (int i = 1; i <= pp; i++) edge[i].deal();
int ans, cnt = n + 1;
for (int i = 1; i <= scnt; i++)
if (!outd[i] && sz[i] < cnt) ans = i, cnt = sz[i];
printf("%d\n", cnt);
for (int i = 1; i <= n; i++)
if (sccno[i] == ans) printf("%d ", i);
putchar('\n');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5;
int n, m, h, c1, c2, t[N];
int cnt[N], cmp[N], out[N];
vector<int> g[N], rg[N];
bool vis[N];
vector<int> vc;
int get_nxt(int x) { return (x + 1) % h; }
void dfs(int u) {
vis[u] = 1;
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (!vis[v]) dfs(v);
}
vc.push_back(u);
}
void rdfs(int u, int k) {
vis[u] = 1;
cmp[u] = k;
cnt[k]++;
for (int i = 0; i < rg[u].size(); i++) {
int v = rg[u][i];
if (!vis[v]) rdfs(v, k);
}
}
void solve() {
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= n; i++) {
if (!vis[i]) dfs(i);
}
memset(vis, 0, sizeof(vis));
int k = 0;
for (int i = vc.size() - 1; i >= 0; i--) {
int v = vc[i];
if (!vis[v]) rdfs(v, ++k);
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j < g[i].size(); j++) {
int v = g[i][j];
if (cmp[i] != cmp[v]) {
out[cmp[i]]++;
}
}
}
int ans = -1, num = N;
for (int i = 1; i <= k; i++) {
if (out[i] != 0) continue;
if (cnt[i] < num) {
num = cnt[i];
ans = i;
}
}
printf("%d\n", num);
for (int i = 1; i <= n; i++) {
if (cmp[i] == ans) {
printf("%d ", i);
}
}
printf("\n");
}
int main() {
scanf("%d %d %d", &n, &m, &h);
for (int i = 1; i <= n; i++) {
scanf("%d", &t[i]);
}
for (int i = 1; i <= m; i++) {
scanf("%d %d", &c1, &c2);
if (get_nxt(t[c1]) == t[c2]) {
g[c1].push_back(c2);
rg[c2].push_back(c1);
}
if (get_nxt(t[c2]) == t[c1]) {
g[c2].push_back(c1);
rg[c1].push_back(c2);
}
}
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
template <class T>
struct rge {
T b, e;
};
template <class T>
rge<T> range(T i, T j) {
return rge<T>{i, j};
}
template <class T>
auto dud(T *x) -> decltype(cerr << *x, 0);
template <class T>
char dud(...);
struct debug {
template <class T>
debug &operator<<(const T &) {
return *this;
}
};
struct Dsu {
vector<int> pr, tot;
Dsu(int n = 0) : pr(n + 5), tot(n + 5, 1) { iota(begin(pr), end(pr), 0); }
int find(int u) { return pr[u] == u ? u : pr[u] = find(pr[u]); }
void unite(int u, int v) {
u = find(u), v = find(v);
if (u != v) pr[v] = u, tot[u] += tot[v];
}
bool same(int u, int v) { return find(u) == find(v); }
int operator[](int u) { return find(u); }
} dsu;
const int N = 1e5 + 5, inf = 2e9;
vector<int> graph[N], dag[N];
int tin[N], fup[N];
bool still[N];
stack<int> stk;
int timer = 0;
void tarjan(int u) {
tin[u] = fup[u] = ++timer;
still[u] = true;
stk.push(u);
for (int v : graph[u]) {
if (!tin[v]) tarjan(v);
if (still[v]) fup[u] = min(fup[u], fup[v]);
}
if (fup[u] == tin[u]) {
int v;
do {
v = stk.top();
stk.pop();
still[v] = false;
dsu.unite(u, v);
} while (v != u);
}
}
int n, m, h, off[N], outdeg[N];
struct Edge {
int u, v;
};
vector<Edge> edges;
void reset() {
for (auto u = (1) - ((1) > (n + 1)); u != n + 1 - ((1) > (n + 1));
u += 1 - 2 * ((1) > (n + 1))) {
graph[u].clear();
tin[u] = fup[u] = still[u] = off[u] = outdeg[u] = 0;
}
timer = 0;
stk = stack<int>();
dsu = Dsu(n);
edges.clear();
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
while (cin >> n >> m >> h) {
reset();
for (auto u = (1) - ((1) > (n + 1)); u != n + 1 - ((1) > (n + 1));
u += 1 - 2 * ((1) > (n + 1)))
cin >> off[u];
while (m--) {
int u, v;
cin >> u >> v;
if ((off[u] + 1) % h == off[v])
graph[u].push_back(v), edges.push_back({u, v});
if ((off[v] + 1) % h == off[u])
graph[v].push_back(u), edges.push_back({v, u});
}
for (auto u = (1) - ((1) > (n + 1)); u != n + 1 - ((1) > (n + 1));
u += 1 - 2 * ((1) > (n + 1)))
if (!tin[u]) tarjan(u);
for (auto e : edges) {
int u = dsu[e.u], v = dsu[e.v];
if (!dsu.same(u, v)) dag[u].push_back(v), outdeg[u]++;
}
debug() << " "
<< "range(outdeg + 1, outdeg + n + 1)"
": "
<< (range(outdeg + 1, outdeg + n + 1)) << " ";
for (auto u = (1) - ((1) > (n + 1)); u != n + 1 - ((1) > (n + 1));
u += 1 - 2 * ((1) > (n + 1)))
debug() << " "
<< "dag[u]"
": "
<< (dag[u]) << " ";
int mn = inf, id;
for (auto u = (1) - ((1) > (n + 1)); u != n + 1 - ((1) > (n + 1));
u += 1 - 2 * ((1) > (n + 1)))
if (u == dsu[u])
if (dsu.tot[u] < mn && !outdeg[u]) mn = dsu.tot[u], id = u;
cout << mn << '\n';
for (auto u = (1) - ((1) > (n + 1)); u != n + 1 - ((1) > (n + 1));
u += 1 - 2 * ((1) > (n + 1)))
if (dsu[u] == id) cout << u << " ";
cout << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class TCost>
class Graph {
public:
struct Edge {
long from, to;
TCost cost;
Edge(long _from, long _to, TCost _cost)
: from(_from), to(_to), cost(_cost){};
};
long size;
bool zeroIndexed;
vector<Edge> edges;
vector<vector<pair<long, TCost>>> adjacencyList;
Graph(){};
Graph(long _size, bool _zeroIndexed = true) {
zeroIndexed = _zeroIndexed;
if (!zeroIndexed) _size++;
size = _size;
adjacencyList.resize(_size);
};
~Graph() = default;
};
template <class TCost>
class DirectedGraph : public Graph<TCost> {
public:
DirectedGraph(){};
DirectedGraph(long _size, bool _zeroIndexed)
: Graph<TCost>(_size, _zeroIndexed){};
DirectedGraph(long _size) : Graph<TCost>(_size){};
void addEdge(long from, long to, TCost cost = 0) {
this->edges.push_back({from, to, cost});
this->adjacencyList[from].push_back({to, cost});
}
void printEdges() {
for (auto edge : this->edges) {
cout << edge.from << ' ' << edge.to << endl;
}
}
};
template <class TCost>
class SCC {
public:
static void TarjanRecursion(long v, long &indexCount, vector<long> &index,
vector<long> &low, stack<long> &S,
DirectedGraph<TCost> &graph,
vector<bool> &onStack,
vector<vector<long>> &components) {
index[v] = indexCount;
low[v] = indexCount;
indexCount++;
S.push(v);
onStack[v] = true;
for (auto edge : graph.adjacencyList[v]) {
long w = edge.first;
if (!index[w]) {
TarjanRecursion(w, indexCount, index, low, S, graph, onStack,
components);
low[v] = min(low[v], low[w]);
} else if (onStack[w]) {
low[v] = min(low[v], index[w]);
}
}
if (low[v] == index[v]) {
vector<long> component;
long w;
do {
w = S.top();
S.pop();
onStack[w] = false;
component.push_back(w);
} while (w != v);
components.push_back(component);
}
}
static vector<vector<long>> Tarjan(DirectedGraph<TCost> graph) {
long indexCount = 1;
vector<long> index(graph.size), low(graph.size);
vector<bool> onStack(graph.size);
stack<long> S;
vector<vector<long>> components;
for (long i = (graph.zeroIndexed ? 0 : 1); i < graph.size; i++) {
if (!index[i]) {
TarjanRecursion(i, indexCount, index, low, S, graph, onStack,
components);
}
}
return components;
}
};
long long n, m, h, u[100001], out[100001], sccnr[1000001], discard[100001];
int main() {
ios_base::sync_with_stdio(false);
cout.precision(30);
cout.tie(0);
cin.tie(0);
cin >> n >> m >> h;
for (__typeof(n + 1) i = (1) - ((1) > (n + 1));
i != (n + 1) - ((1) > (n + 1)); i += 1 - 2 * ((1) > (n + 1)))
cin >> u[i];
DirectedGraph<long long> g(n, false);
for (__typeof(m) i = (0) - ((0) > (m)); i != (m) - ((0) > (m));
i += 1 - 2 * ((0) > (m))) {
long long c1, c2;
cin >> c1 >> c2;
if ((u[c1] + 1) % h == u[c2]) g.addEdge(c1, c2), out[c1]++;
if ((u[c2] + 1) % h == u[c1]) g.addEdge(c2, c1), out[c2]++;
}
vector<vector<long>> rs = SCC<long long>::Tarjan(g);
for (__typeof(rs.size()) i = (0) - ((0) > (rs.size()));
i != (rs.size()) - ((0) > (rs.size()));
i += 1 - 2 * ((0) > (rs.size()))) {
for (auto x : rs[i]) {
sccnr[x] = i;
}
}
for (auto edge : g.edges) {
if (sccnr[edge.from] != sccnr[edge.to]) {
discard[sccnr[edge.from]] = 1;
}
}
long long best = INT32_MAX;
for (__typeof(rs.size()) i = (0) - ((0) > (rs.size()));
i != (rs.size()) - ((0) > (rs.size())); i += 1 - 2 * ((0) > (rs.size())))
if (!discard[i] && rs[i].size() < best) best = (long long)rs[i].size();
cout << best << endl;
for (auto x : rs) {
if (x.size() == best) {
for (auto y : x) cout << y << ' ';
return 0;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 100;
int m, n, h;
int t[maxn];
int first[maxn * 2], nxt[maxn * 2], des[maxn * 2], tot;
int dfn[maxn], low[maxn], dft;
bool d[maxn];
int flag[maxn], cnt[maxn], scc;
stack<int> stk;
inline void add(int x, int y) {
tot++;
des[tot] = y;
nxt[tot] = first[x];
first[x] = tot;
}
void tar(int node) {
dfn[node] = low[node] = ++dft;
stk.push(node);
for (int t = first[node]; t; t = nxt[t]) {
int v = des[t];
if (!dfn[v]) tar(v);
low[node] = min(low[node], low[v]);
}
if (dfn[node] == low[node]) {
scc++;
while (true) {
int temp = stk.top();
flag[temp] = scc;
cnt[scc]++;
stk.pop();
if (temp == node) break;
}
}
}
int main() {
scanf("%d%d%d", &n, &m, &h);
for (int i = 1; i <= n; i++) {
scanf("%d", t + i);
}
for (int i = 0; i < m; i++) {
int u1, u2;
scanf("%d%d", &u1, &u2);
if (t[u1] == (t[u2] + 1) % h) add(u2, u1);
if (t[u2] == (t[u1] + 1) % h) add(u1, u2);
}
for (int i = 1; i <= n; i++) {
if (!dfn[i]) tar(i);
}
for (int i = 1; i <= n; i++) {
for (int t = first[i]; t; t = nxt[t]) {
if (flag[i] == flag[des[t]])
continue;
else {
d[flag[i]]++;
}
}
}
cnt[0] = n + 1;
int ans = 0;
for (int i = 1; i <= scc; i++) {
if (d[i] == 0 && cnt[i] < cnt[ans]) {
ans = i;
}
}
cout << cnt[ans] << endl;
for (int i = 1; i <= n; i++) {
if (flag[i] == ans) {
cout << i << " ";
}
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
template <class T, class U>
inline void add_self(T &a, U b) {
a += b;
if (a >= mod) a -= mod;
if (a < 0) a += mod;
}
template <class T, class U>
inline void min_self(T &x, U y) {
if (y < x) x = y;
}
template <class T, class U>
inline void max_self(T &x, U y) {
if (y > x) x = y;
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
cout << t;
;
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
template <class T, class U>
void print_m(const map<T, U> &m, int w = 3) {
if (m.empty()) {
cout << "Empty" << endl;
return;
}
for (auto x : m) cout << "(" << x.first << ": " << x.second << ")," << endl;
cout << endl;
}
template <class T, class U>
void debp(const pair<T, U> &pr, bool end_line = 1) {
cout << "{" << pr.first << " " << pr.second << "}";
cout << (end_line ? "\n" : ", ");
}
template <class T>
void print_vp(const T &vp, int sep_line = 0) {
if (vp.empty()) {
cout << "Empty" << endl;
return;
}
if (!sep_line) cout << "{ ";
for (auto x : vp) debp(x, sep_line);
if (!sep_line) cout << "}\n";
cout << endl;
}
template <typename T>
void print(const T &v, bool show_index = false) {
int w = 2;
if (show_index) {
for (int i = 0; i < int((v).size()); i++) cout << setw(w) << i << " ";
cout << endl;
}
for (auto &el : v) cout << setw(w) << el << " ";
cout << endl;
}
template <typename T>
void print_vv(const T &vv) {
if (int((vv).size()) == 0) {
cout << "Empty" << endl;
return;
}
int w = 3;
cout << setw(w) << " ";
for (int j = 0; j < int((*vv.begin()).size()); j++)
cout << setw(w) << j << " ";
cout << endl;
int i = 0;
for (auto &v : vv) {
cout << i++ << " {";
for (auto &el : v) cout << setw(w) << el << " ";
cout << "},\n";
}
cout << endl;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
print(v);
return os;
};
template <typename T>
ostream &operator<<(ostream &os, const vector<vector<T>> &vv) {
print_vv(vv);
return os;
};
template <class T, class U>
ostream &operator<<(ostream &os, const map<T, U> &m) {
print_m(m);
return os;
};
template <class T, class U>
ostream &operator<<(ostream &os, const pair<T, U> &pr) {
debp(pr);
return os;
};
template <class T, class U>
ostream &operator<<(ostream &os, const vector<pair<T, U>> &vp) {
print_vp(vp);
return os;
};
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m, H;
while (cin >> n >> m >> H) {
vector<int> a(n + 1);
for (int i = int(1); i < int(n + 1); i++) cin >> a[i];
vector<vector<int>> adj(n + 1), radj(n + 1);
auto add = [&](int x, int y) {
adj[x].push_back(y);
radj[y].push_back(x);
};
for (int i = 0; i < int(m); i++) {
int x, y;
cin >> x >> y;
if ((a[x] + 1) % H == a[y]) add(x, y);
if ((a[y] + 1) % H == a[x]) add(y, x);
}
vector<bool> vis(n + 1);
vector<int> order;
function<void(int)> dfs1 = [&](int node) {
vis[node] = 1;
for (auto ad : adj[node]) {
if (!vis[ad]) dfs1(ad);
}
order.push_back(node);
};
for (int i = int(1); i < int(n + 1); i++) {
if (!vis[i]) dfs1(i);
}
reverse(order.begin(), order.end());
vis.assign(n + 1, 0);
vector<int> comp;
vector<vector<int>> comps;
vector<int> color(n + 1, -1);
int C = 0;
function<void(int)> dfs2 = [&](int node) {
vis[node] = 1;
comp.push_back(node);
color[node] = C;
for (auto ad : radj[node]) {
if (!vis[ad]) {
dfs2(ad);
}
}
};
for (auto node : order) {
if (!vis[node]) {
comp.clear();
dfs2(node);
comps.push_back(comp);
++C;
}
}
vector<int> bad(C);
for (int node = int(1); node < int(n + 1); node++) {
for (auto ad : adj[node]) {
if (color[node] != color[ad]) {
bad[color[node]] = 1;
}
}
}
vector<int> ans;
for (int c = 0; c < int(C); c++) {
if (bad[c]) continue;
if (ans.empty() || int((comps[c]).size()) < int((ans).size()))
ans = comps[c];
}
cout << int((ans).size()) << "\n";
print(ans);
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(3, "Ofast", "inline")
const int MAXN = 1e5 + 5;
const int INF = 0x3f3f3f3f;
struct Edge {
int x, y, nxt;
} e[MAXN << 1];
bool instack[MAXN];
int a[MAXN], head[MAXN], node[MAXN];
int n, m, h, cnt, tot, top, ans, TimeClock;
int belong[MAXN], dfn[MAXN], low[MAXN], stack[MAXN], size[MAXN];
inline int read() {
int X = 0, flag = 0;
char ch = 0;
while (!isdigit(ch)) flag |= ch == '-', ch = getchar();
while (isdigit(ch)) X = (X << 3) + (X << 1) + (ch ^ 48), ch = getchar();
return flag ? -X : X;
}
inline void write(int x) {
if (x < 0) x = -x, putchar('-');
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
inline void add_edge(int x, int y) {
e[++cnt].x = x, e[cnt].y = y;
e[cnt].nxt = head[x], head[x] = cnt;
}
inline void Tarjan(int x) {
low[x] = dfn[x] = ++TimeClock;
stack[++top] = x, instack[x] = true;
for (register int i = head[x]; i; i = e[i].nxt) {
if (!dfn[e[i].y]) {
Tarjan(e[i].y);
low[x] = std::min(low[x], low[e[i].y]);
} else {
if (instack[e[i].y]) low[x] = std::min(low[x], dfn[e[i].y]);
}
}
if (dfn[x] == low[x]) {
tot++;
while (stack[top + 1] != x) {
size[tot]++;
belong[stack[top]] = tot;
instack[stack[top--]] = false;
}
}
}
signed main() {
n = read(), m = read(), h = read();
for (int i = 1; i <= n; i++) a[i] = read();
for (int i = 1, x, y; i <= m; i++) {
x = read(), y = read();
if ((a[x] + 1) % h == a[y]) add_edge(x, y);
if ((a[y] + 1) % h == a[x]) add_edge(y, x);
}
for (int i = 1; i <= n; i++)
if (!dfn[i]) Tarjan(i);
for (int i = 1, x, y; i <= cnt; i++) {
x = belong[e[i].x], y = belong[e[i].y];
if (x ^ y) node[x]++;
}
size[0] = INF;
for (int i = 1; i <= tot; i++)
if (!node[i])
if (size[i] < size[ans]) ans = i;
write(size[ans]), putchar('\n');
for (int i = 1; i <= n; i++)
if (belong[i] == ans) write(i), putchar(' ');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, h, a, b, T[100005], ID[100005], nrout[100005];
vector<int> v[100005], v2[100005];
bool uz[100005];
vector<vector<int> > ans;
vector<int> H;
void dfs(int nod) {
uz[nod] = 1;
for (auto it : v[nod]) {
if (uz[it]) continue;
dfs(it);
}
H.push_back(nod);
}
void dfs2(int nod) {
uz[nod] = 1;
for (auto it : v2[nod]) {
if (uz[it]) continue;
dfs2(it);
}
ans.back().push_back(nod);
}
int main() {
cin >> n >> m >> h;
for (int i = 1; i <= n; i++) {
cin >> T[i];
}
for (int i = 1; i <= m; i++) {
cin >> a >> b;
if ((T[a] + 1) % h == T[b]) v[a].push_back(b), v2[b].push_back(a);
if ((T[b] + 1) % h == T[a]) v[b].push_back(a), v2[a].push_back(b);
}
for (int i = 1; i <= n; i++)
if (!uz[i]) dfs(i);
memset(uz, 0, sizeof(uz));
for (auto it = H.rbegin(); it != H.rend(); it++) {
if (!uz[*it]) {
ans.push_back(*new vector<int>);
dfs2(*it);
}
}
for (int i = 0; i < ans.size(); i++) {
for (auto it : ans[i]) {
ID[it] = i;
}
}
for (int i = 1; i <= n; i++) {
for (auto it : v[i]) {
if (ID[i] != ID[it]) nrout[ID[i]]++;
}
}
int mn = 1e9, sav = 0;
for (int i = 0; i < ans.size(); i++) {
if (nrout[i] == 0) {
if (ans[i].size() < mn) {
mn = ans[i].size();
sav = i;
}
}
}
cout << mn << '\n';
for (auto it : ans[sav]) cout << it << ' ';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int hr[100100];
int n, m, h;
vector<vector<int> > gr(100100);
vector<vector<int> > inv(100100);
bool used[100100];
vector<int> ord;
void dfs(int nod) {
used[nod] = true;
for (auto &x : gr[nod]) {
if (!used[x]) {
dfs(x);
}
}
ord.push_back(nod);
}
vector<int> ctc[100100];
int cul[100100];
void DFS(int nod, int col) {
used[nod] = true;
ctc[col].push_back(nod);
cul[nod] = col;
for (auto &x : inv[nod]) {
if (!used[x]) {
DFS(x, col);
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> m >> h;
for (int i = 1; i <= n; i++) {
cin >> hr[i];
}
for (int i = 1; i <= m; i++) {
int a, b;
cin >> a >> b;
int A = hr[a] + 1;
int B = hr[b] + 1;
A %= h;
B %= h;
if (A == hr[b]) {
gr[a].push_back(b);
inv[b].push_back(a);
}
if (B == hr[a]) {
gr[b].push_back(a);
inv[a].push_back(b);
}
}
for (int i = 1; i <= n; i++) {
if (!used[i]) {
dfs(i);
}
}
reverse(ord.begin(), ord.end());
for (int i = 1; i <= n; i++) {
used[i] = false;
}
int cont = 0;
for (auto &x : ord) {
if (!used[x]) {
cont++;
DFS(x, cont);
}
}
int MIN = 1e9;
int go = 0;
for (int i = 1; i <= cont; i++) {
bool ok = true;
for (auto &x : ctc[i]) {
for (auto &y : gr[x]) {
if (cul[y] == i) {
continue;
}
ok = false;
}
}
if (ok) {
if (MIN > ctc[i].size()) {
MIN = ctc[i].size();
go = i;
}
}
}
cout << MIN << '\n';
for (auto &x : ctc[go]) {
cout << x << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200005;
int n, m, h;
namespace Graph {
int ecnt, head[MAXN], nxt[MAXN], to[MAXN];
inline void init() {
ecnt = 0;
memset(head, -1, sizeof head);
}
inline void adde(int u, int v) {
to[++ecnt] = v;
nxt[ecnt] = head[u];
head[u] = ecnt;
}
} // namespace Graph
int Index, DFN[MAXN], LOW[MAXN];
int scc, sccno[MAXN], val[MAXN];
stack<int> stk;
void tarjan(int u) {
using namespace Graph;
DFN[u] = LOW[u] = ++Index;
stk.push(u);
int v;
for (int i = head[u]; ~i; i = nxt[i]) {
v = to[i];
if (!DFN[v]) {
tarjan(v);
LOW[u] = min(LOW[u], LOW[v]);
} else if (!sccno[v]) {
LOW[u] = min(LOW[u], DFN[v]);
}
}
if (DFN[u] == LOW[u]) {
++scc;
do {
v = stk.top();
stk.pop();
sccno[v] = scc;
++val[scc];
} while (u != v);
}
}
int cnt, X[MAXN], Y[MAXN], tim[MAXN], outdu[MAXN];
int main() {
scanf("%d%d%d", &n, &m, &h);
Graph::init();
for (int i = 1; i <= n; ++i) scanf("%d", &tim[i]);
for (int i = 1; i <= m; ++i) {
int x, y;
scanf("%d%d", &x, &y);
if (tim[x] + 1 == tim[y] || (tim[x] == h - 1 && tim[y] == 0)) {
Graph::adde(x, y);
X[++cnt] = x;
Y[cnt] = y;
}
if (tim[y] + 1 == tim[x] || (tim[y] == h - 1 && tim[x] == 0)) {
Graph::adde(y, x);
X[++cnt] = y;
Y[cnt] = x;
}
}
for (int i = 1; i <= n; ++i)
if (!DFN[i]) tarjan(i);
for (int i = 1; i <= cnt; ++i) {
int x = sccno[X[i]], y = sccno[Y[i]];
if (x != y) ++outdu[x];
}
int idx, ans = n;
for (int i = 1; i <= scc; ++i)
if (!outdu[i] && ans > val[i]) idx = i, ans = val[i];
printf("%d\n", ans);
if (ans == n) {
for (int i = 1; i <= n; ++i) printf("%d ", i);
} else {
for (int i = 1; i <= n; ++i)
if (sccno[i] == idx) printf("%d ", i);
}
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 15;
vector<int> adj[N];
stack<int> st;
int order[N], scc[N], sz[N];
int spos = 0, pos = 1;
int dfs(int root) {
int ret = order[root] = pos++;
st.push(root);
for (int i = 0; i < adj[root].size(); ++i) {
int u = adj[root][i];
if (!order[u]) {
ret = min(ret, dfs(u));
} else if (scc[u] == -1)
ret = min(ret, order[u]);
}
if (ret == order[root]) {
while (1) {
int u = st.top();
st.pop();
scc[u] = spos;
++sz[spos];
if (u == root) break;
}
++spos;
}
return ret;
}
int h[N];
int check(int i, int j, int H) {
if ((h[i] + 1) % H == h[j]) return 1;
return 0;
}
int deg[N];
int main() {
int n, m, H;
memset(scc, -1, sizeof(scc));
scanf("%d%d%d", &n, &m, &H);
for (int i = 1; i <= n; ++i) {
scanf("%d", &h[i]);
}
int u, v;
for (int i = 0; i < m; ++i) {
scanf("%d%d", &u, &v);
if (check(u, v, H)) adj[u].push_back(v);
if (check(v, u, H)) adj[v].push_back(u);
}
for (int i = 1; i <= n; ++i)
if (!order[i]) {
dfs(i);
}
for (int i = 1; i <= n; ++i) {
for (int j = 0; j < adj[i].size(); ++j) {
u = adj[i][j];
if (scc[u] != scc[i]) {
++deg[scc[i]];
}
}
}
int ss = 1e9, id;
for (int i = 0; i < spos; ++i) {
if (ss > sz[i] && deg[i] == 0) {
ss = sz[i];
id = i;
}
}
cout << ss << endl;
for (int i = 1; i <= n; ++i)
if (scc[i] == id) printf("%d ", i);
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, h;
int u[200105];
vector<int> v[200105 << 1];
int ta(int x) {
if (x <= n) return n + x;
return x - n;
}
int head[200105], nxt[400105], to[400105], cnt;
int dt[200105], low[200105], T, col[200105], scc;
int stk[200105], top, instk[200105];
void init() {
cnt = 0;
memset(head, 0, sizeof head);
T = 0;
memset(dt, 0, sizeof dt);
scc = 0;
}
void add(int x, int y) {
to[++cnt] = y;
nxt[cnt] = head[x], head[x] = cnt;
}
void tarjan(int x) {
dt[x] = low[x] = ++T;
stk[top++] = x;
instk[x] = 1;
for (int i = head[x]; i; i = nxt[i]) {
int y = to[i];
if (!dt[y]) {
tarjan(y);
low[x] = min(low[x], low[y]);
} else if (instk[y])
low[x] = min(low[x], dt[y]);
}
if (dt[x] == low[x]) {
scc++;
int y;
do {
y = stk[--top];
instk[y] = 0;
col[y] = scc;
} while (y != x);
}
}
vector<int> w[200105];
int gas[200105];
int anscnt;
int rans[200105];
int main() {
scanf("%d %d %d", &n, &m, &h);
for (int i = 1; i <= n; i++) scanf("%d", &u[i]);
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d %d", &x, &y);
if (u[x] == u[y]) {
add(x, ta(y)), add(ta(y), x);
add(y, ta(x)), add(ta(x), y);
} else {
if (u[x] - u[y] == 1 || u[x] == 0 && u[y] == h - 1) {
add(y, x), add(ta(x), ta(y));
}
if (u[y] - u[x] == 1 || u[y] == 0 && u[x] == h - 1) {
add(x, y), add(ta(y), ta(x));
}
}
}
for (int i = 1; i <= n * 2; i++)
if (!dt[i]) tarjan(i);
for (int x = 1; x <= n * 2; x++) {
for (int i = head[x]; i; i = nxt[i]) {
int y = to[i];
if (col[x] != col[y]) {
w[col[x]].push_back(col[y]);
}
}
}
for (int i = 1; i <= n; i++) gas[col[i]]++;
int mn = n + 1, ans;
for (int i = 1; i <= scc; i++) {
if (w[i].empty()) {
if ((mn > gas[i]) && gas[i]) {
mn = gas[i];
ans = i;
}
}
}
for (int i = 1; i <= n; i++)
if (col[i] == ans) rans[anscnt++] = i;
printf("%d\n", anscnt);
for (int i = 0; i < anscnt; i++) {
printf("%d ", rans[i]);
}
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:20000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,sse3,sse4,popcnt,abm,mmx")
using namespace std;
const int N = 1100;
const int MAXN = int(1e6) + 100;
const int Mmask = (1 << 20);
const int mod = int(1e9) + 7;
const long long MOD = (long long)(1e18) + 7ll;
int solution();
int main(int argc, char* const argv[]) {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
return solution();
}
long long n, m, h, a[MAXN], dp[MAXN], col = 1, ans = (long long)(1e9),
color[MAXN], ccnt[MAXN];
vector<long long> v, G[MAXN], r_G[MAXN], n_G[MAXN];
set<long long> w[MAXN];
bool u[MAXN];
void dotop(int x) {
u[x] = true;
for (auto to : G[x]) {
if (!u[to]) dotop(to);
}
v.push_back(x);
}
void paint(int x) {
u[x] = true;
color[x] = col;
ccnt[col]++;
for (auto to : r_G[x]) {
if (!u[to]) paint(to);
}
}
void build(int x) {
u[x] = true;
for (auto to : G[x]) {
if (!u[to]) build(to);
if (color[to] != color[x]) {
n_G[color[x]].push_back(color[to]);
}
}
}
void calc(int x) {
u[x] = true;
dp[x] = ccnt[x];
for (auto to : n_G[x]) {
if (!u[to]) calc(to);
if (!w[to].count(x)) {
dp[x] += dp[to];
w[to].insert(x);
}
}
}
int solution() {
cin >> n >> m >> h;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= m; i++) {
int f, t;
cin >> f >> t;
if ((a[f] + 1) % h == a[t]) {
G[f].push_back(t);
r_G[t].push_back(f);
}
if ((a[t] + 1) % h == a[f]) {
G[t].push_back(f);
r_G[f].push_back(t);
}
}
for (int i = 1; i <= n; i++) {
if (!u[i]) dotop(i);
}
reverse(begin(v), end(v));
memset(u, false, sizeof u);
for (auto c : v) {
if (!u[c]) {
paint(c);
col++;
}
}
memset(u, false, sizeof u);
for (int i = 1; i <= n; i++) {
if (!u[i]) build(i);
}
memset(u, false, sizeof u);
for (int i = 1; i < col; i++) {
if (!u[i]) calc(i);
ans = min(ans, dp[i]);
}
cout << ans << endl;
for (int i = 1; i < col; i++) {
if (dp[i] == ans) {
for (int j = 1; j <= n; j++) {
if (color[j] == i) cout << j << ' ';
}
return 0;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline void fastio() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
long long C;
vector<vector<long long> > g;
vector<vector<long long> > gr;
vector<long long> color;
vector<long long> top;
vector<long long> usd;
vector<long long> comp;
vector<vector<long long> > Component;
vector<long long> dp;
const long long inf = 1e9 + 123;
void dfs(long long v) {
usd[v] = 1;
for (auto u : g[v]) {
if (usd[u]) continue;
dfs(u);
}
top.push_back(v);
}
void dfster(long long v) {
usd[v] = 1;
comp.back()++;
Component.back().push_back(v);
color[v] = C;
for (auto u : gr[v]) {
if (usd[u]) continue;
dfster(u);
}
}
long long ans = inf;
long long num = -1;
void dfsik(long long v) {
usd[v] = 1;
dp[v] = comp[v];
set<long long> togo;
for (auto u : g[v]) {
togo.insert(u);
}
for (auto u : g[v]) {
if (!usd[u]) {
dfsik(u);
dp[v] += dp[u];
}
}
if (togo.size() == 0) {
if (ans > comp[v]) {
ans = comp[v];
num = v;
}
}
}
void solve() {
long long n, m, h;
cin >> n >> m >> h;
g.resize(n);
gr.resize(n);
color.assign(n, 0);
vector<long long> v(n);
for (long long i = 0; i < n; ++i) {
cin >> v[i];
}
for (long long i = 0; i < m; ++i) {
long long a, b;
cin >> a >> b;
a--;
b--;
if ((v[a] + 1) % h == v[b]) {
g[a].push_back(b);
gr[b].push_back(a);
}
if ((v[b] + 1) % h == v[a]) {
g[b].push_back(a);
gr[a].push_back(b);
}
}
usd.assign(n, 0);
for (long long i = 0; i < n; ++i) {
if (!usd[i]) dfs(i);
}
reverse(top.begin(), top.end());
usd.assign(n, 0);
C = 0;
for (auto i : top) {
if (usd[i]) continue;
comp.push_back(0);
Component.push_back(vector<long long>(0));
dfster(i);
C++;
}
vector<vector<long long> > ng(C);
for (long long i = 0; i < n; ++i) {
for (auto j : g[i]) {
if (color[j] == color[i]) continue;
ng[color[i]].push_back(color[j]);
}
}
g.swap(ng);
dp.resize(C);
usd.assign(C, 0);
for (long long i = 0; i < C; ++i) {
if (!usd[i]) dfsik(i);
}
cout << ans << '\n';
for (auto i : Component[num]) {
cout << i + 1 << ' ';
}
cout << '\n';
}
signed main() {
fastio();
long long t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void out(T x) {
cout << x << endl;
exit(0);
}
using ll = long long;
const ll mod = 1e9 + 7;
const int maxn = 1e6 + 5;
int n, m, h;
int u[maxn];
set<int> g[maxn], rg[maxn];
vector<int> post;
bool viz[maxn];
void dfs1(int at) {
viz[at] = true;
for (int to : g[at]) {
if (!viz[to]) {
dfs1(to);
}
}
post.push_back(at);
}
int cloc;
int scc[maxn];
int siz[maxn];
bool sink[maxn];
void dfs2(int at) {
scc[at] = cloc;
siz[cloc]++;
for (int to : rg[at]) {
if (!scc[to]) {
dfs2(to);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> h;
for (int i = 1; i <= n; i++) {
cin >> u[i];
}
for (int i = 1; i <= m; i++) {
int x, y;
cin >> x >> y;
if ((u[x] + 1) % h == u[y]) {
g[x].insert(y);
rg[y].insert(x);
}
swap(x, y);
if ((u[x] + 1) % h == u[y]) {
g[x].insert(y);
rg[y].insert(x);
}
}
for (int i = 1; i <= n; i++) {
if (!viz[i]) dfs1(i);
}
reverse(post.begin(), post.end());
for (int x : post) {
if (!scc[x]) {
cloc++;
dfs2(x);
}
}
for (int i = 1; i <= cloc; i++) {
sink[i] = true;
}
for (int i = 1; i <= n; i++) {
for (int to : g[i]) {
if (scc[i] != scc[to]) {
sink[scc[i]] = false;
}
}
}
int res = 1e9;
int id = -1;
for (int i = 1; i <= cloc; i++) {
if (sink[i] && siz[i] < res) {
res = siz[i];
id = i;
}
}
cout << res << "\n";
for (int i = 1; i <= n; i++) {
if (scc[i] == id) cout << i << " ";
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
const int maxn = 1e5 + 7, maxd = 1e6 + 7;
const int mod = 1e9 + 7;
const int INF = 0x7f7f7f7f;
int n, m, h;
int t[maxn];
vector<int> e[maxn];
int dfn[maxn], low[maxn], vis[maxn], tim = 1;
int cnt[maxn], id[maxn], scc = 0;
stack<int> ans;
bool ok[maxn];
void init() {
memset(dfn, 0, sizeof dfn);
memset(vis, 0, sizeof vis);
memset(cnt, 0, sizeof cnt);
memset(ok, 1, sizeof ok);
scanf("%d%d%d", &n, &m, &h);
for (int i = 1; i <= n; ++i) scanf("%d", &t[i]);
for (int i = 0; i < m; ++i) {
int u, v;
scanf("%d %d", &u, &v);
if ((t[u] + 1) % h == t[v]) e[u].push_back(v);
if ((t[v] + 1) % h == t[u]) e[v].push_back(u);
}
}
void tar(int u) {
dfn[u] = low[u] = tim++;
ans.push(u);
for (auto v : e[u]) {
if (!dfn[v]) tar(v);
if (!vis[v]) low[u] = min(low[u], low[v]);
}
if (dfn[u] == low[u]) {
scc++;
while (1) {
int v = ans.top();
ans.pop();
id[v] = scc;
cnt[scc]++;
if (u == v) break;
}
}
}
int main() {
init();
for (int i = 1; i <= n; ++i) {
if (!dfn[i]) tar(i);
}
for (int i = 1; i <= n; ++i) {
for (auto j : e[i]) {
if (id[i] == id[j])
continue;
else
ok[id[i]] = 0;
}
}
int ans1 = INF, ans2 = 0;
for (int i = 1; i <= scc; ++i) {
if (ok[i] && cnt[i] < ans1) {
ans1 = cnt[i];
ans2 = i;
}
}
cout << cnt[ans2] << endl;
for (int i = 1; i <= n; ++i) {
if (id[i] == ans2) cout << i << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int>> A, Ab;
vector<int> t;
vector<int> used, order, component;
void dfs1(int v) {
used[v] = 1;
for (int i = 0; i < A[v].size(); i++) {
if (!used[A[v][i]]) {
dfs1(A[v][i]);
}
}
order.push_back(v);
}
void dfs2(int v) {
used[v] = 1;
component.push_back(v);
for (int i = 0; i < Ab[v].size(); i++) {
if (!used[Ab[v][i]]) {
dfs2(Ab[v][i]);
}
}
}
vector<int> c;
vector<vector<int>> g, comps;
int color = 1;
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
cout.tie(0);
int n, m, h;
cin >> n >> m >> h;
A.resize(n + 1);
Ab.resize(n + 1);
t.resize(n + 1);
used.resize(n + 1);
c.resize(n + 1);
for (int i = 1; i <= n; i++) {
cin >> t[i];
}
for (int i = 1; i <= m; i++) {
int a, b;
cin >> a >> b;
if ((t[a] + 1) % h == t[b]) {
A[a].push_back(b);
Ab[b].push_back(a);
}
if ((t[b] + 1) % h == t[a]) {
A[b].push_back(a);
Ab[a].push_back(b);
}
}
for (int i = 1; i <= n; i++) {
if (!used[i]) {
dfs1(i);
}
}
for (int i = 1; i <= n; i++) used[i] = 0;
for (int i = 1; i <= n; i++) {
int v = order[n - i];
if (!used[v]) {
component.clear();
dfs2(v);
for (int j = 0; j < component.size(); j++) {
c[component[j]] = color;
}
color++;
comps.push_back(component);
}
}
g.resize(color);
for (int i = 1; i <= n; i++) {
for (int j = 0; j < A[i].size(); j++) {
int x = c[i], y = c[A[i][j]];
if (x != y) g[x].push_back(y);
}
}
int ans = 1e8;
vector<int> a;
for (int i = 1; i < color; i++) {
if (g[i].size() == 0) {
if (ans > comps[i - 1].size()) {
ans = comps[i - 1].size();
a = comps[i - 1];
}
}
}
cout << ans << endl;
for (int i = 0; i < ans; i++) {
cout << a[i] << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
stack<int> S;
vector<int> G[maxn];
set<int> J[maxn];
int n, m, h, k, u, v, cnt, col_num;
int color[maxn];
int a[maxn], DFN[maxn], Low[maxn], du[maxn];
int Size[maxn];
bool instack[maxn];
void Tarjan(int w) {
instack[w] = true;
DFN[w] = Low[w] = ++cnt;
S.push(w);
for (int i = 0; i < G[w].size(); i++) {
int Nxt = G[w][i];
if (!DFN[Nxt]) {
Tarjan(Nxt);
Low[w] = min(Low[w], Low[Nxt]);
} else if (instack[Nxt])
Low[w] = min(Low[w], DFN[Nxt]);
}
if (Low[w] == DFN[w]) {
instack[w] = false;
color[w] = ++col_num;
Size[col_num] = 1;
while (S.top() != w) {
int u = S.top();
S.pop();
instack[u] = false;
color[u] = col_num;
Size[col_num]++;
}
S.pop();
}
}
int main() {
scanf("%d%d%d", &n, &m, &h);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &u, &v);
if (a[u] > a[v]) swap(u, v);
if (a[v] == a[u] + 1) G[v].push_back(u);
if (a[v] == h - 1 && a[u] == 0) G[u].push_back(v);
}
cnt = 0;
for (int i = 1; i <= n; i++)
if (!DFN[i]) Tarjan(i);
memset(du, 0, sizeof(du));
for (int i = 1; i <= n; i++)
for (int j = 0; j < G[i].size(); j++)
if (color[i] != color[G[i][j]]) du[color[G[i][j]]]++;
int u, ans = 1e9 + 5;
for (int i = 1; i <= col_num; i++)
if (!du[i])
if (ans > Size[i]) {
ans = min(ans, Size[i]);
u = i;
}
printf("%d\n", ans);
for (int i = 1; i <= n; i++)
if (color[i] == u) printf("%d ", i);
}
|
#include <bits/stdc++.h>
using namespace std;
struct SCC {
int n, comp;
vector<vector<int> > g, gt;
vector<int> seq, vis;
void dfs(int u, const vector<vector<int> >& adj) {
for (int v : adj[u])
if (vis[v] == -1) {
vis[v] = comp;
dfs(v, adj);
}
seq.push_back(u);
}
SCC() {}
SCC(int n) : n(n), g(n), gt(n) {}
void add_edge(int u, int v) {
g[u].push_back(v);
gt[v].push_back(u);
}
pair<int, vector<int> > find_SCC() {
vis.assign(n, -1);
comp = 0;
for (int i = 0; i < n; i++)
if (vis[i] == -1) {
vis[i] = comp;
dfs(i, g);
}
vis.assign(n, -1);
comp = 0;
for (int i = n - 1; i >= 0; i--) {
int u = seq[i];
if (vis[u] == -1) {
vis[u] = comp;
dfs(u, gt);
comp++;
}
}
return {comp, vis};
}
vector<vector<int> > get_dag() {
map<pair<int, int>, int> mmap;
vector<vector<int> > dag(comp, vector<int>());
for (int u = 0; u < n; u++)
for (int v : g[u]) {
if (vis[u] == vis[v]) continue;
if (!mmap.count(pair<int, int>(vis[u], vis[v]))) {
dag[vis[u]].push_back(vis[v]);
mmap[pair<int, int>(vis[u], vis[v])] = 1;
}
}
return dag;
}
};
const int mod = 1000000000 + 7;
int addm(int& a, int b) { return (a += b) < mod ? a : a -= mod; }
template <class T, class U>
bool smin(T& a, U b) {
return a > b ? (a = b, 1) : 0;
}
template <class T, class U>
bool smax(T& a, U b) {
return a < b ? (a = b, 1) : 0;
}
int n, m, h;
SCC cc;
int u[100000];
int c[100000][2];
vector<int> outt[100000], comps[100000];
pair<int, vector<int> > scc;
bool inex(int i, int j) {
i = u[i];
j = u[j];
return i + 1 == j || (i + 1 == h && j == 0);
}
bool noout(int i) {
for (int j = 0; j < comps[i].size(); j++)
for (int k = 0; k < outt[comps[i][j]].size(); k++)
if (scc.second[outt[comps[i][j]][k]] != i) return 0;
return 1;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> h;
cc = SCC(n);
for (int i = 0; i < n; i++) cin >> u[i];
for (int i = 0; i < m; i++) {
cin >> c[i][0] >> c[i][1];
c[i][0]--;
c[i][1]--;
if (inex(c[i][0], c[i][1])) {
cc.add_edge(c[i][0], c[i][1]);
outt[c[i][0]].push_back(c[i][1]);
}
if (inex(c[i][1], c[i][0])) {
cc.add_edge(c[i][1], c[i][0]);
outt[c[i][1]].push_back(c[i][0]);
}
}
scc = cc.find_SCC();
for (int i = 0; i < n; i++) comps[scc.second[i]].push_back(i);
int mi = -1;
for (int i = 0; i < scc.first; i++)
if (noout(i) && (mi == -1 || comps[mi].size() > comps[i].size())) mi = i;
cout << comps[mi].size() << endl;
for (int i = 0; i < comps[mi].size(); i++) {
if (i) cout << ' ';
cout << comps[mi][i] + 1;
}
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int fst[N], nxt[2 * N], v[2 * N], cnt;
int dfn[N], low[N], num, st[N], top;
int u[N], c[N], sum[N], siz[N], pos;
bool ins[N];
map<pair<int, int>, bool> mp;
void add(int x, int y) {
if (mp[make_pair(x, y)]) return;
mp[make_pair(x, y)] = 1;
v[++cnt] = y;
nxt[cnt] = fst[x], fst[x] = cnt;
}
void tj(int x) {
dfn[x] = low[x] = ++num;
st[++top] = x, ins[x] = 1;
for (int i = fst[x]; i; i = nxt[i]) {
int y = v[i];
if (!dfn[y]) {
tj(y);
low[x] = min(low[x], low[y]);
} else if (ins[y])
low[x] = min(low[x], dfn[y]);
}
if (dfn[x] == low[x]) {
int y = -1;
pos++;
while (x != y) {
y = st[top--], ins[y] = 0;
c[y] = pos, siz[pos]++;
}
}
}
int main() {
int n, m, h;
scanf("%d%d%d", &n, &m, &h);
for (int i = 1; i <= n; i++) scanf("%d", &u[i]);
int ca = 0, cb = 0;
for (int i = 1; i <= m; i++) {
scanf("%d%d", &ca, &cb);
if ((u[ca] + 1) % h == u[cb]) add(ca, cb);
if ((u[cb] + 1) % h == u[ca]) add(cb, ca);
}
for (int i = 1; i <= n; i++)
if (!dfn[i]) tj(i);
for (int i = 1; i <= n; i++)
for (int j = fst[i]; j; j = nxt[j])
if (c[v[j]] != c[i]) sum[c[i]]++;
int ans = 0x3f3f3f3f, id;
for (int i = 1; i <= pos; i++)
if (!sum[i] && siz[i] < ans) ans = siz[i], id = i;
printf("%d\n", ans);
for (int i = 1; i <= n; i++)
if (c[i] == id) printf("%d ", i);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long curr_comp = 0;
void toposort(long long idx, vector<vector<long long>> &adj,
vector<char> &visited, vector<long long> &st) {
visited[idx] = 1;
for (auto i : adj[idx]) {
if (!visited[i]) toposort(i, adj, visited, st);
}
st.push_back(idx);
}
void sec_pass(long long idx, vector<vector<long long>> &adj,
vector<char> &visited, vector<long long> &comps,
vector<long long> &curr) {
visited[idx] = 1;
comps[idx] = curr_comp;
curr.push_back(idx);
for (auto i : adj[idx]) {
if (!visited[i]) {
sec_pass(i, adj, visited, comps, curr);
}
}
}
long long res = INT_MAX;
vector<long long> ans;
void scc(vector<vector<long long>> &adj, vector<long long> &comps) {
long long n = comps.size();
vector<long long> st;
vector<char> visited(n, 0);
for (long long i = 0; i < n; i++) {
if (!visited[i]) {
toposort(i, adj, visited, st);
}
}
reverse((st).begin(), (st).end());
vector<vector<long long>> cadj(n);
for (long long i = 0; i < n; i++) {
for (auto j : adj[i]) cadj[j].push_back(i);
}
visited = vector<char>(n, 0);
for (auto i : st) {
if (!visited[i]) {
vector<long long> curr;
sec_pass(i, cadj, visited, comps, curr);
curr_comp++;
bool f = 0;
for (auto v : curr) {
for (auto j : cadj[v]) {
if (comps[j] != comps[v]) {
f = 1;
break;
}
}
if (f) break;
}
if (!f && curr.size() < res) {
res = curr.size();
ans = curr;
}
}
}
}
int main() {
long long(n), (m), (h);
scanf("%lld%lld%lld", &(n), &(m), &(h));
;
vector<long long> hrs((n));
for (long long i = 0; i < n; i++) scanf("%lld", &hrs[i]);
;
vector<vector<long long>> adj(n);
for (long long i = 0; i < (m); i++) {
long long(a), (b);
scanf("%lld%lld", &(a), &(b));
;
--a;
--b;
if ((hrs[a] + 1) % h == hrs[b]) {
adj[b].push_back(a);
}
if ((hrs[b] + 1) % h == hrs[a]) {
adj[a].push_back(b);
}
}
vector<long long> comps(n, -1);
scc(adj, comps);
printf("%lld\n", res);
for (auto i : ans) printf("%lld ", i + 1);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = int(5e5) + 5;
const int inf = (int)1e9 + 7;
int n, m, h;
int u[N], used[N], c[N], now;
int dp[N], cnt[N];
vector<int> g[N], rg[N], cc[N];
vector<int> ord, ans;
void dfs(int v) {
u[v] = 1;
for (int i : g[v]) {
if (!u[i]) {
dfs(i);
}
}
ord.push_back(v);
}
void dfs2(int v) {
c[v] = now;
cc[now].push_back(v);
for (int i : rg[v]) {
if (!c[i]) {
dfs2(i);
}
}
}
int main() {
scanf("%d %d %d", &n, &m, &h);
for (int i = 1; i <= n; ++i) {
scanf("%d", u + i);
dp[i] = -1;
}
for (int i = 1; i <= m; ++i) {
int x, y;
scanf("%d %d", &x, &y);
if ((u[x] + 1) % h == u[y]) {
g[x].push_back(y);
rg[y].push_back(x);
}
if ((u[y] + 1) % h == u[x]) {
g[y].push_back(x);
rg[x].push_back(y);
}
}
for (int i = 1; i <= n; ++i)
g[i].resize(unique(g[i].begin(), g[i].end()) - g[i].begin());
for (int i = 1; i <= n; ++i)
rg[i].resize(unique(rg[i].begin(), rg[i].end()) - rg[i].begin());
fill(u + 1, u + 1 + n, 0);
for (int i = 1; i <= n; ++i) {
if (!u[i]) {
dfs(i);
}
}
reverse(ord.begin(), ord.end());
fill(u + 1, u + 1 + n, 0);
for (int i : ord) {
if (!c[i]) {
++now;
dfs2(i);
}
}
for (int i = 1; i <= n; ++i) {
for (int j : g[i]) {
if (c[i] != c[j]) {
cnt[c[i]]++;
}
}
}
int mn = -1;
for (int i = 1; i <= now; ++i) {
if (cnt[i] == 0) {
if (mn == -1 || (int)cc[mn].size() > (int)cc[i].size()) {
mn = i;
}
}
}
printf("%d\n", (int)cc[mn].size());
for (int i : cc[mn]) {
printf("%d ", i);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100001, K = 10;
int n, k, arr[N];
int ndfn, lowLink[N], dfn[N], comp[N], c = -1, cnt[N];
vector<int> adjList[N];
stack<int> stk;
bool inStack[N], vis[N];
vector<int> inDeg, outDeg;
vector<vector<int> > dagList;
void tarjan(int node) {
lowLink[node] = dfn[node] = ndfn++;
stk.push(node), inStack[node] = 1;
for (int ch : adjList[node]) {
if (dfn[ch] == -1) {
tarjan(ch);
lowLink[node] = min(lowLink[node], lowLink[ch]);
} else if (inStack[ch])
lowLink[node] = min(lowLink[node], dfn[ch]);
}
if (lowLink[node] == dfn[node]) {
c++;
int x = -1;
while (x != node) {
x = stk.top(), stk.pop(), inStack[x] = 0;
comp[x] = c, cnt[c]++;
}
}
}
void computeCompGraph() {
int csz = c + 1, cntSrc = csz, cntSnk = csz;
outDeg.clear();
outDeg.resize(csz);
inDeg.clear();
inDeg.resize(csz);
dagList.clear();
dagList.resize(csz);
for (int i = 1; i <= n; ++i)
for (int j = 0; j < adjList[i].size(); ++j) {
int k = adjList[i][j];
if (comp[k] != comp[i]) {
dagList[comp[i]].push_back(comp[k]);
if (!(inDeg[comp[k]]++)) cntSrc--;
if (!(outDeg[comp[i]]++)) cntSnk--;
} else
;
}
}
int main() {
memset(dfn, -1, sizeof dfn);
memset(lowLink, -1, sizeof lowLink);
int m, h;
scanf("%d%d%d", &n, &m, &h);
for (int i = 1; i <= n; i++) scanf("%d", &arr[i]);
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d%d", &x, &y);
if ((arr[x] + 1) % h == arr[y]) adjList[x].push_back(y);
if ((arr[y] + 1) % h == arr[x]) adjList[y].push_back(x);
}
for (int i = 1; i <= n; i++)
if (dfn[i] == -1) tarjan(i);
computeCompGraph();
int mini = N, id = -1;
for (int i = 0; i <= c; i++)
if (dagList[i].empty())
if (cnt[i] < mini) id = i, mini = cnt[i];
printf("%d\n", mini);
for (int i = 1; i <= n; i++)
if (comp[i] == id) printf("%d ", i);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1);
const int MAX = 1e6 + 100;
const int MOD = 1e9 + 7;
int a[MAX], pre[MAX], low[MAX], scc[MAX], tot = 0, sc = 0;
int num[MAX], chu[MAX];
vector<int> e[MAX];
stack<int> p;
void Tarjan(int k) {
pre[k] = low[k] = ++tot;
p.push(k);
for (int i = 0; i < e[k].size(); i++) {
int nex = e[k][i];
if (pre[nex] == 0) {
Tarjan(nex);
low[k] = min(low[k], low[nex]);
} else if (scc[nex] == 0)
low[k] = min(low[k], pre[nex]);
}
if (low[k] == pre[k]) {
sc++;
while (1) {
int x = p.top();
p.pop();
scc[x] = sc;
num[sc]++;
if (x == k) break;
}
}
}
int main() {
int n, m, h;
cin >> n >> m >> h;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
if ((a[x] + 1) % h == a[y]) e[x].push_back(y);
if ((a[y] + 1) % h == a[x]) e[y].push_back(x);
}
for (int i = 1; i <= n; i++)
if (pre[i] == 0) Tarjan(i);
for (int i = 1; i <= n; i++) {
for (int j = 0; j < e[i].size(); j++) {
int nex = e[i][j];
if (scc[i] != scc[nex]) chu[scc[i]]++;
}
}
int ans, ma = 1e9 + 7;
for (int i = 1; i <= n; i++) {
if (chu[scc[i]] == 0 && num[scc[i]] < ma) {
ma = num[scc[i]];
ans = scc[i];
}
}
printf("%d\n", ma);
for (int i = 1; i <= n; i++)
if (scc[i] == ans) printf("%d ", i);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, h;
vector<int> vals;
vector<set<int>> adj;
vector<set<int>> adjr;
vector<bool> used;
vector<int> order, component;
vector<set<int>> adj2(1e5 + 1);
void dfs1(int v) {
used[v] = true;
for (auto node : adj[v])
if (!used[node]) dfs1(node);
order.push_back(v);
}
void dfs2(int v) {
used[v] = true;
component.push_back(v);
for (auto node : adjr[v])
if (!used[node]) dfs2(node);
}
void solve() {
cin >> n >> m >> h;
vals.resize(n + 1);
adj.resize(n + 1);
adjr.resize(n + 1);
for (int i = 1; i <= n; i++) cin >> vals[i];
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
if ((vals[x] + 1) % h == vals[y]) {
adj[x].insert(y);
}
if ((vals[y] + 1) % h == vals[x]) {
adj[y].insert(x);
}
}
for (int i = 1; i <= n; i++)
for (auto node : adj[i]) adjr[node].insert(i);
used.assign(n + 1, false);
for (int i = 1; i <= n; i++)
if (!used[i]) dfs1(i);
used.assign(n + 1, false);
vector<int> roots(n + 1, 0);
vector<int> root_nodes;
vector<int> comp_sizes(n + 1, 0);
for (int i = 0; i < n; i++) {
int v = order[n - i - 1];
if (!used[v]) {
dfs2(v);
int root = component.front();
for (auto node : component) roots[node] = root;
comp_sizes[root] = component.size();
root_nodes.push_back(root);
component.clear();
}
}
for (int child = 1; child <= n; child++)
for (auto neigh : adj[child]) {
int root_node2 = roots[neigh];
int root_node = roots[child];
assert(root_node and root_node2);
if (root_node2 != root_node) adj2[root_node].insert(root_node2);
}
int ans = INT_MAX, ans_node = -1;
for (auto root_node : root_nodes)
if (adj2[root_node].empty()) {
int sz = comp_sizes[root_node];
if (ans > sz) {
ans = sz;
ans_node = root_node;
}
}
assert(ans < INT_MAX);
cout << ans << "\n";
for (int i = 1; i <= n; i++)
if (roots[i] == ans_node) cout << i << " ";
cout << "\n";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
int n, m, h, u, v, a[maxn];
struct Edge {
int to, nex;
} edge[maxn << 1];
int head[maxn], ecnt;
void add_edge(int u, int v) {
edge[++ecnt] = {v, head[u]};
head[u] = ecnt;
}
int color, id, Index;
int vis[maxn], dfn[maxn], stk[maxn], low[maxn], belong[maxn], sz[maxn];
void tarjan(int now) {
dfn[now] = low[now] = ++color;
stk[++Index] = now;
vis[now] = 1;
for (int i = head[now]; i; i = edge[i].nex) {
int to = edge[i].to;
if (!dfn[to]) {
tarjan(to);
low[now] = min(low[now], low[to]);
} else if (vis[to])
low[now] = min(low[now], dfn[to]);
}
if (low[now] == dfn[now]) {
id++;
while (1) {
belong[stk[Index]] = id;
sz[id]++;
vis[stk[Index]] = 0;
Index--;
if (now == stk[Index + 1]) break;
}
}
}
int dgr[maxn];
int main() {
scanf("%d %d %d", &n, &m, &h);
for (int i = 1; i <= n; i++) scanf("%d", a + i);
for (int i = 1; i <= m; i++) {
scanf("%d %d", &u, &v);
if ((a[u] + 1) % h == a[v]) add_edge(u, v);
if ((a[v] + 1) % h == a[u]) add_edge(v, u);
}
for (int i = 1; i <= n; i++)
if (!dfn[i]) tarjan(i);
for (int i = 1; i <= n; i++) {
for (int j = head[i]; j; j = edge[j].nex) {
int to = edge[j].to;
if (belong[i] != belong[to]) dgr[belong[i]]++;
}
}
int best = n + 1, ans = 0;
for (int i = 1; i <= id; i++) {
if (dgr[i]) continue;
if (best > sz[i]) {
ans = i;
best = sz[i];
}
}
printf("%d\n", best);
for (int i = 1; i <= n; i++)
if (belong[i] == ans) printf("%d ", i);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200200;
int n, m, h;
int c[N];
vector<int> to[N];
int bz[N], vis[N], sta[N];
int fa[N], dfn[N], top[N], f[N], p[N], du[N];
int tot, cnt, ans;
void tj(int x) {
dfn[x] = top[x] = ++tot;
sta[++sta[0]] = x;
int sz = to[x].size();
for (int i = (0); i <= (sz - 1); ++i) {
int tt = to[x][i];
if (!dfn[tt]) tj(tt);
top[x] = min(top[x], top[tt]);
}
if (dfn[x] == top[x]) {
++cnt;
for (int now = sta[sta[0]--]; now != x; now = sta[sta[0]--])
++p[f[now] = cnt];
++p[f[x] = cnt];
}
}
int main() {
scanf("%d%d%d", &n, &m, &h);
for (int i = (1); i <= (n); ++i) scanf("%d", &c[i]);
for (int i = (1); i <= (m); ++i) {
int x, y;
scanf("%d%d", &x, &y);
if (c[x] == (c[y] + 1) % h) to[y].push_back(x);
if (c[y] == (c[x] + 1) % h) to[x].push_back(y);
}
ans = 0, p[0] = 2139062143;
for (int i = (1); i <= (n); ++i)
if (!dfn[i]) tj(i);
for (int i = (1); i <= (n); ++i) {
int sz = to[i].size();
for (int l = (0); l <= (sz - 1); ++l)
if (f[i] != f[to[i][l]]) ++du[f[i]];
}
for (int i = (1); i <= (cnt); ++i)
if (du[i] == 0 && p[i] < p[ans]) ans = i;
printf("%d\n", p[ans]);
for (int i = (1); i <= (n); ++i)
if (f[i] == ans) printf("%d ", i);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const int N = 200005;
stack<int> sta;
vector<int> s[N], g[N], scc[N];
int dfs_cnt = 0, pre[N] = {0}, sccno[N] = {0}, scc_cnt = 0, is[N] = {0},
add[N] = {0};
int dfs(int u) {
int lowu, lowv, i;
lowu = pre[u] = ++dfs_cnt;
sta.push(u);
for (i = 0; i < s[u].size(); i++) {
int v = s[u][i];
if (pre[v] == 0) {
lowv = dfs(v);
lowu = min(lowu, lowv);
} else if (pre[v] < pre[u] && sccno[v] == 0) {
lowu = min(lowu, pre[v]);
}
}
if (lowu == pre[u]) {
++scc_cnt;
while (sta.size()) {
int first = sta.top();
sta.pop();
sccno[first] = scc_cnt;
scc[scc_cnt].push_back(first);
if (first == u) break;
}
}
return lowu;
}
int val[N];
int main() {
int n, m, h;
cin >> n >> m >> h;
for (int i = 1; i <= n; i++) {
scanf("%d", &val[i]);
}
for (int i = 0; i < m; i++) {
int first, second;
scanf("%d%d", &first, &second);
if ((val[first] + 1) % h == val[second]) s[first].push_back(second);
if ((val[second] + 1) % h == val[first]) s[second].push_back(first);
}
for (int i = 1; i <= n; i++) {
if (pre[i] == 0) {
dfs(i);
}
}
int ans = -1, id;
for (int i = 1; i <= scc_cnt; i++) {
int flag = 1;
for (auto second : scc[i]) {
for (auto first : s[second]) {
if (sccno[first] != i) flag = 0;
}
}
if (flag) {
if (ans == -1 || (int)scc[i].size() < ans) ans = scc[i].size(), id = i;
}
}
printf("%d\n", ans);
sort(scc[id].begin(), scc[id].end());
for (auto first : scc[id]) printf("%d ", first);
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> g[110000];
vector<int> ag[110000];
stack<int> s;
int n, m, x, y, h, u[110000], v[110000], num[110000], sum[110000];
void link(int x, int y) {
g[x].push_back(y);
ag[y].push_back(x);
}
void dfs(int x) {
v[x] = 1;
for (int i = 0; i < g[x].size(); i++)
if (!v[g[x][i]]) dfs(g[x][i]);
s.push(x);
}
void find(int x, int k) {
num[x] = k;
sum[k]++;
for (int i = 0; i < ag[x].size(); i++)
if (!num[ag[x][i]]) find(ag[x][i], k);
}
int main() {
std::ios::sync_with_stdio(false);
cin >> n >> m >> h;
for (int i = 1; i <= n; i++) cin >> u[i];
for (int i = 1; i <= m; i++) {
cin >> x >> y;
if ((u[x] + 1) % h == u[y]) link(x, y);
if ((u[y] + 1) % h == u[x]) link(y, x);
}
for (int i = 1; i <= n; i++)
if (!v[i]) dfs(i);
int k = 0;
while (!s.empty()) {
int x = s.top();
s.pop();
if (!num[x]) find(x, ++k);
}
memset(v, 0, sizeof(v));
for (int i = 1; i <= n; i++)
for (int j = 0; j < g[i].size(); j++)
if (num[i] != num[g[i][j]]) v[num[i]] = 1;
int ans = 0;
for (int i = 1; i <= k; i++)
if (!v[i])
if (!ans)
ans = i;
else if (sum[i] < sum[ans])
ans = i;
cout << sum[ans] << endl;
for (int i = 1; i <= n; i++)
if (num[i] == ans) cout << i << ' ';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5, inf = 1e9;
vector<int> g[maxn + 50], g1[maxn + 50], g2[maxn + 50];
bool v[maxn + 50];
int n, m, color[maxn + 50], t[maxn + 50], len, c, d[maxn + 50];
int sz[maxn + 5];
int h;
int u[maxn + 5];
set<pair<int, int> > s;
void dfs(int k) {
v[k] = 1;
for (int i = 0; i < g[k].size(); ++i)
if (!v[g[k][i]]) dfs(g[k][i]);
++len;
t[len] = k;
}
void dfs1(int k) {
v[k] = 1;
color[k] = c;
++sz[c];
for (int i = 0; i < g1[k].size(); ++i)
if (!v[g1[k][i]]) dfs1(g1[k][i]);
}
bool check2(int a, int b) {
if (a == b) return 0;
for (int i = 0; i < g2[a].size(); ++i)
if (g2[a][i] == b) return 0;
return 1;
}
vector<pair<int, int> > edge;
int main() {
scanf("%d%d%d", &n, &m, &h);
for (int i = 1; i <= n; ++i) scanf("%d", &u[i]);
while (m--) {
int x, y;
scanf("%d%d", &x, &y);
if ((u[x] + 1) % h == u[y])
g[x].push_back(y), g1[y].push_back(x), edge.push_back(make_pair(x, y));
if ((u[y] + 1) % h == u[x])
g[y].push_back(x), g1[x].push_back(y), edge.push_back(make_pair(y, x));
}
memset(v, 0, sizeof(v));
memset(t, 0, sizeof(t));
for (int i = 1; i <= n; ++i)
if (!v[i]) dfs(i);
memset(v, 0, sizeof(v));
for (int i = len; i >= 1; --i)
if (!v[t[i]]) ++c, dfs1(t[i]);
for (auto e : edge) {
if (color[e.first] == color[e.second]) continue;
if (s.find(make_pair(color[e.first], color[e.second])) == s.end()) {
++d[color[e.first]];
s.insert(make_pair(color[e.first], color[e.second]));
}
}
int ans = n + 1;
int C;
for (int i = 1; i <= c; ++i)
if (d[i] == 0)
if (sz[i] < ans) ans = sz[i], C = i;
printf("%d\n", ans);
for (int i = 1; i <= n; ++i)
if (color[i] == C) printf("%d ", i);
return 0;
}
|
#include <bits/stdc++.h>
const double Pi = acos(-1.0);
using namespace std;
const int maxN = 100005;
int n, m, h;
int u[maxN];
vector<int> G[maxN];
int disc[maxN], low[maxN], t;
vector<int> S;
int scc[maxN], cnt;
bool in[maxN];
void tarjan(int cur) {
if (G[cur].empty()) {
printf("1\n%d\n", cur);
exit(0);
}
disc[cur] = low[cur] = ++t;
S.push_back(cur);
in[cur] = true;
for (int i = 0; i < (int)G[cur].size(); i++) {
int nxt = G[cur][i];
if (!disc[nxt]) {
tarjan(nxt);
low[cur] = min(low[nxt], low[cur]);
} else if (in[nxt])
low[cur] = min(disc[nxt], low[cur]);
}
if (disc[cur] == low[cur]) {
scc[cur] = ++cnt;
in[cur] = false;
int nxt;
while (S.back() != cur) {
nxt = S.back();
S.pop_back();
scc[nxt] = cnt;
in[nxt] = false;
}
S.pop_back();
}
}
bool mark[maxN];
int csz[maxN];
int main(int argc, char** argv) {
scanf("%d %d %d", &n, &m, &h);
for (int i = 1; i <= n; i++) scanf("%d", &u[i]);
int c1, c2;
for (int i = 0; i < m; i++) {
scanf("%d %d", &c1, &c2);
if ((u[c1] + 1) % h == u[c2]) G[c1].push_back(c2);
if ((u[c2] + 1) % h == u[c1]) G[c2].push_back(c1);
}
for (int i = 1; i <= n; i++) {
if (!disc[i]) tarjan(i);
}
for (int i = 1; i <= n; i++) {
csz[scc[i]]++;
if (mark[scc[i]]) continue;
for (int j = 0; j < (int)G[i].size(); j++) {
if (scc[G[i][j]] != scc[i]) mark[scc[i]] = true;
}
}
int ans = INT_MAX, best;
for (int i = 1; i <= cnt; i++) {
if (!mark[i] && csz[i] < ans) {
ans = csz[i];
best = i;
}
}
printf("%d\n", ans);
for (int i = 1; i <= n; i++) {
if (scc[i] == best) printf("%d ", i);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int INF = 0x3f3f3f3f;
const int N = 1e5 + 5;
int n, m, h, t[N];
int tot, head[N];
struct Edge {
int v, nxt;
} edge[N << 1];
void add(int u, int v) {
edge[tot].v = v;
edge[tot].nxt = head[u];
head[u] = tot++;
}
stack<int> st;
int cnt, dfn[N], low[N], in[N];
int scc, belong[N], sz[N];
void tarjan(int u) {
dfn[u] = low[u] = ++cnt;
st.push(u);
in[u] = 1;
for (int i = head[u]; ~i; i = edge[i].nxt) {
int v = edge[i].v;
if (!dfn[v]) {
tarjan(v);
low[u] = min(low[u], low[v]);
} else if (in[v]) {
low[u] = min(low[u], dfn[v]);
}
}
if (low[u] == dfn[u]) {
int v;
scc++;
do {
v = st.top();
st.pop();
in[v] = 0;
belong[v] = scc;
++sz[scc];
} while (u != v);
}
}
void init() {
tot = 0;
memset(head, -1, sizeof(head));
}
int deg[N];
void setscc() {
for (int i = 1; i <= n; ++i)
if (!dfn[i]) tarjan(i);
for (int u = 1; u <= n; ++u) {
for (int i = head[u]; ~i; i = edge[i].nxt) {
int v = edge[i].v;
if (belong[u] != belong[v]) deg[belong[u]]++;
}
}
}
int main() {
init();
scanf("%d%d%d", &n, &m, &h);
for (int i = 1; i <= n; ++i) scanf("%d", &t[i]);
for (int i = 1; i <= m; ++i) {
int x, y;
scanf("%d%d", &x, &y);
if ((t[x] + 1) % h == t[y]) add(x, y);
if ((t[y] + 1) % h == t[x]) add(y, x);
}
setscc();
int ans = n + 1, id;
for (int i = 1; i <= scc; ++i)
if (!deg[i] && sz[i] < ans) {
ans = sz[i];
id = i;
}
printf("%d\n", ans);
for (int i = 1; i <= n; ++i)
if (belong[i] == id) printf("%d ", i);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
set<int> adj[100100], scc[100100], radj[100100];
int inp[100100], sccassign[100100];
bool visited[100100], issccinternal[100100];
int nscc;
void dfs(int u, vector<int> &order) {
if (visited[u]) return;
visited[u] = true;
for (int i : adj[u]) dfs(i, order);
order.push_back(u);
}
void fillscc(int u, int sccindex) {
assert(!visited[u]);
visited[u] = true;
if (sccassign[u] != -1) cout << u << ' ' << sccassign[u] << endl;
assert(sccassign[u] == -1);
sccassign[u] = sccindex;
scc[sccindex].insert(u);
for (int i : radj[u]) {
if (visited[i]) {
if (sccassign[i] != sccindex) issccinternal[sccassign[i]] = true;
continue;
}
fillscc(i, sccindex);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
nscc = 0;
int n, m, h;
cin >> n >> m >> h;
for (int i = 0; i < n; i++) cin >> inp[i];
while (m-- > 0) {
int a, b;
cin >> a >> b;
a--;
b--;
if ((inp[a] + 1) % h == inp[b]) adj[a].insert(b), radj[b].insert(a);
if ((inp[b] + 1) % h == inp[a]) adj[b].insert(a), radj[a].insert(b);
}
vector<int> order;
for (int i = 0; i < n; i++) {
sccassign[i] = -1;
if (visited[i]) continue;
dfs(i, order);
}
memset(visited, false, n);
int n2 = order.size();
for (int i = n2 - 1; i >= 0; i--) {
if (visited[order[i]]) continue;
fillscc(order[i], nscc);
nscc++;
}
int mincnt = INT_MAX, bestscc = -1;
for (int i = 0; i < nscc; i++) {
if (!issccinternal[i] && mincnt > scc[i].size()) {
mincnt = scc[i].size();
bestscc = i;
}
}
assert(bestscc != -1);
cout << scc[bestscc].size() << '\n';
for (int i : scc[bestscc]) cout << i + 1 << ' ';
cout << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, h;
int t[100010];
struct edge {
int to, nxt;
} e[100010 << 2];
int edgenum = 0;
int lin[100010] = {0};
void add(int a, int b) {
++edgenum;
e[edgenum].to = b;
e[edgenum].nxt = lin[a];
lin[a] = edgenum;
return;
}
stack<int> s;
int dfn[100010], low[100010], tot = 0;
bool v[100010];
int ins[100010], siz[100010];
int scc = 0;
void tarjan(int k) {
dfn[k] = low[k] = ++tot;
s.push(k);
v[k] = true;
for (int i = lin[k]; i != 0; i = e[i].nxt) {
if (dfn[e[i].to] == 0) {
tarjan(e[i].to);
low[k] = min(low[k], low[e[i].to]);
} else if (v[e[i].to]) {
low[k] = min(low[k], dfn[e[i].to]);
}
}
if (low[k] >= dfn[k]) {
int t;
++scc;
do {
t = s.top();
s.pop();
v[t] = false;
ins[t] = scc;
siz[scc]++;
} while (t != k);
}
return;
}
int deg[100010];
int main() {
scanf("%d%d%d", &n, &m, &h);
for (int i = 1; i <= n; ++i) {
scanf("%d", &t[i]);
}
int c1, c2;
for (int i = 1; i <= m; ++i) {
scanf("%d%d", &c1, &c2);
if ((t[c1] + 1) % h == t[c2]) add(c1, c2);
if ((t[c2] + 1) % h == t[c1]) add(c2, c1);
}
for (int i = 1; i <= n; ++i) {
if (dfn[i] == 0) {
tarjan(i);
}
}
memset(deg, 0, sizeof(deg));
for (int k = 1; k <= n; ++k) {
for (int i = lin[k]; i != 0; i = e[i].nxt) {
if (ins[k] != ins[e[i].to]) {
++deg[ins[k]];
}
}
}
int ans = -1;
for (int i = 1; i <= scc; ++i) {
if (deg[i] == 0) {
if (ans == -1 || siz[i] < siz[ans]) {
ans = i;
}
}
}
cout << siz[ans] << endl;
for (int i = 1; i <= n; ++i) {
if (ins[i] == ans) {
printf("%d ", i);
}
}
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int sy[100001], u[100001], h, a[100001], n, m, dfn[100001], low[100001],
fir[100001], nex[200001], sto[200001], tot, a1, b1, t, cnt, zhan[100001],
num[100001], nex1[200001], nmin[100001], ans, fir1[100001], now;
bool p[100001], p1[100001];
bool cmp(int aa, int bb) { return (aa < bb); }
int getmin(int aa, int bb) {
if (aa < bb)
return (aa);
else
return (bb);
}
void tarjan(int x) {
int aa = fir[x];
p[x] = false;
p1[x] = true;
cnt++;
zhan[cnt] = x;
t++;
dfn[x] = t;
low[x] = t;
while (aa != 0) {
if (p[sto[aa]]) {
tarjan(sto[aa]);
low[x] = getmin(low[x], low[sto[aa]]);
} else if (p1[sto[aa]])
low[x] = getmin(low[x], low[sto[aa]]);
aa = nex[aa];
}
if (dfn[x] == low[x]) {
bool q = true;
ans++;
nmin[ans] = zhan[cnt];
num[ans] = 0;
while (q) {
int bb = zhan[cnt];
sy[bb] = ans;
if (dfn[bb] == low[bb]) q = false;
if (bb < nmin[ans]) nmin[ans] = bb;
num[ans]++;
nex1[bb] = fir1[ans];
fir1[ans] = bb;
cnt--;
p1[bb] = false;
}
}
}
int main() {
scanf("%d%d%d", &n, &m, &h);
for (int i = 1; i <= n; i++) {
p[i] = true;
p1[i] = false;
}
for (int i = 1; i <= n; i++) scanf("%d", &u[i]);
tot = 0;
ans = 0;
for (int i = 1; i <= m; i++) {
scanf("%d%d", &a1, &b1);
if (((u[a1] + 1 - u[b1]) % h) == 0) {
tot++;
nex[tot] = fir[a1];
fir[a1] = tot;
sto[tot] = b1;
}
if (((1 + u[b1] - u[a1]) % h) == 0) {
tot++;
nex[tot] = fir[b1];
fir[b1] = tot;
sto[tot] = a1;
}
}
cnt = 0;
t = 0;
for (int i = 1; i <= n; i++)
if (p[i]) tarjan(i);
now = 0;
num[0] = n + 1;
for (int i = 1; i <= ans; i++) {
int dbd = fir1[i];
bool p = true;
while (dbd != 0) {
int aa = fir[dbd];
while (aa != 0) {
if (sy[sto[aa]] != sy[dbd]) {
p = false;
break;
}
aa = nex[aa];
}
if (p == false) break;
dbd = nex1[dbd];
}
if (p) {
if (num[i] < num[now]) now = i;
}
}
int cc = fir1[now];
tot = 0;
while (cc != 0) {
tot++;
a[tot] = cc;
cc = nex1[cc];
}
sort(a + 1, a + 1 + tot, cmp);
printf("%d\n", tot);
for (int i = 1; i <= tot; i++) printf("%d ", a[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> dg[101000], dgr[101000], compadj[101000];
int n, m, h, u[101000], in1, in2, seq[101000], seqp;
int component[101000], comp_group, compcnt[101000], minn;
bool processed[101000];
void dfs(int a) {
if (processed[a]) return;
processed[a] = true;
for (auto x : dg[a]) dfs(x);
seq[seqp++] = a;
}
void dfss(int a) {
if (processed[a]) return;
processed[a] = true;
component[a] = comp_group;
for (auto x : dgr[a]) dfss(x);
}
int main() {
cin >> n >> m >> h;
for (int i = 1; i <= n; i++) cin >> u[i];
for (int i = 0; i < m; i++) {
cin >> in1 >> in2;
if (u[in2] > u[in1]) swap(in1, in2);
if ((u[in1] - u[in2]) == 1) {
dg[in2].push_back(in1);
dgr[in1].push_back(in2);
}
if ((u[in1] == (h - 1)) && (u[in2] == 0)) {
dg[in1].push_back(in2);
dgr[in2].push_back(in1);
}
}
for (int i = 1; i <= n; i++) dfs(i);
for (int i = 1; i <= n; i++) processed[i] = false;
for (int i = n - 1; i >= 0; i--) {
if (processed[seq[i]]) continue;
dfss(seq[i]);
comp_group++;
}
for (int i = 1; i <= n; i++) {
for (auto x : dg[i]) {
if (component[i] == component[x]) continue;
compadj[component[i]].push_back(component[x]);
}
}
for (int i = 1; i <= n; i++) {
compcnt[component[i]]++;
}
minn = n;
int minni = 0;
for (int i = 0; i < comp_group; i++) {
if ((compadj[i].size() == 0) && (compcnt[i] < minn)) {
minn = min(minn, compcnt[i]);
minni = i;
}
}
cout << minn << endl;
for (int i = 1; i <= n; i++) {
if (component[i] == minni) cout << i << " ";
}
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rnd(chrono::high_resolution_clock::now().time_since_epoch().count());
vector<vector<long long>> g, gt;
vector<bool> used;
vector<long long> ord, comp, len;
void dfs1(long long s) {
used[s] = true;
for (auto x : g[s])
if (!used[x]) dfs1(x);
ord.push_back(s);
}
void dfs2(long long s, long long clr) {
used[s] = true;
comp[s] = clr;
len[len.size() - 1]++;
for (auto x : gt[s])
if (!used[x]) dfs2(x, clr);
}
signed main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0), cout.precision(20);
long long n, m, h;
cin >> n >> m >> h;
vector<long long> u(n);
vector<pair<long long, long long>> edges;
g.resize(n), gt.resize(n), used.assign(n, false), comp.resize(n);
for (long long i = 0; i < n; i++) cin >> u[i];
for (long long i = 0; i < m; i++) {
long long x, y;
cin >> x >> y;
x--, y--;
if ((u[x] + 1) % h == u[y]) {
g[x].push_back(y);
edges.push_back({x, y});
gt[y].push_back(x);
}
if ((u[y] + 1) % h == u[x]) {
g[y].push_back(x);
edges.push_back({y, x});
gt[x].push_back(y);
}
}
for (long long i = 0; i < n; i++)
if (!used[i]) dfs1(i);
used.assign(n, false);
long long cur = 0;
len.push_back(0);
for (long long i = 0; i < n; i++) {
long long x = ord[n - i - 1];
if (!used[x]) {
cur++;
len.push_back(0);
dfs2(x, cur);
}
}
cout << "\n";
if (cur == 1) {
cout << n << "\n";
for (long long i = 1; i <= n; i++) cout << i << " ";
return 0;
}
vector<pair<long long, long long>> cnt(cur + 1, {0, 0});
for (long long i = 0; i < edges.size(); i++) {
if (comp[edges[i].first] != comp[edges[i].second]) {
cnt[comp[edges[i].first]].first++;
cnt[comp[edges[i].second]].second++;
}
}
long long ans = 1e9, clr;
for (long long i = 1; i < cnt.size(); i++)
if (cnt[i].first == 0 && len[i] < ans) {
ans = len[i];
clr = i;
}
cout << ans << "\n";
for (long long i = 0; i < n; i++)
if (comp[i] == clr) cout << i + 1 << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100004;
int pre[N], vis[N], low[N];
vector<int> g[N];
int u[N], sz[N], sccno[N], out[N];
int clk, cnt;
stack<int> stk;
void dfs(int u) {
low[u] = pre[u] = ++clk;
vis[u] = 1;
stk.push(u);
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (!pre[v]) {
dfs(v);
low[u] = min(low[u], low[v]);
} else if (vis[v])
low[u] = min(low[u], pre[v]);
}
if (low[u] == pre[u]) {
cnt++;
while (1) {
int x = stk.top();
vis[x] = 0;
stk.pop();
sz[cnt]++;
sccno[x] = cnt;
if (x == u) break;
}
}
}
int main() {
int n, m, h;
scanf("%d %d %d", &n, &m, &h);
int i;
for (i = 1; i <= n; i++) scanf("%d", &u[i]);
for (i = 1; i <= m; i++) {
int x, y;
scanf("%d %d", &x, &y);
if ((u[x] + 1) % h == u[y]) g[x].push_back(y);
if ((u[y] + 1) % h == u[x]) g[y].push_back(x);
}
for (i = 1; i <= n; i++) {
if (!pre[i]) dfs(i);
}
for (i = 1; i <= n; i++) {
for (int j = 0; j < g[i].size(); j++) {
int x = i, y = g[i][j];
if (sccno[x] == sccno[y]) continue;
out[sccno[x]] = 1;
}
}
int ans = 1e9, idx;
for (i = 1; i <= cnt; i++) {
if (!out[i] && sz[i] < ans) {
ans = sz[i];
idx = i;
}
}
printf("%d\n", ans);
for (i = 1; i <= n; i++) {
if (sccno[i] == idx) printf("%d ", i);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
set<int> G2[112345], gt2[112345];
vector<int> G[112345], gt[112345], gcond[112345];
int comp[112345], N, cantcomp, used[112345], tam[112345], cant[112345];
stack<int> pila;
void add(int a, int b) {
G2[a].insert(b);
gt2[b].insert(a);
}
void dfs1(int nodo) {
used[nodo] = 1;
for (auto it = G[nodo].begin(); it != G[nodo].end(); it++)
if (!used[*it]) dfs1(*it);
pila.push(nodo);
}
void dfs2(int nodo) {
used[nodo] = 2;
comp[nodo] = cantcomp - 1;
tam[cantcomp - 1]++;
for (auto it = gt[nodo].begin(); it != gt[nodo].end(); it++)
if (used[*it] != 2) dfs2(*it);
}
void kosaraju() {
cantcomp = 0;
memset(used, 0, sizeof(used));
for (int i = (0); i < (N); i++)
if (!used[i]) dfs1(i);
while (!pila.empty()) {
if (used[pila.top()] != 2) {
cantcomp++;
dfs2(pila.top());
}
pila.pop();
}
for (int i = (0); i < (N); i++)
for (auto it = G[i].begin(); it != G[i].end(); it++)
if (comp[i] != comp[*it]) gcond[comp[i]].push_back(comp[*it]);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m, h, v[112345], a, b, ans;
cin >> n >> m >> h;
ans = N = n;
for (int i = (0); i < (n); i++) cin >> v[i];
for (int i = (0); i < (m); i++) {
cin >> a >> b;
a--;
b--;
if ((v[a] + 1) % h == v[b]) add(a, b);
if ((v[b] + 1) % h == v[a]) add(b, a);
}
for (int i = (0); i < (N); i++)
for (auto it = G2[i].begin(); it != G2[i].end(); it++) G[i].push_back(*it);
for (int i = (0); i < (N); i++)
for (auto it = gt2[i].begin(); it != gt2[i].end(); it++)
gt[i].push_back(*it);
for (int i = (0); i < (n); i++)
if (G[i].empty()) {
cout << "1\n" << i + 1 << "\n";
return 0;
}
kosaraju();
for (int i = (0); i < (cantcomp); i++)
if (gcond[i].empty()) ans = min(ans, tam[i]);
cout << ans << "\n";
for (int i = (0); i < (cantcomp); i++)
if (gcond[i].empty() && ans == tam[i]) {
for (int j = (0); j < (n); j++)
if (comp[j] == i) cout << j + 1 << ' ';
cout << "\n";
break;
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.