solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 5;
int n, a[maxn];
unsigned long long qp[maxn], sum1[maxn << 2], sum2[maxn << 2];
void Init() {
qp[0] = 1;
for (int i = 1; i <= n; ++i) qp[i] = qp[i - 1] * 233;
}
void pushup(int rt, int l, int r) {
int mid = l + r >> 1;
sum1[rt] = sum1[rt << 1] * qp[r - mid] + sum1[rt << 1 | 1];
sum2[rt] = sum2[rt << 1 | 1] * qp[mid - l + 1] + sum2[rt << 1];
}
void build(int rt, int l, int r) {
if (l == r) {
sum1[rt] = sum2[rt] = 3;
return;
}
int mid = l + r >> 1;
build(rt << 1, l, mid);
build(rt << 1 | 1, mid + 1, r);
pushup(rt, l, r);
}
void update(int rt, int l, int r, int p) {
if (l == r) {
sum1[rt] = sum2[rt] = 5;
return;
}
int mid = l + r >> 1;
if (p <= mid)
update(rt << 1, l, mid, p);
else
update(rt << 1 | 1, mid + 1, r, p);
pushup(rt, l, r);
}
unsigned long long query1(int rt, int l, int r, int L, int R) {
if (L <= l && R >= r) return sum1[rt];
int mid = l + r >> 1;
unsigned long long res = 0;
if (L <= mid) res = query1(rt << 1, l, mid, L, R);
if (R > mid)
res = res * qp[min(R, r) - mid] + query1(rt << 1 | 1, mid + 1, r, L, R);
return res;
}
unsigned long long query2(int rt, int l, int r, int L, int R) {
if (L <= l && R >= r) return sum2[rt];
int mid = l + r >> 1;
unsigned long long res = 0;
if (R > mid) res = query2(rt << 1 | 1, mid + 1, r, L, R);
if (L <= mid)
res = res * qp[mid - max(l, L) + 1] + query2(rt << 1, l, mid, L, R);
return res;
}
int main() {
scanf("%d", &n), Init();
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
build(1, 1, n);
for (int i = 2; i < n; ++i) {
update(1, 1, n, a[i - 1]);
if (a[i] == 1 || a[i] == n) continue;
int len = min(a[i] - 1, n - a[i]);
unsigned long long p1 = query1(1, 1, n, a[i] - len, a[i] - 1),
p2 = query2(1, 1, n, a[i] + 1, a[i] + len);
if (p1 != p2) puts("YES"), exit(0);
}
puts("NO");
return 0;
}
| 6 |
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <complex>
#include <cmath>
#include <vector>
#include <map>
#include <set>
#include <stack>
#include <bitset>
#include <queue>
#include <assert.h>
using namespace std;
const int N = 310;
const int mod = 998244353;
int dp[N][N][N];
char s[N];
vector<int> v;
/*
* dp[i][j]
*
*/
void add(int &x, int y) {
x += y;
if (x >= mod) x -= mod;
}
int main()
{
int m;
scanf("%s%d", s + 1, &m);
int n = strlen(s + 1);
int cnt = 0;
s[0] = '0';
for (int i = n; i >= 0; i--) {
if (s[i] == '0') {
v.push_back(cnt);
cnt = 0;
} else {
cnt++;
}
}
if (v.size() == 1) {
cout << 1 << endl;
return 0;
}
m = min(m, n);
for (int j = 0; j <= v[0]; j++)
dp[0][j][j] = 1;
for (int i = 0; i + 1 < v.size(); i++) {
for (int j = 0; j <= m; j++) {
for (int k = 0; k <= n; k++) {
if (dp[i][j][k] == 0) continue;
int valid = v[i + 1];
for (int r = 1; r <= valid; r++)
add(dp[i + 1][j + r][k + r], dp[i][j][k]);
for (int r = 0; r <= k; r++)
add(dp[i + 1][j][r], dp[i][j][k]);
}
}
}
int ans = 0;
for (int i = 0; i <= m; i++)
add(ans, dp[v.size() - 1][i][0]);
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 105;
struct node {
int pos, len;
} w[Maxn];
int f[Maxn][Maxn][2];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> w[i].pos >> w[i].len;
sort(w + 1, w + n + 1,
[](const node& a, const node& b) { return a.pos < b.pos; });
for (int i = 0; i <= n; i++)
for (int j = 0; j <= i; j++)
for (int k = 0; k < 2; k++) {
int mx = -1, pos = -1, way = -1;
for (int d = i + 1; d <= n; d++) {
if (w[d].pos > mx) {
mx = w[d].pos;
pos = d;
way = 0;
}
f[d][pos][way] =
max(f[d][pos][way],
f[i][j][k] +
min(w[d].len,
j ? w[d].pos - w[j].pos - k * w[j].len : INT_MAX) +
mx - w[d].pos);
if (w[d].pos + w[d].len > mx) {
mx = w[d].pos + w[d].len;
pos = d;
way = 1;
}
f[d][pos][way] = max(f[d][pos][way],
f[i][j][k] +
min(w[d].len, j ? w[d].pos + w[d].len -
w[j].pos - k * w[j].len
: INT_MAX) +
mx - w[d].pos - w[d].len);
}
}
int ans = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
for (int p = 0; p < 2; p++) ans = max(ans, f[i][j][p]);
cout << ans << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int opr(char ch, int a, int b) {
if (ch == '&') return a & b;
if (ch == '|') return a | b;
return a ^ b;
}
int solve() {
char ch;
scanf("%c", &ch);
if (ch == '0') return 1;
if (ch == '1') return 1 << 3;
if (ch == '?') return (1 << 1) | (1 << 2);
int a = solve();
scanf("%c", &ch);
int b = solve();
int CC = 0;
for (int i = 0; i < 4; ++i)
if (a & (1 << i))
for (int j = 0; j < 4; ++j)
if (b & (1 << j)) CC |= 1 << opr(ch, i, j);
getchar();
return CC;
}
int main() {
int n;
scanf("%d ", &n);
cout << ((solve() & 6) ? ("YES") : ("NO")) << endl;
fclose(stdin);
fclose(stdout);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s1, s2;
cin >> s1 >> s2;
int n = s1.length();
int flag;
if (s1.length() != s2.length())
cout << "NO";
else {
flag = 1;
for (int i = 0; i < s1.length(); ++i) {
if (s1[i] != s2[n - i - 1]) {
cout << "NO";
flag = 0;
break;
}
}
}
if (flag == 1) cout << "YES";
return 0;
}
| 1 |
#include <iostream>
#include <vector>
#include <set>
#include <map>
#include <sstream>
#include <string>
#include <cstdio>
#include <stack>
#include <queue>
#include <algorithm>
#include <numeric>
#include <functional>
#include <cstring>
#include <tuple>
#include <utility>
#include <list>
#include <cmath>
using namespace std;
typedef long long LL;
typedef vector<int> Array;
typedef pair<int, int> P;
const int INF = 1 << 29;
const LL MOD = 100000;
#define rep(i,n) for(int i=0;i<(int)n;++i)
#define all(c) (c).begin(), (c).end()
struct edge{ int to, cost; edge(int t, int c) :to(t), cost(c){} };
int dxk[] = { 1, 1, 1, 0, -1, 0 };
int dxg[] = { 0, 1, 0, -1, -1, -1 };
int dy[] = { -1, 0, 1, 1, 0, -1 };
struct node
{
LL value, lw, rw, left, right;
};
LL gcd(LL a, LL b)
{
if (a < b) swap(a, b);
return a % b == 0 ? b : gcd(b, a % b);
}
LL sks(LL a, LL b)
{
LL g = gcd(a, b);
return a / g * b;
}
LL dfs(int idx, vector<node>& bars)
{
if (idx == -1) return 1LL;
node& node = bars[idx];
if (node.value != 0) return node.value;
LL r = dfs(node.right, bars), l = dfs(node.left, bars);
int m = 1;
while ((r * node.rw * m) % (l * node.lw) != 0) m++;
int lm = r * node.rw * m / (l * node.lw);
//r*lの最小公倍数を基礎値としてm:nにする
//LL s = sks(r * node.rw, l * node.lw);
//return node.value = s / node.rw + s / node.lw;
return node.value = m * r + lm * l;
}
int main()
{
int n;
while (cin >> n && n)
{
vector<node> bars(n);
rep(i, n)
{
int p, q, r, b;
cin >> p >> q >> r >> b;
int g = gcd(p, q);
bars[i].rw = q / g;
bars[i].lw = p / g;
bars[i].left = r - 1;
bars[i].right = b - 1;
}
LL ans = 0;
rep(i, n) ans = max(dfs(i, bars), ans);
cout << ans << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
string s1, s2;
int a[200001];
bool check(int mid) {
string s = s1;
int i, j = 0;
for (i = 1; i <= mid; i++) {
s[a[i] - 1] = 32;
}
for (i = 0; i < s1.size(); i++) {
if (s[i] == 32) continue;
if (s[i] == s2[j]) {
j++;
if (j >= s2.size()) return true;
}
}
return false;
}
int main() {
ios::sync_with_stdio(false);
cin >> s1 >> s2;
int i, l = 0, r = s1.size(), mid, ans;
for (i = 1; i <= r; i++) {
cin >> a[i];
}
while (l <= r) {
mid = (l + r) / 2;
bool t = check(mid);
if (t) {
l = mid + 1;
ans = mid;
} else {
r = mid - 1;
}
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long N = (long long)(2e5) + 105, inf = 1e9, mod = 1e9 + 7;
long long n, a[N];
long long m, b[N];
long long k = 0;
signed main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
cout.tie(0);
cin >> n >> m;
for (long long i = 0; i < n; ++i) {
cin >> a[i];
}
for (long long i = 0; i < m; ++i) {
cin >> b[i];
if (b[i] >= a[k] && k < n) {
++k;
}
}
cout << n - k;
return false;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
unordered_map<long long, long long> abv[20];
long long a[20][20];
int n, m, half;
long long k, ans;
void down(int i, int j, int lev, long long ex) {
if (i >= n || j >= m) return;
ex ^= a[i][j];
if (half == lev) {
abv[j][ex]++;
return;
}
down(i + 1, j, 1 + lev, ex);
down(i, j + 1, 1 + lev, ex);
}
void up(int i, int j, int lev, long long ex) {
if (i < 0 || j < 0) return;
if (lev == n + m - 2 - half) {
ans += abv[j][ex ^ k];
return;
}
ex ^= a[i][j];
up(i - 1, j, lev + 1, ex);
up(i, j - 1, lev + 1, ex);
}
int main() {
int i, j;
for (scanf("%d%d%I64d", &n, &m, &k), i = 0; i < n; i++) {
for (j = 0; j < m; j++) scanf("%I64d", &a[i][j]);
}
half = (n + m - 2) >> 1;
down(0, 0, 0, 0);
up(n - 1, m - 1, 0, 0);
printf("%I64d", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, h;
int a[1010], b[1010], l, r, ans;
bool check(int n) {
memcpy(b, a, sizeof(b));
sort(b + 1, b + n + 1, [](int i, int j) { return i > j; });
long long cnt = 0;
for (int i = 1; i <= n; i += 2) cnt += b[i];
return cnt <= h;
}
int main() {
scanf("%d%d", &n, &h);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
l = 0, r = n;
while (l <= r) {
int mid = l + r >> 1;
if (check(mid)) {
ans = mid;
l = mid + 1;
} else
r = mid - 1;
}
printf("%d\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long k = n;
long long c = 0;
for (long long i = 2; i <= sqrt(n); ++i) {
if (n % i == 0) {
if (c != 0) {
cout << "1" << endl;
return 0;
}
c = i;
while (n % i == 0) {
n = n / i;
}
}
}
if (c != 0) {
if (n != 1)
cout << "1" << endl;
else
cout << c << endl;
} else {
cout << k << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int A[200000 + 1], F[200000 + 1], tree[4 * 200000 + 1], flag[4 * 200000 + 1];
void push(int node, int a, int b) {
if (flag[node]) {
tree[node] += (b - a + 1) * flag[node];
if (a != b) {
int izq = 2 * node + 1, der = 2 * node + 2;
flag[izq] += flag[node];
flag[der] += flag[node];
}
}
flag[node] = 0;
}
void update(int node, int a, int b, int p, int q) {
if (b < p || a > q) return;
push(node, a, b);
if (a >= p && b <= q) {
flag[node]++;
push(node, a, b);
return;
}
int izq = 2 * node + 1, der = 2 * node + 2;
update(izq, a, (a + b) / 2, p, q);
update(der, (a + b) / 2 + 1, b, p, q);
tree[node] = tree[izq] + tree[der];
}
int query(int node, int a, int b, int p, int q) {
if (b < p || a > q) return 0;
push(node, a, b);
if (a >= p && b <= q) {
return tree[node];
}
int izq = 2 * node + 1, der = 2 * node + 2;
return query(izq, a, (a + b) / 2, p, q) +
query(der, (a + b) / 2 + 1, b, p, q);
}
int main() {
int n, q, x, y;
cin >> n >> q;
for (int i = 0; i < n; ++i) {
cin >> A[i];
}
for (int i = 0; i < q; ++i) {
cin >> x >> y;
x--, y--;
update(0, 0, n - 1, x, y);
}
for (int i = 0; i < n; ++i) {
F[i] = query(0, 0, n - 1, i, i);
}
sort(F, F + n);
sort(A, A + n);
long long sum = 0LL;
for (int i = 0; i < n; ++i) {
sum += ((long long)A[i] * F[i]);
}
cout << sum << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 305, Mo = int(1e9) + 7;
vector<int> Lk[MAXN], E[MAXN];
map<int, int> Hash;
bool Walk[MAXN];
int Els[MAXN][3], Pos[MAXN];
int T[MAXN], Ref[MAXN], Col[MAXN], H[MAXN], Block[MAXN][3], W[MAXN][MAXN],
Self[MAXN], Edge, N, K, cnt, c, tot;
void Link(int u, int v) { Lk[u].push_back(v), Lk[v].push_back(u); }
void Extract(int S) {
static int Pre[MAXN];
for (int i = 1; i <= cnt; i++) Pre[i] = 0, E[i].clear(), Self[i] = 0;
c = 0;
tot = 0;
Edge = 0;
static int Q[MAXN];
Q[1] = S;
Ref[S] = (c = 1);
Pos[1] = S;
Walk[S] = 1;
Col[S] = 0;
for (int fi = 1, en = 1; fi <= en; fi++) {
int u = Q[fi];
for (int i = 0; i < Lk[u].size(); i++) {
if (!Walk[Lk[u][i]]) {
Self[u]++;
Edge++;
Ref[Lk[u][i]] = ++c;
Pre[Lk[u][i]] = u;
Pos[c] = Lk[u][i];
Walk[Lk[u][i]] = 1;
Col[Lk[u][i]] = (Col[u] ^ 1);
E[Ref[u]].push_back(Ref[Lk[u][i]]);
Q[++en] = Lk[u][i];
} else if (Lk[u][i] > u && Lk[u][i] != Pre[u])
Self[u]++, Edge++, Els[++tot][0] = Ref[u], Els[tot][1] = Ref[Lk[u][i]],
Els[tot][2] = W[u][Lk[u][i]];
}
}
}
void Dp() {
int c = 0, tag = 0;
static int All[MAXN], Siz[2];
memset(Siz, 0, sizeof Siz);
for (int i = 1; i <= cnt; i++)
if (Ref[i]) Siz[Col[i]]++;
if (Siz[0] < Siz[1]) {
for (int i = 1; i <= cnt; i++)
if (Ref[i] && Col[i] == 0) All[i] = (c++);
tag = 1;
} else {
tag = 0;
for (int i = 1; i <= cnt; i++)
if (Ref[i] && Col[i]) All[i] = (c++);
}
static int G[2][1 << 21];
c = (1 << c);
for (int i = 0; i < c; i++) G[1][i] = 0;
G[1][0] = 1;
int cr = 0;
for (int i = 1; i <= cnt; i++)
if (Ref[i] && Col[i] == tag) {
cr ^= 1;
for (int j = 0; j < c; j++) G[cr ^ 1][j] = G[cr][j];
for (int j = 0; j < c; j++)
if (G[cr][j]) {
for (int k = 0; k < Lk[i].size(); k++) {
int v = Lk[i][k];
if (j & (1 << All[v])) continue;
int nj = (j | (1 << All[v]));
G[cr ^ 1][nj] =
(G[cr ^ 1][nj] + G[cr][j] * 1ll * W[i][v] % Mo) % Mo;
}
}
}
cr ^= 1;
memset(H, 0, sizeof H);
for (int j = 0; j < c; j++) {
int v = 0;
for (int tmp = j; tmp; tmp >>= 1) v += (tmp & 1);
H[v] = (H[v] + G[cr][j]) % Mo;
}
}
bool Ch[MAXN];
int G[MAXN][MAXN], F[MAXN][MAXN], Siz[MAXN], Max[MAXN];
void Dfs(int Now) {
Siz[Now] = Edge;
for (int i = 0; i < E[Now].size(); i++) Dfs(E[Now][i]);
for (int i = 0; i <= Siz[Now]; i++) F[Now][i] = G[Now][i] = 0;
F[Now][0] = 1;
for (int i = 0, cr = 0; i < E[Now].size(); i++) {
int v = E[Now][i];
for (int j = Siz[Now]; j + 1; j--)
if (F[Now][j])
for (int k = 1; k <= Max[v] && k + j <= Edge; k++)
if ((G[v][k] + F[v][k]))
F[Now][j + k] =
(F[Now][j + k] + F[Now][j] * 1ll * ((G[v][k] + F[v][k]) % Mo)) %
Mo;
}
if (!Ch[Now]) {
static int Cur[MAXN], Suf[MAXN][MAXN], Pre[MAXN];
Suf[0][0] = 1;
int ch = 1;
for (int i = E[Now].size() - 1, cr = 0; i + 1; i--, ch++) {
int v = E[Now][i];
for (int j = 0; j <= Siz[Now]; j++) Suf[ch][j] = Suf[ch - 1][j];
for (int j = Siz[Now]; j + 1; j--)
if (Suf[ch][j])
for (int p = 1; p <= Max[v] && p + j <= Edge; p++)
if ((F[v][p] + G[v][p]))
Suf[ch][j + p] =
(Suf[ch][j + p] +
Suf[ch][j] * 1ll * ((F[v][p] + G[v][p]) % Mo) % Mo) %
Mo;
}
for (int i = 0; i <= Edge; i++) Pre[i] = 0;
Pre[0] = 1;
ch--;
for (int i = 0, cr = 0; i < E[Now].size(); i++, ch--) {
int v = E[Now][i];
if (!Ch[v]) {
static int Bak[MAXN];
for (int p = 0; p <= Siz[Now]; p++) Bak[p] = Pre[p];
for (int p = Siz[Now]; p + 1; p--)
if (Bak[p])
for (int q = 1; q <= Max[v] && q + p <= Siz[Now]; q++)
if (F[v][q])
Bak[p + q] = (Bak[p + q] + Bak[p] * 1ll * F[v][q]) % Mo;
for (int p = 0; p <= Siz[Now]; p++)
if (Bak[p])
for (int q = 0; p + q + 1 <= Siz[Now]; q++)
if (Suf[ch - 1][q])
G[Now][p + q + 1] =
(G[Now][p + q + 1] + Bak[p] * 1ll * Suf[ch - 1][q] % Mo *
W[Pos[Now]][Pos[v]] % Mo) %
Mo;
}
for (int p = Siz[Now]; p + 1; p--)
if (Pre[p])
for (int q = 1; q <= Max[v] && q + p <= Siz[Now]; q++)
if ((F[v][q] + G[v][q]))
Pre[p + q] =
(Pre[p + q] + Pre[p] * 1ll * (F[v][q] + G[v][q]) % Mo) % Mo;
cr += Siz[v];
}
}
Max[Now] = 0;
for (int i = 0; i <= Edge; i++)
if (F[Now][i] + G[Now][i]) Max[Now] = i;
}
void Tree() {
memset(H, 0, sizeof H);
for (int i = 0; i < (1 << tot); i++) {
int cr = 1, ch = 0, f = 0;
for (int j = 1; j <= c; j++) Ch[j] = 0;
for (int j = 0; j < tot; j++)
if (i & (1 << j)) {
if (Ch[Els[j + 1][0]] || Ch[Els[j + 1][1]]) {
f = 1;
break;
}
Ch[Els[j + 1][0]] = Ch[Els[j + 1][1]] = 1;
cr = cr * 1ll * Els[j + 1][2] % Mo;
ch++;
}
if (f) continue;
Dfs(1);
for (int i = 0; i <= Edge - ch; i++)
H[i + ch] = (H[i + ch] + cr * 1ll * ((F[1][i] + G[1][i]) % Mo) % Mo) % Mo;
}
}
void Work(int S) {
Extract(S);
if (c / 2 <= Edge - c)
Dp();
else
Tree();
for (int i = K; i; i--)
for (int j = 1; j <= i; j++)
T[i] = (T[i] + T[i - j] * 1ll * H[j] % Mo) % Mo;
memset(Ref, 0, sizeof Ref);
}
int main() {
static int Fac[100005];
scanf("%d%d", &N, &K);
for (int i = 1; i <= K; i++)
scanf("%d%d%d", &Block[i][0], &Block[i][1], &Block[i][2]);
for (int i = 1; i <= K; i++) {
if (!Hash[Block[i][0]]) Hash[Block[i][0]] = ++cnt;
Block[i][0] = Hash[Block[i][0]];
}
Hash.clear();
for (int i = 1; i <= K; i++)
if (!Hash[Block[i][1]]) Hash[Block[i][1]] = ++cnt;
for (int i = 1; i <= K; i++) {
Block[i][1] = Hash[Block[i][1]];
Link(Block[i][0], Block[i][1]);
W[Block[i][0]][Block[i][1]] = W[Block[i][1]][Block[i][0]] =
(Block[i][2] - 1 + Mo) % Mo;
}
T[0] = 1;
for (int i = 1; i <= cnt; i++)
if (!Walk[i]) Work(i);
Fac[0] = 1;
for (int i = 1; i <= N; i++) Fac[i] = Fac[i - 1] * 1ll * i % Mo;
int ans = 0;
for (int i = 0; i <= K; i++) ans = (ans + Fac[N - i] * 1ll * T[i] % Mo) % Mo;
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, d, p;
cin >> n >> d;
int sum = 0;
int ans = 0;
for (int i = 0; i < n; i++) {
cin >> p;
sum += p;
}
sum += (n - 1) * 10;
if (sum <= d) {
if ((d - sum) >= 5) ans += ((d - sum) / 5);
ans += (n - 1) * 2;
cout << ans << endl;
} else
cout << "-1" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int M = 100001;
int n;
int p[M], f[M];
vector<long long> v;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> p[i];
}
for (int i = 0; i < n; i++) {
long long c = 0;
int t = i;
while (!f[t]) {
f[t] = 1;
c++;
t = p[t] - 1;
}
if (c > 0) {
v.push_back(c);
}
}
sort(v.begin(), v.end());
for (int i = 0; i < v.size(); i++) {
}
long long res = 0;
if (v.size() >= 2) {
int len = v.size();
for (int i = 0; i < len - 2; i++) {
long long tmp = v[i];
res += tmp * tmp;
}
long long tmp = v[len - 1] + v[len - 2];
res = res + tmp * tmp;
} else {
res = v[0] * v[0];
}
cout << res << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n = 0, m = 0;
cin >> n >> m;
int arr[n][2 * m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < 2 * m; j++) {
cin >> arr[i][j];
}
}
int count = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 2 * m; j += 2) {
if (arr[i][j] == 1 || arr[i][j + 1] == 1) {
count++;
}
}
}
cout << count << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200010;
long long Answer;
vector<int> G[1010];
int n, m, l, r, Total, Block;
int Left[1010], Right[1010], Belong[MAXN], a[MAXN];
inline long long Read() {
long long x = 0, f = 0;
char c = getchar();
while (!isdigit(c)) {
f |= c == '-';
c = getchar();
}
while (isdigit(c)) {
x = (x << 1) + (x << 3) + (c ^ 48);
c = getchar();
}
return f ? -x : x;
}
inline void Write(const long long &x) {
if (x < 0) {
putchar('-');
Write(-x);
return;
}
if (x > 9) {
Write(x / 10);
}
putchar((x % 10) ^ 48);
return;
}
inline void Init() {
register int i, j = 1;
Block = sqrt(n);
Total = ceil(n * 1.0 / Block);
for (i = 1; i <= Total; ++i) {
Left[i] = j;
for (; j <= i * Block and j <= n; ++j) {
Belong[j] = i;
a[j] = j;
G[i].push_back(j);
}
Right[i] = j - 1;
}
return;
}
inline void UpDate(int left, int right) {
register int posl = Belong[left], posr = Belong[right];
if (posl ^ posr) {
G[posl].erase(lower_bound(G[posl].begin(), G[posl].end(), a[left]));
G[posr].erase(lower_bound(G[posr].begin(), G[posr].end(), a[right]));
G[posr].insert(upper_bound(G[posr].begin(), G[posr].end(), a[left]),
a[left]);
G[posl].insert(upper_bound(G[posl].begin(), G[posl].end(), a[right]),
a[right]);
}
a[left] ^= a[right];
a[right] ^= a[left];
a[left] ^= a[right];
return;
}
inline long long Query(int left, int right, int value) {
long long Cur = 0;
register int i, posl = Belong[left], posr = Belong[right];
if (left > right) {
return 0;
}
if (posl + 1 >= posr) {
for (i = left; i <= right; ++i) {
Cur += (a[i] < value);
}
} else {
for (i = left; i <= Right[posl]; ++i) {
Cur += (a[i] < value);
}
for (i = Left[posr]; i <= right; ++i) {
Cur += (a[i] < value);
}
for (i = posl + 1; i ^ posr; ++i) {
Cur += upper_bound(G[i].begin(), G[i].end(), value) - G[i].begin();
}
}
return Cur;
}
signed main() {
register int i;
n = Read(), m = Read(), Init();
for (i = 1; i <= m; ++i) {
l = Read(), r = Read();
if (l ^ r) {
if (l > r) {
l ^= r, r ^= l, l ^= r;
}
Answer += 2 * (Query(l + 1, r - 1, a[r]) - Query(l + 1, r - 1, a[l])) +
((a[l] < a[r]) ? 1
: (a[l] ^ a[r]) ? -1
: 0);
Write(Answer), putchar('\n');
UpDate(l, r);
} else {
Write(Answer), putchar('\n');
}
}
return 0;
}
| 5 |
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <tuple>
#include <cstring>
using namespace std;
#define loop(i,a,b) for(int i=(a);i<int(b);i++)
#define rep(i,b) loop(i,0,b)
#define eb emplace_back
int w,h;
char g[55][55];
int flg[55][55];
void draw(int i, int j, int c){
rep(d,4){
int di[] = {0,1,0,-1};
int dj[] = {1,0,-1,0};
int ni = i+di[d];
int nj = j+dj[d];
if(ni >= h || ni < 0 || nj >= w || nj < 0) continue;
if(g[ni][nj]!='.' || flg[ni][nj]&c) continue;
flg[ni][nj] |= c;
draw(ni,nj,c);
}
}
int main(){
while(cin >> w >> h && w){
rep(i,h) cin >> g[i];
memset(flg,0,sizeof(flg));
rep(i,h)rep(j,w)if(g[i][j]!='.') draw(i,j,g[i][j]=='W' ? 1 : 2);
int cb = 0, cw = 0;
rep(i,h)rep(j,w){
if(flg[i][j]==1) cw++;
if(flg[i][j]==2) cb++;
}
cout << cb << " " << cw << endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
scanf("%d %d\n", &n, &k);
vector<int> id[2];
for (int i = 0; i < n; i++) {
id[getchar() - '0'].push_back(i);
}
bool w1 = false, w2 = true;
for (int i = 0; i <= n - k; i++) {
for (int j = 0; j <= 1; j++) {
int l0 = i, r0 = i + k - 1;
if (id[j].size() > 0) {
l0 = min(l0, id[j][0]);
r0 = max(r0, id[j][id[j].size() - 1]);
}
int l1 = n, r1 = -1;
if (id[j ^ 1].size() > 0) {
if (id[j ^ 1][0] < i) {
l1 = id[j ^ 1][0];
} else {
auto x = lower_bound(id[j ^ 1].begin(), id[j ^ 1].end(), i + k);
if (x != id[j ^ 1].end()) {
l1 = *x;
}
}
if (id[j ^ 1][id[j ^ 1].size() - 1] >= i + k) {
r1 = id[j ^ 1][id[j ^ 1].size() - 1];
} else {
auto x = lower_bound(id[j ^ 1].begin(), id[j ^ 1].end(), i);
if (x != id[j ^ 1].begin()) {
r1 = *prev(x);
}
}
}
if (l1 == n) {
w1 = true;
} else if (!(r0 - l0 < k || r1 - l1 < k)) {
w2 = false;
}
}
}
printf("%s\n", w1 ? "tokitsukaze" : w2 ? "quailty" : "once again");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long modpow(long long a, long long b, long long m) {
long long r = 1;
while (b > 0) {
if (b & 1) r = (r * a) % m;
a = (a * a) % m;
b >>= 1;
}
return r;
}
int main() {
long long n, i, mi = 1e18, c = 0, j, d = 0, ma = -1e18;
scanf("%lld", &n);
long long a[n], b[n];
for (i = 0; i < n; ++i) {
scanf("%lld", &a[i]);
mi = min(mi, a[i]);
ma = max(ma, a[i]);
}
vector<long long> v;
if (ma == mi) {
printf("%lld ", n);
printf("\n");
for (i = 0; i < n; ++i) printf("%lld ", a[i]);
printf("\n");
return 0;
}
for (i = 0; i < n; ++i) {
a[i] -= mi;
b[i] = a[i];
if (a[i] == 0) v.push_back(i);
}
j = 0;
for (i = 0; i < n; ++i) {
if (a[i] == 2) {
if (j == v.size()) break;
a[i] = 1;
a[v[j++]] = 1;
c += 2;
}
}
j = -1;
for (i = 0; i < n; ++i) {
if (ma - mi < 2) break;
if (b[i] == 1) {
if (j == -1)
j = i;
else {
b[j] = 0, b[i] = 2;
j = -1;
d += 2;
}
}
}
if (c > d) {
printf("%lld ", n - c);
printf("\n");
for (i = 0; i < n; ++i) printf("%lld ", a[i] + mi);
} else {
printf("%lld ", n - d);
printf("\n");
for (i = 0; i < n; ++i) printf("%lld ", b[i] + mi);
}
printf("\n");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005, inf = 0x3f3f3f3f;
const long long llinf = 0x3f3f3f3f3f3f3f3f;
const long double pi = acos(-1.0L);
long long v[maxn], t[maxn], sum[maxn], ans[maxn];
int num = 0;
struct Tree {
int lc, rc, l, r;
long long sum, tag;
};
Tree tree[4 * maxn];
void build(int now, int l, int r) {
tree[now].l = l;
tree[now].r = r;
tree[now].tag = 0;
if (l != r) {
num++;
tree[now].lc = num;
build(num, l, (l + r) / 2);
num++;
tree[now].rc = num;
build(num, (l + r) / 2 + 1, r);
tree[now].sum = tree[tree[now].lc].sum + tree[tree[now].rc].sum;
} else
tree[now].sum = 0;
}
void pushdown(int now) {
if (tree[now].tag == 0) return;
int l = tree[now].lc, r = tree[now].rc;
tree[l].tag += tree[now].tag;
tree[r].tag += tree[now].tag;
tree[l].sum += tree[now].tag * (tree[l].r - tree[l].l + 1);
tree[r].sum += tree[now].tag * (tree[r].r - tree[r].l + 1);
tree[now].tag = 0;
}
void update(int now, int l, int r, long long c) {
if (tree[now].l >= l && tree[now].r <= r) {
tree[now].sum += c * (tree[now].r - tree[now].l + 1);
tree[now].tag += c;
} else {
pushdown(now);
if (l <= (tree[now].l + tree[now].r) / 2) update(tree[now].lc, l, r, c);
if (r > (tree[now].l + tree[now].r) / 2) update(tree[now].rc, l, r, c);
tree[now].sum = tree[tree[now].lc].sum + tree[tree[now].rc].sum;
}
}
long long findsum(int now, int l, int r) {
pushdown(now);
if (tree[now].l >= l && tree[now].r <= r) {
return tree[now].sum;
} else {
long long f = 0;
if (l <= (tree[now].l + tree[now].r) / 2) f = findsum(tree[now].lc, l, r);
if (r > (tree[now].l + tree[now].r) / 2) f += findsum(tree[now].rc, l, r);
return f;
}
}
int main() {
int n, m, i, j;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%I64d", &v[i]);
}
sum[0] = 0;
for (i = 1; i <= n; i++) {
scanf("%I64d", &t[i]);
sum[i] = sum[i - 1] + t[i];
ans[i] = 0;
}
num = 1;
build(1, 1, n);
for (i = 1; i <= n; i++) {
int pos = upper_bound(sum + 1, sum + n + 1, v[i] + sum[i - 1]) - sum;
if (pos > i) update(1, i, pos - 1, 1);
ans[pos] += v[i] - (sum[pos - 1] - sum[i - 1]);
}
for (i = 1; i <= n; i++) {
ans[i] += findsum(1, i, i) * t[i];
printf("%I64d ", ans[i]);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000010;
int n, m, k, kd, d[maxn], a, b;
vector<int> g[maxn];
bool u[maxn];
multiset<int> ss;
int dfs(int i) {
int res = 1;
u[i] = true;
for (int j = 0; j < (int)(g[i].size()); j++)
if (!u[g[i][j]]) res += dfs(g[i][j]);
return res;
}
int main() {
scanf("%d %d %d", &n, &m, &k);
for (int i = 0; i < (int)(m); i++) {
scanf("%d %d", &a, &b);
a--, b--;
g[a].push_back(b);
g[b].push_back(a);
}
kd = 0;
for (int i = 0; i < (int)(n); i++)
if (!u[i]) {
d[kd++] = dfs(i);
}
sort(d, d + kd);
reverse(d, d + kd);
int total = 0;
for (int i = 0; i < (int)(kd); i++) {
if (d[i] > k) d[i] = k;
total += d[i];
ss.insert(d[i]);
}
for (int i = 0;; i++) {
if (total >= 2 * ((int)ss.size() - 1)) {
printf("%d\n", i);
break;
}
int a = *ss.begin();
ss.erase(ss.begin());
int b = *ss.begin();
ss.erase(ss.begin());
total = total - a - b + min(a + b, k);
ss.insert(min(a + b, k));
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
auto print = [&](int i, int j) {
if (n % 2 == 0) {
return i + j != n + 1;
} else {
return i + j != n;
}
};
int m = n * (n - 1) / 2 - n / 2;
cout << m << endl;
for (int i = 1; i <= n; ++i) {
for (int j = i + 1; j <= n; ++j) {
if (print(i, j)) {
cout << i << " " << j << endl;
}
}
}
} | 0 |
#include<bits/stdc++.h>
using namespace std;
int n;
int main(){
cin >> n;
cout << ((n+999)/1000)*1000 - n << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200000 + 5;
int f[N][2], col[N];
int tot;
int head[N], to[N * 2], next1[N * 2];
void lian(int x, int y) {
to[++tot] = y;
next1[tot] = head[x];
head[x] = tot;
}
int ans;
void get(int &d1, int &d2, int x, int c, int fa) {
d1 = 0, d2 = 0;
for (int i = head[x]; i; i = next1[i]) {
int v = to[i];
if (v == fa) continue;
int val = min(f[v][c], f[v][c ^ 1] + 1);
if (val >= d1)
d2 = d1, d1 = val;
else if (val > d2)
d2 = val;
}
}
void dfs(int x, int fa) {
f[x][0] = f[x][1] = 1e6;
for (int i = head[x]; i; i = next1[i]) {
int v = to[i];
if (v == fa) continue;
dfs(v, x);
}
int d1, d2;
if (col[x]) {
f[x][col[x] - 1] = 0;
get(d1, d2, x, col[x] - 1, fa);
ans = max(ans, d1 + d2);
f[x][col[x] - 1] = d1;
return;
}
f[x][0] = 0;
get(d1, d2, x, 0, fa);
int val = d1 + d2;
f[x][0] = d1;
f[x][1] = 0;
get(d1, d2, x, 1, fa);
val = min(val, d1 + d2);
f[x][1] = d1;
ans = max(ans, val);
}
int main() {
int T;
cin >> T;
while (T--) {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &col[i]);
tot = 1;
for (int i = 1; i <= n; i++) head[i] = 0;
int x, y;
for (int i = 1; i <= n - 1; i++) {
scanf("%d %d", &x, &y);
lian(x, y), lian(y, x);
}
ans = 0;
dfs(1, 0);
printf("%d\n", (ans + 1) / 2 + 1);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int N, M, x, y, z, tmp, top[200005], deg[200005];
int val[200005], to;
queue<int> q;
pair<int, int> yol[200005];
vector<int> cont[200005];
void bfs() {
tmp = 1;
q.push(tmp);
while (!q.empty()) {
tmp = q.front();
q.pop();
for (int i = 0; i < (int)cont[tmp].size(); i++)
if (deg[cont[tmp][i]] < 0) {
if (yol[cont[tmp][i]].first == tmp) {
to = yol[cont[tmp][i]].second;
deg[cont[tmp][i]] = 0;
} else {
to = yol[cont[tmp][i]].first;
deg[cont[tmp][i]] = 1;
}
top[to] -= val[cont[tmp][i]];
if (top[to] == 0 && to != N) q.push(to);
}
}
}
int main() {
scanf("%d %d", &N, &M);
for (int i = 0; i < M; i++) {
scanf("%d %d %d", &x, &y, &z);
yol[i] = pair<int, int>(x, y);
val[i] = z;
cont[x].push_back(i);
cont[y].push_back(i);
top[x] += z;
top[y] += z;
}
for (int i = 1; i <= N; i++) top[i] /= 2;
memset(deg, -1, sizeof(deg));
bfs();
for (int i = 0; i < M; i++) {
if (yol[i].second == 1 || yol[i].first == N)
printf("1\n");
else
printf("%d\n", deg[i]);
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, dp[3000][2], a[3000], b[3000], c[3000], i;
int main() {
cin >> n;
for (i = 0; i < n; i++) scanf("%d", &a[i]);
for (i = 0; i < n; i++) scanf("%d", &b[i]);
for (i = 0; i < n; i++) scanf("%d", &c[i]);
dp[0][0] = a[0];
dp[0][1] = b[0];
dp[1][0] = max(a[0] + b[1], a[1] + b[0]);
dp[1][1] = max(b[0] + b[1], a[0] + c[1]);
for (i = 2; i < n; i++) {
dp[i][0] = max(dp[i - 1][0] + b[i], dp[i - 1][1] + a[i]);
dp[i][1] = max(dp[i - 1][0] + c[i], dp[i - 1][1] + b[i]);
}
printf("%d", dp[n - 1][0]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n, r, avg;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> r >> avg;
vector<pair<long long, long long> > v;
long long x, y;
long long sum = 0;
for (long long i = 0; i < n; i++) {
cin >> x >> y;
v.push_back({x, y});
sum += x;
}
sort(v.begin(), v.end(),
[](pair<long long, long long> x, pair<long long, long long> y) {
if (x.second == y.second) {
return r - x.first > r - y.first;
}
return x.second < y.second;
});
long long diff = n * avg - sum;
long long ans = 0;
int idx = 0;
while (sum < (n * avg)) {
long long req = min(n * avg - sum, r - v[idx].first);
ans += (v[idx].second * req);
sum += req;
idx++;
}
cout << ans << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3007, K = 1507, p = 998244353;
vector<int> dp[2][K];
int n, k, a, b, w[N], cnt[N], fac[N], ans[N], ifac[N], f[N][N], c[N][N];
inline int read() {
int num = 0;
char g = getchar();
while (g < 48 || 57 < g) g = getchar();
while (47 < g && g < 58)
num = (num << 1) + (num << 3) + g - 48, g = getchar();
return num;
}
inline int mul(int a, int b) { return 1ll * a * b % p; }
inline int inc(int a, int b) {
if (a + b >= p) return a + b - p;
return a + b;
}
inline int pows(int u, int v) {
int ans = 1;
while (v > 0) {
if (v & 1) ans = mul(ans, u);
u = mul(u, u), v = v >> 1;
}
return ans;
}
inline void getdiv(int u) {
if (u == 0)
b--;
else
a = mul(a, pows(u, p - 2));
}
inline void getmul(int u) {
if (u == 0)
b++;
else
a = mul(a, u);
}
inline int getnum() {
if (b == 0) return a;
return 0;
}
int main() {
n = read(), k = read(), fac[0] = ifac[0] = 1;
for (int i = 1; i <= n; i++)
w[i] = read(), fac[i] = mul(fac[i - 1], i), ifac[i] = pows(fac[i], p - 2);
if (k == 1) {
cout << 0 << ' ';
for (int i = 1; i <= n; i++)
printf("%d ", mul(mul(fac[n], ifac[i]), ifac[n - i]));
return 0;
}
if (k <= 11) {
int s = n / k;
for (int j = 0; j <= s; j++)
dp[0][j].resize((1 << k)), dp[1][j].resize((1 << k));
dp[0][0][0] = 1;
for (int x = 1; x <= n; x++) {
for (int y = 0; y <= s; y++)
for (int z = 0; z < (1 << k); z++) dp[x & 1][y][z] = 0;
for (int y = 0; y <= s; y++) {
for (int z = 0; z < (1 << k) - 1; z++) {
if (!dp[(x - 1) & 1][y][z]) continue;
int t = z | (1 << (w[x] - 1));
if (t + 1 == (1 << k))
dp[x & 1][y + 1][0] =
inc(dp[x & 1][y + 1][0], dp[(x - 1) & 1][y][z]);
else
dp[x & 1][y][t] = inc(dp[x & 1][y][t], dp[(x - 1) & 1][y][z]);
dp[x & 1][y][z] = inc(dp[x & 1][y][z], dp[(x - 1) & 1][y][z]);
}
}
}
for (int y = 0; y <= s; y++)
for (int z = 0; z < (1 << k) - 1; z++)
ans[y] = inc(ans[y], dp[n & 1][y][z]);
ans[0] = (ans[0] - 1 + p) % p;
} else {
int s = n / k;
for (int i = 1; i <= n; i++) {
memset(cnt, 0, sizeof(cnt));
a = 1, b = k;
for (int x = i; x <= n; x++)
getdiv(pows(2, cnt[w[x]]) - 1), c[i][x] = getnum(), cnt[w[x]]++,
getmul(pows(2, cnt[w[x]]) - 1);
}
f[0][0] = 1;
for (int i = 1; i <= n; i++)
for (int j = i; j <= n; j++)
for (int x = 0; x <= i / k; x++)
f[j][x + 1] = inc(f[j][x + 1], mul(c[i][j], f[i - 1][x]));
memset(cnt, 0, sizeof(cnt));
for (int i = n; i >= 0; i--) {
int opt = pows(2, n - i), sum = 1;
for (int x = 1; x <= k; x++) sum = mul(sum, pows(2, cnt[x]) - 1);
opt = (opt - sum + p) % p;
for (int x = 0; x <= s; x++) ans[x] = inc(mul(f[i][x], opt), ans[x]);
cnt[w[i]]++;
}
ans[0] = (ans[0] - 1 + p) % p;
}
for (int i = 0; i <= n; i++) printf("%d ", ans[i]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int check(int *a, int n, int x, bool cur) {
int answer = 0;
for (int i = 0; i < n; i++) {
if (cur) {
if (a[i] <= x) {
answer++;
cur = !cur;
}
} else {
answer++;
cur = !cur;
}
}
return answer;
}
void solve() {
int n, k;
cin >> n >> k;
int l = 1, r = 1e9;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
while (l < r) {
int mid = (l + r) / 2;
if (check(a, n, mid, 0) >= k || check(a, n, mid, 1) >= k)
r = mid;
else
l = mid + 1;
}
cout << l << '\n';
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
t = 1;
while (t--) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
int main() {
int i, j, k, a, b, c;
int n;
scanf("%d %d %d %d", &n, &a, &b, &c);
getchar();
int target = n;
long long result = 0;
for (i = 0; i <= a; i += 2) {
target = n;
target = target - (i / 2);
if (target == 0) {
result++;
break;
}
if (target < 0) break;
int target1;
for (j = 0; j <= b; j++) {
target1 = target;
target1 = target1 - j;
if (target1 == 0) {
result++;
break;
}
if (target1 < 0 || target1 % 2) continue;
if (target1 <= 2 * c) {
result++;
}
}
}
printf("%lld\n", result);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, i, j, c = 0, d, s = 0;
cin >> n >> m;
int a[n + 1];
for (i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
for (i = n - 1; i >= 0; i--) {
c++;
s = s + a[i];
if (s >= m) break;
}
cout << c;
}
| 1 |
#include <bits/stdc++.h>
const long long Infll = 0x3f3f3f3f3f3f3f3f;
const int MN = 100005, MS = 1 << 18 | 7;
long long K, W[MN], G[MN], pre[MN], suf[MN];
int N, nxt[MN], Ans;
std::vector<int> T[MN];
long long amn[MS], bmn[MS], ans[MS], tg[MS];
inline void P(int i, long long x) { bmn[i] += x, ans[i] -= x, tg[i] += x; }
inline void Pushdown(int i) {
if (tg[i]) P((i << 1), tg[i]), P(((i << 1) | 1), tg[i]), tg[i] = 0;
}
long long Calc(int i, int l, int r, long long p) {
if (l == r) return amn[i] - p;
Pushdown(i);
if (bmn[(i << 1)] < p)
return std::min(Calc((i << 1), l, ((l + r) >> 1), p), ans[i]);
else
return std::min(amn[(i << 1)] - p,
Calc(((i << 1) | 1), ((l + r) >> 1) + 1, r, p));
}
void Build(int i, int l, int r) {
if (l == r) {
amn[i] = bmn[i] = suf[l];
return;
}
Build((i << 1), l, ((l + r) >> 1)),
Build(((i << 1) | 1), ((l + r) >> 1) + 1, r);
amn[i] = std::min(amn[(i << 1)], amn[((i << 1) | 1)]);
bmn[i] = std::min(bmn[(i << 1)], bmn[((i << 1) | 1)]);
ans[i] = Calc(((i << 1) | 1), ((l + r) >> 1) + 1, r, bmn[(i << 1)]);
}
void Mdf(int i, int l, int r, int a, int b, long long x) {
if (r < a || b < l) return;
if (a <= l && r <= b) return P(i, x);
Pushdown(i), Mdf((i << 1), l, ((l + r) >> 1), a, b, x),
Mdf(((i << 1) | 1), ((l + r) >> 1) + 1, r, a, b, x);
bmn[i] = std::min(bmn[(i << 1)], bmn[((i << 1) | 1)]);
ans[i] = Calc(((i << 1) | 1), ((l + r) >> 1) + 1, r, bmn[(i << 1)]);
}
int Solve2(int i, int l, int r, long long v) {
if (l == r) return l;
return amn[((i << 1) | 1)] <= v
? Solve2(((i << 1) | 1), ((l + r) >> 1) + 1, r, v)
: Solve2((i << 1), l, ((l + r) >> 1), v);
}
int Solve(int i, int l, int r, long long &p) {
if (l == r) {
int ret = amn[i] - p <= K ? l : 0;
p = std::min(p, bmn[i]);
return ret;
}
Pushdown(i);
if (bmn[(i << 1)] < p) {
if (ans[i] <= K)
return Solve(((i << 1) | 1), ((l + r) >> 1) + 1, r, p = bmn[(i << 1)]);
else {
int ret = Solve((i << 1), l, ((l + r) >> 1), p);
p = std::min(p, bmn[i]);
return ret;
}
} else {
int ret =
amn[(i << 1)] <= K + p ? Solve2((i << 1), l, ((l + r) >> 1), K + p) : 0;
return std::max(ret, Solve(((i << 1) | 1), ((l + r) >> 1) + 1, r, p));
}
}
inline void DFS(int u) {
static int stk[MN], tp;
stk[++tp] = u;
if (nxt[u] <= N) Mdf(1, 1, N, nxt[u] - 1, N, pre[u] - pre[nxt[u]]);
if (u <= N) {
int lb = 2, rb = tp - 1, mid, ret = 1;
while (lb <= rb) {
mid = (lb + rb) >> 1;
if (pre[stk[mid]] - pre[u] > K)
ret = mid, lb = mid + 1;
else
rb = mid - 1;
}
int rmax = stk[ret] - 1;
long long _ = Infll;
if (u > 1) Mdf(1, 1, N, 1, u - 1, Infll);
Mdf(1, 1, N, rmax, N, -Infll);
int pos = Solve(1, 1, N, _);
Mdf(1, 1, N, rmax, N, Infll);
if (u > 1) Mdf(1, 1, N, 1, u - 1, -Infll);
Ans = std::max(Ans, pos - u + 1);
}
for (auto v : T[u]) DFS(v);
if (nxt[u] <= N) Mdf(1, 1, N, nxt[u] - 1, N, pre[nxt[u]] - pre[u]);
--tp;
}
inline void Init() {
static int stk[MN], tp;
scanf("%d%lld", &N, &K), Ans = 1;
for (int i = 1; i < N; ++i) scanf("%lld", &W[i]);
for (int i = 1; i <= N; ++i) scanf("%lld", &G[i]);
for (int i = 2; i <= N; ++i)
pre[i] = pre[i - 1] - G[i - 1] + W[i - 1],
suf[i] = suf[i - 1] - G[i] + W[i - 1];
pre[N + 1] = Infll, nxt[N + 1] = stk[tp = 1] = N + 1;
for (int i = N; i >= 1; --i) {
while (pre[stk[tp]] <= pre[i]) --tp;
nxt[i] = stk[tp], stk[++tp] = i;
T[nxt[i]].push_back(i);
}
}
int main() {
Init();
Build(1, 1, N);
DFS(N + 1);
printf("%d\n", Ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long k, b, n, t, z = 1, cnt = 0;
cin >> k >> b >> n >> t;
while (z <= t) {
cnt++;
z = k * z + b;
}
cout << n - min(n, cnt - 1);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m, ans;
int a[300010];
char s[300010];
inline void prework() {
scanf("%d", &n);
scanf("%s", s + 1);
}
inline void mainwork() {
ans = n;
for (int i = 1; i <= n; i++)
if (s[i] == '1') ans = max(ans, max(2 * i, 2 * (n - i + 1)));
}
inline void print() { printf("%d\n", ans); }
int main() {
int t = 1;
scanf("%d", &t);
for (int i = 1; i <= t; i++) {
prework();
mainwork();
print();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
int n;
string s;
cin >> n;
cin >> s;
sort(s.begin(), s.end());
cout << s;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)(1e9);
const long long INF64 = (long long)(1e18);
const long double EPS = 1e-9;
const long double PI = 3.1415926535897932384626433832795;
map<int, int> visited;
int main() {
ios_base::sync_with_stdio(0);
int n, m;
scanf("%d %d", &n, &m);
vector<int> ans;
int x;
for (int i = 1; i <= n; ++i) {
scanf("%d", &x);
visited[x] = 1;
}
int start = 1, count = 0;
int sum = 0;
for (int i = 1; i <= m; ++i) {
if (visited.find(i) == visited.end()) {
if (m < i)
break;
else {
m -= i;
++count;
ans.push_back(i);
}
}
}
printf("%d\n", count);
for (int i = 0; i < count; ++i) {
printf("%d ", ans[i]);
}
printf("\n");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200020;
long long a;
int main() {
cin >> a;
long long l = 1, r = 1e18;
long long ans =
(((9 * (5 * (9 * (2 * (long long)1e17) % a) % a) % a) % a) + 1) % a;
cout << l + (a - ans) << ' ' << r + (a - ans) << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long a[200005];
long long b[200005];
int pos[200005];
int goal[200005];
int main() {
int n, m;
cin >> n >> m;
long long cf, cb;
int k;
cin >> cf >> k >> cb;
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
a[i] = x;
pos[x] = i;
}
bool can = true;
goal[1] = 0;
goal[m + 2] = n + 1;
for (int i = 1; i <= m; i++) {
int x;
cin >> x;
goal[i + 1] = pos[x];
b[i] = x;
if (goal[i + 1] == 0 || (goal[i] > goal[i + 1])) {
can = false;
}
}
if (!can) {
cout << -1 << '\n';
return 0;
}
long long res = 0;
for (int i = 2; i <= m + 2 && can; i++) {
int diff = goal[i] - goal[i - 1] - 1;
if (diff > 0) {
bool more = true;
for (int j = goal[i - 1] + 1; j <= goal[i] - 1; j++) {
if (a[j] > max(a[goal[i]], a[goal[i - 1]])) {
more = false;
}
}
if (more) {
int left = diff;
res += cb * (left % k);
left -= (left % k);
int possible = left / k;
if (k * cb > cf) {
res += cf * possible;
} else {
res += cb * k * possible;
}
} else {
if (diff < k) {
can = false;
} else {
int left = diff - k;
res += cb * (left % k);
left -= (left % k);
int possible = left / k;
if (k * cb > cf) {
res += cf * possible;
} else {
res += cb * k * possible;
}
res += cf;
}
}
}
}
if (!can) {
cout << -1 << '\n';
return 0;
}
cout << res << '\n';
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = INT_MAX;
const long long INFL = LLONG_MAX;
const long double pi = acos(-1);
vector<string> captain;
vector<string> man;
vector<string> rat;
vector<string> woman;
int main() {
ios_base::sync_with_stdio(0);
cout.precision(15);
cout << fixed;
cout.tie(0);
int N;
cin >> N;
for (int(i) = 1, j123 = N; (i) <= j123; (i)++) {
string s, t;
cin >> s >> t;
if (t == "captain") captain.push_back(s);
if (t == "man") man.push_back(s);
if (t == "rat") rat.push_back(s);
if (t == "child" || t == "woman") woman.push_back(s);
}
for (int(i) = 0, j123 = int(rat.size()); (i) < j123; (i)++)
cout << rat[i] << '\n';
for (int(i) = 0, j123 = int(woman.size()); (i) < j123; (i)++)
cout << woman[i] << '\n';
for (int(i) = 0, j123 = int(man.size()); (i) < j123; (i)++)
cout << man[i] << '\n';
for (int(i) = 0, j123 = int(captain.size()); (i) < j123; (i)++)
cout << captain[i] << '\n';
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n;
long long dp[200005], C, a[200005], b[200005];
;
long long ruia[200005], ruib[200005];
long long seg[(1 << 19)] = {};
void update(int k, long long a) {
k += (1 << 19) / 2 - 1;
seg[k] = a;
while (k > 0) {
k = (k - 1) / 2;
seg[k] = max(seg[k * 2 + 1], seg[k * 2 + 2]);
}
}
long long query(int a, int b, int k, int l, int r) {
if (r < a || b < l || a > b) return -1e18;
if (a <= l && r <= b)
return seg[k];
else {
long long vl = query(a, b, k * 2 + 1, l, (l + r) / 2);
long long vr = query(a, b, k * 2 + 2, (l + r) / 2 + 1, r);
return max(vl, vr);
}
}
int main() {
cin >> n >> C;
for (int i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
ruia[i] = ruia[i - 1] + a[i];
if (i != n) {
scanf("%lld", &b[i]);
ruib[i] = ruib[i - 1] + b[i];
}
}
dp[0] = 0;
fill(seg, seg + (1 << 19), -1e18);
update(0, ruia[n] + ruib[n - 1]);
for (int i = 1; i <= n; i++) {
dp[i] = max(dp[i], dp[i - 1] + min(C, a[i]));
if (a[i] >= C) continue;
int lb = -1, ub = i - 1;
while (ub - lb > 1) {
int mid = (lb + ub) / 2;
long long SUM = ruia[i] - ruia[mid];
SUM += ruib[i - 1] - ruib[mid];
if (SUM >= C)
lb = mid;
else
ub = mid;
}
if (lb >= 0) {
dp[i] = max(dp[i], dp[lb] + C);
}
long long val = query(lb + 1, i - 2, 0, 0, (1 << 18) - 1);
dp[i] = max(dp[i], val - (ruia[n] - ruia[i]) - (ruib[n - 1] - ruib[i - 1]));
update(i, dp[i] + ruia[n] - ruia[i] + ruib[n - 1] - ruib[i]);
}
cout << dp[n] << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
string s;
int solve(string text) {
int len = text.size();
if (text.size() % 2 == 1) {
return 0;
}
string s1 = text.substr(0, len / 2);
string s2 = text.substr(len / 2);
if (s1 != s2) {
return 1;
}
return solve(s1);
}
int main() {
cin >> s;
int len = s.size();
int all_equal = 1;
for (int i = 1; i < len / 2; i++) {
if (s[i] != s[i - 1]) all_equal = 0;
}
if (all_equal) {
cout << "Impossible" << endl;
return 0;
}
if (len % 2 == 1) {
cout << 2 << endl;
return 0;
}
if (solve(s)) {
cout << 1 << endl;
} else {
cout << 2 << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
string s1, s2, s3;
cin >> s1;
cin >> s2;
cin >> s3;
unordered_map<char, long long> counts;
for (long long i = 0; i < s1.length(); i++) counts[s1[i]]++;
for (long long i = 0; i < s2.length(); i++) counts[s2[i]]++;
for (long long i = 0; i < s3.length(); i++) counts[s3[i]]--;
for (auto &v : counts) {
if (v.second != 0) {
cout << "NO"
<< "\n";
return 0;
}
}
cout << "YES"
<< "\n";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
srand(time(NULL));
;
int t;
cin >> t;
while (t--) {
long long n, i;
cin >> n;
set<long long> s;
s.insert(1);
s.insert(n);
for (i = 2; i <= sqrt(n); i++) {
s.insert(n / i);
s.insert(i);
}
set<long long>::iterator it;
s.insert(0LL);
it = s.begin();
cout << s.size() << "\n";
for (it = s.begin(); it != s.end(); it++) {
cout << *it << " ";
}
cout << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
double pi = acos(-1);
int main() {
int i, j, k, n, r, R, cnt;
scanf("%d%d%d", &n, &R, &r);
if (r > R)
cnt = 0;
else if (r * 2 > R)
cnt = 1;
else if (r * 2 == R)
cnt = 2;
else {
double tmp = asin(r * 1. / (R - r));
if (tmp * n <= pi + 1e-12)
puts("YES");
else
puts("NO");
return 0;
}
if (cnt >= n)
puts("YES");
else
puts("NO");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
string s1, s2, s3;
cin >> s1 >> s2 >> s3;
string ans, left;
if (s1[1] == '<') {
reverse(s1.begin(), s1.end());
s1[1] = '>';
}
if (s2[1] == '<') {
reverse(s2.begin(), s2.end());
s2[1] = '>';
}
if (s3[1] == '<') {
reverse(s3.begin(), s3.end());
s3[1] = '>';
}
long long c = 1;
if (s1[0] == s2[0]) {
c++;
ans += s1[0];
left = s3;
} else if (s1[0] == s3[0]) {
c++;
ans += s1[0];
left = s2;
} else if (s2[0] == s3[0]) {
c++;
ans += s2[0];
left = s1;
}
if (c == 1)
cout << "Impossible";
else {
ans += left[0];
ans += left[2];
reverse(ans.begin(), ans.end());
cout << ans;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const int maxn = 100005;
inline int read() {
int res, ok = 1;
char ch;
for (ch = getchar(); ch < '0' || ch > '9'; ch = getchar())
if (ch == '-') ok = -1;
res = ch - '0';
for (ch = getchar(); ch >= '0' && ch <= '9'; ch = getchar())
res = res * 10 + ch - '0';
return res * ok;
}
int n, q, v[maxn], cnt[maxn][10], num[maxn][10], st, sum[15], ans[15];
char a[maxn];
inline bool check(char c) { return c == '<' || c == '>'; }
inline bool work(char c) { return c >= '0' && c <= '9'; }
inline int getin(int a, int b) {
if (b < a) return b;
return a;
}
int main() {
n = read();
q = read();
a[0] = 'X';
scanf("%s", a + 1);
while (st = find(v + 1, v + 1 + n, 0) - v, st <= n) {
int now = st, op = 1;
while (st <= now && now <= n) {
if (v[now] == 0) {
copy(sum, sum + 10, num[now]);
v[now]++;
}
if (work(a[now])) {
sum[a[now] - '0']++;
if (a[now] == '0')
a[now] = 'X';
else
a[now]--;
} else if (check(a[now]))
op = a[now] == '<' ? -1 : 1;
int x;
for (x = now + op; st <= x && x <= n && a[x] == 'X'; x += op) {
if (v[x] == 0 && op == 1) {
copy(sum, sum + 10, num[x]);
v[x]++;
} else if (v[x] == 1 && op == -1) {
copy(sum, sum + 10, cnt[x]);
v[x]++;
}
}
if (check(a[now]) && st <= x && x <= n && check(a[x])) a[now] = 'X';
if (v[now] == 1 && op == -1) {
copy(sum, sum + 10, cnt[now]);
v[now]++;
}
now = x;
}
}
copy(sum, sum + 10, num[n + 1]);
while (q--) {
int l, r;
l = read();
r = read();
copy(num[r + 1], num[r + 1] + 10, ans);
if (v[l] == 2)
for (int i = 0; i < 10; i++) ans[i] = getin(ans[i], cnt[l][i]);
for (int i = 0; i < 10; i++) printf("%d ", ans[i] - num[l][i]);
printf("\n");
}
return 0;
}
| 4 |
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
int k,n;
int main()
{
scanf("%d",&k);
if(k==1)
{
printf("1\n1");
return 0;
}
n=(k+3)/4*2;
printf("%d\n",n);
for(int i=1;i<=n;i++)
{
for(int j=1;j<=n;j++)
{
int val=(i+j-1)%n+1;
if(i%2) printf("%d ",val);
else printf("%d ",(val<=k-n?val+n:val));
}
printf("\n");
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long read() {
long long x = 0, f = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) {
x = x * 10 + c - '0';
c = getchar();
}
return x * f;
}
const int N = 50000 + 100;
struct road {
int w, to;
road(int A, int B) { to = A, w = B; }
};
vector<road> e[N];
int n, K, size[N], t_size, root;
bool t_vis[N], vis[N], done[N];
void GetSize(int now) {
t_vis[now] = true;
size[now] = 1;
for (int i = 0; i < int(e[now].size()); i++)
if (t_vis[e[now][i].to] == false and vis[e[now][i].to] == false) {
GetSize(e[now][i].to);
size[now] += size[e[now][i].to];
}
t_vis[now] = false;
}
void GetRoot(int now) {
t_vis[now] = true;
int OK = true, size_now = 1;
for (int i = 0; i < int(e[now].size()); i++)
if (t_vis[e[now][i].to] == false and vis[e[now][i].to] == false) {
GetRoot(e[now][i].to);
size_now += size[e[now][i].to];
if (size[e[now][i].to] > (t_size / 2)) OK = false;
}
if (t_size - size_now > (t_size / 2)) OK = false;
if (OK == true) root = now;
t_vis[now] = false;
}
int cnt[N], ans;
void dfs2(int now, int dis, int type) {
t_vis[now] = true;
if (type == 1 and K - dis >= 0) ans += cnt[K - dis];
if (type == 2) cnt[dis]++;
if (type == 3) cnt[dis]--;
for (int i = 0; i < int(e[now].size()); i++)
if (t_vis[e[now][i].to] == false and done[e[now][i].to] == true)
dfs2(e[now][i].to, dis + e[now][i].w, type);
t_vis[now] = false;
}
void dfs(int now) {
vis[now] = true;
vector<road> son;
son.reserve(32);
for (int i = 0; i < int(e[now].size()); i++)
if (vis[e[now][i].to] == false) {
GetSize(e[now][i].to), t_size = size[e[now][i].to];
GetRoot(e[now][i].to);
dfs(root);
son.push_back(e[now][i]);
}
for (int i = 0; i < int(son.size()); i++)
dfs2(son[i].to, son[i].w, 1), dfs2(son[i].to, son[i].w, 2);
for (int i = 0; i < int(son.size()); i++) dfs2(son[i].to, son[i].w, 3);
done[now] = true;
}
int main() {
n = read(), K = read();
for (int i = 1; i <= n; i++) e[i].reserve(4);
for (int i = 1; i < n; i++) {
int s = read(), t = read();
e[s].push_back(road(t, 1));
e[t].push_back(road(s, 1));
}
cnt[0]++;
GetSize(1), t_size = size[1];
GetRoot(1);
dfs(root);
printf("%d", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int c1 = 0, c2 = 0;
cin >> n;
string s;
cin >> s;
int i;
for (i = 0; i < s.size(); i++)
if (s[i] == 'A') {
c1++;
} else
c2++;
if (c2 == c1)
cout << "Friendship" << endl;
else if (c1 > c2)
cout << "Anton" << endl;
else if (c2 > c1)
cout << "Danik" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[1000010], vis[1010][1010];
int main() {
int n, m;
while (scanf("%d %d", &n, &m) == 2) {
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
a[i] = x % m;
}
if (n > m) {
printf("YES\n");
continue;
} else {
memset(vis, 0, sizeof(vis));
vis[0][a[0] % m] = 1;
for (int i = 1; i < n; i++) {
for (int j = 0; j < m; j++) {
if (vis[i - 1][j] == 1) {
vis[i][j] = 1;
vis[i][(j + a[i]) % m] = 1;
}
}
vis[i][a[i]] = 1;
}
if (vis[n - 1][0] == 1)
printf("YES\n");
else
printf("NO\n");
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int max_n = 100111, inf = 1000111222;
const int max_lev = 18;
int n, m, q, parent[max_lev][max_n], best_h[max_n], used[max_n], h[max_n];
int real_p[max_lev][max_n];
int tin[max_n], tout[max_n], cur = 1;
vector<int> g[max_n];
void dfs(int v, int p) {
tin[v] = cur++;
parent[0][v] = p;
real_p[0][v] = p;
real_p[0][v] = p;
for (int i = 1; i < max_lev; ++i) {
real_p[i][v] = real_p[i - 1][real_p[i - 1][v]];
}
for (int to : g[v]) {
if (tin[to]) {
if (tin[to] < tin[parent[0][v]]) {
parent[0][v] = to;
}
} else {
dfs(to, v);
if (tin[parent[0][to]] < tin[parent[0][v]]) {
parent[0][v] = parent[0][to];
}
}
}
tout[v] = cur++;
}
bool is_ancestor(int v1, int v2) {
return tin[v1] <= tin[v2] && tout[v1] >= tout[v2];
}
int lca(int v1, int v2) {
if (is_ancestor(v1, v2)) {
return v1;
}
for (int i = max_lev - 1; i >= 0; --i) {
if (!is_ancestor(real_p[i][v1], v2)) {
v1 = real_p[i][v1];
}
}
return real_p[0][v1];
}
int get_d(int v, int up) {
if (v == up) {
return 0;
}
int res = 1;
for (int i = max_lev - 1; i >= 0; --i) {
if (!is_ancestor(parent[i][v], up)) {
res += 1 << i;
v = parent[i][v];
}
}
return res;
}
int main() {
scanf("%d%d%d", &n, &m, &q);
while (m--) {
int u, v;
scanf("%d%d", &u, &v);
--u;
--v;
g[u].push_back(v);
g[v].push_back(u);
}
dfs(0, 0);
for (int lev = 1; lev < max_lev; ++lev) {
for (int i = 0; i < n; ++i) {
parent[lev][i] = parent[lev - 1][parent[lev - 1][i]];
}
}
while (q--) {
int u, v;
scanf("%d%d", &u, &v);
--u;
--v;
int lc = lca(u, v);
int ans = get_d(u, lc) + get_d(v, lc);
printf("%d\n", ans);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = (1 << 30) - 1;
const long long lINF = (1LL << 62) - 1;
const double dINF = 1e40;
const int MAXN = 101000;
vector<int> e[MAXN], adj[MAXN];
bool vis[MAXN];
int deep[MAXN];
vector<tuple<int, int, int> > res;
bool dfs(int u, int fath) {
vis[u] = true;
if (fath == -1)
deep[u] = 0;
else
deep[u] = deep[fath] + 1;
for (auto &v : e[u]) {
if (!vis[v]) {
if (dfs(v, u)) adj[u].push_back(v);
} else {
if (deep[v] < deep[u] - 1) adj[u].push_back(v);
}
}
bool r = true;
if (adj[u].size() & 1) adj[u].push_back(fath), r = false;
for (int i = 0; i < adj[u].size(); i += 2) {
res.push_back(make_tuple(adj[u][i], u, adj[u][i + 1]));
}
return r;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d%d", &u, &v);
e[u].push_back(v);
e[v].push_back(u);
}
bool flag = true;
for (int i = 1; i <= n; i++)
if (!vis[i]) {
if (!dfs(i, -1)) {
flag = false;
}
}
if (flag) {
for (auto &v : res) {
printf("%d %d %d\n", get<0>(v), get<1>(v), get<2>(v));
}
} else {
puts("No solution");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 110;
int n, a[maxN], sum = 0;
int i;
int main() {
cin >> n;
for (i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
}
sort(a, a + n);
i = 0;
while (round((double)(sum) / (double)n) < 5) {
sum += 5 - a[i];
i++;
}
cout << i << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void read_file(bool outToFile = true) {}
string s;
int n;
int main() {
read_file();
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
while (cin >> n) {
cin >> s;
vector<int> ans;
for (int i = 0; i < n; i++) {
if (s[i] == 'W') continue;
int j = i;
while (j < n && s[j] == 'B') j++;
ans.push_back(j - i);
i = j - 1;
}
int sz = ans.size();
printf("%d\n", sz);
for (int i = 0; i < sz; i++) printf("%d%c", ans[i], " \n"[i == sz - 1]);
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
string a;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, k, i, l = 0, r = 0, c = 0, ans = 0;
cin >> n >> k;
cin >> a;
for (i = 0; i < n; i++) {
if (a[i] != 'a') {
if (c < k) {
c++;
r++;
} else {
while (l < n && a[l] != 'b') l++;
l++;
r++;
}
} else
r++;
ans = max(ans, r - l);
}
l = 0;
r = 0;
c = 0;
for (i = 0; i < n; i++) {
if (a[i] != 'b') {
if (c < k) {
c++;
r++;
} else {
while (l < n && a[l] != 'a') l++;
l++;
r++;
}
} else
r++;
ans = max(ans, r - l);
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long Path1[1005][1005], Path2[1005][1005], Path3[1005][1005],
Path4[1005][1005], matrix[1005][1005];
int main() {
int n, m;
cin >> n >> m;
long long maxi = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) scanf("%I64d", &matrix[i][j]);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
Path1[i][j] =
max((i != 0 ? Path1[i - 1][j] : 0), (j != 0 ? Path1[i][j - 1] : 0)) +
matrix[i][j];
for (int i = n - 1; i >= 0; i--)
for (int j = 0; j <= m; j++)
Path2[i][j] = max((i != n - 1 ? Path2[i + 1][j] : 0),
(j != 0 ? Path2[i][j - 1] : 0)) +
matrix[i][j];
for (int i = 0; i < n; i++)
for (int j = m - 1; j >= 0; j--)
Path3[i][j] = max((i != 0 ? Path3[i - 1][j] : 0),
(j != m - 1 ? Path3[i][j + 1] : 0)) +
matrix[i][j];
for (int i = n - 1; i >= 0; i--)
for (int j = m - 1; j >= 0; j--)
Path4[i][j] = max((i != n - 1 ? Path4[i + 1][j] : 0),
(j != m - 1 ? Path4[i][j + 1] : 0)) +
matrix[i][j];
for (int i = 1; i < n - 1; i++)
for (int j = 1; j < m - 1; j++)
maxi = max(maxi, max(Path1[i - 1][j] + Path2[i][j - 1] + Path3[i][j + 1] +
Path4[i + 1][j],
Path1[i][j - 1] + Path2[i + 1][j] + Path3[i - 1][j] +
Path4[i][j + 1]));
cout << maxi;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int cap, m;
pair<int, int> s[40];
int main() {
cin >> cap >> m;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
s[i].first = y * -1;
s[i].second = x;
}
sort(s, s + m);
for (int i = 0; i < m; i++) s[i].first *= -1;
int sum = 0;
for (int i = 0; i < m; i++) {
int v = s[i].first, mucv = s[i].second;
if (mucv >= cap) {
sum += cap * v;
break;
} else {
cap -= mucv;
sum += v * mucv;
}
}
cout << sum;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 100 * 1000 + 50;
int a[maxN], b[maxN], seg[5 * maxN];
struct query {
int x, y, k;
} q[maxN];
void update(int t, int l, int r, int x, int s, int e) {
if (l == s && r == e) {
seg[x] = t;
return;
}
int mid = (s + e) / 2;
if (r > mid) update(t, max(l, mid), r, 2 * x + 1, mid, e);
if (l < mid) update(t, l, min(r, mid), 2 * x, s, mid);
}
int getmax(int k, int x, int s, int e) {
if (e - s < 2) return seg[x];
int mid = (s + e) / 2;
if (k < mid) return max(seg[x], getmax(k, 2 * x, s, mid));
return max(seg[x], getmax(k, 2 * x + 1, mid, e));
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) cin >> b[i];
int cnt = 0;
for (int i = 0; i < m; i++) {
int t, x, y, k;
cin >> t;
if (t == 1) {
cin >> x >> y >> k;
cnt++;
q[cnt].x = x;
q[cnt].y = y;
q[cnt].k = k;
update(cnt, y - 1, y + k - 1, 1, 0, n);
continue;
}
cin >> x;
int index = getmax(x - 1, 1, 0, n);
if (index == 0)
cout << b[x - 1] << endl;
else
cout << a[x - q[index].y + q[index].x - 1] << endl;
}
return 0;
}
| 5 |
#include <cstdio>
#include <vector>
#include <set>
#include <algorithm>
using namespace std;
typedef long long LL;
int n;
LL encode(const vector<char> &v){
LL a = 0;
for(int i = 0; i < n; ++i){
a |= (LL)v[i] << (i << 2);
}
return a;
}
vector<char> decode(LL x){
vector<char> v(n);
for(int i = 0; i < n; ++i){
v[i] = (x >> (i << 2)) & 15;
}
return v;
}
int main(){
scanf("%d", &n);
vector<char> s(n), goal(n);
int x;
for(int i = 0; i < n; ++i){
scanf("%d", &x);
s[i] = x;
goal[i] = i + 1;
}
if( s == goal ){
puts("0");
return 0;
}
vector<LL> v1, v2;
v1.push_back( encode(s) );
v2.push_back( encode(goal) );
set<LL> old;
old.insert( v1[0] );
old.insert( v2[0] );
int a;
for(int a = 1; ; ++a){
vector<LL> tmp;
for(int i = 0; i < v1.size(); ++i){
s = decode( v1[i] );
for(int j = 0; j < n - 1; ++j)
for(int k = j + 2; k <= n; ++k){
vector<char> t = s;
reverse(t.begin() + j, t.begin() + k);
LL u = encode(t);
if( binary_search(v2.begin(), v2.end(), u) ){
printf("%d\n", a);
return 0;
}
if( old.find(u) == old.end() ){
old.insert(u);
tmp.push_back(u);
}
}
}
sort(tmp.begin(), tmp.end());
v1.swap(tmp);
v1.swap(v2);
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
void __print(long long x) { cout << x; }
void __print(long x) { cout << x; }
void __print(unsigned x) { cout << x; }
void __print(unsigned long x) { cout << x; }
void __print(unsigned long long x) { cout << x; }
void __print(float x) { cout << x; }
void __print(double x) { cout << x; }
void __print(long double x) { cout << x; }
void __print(char x) { cout << '\'' << x << '\''; }
void __print(const char *x) { cout << '\"' << x << '\"'; }
void __print(const string &x) { cout << '\"' << x << '\"'; }
void __print(bool x) { cout << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cout << '{';
__print(x.first);
cout << ',';
__print(x.second);
cout << '}';
}
template <typename T>
void __print(const T &x) {
long long f = 0;
cout << '{';
for (auto &i : x) cout << (f++ ? "," : ""), __print(i);
cout << "}";
}
void _print() { cout << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cout << ", ";
_print(v...);
}
const long long INF64 = 1e18;
const long long INF32 = 1e9;
const long long BIG = (long long)(1e9 + 239);
const long long MOD = 1000000007;
const double PI = 2.0 * acos(0.0);
const double EPS = static_cast<double>(1e-10);
const long long day[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
const long long dx[4] = {0, 1, 0, -1};
const long long dy[4] = {1, 0, -1, 0};
mt19937 rnd(239);
typedef vector<vector<long long>> matrix;
void FILEIO() {
freopen("in.txt", "r", stdin);
freopen("out.txt", "w", stdout);
}
long long mostSignDigit(long long n) {
double k = log10(n);
return pow(10, k - floor(k));
}
long long numOfDigits(long long n) { return floor(log10(n)) + 1; }
bool isPowerOfTwo(long long x) { return x && (!(x & (x - 1))); }
bool allPositive(vector<long long> &a) {
return all_of(begin(a), end(a), [](long long x) { return x > 0; });
}
bool anyPositive(vector<long long> &a) {
return any_of(begin(a), end(a), [](long long x) { return x > 0; });
}
bool nonePositive(vector<long long> &a) {
return none_of(begin(a), end(a), [](long long x) { return x > 0; });
}
void solve() {
string s;
cin >> s;
long long n = ((long long)(s).size());
vector<char> v0, v1;
for (long long i = (0); i < (n); i++)
if (((long long)s[i] - (long long)'0') % 2 == 0)
v0.push_back(s[i]);
else
v1.push_back(s[i]);
long long id0 = 0, id1 = 0;
string ans = "";
while (id0 < ((long long)(v0).size()) and id1 < ((long long)(v1).size())) {
if ((long long)v0[id0] < (long long)v1[id1]) {
ans.push_back(v0[id0]);
id0++;
}
if ((long long)v0[id0] > (long long)v1[id1]) {
ans.push_back(v1[id1]);
id1++;
}
}
if (id0 == ((long long)(v0).size()))
for (long long i = (id1); i < (((long long)(v1).size())); i++)
ans.push_back(v1[i]);
if (id1 == ((long long)(v1).size()))
for (long long i = (id0); i < (((long long)(v0).size())); i++)
ans.push_back(v0[i]);
cout << ans << endl;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie();
long long t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void swap(long long &a, long long &b) {
long long t;
t = a;
a = b;
b = t;
}
int main() {
ios_base::sync_with_stdio(0);
std::cin.tie(0);
std::cout.tie(0);
long long n1, n2, k1, k2;
cin >> n1 >> n2 >> k1 >> k2;
if (n1 > n2)
cout << "First" << endl;
else
cout << "Second" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
char s1[1000005];
char s2[1000005];
int main() {
gets(s1);
gets(s2);
int len1 = strlen(s1);
int len2 = strlen(s2);
if (len1 != len2) {
cout << "NO" << endl;
} else {
int ans1 = 0;
int ans2 = 0;
for (int i = 0; i < len1; i++) {
if (s1[i] == '1') {
ans1++;
}
}
for (int i = 0; i < len2; i++) {
if (s2[i] == '1') {
ans2++;
}
}
if ((ans1 == 0 && ans2 != 0) || (ans1 != 0 && ans2 == 0)) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const double PI = 3.14159265358979323846;
const double EPS = 1e-15;
const int INF = 1e9 + 7;
const long long LINF = 8e18 + 7;
const int N = 2e5 + 7;
vector<long long> t[4 * N];
int a[N];
long long s[N];
void build(int v, int L, int R) {
if (L + 1 == R) {
t[v].push_back(s[L]);
return;
}
int M = L + R >> 1;
build(v << 1, L, M);
build(v << 1 | 1, M, R);
t[v].resize(t[v << 1].size() + t[v << 1 | 1].size());
merge(t[v << 1].begin(), t[v << 1].end(), t[v << 1 | 1].begin(),
t[v << 1 | 1].end(), t[v].begin());
}
int get(int v, int L, int R, int l, int r, long long val) {
if (L == l && R == r) {
return t[v].end() - upper_bound(t[v].begin(), t[v].end(), val);
}
int M = L + R >> 1;
int ans = 0;
if (l < M) {
ans += get(v << 1, L, M, l, min(M, r), val);
}
if (r > M) {
ans += get(v << 1 | 1, M, R, max(l, M), r, val);
}
return ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
long long t;
cin >> n >> t;
for (int i = 0; i < int(n); ++i) {
cin >> a[i];
s[i + 1] = a[i] + s[i];
}
build(1, 0, n + 1);
long long ans = 0;
for (int i = 0; i < int(n); ++i) {
ans += get(1, 0, n + 1, 0, i + 1, s[i + 1] - t);
}
cout << ans << endl;
}
| 4 |
#include <iostream>
using namespace std;
int main()
{long long t,n,p=0;
cin>>t;
while(t--)
{long long cnt=0,s;
p=9;
cin>>n;
while(n>p)
{p=p*10+9;
cnt++;}
s=cnt*9+n/(p/9);
cout<<s<<'\n';
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1003;
const long long M = 1000000007;
long long ast(long long x, int n) {
if (n == 0) return 1;
if (n % 2 == 0) {
long long y = ast(x, n / 2);
return (y * y) % M;
} else {
long long y = ast(x, n - 1);
return (y * x) % M;
}
}
long long baz(long long x, long long y) { return (x * ast(y, M - 2)) % M; }
void ass(vector<pair<int, int> >& v, int n) {
for (int i = 0; i < n; ++i) v.push_back(make_pair(0, 0));
}
pair<int, int> operator*(const pair<int, int>& a, const pair<int, int>& b) {
return make_pair(a.first + b.first, a.second + b.second);
}
pair<int, int> operator/(const pair<int, int>& a, const pair<int, int>& b) {
return make_pair(a.first - b.first, a.second - b.second);
}
bool operator!(const pair<int, int>& a) {
return (a.first < 0 && a.second < 0);
}
bool operator>(const pair<int, int>& x, const pair<int, int>& y) {
if (x.first < 0 || x.second < 0) cout << "";
pair<int, int> a = x, b = y;
if (a.second == b.second) return a.first > b.first;
double t = (b.first - a.first) * 1.0 / (a.second - b.second) * 1.0;
if (a.second < b.second) {
if (t >= 2) return true;
return pow(2, t) > 3.0;
} else {
if (t >= 2) return false;
return pow(2, t) < 3.0;
}
}
void ubd(vector<pair<int, int> >& t, int tl, int tr, int x, int y, int pos) {
tl++;
tr++;
x++;
pair<int, int> z;
if (y == 0)
z = make_pair(-N, -N);
else if (y == 1)
z = make_pair(0, 0);
else if (y == 2)
z = make_pair(1, 0);
else
z = make_pair(0, 1);
while (x <= tr) {
t[x] = t[x] * z;
x += (x & (-x));
}
}
pair<int, int> qry(vector<pair<int, int> >& t, int tl, int tr, int l, int r,
int pos) {
if (l < tl || r > tr) return make_pair(-N, -N);
tl++;
tr++;
l++;
r++;
pair<int, int> ans = make_pair(0, 0);
int x = r;
while (x > 0) {
ans = ans * t[x];
x -= (x & (-x));
}
x = l - 1;
while (x > 0) {
ans = ans / t[x];
x -= (x & (-x));
}
return ans;
}
int n;
char b[N][N];
int a[N][N];
vector<pair<int, int> > t1[N], t2[N];
vector<pair<int, int> > b1[N * 2], b2[N * 2];
int pos1[N][N], pos2[N][N];
vector<pair<int, int> > t3[N * 2], t4[N * 2];
pair<int, int> ans;
int main() {
bool zz = true;
cin >> n;
for (int i = 0; i < n; ++i) cin >> b[i];
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
a[i][j] = b[i][j] - '0';
if (a[i][j]) zz = false;
}
}
if (zz) {
cout << 0 << endl;
return 0;
}
for (int i = 0; i < n; ++i) {
ass(t1[i], n * 4);
for (int j = 0; j < n; ++j) {
ubd(t1[i], 0, n - 1, j, a[i][j], 1);
}
}
for (int j = 0; j < n; ++j) {
ass(t2[j], n * 4);
for (int i = 0; i < n; ++i) {
ubd(t2[j], 0, n - 1, i, a[i][j], 1);
}
}
for (int t = -(n - 1); t <= (n - 1); ++t) {
for (int i = 0; i < n; ++i) {
int j = t + i;
t += (n - 1);
if (0 <= j && j < n) b1[t].push_back(make_pair(i, j));
t -= (n - 1);
}
t += (n - 1);
ass(t3[t], b1[t].size() * 4);
for (int i = 0; i < b1[t].size(); ++i) {
ubd(t3[t], 0, b1[t].size() - 1, i, a[b1[t][i].first][b1[t][i].second], 1);
pos1[b1[t][i].first][b1[t][i].second] = i;
}
t -= (n - 1);
}
for (int g = 0; g <= (n - 1) + (n - 1); ++g) {
for (int i = 0; i < n; ++i) {
int j = g - i;
if (0 <= j && j < n) b2[g].push_back(make_pair(i, j));
}
ass(t4[g], b2[g].size() * 4);
for (int i = 0; i < b2[g].size(); ++i) {
ubd(t4[g], 0, b2[g].size() - 1, i, a[b2[g][i].first][b2[g][i].second], 1);
pos2[b2[g][i].first][b2[g][i].second] = i;
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
if (!a[i][j]) continue;
int l = 0, r = n / 2;
while ((r - l) > 4) {
int m = (l + r) / 2;
int dd = i - m;
int uu = i + m;
int ll = j - m;
int rr = j + m;
pair<int, int> z =
(qry(t1[i], 0, n - 1, ll, rr, 1) * qry(t2[j], 0, n - 1, dd, uu, 1));
if (a[i][j] == 2) z.first--;
if (a[i][j] == 3) z.second--;
if (!!(z))
l = m;
else
r = m;
}
for (int m = r; m >= l; --m) {
int dd = i - m;
int uu = i + m;
int ll = j - m;
int rr = j + m;
pair<int, int> z =
(qry(t1[i], 0, n - 1, ll, rr, 1) * qry(t2[j], 0, n - 1, dd, uu, 1));
if (a[i][j] == 2) z.first--;
if (a[i][j] == 3) z.second--;
if (!!(z)) {
if ((z) > ans) ans = z;
break;
}
}
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
if (!a[i][j]) continue;
int l = 0, r = n / 2;
int t = j - i;
int g = i + j;
t += (n - 1);
while ((r - l) > 4) {
int m = (l + r) / 2;
int dd = pos1[i][j] - m;
int uu = pos1[i][j] + m;
int ll = pos2[i][j] - m;
int rr = pos2[i][j] + m;
pair<int, int> z = (qry(t3[t], 0, b1[t].size() - 1, dd, uu, 1) *
qry(t4[g], 0, b2[g].size() - 1, ll, rr, 1));
if (a[i][j] == 2) z.first--;
if (a[i][j] == 3) z.second--;
if (!!(z))
l = m;
else
r = m;
}
for (int m = r; m >= l; --m) {
int dd = pos1[i][j] - m;
int uu = pos1[i][j] + m;
int ll = pos2[i][j] - m;
int rr = pos2[i][j] + m;
pair<int, int> z = (qry(t3[t], 0, b1[t].size() - 1, dd, uu, 1) *
qry(t4[g], 0, b2[g].size() - 1, ll, rr, 1));
if (a[i][j] == 2) z.first--;
if (a[i][j] == 3) z.second--;
if (!!(z)) {
if ((z) > ans) ans = z;
break;
}
}
}
}
cout << (ast(2, ans.first) * ast(3, ans.second)) % M << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 105;
double sqr(double d) { return d * d; }
bool deql(double a, double b) { return fabs(a - b) < 1e-10; }
bool triangle(double a, double b, double c) { return a * a + b * b >= c * c; }
bool square(double a, double b, double c) {
return deql(a * a + b * b, c * c) && deql(a, b);
}
struct Point {
double x, y;
Point(double a = 0, double b = 0) : x(a), y(b) {}
bool operator==(const Point &b) const { return x == b.x && y == b.y; }
} pt[N];
double dis(const Point &a, const Point &b) {
return sqrt(sqr(a.x - b.x) + sqr(a.y - b.y));
}
Point *circumcenter(const Point &x, const Point &y, const Point &z) {
static Point p;
double A2, B2, A1, B1, C2, C1, d, d1, d2;
A1 = 2 * (y.x - x.x);
B1 = 2 * (y.y - x.y);
C1 = sqr(y.x) - sqr(x.x) + sqr(y.y) - sqr(x.y);
A2 = 2 * (z.x - y.x);
B2 = 2 * (z.y - y.y);
C2 = sqr(z.x) - sqr(y.x) + sqr(z.y) - sqr(y.y);
d = A1 * B2 - B1 * A2;
d1 = C1 * B2 - B1 * C2;
d2 = A1 * C2 - C1 * A2;
if (d == 0.0) return 0;
return &(p = Point(d1 / d, d2 / d));
}
int n;
double getmin(Point x) {
double r = 1e9;
for (int i = 1; i <= n; ++i) r = min(r, dis(pt[i], x));
return r;
}
int main() {
Point v, w, *tmp;
double ans = -1;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%lf%lf", &pt[i].x, &pt[i].y);
for (int i = 1; i <= n; ++i)
for (int j = i + 1; j <= n; ++j)
for (int k = j + 1; k <= n; ++k) {
Point x = pt[i], y = pt[j], z = pt[k];
double a = dis(y, z), b = dis(x, y), c = dis(x, z), d;
if (square(b, c, a)) swap(c, a), swap(x, y);
if (square(a, c, b)) swap(c, b), swap(y, z);
if (square(a, b, c)) {
v = Point((x.x + z.x) / 2.0, (x.y + z.y) / 2);
w = Point(v.x * 2 - y.x, v.y * 2 - y.y);
for (int l = 1; l <= n; ++l)
if (pt[l] == w) {
double t = getmin(v);
if (t * 2 > a && ans < t) ans = t;
break;
}
}
tmp = circumcenter(x, y, z);
if (!tmp) continue;
if (!triangle(a, b, c) || !triangle(a, c, b) || !triangle(b, c, a))
continue;
double mx = max(a, max(b, c)), t = getmin(*tmp);
if (t * 2 > mx && ans < t) ans = t;
}
if (ans < 0)
puts("-1");
else
printf("%.9lf", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
string str;
cin >> str;
set<string> st;
queue<string> que;
st.insert(str), que.push(str);
int sum = 0;
while (!que.empty()) {
string s = que.front();
que.pop();
for (int i = 0; i < s.size(); i++) {
string temp = s;
temp.erase(i, 1);
if (!st.count(temp) && st.size() < m) {
st.insert(temp);
que.push(temp);
sum += n - temp.size();
}
}
}
if (st.size() < m)
cout << -1;
else
cout << sum;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int arr[800], n;
long long bb[800], Hi, lo;
priority_queue<int> Q;
int lappa(long long q) {
long long sum = q;
int cnt = 0;
while (!Q.empty()) Q.pop();
for (int j = 0; j < n; j++) {
sum += arr[j];
Q.push(-arr[j]);
while (sum < 0 && !Q.empty()) {
sum += Q.top();
Q.pop();
cnt++;
}
}
return cnt;
}
long long ans_n(int p) {
long long l = lo, h = Hi, mid;
while (l > h) {
mid = (l + h - 1) / 2;
int k = lappa(mid);
if (p < k)
h = mid + 1;
else
l = mid;
}
return l;
}
int main() {
int m, j;
scanf("%d%d", &n, &m);
long long s1 = 1e9;
long long s2 = 0, s3 = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &arr[i]);
s3 += arr[i];
s1 = min(s1, s3);
if (arr[i] > 0) s2 += arr[i];
}
bb[0] = -s1;
Hi = -s2;
lo = -s1;
for (int i = n - 1; i >= 0; i--) {
bb[i] = ans_n(i);
}
long long q;
for (int i = 0; i < m; i++) {
scanf("%lld", &q);
for (j = 0; j < n; j++) {
if (bb[j] <= q) break;
}
printf("%d\n", j);
}
return 0;
}
| 6 |
#include<bits/stdc++.h>
#define ll long long
#define pb push_back
#define lowbit(x) ((x)&(-(x)))
#define mid ((l+r)>>1)
#define lson rt<<1, l, mid
#define rson rt<<1|1, mid+1, r
#define fors(i, a, b) for(int i = (a); i < (b); ++i)
#define all(vec) vec.begin(),vec.end()
using namespace std;
const int maxn = 505;
char mp[maxn][maxn];
int n, m;
int main()
{
int T;cin>>T;
while(T--){
scanf("%d%d", &n, &m);
fors(i,1,n+1) scanf("%s",mp[i]+1);
for(int i=1; i <= n; i += 3){
fors(j,1,m+1) mp[i][j]='X';
}
for(int i = 3; i < n; i += 3){
int x = -1, y = -1;
fors(j,1,m+1){
if(mp[i][j]=='X'){x = i; y = j; break;}
}
if(x!=-1){
mp[x-1][y] = 'X'; continue;
}
fors(j,1,m+1){
if(mp[i-1][j]== 'X'){x = i-1; y = j; break;}
}
if(x!=-1){
mp[x+1][y] = 'X'; continue;
}
mp[i][1]=mp[i-1][1] = 'X';
}
if(n%3 == 0){
fors(i,1,m+1) if(mp[n][i]=='X') mp[n-1][i] = 'X';
}
fors(i,1,n+1) printf("%s\n", mp[i]+1);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[100],b[100],c[100];
int main()
{
int n,sum=0;
cin>>n;
for(int i=1;i<=n;i++)
cin>>a[i];
for(int i=1;i<=n;i++)
{
cin>>b[i];
sum+=b[i];
}
for(int i=1;i<n;i++)
cin>>c[i];
for(int i=1;i<n;i++)
{
if(a[i]+1==a[i+1])
sum+=c[a[i]];
}
cout<<sum;
return 0;
} | 0 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
const int INF = (1 << 29) + 5;
const long long int LLINF = (1ll << 60) + 5;
const int MOD = 1000 * 1000 * 1000 + 7;
const int MAX_N = 2000 * 100 + 5;
int n;
int arr1[MAX_N];
int arr2[MAX_N];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d", &arr1[i]);
}
for (int i = 0; i < n; ++i) {
scanf("%d", &arr2[i]);
}
int ptr1 = 0;
int ptr2 = 0;
for (int i = 0; i < n; ++i) {
if (arr1[i] == 1) {
ptr1 = i;
}
if (arr2[i] == 1) {
ptr2 = i;
}
}
ptr1 = (ptr1 + 1) % n;
ptr2 = (ptr2 + 1) % n;
while (arr1[ptr1] != 1 && arr2[ptr2] != 1 && n != 2) {
if (arr1[ptr1] == 0) {
ptr1 = (ptr1 + 1) % n;
}
if (arr2[ptr2] == 0) {
ptr2 = (ptr2 + 1) % n;
}
if (arr1[ptr1] != arr2[ptr2]) {
printf("NO");
return 0;
}
ptr1 = (ptr1 + 1) % n;
ptr2 = (ptr2 + 1) % n;
if (arr1[ptr1] == 0) {
ptr1 = (ptr1 + 1) % n;
}
if (arr2[ptr2] == 0) {
ptr2 = (ptr2 + 1) % n;
}
}
printf("YES");
fclose(stdin);
fclose(stdout);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct type {
long long k, i, j;
};
bool isPrime(long long n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (long long i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
long long findSubarray(long long arr[], long long n, long long k) {
long long window_sum = 0;
long long min_window = INT_MAX;
long long last = 0;
for (long long i = 0; i < n; i++) {
window_sum += arr[i];
if (i + 1 >= k) {
if (min_window > window_sum) {
min_window = window_sum;
last = i;
}
window_sum -= arr[i + 1 - k];
}
}
long long sum = 0;
for (long long i = last - k + 1; i <= last; i++) {
sum += arr[i];
}
return sum;
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n;
cin >> n;
vector<long long> a(n), b;
for (long long i = 0; i < n; i++) cin >> a[i];
set<long long> s;
for (long long i = 0; i < n; i++) s.insert(a[i]);
vector<long long> c;
for (long long i = 0; i <= n; i++) {
if (s.find(i) == s.end()) {
c.push_back(i);
}
}
b.push_back(c[0]);
long long x = 1;
for (long long i = 1; i < n; i++) {
if (a[i] == a[i - 1]) {
b.push_back(c[x]);
x++;
} else {
b.push_back(a[i - 1]);
}
}
if (b.size() == 0)
cout << "-1"
<< "\n";
for (auto x : b) cout << x << " ";
cout << "\n";
}
| 3 |
#include<iostream>
#include<vector>
#include<bitset>
using namespace std;
int X, Y, n;
vector<vector<int>> s;
vector<vector<int>> answer;
vector<int> area;
// id, 左上, 右下
bool placeable(vector<vector<int>> field, int id, int y1, int x1, int y2, int x2) {
bool ok = false;
for(int i = y1; i <= y2; ++i) for(int j = x1; j <= x2; ++j) {
if(field[i][j] && field[i][j] != id) return false;
if(field[i][j] == id) ok = true;
}
return ok;
}
vector<vector<int>> place(vector<vector<int>> field, int id, int y1, int x1, int y2, int x2) {
for(int i = y1; i <= y2; ++i) for(int j = x1; j <= x2; ++j) field[i][j] = id;
return field;
}
bool in(int y, int x) {
return 0 <= y && y < Y && 0 <= x && x < X;
}
int dfs(vector<vector<int>> field, bitset<16> used) {
if(used.count() == n) {
answer = field;
return 1;
}
int y, x;
y = x = -1;
for(int i = 0; y == -1 && i < Y; ++i) for(int j = 0; x == -1 && j < X; ++j) if(!used[field[i][j]]) {
y = i;
x = j;
}
int result = 0;
for(int id = 1; id <= n; ++id) {
if(used[id]) continue;
if(field[y][x] && field[y][x] != id) continue;
int a = area[id];
for(int i = 1; i <= a; ++i) {
if(a % i) continue;
int j = a / i;
int ny = y + i - 1;
int nx = x + j - 1;
if(!in(ny, nx)) continue;
if(!placeable(field, id, y, x, ny, nx)) continue;
result += dfs(place(field, id, y, x, ny, nx), used.set(id));
used.reset(id);
}
/*
for(int t = 0; t < a; ++t) {
int i = y + t;
int j = x + a / (t + 1) - 1;
if(!in(i, j)) continue;
if(!placeable(field, id, y, x, i, j)) continue;
result += dfs(place(field, id, y, x, i, j), used.set(id));
used.reset(id);
}
*/
}
return result;
}
int main() {
while(cin >> X >> Y >> n, X | Y | n) {
area.clear();
area.resize(n + 1);
for(int i = 0; i < n; ++i) {
int b, k;
cin >> b >> k;
area[b] = k;
}
s.clear();
s.resize(Y, vector<int>(X));
for(auto& y: s) for(auto& x: y) cin >> x;
if(dfs(s, 0) == 1) {
for(int i = 0; i < Y; ++i) {
for(int j = 0; j < X; ++j) cout << (j ? " " : "") << answer[i][j];
cout << endl;
}
} else {
cout << "NA" << endl;
}
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1, c = getchar();
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) {
x = (x << 1) + (x << 3) + (c ^ 48);
c = getchar();
}
return f == 1 ? x : -x;
}
const int N = 2e5 + 4;
int n, Q, k, dfn[N];
long long ans, ans2;
namespace vars {
int tim, siz[N], fa[N], dep[N], son[N], top[N], idx[N];
}
namespace sz {
using namespace vars;
int t[N];
inline void clear() { memset(t, 0, sizeof(t)); }
inline void add(int x, int v) {
for (; x <= n; x += x & -x) t[x] += v;
}
inline int ask(int x) {
int ret = 0;
for (; x; x -= x & -x) ret += t[x];
return ret;
}
inline void additv(int x, int v) {
add(dfn[x], v);
add(dfn[x] + siz[x], -v);
}
inline int askitv(int x) { return ask(dfn[x] + siz[x] - 1) - ask(dfn[x] - 1); }
} // namespace sz
namespace slpf {
inline int jpk(int x, int y, int lca);
}
namespace vt {
vector<int> e[N], vec[N];
int rt, siz[N], son[N];
void dfs_5(int x) {
siz[x] = vec[x].size();
son[x] = 0;
for (auto v : e[x]) {
dfs_5(v);
siz[x] += siz[v];
if (siz[v] > siz[son[x]]) son[x] = v;
}
}
inline void calc_7(int x, int fl, int anc) {
int qwq;
for (auto v : vec[x]) {
qwq = slpf::jpk(anc, v, rt);
if (qwq != -1) ans += fl * sz::askitv(qwq);
}
}
void dfs_7(int x, int fl, int anc) {
calc_7(x, fl, anc);
for (auto v : e[x]) dfs_7(v, fl, anc);
}
inline void calc_8(int x, int fl) {
for (auto v : vec[x]) {
sz::add(dfn[v], fl);
}
}
void dfs_8(int x, int fl) {
calc_8(x, fl);
for (auto v : e[x]) dfs_8(v, fl);
}
void dfs_6(int x, int fl) {
for (auto v : e[x])
if (v != son[x]) dfs_6(v, 0);
calc_7(x, -1, x);
for (auto v : e[x])
if (v != son[x]) dfs_7(v, -1, x);
if (son[x]) dfs_6(son[x], 1);
if (x == rt) {
if (son[x]) dfs_8(son[x], -1);
return;
}
int qwq;
for (auto v : vec[x]) {
qwq = slpf::jpk(x, v, rt);
if (qwq != -1) ans += sz::askitv(qwq);
sz::add(dfn[v], 1);
}
for (auto v : e[x])
if (v != son[x]) {
dfs_7(v, 1, x);
dfs_8(v, 1);
}
if (!fl) dfs_8(x, -1);
}
void dfs_9(int x) {
for (auto v : e[x]) dfs_9(v);
e[x].clear();
vec[x].clear();
}
inline void solve() {
dfs_5(rt);
dfs_6(rt, 0);
dfs_9(rt);
}
} // namespace vt
namespace slpf {
using namespace vars;
vector<int> e[N];
vector<pair<int, int> > vec[N];
void dfs_1(int x) {
siz[x] = 1;
for (auto v : e[x])
if (v != fa[x]) {
fa[v] = x;
dep[v] = dep[x] + 1;
dfs_1(v);
siz[x] += siz[v];
if (siz[v] > siz[son[x]]) son[x] = v;
}
}
void dfs_2(int x, int tp) {
top[x] = tp;
idx[dfn[x] = ++tim] = x;
if (son[x]) dfs_2(son[x], tp);
for (auto v : e[x])
if (v != fa[x] && v != son[x]) dfs_2(v, v);
}
inline int jump(int x, int k) {
if (k < 0) return -1;
if (k >= dep[x]) return 1;
while (dep[x] - dep[top[x]] < k) {
k -= dep[x] - dep[top[x]] + 1;
x = fa[top[x]];
}
return idx[dfn[x] - k];
}
inline int jpk(int x, int y, int lca) {
if (dep[x] - dep[lca] >= k) return jump(y, dep[y] - dep[lca] - 1);
return jump(y, dep[x] + dep[y] - dep[lca] * 2 - k);
}
inline int getlca(int x, int y) {
while (top[x] != top[y]) {
if (dep[top[x]] > dep[top[y]])
x = fa[top[x]];
else
y = fa[top[y]];
}
return dep[x] < dep[y] ? x : y;
}
struct QWQ {
int u, v, au, av;
QWQ() {}
QWQ(int x, int y, int z, int w) : u(x), v(y), au(z), av(w) {}
} qwq[N];
inline bool comp_qwq(const QWQ &a, const QWQ &b) {
return a.au < b.au || (a.au == b.au && a.av < b.av);
}
void dfs_3(int x) {
for (auto v : vec[x]) ans -= sz::ask(dfn[v.first]) + sz::ask(dfn[v.second]);
for (auto v : e[x])
if (v != fa[x]) dfs_3(v);
int cqwq = 0;
for (auto v : vec[x]) {
++cqwq;
qwq[cqwq] =
QWQ(v.first, v.second,
v.first == x ? -cqwq : jump(v.first, dep[v.first] - dep[x] - 1),
jump(v.second, dep[v.second] - dep[x] - 1));
}
sort(qwq + 1, qwq + cqwq + 1, comp_qwq);
for (int i = 1, las = 0; i <= cqwq; i++) {
ans += sz::ask(dfn[qwq[i].u]) + sz::ask(dfn[qwq[i].v]);
if (i == cqwq || qwq[i].au != qwq[i + 1].au || qwq[i].av != qwq[i + 1].av) {
for (int j = i; j > las; j--) {
if (dep[qwq[j].u] - dep[x] >= k)
sz::additv(jump(qwq[j].u, dep[qwq[j].u] - dep[x] - k), 1);
if (dep[qwq[j].v] - dep[x] >= k)
sz::additv(jump(qwq[j].v, dep[qwq[j].v] - dep[x] - k), 1);
}
las = i;
}
}
}
int tp, st[N], b[N];
inline void insert(int x) {
if (tp < 2) {
st[++tp] = x;
return;
}
int lca = getlca(st[tp], x);
if (lca == st[tp]) {
st[++tp] = x;
return;
}
while (tp > 1 && dfn[st[tp - 1]] >= dfn[lca]) {
vt::e[st[tp - 1]].push_back(st[tp]);
tp--;
}
if (st[tp] != lca) {
vt::e[lca].push_back(st[tp]);
st[tp] = lca;
}
st[++tp] = x;
}
inline bool comp_dfn(int x, int y) { return dfn[x] < dfn[y]; }
inline void rebuild() {
sort(b + 1, b + b[0] + 1, comp_dfn);
b[0] = unique(b + 1, b + b[0] + 1) - b - 1;
tp = 0;
for (int i = 1; i <= b[0]; i++) insert(b[i]);
while (tp > 1) {
vt::e[st[tp - 1]].push_back(st[tp]);
tp--;
}
}
void dfs_4(int x) {
for (auto v : e[x])
if (v != fa[x]) dfs_4(v);
if (vec[x].empty()) return;
b[b[0] = 1] = x;
for (auto v : vec[x])
if (v.first != x) {
b[++b[0]] = v.first;
vt::vec[v.first].push_back(v.second);
}
rebuild();
vt::rt = x;
vt::solve();
}
} // namespace slpf
int main() {
n = read();
Q = read();
k = read();
for (int i = 1, u, v; i < n; i++) {
u = read();
v = read();
slpf::e[u].push_back(v);
slpf::e[v].push_back(u);
}
slpf::dfs_1(1);
slpf::dfs_2(1, 1);
for (int u, v, lca; Q--;) {
u = read();
v = read();
if (dfn[u] > dfn[v]) u ^= v ^= u ^= v;
lca = slpf::getlca(u, v);
slpf::vec[lca].push_back(make_pair(u, v));
}
slpf::dfs_3(1);
sz::clear();
slpf::dfs_4(1);
cout << ans << "\n";
return (0 - 0);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, l, s, re, d;
int a[30];
int gcd(int a, int b) {
int r;
while (a % b != 0) {
r = a;
a = b;
b = r % b;
}
return b;
}
int main() {
bool v;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
l += a[i];
if (a[i] % 2 == 1) {
s++;
re = i;
}
}
if (l % 2 == 1) {
if (s > 1) {
puts("0");
for (int i = 1; i <= n; i++)
for (int j = 1; j <= a[i]; j++) printf("%c", (char)('a' + i - 1));
} else {
d = a[1];
for (int i = 2; i <= n; i++) d = gcd(d, a[i]);
printf("%d\n", d);
for (int i = 1; i <= d; i++) {
for (int j = 1; j <= n; j++)
for (int k = 1; k <= (a[j] / d) / 2; k++)
printf("%c", (char)('a' + j - 1));
printf("%c", (char)('a' + re - 1));
for (int j = n; j; j--)
for (int k = 1; k <= (a[j] / d) / 2; k++)
printf("%c", (char)('a' + j - 1));
}
puts("");
}
return 0;
}
d = a[1];
for (int i = 2; i <= n; i++) d = gcd(d, a[i]);
if (d % 2 == 1) {
puts("0");
for (int i = 1; i <= n; i++)
for (int j = 1; j <= a[i]; j++) printf("%c", (char)('a' + i - 1));
return 0;
}
printf("%d\n", d);
v = 0;
for (int i = 1; i <= d; i++) {
if (!v)
for (int j = 1; j <= n; j++)
for (int k = 1; k <= a[j] / d; k++) printf("%c", (char)('a' + j - 1));
else
for (int j = n; j; j--)
for (int k = 1; k <= a[j] / d; k++) printf("%c", (char)('a' + j - 1));
v ^= 1;
}
return 0;
}
| 5 |
#include <iostream>
#include <algorithm>
#include <queue>
#include <iomanip>
using namespace std;
int main()
{
int D, L;
cin >> D >> L;
cout << D / L + D%L << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
vector<int> primes;
int dp[101][1 << 18], n, a[111], man, ansd[111], loc[100];
vector<int> fact[100];
int rec(int i, int mask) {
if (i == n) return 0;
if (dp[i][mask] != 1000000000) return dp[i][mask];
int dif = abs(a[i] - 1);
int ans = rec(i + 1, mask) + dif;
for (int j = 2; j <= 60; j++) {
int k;
for (k = 0; k < fact[j].size(); k++)
if (mask & (1 << fact[j][k])) break;
if (k != (int)fact[j].size()) continue;
int d = abs(a[i] - j);
if (d <= dif) {
int msk = mask;
for (k = 0; k < fact[j].size(); k++) msk = msk | (1 << fact[j][k]);
ans = min(ans, rec(i + 1, msk) + d);
}
}
return dp[i][mask] = ans;
}
void reccons(int i, int mask, int m) {
if (i == n) return;
int dif = abs(a[i] - 1);
if (rec(i + 1, mask) == m - dif) {
ansd[i] = 1;
reccons(i + 1, mask, m - dif);
return;
}
for (int j = 2; j <= 60; j++) {
int k;
for (k = 0; k < fact[j].size(); k++)
if (mask & (1 << fact[j][k])) break;
if (k != (int)fact[j].size()) continue;
int d = abs(a[i] - j);
if (d > dif) continue;
int msk = mask;
for (k = 0; k < fact[j].size(); k++) msk = msk | (1 << fact[j][k]);
if (rec(i + 1, msk) == m - d) {
ansd[i] = j;
reccons(i + 1, msk, m - d);
return;
}
}
}
int main() {
int i, j, t;
for (i = 2; i <= 60; i++) {
for (j = 2; j < i; j++)
if (i % j == 0) break;
if (j == i) primes.push_back(i);
}
for (i = 0; i < 17; i++) loc[primes[i]] = i;
for (i = 2; i <= 60; i++) {
for (j = 0; j < 17; j++)
if (i % primes[j] == 0) fact[i].push_back(j);
}
scanf("%d", &n);
for (i = 0; i < n; i++) scanf("%d", &a[i]);
for (i = 0; i <= n; i++)
for (j = 0; j < (1 << 17); j++) dp[i][j] = 1000000000;
man = rec(0, 0);
reccons(0, 0, man);
for (i = 0; i < n; i++) printf("%d ", ansd[i]);
printf("\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
int n, k, minimal, maximal;
int a[300009], sums[1000009];
inline int min(int v1, int v2) { return v1 < v2 ? v1 : v2; }
inline int max(int v1, int v2) { return v1 > v2 ? v1 : v2; }
void ReadData() {
scanf("%d %d", &n, &k);
minimal = 1000009;
maximal = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
minimal = min(minimal, a[i]);
maximal = max(maximal, a[i]);
}
}
int getSum(int l, int r) {
int l_v = sums[min(1000008, l - 1)];
int r_v = sums[min(1000008, r)];
return r_v - l_v;
}
int answer;
int compare(const void *v1, const void *v2) { return *(int *)v1 - *(int *)v2; }
void Solve() {
if (minimal <= k + 1) {
answer = minimal;
return;
}
answer = 1;
memset(sums, 0, sizeof(sums));
qsort(a, n, sizeof(int), compare);
int index = 0;
for (int i = 1; i < 1000009; i++) {
sums[i] = sums[i - 1];
while (index < n && a[index] == i) {
sums[i]++;
index++;
}
}
for (int i = k + 1; i <= minimal; i++) {
int p = maximal / i;
int check = 0;
for (int j = 1; j <= p; j++) {
check += getSum(j * i, j * i + k);
}
if (check == n) {
answer = i;
}
}
}
void WriteData() { printf("%d\n", answer); }
int main() {
int QWE = 1;
for (int T = 0; T < QWE; T++) {
ReadData();
Solve();
WriteData();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long get_ans(long long n, long long k) {
while (true) {
if (k % 2 == 0) {
return k / 2 + 1;
}
long long cnt = (k / 2 + 1);
k += n - cnt;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
int q;
cin >> q;
for (int i = 0; i < q; ++i) {
long long pos = 0;
cin >> pos;
--pos;
cout << get_ans(n, pos) << endl;
}
return 0;
}
| 2 |
#include<bits/stdc++.h>
#define M 100005
#define YXQAK {printf("Impossible\n"); return 0;}
using namespace std;
int a[M]={0},aa[M]={0};
int n,m,ji=0,now=1;
int main(){
scanf("%d%d",&n,&m);
for(int i=1;i<=m;i++){
scanf("%d",aa+i);
if(aa[i]&1) ji++;
}
if(ji>2) YXQAK
if(ji==0){
for(int i=1;i<=m;i++) a[i]=aa[i];
}else{
for(int i=1;i<=m;i++){
if(aa[i]&1){
if(a[1]==0) a[1]=aa[i];
else a[m]=aa[i];
}else a[++now]=aa[i];
}
}
if(m==1){
printf("%d\n",aa[1]);
if(aa[1]==1) printf("1\n1\n");
else printf("2\n%d %d\n",aa[1]-1,1);
return 0;
}
for(int i=1;i<=m;i++) printf("%d ",a[i]);
printf("\n");
a[1]++; a[m]--; if(a[m]==0) m--;
printf("%d\n",m);
for(int i=1;i<=m;i++) printf("%d ",a[i]);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
const int mod = 1e9 + 7;
const int N3 = 1e3 + 10;
const int INF = 2e9 + 10;
const long long LINF = 2e18;
int main() {
if ("" != "") {
freopen(
""
".in",
"r", stdin);
freopen(
""
".out",
"w", stdout);
}
double a, b, m, vx, vy, vz;
cin >> a >> b >> m;
cin >> vx >> vy >> vz;
double T = m / -vy;
double cx = a / 2 + T * vx;
double cz = T * vz;
while (true) {
if (cx < 0) {
cx = -cx;
} else if (cx > a) {
cx = (2.0 * a) - cx;
} else
break;
}
while (true) {
if (cz < 0) {
cz = -cz;
} else if (cz > b) {
cz = (2.0 * b) - cz;
} else
break;
}
cout << fixed;
cout.precision(7);
cout << cx << ' ' << cz;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, cnt;
char s[105][105];
int main() {
scanf("%d", &n);
for (int i = (0); i < (n); i++) scanf("%s", s[i]);
cnt = 0;
for (int i = (0); i < (n); i++) {
int ok = 0;
for (int j = (0); j < (n); j++)
if (s[i][j] == '.') ok = 1;
cnt += ok;
}
if (cnt == n) {
for (int i = (0); i < (n); i++) {
for (int j = (0); j < (n); j++)
if (s[i][j] == '.') {
printf("%d %d\n", i + 1, j + 1);
break;
}
}
return 0;
}
cnt = 0;
for (int i = (0); i < (n); i++) {
int ok = 0;
for (int j = (0); j < (n); j++)
if (s[j][i] == '.') ok = 1;
cnt += ok;
}
if (cnt == n) {
for (int i = (0); i < (n); i++) {
for (int j = (0); j < (n); j++)
if (s[j][i] == '.') {
printf("%d %d\n", j + 1, i + 1);
break;
}
}
return 0;
}
puts("-1");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
string S;
cin >> N >> S;
int ans = 0;
for (int i = 0; i+2 < N; ++i) {
if (S.substr(i, 3) == "ABC") {
++ans;
}
}
cout << ans << endl;
} | 0 |
#include <bits/stdc++.h>
int i, j, dp[1555][1555], n, k, K;
int main() {
dp[0][0] = 1;
scanf("%d%d", &n, &K);
for (int kk = 0; kk < n; kk++) {
int x;
scanf("%d", &x);
for (i = 500; i >= 0; i--)
for (j = 500; j >= 0; j--)
if (dp[i][j]) dp[i + x][j] = dp[i][j + x] = 1;
}
for (i = 0; i <= K; i++) k += dp[i][K - i];
printf("%d\n", k);
for (i = 0; i <= K; i++)
if (dp[i][K - i]) printf("%d ", i);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int sum;
void decode(int val, int bit) {
if (val) {
decode(val / 2, bit + 1);
sum += (val % 2) * pow(2.0, 8 - bit);
return;
}
if (bit <= 8) {
decode(0, bit + 1);
}
return;
}
int main() {
string s;
while (getline(cin, s)) {
int last = 0;
for (int i = 0; i < s.size(); i++) {
sum = 0;
decode(s[i], 1);
cout << (int)(unsigned char)(last - sum) << endl;
last = sum;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void solve() {}
const long long maxn = 100500;
long long a[maxn];
bool dp[maxn];
long long pos[maxn];
signed main() {
ios::sync_with_stdio(0);
cin.sync_with_stdio(0);
cin.tie(0);
long long n;
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
pos[a[i]] = i;
}
dp[n] = false;
for (long long i = n - 1; i >= 1; i--) {
for (long long j = pos[i]; j <= n; j += i) {
if ((a[j] > i) and (!dp[a[j]])) {
dp[i] = true;
}
}
for (long long j = pos[i]; j >= 1; j -= i) {
if ((a[j] > i) and (!dp[a[j]])) {
dp[i] = true;
}
}
}
for (long long i = 1; i <= n; i++) {
if (dp[a[i]]) {
cout << 'A';
} else {
cout << 'B';
}
}
cout << '\n';
}
| 3 |
#include<iostream>
#include<vector>
#include<cmath>
#include<queue>
//別にqueue使わずに実装余裕じゃん
//いや無理だわ
//セグフォのデバッグができるようになりたい
using namespace std;
int main(){
//エラトステネスの篩を実装する
int np;
int n[9999]={0};//i番目が整数i+2に対応(2~10000)
vector<int> pr;
for(int i=2;i<=100;i++){
if(n[i-2]==0){
for(int j=1;j<=floor(10000/i);j++){
if(j==1){
n[j*i-2]=0;
}else{
n[j*i-2]=1;
}
}
}
}
//prのなかに素数が入っている
for(int i=0;i<9999;i++){
if(n[i]==0){
pr.push_back(i+2);
}
}
int prs=pr.size();
/*
for(int i=0;i<prs;i++){
cout << pr[i] << endl;
}
*/
while(cin>>np && np!=0){
int c=0;//いくつあるかを記録する
int s=0;//その時点での和
queue<int> q;
int j;
for(j=0;j<prs;j++){
s+=pr[j];
if(s>=np){
s-=pr[j];
break;
}
q.push(pr[j]);
}
for(;j<prs;j++){
s+=pr[j];
q.push(pr[j]);
while(s>np){
s-=q.front();
q.pop();
}
if(s==0) break;
if(s==np) c+=1;
}
cout << c << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
unsigned long long n;
cin >> n;
unsigned long long best = 0, bestnum = 0, count = 1;
for (unsigned long long i = 0; i < n; i++) {
unsigned long long num;
cin >> num;
if (i == 0) {
bestnum = num;
best = i;
continue;
}
if (num < bestnum) {
best = i;
bestnum = num;
count = 1;
} else if (num == bestnum)
count++;
}
if (count == 1)
cout << best + 1;
else
cout << "Still Rozdil";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void print(T a) {
for (auto x : a) cout << x << ' ';
cout << endl;
}
void solve() {
long long n;
cin >> n;
vector<long long> a(n);
for (long long i = 0; i < n; i++) cin >> a[i];
vector<long long> id;
id.push_back(0);
for (long long i = 1; i < n - 1; i++) {
if (a[i - 1] < a[i] && a[i] < a[i + 1]) continue;
if (a[i - 1] > a[i] && a[i] > a[i + 1]) continue;
id.push_back(i);
}
id.push_back(n - 1);
cout << (long long)(id).size() << '\n';
for (long long x : id) cout << a[x] << ' ';
cout << '\n';
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t = 1;
cin >> t;
for (long long i = 0; i < t; i++) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
char G[n][m];
vector<pair<int, int> > v;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cin >> G[i][j];
if (G[i][j] == 'W') v.push_back({i, j});
}
}
int sol = 0;
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
for (int i = 0; i < v.size(); ++i) {
int x = v[i].first;
int y = v[i].second;
for (int j = 0; j < 4; ++j) {
int nx = x + dx[j];
int ny = y + dy[j];
if (nx >= 0 && nx < n && ny >= 0 && ny < m && G[nx][ny] == 'P') {
sol++;
break;
}
}
}
cout << sol << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
using ld = long double;
template <class T>
using Table = vector<vector<T>>;
const ld eps = 1e-9;
template <class S, class T>
ostream &operator<<(ostream &os, const pair<S, T> v) {
os << "( " << v.first << ", " << v.second << ")";
return os;
}
template <class T>
ostream &operator<<(ostream &os, const vector<T> &v) {
for (int i = 0; i < v.size(); i++) {
if (i > 0) {
os << " ";
}
os << v[i];
}
return os;
}
template <class T>
ostream &operator<<(ostream &os, const vector<vector<T>> &v) {
for (int i = 0; i < v.size(); i++) {
if (i > 0) {
os << endl;
}
os << v[i];
}
return os;
}
template <class T>
ostream &operator<<(ostream &os, const vector<set<T>> &v) {
for (int i = 0; i < v.size(); i++) {
if (i > 0) {
os << endl;
}
os << v[i];
}
return os;
}
template <class T>
ostream &operator<<(ostream &os, const set<T> &v) {
int i = 0;
for (auto it : v) {
if (i > 0) {
os << ' ';
}
os << it;
i++;
}
return os;
}
using ll = long long;
map<pair<int, int>, int> mp;
int H, W;
int ask(const vector<set<int>> &lines, int x, int y) {
if (mp.find(make_pair(x, y)) != mp.end())
return mp[make_pair(x, y)];
else {
auto it = lines[H + 1 + x - y].lower_bound(y);
if (it == lines[H + 1 + x - y].end()) {
return mp[make_pair(x, y)] = min(x + (H + 1 - y), W - 1);
} else {
int ay = *it;
int ax = x + ay - y - 1;
return mp[make_pair(x, y)] = ask(lines, ax, ay);
}
}
}
vector<int> solve(vector<int> ps) {
vector<set<int>> lines(H + W + 1);
vector<int> rs(W);
for (int i = 0; i < H; ++i) {
lines[ps[i] + H - i].emplace(i);
}
mp.clear();
for (int x = 0; x < W; ++x) {
int y = 0;
rs[x] = ask(lines, x, y);
}
return rs;
}
int main() {
ios::sync_with_stdio(false);
cin >> W >> H;
vector<int> ps(H);
for (int i = 0; i < H; ++i) {
int a;
cin >> a;
a--;
ps[i] = a;
}
vector<int> rs = solve(ps);
for (int i = 0; i < H; ++i) {
ps[i] = W - 1 - ps[i];
}
vector<int> ls = solve(ps);
ll ans = 0;
for (int i = 0; i < W; ++i) {
ans += 1 + rs[i] - i;
ans += ls[i] - i;
}
if (W == 1) ans = 0;
cout << ans << endl;
return 0;
}
| 5 |
#include <iostream>
using namespace std;
int main()
{
double t,ti;
while(cin >> t >> ti){
if(t < 35.50 && ti < 71.00)
{
cout << "AAA" << endl;
}
else if(t < 37.50 && ti < 77.00)
{
cout << "AA" << endl;
}
else if(t < 40.00 && ti < 83.00)
{
cout << "A" << endl;
}
else if(t < 43.00 && ti < 89.00)
{
cout << "B" << endl;
}
else if(t < 50.00 && ti < 105.00)
{
cout << "C" << endl;
}
else if(t < 55.00 && ti < 116.00)
{
cout << "D" << endl;
}
else if(t < 70 && ti < 148.00)
{
cout << "E" << endl;
}
else
cout << "NA" << endl;
}
return 0;
} | 0 |
//Zory-2020
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
// typedef __int128 ll;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
#define edge pair<int,int>
#define FR first
#define SE second
#define MP make_pair
#define PB push_back
#define vc vector
#define db double
#define all(x) (x).begin(),(x).end()
#define sz(x) ((int)(x).size())
#define bin(x) (1ll<<(x))
#define fo(i,l,r) for(int i=(l),I=(r);i<=I;i++)
#define fd(i,r,l) for(int i=(r),I=(l);i>=I;i--)
#define mem(x,val) memset(x,val,sizeof x)
#define Swap(a,b,n) for(int I=0;I<=n;I++) swap(a[I],b[I])
#define PC __builtin_popcountll
#ifdef DEBUG
#define debug(A,args...) fprintf(stderr,A,##args)
#else
#define debug(A,args...)
#endif
#define deb debug("line %d\n",__LINE__)
namespace mine
{
ll qread()
{
ll ans=0,f=1;char c=getchar();
while(c<'0' or c>'9') {if(c=='-')f=-1;c=getchar();}
while('0'<=c and c<='9') ans=ans*10+c-'0',c=getchar();
return ans*f;
}
void write(ll num){if(num<0) putchar('-'),num=-num;if(num>=10) write(num/10);putchar('0'+num%10);}
void write1(ll num){write(num);putchar(' ');}
void write2(ll num){write(num);putchar('\n');}
template<typename T>inline bool chmax(T&a,const T&b){return a<b?a=b,1:0;}
template<typename T>inline bool chmin(T&a,const T&b){return a>b?a=b,1:0;}
ll gcd(ll x,ll y){return y?gcd(y,x%y):x;}
bool IN(ll x,ll l,ll r){return l<=x and x<=r;}
void GG(){puts("No");exit(0);}
const db eps=1e-8;
const int INF=0x3f3f3f3f;
const int MOD=998244353;
int mm(const int x){return x>=MOD?x-MOD:x;}
template<typename T> void add(T &x,const int &y){x=(x+y>=MOD?x+y-MOD:x+y);}
ll qpower(ll x,ll e,int mod=MOD){ll ans=1;while(e){if(e&1)ans=ans*x%mod;x=x*x%mod;e>>=1;}return ans;}
ll invm(ll x){return qpower(x,MOD-2);}
const int MM=1e6+10;
ll fac[MM],facinv[MM],Inv[MM];ll C(int n,int m){return n<0 or m<0 or n<m?0:fac[n]*facinv[m]%MOD*facinv[n-m]%MOD;}
void PRE()
{
fac[0]=1;fo(i,1,MM-1) fac[i]=fac[i-1]*i%MOD;
facinv[MM-1]=invm(fac[MM-1]);fd(i,MM-1,1) facinv[i-1]=facinv[i]*i%MOD;
Inv[1]=1;fo(i,2,MM-1) Inv[i]=(MOD-MOD/i)*Inv[MOD%i]%MOD;
}
namespace PP//全家桶板子
{
const int LN=1<<19;int inv[LN+1];
struct NTT
{
vc<int> w[30];NTT(){inv[1]=1;for(int i=2;i<=LN;i++) inv[i]=ll(MOD-MOD/i)*inv[MOD%i]%MOD;
for(int i=1;i<=20;i++) {w[i].resize(bin(i));w[i][0]=1;int pp=qpower(3,(MOD-1)/bin(i));for(int j=1;j<bin(i-1);j++) w[i][j]=1ll*w[i][j-1]*pp%MOD;}
}
int R[LN];inline void DFT(int A[],int lg,int op=0)
{
int m=bin(lg);assert(m<=LN);if(op) reverse(A+1,A+m);
for(int i=1;i<m;i++){R[i]=(R[i>>1]>>1)|((i&1)<<(lg-1));if(R[i]<i)swap(A[i],A[R[i]]);}
for(int ln=1,lgg=1;ln<m;ln<<=1,lgg++) for(int st=0;st<m;st+=2*ln) for(int k=0;k<ln;k++)
{int t=1ll*w[lgg][k]*A[st+ln+k]%MOD;A[st+ln+k]=mm(A[st+k]+MOD-t);A[st+k]=mm(A[st+k]+t);}
}
}ntt;
int _A[LN],_B[LN],_C[LN],M;
struct P//此结构体内函数选择性写
{
vc<int> a;int n;void rs(int nn){a.resize(n=nn);}P(){rs(M);}
int& operator [] (int x){return a[x];}
friend const P operator * (P a,const int &b) {for(int i=0;i<a.n;i++) a[i]=(ll)a[i]*b%MOD;return a;}
inline void dft(int _A[],int lg,int ln){for(int i=0;i<bin(lg);i++)_A[i]=(i<min(ln,n)?a[i]:0);ntt.DFT(_A,lg);}
inline void idft(int _A[],int lg,int ln){ntt.DFT(_A,lg,1);rs(ln);for(int i=0;i<ln;i++)a[i]=1ll*_A[i]*inv[bin(lg)]%MOD;}
const P Mul(P b,int ln=M)
{
int lg=ceil(log2(ln+ln-1)),m=bin(lg);dft(_A,lg,ln);b.dft(_B,lg,ln);
for(int i=0;i<m;i++) _B[i]=1ll*_A[i]*_B[i]%MOD;b.idft(_B,lg,ln);return b;
}
const P operator * (const P b) {return Mul(b);}
};
void Inv(P &a,P &b,int ln=M)
{
if(ln==1){b.rs(1);b[0]=invm(a[0]);return;}Inv(a,b,(ln+1)/2);
int lg=ceil(log2(ln+ln-1)),m=bin(lg);a.dft(_A,lg,ln);b.dft(_B,lg,ln);
for(int i=0;i<m;i++) _B[i]=(2+MOD-1ll*_B[i]*_A[i]%MOD)*_B[i]%MOD;b.idft(_B,lg,ln);
}
P Ji(P a){a.rs(a.n+1);for(int i=a.n-1;i>=1;i--)a[i]=1ll*a[i-1]*inv[i]%MOD;a[0]=0;return a;}
P Dao(P a){for(int i=0;i<a.n-1;i++)a[i]=1ll*a[i+1]*(i+1)%MOD;a.rs(a.n-1);return a;}
P Ln(P &a,int ln=M){P b;Inv(a,b,ln);return Ji(Dao(a).Mul(b,ln-1));}
void Exp(P &a,P &b,int ln=M)
{
if(ln==1){b.rs(1);b[0]=1;return;}Exp(a,b,(ln+1)/2);
P pp=Ln(b,ln);for(int i=0;i<ln;i++) pp[i]=mm(a[i]+MOD-pp[i]);pp[0]++;
int lg=ceil(log2(ln+ln-1)),m=bin(lg);pp.dft(_A,lg,ln);b.dft(_B,lg,ln);
for(int i=0;i<m;i++) _B[i]=1ll*_A[i]*_B[i]%MOD;b.idft(_B,lg,ln);
}
void Sqrt(P &a,P &b,int ln=M)
{
if(ln==1){b.rs(1);b[0]=1;return;}Sqrt(a,b,(ln+1)/2);P tmp=b*2,c;Inv(tmp,c,ln);
int lg=ceil(log2(ln+ln-1)),m=bin(lg);a.dft(_A,lg,ln);b.dft(_B,lg,ln);c.dft(_C,lg,ln);
for(int i=0;i<m;i++) _A[i]=ll((ll)_B[i]*_B[i]+_A[i])%MOD*_C[i]%MOD;b.idft(_A,lg,ln);
}
P Rev(P a){reverse(a.a.begin(),a.a.end());return a;}
P Inv(P a,int ln=M){P b;Inv(a,b,ln);return b;}
P Div(const P &a,const P &b){return Rev(Rev(a).Mul( Inv(Rev(b),a.n-b.n+1),a.n-b.n+1 ) );}
P Mul2(P a,P b){M=a.n+b.n-1;return a*b;}
P DandC(vc<P> &A,int l,int r)
{
if(l==r) return A[l];
int mid=(l+r)/2;
return Mul2(DandC(A,l,mid),DandC(A,mid+1,r));
}
};
const int N=8e3+10;
//------------------FIXED------------------
int dp[N][N];using namespace PP;
void main()
{
int m=qread(),n=qread();dp[0][0]=1;PRE();
fo(i,1,n)
{
//fo(j,0,m) fo(ad,1,m-j) add(dp[i][j+ad], dp[i-1][j]*C(j+ad+2,ad+2)%MOD );
M=m+1;P A,B;fo(j,0,m) A[j]=dp[i-1][j]*facinv[j]%MOD;fo(j,1,m) B[j]=facinv[j+2];
A=A*B;fo(j,0,m) dp[i][j]=A[j]*fac[j+2]%MOD;
fo(j,0,m) add(dp[i][j], dp[i-1][j]*(C(j,2)+j+1)%MOD );
} int ans=0;fo(j,0,m) add(ans, dp[n][j]*C(m,j)%MOD );write2(ans);
}
};//变量重名！
signed main()
{
//freopen("wind.in","r",stdin);
//freopen("wind.out","w",stdout);
#ifdef DEBUG
freopen("a.in","r",stdin);
//freopen("a.out","w",stdout);
#endif
mine::main();
debug("\n---------------------Zory---------------------\nTime: %.2lf s",1.0*clock()/CLOCKS_PER_SEC);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
double PI = 3.14159265358979323843;
void Timo() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
void print(int n) {
if (n == 0) {
return;
}
print(n - 1);
cout << "Hello world" << endl;
print(n - 1);
}
int main() {
Timo();
string s;
cin >> s;
cout << s;
reverse(s.begin(), s.end());
cout << s << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
int arr[n];
int minn = INT_MAX;
for (int i = 0; i < n; i++) {
cin >> arr[i];
minn = min(minn, arr[i]);
}
vector<int> vec;
for (int i = 0; i < n; i++) {
if (arr[i] == minn) {
vec.push_back(i);
}
}
int ans = INT_MAX;
for (int i = 1; i < vec.size(); i++) {
ans = min(ans, vec[i] - vec[i - 1]);
}
cout << ans;
return 0;
}
| 1 |
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
using namespace std;
using ll = long long;
int main(){
ios_base::sync_with_stdio(false);
int n, k;
cin >> n >> k;
vector<ll> a(n);
for(int i = 0; i < n; ++i){ cin >> a[i]; }
vector<ll> b(n + 1), c(n + 1);
for(int i = 0; i < n; ++i){ b[i + 1] = b[i] + a[i]; }
for(int i = 0; i < n; ++i){ c[i + 1] = c[i] + max(0ll, a[i]); }
ll answer = 0;
for(int i = 0; i + k <= n; ++i){
answer = max(answer, c[i] + max(0ll, b[i + k] - b[i]) + (c[n] - c[i + k]));
}
cout << answer << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
int main() {
long long int t, n, i, m;
scanf("%lld", &t);
for (i = 1; i <= t; i = i + 1) {
scanf("%lld", &n);
long long int p[n], j, a = 0, b = 0, c = 0, d = 0;
for (j = 0; j < n; j = j + 1) {
scanf("%lld", &p[j]);
if (p[j] % 2 == 0) {
a = a + 1;
} else {
b = b + 1;
}
}
scanf("%lld", &m);
long long int q[m];
for (j = 0; j < m; j = j + 1) {
scanf("%lld", &q[j]);
if (q[j] % 2 == 0) {
c = c + 1;
} else {
d = d + 1;
}
}
printf("%lld\n", (a * c) + (b * d));
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int SIZE = 100000;
vector<int> edges[SIZE];
vector<string> str[SIZE];
string c;
int prefc[3 * SIZE];
char s[3 * SIZE];
int pref[3 * SIZE];
void build() {
prefc[0] = 0;
for (int i = 1; i < c.length(); i++) {
int pi = prefc[i - 1];
while (c[pi] != c[i]) {
if (pi == 0) break;
pi = prefc[pi - 1];
}
if (c[pi] != c[i]) {
prefc[i] = 0;
} else {
prefc[i] = pi + 1;
}
}
}
int cnt = 0;
void dfs(int v, int p = -1, int lenb = 0, int lene = 0) {
for (int i = lenb; i < lene; i++) {
int pi;
if (i == 0) {
pi = 0;
} else {
pi = pref[i - 1];
}
if (c[pi] == s[i] && pi + 1 == c.length()) {
cnt++;
pi = prefc[pi - 1];
}
while (c[pi] != s[i]) {
if (pi == 0) break;
pi = prefc[pi - 1];
}
if (c[pi] != s[i]) {
pref[i] = 0;
} else {
pref[i] = pi + 1;
}
}
for (int i = 0; i < edges[v].size(); i++) {
int to = edges[v][i];
if (to == p) continue;
int len = str[v][i].length();
for (int j = 0; j < len; j++) {
s[lene + j] = str[v][i][j];
}
dfs(to, v, lene, lene + len);
}
}
int main() {
int n;
cin >> n;
for (int i = 1; i < n; i++) {
int p;
string s;
cin >> p >> s;
p--;
edges[p].push_back(i);
str[p].push_back(s);
}
cin >> c;
build();
dfs(0);
cout << cnt;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k, q;
cin >> n >> m >> k >> q;
int tv[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
tv[i][j] = -1;
}
}
for (int i = 0; i < q; i++) {
int x, y, t;
cin >> x >> y >> t;
tv[x - 1][y - 1] = t;
}
int vals[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
vals[i][j] = -1;
}
}
for (int i = 0; i < n; i++) {
int counter = 0;
deque<int> times;
for (int j = 0; j < m; j++) {
if (tv[i][j] == -1) {
counter = 0;
times.clear();
} else {
counter++;
int currtime = tv[i][j];
while (!times.empty() && times.back() < currtime) {
times.pop_back();
}
times.push_back(currtime);
if (counter >= k) {
vals[i][j] = times.front();
if (times.front() == tv[i][j - k + 1]) {
times.pop_front();
}
}
}
}
}
int broken = -1;
for (int j = 0; j < m; j++) {
int counter = 0;
deque<int> times;
for (int i = 0; i < n; i++) {
if (vals[i][j] == -1) {
counter = 0;
times.clear();
} else {
counter++;
int currtime = vals[i][j];
while (!times.empty() && times.back() < currtime) {
times.pop_back();
}
times.push_back(currtime);
if (counter >= k) {
if (times.front() < broken || broken == -1) {
broken = times.front();
}
if (times.front() == vals[i - k + 1][j]) {
times.pop_front();
}
}
}
}
}
cout << broken << endl;
}
| 4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.