text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > g;
bitset<int(1e5)> visited;
int temp[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 x) { return temp[x] == x ? x : temp[x] = find(temp[x]); }
void solve(int n, int m) {
for (int i = 0; i < n; i++) temp[i] = i;
int cnt = n;
int u, v;
for (int i = 0; i < m; i++) {
cin >> u >> v;
u--, v--;
u = find(u), v = find(v);
if (u == v)
visited[u] = true;
else {
temp[u] = v;
cnt--;
visited[v] = visited[u] || visited[v];
}
}
for (int i = 0; i < n; i++)
if (temp[i] == i && visited[i]) cnt--;
cout << cnt << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
solve(n, m);
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > g;
bitset<(int)1e6> us;
bool isCyclic(int v, int p = -1) {
us.set(v);
for (int i = 0; i < g[v].size(); i++) {
if (us.test(g[v][i]) && g[v][i] != p) return 0;
if (us.test(g[v][i])) continue;
bool cures = isCyclic(g[v][i], v);
if (!cures) return 0;
}
return 1;
}
int main() {
int n, m;
cin >> n >> m;
g.resize(n + 1);
for (int i = 0; i < m; i++) {
int v, to;
cin >> v >> to;
g[to].push_back(v);
g[v].push_back(to);
}
int sum = 0;
for (int i = 1; i <= n; i++) {
if (us.test(i)) continue;
sum += isCyclic(i);
}
cout << sum << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 1e5 + 5;
int n, m;
vector<int> head[maxN];
bool mark[maxN];
bool DFS(int u, int pre) {
mark[u] = true;
bool ok = false;
for (int v : head[u]) {
if (v == pre) continue;
if (mark[v])
ok = true;
else
ok |= DFS(v, u);
}
return ok;
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; ++i) {
int u, v;
scanf("%d %d", &u, &v);
head[u].push_back(v);
head[v].push_back(u);
}
int res = 0;
for (int u = 1; u <= n; ++u)
if (!mark[u]) res += !DFS(u, 0);
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[100001];
bool vis[100001]{};
int p[100001];
bool fill(int v) {
queue<int> q;
vis[v] = 1;
q.push(v);
p[v] = -1;
bool cicle = 0;
while (!q.empty()) {
v = q.front();
q.pop();
for (int u : adj[v]) {
if (vis[u])
cicle = cicle || (p[v] != u);
else {
vis[u] = 1;
q.push(u);
p[u] = v;
}
}
}
return !cicle;
}
int main() {
int n, m;
cin >> n >> m;
while (m--) {
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++) {
if (!vis[i]) {
cnt += fill(i);
}
}
cout << cnt << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> g[100009];
bool vis[100008];
long long cc = 0;
void dfs(long long src, long long papa) {
vis[src] = 1;
for (long long i = 0; i < g[src].size(); i++) {
if (!vis[g[src][i]]) {
dfs(g[src][i], src);
} else if (g[src][i] != papa)
cc = 1;
}
}
int main() {
set<long long>::iterator it;
long long n, m, ans = 0;
cin >> n >> m;
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);
}
for (long long i = 1; i <= n; i++) {
cc = 0;
if (!vis[i]) {
dfs(i, i);
if (!cc) ans++;
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> vv[1000005];
bool visited[1000005];
map<int, int> mp;
int calcuculateVal(int src) {
queue<pair<int, int> > q;
int level = 1;
q.push(make_pair(src, level));
visited[src] = true;
bool isCyclic = false;
while (!q.empty()) {
pair<int, int> front = q.front();
q.pop();
for (vector<int>::iterator itr = vv[front.first].begin();
itr != vv[front.first].end(); itr++) {
if (visited[*itr] == false) {
visited[*itr] = true;
q.push(make_pair(*itr, front.second + 1));
mp[*itr] = front.first;
} else {
if (mp[front.first] != *itr) {
isCyclic = true;
}
}
}
}
if (isCyclic) {
return 0;
}
return 1;
}
int main() {
int n = -1, m = -1;
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; i++) {
int start, end;
scanf("%d %d", &start, &end);
vv[start].push_back(end);
vv[end].push_back(start);
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (visited[i] == false) {
ans += calcuculateVal(i);
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> edges[100005];
int numnodes;
int numedges;
bool vis[100005];
void dfs(int n) {
if (vis[n]) return;
vis[n] = 1;
numnodes++;
numedges += edges[n].size();
for (int i = 0; i < edges[n].size(); i++) {
int ne = edges[n][i];
if (!vis[ne]) {
dfs(ne);
}
}
}
int main() {
ios_base::sync_with_stdio(0);
int n, m;
while (cin >> n >> m) {
for (int i = 0; i < n; i++) edges[i] = vector<int>();
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
x--;
y--;
edges[x].push_back(y);
edges[y].push_back(x);
}
int res = 0;
memset((vis), 0, sizeof((vis)));
for (int i = 0; i < n; i++) {
if (!vis[i]) {
numnodes = 0;
numedges = 0;
dfs(i);
numedges /= 2;
if (numedges + 1 == numnodes) {
res++;
}
}
}
cout << res << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
stack<int> st;
vector<int> ds[N];
int pre[N], up[N];
int order;
bool ok;
void dfs(int u, int pa) {
pre[u] = up[u] = ++order;
st.push(u);
for (auto v : ds[u]) {
if (v == pa) continue;
if (pre[v] == 0) {
dfs(v, u);
up[u] = min(up[u], up[v]);
} else
up[u] = min(up[u], pre[v]);
}
if (pre[u] == up[u]) {
if (st.top() != u) ok = true;
while (st.top() != u) st.pop();
st.pop();
}
}
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);
ds[u].push_back(v);
ds[v].push_back(u);
}
order = 0;
int ans = 0;
for (int i = 1; i <= n; i++) {
if (pre[i] != 0) continue;
ok = false;
dfs(i, 0);
if (!ok) ans++;
}
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int t = 1, n, m, k, ans;
vector<bool> used, parc;
vector<int> par;
int find(int a) {
if (par[a] == a)
return a;
else
return par[a] = find(par[a]);
}
void solve() {
cin >> n >> m;
par.resize(n + 1);
parc.resize(n + 1, false);
used.resize(n + 1, false);
for (int i = 1; i <= n; i++) par[i] = i;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
int a1 = find(a);
int b1 = find(b);
if (a1 != b1) {
par[a1] = b1;
if (parc[a1]) parc[b1] = true;
} else {
parc[a1] = true;
}
}
for (int i = 1; i <= n; i++) {
int p = find(i);
if (!used[p]) {
if (!parc[p]) ans++;
used[p] = true;
}
}
cout << ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long dsu[100004];
long long siize[100004];
long long roo(long long x) {
while (dsu[x] != x) {
dsu[x] = dsu[dsu[x]];
x = dsu[x];
}
return x;
}
void uniion(long long x, long long y) {
long long p, q;
p = roo(x);
q = roo(y);
if (p == q) return;
if (siize[p] > siize[q]) {
dsu[q] = p;
siize[p] += siize[q];
} else {
dsu[p] = q;
siize[q] += siize[p];
}
}
int main() {
long long n, m, i, ans, y;
scanf("%lld%lld", &n, &m);
for (i = 0; i <= n; i++) {
dsu[i] = i;
siize[i] = 1;
}
long long hs[m];
for (i = 0; i < m; i++) {
scanf("%lld%lld", &hs[i], &y);
uniion(hs[i], y);
}
long long anss[n + 1];
memset(anss, 0, sizeof(anss));
for (i = 0; i < m; i++) anss[roo(hs[i])]++;
ans = 0;
for (i = 1; i <= n; i++) {
if (dsu[i] == i) {
if (siize[i] - 1 == anss[i]) ans++;
}
}
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200010;
const int MAXM = 800010;
const int INF = 0x3f3f3f3f;
struct Edge {
int st, to, next, cap, flow;
} edge[MAXM];
int tol, head[MAXN], gap[MAXN], dep[MAXN], cur[MAXN];
void init() {
tol = 0;
memset(head, -1, sizeof(head));
}
void add_edge(int u, int v, int w, int rw = 0) {
edge[tol].st = u, edge[tol].to = v, edge[tol].cap = w, edge[tol].flow = 0;
edge[tol].next = head[u], head[u] = tol++;
edge[tol].st = v, edge[tol].to = u, edge[tol].cap = rw, edge[tol].flow = 0;
edge[tol].next = head[v], head[v] = tol++;
}
int Q[MAXN];
void BFS(int start, int end) {
memset(dep, -1, sizeof(dep));
memset(gap, 0, sizeof(gap));
gap[0] = 1;
int front = 0, rear = 0;
dep[end] = 0;
Q[rear++] = end;
while (front != rear) {
int u = Q[front++];
for (int i = head[u]; i != -1; i = edge[i].next) {
int v = edge[i].to;
if (dep[v] != -1) continue;
Q[rear++] = v;
dep[v] = dep[u] + 1;
gap[dep[v]]++;
}
}
}
int S[MAXN];
int sap(int start, int end, int N) {
BFS(start, end);
memcpy(cur, head, sizeof(head));
int top = 0;
int u = start;
int ans = 0;
while (dep[start] < N) {
if (u == end) {
int Min = INF;
int inser;
for (int i = 0; i < top; i++)
if (Min > edge[S[i]].cap - edge[S[i]].flow) {
Min = edge[S[i]].cap - edge[S[i]].flow;
inser = i;
}
for (int i = 0; i < top; i++) {
edge[S[i]].flow += Min;
edge[S[i] ^ 1].flow -= Min;
}
ans += Min;
top = inser;
u = edge[S[top] ^ 1].to;
continue;
}
bool flag = false;
int v;
for (int i = cur[u]; i != -1; i = edge[i].next) {
v = edge[i].to;
if (edge[i].cap - edge[i].flow && dep[v] + 1 == dep[u]) {
flag = true;
cur[u] = i;
break;
}
}
if (flag) {
S[top++] = cur[u];
u = v;
continue;
}
int Min = N;
for (int i = head[u]; i != -1; i = edge[i].next) {
if (edge[i].cap - edge[i].flow && dep[edge[i].to] < Min) {
Min = dep[edge[i].to];
cur[u] = i;
}
}
gap[dep[u]]--;
if (!gap[dep[u]]) return ans;
dep[u] = Min + 1;
gap[dep[u]]++;
if (u != start) u = edge[S[--top] ^ 1].to;
}
return ans;
}
int n, m, val[MAXN], id[MAXN], in[MAXN], out[MAXN], x, y, fl, ST, EN;
long long sum, ave;
int main() {
init();
scanf("%d%d", &n, &m);
ST = 0, EN = m + n + 1;
for (int i = 1; i <= m; i++) add_edge(ST, i, 1);
for (int i = m + 1; i <= m + n; i++) add_edge(i, EN, 1);
int u, v;
for (int i = 1; i <= m; i++) {
scanf("%d%d", &u, &v);
add_edge(i, m + u, 1);
add_edge(i, m + v, 1);
}
int flow = sap(ST, EN, EN + 1);
printf("%d\n", n - flow);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<long long>> adj;
vector<bool> vis;
long long v, e;
void dfs(long long k, long long par) {
queue<pair<long long, long long>> q;
q.push({k, par});
vis[k] = true;
while (!q.empty()) {
k = q.front().first;
par = q.front().second;
q.pop();
for (auto it : adj[k]) {
if (it != par) {
if (!vis[it]) {
vis[it] = true;
q.push({it, k});
v++;
e++;
} else
e++;
}
}
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, m, p, q;
cin >> n >> m;
adj = vector<vector<long long>>(n + 1);
for (long long i = 0; i < m; i++) {
cin >> p >> q;
adj[p].push_back(q);
adj[q].push_back(p);
}
long long c = 0;
vis = vector<bool>(n + 1, false);
for (long long i = 1; i <= n; i++) {
if (!vis[i]) {
v = 1, e = 0;
dfs(i, -1);
if (v == e + 1) c++;
}
}
cout << c << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
set<int> conn[100000 + 1];
int degree[100000 + 1];
set<pair<int, int> > d_set;
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int xi, yi;
scanf("%d%d", &xi, &yi);
conn[xi].insert(yi);
conn[yi].insert(xi);
degree[xi]++;
degree[yi]++;
}
for (int i = 1; i <= n; i++) {
int d = degree[i];
d_set.insert(make_pair(d, i));
}
int low_deg = (d_set.begin())->first;
int node = (d_set.begin())->second;
int ct = 0;
while (low_deg < 2 && d_set.size() > 0) {
d_set.erase(d_set.begin());
if (degree[node] == 0) {
ct++;
} else {
degree[node]--;
int n_node = *(conn[node].begin());
int d = degree[n_node];
auto it = d_set.find(make_pair(d, n_node));
d_set.erase(it);
d--;
d_set.insert(make_pair(d, n_node));
degree[n_node]--;
conn[n_node].erase(node);
}
low_deg = d_set.begin()->first;
node = d_set.begin()->second;
}
cout << ct;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[100001];
bool vis[100001];
int b;
void dfs(int n, int p) {
vis[n] = true;
for (int i = 0; i < adj[n].size(); i++) {
int x = adj[n][i];
if (x != p) {
if (vis[x]) {
b = 0;
return;
} else {
dfs(x, n);
}
}
}
}
void solve() {
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 ans = 0;
memset(vis, false, sizeof(vis));
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
b = 1;
dfs(i, -1);
ans += b;
}
}
cout << ans;
}
int main() {
int t;
t = 1;
while (t--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 1e5 + 7;
int n, m;
vector<int> g[MX];
bool Mark[MX];
int e;
int sz;
int ans;
int d[MX];
void solve(int v) {
sz++;
e += d[v];
Mark[v] = true;
for (int u : g[v]) {
if (Mark[u] == true) {
continue;
}
solve(u);
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
x--;
y--;
d[x]++;
d[y]++;
g[x].push_back(y);
g[y].push_back(x);
}
for (int i = 0; i < n; i++) {
if (Mark[i] == false) {
solve(i);
if (e / 2 < sz) ans++;
e = sz = 0;
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool vis[1000000];
int pai[1000000], peso[1000000];
bool iscly = false;
vector<int> adj[1000000];
void dfs(int u, int v) {
vis[u] = true;
for (int i = 0; i < adj[u].size(); i++) {
int k = adj[u][i];
if (k != v) {
if (vis[k])
iscly = true;
else {
dfs(k, u);
}
}
}
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
vis[i] = false;
adj[i].clear();
}
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);
}
long long int s = 0;
for (int i = 0; i < n; i++) {
if (!vis[i]) {
iscly = false;
dfs(i, i);
iscly ? s += 0 : s += 1;
}
}
cout << s;
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> G[100010];
bool vis[100010];
int n, m;
bool cmp(int a, int b) { return a > b; }
int bfs(int v) {
queue<int> q;
q.push(v);
vector<int> deg;
int sum = 0;
vis[v] = true;
while (!q.empty()) {
int u = q.front();
q.pop();
int n = (G[u]).size();
deg.push_back(n);
sum += n;
for (int i = 0; i < (n); ++i) {
int w = G[u][i];
if (!vis[w]) {
q.push(w);
vis[w] = true;
}
}
}
if ((deg).size() > 1) {
sort((deg).begin(), (deg).end(), cmp);
int rem = sum / 2;
for (int i = 0; i < ((deg).size()); ++i) {
if (deg[i] > 1) {
rem -= deg[i] - 1;
if (rem <= 0) {
rem = 0;
break;
}
} else
break;
}
return rem;
} else
return 1;
}
int main() {
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 cnt = 0;
for (int i = 1; i <= (n); ++i)
if (!vis[i]) cnt += bfs(i);
printf("%d\n", cnt);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[100005];
int ans;
bool flag;
bool visited[100005];
void dfs(int u, int p) {
visited[u] = true;
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i];
if (visited[v] == false) {
dfs(v, u);
} else {
if (visited[v] == true && v != p) {
flag = false;
}
}
}
}
int main() {
int n, m;
cin >> n >> m;
ans = 0;
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
flag = true;
for (int i = 1; i <= n; i++) visited[i] = false;
for (int i = 1; i <= n; i++) {
if (visited[i] == false) {
flag = true;
dfs(i, -1);
if (flag != false) ans += 1;
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long int> friends[100005];
long long int visited[100005];
bool cycle;
long long int reckstack[100005];
void dfs(long long int i, long long int parent) {
visited[i] = true;
reckstack[i] = true;
for (long long int y : friends[i]) {
if (!visited[y]) {
dfs(y, i);
}
if (visited[y] && reckstack[y] == 1 && y != parent) {
cycle = true;
}
}
reckstack[i] = false;
}
int32_t main() {
long long int N;
cin >> N;
long long int M;
cin >> M;
for (long long int i = 0; i < M; i++) {
long long int a;
cin >> a;
long long int b;
cin >> b;
a--;
b--;
friends[a].push_back(b);
friends[b].push_back(a);
}
memset(visited, 0, sizeof(visited));
memset(reckstack, 0, sizeof(reckstack));
long long int sum = 0;
for (long long int i = 0; i < N; i++) {
cycle = false;
if (!visited[i]) {
dfs(i, -1);
if (!cycle) {
sum++;
}
}
}
cout << sum << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
vector<int> g[100005];
int vs[100005];
int p[100005];
int t = 1;
int mk;
void dfs(int u) {
vs[u] = 1;
for (int i = 0; i < (int)(g[u].size()); i++) {
int w = g[u][i];
if (!vs[w]) {
p[w] = u;
dfs(w);
} else if (vs[w] and w != p[u]) {
mk = 1;
}
}
}
int main() {
int n, m;
scanf("%d", &n);
scanf("%d", &m);
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d", &a);
scanf("%d", &b);
g[a].push_back(b);
g[b].push_back(a);
}
int cnt = 0;
for (int i = 1; i <= n; i++) {
if (!vs[i]) {
mk = 0;
dfs(i);
if (!mk) {
cnt++;
}
}
}
printf("%d\n", cnt);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> *adj;
static int mark[100005];
static int visited[100005];
static int pi[100005];
int n;
void dfs(int s, int root) {
if (mark[s] == 0) mark[s] = 1;
visited[s] = 1;
for (vector<int>::iterator it = adj[s].begin(); it != adj[s].end(); it++) {
if (!visited[*it]) {
mark[*it] = 2;
pi[*it] = s;
dfs(*it, root);
} else if (visited[*it] == 1 && pi[s] != *it) {
mark[root] = 2;
}
}
visited[s] = 2;
}
int main() {
int m, x, y, i;
cin >> n >> m;
adj = new vector<int>[n + 2];
for (i = 0; i < m; i++) {
scanf("%d %d", &x, &y);
adj[x].push_back(y);
adj[y].push_back(x);
}
for (int i = 1; i <= n; i++) {
if (mark[i] == 0) dfs(i, i);
}
int res = 0;
for (int i = 1; i <= n; i++)
if (mark[i] != 2) res++;
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Data {
int x, y;
} par[100001];
int n, m, x, y, cnt;
int rnk[100001];
void make_set(int v) { par[v].x = v; }
int find_set(int v) {
if (v == par[v].x) return v;
return par[v].x = find_set(par[v].x);
}
void set_union(int a, int b) {
a = find_set(a);
b = find_set(b);
if (a != b) {
if (rnk[a] < rnk[b]) swap(a, b);
par[b].x = a;
if (par[b].y && !par[a].y) par[a].y = 1;
if (rnk[a] == rnk[b]) rnk[a]++;
} else
par[a].y = 1;
}
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) make_set(i);
for (int i = 1; i <= m; i++) {
scanf("%d %d", &x, &y);
set_union(x, y);
}
for (int i = 1; i <= n; i++)
if (par[i].x == i)
if (!par[i].y) cnt++;
cout << cnt;
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) { return parent[u] == u ? u : 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;
long long ans = 0;
vector<long long> g[400000];
long long par[400000];
bool w[400000];
bool cyc = false;
void dfs(int v, int parent) {
w[v] = true;
for (int i = 0; i < g[v].size(); ++i) {
int cur = g[v][i];
if (!w[cur])
dfs(cur, v);
else if (cur != parent)
cyc = true;
}
}
int main(void) {
ios_base::sync_with_stdio(false);
for (int i = 0; i < 200000; ++i) par[i] = -1;
int n, m;
cin >> n >> m;
for (int i = 0; i < m; ++i) {
long long a, b;
cin >> a >> b;
a--;
b--;
g[a].push_back(b);
g[b].push_back(a);
}
for (int i = 0; i < n; ++i) {
cyc = false;
if (!w[i]) {
dfs(i, -1);
if (cyc == false) ans++;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200010;
int n, m;
vector<int> Adj[N];
bool Vis[N], Cycle;
void Dfs(int x, int Lst = -1) {
Vis[x] = true;
for (int i = 0; i < Adj[x].size(); i++) {
int to = Adj[x][i];
if (!Vis[to]) {
Dfs(to, x);
} else if (Vis[to] && to != Lst) {
Cycle = true;
}
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
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 Ans = 0;
for (int i = 1; i <= n; i++) {
if (!Vis[i]) {
Cycle = false;
Dfs(i);
Ans += !Cycle;
}
}
cout << Ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> a[100100];
int ans;
int vis[200000];
void dfs(int per, int now) {
if (vis[per]) {
ans = 0;
return;
}
vis[per] = 1;
for (int i = 0; i < a[per].size(); i++) {
if (a[per][i] != now) dfs(a[per][i], per);
}
}
int main() {
int n, m, x, y, ret;
while (cin >> n >> m) {
ans = 1, ret = 0;
memset(vis, 0, sizeof vis);
for (int i = 0; i < m; i++) {
cin >> x >> y;
a[x].push_back(y);
a[y].push_back(x);
}
for (int i = 1; i <= n; i++) {
if (vis[i]) continue;
ans = 1;
dfs(i, 0);
ret += ans;
}
cout << ret << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
bool tree;
void dfs(int v, int p, vector<vector<int> > &g, vector<bool> &used) {
used[v] = true;
for (int i = 0; i < (int)g[v].size(); i++) {
int to = g[v][i];
if (to == p) continue;
if (used[to]) {
tree = false;
continue;
}
dfs(to, v, g, used);
}
}
int main() {
ios_base::sync_with_stdio(0);
int n, m;
cin >> n >> m;
vector<vector<int> > g(n);
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
b--, a--;
g[a].push_back(b);
g[b].push_back(a);
}
int ans = 0;
vector<bool> used(n, false);
for (int i = 0; i < n; i++) {
if (!used[i]) {
tree = true;
dfs(i, -1, g, used);
if (tree) {
ans++;
}
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool myfunction(int i, int j) { return (i > j); }
bool visit[100000 + 5];
vector<long long int> graph[100000 + 5];
long long int ans;
void initialize(long long int n) {
long long int i;
for (i = 0; i < n + 2; i++) visit[i] = false;
}
void dfs(long long int s, long long int parent) {
visit[s] = true;
long long int i;
for (i = 0; i < graph[s].size(); i++) {
if (visit[graph[s][i]] == false) {
dfs(graph[s][i], s);
} else if (graph[s][i] != parent)
ans = 1;
}
return;
}
int main() {
long long int n, i, m;
cin >> n >> m;
long long int a, b;
initialize(n);
for (i = 0; i < m; i++) {
cin >> a >> b;
graph[a].push_back(b);
graph[b].push_back(a);
}
a = 0;
ans = 0;
for (i = 1; i < n + 1; i++) {
if (visit[i] == false) {
dfs(i, 0);
if (ans != 1) a++;
ans = 0;
}
}
cout << a;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxm = 1e5 + 5;
int pre[maxm];
bool mark[maxm];
int n, m;
int ffind(int x) { return pre[x] == x ? x : pre[x] = ffind(pre[x]); }
signed main() {
for (int i = 0; i < maxm; i++) {
pre[i] = i;
}
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int a, b;
cin >> a >> b;
int x = ffind(a);
int y = ffind(b);
if (x != y) {
pre[x] = y;
mark[y] |= mark[x];
} else {
mark[x] = 1;
}
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (pre[i] == i) {
if (!mark[i]) ans++;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
class Node {
public:
int data;
int state;
int state1;
list<Node*> near;
};
void mark(Node* node, int st) {
if (node->state == 0) {
node->state = st;
} else {
return;
}
for (list<Node*>::iterator it = node->near.begin(); it != node->near.end();
++it) {
mark(*it, st);
}
}
bool is_cycle(Node* node, int st, int st1) {
bool result = false;
if (node->state == st) {
if (node->state1 == 0) {
node->state1 = st1;
for (list<Node*>::iterator it = node->near.begin();
it != node->near.end(); ++it) {
result = result || is_cycle(*it, st, st1 + 1);
}
} else {
if (abs(node->state1 - st1) > 2) {
return true;
}
}
}
return result;
}
int main() {
int n, m;
cin >> n >> m;
vector<Node*> a(n + 1);
for (int i = 1; i <= n; i++) {
a[i] = new Node();
a[i]->data = i;
a[i]->state = 0;
a[i]->state1 = 0;
}
int a1, a2;
for (int i = 0; i < m; i++) {
cin >> a1 >> a2;
a[a1]->near.push_back(a[a2]);
a[a2]->near.push_back(a[a1]);
}
int count = 0;
for (int i = 1; i <= n; i++) {
if (a[i]->state == 0) {
mark(a[i], count + 1);
count++;
}
}
int cur = 1;
int cycle = 0;
int k = 1;
while (k <= n) {
if (a[k]->state == cur) {
if (is_cycle(a[k], cur, 1)) {
cycle++;
}
cur++;
}
k++;
}
cout << count - cycle;
return 0;
}
|
#include <bits/stdc++.h>
bool visited[100001];
using namespace std;
class Graph {
int V;
public:
Graph(int V);
void addEdge(int v, int w);
bool isCyclicUtil(int v, bool visited[], int parent);
list<int> *adj;
};
Graph::Graph(int V) {
this->V = V;
adj = new list<int>[V];
}
void Graph::addEdge(int v, int w) {
adj[v].push_back(w);
adj[w].push_back(v);
}
bool Graph::isCyclicUtil(int v, bool visited[], int parent) {
visited[v] = true;
list<int>::iterator i;
for (i = adj[v].begin(); i != adj[v].end(); ++i) {
if (!visited[*i]) {
if (isCyclicUtil(*i, visited, v)) return true;
} else if (*i != parent)
return true;
}
return false;
}
int main() {
memset(visited, 0, false);
int n, m, x, y, ans = 0, i;
cin >> n >> m;
Graph g(n);
for (i = 0; i < m; i++) {
cin >> x >> y;
x--;
y--;
g.addEdge(x, y);
}
for (i = 0; i < n; i++) {
if (!visited[i]) {
if (!g.isCyclicUtil(i, visited, -1))
ans++;
else if (g.adj[i].size() == 0)
ans++;
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long val;
vector<long long> g[100100];
bool vis[100100];
void dfs(long long start, long long parent) {
vis[start] = true;
for (long long x : g[start])
if (!vis[x])
dfs(x, start);
else if (parent != x)
val = 0;
}
int main() {
long long n, m, ans = 0, u, v;
cin >> n >> m;
for (long long i = 0; i < m; i++) {
cin >> u >> v;
u--, v--;
g[u].push_back(v);
g[v].push_back(u);
}
for (long long i = 0; i < n; i++)
if (!vis[i]) {
val = 1;
dfs(i, -1);
ans += val;
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
namespace io {
char buf[1 << 15], *__S = buf, *__T = buf;
inline int F() {
register int aa = 0;
register bool bb = 0;
register char ch;
while (ch = (__S == __T && (__T = (__S = buf) + fread(buf, 1, 1 << 15, stdin),
__S == __T)
? 0
: *__S++),
(ch > '9' || ch < '0') && ch != '-')
;
ch == '-' ? bb = 1 : aa = ch - '0';
while (ch = (__S == __T && (__T = (__S = buf) + fread(buf, 1, 1 << 15, stdin),
__S == __T)
? 0
: *__S++),
ch <= '9' && ch >= '0')
aa = (aa << 1) + (aa << 3) + ch - '0';
return bb ? -aa : aa;
}
} // namespace io
namespace CJCJLLL {
using namespace io;
int last[100010], edgecnt;
struct EDGE {
int to, next;
} edge[200010];
inline void ae(register int u, register int v) {
edge[++edgecnt] = (EDGE){v, last[u]}, last[u] = edgecnt,
edge[++edgecnt] = (EDGE){u, last[v]}, last[v] = edgecnt;
}
int vis[100010], fa[100010];
bool noans[100010];
inline void DFS(register int pos) {
for (register int i = last[pos], to; i; i = edge[i].next) {
if (!vis[to = edge[i].to]) {
fa[to] = pos;
vis[to] = vis[pos];
DFS(to);
} else if (vis[to] == vis[pos] && to != fa[pos])
noans[vis[pos]] = 1;
}
}
inline void main() {
register int n = F(), m = F(), blk = 0, ans = 0;
for (register int i = 1; i <= m; ++i) ae(F(), F());
memset(noans, 0, sizeof noans);
for (register int i = 1; i <= n; ++i) {
if (!vis[i]) {
vis[i] = ++blk;
DFS(i);
}
}
for (register int i = 1; i <= blk; ++i)
if (!noans[i]) ++ans;
printf("%d\n", ans);
}
} // namespace CJCJLLL
int main() {
CJCJLLL ::main();
fclose(stdin), fclose(stdout);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100007;
int used[N], COLOR[N];
vector<int> g[N];
void dfs(int v, int color) {
used[v] = 1;
COLOR[v] = color;
for (int to : g[v]) {
if (used[to]) {
continue;
}
dfs(to, color);
}
}
int comp[N];
void dfs(int v, int p, int& found) {
used[v] = 1;
comp[COLOR[v]] = 1;
for (int to : g[v]) {
if (to == p) {
continue;
}
if (used[to]) {
found = 1;
return;
}
dfs(to, v, found);
}
}
int n, m, x, y;
int total;
int found, ans;
int main() {
cin >> n >> m;
while (m--) {
scanf("%d %d", &x, &y);
x--;
y--;
g[x].push_back(y);
g[y].push_back(x);
}
for (int i = 0; i < n; i++) {
if (used[i]) {
continue;
}
total++;
dfs(i, total);
}
memset(used, 0, sizeof used);
for (int i = 0; i < n; i++) {
if (comp[COLOR[i]]) {
continue;
}
found = 0;
dfs(i, -1, found);
if (!found) {
continue;
}
ans++;
}
cout << total - ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int used[100001];
vector<int> g[100001];
bool dfs(int v, int u = 0) {
used[v] = 1;
for (auto to : g[v]) {
if (to == u || used[to] == 2) continue;
if (!used[to]) {
if (dfs(to, v)) return true;
continue;
}
return true;
}
return false;
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int v, u;
cin >> v >> u;
g[v].push_back(u);
g[u].push_back(v);
}
int res = 0;
for (int i = 1; i <= n; i++) {
if (!used[i]) {
if (!dfs(i)) {
res++;
}
}
}
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
bool mark[N];
vector<int> G[N];
bool DFS(int r, int pr) {
mark[r] = true;
for (int u : G[r])
if (!mark[u]) {
if (DFS(u, r)) return true;
} else if (u != pr)
return true;
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int n, m;
cin >> n >> m;
while (m--) {
int x, y;
cin >> x >> y;
x--, y--;
G[x].push_back(y), G[y].push_back(x);
}
int ans = 0;
for (int i = 0; i < n; i++)
if (!mark[i]) ans += (!DFS(i, -1));
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void addEdge(vector<long long> adj[], long long u, long long v) {
adj[u].push_back(v);
adj[v].push_back(u);
}
void DFSUtil(vector<long long> adj[], long long v, bool visited[]) {
visited[v] = true;
for (long long i = 0; i < adj[v].size(); ++i)
if (!visited[adj[v][i]]) DFSUtil(adj, adj[v][i], visited);
}
long long f1(vector<long long> adj[], long long n) {
bool* visited = new bool[n];
long long count = 0;
for (long long v = 0; v < n; v++) visited[v] = false;
for (long long v = 0; v < n; v++) {
if (visited[v] == false) {
DFSUtil(adj, v, visited);
count += 1;
}
}
return count;
}
bool isCyclicUtil(vector<long long> adj[], long long v, bool visited[],
long long parent) {
bool flag = false;
visited[v] = true;
for (long long i = 0; i < adj[v].size(); ++i) {
if (!visited[adj[v][i]]) {
if (isCyclicUtil(adj, adj[v][i], visited, v)) flag = true;
} else if (adj[v][i] != parent)
flag = true;
}
return flag;
}
long long isCyclic(vector<long long> adj[], long long n) {
bool* visited = new bool[n];
for (long long i = 0; i < n; i++) visited[i] = false;
long long ans = 0;
for (long long u = 0; u < n; u++) {
if (!visited[u]) {
if (isCyclicUtil(adj, u, visited, -1)) {
ans++;
}
}
}
return ans;
}
void solve() {
long long n, m;
cin >> n >> m;
vector<long long> adj[n];
for (long long i = 0; i < m; i++) {
long long x, y;
cin >> x >> y;
x--;
y--;
adj[x].push_back(y);
adj[y].push_back(x);
}
long long x = f1(adj, n);
long long y = isCyclic(adj, n);
cout << x - y << endl;
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> tu[200001];
bool biaoji[200001];
int jiance = 0;
void dfs(int gen, int die) {
if (biaoji[gen]) {
jiance = 1;
return;
}
biaoji[gen] = 1;
for (int a = 0; a < tu[gen].size(); a++) {
if (tu[gen][a] == die) continue;
dfs(tu[gen][a], gen);
}
}
int main() {
int n, m;
cin >> n >> m;
int q, w;
for (int a = 1; a <= m; a++) {
scanf("%d%d", &q, &w);
tu[q].push_back(w);
tu[w].push_back(q);
}
int js = 0;
for (int a = 1; a <= n; a++) {
if (biaoji[a]) continue;
jiance = 0;
dfs(a, 0);
if (!jiance) js++;
}
cout << js;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, comp_num;
vector<vector<int> > g;
vector<bool> used;
vector<vector<int> > comp;
vector<long long int> dv;
vector<long long int> dv_in_comp;
vector<int> components;
void dfs(int v) {
used[v] = true;
comp[comp.size() - 1].push_back(v);
dv_in_comp[dv_in_comp.size() - 1] += dv[v];
for (int i = 0; i < g[v].size(); i++) {
int to = g[v][i];
if (!used[to]) dfs(to);
}
}
void find_comps() {
for (int i = 0; i < n; i++) {
if (!used[i]) {
comp.push_back(vector<int>());
dv_in_comp.push_back(0);
dfs(i);
}
}
}
int main() {
cin >> n >> m;
g.resize(n);
dv.resize(n, 0);
used.resize(n, false);
components.resize(n, -1);
int ui, vi;
for (int i = 0; i < m; i++) {
scanf("%d%d", &ui, &vi);
ui--;
vi--;
g[ui].push_back(vi);
g[vi].push_back(ui);
dv[ui]++;
dv[vi]++;
}
find_comps();
int total = 0;
for (int i = 0; i < comp.size(); i++) {
if (dv_in_comp[i] > 2 * (comp[i].size() - 1)) {
total += 0;
} else
total++;
}
cout << total;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double PI = acos(-1);
const long long MOD = 1000000007;
const long long FMOD = 998244353;
vector<long long> v[100005];
long long visited[100005];
bool isCycle(long long src, long long par) {
visited[src] = 1;
for (auto x : v[src]) {
if (!visited[x]) {
if (isCycle(x, src)) return true;
} else {
if (x != par) return true;
}
}
return false;
}
signed main() {
long long n, m;
cin >> n >> m;
for (long long i = 0; 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 (long long i = 1; i <= n; i++) {
if (!visited[i]) {
if (!isCycle(i, -1)) {
ans++;
}
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
long long cnt, cnt_e;
vector<int> g[100001];
int vis[100001];
int flag = 0;
void dfs(int first, int p) {
vis[first] = 1;
for (int u : g[first]) {
if (!vis[u])
dfs(u, first);
else if (vis[u] && u != p)
flag = 1;
}
}
int main() {
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 ans = 0;
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
flag = 0;
dfs(i, -1);
if (!flag) ans++;
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int NUM = 2e5 + 5;
long long int n, m;
vector<long long int> g[NUM];
bool vis[NUM];
long long int siz, edges;
void dfs(long long int node) {
vis[node] = 1;
siz++;
edges += g[node].size();
for (auto x : g[node]) {
if (!vis[x]) dfs(x);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int num_tests = 1;
while (num_tests-- > 0) {
cin >> n >> m;
for (long long int i = 0; i < m; i++) {
long long int x, y;
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
memset(vis, 0, sizeof(vis));
long long int ans = 0;
for (long long int i = 1; i < n + 1; i++) {
if (!vis[i]) {
siz = 0, edges = 0;
dfs(i);
edges = edges / 2;
if (edges == siz - 1) ans++;
}
}
cout << ans;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int ans = 0;
int ans1;
bool vis[100005];
vector<int> vec[100005];
void dfs(int pos, int pre) {
if (vis[pos]) {
ans1 = 0;
return;
}
vis[pos] = 1;
for (int i = 0; i < vec[pos].size(); i++) {
if (vec[pos][i] != pre) dfs(vec[pos][i], pos);
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d%d", &a, &b);
vec[a].push_back(b);
vec[b].push_back(a);
}
for (int i = 1; i <= n; i++) {
if (vis[i])
continue;
else {
ans1 = 1;
dfs(i, 0);
ans = ans + ans1;
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
int dh[4] = {0, 1, 0, -1};
int dv[4] = {-1, 0, 1, 0};
using namespace std;
int cycle, vis[100006], ans, m;
vector<int> v[100006];
void dfs(int x, int last) {
if (vis[x]) {
cycle = 0;
return;
}
vis[x] = 1;
for (int i = 0; i < v[x].size(); i++)
if (last != v[x][i]) dfs(v[x][i], x);
}
int main() {
int n, a, b;
cin >> n >> m;
for (int i = 0; i < m; i++) {
scanf("%d", &a);
scanf("%d", &b);
v[a].push_back(b);
v[b].push_back(a);
}
for (int i = 1; i <= int(n); i++)
if (!vis[i]) {
cycle = 1;
dfs(i, -1);
ans += cycle;
}
printf("%d", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> g[100000 + 10];
int vis[100000 + 10], n, m, ans;
void dfs(int pos, int p) {
if (vis[pos]) {
ans = 0;
return;
}
vis[pos] = 1;
for (int i = 0; i < g[pos].size(); i++) {
if (g[pos][i] != p) dfs(g[pos][i], pos);
}
}
int main() {
while (scanf("%d%d", &n, &m) != EOF) {
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= n; i++) g[i].clear();
int x, y;
for (int i = 0; i < m; i++) {
scanf("%d%d", &x, &y);
g[x].push_back(y);
g[y].push_back(x);
}
int sum = 0;
for (int i = 1; i <= n; i++) {
if (vis[i]) continue;
ans = 1;
dfs(i, 0);
sum += ans;
}
printf("%d\n", sum);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 2147483647;
const double PI = acos(-1.0);
const double e = 2.718281828459;
const int mod = 1000000007;
vector<int> vc[100005];
int vis[100005];
int ans, s;
void dfs(int pos, int pre) {
if (vis[pos]) {
ans = 0;
return;
}
vis[pos] = 1;
for (int i = 0; i < vc[pos].size(); ++i) {
if (vc[pos][i] != pre) dfs(vc[pos][i], pos);
}
}
int main() {
int n, m, i, j;
int x, y;
while (~scanf("%d%d", &n, &m)) {
for (i = 1; i <= n; ++i) vc[i].clear();
for (i = 1; i <= m; ++i) {
scanf("%d%d", &x, &y);
vc[x].push_back(y);
vc[y].push_back(x);
}
s = 0;
memset(vis, 0, sizeof(vis));
for (i = 1; i <= n; ++i) {
ans = 1;
if (!vis[i]) {
dfs(i, 0);
s += ans;
}
}
printf("%d\n", s);
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > g;
vector<bool> used;
vector<int> color;
vector<vector<int> > answer(4);
int counter = 0;
void dfs(int &v) {
used[v] = true;
color[v] = counter;
for (int i = 0; i < g[v].size(); i++) {
if (!used[g[v][i]]) dfs(g[v][i]);
}
}
int main() {
int n, m;
cin >> n >> m;
used.resize(n);
g.resize(n);
color.resize(n);
int a, b;
for (int i = 0; i < m; i++) {
cin >> a >> b;
g[a - 1].push_back(b - 1);
g[b - 1].push_back(a - 1);
}
for (int i = 0; i < n; i++) {
if (!used[i]) {
dfs(i);
counter++;
}
}
answer.resize(counter);
for (int i = 0; i < n; i++) {
answer[color[i]].push_back(i);
}
int counter = 0, z = 0;
for (int i = 0; i < answer.size(); i++) {
int e = answer[i].size();
int deg = 0;
for (int j = 0; j < answer[i].size(); j++) {
int v = answer[i][j];
deg += g[v].size();
}
if ((deg / 2) < e) z++;
}
cout << z;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 100000 + 5;
vector<int> v[M];
bool vis[M];
bool f;
void dfs(int x, int w) {
vis[x] = 1;
for (int i = 0; i < v[x].size(); i++) {
int y = v[x][i];
if (y == w) continue;
if (vis[y] == 1) {
f = 0;
continue;
}
dfs(y, x);
}
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
v[x].push_back(y);
v[y].push_back(x);
}
f = 1;
int ans = 0;
for (int i = 1; i <= n; i++) {
if (vis[i] == 0) {
dfs(i, i);
if (f) {
ans++;
}
f = 1;
}
}
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> v[100000 + 1];
long long n, m;
long long taken[100000 + 1];
map<int, int> v2;
int check = 0, sum;
void bfs() {
queue<long long> q;
long long j, x, y;
for (int i = 1; i <= n; i++) {
if (taken[i] == 0) {
q.push(i);
check = 0;
while (!q.empty()) {
x = q.front();
q.pop();
v2[x] = 1;
for (j = 0; j < v[x].size(); j++) {
y = v[x][j];
if (taken[y] == 0) {
q.push(y);
taken[y] = 1;
} else if (taken[y] == 1 && v2[y] == 0) {
check = 1;
}
}
}
if (check == 0) {
sum = sum + 1;
}
}
}
}
int main() {
long long i, x, y;
cin >> n >> m;
for (i = 1; i <= m; i++) {
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
sum = 0;
bfs();
cout << sum << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long> a[100010];
bool visited[100010] = {0};
bool dfs(long x, long parent) {
visited[x] = true;
vector<long>::iterator i;
for (i = a[x].begin(); i != a[x].end(); ++i) {
if (!visited[*i]) {
if (dfs(*i, x)) return true;
} else if (*i != parent)
return true;
}
return false;
}
int main() {
long n, m;
cin >> n >> m;
for (long i = 0; i < m; i++) {
long u, v;
cin >> u >> v;
a[v].push_back(u);
a[u].push_back(v);
}
long count = 0;
for (long i = 1; i <= n; i++) {
if (!visited[i]) {
if (!dfs(i, 0)) count++;
}
}
cout << count;
}
|
#include <bits/stdc++.h>
using namespace std;
int const M = 200005;
map<int, int> mp;
bool vis[M];
vector<int> v[M];
int dsu[M], s[M], n, T, m, k, p, ans, x[M], y[M], dse[M];
int find(int i) {
if (dsu[i] == i) return i;
return dsu[i] = find(dsu[i]);
}
void dfs(int n) {
if (vis[n]) return;
vis[n] = 1;
for (int i = 0; i < v[n].size(); ++i) {
int w = v[n][i];
if (vis[w] == 0) {
++T;
dfs(w);
}
}
}
int main() {
cin >> n >> m;
for (int i = 1; i <= n; ++i) dsu[i] = i;
for (int i = 1; i <= m; ++i) {
int a, b;
cin >> x[i] >> y[i];
v[x[i]].push_back(y[i]);
v[y[i]].push_back(x[i]);
a = find(x[i]);
b = find(y[i]);
dsu[a] = b;
if (a != b) dse[b] += dse[a];
a = find(a);
++dse[a];
}
for (int i = 1; i <= n; ++i) {
T = 1;
if (vis[i] == 0) {
dfs(i);
if (T >= dse[find(i)]) ans += T - dse[find(i)];
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Data {
int x, y;
} par[100001];
int n, m, x, y, cnt;
int rnk[100001];
void make_set(int v) { par[v].x = v; }
int find_set(int v) {
if (v == par[v].x) return v;
return par[v].x = find_set(par[v].x);
}
void set_union(int a, int b) {
a = find_set(a);
b = find_set(b);
if (a != b) {
if (rnk[a] < rnk[b]) swap(a, b);
par[b].x = a;
par[a].y += par[b].y;
if (rnk[a] == rnk[b]) rnk[a]++;
} else
par[a].y = 1;
}
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) make_set(i);
for (int i = 1; i <= m; i++) {
scanf("%d %d", &x, &y);
set_union(x, y);
}
for (int i = 1; i <= n; i++)
if (par[i].x == i)
if (!par[i].y) cnt++;
cout << cnt;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class X, class Y>
void minimize(X &x, const Y &y) {
if (x > y) x = y;
}
template <class X, class Y>
void maximize(X &x, const Y &y) {
if (x < y) x = y;
}
class DisjointSet {
private:
vector<int> label;
public:
DisjointSet() {}
DisjointSet(int n) { label.assign(n + 7, -1); }
int find(int x) {
if (label[x] < 0) return (x);
label[x] = find(label[x]);
return (label[x]);
}
bool join(int a, int b) {
int x = find(a);
int y = find(b);
if (x == y) return (false);
if (label[x] > label[y]) swap(x, y);
label[x] += label[y];
label[y] = x;
return (true);
}
int getSize(int x) { return (-label[find(x)]); }
};
int cntEdge[200200];
int n, m;
pair<int, int> edge[200200];
void init(void) {
scanf("%d%d", &n, &m);
for (int i = (1), _b = (m); i <= _b; i = i + 1)
scanf("%d%d", &edge[i].first, &edge[i].second);
}
void process(void) {
DisjointSet dsu(n);
for (int i = (1), _b = (m); i <= _b; i = i + 1)
dsu.join(edge[i].first, edge[i].second);
for (int i = (1), _b = (m); i <= _b; i = i + 1)
cntEdge[dsu.find(edge[i].first)]++;
int numTree = 0;
for (int i = (1), _b = (n); i <= _b; i = i + 1)
if (dsu.find(i) == i && cntEdge[i] < dsu.getSize(i)) numTree++;
printf("%d\n", numTree);
}
int main(void) {
init();
process();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
bool val = 0;
vector<int> adj[N];
bool vis[N];
void solve(int u, int v) {
if (vis[u]) {
val = 1;
return;
}
vis[u] = 1;
for (int i = 0; i < adj[u].size(); i++) {
if (adj[u][i] != v) {
solve(adj[u][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);
adj[u].push_back(v);
adj[v].push_back(u);
}
int cnt = 0;
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
val = 0;
solve(i, 0);
if (!val) {
cnt++;
}
}
}
cout << cnt << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using namespace std::chrono;
long long fac[1000006];
inline long long exp(long long x, long long n) {
long long r = 1;
x = x;
while (n) {
if (n % 2) r = (r * x) % 1000000007;
x = (x * x) % 1000000007;
n = n / 2;
}
return r;
}
inline long long mmi(long long a) {
return exp(a, 1000000007 - 2) % 1000000007;
}
inline long long fact(long long n) {
long long res = 1;
for (long long i = 1; i < (n + 1); ++i) {
res = (res * i) % 1000000007;
}
return res;
}
inline void fact_a() {
fac[0] = 1;
fac[1] = 1;
for (long long i = 1; i < (105); ++i) {
fac[i] = (fac[i - 1] * i) % 1000000007;
}
}
inline long long inv_fact(long long n) {
long long par = fac[n];
long long res = mmi(par);
return res;
}
inline long long comb(long long n, long long r) {
if (n == r && r == 0) return 1;
if (n < r) return 0;
return ((fac[n] * inv_fact(r)) % 1000000007 * inv_fact(n - r)) % 1000000007;
}
struct triplet {
long long a, b, c;
};
bool operator<(const triplet &t1, const triplet &t2) {
if (t1.a < t2.a) return true;
if (t1.a == t2.a && t1.b < t2.b) return true;
if (t1.a == t2.a && t1.b == t2.b && t1.c < t2.c) return true;
return false;
}
pair<long long, pair<long long, long long> > ex_gcd(long long a, long long b) {
if (b == 0) {
return make_pair(a, make_pair(1, 0));
}
pair<long long, pair<long long, long long> > p = ex_gcd(b, a % b);
long long gcd = p.first;
long long x1 = p.second.first;
long long y1 = p.second.second;
long long x = y1;
long long y = x1 - (a / b) * y1;
return make_pair(gcd, make_pair(x, y));
}
long long prime[3000006];
long long spf_prime[3000006];
void sieve() {
prime[1] = 1;
for (long long i = 2; i * i <= 3000000; i++)
if (prime[i] == 0)
for (long long j = i * i; j <= 3000000; j += i) prime[j] = 1;
}
void spf() {
for (long long i = 2; i * i <= 3000000; i++)
if (!spf_prime[i])
for (long long j = i * i; j <= 3000000; j += i)
if (!spf_prime[j]) spf_prime[j] = i;
for (long long i = 2; i <= 3000000; i++)
if (!spf_prime[i]) spf_prime[i] = i;
}
long long getparent_BIT(long long idx) { return idx - (idx & -idx); }
long long getnext_BIT(long long idx) { return idx + (idx & -idx); }
long long getsum_BIT(long long idx, long long BIT[], long long n) {
long long sum = 0;
while (idx > 0) {
sum += BIT[idx];
idx = getparent_BIT(idx);
}
return sum;
}
void update_BIT(long long idx, long long BIT[], long long val, long long n) {
while (idx <= n) {
BIT[idx] += val;
idx = getnext_BIT(idx);
}
}
void build_BIT(long long BIT[], long long a[], long long n) {
for (long long i = 0; i < (n); ++i) {
update_BIT(i, BIT, a[i], n);
}
}
void comp_lps(string s, long long lps[], long long n) {
long long i = 1, j = 0;
while (i < n) {
if (s[i] == s[j]) {
lps[i++] = ++j;
} else {
if (j != 0)
j = lps[j - 1];
else
lps[i++] = 0;
}
}
}
void dfs_l(long long u, vector<vector<long long> > &adj, long long status[]) {
if (status[u] == 1) return;
status[u] = 1;
for (long long i = 0; i < (adj[u].size()); ++i) dfs_l(adj[u][i], adj, status);
}
long long dij(long long u, long long n,
vector<vector<pair<long long, long long> > > &adj,
long long status[]) {
long long dist[n];
for (long long i = 0; i < (n); ++i) dist[i] = 1000000000;
dist[0] = 0;
priority_queue<pair<long long, long long>,
vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
q;
q.push(make_pair(0, 0));
while (!q.empty()) {
pair<long long, long long> p;
p = q.top();
q.pop();
long long x = p.second;
long long w = p.first;
if (status[x] == 1) continue;
status[x] = 1;
for (long long i = 0; i < (adj[x].size()); ++i) {
long long ww = adj[x][i].first;
long long y = adj[x][i].second;
if (dist[x] + ww < dist[y]) {
dist[y] = dist[x] + ww;
q.push(make_pair(dist[y], y));
}
}
}
if (dist[n - 1] >= 1000000000) return -1;
return dist[n - 1];
}
long long phi(long long n) {
vector<long long> v;
long long k = n;
;
for (long long i = 2; i * i <= n; i++) {
if (k % i == 0) {
v.push_back(i);
while (k % i == 0) k /= i;
}
}
if (k > 1) v.push_back(k);
long long ans = n;
for (long long i = 0; i < (v.size()); ++i) ans -= (ans / v[i]);
return ans;
}
struct trie {
struct trie *left, *right;
bool isend;
};
trie *get_trie() {
trie *ptr = new trie;
ptr->left = NULL;
ptr->right = NULL;
ptr->isend = false;
return ptr;
}
bool isempty(trie *root) {
if (root->left == NULL && root->right == NULL) return true;
return false;
}
void insert_trie(trie *root, string key) {
trie *ptr = root;
for (long long i = 0; i < (key.size()); ++i) {
if (key[i] == '0') {
if (ptr->left == NULL) {
ptr->left = get_trie();
}
ptr = ptr->left;
} else {
if (ptr->right == NULL) ptr->right = get_trie();
ptr = ptr->right;
}
}
ptr->isend = true;
}
trie *remove_trie(trie *root, string key, long long idx = 0) {
if (root == NULL) return NULL;
if (idx == key.size()) {
if (isempty(root)) {
delete (root);
root = NULL;
}
return root;
}
if (key[idx] == '0')
root->left = remove_trie(root->left, key, idx + 1);
else
root->right = remove_trie(root->right, key, idx + 1);
if (isempty(root)) {
delete (root);
root = NULL;
}
return root;
}
long long search_trie(trie *root, string key) {
trie *ptr = root;
string s = "";
for (long long i = 0; i < (key.size()); ++i) {
if (key[i] == '0') {
if (ptr->right != NULL) {
ptr = ptr->right;
s += '1';
} else {
ptr = ptr->left;
s += '0';
}
} else {
if (ptr->left != NULL) {
ptr = ptr->left;
s += '1';
} else {
ptr = ptr->right;
s += '0';
}
}
}
long long res = 0;
reverse(s.begin(), s.end());
for (long long i = s.length() - 1; i >= (0); --i)
res = res * 2 + (s[i] - '0');
return res;
}
struct Comp {
bool operator()(const std::pair<int, int> &a, const std::pair<int, int> &b) {
if (a.first != b.first) {
return a.first < b.first;
}
return a.second > b.second;
}
};
void dearr() {
long long dar[1005];
dar[0] = 1;
dar[1] = 0;
dar[2] = 1;
for (long long i = 3; i < (1002); ++i) {
dar[i] = (i - 1) * (dar[i - 1] + dar[i - 2]);
}
}
long long siz[2];
long long parent[2];
void make_set(long long v) {
parent[v] = v;
siz[v] = 1;
}
long long find_set(long long v) {
if (v == parent[v]) return v;
return find_set(parent[v]);
}
void union_set(long long a, long long b) {
a = find_set(a);
b = find_set(b);
if (a != b) {
if (siz[a] < siz[b]) swap(a, b);
parent[b] = a;
siz[a] += siz[b];
}
}
void rec(long long u, vector<vector<long long> > &adj, long long status[],
long long par, long long &cc, long long &val) {
if (status[u] == 1) {
cc = 1;
return;
}
status[u] = 1;
val += 1;
for (long long i = 0; i < (adj[u].size()); ++i) {
if (adj[u][i] == par) continue;
rec(adj[u][i], adj, status, u, cc, val);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n, m;
cin >> n >> m;
vector<vector<long long> > adj(n);
for (long long i = 0; i < (m); ++i) {
long long x, y;
cin >> x >> y;
x--;
y--;
adj[x].push_back(y);
adj[y].push_back(x);
}
long long dp[n + 5];
memset(dp, -1, sizeof(dp));
long long status[n + 5];
memset(status, 0, sizeof(status));
vector<long long> val(n + 5, 0);
long long ans = 0;
for (long long i = 0; i < (n); ++i) {
long long cc = 0;
long long val = 0;
if (status[i] == 0) {
rec(i, adj, status, -1, cc, val);
if (cc == 1)
ans += val;
else
ans += (val - 1);
}
}
cout << n - ans << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
const int mod = 1e9 + 7;
const int inf = 0x3fffffff;
int father[maxn], cnt[maxn];
int k[maxn], l[maxn];
int n, m;
void initial() {
for (int i = 1; i <= maxn; i++) father[i] = i;
}
int findFather(int x) {
int a = x;
while (x != father[x]) x = father[x];
while (a != father[a]) {
int z = a;
a = father[a];
father[z] = x;
}
return x;
}
void Union(int a, int b) {
int faA = findFather(a);
int faB = findFather(b);
if (faA != faB) father[faA] = faB;
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
initial();
cin >> n >> m;
int a, b;
for (int i = 0; i < m; i++) {
cin >> a >> b;
cnt[a]++;
cnt[b]++;
Union(a, b);
}
for (int i = 1; i <= n; i++) {
int temp = findFather(i);
k[temp]++;
l[temp] += cnt[i];
}
int res = 0;
for (int i = 1; i <= n; i++) {
if (k[i] != 0)
if (k[i] > l[i] / 2) res++;
}
cout << res;
return ~~(0 - 0);
}
|
#include <bits/stdc++.h>
int dh[4] = {0, 1, 0, -1};
int dv[4] = {-1, 0, 1, 0};
using namespace std;
int cycle, vis[123456], ans, m;
vector<int> v[123456];
void dfs(int x, int last) {
if (vis[x]) {
cycle = 0;
return;
}
vis[x] = 1;
for (int i = 0; i < v[x].size(); i++)
if (last != v[x][i]) dfs(v[x][i], x);
}
int main() {
int n, a, b;
cin >> n >> m;
set<int> s;
for (int i = 0; i < m; i++) {
cin >> a >> b;
v[a].push_back(b);
v[b].push_back(a);
s.insert(a);
s.insert(b);
}
for (int i = 1; i <= int(n); i++) {
cycle = 1;
if (vis[i]) continue;
dfs(i, -1);
ans += cycle;
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<long long int>> v(100005);
long long int visited[100005] = {0};
long long int cnt = 0, sum = 0, sume = 0;
void dfs(long long int x) {
if (visited[x] == 0) {
sum++;
visited[x] = 1;
}
sume = sume + v[x].size();
long long int i, j, k, l;
for (i = 0; i < v[x].size(); i++) {
if (visited[v[x][i]] == 0) {
sum++;
visited[v[x][i]] = 1;
dfs(v[x][i]);
}
}
}
int main() {
long long int i, j, k, l, n, a, b, m;
cin >> n >> m;
for (i = 1; i <= m; i++) {
cin >> a >> b;
v[a].push_back(b);
v[b].push_back(a);
}
for (i = 1; i <= n; i++) {
if (visited[i] == 0) {
dfs(i);
if (sume / 2 == sum - 1) {
cnt++;
}
}
sum = 0;
sume = 0;
}
cout << cnt;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const int mod = 1e9 + 7;
int n, m, used[N], ans;
vector<int> g[N];
bool cycle;
void dfs(int v, int p = -1) {
used[v] = 1;
for (auto to : g[v]) {
if (to == p) continue;
if (used[to] == 1) cycle = 1;
if (used[to] == 0) dfs(to, v);
}
used[v] = 2;
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int a, b;
cin >> a >> b;
g[a].push_back(b);
g[b].push_back(a);
}
for (int i = 1; i <= n; i++)
if (used[i] == 0) {
cycle = 0;
dfs(i);
if (!cycle) ans++;
}
cout << ans;
return 0;
}
|
#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> par(100001);
long long int findp(long long int x) {
return par[x] == x ? x : par[x] = findp(par[x]);
}
vector<long long int> v(100001), e(100001);
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 = 1; i <= n; i++) par[i] = i;
vector<long long int> a(m);
for (long long int i = 0; i < m; i++) {
long long int y;
cin >> a[i] >> y;
par[findp(a[i])] = findp(y);
}
long long int ans = 0;
for (long long int i = 1; i <= n; i++) v[findp(i)]++;
for (long long int i = 0; i < m; i++) e[par[a[i]]]++;
for (long long int i = 1; i <= n; i++)
if (v[i] && v[i] - 1 == e[i]) ans++;
cout << ans;
}
rtime();
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;
if (flag[x] || flag[y] || flag[fx] || flag[fy])
flag[fy] = flag[fx] = flag[x] = flag[y] = true;
} else
flag[fy] = flag[fx] = flag[x] = flag[y] = true;
}
for (i = 1; i <= n; i++) {
if (find(i) == i && !flag[find(i)]) ans++;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int fa[N], 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] = 1;
} else
flag[fy] = flag[fx] = flag[x] = flag[y] = 1;
}
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;
const int N = 1e5 + 5;
struct edge {
int v, next;
} e[N * 2];
int n, m, eid, p[N], d[N];
void init() {
memset(p, -1, sizeof p);
eid = 0;
}
void insert(int u, int v) {
e[eid].v = v;
e[eid].next = p[u];
p[u] = eid++;
}
void insert2(int u, int v) {
insert(u, v);
insert(v, u);
}
int ans = 0, start, sum, num;
bool st[N];
void dfs(int u) {
st[u] = 1;
sum += d[u];
num++;
for (int i = p[u]; i + 1; i = e[i].next) {
int v = e[i].v;
if (!st[v]) dfs(v);
}
}
int main() {
init();
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
insert2(u, v);
d[u]++;
d[v]++;
}
for (int i = 1; i <= n; i++) {
if (st[i]) continue;
if (d[i] == 0)
ans++;
else {
if (d[i] == 1) {
num = sum = 0;
dfs(i);
if (num * 2 > sum) ans += (num * 2 - sum) / 2;
}
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int long long n, m, cycle = 0, x, y;
vector<vector<int long long> > a;
vector<int long long> vis;
void dfs(int long long i, int long long path) {
vis[i] = 1;
int long long to;
for (long long j = 0; j < a[i].size(); j++) {
to = a[i][j];
if (vis[to] == 1 && path != to)
cycle = 1;
else if (vis[to] != 1)
dfs(to, i);
}
}
int main() {
ios_base::sync_with_stdio(false);
int long long ans = 0;
cin >> n >> m;
a.resize(n);
vis.resize(n, 0);
for (long long i = 0; i < m; i++) {
cin >> x >> y;
x--;
y--;
a[y].push_back(x);
a[x].push_back(y);
}
for (long long i = 0; i < n; i++) {
cycle = 0;
if (vis[i] == 0) {
dfs(i, -1);
ans += 1 - cycle;
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 100009;
int n, m;
vector<pair<int, int> > E;
vector<vector<pair<int, int> > > g;
int idx[MAX], low[MAX], dfs = 1;
bool is[MAX] = {0};
int P[MAX];
int sz[MAX];
void DFS(int u, int p) {
low[u] = idx[u] = dfs++;
for (int i = 0; i < (int)g[u].size(); i++) {
int v = g[u][i].first;
int j = g[u][i].second;
if (idx[v] == 0) {
DFS(v, u);
low[u] = min(low[u], low[v]);
if (low[u] < idx[v]) {
is[j] = 1;
}
} else if (v != p) {
low[u] = min(low[u], idx[v]);
}
}
}
int find(int x) { return (x == P[x] ? x : P[x] = find(P[x])); }
int BFS(int src) {
bool ok = 0;
queue<int> Q;
idx[src] = 0;
Q.push(src);
while (!Q.empty()) {
int u = Q.front();
Q.pop();
for (int i = 0; i < (int)g[u].size(); i++) {
int v = g[u][i].first;
int c = g[u][i].second;
ok = ok || (is[c] == 0);
if (idx[v] == 0) {
idx[v] = 1;
Q.push(v);
}
}
}
return ok == false;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> m;
g.resize(n);
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
--u, --v;
g[u].push_back(make_pair(v, i));
g[v].push_back(make_pair(u, i));
E.push_back(make_pair(u, v));
}
memset(idx, 0, sizeof idx);
for (int i = 0; i < n; i++)
if (idx[i] == 0) DFS(i, -1);
for (int i = 0; i < n; i++) {
P[i] = i;
sz[i] = 1;
}
for (int i = 0; i < m; i++) {
if (!is[i]) {
int a = find(E[i].first);
int b = find(E[i].second);
P[a] = b;
sz[a] += sz[b];
}
}
int ans = 0;
memset(idx, 0, sizeof idx);
for (int i = 0; i < n; i++) {
if (idx[i] == 0) ans += BFS(i);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m;
cin >> n;
vector<long long> sm(n);
for (int i = 0; i < n; i++) {
cin >> sm[i];
}
sort(sm.begin(), sm.end());
long long now = 1;
for (int i = 0; i < sm.size(); i++) {
if (sm[i] >= now) sm[i] = now, now++;
}
cout << now;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const double PI = acos(-1.0);
const double E = exp(1);
const int N = 1e5 + 5;
int n;
map<long long, long long> m;
int main(void) {
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < n; i++) {
long long a;
cin >> a;
if (!m.count(a)) m[a] = 0;
m[a]++;
}
long long at = 0;
long long s;
long long f = 0;
for (map<long long, long long>::iterator it = m.begin(); it != m.end();
it++) {
s = it->first;
long long x = it->second;
at += s - f;
at = max(0LL, at - x);
f = s;
}
cout << s - at + 1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long p[100005];
int main() {
long long a, b, c, d, e, f;
cin >> a;
for (long long i = 0; i < a; i++) cin >> p[i];
sort(p, p + a);
long long j = 0;
for (long long i = 1; i <= a; i++) {
while (p[j++] < i && j < a)
;
if (j == a) {
if (p[j - 1] >= i)
cout << i + 1;
else
cout << i;
exit(0);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000 * 100 + 10;
int ary[N];
int val[N];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
scanf("%d", &ary[i]);
val[min(ary[i], N - 1)]++;
}
int sum = 0;
for (int i = 1; i < N; i++) {
if (val[i] == 0) {
sum++;
} else {
sum = max(0, sum - val[i] + 1);
}
}
cout << N - sum << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<int, int> chk;
int main() {
int n;
cin >> n;
int a[n + 5], mex = 1;
for (int i = 1; i <= n; i++) cin >> a[i], chk[a[i]]++;
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; i++) {
if (mex >= a[i]) {
if (mex == a[i]) mex++;
continue;
}
chk[a[i]]--;
a[i] = mex;
chk[a[i]]++;
mex++;
}
for (int i = 1; i <= n; i++) {
if (!chk[i]) {
cout << i << endl;
return 0;
}
}
cout << n + 1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; ++i) cin >> a[i];
a.push_back(0);
++n;
sort(a.begin(), a.end());
for (int i = 1; i < n; ++i) {
if ((a[i] == a[i - 1] + 1) || (a[i] == a[i - 1])) continue;
a[i] = a[i - 1] + 1;
}
cout << a.back() + 1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5;
int arr[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> arr[i];
}
sort(arr, arr + n);
int ans = 1;
for (int i = 0; i < n; ++i) {
if (arr[i] >= ans) {
++ans;
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int a[100005];
bool cmp(int a, int b) { return a < b; };
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
sort(a + 1, a + n + 1, cmp);
int now = 1;
for (int i = 1; i <= n; i++) {
now = min(a[i], now);
now++;
}
printf("%d", now);
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 10;
const int MOD = 1e9 + 7;
const int MAXN = 1e6 + 10;
const int SMAXN = 1e3 + 10;
const int P = 259;
const long long BINF = 1e18 + 10;
const long double EPS = 1e-10;
const long double PI = acos(-1);
int n, now;
vector<int> Vec;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
srand(time(0));
cin >> n;
Vec.resize(n);
for (register int i(0); i < n; i++) {
cin >> Vec[i];
}
sort((Vec).begin(), (Vec).end());
now = 1;
for (register int i(0); i < Vec.size(); i++) {
if (Vec[i] >= now) now++;
}
cout << now;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int arr[100000 + 10];
int n, bld = 1;
int main() {
std::ios::sync_with_stdio(false);
cin.tie();
cout.tie();
cin >> n;
for (int i = 0; i < n; i++) cin >> arr[i];
sort(arr, arr + n);
for (int i = 0; i < n; i++)
if (arr[i] >= bld) bld++;
cout << bld << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int compare(const void* a, const void* b) {
return (*(long long int*)a - *(long long int*)b);
}
int main() {
long long int n, i;
long long int arr[100002];
cin >> n;
for (i = 0; i < n; i++) {
cin >> arr[i];
}
qsort(arr, n, sizeof(long long int), compare);
long long int no;
no = 1;
for (i = 0; i < n; i++) {
if (arr[i] < no) no = arr[i];
no++;
}
cout << no << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int n, a[100100];
map<long long int, long long int> m;
int main() {
cin >> n;
int k = 1;
for (int i = 1; i <= n; i++) {
cin >> a[i];
m[a[i]]++;
}
sort(a + 1, a + 1 + n);
for (int i = 1; i <= n; i++) {
while (m[k] && k < a[i]) {
k++;
}
if (k < a[i]) {
m[a[i]]--;
m[k]++;
a[i] = k;
}
}
while (m[k]) k++;
cout << k << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
#pragma warning(disable : 4996)
int n;
scanf("%d", &n);
long long int a[100005];
for (int i = 0; i < n; i++) scanf("%I64d", &a[i]);
sort(a, a + n);
a[0] = 1;
for (int i = 1; i < n; i++) {
if (a[i] - a[i - 1] > 1) a[i] = a[i - 1] + 1;
}
if (n > 1)
printf("%I64d", a[n - 1] + 1);
else
printf("2");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int ara[n];
int temp = n;
int k = 0;
while (n--) {
cin >> ara[k++];
}
sort(ara, ara + temp);
queue<int> Q;
for (int i = 0; i < temp; i++) {
Q.push(ara[i]);
}
int i;
for (i = 1; i < 1000000; i++) {
while (!Q.empty() && Q.front() < i) {
Q.pop();
}
if (Q.empty()) break;
Q.pop();
}
cout << i << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> vec;
for (int i = 0; i < n; i++) {
int num;
cin >> num;
vec.push_back(num);
}
sort(vec.begin(), vec.end());
int start = 1;
set<int> s;
for (int i = 0; i < n; i++) {
if (vec[i] > start && s.find(start) == s.end()) {
vec[i] = start;
s.insert(start);
start++;
} else if (vec[i] == start && s.find(start) == s.end()) {
s.insert(start);
start++;
} else if (vec[i] == start && s.find(start) != s.end()) {
s.insert(start);
}
}
cout << start << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
while (cin >> n) {
int ara[n + 4];
map<int, bool> vis;
for (int i = 0; i < n; i++) {
cin >> ara[i];
}
sort(ara, ara + n);
int sum = 0;
for (int i = 0; i < n; i++) {
if (sum + 1 <= ara[i]) {
vis[ara[i] = sum + 1] = true;
sum += 1;
}
}
cout << sum + 1 << endl;
;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int dx[] = {1, 0, -1, 0};
int dy[] = {0, -1, 0, 1};
int a[100000];
int main() {
int n, current_no = 1;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
a[0] = 1;
for (int i = 1; i < n; i++)
if (a[i] > a[i - 1]) a[i] = a[i - 1] + 1;
cout << a[n - 1] + 1;
}
|
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
int IT_MAX = 1024;
const long long MOD = 1000000007;
const int INF = 1034567890;
const long long LL_INF = 3234567890123456789ll;
const double PI = acos(-1);
const long double ERR = 1E-13;
multiset<int> Mx;
int main() {
int N, i;
scanf("%d", &N);
while (N--) {
scanf("%d", &i);
Mx.insert(i);
}
for (i = 1; !Mx.empty(); i++) {
auto it = Mx.lower_bound(i);
if (it == Mx.end()) break;
Mx.erase(it);
}
return !printf("%d\n", i);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6;
vector<pair<long long, long long> > v;
map<string, int> mp;
bool cmp(pair<long long, long long> p, pair<long long, long long> q) {
if (p.first > q.first) return (q.second < p.second);
}
long long a[101000];
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, m, cnt = 1, b, ans = 0, ans2, x, y, k;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + n + 1);
cnt = 1;
for (int i = 1; i <= n; i++)
if (a[i] >= cnt) cnt++;
cout << cnt;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, j, i;
scanf("%d", &n);
int x[n];
for (i = 0; i < n; i++) {
scanf("%d", &x[i]);
}
sort(x, x + i);
int d = 1;
for (j = 0; j < n; j++) {
if (d <= x[j]) {
d++;
}
}
printf("%d", d);
}
|
#include <bits/stdc++.h>
using namespace std;
int a[100005];
int main() {
int n, i, ind;
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
sort(a + 1, a + n + 1);
ind = 1;
for (i = 1; i <= n; i++)
if (a[i] >= ind) {
a[i] = ind;
ind++;
}
printf("%d\n", ind);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n;
int arr[N];
multiset<int> mp;
int main() {
scanf("%d", &n);
mp.clear();
for (int i = 1; i <= n; ++i) {
scanf("%d", arr + i);
mp.insert(arr[i]);
}
for (int i = 1; i; ++i) {
if (mp.find(i) == mp.end()) {
auto it = mp.lower_bound(i);
if (it == mp.end()) {
cout << i << endl;
return 0;
}
mp.erase(it);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = numeric_limits<int>::max();
const long long LLINF = numeric_limits<long long>::max();
const unsigned long long ULLINF = numeric_limits<unsigned long long>::max();
const double PI = acos(-1.0);
int a[100010];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
int mex = 1;
for (int i = 0; i < n; i++) {
if (mex > a[i])
continue;
else
mex++;
}
cout << mex;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool SR(int &_x) { return scanf("%d", &_x) == 1; }
bool SR(long long &_x) { return scanf("%lld", &_x) == 1; }
bool SR(double &_x) { return scanf("%lf", &_x) == 1; }
bool SR(char *_s) { return scanf("%s", _s) == 1; }
bool RI() { return true; }
template <typename I, typename... T>
bool RI(I &_x, T &..._tail) {
return SR(_x) && RI(_tail...);
}
void SP(const int _x) { printf("%d", _x); }
void SP(const long long _x) { printf("%lld", _x); }
void SP(const double _x) { printf("%.16lf", _x); }
void SP(const char *s) { printf("%s", s); }
void PL() { puts(""); }
template <typename I, typename... T>
void PL(const I _x, const T... _tail) {
SP(_x);
if (sizeof...(_tail)) putchar(' ');
PL(_tail...);
}
int main() {
int n;
RI(n);
vector<int> v(n);
for (int i = 0; i < int(n); i++) RI(v[i]);
multiset<int> s((v).begin(), (v).end());
for (int i = (1); i <= int(n + 1); i++) {
auto it = s.lower_bound(i);
if (it == s.end()) {
PL(i);
return 0;
} else
s.erase(it);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 1e5 + 10;
int n, a[maxN], c[maxN], d[maxN], tot;
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i], c[i] = a[i];
sort(c, c + n);
tot = unique(c, c + n) - c;
for (int i = 0; i < n; i++) d[lower_bound(c, c + tot, a[i]) - c]++;
int ans = 0;
for (int i = 0; i < tot; i++) {
if (d[i] + ans > c[i])
ans = c[i];
else
ans += d[i];
}
cout << ans + 1;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
long long int a[n];
vector<long long int> v;
for (long long int i = 0; i < n; i++) {
cin >> a[i];
v.push_back(a[i]);
}
sort(a, a + n);
sort(v.begin(), v.end());
set<long long int> s(v.begin(), v.end());
if (n == s.size()) {
cout << n + 1 << endl;
return 0;
}
for (long long int i = 0; i < n; i++) {
if (i != n - 1) {
if (a[i + 1] - a[i] > 0) {
a[i + 1] = a[i] + 1;
if (a[i + 1] > i + 2) {
a[i + 1] = i + 2;
}
} else {
if (a[i] != i + 1) {
a[i] = i + 1;
}
}
}
if (i == n - 1) {
if (a[i] > i + 1) {
a[i] = i + 1;
}
}
}
cout << a[n - 1] + 1 << endl;
}
|
#include <bits/stdc++.h>
const long long MaxN = 1e5 + 50;
using namespace std;
int main() {
int n;
cin >> n;
long long a[n];
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
a[0] = 1;
for (int i = 1; i < n; i++)
if (a[i] - a[i - 1] > 1) a[i] = a[i - 1] + 1;
cout << a[n - 1] + 1;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long a[n];
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
a[0] = 1;
for (long long i = 0; i < n; i++) {
if (a[i] + 1 < a[i + 1]) {
a[i + 1] = a[i] + 1;
}
}
cout << a[n - 1] + 1 << endl;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:32000000")
using namespace std;
#pragma comment(linker, "/STACK:56777216")
void Out(const vector<int> &v) {
for (auto x : v) {
cout << x << " ";
}
cout << endl;
}
std::vector<std::string> &split(const std::string &s, char delim,
std::vector<std::string> &elems) {
std::stringstream ss(s);
std::string item;
while (std::getline(ss, item, delim)) {
elems.push_back(item);
}
return elems;
}
std::vector<std::string> split(const std::string &s, char delim) {
std::vector<std::string> elems;
split(s, delim, elems);
return elems;
}
int main() {
ios_base::sync_with_stdio(0);
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
sort(a.begin(), a.end());
vector<int> m;
m.push_back(1);
for (int i = 1; i < a.size(); ++i) {
m.push_back(min(m.back() + 1, a[i]));
}
cout << m.back() + 1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a[100005], x = 1;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
sort(a, a + n + 1);
for (int i = 1; i <= n; i++) {
if (a[i] >= x) x++;
}
cout << x;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, j = 1;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
for (int i = 0; i < n; i++)
if (a[i] >= j) j += 1;
cout << j;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n = 0;
scanf("%d", &n);
long long* ll = new long long[n];
int num = 0;
long long res = 0;
for (int i = 0; i < n; i++) {
scanf("%lld", &ll[i]);
if (ll[i] <= 0) {
num++;
}
}
sort(ll, ll + n);
for (int i = num; i < n; i++) {
if (ll[i] > res)
res++;
else
continue;
}
printf("%lld", res + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int power(long long int first, long long int n) {
if (n == 0)
return 1;
else if (n % 2 == 0) {
long long int second = power(first, n / 2);
return second * second;
} else
return first * power(first, n - 1);
}
int strTOint(string s) {
stringstream ss;
int first;
ss << s;
ss >> first;
return first;
}
double geo_dist(int a, int b, int c, int d) {
double dd = (double)(a - c) * (a - c) + (b - d) * (b - d);
double r = sqrt(dd) + 1e-9;
return r;
}
long long int bigmod(long long int a, long long int p, long long int m) {
if (p == 0) return 1 % m;
if (p % 2 == 0) {
long long int second = bigmod(a, p / 2, m);
return (second * second) % m;
} else {
return (a * bigmod(a, p - 1, m)) % m;
}
}
long long int first, second, d, g;
void ext_gcd(long long int a, long long int b) {
if (b == 0) {
first = 1;
second = 0;
d = a;
return;
}
ext_gcd(b, a % b);
long long int x1 = second;
long long int y1 = first - (a / b) * second;
first = x1;
second = y1;
}
long long int modInv(long long int a, long long int m) {
ext_gcd(a, m);
first %= m;
if (first < 0) first += m;
return first;
}
int fx[] = {0, 0, -1, 1, -1, 1, 1, -1};
int fy[] = {1, -1, 0, 0, 1, 1, -1, -1};
vector<pair<int, int> > adj[1000];
vector<int> v;
map<long long int, long long int> mp;
int main() {
int n;
int ara[100001];
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &ara[i]);
}
sort(ara, ara + n);
long long int val = 1;
for (int i = 0; i < n; i++) {
if (mp[val] == 0 && val <= ara[i]) {
ara[i] = val;
mp[val] = 1;
val++;
}
}
if (mp[val] == 0)
cout << val << endl;
else
cout << val + 1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
template <class Class>
void Print(Class instance) {
std::cout << instance << std::endl;
}
void Print() { std::cout << std::endl; }
int main() {
size_t n;
std::cin >> n;
std::vector<size_t> a(n);
for (size_t index = 0; index < n; ++index) {
std::cin >> a[index];
}
std::sort(a.begin(), a.end());
size_t answer = 0;
for (size_t index = 0; index < n; ++index) {
if (answer + 1 <= a[index]) {
++answer;
}
}
std::cout << answer + 1;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, a, cvp = 1;
vector<long long int> v;
cin >> n;
for (long long int i = 0; i < n; i++) {
cin >> a;
v.push_back(a);
}
sort(v.begin(), v.end());
for (long long int i = 0; i < n; i++) {
if (cvp <= v[i]) cvp++;
}
cout << cvp;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.