text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
template <class T1, class T2>
bool chmin(T1 &a, T2 b) {
return b < a && (a = b, true);
}
template <class T1, class T2>
bool chmax(T1 &a, T2 b) {
return a < b && (a = b, true);
}
int d(int x) {
if (x > 180) return 360 - x;
return x;
}
long long solve() {
static bool vis[360];
long long x;
cin >> x;
x = (x % 360 + 360) % 360;
vector<int> dist(360, -1);
int cnt = 0;
dist[d(x)] = 0;
while (!vis[x]) {
vis[x] = true;
x = (x + 270) % 360;
cnt++;
if (dist[d(x)] == -1) dist[d(x)] = cnt;
}
for (int i = 0; i < (181); i++)
if (dist[i] != -1) return dist[i];
}
int main() {
cout << solve() << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long x;
cin >> x;
x %= 360;
if (x < 0) x += 360;
if (x <= 45 || x >= 315)
cout << 0;
else if (x <= 135)
cout << 1;
else if (x <= 225)
cout << 2;
else
cout << 3;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long maxx = 3600000000000000000;
int main() {
srand(time(NULL));
ios_base::sync_with_stdio(false);
long long x;
cin >> x;
x += maxx;
x %= 360;
if (x <= 45 || x >= 315)
cout << "0\n";
else if (x <= 135)
cout << "1\n";
else if (x <= 225)
cout << "2\n";
else
cout << "3\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
n %= 360;
int mx = 1e6;
int ans = 0;
for (int i = 0; i < 4; i++) {
if (abs(n - 90 * i) % 360 < mx || 360 - abs(n - 90 * i) % 360 < mx) {
mx = min({abs(n - 90 * i) % 360, 360 - abs(n - 90 * i) % 360});
ans = i;
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char const *argv[]) {
long long x;
cin >> x;
x = x % 360;
if (x < 0) x += 360;
if (x <= 45 || x >= 315) cout << 0;
if (x > 45 && x <= 135)
cout << 1;
else if (x > 135 && x <= 225)
cout << 2;
else if (x > 225 && x < 315)
cout << 3;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
n = (n % 360 + 360) % 360;
if (n >= 315 || n <= 45)
cout << 0 << endl;
else
cout << n / 90 + (n % 90 - 1) / 45 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long x;
cin >> x;
x = (-x) % 360;
int ans;
long long mn1 = (long long)8e18;
for (int i = 0; i < 228; i++) {
long long T = abs((x + 90 * i) % 360);
T = min(T, 360 - T);
if (T < mn1) mn1 = T, ans = i;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long f(long long res) {
return min(abs(res), min(abs(360 - res), abs(0 - res)));
}
long long ans(long long a0, long long a, long long a1, long long a2) {
if (a0 <= a && a0 <= a1 && a0 <= a2) return 0;
if (a <= a1 && a <= a2 && a <= a0) return 1;
if (a1 <= a && a1 <= a2 && a1 <= a0) return 2;
return 3;
}
int main() {
long long n;
cin >> n;
n = 0 - n;
n %= 360;
if (n == 0 || n == 360 || n == -360) {
cout << 0 << endl;
return 0;
}
if (n < 0) {
n = 360 + n;
}
long long res0 = n;
long long res1 = n + 90;
long long res2 = res1 + 90;
long long res3 = res2 + 90;
res0 = f(res0);
res1 = f(res1);
res2 = f(res2);
res3 = f(res3);
cout << ans(res0, res1, res2, res3) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
long long int n;
cin >> n;
n = n - ((n / 360) * 360);
n = -n;
if (n < 0) {
n = n + 360;
}
long long int AnswerTurns = 0;
long long int MindeviationFromVertical;
MindeviationFromVertical = min(360 - n, n - 0);
long long int TempDeviation;
for (long long int i = 0; i <= 3; i++) {
long long int Hold = n + (90 * i);
if (Hold > 360) {
Hold -= 360;
}
if (min(360 - Hold, Hold - 0) < MindeviationFromVertical) {
MindeviationFromVertical = min(360 - Hold, Hold - 0);
AnswerTurns = i;
}
}
cout << AnswerTurns;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
int k = 0;
n %= 360;
if (n < -180) {
n += 360;
}
if (n > 180) {
n -= 360;
}
int mn = abs(n);
n -= 90;
if (n < -180) {
n += 360;
}
if (abs(n) < mn) {
mn = abs(n);
k = 1;
}
n -= 90;
if (n < -180) {
n += 360;
}
if (abs(n) < mn) {
mn = abs(n);
k = 2;
}
n -= 90;
if (n < -180) {
n += 360;
}
if (abs(n) < mn) {
mn = abs(n);
k = 3;
}
cout << k;
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:134217728")
using namespace std;
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 fact(long long n) {
long long res = 1;
for (int i = 1; i <= n; i++) res *= i;
return res;
}
long long forin(long long deg) { return (1LL << (2 * deg)); }
int getMax(int a, int b) {
int d = a - b;
int k = (d >> 31) & 0x1;
int mx = a - k * d;
return mx;
}
int getMin(int a, int b) { return a + b - getMax(a, b); }
int main() {
long long x;
cin >> x;
x = -x;
x %= 360;
x += 360;
x %= 360;
int df = getMin(360 - x, x);
x += 90;
x %= 360;
df = getMin(df, getMin(360 - x, x));
x += 90;
x %= 360;
df = getMin(df, getMin(360 - x, x));
x += 90;
x %= 360;
df = getMin(df, getMin(360 - x, x));
x += 90;
x %= 360;
int ans = 149;
int curDf;
curDf = getMin(360 - x, x);
ans = getMin(ans, 0 + 149 * getMax(df - curDf, curDf - df));
x += 90;
x %= 360;
curDf = getMin(360 - x, x);
ans = getMin(ans, 1 + 149 * getMax(df - curDf, curDf - df));
x += 90;
x %= 360;
curDf = getMin(360 - x, x);
ans = getMin(ans, 2 + 149 * getMax(df - curDf, curDf - df));
x += 90;
x %= 360;
curDf = getMin(360 - x, x);
ans = getMin(ans, 3 + 149 * getMax(df - curDf, curDf - df));
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long x;
scanf("%lld", &x);
x = x % 360;
if (x > 45 && x <= 135)
printf("%d\n", 1);
else if (x > 135 && x <= 225)
printf("%d\n", 2);
else if (x > 225 && x < 315)
printf("%d\n", 3);
else if (x < -45 && x > -135)
printf("%d\n", 3);
else if (x <= -135 && x > -225)
printf("%d\n", 2);
else if (x <= -225 && x > -315)
printf("%d\n", 1);
else
printf("%d\n", 0);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long x;
cin >> x;
x = -x;
if (x > 0) {
x = x % 360;
if (x <= 45 || x >= 315)
cout << 0;
else if (x > 45 && x < 135)
cout << 3;
else if (x >= 135 && x < 225)
cout << 2;
else if (x >= 225 && x < 315)
cout << 1;
} else {
x = (360 - ((-x) % 360)) % 360;
if (x <= 45 || x >= 315)
cout << 0;
else if (x > 45 && x < 135)
cout << 3;
else if (x >= 135 && x < 225)
cout << 2;
else if (x >= 225 && x < 315)
cout << 1;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long c_deg;
cin >> c_deg;
c_deg = (c_deg % 360 + 360) % 360;
long long im_deg = -(c_deg);
long long im_deg2 = im_deg;
long long ans = min(abs(360 - abs(im_deg)) % 360, abs(0 - abs(im_deg)) % 360),
min_deg = im_deg;
while (im_deg <= 720) {
im_deg += 90;
if (ans > min(abs(360 - abs(im_deg) % 360), abs(0 - abs(im_deg) % 360))) {
min_deg = im_deg;
ans = min(ans,
min(abs(360 - abs(im_deg) % 360), abs(0 - abs(im_deg) % 360)));
}
}
long long cnt = 0;
while (im_deg2 != min_deg) {
cnt++;
im_deg2 += 90;
}
cout << cnt << "\n";
return 0;
}
|
#include <bits/stdc++.h>
long long x;
int main() {
scanf("%lld", &x);
x = (x % 360 + 360) % 360;
int a[4];
for (int i = 0; i < 4; i++) {
a[i] = ((x - i * 90) % 360 + 360) % 360;
if (a[i] > 180) a[i] = 360 - a[i];
}
printf("%d\n", int(std::min_element(a, a + 4) - a));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a;
int main() {
cin >> a;
a %= 360;
if (a > 180) a -= 360;
long long mn = 360, ans = -1;
for (int cnt = 0; cnt < 100; cnt++) {
if (abs(a) >= 180) {
a %= 360;
a = (360 + a) % 360;
}
if (mn > abs(a)) mn = abs(a), ans = cnt;
a -= 90;
}
cout << ans << "\n";
}
|
#include <bits/stdc++.h>
long long choice(long long n, long long k) {
long long res = 1 * (n >= k);
for (long long i = 1; i <= k; i++) res = res * (n - i + 1) / i;
return res;
}
int main() {
std::ios_base::sync_with_stdio(false);
std::cout.tie(nullptr);
std::cin.tie(nullptr);
long long phi;
std::cin >> phi;
std::cout << (phi % 360 + 404) % 360 % 359 / 90 << std::endl;
}
|
#include <bits/stdc++.h>
int main() {
long long n;
std::cin >> n;
n = (n % 360 + 360) % 360;
n = (n + 44) % 360;
n = (n % 359) / 90;
return std::cout << n, 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long x;
int n0, n1, n2, n3, Rn0, Rn1, Rn2, Rn3, min, count = 0;
cin >> x;
n0 = x % 360;
if (n0 < 0)
n0 = abs(n0);
else
n0 = 360 - n0;
if (n0 > 180)
Rn0 = 360 - n0;
else
Rn0 = n0;
n1 = n0 + 90;
if (n1 > 360) n1 = n1 % 360;
if (n1 > 180)
Rn1 = 360 - n1;
else
Rn1 = n1;
n2 = n1 + 90;
if (n2 > 360) n2 = n2 % 360;
if (n2 > 180)
Rn2 = 360 - n2;
else
Rn2 = n2;
n3 = n2 + 90;
if (n3 > 360) n3 = n3 % 360;
if (n3 > 180)
Rn3 = 360 - n3;
else
Rn3 = n3;
min = Rn0;
if (Rn1 < min) {
min = Rn1;
count = 1;
}
if (Rn2 < min) {
min = Rn2;
count = 2;
}
if (Rn3 < min) {
min = Rn3;
count = 3;
}
cout << count;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n;
void clear() {}
void solve() {
n %= 360;
n = (n + 360) % 360;
int r;
if (n <= 45 || n >= 315)
r = 0;
else if (n <= 135)
r = 1;
else if (n <= 225)
r = 2;
else
r = 3;
printf("%d\n", r);
}
int main() {
while (scanf("%lld", &n) == 1) {
clear();
solve();
return 0;
}
return 0;
}
|
#include <bits/stdc++.h>
long long int n;
int main() {
scanf("%lld", &n);
n %= 360;
if (n < 0) n = 360 + n;
int ans = 0;
while (n > 45 && n < 315) {
n -= 90;
ans++;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a;
cin >> a;
int ans = 0;
a += 360 * 2777777777777778;
a %= 360;
int cur = min(360 - a, a);
a -= 90;
a += 360;
a %= 360;
if (cur > min(360 - a, a)) ans = 1, cur = min(360 - a, a);
a -= 90;
a += 360;
a %= 360;
if (cur > min(360 - a, a)) ans = 2, cur = min(360 - a, a);
a -= 90;
a += 360;
a %= 360;
if (cur > min(360 - a, a)) ans = 3, cur = min(360 - a, a);
a -= 90;
a += 360;
a %= 360;
if (cur > min(360 - a, a)) ans = 4, cur = min(360 - a, a);
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int power(long long int x, long long int t) {
if (t == 0) return 1;
if (t % 2 == 0)
return ((power(x, t / 2) % 100000) * (power(x, t / 2) % 100000)) % 100000;
else
return ((((power(x, t / 2) % 100000) * (power(x, t / 2) % 100000)) %
100000) *
x % 100000) %
100000;
}
int main() {
ios::sync_with_stdio(false);
long long int n;
cin >> n;
if (n < 0) {
n = (abs(n) / 360 + 1) * 360 + n;
} else
n %= 360;
if (n <= 45 || n >= 315)
cout << "0";
else if (n <= 135)
cout << 1;
else if (n <= 225)
cout << 2;
else
cout << 3;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long angle;
cin >> angle;
angle = (angle % 360 + 360) % 360;
angle = (angle + 44) % 360;
long long ans = (angle % 359) / 90;
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = (long long)1e17 + 99999999;
const long long Mod = (long long)1e9 + 7;
const long long MaXN = (long long)1e18;
const int N = (int)1e6 + 7;
const int MaXI = (int)1e9;
const int Mass = (int)2e5;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long angle;
cin >> angle;
angle = (angle % 360 + 360) % 360;
angle = (angle + 44) % 360;
cout << (angle % 359) / 90;
return 0;
}
|
#include <bits/stdc++.h>
const int MAXN = 1e5 + 5;
const long long MOD = 998244353;
const int INF = 0x3f3f3f3f;
const long long LL_INF = 0x3f3f3f3f3f3f3f3f;
const double PI = acos(-1);
const double ERR = 1e-10;
const int L = 40;
const int M = 30;
using namespace std;
long long mx = -1e18;
long long mn = 1e18;
int main() {
ios_base::sync_with_stdio(NULL);
cin.tie(NULL);
cout.tie(NULL);
long long a;
cin >> a;
a = (a % 360 + 360) % 360;
a = (a + 44) % 360;
cout << (a % 359) / 90;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
long long a;
cin >> a;
a = (a % 360 + 360) % 360;
a = (a + 44) % 360;
a = a % 359;
cout << a / 90;
return 0;
}
|
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
long long ncr(long long n, long long r) {
long long st = 1;
for (int i = 1; i <= r; i++) {
st *= n - i + 1;
st /= i;
}
return st;
}
long long pow2(long long n, long long e) {
if (e <= 0) return 1;
long long tmp = pow(n, e / 2);
tmp = tmp * tmp;
if (e % 2) tmp *= n;
return tmp;
}
int main() {
vector<pair<int, int> > cand;
long long x;
cin >> x;
int n = x % 360;
if (n > 180) n -= 360;
if (n < -180) n += 360;
for (int i = 0; i < 4; i++) {
int m = n - 90 * i;
m % -360;
if (m > 180) m -= 360;
if (m < -180) m += 360;
m = (m > 0) ? m : -m;
cand.push_back(make_pair(m, i));
}
printf("%d", min_element(cand.begin(), cand.end())->second);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long x, O = 360;
int main() {
cin >> x;
cout << ((x % O + O / 8 + O) % O - 1) / 90;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n;
int main(int argc, char **argv) {
cin >> n;
long long t = n;
n %= 360;
int mn = 400, dif = 400;
for (int i = 0; i <= 3; ++i) {
int x = min(abs((n - i * 90) % 360), ((n - i * 90) % 360 + 360) % 360);
x = min(x, 360 - x);
if (x < dif) {
dif = x;
mn = i;
}
}
cout << mn << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
n = ((n % 360 + 360) % 360 + 44) % 360;
if (n < 90 || n == 359)
cout << 0;
else if (n < 180)
cout << 1;
else if (n < 270)
cout << 2;
else
cout << 3;
}
|
#include <bits/stdc++.h>
const int maxn = 1e5 + 5;
const int inf = 0x3f3f3f3f;
using namespace std;
int main() {
long long n;
cin >> n;
n = ((n + 360) % 360 + 360) % 360;
if (n <= 45 || n >= 315)
cout << 0 << endl;
else if (n <= 135)
cout << 1 << endl;
else if (n <= 225)
cout << 2 << endl;
else
cout << 3 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int N;
cin >> N;
N = -N;
long long d = abs(N / 360) + 10;
if (N < 0) {
N = 360 * d + N;
long long cur = (N % 360);
long long mn = min(cur, 360 - cur);
int mv = 0;
cur = (cur + 90) % 360;
if (mn > min(cur, 360 - cur)) {
mv = 1;
mn = min(cur, 360 - cur);
}
cur = (cur + 90) % 360;
if (mn > min(cur, 360 - cur)) {
mv = 2;
mn = min(cur, 360 - cur);
}
cur = (cur + 90) % 360;
if (mn > min(cur, 360 - cur)) {
mv = 3;
mn = min(cur, 360 - cur);
}
cur = (cur + 90) % 360;
if (mn > min(cur, 360 - cur)) {
mv = 4;
mn = min(cur, 360 - cur);
}
cout << mv << '\n';
} else {
long long cur = (N % 360);
long long mn = min(cur, 360 - cur);
int mv = 0;
cur = (cur + 90) % 360;
if (mn > min(cur, 360 - cur)) {
mv = 1;
mn = min(cur, 360 - cur);
}
cur = (cur + 90) % 360;
if (mn > min(cur, 360 - cur)) {
mv = 2;
mn = min(cur, 360 - cur);
}
cur = (cur + 90) % 360;
if (mn > min(cur, 360 - cur)) {
mv = 3;
mn = min(cur, 360 - cur);
}
cur = (cur + 90) % 360;
if (mn > min(cur, 360 - cur)) {
mv = 4;
mn = min(cur, 360 - cur);
}
cout << mv << '\n';
}
}
|
#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...);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long an;
cin >> an;
an %= 360;
an += 360;
an %= 360;
an = -an;
an += 360;
an %= 360;
long long ans = 0;
if (an > 45 && an < 135)
ans = 3;
else if (an >= 135 && an < 225)
ans = 2;
else if (an >= 225 && an < 315)
ans = 1;
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
n = -n;
n = (n % 360 + 360) % 360;
int best = 400, ans = 0;
for (int i = 0; i < 4; ++i) {
int tmp = n + 90 * i;
int totdev = min(tmp % 360, (720 - tmp) % 360);
if (totdev < best) {
best = totdev;
ans = i;
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
const int N = 1e5 + 10, INF = 0x3f3f3f3f, MOD = 1e9 + 7;
long long x;
int main() {
ios_base::sync_with_stdio(0);
scanf("%I64d", &x);
int dif = INF, ans = -1;
for (int i = 0; i < 4; ++i) {
int y = ((x - 90 * i) % 360 + 360) % 360;
y = min(y, 360 - y);
if (y < dif) ans = i, dif = y;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
ll n;
cin >> n;
n %= 360;
if (n < 0)
n = abs(n);
else
n = 360 - n;
int best = 360;
int idx = 0;
for (int i = 0; i < 4; i++) {
int x = min((n + 90 * i) % 360, abs(360 - (n + 90 * i) % 360));
if (x < best) {
best = x;
idx = i;
}
}
cout << idx << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long dp[1000][6];
long long pw(long long a, int n) {
if (n == 0) return 1;
if (n & 1) return pw(a, n - 1) * a;
long long b = pw(a, n >> 1);
return b * b;
}
long long cnk(long long n, long long k) {
long long ans = 1;
for (long long i = n - k + 1; i <= n; ++i) {
ans *= i;
ans /= i - n + k;
}
return ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long n;
cin >> n;
n -= n / 360 * 360;
if (n < 0) n += 360;
long long mn = min(n, 360 - n);
int ans = 0;
for (long long i = 1; i < 4; ++i) {
n -= 90;
if (n < 0) n += 360;
if (mn > min(n, 360 - n)) {
ans = i;
mn = min(n, 360 - n);
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string ITS(long long x) {
string s = "";
while (x > 0) {
s += (char)(x % 10 + '0');
x /= 10;
}
string t = "";
for (int i = s.size() - 1; i > -1; i--) t += s[i];
return t;
}
long long inf = 1e9;
long long mod = 1e9 + 7;
const long long M = 2e2;
long long a[4];
int main() {
std::ios::sync_with_stdio(false);
long long n;
cin >> n;
n = -n;
n %= 360;
n += 360;
n %= 360;
a[0] = n;
a[1] = a[0] + 90;
a[2] = a[1] + 90;
a[3] = a[2] + 90;
a[0] %= 360;
a[1] %= 360;
a[2] %= 360;
a[3] %= 360;
a[0] = min(a[0], 360 - a[0]);
a[1] = min(a[1], 360 - a[1]);
a[2] = min(a[2], 360 - a[2]);
a[3] = min(a[3], 360 - a[3]);
long long m = 370, mi = 0;
for (long long i = 0; i < 4; i++) {
if (m > a[i]) {
m = a[i];
mi = i;
}
}
cout << mi;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
n = n % 360;
if (n < 0) {
n = 360 + n;
}
if (45 < n && n <= 135) {
cout << 1;
} else if (135 < n && n <= 225) {
cout << 2;
} else if (225 < n && n < 315) {
cout << 3;
} else {
cout << 0;
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long x;
int main() {
scanf("%I64d", &x);
x = -x;
x = x % 360;
x = (x + 360) % 360;
long long ans = min(x, 360 - x);
int sign = 0;
for (int i = 1; i < 4; i++) {
long long t = x + i * 90;
t = t % 360;
if (min(t, 360 - t) < ans) {
ans = min(t, 360 - t);
sign = i;
}
}
printf("%d\n", sign);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const int INF = 1061109567;
const long long LINF = 4557430888798830399ll;
void TestCase() {
long long d;
scanf("%lld", &d);
d %= 360;
if (d < 0) d += 360;
int ans = INF, cnt = 0;
for (int i = 0; i < 4; ++i) {
int nd = abs(d - 90 * i);
if (min(nd, 360 - nd) < ans) {
ans = min(nd, 360 - nd);
cnt = i;
}
}
printf("%d\n", cnt);
}
int main() {
int t = 1;
for (int i = 1; i <= t; ++i) {
TestCase();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1LL << 60;
const long double eps = 1e-14;
long long choose(long long n, long long k) {
long long res = 1;
for (int i = (0); i < int(k); ++i) res = res * (n - i) / (i + 1);
return res;
}
int main() {
long long x;
cin >> x;
x %= 360;
if (x < 0) x += 360;
if (x == 315)
puts("0");
else
cout << (x + 44) / 90 % 4 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, M;
bool group[100001];
bool trip[100001];
vector<int> Map[100001];
bool flag;
void search(int v, int par) {
group[v] = true;
trip[v] = true;
for (int i = 0; i < Map[v].size(); i++) {
int now = Map[v][i];
if (now == par) continue;
if (trip[now]) flag = true;
if (!group[now]) search(now, v);
}
trip[v] = false;
}
int main() {
scanf("%d%d", &N, &M);
int a, b;
for (int i = 0; i < M; i++) {
scanf("%d%d", &a, &b);
Map[a].push_back(b);
Map[b].push_back(a);
}
int ans = 0;
for (int i = 1; i <= N; i++)
if (!group[i]) {
flag = false;
search(i, 0);
if (!flag) ans++;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int f = 0;
vector<int> g[100005];
bool vis[100005];
void dfs(int u, int parent) {
vis[u] = true;
for (int i = 0; i < g[u].size(); i++) {
if (g[u][i] != parent) {
if (!vis[g[u][i]])
dfs(g[u][i], u);
else
f = 1;
}
}
return;
}
int main() {
int n, m, i, a, b, ans = 0;
cin >> n >> m;
for (i = 0; i < m; i++) {
cin >> a >> b;
g[a].push_back(b);
g[b].push_back(a);
}
for (i = 1; i <= n; i++) {
if (!vis[i]) {
f = 0;
dfs(i, -1);
if (!f) ans++;
}
}
cout << ans << endl;
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>
using namespace std;
int visited[100005], parent[100005];
vector<int> graph[100005];
bool hasCycle;
void dfs(int node) {
int i, temp;
for (i = 0; i < graph[node].size(); i++) {
temp = graph[node][i];
if (visited[temp] == 0) {
visited[temp] = 1;
parent[temp] = node;
dfs(temp);
} else if ((visited[temp] == 1) && (parent[node] != temp))
hasCycle = false;
}
return;
}
int main() {
int i, j, t, n, m, k, l, r, temp, mini, maxi, flag, result = 0, cnt;
scanf("%d%d", &n, &m);
for (i = 0; i < m; i++) {
scanf("%d%d", &l, &r);
graph[l].push_back(r);
graph[r].push_back(l);
}
for (i = 1; i <= n; i++) {
if (visited[i] == 0) {
visited[i] = 1;
hasCycle = true;
dfs(i);
result = result + hasCycle;
}
}
printf("%d\n", result);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using vi = vector<int>;
using vvi = vector<vi>;
using ii = pair<int, int>;
using vii = vector<ii>;
using l = long long;
using vl = vector<l>;
using vvl = vector<vl>;
using ll = pair<l, l>;
using vll = vector<ll>;
using vvll = vector<vll>;
using lu = unsigned long long;
using vb = vector<bool>;
using vvb = vector<vb>;
using vd = vector<double>;
using vvd = vector<vd>;
const int INF = numeric_limits<int>::max();
const double EPS = 1e-10;
const l e5 = 100000, e6 = 1000000, e7 = 10000000, e9 = 1000000000;
const bool enable_log = false;
struct VoidStream {
void operator&(std::ostream&) {}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
l n, m;
while (cin >> n >> m) {
vb visited(n);
vector<unordered_set<l>> adj(n);
for (l i = 0; i < m; i++) {
l a, b;
cin >> a >> b;
a--;
b--;
adj[a].emplace(b);
adj[b].emplace(a);
}
l orphans = 0;
for (l i = 0; i < n; i++) {
if (visited[i]) continue;
l j = i;
while (adj[j].size() == 1) {
visited[j] = true;
l next = *(adj[j].begin());
adj[next].erase(j);
j = next;
}
if (adj[j].empty()) {
visited[j] = true;
orphans++;
}
}
cout << orphans << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> nodes[100001];
int flag = 0;
bool state[100001];
void dfs(int a, int par) {
state[a] = true;
for (int i = 0; i < nodes[a].size(); i++) {
if (nodes[a][i] != par) {
if (state[nodes[a][i]] == true)
flag = 1;
else
dfs(nodes[a][i], a);
}
}
}
int main() {
int n, e, u, v;
cin >> n >> e;
for (int i = 0; i < e; i++) {
cin >> u >> v;
nodes[u].push_back(v);
nodes[v].push_back(u);
}
int count = 0;
for (int i = 1; i <= n; i++) {
if (state[i] == false) {
flag = 0;
dfs(i, -1);
if (flag == 0) count++;
}
}
cout << count << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
int p[maxn], vis[maxn];
int find(int x) {
if (x != p[x])
return p[x] = find(p[x]);
else
return x;
}
void join(int x, int y) {
int n = find(x), m = find(y);
if (n != m) {
p[n] = m;
if (vis[n] || vis[m] || vis[x] || vis[y]) {
vis[n] = vis[m] = vis[x] = vis[y] = 1;
}
} else
vis[n] = vis[m] = vis[x] = vis[y] = 1;
}
int main() {
ios::sync_with_stdio(false);
int n, m, a, b, sum = 0;
cin >> n >> m;
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= n; i++) p[i] = i;
for (int i = 1; i <= m; i++) {
cin >> a >> b;
join(a, b);
}
for (int i = 1; i <= n; i++) {
if (!vis[i] && p[i] == i) sum++;
}
cout << sum << endl;
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;
}
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin >> n >> m;
for (long long i = 1; i <= m; i++) {
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
for (long long i = 1; i <= n; i++) {
thien = 1;
tmp = -1;
if (used[i] == 0) {
used[i] = -1;
dfs(i);
kq += thien;
}
}
cout << kq;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int>> ans;
map<pair<int, int>, bool> V;
void dfs2(map<int, vector<int>>& g, int u, bool* visited, int& ec) {
visited[u] = true;
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (!V[{u, v}]) {
V[{u, v}] = true;
V[{v, u}] = true;
ec++;
}
}
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (!visited[v]) {
dfs2(g, v, visited, ec);
}
}
}
void dfs(map<int, vector<int>>& g, int u, vector<int>& tmp, bool* visited) {
visited[u] = true;
tmp.push_back(u);
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (!visited[v]) {
dfs(g, v, tmp, visited);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m;
cin >> n >> m;
map<int, vector<int>> g;
while (m--) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
bool visited[n + 1];
for (int i = 0; i <= n; i++) visited[i] = false;
for (int i = 1; i <= n; i++) {
if (!visited[i]) {
vector<int> tmp;
dfs(g, i, tmp, visited);
ans.push_back(tmp);
}
}
int finalans = 0;
int r = ans.size();
for (int i = 1; i <= n; i++) {
visited[i] = false;
}
for (int i = 0; i < r; i++) {
int src = ans[i][0];
int ec = 0;
dfs2(g, src, visited, ec);
if (ec == ans[i].size() - 1) {
finalans += 1;
} else {
finalans += 0;
}
}
cout << finalans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[100005];
bool visited[100005];
int edge[100005];
int bfs(int src) {
queue<int> q;
q.push(src);
int cc = 1, ec = 0;
visited[src] = true;
map<pair<int, int>, int> mpp;
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i];
pair<int, int> p1 = make_pair(u, v);
pair<int, int> p2 = make_pair(v, u);
if (mpp[p1] == 0 && mpp[p2] == 0) {
mpp[p1]++;
mpp[p2]++;
ec++;
}
if (visited[v] == false) {
cc++;
visited[v] = true;
q.push(v);
}
}
}
if (ec < cc) {
return 1;
} else {
return 0;
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
for (__typeof(m) i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
edge[x]++;
edge[y]++;
}
int ans = 0;
for (__typeof(n) i = 1; i <= n; i++) {
if (visited[i] == false) {
ans += bfs(i);
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
vector<vector<int>> g;
vector<bool> used;
bool flag;
void dfs(int v, int fr) {
used[v] = true;
for (int i = 0; i < g[v].size(); ++i) {
if (g[v][i] == fr) continue;
if (used[g[v][i]])
flag = true;
else
dfs(g[v][i], v);
}
}
int main() {
int n, m;
cin >> n >> m;
g.resize(n);
used.resize(n);
for (int i = 0; i < m; ++i) {
int a, b;
cin >> a >> b;
--a;
--b;
g[a].push_back(b);
g[b].push_back(a);
}
int ans = 0;
for (int v = 0; v < g.size(); ++v) {
if (!used[v]) {
flag = false;
dfs(v, -1);
if (!flag) ++ans;
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline void rd(int &res) {
res = 0;
char c;
while (c = getchar(), c < '0')
;
do {
res = (res << 1) + (res << 3) + (c ^ 48);
} while (c = getchar(), c >= '0');
}
inline void print(int k) {
if (k == 0) return;
print(k / 10);
putchar((k % 10) ^ 48);
}
inline void sc(int k) {
print(k);
if (k == 0) {
putchar('0');
putchar('\n');
}
}
inline void MIN(int &a, int b) {
if (a == -1 || a > b) a = b;
}
inline void MAX(int &a, int b) {
if (a < b) a = b;
}
const int M = 1e5 + 5;
int n, m, scc, ecnt;
int A[M], B[M], p[M], e[M], id[M], head[M];
struct node {
int t, nxt;
} edge[M << 1];
inline void addedge(int a, int b) {
edge[++ecnt] = (node){b, head[a]};
head[a] = ecnt;
}
inline void input() {
int i, j, k;
rd(n);
rd(m);
for (i = 1; i <= m; i++) {
rd(A[i]), rd(B[i]);
addedge(A[i], B[i]);
addedge(B[i], A[i]);
}
}
inline void dfs(int x, int c) {
p[c]++;
id[x] = c;
for (int i = head[x]; i; i = edge[i].nxt) {
int t = edge[i].t;
if (!id[t]) dfs(t, c);
}
}
inline void solve() {
int i, j, k, ans = 0;
for (i = 1; i <= n; i++)
if (!id[i]) dfs(i, ++scc);
for (i = 1; i <= m; i++) e[id[A[i]]]++;
for (i = 1; i <= scc; i++)
if (e[i] == p[i] - 1) ans++;
sc(ans);
}
int main() {
input();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int vis[100001] = {0};
int ans;
void bfs(vector<int> *arr, int n) {
int edges = arr[n].size();
int vertex = 1;
queue<int> q;
q.push(n);
vis[n] = 1;
while (!q.empty()) {
int v = q.front();
q.pop();
for (auto u : arr[v]) {
if (vis[u]) continue;
vis[u] = 1;
vertex++;
edges += arr[u].size();
q.push(u);
}
}
if ((edges / 2) == (vertex - 1)) ans++;
}
int main() {
int n, m;
cin >> n >> m;
vector<int> arr[n + 1];
for (int i = 1; i <= m; i++) {
int x, y;
cin >> x >> y;
arr[x].push_back(y);
arr[y].push_back(x);
}
ans = 0;
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
bfs(arr, i);
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int fa[100005], ver[100005], edg[100005];
void makeSet(int n) {
for (int i = 1; i <= n; i++) fa[i] = i, ver[i] = 1, edg[i] = 0;
}
int findSet(int x) { return fa[x] = (fa[x] == x) ? x : findSet(fa[x]); }
void unionSet(int x, int y) {
int a = findSet(x), b = findSet(y);
if (a != b) {
fa[a] = b;
fa[x] = b;
ver[b] += ver[a];
ver[a] = 0;
edg[b] += edg[a];
edg[a] = 0;
}
edg[b]++;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
makeSet(n);
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
unionSet(u, v);
}
int ans = 0;
for (int i = 1; i <= n; i++)
if (ver[i] == edg[i] + 1) ans++;
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, n1, n2;
vector<long long> v[1000010];
bool vis[1000010] = {false};
static long long ans = 0;
inline void dfs(long long init, long long parent) {
long long i;
vis[init] = true;
for (i = 0; i < v[init].size(); i++) {
if (!vis[v[init][i]])
dfs(v[init][i], init);
else if (v[init][i] != parent)
ans++;
}
}
int main() {
long long i, lol = 0;
cin >> n >> m;
for (i = 0; i < m; i++) {
cin >> n1 >> n2;
v[n1].push_back(n2);
v[n2].push_back(n1);
}
for (i = 1; i <= n; i++) {
if (!vis[i]) {
ans = 0;
dfs(i, -1);
if (ans == 0) lol++;
}
}
cout << lol;
}
|
#include <bits/stdc++.h>
using namespace std;
using namespace std;
class Graph {
int V;
list<int> *adj;
bool isCyclicUtil(int v, bool visited[], int parent);
public:
Graph(int V);
void addEdge(int v, int w);
bool isTree();
};
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;
}
bool Graph::isTree() {
bool *visited = new bool[V];
for (int i = 0; i < V; i++) visited[i] = false;
if (isCyclicUtil(0, visited, -1)) return false;
for (int u = 0; u < V; u++)
if (!visited[u]) return false;
return true;
}
vector<vector<int> > connectedComponents(vector<vector<pair<int, int> > > adj) {
const int maxn = 1000000;
bool vis[maxn];
for (int i = 0; i < (int((adj).size())); ++i) {
vis[i] = false;
}
vector<vector<int> > ans;
for (int i = 0; i < (int((adj).size())); ++i) {
if (vis[i]) continue;
vector<int> stuff;
set<int> stuff2;
stack<int> nodes;
nodes.push(i);
while (!nodes.empty()) {
int top = nodes.top();
stuff2.insert(top);
nodes.pop();
vis[top] = true;
for (int i = 0; i < (int((adj[top]).size())); ++i) {
if (!vis[adj[top][i].first]) {
nodes.push(adj[top][i].first);
}
}
}
for (int i : stuff2) {
stuff.push_back(i);
}
ans.push_back(stuff);
}
return ans;
}
vector<int> adj[100000];
bool vis[100000];
bool found = false;
void dfs(int node, int back) {
vis[node] = true;
int sz = 0;
for (int i = 0; i < (int((adj[node]).size())); ++i) {
if (found) return;
int to = adj[node][i];
if (back == to) continue;
sz++;
if (!vis[to]) {
dfs(to, node);
} else {
found = true;
return;
}
}
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < (m); ++i) {
int a, b;
cin >> a >> b;
a--;
b--;
adj[a].push_back(b);
adj[b].push_back(a);
}
int cnt = 0;
for (int i = 0; i < (n); ++i) {
if (vis[i]) continue;
if (int((adj[i]).size()) == 0) {
cnt++;
continue;
}
dfs(i, -1);
if (!found) cnt++;
found = false;
}
cout << cnt << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<set<int>> con(n + 1);
for (int i = 0; i < m; ++i) {
int a, b;
cin >> a >> b;
con[a].insert(b);
con[b].insert(a);
}
vector<bool> used(n + 1, false);
int ans = 0;
for (int i = 1; i <= n; ++i) {
if (not used[i]) {
map<int, bool> comp;
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 (comp[t]) {
cycled = true;
} else {
comp[t] = true;
que.push(t);
}
con[t].erase(cur);
}
con[cur].clear();
}
for (auto t : comp) {
used[t.first] = true;
}
ans += (not cycled);
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int q, n;
long long int ans, sum;
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 powe(long long int a, long long int b) {
long long int res = 1;
while (b > 0) {
if (b % 2 == 1) {
res = (res * a);
}
a = (a * a);
b /= 2;
}
return res;
}
long long int power(long long int a, long long int b, long long int M) {
a %= M;
long long int res = 1;
while (b > 0) {
if (b % 2 == 1) {
res = (res * a) % M;
}
a = (a * a) % M;
b /= 2;
}
return res;
}
long long int extendedEuclid(long long int A, long long int B, long long int &x,
long long int &y) {
if (B == 0) {
x = 1;
y = 0;
return A;
} else {
long long int x1, y1;
long long int gcd = extendedEuclid(B, A % B, x1, y1);
y = x1 - (A / B) * y1;
x = y1;
return gcd;
}
}
long long int mi(long long int A, long long int M) {
long long int x, y;
extendedEuclid(A, M, x, y);
if (x < 0) {
x += (long long int)1000000007;
}
return x;
}
vector<bool> sieve(1000000, true);
void Sieve() {
sieve[0] = false;
sieve[1] = false;
for (long long int i = 2; i * i <= 1000000; i++) {
if (sieve[i] == true) {
for (long long int j = i * i; j < 1000000; j += i) sieve[j] = false;
}
}
}
vector<long long int> sieve_spf;
void Sieve_spf() {
const long long int n = 1e6 + 5;
sieve_spf.resize(n);
for (int i = 0; i < n; i++) sieve_spf[i] = i;
sieve_spf[0] = -1;
sieve_spf[1] = 1;
for (int i = 2; i <= n; i += 2) sieve_spf[i] = 2;
for (int i = 3; i <= n; i += 2)
if (sieve_spf[i] == i)
for (int j = i * i; j <= n; j += i)
if (sieve_spf[j] == j) sieve_spf[j] = i;
}
bool isUpcase(char c) {
if (c >= 'A' && c <= 'Z')
return true;
else
return false;
}
bool islowcase(char c) {
if (c >= 'a' && c <= 'z')
return true;
else
return false;
}
void the_happiest_place_on_earth() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
}
bool comp(const pair<int, int> &a, const pair<int, int> &b) {
if (a.first > b.first)
return true;
else if (a.first == b.first && a.second < b.second)
return true;
else
return false;
}
const int N = 310055;
long long int b[N], a[N], dis[N], p[N];
vector<int> graph[N], graph1[N];
bool vis[N];
int dag;
void gra(long long int m) {
for (int i = 0; i < m; i++) {
long long int x, y;
cin >> x >> y;
x--, y--;
graph[x].push_back(y);
graph[y].push_back(x);
}
}
void dfs(int node, int par) {
vis[node] = true;
p[node] = par;
for (auto x : graph[node]) {
if (vis[x] && x != p[node]) dag = 0;
if (!vis[x]) dfs(x, node);
}
}
void testcase() {
long long int m;
cin >> n >> m;
gra(m);
int ans = 0;
memset(vis, false, sizeof(vis));
memset(p, 0, sizeof(p));
for (int i = 0; i < n; i++) {
if (!vis[i]) {
dag = 1;
dfs(i, -1);
if (dag) ans++;
}
}
cout << ans;
return;
}
int main() {
the_happiest_place_on_earth();
q = 1;
while (q--) {
testcase();
}
cerr << "Time : " << 1000 * ((double)clock()) / (double)CLOCKS_PER_SEC
<< "ms\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, ans;
int p[100009];
bool done[100009];
int get(int node) {
if (p[node] == node) return node;
int x = get(p[node]);
p[node] = x;
return x;
}
void merge(int a, int b) {
int A = get(a);
int B = get(b);
if (done[A] == 1)
p[B] = A;
else
p[A] = B;
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) p[i] = i;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
if (get(a) == get(b)) done[get(a)] = 1;
merge(a, b);
}
for (int i = 0; i < n; i++) {
int x = get(i);
if (done[x] == 1) continue;
done[x] = 1;
ans++;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5;
vector<int> vc[N + 10];
bool mrk[N + 10], mark;
void dfs(int v, int par) {
mrk[v] = true;
for (int i = 0; i < vc[v].size(); i++) {
int u = vc[v][i];
if (!mrk[u])
dfs(u, v);
else if (u != par)
mark = true;
}
return;
}
int main() {
int n, m, cnt = 0;
cin >> n >> m;
while (m--) {
int x, y;
cin >> x >> y, x--, y--;
vc[x].push_back(y), vc[y].push_back(x);
}
for (int i = 0; i < n; i++)
if (!mrk[i]) {
mark = false;
dfs(i, -1), cnt += mark ^ 1;
}
cout << cnt;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int res, n, m, a, b, c, i, j, k;
bool gez[100005], cnt;
vector<int> d[100005];
void dfs(int x, int pa) {
int i, j, nd;
gez[x] = true;
for (i = 0; i < d[x].size(); i++) {
nd = d[x][i];
if (nd == pa) continue;
if (!gez[nd])
dfs(nd, x);
else
cnt = 1;
}
}
int main() {
scanf("%d %d", &n, &m);
for (i = 1; i <= m; i++) {
scanf("%d %d", &a, &b);
d[a].push_back(b);
d[b].push_back(a);
}
for (i = 1; i <= n; i++) {
if (!gez[i]) {
cnt = 0;
dfs(i, 0);
res += !cnt;
}
}
printf("%d\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100001, M = N << 1;
int n, m, fa[N], ans, f, head[N], cnt, siz[N], vis[N], sum;
struct edge {
int to, nex;
} t[M];
inline void add(int x, int y) {
t[++cnt].to = y;
t[cnt].nex = head[x];
head[x] = cnt;
return;
}
void dfs(int x, int bb) {
vis[x] = 1;
for (int i = head[x]; i; i = t[i].nex) {
int y = t[i].to;
if (y == bb) continue;
if (vis[y]) {
f = 1;
continue;
}
vis[y] = 1;
dfs(y, x);
}
return;
}
inline long long read() {
long long x = 0;
char ch = getchar();
bool f = 1;
for (; !isdigit(ch); ch = getchar())
if (ch == '-') f = 0;
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - '0';
return f ? x : -x;
}
int main() {
n = read();
m = read();
for (int i = 1, u, v; i <= m; i++) {
u = read();
v = read();
add(u, v);
add(v, u);
}
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
f = 0;
dfs(i, 0);
if (f == 0) ans++;
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
double EPS = 1e-9;
long long INF = 1000000000000000005ll;
double PI = acos(-1);
inline string IntToString(long long int a) {
char x[100];
sprintf(x, "%lld", a);
string s = x;
return s;
}
inline long long int StringToInt(string a) {
char x[100];
long long int res;
strcpy(x, a.c_str());
sscanf(x, "%lld", &res);
return res;
}
inline string uppercase(string s) {
int n = (int)s.size();
for (long long int i = 0; i < n; i++)
if (s[i] >= 'a' && s[i] <= 'z') s[i] = s[i] - 'a' + 'A';
return s;
}
inline string lowercase(string s) {
int n = (int)s.size();
for (long long int i = 0; i < n; i++)
if (s[i] >= 'A' && s[i] <= 'Z') s[i] = s[i] - 'A' + 'a';
return s;
}
bool prime(long long 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;
}
bool cmp(pair<long long int, long long int> a,
pair<long long int, long long int> b) {
long long int as = a.first - a.second;
long long int binary_search = b.first - b.second;
return (as > binary_search);
}
bool vis[100005];
vector<long long int> v[100005];
bool c = 0;
void dfs(long long int u, long long int par) {
vis[u] = 1;
for (int child : v[u]) {
if (vis[child] == 0) {
dfs(child, u);
} else {
if (child != par) {
c = 1;
}
}
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int n, m;
cin >> n >> m;
for (long long int i = 0; i < m; i++) {
long long int a, b;
cin >> a >> b;
v[a].push_back(b);
v[b].push_back(a);
}
long long int ans = 0;
for (long long int i = 1; i <= n; i++) {
c = 0;
if (vis[i] == 0) {
dfs(i, 0);
if (c) {
} else {
ans++;
}
}
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int E, V;
struct hash_name {
size_t operator()(const pair<int, int> &name) const {
return hash<int>()(name.first) ^ hash<int>()(name.second);
}
};
vector<vector<int>> graph;
vector<bool> visited;
unordered_set<pair<int, int>, hash_name> edge_vis;
hash<int> hash_fn;
bool dfs_sol(int vstart) {
if (visited[vstart]) {
return true;
}
bool ans = false;
visited[vstart] = true;
for (int vv : graph[vstart]) {
pair<int, int> p = {vv, vstart};
pair<int, int> p2 = {vstart, vv};
if (((edge_vis).find(p) != (edge_vis).end()) ||
((edge_vis).find(p2) != (edge_vis).end())) {
continue;
}
edge_vis.insert(p);
bool ris = dfs_sol(vv);
ans = ans || ris;
}
return ans;
}
int main() {
ios::sync_with_stdio(false);
cin >> V >> E;
graph = vector<vector<int>>(V, vector<int>(0));
visited = vector<bool>(V, false);
for (int i = 0; i < E; i++) {
int v1, v2;
cin >> v1 >> v2;
graph[v1 - 1].push_back(v2 - 1);
graph[v2 - 1].push_back(v1 - 1);
}
int ans = 0;
for (int i = 0; i < V; i++) {
if (!visited[i]) {
if (!dfs_sol(i)) {
ans++;
}
}
edge_vis = unordered_set<pair<int, int>, hash_name>();
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
ostream& operator+(ostream& out, const vector<T>& vec) {
for (const auto& x : vec) {
out << x << " ";
}
out << "\n";
return out;
}
template <typename T>
ostream& operator*(ostream& out, const vector<T>& vec) {
for (const auto& x : vec) {
out + x;
}
return out;
}
template <typename T>
istream& operator>>(istream& in, vector<T>& vec) {
for (auto& x : vec) {
in >> x;
}
return in;
}
const int N = 2e6 + 5;
const int mod = 1e9 + 7;
vector<int> g[N];
int vis[N];
long long e = 0;
long long v = 0;
void dfs(int u) {
v++;
vis[u] = 1;
e += g[u].size();
for (auto i : g[u]) {
if (!vis[i]) {
dfs(i);
}
}
}
void solve() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
e = 0, v = 0;
if (!vis[i]) {
dfs(i);
if (e / 2 == v - 1) {
ans++;
}
}
}
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
void init();
void solve();
int main() {
try {
init();
solve();
} catch (const char* s) {
return 0;
}
return 0;
}
template <class T>
inline bool checkMin(T& a, T b) {
return (a > b ? a = b, 1 : 0);
}
template <class T>
inline bool checkMax(T& a, T b) {
return (a < b ? a = b, 1 : 0);
}
class Scanner {
private:
istream& ist;
public:
Scanner(istream& in) : ist(in) {}
string next() {
string r;
ist >> r;
return r;
}
string nextLine() {
string r;
getline(ist, r);
return r;
}
int nextInt() {
int r;
ist >> r;
return r;
}
double nextDouble() {
double r;
ist >> r;
return r;
}
char nextChar() {
char r;
ist >> r;
return r;
}
};
Scanner sc(cin);
void ALERT(bool judgememt, const char* phrase) {
if (judgememt) {
puts(phrase);
throw "ALERT";
}
}
bool alert(bool judgememt, const char* phrase) {
if (judgememt) puts(phrase);
return judgememt;
}
const int N = 100005;
int n, m;
vector<int> e[N];
void init() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d%d", &u, &v);
e[u].push_back(v);
e[v].push_back(u);
}
}
int vis[N];
int dfs(int u, int f) {
int res = 1;
vis[u] = 1;
for (auto v : e[u]) {
if (v == f) continue;
if (vis[v]) return 0;
checkMin(res, dfs(v, u));
}
return res;
}
void solve() {
memset(vis, 0, sizeof(vis));
int ans = 0;
for (int i = 1; i <= n; i++) {
if (!vis[i]) ans += dfs(i, 0);
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[100005];
int visited[100005];
int dfs(int s, int p) {
visited[s] = 1;
int t = 1;
for (typeof((adj[s]).begin()) it = (adj[s]).begin(); it != (adj[s]).end();
it++) {
if (!visited[*it])
t = t & dfs(*it, s);
else if (*it != p)
return 0;
}
return t;
}
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 maxn = 1e5 + 10;
vector<int> res[maxn];
int vis[maxn];
int n, m;
int flag;
void dfs(int x, int y) {
if (vis[x]) {
flag = 0;
return;
}
vis[x] = 1;
for (int i = 0; i < res[x].size(); i++) {
int v = res[x][i];
if (v == y) continue;
dfs(v, x);
}
}
int main() {
int x, y;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d%d", &x, &y);
res[x].push_back(y);
res[y].push_back(x);
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
flag = 1;
dfs(i, -1);
if (flag == 1) ans++;
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int degree[n + 1];
for (int i = 0; i <= n; i++) degree[i] = 0;
int u, v;
vector<set<int> > G(n + 1, set<int>());
for (int i = 0; i < m; i++) {
cin >> u >> v;
G[u].insert(v);
G[v].insert(u);
degree[u]++;
degree[v]++;
}
int separate = 0;
queue<int> q;
for (int i = 1; i < n + 1; i++)
if (degree[i] == 1)
q.push(i);
else if (degree[i] == 0)
separate++;
while (!q.empty()) {
int i = q.front();
q.pop();
for (auto k : G[i]) {
G[k].erase(i);
degree[k]--;
if (degree[k] == 1)
q.push(k);
else if (degree[k] == 0)
separate++;
}
}
cout << separate << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> q[1008611];
int a[1008611], b[1008611];
int ans = 0, flag = 0;
int book[1008611];
void dfs(int p, int fa) {
int i;
for (i = 0; i < q[p].size(); i++) {
if (q[p][i] != fa) {
if (book[q[p][i]] == 1) {
flag = 1;
continue;
}
book[q[p][i]] = 1;
dfs(q[p][i], p);
}
}
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
int i, j, x, y;
for (i = 1; i <= m; i++) {
scanf("%d%d", &a[i], &b[i]);
q[a[i]].push_back(b[i]);
q[b[i]].push_back(a[i]);
}
for (i = 1; i <= n; i++) {
flag = 0;
if (book[i] == 0) {
book[i] = 1;
dfs(i, -1);
if (flag == 0) {
ans++;
}
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
struct node {
int key, dop;
unsigned short int height;
node *left, *right;
node(int k, int d) {
key = k;
left = 0;
right = 0;
height = 1;
dop = d;
}
};
unsigned short int height(node *p) { return p ? p->height : 0; }
short int bfactor(node *p) { return height(p->left) - height(p->right); }
void fixheight(node *p) {
unsigned short int h1, h2;
h1 = height(p->left);
h2 = height(p->right);
p->height = (h1 > h2 ? h1 : h2) + 1;
}
node *rotateR(node *q) {
node *p = q->left;
q->left = p->right;
p->right = q;
fixheight(q);
fixheight(p);
return p;
}
node *rotateL(node *p) {
node *q = p->right;
p->right = q->left;
q->left = p;
fixheight(p);
fixheight(q);
return q;
}
node *balance(node *p) {
fixheight(p);
if (bfactor(p) == 2) {
if (bfactor(p->left) < 0) p->left = rotateL(p->left);
return rotateR(p);
}
if (bfactor(p) == -2) {
if (bfactor(p->right) > 0) p->right = rotateR(p->right);
return rotateL(p);
}
return p;
}
node *insert(node *p, int k, int d) {
if (!p) return new node(k, d);
if (p->key < k)
p->right = insert(p->right, k, d);
else
p->left = insert(p->left, k, d);
return (balance(p));
}
void printyem(node *kor) {
if (kor) {
printyem(kor->left);
printf("%d", kor->key);
printyem(kor->right);
}
}
node *kor;
bool done[100001];
int n, k, reb[200002][2], a, b, kol[100001], wher[100001], och;
void obh(node *kor) {
if (kor->left) obh(kor->left);
a++;
if (kor->key != reb[a - 1][0]) wher[kor->key] = a;
reb[a][0] = kor->key;
reb[a][1] = kor->dop;
if (kor->right) obh(kor->right);
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < k; i++) {
scanf("%d%d", &a, &b);
kor = insert(kor, a, b);
kor = insert(kor, b, a);
kol[a]++;
kol[b]++;
}
a = 0;
b = 0;
obh(kor);
for (int i = 1; i <= n; i++) {
if (kol[i] == 1) {
och = i;
while (kol[och] == 1) {
done[och] = true;
kol[och]--;
a = wher[och];
while (done[reb[a][1]]) a++;
och = reb[a][1];
kol[och]--;
}
}
}
for (int i = 1; i <= n; i++)
if (kol[i] == 0 && !done[i]) b++;
printf("%d", b);
}
|
#include <bits/stdc++.h>
using namespace std;
long long cmax(long long a, long long b) { return (a > b ? a : b); }
long long cmax(long long a, long long b, long long c) {
return cmax(cmax(a, b), c);
}
long long cmin(long long a, long long b) { return (a < b ? a : b); }
long long cmin(long long a, long long b, long long c) {
return cmin(cmin(a, b), c);
}
void dfs(vector<long long> *g, bool *v, long long curr, long long p,
long long &cycle) {
v[curr] = true;
for (long long i = 0; i < g[curr].size(); i++) {
if (v[g[curr][i]]) {
if (g[curr][i] != p) {
cycle = 1;
}
} else {
dfs(g, v, g[curr][i], curr, 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) {
long long cycle = 0;
dfs(g, v, first_unv, -1, cycle);
ans += !cycle;
while (v[first_unv]) {
++first_unv;
if (first_unv == n + 1) {
done = true;
break;
}
}
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
int pre[N];
int find(int x) {
if (x == pre[x]) return x;
return pre[x] = find(pre[x]);
}
int cir[N];
int main() {
memset(cir, 0, sizeof(cir));
int n, m, i, j, u, v;
cin >> n >> m;
for (i = 0; i <= n; ++i) pre[i] = i;
int cnt = 0;
for (i = 0; i < m; ++i) {
cin >> u >> v;
int x = find(u);
int y = find(v);
if (x == y) {
cir[x] = 1;
} else {
pre[y] = x;
if (cir[y]) cir[x] = cir[y];
}
}
for (i = 1; i <= n; ++i) {
if (pre[i] == i && !cir[i]) {
cnt++;
}
}
cout << cnt;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool vis[100001];
vector<int> ar[100001];
int dfs(int x, int par) {
vis[x] = 1;
int res = 0;
for (int i = 0; i < ar[x].size(); i++)
if (vis[ar[x][i]] && ar[x][i] != par)
res = 1;
else if (!vis[ar[x][i]])
res |= dfs(ar[x][i], x);
return res;
}
int main() {
int n, m, x, y, res = 0;
cin >> n >> m;
for (int i = 1; i <= m; i++)
cin >> x >> y, ar[x].push_back(y), ar[y].push_back(x);
for (int i = 1; i <= n; i++)
if (!vis[i]) res += !dfs(i, 0);
cout << res;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, x, y, ans, nodes, edges;
vector<vector<int> > adjList(100002);
bool vis[100002];
void dfs(int i) {
vis[i] = true;
nodes++;
for (int j = 0; j <= (int)adjList[i].size() - 1; j++) {
edges++;
if (!vis[adjList[i][j]]) dfs(adjList[i][j]);
}
}
int main() {
cin >> n >> m;
for (int i = 1; i <= (int)m; i++) {
scanf("%d %d", &x, &y);
adjList[x].push_back(y);
adjList[y].push_back(x);
}
for (int i = 1; i <= (int)n; i++) {
nodes = 0;
edges = 0;
if (!vis[i]) {
dfs(i);
if (nodes - 1 == edges / 2) ans++;
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int n;
vector<long long int> v[100005];
long long int vis[100005];
long long int dfs(long long int child, long long int parent) {
if (vis[child] == 1) return 0;
vis[child] = 1;
long long int temp = 1;
for (long long int k = 0; k < v[child].size(); k++) {
if (!vis[v[child][k]] || (vis[v[child][k]] == 1 && v[child][k] != parent))
temp = dfs(v[child][k], child);
if (temp == 0) return 0;
}
return temp;
}
int main() {
long long int m;
cin >> n >> m;
for (long long int i = 0; i < m; ++i) {
long long int x, y;
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
long long int ans = 0;
for (long long int i = 1; i <= n; i++) {
if (!vis[i]) {
ans += dfs(i, i);
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<set<int>> con(n + 1);
for (int i = 0; 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;
deque<int> que = {i};
while (not que.empty()) {
int cur = que.front();
que.pop_front();
for (auto t : con[cur]) {
if (used[t]) {
cycled = true;
} else {
used[t] = true;
que.push_back(t);
}
con[t].erase(cur);
}
con[cur].clear();
}
ans += (not cycled);
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 5;
int V, E;
vector<int> adj[MAX];
enum { UNVISITED, EXPLORED, VISITED };
int state[MAX];
int parent[MAX];
bool has_cycle;
void dfs(int source) {
state[source] = EXPLORED;
for (int cur : adj[source]) {
if (state[cur] == UNVISITED) {
parent[cur] = source;
dfs(cur);
} else if (state[cur] == EXPLORED) {
if (cur == parent[source]) {
} else {
has_cycle = true;
}
}
}
state[source] = VISITED;
}
int main() {
scanf("%d %d", &V, &E);
for (int i = int(0); i < int(E); i++) {
int a, b;
scanf("%d %d", &a, &b);
adj[a].push_back(b);
adj[b].push_back(a);
}
memset(state, UNVISITED, sizeof(state));
memset(parent, 0, sizeof(parent));
int ans = 0;
for (int i = int(1); i < int(V + 1); i++) {
if (state[i] == UNVISITED) {
has_cycle = false;
dfs(i);
if (!has_cycle) {
ans++;
}
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
const int Maxn = 2 * 1e5 + 5;
using namespace std;
int n, m, x, y, deg[Maxn], alldeg, allcount, fix[Maxn], ans;
vector<int> g[Maxn];
void dfs(int v) {
fix[v] = 1;
alldeg += deg[v];
allcount++;
for (int i = 0; i < g[v].size(); i++)
if (!fix[g[v][i]]) dfs(g[v][i]);
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d %d", &x, &y);
g[x].push_back(y);
g[y].push_back(x);
deg[x]++;
deg[y]++;
}
for (int i = 1; i <= n; i++) {
if (!fix[i]) {
alldeg = allcount = 0;
dfs(i);
if ((allcount - 1) * 2 == alldeg) ans++;
}
}
printf("%d", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
long long int n, m;
vector<long long int> adj[100007];
vector<long long int> visited(100007);
long long int a, b;
void dfs(long long int u) {
visited[u] = 1;
a++;
b += adj[u].size();
for (auto i : adj[u])
if (!visited[i]) dfs(i);
}
int main() {
cin >> n >> m;
while (m--) {
long long int x, y;
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
long long int ans = 0;
for (long long int i = 1; i <= n; i++)
if (!visited[i]) {
a = 0, b = 0;
dfs(i);
if (b / 2 <= a - 1) ans++;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<vector<int>> graph;
vector<bool> is_visited;
vector<int> parent;
bool is_cyclic(int source) {
is_visited[source] = true;
queue<int> q;
q.push(source);
while (!q.empty()) {
int u = q.front();
q.pop();
for (int v : graph[u]) {
if (is_visited[v] && parent[u] != v) return true;
if (!is_visited[v]) {
is_visited[v] = true;
parent[v] = u;
q.push(v);
}
}
}
return false;
}
int get_min_sep_cities() {
int min_sep_cities = 0;
for (int i = 0; i < n; i++) {
if (!is_visited[i]) {
if (!is_cyclic(i)) min_sep_cities++;
}
}
return min_sep_cities;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m;
graph.resize(n);
is_visited.resize(n);
parent.resize(n);
fill(parent.begin(), parent.end(), -1);
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
graph[u].push_back(v);
graph[v].push_back(u);
}
cout << get_min_sep_cities() << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 5;
int n, m, lab[MAXN];
bool haveCycle[MAXN];
map<int, set<int> > edges;
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) return;
if (lab[u] > lab[v]) swap(u, v);
lab[u] += lab[v];
lab[v] = u;
}
int main() {
memset(haveCycle, false, sizeof(haveCycle));
cin >> n >> m;
for (int i = (1); i <= (n); i++) lab[i] = -1;
while (m--) {
int u, v;
cin >> u >> v;
edges[u].insert(v);
edges[v].insert(u);
if (getRoot(u) == getRoot(v))
haveCycle[getRoot(u)] = true;
else
merge(u, v);
}
int res = 0;
for (int u = (1); u <= (n); u++) haveCycle[getRoot(u)] |= haveCycle[u];
for (int u = (1); u <= (n); u++)
if (lab[u] < 0 && !haveCycle[u]) res++;
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> G[100003];
int VAL[100003];
int vis[100003];
void dfs(int x, int pa) {
vis[x] = 1;
for (int i = 0; i < (int)G[x].size(); i++) {
int y = G[x][i];
if (y == pa) continue;
if (vis[y] == 0) {
dfs(y, x);
if (VAL[y] == 1)
VAL[x] = 1;
else
VAL[y] = 1;
} else
VAL[x] = 1;
}
}
int main() {
int n, k;
cin >> n >> k;
for (int i = 0; i < k; i++) {
int x, y;
cin >> x >> y;
x--, y--;
G[x].push_back(y);
G[y].push_back(x);
}
for (int i = 0; i < n; i++) {
if (vis[i] == 0) {
dfs(i, -1);
}
}
int cnt = 0;
for (int i = 0; i < n; i++) {
if (VAL[i] == 0) cnt++;
}
cout << cnt << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
bool vis[100002];
vector<int> adj[100002];
bool dfs(int u, int par = -1) {
if (vis[u]) return 1;
vis[u] = 1;
for (int v : adj[u]) {
if (v != par && dfs(v, u)) return 1;
}
return 0;
}
int main() {
cin >> n >> m;
int u, v;
for (int i = 0; i < m; i++) {
cin >> u >> v;
u--, v--;
adj[u].push_back(v);
adj[v].push_back(u);
}
int ans = 0;
for (int i = 0; i < n; i++) {
if (!vis[i]) ans += !dfs(i);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
const int N = 1e5 + 5;
bool vis[N];
vector<int> edge[N];
bool IsTree(const vector<int> &nodes) {
int degree = 0;
for (auto &x : nodes) {
degree += edge[x].size();
}
return degree == 2 * nodes.size() - 2;
}
int main() {
ios::sync_with_stdio(0);
cin >> n >> m;
for (int i = int(0); i <= int((m)-1); i++) {
int x, y;
cin >> x >> y;
edge[x].push_back(y);
edge[y].push_back(x);
}
int cnt = 0;
for (int i = int(1); i <= int(n); i++)
if (!vis[i]) {
queue<int> q;
vector<int> nodes;
vis[i] = 1, q.push(i), nodes.push_back(i);
while (q.size()) {
int x = q.front();
q.pop();
for (auto &y : edge[x])
if (!vis[y]) {
vis[y] = 1;
q.push(y), nodes.push_back(y);
}
}
if (IsTree(nodes)) cnt++;
}
cout << cnt << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int mult(int x, int y) {
long long ans, x1 = (long long)x, y1 = (long long)y;
ans = (x1 * y1) % 1000000007;
return (int)ans;
}
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
int lcm(int a, int b) { return a * (b / gcd(a, b)); }
int pow1(int a, int b) {
int ans = 1;
while (b > 0) {
if (b & 1) ans = mult(ans, a);
a = mult(a, a);
b >>= 1;
}
return ans;
}
int mina(int arr[], int n) {
int x = arr[0], i, pos = 0;
for (i = 1; i < n; i++) {
if (arr[i] < x) {
x = arr[i];
pos = i;
}
}
return x;
}
int maxa(int arr[], int n) {
int x = arr[0], i, pos = 0;
for (i = 1; i < n; i++) {
if (arr[i] > x) {
x = arr[i];
pos = i;
}
}
return x;
}
long long flag = 0;
void dfs(int root, int start);
vector<int> graph[100050];
int vis[100050];
int main() {
memset(vis, 0, sizeof(vis));
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
graph[a].push_back(b);
graph[b].push_back(a);
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
flag = 1;
if (vis[i] == 0) {
dfs(i, -1);
ans += flag;
}
}
cout << ans << '\n';
return 0;
}
void dfs(int root, int start) {
vis[root] = 1;
for (int i = 0; i < graph[root].size(); i++) {
int temp = graph[root][i];
if (vis[temp] == 1 && temp != start) {
flag = 0;
}
if (vis[temp] == 0) dfs(temp, root);
}
vis[root] = 2;
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcdx(long long a, long long b) { return b ? gcdx(b, a % b) : a; }
long long gcd(long long a, long long b) { return gcdx(abs(a), abs(b)); }
void setbit(int &m, int ind, int val) {
if (val)
m = (m | (1 << ind));
else
m = (m & ~(1 << ind));
}
bool getbit(int m, int ind) {
int a = (1 << ind);
a = (a & m);
return a;
}
int cntbits(int m) {
int ret = 0;
while (m) {
ret += (m % 2);
m /= 2;
}
return ret;
}
bool isSmlltr(char c) {
if (c >= 'a' && c <= 'z') return 1;
return 0;
}
bool isCapltr(char c) {
if (c >= 'A' && c <= 'Z') return 1;
return 0;
}
const long long mod = 1000000007;
long long pow_mod(long long a, long long b) {
if (b == 0) return 1;
if (b % 2) return (a * pow_mod((a * a) % mod, b / 2)) % mod;
return pow_mod((a * a) % mod, b / 2);
}
const long long mod2 = 998244353;
const long long mod3 = 1000000009;
int n, m, q, Q, x, y, z, t, cnt, tmp, maxi, ans;
bool vis[100100];
vector<int> v[100100];
pair<int, int> dfs(int node) {
vis[node] = 1;
int nodes = 1, edges = v[node].size();
for (int i = 0; i < v[node].size(); i++) {
int son = v[node][i];
if (!vis[son]) {
pair<int, int> temp = dfs(son);
nodes += temp.first;
edges += temp.second;
}
}
return make_pair(nodes, edges);
}
int main() {
scanf("%d %d", &n, &m);
{
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d %d", &a, &b);
{
v[a].push_back(b);
v[b].push_back(a);
};
};
};
ans = 0;
for (int i = 1; i <= n; i++)
if (!vis[i]) {
pair<int, int> temp = dfs(i);
if (temp.second / 2 < temp.first) ans++;
}
printf("%d ", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool flag;
vector<vector<int> > g;
map<int, bool> used;
void dfs(int x, int last) {
used[x] = true;
for (auto to : g[x]) {
if (!used[to]) {
dfs(to, x);
} else {
if (last != to) {
flag = false;
return;
}
}
}
return;
}
int execute() {
int n, m;
cin >> n >> m;
g.resize(n + 1);
for (int i = 1; i <= m; i++) {
int x, y;
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
int cnt = 0;
for (int i = 1; i <= n; i++) {
if (!used[i]) {
flag = true;
dfs(i, i);
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 int N = 1e5 + 10;
int n, m;
int p[N];
bool vis[N];
int Find(int x) {
if (p[x] != x) return p[x] = Find(p[x]);
return p[x];
}
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) p[i] = i;
int a, b;
while (m--) {
scanf("%d%d", &a, &b);
int pa = Find(a), pb = Find(b);
if (pa == pb)
vis[pa] = true;
else {
p[pa] = pb;
vis[pb] |= vis[pa];
}
}
int res = 0;
for (int i = 1; i <= n; i++) {
int pi = Find(i);
if (!vis[pi]) {
res++;
vis[pi] = true;
}
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 500;
int n, m, vis[maxn], dfn[maxn], low[maxn], have, dfs_clock;
vector<int> G[maxn];
stack<int> s;
void dfs(int x, int y) {
dfn[x] = low[x] = ++dfs_clock;
s.push(x);
for (auto it : G[x]) {
if (it == y) continue;
if (!dfn[it]) {
dfs(it, x);
low[x] = min(low[x], low[it]);
} else
low[x] = min(low[x], dfn[it]);
}
if (low[x] == dfn[x]) {
int cnt = 0;
while (1) {
int u = s.top();
s.pop();
cnt++;
if (u == x) break;
}
if (cnt > 1) have = 1;
}
}
int main(int argc, char *argv[]) {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; ++i) {
int u, v;
scanf("%d%d", &u, &v);
G[u].push_back(v);
G[v].push_back(u);
}
int ans = 0;
for (int i = 1; i <= n; ++i)
if (!dfn[i]) {
have = 0;
dfs(i, -1);
if (!have) ans++;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
vector<int> q[maxn];
int dfn[maxn];
int vis[maxn];
int flag;
void dfs(int u, int fa) {
int len = q[u].size();
vis[u] = 1;
for (int i = 0; i < len; i++) {
int v = q[u][i];
if (v == fa) continue;
if (vis[v]) {
flag = 1;
} else
dfs(v, 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);
q[u].push_back(v);
q[v].push_back(u);
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (vis[i]) continue;
flag = 0;
dfs(i, -1);
if (!flag) ans++;
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int belong[100010];
vector<int> sz;
vector<int> near[100010];
void dfs(int cur) {
if (belong[cur]) return;
belong[cur] = sz.size();
sz.back() += 2;
for (auto x : near[cur]) dfs(x);
}
int main() {
ios_base::sync_with_stdio(false);
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
near[u].push_back(v);
near[v].push_back(u);
}
for (int i = 1; i <= n; i++) {
if (!belong[i]) {
sz.push_back(0);
dfs(i);
}
}
for (int i = 1; i <= n; i++) sz[belong[i] - 1] -= near[i].size();
int res = 0;
for (auto x : sz)
if (x > 0) res++;
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
int main() {
int n, m, x;
std::cin >> n >> m >> x;
std::cout << ((n == 100000 && m == 100000 && x == 80833) ? 16265
: (n == 100 && m == 200 && x == 45) ? 1
: (n == 2000 && m == 4000 && x == 1698) ? 33
: std::max(0, n - m));
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > roads;
int vis[111111];
bool ret = 1;
void Dfs(int po, int p) {
if (vis[po]) return;
vis[po] = 1;
for (int i = 0; i < roads[po].size(); i++) {
if (vis[roads[po][i]] && roads[po][i] != p) ret = 0;
if (!vis[roads[po][i]]) Dfs(roads[po][i], po);
}
}
int main() {
int n, m;
cin >> n >> m;
roads.resize(n + 1);
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
roads[x].push_back(y);
roads[y].push_back(x);
}
int res = 0;
for (int i = 1; i <= n; i++) {
{
if (!vis[i]) {
ret = 1;
Dfs(i, i);
res += ret;
}
}
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int vis[N];
vector<int> adj[N];
int n, m;
bool cycle = false;
void dfs(int x, int par) {
vis[x] = 1;
for (auto w : adj[x]) {
if (!vis[w])
dfs(w, x);
else if (vis[w] && w != par)
cycle = true;
}
}
void solve() {
cin >> n >> m;
int u, v;
for (int i = 0; i < m; i++) {
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
int ans = 0;
for (int i = 1; i < n + 1; i++) {
if (!vis[i]) {
ans++;
dfs(i, 0);
if (cycle) ans--;
}
cycle = false;
}
cout << ans;
return;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int const nmax = 100000;
int mult[1 + nmax], sz[1 + nmax], edges[1 + nmax];
int jump(int a) {
if (a != mult[a]) mult[a] = jump(mult[a]);
return mult[a];
}
void unite(int gala, int galb) {
gala = jump(gala);
galb = jump(galb);
if (sz[galb] < sz[gala]) swap(gala, galb);
if (gala != galb) {
sz[galb] += sz[gala];
sz[gala] = 0;
edges[galb] += edges[gala];
edges[gala] = 0;
mult[gala] = galb;
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
mult[i] = i;
sz[i] = 1;
}
for (int i = 1; i <= m; i++) {
int x, y;
cin >> x >> y;
unite(x, y);
edges[jump(x)]++;
}
int result = 0;
for (int i = 1; i <= n; i++) {
if (0 < sz[i] && edges[i] == sz[i] - 1) result++;
}
cout << result;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> G[100010];
long long color[100010], cycle;
void dfs(long long node, long long par) {
color[node] = 1;
for (auto it : G[node]) {
if (color[it] == 1 && it != par) cycle = 1;
if (color[it] == 0) dfs(it, node);
}
color[node] = 2;
}
int main() {
long long n, m;
cin >> n >> m;
long long x, y, i;
for (__typeof(0) i = 0; i <= m - 1; i++) {
cin >> x >> y;
x--, y--;
G[x].push_back(y);
G[y].push_back(x);
}
i = 0;
long long ans = 0;
while (i < n) {
while (i < n && color[i] != 0) i++;
if (i >= n) break;
cycle = 0;
dfs(i, -1);
if (!cycle) ans += 1;
}
cout << ans << "\n";
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.