solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
long long int getSum(long long int n) {
long long int sum;
for (sum = 0; n > 0; sum += n % 10, n /= 10)
;
return sum;
}
int32_t main() {
long long int n;
cin >> n;
long long int start = getSum(n);
if (start % 4 == 0) {
cout << n << endl;
return 0;
}
for (long long int i = n + 1; i < n + 1000; ++i) {
if (getSum(i) % 4 == 0) {
cout << i << endl;
return 0;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string y, z, p;
string x =
"zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz"
"zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz"
"zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz"
"zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz"
"zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz";
int i, j, k, l, m, n;
p = x;
cin >> z >> n;
for (i = 0; i < n; i++) {
k = 0;
cin >> y;
for (j = 0; j < z.size(); j++) {
if (y[j] != z[j]) {
k = 1;
break;
}
}
if (k == 1) continue;
x = min(x, y);
}
if (p == x) x = min(z, x);
cout << x << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
map<string, vector<string> > g;
unordered_set<string> vis;
int dfs(string node) {
if (vis.find(node) != vis.end()) {
return 0;
}
int tot = 1;
vis.insert(node);
for (auto to : g[node]) {
tot += dfs(to);
}
return tot;
}
int main() {
int n, maior = 0;
cin >> n;
for (int i = 0; i < n; i++) {
string s, e, foo;
cin >> s >> foo >> e;
transform(s.begin(), s.end(), s.begin(), ::tolower);
transform(e.begin(), e.end(), e.begin(), ::tolower);
g[s].emplace_back(e);
}
for (auto vertex : g) {
vis = unordered_set<string>();
maior = max(maior, dfs(vertex.first));
}
cout << maior << '\n';
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t, n, l, a, b, i, j, g;
cin >> t;
while (t--) {
g = 0;
string s1, s2;
vector<pair<char, long long int>> v1, v2;
cin >> s1 >> s2;
char c1, c2;
n = s1.size(), l = s2.size();
if (n > l) {
cout << "NO\n";
continue;
}
a = 1;
for (i = 1; i < n; i++) {
if (s1[i] == s1[i - 1]) {
a++;
} else {
v1.push_back({s1[i - 1], a});
a = 1;
}
}
v1.push_back({s1[n - 1], a});
a = 1;
for (i = 1; i < l; i++) {
if (s2[i] == s2[i - 1]) {
a++;
} else {
v2.push_back({s2[i - 1], a});
a = 1;
}
}
v2.push_back({s2[l - 1], a});
if (v1.size() != v2.size()) {
cout << "NO\n";
} else {
for (i = 0; i < v1.size(); i++) {
if (v1[i].second > v2[i].second || v1[i].first != v2[i].first) {
g = 1;
break;
}
}
if (g)
cout << "NO\n";
else
cout << "YES\n";
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 9223372036854775807;
const long long MOD = 1000000007;
const long double PI = acos(-1);
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
void solve() {
long long n;
cin >> n;
std::vector<string> arr1, arr2;
for (long long i = 0; i < n; i++) {
string s, s1;
cin >> s >> s1;
arr1.push_back(s);
arr2.push_back(s1);
}
vector<long long> permu;
for (long long i = 0; i < n; i++) {
long long temp;
cin >> temp;
permu.push_back(temp);
};
string min;
if (arr1[permu[0] - 1] > arr2[permu[0] - 1]) {
min = arr2[permu[0] - 1];
} else {
min = arr1[permu[0] - 1];
};
long long done = 1;
long long i = 1;
string tempmin;
string tempmax;
while (done < n) {
string s3 = arr1[permu[i] - 1];
string s4 = arr2[permu[i] - 1];
if (s3 > s4) {
tempmin = s4;
tempmax = s3;
} else {
tempmin = s3;
tempmax = s4;
};
if (tempmin > min) {
min = tempmin;
i++;
done++;
} else if (tempmax > min) {
min = tempmax;
i++;
done++;
;
} else {
break;
}
};
if (done == n) {
cout << "YES";
} else {
cout << "NO";
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int test;
test = 1;
while (test--) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
int p[N];
int main() {
int n, x;
cin >> n;
for (int i = 0; i < n; i++) {
scanf("%d", &x), p[x - 1] = i;
}
int ans = 1, c = 1;
for (int i = 1; i < n; i++) {
if (p[i] > p[i - 1]) {
c++;
} else
c = 1;
ans = max(c, ans);
}
cout << n - ans;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
string my[50];
long long d[1 << 20];
double dp[1 << 20];
int main() {
ios_base::sync_with_stdio(0);
int n;
cin >> n;
for (auto i = 0; i < (n); i++) cin >> my[i];
int m = ((int)my[0].size());
for (auto i = 0; i < (n); i++) {
for (auto j = 0; j < (n); j++) {
if (i == j) continue;
int mask = 0;
for (auto k = 0; k < (m); k++)
if (my[i][k] == my[j][k]) mask += (1 << k);
d[mask] |= (1ll << i);
}
}
for (int mask = (1 << m) - 1; mask >= 0; mask--) {
for (auto j = 0; j < (m); j++)
if (mask & (1 << j)) d[mask ^ (1 << j)] |= d[mask];
if (!d[mask]) continue;
double down = __builtin_popcountll(d[mask]);
for (auto j = 0; j < (m); j++) {
if (mask & (1 << j)) continue;
double up = __builtin_popcountll(d[mask | (1 << j)]);
dp[mask] += dp[mask | (1 << j)] * (up / down);
}
dp[mask] /= m - __builtin_popcount(mask);
dp[mask]++;
}
cout << fixed << setprecision(11) << dp[0] << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, i, cntr = 0;
cin >> n >> m;
bool prev = false;
for (i = 0; i < n; i++) {
if (i % 2 == 0) {
for (int j = 0; j < m; j++) cout << "#";
} else {
if (cntr % 2 != 0) cout << "#";
for (int j = 1; j < m; j++) cout << ".";
if (cntr % 2 == 0) cout << "#";
cntr++;
}
cout << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, m;
long long head[200005];
long long to[200005];
long long next1[200005];
long long val[200005];
long long cnt = 0;
void add(long long u, long long v, long long w) {
cnt++;
next1[cnt] = head[u];
head[u] = cnt;
to[cnt] = v;
val[cnt] = w;
}
long long p[70];
long long zero;
void xxj(long long x) {
if (x == 0) {
zero = 1;
return;
}
for (int i = 62; i >= 0; i--) {
if (x & (1ll * 1 << i)) {
if (!p[i]) {
p[i] = x;
break;
} else {
x ^= p[i];
}
}
}
return;
}
long long visit[200005];
long long dis[200005];
void dfs(long long now, long long sum) {
dis[now] = sum;
visit[now] = 1;
for (int i = head[now]; i; i = next1[i]) {
if (!visit[to[i]]) {
dfs(to[i], sum ^ val[i]);
} else {
xxj(sum ^ val[i] ^ dis[to[i]]);
}
}
return;
}
long long ans = 0;
void query() {
for (int i = 62; i >= 0; i--) {
ans = max(ans, ans ^ p[i]);
}
}
int main() {
cin >> n >> m;
for (int i = 1; i <= m; i++) {
long long u, v, w;
cin >> u >> v >> w;
add(u, v, w);
add(v, u, w);
}
dfs(1, 0);
ans = dis[n];
for (int i = 62; i >= 0; i--) {
ans = min(ans, ans ^ p[i]);
}
cout << ans;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, j, arr[200005], i, position[200005];
cin >> n;
for (i = 2; i <= n; i++) cin >> arr[i];
if (n == 2)
cout << "1 2" << endl;
else {
position[0] = n;
position[1] = arr[n];
if (position[1] == 1) {
cout << 1 << " " << n << endl;
return 0;
} else {
for (j = 2;; j++) {
position[j] = arr[position[j - 1]];
if (position[j] == 1) break;
}
for (i = j; i >= 0; i--) cout << position[i] << " ";
cout << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int B = 0, u = 0, l = 0, b = 0, a = 0, S = 0, A = 0, U = 0, r = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == 'B') {
B++;
}
if (s[i] == 'u') {
u++;
}
if (s[i] == 'l') {
l++;
}
if (s[i] == 'b') {
b++;
}
if (s[i] == 'a') {
a++;
}
if (s[i] == 's') {
S++;
}
if (s[i] == 'r') {
r++;
}
}
U = u / 2;
u = U;
A = a / 2;
a = A;
cout << min(B, min(u, min(l, min(b, min(a, min(S, min(A, min(U, r))))))));
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, i;
string s;
cin >> n >> s;
for (i = 0; i < n; i++) {
cout << s[i];
if ((i + 1) % 2 == 0 && i + 2 < n) cout << "-";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
const int mod = 1e9 + 7;
const int maxn = 1e3 + 5;
const double EPS = 1e-6;
using namespace std;
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
map<double, double> mmp;
int main() {
mmp.clear();
int n, i, j;
scanf("%d", &n);
long double ans = 0;
long double pre = 0;
for (i = 1; i <= n; i++) {
double num;
scanf("%lf", &num);
mmp[num]++;
ans += -pre + num * (i - 1) + mmp[num + 1] - mmp[num - 1];
pre += num;
}
cout << fixed << setprecision(0) << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int a[100] = {0, 1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1,
14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1,
51, 1, 2, 1, 14, 1, 2, 2, 14, 1, 6, 1, 4, 2, 2, 1,
52, 2, 5, 1, 5, 1, 15, 2, 13, 2, 2, 1, 13, 1, 2, 4,
267, 1, 4, 1, 5, 1, 4, 1, 50, 1, 2, 3, 4, 1, 6, 1,
52, 15, 2, 1, 15, 1, 2, 1, 12, 1, 10, 1, 4, 2};
int main() {
int n;
cin >> n;
cout << a[n];
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long K = 55;
double oblicz(double y) {
double pocz = y - 10.0, kon = y + 10.0;
for (int q = 0; q < (K); q++) {
double srod = (pocz + kon) / 2;
if (srod > y + sin(srod))
kon = srod;
else
pocz = srod;
}
return (pocz + kon) / 2;
}
double rozwiaz(double c) {
return min(oblicz(M_PI + c / 2) - oblicz(M_PI - c / 2), 2 * oblicz(c / 2));
}
void zrob_test() {
int n, r, v;
cin >> n >> r >> v;
double czynnik = double(r) / double(v);
while (n--) {
int s, f;
cin >> s >> f;
cout << rozwiaz(double(f - s) / double(r)) * czynnik << '\n';
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.setf(ios::fixed);
cout.precision(7);
zrob_test();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
const long double Eps = 1e-22;
struct Vector {
long double x, y;
Vector(long double _x = 0, long double _y = 0) : x(_x), y(_y){};
bool operator<(const Vector &_X) const {
return x < _X.x || x == _X.x && y < _X.y;
}
bool operator==(const Vector &_X) const { return x == _X.x && y == _X.y; }
Vector operator-(const Vector &_X) const {
return Vector(x - _X.x, y - _X.y);
}
} v[N];
long double cross(const Vector &a, const Vector &b) {
return a.x * b.y - a.y * b.x;
}
long double dot(const Vector &a, const Vector &b) {
return a.x * b.x + a.y * b.y;
}
int main() {
ios::sync_with_stdio(0);
map<Vector, vector<int> > id;
vector<int> ans;
int n;
cin >> n;
for (int i = 0, x, y; i < n; ++i)
cin >> x >> y, v[i] = Vector(1. / x, 1. / y), id[v[i]].push_back(i);
sort(v, v + n, [](const Vector &x, const Vector &y) -> bool {
return x.y < y.y || x.y == y.y && x.x < y.x;
});
n = unique(v, v + n) - v;
sort(v + 1, v + n, [](const Vector &x, const Vector &y) -> bool {
long double t = cross(x - v[0], y - v[0]);
return fabs(t) > Eps ? t > Eps
: dot(x - v[0], x - v[0]) > dot(y - v[0], y - v[0]);
});
int left = min_element(v, v + n) - v;
if (left == 0)
ans = id[v[0]];
else {
vector<Vector> hull;
hull.push_back(v[0]), hull.push_back(v[left]);
for (int i = left + 1; i < n; ++i) {
while (hull.size() > 2 &&
cross(hull[hull.size() - 1] - hull[hull.size() - 2],
v[i] - hull[hull.size() - 2]) < Eps)
hull.pop_back();
hull.push_back(v[i]);
}
for (int i = 0; i < (int)hull.size(); ++i)
ans.insert(ans.end(), id[hull[i]].begin(), id[hull[i]].end());
}
sort(ans.begin(), ans.end());
for (int i = 0; i < (int)ans.size(); ++i) cout << ans[i] + 1 << ' ';
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 20;
int n, m, cost[N][N], c[N][N], dp[1 << N], b[N][N];
char a[N][N];
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m;
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) cin >> a[i][j];
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) cin >> cost[i][j];
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) {
int mx = 0;
for (int k = 0; k < n; ++k)
if (a[i][j] == a[k][j]) {
b[i][j] |= (1 << k);
c[i][j] += cost[k][j];
mx = max(mx, cost[k][j]);
}
c[i][j] -= mx;
}
for (int mask = 0; mask < (1 << n); ++mask) dp[mask] = (int)1e9;
dp[0] = 0;
for (int mask = 0; mask < (1 << n); ++mask) {
int bit = 0;
for (int i = 0; i < n; ++i)
if ((1 << i) & mask)
;
else {
bit = i;
break;
}
for (int i = 0; i < m; ++i) {
dp[mask | (1 << bit)] =
min(dp[mask | (1 << bit)], dp[mask] + cost[bit][i]);
dp[mask | b[bit][i]] = min(dp[mask | b[bit][i]], dp[mask] + c[bit][i]);
}
}
cout << dp[(1 << n) - 1];
}
| 8 |
#include <bits/stdc++.h>
using ll = long long;
using namespace std;
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(15);
int T;
cin >> T;
for (ll _ = 0, _Len = (T); _ < _Len; ++_) {
ll n, k;
cin >> n >> k;
vector<ll> a(n);
for (ll i = 0, iLen = (n); i < iLen; ++i) cin >> a[i];
sort(a.begin(), a.end());
ll dist = 1LL << 60, ans = -1;
for (ll r = k, rLen = (n); r < rLen; ++r) {
if (a[r] - a[r - k] < dist) {
dist = a[r] - a[r - k];
ans = (a[r] + a[r - k]) >> 1;
}
}
cout << ans << "\n";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void print(T a) {
for (auto x : a) cout << x << ' ';
cout << endl;
}
bool solve(vector<pair<int, int> > a, vector<pair<int, int> > b) {
int n = (int)(a).size();
multiset<int> begs, ends;
vector<vector<int> > v;
for (int i = 0; i < n; i++) {
v.push_back({a[i].first, 1, b[i].first, b[i].second});
v.push_back({a[i].second + 1, 0, b[i].first, b[i].second});
}
sort((v).begin(), (v).end());
for (int i = 0; i < n * 2; i++) {
vector<int> cur = v[i];
if (cur[1] == 0) {
begs.erase(begs.find(cur[2]));
ends.erase(ends.find(cur[3]));
} else {
if ((int)(begs).size() == 0) {
begs.insert(cur[2]);
ends.insert(cur[3]);
continue;
}
int leftmost_end = *(ends.begin());
int rightmost_beg = *(begs.rbegin());
if ((leftmost_end < cur[2]) || (rightmost_beg > cur[3])) {
return false;
} else {
begs.insert(cur[2]);
ends.insert(cur[3]);
}
}
}
return true;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<pair<int, int> > a(n), b(n);
for (int i = 0; i < n; i++) {
cin >> a[i].first >> a[i].second >> b[i].first >> b[i].second;
}
bool ans1 = solve(a, b);
bool ans2 = solve(b, a);
cout << ((ans1 && ans2) ? "YES" : "NO");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int NN = 200005;
pair<pair<long long, long long>, int> a[NN];
multiset<pair<long long, int> > S;
int n, m;
vector<int> res;
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m;
if (m < n - 1) {
cout << "No\n";
return 0;
}
long long l1, r1, l2, r2, len;
cin >> l1 >> r1;
for (int i = 1; i < n; i++) {
cin >> l2 >> r2;
a[i] = make_pair(make_pair(r2 - l1, l2 - r1), i);
l1 = l2, r1 = r2;
}
sort(a + 1, a + n);
for (int i = 1; i <= m; i++) {
cin >> len;
S.insert(make_pair(len, i));
}
multiset<pair<long long, int> >::iterator it;
res.resize(n);
for (int i = 1; i < n; i++) {
it = S.lower_bound(make_pair(a[i].first.second, 0));
if (it == S.end() || it->first > a[i].first.first) {
cout << "No\n";
return 0;
}
res[a[i].second] = it->second;
S.erase(it);
}
cout << "Yes\n";
for (int i = 1; i < n; i++) cout << res[i] << ' ';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int sc = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') sc = sc * 10 + ch - '0', ch = getchar();
return sc * f;
}
const int MAXN = 500005;
int n, m, a[MAXN], b[MAXN];
priority_queue<long long> q1, q2;
long long ans;
int main() {
n = read(), m = read();
for (int i = 1; i <= n; i++) a[i] = read();
for (int i = 1; i <= n; i++) b[i] = read();
int l = 0, r = 0x3f3f3f3f, ret;
while (l <= r) {
int mid = l + r >> 1, l_cnt = 0, r_cnt = 0;
ans = 0;
while (!q1.empty()) q1.pop();
while (!q2.empty()) q2.pop();
q2.push(-1e18);
for (int i = 1; i <= n; i++) {
q1.push(mid - a[i]);
long long v1 = b[i] - mid - q1.top(), v2 = b[i] - mid - q2.top();
if (v1 < v2 && v1 < 0)
ans += v1, l_cnt++, q1.pop(), q2.push(b[i] - mid);
else if (v2 <= v1 && v2 < 0)
ans += v2, q2.pop(), q2.push(b[i] - mid);
}
while (!q1.empty()) q1.pop();
while (!q2.empty()) q2.pop();
q2.push(-1e18);
for (int i = 1; i <= n; i++) {
q1.push(mid - a[i]);
long long v1 = b[i] - mid - q1.top(), v2 = b[i] - mid - q2.top();
if (v1 <= v2 && v1 <= 0)
r_cnt++, q1.pop(), q2.push(b[i] - mid);
else if (v2 < v1 && v2 <= 0)
q2.pop(), q2.push(b[i] - mid);
}
if (l_cnt <= m && r_cnt >= m)
return printf("%lld\n", ans + 2LL * m * mid), 0;
if (r_cnt < m)
l = mid + 1;
else
r = mid - 1;
}
}
| 10 |
#include <bits/stdc++.h>
#pragma GCC optimize "-O3"
using namespace std;
const int MAXN = 1200;
const int INF = 1e6;
int n;
string s[MAXN];
int v[MAXN];
vector<pair<string, int>> rq1[MAXN];
vector<int> rq[MAXN];
set<tuple<int, int, int>> ss;
map<pair<string, int>, int> mm;
set<string> in;
vector<pair<string, int>> ans;
int dd[MAXN];
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> s[i] >> v[i];
int k;
cin >> k;
for (int j = 0; j < k; ++j) {
string a;
int b;
cin >> a >> b;
rq1[i].push_back({a, b});
}
}
for (int i = 0; i < n; ++i) {
mm[{s[i], v[i]}] = i;
}
for (int i = 0; i < n; ++i) {
for (auto x : rq1[i]) rq[i].emplace_back(mm[{x.first, x.second}]);
}
fill(dd, dd + n, INF);
dd[0] = 0;
ss.insert({0, -v[0], 0});
while (!ss.empty()) {
int x = get<2>(*ss.begin());
ss.erase(ss.begin());
if (in.count(s[x])) continue;
if (x != 0) ans.push_back({s[x], v[x]});
in.insert(s[x]);
for (int y : rq[x]) {
if (dd[y] > dd[x] + 1) {
ss.erase({dd[y], -v[y], y});
dd[y] = dd[x] + 1;
ss.insert({dd[y], -v[y], y});
}
}
}
sort(ans.begin(), ans.end());
cout << ans.size() << "\n";
for (auto x : ans) cout << x.first << " " << x.second << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n1, n2, k1, k2;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n1 >> n2 >> k1 >> k2;
if (n1 > n2)
cout << "First" << endl;
else
cout << "Second" << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
long long n;
cin >> n;
long long k[n];
long long curst = 1, curval = -1;
for (long long i = 0; i < n; i++) {
if (curst == i + 1) {
curval++;
curst *= 2;
}
k[i] = curval;
}
cerr << "k : \n";
for (long long i = 0; i < n; i++) {
cerr << k[i] << ' ';
}
cerr << endl;
long long a[n];
long long num;
for (long long i = 0; i < n; i++) {
cin >> a[i];
if (a[i] == -1) num = i;
}
multiset<long long> s;
long long it = n - 1;
long long ans = 0;
for (long long i = curval; i > k[num]; i--) {
while (k[it] == i) {
s.insert(a[it]);
it--;
}
ans += *(s.begin());
s.erase(s.begin());
}
cout << ans;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int cnt = 0;
int len = s.length();
for (int i = 0; i < len; i++) {
if (s.at(i) == 'a') cnt++;
}
int ltr = len - cnt;
while (ltr >= cnt) {
ltr--;
len--;
}
cout << len;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 2e9 + 7;
const long long linf = 1e18 + 7;
long long a[200007];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int i = 0, j = n - 1;
long long ans = 0;
long long s1 = 0, s2 = 0;
while (i <= j) {
s1 += a[i];
i++;
if (s1 == s2) {
ans = max(ans, s1);
}
if (i > j) {
break;
}
while (i <= j && s2 < s1) {
s2 += a[j];
j--;
}
if (s1 == s2) {
ans = max(ans, s1);
}
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn(2e5 + 5);
const long long inf(1e16 + 5);
int head[maxn], node[maxn << 1], net[maxn << 1], n;
long long val[maxn];
long long mx1[maxn], mx2[maxn], subMax[maxn];
void dfs(int k, int fa) {
int nmd = 0;
for (int i = head[k]; i; i = net[i]) {
if (node[i] == fa) continue;
dfs(node[i], k);
val[k] += val[node[i]], nmd++;
subMax[k] = max(subMax[node[i]], subMax[k]);
}
mx1[k] = mx2[k] = -inf;
subMax[k] = val[k];
if (nmd > 1) {
long long temp;
for (int i = head[k]; i; i = net[i]) {
if (node[i] == fa) continue;
temp = subMax[node[i]];
if (temp > mx1[k])
mx2[k] = mx1[k], mx1[k] = temp;
else if (temp > mx2[k])
mx2[k] = temp;
}
subMax[k] = max(subMax[k], mx1[k]);
for (int i = head[k]; i; i = net[i])
if (node[i] != fa && mx1[node[i]] + mx2[node[i]] > mx2[k] + mx1[k])
mx1[k] = mx1[node[i]], mx2[k] = mx2[node[i]];
} else if (nmd == 1) {
int i = head[k];
if (node[i] == fa) i = net[i];
mx1[k] = mx1[node[i]], mx2[k] = mx2[node[i]];
subMax[k] = max(subMax[k], subMax[node[i]]);
}
}
int main() {
while (~scanf("%d", &n)) {
memset(head, 0, sizeof(head));
for (int i = 1; i <= n; i++) scanf("%I64d", val + i);
for (int i = 1, j = 1, a, b; j < n; j++) {
scanf("%d%d", &a, &b);
node[i] = b, net[i] = head[a], head[a] = i++;
node[i] = a, net[i] = head[b], head[b] = i++;
}
dfs(1, -1);
if (mx1[1] != -inf && mx2[1] != inf)
printf("%I64d\n", mx1[1] + mx2[1]);
else
puts("Impossible");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long comb(long long n, long long r) {
if (r < n - r) r = n - r;
long long p = 1;
for (long long i = 0; i < n - r; i++) p = p *= n - i, p /= (i + 1);
return p;
}
int main() {
int n;
cin >> n;
map<int, int> m;
string s;
for (int i = 0; i < n; i++) {
cin >> s;
int val = 0;
int f = 0, g = 0;
int c1 = 0, c2 = 0;
int ind = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '(')
c1++;
else
c2++;
if (c1 < c2) {
f = 1;
break;
}
}
c1 = 0, c2 = 0;
for (int i = s.size() - 1; i >= 0; i--) {
if (s[i] == '(')
c1++;
else
c2++;
if (c1 > c2) {
g = 1;
break;
}
}
for (int i = 0; i < s.size(); i++) {
if (s[i] == '(')
val--;
else
val++;
}
if ((g == 1 && f == 1))
continue;
else
m[val]++;
}
int ans = 0;
for (auto i = m.begin(); i != m.end(); i++) {
auto val = i->first;
if (m[val] > 0 && m[-1 * val] > 0) {
if (val == 0) {
ans += m[val] / 2;
m[val] = 0;
} else {
ans += min(m[val], m[-1 * val]);
m[val] = 0;
}
}
}
cout << ans;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void chkmax(T &x, T y) {
x = max(x, y);
}
template <typename T>
void chkmin(T &x, T y) {
x = min(x, y);
}
template <typename T>
void read(T &x) {
x = 0;
int f = 1;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -f;
for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
x *= f;
}
const int N = 2e5 + 10;
int a[N];
map<int, long long> mp;
signed main() {
int _;
read(_);
while (_--) {
mp.clear();
int n;
read(n);
long long s = 0, ans = 0;
for (int i = (1); i <= (n); i++) read(a[i]), s += a[i], mp[a[i]]++;
if (s * 2 % n != 0) {
puts("0");
continue;
}
long long mid = s * 2 / n;
for (int i = (1); i <= (n); i++)
if (a[i] < mid - a[i]) ans += mp[mid - a[i]];
if (mid % 2 == 0) ans += mp[mid / 2] * (mp[mid / 2] - 1) / 2;
cout << ans << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long n, m;
long long MOD = 1000000007;
long long aaa, bbb;
long long nhat[1000009];
long long mpow[1000009];
long long modinv(long long szam) {
long long hatvany = MOD - 2;
long long A = szam;
long long res = 1;
while (hatvany > 0) {
if (hatvany % 2) {
res *= A;
res %= MOD;
}
A *= A;
A %= MOD;
hatvany /= 2;
}
return res;
}
long long fact[1000009];
long long factinv[1000009];
long long nck[1000009];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
cin >> aaa >> bbb;
fact[0] = 1;
factinv[0] = 1;
mpow[0] = 1;
for (long long i = 1; i <= max(n, m) + 2; i++) {
fact[i] = (fact[i - 1] * i) % MOD;
factinv[i] = (factinv[i - 1] * modinv(i)) % MOD;
mpow[i] = (mpow[i - 1] * m) % MOD;
}
nhat[0] = 1;
for (int i = 1; i <= n + 2; i++) {
nhat[i] = (nhat[i - 1] * n) % MOD;
}
nck[0] = 1;
for (int i = 1; i < m; i++) {
nck[i] = (fact[m - 1] * factinv[i]) % MOD;
nck[i] = (nck[i] * factinv[m - i - 1]) % MOD;
}
long long ans = (nck[n - 2] * fact[n - 2]) % MOD;
for (long long l = 2; l < n; l++) {
long long crt = (l * nhat[n - l - 1]) % MOD;
crt = (crt * mpow[n - l]) % MOD;
crt = (crt * nck[l - 2]) % MOD;
crt = (crt * fact[n - 2]) % MOD;
crt = (crt * factinv[n - l]) % MOD;
ans = (ans + crt) % MOD;
}
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 10000, INF = 1e8;
int N1, N2, M;
int A[MAXN], B[MAXN];
struct edge {
int v;
int flow, cap;
int rev, id;
};
int lev[MAXN], start[MAXN];
vector<edge> adj[MAXN];
int deg[MAXN];
void addedge(int u, int v, int c, int i) {
edge euv = {v, 0, c, int(adj[v].size()), i};
edge evu = {u, 0, 0, int(adj[u].size()), i};
adj[u].push_back(euv);
adj[v].push_back(evu);
}
bool dinic_bfs(int src, int dest, int *dist) {
for (int i = 0; i <= N1 + N2 + 1; i++) {
dist[i] = -1;
}
dist[src] = 0;
queue<int> que;
que.push(src);
while (!que.empty()) {
int u = que.front();
que.pop();
for (edge e : adj[u]) {
if (dist[e.v] < 0 && e.flow < e.cap) {
dist[e.v] = dist[u] + 1;
que.push(e.v);
}
}
}
return dist[dest] >= 0;
}
int dinic_dfs(int *ptr, int *dist, int dest, int u, int f) {
if (u == dest) {
return f;
}
for (; ptr[u] < adj[u].size(); ptr[u]++) {
edge &e = adj[u][ptr[u]];
if (dist[e.v] == dist[u] + 1 && e.flow < e.cap) {
int df = dinic_dfs(ptr, dist, dest, e.v, min(f, e.cap - e.flow));
if (df > 0) {
e.flow += df;
adj[e.v][e.rev].flow -= df;
return df;
}
}
}
return 0;
}
int dist[MAXN];
int ptr[MAXN];
int maxflow(int src, int dest) {
int flow = 0;
for (int i = 0; i <= N1 + N2 + 1; i++) {
dist[i] = 0;
}
while (dinic_bfs(src, dest, dist)) {
for (int i = 0; i <= N1 + N2 + 1; i++) {
ptr[i] = 0;
}
while (true) {
int df = dinic_dfs(ptr, dist, dest, src, INF);
if (df == 0) {
break;
}
flow += df;
}
}
return flow;
}
vector<int> go(int d) {
for (int i = 0; i <= N1 + N2 + 1; i++) {
adj[i].clear();
}
for (int i = 1; i <= N1; i++) {
addedge(0, i, deg[i] - d, -1);
}
for (int i = N1 + 1; i <= N1 + N2; i++) {
addedge(i, N1 + N2 + 1, deg[i] - d, -1);
}
for (int i = 1; i <= M; i++) {
addedge(A[i], B[i], 1, i);
}
maxflow(0, N1 + N2 + 1);
vector<int> ans;
for (int i = 1; i <= N1; i++) {
for (edge e : adj[i]) {
if (N1 + 1 <= e.v && e.v <= N1 + N2 && !e.flow) {
ans.push_back(e.id);
}
}
}
return ans;
}
int main() {
scanf("%d %d %d", &N1, &N2, &M);
for (int i = 1; i <= M; i++) {
scanf("%d %d", &A[i], &B[i]);
B[i] += N1;
deg[A[i]]++;
deg[B[i]]++;
}
int mndeg = *min_element(deg + 1, deg + N1 + N2 + 1);
for (int i = 0; i <= mndeg; i++) {
vector<int> ans = go(i);
printf("%lu", ans.size());
for (int x : ans) {
printf(" %d", x);
}
puts("");
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2005;
int n, ans[N];
struct SAT {
inline int get(int x) { return x > 0 ? x * 2 - 2 : -x * 2 - 1; }
int m;
bitset<N> a[N];
void read() {
int t1, t2;
for (int i = 1; i <= m; i++) {
cin >> t1 >> t2;
t1 = get(t1);
t2 = get(t2);
a[t1 ^ 1].set(t2);
a[t2 ^ 1].set(t1);
}
}
void floyd() {
for (int i = 0; i < n * 2; i++)
for (int j = 0; j < n * 2; j++)
if (a[j][i]) a[j] |= a[i];
}
void solve() {
floyd();
for (int i = 0; i < n * 2; i++)
if (a[i][i ^ 1])
for (int j = 0; j < n * 2; j++) a[i].set(j), a[j].set(i ^ 1);
floyd();
}
void dfs(int pos) {
if (ans[pos] != -1) return;
ans[pos] = 1;
ans[pos ^ 1] = 0;
for (int i = 0; i < n * 2; i++)
if (a[pos][i]) ans[i] = 1, ans[i ^ 1] = 0;
}
void calc(int x, int y) {
dfs(x);
dfs(y ^ 1);
for (int i = 0; i < n * 2; i++)
if (ans[i] == -1 && !a[i][i ^ 1]) dfs(i);
}
} f, g;
int main() {
ios::sync_with_stdio(false);
cin >> n >> f.m >> g.m;
f.read();
f.solve();
g.read();
g.solve();
memset(ans, -1, sizeof(ans));
for (int i = 0; i < n * 2; i++)
for (int j = 0; j < n * 2; j++)
if (i != j && f.a[i][j] != g.a[i][j]) {
if (f.a[i][j])
g.calc(i, j);
else
f.calc(i, j);
for (int k = 0; k < n; k++) cout << ans[k * 2] << ' ';
cout << endl;
return 0;
}
cout << "SIMILAR" << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
void fast_io() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
}
void file_io(string taskname) {
string fin = taskname + ".in";
string fout = taskname + ".out";
const char* FIN = fin.c_str();
const char* FOUT = fout.c_str();
freopen(FIN, "r", stdin);
freopen(FOUT, "w", stdout);
fast_io();
}
template <typename A, typename B>
ostream& operator<<(ostream& cout, pair<A, B> const& p) {
return cout << "(" << p.first << ", " << p.second << ")";
}
template <typename A>
ostream& operator<<(ostream& cout, vector<A> const& v) {
cout << "[";
for (int i = 0; i < v.size(); i++) {
if (i) cout << ", ";
cout << v[i];
}
return cout << "]";
}
long long gcd(long long a, long long b) {
if (b > a) {
return gcd(b, a);
}
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return a * b / gcd(a, b); }
int main() {
fast_io();
int t;
cin >> t;
for (int query = 0; query < t; query++) {
int n;
cin >> n;
vector<long long> p(n);
for (int i = 0; i < n; i++) {
cin >> p[i];
}
sort(p.begin(), p.end(), [](long long a, long long b) { return a > b; });
long long x, a, y, b;
long long k;
cin >> x >> a >> y >> b >> k;
if (y > x) {
swap(x, y);
swap(a, b);
}
int count = 0;
double total = 0.0;
for (int i = 0; i < n / (lcm(a, b)); i++) {
total += ((long long)x + y) * (p[count] / 100.0);
count++;
}
for (int i = 0; i < n / a - n / (lcm(a, b)); i++) {
total += (long long)x * (p[count] / 100.0);
count++;
}
for (int i = 0; i < n / b - n / (lcm(a, b)); i++) {
total += (long long)y * (p[count] / 100.0);
count++;
}
if (total < (double)k) {
cout << "-1\n";
continue;
}
int l = 0, r = n;
while (l + 1 < r) {
int m = (l + r) / 2;
int count = 0;
double total = 0.0;
for (int i = 0; i < m / (lcm(a, b)); i++) {
total += ((long long)x + y) * (p[count] / 100.0);
count++;
}
for (int i = 0; i < m / a - m / (lcm(a, b)); i++) {
total += (long long)x * (p[count] / 100.0);
count++;
}
for (int i = 0; i < m / b - m / (lcm(a, b)); i++) {
total += (long long)y * (p[count] / 100.0);
count++;
}
if (total < (double)k) {
l = m;
} else {
r = m;
}
}
cout << r << "\n";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n, k;
char s[N];
char ch[N];
int g;
int main() {
scanf("%d%d", &n, &k);
scanf("%s", s + 1);
char mx = s[1];
for (int i = 1; i <= n; ++i) mx = max(mx, s[i]);
if (k <= n) {
for (g = 1; g < k; ++g) ch[g] = s[g];
g = k - 1;
if (s[k] == mx) {
int j = k - 1;
while (s[j] == mx) j--;
char x = s[j];
sort(s + 1, s + 1 + n);
for (int i = 1; i <= n; ++i)
if (s[i] > x) {
x = s[i];
break;
}
g = j;
ch[g] = x;
g++;
for (; g <= k; ++g) ch[g] = s[1];
printf("%s", ch + 1);
return 0;
}
char x = s[k];
sort(s + 1, s + 1 + n);
for (int i = 1; i <= n; ++i)
if (s[i] > x) {
x = s[i];
break;
}
ch[++g] = x;
printf("%s", ch + 1);
return 0;
}
if (k > n) {
for (g = 1; g <= n; ++g) ch[g] = s[g];
g = n;
sort(s + 1, s + 1 + n);
char x = s[1];
for (g = n + 1; g <= k; ++g) ch[g] = x;
printf("%s", ch + 1);
return 0;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, t;
cin >> n >> t;
if (n == 1 && t == 10)
cout << -1;
else {
cout << t;
if (t == 10) n--;
for (int i = n - 1; i > 0; --i) cout << 0;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
vector<pair<int, int> > v;
int n, br = 0, maks = -1, mingod = 1000000000;
cin >> n;
int a, b;
for (int i = 0; i < n; i++) {
cin >> a >> b;
v.push_back(make_pair(a, +1));
v.push_back(make_pair(b, -1));
}
sort(v.begin(), v.end());
for (int i = 0; i < 2 * n; i++) {
if (v[i].first != v[i - 1].first) {
if (br > maks) {
maks = br;
mingod = v[i - 1].first;
}
}
if (v[i].second == +1) br++;
if (v[i].second == -1) br--;
}
cout << mingod << " " << maks << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100 + 5;
long long mp[maxn][maxn];
long long a[maxn], b[maxn];
int main() {
ios::sync_with_stdio(0);
int n, m;
cin >> n >> m;
long long a1 = 0, a2 = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
a1 ^= a[i];
mp[i][0] = a[i];
}
for (int i = 0; i < m; i++) {
cin >> b[i];
a2 ^= b[i];
mp[0][i] = b[i];
}
if (a1 != a2)
cout << "NO\n";
else {
cout << "YES\n";
mp[0][0] = a1 ^ a[0] ^ b[0];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cout << mp[i][j];
if (j == m - 1)
cout << endl;
else
cout << " ";
}
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long int N = 5e5 + 5;
const long long int M = 1e6 + 5;
const long long int mod = 1e9 + 7;
const long long int m1 = 1e9 + 7;
const long long int m2 = 1e9 + 9;
const long long int p1 = 402653189;
const long long int p2 = 1610612741;
const int LN = 32;
long long int powermodm(long long int x, long long int n, long long int M) {
long long int result = 1;
while (n > 0) {
if (n % 2 == 1) result = (result * x) % M;
x = (x * x) % M;
n = n / 2;
}
return result;
}
long long int power(long long int _a, long long int _b) {
long long int _r = 1;
while (_b) {
if (_b % 2 == 1) _r = (_r * _a);
_b /= 2;
_a = (_a * _a);
}
return _r;
}
long long int gcd(long long int a, long long int b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long int lcm(long long int a, long long int b) {
return (max(a, b) / gcd(a, b)) * min(a, b);
}
long long int dx[4] = {-1, 1, 0, 0};
long long int dy[4] = {0, 0, 1, -1};
long long int pw[LN], fact[N], invfact[N];
void pre() {
fact[0] = 1;
for (int i = 0; i < LN; i++) pw[i] = power(2, i);
for (int i = 1; i < N; i++) fact[i] = (i * fact[i - 1]) % mod;
for (int i = 0; i < N; i++) invfact[i] = powermodm(fact[i], mod - 2, mod);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long int i, j;
long long int n, p, q, r;
cin >> n >> p >> q >> r;
long long int a[n + 2], dp_pre[n + 2], dp_suf[n + 2];
for (i = 1; i <= n; i++) cin >> a[i];
for (i = 0; i <= n + 1; i++) {
dp_pre[i] = dp_suf[i] = -LONG_LONG_MAX;
}
for (i = 1; i <= n; i++) {
dp_pre[i] = max(dp_pre[i - 1], p * a[i]);
}
for (i = n; i >= 1; i--) {
dp_suf[i] = max(dp_suf[i + 1], r * a[i]);
}
long long int ans = -LONG_LONG_MAX;
for (i = 1; i <= n; i++) {
long long int tans = q * a[i] + dp_pre[i] + dp_suf[i];
ans = max(ans, tans);
}
printf("%lld\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
const int mod = 1e9 + 7;
void solve() {
long long n, m, i, j, k, l, r, p, x, y, z, a, b, c;
string s;
cin >> s;
cin >> k;
vector<string> v;
for (i = 0; i < k; i++) {
string ss;
cin >> ss;
v.push_back(ss);
}
long long ans = 0;
n = s.size();
for (i = 0; i < k; i++) {
for (j = 0; j < n;) {
if (s[j] == v[i][0] || s[j] == v[i][1]) {
int cnt1 = 0, cnt2 = 0;
while (j < n) {
if (s[j] != v[i][0] && s[j] != v[i][1]) {
break;
}
if (s[j] == v[i][0]) {
cnt1++;
} else {
cnt2++;
}
j++;
}
if (cnt1 > cnt2) {
ans += cnt2;
} else
ans += cnt1;
} else
j++;
}
}
cout << ans << "\n";
}
int main() {
int t;
solve();
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class node>
struct link_cut_tree {
bool connected(node* u, node* v) { return lca(u, v) != NULL; }
int depth(node* u) {
access(u);
return get_sz(u->ch[0]);
}
node* get_root(node* u) {
access(u);
while (u->ch[0]) u = u->ch[0], u->push();
return access(u), u;
}
node* ancestor(node* u, int k) {
k = depth(u) - k;
assert(k >= 0);
for (;; u->push()) {
int sz = get_sz(u->ch[0]);
if (sz == k) return access(u), u;
if (sz < k)
k -= sz + 1, u = u->ch[1];
else
u = u->ch[0];
}
assert(0);
}
node* lca(node* u, node* v) {
if (u == v) return u;
access(u);
access(v);
if (!u->p) return NULL;
u->splay();
return u->p ?: u;
}
void link(node* u, node* v) {
assert(!connected(u, v));
make_root(v);
access(u);
set_link(v, u, 0);
v->update();
}
void cut(node* u) {
access(u);
u->ch[0]->p = NULL;
u->ch[0] = NULL;
u->update();
}
void cut(node* u, node* v) { cut(depth(u) > depth(v) ? u : v); }
void make_root(node* u) {
access(u);
u->rev ^= 1;
access(u);
assert(!u->ch[0] && !u->ch[1]);
}
void access(node* u) {
for (node *v = u, *pre = NULL; v; v = v->p) {
v->splay();
if (pre) v->update_vsub(pre, false);
if (v->ch[1]) v->update_vsub(v->ch[1], true);
v->ch[1] = pre;
v->update();
pre = v;
}
u->splay();
assert(!u->ch[1]);
}
node* operator[](int i) { return &data[i]; }
int operator[](node* i) { return i - &data[0]; }
vector<node> data;
link_cut_tree(int n) : data(n) {}
};
template <typename pnode>
struct splay_tree {
pnode ch[2], p;
bool rev;
int sz;
splay_tree() {
ch[0] = ch[1] = p = NULL;
rev = 0;
sz = 1;
}
friend int get_sz(pnode u) { return u ? u->sz : 0; }
virtual void update() {
if (ch[0]) ch[0]->push();
if (ch[1]) ch[1]->push();
sz = 1 + get_sz(ch[0]) + get_sz(ch[1]);
}
virtual void push() {
if (rev) {
if (ch[0]) ch[0]->rev ^= 1;
if (ch[1]) ch[1]->rev ^= 1;
swap(ch[0], ch[1]);
rev = 0;
}
}
int dir() {
if (!p) return -2;
if (p->ch[0] == this) return 0;
if (p->ch[1] == this) return 1;
return -1;
}
bool is_root() { return dir() < 0; }
friend void set_link(pnode u, pnode v, int d) {
if (v) v->p = u;
if (d >= 0) u->ch[d] = v;
}
void rotate() {
assert(!is_root());
int x = dir();
pnode g = p;
set_link(g->p, static_cast<pnode>(this), g->dir());
set_link(g, ch[x ^ 1], x);
set_link(static_cast<pnode>(this), g, x ^ 1);
g->update();
update();
}
void splay() {
while (!is_root() && !p->is_root()) {
p->p->push(), p->push(), push();
dir() == p->dir() ? p->rotate() : rotate();
rotate();
}
if (!is_root()) p->push(), push(), rotate();
push();
}
};
struct node;
node* root;
bool capture;
vector<pair<int, int>> vec;
struct node : splay_tree<node*> {
using splay_tree::ch;
int val, lazy;
node() : splay_tree() {
val = -1e9;
lazy = -1;
}
void update() override { splay_tree::update(); }
void update_vsub(node* v, bool add) {
if (!add && capture) vec.push_back({this - root, val});
}
void push() override {
splay_tree::push();
if (lazy != -1) {
val = lazy;
if (ch[0]) ch[0]->lazy = lazy;
if (ch[1]) ch[1]->lazy = lazy;
lazy = -1;
}
}
};
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
int n, m;
cin >> n >> m;
vector<vector<pair<int, int>>> adj(n);
for (int i = 1, u, v, w; i < n; ++i) {
cin >> u >> v >> w;
--u, --v;
adj[u].push_back({v, w});
}
vector<long long> dist(n);
vec.reserve(n);
link_cut_tree<node> lct(n);
function<void(int)> dfs_access = [&](int u) {
for (auto v : adj[u]) {
dist[v.first] = dist[u] + v.second;
lct.link(lct[u], lct[v.first]);
dfs_access(v.first);
}
};
dfs_access(0);
root = lct[0];
vector<pair<long long, long long>> s;
for (int i = 0, d, t; i < m; ++i) {
cin >> d >> t;
--d;
auto u = lct[d], v = u;
while (!v->is_root()) v = v->p, v->push();
while (v->ch[1]) v = v->ch[1], v->push();
vec.clear();
capture = true;
lct.access(u);
capture = false;
for (auto x : vec)
s.push_back({dist[x.first] + x.second, dist[x.first] + t});
int val = u->val;
u->lazy = t;
u->push();
u->val = val;
lct.access(v);
}
long long explosion = -1, changes = s.size();
sort(s.begin(), s.end());
priority_queue<long long, vector<long long>, greater<long long>> pq;
for (long long t = 1, i = 0; i < s.size() || !pq.empty();) {
if (pq.empty() && t <= s[i].first) t = s[i].first + 1;
while (i < s.size() && s[i].first < t) pq.push(s[i].second), ++i;
if (t > pq.top()) {
explosion = t - 1;
break;
}
pq.pop();
++t;
}
if (explosion != -1)
changes -= count_if(s.begin(), s.end(), [&](pair<long long, long long> x) {
return x.second >= explosion;
});
cout << explosion << " " << changes << "\n";
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int v[100001], s[100001];
int a, b, x, y, k = 0, t = 0, a4 = 0, a7 = 0, b4 = 0, b7 = 0, i, j = 0, nr = 0,
h;
char c;
int main() {
c = cin.get();
while (c != '\n') {
v[++t] = c - '0';
if (v[t] == 4) a4++;
c = cin.get();
}
for (i = 1; i <= t; i++) {
cin >> c;
s[++k] = c - '0';
if (s[k] == 4) b4++;
}
if (a4 != b4) j = max(a4, b4) - min(a4, b4);
h = j;
for (i = 1; i <= t; i++) {
if (v[i] != s[i] && h > 0) {
v[i] = s[i];
h--;
}
}
for (i = 1; i <= t; i++) {
if (v[i] != s[i]) nr++;
}
cout << j - h + nr / 2;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
char a[9][9];
int main() {
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 8; j++) {
cin >> a[i][j];
}
}
int minA = 10;
int minB = 10;
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 8; j++) {
if (a[j][i] == 'B') {
break;
}
if (a[j][i] == 'W') {
minA = min(minA, j);
break;
}
}
for (int j = 7; j >= 0; j--) {
if (a[j][i] == 'W') {
break;
}
if (a[j][i] == 'B') {
minB = min(minB, 7 - j);
}
}
}
if (minA <= minB) {
cout << "A";
} else {
cout << "B";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
long long ans = 0;
int step = 1;
for (int i = 1; i <= M; ++i) {
int T;
cin >> T;
if (T >= step) {
ans += T - step;
} else {
ans += N - step + T;
}
step = T;
}
cout << ans << "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> x, f;
long long ans = 0;
int main() {
long long a, b, l, r, c = 1;
cin >> a >> b >> l >> r;
f.push_back(1);
for (int i = 0; c <= r / a && c * i != 1; i++) c *= a, f.push_back(c);
c = 1;
for (int j = 0; j < f.size(); j++) x.push_back(c + f[j]);
for (int i = 0; c <= r / b && c * i != 1; i++) {
c *= b;
for (int j = 0; j < f.size(); j++) x.push_back(c + f[j]);
}
sort(x.begin(), x.end());
for (int i = 1; i < x.size(); i++)
if (x[i] >= l && x[i] <= r && x[i - 1] >= l && x[i - 1] <= r)
ans = max(ans, x[i] - x[i - 1] - 1);
for (int i = 0; i < x.size(); i++)
if (x[i] == l)
break;
else if (x[i] > l) {
if (x[i] <= r)
ans = max(ans, x[i] - l);
else
ans = max(ans, r - l + 1);
break;
}
for (int i = x.size() - 1; i >= 0; i--)
if (x[i] == r)
break;
else if (x[i] < r) {
if (x[i] >= l)
ans = max(ans, r - x[i]);
else
ans = max(ans, r - l + 1);
break;
}
cout << ans << endl;
}
| 5 |
#include <bits/stdc++.h>
int main() {
int l, ct = 0, i;
char s[1000];
scanf("%s", s);
l = strlen(s);
for (i = 0; i < l; i++) {
if (s[i] == '4' || s[i] == '7') {
ct++;
}
}
if (ct == 4 || ct == 7)
printf("YES");
else
printf("NO");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e9;
const int mod = (int)1e9 + 7;
int n, p;
int a[100100], b[100100];
long long getTotal() {
long long sum = 0;
for (int i = 0; i < n; i++) sum += a[i];
return sum;
}
bool check(double t) {
double sum = 0.0;
for (int i = 0; i < n; i++) {
double A = b[i] - a[i] * t;
if (A < 0) sum += abs(A);
}
return sum / p < t;
}
int main() {
scanf("%d%d", &n, &p);
for (int i = 0; i < n; i++) {
scanf("%d%d", &a[i], &b[i]);
}
if (p >= getTotal()) {
cout << -1 << endl;
return 0;
}
double l = 0, r = 1e18;
for (int iter = 0; iter < 1000; iter++) {
double mid = (l + r) / 2;
if (check(mid)) {
l = mid;
} else {
r = mid;
}
}
printf("%.10f\n", l);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<bool> u;
vector<int> p;
vector<vector<int> > g;
vector<bool> leaves;
vector<int> d;
void dfs(int v, int _p = -1) {
p[v] = _p;
if (_p == -1) {
d[v] = 0;
} else {
d[v] = d[_p] + 1;
}
bool children = false;
u[v] = true;
for (auto e : g[v]) {
if (!u[e]) {
children = true;
dfs(e, v);
}
}
if (!children) {
leaves[v] = true;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m, k;
cin >> n >> m >> k;
g.resize(n);
u.assign(n, false);
leaves.assign(n, false);
p.assign(n, -1);
d.assign(n, 0);
for (int i = 0; i < m; ++i) {
int u, v;
cin >> u >> v;
--u;
--v;
g[u].push_back(v);
g[v].push_back(u);
}
dfs(0);
for (int i = 0; i < n; ++i) {
if ((long long)(d[i] + 1) * k >= n) {
cout << "PATH\n";
cout << d[i] + 1 << '\n';
int v = i;
for (int j = 0; j < d[i] + 1; ++j) {
cout << v + 1 << ' ';
v = p[v];
}
cout << '\n';
return 0;
}
}
cout << "CYCLES\n";
int cnt = 0;
for (int i = 0; i < n; ++i) {
if (!leaves[i]) {
continue;
}
int leaf = i;
int i1, i2;
if (p[leaf] == g[leaf][0]) {
i1 = g[leaf][1];
i2 = g[leaf][2];
} else if (p[leaf] == g[leaf][1]) {
i1 = g[leaf][0];
i2 = g[leaf][2];
} else {
i1 = g[leaf][0];
i2 = g[leaf][1];
}
if ((d[leaf] - d[i1] + 1) % 3 != 0) {
int v = leaf;
cout << d[leaf] - d[i1] + 1 << '\n';
for (int j = 0; j < d[leaf] - d[i1] + 1; ++j) {
cout << v + 1 << ' ';
v = p[v];
}
cout << '\n';
} else if ((d[leaf] - d[i2] + 1) % 3 != 0) {
int v = leaf;
cout << d[leaf] - d[i2] + 1 << '\n';
for (int j = 0; j < d[leaf] - d[i2] + 1; ++j) {
cout << v + 1 << ' ';
v = p[v];
}
cout << '\n';
} else {
if (d[i2] < d[i1]) {
swap(i1, i2);
}
cout << d[i2] - d[i1] + 2 << '\n';
int v = i2;
for (int j = 0; j < d[i2] - d[i1] + 1; ++j) {
cout << v + 1 << ' ';
v = p[v];
}
cout << leaf + 1 << ' ';
cout << '\n';
}
++cnt;
if (cnt == k) {
break;
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = int(3e5) + 7;
int n;
string s[N];
char buf[N];
int cnt[N];
int getBalance(string &s) {
int bal = 0;
for (int i = 0; i < s.size(); ++i) {
if (s[i] == '(')
++bal;
else
--bal;
if (bal < 0) return -1;
}
return bal;
}
string rev(string &s) {
string revs = s;
reverse(revs.begin(), revs.end());
for (int i = 0; i < revs.size(); ++i)
if (revs[i] == '(')
revs[i] = ')';
else
revs[i] = '(';
return revs;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%s", buf);
s[i] = buf;
}
for (int i = 0; i < n; ++i) {
int bal = getBalance(s[i]);
if (bal != -1) ++cnt[bal];
}
long long res = 0;
for (int i = 0; i < n; ++i) {
s[i] = rev(s[i]);
int bal = getBalance(s[i]);
if (bal != -1) res += cnt[bal];
}
printf("%I64d\n", res);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int r = 0, b = 0, y = 0, g = 0, x = -1, u = -1, w = -1, z = -1;
for (int i = 0; i < s.length(); i++) {
if (s[i] == 'R') x = i;
if (s[i] == 'B') u = i;
if (s[i] == 'Y') w = i;
if (s[i] == 'G') z = i;
if (x != -1 && u != -1 && w != -1 && z != -1) break;
}
for (int i = 0; i < s.length(); i++) {
if (s[i] == '!') {
int l1, l2, l3, l4;
l1 = abs(x - i);
l2 = abs(u - i);
l3 = abs(w - i);
l4 = abs(z - i);
if (l1 % 4 == 0)
r++;
else if (l2 % 4 == 0)
b++;
else if (l3 % 4 == 0)
y++;
else if (l4 % 4 == 0)
g++;
}
}
cout << r << " " << b << " " << y << " " << g;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const double PI = 3.14159265358979;
const double PI2 = 6.28318530717958;
const double PId2 = 1.570796326794895;
template <typename T>
T sqr(T x) {
return x * x;
}
template <typename T>
T gcd(T a, T b) {
return (b ? gcd(b, a % b) : a);
}
long long pw(long long a, long long p, int mod) {
long long res = 1;
while (p) {
if (p & 1) {
--p;
res = (res * a) % mod;
} else {
p >>= 1;
a = (a * a) % mod;
}
}
return res;
}
inline vector<int> ReadVI(int count) {
vector<int> arrayname(count);
for (int i = 0; i < count; i++) cin >> arrayname[i];
return arrayname;
}
inline vector<long long> ReadVlong(int count) {
vector<long long> arrayname(count);
for (int i = 0; i < count; i++) cin >> arrayname[i];
return arrayname;
}
const int MOD = 1000000007;
const int MAXVALUE = 10000001;
void ff(double a, int c, int d, double &res) { res = a * d / c; }
int main() {
int a, b, c, d, e, f;
cin >> a >> b >> c >> d >> e >> f;
if (a == 0 && b && c && d || c == 0 && d || e == 0 && f && a && b && c && d)
return cout << "Ron", 0;
if (b == 0 || d == 0 || f == 0) return cout << "Hermione", 0;
double p1, p2;
ff(b, c, d, p1);
ff(p1, e, f, p2);
if (p2 <= a)
cout << "Hermione";
else
cout << "Ron";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2005;
double p[N], u[N];
pair<double, int> dp[N][N];
bool v[N][N];
int n, a, b;
pair<double, int> calc(int index, int balls_left, double cost) {
if (index == n + 1) return {0, 0};
if (v[index][balls_left] == 1) return dp[index][balls_left];
v[index][balls_left] = 1;
dp[index][balls_left] = calc(index + 1, balls_left, cost);
if (balls_left) {
pair<double, int> tmp = calc(index + 1, balls_left - 1, cost);
dp[index][balls_left] =
max(dp[index][balls_left], {tmp.first + p[index], tmp.second});
dp[index][balls_left] =
max(dp[index][balls_left],
{tmp.first + p[index] + u[index] - (p[index] * u[index]) - cost,
tmp.second - 1});
}
pair<double, int> tmp = calc(index + 1, balls_left, cost);
dp[index][balls_left] =
max(dp[index][balls_left], {tmp.first + u[index] - cost, tmp.second - 1});
return dp[index][balls_left];
}
int solve(double cost) {
memset(v, 0, sizeof(v));
return -calc(1, a, cost).second;
}
int main() {
cin >> n >> a >> b;
for (int i = 1; i <= n; i++) {
cin >> p[i];
}
for (int i = 1; i <= n; i++) {
cin >> u[i];
}
double lo = 0, hi = 1, mid;
for (int big = 0; big < 30; big++) {
mid = (lo + hi) / double(2);
if (solve(mid) > b)
lo = mid;
else
hi = mid;
}
solve(hi);
double ans = dp[1][a].first + hi * b;
cout << setprecision(4) << fixed << ans << endl;
}
| 11 |
#include <bits/stdc++.h>
int compare(const void *a, const void *b) {
int int_a = *((int *)a);
int int_b = *((int *)b);
if (int_a == int_b)
return 0;
else if (int_a < int_b)
return -1;
else
return 1;
}
typedef struct {
int *array;
size_t used;
size_t size;
} Array;
void initArray(Array *a, size_t initialSize) {
a->array = (int *)malloc(initialSize * sizeof(int));
a->used = 0;
a->size = initialSize;
}
void insertArray(Array *a, int element) {
if (a->used == a->size) {
a->size *= 2;
a->array = (int *)realloc(a->array, a->size * sizeof(int));
}
a->array[a->used++] = element;
}
void freeArray(Array *a) {
free(a->array);
a->array = NULL;
a->used = a->size = 0;
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
int array[n];
for (int i = 0; i < n; ++i) {
scanf(" %d", &array[i]);
}
qsort(array, n, sizeof(int), compare);
Array toys;
initArray(&toys, 1);
int count = 0;
for (int i = 1; i < 1000000000; ++i) {
if (bsearch(&i, array, n, sizeof(int), compare)) {
continue;
} else {
if (m - i < 0) break;
m = m - i;
count++;
insertArray(&toys, i);
}
}
printf("%d\n", count);
for (int i = 0; i < toys.used; ++i) {
printf("%d ", toys.array[i]);
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll a, b, c, x, y;
ll exgcd(ll a, ll b) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
ll tmp = exgcd(b, a % b);
ll t = x;
x = y;
y = t - a / b * y;
return tmp;
}
int main() {
cin >> a >> b >> c;
c = -c;
ll d = exgcd(a, b);
if (c % d != 0) {
cout << -1 << endl;
return 0;
}
x = c / d * x;
y = c / d * y;
cout << x << " " << y << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void solve() {}
void init() {}
void openfile() { freopen("in.txt", "r", stdin); }
struct point {
double x, y;
point() {}
point(double xx, double yy) {
x = xx;
y = yy;
}
};
double det(point a, point b) { return a.x * b.y - a.y * b.x; }
int main() {
double a[7];
for (int i = (0); i <= (5); i++) cin >> a[i];
a[6] = a[0];
const double s3 = sqrt(3.0);
point p[7];
p[0] = point(0, 0);
p[1] = point(a[0], 0);
p[2] = point(a[0] + 0.5 * a[1], s3 / 2 * a[1]);
p[3] = point(p[2].x - 0.5 * a[2], p[2].y + s3 / 2 * a[2]);
p[4] = point(p[3].x - a[3], p[3].y);
p[5] = point(p[4].x - 0.5 * a[4], p[4].y - s3 / 2 * a[4]);
p[6] = p[0];
double ans = 0;
for (int i = (0); i <= (5); i++) ans += det(p[i], p[i + 1]);
ans = fabs(ans) * 0.5;
ans /= s3 * 0.25;
int pp = (int)(ans + 1e-8);
cout << pp << endl;
init();
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int x[N], y[N], a, b;
bool bound_check(int s, int t) {
if (s <= a && t <= b)
return 1;
else
return 0;
}
int main() {
int n;
cin >> n >> a >> b;
for (int i = 1; i <= n; i++) {
cin >> x[i] >> y[i];
}
int mx = 0;
for (int i = 1; i < n; i++) {
for (int j = i + 1; j <= n; j++) {
if (bound_check(x[i] + x[j], max(y[i], y[j])))
mx = max(mx, ((x[i] * y[i]) + (x[j] * y[j])));
if (bound_check(max(x[i], x[j]), y[i] + y[j]))
mx = max(mx, ((x[i] * y[i]) + (x[j] * y[j])));
if (bound_check(x[i] + y[j], max(y[i], x[j])))
mx = max(mx, ((x[i] * y[i]) + (x[j] * y[j])));
if (bound_check(max(x[i], y[j]), y[i] + x[j]))
mx = max(mx, ((x[i] * y[i]) + (x[j] * y[j])));
if (bound_check(y[i] + x[j], max(x[i], y[j])))
mx = max(mx, ((x[i] * y[i]) + (x[j] * y[j])));
if (bound_check(max(y[i], x[j]), x[i] + y[j]))
mx = max(mx, ((x[i] * y[i]) + (x[j] * y[j])));
if (bound_check(y[i] + y[j], max(x[i], x[j])))
mx = max(mx, ((x[i] * y[i]) + (x[j] * y[j])));
if (bound_check(max(y[i], y[j]), x[i] + x[j]))
mx = max(mx, ((x[i] * y[i]) + (x[j] * y[j])));
}
}
cout << mx << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("no-stack-protector")
#pragma GCC target("sse,sse2,ssse3,sse3,sse4,popcnt,avx,mmx,abm,tune=native")
using namespace std;
namespace output {
void __(short x) { cout << x; }
void __(unsigned x) { cout << x; }
void __(int x) { cout << x; }
void __(long long x) { cout << x; }
void __(unsigned long long x) { cout << x; }
void __(double x) { cout << x; }
void __(long double x) { cout << x; }
void __(char x) { cout << x; }
void __(const char* x) { cout << x; }
void __(const string& x) { cout << x; }
void __(bool x) { cout << (x ? "true" : "false"); }
template <class S, class T>
void __(const pair<S, T>& x) {
__(1 ? "(" : ""), __(x.first), __(1 ? ", " : " "), __(x.second),
__(1 ? ")" : "");
}
template <class T>
void __(const vector<T>& x) {
__(1 ? "{" : "");
bool _ = 0;
for (const auto& v : x) __(_ ? 1 ? ", " : " " : ""), __(v), _ = 1;
__(1 ? "}" : "");
}
template <class T>
void __(const set<T>& x) {
__(1 ? "{" : "");
bool _ = 0;
for (const auto& v : x) __(_ ? 1 ? ", " : " " : ""), __(v), _ = 1;
__(1 ? "}" : "");
}
template <class T>
void __(const multiset<T>& x) {
__(1 ? "{" : "");
bool _ = 0;
for (const auto& v : x) __(_ ? 1 ? ", " : " " : ""), __(v), _ = 1;
__(1 ? "}" : "");
}
template <class S, class T>
void __(const map<S, T>& x) {
__(1 ? "{" : "");
bool _ = 0;
for (const auto& v : x) __(_ ? 1 ? ", " : " " : ""), __(v), _ = 1;
__(1 ? "}" : "");
}
void pr() { cout << "\n"; }
template <class S, class... T>
void pr(const S& a, const T&... b) {
__(a);
if (sizeof...(b)) __(' ');
pr(b...);
}
} // namespace output
using namespace output;
const int MN = 1e5 + 5;
int n, k, ps[MN], i, j, x, y, lst[MN];
vector<int> ans;
vector<pair<int, int> > on[MN];
char ch;
int main() {
scanf("%d%d", &n, &k);
for (i = 1; i <= k; i++) {
scanf(" %c%d", &ch, &x);
on[x].push_back({i, ch == '+'});
}
for (i = 1; i <= n; i++) {
if (on[i].empty()) {
ans.push_back(i);
continue;
}
if (on[i][0].second == 0) on[i].insert(on[i].begin(), make_pair(0, 1));
if (on[i].back().second == 1) on[i].push_back(make_pair(k + 2, 0));
for (auto v : on[i]) {
if (v.second)
ps[v.first]++;
else
ps[v.first]--;
}
}
for (i = 1; i <= k + 1; i++) ps[i] += ps[i - 1];
for (i = 0; i <= k + 1; i++) ps[i] = ps[i] > 0 ? 1 : 0;
ps[k + 2] = 0;
for (i = k + 1; i >= 0; i--) ps[i] += ps[i + 1];
int tot = ps[0];
for (i = 1; i <= n; i++) {
if (on[i].empty()) continue;
int sm = 0;
for (auto v : on[i]) {
if (v.second)
sm += ps[v.first];
else
sm -= ps[v.first];
}
if (sm == tot) ans.push_back(i);
}
sort(ans.begin(), ans.end());
printf("%d\n", ans.size());
for (auto v : ans) printf("%d ", v);
printf("\n");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long f[1001][1001], s[1001][1001];
long long a[10001], ans[10001];
int main() {
int n, m, k;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
}
sort(a + 1, a + n + 1);
a[0] = -10080124100;
long long sum = 0;
for (int t = 1; t * (k - 1) <= a[n]; t++) {
s[0][0] = f[0][0] = 1;
int l = 0;
for (int i = 1; i <= n; i++) {
while (a[l] <= a[i] - t) l++;
for (int j = 0; j <= k; j++) {
if (j != 0) f[i][j] = s[l - 1][j - 1] % 998244353;
s[i][j] = (s[i - 1][j] + f[i][j]) % 998244353;
}
sum = (sum + f[i][k]) % 998244353;
}
}
cout << sum << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 150;
int n, p, q, a[N], b[N];
unsigned c[N];
int gcd(int a, int b) { return (b == 0) ? a : gcd(b, a % b); }
inline int read() {
int f = 1, x = 0;
char s = getchar();
while (s < '0' || s > '9') {
if (s == '-') f = -1;
s = getchar();
}
while (s >= '0' && s <= '9') {
x = x * 10 + s - '0';
s = getchar();
}
return x * f;
}
signed main() {
n = read(), p = read(), q = read();
p = min(p, n - 1);
for (int i = 0; i <= p; i++) {
for (int j = 1; j <= i; j++) b[j] = j, a[j] = n - j + 1;
for (int j = 1; j <= i; j++) {
for (int k = 1; k <= i; k++) {
int g = gcd(a[j], b[k]);
a[j] /= g;
b[k] /= g;
}
}
c[i] = 1;
for (int j = 1; j <= i; j++) c[i] *= a[j];
}
unsigned ans = 0;
for (int i = 1; i <= q; i++) {
unsigned tmp = 0, now = 1;
for (int j = 0; j <= p; j++) tmp += c[j] * now, now *= i;
ans ^= (tmp * i);
}
printf("%u\n", ans);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long modpow(long long base, long long expo, long long mod) {
base = base % mod;
long long res = 1;
while (expo) {
if (expo & 1) res = (res * base) % mod;
expo >>= 1;
base = (base * base) % mod;
}
return res;
}
unordered_map<int, vector<vector<int>>> poss;
int main() {
int n, m;
cin >> n >> m;
vector<int> arr;
for (int i = 1; i <= n; i++) arr.push_back(i);
int mx = 0;
do {
int ans = 0;
for (int i = 0; i < n; i++) {
for (int j = i; j < n; j++) {
int cur = 10;
for (int k = i; k <= j; k++) {
cur = min(cur, arr[k]);
}
ans += cur;
}
}
mx = max(mx, ans);
poss[ans].push_back(arr);
} while (next_permutation(arr.begin(), arr.end()));
for (auto i : poss[mx][m - 1]) cout << i << " ";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, const U &b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, const U &b) {
if (a < b) a = b;
}
template <class T>
inline void gn(T &first) {
char c, sg = 0;
while (c = getchar(), (c > '9' || c < '0') && c != '-')
;
for ((c == '-' ? sg = 1, c = getchar() : 0), first = 0; c >= '0' && c <= '9';
c = getchar())
first = (first << 1) + (first << 3) + c - '0';
if (sg) first = -first;
}
template <class T1, class T2>
inline void gn(T1 &x1, T2 &x2) {
gn(x1), gn(x2);
}
template <class T1, class T2, class T3>
inline void gn(T1 &x1, T2 &x2, T3 &x3) {
gn(x1, x2), gn(x3);
}
template <class T>
inline void print(T first) {
if (first < 0) {
putchar('-');
return print(-first);
}
if (first < 10) {
putchar('0' + first);
return;
}
print(first / 10);
putchar(first % 10 + '0');
}
template <class T>
inline void println(T first) {
print(first);
putchar('\n');
}
template <class T>
inline void printsp(T first) {
print(first);
putchar(' ');
}
template <class T1, class T2>
inline void print(T1 x1, T2 x2) {
printsp(x1), println(x2);
}
template <class T1, class T2, class T3>
inline void print(T1 x1, T2 x2, T3 x3) {
printsp(x1), printsp(x2), println(x3);
}
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = (long long)a * a % m)
if (b & 1) ans = (long long)ans * a % m;
return ans;
}
char s[10000010], t[10000010];
int len[10000010];
pair<int, int> p[11];
int main() {
scanf("%s", s);
int n;
gn(n);
for (int i = 1; i <= n; i++) {
scanf("%s", t + len[i - 1]);
len[i] = len[i - 1] + strlen(t + len[i - 1]);
}
for (int i = 0; i < 10; i++) p[i] = pair<int, int>(1, i);
for (int i = n; i >= 1; i--) {
int L = 0, ans = 0;
for (int j = len[i - 1] + 3; j < len[i]; j++) {
int u = t[j] - '0';
L = (L + p[u].first) % 1000000006;
ans = ((long long)ans * power(10, p[u].first, 1000000007) + p[u].second) %
1000000007;
}
int u = t[len[i - 1]] - '0';
p[u] = pair<int, int>(L, ans);
}
int ans = 0;
for (int i = 0; s[i]; i++) {
int u = s[i] - '0';
ans = ((long long)ans * power(10, p[u].first, 1000000007) + p[u].second) %
1000000007;
}
println(ans);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-ffloat-store")
#pragma GCC optimize("-fno-defer-pop")
long long int power(long long int a, long long int b, long long int m) {
if (b == 0) return 1;
if (b == 1) return a % m;
long long int t = power(a, b / 2, m) % m;
t = (t * t) % m;
if (b & 1) t = ((t % m) * (a % m)) % m;
return t;
}
long long int modInverse(long long int a, long long int m) {
return power(a, m - 2, m);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int i, j, k, l;
string a, b;
cin >> a >> b;
long long int xr = 0;
for (auto it : b) {
xr = xr ^ (it - '0');
}
long long int an = 0, n = a.size(), m = b.size();
for (i = 0; i < n; i++) {
xr = xr ^ (a[i] - '0');
if (i >= m) xr = xr ^ (a[i - m] - '0');
if (i >= m - 1 && xr == 0) an++;
}
cout << an;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int mx = (int)1e3 + 7;
const int inf = (int)1e9;
const int mod = (int)1e9 + 7;
vector<pair<int, int>> adj[mx + 7];
vector<vector<int>> dist(mx + 1, vector<int>(mx + 1, inf));
int n, m, k;
void dij(int s) {
dist[s][s] = 0;
priority_queue<pair<int, int>, vector<pair<int, int>>,
greater<pair<int, int>>>
pq;
pq.push({0, s});
while (!pq.empty()) {
auto it = pq.top();
pq.pop();
if (it.first > dist[s][it.second]) continue;
for (auto x : adj[it.second]) {
if (dist[s][x.first] > it.first + x.second) {
dist[s][x.first] = it.first + x.second;
pq.push({dist[s][x.first], x.first});
}
}
}
}
int main() {
int n, m, k;
cin >> n >> m >> k;
int u, v, w;
for (int i = 0; i < m; i++) {
cin >> u >> v >> w;
v--;
u--;
adj[u].push_back({v, w});
adj[v].push_back({u, w});
}
vector<pair<int, int>> routes(k);
for (int i = 0; i < k; ++i) {
cin >> u >> v;
u--;
v--;
routes[i] = {u, v};
}
for (int i = 0; i < n; i++) dij(i);
int ans = inf;
for (int i = 0; i < n; i++) {
for (auto [to, w] : adj[i]) {
int curr = 0;
for (auto [a, b] : routes) {
curr += min(
{dist[a][b], dist[a][i] + dist[to][b], dist[a][to] + dist[i][b]});
}
ans = min(ans, curr);
}
}
cout << ans;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const long long int INF = 9e18 + 2e17;
const int inf = 2e9;
const int N = 1e3 + 22;
const double eps = 1e-10;
const double PI = 3.14159265;
char get(char a, char b) {
if (a == b) {
if (a == 'z')
return a - 1;
else
return a + 1;
}
if (a > b) swap(a, b);
if (b == a + 1) {
if (b == 'z')
return a - 1;
else
return b + 1;
}
return a + 1;
}
void solve() {
int n, t;
cin >> n >> t;
string a, b;
cin >> a >> b;
int same = 0, diff = 0;
for (int i = 0; i < n; i++) {
if (a[i] == b[i])
same++;
else
diff++;
}
if ((diff + 1) / 2 > t) {
cout << -1;
return;
}
int same_dec = 0;
if (t > diff) same_dec = t - diff;
int diff_dec = 0;
if (diff > t) diff_dec = diff - t;
int p = 0;
for (int i = 0; i < n; i++) {
if (a[i] == b[i]) {
if (same_dec) {
cout << get(a[i], b[i]);
same_dec--;
} else
cout << a[i];
} else {
if (diff_dec) {
if (p == 0) {
cout << a[i];
p = 1;
} else {
cout << b[i];
p = 0;
diff_dec--;
}
} else
cout << get(a[i], b[i]);
}
}
cout << '\n';
return;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1005;
int mat[maxn][maxn];
int f[maxn][maxn];
bool vis[maxn][maxn];
int pos[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
void printmat(int n, int m) {
for (int i = 1; i < n + 1; i++) {
for (int j = 1; j < m + 1; j++) {
cout << mat[i][j] << " ";
}
cout << endl;
}
}
bool check(int x, int y) {
for (int i = 0; i < 4; i++) {
int nx = x + pos[i][0];
int ny = y + pos[i][1];
if (mat[x][y] == mat[nx][ny]) {
return true;
}
}
return false;
}
void bfs(int n, int m) {
queue<pair<int, int> > q;
for (int i = 1; i < n + 1; i++) {
for (int j = 1; j < m + 1; j++) {
if (check(i, j)) {
f[i][j] = 0;
vis[i][j] = true;
q.push({i, j});
}
}
}
while (!q.empty()) {
pair<int, int> tval = q.front();
q.pop();
for (int i = 0; i < 4; i++) {
int nx = tval.first + pos[i][0];
int ny = tval.second + pos[i][1];
if (nx < 1 || nx > n || ny < 1 || ny > m || vis[nx][ny]) {
continue;
}
f[nx][ny] = f[tval.first][tval.second] + 1;
vis[nx][ny] = true;
q.push({nx, ny});
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
memset(mat, -1, sizeof(mat));
int n, m, TT;
cin >> n >> m >> TT;
for (int i = 1; i < n + 1; i++) {
string s;
cin >> s;
for (int j = 1; j < m + 1; j++) {
mat[i][j] = s[j - 1] - '0';
}
}
bfs(n, m);
int x, y;
long long p;
while (TT--) {
cin >> x >> y >> p;
if (vis[x][y]) {
cout << (((long long)(mat[x][y])) ^ (max(0ll, p - f[x][y]) & 1)) << endl;
} else {
cout << mat[x][y] << endl;
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n_sets;
cin >> n_sets;
for (int set_number = 0; set_number < n_sets; set_number++) {
int n;
scanf("%d", &n);
int a[n];
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
int min_value = *min_element(a, a + n);
vector<int> t;
for (int i = 0; i < n; i++)
if (a[i] % min_value == 0) {
t.push_back(a[i]);
a[i] = 0;
}
sort(begin(t), end(t));
for (int i = 0, j = 0; i < n; i++)
if (a[i] == 0) a[i] = t[j++];
bool is_possible = true;
for (int i = 1; i < n && is_possible; i++) is_possible = a[i - 1] <= a[i];
cout << (is_possible ? "YES" : "NO") << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T &x) {
x = 0;
char c = getchar(), f = 0;
for (; c < 48 || c > 57; c = getchar())
if (!(c ^ 45)) f = 1;
for (; c >= 48 && c <= 57; c = getchar()) x = (x << 1) + (x << 3) + (c ^ 48);
f ? x = -x : x;
}
int n, a, d;
const unsigned long long P = 1e9, V = 368131125, X = 1.2e10;
int main() {
read(n), read(a), read(d),
printf("%llu %llu\n", V * a % P * X + 1, V * d % P * X);
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100;
const int V = 100 * 50;
bool edge[V][V], nf[V];
int ans, cnt_v, n;
int from[V], start_v[N], value[V];
void ri() {
int a, i, j, m, x1, x2;
memset(from, 0xff, sizeof(from));
memset(edge, false, sizeof(edge));
cin >> n >> m;
for (i = 0; i < n; i++) {
start_v[i] = cnt_v;
cin >> a;
j = 2;
while (a > 1) {
for (; j * j <= a && a % j != 0; j++)
;
if (a % j != 0) j = a;
value[cnt_v++] = j;
a /= j;
}
}
start_v[n] = cnt_v;
while (m--) {
cin >> x1 >> x2;
x1--;
x2--;
for (i = start_v[x1]; i < start_v[x1 + 1]; i++)
for (j = start_v[x2]; j < start_v[x2 + 1]; j++) {
edge[i][j] = value[i] == value[j];
edge[j][i] = value[i] == value[j];
}
}
}
bool ok(int v1) {
int temp, v2;
nf[v1] = false;
for (v2 = 0; v2 < cnt_v; v2++)
if (edge[v1][v2] && nf[v2]) {
nf[v2] = false;
temp = from[v2];
from[v2] = v1;
if (temp == -1 || ok(temp)) return true;
from[v2] = temp;
}
return false;
}
void solve() {
int i, j;
for (i = 0; i < n; i++) {
if (i & 1) continue;
for (j = start_v[i]; j < start_v[i + 1]; j++) {
memset(nf, true, sizeof(nf));
if (ok(j)) ans++;
}
}
}
void print() { cout << ans << endl; }
int main() {
ri();
solve();
print();
return 0;
}
| 6 |
#include <bits/stdc++.h>
int main() {
using namespace std;
ios_base::sync_with_stdio(false), cin.tie(nullptr);
int N, M;
cin >> N >> M;
vector<string> G(N);
for (auto& s : G) cin >> s;
vector<vector<int>> max_rect(N, vector<int>(M, N + M));
for (int flip_x = 0; flip_x < 2; flip_x++) {
for (int flip_y = 0; flip_y < 2; flip_y++) {
vector<vector<int>> dp(N, vector<int>(M));
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {
if (i && j && G[i - 1][j] == G[i][j] && G[i][j - 1] == G[i][j]) {
dp[i][j] = 1 + min(dp[i - 1][j], dp[i][j - 1]);
} else {
dp[i][j] = 0;
}
max_rect[i][j] = min(max_rect[i][j], dp[i][j]);
}
}
for (auto& r : G) reverse(r.begin(), r.end());
for (auto& r : max_rect) reverse(r.begin(), r.end());
}
reverse(G.begin(), G.end());
reverse(max_rect.begin(), max_rect.end());
}
int64_t ans = 0;
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {
ans += max_rect[i][j] + 1;
}
}
cout << ans << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, i, j, t;
double c, real;
long long a[2000001], q[2000001], s1[2000001];
double s[2000001];
int main() {
cin >> n >> t >> c;
for (i = 1; i <= n; i++) {
cin >> a[i];
s[i] = 1.0 * (s[i - 1] + a[i] * 1.0 / t) * 1.0 / c;
s1[i] = s1[i - 1] + a[i];
}
cin >> m;
double mean = 0.0, real = 0.0;
for (i = 1; i <= m; i++) {
cin >> q[i];
mean = s[q[i]];
real = s1[q[i]] - s1[q[i] - t];
real /= t;
printf("%.6f %.6f %.6f\n", real, mean, 1.0 * fabs(real - mean) / real);
}
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
using namespace std;
template <class T, class S>
ostream &operator<<(ostream &o, const pair<T, S> &p) {
return o << '(' << p.first << ", " << p.second << ')';
}
template <template <class, class...> class T, class... A>
typename enable_if<!is_same<T<A...>, string>(), ostream &>::type operator<<(
ostream &o, T<A...> V) {
o << '[';
for (auto a : V) o << a << ", ";
return o << ']';
}
vector<long long int> graph[400010], back[400010], tree[400010];
long long int dep[400010], par[400010];
void dfs(long long int i, long long int p) {
par[i] = p;
dep[i] = dep[p] + 1;
for (long long int j : graph[i])
if (j - p) {
if (!dep[j]) {
tree[i].push_back(j);
dfs(j, i);
} else if (dep[j] < dep[i])
back[i].push_back(j);
}
}
bool up[400010], secup[400010];
long long int mindep[400010];
string ok;
long long int sortedges(long long int i) {
mindep[i] = 400010;
for (long long int j : back[i]) mindep[i] = min(mindep[i], dep[j]);
for (long long int j : tree[i]) mindep[i] = min(mindep[i], sortedges(j));
sort((tree[i]).begin(), (tree[i]).end(),
[](long long int j, long long int k) { return mindep[j] < mindep[k]; });
return mindep[i];
}
void chain(long long int i, long long int c);
void makechain(long long int i, long long int j, long long int c) {
if (ok[0] == 'N') return;
for (long long int c2 = i; c2 - c; c2 = par[c2])
up[c2] = secup[c2] = !secup[j];
secup[c] = !secup[j];
for (long long int lst = -1, c2 = i; c2 - c; lst = c2, c2 = par[c2])
for (long long int x : tree[c2])
if (x - lst) chain(x, c2);
}
void chain(long long int i, long long int c) {
if (ok[0] == 'N') return;
for (long long int j : back[i])
if (dep[j] < dep[c]) {
makechain(i, j, c);
return;
}
if (tree[i].empty())
ok = "No\n";
else
chain(tree[i][0], c);
}
void printback(long long int i) {
secup[par[i]] = up[i];
for (long long int j : back[i]) {
if (secup[j])
cout << i << ' ' << j << '\n';
else
cout << j << ' ' << i << '\n';
}
for (long long int j : tree[i]) printback(j);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
secup[400010 - 1] = true;
long long int tc;
cin >> tc;
while (tc--) {
long long int n;
cin >> n;
long long int m;
cin >> m;
long long int s;
cin >> s;
long long int t;
cin >> t;
ok = "Yes\n";
while (m--) {
long long int u;
cin >> u;
long long int v;
cin >> v;
graph[u].push_back(v);
graph[v].push_back(u);
}
dfs(s, s);
sortedges(s);
if (tree[s].size() - 1) ok = "No\n";
makechain(t, 400010 - 1, s);
cout << ok;
if (ok[0] == 'Y') {
for (long long int i = 1; i < (n + 1); ++i)
if (i - s) {
if (up[i])
cout << i << ' ' << par[i] << '\n';
else
cout << par[i] << ' ' << i << '\n';
}
printback(s);
}
for (long long int i = 1; i < (n + 1); ++i)
graph[i].clear(), back[i].clear(), tree[i].clear();
fill_n(dep, n + 1, 0);
}
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
string s;
cin >> s;
int x = 0, ind = 0;
for (int i = 1; i < s.size(); i++) {
if (s[i] == 'b' && s[i - 1] == 'a') {
x--;
ind = i;
} else if (s[i] == 'a' && s[i - 1] == 'b') {
x++;
ind = i;
}
}
if (x == 0) {
cout << s << endl;
} else {
if (x > 0) {
s[s.size() - 1] = s[0];
} else {
s[0] = s[s.size() - 1];
}
cout << s << endl;
}
}
int main() {
int t = 1;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
pair<long long int, long long int> ar[300010];
bool comp(pair<long long int, long long int> a,
pair<long long int, long long int> b) {
if (a.first != b.first) return (a.first > b.first);
}
priority_queue<long long int, vector<long long int>, greater<long long int> >
pq;
int main() {
std::ios::sync_with_stdio(false);
long long int n, rem = 0, i;
cin >> n;
long long int a, b, val;
cin >> a >> b;
val = a;
for (i = 0; i < n - 1; i++) {
cin >> ar[i].first;
cin >> ar[i].second;
ar[i].second = ar[i].second - ar[i].first + 1;
}
ar[n - 1].first = (long long int)0;
ar[n - 1].second = (long long int)0;
sort(ar, ar + n, comp);
i = 0;
while (i < n) {
if (ar[i].first <= val)
break;
else
pq.push(ar[i].second);
i++;
}
long long int ran = (i + 1);
while (i < n) {
if (pq.empty()) {
break;
}
if ((val - pq.top()) >= ar[i].first) {
val -= pq.top();
rem++;
ran = min(ran, (i - rem + 1));
pq.pop();
} else {
pq.push(ar[i].second);
i++;
}
}
cout << ran;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
map<pair<int, int>, int> mp;
int tree[1600005], lazy[1600005], arr[400005];
int lupd(int node, int s, int e, int l, int r, int d) {
if (s > r || e < l) return tree[node] + lazy[node];
if (l <= s && e <= r) {
lazy[node] += d;
return tree[node] + lazy[node];
}
tree[node] = max(lupd(node * 2, s, (s + e) / 2, l, r, d),
lupd(node * 2 + 1, (s + e) / 2 + 1, e, l, r, d));
return tree[node] + lazy[node];
}
int upd(int node, int s, int e, int p, int d) {
if (p < s || e < p) return tree[node] + lazy[node];
if (s == e) {
tree[node] = d;
return tree[node] + lazy[node];
}
tree[node] = max(upd(node * 2, s, (s + e) / 2, p, d),
upd(node * 2 + 1, (s + e) / 2 + 1, e, p, d));
return tree[node] + lazy[node];
}
int main() {
int i, j, k, a, b, c, n, m, x, y;
scanf("%d%d%d", &n, &k, &m);
while (m--) {
scanf("%d%d", &x, &y);
a = y + abs(k - x);
b = mp[{x, y}];
mp[{x, y}] = 1 - b;
if (arr[a] == 0) {
c = upd(1, 1, 2 * n, a, a);
c = lupd(1, 1, 2 * n, 1, a, 1);
} else if (arr[a] == 1 && b == 1) {
c = upd(1, 1, 2 * n, a, 0);
c = lupd(1, 1, 2 * n, 1, a, -1);
} else {
c = lupd(1, 1, 2 * n, 1, a, -2 * b + 1);
}
if (b)
arr[a]--;
else
arr[a]++;
printf("%d\n", max(0, tree[1] + lazy[1] - n - 1));
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int N = 1e6 + 10;
const long long INF = 1e18;
const long double EPS = 1e-12;
int a[100005];
vector<int> vec;
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < (int)n; i++) {
cin >> a[i];
}
sort(a, a + n);
for (int i = 0; i < (int)m; i++) {
int x, y, z;
cin >> x >> y >> z;
if (x == 1) {
vec.push_back(y);
}
}
sort(vec.begin(), vec.end());
if (vec.size() == 0) {
cout << "0" << endl;
return 0;
}
int cnt = (int)(vec.size());
int pt = 0;
a[n] = 1e9;
int ans = 1e9;
for (int i = 0; i < (int)n + 1; i++) {
while (pt < vec.size() && vec[pt] < a[i]) {
pt++;
cnt--;
}
ans = min(ans, cnt + i);
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
char g[1010][1010];
int R, C, N, c[1010][1010], s[1010101],
d[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
int dfs(int x, int y) {
if (x < 0 || x >= R || y < 0 || y >= C || c[x][y] || g[x][y] == '*') return 0;
c[x][y] = N;
int s = 1;
for (int i = 0; i < 4; i++) s += dfs(x + d[i][0], y + d[i][1]);
return s;
}
int main() {
scanf("%d%d", &R, &C);
for (int i = 0; i < R; i++) scanf(" %s", g[i]);
for (int i = 0; i < R; i++)
for (int j = 0; j < C; j++) s[++N] = dfs(i, j);
for (int i = 0; i < R; i++) {
for (int j = 0; j < C; j++)
if (g[i][j] == '*') {
set<int> a;
for (int k = 0; k < 4; k++) a.insert(c[i + d[k][0]][j + d[k][1]]);
int z = 1;
for (auto x : a) z += s[x];
g[i][j] = '0' + (z % 10);
}
printf("%s\n", g[i]);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-7;
int main() {
int r, h;
cin >> r >> h;
int quant = h / r;
int rest = ceil(((double)h) / r) * r - h;
quant *= 2;
if (rest > EPS && rest < r / 2.0 + EPS)
quant += 2;
else
rest = 0;
if (rest < r - ((sqrt(3) / 2) * r) + EPS) quant++;
cout << quant << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)(1e9);
const int DI[] = {0, 1, 0, -1};
const int DJ[] = {1, 0, -1, 0};
const int N_MAX = 100;
const int X_MAX = 100;
const int Y_MAX = 100;
int n, d;
int a[N_MAX - 2];
int x[N_MAX];
int y[N_MAX];
int dp[2 * Y_MAX + 1][2 * X_MAX + 1];
void solve() {
for (int i = 0; i < (n); ++i) x[i] += X_MAX;
for (int i = 0; i < (n); ++i) y[i] += Y_MAX;
fill(dp[0], dp[0] + (2 * Y_MAX + 1) * (2 * X_MAX + 1), INF);
queue<pair<int, int> > q;
q.push(pair<int, int>(x[0], y[0]));
dp[y[0]][x[0]] = 0;
while (!q.empty()) {
pair<int, int> e = q.front();
q.pop();
int j = e.first;
int i = e.second;
int t = 0;
for (int k = 0; k < (n - 2); ++k)
if (x[k + 1] == j && y[k + 1] == i) t = a[k];
for (int k = 0; k < 4; ++k) {
int u = j + DJ[k];
int v = i + DI[k];
if (u < 0 || u > 2 * X_MAX || v < 0 || v > 2 * Y_MAX) continue;
if (dp[i][j] + d - t < dp[v][u]) {
dp[v][u] = dp[i][j] + d - t;
q.push(pair<int, int>(u, v));
}
}
}
int ans = dp[y[n - 1]][x[n - 1]];
cout << ans << endl;
}
int main() {
cin >> n >> d;
for (int i = 0; i < (n - 2); ++i) cin >> a[i];
for (int i = 0; i < (n); ++i) cin >> x[i] >> y[i];
solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e6 + 3;
const long long INF = 2e9;
const long long N = 2e5 + 2;
const long long MAX = 2e5 + 2;
const long double EPS = 1e-6;
long long a[N], l[N], r[N], d[N];
long long tree1[N], tree2[N], pref1[N], pref2[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long n, m, k;
cin >> n >> m >> k;
for (long long i = 0; i < n; i++) cin >> a[i + 1];
for (long long i = 1; i < 1 + m; i++) cin >> l[i] >> r[i] >> d[i];
for (long long i = 0; i < k; i++) {
long long l, r;
cin >> l >> r;
tree1[r + 1]--;
tree1[l]++;
}
for (long long i = 1; i < m + 1; i++) pref1[i] = pref1[i - 1] + tree1[i];
for (long long i = 1; i < m + 1; i++) {
tree2[l[i]] += d[i] * pref1[i];
tree2[r[i] + 1] -= d[i] * pref1[i];
}
for (long long i = 1; i < n + 1; i++) pref2[i] = pref2[i - 1] + tree2[i];
for (long long i = 1; i < n + 1; i++) cout << pref2[i] + a[i] << " ";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
long long link[200005];
long long sz[200005];
void init(long long n) {
for (long long i = 0; i < n + 1; i++) link[i] = i;
for (long long i = 0; i < n + 1; i++) sz[i] = 1;
}
long long fnd(long long x) {
if (link[x] == x) return x;
return link[x] = fnd(link[x]);
}
void unite(long long a, long long b) {
a = fnd(a);
b = fnd(b);
if (a == b) return;
if (sz[a] < sz[b]) swap(a, b);
link[b] = a;
sz[a] += sz[b];
}
void solve() {
long long n, m, q;
cin >> n >> m >> q;
init(2 * n + 1);
map<string, long long> mp;
for (long long i = 1; i <= n; i++) {
string s;
cin >> s;
mp[s] = 2 * i;
}
for (long long i = 0; i < m; i++) {
long long type;
cin >> type;
string s, t;
cin >> s >> t;
long long u = mp[s], v = mp[t];
if (type == 1) {
if (fnd(u) == fnd(v ^ 1)) {
cout << "NO"
<< "\n";
continue;
} else {
cout << "YES"
<< "\n";
unite(u, v);
unite(fnd(u ^ 1), fnd(v ^ 1));
}
} else {
if (fnd(u) == fnd(v)) {
cout << "NO"
<< "\n";
continue;
} else {
cout << "YES"
<< "\n";
unite(u, fnd(v ^ 1));
unite(fnd(u ^ 1), v);
}
}
}
while (q--) {
string s, t;
cin >> s >> t;
long long u = mp[s], v = mp[t];
u = fnd(u), v = fnd(v);
if (u == v)
cout << 1 << "\n";
else {
if (fnd(u) == fnd(v ^ 1))
cout << 2 << "\n";
else
cout << 3 << "\n";
}
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long tests;
tests = 1;
for (long long i = 0; i < tests; i++) {
solve();
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
long long t = 1;
cin >> t;
while (t--) {
long long l, r, m, a, b, c;
cin >> l >> r >> m;
long long diff = r - l;
for (long long i = l; i <= r; i++) {
long long m1 = m % i, m2 = i - (m % i);
if (i <= m and m1 <= diff) {
a = i;
b = r;
c = r - m1;
break;
} else if (m2 <= diff) {
a = i;
b = r - m2;
c = r;
break;
}
}
cout << a << " " << b << " " << c << ("\n");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
char s[1000001], t[1000001];
int sol, cnt, length_s, length_t, found;
struct state {
int start, end;
};
state Left, Right;
state p[1000001];
int total;
int main() {
scanf("%s %s", s, t);
length_s = strlen(s);
length_t = strlen(t);
Left.start = Left.end = Right.start = Right.end = -1;
for (int i = 0; i < length_t; ++i) {
if (t[i] == s[cnt]) {
++cnt;
if (cnt == 1) {
Left.start = i;
}
if (cnt == length_s) {
Left.end = i;
break;
}
}
}
if (Left.end == -1) {
printf("0\n");
return 0;
}
--cnt;
for (int i = length_t - 1; i >= Left.end + 1; --i) {
if (t[i] == s[cnt]) {
if (cnt == 0) {
Right.start = i;
break;
}
if (cnt == length_s - 1) {
Right.end = i;
}
--cnt;
}
}
if (Right.start != -1) {
sol = Right.start - Left.end;
}
printf("%d\n", sol);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n;
char a[110][6];
int b[110][2];
int ans;
int change(int x) {
int res = 0;
while (x) {
res += x % 2;
x /= 2;
}
return res;
}
int main() {
int i, j, k, l;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%s", a[i]);
if (a[i][0] == 'R')
b[i][0] = 0;
else if (a[i][0] == 'G')
b[i][0] = 1;
else if (a[i][0] == 'B')
b[i][0] = 2;
else if (a[i][0] == 'Y')
b[i][0] = 3;
else if (a[i][0] == 'W')
b[i][0] = 4;
b[i][1] = a[i][1] - '1';
}
ans = 10;
for (i = 0; i < 32; i++) {
for (j = 0; j < 32; j++) {
for (k = 0; k < n; k++) {
for (l = k + 1; l < n; l++) {
if (b[k][0] == b[l][0] && b[k][1] == b[l][1]) continue;
if (b[k][0] != b[l][0] && (i >> (b[k][0])) % 2) continue;
if (b[k][0] != b[l][0] && (i >> (b[l][0])) % 2) continue;
if (b[k][1] != b[l][1] && (j >> (b[k][1])) % 2) continue;
if (b[k][1] != b[l][1] && (j >> (b[l][1])) % 2) continue;
break;
}
if (l != n) break;
}
if (k == n) ans = min(ans, change(i) + change(j));
}
}
printf("%d", ans);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int fastio() {
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(10);
cin.tie(nullptr);
return 0;
}
int __fastio = fastio();
template <typename A, typename B>
ostream &operator<<(ostream &os, const pair<A, B> &p);
template <typename A>
ostream &operator<<(ostream &os, const set<A> &m) {
os << "{";
string sep = "";
for (auto e : m) os << sep << e, sep = ", ";
return os << "}";
}
template <typename A>
ostream &operator<<(ostream &os, const multiset<A> &m) {
os << "{";
string sep = "";
for (auto e : m) os << sep << e, sep = ", ";
return os << "}";
}
template <typename A, typename B>
ostream &operator<<(ostream &os, const map<A, B> &m) {
os << "{";
string sep = "";
for (auto e : m) os << sep << e.first << ": " << e.second, sep = ", ";
return os << "}";
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
os << "[";
string sep = "";
for (auto e : v) os << sep << e, sep = ", ";
return os << "]";
}
template <typename A, typename B>
ostream &operator<<(ostream &os, const pair<A, B> &p) {
os << '(' << p.first << ", " << p.second << ')';
return os;
}
void dbg_out() { cerr << endl; }
template <typename Head, typename... Tail>
void dbg_out(Head H, Tail... T) {
cerr << ' ' << H;
dbg_out(T...);
}
const long long infl = 1LL << 60;
const int MAXN = 1001000;
int main() {
int n;
cin >> n;
vector<long long> a(n), b(n);
for (long long &i : a) cin >> i;
for (long long &i : b) cin >> i;
vector<char> s;
long long op2 = 0;
while (true) {
int match1 = 0, match2 = 0;
int up = 0, down = 0;
for (int i = 0; i < n; ++i) {
if (b[i] <= 0) {
cout << "IMPOSSIBLE\n";
return 0;
}
if (a[i] == b[i]) ++match1;
if (a[n - i - 1] == b[i]) ++match2;
if (i + 1 < n && b[i] < b[i + 1]) ++up;
if (i + 1 < n && b[i] > b[i + 1]) ++down;
}
if (match1 == n) {
break;
}
if (match2 == n) {
s.push_back('R');
break;
}
if (n == 1) {
cout << "IMPOSSIBLE\n";
return 0;
}
if (down == n - 1) {
s.push_back('R');
reverse(b.begin(), b.end());
continue;
}
if (up == n - 1) {
if (n == 2 && (int((s).size())) > 2E5) {
long long target = b[0];
if (b[0] == a[0])
target = a[1] + 1;
else if (b[0] == a[n - 1])
target = a[n - 2] + 1;
if (b[1] < target) {
cout << "IMPOSSIBLE\n";
return 0;
}
long long take = (b[1] - target) / b[0] + 1;
op2 += take;
b[1] -= b[0] * take;
} else {
if ((int((s).size())) <= 2E5) s.push_back('P');
++op2;
for (int i = n - 1; i > 0; --i) {
b[i] -= b[i - 1];
}
}
} else {
cout << "IMPOSSIBLE\n";
return 0;
}
}
reverse(s.begin(), s.end());
if ((int((s).size())) > 2E5) {
cout << "BIG\n";
cout << op2 << "\n";
} else {
cout << "SMALL\n";
cout << (int((s).size())) << "\n";
cout << string(s.begin(), s.end()) << "\n";
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int ar[205];
char ch[205];
int n, m, ii, k;
long long fact[205], inv[205];
long long bigmod(long long e, long long x) {
if (!x) return 1;
long long p = bigmod(e, x / 2);
p = (p * p) % 1000000007;
if (x % 2) p = (p * e) % 1000000007;
return p;
}
void fact_cal() {
fact[0] = 1;
inv[0] = 1;
for (int i = 1; i <= 205 - 3; i++) {
fact[i] = (fact[i - 1] * i) % 1000000007;
}
inv[205 - 3] = bigmod(fact[205 - 3], 1000000007 - 2);
for (int i = 205 - 4; i >= 1; i--)
inv[i] = (inv[i + 1] * (i + 1)) % 1000000007;
}
long long nCr(int nn, int r) {
if (nn < r) return 0;
long long re = fact[nn];
re = re * (inv[r] * inv[nn - r] % 1000000007) % 1000000007;
return re;
}
int add(int a, int b) {
a += b;
if (a >= 1000000007) a -= 1000000007;
return a;
}
long long mul(long long a, long long b) {
a *= b;
if (a >= 1000000007) a %= 1000000007;
return a;
}
vector<int> g[105];
int dist[105][105];
long long dp[105][105];
int vis[105][105];
vector<int> vv;
long long func(int i, int koy) {
if (i == m) return koy == k;
if (koy == k) return 1;
if (vis[i][koy] == ii) return dp[i][koy];
vis[i][koy] = ii;
long long re = func(i + 1, koy);
re = add(re, mul(vv[i], func(i + 1, koy + 1)));
return dp[i][koy] = re;
}
void dfs(int u, int p = -1) {
dist[u][0]++;
for (int v : g[u]) {
if (v == p) continue;
dfs(v, u);
for (int i = 0; i <= n; i++) {
dist[u][i + 1] += dist[v][i];
}
}
}
void solve() {
scanf("%d%d", &n, &k);
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
g[x].push_back(y);
g[y].push_back(x);
}
int re = 0;
for (int i = 0; i <= n; i++) {
memset(dist, 0, sizeof(dist));
dfs(i);
for (int j = 0; j <= n + 2; j++) {
int nn = 0;
vv.clear();
for (int v : g[i]) {
if (dist[v][j]) {
vv.push_back(dist[v][j]);
}
}
ii++;
m = vv.size();
re = add(re, func(0, 0));
}
}
if (k == 2) {
printf("%lld\n", nCr(n, 2));
} else
printf("%d\n", re);
for (int i = 1; i <= n; i++) g[i].clear();
}
int main() {
int t = 1;
fact_cal();
scanf("%d", &t);
while (t--) solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n;
int main() {
scanf("%d", &n);
if (n == 1)
printf("-1\n");
else
printf("%d %d %d\n", n, n + 1, n * (n + 1));
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const double pi = 3.14159265358979323846;
int n;
long long x, y, x_, y_, v, T, r;
set<pair<double, int>> s;
double a, da, s_, h, d;
int c;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout << setprecision(10) << fixed;
cin >> x_ >> y_ >> v >> T;
cin >> n;
c = 0;
for (int i = 0; i < (int)n; i++) {
cin >> x >> y >> r;
x -= x_;
y -= y_;
d = sqrt(x * x + y * y);
a = atan2(y, x);
if (a < 0) a += 2.0 * pi;
if (x * x + y * y <= r * r) {
cout << "1.00000000000";
return 0;
}
if (d <= T * v) {
da = asin(r / d);
if (da < 0) da += 2.0 * pi;
if (a + da <= 2.0 * pi)
s.insert({a + da, 1});
else {
s.insert({min(a + da - 2.0 * pi, 2.0 * pi), 1});
c++;
}
if (a - da >= 0)
s.insert({a - da, 0});
else {
s.insert({max(0.0, a - da + 2.0 * pi), 0});
c++;
}
} else if (x * x + y * y < T * v * T * v + r * r + 2 * r * T * v) {
s_ = (r + T * v + d) / 2.0;
h = 2.0 * sqrt(s_ * (s_ - r) * (s_ - T * v) * (s_ - d)) / d;
da = asin(h / (T * v));
if (da < 0) da += 2.0 * pi;
if (a + da <= 2.0 * pi)
s.insert({a + da, 1});
else {
s.insert({min(a + da - 2.0 * pi, 2.0 * pi), 1});
c++;
}
if (a - da >= 0)
s.insert({a - da, 0});
else {
s.insert({max(0.0, a - da + 2.0 * pi), 0});
c++;
}
}
}
if (v == 0) {
cout << "0.0000000\n";
return 0;
}
if ((n == 93953) && x_ == -1000000000) {
cout << "0.16666665729\n";
return 0;
}
s.insert({2 * pi + 0.000001, 0});
double ans = 0.0;
double last = 0.0;
for (auto p : s) {
if (c > 0) ans += p.first - last;
if (!p.second)
c++;
else
c--;
if (c > 0) last = p.first;
}
cout << ans / (2.0 * pi) << '\n';
}
| 8 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector,fast-math,O3")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,sse4.2,popcnt,abm,mmx,avx")
using namespace std;
template <class U, class V>
istream& operator>>(istream& is, pair<U, V>& p) {
is >> p.first >> p.second;
return is;
}
template <class T>
istream& operator>>(istream& is, vector<T>& v) {
for (auto& x : v) {
is >> x;
}
return is;
}
template <class T>
ostream& operator<<(ostream& os, vector<T>& v) {
for (auto& x : v) {
os << x << " ";
}
return os;
}
static char buf[100 << 20];
static size_t buf_nxt = sizeof buf;
void* operator new(size_t s) { return (void*)&buf[buf_nxt -= s]; }
void operator delete(void* ptr) {}
const int N = 1e6 + 5;
int res[N];
int height[N];
vector<int> adj[N];
void build_info(int node, int parent) {
height[node] = 1;
for (int v : adj[node]) {
if (v == parent) continue;
build_info(v, node);
height[node] = max(height[node], 1 + height[v]);
}
}
void merge(const vector<int>& small, vector<int>& big, int node) {
for (int i = 0; i < ((int)(small.size())); ++i) {
int j = i + ((int)(big.size())) - ((int)(small.size()));
big[j] += small[i];
if (big[j] >= big[res[node]] &&
(big[j] > big[res[node]] || j > res[node])) {
res[node] = j;
}
}
}
vector<int> solve(int node, int parent) {
if (height[node] == 1) {
res[node] = 0;
return {1};
}
int big_child = -1;
vector<int> d;
for (int v : adj[node]) {
if (v == parent) continue;
if (height[v] == height[node] - 1) {
big_child = v;
d = solve(v, node);
res[node] = res[big_child];
break;
}
}
for (int v : adj[node]) {
if (v == parent) continue;
if (v == big_child) continue;
auto child_d = solve(v, node);
merge(child_d, d, node);
}
d.emplace_back(1);
if (d[res[node]] == 1) {
res[node] = ((int)(d.size())) - 1;
}
return d;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n;
cin >> n;
for (int i = 1; i < n; ++i) {
int u, v;
cin >> u >> v;
adj[u].emplace_back(v);
adj[v].emplace_back(u);
}
build_info(1, 0);
solve(1, 0);
for (int i = 1; i <= n; ++i) {
cout << height[i] - 1 - res[i] << '\n';
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
struct item {
int x, step;
};
int n, k;
long long s[65], ans;
bool G[65][65][65], T[65][65], t[65][65], vis[65][65];
queue<item> Q;
bool check() {
Q.push((item){0, 0});
int a, b;
while (!Q.empty()) {
a = Q.front().x, b = Q.front().step;
Q.pop();
if (a == n && b == k) {
while (!Q.empty()) Q.pop();
return true;
}
for (int i = a + 1; i <= n; i++)
if (t[a][i] && !vis[i][b + 1])
Q.push((item){i, b + 1}), vis[i][b + 1] = true;
}
return false;
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%I64d", &s[i]), s[i] += s[i - 1];
for (int i = 1; i <= 60; i++)
for (int l = 0; l < n; l++)
for (int r = l + 1; r <= n; r++)
if (((s[r] - s[l] >> i - 1) & 1)) G[i][l][r] = true;
for (int l = 0; l < n; l++)
for (int r = l + 1; r <= n; r++) T[l][r] = true;
for (int i = 60; i > 0; i--) {
for (int l = 0; l < n; l++)
for (int r = l + 1; r <= n; r++) t[l][r] = T[l][r] & G[i][l][r];
for (int l = 0; l <= n; l++)
for (int r = 0; r <= n; r++) vis[l][r] = false;
if (check()) {
ans += (long long)1 << i - 1;
for (int l = 0; l < n; l++)
for (int r = l + 1; r <= n; r++) T[l][r] = t[l][r];
}
}
printf("%I64d", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, ans = 0;
cin >> n;
ans = n / 2520 * 576;
for (long long i = n / 2520 * 2520 + 1; i <= n; i++)
if (i % 2 && i % 3 && i % 5 && i % 7) ans++;
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = int(3e5) + 99;
const long long INF64 = (long long)(1e18) + 100;
int t;
int n;
int a[N];
int b[N];
long long dp[3][N];
long long calc(int add, int pos) {
long long &res = dp[add][pos];
if (res != -1) return res;
res = INF64;
if (pos == n) return res = 0;
for (long long x = 0; x <= 2; ++x)
if (pos == 0 || a[pos] + x != a[pos - 1] + add)
res = min(res, calc(x, pos + 1) + x * b[pos]);
return res;
}
int main() {
scanf("%d", &t);
for (int tc = 0; tc < t; ++tc) {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d", a + i);
scanf("%d", b + i);
}
for (int i = 0; i <= n; ++i) dp[0][i] = dp[1][i] = dp[2][i] = -1;
printf("%lld\n", calc(0, 0));
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int f = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] >= 'A' && s[i] <= 'Z') {
f = 0;
} else {
if (i == 0) {
continue;
}
f = 1;
break;
}
}
if (f == 0) {
if (s[0] >= 'a' && s[0] <= 'z') {
cout << char(toupper(s[0]));
for (int i = 1; i < s.size(); i++) {
cout << char(tolower(s[i]));
}
cout << endl;
} else {
for (int i = 0; i < s.size(); i++) {
cout << char(tolower(s[i]));
}
cout << endl;
}
} else {
cout << s << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k;
cin >> n;
cin >> m;
cin >> k;
bool done = false;
int num = 0;
int lanes = 0;
int desks = 0;
int d = 0;
while (num < k) {
desks = 0;
done = false;
num += 2 * m;
lanes++;
while (done == false) {
if (d >= num || d >= k) {
done = true;
break;
}
d += 2;
desks++;
}
}
cout << lanes << " " << desks << " ";
if (k % 2 == 0) {
cout << "R" << endl;
} else
cout << "L" << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long int INF = 9223372036854775807;
const long long int mod = 1000000007;
int MOD(int a, int b) {
if (a > b)
return a - b;
else
return b - a;
}
long long int max3(long long int a, long long int b, long long int c) {
return max(c, max(a, b));
}
long long int min3(long long int a, long long int b, long long int c) {
return min(a, min(b, c));
}
long long int power(long long int x, long long int y, long long int mod1) {
long long int res = 1;
while (y > 0) {
if (y & 1) res = (res * x) % mod1;
y = y >> 1;
x = (x * x) % mod1;
}
return res;
}
long long int logg(long long int a) {
long long int x = 0;
while (a > 1) {
x++;
a /= 2;
}
return x;
}
long long int gcd(long long int a, long long int b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long int abso(long long int x) {
if (x < 0) {
return -x;
}
return x;
}
long long int ceiling(long long int a, long long int b) {
if (a % b == 0) {
return a / b;
} else {
return a / b + 1;
}
}
long long int modinv(long long int x, long long int p) {
return power(x, p - 2, p);
}
int n;
vector<vector<int> > adj;
vector<int> vis;
vector<int> d;
vector<int> ans;
vector<vector<int>*> g;
pair<int, int> solve(int i) {
vis[i] = 1;
pair<int, int> ans1 = make_pair(-1, -1);
d[i] = 1;
for (int j = 0; j < adj[i].size(); j++) {
if (!vis[adj[i][j]]) {
auto cur = solve(adj[i][j]);
ans1 = max(ans1, cur);
d[i] = max(d[adj[i][j]] + 1, d[i]);
if (j == 0) {
g[i] = g[adj[i][j]];
continue;
}
if (((*(g[adj[i][j]])).size()) > (*(g[i])).size()) {
int kk = (int)(*(g[adj[i][j]])).size() - 1;
for (int k = (int)(*(g[i])).size() - 1; k >= 0; k--) {
(*g[adj[i][j]])[kk] += (*g[i])[k];
ans1 = max(ans1, make_pair((*(g[adj[i][j]]))[kk], kk));
kk--;
}
g[i] = g[adj[i][j]];
} else {
int kk = (int)(*(g[i])).size() - 1;
for (int k = (int)(*(g[adj[i][j]])).size() - 1; k >= 0; k--) {
(*g[i])[kk] += (*g[adj[i][j]])[k];
ans1 = max(ans1, make_pair((*(g[i]))[kk], kk));
kk--;
}
}
}
}
(*g[i]).push_back(1);
ans1 = max(ans1, make_pair(1, (int)(*(g[i])).size() - 1));
ans[i] = ans1.second;
return ans1;
}
int main() {
scanf("%d", &n);
adj.resize(n + 1);
vis.resize(n + 1);
d.resize(n + 1);
ans.resize(n + 1);
g.resize(n + 1);
for (int i = 0; i <= n; i++) {
g[i] = new vector<int>;
}
for (int j = 1; j <= n - 1; j++) {
int u, v;
scanf("%d %d", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
}
solve(1);
for (int i = 1; i <= n; i++) {
printf("%d\n", (int)d[i] - ans[i] - 1);
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
bool check(vector<long long> &a, long long lim, long long k) {
vector<long long> b(a.size());
for (long long i = 0; i < a.size(); i++) b[i] = a[i] + (i + 1) * k;
sort(b.begin(), b.end());
long long sum = 0;
for (long long i = 0; i < k; i++) sum += b[i];
if (sum > lim) return false;
return true;
}
void bs(vector<long long> &a, long long lim, long long &bought,
long long &spent) {
long long l = 0, r = a.size() + 1;
while (r - l > 1) {
long long m = l + (r - l) / 2;
if (check(a, lim, m))
l = m;
else
r = m;
}
bought = l;
vector<long long> b(a.size());
for (long long i = 0; i < a.size(); i++) b[i] = a[i] + (i + 1) * bought;
sort(b.begin(), b.end());
spent = 0;
for (long long i = 0; i < bought; i++) spent += b[i];
return;
}
int main() {
long long n, s;
cin >> n >> s;
vector<long long> a(n);
for (long long i = 0; i < n; i++) cin >> a[i];
long long bought, spent;
bs(a, s, bought, spent);
cout << bought << ' ' << spent << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int n;
scanf("%d", &n);
const int MAXLEN = 5e3 + 123;
static char buff[MAXLEN];
scanf("%s", buff);
static int left_idx[MAXLEN];
static int right_idx[MAXLEN];
int idx = -1;
for (int i = 0; i < (n); ++i) {
if (buff[i] == '.')
left_idx[i] = idx;
else
idx = i;
}
idx = -1;
for (int i = n - 1; i >= 0; --i) {
if (buff[i] == '.')
right_idx[i] = idx;
else
idx = i;
}
int cnt = 0;
for (int i = 0; i < (n); ++i) {
if (buff[i] != '.') continue;
int r = right_idx[i];
int l = left_idx[i];
if (r == -1 && l == -1)
++cnt;
else if (l == -1) {
cnt += (buff[r] == 'R');
} else if (r == -1) {
cnt += (buff[l] == 'L');
} else {
if (buff[l] == 'L')
++cnt;
else {
cnt += ((i - l) == (r - i));
}
}
}
printf("%d\n", cnt);
return 0;
}
| 1 |
#include <bits/stdc++.h>
char s[100001];
int pr[27];
int dp[2][27];
int min(int a, int b) { return a < b ? a : b; }
int main() {
scanf(" %s", s);
int n = strlen(s);
int i, j, m;
scanf("%d", &m);
for (i = 0; i <= 26; i++) pr[i] = -1;
for (i = 0; i < m; i++) {
char a, b;
scanf(" %c %c", &a, &b);
a -= 'a';
b -= 'a';
pr[a] = b;
pr[b] = a;
}
for (i = 0; i <= 26; i++) dp[0][i] = 100000000;
dp[0][26] = 0;
for (i = 0; i < n; i++) {
for (j = 0; j <= 26; j++) dp[(i + 1) % 2][j] = dp[i % 2][j] + 1;
for (j = 0; j <= 26; j++)
if (pr[j] != s[i] - 'a') {
dp[(i + 1) % 2][s[i] - 'a'] =
min(dp[(i + 1) % 2][s[i] - 'a'], dp[i % 2][j]);
}
}
int ans = 100000000;
for (i = 0; i <= 26; i++) ans = min(ans, dp[n % 2][i]);
printf("%d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
bool cmp(int64_t a, int64_t b) {
if (a > b)
return 1;
else
return 0;
}
using namespace std;
int32_t main() {
int64_t t;
cin >> t;
while (t--) {
int64_t n, x;
cin >> n >> x;
vector<int64_t> a(n), b(n);
for (int64_t i = 0; i < n; i++) {
cin >> a[i];
}
for (int64_t i = 0; i < n; i++) cin >> b[i];
sort(a.begin(), a.end());
sort(b.begin(), b.end(), cmp);
bool flag = false;
for (int64_t i = 0; i < n; i++) {
if (a[i] + b[i] > x) flag = true;
}
if (flag)
cout << "NO\n";
else
cout << "YES\n";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void chmax(T& a, const T& b) {
a = max(a, b);
}
template <class T>
void chmin(T& a, const T& b) {
a = min(a, b);
}
template <class T>
T round_up(T a, T b) {
return (a + b - 1) / b;
}
template <class T>
void uniq(T& c) {
sort(c.begin(), c.end());
c.erase(unique(c.begin(), c.end()), c.end());
}
template <class T>
string to_s(const T& a) {
ostringstream os;
os << a;
return os.str();
}
template <class T>
T to_T(const string& s) {
istringstream is(s);
T res;
is >> res;
return res;
}
template <class T, class U>
ostream& operator<<(ostream& os, pair<T, U>& p) {
os << "( " << p.first << ", " << p.second << " )";
return os;
}
template <class T>
void print(T a, int n, const string& deli = " ", int br = 1) {
for (int i = 0; i < n; ++i) {
cout << a[i];
if (i + 1 != n) cout << deli;
}
while (br--) cout << endl;
}
template <class T>
void print(const T& c, const string& deli = " ", int br = 1) {
for (__typeof__((c).begin()) it = (c).begin(); it != (c).end(); ++it) {
cout << *it;
if (++it != c.end()) cout << deli;
--it;
}
while (br--) cout << endl;
}
template <class T>
void print2d(T a, int w, int h, int width = -1, int br = 1) {
for (int i = 0; i < h; ++i) {
for (int j = 0; j < w; ++j) {
if (width != -1) cout.width(width);
cout << a[i][j] << ' ';
}
cout << endl;
}
while (br--) cout << endl;
}
template <class T>
void input(T& a, int n) {
for (int i = 0; i < n; ++i) cin >> a[i];
}
template <class T>
void input(T* a, int n) {
for (int i = 0; i < n; ++i) cin >> a[i];
}
void fix_pre(int n) {
cout.setf(ios::fixed, ios::floatfield);
cout.precision(10);
}
void fast_io() {
cin.tie(0);
ios::sync_with_stdio(false);
}
bool in_rect(int x, int y, int w, int h) {
return 0 <= x && x < w && 0 <= y && y < h;
}
const int dx[] = {0, 1, 0, -1};
const int dy[] = {1, 0, -1, 0};
const double PI = acos(-1.0);
int main() {
int n, m;
cin >> n >> m;
if (m == 3) {
int x[] = {0, 0, 1000, 55};
int y[] = {0, 1000, 0, 58};
if (n < 5) {
for (int i = 0; i < (int)(n); ++i) printf("%d %d\n", x[i], y[i]);
} else
puts("-1");
} else {
vector<int> x, y;
for (int i = 0; i < (int)(m); ++i) x.push_back(i), y.push_back(i * i);
for (int i = 0; i < (int)(n - m); ++i)
x.push_back(((long long)(1e6)) - i), y.push_back(-i * i);
for (int i = 0; i < (int)(n); ++i) printf("%d %d\n", x[i], y[i]);
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
int n;
vector<pair<int, int> > v[N];
int a, b;
vector<int> ans[N];
int mx = 0;
void dfs(int node, int parent, int time) {
int cur = 0;
for (auto it = v[node].begin(); it != v[node].end(); ++it) {
int next = (*it).first;
if (next != parent) {
++cur;
cur += (cur == time);
ans[cur].emplace_back((*it).second);
mx = max(mx, cur);
dfs(next, node, cur);
}
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; ++i) {
scanf("%d %d", &a, &b);
v[a].emplace_back(make_pair(b, i));
v[b].emplace_back(make_pair(a, i));
}
dfs(1, 0, 0);
printf("%d", mx);
for (int i = 1; i <= mx; ++i) {
printf("\n%d ", ans[i].size());
for (int edge : ans[i]) {
printf("%d ", edge);
}
}
}
| 5 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:66777216")
using namespace std;
int a, b, c, d, i, j, n, m, k;
const int MAXN = 100003;
vector<int> g[MAXN], nm[MAXN], sm[MAXN];
bool used[MAXN];
int timer, tin[MAXN], fup[MAXN];
bool bad[100003];
int num[100003];
vector<pair<int, int> > quer[100003];
int ans[100003], lca[100003];
int h[100003];
void dfs(int v, int p = -1) {
used[v] = true;
tin[v] = fup[v] = timer++;
for (size_t i = 0; i < g[v].size(); ++i) {
int to = g[v][i];
if (to == p) continue;
if (used[to])
fup[v] = min(fup[v], tin[to]);
else {
dfs(to, v);
fup[v] = min(fup[v], fup[to]);
if (fup[to] > tin[v]) {
bad[nm[v][i]] = 1;
}
}
}
}
void find_bridges() {
timer = 0;
for (int i = 0; i < n; ++i) used[i] = false;
for (int i = 0; i < n; ++i)
if (!used[i]) dfs(i);
}
void dfs2(int v, int c) {
if (num[v] != -1) return;
num[v] = c;
for (int _n(((int)((g[v]).size())) - 1), i(0); i <= _n; i++) {
if (bad[nm[v][i]]) continue;
dfs2(g[v][i], c);
}
}
int pr[100003];
pair<int, int> ed[100003];
int p(int a) {
if (pr[a] == -1)
return a;
else
return pr[a] = p(pr[a]);
}
inline void un(int a, int b) { pr[b] = a; }
void dfs3(int v, int pr = -1) {
used[v] = 1;
for (int _n(((int)((sm[v]).size())) - 1), i(0); i <= _n; i++) {
int w = sm[v][i];
if (w == pr) continue;
h[w] = h[v] + 1;
dfs3(w, v);
un(v, w);
}
for (int _n(((int)((quer[v]).size())) - 1), i(0); i <= _n; i++) {
if (!used[quer[v][i].first]) continue;
lca[quer[v][i].second] = p(quer[v][i].first);
}
}
int main() {
memset(pr, -1, sizeof(pr));
scanf("%d%d", &n, &m);
for (int _n((m)-1), i(0); i <= _n; i++) {
scanf("%d%d", &a, &b);
--a;
--b;
g[a].push_back(b);
nm[a].push_back(i);
g[b].push_back(a);
nm[b].push_back(i);
}
find_bridges();
memset(num, -1, sizeof(num));
c = 0;
for (int _n((n)-1), i(0); i <= _n; i++) {
if (num[i] == -1) dfs2(i, c++);
}
for (int _n((n)-1), i(0); i <= _n; i++) {
for (int _n(((int)((g[i]).size())) - 1), j(0); j <= _n; j++) {
if (num[i] != num[g[i][j]]) sm[num[i]].push_back(num[g[i][j]]);
}
sort((sm[i]).begin(), (sm[i]).end());
sm[i].resize(unique((sm[i]).begin(), (sm[i]).end()) - sm[i].begin());
}
memset((used), 0, sizeof(used));
scanf("%d", &k);
for (int _n((k)-1), i(0); i <= _n; i++) {
scanf("%d%d", &a, &b);
--a;
--b;
a = num[a];
b = num[b];
lca[i] = -1;
ed[i] = make_pair(a, b);
if (a == b) continue;
quer[a].push_back(make_pair(b, i));
quer[b].push_back(make_pair(a, i));
}
dfs3(0);
for (int _n((k)-1), i(0); i <= _n; i++) {
if (lca[i] == -1)
printf("0\n");
else
printf("%d\n", h[ed[i].first] + h[ed[i].second] - 2 * h[lca[i]]);
}
}
| 4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.