text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void ZZ(const char* name, Arg1&& arg1) {
cerr << name << " = " << arg1 << "\n";
}
template <typename Arg1, typename... Args>
void ZZ(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " = " << arg1;
ZZ(comma, args...);
}
clock_t tim = clock();
const long long N = 1e5 + 5;
vector<long long> adj[N], vis(N, 0);
bool is_cyclic = 0;
long long dfs(long long x, long long p) {
vis[x] = 1;
long long ret = 1;
for (auto i : adj[x]) {
if (i == p) continue;
if (vis[i]) {
is_cyclic = 1;
continue;
}
ret += dfs(i, x);
}
return ret;
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
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);
}
long long ans = n;
for (long long i = (1); i < (n + 1); i++) {
if (vis[i]) continue;
is_cyclic = 0;
long long aux = dfs(i, 0);
aux -= !is_cyclic;
ans -= aux;
}
cout << ans;
cerr << "\nTime Taken : " << (long double)(clock() - tim) / CLOCKS_PER_SEC;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> adj[100010];
long long edges = 0, nodes = 0;
void dfs(long long u, vector<bool> &vis) {
vis[u] = true;
for (int i = 0; i < adj[u].size(); i++) {
long long v = adj[u][i];
edges++;
if (!vis[v]) {
nodes++;
dfs(v, vis);
}
}
}
int main() {
ios::sync_with_stdio(false);
long long n, m;
cin >> n >> m;
for (long long i = 0; i < m; i++) {
long long u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
vector<bool> vis(n + 1, false);
vector<long long> par(n + 1, -1);
long long count = 0;
for (long long i = 1; i <= n; i++) {
if (!vis[i]) {
nodes = 1;
edges = 0;
dfs(i, vis);
edges /= 2;
if (edges + 1 == nodes) count++;
}
}
cout << count << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1000000000000000;
long long gcd(long long a, long long b) {
if (a == 0) {
return b;
}
return gcd(b % a, a);
}
long long lim = 150005;
vector<long long> adj[150005];
vector<long long> vis(lim, 0);
long long f = 0;
void dfs(long long x, long long parent) {
if (vis[x] == 1) return;
vis[x] = 1;
for (auto &it : adj[x]) {
if (vis[it] != 1) {
dfs(it, x);
} else if (it != parent) {
f = 1;
}
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
long long n, m;
cin >> n >> m;
for (long long i = 0; i < m; i++) {
long long u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
long long ans = 0;
for (long long i = 1; i <= n; i++) {
if (!vis[i]) {
f = 0;
dfs(i, -1);
if (f == 0) {
ans++;
}
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > vv;
vector<int> used;
bool t = 1;
int ans(0);
void dfs(int v, int p) {
used[v] = 1;
for (int i = 0; i < vv[v].size() && t; i++)
if (vv[v][i] != p && used[vv[v][i]] != 1)
dfs(vv[v][i], v);
else if (used[vv[v][i]] && vv[v][i] != p)
ans--, t = 0;
}
int main() {
int n, m;
cin >> n >> m;
vv.resize(n + 1);
used.resize(n + 1);
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
vv[a].push_back(b);
vv[b].push_back(a);
}
for (int i = 1; i <= n; i++)
if (!used[i]) {
t = 1;
dfs(i, i);
ans++;
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int us[N];
vector<int> g[N];
bool Cycle(int u, int p = 0) {
bool res = false;
us[u] = 1;
for (int v : g[u]) {
if (v == p) {
continue;
}
if (us[v] == 0) {
res |= Cycle(v, u);
} else if (us[v] == 1) {
return true;
}
}
us[u] = 2;
return res;
}
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);
g[u].push_back(v);
g[v].push_back(u);
}
int res = 0;
for (int u = 1; u <= n; u++) {
if (!us[u]) {
res += !Cycle(u);
}
}
printf("%d\n", res);
}
|
#include <bits/stdc++.h>
using namespace std;
struct road {
int c1, c2;
};
struct city {
int order, num;
vector<int> link;
int cet;
city(int num = 0, int cet = 1) : num(num), cet(cet){};
};
int main() {
int n, m;
while (cin >> n >> m) {
vector<city> c;
road r[m];
for (int i = 0; i < n; i++) {
city ccc;
ccc.order = i;
c.push_back(ccc);
}
for (int i = 0; i < m; i++) {
cin >> r[i].c1 >> r[i].c2;
c[r[i].c1 - 1].num++;
c[r[i].c2 - 1].num++;
c[r[i].c1 - 1].link.push_back(r[i].c2 - 1);
c[r[i].c2 - 1].link.push_back(r[i].c1 - 1);
}
int sum = 0;
while (1) {
bool cet2 = true;
for (int i = 0; i < c.size(); i++) {
if (c[i].cet && c[i].num == 1) {
for (int j = 0; j < c[i].link.size(); j++) {
if (c[c[i].link[j]].cet) c[c[i].link[j]].num--;
}
c[i].cet = 0;
cet2 = false;
} else if (c[i].cet && c[i].num == 0) {
c[i].cet = 0;
cet2 = false;
sum++;
}
}
if (cet2) break;
}
cout << sum << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, f[100009], sum, k, h[100009];
int getf(int i) {
if (f[i] == i) return i;
return f[i] = getf(f[i]);
}
int main() {
for (int i = 0; i < 100009; i++) f[i] = i;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
u = getf(u), v = getf(v);
if (u != v) {
f[u] = v;
if (h[u] || h[v]) h[u] = h[v] = 1;
} else {
h[u] = h[v] = 1;
}
}
for (int i = 1; i <= n; i++)
if (f[i] == i && !h[i]) sum++;
printf("%d", sum);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > g;
bitset<int(1e5)> visited;
int parent[int(1e5)];
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 u) {
if (parent[u] == u) return u;
return parent[u] = find(parent[u]);
}
void solve(int n, int m) {
for (int i = 0; i < n; i++) parent[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 {
parent[u] = v;
cnt--;
visited[v] = visited[u] || visited[v];
}
}
for (int i = 0; i < n; i++)
if (parent[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;
const int MAXN = 100000 + 5;
vector<int> G[MAXN];
int vis[MAXN];
int bfs(int s) {
int node = 1, edge = 0;
queue<int> q;
q.push(s);
vis[s] = 1;
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = 0; i < (int)G[u].size(); i++) {
edge++;
int v = G[u][i];
if (!vis[v]) {
q.push(v);
vis[v] = 1;
node++;
}
}
}
edge /= 2;
if (edge > node - 1) {
return 0;
}
return 1;
}
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);
G[u].push_back(v);
G[v].push_back(u);
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
ans += bfs(i);
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9 + 7;
const long long MINT = ~0u >> 1;
const int maxn = 123456;
set<int> Set[maxn];
bool isOk[maxn];
int n, m;
void solve() {
queue<int> q;
for (int i = 1; i <= n; i++) {
if (1 == Set[i].size()) {
q.push(i);
}
}
while (!q.empty()) {
int cur = q.front();
if (1 == Set[cur].size()) {
isOk[cur] = true;
int temp = *(Set[cur].begin());
Set[cur].erase(temp);
Set[temp].erase(cur);
if (1 == Set[temp].size()) q.push(temp);
q.pop();
} else
q.pop();
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
Set[x].insert(y);
Set[y].insert(x);
}
solve();
int ans(0);
for (int i = 1; i <= n; i++) {
if (!Set[i].size() && !isOk[i]) {
ans++;
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
for (; ch < '0' || ch > '9'; ch = getchar())
if (ch == '-') f = -1;
for (; ch >= '0' && ch <= '9'; ch = getchar()) x = x * 10 + ch - '0';
return x * f;
}
inline long long lread() {
long long x = 0, f = 1;
char ch = getchar();
for (; ch < '0' || ch > '9'; ch = getchar())
if (ch == '-') f = -1;
for (; ch >= '0' && ch <= '9'; ch = getchar()) x = x * 10 + ch - '0';
return x * f;
}
const int maxn = 100005;
int n, m, ans;
struct edge {
int to, next;
} e[maxn << 1];
int head[maxn], top = 1;
void addedge(int u, int v) {
e[++top] = (edge){v, head[u]};
head[u] = top;
e[++top] = (edge){u, head[v]};
head[v] = top;
}
bool vis[maxn];
bool dfs(int x, int f) {
vis[x] = true;
bool flag = true;
for (int i = head[x]; i; i = e[i].next)
if (e[i].to != f) {
if (vis[e[i].to]) flag = false;
if (!vis[e[i].to])
if (!dfs(e[i].to, x)) flag = false;
}
return flag;
}
int main() {
n = read(), m = read();
for (int i = 1; i <= m; i++) {
int u = read(), v = read();
addedge(u, v);
}
for (int i = 1; i <= n; i++)
if (!vis[i]) ans += dfs(i, i);
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int dx[8] = {-1, -1, -1, 0, 1, 1, 1, 0};
const long long int dy[8] = {-1, 0, 1, 1, 1, 0, -1, -1};
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << endl;
err(++it, args...);
}
long long int power(long long int a, long long int b,
long long int m = 1000000007) {
long long int ans = 1;
a = a % m;
while (b > 0) {
if (b & 1) ans = (1LL * a * ans) % m;
b >>= 1;
a = (1LL * a * a) % m;
}
return ans;
}
long long int ncr(long long int n, long long int r) {
long long int res = 1;
if (r > n - r) r = n - r;
for (long long int i = 0; i < r; i++) {
res *= n - i;
res /= i + 1;
}
return res;
}
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 (a * b) / gcd(a, b);
}
clock_t time_p = clock();
void rtime() {
time_p = clock() - time_p;
cerr << "******************\nTime taken : "
<< (long double)(time_p) / CLOCKS_PER_SEC << "\n";
}
vector<long long int> g[100001];
vector<bool> vis(100001);
long long int v, e;
void dfs(long long int i) {
v++;
vis[i] = true;
for (auto x : g[i]) {
e++;
if (!vis[x]) dfs(x);
}
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int tt = 1;
long long int ii = 0;
while (tt-- && ++ii) {
long long int n, m;
cin >> n >> m;
for (long long int i = 0; i < m; i++) {
long long int x, y;
cin >> x >> y;
g[x].emplace_back(y);
g[y].emplace_back(x);
}
long long int ans = 0;
for (long long int i = 1; i <= n; i++)
if (!vis[i]) {
v = 0, e = 0;
dfs(i);
e >>= 1;
if (e == v - 1) ans++;
}
cout << ans << "\n";
}
rtime();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > v(100005 + 1);
vector<int> vis(100005 + 1, 0);
vector<int> group;
void dfs(int i) {
for (int j = 0; j < v[i].size(); j++) {
if (vis[v[i][j]] == 0) {
group.push_back(v[i][j]);
vis[v[i][j]] = 1;
dfs(v[i][j]);
}
}
}
int main() {
int n, m, x, y;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d%d", &x, &y);
v[x].push_back(y);
v[y].push_back(x);
}
int count = 0;
for (int i = 1; i <= n; i++) {
if (vis[i] == 0) {
count++;
group.clear();
group.push_back(i);
vis[i] = 1;
dfs(i);
int counter = 0;
for (int o = 0; o < group.size(); o++) {
counter += v[group[o]].size();
}
counter /= 2;
if (counter >= group.size()) {
count--;
}
}
}
cout << count << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[100010];
int comp[100010];
int vert[100010];
int ar[100010];
int bfs(int n) {
queue<int> Q;
int c = 1;
int ans = 0;
for (int v = (1); v < (n + 1); v++) {
if (comp[v]) continue;
c++;
Q.push(v);
comp[v] = c;
int cur, next;
while (!Q.empty()) {
cur = Q.front();
Q.pop();
vert[c]++;
ar[c] += adj[cur].size();
for (int i = 0; i < (adj[cur].size()); i++) {
int w = adj[cur][i];
if (comp[w] == 0) {
comp[w] = c;
Q.push(w);
}
}
}
int nn = vert[c];
int mm = ar[c] / 2;
if (mm == (nn - 1)) ans++;
}
return (ans);
}
int main() {
int n, m;
cin >> n >> m;
int u, v;
for (int i = 0; i < (m); i++) {
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
cout << bfs(n) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, v[100001];
vector<int> adj[100001];
bool dfs(int cur, int bef) {
v[cur] = 1;
bool ret = false;
for (int i = 0; i < adj[cur].size(); ++i) {
int next = adj[cur][i];
if (next == bef) continue;
if (v[next] == 1)
ret = true;
else
ret = ret || dfs(next, cur);
}
return ret;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; ++i) {
int a, b;
scanf("%d%d", &a, &b);
--a, --b;
adj[a].push_back(b);
adj[b].push_back(a);
}
int ans = 0;
for (int cur = 0; cur < n; ++cur) {
if (v[cur] == 0) {
if (!dfs(cur, cur)) ++ans;
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 100 * 1000 + 10;
int n, m, ans, par[Maxn];
vector<int> adj[Maxn];
bool mark[Maxn], flag;
void dfs(int v) {
mark[v] = true;
for (int i = 0; i < (int)adj[v].size(); i++) {
if (!mark[adj[v][i]]) {
par[adj[v][i]] = v;
dfs(adj[v][i]);
} else {
if (adj[v][i] != par[v]) flag = true;
}
}
return;
}
int main() {
scanf("%d%d", &n, &m);
int u, v;
for (int i = 0; i < m; i++) {
scanf("%d%d", &u, &v);
u--;
v--;
adj[u].push_back(v);
adj[v].push_back(u);
}
for (int i = 0; i < n; i++) {
flag = false;
if (!mark[i]) {
dfs(i);
if (!flag) ans++;
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const int N = 1e5 + 5;
int ans, c;
vector<int> v[N];
bool vis[N];
void dfs(int s, int p) {
vis[s] = true;
for (auto e : v[s]) {
if (!vis[e])
dfs(e, s);
else if (e != p)
c = 0;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m, x, y;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
c = 1;
dfs(i, -1);
ans += c;
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, f[100009], sum, k, h[100009];
inline int getf(int i) {
if (f[i] == i) return i;
return f[i] = getf(f[i]);
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i <= n; i++) f[i] = i;
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
u = getf(u), v = getf(v);
if (u != v) {
f[u] = v;
if (h[u] || h[v]) h[u] = h[v] = 1;
} else {
h[u] = h[v] = 1;
}
}
for (int i = 1; i <= n; i++)
if (f[i] == i && !h[i]) sum++;
printf("%d", sum);
return 0;
}
|
#include <bits/stdc++.h>
int fa[100005], cnt[100005], sz[100005];
int get(int v) {
if (fa[v] != v) fa[v] = get(fa[v]);
return fa[v];
}
int main() {
int n, m, i, a, b;
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) fa[i] = i, cnt[i] = 0, sz[i] = 1;
while (m--) {
scanf("%d %d", &a, &b);
int x = get(a);
int y = get(b);
if (x == y)
cnt[x]++;
else {
cnt[x] += cnt[y] + 1;
sz[x] += sz[y];
fa[y] = x;
}
}
int ans = 0;
for (int i = 1; i <= n; i++)
if (get(i) == i) ans += sz[i] > cnt[i];
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int c, x, y, f, X, Y, n, m, k, l, p;
bool a2[100002], vi[100030], a3[100009];
int pa[100004], p2[100003];
vector<int> V[100009];
stack<int> S;
void dfs2(int n) {
S.push(n);
vi[n] = 1;
for (int i = 0; i < V[n].size(); i++) {
int u = V[n][i];
if (u != p2[n]) {
pa[u]++;
if (!vi[u]) {
p2[u] = n;
dfs2(u);
}
}
}
}
void dfs(int n) {
a2[n] = 1;
for (int i = 0; i < V[n].size(); i++) {
int u = V[n][i];
if (u != pa[n]) a3[u] = 1;
if (!a2[u]) {
pa[u] = n;
dfs(u);
}
}
}
int main() {
while (scanf("%d%d", &n, &m) == 2) {
memset(vi, 0, sizeof(vi));
memset(a2, 0, sizeof(a2));
memset(pa, 0, sizeof(pa));
memset(p2, 0, sizeof(p2));
memset(a3, 0, sizeof(a3));
for (int i = 0; i <= n; i++) {
V[i].clear();
}
for (int i = 0; i < m; i++) {
scanf("%d%d", &x, &y);
V[x].push_back(y);
V[y].push_back(x);
}
for (int i = 1; i <= n; i++) {
if (!vi[i]) {
dfs2(i);
l = 0;
while (!S.empty()) {
int y = S.top();
S.pop();
if (l < pa[y]) {
l = pa[y];
k = y;
}
}
memset(pa, 0, sizeof(pa));
dfs(k);
}
}
int f = 0;
for (int i = 1; i <= n; i++) {
if (!a3[i]) f++;
}
printf("%d\n", f);
}
}
|
#include <bits/stdc++.h>
using namespace std;
bool seen[100005];
int parent[100005];
int go(int u, vector<vector<int> > &G) {
seen[u] = 1;
queue<int> q;
q.push(u);
parent[u] = -1;
while (!q.empty()) {
u = q.front();
q.pop();
for (int i = 0; i < G[u].size(); ++i) {
int v = G[u][i];
if (!seen[v]) {
seen[v] = 1;
parent[v] = u;
q.push(v);
} else if (v != parent[u])
return 0;
}
}
return 1;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m, x, y;
cin >> n >> m;
vector<vector<int> > G(n + 1);
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)
if (!seen[i]) ans += go(i, G);
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > g;
bitset<int(1e5)> visited;
int parent[int(1e5)];
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 u) {
if (parent[u] == u) return u;
return parent[u] = find(parent[u]);
}
void solve(int n, int m) {
for (int i = 0; i < n; i++) parent[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 {
parent[u] = v;
cnt--;
visited[v] = visited[u] || visited[v];
}
}
for (int i = 0; i < n; i++)
if (parent[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 dfs(int u, vector<int> adj[], vector<bool> &vist, int p) {
int i;
vist[u] = true;
for (i = 0; i < adj[u].size(); i++) {
if (vist[adj[u][i]] == true && adj[u][i] != p) return 1;
if (vist[adj[u][i]] == false && adj[u][i] != p) {
if (dfs(adj[u][i], adj, vist, u) == 1) return 1;
}
}
return 0;
}
int main() {
int n, m, c = 0, u, v, i;
cin >> n >> m;
vector<int> adj[100009];
for (i = 0; i < m; i++) {
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
vector<bool> vist(100009, false);
for (i = 1; i <= n; i++) {
if (vist[i] == false) {
if (dfs(i, adj, vist, 0) == 0) c++;
}
}
cout << c << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int j, z;
void bfs(int s, vector<vector<pair<int, int>>>& g, vector<int>& edges,
vector<int>& mark) {
mark[s] = 1;
queue<int> q;
q.push(s);
j = 1;
while (!q.empty()) {
int v = q.front();
q.pop();
for (auto to : g[v]) {
int u = to.first;
int d = to.second;
if (!mark[u]) {
mark[u] = 1;
edges[d] = 1;
j++;
z++;
q.push(u);
} else if (!edges[d]) {
z++;
edges[d] = 1;
}
}
}
}
int main() {
int n, m;
cin >> n >> m;
vector<vector<pair<int, int>>> g(n);
vector<int> edges(m), mark(n);
mark.assign(n, 0);
edges.assign(m, 0);
int v, u;
for (int i = 0; i < m; i++) {
cin >> v >> u;
v--;
u--;
g[v].push_back(make_pair(u, i));
g[u].push_back(make_pair(v, i));
}
int ans = 0;
for (int i = 0; i < n; i++) {
j = 0, z = 0;
if (!mark[i]) {
bfs(i, g, edges, mark);
if (z == j - 1) ans++;
}
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> graph[1000009];
bool vis[1000009];
bool hasCycle = false;
void dfs(int at, int pre) {
vis[at] = true;
for (int i = 0; i < graph[at].size(); i++) {
if (!vis[graph[at][i]]) {
dfs(graph[at][i], at);
} else if (graph[at][i] != pre) {
hasCycle = true;
}
}
}
int main() {
int n, m;
cin >> n >> m;
int a, b;
for (int T = 0; T < m; T++) {
cin >> a >> b;
graph[a].push_back(b);
graph[b].push_back(a);
}
int totalSep = 0;
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
hasCycle = false;
dfs(i, i);
if (!hasCycle) {
totalSep++;
}
}
}
cout << totalSep << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dcmp(long double n, long double y) {
return fabs(n - y) <= 1e-9 ? 0 : n < y ? -1 : 1;
}
const int MAX = 1e5 + 10;
int n, m, ans;
vector<vector<int> > adj;
bool vis[MAX];
int edges;
int dfs(int node) {
vis[node] = 1;
int ret = 1;
edges += adj[node].size();
for (int i = 0; i < ((int)((adj[node]).size())); ++i) {
int child = adj[node][i];
if (!vis[child]) ret += dfs(child);
}
return ret;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
cin >> n >> m;
adj = vector<vector<int> >(n);
for (int i = 0; i < (int)(m); ++i) {
int u, v;
cin >> u >> v;
u--;
v--;
adj[u].push_back(v);
adj[v].push_back(u);
}
for (int i = 0; i < (int)(n); ++i) {
if (!vis[i]) {
edges = 0;
int o = dfs(i);
int y = edges / 2;
if (o - 1 == y) ans++;
}
}
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
int const MN = 1e5 + 100;
bool vis[MN], t;
vector<int> adj[MN];
int n, m, ans;
void dfs(int v, int p = -1) {
vis[v] = 1;
for (auto u : adj[v]) {
if (u == p) continue;
if (vis[u])
t = 1;
else
dfs(u, v);
}
}
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> m;
for (int i = 0, u, v; i < m; i++) {
cin >> u >> v;
u--, v--;
adj[u].push_back(v);
adj[v].push_back(u);
}
for (int i = 0; i < n; i++) {
if (vis[i]) continue;
t = 0;
dfs(i);
if (!t) ans++;
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int rot[100010], vst[100010], h[100010], l[100010], cnt[100010];
int find_root(int u) {
if (u == rot[u]) return u;
return rot[u] = find_root(rot[u]);
}
int main() {
int n, m, u, v, uu, vv, i, j;
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) {
rot[i] = i;
h[i] = 0;
l[i] = 0;
cnt[i] = 1;
}
for (i = 0; i < m; i++) {
scanf("%d%d", &u, &v);
uu = find_root(u);
vv = find_root(v);
if (uu == vv) {
l[uu]++;
continue;
}
if (h[uu] > h[vv]) swap(uu, vv);
rot[uu] = vv;
h[vv] = max(h[vv], h[uu] + 1);
l[vv] += l[uu] + 1;
cnt[vv] += cnt[uu];
}
memset(vst, 0, sizeof(vst));
for (i = 1; i <= n; i++) {
vst[find_root(i)] = 1;
}
int jin = 0;
for (i = 1; i <= n; i++) {
if (vst[i] == 0) continue;
if (l[i] == cnt[i] - 1) jin++;
}
printf("%d\n", jin);
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> graph[(int)1e5];
bool flag, vis[(int)1e5];
int ans;
void dfs(int u, int v) {
vis[v] = true;
for (int i = 0; i < graph[v].size(); i++)
if (!vis[graph[v][i]])
dfs(v, graph[v][i]);
else if (u != graph[v][i])
flag = true;
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
u--, v--;
graph[u].push_back(v);
graph[v].push_back(u);
}
for (int i = 0; i < n; i++) {
flag = false;
if (!vis[i]) {
dfs(i, i);
if (!flag) ans++;
}
}
cout << ans;
}
|
#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;
scanf("%d%d", &N, &M);
memset(deg, 0, sizeof(deg));
memset(cnt, 0, sizeof(cnt));
for (int i = (0); i < (N); i++) root[i] = i;
for (int 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 (int i = (0); i < (N); i++) {
u = find_root(i);
cnt[u]++;
if (u == i) continue;
deg[u] += deg[i];
}
ans = 0;
for (int 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;
vector<int> graph[100001];
bool used[100001];
int ver = 0, edge = 0;
void read_graph(int m) {
int v1, v2;
for (int i = 0; i < m; i++) {
cin >> v1 >> v2;
graph[v1].push_back(v2);
graph[v2].push_back(v1);
}
}
void dfs(int v) {
used[v] = true;
ver++;
for (auto to : graph[v]) {
edge++;
if (!used[to]) dfs(to);
}
}
int main() {
ios::sync_with_stdio(false);
int n, m, i, j, ans = 0, temp;
cin >> n >> m;
read_graph(m);
for (i = 1; i <= n; i++) {
ver = 0;
edge = 0;
if (!used[i]) dfs(i);
if (edge / 2 == ver - 1) ans++;
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 100 * 1000;
const int MAX_M = 100 * 1000;
vector<int> g[MAX_N];
vector<bool> mark(MAX_N, false);
vector<int> pr(MAX_N, -1);
int n, m;
int ans = 0;
void dfs(int st) {
stack<int> s;
s.push(st);
mark[st] = true;
int t = 0;
while (s.empty() == false) {
int u = s.top();
s.pop();
for (int i = 0; i < g[u].size(); i++) {
if (g[u][i] != pr[u]) {
if (mark[g[u][i]] == false) {
mark[g[u][i]] = true;
s.push(g[u][i]);
pr[g[u][i]] = u;
} else {
t = 1;
}
}
}
}
ans -= t;
}
int main() {
cin >> n >> m;
int inp1, inp2;
for (int i = 0; i < m; i++) {
scanf("%d%d", &inp1, &inp2);
inp1--;
inp2--;
g[inp1].push_back(inp2);
g[inp2].push_back(inp1);
}
for (int i = 0; i < n; i++) {
if (mark[i] == false) {
dfs(i);
ans++;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
set<int> e[100010];
inline int ri() {
register char c;
while (1) {
c = getchar();
if (c >= '0' && c <= '9') break;
}
register int x = 0;
while (1) {
x = x * 10 + c - 48;
c = getchar();
if (c < '0' || c > '9') return x;
}
}
int main() {
n = ri(), m = ri();
for (int i = 0; i < m; i++) {
int a = ri() - 1, b = ri() - 1;
e[a].insert(b);
e[b].insert(a);
}
queue<int> q;
int t = 0;
for (int i = 0; i < n; i++)
if (e[i].size() == 1) q.push(i);
while (q.size() > 0) {
int s = q.size();
for (int i = 0; i < s; i++) {
int j = q.front();
q.pop();
if (e[j].size() == 0) continue;
t++;
int k = *e[j].begin();
e[k].erase(j);
e[j].clear();
if (e[k].size() == 1) q.push(k);
}
}
for (int i = 0; i < n; i++)
if (e[i].size() > 1) t++;
cout << n - t << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool se[1000001] = {0};
void seive(long long int n) {
for (long long int i = 2; i <= n; i++) {
if (se[i]) {
continue;
}
for (long long int u = 2 * i; u <= n; u += i) {
se[u] = true;
}
}
}
int vis[100001];
int n, m, d, r;
vector<int> g[100001];
void dfs(int i) {
vis[i] = 1;
r++;
d += g[i].size();
for (auto j : g[i]) {
if (!vis[j]) {
dfs(j);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t;
t = 1;
while (t--) {
cin >> n >> m;
while (m--) {
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; i++) {
if (!vis[i]) {
d = 0, r = 0;
dfs(i);
if (d / 2 < r) {
ans++;
}
}
}
cout << ans;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> gr[100005];
bool visited[100005];
bool flag;
void dfs(int x, int par) {
visited[x] = 1;
int i, j;
for (i = 0; i < gr[x].size(); i++) {
j = gr[x][i];
if (j != par) {
if (visited[j] == 1)
flag = 1;
else
dfs(j, x);
}
}
}
int main() {
int n, m, i, j, k, l, p, ans = 0;
scanf("%d%d", &n, &m);
for (i = 0; i < m; i++) {
scanf("%d%d", &k, &l);
gr[k].push_back(l);
gr[l].push_back(k);
}
for (i = 1; i <= n; i++) {
if (visited[i] == 0) {
flag = 0;
dfs(i, -1);
if (flag == 0) ans++;
}
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int dfs_(int n, vector<vector<int>> &adj_list) {
set<int> unvisited;
for (int i = 1; i <= n; i++) unvisited.insert(i);
int count = 0;
while (!unvisited.empty()) {
auto iter_set = unvisited.begin();
int start_node = *iter_set;
bool cycle = 0;
stack<int> st;
st.push(start_node);
unvisited.erase(start_node);
int prev_node = start_node;
while (!st.empty()) {
int cur_node = st.top();
st.pop();
for (auto &iter : adj_list[cur_node]) {
if (unvisited.find(iter) != unvisited.end()) {
st.push(iter);
prev_node = iter;
unvisited.erase(iter);
} else if (iter != prev_node && iter != start_node) {
cycle = true;
}
}
prev_node = cur_node;
}
if (!cycle) count++;
}
return count;
}
bool visited[100001];
int levels[100001];
int temp_count = 0;
int res_count = 0;
void dfs(int src, vector<vector<int>> &adj_list) {
visited[src] = true;
for (auto &iter : adj_list[src]) {
if (!visited[iter]) {
levels[iter] = levels[src] + 1;
dfs(iter, adj_list);
} else if (levels[iter] > levels[src] + 1) {
temp_count++;
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
int x, y;
cin >> n >> m;
for (int i = 1; i <= n; i++) visited[i] = false;
for (int i = 1; i <= n; i++) levels[i] = 0;
vector<vector<int>> adj_list(n + 1);
for (int i = 0; i < m; ++i) {
cin >> x >> y;
adj_list[x].push_back(y);
adj_list[y].push_back(x);
}
for (int i = 1; i <= n; i++) {
if (!visited[i]) {
temp_count = 0;
dfs(i, adj_list);
if (temp_count == 0) res_count++;
}
}
cout << res_count << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > v(100005);
int visited[100005];
map<pair<long long, long long>, int> mapping;
int nodes, edges;
void dfs(int start) {
nodes++;
visited[start] = 1;
int i;
for (i = 0; i < v[start].size(); i++) {
if (!visited[v[start][i]]) {
edges++;
mapping[pair<long long, long long>(start, v[start][i])] = 1;
dfs(v[start][i]);
} else if (mapping[pair<long long, long long>(start, v[start][i])] == 0 &&
mapping[pair<long long, long long>(v[start][i], start)] == 0) {
mapping[pair<long long, long long>(start, v[start][i])] = 1;
edges++;
}
}
}
int main() {
int i, j, n, m, ans, a, b;
scanf("%d %d", &n, &m);
for (i = 0; i < m; i++) {
scanf("%d %d", &a, &b);
v[a].push_back(b);
v[b].push_back(a);
}
ans = 0;
for (i = 1; i <= n; i++) {
if (visited[i]) continue;
nodes = 0;
edges = 0;
dfs(i);
if (nodes - 1 == edges) ans++;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
constexpr int N = 100001;
int n, m;
vector<int> g[N];
bool u[N];
bool dfs(int v, int p = -1) {
bool c = false;
u[v] = true;
for (int t : g[v]) {
if (t != p) {
if (u[t])
c = true;
else
c |= dfs(t, v);
}
}
return c;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> m;
int ans = 0;
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) {
if (!u[i]) ans += 1 - dfs(i);
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[100001];
bool visited[100001];
void add_edge(int a, int b) {
adj[a].push_back(b);
adj[b].push_back(a);
}
bool DFS(int cur, int last) {
visited[cur] = true;
for (int i = 0; i < adj[cur].size(); i++) {
if (visited[adj[cur][i]] == false) {
bool getdfs = DFS(adj[cur][i], cur);
if (getdfs == true) {
return true;
}
} else if (adj[cur][i] != last) {
return true;
}
}
return false;
}
int n, m, ans;
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int ta, tb;
cin >> ta >> tb;
add_edge(ta, tb);
}
for (int i = 1; i <= n; i++) {
if (visited[i] == false) {
bool cset = DFS(i, -1);
if (cset != true) {
ans++;
}
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int t, ch[100005];
vector<int> g[100005];
void dfs(int u, int fa) {
ch[u] = 1;
for (auto i : g[u]) {
if (ch[i] == 0) {
dfs(i, u);
} else if (ch[i] == 1 && i != fa) {
t = 1;
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
memset(ch, 0, sizeof(ch));
for (int i = 1; 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; i++) {
if (ch[i] == 0) {
t = 0;
dfs(i, i);
if (t == 0) ans++;
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
int n, m;
vector<int> mp[maxn];
int dis[maxn];
int flag;
void dfs(int u, int from) {
dis[u] = 1;
for (int i = 0; i < mp[u].size(); i++) {
int v = mp[u][i];
if (v == from) continue;
if (dis[v] == 1) {
flag = 1;
continue;
}
dfs(v, u);
}
}
void init() {
for (int i = 1; i <= n; i++) {
mp[i].clear();
}
}
int main() {
int x, y;
while (~scanf("%d %d", &n, &m)) {
memset(dis, 0, sizeof(dis));
init();
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d%d", &x, &y);
mp[x].push_back(y);
mp[y].push_back(x);
}
int ti = 0;
for (int i = 1; i <= n; i++) {
if (dis[i] == 0) {
flag = 0;
dfs(i, -1);
if (flag == 0) ti++;
}
}
printf("%d\n", ti);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, -1, 1};
void arquivo() {
freopen("", "r", stdin);
freopen("", "w", stdout);
}
const int N = 200010;
int n, m;
int deg[N];
vector<long long> g[N];
int vis[N];
int leave;
int hasCycle;
void dfs(int x, int ult) {
vis[x] = 1;
leave += (g[x].size() == 1);
for (int i = 0; i < g[x].size(); ++i) {
int y = g[x][i];
if (ult == y) continue;
if (vis[y])
hasCycle = 1;
else
dfs(y, x);
}
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < m; ++i) {
int a, b;
scanf("%d %d", &a, &b);
a--;
b--;
deg[a]++;
deg[b]++;
g[a].push_back(b);
g[b].push_back(a);
}
int ans = 0;
for (int i = 0; i < n; ++i) {
if (!vis[i]) {
leave = hasCycle = 0;
dfs(i, -1);
if (!hasCycle) ans++;
}
}
printf("%d\n", ans);
return 0;
}
|
#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() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
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;
vector<int> w[100001];
vector<bool> visit(100001);
int n, m, ans;
bool flag = false;
void dfs(int i, int parent) {
visit[i] = true;
for (int j = 0; j < w[i].size(); j++) {
if (!visit[w[i][j]]) {
dfs(w[i][j], i);
} else if (w[i][j] != parent) {
flag = true;
}
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
w[u].push_back(v);
w[v].push_back(u);
}
for (int i = 1; i <= n; i++) {
if (!visit[i]) {
int parent = -1;
dfs(i, parent);
if (!flag) {
ans++;
}
flag = false;
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[100005];
bool visit[100005];
int countn, counte;
void dfsvisit(int vert) {
visit[vert] = true;
countn++;
counte += adj[vert].size();
for (int i = 0; i < adj[vert].size(); i++) {
if (!visit[adj[vert][i]]) {
dfsvisit(adj[vert][i]);
}
}
}
int main() {
memset(visit, false, sizeof(visit));
int n, m, l, r;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d%d", &l, &r);
adj[l].push_back(r);
adj[r].push_back(l);
}
int ans = 0;
for (int i = 1; i <= n; i++) {
countn = 0;
counte = 0;
if (!visit[i]) {
dfsvisit(i);
counte /= 2;
}
ans += max(0, (countn - counte));
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
long long par[100010], ran[100010];
bitset<100010> cyc;
long long ufind(long long a) {
if (par[a] != a) par[a] = ufind(par[a]);
return par[a];
}
long long uni(long long a, long long b) {
if (ran[a] > ran[b])
par[b] = a;
else
par[a] = b;
if (ran[a] == ran[b]) ran[b]++;
if (cyc[a] || cyc[b]) {
cyc[a] = true;
cyc[b] = true;
}
}
int main() {
long long t, n, m, x, y, i;
cin >> n >> m;
for (i = 1; i <= n; i++) par[i] = i;
while (m--) {
cin >> x >> y;
long long px = ufind(x);
long long py = ufind(y);
if (px != py)
uni(px, py);
else
cyc[px] = true;
}
long long cnt = 0;
for (i = 1; i <= n; i++)
if (par[i] == i && !cyc[i]) cnt++;
cout << cnt;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5;
vector<int> g[N];
int mark[N];
int cnt[N];
int ed[N];
void dfs(int v, int c) {
mark[v] = c;
cnt[c]++;
for (int u : g[v]) {
if (mark[u] == -1) {
dfs(u, c);
}
}
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
vector<pair<int, int> > e(m);
for (int i = 0; i < m; i++) {
scanf("%d%d", &e[i].first, &e[i].second);
--e[i].first, --e[i].second;
g[e[i].first].push_back(e[i].second);
g[e[i].second].push_back(e[i].first);
}
memset(mark, -1, sizeof mark);
int c = 0;
for (int i = 0; i < n; i++) {
if (mark[i] == -1) {
dfs(i, c++);
}
}
for (int i = 0; i < m; i++) {
ed[mark[e[i].first]]++;
}
int ans = 0;
for (int i = 0; i < c; i++) {
if (ed[i] == cnt[i] - 1) {
ans++;
}
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > g;
bitset<int(1e5)> visited;
int parent[int(1e5)];
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 u) {
if (parent[u] == u) return u;
return parent[u] = find(parent[u]);
}
void solve(int n, int m) {
for (int i = 0; i < n; i++) parent[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 {
parent[u] = v;
cnt--;
visited[v] = visited[u] || visited[v];
}
}
for (int i = 0; i < n; i++)
if (parent[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;
const int MaxN = 100100;
int N, M;
int cnt = -1;
bool been[MaxN];
vector<int> adj[MaxN];
vector<int> Ver[MaxN];
int beenKomp[MaxN];
bool dfsKomp(int i) {
bool ret = 1;
beenKomp[i] = 1;
for (auto v : adj[i]) {
if (!beenKomp[v]) {
ret &= dfsKomp(v);
} else if (beenKomp[v] == 2) {
ret &= 0;
}
}
beenKomp[i] = 2;
return ret;
}
void dfs(int i) {
been[i] = 1;
for (auto v : adj[i]) {
if (!been[v]) dfs(v);
}
Ver[cnt].push_back(i);
}
int main() {
cin >> N >> M;
int ta, tb;
for (int i = (0); i < (M); i++) {
scanf("%d%d", &ta, &tb);
ta--;
tb--;
adj[ta].push_back(tb);
adj[tb].push_back(ta);
}
for (int i = (0); i < (N); i++) {
if (!been[i]) {
cnt++;
dfs(i);
}
}
int sol = 0;
for (int k = (0); k < (cnt + 1); k++) {
if (dfsKomp(Ver[k][0])) sol++;
}
cout << sol << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<list<int> > adj(100001);
int parent[100001];
bool vi[100001];
bool v[100001];
void dfs(int i) {
v[i] = true;
list<int>::iterator i1;
for (i1 = adj[i].begin(); i1 != adj[i].end(); i1++) {
if (v[*i1] == false) dfs(*i1);
}
}
int detect_cycle(int i, int coming) {
vi[i] = true;
list<int>::iterator it;
for (it = adj[i].begin(); it != adj[i].end(); it++) {
if (vi[*it] == false) {
int k = detect_cycle(*it, i);
if (k == 1)
return k;
else
continue;
} else {
if (coming == *it)
continue;
else
return 1;
}
}
return 0;
}
int main() {
int n, m;
cin >> n >> m;
int i, j, k, x, y, c = 0;
for (i = 0; i < m; i++) {
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
list<int> nodes;
for (i = 1; i <= n; i++) {
if (v[i] == false) {
nodes.push_back(i);
dfs(i);
}
}
list<int>::iterator it;
for (it = nodes.begin(); it != nodes.end(); it++) {
if (adj[*it].size() == 0)
c++;
else {
k = detect_cycle(*it, -1);
if (k == 0) c++;
}
}
cout << c;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 0x3f3f3f3f3f3f3f3f;
long long unionfind(long long i, vector<long long> &group) {
vector<long long> v;
while (group[i] != i) {
v.push_back(i);
group[i] = i;
}
for (long long x : v) {
group[x] = i;
}
return i;
}
bool iscycle(long long s, vector<bool> &vis, vector<vector<long long> > &adj,
long long par) {
vis[s] = true;
for (auto it = adj[s].begin(); it != adj[s].end(); it++) {
if (!vis[*it]) {
if (iscycle(*it, vis, adj, s)) {
return true;
}
} else if (*it != par) {
return true;
}
}
return false;
}
void dfs(long long s, vector<vector<long long> > &adj, vector<bool> &vis,
vector<long long> &group) {
vis[s] = true;
for (auto it = adj[s].begin(); it != adj[s].end(); it++) {
if (!vis[*it]) {
group[*it] = s;
dfs(*it, adj, vis, group);
}
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t;
t = 1;
while (t--) {
long long n, m, i;
cin >> n >> m;
vector<vector<long long> > adj(n + 1);
for (i = 0; i < m; i++) {
long long a, b;
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
}
vector<long long> group(n + 1);
for (i = 1; i <= n; i++) group[i] = i;
vector<bool> vis(n + 1, false);
for (i = 1; i <= n; i++) {
if (!vis[i]) dfs(i, adj, vis, group);
}
fill(vis.begin(), vis.end(), false);
long long ans = 0;
for (i = 1; i <= n; i++) {
if (!vis[i]) {
if (!iscycle(i, vis, adj, -1)) ans++;
}
}
cout << ans << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
int INF = 2147483647;
double INFD = 2147483647;
double PI = 3.14159265359;
using namespace std;
bool DFS(int u, int p, vector<vector<int> >& graph, vector<int>& visited,
int& visit_count) {
bool answer = false;
if (visited[u] == 1) {
return true;
}
visit_count++;
visited[u] = 1;
int i = 0;
while (i < graph[u].size()) {
int v = graph[u][i];
if (v != p) {
bool dfs = DFS(v, u, graph, visited, visit_count);
answer = answer || dfs;
}
i++;
}
return answer;
}
int Solve(vector<vector<int> >& graph) {
int u = 0, count = 0;
vector<int> visited(graph.size(), 0);
while (u < graph.size()) {
if (!visited[u]) {
int visit_count = 0;
bool dfs = !DFS(u, u, graph, visited, visit_count);
if (visit_count == 1 || dfs) {
count++;
}
}
u++;
}
return count;
}
int main() {
int n = 0, m = 0;
cin >> n >> m;
vector<vector<int> > graph(n);
int i = 0;
while (i < m) {
int u = 0, v = 0;
cin >> u >> v;
u--;
v--;
graph[u].push_back(v);
graph[v].push_back(u);
i++;
}
cout << Solve(graph) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> v[100001];
bool vis[100001];
void dfs(int nod, int parent, int &flag) {
int i;
vis[nod] = 1;
for (i = 0; i < v[nod].size(); i++) {
int curr = v[nod][i];
if (vis[curr] == 0) {
dfs(curr, nod, flag);
} else if (parent != curr) {
flag = 1;
}
}
return;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int cit, road, i, u1, v1;
cin >> cit >> road;
for (i = 1; i <= road; i++) {
cin >> u1 >> v1;
v[v1].push_back(u1);
v[u1].push_back(v1);
}
int flag, cnt = 0, parent = -1;
for (i = 1; i <= cit; i++) {
flag = 0;
if (vis[i] == 0) {
dfs(i, parent, flag);
if (flag == 0) {
cnt++;
}
}
}
cout << cnt;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> adj[100001];
bool visited[100001];
bool recStack[100001];
vector<long long> p(100001, -1);
vector<long long> rnk(100001, -1);
void create_set(int x) {
visited[x] = 1;
p[x] = x;
rnk[x] = 0;
}
int find_set(int i) {
if (p[i] != i) p[i] = find_set(p[i]);
return p[i];
}
void merge_set(int x, int y) {
int px = find_set(x);
int py = find_set(y);
if (rnk[px] > rnk[py])
p[py] = px;
else
p[px] = py;
if (rnk[px] == rnk[py]) rnk[py] = rnk[py] + 1;
}
bool dfs(long long node, long long parent) {
visited[node] = 1;
for (auto i : adj[node]) {
if (!visited[i]) {
if (dfs(i, node)) return true;
} else if (i != parent)
return true;
}
return false;
}
int main() {
iostream::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long n, m;
cin >> n >> m;
for (long long i = (0); i < (m); ++i) {
long long a, b;
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
}
long long cnt = 0;
memset(visited, 0, sizeof(visited));
for (long long i = (1); i < (n + 1); ++i) {
if (!visited[i]) {
if (dfs(i, 0) == 0) cnt++;
}
}
cout << cnt;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int tp[2000005];
std::vector<long long int> v[100005];
long long int vis[100005], deg[100005], ecnt, vcnt;
void timepass() {
for (int i = 0; i < 2000005; ++i) {
tp[i] = i;
}
}
void DFS(int s) {
vis[s] = 1;
vcnt++;
ecnt += deg[s];
for (int i = 0; i < v[s].size(); ++i) {
if (!vis[v[s][i]]) {
DFS(v[s][i]);
}
}
}
int main() {
long long int q, n, t, m, k = 1, i, j, f = 0, g = 0, h, c = 0, m1, m2, d = 0;
timepass();
cin >> n >> m;
for (int i = 0; i < m; ++i) {
cin >> m1 >> m2;
v[m1].push_back(m2);
v[m2].push_back(m1);
deg[m1]++;
deg[m2]++;
}
for (int i = 1; i < n + 1; ++i) {
if (!vis[i]) {
ecnt = vcnt = 0;
DFS(i);
ecnt = ecnt / 2;
if (ecnt < vcnt) c++;
}
}
cout << c;
return 0;
}
|
#include <bits/stdc++.h>
int du[100010], fa[100010], s1[100010], s2[100010];
int find(int x) {
if (x != fa[x]) fa[x] = find(fa[x]);
return fa[x];
}
int main() {
int n, m, x, y, i, j, k, sum;
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) fa[i] = i;
memset(du, 0, sizeof(du));
memset(s1, 0, sizeof(s1));
memset(s2, 0, sizeof(s2));
for (i = 1; i <= m; i++) {
scanf("%d%d", &x, &y);
j = find(x);
k = find(y);
du[x]++;
du[y]++;
if (j != k) {
if (j < k)
fa[k] = j;
else
fa[j] = k;
}
}
for (i = 1; i <= n; i++) {
j = find(i);
s1[j] = s1[j] + du[i];
s2[j]++;
}
sum = 0;
for (i = 1; i <= n; i++)
if (s2[i] != 0) {
j = s1[i] / 2;
if (j < s2[i]) sum = sum + s2[i] - j;
}
printf("%d\n", sum);
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> v[100005];
bool vis[100005];
bool tree;
void dfs(int n, int p) {
vis[n] = true;
for (int i = 0; i < v[n].size(); i++) {
if (!vis[v[n][i]])
dfs(v[n][i], n);
else if (v[n][i] != p)
tree = false;
}
}
int main() {
int n, m, a, b;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
cin >> a >> b;
v[a].push_back(b);
v[b].push_back(a);
}
int x = 0;
memset(vis, false, sizeof(vis));
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
tree = true;
dfs(i, 0);
if (tree) x++;
}
}
cout << x;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
vector<long long> fact(1);
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long power(long long x, long long y) {
long long temp;
if (y == 0) return 1;
temp = power(x, y / 2);
if (y % 2 == 0)
return temp * temp;
else
return x * temp * temp;
}
long long power(long long x, long long y, long long p) {
long long res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long modInv(long long n, long long p) { return power(n, p - 2, p); }
long long ncr(long long n, long long r) {
return (n >= r ? (fact[n] * modInv(fact[r], mod)) % mod *
modInv(fact[n - r], mod) % mod
: 0);
}
long long add(long long a, long long b) {
long long z = a + b;
if (z >= mod) z -= mod;
return z;
}
long long mul(long long a, long long b) { return (a * b) % mod; }
long long sub(long long a, long long b) { return (a - b + mod) % mod; }
vector<long long> v[100005], vis(100005);
long long cnte = 0, cntv = 0;
void dfs(long long x) {
cntv++;
vis[x] = 1;
for (auto i : v[x]) {
cnte++;
if (!vis[i]) dfs(i);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t = 1, n, i, j, c, d, m;
while (t--) {
cin >> n >> m;
for (i = 0; i < m; i++) {
cin >> c >> d;
v[c].push_back(d);
v[d].push_back(c);
}
long long ans = 0;
for (i = 1; i <= n; i++) {
cnte = cntv = 0;
if (!vis[i]) {
dfs(i);
if (cnte / 2 < cntv) ans++;
}
}
cout << ans;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<int> v[100009];
int visited[100009];
int parent[100009];
int DFS(int start) {
visited[start] = 1;
int i, s = v[start].size(), ans = 0;
for (i = 0; i < s; i++) {
if (visited[v[start][i]] == 0) {
parent[v[start][i]] = start;
ans = DFS(v[start][i]);
} else if (parent[start] != v[start][i]) {
ans = 1;
}
if (ans == 1) break;
}
return ans;
}
int main() {
int i, j, a, b;
scanf("%d%d", &n, &m);
for (i = 0; i < m; i++) {
scanf("%d%d", &a, &b);
v[a].push_back(b);
v[b].push_back(a);
}
int ans = 0, an;
for (i = 1; i <= n; i++) {
if (visited[i] == 0) {
parent[i] = -1;
an = DFS(i);
if (an != 1) ans++;
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long power(long long a, long long b, long long m) {
long long ans = 1;
while (b) {
if (b & 1) ans = (ans * a) % m;
b /= 2;
a = (a * a) % m;
}
return ans;
}
long long par[200000 + 1];
long long cat[200000 + 1];
long long vis[200000 + 1];
long long m;
long long iscycle = 0;
void dfs(long long i, long long p, vector<long long> adj[]) {
vis[i] = 1;
for (long long j = 0; j < adj[i].size(); j++) {
if (adj[i][j] == p) continue;
if (vis[adj[i][j]] == 1 && adj[i][j] != p) {
iscycle = 1;
}
if (vis[adj[i][j]] == 0) {
dfs(adj[i][j], i, adj);
}
}
}
bool cmp(long long x, long long y) { return x > y; }
int32_t main() {
long long q = 1;
long long Q = 1;
while (q--) {
long long n, m;
cin >> n >> m;
vector<long long> adj[n + 1];
long long p = n - 1;
while (m--) {
long long u, v, x;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
long long ans = 0;
for (long long i = 1; i <= n; i++) {
iscycle = 0;
if (vis[i] == 0) {
dfs(i, 0, adj);
if (iscycle == 0) {
ans++;
}
}
}
cout << ans;
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> r[100000 + 1];
bool visited[100000 + 1];
int cnt;
bool cycle, leaf;
void dfs(int, int);
int main(int argc, const char* argv[]) {
int n, m;
scanf("%d%d", &n, &m);
while (m--) {
int u, v;
scanf("%d%d", &u, &v);
r[u].push_back(v);
r[v].push_back(u);
}
for (int u = 1; u <= n; u++) {
if (visited[u]) continue;
if (r[u].size() == 0) {
cnt++;
} else if (r[u].size() == 1) {
visited[u] = true;
cycle = leaf = false;
dfs(r[u][0], u);
cnt += (!cycle && leaf);
}
}
printf("%d\n", cnt);
return 0;
}
void dfs(int u, int from) {
if (visited[u]) {
return;
}
visited[u] = true;
if (!cycle && r[u].size() == 1) {
leaf = true;
return;
}
for (auto v : r[u]) {
if (v == from) continue;
cycle |= visited[v];
}
for (auto v : r[u]) {
if (v == from) continue;
dfs(v, u);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n, m, cnt, res;
vector<int> adj[N];
bool check, visited[N];
void Input() {
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
}
void DFS(int u, int r) {
visited[u] = true;
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i];
if (!visited[v])
DFS(v, u);
else if (visited[v] && v != r)
check = true;
}
}
void Solve() {
for (int i = 1; i <= n; i++) {
if (!visited[i]) {
check = false, DFS(i, 0);
if (check == false) res++;
}
}
}
int main() {
Input();
Solve();
cout << res << '\n';
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;
}
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);
}
p[v] = u;
us[u] |= us[v];
if (u == v) {
us[v] = true;
} else {
s[u] += s[v];
}
}
int res = 0;
for (int u = 1; u <= n; u++) {
if (u == p[u]) {
res += !us[u];
}
}
printf("%d\n", res);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 112345;
int n, m;
vector<bool> visited;
vector<int> adj[N];
bool found;
void dfs(int n, int parent) {
visited[n] = true;
for (auto i : adj[n]) {
if (visited[i] == false) {
dfs(i, n);
} else if (i != parent) {
found = true;
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int a, b;
cin >> a >> b;
a--;
b--;
adj[a].push_back(b);
adj[b].push_back(a);
}
visited.assign(n, false);
int ans = 0;
for (int i = 0; i < n; ++i) {
if (visited[i] == false) {
found = false;
dfs(i, -1);
if (found == false) {
ans++;
}
}
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long fpow(long long base, long long power) {
long long result = 1;
while (power > 0) {
if (power % 2 == 1) {
result = (result * base);
}
base = (base * base);
power /= 2;
}
return result;
}
bool visited[100100];
vector<long long> adj[100100];
int main() {
long long n, m;
cin >> n >> m;
long long i, j, x, ans = 0;
for (i = 0; i < m; i++) {
long long u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
memset(visited, 0, sizeof(visited));
for (i = 1; i <= n; i++) {
if (visited[i] == false) {
long long edgeno = 0, nodes = 0;
queue<long long> Q;
Q.push(i);
while (!Q.empty()) {
long long nodeQ = Q.front();
Q.pop();
nodes++;
visited[nodeQ] = true;
for (j = 0; j < adj[nodeQ].size(); j++) {
long long to = adj[nodeQ][j];
if (visited[to] == false) {
Q.push(to);
}
edgeno++;
}
}
edgeno /= 2;
if (edgeno == nodes - 1) {
ans++;
}
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> graph[200007];
bool vis[200007];
bool dfs(int node, int par = -1) {
vis[node] = true;
bool tree = true;
for (int i = 0; i < graph[node].size(); ++i) {
if (vis[graph[node][i]] && graph[node][i] != par) return false;
if (!vis[graph[node][i]] && tree) tree = dfs(graph[node][i], node);
}
return tree;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int a, b, n, m;
cin >> n >> m;
while (m--) {
cin >> a >> b;
graph[a].push_back(b);
graph[b].push_back(a);
}
int ans = 0;
for (int i = 1; i <= n; ++i) {
if (vis[i]) continue;
if (graph[i].size()) {
ans += (dfs(i) == true);
} else
++ans;
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dx[] = {1, -1, 0, 0, 1, -1, -1, 1};
int dy[] = {0, 0, 1, -1, 1, -1, 1, -1};
vector<int> adj[100005];
bool vis[100005];
vector<vector<int> > v;
vector<int> vv;
void dfs(int x) {
vis[x] = 1;
vv.push_back(x);
for (int i = 0; i < adj[x].size(); i++)
if (!vis[adj[x][i]]) dfs(adj[x][i]);
}
int main() {
int n, m, ans = 0;
scanf("%d%d", &n, &m);
while (m--) {
int u, v;
scanf("%d%d", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
}
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
vv.clear();
dfs(i);
v.push_back(vv);
}
}
for (int i = 0; i < v.size(); i++) {
int c = 0;
for (int j = 0; j < v[i].size(); j++) c += adj[v[i][j]].size();
ans += (c < v[i].size() * 2);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int mxn = 1e5 + 5;
long long int par[mxn];
long long int siz[mxn];
long long int find(long long int n) {
if (par[n] == n) return n;
return par[n] = find(par[n]);
}
void unite(long long int a, long long int b) {
a = find(a);
b = find(b);
if (a != b) {
par[b] = a;
siz[a] += siz[b];
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t = 1;
while (t--) {
long long int i, j, k, n, m;
cin >> n >> m;
for (i = 1; i <= n; i++) {
par[i] = i;
siz[i] = 1;
}
vector<pair<long long int, long long int>> edg(m);
vector<long long int> roads(n + 1, 0);
for (i = 0; i < m; i++) {
cin >> edg[i].first >> edg[i].second;
unite(edg[i].first, edg[i].second);
}
for (i = 0; i < m; i++) roads[find(edg[i].first)]++;
long long int ans = 0;
set<long long int> s;
for (i = 1; i <= n; i++) {
s.insert(find(i));
}
for (auto i : s) {
k = siz[i];
if (roads[i] == k - 1) ans++;
}
cout << ans;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long int> adj[100001];
bool visited[100001];
long long int n, m;
int flag;
void dfs(int parent, int vertex) {
visited[vertex] = true;
int i;
for (i = 0; i < (long long int)(adj[vertex].size()); i++) {
if (visited[adj[vertex][i]] == false)
dfs(vertex, adj[vertex][i]);
else {
if (adj[vertex][i] != parent) flag = 1;
}
}
}
void solve() {
cin >> n >> m;
long long int i, x, y;
for (i = 0; i < m; i++) {
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
int cnt = 0;
int connected_comp = 0;
for (i = 1; i <= n; i++) {
flag = 0;
if (visited[i] == false) {
dfs(0, i);
connected_comp++;
}
if (flag) cnt++;
}
cout << connected_comp - cnt << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 7;
const int N = 100007;
int n, vis[N];
vector<int> g[N];
bool dfs(int v, int p) {
bool res = false;
vis[v] = 1;
for (auto u : g[v])
if (u != p) {
if (vis[u] == 1)
res |= true;
else
res |= dfs(u, v);
}
return res;
}
void solve() {
int m;
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);
}
int res = 0;
for (int v = 1; v <= n; ++v) {
if (vis[v] == 0) {
if (!dfs(v, -1)) ++res;
}
}
cout << res << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.precision(10);
cout << fixed;
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void itval(istream_iterator<string> it) {}
template <typename T, typename... Args>
void itval(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << endl;
itval(++it, args...);
}
const long long int MOD = 1e9 + 7;
template <typename T>
inline void print(T x) {
cout << x << "\n";
}
template <typename T>
inline void printvec(T x) {
for (auto a : x) cout << a << ' ';
cout << '\n';
}
struct custom {
bool operator()(
const pair<pair<long long int, long long int>, long long int> &p1,
const pair<pair<long long int, long long int>, long long int> &p2) const {
if (p1.second == p2.second) {
return p1.first.second < p2.first.second;
}
return p1.second < p2.second;
}
};
long long int get_pow(long long int a, long long int b) {
long long int res = 1;
while (b) {
if (b & 1) res = (res * a) % MOD;
a = (a * a) % MOD;
b >>= 1;
}
return res;
}
const long long int N = 1e5 + 5, inf = 4e18;
std::vector<vector<long long> > adj(N);
vector<bool> vis(N, false);
bool cyc = 0;
long long int cnt = 0;
void dfs(int s, int p) {
vis[s] = 1;
cnt++;
for (auto x : adj[s]) {
if (vis[x] && x != p) {
cyc = 1;
} else if (!vis[x])
dfs(x, s);
}
}
void solve() {
long long int n, m, x, y;
cin >> n >> m;
long long int ans = 0;
for (long long int i = (long long int)0; i < (long long int)(m); i++) {
cin >> x >> y;
x--;
y--;
adj[x].push_back(y);
adj[y].push_back(x);
}
for (long long int i = (long long int)0; i < (long long int)(n); i++) {
if (!vis[i]) {
cnt = 0;
cyc = false;
dfs(i, -1);
if (cyc)
continue;
else
ans++;
}
}
cout << ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int test = 1;
clock_t z = clock();
for (long long int tes = (long long int)0; tes < (long long int)(test);
tes++) {
solve();
}
fprintf(stderr, "Total Time:%.4f\n", (double)(clock() - z) / CLOCKS_PER_SEC),
fflush(stderr);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("omit-frame-pointer")
#pragma GCC optimize("unroll-loops")
const int MAXINT = 2147483640;
const long long MAXLL = 9223372036854775800LL;
const long long MAXN = 1000000;
const double pi = 3.1415926535897932384626433832795;
using namespace std;
pair<long long, long long> x1[300000];
vector<long long> v[300000];
long long f[300000];
long long kolver[300000];
long long koledg[300000];
long long kol = 0;
void dfs(long long xx) {
if (f[xx]) return;
f[xx] = kol;
for (int i = 0; i < v[xx].size(); i++) dfs(v[xx][i]);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
srand(time(0));
long long n, m, i, a, b, ans = 0;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
cin >> a >> b;
v[a].push_back(b);
v[b].push_back(a);
x1[i] = make_pair(a, b);
}
for (int i = 1; i <= n; i++)
if (!f[i]) {
kol++;
dfs(i);
}
for (int i = 1; i <= n; i++) kolver[f[i]]++;
for (int i = 1; i <= m; i++) {
a = x1[i].first;
b = x1[i].second;
koledg[f[a]]++;
}
for (int i = 1; i <= kol; i++)
if (koledg[i] == kolver[i] - 1) ans++;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool vis[100005];
vector<int> adj[100005];
int n, m, u, v, d_edges, nodes, sz, answer;
void dfs(int c) {
vis[c] = 1;
nodes++;
d_edges += adj[c].size();
for (int j = 0; j < adj[c].size(); j++) {
if (!vis[adj[c][j]]) dfs(adj[c][j]);
}
}
int main() {
scanf("%d%d", &n, &m);
while (m--) {
scanf("%d%d", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
}
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
dfs(i);
if (nodes * 2 > d_edges) answer++;
d_edges = nodes = 0;
}
}
printf("%d", answer);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> ed[100100];
bool vis[100100];
bool tree;
void dfs(long long n, long long p) {
vis[n] = 1;
for (long long i = 0; i < ed[n].size(); i++) {
if (vis[ed[n][i]] == 0) {
dfs(ed[n][i], n);
} else if (ed[n][i] != p) {
tree = 0;
}
}
}
int main() {
long long n, m, x, y, i;
cin >> n >> m;
while (m--) {
scanf("%lld", &x);
scanf("%lld", &y);
ed[x].push_back(y);
ed[y].push_back(x);
}
x = 0;
for (i = 1; i <= n; i++) {
if (vis[i] == 0) {
tree = 1;
dfs(i, 0);
if (tree == 1) x++;
}
}
cout << x << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dx[4] = {0, 0, 1, -1};
int dy[4] = {1, -1, 0, 0};
const int mod = (int)1e9 + 7;
const long long INF64 = 3e18;
void smxl(long long &a, long long b) {
if (a < b) a = b;
}
void smnl(long long &a, long long b) {
if (a > b) a = b;
}
void adsl(long long &a, long long b) {
a += b;
if (a >= mod) a -= mod;
}
void misl(long long &a, long long b) {
a -= b;
if (a >= mod) a -= mod;
if (a < 0) a += mod;
}
void smx(long long &a, long long b) {
if (a < b) a = b;
}
void smn(long long &a, long long b) {
if (a > b) a = b;
}
void ads(long long &a, long long b) {
a += b;
if (a >= mod) a -= mod;
}
void mis(long long &a, long long b) {
a -= b;
if (a >= mod) a -= mod;
if (a < 0) a += mod;
}
long long gcd(long long a, long long b) { return (b == 0 ? a : gcd(b, a % b)); }
long long egcd(long long a, long long b, long long &x, long long &y) {
if (a == 0) {
x = 0;
y = 1;
return b;
}
long long x1, y1;
long long d = egcd(b % a, a, x1, y1);
x = y1 - (b / a) * x1;
y = x1;
return d;
}
long long mbinp(long long a, long long b) {
a %= mod;
if (b == 0) return 1;
long long ans = mbinp(a, b / 2);
long long tmp = (ans * ans) % mod;
if (b % 2) return ((tmp * a) % mod);
return ((tmp) % mod);
}
long long binp(long long a, long long b) {
if (b == 0) return 1;
long long ans = binp(a, b / 2);
long long tmp = (ans * ans);
if (b % 2) return ((tmp * a));
return ((tmp));
}
long long C(int n, int m) {
long long ret = 1;
for (int i = 1; i <= m; i++) {
ret *= (n - i + 1);
ret /= i;
}
return ret;
}
long long overbinp(long long a, int b) {
long long res = 1;
while (b) {
if (b & 1) {
if (res < INF64 / a)
res *= a;
else
return INF64;
}
if (b > 1) {
if (a < INF64 / a)
a *= a;
else
return INF64;
}
b >>= 1;
}
return res;
}
const int nax = 1e5 + 50;
int par[nax];
int siize[nax];
int get(int x) { return (x == par[x] ? x : par[x] = get(par[x])); }
void merge(int a, int b) {
int x = get(a);
int y = get(b);
if (x == y) return;
if (siize[x] < siize[y]) swap(x, y);
par[y] = x;
siize[x] += siize[y];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m;
cin >> n >> m;
int cnt = 0;
for (int i = 0; i < n; i++) {
par[i] = i;
siize[i] = 1;
}
vector<pair<int, int> > ed;
map<int, int> cc;
map<int, int> edincc;
while (m--) {
int a, b;
cin >> a >> b;
a--;
b--;
ed.push_back(make_pair(a, b));
merge(a, b);
}
for (int i = 0; i < ed.size(); i++) edincc[get(ed[i].first)]++;
for (int i = 0; i < n; i++) cc[get(i)]++;
for (auto t : cc)
if (cc[t.first] > edincc[t.first]) cnt++;
cout << cnt;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
vector<int> edge[N << 1];
bool vis[N];
int num = 0;
int cnt = 0;
void dfs(int u) {
num++;
vis[u] = true;
cnt += edge[u].size();
for (int i = 0; i < edge[u].size(); i++) {
int v = edge[u][i];
if (vis[v]) continue;
dfs(v);
}
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
edge[u].push_back(v);
edge[v].push_back(u);
}
int ret = 0;
for (int i = 1; i <= n; i++) {
if (vis[i]) continue;
num = 0;
cnt = 0;
dfs(i);
cnt /= 2;
if (cnt < num) ret++;
}
cout << ret << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int cir[1100000];
int pre[1100000];
int n, m;
int find_(int x) { return pre[x] == x ? x : pre[x] = find_(pre[x]); }
void init() {
for (int i = 0; i <= n; i++) pre[i] = i;
}
int main() {
scanf("%d%d", &n, &m);
init();
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
int find_x = find_(x);
int find_y = find_(y);
if (find_x == find_y)
cir[find_x] = find_x;
else {
pre[find_x] = find_y;
if (cir[find_x]) cir[find_y] = cir[find_x];
}
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (pre[i] == i && !cir[i]) ans++;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int n, m, d[N], v, u;
set<int> nei[N], zero, one;
bool mark[N];
void isval(int v) {
if (d[v] == 1)
one.insert(v);
else if (d[v] == 0)
zero.insert(v);
}
int main() {
scanf("%d", &n);
scanf("%d", &m);
for (int i = 0; i < m; i++) {
scanf("%d", &v);
scanf("%d", &u);
v--, u--;
nei[v].insert(u);
nei[u].insert(v);
d[v]++;
d[u]++;
}
for (int i = 0; i < n; i++) {
isval(i);
}
while (one.size() > 0) {
v = *one.begin();
mark[v] = true;
one.erase(v);
for (set<int>::iterator it = nei[v].begin(); it != nei[v].end(); it++) {
u = *it;
d[u]--;
if (!mark[u]) isval(u);
}
}
int answer = zero.size();
cout << answer;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> graph[100001];
int visited[100001] = {0}, parent[100001] = {0};
int dfs(int s, int p) {
visited[s] = 1;
int f = 1;
for (int j = 0; j < graph[s].size(); j++)
if (!visited[graph[s][j]]) {
parent[graph[s][j]] = s;
f = min(f, dfs(graph[s][j], p));
} else if (parent[s] != graph[s][j]) {
f = 0;
}
return f;
}
int main() {
int n, m, ans = 0, i, x, y;
cin >> n >> m;
for (i = 0; i < m; i++) {
cin >> x >> y;
graph[x].push_back(y);
graph[y].push_back(x);
}
for (i = 1; i <= n; i++)
if (!visited[i]) {
parent[i] = -1;
ans += dfs(i, i);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<int> v[100010];
int vis[100010];
int res;
int flag = 0;
void dfs(int pre, int index) {
vis[index] = 1;
res++;
for (int i = 0; i < v[index].size(); i++) {
if (v[index][i] != pre && vis[v[index][i]]) {
flag = 1;
continue;
}
if (!vis[v[index][i]]) {
dfs(index, v[index][i]);
}
}
return;
}
int main() {
cin >> n >> m;
int a, b;
res = 0;
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= m; i++) {
scanf("%d%d", &a, &b);
v[a].push_back(b);
v[b].push_back(a);
}
for (int i = 1; i <= n; i++) {
flag = 0;
if (!vis[i]) {
dfs(0, i);
if (!flag) {
res--;
}
}
}
cout << n - res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 23;
const int MOD = 1e9 + 7;
const int SZ = 1e5 + 100;
bool vis[SZ];
vector<int> G[SZ];
bool dfs(int v, int from) {
vis[v] = true;
bool ret = false;
for (auto u : G[v]) {
if (u == from) continue;
if (vis[u]) {
ret |= true;
} else {
ret |= dfs(u, v);
}
}
return ret;
}
int main() {
ios_base::sync_with_stdio(0);
int n, m, a, b;
cin >> n >> m;
for (int i = 0; i < m; ++i) {
cin >> a >> b;
G[a].push_back(b);
G[b].push_back(a);
}
int ans = 0;
for (int i = 1; i <= n; ++i) {
if (vis[i]) continue;
ans += !dfs(i, -1);
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7, INF = 1e18, mx = 1e5 + 5, mn = 100;
int testCase = 1, cas = 0;
vector<int> G[mx];
int n, m;
int vis[mx], par[mx], indegree[mx];
int ok;
void dfs(int u) {
vis[u]++;
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i];
if (!vis[v]) {
par[v] = u;
indegree[v]++;
dfs(v);
} else if (par[u] != v)
ok = 1;
}
}
int main() {
ios_base ::sync_with_stdio(0), cin.tie(0);
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
G[a].push_back(b);
G[b].push_back(a);
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
ok = 0;
dfs(i);
if (!ok) ans++;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int p[N];
int cycle[N];
int root(int x) { return p[x] == x ? x : p[x] = root(p[x]); }
bool join(int x, int y) {
x = root(x);
y = root(y);
if (x == y) return false;
if (rand() & 1) swap(x, y);
p[x] = y;
cycle[y] |= cycle[x];
return true;
}
int main() {
ios_base::sync_with_stdio(false);
for (int _n(N), i(0); i < _n; i++) p[i] = i;
int n, m;
cin >> n >> m;
for (int _n(m), i(0); i < _n; i++) {
int x, y;
cin >> x >> y;
--x, --y;
if (!join(x, y)) {
cycle[root(x)] = 1;
}
}
set<int> s;
for (int _n(n), i(0); i < _n; i++) s.insert(root(i));
int ans = (int)s.size();
for (int x : s) ans -= cycle[x];
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000011, M = N << 1;
int n, m, fa[N], ans, f, head[N], cnt, siz[N], vis[N], sum;
struct edge {
int to, nex;
} t[M];
inline void add(int x, int y) {
t[++cnt].to = y;
t[cnt].nex = head[x];
head[x] = cnt;
return;
}
void dfs(int x, int bb) {
vis[x] = 1;
for (int i = head[x]; i; i = t[i].nex) {
int y = t[i].to;
if (y == bb) continue;
if (vis[y]) {
f = 1;
continue;
}
vis[y] = 1;
dfs(y, x);
}
return;
}
inline long long read() {
long long x = 0;
char ch = getchar();
bool f = 1;
for (; !isdigit(ch); ch = getchar())
if (ch == '-') f = 0;
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - '0';
return f ? x : -x;
}
int main() {
n = read();
m = read();
for (int i = 1, u, v; i <= m; i++) {
u = read();
v = read();
add(u, v);
add(v, u);
}
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
f = 0;
dfs(i, 0);
if (f == 0) ans++;
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
int father[maxn];
int vis[maxn];
int n, m;
void Init() {
memset(vis, false, sizeof(vis));
for (int i = 1; i < maxn; i++) {
father[i] = i;
}
}
int con(int x) {
if (x != father[x]) {
int rt = father[x];
father[x] = con(father[x]);
}
return father[x];
}
void Union(int x, int y) {
int xx = con(x);
int yy = con(y);
if (xx != yy) {
father[yy] = xx;
if (vis[xx] || vis[yy] || vis[x] || vis[y])
vis[xx] = vis[yy] = vis[x] = vis[y] = true;
return;
}
vis[xx] = vis[yy] = vis[x] = vis[y] = true;
}
int main() {
while (~scanf("%d%d", &n, &m)) {
Init();
int sum = 0;
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d%d", &a, &b);
Union(a, b);
}
for (int i = 1; i <= n; i++) {
if (vis[con(i)] == false && con(i) == i) sum++;
}
printf("%d\n", sum);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double epsilon = 1e-9;
const long long MOD = 1e9 + 7;
const long long N = 1e5 + 5;
vector<long long> arr[N], vis(N, 0);
bool haveCycle = 0;
bool comp(long long a, long long b) { return (a > b); }
long long binpow(long long a, long long b) {
long long res = 1;
while (b > 0) {
if (b & 1) res *= a;
a = a * a;
b >>= 1;
}
return res;
}
void dfs(long long u, long long p) {
vis[u] = 1;
for (auto x : arr[u]) {
if (!vis[x])
dfs(x, u);
else if (x != p)
haveCycle = 1;
}
}
void runcase() {
long long n, m;
cin >> n >> m;
for (long long i = 0; i < m; i++) {
long long u, v;
cin >> u >> v;
arr[u].push_back(v);
arr[v].push_back(u);
}
long long res = 0;
for (long long i = 1; i < n + 1; i++) {
if (!vis[i]) {
haveCycle = 0;
dfs(i, -1);
if (!haveCycle) res++;
}
}
cout << res << "\n";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.precision(10);
long long tests = 1;
while (tests--) {
runcase();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, i, j, k, l, sum = 0, flag = 0, t, first, m, ans = 0, second,
visited[100005];
vector<long long int> v[100005];
void dfs(int node) {
first++;
visited[node] = 1;
second += v[node].size();
for (auto j : v[node]) {
if (!visited[j]) dfs(j);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (i = 0; i < m; i++) {
cin >> j >> k;
v[k].push_back(j);
v[j].push_back(k);
}
for (i = 1; i <= n; i++) {
if (!visited[i]) {
dfs(i);
second /= 2;
if (first == second + 1) ans++;
first = 0;
second = 0;
}
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Node {
Node() : vis(0), comp(-1) {}
int vis;
int comp;
vector<int> adj;
};
void dfs(vector<Node>& a, int u, int comp) {
a[u].vis = true;
a[u].comp = comp;
for (auto v : a[u].adj) {
if (a[v].vis == false) {
dfs(a, v, comp);
}
}
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
vector<Node> a(n);
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
a[u - 1].adj.push_back(v - 1);
a[v - 1].adj.push_back(u - 1);
}
int comp = 0;
for (int i = 0; i < n; i++) {
if (a[i].vis == 0) {
dfs(a, i, comp++);
}
}
int res = 0;
vector<pair<int, int>> comps(comp);
for (int i = 0; i < n; i++) {
comps[a[i].comp].first += a[i].adj.size();
comps[a[i].comp].second++;
}
for (int i = 0; i < comps.size(); i++) {
if (2 * comps[i].second - comps[i].first > 0) res++;
}
cout << res << endl;
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;
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++;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[100005];
bool cycle, visit[100005];
void dfs(int s, int prev) {
visit[s] = true;
for (int i = 0; i < adj[s].size(); i++) {
int t = adj[s][i];
if (!visit[t]) {
dfs(t, s);
} else if (visit[t] && t != prev) {
cycle = true;
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
int cnt = 0;
for (int i = 1; i <= n; i++) {
cycle = false;
if (!visit[i]) {
dfs(i, 0);
if (!cycle) {
cnt++;
}
}
}
cout << cnt << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 1;
const int maxn = 30;
vector<int> g[N];
int w, p[N], used[N];
void dfs(int v) {
used[v] = 1;
for (int i = 0; i < g[v].size(); i++) {
int to = g[v][i];
if (!used[to]) {
p[to] = v;
dfs(to);
}
if (used[to] == 1 && p[v] != to) {
w = 1;
}
}
used[v] = 2;
}
int main() {
int n, m;
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);
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (!used[i]) {
dfs(i);
if (w == 0) ans++;
w = 0;
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
vector<int> G[N];
int ans = 0, res;
int vis[N];
void dfs(int u, int f) {
if (vis[u]) {
res = 1;
return;
} else
vis[u] = 1;
for (auto i : G[u])
if (i != f) dfs(i, u);
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
G[u].push_back(v);
G[v].push_back(u);
}
for (int i = 1; i <= n; i++)
if (!vis[i]) res = 0, dfs(i, -1), ans++, ans -= res;
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
vector<int> adj[N];
int tmp, ans;
bool vis[N];
int n, m;
void dfs(int i, int p) {
vis[i] = 1;
for (auto v : adj[i]) {
if (vis[v] && v != p)
tmp = 0;
else if (!vis[v])
dfs(v, i);
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
for (int i = 1; i <= n; i++) {
tmp = i;
if (!vis[i]) {
dfs(i, 0);
if (tmp > 0) ans++;
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int par[100005];
int cycles[100005];
bool vis[100005];
int find_set(int x) {
if (x == par[x]) return x;
par[x] = find_set(par[x]);
return par[x];
}
int main() {
int n, m, x, y, ans = 0;
cin >> n >> m;
for (int i = 1; i <= n; i++) par[i] = i, cycles[i] = 0;
while (m--) {
cin >> x >> y;
int par_x = find_set(x);
int par_y = find_set(y);
if (par_x == par_y) {
cycles[par_x]++;
continue;
} else {
cycles[par_y] += cycles[par_x];
cycles[par_x] = 0;
par[par_x] = par_y;
}
}
for (int i = 1; i <= n; i++) {
int par_i = find_set(i);
if (vis[par_i]) continue;
vis[par_i] = true;
ans += (cycles[par_i] == 0);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100009;
vector<vector<int>> gr(N);
bool used[N];
int s = -1;
int dfs(int v, int prv = 0) {
used[v] = true;
for (auto u : gr[v]) {
if (u == prv) continue;
if (used[u]) {
s = 0;
return 0;
}
dfs(u, v);
}
return s == 0 ? 0 : 1;
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a = 0, b = 0;
scanf("%d%d", &a, &b);
gr[a].push_back(b);
gr[b].push_back(a);
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (!used[i]) ans += dfs(i);
s = -1;
}
cout << 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;
int p[100010][2], root[100010];
int find_root(int u) {
if (u == root[u]) return u;
return root[u] = find_root(root[u]);
}
int main() {
int N, M, i, u, v, uu, vv;
scanf("%d %d", &N, &M);
for (i = 1; i <= N; i++) {
root[i] = i;
p[i][0] = 1;
}
for (i = 0; i < M; i++) {
scanf("%d %d", &u, &v);
uu = find_root(u);
vv = find_root(v);
if (uu == vv)
p[uu][1]++;
else {
if (p[uu][0] > p[vv][0]) swap(uu, vv);
root[uu] = vv;
p[vv][0] += p[uu][0];
p[vv][1] += p[uu][1] + 1;
p[uu][0] = p[uu][1] = 0;
}
}
int ans = 0;
for (i = 1; i <= N; i++) {
if (p[i][0] <= p[i][1]) continue;
ans++;
}
printf("%d\n", ans);
return 0;
}
|
#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, a, b; i < m; ++i) {
scanf("%d %d", &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_front(t);
}
con[t].erase(cur);
}
con[cur].clear();
}
ans += (not cycled);
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6;
vector<int> g[N];
bool was[N];
bool marked[N];
bool dfs(int i, int p = -1) {
was[i] = true;
bool lel = false;
for (auto x : g[i]) {
if (x != p) {
if (was[x])
return true;
else
lel = lel || dfs(x, i);
}
}
return lel;
}
void mark(int i, int p = -1) {
marked[i] = true;
for (auto x : g[i]) {
if (x == p) continue;
if (!marked[x]) mark(x, i);
}
}
int main() {
::ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
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);
}
int ans = 0;
for (int i = 0; i < n; ++i) {
if (marked[i]) continue;
bool k = dfs(i, -1);
if (k == false) ++ans;
mark(i);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, nr, nrmuchi, ans;
vector<int> v[100001];
int vizitat[100001];
void dfs(int nod) {
vizitat[nod] = 1;
nr++;
for (int i = 0; i < v[nod].size(); ++i) {
nrmuchi++;
if (!vizitat[v[nod][i]]) {
vizitat[v[nod][i]] = 1;
int x = v[nod][i];
dfs(x);
}
}
}
int main() {
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);
}
for (int i = 1; i <= n; ++i) {
nr = 0;
nrmuchi = 0;
if (!vizitat[i]) {
dfs(i);
if (nr > nrmuchi / 2) ++ans;
}
}
cout << ans;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.