solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x, y;
vector<int> arr;
cin >> n;
bool f = false;
for (int i = 0; i < n; i++) {
cin >> x >> y;
if (y != x) {
f = true;
}
arr.push_back(y);
}
if (f) {
cout << "rated";
return 0;
}
reverse(arr.begin(), arr.end());
if (is_sorted(arr.begin(), arr.end())) {
cout << "maybe";
} else {
cout << "unrated";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rnd(time(0));
const long long inf = 0x3f3f3f3f3f3f3f3fLL;
const int N = 1e3 + 5;
const int MOD = 1e9 + 7;
string str;
vector<string> a[N];
bool mark[26];
int deg[N];
vector<int> g[26];
vector<int> topo;
void topoSort() {
topo.clear();
priority_queue<int, vector<int>, greater<int>> pq;
for (int i = 0; i < 26; i++) {
if (!deg[i]) pq.push(i);
}
while (!pq.empty()) {
int u = pq.top();
pq.pop();
topo.push_back(u);
for (auto i : g[u]) {
deg[i]--;
if (!deg[i]) pq.push(i);
}
}
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, k, p;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> p;
for (int j = 0; j < k; j++) {
cin >> str;
a[p].push_back(str);
}
}
vector<string> s;
for (int i = 0; i < n; i++) {
for (int j = 0; j < k; j++) {
s.push_back(a[i][j]);
}
}
n = s.size();
for (int i = 0; i < n; i++) {
for (int j = 0; j < s[i].size(); j++) {
mark[s[i][j] - 'a'] = 1;
}
}
for (int i = 1; i < n; i++) {
int j = 0;
while (j + 1 < s[i].size() && j + 1 < s[i - 1].size() &&
s[i][j] == s[i - 1][j])
j++;
if (s[i][j] != s[i - 1][j]) {
g[s[i - 1][j] - 'a'].push_back(s[i][j] - 'a');
deg[s[i][j] - 'a']++;
} else if (s[i - 1].size() > s[i].size()) {
cout << "IMPOSSIBLE";
return 0;
}
}
topoSort();
if (topo.size() != 26)
cout << "IMPOSSIBLE";
else {
for (auto i : topo) {
if (mark[i]) {
cout << (char)(i + 'a');
}
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
#define mp make_pair
#define pb push_back
#define fi first
#define se second
#define sz(x) int(x.size())
const int mod = 1e9 + 7;
const int inf = 2e9 + 5;
const ll linf = 9e18 + 5;
const ll ll0 = 0 * 1ll;
int n, t;
const int N = 2e5 + 5;
int seg[3 * N];
set<int> know;
void update (int i, int x, int l, int r, int ind) {
if (i < l || r < i) {
return;
}
if (l == r) {
seg[ind] += x;
return;
}
int m = (l + r) / 2;
update(i, x, l, m, 2 * ind);
update(i, x, m + 1, r, 2 * ind + 1);
seg[ind] += x;
}
int sum (int b, int e, int l, int r, int ind) {
if (b <= l && r <= e) {
return seg[ind];
}
if (r < b || e < l) {
return 0;
}
int m = (l + r) / 2;
return sum(b, e, l, m, 2 * ind) + sum(b, e, m + 1, r, 2 * ind + 1);
}
void init () {
}
void input () {
cin >> n >> t;
}
void solve() {
for (int i = 0; i < t; i++) {
int k;
cin >> k;
int l = 1, r = n;
while (l != r) {
int m = (l + r) / 2;
int have = 0;
if (know.find(m) == know.end()) {
cout << "? " << 1 << ' ' << m << endl;
cout.flush();
cin >> have;
know.insert(m);
int now = sum(1, m, 1, n, 1);
update(m, have - now, 1, n, 1);
update(m + 1, now - have, 1, n, 1);
}
else {
have = sum(1, m, 1, n, 1);
}
if (m - have >= k) {
r = m;
}
else {
l = m + 1;
}
}
cout << "! " << l << endl;
cout.flush();
update(l, 1, 1, n, 1);
}
}
void output() {
}
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int number_of_testcases = 1;
//cin >> number_of_testcases;
while (number_of_testcases--) {
init();
input();
solve();
output();
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long satr[(long long)1e5 + 10];
long long soton[(long long)1e5 + 10];
int main() {
int n;
cin >> n;
string str;
cin >> str;
set<char> second;
for (int i = 0; i < (int)str.length(); i++) {
second.insert(str[i]);
}
int javab = 1e6;
int f = second.size();
if (f == 1) {
cout << 1;
return 0;
}
int left = 0, right = 0;
map<char, int> M;
M[str[0]]++;
while (right < (int)str.length()) {
if (M[str[left]] > 1) {
M[str[left]]--;
left++;
} else {
right++;
M[str[right]]++;
}
if ((int)M.size() == f) javab = min(javab, max(0, right - left + 1));
}
cout << javab;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long t, c[309100], n, a[309100], b[309100], m, j, an = 1, k;
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> b[i];
}
for (int i = 0; i < n; i++) {
if (b[i] >= n - m + 1) {
c[j] = i + 1;
j++;
}
}
sort(b, b + n);
for (int i = 1; i <= m; i++) {
k += b[n - i];
}
for (int i = 0; i < m - 1; i++) {
an *= (c[i + 1] - c[i]);
an = an % 998244353;
}
cout << k << " " << an;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline int L(int i) { return i << 1; }
inline int R(int i) { return (i << 1) | 1; }
inline int B(int i) { return 1 << i; }
inline int low_bit(int x) { return x & (-x); }
struct node {
int x, y;
} no[201000];
struct CNT {
int a, b, c;
} shu[201000];
int num[201000 + 201000], top, tp;
int cmp(int a, int b) { return a < b; }
int find(int x) {
int l = 0, r = tp - 1, m;
for (; l <= r;) {
m = (l + r) >> 1;
if (num[m] > x)
r = m - 1;
else if (num[m] < x)
l = m + 1;
else
return m;
}
return -1;
}
int main() {
int n, m;
while (scanf("%d", &n) != EOF) {
m = (n + 1) / 2;
top = 0;
for (int i = 0; i < n; i++) {
scanf("%d%d", &no[i].x, &no[i].y);
num[top++] = no[i].x, num[top++] = no[i].y;
}
sort(num, num + top, cmp);
tp = 0;
for (int i = 1; i < top; i++) {
if (num[i] == num[tp]) continue;
num[++tp] = num[i];
}
tp++;
for (int i = 0; i < tp; i++) shu[i].a = shu[i].b = shu[i].c = 0;
for (int i = 0; i < n; i++) {
int x = find(no[i].x), y = find(no[i].y);
if (x == y)
shu[x].c++;
else
shu[x].a++, shu[y].b++;
}
int ret = 0x3fffffff;
for (int i = 0; i < tp; i++) {
if (shu[i].a + shu[i].c + shu[i].b >= m) {
if (shu[i].a + shu[i].c >= m) {
ret = 0;
break;
}
ret = min(ret, m - shu[i].a - shu[i].c);
}
}
if (ret >= 0x3fffffff)
puts("-1");
else
printf("%d\n", ret);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 13;
long long bufer[N];
long long maxi[N];
int siz[N];
int numofleafs[N];
long long a[N];
vector<int> g[N];
int n;
void calcleaf(int v) {
for (auto x : g[v]) {
calcleaf(x);
numofleafs[v] += numofleafs[x];
}
if (g[v].empty()) numofleafs[v] = 1;
}
void calcsiz(int v, int p) {
siz[v] = 1;
for (auto t : g[v]) {
if (t == p) continue;
calcsiz(t, v);
siz[v] += siz[t];
}
}
bool visited[N];
void dfs(int v) {
for (auto t : g[v]) {
dfs(t);
}
if (siz[v] == 1) {
maxi[v] = a[v];
return;
}
for (auto t : g[v]) {
maxi[v] = max(maxi[v], maxi[t]);
}
for (auto t : g[v]) {
bufer[v] += (maxi[v] - maxi[t]) * numofleafs[t];
bufer[v] += bufer[t];
}
a[v] -= bufer[v];
if (a[v] > 0) {
bufer[v] = 0;
int t = a[v] / numofleafs[v];
for (auto x : g[v]) {
maxi[x] += t;
if (a[v] % numofleafs[v] != 0) maxi[x] += 1;
}
a[v] -= t * numofleafs[v];
if (a[v] != 0) {
bufer[v] = numofleafs[v] - a[v];
}
} else
bufer[v] = abs(a[v]);
for (auto t : g[v]) {
maxi[v] = max(maxi[v], maxi[t]);
}
}
int main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(0);
;
cin >> n;
for (int i = 2; i <= n; i++) {
int e;
cin >> e;
g[e].push_back(i);
}
for (int i = 1; i <= n; i++) cin >> a[i];
calcsiz(1, 1);
calcleaf(1);
dfs(1);
cout << maxi[1] << "\n";
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx")
using namespace std;
string to_string(string s) { return '"' + s + '"'; }
string to_string(const char* s) { return to_string((string)s); }
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto& x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
const int MAXN = 1e5 + 9;
const int MOD = (int)(1e9 + 7);
const int LOG2MAXN = 17;
const int INF = 1e9;
const long double eps = 1e-9;
int di[] = {0, 1, 0, -1};
int dj[] = {1, 0, -1, 0};
char ddir[] = {'R', 'U', 'L', 'D'};
mt19937_64 rnd(chrono::high_resolution_clock::now().time_since_epoch().count());
void solve() {
long long n, T;
cin >> n >> T;
vector<int> nxt(n + 1, -1);
vector<long long> aa(n), ps(n, 0);
vector<pair<long long, long long> > bb;
long long mn = LONG_LONG_MAX;
for (int i = 0; i < n; i++) {
cin >> aa[i];
nxt[i] = i + 1;
mn = min(mn, aa[i]);
ps[i] = aa[i];
bb.push_back({aa[i], i});
if (i) ps[i] += ps[i - 1];
}
sort((bb).begin(), (bb).end());
long long ans = 0;
long long sum = ps[n - 1];
long long curAlive = n;
long long start = 0;
vector<bool> used(n + 1, 0);
for (int cnt = 0; cnt < 100500; cnt++) {
if (T >= sum) {
ans += curAlive * (T / sum);
T %= sum;
}
42;
42;
if (T < mn) break;
int pos = start;
int prv = -1;
while (1) {
42;
if (aa[pos] <= T) {
if (prv != -1) {
nxt[prv] = pos;
} else
start = pos;
prv = pos;
T -= aa[pos];
ans++;
} else {
assert(!used[pos]);
curAlive--;
sum -= aa[pos];
used[pos] = 1;
}
pos = nxt[pos];
if (pos >= n || pos < 0) break;
if (T < mn) break;
}
nxt[prv] = n;
}
cout << ans << endl;
}
void input() {}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
input();
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 800;
int a[N];
long long b[N];
int n, m;
int solve(long long x) {
priority_queue<int> q;
int ret = 0;
for (int i = 1; i <= n; i++) {
if (a[i] < 0) q.push(-a[i]);
x += a[i];
if (x < 0) {
x += q.top();
q.pop();
ret++;
}
}
return ret;
}
long long check(int v) {
long long l = -1, r = 1e15, mid;
while (l + 1 < r) {
mid = (l + r) >> 1;
int t = solve(mid);
if (t <= v)
r = mid;
else
l = mid;
}
return r;
}
int main() {
scanf("%d%d", &n, &m);
int cnt = 0;
for (int i = 1; i <= n; i++) scanf("%d", a + i), cnt += a[i] < 0;
for (int i = 0; i <= cnt; i++) b[i] = check(cnt - i);
while (m--) {
long long x;
scanf("%I64d", &x);
int ans = upper_bound(b, b + cnt + 1, x) - b - 1;
printf("%d\n", cnt - ans);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int c[401];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> c[i];
int ans = -1;
for (int i = 1; i < n; i++) {
for (int j = i; j < n; j++) {
int p = c[i - 1] - 1, cnt = 1, w = c[j];
for (int k = i; k <= j; k++) {
cnt += p / c[k];
w += p / c[k] * c[k];
p %= c[k];
}
p = w;
for (int k = 0; k < n; k++) {
cnt -= p / c[k];
p %= c[k];
}
if (cnt < 0 && (ans == -1 || w < ans)) ans = w;
}
}
cout << ans << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2 * 100000 + 100;
struct node {
int x;
int cur;
} a[maxn];
int ant[maxn];
int lef[maxn];
int righ[maxn];
bool cmp(node u, node v) { return u.x > v.x; }
int main() {
int n;
while (~scanf("%d", &n)) {
for (int i = 0; i < n; i++) {
scanf("%d", &a[i].x);
a[i].cur = i + 1;
}
sort(a, a + n, cmp);
memset(lef, 0, sizeof(lef));
memset(righ, 0, sizeof(righ));
memset(ant, 0, sizeof(ant));
for (int i = 0; i < n; i++) {
int cwt = 1;
int v = a[i].cur;
if (v - 1 >= 1) {
lef[v] = lef[v - 1] + 1;
} else
lef[v] = 1;
if (v + 1 <= n) {
righ[v] = righ[v + 1] + 1;
} else
righ[v] = 1;
cwt = righ[v] + lef[v] - 1;
if (v - 1 >= 1) righ[v - lef[v] + 1] = max(righ[v - lef[v] + 1], cwt);
if (v + 1 <= n) lef[v + righ[v] - 1] = max(lef[v + righ[v] - 1], cwt);
ant[cwt] = max(ant[cwt], a[i].x);
}
int cwt = 0;
for (int i = n; i > 0; i--) {
cwt = max(cwt, ant[i]);
ant[i] = cwt;
}
for (int i = 1; i < n; i++) printf("%d ", ant[i]);
printf("%d\n", ant[n]);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int MOD = 1e9 + 7;
const int N = 1e5 + 10;
ll t[N], p, ans[N], q[N], head = 1, tail = 1;
int n, x[N];
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n >> p;
for (int i = 0; i < n; ++i) cin >> t[i];
for (int i = 0; i < n; ++i) x[i] = i;
sort(x, x + n,
[&](int a, int b) { return t[a] != t[b] ? t[a] < t[b] : a < b; });
priority_queue<int> pq;
int i = 0, z;
ll st;
while (i < n || pq.size() || head < tail) {
if (tail > head)
z = q[head++];
else {
if (pq.empty()) {
st = t[x[i]];
while (i < n && t[x[i]] == st) pq.push(-x[i++]);
}
z = -pq.top();
pq.pop();
}
st += p;
ans[z] = st;
q[--head] = z;
while (i < n && t[x[i]] <= st) {
if (q[tail - 1] > x[i])
q[tail++] = x[i++];
else
pq.push(-x[i++]);
}
++head;
}
for (int i = 0; i < n; ++i) printf("%lld ", ans[i]);
printf("\n");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long double EPS = 1e-9;
void solve() {
cout.precision(14);
cout << fixed;
long double x1, y1, r1, x2, y2, r2;
cin >> x1 >> y1 >> r1 >> x2 >> y2 >> r2;
long double d = sqrtl((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
if (d > r1 + r2 - EPS) {
cout << "0\n";
return;
}
if (r1 + d - EPS < r2) {
cout << atan2l(0, -1) * r1 * r1 << "\n";
return;
}
if (r2 + d - EPS < r1) {
cout << atan2l(0, -1) * r2 * r2 << "\n";
return;
}
long double a = 2 * acosl((r1 * r1 + d * d - r2 * r2) / (2 * r1 * d));
long double b = 2 * acosl((r2 * r2 + d * d - r1 * r1) / (2 * r2 * d));
cout << 0.5 * (r1 * r1 * (a - sinl(a)) + r2 * r2 * (b - sinl(b))) << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
solve();
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int dist[30][30];
int main() {
int i, j, k;
int n, m;
int u, v;
for (i = 0; i < 30; i++) {
for (j = 0; j < 30; j++) dist[i][j] = 100000000;
}
for (i = 0; i < 30; i++) dist[i][i] = 0;
string s, t;
cin >> s >> t;
if (s.length() != t.length()) {
cout << "-1";
return 0;
}
cin >> n;
char c1, c2, c3;
while (n--) {
cin >> c1 >> c2 >> k;
dist[c1 - 'a'][c2 - 'a'] = min(dist[c1 - 'a'][c2 - 'a'], k);
}
for (k = 0; k < 26; k++) {
for (i = 0; i < 26; i++) {
for (j = 0; j < 26; j++)
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
}
}
n = s.length();
int cost = 0, mn;
for (i = 0; i < n; i++) {
if (s[i] != t[i]) {
mn = 100000000;
c3 = '#';
for (j = 'a'; j <= 'z'; j++) {
k = dist[s[i] - 'a'][j - 'a'] + dist[t[i] - 'a'][j - 'a'];
if (k <= mn) mn = k, c3 = j;
}
cost += mn;
s[i] = t[i] = c3;
if (mn >= 100000000) {
cout << "-1";
return 0;
}
}
}
cout << cost << endl;
cout << s;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int inf = int(1e9);
const double eps = 1e-9;
const double pi = 4 * atan(double(1));
const int N = 1010;
pair<long long, long long> p[N];
inline long long gcd(long long a, long long b) {
while (b > 0) {
a %= b;
swap(a, b);
}
return a;
}
int main() {
int n, x0, yy0;
cin >> n >> x0 >> yy0;
for (int i = 0; i < n; ++i) {
int x, y;
scanf("%d %d", &x, &y);
long long vx = x - x0;
long long vy = y - yy0;
long long g = gcd(abs(vx), abs(vy));
vx /= g;
vy /= g;
if (vx < 0 || (vx == 0 && vy < 0)) {
vx *= -1;
vy *= -1;
}
p[i] = make_pair(vx, vy);
}
sort(p, p + n);
n = (int)(unique(p, p + n) - p);
cout << n << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double h, l;
cin >> h >> l;
double p;
p = l * l - h * h;
p /= 2;
p /= h;
printf("%.13f", p);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T sqr(T x) {
return x * x;
}
template <typename T>
T abs(T x) {
return x < 0 ? -x : x;
}
const int MAXN = 22;
const int MAXK = 12;
int a[MAXN][MAXN];
int cnt[MAXK], col[MAXK];
int r[MAXN][MAXN];
int f[MAXN][MAXN];
int cb[1 << MAXK];
int n, m, k, d;
int ans;
long long rec(int x, int y, int c) {
if (x < 1 || y > m) {
if (x == n) {
for (int i = 1; i <= k; i++)
for (int j = i + 1; j <= k; j++)
if (cnt[i] && cnt[j] && col[i] == col[j]) return 0;
c -= d;
long long res = 1;
for (int i = k - d - c + 1; i <= k - d; i++) res *= i;
return res;
}
x += 1;
y = 1;
}
f[x][y] = f[x - 1][y] | f[x][y - 1];
if (cb[f[x][y]] + n - x + 1 + m - y + 1 - 1 > k) return 0;
long long res = 0;
for (int i = 0; i <= c && i < k; i++)
if ((f[x][y] & (1 << i)) == 0 &&
(a[x][y] == 0 || cnt[a[x][y]] == 0 || col[a[x][y]] == i)) {
f[x][y] ^= 1 << i;
cnt[a[x][y]] += 1;
col[a[x][y]] = i;
r[x][y] = i;
res += rec(x, y + 1, c + (i == c));
f[x][y] ^= 1 << i;
cnt[a[x][y]] -= 1;
}
return res;
}
int main() {
cb[0] = 0;
for (int i = 1; i < (1 << MAXK); i++) cb[i] += cb[i >> 1] + (i & 1);
scanf("%d %d %d", &n, &m, &k);
if (n + m - 1 > k) {
puts("0");
return 0;
}
d = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
scanf("%d", &a[i][j]);
if (a[i][j] == 0) continue;
d += cnt[a[i][j]] == 0;
cnt[a[i][j]] += 1;
}
memset(cnt, 0, sizeof(cnt));
memset(col, 0, sizeof(col));
cout << rec(1, 1, 0) % 1000000007 << endl;
fprintf(stderr, "Time execute: %.3lfs\n", clock() / (double)CLOCKS_PER_SEC);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = (1 << 17) + 1000;
const int INF = 1e9;
int n, k, t, a[MAXN], f[18][MAXN][2][2];
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> k;
for (int i = 1; i <= k; i++) cin >> t, a[t - 1] = 1;
int bit = 1 << n;
for (int i = 0; i < 18; i++)
for (int j = 0; j < MAXN; j++)
for (int x1 = 0; x1 < 2; x1++)
for (int x2 = 0; x2 < 2; x2++) f[i][j][x1][x2] = -INF;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < bit; j += (1 << i)) {
if (i == 1) {
for (int x1 = 0; x1 < 2; x1++)
for (int x2 = 0; x2 < 2; x2++)
if (x1 + x2 == a[j] + a[j + 1]) f[i][j][x1][x2] = a[j] | a[j + 1];
} else {
for (int x1 = 0; x1 < 2; x1++) {
for (int x2 = 0; x2 < 2; x2++) {
for (int y1 = 0; y1 < 2; y1++) {
for (int y2 = 0; y2 < 2; y2++) {
t = f[i - 1][j][x1][y1] + f[i - 1][j + (1 << (i - 1))][x2][y2] +
(x1 | x2) + (y1 | y2);
f[i][j][x1][y1] = max(f[i][j][x1][y1], t + (y1 | x2));
f[i][j][x1][y2] = max(f[i][j][x1][y2], t + (y2 | x2));
f[i][j][x1][x2] = max(f[i][j][x1][x2], t + (x2 | y1));
f[i][j][x1][x2] = max(f[i][j][x1][x2], t + (x2 | y2));
f[i][j][x2][y1] = max(f[i][j][x2][y1], t + (y1 | x1));
f[i][j][x2][y2] = max(f[i][j][x2][y2], t + (y2 | x1));
f[i][j][x2][x1] = max(f[i][j][x2][x1], t + (x1 | y1));
f[i][j][x2][x1] = max(f[i][j][x2][x1], t + (x1 | y2));
}
}
}
}
}
}
}
int ans = 0;
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++) ans = max(ans, f[n][0][i][j] + (i | j));
cout << ans << '\n';
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5, SEG = (1 << 18);
vector<pair<int, int>> res;
int n, k;
void sw(string &s, int st, int en) {
while (en > st) {
swap(s[st], s[en]);
st++;
en--;
}
}
void fix(string &s) {
int cnt = 0;
for (int i = 0; i < n; i++) {
if (s[i] == ')')
cnt--;
else
cnt++;
if (cnt < 0) {
for (int ii = i + 1; ii < n; ii++) {
if (s[ii] == '(') {
res.push_back({i, ii});
sw(s, i, ii);
break;
}
}
cnt = 0;
i--;
}
}
}
void print() {
cout << res.size() << '\n';
;
for (auto r : res) {
cout << r.first + 1 << " " << r.second + 1 << '\n';
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
string s;
while (t--) {
res.clear();
cin >> n >> k;
cin >> s;
fix(s);
vector<int> st;
int cnt = 0;
for (int i = 0; i < n; i++) {
if (cnt == 0) st.push_back(i);
if (s[i] == '(')
cnt++;
else
cnt--;
}
st.push_back(n);
for (int i = 0; i < st.size() - 1; i++) {
if (st[i + 1] - st[i] > 2) {
for (int ii = st[i]; ii < st[i + 1]; ii++) {
int l = ii + 1;
;
for (int iii = ii + 1; iii < st[i + 1]; iii++) {
if (s[iii] == ')') {
l = iii;
break;
}
}
res.push_back({ii + 1, l});
sw(s, ii + 1, l);
ii++;
}
}
}
st.pop_back();
if (res.size() && res.back().first == res.back().second) res.pop_back();
st.clear();
cnt = 0;
for (int i = 0; i < n; i++) {
if (cnt == 0) st.push_back(i);
if (s[i] == '(')
cnt++;
else
cnt--;
}
if (k == st.size())
print();
else if (k < st.size()) {
int last = st.back();
for (int i = st.back(); i < n; i++) {
if (s[i] == '(') last = i;
}
int last2 = st[k - 1];
for (int i = last2; i < st[k]; i++) {
if (s[i] == ')') {
last2 = i;
break;
}
}
res.push_back({last2, last});
print();
} else {
print();
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
set<int> s;
int n, l, x, y;
int main() {
cin >> n >> l >> x >> y;
int a;
for (int i = 1; i <= n; ++i) cin >> a, s.insert(a);
int ans = 2;
bool fx = 0, fy = 0;
for (__typeof((s).begin()) it = (s).begin(); it != (s).end(); it++) {
if (s.count(*it + x)) {
ans--, fx = 1;
break;
}
}
for (__typeof((s).begin()) it = (s).begin(); it != (s).end(); it++) {
if (s.count(*it + y)) {
ans--;
fy = 1;
break;
}
}
if (ans == 0) {
cout << 0 << endl;
return 0;
}
if (ans == 1) {
cout << 1 << endl;
if (fx)
cout << y << endl;
else
cout << x << endl;
return 0;
}
for (__typeof((s).begin()) it = (s).begin(); it != (s).end(); it++) {
if (s.count(*it + x + y)) {
cout << 1 << endl;
cout << *it + x << endl;
return 0;
}
if (s.count(*it - abs(x - y)) && *it - max(x, y) >= 0) {
cout << 1 << endl;
if (x > y)
cout << *it - x << endl;
else
cout << *it - y << endl;
return 0;
}
if (s.count(*it + abs(x - y)) && *it + max(x, y) <= l) {
cout << 1 << endl;
if (x > y)
cout << *it + x << endl;
else
cout << *it + y << endl;
return 0;
}
}
cout << 2 << endl;
cout << x << ' ' << y << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 105;
int n, res = 1e9, a[5][N][N];
void calc(int a[N][N], int b[N][N], int c[N][N], int d[N][N]) {
int tmp = 0, tmp2 = 0;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) {
if (a[i][j] != (i + j) % 2)
++tmp;
else
++tmp2;
if (c[i][j] != (i + j) % 2)
++tmp;
else
++tmp2;
if (b[i][j] != (i + j) % 2)
++tmp2;
else
++tmp;
if (d[i][j] != (i + j) % 2)
++tmp2;
else
++tmp;
}
res = min(res, min(tmp, tmp2));
}
int main() {
cin >> n;
for (int i = 1; i <= 4; ++i)
for (int j = 1; j <= n; ++j)
for (int k = 1; k <= n; ++k) {
char z;
cin >> z;
a[i][j][k] = (int)(z - '0');
}
vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
v.push_back(4);
do {
calc(a[v[0]], a[v[1]], a[v[2]], a[v[3]]);
} while (next_permutation(v.begin(), v.end()));
cout << res << "\n";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
const int maxm = 5e4 + 10;
const int INF = 0x3f3f3f3f;
int n, res, dp[maxn];
struct Edge {
int v, next;
} edge[maxn * 2];
int head[maxn], cnt, ans[maxn], c, du[maxn];
void add(int u, int v) {
edge[cnt].next = head[u];
edge[cnt].v = v;
head[u] = cnt++;
}
void dfs(int x, int f) {
bool flag = 0;
for (int i = head[x]; i != -1; i = edge[i].next) {
int v = edge[i].v;
if (v == f) continue;
flag = 1;
dfs(v, x);
dp[x] += dp[v];
}
if (!flag) ans[++c] = x;
}
int main() {
while (scanf("%d", &n) != EOF) {
cnt = 0;
memset(head, -1, sizeof(head));
memset(du, 0, sizeof(du));
int maxx = 0, id = 0;
for (int i = 0; i < n - 1; i++) {
int u, v;
scanf("%d%d", &u, &v);
add(u, v);
add(v, u);
du[u]++;
du[v]++;
if (du[u] > maxx) {
maxx = du[u];
id = u;
}
if (du[v] > maxx) {
maxx = du[v];
id = v;
}
}
int num = 0;
for (int i = 1; i <= n; i++) {
if (du[i] >= 3) num++;
}
if (num >= 2) {
printf("No\n");
continue;
}
c = 0;
dfs(id, 0);
printf("Yes\n");
printf("%d\n", c);
for (int i = 1; i <= c; i++) {
printf("%d %d\n", id, ans[i]);
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const long long infLL = 0x3f3f3f3f3f3f3f3fLL;
const int maxn = 100000 + 5;
int n;
int a[maxn], p[maxn], vec[maxn];
void gcd(long long a, long long b, long long &g, long long &x0, long long &y0) {
if (!b)
g = a, x0 = 1, y0 = 0;
else
gcd(b, a % b, g, y0, x0), y0 -= x0 * (a / b);
}
long long inv(long long a, long long m) {
long long g, x0, y0;
gcd(a, m, g, x0, y0);
return g == 1 ? (x0 + m) % m : -1;
}
bool is_prime(int x) {
for (int i = 2; i * i <= x; ++i)
if (x % i == 0) return false;
return true;
}
bool solve() {
if (n < 9) {
for (int i = 0; i < (n); ++i) a[i] = i + 1;
do {
for (int i = 0; i < (n); ++i) {
p[i] = (i ? p[i - 1] : 1) * a[i] % n;
vec[i] = p[i];
}
sort(vec, vec + n);
if (unique(vec, vec + n) - vec == n) {
cout << "YES" << endl;
for (int i = 0; i < (n); ++i) cout << a[i] << endl;
return true;
}
} while (next_permutation(a, a + n));
return false;
} else {
if (!is_prime(n)) return false;
a[0] = 1;
for (int i = 1; i < n - 1; ++i) a[i] = (i + 1) * inv(i, n) % n;
a[n - 1] = n;
cout << "YES" << endl;
for (int i = 0; i < (n); ++i) cout << a[i] << endl;
return true;
}
}
int main() {
cin >> n;
if (!solve()) cout << "NO" << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long i, n, now, hh, ceng, ans, t, t1, la, a[100001], f[100001], g[100001],
sum[100001];
bool cmp(long long a, long long b) { return a > b; }
int main() {
scanf("%lld", &n);
for (i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
}
sort(a + 1, a + n + 1, cmp);
for (i = 1; i <= n; i++) sum[i] = sum[i - 1] + a[i];
scanf("%lld", &t1);
while (t1--) {
scanf("%lld", &t);
if (g[t])
printf("%lld\n", f[t]);
else {
ans = 0;
hh = t;
ceng = 1;
la = 2;
for (i = 2; i <= n; i = la) {
ans += (sum[min(n, la + hh - 1)] - sum[i - 1]) * ceng;
la += hh;
ceng++;
hh *= t;
}
printf("%lld\n", ans);
g[t] = 1;
f[t] = ans;
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long n, m;
cin >> n >> m;
vector<long long> tc(n), mk(m);
long long a;
long long ceven = 0, codd = 0;
for (int i = 0; i < n; i++) {
cin >> a;
tc[i] = a;
if (a % 2 == 0)
ceven++;
else
codd++;
}
for (int i = 0; i < m; i++) cin >> mk[i];
int counter = 0;
for (int i = 0; i < m; i++) {
if (mk[i] % 2 == 0 && codd > 0) {
counter++;
codd--;
} else if (mk[i] % 2 != 0 && ceven > 0) {
counter++;
ceven--;
}
}
cout << counter;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline int getid(int x, int y) { return x * 1010 + y; }
const int MAXN = 1010;
int parent[2 * MAXN * MAXN];
int size[2 * MAXN * MAXN];
int find(int x) {
if (parent[x] == x) return x;
return parent[x] = find(parent[x]);
}
void join(int x, int y) {
int px = find(x);
int py = find(y);
if (px != py) {
parent[px] = py;
size[py] += size[px];
}
}
int grid[MAXN][MAXN];
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
map<int, vector<pair<int, int>>> mp;
int tgtid;
bool visi[MAXN][MAXN];
int pos;
int remqtd;
pair<int, int> posans[MAXN * MAXN];
map<pair<int, int>, bool> mpmigue;
int n, m;
void dfs(int x, int y) {
visi[x][y] = true;
mpmigue[make_pair(x, y)] = true;
--remqtd;
if (remqtd <= 0) return;
for (int i = 0; i < (4); ++i) {
int nx = x + dx[i];
int ny = y + dy[i];
if (nx >= 0 && nx < n && ny >= 0 && ny < m && !visi[nx][ny]) {
if (find(getid(nx, ny)) == tgtid) dfs(nx, ny);
if (remqtd <= 0) return;
}
}
}
int main() {
scanf(" %d %d", &(n), &(m));
long long k;
scanf(" %lld", &k);
for (int i = 0; i < (n); ++i)
for (int j = 0; j < (m); ++j) {
scanf(" %d", &(grid[i][j]));
mp[grid[i][j]].push_back(make_pair(i, j));
parent[getid(i, j)] = getid(i, j);
size[getid(i, j)] = 1;
}
for (__typeof((mp).rbegin()) it = (mp).rbegin(); it != (mp).rend(); ++it) {
auto& v = it->second;
int cval = it->first;
for (__typeof((v).begin()) it2 = (v).begin(); it2 != (v).end(); ++it2) {
int x = it2->first;
int y = it2->second;
for (int i = 0; i < (4); ++i) {
int nx = x + dx[i];
int ny = y + dy[i];
if (nx >= 0 && nx < n && ny >= 0 && ny < m) {
if (grid[nx][ny] >= cval) join(getid(nx, ny), getid(x, y));
}
}
long long auxcval = cval;
if (k % auxcval == 0LL) {
long long qtd = k / auxcval;
if ((long long)size[find(getid(x, y))] >= qtd) {
printf("YES\n");
remqtd = qtd;
tgtid = find(getid(x, y));
dfs(x, y);
for (int i = 0; i < (n); ++i) {
for (int j = 0; j < (m); ++j) {
if (j) printf(" ");
if (mpmigue.count(make_pair(i, j))) {
--qtd;
printf("%d", cval);
} else {
printf("0");
}
}
printf("\n");
}
exit(0);
}
}
}
}
printf("NO\n");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int k, n, m;
long long p;
int a[1000000], l;
int main() {
scanf("%I64d%d", &p, &k);
while (p) a[++l] = p % k, p /= k;
for (int i = 1; i <= l; i++) {
a[i + 1] += a[i] / k;
a[i] %= k;
if (i % 2 == 0 && a[i]) a[i] = k - a[i], a[i + 1]++;
if (a[l + 1]) l++;
}
printf("%d\n", l);
for (int i = 1; i <= l; i++) printf("%d ", a[i]);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
bool cmp(pair<int, int> a, pair<int, int> b) { return a.second > b.second; }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
unordered_map<int, int> mp;
int n, m;
cin >> n >> m;
int arr[m];
for (int i = 0; i < m; i++) {
cin >> arr[i];
mp[arr[i]]++;
}
vector<pair<int, int>> v(mp.begin(), mp.end());
sort(v.begin(), v.end(), cmp);
int cnt = 1;
while (1) {
int nm = n;
int ok = 0;
for (int i = 0; i < v.size(); i++) {
int number = v[i].second;
while (nm > 0 && number >= cnt) {
number -= cnt;
nm--;
}
if (nm == 0) {
ok = 1;
}
}
if (ok) {
cnt++;
} else {
break;
}
}
cout << cnt - 1 << '\n';
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int mpow(int base, int exp);
void ipgraph(int m);
void dfs(int u, int par);
const int mod = 1000000007;
const int N = 3e5, M = N;
void solve() {
int n;
cin >> n;
int arr[22];
for (int i = 1; i <= n; i++) {
cin >> arr[i];
}
int chest = 0, biceps = 0, back = 0;
for (int i = 1; i <= n; i++) {
if (i % 3 == 1) {
chest += arr[i];
} else if (i % 3 == 2) {
biceps += arr[i];
} else {
back += arr[i];
}
}
if (chest > biceps && chest > back) {
cout << "chest";
} else if (biceps > chest && biceps > back) {
cout << "biceps";
} else {
cout << "back";
}
cout << endl;
}
int main() {
ios_base::sync_with_stdio(0);
solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, b;
string s;
vector<pair<string, int>> c;
cin >> n;
map<string, int> a;
for (int i = 0; i < n; i++) {
cin >> s >> b;
c.push_back(make_pair(s, b));
if (a.find(s) == a.end()) {
a[s] = b;
} else
a[s] += b;
}
int max = -100001;
for (map<string, int>::iterator it = a.begin(); it != a.end(); it++) {
if ((*it).second > max) max = (*it).second;
}
map<string, int> d;
for (int i = 0; i < n; ++i) {
if (a[c[i].first] == max) {
d[c[i].first] += c[i].second;
if (d[c[i].first] >= max) {
cout << c[i].first;
break;
}
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int b, c, d, e, f, i;
int a[4];
int main() {
cin >> b >> c >> d;
a[0] = b;
a[1] = c;
a[2] = d;
sort(a, a + 3);
e = a[1] - a[0];
f = a[2] - a[1];
d = e + f;
cout << d;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int N, M;
long long h(long long t) {
long long q = t / (M - 1);
long long r = t % (M - 1);
if (q % 2 == 0)
return r + 1;
else
return M - r;
}
long long ttg(long long t, long long s) {
long long h1 = h(t);
long long dir = (t / (M - 1)) % 2;
if (h1 == s) return t;
if (h1 > s && dir == 0) {
long long x = t + (M - h1) + (M - s);
return x;
} else if (h1 > s && dir == 1) {
return t + h1 - s;
} else if (h1 < s && dir == 0) {
return t + s - h1;
} else {
return t + h1 - 1 + s - 1;
}
}
long long S[100010];
long long F[100010];
long long T[100010];
int main() {
cin >> N >> M;
for (int i = 0; i < N; i++) {
cin >> S[i] >> F[i] >> T[i];
}
for (int i = 0; i < N; i++) {
if (S[i] == F[i]) {
cout << T[i] << endl;
} else {
long long x = ttg(T[i], S[i]);
x = ttg(x, F[i]);
cout << x << endl;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> cnt(n + 1);
for (int i = 0; i < n; ++i) {
int x;
cin >> x;
++cnt[x];
}
int mx = *max_element(cnt.begin(), cnt.end());
int diff = n + 1 - count(cnt.begin(), cnt.end(), 0);
cout << max(min(mx - 1, diff), min(mx, diff - 1)) << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
if (n == 2)
cout << "1\n";
else if (n == 3)
cout << "7\n";
else {
if (n % 2 == 0) {
for (int i(1); i <= n / 2; i++) cout << "1";
cout << "\n";
} else {
cout << "7";
for (int i(1); i <= (n / 2 - 1); i++) cout << "1";
cout << "\n";
}
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void pre() {}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
pre();
int tests = 1;
while (tests--) {
string s;
cin >> s;
const set<char> vowelsEven = {'a', 'e', 'i', 'o', 'u',
'1', '3', '5', '7', '9'};
int cnt = 0;
for (auto ch : s) {
if (vowelsEven.find(ch) != vowelsEven.end()) cnt++;
}
cout << cnt << '\n';
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXK = 110;
const int MAXM = 110000;
const int M = 1E5;
int a[MAXK], f[MAXM][MAXK];
long long dp(long long n, int k) {
if (k == 0) return n;
if (n <= M && ~f[n][k]) return f[n][k];
long long ret = dp(n, k - 1) - dp(n / a[k], k - 1);
if (n <= M) f[n][k] = ret;
return ret;
}
int main() {
long long n;
int k;
scanf("%lld%d", &n, &k);
for (int i = 1; i <= k; i++) scanf("%d", &a[i]);
sort(a + 1, a + k + 1);
memset(f, -1, sizeof f);
printf("%lld\n", dp(n, k));
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int SZ = 1e5 + 10;
inline long long int max(long long int a, long long int b, long long int c) {
return max(max(a, b), c);
}
inline long long int min(long long int a, long long int b, long long int c) {
return min(min(a, b), c);
}
inline long long int max(long long int a, long long int b) {
return (a > b) ? a : b;
}
inline long long int min(long long int a, long long int b) {
return (a < b) ? a : b;
}
inline long long int mul(long long int x, long long int y, long long int mod_) {
return ((x % mod_) * 1LL * (y % mod_)) % mod_;
}
long long int power(long long int a, long long int n) {
long long int p = 1;
while (n > 0) {
if (n % 2) {
p = p * a;
}
n >>= 1;
a *= a;
}
return p;
}
long long int powm(long long int a, long long int n, long long int mod_) {
long long int p = 1;
while (n) {
if (n % 2) {
p = mul(p, a, mod_);
}
n >>= 1;
a = mul(a, a, mod_);
}
return p % mod_;
}
long long int powi(long long int a, long long int mod_) {
return powm(a, mod_ - 2, mod_);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
long long int mn, mx;
long long int n, m, t, k, i, j, sum = 0, flag = 0, cnt = 0;
long long int x = 0, y = 0, z, l, r, q;
int TC = 1;
while (TC--) {
long long int r, h;
cin >> r >> h;
cnt = (h / r) * 2;
long long int rem = (h % r);
if (3 * r * r <= 4 * rem * rem)
cnt += 3;
else if (2 * rem >= r)
cnt += 2;
else
cnt++;
cout << cnt;
}
cerr << "Time : " << 1000 * ((double)clock()) / (double)CLOCKS_PER_SEC
<< "ms\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
long long mpow(long long a, long long n, long long mod) {
long long ret = 1;
long long b = a;
while (n) {
if (n & 1) ret = (ret * b) % mod;
b = (b * b) % mod;
n >>= 1;
}
return (long long)ret;
}
using namespace std;
int Z[4 * (int)(1e6 + 25)], a[(int)(1e6 + 25)];
int mod = 1e9 + 7;
void z(string &s1) {
int L = 0, R = 0, len = s1.size();
for (int i = 1; i < len; i++) {
Z[0] = len;
if (i > R) {
L = R = i;
while (R < len && s1[R - L] == s1[R]) R++;
Z[i] = R - L;
R--;
} else {
int k = i - L;
if (Z[k] < R - i + 1)
Z[i] = Z[k];
else {
L = i;
while (R < len && s1[R - L] == s1[R]) R++;
Z[i] = R - L;
R--;
}
}
}
}
void solve() {
int n, m, len1, len2;
scanf("%d", &n);
scanf("%d", &m);
string s;
cin >> s;
len1 = s.size();
s = s + '#' + s;
len2 = s.size();
z(s);
if (m == 0) {
cout << mpow(26, n, mod);
return;
}
for (int i = 1; i <= m; i++) {
scanf("%d", &a[i]);
}
int lef = a[1] - 1;
int i = 2;
int extend = a[1] + len1 - 1;
while (i <= m) {
if (a[i] <= extend) {
int diff = extend - a[i];
int pref = Z[len2 - 1 - diff];
if (a[i] + pref - 1 < extend) {
printf("0");
return;
}
int otherlef = len1 - pref;
extend += otherlef;
} else {
lef += (a[i] - extend - 1);
extend = a[i] + len1 - 1;
}
i++;
}
lef += (n - extend);
cout << mpow(26, lef, mod);
}
int main() {
int t = 1;
for (int i = 1; i <= t; i++) {
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxx = 2000 + 9;
bool ispalin[maxx][maxx];
int st[maxx];
int en[maxx];
int main() {
string s;
cin >> s;
int n = (int)s.size();
for (int i = 0; i < n; i++) {
for (int j = i; ~j; j--) {
if (j + 1 >= i - 1 || ispalin[j + 1][i - 1])
ispalin[j][i] = (s[i] == s[j]);
}
}
long long ans = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j <= i; j++) st[i] += ispalin[j][i];
st[i + 1] = st[i];
}
for (int i = n - 1; i > 0; i--) {
int cnt = 0;
for (int j = i; j < n; j++) cnt += ispalin[i][j];
ans += cnt * st[i - 1];
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, s, t, ans;
int main() {
cin >> n >> m;
while (n > 0 && m > 0) {
if (n > m) {
if (n >= 2 && m >= 1) {
n -= 2;
m -= 1;
++ans;
} else
break;
} else if (n >= 1 && m >= 2) {
n -= 1;
m -= 2;
++ans;
} else
break;
}
cout << ans << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return a == 0 ? b : gcd(b % a, a); }
string filename = "test";
vector<pair<int, int> > dots;
vector<int> d_to_f;
struct S {
int x, y, r;
int p;
S() : p(-1) {}
bool operator<(const S& a) const { return r < a.r; }
};
vector<S> f;
long long dist2(const pair<int, int>& a, const pair<int, int>& b) {
long long dx = a.first - b.first, dy = a.second - b.second;
return dx * dx + dy * dy;
}
double dist(const pair<int, int>& a, const pair<int, int>& b) {
return sqrt((1.0) * dist2(a, b));
}
int main() {
string str_fin = filename + ".in";
string str_fout = filename + ".out";
int n, m, k;
cin >> n >> m >> k;
dots.clear();
dots.reserve(n);
int x, y;
for (int _n(n), i(0); i < _n; i++) {
scanf("%d %d", &x, &y);
dots.push_back(pair<int, int>(x, y));
}
f.clear();
f.reserve(m);
for (int _n(m), i(0); i < _n; i++) {
S ff;
scanf("%d %d %d", &ff.r, &ff.x, &ff.y);
f.push_back(ff);
}
sort((f).begin(), (f).end());
for (int _n(m), i(0); i < _n; i++) {
long long r = f[i].r;
for (int _n(m), j(i + 1); j < _n; j++) {
long long r1 = f[j].r;
long long r1_2 = r1 * r1;
long long d2 =
dist2(pair<int, int>(f[i].x, f[i].y), pair<int, int>(f[j].x, f[j].y));
if (d2 < r1_2) {
f[i].p = j;
break;
}
}
}
d_to_f.clear();
for (int _n(n), i(0); i < _n; i++) {
int now = -1;
for (int _n(m), j(0); j < _n; j++) {
long long r1 = f[j].r;
long long r1_2 = r1 * r1;
long long d2 = dist2(dots[i], pair<int, int>(f[j].x, f[j].y));
if (d2 < r1_2) {
now = j;
break;
}
}
d_to_f.push_back(now);
}
for (int _n(k), i(0); i < _n; i++) {
scanf("%d %d", &x, &y);
--x;
--y;
int fx = d_to_f[x], fy = d_to_f[y];
int res = 0;
if (fx != fy) {
int cntx = 0, cnty = 0;
int now = fx;
while (now != -1) {
cntx++;
now = f[now].p;
}
now = fy;
while (now != -1) {
cnty++;
now = f[now].p;
}
int nowx = fx, nowy = fy;
if (cntx > cnty) {
for (int _n(cntx - cnty), i2(0); i2 < _n; i2++) nowx = f[nowx].p;
res = cntx - cnty;
} else if (cnty > cntx) {
for (int _n(cnty - cntx), i2(0); i2 < _n; i2++) nowy = f[nowy].p;
res = cnty - cntx;
}
while (nowx != nowy) {
nowx = f[nowx].p;
nowy = f[nowy].p;
res += 2;
}
}
cout << res << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = (long long)(1e9 + 7);
const long long N = (long long)(1e5 + 7);
long long p[N];
long long h[N];
int n, m;
bool fun(long long dist) {
queue<long long> q;
for (int i = 0; i < m; i++) {
q.push(p[i]);
}
for (int i = 0; i < n; i++) {
if (q.empty()) {
return true;
}
if (q.front() >= h[i]) {
while (!q.empty() && q.front() <= h[i] + dist) {
q.pop();
}
} else {
long long x = h[i] - q.front();
if (x > dist) {
return false;
}
long long y = max(dist - (2 * x), (dist - x) / 2);
y = max(y, (long long)0);
while (!q.empty() && q.front() <= h[i]) {
q.pop();
}
while (!q.empty() && q.front() - h[i] <= y) {
q.pop();
}
}
}
if (q.empty()) {
return true;
} else {
return false;
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> h[i];
}
for (int i = 0; i < m; i++) {
cin >> p[i];
}
sort(h, h + n);
sort(p, p + m);
long long l = 0;
long long r = 20000000007;
long long ans = -1;
while (l <= r) {
long long dist = (l + r) / 2;
if (fun(dist)) {
ans = dist;
r = dist - 1;
} else {
l = dist + 1;
}
}
cout << ans << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
for (int i = 21; i >= 0; i--) {
long long int res = ((1LL << (i + 1)) - 1) * 1LL * (1LL << (i));
long long int tmp = 0;
for (int j = 1; j <= (i + 1); j++) {
tmp = tmp + (1LL << (i + j - 1));
}
if (tmp != res) continue;
if (n % res == 0 && n >= res) {
cout << res << endl;
return 0;
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long n, x[100005], h[100005];
long long dp[100005][3];
long long go(long long i, long long pichla) {
if (i > n) return 0;
if (dp[i][pichla] != -1) return dp[i][pichla];
long long ans = go(i + 1, 0);
long long add = 0;
if (pichla == 2) add = h[i - 1];
if (x[i] - h[i] > x[i - 1] + add) ans = max(ans, 1 + go(i + 1, 1));
if (x[i] + h[i] < x[i + 1]) ans = max(ans, 1 + go(i + 1, 2));
return dp[i][pichla] = ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long i, j;
memset(dp, -1, sizeof dp);
cin >> n;
for (i = 1; i <= n; i++) {
cin >> x[i] >> h[i];
}
x[0] = -1e17;
h[0] = 0;
x[n + 1] = 1e17;
h[n + 1] = 0;
cout << go(1, 0);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x, y;
cin >> n >> x >> y;
int a = n / 2;
if (x >= a && x <= a + 1 && y >= a && y <= a + 1)
cout << "NO" << endl;
else
cout << "YES" << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;
using vpii = vector<pii>;
using vi = vector<int>;
using vvi = vector<vi>;
using ll = long long;
using vll = vector<long long>;
template <class T>
using min_queue = priority_queue<T, vector<T>, greater<T>>;
template <class T>
istream &operator>>(istream &, vector<T> &);
template <class T>
ostream &operator<<(ostream &, const vector<T> &);
template <class T, class U>
istream &operator>>(istream &, pair<T, U> &);
template <class T, class U>
ostream &operator<<(ostream &, const pair<T, U> &);
template <class T>
struct Inf {
static constexpr T inf() {
return std::numeric_limits<T>::has_infinity
? std::numeric_limits<T>::infinity()
: std::numeric_limits<T>::max();
}
};
template <>
struct Inf<int> {
static constexpr int inf() { return 0x3f3f3f3f; }
};
template <>
struct Inf<long long> {
static constexpr long long inf() { return 0x3f3f3f3f3f3f3f3fLL; }
};
constexpr int INF = Inf<int>::inf();
constexpr ll BINF = Inf<ll>::inf();
int solve() {
int a, b, c;
cin >> a >> b >> c;
const int M = 20000;
int ans = INF, anx, any, anz;
auto upd = [&](int x, int y, int z) {
int cost = abs(x - a) + abs(y - b) + abs(z - c);
if (cost < ans) ans = cost, anx = x, any = y, anz = z;
};
for (int x = 1; x <= M; x++) {
for (int y = x; y < M; y += x) {
upd(x, y, y);
int z1 = c - c % y;
int z2 = z1 + y;
if (y <= z1) upd(x, y, z1);
if (y <= z2) upd(x, y, z2);
}
}
cout << ans << endl;
cout << anx << ' ' << any << ' ' << anz << endl;
return 0;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
for (int i = 1; i <= t; i++) solve();
return 0;
}
template <class T>
istream &operator>>(istream &is, vector<T> &v) {
for (auto it = v.begin(); it != v.end(); ++it) is >> *it;
return is;
}
template <class T>
ostream &operator<<(ostream &os, const vector<T> &v) {
for (auto it = v.begin(); it != v.end();)
os << *it, os << " \n"[++it == v.end()];
return os;
}
template <class T, class U>
istream &operator>>(istream &is, pair<T, U> &p) {
return is >> p.first >> p.second;
}
template <class T, class U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
return os << p.first << ' ' << p.second;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, k;
cin >> n >> m >> k;
if (2l * m * n % k != 0) {
printf("NO\n");
return 0;
}
long long inN = n, inM = m, inK = k;
map<long long, int> nF, mF, kF;
for (long long i = 2; i * i <= n; ++i) {
while (n % i == 0) nF[i]++, n /= i;
}
nF[n]++;
for (long long i = 2; i * i <= m; ++i) {
while (m % i == 0) mF[i]++, m /= i;
}
mF[m]++;
for (long long i = 2; i * i <= k; ++i) {
while (k % i == 0) kF[i]++, k /= i;
}
kF[k]++;
bool is2Used = false;
long long nAns = inN;
long long mAns = inM;
for (auto it = kF.begin(); it != kF.end(); it++) {
;
if (false == is2Used && it->first == 2) {
;
is2Used = true;
it->second--;
}
if (nF[it->first] != 0) {
;
int reduce = min(nF[it->first], it->second);
it->second -= reduce;
while (reduce--) {
nAns /= it->first;
};
}
}
if (false == is2Used && 2 * nAns <= inN) {
nAns *= 2;
is2Used = true;
}
for (auto it = kF.begin(); it != kF.end(); it++) {
;
if (false == is2Used && it->first == 2) {
;
is2Used = true;
it->second--;
}
if (mF[it->first] != 0) {
int reduce = min(mF[it->first], it->second);
it->second -= reduce;
while (reduce--) {
mAns /= it->first;
}
};
}
if (false == is2Used && 2 * mAns <= inM) {
mAns *= 2;
is2Used = true;
}
printf("YES\n");
printf("0 0\n");
printf("%lld 0\n", nAns);
printf("0 %lld\n", mAns);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const double PI = 22.0 / 7.0;
const double EPS = 1e-6;
const int infi = (int)1e9;
const long long infl = (long long)1e16;
const int MOD = (int)1e9 + 7;
const int MAX = (int)2e5 + 9;
const int dx[] = {1, -1, 0, 0, 1, 1, -1, -1};
const int dy[] = {0, 0, -1, 1, 1, -1, 1, -1};
long long a[150009], n, q, k;
vector<pair<long long, long long> > ans;
bool operator>(pair<long long, long long> a, pair<long long, long long> b) {
return a.first > b.first;
}
void add(long long val) {
vector<pair<long long, long long> > res;
pair<long long, long long> toPush = make_pair(a[val], val);
res.clear();
bool c = 0;
int i = 0;
for (; (int)res.size() < min(6ll, k);) {
if (i >= (int)ans.size()) {
if (!c) res.push_back(toPush);
break;
}
pair<long long, long long> toComp = ans[i];
if (toPush > toComp) {
c = 1;
res.push_back(toPush);
toPush = make_pair(0, 0);
} else {
res.push_back(toComp);
i++;
}
}
ans.clear();
for (int i = 0; i < (int)res.size(); i++) ans.push_back(res[i]);
}
void check(long long val) {
for (int i = 0; i < (int)ans.size(); i++) {
if (val == ans[i].second) {
cout << "YES\n";
return;
}
}
cout << "NO\n";
}
int main() {
cin >> n >> k >> q;
for (int i = 1; i <= n; i++) cin >> a[i];
while (q--) {
long long id, val;
cin >> id >> val;
if (id == 1)
add(val);
else
check(val);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e17;
long long t, k, x, y, w, G, B;
vector<vector<pair<long long, long long>>> adj;
vector<long long> siz;
void dfs(long long v, long long p) {
siz[v] = 1;
for (pair<long long, long long> edge : adj[v]) {
long long u = edge.first, wei = edge.second;
if (u == p) continue;
dfs(u, v);
siz[v] += siz[u];
if (siz[u] % 2) G += wei;
B += wei * min(siz[u], k - siz[u]);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> t;
while (t--) {
cin >> k;
k <<= 1;
G = B = 0;
adj.clear();
siz.clear();
adj.resize(k);
siz.resize(k);
for (int i = 0; i < k - 1; i++) {
cin >> x >> y >> w;
x--, y--;
adj[x].push_back(make_pair(y, w));
adj[y].push_back(make_pair(x, w));
}
dfs(0, -1);
cout << G << " " << B << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct Node {
int id, v;
bool operator<(const Node &rhs) const {
if (v == rhs.v) return id > rhs.id;
return v > rhs.v;
}
};
int64_t sum1, sum2;
int zero;
int cnt;
set<Node> st;
set<Node> st2;
int main() {
int n;
scanf("%d", &n);
sum1 = 0;
sum2 = 0;
cnt = 0;
zero = 0;
for (int i = 1; i <= n; i++) {
int x, y;
scanf("%d%d", &x, &y);
if (y > 0) {
if (x == 1) cnt++;
sum1 += y;
st2.insert({x, y});
} else {
y = -y;
sum1 -= y;
auto it = st2.find({x, y});
if (it != st2.end()) {
st2.erase(it);
} else {
it = st.find({x, y});
st.erase(it);
if (x == 0) zero--;
sum2 -= y;
}
if (x == 1) {
cnt--;
if (st.size() != 0) {
auto it = --st.end();
Node now = *it;
if (now.id == 0) zero--;
st.erase(it);
sum2 -= now.v;
st2.insert(now);
}
}
}
if (st.size() != cnt && st2.size() != 0) {
auto it = st2.begin();
Node now = *it;
st.insert(now);
if (now.id == 0) zero++;
sum2 += now.v;
st2.erase(it);
}
if (st.size() == 0 || st2.size() == 0) {
} else {
auto it = --st.end();
auto it2 = st2.begin();
st.erase(it);
st2.erase(it2);
Node now1 = *it;
Node now2 = *it2;
if (now2.v > now1.v) {
sum2 += now2.v - now1.v;
if (now2.id == 0) zero++;
if (now1.id == 0) zero--;
st.insert(now2);
st2.insert(now1);
} else {
st.insert(now1);
st2.insert(now2);
}
}
if (st.size() != 0 && zero == 0 && st.size() == cnt) {
auto it1 = --st.end();
Node now = *it1;
st.erase(it1);
sum2 -= now.v;
if (st2.size() != 0) {
auto it2 = st2.begin();
Node now2 = *it2;
st2.erase(it2);
st.insert(now2);
zero++;
sum2 += now2.v;
}
st2.insert(now);
}
printf("%lld\n", sum1 + sum2);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
bool cmp(int f, int s) { return f < s; }
int main() {
int n;
cin >> n;
string s;
cin >> s;
int ans = 0;
for (int i = 0; i < n; i++) {
int cur = 0;
int j = i;
for (j = i; s[j] == s[j + 1]; j++) {
if (j >= n - 1) break;
}
ans += j - i;
i = j;
}
cout << ans;
return 0;
}
| 0 |
#include <bits/stdc++.h>
const int INF = 1e18;
const int inf = 1e9;
const int MAXN = 3e5 + 200;
const long double eps = 1e-8;
const long double pi = acos(-1.0);
using namespace std;
int level[MAXN], parent[MAXN], tin[MAXN], tout[MAXN], dp[MAXN];
int up[MAXN][20];
vector<int> g[MAXN];
int n, m, timer;
int ans[MAXN];
bool upper(int a, int b) { return tin[a] <= tin[b] && tout[a] >= tout[b]; }
void dfs_for_lcp(int v, int p) {
dp[v] = dp[p] + 1;
tin[v] = ++timer;
up[v][0] = p;
for (int i = 1; i < 20; i++) up[v][i] = up[up[v][i - 1]][i - 1];
for (int x : g[v])
if (x != p) dfs_for_lcp(x, v);
tout[v] = ++timer;
}
int lca(int a, int b) {
if (upper(a, b)) return a;
if (upper(b, a)) return b;
for (int i = 19; i >= 0; i--)
if (!upper(up[a][i], b)) a = up[a][i];
return up[a][0];
}
int dfs(int v, int sz, int ¢er, int p = -1) {
int sum = 1;
for (int x : g[v])
if (level[x] == 0 && x != p) sum += dfs(x, sz, center, v);
if (center == -1 && (2 * sum >= sz || p == -1)) center = v;
return sum;
}
void build(int v, int sz, int depth, int last) {
int center = -1;
dfs(v, sz, center);
level[center] = depth;
parent[center] = last;
for (int x : g[center])
if (level[x] == 0) build(x, sz >> 1, depth + 1, center);
}
int dist(int a, int b) {
int lc = lca(a, b);
return (dp[a] + dp[b] - 2 * dp[lc]);
}
void update(int v) {
int V = v;
while (v != -1) {
ans[v] = min(ans[v], dist(v, V));
v = parent[v];
}
return;
}
int find_ans(int v) {
int V = v;
int res = ans[v];
while (v != -1) {
res = min(res, ans[v] + dist(v, V));
v = parent[v];
}
return res;
}
void solve() {
cin >> n >> m;
for (int i = 0; i < n - 1; i++) {
int x, y;
cin >> x >> y;
x--;
y--;
g[x].push_back(y);
g[y].push_back(x);
}
dfs_for_lcp(0, 0);
build(0, n, 1, -1);
for (int i = 0; i < n; i++) ans[i] = inf;
update(0);
for (int i = 0; i < m; i++) {
int t, x;
cin >> t >> x;
x--;
if (t == 1)
update(x);
else
cout << find_ans(x) << "\n";
}
}
int main() {
ios::sync_with_stdio(NULL), cin.tie(0), cout.tie(0);
cout.setf(ios::fixed), cout.precision(0);
int step;
step = 1;
for (int i = 1; i <= step; i++) {
solve();
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 100000;
vector<pair<int, int> > nbrs[MAX_N];
int ps[MAX_N], pcs[MAX_N], cis[MAX_N];
int dos[MAX_N], drs[MAX_N];
vector<pair<int, int> > mds[MAX_N];
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 1; i < n; i++) {
int u, v, c;
scanf("%d%d%d", &u, &v, &c);
nbrs[u].push_back(pair<int, int>(v, c));
nbrs[v].push_back(pair<int, int>(u, c));
}
ps[0] = -1, pcs[0] = 0;
for (int u = 0; u >= 0;) {
vector<pair<int, int> > &nbru = nbrs[u];
int up = ps[u];
if (cis[u] < nbru.size() && nbru[cis[u]].first == up) cis[u]++;
if (cis[u] < nbru.size()) {
pair<int, int> ue = nbru[cis[u]++];
int v = ue.first;
ps[v] = u;
pcs[v] = ue.second;
u = v;
} else {
vector<pair<int, int> > &mdu = mds[u];
sort(mdu.begin(), mdu.end(), greater<pair<int, int> >());
int l = min((int)mdu.size(), k - 1);
drs[u] = dos[u] = 0;
if (l > 0) {
for (int i = 0; i < l; i++) drs[u] += mdu[i].first;
for (int i = 0; i < mdu.size(); i++) {
int doi = drs[u] + mdu[i].second;
if (mdu[i].first >= mdu[l - 1].first) {
doi -= mdu[i].first;
if (l < mdu.size()) doi += mdu[l].first;
}
if (dos[u] < doi) dos[u] = doi;
}
} else {
for (int i = 0; i < mdu.size(); i++)
if (dos[u] < mdu[i].second) dos[u] = mdu[i].second;
}
if (up >= 0) {
int pc = pcs[u];
mds[up].push_back(pair<int, int>(drs[u] + pc, dos[u] + pc));
}
u = up;
}
}
printf("%d\n", max(drs[0], dos[0]));
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
string d, s;
map<char, int> mp;
int q;
int a, b;
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> d;
for (int i = 0; i < d.size(); i++) mp[d[i]] = true;
cin >> s;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '*') a = true;
if (s[i] == '?') b++;
}
cin >> q;
while (q--) {
string f;
cin >> f;
string l = s;
if (f.size() > s.size() && !a && !b) {
cout << "NO\n";
continue;
}
if (f.size() > s.size() && !a) {
cout << "NO\n";
continue;
}
bool ch = true;
bool c = false;
for (int i = 0; i < l.size(); i++) {
if (f[i] == l[i]) continue;
if (l[i] != '?' && l[i] != '*') {
cout << "NO\n";
ch = false;
break;
}
if (l[i] == '?') {
if (mp[f[i]]) continue;
cout << "NO\n";
ch = false;
break;
} else if (s[i] == '*') {
int x = f.size() - i;
int y = s.size() - i;
int w = x - y;
int z = w;
if (f.size() < s.size()) {
l.erase(i, 1);
i--;
continue;
}
for (int j = 0; j <= z; j++) {
if (mp[f[i + j]]) {
ch = false;
cout << "NO\n";
goto next;
}
}
f.erase(i, z);
}
}
if (ch) cout << "YES\n";
next:;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace ::std;
const int maxn = 1e5 + 500;
const int inf = 1e9 + 900;
int a[maxn];
bool b[maxn];
bool tah[maxn];
bool sar[maxn];
int m;
void solve(int n) {
int tol = n - 1;
for (int i = 0; i < n; i++) {
if (a[i] >= tol) {
a[i] = tol;
}
}
int l = 0;
int r = n - 1;
int minn = n - 1 - a[0];
int maxx = a[n - 1];
if (b[0] || b[n - 1]) {
cout << "YES\n";
return;
}
while (r - l > 1) {
int s = l + 1;
if (s <= maxx) {
l = s;
minn = min(minn, tol - a[s] + s);
if (b[s]) {
cout << "YES\n";
return;
}
continue;
}
s = r - 1;
if (s >= minn) {
r = s;
maxx = max(maxx, s - tol + a[s]);
if (b[s]) {
cout << "YES\n";
return;
}
continue;
}
cout << "NO\n";
return;
}
int jel = -1;
int agh = -1;
for (int i = 0; i <= l; i++) {
if (a[i] == tol) {
jel = i;
}
}
for (int i = n - 1; i >= r; i--) {
if (a[i] == tol) {
agh = i;
}
}
if (jel != -1) {
for (int i = 0; i < jel; i++) {
if (jel - i + a[i] >= tol) {
cout << "YES\n";
return;
}
}
}
if (agh != -1) {
for (int i = agh + 1; i < n; i++) {
if (a[i] + i - agh >= tol) {
cout << "YES\n";
return;
}
}
}
cout << "NO\n";
}
vector<int> ger[maxn];
vector<int> path;
bool vis[maxn];
pair<bool, int> dfss(int v, int p = -1) {
int mxx = 0;
int cnt = 0;
bool good = 0;
for (auto u : ger[v]) {
if (u != p && vis[u] == 0) {
pair<int, int> yu = dfss(u, v);
int y = yu.second + 1;
good |= yu.first;
if (y >= m - 1) {
cnt++;
}
mxx = max(mxx, y);
}
}
if (cnt >= 2) {
good = 1;
}
return make_pair(good, mxx);
}
bool dfs(int v, int b, int p = -1) {
if (v == b) {
path.push_back(v);
return 1;
}
for (auto u : ger[v]) {
if (u != p) {
if (dfs(u, b, v)) {
path.push_back(v);
return 1;
}
}
}
return 0;
}
int main() {
int t;
cin >> t;
while (t--) {
int n, A, B;
cin >> n >> A >> B;
A--;
B--;
path.clear();
for (int i = 0; i < n; i++) {
ger[i].clear();
vis[i] = 0;
}
for (int i = 1; i < n; i++) {
int v, u;
cin >> v >> u;
u--;
v--;
ger[v].push_back(u);
ger[u].push_back(v);
}
dfs(A, B);
m = path.size();
for (auto v : path) {
vis[v] = 1;
}
for (int i = 0; i < path.size(); i++) {
pair<int, int> yu = dfss(path[i]);
a[i] = yu.second;
b[i] = yu.first;
}
int m = path.size();
solve(m);
}
}
| 11 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
template <class c>
struct rge {
c b, e;
};
template <class c>
rge<c> range(c i, c j) {
return {i, j};
}
template <class c>
auto dud(c* x) -> decltype(cerr << *x, 0);
template <class c>
char dud(...);
struct debug {
template <class c>
debug& operator<<(const c&) {
return *this;
}
};
using ld = long double;
using ll = long long;
constexpr int mod = 1000 * 1000 * 1000 + 7;
constexpr int odw2 = (mod + 1) / 2;
void OdejmijOd(int& a, int b) {
a -= b;
if (a < 0) a += mod;
}
int Odejmij(int a, int b) {
OdejmijOd(a, b);
return a;
}
void DodajDo(int& a, int b) {
a += b;
if (a >= mod) a -= mod;
}
int Dodaj(int a, int b) {
DodajDo(a, b);
return a;
}
int Mnoz(int a, int b) { return (ll)a * b % mod; }
void MnozDo(int& a, int b) { a = Mnoz(a, b); }
int Pot(int a, int b) {
int res = 1;
while (b) {
if (b % 2 == 1) MnozDo(res, a);
a = Mnoz(a, a);
b /= 2;
}
return res;
}
int Odw(int a) { return Pot(a, mod - 2); }
void PodzielDo(int& a, int b) { MnozDo(a, Odw(b)); }
int Podziel(int a, int b) { return Mnoz(a, Odw(b)); }
int Moduluj(ll x) {
x %= mod;
if (x < 0) x += mod;
return x;
}
template <typename T>
T Maxi(T& a, T b) {
return a = max(a, b);
}
template <typename T>
T Mini(T& a, T b) {
return a = min(a, b);
}
struct Node {
vector<int> wsp;
vector<int> drz;
void Init() {
sort(wsp.begin(), wsp.end());
wsp.resize(unique(wsp.begin(), wsp.end()) - wsp.begin());
drz.resize(wsp.size() + 1);
}
int Pref(int w) {
w = upper_bound(wsp.begin(), wsp.end(), w) - wsp.begin();
int sum = 0;
while (w > 0) {
sum += drz[w];
w -= (w & (-w));
}
return sum;
}
void Dodaj(int w) {
w = lower_bound(wsp.begin(), wsp.end(), w) - wsp.begin() + 1;
while (w < (int)drz.size()) {
drz[w]++;
w += (w & (-w));
}
}
int Sumuj(int a, int b) { return Pref(b) - Pref(a - 1); }
};
vector<Node> drz;
int X, Y, Z;
int n, m, k;
vector<string> odp;
constexpr int nax = 100 * 1000 + 105;
vector<pair<int, int>> punkty[nax];
vector<pair<int, pair<pair<int, int>, pair<int, int>>>> otw[nax], zam[nax];
vector<int> ys;
vector<int> cnt;
int Pref(int x1, int x2, int y) {
y = upper_bound(ys.begin(), ys.end(), y) - ys.begin();
int sum = 0;
while (y > 0) {
sum += drz[y].Sumuj(x1, x2);
y -= (y & (-y));
}
return sum;
}
int Sumuj(int x1, int x2, int y1, int y2) {
const int res = Pref(x1, x2, y2) - Pref(x1, x2, y1 - 1);
debug() << "Sumuj("
" ["
"x1"
": "
<< (x1)
<< "] "
" ["
"x2"
": "
<< (x2)
<< "] "
" ["
"y1"
": "
<< (y1)
<< "] "
" ["
"y2"
": "
<< (y2)
<< "] "
") = "
<< res;
return res;
}
void Dodaj(int x, int y, bool naprawde) {
debug() << "Dodaj("
" ["
"x"
": "
<< (x)
<< "] "
" ["
"y"
": "
<< (y)
<< "] "
" ["
"naprawde"
": "
<< (naprawde)
<< "] "
")";
y = lower_bound(ys.begin(), ys.end(), y) - ys.begin() + 1;
while (y < (int)drz.size()) {
if (naprawde) {
drz[y].Dodaj(x);
} else {
drz[y].wsp.push_back(x);
}
y += (y & (-y));
}
}
void algos() {
for (int i = 1; i <= Z; i++) {
for (auto& it : punkty[i]) {
ys.push_back(it.second);
}
}
sort(ys.begin(), ys.end());
ys.resize(unique(ys.begin(), ys.end()) - ys.begin());
drz.resize(ys.size() + 1);
debug() << " ["
"ys"
": "
<< (ys) << "] ";
for (int i = 1; i <= Z; i++) {
for (auto& it : punkty[i]) {
Dodaj(it.first, it.second, false);
}
}
for (Node& node : drz) {
node.Init();
}
for (int i = 1; i <= Z; i++) {
for (auto& it : otw[i]) {
cnt[it.first] -= Sumuj(it.second.first.first, it.second.first.second,
it.second.second.first, it.second.second.second);
}
for (auto& it : punkty[i]) {
Dodaj(it.first, it.second, true);
}
for (auto& it : zam[i]) {
cnt[it.first] += Sumuj(it.second.first.first, it.second.first.second,
it.second.second.first, it.second.second.second);
assert(cnt[it.first] >= 0);
if (cnt[it.first] == 0) {
odp[it.first] = "UNKNOWN";
} else {
odp[it.first] = "CLOSED";
}
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> X >> Y >> Z >> n >> m >> k;
int x[2] = {X, 1};
int y[2] = {Y, 1};
int z[2] = {Z, 1};
for (int i = 0; i < n; i++) {
int xx, yy, zz;
cin >> xx >> yy >> zz;
Mini(x[0], xx);
Maxi(x[1], xx);
Mini(y[0], yy);
Maxi(y[1], yy);
Mini(z[0], zz);
Maxi(z[1], zz);
}
for (int i = 0; i < m; i++) {
int xx, yy, zz;
cin >> xx >> yy >> zz;
if (x[0] <= xx and xx <= x[1] and y[0] <= yy and yy <= y[1] and
z[0] <= zz and zz <= z[1]) {
cout << "INCORRECT" << endl;
return 0;
}
punkty[zz].emplace_back(xx, yy);
}
cout << "CORRECT" << endl;
odp.resize(k);
cnt.resize(k);
for (int i = 0; i < k; i++) {
int xx, yy, zz;
cin >> xx >> yy >> zz;
if (x[0] <= xx and xx <= x[1] and y[0] <= yy and yy <= y[1] and
z[0] <= zz and zz <= z[1]) {
odp[i] = "OPEN";
} else {
int xxx[2] = {x[0], x[1]};
int yyy[2] = {y[0], y[1]};
int zzz[2] = {z[0], z[1]};
Mini(xxx[0], xx);
Maxi(xxx[1], xx);
Mini(yyy[0], yy);
Maxi(yyy[1], yy);
Mini(zzz[0], zz);
Maxi(zzz[1], zz);
debug() << " ["
"xxx[0]"
": "
<< (xxx[0])
<< "] "
" ["
"xxx[1]"
": "
<< (xxx[1])
<< "] "
" ["
"yyy[0]"
": "
<< (yyy[0])
<< "] "
" ["
"yyy[1]"
": "
<< (yyy[1])
<< "] "
" ["
"zzz[0]"
": "
<< (zzz[0])
<< "] "
" ["
"zzz[1]"
": "
<< (zzz[1]) << "] ";
otw[zzz[0]].emplace_back(
i, make_pair(make_pair(xxx[0], xxx[1]), make_pair(yyy[0], yyy[1])));
zam[zzz[1]].emplace_back(
i, make_pair(make_pair(xxx[0], xxx[1]), make_pair(yyy[0], yyy[1])));
}
}
algos();
for (int i = 0; i < k; i++) {
cout << odp[i] << '\n';
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int MOD = 998244353;
int f[300001];
int pow(int n, int i) {
int a = n, ans = 1;
while (i > 0) {
if (i & 1) {
ans = (ans * 1LL * a) % MOD;
}
a = (a * 1LL * a) % MOD;
i = i >> 1;
}
return ans;
}
void dfs_visit(map<string, vector<string>> adj, map<string, int>& col,
string s) {
col[s] = 1;
for (auto u : adj[s]) {
if (col[u] == 0) {
dfs_visit(adj, col, u);
}
}
}
int dfs_helper(map<string, vector<string>> adj, map<string, int>& col) {
int conn = 0;
for (auto u : adj) {
if (col[u.first] == 0) {
conn++;
dfs_visit(adj, col, u.first);
}
}
return conn;
}
int inv(int n) { return pow(n, MOD - 2); }
int nCr(int n, int r) {
if (r > n)
return 0;
else {
int res = f[n];
res = (res * 1LL * inv(f[r])) % MOD;
res = (res * 1LL * inv(f[n - r])) % MOD;
return res;
}
}
bool exists(string s, string b) {
int n = s.length(), t = b.length();
if (t > n) return false;
for (int i = 0; i < (int)(n - t + 1); ++i) {
if (s.substr(i, t) == b) return true;
}
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int q;
string s, t, a, b = "";
cin >> q;
while (q--) {
cin >> s >> t;
int n = t.length();
int f = 0;
for (int i = 0; i < (int)(n); ++i) {
a = t.substr(i + 1, min(i, n - 1 - i));
reverse((a).begin(), (a).end());
if (t.substr(i - min(i, n - 1 - i), a.length()) == a) {
b = i < n - 1 - i ? t.substr(2 * i + 1) : "";
reverse((b).begin(), (b).end());
b += t.substr(0, i + 1);
if (exists(s, b)) {
cout << "YES"
<< "\n";
f = 1;
break;
}
}
}
if (f == 0)
cout << "NO"
<< "\n";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class P, class Q>
ostream& operator<<(ostream& stream, pair<P, Q> v) {
stream << "(" << v.first << ',' << v.second << ")";
return stream;
}
template <class T>
ostream& operator<<(ostream& stream, const vector<T> v) {
stream << "[ ";
for (int i = 0; i < (int)v.size(); i++) stream << v[i] << " ";
stream << "]";
return stream;
}
template <class T>
T smin(T& a, T b) {
if (a > b) a = b;
return a;
}
template <class T>
T smax(T& a, T b) {
if (a < b) a = b;
return a;
}
inline int readChar();
template <class T = int>
inline T readInt();
template <class T>
inline void writeInt(T x, char end = 0);
inline void writeChar(int x);
inline void writeWord(const char* s);
static const int buf_size = 4096;
inline int getChar() {
static char buf[buf_size];
static int len = 0, pos = 0;
if (pos == len) pos = 0, len = fread(buf, 1, buf_size, stdin);
if (pos == len) return -1;
return buf[pos++];
}
inline int readChar() {
int c = getChar();
while (c <= 32) c = getChar();
return c;
}
template <class T>
inline T readInt() {
int s = 1, c = readChar();
T x = 0;
if (c == '-') s = -1, c = getChar();
while ('0' <= c && c <= '9') x = x * 10 + c - '0', c = getChar();
return s == 1 ? x : -x;
}
static int write_pos = 0;
static char write_buf[buf_size];
inline void writeChar(int x) {
if (write_pos == buf_size)
fwrite(write_buf, 1, buf_size, stdout), write_pos = 0;
write_buf[write_pos++] = x;
}
template <class T>
inline void writeInt(T x, char end) {
if (x < 0) writeChar('-'), x = -x;
char s[24];
int n = 0;
while (x || !n) s[n++] = '0' + x % 10, x /= 10;
while (n--) writeChar(s[n]);
if (end) writeChar(end);
}
inline void writeWord(const char* s) {
while (*s) writeChar(*s++);
}
struct Flusher {
~Flusher() {
if (write_pos) fwrite(write_buf, 1, write_pos, stdout), write_pos = 0;
}
} flusher;
const int N = 1e5 + 5;
int s[N];
int gcd(int a, int b) { return !b ? a : gcd(b, a % b); }
int was[N];
int p[N];
int main(void) {
int n;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
n = readInt();
for (int i = 1; i <= n; ++i) s[i] = readInt(), p[i] = i;
while (clock() < 0.1 * CLOCKS_PER_SEC) {
shuffle(p + 1, p + 1 + n, rng);
int cnt = s[p[1]];
int g = 0;
was[p[1]] = 2;
for (int i = 2; i <= n; ++i) {
int gg = gcd(s[p[i]], cnt);
if (gg == cnt) {
was[p[i]] = 1;
g = gcd(g, s[p[i]]);
} else {
cnt = gg;
was[p[i]] = 2;
}
}
if (cnt == 1 && g == 1) {
writeChar('Y');
writeChar('E');
writeChar('S');
writeChar('\n');
for (int i = 1; i <= n; ++i) {
writeInt(was[i], " \n"[i == n]);
}
return 0;
}
}
puts("NO");
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
void MAIN();
int main() {
MAIN();
return 0;
}
const long long N = 1e6 + 1, mod = 1e9 + 7;
struct ii {
long long first;
long long second;
int id;
};
bool cmp(ii v, ii u) {
if (u.first == v.first) return u.second < v.second;
return u.first < v.first;
}
long long ccw(ii u, ii v) { return u.first * v.second - v.first * u.second; }
ii operator-(ii u, ii v) {
v.first -= u.first;
v.second -= u.second;
return v;
}
ii s[N], x[N];
int ns, nx;
struct polygon {
vector<ii> ver;
vector<ii> graham() {
vector<ii> result;
sort(ver.begin(), ver.end(), cmp);
s[++ns] = ver[0];
for (int i = 1; i < ver.size(); ++i) {
while (ns > 1) {
ii u = s[ns] - s[ns - 1];
ii v = ver[i] - s[ns - 1];
if (ccw(u, v) > 0)
--ns;
else
break;
}
s[++ns] = ver[i];
}
x[++nx] = s[ns];
for (int i = ver.size() - 1; i >= 0; --i) {
while (nx > 1) {
ii u = x[nx] - x[nx - 1];
ii v = ver[i] - x[nx - 1];
if (ccw(u, v) > 0)
--nx;
else
break;
}
x[++nx] = ver[i];
}
for (int i = 1; i <= ns; ++i) result.push_back(s[i]);
for (int i = 1; i <= nx; ++i) result.push_back(x[i]);
return result;
}
} p;
int n, m;
vector<ii> cur;
void MAIN() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
int u, v;
scanf("%d%d", &u, &v);
p.ver.push_back({u, v, 1});
}
scanf("%d", &m);
for (int i = 1; i <= m; ++i) {
int u, v;
scanf("%d%d", &u, &v);
p.ver.push_back({u, v, 0});
}
cur = p.graham();
for (int i = 0; i < cur.size(); ++i)
if (cur[i].id == 0) {
puts("NO");
return;
}
puts("YES");
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long exponentiation(long long base, long long exp) {
if (exp == 0) return 1;
if (exp == 1) return base % 1000000009;
long long t = exponentiation(base, exp / 2);
t = (t * t) % 1000000009;
if (exp % 2 == 0)
return t;
else
return ((base % 1000000009) * t) % 1000000009;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, m, k;
cin >> n >> m >> k;
if (m < k)
cout << m;
else {
long long tn = n - n % k, tm = m - n % k;
long long grps = n / k;
tm = (tm - grps * (k - 1));
if (tm <= 0)
cout << m;
else {
long long ans =
(((exponentiation(2, tm + 1) - 2 + 1000000009) % 1000000009) * k %
1000000009 +
(m - tm * k)) %
1000000009;
cout << ans;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, i, x, y, c = 0, d = 0;
cin >> n;
vector<long long int> v(n);
for (i = 0; i < n; i++) cin >> v[i];
sort(v.begin(), v.end());
x = v[0];
y = v[n - 1];
for (i = 0; i < n; i++) {
if (v[i] == x) c++;
if (v[i] == y) d++;
}
cout << y - x << " ";
if (x == y)
cout << n * (n - 1) / 2;
else
cout << c * d;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 60;
const double inf = 1e14;
double dp[N][N];
int n;
struct nd {
int v, w;
double c;
} a[N];
bool cmp(nd x, nd y) { return x.v > y.v; }
bool cmp2(nd x, nd y) { return x.c < y.c; }
bool check(double mid) {
int i, j, k, p;
double sum;
for (i = 1; i <= n; i++) a[i].c = (double)a[i].v - (double)a[i].w * mid;
int top = 0;
dp[0][0] = 0;
for (i = 1; i <= n; i++) dp[0][i] = inf;
for (i = 1; i <= n; i = j + 1) {
j = i;
while ((j < n) && (a[j + 1].v == a[i].v)) j++;
sort(a + i, a + j + 1, cmp2);
top++;
for (k = 0; k <= n; k++) dp[top][k] = inf;
for (k = 0; k < i; k++) {
sum = 0;
for (p = i; p <= j; p++) {
if (k >= j - p + 1)
dp[top][k + 2 * p - i - j - 1] =
min(dp[top][k + 2 * p - i - j - 1], dp[top - 1][k] + sum);
sum += a[p].c;
}
dp[top][k + j - i + 1] =
min(dp[top][k + j - i + 1], dp[top - 1][k] + sum);
}
}
for (i = 0; i <= n; i++)
if (dp[top][i] <= 0) return 1;
return 0;
}
int main() {
int i, j, k;
double l, r, mid;
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d", &a[i].v);
for (i = 1; i <= n; i++) scanf("%d", &a[i].w);
sort(a + 1, a + n + 1, cmp);
l = 0;
r = 100000000.0;
while (r - l > 3e-7) {
mid = (l + r) / 2.0;
if (check(mid))
r = mid;
else
l = mid;
}
long long ans = (long long)(((l + r) * 500) + 0.999);
printf("%I64d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 502;
int n, m, k;
int maze[MAX][MAX];
void traverseGraph(int x, int y) {
maze[x][y] = 2;
if (maze[x][y + 1] == 1) traverseGraph(x, y + 1);
if (maze[x][y - 1] == 1) traverseGraph(x, y - 1);
if (maze[x + 1][y] == 1) traverseGraph(x + 1, y);
if (maze[x - 1][y] == 1) traverseGraph(x - 1, y);
if (k > 0) maze[x][y] = -1, k--;
}
void findGraphs() {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (maze[i][j] == 1) traverseGraph(i, j);
}
}
}
void findConnectedNode(int x, int y, int& nx, int& ny) {
if (maze[x][y + 1] == 2) nx = x, ny = y + 1;
if (maze[x][y - 1] == 2) nx = x, ny = y - 1;
if (maze[x + 1][y] == 2) nx = x + 1, ny = y;
if (maze[x - 1][y] == 2) nx = x - 1, ny = y;
}
int main() {
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
char c;
cin >> c;
if (c == '.') maze[i][j] = 1;
}
}
findGraphs();
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (maze[i][j] == 0)
cout << "#";
else if (maze[i][j] == -1)
cout << "X";
else
cout << ".";
}
cout << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int count_symbol(const vector<string>& Board, char c) {
int result = 0;
for (int i = 0; i < 3; ++i) {
for (int j = 0; j < 3; ++j) {
if (Board[i][j] == c) {
++result;
}
}
}
return result;
}
bool all_is_symbol(char c1, char c2, char c3, char c) {
if ((c1 == c) && (c2 == c) && (c3 == c)) {
return true;
} else {
return false;
}
}
bool first_player_won(const vector<string>& Board) {
if (all_is_symbol(Board[0][0], Board[0][1], Board[0][2], 'X') ||
all_is_symbol(Board[1][0], Board[1][1], Board[1][2], 'X') ||
all_is_symbol(Board[2][0], Board[2][1], Board[2][2], 'X') ||
all_is_symbol(Board[0][0], Board[1][0], Board[2][0], 'X') ||
all_is_symbol(Board[0][1], Board[1][1], Board[2][1], 'X') ||
all_is_symbol(Board[0][2], Board[1][2], Board[2][2], 'X') ||
all_is_symbol(Board[0][0], Board[1][1], Board[2][2], 'X') ||
all_is_symbol(Board[0][2], Board[1][1], Board[2][0], 'X')) {
return true;
}
return false;
}
bool second_player_won(const vector<string>& Board) {
if (all_is_symbol(Board[0][0], Board[0][1], Board[0][2], '0') ||
all_is_symbol(Board[1][0], Board[1][1], Board[1][2], '0') ||
all_is_symbol(Board[2][0], Board[2][1], Board[2][2], '0') ||
all_is_symbol(Board[0][0], Board[1][0], Board[2][0], '0') ||
all_is_symbol(Board[0][1], Board[1][1], Board[2][1], '0') ||
all_is_symbol(Board[0][2], Board[1][2], Board[2][2], '0') ||
all_is_symbol(Board[0][0], Board[1][1], Board[2][2], '0') ||
all_is_symbol(Board[0][2], Board[1][1], Board[2][0], '0')) {
return true;
}
return false;
}
bool illegal(const vector<string>& Board) {
if (first_player_won(Board) && second_player_won(Board)) {
return true;
}
if (first_player_won(Board) &&
!(count_symbol(Board, 'X') == count_symbol(Board, '0') + 1)) {
return true;
}
if ((second_player_won(Board) &&
!(count_symbol(Board, 'X') == count_symbol(Board, '0')))) {
return true;
}
int q_X = count_symbol(Board, 'X');
int q_0 = count_symbol(Board, '0');
if ((q_X == q_0) || (q_X == q_0 + 1)) {
return false;
} else {
return true;
}
}
int main(int argc, char** argv) {
vector<string> Board;
for (int i = 0; i < 3; ++i) {
string temp;
cin >> temp;
Board.push_back(temp);
}
if (illegal(Board)) {
cout << "illegal" << endl;
} else if (first_player_won(Board)) {
cout << "the first player won" << endl;
} else if (second_player_won(Board)) {
cout << "the second player won" << endl;
} else if (count_symbol(Board, '.') == 0) {
cout << "draw" << endl;
} else if (count_symbol(Board, 'X') == count_symbol(Board, '0')) {
cout << "first" << endl;
} else if (count_symbol(Board, 'X') == count_symbol(Board, '0') + 1) {
cout << "second" << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
int main() {
long long int n, a = 0, b = 0, c = 0, i;
scanf("%I64d", &n);
for (i = 1; i <= n; i++) {
if (i % 3 != 0) {
a = i;
if (n > 2 * i) {
b = i;
if ((n - 2 * i) % 3 != 0) {
c = n - 2 * i;
break;
}
}
}
}
printf("%I64d %I64d %I64d", a, b, c);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int mo = 1000000007;
int POW(int a, int b) {
int ans = 1;
for (; b; b >>= 1, a = (long long int)a * a % mo)
if (b & 1) ans = (long long int)ans * a % mo;
return ans;
}
const int maxn = 3033333;
static int fac[maxn];
inline int combo(int n, int m) {
return (long long int)fac[n] *
POW((long long int)fac[m] * fac[n - m] % mo, mo - 2) % mo;
}
int main() {
int n;
scanf("%d", &n);
fac[0] = 1;
for (int i = 1; i < maxn; ++i) fac[i] = (long long int)fac[i - 1] * i % mo;
printf("%d\n", (2 * combo(2 * n + 1, n + 1) % mo + (mo - 1)) % mo);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
long long mp[5][N];
long long sum_up[N], sum_down[N];
struct node {
long long up, down;
long long ma;
} mpp[N];
int main() {
int t;
cin >> t;
while (t--) {
memset(mpp, 0, sizeof mpp);
long long m;
cin >> m;
for (int i = 1; i <= 2; i++) {
for (int j = 1; j <= m; j++) {
cin >> mp[i][j];
}
}
for (int i = 1; i <= m; i++) {
sum_up[i] = sum_up[i - 1] + mp[1][i];
}
for (int i = 1; i <= m; i++) {
sum_down[i] = sum_down[i - 1] + mp[2][i];
}
for (int i = 1; i <= m; i++) {
mpp[i].up = sum_up[m] - sum_up[i];
mpp[i].down = sum_down[i - 1];
mpp[i].ma = max(mpp[i].down, mpp[i].up);
}
long long res = 1e9;
for (int i = 1; i <= m; i++) {
res = min(res, mpp[i].ma);
}
if (m == 1) res = 0;
cout << res << '\n';
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long T;
cin >> T;
while (T--) {
long long n, k;
cin >> n >> k;
vector<long long> a(n);
for (long long i = 0; i < n; i++) cin >> a[i];
sort(a.begin(), a.end());
long long sum = 0;
long long i = n - 1;
long long j = n - k - 1;
while (k > 0) {
sum = sum + a[j] / a[i];
a[j] = 0;
a[i] = 0;
i--;
j--;
k--;
}
for (long long i = 0; i < n; i++) sum = sum + a[i];
cout << sum << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
vector<int> a(n + 1);
vector<int> pr(n + 1);
for (int i = 1; i <= n; i++) {
cin >> a[i];
pr[i] = pr[i - 1] | a[i];
}
vector<int> sf(n + 2);
for (int i = n; i >= 1; i--) {
sf[i] = sf[i + 1] | a[i];
};
int ans = -1;
int pos = -1;
for (int i = 1; i <= n; i++) {
int cur = a[i] & ~(pr[i - 1] | sf[i + 1]);
if (cur > ans) {
ans = cur;
pos = i;
};
}
assert(pos != -1);
swap(a[1], a[pos]);
for (int i = 1; i <= n; i++) {
cout << a[i] << (i == n ? '\n' : ' ');
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1ll << 32;
long long bigmod(long long a, int p, long long int m) {
if (p == 0) return 1;
if (p & 1) {
return ((a % m) * (bigmod(a, p - 1, m))) % m;
} else {
long long tmp = bigmod(a, p / 2, m);
return (tmp * tmp) % m;
}
}
long long int arr[100005][61];
void dec(unsigned long long int n, long long int j) {
for (int i = 60; i >= 0; i--) {
long long int k = n >> i;
if (k & 1)
arr[j][i] = 1;
else
arr[j][i] = 0;
}
}
vector<long long int> vz;
long long int SieveOfEratosthenes(long long int n) {
bool prime[n + 1];
memset(prime, true, sizeof(prime));
for (long long int p = 2; p * p <= n; p++) {
if (prime[p] == true) {
for (long long int i = p * p; i <= n; i += p) prime[i] = false;
}
}
for (long long int p = 2; p <= n; p++)
if (prime[p]) vz.push_back(p);
}
long long int n, x, l, k, a[200], d[200];
long long int solve(long long int t, long long int i, long long int ct) {
if (i == -1)
return 0;
else if (i == n)
return 1;
else if (ct > 10000)
return 0;
else {
if (a[i] + d[t % x] <= l)
return solve(t + 1, i + 1, ct + 1);
else
solve(t, i - 1, ct + 1);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int chu;
cin >> chu;
while (chu--) {
cin >> n >> k >> l;
long long int i;
long long int mx = 0;
for (long long int i = 0; i < n; i++) {
cin >> a[i];
mx = max(mx, a[i]);
}
if (mx + k <= l) {
cout << "Yes";
cout << "\n";
continue;
}
d[0] = 0;
for (i = 1; i < 2 * k; i++) {
if (i > k)
d[i] = d[i - 1] - 1;
else
d[i] = d[i - 1] + 1;
}
x = 2 * k;
long long int j = 0, y = 0;
for (i = 0; i < x; i++) {
long long int ct = 0;
y = solve(i + 1, 0, ct);
if (y == 1) break;
}
if (y)
cout << "Yes";
else
cout << "No";
cout << "\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e7;
const int MOD = 1e9 + 7;
int n, m, k, sz[1005] = {0}, cnt, cnt2, sz2[1005] = {0};
vector<vector<int> > adjlist;
bool gov[1005] = {0}, vis[1005] = {0};
void dfs(int u) {
cnt++;
vis[u] = 1;
for (int i = 0; i < ((int)(adjlist[u]).size()); i++) {
int v = adjlist[u][i];
cnt2++;
if (!vis[v]) dfs(v);
}
}
int main() {
scanf("%d %d %d", &n, &m, &k);
for (int i = 0; i < k; i++) {
int x;
scanf("%d", &x);
gov[x - 1] = 1;
}
adjlist.assign(n, vector<int>());
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d %d", &u, &v);
u--;
v--;
adjlist[u].push_back(v);
adjlist[v].push_back(u);
}
for (int i = 0; i < n; i++)
if (gov[i]) {
cnt = cnt2 = 0;
dfs(i);
sz[i] = cnt;
sz2[i] = cnt2 / 2;
}
int unused = 0, cnt3 = 0;
for (int i = 0; i < n; i++)
if (!vis[i]) {
unused++;
cnt3 += ((int)(adjlist[i]).size());
}
cnt3 /= 2;
int mx = 0, where;
for (int i = 0; i < n; i++)
if (gov[i]) {
int x = sz[i] + unused;
if (mx < (x * (x - 1)) / 2 - sz2[i] - cnt3) {
mx = (x * (x - 1)) / 2 - sz2[i] - cnt3;
where = i;
}
}
int ans = mx;
for (int i = 0; i < n; i++) {
if (i == where) continue;
if (!gov[i]) continue;
int x = sz[i];
ans += (x * (x - 1)) / 2 - sz2[i];
}
printf("%d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
vector<int> v[400005];
int main() {
scanf("%d %d", &n, &k);
for (int i = (0); i < (k); i++) {
int m;
scanf("%d", &m);
v[i].resize(m);
for (int &x : v[i]) scanf("%d", &x);
}
int res = 0;
for (int i = (0); i < (k); i++) {
int li = int(v[i].size());
for (int j = int(v[i].size()) - 2; j >= 0; j--) {
if (v[i][j + 1] - v[i][j] > 1) {
li = j + 1;
}
}
while (int(v[i].size()) > li) {
v[k].push_back(v[i].back());
v[i].pop_back();
res++;
k++;
}
}
for (int i = (0); i < (k); i++)
if (v[i][0] != 1) res += 2 * int(v[i].size()) - 1;
printf("%d\n", res);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5;
const double pi = acos(-1.0);
struct Point {
double x, y;
void Scan() { scanf("%lf %lf", &x, &y); }
} ver[MAXN + 5];
struct msg {
double ang;
int v;
bool operator==(const msg &a) { return ang == a.ang && v == a.v; }
void Print() { printf("%.7lf %d\n", ang, v); }
} ope[4 * MAXN + 5];
int Tail;
int n, K;
bool cmp(msg a, msg b) { return (a.ang == b.ang ? a.v > b.v : a.ang < b.ang); }
double len(Point a) { return sqrt(a.x * a.x + a.y * a.y); }
int Check(double r) {
int sum = 0;
Tail = 0;
for (int i = 1; i <= n; i++) {
if (ver[i].x == 0 && ver[i].y == 0) {
++sum;
continue;
}
double d = len(ver[i]);
if (d > 2 * r) continue;
double theta = acos(d / (2 * r));
double delta = atan2(ver[i].y, ver[i].x);
double L = delta - theta, R = delta + theta;
if (L < 0) {
L += 2 * pi;
R += 2 * pi;
}
if (R <= 2 * pi) {
ope[++Tail] = msg{L, 1};
ope[++Tail] = msg{R, -1};
} else {
ope[++Tail] = msg{L, 1};
ope[++Tail] = msg{2 * pi, -1};
ope[++Tail] = msg{0, 1};
ope[++Tail] = msg{R - 2 * pi, -1};
}
}
sort(ope + 1, ope + Tail + 1, cmp);
int ret = sum;
for (int i = 1; i <= Tail; i++) {
sum += ope[i].v;
ret = max(ret, sum);
}
return ret;
}
int main() {
scanf("%d %d", &n, &K);
for (int i = 1; i <= n; i++) ver[i].Scan();
double L = 0, R = 2e5;
for (double mid; R - L > 1e-8;) {
mid = (L + R) / 2.0;
if (Check(mid) >= K)
R = mid;
else
L = mid;
}
printf("%.7lf\n", R);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000007;
const int MOD = 1000000007;
const int nmax = 201234;
int n, k, a[nmax], cnt[2][nmax], res;
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
sort(a, a + n);
for (int i = 0; i < n; ++i) {
int b = a[i];
int cnt2 = 0;
while (b) {
if (cnt[0][b] < k) {
cnt[0][b]++;
cnt[1][b] += cnt2;
}
b >>= 1;
cnt2++;
}
}
res = INF;
for (int i = 0; i <= 200000; i++)
if (cnt[0][i] == k && cnt[1][i] < res) res = cnt[1][i];
printf("%d\n", res);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using std::priority_queue;
struct node {
int n;
long long ans;
node(int n, long long ans) {
this->n = n;
this->ans = ans;
}
friend bool operator<(node a, node b) { return a.ans > b.ans; }
};
int money[3011][3010];
int cnt[3010];
int main() {
int n, m, u, v;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &u, &v);
money[u][++money[u][0]] = v;
}
for (int i = 1; i <= m; i++)
std::sort(money[i] + 1, money[i] + 1 + money[i][0]);
long long ans = 1000000000000001ll;
for (int mid = 1; mid <= (n + 1 >> 1); mid++) {
priority_queue<node> q;
long long sum = 0, now = money[1][0];
for (int i = 2; i <= m; i++) {
for (int j = 1; j <= money[i][0] - mid + 1; j++) {
sum += money[i][j];
++now;
}
cnt[i] = std::max(0, money[i][0] - mid + 1);
if (cnt[i] < money[i][0]) {
cnt[i]++;
q.push(node(i, money[i][cnt[i]]));
}
}
for (int i = now + 1; i <= mid; i++) {
if (q.empty()) break;
node k = q.top();
q.pop();
sum += k.ans;
if (cnt[k.n] < money[k.n][0]) q.push(node(k.n, money[k.n][++cnt[k.n]]));
}
ans = ans < sum ? ans : sum;
}
printf("%I64d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
const int inf = 0x3f3f3f3f;
const int mod = 1e9 + 7;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long n, m, t;
char a[107][57];
vector<pair<int, int>> v;
int main() {
int cnt = -1;
scanf("%lld%lld", &n, &m);
scanf("%s", a[1]);
bool f = 0;
for (int j = 0; j <= m / 2; ++j) {
if (a[1][j] != a[1][m - 1 - j]) {
f = 1;
break;
}
}
if (!f) {
cnt = 1;
}
for (int i = 2; i <= n; ++i) {
scanf("%s", a[i]);
for (int j = i - 1; j > 0; --j) {
f = 0;
for (int k = 0; k < m; ++k) {
if (a[i][k] != a[j][m - 1 - k]) {
f = 1;
break;
}
}
if (f == 0) {
v.push_back(make_pair(i, j));
break;
}
}
if ((f && cnt == -1)) {
for (int j = 0; j <= m / 2; ++j) {
if (a[i][j] != a[i][m - 1 - j]) {
f = 0;
break;
}
}
if (f) {
cnt = i;
}
}
}
long long ans = v.size() * 2 * m;
if (cnt != -1) ans += m;
printf("%lld\n", ans);
for (int i = 0; i < v.size(); ++i) {
printf("%s", a[v[i].first]);
}
if (cnt != -1) printf("%s", a[cnt]);
for (int i = v.size() - 1; i >= 0; --i) {
printf("%s", a[v[i].second]);
}
printf("\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double x1, y1, x2, y2, xn, yn;
double wx1, wy1, wx2, wy2;
double v, t, m, d;
cin >> x1 >> y1 >> x2 >> y2;
cin >> v >> t;
cin >> wx1 >> wy1;
cin >> wx2 >> wy2;
double l = 0, r = 1e18, eps = 1e-9;
while (r - l > eps) {
m = (l + r) / 2;
if (m <= t) {
xn = x1 + (wx1 * m);
yn = y1 + (wy1 * m);
} else {
xn = x1 + (wx1 * t);
xn += (wx2 * (m - t));
yn = y1 + (wy1 * t);
yn += (wy2 * (m - t));
}
d = sqrt((y2 - yn) * (y2 - yn) + (x2 - xn) * (x2 - xn));
if (v * m < d)
l = m;
else
r = m;
}
cout.precision(9);
cout << fixed << l;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long a, b, c, d, e, sum;
int main() {
cin >> a >> b >> c >> d >> e;
while (a >= 1 && b >= 1 && c >= 2 && d >= 7 && e >= 4) {
sum++;
a -= 1;
b -= 1;
c -= 2;
d -= 7;
e -= 4;
}
cout << sum;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
namespace RenaMoe {
const int N = (1 << 17) + 5;
const int M = 1e6 + 5;
const int P = 1e9 + 7;
const int inv2 = (P + 1) >> 1;
inline void FWT_or(int *f, int n, int op) {
for (int mid = 1; mid < n; mid <<= 1)
for (int i = 0; i < n; i += mid << 1)
for (int j = 0; j < mid; ++j) {
if (op == 1)
f[i + mid + j] += f[i + j];
else
f[i + mid + j] += P - f[i + j];
f[i + mid + j] %= P;
}
}
inline void FWT_and(int *f, int n, int op) {
for (int mid = 1; mid < n; mid <<= 1)
for (int i = 0; i < n; i += mid << 1)
for (int j = 0; j < mid; ++j) {
if (op == 1)
f[i + j] += f[i + mid + j];
else
f[i + j] += P - f[i + mid + j];
f[i + j] %= P;
}
}
inline void FWT_xor(int *f, int n, int op) {
for (int mid = 1; mid << 1 <= n; mid <<= 1)
for (int i = 0; i < n; i += mid << 1)
for (int j = 0; j < mid; ++j) {
int x = f[i + j], y = f[i + mid + j];
f[i + j] = (x + y) % P;
f[i + mid + j] = (x - y + P) % P;
if (op == -1) {
f[i + j] = (long long)f[i + j] * inv2 % P;
f[i + mid + j] = (long long)f[i + mid + j] * inv2 % P;
}
}
}
int sn, n;
int s[M], cnt[N], a[18][N], aa[18][N], b[N], f1[N], f2[N], f3[N], fib[N];
inline void main() {
cin >> sn;
for (int i = 1; i <= sn; ++i) cin >> s[i];
n = 1 << 17;
for (int i = 1; i < n; ++i) cnt[i] = cnt[i >> 1] + (i & 1);
fib[1] = 1;
for (int i = 2; i < n; ++i) fib[i] = (fib[i - 1] + fib[i - 2]) % P;
for (int i = 1; i <= sn; ++i) ++a[cnt[s[i]]][s[i]];
for (int i = 0; i <= 17; ++i) FWT_or(a[i], n, 1);
for (int i = 0; i < n; ++i) {
for (int j = 0; j <= 17; ++j)
for (int k = 0; j + k <= 17; ++k)
aa[j + k][i] = (aa[j + k][i] + (long long)a[j][i] * a[k][i]) % P;
}
for (int i = 0; i <= 17; ++i) FWT_or(aa[i], n, -1);
for (int i = 0; i < n; ++i) f1[i] = (long long)fib[i] * aa[cnt[i]][i] % P;
for (int i = 1; i <= sn; ++i) ++b[s[i]];
for (int i = 0; i < n; ++i) f2[i] = (long long)fib[i] * b[i] % P;
FWT_xor(b, n, 1);
for (int i = 0; i < n; ++i) b[i] = (long long)b[i] * b[i] % P;
FWT_xor(b, n, -1);
for (int i = 0; i < n; ++i) f3[i] = (long long)fib[i] * b[i] % P;
FWT_and(f1, n, 1), FWT_and(f2, n, 1), FWT_and(f3, n, 1);
for (int i = 0; i < n; ++i) f1[i] = (long long)f1[i] * f2[i] % P * f3[i] % P;
FWT_and(f1, n, -1);
int ans = 0;
for (int i = 0; i < 17; ++i) ans = (ans + f1[1 << i]) % P;
cout << ans << endl;
}
} // namespace RenaMoe
int main() {
ios::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
RenaMoe::main();
cout.flush();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int read() {
int x = 0, sgn = 1;
char ch = getchar();
for (; !isdigit(ch); ch = getchar())
if (ch == '-') sgn = -1;
for (; isdigit(ch); ch = getchar()) x = (x << 1) + (x << 3) + (ch ^ 48);
return x * sgn;
}
const int N = 3e5 + 10;
int x[N], y[N], a[N], b[N], n;
long long ans;
bool fl1, fl2, fl3;
int main() {
n = read();
for (int i = 1; i <= n; i++) x[i] = a[i] = read(), y[i] = b[i] = read();
sort(a + 1, a + n + 1);
sort(b + 1, b + n + 1);
int mid = n + 1 >> 1;
int dx = a[mid + 1] - a[mid], dy = b[mid + 1] - b[mid];
if (n & 1)
dx = min(dx, a[mid] - a[mid - 1]), dy = min(dy, b[mid] - b[mid - 1]);
for (int i = 1; i <= n; i++)
ans += (long long)abs(x[i] - a[mid]) + abs(y[i] - b[mid]);
for (int i = 1; i <= n; i++) {
if (x[i] == a[mid] && y[i] == b[mid]) fl1 = 1;
if (x[i] > a[mid] && y[i] <= b[mid]) fl2 = 1;
if (x[i] > a[mid] && y[i] > b[mid]) fl3 = 1;
}
if (((n % 2 == 0) || fl1) && fl2 && fl3) ans = ans - min(dx, dy);
ans <<= 1;
printf("%lld\n", ans);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int a[100005];
map<int, int> l, r;
int main() {
scanf("%d%d", &n, &m);
if (n == 1) return printf("0\n"), 0;
for (int i = 1; i <= m; i++) scanf("%d", &a[i]);
for (int i = m; i >= 1; i--) {
l[a[i] + i] = l[a[i] + i + 1] + 1;
r[a[i] - i] = r[a[i] - i - 1] + 1;
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
long long nl = max(1, i - m - 1 + l[i]);
long long nr = min(n, i + m + 1 - r[i]);
ans += (nr - nl + 1);
}
printf("%lld\n", ans);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
static const int MAXN = 1e5 + 10;
int n;
int sum;
int a[MAXN];
map<int, int> mp;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
char x;
scanf(" %c", &x);
if (x - 48)
++sum;
else
--sum;
a[i] = sum;
if (!mp[sum]) mp[sum] = i;
}
mp[0] = 0;
int ans = 0;
for (int i = 1; i <= n; ++i) {
ans = max(ans, i - mp[a[i]]);
}
printf("%d\n", ans);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 10;
long long n, k, tmp, su[MAXN], num[MAXN], h[MAXN];
vector<int> Mat[MAXN];
long long ans;
bool cs[MAXN];
void dfs(int v, int p) {
h[v] = h[p] + 1;
for (int i = 0; i < Mat[v].size(); i++)
if (Mat[v][i] != p) {
dfs(Mat[v][i], v);
num[v] += num[Mat[v][i]];
su[v] += su[Mat[v][i]] + num[Mat[v][i]];
}
if (cs[v]) num[v]++;
}
void fans(int v, int p, int r) {
long long all = num[v] - r, u = 0;
all /= 2;
for (int i = 0; i < Mat[v].size(); i++)
if (Mat[v][i] != p)
if (num[Mat[v][i]] > all) {
u = Mat[v][i];
break;
}
if (u != 0 && num[u] - r > all) {
ans += su[v] - su[u] - num[u];
ans -= (num[v] - num[u]) * h[v];
fans(u, v, r + (num[v] - num[u]));
} else
ans += su[v] + r * h[v];
}
int main() {
cin >> n >> k;
for (int i = 0; i < 2 * k; i++) cin >> tmp, cs[tmp] = true;
for (int i = 0; i < n - 1; i++) {
int v, u;
cin >> v >> u;
Mat[u].push_back(v);
Mat[v].push_back(u);
}
h[1] = -1;
dfs(1, 1);
fans(1, 1, 0);
cout << ans;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct xx {
int x, w;
} a[200010];
int ans = 0;
bool cmp(xx a, xx b) { return a.x < b.x; }
int q[200010], f[200010];
void insertk(int h, int v) {
q[v] = min(q[v], h);
while (q[v - 1] > h) {
q[v - 1] = h;
v--;
}
}
int getk(int x) {
int l = 1, r = ans;
while (l < r) {
int mid = l + r + 1 >> 1;
if (q[mid] <= x)
l = mid;
else
r = mid - 1;
}
return l;
}
int main() {
int n;
cin >> n;
memset(q, 0x3f, n * 4);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &a[i].x, &a[i].w);
}
sort(a + 1, a + n + 1, cmp);
for (int i = 1; i <= n; i++) {
int x = a[i].x - a[i].w;
int k = getk(x);
if (ans == 0 || x < q[k])
f[i] = 1;
else
f[i] = k + 1;
ans = max(ans, f[i]);
insertk(a[i].x + a[i].w, f[i]);
}
cout << ans << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const int INF = 0x3f3f3f3f;
const double PI = acos(-1);
const double EPS = 1e-8;
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, 1, 0, -1};
template <class T>
T sqr(T a) {
return a * a;
}
template <class T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
template <class T>
T mod(T a, T b) {
T ret = a % b;
if (ret < 0) ret += b;
return ret;
}
const int N = 10000000;
int n, m, x, t, T;
int a[105][105];
int main(int argc, char const *argv[]) {
ios::sync_with_stdio(false);
while (cin >> n >> m) {
for (int i = 0; i < int(n); ++i)
for (int j = 0; j < int(m); ++j) cin >> a[i][j];
int ans = 0;
for (int i = 0; i < int(n); ++i) {
int t = INF;
for (int j = 0; j < int(m); ++j) t = min(t, a[i][j]);
ans = max(t, ans);
}
cout << ans << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-9;
int SGN(double a) { return ((a > EPS) ? (1) : ((a < -EPS) ? (-1) : (0))); }
int CMP(double a, double b) { return SGN(a - b); }
struct node {
int x, y;
node(int x = 0, int y = 0) : x(x), y(y) {}
};
int dir[][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
int dir8[][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1},
{-1, 1}, {1, -1}, {-1, -1}, {1, 1}};
int main() {
ios::sync_with_stdio(false);
int n, k;
cin >> n >> k;
int t = 240 - k;
int i = 1, ans = 0;
while (ans + i * 5 <= t) {
ans += i * 5;
i++;
}
cout << min(n, i - 1) << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200010;
map<int, int> mp;
int n;
struct pnt {
int x, w;
bool operator<(const pnt &p) const { return x < p.x; }
} p[maxn];
int ask(int x) {
int res = 0;
for (int i = x; i > 0; i -= (i & -i))
if (mp.count(i)) res = max(res, mp[i]);
return res;
}
void update(int x, int v) {
for (int i = x; i < 0x3f3f3f3f; i += (i & -i)) mp[i] = max(mp[i], v);
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d%d", &p[i].x, &p[i].w);
sort(p, p + n);
int ans = 0;
for (int i = 0; i < n; i++) {
int tmp = ask(p[i].x - p[i].w);
ans = max(ans, tmp + 1);
update(p[i].x + p[i].w, tmp + 1);
}
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a[300005], b[300005];
int main() {
ios::sync_with_stdio(false);
int T;
cin >> T;
while (T--) {
int pos1 = 0, pos2 = 0;
string s;
cin >> s;
int len = s.length();
for (int i = 0; i < len; i++) {
int d = s[i] - '0';
if (d % 2) {
a[pos1++] = d;
} else {
b[pos2++] = d;
}
}
int cur1 = 0, cur2 = 0;
for (int i = 0; i < len; i++) {
if (cur1 == pos1)
cout << b[cur2++];
else if (cur2 == pos2)
cout << a[cur1++];
else if (a[cur1] < b[cur2])
cout << a[cur1++];
else
cout << b[cur2++];
}
cout << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 5;
const int Maxm = 20;
int n, m;
int a[Maxn], b[Maxm];
char B[Maxn][Maxm];
int has[Maxm];
bool gotres;
void Print() {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) printf("%c", B[i][j]);
printf("\n");
}
}
bool checkRow(int r, int c, bool lst, int hasline, int wr) {
if (!lst && wr) hasline++;
if (hasline > a[r]) return false;
if (hasline < a[r]) {
int lft = m - c - wr;
return lft >= 0 && hasline + lft / 2 >= a[r];
}
return true;
}
bool checkCol(int r, int c, int wr) {
int hascol = has[c];
if ((r == 0 || B[r - 1][c] == '.') && wr) hascol++;
if (hascol > b[c]) return false;
if (hascol < b[c]) {
int lft = n - r - wr;
return lft >= 0 && hascol + lft / 2 >= b[c];
}
return true;
}
void changeRow(int r, int c, bool &lst, int &hasline, int wr) {
if (!lst && wr) hasline++;
lst = wr;
}
void changeCol(int r, int c, int wr) {
if ((r == 0 || B[r - 1][c] == '.') && wr) has[c]++;
}
void Solve(int r, int c, bool lst, int hasline) {
if (r == n) {
Print();
gotres = true;
return;
}
if (c == m) {
Solve(r + 1, 0, false, 0);
return;
}
if (checkRow(r, c, lst, hasline, 0) && checkCol(r, c, 0)) {
bool memlst = lst;
int memhasline = hasline;
int memhas = has[c];
changeRow(r, c, lst, hasline, 0);
changeCol(r, c, 0);
B[r][c] = '.';
Solve(r, c + 1, lst, hasline);
lst = memlst;
hasline = memhasline;
has[c] = memhas;
}
if (gotres) return;
if (checkRow(r, c, lst, hasline, 1) && checkCol(r, c, 1)) {
bool memlst = lst;
int memhasline = hasline;
int memhas = has[c];
changeRow(r, c, lst, hasline, 1);
changeCol(r, c, 1);
B[r][c] = '*';
Solve(r, c + 1, lst, hasline);
lst = memlst;
hasline = memhasline;
has[c] = memhas;
}
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < m; i++) scanf("%d", &b[i]);
Solve(0, 0, false, 0);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
void Solve() {
long long n, m, rb, cb;
long long rd, cd;
int dr = 1;
int dc = 1;
cin >> n >> m >> rb >> cb >> rd >> cd;
int a, b;
if (rb <= rd)
a = rd - rb;
else
a = n - rd + n - rb;
if (cb <= cd)
b = cd - cb;
else
b = m - cd + m - cb;
cout << min(a, b) << endl;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
long long t = 1;
cin >> t;
while (t--) {
Solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3", "unroll-loops")
#pragma GCC target("sse4.2")
using namespace std;
mt19937 gen(chrono::high_resolution_clock::now().time_since_epoch().count());
void flush() { cout << flush; }
void flushln() { cout << endl; }
void println() { cout << '\n'; }
template <class T>
void print(const T &x) {
cout << x;
}
template <class T>
void read(T &x) {
cin >> x;
}
template <class T, class... U>
void read(T &x, U &...u) {
read(x);
read(u...);
}
template <class T, class... U>
void print(const T &x, const U &...u) {
print(x);
print(u...);
}
template <class T, class... U>
void println(const T &x, const U &...u) {
print(x);
println(u...);
}
template <class T>
inline void sort(T &a) {
sort((a).begin(), (a).end());
}
template <class T>
inline void rsort(T &a) {
sort((a).rbegin(), (a).rend());
}
template <class T>
inline void reverse(T &a) {
reverse((a).begin(), (a).end());
}
template <class T, class U>
inline istream &operator>>(istream &str, pair<T, U> &p) {
return str >> p.first >> p.second;
}
template <class T>
inline istream &operator>>(istream &str, vector<T> &a) {
for (auto &i : a) str >> i;
return str;
}
template <class T>
inline T sorted(T a) {
sort(a);
return a;
}
void solve() {
long long a, b, c, d;
read(a, b, c, d);
long long l = 0, r = 1;
auto first = [&](long long k) {
long long t = k * d;
long long l = max(0ll, (t - c) / d);
long long r = (t / d + 1) - l;
long long v1 = l * d;
long long sum = r * t - (2 * v1 + d * (r - 1)) * r / 2;
return l * (b * c - a) + r * (-a) + sum * b;
};
while (first(r) >= -1e18 && r < 2e6) r *= 2;
if (first(r + 1) < first(r)) {
println(-1);
return;
}
while (r - l > 2) {
long long m1 = l + (r - l) / 3, m2 = r - (r - l) / 3;
if (first(m1) > first(m2))
l = m1;
else
r = m2;
}
long long ans = l;
for (long long i = l + 1; i <= r; ++i)
if (first(i) < first(ans)) ans = i;
println(-first(ans));
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(12);
int t;
read(t);
while (t--) solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int arr[500] = {0};
int main() {
string str1, str2;
cin >> str1 >> str2;
int l, m, temp = 0, res = 0, res2 = 0;
l = str1.length();
m = str2.length();
int mark[l];
fill(mark, mark + l, 0);
for (int i = 0; i < m; i++) {
temp = str2[i];
arr[temp]++;
}
for (int i = 0; i < l; i++) {
temp = str1[i];
if (arr[temp] > 0) {
res++;
mark[i] = 1;
arr[temp]--;
}
}
for (int i = 0; i < l; i++) {
temp = str1[i];
if (mark[i] == 1) continue;
if (temp >= 65 && temp <= 90) {
if (arr[temp + 32] > 0) {
res2++;
arr[temp + 32]--;
}
} else if (temp >= 97 && temp <= 122) {
if (arr[temp - 32] > 0) {
res2++;
arr[temp - 32]--;
}
}
}
cout << res << " " << res2 << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char const *argv[]) {
int n;
cin >> n;
int res = 0;
int prev = 0, f = 0;
vector<int> v(n);
for (int i = 0; i < n; ++i) {
cin >> v[i];
}
for (int i = 1; i < n; ++i) {
int a, prev = v[i - 1];
a = v[i];
if (a + prev == 5) {
f = 1;
} else {
res += (a + prev);
if (i > 1 and v[i] == 2 and v[i - 2] == 3) {
res--;
}
}
}
(f == 1) ? cout << "Infinite\n" : cout << "Finite\n" << res << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k, i, j, v;
cin >> n >> m >> k;
int s[102] = {};
int y[102] = {};
int a[102][102];
for (i = 1; i <= n; ++i)
for (j = 1; j <= m; ++j) cin >> a[i][j];
for (j = 1; j <= m; ++j) {
for (i = 1; i <= n; ++i) {
v = a[i][j];
if (y[i] == 0 && v != 0) {
if (s[v] == -1)
y[i] = j;
else if (s[v] == 0)
s[v] = i;
else if (s[v] > 0) {
y[s[v]] = j;
y[i] = j;
s[v] = -1;
}
}
}
for (i = 0; i <= k; ++i)
if (s[i] > 0) s[i] = 0;
}
for (i = 1; i <= n; ++i) cout << y[i] << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 60;
int n, m, ans;
string s;
vector<int> row[maxn], col[maxn];
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> s;
for (int j = 1; j <= m; j++) {
if (s[j - 1] == '#') {
row[i].push_back(j);
col[j].push_back(i);
}
}
}
for (int i = 1; i <= n; i++) {
for (auto x : row[i]) {
for (auto y : row[i]) {
if (col[y] != col[x]) {
ans = 1;
}
}
}
}
if (ans == 1) {
cout << "No" << endl;
return 0;
}
cout << "Yes" << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 600000;
int n, m, ver[N], nex[N], head[N], cnt, A, B, C, d[N], x, y, vis[N], a[3];
unsigned long long res, sum[N];
vector<int> v[N];
void add(int x, int y) { ver[++cnt] = y, nex[cnt] = head[x], head[x] = cnt; }
int main() {
memset(vis, -1, sizeof(vis));
scanf("%d%d%d%d%d", &n, &m, &A, &B, &C);
for (int i = 1; i <= n; i++)
res = res +
((unsigned long long)i - 1) * (unsigned long long)A *
(((unsigned long long)n - i) * ((unsigned long long)n - i - 1) >>
1ll);
for (int i = 3; i <= n; i++)
res =
res +
((unsigned long long)i - 1) * (unsigned long long)C *
(((unsigned long long)i - 1) * ((unsigned long long)i - 2) >> 1ll);
for (int i = 2; i < n; i++)
res = res + ((unsigned long long)i - 1) * (unsigned long long)B *
((unsigned long long)i - 1) * ((unsigned long long)n - i);
for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + (unsigned long long)i;
for (int i = 1; i <= m; i++) {
scanf("%d%d", &x, &y);
d[x]++, d[y]++;
if (x > y) swap(x, y);
v[x].push_back(y), v[y].push_back(x);
if (x)
res = res - (unsigned long long)sum[x - 1] * A -
(unsigned long long)B * x * x - (unsigned long long)C * y * x;
res = res - (unsigned long long)A * x * ((unsigned long long)y - x - 1) -
((unsigned long long)sum[y - 1] - sum[x]) * B -
(unsigned long long)C * y * ((unsigned long long)y - x - 1);
res = res - (unsigned long long)A * x * ((unsigned long long)n - y - 1) -
(unsigned long long)B * y * (n - y - 1) -
((unsigned long long)sum[n - 1] - sum[y]) * C;
}
for (int i = 0; i < n; i++) sort(v[i].begin(), v[i].end());
for (int i = 0; i < n; i++)
for (int j = 0; j < v[i].size(); j++)
if (v[i][j] > i) {
if (d[i] > d[v[i][j]])
add(i, v[i][j]);
else
add(v[i][j], i);
}
for (int i = 0; i < n; i++) {
int j = 0, k = 0, s = v[i].size();
while (k < s && v[i][k] < i) k++;
if (s < 2) continue;
for (j = 0; j < k; j++) {
res = res + (unsigned long long)B * j * v[i][j];
res = res + (unsigned long long)A * (s - j - 1) * v[i][j];
}
for (j = k; j < s; j++) {
res = res +
(unsigned long long)B * v[i][j] * ((unsigned long long)s - j - 1);
res = res + (unsigned long long)C * v[i][j] * j;
}
res = res +
i * (unsigned long long)C * (((unsigned long long)k - 1) * k >> 1);
res = res + i * (unsigned long long)A *
(((unsigned long long)s - k) * (s - k - 1) >> 1);
res = res + i * (unsigned long long)B * ((unsigned long long)s - k) * k;
}
for (int i = 0; i < n; i++) {
for (int j = head[i]; j; j = nex[j]) vis[ver[j]] = i;
for (int j = head[i]; j; j = nex[j]) {
int t = ver[j];
for (int k = head[t]; k; k = nex[k])
if (vis[ver[k]] == i) {
a[0] = i, a[1] = t, a[2] = ver[k];
sort(a, a + 3);
res = res -
((unsigned long long)a[0] * A + (unsigned long long)a[1] * B +
(unsigned long long)a[2] * C);
}
}
}
cout << res;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
long long cl(long double a) {
if (a > (long long)a) {
return (long long)a + 1;
} else {
return (long long)a;
}
}
long long flr(long double a) { return (long long)a; }
const long long M = 2e5 + 100;
long long n, m, a[M];
void solve() {
cin >> n;
cin >> m;
for (long long i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
map<long long, long long> mark;
map<long long, long long> dist;
vector<long long> res;
long long ans = 0;
queue<long long> q;
for (long long i = 0; i < n; i++) {
q.push(a[i]);
mark[a[i]] = 1;
}
while (!q.empty()) {
long long par = q.front();
q.pop();
if (!mark[par - 1]) {
res.push_back(par - 1);
dist[par - 1] = dist[par] + 1;
q.push(par - 1);
ans += dist[par - 1];
mark[par - 1] = 1;
}
if (res.size() == m) break;
if (!mark[par + 1]) {
res.push_back(par + 1);
dist[par + 1] = dist[par] + 1;
q.push(par + 1);
ans += dist[par + 1];
mark[par + 1] = 1;
}
if (res.size() == m) break;
}
cout << ans << "\n";
for (long long i = 0; i < m; i++) cout << res[i] << " ";
cout << "\n";
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t;
t = 1;
while (t--) solve();
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int h, m, n;
scanf("%d %d:%d", &n, &h, &m);
if (m >= 60) m %= 10;
if (n == 12 && (h > 12 || h == 0)) {
if (h % 10 == 0)
h = 10;
else
h = h % 10;
} else {
if (n == 24 && h >= 24) {
h = h % 10;
}
}
printf("%02d:%02d", h, m);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int M = 1000000007;
string s[150000];
long long val[15], mul10[15];
int main() {
string str;
while (cin >> str) {
int n;
scanf("%d", &n);
for (int i = 0; i < 10; i++) {
val[i] = i;
mul10[i] = 10;
}
for (int i = 0; i < n; i++) cin >> s[i];
for (int i = n - 1; i >= 0; i--) {
long long tval = 0, tmul = 1;
for (int j = s[i].length() - 1; j >= 3; j--) {
int num = s[i][j] - '0';
tval = (tval + val[num] * tmul) % M;
tmul = mul10[num] * tmul % M;
}
int num = s[i][0] - '0';
val[num] = tval;
mul10[num] = tmul;
}
long long ans = 0;
for (int i = 0; i < str.length(); i++) {
ans = (ans * mul10[str[i] - '0'] + val[str[i] - '0']) % M;
}
cout << ans << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int vv[4000010], nxt[4000010], h[2010], e;
int dfn[2010], low[2010], sta[2010], deep, flag, col[2010];
int top;
int num[2010], cnt[2010];
void add(int u, int v) {
vv[e] = v, nxt[e] = h[u], h[u] = e++;
vv[e] = u, nxt[e] = h[v], h[v] = e++;
}
bitset<2010> bb;
void dfs(int u, int f) {
dfn[u] = low[u] = ++deep;
sta[++top] = u;
int v, x;
for (int i = h[u]; i + 1; i = nxt[i])
if (i - f) {
v = vv[i];
if (!dfn[v]) {
dfs(v, i ^ 1);
low[u] = min(low[u], low[v]);
if (low[v] > dfn[u]) {
++flag;
num[flag] = 0;
x = v;
while (top) {
v = sta[top--];
col[v] = flag;
++num[flag];
if (v == x) break;
}
}
} else
low[u] = min(low[u], dfn[v]);
}
}
long long cal(int u, int f) {
cnt[u] = num[u];
int v;
long long ans = (num[u] - 1LL) * num[u];
for (int i = h[u]; i + 1; i = nxt[i]) {
v = vv[i];
if (v == f) continue;
ans += cal(v, u);
ans += 1LL * num[u] * cnt[v];
cnt[u] += cnt[v];
}
return ans;
}
long long cal(int u) {
long long tmp = 0;
int v;
bb.reset();
bb[0] = 1;
long long sum = (num[u] - 1LL) * num[u];
int s = 0;
for (int i = h[u]; i + 1; i = nxt[i]) {
v = vv[i];
tmp = cal(v, u);
sum += tmp;
bb = bb | (bb << cnt[v]);
sum += 1LL * cnt[v] * num[u];
s += cnt[v];
}
long long maxv = 0;
for (int i = 1; i <= s; ++i)
if (bb[i]) {
maxv = max(maxv, 1LL * i * (s - i));
}
return sum + maxv;
}
long long solve(int n, int m) {
memset(dfn, 0, sizeof(dfn));
deep = flag = top = 0;
dfs(1, -1);
memset(h, -1, sizeof(h)), e = 0;
int u, v;
if (top) {
++flag;
num[flag] = 0;
while (top) {
v = sta[top--];
col[v] = flag;
num[flag]++;
}
}
long long ans = 0, tmp;
for (int i = 0; i < 2 * m; i += 2) {
u = vv[i], v = vv[i ^ 1];
if (col[v] - col[u]) add(col[u], col[v]);
}
for (int i = 1; i <= flag; ++i) {
tmp = cal(i);
ans = max(ans, tmp);
}
return ans + n;
}
int main() {
int u, v;
int n, m;
cin >> n >> m;
memset(h, -1, sizeof(h)), e = 0;
for (int i = 1; i <= m; ++i) {
scanf("%d%d", &u, &v);
add(u, v);
}
long long ans = solve(n, m);
printf("%I64d\n", ans);
}
| 9 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.