solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
void Get(int &Ret) {
char CH;
bool FL = 0;
for (; CH = getchar(), CH < '0' || CH > '9';)
if (CH == '-') FL = 1;
for (Ret = CH - '0'; CH = getchar(), CH >= '0' && CH <= '9';
Ret = Ret * 10 + CH - '0')
;
FL && (Ret = -Ret);
}
void Get(long long &Ret) {
char CH;
bool FL = 0;
for (; CH = getchar(), CH < '0' || CH > '9';)
if (CH == '-') FL = 1;
for (Ret = CH - '0'; CH = getchar(), CH >= '0' && CH <= '9';
Ret = Ret * 10 + CH - '0')
;
FL && (Ret = -Ret);
}
const int MAXN = 310000;
struct node {
int v;
node *next;
};
node Edge[MAXN * 2];
node *Ecnt = &Edge[0];
node *adj[MAXN];
inline void addedge(int u, int v) {
node *p = ++Ecnt;
p->v = v;
p->next = adj[u];
adj[u] = p;
}
int n, m;
void Read() {
Get(n);
Get(m);
int i;
for (i = 1; i <= m; i++) {
int u, v;
Get(u);
Get(v);
addedge(u, v);
addedge(v, u);
}
}
int col[MAXN];
void DFS(int u) {
int cnt = 0;
for (node *p = adj[u]; p; p = p->next)
if (col[u] == col[p->v]) cnt++;
if (cnt > 1) {
col[u] ^= 1;
for (node *p = adj[u]; p; p = p->next)
if (col[u] == col[p->v]) DFS(p->v);
}
}
void Solve() {
int i;
for (i = 1; i <= n; i++) DFS(i);
for (i = 1; i <= n; i++) printf("%d", col[i]);
printf("\n");
}
int main() {
Read();
Solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
int main() {
int n;
while (scanf("%d", &n) == 1) {
if (n % 3 == 2)
n++;
else if (n % 3 == 1)
n--;
printf("%d %d\n", n / 36, (n % 36) / 3);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int ls = s.length();
string t;
cin >> t;
int lt = t.length();
int i, j, k = 0;
if (ls != lt) {
cout << "NO" << endl;
} else {
for (i = 0; i < ls; i++) {
for (j = lt - i - 1; j >= 0; j--) {
if (s[i] == t[j]) {
break;
} else {
k = 1;
break;
}
}
if (k == 1)
break;
else
continue;
}
if (k == 1)
cout << "NO" << endl;
else
cout << "YES" << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast", "unroll-loops", "omit-frame-pointer", "inline")
#pragma GCC option("arch=native", "tune=native", "no-zero-upper")
#pragma GCC target("avx2")
using namespace std;
template <typename T>
void maxtt(T& t1, T t2) {
t1 = max(t1, t2);
}
template <typename T>
void mintt(T& t1, T t2) {
t1 = min(t1, t2);
}
bool debug = 0;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
string direc = "RDLU";
const long long MOD2 = (long long)998244353 * (long long)998244353;
long long ln, lk, lm;
void etp(bool f = 0) {
puts(f ? "YES" : "NO");
exit(0);
}
void addmod(int& x, int y, int mod = 998244353) {
x += y;
if (x >= mod) x -= mod;
if (x < 0) x += mod;
assert(x >= 0 && x < mod);
}
void et(int x = -1) {
printf("%d\n", x);
exit(0);
}
long long fastPow(long long x, long long y, int mod = 998244353) {
long long ans = 1;
while (y > 0) {
if (y & 1) ans = (x * ans) % mod;
x = x * x % mod;
y >>= 1;
}
return ans;
}
long long gcd1(long long x, long long y) { return y ? gcd1(y, x % y) : x; }
int dp[5035][5035], fac[5035], C[5035][5035];
void init(int mod = 998244353) {
C[0][0] = 1;
for (int(i) = 1; (i) <= (int)(n); (i)++) {
C[i][0] = 1;
for (int j = 1; j <= i; j++) {
C[i][j] = C[i - 1][j - 1];
addmod(C[i][j], C[i - 1][j]);
}
}
fac[0] = 1;
for (int(i) = 1; (i) <= (int)(n); (i)++)
fac[i] = (long long)fac[i - 1] * i % 998244353;
dp[1][0] = 1;
for (int(i) = 1; (i) <= (int)(n - 1); (i)++) {
for (int j = 0; j < i; j++) {
addmod(dp[i + 1][j], dp[i][j]);
addmod(dp[i + 1][j + 1], dp[i][j]);
addmod(dp[i + 1][j], (long long)dp[i][j] * j % 998244353);
addmod(dp[i + 1][j + 1], (long long)dp[i][j] * (i - 1 - j) % 998244353);
}
}
}
void fmain(int tid) {
scanf("%d", &n);
init();
for (int(k) = 1; (k) <= (int)(n); (k)++) {
int ans = 0;
for (int(i) = 1; (i) <= (int)(n); (i)++) {
addmod(ans, (long long)dp[i][k - 1] * C[n][i] % 998244353 * fac[n - i] %
998244353);
}
printf("%d ", ans);
}
}
int main() {
int t = 1;
for (int(i) = 1; (i) <= (int)(t); (i)++) {
fmain(i);
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const long long MAX = 1e5 + 100;
long long n, ar[MAX], p[MAX], l[10 * MAX], ans = 0;
string cad;
void solve() {
cin >> n >> cad;
ans = 0;
for (long long i = 0; i < n; ++i) ar[i] = cad[i] - '0';
long long sum = 0;
p[0] = n;
for (long long i = 0; i < n; ++i) {
sum += ar[i];
p[i + 1] = sum - (i + 1) + n;
}
for (long long i = 0; i < n + 1; ++i) l[p[i]]++;
for (long long i = 0; i < 10 * n + 1; ++i) ans += (l[i] * (l[i] - 1)) >> 1;
cout << ans << '\n';
for (long long i = 0; i < n + 1; ++i) p[i] = 0;
for (long long i = 0; i < 9 * n + 1; ++i) l[i] = 0;
}
int main() {
ios_base::sync_with_stdio;
int tc;
cin >> tc;
while (tc--) solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int power(long long int a, long long int b) {
a = a % 1000000007;
if (b == 0) return 1LL;
if (b == 1) return a;
long long int temp = power(a, b / 2);
if (b % 2 == 0) return (temp * temp) % 1000000007;
return (((a * temp) % 1000000007) * temp) % 1000000007;
}
void dfs(vector<vector<long long int> > &graph, int mark[], long long int i) {
mark[i] = 1;
for (long long int j = 0; j < (long long int)graph[i].size(); j++)
if (mark[graph[i][j]] == 0) dfs(graph, mark, graph[i][j]);
}
int check(string a, string b) {
long long int i;
for (i = 0; i < (long long int)b.length(); i++) {
if (a[(long long int)a.length() - 1 - i] !=
b[(long long int)b.length() - 1 - i])
return 0;
}
return 1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int t;
cin >> t;
while (t--) {
long long int n, x, mark = -1, leftValue = 0;
cin >> x;
string s;
cin >> s;
n = s.length();
while ((long long int)s.size() < x) {
mark++;
leftValue = (long long int)(s[mark] - '0');
long long int cnt = (s.size() - 1 - mark) * (leftValue - 1), j;
j = mark + 1;
long long int markEnd = s.size(), i;
for (i = 0; i < cnt and (long long int) s.size() < x; i++) {
s.push_back(s[j]);
j++;
if (j == markEnd) j = mark + 1;
}
}
leftValue = 0, mark = 0;
long long int totalSize = n;
while (mark < x) {
leftValue = ((long long int)(s[mark] - '0')) % 1000000007;
long long int cnt = (((totalSize - 1 - mark + 1000000007) % 1000000007) *
(leftValue - 1)) %
1000000007;
totalSize = (totalSize + cnt) % 1000000007;
mark++;
}
cout << totalSize << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int a[100010];
int main() {
int n;
cin >> n;
map<long long, int> d;
long long sum = 0;
int ans = n - 1;
for (int i = 0; i < n; i++) {
int t;
cin >> t;
sum += t;
d[sum]++;
ans = min(ans, n - d[sum]);
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 9;
const int max_n = 3e5 + 5;
int a[max_n];
long long f[max_n];
struct SegmentTree {
struct Tree {
int l, r;
long long sum, a, b;
} t[max_n << 2];
long long F(int n, long long A, long long B) {
if (n == 1) return A % mod;
if (n == 2) return B % mod;
return (A * f[n - 2] % mod + B * f[n - 1] % mod) % mod;
}
long long calc(int n, long long A, long long B) {
return (F(n + 2, A, B) - B + mod) % mod;
}
void push_up(int rt) {
t[rt].sum = (t[(rt << 1)].sum + t[(rt << 1 | 1)].sum) % mod;
}
void push_down(int rt) {
if (t[rt].a != 0 || t[rt].b != 0) {
t[(rt << 1)].a = (t[(rt << 1)].a + t[rt].a) % mod;
t[(rt << 1)].b = (t[(rt << 1)].b + t[rt].b) % mod;
t[(rt << 1)].sum =
(t[(rt << 1)].sum +
calc(t[(rt << 1)].r - t[(rt << 1)].l + 1, t[rt].a, t[rt].b)) %
mod;
t[(rt << 1 | 1)].a =
(t[(rt << 1 | 1)].a +
F(t[(rt << 1)].r - t[(rt << 1)].l + 2, t[rt].a, t[rt].b)) %
mod;
t[(rt << 1 | 1)].b =
(t[(rt << 1 | 1)].b +
F(t[(rt << 1)].r - t[(rt << 1)].l + 3, t[rt].a, t[rt].b)) %
mod;
t[(rt << 1 | 1)].sum =
(t[(rt << 1 | 1)].sum +
calc(t[(rt << 1 | 1)].r - t[(rt << 1 | 1)].l + 1,
F(t[(rt << 1)].r - t[(rt << 1)].l + 2, t[rt].a, t[rt].b),
F(t[(rt << 1)].r - t[(rt << 1)].l + 3, t[rt].a, t[rt].b))) %
mod;
t[rt].a = t[rt].b = 0;
}
}
void build(int l, int r, int rt) {
t[rt].l = l, t[rt].r = r;
t[rt].a = t[rt].b = 0;
if (l == r) {
t[rt].sum = a[l] % mod;
return;
}
int m = (t[rt].l + t[rt].r) / 2;
build(l, m, (rt << 1));
build(m + 1, r, (rt << 1 | 1));
push_up(rt);
}
void update(int l, int r, int rt) {
if (l <= t[rt].l && t[rt].r <= r) {
t[rt].sum = (t[rt].sum + calc(t[rt].r - t[rt].l + 1, f[t[rt].l - l + 1],
f[t[rt].l - l + 2])) %
mod;
t[rt].a = (t[rt].a + f[t[rt].l - l + 1]) % mod;
t[rt].b = (t[rt].b + f[t[rt].l - l + 2]) % mod;
return;
}
push_down(rt);
int m = (t[rt].l + t[rt].r) / 2;
if (l <= m) update(l, r, (rt << 1));
if (r > m) update(l, r, (rt << 1 | 1));
push_up(rt);
}
long long query(int l, int r, int rt) {
if (l <= t[rt].l && t[rt].r <= r) return t[rt].sum;
push_down(rt);
int m = (t[rt].l + t[rt].r) / 2;
long long res = 0;
if (l <= m) res = (res + query(l, r, (rt << 1))) % mod;
if (r > m) res = (res + query(l, r, (rt << 1 | 1))) % mod;
return res;
}
void print(int rt) {
if (t[rt].l == t[rt].r) {
printf("%lld ", t[rt].sum);
return;
}
push_down(rt);
int m = (t[rt].l + t[rt].r) / 2;
print((rt << 1));
print((rt << 1 | 1));
}
} T;
void init() {
f[1] = f[2] = 1;
for (int i = 3; i <= max_n - 1; i++) f[i] = (f[i - 2] + f[i - 1]) % mod;
}
int main() {
int n, m;
init();
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
T.build(1, n, 1);
while (m--) {
int op, l, r;
scanf("%d%d%d", &op, &l, &r);
if (op == 1)
T.update(l, r, 1);
else if (op == 2)
printf("%lld\n", T.query(l, r, 1));
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> v;
void luckynumber(long long n) {
if (n > 1e10) return;
v.push_back(n);
luckynumber(n * 10 + 4);
luckynumber(n * 10 + 7);
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
luckynumber(0);
sort(v.begin(), v.end());
for (long long i = 0; i < v.size(); i++) {
long long x = 0, y = 0;
if (v[i] >= n) {
string str = to_string(v[i]);
for (long long j = 0; j < str.length(); j++) {
if (str[j] == '4')
x++;
else
y++;
}
if (x == y) {
cout << v[i];
return 0;
}
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int max_n = 1011111, max_lev = 21, inf = 1111111111;
struct tree {
int a[4 * max_n], f[4 * max_n];
tree() {
memset(a, 0, sizeof(a));
memset(f, 0, sizeof(f));
}
void push(int v, int l, int r) {
if (f[v] != 0) {
a[v] += f[v];
f[2 * v] += f[v];
f[2 * v + 1] += f[v];
f[v] = 0;
}
}
void update(int v, int tl, int tr, int l, int r, int value) {
if (tl == l && tr == r) {
f[v] += value;
return;
}
push(v, tl, tr);
int mid = (tl + tr) / 2;
if (r <= mid) {
update(2 * v, tl, mid, l, r, value);
} else if (l > mid) {
update(2 * v + 1, mid + 1, tr, l, r, value);
} else {
update(2 * v, tl, mid, l, mid, value);
update(2 * v + 1, mid + 1, tr, mid + 1, r, value);
}
a[v] = min(a[2 * v] + f[2 * v], a[2 * v + 1] + f[2 * v + 1]);
}
int get_min(int v, int tl, int tr, int l, int r) {
if (tl == l && tr == r) {
return a[v] + f[v];
}
push(v, tl, tr);
int mid = (tl + tr) / 2;
if (r <= mid) {
return get_min(2 * v, tl, mid, l, r);
}
if (l > mid) {
return get_min(2 * v + 1, mid + 1, tr, l, r);
}
return min(get_min(2 * v, tl, mid, l, mid),
get_min(2 * v + 1, mid + 1, tr, mid + 1, r));
}
void write(int v, int l, int r) {
if (l == r) {
cout << l << ' ' << r << " - " << a[v] << " (" << f[v] << ")\n";
return;
}
cout << l << ' ' << r << " - " << a[v] << " (" << f[v] << ")\n";
int mid = (l + r) / 2;
write(2 * v, l, mid);
write(2 * v + 1, mid + 1, r);
}
};
int n, a[2][max_n], cl[2][max_n], num[2][max_n], f[max_n], sum[max_n];
pair<int, pair<int, int> > p[max_n], p2[max_n];
string s;
tree t;
bool cmp(int a, int b) { return s[a] < s[b] || s[a] == s[b] && a < b; }
void my_sort() {
memset(sum, 0, sizeof(sum));
for (int i = 0; i < n; ++i) {
++sum[p[i].second.first + 1];
}
for (int i = 1; i < n; ++i) {
sum[i] += sum[i - 1];
}
sum[0] = 0;
for (int i = 0; i < n; ++i) {
p2[sum[p[i].second.first]++] = p[i];
}
memset(sum, 0, sizeof(sum));
for (int i = 0; i < n; ++i) {
++sum[p2[i].first + 1];
}
for (int i = 1; i < n; ++i) {
sum[i] += sum[i - 1];
}
sum[0] = 0;
for (int i = 0; i < n; ++i) {
p[sum[p2[i].first]++] = p2[i];
}
}
void get_suffix_array() {
for (int i = 0; i < n; ++i) {
a[0][i] = i;
}
sort(a[0], a[0] + n, cmp);
int cnt = 0;
for (int i = 0; i < n; ++i) {
num[0][a[0][i]] = i;
}
for (int i = 0; i < n; ++i) {
while (i + 1 < n && s[a[0][i]] == s[a[0][i + 1]]) {
cl[0][i] = cnt;
++i;
}
cl[0][i] = cnt;
++cnt;
}
int f1 = 0, f2 = 1;
for (int lev = 1, len = 1; len <= n; ++lev, len *= 2) {
for (int i = 0; i < n; ++i) {
p[i] = make_pair(cl[f1][num[f1][i]],
make_pair(cl[f1][num[f1][(i + len) % n]], i));
}
sort(p, p + n);
for (int i = 0; i < n; ++i) {
a[f2][i] = p[i].second.second;
num[f2][a[f2][i]] = i;
}
cnt = 0;
for (int i = 0; i < n; ++i) {
while (i + 1 < n && p[i].first == p[i + 1].first &&
p[i].second.first == p[i + 1].second.first) {
cl[f2][i] = cnt;
++i;
}
cl[f2][i] = cnt;
++cnt;
}
swap(f1, f2);
}
}
int main() {
cin >> s;
n = s.length();
get_suffix_array();
int bal = 0;
for (int i = 0; i < n; ++i) {
if (s[i] == '(') {
++bal;
} else {
--bal;
}
t.update(1, 0, n - 1, i, i, bal);
}
for (int i = 0; i < n; ++i) {
int mn = t.get_min(1, 0, n - 1, 0, n - 1);
if (bal > 0) {
if (mn >= 0) {
f[i] = 1;
}
} else {
if (mn - bal >= 0) {
f[i] = 1;
}
}
int x = 1;
if (s[i] == '(') {
x = -1;
}
if (i + 1 < n) {
t.update(1, 0, n - 1, i + 1, n - 1, x);
}
if (i) {
t.update(1, 0, n - 1, 0, i - 1, x);
}
t.update(1, 0, n - 1, i, i, bal - t.get_min(1, 0, n - 1, i, i));
}
if (bal < 0) {
for (int i = 0; i < -bal; ++i) {
printf("(");
}
}
for (int i = 0; i < n; ++i) {
if (f[a[0][i]] == 1) {
int poz = a[0][i];
for (int j = 0; j < n; ++j) {
printf("%c", s[(j + poz) % n]);
}
break;
}
}
if (bal > 0) {
for (int i = 0; i < bal; ++i) {
printf(")");
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,sse4.1,sse4.2,popcnt,abm,mmx,avx")
using namespace std;
const long long maxn = 2000 + 20;
const long long inf = (long long)2e9;
const long double pi = asin(1) * 2;
const long double eps = 1e-8;
const long long mod = (long long)1e9 + 7;
const long long ns = 97;
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
long double C[maxn][maxn];
vector<pair<long long, long long> > g[maxn];
long double ans = 0;
long double al = 0;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
C[0][0] = 1;
for (long long i = 0; i < maxn; ++i) {
C[i][0] = 1;
for (long long j = 1; j < i; ++j) {
C[i][j] = C[i - 1][j - 1] + C[i - 1][j];
}
C[i][i] = 1;
}
long long n, k;
cin >> n >> k;
for (long long i = 0; i < n; ++i) {
for (long long j = i + 1; j < n; ++j) {
long long x;
cin >> x;
if (x != -1) {
g[i].push_back({j, x});
g[j].push_back({i, x});
}
}
}
for (long long i = 0; i < n; ++i) {
long long m = (long long)g[i].size();
if (m < k) continue;
long double s = C[m - 1][k - 1];
al += C[m][k];
long double res = 0;
for (auto& u : g[i]) {
res += u.second;
}
res = res * s;
ans += res;
}
ans = ans / al;
long long r = ans;
cout << r << '\n';
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int a, b, c, d;
bool solve(double t) {
double l1 = 1e233, r1 = -1e233;
double l2 = 1e233, r2 = -1e233;
for (int i = 0; i < 2; ++i)
for (int j = 0; j < 2; ++j) {
double ta = i ? a - t : a + t;
double tb = j ? d - t : d + t;
l1 = min(l1, ta * tb), r1 = max(r1, ta * tb);
}
for (int i = 0; i < 2; ++i)
for (int j = 0; j < 2; ++j) {
double ta = i ? b - t : b + t, tb = j ? c - t : c + t;
l2 = min(l2, ta * tb), r2 = max(r2, ta * tb);
}
if (r2 < l1 || r1 < l2) return false;
return true;
}
int main(int argc, char *argv[]) {
cin >> a >> b >> c >> d;
double l = 0, r = 2e9;
for (int i = 1; i <= 300; ++i) {
double mid = (l + r) / 2.;
if (solve(mid))
r = mid;
else
l = mid;
}
printf("%.12lf\n", l);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int N, Q, i, L, R, P[1000];
long long A[100000];
int euc(int X) {
int i, R = X;
for (i = 2; i * i <= R; i++) {
if (R % i == 0) {
for (X -= X / i; R % i == 0; R /= i) {
}
}
}
if (R > 1) {
X -= X / R;
}
return X;
}
long long kal(long long X, long long Y, int M) {
return min((X * Y) % M + M, X * Y);
}
long long pan(long long X, int Y, int M) {
if (Y == 0) {
return 1;
}
long long R = pan(X, Y >> 1, M);
R = kal(R, R, M);
if (Y & 1) {
R = kal(R, X, M);
}
return R;
}
long long ans(int D) {
if (D == R) {
return pan(A[D], 1, P[D - L]);
}
if (P[D - L] == 1) {
return min(A[D], (long long)2);
}
return pan(A[D], ans(D + 1), P[D - L]);
return R;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> N >> P[0];
for (i = 0; i < N; i++) {
cin >> A[i];
}
for (i = 1; P[i - 1] > 1; i++) {
P[i] = euc(P[i - 1]);
}
cin >> Q;
for (i = 0; i < Q; i++) {
cin >> L >> R;
L--;
R--;
cout << ans(L) % P[0] << '\n';
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
long long int ar[200009], br[200009], ans[200009];
int main() {
long long int n, k;
cin >> n >> k;
for (long long int i = 1; i <= n; i++) {
cin >> ar[i];
br[i] = ar[i];
}
sort(br + 1, br + n + 1);
for (long long int i = 1; i <= n; i++)
ans[i] = lower_bound(br + 1, br + n + 1, ar[i]) - br - 1;
for (long long int i = 1; i <= k; i++) {
long long int a, b;
cin >> a >> b;
if (ar[a] < ar[b])
ans[b]--;
else if (ar[b] < ar[a])
ans[a]--;
}
for (long long int i = 1; i <= n; i++) cout << ans[i] << " ";
cout << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, k, count = 0;
cin >> n >> k;
if (k != 1) {
while (n != 0) {
n /= 2;
count++;
}
cout << ((long long int)1 << count) - (long long int)1;
} else
cout << n;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, k;
cin >> n >> k;
cout << ((n / k) + 1) * k << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, s;
scanf("%lld %lld", &n, &s);
long long space[n + 5], gold, def;
for (int i = 0; i < n; i++) {
scanf("%lld", &space[i]);
}
vector<pair<long long, long long> > v;
for (int i = 0; i < s; i++) {
scanf("%lld %lld", &def, &gold);
v.push_back({def, gold});
}
sort(v.begin(), v.end());
long long sum[s + 5];
sum[0] = 0;
for (int i = 0; i < s; i++) {
sum[i + 1] = sum[i] + v[i].second;
}
for (int i = 0; i < n; i++) {
int it = lower_bound(v.begin(), v.end(),
pair<long long, long long>(space[i] + 1, 0)) -
v.begin();
printf("%d ", sum[it]);
}
printf("\n");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
int n;
char num[maxn], nb[maxn];
int main() {
scanf("%d", &n);
bool zero = false, b = true;
int dig = 0;
for (int i = 0; i < n; i++) {
scanf("%s", num);
if (zero) continue;
if (strcmp(num, "0") == 0) {
zero = true;
continue;
}
int len = strlen(num);
if (num[0] != '1') {
strcpy(nb, num);
b = false;
} else {
bool flag = true;
for (int i = 1; i < len; i++) {
if (num[i] != '0') {
flag = false;
b = false;
break;
}
}
if (flag) {
dig += (len - 1);
} else {
strcpy(nb, num);
}
}
}
if (zero)
printf("0\n");
else {
if (b)
putchar('1');
else
printf("%s", nb);
for (int i = 0; i < dig; i++) putchar('0');
putchar('\n');
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int h1, a1, c1, h2, a2;
cin >> h1 >> a1 >> c1 >> h2 >> a2;
int turn = 1;
vector<int> v;
while (h2 > 0) {
if (turn & 1) {
if (h1 <= a2 && h2 - a1 > 0) {
h1 += c1;
v.push_back(1);
} else {
h2 -= a1;
v.push_back(0);
}
turn++;
} else {
h1 -= a2;
turn++;
}
}
cout << v.size() << endl;
for (int i = 0; i < v.size(); i++) {
if (v[i])
cout << "HEAL" << endl;
else
cout << "STRIKE" << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int test;
cin >> test;
while (test) {
test--;
string x;
cin >> x;
int n = x.size();
vector<int> visited;
visited.push_back(0);
for (int i = 0; i < n; i++) {
if (x[i] == 'R') {
visited.push_back(i + 1);
}
}
visited.push_back(n + 1);
int siza = visited.size();
int temp1 = -INT_MAX;
if (!visited.size()) {
cout << n + 1;
} else {
for (int i = 1; i < siza; i++) {
temp1 = max(temp1, visited[i] - visited[i - 1]);
}
}
cout << temp1 << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int ans = 0, c;
for (int i = 1; i <= 5; i++) {
cin >> c;
ans += c;
}
if (ans == 0) {
cout << -1 << endl;
return 0;
}
if (ans % 5 == 0) {
cout << ans / 5 << endl;
} else {
cout << -1 << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool isprime(long long n) {
if (n < 2) return false;
if (n == 2 || n == 3) return true;
for (long long i = 2; i * i <= n; i++)
if (n % i == 0) return false;
return true;
}
int main() {
int t;
scanf("%d", &t);
while (t--) {
long long a, b;
scanf("%lld%lld", &a, &b);
if (isprime(a + b) && a - b == 1) {
cout << "YES\n";
} else
cout << "NO\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d, f[1001] = {}, i;
cin >> a >> b;
for (i = 1; i <= b; i++) {
cin >> c >> d;
f[c] = 1;
f[d] = 1;
}
c = 1;
while (f[c] != 0) {
c++;
}
cout << a - 1 << endl;
for (i = 1; i <= a; i++) {
if (i == c) {
continue;
}
cout << c << " " << i << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
long long n, m, a[211111], cnt[211111], ty[211111], x[211111], l[211111],
t[211111], b[211111];
int main() {
long long i, j, k, y, z, ca = 1, re = 0, tot = 1;
scanf("%I64d", &(n));
for (int i = (int)(1); i <= (int)(n); ++i) {
scanf("%I64d", &(ty[i]));
if (ty[i] == 1) {
scanf("%I64d", &(x[i]));
if (tot <= 200000) a[tot++] = x[i];
cnt[i] = cnt[i - 1] + 1;
} else {
scanf("%I64d%I64d", &(l[i]), &(t[i]));
long long st = tot;
for (tot; tot <= min(200000ll, st + l[i] * t[i] - 1); tot++) {
int rr = (tot - st) % l[i] + 1;
a[tot] = a[rr];
}
cnt[i] = cnt[i - 1] + l[i] * t[i];
}
}
scanf("%I64d", &(m));
for (i = 0; i < m; ++i) scanf("%I64d", &(b[i]));
for (int i = 0; i < (int)(m); ++i) {
y = upper_bound(cnt + 1, cnt + n + 1, b[i]) - cnt;
if (cnt[y - 1] == b[i]) {
if (ty[y - 1] == 1)
cout << x[y - 1] << ' ';
else
cout << a[l[y - 1]] << ' ';
} else {
int rr = b[i] - cnt[y - 1];
rr %= l[y];
if (rr == 0) rr += l[y];
cout << a[rr] << ' ';
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int isSame(string s) {
char f = s[0];
for (int i = 1; i < s.length(); i++) {
if (f != s[i]) {
return false;
}
}
return true;
}
int main() {
string s1, s2, answer = "";
bool isOk = true;
cin >> s1 >> s2;
for (int i = 0; i < s1.length(); i++) {
if (s1[i] == s2[i]) {
answer += "z";
} else if (s1[i] > s2[i]) {
answer += s2[i];
} else {
isOk = false;
}
}
if (!isOk) {
cout << -1 << endl;
} else {
cout << answer << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 55;
const long double eps = 1e-9;
long long n, w, m;
long long cnt[N];
vector<pair<long long, long double> > ans[N];
long double have[N], reqd[N];
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n >> w >> m;
for (long long i = 1; i <= n; i++) have[i] = w;
long double total = n * w;
total /= m;
for (long long i = 1; i <= m; i++) {
reqd[i] = total;
for (long long j = 1; j <= n; j++) {
if (reqd[i] < eps) break;
if (have[j] > eps) {
long double take = min(reqd[i], have[j]);
have[j] -= take;
reqd[i] -= take;
cnt[j]++;
ans[i].push_back({j, take});
}
}
}
for (long long i = 1; i <= n; i++) {
if (cnt[i] > 2) {
cout << "NO";
return 0;
}
}
for (long long i = 1; i <= m; i++) {
if (reqd[i] > eps) {
cout << "NO";
return 0;
}
}
cout << "YES"
<< "\n";
cout << fixed << setprecision(9);
for (long long i = 1; i <= m; i++) {
for (auto &it : ans[i]) cout << it.first << " " << it.second << " ";
cout << "\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
char s[109];
int n, l, f, t, i;
bool dp[109][350][59][2];
int ans = -(1 << 29);
char opp(char c) {
if (c == 'F') return 'T';
return 'F';
}
void go(int l, int pos, int nn, int dir) {
if (l == strlen(s)) {
if (nn == n) {
ans = max(ans, abs(pos));
}
return;
}
bool &u = dp[l][pos][nn][dir];
if (u) return;
u = 1;
for (int i = 0; i + nn <= n; i++) {
char c = s[l];
if (i & 1) c = opp(c);
if (c == 'T')
go(l + 1, pos, nn + i, !dir);
else
go(l + 1, pos + ((dir == 1) ? 1 : -1), nn + i, dir);
}
}
int main() {
gets(s);
scanf("%d", &n);
memset(dp, 0, sizeof(dp));
go(0, 0, 0, 1);
printf("%d", ans);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int q, n, maxgt = 0;
bool a[101];
void solve() {
int dem = 0, maxV = 0, nhom = 1, nhom1 = 1;
for (int i = 1; i <= maxgt + 1; ++i) {
if (a[i])
++dem;
else {
dem = 0;
nhom = max(nhom, nhom1);
nhom1 = 1;
}
if (dem != 0 && dem == 2) ++nhom1;
}
printf("%d\n", nhom);
for (int i = 1; i <= 100; ++i) a[i] = false;
}
int main() {
int x;
scanf("%d", &q);
for (int i = 1; i <= q; ++i) {
scanf("%d", &n);
for (int j = 1; j <= n; ++j)
scanf("%d", &x), a[x] = true, maxgt = max(maxgt, x);
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 210;
const long long inf = 1e16;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n = 0;
int m = 0;
int k = 0;
cin >> n >> m >> k;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
vector<vector<vector<long long>>> f(
n + 2, vector<vector<long long>>(k + 2, vector<long long>(2)));
for (int i = 0; i <= n; i++)
for (int j = 0; j <= k; j++) f[i][j][0] = f[i][j][1] = -inf;
f[0][0][0] = f[0][0][1] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j <= k; j++) {
f[i + 1][j + 1][1] = max(f[i + 1][j + 1][1], f[i][j][1] + a[i]);
if (m > 1) {
f[i + 1][j + 1][1] = max(f[i + 1][j + 1][1], f[i][j][0] + a[i]);
}
for (int h = 1; h < m; h++) {
if (i + h > n) continue;
f[i + h][j][0] = max(f[i + h][j][0], f[i][j][1]);
}
}
}
long long res = max(f[n][k][0], f[n][k][1]);
if (res < 0)
cout << -1;
else
cout << res;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct IO {
inline int read() {
int sum = 0, ff = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') ff = -1;
ch = getchar();
}
while (isdigit(ch)) sum = sum * 10 + (ch ^ 48), ch = getchar();
return sum * ff;
}
inline void write(int x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) write(x / 10);
putchar(x % 10 + 48);
}
inline void writeln(int x) {
write(x);
putchar('\n');
}
} fast;
const int dx[] = {0, 0, -1, 1};
const int dy[] = {-1, 1, 0, 0};
int n, m, vis[1505][1505][2];
char ch[1505][1505];
inline void dfs(int x, int y) {
if (vis[x % n][y % m][0] == -1 && vis[x % n][y % m][1] == -1) {
vis[x % n][y % m][0] = x;
vis[x % n][y % m][1] = y;
} else if (vis[x % n][y % m][0] != x || vis[x % n][y % m][1] != y) {
printf("Yes\n");
exit(0);
} else
return;
for (int i = 0; i < 4; i++) {
int tx = x + dx[i];
int ty = y + dy[i];
if (ch[tx % n][ty % m] == '.') dfs(tx, ty);
}
}
int main() {
scanf("%d%d", &n, &m);
int sx = 0, sy = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
cin >> ch[i][j];
if (ch[i][j] == 'S') {
ch[i][j] = '.';
sx = i + n * m;
sy = j + n * m;
}
}
memset(vis, -1, sizeof(vis));
dfs(sx, sy);
printf("No\n");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n <= 10 || n > 21) {
cout << 0 << endl;
} else if (n == 20) {
cout << 15 << endl;
} else {
cout << 4 << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
string to_string(long long x) {
string s;
bool neg = x < 0;
x = abs(x);
do {
s += char('0' + x % 10);
x /= 10;
} while (x != 0);
if (neg) s += '-';
reverse(s.begin(), s.end());
return s;
}
long long powmod(long long a, long long b, long long mod) {
if (b == 0 || a == 1) return mod == 1 ? 0 : 1;
if (b % 2 == 0) {
long long k = powmod(a, b / 2, mod);
return (k * k) % mod;
} else {
long long k = powmod(a, b / 2, mod);
return ((k * k) % mod * a) % mod;
}
}
long long gcd(long long a, long long b) {
while (b) {
a %= b;
swap(a, b);
}
return a;
}
bool is_prime(long long n) {
long long bound = sqrt(n);
long long d = 2;
while (d <= bound && n % d != 0) ++d;
return d * d > n;
}
const int MOD = 1000000007;
const int MOD2 = 1000000009;
const int BASE = 257;
const int INF = 1000000050;
const int MX = 100010;
const double EPS = 1e-9;
const int DI[]{1, -1, 0, 0};
const int DJ[]{0, 0, 1, -1};
mt19937 rnd;
void solve() {
string s;
cin >> s;
int l = INF;
int r = -1;
int n = s.size();
for (int i = 0; i < n; i++) {
if (s[i] == '1') {
l = min(l, i);
r = max(r, i);
}
}
if (l == INF)
cout << 0 << '\n';
else {
int ans = 0;
for (int i = l; i < r + 1; i++) {
if (s[i] == '0') ++ans;
}
cout << ans << '\n';
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
for (int i = 0; i < t; i++) solve();
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void sf(int &x) { scanf("%d", &x); }
void sf(long long &x) { scanf("%lld", &x); }
void sf(float &x) { scanf("%f", &x); }
void sf(double &x) { scanf("%lf", &x); }
void sf(int &x, int &y) { scanf("%d%d", &x, &y); }
void sf(float &x, float &y) { scanf("%f%f", &x, &y); }
void sf(double &x, double &y) { scanf("%lf%lf", &x, &y); }
void sf(double &x, double &y, double &z) { scanf("%lf%lf%lf", &x, &y, &z); }
void sf(int &x, int &y, int &z) { scanf("%d%d%d", &x, &y, &z); }
void sf(long long &x, long long &y, long long &z) {
scanf("%lld%lld%lld", &x, &y, &z);
}
void sf(float &x, float &y, float &z) { scanf("%u%u%u", &x, &y, &z); }
void sf(char &x) { x = getchar(); }
void sf(char *s) { scanf("%s", s); }
void sf(string &s) { cin >> s; }
void pf(int x) { printf("%d\n", x); }
void pf(int x, int y) { printf("%d %d\n", x, y); }
void pf(int x, int y, int z) { printf("%d %d %d\n", x, y, z); }
void pf(long long x) { printf("%lld\n", x); }
void pf(float x) { printf("%u\n", x); }
void pf(double x) { printf("%.6lf\n", x); }
void pf(double x, double y) { printf("%.5lf %.5lf\n", x, y); }
void pf(char x) { printf("%c\n", x); }
void pf(char *x) { printf("%s\n", x); }
void pf(string x) {
cout << x;
puts("");
}
template <class T>
T bigmod(T b, T p, T m) {
if (p == 0) return 1 % m;
T x = b;
T ans = 1;
while (p) {
if (p & 1) ans = (ans * x) % m;
p >>= 1;
x = (x * x) % m;
}
return ans;
}
template <class T>
T gcd(T x, T y) {
if (y == 0) return x;
return gcd(y, x % y);
}
template <typename T>
T POW(T b, T p) {
if (p == 1) return b;
if (p % 2 == 0) {
T s = POW(b, p / 2);
return s * s;
}
return b * POW(b, p - 1);
}
template <typename T>
T modinv(T num, T m) {
return bigmod(num, m - 2, m);
}
int n, m;
vector<pair<int, int> > v, an;
int c[109], a[109];
int main() {
sf(n, m);
for (int i = 0; i < n; i++) {
a;
sf(a[i]);
v.push_back(make_pair(a[i], i));
}
sort(v.begin(), v.end());
for (int i = 0; i < n; i++) {
if (i & 1) {
c[v[i].first] = 1;
} else
c[v[i].first] = 0;
}
for (int i = 0; i < m; i++) {
int x, y;
sf(x, y);
}
for (int i = 0; i < n; i++) cout << c[a[i]] << " ";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class stl>
void DBGSTL(stl a) {
for (__typeof((a).begin()) i = (a).begin(); i != (a).end(); i++) {
cerr << *i << " ";
}
cerr << "\n";
return;
}
using namespace std;
struct point {
int val, idx;
point(int a, int b) {
val = a;
idx = b;
}
point() {}
};
point min(point a, point b) {
if (a.val < b.val) {
return a;
} else {
return b;
}
}
int arr[100005];
int n;
point tree[3 * 100005];
point INF;
void build(int node, int left, int right) {
if (left > right) return;
if (left == right) {
tree[node].val = arr[left];
tree[node].idx = left;
return;
}
int mid = (left + right) / 2;
build(2 * node, left, mid);
build(2 * node + 1, mid + 1, right);
tree[node] = min(tree[2 * node], tree[2 * node + 1]);
return;
}
point query(int node, int left, int right, int i, int j) {
if (left >= i && right <= j) {
return tree[node];
}
if (right < i || left > j) return INF;
int mid = (left + right) / 2;
point ret1 = query(2 * node, left, mid, i, j);
point ret2 = query(2 * node + 1, mid + 1, right, i, j);
return min(ret1, ret2);
}
vector<pair<int, int> > ans;
void solve(int left, int right, int now) {
if (left > right) {
return;
}
if (left < 0 || right >= n || right < 0 || left >= n) {
return;
}
if (left == right) {
int v = arr[left] - now;
for (int i = 1; i <= v; i++) {
ans.push_back(pair<int, int>(left, right));
}
return;
}
point mn = query(1, 0, n - 1, left, right);
int v = arr[mn.idx] - now;
solve(left, mn.idx - 1, now + v);
solve(mn.idx + 1, right, now + v);
for (int i = 1; i <= v; i++) {
ans.push_back(pair<int, int>(left, right));
}
return;
}
int main() {
INF.val = 1000000;
INF.idx = -1;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &arr[i]);
}
build(1, 0, n - 1);
solve(0, n - 1, 0);
cout << ans.size() << "\n";
for (int i = 0; i < ans.size(); i++) {
printf("%d %d\n", ans[i].first + 1, ans[i].second + 1);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int q;
cin >> q;
while (q--) {
string s, t;
cin >> s >> t;
sort(s.begin(), s.end());
bool ok = 0;
for (int i = 0; i < t.size(); i++) {
if (i + s.size() - 1 >= t.size()) break;
string ss = "";
for (int j = i; j < i + s.size(); j++) {
ss += t[j];
}
sort(ss.begin(), ss.end());
if (ss == s) ok = 1;
}
if (ok) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
template <class T = int>
inline T readInt();
inline double readDouble();
inline int readUInt();
inline int readChar();
inline void readWord(char *s);
inline bool readLine(char *s);
inline bool isEof();
inline int getChar();
inline int peekChar();
inline bool seekEof();
inline void skipBlanks();
inline std::string readString();
template <class T>
inline void writeInt(T x, char end = 0, int len = -1);
inline void writeChar(int x);
inline void writeWord(const char *s);
inline void writeDouble(double x, int len = 0);
inline void flush();
static struct buffer_flusher_t {
~buffer_flusher_t() { flush(); }
} buffer_flusher;
using namespace std;
inline void init() {
srand(time(0));
ios_base::sync_with_stdio(0);
cin.tie(0);
}
template <class T, class S>
inline void rmax(T &a, S b) {
a = max(a, (T)b);
}
template <class T, class S>
inline void rmin(T &a, S b) {
a = min(a, (S)b);
}
inline long long mul(long long a, long long b, long long m) {
return a * b % m;
}
inline long long binpow(long long n, long long p, long long m) {
if (!p) return 1;
if (p & 1) return mul(n, binpow(n, p - 1, m), m);
long long v = binpow(n, p / 2, m);
return mul(v, v, m);
}
inline bool is_prime(long long n) {
for (long long i = 2; i * i <= n; ++i)
if (n % i == 0) return 0;
return 1;
}
inline vector<long long> factor(long long n) {
vector<long long> ans;
for (long long i = 2; i * i <= n; ++i)
while (n % i == 0) ans.push_back(i), n /= i;
if (n != 1) ans.push_back(n);
return ans;
}
inline vector<long long> divisors(long long n) {
vector<long long> ret;
for (long long i = 1; i * i <= n; ++i) {
if (n % i == 0) {
ret.push_back(i);
if (i * i != n) ret.push_back(n / i);
}
}
return ret;
}
inline vector<pair<long long, int>> factor_pows(long long n) {
auto fac = factor(n);
vector<pair<long long, int>> ret;
int L = 0;
while (L < (int)fac.size()) {
int R = L;
while (R < (int)fac.size() && fac[R] == fac[L]) ++R;
ret.push_back({fac[L], R - L});
L = R;
}
return ret;
}
inline long long gen_random_prime(long long L = (int)1e9) {
L += rand() % 4242;
while (!is_prime(L)) ++L;
return L;
}
inline long long nmod(long long a, long long m) { return (a % m + m) % m; }
inline int mrand() { return abs((1LL * rand() << 15) + rand()); }
struct HashedString {
string s;
vector<long long> MOD, POW;
vector<vector<long long>> hash;
vector<vector<long long>> pows;
string substr(int L, int n) { return s.substr(L, n); }
int size() const { return s.size(); }
char operator[](int n) const { return s[n]; }
vector<long long> get_hash(int L, int R) {
vector<long long> ret;
for (int i = 0; i < (int)hash.size(); ++i) {
ret.push_back(nmod(hash[i][R] - hash[i][L] * pows[i][R - L], MOD[i]));
}
return ret;
}
bool equal(int L1, int R1, int L2, int R2) {
return get_hash(L1, R1) == get_hash(L2, R2);
}
void operator+=(char c) {
s += c;
for (int i = 0; i < (int)hash.size(); ++i) {
long long m = MOD[i], p = POW[i], cp = pows[i].back(),
cm = hash[i].back();
cm = (cm * p + c) % m, cp = cp * p % m;
hash[i].push_back(cm);
pows[i].push_back(cp);
}
}
void operator+=(const string &oth) {
for (int i = 0; i < (int)hash.size(); ++i)
for (char c : oth) (*this) += c;
}
HashedString(const string &s, int n = 1) {
for (int i = 0; i < n; ++i) {
MOD.push_back(gen_random_prime());
POW.push_back(gen_random_prime());
hash.push_back({0}), pows.push_back({1});
}
(*this) += s;
}
};
const int MAXN = 3e5 + 42;
int n;
struct Treap {
Treap *left = NULL;
Treap *right = NULL;
long long t;
int y;
long long prefix_sum;
long long speed;
long long push = 0;
long long min_prefix_sum_in_subtree;
Treap(long long t, long long val, long long speed)
: t(t),
y(mrand()),
prefix_sum(val),
speed(speed),
min_prefix_sum_in_subtree(val) {}
};
typedef Treap *treap;
inline void vertex_add(treap a, long long push) {
a->prefix_sum += push;
a->min_prefix_sum_in_subtree += push;
a->push += push;
}
inline void push(treap a) {
long long push = a->push;
if (!push) return;
if (a->left) {
vertex_add(a->left, push);
}
if (a->right) {
vertex_add(a->right, push);
}
a->push = 0;
}
const long long INF = 1e18;
inline long long smin(treap a) {
return a ? a->min_prefix_sum_in_subtree : INF;
}
inline void recalc(treap a) {
a->min_prefix_sum_in_subtree =
min({smin(a->left), smin(a->right), a->prefix_sum});
}
inline treap merge(treap a, treap b) {
if (!a) return b;
if (!b) return a;
if (a->y < b->y) {
push(a);
a->right = merge(a->right, b);
recalc(a);
return a;
} else {
push(b);
b->left = merge(a, b->left);
recalc(b);
return b;
}
}
inline pair<treap, treap> split(treap a, long long k) {
if (!a) return {a, a};
push(a);
if (a->t < k) {
auto [l, r] = split(a->right, k);
a->right = l;
recalc(a);
return {a, r};
} else {
auto [l, r] = split(a->left, k);
a->left = r;
recalc(a);
return {l, a};
}
}
inline treap get_least(treap a) {
push(a);
if (!a->left) {
return a;
}
return get_least(a->left);
}
inline treap get_greatest(treap a) {
push(a);
if (!a->right) {
return a;
}
return get_greatest(a->right);
}
inline treap find_first_less(treap a, long long v) {
push(a);
if (smin(a->left) <= v) {
return find_first_less(a->left, v);
}
if (a->prefix_sum <= v) return a;
return find_first_less(a->right, v);
}
inline void print_tree(treap a) {
if (!a) return;
print_tree(a->left);
if (false) cerr << a->t << ' ';
print_tree(a->right);
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout.precision(20);
srand(time(0));
treap root = new Treap(0, 0, 0);
root = merge(root, new Treap(2e9, 0, 0));
int q = readInt();
int t;
int second, type;
for (int i = 0; i < q; ++i) {
type = readInt();
if (type == 1) {
t = readInt();
second = readInt();
auto [l, r] = split(root, t);
treap vr = get_least(r);
treap vl = get_greatest(l);
long long psum = vl->prefix_sum + (t - vl->t) * vl->speed;
long long new_psum = psum + (vr->t - t) * second;
vertex_add(r, new_psum - vr->prefix_sum);
root = merge(l, merge(new Treap(t, psum, second), r));
} else if (type == 2) {
t = readInt();
auto [l, tr] = split(root, t);
auto [y, r] = split(tr, t + 1);
treap vl = get_greatest(l);
treap vr = get_least(r);
long long new_psum = vl->prefix_sum + (vr->t - vl->t) * vl->speed;
vertex_add(r, new_psum - vr->prefix_sum);
root = merge(l, r);
} else {
int L = readInt();
int R = readInt();
long long v = readInt();
if (v == 0) {
cout << L << '\n';
continue;
}
auto [l, yr] = split(root, L);
auto [y, r] = split(yr, R + 1);
if (!y) {
cout << -1 << '\n';
} else {
treap vl = get_least(y);
treap vr = get_greatest(y);
long long searching_v = vl->prefix_sum - v;
if (y->min_prefix_sum_in_subtree > searching_v) {
long long new_psum = vr->prefix_sum + (R - vr->t) * vr->speed;
if (new_psum > searching_v) {
cout << "-1\n";
} else {
cout << vr->t +
(long double)(searching_v - vr->prefix_sum) / vr->speed
<< '\n';
}
} else {
treap h = find_first_less(y, searching_v);
auto [yl, yr] = split(y, h->t);
treap vyl = get_greatest(yl);
cout << vyl->t +
(long double)(searching_v - vyl->prefix_sum) / vyl->speed
<< '\n';
y = merge(yl, yr);
}
}
root = merge(l, merge(y, r));
}
}
}
static const int buf_size = 4096;
static unsigned char buf[buf_size];
static int buf_len = 0, buf_pos = 0;
inline string readString() {
const int MAX = 1e6 + 42;
static char buf[MAX];
readWord(buf);
return string(buf);
}
inline bool isEof() {
if (buf_pos == buf_len) {
buf_pos = 0, buf_len = fread(buf, 1, buf_size, stdin);
if (buf_pos == buf_len) return 1;
}
return 0;
}
inline int getChar() { return isEof() ? -1 : buf[buf_pos++]; }
inline int peekChar() { return isEof() ? -1 : buf[buf_pos]; }
inline bool seekEof() {
int c;
while ((c = peekChar()) != -1 && c <= 32) buf_pos++;
return c == -1;
}
inline void skipBlanks() {
while (!isEof() && buf[buf_pos] <= 32U) buf_pos++;
}
inline int readChar() {
int c = getChar();
while (c != -1 && c <= 32) c = getChar();
return c;
}
inline int readUInt() {
int c = readChar(), x = 0;
while ('0' <= c && c <= '9') x = x * 10 + c - '0', c = getChar();
return x;
}
template <class T>
inline T readInt() {
int second = 1, c = readChar();
T x = 0;
if (c == '-')
second = -1, c = getChar();
else if (c == '+')
c = getChar();
while ('0' <= c && c <= '9') x = x * 10 + c - '0', c = getChar();
return second == 1 ? x : -x;
}
inline double readDouble() {
int second = 1, c = readChar();
double x = 0;
if (c == '-') second = -1, c = getChar();
while ('0' <= c && c <= '9') x = x * 10 + c - '0', c = getChar();
if (c == '.') {
c = getChar();
double coef = 1;
while ('0' <= c && c <= '9') x += (c - '0') * (coef *= 1e-1), c = getChar();
}
return second == 1 ? x : -x;
}
inline void readWord(char *second) {
int c = readChar();
while (c > 32) *second++ = c, c = getChar();
*second = 0;
}
inline bool readLine(char *second) {
int c = getChar();
while (c != '\n' && c != -1) *second++ = c, c = getChar();
*second = 0;
return c != -1;
}
static int write_buf_pos = 0;
static char write_buf[buf_size];
inline void writeChar(int x) {
if (write_buf_pos == buf_size)
fwrite(write_buf, 1, buf_size, stdout), write_buf_pos = 0;
write_buf[write_buf_pos++] = x;
}
inline void flush() {
if (write_buf_pos)
fwrite(write_buf, 1, write_buf_pos, stdout), write_buf_pos = 0;
}
template <class T>
inline void writeInt(T x, char end, int output_len) {
if (x < 0) writeChar('-'), x = -x;
char second[24];
int n = 0;
while (x || !n) second[n++] = '0' + x % 10, x /= 10;
while (n < output_len) second[n++] = '0';
while (n--) writeChar(second[n]);
if (end) writeChar(end);
}
inline void writeWord(const char *second) {
while (*second) writeChar(*second++);
}
inline void writeDouble(double x, int output_len) {
if (x < 0) writeChar('-'), x = -x;
int t = (int)x;
writeInt(t), x -= t;
writeChar('.');
for (int i = output_len - 1; i > 0; i--) {
x *= 10;
t = std::min(9, (int)x);
writeChar('0' + t), x -= t;
}
x *= 10;
t = std::min(9, (int)(x + 0.5));
writeChar('0' + t);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
map<pair<unsigned long long, unsigned long long>, unsigned long long> dp;
unsigned long long lazy_dp(unsigned long long u, unsigned long long v) {
auto key = make_pair(u, v);
if (dp.count(key)) return dp[key];
unsigned long long ans = -1;
if (u == v)
ans = u;
else if ((u & 1) != (v & 1))
ans = -1;
else {
if (u & 1) {
unsigned long long r = lazy_dp(u / 2, (v - 1) / 2);
if (r != -1) ans = (r * 2);
} else {
unsigned long long r1 = lazy_dp(u / 2, (v - 2) / 2);
unsigned long long r2 = lazy_dp(u / 2, v / 2);
if (r1 != -1)
ans = 1 + (r1 * 2);
else if (r2 != -1)
ans = r2 * 2;
}
}
dp[key] = ans;
return ans;
}
int main(int argc, char **argv) {
ios::sync_with_stdio(false);
cin.tie(0);
unsigned long long u, v;
cin >> u >> v;
if (u > v || (u & 1) != (v & 1)) {
cout << "-1\n";
return 0;
}
if (u == v) {
if (u == 0)
cout << "0\n";
else
cout << "1\n" << u << "\n";
return 0;
}
auto p = lazy_dp(u, v);
if (p != -1)
cout << "2\n" << p << " " << (u ^ p) << "\n";
else {
unsigned long long diff = (v - u) / 2;
cout << "3\n" << u << " " << diff << " " << diff << "\n";
}
return 0;
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define mx 2000005
vector <int> v;
void Print()
{
for(auto it : v)
cout << it << " ";
cout << "\n";
}
void solve(int tc)
{
v.clear();
int n;
cin >> n;
for(int i=n; i>=1; i--){
v.push_back(i);
}
if(n%2 == 0)
Print();
else{
int mid = (n/2);
int mid2 = (n/2)+1;
swap(v[mid], v[mid2]);
Print();
}
}
int main()
{
ios_base::sync_with_stdio(0);
cin.tie(0);
//calc();
int t=1;
cin >> t;
for(int i=1; i<=t; i++)
solve(i);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
long long sum = 0;
long long cnt = 0;
for (int i = 0; i < k; i++) {
long long a, b;
cin >> a >> b;
sum += (n - a + 1) * b % n;
cnt += b;
}
if (cnt != n) {
cout << (cnt < n ? 1 : -1) << '\n';
return 0;
}
long long expected = (long long)n * (n + 1) / 2;
cout << (sum % n == expected % n ? 1 : -1) << '\n';
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> a[101];
long long vis[101] = {0}, c = 0, cnt = 0, siz = 0;
void dfs(long long s) {
vis[s] = 1;
cnt++;
siz += a[s].size();
for (auto it = a[s].begin(); it != a[s].end(); it++)
if (vis[*it] == 0) dfs(*it);
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long n, m, x, y, i;
cin >> n >> m;
for (i = 0; i < m; i++) {
cin >> x >> y;
a[x].push_back(y);
a[y].push_back(x);
}
for (i = 1; i <= n; i++) {
if (vis[i] == 0) {
cnt = 0;
siz = 0;
dfs(i);
if (2 * cnt == siz && cnt % 2 != 0) c++;
}
}
if ((c % 2 == 0 && n % 2 != 0) || (c % 2 != 0 && n % 2 == 0))
cout << c + 1;
else
cout << c;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void fileio() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
if (fopen("input.txt", "r")) {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
}
const long double eps = 1e-7;
long long n, k, a[5005], pf[5005] = {0};
int main() {
fileio();
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) pf[i] = a[i] + pf[i - 1];
double res = 0.0;
for (int i = 1; i <= n; i++)
for (int j = i + k - 1; j <= n; j++) {
res = max(res, ((pf[j] - pf[i - 1]) * 1.0) / ((j - i + 1) * 1.0));
}
cout << fixed << setprecision(11) << res;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 35, P = 998244353, Q = 1000000;
int n, x[maxn], inv[maxn], C[maxn][maxn], px[maxn * maxn];
vector<int> a[maxn * maxn];
inline void inc(int &x, int y) {
if ((x += y) >= P) x -= P;
}
inline void dec(int &x, int y) {
if ((x -= y) < 0) x += P;
}
int qp(int x, int y) {
int z = 1;
for (; y; y >>= 1, x = 1LL * x * x % P) {
if (y & 1) z = 1LL * z * x % P;
}
return z;
}
vector<int> integrate(vector<int> a) {
vector<int> b = {0};
for (int i = 0; i < a.size(); i++) {
b.push_back(1LL * a[i] * inv[i + 1] % P);
}
return b;
}
void sub(vector<int> &a, vector<int> b) {
while (a.size() < b.size()) a.push_back(0);
for (int i = 0; i < b.size(); i++) {
dec(a[i], b[i]);
}
}
vector<int> shift(vector<int> a, int d) {
vector<int> b(a.size()), pw = {1};
for (int i = 0; i < a.size(); i++) {
pw.push_back(1LL * d * pw.back() % P);
}
for (int i = 0; i < a.size(); i++) {
for (int j = 0; j <= i; j++) {
inc(b[j], 1LL * a[i] * C[i][j] % P * pw[i - j] % P);
}
}
return b;
}
int eval(vector<int> a, int x) {
int ans = 0;
for (int i = (int)a.size() - 1; ~i; i--) {
ans = (1LL * ans * x + a[i]) % P;
}
return ans;
}
int main() {
scanf("%d", &n);
for (int i = 0; i <= n; i++) {
inv[i] = qp(i, P - 2);
for (int j = C[i][0] = 1; j <= i; j++) {
C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % P;
}
}
vector<int> decimal = {0};
for (int i = 0; i < n; i++) {
double foo;
scanf("%lf", &foo);
x[i] = round(foo * Q);
decimal.push_back(x[i] % Q);
}
sort(decimal.begin(), decimal.end());
decimal.resize(unique(decimal.begin(), decimal.end()) - decimal.begin());
int cnt = decimal.size();
for (int i = 0; i <= cnt * n; i++) {
px[i] = 1LL * (i / cnt * Q + decimal[i % cnt]) * qp(Q, P - 2) % P;
}
for (int i = 0; i < n; i++) {
x[i] = 1LL * x[i] * qp(Q, P - 2) % P;
for (int j = 0; j <= cnt * n; j++) {
if (x[i] == px[j]) {
x[i] = j;
break;
}
}
}
for (int i = 0; i < cnt * n; i++) {
a[i] = {i < min(cnt, x[0])};
}
for (int i = 1; i < n; i++) {
for (int j = 0; j < cnt * n; j++) {
a[j] = integrate(a[j]);
}
for (int j = cnt * n - 1; ~j; j--) {
dec(a[j][0], eval(a[j], px[j]));
for (int k = j - 1; k >= max(0, j - cnt); k--) {
inc(a[j][0], eval(a[k], px[k + 1]));
if (k > j - cnt)
dec(a[j][0], eval(a[k], px[k]));
else
sub(a[j], shift(a[j - cnt], P - 1));
}
}
for (int j = x[i]; j < cnt * n; j++) {
a[j] = {0};
}
}
int ans = 0;
for (int i = 0; i < n * cnt; i++) {
vector<int> b = integrate(a[i]);
inc(ans, eval(b, px[i + 1]));
dec(ans, eval(b, px[i]));
}
printf("%d\n", ans);
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const char letters[] = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i',
'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r',
's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};
const int dx[] = {0, -1, 0, 1, -1, -1, 1, 1};
const int dy[] = {1, 0, -1, 0, 1, -1, 1, -1};
int inline max3(int a, int b, int c) { return max(a, max(b, c)); }
int n;
long long ab, a, b;
int main() {
scanf("%d", &n);
while (n--) {
scanf("%lld", &a);
scanf("%lld", &b);
ab = a * 1LL * b;
int l = 1, r = 1e6, mid;
while (l < r) {
mid = l + (r - l + 1) / 2;
if (1LL * mid * mid * mid <= ab)
l = mid;
else
r = mid - 1;
}
if (1LL * r * r * r == ab && a % r == 0 && b % r == 0)
puts("YES");
else
puts("NO");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e9;
const double eps = (double)1e-8;
const int mod = (int)1000000007;
const int maxn = (int)1e5 + 5;
long long ans, n, m, s1, ms1, d[2003][2003];
string st;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
cin >> st;
s1 = 0;
ms1 = 0;
for (int i = (0); i < (m); i++) {
if (st[i] == '(')
s1++;
else
s1--;
ms1 = min(ms1, s1);
}
d[0][0] = (long long)1;
for (int i = (1); i <= (2000); i++) {
d[i][0] = d[i - 1][1];
for (int j = (1); j <= (2000); j++) {
d[i][j] = (d[i - 1][j - 1] + d[i - 1][j + 1]) % mod;
}
}
ans = (long long)0;
for (int i = (0); i <= (n - m); i++) {
for (int j = (0); j <= (n - m); j++) {
if (j + ms1 >= 0 && j + s1 <= n - m)
ans += (long long)d[i][j] * (long long)d[n - m - i][j + s1];
ans %= mod;
}
}
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n, m, q;
vector<int> adj[N];
vector<int> people[N];
int tt;
int st[N], en[N];
int lca[19][N];
vector<int> p[19][N];
vector<int> merge(vector<int> &a, vector<int> &b) {
vector<int> ret = a;
ret.insert(ret.end(), b.begin(), b.end());
sort(ret.begin(), ret.end());
ret.erase(unique(ret.begin(), ret.end()), ret.end());
if (ret.size() > 10) ret.resize(10);
return ret;
}
void dfs(int node, int par) {
st[node] = ++tt;
lca[0][node] = par;
for (int i = 1; i < 19; i++) {
lca[i][node] = lca[i - 1][lca[i - 1][node]];
}
vector<int> v = merge(people[node], people[par]);
p[0][node] = v;
for (int i = 1; i < 19; i++) {
p[i][node] = merge(p[i - 1][node], p[i - 1][lca[i - 1][node]]);
}
for (auto to : adj[node]) {
if (to != par) dfs(to, node);
}
en[node] = ++tt;
}
bool check(int a, int b) { return st[a] < st[b] && en[a] > en[b]; }
void output(int l, int r, int a) {
if (l == r) {
cout << min(a, (int)people[l].size()) << " ";
for (int i = 0; i < min(a, (int)people[l].size()); i++) {
cout << people[l][i] << " ";
}
cout << "\n";
return;
}
vector<int> v;
for (int i = 18; ~i; i--) {
if (!check(lca[i][l], r)) {
v = merge(v, p[i][l]);
l = lca[i][l];
}
}
for (int i = 18; ~i; i--) {
if (!check(lca[i][r], l)) {
v = merge(v, p[i][r]);
r = lca[i][r];
}
}
if (l != r) {
v = merge(v, p[0][l]);
v = merge(v, p[0][r]);
}
cout << min((int)v.size(), a) << " ";
for (int i = 0; i < min((int)v.size(), a); i++) cout << v[i] << " ";
cout << "\n";
}
void solve() {
cin >> n >> m >> q;
for (int i = 1; i < n; i++) {
int a, b;
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
}
for (int i = 1; i <= m; i++) {
int a;
cin >> a;
people[a].push_back(i);
}
for (int i = 1; i <= n; i++) {
sort(people[i].begin(), people[i].end());
if (people[i].size() > 10) people[i].resize(10);
}
dfs(1, 1);
while (q--) {
int l, r, a;
cin >> l >> r >> a;
output(l, r, a);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
unsigned long long n;
cin >> n;
if (n % 2 == 1) {
cout << 0;
} else {
long long cnt = 1;
for (long long i = 0; i < n / 2; i++) {
cnt *= 2;
}
cout << cnt;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
set<int> ss;
for (int i = 0; i < n; i++) {
int broj;
cin >> broj;
while (broj % 2 == 0) broj /= 2;
while (broj % 3 == 0) broj /= 3;
ss.insert(broj);
}
if (ss.size() == 1)
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, c = 1, p = 1;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
for (int j = i - 1; j >= 0; j--) {
if (a[i] == a[j]) {
p++;
}
}
if (p > c) c = p;
p = 1;
}
cout << c;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void solve(istream &in, ostream &out);
int main() {
ios::sync_with_stdio(false);
solve(cin, cout);
return 0;
}
static inline int g1(int n) {
if (n == 1 || n == 3) {
return 1;
}
if (n % 2) {
return 0;
}
int h1 = g1(n - 1);
int h2 = g1(n / 2);
if (h1 > h2) {
swap(h1, h2);
}
if (h1 > 0) {
return 0;
}
if (h2 == 1) {
return 2;
}
return 1;
}
static inline int g0(int n) {
if (n <= 2) {
return n;
}
return 1 - n % 2;
}
void solve(istream &in, ostream &out) {
int n, k;
in >> n >> k;
int ans = 0;
if (k % 2) {
for (int i = 0, a; i < n; ++i) {
in >> a;
ans ^= g1(a);
}
} else {
for (int i = 0, a; i < n; ++i) {
in >> a;
ans ^= g0(a);
}
}
if (ans) {
out << "Kevin" << endl;
} else {
out << "Nicky" << endl;
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int CAPS = 0, caps = 0;
string a;
cin >> a;
for (int i = 0; i < a.length(); i++) {
if ((int)a[i] > (int)'@' && (int)a[i] < (int)'[') {
CAPS += a[i] - (int)'@';
}
if ((int)a[i] > (int)'`' && (int)a[i] < (int)'{') {
caps += a[i] - (int)'`';
}
}
cout << CAPS - caps;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, x;
set<int> s;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d", &x);
if (x) s.insert(x);
}
printf("%d\n", s.size());
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int oo = 1 << 30;
const double PI = M_PI;
const double EPS = 1e-15;
const int MaxN = 1000005;
int N;
int values[4 * MaxN];
int P[MaxN];
int zero(int x) { return 2 * x + 1; }
int one(int x) { return 2 * x + 2; }
void update(int node, int x, int deep, int val) {
if (deep == -1) {
values[node] += val;
return;
}
if (x & (1 << deep))
update(one(node), x, deep - 1, val);
else
update(zero(node), x, deep - 1, val);
values[node] = values[one(node)] + values[zero(node)];
}
int pick(int node, int x, int deep, int current) {
if (deep == -1) return current;
if (x & (1 << deep)) {
if (values[zero(node)])
return pick(zero(node), x, deep - 1, current);
else
return pick(one(node), x, deep - 1, current | (1 << deep));
} else {
if (values[one(node)])
return pick(one(node), x, deep - 1, current | (1 << deep));
else
return pick(zero(node), x, deep - 1, current);
}
}
int main() {
cin.sync_with_stdio(false);
cin >> N;
N = N + 1;
for (int i = 0; i < N; i++) update(0, i, 19, +1);
long long answer = 0;
for (int i = 0; i < N; i++) {
P[i] = pick(0, i, 19, 0);
update(0, P[i], 19, -1);
answer = answer + (i ^ P[i]);
}
cout << answer << endl;
for (int i = 0; i < N; i++) cout << P[i] << " ";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool prime[1000010];
void sieve() {
prime[0] = prime[1] = 1;
for (int i = 2; i * i < 1000010; ++i)
if (!prime[i])
for (int j = i * i; j <= 1000010; j += i) prime[j] = 1;
}
int main() {
sieve();
int n;
long long int x, sq;
scanf("%d", &n);
while (n--) {
scanf("%I64d", &x);
sq = sqrt(x);
puts(!prime[sq] && sq * sq == x ? "YES" : "NO");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename C>
void MA(C& a, C b) {
if (a < b) a = b;
}
template <typename C>
void MI(C& a, C b) {
if (a > b) a = b;
}
int n, c;
void nie() {
puts("IMPOSSIBLE");
exit(0);
}
vector<int> l[1000001], r[1000001];
vector<int> wyn;
int dfs(int i, int cn) {
if (i == cn) return cn - 1;
if (l[i].size() == 0) {
wyn.push_back(i);
for (int j = 0; j < r[i].size(); j++) MA(cn, r[i][j] + 1);
return dfs(i + 1, cn);
} else {
int ma = l[i][0];
for (int j = 0; j < l[i].size(); j++) MA(ma, l[i][j]);
int pom = dfs(i + 1, ma + 1);
wyn.push_back(i);
for (int j = 0; j < r[i].size(); j++)
if (r[i][j] <= pom) nie();
ma = max(cn, pom + 1);
for (int j = 0; j < r[i].size(); j++) MA(ma, r[i][j] + 1);
return dfs(pom + 1, ma);
}
}
int main() {
scanf("%d%d", &n, &c);
for (int i = 0; i < c; i++) {
int a, b;
scanf("%d%d", &a, &b);
a--;
b--;
if (b <= a) nie();
char z[6];
scanf("%s", z);
if (z[0] == 'L') {
l[a].push_back(b);
} else {
r[a].push_back(b);
}
}
dfs(0, n);
for (int i = 0; i < n; i++) printf("%d ", wyn[i] + 1);
puts("");
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
long long n, k;
cin >> n >> k;
pair<long long, long long> a[n];
for (long long i = 0; i < n; ++i) {
cin >> a[i].first;
a[i].second = i;
}
sort(a, a + n);
vector<long long> ans[n];
long long val = a[0].first;
for (long long i = 0; i < n; ++i) {
long long x = a[i].first;
for (long long j = 0; j < min(x, val + 1); ++j) {
a[i].first--;
ans[a[i].second].push_back(0);
}
}
for (long long i = 0; i < n; ++i) {
while (a[i].first--) {
ans[a[i].second].push_back(ans[a[i].second].back() + 1);
}
}
bool access = true;
for (long long i = 0; i < n; ++i) {
for (long long to : ans[i]) {
if (to + 1 > k) access = false;
}
}
if (access) {
cout << "YES" << endl;
for (long long i = 0; i < n; ++i) {
for (long long to : ans[i]) {
cout << to + 1 << ' ';
}
cout << endl;
}
} else {
cout << "NO";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
vector<pair<int, int> > ans;
deque<pair<char, int> > st;
for (int i = 0; i < s.size(); i++) {
if (st.size() == 0 && ((s[i] == ']') || (s[i] == ')')))
continue;
else if (s[i] == '[') {
st.push_back(make_pair('[', i));
} else if (s[i] == '(') {
st.push_back(make_pair('(', i));
} else if (s[i] == ']') {
if (st.size() && st.back().first == '[') {
while (ans.size() && ans.back().first > st.back().second)
ans.pop_back();
ans.push_back(make_pair(st.back().second, i));
st.pop_back();
} else {
st.clear();
}
} else if (s[i] == ')') {
if (st.size() && st.back().first == '(') {
while (ans.size() && ans.back().first > st.back().second)
ans.pop_back();
ans.push_back(make_pair(st.back().second, i));
st.pop_back();
} else {
st.clear();
}
}
}
if (ans.size() == 0) {
cout << "0";
return 0;
}
string res = "";
int mx = 0;
int lr = -1;
int lz = -1;
sort(ans.begin(), ans.end());
int l = -1;
int r = -1;
for (int i = 0; i < ans.size(); i++) {
if (ans[i].second < r) continue;
l = ans[i].first;
r = ans[i].second;
while (i < ans.size() - 1 && ans[i + 1].first - ans[i].second == 1) {
i++;
r = ans[i].second;
}
string temp = "";
int cnt = 0;
for (int j = l; j <= r; j++) {
cnt += (s[j] == '[');
}
if (cnt > mx) {
mx = cnt;
lr = l;
lz = r;
}
}
if (lr == -1) {
cout << "0";
return 0;
}
cout << mx << endl;
for (int j = lr; j <= lz; j++) cout << s[j];
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cout.tie(nullptr);
cout << fixed;
cout.precision(10);
int n, k;
cin >> n >> k;
long long arr[n + 1];
for (int i = 1; i <= n; i++) {
cin >> arr[i];
}
for (int i = n - 1; i > 0; i--) {
arr[i] += arr[i + 1];
}
priority_queue<long long> pq;
for (int i = 2; i <= n; i++) {
pq.push(arr[i]);
}
long long sum = 0ll;
sum += arr[1];
for (int i = 0; i < k - 1; i++) {
sum += pq.top();
pq.pop();
}
cout << sum;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long nax = 1e5 + 7;
const long long mod = 1e9 + 7;
const long long inf = numeric_limits<long long>::max();
long long n, m;
bool check(vector<long long> &vec) {
vector<long long> freq(n + 1, 0);
for (long long i = 0; i < n; i++) {
if (vec[i] > n) return false;
freq[vec[i]]++;
if (freq[vec[i]] > 1) {
return false;
}
}
for (long long i = 0; i < n; i++) {
if (freq[i + 1] != 1) return false;
}
return true;
}
void test() {
cin >> n;
vector<long long> vec;
vec.push_back(0);
long long first = 0;
for (long long i = 1; i < n; i++) {
long long t;
cin >> t;
vec.push_back(vec.back() + t);
first = min(first, vec.back());
}
first = 1 - first;
for (long long &x : vec) x += first;
if (check(vec))
for (long long x : vec) cout << x << ' ';
else
cout << -1;
}
signed main() {
ios_base ::sync_with_stdio(false);
cin.tie(NULL);
long long T = 1;
while (T--) {
test();
cout << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long int n;
cin >> n;
unordered_map<long long int, long long int> arr;
long long int arr1[n];
long long int maxx = INT_MIN;
for (int i = 0; i < n; i++) {
cin >> arr1[i];
arr[arr1[i]]++;
maxx = max(maxx, arr1[i]);
}
vector<long long int> ans(maxx + 1, 0);
ans[0] = 0;
ans[1] = arr[1];
for (long long int i = 2; i <= maxx; i++) {
ans[i] = max(ans[i - 1], ans[i - 2] + (i * arr[i]));
}
cout << ans[maxx];
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
struct Complex {
double real, imag;
Complex(double a = 0, double b = 0) : real(a), imag(b) {}
Complex operator+(Complex p) { return Complex(real + p.real, imag + p.imag); }
Complex operator-(Complex p) { return Complex(real - p.real, imag - p.imag); }
Complex operator*(Complex p) {
return Complex(real * p.real - imag * p.imag,
real * p.imag + imag * p.real);
}
Complex operator*(double p) { return Complex(real * p, imag * p); }
Complex operator/(double p) { return Complex(real / p, imag / p); }
Complex conj() { return Complex(real, -imag); }
};
ostream &operator<<(ostream &os, const Complex &p) {
return os << "(" << p.real << ", " << p.imag << ")";
}
const int ms = 1 << 20;
char buff[ms];
int a[ms], b[ms];
Complex aux[ms];
void fft(Complex p[], int n, int oper) {
for (int i = 1, j = 0; i < n - 1; ++i) {
for (int s = n; j ^= s >>= 1, ~j & s;)
;
if (i < j) swap(p[i], p[j]);
}
Complex wn, w;
for (int d = 0; (1 << d) < n; ++d) {
int m = 1 << d, m2 = m << 1;
double p0 = pi / m * oper;
wn = Complex(cos(p0), sin(p0));
for (int i = 0; i < n; i += m2) {
w = 1;
for (int j = 0; j < m; ++j) {
Complex &p1 = p[i + j + m], &p2 = p[i + j];
Complex t = w * p1;
p1 = p2 - t;
p2 = p2 + t;
w = w * wn;
}
}
}
if (oper == -1)
for (int i = 0; i < n; ++i) p[i] = p[i] / n;
}
void mult(int a[], int &n, int b[], int m) {
int N = 1;
while (N < n + m) N <<= 1;
for (int i = 0; i < N; ++i) {
aux[i].real = i < n ? a[i] : 0;
aux[i].imag = i < m ? b[i] : 0;
}
fft(aux, N, 1);
for (int i = 0; i <= (N >> 1); ++i) {
int j = (N - i) & (N - 1);
aux[i] = (aux[i] * aux[i] - (aux[j] * aux[j]).conj()) * Complex(0, -0.25);
aux[j] = aux[i].conj();
}
fft(aux, N, -1);
for (int i = 0; i < N; ++i) {
}
n += m - 1;
for (int i = 0; i < n; ++i) {
a[i] = aux[i].real + 0.5;
}
}
int read() {
int x = 0;
int c = getchar();
for (; !isdigit(c); c = getchar()) {
}
for (; isdigit(c); c = getchar()) {
x = x * 10 + c - '0';
}
return x;
}
void write(int x) {
if (x / 10) {
write(x / 10);
}
putchar(x % 10 + '0');
}
int main() {
int t = read();
while (t--) {
int n = read();
scanf(" %s", buff);
for (int i = 0; i < n; ++i) {
a[i] = buff[i] == 'V';
b[n - i - 1] = buff[i] == 'K';
}
int N = n;
mult(a, N, b, n);
vector<int> ans;
for (int d = 1; d <= n; ++d) {
bool ok = true;
for (int i = (n % d - 1 + d) % d; i < N; i += d) {
ok &= a[i] == 0;
}
if (ok) {
ans.push_back(d);
}
}
printf("%d\n", (int)ans.size());
for (int d : ans) {
printf("%d ", d);
}
puts("");
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
int main() {
int c = 0, d = 0, n = 0, m = 0, k = 0;
std::cin >> c >> d >> n >> m >> k;
int p = 0;
int a = n * m - k;
if (a > 0) {
int p1 = (a + n - 1) / n * c;
int p2 = a * d;
int p12 = a / n * c + a % n * d;
p = std::min(std::min(p1, p2), p12);
}
std::cout << p;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
struct Edge {
int v, next;
} edge[N * 2];
int head[N], cnt, turn[N], a[N], vis[N], ans;
void addedge(int u, int v) {
edge[cnt].v = v;
edge[cnt].next = head[u];
head[u] = cnt++;
}
void init() {
memset(head, -1, sizeof(head));
memset(vis, 0, sizeof(vis));
cnt = 0;
ans = 0;
}
void dfs(int u, int x1, int x2) {
if (vis[u]) return;
vis[u] = 1;
a[u] = a[u] ^ x1;
if (a[u]) {
turn[ans++] = u;
x1 ^= 1;
a[u] = 0;
}
for (int i = head[u]; i + 1; i = edge[i].next) {
int v = edge[i].v;
dfs(v, x2, x1);
}
return;
}
int main() {
int n;
cin >> n;
int t = n;
int u, v;
init();
while (--t) {
cin >> u >> v;
addedge(u, v);
addedge(v, u);
}
for (int i = 1; i <= n; i++) cin >> a[i];
int x;
for (int i = 1; i <= n; i++) {
cin >> x;
a[i] ^= x;
}
dfs(1, 0, 0);
cout << ans << endl;
for (int i = 0; i < ans; i++) cout << turn[i] << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m, x, y;
vector<int> v[3005];
long long cal(int k) {
vector<int> bk;
long long res = 0;
long long cnt = v[1].size();
for (int i = 2; i <= m; i++) {
int num = v[i].size();
for (int j = 0; j < num; j++) {
if (num - j >= k) {
res += v[i][j];
cnt++;
} else
bk.push_back(v[i][j]);
}
}
if (cnt < k) {
sort(bk.begin(), bk.end());
for (int i = 0; i < bk.size() && cnt < k; i++) {
res += bk[i];
cnt++;
}
}
return cnt < k ? 0x3f3f3f3f3f3f3f3f : res;
}
int main() {
while (~scanf("%d %d", &n, &m)) {
for (int i = 1; i <= m; i++) v[i].clear();
for (int i = 1; i <= n; i++) {
scanf("%d %d", &x, &y);
v[x].push_back(y);
}
for (int i = 1; i <= m; i++) sort(v[i].begin(), v[i].end());
long long ans = 0x3f3f3f3f3f3f3f3f;
for (int i = 1; i <= n; i++) ans = min(ans, cal(i));
printf("%lld\n", ans);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 600 + 7, N = 600;
const long long MOD = (1e9) + 7, B = (1e9) + 1;
int n, Fa[maxn], id[maxn], v[maxn], vs, r, k, sum[maxn];
long long a[maxn], F[maxn][maxn], C[maxn][maxn], ans;
int find(int k) { return (Fa[k] == k) ? (k) : (Fa[k] = find(Fa[k])); }
bool check(long long p) {
long long L = 1, R = B, mid;
while (L < (R - 1)) {
mid = (L + R) >> 1;
if ((mid * mid) > p)
R = mid - 1;
else
L = mid;
}
if ((L * L) == p) return true;
if ((R * R) == p) return true;
return false;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) Fa[i] = i;
for (int i = 1; i <= n; i++) {
scanf("%I64d", &a[i]);
for (int j = 1; j <= i - 1; j++)
if (check(a[i] * a[j])) {
Fa[i] = find(j);
break;
}
}
for (int i = 1; i <= n; i++) {
k = find(i);
if (!id[k]) id[k] = ++vs;
++v[id[k]];
}
for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + v[i];
for (int i = 0; i <= N; i++) C[i][0] = C[i][i] = 1;
for (int i = 2; i <= N; i++)
for (int j = 1; j <= i - 1; j++)
C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % MOD;
F[1][v[1] - 1] = 1;
for (int i = 1; i <= vs - 1; i++) {
for (int j = 0; j <= sum[i] - 1; j++) {
if (!F[i][j]) continue;
for (int l = 1; l <= v[i + 1]; l++) {
r = min(l, j);
for (int K = 0; K <= r; K++) {
F[i + 1][j - l + v[i + 1] - K] +=
(((((F[i][j] * C[v[i + 1] - 1][l - 1]) % MOD) * C[j][K]) % MOD) *
C[sum[i] + 1 - j][l - K]) %
MOD;
if (F[i + 1][j - l + v[i + 1] - K] >= MOD)
F[i + 1][j - l + v[i + 1] - K] -= MOD;
}
}
}
}
ans = F[vs][0];
for (int i = 1; i <= vs; i++)
for (int j = 2; j <= v[i]; j++) ans = (ans * (long long)(j)) % MOD;
printf("%I64d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n;
int m;
int main() {
cin >> n;
for (int i = 1; i <= n; i += 2) {
cout << i << " ";
}
m = n - 1;
if ((n - 1) % 2 == 0) {
m = n - 2;
}
for (int i = m; i >= 1; i -= 2) {
cout << i << " ";
}
for (int i = 2; i <= n; i += 2) {
cout << i << " ";
}
m = n - 1;
if ((n - 1) % 2 == 1) {
m = n - 2;
}
for (int i = m; i >= 1; i -= 2) {
cout << i << " ";
}
cout << n << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, k, a[222], s[222], b[222], c[222], w, q, M = -99999, m;
int main() {
cin >> n >> k;
s[0] = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
s[i] = s[i - 1] + a[i];
}
for (int l = 0; l <= n - 1; l++)
for (int r = l + 1; r <= n; r++) {
m = s[r] - s[l];
w = 0;
q = 0;
for (int i = 1; i <= n; i++) {
if (i > l && i <= r) {
w++;
b[w] = a[i];
} else {
q++;
c[q] = a[i];
}
}
sort(b + 1, b + w + 1);
sort(c + 1, c + q + 1);
reverse(c + 1, c + q + 1);
for (int i = 1; i <= min(k, min(q, w)); i++) {
if (c[i] - b[i] > 0) m = m - b[i] + c[i];
}
M = max(M, m);
}
cout << M;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool bo[1000005];
int main() {
int n;
cin >> n;
int q = 2;
vector<int> v;
for (int i = 1; i <= n; i++) {
if (bo[i] == 0) {
for (int j = i; j <= n; j += q) {
if (bo[j] == 0) {
bo[j] = 1;
v.push_back(i);
}
}
q *= 2;
}
}
if (n != v.back()) {
int q = v.back();
q = (q + (q * 2)) / 2;
if (n >= q) {
v.pop_back();
v.push_back(q);
}
}
for (auto it : v) cout << it << " ";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int x[1001];
int main() {
int n, i, sum, c;
sum = c = 0;
cin >> n;
for (i = 1; i <= n; i++) {
sum = sum + i;
if (sum == n) {
x[c] = i;
c++;
break;
} else if (sum < n) {
if ((sum + (i + 1)) <= n) {
x[c] = i;
c++;
} else if ((sum + (i + 1)) > n) {
x[c] = i + (n - sum);
c++;
break;
}
}
}
cout << c << endl;
for (i = 0; i < c; i++) cout << x[i] << " ";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long n, K, m, d, res;
inline long long mul(long long a, long long b) {
if (1.0 * a * b > 1e18) return 1e18 + 1;
return a * b;
}
inline void check(long long i) {
long long left = n / mul(i, K);
long long right = n / (mul(i - 1, K) + 1);
if (left > m) return;
res = max(res, i * min(right, m));
}
int main() {
cin >> n >> K >> m >> d;
for (int i = 1; i <= d; ++i) check(i);
cout << res << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000000;
int main() {
int nm, nc, y;
cin >> nm >> nc >> y >> y;
vector<int> m(nm), c(nc + 2), dc(nc + 2, INF);
for (int i = 0; i < nm; ++i) cin >> m[i];
c[0] = -INF;
dc[0] = 0, dc[nc + 1] = 0;
for (int i = 1; i <= nc; ++i) cin >> c[i];
c[nc + 1] = INF + 1;
int inc = 0, k = 0;
for (int i = 0; i < nm; ++i) {
if (c[inc] > m[i]) --inc;
int to_left, to_right, l, r;
while (c[inc] < m[i]) ++inc;
if (c[inc] > m[i]) --inc;
to_left = m[i] - c[inc];
l = inc;
if (m[i] != c[inc]) ++inc;
r = inc;
to_right = c[inc] - m[i];
if (dc[r] && (to_right < to_left)) {
if (dc[r] == INF) ++k;
dc[r] = to_right;
} else {
if (dc[l] == INF) {
dc[l] = to_left;
++k;
} else if (dc[l] == to_left)
++k;
else {
if (to_left == to_right)
if (l != r) {
dc[r] = to_right;
++k;
} else
dc[l] = 0;
else if (to_left < dc[l])
dc[l] = to_left;
}
}
}
cout << nm - k;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n = 0, m = 0, k = 0;
cin >> n >> m >> k;
if (n > m) swap(n, m);
if (k > n + m - 2) {
cout << -1;
return 0;
}
if (k < n)
cout << max(m * (n / (k + 1)), n * (m / (k + 1)));
else if (k >= n && k < m)
cout << n * (m / (k + 1));
else {
long long y = m;
long long x = k + 2 - m;
cout << (n / x) * (m / y);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = (1 << 15) + 8;
int father[Maxn];
char np[2][Maxn >> 1];
char str[Maxn >> 1];
int ans = 0;
int find(int x) {
if (father[x] == x)
return x;
else
return father[x] = find(father[x]);
}
void Union(int x, int y) {
int fx = find(x);
int fy = find(y);
if (fx != fy) {
ans--;
father[fy] = fx;
}
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
memset(np, 0, sizeof(np));
for (int i = 1; i <= (m << 1); i++) father[i] = i;
for (int i = 0; i < n; i++) {
scanf("%s", str);
int cur = i & 1;
for (int j = 1; j <= (m >> 2); j++) {
int x = isdigit(str[j - 1]) ? str[j - 1] - '0' : str[j - 1] - 'A' + 10;
ans += np[cur][((j - 1) << 2) + 1] = (x >> 3) & 1;
ans += np[cur][((j - 1) << 2) + 2] = (x >> 2) & 1;
ans += np[cur][((j - 1) << 2) + 3] = (x >> 1) & 1;
ans += np[cur][((j - 1) << 2) + 4] = x & 1;
}
for (int j = 1; j <= m; j++) father[cur * m + j] = cur * m + j;
for (int j = 1; j < m; j++)
if (np[cur][j] && np[cur][j + 1]) Union(cur * m + j, cur * m + j + 1);
for (int j = 1; j <= m; j++) {
if (np[cur ^ 1][j] && np[cur][j]) Union(cur * m + j, (cur ^ 1) * m + j);
}
}
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
int a = 0;
int h, n, m;
cin >> h >> n >> m;
for (int i = 0; h > 0; i++) {
if (n > 0 && (h / 2 + 10) < h) {
h = h / 2 + 10;
n--;
} else if (m > 0) {
h = h - 10;
m--;
} else
break;
if (h <= 0) {
cout << "YES";
a++;
break;
}
}
if (a == 0) cout << "NO";
cout << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MN = 1e5 + 111;
long long mod = 0;
int tin[MN], tout[MN], pt[MN], sz[MN], t = 0, d[MN];
long long c[MN], cr[MN], pw[MN], pwr[MN], ans = 0;
vector<pair<int, int> > g[MN];
long long rev(long long a, long long m) {
if (a == 1)
return 1;
else
return (1 - rev(m % a, a) * m) / a + m;
}
void dfs(int u, int p, int d, long long ps, long long psr) {
::d[u] = d;
c[u] = ps;
cr[u] = psr;
pt[t] = u;
tin[u] = t++;
sz[u] = 1;
for (auto v : g[u]) {
if (v.first == p) continue;
dfs(v.first, u, d + 1, ((ps * 10 + v.second) % mod),
(psr + v.second * pw[d]) % mod);
sz[u] += sz[v.first];
}
tout[u] = t;
}
unordered_map<long long, int> cnt, cntr;
void sol(int u, int p, int f) {
int w = -1;
for (auto v : g[u]) {
if (v.first == p) continue;
if (w == -1 || sz[w] < sz[v.first]) {
w = v.first;
}
}
for (auto i : g[u]) {
int v = i.first;
if (v == p || v == w) continue;
sol(v, u, 0);
}
if (w != -1) {
sol(w, u, 1);
}
{
int v = u;
long long a = (cr[v] - cr[u]) * pwr[d[u]];
a = mod - a;
a %= mod;
if (a < 0) a += mod;
a *= pwr[d[u]];
a += c[u] * pwr[d[u]];
a %= mod;
ans += cnt[a];
long long k = (mod - (c[v] - c[u] * pw[d[v] - d[u]])) % mod;
if (k < 0) k += mod;
k *= pw[d[u]];
k %= mod;
k *= pw[d[u]];
k %= mod;
k *= pwr[d[v]];
k += cr[u];
k %= mod;
ans += cntr[k];
long long b = c[u] * pwr[d[u]] % mod;
cnt[b]++;
cntr[cr[u]]++;
}
for (auto i : g[u]) {
int first = i.first;
if (first == p || first == w) continue;
for (int i = tin[first]; i < tout[first]; ++i) {
int v = pt[i];
long long a = (cr[v] - cr[u]) * pwr[d[u]];
a = mod - a;
a %= mod;
if (a < 0) a += mod;
a *= pwr[d[u]];
a += c[u] * pwr[d[u]];
a %= mod;
ans += cnt[a];
long long k = (mod - (c[v] - c[u] * pw[d[v] - d[u]])) % mod;
if (k < 0) k += mod;
k *= pw[d[u]];
k %= mod;
k *= pw[d[u]];
k %= mod;
k *= pwr[d[v]];
k += cr[u];
k %= mod;
ans += cntr[k];
}
for (int i = tin[first]; i < tout[first]; ++i) {
int v = pt[i];
long long b = c[v] * pwr[d[v]] % mod;
cnt[b]++;
cntr[cr[v]]++;
}
}
if (!f) {
for (int i = tin[u]; i < tout[u]; ++i) {
int v = pt[i];
long long b = c[v] * pwr[d[v]] % mod;
cnt[b]--;
cntr[cr[v]]--;
}
}
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n >> mod;
if (mod == 1) {
cout << (long long)n * (n - 1) << '\n';
return 0;
}
for (int i = 0; i < n - 1; ++i) {
int u, v, c;
cin >> u >> v >> c;
g[u].push_back({v, c});
g[v].push_back({u, c});
}
pw[0] = 1;
pwr[0] = 1;
for (int i = 1; i < MN; ++i) {
pw[i] = pw[i - 1] * 10;
pw[i] %= mod;
pwr[i] = rev(pw[i], mod);
}
dfs(0, 0, 0, 0, 0);
sol(0, -1, 1);
cout << ans;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long n, arr[105], k;
bool check(long long d) {
long long sum = 0;
for (int i = 1; i <= n; i++) sum += (arr[i] + d - 1) / d;
sum *= d;
if (sum <= k) return true;
return false;
}
int main() {
long long i, j, ans = 0;
scanf("%lld", &n);
scanf("%lld", &k);
for (i = 1; i <= n; i++) {
scanf("%lld", &arr[i]);
k += arr[i];
}
for (i = 1; i * i <= k; i++) {
if (check(i)) ans = max(ans, i);
if (check(k / i)) ans = max(ans, k / i);
}
printf("%lld\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long pascal[4005][4005], arr[4005][4005];
long long eq[4005];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= n; j++) {
if (j == 0) {
pascal[i][j] = 1;
} else {
pascal[i][j] = 0;
}
}
}
for (int i = 1; i < n + 1; i++) {
for (int j = 1; j <= i; j++) {
pascal[i][j] = (pascal[i - 1][j - 1] + pascal[i - 1][j]) % 1000000007;
}
}
eq[0] = 1;
arr[0][0] = 1;
for (int i = 1; i < n - 1; i++) {
for (int j = 0; j <= i; j++) {
if (j == 0) {
arr[i][j] = arr[i - 1][i - 1];
} else {
arr[i][j] = (arr[i - 1][j - 1] + arr[i][j - 1]) % 1000000007;
}
}
}
for (int i = 1; i < n; i++) {
eq[i] = arr[i - 1][i - 1];
}
long long ans = 0;
for (int i = 0; i < n; i++) {
long long temp = (eq[i] * pascal[n][i]) % 1000000007;
ans = (ans + temp) % 1000000007;
}
printf("%I64d", ans);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, h, v;
cin >> n;
int arr[1006];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
int d = -1;
int c = 0;
while (c != n) {
d++;
for (int i = 0; i < n; i++) {
if (arr[i] <= c && arr[i] >= 0) {
c++;
arr[i] = -1;
}
}
if (c != n) {
d++;
for (int i = n - 1; i >= 0; i--) {
if (arr[i] <= c && arr[i] >= 0) {
c++;
arr[i] = -1;
}
}
}
}
cout << d << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
int main() {
int i, y, yes = 0, no = 0;
scanf("%d\n", &y);
char array[y];
gets(array);
for (i = 0; i < y; i++) {
if (array[i] == 'F' && array[i + 1] == 'S') {
no++;
} else if (array[i] == 'S' && array[i + 1] == 'F') {
yes++;
}
}
if (yes > no)
printf("\nyes");
else
printf("\nNO");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long a[n + 5];
bool checka = 0, checkd = 0;
if (n == 1) {
int tmp;
cin >> tmp;
cout << tmp;
return 0;
}
for (long long i = 0; i < n; i++) {
cin >> a[i];
if (a[i] < 0) checka = 1;
if (a[i] > 0) checkd = 1;
}
long long sum = 0;
if (checka == 1 && checkd == 1) {
for (long long i = 0; i < n; i++) sum += abs(a[i]);
cout << abs(sum);
} else if (checka == 1 && checkd == 0) {
long long nmax = -1e9;
for (long long i = 0; i < n; i++) nmax = max(nmax, a[i]);
for (long long i = 0; i < n; i++) {
if (a[i] == nmax) {
a[i] = abs(a[i]);
break;
}
}
long long sum1 = 0;
for (long long i = 0; i < n; i++) sum1 += a[i];
cout << abs(sum1);
} else {
long long nmin = 1e9;
for (long long i = 0; i < n; i++) nmin = min(nmin, a[i]);
for (long long i = 0; i < n; i++) {
if (a[i] == nmin) {
a[i] = -a[i];
break;
}
}
long long sum2 = 0;
for (long long i = 0; i < n; i++) sum2 += a[i];
cout << abs(sum2);
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long z = 998244353;
long long gcd(long long a, long long b) {
if (a == 0) return b;
if (b == 0) return a;
return gcd(b, a % b);
}
long long power(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) {
res = (res * a);
b--;
} else {
a = (a * a);
b = b >> 1;
}
}
return res;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t;
t = 1;
while (t--) {
long long n, m;
cin >> n >> m;
long long a[n], b[m];
for (long long i = 0; i < n; i++) cin >> a[i];
for (long long i = 0; i < m; i++) cin >> b[i];
long long k = power(2, 9), ans = 0;
for (long long i = 0; i < k; i++) {
long long c = 0;
for (long long j = 0; j < n; j++) {
for (long long l = 0; l < m; l++) {
if ((i | (a[j] & b[l])) == i) {
c++;
break;
}
}
}
if (c == n) {
ans = i;
break;
}
}
cout << ans << "\n";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long LLINF = 1e18;
const int MAXN = 2e5 + 10;
const int mod = 1e9 + 7;
vector<int> delta[MAXN];
int arr[MAXN];
long long bit[MAXN];
int n, m;
inline int lowbit(int x) { return x & (-x); }
inline void update(int pos, int val) {
for (int i = pos; i <= n; i += lowbit(i)) {
bit[i] += val;
}
}
inline long long querysum(int pos) {
long long ret = 0;
for (int i = pos; i > 0; i -= lowbit(i)) {
ret += bit[i];
}
return ret;
}
inline int query(int pos) {
if (pos == 1)
return querysum(pos);
else
return querysum(pos) - querysum(pos - 1);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= m; i++) cin >> arr[i];
for (int i = 2; i <= m; i++) {
delta[arr[i]].push_back(arr[i - 1]);
delta[arr[i - 1]].push_back(arr[i]);
}
long long ans = 0;
for (int i = 1; i <= n; i++) update(i, i);
for (int i = 2; i <= m; i++) {
ans += abs(query(arr[i]) - query(arr[i - 1]));
}
cout << ans << " ";
for (int i = 2; i <= n; i++) {
for (auto it : delta[i]) ans -= abs(query(i) - query(it));
for (auto it : delta[i - 1]) {
if (it == i) continue;
ans -= abs(query(i - 1) - query(it));
}
update(i, 1 - query(i));
update(i - 1, i - query(i - 1));
for (auto it : delta[i]) ans += abs(query(i) - query(it));
for (auto it : delta[i - 1]) {
if (it == i) continue;
ans += abs(query(i - 1) - query(it));
}
cout << ans << " ";
}
cout << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long f(long long n) {
if (n < 10) return n;
string s = "";
long long m = n;
while (n > 0) {
s = char(n % 10 + int('0')) + s;
n /= 10;
}
long long res = m / 10 - 1;
if (s[0] <= s[int(s.size()) - 1]) ++res;
res += 9;
return res;
}
int main() {
long long l, r;
cin >> l >> r;
cout << f(r) - f(l - 1);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, m, l;
cin >> n >> m >> l;
vector<long long> vec(n);
set<long long> s;
for (long long i = 0; i < n; ++i) {
cin >> vec[i];
if (vec[i] > l) s.insert(i);
}
long long cnt = 0;
long long prev = -2;
for (auto x : s) {
if (x > prev + 1) ++cnt;
prev = x;
}
while (m > 0) {
--m;
int q;
cin >> q;
if (q == 0) {
cout << cnt << endl;
} else {
long long p, d;
cin >> p >> d;
--p;
vec[p] += d;
if (vec[p] > l) s.insert(p);
if (vec[p] > l && vec[p] - d <= l) {
if (p > 0 && p == n - 1) {
if (vec[p - 1] <= l) ++cnt;
} else if (p < n - 1 && p == 0) {
if (vec[p + 1] <= l) ++cnt;
} else if (p < n - 1 && p > 0) {
if (vec[p + 1] <= l && vec[p - 1] <= l)
++cnt;
else if (vec[p + 1] > l && vec[p - 1] > l)
--cnt;
} else if (p == 0 && p == n - 1) {
if (vec[p] > l && vec[p] - d <= l) ++cnt;
}
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int a[200005];
int pre[200005], vis[200005] = {0};
vector<int> p[200005], pp[200005];
unordered_map<int, int> mp;
unordered_set<int> mp1[200005];
int hx = 0;
int findx(int x) { return x == pre[x] ? x : pre[x] = findx(pre[x]); }
int mmp[200005] = {0};
int anss = 0;
int maxx = -1;
void dfs(int x, int tmp) {
if (tmp > maxx) {
maxx = tmp;
anss = x;
}
int i;
int hp = pp[x].size();
for (i = 0; i < hp; i++) {
if (mmp[pp[x][i]] == 0) {
mmp[pp[x][i]] = 1;
dfs(pp[x][i], tmp + 1);
mmp[pp[x][i]] = 0;
}
}
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
pre[i] = i;
scanf("%d", &a[i]);
}
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
p[u].push_back(v);
p[v].push_back(u);
}
for (int i = 1; i <= n; i++) {
vis[i] = 1;
int len = p[i].size();
for (int j = 0; j < len; j++) {
int id = p[i][j];
if (a[id] == a[i]) {
vis[id] = 1;
id = findx(id);
int x = findx(i);
pre[id] = x;
}
}
}
for (int i = 1; i <= n; i++) {
int x = findx(i);
if (mp[x] == 0) {
mp[x] = ++hx;
}
x = mp[x];
int len = p[i].size();
for (int j = 0; j < len; j++) {
int id = p[i][j];
id = findx(id);
if (mp[id] == 0) {
mp[id] = ++hx;
}
id = mp[id];
if (mp1[x].find(id) == mp1[x].end()) {
mp1[x].insert(id);
mp1[id].insert(x);
pp[x].push_back(id);
pp[id].push_back(x);
}
}
}
mmp[1] = 1;
dfs(1, 1);
mmp[1] = 0;
mmp[anss] = 1;
dfs(anss, 1);
printf("%d\n", maxx / 2);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> v[108];
int n, i, j;
for (i = 0; i < 108; i++) v[i].resize(108);
vector<int> in(108);
scanf("%d", &(n));
;
for (i = 0; i < n; i++) scanf("%d", &(in[i]));
;
for (i = 0; i < n; i++)
for (j = 0; j < in[i]; j++) scanf("%d", &(v[i][j]));
;
int ans = 1000000, ians;
for (i = 0; i < n; i++) {
ians = 0;
for (j = 0; j < in[i]; j++) ians += 5 * v[i][j] + 15;
ans = min(ans, ians);
}
printf("%d\n", (ans));
;
return 0;
}
| 0 |
#include <bits/stdc++.h>
int a[105], n, m;
int main() {
while (scanf("%d", &n) != EOF) {
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
scanf("%d", &m);
for (int i = 0, x, y; i < m; ++i) {
scanf("%d%d", &x, &y);
a[x - 1] += y - 1;
a[x + 1] += a[x] - y;
a[x] = 0;
}
for (int i = 1; i <= n; ++i) printf("%d\n", a[i]);
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long LLINF = 1e18;
const int maxN = 1e5;
const int MOD = 100000000;
int N1, N2, K1, K2;
int dp[110][110][20][20];
int f(int fm, int hm, int fmax, int hmax) {
if (fm < 0 || hm < 0 || fmax > K1 || hmax > K2) return 0;
if (fm == 0 && hm == 0) return 1;
if (dp[fm][hm][fmax][hmax] != -1) return dp[fm][hm][fmax][hmax];
int &ret = dp[fm][hm][fmax][hmax];
return ret = (f(fm - 1, hm, fmax + 1, 0) + f(fm, hm - 1, 0, hmax + 1)) % MOD;
}
int main() {
scanf("%d %d", &N1, &N2), scanf("%d %d", &K1, &K2);
for (int n1 = 0; n1 < N1 + 1; n1++)
for (int n2 = 0; n2 < N2 + 1; n2++)
for (int k1 = 0; k1 < K1 + 1; k1++)
for (int k2 = 0; k2 < K2 + 1; k2++) dp[n1][n2][k1][k2] = -1;
printf("%d\n", f(N1, N2, 0, 0));
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const int MAX = 5e3 + 5;
const long long MAX2 = 11;
const long long MOD = 1000000007;
const long long MOD2 = 1000005329;
const long long INF = 2e18;
const int dr[] = {1, 0, -1, 0, 1, 1, -1, -1, 0};
const int dc[] = {0, 1, 0, -1, 1, -1, 1, -1, 0};
const double pi = acos(-1);
const double EPS = 1e-9;
const int block = 2000;
int n, m, x[MAX], dp[MAX][MAX];
double d;
int f(int pos, int ls) {
if (pos > n) return 0;
if (dp[pos][ls] != -1) return dp[pos][ls];
if (x[pos] >= x[ls])
return dp[pos][ls] = max(f(pos + 1, ls), f(pos + 1, pos) + 1);
return dp[pos][ls] = f(pos + 1, ls);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; ++i) cin >> x[i] >> d;
memset(dp, -1, sizeof dp);
cout << n - f(1, 0) << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long sqr(long long first) { return first * first; }
const double PI = acos(-1);
const int MAXN = 2e6 + 10;
const int INF = 1e9;
const long long md = 1e9 + 7;
const long long md2 = 2e9 + 7;
const long long RNG = 1e18;
long long bpow(long long a, long long b) {
long long res = 1;
while (b > 0) {
if (b & 1ll) res = (res * a);
a = (a * a);
b >>= 1ll;
}
return res;
}
int n, m, k;
vector<int> g[MAXN], cnt[MAXN];
int c[MAXN];
int vis[MAXN];
int dfs(int v, int c) {
vis[v] = c;
cnt[c].push_back(v);
int res = 1;
for (auto to : g[v])
if (!vis[to]) res += dfs(to, c);
return res;
}
int main() {
scanf(
"%d"
"%d"
"%d",
&n, &m, &k);
for (int i = 1; i <= k; i++) scanf("%d", &c[i]);
while (m--) {
int u, v;
scanf(
"%d"
"%d",
&u, &v);
g[u].push_back(v);
g[v].push_back(u);
}
long long ans = 0;
long long mxx = 0;
for (int i = 1; i <= k; i++) {
long long cur = dfs(c[i], i);
mxx = max(mxx, cur);
long long mx = cur * (cur - 1) / 2;
long long t = 0;
for (auto v : cnt[i]) t += int(g[v].size());
t /= 2;
ans += mx - t;
}
long long cur = 0, t = 0;
for (int i = 1; i <= n; i++)
if (!vis[i]) cur++, t += g[i].size();
if (cur > 0)
ans += (mxx + cur) * (mxx + cur - 1) / 2 - t / 2 - mxx * (mxx - 1) / 2;
cout << ans;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[100005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, k;
cin >> n >> k;
int def = 0;
for (int i = 1; i <= n + 1; i++) {
string s;
cin >> s;
a[i] = 1000000007;
if (s[0] != '?') {
a[i] = stoi(s);
++def;
}
}
if (k == 0) {
cout << (a[1] == 0 or a[1] == 1000000007 and def % 2 ? "Yes" : "No");
} else {
if (def == n + 1) {
bool is = true;
int x = 0;
for (int i = 1; i <= n; i++) {
int y = (x - a[i]) % k;
if (y) {
is = false;
break;
}
x = (x - a[i]) / k;
}
is &= x == a[n + 1];
cout << (is ? "Yes" : "No");
} else {
cout << (n % 2 ? "Yes" : "No");
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
const long double eps = 1e-7;
const int inf = 1000000010;
const long long INF = 10000000000000010LL;
const int MAXN = 100010, LOG = 20;
long long A, n, x, y, ans;
vector<long long> D, prime;
long long dp[2000][6720];
long long is(long long x, long long y) {
long long tmp = 1;
while (tmp < y) tmp *= x;
return tmp == y;
}
long long get(long long x) {
if (x <= 2) return -1;
x--;
for (long long i = 2; i * i <= x; i++)
if (x % i == 0) {
long long tmp = is(i, x);
if (!tmp) return -1;
return i;
}
return x;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> A;
for (long long i = 1; i * i <= A; i++)
if (A % i == 0) {
D.push_back(i);
if (i * i != A) D.push_back(A / i);
}
for (long long x : D) {
long long tmp = get(x);
if (tmp != -1) prime.push_back(tmp);
}
sort(D.begin(), D.end());
sort(prime.begin(), prime.end());
prime.resize(unique(prime.begin(), prime.end()) - prime.begin());
dp[0][0] = 1;
for (int i = 0; i < prime.size(); i++) {
long long p = prime[i];
for (int j = 0; j < D.size(); j++) {
long long tmp = p;
dp[i + 1][j] += dp[i][j];
for (; (tmp + 1) * D[j] <= A && (tmp + 1) * D[j] > 0; tmp *= p)
if (A % ((tmp + 1) * D[j]) == 0)
dp[i + 1][lower_bound(D.begin(), D.end(), (tmp + 1) * D[j]) -
D.begin()] += dp[i][j];
}
}
cout << dp[prime.size()][D.size() - 1] << '\n';
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
bool test = false;
cin >> a;
for (int i = 0; i < a; i++) {
cin >> b;
if (b == 1) test = true;
}
if (test)
cout << "HARD\n";
else
cout << "EASY\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x, a[100];
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
long long s = 0, t = 1;
for (int i = n - 1; i >= 0; i--) {
t += a[i] - 1;
s += t;
}
cout << s << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 0.0000001;
int main() {
ios_base::sync_with_stdio(false);
int n;
string s;
cin >> n >> s;
vector<int> sum(n, 0);
sum[0] = s[0] - '0';
for (int i = 1; i < n; ++i) {
sum[i] = sum[i - 1] + (s[i] - '0');
}
for (int i = 0; i < n - 1; ++i) {
int need = sum[i];
int it = i + 1, now = 0, cnt = 0;
bool flag = 1;
while (it < n) {
if (s[it] == '0') {
cnt++;
} else if (now + (s[it] - '0') > need) {
flag = 0;
break;
} else if (now + (s[it] - '0') == need) {
now = 0;
} else
now += (s[it] - '0');
it++;
}
if (flag && now == 0 && (n - i - 1 > cnt || need == 0)) {
cout << "YES";
return 0;
}
}
cout << "NO";
return 0;
}
| 2 |
#include <bits/stdc++.h>
inline int Input() {
int ret = 0;
bool isN = 0;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') isN = 1;
c = getchar();
}
while (c >= '0' && c <= '9') {
ret = ret * 10 + c - '0';
c = getchar();
}
return isN ? -ret : ret;
}
inline void Output(long long x) {
if (x < 0) {
putchar('-');
x = -x;
}
int len = 0, data[20];
while (x) {
data[len++] = x % 10;
x /= 10;
}
if (!len) data[len++] = 0;
while (len--) putchar(data[len] + 48);
putchar('\n');
}
#pragma comment(linker, "/STACK:124000000,124000000")
using namespace std;
int p[1005];
long long dp[1005];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", p + i);
}
dp[1] = 0;
for (int i = 1; i <= n; i++) {
dp[i + 1] = (2 * dp[i] + 2 - dp[p[i]] + 2 * 1000000007) % 1000000007;
}
printf("%I64d\n", dp[n + 1]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
class cpx {
public:
double x, y;
cpx(double p = 0, double q = 0) : x(p), y(q) {}
cpx operator+(const cpx &o) { return cpx(x + o.x, y + o.y); }
cpx operator-(const cpx &o) { return cpx(x - o.x, y - o.y); }
cpx operator*(const cpx &o) {
return cpx(x * o.x - y * o.y, x * o.y + y * o.x);
}
cpx conj() { return cpx(x, -y); }
};
const double PI = acos(-1);
void fft(vector<cpx> &a, int f) {
int i, j, k, n = int(a.size());
for (i = j = 0; i < n; ++i) {
if (i > j) swap(a[i], a[j]);
for (k = n >> 1; (j ^= k) < k; k >>= 1)
;
}
for (i = 1; i < n; i <<= 1) {
cpx wn(cos(PI / i), f * sin(PI / i));
for (j = 0; j < n; j += i << 1) {
cpx w(1, 0);
for (k = 0; k < i; ++k, w = w * wn) {
cpx x = a[j + k], y = w * a[i + j + k];
a[j + k] = x + y;
a[i + j + k] = x - y;
}
}
}
if (f == -1)
for (i = 0; i < n; ++i) a[i].x /= n, a[i].y /= n;
}
int S = 2000;
vector<vector<int>> inB;
vector<int> a, b;
vector<cpx> A, B;
char s[1 << 18];
int main() {
int m, n;
scanf("%s", s);
a.resize(strlen(s));
for (n = 0; s[n]; ++n) a[n] = (s[n] == '1' ? 1 : -1);
scanf("%s", s);
b.resize(strlen(s));
for (m = 0; s[m]; ++m) b[m] = (s[m] == '1' ? 1 : -1);
int i, j, k, res = 0;
int l, r, p, q, N, Q, sz;
inB.assign((n + S - 1) / S, vector<int>(m, 0));
for (N = 1; N <= S + m - 1; N <<= 1)
;
A.resize(N), B.resize(N);
for (i = 0; i < m; ++i) B[i] = cpx(b[i], 0);
fft(B, 1);
for (i = 0, k = 0; i < n; i += S, ++k) {
l = i, r = min(i + S, n), sz = r - l;
for (j = 0; j < sz; ++j) A[sz - 1 - j] = cpx(a[j + l], 0);
for (j = sz; j < N; ++j) A[j] = cpx(0, 0);
fft(A, 1);
for (j = 0; j < N; ++j) A[j] = A[j] * B[j];
fft(A, -1);
for (j = 0; j < m; ++j) inB[k][j] = (sz - (int)round(A[j].x)) >> 1;
}
scanf("%d", &Q);
while (Q--) {
int l, l2, len, r, k, le, res;
cin >> l >> l2 >> len;
r = l + len - 1, l2 -= l;
k = l / S + 1, le = min(k * S - 1, r);
res = 0;
while (l <= le) res += (a[l] != b[l + l2]), ++l;
while (l + S - 1 <= r) res += inB[k++][le + S + l2], l += S, le += S;
while (l <= r) res += (a[l] != b[l + l2]), ++l;
printf("%d\n", res);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
;
if (n == 1 || n == 2 || n == 4) {
cout << -1 << "\n";
return;
}
if (n % 3 == 0) {
cout << n / 3 << " ";
cout << 0 << " ";
cout << 0 << "\n";
} else if ((n - 5) % 3 == 0) {
cout << (n - 5) / 3 << " ";
cout << 1 << " ";
cout << 0 << "\n";
} else if ((n - 7) % 3 == 0) {
cout << (n - 7) / 3 << " ";
cout << 0 << " ";
cout << 1 << "\n";
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int T;
cin >> T;
while (T--) solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 70 + 20;
pair<pair<int, int>, int> par[N][N][N];
bool mark[N][N][N];
queue<pair<pair<int, int>, int> > q;
int k1, k2, k3;
long long dis[N][N][N];
char a[N][N];
long long ans = 1e9;
void pp(int x1, int x2, int x3) {
if (par[x1][x2][x3].second != -1) {
auto l = par[x1][x2][x3];
pp(l.first.first, l.first.second, l.second);
if (l.first.first != x1) cout << l.first.first + 1 << ' ' << x1 + 1 << "\n";
if (l.first.second != x2)
cout << l.first.second + 1 << ' ' << x2 + 1 << "\n";
if (l.second != x3) cout << l.second + 1 << ' ' << x3 + 1 << "\n";
}
}
int main() {
ios::sync_with_stdio(false);
int x, y, z, n;
cin >> n >> x >> y >> z;
x--;
z--;
y--;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cin >> a[i][j];
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
for (int k = 0; k < n; k++) {
dis[i][j][k] = 1e9;
}
}
}
par[x][y][z] = make_pair(make_pair(-1, -1), -1);
dis[x][y][z] = 0;
q.push({{x, y}, z});
mark[x][y][z] = true;
while (!q.empty()) {
k1 = (q.front().first).first;
k2 = (q.front().first).second;
k3 = q.front().second;
q.pop();
for (int i = 0; i < n; i++) {
if (a[i][k1] == a[k2][k3] && !mark[i][k2][k3] && i != k1 && i != k2 &&
i != k3) {
q.push({{i, k2}, k3});
mark[i][k2][k3] = true;
par[i][k2][k3] = {{k1, k2}, k3};
dis[i][k2][k3] = dis[k1][k2][k3] + 1;
}
if (a[i][k2] == a[k1][k3] && !mark[k1][i][k3] && i != k1 && i != k2 &&
i != k3) {
q.push({{k1, i}, k3});
mark[k1][i][k3] = true;
par[k1][i][k3] = {{k1, k2}, k3};
dis[k1][i][k3] = dis[k1][k2][k3] + 1;
}
if (a[i][k3] == a[k1][k2] && !mark[k1][k2][i] && i != k1 && i != k2 &&
i != k3) {
q.push({{k1, k2}, i});
mark[k1][k2][i] = true;
par[k1][k2][i] = {{k1, k2}, k3};
dis[k1][k2][i] = dis[k1][k2][k3] + 1;
}
}
}
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
for (int k = 0; k < 3; k++) {
ans = min(ans, dis[i][j][k]);
}
}
}
if (ans == 1e9) {
cout << "-1";
return 0;
}
cout << ans << "\n";
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
for (int k = 0; k < 3; k++) {
if (dis[i][j][k] == ans && i != j && j != k && i != k) {
pp(i, j, k);
return 0;
}
}
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
string s;
int n;
int A[200];
int rev(char a) {
int b = 0;
for (int i = 7; i >= 0; i--) {
if (a & (1 << i)) b = b | (1 << (7 - i));
}
return b;
}
int main() {
getline(cin, s);
n = s.size();
for (int i = 0; i < n; i++) {
if (i == 0) {
A[i] = -rev(s[i]);
A[i] %= 256;
if (A[i] < 0) A[i] += 256;
} else {
A[i] = rev(s[i - 1]) - rev(s[i]);
A[i] %= 256;
if (A[i] < 0) A[i] += 256;
}
}
for (int i = 0; i < n; i++) cout << A[i] << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
vector<double> M(5), W(5);
for (int i = 0; i < 5; ++i) cin >> M[i];
for (int i = 0; i < 5; ++i) cin >> W[i];
double hs, hu;
cin >> hs >> hu;
double ans = 0, cur = 500;
for (int i = 0; i < 5; ++i) {
ans += max(0.3 * cur, (1 - M[i] / 250) * cur - 50 * W[i]);
cur += 500;
}
ans += hs * 100 - hu * 50;
cout << ans << "\n";
return 0;
}
| 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.