solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
template <class T>
int getbit(T s, int i) {
return (s >> i) & 1;
}
template <class T>
T onbit(T s, int i) {
return s | (T(1) << i);
}
template <class T>
T offbit(T s, int i) {
return s & (~(T(1) << i));
}
template <class T>
int cntbit(T s) {
return __builtin_popcount(s);
}
template <class T>
T gcd(T a, T b) {
T r;
while (b != 0) {
r = a % b;
a = b;
b = r;
}
return a;
}
const long double PI = 2 * acos(0.0);
const long double eps = 1e-15;
const int infi = 1e9;
const long long Linfi = 1e18;
const long long MOD = 1000000007;
const int c1 = 31;
const int c2 = 37;
long long n, m;
string s;
void solve() {
cin >> n >> m >> s;
m--;
long long p = 0, c = 0;
for (int i = 1; i < n; i++) {
if (s[i] == s[i - 1]) {
c += n * m;
p = i;
} else if (s[i] != s[i - 2])
p = i - 1;
c += i - p;
}
cout << n * n * m - c;
}
int main() {
solve();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long a, b, total = 0, temp;
int main() {
scanf("%I64d %I64d", &a, &b);
while (a != 0 && b != 0) {
total += a / b;
a %= b;
temp = a;
a = b;
b = temp;
}
printf("%I64d\n", total);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int dx[] = {0, 0, 1, -1, -1, -1, 1, 1};
int dy[] = {1, -1, 0, 0, -1, 1, 1, -1};
template <class T>
inline T biton(T n, T pos) {
return n | ((T)1 << pos);
}
template <class T>
inline T bitoff(T n, T pos) {
return n & ~((T)1 << pos);
}
template <class T>
inline T ison(T n, T pos) {
return (bool)(n & ((T)1 << pos));
}
template <class T>
inline T gcd(T a, T b) {
while (b) {
a %= b;
swap(a, b);
}
return a;
}
inline int nxt() {
int aaa;
scanf("%d", &aaa);
return aaa;
}
inline long long lxt() {
long long aaa;
scanf("%lld", &aaa);
return aaa;
}
inline double dxt() {
double aaa;
scanf("%lf", &aaa);
return aaa;
}
template <class T>
inline T bigmod(T p, T e, T m) {
T ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p) % m;
p = (p * p) % m;
}
return (T)ret;
}
class fenwick {
public:
long long tree[200005] = {0};
void Update(int pos, long long val, int limit) {
while (pos <= limit) {
tree[pos] += val;
pos += pos & (-pos);
}
}
long long Query(int pos) {
long long sum = 0;
while (pos > 0) {
sum += tree[pos];
pos -= pos & (-pos);
}
return sum;
}
} past, pastSum;
void solve() {
vector<pair<long long, long long>> v;
int n = nxt();
for (int i = 0; i < n; i++) {
v.emplace_back(lxt(), 0);
}
for (int i = 0; i < n; i++) {
v[i].second = lxt();
}
sort(v.begin(), v.end());
set<long long> st;
for (int i = 0; i < n; i++) st.insert(v[i].second);
vector<long long> velocity(st.begin(), st.end());
n = (int)(velocity).size();
long long ans = 0;
for (int i = 0; i < (int)(v).size(); i++) {
int pos = lower_bound(velocity.begin(), velocity.end(), v[i].second) -
velocity.begin();
ans += past.Query(pos + 1) * v[i].first - pastSum.Query(pos + 1);
past.Update(pos + 1, 1LL, n);
pastSum.Update(pos + 1, v[i].first, n);
}
printf("%lld\n", ans);
}
int main() {
cout.setf(ios::fixed);
cout.precision(10);
int tc = 1;
while (tc--) {
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<long long int> v[1003];
long long int has[1003];
void balance(long long int a, long long int b) {
has[a] -= 1;
has[b] -= 1;
for (long long int i = 0; i < v[a].size(); i++)
if (has[v[a][i]] != 0) has[v[a][i]] -= 1;
for (long long int i = 0; i < v[b].size(); i++)
if (has[v[b][i]] != 0) has[v[b][i]] -= 1;
}
int main() {
memset(has, 0, sizeof(has));
long long int n, i, ans = 1;
cin >> n;
for (i = 0; i < n - 1; i++) {
long long int x, y;
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
has[x]++;
has[y]++;
}
while (1) {
long long int count = 0, a, b;
for (i = 1; i <= n; i++) {
if (has[i] == 1 and count == 0) {
a = i;
count++;
} else if (has[i] == 1 and count == 1) {
b = i;
count++;
break;
}
}
if (count == 0)
break;
else if (count == 1) {
ans = a;
break;
} else {
cout << "? " << a << ' ' << b << endl;
cin >> ans;
if (ans == -1) break;
if (ans == a) break;
if (ans == b) break;
balance(a, b);
}
}
cout << "! " << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000000007;
int a[200001];
int b[200001];
int main() {
long long n, x, ans = 1;
cin >> n;
for (int i = 2; i < n; i++) {
x = i;
while (x % 2 == 0) {
b[2]++;
x /= 2;
}
for (int j = 3; j <= sqrt(x); j += 2)
while (x % j == 0) {
b[j]++;
x /= j;
}
b[x]++;
}
for (int i = n + 1; i < 2 * n; i++) {
x = i;
while (x % 2 == 0) {
a[2]++;
x /= 2;
}
for (int j = 3; j <= sqrt(x); j += 2)
while (x % j == 0) {
a[j]++;
x /= j;
}
a[x]++;
}
for (int i = 2; i <= 200000; i++)
for (int j = 0; j < a[i] - b[i]; j++) ans = (ans * i) % maxn;
cout << ((ans * 2) - n) % maxn << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
char s[505];
int graph[505][505];
int n, m, a, b;
int flag;
void dfs(int i, char k) {
s[i] = k;
for (int j = 1; j <= n; j++) {
if (i != j && s[j] != 'b')
if (graph[i][j] == 0) {
if (s[j] == 'd') {
k == 'a' ? dfs(j, 'c') : dfs(j, 'a');
} else if (s[j] == k) {
flag = 0;
return;
}
} else {
if (s[j] == 'd') {
k == 'a' ? dfs(j, 'a') : dfs(j, 'c');
} else if (s[j] != k) {
flag = 0;
return;
}
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &a, &b);
graph[a][b] = 1;
graph[b][a] = 1;
}
for (int i = 0; i <= n; i++) s[i] = 'd';
for (int i = 1; i <= n; i++) {
int tmp = 0;
for (int j = 1; j <= n; j++)
if (j != i && graph[i][j]) tmp++;
if (tmp == n - 1) s[i] = 'b';
}
flag = 1;
for (int i = 1; i <= n; i++) {
if (s[i] == 'd') dfs(i, 'a');
}
if (flag == 0) {
printf("No\n");
return 0;
}
printf("Yes\n");
for (int i = 1; i <= n; i++) printf("%c", s[i]);
printf("\n");
return 0;
}
| 5 |
#include <bits/stdc++.h>
int n, a, s;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a);
if (a < 0)
s += a * -1;
else
s += a;
}
printf("%d", s);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1050;
int n, tot = 0, m = 0;
int siz[N], p[N], h[N], ex[N], ey[N];
vector<int> RT, U;
namespace GRD {
int f[N][N];
void init() {
int i, j, k, u, v;
memset(f, 0x3f, sizeof(f));
for (i = 1; i <= n; i++) f[i][i] = 0;
for (i = 1; i < n; i++) {
scanf("%d%d", &u, &v);
f[u][v] = f[v][u] = 1;
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= n; j++) {
for (k = 1; k <= n; k++) {
f[j][k] = min(f[j][k], f[j][i] + f[i][k]);
}
}
}
}
int qry(vector<int> A, vector<int> B, int x) {
int i, j, a, b, asi, bsi, ans = 0;
asi = A.size();
bsi = B.size();
for (i = 0; i < asi; i++) {
for (j = 0; j < bsi; j++) {
a = A[i];
b = B[j];
if (f[a][x] + f[x][b] == f[a][b]) ans++;
}
}
return ans;
}
} // namespace GRD
int qry(vector<int> S, vector<int> T, int v) {
int tot, i, ret;
tot = S.size();
printf("%d\n", tot);
for (i = 0; i < tot; i++) printf("%d ", S[i]);
putchar('\n');
tot = T.size();
printf("%d\n", tot);
for (i = 0; i < tot; i++) printf("%d ", T[i]);
putchar('\n');
printf("%d\n", v);
fflush(stdout);
scanf("%d", &ret);
return ret;
}
bool cmp(const int &a, const int &b) { return siz[a] > siz[b]; }
vector<int> get(int len) {
int i;
vector<int> s;
s.clear();
for (i = 1; i <= len; i++) s.push_back(h[i]);
return s;
}
int main() {
int i, j, sl, sr, mid;
scanf("%d", &n);
RT.clear();
RT.push_back(1);
U.clear();
for (i = 2; i <= n; i++) U.push_back(i);
siz[1] = n;
for (i = 2; i <= n; i++) siz[i] = qry(RT, U, i);
for (i = 1; i <= n; i++) p[i] = i;
sort(p + 1, p + n + 1, cmp);
for (i = n; i >= 1; i--) {
while (true) {
if (tot == 0 || qry(RT, get(tot), p[i]) == 0) break;
sl = 1;
sr = tot;
while (sl < sr) {
mid = (sl + sr) >> 1;
if (qry(RT, get(mid), p[i]) > 0)
sr = mid;
else
sl = mid + 1;
}
m++;
ex[m] = p[i];
ey[m] = h[sl];
for (j = sl; j < tot; j++) h[j] = h[j + 1];
tot--;
}
for (j = tot + 1; j > 1; j--) h[j] = h[j - 1];
h[1] = p[i];
tot++;
}
puts("ANSWER");
for (i = 1; i < n; i++) printf("%d %d\n", ex[i], ey[i]);
fflush(stdout);
return 0;
}
| 11 |
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <vector>
using namespace std;
#define endl '\n'
#define ll long long
#define pi pair<int, int>
#define f first
#define s second
const int mxn = 100003, k = 4;
int n;
string s;
vector<pi> v;
vector<int> ans;
int dp[mxn];
int main(){
ios::sync_with_stdio(0);
cin.tie(0);
cin >> s;
n = s.size();
v.push_back({-2, -2});
for(int i = 0; i < n; i++){
if(s[i] == '#'){
if(i && s[i - 1] == '#') v.back().s++;
else v.push_back({i, i});
}
}
v.push_back({n + 1, n + 1});
for(int i = 0; i < 4; i++){
for(int j = 1; j <= n + 2; j++){
dp[j] = -1;
for(int l = 1; l <= min(i, j - 1); l++) if(~dp[j - l - 1]) dp[j] = l;
}
bool t = 1;
ans.clear();
for(int j = 1; j < v.size(); j++){
int x = v[j].f - v[j - 1].s - i - 2;
if(x >= 0 && ~dp[x]){
for(; x; x -= dp[x] + 1) ans.push_back(dp[x]);
ans.push_back(v[j].s - v[j].f + i + 1);
}else{
t = 0;
break;
}
}
if(t){
ans.pop_back();
cout << ans.size() << endl;
if(!ans.empty()) cout << ans[0];
for(int i = 1; i < ans.size(); i++) cout << " " << ans[i];
cout << endl;
return 0;
}
}
cout << -1 << endl;
return 0;
} | 9 |
#include <bits/stdc++.h>
using namespace std;
int y, z[101], n, a[101][101], x, b[101];
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
cin >> a[i][j];
if (a[i][j] == 1) {
b[i] = 1;
}
if (a[i][j] == 2) {
b[j] = 1;
}
if (a[i][j] == 3) {
b[i] = 1;
b[j] = 1;
}
}
}
for (int i = 1; i <= n; ++i) {
if (b[i] == 0) {
y++;
z[y] = i;
}
}
cout << y << endl;
for (int i = 1; i <= y; ++i) {
cout << z[i] << " ";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T& x) {
int f = 0, c = getchar();
x = 0;
while (!isdigit(c)) f |= c == '-', c = getchar();
while (isdigit(c)) x = x * 10 + c - 48, c = getchar();
if (f) x = -x;
}
template <typename T, typename... Args>
inline void read(T& x, Args&... args) {
read(x);
read(args...);
}
template <typename T>
void write(T x) {
if (x < 0) x = -x, putchar('-');
if (x > 9) write(x / 10);
putchar(x % 10 + 48);
}
template <typename T>
void writeln(T x) {
write(x);
puts("");
}
template <typename T>
inline bool chkmin(T& x, const T& y) {
return y < x ? (x = y, true) : false;
}
template <typename T>
inline bool chkmax(T& x, const T& y) {
return x < y ? (x = y, true) : false;
}
const int maxn = (int)1e5 + 10;
const int inf = 0x3f3f3f3f;
const long long mod = 998244353ll;
int n, m, q, ans[maxn], res, op[maxn], x[maxn], y[maxn];
bool g[1001][1001];
vector<int> es[maxn];
void dfs(int u) {
bool valid = 0;
if (op[u] == 1) {
if (!g[x[u]][y[u]]) {
valid = 1, g[x[u]][y[u]] = 1, res++;
}
}
if (op[u] == 2) {
if (g[x[u]][y[u]]) {
valid = 1, g[x[u]][y[u]] = 0, res--;
}
}
if (op[u] == 3) {
for (int i = (1); i < (m + 1); i++) {
if (g[x[u]][i]) {
g[x[u]][i] = 0, res--;
} else {
g[x[u]][i] = 1, res++;
}
}
}
ans[u] = res;
for (int i = (0); i < ((int)es[u].size()); i++) {
dfs(es[u][i]);
}
if (op[u] == 1 && valid) {
if (g[x[u]][y[u]]) {
g[x[u]][y[u]] = 0, res--;
}
}
if (op[u] == 2 && valid) {
if (!g[x[u]][y[u]]) {
g[x[u]][y[u]] = 1, res++;
}
}
if (op[u] == 3) {
for (int i = (1); i < (m + 1); i++) {
if (!g[x[u]][i]) {
g[x[u]][i] = 1, res++;
} else {
g[x[u]][i] = 0, res--;
}
}
}
}
int main() {
read(n, m, q);
for (int i = (1); i < (q + 1); i++) {
read(op[i], x[i]);
if (op[i] <= 2)
read(y[i]), es[i - 1].push_back(i);
else if (op[i] == 3)
es[i - 1].push_back(i);
else
es[x[i]].push_back(i);
}
dfs(0);
for (int i = (1); i < (q + 1); i++) {
writeln(ans[i]);
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 22, MOD = 1e9 + 7;
const long long INF = LLONG_MAX >> 1;
int dp[1 << maxN], au[1 << maxN], adj[maxN], n;
void prt(int m) {
int ct = 0;
for (int i = 0; i < n; i++)
if (1 << i & m) ct++;
cout << ct << '\n';
while (m) cout << au[m] + 1 << ' ', m ^= 1 << au[m];
cout << '\n';
}
void proc(int msk) {
for (int i = 0; i < n; i++) {
if (!(1 << i & msk) && (1 << i & dp[msk])) {
dp[1 << i | msk] = dp[msk] | adj[i], au[1 << i | msk] = i;
if (dp[1 << i | msk] + 1 == (1 << n)) prt(1 << i | msk), exit(0);
}
}
}
void combs(int sz, int be, int ms) {
if (!sz) return proc(ms);
for (int i = be; i < n; i++) combs(sz - 1, i + 1, ms | 1 << i);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
int m;
cin >> n >> m;
if (n * (n - 1) == m * 2 || n == 1) {
cout << "0\n";
return 0;
}
for (int i = 0, u, v; i < m; i++) {
cin >> u >> v;
u--, v--;
adj[u] |= 1 << v, adj[v] |= 1 << u;
}
for (int i = 0; i < n; i++) {
dp[1 << i] = adj[i] |= 1 << i, au[1 << i] = i;
if (dp[1 << i] + 1 == (1 << n)) prt(1 << i), exit(0);
}
for (int i = 1; i < n; i++) combs(i, 0, 0);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long n, ans, ra, rb, rc, P[20][70], p[20];
int k, d[20];
void attB(int i, long long a, long long b, long long bc) {
if (b * b > bc) return;
if (i == k) {
long long c = bc / b;
if (a * b + b * c + c * a < ans) {
ans = a * b + b * c + c * a;
ra = a;
rb = b;
rc = c;
}
return;
}
for (int j = 0; j <= d[i]; j++) {
d[i] -= j;
attB(i + 1, a, b * P[i][j], bc);
d[i] += j;
}
}
void attA(int i, long long a) {
if (a * a > n / a) return;
if (i == k) {
long long bc = n / a;
if (sqrt(bc) * 2 * a + bc >= ans) return;
attB(0, a, 1, bc);
return;
}
for (int j = d[i]; j >= 0; j--) {
d[i] -= j;
attA(i + 1, a * P[i][j]);
d[i] += j;
}
}
int main() {
int test;
cin >> test;
while (test--) {
n = 1;
cin >> k;
for (int i = 0; i < k; i++) {
cin >> p[i] >> d[i];
P[i][0] = 1;
for (int j = 1; j <= d[i]; j++) P[i][j] = P[i][j - 1] * p[i];
n *= P[i][d[i]];
}
ans = n * 4 + 2;
ra = n;
rb = 1;
rc = 1;
attA(0, 1);
cout << ans * 2 << ' ' << ra << ' ' << rb << ' ' << rc << endl;
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
const int maxn = 3e5 + 5;
char s[maxn];
int st[maxn], ed[maxn];
int rk[maxn], tp[maxn], tax[maxn];
int height[maxn], sa[maxn], f[maxn][21], bin[maxn];
int mn[maxn][21], mx[maxn][21];
int M;
void qsort(int n) {
for (int i = 0; i <= M; i++) tax[i] = 0;
for (int i = 1; i <= n; i++) tax[rk[i]]++;
for (int i = 1; i <= M; i++) tax[i] += tax[i - 1];
for (int i = n; i >= 1; i--) sa[tax[rk[tp[i]]]--] = tp[i];
}
void get_sa(int n) {
for (int i = 1; i <= n; i++) {
M = max(M, rk[i] = s[i]);
tp[i] = i;
}
qsort(n);
for (int w = 1, p = 0; p < n; M = p, w <<= 1) {
p = 0;
for (int i = 1; i <= w; i++) tp[++p] = n - w + i;
for (int i = 1; i <= n; i++) {
if (sa[i] > w) tp[++p] = sa[i] - w;
}
qsort(n);
for (int i = 0; i <= n; i++) tp[i] = rk[i];
rk[sa[1]] = p = 1;
for (int i = 2; i <= n; i++) {
rk[sa[i]] =
(tp[sa[i - 1]] == tp[sa[i]] && tp[sa[i - 1] + w] == tp[sa[i] + w])
? p
: ++p;
}
}
}
void get_height(int n) {
int k = 0;
for (int i = 1; i <= n; i++) {
if (k) k--;
int j = sa[rk[i] - 1];
while (j && s[i + k] == s[j + k]) k++;
height[rk[i]] = k;
}
}
void build(int n) {
for (int i = 1; i <= n; i++) {
f[i][0] = height[i];
mn[i][0] = sa[i];
mx[i][0] = sa[i] <= ed[0] ? sa[i] : 0;
}
for (int j = 1; j <= bin[n]; j++) {
for (int i = 1; i + (1 << j) - 1 <= n; i++) {
int t = i + (1 << (j - 1));
f[i][j] = min(f[i][j - 1], f[t][j - 1]);
mn[i][j] = min(mn[i][j - 1], mn[t][j - 1]);
mx[i][j] = max(mx[i][j - 1], mx[t][j - 1]);
}
}
}
int query1(int x, int y) {
if (x == y) return 0;
x++;
int j = bin[y - x + 1];
int k = y - (1 << j) + 1;
return min(f[x][j], f[k][j]);
}
int query2(int x, int y) {
int j = bin[y - x + 1];
int k = y - (1 << j) + 1;
return min(mn[x][j], mn[k][j]);
}
int query3(int x, int y) {
int j = bin[y - x + 1];
int k = y - (1 << j) + 1;
return max(mx[x][j], mx[k][j]);
}
int main() {
scanf("%s", s + 1);
ed[0] = strlen(s + 1);
int m;
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
s[ed[i - 1] + 1] = '*';
st[i] = ed[i - 1] + 2;
scanf("%s", s + st[i]);
ed[i] = strlen(s + 1);
}
int n = strlen(s + 1);
bin[0] = -1;
for (int i = 1; i <= n; i++) bin[i] = bin[i >> 1] + 1;
get_sa(n);
get_height(n);
build(n);
int ans = 0;
for (int t = 1; t <= m; t++) {
int flag = 0;
for (int i = st[t] + 1; i <= ed[t]; i++) {
int tmp = rk[st[t]], len = ed[t] - st[t] + 1;
int L = tmp, R = tmp;
int l = 1, r = tmp - 1, mid, res = 0;
while (l <= r) {
mid = (l + r) >> 1;
if (query1(mid, tmp) >= i - st[t])
res = mid, r = mid - 1;
else
l = mid + 1;
}
if (query1(res, tmp) >= i - st[t]) L = res;
l = tmp + 1, r = n, res = n;
while (l <= r) {
mid = (l + r) >> 1;
if (query1(tmp, mid) >= i - st[t])
res = mid, l = mid + 1;
else
r = mid - 1;
}
if (query1(tmp, res) >= i - st[t]) R = res;
int mnn = query2(L, R);
if (mnn > ed[0]) continue;
tmp = rk[i];
L = tmp, R = tmp;
l = 1, r = tmp - 1, mid, res = 0;
while (l <= r) {
mid = (l + r) >> 1;
if (query1(mid, tmp) >= len - i + st[t])
res = mid, r = mid - 1;
else
l = mid + 1;
}
if (query1(res, tmp) >= len - i + st[t]) L = res;
l = tmp + 1, r = n, res = n;
while (l <= r) {
mid = (l + r) >> 1;
if (query1(tmp, mid) >= len - i + st[t])
res = mid, l = mid + 1;
else
r = mid - 1;
}
if (query1(tmp, res) >= len - i + st[t]) R = res;
int mxx = query3(L, R);
if (mxx <= mnn + i - st[t] - 1)
continue;
else
flag = 1;
if (flag) break;
}
ans += flag;
}
printf("%d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
unsigned long long n, p[1000005], ans, l, h[1000005], db[1000005], f;
char s[1000005];
void hhash(unsigned long long x) {
for (unsigned long long i = 1; i < l; i++) {
if (i + x - 1 >= l - 1) return;
unsigned long long sum = h[x - 1];
if (h[i + x - 1] - h[i - 1] * db[x] == sum) {
for (unsigned long long k = 0; k < x; k++) cout << s[k];
f = 1;
return;
}
}
}
void aaa() {
for (unsigned long long i = 1; i < l; i++) {
unsigned long long j = p[i - 1];
while (j > 0 && s[j] != s[i]) j = p[j - 1];
if (s[j] == s[i]) j++;
p[i] = j;
}
unsigned long long j = p[l - 1];
while (j > 0) {
hhash(j);
if (f == 1)
return;
else
j = p[j - 1];
}
}
signed main() {
cin >> s;
l = strlen(s);
db[0] = 1;
for (unsigned long long i = 1; i <= l; i++) db[i] = db[i - 1] * 27;
h[0] = s[0] - 'a' + 1;
for (unsigned long long i = 1; i < l; i++)
h[i] = h[i - 1] * 27 + s[i] - 'a' + 1;
aaa();
if (f == 0) cout << "Just a legend\n";
return 0;
}
| 4 |
/*______________________________________________Bismillahir Rahmanir Rahim____________________________________________
|
| TTTTTTTTTTTTTTTTTTTTTTTRRRRRRRRRRRRRRRRR 888888888 66666666 |
| T:::::::::::::::::::::TR::::::::::::::::R 88:::::::::88 6::::::6 |
| T:::::::::::::::::::::TR::::::RRRRRR:::::R 88:::::::::::::88 6::::::6 |
| T:::::TT:::::::TT:::::TRR:::::R R:::::R 8::::::88888::::::8 6::::::6 |
| TTTTTT T:::::T TTTTTT R::::R R:::::R 8:::::8 8:::::8 6::::::6 |
| T:::::T R::::R R:::::R 8:::::8 8:::::8 6::::::6 |
| T:::::T R::::RRRRRR:::::R 8:::::88888:::::8 6::::::6 |
| T:::::T R:::::::::::::RR 8:::::::::::::8 6::::::::66666 |
| T:::::T R::::RRRRRR:::::R 8:::::88888:::::8 6::::::::::::::66 |
| T:::::T R::::R R:::::R 8:::::8 8:::::86::::::66666:::::6 |
| T:::::T R::::R R:::::R 8:::::8 8:::::86:::::6 6:::::6 |
| T:::::T R::::R R:::::R 8:::::8 8:::::86:::::6 6:::::6 |
| TT:::::::TT RR:::::R R:::::R 8::::::88888::::::86::::::66666::::::6 |
| T:::::::::T R::::::R R:::::::R 88:::::::::::::88 66:::::::::::::66 |
| T:::::::::T R::::::R R:::::::R 88:::::::::88 66:::::::::66 |
| TTTTTTTTTTT RRRRRRRR RRRRRRRRR 888888888 666666666 | |
| |
| Student of Cmputer Science & Engineering |
| Comilla University |
| Email : [email protected] |
| ___________________Don't judge a book by it's cover___________________ |
|___________________________________________________________________________________________________________________*/
#include <bits/stdc++.h>
#include<vector>
#include<iterator>
#include<stdlib.h>
#include <algorithm>
#include <cctype>
#include <utility>
#include<iostream>
using namespace std;
int DMCA(int n)
{
int s=0;
while(n>0)
{
s+=(n%10);
n/=10;
}
return s;
}
int main()
{
int t;
cin>>t;
int i=1;
while(i>0)
{
t=DMCA(t);
i=t/10;
}
cout<<t<<endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
string s[500000 + 10];
void calc(string& a, string& b) {
if (a <= b) {
return;
}
int i;
for (i = 0; i < min(a.length(), b.length()); i++) {
if (a[i] > b[i]) break;
}
a.resize(i);
}
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> s[i];
for (int i = n; i >= 1; i--) calc(s[i - 1], s[i]);
for (int i = 1; i <= n; i++) cout << s[i] << endl;
return 0;
}
| 5 |
#include<iostream>
using namespace std;
const int N = 405;
char a[N][N];
int main(){
int t;cin >> t;
while(t --){
int n;cin >> n;
int fl = 0;
int x,y,xx,yy;
for(int i = 0;i < n;i ++){
for(int j = 0;j < n;j ++){
cin >> a[i][j];
if(!fl && a[i][j] == '*')x = i,y = j,fl = 1;
else if(fl && a[i][j] == '*') xx = i,yy = j;
}
}
if(xx == x){
if(x + 1 < n){
a[x + 1][y] = '*';
a[x + 1][yy] = '*';
}
else a[x - 1][y] = '*',a[x - 1][yy] = '*';
}
else if(yy == y){
if(y + 1 < n) a[x][y + 1] = '*',a[xx][y + 1] = '*';
else a[x][y - 1] = '*',a[xx][y - 1] = '*';
}
else{
a[x][yy] = '*';
a[xx][y] = '*';
}
for(int i = 0;i < n;i ++){
for(int j = 0;j < n;j ++){
cout << a[i][j];
}
cout << endl;
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int NN = 2e5 + 100;
long long n, dp[NN + 100];
long long mod = 998244353;
int main() {
cin >> n;
dp[0] = 1;
for (int i = 1; i <= NN; i++) {
dp[i] = 10 * dp[i - 1] % mod;
}
for (int i = 1; i < n; i++) {
long long res = 180 * dp[n - i - 1] % mod;
res = (res + (810 * (n - i - 1) % mod) * dp[n - i - 2] % mod) % mod;
cout << res << " ";
}
cout << 10 << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("sse4")
using namespace std;
void err(istringstream &ss) { cout << "\n"; }
template <typename T, typename... Args>
void err(istringstream &ss, const T &a, const Args &...args) {
string token;
getline(ss, token, ',');
cout << token << " = " << a << "; ";
err(ss, args...);
}
long long t, m, n;
vector<int> A;
void solve() {
vector<int> res;
for (int k = 1; k < n; k++) {
bool flag = 1;
long long diff = A[k] - A[0];
for (int i = 1, j = k + 1; j < n; i++, j++)
if (A[j] - A[i] != diff) {
flag = 0;
break;
}
if (flag) res.push_back(k);
}
cout << res.size() << endl;
for (auto r : res) cout << r << " ";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n;
A.resize(n);
for (int i = 0; i < n; i++) cin >> A[i];
A.insert(A.begin(), 0);
n++;
solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class c>
c gcd(c a, c b) {
if (b == 0) return a;
gcd(b, a % b);
}
template <class a>
bool prime(a n) {
for (a i = 2; i <= sqrt(n); i++) {
if (n % i == 0) return 0;
}
return 1;
}
bool bigger(pair<int, int> picachu, pair<int, int> qicachu) {
return (picachu.first < qicachu.first);
}
void printarr(int arr[], int n) {
for (int i = 0; i < n; i++) cout << arr[i] << ' ';
cout << endl;
}
int chartoint(char c) {
if (c >= 'a' && c <= 'z') return c - 'a';
if (c >= 'A' && c <= 'Z') return c - 'A' + 26;
return 52;
}
int kadane(int arr[], int n) {
int maximum = arr[0];
int max_so_far = 0;
for (int i = 0; i < n; i++) {
max_so_far += arr[i];
if (max_so_far > maximum) maximum = max_so_far;
if (max_so_far < 0) max_so_far = 0;
}
return maximum;
}
template <class c>
c lcm(c a, c b) {
c g = gcd(a, b);
a /= g;
b /= g;
return (a * b * g);
}
void run() {
int n, m;
cin >> n >> m;
int count = 0;
while (n != m) {
if (m % 2 || m < n) {
m++;
} else {
m /= 2;
}
count++;
}
cout << count << endl;
}
int main() {
ios_base::sync_with_stdio;
cin.tie(NULL);
cin.tie(NULL);
;
{ run(); }
cerr << "time taken : " << (float)clock() / CLOCKS_PER_SEC << " secs" << endl;
return 0;
;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int cnt[3] = {0}, prime[400005];
vector<int> p;
void preComp() {
for (int i = 0; i < 400005; i++) {
prime[i] = 1;
}
prime[0] = 0;
prime[1] = 0;
for (int i = 2; i <= 400000; ++i) {
if (prime[i]) {
for (int j = 2 * i; j <= 400000; j += i) {
prime[j] = 0;
}
p.push_back(i);
}
}
}
int main() {
preComp();
int n;
scanf("%d", &n);
int sum = 0;
for (int i = 0, x; i < n; ++i) {
scanf("%d", &x);
sum += x;
if (x == 1)
cnt[1]++;
else
cnt[2]++;
}
int last = 0;
for (int i = 0; p[i] <= sum; ++i) {
int req = p[i] - last;
int twos = req / 2;
int ones = req % 2;
while (cnt[2] && twos) {
printf("2 ");
cnt[2]--;
twos--;
}
while (cnt[1] >= 2 && twos) {
printf("1 1 ");
cnt[1] -= 2;
twos--;
}
while (cnt[1] && ones) {
printf("1 ");
cnt[1]--;
ones--;
}
last = p[i];
}
while (cnt[1] > 0) {
printf("1 ");
cnt[1]--;
}
while (cnt[2] > 0) {
printf("2 ");
cnt[2]--;
}
printf("\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5;
const int S = 450;
const uint8_t M = 101;
int n, m, l, r;
uint8_t a[N], x, y;
int st[S], en[S], bk[N];
list<int> b[S][M];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%hhu", a + i);
int i = 0, j = 0, k = 0;
while (i < n) {
st[k] = i;
while (j < n and j < i + S) {
bk[j] = k;
b[k][a[j]].push_back(j);
++j;
}
en[k] = j - 1;
++k;
i = j;
}
scanf("%d", &m);
while (m--) {
scanf("%d %d %hhu %hhu", &l, &r, &x, &y);
if (x == y) continue;
--l;
--r;
for (int i = bk[l]; i <= bk[r]; ++i) {
if (st[i] >= l and en[i] <= r) {
b[i][y].splice(b[i][y].end(), b[i][x]);
} else {
auto it = b[i][x].begin();
for (; it != b[i][x].end();) {
auto jt = next(it);
if (*it >= l and *it <= r) {
b[i][y].splice(b[i][y].end(), b[i][x], it);
}
it = jt;
}
}
}
}
for (int i = 1; i < M; ++i) {
for (int j = 0; j < k; ++j) {
for (int idx : b[j][i]) {
a[idx] = i;
}
}
}
for (int i = 0; i < n; ++i) printf("%hhu ", a[i]);
printf("\n");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 4e2 + 10;
long long n, arr[MAXN], aarr[MAXN], al[MAXN], l[MAXN], dp[MAXN][MAXN],
dp2[MAXN][MAXN], save[MAXN][MAXN], maper, p[MAXN];
set<int> s;
map<int, long long> mp, mp2, mp3;
bool cmp(int i, int j) { return aarr[i] < aarr[j]; }
int main() {
ios::sync_with_stdio(0);
cin >> n;
for (int i = 1; i <= n; i++) {
p[i] = i;
cin >> aarr[i] >> al[i];
mp2[aarr[i]] = al[i];
s.insert(aarr[i]);
s.insert(aarr[i] + al[i]);
s.insert(aarr[i] - al[i]);
}
sort(p + 1, p + n + 1, cmp);
for (int i = 1; i <= n; i++) {
arr[i] = aarr[p[i]];
l[i] = al[p[i]];
}
for (auto i : s) {
mp[i] = ++maper;
mp3[maper] = i;
}
for (int i = 1; i <= maper; i++) {
save[i][i] = mp3[i];
for (int j = i + 1; j <= maper; j++) {
save[i][j] = save[i][j - 1];
if (mp2.count(mp3[j])) {
save[i][j] = min(save[i][j], mp3[j] - mp2[mp3[j]]);
}
}
}
for (int i = 1; i <= maper; i++) {
for (int j = 1; j <= n; j++) {
for (int k = 1; k <= j; k++) {
if (mp[arr[k]] >= i) {
if (arr[k] - l[k] >= mp3[i]) continue;
int ind = save[mp[arr[k] - l[k]]][mp[arr[j]]];
dp[i][j] = max(dp[i][j], dp2[mp[ind]][k - 1] + mp3[i] - ind);
} else {
if (arr[k] + l[k] < mp3[i]) continue;
int ind = save[mp[arr[k]]][mp[arr[j]]];
dp[i][j] = max(dp[i][j], dp2[mp[ind]][k - 1] + mp3[i] - ind);
}
}
for (int k = i; k <= maper; k++) dp2[k][j] = max(dp2[k][j], dp[i][j]);
}
}
cout << dp2[maper][n] << endl;
cin >> n;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1E9 + 7;
const long long N = 2E5 + 6;
const long long inf = 1E15;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
if (fopen("inp.txt", "r")) {
freopen("inp.txt", "r", stdin);
freopen("outp.txt", "w", stdout);
}
long long n, i, p, s1 = 0, s2 = 0;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> p;
if (p < 0)
s2 += p;
else
s1 += p;
}
cout << s1 - s2;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 110;
int a[maxn];
int main() {
int n;
while (cin >> n) {
int ans = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (a[i]) ans++;
}
for (int i = 1; i <= n; i++) {
if (a[i] == 1) {
if (i == 1) continue;
if (a[i - 1] && i >= 1) continue;
if (i >= 2 && a[i - 2]) {
ans++;
continue;
}
}
}
cout << ans << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int getint() {
int _x = 0, _tmp = 1;
char _tc = getchar();
while ((_tc < '0' || _tc > '9') && _tc != '-') _tc = getchar();
if (_tc == '-') _tc = getchar(), _tmp = -1;
while (_tc >= '0' && _tc <= '9') _x *= 10, _x += (_tc - '0'), _tc = getchar();
return _x * _tmp;
}
bool equal(double _x, double _y) { return _x > _y - 1e-7 && _x < _y + 1e-7; }
int __ = 1, cs;
int n, a[510], dp[510][510];
void build() {}
void init() {
n = getint();
for (int i = 1; i <= n; i++) a[i] = getint();
}
int DP(int l, int r) {
if (l > r) return 1;
if (dp[l][r]) return dp[l][r];
if (l == r) return dp[l][r] = 1;
int sum = DP(l + 1, r);
for (int i = l + 1; i <= r; i++)
if (a[i] > a[l]) {
long long tsum = ((long long)(DP(l + 1, i - 1)) * (long long)(DP(i, r))) %
1000000007ll;
sum = (sum + (int)tsum) % 1000000007ll;
}
return dp[l][r] = sum;
}
void solve() {
if (n == 1)
puts("1");
else
printf("%d\n", DP(2, n));
}
int main() {
build();
while (__--) {
init();
solve();
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000005;
const int mo = 998244353;
int n, fac[N], inv[N], C[N * 2];
int main() {
scanf("%d", &n);
fac[0] = inv[0] = inv[1] = 1;
for (int i = (int)(2); i <= (int)(n); i++)
inv[i] = 1ll * inv[mo % i] * (mo - mo / i) % mo;
for (int i = (int)(1); i <= (int)(n); i++)
inv[i] = 1ll * inv[i - 1] * inv[i] % mo;
for (int i = (int)(1); i <= (int)(n); i++) fac[i] = 1ll * fac[i - 1] * i % mo;
C[0] = n;
for (int i = (int)(1); i <= (int)(n - 1); i++)
C[i] = 1ll * fac[n] * inv[n - i + 1] % mo *
(1ll * (n - i) * (n - i) % mo + 1) % mo;
for (int i = (int)(0); i <= (int)(n - 1); i++)
C[i + n] = (fac[n] + mo - C[i]) % mo;
int ans = 1ll * fac[n] * n % mo;
ans = 1ll * ans * (ans + 1) / 2 % mo;
for (int i = (int)(0); i <= (int)(2 * n - 1); i++)
ans = (ans + mo - 1ll * i * C[i] % mo) % mo;
printf("%d\n", ans);
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, c = 0;
cin >> n;
string s;
cin >> s;
for (int i = 0; i < n; i++) {
if (s[i] == '-' && c > 0) {
c--;
} else if (s[i] == '+') {
c++;
}
}
cout << c;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void getData(int *dataArray, int count) {
for (int i = 0; i < count; i++) {
scanf("%d", &dataArray[i]);
}
}
double inline max(double x, double y) { return x - y > 1e-6 ? x : y; }
int main() {
int n;
scanf("%d", &n);
int *x = new int[n];
getData(x, n);
int m;
scanf("%d", &m);
int *y = new int[m];
getData(y, m);
int k;
scanf("%d", &k);
int *z = new int[k];
getData(z, k);
int A, B;
scanf("%d %d", &A, &B);
double result = 0;
double C = (double)A / B;
int maxr = 0;
for (int i = 0; i < n; i++) {
if (x[i] > maxr) maxr = x[i];
}
maxr = maxr * maxr;
for (int j = 0; j < m; j++) {
double tmp = (double)y[j] * maxr;
for (int t = 0; t < k; t++) {
result = max(result, tmp / ((double)C * z[t] + y[j]));
}
}
printf("%f", sqrt(result));
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
string s;
cin >> s;
vector<string> v;
int i = 0;
while (i < s.size()) {
if (s[i] == '0') {
i++;
continue;
}
int j;
j = i;
while (s[j++] == '1' && j <= s.size())
;
v.push_back(s.substr(i, j - i - 1));
i = j;
}
int sum = 0;
sort(v.rbegin(), v.rend());
for (int i = 0; i < v.size(); i = i + 2) {
sum = sum + v[i].size();
}
cout << sum << "\n";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) {
solve();
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void RI(int& x) {
x = 0;
char c = getchar();
while (!(c >= '0' && c <= '9' || c == '-')) c = getchar();
bool flag = 1;
if (c == '-') {
flag = 0;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
if (!flag) x = -x;
}
void RII(int& x, int& y) { RI(x), RI(y); }
void RIII(int& x, int& y, int& z) { RI(x), RI(y), RI(z); }
void RC(char& c) {
c = getchar();
while (c == ' ' || c == '\n') c = getchar();
}
char RC() {
char c = getchar();
while (c == ' ' || c == '\n') c = getchar();
return c;
}
const long long mod = 1e9 + 7;
const long long LINF = 1e18;
const int INF = 1e9;
const double EPS = 1e-8;
int main() {
int n;
cin >> n;
int ans1 = 0, ans2 = 0;
vector<int> vec;
for (int i = 1; i <= n; i++) {
int num;
cin >> num;
if (num & 1) {
for (int i = 1; i <= num / 2; i++) {
int t;
cin >> t;
ans1 += t;
}
int t;
cin >> t;
vec.push_back(t);
for (int i = num / 2 + 2; i <= num; i++) {
int t;
cin >> t;
ans2 += t;
}
} else {
for (int i = 1; i <= num / 2; i++) {
int t;
cin >> t;
ans1 += t;
}
for (int i = num / 2 + 1; i <= num; i++) {
int t;
cin >> t;
ans2 += t;
}
}
}
sort((vec).begin(), (vec).end());
int t = 0;
for (int i = (int)vec.size() - 1; i >= 0; i--) {
if (t == 0)
ans1 += vec[i];
else
ans2 += vec[i];
t ^= 1;
}
cout << ans1 << " " << ans2 << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long n, m;
long long ans[51];
bool used[51];
int main() {
scanf("%I64d%I64d", &n, &m);
long long i = 1, last = 1, cnt = n - 2;
for (; i <= n && last <= n;) {
if ((1LL << cnt) >= m) {
cnt = max(cnt - 1, 0LL);
ans[i] = last++;
i++;
continue;
}
last++;
m -= (1LL << cnt);
cnt = max(cnt - 1, 0LL);
}
for (long long j = 1; j < i; j++) used[ans[j]] = true;
for (long long j = i; j <= n; j++) {
for (long long k = n; k >= 1; k--)
if (!used[k]) {
ans[j] = k;
used[k] = true;
break;
}
}
for (long long i = 1; i <= n; i++) printf("%I64d ", ans[i]);
printf("\n");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, p, price = 101, money = 0;
cin >> n;
while (n--) {
cin >> a >> p;
if (price > p) {
price = p;
}
money += a * price;
}
cout << money;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
long long int a[2 * n];
for (long long int i = (0); i < (2 * n); i++) cin >> a[i];
long long int b[2 * n], k = 0;
long long int temp = 1, ma = a[0];
for (long long int i = (1); i < (2 * n); i++) {
if (a[i] < ma)
temp++;
else {
b[k] = temp;
k++;
temp = 1;
ma = a[i];
}
}
b[k] = temp;
k++;
int ans = 0;
bool dp[2 * n + 1][k + 1];
for (long long int i = (0); i < (k + 1); i++) dp[0][i] = true;
for (long long int i = (0); i < (k + 1); i++)
for (long long int j = (1); j < (2 * n + 1); j++) dp[j][i] = false;
for (long long int i = (1); i < (k + 1); i++) {
for (long long int j = (1); j < (2 * n + 1); j++) {
dp[j][i] = dp[j][i - 1];
if (b[i - 1] <= j) dp[j][i] = dp[j][i] | dp[j - b[i - 1]][i - 1];
}
}
for (long long int i = (0); i < (k + 1); i++) {
if (dp[n][i]) {
ans = 1;
break;
}
}
if (ans == 1)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long int power(long long int a, long long int b,
long long int m = 1000000007) {
if (b == 0) return 1;
if (b == 1) return a;
long long int c = power(a, b / 2, m);
if (b % 2 == 0) return ((c % m) * (c % m)) % m;
return ((((c % m) * (c % m)) % m) * (a % m)) % m;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int n, k, m, i, j, c = 0, cs = 0, t;
t = 1;
string s, p;
while (t--) {
cin >> n >> s;
unordered_map<string, long long int> mp;
for (long long int i = 0; i < n - 1; i++) {
p = s[i];
p += s[i + 1];
mp[p]++;
}
for (auto x : mp) c = max(c, x.second);
for (auto x : mp) {
if (c == x.second) {
cout << x.first;
return 0;
}
}
if (t != 0) cout << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long arr[200010];
priority_queue<pair<long long, long long> > pq, pq1;
vector<long long> v;
int main() {
long long total;
cin >> total;
for (long long i = 1; i <= total; i++) {
scanf("%lld", &arr[i]);
pq1.push(make_pair(-arr[i], i));
}
char p;
for (long long i = 1; i <= 2 * total; i++) {
scanf(" %c", &p);
if (p == '0') {
long long o = pq1.top().second;
long long val = -pq1.top().first;
pq1.pop();
pq.push(make_pair(val, o));
v.push_back(o);
} else {
long long o = pq.top().second;
pq.pop();
v.push_back(o);
}
}
for (long long i = 0; i < v.size(); i++) {
if (i) printf(" ");
printf("%lld", v[i]);
}
printf("\n");
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, q, t, nc = 0, root;
int in[200005];
int out[200005];
int sm[400005];
bool lazy[400005];
int lc[400005];
int rc[400005];
int src[200005];
vector<int> v[200005];
char s[5];
int build(int l, int r) {
int id = ++nc;
if (l == r) {
sm[id] = src[l];
lazy[id] = false;
return id;
}
int mid = (l + r) / 2;
lc[id] = build(l, mid);
rc[id] = build(mid + 1, r);
sm[id] = sm[lc[id]] + sm[rc[id]];
lazy[id] = false;
return id;
}
void update(int id, int l, int r, int ul, int ur) {
if (ur < l || r < ul) {
return;
}
if (ul <= l && r <= ur) {
sm[id] = (r - l + 1) - sm[id];
lazy[id] ^= 1;
return;
}
int mid = (l + r) / 2;
if (lazy[id]) {
sm[lc[id]] = (mid - l + 1) - sm[lc[id]];
lazy[lc[id]] ^= 1;
sm[rc[id]] = (r - mid) - sm[rc[id]];
lazy[rc[id]] ^= 1;
lazy[id] = false;
}
update(lc[id], l, mid, ul, ur);
update(rc[id], mid + 1, r, ul, ur);
sm[id] = sm[lc[id]] + sm[rc[id]];
}
int query(int id, int l, int r, int ql, int qr) {
if (qr < l || r < ql) {
return 0;
}
if (ql <= l && r <= qr) {
return sm[id];
}
int mid = (l + r) / 2;
if (lazy[id]) {
sm[lc[id]] = (mid - l + 1) - sm[lc[id]];
lazy[lc[id]] ^= 1;
sm[rc[id]] = (r - mid) - sm[rc[id]];
lazy[rc[id]] ^= 1;
lazy[id] = false;
}
int q1 = query(lc[id], l, mid, ql, qr);
int q2 = query(rc[id], mid + 1, r, ql, qr);
return q1 + q2;
}
void dfs(int x) {
in[x] = ++t;
for (int u : v[x]) {
dfs(u);
}
out[x] = t;
}
int main() {
scanf("%d", &n);
for (int i = 2; i <= n; i++) {
scanf("%d", &t);
v[t].push_back(i);
}
t = 0;
dfs(1);
for (int i = 1; i <= n; i++) {
scanf("%d", &t);
src[in[i]] = t;
}
root = build(1, n);
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
scanf("%s %d", s, &t);
if (s[0] == 'g') {
printf("%d\n", query(root, 1, n, in[t], out[t]));
} else {
update(root, 1, n, in[t], out[t]);
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 7;
int arr[maxn];
int main() {
int b, k;
scanf("%d%d", &b, &k);
for (int i = k - 1; i >= 0; i--) {
scanf("%d", &arr[i]);
}
long long ans = 0;
for (int i = k - 1; i >= 0; i--) {
if (i)
ans += arr[i] * b;
else
ans += arr[i];
}
ans %= 2;
if (ans)
puts("odd");
else
puts("even");
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, tex, n = 3, d = 0;
cin >> a >> b >> c;
d = a + b + c;
if (2 * a + 2 * b < d) d = 2 * a + 2 * b;
if (a * 2 + 2 * c < d) d = a * 2 + 2 * c;
if (b * 2 + 2 * c < d) d = b * 2 + 2 * c;
;
cout << d << endl;
}
| 0 |
#include <bits/stdc++.h>
int n;
int pzs(int k) {
for (int i = 2; i * i <= k; i++) {
if (k % i == 0) {
return 0;
break;
}
}
return 1;
}
int main() {
scanf("%d", &n);
if (pzs(n)) {
printf("1\n%d\n", n);
return 0;
}
printf("3\n3 ");
n -= 3;
for (int i = 3;; i += 2) {
if (pzs(i) && pzs(n - i)) {
printf("%d %d\n", i, n - i);
return 0;
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, d;
double t[100005];
cin >> n >> a >> d;
memset(t, 0, sizeof(t));
for (int i = 1; i <= n; i++) {
int tt, v;
double s;
cin >> tt >> v;
double ttt = (double)v / a;
s = 0.5 * a * ttt * ttt;
if (s <= d) {
t[i] = tt + ttt + (double)(d - s) / (double)v;
} else {
t[i] = tt + sqrt(((2.0 * (double)d)) / (double)a);
}
if (t[i] <= t[i - 1]) {
printf("%.10f\n", t[i - 1]);
t[i] = t[i - 1];
} else
printf("%.10f\n", t[i]);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
if (m > n)
cout << -1 << endl;
else {
if (m == n)
cout << m << endl;
else {
int p = n / 2 + n % 2;
while (p % m != 0 && p <= n) {
p++;
}
cout << p << endl;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long mxn = 1e5 + 7;
int main() {
long long n;
set<long long> qwe;
while (cin >> n) {
qwe.insert(n);
}
cout << 4 - qwe.size();
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 100;
char s[maxn];
int main() {
scanf("%s", s);
int n = strlen(s);
int m = (n + 1) / 2;
int ans = 0;
for (int i = 0; i < m; i++) {
if (s[i] != s[n - i - 1]) ans++;
}
if (n & 1) {
if (ans <= 1)
printf("YES\n");
else
printf("NO\n");
} else {
if (ans == 1)
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using std::set;
using std::string;
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(nullptr);
string s;
std::cin >> s;
int h = -1, e = -1, i1 = -1, i2 = -1, d = -1;
for (size_t i = 0; i < s.size(); ++i) {
if (s[i] == 'h' && h < 0) {
h = i;
}
if (s[i] == 'e' && e < 0 && h >= 0) {
e = i;
}
if (s[i] == 'd' && d < 0 && h >= 0 && e > 0 && i1 > 0) {
d = i;
}
if (s[i] == 'i' && i1 < 0 && h >= 0 && e > 0) {
i1 = i;
} else {
if (s[i] == 'i' && i2 < 0 && i1 > 0 && h >= 0 && e > 0 && d > 0) {
i2 = i;
}
}
if (h < e && e < i1 && i1 < d && d < i2) {
std::cout << "YES";
return 0;
}
}
std::cout << "NO";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline void init() {
ios::sync_with_stdio(false);
cin.tie(0);
}
int dx[4] = {0, 0, -1, 1};
int dy[4] = {-1, 1, 0, 0};
const int N = 2001;
const int INF = 0x3f3f3f3f;
int g[N][N];
bool vis[N][N];
int lft[N][N];
void test() {
int n, m;
cin >> n >> m;
int r, c;
cin >> r >> c;
r--, c--;
int x, y;
cin >> x >> y;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
char c;
cin >> c;
g[i][j] = (c == '*');
}
}
memset(lft, INF, sizeof lft);
deque<pair<int, int> > dq;
lft[r][c] = 0;
dq.push_front({r, c});
auto disp_dq = [&]() {
for (pair<int, int> val : dq) {
cout << '{' << val.first << ',' << val.second << '}';
}
cout << endl;
};
while (!dq.empty()) {
pair<int, int> cur = dq.front();
dq.pop_front();
vis[cur.first][cur.second] = true;
for (int i = 0; i < 4; i++) {
pair<int, int> nxt = cur;
nxt.first = cur.first + dx[i];
nxt.second = cur.second + dy[i];
if (nxt.first < 0 or nxt.first >= n or nxt.second < 0 or nxt.second >= m)
continue;
if (g[nxt.first][nxt.second] == 1 or vis[nxt.first][nxt.second]) continue;
if (i) {
if (lft[nxt.first][nxt.second] > lft[cur.first][cur.second]) {
lft[nxt.first][nxt.second] = lft[cur.first][cur.second];
dq.push_front(nxt);
}
} else {
if (lft[nxt.first][nxt.second] > lft[cur.first][cur.second] + 1) {
lft[nxt.first][nxt.second] = lft[cur.first][cur.second] + 1;
dq.push_back(nxt);
}
}
}
}
int ans = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (lft[i][j] == INF) continue;
int rr = lft[i][j] + (j - c);
if (lft[i][j] <= x and rr <= y) ans++;
}
}
cout << ans << '\n';
}
int main() {
init();
test();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
string s;
vector<pair<int, int> > v;
cin >> s;
int n = (int)s.length(), last = 0;
for (int i = 0; i < n; i++) {
if (i == n - 1 || s[i] != s[i + 1]) {
if (s[i] == '1') {
v.push_back({n - last, 1});
v.push_back({n - (i + 1), -1});
}
last = i + 1;
}
}
stack<pair<int, int> > S;
for (int i = 0; i < v.size(); i++) {
if (S.empty()) {
S.push(v[i]);
continue;
}
if (S.top().first == v[i].first + 1 && S.top().second + v[i].second == 0) {
S.pop();
S.push({v[i].first, -v[i].second});
} else
S.push(v[i]);
}
cout << (int)S.size() << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 4444;
const int M = N * 10;
int s[N], c[M];
char str[N];
int main() {
long long a;
while (cin >> a >> str) {
int n = strlen(str);
s[0] = 0;
for (int i = 0; i < n; i++) s[i + 1] = str[i] - '0';
for (int i = 1; i <= n; i++) s[i] += s[i - 1];
for (int i = 0; i < M; i++) c[i] = 0;
for (int i = 1; i <= n; i++)
for (int j = i; j <= n; j++) c[s[j] - s[i - 1]]++;
long long ans = 0;
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j++) {
long long ds = s[j] - s[i - 1];
if (ds == 0) {
if (a == 0) ans += (long long)(n + 1) * n >> 1;
} else {
if (a % ds) continue;
if (a / ds >= M) continue;
ans += c[a / ds];
}
}
}
cout << ans << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const double pi = 3.14159265359;
const long long int mini = 1e18;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long n, m, i, j, l, k = 0, p = 0, s = 0, t = 1, x, y, z, r, c;
long long a[15];
long long b[15] = {0};
cin >> n >> k;
for (i = 0; i < k; i++) {
cin >> x;
if (i != k - 1) s += (n - x);
}
cout << s;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long power(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) res = (res * a) % 1000000007;
a = (a * a) % 1000000007;
b >>= 1;
}
return res;
}
signed main() {
std ::ios_base ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n, x;
cin >> n >> x;
vector<long long> primes;
long long p = n;
for (long long i = 2; i * i <= p; i++) {
if (p % i) continue;
primes.push_back(i);
while (p % i == 0) p /= i;
}
if (p > 1) primes.push_back(p);
long long answer = 1;
for (long long i = 0; i < primes.size(); i++) {
long long prime = primes[i];
long long cur = x;
long long cnt = 0;
while (cur) {
cnt += (cur / prime);
cur /= prime;
}
answer = (answer * power(prime, cnt)) % 1000000007;
}
cout << answer;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using lint = long long;
using ulint = unsigned long long;
const int N = 500 + 1;
const int K = 10 + 1;
int h[K];
int dp[N * K];
int n, k;
int solve(int p, int c) {
if (p == 0 || c == 0) {
return 0;
}
fill(begin(dp), end(dp), 0);
while (p--) {
for (int i = 0; i <= c; i++) {
for (int j = 0; j <= k; j++) {
if (i >= j) {
dp[i - j] = max(dp[i - j], dp[i] + h[j]);
}
}
}
}
return *max_element(begin(dp), end(dp));
}
int main(void) {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n >> k;
map<int, int> fav, cnt;
for (int i = 0; i < n * k; i++) {
int c;
cin >> c;
cnt[c]++;
}
for (int i = 0; i < n; i++) {
int f;
cin >> f;
fav[f]++;
}
for (int i = 1; i <= k; i++) {
cin >> h[i];
}
int ans = 0;
for (auto e : fav) {
ans += solve(e.second, cnt[e.first]);
}
cout << ans << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
for (int it = 0; it < t; ++it) {
int n;
cin >> n;
vector<int> v(n, 0);
for (auto& x : v) cin >> x;
vector<int> kek(n, 0);
if (n % 2 == 1) {
for (int i = 0; i <= n / 2; i++) {
kek[i] = i;
}
kek[n / 2 + 1] = n / 2 + 1;
for (int i = 0; i <= n / 2; i++) {
kek[n - 1 - i] = i;
}
bool yes = true;
for (int i = 0; i < n; i++) {
if (v[i] < kek[i]) yes = false;
}
if (yes)
cout << "Yes\n";
else
cout << "No\n";
} else {
for (int i = 0; i < n / 2; i++) {
kek[i] = i;
}
kek[n / 2] = n / 2;
for (int i = n / 2 + 1; i < n; i++) {
kek[i] = n - 1 - i;
}
bool yes = true;
for (int i = 0; i < n; i++) {
if (v[i] < kek[i]) yes = false;
}
if (yes) {
cout << "Yes\n";
continue;
}
reverse(kek.begin(), kek.end());
yes = true;
for (int i = 0; i < n; i++) {
if (v[i] < kek[i]) yes = false;
}
if (yes) {
cout << "Yes\n";
continue;
}
cout << "No\n";
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline void read(long long &x) {
x = 0;
long long f = 1;
char s = getchar();
while (s < '0' || s > '9') {
if (s == '-') f = -1;
s = getchar();
}
while (s >= '0' && s <= '9') {
x = (x << 3) + (x << 1) + (s ^ 48);
s = getchar();
}
x *= f;
}
inline long long Min(long long x, long long y) { return x < y ? x : y; }
inline long long QuickPow(long long x, long long y) {
long long Res = 1, Temp = x;
while (y) {
if (y & 1) Res = Res * Temp % 1000000007;
Temp = Temp * Temp % 1000000007;
y /= 2;
}
return Res;
}
long long a[3005];
double f[3005 * 3005];
int main() {
long long n;
read(n);
for (register int i = 1; i <= n; ++i) read(a[i]);
long long Nxd = 0;
for (register int i = 1; i < n; ++i)
for (register int j = i + 1; j <= n; ++j)
if (a[i] > a[j]) Nxd++;
f[0] = 0;
f[1] = 1;
for (register int i = 2; i <= Nxd; ++i) f[i] = 4 + f[i - 2];
printf("%.10f\n", f[Nxd]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int l, r;
mutable long long val;
node(int L = -1, int R = -1, long long Val = 0) { l = L, r = R, val = Val; }
bool operator<(const node &d) const { return l < d.l; }
};
set<node> s;
int n, m, inp;
int seed, vmax;
vector<pair<long long, int> > v;
int rnd() {
int ret = seed;
seed = ((long long)seed * 7LL + 13LL) % 1000000007;
return ret;
}
set<node>::iterator split(int pos) {
set<node>::iterator it = s.lower_bound(node(pos));
if (it != s.end() && it->l == pos) return it;
it--;
int L = it->l, R = it->r;
long long V = it->val;
s.erase(it);
s.insert(node(L, pos - 1, V));
return s.insert(node(pos, R, V)).first;
}
void merge(int l, int r, int v) {
set<node>::iterator itl = split(l), itr = split(r + 1);
s.erase(itl, itr);
s.insert(node(l, r, (long long)v));
}
void add(int l, int r, int v) {
set<node>::iterator itl = split(l), itr = split(r + 1);
for (; itl != itr; itl++) itl->val += v;
}
long long find_kth(int l, int r, int k) {
v.clear();
set<node>::iterator itl = split(l), itr = split(r + 1);
for (; itl != itr; itl++)
v.push_back(make_pair(itl->val, (itl->r) - (itl->l) + 1));
sort(v.begin(), v.end());
for (int i = 0; i <= (int)v.size() - 1; i++) {
k -= v[i].second;
if (k <= 0) return v[i].first;
}
return -1LL;
}
int power(int a, int x, int p) {
int sum = 1;
while (x) {
if (x & 1) sum = (long long)sum * a % p;
a = (long long)a * a % p;
x >>= 1;
}
return sum;
}
int get_sum(int l, int r, int x, int p) {
set<node>::iterator itl = split(l), itr = split(r + 1);
int sum = 0;
for (; itl != itr; itl++)
sum = ((long long)sum +
(long long)((itl->r) - (itl->l) + 1) * power(itl->val % p, x, p)) %
p;
return sum;
}
int main() {
int opt, l, r, x, y;
cin >> n >> m >> seed >> vmax;
for (int i = 1; i <= n; i++) {
inp = rnd() % vmax + 1;
s.insert(node(i, i, (long long)inp));
}
for (int i = 1; i <= m; i++) {
opt = rnd() % 4 + 1;
l = rnd() % n + 1;
r = rnd() % n + 1;
if (l > r) swap(l, r);
if (opt == 3)
x = rnd() % (r - l + 1) + 1;
else
x = rnd() % vmax + 1;
if (opt == 4) y = rnd() % vmax + 1;
switch (opt) {
case 1:
add(l, r, x);
break;
case 2:
merge(l, r, x);
break;
case 3:
printf("%lld\n", find_kth(l, r, x));
break;
case 4:
printf("%d\n", get_sum(l, r, x, y));
break;
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int x1, y1, x2, y2;
scanf(" %d %d %d %d", &x1, &y1, &x2, &y2);
if (x1 != x2)
printf("%d %d\n", x1, x2);
else if (y1 != y2)
printf("%d %d\n", y1, y2);
else
printf("%d %d\n", x1, y2);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
bool b = false;
int a1[5000], a2[5000], a3[5000], b1 = 0, b2 = 0, b3 = 0;
int n;
cin >> n;
int a[n], t1 = 0, t2 = 0, t3 = 0, m;
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (a[i] == 1) {
t1++;
a1[b1] = i;
b1++;
} else if (a[i] == 2) {
t2++;
a2[b2] = i;
b2++;
} else if (a[i] == 3) {
t3++;
a3[b3] = i;
b3++;
}
}
if (t1 == 0 || t2 == 0 || t3 == 0) {
cout << 0;
goto e;
}
m = min(min(t1, t2), t3);
cout << m << endl;
for (int i = 0; i < m; i++) {
cout << a1[i] << " " << a2[i] << " " << a3[i] << endl;
}
e:
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
template <typename T>
inline T read() {
T ans = 0, flag = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') flag = -1;
c = getchar();
}
while (isdigit(c)) {
ans = ans * 10 + c - 48;
c = getchar();
}
return ans * flag;
}
int n, a[maxn];
long long s[maxn];
map<long long, int> cnt;
int main() {
n = read<int>();
for (register int i(1), end_i(n); i <= end_i; i++)
s[i] = s[i - 1] + (a[i] = read<int>());
cnt[0] = 1;
int j = 0;
long long ans = 0;
for (register int i(1), end_i(n); i <= end_i; i++) {
cnt[s[i]]++;
while (cnt[s[i]] > 1) cnt[s[j++]]--;
ans += i - j;
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
const double eps = 1e-12;
double x, y;
double k;
int cal1(int mid) {
double temp = (y - x) / (-2 * mid);
if (temp + eps >= y)
return 1;
else
return 0;
}
int cal2(int mid) {
double temp = (y + x) / (2 * mid);
if (temp + eps >= y)
return 1;
else
return 0;
}
int main() {
while (~scanf("%lf%lf", &x, &y)) {
k = 1e15;
int l = 0, r = 1e9 + 5;
while (l <= r) {
int mid = (l + r) >> 1;
if (cal1(mid)) {
l = mid + 1;
k = min((y - x) / (-2 * mid), k);
} else
r = mid - 1;
}
l = 0, r = 1e9 + 5;
while (l <= r) {
int mid = (l + r) >> 1;
if (cal2(mid)) {
l = mid + 1;
k = min((y + x) / (2 * mid), k);
} else
r = mid - 1;
}
if (k > 1e13)
printf("-1\n");
else
printf("%.10lf\n", k);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int inft = 1000000009;
const int MAXN = 1000006;
const double eps = 1e-15;
inline bool iszero(double first) { return first <= eps && first >= -eps; }
int sgn(double first) { return iszero(first) ? 0 : (first < 0 ? -1 : 1); }
struct pt {
int first, second;
int nr;
pt(double xx = 0, double yy = 0, int nnrr = -1)
: first(xx), second(yy), nr(nnrr) {}
};
bool operator<(const pt &a, const pt &b) {
if (a.first != b.first) return a.first > b.first;
return a.second > b.second;
}
bool praword(pt a, pt b, pt c) {
return 1LL * a.second * b.first * c.first * c.second +
1LL * a.first * a.second * b.second * c.first +
1LL * a.first * b.first * b.second * c.second -
(1LL * a.first * a.second * b.first * c.second +
1LL * a.first * b.second * c.first * c.second +
1LL * a.second * b.first * b.second * c.first) <
0;
}
vector<pt> otoczka(vector<pt> ab) {
sort(ab.begin(), ab.end());
int l = ab.size(), i, j, k;
vector<pt> wyn(l + 1);
if (l < 3) return ab;
j = 0;
for (i = 0; i < l; i++) {
if (i && ab[i].second <= wyn[j - 1].second) continue;
while (j - 2 >= 0 && praword(wyn[j - 2], wyn[j - 1], ab[i])) j--;
wyn[j++] = ab[i];
}
return vector<pt>(wyn.begin(), wyn.begin() + j);
}
map<pair<int, int>, vector<int> > M;
int main() {
int n;
scanf("%d", &n);
vector<pt> A(n);
for (int i = 0; i < (n); ++i) {
int a, b;
scanf("%d%d", &a, &b);
A[i].nr = i;
A[i].first = a;
A[i].second = b;
M[pair<int, int>(A[i].first, A[i].second)].push_back(i);
}
vector<pt> B = otoczka(A);
vector<int> ANS;
for (typeof((B).begin()) it = (B).begin(); it != (B).end(); ++it)
for (typeof((M[pair<int, int>(it->first, it->second)]).begin()) i2 =
(M[pair<int, int>(it->first, it->second)]).begin();
i2 != (M[pair<int, int>(it->first, it->second)]).end(); ++i2)
ANS.push_back(*i2);
sort((ANS).begin(), (ANS).end());
ANS.resize(unique((ANS).begin(), (ANS).end()) - ANS.begin());
for (typeof((ANS).begin()) it = (ANS).begin(); it != (ANS).end(); ++it)
printf("%d ", *it + 1);
printf("\n");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 5;
char str[maxn];
int dp[maxn];
int main() {
while (scanf("%s", &str) == 1) {
int len = strlen(str);
int ans = 0;
int sum = 0;
stack<int> s;
memset(dp, 0, sizeof(dp));
for (int i = 0; i < len; ++i) {
if (str[i] == '(') {
s.push(i);
} else {
if (!s.empty()) {
int temp = s.top();
s.pop();
if (temp != 0) {
dp[i] = dp[temp - 1] + i - temp + 1;
} else {
dp[i] = dp[0] + i - temp + 1;
}
if (ans < dp[i]) {
ans = dp[i];
sum = 1;
} else if (ans == dp[i]) {
++sum;
}
}
}
}
if (ans == 0) {
printf("0 1\n");
} else {
printf("%d %d\n", ans, sum);
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
const int N = 300000;
int n;
char s[N + 1];
int main() {
scanf("%d%s", &n, s);
int p = -1;
for (int i = 0; i < n - 1; ++i)
if (s[i] > s[i + 1]) p = i;
if (p != -1) {
printf("YES\n");
printf("%d %d\n", p + 1, p + 2);
} else
printf("NO\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
int add(int a, int b) {
long long x = a + b;
if (x >= 998244353) x -= 998244353;
if (x < 0) x += 998244353;
return x;
}
long long mul(long long a, long long b) { return (a * b) % 998244353; }
long long pw(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans = (ans * a) % 998244353;
a = (a * a) % 998244353;
b >>= 1;
}
return ans;
}
int n;
long long dp[2][1000002];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
dp[1][0] = 1;
dp[0][0] = 1;
for (int i = 1; i <= n; ++i) {
int x = (i - 1);
if (x % 2 == 0) {
int par = (1 + x / 2) % 2;
dp[par][i] = mul(dp[!par][x / 2], dp[0][x / 2]);
} else {
for (int j = x / 2; j <= 1 + x / 2; j++) {
int par = (1 + j) % 2;
dp[par][i] = mul(dp[!par][j], dp[0][i - j - 1]);
}
}
}
cout << (dp[1][n] + dp[0][n]) % 998244353;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int b, d;
string a, c;
int dp[111];
int main() {
cin >> b >> d >> a >> c;
for (int i = (0); i < (c.size()); i++) {
int k = 0;
for (int j = (0); j < (a.size()); j++)
if (c[(i + k) % c.size()] == a[j]) k++;
dp[i] = k;
}
long long int ans = 0;
for (int i = (0); i < (b); i++) ans += dp[(ans % c.size())];
cout << ans / c.size() / d << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int a[110];
int main() {
int n, m, l, r, i, j;
int k = 0;
while (~scanf("%d %d", &n, &m)) {
memset(a, 0, sizeof(a));
for (i = 1; i <= m; i++) a[i] = i;
for (i = 1; i <= n; i++) {
scanf("%d %d", &l, &r);
for (j = l; j <= r; j++) a[j] = 0;
}
for (i = 1; i <= m; i++) {
if (a[i] != 0) ++k;
}
if (k == 0)
printf("%d\n", k);
else {
printf("%d\n", k);
for (i = 1; i <= m; i++) {
if (a[i] != 0) printf("%d ", a[i]);
}
printf("\n");
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
const int N = 100100;
std::mt19937 rd(time(0));
int ls[N], rs[N], sz[N], p[N], rt, n, tot;
long long v[N], ad[N], tg[N];
int nd(long long a) { return p[++tot] = rd(), sz[tot] = 1, v[tot] = a, tot; }
void up(int x) { sz[x] = sz[ls[x]] + sz[rs[x]] + 1; }
void pt1(int x, long long t) {
if (x) v[x] += t, ad[x] += t;
}
void pt2(int x, long long t) {
if (x) v[x] += t * sz[ls[x]], tg[x] += t;
}
void dw(int x) {
if (ad[x]) pt1(ls[x], ad[x]), pt1(rs[x], ad[x]), ad[x] = 0;
if (tg[x])
pt2(ls[x], tg[x]), pt2(rs[x], tg[x]), pt1(rs[x], (sz[ls[x]] + 1ll) * tg[x]),
tg[x] = 0;
}
void split(int rt, int k, int& x, int& y) {
if (!rt)
x = y = 0;
else {
dw(rt);
if (k <= sz[ls[rt]])
split(ls[rt], k, x, ls[rt]), up(y = rt);
else
split(rs[rt], k - sz[ls[rt]] - 1, rs[rt], y), up(x = rt);
}
}
int merge(int x, int y) {
if (!x || !y) return x | y;
if (p[x] > p[y]) {
dw(x), rs[x] = merge(rs[x], y), up(x);
return x;
} else {
dw(y), ls[y] = merge(x, ls[y]), up(y);
return y;
}
}
long long kth(int rt, int k) {
dw(rt);
if (k <= sz[ls[rt]]) return kth(ls[rt], k);
return sz[ls[rt]] + 1 == k ? v[rt] : kth(rs[rt], k - sz[ls[rt]] - 1);
}
long long kth(int k) { return k ? kth(rt, k) : 0; }
long long mx(int rt) {
return rt ? dw(rt), std::max(v[rt], std::max(mx(ls[rt]), mx(rs[rt]))) : 0;
}
int main() {
std::ios::sync_with_stdio(false), std::cin.tie(0);
std::cin >> n;
rt = merge(nd(-1e18), nd(-1e18));
for (int i = 1, x; i <= n; ++i) {
std::cin >> x;
int l = -1, r = i, a, b;
while (l + 1 != r) {
long long mid = l + r >> 1;
if (kth(mid) + x * (mid + 1) > kth(mid + 1))
r = mid;
else
l = mid;
}
l = r;
if (l) {
split(rt, l - 1, a, b);
rt = merge(a, nd(kth(b, 1)));
pt1(b, x * (l + 1ll));
pt2(b, x);
rt = merge(rt, b);
} else {
pt1(rt, x + x);
pt2(rt, x);
rt = merge(nd(x), rt);
}
}
std::cout << mx(rt) << '\n';
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
map<char, int> mp;
int t = 1;
for (char i = 'a'; i <= 'z'; i++) {
mp[i] = t;
t++;
}
int n, k;
cin >> n >> k;
string s;
cin >> s;
sort(s.begin(), s.end());
string p;
for (int i = 0; i < s.size(); i++) {
if (p.size() == k) {
break;
}
if ((s[i] - p[p.size() - 1]) >= 2) {
p += s[i];
}
}
int v = 0;
if (p.size() != k) {
cout << -1;
} else {
int h = 0;
for (auto i : mp) {
if (i.first == p[h]) {
v += i.second;
h++;
}
}
cout << v;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using ll = long long;
using namespace std;
unsigned long long int leftRotate(unsigned long long int n,
unsigned long long int d) {
return (n << d) | (n >> (16 - d));
}
unsigned long long int rightRotate(unsigned long long int n,
unsigned long long int d) {
return (n >> d) | (n << (16 - d));
}
int log2(int x) {
int res = 0;
while (x >>= 1) res++;
return res;
}
long long int issorted(long long int arr[], long long int n) {
if (n == 1 || n == 0) return 1;
if (arr[n - 1] < arr[n - 2]) return 0;
return issorted(arr, n - 1);
}
int computeXOR(int n) {
if (n % 4 == 0) return n;
if (n % 4 == 1) return 1;
if (n % 4 == 2)
return n + 1;
else
return 0;
}
long long int count(string s) {
long long int ans = 1, i, j;
for (i = 1; i < s.length(); i++) {
for (j = 0; j < i; j++) {
if (s[i] == s[j]) break;
}
if (i == j) ans++;
}
return ans;
}
bool isPerfectSquare(long double x) {
long double sr = sqrt(x);
return ((sr - floor(sr)) == 0);
}
long long int countarray(long long int a[], long long int n) {
unordered_set<long long int> s;
for (long long int i = 0; i < n; i++) s.insert(a[i]);
return s.size();
}
bool check(int N) {
long long int i;
if (N & (1 << i))
return true;
else
return false;
}
bool isvowel(char ch) {
string s = "aeiouAEIOU";
for (char c : s) {
if (c == ch) {
return true;
}
}
return false;
}
bool isPrime(long long int n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (long long int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
struct interval {
int start, end;
};
bool compare(interval x, interval y) { return (x.start < y.start); }
bool isSubstring(string s1, string s2) {
int M = s1.length();
int N = s2.length();
for (int i = 0; i <= N - M; i++) {
int j;
for (j = 0; j < M; j++)
if (s2[i + j] != s1[j]) break;
if (j == M) return true;
}
return false;
}
int seive(int n) {
bool isprime[n + 1];
for (int i = 2; i <= n; i++) isprime[i] = true;
isprime[0] = false;
isprime[1] = false;
for (int i = 2; i <= sqrt(n); i++) {
if (isprime[i] == true) {
for (int j = i * i; j <= n; j += i) {
isprime[j] = false;
}
}
}
int count = 0;
for (int i = 0; i <= n; i++) {
if (isprime[i] == true) count++;
}
return count;
}
void multiply(int a[2][2], int m[2][2]) {
int him[2][2];
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
him[i][j] = 0;
for (int k = 0; k < 2; k++) {
him[i][j] += (a[i][k] * m[k][j]);
}
}
}
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
a[i][j] = him[i][j];
}
}
}
void power(int a[2][2], int n) {
if (n == 0 || n == 1) return;
power(a, n / 2);
multiply(a, a);
if (n % 2 != 0) {
int m[2][2] = {{1, 1}, {1, 0}};
multiply(a, m);
}
}
int fib(int n) {
int a[2][2] = {{1, 1}, {1, 0}};
if (n == 0) return 0;
power(a, n - 1);
return a[0][0];
}
int factmod(int n, int p) {
int res = 1;
while (n > 1) {
res = (res * ((n / p) % 2 ? p - 1 : 1)) % p;
for (int i = 2; i <= (n % p); i++) res = (res * i) % p;
n /= p;
}
return res % p;
}
int bubblesort(int a[], int n) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n - 1; j++) {
if (a[j] > a[j + 1]) {
swap(a[j], a[j + 1]);
}
}
}
}
long long int modularexponentiation(int a, long long int n, long long int m) {
long long int res = 1;
while (n > 0) {
if (n & 1) res = ((res % m) * (a % m)) % m;
n /= 2;
a = ((a % m) * (a % m)) % m;
}
return res;
}
long long int largest_power(long long int N) {
N = N | (N >> 1);
N = N | (N >> 2);
N = N | (N >> 4);
N = N | (N >> 8);
N = N | (N >> 16);
return (N + 1) >> 1;
}
bool alternate(long long int n) {
long long int i;
if ((n ^ (n >> 1)) == (pow(2, i) - 1)) return true;
return false;
}
long long int countDivisors(long long int n) {
long long int cnt = 0;
for (int i = 1; i <= sqrt(n); i++) {
if (n % i == 0) {
if (n / i == i)
cnt++;
else
cnt = cnt + 2;
}
}
return cnt;
}
int highestpowerof2(int n) { return (n & (~(n - 1))); }
long long int dectobin(long long int n) {
for (int i = 31; i >= 0; i--) {
if (n & (1 << i))
cout << "1";
else
cout << "0";
}
}
void lowertoupper(char ch) {
ch = ch & '_';
cout << ch << " ";
}
void uppertolower(char ch) {
ch = ch | ' ';
cout << ch << " ";
}
long long int primecounter(long long int l, long long int r) {
long long int fact = 1, count = 0;
for (long long int i = l; i <= r; i++) {
if (((fact - i) % ((1LL << i) - 1)) == 0) count++;
fact *= ((1LL << i) - 1);
}
return count;
}
long long int counteprime(long long int l, long long int r) {
long long int count = 0, i, j;
for (i = l; i <= r; i++) {
for (j = 2; j <= (i / j); j++) {
if (!(i % j)) break;
}
if (j > (i / j)) count++;
}
return count;
}
void pairsort(int a[], char b[], int n) {
pair<int, char> pairt[n];
for (int i = 0; i < n; i++) {
pairt[i].first = a[i];
pairt[i].second = b[i];
}
sort(pairt, pairt + n);
for (int i = 0; i < n; i++) {
a[i] = pairt[i].first;
b[i] = pairt[i].second;
}
}
long long int fibo(long long int n) {
long double him = (1 + sqrt(5)) / 2;
return round(pow(him, n) / sqrt(5));
}
long long int binToDec(string c) {
long long int count = 0;
for (long long int i = 0; i < c.length(); i++) {
if (c[i] == '1') {
long long int val = 1;
for (long long int j = 0; j < i; j++) {
val *= 2;
}
count += val;
}
}
return count;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
string s;
cin >> s;
string c = "";
map<char, string> make_pair;
long long int sum, count = 0, z;
make_pair['>'] = "1000";
make_pair['<'] = "1001";
make_pair['+'] = "1010";
make_pair['-'] = "1011";
make_pair['.'] = "1100";
make_pair[','] = "1101";
make_pair['['] = "1110";
make_pair[']'] = "1111";
for (int i = 0; i < s.length(); i++) {
c += make_pair[s[i]];
}
reverse(c.begin(), c.end());
for (long long int i = 0; i < c.length(); i++) {
if (c[i] == '1') {
long long int val = 1;
for (long long int j = 0; j < i; j++) {
val *= 2;
val %= 1000003;
}
count += val;
count %= 1000003;
}
}
cout << count << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void readi(T &x) {
T input = 0;
bool negative = false;
char c = ' ';
while (c < '-') {
c = getchar();
}
if (c == '-') {
negative = true;
c = getchar();
}
while (c >= '0') {
input = input * 10 + (c - '0');
c = getchar();
}
if (negative) {
input = -input;
}
x = input;
}
template <class T>
void printi(T output) {
if (output == 0) {
putchar('0');
return;
}
if (output < 0) {
putchar('-');
output = -output;
}
int aout[20];
int ilen = 0;
while (output) {
aout[ilen] = ((output % 10));
output /= 10;
ilen++;
}
for (int i = ilen - 1; i >= 0; i--) {
putchar(aout[i] + '0');
}
return;
}
template <class T>
void ckmin(T &a, T b) {
a = min(a, b);
}
template <class T>
void ckmax(T &a, T b) {
a = max(a, b);
}
long long randomize(long long mod) {
return ((1ll << 30) * rand() + (1ll << 15) * rand() + rand()) % mod;
}
const long double PI = 4.0 * atan(1.0);
const long double EPS = 1e-20;
long long normalize(long long x, long long mod = 1000000007) {
return (((x % mod) + mod) % mod);
}
long long N;
bitset<1000000> bs;
int32_t main() {
ios_base::sync_with_stdio(0);
srand(time(0));
if (fopen("cf997b.in", "r")) {
freopen("cf997b.in", "r", stdin);
}
cin >> N;
if (N > 1000) {
cout << 1ll * 49ll * N - 247ll << '\n';
return 0;
}
bs[0] = true;
for (int i = 0; i < N; i++) {
bs |= ((bs << 4) | (bs << 9) | (bs << 49));
}
cout << bs.count() << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
inline int in() {
int x;
scanf("%d", &x);
return x;
}
bool Check(int N, int pos) { return (bool)(N & (1 << pos)); }
int Set(int N, int pos) { return N = N | (1 << pos); }
int fx[] = {+0, +0, +1, -1, -1, +1, -1, +1};
int fy[] = {-1, +1, +0, +0, +1, +1, -1, -1};
int hr[] = {-2, -2, -1, +1, +2, +2, -1, +1};
int hc[] = {+1, -1, +2, +2, -1, +1, -2, -2};
int dx[] = {+1, -1, +0, +0};
int dy[] = {+0, +0, +1, -1};
const int MAXN = (int)1e5 + 9;
int main() {
int i, j, k, l, m, n, p, q, x, y, u, v, r, tc, t;
string s[] = {"Time", "Mind", "Soul", "Power", "Reality", "Space"};
cin >> n;
map<string, int> mp;
for (i = 0; i < n; i++) {
string tt;
cin >> tt;
if (tt == "purple") mp["Power"]++;
if (tt == "green") mp["Time"]++;
if (tt == "blue") mp["Space"]++;
if (tt == "orange") mp["Soul"]++;
if (tt == "red") mp["Reality"]++;
if (tt == "yellow") mp["Mind"]++;
}
vector<string> vv;
for (i = 0; i < 6; i++) {
if (mp[s[i]] == 0) vv.push_back(s[i]);
}
cout << vv.size() << endl;
for (i = 0; i < vv.size(); i++) cout << vv[i] << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, g, b;
void Process() {
cin >> n >> g >> b;
long long good = (n + 1) / 2;
long long bad = n - good;
long long cycle = good / g;
if (good % g == 0) --cycle;
good -= cycle * g;
bad -= cycle * b;
if (bad <= 0) {
cout << cycle * (g + b) + good << endl;
return;
} else
cout << cycle * (g + b) + good + bad << endl;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int Tcase;
cin >> Tcase;
while (Tcase--) {
Process();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char srt[110];
int count = 1, i, l, max = 0;
gets(srt);
l = strlen(srt);
for (i = 0; i < l; i++) {
if (srt[i] == 'A' || srt[i] == 'E' || srt[i] == 'I' || srt[i] == 'U' ||
srt[i] == 'O' || srt[i] == 'Y') {
if (count > max) {
max = count;
}
count = 1;
} else {
count++;
if (count > max) {
max = count;
}
}
}
cout << max << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MN = 1000111;
const int BASE = 1000000007;
int f[2][MN], g[2][MN];
int main() {
int n = 1000000;
f[0][1] = g[0][1] = 0;
f[1][1] = g[1][1] = 1;
for (int i = (2), _b = (n); i <= _b; i++)
for (int last = 0, _a = (2); last < _a; last++) {
if ((i & 1) == last) f[last][i] = g[1 - last][i - 1] + 1;
g[last][i] = g[last][i - 1] + f[last][i];
if (g[last][i] >= BASE) g[last][i] -= BASE;
}
while (cin >> n) cout << (g[0][n] + g[1][n]) % BASE << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct SuffixAutomaton {
int len[2 * 1000100], link[2 * 1000100], cnt[2 * 1000100];
int nxt[2 * 1000100][26], sz, last, root;
int newnode() {
int x = ++sz;
len[x] = 0;
link[x] = -1;
cnt[x] = 1;
for (int c = 0; c < 26; c++) nxt[x][c] = 0;
return x;
}
inline int reduce(char c) { return c - 'a'; }
SuffixAutomaton() { clear(); }
void clear() {
sz = 0;
root = last = newnode();
}
void insert(string &s) {
for (char &c : s) extend(reduce(c));
}
void extend(int c) {
int cur = newnode(), p;
len[cur] = len[last] + 1;
for (p = last; p != -1 && !nxt[p][c]; p = link[p]) {
nxt[p][c] = cur;
}
if (p == -1)
link[cur] = root;
else {
int q = nxt[p][c];
if (len[p] + 1 == len[q])
link[cur] = q;
else {
int clone = newnode();
len[clone] = len[p] + 1;
for (int i = 0; i < 26; i++) nxt[clone][i] = nxt[q][i];
link[clone] = link[q];
cnt[clone] = 0;
while (p != -1 && nxt[p][c] == q) {
nxt[p][c] = clone;
p = link[p];
}
link[q] = link[cur] = clone;
}
}
last = cur;
}
int deg[2 * 1000100];
void computeCnt() {
fill(deg, deg + sz + 1, 0);
for (int i = root + 1; i <= sz; i++) deg[link[i]]++;
queue<int> q;
for (int i = root + 1; i <= sz; i++)
if (deg[i] == 0) q.push(i);
while (!q.empty()) {
int i = q.front();
q.pop();
if (i <= root) continue;
int j = link[i];
cnt[j] += cnt[i];
if ((--deg[j]) == 0) q.push(j);
}
}
int nmatches(string &s) {
int p = root;
for (int i = 0; i < s.size(); i++) {
int c = reduce(s[i]);
if (!nxt[p][c]) return 0;
p = nxt[p][c];
}
return cnt[p];
}
} SA;
int n, sz;
char s[1000100];
string str, pat;
void z_function(string &s, int *z) {
for (int i = 1, L = 0, R = 0; i < s.size(); i++) {
if (i > R) L = R = i;
z[i] = min(R - i, z[i - L]);
while (i + z[i] < s.size() && s[z[i]] == s[i + z[i]]) z[i]++;
if (i + z[i] > R) L = i, R = i + z[i];
}
}
int z[2000100];
bool ok(int id) { return (id < sz || z[id - sz + 1] < sz); }
int main() {
scanf("%s", s);
str = s;
SA.insert(str);
SA.computeCnt();
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%s", s);
pat = s;
sz = pat.size();
pat += pat;
pat.pop_back();
z_function(pat, z);
int ans = 0, v = 1, l = 0;
for (int j = 0; j < pat.size(); j++) {
int idx = pat[j] - 'a';
while (v > 1 && (!SA.nxt[v][idx] || SA.len[SA.link[v]] >= sz - 1)) {
v = SA.link[v];
l = SA.len[v];
}
if (SA.nxt[v][idx]) {
v = SA.nxt[v][idx];
l++;
}
if (!ok(j)) {
break;
}
if (l >= sz) ans += SA.cnt[v];
}
printf("%d\n", ans);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long m1 = 799999969;
const long long k1 = 599999929;
struct h {
long long v;
int l;
};
long long pot[300011];
long long minv[300011];
long long modpot(long long x, long long p, long long mod) {
if (p == 0) return 1;
if (p % 2 == 1) return (x * modpot(x, p - 1, mod)) % mod;
x = modpot(x, p / 2, mod);
return (x * x) % mod;
}
h add(h h1, h h2) {
h nh;
nh.v = h2.v * pot[h1.l];
nh.v %= m1;
nh.v += h1.v;
nh.v %= m1;
nh.l = h1.l + h2.l;
return nh;
}
h subsa(h h1, h h2) {
if (h1.l >= h2.l) return {0, 0};
h nh = h2;
nh.v += m1 - h1.v;
nh.v %= m1;
nh.v *= minv[h1.l];
nh.v %= m1;
nh.l -= h1.l;
return nh;
}
h subse(h h1, h h2) {
if (h1.l >= h2.l) return {0, 0};
h nh = h2;
nh.v += m1 - (h1.v * pot[h2.l - h1.l]) % m1;
nh.v %= m1;
nh.l -= h1.l;
return nh;
}
string nc;
vector<int> g[300001];
int apd[300001];
int dd[300001];
int pp[300001];
const int N2 = 1 << 20;
pair<int, int> mist[2 * N2];
int lcai[300001];
void setmin(int i, pair<int, int> v) {
i += N2;
mist[i] = v;
for (i = i / 2; i; i /= 2) {
mist[i] = mist[i * 2];
if (mist[i].first == 0 ||
(mist[i * 2 + 1].first > 0 && mist[i * 2 + 1].first < mist[i].first)) {
mist[i] = mist[i * 2 + 1];
}
}
}
int lca(int a, int b) {
a = lcai[a] + N2;
b = lcai[b] + N2;
if (b < a) swap(a, b);
pair<int, int> mi = {9999999, 9999999};
while (a <= b) {
if (a % 2) {
mi = min(mi, mist[a++]);
}
if (!(b % 2)) {
mi = min(mi, mist[b--]);
}
a /= 2;
b /= 2;
}
return mi.second;
}
int git = 0;
void dfs1(int x, int p, int d) {
pp[x] = p;
lcai[x] = git;
setmin(git, {d, x});
git++;
apd[x] = d;
for (int nx : g[x]) {
if (nx != p) {
dfs1(nx, x, d + 1);
setmin(git, {d, x});
git++;
apd[x] = max(apd[x], apd[nx]);
}
}
}
h nh[300001];
h rnh[300001];
void dfs2(int x, int p, int d) {
dd[x] = d;
nh[x] = add(nh[p], {nc[x - 1] - 'a' + 1, 1});
rnh[x] = add({nc[x - 1] - 'a' + 1, 1}, rnh[p]);
for (int nx : g[x]) {
if (nx != p) {
dfs2(nx, x, d + 1);
}
}
}
int lpc[300001];
int lpci[300001];
vector<int> pns[300001];
int gci = 1;
int ac[300001][20];
int loga[300011];
int logam[300011];
void dfs3(int x, int p, int ci) {
ac[x][0] = pp[x];
for (int i = 1; i < 20; i++) {
ac[x][i] = ac[ac[x][i - 1]][i - 1];
}
if (ci == 0) {
ci = gci++;
}
lpci[x] = pns[ci].size();
pns[ci].push_back(x);
lpc[x] = ci;
int md = 0;
int mdi = 0;
for (int nx : g[x]) {
if (nx != p) {
if (apd[nx] > md) {
md = apd[nx];
mdi = nx;
}
}
}
if (mdi) dfs3(mdi, x, ci);
for (int nx : g[x]) {
if (nx != p && nx != mdi) {
dfs3(nx, x, 0);
}
}
}
int ktha(int x, int k) {
if (x == 0) return 0;
if (lpci[x] + k < (int)pns[lpc[x]].size()) {
return pns[lpc[x]][lpci[x] + k];
} else {
return ktha(ac[x][loga[k]], logam[k]);
}
}
long long geth(int a, int b, int lc, int le) {
if (dd[a] - dd[lc] + 1 >= le) {
return subse(rnh[ktha(a, le)], rnh[a]).v;
} else {
h r = subse(rnh[lc], rnh[a]);
le -= dd[a] - dd[lc];
int lol = ktha(b, dd[b] - dd[lc] - le + 1);
r = add(r, subsa(nh[pp[lc]], nh[lol]));
return r.v;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
pot[0] = 1;
minv[0] = 1;
for (int i = 1; i <= 300010; i++) {
pot[i] = pot[i - 1] * k1;
pot[i] %= m1;
minv[i] = modpot(pot[i], m1 - 2, m1);
for (int ii = 0; ii < 20; ii++) {
if ((1 << ii) <= i) {
loga[i] = ii;
logam[i] = i - (1 << ii);
}
}
}
int n;
cin >> n;
cin >> nc;
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
g[a].push_back(b);
g[b].push_back(a);
}
nh[0] = {0, 0};
rnh[0] = {0, 0};
dfs1(1, 0, 1);
dfs2(1, 0, 0);
dfs3(1, 0, 0);
for (int i = 1; i < gci; i++) {
reverse(pns[i].begin(), pns[i].end());
for (int ii = 0; ii < (int)pns[i].size(); ii++) {
lpci[pns[i][ii]] = ii;
}
int x = pp[pns[i][pns[i].size() - 1]];
int lol = pns[i].size();
while (x != 0 && lol > 0) {
pns[i].push_back(x);
x = pp[x];
lol--;
}
}
int q;
cin >> q;
for (int i = 0; i < q; i++) {
int a, b, c, d;
cin >> a >> b >> c >> d;
int l1 = lca(a, b);
int l2 = lca(c, d);
int mi = 1;
int ma = min(dd[a] + dd[b] - 2 * dd[l1], dd[c] + dd[d] - 2 * dd[l2]) + 1;
while (mi <= ma) {
int m = (mi + ma) / 2;
if (geth(a, b, l1, m) == geth(c, d, l2, m)) {
mi = m + 1;
} else {
ma = m - 1;
}
}
cout << ma << '\n';
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int mo = 1e9 + 7, x[101000], n, L[101000], R[101000], f[101000], two[101000],
ten[101000], tot[101000], l[101000], r[101000], size[101000], w[101000];
char ch[101000];
int solve() {
int ans = 0;
size[n + 1] = 1;
int totnum = 0;
for (int i = n; i; i--)
if (x[i] == 4)
size[i] = size[i + 1];
else
size[i] = (two[n - i] + size[i + 1]) % mo;
w[n + 1] = 0;
for (int i = n; i; i--)
w[i] = (1ll * w[i + 1] + 1ll * x[i] * ten[n - i]) % mo;
if (x[n] == 7) ans = 28;
if (x[n] == 4)
totnum = 4;
else
totnum = 11;
for (int i = n - 1; i; i--) {
int num = ((1ll * totnum * 2 - l[n - i] - w[i + 1]) + mo) % mo;
if (x[i] == 4) {
ans = (ans +
1ll *
(1ll * (1ll * ten[n - i] * 4 % mo) *
(1ll * ten[n - i] * 4 % mo) % mo) *
(size[i + 1] - 1) % mo +
1ll * ten[n - i] * 4 % mo * num % mo) %
mo;
totnum = (totnum + 1ll * ten[n - i] * 4 % mo * size[i] % mo) % mo;
} else {
ans = (ans +
1ll *
(1ll * (1ll * ten[n - i] * 7 % mo) *
(1ll * ten[n - i] * 7 % mo) % mo) *
(size[i + 1] - 1) % mo +
1ll * ten[n - i] * 7 % mo * num % mo) %
mo;
num = ((1ll * 2 * tot[n - i] - l[n - i] - r[n - i]) % mo + mo) % mo;
ans = (ans +
1ll *
(1ll * (1ll * ten[n - i] * 4 % mo) *
(1ll * ten[n - i] * 4 % mo) % mo) *
(two[n - i] - 1) % mo +
1ll * ten[n - i] * 4 % mo * num % mo + f[n - i]) %
mo;
ans = (ans + 1ll * L[n - i + 1] * R[n - i + 1] % mo) % mo;
totnum = (totnum + 1ll * ten[n - i] * 7 % mo * size[i + 1] % mo) % mo;
totnum =
(totnum + tot[n - i] + 1ll * ten[n - i] * 4 % mo * two[n - i] % mo) %
mo;
}
}
return ans;
}
int main() {
scanf("%s", ch + 1);
n = strlen(ch + 1);
for (int i = 1; i <= n; i++) x[i] = ch[i] - '0';
L[1] = 4;
R[1] = 7;
for (int i = 2; i <= n; i++) {
L[i] = (1ll * L[i - 1] * 10 + 7) % mo;
R[i] = (1ll * R[i - 1] * 10 + 4) % mo;
}
for (int i = 1; i <= n; i++) l[i] = ch[i] - '0';
two[0] = 1;
for (int i = 1; i <= n; i++) two[i] = two[i - 1] * 2 % mo;
ten[0] = 1;
for (int i = 1; i <= n; i++) ten[i] = 1ll * ten[i - 1] * 10 % mo;
tot[1] = 11;
for (int i = 2; i <= n; i++)
tot[i] = (1ll * tot[i - 1] * 20 % mo + 1ll * 11 * two[i - 1]) % mo;
l[1] = 4;
r[1] = 7;
for (int i = 2; i <= n; i++) {
l[i] = (1ll * l[i - 1] * 10 + 4) % mo;
r[i] = (1ll * r[i - 1] * 10 + 7) % mo;
}
f[1] = 28;
for (int i = 2; i <= n; i++) {
f[i] = 1ll * L[i] * R[i] % mo;
long long num =
((1ll * 2 * tot[i - 1] - l[i - 1] - r[i - 1]) % mo + mo) % mo;
f[i] = (f[i] +
1ll *
(1ll * (1ll * ten[i - 1] * 7 % mo) *
(1ll * ten[i - 1] * 7 % mo) % mo) *
(two[i - 1] - 1) % mo +
1ll * ten[i - 1] * 7 % mo * num + f[i - 1]) %
mo;
f[i] = (f[i] +
1ll *
(1ll * (1ll * ten[i - 1] * 4 % mo) *
(1ll * ten[i - 1] * 4 % mo) % mo) *
(two[i - 1] - 1) % mo +
1ll * ten[i - 1] * 4 % mo * num + f[i - 1]) %
mo;
}
long long ans = solve();
scanf("%s", ch + 1);
for (int i = 1; i <= n; i++) x[i] = ch[i] - '0';
ans = (solve() - ans + mo) % mo;
cout << ans << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
const long long K = 1e6 + 100;
const long long MOD = 1e9 + 7;
long long n, k;
long long pre[K];
long long suf[K];
long long fac[K];
long long inv[K];
long long pow(long long x, long long k) {
if (x == 0) return 0;
long long res = 1;
while (k) {
if (k & 1) res *= x, res %= MOD;
x *= x, x %= MOD;
k >>= 1;
}
return res;
}
signed main() {
scanf("%lld%lld", &n, &k);
pre[0] = n - k - 1, suf[k + 1] = n, inv[0] = inv[1] = 1, fac[0] = 1;
for (long long i = 1; i <= k + 1; ++i)
pre[i] = pre[i - 1] * (n - k - 1 + i), pre[i] %= MOD;
for (long long i = k; i >= 0; --i)
suf[i] = suf[i + 1] * (n - k - 1 + i), suf[i] %= MOD;
for (long long i = 2; i <= k + 1; ++i)
inv[i] = (MOD - MOD / i) * inv[MOD % i] % MOD;
for (long long i = 1; i <= k + 1; ++i) fac[i] = inv[i] * fac[i - 1] % MOD;
long long f = 0, ans = 0;
for (long long i = 0; i <= k + 1; ++i) {
f += pow(i, k), f %= MOD;
long long add;
if (i == 0)
add = f * pre[k - 1] % MOD;
else if (i == k + 1)
add = f * suf[1] % MOD;
else
add = f * suf[k + 1 - i + 1] % MOD * pre[k + 1 - i - 1] % MOD;
ans +=
add * ((k + 1 - i) & 1 ? -1 : 1) * fac[i] % MOD * fac[k + 1 - i] % MOD,
ans %= MOD;
}
printf("%lld", (ans % MOD + MOD) % MOD);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int a[300];
int main() {
int n, i, ans;
while (scanf("%d", &n) != EOF) {
ans = 0;
int f = 0;
for (i = 0; i < 2 * n - 1; i++) {
scanf("%d", &a[i]);
if (a[i] < 0) {
f++;
}
}
sort(a, a + 2 * n - 1);
a[2 * n - 1] = 1;
if (f % 2) {
if (n % 2) {
for (i = 0; i < 2 * n - 1; i++) {
if (a[i] < 0) {
ans -= a[i];
} else {
ans += a[i];
}
}
} else {
for (i = 0; i < 2 * n - 1; i++) {
if (a[i] < 0) {
ans -= a[i];
a[i] = -a[i];
} else {
ans += a[i];
}
}
sort(a, a + 2 * n - 1);
ans -= 2 * a[0];
}
} else {
for (i = 0; i < 2 * n - 1; i++) {
if (a[i] < 0) {
ans -= a[i];
} else {
ans += a[i];
}
}
}
printf("%d\n", ans);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long INFLL = 1e18;
const int MOD = 998244353;
const int MAXN = 2e5 + 5;
long long dp[MAXN][11];
int n;
vector<int> g[MAXN];
int dfs(int v, int d, int p) {
if (dp[v][d] != -1) return dp[v][d];
int r = INF;
if (d == 0) {
r = 0;
for (int u : g[v]) {
if (u != p) {
r += dfs(u, 1, v);
}
}
return dp[v][d] = r;
}
if (d == 1) {
r = 0;
for (int u : g[v]) {
if (u != p) {
r += dfs(u, 2, v);
}
}
return dp[v][d] = r;
}
if (d == 2) {
r = dfs(v, 1, p) + 1;
int sum = 0;
for (int u : g[v]) {
if (u != p) sum += dfs(u, 3, v);
}
r = min(r, sum);
return dp[v][d] = r;
}
if (d == 3) {
r = min(r, dfs(v, 1, p) + 1);
int sum = 0;
for (int u : g[v]) {
if (u != p) {
sum += dfs(u, 3, v);
}
}
for (int u : g[v]) {
if (u != p) {
r = min(r, dfs(u, 1, v) + 1 + sum - dfs(u, 3, v));
}
}
return dp[v][d] = r;
}
return 0;
}
int main() {
scanf("%d", &n);
int a, b;
for (int i = 0; i < n - 1; i++) {
scanf("%d %d", &a, &b);
a--;
b--;
g[a].push_back(b);
g[b].push_back(a);
}
memset(dp, -1, sizeof(dp));
printf("%d\n", dfs(0, 0, 0));
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
inline void read(register int *n) {
register char c;
*n = 0;
do {
c = getchar();
} while (c < '0' || c > '9');
do {
*n = c - '0' + *n * 10;
c = getchar();
} while (c >= '0' && c <= '9');
}
vector<int> kperm(vector<int> V, long long k) {
k--;
vector<int> res;
long long fac[20] = {1};
for (register int i = (1); i < (20); ++i) fac[i] = i * fac[i - 1];
if (k >= fac[((int)(V).size())]) {
cout << -1 << "\n";
exit(0);
}
while (!V.empty()) {
long long f = fac[((int)(V).size()) - 1];
res.push_back(V[k / f]);
V.erase(V.begin() + k / f);
k %= f;
}
return res;
}
vector<long long> V;
void gen(long long x) {
if (x > 0) V.push_back(x);
if (x > 1000LL * 1000 * 1000 * 100) return;
gen(x * 10 + 7);
gen(x * 10 + 4);
}
bool islucky(int x) {
while (x % 10 == 7 || x % 10 == 4) x /= 10;
return x == 0;
}
int main(int argv, char **argc) {
gen(0);
long long n, k, m;
cin >> n >> k;
m = min(16LL, n);
vector<int> tmp;
for (register int i = (0); i < (m); ++i) tmp.push_back(n - i);
sort((tmp).begin(), (tmp).end());
int cnt = 0;
for (register int i = (0); i < (((int)(V).size())); ++i)
if (V[i] <= n - 16) cnt++;
tmp = kperm(tmp, k);
for (register int i = (0); i < (m); ++i)
if (islucky(tmp[((int)(tmp).size()) - 1 - i]) && islucky(n - i)) cnt++;
cout << cnt << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
char memo[503][503][503];
int c[503], n;
char DP(int pos, int c1, int c2) {
if (pos == n) return c1 == 0 && c2 == 0;
char &ret = memo[pos][c1][c2];
if (ret != -1) return ret;
char ans = DP(pos + 1, c1, c2);
if (c[pos] <= c1) ans = max(ans, DP(pos + 1, c1 - c[pos], c2));
if (c[pos] <= c2) ans = max(ans, DP(pos + 1, c1, c2 - c[pos]));
return ret = ans;
}
int main() {
int k;
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) scanf("%d", &c[i]);
memset(memo, -1, sizeof memo);
vector<int> ans;
for (int i = 0; i <= k; i++)
if (DP(0, i, k - i)) ans.push_back(i);
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++) {
if (i) printf(" ");
printf("%d", ans[i]);
}
puts("");
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a[200010], n;
scanf("%d", &n);
stack<int> s;
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (!s.empty() && abs(s.top() - a[i]) % 2 == 0)
s.pop();
else
s.push(a[i]);
}
if (s.size() <= 1)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long int MOD = 1e9 + 7;
long long int INF = 1e18;
long long int power(long long int base, long long int exp) {
long long int res = 1;
while (exp > 0) {
if (exp % 2 == 1) res = (res * base);
base = (base * base);
exp /= 2;
}
return res;
}
long long int bitc(long long int n, long long int x) { return ((n >> x) & 1); }
long long int __gcd(long long int a, long long int b) {
return b == 0 ? a : __gcd(b, a % b);
}
long long int fsub(long long int a, long long int b, long long int p = MOD) {
return ((a % p) - (b % p) + p) % p;
}
long long int fmult(long long int a, long long int b, long long int p = MOD) {
return ((a % p) * (b % p)) % p;
}
long long int fadd(long long int a, long long int b, long long int p = MOD) {
return (a % p + b % p) % p;
}
long long int fpow(long long int n, long long int k, long long int p = MOD) {
long long int r = 1;
while (k > 0) {
if (k & 1) r = r * n % p;
n = n * n % p;
k = k >> 1;
}
return r;
}
long long int inv(long long int a, long long int p = MOD) {
return fpow(a, p - 2, p);
}
long long int fdiv(long long int a, long long int b, long long int p = MOD) {
long long int yinv = inv(b);
long long int ans = (a * yinv) % p;
return ans;
}
template <typename T>
istream &operator>>(istream &in, vector<T> &a) {
for (auto &item : a) {
in >> item;
}
return in;
}
template <typename T, typename U>
ostream &operator<<(ostream &out, pair<T, U> &a) {
cout << a.first << " " << a.second;
return out;
}
template <typename T, typename U>
istream &operator>>(istream &out, pair<T, U> &a) {
cin >> a.first >> a.second;
return out;
}
template <typename T, typename U>
ostream &operator<<(ostream &out, map<T, U> &a) {
for (auto &item : a) {
out << item << "\n";
}
return out;
}
template <typename T>
ostream &operator<<(ostream &out, vector<T> &a) {
for (auto &item : a) {
out << item << " ";
}
return out;
}
template <typename T>
ostream &operator<<(ostream &out, vector<vector<T>> &a) {
for (auto &item : a) {
out << item << "\n";
}
return out;
}
template <int D, typename T>
struct Vec : public vector<Vec<D - 1, T>> {
static_assert(D >= 1, "Vector dimension must be greater than zero!");
template <typename... Args>
Vec(int n = 0, Args... args)
: vector<Vec<D - 1, T>>(n, Vec<D - 1, T>(args...)) {}
};
template <typename T>
struct Vec<1, T> : public vector<T> {
Vec(int n = 0, T val = T()) : vector<T>(n, val) {}
};
std::vector<bool> is_prime;
std::vector<long long int> primes;
void sieve(long long int n) {
is_prime.resize(n + 2, true);
primes.clear();
long long int p;
for (p = 2; p * p <= n; p++) {
if (is_prime[p]) {
long long int i;
for (i = p * p; i <= n; i += p) {
is_prime[i] = false;
}
}
}
is_prime[0] = is_prime[1] = false;
long long int i;
for (i = 2; i <= n; i++) {
if (is_prime[i]) {
primes.emplace_back(i);
}
}
}
map<long long int, long long int> prime_factors(long long int n) {
map<long long int, long long int> s;
long long int i;
long long int tc = 0;
while (n % 2 == 0) {
tc++;
n /= 2;
}
if (tc > 0) {
s[2] = tc;
}
for (i = 3; i <= sqrt(n); i += 2) {
tc = 0;
while (n % i == 0) {
tc++;
n /= i;
}
if (tc > 0) {
s[i] = tc;
}
}
if (n > 2) {
s[n] += 1;
}
return s;
}
std::vector<long long int> fact_vec;
void fact_fun(long long int n) {
fact_vec.resize(n + 10);
long long int i;
fact_vec[0] = 1;
for (i = 1; i <= n + 2; i++) {
fact_vec[i] = (fact_vec[i - 1] * i) % MOD;
}
}
std::vector<long long int> p2;
void power_2(long long int n, long long int m = MOD) {
long long int i;
MOD = m;
p2.emplace_back(1);
for (i = 0; i < n; i++) {
p2.emplace_back(fmult(p2.back(), 2));
}
}
long long int ncr(long long int n, long long int r) {
if (r > n) return 0;
return fdiv(fact_vec[n], fmult(fact_vec[r], fact_vec[n - r]));
}
std::vector<long long int> spf;
void sieve2(long long int MAXN) {
MAXN += 10;
spf.resize(MAXN, 0);
spf[1] = 1;
for (long long int i = 2; i < MAXN; i++) spf[i] = i;
for (long long int i = 4; i < MAXN; i += 2) spf[i] = 2;
for (long long int i = 3; i * i < MAXN; i++) {
if (spf[i] == i) {
for (long long int j = i * i; j < MAXN; j += i) {
if (spf[j] == j) spf[j] = i;
}
}
}
}
map<long long int, long long int> getFactorization(long long int x) {
map<long long int, long long int> ret;
while (x != 1) {
ret[spf[x]]++;
x = x / spf[x];
}
return ret;
}
long long int N = 7010;
Vec<2, long long int> dp(3, N, -1);
Vec<2, long long int> wn(3, N);
int main() {
long long int i, j;
ios::sync_with_stdio(false);
cin.tie(0);
long long int ti;
ti = 1;
while (ti--) {
long long int n;
cin >> n;
std::vector<long long int> k(2);
cin >> k[0];
Vec<2, long long int> a(2);
a[0].resize(k[0]);
cin >> a[0];
cin >> k[1];
a[1].resize(k[1]);
cin >> a[1];
for (i = 1; i < n; i++) {
wn[0][i] = k[0];
wn[1][i] = k[1];
}
dp[0][0] = 0;
dp[1][0] = 0;
queue<pair<long long int, long long int>> q;
q.push(make_pair(0, 0));
q.push(make_pair(1, 0));
while (!q.empty()) {
long long int u = q.front().first;
long long int v = q.front().second;
q.pop();
if (dp[u][v] == 0) {
for (j = 0; j < k[!u]; j++) {
long long int uu = !u;
long long int vv = fsub(v, a[uu][j], n);
if (dp[uu][vv] == -1) {
dp[uu][vv] = 1;
q.push(make_pair(uu, vv));
}
}
} else {
for (j = 0; j < k[!u]; j++) {
long long int uu = !u;
long long int vv = fsub(v, a[uu][j], n);
--wn[uu][vv];
if (dp[uu][vv] == -1 && wn[uu][vv] == 0) {
dp[uu][vv] = 0;
q.push(make_pair(uu, vv));
}
}
}
}
for (i = 0; i < 2; i++) {
for (j = 1; j < n; j++) {
if (dp[i][j] == -1) {
cout << "Loop"
<< " ";
} else if (dp[i][j]) {
cout << "Win"
<< " ";
} else {
cout << "Lose"
<< " ";
}
}
cout << "\n";
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = (int)1e6 + 10;
int a, b;
int f[maxN];
int ans[maxN];
int to[maxN];
vector<int> v;
int n;
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
v.resize(n);
for (int i = 0; i < n; i++) cin >> v[i];
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
cin >> a >> b;
for (int i = b + 1; i <= a; i++) f[i - b] = i - 1;
for (int i = 0; i < v.size(); i++) {
if ((a - a % v[i]) >= b) f[a - b] = min(f[a - b], a - a % v[i]);
int st = v[i] * ((b + v[i] - 1) / v[i]);
if (st > a) continue;
st += v[i] - 1;
if (st > a) continue;
for (int j = st; j <= a; j += v[i])
f[j - b] = min(f[j - b], j - (v[i] - 1));
}
ans[0] = 0;
int t = 2 * (int)1e9;
for (int i = a; i >= b + 1; i--) {
t = min(t, f[i - b]);
to[i - b] = t;
}
int k = 0;
while (a > b) {
k++;
a = to[a - b];
}
cout << k;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = (2e5 + 10);
char s[2][N];
struct node {
int l, r;
int val[4];
} t[N * 4];
void pushup2(node &u, node &l, node &r) {
u.val[0] = min({u.val[0], l.val[0] + r.val[0], l.val[1] + r.val[2]});
u.val[1] = min({u.val[1], l.val[0] + r.val[1], l.val[1] + r.val[3]});
u.val[2] = min({u.val[2], l.val[2] + r.val[0], l.val[3] + r.val[2]});
u.val[3] = min({u.val[3], l.val[2] + r.val[1], l.val[3] + r.val[3]});
}
void pushup(int x) {
auto &u = t[x], &l = t[x << 1], &r = t[x << 1 | 1];
pushup2(u, l, r);
}
void build(int u, int l, int r) {
t[u].l = l, t[u].r = r;
memset(t[u].val, 0x3f, sizeof t[u].val);
if (l == r) {
if (s[0][l] == '.') t[u].val[0] = 1;
if (s[1][l] == '.') t[u].val[3] = 1;
if (s[0][l] == '.' && s[1][l] == '.') t[u].val[1] = t[u].val[2] = 2;
return;
} else {
int mid = l + r >> 1;
build(u << 1, l, mid);
build(u << 1 | 1, mid + 1, r);
pushup(u);
}
}
node que(int u, int l, int r) {
if (t[u].l >= l && t[u].r <= r) return t[u];
int mid = t[u].l + t[u].r >> 1;
if (r <= mid)
return que(u << 1, l, r);
else if (l > mid)
return que(u << 1 | 1, l, r);
else {
auto lc = que(u << 1, l, r), rc = que(u << 1 | 1, l, r);
node res;
memset(res.val, 0x3f, sizeof res.val);
pushup2(res, lc, rc);
return res;
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
int n, m;
cin >> n >> m;
cin >> s[0] + 1 >> s[1] + 1;
build(1, 1, n);
while (m--) {
int l, r;
cin >> l >> r;
int beg = (l - 1) % n + 1, ed = (r - 1) % n + 1;
if (beg > ed) {
swap(beg, ed);
swap(l, r);
}
auto res = que(1, beg, ed);
bool flag = false;
if (l <= n && r <= n && res.val[0] < 0x3f3f3f3f)
flag = true, cout << res.val[0] - 1 << "\n";
else if (l <= n && r > n && res.val[1] < 0x3f3f3f3f)
flag = true, cout << res.val[1] - 1 << "\n";
else if (l > n && r <= n && res.val[2] < 0x3f3f3f3f)
flag = true, cout << res.val[2] - 1 << "\n";
else if (l > n && r > n && res.val[3] < 0x3f3f3f3f)
flag = true, cout << res.val[3] - 1 << "\n";
if (!flag) cout << -1 << "\n";
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, U b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, U b) {
if (a < b) a = b;
}
struct point {
double first, second;
point(double first = 0, double second = 0) : first(first), second(second) {}
point operator-(point a) { return point(first - a.first, second - a.second); }
double operator^(point a) { return first * a.second - second * a.first; }
double operator*(point a) { return first * a.first + second * a.second; }
double nor() { return sqrt(*this * *this); }
void input() { scanf("%lf %lf", &first, &second); }
void print() { printf("%lf %lf\n", first, second); }
};
const double pi = acos(-1);
int intersect(point a, point b, double r) {
double ab = (a - b).nor(), aa = a.nor(), bb = b.nor();
double mid = min(aa, bb);
if (aa * aa < bb * bb + ab * ab && bb * bb < aa * aa + ab * ab)
smin(mid, fabs(a ^ b) / ab);
return mid < r - 1e-10;
}
void tangent_of_circle(double r, point a, double *al) {
double be = acos(r / a.nor());
al[0] = atan2(a.second, a.first) - be;
al[1] = atan2(a.second, a.first) + be;
}
double calc(point a, double al, point b, double be, double r) {
point c = point(cos(al) * r, sin(al) * r);
point d = point(cos(be) * r, sin(be) * r);
if (intersect(a, c, r)) return 1e200;
if (intersect(b, d, r)) return 1e200;
double ans = (a - c).nor() + (b - d).nor();
double mid = fabs(al - be);
smin(mid, 2 * pi - mid);
return ans + mid * r;
}
point a, b;
double vp, v, r, R, al, be;
int can(double t) {
point c = point(cos(al * t + be) * R, sin(al * t + be) * R);
if (!intersect(b, c, r)) return (b - c).nor() / v < t + 1e-10;
double tb[4], tc[4];
tangent_of_circle(r, b, tb);
tangent_of_circle(r, c, tc);
double mid = 1e200;
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++) {
smin(mid, calc(b, tb[i], c, tc[j], r));
}
return mid / v < t + 1e-10;
}
int main() {
a.input();
scanf("%lf", &vp);
b.input();
scanf("%lf%lf", &v, &r);
R = a.nor();
al = vp / R, be = atan2(a.second, a.first);
double st = 0, ed = 1e10;
for (int i = 0; i < 100; i++) {
double mid = (st + ed) / 2;
if (can(mid))
ed = mid;
else
st = mid;
}
printf("%.10lf\n", ed);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100 * 1000 + 17;
int a[MAXN], m, lazy[MAXN << 2], seg[MAXN << 2];
void relax(int v) {
seg[v << 1] += lazy[v];
seg[v << 1 | 1] += lazy[v];
lazy[v << 1] += lazy[v];
lazy[v << 1 | 1] += lazy[v];
lazy[v] = 0;
}
void add(int lp, int rp, int val, int v = 1, int l = 1, int r = m + 1) {
if (rp <= l || r <= lp) return;
if (lp <= l && r <= rp) {
seg[v] += val;
lazy[v] += val;
return;
}
relax(v);
add(lp, rp, val, v << 1, l, l + r >> 1);
add(lp, rp, val, v << 1 | 1, l + r >> 1, r);
seg[v] = max(seg[v << 1], seg[v << 1 | 1]);
}
int get(int v = 1, int l = 1, int r = m + 1) {
if (l + 1 == r) return l;
relax(v);
if (seg[v << 1 | 1] > 0)
return get(v << 1 | 1, l + r >> 1, r);
else
return get(v << 1, l, l + r >> 1);
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> m;
for (int i = 1; i <= m; i++) {
int p, t, x;
cin >> p >> t;
if (t == 0)
add(1, p + 1, -1);
else {
cin >> x;
add(1, p + 1, 1);
a[p] = x;
}
if (seg[1] <= 0)
cout << -1 << endl;
else
cout << a[get()] << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 12;
const long long INF = 1e18, mod = 1e9 + 7;
int n, h[N], in[N], out[N], was[N];
long long t[N], ans, dp1[N], dp2[N];
vector<int> g[N];
void dfs(int v, int pr) {
was[v] = 1;
vector<long long> dif;
long long sum = 0;
for (int to : g[v]) {
if (to != pr) {
dfs(to, v);
sum += dp1[to];
dif.push_back(dp2[to] - dp1[to]);
}
}
sort(dif.begin(), dif.end(), [](long long x, long long y) { return x > y; });
int len = dif.size();
dp1[v] = max(dp1[v], min(in[v] + (pr != -1), out[v] + len) * t[v] + sum);
dp2[v] = max(dp2[v], min(in[v], out[v] + len + (pr != -1)) * t[v] + sum);
long long pref = 0;
for (int i = 1; i <= len; i++) {
pref += dif[i - 1];
dp1[v] = max(dp1[v], min(in[v] + (pr != -1) + i, out[v] + len - i) * t[v] +
pref + sum);
dp2[v] = max(dp2[v], min(in[v] + i, out[v] + len - i + (pr != -1)) * t[v] +
pref + sum);
}
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) cin >> t[i];
for (int i = 1; i <= n; i++) cin >> h[i];
for (int i = 1, x, y; i < n; i++) {
cin >> x >> y;
ans += t[x] + t[y];
if (h[x] == h[y])
g[x].push_back(y), g[y].push_back(x);
else {
if (h[x] < h[y])
out[x]++, in[y]++;
else
in[x]++, out[y]++;
}
}
for (int i = 1; i <= n; i++) {
if (!was[i]) {
dfs(i, -1);
ans -= dp1[i];
}
}
cout << ans;
}
| 10 |
#include <bits/stdc++.h>
const int mod = 1e9 + 7;
using namespace std;
long long POW(long long bs, long long ex) {
long long res = 1;
while (ex) {
if (ex % 2) res = (res * bs) % mod;
bs = (bs * bs) % mod;
ex /= 2LL;
}
return res % mod;
}
long long GS(long long r, long long n) {
if (r == 1) return n % mod;
return (POW(r, n) - 1) * POW(r - 1, mod - 2) % mod;
}
int main() {
long long a, b, n, x;
cin >> a >> b >> n >> x;
cout << (POW(a, n) * x + b * GS(a, n)) % mod;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T nextInt() {
T x = 0, p = 1;
char ch;
do {
ch = getchar();
} while (ch <= ' ');
if (ch == '-') {
p = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + (ch - '0');
ch = getchar();
}
return x * p;
}
const int maxN = (int)5e2 + 10;
const int maxS = (int)2.5e5 + 10;
const int INF = (int)1e9 + 5;
const int mod = (int)1e9 + 7;
const long long LLINF = (long long)4e18 + 5;
int n, k;
char s[maxN][maxN];
int comps;
int comp[maxN][maxN];
int sz[maxS];
int qx[maxS];
int qy[maxS];
int qs, qf;
void add(int x, int y) {
comp[x][y] = comps;
++sz[comps];
qx[qf] = x;
qy[qf++] = y;
}
bool in(int x, int y) { return 1 <= x && x <= n && 1 <= y && y <= n; }
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
void bfs(int x, int y) {
qs = qf = 0;
add(x, y);
while (qs < qf) {
x = qx[qs];
y = qy[qs++];
for (int k = 0; k < 4; ++k) {
int nx = x + dx[k];
int ny = y + dy[k];
if (in(nx, ny) && s[nx][ny] == '.' && comp[nx][ny] == 0) {
add(nx, ny);
}
}
}
}
int last[maxS];
int have[maxS];
int cursum;
int occup;
void init() {
memset(have, 0, sizeof have);
memset(last, -1, sizeof last);
cursum = 0;
occup = 0;
}
void add(int &v, int s, int d) {
if (v == 0 && d == 1) {
cursum += s;
}
if (v == 1 && d == -1) {
cursum -= s;
}
v += d;
}
void process(int j, int l, int r, int d) {
for (int i = l; i <= r; ++i) {
if (s[i][j] == 'X') {
occup += d;
}
int x = comp[i][j];
add(have[x], sz[x], d);
}
}
int calc(int u, int d, int l, int r) {
static int iter = 0;
iter++;
int extra = 0;
for (int j = l; j <= r; ++j) {
{
int x = comp[u - 1][j];
if (have[x] == 0) {
if (last[x] != iter) {
extra += sz[x];
last[x] = iter;
}
}
}
{
int x = comp[d + 1][j];
if (have[x] == 0) {
if (last[x] != iter) {
extra += sz[x];
last[x] = iter;
}
}
}
}
for (int i = u; i <= d; ++i) {
{
int x = comp[i][l - 1];
if (have[x] == 0) {
if (last[x] != iter) {
extra += sz[x];
last[x] = iter;
}
}
}
{
int x = comp[i][r + 1];
if (have[x] == 0) {
if (last[x] != iter) {
extra += sz[x];
last[x] = iter;
}
}
}
}
return cursum + extra + occup;
}
int main() {
n = nextInt<int>();
k = nextInt<int>();
for (int i = 1; i <= n; ++i) {
gets(s[i] + 1);
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
if (comp[i][j] == 0 && s[i][j] == '.') {
++comps;
bfs(i, j);
}
}
}
int res = 0;
for (int i = 1; i + k - 1 <= n; ++i) {
init();
int up = i;
int down = i + k - 1;
int l = 1, r = 0;
for (int j = 1; j + k - 1 <= n; ++j) {
int le = j;
int ri = j + k - 1;
while (l < le) {
process(l, up, down, -1);
l++;
}
while (r < ri) {
++r;
process(r, up, down, +1);
}
res = max(res, calc(up, down, le, ri));
}
}
printf("%d\n", res);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100100;
int n, m;
vector<vector<int> > A, sol;
inline int num(int i, int j) { return i * m + j + 1; }
void load() { scanf("%d%d", &n, &m); }
void transpose(vector<vector<int> > &X) {
vector<vector<int> > B;
for (int i = 0; i < m; i++) {
vector<int> vi;
for (int j = 0; j < n; j++) vi.push_back(X[j][i]);
B.push_back(vi);
}
X = B;
}
vector<int> perm(vector<int> a, vector<int> p) {
vector<int> ret(m, 0);
for (int i = 0; i < m; i++) ret[p[i]] = a[i];
return ret;
}
bool solve() {
if (n == m && n == 1) {
printf("YES\n1\n");
return true;
}
if (max(n, m) == 3) {
if (n == m) {
printf("YES\n");
printf("9 7 6\n5 3 4\n1 8 2\n");
return true;
} else
return false;
}
if (max(n, m) < 3) return false;
for (int i = 0; i < n; i++) {
vector<int> vi;
for (int j = 0; j < m; j++) {
vi.push_back(num(i, j));
}
A.push_back(vi);
}
bool bl = false;
if (n > m) {
transpose(A);
bl = true;
swap(n, m);
}
if (m == 4) {
int fir[] = {1, 3, 0, 2};
int sec[] = {2, 0, 3, 1};
vector<int> p1(fir, fir + sizeof(fir) / sizeof(int));
vector<int> p2(sec, sec + sizeof(sec) / sizeof(int));
for (int i = 0; i < n; i++) {
if (i & 1) {
sol.push_back(perm(A[i], p1));
} else
sol.push_back(perm(A[i], p2));
}
} else {
vector<int> p;
int pot = (m + 1) / 2;
for (int i = 0; i < m; i++) {
int koji = i / 2;
if (i & 1) koji += pot;
p.push_back(koji);
}
for (int i = 0; i < n; i++) {
sol.push_back(perm(A[i], p));
vector<int> p_(m, 0);
for (int j = 0; j < m; j++) p_[(j + 1) % m] = p[j];
p = p_;
}
}
if (bl) {
transpose(sol);
swap(n, m);
}
printf("YES\n");
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) printf("%d ", sol[i][j]);
printf("\n");
}
return true;
}
int main() {
load();
if (!solve()) printf("NO\n");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
int n, m, a[maxn], b[maxn];
bool pan(long long x) {
for (int i = 1; i <= n; i++) b[i] = a[i];
int pos = n;
for (int i = 1; i <= m; i++) {
long long t = x;
while (!b[pos] && pos) pos--;
if (!pos) return true;
t -= pos;
if (t < 0) return false;
while (t >= 0) {
if (b[pos] > t) {
b[pos] -= t;
break;
}
t -= b[pos];
b[pos] = 0;
while (!b[pos] && pos) pos--;
if (!pos) return true;
}
}
while (!b[pos] && pos) pos--;
return !pos;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
long long l = 0, r = 0x3f3f3f3f3f3f3f3f;
while (l < r) {
long long mid = (l + r) >> 1;
if (pan(mid))
r = mid;
else
l = mid + 1;
}
cout << l << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long sum = 0, cur = 0, x;
cin >> x;
int* y = new int[x];
for (int i = 0; i < x; i++) {
cin >> y[i];
sum += y[i];
}
for (int i = 0; i < x; i++) {
cur += y[i];
if (sum <= cur * 2) {
cout << i + 1 << '\n';
return 0;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m, h;
int bb[109][109][109];
int a[109], b[109], c[109][109];
int main() {
scanf("%d%d%d", &n, &m, &h);
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
for (int k = 1; k <= h; k++) {
bb[i][j][k] = 1;
}
}
}
for (int i = 1; i <= m; i++) {
scanf("%d", &a[i]);
for (int j = 1; j <= n; j++) {
for (int k = a[i] + 1; k <= h; k++) {
bb[i][j][k] = 0;
}
}
}
for (int j = 1; j <= n; j++) {
scanf("%d", &b[j]);
for (int i = 1; i <= m; i++) {
for (int k = b[j] + 1; k <= h; k++) {
bb[i][j][k] = 0;
}
}
}
for (int j = 1; j <= n; j++) {
for (int i = 1; i <= m; i++) {
scanf("%d", &c[i][j]);
if (c[i][j] == 0) {
for (int k = 1; k <= h; k++) bb[i][j][k] = 0;
}
}
}
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
for (int k = 2; k <= h; k++) {
if (bb[i][j][k]) bb[i][j][1]++;
}
}
}
for (int j = 1; j <= n; j++) {
for (int i = 1; i <= m; i++) {
printf("%d ", bb[i][j][1]);
}
printf("\n");
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n;
int lista[507];
int main() {
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> lista[i];
}
bool flag = false;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
for (int k = 0; k < n; ++k) {
int t[3] = {lista[i], lista[j], lista[k]};
sort(t, t + 3);
if (lista[i] != lista[j] && lista[j] != lista[k] &&
lista[i] != lista[k]) {
if (t[2] - t[0] <= 2) flag = true;
}
}
}
}
cout << (flag ? "YES" : "NO");
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int g[65]{0, 1, 1, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5,
6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8,
8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10, 10, 10};
const int MAXN = 1000007;
int s[MAXN];
map<pair<int, long long>, int> dp;
int grundy(pair<int, long long> s) {
if (dp.find(s) != dp.end()) return dp[s];
long long mask = s.second;
int &res = dp[s];
set<int> S;
for (int i = 1; i <= 60; i++) {
if (!(mask & (1ll << i)) && s.first >= i) {
S.insert(grundy(make_pair(s.first - i, (mask | (1ll << i)))));
}
}
while (S.count(res) > 0) res++;
return res;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &s[i]);
}
if (n == 1)
printf("NO\n");
else {
int XOR = 0;
for (int i = 0; i < n; i++) {
XOR ^= grundy(make_pair(s[i], 0));
}
if (XOR == 0)
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void solve() { return; }
int main() {
int q;
cin >> q;
for (int i = 0; i < q; i++) {
long long n, k;
cin >> n;
int a[2 * n];
map<int, int> pos;
for (int i = 0; i < 2 * n; i++) {
cin >> a[i];
pos[a[i]] = i;
}
long long val, prev = 2 * n;
vector<int> v;
for (int i = 2 * n; i > 0; i--) {
if (prev > pos[i]) {
val = prev - pos[i];
prev = pos[i];
v.push_back(val);
}
}
map<int, bool> occ;
occ[0] = true;
for (auto j : v) {
vector<int> temp;
for (int i = 0; i < n; i++) {
if (occ[i]) {
temp.push_back(i + j);
}
}
for (auto i : temp) occ[i] = true;
}
if (occ[n] == true)
cout << "YES";
else
cout << "NO";
cout << "\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, p = "";
int n, k;
cin >> n >> k >> s;
for (int i = 0; i < k; i++) {
char c;
cin >> c;
p += c;
}
long long ans = 0;
int len = 0;
for (int i = 0; s[i]; i++) {
if (strchr(p.c_str(), s[i])) {
len++;
} else {
ans += 1LL * len * (len + 1) / 2;
len = 0;
}
}
ans += 1LL * len * (len + 1) / 2;
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long n, m;
vector<vector<long long>> g;
vector<vector<pair<long long, long long>>> dp;
pair<long long, long long> add(pair<long long, long long> a,
pair<long long, long long> b) {
return {a.first + b.first, a.second + b.second};
}
vector<pair<long long, long long>> merge(
vector<pair<long long, long long>> &a,
vector<pair<long long, long long>> &b) {
vector<pair<long long, long long>> ret(
min((long long)(a.size() + b.size()), m), {-1, 0});
for (long long i = 0; i < (long long)a.size(); ++i) {
for (long long j = 0; j < (long long)b.size() && i + j < m; ++j) {
ret[i + j] = max(ret[i + j], add(a[i], b[j]));
if (i + j + 1 < m)
ret[i + j + 1] =
max(ret[i + j + 1], add(a[i], {b[j].first + (b[j].second > 0), 0}));
}
}
return ret;
}
void dfs(long long x, long long par = 0) {
for (auto v : g[x]) {
if (v == par) continue;
dfs(v, x);
dp[x] = merge(dp[x], dp[v]);
}
}
int32_t main() {
ios::sync_with_stdio(0);
cout.tie(0);
cin.tie(0);
long long tc;
cin >> tc;
while (tc--) {
cin >> n >> m;
g.assign(n, vector<long long>());
dp.assign(n, vector<pair<long long, long long>>());
for (long long i = 0; i < n; ++i) {
long long b;
cin >> b;
dp[i].emplace_back(0, -b);
}
for (long long i = 0; i < n; ++i) {
long long w;
cin >> w;
dp[i][0].second += w;
}
for (long long i = 1; i < n; ++i) {
long long u, v;
cin >> u >> v;
--u;
--v;
g[u].push_back(v);
g[v].push_back(u);
}
dfs(0);
if (dp[0][m - 1].second > 0) dp[0][m - 1].first++;
cout << dp[0][m - 1].first << '\n';
}
}
| 8 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define endl '\n';
const ll nmax = 1000000007;
int main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);cout.tie(NULL);
ll t;
cin >> t;
while(t--){
ll n, a, b;
cin >> n >> a >> b;
string s;
cin >> s;
ll chunks = 1, ans = a*n;
for(ll i=1; i<n; i++){
if(s[i] != s[i-1]){
chunks++;
}
}
ans += max(n*b, ((chunks+2)/2)*b);
cout << ans << endl;
}
return 0;
} | 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.