solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, i, a[1010];
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (i = 0; i < n; i++) {
if (a[i] >= 8) {
k -= 8;
a[i + 1] += a[i] - 8;
} else
k -= a[i];
if (k <= 0) break;
}
if (k <= 0 && i != n)
cout << i + 1 << endl;
else
cout << "-1" << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e2 + 7;
set<string> arr[2];
int res = 0, n, k;
string str;
int main() {
ios::sync_with_stdio(0);
cin.tie();
cout.tie(0);
cin >> n >> k >> str;
arr[0].insert(str);
int act = 0;
while (k) {
if (arr[0].size() == 0) {
cout << -1 << "\n";
return 0;
}
for (auto i : arr[0]) {
for (int j = 0; j < i.size(); ++j) {
arr[1].insert(i.substr(0, j) + i.substr(j + 1, i.size() - 1 - j));
}
}
int cnt = min((int)arr[0].size(), k);
res += act * cnt;
k -= cnt;
act++;
swap(arr[0], arr[1]);
arr[1].clear();
}
cout << res << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long Mod = 1000000007LL;
const int N = 1e5 + 10;
const long long Inf = 2242545357980376863LL;
const long long Log = 30;
long long ans = 0, fu = 0;
void Up(long long a, long long b) {
if (a == ans) fu = min(fu, b);
if (a > ans) {
ans = a;
fu = b;
}
}
vector<long long> A[4];
long long c[N], f[N], l[N];
bool CMP(long long i, long long j) { return f[i] < f[j]; }
long long ps[N];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, d, second;
cin >> n >> d >> second;
for (int i = 0; i < n; i++) {
cin >> c[i] >> f[i] >> l[i];
if (l[i] >= d)
l[i] = 1;
else
l[i] = 0;
A[l[i] + (c[i] > 0) + (c[i] > 0)].push_back(i);
}
for (int i = 0; i < 4; i++) sort(A[i].begin(), A[i].end(), CMP);
long long cnt = 0, sm = 0;
for (auto i : A[1]) {
if (sm + f[i] <= second) {
cnt++;
sm += f[i];
}
}
Up(cnt, sm);
for (int i = 1; i <= A[1].size(); i++) ps[i] = ps[i - 1] + f[A[1][i - 1]];
cnt = 0, sm = 0;
long long R = 0;
for (auto i : A[3]) R += c[i] - 1;
for (auto i : A[2]) R += c[i] - 1;
long long first = 0;
for (int i = 1; i <= A[3].size(); i++) {
first += f[A[3][i - 1]];
if (first > second) break;
cnt = A[3].size() + A[2].size();
sm = first;
long long rq = R + i;
long long d = min(rq, (long long)A[0].size());
rq -= d;
cnt += d;
d = min(rq, (long long)A[1].size());
cnt += d;
long long y =
upper_bound(ps, ps + (A[1].size() - d) + 1, second - first) - ps;
cnt += y - 1;
Up(cnt, sm + ps[y - 1]);
}
cout << ans << ' ' << fu << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
double a[200010];
double b[200010];
int n;
double Cal(double x) {
double Max = 0, Min = 0;
double best = 0.0;
for (int i = 1; i <= n; ++i) {
Max = max(0.0, Max) + (a[i] - x);
best = max(best, fabs(Max));
Min = min(0.0, Min) + (a[i] - x);
best = max(best, fabs(Min));
}
return best;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%lf", &a[i]);
double left = -1000000, right = 1000000;
double mid, midmid;
for (int i = 0; i < 300; i++) {
mid = (left + right) / 2;
midmid = (mid + right) / 2;
if (Cal(mid) < Cal(midmid))
right = midmid;
else
left = mid;
}
printf("%lf\n", Cal(right));
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int aa[100005], n, d, b, qq[100005], cur = 1, a[100005], mid;
int f(int hmn, int far) {
int r = 1, sum = 0, re = 0, fro;
for (int i = 1; i <= hmn; i++) {
for (; r <= far && r <= i + d * i; r++) sum += a[r];
if (a[i] >= b) {
int tmp = a[i] - b;
a[i] -= tmp;
a[i + 1] += tmp;
sum -= a[i];
} else {
if (sum >= b) {
a[r - 1] -= b - a[i];
a[i] = b;
sum -= a[i];
} else {
a[i + 1] += a[i];
a[i] = 0;
re++;
}
}
}
return re;
}
int z(int x, int &tmp1, int &tmp2) {
while (qq[cur - 1] >= x && cur > 1) cur--;
while (qq[cur] < x && cur < n) cur++;
memset(a, 0, sizeof(a));
for (int i = 1; i <= cur; i++) a[i] = aa[i];
a[cur] = x - qq[cur - 1];
tmp1 = f((n + 1) / 2, cur);
memset(a, 0, sizeof(a));
for (int i = n; i >= cur; i--) a[n - i + 1] = aa[i];
a[n - cur + 1] = qq[cur] - x;
tmp2 = f(n / 2, n - cur + 1);
return tmp2 - tmp1;
}
int main() {
cin >> n >> d >> b;
for (int i = 1; i <= n; i++) {
scanf("%d", &aa[i]);
qq[i] = qq[i - 1] + aa[i];
}
int l = 0, r = n * b, re, tmp1, tmp2;
while (l <= r) {
mid = (l + r) >> 1;
if (z(mid, tmp1, tmp2) >= 0)
re = mid, r = mid - 1;
else
l = mid + 1;
}
z(re, tmp1, tmp2);
int ans = max(tmp1, tmp2);
z(re - 1, tmp1, tmp2);
ans = min(ans, max(tmp1, tmp2));
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int best[5005][2505][3];
int h[5005];
int n;
int INF = 800000000;
int main() {
fscanf(stdin, "%d", &n);
for (int i = 1; i <= n; i++) {
fscanf(stdin, "%d", &h[i]);
}
h[0] = -10;
h[n + 1] = -10;
for (int i = 0; i <= n; i++) {
for (int j = 1; j <= (n + 1) / 2; j++) {
best[i][j][0] = INF;
best[i][j][1] = INF;
best[i][j][2] = INF;
}
}
for (int i = 0; i <= n; i++) {
best[i][0][0] = INF;
best[i][0][1] = INF;
best[i][0][2] = 0;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= (n + 1) / 2; j++) {
best[i][j][1] = best[i - 1][j][0];
best[i][j][2] = min(best[i - 1][j][1], best[i - 1][j][2]);
if (i <= 2) {
best[i][j][0] = best[i - 1][j - 1][2] + max(0, h[i - 1] - h[i] + 1) +
max(0, h[i + 1] - h[i] + 1);
} else {
best[i][j][0] =
min(best[i - 1][j - 1][2] + max(0, h[i - 1] - h[i] + 1),
best[i - 1][j - 1][1] +
max(0, min(h[i - 2] - 1, h[i - 1]) - h[i] + 1)) +
max(0, h[i + 1] - h[i] + 1);
}
}
}
for (int j = 1; j <= (n + 1) / 2; j++) {
int minimo = min(best[n][j][0], min(best[n][j][1], best[n][j][2]));
fprintf(stdout, "%d ", minimo);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
string num = "0123456789";
int main() {
ios::sync_with_stdio(0);
;
cin.tie(0);
;
int q;
cin >> q;
while (q--) {
int n, m;
cin >> n >> m;
int a[n][m];
vector<vector<int>> v(n);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int x;
cin >> x;
v[i].push_back(x);
}
}
int b[n];
for (int l = 0; l < m; l++)
for (int i = 0; i < n; i++) {
cin >> b[i];
for (auto &e : v) {
if (e[0] == b[i])
for (int j = 0; j < m; j++) a[i][j] = e[j];
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) cout << a[i][j] << " ";
cout << endl;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
char a[1002][34], b[34];
int point[1002], res[1002], h[1002];
int main() {
int n, x, i, j, p = 1;
scanf("%d", &n);
scanf("%s %d", &a[0], &x);
point[0] += x;
h[0] = point[0];
res[0] = 0;
for (i = 1; i < n; i++) {
scanf("%s %d", &b, &x);
for (j = 0; j < p; j++) {
if (strcmp(a[j], b) == 0) {
break;
}
}
if (i == p) {
strcpy(a[p], b);
p++;
}
point[j] += x;
h[i] = point[j];
res[i] = j;
}
int max = point[0];
for (i = 1; i < p; i++) {
if (point[i] > max) max = point[i];
}
for (i = 0; i < n; i++) {
if (point[res[i]] == max && h[i] >= max) break;
}
printf("%s", a[res[i]]);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<long long int> v(max(m + 1, max(3, n + 1)), 0);
v.at(1) = 2;
v.at(2) = 4;
for (int i = 3; i <= max(m, n); i++) {
v.at(i) = v.at(i - 1) + v.at(i - 2);
v.at(i) %= 1000000007;
}
cout << setprecision(numeric_limits<long long int>::digits10)
<< (v.at(m) + v.at(n) - 2) % 1000000007 << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
struct sc {
int cnt, count;
long long num[5001];
} p[5010];
struct ms {
int id;
long long num;
} ans[200000], t[200000];
int sta, end;
void merge(int x, int y) {
int mid = (x + y) >> 1, i = x, j = mid + 1, k = x;
while (i != mid + 1 && j != y + 1) {
if (ans[i].num > ans[j].num) {
t[k].id = ans[j].id;
t[k++].num = ans[j++].num;
} else {
t[k].id = ans[i].id;
t[k++].num = ans[i++].num;
}
}
while (i <= mid) {
t[k].id = ans[i].id;
t[k++].num = ans[i++].num;
}
while (j <= y) {
t[k].id = ans[j].id;
t[k++].num = ans[j++].num;
}
for (i = x; i <= y; ++i) {
ans[i].id = t[i].id;
ans[i].num = t[i].num;
}
}
void mergesort(int x, int y) {
if (x < y) {
int mid = (x + y) >> 1;
mergesort(x, mid);
mergesort(mid + 1, y);
merge(x, y);
}
}
int main() {
int n, i, j, k, l = 0, m, sum = 0;
scanf("%d", &n);
for (i = 0; i < n; ++i) {
long long t1, t2, t3, t4;
k = 0;
scanf("%d %I64d %I64d %I64d %I64d", &m, &t1, &t2, &t3, &t4);
l += m;
p[i].cnt = m;
p[i].count = 1;
p[i].num[0] = -1;
p[i].num[1] = t1;
for (j = 2; j <= m; ++j) {
p[i].num[j] = (p[i].num[j - 1] * t2 + t3) % t4;
if (p[i].num[j] < p[i].num[j - 1]) k++;
}
if (k > sum) sum = k;
}
printf("%d\n", sum);
if (l <= 200000) {
sta = 0;
end = 0;
while (end < l) {
for (i = 0; i < n; ++i) {
for (j = p[i].count; j <= p[i].cnt; ++j) {
if (j != p[i].count && p[i].num[j] < p[i].num[j - 1]) {
p[i].count = j;
break;
}
ans[end].id = i;
ans[end++].num = p[i].num[j];
}
if (j > p[i].cnt) p[i].count = j;
}
mergesort(sta, end - 1);
sta = end;
}
for (i = 0; i < l; ++i) printf("%I64d %d\n", ans[i].num, ans[i].id + 1);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<vector<int>> transitions;
int n;
cin >> n;
for (int i = 0; i <= n; i++) transitions.push_back(vector<int>{});
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a;
cin >> b;
transitions[a].push_back(b);
transitions[b].push_back(a);
}
vector<int> given_bfs;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
given_bfs.push_back(x);
}
if (given_bfs[0] != 1) {
cout << "No" << endl;
exit(0);
}
int used[200001];
for (int i = 0; i < 200001; i++) used[i] = 0;
used[1] = 1;
queue<unordered_set<int>> q;
q.push(unordered_set<int>{});
for (int u : transitions[1]) {
used[u] = 1;
q.front().insert(u);
}
if (q.front().size() == 0) q.pop();
int i = 1;
unordered_set<int> current_set{};
while (!q.empty() || !current_set.empty()) {
if (i >= given_bfs.size()) {
cout << "No" << endl;
exit(0);
}
if (current_set.size() == 0) {
current_set = q.front();
q.pop();
}
int node = given_bfs[i];
if (current_set.find(node) == current_set.end()) {
cout << "No" << endl;
exit(0);
}
current_set.erase(node);
unordered_set<int> succ;
for (int u : transitions[node]) {
if (used[u]) continue;
succ.insert(u);
used[u] = 1;
}
if (succ.size() > 0) q.push(succ);
i++;
}
cout << "Yes" << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
char s[100100];
int main() {
int n, k;
scanf("%d%d", &n, &k);
scanf("%s", s);
int res = 0;
int used = 0;
int pt = 0;
for (int i = 0; s[i]; i++) {
if (s[i] != 'a') used++;
while (used > k && pt <= i) {
if (s[pt++] != 'a') used--;
}
if (used > k) continue;
if ((i - pt + 1) > res) res = i - pt + 1;
}
used = 0;
pt = 0;
for (int i = 0; s[i]; i++) {
if (s[i] != 'b') used++;
while (used > k && pt <= i) {
if (s[pt++] != 'b') used--;
}
if (used > k) continue;
if ((i - pt + 1) > res) res = i - pt + 1;
}
printf("%d\n", res);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int tab[n];
long long s = 0;
for (int i = 0; i < n; i++) {
cin >> tab[i];
if (i == tab[i]) {
s++;
tab[i] = -1;
}
}
bool bo = false;
for (int i = 0; i < n; i++) {
if (tab[i] != -1) {
if (tab[tab[i]] == i) {
s += 2;
bo = false;
break;
}
bo = true;
}
}
if (bo) s++;
cout << s;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<pair<long long, long long>, long long> > v;
vector<pair<long long, long long> > q;
pair<long long, long long> qr[1000000 + 77];
long long b[1000000 + 77];
long long f[1000000 + 77];
vector<long long> dis;
long long ans[1000000 + 77];
long long a[1000000 + 77];
long long c[1000000 + 77];
map<long long, long long> mp;
map<long long, long long> mm;
int32_t main() {
long long n, m, l, r;
scanf("%lld%lld", &n, &m);
long long val = 0;
for (long long i = 0; i < n; i++) {
scanf("%lld", &b[i]);
if (mp[b[i]] == 0) {
mp[b[i]] = ++val;
}
}
for (long long i = 0; i < n; i++) {
a[i] = mp[b[i]];
c[i] = b[i];
}
long long sq = (sqrt(n));
pair<long long, long long> x, z;
pair<pair<long long, long long>, long long> y;
pair<pair<long long, long long>, long long> pii;
for (long long i = 0; i < m; i++) {
scanf("%lld%lld", &l, &r);
l--, r--;
z = make_pair(l / sq, r);
x = make_pair(l, r);
q.push_back(x);
qr[i] = x;
y = make_pair(z, i);
v.push_back(y);
}
sort(v.begin(), v.end());
pii = v[0];
long long s1 = qr[v[0].second].first;
long long s2 = qr[v[0].second].second;
long long res1, res2;
res1 = 0;
long long cnt = 0;
for (long long i = s1; i <= s2; i++) {
f[a[i]]++;
if (f[a[i]] == c[i]) cnt++;
if (f[a[i]] - 1 == c[i]) cnt--;
}
ans[v[0].second] = cnt;
for (long long j = 1; j < v.size(); j++) {
long long k = v[j].second;
long long left = qr[k].first, right = qr[k].second;
if (left < s1) {
for (long long i = s1 - 1; i >= left; i--) {
f[a[i]]++;
if (f[a[i]] == c[i]) cnt++;
if (f[a[i]] - 1 == c[i]) cnt--;
}
} else if (left > s1) {
for (long long i = s1; i < left; i++) {
f[a[i]]--;
if (f[a[i]] == c[i]) {
cnt++;
}
if (f[a[i]] + 1 == c[i]) cnt--;
}
}
if (right > s2) {
for (long long i = s2 + 1; i <= right; i++) {
f[a[i]]++;
if (f[a[i]] == c[i]) cnt++;
if (f[a[i]] - 1 == c[i]) cnt--;
}
} else if (right < s2) {
for (long long i = s2; i > right; i--) {
if (f[a[i]] != 0) f[a[i]]--;
if (f[a[i]] == c[i]) {
cnt++;
}
if (f[a[i]] + 1 == c[i]) cnt--;
}
}
ans[k] = cnt;
s1 = left, s2 = right;
}
for (long long i = 0; i < m; i++) {
printf("%lld\n", ans[i]);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
inline void read(int &x) {
int v = 0, f = 1;
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-')
f = -1;
else
v = (c & 15);
while (isdigit(c = getchar())) v = (v << 1) + (v << 3) + (c & 15);
x = v * f;
}
inline void read(long long &x) {
long long v = 0ll, f = 1ll;
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-')
f = -1;
else
v = (c & 15);
while (isdigit(c = getchar())) v = (v << 1) + (v << 3) + (c & 15);
x = v * f;
}
inline void readc(char &x) {
char c;
while (((c = getchar()) == ' ') || c == '\n')
;
x = c;
}
const int N = 100100;
map<int, int> mp1, mp2, mp3;
vector<int> e[N];
int n, i, ans[N], sz[N], son[N], rt;
void dfs1(int x) {
sz[x] = 1;
for (__typeof((e[x]).begin()) it = (e[x]).begin(); it != (e[x]).end(); it++) {
dfs1(*it);
sz[x] += sz[*it];
if (sz[*it] > sz[son[x]]) {
son[x] = *it;
}
}
mp1[sz[x]]++;
}
void dfsu(int x, int v, int p) {
if (!(mp3[sz[x]] += v)) mp3.erase(sz[x]);
if (!(mp1[sz[x]] -= v)) mp1.erase(sz[x]);
for (__typeof((e[x]).begin()) it = (e[x]).begin(); it != (e[x]).end(); it++)
if (*it != p) dfsu(*it, v, x);
}
int query(map<int, int> &mp, int l, int r, int tl, int tr) {
int mid, ans = n - 1;
l--;
while (l < r) {
mid = (l + r + 1) / 2;
map<int, int>::iterator it = mp.lower_bound(tl - mid);
if (it != mp.end() && it->first <= mid + tr) {
r = mid - 1;
ans = mid;
} else
l = mid;
}
return ans;
}
void dfs2(int x, int tag) {
mp2[sz[x]]++;
if (!--mp1[sz[x]]) {
mp1.erase(sz[x]);
}
int mi = n, mx = 0;
for (__typeof((e[x]).begin()) it = (e[x]).begin(); it != (e[x]).end(); it++) {
if (*it != son[x]) {
mx = max(mx, sz[*it]);
dfs2(*it, 0);
}
mi = min(mi, sz[*it]);
}
if (son[x]) dfs2(son[x], 1);
if (sz[x] != n) mi = min(mi, n - sz[x]);
ans[x] = max(sz[son[x]], n - sz[x]);
if (n - sz[x] <= sz[son[x]]) {
mx = max(mx, n - sz[x]);
ans[x] = min(ans[x], query(mp3, mi, sz[son[x]], sz[son[x]], -mi));
}
dfsu(x, 1, son[x]);
if (!++mp1[sz[x]]) mp1.erase(sz[x]);
if (n - sz[x] > sz[son[x]]) {
mx = sz[son[x]];
ans[x] = min(ans[x], query(mp1, mi, n - sz[x], n - sz[x], -mi));
ans[x] = min(ans[x], query(mp2, mi, n - sz[x], n, sz[x] - mi));
}
ans[x] = max(ans[x], mx);
if (!--mp2[sz[x]]) mp2.erase(sz[x]);
if (!tag) dfsu(x, -1, 0);
}
int main() {
read(n);
for (((i)) = (1); ((i)) <= ((n)); ((i))++) {
int x, y;
read(x);
read(y);
if (x == 0 || y == 0) {
rt = x + y;
}
e[x].push_back(y);
}
dfs1(rt);
dfs2(rt, 0);
for (((i)) = (1); ((i)) <= ((n)); ((i))++) {
printf("%d\n", ans[i]);
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int i, j, x, y, N, k, h, Ans, p, len;
struct node {
int l, r, len;
} A[2005];
int P[2005], Q[2005], f[2005], g[2005], link[2005], Out[2005];
int res[2005][2005];
int cmp1(const int &i, const int &j) { return A[i].len < A[j].len; }
int cmp2(const int &i, const int &j) { return A[i].l < A[j].l; }
void Get(int x) {
int i;
Out[++len] = x;
for (i = 1; i < res[x][0]; ++i) Get(res[x][i]);
}
int main() {
scanf("%d", &N);
for (i = 1; i <= N; ++i) {
scanf("%d%d", &x, &y);
A[i].l = x - y + 1, A[i].r = x + y;
}
for (i = 1; i <= N; ++i) A[i].len = A[i].r - A[i].l + 1;
for (i = 1; i <= N; ++i) P[i] = i;
sort(P + 1, P + N + 1, cmp1);
for (i = 1; i <= N; ++i) Q[i] = i;
sort(Q + 1, Q + N + 1, cmp2);
for (k = 1; k <= N; ++k) {
i = P[k];
for (j = 1; j <= N; ++j) f[j] = 2000000005;
for (j = 1; j <= N; ++j) link[j] = 0;
f[0] = A[i].l - 1, p = 0;
for (h = 1; h <= N; ++h) {
j = Q[h];
if (A[j].r > A[i].r || A[j].l < A[i].l) continue;
for (; f[p + 1] < A[j].l; ++p)
;
if (A[j].r < f[p + g[j]]) {
f[p + g[j]] = A[j].r;
link[p + g[j]] = j;
}
}
for (j = N; f[j] == 2000000005; --j)
;
for (h = j; h; h -= g[link[h]]) res[i][++res[i][0]] = link[h];
res[i][++res[i][0]] = i;
g[i] = j + 1;
}
for (j = 1; j <= N; ++j) f[j] = 2000000005;
for (j = 1; j <= N; ++j) link[j] = 0;
f[0] = A[1].l - 1, p = 0;
for (h = 1; h <= N; ++h) {
j = Q[h];
for (; f[p + 1] < A[j].l; ++p)
;
if (A[j].r < f[p + g[j]]) {
f[p + g[j]] = A[j].r;
link[p + g[j]] = j;
}
}
for (j = N; f[j] == 2000000005; --j)
;
printf("%d\n", j);
for (h = j; h; h -= g[link[h]]) Get(link[h]);
sort(Out + 1, Out + j + 1);
for (i = 1; i < j; ++i) printf("%d ", Out[i]);
printf("%d\n", Out[j]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, c;
cin >> n;
int a = 0, b = 0;
for (int i = 0; i < n; i++) {
cin >> c;
if (c == 0)
a++;
else
b++;
}
if (a == 0) {
cout << -1;
return 0;
}
if (b < 9) {
cout << 0;
return 0;
}
int k = b / 9;
for (int i = 0; i < k; i++) cout << "555555555";
for (int i = 0; i < a; i++) cout << "0";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 100;
long long ans[maxn];
int main() {
long long n, m;
scanf("%I64d%I64d", &n, &m);
for (int i = 1; i <= n; ++i) scanf("%d", &ans[i]);
int res1 = 0;
for (int i = 1; i <= n; i++) {
if ((long long)i * (1 + i) / 2 > m) {
res1 = i;
break;
} else if ((long long)i * (1 + i) / 2 == m) {
cout << ans[i] << endl;
return 0;
}
}
cout << ans[(long long)m - res1 * (res1 - 1) / 2] << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int m;
bool w[10];
vector<int> ans;
bool dfs(int curr, int lastmove, int iter) {
if (abs(curr) > 10) return false;
if (iter == m) return true;
for (int i = 0; i < 10; i++) {
if (w[i] && i != lastmove) {
if (iter % 2 == 0) {
if (curr + (i + 1) > 0) {
if (dfs(curr + i + 1, i, iter + 1)) {
ans.push_back(i + 1);
return true;
}
}
} else {
if (curr - (i + 1) < 0) {
if (dfs(curr - i - 1, i, iter + 1)) {
ans.push_back(i + 1);
return true;
}
}
}
}
}
return false;
}
int main() {
string s;
cin >> s;
cin >> m;
for (int i = 0; i < 10; i++) w[i] = (s[i] == '1');
if (dfs(0, -1, 0)) {
cout << "YES" << endl;
int size = ans.size();
for (int i = size - 1; i >= 0; i--) {
cout << ans[i] << " ";
}
cout << endl;
} else {
cout << "NO" << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void __print(long long x) { cout << x; }
void __print(double x) { cout << x; }
void __print(long double x) { cout << x; }
void __print(char x) { cout << '\'' << x << '\''; }
void __print(const char *x) { cout << '\"' << x << '\"'; }
void __print(const string &x) { cout << '\"' << x << '\"'; }
void __print(bool x) { cout << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cout << '{';
__print(x.first);
cout << ',';
__print(x.second);
cout << '}';
}
template <typename T>
void __print(const T &x) {
long long f = 0;
cout << '{';
for (auto &i : x) cout << (f++ ? "," : ""), __print(i);
cout << "}";
}
void _print() { cout << "\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cout << ", ";
_print(v...);
}
signed main() {
long long n;
cin >> n;
vector<long long> v(n);
map<long long, long long> mp;
for (long long i = 0; i < n; i++) {
cin >> v[i];
mp[v[i]]++;
}
vector<pair<long long, long long>> vp(n + 1);
for (long long i = 1; i <= n; i++) {
vp[i].first = i;
vp[i].second = mp[i];
}
long long ans = 0;
for (long long i = 1; i <= n; i++) {
if (i < n) {
if (vp[i].second > 0) {
long long to_shift = vp[i].second - 1;
vp[i + 1].second += to_shift;
ans += to_shift;
}
}
}
long long to_add = ((vp[n].second - 1) * (vp[n].second)) / 2;
cout << ans + to_add << "\n";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long w, a[9];
long long solve(long long cap, int maxitem) {
if (maxitem == 0) return 0;
long long cnt = (cap >= maxitem * a[maxitem]) ? a[maxitem] : cap / maxitem;
long long x = solve(cap - maxitem * cnt, maxitem - 1) + maxitem * cnt;
long long y =
cnt ? solve(cap - maxitem * (cnt - 1), maxitem - 1) + maxitem * (cnt - 1)
: 0;
long long z =
maxitem > 1 && cnt > 2
? solve(cap - maxitem * (cnt - 2), maxitem - 1) + maxitem * (cnt - 2)
: 0;
return max(max(x, y), z);
}
int main(void) {
cin >> w;
for (int i = 1; i < 9; i++) cin >> a[i];
cout << solve(w, 8);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline string DISPLAYBIT(T n, int s, int e) {
string a;
while (s >= e) {
if (s < sizeof(n) * CHAR_BIT)
((sizeof(n) == 4) && (((n) & (1 << (s))) != 0)) ||
((sizeof(n) == 8) && (((n) & (((long long)(1)) << (s))) != 0))
? a += '1'
: a += '0';
s--;
}
return a;
}
template <class T>
inline int COUNTBIT(T n) {
return (sizeof(n) == 4) ? __builtin_popcount(n) : __builin_popcountl(n);
}
template <class T>
inline int LSB(T n) {
return (sizeof(n) == 4) ? __builtin_ffs(n) - 1 : __builtin_ffsl(n) - 1;
}
template <class T>
inline int MSB(T n) {
return (sizeof(n) == 4) ? 31 - __builtin_clz(n) : 63 - __builtin_clzl(n);
}
template <class T>
inline T GCD(T a, T b) {
if (a < 0) return GCD(-a, b);
if (b < 0) return GCD(a, -b);
return (b == 0) ? a : GCD(b, a % b);
}
template <class T>
inline T LCM(T a, T b) {
if (a < 0) return LCM(-a, b);
if (b < 0) return LCM(a, -b);
return a * (b / GCD(a, b));
}
template <class T>
inline T EUCLIDEAN(T a, T b, T& x, T& y) {
if (a < 0) {
T d = EUCLIDEAN(-a, b, x, y);
x = -x;
return d;
}
if (b < 0) {
T d = EUCLIDEAN(a, -b, x, y);
y = -y;
return d;
}
if (b == 0) {
x = 1;
y = 0;
return a;
} else {
T d = EUCLIDEAN(b, a % b, x, y);
T t = x;
x = y;
y = t - (a / b) * y;
return d;
}
}
template <class T>
inline vector<pair<T, int> > FACTORISE(T n) {
vector<pair<T, int> > R;
for (T i = 2; n > 1;) {
if (n % i == 0) {
int C = 0;
for (; n % i == 0; C++, n /= i)
;
R.push_back(make_pair(i, C));
}
i++;
if (i > n / i) i = n;
}
if (n > 1) R.push_back(make_pair(n, 1));
return R;
}
template <class T>
inline vector<pair<int, int> > FACTORIZE(int n) {
if (n > 1e7) return FACTORISE(n);
vector<pair<int, int> > R;
vector<int> a(({
int b = ceil(sqrt(n));
vector<int> d(n, 0);
vector<int> e;
int f = 2;
e.push_back(2);
e.push_back(3);
for (int x = 1; x < b + 1; x++) {
for (int y = 1; y < b + 1; y++) {
int n = (4 * x * x) + (y * y);
if (n <= n && (n % 12 == 1 || n % 12 == 5)) {
d[n] ^= 1;
}
n = (3 * x * x) + (y * y);
if (n <= n && n % 12 == 7) {
d[n] ^= 1;
}
n = (3 * x * x) - (y * y);
if (x > y && n <= n && n % 12 == 11) {
d[n] ^= 1;
}
}
}
for (int r = 5; r < b + 1; r++) {
if (d[r]) {
for (int i = r * r; i < n; i += (r * r)) {
d[i] = 0;
}
}
}
for (int c = 5; c < n; c++) {
if (d[c]) {
e.push_back(c);
}
}
e;
}));
int i;
if (a[({
int z = (lower_bound((a).begin(), (a).end(), n) - (a).begin());
(z == 0 && a[0] != n) ? -1 : z;
})] == n) {
R.push_back(make_pair(n, 1));
return R;
}
int b = (int)sqrt(n);
for (i = 0; a[i] <= b; i++) {
if (n % a[i] == 0) {
int d = 0;
for (; n % a[i] == 0; d++, n /= a[i])
;
R.push_back(make_pair(a[i], d));
}
}
for (; a[i] < n; i++) {
if (n % a[i] == 0) {
R.push_back(make_pair(a[i], 1));
break;
}
}
return R;
}
template <class T>
inline bool IZPRIME(T n) {
if (n <= 1) return false;
for (T i = 2; i * i <= n; i++)
if (n % i == 0) return false;
return true;
}
template <class T>
inline bool ISPRIME(T n) {
if (n > 1e7) return IZPRIME(n);
vector<int> a(({
int b = ceil(sqrt(n));
vector<int> d(n, 0);
vector<int> e;
int f = 2;
e.push_back(2);
e.push_back(3);
for (int x = 1; x < b + 1; x++) {
for (int y = 1; y < b + 1; y++) {
int n = (4 * x * x) + (y * y);
if (n <= n && (n % 12 == 1 || n % 12 == 5)) {
d[n] ^= 1;
}
n = (3 * x * x) + (y * y);
if (n <= n && n % 12 == 7) {
d[n] ^= 1;
}
n = (3 * x * x) - (y * y);
if (x > y && n <= n && n % 12 == 11) {
d[n] ^= 1;
}
}
}
for (int r = 5; r < b + 1; r++) {
if (d[r]) {
for (int i = r * r; i < n; i += (r * r)) {
d[i] = 0;
}
}
}
for (int c = 5; c < n; c++) {
if (d[c]) {
e.push_back(c);
}
}
e;
}));
int b = ({
int z = (lower_bound((a).begin(), (a).end(), n) - (a).begin());
(z == 0 && a[0] != n) ? -1 : z;
});
return (b != -1 && a[b] == n);
}
template <class T>
inline T TOTIENT(T n) {
vector<pair<T, int> > R = FACTORIZE(n);
T r = n;
for (int i = 0; i < R.size(); i++) r = r / R[i].first * (R[i].first - 1);
return r;
}
template <class T>
inline T CHECKMOD(T n, T m) {
return (n % m + m) % m;
}
template <class T>
inline T MULTIPLYMOD(T a, T b, T m) {
return (
T)((((long long)(a) * (long long)(b) % (long long)(m)) + (long long)(m)) %
(long long)(m));
}
template <class T>
inline T DIVIDEMOD(T a, T b, T m) {
T x, y;
EUCLIDEAN(b, m, x, y);
return MULTIPLYMOD(a, x, m);
}
template <class T>
inline T POWERMOD(T p, int e, T m) {
if (e == 0)
return 1 % m;
else if (e % 2 == 0) {
T t = POWERMOD(p, e / 2, m);
return MULTIPLYMOD(t, t, m);
} else
return MULTIPLYMOD(POWERMOD(p, e - 1, m), p, m);
}
template <class T>
inline void SHOWMATRIX(vector<vector<T> >& A) {
for (int i = 0; i < ((int)(A).size()); i++) {
for (int j = 0; j < ((int)(A[0]).size()); j++) cout << A[i][j] << " ";
cout << endl;
}
}
template <class T>
inline void COPYMATRIX(int m, int n, vector<vector<T> >& A,
vector<vector<T> >& B) {
B.clear();
B.resize(n - m + 1, vector<T>(n - m + 1));
for (int i = m, k = 0; i <= n; i++, k++) {
for (int j = m, l = 0; j <= n; j++, l++) B[k][l] = A[i][j];
}
}
template <class T>
inline void IDENTITYMATRIX(int n, vector<vector<T> >& A) {
A.clear();
A.resize(n, vector<T>(n));
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) A[i][j] = (i == j) ? 1 : 0;
}
template <class T, class BinaryOperation>
inline void CHECKMATRIX(vector<vector<T> > A, vector<vector<T> > B,
vector<vector<T> >& C, BinaryOperation b) {
int n = ((int)(A).size());
C.clear();
C.resize(((int)(A).size()), vector<T>(((int)(A).size())));
for (int i = 0; i < ((int)(A).size()); i++)
for (int j = 0; j < ((int)(A[0]).size()); j++)
C[i][j] = b(A[i][j], B[i][j]);
}
template <class T>
inline void mulMatrix(vector<vector<T> > A, vector<vector<T> > B,
vector<vector<T> >& C) {
C.clear();
C.resize(((int)(A).size()), vector<T>(((int)(B[0]).size())));
for (int i = 0; i < ((int)(A).size()); i++)
for (int j = 0; j < ((int)(B[0]).size()); j++)
for (int k = 0; k < ((int)(B).size()); k++) C[i][j] += A[i][k] * B[k][j];
}
template <class T>
inline void TRANSMATRIX(vector<vector<T> >& B, vector<vector<T> >& A) {
B.clear();
B.resize(((int)(A[0]).size()), vector<T>(((int)(A).size())));
for (int i = 0; i < ((int)(B).size()); i++) {
for (int j = 0; j < ((int)(B[0]).size()); j++) B[i][j] = A[j][i];
}
}
template <class T, class BinaryOperation>
inline void SCALARMATRIX(vector<vector<T> >& B, vector<vector<T> >& A, T c,
BinaryOperation d) {
B.clear();
B.resize(((int)(A[0]).size()), vector<T>(((int)(A).size())));
for (int i = 0; i < ((int)(B).size()); i++) {
for (int j = 0; j < ((int)(B[0]).size()); j++) B[i][j] = d(A[j][i], c);
}
}
template <class T>
inline string TOSTRING(T n) {
ostringstream ost;
ost << n;
ost.flush();
return ost.str();
}
template <class T>
inline void TOVAR(string s, T& r) {
istringstream sin(s);
sin >> r;
}
template <class T>
inline void STOV(string s, vector<T>& vi) {
vi.clear();
istringstream sin(s);
for (T v; sin >> v; vi.push_bakc(v))
;
}
template <class T>
inline void VTOS(vector<T> vi, string& s) {
ostringstream sout;
for (int i = 0; i < vi.size(); i++) {
if (i > 0) sout << ' ';
sout << vi[i];
}
s = sout.str();
}
template <class T>
inline vector<T> ATOV(T a[]) {
vector<T> v(a, a + sizeof(a) / sizeof(T));
return v;
}
template <class T>
struct Fraction {
T a, b;
Fraction(T a = 0, T b = 1);
string toString();
};
template <class T>
Fraction<T>::Fraction(T a, T b) {
T d = GCD(a, b);
a /= d;
b /= d;
if (b < 0) a = -a, b = -b;
this->a = a;
this->b = b;
}
template <class T>
string Fraction<T>::toString() {
ostringstream sout;
sout << a << "/" << b;
return sout.str();
}
template <class T>
Fraction<T> operator+(Fraction<T> p, Fraction<T> q) {
return Fraction<T>(p.a * q.b + q.a * p.b, p.b * q.b);
}
template <class T>
Fraction<T> operator-(Fraction<T> p, Fraction<T> q) {
return Fraction<T>(p.a * q.b - q.a * p.b, p.b * q.b);
}
template <class T>
Fraction<T> operator*(Fraction<T> p, Fraction<T> q) {
return Fraction<T>(p.a * q.a, p.b * q.b);
}
template <class T>
Fraction<T> operator/(Fraction<T> p, Fraction<T> q) {
return Fraction<T>(p.a * q.b, p.b * q.a);
}
int n, m, start_x, start_y;
vector<string> G;
vector<vector<pair<int, int> > > chk;
vector<vector<bool> > vis;
struct elem {
int x, y, maze_x, maze_y;
};
int main() {
double tmp_start = clock();
fprintf(stderr, "Start\n");
n = ({
int x;
scanf("%d", &x);
x;
}),
m = ({
int x;
scanf("%d", &x);
x;
});
G.clear();
vis.resize(n, vector<bool>(m, 0));
chk.resize(n, vector<pair<int, int> >(m, make_pair((int)1e9, (int)1e9)));
for (int i = 0; i < n; i++) {
string temp;
cin >> temp;
for (int j = 0; j < ((int)(temp).size()); j++)
if (temp[j] == 'S') {
start_x = i;
start_y = j;
}
G.push_back(temp);
}
pair<int, int> dir[4] = {make_pair(-1, 0), make_pair(1, 0), make_pair(0, 1),
make_pair(0, -1)};
bool ans = 0;
stack<elem> Q;
elem start;
start.x = start_x, start.y = start_y, start.maze_x = 0, start.maze_y = 0;
Q.push(start);
vis[start_x][start_y] = 1;
chk[start_x][start_y] = make_pair(start.maze_x, start.maze_y);
while (!Q.empty()) {
elem S = Q.top();
Q.pop();
for (int i = 0; i < 4; i++) {
int x = S.x + dir[i].first;
int y = S.y + dir[i].second;
int maze_x = S.maze_x, maze_y = S.maze_y;
if (x < 0) {
x = n - 1;
maze_x--;
}
if (y < 0) {
y = m - 1;
maze_y--;
}
if (x >= n) {
x = 0;
maze_x++;
}
if (y >= m) {
y = 0;
maze_y++;
}
if (G[x][y] == '#') continue;
if (vis[x][y]) {
if (chk[x][y] != make_pair(maze_x, maze_y)) {
ans = true;
break;
}
} else {
elem t = {x, y, maze_x, maze_y};
vis[x][y] = 1;
chk[x][y] = make_pair(maze_x, maze_y);
Q.push(t);
}
}
if (ans) break;
}
if (ans)
cout << "Yes\n";
else
cout << "No\n";
fprintf(stderr, "Total time = %.2lf sec\n",
(double)(clock() - tmp_start) / CLOCKS_PER_SEC);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int b[305];
vector<int> g[305];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", b + i);
b[0] = 0;
g[0].push_back(0);
for (int i = 1; i <= n; i++) {
if (b[i] > b[i - 1]) {
int temp = b[i] - b[i - 1];
for (int j = g[i - 1].size() - 1; j >= 0; j--) {
int now = g[i - 1][j];
if (temp == 0) break;
if (temp > 9 - now) {
g[i].push_back(9);
temp -= (9 - now);
} else {
g[i].push_back(now + temp);
temp = 0;
for (int k = j - 1; k >= 0; k--) g[i].push_back(g[i - 1][k]);
}
}
while (temp) {
if (temp >= 9) {
g[i].push_back(9);
temp -= 9;
} else {
g[i].push_back(temp);
temp = 0;
}
}
} else {
int temp = b[i - 1] - b[i] + 1;
int flag = g[i - 1].size() - 1;
int sum = 0;
for (int j = g[i - 1].size() - 1; j >= 0; j--) {
sum += g[i - 1][j];
if (sum >= temp) {
flag = j - 1;
break;
}
}
while (flag >= 0 && g[i - 1][flag] == 9) {
flag--;
}
int p = flag;
for (int j = g[i - 1].size() - 1; j >= flag + 1; j--)
g[i].push_back(g[i - 1][j]);
sort(g[i].begin(), g[i].end());
for (int j = 0; j < g[i].size(); j++) {
if (temp > g[i][j]) {
temp -= g[i][j];
g[i][j] = 0;
} else {
g[i][j] -= temp;
temp = 0;
break;
}
}
reverse(g[i].begin(), g[i].end());
int ad = 1;
for (int j = p; j >= 0; j--) {
int now = g[i - 1][j];
if (now + ad == 10) {
g[i].push_back(9);
ad = 1;
} else {
g[i].push_back(now + ad);
ad = 0;
}
}
if (ad == 1) g[i].push_back(1);
}
reverse(g[i].begin(), g[i].end());
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j < g[i].size(); j++) printf("%d", g[i][j]);
printf("\n");
}
}
| 6 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
string names[11];
int a[11][101];
int b[11][101];
int c[11][101];
int main(int argc, char **argv) {
int n, m, k;
vector<pair<int, int> > r;
scanf("%d %d %d", &n, &m, &k);
for (int i = 0; i < n; i++) {
cin >> names[i];
for (int j = 0; j < m; j++) {
scanf("%d %d %d", &a[i][j], &b[i][j], &c[i][j]);
}
}
int ans = 0;
for (int i1 = 0; i1 < n; i1++)
for (int i2 = 0; i2 < n; i2++) {
int cost = 0;
r.clear();
for (int l = 0; l < m; l++)
if (b[i2][l] - a[i1][l] > 0) {
r.push_back(make_pair(b[i2][l] - a[i1][l], c[i1][l]));
}
sort(r.begin(), r.end());
int ck = 0;
for (int i = r.size(); i--;) {
int d = min(r[i].second, k - ck);
cost += r[i].first * d;
ck += d;
}
if (cost > ans) {
ans = cost;
}
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e9 + 7;
const long long INF = 1LL << 60;
const long long mod = 1e9 + 7;
const long double eps = 1e-8;
const long double pi = acos(-1.0);
template <class T>
inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
struct P {
long long x, y;
};
long double ex(P s, P t, P r) {
long double x1 = (long double)t.x - (long double)s.x;
long double y1 = (long double)t.y - (long double)s.y;
long double x2 = (long double)r.x - (long double)s.x;
long double y2 = (long double)r.y - (long double)s.y;
return x1 * y2 - x2 * y1;
}
bool cross(P a, P b, P s, P t) {
if (ex(a, b, s) * ex(a, b, t) > 0) return false;
if (ex(b, a, s) * ex(b, a, t) > 0) return false;
if (ex(t, s, a) * ex(t, s, b) > 0) return false;
return ex(s, t, a) * ex(s, t, b) < eps;
}
pair<bool, pair<long double, long double>> intersection_ls(P a1, P a2, P b1,
P b2) {
long double d1 = abs(ex(b1, a1, b2));
long double d2 = abs(ex(b1, a2, b2));
if (!cross(a1, a2, b1, b2)) {
return {false, {0.0, 0.0}};
}
return {true,
{a1.x + (a2.x - a1.x) * d1 / (d1 + d2),
a1.y + (a2.y - a1.y) * d1 / (d1 + d2)}};
}
long long gcd(long long x, long long y) {
if (y == 0) return x;
return gcd(y, x % y);
}
void solve() {
long long n;
cin >> n;
vector<pair<P, P>> vec;
long long ans = 0;
for (long long i = 0; i < n; i++) {
long long ax, ay, bx, by;
cin >> ax >> ay >> bx >> by;
vec.push_back({P{ax, ay}, P{bx, by}});
ans += gcd(abs(ax - bx), abs(ay - by)) + 1;
}
map<pair<long long, long long>, long long> mp;
for (long long i = 0; i < n; i++) {
for (long long j = i + 1; j < n; ++j) {
auto res = intersection_ls(vec[i].first, vec[i].second, vec[j].first,
vec[j].second);
if (!res.first) continue;
long double X = res.second.first, Y = res.second.second;
if (floor(X + eps) < X + 2 * eps && floor(X + eps) > X - 2 * eps) {
if (floor(Y + eps) < Y + 2 * eps && floor(Y + eps) > Y - 2 * eps) {
mp[{floor(X + eps), floor(Y + eps)}]++;
}
}
}
}
for (auto p : mp) {
long long k = 2;
while (k * (k - 1) / 2 <= p.second) {
if (k * (k - 1) / 2 == p.second) {
ans -= (k - 1);
break;
}
++k;
}
}
cout << ans << endl;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x1, y1, z1, x2, y2, z2;
cin >> x1 >> y1 >> z1;
cin >> x2 >> y2 >> z2;
if (x1 == x2 || y1 == y2 || z1 == z2)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
const int maxn = 5e5 + 555;
char str[maxn];
map<char, int>cnt;
int n, k;
inline int cal(char c) {
return (k - (cnt[c] % k)) % k;
}
void solve() {
cnt.clear();
scanf("%d %d", &n, &k);
scanf("%s", str + 1);
int tot = 0;
if (n % k) {
puts("-1");
return;
}
int pos = 0;
char posc = 'a';
for (int i = 1; i <= n; i++) {
int le = n - i;
for (char nowc = str[i] + 1; nowc <= 'z'; nowc++) {
tot -= cal(nowc);
cnt[nowc]++;
tot += cal(nowc);
if (tot <= le) {
if (pos < i) {
pos = i;
posc = nowc;
}
}
tot -= cal(nowc);
cnt[nowc]--;
tot += cal(nowc);
}
char nowc = str[i];
tot -= cal(nowc);
cnt[nowc]++;
tot += cal(nowc);
}
if (tot == 0) {
printf("%s\n", str + 1);
return;
}
cnt.clear();
str[pos] = posc;
for (int i = 1; i <= pos; i++) {
cnt[str[i]]++;
}
tot = 0;
for (char nowc = 'a'; nowc <= 'z'; nowc++) {
tot += cal(nowc);
}
int more = (n - pos) - tot;
for (int i = 1; i <= more; i++)
str[i + pos] = 'a';
char cc = 'a';
for (int i = more + pos + 1; i <= n; i++) {
while (cal(cc) == 0)
cc++;
str[i] = cc;
cnt[cc]++;
}
printf("%s\n", str + 1);
}
signed main() {
//freopen("in.txt", "r", stdin);
int T = 1;
cin >> T;
while (T--)
solve();
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long Mo = 1000000007LL;
struct matrix {
long long v[2][2];
void operator*=(matrix b) {
matrix a;
memcpy(a.v, v, sizeof(v));
memset(v, 0, sizeof(v));
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++)
for (int k = 0; k < 2; k++)
v[i][j] += a.v[i][k] * b.v[k][j], v[i][j] %= Mo;
}
bool operator==(matrix b) {
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++)
if (v[i][j] != b.v[i][j]) return false;
return true;
}
} uni, mark[101000 << 2], trans, Trans;
struct str {
long long a, b;
void operator*=(matrix x) {
long long a_ = a, b_ = b;
a = a_ * x.v[0][0] + b_ * x.v[1][0];
a %= Mo;
b = a_ * x.v[0][1] + b_ * x.v[1][1];
b %= Mo;
}
} temp, val[101000 << 2];
str operator+(str a, str b) {
return (str){(a.a + b.a) % Mo, (a.b + b.b) % Mo};
}
int n, m;
long long A[101000];
matrix fpm(long long b) {
matrix ans = uni;
matrix a = trans;
for (; b; b >>= 1) {
if (b & 1LL) ans *= a;
a *= a;
}
return ans;
}
void build(int u, int L, int R) {
mark[u] = uni;
if (L == R) {
val[u] = temp;
val[u] *= fpm(A[L] - 1);
return;
}
build((u << 1), L, ((L + R) >> 1));
build(((u << 1) + 1), (((L + R) >> 1) + 1), R);
val[u] = val[(u << 1)] + val[((u << 1) + 1)];
}
void down(int u, int L, int R) {
if (mark[u] == uni) return;
val[u] *= mark[u];
if (L < R) {
mark[(u << 1)] *= mark[u];
mark[((u << 1) + 1)] *= mark[u];
}
mark[u] = uni;
return;
}
void change(int u, int L, int R, int l, int r) {
down(u, L, R);
if (L == l && R == r) {
mark[u] *= Trans;
down(u, L, R);
return;
}
if (r < (((L + R) >> 1) + 1))
down(((u << 1) + 1), (((L + R) >> 1) + 1), R),
change((u << 1), L, ((L + R) >> 1), l, r);
else if (l > ((L + R) >> 1))
down((u << 1), L, ((L + R) >> 1)),
change(((u << 1) + 1), (((L + R) >> 1) + 1), R, l, r);
else
change((u << 1), L, ((L + R) >> 1), l, ((L + R) >> 1)),
change(((u << 1) + 1), (((L + R) >> 1) + 1), R, (((L + R) >> 1) + 1),
r);
val[u] = val[(u << 1)] + val[((u << 1) + 1)];
}
str find(int u, int L, int R, int l, int r) {
down(u, L, R);
if (L == l && R == r) return val[u];
if (r < (((L + R) >> 1) + 1))
return find((u << 1), L, ((L + R) >> 1), l, r);
else if (l > ((L + R) >> 1))
return find(((u << 1) + 1), (((L + R) >> 1) + 1), R, l, r);
else {
return find((u << 1), L, ((L + R) >> 1), l, ((L + R) >> 1)) +
find(((u << 1) + 1), (((L + R) >> 1) + 1), R, (((L + R) >> 1) + 1),
r);
}
}
int main() {
scanf("%d %d", &n, &m);
trans.v[1][1] = trans.v[0][1] = trans.v[1][0] = 1;
uni.v[0][0] = uni.v[1][1] = 1;
temp.a = 0;
temp.b = 1;
for (int i = 1; i <= n; i++) scanf("%I64d", &A[i]);
build(1, 1, n);
for (; m; m--) {
int t, l, r, x;
scanf("%d %d %d", &t, &l, &r);
if (t == 1) {
scanf("%d", &x);
Trans = fpm(x);
change(1, 1, n, l, r);
} else {
str u = find(1, 1, n, l, r);
printf("%I64d\n", u.b);
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
long long fp(long long x, int k = 998244353 - 2) {
long long ans = 1;
while (k) {
if (k & 1) ans = ans * x % 998244353;
x = x * x % 998244353, k >>= 1;
}
return ans;
}
long long a[524444], b[524444], w[524444], w2[524444];
int n, c[3000006], m;
struct S {
int n;
vector<int> v;
} s[400005];
priority_queue<pair<int, int> > q;
void gen() {
w[0] = w2[0] = 1, w[1] = w2[n - 1] = fp(3, (998244353 - 1) / n);
for (int i = 2; i < n; ++i) w[i] = w2[n - i] = w[i - 1] * w[1] % 998244353;
}
void ntt(long long *a, long long *w) {
for (int i = 0, j = 0; i < n; ++i) {
if (i < j) swap(a[i], a[j]);
for (int k = n >> 1; (j ^= k) < k; k >>= 1)
;
}
for (int i = 2; i <= n; i <<= 1) {
for (int j = 0; j < n; j += i) {
for (int k = 0; k < (i >> 1); ++k) {
int l = j + k, r = l + (i >> 1);
long long o = a[r] * w[n / i * k] % 998244353;
a[r] = (a[l] + 998244353 - o) % 998244353,
a[l] = (a[l] + o) % 998244353;
}
}
}
}
void mul() {
ntt(a, w), ntt(b, w);
long long r = fp(n);
for (int i = 0; i < n; ++i) a[i] = a[i] * b[i] % 998244353 * r % 998244353;
ntt(a, w2);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
int p;
scanf("%d", &p);
++c[p];
}
for (int i = 1; i <= 3000000; ++i) {
if (!c[i]) continue;
++m;
s[m].n = c[i];
for (int j = 0; j <= c[i]; ++j) s[m].v.push_back(1);
q.push(make_pair(-c[i], m));
}
int N = n;
for (int _ = m; _ > 1; --_) {
int x = q.top().second;
q.pop();
int y = q.top().second;
q.pop();
int z = s[x].n + s[y].n;
n = 1;
while (n <= z) n <<= 1;
for (int i = 0; i <= s[x].n; ++i) a[i] = s[x].v[i];
for (int i = s[x].n + 1; i < n; ++i) a[i] = 0;
for (int i = 0; i <= s[y].n; ++i) b[i] = s[y].v[i];
for (int i = s[y].n + 1; i < n; ++i) b[i] = 0;
gen();
mul();
++m;
s[m].n = n - 1;
for (int i = 0; i < n; ++i) s[m].v.push_back(a[i]);
q.push(make_pair(1 - n, m));
}
printf("%d\n", s[m].v[(N + 1) / 2]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
string s, ans = "";
cin >> s;
int n = s.length();
if (count(s.begin(), s.end(), '0') == n ||
count(s.begin(), s.end(), '1') == n) {
cout << s << endl;
continue;
}
int i = 0;
ans += s[0];
for (int i = 1; i < n; i++) {
if ((s[i - 1] - '0') ^ (s[i] - '0') == 1)
ans += s[i];
else {
ans += (s[i] - '0') ^ 1 + '0';
ans += s[i];
}
}
cout << ans << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; }
inline bool isLeapYear(long long int year) {
return (year % 400 == 0) | (year % 4 == 0 && year % 100 != 0);
}
inline void normal(long long int &a) {
a %= 1000000007;
(a < 0) && (a += 1000000007);
}
inline long long int modMul(long long int a, long long int b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
return (a * b) % 1000000007;
}
inline long long int modAdd(long long int a, long long int b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
return (a + b) % 1000000007;
}
inline long long int modSub(long long int a, long long int b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
a -= b;
normal(a);
return a;
}
inline long long int modPow(long long int b, long long int p) {
long long int r = 1;
while (p) {
if (p & 1) r = modMul(r, b);
b = modMul(b, b);
p >>= 1;
}
return r;
}
inline long long int modInverse(long long int a) {
return modPow(a, 1000000007 - 2);
}
inline long long int modDiv(long long int a, long long int b) {
return modMul(a, modInverse(b));
}
inline bool isInside(pair<int, int> p, long long int n, long long int m) {
return (p.first >= 0 && p.first < n && p.second >= 0 && p.second < m);
}
inline bool isInside(pair<int, int> p, long long int n) {
return (p.first >= 0 && p.first < n && p.second >= 0 && p.second < n);
}
inline bool isSquare(long long int x) {
long long int s = sqrt(x);
return (s * s == x);
}
inline bool isFib(long long int x) {
return isSquare(5 * x * x + 4) || isSquare(5 * x * x - 4);
}
inline bool isPowerOfTwo(long long int x) {
return ((1LL << (long long int)log2(x)) == x);
}
struct func {
bool operator()(pair<int, int> const &a, pair<int, int> const &b) {
if (a.first == b.first) return (a.second < b.second);
return (a.first < b.first);
}
};
const long long int INF = 0x3f3f3f3f3f3f3f3f;
const long double EPS = 1e-9;
const int inf = 0x3f3f3f3f;
const int mx = (int)1e5 + 9;
struct Point {
long long int s, p, x, y;
string name;
bool operator<(const Point &ob) const {
return s == ob.s ? p < ob.p : s > ob.s;
}
};
double distance(Point a, Point b) {
return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
}
long long int n, m, t, i, j, res;
long long int counT(long long int x[], long long int y[], int N) {
map<pair<long long int, long long int>, long long int> mp;
for (int i = 0; i < N; i++) {
for (int j = i + 1; j < N; j++) {
long long int midX = x[i] + x[j];
long long int midY = y[i] + y[j];
mp[{midX, midY}]++;
}
}
res = 0;
for (auto it : mp) {
long long int freq = it.second;
res += freq * (freq - 1) / 2;
}
return res;
}
int main() {
scanf("%lld", &t);
long long int arr[t + 9], brr[t + 9];
for (int i = 0; i < (t); i++) {
scanf("%lld", &arr[i]);
scanf("%lld", &brr[i]);
}
printf("%lld\n", counT(arr, brr, t));
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int MOD = 100000009;
const int maxn = (int)1e6 + 7;
int main() {
long long n, k;
scanf("%lld", &n);
char ss[maxn], ss2[maxn];
scanf("%s", ss);
scanf("%s", ss2);
int a[28] = {0};
int i1, i2;
int cnt = 1;
int ans = 0;
int res[28][28] = {0};
memset(res, -1, sizeof(res));
for (int i = 0; i < (n); i++) {
i1 = ss[i] - 'a';
i2 = ss2[i] - 'a';
if (i1 == i2) continue;
if (a[i1] == 0 && a[i2] == 0) {
a[i1] = cnt;
a[i2] = cnt;
cnt++;
ans++;
} else if (a[i1] != a[i2]) {
if (a[i1] == 0) a[i1] = a[i2], ans++;
if (a[i2] == 0) a[i2] = a[i1], ans++;
}
if (a[i1] != a[i2]) {
ans++;
int b = a[i2];
for (int j = 0; j < 26; j++) {
if (a[j] == b) a[j] = a[i1];
}
}
}
for (int i = 1; i < cnt; i++) {
int cntt = 0;
for (int j = 0; j < (26); j++) {
if (a[j] == i) res[i][cntt++] = j;
}
}
cout << ans << endl;
for (int i = 1; i < cnt; i++) {
for (int j = 1; res[i][j] != -1; j++) {
cout << char('a' + res[i][j - 1]) << " " << char('a' + res[i][j]) << endl;
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long base = 331;
const int dx[8] = {0, -1, 0, 1, 1, -1, -1, 1};
const int dy[8] = {-1, 0, 1, 0, -1, -1, 1, 1};
const int N = 5005;
int n, a[N];
int ans[N];
int f[N];
int cnt[N];
bool check(int val) {
int k = (int)sqrt(1.00 * val);
return (k * k == val);
}
void gogo() {
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
}
for (int i = 1; i <= n; ++i) {
int value = abs(a[i]);
f[i] = 1e9;
for (int j = 2; j * j <= value; ++j) {
if (value % j == 0) {
int val = value / j;
if (j != 1 && check(val)) {
f[i] = min(f[i], j);
}
val = j;
if (value / j != 1 && check(val)) {
f[i] = min(f[i], value / j);
}
}
}
if (check(value)) {
if (value == 0)
f[i] = 0;
else
f[i] = 1;
}
if (f[i] == 1e9) f[i] = value;
if (a[i] < 0) f[i] = -f[i];
}
vector<int> nen;
for (int i = 1; i <= n; ++i) nen.push_back(f[i]);
sort((nen).begin(), (nen).end());
nen.resize(unique((nen).begin(), (nen).end()) - nen.begin());
for (int i = 1; i <= n; ++i)
f[i] = lower_bound((nen).begin(), (nen).end(), f[i]) - nen.begin();
for (int i = 1; i <= n; ++i) {
int dem = 0;
bool zero = 0;
for (int j = i; j <= n; ++j) {
zero |= (nen[f[j]] == 0);
cnt[f[j]]++;
if (cnt[f[j]] == 1) ++dem;
if (zero && dem >= 2)
++ans[dem - 1];
else
++ans[dem];
}
for (int j = i; j <= n; ++j) cnt[f[j]] = 0;
}
for (int i = 1; i <= n; ++i) cout << ans[i] << ' ';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
if (fopen("sol"
".inp",
"r")) {
freopen(
"sol"
".inp",
"r", stdin);
freopen(
"sol"
".out",
"w", stdout);
}
gogo();
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, a;
long long capSum = 0, t = 0, c;
cin >> n >> k;
vector<pair<int, int>> v(n);
for (int i = 0; i < n; i++) {
cin >> a;
v[i] = make_pair(a, 0);
}
for (int i = 0; i < k; i++) {
cin >> a;
capSum += v[a - 1].first;
v[a - 1].second = 1;
}
c = capSum;
for (int i = 0; i < n; i++) {
if (v[i % n].second == 1) {
c -= v[i % n].first;
t += v[i % n].first * c;
} else {
t += capSum * v[i % n].first;
if (v[(i + 1) % n].second == 1)
continue;
else
t += v[i % n].first * v[(i + 1) % n].first;
}
}
cout << t << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, i, x, b, q, j, s, t, w;
int H[20], Q[10000];
int main() {
cin >> n;
x = n;
while (x) {
H[++s] = x % 10;
x /= 10;
}
t = 1;
for (i = 1; i < s; i++) t *= 10;
for (i = s; i >= 1; i--) {
q = max(H[i], q);
w = 0;
for (j = 0; j < H[i]; j++) Q[++w] += t;
t /= 10;
}
cout << q << endl;
for (i = 1; i <= q; i++) cout << Q[i] << ' ';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
char z[1000];
vector<string> v;
int main() {
int N;
scanf("%d ", &N);
for (int i = 0; i < N; i++) {
scanf("%s ", z);
if (!strcmp(z, "pwd")) {
printf("/");
for (int k = 0; k < (int)v.size(); k++) printf("%s/", v[k].c_str());
printf("\n");
} else if (!strcmp(z, "cd")) {
scanf("%s ", z);
int k = 0;
if (z[0] == '/') {
v.clear();
k = 1;
}
int l = strlen(z);
while (k < l) {
int nk = k;
while (z[nk] && z[nk] != '/') nk++;
z[nk] = 0;
if (!strcmp(z + k, ".."))
v.pop_back();
else
v.push_back(string(z + k));
k = nk + 1;
}
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
const int N = 1e4 + 2;
const long long MOD = 998244353;
const int oo = 1e9;
using namespace std;
int T, n, a[N], F[N][2001];
void solve() {
cin >> n;
for (int i = 0; i <= n; i++) {
if (i) cin >> a[i];
for (int j = 0; j <= 2000; j++) F[i][j] = oo;
}
F[0][0] = 0;
for (int i = 0; i <= n - 1; i++) {
for (int j = 0; j <= 2000; j++) {
if (F[i][j] == oo) continue;
F[i + 1][max(0, j - a[i + 1])] =
min(F[i + 1][max(0, j - a[i + 1])], F[i][j] + max(0, a[i + 1] - j));
F[i + 1][j + a[i + 1]] =
min(F[i + 1][j + a[i + 1]],
(a[i + 1] <= F[i][j] - j ? F[i][j] : a[i + 1] + j));
}
}
int res = oo;
for (int j = 0; j <= 2000; j++) res = min(res, F[n][j]);
cout << res << '\n';
}
int main() {
cin >> T;
while (T--) {
solve();
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int u[20], r[20];
bool seen[23][23] = {};
void dfs(int R, int C) {
seen[R][C] = true;
if (u[C] == 1 && R != 0) {
if (!seen[R - 1][C]) {
dfs(R - 1, C);
}
}
if (u[C] == 0 && R != n - 1) {
if (!seen[R + 1][C]) {
dfs(R + 1, C);
}
}
if (r[R] == 0 && C != 0) {
if (!seen[R][C - 1]) {
dfs(R, C - 1);
}
}
if (r[R] == 1 && C != m - 1) {
if (!seen[R][C + 1]) {
dfs(R, C + 1);
}
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
char x;
cin >> x;
if (x == '<')
r[i] = 0;
else
r[i] = 1;
}
for (int i = 0; i < m; i++) {
char x;
cin >> x;
if (x == '^')
u[i] = 1;
else
u[i] = 0;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
dfs(i, j);
for (int R = 0; R < n; R++) {
for (int C = 0; C < m; C++) {
if (!seen[R][C]) {
cout << "NO";
return 0;
}
seen[R][C] = false;
}
}
}
}
cout << "YES";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n;
cin >> n;
long long int a[200005][2];
for (long long int i = 1; i <= n; i++) {
cin >> a[i][0] >> a[i][1];
}
if (n == 3) {
cout << "1 2 3" << endl;
return 0;
}
long long int c[200005] = {0};
for (long long int i = 1; i <= n; i++) {
if ((a[a[i][0]][0] == a[i][1]) || (a[a[i][0]][1] == a[i][1])) {
c[i] = a[i][0];
} else
c[i] = a[i][1];
}
long long int flag = 0;
for (long long int i = 1, j = 0; j < n; j++) {
cout << i << " ";
i = c[i];
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long maxval = 1e18 + 7;
long long casio[300005][12], cs = 0;
long long dp[300005][12], a[300005], b[300005];
long long n;
long long call(long long pos, long long inc) {
if (pos == n + 1) return 0;
if (casio[pos][inc] == cs) return dp[pos][inc];
casio[pos][inc] = cs;
long long ret = maxval;
long long prev = a[pos - 1] + inc;
for (long long j = 0; j <= 10; j++) {
if (prev != a[pos] + j) {
ret = min(ret, call(pos + 1, j) + (j * b[pos]));
}
}
return dp[pos][inc] = ret;
}
int main() {
ios_base::sync_with_stdio(false);
long long q;
cin >> q;
while (q--) {
cs++;
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> a[i] >> b[i];
}
cout << call(1, 0) << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, a[1000001], d[1000001][25], coun, cnt, pos[1000001][25], q[50];
pair<int, int> minl[50];
map<int, bool> used;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
int cur = a[i];
coun = 0;
while (cur != 0) {
d[i][coun++] = cur % 2;
cur /= 2;
}
if (!used[a[i]]) {
used[a[i]] = 1;
cnt++;
}
}
for (int i = 0; i <= 21; i++) {
if (d[n][i] == 1)
pos[n][i] = n;
else
pos[n][i] = n + 1;
}
for (int i = n - 1; i >= 1; i--) {
for (int j = 0; j <= 21; j++) {
if (d[i][j] == 1)
pos[i][j] = i;
else
pos[i][j] = pos[i + 1][j];
}
}
for (int l = 1; l <= n; l++) {
for (int i = 0; i <= 21; i++) q[i] = 0;
for (int i = 0; i <= 21; i++) {
minl[i].first = pos[l][i];
minl[i].second = i;
}
sort(minl, minl + 22);
for (int i = 0; i < 22; i += 0) {
if (minl[i].first > n) break;
int r = i;
while (r <= 21 && minl[r].first == minl[i].first) q[minl[r++].second] = 1;
int ch = 0, po = 1;
for (int j = 0; j < 22; j++) {
ch += q[j] * po;
po *= 2;
}
if (!used[ch]) {
used[ch] = 1;
cnt++;
}
i = r;
}
}
cout << cnt;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long a[2003][2003];
unordered_map<int, long long> pr;
long long se[4004];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
int i, j;
for (i = 1; i <= n; i++) {
for (j = 1; j <= n; j++) {
cin >> a[i][j];
pr[j - i] += a[i][j];
se[i + j] += a[i][j];
}
}
long long oddp = 0;
long long evenp = 0;
pair<long long, long long> pairOdd = {1, 1};
pair<long long, long long> pairEven = {1, 2};
for (i = 1; i <= n; i++) {
for (j = 1; j <= n; j++) {
long long psum = pr[j - i];
long long ssum = se[i + j];
long long tans = psum + ssum - a[i][j];
if ((i + j) % 2 == 0) {
if (oddp < tans) {
oddp = tans;
pairEven = {i, j};
}
} else {
if (evenp < tans) {
evenp = tans;
pairOdd = {i, j};
}
}
}
}
cout << oddp + evenp << "\n";
cout << pairEven.first << " " << pairEven.second << " " << pairOdd.first
<< " " << pairOdd.second << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int mm = 1e5 + 10;
long long a1, a2, a3, a4, a5, a6, a7, a8, a9, ans, ez1, n, m, k;
vector<pair<int, int>> inp;
int flag[mm];
string s, s1, s2;
void input() { cin >> s; }
void solve() {
a2 = 0;
bool here1 = 0, here2 = 0, here3 = 0;
if (s.size() >= 5) a2++;
for (int i = 0; i < s.size(); i++) {
if (s[i] >= '0' && s[i] <= '9' && !here1) {
a2++;
here1 = 1;
}
if (s[i] >= 'a' && s[i] <= 'z' && !here2) {
a2++;
here2 = 1;
}
if (s[i] >= 'A' && s[i] <= 'Z' && !here3) {
a2++;
here3 = 1;
}
}
if (a2 >= 4)
cout << "Correct" << endl;
else
cout << "Too weak" << endl;
}
int main() {
input();
solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
int main() {
int n;
scanf("%d", &n);
int k = n / 2;
printf("%d\n", k);
for (int i = 0; i < k - 1; i++) printf("2 ");
if (n % 2)
printf("3");
else
printf("2");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long M = 1e9 + 7;
const long long N = 2e5 + 10;
vector<long long> fact(N), ifact(N);
long long inv(long long x) {
long long res = 1;
long long b = M - 2;
while (b) {
if (b & 1) res = (res * x) % M;
x = (x * x) % M;
b >>= 1;
}
return res;
}
void init() {
fact[0] = 1;
for (long long i = 1; i < N; i++) fact[i] = (fact[i - 1] * i) % M;
ifact[(long long)2e5] = inv(fact[(long long)2e5]);
for (long long i = (long long)2e5 - 1; i >= 0; i--)
ifact[i] = (ifact[i + 1] * (i + 1)) % M;
}
long long ncr(long long n, long long r) {
if (r > n) return 0;
long long res = fact[n];
res = (res * ifact[r]) % M;
res = (res * ifact[n - r]) % M;
return res;
}
long long power(long long x, long long y, long long p) {
long long res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
long long t = 1;
while (t--) {
long long n, m;
cin >> n >> m;
long long a[100005], b[100005];
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < m; i++) cin >> b[i];
int l = 0, max = 0;
for (int i = 0; i < n; i++) {
while (abs(b[l] - a[i]) >= abs(b[l + 1] - a[i]) and l < m - 1) {
l++;
}
if (max < abs(b[l] - a[i])) max = abs(b[l] - a[i]);
}
cout << max;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int x, n, m, temp = 0;
cin >> x >> n >> m;
for (int i = 0; i <= n; i++) {
if (x <= 10 * m) {
temp = 1;
break;
} else
x = x / 2 + 10;
}
if (temp == 1)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 111;
const int INF = 1e9;
int tt, k;
int a[7];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> tt;
for (int t = 0; t < tt; ++t) {
cin >> k;
int sum = 0;
for (int i = 0; i < 7; ++i) {
cin >> a[i];
sum += a[i];
}
int mn = INF;
for (int i = 0; i < 7; ++i) {
int cur = 0;
int ds = 0;
for (int j = i; j < 7; ++j) {
cur += a[j];
if (cur == k) {
if (mn > j - i + 1) {
mn = j - i + 1;
}
break;
}
}
ds = 7 - i;
if ((k - cur) % sum != 0) {
ds += 7 * ((k - cur) / sum);
cur += (((k - cur) / sum)) * sum;
} else {
ds += 7 * ((k - cur) / sum - 1);
cur += (((k - cur) / sum) - 1) * sum;
}
int id = 0;
while (cur != k) {
cur += a[id];
id++, ds++;
}
mn = min(mn, ds);
}
cout << mn << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const int IDK = 450 + (rand() % 50);
int n, d, x;
int a[N], b[N], c;
int pos[N];
int arr[N];
int siz;
int getnextX() { return x = (37LL * x + 10007) % 1000000007; }
int main() {
scanf("%d %d %d", &n, &d, &x);
for (int i = 0; i < n; ++i) {
a[i] = i + 1;
swap(a[i], a[getnextX() % (i + 1)]);
}
for (int i = 0; i < n; ++i) {
b[i] = i < d;
pos[a[i]] = i;
swap(b[i], b[getnextX() % (i + 1)]);
}
siz = 0;
for (int i = 0; i < n; ++i) {
if (b[i]) {
arr[++siz] = i;
}
c = 0;
if (siz < IDK) {
for (int j = 1; j <= siz; ++j) {
c = max(c, a[i - arr[j]]);
}
} else {
for (int k = n; k >= 1; --k) {
int j = pos[k];
if (j <= i && b[i - j]) {
c = k;
break;
}
}
}
printf("%d\n", c);
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
char mat[105][105];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> mat[i][j];
bool flag = true;
for (int i = 0; i < n; i++)
for (int j = 1; j < m; j++)
if (mat[i][0] != mat[i][j]) flag = false;
for (int i = 1; i < n; i++)
if (mat[i - 1][0] == mat[i][0]) flag = false;
if (flag)
cout << "YES";
else
cout << "NO";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int k = 1;
int M = 1;
for (int c = 1; k <= n; ++c) {
k = 0;
for (int i = 0; i < c; ++i) {
k <<= 1;
k |= 1;
}
for (int i = 0; i < c - 1; ++i) {
k <<= 1;
}
if (0 == n % k) {
M = k;
}
}
cout << M;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T mod_v(T num) {
if (num >= 0)
return num % 1000000007;
else
return (num % 1000000007 + 1000000007) % 1000000007;
}
template <class T>
inline T gcd(T a, T b) {
a = abs(a);
b = abs(b);
while (b) b ^= a ^= b ^= a %= b;
return a;
}
template <class T>
T fast_pow(T n, T p) {
if (p == 0) return 1;
if (p % 2) {
T g = mod_v(mod_v(n) * mod_v(fast_pow(n, p - 1)));
return g;
} else {
T g = fast_pow(n, p / 2);
g = mod_v(mod_v(g) * mod_v(g));
return g;
}
}
template <class T>
inline T modInverse(T n) {
return fast_pow(n, 1000000007 - 2);
}
bool equalTo(double a, double b) {
if (fabs(a - b) <= 1e-9)
return true;
else
return false;
}
bool notEqual(double a, double b) {
if (fabs(a - b) > 1e-9)
return true;
else
return false;
}
bool lessThan(double a, double b) {
if (a + 1e-9 < b)
return true;
else
return false;
}
bool lessThanEqual(double a, double b) {
if (a < b + 1e-9)
return true;
else
return false;
}
bool greaterThan(double a, double b) {
if (a > b + 1e-9)
return true;
else
return false;
}
bool greaterThanEqual(double a, double b) {
if (a + 1e-9 > b)
return true;
else
return false;
}
struct debugger {
template <typename T>
debugger& operator,(const T& v) {
cerr << v << " ";
return *this;
}
} dbg;
int nextInt() {
int n;
scanf("%d", &n);
return n;
}
long long nextLong() {
long long n;
scanf("%lld", &n);
return n;
}
void print(int n) { printf("%d", n); }
void println(int n) { printf("%d\n", n); }
void println(long long n) { printf("%lld\n", n); }
template <class T>
inline int in(register T& num) {
register char c = 0;
num = 0;
bool n = false;
while (c < 33) c = getchar();
while (c > 33) {
if (c == '-')
n = true;
else
num = num * 10 + c - '0';
c = getchar();
}
num = n ? -num : num;
return 1;
}
int kp[1000005];
long long dp[1000005];
long long tmp[1000005];
int lst[1000004], c = 0;
int main() {
int n;
in(n);
for (int i = 1; i <= n; i++) in(kp[i]);
for (int i = n; i >= 1; i--) {
int ln = sqrt(kp[i]);
c = 0;
for (int j = 1; j <= ln; j++) {
if (kp[i] % j == 0) {
tmp[j] = 1 + dp[j + 1];
lst[c++] = j;
if (j * j != kp[i]) {
tmp[kp[i] / j] = 1 + dp[(kp[i] / j) + 1];
lst[c++] = kp[i] / j;
}
}
}
for (int j = 0; j < c; j++) {
dp[lst[j]] += tmp[lst[j]];
while (dp[lst[j]] >= 1000000007) dp[lst[j]] -= 1000000007;
}
}
cout << dp[1];
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<long long> > adj;
vector<long long> p;
unordered_set<long long> dia;
pair<long long, long long> dfs(long long x, long long pa, long long d) {
p[x] = pa;
pair<long long, long long> an = {d, x};
for (long long i = 0; i < adj[x].size(); i++) {
if (adj[x][i] != pa) an = max(an, dfs(adj[x][i], x, d + 1));
}
return an;
}
pair<long long, long long> dfs1(long long x, long long pa, long long d) {
p[x] = pa;
pair<long long, long long> an = {d, x};
for (long long i = 0; i < adj[x].size(); i++) {
if (adj[x][i] != pa && dia.find(adj[x][i]) == dia.end())
an = max(an, dfs(adj[x][i], x, d + 1));
}
return an;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n;
cin >> n;
p.resize(n);
adj.resize(n);
for (long long i = 0; i < n - 1; i++) {
long long x, y;
cin >> x >> y;
--x, --y;
adj[x].push_back(y);
adj[y].push_back(x);
}
pair<long long, long long> d1 = dfs(0, -1, 0);
pair<long long, long long> d2 = dfs(d1.second, -1, 0);
long long y = d2.second;
while (y != d1.second) {
dia.insert(y);
y = p[y];
}
dia.insert(d1.second);
if (d2.first == (n - 1)) {
cout << n - 1 << endl << d2.second + 1 << " " << d1.second + 1 << " ";
for (int i = 1; i <= n; i++)
if (i != (d2.second + 1) && i != (d1.second + 1)) {
cout << i << endl;
break;
}
return 0;
}
pair<long long, long long> c = {0, 0};
for (auto it : dia) {
pair<long long, long long> pr = dfs1(it, -1, 0);
c = max(c, pr);
}
cout << c.first + d2.first << endl
<< c.second + 1 << " " << d2.second + 1 << " " << d1.second + 1 << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void _dbg(string) { cout << endl; }
template <class H, class... T>
void _dbg(string s, H h, T... t) {
int l = s.find(',');
cout << s.substr(0, l) << " = " << h << ", ";
_dbg(s.substr(l + 1), t...);
}
template <class T, class U>
ostream& operator<<(ostream& o, const pair<T, U>& p) {
o << "(" << p.first << "," << p.second << ")";
return o;
}
template <class T>
ostream& operator<<(ostream& o, const vector<T>& v) {
o << "[";
for (T t : v) {
o << t << ",";
}
o << "]";
return o;
}
vector<int> tree[200010];
class LCA {
private:
int n, ln;
public:
vector<vector<int> > parent;
vector<int> depth;
LCA(int _n) : n(_n), depth(_n) {
ln = 0;
while (n > (1 << ln)) ln++;
parent = vector<vector<int> >(ln, vector<int>(n));
}
void dfs(int v, int p, int d) {
parent[0][v] = p;
depth[v] = d;
for (int i = (int)(0); i < (int)(tree[v].size()); i++)
if (tree[v][i] != p) dfs(tree[v][i], v, d + 1);
}
void init(int root) {
dfs(root, -1, 0);
for (int k = 0; k + 1 < ln; k++) {
for (int v = 0; v < n; v++) {
if (parent[k][v] < 0)
parent[k + 1][v] = -1;
else
parent[k + 1][v] = parent[k][parent[k][v]];
}
}
}
int query(int u, int v) {
if (depth[u] > depth[v]) swap(u, v);
for (int k = 0; k < ln; k++) {
if ((depth[v] - depth[u]) >> k & 1) v = parent[k][v];
}
if (u == v) return u;
for (int k = ln - 1; k >= 0; k--) {
if (parent[k][u] != parent[k][v]) {
u = parent[k][u];
v = parent[k][v];
}
}
return parent[0][u];
}
};
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = (int)(0); i < (int)(n - 1); i++) {
scanf("%d", &a[i]);
a[i]--;
tree[i + 1].push_back((a[i]));
tree[a[i]].push_back((i + 1));
}
LCA lca(n);
lca.init(0);
int v1 = 0, v2 = 0;
int ans = 0;
auto dist = [&](int p, int q) {
int pp = lca.query(p, q);
return lca.depth[p] + lca.depth[q] - 2 * lca.depth[pp];
};
for (int i = (int)(0); i < (int)(n - 1); i++) {
int d1 = dist(i + 1, v1);
int d2 = dist(i + 1, v2);
if (d1 > ans && d1 >= d2) {
v2 = i + 1;
ans = d1;
} else if (d2 > ans) {
v1 = i + 1;
ans = d2;
}
printf("%d%c", ans, " \n"[i == n - 2]);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long a[3004], dp[2][3004];
vector<long long> b;
long long inf = 1e15;
int main() {
int n, m;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
a[i] -= i;
b.push_back(a[i]);
}
sort(b.begin(), b.end());
b.erase(unique(b.begin(), b.end()), b.end());
m = b.size();
dp[0][0] = abs(a[0] - b[0]);
for (int j = 1; j < m; j++) dp[0][j] = min(dp[0][j - 1], abs(a[0] - b[j]));
bool now = 0;
for (int i = 1; i < n; i++) {
now = !now;
dp[now][0] = dp[!now][0] + abs(a[i] - b[0]);
for (int j = 1; j < m; j++)
dp[now][j] = min(dp[now][j - 1], abs(a[i] - b[j]) + dp[!now][j]);
}
cout << dp[now][m - 1] << "\n";
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
constexpr long long int MOD = 998244353;
constexpr double EPS = 1e-9;
long long int N, M, K, H, W, L, R;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> N;
vector<int> v(N);
for (auto &i : v) cin >> i;
vector<long long int> cost(N);
long long int ans = 0;
for (auto &i : cost) {
cin >> i;
ans += i;
}
cin >> M;
vector<int> w(1, 0);
for (int i = 0; i < M; i++) {
cin >> K;
w.push_back(K);
}
for (int i = 1; i < M; i++) {
if (w[i] <= w[i - 1]) {
cout << "NO\n";
return 0;
}
}
map<int, int> converter;
for (int i = 0; i <= M; i++) {
converter[w[i]] = i;
}
int cnt = 1;
for (int i = 0; i < N; i++) {
if (v[i] == w[cnt]) cnt++;
if (cnt == M + 1) break;
}
if (cnt < M + 1) {
cout << "NO\n";
return 0;
}
map<int, long long int> minus;
map<int, long long int> ret;
for (int i = 0; i <= w.size(); i++) ret[i] = MOD * MOD;
ret[w.size()] = ans;
for (int i = N - 1; i >= 0; i--) {
auto it = lower_bound(w.begin(), w.end(), v[i]) - w.begin();
if (converter.find(v[i]) == converter.end()) {
minus[it - 1] += max(0LL, cost[i]);
continue;
}
ret[it] = min(ret[it], ret[it + 1] - minus[it - 1] - cost[i]);
minus[it - 1] += max(cost[i], 0LL);
}
cout << "YES\n";
cout << ret[1] << endl;
}
| 8 |
#include "bits/stdc++.h"
#define rep(i,a,n) for(int i=a;i<=n;i++)
#define per(i,a,n) for(int i=n;i>=a;i--)
#define pb push_back
#define mp make_pair
#define FI first
#define SE second
#define maxn 3000
#define mod 1000000007
#define inf 0x3f3f3f3f
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
typedef vector<int> vi;
typedef double db;
int a[maxn+5];
int cnt[maxn+5][maxn+5]; // cnt[i][j] = #{ 1<=k<=j | k+a[k]>i }.
int dp[maxn+5][maxn+5]; // dp[i][j] = minimum cost to set way[i]=1 and way[k]=0 for all i<k<=j.
int main()
{
int cas; scanf("%d",&cas); while(cas--)
{
int n; scanf("%d",&n);
rep(i,1,n) scanf("%d",&a[i]);
rep(i,1,n) rep(j,1,i) cnt[i][j]=cnt[i][j-1]+(j+a[j]>i);
rep(i,1,n) rep(j,1,n) dp[i][j]=inf;
rep(j,1,n) dp[n][j]=0;
per(i,1,n-1)
{
int mn=inf;
per(j,i+1,i+a[i])
{
mn=min(mn,dp[j][i+a[i]]+cnt[j-1][j-1]-cnt[j-1][i]);
dp[i][j-1]=mn;
}
rep(j,1,i-1) dp[i][j]=dp[i][i];
}
printf("%d\n",dp[1][1]);
}
return 0;
} | 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n, ans = 0;
int s[10];
cin >> n;
int maxStrength = 0;
for (int i = 0; i < 3; i++) {
cin >> s[i];
maxStrength += s[i];
}
sort(s, s + 3);
bool destructible = true;
int battles[200001];
int battleLevel[3 + 1];
for (int i = 0; i < 3 + 1; i++) battleLevel[i] = 0;
for (int i = 0; i < n; i++) {
cin >> battles[i];
if (battles[i] > maxStrength) destructible = false;
for (int j = 0; j < 3; j++) {
if (battles[i] <= s[j]) battleLevel[j]++;
}
if (battles[i] <= s[0] + s[1]) battleLevel[3]++;
}
battleLevel[1] -= battleLevel[0];
battleLevel[2] -= battleLevel[1] + battleLevel[0];
battleLevel[3] -= battleLevel[0] + battleLevel[1];
sort(battles, battles + n);
if (destructible) {
int currentIndex = n - 1;
if (s[0] + s[1] > s[2]) {
for (int i = n - 1; i > -1; i--) {
if (battles[i] > s[1] + s[2])
ans++;
else {
currentIndex = i;
break;
}
if (i == 0) currentIndex = -1;
}
for (int i = currentIndex; i > -1; i--) {
if (battles[i] <= s[0] + s[2]) {
currentIndex = i;
break;
} else {
ans++;
if (battleLevel[0] > 0) battleLevel[0]--;
}
if (i == 0) currentIndex = -1;
}
for (int i = currentIndex; i > -1; i--) {
if (battles[i] <= s[0] + s[1]) {
currentIndex = i;
break;
} else {
ans++;
if (battleLevel[1] > 0)
battleLevel[1]--;
else if (battleLevel[0] > 0)
battleLevel[0]--;
}
if (i == 0) currentIndex = -1;
}
for (int i = currentIndex; i > -1; i--) {
if (battles[i] <= s[2]) {
currentIndex = i;
break;
} else {
ans++;
if (battleLevel[2] > 0)
battleLevel[2]--;
else if (battleLevel[1] > 0)
battleLevel[1]--;
else if (battleLevel[0] > 0)
battleLevel[0]--;
}
if (i == 0) currentIndex = -1;
}
for (int i = currentIndex; i > -1; i--) {
if (battleLevel[0] == 0 && battleLevel[1] == 0 && battleLevel[2] <= 0)
break;
else {
if (battleLevel[0] == 0 && battleLevel[1] == 0)
battleLevel[2] -= 2;
else {
for (int j = 2; j > -1; j--) {
for (int k = j; k > -1; k--) {
if (battleLevel[k] > 0) {
battleLevel[k]--;
break;
}
}
}
}
ans++;
}
}
cout << ans;
} else {
battleLevel[2] -= battleLevel[3];
for (int i = n - 1; i > -1; i--) {
if (battles[i] > s[1] + s[2])
ans++;
else {
currentIndex = i;
break;
}
if (i == 0) currentIndex = -1;
}
for (int i = currentIndex; i > -1; i--) {
if (battles[i] <= s[0] + s[2]) {
currentIndex = i;
break;
} else {
ans++;
if (battleLevel[0] > 0) battleLevel[0]--;
}
if (i == 0) currentIndex = -1;
}
for (int i = currentIndex; i > -1; i--) {
if (battles[i] <= s[2]) {
currentIndex = i;
break;
} else {
ans++;
if (battleLevel[1] > 0)
battleLevel[1]--;
else if (battleLevel[0] > 0)
battleLevel[0]--;
}
if (i == 0) currentIndex = -1;
}
for (int i = currentIndex; i > -1; i--) {
if (battles[i] <= s[0] + s[1]) {
currentIndex = i;
break;
} else {
ans++;
if (battleLevel[0] == 0 && battleLevel[1] == 0) {
battleLevel[3]--;
} else {
if (battleLevel[1] > 0)
battleLevel[1]--;
else if (battleLevel[0] > 0)
battleLevel[0]--;
if (battleLevel[0] > 0) battleLevel[0]--;
}
}
if (i == 0) currentIndex = -1;
}
battleLevel[2] = battleLevel[3];
for (int i = currentIndex; i > -1; i--) {
if (battleLevel[0] == 0 && battleLevel[1] == 0 && battleLevel[2] <= 0)
break;
else {
if (battleLevel[0] == 0 && battleLevel[1] == 0)
battleLevel[2] -= 2;
else {
for (int j = 2; j > -1; j--) {
for (int k = j; k > -1; k--) {
if (battleLevel[k] > 0) {
battleLevel[k]--;
break;
}
}
}
}
ans++;
}
}
cout << ans;
}
} else {
cout << -1;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
int R, r, _k;
cin >> R >> r >> _k;
double left = .5 / R;
double right = .5 / r;
double rad = (right - left) / 2.;
double x = (right + left) / 2.;
double y = (right - left) * _k;
double k = y / x;
double x1 = x - rad / sqrt(k * k + 1);
double x2 = x + rad / sqrt(k * k + 1);
double a1 = 1 / x1 / (k * k + 1);
double b1 = k * a1;
double a2 = 1 / x2 / (k * k + 1);
double b2 = k * a2;
double ans = hypot(a2 - a1, b2 - b1) / 2;
cout.precision(10);
cout << fixed << ans << endl;
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 100010;
struct Node {
int l, r;
Node *lc, *rc;
vector<pair<long long, long long> > list;
vector<pair<double, int> > x;
} pool[MaxN << 1], *tail = pool, *rt;
int n, m;
int sum[MaxN], a[MaxN];
long long k[MaxN], b[MaxN];
double sx[MaxN];
inline double intersect(const pair<long long, long long> &a,
const pair<long long, long long> &b) {
return 1. * (b.second - a.second) / (a.first - b.first);
}
void insert(vector<pair<long long, long long> > &a,
const pair<long long, long long> &b) {
int len = a.size();
while (len >= 2) {
double x = intersect(a[len - 1], b);
if (x > sx[len - 2]) break;
a.pop_back();
len--;
}
if (len) sx[len - 1] = intersect(a[len - 1], b);
a.push_back(b);
}
void build(Node *(&rt), int l, int r) {
rt = tail++;
rt->l = l;
rt->r = r;
rt->x.push_back(pair<double, int>(-1e9, 0));
if (l == r)
rt->list.push_back(pair<long long, long long>(k[l], b[l]));
else {
build(rt->lc, l, l + r >> 1);
build(rt->rc, (l + r >> 1) + 1, r);
vector<pair<long long, long long> >::iterator lp = rt->lc->list.begin(),
rp = rt->rc->list.begin();
while (lp != rt->lc->list.end() || rp != rt->rc->list.end()) {
if (lp == rt->lc->list.end())
insert(rt->list, *(rp++));
else if (rp == rt->rc->list.end())
insert(rt->list, *(lp++));
else if (lp->first == rp->first) {
if (lp->second <= rp->second)
insert(rt->list, *lp);
else
insert(rt->list, *rp);
lp++;
rp++;
} else if (lp->first > rp->first)
insert(rt->list, *(lp++));
else
insert(rt->list, *(rp++));
}
for (int i = 0; i < rt->list.size() - 1; i++)
rt->x.push_back(pair<double, int>(sx[i], i));
}
rt->x.push_back(pair<double, int>(1e9, rt->list.size() - 1));
}
long long query(Node *rt, int l, int r, int x) {
if (l <= rt->l && r >= rt->r) {
int a = lower_bound(rt->x.begin(), rt->x.end(), pair<double, int>(x, 0))
->second;
return rt->list[a].first * x + rt->list[a].second;
} else {
int mid = rt->l + rt->r >> 1;
long long res = 0x7fffffffffffffffLL;
if (l <= mid) res = min(res, query(rt->lc, l, r, x));
if (r > mid) res = min(res, query(rt->rc, l, r, x));
return res;
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++)
scanf("%d", &a[i]), sum[i] = sum[i - 1] + a[i], k[i] = a[i],
b[i] = k[i] * i - sum[i];
build(rt, 1, n);
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
cout << sum[y] + query(rt, y - x + 1, y, x - y) << endl;
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
int dp[10][10][10][2];
int id[10][10][10][2], cnt;
const int INF = 0x3f3f3f3f;
struct Node {
int i, j, k, l;
Node() {}
Node(int _i, int _j, int _k, int _l) { i = _i, j = _j, k = _k, l = _l; }
} trfrom[10][10][10][2];
inline int& f(const Node& x) { return dp[x.i][x.j][x.k][x.l]; }
vector<Node> state;
inline pair<int, int> trans(int nex, int x, string& s) {
if (nex == 0 && x == (int((s).size())) + 1) {
return pair<int, int>(x, 0);
} else if (x == (int((s).size())) + 1)
--x;
if (x == 0) return pair<int, int>(x, 1);
if (nex == s[x - 1]) return pair<int, int>(x - 1, 1);
return pair<int, int>(x, 1);
}
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
que;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL), cout.tie(NULL);
string s;
cin >> s;
int add = s.find('+');
int ecr = s.find('=');
string a = string(s.begin(), s.begin() + add);
string b = string(s.begin() + add + 1, s.begin() + ecr);
string c = string(s.begin() + ecr + 1, s.end());
memset(dp, 0x3f, sizeof(dp));
dp[(int((a).size())) + 1][(int((b).size())) + 1][(int((c).size())) + 1][0] =
0;
id[(int((a).size())) + 1][(int((b).size())) + 1][(int((c).size())) + 1][0] =
cnt++;
trfrom[(int((a).size())) + 1][(int((b).size())) + 1][(int((c).size())) + 1]
[0] = Node(-1, -1, -1, -1);
state.push_back(Node((int((a).size())) + 1, (int((b).size())) + 1,
(int((c).size())) + 1, 0));
que.push(pair<int, int>(0, 0));
reverse((a).begin(), (a).end());
reverse((b).begin(), (b).end());
reverse((c).begin(), (c).end());
for (auto& ch : a) ch -= 48;
for (auto& ch : b) ch -= 48;
for (auto& ch : c) ch -= 48;
while (que.size()) {
pair<int, int> u = que.top();
que.pop();
if (u.first != f(state[u.second])) continue;
for (register int x = (0); x <= (9); ++x)
for (register int y = (0); y <= (9); ++y)
for (register int z = (0); z <= (9); ++z) {
int nl = -(state[u.second].l * 10) + x + y - z;
if (nl != -1 && nl != 0) continue;
nl = -nl;
pair<int, int> ii = trans(x, state[u.second].i, a);
pair<int, int> jj = trans(y, state[u.second].j, b);
pair<int, int> kk = trans(z, state[u.second].k, c);
int val = u.first + ii.second + jj.second + kk.second;
int ni = ii.first, nj = jj.first, nk = kk.first;
if (dp[ni][nj][nk][nl] > val) {
if (dp[ni][nj][nk][nl] == INF) {
id[ni][nj][nk][nl] = cnt++;
state.push_back(Node(ni, nj, nk, nl));
}
dp[ni][nj][nk][nl] = val;
trfrom[ni][nj][nk][nl] = Node(u.second, x, y, z);
que.push(pair<int, int>(val, id[ni][nj][nk][nl]));
}
}
}
string p1, p2, p3;
Node now = trfrom[0][0][0][0];
while (now.i != -1) {
p1 += now.j + '0';
p2 += now.k + '0';
p3 += now.l + '0';
now =
trfrom[state[now.i].i][state[now.i].j][state[now.i].k][state[now.i].l];
}
while (p1.size() > 1 && p1.back() == 48) p1.pop_back();
while (p2.size() > 1 && p2.back() == 48) p2.pop_back();
while (p3.size() > 1 && p3.back() == 48) p3.pop_back();
reverse((p1).begin(), (p1).end());
reverse((p2).begin(), (p2).end());
reverse((p3).begin(), (p3).end());
cout << (p1 + "+" + p2 + "=" + p3) << '\n';
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long double EPS = 1e-8;
const int INF = 1000000001;
const int MAXK = 200;
int ans[MAXK][MAXK];
int main() {
int n;
cin >> n;
int k = 3;
while (k * (k - 1) / 2 <= n) k++;
k--;
int w = 1;
printf("%d\n", k);
for (int i = 0; i < (k); i++) {
for (int j = 0; j < (i); j++) printf("%d ", ans[i][j]);
for (int j = i + 1; j < k; ++j) {
printf("%d ", w);
ans[j][i] = w;
w++;
}
printf("\n");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t = 1, n, x, k, m;
cin >> t;
long long ar[200005];
while (t--) {
long long p, i;
cin >> n >> p >> k;
for (long long i = 0; i < n; i++) cin >> ar[i];
sort(ar, ar + n);
long long ans1 = 0, ans2 = 0, p1;
p1 = p;
for (i = 1; i <= n; i = i + 2) {
if (ar[i] <= p && i < n) {
ans1 += 2;
p = p - ar[i];
} else {
if (ar[i - 1] <= p) {
ans1 = ans1 + 1;
p = p - ar[i - 1];
}
break;
}
}
if (ar[0] <= p1) {
p1 = p1 - ar[0], ans2 = ans2 + 1;
}
for (i = 2; i <= n; i = i + 2) {
if (ar[i] <= p1 && i < n) {
ans2 += 2;
p1 = p1 - ar[i];
} else {
if (ar[i - 1] <= p) {
ans2 = ans2 + 1;
p1 = p1 - ar[i - 1];
}
break;
}
}
cout << max(ans1, ans2) << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e18;
long long k, f[6];
long long q;
long long dp[6][1000000];
inline long long calc(long long s) {
if ((s + 8) / 9 > k) return -inf;
long long a = s / 9;
s -= a * 9;
if (a + 2 <= k) {
return a * 3 + s / 3;
} else {
return a * 3 + (s % 3 == 0 ? s / 3 : 0);
}
}
const long long L = 1000000;
long long Lim1, Lim2;
long long stk[L * 2];
inline void solve(vector<long long>& dp, long long val, long long rr) {
long long n = dp.size();
vector<long long> dp1(dp.size(), -inf);
vector<long long> dp2(dp.size(), -inf);
vector<long long> dp3(dp.size(), -inf);
for (long long r = 0; r < 9; r++) {
long long v = 0, u = 1;
for (long long j = r, l = 0; j < n; j += 9, l++) {
while (v >= u &&
dp[j] - l * 3 * val > dp[stk[v] * 9 + r] - stk[v] * 3 * val)
--v;
stk[++v] = l;
while (u <= v && l - stk[u] > k) ++u;
if (u <= v)
dp1[j] = l * 3 * val + dp[stk[u] * 9 + r] - 3ll * stk[u] * val;
}
v = 0, u = 1;
for (long long j = r, l = 0; j < n; j += 9, l++) {
while (v >= u &&
dp[j] - l * 3 * val > dp[stk[v] * 9 + r] - stk[v] * 3 * val)
--v;
stk[++v] = l;
while (u <= v && l - stk[u] > k - 1) ++u;
if (u <= v)
dp2[j] = l * 3 * val + dp[stk[u] * 9 + r] - 3ll * stk[u] * val;
}
v = 0, u = 1;
for (long long j = r, l = 0; j < n; j += 9, l++) {
while (v >= u &&
dp[j] - l * 3 * val > dp[stk[v] * 9 + r] - stk[v] * 3 * val)
--v;
stk[++v] = l;
while (u <= v && l - stk[u] > k - 2) ++u;
if (u <= v)
dp3[j] = l * 3 * val + dp[stk[u] * 9 + r] - 3ll * stk[u] * val;
}
}
for (long long i = 0; i < n; i++) {
dp[i] = max(dp[i], dp1[i]);
for (long long j = i; j >= max(0ll, i - 9); j--) {
dp[i] = max(dp[i], dp2[j] + ((i - j) % 3 == 0 ? ((i - j) / 3) * val : 0));
}
for (long long j = i; j >= max(0ll, i - 9); j--) {
dp[i] = max(dp[i], dp3[j] + ((i - j) / 3) * val);
}
}
}
inline void init() {
for (long long i = 0; i < L; i++) {
if (calc(i) < 0)
dp[0][i] = -inf;
else
dp[0][i] = calc(i) * f[0];
}
long long w = 10;
for (long long k = 1; k <= 5; k++, w *= 10) {
for (long long r = 0; r < w; r++) {
vector<long long> v;
for (long long i = r; i < L; i += w) {
v.push_back(dp[k - 1][i]);
}
solve(v, f[k], r);
for (long long i = r, j = 0; i < L; i += w, j++) {
dp[k][i] = v[j];
}
}
}
}
inline void Main() {
int x;
scanf("%d", &x);
printf("%lld\n", dp[5][x]);
}
int main() {
cin >> k;
for (int i = 0; i < 6; i++) cin >> f[i];
init();
cin >> q;
while (q--) {
Main();
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const double inf = 1e20;
const int MX = 55;
const int MM = 5500;
double f[MX][MM];
int a[MX], b[MX], p[MX];
int n, R;
bool ok(double mid) {
for (int i = n - 1; i >= 0; i--) {
for (int j = R + 1; j < MM; j++) f[i + 1][j] = mid;
for (int j = 0; j <= R; j++) {
double t1 = (f[i + 1][j + a[i]] + a[i]) * p[i] / 100;
double t2 = (f[i + 1][j + b[i]] + b[i]) * (100 - p[i]) / 100;
f[i][j] = min(mid, t1 + t2);
}
}
return f[0][0] < mid;
}
int main() {
scanf("%d%d", &n, &R);
for (int i = 0; i < n; i++) scanf("%d%d%d", &a[i], &b[i], &p[i]);
double l = 0, r = 1e10;
for (int T = 1; T <= 100; T++) {
double mid = (l + r) / 2;
if (ok(mid))
r = mid;
else
l = mid;
}
printf("%.10f\n", l);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
if (s == "a8" || s == "h8" || s == "a1" || s == "h1")
cout << '3';
else if (s[0] == 'a' || s[0] == 'h' || s[1] == '1' || s[1] == '8')
cout << '5';
else
cout << '8';
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
set<int> d;
for (int i = 1; i * i <= n; i++) {
if (n % i == 0) {
d.insert(i);
d.insert(n / i);
}
}
for (int i : d) {
for (int j = i * k; j < k * (i + 1); j++) {
int tmp = j;
if ((tmp % k) * (tmp / k) == n) {
cout << tmp;
return 0;
}
}
}
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int main()
{
int t;
cin>>t;
while(t--)
{
ll n,m;
cin>>n>>m;
string s;
cin>>s;
while(m--)
{
ll l,r,flag=0;
cin>>l>>r;
l--;
r--;
for(ll i=l-1;i>=0;i--)
{
if(s[i]==s[l])
flag=1;
}
for(ll i=r+1;i<n;i++)
{
if(s[i]==s[r])
flag=1;
}
if(flag==1)
cout<<"YES"<<endl;
else
cout<<"NO"<<endl;
}
}
} | 0 |
#include <bits/stdc++.h>
typedef struct {
char Name[21];
int T, P, G;
} Friend;
int n;
char phone[9];
Friend Lista[100];
int MAX[4];
char LF[3][100][21];
int ind[3];
int tipo() {
if (phone[0] == phone[1] && phone[0] == phone[3] && phone[0] == phone[4] &&
phone[0] == phone[6] && phone[0] == phone[7])
return 1;
if (phone[0] > phone[1] && phone[1] > phone[3] && phone[3] > phone[4] &&
phone[4] > phone[6] && phone[6] > phone[7])
return 2;
return 3;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int m;
scanf("%d %s", &m, Lista[i].Name);
for (int j = 0; j < m; j++) {
scanf("%s", phone);
switch (tipo()) {
case 1:
Lista[i].T++;
break;
case 2:
Lista[i].P++;
break;
case 3:
Lista[i].G++;
break;
}
}
}
for (int i = 0; i < n; i++) {
MAX[1] = std::max(MAX[1], Lista[i].T);
MAX[2] = std::max(MAX[2], Lista[i].P);
MAX[3] = std::max(MAX[3], Lista[i].G);
}
for (int i = 0; i < n; i++) {
if (Lista[i].T == MAX[1]) {
memcpy(LF[0][ind[0]], Lista[i].Name, 21);
ind[0]++;
}
if (Lista[i].P == MAX[2]) {
memcpy(LF[1][ind[1]], Lista[i].Name, 21);
ind[1]++;
}
if (Lista[i].G == MAX[3]) {
memcpy(LF[2][ind[2]], Lista[i].Name, 21);
ind[2]++;
}
}
printf("If you want to call a taxi, you should call: ");
for (int i = 0; i < ind[0]; i++) {
printf("%s", LF[0][i]);
if (i + 1 < ind[0]) {
printf(", ");
} else {
printf(".");
}
}
printf("\nIf you want to order a pizza, you should call: ");
for (int i = 0; i < ind[1]; i++) {
printf("%s", LF[1][i]);
if (i + 1 < ind[1]) {
printf(", ");
} else {
printf(".");
}
}
printf(
"\nIf you want to go to a cafe with a wonderful girl, you should call: ");
for (int i = 0; i < ind[2]; i++) {
printf("%s", LF[2][i]);
if (i + 1 < ind[2]) {
printf(", ");
} else {
printf(".");
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k;
cin >> k;
string s;
string sw;
if (k % 2) {
cout << -1 << endl;
return 0;
}
for (int i = 0; i < k; ++i) {
if (i % 2) {
sw = "ww";
} else {
sw = "bb";
}
s = sw;
for (int j = 0; j < (k / 2); ++j) {
if (j % 2 && i % 2) {
sw = "bb";
} else if (i % 2 && j % 2 == 0) {
sw = "ww";
} else if (i % 2 == 0 && j % 2) {
sw = "ww";
} else {
sw = "bb";
}
s = sw;
for (int x = 0; x < (k / 2); ++x) {
cout << s;
if (s == "bb") {
s = "ww";
} else {
s = "bb";
}
}
s = sw;
cout << endl;
for (int x = 0; x < (k / 2); ++x) {
cout << s;
if (s == "bb") {
s = "ww";
} else {
s = "bb";
}
}
cout << endl;
}
cout << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
string s;
cin >> s;
long long m;
cin >> m;
vector<string> vec(m);
for (long long i = 0; i < m; i++) {
cin >> vec[i];
}
bool vis[26];
for (long long i = 0; i < 26; i++) {
vis[i] = false;
}
for (long long i = 0; i < n; i++) {
if (s[i] != '*') {
vis[s[i] - 'a'] = true;
}
}
for (long long i = 0; i < vec.size(); i++) {
for (long long j = 0; j < n; j++) {
if (s[j] != '*') {
if (s[j] != vec[i][j]) {
vec.erase(vec.begin() + i);
i--;
break;
}
}
if (s[j] == '*') {
if (vis[vec[i][j] - 'a']) {
vec.erase(vec.begin() + i);
i--;
break;
}
}
}
}
vector<char> v;
for (long long i = 0; i < n; i++) {
if (s[i] == '*') {
if (vis[vec[0][i] - 'a'] == false) {
v.push_back(vec[0][i]);
}
}
}
for (long long i = 1; i < vec.size(); i++) {
for (long long k = 0; k < v.size(); k++) {
bool t = false;
for (long long j = 0; j < n; j++) {
if (s[j] == '*' && v[k] == vec[i][j]) {
t = true;
break;
}
}
if (!t) {
v.erase(v.begin() + k);
k--;
}
}
}
set<char> sec;
for (long long i = 0; i < v.size(); i++) {
sec.insert(v[i]);
}
cout << sec.size() << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const double PI = atan(1.0) * 4;
const int64_t INF = 100000000000000003;
const int32_t LOG = 21;
const long long int MOD = 1e9 + 7;
long long int t[4 * 200005];
long long int lazy[4 * 200005];
long long int pos[200005];
long long int a[200005];
long long int cost[200005];
void push(long long int v) {
t[v * 2] += lazy[v];
lazy[v * 2] += lazy[v];
t[v * 2 + 1] += lazy[v];
lazy[v * 2 + 1] += lazy[v];
lazy[v] = 0;
}
void update(long long int v, long long int tl, long long int tr,
long long int l, long long int r, long long int addend) {
if (l > r) return;
if (l == tl && tr == r) {
t[v] += addend;
lazy[v] += addend;
} else {
push(v);
long long int tm = (tl + tr) / 2;
update(v * 2, tl, tm, l, min(r, tm), addend);
update(v * 2 + 1, tm + 1, tr, max(l, tm + 1), r, addend);
t[v] = min(t[v * 2], t[v * 2 + 1]);
}
}
long long int query(long long int v, long long int tl, long long int tr,
long long int l, long long int r) {
if (l > r) return INF;
if (l <= tl && tr <= r) return t[v];
push(v);
long long int tm = (tl + tr) / 2;
return min(query(v * 2, tl, tm, l, min(r, tm)),
query(v * 2 + 1, tm + 1, tr, max(l, tm + 1), r));
}
int32_t main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
long long int n;
cin >> n;
for (long long int i = 0; i < n; i++) {
cin >> a[i];
pos[a[i]] = i;
}
for (long long int i = 0; i < n; i++) cin >> cost[i];
long long int sum = 0;
for (long long int i = 0; i < n; i++) {
sum += cost[i];
update(1, 0, n - 1, i, i, sum);
}
long long int ans = query(1, 0, n - 1, 0, n - 2);
for (long long int i = 1; i < n + 1; i++) {
long long int loc = pos[i];
long long int val = cost[loc];
update(1, 0, n - 1, 0, loc - 1, val);
update(1, 0, n - 1, loc, n - 1, -val);
ans = min(ans, query(1, 0, n - 1, 0, n - 2));
}
cout << ans << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
const int inf = 0x7f7f7f7f;
struct Node {
int m1, m2;
};
inline Node merge(Node a, Node b) {
if (a.m1 <= b.m1)
return (Node){a.m1, min(b.m1, a.m2)};
else
return (Node){b.m1, min(a.m1, b.m2)};
}
struct Segment_Tree {
int s[N << 2];
Node val[N << 2];
inline void build(int rt, int l, int r) {
s[rt] = inf;
val[rt] = (Node){inf, inf};
if (l == r) return;
build(rt << 1, l, ((l + r) >> 1));
build(rt << 1 | 1, ((l + r) >> 1) + 1, r);
}
inline void pushup(int rt) {
val[rt] = merge(val[rt << 1], val[rt << 1 | 1]);
}
inline void insert(int rt, int l, int r, int k, int ch) {
if (l == r) {
s[rt] = ch;
val[rt] = (Node){s[rt], inf};
return;
}
if (k <= ((l + r) >> 1))
insert(rt << 1, l, ((l + r) >> 1), k, ch);
else
insert(rt << 1 | 1, ((l + r) >> 1) + 1, r, k, ch);
pushup(rt);
}
inline Node query(int rt, int l, int r, int L, int R) {
if (L <= l && r <= R) return val[rt];
Node ans = (Node){inf, inf};
if (L <= ((l + r) >> 1))
ans = merge(ans, query(rt << 1, l, ((l + r) >> 1), L, R));
if (R > ((l + r) >> 1))
ans = merge(ans, query(rt << 1 | 1, ((l + r) >> 1) + 1, r, L, R));
return ans;
}
} t[10];
int n, m, a[N];
inline void upd(int p) {
int x = a[p];
for (int i = (1); i <= (9); i++) {
if (x % 10) t[i].insert(1, 1, n, p, a[p]);
x /= 10;
}
}
inline void solve() {
scanf("%d %d", &n, &m);
for (int i = (1); i <= (9); i++) t[i].build(1, 1, n);
for (int i = (1); i <= (n); i++) {
scanf("%d", &a[i]);
upd(i);
}
for (int i = (1); i <= (m); i++) {
int opt, x, y;
scanf("%d %d %d", &opt, &x, &y);
if (opt & 1) {
for (int j = (1); j <= (9); j++) t[j].insert(1, 1, n, x, inf);
a[x] = y;
upd(x);
} else {
Node ans;
int Ans = inf;
for (int j = (1); j <= (9); j++) {
ans = t[j].query(1, 1, n, x, y);
if (ans.m1 == inf || ans.m2 == inf) continue;
Ans = min(Ans, ans.m1 + ans.m2);
}
if (Ans != inf)
printf("%d\n", Ans);
else
printf("-1\n");
}
}
}
signed main() { solve(); }
| 7 |
#include <bits/stdc++.h>
using namespace std;
inline int in() {
int32_t x;
scanf("%d", &x);
return x;
}
inline string get() {
char ch[1000010];
scanf("%s", ch);
return ch;
}
const long long maxn = 60 + 10;
const long long MAX_LG = 21;
const long long INF = 1e9;
const long long SQ = 317;
const long long mod = 1e9 + 7;
long long dp[maxn][maxn], a[maxn];
long long can[maxn][maxn];
long long tot;
long double res;
long double c[100][100];
int32_t main() {
long long n = in();
for (long long i = 0; i < n; i++) a[i] = in();
long long p = in();
for (long long i = 0; i < maxn; i++) {
for (long long j = 0; j <= i; j++) {
if (!j)
c[i][j] = 1;
else
c[i][j] = c[i - 1][j - 1] + c[i - 1][j];
}
}
can[0][0] = true;
for (long long pt = 0; pt < n; pt++) {
for (long long cnt = pt; cnt >= 0; cnt--) {
for (long long sum = maxn - 1; sum >= 0; sum--) {
if (sum + a[pt] > p) continue;
can[cnt + 1][sum + a[pt]] += can[cnt][sum];
}
}
}
for (long long i = 1; i <= n; i++) {
long long tot = 0;
for (long long j = 0; j <= p; j++) {
tot += can[i][j];
}
res += ((long double)tot) / c[n][i];
}
cout.precision(10);
cout << fixed << res << "\n";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, j;
cin >> n;
int a[n];
map<int, int> m;
for (i = 0; i < n; i++) {
cin >> a[i];
m[a[i]]++;
}
for (i = 0; i < n; i++) {
for (j = 0; j < 31; j++) {
int x = (1 << j) - a[i];
if (m.count(x) && (m[x] > 1 || (m[x] == 1 && x != a[i]))) {
a[i] = -1;
break;
}
}
}
int ans = 0;
for (i = 0; i < n; i++) {
if (a[i] != -1) {
ans++;
}
}
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100;
int N, arr[maxn], dp[maxn][maxn][maxn][3];
vector<int> pos[3];
bool marked[maxn];
inline int calc(int a, vector<int> &v) {
int cnt = 0;
for (int ck : v) cnt += ck <= a;
return cnt;
}
int solve(int a[3], int lst) {
if (a[0] + a[1] + a[2] == 0) return 0;
if (dp[a[0]][a[1]][a[2]][lst] != -1) return dp[a[0]][a[1]][a[2]][lst];
int res = 0x3f3f3f3f;
memset(marked, 0, sizeof marked);
for (int i = 0; i < 3; i++)
for (int k = 0; k < a[i]; k++) marked[pos[i][k]] = true;
vector<int> v;
for (int i = 1; i <= N; i++)
if (!marked[i]) v.push_back(i);
for (int p = 0; p < 3; p++) {
if (p == 0 && lst == 1 || !a[p]) continue;
int pp = pos[p][--a[p]], cc = calc(pp, v);
res = min(res, solve(a, p) + cc);
a[p]++;
}
return dp[a[0]][a[1]][a[2]][lst] = res;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> N;
for (int i = 1; i <= N; i++) {
char c;
cin >> c;
if (c == 'V')
arr[i] = 0;
else if (c == 'K')
arr[i] = 1;
else
arr[i] = 2;
pos[arr[i]].push_back(i);
}
memset(dp, -1, sizeof dp);
int res = 0x3f3f3f3f, tmp[3];
for (int i = 0; i < 3; i++) tmp[i] = (int)pos[i].size();
for (int i = 0; i < 3; i++) {
if (!tmp[i]) continue;
tmp[i]--;
res = min(res, solve(tmp, i));
tmp[i]++;
}
cout << res << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 202020;
int n, m, k, ans, vis[N], color[N], cnt, maxC;
map<int, int> d;
vector<int> g[N];
void dfs(int u) {
vis[u] = 1;
cnt++;
d[color[u]]++;
maxC = max(maxC, d[color[u]]);
for (auto v : g[u]) {
if (vis[v] == 0) dfs(v);
}
}
int main() {
ios::sync_with_stdio(0);
cin >> n >> m >> k;
for (int i = (1); i <= (n); ++i) cin >> color[i];
for (int i = (1); i <= (m); ++i) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
ans = 0;
for (int i = (1); i <= (n); ++i)
if (vis[i] == 0) {
d.clear();
cnt = maxC = 0;
dfs(i);
ans += cnt - maxC;
}
cout << ans;
cerr << "\nTime elapsed: " << 1000 * clock() / CLOCKS_PER_SEC << " ms\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 53;
const int MOD = 998244353;
int add(int a, int b) {
long long res = (long long)a + b;
return res % MOD;
}
int sub(int a, int b) {
long long res = (long long)a - b;
res %= MOD;
res += MOD;
return res % MOD;
}
int mul(int a, int b) {
long long res = (long long)a * b;
return res % MOD;
}
int binpow(int a, int b) {
int res = 1;
while (b > 0) {
if (b & 1) {
res = mul(res, a);
}
a = mul(a, a);
b >>= 1;
}
return res;
}
int inv(int a) { return binpow(a, MOD - 2); }
int divv(int a, int b) { return mul(a, inv(b)); }
int n, m;
int SA, SB;
int dp[MAXN][MAXN][MAXN];
int sw;
void relax_like(int dw, int sa, int sb) {
int sum_like = SA + sa;
int sum_disl = SB - sb;
int w = sw + dw;
{
int prob = divv(w, sum_like + sum_disl);
dp[dw + 1][sa + 1][sb] =
add(dp[dw + 1][sa + 1][sb], mul(dp[dw][sa][sb], prob));
}
{
int prob = divv(sum_like - w, sum_like + sum_disl);
dp[dw][sa + 1][sb] = add(dp[dw][sa + 1][sb], mul(dp[dw][sa][sb], prob));
}
{
int prob = divv(sum_disl, sum_like + sum_disl);
dp[dw][sa][sb + 1] = add(dp[dw][sa][sb + 1], mul(dp[dw][sa][sb], prob));
}
}
void relax_dislike(int dw, int sa, int sb) {
int sum_like = SA + sa;
int sum_disl = SB - sb;
int w = sw - dw;
if (w > 0) {
int prob = divv(w, sum_like + sum_disl);
dp[dw + 1][sa][sb + 1] =
add(dp[dw + 1][sa][sb + 1], mul(dp[dw][sa][sb], prob));
}
{
int prob = divv(sum_disl - w, sum_like + sum_disl);
dp[dw][sa][sb + 1] = add(dp[dw][sa][sb + 1], mul(dp[dw][sa][sb], prob));
}
{
int prob = divv(sum_like, sum_like + sum_disl);
dp[dw][sa + 1][sb] = add(dp[dw][sa + 1][sb], mul(dp[dw][sa][sb], prob));
}
}
int solve_one(int sw_, int lk) {
sw = sw_;
for (int i = 0; i < MAXN; i++) {
for (int j = 0; j < MAXN; j++) {
for (int k = 0; k < MAXN; k++) {
dp[i][j][k] = 0;
}
}
}
dp[0][0][0] = 1;
for (int d = 0; d < m; d++) {
for (int sa = 0; sa <= d; sa++) {
int sb = d - sa;
for (int w = 0; w + 1 < MAXN; w++) {
if (lk) {
relax_like(w, sa, sb);
} else {
relax_dislike(w, sa, sb);
}
}
}
}
int ans = 0;
for (int ew = 0; ew < MAXN; ew++) {
for (int sa = 0; sa <= m; sa++) {
int sb = m - sa;
if (lk) {
ans = add(ans, mul(ew, dp[ew][sa][sb]));
} else {
ans = sub(ans, mul(ew, dp[ew][sa][sb]));
}
}
}
return add(sw, ans);
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
vector<int> a(n);
for (auto &t : a) {
cin >> t;
}
vector<int> w(n);
for (auto &t : w) {
cin >> t;
}
SA = 0;
SB = 0;
for (int i = 0; i < n; i++) {
if (a[i]) {
SA += w[i];
} else {
SB += w[i];
}
}
for (int i = 0; i < n; i++) {
cout << solve_one(w[i], a[i]) << '\n';
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
double dp[2003][2003];
int read() {
int X = 0, W = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') W = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
X = X * 10 + ch - '0';
ch = getchar();
}
return X * W;
}
long long Read() {
long long X = 0, W = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') W = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
X = X * 10 + ch - '0';
ch = getchar();
}
return X * W;
}
int main() {
int T;
T = read();
while (T--) {
long long a, b;
double saber = 0;
a = Read(), b = Read();
if (a == 0 && b == 0)
saber = 1.0;
else if (a == 0 && b > 0)
saber = 0.5;
else if (a > 0 && b == 0)
saber = 1.0;
else if (a > 0 && b > 0) {
if (a >= 4 * b)
saber = (1.0 * (2 * a - 4 * b) * b / 2 + a * b) / (2 * a * b);
else
saber = (1.0 * a * a / 8 + a * b) / (2 * a * b);
}
printf("%.10f\n", saber);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 5, inf = 1e18;
long long n, m, d[N * 2], h[N * 2], dis[N * 2];
template <class T>
void read(T &x) {
x = 0;
char c = getchar();
long long f = 0;
while (c < '0' || c > '9') f |= (c == '-'), c = getchar();
while (c >= '0' && c <= '9')
x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();
if (f) x = -x;
}
struct node {
long long mx, mi;
} tr[N * 2 * 4];
long long L(long long x) {
if (x < 0) return inf;
return (dis[x] - h[x] * 2);
}
long long R(long long x) {
if (x < 0) return -inf;
return (dis[x] + h[x] * 2);
}
void upd(long long p) {
tr[p].mi = L(tr[(p << 1)].mi) < L(tr[(p << 1 | 1)].mi) ? tr[(p << 1)].mi
: tr[(p << 1 | 1)].mi;
tr[p].mx = R(tr[(p << 1)].mx) > R(tr[(p << 1 | 1)].mx) ? tr[(p << 1)].mx
: tr[(p << 1 | 1)].mx;
}
void build(long long p, long long l, long long r) {
if (l > r) return;
if (l == r) {
tr[p].mx = tr[p].mi = l;
return;
}
build((p << 1), l, (l + r >> 1));
build((p << 1 | 1), (l + r >> 1) + 1, r);
upd(p);
}
pair<long long, long long> que(long long p, long long l, long long r,
long long s, long long e) {
if (s > e || l > e || r < s) return pair<long long, long long>(-1, -1);
if (l >= s && r <= e) return pair<long long, long long>(tr[p].mi, tr[p].mx);
pair<long long, long long> t1 = que((p << 1), l, (l + r >> 1), s, e);
pair<long long, long long> t2 = que((p << 1 | 1), (l + r >> 1) + 1, r, s, e);
return pair<long long, long long>(
L(t1.first) < L(t2.first) ? t1.first : t2.first,
R(t1.second) > R(t2.second) ? t1.second : t2.second);
}
signed main() {
cin >> n >> m;
for (long long i = 1; i <= n; ++i) {
read(d[i]);
d[i + n] = d[i];
}
for (long long i = 1; i <= n; ++i) {
read(h[i]);
h[i + n] = h[i];
}
dis[1] = 0;
for (long long i = 2; i <= n * 2; ++i) dis[i] = dis[i - 1] + d[i - 1];
build(1, 1, n * 2);
long long a, b, ans;
pair<long long, long long> res, l, r;
while (m-- > 0) {
ans = 0;
read(a);
read(b);
if (a <= b) {
res = que(1, 1, n * 2, b + 1, n + a - 1);
if (res.first == res.second) {
l = que(1, 1, n * 2, b + 1, res.first - 1);
r = que(1, 1, n * 2, res.first + 1, n + a - 1);
ans = max(R(res.second) - L(l.first), R(r.second) - L(res.first));
} else
ans = R(res.second) - L(res.first);
} else {
res = que(1, 1, n * 2, b + 1, a - 1);
if (res.first == res.second) {
l = que(1, 1, n * 2, b + 1, res.first - 1);
r = que(1, 1, n * 2, res.first + 1, a - 1);
ans = max(R(res.second) - L(l.first), R(r.second) - L(res.first));
} else
ans = R(res.second) - L(res.first);
}
cout << ans << "\n";
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 705;
long long int b[5][N][N];
int deg[N];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int v, u;
cin >> v >> u;
v--, u--;
b[0][v][u] = b[0][u][v] = 1;
deg[v]++, deg[u]++;
}
long long int sum = 0;
for (int i = 1; i < 5; i++) {
for (int j = 0; j < n; j++)
for (int k = j; k < n; k++)
for (int t = 0; t < n; t++) b[i][j][k] += b[i - 1][j][t] * b[0][t][k];
for (int j = 0; j < n; j++)
for (int k = j; k < n; k++) b[i][k][j] = b[i][j][k];
}
for (int i = 0; i < n; i++) {
if (deg[i] > 1) sum -= b[2][i][i] * (deg[i] - 1) * 5;
sum += b[4][i][i];
}
cout << sum / 10 << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
const double PI = acos(-1);
long long A[100001];
using namespace std;
int main(void) {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> A[i];
}
if (n == 1) {
cout << 1 << ' ' << 1 << '\n';
cout << 100000000000 << '\n';
cout << 1 << ' ' << 1 << '\n';
cout << 0 << '\n';
cout << 1 << ' ' << 1 << '\n';
cout << -(A[1] + 100000000000) << '\n';
} else {
cout << 1 << ' ' << n << '\n';
for (int i = 1; i < n; i++) {
cout << -A[i] * n << ' ';
}
long long k = 10000000000000 / n;
cout << n * k;
cout << '\n' << 1 << ' ' << n - 1 << '\n';
for (int i = 1; i <= n - 1; i++) cout << A[i] * (n - 1) << ' ';
cout << '\n' << n << ' ' << n << '\n';
cout << -(A[n] + n * k);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 55;
string s;
int n, m;
int dui;
map<long long, int> M;
void gao(int dep, long long val, int duijige) {
if (n - dep + duijige < dui) return;
if (dep == n) {
if (duijige == dui) ++M[val];
return;
}
int now = s[dep] - '0';
if (duijige + 1 <= dui) {
gao(dep + 1, val * 2 + now, duijige + 1);
}
gao(dep + 1, val * 2 + (!now), duijige);
}
int main() {
while (cin >> n >> m) {
M.clear();
int i, ans = 0;
for (i = 0; i < m; ++i) {
cin >> s >> dui;
gao(0, 0LL, 0);
}
for (map<long long, int>::iterator p = M.begin(); p != M.end(); ++p)
if (p->second == m) ++ans;
cout << ans << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1e9 + 7;
const int OO = INT_MAX, P = 10000;
int xd[] = {1, 0, -1, 0, -1, 1, 1, -1};
int yd[] = {0, -1, 0, 1, 1, 1, -1, -1};
int main() {
ios::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
long long int t;
cin >> t;
while (t--) {
long long int l, r;
cin >> l >> r;
if (l * 2 > r)
cout << -1 << " " << -1 << '\n';
else
cout << l << " " << 2 * l << '\n';
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int N = 1010, M = (1 << 8) + 10;
int n, q[N], x, c[10], a[10][N], mn, f[N][M];
int cur[10];
int cal(int len) {
int m = (1 << 8) - 1;
for (int i = 1; i <= n + 1; i++)
for (int j = 0; j <= m; j++) {
f[i][j] = -INF;
}
f[1][0] = 0;
memset(cur, 0, sizeof(cur));
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= m; j++) {
if (f[i][j] == -INF) {
continue;
}
for (int k = 1; k <= 8; k++) {
int p = 1 << (k - 1);
if (p & j) {
continue;
}
int cnt = cur[k] + len - 1;
if (cnt > c[k]) {
continue;
}
f[a[k][cnt] + 1][j | p] = max(f[a[k][cnt] + 1][j | p], f[i][j]);
cnt++;
if (cnt > c[k]) {
continue;
}
f[a[k][cnt] + 1][j | p] = max(f[a[k][cnt] + 1][j | p], f[i][j] + 1);
}
}
cur[q[i]]++;
}
int ans = -INF;
for (int i = 1; i <= n + 1; i++) {
ans = max(ans, f[i][m]);
}
if (ans == -INF) {
return -1;
}
return ans * len + (8 - ans) * (len - 1);
}
int main() {
scanf("%d", &n);
memset(c, 0, sizeof(c));
q[0] = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &x);
q[i] = x;
c[x]++;
a[x][c[x]] = i;
}
mn = INF;
for (int i = 1; i <= 8; i++) {
mn = min(mn, c[i]);
}
int l = 2, r = mn + 1, mid, tmp, ans = -1;
while (l <= r) {
mid = (l + r) >> 1;
tmp = cal(mid);
if (tmp != -1) {
l = mid + 1;
ans = tmp;
} else {
r = mid - 1;
}
}
if (ans == -1) {
ans = 0;
for (int i = 1; i <= 8; i++)
if (c[i] > 0) {
ans++;
}
}
printf("%d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> l(m);
for (int i = 0; i < m; i++) {
cin >> l[i];
if (l[i] + i > n) {
cout << -1 << endl;
return 0;
}
}
vector<long long> cum(m + 1, 0);
for (int i = m - 1; i >= 0; i--) {
cum[i] = cum[i + 1] + l[i];
}
if (cum[0] < n) {
cout << -1 << endl;
return 0;
}
for (int i = 0; i < m; i++) {
cout << max((long long)(i + 1), n - cum[i] + 1) << " ";
}
cout << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T>
inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
const long long INF = 1e18;
long long N, K;
vector<long long> a;
vector<long long> ans;
__int128_t g(__int128_t a, __int128_t b) { return b * (a - b * b); }
vector<long long> f(__int128_t border) {
vector<long long> ret(N);
for (int i = 0; i < N; i++) {
long long ok = 0;
long long ng = a[i] + 1;
while (abs(ok - ng) > 1) {
long long mid = (ok + ng) / 2;
if (g(a[i], mid) - g(a[i], mid - 1) >= border)
ok = mid;
else
ng = mid;
}
ret[i] = ok;
}
return ret;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> N >> K;
priority_queue<pair<long long, long long> > que;
a.resize(N);
for (int i = 0; i < N; i++) {
cin >> a[i];
}
__int128_t ng = -1e30;
__int128_t ok = 1e30;
while (ok - ng > 1) {
__int128_t mid = (ok + ng) / 2;
vector<long long> tmp = f(mid);
long long num = 0;
for (auto val : tmp) num += val;
if (num <= K)
ok = mid;
else
ng = mid;
}
vector<long long> tmp1 = f(ok);
vector<long long> tmp2 = f(ok - 1);
long long rest = K;
for (int i = 0; i < N; i++) {
rest -= tmp1[i];
}
for (int i = 0; i < N; i++) {
long long delta = min(rest, tmp2[i] - tmp1[i]);
rest -= delta;
tmp1[i] += delta;
}
for (int i = 0; i < N; i++) {
if (i != 0) cout << " ";
cout << tmp1[i];
}
cout << "\n";
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, k, x;
int val[100005];
int f[2][1027];
int main() {
scanf("%d%d%d", &n, &k, &x);
int mx = x;
for (int i = 1, t; i <= n; i++) scanf("%d", &t), f[0][t]++, mx = max(mx, t);
for (int i = 1;; i <<= 1) {
if (i > mx) {
mx = i;
break;
}
}
int now = 0;
for (int i = 1; i <= k; i++) {
memset(f[now ^ 1], 0, sizeof(f[0]));
int last = 1;
for (int j = 0; j < mx; j++) {
int t = f[now][j] / 2;
if (f[now][j] % 2 != 0) {
f[now ^ 1][j] += t;
f[now ^ 1][j ^ x] += t;
last == 1 ? f[now ^ 1][j ^ x]++ : f[now ^ 1][j]++;
last ^= 1;
} else {
f[now ^ 1][j] += t;
f[now ^ 1][j ^ x] += t;
}
}
now ^= 1;
}
int rmx = 0, rmn = 1e9 + 1;
for (int i = 0; i < mx; i++) {
if (f[now][i] != 0) rmx = max(rmx, i), rmn = min(rmn, i);
}
printf("%d %d\n", rmx, rmn);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int q;
int *a = new int[10000];
cin >> q;
for (int i = 0; i < 2 * q; i++) cin >> a[i];
sort(a, a + 2 * q);
if (a[0] != a[2 * q - 1])
for (int i = 0; i < 2 * q; i++) cout << a[i] << " ";
else
cout << -1;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
inline void read(int &x) {
register int c = getchar();
x = 0;
int neg = 0;
for (; ((c < 48 || c > 57) && c != '-'); c = getchar())
;
if (c == '-') {
neg = 1;
c = getchar();
}
for (; c > 47 && c < 58; c = getchar()) {
x = (x << 1) + (x << 3) + c - 48;
}
if (neg) x = -x;
}
inline void writeln(int x) {
char buffor[21];
register int i = 0;
int neg = 0;
if (x < 0) {
neg = 1;
x = -x;
}
do {
buffor[i++] = (x % 10) + '0';
x /= 10;
} while (x);
i--;
if (neg) putchar('-');
while (i >= 0) putchar(buffor[i--]);
putchar('\n');
}
long long x, y, l, r;
vector<long long> un;
void input() { cin >> x >> y >> l >> r; }
bool in(long long a) {
if (a >= l and a <= r) return true;
return false;
}
void solve() {
long long a = 1, b;
while (1) {
b = 1;
if (in(a + b)) un.push_back(a + b);
while (1) {
if (b <= (r - a) / y)
b = b * y;
else
break;
if (in(a + b)) un.push_back(a + b);
}
if (a > r / x) break;
a = a * x;
}
un.push_back(l - 1);
un.push_back(r + 1);
sort(un.begin(), un.end());
long long res = 0;
for (int i = 1; i <= (int)un.size() - 1; i++)
res = max(un[i] - un[i - 1] - 1, res);
cout << res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
input();
solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e3 + 5;
const double pi = acos(-1.0);
struct node {
int x, y, r;
int num;
double area;
} a[maxn];
int n;
bool cmp(node a, node b) { return a.r > b.r; }
bool in(node a, node b) {
return 1.0 * (a.x - b.x) * (a.x - b.x) + 1.0 * (a.y - b.y) * (a.y - b.y) <
1.0 * (a.r + b.r) * (a.r + b.r);
}
int main() {
while (cin >> n) {
for (int i = 1; i <= n; i++) {
scanf("%d%d%d", &a[i].x, &a[i].y, &a[i].r);
a[i].area = pi * a[i].r * a[i].r;
}
sort(a + 1, a + 1 + n, cmp);
for (int i = 1; i <= n; i++)
for (int j = i + 1; j <= n; j++)
if (in(a[i], a[j])) a[j].num++;
double ans = 0.0;
for (int i = 1; i <= n; i++) {
if (!a[i].num || a[i].num % 2)
ans += a[i].area;
else
ans -= a[i].area;
}
printf("%.8f\n", ans);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long ans = 0;
void H2A() {
long long n, k;
cin >> n >> k;
long long arr[n];
for (int i = 0; i < n; i++) cin >> arr[i];
long long l = 0, r = 0, counter = 0;
long long sum = 0;
while (r < n) {
if (sum < k) {
while (sum < k && r < n) sum += arr[r++], counter++;
if (sum > k) sum -= arr[--r], counter--;
}
ans = max(counter, ans);
if (l == r)
l++, r++;
else
sum -= arr[l++], counter--;
}
if (sum < k) ans = max(ans, counter);
cout << ans;
}
int main() {
int t = 1;
while (t--) H2A();
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int a[N], b[N], c[N], vis[N];
int main() {
int n, k;
cin >> n >> k;
for (int i = (1); i < (n + 1); i++) cin >> a[i];
for (int i = (1); i < (k + 1); i++) b[i] = a[i];
int task = 0, cur = k + 1, ans = 0;
while (task < n) {
int q = task * 100.0 / n + 0.5;
for (int i = 1; i <= k; ++i) {
if (!b[i]) continue;
c[i]++;
if (c[i] == q && !vis[i]) ans++, vis[i] = 1;
if (c[i] >= b[i]) {
task++;
vis[i] = 0;
c[i] = 0;
b[i] = a[cur];
cur++;
}
}
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
template <typename T>
inline bool remin(T& c, const T& n) {
if (c > n) {
c = n;
return 1;
}
return 0;
}
template <typename T>
inline bool remax(T& c, const T& n) {
if (c < n) {
c = n;
return 1;
}
return 0;
}
int _in;
int in() {
scanf("%d", &_in);
return _in;
}
const int N = 2e5;
int heaven[N], n, m, hsz = 0;
int hell(int a) { return lower_bound(heaven, heaven + hsz, a) - heaven; }
double push[4 * N];
void _build(int from, int to, int v) {
if (from + 1 == to)
push[v] = 0;
else {
int mid = (from + to) / 2;
_build(from, mid, v * 2);
_build(mid, to, v * 2 + 1);
push[v] = 1;
}
}
void _alter(int qfrom, int from, int to, int v, double val) {
if (from + 1 == to)
push[v] += val;
else {
int mid = (from + to) / 2;
qfrom < mid ? _alter(qfrom, from, mid, v * 2, val)
: _alter(qfrom, mid, to, v * 2 + 1, val);
}
}
void alter(int qfrom, int val) { _alter(qfrom, 0, hsz, 1, val); }
void _seg(int qfrom, int qto, int from, int to, int v, double prob) {
if (qfrom < qto) {
if (qfrom == from && qto == to)
push[v] *= prob;
else {
int mid = (from + to) / 2;
_seg(qfrom, min(qto, mid), from, mid, v * 2, prob);
_seg(max(qfrom, mid), qto, mid, to, v * 2 + 1, prob);
}
}
}
void seg(int qfrom, int qto, double prob) {
_seg(max(qfrom, 0), min(qto, hsz), 0, hsz, 1, prob);
}
double _dry(int from, int to, int v) {
if (from + 1 == to)
return push[v];
else {
int mid = (from + to) / 2;
return (_dry(from, mid, v * 2) + _dry(mid, to, v * 2 + 1)) * push[v];
}
}
stack<int> input;
int main() {
n = in();
m = in();
int i, j, h, l, r, p;
for ((i) = (0); (i) < (n); ++(i)) {
input.push(heaven[hsz++] = in());
input.push(in());
input.push(in());
input.push(in());
}
for ((i) = (0); (i) < (m); ++(i)) {
input.push(heaven[hsz++] = in());
input.push(in());
}
sort(heaven, heaven + hsz);
hsz = unique(heaven, heaven + hsz) - heaven;
_build(0, hsz, 1);
for ((i) = (0); (i) < (m); ++(i)) {
p = input.top();
input.pop();
j = input.top();
input.pop();
j = hell(j);
alter(j, p);
}
for ((i) = (0); (i) < (n); ++(i)) {
r = input.top();
input.pop();
l = input.top();
input.pop();
h = input.top();
input.pop();
p = input.top();
j = hell(p);
input.pop();
seg(hell(p - h), j, double(100 - l) / 100.0);
seg(j + 1, hell(p + h + 1), double(100 - r) / 100.0);
}
printf("%lf\n", _dry(0, hsz, 1));
return 0;
}
| 7 |
#include <bits/stdc++.h>
const int OO = (int)1e9 + 10;
using namespace std;
int A[(int)1e6 + 10], B[(int)1e6 + 10];
long long ans;
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> A[i];
if (B[A[i] ^ m]) ans += B[A[i] ^ m];
B[A[i]]++;
}
cout << ans;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
string s;
long long n;
const long long N = 100005;
long long tens[N], sumTens[N], pref[N], suff[N], prefSum[N], suffSum[N];
long long mulMod(long long a, long long b) {
a *= b;
a %= 1000000007;
return a;
}
long long addMod(long long a, long long b) {
long long c = (a + b) % 1000000007;
return c;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cout << setprecision(10) << fixed;
long long t = 1;
while (t--) {
cin >> s;
n = s.length();
if (n == 1) {
cout << 0 << endl;
return 0;
}
if (n == 2) {
cout << (s[0] - '0') + (s[1] - '0') << endl;
return 0;
}
tens[0] = 1, sumTens[0] = 0;
for (long long i = 1; i < N; i++) {
tens[i] = mulMod(tens[i - 1], 10);
sumTens[i] = addMod(sumTens[i - 1], tens[i]);
}
pref[0] = (s[0] - '0'), suff[n - 1] = (s[n - 1] - '0');
prefSum[0] = pref[0], suffSum[n - 1] = suff[n - 1];
for (long long i = 1; i < n; i++) {
pref[i] = addMod(mulMod(pref[i - 1], 10), (s[i] - '0'));
prefSum[i] = addMod(prefSum[i - 1], pref[i]);
}
long long p = 10;
for (long long i = n - 2; i >= 0; i--) {
suff[i] = addMod(mulMod((s[i] - '0'), p), suff[i + 1]);
suffSum[i] = addMod(suffSum[i + 1], suff[i]);
p = mulMod(p, 10);
}
long long ans = 0;
ans = addMod(ans, suffSum[1]);
ans = addMod(ans, prefSum[n - 2]);
for (long long i = 1; i < n - 1; i++) {
long long temp = mulMod(pref[i - 1], sumTens[n - i - 1]);
temp = addMod(temp, suffSum[i + 1]);
ans = addMod(ans, temp);
}
cout << ans << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int arr[N];
int u[N];
set<int> s;
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; ++i) {
scanf("%d", &arr[i]);
}
for (int i = n - 1; i >= 0; --i) {
s.insert(arr[i]);
u[i] = s.size();
}
int t;
for (int k = 0; k < m; ++k) {
cin >> t;
cout << u[t - 1] << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int T, N, n, i, apples, oranges, m;
cin >> T;
while (T--) {
cin >> N;
apples = 0;
oranges = 0;
n = (2 * N) - 1;
pair<pair<long long int, long long int>, long long int> Box[n];
for (i = 0; i < n; i++) {
cin >> Box[i].first.first >> Box[i].first.second;
Box[i].second = i + 1;
apples += Box[i].first.first;
oranges += Box[i].first.second;
}
sort(Box, Box + n);
cout << "YES" << endl;
for (i = 1; i < n - 1; i = i + 2) {
if (Box[i].first.second > Box[i - 1].first.second) {
cout << Box[i].second << " ";
} else {
cout << Box[i - 1].second << " ";
}
}
cout << Box[n - 1].second << endl;
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int M = 100 + 5;
struct NODE {
int ihash[4];
int visited_number;
bool operator<(const NODE& a) const {
for (int i = 0; i < 4; i++) {
if (ihash[i] != a.ihash[i]) {
return ihash[i] < a.ihash[i];
}
}
return false;
}
};
set<NODE> Queue;
int candidate_flag[4];
string candidate_name[4] = {"Gryffindor", "Hufflepuff", "Ravenclaw",
"Slytherin"};
int rev_map[1000];
int main() {
rev_map['G'] = 0;
rev_map['H'] = 1;
rev_map['R'] = 2;
rev_map['S'] = 3;
int n;
cin >> n;
string s;
cin >> s;
NODE node;
for (int i = 0; i < 4; i++) {
node.ihash[i] = 0;
node.visited_number = 0;
}
Queue.insert(node);
int SIZE = 1;
while (SIZE > 0) {
SIZE = 0;
set<NODE> t_Queue;
for (set<NODE>::iterator it = Queue.begin(); it != Queue.end(); it++) {
NODE node = *it;
int min_value = node.ihash[0];
for (int i = 0; i < 4; i++) {
if (node.ihash[i] < min_value) {
min_value = node.ihash[i];
}
}
int min_value_number = 0;
for (int i = 0; i < 4; i++) {
if (node.ihash[i] == min_value) {
min_value_number++;
if (node.visited_number == n) {
candidate_flag[i] = 1;
}
}
}
if (node.visited_number < n) {
if (s[node.visited_number] == '?') {
vector<int> position;
for (int j = 0; j < 4; j++) {
if (node.ihash[j] == min_value) {
position.push_back(j);
}
}
for (int k = 0; k < min_value_number; k++) {
NODE tmp;
for (int j = 0; j < 4; j++) {
tmp.ihash[j] = node.ihash[j];
}
tmp.ihash[position[k]]++;
tmp.visited_number = node.visited_number + 1;
t_Queue.insert(tmp);
SIZE++;
}
} else {
NODE tmp;
for (int j = 0; j < 4; j++) {
tmp.ihash[j] = node.ihash[j];
}
tmp.visited_number = node.visited_number + 1;
tmp.ihash[rev_map[s[node.visited_number]]]++;
t_Queue.insert(tmp);
SIZE++;
}
}
}
Queue = t_Queue;
}
for (int i = 0; i < 4; i++) {
if (candidate_flag[i] == 1) {
cout << candidate_name[i] << endl;
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, a, b, c, d;
struct edge {
int u, v, val;
} e[2000 + 5];
vector<int> G[2000 + 5];
vector<edge> ans;
void dfs(int x, int fa, int kdf) {
if (G[x].size() == 1) {
if (!kdf) {
if (a == 0) a = x;
b = x;
} else {
if (c == 0) c = x;
d = x;
}
}
for (int i = 0; i < G[x].size(); i++) {
int nxt = G[x][i];
if (nxt == fa) continue;
dfs(nxt, x, kdf);
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int u, v, val;
scanf("%d%d%d", &u, &v, &val);
e[i] = (edge){u, v, val};
G[u].push_back(v);
G[v].push_back(u);
}
for (int i = 1; i <= n; i++)
if (G[i].size() == 2) {
printf("NO\n");
return 0;
}
printf("YES\n");
for (int i = 1; i < n; i++) {
int u = e[i].u, v = e[i].v, val = e[i].val;
a = b = c = d = 0;
dfs(u, v, 0);
dfs(v, u, 1);
ans.push_back((edge){a, c, val / 2});
ans.push_back((edge){b, d, val / 2});
if (a != b) ans.push_back((edge){a, b, -val / 2});
if (c != d) ans.push_back((edge){c, d, -val / 2});
}
printf("%d\n", ans.size());
for (int i = 0; i < ans.size(); i++)
printf("%d %d %d\n", ans[i].u, ans[i].v, ans[i].val);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int ms[100001];
int main() {
memset(ms, 0, sizeof ms);
int a, b, m, u;
cin >> a >> b >> m >> u;
u = u % m;
for (int i = 0;; i++) {
if (ms[u] == 0)
ms[u] = i;
else {
cout << i - ms[u];
break;
}
u = (a * u % m + b % m) % m;
}
}
| 2 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.