text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
string gs(char x) {
string s(1, x);
return s;
}
vector<long long> v[100001];
bool vis[100001];
long long numnode, numedge;
void dfs(long long c) {
numnode++;
numedge += v[c].size();
vis[c] = true;
for (long long i = 0; i < v[c].size(); i++) {
if (!vis[v[c][i]]) {
dfs(v[c][i]);
}
}
}
int main() {
ios::sync_with_stdio(false);
long long n, m;
cin >> n >> m;
long long a, b;
for (long long i = 0; i < m; i++) {
cin >> a >> b;
v[a].push_back(b);
v[b].push_back(a);
}
long long ans = 0;
for (long long i = 1; i <= n; i++) {
if (!vis[i]) {
numedge = 0;
numnode = 0;
dfs(i);
numedge /= 2;
if (numnode == numedge + 1) ans += 1;
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000000;
vector<int> a[maxn];
bool mark[maxn];
int j = 1;
void dfs(int v, int y) {
mark[v] = true;
for (int i = 0; i < a[v].size(); i++) {
int g = a[v][i];
if (mark[g] == false) {
dfs(g, v);
} else if (a[v][i] != y) {
j = 0;
}
}
}
int main() {
ios::sync_with_stdio(false);
int n;
int m;
int ans = 0;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int b, c;
cin >> b >> c;
b--;
c--;
a[b].push_back(c);
a[c].push_back(b);
}
for (int i = 0; i < n; i++) {
if (!mark[i]) {
j = 1;
dfs(i, -1);
ans += j;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long int;
using ld = long double;
inline int in() {
int n;
scanf("%d", &n);
return n;
}
const ll maxn = 1e5 + 1;
vector<int> adj[maxn];
bool visited[maxn];
bool dfs(int v, int p) {
visited[v] = true;
for (int u : adj[v]) {
if (visited[u] and u != p) return true;
if (!visited[u] and dfs(u, v)) return true;
}
return false;
}
int main() {
int n = in(), m = in();
for (int i = 0; i < m; i++) {
int u = in() - 1, v = in() - 1;
adj[u].push_back(v);
adj[v].push_back(u);
}
int ans = 0;
for (int v = 0; v < n; v++) {
if (!visited[v]) dfs(v, -1) ? ans = ans : ans++;
}
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
const int mod = 1e9 + 7;
const int B = sqrt(N);
int n, m;
int g;
int ans;
bool used[N];
vector<int> v[N];
void dfs(int x, int p) {
used[x] = true;
for (auto y : v[x]) {
if (y == p) continue;
if (used[y])
g = 0;
else
dfs(y, x);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int x, y;
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
for (int i = 1; i <= n; i++) {
if (!used[i]) {
g = 1;
dfs(i, i);
ans += g;
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
int vis[maxn];
vector<int> edge[maxn];
void dfs(int root, int &cnt, int &nd) {
vis[root] = 1;
for (int i = 0; i < edge[root].size(); i++) {
int nt = edge[root][i];
cnt++;
if (!vis[nt]) {
nd++;
dfs(nt, cnt, nd);
}
}
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
edge[u].push_back(v);
edge[v].push_back(u);
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
int cnt = 0, nd = 1;
dfs(i, cnt, nd);
if (cnt / 2 < nd) ans++;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<int> g[200100];
int ciclo, vis[200100];
void dfs(int x, int pai = -1) {
if (vis[x]) return;
vis[x] = 1;
for (int i = 0; i < g[x].size(); ++i) {
int y = g[x][i];
if (y == pai) continue;
if (vis[y] == 1)
ciclo = 1;
else if (vis[y] == 0)
dfs(y, x);
}
vis[x] = 2;
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < m; ++i) {
int x, y;
scanf("%d %d", &x, &y);
g[x].push_back(y);
g[y].push_back(x);
}
int ans = 0;
for (int i = 1; i <= n; ++i) {
if (!vis[i]) {
ciclo = 0;
dfs(i);
if (!ciclo) ans++;
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Node {
vector<int> arr;
};
bool cycle(vector<Node> &arr, vector<bool> &visited, int idx, int parent) {
Node &n = arr[idx];
int Q = n.arr.size();
int flag = false;
for (int q = (0); q < (Q); ++q) {
int to = n.arr[q];
if (to != parent) {
if (visited[to]) {
flag = true;
} else {
visited[to] = true;
flag |= cycle(arr, visited, to, idx);
}
}
}
return flag;
}
int main() {
int N, M;
cin >> N >> M;
vector<Node> arr(N);
vector<bool> vis(N, false);
for (int n = (0); n < (M); ++n) {
int a, b;
cin >> a >> b;
a--;
b--;
arr[a].arr.push_back(b);
arr[b].arr.push_back(a);
}
int sum = 0;
for (int n = (0); n < (N); ++n) {
if (!vis[n]) {
vis[n] = true;
sum += 1 - (cycle(arr, vis, n, n));
}
}
cout << sum << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 1;
int pa[maxn], cnt[maxn], e[maxn];
int n, m;
inline void init() {
for (int i = 1; i <= n; ++i) {
pa[i] = i;
cnt[i] = 1;
e[i] = 0;
}
}
int findpa(int id) { return pa[id] == id ? id : pa[id] = findpa(pa[id]); }
void merge(int x, int y) {
x = findpa(x), y = findpa(y);
if (x != y) {
if (cnt[x] > cnt[y]) swap(x, y);
cnt[y] += cnt[x];
e[y] += e[x] + 1;
cnt[x] = 0;
e[x] = 0;
pa[x] = y;
} else
e[x] += 1;
}
int main() {
scanf("%d %d", &n, &m);
init();
for (int i = 1; i <= m; ++i) {
int u, v;
scanf("%d %d", &u, &v);
merge(u, v);
}
int ans = 0;
for (int i = 1; i <= n; ++i) {
if (cnt[i] == e[i] + 1) ++ans;
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxx = 1e5 + 5;
bool mark[maxx];
int ans = 0, num = 0;
int par[maxx], h[maxx], deg[maxx];
vector<int> v[maxx];
void dfs(int x) {
mark[x] = 1;
for (int i = 0; i < v[x].size(); i++) {
int child = v[x][i];
if (mark[child] == 1 && h[child] < h[x] && child != par[x]) ans++;
if (!mark[child]) {
h[child] = h[x] + 1;
par[child] = x;
ans++;
num++;
dfs(child);
}
}
}
int main() {
int n, m, answer = 0;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int fi, se;
cin >> fi >> se;
v[fi].push_back(se);
v[se].push_back(fi);
deg[fi]++;
deg[se]++;
}
for (int i = 1; i <= n; i++)
if (!mark[i]) {
ans = 0;
num = 1;
dfs(i);
if (ans < num) answer++;
}
cout << answer;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
long long a, idx, d;
};
long long n, m, k;
vector<vector<long long> > v;
vector<long long> vis;
vector<long long> par;
long long flag;
void dfs(long long u) {
vis[u] = 1;
for (auto x : v[u]) {
if (x == par[u]) continue;
if (vis[x] == 2)
continue;
else if (vis[x] == 1) {
flag = 1;
} else {
par[x] = u;
dfs(x);
}
}
vis[u] = 2;
}
void solve() {
long long i, j, x, y, z;
cin >> n >> m;
v.resize(n + 1);
for (i = 0; i < m; i++) {
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
vis.resize(n + 1, 0);
par.resize(n + 1, 0);
long long ans = 0;
for (i = 1; i < n + 1; i++) {
if (vis[i] == 0) {
flag = 0;
dfs(i);
if (flag == 0) ans++;
}
}
cout << ans << endl;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long t = 1;
while (t--) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int m;
int ans;
bool used[100001];
vector<int> es[100001];
bool dfs(int v, int p) {
bool found = 0;
used[v] = 1;
for (int i = 0; i < es[v].size(); i++) {
int u = es[v][i];
if (used[u]) {
if (u != p) found = 1;
continue;
}
found |= dfs(u, v);
}
return found;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d%d", &a, &b);
--a;
--b;
es[a].push_back(b);
es[b].push_back(a);
}
for (int i = 0; i < n; i++) {
if (!used[i]) {
if (!dfs(i, i)) ans++;
}
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<set<int>> con(n + 1);
for (int i = 0; i < m; ++i) {
int a, b;
cin >> a >> b;
con[a].insert(b);
con[b].insert(a);
}
vector<bool> used(n + 1, false);
int ans = 0;
for (int i = 1; i <= n; ++i) {
if (not used[i]) {
used[i] = true;
bool cycled = false;
queue<int> que;
que.push(i);
while (not que.empty()) {
int cur = que.front();
que.pop();
for (auto t : con[cur]) {
if (used[t]) {
cycled = true;
} else {
used[t] = true;
que.push(t);
}
con[t].erase(cur);
}
con[cur].clear();
}
ans += (not cycled);
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> g[100005];
bool bio[100005];
int cnt = 0;
bool fl;
void dfs(int v, int pret) {
bio[v] = 1;
for (auto x : g[v]) {
if (!bio[x])
dfs(x, v);
else if (pret != x)
fl = false;
}
}
int main() {
ios_base::sync_with_stdio(false);
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
a--, b--;
g[a].push_back(b);
g[b].push_back(a);
}
for (int i = 0; i < n; i++) {
fl = true;
if (!bio[i]) dfs(i, -1), cnt += fl;
}
cout << cnt;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void umax(T &x, T y) {
if (y > x) x = y;
}
template <class T>
inline void umin(T &x, T y) {
if (y < x) x = y;
}
const int N = 1e5 + 9;
const int INF = 2 * 1e9 + 9;
int n, m, ans, g;
int vis[N];
vector<int> E[N];
void dfs(int nd, int pr) {
vis[nd] = 1;
for (int i = 0; i < E[nd].size(); i++) {
if (E[nd][i] == pr) continue;
if (vis[E[nd][i]] == 0)
dfs(E[nd][i], nd);
else if (vis[E[nd][i]] == 1)
g = 0;
}
vis[nd] = 2;
}
int main() {
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int x, y;
cin >> x >> y;
E[x].push_back(y);
E[y].push_back(x);
}
for (int i = 1; i <= n; i++) {
if (vis[i] == 0) {
g = 1;
dfs(i, -1);
ans += g;
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
struct Sync_stdio {
Sync_stdio() {
cin.tie(NULL);
ios_base::sync_with_stdio(false);
}
} _sync_stdio;
vector<vector<int>> g;
vector<int> used;
int flag = 1;
void dfs(int x, int p = -1) {
used[x] = 1;
for (auto i : g[x]) {
if (used[i] && i != p) {
flag = 1;
}
if (used[i]) {
continue;
}
dfs(i, x);
}
}
int main() {
int n, m;
cin >> n >> m;
g.resize(n);
used.resize(n);
for (int i = (0); i < (m); ++i) {
int x, y;
cin >> x >> y;
--x, --y;
g[x].push_back(y);
g[y].push_back(x);
}
long long res = 0;
for (int i = (0); i < (n); ++i) {
flag = 0;
if (!used[i]) {
dfs(i);
res += !flag;
}
}
cout << res;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<set<int>> con(n + 1);
for (int i = 0; i < m; ++i) {
int a, b;
cin >> a >> b;
con[a].insert(b);
con[b].insert(a);
}
vector<bool> used(n + 1, false);
int ans = 0;
for (int i = 1; i <= n; ++i) {
if (not used[i]) {
used[i] = true;
bool cycled = false;
deque<int> que = {i};
while (not que.empty()) {
int cur = que.front();
que.pop_front();
for (auto t : con[cur]) {
if (used[t]) {
cycled = true;
} else {
used[t] = true;
que.push_back(t);
}
con[t].erase(cur);
}
con[cur].clear();
}
ans += (not cycled);
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 0x3f3f3f3f;
const int MAXL = 0x7ffff;
inline void read(int &x) {
x = 0;
char c = getchar();
while (c > '9' || c < '0') c = getchar();
while (c <= '9' && c >= '0') {
x = x * 10 + c - '0';
c = getchar();
}
}
inline void write(int re) {
if (re > 9) write(re / 10);
putchar(re % 10 + '0');
}
int ans, fat[100010], n, m;
bool vis[100100];
inline int find(register int x) {
if (x == fat[x]) return x;
return fat[x] = find(fat[x]);
}
int main() {
read(n);
read(m);
ans = n;
for (register int i = 0; i <= n; i++) fat[i] = i;
for (register int i = 0; i < m; i++) {
register int a, b;
read(a);
read(b);
register int fa = find(a);
register int fb = find(b);
if (fa == fb && !vis[fa]) {
ans--;
vis[fa] = 1;
} else if (fa != fb) {
ans--;
if (vis[fa] == 1 && vis[fb] == 1) ans++;
if (vis[fa] == 1 || vis[fb] == 1) vis[fa] = 1, vis[fb] = 1;
fat[fb] = fa;
}
}
if (ans >= 0)
cout << ans;
else
cout << 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dx[] = {1, 0, -1, 0};
int dy[] = {0, 1, 0, -1};
const int N = (int)1e6 + 7;
const int MOD = (int)1e9 + 7;
const int INF = (int)2e7;
const long long BIG = 1e18;
int used[N], cycle = 0;
vector<vector<int> > g(N);
void dfs(int v, int p = -1) {
used[v] = 1;
for (auto to : g[v]) {
if (used[to] == 1)
if (to != p) cycle = 1;
if (used[to] == 0) dfs(to, v);
}
used[v] = 2;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
;
int n, m;
cin >> n >> m;
while (m--) {
int u, v;
cin >> u >> v;
g[u].push_back(v), g[v].push_back(u);
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (!used[i]) {
cycle = 0;
dfs(i);
ans += !cycle;
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std::chrono;
using namespace std;
void setIO(string inoutname) {
freopen((inoutname + ".in").c_str(), "r", stdin);
freopen((inoutname + ".out").c_str(), "w", stdout);
}
vector<long long> g[100005];
long long n, m;
bool vis[100005];
bool ncik;
void dfs(long long u, long long par) {
vis[u] = 1;
for (long long s : g[u]) {
if (s == par) continue;
if (vis[s])
ncik = 0;
else
dfs(s, u);
}
}
int main() {
ios_base::sync_with_stdio(false);
cerr.tie(0);
cout.tie(0);
cin.tie(0);
cin >> n >> m;
for (int i = 1; i <= m; i++) {
long long u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
if (vis[i]) continue;
ncik = 1;
dfs(i, i);
if (ncik) ans++;
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, M;
bool group[100001];
vector<int> Map[100001];
bool flag;
void search(int v, int par) {
group[v] = true;
for (int i = 0; i < Map[v].size(); i++) {
int now = Map[v][i];
if (now == par) continue;
if (group[now])
flag = true;
else
search(now, v);
}
}
int main() {
scanf("%d%d", &N, &M);
int a, b;
for (int i = 0; i < M; i++) {
scanf("%d%d", &a, &b);
Map[a].push_back(b);
Map[b].push_back(a);
}
int ans = 0;
for (int i = 1; i <= N; i++)
if (!group[i]) {
flag = false;
search(i, 0);
if (!flag) ans++;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long thien, used[300001], n, m, u, v, kq, tmp;
vector<long long> g[300001];
void dfs(long long u) {
for (long long ii = 0; ii < g[u].size(); ii++) {
v = g[u][ii];
if (used[v] == 0) {
used[v] = u;
tmp = u;
dfs(v);
} else if (used[u] != v) {
thien = 0;
}
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin >> n >> m;
for (long long i = 1; i <= m; i++) {
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
for (long long i = 1; i <= n; i++) {
thien = 1;
tmp = -1;
if (used[i] == 0) {
used[i] = -1;
dfs(i);
kq += thien;
}
}
cout << kq;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, x, y, c[100500], ans;
vector<int> g[100500];
bool dfs(int v, int p = -1) {
c[v] = 1;
for (int i = 0; i < g[v].size(); ++i) {
int to = g[v][i];
if (to == p) continue;
if (c[to] == 0) {
if (dfs(to, v)) return true;
} else if (c[to] == 1)
return true;
}
c[v] = 2;
return false;
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; ++i) {
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
for (int i = 1; i <= n; ++i)
if (c[i] == 0) ans += !dfs(i);
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 9;
vector<int> adj[N];
int vis[N], finalvis[N], tarnode = 1;
vector<int> vec;
void dfs(int child, int par) {
vis[child] = 1;
for (auto node : adj[child]) {
if (node != par and vis[node]) {
tarnode = node;
vec.push_back(tarnode);
}
if (node != par and !vis[node]) {
dfs(node, child);
}
}
}
void dfs1(int child, int par) {
for (auto node : adj[child]) {
if (node != par and !finalvis[node]) {
finalvis[node] = 1;
dfs1(node, child);
}
}
}
int main() {
int n, m, u, v;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
for (int i = 1; i <= n; i++) {
if (!vis[i]) dfs(i, i);
}
for (auto val : vec) {
dfs1(val, val);
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (!finalvis[i]) dfs1(i, i), ans++;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > g;
bool used[100005];
int dfs(int v, int p = -1) {
if (used[v]) {
return 0;
}
used[v] = true;
int ans = 1;
for (int j : g[v]) {
if (j != p) {
ans = ans * dfs(j, v);
}
}
return ans;
}
int main() {
int n, m;
cin >> n >> m;
g.resize(n);
for (int i = 0; i < m; i++) {
int l, r;
cin >> l >> r;
l--, r--;
g[l].push_back(r);
g[r].push_back(l);
}
int ans = 0;
for (int i = 0; i < n; i++) {
if (!used[i]) {
ans += dfs(i);
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> vt[100010];
int vis[100010];
int cy;
void dfs(int r, int p) {
vis[r] = 1;
for (int i = 0; i < vt[r].size(); i++) {
if (vt[r][i] != p) {
if (vis[vt[r][i]])
cy = 1;
else
dfs(vt[r][i], r);
}
}
}
int main() {
ios::sync_with_stdio(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
vt[x].push_back(y);
vt[y].push_back(x);
}
int ans = 0;
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
cy = 0;
dfs(i, -1);
if (cy == 0) ans++;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
constexpr int MOD = 1000 * 1000 * 1000 + 7;
int n, m, ans;
vector<vector<int>> G;
vector<bool> marked;
int edges, vertices;
void dfs(int v) {
marked[v] = true;
++vertices;
edges += G[v].size();
for (int u : G[v])
if (!marked[u]) dfs(u);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
G.resize(n);
marked.resize(n);
for (int i = 0; i < m; ++i) {
int x, y;
cin >> x >> y;
--x;
--y;
G[x].push_back(y);
G[y].push_back(x);
}
for (int i = 0; i < n; ++i) {
if (!marked[i]) {
edges = vertices = 0;
dfs(i);
edges /= 2;
if (edges == vertices - 1) ++ans;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long int lcm(long long int a, long long int b) {
return b * a / gcd(a, b);
}
long long int abs1(long long int a) {
if (a < 0)
return -1 * a;
else
return a;
}
long long int max(long long int a, long long int b) {
if (a > b) return a;
return b;
}
long long int fast_pow(long long base, long long n) {
if (n == 0) return 1;
if (n == 1) return base;
long long halfn = fast_pow(base, n / 2);
if (n % 2 == 0)
return (halfn * halfn);
else
return (((halfn * halfn)) * base);
}
long long int findMMI_fermat(long long int n, long long int M) {
return fast_pow(n, M - 2);
}
const double PI = 3.14159265358979323846;
vector<int> x[100001];
bool b[100001];
int parent[1000001];
int loop = 0;
void dfs(int i, int parent1) {
if (b[i] == true) {
if (i != parent[parent1]) {
loop++;
}
return;
}
b[i] = true;
for (int j = 0; j < x[i].size(); j++) {
if (parent[x[i][j]] == 0) parent[x[i][j]] = i;
dfs(x[i][j], i);
}
}
int main() {
memset(b, false, sizeof(b));
int n, m;
cin >> n >> m;
while (m--) {
int x1, y;
cin >> x1 >> y;
x[x1].push_back(y);
x[y].push_back(x1);
}
int count = 0;
for (int i = 1; i <= n; i++) {
if (b[i] == false) {
dfs(i, 0);
if (loop > 0) {
loop = 0;
} else
count++;
}
}
cout << count;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
set<int> adj[N];
bool visited[N];
int disc[N], low[N], freq[N], id[N], cntr, ans;
vector<pair<int, int> > bridge;
vector<int> B[N];
void dfs_bridge(int u, int prev) {
visited[u] = true;
disc[u] = ++cntr, low[u] = disc[u];
for (auto v : adj[u]) {
if (v == prev) continue;
if (!visited[v]) {
dfs_bridge(v, u);
if (low[v] > disc[u]) bridge.push_back({u, v});
}
low[u] = min(low[u], low[v]);
}
}
void dfs_id(int u) {
visited[u] = 1;
id[u] = cntr;
freq[cntr]++;
for (auto v : adj[u])
if (!visited[v]) dfs_id(v);
}
bool ok;
void dfs_ans(int u) {
if (freq[u] != 1) ok = 0;
visited[u] = 1;
for (auto v : B[u])
if (!visited[v]) dfs_ans(v);
}
int main() {
int n, m, u, v;
cin >> n >> m;
while (m--) {
cin >> u >> v;
adj[u].insert(v);
adj[v].insert(u);
}
for (int i = 1; i <= n; i++)
if (!visited[i]) dfs_bridge(i, 0);
for (auto v : bridge) {
adj[v.first].erase(v.second);
adj[v.second].erase(v.first);
}
cntr = 0;
for (int i = 1; i <= n; i++) visited[i] = 0;
for (int i = 1; i <= n; i++) {
if (!visited[i]) {
cntr++;
dfs_id(i);
}
}
for (auto v : bridge) {
int a = id[v.first], b = id[v.second];
B[a].push_back(b);
B[b].push_back(a);
}
for (int i = 1; i <= cntr; i++) visited[i] = 0;
for (int i = 1; i <= cntr; i++) {
if (!visited[i]) {
ok = 1;
dfs_ans(i);
if (ok == 1) ans++;
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long linf = 1e18 + 5;
const int mod = (int)1e9 + 7;
const int logN = 17;
const int inf = 1e9;
const int N = 2e5 + 5;
int n, m, x, y, z, t, h[N];
vector<int> v[N];
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d %d", &x, &y);
v[x].push_back(y);
v[y].push_back(x);
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (h[i]) continue;
queue<int> q;
int t = 0, s = 0;
q.push(i);
h[i] = 1;
while (q.size()) {
int node = q.front();
q.pop();
s++;
t += v[node].size();
for (__typeof(v[node].begin()) it = v[node].begin(); it != v[node].end();
it++)
if (!h[*it]) {
q.push(*it);
h[*it] = 1;
}
}
t /= 2;
if (t + 1 == s) ans++;
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 101010;
int n, m, ans, vis[N], chuky;
vector<int> g[N];
void dfs(int u, int p) {
vis[u] = 1;
for (auto v : g[u]) {
if (v == p) continue;
if (vis[v] == 1)
chuky = 1;
else
dfs(v, u);
}
}
int main() {
ios::sync_with_stdio(0);
cin >> n >> m;
for (int i = (1); i <= (m); ++i) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
ans = 0;
for (int i = (1); i <= (n); ++i)
if (vis[i] == 0) {
chuky = 0;
dfs(i, i);
ans += (chuky == 0);
}
cout << ans;
cerr << "\nTime elapsed: " << 1000 * clock() / CLOCKS_PER_SEC << " ms\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
class Graph {
vector<vector<int>> edges;
int cycle;
int N;
vector<int> vis;
public:
Graph(int _N) {
N = _N;
edges.assign(N, vector<int>());
vis.assign(N, 0);
cycle = 0;
}
void addEdge(int x, int y) {
edges[x].push_back(y);
edges[y].push_back(x);
}
bool visited(int node) { return vis[node] > 0; }
void df(int node, int first) {
vis[node] = 1;
for (auto v : edges[node]) {
if (v == first) {
continue;
}
if (vis[v]) {
cycle = 1;
} else {
df(v, node);
}
}
}
int solve(int node) {
cycle = 0;
df(node, -1);
if (cycle) {
return 0;
} else {
return 1;
}
}
};
int main() {
int N, M;
cin >> N >> M;
Graph G(N);
for (int i = 0; i < M; ++i) {
int x, y;
cin >> x >> y;
x--;
y--;
G.addEdge(x, y);
}
int cnt = 0;
for (int i = 0; i < N; ++i) {
if (!G.visited(i)) {
cnt += G.solve(i);
}
}
cout << cnt << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dfs(int source, int prev, vector<set<int> > &adj, vector<bool> &vis,
bool &cycle) {
vis[source] = true;
for (set<int>::iterator it = adj[source].begin(); it != adj[source].end();
it++) {
if (*it != prev) {
if (vis[*it]) {
cycle = true;
} else
dfs(*it, source, adj, vis, cycle);
}
}
return (cycle ? 0 : 1);
}
int main() {
int n, m;
cin >> n >> m;
std::vector<set<int> > adj(n + 1);
int v1, v2;
for (int i = 0; i < m; i++) {
cin >> v1 >> v2;
adj[v1].insert(v2);
adj[v2].insert(v1);
}
std::vector<bool> vis(n + 1, false);
bool cycle;
int ans = 0;
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
cycle = false;
ans += dfs(i, -1, adj, vis, cycle);
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
bool vis[N];
vector<int> v[N];
int f;
void dfs(int i, int parent) {
vis[i] = 1;
for (int it : v[i]) {
if (!vis[it]) {
dfs(it, i);
} else {
if (it != parent) f = 1;
}
}
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= m; ++i) {
int a, b;
cin >> a >> b;
v[a].push_back(b);
v[b].push_back(a);
}
int ans = 0;
for (int i = 1; i <= n; ++i) {
if (!vis[i]) {
f = 0;
dfs(i, 0);
ans += !f;
}
}
cout << ans << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MX = 1e5 + 1;
int n, m, ans;
vector<vector<int> > A(MX);
bool vis[MX];
bool solve(int i, int pre = -1) {
if (vis[i]) return false;
vis[i] = true;
int ret = 1;
for (int j = 0; j < (int)A[i].size(); ++j)
if (A[i][j] != pre) ret = ret && solve(A[i][j], i);
return ret;
}
int main() {
cin >> n >> m;
for (int i = 1; i <= m; ++i) {
int a, b;
cin >> a >> b;
A[a].push_back(b);
A[b].push_back(a);
}
for (int i = 1; i <= n; ++i) ans += solve(i);
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> edges[100001];
bool visited[100001] = {false};
bool dfs(int v, int prev) {
if (visited[v]) return true;
visited[v] = true;
bool res = false;
for (auto t : edges[v]) {
if (t == prev) continue;
res |= dfs(t, v);
}
return res;
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int x, y;
cin >> x >> y;
edges[x].push_back(y);
edges[y].push_back(x);
}
int res = 0;
for (int i = 1; i <= n; ++i) {
if (visited[i]) continue;
bool has_loop = dfs(i, -1);
res += has_loop ? 0 : 1;
}
cout << res << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
int vis[200001] = {0};
vector<int> v[200001];
int main() {
int n, m, x, y, c = 0;
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
vector<int> q;
for (int i = 1; i <= n; i++) {
if (vis[i] == 0) {
q.push_back(i);
int j = 0, tag1 = true;
while (1) {
int k = q[j];
int tag = true;
vis[k] = 2;
for (int l = 0; l < v[k].size(); l++) {
if (vis[v[k][l]] == 1)
tag1 = false;
else if (vis[v[k][l]] == 0) {
q.push_back(v[k][l]);
tag = false;
vis[v[k][l]] = 1;
}
}
if (tag == true && j == q.size() - 1) break;
j++;
}
if (tag1 == true) c++;
}
q.clear();
}
cout << c;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<int> adj[100005];
int edges, vertices;
void dfs(bool vis[], int src) {
vis[src] = true;
vertices++;
for (int i = 0; i < adj[src].size(); i++) {
edges++;
if (!vis[adj[src][i]]) dfs(vis, adj[src][i]);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
x--;
y--;
adj[x].push_back(y);
adj[y].push_back(x);
}
int ans = 0;
bool vis[n];
memset(vis, false, sizeof(vis));
for (int i = 0; i < n; i++) {
if (!vis[i]) {
edges = 0;
vertices = 0;
dfs(vis, i);
if (edges / 2 == vertices - 1) ans++;
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100100;
bool vis[N], cycle;
vector<vector<int> > g;
void dfs(int u, int p) {
if (vis[u]) {
cycle = true;
return;
}
vis[u] = true;
for (int i = 0; i < (int)g[u].size(); ++i)
if (g[u][i] != p) dfs(g[u][i], u);
}
int main(int argc, char const *argv[]) {
int n, m;
scanf("%d%d", &n, &m);
g.resize(n);
for (int i = 0, u, v; i < m; ++i) {
scanf("%d%d", &u, &v);
--u;
--v;
g[u].push_back(v);
g[v].push_back(u);
}
int ans = 0;
for (int i = 0; i < n; ++i) {
if (!vis[i]) {
cycle = false;
dfs(i, -1);
ans += !cycle;
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, u, v, edges, ans;
vector<long long> adj[100001], nodes;
bool visit[100001];
void dfs(int node) {
nodes.push_back(node);
visit[node] = 1;
for (long long i = 0; i < adj[node].size(); i++) {
if (!visit[adj[node][i]]) dfs(adj[node][i]);
}
}
int main() {
cin >> n >> m;
for (long long i = 0; i < m; i++) {
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
for (long long i = 1; i <= n; i++) {
if (!visit[i]) {
nodes.clear();
edges = 0;
dfs(i);
for (long long i = 0; i < nodes.size(); i++)
edges += adj[nodes[i]].size();
if (edges / 2 < nodes.size()) ans++;
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> g[100005];
bool vis[100005] = {0};
bool dfs(long long u, long long par) {
vis[u] = 1;
long long sz = g[u].size();
for (long long i = (long long)(0); i <= (long long)(sz - 1); i++) {
if (!vis[g[u][i]]) {
if (dfs(g[u][i], u)) return 1;
} else {
if (g[u][i] != par) {
return 1;
}
}
}
return 0;
}
int main() {
std::ios::sync_with_stdio(false);
long long n, m, a, b;
cin >> n >> m;
for (long long i = (long long)(1); i <= (long long)(m); i++) {
cin >> a >> b;
g[a].push_back(b);
g[b].push_back(a);
}
long long c = 0;
for (long long i = (long long)(1); i <= (long long)(n); i++) {
if (!vis[i]) {
if (!dfs(i, -1)) c++;
}
}
cout << c << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 500009;
const int mod = 1000000007;
long long int n, m, x, y;
vector<long long int> v[N];
vector<bool> vis;
bool is;
void pre() { vis.assign(N, 0); }
void dfs(long long int ver, long long int par) {
vis[ver] = 1;
for (auto &it : v[ver]) {
if (it == par) continue;
if (vis[it] == 1) {
is = 1;
continue;
}
dfs(it, ver);
}
}
int32_t main() {
pre();
cin >> n >> m;
for (long long int i = 0; i < m; i++) {
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
long long int ans = 0;
for (long long int i = 1; i <= n; i++) {
if (vis[i]) continue;
is = 0;
dfs(i, -1);
ans++;
if (is) ans--;
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
struct Nod {
int b, next;
void init(int b, int next) {
this->b = b;
this->next = next;
}
} buf[maxn];
int n, m, len, E[maxn];
int vis[maxn], sep[maxn];
void init() {
len = 0;
memset(E, -1, sizeof(E));
memset(vis, 0, sizeof(vis));
memset(sep, 0, sizeof(sep));
}
void add_edge(int a, int b) {
buf[len].init(b, E[a]);
E[a] = len++;
buf[len].init(a, E[b]);
E[b] = len++;
}
void dfs(int u, int pre) {
int i, v;
for (i = E[u]; i != -1; i = buf[i].next) {
v = buf[i].b;
if (v == pre) continue;
if (vis[v])
sep[v] = 1;
else {
vis[v] = 1;
dfs(v, u);
}
}
}
bool find(int u, int pre) {
int i, v, ans = sep[u];
for (i = E[u]; i != -1; i = buf[i].next) {
v = buf[i].b;
if (v == pre || vis[v] == 2) continue;
vis[v] = 2;
ans |= find(v, u);
}
return ans;
}
int main() {
int i, j, u, v;
scanf("%d%d", &n, &m);
init();
while (m--) {
scanf("%d%d", &u, &v);
add_edge(u, v);
}
int ans = 0;
for (i = 1; i <= n; i++) {
if (vis[i]) continue;
dfs(i, -1);
ans += !find(i, -1);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool vis[100005];
int in[100005];
vector<int> V[100005];
bool cy = 0;
void Cyclic(int u, int p) {
int i, v;
for (i = 0; i < V[u].size(); i++) {
v = V[u][i];
if (v == p) continue;
if (vis[v]) {
cy = 1;
continue;
}
vis[v] = 1;
Cyclic(v, u);
}
}
int main(int argc, const char* argv[]) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int c = 0, n, m, i, j, u, v;
cin >> n >> m;
for (i = 0; i < m; i++) {
cin >> u >> v;
V[u].push_back(v);
V[v].push_back(u);
}
for (i = 1; i <= n; i++) {
if (!vis[i]) {
cy = 0;
vis[i] = 1;
Cyclic(i, 0);
if (cy == 0) c++;
}
}
cout << c;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = (int)1e9 + 7;
const int INF = (int)1e9;
const long long LINF = (long long)1e18;
const long double PI = acos((long double)-1);
const long double EPS = 1e-9;
long long gcd(long long a, long long b) {
long long r;
while (b) {
r = a % b;
a = b;
b = r;
}
return a;
}
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
long long fpow(long long n, long long k, int p = MOD) {
long long r = 1;
for (; k; k >>= 1) {
if (k & 1) r = r * n % p;
n = n * n % p;
}
return r;
}
template <class T>
void setmin(T& a, T val) {
if (a > val) a = val;
}
template <class T>
void setmax(T& a, T val) {
if (a < val) a = val;
}
void addmod(int& a, int val, int p = MOD) {
if ((a = (a + val)) >= p) a -= p;
}
void submod(int& a, int val, int p = MOD) {
if ((a = (a - val)) < 0) a += p;
}
int mult(int a, int b, int p = MOD) { return (long long)a * b % p; }
int inv(int a, int p = MOD) { return fpow(a, p - 2, p); }
const int maxn = 100010;
int n, m;
int dj[maxn];
int sz[maxn];
int tot[maxn];
void init() {
for (int i = (0); i < (n); i++) dj[i] = i, sz[i] = 1;
}
int find(int u) { return dj[u] == u ? dj[u] : dj[u] = find(dj[u]); }
void join(int u, int v) {
int p = find(u);
int q = find(v);
if (p != q) {
dj[p] = q;
tot[q] += tot[p];
sz[q] += sz[p];
}
tot[q]++;
}
void solve() {
cin >> n >> m;
init();
for (int i = (0); i < (m); i++) {
int u, v;
cin >> u >> v;
u--;
v--;
join(u, v);
}
int ans = 0;
for (int i = (0); i < (n); i++) {
if (dj[i] == i) {
if (tot[i] < sz[i]) {
ans++;
}
}
}
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<vector<int> > g;
vector<vector<int> > parts;
vector<bool> used;
void dfs(int v) {
used[v] = true;
parts[parts.size() - 1].push_back(v);
for (int i = 0; i < g[v].size(); ++i) {
int to = g[v][i];
if (!used[to]) {
dfs(to);
}
}
}
bool tree(vector<int> data) {
int kr = 0;
for (int i = 0; i < data.size(); ++i) {
kr += g[data[i]].size();
}
if (kr / 2 == data.size() - 1) {
return true;
}
return false;
}
int main() {
cin >> n >> m;
used.resize(n, false);
g.resize(n);
for (int i = 0; i < m; ++i) {
int l, r;
cin >> l >> r;
l--;
r--;
g[l].push_back(r);
g[r].push_back(l);
}
for (int i = 0; i < n; ++i) {
if (!used[i]) {
vector<int> a;
parts.push_back(a);
dfs(i);
}
}
used.resize(n, false);
int cnt = 0;
for (int i = 0; i < parts.size(); ++i) {
if (tree(parts[i])) {
cnt++;
}
}
cout << cnt;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100010;
int pre[MAXN];
int faind(int x) {
if (pre[x] == x) return x;
int fd = faind(pre[x]);
pre[x] = fd;
return fd;
}
bool fk[MAXN];
void join(int a, int b) {
int fa = faind(a), fb = faind(b);
if (fa == fb) {
fk[fa] = true;
return;
}
if (fk[fa] || fk[fb]) fk[fa] = fk[fb] = true;
if (fa < fb)
pre[fb] = fa;
else
pre[fa] = fb;
}
int main() {
int n, m, u, v, cnt = 0;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
pre[i] = i;
fk[i] = false;
}
for (int i = 0; i < m; i++) {
scanf("%d%d", &u, &v);
join(u, v);
}
for (int i = 1; i <= n; i++) {
if (!fk[faind(i)]) {
cnt++;
fk[faind(i)] = true;
}
}
printf("%d\n", cnt);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m = 0, k = 0;
bool test = false, test1 = false;
long long const N = 1e5 + 7;
bool check(int p, int n) {
int temp = p, count = 0, f = 5;
while (f <= temp) {
count += temp / f;
f = f * 5;
}
return (count >= n);
}
int findNum(int n) {
if (n == 1) return 5;
int low = 0;
int high = 5 * n;
while (low < high) {
int mid = (low + high) >> 1;
if (check(mid, n))
high = mid;
else
low = mid + 1;
}
return low;
}
long long const oo = 1000000007;
long long nChoosek(long long n, long long k) {
if (k > n) return 0;
if (k * 2 > n) k = n - k;
if (k == 0) return 1;
long long result = n;
for (long long i = 2; i <= k; ++i) {
result *= (n - i + 1);
result /= i;
}
return result;
}
vector<long long> v, v1;
vector<pair<long long, long long> > vv;
map<long long, long long> my;
map<long long, long long> my1;
priority_queue<long long> q;
long long t[N];
long long t1[N];
long long dx[4] = {0, 1, 0, -1};
long long dy[4] = {1, 0, -1, 0};
bool in_da_prison(long long x, long long y) {
return (x < 9 && x >= 0 && y < 9 && y >= 0);
}
long long dp(long long i) {
if (i == 0) return 1;
if (i < 0) return 0;
if (t[i] != -1) return t[i];
long long choice1 = dp(i - 1) % oo;
long long choice2 = dp(i - k) % oo;
return t[i] = (choice1 % oo + choice2 % oo) % oo;
}
vector<long long> v2[N];
long long z[N], pr[N];
void dfs(long long s) {
if (z[s]) return;
z[s] = 1;
for (long long u = 0; u < v2[s].size(); u++) {
if (!z[v2[s][u]])
pr[v2[s][u]] = s;
else {
if (pr[s] != v2[s][u]) test = true;
}
dfs(v2[s][u]);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long i = 0, j = 0, a = 0, b = 0, c = 0, d = 1e10, x = 0, y = 0, s = 0, t;
string s1, s2, s3, s4, s5;
cin >> n >> m;
memset(pr, -1, sizeof pr);
for (i = 0; i < m; i++) {
cin >> a >> b;
a--;
b--;
v2[a].push_back(b);
v2[b].push_back(a);
}
for (i = 0; i < n; i++) {
test = false;
if (!z[i]) {
dfs(i);
if (!test) s++;
}
}
cout << s;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long int ceil2(long long int a, long long int b) {
return (a + b - 1) / b;
}
inline long long int hcf(long long int n1, long long int n2) {
if (n2 != 0)
return hcf(n2, n1 % n2);
else
return n1;
}
long long binpow(long long a, long long b, long long m) {
a %= m;
long long res = 1;
while (b > 0) {
if (b & 1) res = res * a % m;
a = a * a % m;
b >>= 1;
}
return res;
}
int primefactor(int n) {
int cnt = 0;
while (n % 2 == 0) {
n /= 2;
cnt++;
}
for (int i = 3; (i * i) <= n; i += 2) {
while (n % i == 0) {
n /= i;
cnt++;
}
}
if (n > 2) {
cnt++;
}
return cnt;
}
inline void init_code() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
int n, m;
int ans;
vector<vector<int>> g;
vector<bool> vis;
bool dfs(int u, int par) {
vis[u] = true;
for (auto v : g[u]) {
if (v == par) {
continue;
}
if (vis[v]) {
return true;
}
if (!vis[v]) {
if (dfs(v, u)) {
return true;
}
}
}
return false;
}
bool ok;
void cc() {
for (int i = 1; i < (n + 1); i++) {
if (!vis[i]) {
ok = dfs(i, -1);
if (!ok) {
ans--;
}
}
}
}
int main() {
init_code();
cin >> n >> m;
g.resize(n + 1);
vis.assign(n + 1, false);
ans = n;
int xi, yi;
for (int i = 0; i < m; i++) {
cin >> xi >> yi;
g[xi].push_back(yi);
g[yi].push_back(xi);
}
cc();
cout << (n - ans) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int p[N], s[N];
bool us[N];
int Find(int u) { return p[u] == u ? u : (p[u] = Find(p[u])); }
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
p[i] = i;
s[i] = 1;
}
int res = n;
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d%d", &u, &v);
u = Find(u);
v = Find(v);
if (s[u] > s[v]) {
swap(u, v);
}
if (u != v) {
res--;
p[u] = v;
s[v] += s[u];
res += us[v] && us[u];
us[v] |= us[u];
} else if (!us[u]) {
res--;
us[u] = true;
}
}
printf("%d\n", res);
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
int pre[maxn];
int mark[maxn];
int ans;
int find(int x) {
int r = x;
while (pre[r] != r) {
r = pre[r];
}
int i = x, j;
while (i != r) {
j = pre[i];
pre[i] = r;
i = j;
}
return r;
}
void join(int x, int y) {
int fx = find(x);
int fy = find(y);
if (fx != fy) {
pre[fy] = fx;
if (mark[fy]) mark[fx] = 1;
} else {
mark[fy] = 1;
}
}
int main() {
int n, m;
while (scanf("%d%d", &n, &m) != EOF) {
memset(mark, 0, sizeof(mark));
ans = 0;
for (int i = 0; i < n; i++) pre[i] = i;
while (m--) {
int x, y;
scanf("%d%d", &x, &y);
join(x, y);
}
for (int i = 0; i < n; i++) {
if (pre[i] == i && !mark[i]) ans++;
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using pdd = pair<double, double>;
using vi = vector<int>;
using vii = vector<pii>;
using vs = vector<string>;
const double PI = acos(-1.0);
const double EPS = 1e-14;
const int MOD = 1e9 + 7;
const int INF = 1e9;
const ll INFLL = 4e18;
const int MAX = 1e5;
int N, M;
vi adj[MAX + 5];
bool vis[MAX + 5];
int par[MAX + 5];
int edges[MAX + 5], vertices[MAX + 5];
void init(int n) {
for (int i = (int)1; i <= (int)n; i++) {
par[i] = i;
}
}
int get_par(int x) {
if (par[x] != x) par[x] = get_par(par[x]);
return par[x];
}
bool is_united(int a, int b) { return get_par(a) == get_par(b); }
void unite(int a, int b) {
a = get_par(a);
b = get_par(b);
par[a] = b;
}
void read() {
cin >> N >> M;
for (int i = 0; i < (int)M; i++) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
init(N);
}
void dfs(int now, int par) {
vis[now] = true;
unite(now, par);
for (int f : adj[now]) {
if (!vis[f]) {
dfs(f, par);
}
}
}
void solve() {
for (int v = (int)1; v <= (int)N; v++) {
if (!vis[v]) {
dfs(v, v);
}
}
for (int v = (int)1; v <= (int)N; v++) {
vertices[get_par(v)]++;
edges[get_par(v)] += (int)adj[v].size();
}
ll ans = 0;
for (int v = (int)1; v <= (int)N; v++) {
if (v == get_par(v)) {
ans += max(0, vertices[v] - edges[v] / 2);
}
}
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int TC = 1;
while (TC--) {
read();
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-9;
const long long mod = 1e9 + 7;
const int max_n = 1000100;
bool vis[100100] = {0};
int par[100100];
vector<int> g[100100];
bool ok;
void dfs(int x) {
vis[x] = 1;
for (int i = 0; i < g[x].size(); i++) {
if (!vis[g[x][i]]) {
par[g[x][i]] = x;
dfs(g[x][i]);
} else {
if (g[x][i] != par[x]) ok = true;
}
}
}
int main() {
int n, m;
cin >> n >> m;
int x, y;
for (int i = 0; i < m; i++) {
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
int ans = 0;
for (int i = 1; i <= n; i++) {
ok = false;
if (!vis[i]) {
par[i] = -1;
dfs(i);
if (!ok) ++ans;
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int vis[100005], k, deg;
vector<int> g[100005];
void dfs(int v) {
vis[v] = 1;
k++;
for (auto u : g[v]) {
deg++;
if (vis[u] == 0) {
dfs(u);
}
}
}
int main() {
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
int ans = 0;
for (int i = 0; i < n; i++) {
if (!vis[i + 1]) {
k = 0;
deg = 0;
dfs(i + 1);
if (2 * k - 2 == deg) ans++;
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int in() {
int x;
scanf("%d", &x);
return x;
}
bool Check(int N, int pos) { return (bool)(N & (1 << pos)); }
int Set(int N, int pos) { return N = N | (1 << pos); }
int fx[] = {+0, +0, +1, -1, -1, +1, -1, +1};
int fy[] = {-1, +1, +0, +0, +1, +1, -1, -1};
int hr[] = {-2, -2, -1, +1, +2, +2, -1, +1};
int hc[] = {+1, -1, +2, +2, -1, +1, -2, -2};
int dx[] = {+1, -1, +0, +0};
int dy[] = {+0, +0, +1, -1};
const int MAXN = (int)1e5 + 9;
vector<int> g[MAXN];
int mark[MAXN], deg[MAXN], vert;
map<pair<int, int>, int> mp;
bool flag;
void dfs(int curr, int par) {
mark[curr] = 1;
vert++;
for (int i = 0; i < g[curr].size(); i++) {
int v = g[curr][i];
if (mark[v] == 1 && v != par)
mp[pair<int, int>(min(curr, v), max(curr, v))]++;
else if (!mark[v]) {
mp[pair<int, int>(min(curr, v), max(curr, v))]++;
dfs(v, curr);
}
}
}
int main() {
int i, j, k, l, m, n, p, q, x, y, u, v, r, tc, t;
n = in(), m = in();
memset(deg, 0, sizeof(deg));
for (i = 0; i < m; i++) {
u = in(), v = in();
g[u].push_back(v);
g[v].push_back(u);
deg[u]++, deg[v]++;
}
memset(mark, 0, sizeof(mark));
int ans = 0;
for (i = 1; i <= n; i++) {
v = i;
if (!mark[v]) {
vert = 0;
dfs(i, 0);
if (vert - 1 == mp.size()) ans++;
}
mp.clear();
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = ~(1 << 31);
const double pi = acos(-1);
set<int> got;
vector<int> edg[100020];
bool vis[100020];
void dfs(int at) {
if (vis[at]) return;
got.insert(at);
vis[at] = true;
for (__typeof((edg[at]).begin()) it = (edg[at]).begin();
it != (edg[at]).end(); ++it)
dfs(*it);
}
int main() {
cin.sync_with_stdio(false);
memset(vis, 0, sizeof(vis));
int n, m;
cin >> n >> m;
for (int i = (0); i < (m); i++) {
int a, b;
cin >> a >> b;
a--;
b--;
edg[a].push_back(b);
edg[b].push_back(a);
}
int cost = 0;
for (int i = (0); i < (n); i++) {
got.clear();
dfs(i);
int size = got.size();
int edges = 0;
for (__typeof((got).begin()) it = (got).begin(); it != (got).end(); ++it)
edges += edg[*it].size();
edges /= 2;
if (edges == size - 1) cost++;
}
cout << cost << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> c[100001];
vector<int> g[100001];
vector<int> ad[100001];
int l, k, a[100001], b, x, z, y, s, m, n, p, d;
bool mark[100001];
bool cmark[100001];
void dfs(int v) {
int u;
mark[v] = 1;
g[l].push_back(v);
z = ad[v].size();
for (int(u) : ad[v]) {
if (mark[u] == 0) {
a[u] = a[v] + 1;
dfs(u);
} else {
if (abs(a[v] - a[u]) != 1 && u != v) {
c[v].push_back(u);
c[v].push_back(u);
}
}
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> x >> y;
ad[x].push_back(y);
ad[y].push_back(x);
}
l = 1;
for (int i = 1; i <= n; i++) {
p = i;
d = 0;
if (mark[p] == 0) {
a[p] = 1;
dfs(p);
for (int(u) : g[l]) {
if (c[u].size() > 0) {
d = 1;
break;
}
}
if (d == 0) s++;
l++;
}
}
cout << s;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;
using lli = long long int;
using iii = tuple<int, int, int>;
using iiii = tuple<int, int, int, int>;
using ulli = unsigned long long int;
using ui = unsigned int;
using Bit = bitset<30>;
const int maxBit = 30;
const int maxN = 3e5;
const int block = 600;
const int cBlocks = maxN / block;
const int C = 1e3;
const int maxM = 2e5;
const int maxl = 18;
const int inf = 0x3f3f3f3f;
const lli INF = 0x3f3f3f3f3f3f3f3f;
const char sp = ' ';
const char dl = '\n';
const int mod = 998244353;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int test = 1;
while (test--) {
int n, m;
cin >> n >> m;
vector<vector<int>> Adj(n + 1);
for (int i = 1, u, v; i <= m; i++) {
cin >> u >> v;
Adj[u].push_back(v);
Adj[v].push_back(u);
}
vector<int> Mark(n + 1);
vector<bool> Visited(n + 1);
int res = 0;
int Connected_component = 0;
function<void(int)> DFS = [&](int u) {
Mark[u] = Connected_component;
Visited[u] = true;
for (int v : Adj[u])
if (!Visited[v]) DFS(v);
return;
};
for (int i = 1; i <= n; i++)
if (!Visited[i]) {
Connected_component++;
DFS(i);
}
vector<int> Sum_Vertex(Connected_component + 1),
Sum_Edge(Connected_component + 1);
for (int i = 1; i <= n; i++) {
Sum_Vertex[Mark[i]]++;
Sum_Edge[Mark[i]] += Adj[i].size();
}
for (int i = 1; i <= Connected_component; i++) {
if (Sum_Edge[i] / 2 < Sum_Vertex[i]) res++;
}
cout << res;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> graph[100010];
int visited[100010], par[100010], mk = 0;
void dfs(int s) {
visited[s] = 1;
for (int i = 0; i < graph[s].size(); i++) {
if (!visited[graph[s][i]]) {
par[graph[s][i]] = s;
dfs(graph[s][i]);
} else if (graph[s][i] != par[s])
mk = 1;
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
graph[a - 1].push_back(b - 1);
graph[b - 1].push_back(a - 1);
}
int ans = 0;
for (int i = 0; i < n; i++) {
if (!visited[i]) {
mk = 0;
dfs(i);
ans += 1 - mk;
}
}
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
long long cmax(long long a, long long b) { return (a > b ? a : b); }
long long cmax(long long a, long long b, long long c) {
return cmax(cmax(a, b), c);
}
long long cmin(long long a, long long b) { return (a < b ? a : b); }
long long cmin(long long a, long long b, long long c) {
return cmin(cmin(a, b), c);
}
void bfs(vector<long long> *g, bool *v, long long s, long long &cycle) {
queue<pair<long long, long long>> q;
v[s] = true;
q.push(make_pair(s, -1));
while (!q.empty()) {
pair<long long, long long> curr = q.front();
q.pop();
for (long long i = 0; i < g[curr.first].size(); i++) {
if (!v[g[curr.first][i]]) {
v[g[curr.first][i]] = true;
q.push(make_pair(g[curr.first][i], curr.first));
} else {
if (g[curr.first][i] != curr.second) {
cycle = 1;
}
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, m;
cin >> n >> m;
vector<long long> *g = new vector<long long>[n + 1];
for (long long i = 0; i < m; i++) {
long long x, y;
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
bool *v = new bool[n + 1];
for (long long i = 1; i <= n; i++) {
v[i] = false;
}
bool done = false;
long long ans = 0, first_unv = 1;
while (!done) {
long long cycle = 0;
bfs(g, v, first_unv, cycle);
ans += !cycle;
while (v[first_unv]) {
++first_unv;
if (first_unv == n + 1) {
done = true;
break;
}
}
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
constexpr int MAXN = 1e5 + 52;
int visited[MAXN], n, m, ans, h[MAXN];
vector<int> G[MAXN];
bool foundcycle = false;
void dfs(int u) {
visited[u] = 1;
for (auto v : G[u]) {
if (!visited[v]) {
h[v] = h[u] + 1;
dfs(v);
} else if (h[u] < h[v] - 1) {
foundcycle = true;
}
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
G[u].push_back(v);
G[v].push_back(u);
}
for (int i = 1; i <= n; i++) {
foundcycle = false;
if (!visited[i]) {
dfs(i);
if (!foundcycle) {
ans++;
}
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
const int M = 1e9 + 7;
const int N = 1e5 + 5;
using namespace std;
vector<long long int> v[N];
long long int indeg[26];
long long int vis[N], edge, ver;
bool cycle(long long int x) {
if (vis[x] == 2) return false;
if (vis[x] == 1) return true;
vis[x] = 1;
for (auto f : v[x]) {
if (cycle(f)) return true;
}
vis[x] = 2;
return false;
}
void dfs(long long int x) {
if (vis[x]) return;
vis[x] = 1;
++ver;
edge += v[x].size();
for (auto y : v[x]) {
dfs(y);
}
}
int main() {
long long int n, m;
cin >> n >> m;
for (long long int i = 0; i < m; ++i) {
long long int a, b;
cin >> a >> b;
v[a].push_back(b);
v[b].push_back(a);
}
long long int ans = 0;
for (long long int i = 1; i <= n; ++i) {
if (!vis[i]) {
ver = 0, edge = 0;
dfs(i);
edge /= 2;
ans += (edge < ver);
}
}
cout << ans << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long int> adj[100005];
long long int visited[100005];
long long int counter;
long long int answer;
long long int maxcounter = INT_MIN;
long long int n, m;
double countedges;
double countnodes;
void dfs(int i) {
visited[i] = 1;
countedges += adj[i].size() / 2.0;
countnodes++;
for (int j = 0; j < adj[i].size(); j++) {
if (!visited[adj[i][j]]) dfs(adj[i][j]);
}
}
int main() {
cin >> n >> m;
int a, b;
for (int i = 0; i < m; i++) {
scanf("%d", &a);
scanf("%d", &b);
adj[a - 1].push_back(b - 1);
adj[b - 1].push_back(a - 1);
}
for (int i = 0; i < n; i++) {
countedges = 0;
countnodes = 0;
if (!visited[i]) {
dfs(i);
}
if (countnodes == (countedges + 1)) {
answer++;
}
}
cout << answer << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int>> neighbors;
vector<int> colors;
bool cycles;
void dfs(int i, int parent) {
colors[i] = 1;
for (auto& neighbor : neighbors[i])
if (neighbor != parent) {
if (!colors[neighbor]) dfs(neighbor, i);
if (colors[neighbor] == 1) cycles = true;
}
colors[i] = 2;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int n, m;
cin >> n >> m;
neighbors.resize(n);
while (m--) {
int x, y;
cin >> x >> y;
--x;
--y;
neighbors[x].push_back(y);
neighbors[y].push_back(x);
}
int answer = 0;
colors.resize(n, 0);
for (int i = 0; i < n; ++i)
if (!colors[i]) {
cycles = false;
dfs(i, i);
answer += !cycles;
}
cout << answer;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, cnt, flag;
vector<int> graph[100005];
bool vis[100005];
void dfs(int node, int parent) {
vis[node] = 1;
int x, u, v, i;
cnt++;
for (i = 0; i < graph[node].size(); i++) {
v = graph[node][i];
if (v == parent) continue;
if (vis[v] == 1)
flag = 1;
else
dfs(v, node);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
int i, j, k, u, v, x, sum = 0;
for (i = 0; i < m; i++) {
cin >> u >> v;
graph[u].push_back(v);
graph[v].push_back(u);
}
for (i = 1; i <= n; i++) {
if (vis[i] == 0) {
cnt = 0;
flag = 0;
dfs(i, 0);
if (flag == 1)
sum += cnt;
else
sum += (cnt - 1);
}
}
cout << n - sum << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 2e5 + 5;
int n, m;
vector<int> adj[MAX_N];
bool vis[MAX_N];
bool cycle = false;
void dfs(int v, int p) {
vis[v] = true;
for (int u : adj[v]) {
if (u == p) continue;
if (vis[u])
cycle = true;
else
dfs(u, v);
}
}
void solve() {
int i = 0;
int comp = 0, cycles_comp = 0;
for (i = 0; i < n; i++) {
if (!vis[i]) {
cycle = false;
dfs(i, -1);
comp++;
cycles_comp += cycle;
}
}
cout << comp - cycles_comp << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
while (t--) {
cin >> n >> m;
int i = 0;
for (i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
x--;
y--;
adj[x].push_back(y);
adj[y].push_back(x);
}
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> v[100005];
vector<pair<int, int> > my;
int n, m, count1[100005], ans = 0, nodes, edges;
bool visited[100005];
void dfs(int s, int p) {
bool flag = true;
visited[s] = true;
edges += count1[s];
nodes++;
for (int i = 0; i < v[s].size(); ++i) {
if (!visited[v[s][i]]) {
visited[v[s][i]] = true;
dfs(v[s][i], s);
}
}
}
bool cmpr(pair<int, int> a, pair<int, int> b) {
if (a.second != b.second) {
return a.second > b.second;
} else
return a.first < b.first;
}
int main() {
int x, y;
cin >> n >> m;
memset(count1, 0, sizeof(count1));
memset(visited, false, sizeof(visited));
for (int i = 0; i < m; i++) {
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
count1[y]++;
count1[x]++;
}
for (int i = 1; i <= n; i++) {
my.push_back(make_pair(i, count1[i]));
}
for (int i = 0; i < my.size(); ++i) {
if (!visited[my[i].first]) {
nodes = 0;
edges = 0;
dfs(my[i].first, 0);
if (edges / 2 + 1 == nodes) ans++;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool vis[100100];
vector<int> v[100100];
int d[100100];
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d %d", &x, &y);
v[x].push_back(y);
v[y].push_back(x);
}
queue<int> q;
for (int i = 1; i <= n; i++) {
d[i] = v[i].size();
if (v[i].size() == 1) q.push(i);
}
int cnt = 0;
while (q.size()) {
int x = q.front();
q.pop();
vis[x] = 1;
if (d[x] > 0) cnt++;
for (int y : v[x]) {
if (vis[y]) continue;
d[y]--;
if (d[y] == 1) q.push(y);
}
}
int num = 0;
for (int i = 1; i <= n; i++) {
if (d[i] <= 1) num++;
}
cout << max(0, n - cnt - (n - num)) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > roads;
int vis[111111];
int cnt1, cnt2;
void Dfs(int po) {
if (vis[po]) return;
vis[po] = 1;
cnt1++;
cnt2 += roads[po].size();
for (int i = 0; i < roads[po].size(); i++) {
if (!vis[roads[po][i]]) Dfs(roads[po][i]);
}
}
int main() {
int n, m;
cin >> n >> m;
roads.resize(n + 1);
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
roads[x].push_back(y);
roads[y].push_back(x);
}
int res = 0;
for (int i = 1; i <= n; i++) {
{
if (!vis[i]) {
cnt1 = 0, cnt2 = 0;
Dfs(i);
if (cnt2 / 2 == cnt1 - 1) res++;
}
}
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int>> v;
const int MAXN = 100010;
bool vis[MAXN];
int deg[MAXN];
int left[MAXN];
void dfs(int node, int parent, bool is) {
if (is) ++deg[node];
if (vis[node]) return;
vis[node] = true;
for (int i = 0; i < v[node].size(); ++i) {
if (v[node][i] != parent) dfs(v[node][i], node, true);
}
}
int p1 = 0, p2 = 0;
void dfs2(int node) {
if (vis[node]) return;
vis[node] = true;
if (deg[node] == 0)
++p1;
else
p2 += deg[node] - 1;
for (int i = 0; i < v[node].size(); ++i) dfs2(v[node][i]);
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
v.resize(n, vector<int>());
for (int i = 0, a, b; i < m; ++i) {
scanf("%d%d", &a, &b);
--a;
--b;
v[a].push_back(b);
v[b].push_back(a);
}
memset(vis, false, sizeof(vis));
for (int i = 0; i < n; ++i)
if (!vis[i]) dfs(i, -1, false);
memset(vis, false, sizeof(vis));
int tot = 0;
for (int i = 0; i < n; ++i) {
p1 = 0, p2 = 0;
if (!vis[i])
dfs2(i);
else
continue;
p1 -= min(p2, p1);
tot += p1;
}
printf("%d\n", tot);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
vector<int> v[maxn];
int vos[maxn];
int ans;
void dfs(int now, int pre) {
if (vos[now]) {
ans = 0;
return;
}
vos[now] = 1;
for (int i = 0; i < v[now].size(); i++) {
if (v[now][i] != pre) {
dfs(v[now][i], now);
}
}
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
int a, b;
for (int i = 0; i < m; i++) {
scanf("%d%d", &a, &b);
v[a].push_back(b);
v[b].push_back(a);
}
memset(vos, 0, sizeof(vos));
int sum = 0;
for (int i = 1; i <= n; i++) {
if (vos[i]) continue;
ans = 1;
dfs(i, 0);
sum += ans;
}
printf("%d\n", sum);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int root[100010], deg[100010], cnt[100010];
int find_root(int u) {
if (u == root[u]) return u;
return root[u] = find_root(root[u]);
}
int main() {
int N, M, u, v, ans, i;
scanf("%d%d", &N, &M);
for (i = 0; i < N; i++) root[i] = i;
for (i = 0; i < M; i++) {
scanf("%d%d", &u, &v);
u--;
v--;
deg[u]++;
deg[v]++;
int uu = find_root(u);
int vv = find_root(v);
if (uu == vv) continue;
root[uu] = vv;
}
for (i = 0; i < N; i++) {
u = find_root(i);
cnt[u]++;
if (u == i) continue;
deg[u] += deg[i];
}
ans = 0;
for (i = 0; i < N; i++) {
u = find_root(i);
if (u != i) continue;
if (deg[u] == 2 * (cnt[u] - 1)) ans++;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int fa[N];
bool flag[N];
int find(int x) {
int r = x;
while (fa[r] != r) r = fa[r];
int i = x, j;
while (i != r) {
j = fa[i];
fa[i] = r;
i = j;
}
return r;
}
int main() {
int n, m, i, j;
int x, y, fx, fy;
int ans;
ans = 0;
cin >> n >> m;
for (i = 1; i <= n; i++) fa[i] = i;
while (m--) {
cin >> x >> y;
fx = find(x);
fy = find(y);
if (fx != fy) {
fa[fx] = fy;
flag[fy] |= flag[fx];
} else
flag[fx] = flag[fy] = true;
}
for (i = 1; i <= n; i++) {
int tem = find(i);
if (tem == i && !flag[tem]) ans++;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> g[100010];
int comp_v, comp_e, cnt, v[100010];
void dfs(int i, int p) {
v[i] = cnt;
comp_v++;
comp_e += g[i].size();
for (int j(0); j < g[i].size(); ++j)
if (!v[g[i][j]]) dfs(g[i][j], i);
}
int main() {
ios::sync_with_stdio(false);
int n, m, x, y, ans(0);
cin >> n >> m;
for (int i(0); i < m; ++i) {
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
for (int i(1); i <= n; ++i)
if (!v[i]) {
cnt++;
comp_e = comp_v = 0;
dfs(i, -1);
if (comp_v * 2 - 2 == comp_e) ans++;
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100001;
int parent[maxn];
int size[maxn];
int E[maxn];
int FIND(int x) {
if (parent[x] != x) parent[x] = FIND(parent[x]);
return parent[x];
}
void join(int u, int v) {
int pu = FIND(u);
int pv = FIND(v);
if (pu != pv) {
parent[pu] = pv;
E[pv] += E[pu];
size[pv] += size[pu];
}
E[pv]++;
}
int main() {
int n, m;
scanf("%d", &n);
scanf("%d", &m);
for (int i = 1; i <= n; i++) {
parent[i] = i;
size[i] = 1;
E[i] = 0;
}
while (m--) {
int u, v;
scanf("%d", &u);
scanf("%d", &v);
join(u, v);
}
int ans = 0;
for (int i = 1; i <= n; i++)
if (FIND(i) == i) {
ans += ((E[i] + 1) == size[i]) ? 1 : 0;
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> A[100005];
int vis[100005];
int dfs(int u, int par) {
vis[u] = 1;
int k = 0;
for (int i = 0; i < A[u].size(); i++) {
if (!vis[A[u][i]])
k = k || dfs(A[u][i], u);
else if (vis[A[u][i]] && A[u][i] != par)
k = 1;
}
return k;
}
int main() {
ios_base::sync_with_stdio(false);
int n, m, a, b;
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> a >> b;
A[a].push_back(b);
A[b].push_back(a);
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
ans += (!dfs(i, i));
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:36777216")
using namespace std;
inline long long MAX(long long a, long long b) { return (a > b) ? (a) : (b); }
inline long long MIN(long long a, long long b) { return (a < b) ? (a) : (b); }
void ex() {
cout << "NO";
exit(0);
}
int const sz = 2e5 + 3;
int label[sz + 1];
vector<int> comp[sz + 1];
vector<int> con[sz + 1];
void dfs(int a, int lab) {
for (std::vector<int>::iterator it = con[a].begin(); it != con[a].end();
++it) {
int u = *it;
if (label[u] > 0) continue;
comp[lab].push_back(u);
label[u] = lab;
dfs(u, lab);
}
}
int main() {
int i, j, n, m, a, b;
cin >> n >> m;
for (i = 1; i <= m; i++) {
cin >> a >> b;
con[a].push_back(b);
con[b].push_back(a);
}
for (i = 0; i <= n; i++) label[i] = 0;
int lab = 0;
for (i = 1; i <= n; i++)
if (label[i] == 0) {
lab++;
label[i] = lab;
comp[lab].push_back(i);
dfs(i, lab);
}
long long edge;
int ans = 0;
for (i = 1; i <= lab; i++) {
edge = 0;
for (std::vector<int>::iterator it = comp[i].begin(); it != comp[i].end();
++it) {
edge += con[*it].size();
}
if (comp[i].size() == edge / 2 + 1) ans++;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100010;
const int INF = 1e9 + 7;
const double eps = 1e-10;
int N, M, T = INF, Cases = 0;
int x, y;
int father[MAXN];
bool loop[MAXN];
int top(int x) {
if (father[x] != x) father[x] = top(father[x]);
return father[x];
}
int main() {
while (T-- && ~(scanf("%d%d", &N, &M))) {
for (int i = 0; i <= N; i++) father[i] = i;
memset(loop, false, sizeof(loop));
while (M--) {
scanf("%d%d", &x, &y);
int fx = top(x);
int fy = top(y);
if (fx != fy) {
father[fx] = fy;
loop[fy] = loop[fx] || loop[fy];
} else
loop[fx] = true;
}
int ans = 0;
for (int i = 1; i <= N; i++) {
int f = top(i);
if (loop[f] == false) {
loop[f] = true;
ans++;
}
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace ::std;
const long long maxn = 1e5 + 500;
const long long mod = 1e9 + 7;
const long long inf = 1e9 + 500;
bool por[maxn];
long long par[maxn];
bool yal[maxn];
long long find_dad(long long a) {
if (par[a] == a) {
return a;
}
par[a] = find_dad(par[a]);
return par[a];
}
int main() {
long long n, m;
cin >> n >> m;
for (long long i = 0; i < n; i++) {
par[i] = i;
}
for (long long i = 0; i < m; i++) {
long long v, u;
cin >> v >> u;
v--;
u--;
yal[u] = 1;
yal[v] = 1;
u = find_dad(u);
v = find_dad(v);
if (v == u) {
por[v] = 1;
} else {
par[u] = v;
por[v] |= por[u];
}
}
long long ans = 0;
for (long long i = 0; i < n; i++) {
if (par[i] == i && por[i] == 0) {
ans++;
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
long findParent(long i, long parent[]) {
if (parent[parent[i]] == parent[i]) return parent[i];
return findParent(parent[i], parent);
}
void nodeUnion(long a, long b, long parent[], long size[], long edg[]) {
if (findParent(a, parent) == findParent(b, parent)) {
edg[findParent(a, parent)]++;
return;
}
int p_a = findParent(a, parent);
int p_b = findParent(b, parent);
if (size[p_a] > size[p_b]) {
size[p_a] += size[p_b];
parent[p_b] = p_a;
edg[p_a] += edg[p_b];
edg[p_a]++;
return;
}
size[p_b] += size[p_a];
parent[p_a] = p_b;
edg[p_b] += edg[p_a];
edg[p_b]++;
return;
}
int main() {
std::ios::sync_with_stdio(false);
long n, m, parent[100010], size[100010], edg[100010];
for (long i = 0; i <= 100001; i++) {
parent[i] = i;
size[i] = 1;
edg[i] = 0;
}
cin >> n >> m;
while (m--) {
long a, b;
cin >> a >> b;
nodeUnion(a, b, parent, size, edg);
}
long ans = 0;
for (long i = 1; i <= n; i++) {
if (parent[i] == i) {
if (size[i] - 1 == edg[i]) ans++;
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
struct edge {
int to, next;
} e[200001];
int n, m, h[100001], cnt, book[100001], ans, k;
void add(int u, int v) {
e[++cnt].next = h[u];
e[cnt].to = v;
h[u] = cnt;
}
void dfs(int x, int fa) {
if (book[x]) k = 0;
book[x]++;
if (!k) return;
for (int l = h[x]; l; l = e[l].next) {
int v = e[l].to;
if (v == fa) continue;
dfs(v, x);
}
book[x]++;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int a, b;
scanf("%d%d", &a, &b);
add(a, b), add(b, a);
}
for (int i = 1; i <= n; i++)
if (!book[i]) {
k = 1;
dfs(i, 0);
ans += k;
}
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace custom {
const int dx[4] = {-1, 0, 1, 0};
const int dy[4] = {0, 1, 0, -1};
template <class T>
void print(T a) {
cout << a;
}
template <class T1, class T2>
void print(pair<T1, T2>& a) {
cout << "{" << a.first << "," << a.second << "} ";
}
template <class T>
void parr(T& arr) {
int i = 0;
for (auto& el : arr) {
if (i > 0) print(" ");
print(el);
i |= 1;
}
}
template <class T>
void print(vector<T>& a) {
parr(a);
}
template <class T>
void print(set<T>& a) {
parr(a);
}
template <class T>
void print(queue<T>& a) {
parr(a);
}
template <class T>
void print(deque<T>& a) {
parr(a);
}
template <class T>
void print(stack<T>& a) {
parr(a);
}
template <class T1, class T2>
void print(map<T1, T2>& a) {
int i = 0;
for (auto& el : a) {
if (i > 0) print("\n");
print(el.first);
print(" : ");
print(el.second);
i |= 1;
}
}
template <class arg1, class... args>
void print(arg1 f, args... n) {
print(f);
print(" ");
print(n...);
}
template <class T>
void print(vector<vector<T>>& a) {
for (auto& el : a) print(el, "\n");
}
template <class T>
int len(T& a) {
return a.size();
}
template <class T>
long long sum(T& a) {
long long s = 0;
for (auto& el : a) s += el;
return s;
}
} // namespace custom
using namespace custom;
bool dfs(int p, int i, vector<int>& vis, vector<vector<int>>& ed) {
if (vis[i]) {
return true;
}
bool temp = false;
vis[i] = 1;
for (auto& el : ed[i]) {
if (el == p) continue;
temp |= (dfs(i, el, vis, ed));
}
return temp;
}
void solve() {
int n, m;
cin >> n >> m;
int x, y;
vector<vector<int>> ed(n + 1);
for (int i = 0; i < m; i += 1) {
cin >> x >> y;
ed[x].push_back(y);
ed[y].push_back(x);
}
vector<int> vis(n + 1, 0);
int ans = 0;
for (int i = 1; i < n + 1; i += 1) {
if (vis[i]) continue;
bool b = dfs(-1, i, vis, ed);
if (!b) ans += 1;
}
print(ans);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t;
t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e8;
const double pi = 3.1415926535897;
const double EPS = (1e-7);
int dcmp(double x, double y) { return fabs(x - y) <= EPS ? 0 : x < y ? -1 : 1; }
struct edge {
int from, to, w;
edge(int u, int v, int w) : from(u), to(v), w(w) {}
bool operator<(const edge &e) const { return w > e.w; }
};
const int N = 1e5 + 5;
vector<int> adj[N];
set<pair<int, int> > edges;
int deg[N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
int x, y;
for (int i = 0; i < m; i++) {
cin >> x >> y;
x--;
y--;
adj[x].push_back(y);
adj[y].push_back(x);
deg[x]++;
deg[y]++;
int mini = min(x, y);
int maxi = max(x, y);
edges.insert({mini, maxi});
}
int ans = 0;
queue<int> q;
for (int i = 0; i < n; i++) {
if (deg[i] == 0)
ans++;
else if (deg[i] == 1)
q.push(i);
}
while (!q.empty()) {
int u = q.front();
q.pop();
if (!deg[u]) {
deg[u] = -1;
ans++;
continue;
}
for (auto ch : adj[u]) {
int mini = min(ch, u);
int maxi = max(ch, u);
pair<int, int> p = make_pair(mini, maxi);
if (edges.count(p) > 0) {
deg[ch]--;
edges.erase(p);
if (deg[ch] == 1) {
q.push(ch);
}
}
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e9;
const long long inf64 = 1e18;
const long long mod = inf + 7;
const long long N = 2e5 + 50;
vector<long long> adj[N];
bool vis[N];
bool isCycle = false;
long long ans = 0, cc = 0;
void dfs(long long s, long long p = 0) {
vis[s] = 1;
for (long long x : adj[s]) {
if (x == p) continue;
if (vis[x])
isCycle = 1;
else
dfs(x, s);
}
}
void solve() {
long long n, m;
cin >> n >> m;
for (long long i = 0; i < m; i++) {
long long x, y;
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
for (long long i = 1; i <= n; i++) {
if (!vis[i]) {
isCycle = 0;
dfs(i);
if (!isCycle) ans++;
}
}
cout << ans;
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long tc = 1;
while (tc--) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5;
int n, m, ans;
int is[N];
vector<int> g[N];
int cur;
void dfs(int u, int p = -1) {
is[u] = 1;
for (int to : g[u]) {
if (is[to] && to != p) {
cur = 1;
}
if (!is[to]) dfs(to, u);
}
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
for (int i = 1; i <= n; i++) {
if (!is[i]) {
cur = 0;
dfs(i);
ans += (cur ^ 1);
}
}
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 100000007;
const int M = 300007;
const long double pi = acos(-1);
const int MAXN = 100005;
const int N = 1e5 + 5;
vector<int> graph[N];
bool seen[N];
int parent[N];
bool cycle = false;
void dfs(int vertex) {
seen[vertex] = true;
for (int i = 0; i < graph[vertex].size(); i++) {
if (seen[graph[vertex][i]] && graph[vertex][i] != parent[vertex]) {
cycle = true;
} else if (!seen[graph[vertex][i]]) {
parent[graph[vertex][i]] = vertex;
dfs(graph[vertex][i]);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
int t, i, j;
int n, m;
cin >> n >> m;
for (i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
graph[x].push_back(y);
graph[y].push_back(x);
}
int ans = 0;
for (i = 1; i <= n; i++) {
if (!seen[i]) {
cycle = false;
dfs(i);
if (!cycle) ans++;
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 7;
const int INF = 1e9 + 7;
const long long int LINF = 1e18;
const long long int MOD = 1e9 + 7;
using namespace std;
vector<int> a[MAXN];
vector<int> topsort;
int used[MAXN];
bool good = false;
void dfs2(int x, int p = -1) {
used[x] = 1;
for (auto i : a[x]) {
if (i == p) {
continue;
}
if (used[i] == 1) {
good = true;
} else if (used[i] == 0) {
dfs2(i, x);
}
}
used[x] = 2;
}
void dfs(int x, int p = -1) {
used[x] = 1;
for (auto i : a[x]) {
if (i == p) {
continue;
}
if (used[i] == 1) {
good = true;
} else if (used[i] == 0) {
dfs(i, x);
}
}
used[x] = 2;
topsort.push_back(x);
}
int n, m;
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d %d", &x, &y);
a[x].push_back(y);
a[y].push_back(x);
}
for (int i = 1; i <= n; i++) {
if (!used[i]) {
dfs(i);
}
}
int ans = 0;
for (int i = 1; i <= n; i++) {
used[i] = 0;
}
reverse(topsort.begin(), topsort.end());
for (auto i : topsort) {
good = false;
if (!used[i]) {
dfs2(i);
if (!good) {
ans++;
}
}
}
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, u, v, fa[100005], tot[100005] = {0}, TOT[100005] = {0};
int findfa(int x) { return fa[x] == x ? x : fa[x] = findfa(fa[x]); }
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) fa[i] = i, tot[i] = 1, TOT[i] = 0;
for (int i = 1; i <= m; i++) {
scanf("%d%d", &u, &v);
u = findfa(u), v = findfa(v);
if (u == v)
TOT[u]++;
else {
fa[u] = v;
tot[v] += tot[u];
TOT[v] += TOT[u] + 1;
tot[u] = TOT[u] = 0;
}
}
int ans = 0;
for (int i = 1; i <= n; i++) {
findfa(i);
if (fa[i] == i) ans += tot[i] > TOT[i] ? 1 : 0;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a, b;
vector<int> adj[100001];
bool visited[100001];
int v, e;
void dfs(int node) {
visited[node] = true;
v++;
e += adj[node].size();
for (auto i : adj[node]) {
if (visited[i] == false) {
dfs(i);
}
}
}
int main() {
int n, k;
cin >> n >> k;
while (k--) {
int a, b;
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (visited[i] == false) {
v = 0;
e = 0;
dfs(i);
if (e / 2 < v) {
ans++;
}
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
vector<long long> v[N];
long long vis[N] = {0};
long long ver, ed;
void dfs(long long n) {
vis[n] = 1;
ver++;
for (auto itr : v[n]) {
ed++;
if (!vis[itr]) {
dfs(itr);
}
}
}
int main() {
long long e, n, i;
cin >> n >> e;
for (i = 0; i < e; i++) {
long long x, y;
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
long long cnt = 0;
for (i = 1; i <= n; i++) {
if (!vis[i]) {
ver = 0;
ed = 0;
dfs(i);
ed = ed / 2;
if (ed < ver) {
cnt++;
}
}
}
cout << cnt << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > g;
bitset<int(2e5)> visited;
int temp[int(2e5)];
long long min(long long a, long long b) { return a < b ? a : b; }
void dfs(int u) {
visited[u] = true;
for (int v : g[u])
if (!visited[v]) dfs(v);
}
int find(int x) { return temp[x] == x ? x : temp[x] = find(temp[x]); }
void solve(int n, int m) {
for (int i = 0; i < n; i++) temp[i] = i;
int cnt = n;
int u, v;
for (int i = 0; i < m; i++) {
cin >> u >> v;
u--, v--;
u = find(u), v = find(v);
if (u == v)
visited[u] = true;
else {
temp[u] = v;
cnt--;
visited[v] = visited[u] || visited[v];
}
}
for (int i = 0; i < n; i++)
if (temp[i] == i && visited[i]) cnt--;
cout << cnt << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
solve(n, m);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<int> g[100069];
int vis[100069];
int nodes;
int edges;
int flag;
void dfs(int i, int root, int par) {
nodes++;
vis[i] = 1;
for (int j = 0; j < g[i].size(); j++) {
int u = g[i][j];
if (vis[u] && u != par) flag = 1;
if (!vis[u]) dfs(u, root, i);
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
int ans = 0;
for (int i = 1; i < n + 1; i++) {
flag = 0;
if (!vis[i]) {
dfs(i, i, -1);
if (flag == 0) ans = ans + 1;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<int, int> used;
map<int, vector<int> > graph;
int n, m, check;
void dfs(int v, int p = -1) {
used[v] = 1;
int i, to;
for (i = 0; i < graph[v].size(); i++) {
to = graph[v][i];
if (used[to] == 1 && to != p) check++;
if (!used[to]) dfs(to, v);
}
used[v] = 2;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int i, x, y, sep = 0;
cin >> n >> m;
for (i = 0; i < m; i++) {
cin >> x >> y;
graph[x - 1].push_back(y - 1);
graph[y - 1].push_back(x - 1);
}
for (i = 0; i < n; i++) {
if (!used[i]) {
check = 0;
dfs(i);
if (!check) sep++;
}
}
cout << sep;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int fa[N];
bool flag[N];
int find(int x) {
int r = x;
while (fa[r] != r) r = fa[r];
int i = x, j;
while (i != r) {
j = fa[i];
fa[i] = r;
i = j;
}
return r;
}
int main() {
ios::sync_with_stdio(false);
int n, m, i, j;
int x, y, fx, fy;
int ans;
ans = 0;
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) fa[i] = i;
while (m--) {
scanf("%d%d", &x, &y);
fx = find(x);
fy = find(y);
if (fx != fy) {
fa[fx] = fy;
if (flag[x] || flag[y] || flag[fx] || flag[fy])
flag[fy] = flag[fx] = flag[x] = flag[y] = true;
} else
flag[fy] = flag[fx] = flag[x] = flag[y] = true;
}
for (i = 1; i <= n; i++) {
if (find(i) == i && !flag[find(i)]) ans++;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 2e5 + 239;
int n, p[M];
int m;
vector<int> v[200050];
int vis[200050];
int x = 0;
void dfs(int i, int p) {
vis[i] = 1;
for (auto y : v[i]) {
if (!vis[y]) {
dfs(y, i);
} else if (y != p) {
x = 1;
}
}
}
void solve() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a = 0, b = 0;
cin >> a >> b;
v[a].push_back(b);
v[b].push_back(a);
}
int cnt = 0;
for (int i = 1; i <= n; i++) {
x = 0;
if (!vis[i]) {
dfs(i, -1);
if (x == 0) {
cnt++;
}
}
}
cout << cnt;
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m;
vector<long long> g[100010];
vector<bool> vis(1e5 + 10, false);
long long edges, nodes;
void dfs(int i) {
if (vis[i]) {
return;
}
vis[i] = true;
nodes++;
edges += g[i].size();
for (auto j : g[i]) {
dfs(j);
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 0; i < m; i++) {
long long a, b;
cin >> a >> b;
g[a].push_back(b);
g[b].push_back(a);
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
edges = 0;
nodes = 0;
dfs(i);
edges /= 2;
if (edges < nodes) ans++;
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
vector<int> g[N];
int deg[N];
bool cycle;
int color[N];
inline void dfs(int cur, int par) {
color[cur] = 1;
for (int i = 0; i < (int)g[cur].size(); i++) {
int nbr = g[cur][i];
if (color[nbr] == 1) {
if (nbr != par) {
cycle = true;
}
} else if (color[nbr] == 0) {
dfs(nbr, cur);
}
}
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d %d", &u, &v);
u--, v--;
g[u].push_back(v);
g[v].push_back(u);
}
int cnt = 0;
for (int i = 0; i < n; i++) {
cycle = false;
if (color[i] == 0) {
dfs(i, -1);
if (!cycle) {
cnt++;
}
}
}
printf("%d\n", cnt);
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> gr[100001];
bool visited[100001];
bool cycle = false;
void dfs(long long i, long long parent) {
for (long long j = 0; j < gr[i].size(); j++) {
if (visited[gr[i][j]] == false) {
visited[gr[i][j]] = true;
dfs(gr[i][j], i);
} else if (parent != gr[i][j]) {
cycle = true;
}
}
}
int main() {
long long n, m;
cin >> n >> m;
long long c = 0;
for (long long i = 0; i < m; i++) {
long long a, b;
cin >> a >> b;
gr[a].push_back(b);
gr[b].push_back(a);
}
for (long long i = 1; i <= n; i++) {
cycle = false;
if (visited[i] == false) {
visited[i] = true;
dfs(i, 0);
if (cycle == false) {
c++;
}
}
}
cout << c;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
set<int> que;
int inn[200100];
set<int> des[200010];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
inn[u]++;
inn[v]++;
des[u].insert(v);
des[v].insert(u);
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (inn[i] == 0)
ans++;
else if (inn[i] == 1)
que.insert(i);
}
while (que.size()) {
int id = *que.begin();
que.erase(id);
if (inn[id] == 0) {
ans++;
continue;
}
inn[*des[id].begin()]--;
des[*des[id].begin()].erase(id);
if (inn[*des[id].begin()] <= 1) que.insert(*des[id].begin());
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
const int N = 100008;
char flag[N];
int p[N];
int find(int x) {
if (x == p[x]) return x;
return p[x] = find(p[x]);
}
int main() {
int i, j, k, n, m;
int x, y, fx, fy, s = 0;
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) p[i] = i;
while (m--) {
scanf("%d%d", &x, &y);
fx = find(x);
fy = find(y);
if (fx != fy) {
p[fx] = fy;
if (flag[fx] || flag[fy] || flag[x] || flag[y]) {
flag[x] = flag[y] = flag[fx] = flag[fy] = 1;
}
} else {
flag[x] = flag[y] = flag[fx] = flag[fy] = 1;
}
}
for (i = 1; i <= n; i++) {
if (find(i) == i && !flag[find(i)]) s++;
}
printf("%d\n", s);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, a, b;
int wyn;
vector<int> g[100005];
bitset<100005> v;
bool dodaj;
void dfs(int x, int from) {
v[x] = true;
for (int i = 0; i < (((int)(g[x]).size())); ++i) {
if (g[x][i] != from) {
if (!v[g[x][i]]) {
dfs(g[x][i], x);
} else {
dodaj = true;
}
}
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < (m); ++i) {
cin >> a >> b;
g[a].push_back(b);
g[b].push_back(a);
}
for (int i = 1; i <= (n); ++i) {
if (!v[i]) {
wyn++;
dodaj = false;
dfs(i, 0);
if (dodaj) wyn--;
}
}
cout << wyn << endl;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.