solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n = 0, a, i, j, k, l, m, d, sn, tn, un, z1, z2, ans = 0;
string s, t, u;
getline(cin, s);
getline(cin, u);
sn = s.size();
un = u.size();
if (un > sn) {
z1 = 0;
for (i = -un + 1; i < sn + un - 1; i++) {
z2 = 0;
for (j = 0; j < un; j++) {
if ((i + j >= 0) && (i + j <= sn - 1))
if (s[i + j] == u[j]) z2++;
}
z1 = max(z1, z2);
}
ans = un - z1;
} else if (un == sn) {
z1 = 0;
for (i = -un + 1; i < sn + un - 1; i++) {
z2 = 0;
for (j = 0; j < un; j++) {
if ((i + j >= 0) && (i + j <= sn - 1))
if (s[i + j] == u[j]) z2++;
}
z1 = max(z1, z2);
}
ans = un - z1;
} else {
z1 = 0;
for (i = -un + 1; i < sn + un - 1; i++) {
z2 = 0;
for (j = 0; j < un; j++) {
if ((i + j >= 0) && (i + j <= sn - 1))
if (s[i + j] == u[j]) z2++;
}
z1 = max(z1, z2);
}
ans = un - z1;
}
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
struct point {
int x, y;
};
struct target {
point l, r;
int h, ix;
} dat[100005];
list<target> lst;
bool cmp(target a, target b) {
if (a.h < b.h) return true;
return false;
}
bool inRange(point a, target b) {
if (a.x >= b.l.x && a.x <= b.r.x && a.y >= b.l.y && a.y <= b.r.y) return true;
return false;
}
bool vis[100005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> dat[i].l.x >> dat[i].r.x >> dat[i].l.y >> dat[i].r.y >> dat[i].h;
dat[i].ix = i;
}
sort(dat + 1, dat + n + 1, cmp);
for (int i = 1; i <= n; i++) {
lst.push_back(dat[i]);
}
int m;
cin >> m;
point bul;
while (m--) {
int ans = 0;
cin >> bul.x >> bul.y;
for (list<target>::iterator it = lst.begin(); it != lst.end(); it++) {
if (inRange(bul, *it)) {
ans = it->ix;
lst.erase(it);
break;
}
}
cout << ans << "\n";
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long ans, C[120][120], n, t, m, i, o, s, j;
int main() {
scanf("%I64d%I64d", &n, &t);
for (s = 1, m = 1; s < t; s <<= 1, m++)
;
if (s != t) return puts("0"), 0;
if (m == 1) ans--;
n++;
for (i = 0; i <= 60; ++i)
for (j = 0; j <= i; ++j) C[i][j] = !j ? 1 : C[i - 1][j - 1] + C[i - 1][j];
for (i = 60; i >= 0; --i) {
if (m < 0) break;
if (o + (1ll << i) <= n) {
ans += C[i][m];
m--;
o += 1ll << i;
}
}
if (!m) ans++;
printf("%I64d\n", ans);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long md = 1e9 + 7;
int n, m;
vector<int> q, v[200005];
long long s[200005], dp[200005];
map<int, int> mt;
int last;
pair<int, int> a[100005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
q.push_back(0);
q.push_back(n);
for (int i = 1; i <= m; ++i) {
cin >> a[i].first >> a[i].second;
q.push_back(a[i].first);
q.push_back(a[i].second);
}
sort(q.begin(), q.end());
for (int i = 0; i < q.size(); ++i) {
if (i == 0) {
continue;
}
if (q[i] != q[i - 1]) ++last;
mt[q[i]] = last;
}
for (int i = 1; i <= m; ++i) {
a[i].first = mt[a[i].first];
a[i].second = mt[a[i].second];
v[a[i].second].push_back(a[i].first);
}
dp[0] = 1;
s[0] = 1;
for (int i = 1; i <= last; ++i) {
s[i] = s[i - 1];
for (int j = 0; j < v[i].size(); ++j) {
int x = v[i][j];
if (x != 0)
dp[i] = (dp[i] + s[i - 1] - (s[x - 1]) + md) % md;
else
dp[i] = (dp[i] + s[i - 1] + md) % md;
}
s[i] = (s[i] + dp[i]) % md;
}
cout << dp[last];
}
| 4 |
#include <bits/stdc++.h>
std::vector<std::pair<int, int> > grades;
int main(int argc, char const *argv[]) {
long long n, r, avg;
std::cin >> n >> r >> avg;
long long rest = avg * n;
for (int i = 0; i < n; ++i) {
int a, b;
std::cin >> a >> b;
grades.push_back(std::make_pair(b, a));
rest -= a;
}
std::sort(grades.begin(), grades.end());
long long first = 0LL;
int i = 0;
while (rest > 0 && i < n) {
long long use = r - grades[i].second;
if (rest <= use) {
use = rest;
}
rest -= use;
first += use * grades[i].first;
i++;
}
std::cout << first << '\n';
return EXIT_SUCCESS;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL);
int n;
string s;
cin >> n;
while (n--) {
cin >> s;
int l = s.length();
long long res = 0;
int cnt = 0;
string x = "";
for (int i = 0; i < l; i++)
if (s[i] >= '0' && s[i] <= '9')
res = res * 10 + s[i] - '0', cnt++, x += s[i];
long long mn = 1989, mx = 1998, poww = 10;
for (int i = 1; i < cnt; i++) {
poww *= 10;
mn = mx + 1;
mx = mn + poww - 1;
}
if (mn % poww > res) mn += poww;
string c = to_string(mn);
l = c.length();
for (int i = 0; i < l - cnt; i++) cout << c[i];
cout << x << endl;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int i, j, k, n, sum = 0, ans = 0, x, y, z, a[100005] = {0}, index,
id;
long long int d, m;
cin >> n >> k >> m >> d;
for (i = 0; i < d; i++) {
sum = 0;
if ((n / k) > 1 / k + i) {
x = 1 + k * i;
y = n / x;
if (y > m) {
sum = m * (i + 1);
} else {
sum = y * (i + 1);
}
ans = max(ans, sum);
}
}
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long double pi = acos(-1.0);
const long double eps = 1e-7;
long long a, w, h;
long double solve() {
if (a > 90) a = 180 - a;
if (a == 0) return w * h;
if (a == 90) return ((min(w, h)) * (min(w, h)));
long double n[4], k[4], ans = 0, x[9], y[9], w2 = (long double)w / 2,
h2 = (long double)h / 2, alpha;
int len = 0;
alpha = pi * a / 180;
k[0] = tan(alpha);
n[0] = h / (2 * cos(alpha));
k[1] = -1 / k[0];
n[1] = -w / (2 * sin(alpha));
k[2] = k[0];
k[3] = k[1];
n[2] = -n[0];
n[3] = -n[1];
for (int i = 0; i < 2; ++i) {
for (int j = 0; j < 2; ++j) {
y[len] = i ^ j ? -h2 : h2;
x[len] = (y[len] - n[2 * i]) / k[2 * i];
if (((-w2 <= x[len] + eps) && (x[len] <= w2 + eps))) ++len;
}
for (int j = 0; j < 2; ++j) {
x[len] = i ^ j ? w2 : -w2;
y[len] = x[len] * k[2 * i] + n[2 * i];
if (((-h2 <= y[len] + eps) && (y[len] <= h2 + eps))) ++len;
}
for (int j = 0; j < 2; ++j) {
x[len] = i ^ j ? w2 : -w2;
y[len] = x[len] * k[2 * i + 1] + n[2 * i + 1];
if (((-h2 <= y[len] + eps) && (y[len] <= h2 + eps))) ++len;
}
for (int j = 0; j < 2; ++j) {
y[len] = i ^ j ? h2 : -h2;
x[len] = (y[len] - n[2 * i + 1]) / k[2 * i + 1];
if (((-w2 <= x[len] + eps) && (x[len] <= w2 + eps))) ++len;
}
}
for (int i = 0; i < len; ++i)
ans += abs(x[i] * y[(i + 1) % len] - x[(i + 1) % len] * y[i]);
return ans / 2;
}
int main() {
scanf("%I64d %I64d %I64d", &w, &h, &a);
cout << setprecision(15) << fixed;
cout << solve() << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
int main() {
int n, k;
std::cin >> n >> k;
std::vector<std::pair<int, int>> results(n);
for (int i = 0; i < n; ++i) {
int p, t;
std::cin >> p >> t;
results[i] = {p, t};
}
std::sort(results.begin(), results.end(),
[](const std::pair<int, int>& lhs, const std::pair<int, int>& rhs) {
if (lhs.first == rhs.first) return lhs.second < rhs.second;
return lhs.first > rhs.first;
});
std::vector<int> teams(n);
int id = 1;
teams[0] = id;
for (int i = 1; i < n; ++i) {
if (results[i - 1] == results[i]) {
teams[i] = id;
} else {
id++;
teams[i] = id;
}
}
int team_id = teams[k - 1];
auto l = std::lower_bound(teams.begin(), teams.end(), team_id);
auto r = std::upper_bound(teams.begin(), teams.end(), team_id);
std::cout << r - l << '\n';
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long M = 1000000000 + 7;
long long power(long long x, long long n) {
long long result = 1;
while (n > 0) {
if (n % 2 == 1) result = (result * x) % M;
x = (x * x) % M;
n = n / 2;
}
return result;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, x;
cin >> x >> n;
vector<long long> prime;
long long tx = x;
long long div = 2;
for (long long i = 2; i * i <= x; i++) {
long long temptx = tx;
while (tx % div == 0) {
tx /= div;
}
if (tx != temptx) prime.push_back(div);
div++;
}
if (tx >= 2) prime.push_back(tx);
long long ans = 1;
for (long long p : prime) {
long long i = 1;
long long sum = 0;
long long ratio = n / p;
i = 2;
while (ratio != 0) {
ans *= power(p, ratio);
ans %= M;
ratio /= p;
}
}
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int arr[1000000];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string str;
vector<long long int> vect;
long long int t, i, j, n, a, m, val;
cin >> t;
while (t--) {
str.clear();
vect.clear();
val = 0;
a = 0;
cin >> str;
n = str.size();
for (i = 0; i < n; i++) {
if (str[i] == '1') {
a++;
} else {
if (a != 0) vect.push_back(a);
a = 0;
}
}
if (a != 0) vect.push_back(a);
m = vect.size();
sort(vect.begin(), vect.end());
for (i = m - 1; i >= 0; i -= 2) {
val += vect[i];
}
cout << val << '\n';
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, num, nums[10005];
long long a[1000005], d[1000005];
void divide(long long v) {
num = 0;
for (long long i = 1; i * i <= v; i++) {
if (v % i == 0) {
d[++num] = i;
if (v / i != i) d[++num] = v / i;
}
}
}
long long gcd(long long a, long long b) {
if (!b) return a;
return gcd(b, a % b);
}
int main() {
srand(time(NULL));
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
int t = 11;
long long ans = 1;
while (t--) {
long long x = a[1ll * rand() * rand() % n + 1];
divide(x);
sort(d + 1, d + num + 1);
memset(nums, 0, sizeof(nums));
for (int i = 1; i <= n; i++) {
int pos = lower_bound(d + 1, d + num + 1, gcd(x, a[i])) - d;
nums[pos]++;
}
for (int i = 1; i <= num; i++)
for (int j = i + 1; j <= num; j++)
if (d[j] % d[i] == 0) nums[i] += nums[j];
for (int i = num; i >= 1; i--) {
if (nums[i] * 2 >= n) {
ans = max(ans, d[i]);
break;
}
}
}
printf("%lld\n", ans);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T inverse(T a, T m) {
T u = 0, v = 1;
while (a != 0) {
T t = m / a;
m -= t * a;
swap(a, m);
u -= t * v;
swap(u, v);
}
assert(m == 1);
return u;
}
template <typename T>
class Modular {
public:
using Type = typename decay<decltype(T::value)>::type;
constexpr Modular() : value() {}
template <typename U>
Modular(const U &x) {
value = normalize(x);
}
template <typename U>
static Type normalize(const U &x) {
Type v;
if (-mod() <= x && x < mod())
v = static_cast<Type>(x);
else
v = static_cast<Type>(x % mod());
if (v < 0) v += mod();
return v;
}
const Type &operator()() const { return value; }
template <typename U>
explicit operator U() const {
return static_cast<U>(value);
}
constexpr static Type mod() { return T::value; }
Modular &operator+=(const Modular &other) {
if ((value += other.value) >= mod()) value -= mod();
return *this;
}
Modular &operator-=(const Modular &other) {
if ((value -= other.value) < 0) value += mod();
return *this;
}
template <typename U>
Modular &operator+=(const U &other) {
return *this += Modular(other);
}
template <typename U>
Modular &operator-=(const U &other) {
return *this -= Modular(other);
}
Modular &operator++() { return *this += 1; }
Modular &operator--() { return *this -= 1; }
Modular operator++(int) {
Modular result(*this);
*this += 1;
return result;
}
Modular operator--(int) {
Modular result(*this);
*this -= 1;
return result;
}
Modular operator-() const { return Modular(-value); }
template <typename U = T>
typename enable_if<is_same<typename Modular<U>::Type, int>::value,
Modular>::type &
operator*=(const Modular &rhs) {
value = normalize(static_cast<int64_t>(value) *
static_cast<int64_t>(rhs.value));
return *this;
}
template <typename U = T>
typename enable_if<is_same<typename Modular<U>::Type, long long>::value,
Modular>::type &
operator*=(const Modular &rhs) {
long long q = static_cast<long long>(static_cast<long double>(value) *
rhs.value / mod());
value = normalize(value * rhs.value - q * mod());
return *this;
}
template <typename U = T>
typename enable_if<!is_integral<typename Modular<U>::Type>::value,
Modular>::type &
operator*=(const Modular &rhs) {
value = normalize(value * rhs.value);
return *this;
}
Modular &operator/=(const Modular &other) {
return *this *= Modular(inverse(other.value, mod()));
}
friend const Type &abs(const Modular &x) { return x.value; }
template <typename U>
friend bool operator==(const Modular<U> &lhs, const Modular<U> &rhs);
template <typename U>
friend bool operator<(const Modular<U> &lhs, const Modular<U> &rhs);
template <typename V, typename U>
friend V &operator>>(V &stream, Modular<U> &number);
private:
Type value;
};
template <typename T>
bool operator==(const Modular<T> &lhs, const Modular<T> &rhs) {
return lhs.value == rhs.value;
}
template <typename T, typename U>
bool operator==(const Modular<T> &lhs, U rhs) {
return lhs == Modular<T>(rhs);
}
template <typename T, typename U>
bool operator==(U lhs, const Modular<T> &rhs) {
return Modular<T>(lhs) == rhs;
}
template <typename T>
bool operator!=(const Modular<T> &lhs, const Modular<T> &rhs) {
return !(lhs == rhs);
}
template <typename T, typename U>
bool operator!=(const Modular<T> &lhs, U rhs) {
return !(lhs == rhs);
}
template <typename T, typename U>
bool operator!=(U lhs, const Modular<T> &rhs) {
return !(lhs == rhs);
}
template <typename T>
bool operator<(const Modular<T> &lhs, const Modular<T> &rhs) {
return lhs.value < rhs.value;
}
template <typename T>
Modular<T> operator+(const Modular<T> &lhs, const Modular<T> &rhs) {
return Modular<T>(lhs) += rhs;
}
template <typename T, typename U>
Modular<T> operator+(const Modular<T> &lhs, U rhs) {
return Modular<T>(lhs) += rhs;
}
template <typename T, typename U>
Modular<T> operator+(U lhs, const Modular<T> &rhs) {
return Modular<T>(lhs) += rhs;
}
template <typename T>
Modular<T> operator-(const Modular<T> &lhs, const Modular<T> &rhs) {
return Modular<T>(lhs) -= rhs;
}
template <typename T, typename U>
Modular<T> operator-(const Modular<T> &lhs, U rhs) {
return Modular<T>(lhs) -= rhs;
}
template <typename T, typename U>
Modular<T> operator-(U lhs, const Modular<T> &rhs) {
return Modular<T>(lhs) -= rhs;
}
template <typename T>
Modular<T> operator*(const Modular<T> &lhs, const Modular<T> &rhs) {
return Modular<T>(lhs) *= rhs;
}
template <typename T, typename U>
Modular<T> operator*(const Modular<T> &lhs, U rhs) {
return Modular<T>(lhs) *= rhs;
}
template <typename T, typename U>
Modular<T> operator*(U lhs, const Modular<T> &rhs) {
return Modular<T>(lhs) *= rhs;
}
template <typename T>
Modular<T> operator/(const Modular<T> &lhs, const Modular<T> &rhs) {
return Modular<T>(lhs) /= rhs;
}
template <typename T, typename U>
Modular<T> operator/(const Modular<T> &lhs, U rhs) {
return Modular<T>(lhs) /= rhs;
}
template <typename T, typename U>
Modular<T> operator/(U lhs, const Modular<T> &rhs) {
return Modular<T>(lhs) /= rhs;
}
template <typename T, typename U>
Modular<T> power(const Modular<T> &a, const U &b) {
assert(b >= 0);
Modular<T> x = a, res = 1;
U p = b;
while (p > 0) {
if (p & 1) res *= x;
x *= x;
p >>= 1;
}
return res;
}
template <typename T>
bool IsZero(const Modular<T> &number) {
return number() == 0;
}
template <typename T>
string to_string(const Modular<T> &number) {
return to_string(number());
}
template <typename U, typename T>
U &operator<<(U &stream, const Modular<T> &number) {
return stream << number();
}
template <typename U, typename T>
U &operator>>(U &stream, Modular<T> &number) {
typename common_type<typename Modular<T>::Type, long long>::type x;
stream >> x;
number.value = Modular<T>::normalize(x);
return stream;
}
constexpr int md = (int)998244353;
using Mint = Modular<std::integral_constant<decay<decltype(md)>::type, md>>;
vector<Mint> fact(1, 1);
vector<Mint> inv_fact(1, 1);
Mint C(int n, int k) {
if (k < 0 || k > n) {
return 0;
}
while ((int)fact.size() < n + 1) {
fact.push_back(fact.back() * (int)fact.size());
inv_fact.push_back(1 / fact.back());
}
return fact[n] * inv_fact[k] * inv_fact[n - k];
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n, k;
cin >> n >> k;
string s;
cin >> s;
vector<int> pos;
for (int i = 0; i < n; i++) {
if (s[i] == '1') pos.emplace_back(i);
}
if (k == 0 || k > pos.size()) {
cout << 1;
return 0;
}
int l = 0, r = pos[k - 1];
int cnt0 = r - l + 1 - k, cnt1 = k;
Mint q = C(5005, 1);
Mint ans = fact[cnt0 + cnt1] / fact[cnt0] / fact[cnt1] - 1;
r++;
if (r < n) {
if (s[r] == '0')
cnt0++;
else
cnt1++;
}
while (r < n) {
while (cnt1 > k) {
if (s[l] == '0')
cnt0--;
else
cnt1--;
l++;
}
int c1 = cnt1, c0 = cnt0;
if (s[r] == '1')
c0--;
else
c1--;
if (c0 >= 0 && c1 >= 0) ans += fact[c0 + c1] / fact[c0] / fact[c1];
r++;
if (r == n) break;
if (s[r] == '0')
cnt0++;
else
cnt1++;
}
cout << ans + 1;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int data[100010];
int main() {
int n;
int x, k;
cin >> n;
for (int i = 0; i <= n - 1; i++) {
cin >> x >> k;
if (data[k] < x) {
cout << "NO" << endl;
return 0;
}
data[k] = max(x + 1, data[k]);
}
cout << "YES" << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 2e5 + 5;
int arr[MAX];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &arr[i]);
int x = -1, y = -1, mx = arr[0];
for (int i = 0; i < n - 1; i++) {
mx = max(mx, arr[i + 1]);
int dif = abs(arr[i] - arr[i + 1]);
if (dif > 1) {
if (y == -1)
y = dif;
else if (dif != y) {
puts("NO");
return 0;
}
}
if (dif == 0) {
puts("NO");
return 0;
}
}
if (y == -1) {
puts("YES");
printf("1 %d", mx);
return 0;
}
for (int i = 0; i < n - 1; i++) {
int now = arr[i];
int nxt = arr[i + 1];
if (now % y == 0) {
if (nxt != now + y && nxt != now - y && nxt != now - 1) {
puts("NO");
return 0;
}
} else if (now % y == 1) {
if (nxt != now + y && nxt != now - y && nxt != now + 1) {
puts("NO");
return 0;
}
} else if (nxt != now + 1 && nxt != now - 1 && nxt != now - y &&
nxt != now + y) {
puts("NO");
return 0;
}
}
x = ceil((double)mx / (double)y);
puts("YES");
printf("%d %d", x, y);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
string s[109], q;
int d[109];
int v[1009];
int main() {
int a, b;
cin >> a >> b;
for (int i = 1; i <= a; i++) cin >> s[i];
for (int i = 1; i <= b; i++) {
cin >> d[i];
v[d[i]] = 1;
}
bool u, r = 1;
for (int i = 0; i < (int)s[d[1]].size(); i++) {
u = 1;
for (int j = 2; j <= b; j++) {
if (!r) break;
if ((int)s[d[j]].size() != (int)s[d[1]].size()) {
r = 0;
break;
}
if (s[d[j]][i] != s[d[1]][i]) u = 0;
}
if (u) {
q += s[d[1]][i];
} else
q += "?";
}
for (int i = 1; i <= a; i++) {
u = 0;
if (!v[i] and (int) s[d[1]].size() == (int)s[i].size()) {
for (int j = 0; j < (int)q.size(); j++) {
if (q[j] != '?' and q[j] != s[i][j]) u = 1;
}
if (u == 0) r = 0;
}
}
if (!r)
cout << "No" << endl;
else {
cout << "Yes" << endl;
cout << q << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, T, a, m;
double mean = 0.0;
double sum = 0.0, c;
scanf("%d%d%lf", &n, &T, &c);
double* b1 = new double[n];
double* b2 = new double[n];
double* b3 = new double[n];
for (int i = 0; i < T - 1; i++) {
scanf("%d", &a);
sum += a;
b1[i] = (a * 1.0);
mean = (mean + (a * 1.0) / T) / c;
}
for (int i = T - 1; i < n; i++) {
scanf("%d", &a);
b1[i] = (a * 1.0);
{ mean = (mean + (a * 1.0) / T) / c; }
sum += a;
if (i - T >= 0) {
sum -= b1[i - T];
}
b2[i] = mean;
b3[i] = (sum) / T;
}
scanf("%d", &m);
for (int i = 0; i < m; i++) {
scanf("%d", &a);
printf("%lf %lf %lf\n", b3[a - 1], b2[a - 1],
abs(b3[a - 1] - b2[a - 1]) / b3[a - 1]);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100;
const int M = 4;
const int INF = N * N * 4;
int n;
char c[N + 10];
int a[M][N][N];
int m[M][2];
int main() {
scanf("%d ", &n);
for (int(i) = (0); (i) < (int)(M); (i)++) {
for (int(j) = (0); (j) < (int)(n); (j)++) {
fgets(c, n + 2, stdin);
for (int(k) = (0); (k) < (int)(n); (k)++) a[i][j][k] = c[k] - '0';
}
fgets(c, 2, stdin);
}
memset(m, 0, sizeof(m));
for (int(i) = (0); (i) < (int)(M); (i)++)
for (int(j) = (0); (j) < (int)(2); (j)++) {
for (int(k) = (0); (k) < (int)(n); (k)++)
for (int(l) = (0); (l) < (int)(n); (l)++) {
int g = (k + l) & 1 ? (j + 1) & 1 : j;
if (a[i][k][l] != g) m[i][j]++;
}
}
int res = INF;
for (int(i) = (0); (i) < (int)(1 << M); (i)++) {
int cnt = 0;
for (int(j) = (0); (j) < (int)(M); (j)++)
if ((i >> j) & 1) cnt++;
if (cnt != 2) continue;
cnt = 0;
for (int(j) = (0); (j) < (int)(M); (j)++) cnt += m[j][(i >> j) & 1];
res = min(res, cnt);
}
printf("%d\n", res);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
using max_pq = priority_queue<T>;
template <class T>
using min_pq = priority_queue<T, vector<T>, greater<T>>;
long long int x, y;
template <class T>
T gcd(T a, T b) {
if (a == 0) {
x = 0, y = 1;
return b;
}
T gc = gcd(b % a, a);
T temp;
temp = x;
x = y - (b / a) * temp;
y = temp;
return gc;
}
long long int po(long long int a, long long int x, long long int m) {
if (x == 0) {
return 1;
}
long long int ans = 1;
long long int k = 1;
while (k <= x) {
if (x & k) {
ans = ((ans * a) % m);
}
k <<= 1;
a *= a;
a %= m;
}
return ans;
}
int a, b, l;
bool check(double w) {
for (double ang = 0.0000; ang <= 3.1415926535898 / 2.0; ang += 0.000005) {
double i = b - w * cos(ang);
i /= sin(ang);
double j = a - w * sin(ang);
j /= cos(ang);
if (l * cos(ang) + w * sin(ang) <= a) return true;
if (i + j < l && j > 0 && i > 0) return false;
}
return true;
}
int main() {
ios::sync_with_stdio(false);
cout.tie(0);
cin.tie(0);
cin >> a >> b >> l;
if (l <= b) {
cout << min(l, a) << '\n';
return 0;
}
double low = 0, high = min(l, b);
high = min(high, (double)a);
double ans = 0;
while (high - low > 1e-8) {
double mid = low + high;
mid /= 2;
if (check(mid)) {
ans = mid;
low = mid + 1e-8;
} else
high = mid - 1e-8;
}
if (ans == 0)
cout << "My poor head =(";
else
printf("%.8lf", ans);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n;
struct Node {
double a, b;
int id;
} poi[200200];
bool cmp(Node a, Node b) { return a.a < b.a || a.a == b.a && a.b < b.b; }
int fa[200200];
int find(int x) { return fa[x] == x ? x : fa[x] = find(fa[x]); }
int sta[200200], top;
Node en[200200];
double sl(Node x, Node y) { return (x.b - y.b) / (x.a - y.a); }
bool book[200200];
int main() {
scanf("%d", &n);
int a, b;
for (int i = 1; i <= n; ++i) {
scanf("%d%d", &a, &b);
poi[i].a = 100.00 / a;
poi[i].b = 100.00 / b;
poi[i].id = i;
fa[i] = i;
}
sort(poi + 1, poi + n + 1, cmp);
int tn = n, n = 0;
for (int i = 1; i <= tn; ++i) {
if (poi[i].a == poi[n].a && poi[i].b == poi[n].b) {
fa[find(poi[i].id)] = find(poi[n].id);
continue;
}
if (poi[i].a == poi[n].a) continue;
poi[++n] = poi[i];
}
for (int i = 1; i <= n; ++i) {
if (!top) {
sta[++top] = i;
continue;
}
while (top > 1 &&
sl(poi[i], poi[sta[top - 1]]) < sl(poi[sta[top]], poi[sta[top - 1]]))
top--;
sta[++top] = i;
}
for (int i = 1; i <= top; ++i) {
en[i] = poi[sta[i]];
}
book[find(en[1].id)] = 1;
for (int i = 1; i < top; ++i)
if (sl(en[i], en[i + 1]) < 0) {
book[find(en[i].id)] = book[find(en[i + 1].id)] = 1;
}
for (int i = 1; i <= tn; ++i)
if (book[find(i)]) printf("%d ", i);
puts("");
return 0;
}
| 9 |
#include <bits/stdc++.h>
const int N = 1e6 + 10;
using namespace std;
int fact[N];
int n, m;
int ans_for_len(int len) {
int ans = 1;
long long subseq_count = n - len + 1;
long long len_fact = fact[len];
long long other_fact = fact[n - len];
long long place_count = n - len + 1;
ans = (int)((subseq_count * ans) % m);
ans = (int)((len_fact * ans) % m);
ans = (int)((other_fact * ans) % m);
ans = (int)((place_count * ans) % m);
return ans;
}
int main() {
cin >> n >> m;
fact[0] = 1;
for (int i = 1; i < N; i++) {
fact[i] = (int)(((long long)fact[i - 1] * i) % m);
}
int ans = 0;
for (int len = 1; len <= n; len++) {
ans = (ans + ans_for_len(len)) % m;
}
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[105];
int main() {
int i, n, j = 0, k, l;
cin >> n;
for (i = 0; i < n; i++) {
cin >> a[i];
}
sort(a + 1, a + n);
while (a[0] <= a[n - 1]) {
j++;
a[n - 1]--;
a[0]++;
sort(a + 1, a + n);
}
cout << j << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using pi = pair<int, int>;
const int mod = 1e9 + 7;
const ll inf = ll(1e18);
const double PI = acos(-1), eps = 1e-9;
const int mxn = 1e6, mxa = 1e5;
int nr, ng, nb;
ll calc(ll x, ll y, ll z) {
return (x - y) * (x - y) + (y - z) * (y - z) + (x - z) * (x - z);
}
void solve() {
cin >> nr >> ng >> nb;
set<int> r, g, b;
for (int i = 0; i < nr; ++i) {
int a;
cin >> a;
r.insert(a);
}
for (int i = 0; i < ng; ++i) {
int a;
cin >> a;
g.insert(a);
}
for (int i = 0; i < nb; ++i) {
int a;
cin >> a;
b.insert(a);
}
ll ans = -1;
for (const int &x : r) {
auto it = g.upper_bound(x);
if (it != g.begin()) --it;
int y = *it;
it = b.lower_bound(x);
if (it == b.end()) --it;
int z = *it;
if (ans == -1)
ans = calc(x, y, z);
else
ans = min(ans, calc(x, y, z));
it = b.upper_bound(x);
if (it != b.begin()) --it;
z = *it;
it = g.lower_bound(x);
if (it == g.end()) --it;
y = *it;
if (ans == -1)
ans = calc(x, y, z);
else
ans = min(ans, calc(x, y, z));
}
for (const int &y : g) {
auto it = r.upper_bound(y);
if (it != r.begin()) --it;
int x = *it;
it = b.lower_bound(y);
if (it == b.end()) --it;
int z = *it;
if (ans == -1)
ans = calc(x, y, z);
else
ans = min(ans, calc(x, y, z));
it = b.upper_bound(y);
if (it != b.begin()) --it;
z = *it;
it = r.lower_bound(y);
if (it == r.end()) --it;
x = *it;
if (ans == -1)
ans = calc(x, y, z);
else
ans = min(ans, calc(x, y, z));
}
for (const int &z : b) {
auto it = r.upper_bound(z);
if (it != r.begin()) --it;
int x = *it;
it = g.lower_bound(z);
if (it == g.end()) --it;
int y = *it;
if (ans == -1)
ans = calc(x, y, z);
else
ans = min(ans, calc(x, y, z));
it = g.upper_bound(z);
if (it != g.begin()) --it;
y = *it;
it = r.lower_bound(z);
if (it == r.end()) --it;
x = *it;
if (ans == -1)
ans = calc(x, y, z);
else
ans = min(ans, calc(x, y, z));
}
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t-- > 0) solve();
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void checkMin(T& r, T val) {
if (r > val) r = val;
}
vector<int> v;
int d[10];
int d2[10];
bool vis[1000010];
char buf[210];
char sn[10];
int n;
int ans;
void check() {
int res = 0;
for (int i = 0; i < 10; ++i) {
if (v[i] > d[i]) return;
int t = v[i];
while (t--) {
res = res * 11 + (1 + i);
}
}
if (vis[res]) return;
vis[res] = true;
ans++;
}
void dfs(int dep) {
if (dep == n) {
check();
return;
}
if (sn[dep] == '2' || sn[dep] == '5') {
v[2]++;
dfs(dep + 1);
v[2]--;
v[5]++;
dfs(dep + 1);
v[5]--;
} else if (sn[dep] == '6' || sn[dep] == '9') {
v[6]++;
dfs(dep + 1);
v[6]--;
v[9]++;
dfs(dep + 1);
v[9]--;
} else {
v[sn[dep] - '0']++;
dfs(dep + 1);
v[sn[dep] - '0']--;
}
}
int main() {
v = vector<int>(10, 0);
scanf("%s%s", sn, buf);
n = strlen(sn);
int len = strlen(buf);
for (int i = 0; i < len; ++i) d[buf[i] - '0']++;
for (int i = 0; i < n; ++i) d2[sn[i] - '0']++;
int ans = 1 << 30;
if (d2[2] + d2[5]) checkMin(ans, (d[2] + d[5]) / (d2[2] + d2[5]));
if (d2[6] + d2[9]) checkMin(ans, (d[6] + d[9]) / (d2[6] + d2[9]));
if (d2[0]) checkMin(ans, d[0] / d2[0]);
if (d2[1]) checkMin(ans, d[1] / d2[1]);
if (d2[3]) checkMin(ans, d[3] / d2[3]);
if (d2[4]) checkMin(ans, d[4] / d2[4]);
if (d2[7]) checkMin(ans, d[7] / d2[7]);
if (d2[8]) checkMin(ans, d[8] / d2[8]);
printf("%d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200009;
const int inf = 0x3f3f3f3f;
int L[maxn], R[maxn], a[maxn], b[maxn], c[maxn];
int n;
long long res;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int main() {
n = read();
L[0] = -inf;
R[0] = inf;
for (int i = 1; i <= n; i++) {
a[i] = read();
b[i] = read();
res -= a[i];
int ll = a[i], rr = a[i] + b[i];
L[i] = max(L[i - 1] - 1, ll);
R[i] = min(R[i - 1] + 1, rr);
if (L[i] > R[i]) {
printf("-1");
return 0;
}
}
int now = R[n];
res += now;
c[n] = now;
for (int i = n - 1; i >= 1; i--) {
for (int j = now + 1; j >= now - 1; j--)
if (L[i] <= j && j <= R[i]) {
now = j;
break;
}
res += now;
c[i] = now;
}
printf("%I64d\n", res);
for (int i = 1; i <= n; i++) printf("%d ", c[i]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename Tp>
inline void outarr(Tp _begin, Tp _end, const char* _delim = " ") {
for (Tp current = _begin; current != _end; ++current) {
std::cout << *current << _delim;
}
std::cout << '\n';
}
using ll = long long;
using pii = std::pair<int, int>;
constexpr int INF = 0x3f3f3f3f;
constexpr int MOD = static_cast<const int>(1e9 + 7);
class SegmentTree {
public:
struct Node {
int Val = INF;
int Push = -1;
};
explicit SegmentTree(int n) : tree(n << 2), size(n) {}
void Update(int l, int r, int x) { UpdateRangeImpl(0, 0, size - 1, l, r, x); }
int Get(int i) { return QuerySingleImpl(0, 0, size - 1, i); }
private:
int Left(int v) const { return (v << 1) + 1; }
int Right(int v) const { return (v << 1) + 2; }
void UpdateVertex(int) {}
void Push(int v) {
if (tree[v].Push != -1) {
for (int j : {Left(v), Right(v)}) {
tree[j].Val = tree[j].Push = tree[v].Push;
}
tree[v].Push = -1;
}
}
void UpdateRangeImpl(int v, int tl, int tr, int l, int r, int x) {
if (l > r) {
return;
}
if (tl == l && r == tr) {
tree[v].Val = tree[v].Push = x;
return;
}
Push(v);
const int mid = (tl + tr) >> 1;
UpdateRangeImpl(Left(v), tl, mid, l, min(mid, r), x);
UpdateRangeImpl(Right(v), mid + 1, tr, max(l, mid + 1), r, x);
UpdateVertex(v);
}
int QuerySingleImpl(int v, int tl, int tr, int i) {
if (tl == tr) {
return tree[v].Val;
}
Push(v);
const int mid = (tl + tr) >> 1;
if (i <= mid) {
return QuerySingleImpl(Left(v), tl, mid, i);
}
return QuerySingleImpl(Right(v), mid + 1, tr, i);
}
vector<Node> tree;
const int size;
};
vector<int> BuildZF(const string& s) {
const int n = static_cast<int>((s).size());
vector<int> zf(n, 0);
for (int i = 1, l = 0; i < n; ++i) {
if (l + zf[l] > i) {
zf[i] = min(l + zf[l] - i, zf[i - l]);
}
while (i + zf[i] < n && s[zf[i]] == s[i + zf[i]]) {
++zf[i];
}
if (l + zf[l] < i + zf[i]) {
l = i;
}
}
return zf;
}
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(nullptr);
int n, m, k;
string s, t;
cin >> n >> m >> k >> s >> t;
auto pzf = BuildZF(t + '#' + s);
SegmentTree pst(m + 1);
for (int i = n - 1; i >= 0; --i) {
if (pzf[i + m + 1] == m) {
cout << "Yes"
"\n";
int lb = max(1, i + m - k - k + 1);
cout << lb << ' ' << lb + k << "\n";
return 0;
}
pst.Update(max(1, k - i), pzf[i + m + 1], i);
}
reverse((t).begin(), (t).end());
reverse((s).begin(), (s).end());
auto szf = BuildZF(t + '#' + s);
SegmentTree sst(m + 1);
for (int i = n - 1; i > 0; --i) {
sst.Update(max(1, k - i), szf[i + m + 1], n - 1 - i);
}
int ans_l = -1;
int ans_r = -1;
for (int i = 1; i < m; ++i) {
if (max(i, m - i) > k) {
continue;
}
int l = pst.Get(i) + i - 1;
int r = sst.Get(m - i) - m + i + 1;
if (l < r && r < n) {
ans_l = l - k + 2;
ans_r = r + 1;
break;
}
}
if (ans_l == -1) {
return cout << ("No") << '\n', 0;
;
}
cout << "Yes"
"\n";
cout << ans_l << ' ' << ans_r << "\n";
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int D[100000], S[100000];
int main() {
int N;
cin >> N;
queue<int> Q;
for (int i = 0; i < N; i++) {
cin >> D[i] >> S[i];
if (D[i] == 1) {
Q.push(i);
}
}
vector<pair<int, int> > edges;
while (!Q.empty()) {
int i = Q.front();
Q.pop();
if (D[i] != 1) continue;
int v = S[i];
edges.push_back({i, v});
D[i]--;
D[v]--;
S[i] ^= v;
S[v] ^= i;
if (D[v] == 1) Q.push(v);
}
cout << edges.size() << endl;
for (auto it : edges) cout << it.first << " " << it.second << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int tt;
cin >> tt;
while (tt--) {
int na, nb, nc;
cin >> na >> nb >> nc;
vector<int> a(na), b(nb), c(nc);
for (int i = 0; i < na; i++) {
cin >> a[i];
}
for (int i = 0; i < nb; i++) {
cin >> b[i];
}
for (int i = 0; i < nc; i++) {
cin >> c[i];
}
sort(a.begin(), a.end());
sort(b.begin(), b.end());
sort(c.begin(), c.end());
auto solve = [](vector<int> &a, vector<int> &b, vector<int> &c) {
long long res = 4 * 1e18;
for (auto i : b) {
auto l = lower_bound(a.begin(), a.end(), i + 1);
auto r = lower_bound(c.begin(), c.end(), i);
if (l == a.begin() || r == c.end()) continue;
long long x = *prev(l), y = i, z = *r;
long long w = (x - y) * (x - y) + (y - z) * (y - z) + (z - x) * (z - x);
res = min(res, w);
}
return res;
};
long long ans = 4 * 1e18;
ans = min(ans, solve(a, b, c));
ans = min(ans, solve(a, c, b));
ans = min(ans, solve(b, a, c));
ans = min(ans, solve(b, c, a));
ans = min(ans, solve(c, b, a));
ans = min(ans, solve(c, a, b));
cout << ans << '\n';
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long ans = 0;
string s;
long long cal(int L, int R, bool g) {
long long U = 0, A = 0, M = 1;
if (!g) U = cal(L, R, 1);
int i1 = (g ? L : 0), i2 = (g ? R + 1 : s.size());
for (int i = i1; i < i2; i++) {
if (!g && i == L) {
M *= U;
i = R;
} else if (s[i] == '+') {
A += M;
M = 1;
} else if (s[i] <= '9' && s[i] >= '0') {
M *= s[i] - '0';
}
}
return A + M;
}
int main() {
cin >> s;
ans = cal(0, 0, 0);
for (int i = 0; i < s.size(); i++)
if (s[i] == '*') {
for (int j = 0; j < i; j += 2) {
long long t = cal(j, i - 1, 0);
ans = max(ans, t);
}
for (int j = i + 1; j < s.size(); j += 2) {
long long t = cal(i + 1, j, 0);
ans = max(ans, t);
}
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:60000000")
using namespace std;
const long double eps = 1e-9;
const int inf = (1 << 30) - 1;
const long long inf64 = ((long long)1 << 62) - 1;
const long double pi = 3.1415926535897932384626433832795;
template <class T>
T sqr(T x) {
return x * x;
}
struct treeNode {
long long leftD, rightD;
vector<pair<long long, int> > S;
};
struct element {
long long d, m, r, p;
};
bool u[300500];
element A[300500];
int n, lst, ans;
long long p, r;
treeNode tree[524288];
vector<pair<long long, long long> > Q;
bool operator<(const element& p1, const element& p2) { return p1.d < p2.d; }
void read() {
int x, y;
cin >> x >> y >> p >> r >> n;
r = r * r;
memset(u, 0, sizeof(u));
for (int i = 0; i < (int)(n); i++) {
int x1, Y1HUI;
scanf("%d%d", &x1, &Y1HUI);
x1 -= x;
Y1HUI -= y;
A[i].d = (long long)x1 * x1 + (long long)Y1HUI * Y1HUI;
int m1, r1, p1;
scanf("%d%d%d", &m1, &p1, &r1);
A[i].r = r1;
A[i].r = A[i].r * A[i].r;
A[i].p = p1;
A[i].m = m1;
}
ans = 0;
Q.push_back(make_pair(r, p));
sort(A, A + n);
}
void update(vector<pair<long long, int> >& S, long long y) {
while (S.size() > 0 && S.back().first <= y) {
int v = S.back().second;
S.pop_back();
if (!u[v]) {
u[v] = 1;
ans++;
Q.push_back(make_pair(A[v].r, A[v].p));
}
}
}
void go(int v, long long l, long long r, long long y) {
if (tree[v].rightD < l || tree[v].leftD > r) return;
if (l <= tree[v].leftD && tree[v].rightD <= r) {
update(tree[v].S, y);
return;
}
go(v * 2, l, r, y);
go(v * 2 + 1, l, r, y);
}
int main() {
read();
lst = 1;
while (lst < n) lst *= 2;
for (int i = 0; i < (int)(lst * 2); i++) tree[i].leftD = tree[i].rightD = 0;
for (int i = 0; i < (int)(n); i++) {
tree[i + lst].leftD = A[i].d;
tree[i + lst].rightD = A[i].d;
tree[i + lst].S.push_back(make_pair(A[i].m, i));
}
for (int i = n; i < lst; i++) {
tree[i + lst].leftD = inf64;
tree[i + lst].rightD = inf64;
}
for (int i = lst - 1; i >= 1; i--) {
tree[i].leftD = tree[i * 2].leftD;
tree[i].rightD = tree[i * 2 + 1].rightD;
tree[i].S = tree[i * 2].S;
tree[i].S.insert(tree[i].S.end(), tree[i * 2 + 1].S.begin(),
tree[i * 2 + 1].S.end());
sort(tree[i].S.begin(), tree[i].S.end());
reverse(tree[i].S.begin(), tree[i].S.end());
}
while (Q.size() > 0) {
pair<long long, long long> v = Q.back();
Q.pop_back();
go(1, 1, v.first, v.second);
}
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int mod = (int)1e9 + 7;
const int inf = (int)(1e9);
const int N = 100005;
int n;
string s;
int ind1, ind2;
string thro;
string dop;
int j;
int main() {
int i = 0;
scanf("%d\n", &n);
for (; i < n; ++i) {
getline(cin, s);
j = 0;
while (s[j] == ' ' && j < (int)s.size()) j++;
if (j == (int)s.size()) continue;
if (s[j] == 't' && s[j + 1] == 'h') {
j += 4;
while (s[j] != '(') ++j;
++j;
while (s[j] == ' ') ++j;
ind1 = j;
while (s[j] != ' ' && s[j] != ')') ++j;
ind2 = j - 1;
thro = s.substr(ind1, ind2 - ind1 + 1);
break;
}
}
int flag = 0;
int dif = 0;
for (; i < n; ++i) {
getline(cin, s);
j = 0;
while (s[j] == ' ' && j < (int)s.size()) j++;
if (j == (int)s.size()) continue;
if (s[j] == 't' && s[j + 1] == 'r') {
dif++;
continue;
}
if (s[j] == 'c' && s[j + 1] == 'a' && dif > 0) {
dif--;
continue;
}
j += 5;
while (s[j] != '(') ++j;
++j;
while (s[j] == ' ') ++j;
ind1 = j;
while (s[j] != ' ' && s[j] != ',') ++j;
ind2 = j - 1;
dop = s.substr(ind1, ind2 - ind1 + 1);
if (dop != thro) continue;
while (s[j] != '"') ++j;
++j;
ind1 = j;
while (s[j] != '"') ++j;
ind2 = j - 1;
cout << s.substr(ind1, ind2 - ind1 + 1);
return 0;
}
cout << "Unhandled Exception" << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 500005;
const long long mod = 1e9 + 7;
long long power(long long a, long long b) {
if (b == 0) return 1;
if (b == 1) return a % mod;
if (b % 2 == 1) return (power(a, b - 1) * a) % mod;
long long q = power(a, b / 2);
return (q * q) % mod;
}
void solve() {
long long x = 0, y = 0, c = 1, ans = 0;
long long n, m, k;
cin >> n;
vector<long long> dp(n + 1);
for (long long i = n; i > 1; --i) {
dp[i] = (n / i) * power(n - (n / i), mod - 2) % mod;
for (long long j = 2 * i; j <= n; j += i) {
dp[i] -= dp[j];
dp[i] += mod;
dp[i] %= mod;
}
c += dp[i];
c %= mod;
}
cout << c << "\n";
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int a[N], n;
inline int gcd(long long a, long long b) {
for (int c = a % b; c; a = b, b = c, c = a % b)
;
return b;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
sort(a + 1, a + n + 1);
long long sum = 0, ans = 0;
for (int i = 2; i <= n; ++i) sum += a[i] - a[1];
for (int i = 1; i <= n; ++i) ans += a[i];
ans += sum;
for (int i = 2; i <= n; ++i) {
sum -= (long long)(n - i + 1) * (a[i] - a[i - 1]);
sum += (long long)(i - 1) * (a[i] - a[i - 1]);
ans += sum;
}
long long d = gcd(ans, n);
printf("%I64d %I64d\n", ans / d, n / d);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 20;
long long a[N], now, ans, s[N];
vector<long long> gr[N];
void root(int v = 1, int h = 0, int par = -1) {
now += h * a[v];
s[v] = a[v];
for (int u : gr[v])
if (u != par) root(u, h + 1, v), s[v] += s[u];
}
void upd(int v = 1, int par = -1) {
ans = max(ans, now);
for (int u : gr[v]) {
long long tmp = now;
if (u != par) {
now += s[1] - 2 * s[u], upd(u, v);
}
now = tmp;
}
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n - 1; i++) {
int x, y;
cin >> x >> y;
gr[--x].push_back(--y);
gr[y].push_back(x);
}
root();
upd();
cout << ans;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int d[5005][5005];
vector<int> G[5005];
int main() {
int n, m, a, b;
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> a >> b;
a--;
b--;
G[a].push_back(b);
G[b].push_back(a);
}
memset(d, -1, sizeof d);
for (int i = 0; i < n; i++) {
queue<int> q;
d[i][i] = 0;
q.push(i);
while (!q.empty()) {
int s = q.front();
q.pop();
for (int j = 0; j < G[s].size(); j++) {
int to = G[s][j];
if (d[i][to] == -1) {
d[i][to] = d[i][s] + 1;
q.push(to);
}
}
}
}
int s[2], l[2], t[2];
for (int i = 0; i < 2; i++) {
cin >> s[i] >> t[i] >> l[i];
s[i]--;
t[i]--;
}
int ans = m + 1;
for (int it = 0; it < 2; it++) {
swap(s[0], t[0]);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
int v[] = {d[s[0]][i] + d[i][j] + d[j][t[0]],
d[s[1]][i] + d[i][j] + d[j][t[1]]};
if (v[0] <= l[0] && v[1] <= l[1]) {
ans = min(ans, v[0] + v[1] - d[i][j]);
}
}
}
}
if (d[s[0]][t[0]] <= l[0] && d[s[1]][t[1]] <= l[1])
ans = min(ans, d[s[0]][t[0]] + d[s[1]][t[1]]);
if (ans > m)
ans = -1;
else
ans = m - ans;
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long int a, b, c, d, e, i, j, k, m, n, q = 0, r = 0, u, s, t, p = 2, x, y,
temp, v, l;
long long int ans = 0;
string s1, s4, s5, s6, s7, s8, s9;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (i = 0; i < n; i++) {
long long int h;
cin >> h >> m;
cout << (60 - m) + 60 * (23 - h) << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int M = 10000;
int n, m, s, t, cnt;
long long L, dis[1005];
bool mark[M + 5];
struct Edge {
int from, to, next;
long long w;
} edge[M << 1 + 5];
int h[1005];
void edge_add(int from, int to, long long w) {
edge[cnt].from = from;
edge[cnt].to = to;
edge[cnt].w = w;
edge[cnt].next = h[from];
h[from] = cnt++;
}
struct Node {
int to;
long long d;
Node() {}
Node(int to_, long long d_) : to(to_), d(d_) {}
bool operator<(Node a) const { return a.d < d; }
};
void dij() {
memset(dis, 0x3f, sizeof(dis));
dis[s] = 0;
priority_queue<Node> Q;
Q.push(Node(s, 0));
Node node;
while (!Q.empty()) {
node = Q.top();
Q.pop();
int x = node.to;
if (node.d > dis[x]) continue;
for (int k = h[x]; k != -1; k = edge[k].next) {
int y = edge[k].to;
long long cost = edge[k].w;
if (dis[x] + cost < dis[y]) Q.push(Node(y, dis[y] = dis[x] + cost));
}
}
}
void init() {
cnt = 0;
memset(mark, false, sizeof(mark));
memset(h, -1, sizeof(h));
}
void solve() {
cin >> n >> m >> L >> s >> t;
int a, b;
long long c;
for (int i = 0; i < m; i++) {
cin >> a >> b >> c;
if (c == 0) {
c = 1;
mark[i] = true;
}
edge_add(a, b, c);
edge_add(b, a, c);
}
dij();
long long delta = L - dis[t];
bool ok = false;
if (delta < 0)
cout << "NO\n";
else {
if (delta == 0) ok = true;
for (int i = 0; i < m && !ok; i++) {
if (!mark[i]) continue;
edge[i * 2].w = edge[i * 2 + 1].w = (long long)1 + delta;
dij();
delta = L - dis[t];
if (delta == 0) ok = true;
}
if (ok) {
cout << "Yes\n";
for (int i = 0; i < m; i++) {
cout << edge[i * 2].from << " " << edge[i * 2].to << " "
<< edge[i * 2].w << endl;
}
} else
cout << "NO\n";
}
}
int main() {
ios::sync_with_stdio(false);
init();
solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
const int M = 4e6 + 7;
struct HELP_ME_AC {
int ch[M][2] = {}, end[M] = {}, sz = 0;
int fail[M] = {}, last[M] = {};
int now, zhi[M];
void insert(int id, int num) {
int c = num, s = 0;
while (c % 2 == 0) c /= 2, s++;
if (c == 1) {
int u = zhi[now];
u = ch[u][1];
for (int i = 1; i <= s; i++) {
ch[u][0] = ++sz;
u = sz;
}
end[u] = id;
return;
} else {
int u = zhi[now];
ch[u][0] = ++sz;
zhi[++now] = sz;
u = sz;
int l = num - now - 1;
for (int i = l; i >= 0; i--) {
if (num * 2 >= (2 << i)) {
ch[u][1] = ++sz;
u = sz;
num -= (2 << i - 1);
} else {
ch[u][0] = ++sz;
u = sz;
}
}
end[u] = id;
}
}
void build() {
queue<int> q;
for (int i = 0; i < 2; i++)
if (ch[0][i]) fail[ch[0][i]] = 0, q.push(ch[0][i]);
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = 0; i < 2; i++) {
int &v = ch[u][i];
if (v) {
q.push(v);
fail[v] = ch[fail[u]][i];
last[v] = end[fail[v]] ? fail[v] : last[fail[v]];
} else
v = ch[fail[u]][i];
}
}
}
int query(const char *s) {
int now = 0, tot = 0;
for (int i = 0; s[i]; i++) {
now = ch[now][s[i] - '0'];
int id = end[now] ? now : last[now];
while (id) {
++tot;
id = last[id];
}
}
return tot;
}
} ac;
int a, b, c, t;
char ch[200005];
int main() {
ac.ch[0][1] = 1;
ac.sz = 1;
ac.end[1] = ac.end[0] = 1;
for (int i = 2; i <= 2e5; i++) {
ac.insert(i, i);
}
ac.build();
cin >> t;
while (t--) {
scanf("%s", (ch + 1));
cout << ac.query(ch + 1) << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string str, res;
int num;
int t;
cin >> str;
cin >> num;
for (int i = 0; i < str.size(); i++) {
if (str[i] <= 'z' && str[i] >= 'a')
;
else
str[i] -= ('A' - 'a');
}
for (int i = 0; i < str.size(); i++) {
t = str[i];
if (t < num + 97)
res += t + 'A' - 'a';
else
res += t;
}
cout << res;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int f;
cin >> f;
string g;
cin >> g;
if (f == 12) {
if (g[0] > '1' && g[1] > '0')
g[0] = '0';
else if (g[0] > '1' && g[1] == '0')
g[0] = '1';
else if (g[0] == '1' && g[1] > '2')
g[0] = '0';
else if (g[0] == '0' && g[1] < '1')
g[0] = '1';
else
g[0] = g[0];
if (g[3] > '5')
g[3] = '5';
else
g[3] = g[3];
}
if (g[0] > '2')
g[0] = '0';
else if (g[0] == '2' && g[1] > '3')
g[1] = '3';
else
g[1] = g[1];
if (g[3] > '5')
g[3] = '5';
else
g[3] = g[3];
cout << g << endl;
}
| 2 |
#include <bits/stdc++.h>
const long double eps = 1e-9;
const long double pi = acos(-1);
bool Equal(long double x, long double y) { return fabs(x - y) < eps; }
bool Greater(long double x, long double y) { return x - eps > y; }
bool Lesser(long double x, long double y) { return x + eps < y; }
struct point {
long double x, y, ang;
};
using namespace std;
int main() {
long long x1, y1, r1, x2, y2, r2;
cin >> x1 >> y1 >> r1;
cin >> x2 >> y2 >> r2;
if (r1 < r2) {
swap(r1, r2);
swap(x1, x2);
swap(y1, y2);
}
long long c1c2 = (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2);
cout << setprecision(10) << fixed;
long double ans = 0.0, rr1, rr2;
if (c1c2 >= (r1 + r2) * (r1 + r2)) {
printf("0.000000000000");
return 0;
} else if (c1c2 <= (r1 - r2) * (r1 - r2)) {
cout << pi * (long double)r2 * (long double)r2;
return 0;
}
long double d = sqrt((long double)c1c2);
rr1 = r1, rr2 = r2;
long double th2 = acos((rr2 * rr2 + d * d - rr1 * rr1) / (2 * rr2 * d));
long double th1 = acos((rr1 * rr1 + d * d - rr2 * rr2) / (2 * rr1 * d));
long double second = th1 * rr1 * rr1;
long double t = rr1 * rr1 * sin(th1) * cos(th1);
ans += second - t;
second = th2 * rr2 * rr2;
t = rr2 * rr2 * sin(th2) * cos(th2);
ans += second - t;
cout << ans;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
vector<pair<pair<int, int>, int> > points[1005];
for (int i = (int)(1); i <= (int)(n); i++) {
int x, y;
cin >> x >> y;
points[x / 1000].push_back({{y, x}, i});
}
for (int i = (int)(0); i <= (int)(1000); i++) {
sort((points[i]).begin(), (points[i]).end());
if (i % 2) reverse((points[i]).begin(), (points[i]).end());
}
for (int i = (int)(0); i <= (int)(1000); i++)
for (auto p : points[i]) cout << p.second << ' ';
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, l, s, t, x[11111], y[11111], z[11111], L, R, mid, xp,
dist[11111];
vector<pair<long long, long long> > g[1111];
bool can[11111];
long long dijk() {
priority_queue<pair<long long, long long> > pq;
pq.push(make_pair(0, s));
for (long long i = 0; i < n; i++) dist[i] = 1e18;
dist[s] = 0;
while (!pq.empty()) {
long long x = pq.top().second;
pq.pop();
for (int i = 0; i < g[x].size(); i++) {
long long to = g[x][i].first, val = g[x][i].second;
if (dist[to] > dist[x] + val) {
dist[to] = dist[x] + val;
pq.push(make_pair(-dist[to], to));
}
}
}
return dist[t];
}
int main() {
scanf("%I64d%I64d%I64d%I64d%I64d", &n, &m, &l, &s, &t);
for (long long i = 1; i <= m; i++) {
scanf("%I64d%I64d%I64d", &x[i], &y[i], &z[i]);
if (z[i]) {
g[x[i]].push_back(make_pair(y[i], z[i]));
g[y[i]].push_back(make_pair(x[i], z[i]));
}
}
if (dijk() < l) {
printf("NO\n");
return 0;
}
L = 1;
R = 1E18;
while (L <= R) {
mid = (L + R) / 2;
for (long long i = 0; i < n; i++) g[i].clear();
for (long long i = 1; i <= m; i++) {
if (!z[i]) {
g[x[i]].push_back(make_pair(y[i], mid));
g[y[i]].push_back(make_pair(x[i], mid));
} else {
g[x[i]].push_back(make_pair(y[i], z[i]));
g[y[i]].push_back(make_pair(x[i], z[i]));
}
}
xp = dijk();
if (xp == l) {
printf("YES\n");
for (long long i = 1; i <= m; i++) {
if (!z[i])
printf("%I64d %I64d %I64d\n", x[i], y[i], mid);
else
printf("%I64d %I64d %I64d\n", x[i], y[i], z[i]);
}
return 0;
}
if (xp > l)
R = mid - 1;
else
L = mid + 1;
}
if (R <= 0) {
printf("NO\n");
return 0;
}
for (long long i = 1; i <= m; i++) {
if (!z[i]) {
can[i] = 1;
z[i] = R;
}
}
for (long long i = 1; i <= m; i++) {
if (can[i]) {
z[i] = L;
for (long long j = 0; j < n; j++) g[j].clear();
for (long long j = 1; j <= m; j++) {
g[x[j]].push_back(make_pair(y[j], z[j]));
g[y[j]].push_back(make_pair(x[j], z[j]));
}
if (dijk() == l) {
printf("YES\n");
for (long long j = 1; j <= m; j++) {
printf("%I64d %I64d %I64d\n", x[j], y[j], z[j]);
}
return 0;
}
}
}
printf("NO\n");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
string res;
set<string> st;
for (int i = 0; i < n; ++i) {
string s;
cin >> s;
string rev = s;
reverse(rev.begin(), rev.end());
if (st.find(rev) != st.end()) {
res += s;
st.erase(rev);
} else {
st.insert(s);
}
}
string pali;
for (string s : st) {
bool good = true;
for (int i = 0; i < m / 2; ++i) good &= s[i] == s[m - 1 - i];
if (good) {
pali = s;
break;
}
}
string temp = res;
res += pali;
reverse(temp.begin(), temp.end());
res += temp;
cout << res.size() << endl << res;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
long long n;
cin >> n;
string s;
cin >> s;
long long l = 0, r = 0;
for (long long i = 0; i < n; i++) {
if (s[i] == '<')
l++;
else
break;
}
for (long long i = n - 1; i >= 0; i--) {
if (s[i] == '>')
r++;
else
break;
}
cout << l + r << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
string tmp = "x";
string out = "";
cin >> n;
vector<string> strings(n);
for (int i = 0; i < n; i++) cin >> strings[i];
for (int i = 0, j = 0; i < strings[0].size(); i++, j = 0) {
for (; j < n; j++) {
if (tmp == "x" && strings[j][i] != '?') {
tmp = strings[j][i];
break;
}
}
for (j++; j < n; j++) {
if (strings[j][i] != '?' && tmp[0] != strings[j][i]) tmp = "?";
}
out += tmp;
tmp = "x";
}
cout << out << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int v[100010];
char s[100010];
int main() {
int n, res = 0, res1 = 0;
scanf("%d\n", &n);
int i;
for (i = 0; (i + 1) < n; i++) scanf("%d ", &v[i]);
scanf("%d\n", &v[n - 1]);
gets(s);
if (s[0] == '1') {
res1 += v[0];
}
res = res + v[0];
for (int i = 1; i < n; i++) {
if (s[i] == '1') {
res1 = max(res1 + v[i], res);
}
res = res + v[i];
}
printf("%d", res1);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int nn = 1e5 + 5;
const int mod = 1000000007;
int father[nn], n, m, tot;
pair<int, int> hate[nn];
int vis[nn];
int getfather(int p) {
return father[p] == p ? p : father[p] = getfather(father[p]);
}
inline void merge(int p, int q) { father[getfather(p)] = getfather(q); }
int cnt, Begin[nn << 1], End[nn << 1], Last[nn], Prev[nn << 1];
inline void addedge(int p, int q) {
cnt++;
Begin[cnt] = p;
End[cnt] = q;
Prev[cnt] = Last[p];
Last[p] = cnt;
}
void dfs(int p, int ff) {
vis[p] = ff;
for (int i = Last[p]; i; i = Prev[i]) {
if (vis[End[i]] == 1) {
dfs(End[i], ~ff);
} else {
if (~ff != vis[End[i]]) {
printf("0");
exit(0);
}
}
}
}
int ksm(int a, int n) {
long long ans = 1;
while (n) {
if (n & 1) ans = (ans * a) % mod;
n >>= 1;
a = 1ll * a * a % mod;
}
return ans;
}
int main() {
scanf("%d %d", &n, &m);
int a, b, c;
for (int i = 1; i <= n; i++) father[i] = i;
while (m--) {
scanf("%d %d %d", &a, &b, &c);
if (c == 1)
merge(a, b);
else
hate[++tot] = pair<int, int>{a, b};
}
for (int i = 1; i <= tot; i++) {
hate[i].first = getfather(hate[i].first);
hate[i].second = getfather(hate[i].second);
addedge(hate[i].first, hate[i].second);
addedge(hate[i].second, hate[i].first);
}
for (int i = 1; i <= n; i++) vis[i] = 1;
int ans = 0;
for (int i = 1; i <= n; i++)
if (vis[getfather(i)] == 1) {
ans++;
dfs(getfather(i), 0);
}
printf("%d", ksm(2, ans - 1));
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
const double PI = acos(-1.0);
const long long mod = 1e9 + 7;
const int maxn = 100005;
double p, r;
void solve() {
cin >> p >> r;
double x = r * sin(PI / p) / sin((1.5 * PI) / p);
printf("%.20f", r * x * p * sin(PI / (2.0 * p)));
}
int main() {
solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
const int B = 1e9 + 7;
int n;
long long inv[N];
long long mypow(long long a, int b) {
long long res = 1;
while (b) {
if (b & 1) res = res * a % B;
a = a * a % B;
b >>= 1;
}
return res;
}
long long C(long long a, int b) {
long long res = 1;
for (int i = 0; i < b; ++i) {
res = res * (a - i) % B;
}
for (int i = b; i >= 1; --i) {
res = res * inv[i] % B;
}
return res;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
inv[i] = mypow(i, B - 2);
}
printf("%lld\n", (C(n + n - 1, n - 1) * 2 + B - n) % B);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i = 0, j = 0;
char a[1000], b[1000];
gets(a);
if (a[0] == '.') {
for (j = 0; j < 3; j++) {
b[j] = '.';
}
i += 3;
}
while (a[i] != '\0') {
if (a[i] == ',' && a[i + 1] != '\0') {
b[j] = ',';
j++;
b[j] = ' ';
j++;
i++;
} else if (a[i] == ',' && a[i + 1] == '\0') {
b[j] = ',';
j++;
i++;
} else if (a[i] == '.' && b[j - 1] != ' ') {
b[j] = ' ';
b[j + 1] = '.';
b[j + 2] = '.';
b[j + 3] = '.';
j += 4;
i += 3;
} else if (a[i] == '.' && b[j - 1] == ' ') {
b[j] = '.';
b[j + 1] = '.';
b[j + 2] = '.';
j += 3;
i += 3;
} else if (a[i] == ' ' && (a[i + 1] >= '0' && a[i + 1] <= '9') &&
(b[j - 1] >= '0' && b[j - 1] <= '9')) {
b[j] = ' ';
j++;
i++;
} else if (a[i] >= '0' && a[i] <= '9') {
b[j] = a[i];
j++;
i++;
} else
i++;
}
b[j] = '\0';
puts(b);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5000 + 5;
int p[maxn], bp[maxn], a[maxn], b[maxn], c[maxn];
bool used[maxn];
int get_bp(int i, int j) { return p[i] ^ bp[i] ^ p[j]; }
int get_p(int i, int j) { return get_bp(i, j) ^ bp[j]; }
bool check(int pos, int n) {
memset(used, 0, sizeof(used));
a[pos] = 0;
b[0] = pos;
used[0] = true;
for (int i = pos - 1; i >= 0; --i) {
a[i] = a[i + 1] ^ get_p(i, i + 1);
if (a[i] >= n || used[a[i]]) return false;
b[a[i]] = i;
}
for (int i = pos + 1; i < n; ++i) {
a[i] = a[i - 1] ^ get_p(i, i - 1);
if (a[i] >= n || used[a[i]]) return false;
b[a[i]] = i;
}
for (int i = 0; i < n; ++i) {
if ((a[0] ^ b[i]) != p[i] || (a[i] ^ b[i]) != bp[i]) return false;
}
memcpy(c, a, sizeof(c));
return true;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
printf("? 0 %d\n", i);
fflush(stdout);
scanf("%d", &p[i]);
printf("? %d %d\n", i, i);
fflush(stdout);
scanf("%d", &bp[i]);
}
int cnt = 0;
for (int i = 0; i < n; ++i)
if (check(i, n)) ++cnt;
printf("!\n");
fflush(stdout);
printf("%d\n", cnt);
fflush(stdout);
for (int i = 0; i < n; ++i) printf("%d%c", c[i], " \n"[i == n - 1]);
fflush(stdout);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int N, M, K, ans;
bool board[1000 + 10][1000 + 10];
bool check(int x, int y) {
if (board[x - 1][y] && board[x - 1][y + 1] && board[x][y + 1]) return true;
if ((board[x - 1][y] && board[x - 1][y - 1] && board[x][y - 1])) return true;
if ((board[x + 1][y] && board[x + 1][y - 1] && board[x][y - 1])) return true;
if ((board[x + 1][y] && board[x + 1][y + 1] && board[x][y + 1])) return true;
return false;
}
int x, y;
int main() {
cin >> N >> M >> K;
bool flag = false;
int ans = 0;
for (int i = 0; i < K; i++) {
cin >> x >> y;
if (!flag) {
if (!board[x][y]) {
board[x][y] = true;
if (check(x, y)) {
flag = true;
ans = i + 1;
}
} else
continue;
}
}
cout << ans << "\n";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long int x, y;
cin >> x >> y;
if (y == 1)
cout << "YES" << endl;
else if (x == 1)
cout << "NO" << endl;
else {
unordered_map<long long int, long long int> map;
int flag = 0;
while (true) {
if (x >= y) {
cout << "YES" << endl;
break;
} else if (x % 2 != 0 && x < y) {
if (map.find(x) == map.end())
map[x]++;
else {
cout << "NO" << endl;
break;
}
x--;
} else if (x % 2 == 0 && x < y) {
if (map.find(x) == map.end())
map[x]++;
else {
cout << "NO" << endl;
break;
}
x = (3 * x) / 2;
}
}
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int Mod = 1e9 + 7;
struct Matrix {
int n, m;
int s[101][101];
Matrix() {
for (int i = 0; i < 101; i++)
for (int j = 0; j < 101; j++) s[i][j] = 0;
}
} A, f;
int n, x, D;
Matrix operator*(Matrix A, Matrix B) {
Matrix C;
C.n = A.n, C.m = B.m;
for (int i = 0; i < C.n; i++)
for (int k = 0; k < A.m; k++)
for (int j = 0; j < C.m; j++)
(C.s[i][j] += 1LL * A.s[i][k] * B.s[k][j] % Mod) %= Mod;
return C;
}
Matrix Pow(Matrix A, int b) {
Matrix res = A;
for (--b; b; b >>= 1, A = A * A)
if (b & 1) res = res * A;
return res;
}
int main() {
scanf("%d%d", &n, &x);
if (!x) return puts("1"), 0;
for (int i = 0; i < n; i++) {
scanf("%d", &D);
A.s[100 - D][99]++;
A.s[100 - D][100]++;
}
for (int i = 1; i < 100; i++) A.s[i][i - 1] = 1;
A.s[100][100] = 1, A.n = A.m = 101;
f.s[0][99] = f.s[0][100] = 1, f.n = 1, f.m = 101;
f = f * Pow(A, x);
printf("%d\n", f.s[0][100]);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
int n;
while (cin >> n) {
int arr[n];
long long odd = 0, even = 0;
for (int i = 0; i < n; i++) {
cin >> arr[i];
if (i != 0) {
if (i % 2 == 0)
even += arr[i];
else
odd += arr[i];
}
}
int cnt = 0;
if (even == odd) cnt++;
for (int i = 1; i < n; i++) {
if (i % 2 == 0) {
even -= arr[i];
even += arr[i - 1];
} else {
odd -= arr[i];
odd += arr[i - 1];
}
if (odd == even) cnt++;
}
cout << cnt << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long int INF = 9223372036854775807LL;
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization("unroint-loops")
long long int power(long long int a, long long int b, long long int m) {
long long int res = 1;
while (b) {
if (b & 1) res = ((res % m) * (a % m)) % m;
a = ((a % m) * (a % m)) % m;
b >>= 1;
}
return res;
}
long long int power(long long int a, long long int b) {
long long int res = 1;
while (b) {
if (b & 1) res *= a;
a *= a;
b >>= 1;
}
return res;
}
void solve() {
long long int n;
cin >> n;
map<long long int, set<long long int>> mp;
for (long long int i = 0; i < n; i++) {
long long int a;
cin >> a;
for (long long int j = 0; j < a; j++) {
long long int x;
cin >> x;
mp[i].insert(x);
}
}
for (auto x : mp) {
bool ok = true;
for (auto y : mp) {
set<long long int> temp = y.second;
if (x.first != y.first) {
for (auto z : x.second) temp.erase(z);
}
if (temp.empty()) {
ok = false;
break;
}
}
if (ok)
cout << "YES\n";
else
cout << "NO\n";
}
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int tt = 1;
while (tt--) {
solve();
cout << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
long long mod_pow(long long a, long long n, long long mod) {
long long res = 1;
while (n) {
if (n & 1) res = (res * a) % mod;
n /= 2;
a = (a * a) % mod;
}
return res;
}
void solve();
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) solve();
}
void solve() {
long long n;
cin >> n;
vector<long long> v(n);
for (int i = 0; i < n; ++i) cin >> v[i];
int a = v[0], b = v[1];
vector<int> ans(2);
ans[0] = a, ans[1] = b;
for (int i = 2; i < n; ++i) {
if (a > b && b > v[i]) {
ans.pop_back();
ans.push_back(v[i]);
b = v[i];
} else if (b > a && v[i] > b) {
ans.pop_back();
ans.push_back(v[i]);
b = v[i];
} else {
ans.push_back(v[i]);
a = b;
b = v[i];
}
}
cout << ans.size() << "\n";
for (auto i : ans) cout << i << " ";
cout << "\n";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
int n, m;
int color[N];
char a[N];
int lg[N], ST[N][25];
bool visited[N], ans[N];
int nxt(int i) {
if (a[i] == 'R')
return i + 1;
else if (a[i] == 'L')
return i - 1;
else if (a[i] == 'U')
return i - m;
else
return i + m;
}
void build() {
for (int i = 1; i <= n * m; ++i) {
ST[i][0] = nxt(i);
}
for (int j = 1; j <= 20; ++j) {
for (int i = 1; i <= n * m; ++i) {
ST[i][j] = ST[ST[i][j - 1]][j - 1];
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
lg[1] = 0;
for (int i = 1; i < N; ++i) lg[i] = lg[i / 2] + 1;
int t;
cin >> t;
while (t--) {
cin >> n >> m;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
char ch;
cin >> ch;
color[(i - 1) * m + j] = 1 - (ch - '0');
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
cin >> a[(i - 1) * m + j];
}
}
build();
for (int i = 1; i <= n * m; ++i) visited[i] = ans[i] = 0;
for (int i = 1; i <= n * m; ++i) {
int cur = ST[i][20];
visited[cur] = true;
ans[cur] |= color[i];
}
int ans1 = 0, ans2 = 0;
for (int i = 1; i <= n * m; ++i) {
if (visited[i]) {
++ans1;
if (ans[i]) ++ans2;
}
}
cout << ans1 << " " << ans2 << "\n";
}
}
| 7 |
#include <bits/stdc++.h>
bool f(const std::string &s, long long k) {
if (k > s.size()) return false;
long long bits = 0;
std::set<long long> strs;
for (int i = 0; i < k; ++i) {
bits = (bits << 1) | (s[i] - '0');
}
strs.insert(bits);
for (int i = k; i < s.size(); ++i) {
bits = (bits << 1) | (s[i] - '0');
strs.insert(bits & ((1LL << k) - 1));
}
return strs.size() == (1LL << k);
}
int n, m;
std::string strs[205];
int ans[205] = {0};
void f(int i) {
while (f(strs[i], ans[i] + 1)) ++ans[i];
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
std::cout.tie(nullptr);
std::cin >> n;
std::vector<std::string> vs(n);
for (int i = 1; i <= n; ++i) {
std::cin >> strs[i];
f(i);
}
std::cin >> m;
for (int i = 1; i <= m; ++i) {
int a, b;
std::cin >> a >> b;
strs[n + i] = strs[a] + strs[b];
ans[n + i] = std::max(ans[a], ans[b]);
f(n + i);
std::cout << ans[n + i] << '\n';
if (strs[n + i].size() > 1e6)
strs[n + i] = strs[n + i].substr(0, 1e5) +
strs[n + i].substr(strs[n + i].size() - 1e5);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a;
cin >> n;
a = 1e7 - n + 1;
while (n) {
cout << a << ' ';
a++;
n--;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int a[2010];
int gcd(int a, int b) { return !b ? a : gcd(b, a % b); }
int main() {
int n;
while (scanf("%d", &n) > 0) {
int not_one = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
not_one += (a[i] != 1);
}
if (!not_one) {
printf("0\n");
continue;
}
if (not_one < n) {
printf("%d\n", not_one);
continue;
}
int min_seg = n + 1;
for (int i = 0; i < n; i++) {
int tmp = a[i], j = i + 1;
while (j < n and tmp != 1) {
tmp = gcd(tmp, a[j]);
j++;
}
if (tmp == 1) {
min_seg = min(min_seg, j - i);
}
}
if (min_seg == n + 1) {
printf("-1\n");
} else {
printf("%d\n", not_one + min_seg - 2);
}
}
}
| 3 |
#include <bits/stdc++.h>
int main() {
puts("1");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string x;
cin >> x;
stack<int> p;
int c = 0;
for (int i = 0; i < x.size(); i++) {
if (x[i] == '(')
p.push(x[i]);
else if (!p.empty() && p.top() == '(') {
c += 2;
p.pop();
}
}
cout << c;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
char op[20];
char s[205];
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
getchar();
cin.getline(op, 15);
int dir;
if (op[3] == 'h') {
dir = 0;
} else {
dir = 1;
}
scanf("%s", s);
int dir2 = m < k ? 0 : 1;
int len = strlen(s);
bool flag = false;
int t = 0;
for (int i = 0; i < len; ++i) {
++t;
int lastk = k;
if (dir == 0) {
--k;
if (k == 0) k = 2, dir = 1;
} else {
++k;
if (k == n + 1) k = n - 1, dir = 0;
}
if (s[i] == '0') {
if (dir == 0) {
if (m > lastk && m < n)
++m;
else if (m < lastk && m > 1)
--m;
} else {
if (m < lastk && m > 1)
--m;
else if (m > lastk && m < n)
++m;
}
} else if (i != len - 1) {
if (dir == 0)
m = n;
else
m = 1;
}
if (m == k && i != len - 1) {
flag = true;
break;
}
}
if (!flag) {
puts("Stowaway");
} else {
printf("Controller %d\n", t);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, t;
int v;
cin >> t;
long long int a = 6, b = 10, c = 14;
while (t--) {
cin >> n;
if (n <= 30)
cout << "NO" << endl;
else if (n == 36 || n == 40 || n == 44) {
cout << "YES" << endl;
cout << "6 10 15 " << n - 31 << endl;
} else {
cout << "YES" << endl;
cout << "6 10 14 " << n - 30 << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
int b[n];
int p1 = 0, p2 = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
b[i] = a[i];
}
sort(b, b + n);
for (int i = 1; i < n; i++) {
if (a[i - 1] > a[i]) {
int j = i;
while (j < n && a[j] < a[j - 1]) {
j++;
}
p1 = i - 1;
p2 = j - 1;
break;
}
}
sort(a + p1, a + p2 + 1);
bool t = 1;
for (int i = 0; i < n; i++) {
if (a[i] != b[i]) {
t = 0;
}
}
if (!t)
cout << "no";
else {
cout << "yes" << endl;
cout << p1 + 1 << " " << p2 + 1;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:10000000000")
using namespace std;
const int MOD = 1000000007;
const int INF = 1000000007LL;
const long long INF2 = 1000000007LL * 1000000007LL;
const long double EPS = 1e-9;
const int SIZE = 100100;
mt19937 rng(time(0));
uniform_int_distribution<int> uid(-1000000000, 1000000000);
int n, m, k;
vector<int> g[SIZE], r[2], gn[SIZE];
int u[SIZE];
int u1[SIZE];
int a, b;
void dfs(int v, int c = 1) {
if (u1[v]) return;
u1[v] = c;
r[c - 1].push_back(v);
for (auto& i : g[v]) dfs(i, 3 - c);
}
bool cmp(int x, int y) { return g[x].size() < g[y].size(); }
vector<int> opposite(int x) {
set<int> st;
for (int i = 0; i < n; ++i) st.insert(i);
for (auto& i : g[x]) st.erase(i);
vector<int> rs;
for (auto& i : st) {
if (u1[i] == u1[x]) continue;
rs.push_back(i);
if (rs.size() == 2) break;
}
return rs;
}
bool cmp2(int x, int y) { return gn[x].size() > gn[y].size(); }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
k = n - 1;
for (int rep_iter = 0; rep_iter < m; ++rep_iter) {
cin >> a >> b;
--a;
--b;
g[a].push_back(b);
g[b].push_back(a);
}
for (int i = 0; i < n; ++i) {
sort(begin(g[i]), end(g[i]));
}
for (int i = 0; i < n; ++i) {
dfs(i);
}
if (r[0].size() % 3 == 0) {
for (auto& i : r[0]) {
u[i] = k / 3 + 1;
--k;
}
for (auto& i : r[1]) {
u[i] = k / 3 + 1;
--k;
}
cout << "YES\n";
for (int i = 0; i < n; ++i) {
cout << u[i] << ' ';
}
return 0;
}
if (r[1].size() % 3 == 1) swap(r[0], r[1]);
sort(begin(r[0]), end(r[0]), cmp);
if (g[r[0][0]].size() <= r[1].size() - 2) {
vector<int> x = opposite(r[0][0]);
u[r[0][0]] = k / 3 + 1;
for (auto& i : x) u[i] = k / 3 + 1;
x.push_back(r[0][0]);
k -= 3;
for (auto& i : r[0]) {
if ((find(begin(x), end(x), i) != end(x))) continue;
u[i] = k / 3 + 1;
--k;
}
for (auto& i : r[1]) {
if ((find(begin(x), end(x), i) != end(x))) continue;
u[i] = k / 3 + 1;
--k;
}
cout << "YES\n";
for (int i = 0; i < n; ++i) {
cout << u[i] << ' ';
}
return 0;
}
for (auto& i : r[0]) {
if (g[i].size() == r[1].size()) break;
gn[opposite(i)[0]].push_back(i);
}
sort(begin(r[1]), end(r[1]), cmp2);
if (gn[r[1][1]].size() < 2) {
cout << "NO";
return 0;
}
vector<int> x;
x.push_back(r[1][0]);
x.push_back(gn[r[1][0]][0]);
x.push_back(gn[r[1][0]][1]);
x.push_back(r[1][1]);
x.push_back(gn[r[1][1]][0]);
x.push_back(gn[r[1][1]][1]);
for (auto& i : x) {
u[i] = k / 3 + 1;
--k;
}
for (auto& i : r[0]) {
if ((find(begin(x), end(x), i) != end(x))) continue;
u[i] = k / 3 + 1;
--k;
}
for (auto& i : r[1]) {
if ((find(begin(x), end(x), i) != end(x))) continue;
u[i] = k / 3 + 1;
--k;
}
cout << "YES\n";
for (int i = 0; i < n; ++i) {
cout << u[i] << ' ';
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void setmax(T &a, T b) {
if (b > a) a = b;
}
template <class T>
inline void setmin(T &a, T b) {
if (b < a) a = b;
}
long long ans = 0;
map<int, int> inSegPos, segPos;
class seg {
public:
vector<int> pr, ne;
int st, size, number;
seg() {}
void push(vector<int> &t, int v) {
if (t[v] != -1) {
t[v * 2] = t[v * 2 + 1] = t[v];
t[v] = -1;
}
}
void update(vector<int> &t, int v, int tl, int tr, int l, int r, int color) {
if (l > r) return;
if (l == tl && tr == r)
t[v] = color;
else {
push(t, v);
int tm = (tl + tr) / 2;
update(t, v * 2, tl, tm, l, min(r, tm), color);
update(t, v * 2 + 1, tm + 1, tr, max(l, tm + 1), r, color);
}
}
void update(vector<int> &t, int l, int r, int val) {
if (r >= l)
update(t, 1, 0, st - 1, l, r, val);
else {
update(t, 1, 0, st - 1, l, size - 1, val);
update(t, 1, 0, st - 1, 0, r, val);
}
}
int get(vector<int> &t, int v, int tl, int tr, int pos) {
if (tl == tr) return t[v];
push(t, v);
int tm = (tl + tr) / 2;
if (pos <= tm)
return get(t, v * 2, tl, tm, pos);
else
return get(t, v * 2 + 1, tm + 1, tr, pos);
}
int get(vector<int> &t, int pos) { return get(t, 1, 0, st - 1, pos); }
void add(int pos, int id) {
if (number == size) {
assert(0);
}
number++;
int next = get(ne, pos);
int prev = get(pr, pos);
ans += (next + size - pos) % size;
inSegPos[id] = next;
if (number == size) return;
pos = next;
next = get(ne, (pos + 1) % size);
prev = get(pr, pos);
update(ne, (prev + 1) % size, pos, next);
update(pr, (pos + 1) % size, next, prev);
}
void del(int pos) {
if (size == number) {
update(pr, 0, size - 1, pos);
update(ne, 0, size - 1, pos);
} else {
int next = get(ne, pos);
int prev = get(pr, pos);
assert(next != pos);
update(ne, (prev + 1) % size, pos, pos);
update(pr, (pos + 1) % size, next, pos);
}
number--;
}
seg(int size_) {
size = size_;
pr.resize(size * 4 + 5);
ne.resize(size * 4 + 5);
number = 0;
st = 1;
while (size >= st) st *= 2;
for (int i = 0; i < size; i++) {
update(ne, i, i, i);
update(pr, i, i, (i - 1 + size) % size);
}
}
};
vector<int> sizes;
vector<pair<int, int> > pos;
vector<seg> segs;
int main(void) {
int h, n, m;
cin >> h >> m >> n;
vector<bool> was(h);
pos.resize(h);
for (int i = 0; i < h; i++) {
if (was[i]) continue;
int t = i, size = 0;
while (!was[t]) {
was[t] = true;
pos[t] = make_pair(((int)((sizes).size())), size);
size++;
t = (t + m) % h;
}
sizes.push_back(size);
}
segs.resize(((int)((sizes).size())));
for (int i = 0; i < ((int)((sizes).size())); i++) segs[i] = seg(sizes[i]);
fgetc(stdin);
for (int i = 0; i < n; i++) {
char ch;
int id, hash;
scanf("%c %d", &ch, &id);
if (ch == '+') {
scanf("%d", &hash);
segPos[id] = pos[hash].first;
segs[pos[hash].first].add(pos[hash].second, id);
} else if (ch == '-') {
segs[segPos[id]].del(inSegPos[id]);
}
fgetc(stdin);
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 85 - 69, maxsq = 315;
int a[maxn], dadash[maxn], cnt[maxn];
int n, que;
void fix(int id) {
for (int i = (id + 1) * maxsq - 1; i >= id * maxsq; i--) {
int newpos = i + a[i];
if (newpos >= n) {
dadash[i] = i;
cnt[i] = 0;
} else if (i / maxsq == newpos / maxsq) {
dadash[i] = dadash[newpos];
cnt[i] = cnt[newpos] + 1;
} else {
dadash[i] = newpos;
cnt[i] = 1;
}
}
return;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> que;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = maxn / 2 / maxsq; i >= 0; i--) fix(i);
while (que--) {
int ty;
cin >> ty;
if (ty) {
int fi, count = 1;
cin >> fi;
fi--;
while (dadash[fi] != fi) count += cnt[fi], fi = dadash[fi];
count += cnt[fi];
cout << fi + 1 << ' ' << count << '\n';
} else {
int fi, se;
cin >> fi >> se;
fi--;
a[fi] = se;
fix(fi / maxsq);
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long mod = (1000000007LL);
inline long long poww(long long a, long long b) {
long long res = 1;
while (b > 0) {
if (b & 1) res = (res * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return res;
}
inline pair<long long, long long> operator+(pair<long long, long long> A,
pair<long long, long long> B) {
return pair<long long, long long>(A.first + B.first, A.second + B.second);
}
inline pair<long long, long long> operator-(pair<long long, long long> A,
pair<long long, long long> B) {
return pair<long long, long long>(A.first - B.first, A.second - B.second);
}
inline long long mult(long long a, long long b) { return (a * b) % mod; }
long long gcd(long long a, long long b) {
while (b) {
a %= b;
swap(a, b);
}
return a;
}
long long n, m, q, k, v[300050], ans;
pair<long long, long long> w[300050];
string second;
long long xmax, inf = 2000000000;
long long L[300050], R[300050];
long long cost(long long i, long long j) {
if (L[j] <= i and i <= R[j]) return 0;
long long delta = min(abs(L[j] - i), abs(R[j] - i));
return delta;
}
long long dp[300050][2];
long long solve(long long i, long long j) {
if (i > xmax) return 0;
if (j > n) return inf;
if (dp[i][j] != -1) return dp[i][j];
long long A = solve(i, j + 1);
for (long long delta = 0; delta <= 1000; delta++) {
if (cost(i, j) <= delta) {
A = min(A, solve(R[j] + delta + 1, j + 1) + delta);
}
}
return dp[i][j] = A;
}
long long opt[300050][2];
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> xmax;
vector<pair<long long, long long> > val;
for (long long i = 1; i <= n; i++) {
long long x, len;
cin >> x >> len;
val.push_back({x - len, x + len});
}
sort(begin(val), end(val));
for (long long i = 0; i < (long long)(val).size(); i++) {
L[i + 1] = val[i].first;
R[i + 1] = val[i].second;
}
for (long long j = n + 1; j >= 1; j--) {
for (long long i = xmax + 1; i >= 1; i--) {
if (i > xmax) {
dp[i][j & 1] = 0;
} else if (j > n)
dp[i][j & 1] = inf;
else {
dp[i][j & 1] = dp[i][(j + 1) & 1];
long long c = cost(i, j);
long long u = R[j] + 1;
if (u + c > xmax) {
dp[i][j & 1] = c;
} else
dp[i][j & 1] = min(dp[i][j & 1], opt[u + c][(j + 1) & 1]);
}
if (i <= xmax)
opt[i][j & 1] = min(opt[i + 1][j & 1], dp[i][j & 1] + i - R[j - 1] - 1);
else
opt[i][j & 1] = dp[i][j & 1] + i - R[j - 1] - 1;
}
}
cout << dp[1][1] << "\n";
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
map<int, bool> flag;
int ans[200020];
int main() {
int n, k;
queue<int> q;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
int id;
cin >> id;
if (flag[id])
continue;
else {
if ((int)q.size() >= k) {
int temp = q.front();
q.pop();
flag[temp] = false;
q.push(id);
flag[id] = true;
} else {
q.push(id);
flag[id] = true;
}
}
}
int sz = (int)q.size();
cout << sz << endl;
int j = sz - 1;
while (!q.empty()) {
ans[j--] = q.front();
q.pop();
}
for (int i = 0; i < sz; i++) {
cout << ans[i] << " ";
}
cout << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
list<int> ciclo;
vector<pair<int, int> > adj[7];
void dfs(list<int>::iterator it, int u) {
it = ciclo.insert(it, u);
for (int j = 0; j < (int)adj[u].size(); ++j) {
pair<int, int> &v = adj[u][j];
if (v.second) {
v.second = 0;
for (int k = 0; k < (int)adj[v.first].size(); ++k) {
pair<int, int> &other = adj[v.first][k];
if (other.first == u && other.second) {
other.second = 0;
break;
}
}
dfs(it, v.first);
}
}
}
int x[105], y[105];
int deg[7];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d %d", &x[i], &y[i]);
adj[x[i]].push_back(pair<int, int>(y[i], 1));
adj[y[i]].push_back(pair<int, int>(x[i], 1));
deg[x[i]]++;
deg[y[i]]++;
}
int even = 0, odd = 0, start = 0;
for (int i = 0; i < 7; ++i) {
if (deg[i] == 0) continue;
if (deg[i] & 1)
odd++, start = i;
else
even++;
}
if (odd != 0 && odd != 2) {
puts("No solution");
return 0;
}
if (odd == 0) {
for (int i = 0; i < 7; ++i)
if (deg[i]) start = i;
}
dfs(ciclo.begin(), start);
vector<int> sol(ciclo.begin(), ciclo.end());
vector<pair<int, int> > answer;
int prev;
for (int i = 0; i < (int)sol.size(); ++i) {
if (i == 0) {
prev = sol[i];
continue;
}
int current = sol[i];
for (int rep = 0; rep < n; ++rep) {
if (x[rep] == -1 || y[rep] == -1) continue;
if (prev == x[rep] && current == y[rep]) {
answer.push_back(pair<int, int>(rep + 1, 0));
x[rep] = y[rep] = -1;
break;
} else if (prev == y[rep] && current == x[rep]) {
answer.push_back(pair<int, int>(rep + 1, 1));
x[rep] = y[rep] = -1;
break;
}
}
prev = current;
}
if (answer.size() != n) {
puts("No solution");
} else {
for (int i = 0; i < n; ++i)
printf("%d %c\n", answer[i].first, answer[i].second == 0 ? '+' : '-');
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5;
map<int, int> mp[20];
int a[maxn + 10];
int n, k;
int mo[maxn + 10][20];
long long ans;
inline void init() {
for (int i = 1; i <= n; i++) {
mo[i][0] = a[i] % k;
for (int j = 1; j <= 10; j++) {
mo[i][j] = (int)(((long long)mo[i][j - 1]) * 10 % k);
}
}
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
init();
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= 10; j++) {
mp[j][mo[i][j]]++;
}
}
for (int i = 1; i <= n; i++) {
int w = 1 + (int)log10(a[i]);
if (mo[i][0] != 0) {
ans += mp[w][k - mo[i][0]];
} else {
ans += mp[w][0];
}
if ((mo[i][0] + mo[i][w]) % k == 0) {
ans--;
}
}
printf("%I64d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n, pos2, res = 1, pos1;
string s;
int main() {
cin >> s;
n = s.length();
s = ' ' + s;
pos2 = n;
for (int i = n - 1; i >= 1; i--)
if (s[i] != s[i + 1])
pos2--;
else
break;
pos1 = 1;
for (int i = 2; i <= n; i++)
if (s[i] != s[i - 1])
pos1++;
else
break;
if (s[1] != s[n])
if (pos1 < pos2)
res = pos1 + n - pos2 + 1;
else
res = n;
int tmp = 1;
for (int i = 2; i <= n; i++) {
if (s[i] != s[i - 1]) {
tmp++;
res = max(res, tmp);
} else
tmp = 1;
}
cout << res;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void print(T a, char c = '\n') {
cout << a << c;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
vector<long long> v;
long long m, n;
cin >> n >> m;
long long a[m + 1], total = 0, c = 1;
for (long long i = 1; i <= m; i++) {
cin >> a[i];
total += a[i];
}
if (total < n) {
print(-1);
return 0;
}
for (long long i = 1; i <= m; i++) {
v.push_back(c);
if ((n - a[i]) + 1 < c) {
print(-1);
return 0;
}
if (total - a[i] >= n - i) {
c++;
} else {
c = n - ((total - a[i])) + 1;
}
total -= a[i];
}
for (auto i : v) print(i, ' ');
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void Z(char *s, int *z, int n) {
memset(z, 0, n << 2);
int c = 0;
for (int i = 1; i < n; i++) {
if (i + z[i - c] < c + z[c]) {
z[i] = z[i - c];
} else {
z[i] = max(0, c + z[c] - i);
while (i + z[i] < n && s[z[i]] == s[i + z[i]]) z[i]++;
c = i;
}
}
z[0] = n;
}
struct Hash {
int mod, len;
vector<long long> h, pw;
Hash() {}
Hash(char *s, int _len, int _mod) {
len = _len;
mod = _mod;
h.resize(len + 1);
pw.resize(len + 1);
pw[0] = 1;
for (int i = 1; i <= len; i++) {
pw[i] = pw[i - 1] * 10 % mod;
h[i] = (h[i - 1] * 10 + s[i] - '0') % mod;
}
}
long long get(int l, int r) {
static long long res;
res = (h[r] - h[l - 1] * pw[r - l + 1]) % mod;
return res < 0 ? res + mod : res;
}
};
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
bool isprime(int x) {
for (int i = 2; i * i <= x; i++)
if (x % i == 0) return 0;
return 1;
}
int randomprime() {
int res = 4;
while (!isprime(res)) res = 1e9 + rng() % 5000;
return res;
}
long long mods[] = {(long long)1e9 + 7, 998244353, 19260817, randomprime(),
randomprime()};
struct hashval5 {
long long h[5];
hashval5() {}
hashval5(Hash *s, int l, int r) {
for (int i = 0; i < 5; i++) h[i] = s[i].get(l, r);
}
hashval5 &operator+=(const hashval5 &a) {
for (int i = 0; i < 5; i++) h[i] = (h[i] + a.h[i]) % mods[i];
return *this;
}
hashval5 operator+(const hashval5 &a) {
hashval5 res = *this;
res += a;
return res;
}
bool operator==(const hashval5 &a) { return !memcmp(h, a.h, sizeof(h)); }
};
struct hash5 {
Hash h[5];
hash5() {}
hash5(char *s, int len) {
for (int i = 0; i < 5; i++) h[i] = Hash(s, len, mods[i]);
}
hashval5 get(int l, int r) { return hashval5(h, l, r); }
hashval5 get(int l1, int r1, int l2, int r2) {
return hashval5(h, l1, r1) + hashval5(h, l2, r2);
}
};
int n, m, lcp[500005], zbox[700005], len[500005];
char s[500005], t[200005], zstr[700005];
hash5 hs, ht;
hashval5 want;
void cmp(int l1, int r1, int l2, int r2) {
int carry = 0;
for (int i = 0; i < m; i++) {
if (r1 - i >= l1) carry += s[r1 - i] - '0';
if (r2 - i >= l2) carry += s[r2 - i] - '0';
if (carry % 10 != t[m - i] - '0') return;
carry /= 10;
}
if (!carry) {
cout << l1 << ' ' << r1 << '\n' << l2 << ' ' << r2;
exit(0);
}
}
void test(int l1, int r1, int l2, int r2) {
if (hs.get(l1, r1, l2, r2) == want) {
cmp(l1, r1, l2, r2);
}
}
void check(int l, int r, int k) {
if (k > 0) {
if (r + k <= n) test(l, r, r + 1, r + k);
if (l - k >= 1) test(l - k, l - 1, l, r);
}
}
void deal(int l, int r) {
int ps, pt;
if (r - l + 1 < m) {
ps = l - 1, pt = 1;
check(l, r, m);
if (t[1] != '1') return;
} else {
if (lcp[l] >= m) return;
ps = l + lcp[l];
pt = 1 + lcp[l];
if (t[pt] < s[ps]) return;
check(l, r, r - ps + 1);
if (ps == r || t[pt] != s[ps] + 1) return;
}
int cl = min(len[ps + 1], r - ps);
check(l, r, r - ps - cl);
check(l, r, r - ps - cl + 1);
check(l, r, max(1, m - pt));
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> s + 1 >> t + 1;
n = strlen(s + 1);
m = strlen(t + 1);
hs = hash5(s, n);
ht = hash5(t, m);
want = ht.get(1, m);
memcpy(zstr + 1, t + 1, m);
memcpy(zstr + m + 1, s + 1, n);
Z(zstr + 1, zbox + 1, m + n);
for (int i = n; i >= 1; i--) {
lcp[i] = min(zbox[i + m], m);
len[i] = s[i] == '9' ? len[i + 1] + 1 : 0;
}
for (int i = 1; i + m - 1 <= n; i++) deal(i, i + m - 1);
if (m > 1)
for (int i = 1; i + m - 2 <= n; i++) deal(i, i + m - 2);
return 0;
}
| 12 |
#include <bits/stdc++.h>
template <class T>
bool setmax(T& l, T const& r) {
if (not(l < r)) return false;
l = r;
return true;
}
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<int> a(n);
for (int i = 0; (i) < (n); ++(i)) cin >> a[i];
vector<vector<int> > g(n);
for (int i = 0; (i) < (n - 1); ++(i)) {
int u, v;
cin >> u >> v;
--u;
--v;
g[u].push_back(v);
g[v].push_back(u);
}
int low = *min_element(a.begin(), a.end());
int high = *max_element(a.begin(), a.end()) + 1;
while (low + 1 < high) {
int mid = (low + high) / 2;
auto forbidden = [&](int i) { return a[i] < mid; };
bool found = false;
vector<bool> used(n);
vector<int> dp(n);
vector<bool> has_forbidden(n);
for (int i = 0; (i) < (n); ++(i))
if (not forbidden(i) and not used[i]) {
int root = -1;
function<void(int)> collect = [&](int i) {
used[i] = true;
for (int j : g[i])
if (not used[j]) {
if (not forbidden(j)) collect(j);
if (forbidden(j)) root = i;
}
};
collect(i);
if (root == -1) {
found = true;
break;
}
function<void(int, int)> dfs = [&](int i, int p) {
if (found) return;
int max_forbidden = 0;
int snd_forbidden = 0;
int sum_free = 0;
for (int j : g[i])
if (j != p) {
if (forbidden(j)) {
has_forbidden[i] = true;
} else {
dfs(j, i);
if (found) return;
if (has_forbidden[j]) {
has_forbidden[i] = true;
setmax(snd_forbidden, dp[j]);
if (max_forbidden < snd_forbidden)
swap(max_forbidden, snd_forbidden);
} else {
sum_free += dp[j];
}
}
}
dp[i] = 1 + sum_free + max_forbidden;
if (k <= dp[i] + snd_forbidden) found = true;
};
dfs(root, -1);
if (found) break;
}
(not found ? high : low) = mid;
}
cout << low << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int m[104][104];
int n;
string inp;
int cross = 0;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
cin >> n;
memset(m, 0, sizeof(m));
for (int i = 1; i <= n; i++) {
cin >> inp;
for (int j = 1; j <= n; j++) {
m[i][j] = (inp[j - 1] == '#' ? 1 : 0);
if (inp[j - 1] == '#') cross++;
}
}
for (int l = 0; l <= 100; l++) {
for (int i = 1; i <= n - 2; i++) {
for (int j = 1; j <= n - 2; j++) {
if (m[i][j] == 0 && m[i + 1][j] == 1 && m[i + 2][j] == 0 &&
m[i][j + 1] == 1 && m[i + 1][j + 1] == 1 && m[i + 2][j + 1] == 1 &&
m[i + 1][j + 2] == 1) {
cross -= 5;
m[i + 1][j] = m[i][j + 1] = m[i + 1][j + 1] = m[i + 2][j + 1] =
m[i + 1][j + 2] = 0;
}
}
}
}
if (cross == 0) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios::sync_with_stdio(0);
std::cin.tie(0);
std::cout.tie(0);
int n;
cin >> n;
vector<pair<long long, long long> > a(n);
for (int i = 0; i < n; i++) cin >> a[i].first, a[i].second = i;
sort(a.begin(), a.end());
vector<int> teamSize(n, 3);
vector<long long> dp(n, 0);
long long INF = 1e18;
dp[n - 3] = a[n - 1].first - a[n - 3].first;
for (int i = n - 4; i >= 0; i--) {
long long temp = ((i + 3 <= n - 3) ? a[i + 2].first + dp[i + 3] : INF);
dp[i] = -a[i].first + min(a[i + 1].first + dp[i + 1], temp);
if ((i + 3 <= n - 3) && (temp < a[i + 1].first + dp[i + 1])) {
teamSize[i] = 3;
} else
teamSize[i] = teamSize[i + 1] + 1;
}
int cur = 0;
int id = 1;
while (cur < n) {
int curSize = teamSize[cur];
while (curSize--) {
swap(a[cur].first, a[cur].second);
a[cur++].second = id;
}
id++;
}
cout << dp[0] << " " << id - 1 << "\n";
sort(a.begin(), a.end());
for (auto it : a) cout << it.second << " ";
cout << "\n";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000 * 100 * 2 + 10;
long long int a[MAXN];
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int n, k;
cin >> n >> k;
int ans = MAXN;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < MAXN; i++) {
vector<int> v;
int cnt = 0;
for (int j = 0; j < n; j++) {
int t = a[j], c = 0;
while (t > i) {
c++;
t /= 2;
}
if (t == i) {
cnt++;
v.push_back(c);
}
}
if (cnt >= k) {
sort(v.begin(), v.end());
int d = 0;
for (int j = 0; j < k; j++) {
d += v[j];
}
ans = min(ans, d);
}
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int M = (int)2e5 + 5, INF = (int)1e9 + 7;
template <class T>
void Rd(T &res) {
res = 0;
static char p;
while (p = getchar(), p < '0')
;
do {
res = (res * 10) + (p ^ 48);
} while (p = getchar(), p >= '0');
}
template <class T>
void Ps(T x) {
if (x == 0) return;
Ps(x / 10);
putchar(x % 10 ^ 48);
}
template <class T>
void Pt(T x) {
if (x == 0)
putchar('0');
else
Ps(x);
putchar('\n');
}
template <class T>
void Min(T &x, T y) {
if (x > y) x = y;
}
struct W {
int to, nx;
} Lis[M];
int Head[M], tot;
void Add(int x, int y) {
Lis[++tot] = (W){y, Head[x]};
Head[x] = tot;
}
int n, q, de[M], up_to_1[M], L[M], R[M], dfs_cnt, id[M * 2];
long long val[M * 4], che[M * 4], dep[M];
void ADD(int x, int v) {
while (x <= n) {
dep[x] += v;
x += x & (-x);
}
}
long long Sum(int x) {
long long re = 0;
while (x) {
re += dep[x];
x -= x & (-x);
}
return re;
}
void up(int p) { val[p] = min(val[p << 1], val[p << 1 | 1]); }
void down(int p) {
if (che[p]) {
che[p << 1] += che[p], che[p << 1 | 1] += che[p];
val[p << 1] += che[p], val[p << 1 | 1] += che[p];
che[p] = 0;
}
}
void update(int L, int R, int p, int x, long long v) {
if (L == R) {
val[p] = v;
return;
}
down(p);
int mid = (L + R) >> 1;
if (mid >= x)
update(L, mid, p << 1, x, v);
else
update(mid + 1, R, p << 1 | 1, x, v);
up(p);
}
void update_(int L, int R, int p, int l, int r, int v) {
if (L == l && R == r) {
val[p] += v;
che[p] += v;
return;
}
down(p);
int mid = (L + R) >> 1;
if (mid >= r)
update_(L, mid, p << 1, l, r, v);
else if (mid < l)
update_(mid + 1, R, p << 1 | 1, l, r, v);
else
update_(L, mid, p << 1, l, mid, v),
update_(mid + 1, R, p << 1 | 1, mid + 1, r, v);
up(p);
}
long long query(int L, int R, int p, int l, int r) {
if (L == l && R == r) return val[p];
down(p);
int mid = (L + R) >> 1;
if (mid >= r)
return query(L, mid, p << 1, l, r);
else if (mid < l)
return query(mid + 1, R, p << 1 | 1, l, r);
else
return min(query(L, mid, p << 1, l, mid),
query(mid + 1, R, p << 1 | 1, mid + 1, r));
}
void dfs(int x) {
L[x] = ++dfs_cnt;
ADD(L[x], de[x]);
for (int i = Head[x], to; i && (to = Lis[i].to, 1); i = Lis[i].nx) dfs(to);
R[x] = dfs_cnt;
ADD(R[x] + 1, -de[x]);
update(1, n, 1, L[x], Sum(L[x]) + up_to_1[x]);
}
int main() {
Rd(n), Rd(q);
for (int i = 1, x, y; i < n; i++)
Rd(x), Rd(y), Rd(de[y]), Add(x, y), id[i] = y;
for (int i = 1, x, y; i < n; i++)
Rd(x), Rd(y), Rd(up_to_1[x]), id[i + n - 1] = x;
dfs(1);
for (int i = 1, op, x, y; i <= q; i++) {
Rd(op), Rd(x), Rd(y);
if (op == 1) {
if (x < n) {
x = id[x];
ADD(L[x], y - de[x]);
ADD(R[x] + 1, de[x] - y);
update_(1, n, 1, L[x], R[x], y - de[x]);
de[x] = y;
} else {
x = id[x];
up_to_1[x] = y;
update(1, n, 1, L[x], up_to_1[x] + Sum(L[x]));
}
} else {
long long ans = Sum(L[y]) + query(1, n, 1, L[x], R[x]) - Sum(L[x]);
if (L[x] <= L[y] && R[x] >= R[y]) Min(ans, Sum(L[y]) - Sum(L[x]));
Pt(ans);
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
const long long linf = 1e18 + 7;
const int inf = 1e9 + 7;
const int N = 1e6 + 5;
long long n, a, b, T, pref[N];
string s;
bool check(int x) {
long long mn = linf;
int pos = x;
while (pos >= 1) {
int l = pos - x + 1, r = pos;
if (l <= 0) l = n + l;
long long res = x;
res += (x - 1) * a;
if (l <= r) {
res += pref[r] - pref[l - 1];
} else {
res += pref[r];
res += pref[n] - pref[l - 1];
res += min((int(n) - l + 1), (r - 1)) * a;
}
mn = min(res, mn);
pos--;
}
return mn <= T;
}
int main() {
cin >> n >> a >> b >> T >> s;
s = ' ' + s;
for (int i = 1; i <= n; i++) {
if (s[i] == 'w') pref[i] += b;
pref[i] += pref[i - 1];
}
int l = 0, r = n;
while (r - l > 1) {
int md = (l + r) >> 1;
if (check(md))
l = md;
else
r = md;
}
if (check(r)) l = r;
cout << l << endl;
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
using ll = long long;
using ld = long double;
using VI = vector<ll>;
using VV = vector<VI>;
using VS = vector<string>;
using PII = pair<ll, ll>;
template <typename A, typename B>
string to_string(pair<A, B> p);
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);
string to_string(const string& s) { return '"' + s + '"'; }
string to_string(const char* s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
string to_string(vector<bool> v) {
bool first = true;
string res = "{";
for (int i = 0; i < static_cast<int>(v.size()); i++) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(v[i]);
}
res += "}";
return res;
}
template <size_t N>
string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++) {
res += static_cast<char>('0' + v[i]);
}
return res;
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto& x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ")";
}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}
void debug_out() { cerr << '\n'; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
template <class T>
bool chmax(T& a, const T& b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool chmin(T& a, const T& b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
ll SUM(VI& V) { return accumulate((V).begin(), (V).end(), 0LL); }
ll MIN(VI& V) { return *min_element((V).begin(), (V).end()); }
ll MAX(VI& V) { return *max_element((V).begin(), (V).end()); }
void print_vector(VI& V) {
ll n = V.size();
for (ll i = (0); i < (n); ++i) {
if (i) cout << ' ';
cout << V[i];
}
cout << endl;
}
ll gcd(ll a, ll b) {
if (b == 0) return a;
return gcd(b, a % b);
}
ll lcm(ll a, ll b) {
ll g = gcd(a, b);
return a / g * b;
}
using ld = long double;
using inverse_priority_queue = priority_queue<ll, vector<ll>, greater<ll> >;
int popcount(ll t) { return __builtin_popcountll(t); }
void no() {
cout << ("No") << '\n';
exit(0);
}
void yes() {
cout << ("Yes") << '\n';
exit(0);
}
const ll mod = 1e9 + 7;
const ll inf = 1e18;
const double PI = acos(-1);
ll ceil_div(ll a, ll b) { return (a + b - 1) / b; }
ll string_to_ll(string s) { return atoll(s.c_str()); }
struct mint {
ll x;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
mint operator-() const { return mint(-x); }
mint& operator+=(const mint a) {
if ((x += a.x) >= mod) x -= mod;
return *this;
}
mint& operator-=(const mint a) {
if ((x += mod - a.x) >= mod) x -= mod;
return *this;
}
mint& operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const {
mint res(*this);
return res += a;
}
mint operator-(const mint a) const {
mint res(*this);
return res -= a;
}
mint operator*(const mint a) const {
mint res(*this);
return res *= a;
}
mint pow(ll t) const {
if (!t) return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1) a *= *this;
return a;
}
mint inv() const { return pow(mod - 2); }
mint& operator/=(const mint a) { return (*this) *= a.inv(); }
mint operator/(const mint a) const {
mint res(*this);
return res /= a;
}
};
void solve() {
ll N;
cin >> N;
VI A(N);
for (ll i = (0); i < (N); ++i) {
cin >> A[i];
}
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll N, K, L;
cin >> N >> K >> L;
42;
VI A(N * K);
for (ll i = (0); i < (N * K); ++i) cin >> A[i];
sort((A).begin(), (A).end());
42;
if (A[N - 1] - A[0] > L) {
cout << (0) << '\n';
return 0;
}
ll ma = A[0] + L;
ll cnt = 0;
for (ll a : A) {
if (a <= ma) cnt++;
}
42;
42;
inverse_priority_queue que;
for (ll a : A) {
if (a <= ma) que.push(a);
}
42;
ll kezuri = que.size() - N;
42;
ll sum = 0;
for (ll i = (0); i < (N); ++i) {
ll mi = que.top();
que.pop();
ll cnt = 1;
while (kezuri && cnt < K) {
42;
que.pop();
kezuri--;
cnt++;
}
sum += mi;
}
cout << (sum) << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void solve();
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
cin >> t;
while (t--) solve();
}
void solve() {
int n;
cin >> n;
string s;
cin >> s;
int ind = -1;
for (int i = 0; i < n; ++i) {
if (s[i] == '0') {
ind = i;
break;
}
}
if (ind != -1 and ind <= (n / 2 - 1)) {
cout << ind + 2 << " " << n << " " << ind + 1 << " " << n << "\n";
} else if (ind != -1) {
cout << 1 << " " << ind + 1 << " " << 1 << " " << ind << "\n";
} else {
cout << 1 << " " << (n) / 2 << " " << (n + 1) / 2 + 1 << " " << n << "\n";
}
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
template <typename X>
inline X abs(const X& a) {
return a < 0 ? -a : a;
}
template <typename X>
inline X sqr(const X& a) {
return a * a;
}
const int size = 1e5 + 5;
const double eps = 0.0001;
const long double PI = 3.1415926535897932384626433832795;
const long long MOD = 1000000007;
const long long INF = 1LL << 62;
const long long MAX5 = 100001;
const long long MAX6 = 1000001;
const long long MAX17 = 99999999999999999;
const double DMAX = 2e18 + 5;
const int P = 239017;
void solution();
void include_file();
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solution();
return 0;
}
inline void include_file() {
ios_base::sync_with_stdio(true);
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
inline bool isPrime(long long n) {
for (int i = 2; i * i <= n; ++i)
if (n % i == 0) return false;
return true;
}
inline string ekv(string a) {
if (a.size() & 1) return a;
string x = ekv(a.substr(0, a.size() / 2));
string y = ekv(a.substr(a.size() / 2));
return min(x + y, y + x);
}
inline long long cubic_root(long long x) {
long long l = 0, r = MAX6;
while (l != r) {
long long m = (l + r + 1) / 2;
if (m * m * m > x)
r = m - 1;
else
l = m;
}
return l;
}
inline float FastInvSqrt(float x) {
float xhalf = 0.5f * x;
int i = *(int*)&x;
i = 0x5f3759df - (i >> 1);
x = *(float*)&i;
x = x * (1.5f - (xhalf * x * x));
return x;
}
inline long long gcd(long long a, long long b) {
while (b ^= a ^= b ^= a = a % b)
;
return a;
}
inline long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
unsigned long long NCR(unsigned long long n, unsigned long long r) {
if (r == 0) return 1;
if (r > n >> 1) return NCR(n, n - r);
unsigned long long res = 1;
for (long long k = 1; k <= r; ++k) {
res *= (unsigned long long)(n - k + 1);
res /= k;
}
return res;
}
constexpr uint64_t mod = (1ull << 61) - 1;
inline uint64_t modmul(uint64_t a, uint64_t b) {
uint64_t l1 = (uint32_t)a, h1 = a >> 32, l2 = (uint32_t)b, h2 = b >> 32;
uint64_t l = l1 * l2, m = l1 * h2 + l2 * h1, h = h1 * h2;
uint64_t ret =
(l & mod) + (l >> 61) + (h << 3) + (m >> 29) + (m << 35 >> 3) + 1;
ret = (ret & mod) + (ret >> 61);
ret = (ret & mod) + (ret >> 61);
return ret - 1;
}
void yes() { cout << "YES"; }
void no() { cout << "NO"; }
void yes(bool res, bool small = false) {
if (!small) {
if (res)
cout << "YES";
else
cout << "NO";
} else {
if (res)
cout << "Yes";
else
cout << "No";
}
}
void dabl(double x) { printf("%.10lf", x); }
namespace bits {
template <typename X>
inline X MAX(const X& a, const X& b) {
return b & ((a - b) >> 31) | a & (~(a - b) >> 31);
}
template <typename X>
inline X MIN(const X& a, const X& b) {
return a & ((a - b) >> 31) | b & (~(a - b) >> 31);
}
inline bool check2(const long long n) { return n > 0 && (n & (n - 1)); }
inline long long ostatok2(const long long n, const long long m) {
return m & (n - 1);
}
template <typename X>
inline void SWAP(X& a, X& b) {
a ^= b;
b ^= a;
a ^= b;
}
inline size_t count_1_in_LL(unsigned long long n) {
std::size_t i(0);
for (; n; ++i) n &= n - 1;
return i;
}
} // namespace bits
void debug() { cout << endl; }
template <typename H, typename... T>
void debug(H p, T... t) {
std::cout << p << " ";
debug(t...);
}
vector<vector<int> > g;
inline void solution() {
int n;
cin >> n;
int a[n];
for (long long i = 0; i < n; ++i) cin >> a[i];
;
map<int, set<int> > q;
int ideal = 0, k = 0;
for (long long i = 0; i < n; ++i) {
q[a[i]].insert(i);
if (q[a[i]].size() > k) {
k = q[a[i]].size();
ideal = a[i];
}
}
set<int> pos = q[ideal];
vector<pair<int, pair<int, int> > > res;
int cur;
while (pos.size() > 0) {
cur = *pos.begin();
for (int i = cur - 1; i >= 0; --i) {
if (a[i] == ideal)
break;
else {
if (a[i + 1] > a[i])
res.push_back({1, {i + 1, i + 2}});
else
res.push_back({2, {i + 1, i + 2}});
a[i] = ideal;
}
}
pos.erase(cur);
}
if (cur != n - 1) {
for (int i = cur + 1; i < n; ++i) {
if (a[i - 1] > a[i])
res.push_back({1, {i + 1, i}});
else
res.push_back({2, {i + 1, i}});
a[i] = ideal;
}
}
cout << res.size() << endl;
for (auto x : res) {
cout << x.first << " " << x.second.first << " " << x.second.second << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
cin >> n >> m;
map<int, int> g;
vector<int> to_erase;
for (int i = 0; i < m; i++) {
int a;
cin >> a;
if (g.find(a) == g.end()) {
g[a] = 1;
} else {
g[a]++;
}
if (g.size() == n) {
cout << 1;
for (auto it = g.begin(); it != g.end(); ++it) {
g[it->first]--;
if (g[it->first] == 0) to_erase.push_back(it->first);
}
for (int i = 0; i < to_erase.size(); i++) g.erase(to_erase[i]);
to_erase.clear();
} else {
cout << 0;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0;
char ch = getchar();
while (!isdigit(ch)) ch = getchar();
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
return x;
}
inline int Less(double a, double b) { return a + 1e-9 < b; }
inline int Equal(double a, double b) { return fabs(a - b) < 1e-9; }
struct circle {
double x, y, r;
inline void init() { scanf("%lf%lf%lf", &x, &y, &r); }
} c[5];
struct point {
double x, y;
inline point(double tmp1 = 0, double tmp2 = 0) { x = tmp1, y = tmp2; }
};
inline double sqr(double x) { return x * x; }
inline double dis(double x, double y, double a, double b) {
return sqrt(sqr(x - a) + sqr(y - b));
}
inline vector<point> ip(circle X, circle Y) {
double x = X.x, y = X.y, R = X.r;
double a = Y.x, b = Y.y, S = Y.r;
double d = dis(x, y, a, b);
if (d > R + S || d < fabs(R - S)) {
vector<point> ans(0);
return ans;
}
double A = (sqr(R) - sqr(S) + sqr(d)) / (2 * d);
double h = sqrt(sqr(R) - sqr(A));
double x2 = x + A * (a - x) / d, y2 = y + A * (b - y) / d;
double x3 = x2 - h * (b - y) / d, y3 = y2 + h * (a - x) / d;
double x4 = x2 + h * (b - y) / d, y4 = y2 - h * (a - x) / d;
vector<point> ans;
ans.push_back(point(x3, y3));
ans.push_back(point(x4, y4));
return ans;
}
inline int unique(vector<point> p) {
int cnt = 0;
sort(p.begin(), p.end(), [&](point a, point b) {
return Less(a.x, b.x) || Equal(a.x, b.x) && Less(a.y, b.y);
});
for (int i = 0; i < p.size(); i++)
if (!i || (!Equal(p[i].x, p[i - 1].x) || !Equal(p[i].y, p[i - 1].y))) ++cnt;
return cnt;
}
inline int solve(circle a, circle b) {
vector<point> ans = ip(a, b);
int w = unique(ans);
return w == 2 ? 4 : 3;
}
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) c[i].init();
if (n == 1) return puts("2");
if (n == 2) return printf("%d\n", solve(c[1], c[2])), 0;
for (int i = 1; i <= n; i++)
for (int j = i + 1; j <= n; j++) {
vector<point> ans = ip(c[i], c[j]);
int w = unique(ans);
if (!w) continue;
for (int k = 1; k <= n; k++)
if (k != i && k != j) {
vector<point> a = ip(c[i], c[k]);
vector<point> b = ip(c[j], c[k]), ans;
for (int i = 0; i < a.size(); i++) ans.push_back(a[i]);
for (int i = 0; i < b.size(); i++) ans.push_back(b[i]);
int w = unique(ans);
printf("%d\n", solve(c[i], c[j]) + max(1, w));
exit(0);
}
}
puts("4");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 2;
int p[N], a[N], lst[N], inxt[N], pre[N], c[N], dep[N], nd[N], r[N], lj[N],
nxt[N], fir[N];
int n, m, q, i, j, cc, bs;
inline void add(int x, int y) {
lj[++bs] = y;
nxt[bs] = fir[x];
fir[x] = bs;
}
inline void read(int &x) {
cc = getchar();
while ((cc < 48) || (cc > 57)) cc = getchar();
x = cc ^ 48;
cc = getchar();
while ((cc >= 48) && (cc <= 57)) {
x = x * 10 + (cc ^ 48);
cc = getchar();
}
}
void dfs(int x) {
int i;
nd[dep[x]] = x;
if (dep[x] >= n)
r[x] = nd[dep[x] - (n - 1)];
else
r[x] = m + 1;
for (i = fir[x]; i; i = nxt[i]) {
dep[lj[i]] = dep[x] + 1;
dfs(lj[i]);
}
}
int main() {
read(n);
read(m);
read(q);
for (i = 1; i <= n; i++) {
read(p[i]);
inxt[p[i]] = p[i - 1];
}
inxt[p[1]] = p[n];
for (i = 1; i <= m; i++) {
read(a[i]);
pre[i] = lst[a[i]];
lst[a[i]] = i;
for (j = lst[inxt[a[i]]]; (j) && (c[j] == 0); j = pre[j]) c[j] = i;
}
for (i = 1; i <= m; i++)
if (!c[i]) c[i] = m + 1;
for (i = 1; i <= m; i++) add(c[i], i);
dfs(m + 1);
for (i = m - 1; i; i--) r[i] = min(r[i + 1], r[i]);
while (q--) {
read(i);
read(j);
putchar(48 + (r[i] <= j));
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long mapa[51][51];
long mapb[51][51];
long na, ma, nb, mb;
long x, y;
long ansx, ansy;
char getnext() {
char p = getchar();
while (!(p <= '1' && p >= '0')) p = getchar();
return p;
}
int main() {
scanf("%ld%ld", &na, &ma);
for (long i = 1; i <= na; i++)
for (long j = 1; j <= ma; j++) mapa[i][j] = getnext() - '0';
scanf("%ld%ld", &nb, &mb);
for (long i = 1; i <= nb; i++)
for (long j = 1; j <= mb; j++) mapb[i][j] = getnext() - '0';
long ans = 0;
for (x = -50; x <= 50; x++)
for (y = -50; y <= 50; y++) {
long reu = 0;
for (long i = 1; i <= na; i++)
for (long j = 1; j <= ma; j++)
if (i + x >= 1 && i + x <= nb && j + y >= 1 && j + y <= mb)
reu += mapa[i][j] * mapb[i + x][j + y];
if (reu >= ans) {
ans = reu;
ansx = x;
ansy = y;
}
}
printf("%ld %ld\n", ansx, ansy);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
cin >> a >> b;
if (a == 0 && b == 0) {
cout << "NO";
return 0;
}
if (abs(a - b) <= 1)
cout << "YES";
else
cout << "NO";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
inline void beg();
inline void fin();
const int N = 2e5 + 5;
string t, p;
int a[N];
bool check(int num) {
string q = t;
for (int i = 0; i < num; i++) {
q[a[i] - 1] = '#';
}
int j = 0;
for (int i = 0; i < (int)q.size() && j < (int)p.size(); i++) {
if (q[i] == p[j]) j++;
}
return j == (int)p.size();
}
int main() {
beg();
cin >> t >> p;
for (int i = 0; i < (int)t.size(); i++) cin >> a[i];
int lo = 0, hi = (int)t.size(), mid;
while (lo < hi) {
mid = lo + (hi - lo + 1) / 2;
if (check(mid))
lo = mid;
else
hi = mid - 1;
}
cout << lo << endl;
fin();
return 0;
}
inline void beg() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.precision(10);
cout << fixed;
}
inline void fin() {}
| 4 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
template <class T>
inline T sqr(T x) {
return x * x;
}
const double eps = 1e-9;
const double pi = acos(-1.0);
const int maxn = 5005;
vector<int> g[maxn];
int deg[maxn], can[maxn], cur[maxn];
int dfs(int v, int p) {
int res = 1;
for (int i = 0; i < (int)(g[v]).size(); i++) {
int to = g[v][i];
if (to == p) continue;
res += dfs(to, v);
}
return res;
}
void go(int v) {
if (deg[v] == 1) return;
vector<int> s;
int S = 0;
for (int i = 0; i < (int)(g[v]).size(); i++) {
int to = g[v][i];
S += dfs(to, v);
s.push_back(dfs(to, v));
}
memset(cur, 0, sizeof(cur));
cur[0] = 1;
for (int i = 0; i < (int)(s).size(); i++)
for (int j = S; j >= s[i]; j--)
if (cur[j - s[i]]) cur[j] = 1;
for (int i = 1; i < S; i++) can[i] |= cur[i];
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
--a;
--b;
g[a].push_back(b);
g[b].push_back(a);
++deg[a];
++deg[b];
}
vector<pair<int, int> > ans;
for (int i = 0; i < n; i++) go(i);
int res = 0;
for (int i = 1; i <= n - 2; i++)
if (can[i]) res++;
cout << res << endl;
for (int i = 1; i <= n - 2; i++)
if (can[i]) cout << i << " " << n - 1 - i << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long n, k, c, ans[300001], total, var;
vector<pair<int, int> > vec;
map<int, int> mp;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> c;
vec.push_back(make_pair(c, i + 1));
}
sort(vec.rbegin(), vec.rend());
var = k + 1;
for (int i = 0; i < vec.size(); i++) {
int indx = vec[i].second;
if (!mp[indx] && indx >= k + 1) {
ans[indx] = vec[i].second;
mp[indx] = 1;
} else {
while (mp[var]) {
var++;
}
if (var > indx) {
total += (var - vec[i].second) * vec[i].first;
ans[indx] = var;
mp[var] = 1;
} else {
ans[indx] = var;
mp[var] = 1;
}
}
}
cout << total << endl;
for (int i = 1; i <= n; i++) cout << ans[i] << " ";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bitset<2050> tmp, dp;
bool mark[1050];
vector<int> vals;
int main() {
int k, n, i, x, j;
scanf("%i %i", &k, &n);
for (i = 0; i < n; i++) scanf("%i", &x), mark[x] = true;
for (i = 0; i <= 1000; i++)
if (mark[i]) vals.push_back(i - k);
dp.set(1000);
for (i = 1; i <= 1000; i++) {
tmp = 0;
for (j = 0; j < vals.size(); j++) {
if (vals[j] > 0)
tmp |= dp << vals[j];
else
tmp |= dp >> (-vals[j]);
}
dp = tmp;
if (dp.test(1000)) {
printf("%i\n", i);
return 0;
}
}
printf("-1\n");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 1e5 + 10;
long long n, m;
vector<pair<pair<long long, long long>, long long>> ans, ansr;
vector<long long> getter, giver;
long long chiz[maxn];
void in();
void solve();
void out();
int main() {
in();
solve();
out();
}
void in() {
ios::sync_with_stdio(false);
cout.tie(0);
cin.tie(0);
cin >> n >> m;
for (long long i = 0; i < m; i++) {
long long u, v, w;
cin >> u >> v >> w;
u--;
v--;
chiz[u] -= w;
chiz[v] += w;
}
}
void solve() {
for (long long i = 0; i < n; i++) {
if (chiz[i] > 0)
getter.push_back(i);
else if (chiz[i] < 0) {
giver.push_back(i);
chiz[i] = -chiz[i];
}
}
long long now = 0;
for (long long i = 0; i < getter.size(); i++) {
while (now < giver.size() && chiz[giver[now]] < chiz[getter[i]]) {
ansr.push_back({{giver[now], getter[i]}, chiz[giver[now]]});
chiz[getter[i]] -= chiz[giver[now++]];
}
if (now < giver.size()) {
ansr.push_back({{giver[now], getter[i]}, chiz[getter[i]]});
chiz[giver[now]] -= chiz[getter[i]];
}
}
for (auto i : ansr)
if (i.second) ans.push_back(i);
}
void out() {
cout << ans.size() << '\n';
for (auto i : ans)
cout << i.first.first + 1 << ' ' << i.first.second + 1 << ' ' << i.second
<< endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int l = s.find('@'), a = s.size(), b = s.find('/'), d = s.find('.');
if (l <= 0 || s[l + 1] == '.' || a - 1 == l) {
cout << "NO" << endl;
return 0;
}
if (s[a - 1] == '.' || s[d + 1] == '/' || s[a - 1] == '/') {
cout << "NO" << endl;
return 0;
}
for (int i = 0; i < l; i++) {
if (!isalpha(s[i]) && !isalnum(s[i]) && s[i] != '_') {
cout << "NO" << endl;
return 0;
}
}
if (b == -1) {
for (int i = l + 1; i < a; i++) {
if ((!isalpha(s[i]) && !isalnum(s[i]) && s[i] != '_' && s[i] != '.') ||
(s[i] == '.' && s[i + 1] == '.')) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
} else {
for (int i = l + 1; i < b; i++) {
if ((!isalpha(s[i]) && !isalnum(s[i]) && s[i] != '_' && s[i] != '.') ||
(s[i] == '.' && (s[i + 1] == '.' || s[i + 1] == '/'))) {
cout << "NO" << endl;
return 0;
}
}
for (int i = b + 1; i < a; i++) {
if (!isalpha(s[i]) && !isalnum(s[i]) && s[i] != '_') {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
int orands = 0;
vector<int> o(n + 1), a(n + 1);
for (int i = 2; i <= n; i++) {
cout << "and 1 " << i << endl;
cin >> a[i];
orands |= a[i];
}
int andors = (1 << 30) - 1;
for (int i = 2; i <= n; i++) {
cout << "or 1 " << i << endl;
cin >> o[i];
andors &= o[i];
}
cout << "and 2 3" << endl;
int x;
cin >> x;
int c1 = orands;
for (int i = 0; i < 30; i++) {
if (((orands >> i) & 1) == 0 && ((andors >> i) & 1) == 1 &&
((x >> i) & 1) == 0) {
c1 |= (1 << i);
}
}
vector<int> c(n + 1);
c[1] = c1;
for (int i = 2; i <= n; i++) {
c[i] = c[1] ^ (o[i] - a[i]);
}
sort(c.begin() + 1, c.end());
cout << "finish " << c[k] << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long double eps = 1e-7L;
const long double PI = atan(1) * 4.0;
int N, D;
int X[20002], Y[20002], R[20002];
vector<pair<long double, int> > V;
vector<pair<long double, long double> > Rn;
int result;
long double g_dist(long double xn1, long double yn1, long double xn2,
long double yn2) {
return sqrt((xn1 - xn2) * (xn1 - xn2) + (yn1 - yn2) * (yn1 - yn2));
}
void reg(long double& pn) {
while (pn < 0) pn += 2 * PI;
while (pn > 2 * PI) pn -= 2 * PI;
}
int main() {
cin.sync_with_stdio(false);
cin >> N >> D;
for (int i = 1; i <= N; ++i) cin >> X[i] >> Y[i] >> R[i];
for (int i = 1; i <= N; ++i) {
long double dnow = g_dist(0, 0, X[i], Y[i]);
long double dn1 = dnow - R[i], dn2 = dnow + R[i];
int tn1 = int(dn1 / D) - 1, tn2 = int(dn2 / D) + 1;
for (int j = max(1, tn1); j <= tn2; ++j)
if (D * j - dn1 > -eps && D * j - dn2 < eps) {
long double pnow = atan2(Y[i], X[i]),
ang = acos((dnow * dnow + 1.0 * D * j * D * j -
1.0 * R[i] * R[i]) /
(2 * dnow * D * j));
long double pn1 = pnow - ang, pn2 = pnow + ang;
pn2 += 2 * eps;
reg(pn1);
reg(pn2);
V.push_back(make_pair(pn1, 1));
V.push_back(make_pair(pn2, -1));
Rn.push_back(make_pair(pn1, pn2));
}
}
sort(V.begin(), V.end());
int pnow = 0;
for (int i = 0; i < int(Rn.size()); ++i) {
long double pn1 = Rn[i].first, pn2 = Rn[i].second - 2 * eps;
if (pn1 - pn2 < eps) {
if (pn1 - V[0].first < eps && V[0].first - pn2 < eps) ++pnow;
} else {
if (V[0].first - pn1 > -eps || V[0].first - pn2 < eps) ++pnow;
}
}
result = pnow;
int indnow = 0;
while (indnow < int(V.size()) && fabs(V[indnow].first - V[0].first) < eps)
++indnow;
for (int i = indnow; i < int(V.size()); ++i) {
pnow += V[i].second;
result = max(result, pnow);
}
cout << result << '\n';
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (!b) return a;
return gcd(b, a % b);
}
const int MAXN = 2e5 + 5;
int N, M;
bool forb[MAXN];
pair<int, int> egcd(long long a, long long b) {
if (b == 0) return {1, 0};
pair<int, int> RES = egcd(b, a % b);
return {RES.second, RES.first - RES.second * (a / b)};
}
long long inv(long long n, long long m) {
pair<int, int> EDGC = egcd(n, m);
return ((EDGC.first % m) + m) % m;
}
vector<int> val[MAXN], node;
vector<int> G[MAXN];
pair<int, int> dp[MAXN];
pair<int, int> f(int v) {
pair<int, int> &ret = dp[v];
if (ret.first != -1) return dp[v];
ret = {0, -1};
for (int i = 0; i < (int)G[v].size(); i++) {
int u = G[v][i];
ret = max(ret, {f(u).first, u});
}
ret.first += val[v].size();
return ret;
}
int main() {
scanf("%d", &N), scanf("%d", &M);
for (int i = 0; i < (int)N; i++) {
int x;
scanf("%d", &x);
forb[x] = true;
}
for (int i = 0; i < (int)M; i++) {
int g = gcd(i, M) % M;
if (forb[i]) continue;
val[g].push_back(i);
if (val[g].size() == 1) node.push_back(g);
}
for (int i = 0; i < (int)node.size(); i++)
for (int j = 0; j < (int)node.size(); j++)
if (i != j && node[i] != 0 && node[j] % node[i] == 0)
G[node[i]].push_back(node[j]);
for (int i = 0; i < (int)node.size(); i++) dp[node[i]] = {-1, -1};
int v = -1, ans = 0;
for (int i = 0; i < (int)node.size(); i++)
if (f(node[i]).first > ans) {
ans = f(node[i]).first;
v = node[i];
}
int cur = 1;
printf("%d\n", ans);
while (v != -1) {
for (int i = 0; i < (int)val[v].size(); i++) {
printf("%lld ", (inv(cur, M) * val[v][i] / gcd(M, cur)) % M);
cur = val[v][i];
}
v = f(v).second;
}
}
| 7 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.