text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
int a[200005], mn[800005], tag[800005];
long long sum[800005];
inline int read() {
register int x = 0, f = 1;
register char s = getchar();
while (s > '9' || s < '0') {
if (s == '-') f = -1;
s = getchar();
}
while (s >= '0' && s <= '9') {
x = x * 10 + s - '0';
s = getchar();
}
return x * f;
}
inline int min(const int &x, const int &y) { return x < y ? x : y; }
inline void pushup(int p) {
mn[p] = min(mn[p << 1], mn[p << 1 | 1]);
sum[p] = sum[p << 1] + sum[p << 1 | 1];
}
inline void work(int p, int l, int r, int val) {
if (tag[p] < val) {
sum[p] = (r - l + 1) * 1ll * val;
mn[p] = val;
tag[p] = val;
}
}
inline void spread(int p, int l, int r) {
if (tag[p]) {
int mid = l + r >> 1;
work(p << 1, l, mid, tag[p]);
work(p << 1 | 1, mid + 1, r, tag[p]);
tag[p] = 0;
}
}
inline void build(int p, int l, int r) {
if (l == r) {
mn[p] = sum[p] = a[l];
return;
}
int mid = l + r >> 1;
build(p << 1, l, mid);
build(p << 1 | 1, mid + 1, r);
pushup(p);
}
inline void modify_cov(int p, int l, int r, int L, int R, int val) {
if (L <= l && r <= R) {
work(p, l, r, val);
return;
}
int mid = l + r >> 1;
spread(p, l, r);
if (L <= mid) modify_cov(p << 1, l, mid, L, R, val);
if (R > mid) modify_cov(p << 1 | 1, mid + 1, r, L, R, val);
pushup(p);
}
inline int GetLeftPosition(int p, int l, int r, int val) {
if (mn[p] > val) return -1;
if (l == r) return l;
int mid = l + r >> 1;
spread(p, l, r);
if (mn[p << 1] <= val) return GetLeftPosition(p << 1, l, mid, val);
return GetLeftPosition(p << 1 | 1, mid + 1, r, val);
}
inline int GetSegmentSum(int p, int l, int r, long long &val) {
if (sum[p] <= val) {
val -= sum[p];
return r - l + 1;
}
int mid = l + r >> 1, res = 0;
spread(p, l, r);
if (mn[p << 1] <= val) res += GetSegmentSum(p << 1, l, mid, val);
if (mn[p << 1 | 1] <= val) res += GetSegmentSum(p << 1 | 1, mid + 1, r, val);
return res;
}
inline long long GetSum(int p, int l, int r, int L, int R) {
if (L <= l && r <= R) return sum[p];
int mid = l + r >> 1;
long long res = 0;
spread(p, l, r);
if (L <= mid) res += GetSum(p << 1, l, mid, L, R);
if (R > mid) res += GetSum(p << 1 | 1, mid + 1, r, L, R);
return res;
}
int main() {
int n = read(), Q = read();
for (register int i = 1; i <= n; ++i) a[i] = read();
build(1, 1, n);
while (Q--) {
int op = read(), x = read();
long long y = read();
if (op == 1) {
int pos = GetLeftPosition(1, 1, n, y);
if (pos > x || pos == -1) {
continue;
} else
modify_cov(1, 1, n, pos, x, y);
} else {
if (x != 1) y += GetSum(1, 1, n, 1, x - 1);
printf("%d\n", GetSegmentSum(1, 1, n, y) - x + 1);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using i64 = long long;
struct Tnode {
array<i64, 3> info;
int size;
int valset;
} node[4 * 223456];
int a[223456], n, q;
array<i64, 3> operator+(array<i64, 3> &a, array<i64, 3> &b) {
return {a[0] + b[0], max(a[1], b[1]), min(a[2], b[2])};
}
void setval(int id, int val) {
node[id].valset = val;
node[id].info = {(i64)node[id].size * val, val, val};
}
void clear(int id) {
if (node[id].valset != -1) {
setval(id * 2, node[id].valset);
setval(id * 2 + 1, node[id].valset);
node[id].valset = -1;
}
}
void build(int id, int l, int r) {
node[id].valset = -1;
node[id].size = r - l + 1;
if (l == r) {
node[id].info = {a[l], a[l], a[l]};
} else {
int m = (l + r) / 2;
build(id * 2, l, m);
build(id * 2 + 1, m + 1, r);
node[id].info = node[id * 2].info + node[id * 2 + 1].info;
}
}
void rangeset(int id, int l, int r, int rl, int rr, int v) {
if (l == rl && r == rr) {
if (node[id].info[2] >= v) return;
if (node[id].info[1] <= v) {
setval(id, v);
return;
}
clear(id);
int m = (l + r) / 2;
rangeset(id * 2, l, m, l, m, v);
rangeset(id * 2 + 1, m + 1, r, m + 1, r, v);
node[id].info = node[id * 2].info + node[id * 2 + 1].info;
} else {
clear(id);
int m = (l + r) / 2;
if (rr <= m)
rangeset(id * 2, l, m, rl, rr, v);
else if (rl > m)
rangeset(id * 2 + 1, m + 1, r, rl, rr, v);
else {
rangeset(id * 2, l, m, rl, m, v);
rangeset(id * 2 + 1, m + 1, r, m + 1, rr, v);
}
node[id].info = node[id * 2].info + node[id * 2 + 1].info;
}
}
int getnext(int id, int l, int r, int rl, int rr, int v) {
if (l == rl && r == rr) {
if (node[id].info[1] <= v) return l;
if (node[id].info[2] > v) return n + 1;
clear(id);
int m = (l + r) / 2;
return min(getnext(id * 2, l, m, l, m, v),
getnext(id * 2 + 1, m + 1, r, m + 1, r, v));
} else {
clear(id);
int m = (l + r) / 2;
if (rr <= m)
return getnext(id * 2, l, m, rl, rr, v);
else if (rl > m)
return getnext(id * 2 + 1, m + 1, r, rl, rr, v);
else {
return min(getnext(id * 2, l, m, rl, m, v),
getnext(id * 2 + 1, m + 1, r, m + 1, rr, v));
}
}
}
bool isful;
int cnt;
void geteat(int id, int l, int r, int rl, int rr, int &v) {
if (!isful) {
return;
}
if (l == rl && r == rr) {
if (node[id].info[0] <= v) {
v -= node[id].info[0];
cnt += node[id].size;
return;
}
if (l == r) {
isful = false;
return;
}
clear(id);
int m = (l + r) / 2;
geteat(id * 2, l, m, l, m, v);
geteat(id * 2 + 1, m + 1, r, m + 1, r, v);
} else {
clear(id);
int m = (l + r) / 2;
if (rr <= m)
geteat(id * 2, l, m, rl, rr, v);
else if (rl > m)
geteat(id * 2 + 1, m + 1, r, rl, rr, v);
else {
geteat(id * 2, l, m, rl, m, v);
geteat(id * 2 + 1, m + 1, r, m + 1, rr, v);
}
}
}
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
build(1, 1, n);
for (int i = 0; i < q; i++) {
int t, x, y;
scanf("%d%d%d", &t, &x, &y);
if (t == 1) {
rangeset(1, 1, n, 1, x, y);
} else {
int pos = x, c = 0;
while (pos <= n) {
pos = getnext(1, 1, n, pos, n, y);
if (pos == n + 1) break;
isful = true;
cnt = 0;
geteat(1, 1, n, pos, n, y);
c += cnt;
pos += cnt;
}
printf("%d\n", c);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long k = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
k = k * 10 + ch - '0';
ch = getchar();
}
return k * f;
}
inline void write(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
inline void writeln(long long x) {
write(x);
puts("");
}
const long long N = 2e5 + 10;
long long n, Q, a[N];
long long t[4 * N], mat[4 * N], mit[4 * N], pt[4 * N];
inline void pushdown(long long l, long long r, long long nod) {
if (l == r || pt[nod] == 0) return;
long long mid = l + r >> 1;
pt[nod << 1] = pt[nod << 1 | 1] = pt[nod];
t[nod << 1] = pt[nod] * (mid - l + 1);
t[nod << 1 | 1] = pt[nod] * (r - mid);
mat[nod << 1] = mit[nod << 1] = mat[nod << 1 | 1] = mit[nod << 1 | 1] =
pt[nod];
pt[nod] = 0;
}
inline void update(long long nod) {
t[nod] = t[nod << 1] + t[nod << 1 | 1];
mat[nod] = mat[nod << 1];
mit[nod] = mit[nod << 1 | 1];
}
inline void build(long long l, long long r, long long nod) {
pt[nod] = 0;
if (l == r) {
t[nod] = mit[nod] = mat[nod] = a[l];
return;
}
long long mid = l + r >> 1;
build(l, mid, nod << 1);
build(mid + 1, r, nod << 1 | 1);
update(nod);
}
inline void xg(long long l, long long r, long long i, long long j, long long x,
long long nod) {
pushdown(l, r, nod);
if (mit[nod] >= x) return;
if (l >= i && r <= j && mat[nod] <= x) {
t[nod] = x * (r - l + 1);
mat[nod] = mit[nod] = x;
pt[nod] = x;
return;
}
long long mid = l + r >> 1;
if (i <= mid) xg(l, mid, i, j, x, nod << 1);
if (j > mid) xg(mid + 1, r, i, j, x, nod << 1 | 1);
update(nod);
}
long long sum;
inline long long query(long long l, long long r, long long i, long long j,
long long nod) {
pushdown(l, r, nod);
if (l >= i && r <= j && t[nod] <= sum) {
sum -= t[nod];
return r - l + 1;
}
long long mid = l + r >> 1, ans = 0;
if (i <= mid && sum >= mit[nod << 1]) ans += query(l, mid, i, j, nod << 1);
if (j > mid && sum >= mit[nod << 1 | 1])
ans += query(mid + 1, r, i, j, nod << 1 | 1);
return ans;
}
signed main() {
n = read();
Q = read();
for (long long i = 1; i <= n; i++) a[i] = read();
build(1, n, 1);
while (Q--) {
long long t = read(), x = read(), v = read();
if (t == 1)
xg(1, n, 1, x, v, 1);
else {
sum = v;
writeln(query(1, n, x, n, 1));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 4e5 + 10;
long long n, q, a[maxn];
struct node {
long long sum, Min, Max, len, lazy;
} Tree[maxn << 2];
inline void PushUp(long long root) {
Tree[root].Max = Tree[root << 1].Max;
Tree[root].Min = Tree[root << 1 | 1].Min;
Tree[root].sum = Tree[root << 1].sum + Tree[root << 1 | 1].sum;
}
inline void PushTag(long long root, long long val) {
Tree[root].Min = Tree[root].Max = Tree[root].lazy = val;
Tree[root].sum = val * Tree[root].len;
}
inline void PushDown(long long root) {
if (!Tree[root].lazy) return;
PushTag(root << 1, Tree[root].lazy);
PushTag(root << 1 | 1, Tree[root].lazy);
Tree[root].lazy = 0;
}
inline void Build(long long root, long long l, long long r) {
Tree[root].len = r - l + 1;
if (l == r) {
Tree[root].sum = Tree[root].Min = Tree[root].Max = a[l];
return;
}
long long Mid = l + r >> 1;
Build(root << 1, l, Mid);
Build(root << 1 | 1, Mid + 1, r);
PushUp(root);
}
inline long long Find(long long root, long long l, long long r, long long val) {
if (l == r) return Tree[root].Min <= val ? l : n + 1;
long long Mid = l + r >> 1;
PushDown(root);
if (Tree[root << 1].Min > val) return Find(root << 1 | 1, Mid + 1, r, val);
return Find(root << 1, l, Mid, val);
}
inline void Modify(long long root, long long l, long long r, long long L,
long long R, long long val) {
if (L <= l && r <= R) {
PushTag(root, val);
return;
}
long long Mid = l + r >> 1;
PushDown(root);
if (L <= Mid) Modify(root << 1, l, Mid, L, R, val);
if (Mid < R) Modify(root << 1 | 1, Mid + 1, r, L, R, val);
PushUp(root);
}
inline long long Query(long long root, long long l, long long r, long long L,
long long R) {
if (L > R) return 0;
if (L <= l && r <= R) return Tree[root].sum;
long long Mid = l + r >> 1, ret = 0;
PushDown(root);
if (L <= Mid) ret += Query(root << 1, l, Mid, L, R);
if (Mid < R) ret += Query(root << 1 | 1, Mid + 1, r, L, R);
return ret;
}
inline long long Solve(long long root, long long l, long long r,
long long val) {
if (l == r) return l;
long long Mid = l + r >> 1;
PushDown(root);
if (val >= Tree[root << 1].sum + Tree[root << 1 | 1].Max)
return Solve(root << 1 | 1, Mid + 1, r, val - Tree[root << 1].sum);
else
return Solve(root << 1, l, Mid, val);
}
signed main() {
scanf("%lld%lld", &n, &q);
for (long long i = (1), _end_ = (n); i <= _end_; ++i) scanf("%lld", &a[i]);
Build(1, 1, n);
while (q--) {
long long t, x, y;
scanf("%lld%lld%lld", &t, &x, &y);
if (t == 1) {
long long pos = Find(1, 1, n, y);
if (pos <= x) Modify(1, 1, n, pos, x, y);
}
if (t == 2) {
long long now = max(x, Find(1, 1, n, y)), ans = 0;
while (now <= n) {
long long pos = Solve(1, 1, n, Query(1, 1, n, 1, now - 1) + y);
y -= Query(1, 1, n, now, pos);
ans += pos - now + 1;
if (pos == n) break;
now = Find(1, 1, n, y);
}
printf("%lld\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
int n, m, a[N];
long long sum[N << 2];
int lazy[N << 2], mn[N << 2];
void ADD(int id, int L, int R, int val) {
lazy[id] = val, mn[id] = val, sum[id] = (long long)(R - L + 1) * val;
}
void pushdown(int id, int L, int R) {
int mid = (L + R) >> 1;
if (lazy[id])
ADD(id << 1, L, mid, lazy[id]), ADD(id << 1 | 1, mid + 1, R, lazy[id]),
lazy[id] = 0;
}
void upd(int id) {
sum[id] = sum[id << 1] + sum[id << 1 | 1];
mn[id] = min(mn[id << 1], mn[id << 1 | 1]);
}
void add(int id, int L, int R, int l, int r, int val) {
if (l <= L && R <= r) {
if (L == R) return mn[id] = sum[id] = max(mn[id], val), void();
pushdown(id, L, R);
int mid = (L + R) >> 1;
if (mn[id << 1] > val)
add(id << 1 | 1, mid + 1, R, l, r, val);
else
ADD(id << 1 | 1, mid + 1, R, val), add(id << 1, L, mid, l, r, val);
upd(id);
return;
}
pushdown(id, L, R);
int mid = (L + R) >> 1;
if (l <= mid) add(id << 1, L, mid, l, r, val);
if (r > mid) add(id << 1 | 1, mid + 1, R, l, r, val);
upd(id);
}
int query1(int id, int L, int R, int val) {
if (L == R) {
if (mn[id] <= val)
return L;
else
return L + 1;
}
pushdown(id, L, R);
int mid = (L + R) >> 1;
if (mn[id << 1] <= val)
return query1(id << 1, L, mid, val);
else
return query1(id << 1 | 1, mid + 1, R, val);
}
int query2(int id, int L, int R, long long val) {
if (L == R) {
if (sum[id] > val)
return L;
else
return L + 1;
}
pushdown(id, L, R);
int mid = (L + R) >> 1;
if (val < sum[id << 1])
return query2(id << 1, L, mid, val);
else
return query2(id << 1 | 1, mid + 1, R, val - sum[id << 1]);
}
long long query3(int id, int L, int R, int l, int r) {
if (l <= L && R <= r) return sum[id];
pushdown(id, L, R);
int mid = (L + R) >> 1;
long long res = 0;
if (l <= mid) res += query3(id << 1, L, mid, l, r);
if (r > mid) res += query3(id << 1 | 1, mid + 1, R, l, r);
return res;
}
void build(int id, int L, int R) {
if (L == R) return mn[id] = sum[id] = a[L], void();
int mid = (L + R) >> 1;
build(id << 1, L, mid), build(id << 1 | 1, mid + 1, R), upd(id);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
cin >> n >> m;
for (int i = 1, iE = n; i <= iE; i++) cin >> a[i];
build(1, 1, n);
while (m--) {
int opt, x, y;
cin >> opt >> x >> y;
if (opt == 1) {
add(1, 1, n, 1, x, y);
continue;
}
int ans = 0;
while (x <= n) {
int nx = max(x, query1(1, 1, n, y));
if (nx > n) break;
int pos = query2(1, 1, n, y + (nx == 1 ? 0 : query3(1, 1, n, 1, nx - 1)));
if (pos == x) assert(0);
ans += pos - nx, y -= query3(1, 1, n, nx, pos - 1), x = pos;
}
cout << ans << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long N, Q, vals[300005], ans, val;
long long treemn[300005 * 8];
long long treemx[300005 * 8];
long long treesm[300005 * 8];
long long lazy[300005 * 8];
void updLazy(long long x, long long l, long long r) {
if (!lazy[x]) return;
treemx[x] = treemn[x] = lazy[x];
treesm[x] = (r - l + 1) * treemx[x];
lazy[2 * x + 1] = lazy[x];
lazy[2 * x + 2] = lazy[x];
lazy[x] = 0;
}
void initTree(long long x, long long l, long long r) {
if (l == r) {
treemn[x] = treemx[x] = treesm[x] = vals[l];
return;
}
long long mid = (l + r) / 2;
initTree(2 * x + 1, l, mid);
initTree(2 * x + 2, mid + 1, r);
treemn[x] = min(treemn[2 * x + 1], treemn[2 * x + 2]);
treemx[x] = max(treemx[2 * x + 1], treemx[2 * x + 2]);
treesm[x] = treesm[2 * x + 1] + treesm[2 * x + 2];
}
void upd(long long x, long long l, long long r, long long lq, long long rq,
long long v) {
updLazy(x, l, r);
if (l > rq or r < lq) return;
if (treemn[x] >= v) return;
if (l >= lq && r <= rq && treemx[x] <= v) {
lazy[x] = v;
updLazy(x, l, r);
return;
}
long long mid = (l + r) / 2;
upd(2 * x + 1, l, mid, lq, rq, v);
upd(2 * x + 2, mid + 1, r, lq, rq, v);
treemn[x] = min(treemn[2 * x + 1], treemn[2 * x + 2]);
treemx[x] = max(treemx[2 * x + 1], treemx[2 * x + 2]);
treesm[x] = treesm[2 * x + 1] + treesm[2 * x + 2];
}
void qry(long long x, long long l, long long r, long long lq, long long rq) {
updLazy(x, l, r);
if (l > rq or r < lq) return;
if (val < treemn[x]) return;
if (l >= lq && r <= rq && treesm[x] <= val) {
ans += r - l + 1;
val -= treesm[x];
return;
}
long long mid = (l + r) / 2;
qry(2 * x + 1, l, mid, lq, rq);
qry(2 * x + 2, mid + 1, r, lq, rq);
}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
cin >> N >> Q;
for (long long i = 1; i <= N; i++) cin >> vals[i];
initTree(0, 1, N);
while (Q--) {
long long t, x, y;
cin >> t >> x >> y;
if (t == 1) {
upd(0, 1, N, 1, x, y);
} else {
ans = 0;
val = y;
qry(0, 1, N, x, N);
cout << ans << "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0;
int f = 0;
char ch = getchar();
while (ch < '0' || ch > '9') f |= (ch == '-'), ch = getchar();
while (ch >= '0' && ch <= '9')
x = (x << 3) + (x << 1) + ch - '0', ch = getchar();
return x = f ? -x : x;
}
inline void write(long long x, bool f = true) {
if (x == 0) {
putchar('0');
if (f)
putchar('\n');
else
putchar(' ');
return;
}
if (x < 0) {
putchar('-');
x = -x;
}
static char s[23];
int l = 0;
while (x != 0) s[l++] = x % 10 + 48, x /= 10;
while (l) putchar(s[--l]);
if (f)
putchar('\n');
else
putchar(' ');
}
int lowbit(int x) { return x & (-x); }
template <class T>
T big(const T &a1, const T &a2) {
return a1 > a2 ? a1 : a2;
}
template <class T>
T sml(const T &a1, const T &a2) {
return a1 < a2 ? a1 : a2;
}
template <typename T, typename... R>
T big(const T &f, const R &...r) {
return big(f, big(r...));
}
template <typename T, typename... R>
T sml(const T &f, const R &...r) {
return sml(f, sml(r...));
}
void debug_out() { cout << '\n'; }
template <typename T, typename... R>
void debug_out(const T &f, const R &...r) {
cout << f << " ";
debug_out(r...);
}
const int INF = 0x3f3f3f3f;
const int mod = 1e9 + 7;
const int MXN = 2e5 + 5;
int n, m;
int ar[MXN];
long long sum[MXN << 2];
int sumfg[MXN << 2], mn[MXN << 2];
void push_up(int rt) {
sum[rt] = sum[rt << 1] + sum[rt << 1 | 1];
mn[rt] = mn[rt << 1 | 1];
}
void build(int l, int r, int rt) {
sumfg[rt] = 0;
if (l == r) {
mn[rt] = ar[l];
sum[rt] = ar[l];
return;
}
int mid = (l + r) >> 1;
build(l, mid, rt << 1), build(mid + 1, r, rt << 1 | 1);
push_up(rt);
}
void push_down(int rt, int l, int mid, int r) {
if (sumfg[rt] == 0) return;
assert(sumfg[rt << 1] <= sumfg[rt] && sumfg[rt << 1 | 1] <= sumfg[rt]);
sumfg[rt << 1] = sumfg[rt << 1 | 1] = sumfg[rt];
sum[rt << 1] = (long long)sumfg[rt] * (mid - l + 1);
mn[rt << 1] = sumfg[rt];
sum[rt << 1 | 1] = (long long)sumfg[rt] * (r - mid);
mn[rt << 1 | 1] = sumfg[rt];
sumfg[rt] = 0;
}
long long qsum(int L, int R, int l, int r, int rt) {
if (L > R) return 0;
if (L <= l && r <= R) return sum[rt];
int mid = (l + r) >> 1;
push_down(rt, l, mid, r);
if (L > mid)
return qsum(L, R, mid + 1, r, rt << 1 | 1);
else if (R <= mid)
return qsum(L, R, l, mid, rt << 1);
else {
return qsum(L, mid, l, mid, rt << 1) +
qsum(mid + 1, R, mid + 1, r, rt << 1 | 1);
}
}
void update(int L, int R, int v, int l, int r, int rt) {
if (L <= l && r <= R) {
sum[rt] = (long long)v * (r - l + 1);
mn[rt] = v;
sumfg[rt] = max(sumfg[rt], v);
return;
}
if (l == r) return;
int mid = (l + r) >> 1;
push_down(rt, l, mid, r);
if (L > mid) {
update(L, R, v, mid + 1, r, rt << 1 | 1);
} else if (R <= mid) {
update(L, R, v, l, mid, rt << 1);
} else {
update(L, mid, v, l, mid, rt << 1);
update(mid + 1, R, v, mid + 1, r, rt << 1 | 1);
}
push_up(rt);
}
int que4(int L, int R, int v, int l, int r, int rt) {
if (mn[rt] > v) return -1;
if (l == r) return l;
int mid = (l + r) >> 1;
push_down(rt, l, mid, r);
if (L > mid) {
return que4(L, R, v, mid + 1, r, rt << 1 | 1);
} else if (R <= mid) {
return que4(L, R, v, l, mid, rt << 1);
} else {
if (mn[rt << 1] > v)
return que4(mid + 1, R, v, mid + 1, r, rt << 1 | 1);
else
return que4(L, mid, v, l, mid, rt << 1);
}
}
long long Left;
int que3(int L, int R, int v, int l, int r, int rt) {
if (l == r) {
if (sum[rt] <= v)
return l;
else
return -1;
}
int mid = (l + r) >> 1;
push_down(rt, l, mid, r);
if (L > mid) {
Left -= sum[rt << 1];
return que3(L, R, v, mid + 1, r, rt << 1 | 1);
} else if (R <= mid) {
return que3(L, R, v, l, mid, rt << 1);
} else {
if (sum[rt << 1] - Left < v) {
v -= (sum[rt << 1] - Left);
Left = 0;
return max(mid, que3(mid + 1, R, v, mid + 1, r, rt << 1 | 1));
} else if (sum[rt << 1] - Left == v)
return mid;
else
return que3(L, mid, v, l, mid, rt << 1);
}
}
int que2(int p, int v, int l, int r, int rt) {
if (p <= l && sum[rt] <= v) return r - l + 1;
if (l == r) return 0;
int mid = (l + r) >> 1, ans = 0;
push_down(rt, l, mid, r);
if (p <= mid) {
Left = qsum(1, p - 1, 1, n, 1);
int pos = que3(p, mid, v, 1, n, 1);
long long tmp = qsum(p, pos, 1, n, 1);
;
ans += max(0, pos - p + 1);
if (pos == n) return ans;
v -= tmp;
pos = que4(pos + 1, n, v, 1, n, 1);
if (pos == -1) return ans;
ans += que2(pos, v, l, r, rt);
} else {
ans += que2(p, v, mid + 1, r, rt << 1 | 1);
}
return ans;
}
void work() {
n = read(), m = read();
for (register int i = (1), LIM = (n + 1); i < LIM; ++i) ar[i] = read();
build(1, n, 1);
while (m--) {
int opt = read(), x = read(), y = read();
if (opt == 1) {
int ls = que4(1, x, y, 1, n, 1);
if (ls == -1) continue;
update(ls, x, y, 1, n, 1);
} else {
int pos = que4(x, n, y, 1, n, 1);
int ans = 0;
if (pos != -1) ans = que2(pos, y, 1, n, 1);
printf("%d\n", ans);
}
}
}
int main() {
for (int cas = 1, tim = 1; cas <= tim; ++cas) {
work();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int Max[N << 2], Min[N << 2], tag[N << 2], len[N << 2];
long long sum[N << 2];
int a[N];
int n, q, op, x, y;
long long tot;
inline void pushup(int now) {
Max[now] = max(Max[now << 1], Max[now << 1 | 1]);
Min[now] = min(Min[now << 1], Min[now << 1 | 1]);
sum[now] = sum[now << 1] + sum[now << 1 | 1];
}
inline void pushdown(int now) {
if (tag[now] == -1) return;
Max[now << 1] = Min[now << 1] = Max[now << 1 | 1] = Min[now << 1 | 1] =
tag[now];
sum[now << 1] = 1ll * tag[now] * len[now << 1];
sum[now << 1 | 1] = 1ll * tag[now] * len[now << 1 | 1];
tag[now << 1] = tag[now << 1 | 1] = tag[now];
tag[now] = -1;
}
void build(int now, int l, int r) {
tag[now] = -1;
len[now] = r - l + 1;
if (l == r) {
Max[now] = Min[now] = sum[now] = a[l];
return;
}
int mid = (l + r) >> 1;
build(now << 1, l, mid);
build(now << 1 | 1, mid + 1, r);
pushup(now);
}
void update(int now, int l, int r, int x, int y, int z) {
if (x > y) return;
if (l == x && r == y) {
Max[now] = Min[now] = tag[now] = z;
sum[now] = 1ll * z * len[now];
return;
}
int mid = (l + r) >> 1;
pushdown(now);
if (mid >= y)
update(now << 1, l, mid, x, y, z);
else if (mid < x)
update(now << 1 | 1, mid + 1, r, x, y, z);
else
update(now << 1, l, mid, x, mid, z),
update(now << 1 | 1, mid + 1, r, mid + 1, y, z);
pushup(now);
}
int Find(int now, int l, int r, int x) {
if (l == r) return l;
int mid = (l + r) >> 1;
pushdown(now);
if (Max[now << 1 | 1] < x)
return Find(now << 1, l, mid, x);
else
return Find(now << 1 | 1, mid + 1, r, x);
}
long long Sum(int now, int l, int r, int x, int y) {
if (x > y) return 0;
if (l == x && r == y) return sum[now];
int mid = (l + r) >> 1;
pushdown(now);
if (mid >= y)
return Sum(now << 1, l, mid, x, y);
else if (mid < x)
return Sum(now << 1 | 1, mid + 1, r, x, y);
else
return Sum(now << 1, l, mid, x, mid) +
Sum(now << 1 | 1, mid + 1, r, mid + 1, y);
}
int query(int now, int l, int r, long long &val) {
if (Min[now] > val) return 0;
if (sum[now] <= val) {
val -= sum[now];
return len[now];
}
int mid = (l + r) >> 1;
pushdown(now);
int lcnt = query(now << 1, l, mid, val);
int rcnt = query(now << 1 | 1, mid + 1, r, val);
return lcnt + rcnt;
}
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
build(1, 1, n);
for (; q; q--) {
scanf("%d%d%d", &op, &x, &y);
if (op == 1) {
int l = (Max[1] < y ? 0 : Find(1, 1, n, y));
update(1, 1, n, l + 1, x, y);
} else {
tot = y + Sum(1, 1, n, 1, x - 1);
printf("%d\n", query(1, 1, n, tot) - (x - 1));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void read(T& res) {
res = 0;
bool bo = 0;
char c;
while (((c = getchar()) < '0' || c > '9') && c != '-')
;
if (c == '-')
bo = 1;
else
res = c - 48;
while ((c = getchar()) >= '0' && c <= '9')
res = (res << 3) + (res << 1) + (c - 48);
if (bo) res = ~res + 1;
}
const int N = 2e5 + 5, M = N << 2;
int n, q, a[N];
long long min_s[M], up_v[M], max_s[M];
long long sum_s[M];
void check(int t, int l, int r, long long v) {
if (l > r) return;
if (v > min_s[t]) {
up_v[t] = max(up_v[t], v);
max_s[t] = max(max_s[t], v);
min_s[t] = v;
sum_s[t] = v * (r - l + 1);
}
}
void push_down(int t, int l, int r) {
if (up_v[t] == 0) {
return;
}
if (l >= r) {
return;
}
int mid = (l + r) >> 1;
check(t << 1, l, mid, up_v[t]);
check(t << 1 | 1, mid + 1, r, up_v[t]);
up_v[t] = 0;
}
void push_up(int t, int l, int r) {
sum_s[t] = sum_s[t << 1] + sum_s[t << 1 | 1];
max_s[t] = max(max_s[t << 1], max_s[t << 1 | 1]);
min_s[t] = min(min_s[t << 1], min_s[t << 1 | 1]);
}
void build(int l, int r, int p) {
if (l == r) return (void)(max_s[p] = min_s[p] = sum_s[p] = a[l]);
int mid = l + r >> 1;
build(l, mid, p << 1);
build(mid + 1, r, p << 1 | 1);
max_s[p] = a[l];
min_s[p] = a[r];
sum_s[p] = sum_s[p << 1] + sum_s[p << 1 | 1];
}
void down(int l, int r, int mid, int p) {
if (l < r && up_v[p] > 0) {
up_v[p << 1] = max_s[p << 1] = min_s[p << 1] = up_v[p];
sum_s[p << 1] = 1ll * (mid - l + 1) * up_v[p];
up_v[p << 1 | 1] = max_s[p << 1 | 1] = min_s[p << 1 | 1] = up_v[p];
sum_s[p << 1 | 1] = 1ll * (r - mid) * up_v[p];
up_v[p] = 0;
}
}
int find_pres(int l, int r, int ul, int ur, long long& x, int p) {
int mid = l + r >> 1;
down(l, r, mid, p);
if (r < ul || l > ur) {
return 0;
}
if (x < min_s[p]) {
return 0;
}
if (ul <= l && ur >= r && sum_s[p] > 0 && sum_s[p] <= x) {
x -= sum_s[p];
return r - l + 1;
}
if (l >= r) {
return 0;
}
int ret = find_pres(l, mid, ul, ur, x, p << 1) +
find_pres(mid + 1, r, ul, ur, x, p << 1 | 1);
return ret;
}
int sum(int t, int l, int r, int ul, int ur, long long& money) {
push_down(t, l, r);
if (r < ul || l > ur) {
return 0;
}
if (money < min_s[t]) {
return 0;
}
if (ul <= l && ur >= r && sum_s[t] > 0 && sum_s[t] <= money) {
money -= sum_s[t];
return (r - l + 1);
}
if (l >= r) {
return 0;
}
long long ret = 0;
int mid = (l + r) >> 1;
if (ul <= mid) {
ret += sum(t << 1, l, mid, ul, ur, money);
}
if (ur >= mid + 1) {
ret += sum(t << 1 | 1, mid + 1, r, ul, ur, money);
}
push_up(t, l, r);
return ret;
}
void update(int t, int l, int r, int ul, int ur, long long v) {
if (r < ul || l > ur) {
return;
}
if (v <= min_s[t]) {
return;
}
if (ul <= l && ur >= r && v >= max_s[t]) {
max_s[t] = max(max_s[t], v);
min_s[t] = max(min_s[t], v);
sum_s[t] = v * (r - l + 1);
up_v[t] = max(up_v[t], v);
return;
}
if (l >= r) {
return;
}
push_down(t, l, r);
int mid = (l + r) >> 1;
if (ul <= mid) {
update(t << 1, l, mid, ul, ur, v);
}
if (ur >= mid + 1) {
update(t << 1 | 1, mid + 1, r, ul, ur, v);
}
push_up(t, l, r);
}
int main() {
int op, x, y;
read(n);
read(q);
for (int i = 1; i <= n; i++) read(a[i]);
memset(up_v, 0, sizeof(up_v));
build(1, n, 1);
while (q--) {
read(op);
read(x);
read(y);
if (op == 2) {
long long yy = y;
int res = sum(1, 1, n, x, n, yy);
printf("%d\n", res);
} else {
update(1, 1, n, 1, x, y);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename F, typename... Args>
void timeit(F func, Args &&...args) {
clock_t start = clock();
func(std::forward<Args>(args)...);
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int maxn = 2e5 + 100;
int val[maxn];
struct seg {
long long sum[maxn * 4], mx[maxn * 4], mn[maxn * 4], lazy[maxn * 4];
inline void pushup(int rt) {
sum[rt] = sum[(rt << 1)] + sum[(rt << 1 | 1)];
mx[rt] = mx[(rt << 1)];
mn[rt] = mn[(rt << 1 | 1)];
}
inline void pushdown(int l, int r, int rt) {
if (lazy[rt] == 0) return;
mx[(rt << 1)] = mx[(rt << 1 | 1)] = lazy[rt];
mn[(rt << 1)] = mn[(rt << 1 | 1)] = lazy[rt];
sum[(rt << 1)] = (((l + r) >> 1) - l + 1) * lazy[rt];
sum[(rt << 1 | 1)] = (r - ((l + r) >> 1)) * lazy[rt];
lazy[(rt << 1)] = lazy[(rt << 1 | 1)] = lazy[rt];
lazy[rt] = 0;
}
void build(int l, int r, int rt) {
if (l == r) {
sum[rt] = mx[rt] = mn[rt] = val[l];
} else {
build(l, ((l + r) >> 1), (rt << 1));
build(((l + r) >> 1) + 1, r, (rt << 1 | 1));
pushup(rt);
}
}
void modify(int ql, int qr, int l, int r, int rt, long long tar) {
if (ql <= l && r <= qr) {
mx[rt] = mn[rt] = tar;
sum[rt] = (r - l + 1) * tar;
lazy[rt] = tar;
return;
}
pushdown(l, r, rt);
if (ql <= ((l + r) >> 1)) modify(ql, qr, l, ((l + r) >> 1), (rt << 1), tar);
if (qr > ((l + r) >> 1))
modify(ql, qr, ((l + r) >> 1) + 1, r, (rt << 1 | 1), tar);
pushup(rt);
}
int query_pos(long long val, int l, int r, int rt) {
if (mx[rt] <= val) return l;
pushdown(l, r, rt);
if (mn[(rt << 1)] <= val)
return query_pos(val, l, ((l + r) >> 1), (rt << 1));
return query_pos(val, ((l + r) >> 1) + 1, r, (rt << 1 | 1));
}
long long query_sum(int ql, int qr, int l, int r, int rt) {
if (ql > qr) return 0;
if (ql <= l && r <= qr) return sum[rt];
pushdown(l, r, rt);
long long ret = 0;
if (ql <= ((l + r) >> 1))
ret = query_sum(ql, qr, l, ((l + r) >> 1), (rt << 1));
if (qr > ((l + r) >> 1))
ret += query_sum(ql, qr, ((l + r) >> 1) + 1, r, (rt << 1 | 1));
return ret;
}
int query_sum_pos(int l, int r, int rt, long long v) {
if (l == r) return l;
pushdown(l, r, rt);
if (sum[(rt << 1)] <= v)
return query_sum_pos(((l + r) >> 1) + 1, r, (rt << 1 | 1),
v - sum[(rt << 1)]);
return query_sum_pos(l, ((l + r) >> 1), (rt << 1), v);
}
} seg_tree;
void solve() {
int n, q;
cin >> n >> q;
for (int i = 1; i <= n; i++) cin >> val[i];
seg_tree.build(1, n + 1, 1);
for (int _i = 0, t, x, y, pos, l, r; _i < q; _i++) {
cin >> t >> x >> y;
if (t == 1) {
pos = seg_tree.query_pos(y, 1, n + 1, 1);
if (pos > x) continue;
seg_tree.modify(pos, x, 1, n + 1, 1, y);
} else {
int ans = 0, mid;
long long tmp;
pos = x;
while (true) {
pos = max(pos, seg_tree.query_pos(y, 1, n + 1, 1));
if (pos > n) break;
tmp = y + seg_tree.query_sum(1, pos - 1, 1, n + 1, 1);
tmp = seg_tree.query_sum_pos(1, n + 1, 1, tmp);
y -= seg_tree.query_sum(pos, tmp - 1, 1, n + 1, 1);
ans += tmp - pos;
pos += tmp - pos;
}
cout << ans << '\n';
}
}
}
signed main() {
ios::sync_with_stdio(false), cin.tie(NULL);
solve();
}
|
#include <bits/stdc++.h>
struct SegmentTree {
int n;
std::vector<int> mn, tag;
std::vector<int64_t> sum;
SegmentTree(const std::vector<int> &a) {
n = a.size();
mn.resize(4 * n);
tag.resize(4 * n);
sum.resize(4 * n);
std::function<void(int, int, int)> build = [&](int p, int l, int r) {
if (r - l == 1) {
mn[p] = sum[p] = a[l];
return;
}
int m = (l + r) / 2;
build(2 * p, l, m);
build(2 * p + 1, m, r);
pull(p);
};
build(1, 0, n);
}
void pull(int p) {
mn[p] = std::min(mn[2 * p], mn[2 * p + 1]);
sum[p] = sum[2 * p] + sum[2 * p + 1];
}
void set(int p, int l, int r, int v) {
tag[p] = v;
mn[p] = v;
sum[p] = int64_t(r - l) * v;
}
void push(int p, int l, int r) {
if (tag[p] > 0) {
int m = (l + r) / 2;
set(2 * p, l, m, tag[p]);
set(2 * p + 1, m, r, tag[p]);
tag[p] = 0;
}
}
void rangeSet(int p, int l, int r, int x, int y, int v) {
if (l >= y || r <= x) return;
if (l >= x && r <= y) return set(p, l, r, v);
int m = (l + r) / 2;
push(p, l, r);
rangeSet(2 * p, l, m, x, y, v);
rangeSet(2 * p + 1, m, r, x, y, v);
pull(p);
}
int bound(int p, int l, int r, int x) {
if (r - l == 1) return mn[p] >= x ? r : l;
int m = (l + r) / 2;
push(p, l, r);
if (mn[2 * p] >= x)
return bound(2 * p + 1, m, r, x);
else
return bound(2 * p, l, m, x);
}
void modify(int x, int y) {
int l = std::min(x, bound(1, 0, n, y));
rangeSet(1, 0, n, l, x, y);
}
int query(int p, int l, int r, int x, int &y) {
if (r <= x) return 0;
if (mn[p] > y) return 0;
if (l >= x && sum[p] <= y) {
y -= sum[p];
return r - l;
}
int m = (l + r) / 2;
push(p, l, r);
int res = query(2 * p, l, m, x, y);
res += query(2 * p + 1, m, r, x, y);
return res;
}
int query(int x, int y) { return query(1, 0, n, x, y); }
};
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
int n, q;
std::cin >> n >> q;
std::vector<int> a(n);
for (int i = 0; i < n; ++i) std::cin >> a[i];
SegmentTree segt(a);
while (q--) {
int t, x, y;
std::cin >> t >> x >> y;
if (t == 1) {
segt.modify(x, y);
} else {
std::cout << segt.query(x - 1, y) << "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5, mod = 998244353;
template <class o>
inline void qr(o &x) {
x = 0;
char c = getchar();
int f = 1;
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + (c ^ 48);
c = getchar();
}
x *= f;
}
template <class o>
void qw(o x) {
if (x / 10) qw(x / 10);
putchar(x % 10 + 48);
}
template <class o>
void pr1(o x) {
if (x < 0) putchar('-'), x = -x;
qw(x);
putchar(' ');
}
template <class o>
void pr2(o x) {
if (x < 0) putchar('-'), x = -x;
qw(x);
puts("");
}
inline int ksm(int a, int b = mod - 2) {
int ans = 1;
for (; b; b >>= 1, a = 1ll * a * a % mod)
if (b & 1) ans = 1ll * ans * a % mod;
return ans;
}
inline int add(int a, int b) { return a += b, a >= mod ? a - mod : a; }
inline int sub(int a, int b) { return a -= b, a < 0 ? a + mod : a; }
int mx[N << 2], mn[N << 2], lz[N << 2], siz[N << 2], a[N];
long long s[N << 2];
void upd(int p) {
mx[p] = mx[p << 1];
mn[p] = mn[p << 1 | 1];
s[p] = s[p << 1] + s[p << 1 | 1];
}
void pushdown(int p) {
if (lz[p]) {
int d = lz[p];
lz[p] = 0;
mx[p << 1] = d;
s[p << 1] = 1ll * siz[p << 1] * d;
mn[p << 1] = d;
lz[p << 1] = max(lz[p << 1], d);
mx[p << 1 | 1] = d;
s[p << 1 | 1] = 1ll * siz[p << 1 | 1] * d;
mn[p << 1 | 1] = d;
lz[p << 1 | 1] = max(lz[p << 1 | 1], d);
}
}
void build(int p, int l, int r) {
siz[p] = r - l + 1;
if (l == r) {
mx[p] = mn[p] = s[p] = a[l];
return;
}
int mid = l + r >> 1;
build(p << 1, l, mid);
build(p << 1 | 1, mid + 1, r);
upd(p);
}
void modify(int p, int l, int r, int x, int d) {
int mid = l + r >> 1;
if (r > x) {
pushdown(p);
if (mid < x) modify(p << 1 | 1, mid + 1, r, x, d);
modify(p << 1, l, mid, x, d);
upd(p);
return;
}
if (mx[p] <= d) {
mx[p] = mn[p] = d;
s[p] = 1ll * siz[p] * d;
lz[p] = max(lz[p], d);
return;
}
if (mn[p] >= d) return;
pushdown(p);
modify(p << 1, l, mid, x, d);
modify(p << 1 | 1, mid + 1, r, x, d);
upd(p);
}
long long sum;
int ans;
void query(int p, int l, int r, int x) {
int mid = l + r >> 1;
if (l < x) {
pushdown(p);
if (x <= mid) query(p << 1, l, mid, x);
query(p << 1 | 1, mid + 1, r, x);
return;
}
if (mn[p] > sum) return;
if (s[p] <= sum) {
sum -= s[p];
ans += siz[p];
return;
}
pushdown(p);
query(p << 1, l, mid, x);
query(p << 1 | 1, mid + 1, r, x);
}
void solve() {
int n, m;
qr(n);
qr(m);
for (int i = 1; i <= n; ++i) qr(a[i]);
build(1, 1, n);
for (int i = 1; i <= m; ++i) {
int op, x, y;
qr(op);
qr(x), qr(y);
if (op == 1)
modify(1, 1, n, x, y);
else
ans = 0, sum = y, query(1, 1, n, x), pr2(ans);
}
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, q, a[200005];
struct nod {
long long mi, mx, s, lazy;
} tr[200005 << 2];
void pushup(long long now, long long l, long long r) {
tr[now].mx = max(tr[(now << 1)].mx, tr[((now << 1) | 1)].mx);
tr[now].mi = min(tr[(now << 1)].mi, tr[((now << 1) | 1)].mi);
tr[now].s = tr[(now << 1)].s + tr[((now << 1) | 1)].s;
}
void mdf(long long now, long long l, long long r, long long v) {
tr[now].mx = tr[now].mi = v;
tr[now].s = (r - l + 1) * v;
tr[now].lazy = v;
}
void pushdown(long long now, long long l, long long r) {
if (l == r) return;
long long mid = (l + r) >> 1;
if (tr[now].lazy) {
tr[(now << 1)].mx = tr[((now << 1) | 1)].mx = tr[(now << 1)].mi =
tr[((now << 1) | 1)].mi = tr[now].lazy;
tr[(now << 1)].s = (mid - l + 1) * tr[now].lazy;
tr[((now << 1) | 1)].s = (r - mid) * tr[now].lazy;
tr[(now << 1)].lazy = tr[((now << 1) | 1)].lazy = tr[now].lazy;
tr[now].lazy = 0;
}
pushup(now, l, r);
}
void ins(long long now, long long l, long long r, long long x, long long y,
long long v) {
if (tr[now].lazy) pushdown(now, l, r);
if (x <= l && r <= y) {
mdf(now, l, r, v);
return;
}
long long mid = (l + r) >> 1;
if (x <= mid) ins((now << 1), l, mid, x, y, v);
if (y > mid) ins(((now << 1) | 1), mid + 1, r, x, y, v);
pushup(now, l, r);
}
long long query(long long now, long long l, long long r, long long k) {
if (tr[1].mi > k) return n + 1;
if (tr[now].lazy) pushdown(now, l, r);
if (l == r) return l;
long long mid = (l + r) >> 1;
if (tr[(now << 1)].mi <= k) return query((now << 1), l, mid, k);
return query(((now << 1) | 1), mid + 1, r, k);
}
long long flag, sum, cnt;
long long solve(long long now, long long l, long long r, long long x) {
if (tr[now].lazy) pushdown(now, l, r);
if (!flag && l == r && x == l) flag = 1;
if (l == r) {
if (flag == 1 && sum >= tr[now].s) {
sum -= tr[now].s;
cnt++;
return 1;
}
return 0;
}
long long mid = (l + r) >> 1;
if (flag == 0) {
if (x <= mid) {
long long adc = solve((now << 1), l, mid, x);
if (adc == 1) adc = solve(((now << 1) | 1), mid + 1, r, x);
return adc;
} else
return solve(((now << 1) | 1), mid + 1, r, x);
} else {
if (sum >= tr[now].s) {
sum -= tr[now].s, cnt += r - l + 1;
return 1;
} else {
long long adc = solve((now << 1), l, mid, x);
if (adc == 1) adc = solve(((now << 1) | 1), mid + 1, r, x);
return adc;
}
}
}
signed main() {
ios::sync_with_stdio(0);
cin >> n >> q;
for (long long i = 1, x; i <= n; i++) cin >> a[i], ins(1, 1, n, i, i, a[i]);
for (long long i = 1, op, x, y; i <= q; i++) {
cin >> op >> x >> y;
if (op == 1) {
long long pos = query(1, 1, n, y);
if (pos > y)
continue;
else
ins(1, 1, n, pos, x, y);
} else {
sum = y, cnt = 0;
while (sum >= tr[1].mi) {
flag = 0;
long long pos = query(1, 1, n, sum);
if (pos < x) pos = x;
long long adc = solve(1, 1, n, pos);
if (adc == 1) break;
}
cout << cnt << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int n, q, a[N], tag[N << 2], mn[N << 2], mx[N << 2];
long long sum[N << 2];
void up(int x) {
sum[x] = sum[(x << 1)] + sum[(x << 1 | 1)];
mn[x] = min(mn[(x << 1)], mn[(x << 1 | 1)]);
mx[x] = max(mx[(x << 1)], mx[(x << 1 | 1)]);
}
void cov(int x, int l, int r, int v) {
tag[x] = v;
sum[x] = 1ll * (r - l + 1) * v;
mn[x] = mx[x] = v;
}
void down(int x, int l, int r) {
if (tag[x]) {
int mid = (l + r) >> 1;
cov((x << 1), l, mid, tag[x]);
cov((x << 1 | 1), mid + 1, r, tag[x]);
tag[x] = 0;
}
}
void build(int x = 1, int l = 1, int r = n) {
if (l == r) {
sum[x] = mn[x] = mx[x] = a[l];
return;
}
int mid = (l + r) >> 1;
build((x << 1), l, mid);
build((x << 1 | 1), mid + 1, r);
up(x);
}
void chkmax(int L, int R, int v, int x = 1, int l = 1, int r = n) {
if (mn[x] >= v) return;
if (L <= l && r <= R && mx[x] <= v) return cov(x, l, r, v);
down(x, l, r);
int mid = (l + r) >> 1;
if (L <= mid) chkmax(L, R, v, (x << 1), l, mid);
if (R > mid) chkmax(L, R, v, (x << 1 | 1), mid + 1, r);
up(x);
}
long long getsum(int L, int R, int x = 1, int l = 1, int r = n) {
if (L > R) return 0;
if (L <= l && r <= R) return sum[x];
down(x, l, r);
int mid = (l + r) >> 1;
long long ret = 0;
if (L <= mid) ret += getsum(L, R, (x << 1), l, mid);
if (R > mid) ret += getsum(L, R, (x << 1 | 1), mid + 1, r);
return ret;
}
int binary1(int v, int x = 1, int l = 1, int r = n) {
if (l == r) return sum[x] <= v ? l : n + 1;
down(x, l, r);
int mid = (l + r) >> 1;
if (mn[(x << 1)] <= v) return binary1(v, (x << 1), l, mid);
return binary1(v, (x << 1 | 1), mid + 1, r);
}
int binary2(long long v, int x = 1, int l = 1, int r = n) {
if (l == r) return sum[x] >= v ? l : n + 1;
down(x, l, r);
int mid = (l + r) >> 1;
if (sum[(x << 1)] >= v) return binary2(v, (x << 1), l, mid);
return binary2(v - sum[(x << 1)], (x << 1 | 1), mid + 1, r);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> q;
for (int i = 1; i <= n; i++) cin >> a[i];
build();
while (q--) {
int op, x, y;
cin >> op >> x >> y;
if (op == 1)
chkmax(1, x, y);
else {
int ans = 0;
while (x <= n) {
long long pre = getsum(1, x - 1);
int t = binary2(pre + y + 1);
ans += t - x;
y -= getsum(x, t - 1);
if (t > n) break;
x = binary1(y);
}
cout << ans << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10, inf = 0x3f3f3f3f, mod = 1e9 + 7;
int n, q;
long long v[N << 2], mx[N << 2], mi[N << 2], tag[N << 2], a[N];
void pushup_(int o) {
v[o] = v[o << 1] + v[o << 1 | 1];
mx[o] = max(mx[o << 1], mx[o << 1 | 1]);
mi[o] = min(mi[o << 1], mi[o << 1 | 1]);
}
void build_(int o, int l, int r) {
if (l == r) {
v[o] = mx[o] = mi[o] = a[l];
return;
}
int mid = (l + r) >> 1;
build_(o << 1, l, mid), build_(o << 1 | 1, mid + 1, r);
pushup_(o);
}
void pushdown(int o, int l, int r) {
if (!tag[o]) return;
tag[o << 1] = tag[o << 1 | 1] = tag[o];
mx[o << 1] = mx[o << 1 | 1] = mi[o << 1] = mi[o << 1 | 1] = tag[o];
int mid = (l + r) >> 1;
v[o << 1] = (mid - l + 1) * tag[o], v[o << 1 | 1] = (r - mid) * tag[o];
tag[o] = 0;
}
void remax_(int o, int l, int r, int x, int y, long long val) {
if (x <= l && r <= y) {
if (mi[o] >= val) return;
if (mx[o] <= val) {
mx[o] = mi[o] = val, tag[o] = val;
v[o] = (r - l + 1) * val;
return;
}
}
pushdown(o, l, r);
int mid = (l + r) >> 1;
if (x <= mid) remax_(o << 1, l, mid, x, y, val);
if (mid < y) remax_(o << 1 | 1, mid + 1, r, x, y, val);
pushup_(o);
}
int query_(int o, int l, int r, int x, int y, int &val) {
if (x <= l && r <= y) {
if (val < mi[o]) return 0;
if (val >= v[o]) {
val -= v[o];
return r - l + 1;
}
}
pushdown(o, l, r);
int mid = (l + r) >> 1, res = 0;
if (x <= mid) res += query_(o << 1, l, mid, x, y, val);
if (mid < y) res += query_(o << 1 | 1, mid + 1, r, x, y, val);
return res;
}
int main() {
scanf("%d%d", &n, &q);
for (int i = (1); i <= (n); i++) scanf("%lld", &a[i]);
build_(1, 1, n);
for (int op, x, y, i = 1; i <= q; i++) {
scanf("%d%d%d", &op, &x, &y);
if (op == 1)
remax_(1, 1, n, 1, x, y);
else
printf("%d\n", query_(1, 1, n, x, n, y));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 200001;
long long a[maxn], n, q, t, x, y;
struct Node {
long long l, r, mi, ma, sum, lazy;
Node(long long ll, long long rr, long long val) {
l = ll, r = rr, lazy = 0;
mi = ma = sum = val;
}
};
Node* seg[4 * maxn];
void push_up(long long v) {
seg[v]->mi = min(seg[v * 2]->mi, seg[v * 2 + 1]->mi);
seg[v]->ma = max(seg[v * 2]->ma, seg[v * 2 + 1]->ma);
seg[v]->sum = seg[v * 2]->sum + seg[v * 2 + 1]->sum;
}
void push_down(long long v) {
if (seg[v]->l == seg[v]->r) return;
if (seg[v]->lazy == 0) return;
long long lazy = seg[v]->lazy;
seg[v]->lazy = 0;
seg[v * 2]->mi = seg[v * 2]->ma = seg[v * 2]->lazy = lazy;
seg[v * 2]->sum = lazy * (seg[v * 2]->r - seg[v * 2]->l + 1);
seg[v * 2 + 1]->mi = seg[v * 2 + 1]->ma = seg[v * 2 + 1]->lazy = lazy;
seg[v * 2 + 1]->sum = lazy * (seg[v * 2 + 1]->r - seg[v * 2 + 1]->l + 1);
}
void build(long long v, long long l, long long r) {
if (l == r) {
seg[v] = new Node(l, r, a[l]);
return;
}
long long m = (l + r) >> 1;
build(v * 2, l, m);
build(v * 2 + 1, m + 1, r);
seg[v] = new Node(l, r, 0);
push_up(v);
}
void update(long long v, long long l, long long r, long long val) {
if (seg[v]->l > r || seg[v]->r < l || seg[v]->mi >= val) return;
if (seg[v]->l >= l && seg[v]->r <= r && seg[v]->ma < val) {
seg[v]->mi = seg[v]->ma = seg[v]->lazy = val;
seg[v]->sum = val * (seg[v]->r - seg[v]->l + 1);
return;
}
push_down(v);
update(v * 2, l, r, val);
update(v * 2 + 1, l, r, val);
push_up(v);
}
long long query(long long v, long long l, long long r, long long& val) {
if (seg[v]->mi > val) return 0;
if (seg[v]->l > r || seg[v]->r < l) return 0;
if (seg[v]->l >= l && seg[v]->r <= r && seg[v]->sum <= val) {
val -= seg[v]->sum;
return seg[v]->r - seg[v]->l + 1;
}
push_down(v);
return query(v * 2, l, r, val) + query(v * 2 + 1, l, r, val);
}
int main() {
cin >> n >> q;
for (long long i = 1; i <= n; i++) cin >> a[i];
build(1, 1, n);
while (q--) {
cin >> t >> x >> y;
if (t == 1) {
update(1, 1, x, y);
continue;
}
cout << query(1, x, n, y) << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define FOR(i, st, n) for (int i = st; i < n; i++)
const int INF = 1e9+100;
int main(){
ios::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin>>t;
while (t--){
string s;
cin>>s;
int n = s.size();
int ans = 0;
for (int i = 0; i < n-1; i++){
if (i < n-2 && s[i] == s[i+1] && s[i] == s[i+2]){
ans+=2;
i += 2;
}else if(s[i] == s[i+1]){
ans++;
i++;
}else if(i < n-2 && s[i] == s[i+2]){
ans++;
if (i < n-3 && s[i+1] == s[i+3]){
ans++;
i+=3;
}else{
i+=2;
}
}
}
cout<<ans<<'\n';
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define N 100005
typedef long long LL;
typedef unsigned long long ULL;
int main()
{
int k,j,i,tt,temp;
cin>>tt;
while(tt--)
{
int n,a[N]={0},ans=0;
char cha[N]={0},chb[1],ch;
cin>>cha+1;
for(i=2;cha[i]!=0;i++)
{
if(cha[i]==cha[i-1]&&cha[i-1]!=1)
{
cha[i]=1;
ans+=1;
}
if(cha[i-1]==cha[i+1]&&cha[i-1]!=1)
{
cha[i+1]=1;
ans+=1;
}
}
cout<<ans<<endl;
//cout<<endl;
}
return 0;
}
|
#define rep(i,n) for (int i=0;i < (int)(n);i++)
#define ALL(v) v.begin(),v.end()
typedef long long ll;
#include <bits/stdc++.h>
using namespace std;
int main(){
int t;
cin>>t;
while(t--){
string s;
cin>>s;
int n=s.size();
int cnt=0;
for(int i=1;i<n;i++){
if(s[i]==s[i-1]){
cnt++;
s[i]='A';
}
else if(i>1 && s[i]==s[i-2]){
cnt++;
s[i]='B';
}
}
cout<<cnt<<endl;
}
return 0;
} |
/*starting with the name of almighty ALLAH*/
/*solved by RAKIB JOY*/
// Practice is the only shortcut to improve
#include<bits/stdc++.h>
#define ll int
#define pb push_back
#define vc vector
#define vi vc<int>
#define vl vc<ll>
#define dbg(x) cout<<x<<endl;
#define mp(x,y) make_pair(x,y)
#define yes dbg("YES")
#define no dbg("NO")
#define tst int t;cin>>t;while(t--)
#define srt(v) sort(v.begin(),v.end());
#define rsrt(v) sort(v.rbegin(),v.rend());
#define rj ios::sync_with_stdio(false);cin.tie(0);
#define rvs(v) reverse(v.begin(),v.end());
#define F first
#define S second
#define mod 1000000007
#define gcd(a,b) __gcd(a,b)
#define lcm(a,b) (a*b)/gcd(a,b)
#define PI 2*acos(0.0)
#define pii pair<int,int>
#define fr(i,a,b) for(ll i=a;i<=b;i++)
#define coutv(v) for(auto it:v)cout<<it<<' ';cout<<endl;
#define cinv(v) for(auto &it:v)cin>>it;
#define all(v) v.begin(),v.end()
#define rall(v) v.rbegin(),v.rend()
#define ld long double
using namespace std;
/*#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
template<typename T> using ordered_set =tree<T, null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update>;
*/
//sieve bool b[1000005];void primenire(){int i, j;b[0]=true;b[1]=true;for(i=4; i<=1000000; i+=2){b[i]=true;}for(i=3; i<=1001; i+=2){if(!b[i]){for(j=i*i; j<=1000001; j+=2*i){b[j]=true;}}}}
// power ll power(ll a,ll b){if(b==0)return 1LL;if(b&1)return a*power(a,b-1);else{ll x=power(a,b/2);return x*x;}}
//bigmod long long int m(long long int a,long long int b,long long int c){if(b==0)return 1;if(b%2==0){long long int tmp=m(a,b/2,c);return ((tmp%c)*(tmp%c))%c;}elsereturn ((a%c)*(m(a,b-1,c)%c))%c;}
//MaxSubarraySum ll mss(vector<ll>v){ll mx=v[0];ll sz=v.size();for(int i=1;i<=sz;i++){ll t=v[i]+v[i-1];if(t>=v[i]) v[i]=t;mx=max(mx,v[i]*1LL);}return mx;}
//combination ll com[1001][1001];void combination(){com[1][1]=1;com[1][0]=1;for(ll i=2; i<=1000; i++){com[i][0]=1;for(ll j=1; j<=i; j++){com[i][j]=com[i-1][j]+com[i-1][j-1];}}}
///--------------Graph Moves--------------------------------------
///const int fx[] = {+1,-1,+0,+0};
///const int fy[] = {+0,+0,+1,-1};
///const int fx[] = {+0,+0,+1,-1,-1,+1,-1,+1}; ///King's move
///const int fy[] = {-1,+1,+0,+0,+1,+1,-1,-1}; ///king's Move
///const int fx[] = {-2,-2,-1,-1,+1,+1,+2,+2}; ///knight's move
///const int fy[] = {-1,+1,-2,+2,-2,+2,-1,+1}; ///knight's move
///---------------------------------------------------------------
string s;
ll sz;
int dp[100001][3][3];
ll goriberDP(ll in,ll o,ll t)
{
if(in>=sz)
return 0;
if(dp[in][o][t]!=-1)
return dp[in][o][t];
if(t)
{
if(s[in-1]==s[in])
return dp[in][o][t]=1+goriberDP(in+1,t,0);
}
if(o)
{
if(s[in-2]==s[in])
return dp[in][o][t]=1+goriberDP(in+1,t,0);
}
return dp[in][o][t]=min(1+goriberDP(in+1,t,0),goriberDP(in+1,t,1));
}
void solve()
{
cin>>s;
sz=s.size();
fr(i,0,sz)
{
fr(j,0,2) fr(k,0,2) dp[i][j][k]=-1;
}
cout<<goriberDP(0,0,0)<<endl;
}
int main()
{
rj
tst
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define pi acos(-1)
#define inc(a) a.begin(), a.end()
#define dec(a) a.rbegin(), a.rend()
#define Unique(n) (n).erase(unique(inc(n)), (n).end())
#define what_is(x) cerr << #x << " is " << x << '\n';
#define to(i, a, n) for(int i=a; i<n; i++)
#define fr(i, a, n) for(int i=a; i>=n; i--)
#define read(arr, l, r) for(int i=l; i<r; cin >> arr[i++])
#define prnt(arr, l, r) for(int i=l; i<r; cout << arr[i++] << " \n"[i==r])
typedef long long ll;
typedef long double ld;
int dx[] = {0, 1, 0, -1};
int dy[] = {1, 0, -1, 0};
int t, n, ans;
string s;
int main(){
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> t;
while(t--){
cin >> s, n = s.size();
s += "aaa", ans = 0;
to(i, 1, n) if(i == 1 && s[i] == s[i-1]){
ans++;
to(j, 'a', 'z'+1) if(j!=s[i-1] && j!=s[i+1] && j!=s[i+2]){
s[i] = j; break;
}
}else if(s[i]==s[i-1] || s[i]==s[i-2]){
ans++;
to(j, 'a', 'z'+1) if(j!=s[i-2] && j!=s[i-1] && j!=s[i+1] && j!=s[i+2]){
s[i] = j; break;
}
}
cout << ans << '\n';
}
return 0;
}
|
/*author - Kishor Kumar*/
#include<bits/stdc++.h>
using namespace std;
#define pow2(x) ((x)*(x));
#define max3(a,b,c) max(a,max(b,c))
#define min3(a,b,c) min(a,min(b,c))
#define ll long long
#define ld long double
#define eb emplace_back
#define pb push_back
#define mod 1000000007
#define mp make_pair
#define ff first
#define ss second
#define all(c) (c).begin(),(c).end()
#define nl "\n"
#define fast ios_base::sync_with_stdio(false),cin.tie(0),cout.tie(0)
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<vi> vvi;
typedef vector<vl> vvl;
typedef pair<int,int> pi;
typedef vector<pair<ll,ll>> vpl;
typedef pair<ll,ll> pl;
typedef map<ll,ll> ml;
typedef map<int,int> mi;
typedef unordered_map<int,int> umi;
typedef unordered_map<char,int> umc;
typedef unordered_set<int> usi;
typedef stack<int> st;
void solve(){
string s;
cin>>s;
int c = 0;
for(int i=1;i<s.size();i++){
if(s[i-1] == s[i] || (i>1 && s[i-2] == s[i])){
c++;
s[i] = '0';
}
}
cout<<c;
}
int main()
{
fast;
ll t;
cin>>t;
while(t--){
solve();
cout<<nl;
}
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
#define ll long long
ll mod = 1000000007;
int main()
{
int t;
cin>>t;
while(t--){
string s;
cin>>s;
ll c=0;
if(s[0]==s[1]){
c++;
s[1]='*';
}
for(ll i=2;i<s.size();i++){
if(s[i-1]==s[i]){
c++;
s[i]='*';
}else if(s[i-2]==s[i]){
c++;
s[i]='*';
}
}
cout<<c<<endl;
}
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
int main()
{
int t;
cin>>t;
while(t--)
{
int c=0;
string s;
cin>>s;
int prev=1;
for(int i=1;i<s.length();i++)
{
if(s[i]==s[i-1])
{
s[i]='#';
c++;
prev++;
}
else if(i>1&&s[i]==s[i-2])
{
s[i]='#';
c++;
prev++;
}
}
cout<<c<<endl;
}
}
|
/// (c) Rahimov Voris, 2020.
/*
.:*+=%@@@@@@=-.
.:=@#@@@#@@#######%==*.
.-=####@######%*-.....:%##%.
.*@###########%+:--........-%@-
.*@##############@+--.........-:%-
.+##################@==%%%%=+*:----+.
.-@####################%++%@@@@@=+**%@@*
.%###################@%%@@@###@%+:--%@@%.
-@###################@%%%%*::*%++:-----=@+.
-#####################@%=++++++*:-------.-=:
.+####################@%++*::-:::--::*:::***=:
.@#####################%=++*::::-:::++*=##@@#@-
..#####################@%%=++**:::::**+%@#@%%##-..
.%####################@@%=+++*+****::*=@######@.
.=######################@%%==+==++**+=@%@##@###+:...
-#######################@@@%%%===++=@@@%=++===*::--...
-########################@@@@@@@%==%%=++==@@:::::*:--.
..:#########################@@@@@@%%======++++::-..:-.--...
%#############################@###@%%@@%==%=%*----.--.::---.
#############################################*-:*:-:---*---- .
#############################################*--*--:---*---:-.
#############################################+--::--::-*::-::.
###########################################+:*-.---.---.:---*-..
###########################################**:-----------------.
##########################################@::**:--::::::--:::::-
###########################################:--:*:::::::::**::*+*
###########################################=:::***::::::**:::*+*
############################@@@@@@#########@+****::::********+++
############################@%%%%%@@@@@@@###%+***::::::::***+==+
############################@%%%%%%%%%%%@####=+:::-::::-::*+=%%+
#############################@%%%%%%%%%%@#####=::--------:*=%@%+
%###########################@%%%%==%%%%%%@##@#=:------..-:+%@@%=
----------------------------------------------
--------------------------------------------
----------------------------------------------
--------------------------------------------
----------------------------------------------
o###########oo
o##" ""##o
o#" "##
o#" "#o
#" ## ## "##
#" ##
# ################### #
# #
# #
# #
# #
# #
# #
#o #
"#o ##
"#o ##
"#o o#"
"#o ##
"#o o#"
"#ooo ooo#######oo
############### "######o
o###"" "###o # ###
o###o oooo ### oo####"
o###**# #**# ############"
""##""""""""""########### #
# oooooooo#"#** ## #
# # # # ** ## #
#o# #o# *****###ooo#
##
## o###o
## o##***##
o########## #***#**##o
o##" ""### #***##***#
o#######o ### oo#### ##**####*#
o##" ""#############"" ##****###
##" ## ##*##*###
## ### ##### ##
## ### # ## #
## ## #
## ##
## ###
## ###oo
### ""###
###
###
*/
#pragma GCC optimize ("O3")
#pragma GCC target ("sse4")
#include<bits/stdc++.h>
using namespace std;
#define ld long double
#define fi first
#define se second
#define pb push_back
#define pf push_front
#define sukanujnaskorost ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define endl '\n'
#define rep(i, a, b) for(int i = (a); i <= (b); i++)
long long mod = 1000000000 + 7;
long long N = 100107;
long long binpow(long long x, long long y)
{
if(y == 1)
return x;
else if(y % 2 == 0)
{
long long w = binpow(x, y / 2);
return w * w;
}
else
return x * binpow(x, y - 1);
}
long long factorial(long long n)
{
long long s = 1;
for(long long i = 1; i <= n; i++)
s *= i;
return s;
}
long long c[200000];
int main()
{
sukanujnaskorost
// freopen("input.in","r",stdin);
// freopen("output.out","w",stdout);
long long t = 1;
cin >> t;
while (t--){
string stroka;
long long answer = 0;
map<long long, bool> used;
cin >> stroka;
for (int i = 0; i < stroka.size() - 1; i++) {
if (stroka[i] == stroka[i + 1] && used[i] == false) {
used[i + 1] = true;
answer++;
}
if (i > 0 + 1 - 1 && used[i - 1 + 1 - 1] == false && stroka[i + 1 + 1 - 1] == stroka[i - 1 + 1 - 1]) {
used[i + 1 + 1 -1] = true;
answer++;
}
}
cout << answer + 1 - 1 << "\n";
}
}
|
#include<iostream>
#include<vector>
#include<cstring>
#include<map>
#include<bitset>
#include<assert.h>
#include<algorithm>
#include<iomanip>
#include<cmath>
#include<set>
#include<queue>
#include<sstream>
#include<unordered_map>
#include<unordered_set>
#include<chrono>
#include<stack>
#include<deque>
#include<random>
#define long long long
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int N=1e5,inf=1e9,mod=1e9+7;
//int dp[N+2][26+2][26+2];
map<int,int>dp[26+2][26+2];
string s;
int dfs(int id,int a,int b)
{
if(id>=(int)s.size())return 0;
if(dp[a][b].count(id))return dp[a][b][id];
//if(dp[id][a][b]!=-1)return dp[id][a][b];
int ret=1+dfs(id+1,b,26);
if((s[id]-'a'!=a) && (s[id]-'a'!=b))
ret=min(ret,dfs(id+1,b,s[id]-'a'));
return dp[a][b][id]=ret;
}
int main()
{
ios_base::sync_with_stdio(0);cin.tie(0);
int t;cin>>t;
while(t--)
{
cin>>s;
if((int)s.size()==1)
{
cout<<0<<'\n';continue;
}
// for(int i=0;i<=(int)s.size();i++)
// {
// for(int j=0;j<=26;j++)
// for(int k=0;k<=26;k++)dp[i][j][k]=-1;
// }
for(int i=0;i<=26;i++)for(int j=0;j<=26;j++)dp[i][j].clear();
int ans=2+dfs(2,26,26);
ans=min(ans,1+dfs(2,26,s[1]-'a'));
ans=min(ans,1+dfs(2,s[0]-'a',26));
if(s[0]!=s[1])ans=min(ans,dfs(2,s[0]-'a',s[1]-'a'));
cout<<ans<<'\n';
}
return 0;
} |
#include <bits/stdc++.h>
#define ll long long
#define pi pair<int, int>
#define pf pair<float, int>
#define ps pair<string, int>
#define pii pair<pi, int>
#define mi map<int, int>
#define ms map<string, int>
#define mc map<char, int>
#define mpi map<pi, int>
#define F first
#define S second
#define vt vector
#define vi vector<int>
#define vd vector<double>
#define vf vector<float>
#define vl vector<long long>
#define vpi vector<pi>
#define vpf vector<pf>
#define vpii vector<pii>
#define st set
#define si set<int>
#define sd set<double>
#define sf set<float>
#define sl set<long long>
#define FOR(t, q) for(int q = 0; q < t; q++)
#define FORV(a, x) for (auto& a : x)
#define sz(v) (int)(v.size())
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
#define B(v) v.begin()
#define RB(v) v.rbegin()
#define E(v) v.end()
#define RE(v) v.rend()
#define LOWER(s) transform(s.begin(), s.end(), s.begin(), ::tolower)
#define UPPER(s) transform(s.begin(), s.end(), s.begin(), ::toupper)
#define TC int _t; cin >> _t; FOR(_t, _q)
using namespace std;
void solve(){
string s; cin >> s;
int n = s.length(), cnt = 0;
for(int i = 1; i < n; i++) {
if(s[i-1] == s[i] || s[i-2] == s[i]) cnt++, s[i] = 0;
}
cout << cnt << endl;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
TC solve();
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=1e6+50;
int a[N];
int main(){
int T;cin>>T;
while(T--){
string s;cin>>s;
int ans=0;
for(int i=0;s[i];i++){
if(s[i]=='*') continue;
if(i+2<s.size() && s[i]==s[i+2]){
++ans;
s[i+2]='*';
}
if(i+1<s.size() && s[i]==s[i+1]){
++ans;
s[i+1]='*';
}
}
cout<<ans<<endl;
}
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
#define PI 3.14159265
#define seive_len 1000001
typedef long long int lli;
bool seive[seive_len];
const int MOD = 1000000007;
lli primeSeive[seive_len];
lli gcd(lli a, lli b) {
if(b == 0)
return a;
return gcd(b, a%b);
}
lli lcm(lli a, lli b) {
lli gcd_ = gcd(a, b);
lli lcm_ = (a*b)/gcd_;
return lcm_;
}
lli ncr(lli n, lli r) {
lli res = 1;
if(r > n-r)
r = n-r;
for(lli i=0;i<r;i++) {
res *= (n-i);
res /= (i+1);
}
return res;
}
lli ncrMODp(lli n, lli r) {
if(r > n-r)
r = n-r;
lli prow[r+1];
memset(prow, 0, sizeof(prow));
prow[0] = 1;
for(lli i=1;i<=n;i++) {
for(lli j=min(i, r);j>0;j--) {
prow[j] = (prow[j]+prow[j-1])%MOD;
}
}
return prow[r];
}
lli fastPower(lli a, lli b) {
lli res=1;
while(b > 0) {
if(b&1)
res *= a;
a *= a;
b >>= 1;
}
return res;
}
lli fastPowerMODp(lli a, lli b) {
a %= MOD;
lli res = 1;
while(b) {
if(b%2 == 1)
res = (res*a)%MOD;
a = (a*a)%MOD;
b >>= 1;
}
return res;
}
void multiply(lli a[][2], lli b[][2]) {
lli res[2][2];
memset(res, 0, sizeof(res));
for(lli i=0;i<2;i++) {
for(lli j=0;j<2;j++) {
for(lli k=0;k<2;k++) {
res[i][j] += a[i][k]*b[k][j]%MOD;
}
}
}
for(lli i=0;i<2;i++)
for(lli j=0;j<2;j++)
a[i][j] = res[i][j];
}
void matrixExpo(lli a[][2], lli n) {
if(n == 0 || n == 1)
return;
lli b[][2] = {{1,1}, {1,0}};
matrixExpo(a, n/2);
multiply(a, a);
if(n%2)
multiply(a, b);
}
void makeSeive() {
for(lli i=2;i*i<=seive_len;i++) {
if(seive[i]) {
for(lli j=i*i;j<=seive_len;j+=i)
seive[j] = false;
}
}
}
void makePrimeSeive() {
for(lli i=1;i<seive_len;i++)
primeSeive[i] = i;
for(lli i=4;i<seive_len;i+=2)
primeSeive[i] = 2;
for(lli i=3;i*i<seive_len;i++) {
if(primeSeive[i] == i) {
for(lli j=i*i;j<seive_len;j+=i) {
if(primeSeive[j] == j)
primeSeive[j] = i;
}
}
}
}
bool isPrime(lli n) {
for(lli i=2;i<=sqrt(n);i++) {
if(n%i == 0)
return false;
}
return true;
}
void getInput(vector<lli>& a, lli n) {
lli x;
for(lli i=0;i<n;i++) {
cin >> x;
a.push_back(x);
}
}
void testCase() {
string s;
cin >> s;
int n = s.size();
lli res = 0;
if(n == 1)
res = 0;
else if(n == 2)
res = s[0]==s[1];
else {
bool is[n];
memset(is, false, sizeof is);
for(int i=1;i<n;i++) {
if(i > 1 && is[i-2] == false && s[i-2] == s[i]) {
res++;
is[i] = true;
}
if(is[i-1] == false && s[i-1] == s[i]) {
is[i] = true;
res++;
}
}
}
cout << res;
}
int main() {
// ios_base::sync_with_stdio(false);
// cin.tie(NULL);
lli t=1;
cin >> t;
// makePrimeSeive();
// FILE* fp;
// fp = fopen("out.txt", "w");
for(lli i=1;i<=t;i++) {
// fprintf(fp, "Case #%d:\n", i);
// cout << "Case #" << i << ":" << ' ';
testCase();
cout << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int M = 1000000000;
bool isGood(string& s, int i, int c)
{
if (i > 0) if (s[i - 1] - 'a' == c) return false;
if (i > 1) if (s[i - 2] - 'a' == c) return false;
if (i < s.size() - 1) if (s[i + 1] - 'a' == c) return false;
if (i < s.size() - 2) if (s[i + 2] - 'a' == c) return false;
return true;
}
int main()
{
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
for (int t1 = 0; t1 < t; t1++)
{
string s;
cin >> s;
string org = s;
int n = s.size();
if (n == 1) cout << 0 << "\n";
else
{
vector<vector<vector<int>>> dp(n, vector<vector<int>>(2, vector<int>(2, M)));
if (s[0] == s[1]) {
dp[1][0][0] = M;
} else dp[1][0][0] = 0;
dp[1][1][0] = 1;
dp[1][0][1] = 1;
dp[1][1][1] = 2;
for (int i = 2; i < n; i++)
{
for (int j = 0; j <= 1; j++)
{
for (int k = 0; k <= 1; k++)
{
for (int l = 0; l <= 1; l++)
{
if (k == 0 && l == 0)
{
if (s[i] == s[i - 1])
{
continue;
}
}
if (j == 0 && l == 0)
{
if (s[i] == s[i - 2])
{
continue;
}
}
dp[i][k][l] = min(dp[i][k][l], dp[i - 1][j][k] + l);
//cout << i << " " << k << " " << l << " e " << " " << j << k << endl;
//cout << dp[i][k][l] << endl;
}
}
}
}
int best = M;
for (int i = 0; i < 2; i++)
{
for (int j = 0; j < 2; j++)
{
best = min(best, dp[n - 1][i][j]);
}
}
cout << best << "\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
#define int long long
//#define double long double
#define f first
#define s second
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define pb push_back
#define eb emplace_back
#define pii pair<int, int>
//#define _USE_MATH_DEFINES
const int maxn = 100000, k = 26;
int dp[26][26], prv[26][26];
void solve() {
string s;
cin >> s;
int n = s.size();
if (n == 1) {
cout << 0 << '\n';
return;
}
for (int i = 0; i < k; ++i) {
for (int j = 0; j < k; ++j) {
dp[i][j] = prv[i][j] = 0;
if (s[0]-'a' != i)
prv[i][j]++;
if (s[1]-'a' != j)
prv[i][j]++;
if (i == j)
prv[i][j] = maxn+1;
dp[i][j] = prv[i][j];
}
}
for (int i = 2; i < n; ++i) {
for (int j1 = 0; j1 < k; ++j1) {
for (int j2 = 0; j2 < k; ++j2) {
prv[j1][j2] = dp[j1][j2];
dp[j1][j2] = maxn+1;
}
}
for (int j1 = 0; j1 < k; ++j1) {
int m1 = 0, m2 = 1;
if (j1 == 0)
m1 = 2;
if (j1 == 1)
m2 = 2;
if (prv[m1][j1] > prv[m2][j1])
swap(m1, m2);
for (int j2 = max(m1, m2)+1; j2 < k; ++j2) {
if (j2 != j1) {
if (prv[j2][j1] < prv[m1][j1]) {
m2 = m1;
m1 = j2;
} else if (prv[j2][j1] < prv[m2][j1]) {
m2 = j2;
}
}
}
for (int j2 = 0; j2 < k; ++j2) {
if (j2 != j1) {
if (j2 == m1)
dp[j1][j2] = prv[m2][j1];
else
dp[j1][j2] = prv[m1][j1];
if (s[i]-'a' != j2)
dp[j1][j2]++;
}
}
}
}
int ans = maxn+1;
for (int i = 0; i < 26; ++i) {
for (int j = 0; j < 26; ++j) {
ans = min(ans, dp[i][j]);
}
}
cout << ans << '\n';
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
int main(void)
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin>>t;
while(t--)
{
string s;
cin>>s;
int n = s.length(), ans=0;
for(int i=0;i<n-1;i++)
{
if(s[i]==s[i+1] && s[i]!='*')
{
ans++;
s[i+1]='*';
}
if(i<n-2)
{
if(s[i]==s[i+2] && s[i]!='*')
{
ans++;
s[i+2]='*';
}
}
}
cout<<ans<<"\n";
}
} |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
void test_case() {
string s;
cin >> s;
int n = (int)s.size();
vector<pair<int,int>> vec;
vector<bool> fix(n);
for (int i = 0; i < n; i++) fix[i] = false;
for (int i = 0; i < n - 1; i++) {
if (s[i] == s[i+1]) {
vec.emplace_back(i,i+1);
}
}
for (int i = 0; i < n - 2; i++) {
if (s[i] == s[i+2]) {
vec.emplace_back(i,i+2);
}
}
sort(vec.begin(),vec.end());
int ans = 0;
for (int i = 0; i < (int)vec.size(); i++) {
int s = vec[i].first;
if (vec[i].second - vec[i].first == 2) {
if (!fix[s] && !fix[s + 2]) {
ans++;
fix[s + 2] = true;
}
} else {
if (!fix[s] && !fix[s + 1]) {
ans++;
fix[s + 1] = true;
}
}
}
cout << ans << endl;
}
int main() {
int t;
cin >> t;
for (int i = 0; i < t; i++) {
test_case();
}
} |
#include <bits/stdc++.h>
using namespace std;
int t, n, ans;
char s[100010];
int main()
{
cin >> t;
while(t--)
{
scanf("%s", s + 1);
n = strlen(s + 1);
ans = 0;
s[n + 1] = s[n + 2] = 'A';
for(int i = 2; i <= n; i++)
{
if(s[i] == s[i - 1] && i > 1)
{
for(char j = 'a'; j <= 'z'; j++)
if(j != s[i + 1] && j != s[i - 1] && j != s[i - 2] && j != s[i + 2])
{
s[i] = j;
break;
}
ans++;
}
if(s[i] == s[i - 2] && i > 2)
{
for(char j = 'a'; j <= 'z'; j++)
if(j != s[i] && j != s[i - 1] && j != s[i + 1] && j != s[i + 2])
{
s[i] = j;
break;
}
ans++;
}
}
cout << ans << endl;
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
inline vector<int> getD1(string s){
int n = s.size();
vector<int> d1 (n);
int l=0, r=-1;
for (int i=0; i<n; ++i) {
int k = i>r ? 1 : min (d1[l+r-i], r-i+1);
while (i+k < n && i-k >= 0 && s[i+k] == s[i-k]) ++k;
d1[i] = k;
if (i+k-1 > r)
l = i-k+1, r = i+k-1;
}
return d1;
}
inline vector<int> getD2(string s){
int n = s.size();
vector<int> d2 (n);
int l=0, r=-1;
for (int i=0; i<n; ++i) {
int k = i>r ? 0 : min (d2[l+r-i+1], r-i+1);
while (i+k < n && i-k-1 >= 0 && s[i+k] == s[i-k-1]) ++k;
d2[i] = k;
if (i+k-1 > r)
l = i-k, r = i+k-1;
}
return d2;
}
int main(){
#ifdef nurik
freopen("in", "r", stdin);
#endif
ios_base::sync_with_stdio(0);
int t;
cin >> t;
while(t--){
string s;
int n, res = 0;
cin >> s;
n = s.size();
for(int i=0; i<n; ++i){
if(i < n - 1 && s[i] == s[i + 1] && s[i] != '.'){
++res;
s[i + 1] = '.';
}
if(i > 0 && i < n - 1 && s[i + 1] == s[i - 1] && s[i + 1] != '.'){
s[i + 1] = '.';
++res;
}
}
cout << res << "\n";
}
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define F first
#define S second
const int MXN = 200040;
int cnt[MXN];
bool b[MXN];
ll n,d;
int main(){
int t;
cin >> t;
while(t--){
string s;
cin >> s;
int n = s.size();
int ans = 0;
bool b[n+3];
for(int i = 0 ; i < n+3 ; i++){
b[i] = 0;
}
for(int i = 1 ; i < n ; i++){
if(i == 1){
if(s[i] == s[i-1]){
b[i] = 1;
ans++;
}
continue;
}
if(s[i] != s[i-1] && s[i] != s[i-2])continue;
if(s[i] == s[i-1] && s[i] == s[i-2]){
if(b[i-1] && b[i-2])continue;
b[i] = 1;
ans++;
continue;
}
if(s[i] == s[i-1] && s[i] != s[i-2]){
if(b[i-1])continue;
b[i] = 1;
ans++;
continue;
}
if(s[i] == s[i-2] && s[i] != s[i-1]){
if(b[i-2])continue;
b[i] = 1;
ans++;
continue;
}
}
cout << ans << "\n";
}
} |
#include <bits/stdc++.h>
#define rep(i,a,b) for (int i=a;i<=b;++i)
#define per(i,a,b) for (int i=a;i>=b;--i)
#define mst(x,a) memset(x,a,sizeof(x))
using namespace std;
typedef long long ll;
typedef double db;
const int MAXN = 1e5+5;
int MAX(int a,int b) {return a>b?a:b;}
int MIN(int a,int b) {return a<b?a:b;}
char a[MAXN];
int main() {
int t; cin >> t;
while (t--) {
int ans = 0;
cin >> a;
for (int i=1;a[i];++i) {
if ((i>=1 && a[i] == a[i-1]) || (i>=2 && a[i] == a[i-2])) {
a[i] = '?';
ans++;
}
}
cout<<ans<<endl;
}
return 0;
}
/*
abaaa
ab?aa
ab?a?
*/ |
#include <bits/stdc++.h>
typedef long long ll;
using namespace std;
int main()
{
ll t;
cin>>t;
while(t--)
{
string s;
cin>>s;
ll ans=0;
ll x=0;
ll n=s.size();
for(ll i=0;i<n-1;i++)
{
if(i+2<n){
if(s[i]==s[i+1]&&s[i+1]==s[i+2]&&s[i]!='0')
{
s[i+1]='0';
s[i+2]='0';
x=x+2;
i=i+2;
}
else if(s[i]==s[i+2]&&s[i]!='0')
{
s[i+2]='0';
x++;
if(i+3<n)
{
if(s[i+1]==s[i+3])
{
x++;
s[i+3]=0;
i++;
}
}
i=i+2;
}
else if(s[i]==s[i+1]&&s[i]!='0')
{
x++;
s[i+1]='0';
i++;
}
}
else if(s[i]==s[i+1]&&s[i]!='0')
{
x++;
s[i+1]='0';
i++;
}
}
cout<<x<<endl;
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
const int maxn=1010;
int t;
string s;
int main () {
scanf("%d",&t);
while (t--) {
cin>>s;
int ans=0;
for (int i=1;i<s.size();i++) {
if (i-1>=0&&s[i]==s[i-1]) {
s[i]='#';
ans++;
}
else if (i-2>=0&&s[i]==s[i-2]) {
s[i]='#';
ans++;
}
}
printf("%d\n",ans);
}
} |
#include<bits/stdc++.h>
using namespace std;
int main(){
int t;
cin>>t;
while(t--){
string s;
cin>>s;
int c=0;
for(int i=1;i<s.size();++i){
if(s[i]==s[i-1]){
s[i]='@';
c++;
}
else{
if(i>1 && s[i]==s[i-2]){
s[i]='@';
c++;
}
}
}
cout<<(c)<<endl;
}
} |
#include<bits/stdc++.h>
#define limit (int)(2e5 + 5)
#define mod (int)(1e9 + 7)
#define inf 1e16;
#define pb push_back
#define fi first
#define se second
using namespace std;
using lli = long long int;
using ld = long double;
using ulli = unsigned long long int;
int n;
string s;
stack<char> st;
char c[limit];
void ini()
{
n = s.length();
while(st.size() > 0)
st.pop();
return;
}
int main()
{
ios_base::sync_with_stdio (false);
cin.tie(NULL);
int testn=1;
cin >> testn;
for (int casen = 0; casen < testn; ++casen)
{
cin >> s;
ini();
if(n == 1)
{
cout << 0 << "\n";
continue;
}
if (n == 2)
{
cout << (s[1] == s[0]) << "\n";
continue;
}
int ans = 0,in = 1;
c[0] = s[0];
if(s[1] == s[0])
{
ans++;
s[1] = '_';
}
for (int i = 2; i < n; ++i)
{
if(s[i] == s[i-1] || s[i] == s[i-2])
{
ans++;
s[i] = '_';
continue;
}
}
cout << ans << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(){
int t; cin>>t;
while(t--){
string s; cin>>s;
int ans = 0;
for(int i=1; i<s.size();++i){
if(s[i]==s[i-1]||s[i]==s[i-2])
s[i]='Z', ++ans;
}
cout<<ans<<'\n';
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
const ll MOD = 1e9+7;
int main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t; cin >> t;
while(t--){
string s; cin >> s;
int changes = 0;
s = "00"+s+"00";
for (int i=2; i<s.size()-2; i++){
set<char> alph = {'q', 'w', 'e', 'r', 't'};
if (s[i]==s[i-1] or s[i]==s[i-2]){
alph.erase(s[i-1]);
alph.erase(s[i-2]);
alph.erase(s[i+1]);
alph.erase(s[i+2]);
s[i] = *s.begin();
changes++;
}
}
cout << changes << endl;
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
int dp[2][30][30];
string s;
void solve_tc(){
cin >> s;
int n = s.size();
for(int i=0;i<=1;i++) for(int j=0;j<=27;j++) for(int k=0;k<=27;k++) dp[i][j][k] = 1e9;
dp[0][0][1] = 0;
for(int i=1;i<=n;i++){
int u = s[i-1] - 'a' + 2;
for(int j=0;j<=27;j++) for(int k=0;k<=27;k++) dp[i%2][j][k] = 1e9;
for(int j=0;j<=27;j++){
for(int k=0;k<=27;k++) if(j != k){
if(j != u && k != u) dp[i%2][k][u] = min(dp[i%2][k][u], dp[!(i%2)][j][k]);
dp[i%2][k][0] = min(dp[i%2][k][0], dp[!(i%2)][j][k] + 1);
dp[i%2][k][1] = min(dp[i%2][k][1], dp[!(i%2)][j][k] + 1);
}
}
}
int ans = 1e9;
for(int i=0;i<=27;i++) for(int j=0;j<=27;j++) ans = min(ans, dp[n%2][i][j]);
cout << ans;
}
int main(){
ios_base::sync_with_stdio(0);cin.tie(0);
int tc = 1;
cin >> tc;
while(tc--){
solve_tc();
cout << "\n";
}
} |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
ll t;
cin>>t;
while(t--)
{
string s;
cin>>s;
ll n=s.length();
char adj1='0';
char alt1='0';
char adj2,alt2;
ll count=0;
for(ll i=0;i<n;i++)
{
if(i+1<n)
{
if(s[i]==s[i+1])
{
if(i+2<n)
{
adj1=s[i+2];
}
if(i+3<n)
alt1=s[i+3];
char c='0';
for(int j=0;j<26;j++)
{
if(char('a'+j)!=adj1&&char('a'+j)!=alt1&&char('a'+j)!=s[i])
{
c=char('a'+j);
break;
}
}
count++;
s[i+1]=c;
}
}
adj1='0';
alt1='0';
if(i+2<n&&s[i]==s[i+2])
{
if(s[i]==s[i+2])
{
if(i+3<n)
{
adj1=s[i+3];
}
if(i+4<n)
alt1=s[i+4];
char c='0';
for(int j=0;j<26;j++)
{
if(char('a'+j)!=adj1&&char('a'+j)!=alt1&& char('a'+j)!=s[i]&& char('a'+j)!=s[i+1])
{
c=char('a'+j);
break;
}
}
count++;
s[i+2]=c;
}
}
}
cout<<count<<endl;
}
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
namespace IO
{
const int buffer_size=1e5+5;
char buf[buffer_size],*S,*T;
bool flag_EOF;
inline char read_char()
{
if(S==T)
T=(S=buf)+fread(buf,1,buffer_size,stdin);
return S!=T?*(S++):EOF;
}
inline int read_int()
{
int flag=1;
char c=read_char();
while(c<'0'||c>'9')
{
if(c==EOF)
{
flag_EOF=true;
return 0;
}
flag=(c=='-'?-1:1);
c=read_char();
}
int x=0;
while(c>='0'&&c<='9')
{
x=x*10+(c^48);
c=read_char();
}
return x*flag;
}
char st[13];
int _top;
void Write(int x)
{
if(!x)
{
putchar('0');
return;
}
if(x<0)
{
putchar('-');
x=-x;
}
while(x)
{
st[++_top]=x%10+'0';
x/=10;
}
while(_top>0)
putchar(st[_top--]);
}
}
const int max_len=1e5+5;
char str[max_len];
int main()
{
int t;
scanf("%d",&t);
while(t--)
{
scanf("%s",str+1);
int len=strlen(str+1);
int ans=0;
for(int i=1;i<=len;++i)
{
if((i-1>=1&&str[i-1]==str[i])||(i-2>=1&&str[i-2]==str[i]))
{
for(char x='a';x<='z';++x)
{
if((i-1<1||str[i-1]!=x)&&(i-2<1||str[i-2]!=x)&&(i+1>len||str[i+1]!=x)&&(i+2>len||str[i+2]!=x))
{
str[i]=x;
break;
}
}
++ans;
}
}
printf("%d\n",ans);
}
return 0;
}
|
// December 30, 2020
// https://codeforces.com/contest/1466/problem/C
/*
g++ -D _DEBUG -std=c++11 -Wl,--stack=268435456 -g -Wall -Wfatal-errors 1466C.cpp && a
g++ -D _DEBUG -std=c++11 -Wl,--stack=268435456 -g -Wall -Wfatal-errors 1466C.cpp -ggdb && gdb a
*/
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
#ifdef _DEBUG
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
freopen("debug_output.txt", "w", stderr);
#endif
int tt;
cin >> tt;
while (tt--) {
string s;
cin >> s;
int n = (int) s.size();
int ans = 0;
vector<int> CHECKS = {-2, -1};
for (int i = 1; i < n; i++) {
bool change = false;
auto Check = [&](int d) {
int j = i + d;
if (0 <= j && j < n && s[i] == s[j]) {
change = true;
}
};
for (int d : CHECKS) {
Check(d);
}
if (change) {
s[i] = '.';
ans += 1;
}
}
cout << ans << '\n';
}
return 0;
} |
#define _CRT_SECURE_NO_WARNINGS
/* To Be or Not To Be !!
Allah_Almost3aan
Make it happens :) */
#include<bits/stdc++.h>
#include<unordered_map>
//#include<unorderd_set>
using namespace std;
using ll = long long;
using ld = long double;
const ll OO = 1e16;
#define ed '\n'
#define F first
//#define S second
#define sz(a)a.size()
#define vi vector<int>
#define pii pair<int,int>
#define all(c)c.begin(),c.end()
#define RT(v)return cout<<v,0
#define rall(s)s.rbegin(),s.rend()
#define stpr(n)fixed<<setprecision(n)
int di[8] = { 0, 0, 1, -1, -1, 1, -1, 1 };
int dj[8] = { 1, -1, 0, 0, 1, 1, -1, -1 };
#define show(x)cout<<"> "<<(#x)<<" = "<<x<<ed
#define reset(mem,val)memset(mem,val,sizeof mem)
#define fast ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
string ys = "YES", no = "NO";
const long double dgr = acos(-1) / 180, dg = 180 / acos(-1);
const int mod = 1e9 + 7, N = 1e5 + 5;
int main()
{
fast;
int t;
cin >> t;
while (t--)
{
string s; cin >> s;
int ans=0;
for (int i = 1; i < sz(s); i++){
if (s[i] == s[i - 1] || (i>1 && s[i] == s[i - 2]))ans++, s[i] = '#';
}
cout << ans << ed;
}
return 0;
}
|
#include <iostream>
using namespace std;
int main() {
int t;
cin>>t;
while(t--){
string s;
cin>>s;
int n=s.length();
int ans=0;
for(int i=0; i<n-2; i++){
if(s[i]==s[i+1] && s[i]==s[i+2] && s[i]!='1'){
ans+=2;
s[i+1]='1';
s[i+2]='1';
}else if(s[i]==s[i+1] && s[i]!='1'){
ans++;
s[i+1]='1';
}else if(s[i]==s[i+2] && s[i]!='1'){
ans++;
s[i+2]='1';
}
}
if(s[n-1]==s[n-2] && s[n-1]!='1'){
ans++;
}
cout<<ans<<endl;
}
}
|
// STUPID.. AS ALWAYS
#include<bits/stdc++.h>
using namespace std;
#define fastio ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
#define ll long long
#define pll pair<ll,ll>
#define vll vector<ll>
#define vs vector<string>
#define ff first
#define ss second
#define all(x) x.begin(),x.end()
#define pb push_back
#define ppb pop_back
# define ln cout << "\n" ;
#define maxHeap priority_queue<ll>
#define minHeap priority_queue <ll, vector<ll>, greater<ll> >
#define MOD 1000000009
#define MAX 2000000000000000000
#define MAXN 1000006
void solve(){
ll n,i,j;
// cin >> n;
string s; cin >> s;
n = s.size();
ll ans =0;
for(i=1;i<n;i++){
if(s[i] == s[i-1] && s[i] != '$'){
ans ++;
s[i] = '$';
// s[i] = s[i-1] +1; if(s[i] == s[i+1]) s[i]++;
}
if(i<n-1 && s[i-1] != '$' && s[i-1] == s[i+1]){
// s[i+1] = s[i+1] +1; if(s[i] == s[i+1]) s[i+1] ++;
// if(i+2<n && s[i+1] == s[i+2]) s[i+1]++;
// if(s[i+1])
ans++;
s[i+1] = '$';
}
}
cout << ans; ln;
}
int main()
{
fastio
ll t; cin >> t; for(ll i=1;i<=t;i++)
//cout << "Case #" << i << ": ",
solve();
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
const int N=114514;
char s[N];
int n,v[N],kkr;
int main(){int t;
scanf("%d",&t);while(t--){kkr=0;
scanf("%s",s+1);n=strlen(s+1);
for(int i=2;i<=n;i++){v[i]=0;
if((s[i]==s[i-1]&&!v[i-1]||s[i]==s[i-2]&&!v[i-2]))v[i]=1,kkr++;
}printf("%d\n",kkr);
}} |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#define endl '\n'
using namespace std;
int t;
void read()
{
cin >> t;
}
const int maxn = 1e5 + 3;
const int inf = 1e9;
int dp[26][26], nxt_dp[26][26], dp_without[26][26];
int pr[26], su[26];
void solve()
{
while (t--)
{
string s;
cin >> s;
int sz = (int)s.size();
if (sz == 1)
{
cout << 0 << endl;
continue;
}
for (int i = 0; i < 26; i++)
for (int j = 0; j < 26; j++)
{
if (i != j)
dp[i][j] = (s[0] - 'a' != i) + (s[1] - 'a' != j);
else
dp[i][j] = inf;
}
for (int i = 0; i < 26; i++)
for (int j = 0; j < 26; j++)
{
dp_without[i][j] = inf;
for (int k = 0; k < 26; k++)
if (k != j)
dp_without[i][j] = min(dp_without[i][j], dp[k][i]);
}
for (int i = 3; i <= sz; i++)
{
for (int j = 0; j < 26; j++)
for (int k = 0; k < 26; k++)
{
if (j == k)
{
nxt_dp[j][k] = inf;
continue;
}
nxt_dp[j][k] = (k != s[i-1] - 'a') + dp_without[j][k];
}
for (int j = 0; j < 26; j++)
for (int k = 0; k < 26; k++)
dp[j][k] = nxt_dp[j][k];
for (int j = 0; j < 26; j++)
{
pr[0] = dp[0][j];
for (int k = 1; k < 26; k++)
pr[k] = min(pr[k-1], dp[k][j]);
su[25] = dp[25][j];
for (int k = 24; k >= 0; k--)
su[k] = min(su[k+1], dp[k][j]);
for (int k = 0; k < 26; k++)
{
dp_without[j][k] = inf;
if (k != 0)
dp_without[j][k] = min(dp_without[j][k], pr[k-1]);
if (k != 25)
dp_without[j][k] = min(dp_without[j][k], su[k+1]);
}
}
}
int ans = inf;
for (int i = 0; i < 26; i++)
for (int j = 0; j < 26; j++)
ans = min(ans, dp[i][j]);
cout << ans << endl;
}
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
read();
solve();
}
|
#include<bits/stdc++.h>
using namespace std;
#define Speed_UP ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
typedef long long ll;
#define pb push_back
int solve(){
string a;
cin>>a;
int n = a.length(),ans=0;
a+="..";
for(int i=1;i<n;i++){
if(a[i-1] == a[i] && a[i]!=1){ a[i] = 1; ans++;}
if(a[i-1] == a[i+1] && a[i+1]!=1){ a[i+1] = 1; ans++;}
}
cout<<ans<<"\n";
return 0;
}
int main(){
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
#endif
Speed_UP
int t;
cin>>t;
while(t--){
solve();
}
} |
/**
* code generated by JHelper
* More info: https://github.com/AlexeyDmitriev/JHelper
* @author Kein Yukiyoshi
*/
// clang-format off
//#pragma GCC optimize("Ofast")
//#pragma GCC target("avx")
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define stoi stoll
#define Endl endl
#define itn int
#define fi first
#define se second
#define rep(i, n) for(int i=0, i##_len=(n); i<i##_len; i++)
#define rep2(i, a, b) for (int i = (int)(a), i##_len=(b); i < i##_len; i++)
#define rep3(i, a, b) for (int i = (int)(a), i##_len=(b); i >= i##_len; i--)
#define FOR(i, a) for (auto &i: a)
#define ALL(obj) begin(obj), end(obj)
#define _max(x) *max_element(ALL(x))
#define _min(x) *min_element(ALL(x))
#define _sum(x) accumulate(ALL(x), 0LL)
const int MOD = 1000000007;
// const int MOD = 998244353;
const int INF = (int)(1e13 + 7);
const double EPS = 1e-8;
const double PI = 3.14159265358979;
template <class T> using V = vector<T>;
template <class T> using VV = vector<vector<T>>;
template <class T> using VVV = vector<vector<vector<T>>>;
template <class T, class S> using P = pair<T, S>;
template<class T> bool chmax(T &a, const T &b) {if (a < b) {a = b;return true;}return false;}
template<class T> bool chmin(T &a, const T &b) {if (b < a) {a = b;return true;}return false;}
int _ceil(int a, int b) { return (a >= 0 ? (a + (b - 1)) / b : (a - (b - 1)) / b); }
int _mod(int a) {return a >= 0 ? a % MOD : a - (MOD * _ceil(a, MOD));}
int _pow(int a, int b) {int res = 1;for (a %= MOD; b; a = a * a % MOD, b >>= 1)if (b & 1) res = res * a % MOD;return res;}
struct mint {long long x;mint(long long x = 0) : x((x % MOD + MOD) % MOD) {}mint operator-() const { return mint(-x); }mint &operator+=(const mint a) {if ((x += a.x) >= MOD) x -= MOD;return *this;}mint &operator-=(const mint a) {if ((x += MOD - a.x) >= MOD) x -= MOD;return *this;}mint &operator*=(const mint a) { (x *= a.x) %= MOD;return *this; }mint operator+(const mint a) const { return mint(*this) += a; }mint operator-(const mint a) const { return mint(*this) -= a; } mint operator*(const mint a) const { return mint(*this) *= a; }mint pow(long long t) const {if (!t) return 1;mint a = pow(t >> 1);a *= a;if (t & 1) a *= *this;return a;}mint inv() const { return pow(MOD - 2); }mint &operator/=(const mint a) { return *this *= a.inv(); }mint operator/(const mint a) const { return mint(*this) /= a; }};istream &operator>>(istream &is, mint &a) { return is >> a.x; }ostream &operator<<(ostream &os, const mint &a) { return os << a.x; }
// clang-format on
class CCaninePoetry {
public:
static void solve(istream &cin, ostream &cout) {
cin.tie(nullptr);
cout.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(15);
int t;
cin >> t;
rep(_, t) {
string S;
cin >> S;
V<int> s;
int ans = 0;
rep(i, S.size()) s.emplace_back(S[i]);
int now = INF;
if (s[0] == s[1]) {
s[1] = now;
now++;
ans++;
}
rep2(i, 2, S.size()) {
if (s[i] == s[i - 1] or s[i] == s[i - 2]) {
s[i] = now;
now++;
ans++;
}
}
cout << ans << endl;
}
}
};
signed main() {
CCaninePoetry solver;
std::istream& in(std::cin);
std::ostream& out(std::cout);
solver.solve(in, out);
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long int lli;
#define scanvector(a,n) vector<lli>a; for(lli i=0;i<n;i++) { lli x ; cin>>x; a.push_back(x);}
#define scanmatrix(a,n,m) vector<vector<lli> > a(n,vector<lli> (m,0));for (lli i=0;i<n;i++){for (int j=0;j<m;j++){cin>>a[i][j];}}
#define scanstring(s) string s; cin>>s;
#define printvector(A) for (int i=0;i<A.size();i++){cout<<A[i]<<" ";}cout<<"\n";
#define pi 3.14159265358979
typedef long double ld;
typedef vector<int> vi;
typedef vector<lli> vlli;
typedef vector<vector<int> > mati;
typedef vector<vector<lli> > matlli;
typedef vector<vector<bool > >matb;
typedef unordered_map<lli,lli> umpl;
typedef unordered_map<lli,vlli> umpv;
typedef map<lli,lli> mpl;
typedef map<lli,vlli> mpv;
#define For(i,a,m,l) for(lli i=a;i<m;i+=l)
#define all(vec) (vec.begin(),vec.end())
#define itmp(it,mp) for(auto it=mp.begin();it!=mp.end();it++)
#define itmpr(it,mp) for(auto it=mp.rbegin();it!=mp.rend();it++)
long long int fast_exp(long long int A,long long int B,long long int C){
if (A==0)
return 0;
if (C==0)
return 0;
if (B==0)
return 1;
if (B==1)
return A%C;
long long int res=A;
if (res>C)
res=res%C;
int counter=2;
while (counter<B)
{
res=res*res;
if (res>C)
res=res%C;
counter*=2;
if (counter>=B)
break;
}
counter/=2;
return ((res%C)*fast_exp(A, B-counter,C))%C;
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
lli t;cin>>t;
For(u,0,t,1)
{
string s;
cin>>s;
lli n=s.size();
vector<bool> temp(n,false);
For(i,0,n,1)
{
if (i<n-1 and s[i]==s[i+1] and temp[i]!=true and temp[i+1]!=true)
{
temp[i+1]=true;
}
if (i<n-2 and s[i]==s[i+2] and temp[i]!=true and temp[i+2]!=true)
{
temp[i+2]=true;
}
}
lli ans=0;
///printvector(temp);
For(i,0,n,1)
{
ans+=temp[i];
}
cout<<ans<<"\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100007;
int n;
char in[N];
bool used[N];
void solve(){
scanf("%s", in + 1);
n = strlen(in + 1);
for(int i = 1; i <= n; ++i)
used[i] = false;
int ans = 0;
for(int i = 2; i <= n; ++i){
bool use_need = false;
if(in[i] == in[i - 1] && !used[i - 1])
use_need = true;
if(i > 2 && in[i] == in[i - 2] && !used[i - 2])
use_need = true;
used[i] = use_need;
ans += used[i];
}
printf("%d\n", ans);
}
int main(){
int t;
scanf("%d", &t);
while(t--) solve();
} |
#include <iostream>
#include <cmath>
#include <vector>
#include <string>
#include <algorithm>
#include <deque>
#include <queue>
#include <iomanip>
#include <map>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <cassert>
using namespace std;
typedef long long ll;
typedef long double ld;
#define umap unordered_map
#define uset unordered_set
#define len(x) int(x.size())
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
#define pii pair<int, int>
template<typename T>
void read(vector<T>& vec) {
for (int i = 0; i < len(vec); ++i) {
cin >> vec[i];
}
}
template<typename T>
void print(vector<T>& vec, string c) {
if (!vec.empty()) {
cout << vec[0];
for (int i = 1; i < len(vec); ++i) {
cout << c << vec[i];
}
cout << '\n';
}
}
const int INF = int(1e9) + 7;
void solve() {
string s;
cin >> s;
int n = len(s), cnt = 0;
s = "1111" + s + "1111";
for (int i = 5; i < n + 4; ++i) {
if (s[i] == s[i - 1] || s[i] == s[i - 2]) {
++cnt;
s[i] = '$';
}
}
cout << cnt << '\n';
}
int main() {
ios::sync_with_stdio(0);
cout.precision(15);
cin.tie(0);
int tests = 1;
cin >> tests;
while (tests--) solve();
} |
#include <bits/stdc++.h>
using namespace std;
#define double long double
#define mod 1000000007
#define int long long
#define vi vector<int> // a[n] s[n] v(n) pop_back
#define vvi vector<vector<int>> // vvi(n) vec[i]=vi(col);
#define maxx(arr) *max_element(arr.begin(),arr.end())
#define minn(arr) *min_element(arr.begin(),arr.end())
#define maxa(arr) *max_element(arr,arr+arr.size())
#define mina(arr) *min_element(arr,arr+arr.size())
#define sortt(sv) sort(sv.begin(),sv.end()) //str & v
#define pb push_back
#define forr(z,i,n) for(int i=z;i<n;i++) // n= name.size()
#define foru(n,i,x) for(int i=n-1;i>=0;i--) //for(i+=3) loop last line i+=2;
#define aa(i,st) for(auto i=st.begin();i!=st.end();i++) //arr not/*i(vec,set,0Dstring)/mp(i->first)
#define au(i,st) for(auto i=st.rbegin();i!=st.rend();i++)
#define gcd(a,b) __gcd(a,b)
#define lcm(a,b) ((a)*(b)/gcd(a,b))
#define con(arr,s); int arr[s.size()]={0};for(int i=0;i<s.size();i++){arr[i]=arr[i]*10+(s[i]-48);}
/*to con int0Dstring to int array (cant use forr shortcut in arr now) /u can iterate in string but only like s[i]==s[i-1]
stack<int> top pop/push (only3 funct) LIFO
queue<int> front FIFO
pow(base,power);
int rotty= sqrt(num); cout<<rooty; gives base value
double num = -7.11; cout << cbrt(num); gives till .5 point
Subarray - contiguous while subset or subsequence - not contiguous
string s ="12:34"; => int h=(s[firstdigit]-'0')*as per no + s[nextdigit]-'0'...;
int h= (s[0]-'0')*10+ s[1]-'0';
a=8 normal -> printf("%04d:",a) => 0008 for new line -> printf("%04d\n",a)
true(1), binary search -> middle */
void solve(){
string s;
cin>>s;
int n=s.size();
int cnt=0;
forr(1,i,n){
if(s[i]==s[i-1]|| (i>1&&s[i]==s[i-2])){
cnt++; s[i]=0;
}
}
cout<<cnt<<"\n";
}
int32_t main(){
ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#ifndef ONLINE_JUDGE
freopen("input.txt","r",stdin);
freopen("output.txt","w",stdout);
#endif
int t;cin>>t;while(t--)
solve();
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define int long long
signed main()
{
int t;
cin>>t;
char c='#';
char d='*';
for(int ii=0;ii<t;ii++)
{
string s;
cin>>s;
int a=0;
int n=s.size();
for(int j=0;j<s.size();j++)
{
if(s[j]=='#')
continue;
if(j+2<n)
{
if(s[j]==s[j+1]&&s[j]==s[j+2])
{
a+=2;
j++;
j++;
continue;
}
if(s[j]==s[j+2])
{
a++;
s[j+2]='#';
continue;
}
}
if(j+1<n)
{
if(s[j]==s[j+1])
{
a++;
j++;
}
}
}
cout<<a<<endl;
}
return 0;
}
|
#include <bits/stdc++.h>
#define l1 long long
#define ld long double
#define mod 1000000007
#define MOD 998244353
#define eps 0.000000001
#define pi acos(-1.0)
#define f first
#define se second
#define pb push_back
#define pp pop_back
#define pf push_front
#define in(a) \
for (auto &x : a) \
cin >> x;
#define pr(a) \
for (auto x : a) \
cout << x << " "; \
cout << "\n";
#define all(x) x.begin(), x.end()
#define set(a, b) memset(a, b, sizeof(a))
#define cntsbs(n) __builtin_popcount(n)
#define mn *min_element
#define mx *max_element
#define input \
l1 t; \
cin >> t; \
while (t--)
#define endl "\n"
using namespace std;
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
input
{
string s, ss;
cin >> s;
l1 n = s.size(), cnt = 0;
for (l1 i = 1; i < n; ++i)
{
if (s[i] == s[i - 1] && s[i] != '*')
{
cnt++;
s[i] = '*';
if (i + 1 < n && s[i - 1] == s[i + 1])
s[i + 1] = '*', cnt++;
}
else
{
if (i + 1 < n && s[i - 1] == s[i + 1])
s[i + 1] = '*', cnt++;
}
}
cout << cnt << endl;
}
return 0;
} |
/*
SpoilerAlert_DumbledoreDead
*/
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define pb push_back
#define fast ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
int main()
{
fast;
ll t;
cin>>t;
while(t--)
{
string s;
cin>>s;
ll i,ans=0;
for(i=0;i<s.size();i++)
{
if(s[i]==s[i+1]){s[i+1]='1';ans++;}
else if(i>0&&i<s.size()-1&&s[i-1]==s[i+1]){s[i+1]='1';ans++;}
}
cout<<ans<<endl;
}
}
|
#include<bits/stdc++.h>
using namespace std;
#define int long long int
#define endl '\n'
#define all(v) (v).begin(), (v).end()
#define imie(...) " [" << #__VA_ARGS__ ": " << (__VA_ARGS__) << "] "
void SolveTestCase()
{
string str;
cin >> str;
int len = str.length();
str += '.';
vector<bool>mark(len, false);
for(int i=0; i<len-1; ++i) {
if(mark[i])
continue;
if(str[i] == str[i+1])
mark[i+1] = true;
if(str[i] == str[i+2])
mark[i+2] = true;
}
int cnt = 0;
for(int i=0; i<len; ++i)
if(mark[i])
cnt += 1;
cout << cnt << endl;
}
signed main()
{
ios_base::sync_with_stdio(0);
cin.tie(0);
int T;
cin >> T;
while(T--)
SolveTestCase();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define l1(i, n) for (ll i = 1; i <= n; i++)
#define l0(i, n) for (ll i = 0; i < n; i++)
#define lo(i, s, n) for (ll i = s; i <= n; i++)
#define sca(n) scanf("%lld", &n)
#define pri(n) printf("%lld", n)
#define pb push_back
#define mp make_pair
#define sorted(x) sort(x.begin(), x.end())
#define reversed(x) reverse(x.begin(), x.end())
#define all(x) x.begin(), x.end()
#define ms(a, b) memset(a, b, sizeof(a));
#define cases(tc) cout<<"Case "<<tc<<": "
#define nl cout<<"\n";
#define pnl printf("\n");
#define pi acos(-1)
#define mod 1000000007
#define inf 999999999999999999
int main()
{
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
/*
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
*/
ll t;
cin>>t;
while(t--){
string x;
cin>>x;
ll cnt=0;
l1(i, x.size()-1){
if(x[i]==x[i-1]){
cnt++;
x[i]='?';
}
else if(i>1 && x[i]==x[i-2]){
cnt++;
x[i]='?';
}
}
cout<<cnt;
nl
}
return 0;
}
|
#include<iostream>
using namespace std;
/******************** Beginning of Template **************************/
/************ ALL HEADER FILE ***********/
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <fstream>
#include <queue>
#include <deque>
#include <bitset>
#include <iterator>
#include <list>
#include <stack>
#include <map>
#include <set>
#include <functional>
#include <utility>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iomanip>
#include <cassert>
/************************************ ALL DEFINE ****************************************************/
#define repstep(i, j, k, step) for (int i=j; i<k; i+=step)
#define rep(i, j, k) for (int i=j; i<k; i++)
#define dsrep(i, j, k, step) for (int i=j; i>=k; i-=step)
#define drep(i, j, k) for(int i=j; i>=k; i--)
#define srep(i, k) for(int i = (0); i < (k); i++ )
#define sdrep(i, k) for(int i = j; i >= (k); i-- )
//srep==simple repetition.
#define sbko(cont) cont.begin(), cont.end()
//#define RALL(cont) cont.begin(), cont.end()
#define every(l) for(auto it=l.begin(); it != l.end(); it++)
#define mp make_pair
#define pb push_back
#define RESET(a, b) memset(a, b, sizeof(a))
#define INF (int)MAX_INT
#define EPS (int)1e-9
#define PI acos(-1)
#define MOD 1000000007
#define fango using
#define ganteng namespace
#define sekali std
#define deb(x) cout<<#x<<" = "<<x<<endl;
#define deb2(x,y) cout<<#x<<" = "<<x<<#y<<" = "<<y<<endl;
#define deb3(x,y,z) cout<<#x<<" = "<<x<<#y<<" = "<<y<<#z<<" = "<<z<<endl;
#define deb4(x,y,z,n) cout<<#x<<" = "<<x<<#y<<" = "<<y<<#z<<" = "<<z<<" "<<#n<<"= "<<n<<endl;
#define deb5(x,y,z,n,n2) cout<<#x<<" = "<<x<<#y<<" = "<<y<<#z<<" = "<<z<<" "<<#n<<"= "<<n<<" "<<#n2<<" = "<<n2<<endl;
/************************************ END OF DEFINE ****************************************************/
/************************************ ALL TYPEDEF ****************************************************/
typedef pair<int, int> pii;
typedef pair<int, pii> piii;
typedef vector<int> vi;
typedef vector<string> vs;
typedef vector<pii> vii;
typedef vector<vi> grp;
typedef vector<piii> viii;
typedef long long int32;
typedef unsigned long long uint32;
typedef long long int int64;
typedef unsigned long long int uint64;
void swap(int *a,int *b)
{
int c=*a;
*a=*b;
*b=c;
}
int abs(int a)
{
if(a>0)
return a;
else
return -a;
}
void solve()
{
long long int ans=0;
string s; cin>>s;
for(int i=1;i<s.length();i++)
{
if(s[i]==s[i-1])
{
s[i]='0'; ans++;
}
else if (i-2>-1 && s[i]==s[i-2])
{
s[i]='0'; ans++;
}
}
cout<<ans<<endl;
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t; cin>>t; while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
#define ll long long int
#define ull unsigned long long
#define br "\n"
#define sp " "
using namespace std;
int main() {
// ios_base::sync_with_stdio(false);
// cin.tie(NULL);
ll t;
cin>>t;
while(t--){
string s;
cin>>s;
ll i,j,n=s.length(),ans=0;
if(n==1)
cout<<0<<br;
else if(n==2)
{
if(s[0]==s[1])
cout<<1<<br;
else
cout<<0<<br;
}
else{
for(i=0;i<n-1;i++)
{
if(s[i]==s[i+1])
s[i+1]='*';
if(s[i]==s[i+2]&&i!=n-2)
s[i+2]='*';
}
for(i=0;i<n;i++)
{
if(s[i]=='*')
ans++;
}
cout<<ans<<br;
}
}
return 0;
}
|
// 2 jan 2021
#include<bits/stdc++.h>
using namespace std;
int main(){
int t;
cin>>t;
while(t--){
string str;
cin>>str;
int n=str.length();
if(n==1){
cout<<0<<endl;
continue;
}
if(n==2){
if(str[0]==str[1]){
cout<<1<<endl;
continue;
}
else{
cout<<0<<endl;
continue;
}
}
int ans=0;
for(int i=1;i<str.length();i++){
if(str[i]==str[i-1]||(i-2>=0&&str[i]==str[i-2])){
str[i]='*';
ans++;
}
}
cout<<ans<<endl;
}
} |
#include<bits/stdc++.h>
#include <iostream>
#include <math.h>
#include <utility>
#include <algorithm>
#include <string>
#include <vector>
#include <set>
#define ll long long
#define pb push_back
#define mp make_pair
#define pii pair<int, int>
#define pll pair<ll, ll>
#define ff first
#define ss second
#define vi vector<int>
#define vl vector<ll>
#define vii vector<pii>
#define vll vector<pll>
#define FOR(i, N) for (i = 0; i < (N); i++)
#define FORe(i, N) for (i = 1; i <= (N); i++)
#define FORr(i, a, b) for (i = (a); i < (b); i++)
#define FORrev(i, N) for (i = (N); i >= 0; i--)
#define F0R(i, N) for (int i = 0; i < (N); i++)
#define F0Re(i, N) for (int i = 1; i <= (N); i++)
#define F0Rr(i, a, b) for (ll i = (a); i < (b); i++)
#define F0Rrev(i, N) for (int i = (N); i >= 0; i--)
#define all(v) (v).begin(), (v).end()
#define dbgLine cerr << " LINE : " << __LINE__ << "\n"
#define ldd long double
using namespace std;
const int Alp = 26;
const int __PRECISION = 9;
const int inf = 1e9 + 8;
const ldd PI = acos(-1);
const ldd EPS = 1e-7;
const ll MOD = 1e9 + 7;
const ll MAXN = 2e5 + 5;
const ll ROOTN = 320;
const ll LOGN = 18;
const ll INF = 1e18 + 1022;
int main()
{
int test;
cin >> test;
while (test--)
{
// ios_base::sync_with_stdio(false);
// cin.tie(0);
// cout.tie(0);
ll i, j, k = 0, x, p, q, m = 0, g, n, R, mx = 0, popo, sum = 0;
string s;
cin>>s;
n=s.size();
FORr(i, 1, n)
{
if(i!=1 && s[i]==s[i-2])
{
s[i]='A';
k++;
}
else if(s[i]==s[i-1])
{
s[i]='A';
k++;
}
}
cout<<k<<endl;
}
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
#define FastIO ios_base::sync_with_stdio(false); cin.tie(0);
#define ll long long
#define ull unsigned long long
#define pb push_back
#define All(x) (x).begin(),(x).end()
#define mp make_pair
#define nl "\n"
typedef pair<int,int>ii;
typedef vector<int>vi;
typedef vector<ii>vii;
typedef vector<vi>vvi;
typedef vector<long long>vl;
typedef vector <vl>vvl;
template<class T>
void print(T& a)
{
for(auto x:a)
cout<<x<<" ";
cout<<"\n";
}
int main()
{
FastIO
int tt;
cin>>tt;
while(tt--)
{
string s;
cin>>s;
int n=s.length();
int cnt=0;
for(int i=0; i<n; i++)
{
if(s[i]=='.')
continue;
if(i+2<n && s[i]==s[i+2])
{
if(s[i]==s[i+1])
{
s[i+1]='.';
s[i+2]='.';
cnt+=2;
}
else
{
s[i+2]='.';
cnt++;
}
}
else if(i+1<n && s[i]==s[i+1])
{
s[i+1]='.';
cnt++;
}
}
cout<<cnt<<nl;
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define pi (3.141592653589)
#define mod 1000000007
#define int long long
#define float double
#define pb push_back
#define mp make_pair
#define fr first
#define sc second
#define all(c) c.begin(), c.end()
#define min3(a, b, c) min(c, min(a, b))
#define min4(a, b, c, d) min(d, min(c, min(a, b)))
#define max3(a,b,c) max(a,max(b,c))
#define max4(a,b,c,d) max(a,max(b,max(c,d)))
#define read(v) for(int i=0;i<v.size();i++)cin>>v[i];
#define rrep(i, n) for(int i=n-1;i>=0;i--)
#define rep(i,n) for(int i=0;i<n;i++)
#define in cin>>
#define out cout<<
#define default(a,n,b) for(int i=0;i<n;i++)a[i]=b;
#define YNans(poss,a,b) cout << (poss ? a : b ) << endl;
#define inarray(a,n) for(int i=0;i<n;i++)cin>>a[i];
#define fast ios_base :: sync_with_stdio(false),cin.tie(NULL);
int gcd(int a, int b)
{
return (b?gcd(b,a%b):a);
}
bool isPrime(int n){
if(n==1) return false;
if(n==2) return true;
for(int i=2;i*i<=n;i++){
if(n%i==0)return false;
}
return true;
}
void solve(){
string s;in s;
int n=s.size();
int ans=0;
// vector<vector<int>> v(27);
for(int i=0;i<n;i++){
if(s[i]=='-'){
continue;
}
if(i<n-1&&s[i]==s[i+1]){
s[i+1]='-';
ans++;
}
if(i<n-2&&s[i]==s[i+2]){
s[i+2]='-';
ans++;
}
}
cout<<ans<<endl;
}
int32_t main(){
fast
int t=1;
cin>>t;
while(t--){
solve();
}
return 0;
}
|
//meh madarchod hu jo isme aaya
/*
_oo0oo_
o8888888o
88" . "88
(| -_- |)
0\ = /0
___/`---'\___
.' \\| |// '.
/ \\||| : |||// \
/ _||||| -:- |||||- \
| | \\\ - /// | |
| \_| ''\---/'' |_/ |
\ .-\__ '-' ___/-. /
___'. .' /--.--\ `. .'___
."" '< `.___\_<|>_/___.' >' "".
| | : `- \`.;`\ _ /`;.`/ - ` : | |
\ \ `_. \_ __\ /__ _/ .-` / /
=====`-.____`.___ \_____/___.-`___.-'=====
`=---='
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Jaspreet singh @jsar3004 Codechef/codeforces/topcoder
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
#include<bits/stdc++.h>
#define needforspeed ios_base::sync_with_stdio(false)
#define ll long long int
#define ld long double
#define ff1(i,a,b) for(ll i=a;i<b;i++)
#define pb push_back
#define pp pair<int,int>
#define mp make_pair
#define fi first
#define se second
#define in insert
#define PI 3.1415926535
#define mod 1000000007
#define coutd(x) cout << fixed << setprecision(x)
#define DECIMAL(n) std::cout << std::fixed << std::setprecision(n);
using namespace std;
int maxint = numeric_limits<int>::max();
bool sortbysec(const pair<ll,ll> &a,
const pair<ll,ll> &b)
{
return (a.se > b.se);
}
bool sortbyfirst(const pair<ll,ll> &a,
const pair<ll,ll> &b)
{
return (a.fi< b.fi);
}
long double distance1(ll x1, ll y1, ll x2, ll y2)
{
return sqrt(pow(x2 - x1, 2) +
pow(y2 - y1, 2) * 1.0);
}
long long binpoww(long long a, long long b, long long m) {
a %= m;
long long res = 1;
while (b > 0) {
if (b & 1)
res = res * a % m;
a = a * a % m;
b >>= 1;
}
return res;
}
long long int fast_power(long long int a, long long int b) {
long long int res = 1;
while (b > 0) {
if (b & 1)
res = res * a;
a = a * a;
b >>= 1;
}
return res;
}
void solve()
{
string s;
cin>>s;
ll c=0;
if(s.size()==1)
{
cout<<0<<endl;
return;
}
else if(s.size()==2)
{
if(s[0]!=s[1])
cout<<0<<endl;
else
cout<<1<<endl;
return;
}
ll ans=0;
ll n=s.size();
for(int i=0;i<=s.size()-3;i++)
{
if(s[i]==s[i+1]&&s[i+1]==s[i+2])
{
set<char>c;
c.insert(s[i]);
if(i+3<n)
{
c.insert(s[i+3]);
}
if(i+4<n)
{
c.insert(s[i+4]);
}
ll co=1;
for(char x='a';x<='z';x++)
{
if(c.find(x)==c.end())
{
s[i+co]=x; c.insert(x);
co++;
ans++;
}
if(co==3)
break;
}
}
else if(s[i]==s[i+1])
{
set<char>c;
c.insert(s[i]);
c.insert(s[i+2]);
if(i+3<n)
{
c.insert(s[i+3]);
}
for(char x='a';x<='z';x++)
{
if(c.find(x)==c.end())
{
ans++;
s[i+1]=x; break;
}
}
}
else if(s[i]==s[i+2])
{
set<char>c;
c.insert(s[i]);
c.insert(s[i+1]);
if(i+3<n)
{
c.insert(s[i+3]);
}
if(i+4<n)
{
c.insert(s[i+4]);
}
for(char x='a';x<='z';x++)
{
if(c.find(x)==c.end())
{
ans++;
s[i+2]=x; break;
}
}
}
else if(s[i+1]==s[i+2])
{
set<char>c;
c.insert(s[i]);
c.insert(s[i+2]);
if(i+3<n)
{c.insert(s[i+3]);}
if(i+4<n)
{
c.insert(s[i+4]);
}
for(char x='a';x<='z';x++)
{
if(c.find(x)==c.end())
{
ans++;
s[i+2]=x;
break;
}
}
}
}
cout<<ans<<endl;
}
int main()
{
needforspeed;
ll t=1;
cin>>t;
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
while(t--)
{
solve();
}
return 0;
} |
#include<bits/stdc++.h>
#define fi first
#define se second
#define mk make_pair
#define pb push_back
#define mod 1000000007
#define lowbit(n) n&-n
#define mem(x) memset(x,0,sizeof(x))
#define fo(i,a,b) for(int i=a,_e=b;i<=_e;++i)
#define fd(i,a,b) for(int i=b,_e=a;i>=_e;--i)
#define Cout(a,l,r) fo(i,l,r) cout<<a[i]<<' ';cout<<endl
using namespace std;
const int maxn=200010;
typedef long long ll;
typedef long double ld;
int n,m;
int c[maxn];
int main()
{
ios_base::sync_with_stdio(0);
cin.tie(0);cout.tie(0);
int T;cin>>T;
while(T--){
string s;
cin>>s;
int ans=0;
if(s.length()==1) {
cout<<"0"<<endl;
continue;
}
else {
if(s[1]==s[0])
ans++,c[1]=1;
}
fo(i,2,s.length()-1){
if(c[i-1]==0 && s[i]==s[i-1]) c[i]=1,ans++;
if(c[i]==0)
if(c[i-2]==0 && s[i]==s[i-2])
c[i]=1,ans++;
}
fo(i,0,s.length()) c[i]=0;
cout<<ans<<endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll N = 1e5 + 5;
bool pre[N];
set<ll> st;
int main()
{
int t;
cin>>t;
while(t--)
{
string s;
cin>>s;
int n=s.length();
int ans=0;
for(int i=0;i<n;i++) pre[i]=false;
for(int i=1;i<n;i++)
{
bool temp=false;
if(s[i]==s[i-1]&& pre[i-1]==false) temp=true;
if(i>1 && s[i]==s[i-2] && pre[i-2]==false) temp=true;
pre[i]=temp;
ans+=pre[i];
}
cout<<ans<<"\n";
}
}
|
/* ****_hela**** */
#include<bits/stdc++.h>
#define ll long long
#define pb push_back
#define endl '\n'
#define pii pair<ll int,ll int>
#define vi vector<ll int>
#define all(a) (a).begin(),(a).end()
#define F first
#define S second
#define sz(x) (ll int)x.size()
#define hell 1000000007
#define rep(i,a,b) for(ll int i=a;i<b;i++)
#define lbnd lower_bound
#define ubnd upper_bound
#define bs binary_search
#define mp make_pair
using namespace std;
#define N 100005
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int TESTS=1;
cin>>TESTS;
while(TESTS--)
{
string s;
cin>>s;
int n=s.size();
ll ans=0;
for(int i=1;i<n;i++){
if(s[i]==s[i-1] || ((i>=2) && s[i]==s[i-2])){
s[i]='#';
ans++;
}
}
cout<<ans<<'\n';
}
return 0;
} |
/*
_ __ __ _ _
| | \ \ / / | | (_)
| |__ _ _ \ V /__ _ _ __ | | ___ _
| '_ \| | | | \ // _` | '_ \| | / _ \ |
| |_) | |_| | | | (_| | | | | |___| __/ |
|_.__/ \__, | \_/\__,_|_| |_\_____/\___|_|
__/ |
|___/
*/
#include <map>
#include <set>
#include <list>
#include <cmath>
#include <queue>
#include <cstdio>
#include <stack>
#include <time.h>
#include <vector>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <algorithm>
#include <unordered_map>
//#define VNAME(x) (#x)
//#define Kan(x) std::cerr << "[ " << #x << " ]"; KAN(x)
#define show(x) std::cerr << #x << " = " << x << std::endl
#define show2(x,y) std::cerr << #x << " = " << x << " " << #y << " = " << y << std::endl
#define show3(x,y,z) std::cerr << #x << " = " << x << " " << #y << " = " << y << " " << #z << " = " << z << std::endl
#define show4(x,y,z,p) std::cerr << #x << " = " << x << " " << #y << " = " << y << " " << #z << " = " << z << " " << #p << " = " << p << std::endl
#define IOS ios::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
#define fin freopen("in.txt", "r", stdin)
#define fout freopen("out.txt", "w", stdout)
#define ll long long
using namespace std;
//template<class TPL>
//void KAN(TPL A){
// std :: cerr << std :: endl << "Element Number = " << A.size() << std :: endl << "< ";
// for(auto it : A)std :: cerr << it << ", ";
// std :: cerr << ">" << std :: endl << std :: endl;
//}
namespace Fast_IO{ ///orz laofu
const int MAXL((1 << 18) + 1);int iof, iotp;
char ioif[MAXL], *ioiS, *ioiT, ioof[MAXL],*iooS=ioof,*iooT=ioof+MAXL-1,ioc,iost[55];
char Getchar(){
if (ioiS == ioiT){
ioiS=ioif;ioiT=ioiS+fread(ioif,1,MAXL,stdin);return (ioiS == ioiT ? EOF : *ioiS++);
}else return (*ioiS++);
}
void Write(){fwrite(ioof,1,iooS-ioof,stdout);iooS=ioof;}
void Putchar(char x){*iooS++ = x;if (iooS == iooT)Write();}
inline int read(){
int x=0;for(iof=1,ioc=Getchar();(ioc<'0'||ioc>'9')&&ioc!=EOF;)iof=ioc=='-'?-1:1,ioc=Getchar();
if(ioc==EOF)exit(0);
for(x=0;ioc<='9'&&ioc>='0';ioc=Getchar())x=(x<<3)+(x<<1)+(ioc^48);return x*iof;
}
inline long long read_ll(){
long long x=0;for(iof=1,ioc=Getchar();(ioc<'0'||ioc>'9')&&ioc!=EOF;)iof=ioc=='-'?-1:1,ioc=Getchar();
if(ioc==EOF)exit(0);
for(x=0;ioc<='9'&&ioc>='0';ioc=Getchar())x=(x<<3)+(x<<1)+(ioc^48);return x*iof;
}
/**
#define lll __int128
inline lll read_lll(){
lll x=0;for(iof=1,ioc=Getchar();(ioc<'0'||ioc>'9')&&ioc!=EOF;)iof=ioc=='-'?-1:1,ioc=Getchar();
if(ioc==EOF)exit(0);
for(x=0;ioc<='9'&&ioc>='0';ioc=Getchar())x=(x<<3)+(x<<1)+(ioc^48);return x*iof;
}*/
template <class Int>void Print(Int x, char ch = '\0'){
if(!x)Putchar('0');if(x<0)Putchar('-'),x=-x;while(x)iost[++iotp]=x%10+'0',x/=10;
while(iotp)Putchar(iost[iotp--]);if (ch)Putchar(ch);
}
void Getstr(char *s, int &l){
for(ioc=Getchar();ioc==' '||ioc=='\n'||ioc=='\t';)ioc=Getchar();
if(ioc==EOF)exit(0);
for(l=0;!(ioc==' '||ioc=='\n'||ioc=='\t'||ioc==EOF);ioc=Getchar())s[l++]=ioc;s[l] = 0;
}
void Putstr(const char *s){for(int i=0,n=strlen(s);i<n;++i)Putchar(s[i]);}
} // namespace Fast_IO
using namespace Fast_IO;
const int MAX = 2e5+50;
const ll MOD = 998244353;
const int INF = 0x3f3f3f3f;
const ll LINF = 0x3f3f3f3f3f3f3f3f;
const double EPS = 1e-3;
ll qpow(ll a,ll n){/* */ll res = 1LL;while(n){if(n&1)res=res*a%MOD;a=a*a%MOD;n>>=1;}return res;}
ll qpow(ll a,ll n,ll p){a%=p;ll res = 1LL;while(n){if(n&1)res=res*a%p;a=a*a%p;n>>=1;}return res;}
ll npow(ll a,ll n){/* */ll res = 1LL;while(n){if(n&1)res=res*a;a=a*a;n>>=1;}return res;}
ll inv(ll a){/* */return qpow(a,MOD-2);}
ll inv(ll a,ll p){return qpow(a,p-2,p);}
const int MAXT = 10;
int main()
{
int T;cin >> T;
while(T--){
string ss;cin >> ss;
int ans = 0;
for(int i = 1;i < ss.size();++i){
if(ss[i] == ss[i-1] && ss[i] != '+'){
ss[i] = '+';
ans++;
}
if(i >= 2 && ss[i] == ss[i-2] && ss[i] != '+'){
ss[i] = '+';
ans++;
}
}
printf("%d\n",ans);
}
return 0;
}
/**
*/
|
#include <iostream>
#include <sstream>
#include <iomanip>
#include <algorithm>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <vector>
#include <string>
#include <cstring>
#include <cmath>
#include <cstdio>
#define all(v) (v).begin(), (v).end()
#define unq(v) (v).erase(unique(all(v)), (v).end())
#define ii int, int
#define li int, int
#define ll2 ll, ll
#define vec vector
#define pii pair <int, int>
#define pli pair <ll, int>
#define pil pair <int, ll>
#define pll2 pair <ll, ll>
#define mp make_pair
#define pb push_back
#define fi first
#define se second
#define MULTI int T; cin >> T; while(T--)
#define sqr(x) ((x) * (x))
#define test cerr << '!' << endl;
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
void main0 ();
int main () {
clock_t start, end;
#ifndef ONLINE_JUDGE
freopen("C:\\Users\\98497\\Desktop\\code\\file.in", "r", stdin);
start = clock();
#endif
ios::sync_with_stdio(false);
main0();
#ifndef ONLINE_JUDGE
end = clock();
cout << "( "<<(end - start) << " ms )" << endl;
fclose(stdin);
#endif
return 0;
}
const int dx[8] = {0, 1, -1, 0, 1, 1, -1, -1};
const int dy[8] = {1, 0, 0, -1, 1, -1, -1, 1};
const int N = 2e5 + 5;
const int M = 1e5;
const int INF = 0x3f3f3f3f;
const ll INFF = 0x3f3f3f3f3f3f3f3f;
const int mod = 998244353;
const double eps = 1e-6;
const double Pi = acos(-1.0);
int flag[N];
void main0 () {
MULTI {
string s;
cin >> s;
int n = s.length();
s = "$" + s + "$";
int ans = 0;
for (int i = 1;i <= n;++i) {
flag[i] = 0;
}
for (int i = 1;i <= n;++i) {
if (i >= 2) if ((s[i] == s[i - 1]) && (!flag[i - 1])) flag[i] = 1;
if (i >= 3) if ((s[i] == s[i - 2]) && (!flag[i - 2])) flag[i] = 1;
}
for (int i = 1;i <= n;++i) {
ans += flag[i];
}
cout << ans << endl;
}
}
|
// #include </Users/mariapiacaggianelli/Documents/cp/stdc++.h>
#include <bits/stdc++.h>
using namespace std;
#define MAXN 1e6
#define MOD 1e9+7
#define PB push_back
#define F first
#define S second
typedef long long ll;
typedef string str;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<str> vs;
typedef pair<int,int> pi;
typedef pair<ll,ll> pll;
typedef pair<str,str> ps;
int T;
int main(){
T = 1;
cin >> T;
while(T--){
str s; cin >> s;
int ris = 0;
for(int i = 1; i < s.size(); i++){
if (s[i] == s[i-1] || (i > 1 && s[i] == s[i-2])){
char c = 'a';
while(c == s[i-1] || (i > 1 && c == s[i-2]) || (i < s.size()-1 && c == s[i+1]) || (i < s.size()-2 && c == s[i+2])) c++;
s[i] = c;
ris++;
}
}
cout << ris << "\n";
}
return 0;
}
|
#include<bits/stdc++.h>
#define ll long long int
using namespace std;
void solve()
{
string s;
cin >> s;
int n = s.length();
set<char> st;
int cnt = 0;
for(int i=1;i<n;i++){
st.clear();
if(s[i] == s[i-1] or s[i] == s[i-2]){
st.insert(s[i]);
if(i >= 1);
st.insert(s[i-1]);
if(i >= 2)
st.insert(s[i-2]);
if(i <= n-2)
st.insert(s[i+1]);
if(i <= n-3)
st.insert(s[i+2]);
for(char j = 'a'; j <= 'e'; j++){
if(st.find(j) == st.end()){
s[i] = j;
break;
}
}
cnt++;
}
}
cout << cnt<<endl;
}
int main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin>>t;
while(t--){
solve();
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
//4/
using namespace std::chrono;
typedef unsigned long long ull;
typedef long long ll;
typedef long double ld;
#define _USE_MATH_DEFINES
#define cin_exp cin.exceptions(cin.failbit);
#define dis_inbf cin.ignore(numeric_limits<streamsize>::max(),'\n'); //discards the imput buffer
#define IOS ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define repG(i, n) for(ll i = 0; i < (n); ++i)
#define rep(i, a, n) for(ll i = a; i < (n); ++i)
#define repd(i, a, n) for(ll i = a; i >= (n); --i)
#define trav(a, x) for(auto& a : x)
#define all(x) x.begin(), x.end()
#define sz(x) (ll)(x).size()
#define fill(a) memset(a, 0, sizeof (a))
#define fill_2(a,b) memset(a, 0, sizeof (a));memset(b, 0, sizeof (b));
#define fill_n(a) memset(a,-1,sizeof(a))
#define fst first
#define snd second
#define mpr make_pair
#define pb push_back
#define eb emplace_back
#define mod 998244353//1000000007//000000000000007//1000000009
#define PI 3.14159265358979323846264
#define fftmod 998244353
#define arr_106 1000011
#define arr_105 100011
#define ll_inf 1223372036854775807
#define int_inf 1147483647
#define endl "\n"
#define sort_vec(v) sort(v.begin(),v.end())
#define sort_vecr(v) sort(v.rbegin(),v.rend())
#define all_of(v) v.begin(),v.end()
#define l_b lower_bound
#define u_b upper_bound
#define trace_1(a) for(auto i:a) cout<<i<<" ";cout<<endl;
#define trace_2(a,b) for(auto i:a)cout<<i<<" ";cout<<endl;for(auto i:b)cout<<i<<" ";cout<<endl;
#define setpres() cout << fixed << setprecision(16);
#define n_l cout<<endl;
#define in_1(n) cin>>n;
#define input(a) for(auto &it:a) cin>>it;
//#define int long long
//////////////////// DEBUG /////////////////////////////////////////
#ifdef LOCAL
#define D(x) cerr << #x << " is:\t" << x << '\n';
#define DD(x, y) cerr << '(' << #x << ',' << #y << ") are:\t" << x << ' ' << y << '\n';
#define DDD(x, y, z) cerr << '(' << #x << ',' << #y << ',' << #z << ") are:\t" << x << ' ' << y << ' ' << z << '\n';
#else
#define D(x) ;
#define DD(x, y) ;
#define DDD(x, y, z) ;
#endif
typedef long double ld;
typedef pair<ll, ll> pii;
typedef pair<ll, pii> pip;
typedef pair<pii, ll> ppi;
typedef vector<ll> vi;
typedef vector<string> vs;
typedef vector<pii> vpi;
typedef vector<vi> vvi;
typedef vector<vpi> vvpi;
typedef map<ll,ll> mii;
typedef map<pii,ll> mpi;
ll fac[1000006];
inline ll exp(ll x,ll n){ll r=1;x=x;while(n){if(n%2)r=(r*x)%mod;x=(x*x)%mod;n=n/2;}return r;}
inline ll mmi(ll a){return exp(a,mod-2)%mod;}
inline ll fact(ll n){ll res=1;rep(i,1,n+1){res=(res*i)%mod;}return res;}
inline void fact_a(){fac[0]=1;fac[1]=1;rep(i,1,1000005){fac[i]=(fac[i-1]*i)%mod;}}
inline ll inv_fact(ll n){/*fact_a();*/ll par=fac[n];ll res=mmi(par);return res;}
inline ll comb(ll n,ll r){/*fact_a();*/if(n==r && r==0)return 1;if(n<r)return 0;return ((fac[n]*inv_fact(r))%mod*inv_fact(n-r))%mod;}
struct triplet{ll a,b,c;};
bool operator < (const triplet &t1,const triplet &t2){
if(t1.a<t2.a)return true;
if(t1.a==t2.a && t1.b <t2.b)return true;
if(t1.a==t2.a && t1.b ==t2.b && t1.c<t2.c)
return true;return false;}
pair<ll,pii > ex_gcd(ll a,ll b)
{ if(b==0){return mpr(a,mpr(1,0));}
pip p=ex_gcd(b,a%b);
ll gcd=p.fst;ll x1=p.snd.fst;ll y1=p.snd.snd;
ll x=y1;ll y=x1-(a/b)*y1;
return mpr(gcd,mpr(x,y));
}
ll prime[3000006];
ll spf_prime[3000006];
void sieve(){prime[1]=1;for(ll i=2;i*i<=3000000;i++)if(prime[i]==0)for(ll j=i*i;j<=3000000;j+=i)prime[j]=1;}
void spf(){
for(ll i=2;i*i<=3000000;i++)if(!spf_prime[i])for(ll j=i*i;j<=3000000;j+=i)if(!spf_prime[j])spf_prime[j]=i;
for(ll i=2;i<=3000000;i++)if(!spf_prime[i])spf_prime[i]=i;
}
ll getparent_BIT(ll idx)
{
return idx-(idx& -idx);
}
ll getnext_BIT(ll idx)
{
return idx+(idx& -idx);
}
ll getsum_BIT(ll idx,ll BIT[],ll n)
{
idx++;
ll sum=0;
while(idx>0)
{
sum=max(sum,BIT[idx]);
idx=getparent_BIT(idx);
}
return sum;
}
void update_BIT(ll idx,ll BIT[],ll val,ll n)
{
idx++;
while(idx<=n)
{
BIT[idx]=max(BIT[idx],val);
idx=getnext_BIT(idx);
}
}
void build_BIT(ll BIT[],ll a[],ll n)
{
rep(i,0,n)
{
update_BIT(i,BIT,a[i],n);
}
}
void comp_lps(string s,ll lps[],ll n)
{ ll i=1,j=0;
while(i<n){if(s[i]==s[j]){lps[i++]=++j;}
else{ if(j!=0) j=lps[j-1]; else lps[i++]=0;}}
}
void dfs_l(ll u,vvi &adj,ll status[])
{
if(status[u]==1) return;status[u]=1;
rep(i,0,adj[u].size())
dfs_l(adj[u][i],adj,status);
}
ll dij(ll u,ll n,vector<vector<pii> > &adj,ll status[])
{
ll dist[n];
rep(i,0,n) dist[i]=1000000000;
dist[0]=0;
priority_queue<pii,vpi,greater<pii> > q;
q.push(mpr(0,0));
while(!q.empty())
{
pii p;
p=q.top();
q.pop();
ll x=p.snd;
ll w=p.fst;
if(status[x]==1) continue;
status[x]=1;
rep(i,0,adj[x].size())
{
ll ww=adj[x][i].fst;
ll y=adj[x][i].snd;
if(dist[x]+ww<dist[y])
{
dist[y]=dist[x]+ww;
q.push(mpr(dist[y],y));
}
}
}
if(dist[n-1]>=1000000000) return -1;
return dist[n-1];
}
ll phi(ll n)
{
vi v;
ll k=n;;
for(ll i=2;i*i<=n;i++)
{
if(k%i==0)
{
v.pb(i);
while(k%i==0) k/=i;
}
}
if(k>1) v.pb(k);
ll ans=n;
rep(i,0,v.size())
ans-=(ans/v[i]);
return ans;
}
struct trie
{
struct trie *left,*right;
bool isend;
};
trie* get_trie()
{
trie* ptr=new trie;
ptr->left=NULL;
ptr->right=NULL;
ptr->isend=false;
return ptr;
}
bool isempty(trie* root)
{
if(root->left==NULL && root->right==NULL) return true;
return false;
}
void insert_trie(trie *root,string key)
{
trie *ptr=root;
rep(i,0,key.size())
{
if(key[i]=='0')
{
if(ptr->left==NULL)
{
ptr->left=get_trie();
}
ptr=ptr->left;
}
else
{
if(ptr->right==NULL)
ptr->right=get_trie();
ptr=ptr->right;
}
}
ptr->isend=true;
}
trie* remove_trie(trie *root,string key,ll idx=0)
{
if(root==NULL) return NULL;
if(idx==key.size())
{
if(isempty(root))
{
delete(root);
root=NULL;
}
return root;
}
if(key[idx]=='0')
root->left=remove_trie(root->left,key,idx+1);
else
root->right=remove_trie(root->right,key,idx+1);
if(isempty(root))
{
delete(root);
root=NULL;
}
return root;
}
ll search_trie(trie *root,string key)
{
trie *ptr=root;
string s="";
rep(i,0,key.size())
{
if(key[i]=='0')
{
if(ptr->right!=NULL)
{
ptr=ptr->right;s+='1';
}
else
{
ptr=ptr->left;s+='0';
}
}
else
{
if(ptr->left!=NULL)
{
ptr=ptr->left;s+='1';
}
else
{
ptr=ptr->right;s+='0';
}
}
}
ll res=0;
reverse(s.begin(),s.end());
repd(i,s.length()-1,0)
res=res*2+(s[i]-'0');
return res;
}
// ifstream fin("input.txt");ofstream fout("output.txt");
/*
#ifndef ONLINE_JUDGE
double _tBeg=clock();
#endif
*/
/*double cal(ll h,ll c,ll mid)
{
double f=(double)(h*(mid+1)+ c*(mid))/(double)(2*mid+1);
return f;
}*/
struct Comp {
bool operator()(const std::pair<int, int> &a, const std::pair<int, int> &b) {
if (a.first != b.first) {
return a.first < b.first;
}
return a.second > b.second;
}
/*Comp comp_functor;
std::sort(v.begin(), v.end(), comp_functor);*/
};
void dearr()
{
ll dar[1005];
dar[0]=1;dar[1]=0;dar[2]=1;
rep(i,3,1002)
{
dar[i]=(i-1)*(dar[i-1]+dar[i-2]);
}
}
struct dsu
{
ll siz[200002];
ll parent[200002];
void make_set(ll v)
{
parent[v]=v;
siz[v]=1;
}
ll find_set(ll v)
{
if(v==parent[v]) return v;
return parent[v]=find_set(parent[v]);
}
void union_set(ll a,ll b)
{
a=find_set(a);
b=find_set(b);
if(a!=b)
{
if(siz[a]<siz[b]) swap(a,b);
parent[b]=a;
siz[a]+=siz[b];
}
}
};
ll dist[200006];
void dij(ll s,vector<vpi> &adj,ll n)
{
priority_queue<pii,vpi,greater<pii> > q;
q.push(mpr(0,s));
ll status[n+2];
fill(status);
while(!q.empty())
{
pii p=q.top();
q.pop();
if(status[p.snd]==1) continue;
status[p.snd]=1;
ll u=p.snd;
ll w=p.fst;
rep(i,0,adj[u].size())
{ ll v=adj[u][i].snd;
ll ww=adj[u][i].fst;
if(dist[u]+ww < dist[v])
{
dist[v]=dist[u]+ww;
q.push(mpr(dist[v],v));
}
}
}
}
ll rec(ll u,vvi &adj,ll status[],ll d[],ll p[])
{
if(status[u]==1) return 0;
status[u]=1;
ll a=0;
rep(i,0,adj[u].size())
{
a+=rec(adj[u][i],adj,status,d,p);
}
return d[u]=a+p[u];
}
ll rec1(ll u,vvi &adj,ll status[],ll d[],ll h[],ll &dd,ll p[])
{
status[u]=1;
ll b=0;
ll cc=0;
for(auto it:adj[u])
{ if(status[it]==1) continue;
b+=rec1(it,adj,status,d,h,dd,p);
cc=1;
}
if(!cc)
{
if((h[u]+d[u]+2)%2==1 || h[u]<(-d[u]) || h[u]>(d[u]))
{dd=1; return 0;}
else return (d[u]-h[u])/2;
}
ll H=d[u]-2*(b+p[u]);
if((h[u]+d[u]+2)%2==1 || h[u] < H || h[u]>d[u])
{dd=1;return 0;}
return (d[u]-h[u])/2;
}
int main()
{
#ifndef ONLINE_JUDGE
double _tBeg=clock();
#endif
IOS;
ll t;
cin>>t;
while(t--)
{
string s;
cin>>s;
ll n=s.length();
ll cnt=0;
rep(i,1,n)
{
if(i==1)
{
if(s[i]!=s[i-1]) continue;
char c;
if('a'!=s[i-1] && (i+1>=n || 'a'!=s[i+1]) && (i+2>=n || 'a'!=s[i+2]))
{
c='a';
}
else if('b'!=s[i-1] && (i+1>=n || 'b'!=s[i+1]) && (i+2>=n || 'b'!=s[i+2]))
{
c='b';
}
else if('c'!=s[i-1] && (i+1>=n || 'c'!=s[i+1]) && (i+2>=n || 'c'!=s[i+2]))
{
c='c';
}
else if('d'!=s[i-1] && (i+1>=n || 'd'!=s[i+1]) && (i+2>=n || 'd'!=s[i+2]))
{
c='d';
}
s[i]=c;
cnt+=1;
}
else
{
if(s[i]!=s[i-1] && s[i]!=s[i-2]) continue;
char c='e';
if('a'!=s[i-2] && 'a'!=s[i-1] && (i+1>=n || 'a'!=s[i+1]) && (i+2>=n || 'a'!=s[i+2]))
{
c='a';
}
else if('b'!=s[i-2] && 'b'!=s[i-1] && (i+1>=n || 'b'!=s[i+1]) && (i+2>=n || 'b'!=s[i+2]))
{
c='b';
}
else if('c'!=s[i-2] && 'c'!=s[i-1] && (i+1>=n || 'c'!=s[i+1]) && (i+2>=n || 'c'!=s[i+2]))
{
c='c';
}
else if('d'!=s[i-2] && 'd'!=s[i-1] && (i+1>=n || 'd'!=s[i+1]) && (i+2>=n || 'd'!=s[i+2]))
{
c='d';
}
s[i]=c;
cnt+=1;
}
}
cout<<cnt<<endl;
}
#ifndef ONLINE_JUDGE
double _tEnd=clock();
printf("total time %.6f\n",(_tEnd-_tBeg)/CLOCKS_PER_SEC);
#endif
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
int main(){
ll test,n,m;
cin>>test;
while(test--){
string str;
cin>>str;
int ans=0;
for(int i=1;i<str.size();i++){
if(str[i-1]==str[i]){
str[i]='1';
}
if(i-2>=0 && str[i-2]==str[i]){
str[i]='1';
}
}
for(char s:str){
if(s=='1'){
ans++;
}
}
cout<<ans<<"\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cout.tie(0);
cin.tie(0);
int tc;
cin >> tc;
while (tc--) {
string s;
cin >> s;
int ans = 0, n = s.size();
for (int i = 0; i < n; ++i) {
bool good = 1;
if (i-2 >= 0 && s[i] == s[i-2]) good = 0;
if (i-1 >= 0 && s[i] == s[i-1]) good = 0;
if (!good) {
++ans;
s[i] = '#';
}
}
cout << ans << '\n';
}
}
|
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int t;
cin >> t;
string word;
while (t--) {
cin >> word;
int count_pal = 0;
// busco palindroms de llargada 2
for (int i = 0; i < word.length(); i++) {
if (i+1 < word.length() and word[i] == word[i+1] and word[i] != '.'){
count_pal ++;
word[i+1] = '.';
}
if (i+2 < word.length() and word[i] == word[i+2] and word[i] != '.'){
count_pal ++;
word[i+2] = '.';
}
}
cout << count_pal << endl;
}
} |
#include<bits/stdc++.h>
#define int long long
using namespace std;
void fun(string v)
{
int ans = 0;
int n = v.size();
for(int i=0;i<n;i++)
{
if(i+1<n and isalpha(v[i]) and v[i]==v[i+1])
{
v[i+1]='.';
ans++;
}
if(i+2<n and isalpha(v[i]) and v[i]==v[i+2])
{
v[i+2]='.';
ans++;
}
}
cout<<ans<<endl;
}
int32_t main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin>>t;
while(t--)
{
string s;
cin>>s;
fun(s);
}
return 0;
} |
//
// Created by yamunaku on 2020/12/30.
//
#include <bits/stdc++.h>
//#include <atcoder/all>
using namespace std;
//using namespace atcoder;
#define rep(i, n) for(int i = 0; i < (n); i++)
#define repl(i, l, r) for(int i = (l); i < (r); i++)
#define per(i, n) for(int i = ((n)-1); i >= 0; i--)
#define perl(i, l, r) for(int i = ((r)-1); i >= (l); i--)
#define all(x) (x).begin(),(x).end()
#define MOD9 998244353
#define MOD1 1000000007
#define IINF 1000000000
#define LINF 1000000000000000000
#define SP <<" "<<
#define CYES cout<<"Yes"<<endl
#define CNO cout<<"No"<<endl
#define CFS cin.tie(0);ios::sync_with_stdio(false)
#define CST(x) cout<<fixed<<setprecision(x)
using ll = long long;
using ld = long double;
using vi = vector<int>;
using mti = vector<vector<int>>;
using vl = vector<ll>;
using mtl = vector<vector<ll>>;
using pi = pair<int, int>;
using pl = pair<ll, ll>;
template<typename T>
using heap = priority_queue<T, vector<T>, function<bool(const T, const T)>>;
void solve() {
string s;
cin >> s;
int n = s.size();
int ans = 0;
repl(i, 1, n) {
bool need = s[i] == s[i - 1];
if (i >= 2) {
need |= s[i] == s[i - 2];
}
if (need) {
ans++;
s[i] = '*';
}
}
cout << ans << endl;
}
int main() {
CFS;
int t;
cin >> t;
rep(_, t) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(0);
string str;
int t,i,ans;
bool f;
cin>>t;
while(t--){
cin>>str;
ans = 0;f = false;
for(i=1;i<str.size();i++){
if(str[i-1] == str[i]){
ans++;
if(f)str[i] = '0';
else str[i] = '1';
f = !f;
}
else if(i>1 && str[i-2] == str[i]){
ans++;
if(f)str[i] = '0';
else str[i] = '1';
f = !f;
}
}
cout<<ans<<"\n";
}
return 0;
}
|
#include <unordered_set>
#include <unordered_map>
#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
#include <stack>
#include <queue>
#include <deque>
#include <cmath>
#include <set>
#include <map>
using namespace std;
typedef long long ll;
const int Z = (int) 2e3 + 228;
const int N = (int) 1e5 + 228;
const int INF = (int) 1e9 + 228;
const ll LLINF = (ll) 1e18 + 228;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int tst;
cin >> tst;
while (tst--) {
string s;
cin >> s;
int n = s.size();
if (n == 1) {
cout << 0 << "\n";
continue;
}
if (n == 2) {
if (s[0] != s[1]) {
cout << 0 << "\n";
} else {
cout << 1 << "\n";
}
continue;
}
set<char> mn;
for (char c = 'a'; c <= 'z'; ++c) {
mn.insert(c);
}
int ans = 0;
for (int i = 0; i + 2 < n; ++i) {
set<char> kek = mn;
for (int j = i - 1; j >= max(0, i - 8); --j) {
kek.erase(s[j]);
}
for (int j = i; j < min(n, i + 8); ++j) {
kek.erase(s[j]);
}
if (s[i] == s[i + 1] && s[i + 1] == s[i + 2]) {
kek.erase(s[i]);
s[i + 1] = *kek.begin();
s[i + 2] = *++kek.begin();
ans += 2;
} else if (s[i] == s[i + 1]) {
s[i + 1] = *kek.begin();
++ans;
} else if (s[i + 1] == s[i + 2]) {
s[i + 2] = *kek.begin();
++ans;
} else if (s[i] == s[i + 2]) {
s[i + 2] = *kek.begin();
++ans;
}
}
cout << ans << "\n";
}
return 0;
}
/*
1
hthtqqqqmnmnososeaeaaa
*/ |
///====================== TEMPLATE STARTS HERE =====================///
#include <bits/stdc++.h>
using namespace std;
#define endl "\n"
#define pb push_back
#define MP make_pair
#define ff first
#define ss second
#define ABS(x) ((x)<0?-(x):(x))
#define FABS(x) ((x)+eps<0?-(x):(x))
#define LCM(x,y) (((x)/gcd((x),(y)))*(y))
#define POPCOUNT __builtin_popcountll
#define Set(N,p) ((N)|((1LL)<<(p)))
#define Reset(N,p) ((N)&(~((1LL)<<(p))))
#define Check(N,p) (!(((N)&((1LL)<<(p)))==(0)))
#define fast_cin ios_base::sync_with_stdio(false);cin.tie(NULL)
#define LL long long
#define LLU long long unsigned int
typedef pair < int, int > pii;
typedef pair < LL, LL > pll;
typedef vector<int> vi;
typedef vector<LL> vl;
typedef vector<pll> vll;
#ifdef s_da_sailor
#define line cout << "\n===================\n"
#define trace(...) __f( #__VA_ARGS__ , __VA_ARGS__ )
template <typename Arg1>
void __f(const char* name, Arg1&& arg1){
cerr << name << " = " << arg1 << "\n";
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args){
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " = " << arg1 << " , ";
__f(comma + 1, args...);
}
#else
#define line
#define trace(...)
#endif // s_da_sailor
inline LL gcd ( LL a, LL b ) {
a = ABS ( a ); b = ABS ( b );
while ( b ) { a = a % b; swap ( a, b ); } return a;
}
LL ext_gcd ( LL A, LL B, LL *X, LL *Y ){
LL x2, y2, x1, y1, x, y, r2, r1, q, r;
x2 = 1; y2 = 0;
x1 = 0; y1 = 1;
for (r2 = A, r1 = B; r1 != 0; r2 = r1, r1 = r, x2 = x1, y2 = y1, x1 = x, y1 = y ) {
q = r2 / r1;
r = r2 % r1;
x = x2 - (q * x1);
y = y2 - (q * y1);
}
*X = x2; *Y = y2;
return r2;
}
inline LL modInv ( LL a, LL m ) {
LL x, y;
ext_gcd( a, m, &x, &y );
x %= m;
if ( x < 0 ) x += m;
return x;
}
inline LL bigmod ( LL a, LL p, LL m ) {
LL res = 1 % m, x = a % m;
while ( p ) {
if ( p & 1 ) res = ( res * x ) % m;
x = ( x * x ) % m; p >>= 1; /// For bigmod2 multiply here using mulmod
}
return res;
}
//int knightDir[8][2] = { {-2,1},{-1,2},{1,2},{2,1},{2,-1},{-1,-2},{1,-2},{-2,-1} };
//int dir4[4][2] = {{-1,0},{0,1},{1,0},{0,-1}};
//int dir8[8][2] = {{-1,0},{0,1},{1,0},{0,-1},{-1,-1},{1,1},{1,-1},{-1,1}};
const LL inf = 2147383647;
const LL mod = 1000000007;
const double pi = 2 * acos ( 0.0 );
const double eps = 1e-11;
//mt19937 rng(chrono::steady_clock::now().time_since_epoch().count()); /// For generating random numbers
///====================== TEMPLATE ENDS HERE =====================///
#define SIZE 100005
int ks;
string S;
int n, A[SIZE];
void solve() {
cin >> S;
n = S.size();
for(int i=0; i<n; i++) {
A[i] = S[i] - 'a';
}
int curr = 30;
for(int i=0; i<n; i++) {
if(i>=1 && A[i-1]==A[i]) {
A[i] = curr;
curr++;
}
else if(i>=2 && A[i-2]==A[i]) {
A[i] = curr;
curr++;
}
}
cout << curr-30 << endl;
}
int main () {
#ifdef s_da_sailor
freopen ( "input.txt", "r", stdin );
//freopen ( "output.txt", "w", stdout );
#endif // s_da_sailor
fast_cin;
int tc;
cin >> tc;
for(ks=1; ks<=tc; ks++) {
solve();
}
return 0;
}
|
//#include<bits/stdc++.h>
#include <iostream>
#include <vector>
#include <deque>
#include <map>
#include <set>
#include <list>
#include <cmath>
#include <cstring>
#include <algorithm>
using namespace std;
#define fast \
ios_base::sync_with_stdio(0); \
cin.tie(0)
#define file \
freopen("input.txt", "r", stdin); \
freopen("output.txt", "w", stdout)
#define ff first
#define ss second
#define pb push_back
#define pf push_front
#define mp make_pair
#define all(s) s.begin(), s.end()
typedef long long ll;
const double pi = acos(-1);
const ll N = 1e5 + 5;
int main()
{
fast;
ll tc;
cin >> tc;
while (tc--)
{
string s;
ll n, i, j, ans = 0;
cin >> s;
j=s.size();
char ch = '0';
for (i = 0; i < j - 1; i++)
{
if (i < j - 2)
{
if (s[i] == s[i + 1] && s[i] == s[i + 2])ans =ans+2,i=i+2;
else if (s[i] == s[i + 1])ans++,i++;
else if (s[i] == s[i + 2])
{
ans++;
s[i + 2] = ch;
ch++;
ch%='0';
}
}
else if (s[i] == s[i + 1])ans++,i++;
}
cout << ans << endl;
}
} |
#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <tuple>
#include <utility>
#include <cmath>
#include <bitset>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int T;
cin >> T;
for (int t = 0; t < T; ++t) {
string s;
cin >> s;
if (s.length() == 1) cout << 0 << '\n';
else if (s.length() == 2) cout << ((s[0] == s[1]) ? 1 : 0) << '\n';
else {
int ans = 0;
char x = s.front();
for (int i = 2; i < s.length(); ++i) {
if (s[i] != '#' && s[i - 2] == s[i - 1] && s[i - 1] == s[i - 0]) {
ans += 2;
s[i] = '#';
s[i - 1] = '#';
}
else if (s[i - 2] != '#' && s[i - 2] == s[i - 1]) {
ans++;
s[i - 1] = '#';
}
else if (s[i] != '#' && s[i - 1] == s[i]) {
ans++;
s[i] = '#';
}
else if (s[i] != '#' && s[i - 2] == s[i]) {
ans++;
s[i] = '#';
}
}
cout << ans << '\n';
}
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i, a) for (int i = 0; i < (a); i++)
#define repd(i, a) for (int i = (a)-1; i >= 0; i--)
#define reps(i, a, j) for (int i = (j); i < (a); i++)
#define deb(x) cout << #x << " " << x << endl;
#define debs(x) cout << #x << " " << x << " ";
#define deba(x) for (auto _i:x) cout << _i << " "; cout << endl;
#define ms(a) memset(a,0,sizeof(a));
#define mp make_pair
#define eb emplace_back
#define pii pair < int , int >
#define all(a) a.begin(),a.end()
// const int INF = 1e9+7;
/*
*/
void solve() {
string s; cin >> s;
int n = s.length(),res = 0;
reps (i,n,1) {
if (s[i] == s[i-1]) {res ++;s[i] = '?';}
else if (i > 1 && s[i] == s[i-2]) {res++;s[i] = '?';}
}
cout << res << endl;
}
signed main(){
ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
int t; cin >> t;
while (t--) solve();
} |
#include<bits/stdc++.h>
using namespace std;
int main(){
int t;
cin>>t;
while(t--){
string s;
cin>>s;
int i;
int n=s.length();
int ans=0;
if(s[1]==s[0]){
ans++;
s[1]='?';
}
for(i=1;i<n-1;i++){
if(s[i-1]==s[i+1]){
if(s[i]==s[i+1]){
ans=ans+2;
s[i]='!';
s[i+1]='?';
}
else{
s[i+1]='?';
ans++;
}
}
else{
if(s[i]==s[i+1]){
s[i+1]='?';
ans++;
}
}
}
cout<<ans<<endl;
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
typedef unsigned int uint;
typedef double db;
typedef long double ldb;
typedef vector <int> vi;
typedef vector <ll> vl;
struct pii { int x,y; };
struct pll { ll x,y; };
typedef vector <pii> vii;
typedef vector <pll> vll;
#define pb push_back
const ll MOD = 998244353;
const int N = 100005;
const pii dir[4] = {{-1,0},{1,0},{0,-1},{0,1}};
pii operator + (pii x,pii y) {return {x.x+y.x,x.y+y.y};};
pii operator - (pii x,pii y) {return {x.x-y.x,x.y-y.y};};
inline int lowbit(int x) {return x&(-x);}
ll getgcd(ll x,ll y) {return (y==0) ? x : getgcd(y,x%y);}
ll power(ll x,ll mi,ll mod = MOD)
{
ll s1=1LL,s2=x%mod,m=mi;
for (;m;m>>=1) {if (m&1) s1=s1*s2%mod;s2=s2*s2%mod;}
return s1;
}
inline ll getinv(ll x,ll mod = MOD) {return power(x,mod - 2);};
ll fac[N],ifac[N];
void count_prepare(ll mod = MOD)
{
fac[0]=1;for (int i=1;i<N;++i) fac[i]=fac[i-1]*i%mod;
ifac[N-1]=getinv(fac[N-1],mod);
for (int i=N-2;i>=0;--i) ifac[i]=ifac[i+1]*(i+1)%mod;
}
ll C(ll n,ll m,ll mod = MOD)
{
if (n<0 || m<0 || m>n) return 0;
return 1LL*fac[n]*ifac[m]%mod*ifac[n-m]%mod;
}
string st;
int a[N];
//int dp[N][26][26];
int n;
void init()
{
cin>>st;
n=st.size();
a[0]=a[n+1]=a[n+2]=0;
for (int i=1;i<=n;++i) a[i]=st[i-1]-'a'+1;
//memset(dp,0,sizeof(dp[0])*(n+2));
return;
}
int calc(int x1,int x2,int x3,int x4)
{
for (int i=1;i<=26;++i)
{
if (i!=x1 && i!=x2 && i!=x3 && i!=x4) return i;
}
assert(0);
return 0;
}
void solve()
{
int ans=0;
for (int i=2;i<=n;++i)
{
if (a[i]==a[i-1] || (i>2 && a[i]==a[i-2]))
{
a[i]=calc(a[i-1],a[i-2],a[i+1],a[i+2]);
++ans;
}
}
cout<<ans<<endl;
//cout<<"n="<<n<<endl;
//for (int i=1;i<=n;++i) cout<<(char)('a'+a[i]-1)<<' ';cout<<endl;
return;
}
int main()
{
ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
int T=1;
cin>>T;
// T=read();
// count_prepare();
for (int cas=1;cas<=T;++cas)
{
//printf("Case %d : \n",cas);
init();
solve();
}
return 0;
} |
#include<bits/stdc++.h>
#define pb push_back
#define fo(i,n) for(int i=0;i<n;i++)
#define ll long long
#define int long long
#define Mod 1000000007
#define maxn 200005
#define MAX 4294967296 // 2^32
const int M=1e9+7;
#define ip pair<int,int>
#define test(t) ll t;cin>>t;while(t--)
using namespace std;
long long power(int x,int y){
if(y==0)return 1;
long long res=1;
while(y>0){
if(y&1){
res=(res*x)%Mod;
}
x=x*x%Mod;
y/=2;
}
return res;
}
ll power(ll x, ll y, ll p)
{
ll res = 1; // Initialize result
x = x % p; // Update x if it is more than or
// equal to p
while (y > 0)
{
// If y is odd, multiply x with result
if (y & 1)
res = (res*x) % p;
// y must be even now
y = y>>1; // y = y/2
x = (x*x) % p;
}
return res;
}
long long gcd(int x,int y){
// if(y>x)swap(x,y);
if(y==0)return x;
return gcd(y,x%y);
}
// const int N=200005;
// int dp[N];
// int r=1000000000000000005;
int fact[250005];
// int prime[25]={2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97};
// set<int>st;
int mul(int l,int r){
return ((l%Mod)%Mod*(r%Mod)%Mod)%Mod;
}
int nCr(int n,int k){
if(n<k)return 0;
int ans=fact[n]%Mod;
ans=mul(ans,power(fact[n-k],Mod-2));
ans=mul(ans,power(fact[k],Mod-2));
return ans;
}
// int n;
// int v=100000000000000;
// void dfs(int i,int j){
// size[i]=1;
// bool is=1;
// for(auto it:adj[i]){
// if(!vis[it]){
// dfs(it,i);
// size[i]+=size[it];
// }
// }
// }
void solve(){
string s;
cin>>s;
int res=0;
int n=s.length();
int a[n+1];
for(int i=1;i<n;i++){
if(s[i]==s[i-1] || (i-2>=0 && s[i]==s[i-2])){s[i]='*';
res++;}
}
cout<<res<<"\n";
}
signed main(){
// std::string binary = std::bitset<8>(n).to_string();
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
// memset(fact,0,sizeof(fact));
test(t)
solve();
} |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
int main(){
ll t;
cin >> t;
while (t)
{
string s2;
cin >> s2;
ll a = 0;
for (ll i = 0; i < s2.size(); i++)
{
if (((i + 1) < s2.size()) && s2[i] == s2[i + 1] && (s2[i] != '#'))
{
s2[i + 1] = '#';
a++;
}
if (((i + 2) < (s2.size())) && s2[i] == s2[i + 2] && (s2[i] != '#'))
{
s2[i + 2] = '#';
a++;
}
}
cout << a << endl;
t--;
}
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
#define mp make_pair
#define pb push_back
#define fill(a,val) memset(a,val,sizeof(a))
#define f first
#define s second
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
int main()
{
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
int t;
cin>>t;
while(t--)
{
string str;
int res=0;
cin>>str;
int n=str.size();
for(int i=1;i<n;i++)
{
if(str[i]==str[i-1] || (i>1 && str[i]==str[i-2]))
{
res++;
str[i]='#';
}
}
cout<<res<<endl;
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
const int N=1e5+10;
char str[N];
void ac(){
scanf("%s",str+2);
int len=strlen(str+2);
str[0]='A';
str[1]='C';
str[2+len++]='A';
str[2+len++]='C';
int cnt=0;
for(int i=2;i<len;i++){
if((str[i]==str[i-1])||(str[i]==str[i-2])){
cnt++;
str[i]='a';
while((str[i]==str[i-1])||(str[i]==str[i-2])||(str[i]==str[i+1])||(str[i]==str[i+2])){
str[i]=str[i]+1;
}
}
}
cout << cnt << endl;
}
int main(){
int t;
scanf("%d",&t);
while(t--){
ac();
}
}
|
// wla a m7ma ma7ros
#include <algorithm>
#include <bitset>
#include <complex>
#include <cassert>
#include <deque>
#include <iostream>
#include <iomanip>
#include <istream>
#include <iterator>
#include <map>
#include <math.h>
#include <memory>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <string.h>
#include <time.h>
#include <vector>
#define INF_MAX 2147483647
#define INF_MIN -2147483647
#define INF_LL 4000000000000000000LL
#define INF 1000000000
#define EPS 1e-8
#define LL long long
#define mod 1000000007
#define pb push_back
#define mp make_pair
#define f first
#define s second
#define setzero(a) memset(a,0,sizeof(a))
#define setdp(a) memset(a,-1,sizeof(a))
#define bits(a) __builtin_popcountll(a)
using namespace std;
char s[100005];
int dp[100005][2][2];
int v[100005][2][2];
int tt = 0, n;
int solve (int ind, bool last, bool pre) {
if (ind >= n) return 0;
int &temp = dp[ind][last][pre];
if (v[ind][last][pre] == tt) return temp;
v[ind][last][pre] = tt;
temp = INF;
if (!pre && ind > 1 && s[ind - 2] == s[ind]) {
temp = solve(ind + 1, 1, last) + 1;
if (!last && s[ind] == s[ind - 1])
temp++;
} else if (!last && ind > 0 && s[ind] == s[ind - 1]) {
temp = solve(ind + 1, 1, last) + 1;
} else {
temp = min(solve(ind + 1, 1, last) + 1, solve(ind + 1, 0, last));
}
return temp;
}
int main() {
int t;
cin >> t;
while (t--) {
scanf("%s", s);
n = (int) strlen(s);
tt++;
printf("%d\n", solve(0, 0, 0));
}
return 0;
}
// aa, aba
// axba
|
//
// Created by Abhishek Bansal on 12/30/2020.
//
//#pragma GCC optimize ("O3")
//#pragma GCC target ("sse4")
#include <bits/stdc++.h>
#define ll long long
#define ld long double
using namespace std;
int main() {
ios_base::sync_with_stdio(false);cin.tie(nullptr);
int T;cin >> T;
while (T--) {
string s;cin >> s;
int n = s.length(), cnt = 0;
if (n == 1) {
cout << 0 << "\n";
continue;
}
char val[4] = {'1', '2', '3', '4'};
int p = 0;
if (s[1] == s[0]) {
cnt++, s[1] = val[p];
p = (p + 1) % 4;
}
for (int i = 2; i < n; ++i) {
if (s[i] == s[i - 1] || s[i] == s[i - 2]) {
cnt++, s[i] = val[p];
p = (p + 1) % 4;
}
}
cout << cnt << "\n";
}
return 0;
} |
#include <iostream>
#include <string>
using namespace std;
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(0);
int t; cin >> t;
while(t--) {
string s;
cin >> s;
int ct = 0;
for(int i = 1; i < (int)s.size(); i++) {
if(s[i] == s[i - 1] || (i > 1 && s[i] == s[i - 2])) {
ct++;
s[i] = '$';
}
}
cout << ct << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main ()
{
int t;
cin >> t;
string s;
while(t--)
{
cin >> s;
if (s.length() == 1)
{
printf("0\n");
continue;
}
bool tochange[s.length()];
for (bool &c : tochange) c = false;
tochange[1] = s[1] == s[0];
for (int i = 2; i < s.length(); i++)
tochange[i] = (s[i] == s[i - 1] && !tochange[i - 1]) || (s[i] == s[i - 2] && !tochange[i - 2]);
int res = 0;
for (bool c : tochange) if (c) res++;
printf("%d\n", res);
}
} |
#include <iostream>
#include <cstdio>
#include <cstring>
const int N = 1e5 + 10;
char in[N];
bool used[N];
void solve(){
scanf("%s", in + 1);
memset(used, 0, sizeof used);
int ans = 0;
for (int i = 2; i <= strlen(in + 1); ++i) {
bool use_need = false;
if (in[i] == in[i - 1] && !used[i - 1])
use_need = true;
if (i > 2 && in[i] == in[i - 2] && !used[i - 2])
use_need = true;
used[i] = use_need;
ans += use_need;
}
printf("%d\n", ans);
}
int main() {
int cases;
scanf("%d", &cases);
while (cases--)
solve();
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.