text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
vector<int> g[100005];
int U[100005], V[100005];
vector<pair<int, int> > nodes;
int m1[100005];
int m2[100005];
int seen[100005];
int id;
bool dfs(int node) {
for (int i = 0; i < int(g[node].size()); i++) {
int ind = g[node][i];
if (m2[ind] == -1) {
m2[ind] = node;
m1[node] = ind;
return true;
}
}
for (int i = 0; i < int(g[node].size()); i++) {
int ind = g[node][i];
if (seen[ind] == id) continue;
int brother = m2[ind];
seen[ind] = id;
m1[node] = ind;
m2[ind] = node;
m1[brother] = -1;
if (dfs(brother)) return true;
m1[node] = -1;
m2[ind] = brother;
m1[brother] = node;
}
return false;
}
int main() {
ios::sync_with_stdio(false);
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(i);
g[v].push_back(i);
U[i] = min(u, v), V[i] = max(u, v);
m2[i] = -1;
}
for (int node = 0; node < n; node++)
nodes.push_back(make_pair(int(g[node].size()), node)), m1[node] = -1;
sort(nodes.begin(), nodes.end());
int ans = 0;
id = 1;
for (int i = 0; i < n; i++, id++)
if (!dfs(nodes[i].second)) ans++;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m;
vector<long long> graph[100005];
long long visited[100005];
void in_edge() {
long long u, v;
for (long long i = 1; i <= m; i++) {
scanf("%lld%lld", &u, &v);
graph[u].push_back(v);
graph[v].push_back(u);
}
}
long long bfs(long long source) {
long long count1 = 0;
visited[source] = 1;
count1++;
deque<long long> q;
long long sum = 0;
q.push_back(source);
while (!q.empty()) {
long long s = q.front();
q.pop_front();
sum += graph[s].size();
for (long long i = 0; i < graph[s].size(); i++) {
long long adj = graph[s][i];
if (visited[adj] == -1) {
count1++;
visited[adj] = 1;
q.push_back(adj);
}
}
}
sum /= 2;
if (sum >= count1) {
return 0;
} else {
return 1;
}
}
int main() {
scanf("%lld", &n);
scanf("%lld", &m);
memset(visited, -1, sizeof visited);
in_edge();
long long sum = 0;
for (long long i = 1; i <= n; i++) {
if (visited[i] == -1) {
sum += bfs(i);
}
}
cout << sum << endl;
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; i < m; ++i) {
int a, b;
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;
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> adj[100005];
int visited[100005];
int dfs(int s, int p) {
visited[s] = 1;
int taa = 1;
for (typeof((adj[s]).begin()) it = (adj[s]).begin(); it != (adj[s]).end();
it++) {
if (!visited[*it])
taa = taa & dfs(*it, s);
else if (*it != p)
return 0;
}
return taa;
}
int main() {
int u, v, i, j, k, V, E;
cin >> V >> E;
for (i = 0; i < E; i++) {
cin >> u >> v;
u--;
v--;
adj[u].push_back(v);
adj[v].push_back(u);
}
for (i = 0; i < V; i++) visited[i] = 0;
int count = 0;
for (i = 0; i < V; i++)
if (!visited[i]) count += dfs(i, -1);
cout << count << 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() {
ios::sync_with_stdio(false);
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;
int z[110001], res, u, v, n, m;
long long pr[110001];
int root(int u) { return pr[u] < 0 ? u : root(pr[u]); }
void merge(int u, int v) {
if ((u = root(u)) == (v = root(v))) {
z[u] = 1;
return;
}
if (pr[u] > pr[v]) swap(u, v);
pr[u] += pr[v];
pr[v] = u;
z[u] = max(z[u], z[v]);
z[v] = max(z[v], z[u]);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int test = 1;
while (test--) {
scanf("%d%d", &n, &m);
for (int i = 0; i <= n; ++i) pr[i] = -1;
for (int i = 1; i <= m; ++i) {
scanf("%d%d", &u, &v);
merge(u, v);
}
int res = 0;
for (int i = 1; i <= n; ++i)
if (pr[i] < 0 && z[i] == 0) res++;
printf("%d\n", res);
}
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;
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 5;
int n, m, lab[MAXN];
bool cyc[MAXN];
int getRoot(int u) {
if (lab[u] < 0) return u;
return lab[u] = getRoot(lab[u]);
}
void merge(int u, int v) {
u = getRoot(u);
v = getRoot(v);
if (u == v) {
cyc[u] = true;
return;
}
if (lab[u] > lab[v]) swap(u, v);
lab[u] += lab[v];
lab[v] = u;
cyc[u] = (cyc[u] || cyc[v]);
}
int main() {
memset(cyc, false, sizeof(cyc));
cin >> n >> m;
for (int i = (1); i <= (n); i++) lab[i] = -1;
while (m--) {
int u, v;
cin >> u >> v;
merge(u, v);
}
int res = 0;
for (int u = (1); u <= (n); u++)
if (lab[u] < 0 && !cyc[u]) res++;
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
vector<vector<long long int> > input(n + 1);
for (int i = 1; i <= m; i++) {
long long int a, b;
cin >> a >> b;
input[a].push_back(b);
input[b].push_back(a);
}
int visited[n + 1];
for (int i = 1; i <= n; i++) visited[i] = false;
long long int ans = 0;
for (int i = 1; i <= n; i++) {
if (visited[i] == true) continue;
long long int vertex = 0, edge = 0;
stack<long long int> dfs;
dfs.push(i);
visited[i] = true;
while (dfs.size()) {
long long int top = dfs.top();
dfs.pop();
vertex++;
edge += input[top].size();
for (int j = 0; j < input[top].size(); j++) {
long long int child = input[top][j];
if (!visited[child]) {
dfs.push(child);
visited[child] = true;
}
}
}
edge = edge / 2;
if (vertex > edge) ans++;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
int n, m, x, y, kq, sl;
vector<int> g[maxn];
bool ok[maxn];
void dfs(int u, int p) {
if (ok[u]) {
sl = 0;
return;
}
ok[u] = true;
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (v == p) continue;
dfs(v, u);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
while (m--) {
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
for (int i = 1; i <= n; i++) {
if (!ok[i]) {
sl = 1;
dfs(i, 0);
kq += sl;
}
}
cout << kq;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:1024000000,1024000000")
const int INF = 0x3f3f3f;
const int MOD = 1e9 + 7;
const int MAXN = 400000;
const double eps = 1e-6;
const double pi = acos(-1.0);
using namespace std;
int n, m, fa[MAXN], vis[MAXN];
int find(int x) {
if (x != fa[x])
return fa[x] = find(fa[x]);
else
return x;
}
int main() {
cin >> n >> m;
for (int i = 0; i <= n; i++) fa[i] = i, vis[i] = 0;
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d%d", &a, &b);
int dx = find(a), dy = find(b);
if (dy == dx)
vis[dx] = 1;
else
fa[dx] = dy;
}
for (int i = 1; i <= n; i++) {
if (vis[i]) vis[find(i)] = 1;
}
int ans = 0;
for (int i = 1; i <= n; i++) {
int x = find(i);
if (vis[x] == 0) {
ans++;
vis[x] = 1;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5;
vector<int> G[MAXN + 7];
bool vis[MAXN + 7];
bool OK = false;
void DFS(int x, int f) {
vis[x] = true;
for (int i = 0; i < G[x].size(); i++) {
if (!vis[G[x][i]])
DFS(G[x][i], x);
else if (vis[G[x][i]] && G[x][i] != f)
OK = true;
}
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d %d", &a, &b);
G[a].push_back(b);
G[b].push_back(a);
}
int ans = 0;
for (int i = 1; i <= n; i++) {
OK = false;
if (!vis[i]) {
DFS(i, 0);
if (!OK) ans++;
}
}
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<int> g[100005];
vector<vector<int>> comps;
vector<int> counts;
bool visited[100005];
void dfs(int curr, bool first) {
visited[curr] = true;
if (first) {
comps.push_back(vector<int>());
counts.push_back(0);
}
comps[comps.size() - 1].push_back(curr);
for (auto u : g[curr]) {
counts[counts.size() - 1]++;
if (!visited[u]) dfs(u, false);
}
}
int main() {
int 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);
}
for (int i = 1; i < n; ++i) {
if (!visited[i]) dfs(i, true);
}
int c = 0;
for (int i = 0; i < comps.size(); ++i) {
if (counts[i] / 2 == comps[i].size() - 1)
c += counts[i] / 2;
else
c += comps[i].size();
}
cout << n - c << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
ostream &operator<<(ostream &os, const vector<T> &);
template <size_t n, class... T>
typename enable_if<(n >= sizeof...(T))>::type _ot(ostream &,
const tuple<T...> &) {}
template <size_t n, class... T>
typename enable_if<(n < sizeof...(T))>::type _ot(ostream &os,
const tuple<T...> &t) {
os << (n == 0 ? "" : " ") << get<n>(t);
_ot<n + 1>(os, t);
}
template <class... T>
ostream &operator<<(ostream &os, const tuple<T...> &t) {
_ot<0>(os, t);
return os;
}
template <class T, class U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
return os << "(" << p.first << ", " << p.second << ") ";
}
template <class T>
ostream &operator<<(ostream &os, const vector<T> &v) {
for (size_t i = 0; i < v.size(); i++)
os << v[i] << (i + 1 == v.size() ? "" : ", ");
return os;
}
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using pii = pair<int, int>;
void fastios() {
ios_base::sync_with_stdio(0);
cin.tie(0);
}
struct UnionFind {
vector<int> par;
int cnt;
UnionFind(int size_) : par(size_, -1), cnt(size_) {}
void unite(int x, int y) {
if ((x = find(x)) != (y = find(y))) {
if (par[y] < par[x]) swap(x, y);
par[x] += par[y];
par[y] = x;
cnt--;
}
}
bool same(int x, int y) { return find(x) == find(y); }
int find(int x) { return par[x] < 0 ? x : par[x] = find(par[x]); }
int size(int x) { return -par[find(x)]; }
int size() { return cnt; }
};
int main() {
int n, m;
while (cin >> n >> m) {
vector<int> u(m), v(m);
UnionFind uf(n);
vector<int> deg(n);
for (int i = 0; i < (int)(m); i++) {
int a, b;
cin >> a >> b;
--a, --b;
uf.unite(a, b);
++deg[a];
++deg[b];
}
int ans = 0;
map<int, vector<int>> comps;
for (int i = 0; i < (int)(n); i++) {
comps[uf.find(i)].emplace_back(i);
}
for (auto &e : comps) {
auto &comp = e.second;
int degsum = 0;
for (int v : comp) {
degsum += deg[v];
}
int E = degsum / 2;
int V = comp.size();
if (E == V - 1) {
++ans;
}
}
cout << ans << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
const double PI = acos(-1.);
const double eps = 1e-9;
int n, m;
set<int> G[100005];
int main() {
int i, j, k, _T;
while (~scanf("%d%d", &n, &m)) {
for (i = 1; i <= n; i++) G[i].clear();
for (i = 0; i < m; i++) {
int u, v;
scanf("%d%d", &u, &v);
G[u].insert(v);
G[v].insert(u);
}
int ans = 0;
queue<int> Q;
for (i = 1; i <= n; i++) {
if (G[i].size() == 0)
ans++;
else if (G[i].size() == 1)
Q.push(i);
}
while (!Q.empty()) {
int u = Q.front();
Q.pop();
if (G[u].size() == 0)
ans++;
else
for (auto v : G[u]) {
G[v].erase(u);
if (G[v].size() == 1) Q.push(v);
}
G[u].clear();
}
cout << ans << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> v[100010];
int vis[100010];
int dfs(int u, int fa) {
if (vis[u]) return 1;
vis[u] = 1;
for (int i = 0; i < v[u].size(); i++) {
int mm = v[u][i];
if (mm == fa) continue;
if (dfs(mm, u)) return 1;
}
return 0;
}
int main() {
int n, m, x, y;
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (!vis[i]) ans += dfs(i, 0) ^ 1;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100000;
bool visited[MAXN];
vector<int> adj[MAXN];
bool is_tree(int start) {
stack<pair<int, int>> q;
q.push(make_pair(start, -1));
while (!q.empty()) {
int cur, parent;
tie(cur, parent) = q.top();
q.pop();
if (visited[cur]) return false;
visited[cur] = true;
for (int a : adj[cur]) {
if (a == parent) continue;
q.push(make_pair(a, cur));
}
}
return true;
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
adj[x - 1].push_back(y - 1);
adj[y - 1].push_back(x - 1);
}
int count = 0;
for (int i = 0; i < n; i++) {
if (visited[i]) continue;
if (is_tree(i)) count++;
}
cout << count;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool mark[100010];
vector<int> graf[100010];
int DFS(int u, int parent) {
mark[u] = true;
for (int i = 0; i < graf[u].size(); i++) {
int v = graf[u][i];
if (v == parent) continue;
if (v != parent && mark[v]) return 1;
if (DFS(v, u) == 1) return 1;
}
return 0;
}
int main() {
int n, m, sol = 0;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d%d", &u, &v);
graf[u].push_back(v);
graf[v].push_back(u);
}
for (int i = 1; i <= n; i++) {
if (!mark[i]) sol += (1 - DFS(i, -1));
}
printf("%d\n", sol);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
set<int> g[100005];
int ja[100005];
int recebeu[100005];
priority_queue<pair<int, pair<int, int> > > pq;
int main() {
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int in, in1;
cin >> in >> in1;
in--, in1--;
g[in].insert(in1);
g[in1].insert(in);
}
for (int i = 0; i < n; i++) {
ja[i] = 0;
recebeu[i] = 0;
pq.push(make_pair(0, make_pair(-(int)g[i].size(), i)));
}
while (!pq.empty()) {
int tam = pq.top().second.first, atual = pq.top().second.second;
pq.pop();
if (ja[atual]) continue;
ja[atual] = 1;
int dequem = -1, qtd = 0;
if (!recebeu[atual]) {
for (set<int>::iterator it = g[atual].begin(); it != g[atual].end();
it++) {
int prox = *it;
if (recebeu[prox]) {
dequem = prox;
qtd = 999999999;
} else if (qtd < g[prox].size()) {
dequem = prox;
qtd = g[prox].size();
}
}
for (set<int>::iterator it = g[atual].begin(); it != g[atual].end();
it++) {
int prox = *it;
g[prox].erase(atual);
if (dequem == prox)
recebeu[atual] = 1;
else
recebeu[prox] = 1;
pq.push(
make_pair(recebeu[prox], make_pair(-(int)g[prox].size(), prox)));
}
} else {
for (set<int>::iterator it = g[atual].begin(); it != g[atual].end();
it++) {
int prox = *it;
g[prox].erase(atual);
recebeu[prox] = 1;
pq.push(
make_pair(recebeu[prox], make_pair(-(int)g[prox].size(), prox)));
}
}
}
int res = 0;
for (int i = 0; i < n; i++) {
if (!recebeu[i]) res++;
}
cout << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, ans, fa[100001];
bool mark[100001];
int find(int x) {
if (x == fa[x]) return x;
return fa[x] = find(fa[x]);
}
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) fa[i] = i;
for (int i = 1; i <= m; i++) {
int x, y;
cin >> x >> y;
int fx = find(x), fy = find(y);
if (fx != fy) {
fa[fx] = fy;
if (mark[fx] || mark[x] || mark[fy] || mark[y])
mark[fx] = mark[x] = mark[fy] = mark[y] = 1;
} else
mark[fx] = mark[x] = mark[fy] = mark[y] = 1;
}
for (int i = 1; i <= n; i++)
if (find(i) == i && !mark[i]) ans++;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000 + 5;
int par[maxn];
int d[maxn];
bool vis[maxn];
int n, m;
struct Edge {
int from, to;
Edge(int from, int to) : from(from), to(to) {}
};
vector<Edge> edges;
vector<int> G[maxn];
void init() {
scanf("%d%d", &n, &m);
for (int i = 0; i <= n; i++) {
G[i].erase(G[i].begin(), G[i].end());
vis[i] = false;
d[i] = 0;
}
edges.erase(edges.begin(), edges.end());
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d%d", &u, &v);
edges.push_back(Edge(u, v));
edges.push_back(Edge(v, u));
int l = edges.size();
G[u].push_back(l - 2);
G[v].push_back(l - 1);
}
}
void solve() {
int res = 0;
for (int i = 1; i <= n; i++) {
if (vis[i] == true) continue;
bool flag = true;
queue<int> que;
que.push(i);
vis[i] = true;
d[i] = 1;
while (!que.empty()) {
int s = que.front();
que.pop();
d[s] = 2;
int cnt = 0;
for (int j = 0; j < G[s].size(); j++) {
Edge x = edges[G[s][j]];
if (d[x.to] >= 1) {
cnt++;
continue;
}
vis[x.to] = true;
que.push(x.to);
d[x.to] = 1;
}
if (cnt >= 2) flag = false;
}
res += flag;
}
printf("%d\n", res);
}
int main() {
init();
solve();
return 0;
}
|
#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);
}
int dfs(vector<long long> *g, bool *v, long long curr, long long p) {
v[curr] = true;
int cycle = 0;
for (long long i = 0; i < g[curr].size(); i++) {
if (v[g[curr][i]]) {
if (g[curr][i] != p) {
cycle = 1;
}
} else {
cycle = dfs(g, v, g[curr][i], curr) || cycle;
}
}
return cycle;
}
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) {
ans += !dfs(g, v, first_unv, -1);
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;
const int N = 100000 + 5;
int n, m;
vector<int> G[N];
int p[N];
bool vis[N];
int find(int x) { return x == p[x] ? x : p[x] = find(p[x]); }
int main() {
cin >> n >> m;
for (int(i) = (0); (i) < (int)(n); (i)++) p[i] = i;
int ans = n;
for (int(i) = (0); (i) < (int)(m); (i)++) {
int a, b;
cin >> a >> b;
--a, --b;
a = find(a);
b = find(b);
if (a == b) {
vis[a] = 1;
} else {
p[a] = b;
--ans;
vis[b] |= vis[a];
}
}
for (int(i) = (0); (i) < (int)(n); (i)++)
if (i == p[i] && vis[i]) --ans;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 123;
const int TMXN = 2e6 + 10;
const int INF = 1e9 + 7;
const long long INFL = 1e18;
const long double EPS = 0.000000000001;
int n, m;
int u, v;
vector<int> g[N];
int ver;
int road;
int used[N];
int ans;
void dfs(int v) {
used[v] = 1;
ver++;
for (int i = 0; i < g[v].size(); i++) {
road++;
int x = g[v][i];
if (!used[x]) {
dfs(x);
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
}
for (int i = 1; i <= n; i++) {
if (!used[i]) {
ver = 0;
road = 0;
dfs(i);
ans += max(0, ver - (road / 2));
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool vis[100005];
vector<int> from[100005];
bool dfs(int x, int last) {
int i;
bool ans = false;
if (vis[x]) return true;
vis[x] = true;
for (i = 0; i < from[x].size(); i++) {
if (from[x][i] != last) ans |= dfs(from[x][i], x);
}
return ans;
}
int main() {
int n, m;
int i, x, y;
int ans = 0;
scanf("%d%d", &n, &m);
for (i = 0; i < m; i++) {
scanf("%d%d", &x, &y);
from[x].push_back(y);
from[y].push_back(x);
}
for (i = 1; i <= n; i++) {
if (!vis[i]) {
if (!dfs(i, -1)) ans++;
}
}
printf("%d", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
long long modpow(long long base, long long exponent, long long modulus) {
if (base == 0 && exponent == 0) return 0;
long long result = 1;
while (exponent > 0) {
if (exponent % 2 == 1) result = (result * base) % modulus;
exponent = exponent >> 1;
base = (base * base) % modulus;
}
return result;
}
int N, M;
vector<int> AdjList[200110];
bool visited[200110];
int e = 0, ans = 0, v = 0;
void dfs(int node) {
visited[node] = true;
v++;
for (int i = 0; i < AdjList[node].size(); i++) {
if (!visited[AdjList[node][i]]) {
dfs(AdjList[node][i]);
}
e++;
}
}
inline void ReadInput(void) {
scanf("%d", &N);
scanf("%d", &M);
for (int i = 1; i <= M; i++) {
int a, b;
scanf("%d", &a);
scanf("%d", &b);
AdjList[a].push_back(b);
AdjList[b].push_back(a);
}
}
inline void solve(void) {
for (int i = 1; i <= N; i++) {
if (!visited[i]) {
e = 0;
v = 0;
dfs(i);
e /= 2;
if (e == v - 1) ans++;
}
}
cout << ans << endl;
}
inline void Refresh(void) {}
int main() {
ReadInput();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long int> vec[100005];
long long int n, m;
long long int vis[100005];
long long int flg = 0;
void solve(long long int id, long long int par) {
vis[id] = 1;
for (long long int i = 0; i < vec[id].size(); ++i) {
long long int v = vec[id][i];
if (vis[v] == -1) {
solve(v, id);
} else {
if (v != par) {
flg = 0;
}
}
}
}
int main() {
std::ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (long long int i = 0; i < m; i++) {
long long int a, b;
cin >> a >> b;
vec[a].push_back(b);
vec[b].push_back(a);
}
memset(vis, -1, sizeof(vis));
long long int ans = 0;
for (long long int i = 0; i < n; i++) {
if (vis[i + 1] == -1) {
flg = 1;
solve(i + 1, -1);
ans += flg;
}
}
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long> b = {}, c = {};
long e;
vector<vector<long>> d = {};
void dfs(long v) {
b[v - 1] = 1;
c.push_back(v);
e++;
for (long i = 1; i <= d[v - 1][0]; i++) {
if (!b[d[v - 1][i] - 1]) {
dfs(d[v - 1][i]);
}
}
}
int main() {
long n, m, a = 0, u, v, f = 0;
cin >> n >> m;
for (long i = 0; i < n; i++) {
b.push_back(0);
d.push_back({0});
}
for (long i = 0; i < m; i++) {
cin >> u >> v;
d[u - 1][0]++;
d[u - 1].push_back(v);
d[v - 1][0]++;
d[v - 1].push_back(u);
}
for (long i = 0; i < n; i++) {
if (!b[i]) {
c = {};
e = 0;
dfs(i + 1);
f = 0;
for (long j = 0; j < e; j++) {
f += d[c[j] - 1][0];
}
if (e - f / 2 > 0) {
a += e - f / 2;
}
}
}
cout << a;
}
|
#include <bits/stdc++.h>
using namespace std;
struct road {
int sta, endd;
bool visited;
};
bool cmp(road a, road b) {
if (a.sta != b.sta)
return a.sta < b.sta;
else
return a.endd < b.endd;
}
road rec[200005];
bool flag[100005];
int bo[100005];
int visnum, m;
bool dfs(int n, int l) {
int stapos;
if (l != -1) {
for (int i = bo[n];; i++) {
if (rec[i].endd == l) {
rec[i].visited = true;
break;
}
}
}
if (flag[n] == true) {
return true;
} else {
visnum++;
flag[n] = true;
}
bool tiana = false;
bool tempb;
for (int i = bo[n];; i++) {
if (rec[i].sta != n || i > m * 2 + 1) return tiana;
if (rec[i].visited == false) {
rec[i].visited = true;
tempb = dfs(rec[i].endd, n);
if (tempb == true) tiana = true;
}
}
return tiana;
}
int main() {
int n, a, b, ans;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d%d", &a, &b);
rec[i * 2].sta = a;
rec[i * 2].endd = b;
rec[i * 2].visited = false;
rec[i * 2 + 1].endd = a;
rec[i * 2 + 1].sta = b;
rec[i * 2 + 1].visited = false;
}
sort(rec, rec + m * 2, cmp);
memset(bo, -1, sizeof(bo));
bo[rec[0].sta] = 0;
int temp = rec[0].sta;
for (int i = 1; i < m * 2; i++) {
if (rec[i].sta != temp) {
bo[rec[i].sta] = i;
temp = rec[i].sta;
}
}
memset(flag, false, sizeof(flag));
visnum = 0;
ans = 0;
for (int i = 1; i <= n; i++) {
if (flag[i] == false) {
if (dfs(i, -1) == false) ans++;
}
if (visnum == n) break;
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> c;
vector<int> vis;
vector<vector<int> > a;
void rec(int fr, int cur) {
if (vis[cur] == 1) return;
int i, to;
vis[cur] = 1;
for (i = 0; i < a[cur].size(); i++) {
to = a[cur][i];
if (to != fr && vis[to] == 1) {
c[to] = 2;
} else if (to != fr) {
rec(cur, to);
if (c[cur] == 2) {
c[to] = 2;
} else if (c[to] == 1 || c[to] == 2)
c[cur] = 1;
else
c[to] = 1;
}
}
}
int main() {
int n, i, j, m, x, y, ans = 0;
cin >> n >> m;
a.resize(n);
c.assign(n, 0);
vis.assign(n, 0);
for (i = 0; i < m; i++) {
cin >> x >> y;
a[x - 1].push_back(y - 1);
a[y - 1].push_back(x - 1);
}
for (i = 0; i < n; i++) {
rec(-1, i);
}
for (i = 0; i < n; i++) {
if (c[i] == 0) ans++;
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int vis[100100];
vector<int> g[100100];
int dfs(int node, int par = 0) {
if (vis[node]) return 0;
vis[node] = 1;
int r = 1;
for (int i = 0; i < g[node].size(); i++) {
int child = g[node][i];
if (child == par) continue;
if (!dfs(child, node)) r = 0;
}
return r;
}
void solve() {
int n, m;
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 s = 0;
for (int a = 1; a <= n; a++) {
if (!vis[a]) s += dfs(a);
}
cout << s << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
while (t--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 100005;
vector<int> V[MAX_N];
bool mark[MAX_N];
int n, m;
int Edge, Verticles;
void DFS(int x) {
mark[x] = true;
Edge += V[x].size();
Verticles++;
for (int i = 0; i < V[x].size(); i++) {
int t = V[x][i];
if (!mark[t]) DFS(t);
}
}
int main() {
scanf("%d %d", &n, &m);
while (m--) {
int u, v;
scanf("%d %d", &u, &v);
V[u].push_back(v);
V[v].push_back(u);
}
int res = 0;
for (int i = 1; i <= n; i++)
if (!mark[i]) {
Edge = Verticles = 0;
DFS(i);
if (2 * Verticles > Edge) ++res;
}
printf("%d", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100009;
vector<vector<int>> tr(N);
bool used[N];
int s = -1;
int dfs(int v, int prv = 0) {
used[v] = true;
for (int u : tr[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);
tr[a].push_back(b);
tr[b].push_back(a);
}
int ans = 0, sum = 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;
vector<int> vec[100010];
int vis[100010];
int n, m;
int ans = 0;
int vis2[100010];
int dfs(int pre, int now) {
if (vis2[now]) return 1;
for (int i = 0; i < vec[now].size(); i++) {
if (vec[now][i] != pre) {
if (vis[vec[now][i]]) {
return 1;
}
vis[vec[now][i]] = 1;
if (dfs(now, vec[now][i])) {
return 1;
}
vis[vec[now][i]] = 0;
}
}
vis2[now] = 1;
return 0;
}
int main() {
memset(vis2, 0, sizeof(vis2));
memset(vis, 0, sizeof(vis));
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d %d", &u, &v);
vec[u].push_back(v);
vec[v].push_back(u);
}
for (int i = 1; i <= n; i++) {
vis[i] = 1;
if (!dfs(0, i)) ans++;
vis[i] = 0;
}
printf("%d", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> graph[10000001];
int vis[1000001], parent[1000001], k = 1, cnt = 0;
void iscycle(int start) {
vis[start] = 1;
for (int i = 0; i < graph[start].size(); i++) {
if (vis[graph[start][i]] == 1 && parent[start] != graph[start][i]) {
k = 0;
} else if (vis[graph[start][i]] == 0) {
parent[graph[start][i]] = start;
iscycle(graph[start][i]);
}
}
}
int main() {
int n, m, a, b;
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> a >> b;
graph[a].push_back(b);
graph[b].push_back(a);
}
for (int i = 1; i <= n; i++) {
if (vis[i] == 0) {
iscycle(i);
if (k == 0) {
k = 1;
} else {
cnt++;
}
}
}
cout << cnt << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, ans, crnt;
vector<int> v[100009];
bool done[100009];
void dfs(int node, int p) {
done[node] = 1;
for (int i = 0; i < v[node].size(); i++) {
int u = v[node][i];
if (done[u] && u != p) {
crnt = 0;
continue;
}
if (u == p) continue;
dfs(u, node);
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
v[a].push_back(b);
v[b].push_back(a);
}
for (int i = 0; i < n; i++) {
crnt = 1;
if (!done[i]) {
dfs(i, i);
ans += crnt;
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > components;
vector<vector<int> > g;
vector<int> component;
vector<int> p, s;
map<int, bool> used;
int get(int x) { return x == p[x] ? x : p[x] = get(p[x]); }
void union_sets(int a, int b) {
int x = get(a);
int y = get(b);
if (x != y) {
if (s[x] < s[y]) {
swap(x, y);
}
p[y] = x;
s[x] += s[y];
}
return;
}
void dfs(int x) {
used[x] = true;
component.push_back(x);
for (auto to : g[x]) {
if (!used[to]) {
dfs(to);
}
}
return;
}
bool flag;
void cyclic(int x, int last) {
used[x] = true;
for (auto to : g[x]) {
if (!used[to]) {
cyclic(to, x);
} else {
if (to != last) {
flag = false;
return;
}
}
}
return;
}
int execute() {
int n, m;
cin >> n >> m;
g.resize(n + 1);
p.resize(n + 1);
s.resize(n + 1);
for (int i = 1; i <= n; i++) {
p[i] = i;
s[i] = 1;
}
for (int i = 1; i <= m; i++) {
int x, y;
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
union_sets(x, y);
}
for (int i = 1; i <= n; i++) {
if (!used[i]) {
component.clear();
dfs(i);
components.push_back(component);
}
}
used.clear();
int cnt = 0;
for (auto xt : components) {
for (auto x : xt) {
if (x == get(x)) {
flag = true;
cyclic(x, x);
cnt += flag;
}
}
}
cout << cnt << endl;
return 0;
}
int TE = true;
bool mTest = false;
int main() {
ios_base::sync_with_stdio(false);
if (mTest) cin >> TE;
while (TE--) {
execute();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long M = 1e9 + 7;
const long long N = 1e5 + 5;
long long parent[N], size[N];
void make_set(long long v) {
parent[v] = v;
size[v] = 1;
}
long long find_set(long long v) {
if (v == parent[v]) return v;
return parent[v] = find_set(parent[v]);
}
void union_sets(long long a, long long b) {
a = find_set(a);
b = find_set(b);
if (a != b) {
if (size[a] < size[b]) swap(a, b);
parent[b] = a;
size[a] += size[b];
}
}
void solve() {
long long n, k;
cin >> n >> k;
vector<vector<long long>> v;
v.resize(n);
for (long long i = 0; i < n; i++) {
make_set(i);
}
for (long long i = 0; i < k; i++) {
long long x, y;
cin >> x >> y;
x--, y--;
union_sets(x, y);
v[x].push_back(y);
v[y].push_back(x);
}
map<long long, long long> m;
for (long long i = 0; i < n; i++) {
m[find_set(i)] += v[i].size();
}
long long ans = 0;
for (auto it : m) {
if (size[it.first] > it.second / 2) ans++;
}
cout << ans << "\n";
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long t = 1;
while (t--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rnd(chrono::high_resolution_clock::now().time_since_epoch().count());
const int N = 1e5 + 7;
vector<int> g[N];
bool used[N];
vector<int> vis;
int cnt = 0;
void dfs(int v) {
if (used[v]) {
return;
}
vis.push_back(v);
used[v] = true;
for (int u : g[v]) {
dfs(u);
cnt++;
}
}
int main() {
ios::sync_with_stdio(0);
cin.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);
}
vector<vector<int> > comp;
int ans = 0;
for (int i = 0; i < n; i++) {
if (!used[i]) {
vis.clear();
cnt = 0;
dfs(i);
comp.push_back(vis);
int sz = 0;
if (comp.empty() == false) {
sz = (int)comp.back().size();
}
cnt /= 2;
if (cnt > sz - 1) {
continue;
}
ans++;
}
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void swap(int *a, int *b) {
int temp = *a;
*a = *b;
*b = temp;
}
long long int power(long long int a, long long int b) {
long long int x = 1;
long long int y = a;
while (b > 0) {
if (b & 1) {
x = x * y;
x %= 1000000007;
}
y = y * y;
y %= 1000000007;
b /= 2;
}
return x;
}
long long int inver(long long int a) { return power(a, 1000000007 - 2); }
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
int n, m;
bool visi[100010];
int dsu[100010];
void pre() {
for (int i = 1; i <= n; i++) {
dsu[i] = i;
}
}
int root(int x) {
while (x != dsu[x]) {
dsu[x] = dsu[dsu[x]];
x = dsu[x];
}
return x;
}
int main() {
scanf("%d%d", &n, &m);
pre();
vector<int> ci;
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d%d", &x, &y);
int root_x = root(x);
int root_y = root(y);
if (root_x == root_y) {
visi[root_x] = true;
ci.push_back(root_x);
} else {
dsu[root_x] = root_y;
}
}
for (int i = 0; i < ci.size(); i++) {
visi[root(ci[i])] = true;
}
int ans = 0;
for (int i = 1; i <= n; i++) {
int root_x = root(i);
if (visi[i] == true) {
visi[root_x] = true;
}
if (visi[root_x] == false) {
ans++;
visi[root_x] = true;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-15;
const double Max = 1e+18;
inline void normal(long long& a) {
a %= 1000000007;
(a < 0) && (a += 1000000007);
}
inline long long mul(long long a, long long b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
return (a * b) % 1000000007;
}
inline long long add(long long a, long long b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
return (a + b) % 1000000007;
}
inline long long sub(long long a, long long b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
a -= b;
normal(a);
return a;
}
int val[100100], visited[100010];
vector<int> G[100010];
bool dfs(int idx, int par) {
visited[idx] = 1;
long long i, n = G[idx].size();
bool ans = false;
for (i = 0; i < n; i++) {
if (visited[G[idx][i]] && G[idx][i] != par) ans = true;
if (!visited[G[idx][i]]) ans = ans | dfs(G[idx][i], idx);
}
return ans;
}
int main() {
ios::sync_with_stdio(false);
long long n, m, i, j, k;
cin >> n >> m;
for (i = 0; i < m; i++) {
cin >> j >> k;
G[j].push_back(k);
G[k].push_back(j);
}
long long ans = 0;
for (i = 1; i <= n; i++) {
if (!visited[i]) {
if (!dfs(i, -1)) ans++;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> v[100001];
vector<int> par(100001);
int ans = 0;
bool dfs(int src, bool visited[]) {
visited[src] = true;
bool flag = false;
int j;
for (j = 0; j < v[src].size(); j++) {
if (visited[v[src][j]] == false) {
par[v[src][j]] = src;
bool curr = dfs(v[src][j], visited);
flag = flag || curr;
} else if (v[src][j] != par[src]) {
flag = true;
}
}
return flag;
}
int main() {
int n, m;
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);
}
bool visited[n + 1];
memset(visited, false, sizeof(visited));
for (int i = 1; i <= n; i++) {
if (visited[i] == false) {
par[i] = -1;
bool x = dfs(i, visited);
if (!x) {
ans++;
}
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool isPrime(int n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
vector<vector<int>> v;
vector<int> vis;
int cyc = 0;
void dfs(int node, int par) {
vis[node] = 1;
for (auto x : v[node]) {
if (x == par) continue;
if (!vis[x])
dfs(x, node);
else {
cyc = 1;
return;
}
}
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
int n, m, ans = 0;
cin >> n >> m;
v.resize(n + 1);
vis.resize(n + 1, 0);
for (int i = 0; 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 (!vis[i]) {
dfs(i, 0);
ans += cyc == 0;
cyc = 0;
}
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1000000007LL;
const double EPS = 1e-14;
const long long inf_ll = (long long)1e18;
const long long maxn = 100005LL;
const long long maxm = 100005LL;
const long long mod = 1000000007LL;
struct Graph {
struct edge {
int u, v, nxt;
edge(int nu = 0, int nv = 0, int nnxt = 0) : u(nu), v(nv), nxt(nnxt) {}
} E[maxm * 2];
int cnt, head[maxn];
inline void link(int u, int v) {
E[++cnt] = edge(u, v, head[u]);
head[u] = cnt;
E[++cnt] = edge(v, u, head[v]);
head[v] = cnt;
}
} G;
int n, m;
int vis[maxn];
int ans;
int dfs(int u, int p) {
vis[u] = 1;
for (register int(i) = G.head[u], (v) = G.E[i].v; (i);
(i) = G.E[i].nxt, (v) = G.E[i].v) {
if (v != p && vis[v]) return 1;
if (v == p) continue;
if (dfs(v, u)) return 1;
}
return 0;
}
int main() {
scanf("%d%d", &n, &m);
for (register int(i) = (1); (i) <= (m); ++i) {
int u, v;
scanf("%d%d", &u, &v);
G.link(u, v);
}
for (register int(i) = (1); (i) <= (n); ++i)
if (!vis[i] && !dfs(i, 0)) ++ans;
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1001001;
int n, m;
long long int j = 1;
int arr[N];
long long a, b, c;
vector<int> nodes1[N];
vector<int> nodes2[N];
map<int, int> mp;
queue<int> q;
queue<set<int> > q1;
bool visited1[N];
bool visited2[N];
char w[N];
int ans1, ans2;
int arr1[N], arr2[N];
string s, s1, s2;
int k;
int max11 = -1;
long long p = 1;
set<int> l;
vector<int> ll[11];
int sum = 0;
int path = 0;
int visited[N];
int mod = 1e9 + 7;
int color;
int path1, path2;
bool flag = true;
int skewers = 0;
int mask;
int points[N];
int files[N];
long long min11 = 100000000000;
string str;
int freq[N];
void dfs(int node) {
visited1[node] = true;
ans1++;
for (int i = 0; i < nodes1[node].size(); i++) {
ans2++;
if (visited1[nodes1[node][i]] == false) dfs(nodes1[node][i]);
}
}
int main() {
scanf("%d%d", &a, &b);
for (int i = 0; i < b; i++) {
scanf("%d%d", &n, &m);
nodes1[n].push_back(m);
nodes1[m].push_back(n);
}
for (int i = 1; i <= a; i++) {
if (visited1[i] == false) {
dfs(i);
sum += (ans1 == ans2 / 2 + 1);
ans1 = 0;
ans2 = 0;
}
}
cout << sum << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long dx[] = {-1, -1, -1, 0, 1, 1, 1, 0};
const long long dy[] = {-1, 0, 1, 1, 1, 0, -1, -1};
class DSU {
public:
vector<long long> parent;
DSU(long long n) {
parent.resize(n);
for (long long i = 0; i < n; i++) {
parent[i] = i;
}
}
bool unite(long long x, long long y) {
long long px = find(x);
long long py = find(y);
if (px == py) {
return true;
}
parent[px] = py;
return false;
}
long long find(long long x) {
if (x == parent[x]) {
return x;
} else {
return parent[x] = find(parent[x]);
}
}
};
vector<long long> edge[100005];
bool vis[100005];
set<pair<long long, long long>> nodes;
void dfs(long long node) {
if (vis[node]) {
return;
}
vis[node] = 1;
for (auto x : edge[node]) {
long long aa, bb;
aa = x;
bb = node;
if (aa > bb) {
swap(aa, bb);
}
nodes.insert({aa, bb});
if (!vis[x]) {
dfs(x);
}
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long test = 1;
while (test--) {
long long n;
cin >> n;
long long m;
cin >> m;
long long ans = 0;
for (long long i = 0; i < m; i++) {
long long x, y;
cin >> x >> y;
x--;
y--;
edge[x].push_back(y);
edge[y].push_back(x);
}
DSU dsu(2 * n + 100);
for (long long i = 0; i < n; i++) {
if (!vis[i]) {
nodes.clear();
dfs(i);
long long cnt = 1;
for (auto x : nodes) {
if (dsu.unite(x.first, x.second)) {
cnt = 0;
break;
}
}
ans += cnt;
}
}
cout << ans << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename Head>
inline void dout(Head in) {
cerr << in << '\n';
}
int main() {
ios::sync_with_stdio(false), cin.tie(NULL);
int n, m;
cin >> n >> m;
vector<vector<int>> adj(n);
for (int i = 0; i < m; i++) {
int v, u;
cin >> v >> u;
v--;
u--;
adj[v].emplace_back(u);
adj[u].emplace_back(v);
}
int nodes;
long long edges;
vector<bool> mark(n, false);
function<void(int)> dfs = [&](int v) {
mark[v] = true;
nodes++;
edges += adj[v].size();
for (int e : adj[v]) {
if (!mark[e]) {
dfs(e);
}
}
};
int ans = 0;
for (int i = 0; i < n; i++) {
if (!mark[i]) {
edges = 0;
nodes = 0;
dfs(i);
if (nodes > (edges >> 1)) {
ans++;
}
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void dfs(int i, vector<vector<int>> &graph, bool &flag, int parent,
vector<bool> &visited) {
int sz = graph[i].size();
for (int j = 0; j < sz; j++) {
if (graph[i][j] != parent) {
if (visited[graph[i][j]])
flag = true;
else {
visited[graph[i][j]] = true;
dfs(graph[i][j], graph, flag, i, visited);
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m, a, b;
cin >> n >> m;
vector<vector<int>> graph(n + 1);
for (int i = 0; i < m; i++) {
cin >> a >> b;
graph[a].push_back(b);
graph[b].push_back(a);
}
long long ans = 0;
vector<bool> visited(n + 1, false);
for (int f = 1; f <= n; f++) {
if (graph[f].size() == 0) {
ans++;
continue;
}
if (!visited[f]) {
bool flag = false;
dfs(f, graph, flag, -1, visited);
if (!flag) ans++;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int maxn = 0;
vector<long long> mprime;
vector<long long> arr, brr;
class BitDicTree {
private:
vector<int> vp;
vector<vector<int>> cp;
public:
BitDicTree() {
cp.push_back(vector<int>(2, -1));
vp.push_back(0);
}
void add(int x) {
int pos = 0;
for (int i = 31; i >= 0; i--) {
int c = (x >> i) & 1;
if (cp[pos][c] == -1) {
cp.push_back(vector<int>(2, -1));
vp.push_back(0);
cp[pos][c] = vp.size() - 1;
}
vp[cp[pos][c]] += 1;
pos = cp[pos][c];
}
}
void remove(int x) {
int pos = 0;
for (int i = 31; i >= 0; i--) {
int c = (x >> i) & 1;
vp[cp[pos][c]] -= 1;
pos = cp[pos][c];
}
}
int query(int x) {
int pos = 0;
int ans = 0;
for (int i = 31; i >= 0; i--) {
int c = ((x >> i) & 1);
if (cp[pos][1 - c] != -1 && vp[cp[pos][1 - c]] > 0) {
ans += (1 << i);
pos = cp[pos][1 - c];
} else
pos = cp[pos][c];
}
return ans;
}
};
class UF {
public:
vector<long long> tree;
int nodes;
UF(int n) {
nodes = n;
tree = vector<long long>(n);
iota(begin(tree), end(tree), 0);
}
int find(int st) {
if (tree[st] != st) tree[st] = find(tree[st]);
return tree[st];
}
bool connect(int a, int b) {
int ua = find(a);
int ub = find(b);
if (ua != ub) {
tree[ua] = ub;
nodes -= 1;
}
return ua != ub;
}
int query() { return nodes; }
};
class Math {
public:
vector<long long> fac, inv;
int MOD;
Math(int n, int mod) {
MOD = mod;
fac = vector<long long>(n);
inv = vector<long long>(n);
fac[0] = 1;
for (int i = 1; i < n; i++) {
fac[i] = fac[i - 1] * i % MOD;
}
inv[n - 1] = QPow(fac[n - 1], MOD - 2);
for (int i = n - 2; i >= 0; i--) {
inv[i] = inv[i + 1] * (i + 1) % MOD;
}
}
long long comb(int n, int m) {
return ((fac[n] * inv[m]) % MOD * inv[n - m]) % MOD;
}
long long arrang(int n, int m) { return fac[n] * inv[n - m] % MOD; }
long long QPow(long long x, long long n) {
long long ret = 1;
long long tmp = x % MOD;
while (n) {
if (n & 1) {
ret = (ret * tmp) % MOD;
}
tmp = tmp * tmp % MOD;
n >>= 1;
}
return ret;
}
};
unsigned euler(unsigned x) {
unsigned i, res = x;
for (i = 2; i < (int)sqrt(x * 1.0) + 1; i++) {
if (!(x % i)) {
res = res / i * (i - 1);
while (!(x % i)) {
x /= i;
}
}
}
if (x > 1) {
res = res / x * (x - 1);
}
return res;
}
void mprime_init() {
mprime = vector<long long>(maxn, -1);
for (int i = 2; i < maxn; i++) {
if (mprime[i] == -1) {
mprime[i] = i;
for (int j = 2 * i; j < maxn; j += i) {
if (mprime[j] == -1) mprime[j] = i;
}
}
}
}
void solve() {
int n, m;
cin >> n >> m;
UF uf(n + 1);
vector<pair<int, int>> es;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
es.push_back({a, b});
uf.connect(a, b);
}
vector<int> cnt(n + 1, 0);
vector<int> ec(n + 1, 0);
for (int i = 1; i <= n; i++) {
cnt[uf.find(i)] += 1;
}
for (int i = 0; i < m; i++) {
ec[uf.find(es[i].first)] += 1;
}
int ans = 0;
for (int i = 0; i <= n; i++) {
if (cnt[i] == ec[i] + 1) {
ans += 1;
}
}
cout << ans << endl;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(nullptr);
cout.tie(nullptr);
cout.precision(10);
cout << fixed;
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> v[100001];
int vis[100001], edg = 0, ver = 0;
void dfs(int i) {
vis[i] = 1;
ver += v[i].size();
edg++;
for (auto j : v[i]) {
if (!vis[j]) dfs(j);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
edg = 0;
ver = 0;
dfs(i);
if (ver / 2 == edg - 1) ans++;
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m;
vector<long long> graph[100005];
long long parent[100005];
void cle() { memset(parent, -1, sizeof parent); }
void in_edge() {
long long u, v;
for (long long i = 1; i <= m; i++) {
scanf("%lld%lld", &u, &v);
graph[u].push_back(v);
graph[v].push_back(u);
}
}
long long bfs(long long source) {
parent[source] = source;
deque<long long> q;
q.push_back(source);
bool flag = 0;
while (!q.empty()) {
long long s = q.front();
q.pop_front();
for (long long i = 0; i < graph[s].size(); i++) {
long long adj = graph[s][i];
if (parent[adj] == -1) {
parent[adj] = s;
q.push_back(adj);
} else if (parent[adj] != -1) {
if (parent[s] != adj) {
flag = 1;
}
}
}
}
if (flag == 1) {
return 0;
} else {
return 1;
}
}
int main() {
scanf("%lld", &n);
scanf("%lld", &m);
cle();
in_edge();
long long sum = 0;
for (long long i = 1; i <= n; i++) {
if (parent[i] == -1) {
sum += bfs(i);
}
}
cout << sum << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool visited[100010];
list<long long int> l[100010];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
memset(visited, 0, sizeof(visited));
long long int n, m;
cin >> n >> m;
long long int i, x, y, ans = 0;
for (i = 0; i < m; i++) {
cin >> x >> y;
x--;
y--;
l[x].push_back(y);
l[y].push_back(x);
}
bool cycle;
for (i = 0; i < n; i++) {
if (visited[i]) continue;
pair<long long int, long long int> p1, p2;
stack<pair<long long int, long long int> > s;
s.push(make_pair(i, -1ll));
cycle = 0;
while (!s.empty()) {
p1 = s.top();
s.pop();
if (!visited[p1.first]) {
visited[p1.first] = 1;
list<long long int>::iterator it;
for (it = l[p1.first].begin(); it != l[p1.first].end(); it++) {
if (visited[*it]) {
if (*it != p1.second) {
cycle = 1;
}
} else {
s.push(make_pair(*it, p1.first));
}
}
}
}
if (!cycle) 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 loop = 0;
void dfs(int i, int parent1) {
if (b[i] == true) {
loop++;
return;
}
b[i] = true;
for (int j = 0; j < x[i].size(); j++) {
if (x[i][j] != parent1) 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, i);
if (loop > 0) {
loop = 0;
} else
count++;
}
}
cout << count;
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;
const int MAX_N = 100001;
const long long MOD = 1000000007;
const long long INF = 1e18;
int par[MAX_N], ans[MAX_N], sz[MAX_N];
int rt(int v) { return ((par[v] == v) ? (v) : (par[v] = rt(par[v]))); }
void join(int u, int v) {
ans[rt(v)]++;
if ((u = rt(u)) != (v = rt(v))) par[u] = v, ans[v] += ans[u], sz[v] += sz[u];
}
int n, m;
bitset<MAX_N> vis;
int main(int argc, const char* argv[]) {
ios_base::sync_with_stdio(0), cin.tie(0);
cin >> n >> m;
for (int i = (0); i < (n); i++) par[i] = i, sz[i] = 1;
for (int i = (0); i < (m); i++) {
int a, b;
cin >> a >> b;
a--, b--;
join(a, b);
}
int num = 0;
for (int i = (0); i < (n); i++) {
if (vis[rt(i)]) continue;
vis[rt(i)] = 1;
num += max(sz[rt(i)] - ans[rt(i)], 0);
}
cout << num << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<int> g[100005];
bool tk[100005];
vector<int> vis;
void dfs(int i) {
if (tk[i]) return;
vis.push_back(i);
tk[i] = true;
int ans = 0;
for (int j = 0; j < g[i].size(); j++) {
dfs(g[i][j]);
}
}
int solve() {
memset(tk, 0, sizeof(tk));
int res = 0;
for (int i = 0; i < n; i++) {
if (!tk[i]) {
vis.clear();
dfs(i);
int v = vis.size();
int e = 0;
for (int j = 0; j < vis.size(); j++) {
e += g[vis[j]].size();
}
e /= 2;
if (e < v) res++;
}
}
return res;
}
int main() {
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);
}
printf("%d\n", solve());
}
|
#include <bits/stdc++.h>
using namespace std;
struct dsu {
long p, vrt, edge;
};
vector<dsu> v;
long find_set(long x) {
if (v[x].p == x)
return x;
else
return (v[x].p = find_set(v[x].p));
}
void union_set(long &a, long &b) {
long x, y;
x = find_set(a);
y = find_set(b);
v[x].p = y;
v[y].vrt += v[x].vrt;
v[y].edge += v[x].edge + 1;
}
int main() {
long n, m, a, b;
cin >> n >> m;
for (long i = 0; i <= n; ++i) v.push_back({i, 1, 0});
for (long i = 0; i < m; ++i) {
cin >> a >> b;
if (find_set(a) == find_set(b))
++v[find_set(a)].edge;
else
union_set(a, b);
}
long long ans = 0;
for (long i = 1; i <= n; ++i)
if (v[i].p == i) {
if (v[i].edge < v[i].vrt) ++ans;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 2000000000;
const int N = 100005;
bool use[N];
vector<int> g[N];
bool dfs(int v, int pr = -1) {
use[v] = true;
for (int i = 0; i < g[v].size(); i++) {
int to = g[v][i];
if (to == pr) continue;
if (!use[to]) {
if (dfs(to, v)) return true;
} else {
return true;
}
}
return false;
}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
int n, m;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int q, w;
cin >> q >> w;
g[q].push_back(w);
g[w].push_back(q);
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (!use[i]) {
if (!dfs(i)) ans++;
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
long long l, r, n, m, k, s, ans, ln, w, h, T, TT, x[1000001], y[1000001];
bool tt[1000001], ttt;
vector<long long> c[200001];
template <typename BRUH>
inline BRUH sqr(BRUH x) {
return x * x;
}
long long binpow(long long h, long long r) {
long long l = 1;
while (r) {
if (r & 1) l *= h, l %= MOD;
h *= h;
h %= MOD;
r /= 2;
}
return l;
}
void dfs(int h) {
T++;
tt[h] = 1;
TT += c[h].size();
for (int i = 0; i < c[h].size(); i++)
if (!tt[c[h][i]]) {
dfs(c[h][i]);
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = 0; i < m; i++) {
long long x, y;
cin >> x >> y;
c[x].push_back(y);
c[y].push_back(x);
}
long long ans = 0;
for (int i = 1; i <= n; i++)
if (!tt[i]) {
T = 0;
TT = 0;
dfs(i);
ans += max(T - TT / 2, 0ll);
}
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;
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;
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++;
}
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 (v == tmp) continue;
if (used[v] == 0) {
used[v] = u;
tmp = u;
dfs(v);
} else if (used[u] != v) {
thien = 0;
used[v] = 1e9;
}
}
}
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>
#pragma comment(linker, "/stack:64000000")
using namespace std;
const double PI = 2 * acos(0.0);
const double eps = 1e-9;
template <class T>
T jog(T a, T b) {
return a + b;
}
template <class T>
T bog(T a, T b) {
return a - b;
}
template <class T>
T gon(T a, T b) {
return a * b;
}
template <class T>
T sq(T x) {
return x * x;
}
template <class T>
T gcd(T a, T b) {
return b == 0 ? a : gcd(b, a % b);
}
template <class T>
T lcm(T a, T b) {
return (a / gcd(a, b)) * b;
}
template <class T>
T power(T a, T p) {
T res = 1, x = a;
while (p) {
if (p & 1) res = res * x;
x = x * x;
p >>= 1;
}
return res;
}
template <class T>
T cordinatlenth(T a, T b, T c, T d) {
return sqrt(sq(a - c) + sq(b - d));
}
template <class T>
string toString(T n) {
ostringstream oss;
oss << n;
oss.flush();
return oss.str();
}
int toInt(string s) {
int r = 0;
istringstream sin(s);
sin >> r;
return r;
}
long long bigmod(long long a, long long p, long long mod) {
long long res = 1, x = a;
while (p) {
if (p & 1) res = (res * x) % mod;
x = (x * x) % mod;
p >>= 1;
}
return res;
}
int diraction1[] = {-1, 0, 0, 1, 1, -1, -1, 1};
int diraction2[] = {0, -1, 1, 0, 1, -1, 1, -1};
int horsed1[] = {-2, -2, -1, 1, 2, 2, 1, -1};
int horsed2[] = {1, -1, -2, -2, -1, 1, 2, 2};
void Input();
const int INF = 2147483647;
const long long LINF = 9223372036854775807ll;
void DFs(int u);
int n, m, ans, fl, par[100010], nw[100010];
vector<vector<int> > graph;
bool mark[100010], ck[100010], mr[100010];
vector<int> vv;
int main() {
Input();
return 0;
}
void Input() {
cin >> n >> m;
graph.assign(n + 5, vector<int>());
for (int i = 0, a, b; i < m; i++) {
scanf("%d %d", &a, &b);
graph[a].push_back(b);
graph[b].push_back(a);
ck[a] = ck[b] = true;
}
memset(par, -1, sizeof(par));
memset(nw, 0, sizeof(nw));
memset(mark, false, sizeof(mark));
for (int i = 1; i <= n; i++) {
if (!ck[i]) {
ans++;
continue;
}
if (mark[i]) continue;
fl = 1;
mr[i] = true;
DFs(i);
ans += fl;
}
cout << ans << endl;
}
void DFs(int u) {
mark[u] = true;
nw[u] = 1;
for (int i = 0; i < graph[u].size(); i++) {
int v = graph[u][i];
if (par[u] != v && (nw[v] == 2 || nw[v] == 3)) fl = 0;
if (mr[v] || par[u] == v || nw[v] >= 2) continue;
par[v] = u;
mr[v] = true;
nw[u] = 2;
DFs(v);
par[v] = -1;
}
nw[u] = 3;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 500009;
const int mod = 1000000007;
int n, m, x, y;
vector<int> v[N];
vector<bool> vis;
bool is;
void pre() { vis.assign(N, 0); }
void dfs(int ver, 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() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin.exceptions(cin.failbit);
;
pre();
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
int ans = 0;
for (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;
bool visited[100005] = {false};
bool isTree(int root, int parent, vector<int> adjlist[]) {
if (visited[root]) return false;
if (adjlist[root].empty()) {
visited[root] = true;
return true;
}
bool res = true;
visited[root] = true;
for (int i = 0; i < adjlist[root].size() && res; i++) {
int v = adjlist[root][i];
if (v != parent) res = isTree(v, root, adjlist);
}
return res;
}
int main() {
int m, n, u, v, t, res = 0;
cin >> n >> m;
vector<int> adjlist[n + 1];
for (int i = 0; i < m; i++) {
cin >> u >> v;
adjlist[u].push_back(v);
adjlist[v].push_back(u);
}
for (int i = 1; i <= n; i++) {
if (!visited[i]) {
if (isTree(i, -1, adjlist)) res++;
}
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n, m, a, b, vis[N], r, e, res;
set<int> g[N];
void dfs(int v) {
vis[v] = 1;
r++;
e += g[v].size();
for (auto i : g[v])
if (!vis[i]) dfs(i);
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> a >> b;
g[a].insert(b);
g[b].insert(a);
}
for (int i = 1; i <= n; i++)
if (!vis[i]) {
r = e = 0;
dfs(i);
if (r == e / 2 + 1) res++;
}
cout << res;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
const int maxn = 200005;
vector<int> V[maxn];
map<long long, int> mp;
void init() {
mp.clear();
for (int i = 0; i < maxn; i++) V[i].clear();
}
int u[maxn];
int n, m;
int q[maxn];
int doit(int x, int pa) {
if (u[x]) return false;
u[x] = 1;
int len = V[x].size();
bool re = true;
for (int i = 0; i < len; i++) {
int now = V[x][i];
if (pa == now) continue;
re = re & doit(now, x);
}
return re;
}
int main() {
while (cin >> n >> m) {
init();
memset(u, 0, sizeof(u));
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);
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (u[i] == 0) ans += doit(i, 0);
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> V[100001];
bool visited[100001];
long long nodes, edges;
void dfs(long long x) {
visited[x] = 1;
nodes++;
long long i;
for (i = 0; i < V[x].size(); i++) {
edges++;
if (!visited[V[x][i]]) {
dfs(V[x][i]);
}
}
}
long long Power(long long a, long long b) {
long long result = 1;
while (b) {
if (b % 2) {
result = (result * a) % 1000000007;
}
b = b >> 1;
a = (a * a) % 1000000007;
}
return result;
}
int main() {
std::ios_base::sync_with_stdio(false);
long long N, M, i;
cin >> N >> M;
while (M--) {
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 + 1; i++) {
if (!visited[i]) {
nodes = 0;
edges = 0;
dfs(i);
if (nodes - 1 == edges / 2) {
cnt++;
}
}
}
cout << cnt;
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;
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;
std::vector<int> adj[200000];
bool visited[200000];
int dfs(int v, int parent) {
visited[v] = 1;
int cycle = 0;
for (auto it : adj[v]) {
if (visited[it] == true && it != parent) {
cycle = 1;
}
if (!visited[it]) {
if (dfs(it, v)) {
cycle = 1;
}
}
}
return cycle;
}
void dfs_helper(int n) {
int ans = 0;
for (int i = 1; i <= n; i++) {
if (visited[i] == false) {
if (!dfs(i, -1)) {
ans += 1;
}
}
}
cout << ans;
}
int main() {
int n, m, u, v;
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
dfs_helper(n);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 112345;
vector<int> v[N];
bool used[N];
bool ok = 0;
void dfs(int x, int p) {
used[x] = 1;
for (int i = 0; i < v[x].size(); i++) {
int to = v[x][i];
if (!used[to]) {
dfs(to, x);
} else {
if (to != p && p != -1) {
ok = 1;
}
}
}
}
int main() {
int n, m, i, j, x, y;
cin >> n >> m;
for (i = 1; i <= m; i++) {
scanf("%d %d", &x, &y);
v[x].push_back(y);
v[y].push_back(x);
}
int cnt = 0;
for (i = 1; i <= n; i++) {
if (!used[i]) {
ok = 0;
dfs(i, -1);
if (!ok) cnt++;
}
}
cout << cnt;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 5;
const int MAXM = 1e5 + 5;
int n, m;
pair<int, int> road[MAXM];
int vis[MAXN];
int cc_cnt;
int cc_ecnt[MAXN];
int cc_vcnt[MAXN];
vector<int> G[MAXN];
int ex[MAXM];
void dfs(int u) {
vis[u] = 1;
++cc_vcnt[cc_cnt];
cc_ecnt[cc_cnt] += ex[u];
for (int v : G[u])
if (!vis[v]) dfs(v);
}
void solve() {
for (int i = 0; i < m; ++i) {
G[road[i].first].push_back(road[i].second),
G[road[i].second].push_back(road[i].first);
++ex[road[i].first];
++ex[road[i].second];
}
for (int i = 1; i <= n; ++i) {
if (vis[i]) continue;
++cc_cnt;
dfs(i);
cc_ecnt[cc_cnt] /= 2;
}
int ans = 0;
for (int i = 1; i <= cc_cnt; ++i) {
if (cc_ecnt[i] < cc_vcnt[i]) ans += cc_vcnt[i] - cc_ecnt[i];
}
cout << ans << "\n";
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> m;
for (int i = 0; i < m; ++i) cin >> road[i].first >> road[i].second;
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> v[100001], a1(100001), vis(100001);
int e, ans = 0;
void dfs(int st, int par) {
vis[st] = 1;
for (auto x : v[st]) {
if (!vis[x]) {
dfs(x, st);
} else if (x != par) {
e = 0;
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
for (long long int i = 0; 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++) {
e = 1;
if (!vis[i]) {
dfs(i, -1);
ans += e;
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
bool visited[100005];
vector<long long> mp[100005];
long long res = 0;
long long ans = 0;
const long long U = 1e8 + 7;
void dfs(long long second) {
visited[second] = true;
ans++;
for (int i = 0; i < mp[second].size(); i++) {
res++;
if (visited[mp[second][i]] == false) {
dfs(mp[second][i]);
}
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n, m;
cin >> n >> m;
memset(visited, false, sizeof visited);
for (int i = 0; i < m; i++) {
long long a, b;
cin >> a >> b;
mp[a].push_back(b);
mp[b].push_back(a);
}
long long x = 0;
for (int i = 0; i < n; i++) {
if (visited[i] == false) {
res = 0;
ans = 0;
dfs(i);
res = res / 2;
if (res == ans - 1) x++;
}
}
cout << x - 1;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[100005];
void addEdge(int x, int y) {
adj[x].push_back(y);
adj[y].push_back(x);
}
bool visited[100005] = {false};
bool currentcycle[100005] = {false};
bool iscycle = false;
void dfs(int node, int parent) {
visited[node] = true;
currentcycle[node] = true;
for (int i = 0; i < adj[node].size(); i++) {
if (adj[node][i] != parent) {
if (visited[adj[node][i]] == false) {
dfs(adj[node][i], node);
} else {
if (currentcycle[adj[node][i]] == true) {
iscycle = true;
}
}
}
}
currentcycle[node] = false;
}
int main() {
int answer = 0;
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
addEdge(x, y);
}
for (int i = 1; i <= n; i++) {
if (visited[i] == false) {
dfs(i, -1);
if (iscycle == false) answer += 1;
}
iscycle = false;
}
cout << answer;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
const int MOD = 1e9 + 7;
const int N = 3e5 + 10;
int n, deg[N], v[N][2], mark[N];
vector<int> e[N];
queue<int> q;
void prepare() {
int m, x, y;
scanf("%d%d", &n, &m);
for (auto i = (1); i <= (m); i++) {
scanf("%d%d", &x, &y);
v[i][0] = x;
v[i][1] = y;
e[x].push_back(i);
e[y].push_back(i);
deg[x]++, deg[y]++;
}
}
int solve() {
for (auto i = (1); i <= (n); i++)
if (deg[i] == 1) q.push(i);
int ans = 0;
for (auto i = (1); i <= (n); i++)
if (!deg[i]) ans++;
while (!q.empty()) {
int x = q.front();
q.pop();
if (deg[x] == 0) ans++;
for (auto i : e[x])
if (!mark[i]) {
mark[i] = 1;
for (auto j = (0); j <= (1); j++) {
int y = v[i][j];
deg[y]--;
if (deg[y] == 1) q.push(y);
}
}
}
return ans;
}
int main() {
prepare();
cout << solve();
}
|
#include <bits/stdc++.h>
using namespace std;
long long zero = 0;
long long one = 1;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return (a / gcd(a, b) * b); }
long long expo(long long x, long long y) {
long long res = 1;
x = x % 1000000007;
while (y > 0) {
if (y & 1) res = (1ll * res * x) % 1000000007;
y = y >> 1;
x = (1ll * x * x) % 1000000007;
}
return res;
}
long long ncr(long long n, long long r) {
long long res = 1;
if (r > n - r) r = n - r;
for (long long i = 0; i < r; i++) {
res *= n - i;
res /= i + 1;
}
return res;
}
long long max(long long a, long long b) { return (a > b) ? a : b; }
bool prime(long long n) {
long long i;
for (i = 2; i <= sqrt(n); i++) {
if (n % i == 0) return false;
}
return true;
}
bool sortbysec(const pair<long long, long long> &a,
const pair<long long, long long> &b) {
return (a.second < b.second);
}
long long rr[] = {
0, 1, 1, 1, 0, -1, -1, -1,
};
long long cc[] = {1, 1, 0, -1, -1, -1, 0, 1};
const int N = 1000001;
long long n, m;
vector<long long> g[N];
bool vis[N];
long long nodes, edges;
void dfs(long long u) {
vis[u] = 1;
nodes++;
edges += g[u].size();
for (long long v : g[u])
if (!vis[v]) dfs(v);
}
signed main() {
cin >> n >> m;
for (long long i = 0; i < (long long)m; i++) {
long long u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
long long ans = 0;
for (long long i = 1; i < (long long)n + 1; i++) {
if (!vis[i]) {
nodes = 0, edges = 0;
dfs(i);
edges /= 2;
ans += (edges < nodes);
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000 * 1000 + 10;
vector<int> adj[MAXN];
bool mark[MAXN];
bool fl = false;
vector<int> q;
int p[MAXN];
long long int mod = 1000 * 1000 * 1000 + 7;
void addEdge(long long int u, long long int v) {
adj[u].push_back(v);
adj[v].push_back(u);
}
void BFS(int u) {
mark[u] = true;
q.push_back(u);
p[u] = u;
while (!q.empty()) {
int x = q.back();
q.pop_back();
for (int i = 0; i < adj[x].size(); i++) {
int y = adj[x][i];
if (!mark[y]) {
mark[y] = true;
q.push_back(y);
p[y] = x;
} else if (p[x] != y) {
fl = true;
}
}
}
return;
}
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 x, y;
cin >> x >> y;
addEdge(x, y);
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (!mark[i]) {
fl = false;
BFS(i);
if (!fl) ans++;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200100;
int n, m, a, b, ans = 0;
bool vis[N];
vector<int> g[N];
bool cycle = false;
void dfs(int u, int p) {
if (vis[u]) {
cycle = true;
return;
}
vis[u] = true;
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (v == p) continue;
dfs(v, u);
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d%d", &a, &b);
g[a].push_back(b);
g[b].push_back(a);
}
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
cycle = false;
dfs(i, -1);
ans += (!cycle);
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
const int N = 1e5 + 5;
using namespace std;
template <class T>
void print_container(T &container) {
for (auto &t : container) {
cout << t.first << " " << t.second.first << " " << t.second.second << " "
<< "\n";
}
cout << "\n";
}
int n, m;
bool visited[N];
vector<int> adj[N];
bool hasCycle = false;
void dfs(int x, int par) {
visited[x] = true;
for (auto u : adj[x]) {
if (visited[u] && u != par) hasCycle = true;
if (!visited[u]) dfs(u, x);
}
}
void solve() {
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;
for (int i = 0; i < n; i++) {
if (!visited[i]) {
hasCycle = false;
dfs(i, -1);
ans += !hasCycle;
}
}
cout << ans << "\n";
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> siz(100020), par(100020);
vector<bool> cycle(100020, false);
void make_set(long long v) {
siz[v] = 1;
par[v] = v;
}
long long find_set(long long v) {
if (par[v] == v) return v;
return par[v] = find_set(par[v]);
}
void union_sets(long long a, long long b) {
a = find_set(a);
b = find_set(b);
if (a != b) {
if (siz[a] > siz[b]) {
siz[a] += siz[b];
par[b] = a;
} else {
siz[b] += siz[a];
par[a] = b;
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
string str, str2;
long long elm, tc, n, m;
tc = 1;
while (tc--) {
cin >> n >> m;
for (long long x = 1; x < n + 1; x++) make_set(x);
long long a, b;
for (long long x = 0; x < m; x++) {
cin >> a >> b;
if (find_set(a) != find_set(b)) {
long long is = 0;
if (cycle[find_set(a)] == true || cycle[find_set(b)] == true) is = 1;
union_sets(a, b);
if (is) cycle[find_set(a)] = true;
} else
cycle[find_set(a)] = true;
}
set<long long> comp, cyc;
for (long long x = 1; x < n + 1; x++) {
long long temp = find_set(x);
comp.insert(temp);
if (cycle[temp]) cyc.insert(temp);
}
cout << comp.size() - cyc.size();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long mod = 10000000000;
long long gcd(long long a, long long b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
long long fastexp(long long x, long long n) {
long long result = 1;
while (n > 0) {
if (n % 2 == 1) result *= x;
x *= x;
n = n / 2;
}
return result;
}
long long modularExp(long long x, long long n, long long mod) {
long long result = 1;
while (n > 0) {
if (n % 2 == 1) result = (result * x) % mod;
x = ((x % mod) * (x % mod)) % mod;
n = n / 2;
}
return (result) % mod;
}
bool isPrime(long long n) {
for (long long i = 2; i * i <= n; i++)
if (n % i == 0) return false;
return true;
}
bool mycomp(pair<long long, long long> &a, pair<long long, long long> &b) {
if (a.first != b.first)
return a.first < b.first;
else
return a.second < b.second;
}
vector<long long> v[100005], visited(100005);
long long dfs(long long node, long long par) {
visited[node] = 1;
long long x = 0;
for (auto it : v[node]) {
if (visited[it] && it != par)
x += 1;
else if (it == par)
continue;
else
x += dfs(it, node);
}
if (x >= 1)
return 1;
else
return 0;
}
void solve() {
long long n, m;
cin >> n >> m;
long long i;
for (i = 1; i <= m; i++) {
long long x, y;
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
long long ans = 0;
for (i = 1; i <= n; i++) {
if (!visited[i]) {
if (!dfs(i, -1)) ans += 1;
}
}
cout << ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t;
long long i;
t = 1;
while (t--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T sqr(T x) {
return x * x;
}
template <typename T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
const int MAXN = (int)1e5 + 10;
int n, m;
int ans;
vector<int> d[MAXN];
bool us[MAXN];
bool flag = false;
void dfs(int x, int pr) {
us[x] = true;
for (int i = 0; i < d[x].size(); i++)
if (!us[d[x][i]])
dfs(d[x][i], x);
else if (d[x][i] != pr)
flag = true;
}
int main() {
ios_base ::sync_with_stdio(false);
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int x, y;
cin >> x >> y;
d[x].push_back(y);
d[y].push_back(x);
}
for (int i = 1; i <= n; i++)
if (!us[i]) {
flag = false;
dfs(i, 0);
if (!flag) ans++;
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100111;
int n, m;
int p[N][2];
int cnt[N];
int main() {
int i;
while (scanf("%d%d", &n, &m) != EOF) {
memset(cnt, 0, sizeof(cnt));
for (i = 1; i <= m; i++) {
scanf("%d%d", &p[i][0], &p[i][1]);
cnt[p[i][0]]++;
cnt[p[i][1]]++;
}
int ans = 0;
bool flag = false;
for (i = 1; i <= n; i++) {
if (!cnt[i]) ans++;
if (cnt[i] == 1) flag = true;
}
while (flag) {
flag = false;
for (i = 1; i <= m; i++) {
if (p[i][0]) {
if (cnt[p[i][0]] == 1) {
cnt[p[i][1]]--;
if (cnt[p[i][1]] == 1) flag = true;
if (cnt[p[i][1]] == 0) ans++;
p[i][0] = 0;
continue;
}
if (cnt[p[i][1]] == 1) {
cnt[p[i][0]]--;
if (cnt[p[i][0]] == 1) flag = true;
if (cnt[p[i][0]] == 0) ans++;
p[i][0] = 0;
continue;
}
}
}
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
const long long M = (long long)1e9 + 7;
int Int() {
int x;
scanf("%d", &x);
return x;
}
long long Long() {
long long x;
scanf("%lld", &x);
return x;
}
void Char(char *ch) { scanf("%s", ch); }
template <typename t>
inline t abs(t a) {
if (a >= 0) return a;
return -a;
}
template <typename T>
inline T modpow(T b, T p, T Mod) {
T res = 1;
while (p) {
if (p & 1) {
res *= b;
res %= Mod;
}
b *= b;
b %= Mod;
p >>= 1;
}
return res;
}
template <typename T>
inline T ModInv(T b, T Mod) {
return modpow(b, Mod - 2, Mod);
}
template <typename T>
inline T pwr(T b, T p) {
T res = 1;
while (p) {
if (p & 1) {
res *= b;
}
b *= b;
p >>= 1;
}
return res;
}
template <typename T>
inline T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <typename T>
inline void Int(T &n) {
n = 0;
int f = 1;
register int ch = getchar();
for (; !isdigit(ch); ch = getchar())
if (ch == '-') f = -1;
for (; isdigit(ch); ch = getchar()) n = (n << 3) + (n << 1) + ch - '0';
n = n * f;
}
template <typename T, typename U>
inline void Int(T &a, U &b) {
Int(a);
Int(b);
}
template <typename T, typename U, typename W>
inline void Int(T &a, U &b, W &c) {
Int(a, b);
Int(c);
}
template <typename T, typename U, typename W, typename X>
inline void Int(T &a, U &b, W &c, X &d) {
Int(a, b, c);
Int(d);
}
vector<int> Unique(vector<int> v) {
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
return v;
}
vector<string> split(const string &s, char c) {
vector<string> v;
stringstream ss(s);
string x;
while (getline(ss, x, c)) v.emplace_back(x);
return move(v);
}
void err(vector<string>::iterator it) {}
template <typename T, typename... Args>
void err(vector<string>::iterator it, T a, Args... args) {
cout << it->substr((*it)[0] == ' ', it->length()) << " = " << a << " ";
err(++it, args...);
}
std::vector<int> g[N];
bool vis[N], cycle;
void dfs(int s, int p = -1) {
for (int i = 0; i < (int)g[s].size(); i++) {
int u = g[s][i];
if (u == p) continue;
if (!vis[u]) {
vis[u] = 1;
dfs(u, s);
} else {
cycle = 1;
return;
}
}
}
int main() {
int n = Int(), m = Int();
for (int i = 1; i <= m; i++) {
int l = Int(), r = Int();
g[l].push_back(r);
g[r].push_back(l);
}
int res = 0;
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
vis[i] = 1;
cycle = 0;
dfs(i);
if (!cycle) res++;
}
}
printf("%d\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
int n, m;
set<int> graf[MAXN];
int deg[MAXN];
bool ok[MAXN];
void dfs(int node) {
int ne = *graf[node].begin();
ok[node] = true;
deg[node] = 0;
graf[node].clear();
deg[ne]--;
graf[ne].erase(node);
if (deg[ne] == 1) dfs(ne);
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; ++i) {
int x, y;
scanf("%d%d", &x, &y);
x--;
y--;
deg[x]++;
graf[x].insert(y);
deg[y]++;
graf[y].insert(x);
}
for (int i = 0; i < n; ++i) {
if (deg[i] == 1 && !ok[i]) {
dfs(i);
}
}
int sol = 0;
for (int i = 0; i < n; ++i) {
if (!deg[i] && !ok[i]) {
sol++;
}
}
printf("%d", sol);
}
|
#include <bits/stdc++.h>
using namespace std;
bool Dfs(int v, int pv, const vector<vector<int>>& gr, vector<char>& use) {
bool result = false;
use[v] = true;
for (int u : gr[v]) {
if (u == pv) {
continue;
}
if (use[u]) {
result = true;
} else {
bool result2 = Dfs(u, v, gr, use);
result = (result || result2);
}
}
return result;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int N, M;
cin >> N >> M;
vector<vector<int>> gr(N);
for (int i = 0; i < M; ++i) {
int a, b;
cin >> a >> b;
--a;
--b;
gr[a].push_back(b);
gr[b].push_back(a);
}
int result = 0;
vector<char> use(N, false);
for (int i = 0; i < N; ++i) {
if (use[i]) {
continue;
}
if (!Dfs(i, -1, gr, use)) {
++result;
}
}
cout << result << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void detectCycle(int parent, int x, bool &hasCycle, vector<int> adjList[],
bool visited[]) {
int neighbor;
visited[x] = true;
for (int i = 0; i < adjList[x].size(); i++) {
neighbor = adjList[x][i];
if (neighbor != parent && visited[neighbor])
hasCycle = true;
else if (!visited[neighbor])
detectCycle(x, neighbor, hasCycle, adjList, visited);
}
}
int main() {
int n, m, i, x, y;
cin >> n >> m;
vector<int> adjList[n + 1];
bool visited[n + 1];
fill(visited + 1, visited + n + 1, false);
for (i = 0; i < m; i++) {
cin >> x >> y;
adjList[x].push_back(y);
adjList[y].push_back(x);
}
bool cycle = false;
int k = 0;
for (i = 1; i <= n; i++) {
if (!visited[i]) {
cycle = false;
detectCycle(-1, i, cycle, adjList, visited);
if (!cycle) k++;
}
}
cout << k;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> edges[(int)(1e5 + 1)];
void print_vector2d(vector<vector<int>>& a, string name) {
cout << name << " is\n";
for (int i = 0; i < a.size(); i++) {
for (int j = 0; j < a[0].size(); j++) {
cout << a[i][j] << " ";
}
cout << "\n";
}
cout << "\n";
}
void print_vector(vector<int>& a, string name) {
cout << name << " is\n";
for (int i = 0; i < a.size(); i++) {
cout << a[i] << " ";
}
cout << "\n";
}
void dfs(int n, int p, vector<int>& visited, int& cycle) {
visited[n] = 1;
for (int i = 0; i < edges[n].size(); i++) {
int c = edges[n][i];
if (c == p) continue;
if (visited[c] == 1) {
cycle = 1;
} else {
dfs(c, n, visited, cycle);
}
}
}
int main() {
int n, m;
cin >> n >> m;
vector<int> visited(n + 1, 0);
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
edges[a].push_back(b);
edges[b].push_back(a);
}
int separate = 0;
for (int i = 1; i <= n; i++) {
if (visited[i] != 1) {
int cycle = 0;
dfs(i, 0, visited, cycle);
if (cycle == 0) {
separate += 1;
}
}
}
cout << separate << "\n";
return (0);
}
|
#include <bits/stdc++.h>
typedef struct l_i {
int32_t* data;
unsigned size;
unsigned capacity;
} l_i;
static const l_i l_zero_i = {0};
void l_resize_i(l_i* list) {
if (list->capacity < 4)
list->capacity = 4;
else
list->capacity <<= 2;
list->data = (int32_t*)realloc(list->data, sizeof(int32_t) * list->capacity);
assert(list->data != NULL);
}
void l_free_i(l_i* list) {
free(list->data);
*list = l_zero_i;
}
bool l_empty_i(l_i* list) { return (list->size == 0); }
void l_add_i(l_i* list, int32_t value) {
if (list->size == list->capacity) l_resize_i(list);
list->data[list->size] = value;
++list->size;
}
void l_insertAt_i(l_i* list, unsigned idx, int32_t val) {
assert(idx <= list->size);
if (list->size == list->capacity) l_resize_i(list);
for (unsigned i = list->size; i > idx; --i) {
list->data[i] = list->data[i - 1];
}
list->data[idx] = val;
++list->size;
}
void l_removeAt_i(l_i* list, unsigned idx) {
assert(idx < list->size);
for (unsigned i = idx; i < list->size - 1; ++i) {
list->data[i] = list->data[i + 1];
}
--list->size;
}
inline void l_swap_i(l_i* list, unsigned i, unsigned j) {
assert(i < list->size);
assert(j < list->size);
int32_t tmp = list->data[i];
list->data[i] = list->data[j];
list->data[j] = tmp;
}
l_i g[100005];
bool visited[100005];
bool dfs(int node, int parent) {
if (visited[node]) return true;
visited[node] = true;
bool res = false;
for (int _k = (0), _n = (g[node].size - 1), i = _k; i <= _n; ++i) {
int v = g[node].data[i];
if (v == parent) continue;
res |= dfs(v, node);
}
return res;
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int _k = (1), _n = (m), i = _k; i <= _n; ++i) {
int u, v;
scanf("%d %d", &u, &v);
l_add_i(&g[u], v);
l_add_i(&g[v], u);
}
int count = 0;
for (int _k = (1), _n = (n), i = _k; i <= _n; ++i) {
if (!visited[i] && !dfs(i, -1)) ++count;
}
printf("%d", count);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int res = 0;
int neg;
while (true) {
char ch = getchar();
if (ch >= '0' && ch <= '9' || ch == '-') {
if (ch == '-')
neg = -1;
else
neg = 1, res = ch - '0';
break;
}
}
while (true) {
char ch = getchar();
if (ch >= '0' && ch <= '9')
res *= 10, res += ch - '0';
else
break;
}
return res * neg;
}
const int maxn = 100020;
const int MOd = 1e9 + 7;
int a, b;
vector<pair<int, int> > w[maxn];
vector<int> w2[maxn];
int name[maxn], low[maxn], id[maxn], cnt;
int ex[maxn], used[maxn], T;
int find(int n) {
if (name[n] == low[n]) return low[n];
return low[n] = find(id[low[n]]);
}
void dfs(int n, int back) {
name[n] = low[n] = ++cnt;
id[cnt] = n;
for (int i = 0; i < w[n].size(); i++)
if (!name[w[n][i].first]) {
dfs(w[n][i].first, n);
low[n] = min(low[n], (low[w[n][i].first]));
} else if (w[n][i].first != back)
low[n] = min(low[n], (name[w[n][i].first]));
}
void dfs2(int n, int back) {
used[n] = 1;
if (ex[n]) T = 1;
for (int i = 0; i < w2[n].size(); i++)
if (!used[w2[n][i]]) {
dfs2(w2[n][i], n);
}
}
int main() {
scanf("%d %d", &a, &b);
for (int i = 1, j, k; i <= b; i++) {
scanf("%d %d", &j, &k);
w[j].push_back(pair<int, int>(k, 0));
w[k].push_back(pair<int, int>(j, 0));
}
for (int i = a; i >= 1; i--)
if (!name[i]) dfs(i, 0);
for (int i = 1; i <= a; i++)
if (low[i] != name[i]) {
used[i] = 1;
int t = find(i);
ex[id[t]] = 1;
}
for (int i = 1; i <= a; i++) assert(name[i]);
for (int i = 1; i <= a; i++) {
int h2 = id[find(i)];
for (int j = 0; j < w[i].size(); j++) {
int h = id[find(w[i][j].first)];
if (h != h2) w2[h2].push_back(h);
}
}
int ans = 0;
for (int i = 1; i <= a; i++)
if (!used[i]) {
T = 0;
dfs2(i, 0);
if (!T) ans++;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
const double pi = 4 * atan(1);
const int inf = 1 << 30;
const int INF = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
int nCase = 0;
int dcmp(double x) {
if (fabs(x) < eps) return 0;
return x < 0 ? -1 : 1;
}
template <class T>
inline bool read(T& n) {
T x = 0, tmp = 1;
char c = getchar();
while ((c < '0' || c > '9') && c != '-' && c != EOF) c = getchar();
if (c == EOF) return false;
if (c == '-') c = getchar(), tmp = -1;
while (c >= '0' && c <= '9') x *= 10, x += (c - '0'), c = getchar();
n = x * tmp;
return true;
}
template <class T>
inline void write(T n) {
if (n < 0) {
putchar('-');
n = -n;
}
int len = 0, data[20];
while (n) {
data[len++] = n % 10;
n /= 10;
}
if (!len) data[len++] = 0;
while (len--) putchar(data[len] + 48);
}
long long QMOD(long long x, long long k) {
long long res = 1LL;
while (k) {
if (k & 1) res = res * x % MOD;
k >>= 1;
x = x * x % MOD;
}
return res;
}
const int maxn = 1e5 + 10;
int n, m;
struct node {
int u, deg;
bool operator<(const node& rhs) const { return deg > rhs.deg; }
};
priority_queue<node> que;
int deg[maxn];
vector<int> G[maxn];
int mark[maxn];
int main(int argc, const char* argv[]) {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; ++i) {
int u, v;
scanf("%d%d", &u, &v);
deg[u]++;
deg[v]++;
G[u].push_back(v);
G[v].push_back(u);
}
for (int i = 1; i <= n; ++i) que.push(node{i, deg[i]});
int cnt = 0;
while (!que.empty()) {
node temp = que.top();
que.pop();
if (mark[temp.u]) continue;
if (temp.deg == 0) {
cnt++;
continue;
}
if (temp.deg == 1) {
int u = temp.u;
for (int& v : G[u]) {
if (!mark[v]) {
deg[v]--;
que.push(node{v, deg[v]});
}
}
mark[u] = 1;
}
if (temp.deg > 1) break;
}
cout << cnt << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 3;
int n, m, vis[N], num, sz[N], ver[N];
vector<int> adj[N];
void dfs(int u) {
vis[u] = num;
ver[num]++;
for (int v : adj[u])
if (!vis[v]) dfs(v);
}
void init() {
ios::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;
adj[u].push_back(v), adj[v].push_back(u);
}
}
void solve() {
int res = 0;
for (int i = 1; i <= n; ++i)
if (!vis[i]) ++num, dfs(i);
for (int i = 1; i <= n; ++i)
for (int v : adj[i]) ++sz[vis[i]];
for (int i = 1; i <= num; ++i) res += (sz[i] == 2 * (ver[i] - 1));
cout << res;
}
int main() {
init();
solve();
}
|
#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);
}
for (int i = 1; i <= n; i++) {
if (!finalvis[i]) dfs1(i, i);
}
int ans = 0;
for (int i = 1; i <= n; i++)
if (!finalvis[i]) ans++;
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 50;
int n, m, u, v, k, cnt, cnt2;
vector<int> g[N];
priority_queue<int, vector<int>, greater<int> > q;
bool visited[N];
int mx = INT_MIN;
const int fx[9] = {0, 0, 1, -1, 0, 1, 1, -1, -1};
const int fy[9] = {1, -1, 0, 0, 0, 1, -1, 1, -1};
const int dx[] = {0, 1, 0, -1};
const int dy[] = {1, 0, -1, 0};
bool cycle;
void dfs(int x, int parent) {
if (visited[x]) {
cycle = true;
return;
}
visited[x] = true;
for (auto i : g[x]) {
if (i == parent) {
continue;
}
dfs(i, x);
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
ios_base::sync_with_stdio(0);
cin >> n >> m;
for (int i = 1; i <= m; i++) {
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
for (int i = 1; i <= n; i++) {
if (!visited[i]) {
dfs(i, 0);
if (!cycle) {
cnt++;
}
cycle = false;
}
}
cout << cnt;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100001, M = N << 1;
int n, m, fa[N], ans, f, head[N], cnt, 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 bool testcases = 1;
void print(int a[], int n) {
for (int i = 0; i < n; i++) cout << a[i] << " ";
cout << "\n";
}
unsigned long long int logn(unsigned long long int n,
unsigned long long int r) {
return (n > r - 1) ? 1 + logn(n / r, r) : 0;
}
vector<int> adj[100005];
vector<bool> visited(100005, false);
bool dfs(int k, int flag, int st) {
visited[k] = true;
for (int i = 0; i < adj[k].size(); ++i) {
if (!visited[adj[k][i]]) {
if (dfs(adj[k][i], k, st)) return true;
} else {
if (flag != adj[k][i]) st = 1;
}
}
if (st) return true;
return false;
}
int main() {
ios_base::sync_with_stdio(0);
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;
adj[a].push_back(b);
adj[b].push_back(a);
}
int count = 0;
for (int i = 1; i < n; ++i)
if (!visited[i]) {
if (!dfs(i, -1, 0)) count++;
}
cout << count;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int s, t, next;
} p[1000000];
int fel[100001], v[100001], tot, n, m, x, y, ans, flag;
inline void add_edge(int s, int t) {
p[tot].s = s, p[tot].t = t, p[tot].next = fel[s];
fel[s] = tot++;
}
inline void init() {
tot = 0;
memset(fel, -1, sizeof(fel));
}
inline void dfs_1(int x, int last) {
v[x] = 1;
for (int i = fel[x], y = p[i].t; i != -1; i = p[i].next, y = p[i].t) {
if (v[y] && last != y) flag = 0;
if (!v[y]) dfs_1(y, x);
}
}
int main() {
init();
scanf("%d%d", &n, &m);
while (m--) scanf("%d%d", &x, &y), add_edge(x, y), add_edge(y, x);
for (int i = 1; i <= n; i++)
if (!v[i]) flag = 1, dfs_1(i, 0), ans += flag ? 1 : 0;
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
const int ms = 100100;
int par[ms];
int pos[ms];
bool got[ms];
int getPar(int x) {
if (par[x] == x) {
return x;
} else {
return par[x] = getPar(par[x]);
}
}
void makeUnion(int a, int b, int newPos) {
a = getPar(a);
b = getPar(b);
par[b] = a;
pos[a] = newPos;
}
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(NULL);
int n, m;
std::cin >> n >> m;
for (int i = 0; i < n; i++) {
pos[i] = par[i] = i;
}
int ans = n;
for (int i = 0; i < m; i++) {
int u, v;
std::cin >> u >> v;
u--;
v--;
if (!got[pos[getPar(u)]]) {
ans--;
int newPos = pos[getPar(v)];
int oldPos = pos[getPar(u)];
got[oldPos] = true;
makeUnion(u, v, newPos);
} else if (!got[pos[getPar(v)]]) {
ans--;
int newPos = pos[getPar(u)];
int oldPos = pos[getPar(v)];
got[oldPos] = true;
makeUnion(u, v, newPos);
}
}
std::cout << ans << std::endl;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool smin(T &_x, T &_y) {
return _x <= _y ? false : ((_x = _y), true);
}
template <class T>
bool smax(T &_x, T &_y) {
return _x >= _y ? false : ((_x = _y), true);
}
const int maxn = 1e5 + 5;
const int inf = 1e9;
const int mod = 1e9 + 7;
int n, m;
vector<int> edge[maxn];
bool mark[maxn];
bool dfs(int v, int par) {
mark[v] = true;
bool ans = 0;
for (int u : edge[v]) {
if (mark[u]) {
if (u != par) ans = 1;
continue;
}
ans |= dfs(u, v);
}
return ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int v, u;
cin >> v >> u;
v--;
u--;
edge[v].push_back(u);
edge[u].push_back(v);
}
int ans = 0;
for (int i = 0; i < n; i++) {
if (!mark[i]) ans += !dfs(i, -1);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
class graph {
public:
long long n;
vector<bool> vis;
vector<long long> *adj;
graph(long long b) {
n = b;
adj = new vector<long long>[n];
vis.resize(n, false);
}
void add_edge(long long b, long long c);
bool dfs(long long b, long long p);
};
void graph::add_edge(long long b, long long c) {
adj[b].push_back(c);
adj[c].push_back(b);
}
bool graph::dfs(long long b, long long p) {
if (vis[b]) {
return true;
} else {
bool temp = false;
vis[b] = true;
for (auto c : adj[b]) {
if (c != p) {
temp |= dfs(c, b);
}
}
return temp;
}
}
void solve() {
long long i, j, k, n, m;
cin >> n >> m;
graph g = graph(n);
for (i = 0; i < m; i++) {
cin >> j >> k;
j--;
k--;
g.add_edge(j, k);
}
long long ans = 0;
for (i = 0; i < n; i++) {
if (!g.vis[i]) {
ans++;
bool temp = g.dfs(i, -1);
if (temp) {
ans--;
}
}
}
cout << ans << "\n";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
t = 1;
while (t--) solve();
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.