solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
const int maxn = 100000;
using namespace std;
int n;
int a[maxn + 10];
int main() {
while (scanf("%d", &n) != EOF) {
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
if (n == 1) {
printf("2\n");
continue;
}
sort(a, a + n);
a[0] = 1;
for (int i = 1; i < n; i++) {
if (a[i] != a[i - 1]) {
if (a[i] != a[i - 1] + 1) a[i] = a[i - 1] + 1;
}
}
printf("%d\n", a[n - 1] + 1);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int q;
cin >> q;
for (int j = 0; j < q; ++j) {
int n, k, mi = 1e9, ma = 0;
cin >> n >> k;
for (int i = 0; i < n; ++i) {
int a;
cin >> a;
mi = min(mi, a);
ma = max(ma, a);
}
if (abs(ma - (mi + k)) <= k) {
cout << mi + k << "\n";
} else {
cout << -1 << "\n";
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int to, next;
};
int ans1, ans2;
struct hash {
node g[120000];
int ed, st[120000];
int file[120000], folder[120000];
int cnt, pre;
map<string, int> mp;
inline void add(int x, int y) {
ed++;
g[ed].to = y;
g[ed].next = st[x];
st[x] = ed;
}
inline void input(string x) {
x[0] = '.';
string tmp = "";
pre = 0;
for (int i = 1; i < x.length(); i++) {
if (x[i] != '.' && (!(x[i] >= '0' && x[i] <= '9')) &&
(!(x[i] >= 'a' && x[i] <= 'z'))) {
if (mp.count(tmp) == 0) {
cnt++;
mp[tmp] = cnt;
folder[cnt] = 1;
add(pre, mp[tmp]);
}
pre = mp[tmp];
}
tmp += x.substr(i, 1);
}
if (mp.count(tmp) == 0) {
cnt++;
mp[tmp] = cnt;
file[mp[tmp]] = 1;
add(pre, mp[tmp]);
}
}
inline void dfs(int x) {
for (int i = st[x]; i != 0; i = g[i].next) {
dfs(g[i].to);
file[x] += file[g[i].to];
folder[x] += folder[g[i].to];
}
}
inline void getans() {
for (int i = 1; i <= cnt; i++) {
ans1 = max(ans1, folder[i]);
ans2 = max(ans2, file[i]);
}
}
} sgt[10];
inline void solve() { printf("%d %d\n", ans1 - 1, ans2); }
string str;
int fl;
int main() {
int T = 2;
while (!cin.eof()) {
cin >> str;
fl = str[0] - 'A';
sgt[fl].input(str.substr(2));
}
for (int i = 0; i < 10; i++) {
sgt[i].dfs(0);
sgt[i].getans();
}
solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MaxN = int(2e6) + 256;
const long long INF = (long long)(1e18);
const int mod = (int)(1e9) + 7;
const double pi = 3.1415926535897932384626433832795;
long long n, m, a[MaxN], b[MaxN];
long long ans, ans1;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
string second;
cin >> second;
vector<char> v;
for (int i = second.size() - 1; i >= 0; i--) {
if (second[i] == '.' || ('0' <= second[i] && second[i] <= '9')) {
v.push_back(second[i]);
} else {
int last = -1;
long long cnt = 1;
for (int j = 0; j < v.size(); j++) {
if (v[j] == '.') {
last = j;
int S = 0;
for (int l = j - 1; l >= 0; l--) {
if (v[l] == '.')
break;
else
S++;
}
if (S == 2) {
double q = (v[j - 1] - '0') * 10 + (v[j - 2] - '0') * 1;
ans1 = q + ans1;
} else {
ans = ans + int(v[j - 3] - '0') * cnt;
cnt = cnt * 10ll;
ans = ans + int(v[j - 2] - '0') * cnt;
cnt = cnt * 10ll;
ans = ans + int(v[j - 1] - '0') * cnt;
cnt = cnt * 10ll;
}
} else if (j == v.size() - 1) {
for (int l = last + 1; l < v.size(); l++) {
ans = ans + int(v[l] - '0') * cnt;
cnt = cnt * 10;
}
}
}
v.clear();
}
}
bool ok = 0;
vector<int> kal;
for (int i = 1; i <= 2; i++) {
kal.push_back(ans1 % 10);
ans1 /= 10;
}
reverse(kal.begin(), kal.end());
vector<int> A;
ans += ans1;
if (kal[0] || kal[1]) ok = 1;
while (ans) {
A.push_back(ans % 10);
ans /= 10;
}
long long cnt = 0;
for (int i = 0; i < A.size(); i++) {
v.push_back(char(A[i] + '0'));
cnt++;
if (cnt == 3 && A.size() != i + 1) {
cnt = 0;
v.push_back('.');
}
}
reverse(v.begin(), v.end());
for (int i = 0; i < v.size(); i++) cout << v[i];
if (ok) {
if (v.size() == 0) cout << "0";
cout << '.';
for (int i = 0; i < kal.size(); i++) cout << kal[i];
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 7;
int in[202][202], a[202][202], p[202], n, m;
string t;
bool issort(int i) {
for (int j = 2; j <= m; j++)
if (a[i][j] < a[i][j - 1]) return false;
return true;
}
bool isinsort(int i) {
for (int j = 2; j <= m; j++)
if (a[i][j] > a[i][j - 1]) return false;
return true;
}
bool ok() {
string s;
for (int i = 1; i <= n; i++) {
p[i] = 0;
for (int j = 1; j <= m; j++) p[i] += a[i][j];
}
int i;
for (i = 1; i <= n; i++) {
if (p[i] == 0)
s += '0';
else if (p[i] == m)
s += '1';
else
break;
}
if (i <= n) {
if (issort(i))
s += '0';
else if (isinsort(i))
s += '1';
else
return false;
for (i = i + 1; i <= n; i++) {
if (p[i] == 0)
s += '1';
else if (p[i] == m)
s += '0';
else
return false;
}
}
cout << "YES" << '\n';
cout << s << '\n' << t << '\n';
return true;
}
int main() {
std::ios::sync_with_stdio(0);
std::cin.tie(0);
;
cin >> n >> m;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) cin >> in[i][j];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) a[i][j] = in[i][j];
t = "";
for (int i = 1; i <= m; i++) {
if (a[1][i]) {
t += '1';
for (int j = 1; j <= n; j++) a[j][i] ^= 1;
} else {
t += '0';
}
}
if (ok()) return 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) a[i][j] = in[i][j];
t = "";
for (int i = 1; i <= m; i++) {
if (a[n][i]) {
t += '1';
for (int j = 1; j <= n; j++) a[j][i] ^= 1;
} else {
t += '0';
}
}
if (ok()) return 0;
cout << "NO" << '\n';
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n;
int x[1024], y[1024], c[1024];
int pts[1024];
int chull[1024], tp;
int chull_size;
int ans_l[1024], ans_r[1024], ans_len = 0;
void add_edge(int u, int v) {
ans_l[ans_len] = u;
ans_r[ans_len] = v;
ans_len++;
}
void print_ans() {
printf("%d\n", ans_len);
for (int i = 0; i < ans_len; i++) printf("%d %d\n", ans_l[i], ans_r[i]);
}
bool ccw(int i, int j, int k) {
return (x[i] * y[j] + x[j] * y[k] + x[k] * y[i] - x[j] * y[i] - x[k] * y[j] -
x[i] * y[k]) > 0;
}
int pivot;
bool comp_by_pivot(int i, int j) {
assert(i != pivot);
assert(j != pivot);
return ccw(pivot, i, j);
}
void run(int i, int j, int k, const vector<int> &inner, bool sep) {
if (inner.size() == 0) {
if (sep) {
;
} else {
add_edge(j, k);
}
} else {
int pivot = -1;
for (int p : inner) {
if (pivot == -1 || ccw(j, p, pivot)) pivot = p;
}
vector<int> j_inner, k_inner;
for (int p : inner)
if (p != pivot) {
if (ccw(pivot, i, p))
j_inner.push_back(p);
else
k_inner.push_back(p);
}
if (c[pivot] == c[i]) {
run(j, pivot, i, j_inner, false);
run(k, i, pivot, k_inner, true);
if (!sep) add_edge(j, k);
} else {
run(i, j, pivot, j_inner, false);
run(i, pivot, k, k_inner, sep);
}
}
}
void run(int i, int j, int k, bool sep) {
assert(i != j && j != k && k != i);
assert(ccw(i, j, k));
vector<int> inner;
for (int l = 0; l < n; l++)
if (l != i && l != j && l != k && ccw(i, j, l) && ccw(j, k, l) &&
ccw(k, i, l)) {
inner.push_back(l);
}
run(i, j, k, inner, sep);
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d %d %d", &x[i], &y[i], &c[i]);
}
if (n == 1) {
printf("0\n");
} else if (n == 2) {
if (c[0] == c[1]) {
printf("1\n");
printf("0 1\n");
} else {
printf("0\n");
}
} else {
pivot = 0;
for (int i = 1; i < n; i++)
if (x[i] < x[pivot] || (x[i] == x[pivot] && y[i] < y[pivot])) pivot = i;
for (int i = 0; i < n - 1; i++) pts[i] = (i < pivot ? i : i + 1);
sort(pts, pts + n - 1, comp_by_pivot);
chull[0] = pivot;
tp = 0;
for (int i = 0; i < n - 1; i++) {
int cur = pts[i];
while (tp >= 1 && (ccw(chull[tp - 1], chull[tp], cur) == false)) tp--;
chull[++tp] = cur;
}
chull_size = tp + 1;
int num_change = 0;
for (int i = 0; i < chull_size; i++)
if (c[chull[i]] != c[chull[(i + 1) % chull_size]]) num_change++;
if (num_change == 0) {
int c_chull = c[chull[0]];
int center_pivot = -1;
for (int i = 0; i < n; i++)
if (c[i] != c_chull) {
center_pivot = i;
break;
}
if (center_pivot == -1) {
printf("%d\n", n - 1);
for (int i = 0; i < n - 1; i++) printf("%d %d\n", pivot, pts[i]);
} else {
for (int i = 0; i < chull_size - 1; i++) {
run(center_pivot, chull[i], chull[i + 1], false);
}
run(center_pivot, chull[chull_size - 1], chull[0], true);
print_ans();
}
} else if (num_change == 2) {
int p1 = -1;
for (int i = 1; i < chull_size; i++)
if (c[chull[i - 1]] != c[chull[i]]) {
p1 = i;
break;
}
assert(p1 >= 1 && p1 < chull_size);
rotate(chull, chull + p1, chull + chull_size);
int p2 = -1;
for (int i = 1; i < chull_size; i++)
if (c[chull[i - 1]] != c[chull[i]]) {
p2 = i;
break;
}
for (int i = 0; i < p2 - 1; i++) {
run(chull[p2], chull[i], chull[i + 1], false);
}
for (int i = p2; i < chull_size - 1; i++) {
run(chull[0], chull[i], chull[i + 1], false);
}
print_ans();
} else {
assert(num_change % 2 != 1);
printf("Impossible\n");
}
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
struct SegTree {
struct Node {
int l = 0, r = 0;
std::pair<int, int> v = {0, -1}, p = {0, -1};
};
std::vector<Node> tree = {{}, {}};
void visit(int n, int l, int m, int r) {
if (!tree[n].l && l <= m) tree[n].l = tree.size(), tree.emplace_back();
if (!tree[n].r && m + 1 <= r) tree[n].r = tree.size(), tree.emplace_back();
setMax(tree[n].l, l, m, l, r, tree[n].p);
setMax(tree[n].r, m + 1, r, l, r, tree[n].p);
tree[n].p = Node().p;
}
void setMax(int n, int l, int r, int lq, int rq, std::pair<int, int> v) {
if (!n || r < lq || rq < l || rq < lq) {
return;
} else if (lq <= l && r <= rq) {
tree[n].v = std::max(tree[n].v, v);
tree[n].p = std::max(tree[n].p, v);
} else {
int m = l + (r - l) / 2;
visit(n, l, m, r);
setMax(tree[n].l, l, m, lq, rq, v);
setMax(tree[n].r, m + 1, r, lq, rq, v);
tree[n].v = std::max(tree[tree[n].l].v, tree[tree[n].r].v);
}
}
std::pair<int, int> getMax(int n, int l, int r, int lq, int rq) {
if (!n || r < lq || rq < l || rq < lq)
return Node().v;
else if (lq <= l && r <= rq)
return tree[n].v;
int m = l + (r - l) / 2;
visit(n, l, m, r);
return std::max(getMax(tree[n].l, l, m, lq, rq),
getMax(tree[n].r, m + 1, r, lq, rq));
}
} tree;
int main() {
int n, m;
scanf("%d %d", &n, &m);
std::vector<int> points;
std::unordered_map<int, int> relpoint;
std::vector<std::vector<std::pair<int, int>>> intervals(n + 1);
for (int x = 0, i, l, r; x < m; ++x) {
scanf("%d %d %d", &i, &l, &r);
intervals[i].push_back({l, r});
if (!relpoint.count(l)) points.push_back(l);
if (!relpoint.count(r)) points.push_back(r);
relpoint[l] = relpoint[r] = 0;
}
std::sort(points.begin(), points.end());
for (int i = 1; i <= points.size(); ++i) relpoint[points[i]] = i;
std::vector<int> bptr(n + 1, -1);
for (int row = 1; row <= n; ++row) {
auto &v = intervals[row];
std::sort(v.begin(), v.end());
std::vector<std::pair<int, int>> ranges;
for (int i = 0, j; i < v.size(); i = j) {
int l = v[i].first, r = v[i].second;
for (j = i + 1; j < v.size() && v[j].first <= r; ++j)
r = std::max(r, v[j].second);
ranges.push_back({relpoint[l], relpoint[r]});
}
std::pair<int, int> dp = {0, -1};
for (auto &lr : ranges)
dp = std::max(dp, tree.getMax(1, 1, points.size(), lr.first, lr.second));
for (auto &lr : ranges) {
tree.setMax(1, 1, points.size(), lr.first, lr.second,
{dp.first + 1, row});
}
bptr[row] = dp.second;
}
auto ans = tree.getMax(1, 1, points.size(), 1, points.size());
printf("%d\n", n - ans.first);
for (int i = ans.second, j; i != -1;) i = bptr[j = i], bptr[j] = 0;
for (int row = 1; row <= n; ++row)
if (bptr[row] != 0) printf("%d ", row);
if (ans.first != n) printf("\n");
}
| 7 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops")
using namespace std;
const long long INF = 1e9 + 7, MAXN = 1e6 + 5;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int q;
cin >> q;
while (q--) {
int n;
cin >> n;
vector<int> a(n);
for (auto& i : a) cin >> i;
int k = min_element(a.begin(), a.end()) - a.begin();
bool p = 1;
for (int i = k; i < n + k - 1; i++) {
if (a[i % n] != a[(i + 1) % n] - 1) p = 0;
}
reverse(a.begin(), a.end());
k = min_element(a.begin(), a.end()) - a.begin();
bool p1 = 1;
for (int i = k; i < n + k - 1; i++) {
if (a[i % n] != a[(i + 1) % n] - 1) p1 = 0;
}
if (p1 || p)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct P {
long long x, y;
P operator+(P b) { return P{x + b.x, y + b.y}; }
P operator-(P b) { return P{x - b.x, y - b.y}; }
};
long double dist(P a, P b) {
return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
}
long double cross(P a, P b) { return a.x * b.y - b.x * a.y; }
long double find(P a, P b, P c) {
long double r = dist(a, c), s = abs(cross(b - a, c - a));
return (0.5 * s) / r;
}
int main() {
int n;
vector<P> v;
cin >> n;
for (int i = 0; i < n; ++i) {
long long a, b;
cin >> a >> b;
P agr;
agr.x = a, agr.y = b;
v.push_back(agr);
}
long double ans = 1e16;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < 2 * n; ++j) {
if (abs(i - j) <= 2) {
for (int k = 0; k < 2 * n; ++k) {
if (abs(i - k) <= 2 and set<int>{i % n, j % n, k % n}.size() == 3) {
ans = min(ans, find(v[i % n], v[j % n], v[k % n]));
}
}
}
}
}
cout.precision(10);
cout << ans << "\n";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, t;
cin >> s >> t;
long long int size = 0, count = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] != t[i]) {
count++;
}
}
long long int i = 0;
size = s.size() / 2;
if (count % 2 == 0) {
for (int i = 0; i < s.size(); i++) {
if (s[i] == t[i]) {
cout << s[i];
} else {
if (count != 0) {
cout << s[i];
count -= 2;
} else {
cout << t[i];
}
}
}
} else {
cout << "impossible";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long int mod = 998244353;
bool check(pair<long long int, long long int> p1,
pair<long long int, long long int> p2) {
return p2.second > p1.second;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int n;
cin >> n;
string s;
cin >> s;
bool alls = true;
for (int i = 0; i < n - 1; i++) {
if (s[i] != s[i + 1]) {
alls = false;
break;
}
}
if (alls) {
long long int ans = 1;
ans *= (n + 1);
ans *= n;
ans /= 2;
ans %= mod;
cout << ans;
return 0;
}
if (s[0] == s[n - 1]) {
int front = 1, back = 1;
for (int i = 1; i < n; i++) {
if (s[i] == s[i - 1]) {
front++;
} else {
break;
}
}
for (int i = n - 2; i >= 0; i--) {
if (s[i] == s[i + 1]) {
back++;
} else {
break;
}
}
long long int ans = 1 * (front + 1);
ans *= (back + 1);
ans %= mod;
cout << ans;
return 0;
}
int front = 1, back = 1;
for (int i = 1; i < n; i++) {
if (s[i] == s[i - 1]) {
front++;
} else {
break;
}
}
for (int i = n - 2; i >= 0; i--) {
if (s[i] == s[i + 1]) {
back++;
} else {
break;
}
}
cout << (front + back + 1) % mod;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class T1, class T2>
bool umin(T1& a, T2 b) {
return a > b ? (a = b, true) : false;
}
template <class T1, class T2>
bool umax(T1& a, T2 b) {
return a < b ? (a = b, true) : false;
}
template <class T>
void clear(T& a) {
T().swap(a);
}
const int N = 1e5 + 5;
int n, m, _, k;
int a, b, len[N], lens, ne[N];
string s, ans[N], cur;
void solve(int x) {
cur += s[x];
if (s[x] != s[a])
ne[x] = a;
else
ne[x] = ne[a];
b = a;
a = x;
len[x] = cur.size();
if (cur.size() <= 10)
ans[x] = cur, reverse((ans[x]).begin(), (ans[x]).end());
else {
string t = cur.substr(cur.size() - 5, 5);
reverse((t).begin(), (t).end());
ans[x] = t + "..." + cur[1] + cur[0];
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cin >> s;
a = lens = s.size();
s += char(0);
ne[lens] = lens;
for (int i = (lens - 1); i >= (0); --i) {
if (s[i] != s[i + 1])
solve(i);
else if (i + 1 == a && s[ne[i + 1]] < s[i]) {
a = b;
cur.pop_back();
len[i] = len[i + 2];
ans[i] = ans[i + 2];
} else
solve(i);
}
for (int i = (0); i <= (lens - 1); ++i)
cout << len[i] << ' ' << ans[i] << '\n';
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long M = 1e5 + 10;
const long long INF = 1e18 + 5;
const long long MOD = 1e9 + 7;
const long long MAX = 25;
const long long N = 2.5e5 + 200;
const double PI = 3.14159265358979323846264338327950288419716939937510;
long long ans, mark[M], n, m, a[M], b[M], pa[M];
vector<long long> adj[M];
void dfs(long long i) {
if (mark[i]) return;
mark[i] = 1;
if (a[i] == b[i]) {
ans++;
b[i]++;
pa[i] = 1;
for (auto x : adj[i]) b[x]++, dfs(x);
}
mark[i] = 0;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (long long i = 1; i <= m; i++) {
long long p, q;
cin >> p >> q;
adj[p].push_back(q);
adj[q].push_back(p);
}
for (long long i = 1; i <= n; i++) cin >> a[i];
for (long long i = 1; i <= n; i++) dfs(i);
cout << ans << "\n";
for (long long i = 1; i <= n; i++)
if (pa[i] == 1) cout << i << " ";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
long long m, n, k, t;
cin >> m >> n >> k >> t;
vector<long long> a(m);
for (long long i = 0; i < m; i++) {
cin >> a[i];
}
sort(a.begin(), a.end());
vector<vector<pair<long long, long long> > > b(n);
for (long long i = 0; i < k; i++) {
long long l, r, d;
cin >> l >> r >> d;
l--;
r--;
b[l].push_back({d, r});
}
long long l = -1, r = m;
while (l + 1 < r) {
long long mid = (l + r) / 2;
vector<pair<long long, long long> > road;
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < b[i].size(); j++) {
if (b[i][j].first > a[mid]) {
road.push_back({i, b[i][j].second});
}
}
}
sort(road.begin(), road.end());
vector<pair<long long, long long> > rd;
if (road.size() > 0) {
long long cl = road[0].first, cr = road[0].second;
for (long long i = 1; i < (long long)road.size(); i++) {
if (road[i].first <= cr) {
cr = max(road[i].second, cr);
} else {
rd.push_back({cl, cr});
cl = road[i].first;
cr = road[i].second;
}
}
rd.push_back({cl, cr});
}
long long ans = n + 1;
for (long long i = 0; i < (long long)rd.size(); i++) {
ans += (rd[i].second - rd[i].first + 1) * 2;
}
if (ans <= t) {
r = mid;
} else {
l = mid;
}
}
cout << m - r << endl;
}
| 5 |
#include <bits/stdc++.h>
int main() {
int n, j, i, k, tam;
int a[1000];
scanf("%d", &n);
scanf("%d", &k);
for (i = 0; i < n; i++) scanf("%d", &a[i]);
for (i = 0; i < n - 1; i++)
for (j = i + 1; j < n; j++)
if (a[i] > a[j]) {
tam = a[j];
a[j] = a[i];
a[i] = tam;
}
printf("%d", a[n - k]);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
char s[maxn];
int vis[maxn];
pair<char, int> sta[maxn];
int main() {
scanf("%s", s);
int o = -1;
for (int i = 0; s[i]; i++) {
if (s[i] == '0' && o >= 0 && sta[o].first == '1') {
vis[sta[o].second] = 1;
o--;
} else
sta[++o] = make_pair(s[i], i);
}
for (int i = 0; s[i]; i++) printf("%d", vis[i]);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
int seq[2000];
int min = 100000, max = 0;
int ans = -1;
for (int i = 0; i < n; ++i) {
scanf("%d", seq + i);
bool flag = 0;
if (seq[i] > max) {
max = seq[i];
flag = 1;
ans++;
}
if (seq[i] < min) {
min = seq[i];
if (!flag) {
ans++;
}
}
}
printf("%d\n", ans);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
mt19937 rng((int)chrono::steady_clock::now().time_since_epoch().count());
const int MOD = 998244353;
const int MAXN = 4e5 + 5;
const ll INF = 2e18;
int fexp(ll b, int e) {
ll resp = 1;
while (e) {
if (e & 1) resp = (resp * b) % MOD;
b = (b * b) % MOD;
e >>= 1;
}
return resp;
}
int fat[MAXN], inv[MAXN];
ll nck(int n, int k) {
return (((1ll * fat[n] * inv[k]) % MOD) * 1ll * inv[n - k]) % MOD;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
fat[0] = 1;
for (int i = 1; i < MAXN; i++) {
fat[i] = (1ll * fat[i - 1] * i) % MOD;
}
inv[MAXN - 1] = fexp(fat[MAXN - 1], MOD - 2);
for (int i = MAXN - 2; i >= 0; i--) {
inv[i] = (1ll * (i + 1ll) * inv[i + 1]) % MOD;
}
int n;
cin >> n;
int b = 0, w = 0, cnt = 1;
bool wb = true, bw = true;
string s;
for (int i = 0; i < n; i++) {
cin >> s;
wb &= (s != "WW" && s != "BB" && s != "B?" && s != "?W" && s != "BW");
bw &= (s != "WW" && s != "BB" && s != "?B" && s != "W?" && s != "WB");
if (s == "WW" || s == "BB") cnt = 0;
if (s == "??") cnt = (2ll * cnt) % MOD;
if (s[0] == 'B') b++;
if (s[0] == 'W') w++;
if (s[1] == 'B') b++;
if (s[1] == 'W') w++;
}
if (b > n || w > n)
cout << "0\n";
else {
cout << (nck(2 * n - b - w, n - b) - cnt + bw + wb + MOD) % MOD << '\n';
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000;
long long ans[MAXN + 10];
long long dist[MAXN + 10][MAXN + 10];
bool vis[MAXN + 10];
int lst[MAXN + 10];
int n;
void push(const int x) {
vis[x] = true;
for (int k = 1; k <= n; ++k) {
for (int j = 1; j <= n; ++j) {
if (!vis[k] || !vis[j]) continue;
dist[x][j] = min(dist[x][j], dist[x][k] + dist[k][j]);
dist[j][x] = min(dist[j][x], dist[j][k] + dist[k][x]);
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
if (i == j || !vis[i] || !vis[j]) continue;
dist[i][j] = min(dist[i][j], dist[i][x] + dist[x][j]);
}
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) scanf("%I64d", &dist[i][j]);
for (int i = 1; i <= n; ++i) scanf("%d", &lst[i]);
for (int t = n; t; --t) {
push(lst[t]);
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
if (i == j || !vis[i] || !vis[j]) continue;
ans[t] += dist[i][j];
}
}
}
for (int i = 1; i <= n; ++i) printf("%I64d ", ans[i]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T min(T a, T b, T c) {
return min(a, min(b, c));
}
template <class T>
T min(T a, T b, T c, T d) {
return min(a, min(b, min(c, d)));
}
template <class T>
T max(T a, T b, T c) {
return max(a, max(b, c));
}
template <class T>
T max(T a, T b, T c, T d) {
return max(a, max(b, max(c, d)));
}
bool cmp(const pair<int, int>& a, const pair<int, int>& b) {
return (a.first > b.first || (a.first == b.first && a.second >= b.second));
}
long long GCD(long long a, long long b) { return (a % b) ? GCD(b, a % b) : b; }
const string namePro = "tmp";
bool ck[1000007];
int main() {
srand(time(NULL));
int n, k;
scanf("%d%d", &n, &k);
vector<pair<int, int> > vc;
int tmp = rand() % RAND_MAX + 1;
for (int i = (1); i <= (1000000); ++i) {
if ((tmp ^ i) > i) vc.push_back(make_pair(i, (tmp ^ i)));
}
if (n % 3 == 0 && k == 0) {
set<int> st;
for (int i = (0); i <= (1000000); ++i) {
int k = rand() % RAND_MAX + 1;
if ((i ^ k) > 1000000) continue;
if (!ck[i] && !ck[k] && !ck[(i ^ k)] && i != k && i != (i ^ k) &&
k != (i ^ k)) {
ck[i] = ck[k] = ck[(i ^ k)] = 1;
st.insert(i);
st.insert(k);
st.insert(i ^ k);
}
if ((int)st.size() == n) break;
}
puts("YES");
for (__typeof(st.begin()) it = st.begin(); it != st.end(); ++it)
cout << *it << " ";
return 0;
}
int cnt = 0;
bool check = 0;
set<int> st;
while (n > 2) {
if (vc[cnt].first != k && vc[cnt].second != k && vc[cnt].first != tmp &&
vc[cnt].second != tmp) {
st.insert(vc[cnt].first);
st.insert(vc[cnt].second);
-- --n;
check = !check;
}
++cnt;
}
if (n == 2) {
if (check) {
st.insert(tmp);
st.insert(k);
} else {
st.insert(tmp);
st.insert((k ^ tmp));
}
} else {
if (check)
st.insert((k ^ tmp));
else
st.insert(k);
}
int ans = 0;
for (__typeof(st.begin()) it = st.begin(); it != st.end(); ++it) ans ^= *it;
if (ans == k) {
puts("YES");
for (__typeof(st.begin()) it = st.begin(); it != st.end(); ++it)
cout << *it << " ";
} else
puts("NO");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5007;
const int Inf = 0x3fffffff;
const int Mod = 1e9 + 7;
const double eps = 1e-8;
vector<int> e[N];
int sz, root, tot[N];
int f[N][2][N], cur[2][N];
void Dfs(int u, int pre) {
if (e[u].size() == 1) {
tot[u] = 1;
f[u][1][1] = f[u][0][0] = 0;
f[u][0][1] = f[u][1][0] = Inf;
return;
}
for (int w = 0; w < e[u].size(); w++) {
int v = e[u][w];
if (v == pre) continue;
Dfs(v, u);
memset(cur, 0x3f, sizeof(cur));
for (int i = 0; i < 2; i++) {
int mxj = min(sz / 2, tot[u]);
for (int j = mxj; j >= 0; j--) {
for (int p = 0; p < 2; p++) {
int mxq = min(tot[v], sz / 2);
for (int q = 0; q <= mxq; q++) {
if (j + q > sz / 2) break;
cur[i][j + q] =
min(cur[i][j + q], f[u][i][j] + f[v][p][q] + (i != p));
}
}
}
}
tot[u] += tot[v];
for (int i = 0; i < 2; i++) {
int mxj = min(sz / 2, tot[u]);
for (int j = mxj; j >= 0; j--) {
f[u][i][j] = cur[i][j];
}
}
}
}
int n, u, v;
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
scanf("%d%d", &u, &v);
e[u].push_back(v);
e[v].push_back(u);
}
if (n == 2) {
puts("1");
return 0;
}
for (int i = 1; i <= n; i++) {
if (e[i].size() > 1) {
root = i;
} else {
sz++;
}
}
memset(f, 0x3f, sizeof(f));
for (int i = 1; i <= n; i++) f[i][0][0] = f[i][1][0] = 0;
Dfs(root, 0);
printf("%d\n", f[root][0][sz / 2]);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m = -1, z = 0, x, t, c, b, k;
long long sum = 0;
int arr[200010];
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d%d", &arr[i], &x);
sum += arr[i];
if (m <= x) {
z = m;
b = c;
m = x;
c = i;
} else if (x >= z) {
z = x;
b = i;
}
}
for (int i = 0; i < n; i++) {
if (i == c) {
t = z;
k = b;
} else {
t = m;
k = c;
}
sum -= arr[i];
printf("%I64d ", sum * t);
sum += arr[i];
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > v;
void does(int x) {
if (v[x].first != 0) {
if (v[x].first < 0)
cout << "1 " << v[x].first * -1 << " L" << endl;
else
cout << "1 " << v[x].first << " R" << endl;
}
if (v[x].second != 0) {
if (v[x].second < 0)
cout << "1 " << v[x].second * -1 << " D" << endl;
else
cout << "1 " << v[x].second << " U" << endl;
}
cout << "2" << endl;
if (v[x].second != 0) {
if (v[x].second < 0)
cout << "1 " << v[x].second * -1 << " U" << endl;
else
cout << "1 " << v[x].second << " D" << endl;
}
if (v[x].first != 0) {
if (v[x].first < 0)
cout << "1 " << v[x].first * -1 << " R" << endl;
else
cout << "1 " << v[x].first << " L" << endl;
}
cout << "3" << endl;
}
bool comp(pair<int, int> a, pair<int, int> b) {
if (a.first < 0) a.first = (a.first * -1);
if (a.second < 0) a.second = (a.second * -1);
if (b.first < 0) b.first = b.first * -1;
if (b.second < 0) b.second = b.second * -1;
return a < b;
}
int main() {
int n;
cin >> n;
v = vector<pair<int, int> >(n);
int count = 0;
for (int i = 0; i < n; ++i) {
int x, y;
cin >> x >> y;
v[i].first = x;
v[i].second = y;
count += 2 * ((x and 1) + (y and 1) + 1);
}
sort(v.begin(), v.end(), comp);
cout << count << endl;
for (int i = 0; i < n; ++i) does(i);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 105;
char arr[MAX][MAX];
int main() {
int n;
cin >> n;
int cnt = 0;
bool flag = false;
for (int i = 0; i < n; i++) cin >> arr[i];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (arr[i][j] == '.') {
cnt++;
break;
}
}
}
if (cnt < n) {
flag = true;
}
if (!flag) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (arr[i][j] == '.') {
cout << i + 1 << " " << j + 1 << endl;
break;
}
}
}
} else {
cnt = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (arr[j][i] == '.') {
cnt++;
break;
}
}
}
bool flag = false;
if (cnt < n) {
flag = true;
}
if (flag) {
cout << "-1" << endl;
return 0;
} else {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (arr[j][i] == '.') {
cout << j + 1 << " " << i + 1 << endl;
break;
}
}
}
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int num[1111];
int anss[1111];
int main() {
int t, n, p;
scanf("%d", &t);
while (t--) {
scanf("%d%d", &n, &p);
int q = 2 * n + p;
for (int i = 1; i < n; i++) {
for (int j = i + 1; j <= n; j++) {
if (q > 0) {
printf("%d %d\n", i, j);
q--;
}
}
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b, c, d, e, g, h, i, j, k, l, n, t, z;
cin >> t;
while (t--) {
cin >> a >> b;
c = a ^ b;
cout << c << endl;
}
}
| 0 |
#include <bits/stdc++.h>
int main() {
int n, i;
int ar[101];
int spec = 0;
scanf("%d", &n);
for (i = 0; i < n; i++) scanf("%d", &ar[i]);
spec = 3;
for (i = 0; i < n; i++) {
if (ar[i] == spec) {
printf("NO\n");
return 0;
} else if (ar[i] == 1) {
if (spec == 2)
spec = 3;
else if (spec == 3)
spec = 2;
else {
printf("NO\n");
return 0;
}
} else if (ar[i] == 2) {
if (spec == 1)
spec = 3;
else if (spec == 3)
spec = 1;
else {
printf("NO\n");
return 0;
}
} else if (ar[i] == 3) {
if (spec == 1)
spec = 2;
else if (spec == 2)
spec = 1;
else {
printf("NO\n");
return 0;
}
}
}
printf("YES\n");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
if (x1 == x2 && y1 == y2) {
cout << 0 << " " << 0 << " " << 0;
cout << '\n';
return 0;
}
int ans1 = 0;
if (x1 == x2 && y1 == y2)
ans1 = 0;
else if (x1 == x2 || y1 == y2)
ans1 = 1;
else
ans1 = 2;
int ans2 = 0;
int diff1 = abs(x1 - x2), diff2 = abs(y1 - y2);
if (diff1 == diff2)
ans2 = 1;
else if (diff1 % 2 == 0 && diff2 % 2 == 0)
ans2 = 2;
else if (diff1 % 2 != 0 && diff2 % 2 != 0)
ans2 = 2;
else
ans2 = 0;
int ans3 = max(diff1, diff2);
cout << ans1 << " " << ans2 << " " << ans3 << '\n';
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
unsigned long long int n, k;
cin >> n >> k;
if ((n / k) % 2)
cout << "YES\n";
else
cout << "NO\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct node {
unordered_map<int, int> ch;
vector<int> term;
int next(int v);
int ins(int v);
};
pair<int, int> ed[105][105];
node trie[10005];
bool mark[105];
int last[105];
int pre[205];
int deg[105];
int vis[105];
int hv[105];
int hf[105];
int e[205];
int m[105];
int n, T, ec, c;
int node::next(int v) {
if (ch.count(v))
return ch[v];
else
return -1;
}
int node::ins(int v) {
if (ch.count(v))
return ch[v];
else
ch[v] = ++c;
return c;
}
void add(int a, int b) {
e[++ec] = b, pre[ec] = last[a], last[a] = ec;
e[++ec] = a, pre[ec] = last[b], last[b] = ec;
}
int v[105];
void dfs_hash(int x, int par) {
int i, k = 0;
hf[x] = 23333;
for (i = last[x]; i != 0; i = pre[i])
if (e[i] != par) dfs_hash(e[i], x);
for (i = last[x]; i != 0; i = pre[i])
if (e[i] != par) v[++k] = hf[e[i]];
sort(v + 1, v + k + 1);
for (i = 1; i <= k; ++i)
hf[x] = (((long long)hf[x] * 2333) ^ v[i]) % 1000000007;
hf[x] = (long long)hf[x] * 4999 % 1000000007;
}
void calc_hash(int type) {
int i;
for (i = 1; i <= n; ++i)
if (vis[i] == type) {
memset(hf, 0, sizeof(hf));
dfs_hash(i, 0);
hv[i] = hf[i];
}
}
void makehash(int p) {
int i, k;
memset(hv, 0, sizeof(hv));
for (i = 1; i <= T; ++i) calc_hash(i);
sort(hv + 1, hv + n + 1);
k = 1;
for (i = 1; i <= n; ++i) k = trie[k].ins(hv[i]);
trie[k].term.push_back(p);
}
void buildtree(int ver) {
int i;
memset(last, 0, sizeof(last));
memset(deg, 0, sizeof(deg));
ec = 0;
for (i = 1; i <= m[ver]; ++i) {
add(ed[ver][i].first, ed[ver][i].second);
++deg[ed[ver][i].first], ++deg[ed[ver][i].second];
}
}
void dfs(int x) {
int i;
vis[x] = T;
for (i = last[x]; i != 0; i = pre[i])
if (vis[e[i]] != T) dfs(e[i]);
}
void init() {
int i, j;
for (i = 1; i <= n; ++i) {
buildtree(i), T = 0;
memset(vis, 0, sizeof(vis));
for (j = 1; j <= n; ++j)
if (vis[j] == 0) {
++T;
dfs(j);
}
makehash(i);
}
}
int find() {
int i, j = 1;
for (i = 1; i <= n; ++i)
if ((j = trie[j].next(hv[i])) == -1) return 0;
return j;
}
bool check(int to, int nv, int del) {
int i, p;
m[n + 2] = 0;
if (del != nv && del != to) ed[n + 2][++m[n + 2]] = make_pair(nv, to);
for (i = 1; i <= m[n + 1]; ++i)
if (ed[n + 1][i].first != del && ed[n + 1][i].second != del)
ed[n + 2][++m[n + 2]] = ed[n + 1][i];
memset(vis, 0, sizeof(vis));
buildtree(n + 2);
memset(hv, 0, sizeof(hv));
calc_hash(0);
sort(hv + 1, hv + n + 1);
if ((p = find()) == 0) return 0;
for (i = 0; i < trie[p].term.size(); ++i)
if (!mark[trie[p].term[i]]) {
mark[trie[p].term[i]] = 1;
return 1;
}
return 0;
}
bool work() {
int i, j, x, gr;
for (i = 1; i <= n; ++i)
if (m[i] == n - 2) break;
buildtree(i);
memcpy(ed[n + 1], ed[i], sizeof(ed[i]));
m[n + 1] = m[i];
for (i = 1; i <= n; ++i)
if (deg[i] == 0) break;
x = i;
for (i = 1; i <= n; ++i)
if (i != x) {
memset(mark, 0, sizeof(mark));
for (j = 1; j <= n; ++j)
if (!check(i, x, j)) break;
if (j > n) {
ed[n + 1][++m[n + 1]] = make_pair(i, x);
return 1;
}
}
return 0;
}
void output() {
int i;
for (i = 1; i < n; ++i)
printf("%d %d\n", ed[n + 1][i].first, ed[n + 1][i].second);
}
void spec2() {
if (m[1] == 0 && m[2] == 0)
printf("YES\n1 2\n");
else
printf("NO\n");
}
int main() {
int i, j, t, x, y;
scanf("%d", &t);
while (t--) {
while (c) {
trie[c].ch.clear();
trie[c].term.clear();
--c;
}
c = 1;
scanf("%d%d", &n, &n);
for (i = 1; i <= n; ++i) {
scanf("%d", &m[i]);
for (j = 1; j <= m[i]; ++j) {
scanf("%d%d", &x, &y);
ed[i][j] = make_pair(x, y);
}
}
if (n == 2) {
spec2();
continue;
}
init();
if (work()) {
printf("YES\n");
output();
} else
printf("NO\n");
}
fclose(stdin);
fclose(stdout);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10, M = 30;
char a[N], b[N];
int n, ct[M][M], fa[M], x, y;
int find_f(int x) { return x == fa[x] ? x : fa[x] = find_f(fa[x]); }
int main() {
int T;
cin >> T;
while (T--) {
scanf("%d%s%s", &n, a + 1, b + 1);
bool flg = 1;
memset(ct, 0, sizeof(ct));
for (int i = 1; i <= n; i++) {
if (a[i] > b[i]) {
flg = 0;
break;
}
if (a[i] < b[i]) ct[a[i] - 'a'][b[i] - 'a'] = 1;
}
if (!flg) {
puts("-1");
continue;
}
int ans = 0;
for (int i = 0; i <= 20; i++) fa[i] = i;
for (int i = 0; i <= 20; i++)
for (int j = i + 1; j <= 20; j++)
if (ct[i][j]) {
x = find_f(i);
y = find_f(j);
if (x != y) ans++, fa[x] = y;
}
cout << ans << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int nmax = 2e5;
const int inf = 1 << 30;
vector<int> g[nmax + 1];
int sz[nmax + 1];
int d[nmax + 1][2];
void dfs_max(int nod, int h) {
for (auto i : g[nod]) dfs_max(i, h + 1);
sz[nod] = 0;
for (auto i : g[nod]) sz[nod] += sz[i];
if (sz[nod] == 0) sz[nod] = 1;
d[nod][0] = d[nod][1] = 0;
if (h % 2 == 0) {
d[nod][0] = sz[nod] - 1;
for (auto i : g[nod]) d[nod][0] = min(d[nod][0], sz[i] - d[i][1]);
d[nod][0] = sz[nod] - d[nod][0];
} else {
for (auto i : g[nod]) d[nod][1] += (d[i][0] - 1);
++d[nod][1];
}
}
void dfs_min(int nod, int h) {
for (auto i : g[nod]) dfs_min(i, h + 1);
d[nod][0] = d[nod][1] = 0;
if (h % 2 == 0) {
for (auto i : g[nod]) d[nod][0] += d[i][1];
if (d[nod][0] == 0) ++d[nod][0];
} else {
d[nod][1] = 1 << 30;
for (auto i : g[nod]) d[nod][1] = min(d[nod][1], d[i][0]);
if (d[nod][1] == 1 << 30) d[nod][1] = 1;
}
}
int main() {
int n;
cin >> n;
for (int i = 1; i < n; ++i) {
int x, y;
fscanf(stdin, "%d%d", &x, &y);
g[x].push_back(y);
}
dfs_max(1, 0);
fprintf(stdout, "%d ", d[1][0]);
dfs_min(1, 0);
fprintf(stdout, "%d\n", d[1][0]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
struct Point {
double x, y;
Point(void) {}
Point(double _x, double _y) : x(_x), y(_y) {}
friend Point operator-(const Point &a, const Point &b) {
return Point(a.x - b.x, a.y - b.y);
}
friend Point operator+(const Point &a, const Point &b) {
return Point(a.x + b.x, a.y + b.y);
}
friend Point operator*(const Point &a, const double &b) {
return Point(a.x * b, a.y * b);
}
void read() { scanf("%lf%lf", &x, &y); }
} A, B, C;
inline double sqr(double x) { return x * x; }
inline double dist(Point a, Point b) {
return sqrt(sqr(a.x - b.x) + sqr(a.y - b.y));
}
struct Circle {
Point o;
double r;
Circle(void) {}
Circle(Point _o, double _r) : o(_o), r(_r) {}
friend pair<Point, Point> jiao(const Circle &a, const Circle &b) {
double d = dist(a.o, b.o);
double d1 = (sqr(a.r) - sqr(b.r) + sqr(d)) / 2 / d;
Point p1 = b.o - a.o;
Point p2 = Point(-p1.y, p1.x);
Point now = a.o + p1 * (d1 / dist(a.o, b.o));
Point res1 = now, res2 = now;
double d2 = sqrt(sqr(a.r) - sqr(d1));
if (d2 > 1e-8) {
res1 = now + p2 * (d2 / sqrt(sqr(p2.x) + sqr(p2.y)));
res2 = now - p2 * (d2 / sqrt(sqr(p2.x) + sqr(p2.y)));
}
return make_pair(res1, res2);
}
friend bool operator<(const Circle &a, const Circle &b) { return a.r < b.r; }
};
inline bool In(const Circle &a, const Point &b) { return dist(a.o, b) <= a.r; }
void print(double x) {
printf("%.10lf\n", x);
exit(0);
}
double lim1, lim2;
Circle c[3];
inline bool neihan(Circle a, Circle b) {
return dist(a.o, b.o) <= abs(a.r - b.r);
}
inline bool check2(Circle a, Circle b) {
return dist(a.o, b.o) <= a.r + b.r + 1e-9;
}
inline bool check(double T) {
c[0] = Circle(Point(A), T);
c[1] = Circle(Point(C), lim1 - T - dist(B, C));
c[2] = Circle(Point(B), lim2 - T);
sort(c, c + 3);
if (c[0].r < 0 || c[1].r < 0 || c[2].r < 0) return false;
if (!check2(c[0], c[1]) || !check2(c[1], c[2]) || !check2(c[0], c[2]))
return false;
if (neihan(c[0], c[1])) return check2(c[0], c[2]);
if (neihan(c[0], c[2])) return check2(c[0], c[1]);
if (neihan(c[1], c[2])) return check2(c[0], c[1]);
pair<Point, Point> tmp;
tmp = jiao(c[0], c[1]);
if (In(c[2], tmp.first) || In(c[2], tmp.second)) return true;
tmp = jiao(c[0], c[2]);
if (In(c[1], tmp.first) || In(c[1], tmp.second)) return true;
tmp = jiao(c[1], c[2]);
if (In(c[0], tmp.first) || In(c[0], tmp.second)) return true;
return false;
}
int main() {
cin >> lim1 >> lim2;
A.read();
B.read();
C.read();
lim1 += dist(A, C) + dist(C, B);
lim2 += dist(A, B);
if (lim2 >= dist(A, C) + dist(C, B)) print(min(lim1, lim2));
double l = 0, r = 1000000;
for (int i = 1; i <= 100000; i++) {
double mid = (l + r) / 2;
if (check(mid))
l = mid;
else
r = mid;
}
print(l);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <class T, class first>
inline bool checkbit(T a, first pos) {
T t = 1;
return ((a & (t << pos)) > 0);
}
template <class T, class first>
inline T setbit(T a, first pos) {
T t = 1;
return (a | (t << pos));
}
template <class T, class first>
inline T resetbit(T a, first pos) {
T t = 1;
return (a & (~(t << pos)));
}
template <class T, class first>
inline T togglebit(T a, first pos) {
T t = 1;
return (a ^ (t << pos));
}
template <typename T>
T POW(T B, T printf) {
if (printf == 0) return 1;
if (printf & 1)
return B * POW(B, printf - 1);
else
return (POW(B, printf / 2) * POW(B, printf / 2));
}
template <typename T>
T Bigmod(T base, T power, T mod) {
T ret = 1;
while (power) {
if (power & 1) ret = (ret * base) % mod;
base = (base * base) % mod;
power >>= 1;
}
return ret;
}
template <typename T>
T ModInverse(T number, T mod) {
return Bigmod(number, mod - 2, mod);
}
template <typename T>
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 <typename T>
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 <typename T>
T EUCLIDE(T a, T b, T &x, T &y) {
if (a < 0) {
T d = euclide(-a, b, x, y);
x = -x;
return d;
}
if (b < 0) {
T d = euclide(a, -b, x, y);
y = -y;
return d;
}
if (b == 0) {
x = 1;
y = 0;
return a;
} else {
T d = euclide(b, a % b, x, y);
T t = x;
x = y;
y = t - (a / b) * y;
return d;
}
}
template <typename T>
T ABS(T a) {
if (a < 0)
return -a;
else
return a;
}
double DEG(double x) { return (180.0 * x) / ((2.0 * acos(0.0))); }
double RAD(double x) { return (x * (double)(2.0 * acos(0.0))) / (180.0); }
template <typename T>
double DIS(T x1, T y1, T x2, T y2) {
return sqrt((double)((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)));
}
template <typename T>
T ANGLE(T x1, T y1, T x2, T y2) {
return atan(double(y1 - y2) / double(x1 - x2));
}
template <typename T>
long long isLeft(T a, T b, T c) {
return (c.x - a.x) * (b.y - a.y) - (b.x - a.x) * (c.y - a.y);
}
template <class T>
inline bool setmin(T &a, T b) {
return a > b ? a = b, true : false;
}
template <class T>
inline bool setmax(T &a, T b) {
return a < b ? a = b, true : false;
}
void P_ARR(int *ar, int a, int b) {
if (a > b) swap(a, b);
if (a <= b) cout << ar[a];
for (int i = a + 1; i <= b; i++) cout << " " << ar[i];
cout << endl;
}
template <typename T>
T in() {
char ch;
T n = 0;
bool ng = false;
while (1) {
ch = getchar();
if (ch == '-') {
ng = true;
ch = getchar();
break;
}
if (ch >= '0' && ch <= '9') break;
}
while (1) {
n = n * 10 + (ch - '0');
ch = getchar();
if (ch < '0' || ch > '9') break;
}
return (ng ? -n : n);
}
int ar[70];
long long dp[70][2][70];
int len;
int p;
long long call(int pos, int choto, int cnt) {
if (cnt > len) return 0;
if (pos == len) return (cnt == p);
long long &ret = dp[pos][choto][cnt];
if (ret != -1) return ret;
ret = 0;
int high = (choto) ? 1 : ar[pos];
for (int i = 0; i <= high; i++)
ret += call(pos + 1, (choto || (i < high)), cnt + i);
return ret;
}
int main() {
long long N, T;
cin >> N >> T;
long long v = 1;
while (v < T) {
p++;
v *= 2;
}
if (v > T) {
printf("%d\n", 0);
return 0;
}
p = p + 1;
N++;
while (N) ar[len++] = N % 2, N /= 2;
reverse(ar, ar + len);
memset(dp, -1, sizeof dp);
printf("%lld\n", call(0, 0, 0) - (T == 1));
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
#pragma comment(linker, "/STACK:336777216")
using namespace std;
int IT_MAX = 1 << 17;
long long MOD = 1000000007;
const int INF = 0x3f3f3f3f;
const long long LL_INF = 0x3f3f3f3f3f3f3f3f;
const double PI = acos(-1);
const double ERR = 1e-10;
set<pair<int, int> > Sx;
vector<int> conn[200050];
bool pchk[200050];
int lc = 1;
vector<int> Vl[200050];
int r[200050];
int sz[200050];
int root(int x) { return (x == r[x]) ? x : (r[x] = root(r[x])); }
int main() {
int N, M, i, j;
scanf("%d %d", &N, &M);
for (i = 1; i <= M; i++) {
int t1, t2;
scanf("%d %d", &t1, &t2);
Sx.emplace(t1, t2);
Sx.emplace(t2, t1);
conn[t1].push_back(t2);
conn[t2].push_back(t1);
}
int p = 1;
for (i = 2; i <= N; i++)
if (conn[i].size() < conn[p].size()) p = i;
for (auto it : conn[p]) pchk[it] = true;
for (i = 1; i <= N; i++)
if (!pchk[i]) Vl[1].push_back(i);
for (i = 1; i <= N; i++) {
if (!pchk[i]) continue;
lc++;
Vl[lc].push_back(i);
}
for (i = 1; i <= lc; i++) r[i] = i;
for (i = 1; i <= lc; i++) {
for (j = i + 1; j <= lc; j++) {
bool chk = false;
for (auto it1 : Vl[i]) {
for (auto it2 : Vl[j]) {
if (Sx.count(pair<int, int>(it1, it2))) continue;
chk = true;
break;
}
}
if (chk) r[root(i)] = root(j);
}
}
int cnt = 0;
for (i = 1; i <= lc; i++) sz[root(i)] += Vl[i].size();
vector<int> Va;
for (i = 1; i <= lc; i++)
if (r[i] == i) Va.push_back(sz[i]);
sort((Va).begin(), (Va).end());
printf("%d\n", (int)Va.size() - 1);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, c, maxi = 0;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
for (int j = 0; j < n; j++) {
c = count(v.begin(), v.end(), v[j]);
if (c > maxi) {
maxi = c;
}
}
set<int> s(v.begin(), v.end());
int ss = int(s.size());
cout << maxi << " " << ss << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int Max = 3e5 + 10;
const int E = Max * 2;
int son[Max], maxson[Max], fa[Max], zx[Max];
int head[Max], nex[E], pnt[E], edge;
int vis[Max];
void Init() {
edge = 0;
memset(son, 0, sizeof(son));
memset(maxson, 0, sizeof(maxson));
memset(fa, -1, sizeof(fa));
memset(head, -1, sizeof(head));
memset(vis, 0, sizeof(vis));
}
void Addedge(int u, int v) {
pnt[edge] = v;
nex[edge] = head[u];
head[u] = edge++;
}
void dfs1(int u) {
son[u] = 1;
vis[u] = 1;
maxson[u] = 0;
int v;
for (int e = head[u]; e != -1; e = nex[e]) {
v = pnt[e];
if (!vis[v]) {
dfs1(v);
son[u] += son[v];
maxson[u] = max(maxson[u], son[v]);
}
}
}
bool is_ok(int u, int v) {
if (son[u] >= maxson[v] * 2 && son[u] >= (son[u] - son[v]) * 2) return 1;
return 0;
}
void dfs2(int u) {
vis[u] = 1;
if (son[u] == 1) {
zx[u] = u;
return;
}
int v, z = u;
for (int e = head[u]; e != -1; e = nex[e]) {
v = pnt[e];
if (!vis[v]) {
dfs2(v);
if (maxson[u] == son[v]) {
z = zx[v];
}
}
}
while (!is_ok(u, z) && fa[z] != -1) {
z = fa[z];
}
zx[u] = z;
}
int main() {
int n, m;
while (~scanf("%d%d", &n, &m)) {
Init();
int u, v;
for (int i = 2; i <= n; i++) {
scanf("%d", &u);
fa[i] = u;
Addedge(u, i);
Addedge(i, u);
}
dfs1(1);
memset(vis, 0, sizeof(vis));
dfs2(1);
while (m--) {
scanf("%d", &u);
printf("%d\n", zx[u]);
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e4 + 5;
int nex[maxn];
void getnex(string s) {
int n = s.size(), i = 0, j = -1;
nex[0] = -1;
while (i < n) {
if (s[i] == s[j] || j == -1)
nex[++i] = ++j;
else
j = nex[j];
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, k;
cin >> n >> k;
string s;
cin >> s;
getnex(s);
int pos = nex[n];
string t = s;
k--;
while (k--) {
for (int i = pos; i < n; i++) t += s[i];
}
cout << t << '\n';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using tint = long long;
using ld = long double;
using vi = vector<int>;
using pi = pair<int, int>;
const tint MOD = 1e9 + 7;
const int MX = 1e5 + 5;
const int INF = 1e9;
const long double PI = acos((-1));
void NACHO(string name = "factory") {
ios_base::sync_with_stdio(0);
cin.tie(0);
}
int main() {
NACHO();
int tc;
cin >> tc;
while (tc--) {
int n;
cin >> n;
vi a(n + 1);
for (int i = 0; i < int(n); i++) cin >> a[i + 1];
vi dp(n + 1, 1);
for (int i = 1; i < int(n + 1); i++) {
for (int j = 1; j * j <= i; ++j) {
if (i % j == 0) {
if (a[j] < a[i]) dp[i] = max(dp[i], dp[j] + 1);
if (a[i / j] < a[i]) dp[i] = max(dp[i], dp[i / j] + 1);
}
}
}
int maxi = 0;
for (int i = 0; i < int(n); i++) maxi = max(maxi, dp[i + 1]);
cout << maxi << "\n";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
class york {
public:
void solve();
};
struct block {
int start;
vector<long long> v;
};
const int X = 300000;
const int SQ = 512;
int n;
int w[X + 7];
int steps[SQ];
vector<block> vb[SQ];
void build() {
for (int l = 1; l < SQ; ++l) {
vector<long long> v(l + 1);
for (int i = 0; i < l; ++i) {
v.push_back(0);
}
steps[l] = sqrt(X / l) * 1.28;
int STEP = steps[l];
for (int start = 0; start + l * STEP < X; start += l * STEP) {
for (int head = start; head < start + l * STEP; head += l) {
for (int i = 0; i < l; ++i) {
v[i] += w[head + i];
}
}
block b;
b.start = start + l * (STEP - 1);
b.v = vector<long long>(v);
vb[l].push_back(b);
}
}
}
long long cal(int step, int start, int end) {
if (start >= end) return 0;
if (step >= SQ) {
long long sum = 0;
for (int pos = start; pos < end; pos += step) {
sum += w[pos];
}
return sum;
} else {
vector<block>& v = vb[step];
int pos = start;
long long val = w[pos];
int magic = max(0, (end / step) / steps[step] - 3);
for (int i = magic; i < v.size(); ++i) {
if (v[i].start + start < end) {
pos = v[i].start + start;
val = v[i].v[start];
} else {
break;
}
}
pos += step;
while (pos < end) {
val += w[pos];
pos += step;
}
return val;
}
}
void york::solve() {
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> w[i];
}
build();
int q;
cin >> q;
for (int _q = 0; _q < q; ++_q) {
int a, b;
cin >> a >> b;
a--;
long long ans = cal(b, a % b, n) - cal(b, a % b, a);
cout << ans << endl;
}
}
int main() {
(new york())->solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
set<long long> v;
set<long long>::iterator j;
for (long long i = 1; i <= pow(n, 0.5); i++) {
if (n % i == 0) {
long long x = n / i;
v.insert((x * (2 + (x - 1) * i)) / 2);
v.insert((i * (2 + (i - 1) * x)) / 2);
}
}
for (j = v.begin(); j != v.end(); j++) {
cout << *j << " ";
}
cout << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 1e5 + 5;
int main(int argc, char const *argv[]) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
vector<ll> a(n);
ll mi = INT_MAX;
for (int i = 0; i < n; i++) {
cin >> a[i];
mi = min(mi, a[i]);
}
for (int i = 0; i < n; i++) {
a[i] -= mi;
}
for (int i = 0; i < n; i++) {
a.push_back(a[i]);
}
ll c = 0;
ll mx = 0;
for (int i = 0; i < a.size(); i++) {
if (a[i] == 0) {
mx = max(mx, c);
c = 0;
} else
++c;
}
cout << mi * n + mx;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
string s[20];
vector<pair<int, int> > left1, right1;
int main() {
cin >> n >> m;
int mark = 0, limit = 0;
for (int i = 0; i < n; i++) {
int prev = 0, sum1 = 0, sum2 = 0;
cin >> s[i];
for (int j = 0; j < s[i].size(); j++) {
if (s[i][j] == '1') {
sum1 += abs(prev - j);
prev = j;
}
}
int len = m + 2;
left1.push_back({sum1, abs(prev)});
prev = len - 1;
for (int j = len - 1; j >= 0; j--) {
if (s[i][j] == '1') {
sum2 += abs(prev - j);
prev = j;
}
}
right1.push_back({sum2, abs(prev)});
if (sum1 == 0 && mark == 0)
limit++;
else
mark = 1;
}
int ans = 1e17, lim = pow(2, abs(n));
for (int i = 0; i < lim; i++) {
int temp = 0;
for (int j = n - 1; j >= limit; j--) {
if (i & (1 << j)) {
if (j == n - 1) {
temp += m + 1;
}
temp += right1[j].first;
if (j != limit) {
if (i & (1 << (j - 1)))
temp += abs(m + 1 - right1[j].second);
else
temp += abs(right1[j].second);
}
} else {
temp += left1[j].first;
if (j != limit) {
if (i & (1 << (j - 1)))
temp += abs(m + 1 - left1[j].second);
else
temp += abs(left1[j].second);
}
}
if (j != limit) temp++;
}
ans = min(ans, temp);
}
cout << ans << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0)->sync_with_stdio(0);
cin.exceptions(ios::badbit | ios::failbit);
int n;
cin >> n;
vector<vector<int>> adj(n);
vector<int> init(n, -1), leaves;
vector<string> type(n);
for (auto u = 0; u < n; ++u) {
cin >> type[u];
if (type[u] == "AND" || type[u] == "OR" || type[u] == "XOR") {
int v, w;
cin >> v >> w, --v, --w;
adj[u].push_back(v), adj[u].push_back(w);
} else if (type[u] == "NOT") {
int v;
cin >> v, --v;
adj[u].push_back(v);
} else {
cin >> init[u];
leaves.push_back(u);
}
}
sort(leaves.begin(), leaves.end());
function<void(int)> dfs = [&](int u) {
if (type[u] == "AND" || type[u] == "OR" || type[u] == "XOR") {
for (auto v : adj[u]) {
dfs(v);
}
auto merge = [&](int x, int y) {
return type[u] == "AND" ? x & y : type[u] == "OR" ? x | y : x ^ y;
};
init[u] = merge(init[adj[u][0]], init[adj[u][1]]);
} else if (type[u] == "NOT") {
int v = adj[u][0];
dfs(v);
init[u] = !init[v];
}
};
dfs(0);
42;
vector<array<int, 2>> dp(n, {0, 1});
function<void(int)> solve = [&](int u) {
if (type[u] == "AND" || type[u] == "OR" || type[u] == "XOR") {
auto merge = [&](int x, int y) {
return type[u] == "AND" ? x & y : type[u] == "OR" ? x | y : x ^ y;
};
for (auto v : adj[u]) {
int w = v ^ adj[u][0] ^ adj[u][1];
dp[v] = {dp[u][merge(0, init[w])], dp[u][merge(1, init[w])]};
solve(v);
}
} else if (type[u] == "NOT") {
int v = adj[u][0];
dp[v] = {dp[u][1], dp[u][0]};
solve(v);
}
};
solve(0);
for (auto u : leaves) {
cout << dp[u][!init[u]];
}
cout << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int xx[8] = {1, 1, 1, -1, -1, -1, 0, 0};
int yy[8] = {0, 1, -1, 0, 1, -1, -1, 1};
int main() {
int x, y, z, i, t;
int st1, st, en, en1;
map<pair<int, int>, int> m;
queue<pair<int, int> > q;
while (cin >> st >> en >> st1 >> en1) {
cin >> x;
for (i = 0; i < x; i++) {
cin >> y >> z >> t;
for (int j = z; j <= t; j++) {
m[make_pair(y, j)] = -1;
}
}
m[make_pair(st, en)] = 0;
q.push(make_pair(st, en));
while (!q.empty()) {
int xxx = q.front().first;
int yyy = q.front().second;
q.pop();
for (int j = 0; j < 8; j++) {
int n = xxx + xx[j];
int l = yyy + yy[j];
if (m[make_pair(n, l)] < 0) {
m[make_pair(n, l)] = m[make_pair(xxx, yyy)] + 1;
q.push(make_pair(n, l));
}
}
}
cout << m[make_pair(st1, en1)] << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int n, i, j;
cin >> s;
cin >> n;
if (s.length() < n || s.length() % n != 0)
cout << "NO";
else {
int count = n;
n = s.length() / n;
int start = 0;
int end = n - 1;
bool possible;
while (count--) {
possible = true;
i = start;
j = end;
while (i < j) {
if (s[i] != s[j]) {
possible = false;
break;
}
i++;
j--;
}
if (!possible) break;
start += n;
end += n;
}
if (possible)
cout << "YES";
else
cout << "NO";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
template <class T>
inline void read(T &res) {
char ch;
while (ch = getchar(), !isdigit(ch))
;
res = ch ^ 48;
while (ch = getchar(), isdigit(ch)) res = res * 10 + ch - 48;
}
template <class T>
inline void put(T x) {
if (x > 9) put(x / 10);
putchar(x % 10 + 48);
}
using std::vector;
const int N = 2e5 + 5;
const int M = 450;
const int L = 1 << 14;
int n, K, Q, _sta, ans, apr;
int r[N], b[N], a[N];
struct block {
int bm, m, S;
vector<int> cnt[L], tag, bl, br, blen;
vector<int> bel, pos, sum;
inline void Query(int opt) {
for (int i = 0; i <= bm; ++i) ans += (blen[i] - cnt[tag[i]][i]) * opt;
apr += ((sum[m - 1] ^ tag[bm]) > 0) * opt;
}
inline void Build(int x) {
for (int i = x; i <= n; i += K) pos.push_back(i);
m = pos.size();
sum.resize(m);
bel.resize(m);
S = _sta / 2;
!S ? S = 1 : 0;
bm = (m + S - 1) / S;
for (int i = 0; i < m; ++i) sum[i] = r[pos[i]];
for (int i = 1; i < m; ++i) sum[i] ^= sum[i - 1];
for (int i = 0; i < m; ++i) bel[i] = i / S;
bl.resize(bm);
br.resize(bm);
blen.resize(bm);
tag.resize(bm);
for (int i = 0; i < L; ++i) cnt[i].resize(bm);
bl[bm = 0] = 0;
for (int i = 1; i < m; ++i)
if (bel[i] != bel[i - 1]) br[bm] = i - 1, bl[++bm] = i;
br[bm] = m - 1;
for (int i = 0; i <= bm; ++i) {
blen[i] = br[i] - bl[i] + 1;
for (int j = bl[i]; j <= br[i]; ++j) ++cnt[sum[j]][i];
}
Query(1);
}
inline void Modify(int x, int v) {
int t = bel[x];
if (x == bl[t]) --t;
if (t >= 0) {
for (int i = x; i <= br[t]; ++i) {
--cnt[sum[i]][t];
sum[i] ^= v;
++cnt[sum[i]][t];
}
}
for (int i = t + 1; i <= bm; ++i) tag[i] ^= v;
}
} t[M];
inline void calc(int x, int opt) {
int res = 0;
for (int i = x; i <= n; i += K) {
res ^= r[i];
if (res > 0) ans += opt;
}
if (res > 0) apr += opt;
}
inline void work1() {
for (int i = 1; i <= K; ++i) calc(i, 1);
if (apr > 0)
puts("-1");
else
put(ans), putchar('\n');
char opt;
for (int i = 1, p, v; i <= Q; ++i) {
scanf("%s", &opt);
read(p);
read(v);
calc((p - 1) % K + 1, -1);
if (K != 1) calc(p % K + 1, -1);
int tmp1, tmp2;
tmp1 = a[p] ^ b[p];
(opt == 'a' ? a[p] : b[p]) = v;
tmp2 = a[p] ^ b[p];
r[p] ^= tmp1 ^ tmp2;
r[p + 1] ^= tmp1 ^ tmp2;
calc((p - 1) % K + 1, 1);
if (K != 1) calc(p % K + 1, 1);
if (apr > 0)
puts("-1");
else
put(ans), putchar('\n');
}
}
inline void work2() {
for (int i = 1; i <= K; ++i) t[i].Build(i);
if (apr > 0)
puts("-1");
else
put(ans), putchar('\n');
char opt;
for (int i = 1, p, v; i <= Q; ++i) {
scanf("%s", &opt);
read(p);
read(v);
int p1 = (p - 1) % K + 1, p2 = p % K + 1;
t[p1].Query(-1);
if (K != 1) t[p2].Query(-1);
int tmp = a[p] ^ b[p];
(opt == 'a' ? a[p] : b[p]) = v;
tmp ^= a[p] ^ b[p];
t[p1].Modify((p - 1) / K, tmp);
t[p2].Modify(p / K, tmp);
t[p1].Query(1);
if (K != 1) t[p2].Query(1);
if (apr > 0)
puts("-1");
else
put(ans), putchar('\n');
}
}
int main() {
read(n);
read(K);
read(Q);
for (int i = 1; i <= n; ++i) read(a[i]);
for (int i = 1; i <= n; ++i) read(b[i]);
for (int i = 1; i <= n; ++i) r[i] = a[i] ^ b[i];
for (int i = n; i >= 1; --i) r[i + 1] ^= r[i];
++n;
_sta = sqrt(n);
if (K > (_sta >> 1))
work1();
else
work2();
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int n, u[2005], v[2005], f[2005][11][11][11][11];
int dis(int x, int y) { return abs(x - y); }
int dfs(int i, int cur, int a, int b, int c) {
if (f[i][cur][a][b][c] != -1) return f[i][cur][a][b][c];
int re = 0x3f3f3f3f;
if (i > n) {
if (a == 0 && b == 0 && c == 0) return 0;
if (a) re = min(re, dfs(i, a, 0, b, c) + dis(cur, a) + 1);
if (b) re = min(re, dfs(i, b, a, 0, c) + dis(cur, b) + 1);
if (c) re = min(re, dfs(i, c, a, b, 0) + dis(cur, c) + 1);
return f[i][cur][a][b][c] = re;
}
if (a) re = min(re, dfs(i, a, 0, b, c) + dis(cur, a) + 1);
if (b) re = min(re, dfs(i, b, a, 0, c) + dis(cur, b) + 1);
if (c) re = min(re, dfs(i, c, a, b, 0) + dis(cur, c) + 1);
if (a && b && c) {
re = min(re,
dfs(i + 1, v[i], a, b, c) + dis(cur, u[i]) + dis(u[i], v[i]) + 2);
re = min(re, dfs(i + 1, a, v[i], b, c) + dis(cur, u[i]) + dis(u[i], a) + 2);
re = min(re, dfs(i + 1, b, a, v[i], c) + dis(cur, u[i]) + dis(u[i], b) + 2);
re = min(re, dfs(i + 1, c, a, b, v[i]) + dis(cur, u[i]) + dis(u[i], c) + 2);
} else {
if (!a)
re = min(re, dfs(i + 1, u[i], v[i], b, c) + dis(cur, u[i]) + 1);
else if (!b)
re = min(re, dfs(i + 1, u[i], a, v[i], c) + dis(cur, u[i]) + 1);
else
re = min(re, dfs(i + 1, u[i], a, b, v[i]) + dis(cur, u[i]) + 1);
}
return f[i][cur][a][b][c] = re;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) scanf("%d %d", &u[i], &v[i]);
memset(f, -1, sizeof(f));
cout << dfs(1, 1, 0, 0, 0) << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
long long gi() {
long long x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) f ^= ch == '-', ch = getchar();
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
return f ? x : -x;
}
int pow(int x, int y) {
int ret = 1;
while (y) {
if (y & 1) ret = 1ll * ret * x % 1000000007;
x = 1ll * x * x % 1000000007;
y >>= 1;
}
return ret;
}
int ifact[200010];
int S(int n, int m) {
int ret = 0;
for (int i = 0, M = 1; i <= m; ++i, M = 1000000007 - M)
ret = (ret + 1ll * M * ifact[i] % 1000000007 * ifact[m - i] % 1000000007 *
pow(m - i, n)) %
1000000007;
return ret;
}
int main() {
int n = gi(), k = gi(), W = 0;
for (int i = 1; i <= n; ++i) W = (W + gi()) % 1000000007;
ifact[0] = 1;
for (int i = 1; i <= n; ++i) ifact[i] = 1ll * ifact[i - 1] * i % 1000000007;
ifact[n] = pow(ifact[n], 1000000007 - 2);
for (int i = n; i; --i) ifact[i - 1] = 1ll * ifact[i] * i % 1000000007;
printf("%d\n", 1ll * W *
(S(n, k) + 1ll * (n - 1) * S(n - 1, k) % 1000000007) %
1000000007);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int modo = 1000000000;
int val1[1 << 19], val2[1 << 19];
int tag[1 << 19];
int fib[200005];
int sum_fib[200005];
int a[200005];
void update_ans(int num, int l, int r) {
int mid = (l + r) / 2;
val1[num] = (val1[num * 2 + 1] + (long long)val1[num * 2 + 2] * fib[mid - l] +
(long long)val2[num * 2 + 2] * fib[mid - l + 1]) %
modo;
val2[num] =
(val2[num * 2 + 1] + (long long)val1[num * 2 + 2] * fib[mid - l + 1] +
(long long)val2[num * 2 + 2] * fib[mid - l + 2]) %
modo;
}
void push_down(int num, int l, int r) {
if (tag[num] == 0) return;
int mid = (l + r) / 2;
val1[num * 2 + 1] =
(val1[num * 2 + 1] + (long long)sum_fib[mid - l] * tag[num] + tag[num]) %
modo;
val2[num * 2 + 1] =
(val2[num * 2 + 1] + (long long)sum_fib[mid - l + 1] * tag[num]) % modo;
val1[num * 2 + 2] =
(val1[num * 2 + 2] + (long long)sum_fib[r - mid] * tag[num] + tag[num]) %
modo;
val2[num * 2 + 2] =
(val2[num * 2 + 2] + (long long)sum_fib[r - mid + 1] * tag[num]) % modo;
tag[num] = 0;
}
void build_tree(int num, int l, int r) {
if (l == r - 1) {
val1[num] = a[l];
val2[num] = 0;
return;
}
int mid = (l + r) / 2;
build_tree(num * 2 + 1, l, mid);
build_tree(num * 2 + 2, mid, r);
update_ans(num, l, r);
}
int query(int num, int l, int r, int l0, int r0, int t) {
if ((l0 <= l) && (r <= r0)) {
return ((long long)val1[num] * fib[t] + (long long)val2[num] * fib[t + 1]) %
modo;
}
int sum = 0;
push_down(num, l, r);
int mid = (l + r) / 2;
if (l0 < mid) sum += query(num * 2 + 1, l, mid, l0, r0, t);
if (mid < r0) sum += query(num * 2 + 2, mid, r, l0, r0, t + (mid - l));
return sum % modo;
}
void change1(int num, int l, int r, int loc, int t) {
if (l == r - 1) {
val1[num] = t;
val2[num] = 0;
return;
}
push_down(num, l, r);
int mid = (l + r) / 2;
if (loc < mid)
change1(num * 2 + 1, l, mid, loc, t);
else
change1(num * 2 + 2, mid, r, loc, t);
update_ans(num, l, r);
}
void change2(int num, int l, int r, int l0, int r0, int t) {
if ((l0 <= l) && (r <= r0)) {
val1[num] = (val1[num] + (long long)sum_fib[r - l] * t) % modo;
val2[num] = (val2[num] + (long long)sum_fib[r - l + 1] * t - t) % modo;
tag[num] += t;
return;
}
push_down(num, l, r);
int mid = (l + r) / 2;
if (l0 < mid) change2(num * 2 + 1, l, mid, l0, r0, t);
if (mid < r0) change2(num * 2 + 2, mid, r, l0, r0, t);
update_ans(num, l, r);
}
int main() {
int i;
fib[0] = 1;
fib[1] = 0;
sum_fib[0] = 1;
sum_fib[1] = 1;
for (i = 2; i <= 200002; i++) {
fib[i] = (fib[i - 1] + fib[i - 2]) % modo;
sum_fib[i] = (sum_fib[i - 1] + fib[i]) % modo;
}
int n, m;
scanf("%d%d", &n, &m);
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
build_tree(0, 0, n);
for (i = 0; i < m; i++) {
int oper;
scanf("%d", &oper);
if (oper == 1) {
int loc, val;
scanf("%d%d", &loc, &val);
loc--;
change1(0, 0, n, loc, val);
} else if (oper == 2) {
int l, r;
scanf("%d%d", &l, &r);
l--;
printf("%d\n", query(0, 0, n, l, r, 2 - l));
} else {
int l, r, x;
scanf("%d%d%d", &l, &r, &x);
l--;
change2(0, 0, n, l, r, x);
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int mat[100][100];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> mat[i][j];
}
}
int row[100] = {0}, col[100] = {0}, ans = 0;
if (m < n) {
for (int i = 0; i < m; i++) {
int cmin = INT_MAX;
for (int j = 0; j < n; j++) {
cmin = min(cmin, mat[j][i]);
}
col[i] = cmin;
ans += cmin;
for (int j = 0; j < n; j++) {
mat[j][i] -= cmin;
}
}
for (int i = 0; i < n; i++) {
int rmin = INT_MAX;
for (int j = 0; j < m; j++) {
rmin = min(rmin, mat[i][j]);
}
row[i] = rmin;
ans += rmin;
for (int j = 0; j < m; j++) {
mat[i][j] -= rmin;
}
}
} else {
for (int i = 0; i < n; i++) {
int rmin = INT_MAX;
for (int j = 0; j < m; j++) {
rmin = min(rmin, mat[i][j]);
}
row[i] = rmin;
ans += rmin;
for (int j = 0; j < m; j++) {
mat[i][j] -= rmin;
}
}
for (int i = 0; i < m; i++) {
int cmin = INT_MAX;
for (int j = 0; j < n; j++) {
cmin = min(cmin, mat[j][i]);
}
col[i] = cmin;
ans += cmin;
for (int j = 0; j < n; j++) {
mat[j][i] -= cmin;
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (mat[i][j] != 0) {
cout << "-1" << endl;
return 0;
}
}
}
cout << ans << endl;
for (int i = 0; i < n; i++) {
for (int j = 0; j < row[i]; j++) {
cout << "row " << i + 1 << endl;
}
}
for (int i = 0; i < m; i++) {
for (int j = 0; j < col[i]; j++) {
cout << "col " << i + 1 << endl;
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, x;
vector<int> a;
void next(int n, int x, vector<int> a) {
int less = 0;
int more = 0;
int steps = 1;
for (int i = 0; i < n; i++) a[i]<x ? less++ : a[i]> x ? more++ : steps = 0;
if (less + more < n - 1)
for (int i = n - less - more - 1; i > 0; i--) more > less ? less++ : more++;
steps += more > less ? more - less - 1 : less - more;
cout << steps << endl;
}
int main() {
cin >> n >> x;
a.resize(n);
for (int i = 0; i < n; i++) cin >> a[i];
next(n, x, a);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
typedef signed long long ll;
#define _P(...) (void)printf(__VA_ARGS__)
#define FOR(x,to) for(x=0;x<(to);x++)
#define FORR(x,arr) for(auto& x:arr)
#define FORR2(x,y,arr) for(auto& [x,y]:arr)
#define ALL(a) (a.begin()),(a.end())
#define ZERO(a) memset(a,0,sizeof(a))
#define MINUS(a) memset(a,0xff,sizeof(a))
template<class T> bool chmax(T &a, const T &b) { if(a<b){a=b;return 1;}return 0;}
template<class T> bool chmin(T &a, const T &b) { if(a>b){a=b;return 1;}return 0;}
//-------------------------------------------------------
int N,X;
ll S[55];
const ll mo=998244353;
const int MAT=55;
struct Mat { ll v[MAT][MAT]; Mat(){ZERO(v);};};
Mat mulmat(Mat& a,Mat& b,int n=MAT) {
ll mo2=4*mo*mo;
int x,y,z; Mat r;
FOR(x,n) FOR(y,n) r.v[x][y]=0;
FOR(x,n) FOR(z,n) FOR(y,n) {
r.v[x][y] += a.v[x][z]*b.v[z][y];
if(r.v[x][y]>mo2) r.v[x][y] -= mo2;
}
FOR(x,n) FOR(y,n) r.v[x][y]%=mo;
return r;
}
Mat powmat(ll p,Mat a,int n=MAT) {
int i,x,y; Mat r;
FOR(x,n) FOR(y,n) r.v[x][y]=0;
FOR(i,n) r.v[i][i]=1;
while(p) {
if(p%2) r=mulmat(r,a,n);
a=mulmat(a,a,n);
p>>=1;
}
return r;
}
void solve() {
int i,j,k,l,r,x,y; string s;
cin>>N>>X;
int pre=0;
FOR(i,N) {
cin>>x;
if(x==0) {
i--,N--;
continue;
}
if(pre==0) {
S[i+1]=S[i]+x;
pre=x;
}
else if((x>0)==(pre>0)) {
S[i]+=x;
i--,N--;
}
else {
S[i+1]=S[i]+x;
pre=x;
}
}
S[N+1]=S[N];
ll ma=0,mi=0,d=0;
vector<ll> V;
FOR(i,N+1) {
V.push_back(S[i]);
V.push_back(S[i]-1);
V.push_back(S[i]+1);
ma=max(ma,S[i]);
mi=min(mi,S[i]);
d=max(d,S[i]-mi);
}
if(d==0) {
cout<<1<<" "<<(-S[N]+1)%mo<<endl;
return;
}
sort(ALL(V));
V.erase(unique(ALL(V)),V.end());
Mat A;
FOR(y,N+1) FOR(x,y) if(S[y]-S[x]==d) A.v[x][x]=1;
/*
FOR(y,N+1) {
FOR(x,N+1) cout<<A.v[y][x]<<" ";
cout<<endl;
}
FOR(y,N+1) cout<<S[y]<<" ";
cout<<endl;
*/
FOR(i,V.size()-1) {
ll a=V[i];
ll b=V[i+1];
{
Mat B;
mi=0;
FOR(j,N+1) {
mi=min(mi,S[j]);
if(mi==S[j]&&b<=mi) B.v[j][j]=1;
if(S[j]<S[j+1]&&S[j]<=a&&b<S[j+1]) B.v[j][j]=1;
if((S[j]<=a&&a<=S[j+1])||(S[j]>=a&&S[j+1]<=a)) {
for(k=j+1;k<N;k++) {
if((S[k]<=b&&b<S[k+1])||(S[k]>=b&&S[k+1]<b)) {
B.v[k][j]=1;
}
}
if(b==S[N]) B.v[N][j]=1;
}
}
ma=-1LL<<60;
for(j=N;j>=0;j--) {
ma=max(ma,S[j]);
if(S[j]==ma&&a>=S[j]) B.v[j][j]=1;
}/*
cout<<"B"<<a<<" "<<b<<endl;
FOR(y,N+1) {
FOR(x,N+1) cout<<B.v[y][x]<<" ";
cout<<endl;
}
*/
B=powmat(b-a,B,N+1);
A=mulmat(B,A,N+1);
}
/*
FOR(y,N+1) {
FOR(x,N+1) cout<<A.v[y][x]<<" ";
cout<<endl;
}
*/
}
ll ret=0;
FOR(y,N+1) FOR(x,y) if(S[y]-S[x]==d) ret+=A.v[y][x];
cout<<(d+1)<<" "<<ret%mo<<endl;
}
int main(int argc,char** argv){
string s;int i;
if(argc==1) ios::sync_with_stdio(false), cin.tie(0);
FOR(i,argc-1) s+=argv[i+1],s+='\n'; FOR(i,s.size()) ungetc(s[s.size()-1-i],stdin);
cout.tie(0); solve(); return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const int INF = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
const double EPS = 1e-9;
int n, a[100015];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
long long ans = 0;
for (int i = 1; i <= n; ++i) {
long long x = a[i], y = a[i + 1];
if (x == y) continue;
if (x < y)
ans += x * (y - x);
else
ans += (n - x + 1) * (x - y);
}
printf("%lld\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long M = 1000000;
long long n, ok[100005], res = 0, p[100005], t = 0;
string s;
void solve() {
cin >> s;
if (s == "for") {
cin >> n;
t++;
if (ok[t - 1]) {
ok[t] = 1;
return;
} else
ok[t] = 0;
p[t] = p[t - 1] * n;
if (p[t] >= (long long)((long long)1 << (long long)32))
ok[t] = 1;
else
ok[t] = 0;
return;
}
if (s == "end") {
t--;
} else {
res += p[t];
if (ok[t] || res >= (long long)((long long)1 << (long long)32)) {
cout << "OVERFLOW!!!";
exit(0);
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long T = 1;
p[0] = 1;
cin >> T;
for (int i = 1; i <= T; i++) {
solve();
}
cout << res;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
int N = 512;
vector<int> dp(N);
dp[0] = 0;
for (int i = 1; i < N; ++i) {
set<int> s = {0, 1, 2};
s.erase(dp[i - 1]);
if (i % 2 == 0) s.erase(dp[i / 2]);
dp[i] = *s.begin();
}
vector<int> wtf = {4, 12, 0, 4, 12, 0, 4, 12, 4, 12, 0};
int n, k;
cin >> n >> k;
int x = 0;
for (int i = 0, y; i < n; ++i) {
cin >> y;
if (k & 1) {
if (y < 244)
x ^= dp[y];
else {
if (y % 2 == 1) continue;
if (y % 16 == wtf[(y - 244) % wtf.size()])
x ^= 2;
else
x ^= 1;
}
} else {
if (y <= 2)
x ^= y;
else
x ^= y == 1 || y % 2 == 0;
}
}
if (x)
cout << "Kevin\n";
else
cout << "Nicky\n";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cout << name << " : " << arg1 << "\n";
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cout.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
int mpow(int base, int exp);
void ipgraph(int n, int m);
void dfs(int u, int par);
const int N = 5000, M = 100005;
vector<long long> g[N];
int a[N];
void solve() {
long long i, j, n, m, k, a, b, c;
cin >> n >> k;
vector<long long> arr(n);
for (i = 0; i < n; ++i) cin >> arr[i];
vector<long long> window(n);
i = 0, m = 0;
for (i = 0; i < k; ++i) m += arr[i];
j = k;
i = 1;
window[0] = m;
while (j < n) {
m -= arr[i - 1];
m += arr[j];
window[i] = m;
i++, j++;
}
long long m1 = -1, m2 = -1, temp, ans1, ans2;
for (i = n - 2 * k; i >= 0; i--) {
long long s1 = window[i + k];
if (s1 >= m1) {
temp = i + k;
m1 = s1;
}
long long s2 = window[i] + m1;
if (s2 >= m2) {
ans1 = i, ans2 = temp;
m2 = s2;
}
}
cout << ans1 + 1 << " " << ans2 + 1;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
{ solve(); }
}
int mpow(int base, int exp) {
base %= ((int)1e9 + 7);
int result = 1;
while (exp > 0) {
if (exp & 1) result = ((long long)result * base) % ((int)1e9 + 7);
base = ((long long)base * base) % ((int)1e9 + 7);
exp >>= 1;
}
return result;
}
void ipgraph(int n, int m) {
int i, u, v;
while (m--) {
cin >> u >> v;
u--, v--;
g[u].push_back(v);
g[v].push_back(u);
}
}
void dfs(int u, int par) {
for (int v : g[u]) {
if (v == par) continue;
dfs(v, u);
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long a1, b1, c1, a2, b2, c2;
int main() {
long long n, t, m;
scanf("%lld%lld%lld", &n, &t, &m);
scanf("%lld%lld%lld", &a1, &b1, &c1);
scanf("%lld%lld%lld", &a2, &b2, &c2);
if (m <= t / n) {
printf("0\n");
return 0;
}
if (b1 > t / n && b2 > t / n) {
printf("-1\n");
return 0;
}
if (b1 < m && b2 < m) {
if (b1 > b2) {
long long tmp = a1;
a1 = a2;
a2 = tmp;
tmp = b1;
b1 = b2;
b2 = tmp;
tmp = c1;
c1 = c2;
c2 = tmp;
}
long long a_limit = (n + a1 - 1) / a1;
long long ans = a_limit * c1;
long long money;
long long nn = n, tt = t;
for (long long i = 0; i <= nn; i++) {
money = (i + a1 - 1) / a1;
money *= c1;
if (n == 0 || m <= t / n) {
ans = min(ans, money);
break;
}
if (b2 <= t / n) {
long long cal1 = m;
cal1 *= n;
cal1 -= t;
long long cal2 = m;
cal2 -= b2;
long long target = (cal1 + cal2 - 1) / cal2;
long long gae = (target + a2 - 1);
gae /= a2;
long long cost = gae;
cost *= c2;
ans = min(ans, money + cost);
}
n -= 1;
t -= b1;
}
printf("%lld\n", ans);
} else if (b1 < m) {
long long cal1 = m;
cal1 *= n;
cal1 -= t;
long long cal2 = m;
cal2 -= b1;
long long target = (cal1 + cal2 - 1) / cal2;
long long gae = (target + a1 - 1);
gae /= a1;
long long money = gae;
money *= c1;
printf("%lld\n", money);
} else if (b2 < m) {
long long cal1 = m;
cal1 *= n;
cal1 -= t;
long long cal2 = m;
cal2 -= b2;
long long target = (cal1 + cal2 - 1) / cal2;
long long gae = (target + a2 - 1);
gae /= a2;
long long money = gae;
money *= c2;
printf("%lld\n", money);
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[2000000];
string s, t;
int cheak(int mid) {
string v = s;
for (int i = 0; i < mid + 1; i++) v[a[i] - 1] = '-';
string h = "";
for (int i = 0; i < n; i++)
if (v[i] != '-') h += v[i];
string as = "";
int idx = 0;
for (int i = 0; i < h.length(); i++) {
if (h[i] == t[idx]) {
if (idx == t.length() - 1) return true;
idx++;
}
}
return false;
}
int main(void) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
cin >> s >> t;
n = s.length();
for (int i = 0; i < n; i++) cin >> a[i];
int l = 0, r = n - 1;
int mid;
while (l <= r) {
mid = (l + r) / 2;
if (cheak(mid)) {
l = mid + 1;
} else {
r = mid - 1;
}
}
cout << l << "\n";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const int N = 100005;
const double PI = 4 * atan(1);
set<char> vowel = {'A', 'O', 'Y', 'E', 'U', 'I', 'a', 'o', 'y', 'e', 'u', 'i'};
int dx[] = {1, -1, 0, 0, 1, -1, 1, -1};
int dy[] = {0, 0, 1, -1, 1, 1, -1, -1};
long long gcd(long long a, long long b) { return (b == 0 ? a : gcd(b, a % b)); }
long long lcm(long long a, long long b) { return a * (b / gcd(a, b)); }
bool issquare(long long w) { return trunc(sqrt(w)) * trunc(sqrt(w)) == w; }
bool isprime(long long u) {
for (long long i = 2; i <= (int)sqrt(u); i++) {
if (u % i == 0) return 0;
}
return 1;
}
long long mod(long long to_mod) {
to_mod %= MOD;
while (to_mod < 0) to_mod += MOD;
return to_mod % MOD;
}
long long power(long long x, long long y) {
long long res = 1;
x = x;
while (y > 0) {
if (y & 1) res = (res * x);
y = y >> 1;
x = (x * x);
}
return res;
}
long long n, m, k, a, l, r, b, t, ans = 0, res = 0, x, y, z, dfsroot, xmax,
xmin;
vector<long long> vv, v;
vector<pair<string, long long> > troll;
double db;
vector<pair<long long, long long> > vvv;
priority_queue<pair<long long, long long> > pq;
map<long long, vector<long long> > adj;
char c;
bool vis[105];
map<string, long long> points;
map<long long, long long> maa;
string ch, ch1, ch2;
long long dist[105][105];
unordered_set<string> ss;
void add(long long v1, long long v2) {
v1--;
v2--;
adj[v1].push_back(v2);
adj[v2].push_back(v1);
}
void dfs(long long src, long long a) {
if (vis[src]) return;
vis[src] = 1;
if (v[src] == dfsroot) ans = a;
if (vis[v[src]]) return;
dfs(v[src], a + 1);
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x;
x--;
v.push_back(x);
}
res = 1;
for (long long i = 0; i < n; i++) {
memset(vis, 0, sizeof(vis));
ans = 1e9;
dfsroot = i;
dist[i][i] = 0;
dfs(i, 1);
if (ans >= 1e9) {
cout << -1;
return 0;
}
if (ans % 2 == 0)
res = lcm(res, ans / 2);
else
res = lcm(res, ans);
}
cout << res;
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma loop - opt(on)
using namespace std;
long long int t, n;
vector<long long int> ans, a, vis, par;
vector<vector<long long int>> mp;
long long int dfs(long long int x) {
long long int ans = -1;
for (auto i : mp[x]) {
if (vis[i]) continue;
if (i == x || par[i] != -1)
par[i] = x, ans = x;
else
par[i] = x, ans = dfs(i);
if (ans != -1) return ans;
}
vis[x] = 1, par[x] = -1;
return ans;
}
void solve() {
vis.assign(n, 0), par.assign(n, -1);
mp.assign(n, vector<long long int>(0)), ans.clear();
for (long long int i = 0; i <= n - 1; i++) {
mp[i].push_back(i - a[i]);
}
long long int aa = -1, bb;
for (long long int i = 0; i <= n - 1; i++) {
if (!vis[i]) aa = dfs(i);
if (aa != -1) break;
}
bb = aa;
ans.push_back(aa);
while (par[aa] != bb) {
aa = par[aa], ans.push_back(aa);
}
return;
}
signed main() {
ios::sync_with_stdio(false), cin.tie(0);
cin >> t;
while (t--) {
cin >> n, a.resize(n);
for (long long int i = 0; i <= n - 1; i++) cin >> a[i];
solve();
cout << ans.size() << "\n";
for (long long int i = 0; i <= ans.size() - 1; i++) {
cout << ans[i] + 1 << (i == ans.size() - 1 ? "\n" : " ");
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int seq[4096];
int table[4096];
int main() {
int N;
scanf("%d", &N);
int r = 0;
for (int i = 0; i < N; i++) {
scanf("%d", seq + i);
for (int j = 0; j < i; j++) r += seq[j] > seq[i];
}
printf("%d\n", (r / 2) * 4 + (r & 1));
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
inline long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
inline long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
int month[15] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int dir[8][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1},
{-1, -1}, {1, 1}, {1, -1}, {-1, 1}};
const int MAXN = 3e5 + 5;
const int INF = 1 << 30;
const long long mod = 1e9 + 7;
const double eps = 1e-8;
const long long inff = 0x3f3f3f3f3f3f3f3f;
int n, m, ans = mod, s[3];
char c, d[5] = {'A', 'G', 'C', 'T'};
vector<char> q[MAXN];
void solve(char s1, char s2, int t) {
char s3 = ' ', s4;
for (int i = 0; i <= 3; i++) {
if (d[i] != s1 && d[i] != s2 && s3 == ' ') s3 = d[i];
if (d[i] != s1 && d[i] != s2 && s3 != ' ') s4 = d[i];
}
int sum = 0;
if (t == 1) {
for (int i = 0; i <= n - 1; i++) {
int cn[3] = {0, 0};
char cc[3];
if (i % 2)
cc[0] = s1, cc[1] = s2;
else
cc[0] = s3, cc[1] = s4;
for (int j = 0; j <= m - 1; j++) {
int k = j % 2, kk = !k;
if (q[i][j] != cc[k]) cn[0]++;
if (q[i][j] != cc[kk]) cn[1]++;
}
sum += min(cn[0], cn[1]);
}
}
if (t == 2) {
for (int i = 0; i <= m - 1; i++) {
int cn[3] = {0, 0};
char cc[3];
if (i % 2)
cc[0] = s1, cc[1] = s2;
else
cc[0] = s3, cc[1] = s4;
for (int j = 0; j <= n - 1; j++) {
int k = j % 2, kk = !k;
if (q[j][i] != cc[k]) cn[0]++;
if (q[j][i] != cc[kk]) cn[1]++;
}
sum += min(cn[0], cn[1]);
}
}
if (t != 0) {
if (sum < ans) ans = sum, s[0] = s1, s[1] = s2, s[2] = t;
} else {
t = s[2];
if (t == 1) {
for (int i = 0; i <= n - 1; i++) {
int cn[3] = {0, 0};
char cc[3];
if (i % 2)
cc[0] = s1, cc[1] = s2;
else
cc[0] = s3, cc[1] = s4;
for (int j = 0; j <= m - 1; j++) {
int k = j % 2, kk = !k;
if (q[i][j] != cc[k]) cn[0]++;
if (q[i][j] != cc[kk]) cn[1]++;
}
if (cn[0] < cn[1]) {
for (int j = 0; j <= m - 1; j++) {
int k = j % 2;
q[i][j] = cc[k];
}
} else {
for (int j = 0; j <= m - 1; j++) {
int k = !(j % 2);
q[i][j] = cc[k];
}
}
}
}
if (t == 2) {
for (int i = 0; i <= m - 1; i++) {
int cn[3] = {0, 0};
char cc[3];
if (i % 2)
cc[0] = s1, cc[1] = s2;
else
cc[0] = s3, cc[1] = s4;
for (int j = 0; j <= n - 1; j++) {
int k = j % 2, kk = !k;
if (q[j][i] != cc[k]) cn[0]++;
if (q[j][i] != cc[kk]) cn[1]++;
}
if (cn[0] < cn[1]) {
for (int j = 0; j <= n - 1; j++) {
int k = j % 2;
q[j][i] = cc[k];
}
} else {
for (int j = 0; j <= n - 1; j++) {
int k = !(j % 2);
q[j][i] = cc[k];
}
}
}
}
for (int i = 0; i <= n - 1; i++) {
for (int j = 0; j <= m - 1; j++) printf("%c", q[i][j]);
printf("\n");
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i <= n - 1; i++) {
getchar();
for (int j = 1; j <= m; j++) {
scanf("%c", &c);
q[i].push_back(c);
}
}
for (int i = 0; i <= 2; i++)
for (int j = i + 1; j <= 3; j++) solve(d[i], d[j], 1);
for (int i = 0; i <= 2; i++)
for (int j = i + 1; j <= 3; j++) solve(d[i], d[j], 2);
solve(s[0], s[1], 0);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
bool vis[1000010];
int p[1000010];
vector<int> g[1000010];
vector<int> col[1000010];
vector<int> num[1000010];
int ans[1000010];
void dfs(int v, int k) {
col[k].push_back(v);
num[k].push_back(p[v]);
vis[v] = 1;
for (int to : g[v])
if (!vis[to]) dfs(to, k);
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < (n); i++) scanf("%d", &p[i]);
for (int i = 0; i < (m); i++) {
int a, b;
scanf("%d %d", &a, &b);
--a;
--b;
g[a].push_back(b);
g[b].push_back(a);
}
int now = 0;
for (int i = 0; i < (n); i++)
if (!vis[i]) {
dfs(i, now++);
}
for (int i = 0; i < (now); i++) {
sort((col[i]).begin(), (col[i]).end());
sort((num[i]).begin(), (num[i]).end());
reverse((num[i]).begin(), (num[i]).end());
for (int j = 0; j < (num[i].size()); j++) {
ans[col[i][j]] = num[i][j];
}
}
for (int i = 0; i < (n); i++) printf("%d%c", ans[i], i == n - 1 ? '\n' : ' ');
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long MAX = 1e18;
int n;
vector<int> primes;
vector<long long> f(int start) {
vector<long long> nums(1, 1);
for (int i = start; i < n; i += 2) {
auto next = nums;
auto p = primes[i];
for (auto q : nums) {
while (q <= MAX / p) {
q *= p;
next.push_back(q);
}
}
nums = next;
}
sort(nums.begin(), nums.end());
return nums;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
primes.resize(n);
for (int i = 0; i < n; i++) {
cin >> primes[i];
}
long long k;
cin >> k;
if (n == 1) {
auto num = 1LL;
for (int i = 1; i < k; i++) {
num *= primes[0];
}
cout << num << '\n';
return 0;
}
auto left = f(0);
auto right = f(1);
auto count = [&](long long cur) {
int j = right.size();
long long cnt = 0;
for (int i = 0; i < (int)left.size(); i++) {
while (j > 0 && left[i] > cur / right[j - 1]) {
j--;
}
cnt += j;
}
return cnt;
};
long long L = 0LL;
long long R = 1e18 + 1;
while (L + 1 < R) {
long long M = (L + R) / 2;
auto x = count(M);
if (x < k)
L = M;
else
R = M;
}
cout << R << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int smallestDivisor(int n) {
if (n % 2 == 0) return 2;
for (int i = 3; i * i <= n; i += 2) {
if (n % i == 0) return i;
}
return n;
}
int main() {
int n;
cin >> n;
int suma = n;
while (true) {
n = n / smallestDivisor(n);
suma += n;
if (n == 1) {
false;
break;
}
}
cout << suma;
}
| 1 |
#include <bits/stdc++.h>
template <class T>
bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
using namespace std;
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<long long> a(n), b(n);
for (int i = 0; i < (int)(n); i++) cin >> a[i] >> b[i];
long long ans = 0;
for (int i = 0; i < (int)(n); i++) {
int j = (i + 1) % n;
if (b[i] < a[j]) {
ans += a[j] - b[i];
a[j] = b[i];
}
}
sort((a.begin()), (a.end()));
ans += a[0];
cout << ans << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int _ = 1, tc = 1;
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
const int MAXN = 1e7 + 1;
int spf[MAXN];
int d, x, y;
void sieve() {
for (int i = 1; i < MAXN; i++) spf[i] = i;
for (int i = 4; i < MAXN; i += 2) spf[i] = 2;
for (int i = 3; i * i < MAXN; i += 2) {
if (spf[i] == i) {
for (int j = i * i; j < MAXN; j += i) {
if (spf[j] == j) spf[j] = i;
}
}
}
}
void extended_gcd(int a, int b) {
if (b == 0) {
d = a;
x = 1;
y = 0;
} else {
extended_gcd(b, a % b);
int temp = y;
y = x - y * (a / b);
x = temp;
}
}
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
int lcm(int a, int b) { return a * (b / gcd(a, b)); }
int getmod(int x, int y, int mod) { return (((x - y) % mod) + mod) % mod; }
vector<string> split(string line, char dil) {
vector<string> tokens;
stringstream check1(line);
string intermediate;
while (getline(check1, intermediate, dil)) {
tokens.push_back(intermediate);
}
return tokens;
}
void read(vector<long long>& v) {
for (int i = 0; i < v.size(); i++) cin >> v[i];
}
void solve() {
int n, q;
cin >> n;
vector<long long> v(n);
read(v);
vector<long long> diff(n - 1);
long long toright = 0, toleft = 0;
for (int i = 1; i < n; i++) {
diff[i - 1] = v[i] - v[i - 1];
if (diff[i - 1] > 0) {
toright += diff[i - 1];
} else {
toleft -= diff[i - 1];
}
}
cout << v[0] + ((toright - v[0]) / 2 + ((toright - v[0]) % 2)) << endl;
cin >> q;
while (q--) {
long long r, l, x;
cin >> l >> r >> x;
if (l == 1 && r == n) {
v[0] += x;
if (l != r) v[n - 1] += x;
} else if (l == 1) {
v[0] += x;
if (diff[r - 1] > 0) {
toright -= diff[r - 1];
} else {
toleft += diff[r - 1];
}
diff[r - 1] -= x;
if (diff[r - 1] > 0) {
toright += diff[r - 1];
} else {
toleft -= diff[r - 1];
}
} else if (r == n) {
v[n - 1] += x;
if (diff[l - 2] > 0) {
toright -= diff[l - 2];
} else {
toleft += diff[l - 2];
}
diff[l - 2] += x;
if (diff[l - 2] > 0) {
toright += diff[l - 2];
} else {
toleft -= diff[l - 2];
}
} else {
if (diff[l - 2] > 0) {
toright -= diff[l - 2];
} else {
toleft += diff[l - 2];
}
diff[l - 2] += x;
if (diff[l - 2] > 0) {
toright += diff[l - 2];
} else {
toleft -= diff[l - 2];
}
if (diff[r - 1] > 0) {
toright -= diff[r - 1];
} else {
toleft += diff[r - 1];
}
diff[r - 1] -= x;
if (diff[r - 1] > 0) {
toright += diff[r - 1];
} else {
toleft -= diff[r - 1];
}
}
long long opt1 = v[0] + ((toright - v[0]) / 2 + (getmod(toright, v[0], 2)));
long long opt2 =
v[n - 1] + ((toleft - v[n - 1]) / 2 + (getmod(toleft, v[n - 1], 2)));
cout << min(opt1, opt2) << endl;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
while (_--) {
solve();
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long b, c, r, n, mi = 0, ma = 0, h, m, k, A[1000], s = 0, tt;
cin >> tt;
while (tt--) {
cin >> r >> c;
cout << r + c << '\n';
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, p;
cin >> n >> p;
vector<int> a(n);
long long s = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
vector<long long> b(n + 1, 0);
for (int i = 1; i <= n; i++) {
b[i] = b[i - 1] + a[i - 1];
}
for (int i = 1; i <= n; i++) {
s = max(b[i] % p + (b[n] - b[i]) % p, s);
}
cout << s;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)1e5 + 5;
int n, m, p, d, q;
char s[N];
int ans[10], t[N * 40][10];
vector<int> occ[N];
void add(int i, int x) {
occ[i].push_back(++m);
for (int j = 0; j < 10; j++) t[m][j] = t[m - 1][j] + (j == x);
}
int get(vector<int> &a, int x) {
vector<int>::iterator it = lower_bound(a.begin(), a.end(), x);
if (it == a.end()) return m + 1;
return *it;
}
int main() {
scanf("%d%d", &n, &q);
scanf("%s", s + 1);
int far = 0;
while (far < n) {
int bnd = far;
p = far + 1;
d = 1;
int last = 0;
for (; p > bnd && p <= n; p += d) {
if (p > far) far = p;
add(p, s[p] - '0');
if (!s[p]) continue;
if (s[p] >= '0' && s[p] <= '9') {
if (s[p] == '0')
s[p] = 0;
else
s[p]--;
} else {
if (s[last] == '<' || s[last] == '>') s[last] = 0;
if (s[p] == '<')
d = -1;
else
d = 1;
}
last = p;
}
add(p, -1);
}
while (q--) {
int l, r;
scanf("%d%d", &l, &r);
int x = get(occ[l], 0), y = min(get(occ[l - 1], x), get(occ[r + 1], x));
x--, y--;
for (int j = 0; j < 10; j++) printf("%d ", t[y][j] - t[x][j]);
puts("");
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e3 + 5;
int a[N];
int main() {
int n, m, inf = 1e8;
cin >> n >> m;
int sum = 0;
for (int i = 0; i < n; i++) sum += i / 2;
if (sum < m) return cout << -1, 0;
for (int i = 0; i < n; i++) {
if (m >= i / 2)
cout << i + 1 << " ", m -= i / 2;
else if (m > 0) {
int res = i + 1, t = i;
while (t / 2 > m) t--, res++;
cout << res << " ", m = 0;
} else
cout << inf << " ", inf += 2 * N;
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, i, j, k, s, a[50], b[50], c[50];
long long x;
int main() {
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%I64d", &x);
for (j = 0; (1ll << j) < x; j++)
;
if ((1ll << j) == x)
a[j]++;
else
b[j - 1]++;
}
for (i = a[0]; i > 0; i--) {
k = i;
s = 0;
for (j = 0; j <= 40; j++) {
k = min(k, a[j]);
c[j] = k;
}
for (j = 40; j >= 0; j--) {
s += b[j] + a[j] - c[j];
if (s > c[j]) break;
}
if (j >= 0) break;
}
if (i == a[0])
cout << "-1";
else
for (i++; i <= a[0]; i++) cout << i << " ";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long mod = 1000000007;
int t;
cin >> t;
while (t--) {
vector<long long> v(6, 0);
long long sum;
for (long long i = 0; i < 7; i++) {
if (i < 6)
cin >> v[i];
else
cin >> sum;
}
long long a, b, c;
long long l, r;
int flag = 0;
for (long long i = 0; i < v.size() - 2; i++) {
l = i + 1;
r = v.size() - 1;
while (l < r) {
if (v[i] + v[l] + v[r] == sum) {
a = v[i];
b = v[l];
c = v[r];
flag = 1;
} else if (v[i] + v[l] + v[r] < sum)
l++;
else
r--;
if (flag == 1) break;
}
if (flag == 1) break;
}
cout << a << " " << b << " " << c << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 1000;
long long v, d, ans;
int n, nxt[N];
struct node {
long long x, p, id;
bool operator<(const node &o) const { return x < o.x; }
} a[N];
stack<node> s;
int main() {
cin >> d >> v >> n;
for (int i = 1; i <= n; i++) scanf("%lld%lld", &a[i].x, &a[i].p);
a[0].p = 1e6 + 1;
a[n + 1].x = d;
sort(a, a + n + 2);
for (int i = 0; i <= n; i++)
if (a[i + 1].x - a[i].x > v) {
cout << -1;
return 0;
}
s.push(node{d, 0, n + 1});
for (int i = n; i >= 1; i--) {
node t = node{0, 0, 0};
while (t = s.top(), t.x - a[i].x > v || t.p > a[i].p) {
s.pop();
if (s.empty()) {
t.id = 0;
break;
}
}
nxt[i] = t.id;
s.push(node{a[i].x, a[i].p, i});
}
int i = 0;
long long now = v;
while (i <= n) {
if (!nxt[i]) {
ans += a[i].p * (v - now);
now = v - (a[i + 1].x - a[i].x);
i++;
} else {
long long dis = a[nxt[i]].x - a[i].x;
if (dis < now)
now -= dis;
else {
ans += a[i].p * (dis - now);
now = 0;
}
i = nxt[i];
}
}
cout << ans;
}
| 7 |
#include <bits/stdc++.h>
std::mt19937_64 rng(
std::chrono::steady_clock::now().time_since_epoch().count());
long long int myRand(long long int R) {
long long int val = rng() % R;
assert(val >= 0);
return val;
}
using namespace std;
const long double PI = atan(1.0) * 4;
const int64_t INF = 3e18;
const int32_t LOG = 21;
const long long int MOD = 1e9 + 7;
long long int zeros[100005];
long long int ans[100005];
long long int ask(long long int i, long long int j) {
i++;
j++;
assert(i != j);
cout << "? " << i << " " << j << '\n';
long long int resp;
cin >> resp;
return resp;
}
long long int query(long long int ind, long long int n) {
long long int ans = (1 << 12) - 1;
for (long long int i = 0; i < 12; i++) {
if (zeros[i] == ind) {
if (ans & (1 << i)) ans ^= (1 << i);
continue;
}
if (ans == -1)
ans = ask(ind, zeros[i]);
else
ans &= ask(ind, zeros[i]);
}
return ans;
}
int32_t main() {
long long int tests = 1;
for (long long int ii = 0; ii < tests; ii++) {
long long int n;
cin >> n;
fill(zeros, zeros + 13, -1);
long long int marked = 0;
while (marked != 12) {
long long int x = myRand(n), y = myRand(n);
while (x == y) {
x = myRand(n);
y = myRand(n);
}
long long int resp = ask(x, y);
for (long long int i = 0; i < 12; i++) {
if (!((1 << i) & resp)) {
if (zeros[i] == -1) {
zeros[i] = x;
marked++;
}
}
}
}
long long int ind = 0;
long long int val = query(ind, n);
for (long long int i = 1; i < n; i++) {
if (val == 0) break;
long long int resp = ask(ind, i);
if (resp == val) {
ind = i;
val = query(ind, n);
}
}
ans[ind] = 0;
for (long long int i = 0; i < n; i++) {
if (i != ind) {
ans[i] = ask(i, ind);
}
}
cout << "!";
for (long long int i = 0; i < n; i++) cout << " " << ans[i];
cout << '\n';
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
int n, m, a, b;
while (t--) {
cin >> n >> m >> a >> b;
int onesn = n * a;
int onesm = m * b;
if (onesn != onesm)
cout << "NO"
<< "\n";
else {
cout << "YES"
<< "\n";
char matrix[n][m];
int cnt, pos = 0, pos2 = 0;
for (int i = 0; i < n; i++) {
cnt = a;
for (int j = 0; j < m; j++) {
if (cnt > 0 && j == pos) {
matrix[i][j] = '1';
cnt--;
pos++;
if (pos == m) {
pos = 0;
while (cnt) {
matrix[i][pos] = '1';
cnt--;
pos++;
}
}
} else
matrix[i][j] = '0';
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cout << matrix[i][j];
}
cout << "\n";
}
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, q, ans = 0, i;
char tmp;
cin >> n >> q;
vector<char> v(n + 2);
for (i = 1; i <= n; ++i) {
cin >> v[i];
if (v[i] == '.' && v[i - 1] == '.') ++ans;
}
while (q--) {
cin >> i >> tmp;
if (v[i] == '.' && tmp != '.') {
if (v[i - 1] == '.' && v[i + 1] == '.')
ans -= 2;
else if (v[i - 1] == '.' || v[i + 1] == '.')
--ans;
} else if (v[i] != '.' && tmp == '.') {
if (v[i - 1] == '.' && v[i + 1] == '.')
ans += 2;
else if (v[i - 1] == '.' || v[i + 1] == '.')
++ans;
}
v[i] = tmp;
cout << ans << '\n';
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
int n, m, t;
int f[maxn][2];
int read() {
int x;
scanf("%d", &x);
return x;
}
bool check(long long x, long long y) {
if (x > y) return false;
if (y & 1) {
if (x & 1) {
return false;
} else {
return true;
}
} else {
if (2 * x > y) {
return x & 1;
} else if (4 * x > y) {
return true;
} else {
return check(x, y / 4);
}
}
}
int main() {
int i, j;
long long x, y;
n = read();
for (i = 1; i <= n; i++) {
scanf("%lld%lld", &x, &y);
f[i][0] = check(x, y);
f[i][1] = x * 2 > y || check(x, y / 2);
}
f[0][0] = 0, f[0][1] = 1;
for (i = 1; i <= n; i++) {
x = f[0][0], y = f[0][1];
f[0][0] = (y && f[i][0]) || (x && !f[i][0]);
f[0][1] = (y && f[i][1]) || (x && !f[i][1]);
}
printf("%d %d\n", f[0][0], f[0][1]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
string t;
double l, r, mid;
char s[2001000];
double f[2001000][2];
int len;
int main() {
scanf("%s", s);
len = strlen(s);
for (int i = 0; i < len; ++i) {
t += s[i];
if (s[i] != 'X' && i + 1 < len && s[i] == s[i + 1]) t += 'X';
}
if (s[0] != 'X' && s[0] == s[len - 1]) {
if (s[0] == 'L')
t += 'X';
else
t = "X" + t;
}
len = t.size(), r = 1;
while (r - l > eps) {
mid = (l + r) / 2.0;
f[0][0] = 0.0, f[0][1] = -mid;
for (int i = 0; i < len; i++) {
f[i + 1][0] = f[i][1] - mid;
f[i + 1][1] = f[i][0] - mid;
if (t[i] != 'X') {
if (t[i] == 'L')
f[i + 1][1] = max(f[i + 1][1], f[i][0] + 1 - mid);
else
f[i + 1][0] = max(f[i + 1][0], f[i][1] + 1 - mid);
}
f[i + 1][0] = max(f[i + 1][0], f[i + 1][1] - mid);
f[i + 1][1] = max(f[i + 1][1], f[i + 1][0] - mid);
}
if (f[len][0] > 0)
l = mid;
else
r = mid;
}
len = (l + eps) * 1e8;
printf("%d.%06d\n", len / 1000000, len % 1000000);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, i, j, n, k, p = 0, c = 0, s = 0;
cin >> n >> k;
for (i = 0; i < n; i++) {
c++;
cin >> x;
if (x >= 8) {
p = p + 8;
s = s + x - 8;
} else {
p = p + x;
if (s != 0) {
x = 8 - x;
if (s >= x) {
p = p + x;
s = s - x;
} else {
p = p + s;
s = 0;
}
}
}
if (k <= p) break;
}
if (k > p)
cout << -1 << endl;
else
cout << c << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long max(long long a, long long b) {
if (a > b)
return a;
else
return b;
}
long long min(long long a, long long b) {
if (a < b)
return a;
else
return b;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
int p, mod = 1000000007, n, res;
string s;
int pwr2(int x) {
p = 1;
for (int i = 0; i < x; ++i) p = (p << 1) % mod;
return p;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> s;
n = s.size();
reverse(s.begin(), s.end());
for (int i = 0; i < n; ++i)
if (s[i] == '0')
res = (res * 2) % mod;
else
res = (res * 2 % mod + (pwr2(i) * (long long)pwr2(i)) % mod) % mod;
cout << res;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename C>
struct mcmf {
static constexpr T eps = (T)1e-9;
struct edge {
int from, to;
T c, first;
C cost;
};
vector<vector<int> > g;
vector<edge> edges;
vector<C> d;
vector<bool> in_queue;
vector<int> q, pe;
int n, source, sink;
T flow;
C cost;
mcmf(int n, int source, int sink)
: n(n), source(source), sink(sink), g(n), d(n), in_queue(n), pe(n) {
assert(0 <= source && source < n && 0 <= sink && sink < n &&
source != sink);
flow = cost = 0;
}
void clear_flow() {
for (const edge &e : edges) e.first = 0;
flow = 0;
}
void add(int from, int to, T forward_cap, T backward_cap, C cost) {
assert(0 <= from && from < n && 0 <= to && to < n);
g[from].push_back((int)edges.size());
edges.push_back({from, to, forward_cap, 0, cost});
g[to].push_back((int)edges.size());
edges.push_back({to, from, backward_cap, 0, -cost});
}
bool expath() {
fill(d.begin(), d.end(), numeric_limits<C>::max());
q.clear();
q.push_back(source);
d[source] = 0;
in_queue[source] = true;
int beg = 0;
bool found = false;
while (beg < q.size()) {
int i = q[beg++];
if (i == sink) found = true;
in_queue[i] = false;
for (int id : g[i]) {
const edge &e = edges[id];
if (e.c - e.first > eps && d[i] + e.cost < d[e.to]) {
d[e.to] = d[i] + e.cost;
pe[e.to] = id;
if (!in_queue[e.to]) {
q.push_back(e.to);
in_queue[e.to] = true;
}
}
}
}
if (found) {
T push = numeric_limits<T>::max();
int v = sink;
while (v != source) {
const edge &e = edges[pe[v]];
push = min(push, e.c - e.first);
v = e.from;
}
v = sink;
while (v != source) {
edge &e = edges[pe[v]];
e.first += push;
edge &back = edges[pe[v] ^ 1];
back.first -= push;
v = e.from;
}
flow += push;
cost += push * d[sink];
}
return found;
}
pair<T, C> get_mcmf() {
while (expath()) {
}
return {flow, cost};
}
};
int n, m;
int e[55][55];
int p[55 * 55], q[55 * 55];
int ans[55][55];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
for (int _ = 0; _ < (signed)(m); _++) {
int u, v;
cin >> u >> v;
e[u][v] = 1;
}
int k = n * (n - 1) / 2;
mcmf<int, int> g(1 + k + n + 1, 0, k + n + 1);
int ptr = 0;
for (int i = (1); i <= (signed)(n); i++) {
for (int j = (i + 1); j <= (signed)(n); j++) {
++ptr;
p[ptr] = i;
q[ptr] = j;
g.add(0, ptr, 1, 0, 0);
if (!e[j][i]) {
g.add(ptr, k + i, 1, 0, 0);
}
if (!e[i][j]) {
g.add(ptr, k + j, 1, 0, 0);
}
}
for (int j = 0; j < (signed)(n); j++) {
g.add(k + i, k + n + 1, 1, 0, j);
}
}
auto cur = g.get_mcmf();
for (auto ee : g.edges) {
if (ee.from <= k && ee.first == 1 && ee.from >= 1) {
ans[ee.to - k][p[ee.from] + q[ee.from] - (ee.to - k)] = 1;
}
}
for (int i = (1); i <= (signed)(n); i++) {
for (int j = (1); j <= (signed)(n); j++) {
cout << ans[i][j];
}
cout << "\n";
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
int s, f;
cin >> s >> f;
int hours = f - s;
vector<int> pre(n + hours + 1, 0);
pre[0] = v[0];
for (int i = 0; i < hours; i++) {
v.push_back(v[i]);
}
for (int i = 1; i < n + hours; i++) {
pre[i] += pre[i - 1] + v[i];
}
int ans = INT_MIN;
int index;
for (int i = 0; i < n; i++) {
int val = pre[i + hours - 1] - (i > 0 ? pre[i - 1] : 0);
if (val > ans) {
ans = val;
index = i + 1;
}
}
int actual = INT_MAX;
for (int i = 0; i < n; i++) {
int val = pre[i + hours - 1] - (i > 0 ? pre[i - 1] : 0);
if (val == ans) {
ans = val;
index = i + 1;
if (index == s) {
actual = min(index, actual);
} else if (index > s) {
int temp = (n + s) - (index - 1);
actual = min(temp, actual);
} else {
actual = min(s - index + 1, actual);
}
}
}
cout << actual;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll MAX = 3e5 + 1;
const ll inf = 1e9;
const ll mod = 1e9 + 7;
set<ll> s;
multiset<ll> dis;
ll res() {
if (s.size() < 2) return 0;
return *prev(s.end()) - *s.begin() - *prev(dis.end());
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll n, q, tc, x, y, t;
tc = 1;
while (tc--) {
cin >> n >> q;
for (ll i = 0; i < (ll)n; i++) cin >> x, s.insert(x);
for (auto it = s.begin(); it != s.end(); it++) {
if (it == s.begin()) continue;
dis.insert((*it) - (*prev(it)));
}
cout << res() << endl;
while (q--) {
cin >> t >> x;
if (t == 0) {
auto it = s.lower_bound(x);
if (it != s.begin() && it != prev(s.end())) {
dis.insert(*next(it) - *prev(it));
}
if (it != s.begin()) {
dis.erase(dis.lower_bound(*it - *prev(it)));
}
if (it != prev(s.end())) {
dis.erase(dis.lower_bound(*next(it) - *it));
}
s.erase(it);
} else {
auto it = s.lower_bound(x);
if (it != s.begin() && it != s.end()) {
dis.erase(dis.lower_bound(*it - *prev(it)));
}
if (it != s.begin()) {
dis.insert(x - *prev(it));
}
if (it != s.end()) {
dis.insert(*it - x);
}
s.insert(x);
}
cout << res() << endl;
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
string st;
long n, k;
string s;
set<pair<string, long> > sett;
set<pair<string, long> >::iterator it;
pair<string, long> tt;
int main() {
ios_base::sync_with_stdio(0);
cin >> st;
n = st.size();
cin >> k;
if (1ll * n * (n + 1) / 2 < k) {
cout << "No such line." << endl;
return 0;
}
for (int i = 0; i < n; i++) {
s = "";
s += st[i];
sett.insert(make_pair(s, i));
}
--k;
for (; k; --k) {
it = sett.begin();
tt = (*it);
sett.erase(it);
if (tt.second != n - 1) {
tt.second++;
tt.first += st[tt.second];
sett.insert(tt);
}
}
it = sett.begin();
cout << (*it).first << endl;
cin.get();
cin.get();
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
int n, k;
int a[139];
bool judge(long long x) {
double sum = 0;
for (int i = (1); i < n + 1; i++) sum += a[i];
for (int i = (1); i < x + 1; i++) sum += k;
return sum / (n + x) * 10 >= (k - 0.5) * 10;
}
long long Bsearch(long long l, long long r) {
while (l < r) {
long long mid = (l + r) >> 1;
if (judge(mid))
r = mid;
else
l = mid + 1;
}
return l;
}
int main() {
scanf("%d%d", &n, &k);
for (int i = (1); i < n + 1; i++) scanf("%d", &a[i]);
printf("%d\n", Bsearch(0, 100000));
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
const int N = 1e3 + 10;
const double eps = 1e-5;
int n;
struct Tarr {
long long tarr[N][N];
Tarr() {
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
tarr[i][j] = 0;
}
}
}
static int lowbit(int x) { return x & -x; }
void add(int x, int y, long long val) {
while (x <= n) {
int p = y;
while (p <= n) {
tarr[x][p] ^= val;
p += lowbit(p);
}
x += lowbit(x);
}
}
long long query(int x, int y) {
long long res = 0;
while (x) {
int p = y;
while (p) {
res ^= tarr[x][p];
p -= lowbit(p);
}
x -= lowbit(x);
}
return res;
}
};
Tarr an, ai, aj, aij;
long long query(int x, int y) {
return (((x + 1) * (y + 1) % 2) * an.query(x, y)) ^
(((x + 1) % 2) * ai.query(x, y)) ^ (((y + 1) % 2) * aj.query(x, y)) ^
aij.query(x, y);
}
long long query(int x1, int y1, int x2, int y2) {
return query(x2, y2) ^ query(x1 - 1, y2) ^ query(x2, y1 - 1) ^
query(x1 - 1, y1 - 1);
}
void add(int x, int y, long long val) {
an.add(x, y, val);
ai.add(x, y, (y % 2) * val);
aj.add(x, y, (x % 2) * val);
aij.add(x, y, (x * y % 2) * val);
}
void add(int x1, int y1, int x2, int y2, long long val) {
add(x1, y1, val);
add(x1, y2 + 1, val);
add(x2 + 1, y1, val);
add(x2 + 1, y2 + 1, val);
}
int main() {
std::ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int m;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int op;
cin >> op;
if (op == 2) {
int x1, y1, x2, y2;
long long v;
cin >> x1 >> y1 >> x2 >> y2 >> v;
add(x1, y1, x2, y2, v);
} else {
int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
cout << query(x1, y1, x2, y2) << '\n';
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int a[400000], b[400000], c[400000], p1[400000], p2[400000], p[400000], n;
void add(int x, int v) {
while (x <= n) c[x] += v, x += ((x) & (-x));
}
int sum(int x) {
int res = 0;
while (x) res += c[x], x -= ((x) & (-x));
return res;
}
int main() {
scanf("%d", &n);
memset(c, 0, sizeof(c));
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
a[i]++;
}
for (int i = n; i >= 1; i--) {
p1[i] = sum(a[i] - 1);
add(a[i], 1);
}
memset(c, 0, sizeof(c));
for (int i = 1; i <= n; i++) {
scanf("%d", &b[i]);
b[i]++;
}
for (int i = n; i >= 1; i--) {
p2[i] = sum(b[i] - 1);
add(b[i], 1);
}
int jw = 0;
for (int i = n; i >= 1; i--) {
int t = n - i + 1;
p[i] = (p1[i] + p2[i] + jw) % t;
jw = (p1[i] + p2[i] + jw) / t;
}
memset(c, 0, sizeof(c));
for (int i = 1; i <= n; i++) add(i, 1);
for (int i = 1; i <= n; i++) {
int l = 1, r = n;
while (l < r) {
int mid = (l + r + 1) >> 1;
if (sum(mid - 1) > p[i])
r = mid - 1;
else
l = mid;
}
printf("%d ", l - 1);
add(l, -1);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000010;
int n, k;
int a[N];
int c[N], flag[N];
int main() {
scanf("%d %d", &n, &k);
for (int i = 0; i < n; ++i) scanf("%d", a + i);
for (int i = 0; i < n; ++i)
for (int j = i + 1; j < n; ++j) {
int tem = abs(a[i] - a[j]);
c[tem]++;
}
for (int i = 1;; ++i) {
int cnt = 0, res = 0;
for (int j = i; j < N; j += i) cnt += c[j];
if (cnt > k * (k + 1) / 2) continue;
for (int j = 0; j < n; ++j) {
if (flag[a[j] % i] == i)
res++;
else
flag[a[j] % i] = i;
}
if (res <= k) {
printf("%d\n", i);
break;
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int gra[30][30];
int dp[102][102][30];
int main() {
int k, m, len, ans = -0x3f3f3f3f;
char str[102];
str[0] = 'a';
scanf("%s%d", &str[1], &k);
scanf("%d", &m);
getchar();
for (int i = 0; i < 102; i++)
for (int j = 0; j < 102; j++)
for (int k = 0; k < 30; k++) dp[i][j][k] = -0x3f3f3f3f;
while (m--) {
char u, v;
u = getchar();
getchar();
v = getchar();
u = u - 'a' + 1;
v = v - 'a' + 1;
scanf("%d", &gra[u][v]);
getchar();
}
for (int x = 1; x <= 26; x++)
if (x == str[1] - 'a' + 1)
dp[0][1][x] = 0;
else
dp[1][1][x] = 0;
for (int i = 2; str[i]; i++)
for (int kk = 0; kk <= k; kk++)
for (int x = 1; x <= 26; x++) {
if (x != str[i] - 'a' + 1 && kk > 0)
for (int y = 1; y <= 26; y++)
if (dp[kk - 1][i - 1][y] != -0x3f3f3f3f)
dp[kk][i][x] =
max(dp[kk][i][x], dp[kk - 1][i - 1][y] + gra[y][x]);
if (x == str[i] - 'a' + 1)
for (int y = 1; y <= 26; y++)
if (dp[kk][i - 1][y] != -0x3f3f3f3f)
dp[kk][i][x] = max(dp[kk][i][x], dp[kk][i - 1][y] + gra[y][x]);
}
len = strlen(str);
for (int i = 0; i <= k; i++)
for (int j = 1; j <= 26; j++) ans = max(dp[i][len - 1][j], ans);
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long n, a[500005], ans;
signed main(void) {
cin >> n;
for (long long i = 1; i <= n; i++) cin >> a[i], ans = ans ^ a[i];
if (ans != 0 && n % 2 == 0) {
cout << "NO";
return 0;
}
cout << "YES" << '\n';
if (n % 2 == 1) {
cout << n - 1 << '\n';
for (long long i = 1; i <= n - 2; i += 2) {
cout << i << ' ' << i + 1 << ' ' << n << '\n';
}
for (long long i = 1; i <= n - 2; i += 2) {
cout << i << ' ' << i + 1 << ' ' << n << '\n';
}
}
if (n % 2 == 0) {
n--;
cout << n - 1 << '\n';
for (long long i = 1; i <= n - 2; i += 2) {
cout << i << ' ' << i + 1 << ' ' << n << '\n';
}
for (long long i = 1; i <= n - 2; i += 2) {
cout << i << ' ' << i + 1 << ' ' << n << '\n';
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
int sum[30], len;
char s[maxn];
int main() {
scanf("%s", s + 1);
len = strlen(s + 1);
for (int i = 1; i <= len; i++) sum[s[i] - 'a']++;
int i = 0, j = 25;
while (i < j) {
while (i < j && !(sum[i] & 1)) i++;
while (i < j && !(sum[j] & 1)) j--;
sum[i]++;
sum[j]--;
}
for (i = 0; i <= 25; i++)
for (j = 1; j <= sum[i] / 2; j++) printf("%c", i + 'a');
for (i = 0; i <= 25; i++)
if (sum[i] % 2) printf("%c", i + 'a');
for (i = 25; i >= 0; i--)
for (j = 1; j <= sum[i] / 2; j++) printf("%c", i + 'a');
cout << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, n, m, r, min_s = 1000, min_b = 1000, max_b = 0;
int s[31] = {0}, b[31] = {0};
cin >> n >> m >> r;
for (i = 0; i < n; i++) {
cin >> s[i];
if (min_s > s[i]) {
min_s = s[i];
}
}
for (i = 0; i < m; i++) {
cin >> b[i];
if (min_b > b[i]) {
min_b = b[i];
}
if (max_b < b[i]) {
max_b = b[i];
}
}
if (min_s >= max_b) {
cout << r << endl;
} else {
cout << ((r - r % min_s) / min_s) * max_b + (r % min_s) << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
string s;
cin >> s;
int a[4][4] = {0};
int i, j, k = -1;
while (++k < (int)(s).size()) {
if (s[k] == '0') {
j = -1;
while (++j < 4) {
i = -1;
while (++i < 3)
if (a[i][j] == 0 && a[i + 1][j] == 0) {
a[i][j] = 1, a[i + 1][j] = 1;
break;
}
if (i != 3) break;
}
cout << i + 1 << " " << j + 1 << endl;
} else {
i = -1;
while (++i < 4) {
j = -1;
while (++j < 3)
if (a[i][j] == 0 && a[i][j + 1] == 0) {
a[i][j] = 1, a[i][j + 1] = 1;
break;
}
if (j != 3) break;
}
cout << i + 1 << " " << j + 1 << endl;
}
i = -1;
int ct;
while (++i < 4) {
j = -1;
ct = 0;
while (++j < 4)
if (a[i][j] == 1) ct++;
if (ct == 4) {
j = -1;
while (++j < 4) a[i][j] = 0;
}
}
j = -1;
while (++j < 4) {
i = -1;
ct = 0;
while (++i < 4)
if (a[i][j] == 1) ct++;
if (ct == 4) {
i = -1;
while (++i < 4) a[i][j] = 0;
}
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
char s[10][10];
int main() {
scanf("%s", s[0]);
for (int i = 1; i < 6; i++) {
scanf("%s", s[i]);
}
for (int i = 1; i < 6; i++) {
if (s[i][0] == s[0][0] || s[i][1] == s[0][1]) {
cout << "YES" << endl;
return 0;
}
}
cout << "NO" << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10, mod = 1e9 + 7;
const long long inf = 1e18;
bool f[maxn];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
string s;
cin >> s;
int ans = 0, n = int((s).size());
for (int i = 0; i < int((s).size()); i++) {
int A = s[i] == '1';
int B = s[i == int((s).size()) - 1 ? 0 : i + 1] == '1';
if (A != B) f[i] = 1;
}
int pos = 0;
for (int i = 0; i < int((s).size()); i++) {
if (f[i] == 0) pos = i;
}
int pos2 = (pos + 1) % n;
while (pos != pos2) {
if (f[pos2] == 0) pos2 = (pos2 + 1) % n;
int cnt = 0;
while (pos != pos2 && f[pos2] == 1) {
cnt++;
pos2 = (pos2 + 1) % n;
}
ans += (cnt + 1) / 2;
}
return cout << ans << endl, 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
bool vis[1000];
string make(string s, int k) {
memset(vis, false, sizeof vis);
int n = (int)s.size();
for (int i = 0; i < n; i++)
if (s[i] == '?' && s[n - i - 1] != '?') s[i] = s[n - i - 1];
for (int i = 0; i < n; i++)
if (s[i] != '?') vis[s[i] - 'a'] = true;
for (int i = k - 1; i >= 0; i--)
if (vis[i] == false) {
char c = 'a' + i;
for (int j = n / 2; j < n; j++)
if (s[j] == '?') {
s[j] = s[n - j - 1] = c;
break;
}
}
for (int i = 0; i < n; i++)
if (s[i] == '?') s[i] = s[n - i - 1] = 'a';
return s;
}
bool valid(string s, int k) {
memset(vis, false, sizeof vis);
int n = (int)s.size();
if (n < 2 * k - 1) return 0;
for (int i = 0; i < n; i++) vis[s[i] - 'a'] = true;
for (int i = 0; i < k; i++)
if (vis[i] == false) return 0;
for (int i = 0; i < n; i++)
if (s[i] - 'a' > k - 1) return 0;
for (int i = 0; i < n; i++)
if (s[i] != s[n - i - 1]) return 0;
return 1;
}
int main() {
int k;
string s;
cin >> k >> s;
s = make(s, k);
if (valid(s, k))
cout << s << endl;
else
cout << "IMPOSSIBLE" << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int d[N], q[N], fi[10], ne[N], f[N][10], dist[10][10], mark[N], num[10][1 << 8],
nums[10], n;
char s[N];
void bfs(int c) {
int h = 1, t = 0, u[10];
for (int i = 1; i <= n; i++)
if (s[i] - 'a' == c)
d[q[++t] = i] = 0;
else
d[i] = -1;
for (int i = 0; i < 8; i++) u[i] = 1;
u[c] = 0;
for (; h <= t; h++) {
if (u[s[q[h]] - 'a']) {
u[s[q[h]] - 'a'] = 0;
for (int i = fi[s[q[h]] - 'a']; i; i = ne[i])
if (d[i] == -1) d[q[++t] = i] = d[q[h]] + 1;
}
if (q[h] > 1 && d[q[h] - 1] == -1) d[q[++t] = q[h] - 1] = d[q[h]] + 1;
if (q[h] < n && d[q[h] + 1] == -1) d[q[++t] = q[h] + 1] = d[q[h]] + 1;
}
for (int i = 1; i <= n; i++) f[i][c] = d[i];
}
int main() {
scanf("%d\n%s", &n, s + 1);
for (int i = 1; i <= n; i++) {
ne[i] = fi[s[i] - 'a'];
fi[s[i] - 'a'] = i;
}
for (int i = 0; i < 8; i++) bfs(i);
for (int i = 0; i < 8; i++)
for (int j = 0; j < 8; j++) dist[i][j] = -1;
for (int i = 1, j; i <= n; i++)
for (j = 0; j < 8; j++)
if (f[i][j] != -1 &&
(dist[s[i] - 'a'][j] == -1 || f[i][j] < dist[s[i] - 'a'][j]))
dist[s[i] - 'a'][j] = f[i][j];
for (int i = 1, j; i <= n; i++) {
mark[i] = 0;
for (j = 7; j >= 0; j--)
mark[i] = mark[i] << 1 ^ (f[i][j] - dist[s[i] - 'a'][j]);
}
int ans = 0, now = 1;
long long ansp = 0;
for (int i = 1, j, k; i <= n; i++) {
int l = i;
for (; l >= 1; l--) {
int mindst = -1;
for (j = 0; j < 8; j++)
if (f[l][j] != -1 && f[i][j] != -1 &&
(mindst == -1 || f[l][j] + f[i][j] + 1 < mindst))
mindst = f[l][j] + f[i][j] + 1;
if (mindst <= i - l) break;
}
for (; now <= l; now++) {
nums[s[now] - 'a']++;
for (j = mark[now]; j; j = (j - 1) & mark[now]) num[s[now] - 'a'][j]++;
}
for (j = 0; j < 8; j++) {
int mindst = -1, minnum = 0;
for (k = 0; k < 8; k++)
if (f[i][k] != -1 && dist[k][j] != -1 &&
(mindst == -1 || f[i][k] + dist[k][j] + 1 < mindst))
mindst = f[i][k] + dist[k][j] + 1;
if (mindst == -1) continue;
int mrk = 0;
for (k = 0; k < 8; k++)
if (f[i][k] != -1 && dist[k][j] != -1 &&
f[i][k] + dist[k][j] + 1 == mindst)
mrk ^= 1 << k;
if (num[j][mrk])
mindst++, minnum = num[j][mrk];
else
minnum = nums[j];
if (!minnum) continue;
if (mindst > ans)
ans = mindst, ansp = minnum;
else if (mindst == ans)
ansp = ansp + minnum;
}
if (i - now > ans)
ans = i - now, ansp = 1;
else if (i - now == ans)
ansp++;
}
printf("%d %I64d\n", ans, ansp);
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int INF = 1000000001;
vector<int> a;
void writeln(int a) { printf("%d\n", a); }
void writeln(int a, int b) { printf("%d %d\n", a, b); }
void writeln(int a, int b, int c) { printf("%d %d %d\n", a, b, c); }
void writeln(int a, int b, int c, int d) {
printf("%d %d %d %d\n", a, b, c, d);
}
void write(int a) { printf("%d", a); }
void write(int a, int b) { printf("%d %d", a, b); }
void write(int a, int b, int c) { printf("%d %d %d", a, b, c); }
void write(int a, int b, int c, int d) { printf("%d %d %d %d", a, b, c, d); }
void read(int &a) { scanf("%d", &a); }
void read(int &a, int &b) { scanf("%d %d", &a, &b); }
void read(int &a, int &b, int &c) { scanf("%d %d %d", &a, &b, &c); }
void read(int &a, int &b, int &c, int &d) {
scanf("%d %d %d %d", &a, &b, &c, &d);
}
void readln(int &a) { scanf("%d\n", &a); }
void readln(int &a, int &b) { scanf("%d %d\n", &a, &b); }
void readln(int &a, int &b, int &c) { scanf("%d %d %d\n", &a, &b, &c); }
void readln(int &a, int &b, int &c, int &d) {
scanf("%d %d %d %d\n", &a, &b, &c, &d);
}
void writeln(vector<int> a) {
for (int i = 0; i < a.size(); i++)
printf("%d%c", a[i], i == a.size() - 1 ? '\n' : ' ');
}
void readln(vector<int> &a, int n) {
int x;
for (int i = 1; i <= n; i++) read(x), a.push_back(x);
}
int main() {
int n, m, k;
readln(n, k);
readln(a, n);
sort(a.begin(), a.begin() + n);
if (n < k) {
printf("-1");
return 0;
}
writeln(a[n - k], 0);
return 0;
}
| 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.