solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const double PI = acos(-1.0);
const int inf = 0x3f3f3f3f;
template <class T>
void read(T& num) {
char CH;
bool F = false;
for (CH = getchar(); CH < '0' || CH > '9'; F = CH == '-', CH = getchar())
;
for (num = 0; CH >= '0' && CH <= '9';
num = num * 10 + CH - '0', CH = getchar())
;
F && (num = -num);
}
int stk[70], tp;
template <class T>
inline void print(T p) {
if (!p) {
puts("0");
return;
}
while (p) stk[++tp] = p % 10, p /= 10;
while (tp) putchar(stk[tp--] + '0');
putchar('\n');
}
struct node {
int al, ar;
int mx;
};
struct node1 {
int hl, hr;
node subt[4000];
} t[4][310 * 4];
void build_sub(int id, int rt, int ll, int rr, int flag) {
t[flag][id].subt[rt].al = ll;
t[flag][id].subt[rt].ar = rr;
t[flag][id].subt[rt].mx = inf;
if (ll == rr) {
return;
}
int mid = (ll + rr) >> 1;
build_sub(id, rt << 1, ll, mid, flag);
build_sub(id, rt << 1 | 1, mid + 1, rr, flag);
}
void build(int id, int l, int r, int ll, int rr, int flag) {
t[flag][id].hl = l;
t[flag][id].hr = r;
build_sub(id, 1, ll, rr, flag);
if (l == r) return;
int mid = (l + r) >> 1;
build(id << 1, l, mid, ll, rr, flag);
build(id << 1 | 1, mid + 1, r, ll, rr, flag);
}
void add_sub(int id, int rt, int act, int love, int flag) {
t[flag][id].subt[rt].mx = min(love, t[flag][id].subt[rt].mx);
if (t[flag][id].subt[rt].al == t[flag][id].subt[rt].ar) return;
int mid = (t[flag][id].subt[rt].al + t[flag][id].subt[rt].ar) >> 1;
if (act <= mid)
add_sub(id, rt << 1, act, love, flag);
else
add_sub(id, rt << 1 | 1, act, love, flag);
t[flag][id].subt[rt].mx =
min(t[flag][id].subt[rt << 1].mx, t[flag][id].subt[rt << 1 | 1].mx);
}
void add(int id, int h, int act, int love, int flag) {
add_sub(id, 1, act, love, flag);
if (t[flag][id].hl == t[flag][id].hr) {
return;
}
int mid = (t[flag][id].hl + t[flag][id].hr) >> 1;
if (h <= mid)
add(id << 1, h, act, love, flag);
else
add(id << 1 | 1, h, act, love, flag);
}
void add_sub1(int id, int rt, int act, int love, int flag) {
t[flag][id].subt[rt].mx = love;
if (t[flag][id].subt[rt].al == t[flag][id].subt[rt].ar) return;
int mid = (t[flag][id].subt[rt].al + t[flag][id].subt[rt].ar) >> 1;
if (act <= mid)
add_sub1(id, rt << 1, act, love, flag);
else
add_sub1(id, rt << 1 | 1, act, love, flag);
t[flag][id].subt[rt].mx = love;
}
void add1(int id, int h, int act, int love, int flag) {
add_sub1(id, 1, act, love, flag);
if (t[flag][id].hl == t[flag][id].hr) {
return;
}
int mid = (t[flag][id].hl + t[flag][id].hr) >> 1;
if (h <= mid)
add1(id << 1, h, act, love, flag);
else
add1(id << 1 | 1, h, act, love, flag);
}
int sear(int id, int rt, int ll, int rr, int flag) {
if (t[flag][id].subt[rt].al == ll && t[flag][id].subt[rt].ar == rr) {
return t[flag][id].subt[rt].mx;
}
int mid = (t[flag][id].subt[rt].al + t[flag][id].subt[rt].ar) >> 1;
if (rr <= mid)
return sear(id, rt << 1, ll, rr, flag);
else if (ll > mid)
return sear(id, rt << 1 | 1, ll, rr, flag);
else
return min(sear(id, rt << 1, ll, mid, flag),
sear(id, rt << 1 | 1, mid + 1, rr, flag));
}
int query(int id, int l, int r, int ll, int rr, int flag) {
if (t[flag][id].hl == l && t[flag][id].hr == r) {
return sear(id, 1, ll, rr, flag);
}
int mid = (t[flag][id].hl + t[flag][id].hr) >> 1;
if (r <= mid)
return query(id << 1, l, r, ll, rr, flag);
else if (l > mid)
return query(id << 1 | 1, l, r, ll, rr, flag);
else
return min(query(id << 1, l, mid, ll, rr, flag),
query(id << 1 | 1, mid + 1, r, ll, rr, flag));
}
struct no {
int l, r, dis;
};
vector<no> ve[310 * 310];
int a[305][305], le[310 * 310];
int n, m, p;
int main() {
no x;
read(n);
read(m);
read(p);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
read(a[i][j]);
x.l = i;
x.r = j;
x.dis = inf;
ve[a[i][j]].push_back(x);
}
}
for (int i = 0; i < 4; i++) {
build(1, 1, n, 1, m, i);
}
for (int i = 1; i <= p; i++) {
le[i] = ve[i].size();
}
for (int i = 0; i < le[1]; i++) {
int l = ve[1][i].l, r = ve[1][i].r;
ve[1][i].dis = l + r - 2;
}
for (int i = 2; i <= p; i++) {
int len1 = le[i], len2 = le[i - 1];
for (int j = 0; j < len2; j++) {
int l = ve[i - 1][j].l, r = ve[i - 1][j].r;
add(1, l, r, ve[i - 1][j].dis - l - r, 0);
add(1, l, r, ve[i - 1][j].dis - l + r, 1);
add(1, l, r, ve[i - 1][j].dis + l - r, 2);
add(1, l, r, ve[i - 1][j].dis + l + r, 3);
}
for (int j = 0; j < len1; j++) {
int l = ve[i][j].l, r = ve[i][j].r;
ve[i][j].dis = min(ve[i][j].dis, query(1, 1, l, 1, r, 0) + l + r);
ve[i][j].dis = min(ve[i][j].dis, query(1, 1, l, r, m, 1) + l - r);
ve[i][j].dis = min(ve[i][j].dis, query(1, l, n, 1, r, 2) - l + r);
ve[i][j].dis = min(ve[i][j].dis, query(1, l, n, r, m, 3) - l - r);
}
for (int j = 0; j < len2; j++) {
add1(1, ve[i - 1][j].l, ve[i - 1][j].r, inf, 0);
add1(1, ve[i - 1][j].l, ve[i - 1][j].r, inf, 1);
add1(1, ve[i - 1][j].l, ve[i - 1][j].r, inf, 2);
add1(1, ve[i - 1][j].l, ve[i - 1][j].r, inf, 3);
}
}
cout << ve[p][0].dis << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 26;
int road[maxn][maxn];
int main() {
string a, b;
int n;
cin >> a >> b >> n;
if (a.size() != b.size()) {
cout << -1;
return 0;
}
for (int i = 0; i < maxn; i++) {
fill(road[i], road[i] + maxn, 10010);
}
for (int i = 0; i < n; i++) {
char c, d;
int e;
cin >> c >> d >> e;
road[int(c) - 'a'][int(d) - 'a'] = min(road[int(c) - 'a'][int(d) - 'a'], e);
}
for (int i = 0; i < maxn; i++) {
road[i][i] = 0;
}
for (int k = 0; k < maxn; k++) {
for (int i = 0; i < maxn; i++) {
for (int j = 0; j < maxn; j++) {
road[i][j] = min(road[i][j], road[i][k] + road[k][j]);
}
}
}
string str;
int ans = 0;
for (int i = 0; i < a.size(); i++) {
int mini = 10010;
int ch = -2;
if (a[i] == b[i]) {
str += a[i];
continue;
}
for (int j = 0; j < maxn; j++) {
if (mini > road[int(a[i]) - 'a'][j] + road[int(b[i]) - 'a'][j]) {
mini = road[int(a[i]) - 'a'][j] + road[int(b[i]) - 'a'][j];
ch = j;
}
}
if (ch == -2) {
cout << -1;
return 0;
}
str += char(ch + 'a');
ans += mini;
}
cout << ans << endl << str;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int rem(const string& s, int mod) {
long long res = 0;
for (int i = 0; i < (int)(s).size(); ++i) {
res *= 10;
res += (s[i] - '0');
if (res >= mod) {
res %= mod;
}
}
return res;
}
int fi(int n) {
int ans = n;
for (int i = 2; i * i <= n; ++i) {
if (n % i == 0) {
ans /= i;
ans *= (i - 1);
while (n % i == 0) {
n /= i;
}
}
}
if (n != 1) {
ans /= n;
ans *= (n - 1);
}
return ans;
}
long long binpow(long long a, long long n, long long mod) {
long long ans = 1;
while (n) {
if (n & 1) {
ans = (ans * a) % mod;
}
n >>= 1;
if (n) {
a = (a * a) % mod;
}
}
return ans;
}
long long str_to_ll(const string& s) {
long long ans = 0;
for (int i = 0; i < (int)(s).size(); ++i) {
ans *= 10;
ans += (s[i] - '0');
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
string b, n;
int c;
cin >> b >> n;
cin >> c;
long long ans = rem(b, c);
--ans;
if (ans < 0) {
ans += c;
}
int d = fi(c);
int p = rem(n, d);
--p;
if (p < 0) {
p += d;
}
if ((int)(n).size() >= 12 || str_to_ll(n) - 1 >= d) {
p += d;
}
long long q = rem(b, c);
ans *= binpow(q, p, c);
ans %= c;
cout << (ans == 0 ? c : ans) << "\n";
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
cout << (n - 1) * n * (n + 1) / 3 << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int oo = 0x3f3f3f3f;
const double eps = 1e-9;
const double PI = acos(-1.0);
int N, M;
pair<int, int> tmp[500];
int x[500][2], x2[500][2];
double at2r[500][500];
double at2b[500][500];
int CID;
bool ccw(int xx, int yy, int ia, int ib) {
long long xa, ya, xb, yb;
if (ia < 0) {
ia = -1 - ia;
xa = x2[ia][0];
ya = x2[ia][1];
} else {
xa = x[ia][0];
ya = x[ia][1];
}
if (ib < 0) {
ib = -1 - ib;
xb = x2[ib][0];
yb = x2[ib][1];
} else {
xb = x[ib][0];
yb = x[ib][1];
}
xa -= xx;
xb -= xx;
ya -= yy;
yb -= yy;
return (xa * yb > xb * ya);
}
struct PD {
double first;
int second;
PD() {}
PD(double a, int s) {
first = a;
second = s;
}
};
bool operator<(const PD& a, const PD& b) {
bool ret;
if (abs(a.first - b.first) > eps)
ret = a.first < b.first;
else {
int ia = a.second;
int ib = b.second;
ret = ccw(x[CID][0], x[CID][1], ia, ib);
}
return ret;
}
PD cur[1000];
int main() {
scanf("%d%d", &N, &M);
for (int i = (0); i < (N); i++) {
scanf("%d%d", &(tmp[i].first), &(tmp[i].second));
}
sort(tmp, tmp + N);
for (int i = (0); i < (N); i++) {
x[i][0] = tmp[i].first;
x[i][1] = tmp[i].second;
}
for (int i = (0); i < (M); i++) {
scanf("%d%d", &(x2[i][0]), &(x2[i][1]));
}
for (int i = (0); i < (N); i++) {
for (int j = (0); j < (N); j++)
at2r[i][j] = atan2(x[j][1] - x[i][1], x[j][0] - x[i][0]);
}
for (int i = (0); i < (N); i++) {
for (int j = (0); j < (M); j++)
at2b[i][j] = atan2(x2[j][1] - x[i][1], x2[j][0] - x[i][0]);
}
int res = 0;
for (int p1 = (0); p1 < (N); p1++) {
int ID = 0;
CID = p1;
for (int i = (p1 + 1); i < (N); i++) {
cur[ID].second = i;
cur[ID++].first = at2r[p1][i];
}
for (int i = (0); i < (M); i++) {
cur[ID].second = -1 - i;
cur[ID++].first = at2b[p1][i];
}
sort(cur, cur + ID);
for (int i = (0); i < (ID); i++)
if (cur[i].second >= 0) {
int p2 = cur[i].second;
double pw = 100.0;
double gw = PI + cur[i].first;
int fin = -1;
for (int j = (i + 1); j < (ID); j++) {
int id = cur[j].second;
if (id < 0) {
id = -1 - id;
double win = gw - at2b[p2][id];
if (win > PI) win -= 2 * PI;
if (win < 0) break;
pw = min(win, pw);
} else {
double win = gw - at2r[p2][id];
if (win > PI) win -= 2 * PI;
if (win < 0) break;
if (win < pw) res++;
}
}
}
}
printf("%d\n", res);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int l, b, f;
int a[105], c[105];
int sum[101205 << 2], lsum[101205 << 2], rsum[101205 << 2], visit[101205 << 2];
void pushup(int l, int r, int node) {
int len = r - l + 1;
lsum[node] = lsum[node << 1];
rsum[node] = rsum[node << 1 | 1];
if (lsum[node] == len - (len >> 1)) lsum[node] += lsum[node << 1 | 1];
if (rsum[node] == (len >> 1)) rsum[node] += rsum[node << 1];
sum[node] = max(rsum[node << 1] + lsum[node << 1 | 1],
max(sum[node << 1], sum[node << 1 | 1]));
}
void pushdown(int l, int r, int node) {
int len = r - l + 1;
if (visit[node] != -1) {
visit[node << 1] = visit[node << 1 | 1] = visit[node];
lsum[node << 1] = rsum[node << 1] = sum[node << 1] =
visit[node] ? 0 : len - (len >> 1);
lsum[node << 1 | 1] = rsum[node << 1 | 1] = sum[node << 1 | 1] =
visit[node] ? 0 : (len >> 1);
visit[node] = -1;
}
}
void build(int l, int r, int node) {
visit[node] = -1;
lsum[node] = rsum[node] = sum[node] = r - l + 1;
if (l == r) return;
int mid = (l + r) >> 1;
build(l, mid, node << 1);
build(mid + 1, r, node << 1 | 1);
}
void update(int x, int y, int v, int l, int r, int node) {
if (x <= l && y >= r) {
lsum[node] = rsum[node] = sum[node] = v ? 0 : r - l + 1;
visit[node] = v;
return;
}
pushdown(l, r, node);
int mid = (l + r) >> 1;
if (x <= mid) update(x, y, v, l, mid, node << 1);
if (y > mid) update(x, y, v, mid + 1, r, node << 1 | 1);
pushup(l, r, node);
}
int query(int a, int l, int r, int node) {
if (l == r) return l;
pushdown(l, r, node);
int mid = (l + r) >> 1;
if (sum[node << 1] >= a)
return query(a, l, mid, node << 1);
else if (rsum[node << 1] + lsum[node << 1 | 1] >= a)
return mid - rsum[node << 1] + 1 + b;
else
return query(a, mid + 1, r, node << 1 | 1);
}
int main() {
int n, choice, x, cnt = 0;
while (scanf("%d%d%d", &l, &b, &f) != EOF) {
l = l + b + f;
build(1, l, 1);
scanf("%d", &n);
while (n--) {
scanf("%d", &choice);
++cnt;
if (choice == 1) {
scanf("%d", &a[cnt]);
if (sum[1] < a[cnt] + b + f)
printf("-1\n");
else {
c[cnt] = query(a[cnt] + b + f, 1, l, 1);
update(c[cnt], c[cnt] + a[cnt] - 1, 1, 1, l, 1);
printf("%d\n", c[cnt] - 1 - b);
}
} else if (choice == 2) {
scanf("%d", &x);
update(c[x], c[x] + a[x] - 1, 0, 1, l, 1);
}
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
long long int rvsr(long long int n) {
string s = to_string(n);
reverse(s.begin(), s.end());
stringstream obj(s);
obj >> n;
return n;
}
long long int power(long long int x, long long int y) {
long long int res = 1;
x = x;
while (y > 0) {
if (y & 1) res = (res * x);
y = y >> 1;
x = (x * x);
}
return res;
}
long long int logtwo(long long int n) {
if (n == 1) return 0;
return logtwo(n / 2) + 1;
}
long long int isprime(long long int n) {
for (long long int c1 = 2; c1 * c1 <= n; c1++) {
if (n % c1 == 0) {
return 0;
}
}
return 1;
}
long long int twop(long long int n) {
long long int x = 0;
while (n % 2 == 0) {
n /= 2;
x++;
}
return x;
}
template <typename T, typename T1>
T amin(T &a, T1 b) {
if (b < a) a = b;
return a;
}
void solve() {
long long int n;
int d;
cin >> n;
int max = 0, min = INT_MAX;
for (long long int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
if (x < min) {
min = x;
if (y >= max) {
d = i + 1;
} else
d = -1;
}
if (y > max) {
max = y;
if (x <= min) {
d = i + 1;
} else
d = -1;
}
if (x == min && y == max) d = i + 1;
}
cout << d << "\n";
return;
}
int main() {
long long int t;
t = 1;
while (t--) solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long arr[n];
for (long long i = 0; i < n; i++) {
cin >> arr[i];
}
long long i = 0, j = 0;
vector<long long> vec;
while (i < n) {
long long ans = 1;
j = i;
while (j < n) {
if (j != 0 && arr[j] == 1) {
vec.push_back(arr[j - 1]);
j++;
break;
} else {
j++;
}
}
i = j;
}
vec.push_back(arr[n - 1]);
if (n == 1) {
cout << 1 << endl;
cout << 1 << endl;
} else {
cout << vec.size() << endl;
for (auto x : vec) cout << x << " ";
cout << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m, i, a, b, j, k;
cin >> n >> m;
vector<int> v[n + 1];
for (i = 1; i <= m; i++) {
cin >> a >> b;
v[a].push_back(b);
}
for (i = 1; i <= n; i++) {
long long ans = 0;
for (j = 1; j <= n; j++) {
if (v[j].size() > 0) {
long long last = v[j][0];
for (k = 0; k < v[j].size(); k++) {
if ((v[j][k] - j + n) % n < (last - j + n) % n) {
last = v[j][k];
}
}
long long tempans =
(j - i + n) % n + (v[j].size() - 1) * n + (last - j + n) % n;
ans = max(ans, tempans);
}
}
cout << ans << " ";
}
cout << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int mx = 1e5 + 10;
const double eps = 1e-9;
const int inf = 1e9;
map<pair<int, int>, int> link2;
map<int, int> link;
vector<int> adj[mx];
int n, len = 0;
bool ok = 0, vis[mx];
map<int, int> XX;
void dfs(int u) {
len++;
vis[u] = 1;
if (len == n + 1) ok = 1;
if (ok) {
printf("%d ", XX[u]);
return;
}
for (auto v : adj[u]) {
if (!vis[v]) {
dfs(v);
if (ok) {
printf("%d ", XX[u]);
return;
}
}
}
}
int main() {
scanf("%d", &n);
int u, v;
int c = 1;
for (int i = 1; i <= n; i++) {
scanf("%d%d", &u, &v);
if (!link[u]) {
XX[c] = u;
link[u] = c++;
}
if (!link[v]) {
XX[c] = v;
link[v] = c++;
}
link2[{u, v}] = 1;
}
for (auto &x : link2) {
int tmp1 = x.first.first, tmp2 = x.first.second;
adj[link[tmp1]].push_back(link[tmp2]);
adj[link[tmp2]].push_back(link[tmp1]);
}
int root = 1;
for (int i = 1; i <= n; i++)
if (adj[i].size() == 1) {
root = i;
break;
}
dfs(root);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vll = vector<ll>;
using pii = pair<int, int>;
using vvi = vector<vi>;
using vii = vector<pii>;
string s;
bool read() {
if (!(cin >> s)) {
return 0;
}
return 1;
}
const int mod = (int)1e9 + 7;
void add(int &a, int b) {
a += b;
if (a >= mod) a -= mod;
}
void sub(int &a, int b) {
a -= b;
if (a < 0) a += mod;
}
void kill(vi &v) {
v.clear();
v.shrink_to_fit();
}
struct gap_jumper {
string s;
vi value;
int n;
gap_jumper(string s_, int n_) {
n = n_;
value.resize(n + 1);
s = s_;
assert(int((s).size()) == 2 * n);
}
vi d_was;
vvi next_, prev_, sum_;
int get_id(int step) {
int pos = find((d_was).begin(), (d_was).end(), step) - d_was.begin();
if (pos != int((d_was).size())) return pos;
d_was.push_back(step);
next_.push_back(vi(2 * n)), prev_.push_back(vi(2 * n)),
sum_.push_back(vi());
sum_.back().reserve(n);
vi &next = next_.back();
vi &prev = prev_.back();
for (int i = int(2 * n) - 1; i >= 0; --i) {
if (i + step >= 2 * n)
next[i] = 1;
else
next[i] = (s[i] != s[i + step] ? 1 : next[i + step] + 1);
}
for (int i = 0; i < int(2 * n); ++i) {
if (i < step)
prev[i] = 1;
else
prev[i] = (s[i] != s[i - step] ? 1 : prev[i - step] + 1);
}
return pos;
}
int first_left(int pos, int step, char what) {
const int id = get_id(step);
const vi &prev = prev_[id];
if (what != s[pos]) return 0;
return prev[pos];
}
int first_right(int pos, int step, char what) {
const int id = get_id(step);
const vi &next = next_[id];
if (what != s[pos]) return 0;
return next[pos];
}
int sum(int pos, int step, int len) {
const int id = get_id(step);
vi &sum = sum_[id];
int to = pos + step * (len - 1);
assert(0 <= pos && pos <= to && to < int((value).size()));
while (int((sum).size()) <= to) {
const int cur_id = int((sum).size());
sum.push_back(value[cur_id]);
if (cur_id >= step) add(sum.back(), sum[cur_id - step]);
}
int res = sum[to];
if (pos - step >= 0) sub(res, sum[pos - step]);
return res;
}
void purge(const vi &allowed) {
vi to_del;
for (int i = 0; i < int(int((d_was).size())); ++i) {
const int id = d_was[i];
if (!binary_search((allowed).begin(), (allowed).end(), id))
to_del.push_back(i);
}
reverse((to_del).begin(), (to_del).end());
for (int id : to_del) {
d_was[id] = -1;
kill(sum_[id]);
kill(prev_[id]);
kill(next_[id]);
}
}
};
struct prog {
int start, diff, len;
int get(int id) const { return start + diff * id; }
int get_end() const { return start + diff * (len - 1); }
};
void relax(vector<prog> &v) {
vector<prog> nv;
for (const auto &pr : v) {
if (pr.len == 0) continue;
if (nv.empty())
nv.push_back(pr);
else {
auto &top = nv.back();
if (top.len == 1 && pr.len == 1)
top = prog{top.start, pr.start - top.start, 2};
else if (top.len == 1 && pr.start - top.start == pr.diff) {
top = prog{top.start, pr.diff, pr.len + 1};
} else if (pr.len == 1 && pr.start - top.get_end() == top.diff) {
top.len++;
} else if (pr.diff == top.diff && pr.start - top.get_end() == top.diff) {
top.len += pr.len;
} else {
nv.push_back(pr);
}
}
}
v.swap(nv);
}
void incr_all(vector<prog> &v, int delta) {
for (auto &pr : v) pr.start += delta;
}
void add_start(vector<prog> &v, int num) {
assert(v.empty() || num < v.front().start);
v.insert(v.begin(), prog{num, 1, 1});
}
void del(vector<prog> &v, const vi &who) {
int ptr = 0;
vector<prog> nv;
for (const auto &pr : v) {
int last_alive = 0;
while (ptr < int((who).size()) && pr.start <= who[ptr] &&
who[ptr] <= pr.get_end()) {
assert((who[ptr] - pr.start) % pr.diff == 0);
int cur_id = (who[ptr] - pr.start) / pr.diff;
if (last_alive < cur_id)
nv.push_back(prog{pr.get(last_alive), pr.diff, cur_id - last_alive});
assert(last_alive <= cur_id);
last_alive = cur_id + 1;
ptr++;
}
const int total = pr.len;
if (last_alive < total)
nv.push_back(prog{pr.get(last_alive), pr.diff, total - last_alive});
}
v.swap(nv);
relax(v);
}
void print(const vector<prog> &v) {
for (const auto &pr : v) {
for (int i = 0; i < int(pr.len); ++i)
;
;
};
;
}
double time() { return (double)clock() / CLOCKS_PER_SEC; }
int work_old() {
const int n = int((s).size()) / 2;
assert(int((s).size()) == 2 * n);
vi dp(n + 1);
dp[0] = 1;
vi pref;
for (int len = 0; len < int(n + 1); ++len)
if (len) {
if (int((pref).size()) >= 50) return -1;
const int l = n - len, r = n + len;
vi npref;
for (int i : pref) {
if (s[l] == s[r - i - 2] && s[l + i + 1] == s[r - 1] && i + 2 <= len)
npref.push_back(i + 2);
}
if (s[l] == s[r - 1]) npref.push_back(1);
if (len >= 2 && s[l] == s[r - 2] && s[l + 1] == s[r - 1])
npref.push_back(2);
pref = npref;
for (int i : pref) add(dp[len], dp[len - i]);
}
return dp[n];
}
void solve() {
const int n = int((s).size()) / 2;
assert(int((s).size()) == 2 * n);
int ans = work_old();
if (ans != -1) {
cout << ans << endl;
return;
}
gap_jumper info(s, n);
vi dp(n + 1);
dp[0] = 1;
info.value[0] = 1;
vector<prog> pref;
for (int len = 0; len < int(n + 1); ++len)
if (len) {
const int l = n - len, r = n + len;
vi to_del;
for (const auto &pr : pref) {
for (int i = 0; i < pr.len;) {
int cur = pr.get(i);
const int left_steps = info.first_left(r - cur - 2, pr.diff, s[l]);
const int right_steps =
info.first_right(l + cur + 1, pr.diff, s[r - 1]);
const int steps = min(left_steps, right_steps);
i += steps;
if (i >= pr.len) break;
cur = pr.get(i);
assert(!(s[l] == s[r - cur - 2] && s[l + cur + 1] == s[r - 1]));
to_del.push_back(cur);
i++;
}
}
if (!pref.empty() && pref.back().get_end() == len - 1 &&
!count((to_del).begin(), (to_del).end(), len - 1))
to_del.push_back(len - 1);
del(pref, to_del);
incr_all(pref, 2);
if (len >= 2 && s[l] == s[r - 2] && s[l + 1] == s[r - 1])
add_start(pref, 2);
if (s[l] == s[r - 1]) add_start(pref, 1);
relax(pref);
assert(int((pref).size()) <= 20);
for (const auto &pr : pref) {
int start = len - pr.get_end();
int cur_sum = info.sum(start, pr.diff, pr.len);
add(dp[len], cur_sum);
}
vi allowed;
for (const auto &pr : pref) allowed.push_back(pr.diff);
sort((allowed).begin(), (allowed).end());
allowed.resize(unique((allowed).begin(), (allowed).end()) -
allowed.begin());
info.value[len] = dp[len];
}
cout << dp[n] << endl;
}
int main() {
cin.tie(nullptr);
ios_base::sync_with_stdio(false);
while (read()) {
solve();
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
vector<long long> v(n);
long long i;
for (i = 0; i < n; i++) cin >> v[i];
reverse(v.begin(), v.end());
for (auto it : v) cout << it << " ";
cout << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long pow2(long long base, long long p) {
long long ans = 1;
while (p > 0) {
if (p & 1)
ans = (((ans) % 1000000007) * ((base) % 1000000007)) % 1000000007;
base = (((base) % 1000000007) * ((base) % 1000000007)) % 1000000007;
p = p / 2;
}
return ans;
}
int main() {
long long arr[1000006];
arr[0] = 1;
for (int i = 1; i < 1000006; i++) arr[i] = (arr[i - 1] * i) % 1000000007;
long long a, b, n;
long long ans = 0;
cin >> a >> b >> n;
for (int i = 0; i < n + 1; i++) {
long long sum = a * i + b * (n - i);
long long temp = sum;
long long flag = 1;
while (temp > 0) {
long long dig = temp % 10;
if (dig != a && dig != b) {
flag = 0;
break;
}
temp = temp / 10;
}
if (flag == 1) {
ans = (ans + ((arr[n] % 1000000007) *
(pow2(((arr[i] % 1000000007) * (arr[n - i] % 1000000007)) %
1000000007,
1000000007 - 2)) %
1000000007) %
1000000007) %
1000000007;
}
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bitset<300000000> s;
int l, r;
int main() {
ios::sync_with_stdio(false);
cin >> l >> r;
for (int i = 3; i * i <= r; i += 2) {
if (!s[i])
for (long long j = (long long)i * i; j <= r; j += 2 * i) {
s[j] = 1;
}
}
int ans = (l <= 2) && (r >= 2);
for (int i = 5; i <= r; i += 4) {
if (i >= l && !s[i]) ans++;
}
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, x;
cin >> n;
long long int s = 0;
for (long long int i = 0; i < n; ++i) {
cin >> x;
if (x < 0) x *= -1;
s += x;
}
cout << s << "\n";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 2e9;
const long long INFL = 2e18;
const int N = 1e6, M = N;
int n, m, G = 0;
vector<int> adj[N + 5];
int gr[N + 5], p[N + 5];
vector<int> pth[N + 5];
vector<int> PTH_myEndlessLove;
int Pos[N + 5];
void dfs(int u) {
gr[u] = G;
PTH_myEndlessLove.push_back(u);
for (int i = (0), _b = (((int)(adj[u]).size())); i < _b; ++i) {
int v = adj[u][i];
if (gr[v]) continue;
dfs(v);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m;
for (int i = (1), _b = (n); i <= _b; ++i) cin >> p[i];
int u, v;
while (m--) {
cin >> u >> v;
adj[p[u]].push_back(p[v]);
adj[p[v]].push_back(p[u]);
}
for (int i = (1), _b = (n); i <= _b; ++i)
if (!gr[p[i]]) {
PTH_myEndlessLove.clear();
++G;
dfs(p[i]);
sort(PTH_myEndlessLove.begin(), PTH_myEndlessLove.end());
reverse(PTH_myEndlessLove.begin(), PTH_myEndlessLove.end());
pth[G] = PTH_myEndlessLove;
}
for (int i = (1), _b = (n); i <= _b; ++i) {
cout << pth[gr[p[i]]][Pos[gr[p[i]]]] << ' ';
++Pos[gr[p[i]]];
}
cout << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<int> v(n);
int arr[n + 1];
for (int i = 0; i < n; i++) {
cin >> v[i];
arr[v[i]] = i;
}
vector<pair<int, int>> p;
int l = 0, r = n - 1;
for (int pp = 1; pp <= n; ++pp) {
int i = arr[pp];
int j = pp - 1;
if (i == j)
continue;
else if (abs(i - j) >= n / 2) {
arr[v[i]] = j;
arr[v[j]] = i;
swap(v[i], v[j]);
p.push_back({i + 1, j + 1});
} else {
if (i < n / 2 && j < n / 2) {
int vr = v[r];
int vj = v[j];
swap(v[i], v[r]);
p.push_back({i + 1, r + 1});
swap(v[j], v[r]);
p.push_back({j + 1, r + 1});
arr[vj] = r;
arr[vr] = i;
arr[pp] = j;
} else if (i >= n / 2 && j < n / 2) {
int vr = v[r];
int vj = v[j];
int vl = v[l];
int vi = v[i];
swap(v[l], v[i]);
p.push_back({l + 1, i + 1});
swap(v[r], v[l]);
p.push_back({r + 1, l + 1});
swap(v[j], v[r]);
p.push_back({j + 1, r + 1});
swap(v[i], v[l]);
p.push_back({i + 1, l + 1});
arr[vi] = j;
arr[vr] = i;
arr[vj] = r;
} else {
int vr = v[r];
int vj = v[j];
int vl = v[l];
int vi = v[i];
swap(v[l], v[i]);
p.push_back({l + 1, i + 1});
swap(v[l], v[j]);
p.push_back({l + 1, j + 1});
swap(v[l], v[i]);
p.push_back({l + 1, i + 1});
arr[vi] = j;
arr[vj] = i;
}
}
}
cout << p.size() << endl;
for (auto &x : p) {
cout << x.first << " " << x.second << endl;
}
}
| 4 |
#include <bits/stdc++.h>
const int maxBufSize = (10000000);
using namespace std;
int n;
string str[105];
int main() {
int i, j, a, b, c;
str[0] = "zero";
str[1] = "one";
str[2] = "two";
str[3] = "three";
str[4] = "four";
str[5] = "five";
str[6] = "six";
str[7] = "seven";
str[8] = "eight";
str[9] = "nine";
str[10] = "ten";
str[11] = "eleven";
str[12] = "twelve";
str[13] = "thirteen";
str[14] = "fourteen";
str[15] = "fifteen";
str[16] = "sixteen";
str[17] = "seventeen";
str[18] = "eighteen";
str[19] = "nineteen";
str[20] = "twenty";
str[30] = "thirty";
str[40] = "forty";
str[50] = "fifty";
str[60] = "sixty";
str[70] = "seventy";
str[80] = "eighty";
str[90] = "ninety";
cin >> n;
a = n % 10;
if (n <= 20) {
cout << str[n];
} else if (a == 0) {
cout << str[n];
} else {
b = (n / 10) * 10;
cout << str[b] << "-" << str[a];
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void boost() {
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
}
int main() {
boost();
int n;
cin >> n;
long a[n], b[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
cin >> b[i];
}
vector<long> c(n);
for (int i = 0; i < n; i++) {
c[i] = a[i] - b[i];
}
sort(c.begin(), c.end());
long long count = 0;
for (int i = 0; i < n; i++) {
auto it = upper_bound(c.begin() + i + 1, c.end(), -c[i]);
int d = c.end() - it;
count += d;
}
cout << count;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e9 + 100;
const long double eps = 1e-12;
const long double pi = acos(-1.0L);
int myrand() { return rand(); }
unsigned rdtsc() {
unsigned ans;
asm("rdtsc" : "=a"(ans));
return ans;
}
int rnd(int x) { return myrand() % x; }
void precalc() {}
int n, m;
vector<vector<int> > graph;
vector<vector<int> > t;
vector<int> col;
bool read() {
if (scanf("%d%d", &n, &m) < 2) {
return false;
}
graph = t = vector<vector<int> >(n);
for (int i = 0; i < m; i++) {
int u, v;
char c;
scanf("%d%d %c", &u, &v, &c);
u--, v--;
graph[u].push_back(v);
graph[v].push_back(u);
if (c == 'R') {
t[u].push_back(1);
t[v].push_back(1);
} else {
assert(c == 'B');
t[u].push_back(0);
t[v].push_back(0);
}
}
return true;
}
vector<int> comp[2];
bool ok;
void dfs(int v, int cur) {
if (col[v] != -1) {
if (col[v] != cur) {
ok = false;
}
} else {
col[v] = cur;
comp[cur].push_back(v);
for (int i = 0; i < ((int)((graph[v]).size())); i++) {
dfs(graph[v][i], cur ^ t[v][i]);
}
}
}
void solve() {
int mn = inf;
vector<int> ans;
for (int it = 0; it < 2; it++) {
col = vector<int>(n, -1);
ok = true;
vector<int> curans;
for (int i = 0; i < n; i++) {
if (col[i] == -1) {
comp[0] = comp[1] = vector<int>();
dfs(i, 0);
if (((int)((comp[1]).size())) < ((int)((comp[0]).size()))) {
swap(comp[1], comp[0]);
}
for (int j = 0; j < ((int)((comp[0]).size())); j++) {
curans.push_back(comp[0][j]);
}
}
}
if (ok && ((int)((curans).size())) < mn) {
ans = curans;
mn = ((int)((curans).size()));
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < ((int)((graph[i]).size())); j++) {
t[i][j] ^= 1;
}
}
}
if (mn == inf) {
printf("-1\n");
} else {
printf("%d\n", mn);
for (int i = 0; i < ((int)((ans).size())); i++) {
printf("%d%c", ans[i] + 1, " \n"[i == ((int)((ans).size())) - 1]);
}
}
}
int main() {
srand(rdtsc());
precalc();
while (true) {
if (!read()) {
break;
}
solve();
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma GCC optimize(3)
using namespace std;
int n, k, a[500005], dig[500005], p[50];
const int M = 1000033;
struct HashMap {
int cnt = 0, head[M], to[M], nxt[M];
long long v[M];
bool count(int f) {
int x = f % M;
for (int i = head[x]; i; i = nxt[i]) {
if (to[i] == f) {
return true;
}
}
return false;
}
long long get(int f) {
int x = f % M;
for (int i = head[x]; i; i = nxt[i]) {
if (to[i] == f) {
return v[i];
}
}
return 0;
}
void set(int f, long long val) {
int x = f % M;
to[++cnt] = f;
nxt[cnt] = head[x];
v[cnt] = val;
head[x] = cnt;
}
} mp[11];
inline int get(int x) {
int ans = 0;
while (x) {
ans++;
x /= 10;
}
return ans;
}
int main() {
scanf("%d%d", &n, &k);
for (register int i = 1; i <= n; i++) scanf("%d", a + i);
for (register int i = 1; i <= n; i++) dig[i] = get(a[i]);
p[0] = 1;
for (register int i = 1; i <= 10; i++) p[i] = p[i - 1] * 10ll % k;
for (register int i = 1; i <= n; i++)
for (register int j = 1; j <= 10; ++j)
mp[j].set(1ll * a[i] * p[j] % k, mp[j].get(1ll * a[i] * p[j] % k) + 1);
long long ans = 0;
for (register int i = 1; i <= n; i++) {
register int now = a[i] % k;
register int tmp = mp[dig[i]].get((k - now) % k);
if (tmp) {
ans += tmp;
if ((now * p[dig[i]] % k) == (k - now) % k) ans--;
}
}
printf("%I64d\n", ans);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, y;
scanf("%d%d", &x, &y);
if (x < y) {
printf("-1\n");
return 0;
}
double t1 = (x - y) * 1.0 / 2;
double t2 = (x + y) * 1.0 / 2;
int k1 = floor(t1 / y);
int k2 = floor(t2 / y);
t1 /= k1;
t2 /= k2;
if (t1 < t2)
printf("%.10lf\n", t1);
else
printf("%.10lf\n", t2);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5;
int n, m, upd, c[MAXN + 5], t[MAXN + 5], has[MAXN + 5], cnt[MAXN + 5],
ans[MAXN + 5];
vector<pair<int, int> > adj[MAXN + 5];
vector<pair<int, int> > q[MAXN + 5];
void dfsw(int v, int par) {
for (int i = 0; i < ((int)((adj[v]).size())); i++)
if (adj[v][i].second != par) {
int u = adj[v][i].second;
dfsw(u, v);
adj[v][i].first = t[u];
t[v] += t[u];
}
sort(adj[v].begin(), adj[v].end());
}
void dfsadd(int v) {
has[++cnt[c[v]]]++;
for (int i = 1; i < ((int)((adj[v]).size())); i++) dfsadd(adj[v][i].second);
}
void dfsrem(int v) {
has[cnt[c[v]]]--, cnt[c[v]]--;
for (int i = 1; i < ((int)((adj[v]).size())); i++) dfsrem(adj[v][i].second);
}
void dfsans(int v) {
for (int i = 1; i < ((int)((adj[v]).size())) - 1; i++) {
dfsans(adj[v][i].second);
dfsrem(adj[v][i].second);
}
if (((int)((adj[v]).size())) > 1) dfsans(adj[v].back().second);
has[++cnt[c[v]]]++;
for (int i = 1; i < ((int)((adj[v]).size())) - 1; i++)
dfsadd(adj[v][i].second);
for (int i = 0; i < ((int)((q[v]).size())); i++)
ans[q[v][i].second] = has[q[v][i].first];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> c[i], c[i]--, t[i]++;
adj[0].push_back(make_pair(0, -1));
for (int i = 0, v, u; i < n - 1; i++) {
cin >> v >> u, v--, u--;
adj[v].push_back(make_pair(0, u));
adj[u].push_back(make_pair(0, v));
}
for (int i = 0, v, k; i < m; i++) {
cin >> v >> k, v--;
q[v].push_back(make_pair(k, i));
}
dfsw(0, -1);
dfsans(0);
for (int i = 0; i < m; i++) cout << ans[i] << "\n";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9, mod = 1e9 + 7;
const int N = 1e5 + 5;
int S = 1, t1, t2, n, m, k, x, y, z, size[N], root[N], h[N], sum[N];
long long res[N];
vector<pair<pair<int, int>, pair<int, int> > > edges;
vector<pair<int, int> > v[N];
int findset(int x) {
return root[x] = (root[x] == x) ? root[x] : findset(root[x]);
}
void merge(int x, int y) {
if ((t1 = findset(x)) == (t2 = findset(y))) return;
root[t1] = t2;
size[t2] += size[t1];
size[t1] = 0;
}
int prepare(int node, int last, int col) {
sum[node] = size[node];
for (__typeof(v[node].begin()) it = v[node].begin(); it != v[node].end();
it++)
if (it->first != last) {
sum[node] += prepare(it->first, node, S);
h[it->first] = col;
}
return sum[node];
}
void solve(int node, int last, int all) {
for (__typeof(v[node].begin()) it = v[node].begin(); it != v[node].end();
it++) {
if (it->first == last) continue;
res[it->second] = 2LL * (all - sum[it->first]) * sum[it->first];
solve(it->first, node, all);
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n - 1; i++) {
scanf("%d %d %d", &x, &y, &z);
edges.push_back(make_pair(make_pair(z, i), make_pair(x, y)));
}
sort(edges.begin(), edges.end());
for (int i = 1; i <= n; i++) root[i] = i, size[i] = 1;
for (int i = 0; i <= (int)edges.size() - 1; i++) {
int last = i;
while (i < (int)edges.size() - 1 &&
edges[i + 1].first.first == edges[last].first.first)
i++;
vector<int> temp;
++S;
for (int j = last; j <= i; j++) {
int x = findset(edges[j].second.first);
int y = findset(edges[j].second.second);
temp.push_back(x);
temp.push_back(y);
v[x].push_back(make_pair(y, edges[j].first.second));
v[y].push_back(make_pair(x, edges[j].first.second));
}
sort(temp.begin(), temp.end());
temp.resize(unique(temp.begin(), temp.end()) - temp.begin());
for (__typeof(temp.begin()) it = temp.begin(); it != temp.end(); it++)
if (h[*it] != S) prepare(*it, 0, S);
for (__typeof(temp.begin()) it = temp.begin(); it != temp.end(); it++)
if (h[*it] != S) solve(*it, 0, sum[*it]);
for (__typeof(temp.begin()) it = temp.begin(); it != temp.end(); it++) {
for (__typeof(v[*it].begin()) it2 = v[*it].begin(); it2 != v[*it].end();
it2++)
merge(*it, it2->first);
v[*it].clear();
}
}
long long mx = *max_element(res + 1, res + n), cnt = 0;
for (int i = 1; i <= n - 1; i++) cnt += res[i] == mx;
printf("%lld %lld\n", mx, cnt);
for (int i = 1; i <= n - 1; i++)
if (res[i] == mx) printf("%d ", i);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long Maxn3 = 1e3 + 10;
const long long Maxn4 = 1e4 + 10;
const long long Maxn5 = 1e5 + 10;
const long long Maxn6 = 1e6 + 10;
const long long Maxn7 = 1e7 + 10;
const long long Maxn8 = 1e8 + 10;
const long long Maxn9 = 1e9 + 10;
const long long Maxn18 = 1e18 + 10;
const long long Mod1 = 1e7 + 7;
const long long Mod2 = 1e9 + 7;
int main() {
std::ios_base::Init i;
std::ios_base::sync_with_stdio(false);
std::cin.tie(0);
long long l1, r1, l2, r2, k, ans = 0;
cin >> l1 >> r1 >> l2 >> r2 >> k;
long long a = min(r1, r2), b = max(l1, l2);
ans = a - b + 1;
if (k >= b and k <= a) ans -= 1;
if (ans >= 0)
return cout << ans << endl, 0;
else
return cout << 0 << endl, 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long M = 1005, X = 143, MOD = 12345;
long long n, m, mul[M], t[32], cc, ansi, flag;
bool mark[X], mm[32][X];
char c[M];
vector<long long> v, w[X], z;
map<vector<long long>, long long> mapi;
struct matrix {
long long a[X][X];
matrix() {
for (int i = 1; i <= 130; i++) {
for (int j = 1; j <= 130; j++) {
a[i][j] = 0;
}
}
}
matrix operator*(matrix b) {
matrix c;
for (int i = 1; i <= cc; i++) {
for (int j = 1; j <= cc; j++) {
for (int k = 1; k <= cc; k++) {
c.a[i][j] = (c.a[i][j] + a[i][k] * b.a[k][j]) % MOD;
}
}
}
return c;
}
};
matrix p, ans;
void make(long long x) {
if (x > 25) {
cc++;
mapi[v] = cc;
w[cc] = v;
return;
}
if (!t[x]) {
v.push_back(0);
make(x + 1);
v.pop_back();
return;
}
for (int i = 0; i < t[x]; i++) {
v.push_back(i);
make(x + 1);
v.pop_back();
}
}
matrix pow(matrix x, long long r) {
if (r == 1) return x;
matrix y = pow(x, r / 2);
y = y * y;
if (r % 2) y = y * x;
return y;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> m;
if (!n) {
cout << 1 << endl;
return 0;
}
for (int i = 1; i <= m; i++) {
cin >> c[i] >> mul[i];
if (t[c[i] - 'A']) {
t[c[i] - 'A'] *= mul[i];
} else {
t[c[i] - 'A'] = mul[i];
}
}
for (int i = 1; i <= m; i++) {
for (int j = 0; j < t[c[i] - 'A']; j += mul[i]) {
mm[c[i] - 'A'][j] = 1;
}
}
make(0);
for (int i = 1; i <= cc; i++) {
flag = 1;
for (int j = 0; j < 26; j++) {
if (t[j] && !mm[j][w[i][j]]) {
flag = 0;
break;
}
}
mark[i] = flag;
for (int j = 0; j < 26; j++) {
if (t[j]) {
z = w[i];
z[j] = (w[i][j] + 1) % t[j];
p.a[i][mapi[z]]++;
}
}
}
ans = pow(p, n);
for (int i = 1; i <= cc; i++) {
if (mark[i]) {
ansi = (ansi + ans.a[1][i]) % MOD;
}
}
cout << ansi << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k, b, c;
cin >> k >> b >> c;
if (c > b) swap(b, c);
if (c / k == 0 & b % k != 0)
printf("%d\n", -1);
else
printf("%d\n", b / k + c / k);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
long long dp[maxn][1 << 7];
int s[maxn][7];
int a[maxn], id[maxn];
bool cmp(int x, int y) { return a[x] > a[y]; }
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, p, K;
cin >> n >> p >> K;
for (int i = 1; i <= n; i++) id[i] = i, cin >> a[i];
for (int i = 1; i <= n; i++) {
for (int j = 0; j < p; j++) {
cin >> s[i][j];
}
}
sort(id + 1, id + n + 1, cmp);
for (int i = 1; i <= n; i++) {
int x = id[i];
for (int j = 0; j < (1 << p); j++) {
int cnt = i - 1 - __builtin_popcount(j);
if (cnt >= 0 && cnt < K)
dp[i][j] = dp[i - 1][j] + a[x];
else
dp[i][j] = dp[i - 1][j];
for (int k = 0; k < p; k++) {
if (!(j & (1 << k))) continue;
dp[i][j] = max(dp[i][j], dp[i - 1][j ^ (1 << k)] + s[x][k]);
}
}
}
cout << dp[n][(1 << p) - 1] << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long MAX = 1e18 + 10;
long long n, a, b;
long long x[1000100], f[1000100], g[1000100];
vector<long long> prime;
bool isprime[1000100];
set<long long> s;
void getPrime() {
int i, j;
for (i = 0; i < 1000100; i++) isprime[i] = true;
isprime[0] = isprime[1] = 0;
for (i = 2; i < 1000100; i++) {
if (!isprime[i]) continue;
for (j = 2 * i; j < 1000100; j += i) isprime[j] = false;
}
prime.clear();
for (i = 2; i < 1000100; i++) prime.push_back(i);
}
long long change(long long a, long long p) {
if (a % p == 0) return 0;
if ((a + 1) % p == 0 || (a - 1) % p == 0) return b;
return -1;
}
long long Solve(long long p) {
int L = n + 1, R = 0, i, tag = 0;
long long t, G, res;
f[0] = 0;
for (i = 1; i <= n; i++) {
t = change(x[i], p);
if (t == -1) {
L = i;
tag = 1;
}
if (tag)
f[i] = MAX;
else
f[i] = f[i - 1] + t;
}
g[n + 1] = 0;
tag = 0;
for (i = n; i > 0; i--) {
t = change(x[i], p);
if (t == -1) {
R = i;
tag = 1;
}
if (tag)
g[i] = MAX;
else
g[i] = g[i + 1] + t;
}
G = g[n + 1] + (n + 1) * a;
res = f[n];
for (i = n; i >= 0; i--) {
res = min(res, f[i] - (i + 1) * a + G);
G = min(G, g[i] + i * a);
}
return res;
}
void Get(long long a) {
if (a == 0 || a == 1) return;
int i, l = prime.size(), t;
for (i = 0; i < l; i++) {
t = prime[i];
if (t * t > a) break;
while (a % t == 0) {
if (s.find(t) == s.end()) s.insert(t);
a /= t;
}
}
if (a > 1) s.insert(a);
}
void Init() {
s.clear();
Get(x[1]);
Get(x[1] + 1);
Get(x[1] - 1);
Get(x[n]);
Get(x[n] + 1);
Get(x[n] - 1);
}
int main() {
int i, j;
long long ans;
set<long long>::iterator it;
getPrime();
scanf("%I64d%I64d%I64d", &n, &a, &b);
for (i = 1; i <= n; i++) scanf("%I64d", &x[i]);
Init();
ans = MAX;
for (it = s.begin(); it != s.end(); it++) ans = min(ans, Solve(*it));
printf("%I64d", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
const int MXN = 1e6 + 1;
const int INF = 1e9 + 7;
const int N = 1e3 + 1;
using namespace std;
long long int a, b, s, x, y;
int main() {
ios_base ::sync_with_stdio(0);
cin >> a >> b >> s;
if (abs(a) + abs(b) == s) {
cout << "Yes";
return 0;
}
if (abs(a) + abs(b) > s) {
cout << "No";
return 0;
}
s -= (abs(a) + abs(b));
if (s % 2 == 0) {
cout << "Yes";
} else {
cout << "No";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, r;
scanf("%d%d", &n, &r);
vector<double> c(1 << n);
double s = 0.0;
for (int i = 0; i < (1 << n); i++) {
scanf("%lf", &c[i]);
s += c[i];
}
double p = pow(2.0, n);
printf("%.7lf\n", s / p);
while (r--) {
int x;
double g;
scanf("%d%lf", &x, &g);
s += g - c[x];
c[x] = g;
printf("%.7lf\n", s / p);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
typedef struct point {
int x, y;
point(){};
point(int a, int b) {
x = a;
y = b;
}
} point;
int X[] = {0, 1, -1, 0, -1, 1, -1, 1};
int Y[] = {1, 0, 0, -1, -1, 1, 1, -1};
string inttostr(int num) {
string res;
stringstream s;
s << num;
s >> res;
return res;
}
vector<int> extract_int(string str) {
stringstream s;
s << str;
vector<int> res;
int num = -1;
while ((s >> num)) res.push_back(num);
return res;
}
int n;
int friends[2001][2001];
int non_friends[2001][2001];
int vis[2001];
bool is_valid(vector<int> s) {
for (int i = 0; i < s.size(); i++)
for (int j = 0; j < s.size(); j++)
if (non_friends[s[i]][s[j]] || non_friends[s[j]][s[i]]) return false;
return true;
}
void find_sol(int indx, vector<int> &f) {
if (vis[indx]) return;
f.push_back(indx);
vis[indx] = 1;
for (int i = 1; i <= n; i++)
if (friends[indx][i] || friends[i][indx]) find_sol(i, f);
}
int main() {
int n, m, c, i, j;
cin >> n >> m >> c;
int a[n], b[m];
for (i = 0; i < n; i++) cin >> a[i];
for (i = 0; i < m; i++) cin >> b[i];
int indx = 0;
for (i = 0; i <= (n - m); i++) {
for (j = i; j < i + m; j++, indx++) {
a[j] += b[indx % m];
a[j] %= c;
}
}
for (i = 0; i < n; i++) {
cout << a[i] << " ";
}
cout << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long MAX = 1e6 + 5;
long long n, m, i, j, k = 0, cou = 0, F, o, z;
string s;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
char c;
cin >> n;
for (i = 0; i < n; i++) {
cin >> c;
if (c == '1') {
o++;
} else {
z++;
}
}
cout << max(o, z) - min(o, z);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 10005;
const int inf = 1e9;
const int mod = 1e9;
const int base = 1000 * 1000 * 1000;
struct tp {
pair<int, string> first, second, th;
};
int n, m, a, b;
string s;
tp p[N];
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> s >> a >> b;
if (p[a].first.first <= b) {
p[a].th.first = p[a].second.first, p[a].th.second = p[a].second.second;
p[a].second.first = p[a].first.first,
p[a].second.second = p[a].first.second;
p[a].first.first = b, p[a].first.second = s;
} else if (p[a].second.first <= b) {
p[a].th.first = p[a].second.first, p[a].th.second = p[a].second.second;
p[a].second.first = b, p[a].second.second = s;
} else if (p[a].th.first <= b) {
p[a].th.first = b, p[a].th.second = s;
}
}
for (int i = 1; i <= m; i++) {
if (p[i].second.first == p[i].th.first && p[i].th.second.size() > 0)
cout << "?" << endl;
else {
cout << p[i].first.second << " " << p[i].second.second << endl;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;
int n, stick[maxn], ans[4], tmp[maxn];
int main() {
int t, i, j, k, cnt = 0, flag, a, b;
double aans, tt;
cin >> t;
while (t--) {
cin >> n;
flag = cnt = 0;
aans = 1e18;
for (i = 1; i <= n; i++) scanf("%d", tmp + i);
sort(tmp + 1, tmp + n + 1);
for (i = 1; i <= n; i++) {
if (i >= 4 && tmp[i] == tmp[i - 1] && tmp[i - 1] == tmp[i - 2] &&
tmp[i - 2] == tmp[i - 3]) {
flag = 1;
ans[1] = tmp[i];
break;
} else if (i >= 3 && tmp[i] == tmp[i - 1] && tmp[i] != tmp[i - 2] ||
i < 3 && tmp[i] == tmp[i - 1])
stick[++cnt] = tmp[i];
}
if (flag) {
cout << ans[1] << " " << ans[1] << " " << ans[1] << " " << ans[1] << endl;
continue;
}
ans[1] = stick[1];
ans[2] = stick[2];
for (i = 3; i <= cnt; i++) {
if (stick[i] * ans[1] < stick[i - 1] * ans[2]) {
ans[2] = stick[i];
ans[1] = stick[i - 1];
}
}
cout << ans[1] << " " << ans[1] << " " << ans[2] << " " << ans[2] << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
long long int c[n + 1], top[4] = {0};
memset(top, 0, sizeof top);
bool avail[n + 1];
vector<pair<long long int, int> > a[4];
for (int i = (0); i < (int)n; i++) {
cin >> c[i];
avail[i] = 1;
}
int g;
for (int i = (0); i < (int)n; i++) {
cin >> g;
a[g].push_back(make_pair(c[i], i));
}
for (int i = (0); i < (int)n; i++) {
cin >> g;
a[g].push_back(make_pair(c[i], i));
}
for (int i = (1); i < (int)4; i++) sort(a[i].begin(), a[i].end());
long long int m;
cin >> m;
for (int i = (0); i < (int)m; i++) {
cin >> g;
pair<long long int, int> ag;
while (top[g] < a[g].size() and avail[a[g][top[g]].second] != 1)
top[g] += 1;
if (top[g] == a[g].size()) {
cout << -1 << " ";
continue;
}
ag = a[g][top[g]];
avail[ag.second] = 0;
cout << ag.first << " ";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
const long long maxn = 1005;
long long n, m, base, k, ansx, ansy, anss;
long long a[maxn][maxn], line[maxn][maxn], sum1[maxn << 1][maxn],
sum2[maxn << 1][maxn];
long long lft[maxn][maxn], rgt[maxn][maxn], ans[maxn][maxn];
inline long long max(long long a, long long b) { return a > b ? a : b; }
inline long long getlinesum(long long x, long long l, long long r) {
return l > r ? 0 : line[x][r] - line[x][l - 1];
}
inline long long getsum1(long long x, long long l, long long r) {
return l > r ? 0 : sum1[x][r] - sum1[x][l - 1];
}
inline long long getsum2(long long x, long long l, long long r) {
return l > r ? 0 : sum2[base + x][r] - sum2[base + x][l - 1];
}
signed main() {
scanf("%lld%lld%lld", &n, &m, &k), base = max(n, m);
for (long long i = 1; i <= n; i++)
for (long long j = 1; j <= m; j++) scanf("%lld", &a[i][j]);
for (long long i = 1; i <= m; i++)
for (long long j = 1; j <= n; j++) line[i][j] = line[i][j - 1] + a[j][i];
for (long long i = 1; i <= n + m; i++)
for (long long j = 1; j <= n; j++)
sum1[i][j] =
sum1[i][j - 1] + (i - j >= 1 && i - j <= m ? a[j][i - j] : 0);
for (long long i = -base; i <= base; i++)
for (long long j = 1; j <= n; j++)
sum2[base + i][j] =
sum2[base + i][j - 1] + (i + j >= 1 && i + j <= m ? a[j][i + j] : 0);
for (long long i = k; i <= n - k + 1; i++) {
for (long long j = 1; j <= k; j++)
lft[i][k] += getlinesum(j, i - j + 1, i + j - 1);
for (long long j = k + 1; j <= m; j++)
lft[i][j] = lft[i][j - 1] + getlinesum(j, i - k + 1, i + k - 1) -
getsum1((i - k + 1) + (j - 1), i - k + 1, i) -
getsum2((j - 1) - (i + k - 1), i + 1, i + k - 1);
for (long long j = m; j >= m - k + 1; j--)
rgt[i][m - k + 1] +=
getlinesum(j, i - (m - j + 1) + 1, i + (m - j + 1) - 1);
for (long long j = m - k; j >= 1; j--)
rgt[i][j] = rgt[i][j + 1] + getlinesum(j, i - k + 1, i + k - 1) -
getsum1((i + k - 1) + (j + 1), i, i + k - 1) -
getsum2((j + 1) - (i - k + 1), i - k + 1, i - 1);
}
anss = -1;
for (long long i = k; i <= n - k + 1; i++) {
for (long long j = 0; j < k; j++)
ans[i][k] += (k - j) * (getsum1((i - j) + k, i - j, i) +
getsum1((i + j) + k, i, i + j - 1) +
getsum2((k - j) - i, i + 1, i + j) +
getsum2((k + j) - i, i - j + 1, i - 1));
for (long long j = k + 1; j <= m - k + 1; j++)
ans[i][j] = ans[i][j - 1] + rgt[i][j] - lft[i][j - 1];
for (long long j = k; j <= m - k + 1; j++)
if (ans[i][j] > anss) anss = ans[i][j], ansx = i, ansy = j;
}
printf("%lld %lld\n", ansx, ansy);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
vector<long long> d(200010, 0);
int main() {
long long n;
cin >> n;
long long ans = n;
for (long long i = 0; i < n - 1; i++) {
long long u, v;
cin >> u >> v;
ans = (ans * (++d[u]) % mod * (++d[v]) % mod) % mod;
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
char s[200000], t[200000];
int poz1[200000], poz2[200000], n1, n2, j;
int main() {
cin >> (s + 1);
cin >> (t + 1);
n1 = strlen(s + 1), n2 = strlen(t + 1);
for (int i = 1, j = 1; i <= n2; ++j)
if (s[j] == t[i]) poz1[i] = j, ++i;
for (int i = n2, j = n1; i >= 1; --j)
if (s[j] == t[i]) poz2[i] = j, --i;
int ans = n1 - poz1[n2];
ans = max(ans, poz2[1] - 1);
for (int i = 1; i < n2; ++i)
ans = max(ans, abs(poz2[i + 1] - poz1[i] - 1)),
ans = max(ans, abs(poz2[i + 1] - poz2[i] - 1)),
ans = max(ans, abs(poz1[i + 1] - poz1[i] - 1));
cout << ans << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int a, long long int b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
int main() {
ios_base::sync_with_stdio(false);
long long int x, y;
cin >> x >> y;
vector<pair<char, long long int> > v;
while (x > 1 or y > 1) {
if (gcd(x, y) > 1) {
cout << "Impossible" << endl;
return 0;
}
if (x > y) {
long long int k = x / y - 1;
if (x - k * y > y) ++k;
v.push_back(make_pair('A', k));
x -= y * k;
} else {
long long int k = y / x - 1;
if (y - k * x > x) ++k;
v.push_back(make_pair('B', k));
y -= x * k;
}
}
for (int i = 0; i < v.size(); ++i) {
cout << v[i].second << v[i].first;
}
cout << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
inline char gc() {
static char buf[100000], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? EOF
: *p1++;
}
inline long long read() {
long long x = 0;
char ch = getchar();
bool positive = 1;
for (; !isdigit(ch); ch = getchar())
if (ch == '-') positive = 0;
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - '0';
return positive ? x : -x;
}
inline void write(long long a) {
if (a < 0) {
a = -a;
putchar('-');
}
if (a >= 10) write(a / 10);
putchar('0' + a % 10);
}
inline void writeln(long long a) {
write(a);
puts("");
}
inline void wri(long long a) {
write(a);
putchar(' ');
}
inline unsigned long long rnd() {
return ((unsigned long long)rand() << 30 ^ rand()) << 4 | rand() % 4;
}
const int N = 120005, block = 300, B = N / block + 3, inf = 1000000005;
int n, q, a[N], belong[N], mzs[N], p[N], l[N], r[N], q1[N], q2[N], t1, t2,
val[N], cnt[B], lazy[B], L[B], R[B];
pair<int, int> mn[N];
long long ans[N];
pair<int, int> operator+(pair<int, int> a, pair<int, int> b) {
if (a.second == 0)
return b;
else if (b.second == 0)
return a;
return a.first == b.first ? make_pair(a.first, a.second + b.second)
: (a.first > b.first ? a : b);
}
void bao(int l, int r, int x) {
int id = belong[l];
for (int i = l; i <= r; i++) a[i] += x;
mn[id] = make_pair(inf, 0);
for (int i = L[id]; i <= R[id]; i++) mn[id] = mn[id] + make_pair(a[i], 1);
}
void down(int x) {
if (!mzs[x]) return;
for (int i = L[x]; i <= R[x]; i++)
if (a[i] == mn[x].first) {
val[i] += mzs[x];
}
mzs[x] = 0;
}
void ins(int l, int r, int x) {
if (l > r) return;
if (belong[l] == belong[r]) {
down(belong[l]);
bao(l, r, x);
return;
}
down(belong[l]);
bao(l, R[belong[l]], x);
down(belong[r]);
bao(L[belong[r]], r, x);
for (int i = belong[l] + 1; i < belong[r]; i++) lazy[i] += x;
}
void upd() {
for (int i = 1; i <= belong[n]; i++)
if (mn[i].first + lazy[i] == 0) {
mzs[i]++;
cnt[i] += mn[i].second;
}
}
long long ask(int l) {
long long ans = 0;
down(belong[l]);
for (int i = l; i <= R[belong[l]]; i++) ans += val[i];
for (int i = belong[l] + 1; i <= belong[n]; i++) ans += cnt[i];
return ans;
}
vector<int> v[N];
int main() {
n = read();
for (int i = 1; i <= n; i++) {
p[i] = read();
if ((i - 1) % block == 0)
L[belong[i] = belong[i - 1] + 1] = i;
else
belong[i] = belong[i - 1];
R[belong[i]] = i;
a[i] = -1;
mn[belong[i]] = mn[belong[i]] + make_pair(-1, 1);
}
q = read();
for (int i = 1; i <= q; i++) {
l[i] = read();
r[i] = read();
v[r[i]].push_back(i);
}
for (int i = 1; i <= n; i++) {
while (p[q1[t1]] < p[i] && t1) {
ins(q1[t1 - 1] + 1, q1[t1], -p[i] + p[q1[t1]]);
t1--;
}
q1[++t1] = i;
while (p[q2[t2]] > p[i] && t2) {
ins(q2[t2 - 1] + 1, q2[t2], p[i] - p[q2[t2]]);
t2--;
}
q2[++t2] = i;
ins(1, i, 1);
upd();
for (unsigned j = 0; j < v[i].size(); j++) ans[v[i][j]] = ask(l[v[i][j]]);
}
for (int i = 1; i <= q; i++) writeln(ans[i]);
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int num[101000];
int main() {
int n;
scanf("%d", &n);
int sum = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &num[i]);
sum += num[i];
}
sort(num, num + n);
int k = 0;
for (int i = 0; i < n; i++) {
k += num[i];
if (k > (sum + 1) / 2) {
k -= num[i];
break;
}
}
printf("%d", sum - k - k + 1);
return 0;
}
| 1 |
#include <bits/stdc++.h>
int main(void) {
int n = 500;
printf("%d\n", n);
printf("0 500000\n");
int x = 300000;
for (int r = n - 2; r >= 1; r--) {
x += r;
printf("%d %d\n", x, r);
x += r;
}
printf("1000000 1000000\n");
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16000000")
using namespace std;
const int Maxn = 100005;
const long long Inf = 1000000000000000000ll;
int n, m, q;
int c[Maxn];
vector<int> neigh[Maxn];
vector<int> inCity[Maxn];
int cur, lef[Maxn], rig[Maxn], cnt[Maxn];
int my[Maxn], L[Maxn], P[Maxn], ind[Maxn];
vector<int> seq[Maxn];
long long BIT[Maxn];
struct segtree {
vector<pair<long long, long long> > st;
vector<long long> add;
vector<long long> BIT;
int n;
segtree(int gn = 1) {
n = gn;
int m = 1;
while (m <= 4 * n) m *= 2;
st.resize(m);
add.resize(m);
BIT.resize(n, 0);
}
void Create(int v, int l, int r, const vector<int> &V) {
if (l == r)
if (inCity[V[l]].empty()) {
st[v] = pair<long long, long long>(Inf, -1);
add[v] = Inf;
} else {
st[v] = pair<long long, long long>(inCity[V[l]].back(), V[l]);
add[v] = inCity[V[l]].back();
}
else {
int m = l + r >> 1;
Create(2 * v, l, m, V);
Create(2 * v + 1, m + 1, r, V);
st[v] = min(st[2 * v], st[2 * v + 1]);
add[v] = 0;
}
}
void Create(const vector<int> &V) { Create(1, 0, n - 1, V); }
pair<long long, long long> getBest(int v, int l, int r, int a, int b) {
if (l == a && r == b)
return st[v];
else {
int m = l + r >> 1;
pair<long long, long long> res;
if (b <= m)
res = getBest(2 * v, l, m, a, b);
else if (m + 1 <= a)
res = getBest(2 * v + 1, m + 1, r, a, b);
else
res = min(getBest(2 * v, l, m, a, m),
getBest(2 * v + 1, m + 1, r, m + 1, b));
res.first += add[v];
return res;
}
}
pair<long long, long long> getBest(int a, int b) {
pair<long long, long long> best = getBest(1, 0, n - 1, a, b);
if (best.second != -1) best.first += getBIT(ind[best.second]);
return best;
}
void Remove(int v, int l, int r, int city) {
if (l == r) {
add[v] -= inCity[city].back();
inCity[city].pop_back();
if (inCity[city].empty()) {
st[v] = pair<long long, long long>(Inf, -1);
add[v] = Inf;
} else {
add[v] += inCity[city].back();
st[v] = pair<long long, long long>(add[v], city);
}
} else {
int m = l + r >> 1;
if (ind[city] <= m)
Remove(2 * v, l, m, city);
else
Remove(2 * v + 1, m + 1, r, city);
st[v] = min(st[2 * v], st[2 * v + 1]);
st[v].first += add[v];
}
}
void Remove(int city) { Remove(1, 0, n - 1, city); }
void Update(int v, int l, int r, int a, int b, int val) {
if (l == a && r == b) {
st[v].first += val;
add[v] += val;
} else {
int m = l + r >> 1;
if (a <= m) Update(2 * v, l, m, a, min(m, b), val);
if (m + 1 <= b) Update(2 * v + 1, m + 1, r, max(m + 1, a), b, val);
st[v] = min(st[2 * v], st[2 * v + 1]);
st[v].first += add[v];
}
}
void Update(int ind, int val) {
Update(1, 0, n - 1, ind, n - 1, val);
ind++;
for (int i = ind; i <= n; i += i & -i) BIT[i - 1] -= val;
}
long long getBIT(int ind) {
long long res = 0ll;
ind++;
for (int i = ind; i > 0; i -= i & -i) res += BIT[i - 1];
return res;
}
};
segtree S[Maxn];
void Traverse1(int v) {
lef[v] = ++cur;
cnt[v] = 1;
for (int i = 0; i < neigh[v].size(); i++) {
int u = neigh[v][i];
if (P[v] == u) continue;
P[u] = v;
L[u] = L[v] + 1;
Traverse1(u);
cnt[v] += cnt[u];
}
rig[v] = cur;
}
void Traverse2(int v, int myp) {
my[v] = myp;
ind[v] = seq[myp].size();
seq[myp].push_back(v);
bool was = false;
for (int i = 0; i < neigh[v].size(); i++) {
int u = neigh[v][i];
if (P[v] == u) continue;
if (cnt[u] > cnt[v] / 2) {
Traverse2(u, myp);
was = true;
} else
Traverse2(u, u);
}
if (!was) {
S[myp] = segtree(seq[myp].size());
S[myp].Create(seq[myp]);
}
}
void Insert(int x, long long val) {
for (int i = x; i <= n; i += i & -i) BIT[i] += val;
}
long long Get(int x) {
long long res = 0;
for (int i = x; i > 0; i -= i & -i) res += BIT[i];
return res;
}
pair<long long, long long> getBest(int v, int u) {
pair<long long, long long> got = pair<long long, long long>(Inf, -1);
while (my[v] != my[u])
if (L[my[v]] >= L[my[u]]) {
pair<long long, long long> cand = S[my[v]].getBest(0, ind[v]);
if (cand.second != -1) cand.first += Get(lef[cand.second]);
got = min(got, cand);
v = P[my[v]];
} else {
pair<long long, long long> cand = S[my[u]].getBest(0, ind[u]);
if (cand.second != -1) cand.first += Get(lef[cand.second]);
got = min(got, cand);
u = P[my[u]];
}
int l = min(ind[v], ind[u]), r = max(ind[v], ind[u]);
pair<long long, long long> cand = S[my[v]].getBest(l, r);
if (cand.second != -1) cand.first += Get(lef[cand.second]);
got = min(got, cand);
return got;
}
int main() {
scanf("%d %d %d", &n, &m, &q);
for (int i = 0; i < n - 1; i++) {
int a, b;
scanf("%d %d", &a, &b);
neigh[a].push_back(b);
neigh[b].push_back(a);
}
for (int i = 1; i <= m; i++) {
int c;
scanf("%d", &c);
inCity[c].push_back(i);
}
for (int i = 1; i <= n; i++) sort(inCity[i].rbegin(), inCity[i].rend());
Traverse1(1);
Traverse2(1, 1);
while (q--) {
int t;
scanf("%d", &t);
if (t == 1) {
int v, u, k;
scanf("%d %d %d", &v, &u, &k);
vector<int> inv;
while (k--) {
pair<long long, long long> b = getBest(v, u);
if (b.second == -1) break;
inv.push_back(inCity[b.second].back());
S[my[b.second]].Remove(b.second);
}
printf("%d", inv.size());
for (int i = 0; i < inv.size(); i++) printf(" %d", inv[i]);
printf("\n");
} else {
int v, k;
scanf("%d %d", &v, &k);
Insert(lef[v], k);
Insert(rig[v] + 1, -k);
S[my[v]].Update(ind[v], k);
}
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int dig(int m, int n) {
set<int> a;
while (m) {
a.insert(m % 10);
m = m / 10;
}
while (n) {
int x = n % 10;
if (a.find(x) != a.end()) return 1;
n = n / 10;
}
return 0;
}
int main() {
int n, ans = 0;
cin >> n;
for (int i = 1; i * i <= n; i++) {
if (n % i == 0) {
int y = n / i;
if (dig(i, n)) ans++;
if (y != i)
if (dig(y, n)) ans++;
}
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, k, num, color = 1;
vector<int> ans(5e3 + 3);
map<int, vector<int> > m;
int main(void) {
ios ::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; ++i) {
cin >> num;
m[num].emplace_back(i);
}
for (auto p : m) {
if (p.second.size() > k) {
cout << "NO"
<< "\n";
return 0;
}
for (int num : p.second) {
ans[num] = color;
++color;
if (color == k + 1) {
color = 1;
}
}
}
cout << "YES"
<< "\n";
for (int i = 1; i <= n; ++i) {
cout << ans[i] << " \n"[i == n];
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int INF = 1e9;
const int N = 1e5 + 5;
inline long long pow_mod(long long x, long long n) {
long long r = 1;
while (n) {
if (n & 1) r = (r * x) % MOD;
x = (x * x) % MOD;
n >>= 1;
}
return r;
}
inline long long pow_(long long x, long long n) {
long long r = 1;
while (n) {
if (n & 1) r = (r * x);
x = (x * x);
n >>= 1;
}
return r;
}
inline void solve() {
int n;
cin >> n;
int l[n];
for (int i = 0; i < n; i++) cin >> l[i];
int r[n];
for (int i = 0; i < n; i++) cin >> r[i];
int ans[n];
for (int i = 0; i < n; i++) ans[i] = n - (l[i] + r[i]);
for (int i = 0; i < n; i++) {
for (int j = i - 1; j >= 0; j--)
if (ans[i] < ans[j]) l[i]--;
if (l[i]) {
cout << "NO\n";
return;
}
for (int j = i + 1; j < n; j++)
if (ans[i] < ans[j]) r[i]--;
if (r[i]) {
cout << "NO\n";
return;
}
}
cout << "YES\n";
for (int &x : ans) cout << x << ' ';
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int t = 1;
while (t--) solve();
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5;
const long long M = 1e4;
const long long inf = 2e18;
inline long long read() {
long long s = 0;
register bool neg = 0;
register char c = getchar();
for (; c < '0' || c > '9'; c = getchar()) neg |= (c == '-');
for (; c >= '0' && c <= '9'; s = s * 10 + (c ^ 48), c = getchar())
;
s = (neg ? -s : s);
return s;
}
long long t, a, tmp[N + 5], sa[N + 5], rk[N + 5], h[N + 5], cnt[N + 5], p, q,
L[N + 5], sk[N + 5], r, _h[N + 5], re[N + 5];
char s[N + 5];
void init() {
p = 127;
for (long long i = (1); i <= (p); ++i) cnt[i] = 0;
for (long long i = (1); i <= (a); ++i) cnt[rk[i] = s[i]]++;
for (long long i = (1); i <= (p); ++i) cnt[i] += cnt[i - 1];
for (long long i = (1); i <= (a); ++i) sa[cnt[rk[i]]--] = i;
for (long long i = 1;; i <<= 1, p = q) {
q = 0;
for (long long j = (a - i + 1); j <= (a); ++j) tmp[++q] = j;
for (long long j = (1); j <= (a); ++j)
if (sa[j] > i) tmp[++q] = sa[j] - i;
for (long long j = (1); j <= (p); ++j) cnt[j] = 0;
for (long long j = (1); j <= (a); ++j) cnt[rk[j]]++;
for (long long j = (1); j <= (p); ++j) cnt[j] += cnt[j - 1];
for (long long j = (a); j >= (1); --j)
sa[cnt[rk[tmp[j]]]--] = tmp[j], tmp[j] = 0;
swap(tmp, rk);
q = 1;
rk[sa[1]] = 1;
for (long long j = (2); j <= (a); ++j)
rk[sa[j]] =
(tmp[sa[j]] == tmp[sa[j - 1]] && tmp[sa[j] + i] == tmp[sa[j - 1] + i])
? q
: ++q;
if (q == a) break;
}
for (long long i = (1); i <= (a); ++i) sa[rk[i]] = i;
p = 0;
for (long long j = (1); j <= (a); ++j) {
if (p) --p;
while (s[j + p] == s[sa[rk[j] - 1] + p]) ++p;
h[j] = p;
}
for (long long i = (1); i <= (a); ++i) _h[rk[i]] = h[i];
}
signed main() {
t = read();
while (t--) {
memset(L, 0, sizeof(L));
scanf("%s", s + 1);
a = strlen(s + 1);
init();
long long ans = 0, o = 0, lst = 0;
r = 0;
for (long long i = (1); i <= (a); ++i) {
re[i] = i;
while (r && _h[sk[r]] > _h[i]) {
o += (i - re[L[sk[r]]]) * (_h[sk[r]] - max(_h[i], _h[L[sk[r]]]));
ans += (i - re[L[sk[r]]]) * (i - re[L[sk[r]]]) *
(_h[sk[r]] - max(_h[i], _h[L[sk[r]]]));
r--;
}
if (r && _h[sk[r]] == _h[i]) {
re[sk[r]] = i;
continue;
}
if (r)
L[i] = sk[r];
else
L[i] = lst;
if (_h[i])
sk[++r] = i;
else
lst = i;
}
while (r) {
ans += (a - re[L[sk[r]]] + 1) * (a - re[L[sk[r]]] + 1) *
(_h[sk[r]] - _h[sk[r - 1]]);
o += (a - re[L[sk[r]]] + 1) * (_h[sk[r]] - _h[sk[r - 1]]);
r--;
}
ans += a * (a + 1) / 2 - o;
printf("%lld\n", ans);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long n, s;
bool check(long long x) {
long long y = x;
long long dem = 0;
while (x != 0) {
dem += x % 10;
x /= 10;
}
return (y - dem >= s);
}
int main() {
cin >> n >> s;
long long l = 0, r = n + 1;
while (r - l > 1) {
long long mid = (r + l) >> 1;
if (check(mid))
r = mid;
else
l = mid;
}
cout << n - r + 1;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int ar[n];
for (int i = 0; i < n; i++) cin >> ar[i];
sort(ar, ar + n);
for (int i = n - 1; i >= 0; i--) cout << ar[i] << " ";
cout << "\n";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
long long ans = 0;
for (int i = (0); i < (n); ++i) {
long long t, T, x, cost;
cin >> t >> T >> x >> cost;
if (t >= T) {
ans += cost + m * x;
continue;
}
long long aux1 = cost;
if (m > (T - t)) aux1 += m * x;
long long aux2 = (long long)ceil((double)(m - (T - t)) / (T - t)) + 1;
aux2 *= cost;
ans += min(aux1, aux2);
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const int mn = 5e3 + 10;
long long po(long long a, long long b = mod - 2) {
long long ans = 1;
for (; b; b >>= 1, a *= a, a %= mod)
if (b & 1) ans *= a, ans %= mod;
return ans;
}
long long fact[mn];
long long ch(long long a, long long b) {
return fact[a] * po(fact[b] * fact[a - b] % mod) % mod;
}
long long dp[mn][mn];
long long cp[26][mn];
int main() {
cin.tie(0);
cin.sync_with_stdio(0);
fact[0] = 1;
for (int i = 1; i < mn; i++) fact[i] = fact[i - 1] * i % mod;
int n;
cin >> n;
string s;
cin >> s;
s.erase(unique(s.begin(), s.end()), s.end());
for (char& c : s) c -= 'a';
s = " " + s;
dp[0][0] = 1;
for (int i = 1; i < s.size(); i++) {
for (int j = 1; j <= n; j++) dp[i][j] = dp[i - 1][j - 1];
for (int j = 1; j <= n; j++)
dp[i][j] -= cp[s[i]][j] + cp[s[i]][j - 1], dp[i][j] %= mod;
for (int j = 1; j <= n; j++) cp[s[i]][j] += dp[i][j], cp[s[i]][j] %= mod;
for (int j = 0; j <= n; j++) dp[i][j] += dp[i - 1][j], dp[i][j] %= mod;
}
long long ans = 0;
for (int i = 1; i <= n; i++)
ans += dp[s.size() - 1][i] * ch(n - 1, i - 1), ans %= mod;
if (ans < 0) ans += mod;
printf("%lld", ans);
}
| 8 |
#include <bits/stdc++.h>
const int maxn = 500100;
const double eps = 0.0000000001;
const double inf = 99999999999;
double dis(double x1, double y1, double x2, double y2) {
return sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1));
}
using namespace std;
int main() {
double x1, y1, x2, y2, vmax, t, vx, vy, wx, wy;
double r, l;
while (cin >> x1 >> y1 >> x2 >> y2 >> vmax >> t >> vx >> vy >> wx >> wy) {
l = 0;
r = inf;
while (r - l > eps) {
double mid = (l + r) / 2;
double d, x3, y3;
if (mid > t) {
x3 = x1 + t * vx + (mid - t) * wx;
y3 = y1 + t * vy + (mid - t) * wy;
} else {
x3 = x1 + mid * vx;
y3 = y1 + mid * vy;
}
d = dis(x3, y3, x2, y2);
if (d / vmax > mid)
l = mid;
else
r = mid;
}
printf("%.10f\n", l);
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MaxN = int(2e6) + 256;
const int INF = int(1e9);
const int mod = (int)(1e9) + 7;
const double pi = 3.1415926535897932384626433832795;
long long n, m, ans, a[MaxN], d[MaxN][3];
int used[MaxN][3], timer;
long long rec(int x, int q) {
if (x > n || x <= 0) {
return 0;
}
if (used[x][q] == timer) {
d[x][q] = -1;
return -1;
}
used[x][q] = timer;
if (d[x][q] != -2) return d[x][q];
long long ans = 0;
if (q == 1) {
long long A = rec(x + a[x], 2);
if (A == -1)
d[x][q] = -1;
else
d[x][q] = A + a[x];
} else {
long long A = rec(x - a[x], 1);
if (A == -1)
d[x][q] = -1;
else
d[x][q] = A + a[x];
}
return d[x][q];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 2; i <= n; i++) {
cin >> a[i];
for (int j = 1; j <= 2; j++) d[i][j] = -2;
}
for (int i = 2; i <= n; i++) {
for (int j = 1; j <= 2; j++) {
if (d[i][j] == -2) {
timer++;
used[1][1] = timer;
rec(i, j);
}
}
}
for (int i = 1; i < n; i++) {
if (d[i + 1][2] == -1)
cout << -1 << "\n";
else
cout << i + d[i + 1][2] << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
long long s, t, g[200007], c, v;
pair<long long, long long> car[200007];
int check(int x) {
long long sum = 0, dis = 0, cur = 0, val = car[x].first;
for (int i = 1; i <= k + 1; i++) {
long long pl = g[i];
if (i == 1)
dis = pl - 0;
else
dis = pl - g[i - 1];
if (dis > val) return 0;
cur = dis * 2;
if (cur <= val)
sum += dis;
else {
sum += dis + (cur - val);
}
}
if (sum <= t)
return 1;
else
return 0;
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> k >> s >> t;
for (int i = 1; i <= n; i++) {
cin >> c >> v;
car[i] = make_pair(v, c);
}
for (int i = 1; i <= k; i++) {
cin >> g[i];
}
sort(g + 1, g + 1 + k);
g[k + 1] = s;
sort(car + 1, car + 1 + n);
int start = 1, en = n;
int mid = (start + en) / 2;
if (check(n) == 0) {
cout << -1;
return 0;
}
int cnp = 500;
while (cnp--) {
if (check(mid) == 1)
en = mid;
else
start = mid + 1;
mid = (start + en) / 2;
}
long long ans = 1e16;
for (int i = mid; i <= n; i++) {
ans = min(ans, car[i].second);
}
cout << ans;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; }
const int INF = 1 << 29;
inline int two(int n) { return 1 << n; }
inline int test(int n, int b) { return n & two(b); }
inline void set_bit(int& n, int b) { n |= two(b); }
inline void unset_bit(int& n, int b) { n &= ~two(b); }
inline int last_bit(int n) { return n & (-n); }
inline int ones(int n) {
int res = 0;
while (n && ++res) n -= n & (-n);
return res;
}
template <class T>
void chmax(T& a, const T& b) {
a = max(a, b);
}
template <class T>
void chmin(T& a, const T& b) {
a = min(a, b);
}
const int MAX = 1000001;
int l1, l2, in1[2 * MAX], in2[MAX], pos[MAX], res;
long long last[2 * MAX];
int main() {
scanf("%d%d", &l1, &l2);
for (int i = 0; i < (l1); i++) {
scanf("%d", &in1[i]);
in1[l1 + i] = in1[i];
}
memset(pos, -1, sizeof(pos));
for (int i = 0; i < (l2); i++) {
scanf("%d", &in2[i]);
pos[in2[i]] = i;
}
long long add = 0;
int index = 0, first = 1;
for (int i = 0; i < (2 * MAX); i++) {
if (pos[in1[i]] == -1) {
index = i + 1;
first = 1;
continue;
}
last[i] = add + pos[in1[i]];
if (!first && last[i] < last[i - 1]) {
last[i] += l2;
add += l2;
}
first = 0;
while (index < i && (last[i] - last[index] >= l2 || i - index >= l1))
++index;
res = max(res, i - index + 1);
}
printf("%d\n", res);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int maxn = 3e5 + 10;
long long mod;
int n, m;
int a[maxn];
int ans[maxn];
vector<int> v[maxn];
char s[maxn];
int main() {
cin >> (s + 1);
cout << "3" << endl;
cout << "L"
<< " "
<< "2" << endl;
cout << "R"
<< " "
<< "2" << endl;
cout << "R"
<< " " << 2 * strlen(s + 1) - 1 << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int o[10], o2[10];
int main() {
string a;
cin >> a;
for (int i = (0); i <= (((int)((a).size())) - 1); i++) o[a[i] - '0']++;
int mx = -1, ii = 0;
for (int i = (0); i <= (9); i++) o2[i] = o[i];
for (int i = (1); i <= (5); i++)
if (o[i] && o2[10 - i]) {
o[i]--, o2[10 - i]--;
int ans = 1;
for (int j = (0); j <= (9); j++) ans += min(o[j], o2[9 - j]);
if (ans > mx) mx = ans, ii = i;
o[i]++, o2[10 - i]++;
};
string ans, ans2;
if (ii) {
ans.push_back(ii + '0');
o[ii]--;
ans2.push_back(10 - ii + '0');
o2[10 - ii]--;
};
for (int i = (0); i <= (9); i++)
while (o[i] && o2[9 - i]) {
o[i]--, o2[9 - i]--;
ans.push_back(i + '0');
ans2.push_back(9 - i + '0');
};
string m0(min(o[0], o2[0]), '0');
int ll = min(o[0], o2[0]);
o[0] -= ll, o2[0] -= ll;
ans = m0 + ans, ans2 = m0 + ans2;
for (int i = (0); i <= (9); i++)
for (int j = (1); j <= (o[i]); j++) ans.push_back(i + '0');
for (int i = (0); i <= (9); i++)
for (int j = (1); j <= (o2[i]); j++) ans2.push_back(i + '0');
for (int i = (((int)((ans).size())) - 1); i >= (0); i--) cout << ans[i];
cout << endl;
for (int i = (((int)((ans2).size())) - 1); i >= (0); i--) cout << ans2[i];
cout << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 2e5 + 4;
string s;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
;
cin >> s;
long long n = s.size();
long long sub = 0;
for (int k = 1; k <= 8; k++) {
for (int i = 0; i + k <= n; i++) {
bool flag = false;
for (int j = 1; 2 * j < k; j++) {
for (int st = i; st + 2 * j < i + k; st++) {
if (s[st] == s[st + j] && s[st] == s[st + 2 * j]) {
flag = true;
}
}
}
if (!flag) sub++;
}
}
cout << n * (n + 1) / 2 - sub << '\n';
}
| 5 |
#include <bits/stdc++.h>
int palindrome(char checkstring1[11], int length);
int main() {
int i, flag = 0, j, k, r, l;
char string[11];
char string1[12];
scanf("%s", string);
for (i = 0; i <= strlen(string); i++) {
for (j = 0; j <= 25; j++) {
string1[i] = 'a' + j;
l = 0;
for (k = 0; k < strlen(string) + 1; k++) {
if (i != k) {
string1[k] = string[l];
l++;
}
}
flag = palindrome(string1, strlen(string));
if (flag) {
break;
}
}
if (flag) {
break;
}
}
if (flag) {
for (r = 0; r < strlen(string) + 1; r++) {
printf("%c", string1[r]);
}
} else
printf("NA");
return 0;
}
int palindrome(char checkstring[12], int length) {
int count = 0, i;
for (i = 0; i < (length + 1) / 2; i++) {
if (checkstring[i] == checkstring[length - i]) count++;
}
if (count == (length + 1) / 2)
return 1;
else
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
char s1[100005], s2[100005];
int main() {
int a = 0, b = 0;
gets(s1);
gets(s2);
int l = strlen(s1);
for (int i = 0; i < l; i++) {
if (s1[i] == '4' && s2[i] == '7') a++;
if (s1[i] == '7' && s2[i] == '4') b++;
}
printf("%d\n", a > b ? a : b);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
using v2d = vector<vector<T> >;
template <class T>
bool uin(T &a, T b) {
return a > b ? (a = b, true) : false;
}
template <class T>
bool uax(T &a, T b) {
return a < b ? (a = b, true) : false;
}
mt19937 rng(chrono::system_clock::now().time_since_epoch().count());
const int maxN = 1e5 + 10;
int n, m, c, q, p[maxN];
set<int> st[maxN];
map<int, int> mp[maxN];
int root(int u) { return u == p[u] ? u : p[u] = root(p[u]); }
bool unify(int u, int v) {
u = root(u);
v = root(v);
if (u == v) {
return 0;
}
if (st[u].size() < st[v].size()) {
swap(u, v);
}
p[v] = u;
st[u].insert((st[v]).begin(), (st[v]).end());
st[v].clear();
return 1;
}
void solve() {
cin >> n >> m >> c >> q;
iota(p + 1, p + n + 1, 1);
auto add_edge = [&](int u, int v, int col) {
if (mp[u].count(col)) {
unify(mp[u][col], v);
}
mp[u][col] = v;
st[root(u)].insert(v);
};
while (m--) {
int x, y, z;
cin >> x >> y >> z;
add_edge(x, y, z);
add_edge(y, x, z);
}
while (q--) {
char type;
cin >> type;
if (type == '+') {
int x, y, z;
cin >> x >> y >> z;
add_edge(x, y, z);
add_edge(y, x, z);
} else {
int x, y;
cin >> x >> y;
cout << (root(x) == root(y) || st[root(x)].count(y) ? "Yes" : "No")
<< "\n";
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int T = 1;
while (T--) {
solve();
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2000;
int n, m, tot, sum, big, a[MAXN][MAXN];
bool judge() {
bool res = true;
for (int i = 0; i < (n / 2); i++)
for (int j = 0; j < (m); j++)
if (a[i][j] != a[n - i - 1][j]) res = false;
return res;
}
int main() {
cin >> n >> m;
for (int i = 0; i < (n); i++)
for (int j = 0; j < (m); j++) cin >> a[i][j];
while (n % 2 == 0 && judge()) n /= 2;
cout << n << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, k, maxb, t;
int f[101001];
int l;
int a[101011];
void init() { cin >> k >> n >> maxb >> t; }
void force() {
for (int T = 1; T <= k; T++) {
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i < t; i++) {
for (int j = 1; j <= n; j++) a[i * n + j] = a[j];
}
int nt = n * t;
memset(f, 0, sizeof(f));
l = 0;
for (int i = 1; i <= nt; i++)
if (a[i] > f[l])
f[++l] = a[i];
else {
int pos = upper_bound(f + 1, f + 1 + l, a[i]) - f;
if (f[pos - 1] != a[i]) f[pos] = a[i];
}
cout << l << endl;
}
}
int g[101010];
void work() {
for (int T = 1; T <= k; T++) {
for (int i = 1; i <= n; i++) cin >> a[i];
memset(g, -1, sizeof(g));
int lim = min(t, maxb);
l = 0;
for (int i = 1; i <= lim; i++) {
for (int j = 1; j <= n; j++) {
if (a[j] > f[l]) {
f[++l] = a[j];
g[a[j]] = l;
} else {
if (g[a[j]] == -1) {
for (int p = a[j]; p <= maxb; p++)
if (g[p] != -1) {
f[g[p]] = a[j];
g[a[j]] = g[p];
g[p] = -1;
break;
}
}
}
}
}
cout << l << endl;
}
}
int main() {
std::ios::sync_with_stdio(false);
init();
if (1LL * n * t <= 100000)
force();
else
work();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
struct data {
int x, y, z;
};
data num[500003];
int tree[4 * 500003], n, numy[500003];
bool cmp(data a, data b) { return a.x > b.x; }
int query(int node, int l, int r, int ql, int qr) {
if (ql == l && qr == r) return tree[node];
int mid = (l + r) >> 1;
if (qr <= mid)
return query(2 * node, l, mid, ql, qr);
else if (ql > mid)
return query(2 * node + 1, mid + 1, r, ql, qr);
else {
int x, y;
x = query(2 * node, l, mid, ql, mid);
y = query(2 * node + 1, mid + 1, r, mid + 1, qr);
return max(x, y);
}
}
void update(int node, int l, int r, int pos, int val) {
if (l == r) {
tree[node] = max(tree[node], val);
return;
}
int mid = (l + r) >> 1;
if (pos <= mid)
update(2 * node, l, mid, pos, val);
else
update(2 * node + 1, mid + 1, r, pos, val);
tree[node] = max(tree[2 * node], tree[2 * node + 1]);
}
int get(int a) {
int start = 1, end = n, mid;
while (start <= end) {
mid = (start + end) >> 1;
if (numy[mid] == a)
return mid;
else if (numy[mid] < a)
start = mid + 1;
else
end = mid - 1;
}
}
int main() {
int i, j, no, pos, k;
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d", &num[i].x);
for (i = 1; i <= n; i++) {
scanf("%d", &num[i].y);
numy[i] = num[i].y;
}
for (i = 1; i <= n; i++) scanf("%d", &num[i].z);
sort(num + 1, num + n + 1, cmp);
sort(numy + 1, numy + n + 1);
no = 0;
for (i = 1; i <= n; i = j) {
for (j = i; j <= n && num[i].x == num[j].x; j++) {
pos = get(num[j].y);
if (pos == n) continue;
k = query(1, 1, n, pos + 1, n);
if (num[j].z < k) no++;
}
for (j = i; j <= n && num[i].x == num[j].x; j++) {
pos = get(num[j].y);
update(1, 1, n, pos, num[j].z);
}
}
printf("%d\n", no);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long dp[50][2];
long long second, X;
void give(int n, long long c, long long x, long long s) {
if (x > 1) x = 1;
if (s > 1) s = 1;
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
if ((i ^ j) == x and (c + i + j) % 2 == s) {
dp[n + 1][(c + i + j) / 2] += dp[n][c];
}
}
}
}
inline void ReadInput(void) {
scanf("%lld", &second);
scanf("%lld", &X);
}
inline void solve(void) {
dp[0][0] = 1;
for (int i = 0; i < 50; i++) {
give(i, 0, X & (1LL << i), second & (1LL << i));
give(i, 1, X & (1LL << i), second & (1LL << i));
}
if (second == X) dp[49][0] -= 2;
cout << dp[49][0] << endl;
}
inline void Refresh(void) {}
int main() {
ReadInput();
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x7fffffff;
int stk[50005], top = 0;
struct Point {
long long x, y;
Point() {}
Point(long long _x, long long _y) {
x = _x;
y = _y;
}
Point operator-(const Point &b) const { return Point(x - b.x, y - b.y); }
Point operator+(const Point &b) const { return Point(x + b.x, y + b.y); }
long long operator^(const Point &b) const { return x * b.y - y * b.x; }
long long operator*(const Point &b) const { return x * b.x + y * b.y; }
bool operator==(const Point &b) const { return (x == b.x && y == b.y); }
} p[50005], A, B, C, AA, AB, AC;
bool cmp(Point a, Point b) {
Point d_a = a - p[0], d_b = b - p[0];
if ((d_a ^ d_b) > 0)
return 1;
else if ((d_a ^ d_b) < 0)
return 0;
else
return abs(d_a.x) < abs(d_b.x);
}
void Graham(int n) {
int i;
stk[top++] = 0;
for (i = 1; p[i] == p[0]; i++)
;
stk[top++] = i++;
for (; i < n; i++) {
if (((p[stk[top - 1]] - p[stk[top - 2]]) ^ (p[i] - p[stk[top - 1]])) > 0) {
stk[top++] = i;
continue;
} else {
while (!(((p[stk[top - 1]] - p[stk[top - 2]]) ^
(p[i] - p[stk[top - 1]])) > 0) &&
top > 1)
top--;
stk[top++] = i;
continue;
}
}
}
long long sss(Point a, Point b, Point c) { return abs((b - a) ^ (c - a)); }
void TriangleS() {
A = p[stk[0]], B = p[stk[1]], C = p[stk[2]];
bool flag = 0;
while (1) {
flag = 0;
for (int i = 0; i < top; i++) {
if (sss(p[stk[i]], B, C) > sss(A, B, C)) {
A = p[stk[i]];
flag = 1;
}
if (sss(A, p[stk[i]], C) > sss(A, B, C)) {
B = p[stk[i]];
flag = 1;
}
if (sss(A, B, p[stk[i]]) > sss(A, B, C)) {
C = p[stk[i]];
flag = 1;
}
}
if (flag == 0) break;
}
}
int main() {
long long n, s, xm, ym;
int nm, i;
cin >> n >> s;
xm = INF;
ym = INF;
for (i = 0; i < n; i++) {
scanf("%I64d%I64d", &p[i].x, &p[i].y);
if (p[i].y < ym) {
xm = p[i].x;
ym = p[i].y;
nm = i;
} else if (p[i].y == ym && p[i].x < xm) {
xm = p[i].x;
ym = p[i].y;
nm = i;
}
}
swap(p[0], p[nm]);
sort(p + 1, p + n, cmp);
Graham(n);
TriangleS();
AA = A + ((B - A) + (C - A));
AB = B + ((A - B) + (C - B));
AC = C + ((A - C) + (B - C));
printf("%I64d %I64d\n", AA.x, AA.y);
printf("%I64d %I64d\n", AB.x, AB.y);
printf("%I64d %I64d\n", AC.x, AC.y);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long sum[500101];
long long ans = 0, last = 0;
int main() {
int a, b, c, d;
cin >> a >> b >> c >> d;
for (int i = 1; i <= d; ++i) sum[i] = sum[i - 1] + i;
long long y;
for (int z = c; z <= d; ++z) {
if (b + c <= z) break;
int g = z - b + 1;
int x = b - a + 1;
if (g < b) {
y = c - b + 1;
long long k = min(b - g, x - 1);
ans += k * y;
x = x - k;
} else
y = c - g + 1;
if (y <= x)
ans += sum[y];
else {
ans += (sum[y] - sum[y - x]);
}
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T gcd(T a, T b) {
return (b == 0) ? abs(a) : gcd(b, a % b);
}
template <typename T>
inline T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
template <typename T>
inline T mod(T a, T b) {
a %= b;
if (a < 0) a += b;
return a;
}
template <typename T>
inline T sqr(T x) {
return x * x;
}
template <typename T>
inline T gmax(T a, T b) {
return (a > b ? a : b);
}
template <typename T>
inline T gmin(T a, T b) {
return (a < b ? a : b);
}
int dgt[10];
void todgt(long long n) {
int i;
for (i = 8; i >= 0; i--) {
dgt[i] = n % 10;
n /= 10;
}
return;
}
int main() {
long long a, b, m;
long long i;
cin >> a >> b >> m;
if (b >= m) {
cout << 2 << endl;
return 0;
}
long long v = 1;
for (i = 0; i < (9); i++) v *= 10, v %= m;
if (!v) {
cout << 2 << endl;
return 0;
}
for (i = (1); i <= (m); i++) {
if (i > a) {
cout << 2 << endl;
return 0;
}
if (((v * i) % m) && (((v * i) % m) < (m - b))) {
break;
}
}
if (i == m + 1) {
cout << 2 << endl;
return 0;
}
todgt(i);
cout << 1 << " ";
for (i = 0; i < (9); i++) cout << dgt[i];
cout << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long n;
cin >> n;
string s = "ROYGBIV";
long long x = n - 7;
string st = "GBIV";
long long i = 0;
while (i < x) {
s += st[(i % 4)];
i++;
}
cout << s << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
int n, k;
cin >> n >> k;
int max_h = -2e9;
for (int i = 0; i < n; ++i) {
int f, t;
cin >> f >> t;
max_h = max(max_h, f - max(0, t - k));
}
cout << max_h << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int ans[200005 << 2], cnt, n, m, rt;
vector<int> g[200005];
bool v[200005], c[200005];
void add(int x) { c[ans[++cnt] = x] ^= 1; }
bool ok() {
for (int i = 1; i <= n; ++i)
if (c[i]) return 0;
return 1;
}
void dfs(int u) {
add(u), v[u] = 1;
for (typeof(g[u].begin()) x = g[u].begin(); x != g[u].end(); ++x) {
if (v[*x]) continue;
dfs(*x), add(u);
if (c[*x]) add(*x), add(u);
}
}
int main() {
scanf("%d%d", &n, &m);
int u, v;
for (int i = 1; i <= m; ++i)
scanf("%d%d", &u, &v), g[u].push_back(v), g[v].push_back(u);
for (int i = 1; i <= n; ++i) scanf("%d", &c[i]), rt = c[i] ? i : rt;
dfs(rt);
if (c[rt]) --cnt, c[rt] = 0;
if (ok()) {
printf("%d\n", cnt);
for (int i = 1; i <= cnt; ++i)
printf("%d%c", ans[i], (i == cnt) ? '\n' : ' ');
} else
puts("-1");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1010;
bool st[N];
int a[N];
int n;
vector<int> ans;
int mex() {
memset(st, false, sizeof st);
for (int i = 0; i < n; i++) st[a[i]] = true;
int cur = 0;
while (st[cur]) cur++;
return cur;
}
bool check() {
for (int i = 0; i < n; i++)
if (a[i] != i) return false;
return true;
}
int main() {
ios ::sync_with_stdio(false);
cin.tie(0);
int T;
cin >> T;
while (T--) {
ans.clear();
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
while (!check()) {
int x = mex();
int p = x;
if (x == n) {
for (int i = 0; i < n; i++)
if (a[i] != i) {
p = i;
break;
}
}
a[p] = x;
ans.push_back(p);
}
cout << ans.size() << endl;
for (auto x : ans) cout << x + 1 << " ";
cout << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int mask[2][60][60];
int dp[60][60];
int graph[30][30];
void func(int id, int N, string s) {
int d, i, j, k, a, b;
for (d = 1; d <= N; d++)
for ((i) = 0; (i) < (int)(N - d + 1); (i)++) {
j = i + d;
if (d == 1) {
mask[id][i][j] = (1 << (s[i] - 'a'));
} else {
for (k = i + 1; k < j; k++)
for ((a) = 0; (a) < (int)(26); (a)++)
if (mask[id][i][k] & (1 << a))
for ((b) = 0; (b) < (int)(26); (b)++)
if (mask[id][k][j] & (1 << b)) mask[id][i][j] |= graph[a][b];
}
}
}
int main(void) {
int Q, N, M, i, j, k, l;
string s, t;
cin >> s >> t >> Q;
for ((i) = 0; (i) < (int)(Q); (i)++) {
string tmp;
cin >> tmp;
graph[tmp[3] - 'a'][tmp[4] - 'a'] |= (1 << (tmp[0] - 'a'));
}
N = s.length();
func(0, N, s);
M = t.length();
func(1, M, t);
for ((i) = 0; (i) < (int)(N + 1); (i)++)
for ((j) = 0; (j) < (int)(M + 1); (j)++) dp[i][j] = (1 << 29);
dp[0][0] = 0;
for ((i) = 0; (i) < (int)(N + 1); (i)++)
for ((j) = 0; (j) < (int)(M + 1); (j)++)
for ((k) = 0; (k) < (int)(i); (k)++)
for ((l) = 0; (l) < (int)(j); (l)++)
if (mask[0][k][i] & mask[1][l][j])
dp[i][j] = min(dp[i][j], dp[k][l] + 1);
int ans = dp[N][M];
if (ans == (1 << 29))
cout << -1 << endl;
else
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >>t;
while (t>0){
t--;
int n;
cin >> n;
int nos[2*n];
for(int i =0;i<(2*n);i++){
cin >> nos[i];
}
sort(nos,nos+2*n);
for (int i =0;i<n;i++){
cout << nos[i] << " " << nos[2*n - i - 1] << " ";
}
cout << "\n";
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
char s[2020];
bool mp[8080][8080], mp1[8080][8080];
long long ans;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
char s = getchar();
int cur;
for (int j = 1; j <= n / 4; ++j) {
s = getchar();
cur = s >= '0' && s <= '9' ? s - '0' : s - 'A' + 10;
for (int k = 0; k < 4; ++k)
mp1[i][j * 4 - k] = mp[i][j * 4 - k] = cur >> k & 1;
}
}
ans = (614ll * n + 1) * n * (n - 1) / 2;
for (int i = 1; i <= n; ++i) {
int ed = 0, p = 0;
for (int j = 1; j <= n; ++j)
if (mp[i][j] && (!ed || mp[ed][j])) ed = j;
for (int j = 1; j <= n; ++j)
if (!mp[i][j] && mp[ed][j]) {
ans -= 614 * n - 2;
mp1[i][j] = 1;
if (!p || mp[j][p]) p = j;
}
for (int j = 1; j <= n; ++j)
if (!mp1[i][j] && i != j && mp[p][j]) ans -= 614 * n - 3;
}
printf("%lld", ans);
return 0;
}
| 13 |
#include <bits/stdc++.h>
int n;
long long s, f[30];
long long inv(long long x) {
long long base = 1000000007 - 2, ans = 1;
while (base) {
if (base & 1) ans = ans * x % 1000000007;
x = x * x % 1000000007;
base >>= 1;
}
return ans;
}
long long C(long long x, long long k) {
if (x < k) return 0;
if (x - k < k) k = x - k;
long long numerator = 1, denominator = 1;
for (long long i = 0; i < k; i++) {
numerator = numerator * (x - i) % 1000000007;
denominator = denominator * (i + 1) % 1000000007;
}
return numerator * inv(denominator) % 1000000007;
}
long long lucas(long long x, long long k) {
if (!k) return 1;
return C(x % 1000000007, k % 1000000007) *
lucas(x / 1000000007, k / 1000000007) % 1000000007;
}
int main() {
scanf("%d%lld", &n, &s);
for (int i = 0; i < n; i++) scanf("%lld", &f[i]);
long long ans = 0;
for (int i = 0; i < (1 << n); i++) {
int sign = 1;
long long sum = s;
for (int j = 0; j < n; j++)
if (i & (1 << j)) {
sign *= -1;
sum -= f[j] + 1;
}
if (sum < 0) continue;
ans = (ans + sign * lucas(sum + n - 1, n - 1)) % 1000000007;
}
ans = (ans + 1000000007) % 1000000007;
printf("%lld\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void sep(string SS = "BLOCK") {
cout << "-------------" << SS << "-----------------\n";
}
template <typename T>
void debugv(vector<T> arr) {
for (auto t : arr) cout << t << " ";
cout << "\n";
}
template <typename T>
void debugarr(T arr, int n) {
for (int i = 0; i < n; i++) cout << arr[i] << " ";
cout << "\n";
}
template <typename T>
void chmax(T& a, T b) {
if (a < b) a = b;
}
template <typename T>
void chmin(T& a, T b) {
if (a > b) a = b;
}
long long min(long long a, long long b) { return a < b ? a : b; }
long long max(long long a, long long b) { return a > b ? a : b; }
const int maxn = 4e6 + 100;
long long arr[maxn], n, m, t, k, q;
unordered_map<long long, long long> u;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
vector<string> arr(n);
for (int i = 0; i < n; i++) cin >> arr[i];
auto cmp = [](string a, string b) {
string one = a + b;
string two = b + a;
return one < two;
};
sort(arr.begin(), arr.end(), cmp);
for (auto a : arr) cout << a;
cout << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
if (n < 4)
cout << -1 << endl;
else {
int k = n / 4;
for (int i = 0; i < k; i++) {
cout << i * 4 + 2 << ' ';
if (i != k - 1) cout << i * 4 + 4 << ' ';
if (i != k - 1) cout << i * 4 + 1 << ' ';
if (i != k - 1) cout << i * 4 + 3 << ' ';
}
if (k * 4 + 2 <= n) cout << k * 4 + 2 << ' ';
cout << (k - 1) * 4 + 4 << ' ';
cout << (k - 1) * 4 + 1 << ' ';
cout << 4 * (k - 1) + 3 << ' ';
if (k * 4 + 1 <= n) cout << k * 4 + 1 << ' ';
if (k * 4 + 3 <= n) cout << k * 4 + 3 << ' ';
cout << endl;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) {
if (i & 1)
cout << -(abs(a[i])) << ' ';
else
cout << abs(a[i]) << ' ';
}
cout << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int INF = 1e9;
const int N = 2e5 + 4;
long long powmod(long long a, long long b, long long mod) {
long long res = 1;
a %= mod;
for (; b; b >>= 1) {
if (b & 1) res = (res * a) % mod;
a = (a * a) % mod;
}
return res % MOD;
}
int gcd(int a, int b) {
while (b > 0) {
int t = a % b;
a = b, b = t;
}
return a;
}
long long lcm(long long a, long long b) { return (a / gcd(a, b)) * b; }
long long is_prime(long long n) {
if (n <= 1 || n > 3 && (n % 2 == 0 || n % 3 == 0)) return 0;
for (long long i = 5, t = 2; i * i <= n; i += t, t = 6 - t)
if (n % i == 0) return 0;
return 1;
}
int modI(int a, int m) {
int m0 = m, y = 0, x = 1;
if (m == 1) return 0;
while (a > 1) {
int q = a / m;
int t = m;
m = a % m;
a = t;
t = y;
y = x - q * y;
x = t;
}
if (x < 0) x += m0;
return x;
}
long long mod_inv(long long a, long long m = MOD) {
return a == 1 ? 1 : m - mod_inv(m % a, a) * m / a;
}
long long choose(long long n, long long r) {
long long product = 1;
for (long long i = 0; i < r; i++)
product = product * (n - i) % MOD * mod_inv(i + 1) % MOD;
return product;
}
long long getcount(long long n, int k) {
long long res = (n >> (k + 1)) << k;
if ((n >> k) & 1) res += n & ((1ll << k) - 1);
return res;
}
int bit[N];
void init(void) {
int i;
for (int i = 0; i < N; i++) bit[i] = 0;
}
void update(int idx, int val) {
while (idx <= N) {
bit[idx] = max(bit[idx], val);
idx += idx & -idx;
}
}
int pref(int idx) {
int ans = 0;
while (idx > 0) {
ans = max(ans, bit[idx]);
idx -= idx & -idx;
}
return ans;
}
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
string s;
cin >> s;
int r = 0;
for (int i = 0; i < n; i++) {
if (s[i] == 'R') r++;
}
if (r == 0 || r == n) {
if (r == 0) r = n;
cout << (r + 2) / 3 << "\n";
continue;
}
int ans = 0;
for (int i = 0; i < n; i++) {
int f = 1;
while (i + 1 < n && s[i] == s[i + 1]) f++, i++;
ans += f / 3;
}
if (s[0] == s[n - 1]) {
int l = 1;
r = 0;
int i = 0;
while (i + 1 < n && s[i] == s[i + 1]) i++, l++;
r = 1;
i = n - 1;
while (i - 1 >= 0 && s[i] == s[i - 1]) i--, r++;
ans -= l / 3;
ans -= r / 3;
ans += (l + r) / 3;
}
cout << ans << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, r;
int c;
cin >> a >> b >> r;
c = r * 2;
if (b < c || a < c)
cout << "Second" << endl;
else
cout << "First" << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int w = 0, b = 0, total;
char buf;
for (int i = 0; i < 64; i++) {
total = 0;
cin >> buf;
if (!(buf == '.')) {
if (isalpha(buf)) {
if (buf == 'q' || buf == 'Q')
total += 9;
else if (buf == 'r' || buf == 'R')
total += 5;
else if (buf == 'b' || buf == 'B')
total += 3;
else if (buf == 'n' || buf == 'N')
total += 3;
else if (buf == 'p' || buf == 'P')
total += 1;
else if (buf == 'k' || buf == 'K')
total += 0;
else
return 1;
if (isupper(buf))
w += total;
else
b += total;
}
}
}
if (w > b)
cout << "White" << endl;
else if (b > w)
cout << "Black" << endl;
else
cout << "Draw" << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long i, k, j, l, n, m, t;
t = 1;
while (t--) {
string s;
cin >> s;
cout << (s.size() + 1) * 25 + 1;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long infi = 1e18 + 10;
long long MOD = 1e9 + 7;
const long long N = 1e6 + 10;
const long long M = 998244353;
long long dx[] = {1, 0, -1, 0};
long long dy[] = {0, 1, 0, -1};
void init_code() {}
long long binexp(long long a, long long b, long long p) {
a %= p;
long long ans = 1;
while (b > 0) {
if (b & 1) ans = (ans * a) % p;
a = (a * a) % p;
b >>= 1;
}
return ans;
}
long long mod_inverse(long long n, long long p) { return binexp(n, p - 2, p); }
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t;
cin >> t;
while (t--) {
vector<long long> v(7);
bool found = false;
for (long long i = 0; i < 7; i++) cin >> v[i];
for (long long i = 0; i < 7; i++) {
for (long long j = i + 1; j < 7; j++) {
for (long long k = j + 1; k < 7; k++) {
if (v[i] + v[j] + v[k] == v[6]) {
if (!found) {
found = true;
cout << v[i] << " " << v[j] << " " << v[k] << "\n";
}
}
}
}
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int read() {
char ch = getchar();
int x = 0, flag = 1;
for (; !isdigit(ch); ch = getchar())
if (ch == '-') flag *= -1;
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - 48;
return x * flag;
}
void write(int x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) write(x / 10);
putchar(x % 10 + 48);
}
const int Maxn = 400009;
struct quer {
int opt, u, v;
};
struct interval {
int l, r;
};
int n, s[Maxn][3], cnt1, tmp, tpd[Maxn * 2], d, shot[Maxn];
interval a[Maxn];
quer b[Maxn];
void init() {
n = read();
for (int i = (1), i_end_ = (n); i <= i_end_; ++i) {
int opt = read(), l = read(), r = read();
if (opt == 1) a[++cnt1] = (interval){l, r}, shot[i] = cnt1;
b[i] = (quer){opt, l, r};
}
for (int i = (1), i_end_ = (cnt1); i <= i_end_; ++i) {
tpd[++tmp] = a[i].l - 1, tpd[++tmp] = a[i].l;
tpd[++tmp] = a[i].l + 1, tpd[++tmp] = a[i].r - 1;
tpd[++tmp] = a[i].r, tpd[++tmp] = a[i].r + 1;
}
sort(tpd + 1, tpd + tmp + 1);
d = unique(tpd + 1, tpd + tmp + 1) - tpd - 1;
for (int i = (1), i_end_ = (cnt1); i <= i_end_; ++i) {
a[i].l = lower_bound(tpd + 1, tpd + d + 1, a[i].l) - tpd,
a[i].r = lower_bound(tpd + 1, tpd + d + 1, a[i].r) - tpd;
}
for (int i = (1), i_end_ = (n); i <= i_end_; ++i)
if (b[i].opt == 1) b[i].u = a[shot[i]].l, b[i].v = a[shot[i]].r;
}
int L[Maxn], R[Maxn], amt, fa[Maxn];
int find(int u) { return fa[u] ^ u ? fa[u] = find(fa[u]) : u; }
namespace SGMTtree {
vector<int> tree[Maxn << 2];
void combine(int rt, int l, int r, int pos, int val) {
if (!tree[rt].empty()) {
for (int i = (0), i_end_ = (tree[rt].size() - 1); i <= i_end_; ++i) {
int u = find(tree[rt][i]);
L[val] = min(L[val], L[u]), R[val] = max(R[val], R[u]);
fa[u] = val;
}
tree[rt].clear(), tree[rt].push_back(val);
}
if (l == r) return;
int mid = (l + r) >> 1;
(pos <= mid) ? combine(rt << 1, l, mid, pos, val)
: combine(rt << 1 | 1, mid + 1, r, pos, val);
}
void update(int rt, int l, int r, int P, int Q, int val) {
if (P > Q) return;
if (P <= l && r <= Q) {
tree[rt].push_back(val);
return;
}
int mid = (l + r) >> 1;
if (Q <= mid)
update(rt << 1, l, mid, P, Q, val);
else if (P >= mid + 1)
update(rt << 1 | 1, mid + 1, r, P, Q, val);
else
update(rt << 1, l, mid, P, Q, val),
update(rt << 1 | 1, mid + 1, r, P, Q, val);
}
}; // namespace SGMTtree
void solve() {
for (int i = (1), i_end_ = (n); i <= i_end_; ++i) {
if (b[i].opt == 1) {
++amt, L[amt] = b[i].u;
R[amt] = b[i].v;
fa[amt] = amt;
SGMTtree ::combine(1, 1, d, L[amt], amt),
SGMTtree ::combine(1, 1, d, R[amt], amt);
SGMTtree ::combine(1, 1, d, b[i].u, amt),
SGMTtree ::combine(1, 1, d, b[i].v, amt);
SGMTtree ::update(1, 1, d, L[amt] + 1, R[amt] - 1, amt);
} else {
int p = find(b[i].u), q = find(b[i].v);
if (p == q) {
puts("YES");
continue;
}
if ((L[q] < a[b[i].u].l && a[b[i].u].l < R[q]) ||
(L[q] < a[b[i].u].r && a[b[i].u].r < R[q])) {
puts("YES");
continue;
}
puts("NO");
}
}
}
int main() {
init();
solve();
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int last[100005];
int main() {
int n, x[100005], y[100005];
cin >> n;
for (int i = 1; i <= n; i++) {
scanf("%d %d", &x[i], &y[i]);
int cnt = 0;
if (y[i] == 0) {
for (int j = 1; j <= sqrt(x[i]); j++) {
if (x[i] % j == 0) {
last[j] = i;
cnt = cnt + 1;
if (x[i] / j != j) {
last[x[i] / j] = i;
cnt = cnt + 1;
}
}
}
} else {
int ind = i - y[i];
for (int j = 1; j <= sqrt(x[i]); j++) {
if (x[i] % j == 0) {
if (last[j] < ind) cnt = cnt + 1;
last[j] = i;
if (x[i] / j != j) {
if (last[x[i] / j] < ind) cnt = cnt + 1;
last[x[i] / j] = i;
}
}
}
}
cout << cnt << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
double p[200];
double s[200];
double ans[200][200];
int main() {
int n, i, j, k;
scanf("%d", &n);
for (i = 0; i < n; i++) scanf("%lf", &p[i]);
sort(p, p + n);
memset(ans, 0, sizeof(ans));
double r = 0;
for (i = 0; i < n; i++) {
s[i] = 1;
for (j = i - 1; j >= 0; j--) s[j] = s[j + 1] * (1.0 - p[j]);
for (j = i + 1; j < n; j++) s[j] = s[j - 1] * (1.0 - p[j]);
for (j = 0; j <= i; j++)
for (k = i; k < n; k++) {
double now = s[j] * s[k] * p[i];
ans[j][k] += now;
}
}
for (i = 0; i < n; i++)
for (j = i; j < n; j++) r = max(r, ans[i][j]);
printf("%.11lf\n", r);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int M = 310;
const int N = 2000 * 1000 + 13;
int n, m, q;
int a[M][M];
int dx[] = {-1, 0, 1, 0};
int dy[] = {0, -1, 0, 1};
bool in(int first, int second) {
return 0 <= first && first < n && 0 <= second && second < m;
}
int p[M * M], rk[M * M];
int getp(int v) { return p[v] == v ? v : p[v] = getp(p[v]); }
bool unite(int a, int b) {
a = getp(a);
b = getp(b);
if (a == b) return false;
if (rk[a] < rk[b]) swap(a, b);
p[b] = a;
rk[a] += rk[b];
return true;
}
int dif[N];
vector<pair<int, int> > add[N], del[N];
void recalc(const vector<pair<int, int> >& ev, int coeff) {
for (int i = 0; i < int(n); ++i)
for (int j = 0; j < int(m); ++j) a[i][j] = 0;
for (int i = 0; i < int(n * m); ++i) p[i] = i, rk[i] = 1;
for (auto it : ev) {
int cur = 1;
int first = it.first / m, second = it.first % m;
a[first][second] = 1;
for (int k = 0; k < int(4); ++k) {
int nx = first + dx[k];
int ny = second + dy[k];
if (in(nx, ny) && a[nx][ny] == 1)
cur -= unite(nx * m + ny, first * m + second);
}
dif[it.second] += cur * coeff;
}
}
int main() {
scanf("%d%d%d", &n, &m, &q);
int clrs = 1;
for (int i = 0; i < int(q); ++i) {
int first, second, c;
scanf("%d%d%d", &first, &second, &c);
--first;
--second;
if (a[first][second] == c) continue;
clrs = c + 1;
add[c].push_back(make_pair(first * m + second, i));
del[a[first][second]].push_back(make_pair(first * m + second, i));
a[first][second] = c;
}
for (int first = 0; first < int(n); ++first)
for (int second = 0; second < int(m); ++second)
del[a[first][second]].push_back(make_pair(first * m + second, q));
for (int i = 0; i < int(clrs); ++i) reverse((del[i]).begin(), (del[i]).end());
for (int i = 0; i < int(clrs); ++i) recalc(add[i], +1);
for (int i = 0; i < int(clrs); ++i) recalc(del[i], -1);
int cur = 1;
for (int i = 0; i < int(q); ++i) {
cur += dif[i];
printf("%d\n", cur);
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, k = 0, n;
string a;
cin >> n;
for (int m = 0; m < n; m++) {
cin >> a;
cin >> i >> j;
if (i >= 2400 && j > i) k++;
}
if (k >= 1)
cout << "YES\n";
else
cout << "NO\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
char grid[50][50];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int a, b, c, d, n = 0, m = 0;
cin >> a >> b >> c >> d;
a--;
b--;
c--;
d--;
for (int i = 0; i < 25; i++)
for (int j = 0; j < 25; j++) grid[i][j] = 'A';
for (int i = 0; i < 25; i++)
for (int j = 25; j < 50; j++) grid[i][j] = 'B';
for (int i = 25; i < 50; i++)
for (int j = 0; j < 50; j++) grid[i][j] = 'C';
for (int i = 25; i < 50; i++)
for (int j = 25; j < 50; j++) grid[i][j] = 'D';
for (int i = 1; b && i < 25; i += 2)
for (int j = 1; b && j < 25; j += 2) {
grid[i][j] = 'B';
b--;
}
for (int i = 1; c && i < 25; i += 2)
for (int j = 26; c && j < 50; j += 2) {
grid[i][j] = 'C';
c--;
}
for (int i = 26; d && i < 50; i += 2)
for (int j = 1; d && j < 25; j += 2) {
grid[i][j] = 'D';
d--;
}
for (int i = 26; a && i < 50; i += 2)
for (int j = 26; a && j < 50; j += 2) {
grid[i][j] = 'A';
a--;
}
cout << 50 << ' ' << 50 << '\n';
for (int i = 0; i < 50; i++) {
for (int j = 0; j < 50; j++) cout << grid[i][j];
cout << '\n';
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<long long int> v;
bool vi[1002][1002];
char te[100006];
map<pair<long long int, long long int>, long long int> ma;
int main() {
long long int n;
cin >> te;
long long int l = strlen(te);
for (long long int i = 0; i < l; i++) v.push_back(te[i] - '0');
long long int la = v[v.size() - 1];
l = v.size();
long long int max = INT_MAX;
int flag1 = 0;
int flag2 = 0;
long long int temp_i = -1;
for (long long int i = 0; i < l; i++) {
if (v[i] % 2 == 0) {
flag1 = 1;
if (v[i] < la) {
v[l - 1] = v[i];
v[i] = la;
flag2 = 1;
break;
} else if (v[i] > la) {
if (temp_i < i) {
temp_i = i;
max = v[i];
}
}
}
}
if (flag2) {
for (long long int i = 0; i < l; i++) printf("%I64d", v[i]);
} else {
if (!flag1) {
printf("-1");
} else if (max != INT_MAX) {
long long int temp = v[temp_i];
v[temp_i] = la;
v[l - 1] = temp;
for (long long int i = 0; i < l; i++) printf("%I64d", v[i]);
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool f(pair<int, int> a, pair<int, int> b) { return a.second < b.second; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m;
cin >> n >> m;
pair<int, int> a[n];
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
a[i] = make_pair(max(1, x - y), min(x + y, m));
}
sort(a, a + n, f);
int dp[m + 1];
fill(dp, dp + m + 1, INT_MAX);
for (auto e : a) {
for (int i = 1; i < m + 1; i++) {
int r = e.second + e.first - 1;
dp[i] = min(dp[i], e.first - 1 + max(0, i - r));
}
}
dp[0] = 0;
for (auto e : a) {
for (int j = e.first; j < e.second + 1; j++) dp[j] = dp[e.first - 1];
for (int j = e.second; j < m + 1; j++) {
int p = max(e.first - j + e.second - 1, 0);
dp[j] = min(dp[j], j - e.second + dp[p]);
}
}
cout << dp[m];
}
| 7 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
const int maxn = 100010;
int n, m, a[maxn];
void print(int x) {
if (x >= 10) print(x / 10);
putchar(x % 10 + '0');
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (int i = 1, op, l, r, x; i <= m; i++) {
scanf("%d %d %d %d", &op, &l, &r, &x);
if (op == 1) {
int j = l;
int *b = a + l;
for (; j + 3 <= r; j += 4) {
*b -= *b > x ? x : 0, b++;
*b -= *b > x ? x : 0, b++;
*b -= *b > x ? x : 0, b++;
*b -= *b > x ? x : 0, b++;
}
while (j <= r) {
a[j] -= a[j] > x ? x : 0, j++;
}
} else {
int ans = 0, j = l;
int *b = a + l;
for (; j + 3 <= r; j += 4) {
ans += *b == x, b++;
ans += *b == x, b++;
ans += *b == x, b++;
ans += *b == x, b++;
}
while (j <= r) {
ans += a[j] == x, j++;
}
print(ans), putchar('\n');
}
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
int main() {
char a[5][2];
char b[2], flag = 0;
for (int i = 0; i < 2; i++) {
scanf("%[^\n]c", &b[i]);
}
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 2; j++) {
scanf(" %c", &a[i][j]);
}
}
for (int i = 0; i < 5; i++) {
if (a[i][0] == b[0] || a[i][1] == b[1]) {
printf("YES");
flag = 1;
break;
}
}
if (flag == 0) printf("NO");
return 0;
}
| 0 |
#include <bits/stdc++.h>
const long long M = 1e9 + 7;
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t;
cin >> t;
for (long long i = 0; i < t; i++) {
string s;
cin >> s;
for (long long j = 0; j < 26; j++) {
for (long long k = 0; k < s.length(); k++) {
long long c = 0, flag = 0;
while (s[k] == ('a' + j) && k < s.length()) {
flag = 1;
c++;
k++;
}
if (flag == 1) k--;
if (c % 2 == 1) {
cout << (char)('a' + j);
break;
}
}
}
cout << "\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m = 0, ans = 0;
int a[30], A[1 << 20], B[1 << 20];
void deal(const int z, const int x, const int y) {
if (z > m) return;
int w = x ^ y;
deal(z + 1, x, w);
for (int i = 1; i <= a[z]; ++i) A[++ans] = x, B[ans] = y;
deal(z + 1, w, y);
}
void Gans(const int z) {
if (z == m) {
for (int i = 1; i < a[z]; ++i) A[++ans] = 1, B[ans] = 2;
A[++ans] = 1, B[ans] = 3;
for (int i = 1; i < a[z]; ++i) A[++ans] = 2, B[ans] = 3;
return;
}
if (a[z] < 2) {
deal(z, 1, 3);
return;
}
deal(z + 1, 1, 3);
for (int i = 1; i <= a[z]; ++i) A[++ans] = 1, B[ans] = 2;
deal(z + 1, 3, 1);
for (int i = 1; i <= a[z]; ++i) A[++ans] = 2, B[ans] = 3;
Gans(z + 1);
}
int main() {
scanf("%d", &n);
for (int i = 1, j = -1, x; i <= n; ++i) {
scanf("%d", &x);
if (x != j) j = x, a[++m] = 0;
++a[m];
}
Gans(1);
printf("%d\n", ans);
for (int i = 1; i <= ans; ++i) printf("%d %d\n", A[i], B[i]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int arr[10] = {0};
int k;
cin >> k;
k *= 2;
char s;
for (int i = 0; i < 16 && cin >> s; i++)
if (s != '.') arr[s - '0']++;
for (int i = 0; i < 10; i++)
if (arr[i] > k) {
cout << "NO";
return 0;
}
cout << "YES";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
int main() {
scanf("%d", &n);
int ans = 0;
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
int j = 1;
while (x >= j) x -= j, j++;
j--;
ans ^= j;
}
if (ans == 0)
printf("YES");
else
printf("NO");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
const int mod = 1e9 + 7;
int n, m;
inline int read() {
int x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 1) + (x << 3) + c - '0';
c = getchar();
}
return x * f;
}
struct surf {
int xl, xr, yl, yr, h, id;
} s[maxn];
inline int cmps(surf x, surf y) { return x.h < y.h; }
struct point {
int x, y, id;
} p[maxn];
inline int cmpx(point x, point y) { return x.x < y.x; }
inline int cmpy(point x, point y) { return x.y < y.y; }
struct node {
int xl, xr, yl, yr, id;
} tr[maxn << 2], w;
inline void build(int h, int l, int r, int k) {
if (l == r) {
tr[h].xl = tr[h].xr = p[l].x;
tr[h].yl = tr[h].yr = p[l].y;
tr[h].id = p[l].id;
return;
}
int mid = (l + r) >> 1;
nth_element(p + l, p + mid, p + r + 1, k ? cmpx : cmpy);
build(h << 1, l, mid, k ^ 1);
build(h << 1 | 1, mid + 1, r, k ^ 1);
int ls = h << 1, rs = h << 1 | 1;
tr[h].id = min(tr[ls].id, tr[rs].id);
tr[h].xl = min(tr[ls].xl, tr[rs].xl);
tr[h].yl = min(tr[ls].yl, tr[rs].yl);
tr[h].xr = max(tr[ls].xr, tr[rs].xr);
tr[h].yr = max(tr[ls].yr, tr[rs].yr);
}
inline void bl(int h, int l, int r) {
printf("%d %d %d %d %d %d\n", h, tr[h].id, tr[h].xl, tr[h].xr, tr[h].yl,
tr[h].yr);
if (l == r) return;
int mid = (l + r) >> 1;
bl(h << 1, l, mid);
bl(h << 1 | 1, mid + 1, r);
}
int pos[maxn], ans[maxn];
inline void query(int h) {
if (tr[h].id > w.id || tr[h].xl > w.xr || tr[h].xr < w.xl ||
tr[h].yl > w.yr || tr[h].yr < w.yl)
return;
if (tr[h].xl >= w.xl && tr[h].xr <= w.xr && tr[h].yl >= w.yl &&
tr[h].yr <= w.yr)
return void(w.id = tr[h].id);
if (tr[h << 1].id < tr[h << 1 | 1].id)
query(h << 1), query(h << 1 | 1);
else
query(h << 1 | 1), query(h << 1);
}
inline void update(int h, int l, int r, int x) {
if (l == r) return void(tr[h].id = m + 1);
int mid = (l + r) >> 1;
if (mid >= x)
update(h << 1, l, mid, x);
else
update(h << 1 | 1, mid + 1, r, x);
tr[h].id = min(tr[h << 1].id, tr[h << 1 | 1].id);
}
int main() {
n = read();
for (int i = 1; i <= n; i++) {
s[i].xl = read(), s[i].xr = read();
s[i].yl = read(), s[i].yr = read();
s[i].h = read(), s[i].id = i;
}
sort(s + 1, s + 1 + n, cmps);
m = read();
for (int i = 1; i <= m; i++) {
p[i].x = read(), p[i].y = read();
p[i].id = i;
}
build(1, 1, m, 0);
for (int i = 1; i <= m; i++) pos[p[i].id] = i;
for (int i = 1; i <= n; i++) {
w = (node){s[i].xl, s[i].xr, s[i].yl, s[i].yr, m + 1};
query(1);
if (w.id == m + 1) continue;
ans[w.id] = s[i].id;
update(1, 1, m, pos[w.id]);
}
for (int i = 1; i <= m; i++) printf("%d\n", ans[i]);
return 0;
}
| 8 |
Subsets and Splits