text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
long long n, m, l, p, g;
long long hair[100001];
long long sec;
bool higher[100002];
bool t;
int main() {
cin >> n >> m >> l;
for (long long(i) = (1); (i) <= (n); (i)++) {
cin >> hair[i];
higher[i] = (hair[i] > l);
if (!higher[i - 1]) sec += (hair[i] > l);
}
while (m-- > 0) {
cin >> t;
if (t) {
cin >> p >> g;
hair[p] += g;
if (!higher[p]) {
if (hair[p] > l) {
if (!((higher[p - 1]) || (higher[p + 1]))) {
sec++;
}
if (((higher[p - 1]) && (higher[p + 1]))) {
sec--;
}
higher[p] = true;
}
}
} else {
cout << sec;
cout << "\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const double PI = 3.141592653589793238462643383279502884;
const double EPS = 1e-9;
int main() {
long long n, m, l;
cin >> n >> m >> l;
vector<long long> a(100001);
vector<bool> b(100001);
for (int i = 0; i < n; i++) {
cin >> a[i];
b[i] = a[i] > l;
}
long long count = 0;
if (b[0]) {
count++;
}
for (int i = 1; i < n; i++) {
if (b[i] && !b[i - 1]) {
count++;
}
}
for (int j = 0; j < m; j++) {
int t;
cin >> t;
if (t == 0) {
cout << count << endl;
} else {
long long p, d;
cin >> p >> d;
long long prevLength = a[p - 1];
a[p - 1] += d;
if (prevLength <= l && a[p - 1] > l) {
b[p - 1] = true;
if (p == 1) {
if (!b[1]) {
count += 1;
}
} else if (p == n) {
if (!b[n - 2]) {
count += 1;
}
} else {
if (b[p - 2] && b[p]) {
count -= 1;
} else if (!b[p - 2] && !b[p]) {
count += 1;
}
}
}
}
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, l;
cin >> n >> m >> l;
long long arr[n];
bool is[n];
for (long long i = 0; i < n; i++) {
cin >> arr[i];
if (arr[i] > l)
is[i] = true;
else
is[i] = false;
}
long long res = 0;
for (long long i = 0; i < n - 1; i++) {
if (is[i] != is[i + 1] && is[i]) {
res++;
}
}
if (is[n - 1]) res++;
while (m--) {
long long q;
cin >> q;
if (q == 0) {
cout << res << "\n";
} else {
long long x, y;
cin >> x >> y;
x--;
arr[x] += y;
if (n == 1) {
if (!is[x] && arr[x] > l) {
res++;
is[x] = true;
}
continue;
}
if (x == 0) {
if (arr[x] > l && !is[x + 1] && !is[x]) {
res++;
}
if (arr[x] > l) {
is[x] = true;
}
} else if (x == n - 1) {
if (arr[x] > l && !is[x - 1] && !is[x]) {
res++;
}
if (arr[x] > l) {
is[x] = true;
}
} else {
if (arr[x] > l && !is[x - 1] && !is[x + 1] && !is[x]) {
res++;
} else if (arr[x] > l && is[x - 1] && is[x + 1] && !is[x]) {
res--;
}
if (arr[x] > l) {
is[x] = true;
}
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, l, a[100002], t, p, d, c;
int main() {
cin >> n >> m >> l;
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (a[i] > l and a[i - 1] <= l) {
c++;
}
}
for (int i = 1; i <= m; i++) {
cin >> t;
if (t) {
cin >> p >> d;
if (a[p] <= l and a[p] + d > l) {
if (a[p - 1] > l and a[p + 1] > l) {
c--;
} else if (a[p - 1] <= l and a[p + 1] <= l) {
c++;
}
}
a[p] += d;
} else {
cout << c << endl;
}
}
}
|
#include <bits/stdc++.h>
const long long MOD = 1e9 + 7;
const long long INF = 1011111111;
const long long LLINF = 1000111000111000111LL;
const long double EPS = 1e-10;
const long double PI = 3.14159265358979323;
using namespace std;
long long powm(long long base, long long exp, long long mod = MOD) {
long long ans = 1;
while (exp) {
if (exp & 1) ans = (ans * base) % mod;
exp >>= 1, base = (base * base) % mod;
}
return ans;
}
const long long N = 1000005;
long long a[N], mk[N];
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, m, l, type, p, d;
cin >> n >> m >> l;
long long ans = 0;
for (long long i = 1; i < n + 1; i++) cin >> a[i];
for (long long i = 1; i < n + 1; i++)
if (a[i] > l) mk[i] = 1;
for (long long i = 1; i < n + 1; i++)
if (mk[i] and !mk[i - 1]) ans++;
while (m--) {
cin >> type;
if (type == 0) {
cout << ans << '\n';
} else {
cin >> p >> d;
if (mk[p]) continue;
a[p] += d;
if (a[p] > l) {
mk[p] = 1;
if (mk[p - 1] == 0 and mk[p + 1] == 0) {
ans++;
} else if (mk[p - 1] + mk[p + 1] == 1) {
continue;
} else {
ans--;
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long c[100100];
int pai[100100];
int find(int x) {
if (pai[x] == x) return x;
return pai[x] = find(pai[x]);
}
bool join(int a, int b) {
int pa = find(a);
int pb = find(b);
if (pa == pb) return false;
pai[pa] = pai[pb];
return true;
}
int main() {
int n, m;
long long k;
int maior = 0;
cin.sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
cin >> c[i];
if (c[i] > k) maior++;
pai[i] = i;
}
pai[n] = n;
pai[0] = 0;
for (int i = 1; i <= n; i++) {
if ((c[i] > k) and (c[i + 1] > k)) {
if (join(i, i + 1)) maior--;
}
}
for (int i = 1; i <= m; i++) {
int op;
cin >> op;
if (op == 0) {
cout << maior << '\n';
} else {
int a;
long long b;
cin >> a >> b;
if (c[a] <= k) {
c[a] += b;
if (c[a] > k) {
if ((c[a - 1] > k) and (c[a + 1] > k)) {
join(a, a + 1);
join(a, a - 1);
maior--;
} else if (c[a - 1] > k) {
join(a, a - 1);
} else if (c[a + 1] > k) {
join(a, a + 1);
} else {
maior++;
}
}
} else {
c[a] += b;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> parent;
vector<int> Rank;
void add_element(int x) {
parent.push_back(x);
Rank.push_back(1);
}
int find_set(int x) {
if (parent[x] == x) return x;
parent[x] = find_set(parent[x]);
return parent[x];
}
void join_elements(int x, int y) {
int a = find_set(x);
int b = find_set(y);
if (a != b) {
if (Rank[a] > Rank[b]) {
parent[b] = a;
Rank[a] += b;
} else {
parent[a] = b;
Rank[b] += a;
}
}
}
int N, M, L;
long long A, B, C;
long long m[200000];
int main() {
ios_base::sync_with_stdio();
cin.tie(0);
cout.tie(0);
cin >> N >> M >> L;
int segment_count = 0;
m[0] = -1;
add_element(0);
for (int i = 1; i <= N; ++i) {
cin >> m[i];
add_element(i);
if (m[i] > L) {
++segment_count;
if (m[i - 1] > L) {
join_elements(i - 1, i);
--segment_count;
}
}
}
add_element(N + 1);
for (int i = 0; i < M; ++i) {
cin >> A;
if (A == 0)
cout << segment_count << "\n";
else {
cin >> B >> C;
if ((m[B] <= L) && (m[B] + C > L)) {
m[B] += C;
++segment_count;
if (m[B - 1] > L) {
join_elements(B - 1, B);
--segment_count;
}
if (m[B + 1] > L) {
join_elements(B + 1, B);
--segment_count;
}
} else
m[B] += C;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using ll = long long;
using namespace std;
int main() {
ll n, m, l, val, sum;
cin >> n >> m >> l;
sum = 0;
vector<long long int> v;
v.push_back(-1);
for (ll i = 1; i <= n; i++) {
cin >> val;
v.push_back(val);
if (v[i] > l && v[i - 1] <= l) sum++;
}
v.push_back(-1);
ll cod, ind, prev;
while (m--) {
cin >> cod;
if (cod == 0)
cout << sum << endl;
else {
cin >> ind;
cin >> val;
prev = v[ind];
v[ind] += val;
if ((prev <= l) && (v[ind] > l) && (v[ind - 1] <= l) && (v[ind + 1] <= l))
sum++;
if ((prev <= l) && (v[ind] > l) && (v[ind - 1] > l) && (v[ind + 1] > l))
sum--;
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("O3")
#pragma GCC optimize("O2")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cout << name << " : " << arg1 << '\n';
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cout.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
long long dx[4] = {1, -1, 0, 0};
long long dy[4] = {0, 0, 1, -1};
const long long MOD = 1e9 + 7;
long long fast_pow(long long a, long long b) {
long long res = a, ret = 1;
while (b > 0) {
if (b % 2) ret = (ret * res) % MOD;
res = (res * res) % MOD;
b /= 2;
}
return ret;
}
const long long maxN = 1e5 + 7;
long long arr[maxN];
long long par[maxN];
long long sz;
long long siz[maxN];
long long getpar(long long x) {
if (par[x] != x) {
par[x] = getpar(par[x]);
}
return x;
}
void merge(long long a_par, long long b_par) {
if (siz[a_par] < siz[b_par]) {
par[a_par] = par[b_par];
siz[b_par] += siz[a_par];
} else {
par[b_par] = par[a_par];
siz[a_par] += siz[b_par];
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
time_t time_t1, time_t2;
time_t1 = clock();
long long t = 1;
while (t--) {
long long n, m, l;
cin >> n >> m >> l;
for (long long i = 1; i <= n; ++i) {
cin >> arr[i];
par[i] = -1;
}
par[0] = -1;
for (long long i = 1; i <= n; ++i) {
if (arr[i] > l) {
par[i] = i;
siz[i] = 1;
}
}
for (long long i = 1; i < n; ++i) {
if (par[i] != -1 and par[i + 1] != -1) {
long long a_par = getpar(i);
long long b_par = getpar(i + 1);
merge(a_par, b_par);
}
}
par[n + 1] = -1;
sz = 0;
for (long long i = 1; i <= n; ++i) {
if (par[i] == i) {
sz++;
}
}
long long idx, inc;
long long tp;
while (m--) {
cin >> tp;
bool lef = false, rig = false;
if (tp == 0) {
cout << sz << '\n';
} else {
cin >> idx >> inc;
long long al = arr[idx];
arr[idx] += inc;
if (al > l) {
continue;
}
if (arr[idx] <= l) {
continue;
}
if (arr[idx] > l) {
par[idx] = idx;
if (par[idx - 1] != -1) {
lef = true;
long long a_par = getpar(idx);
long long b_par = getpar(idx - 1);
merge(a_par, b_par);
}
if (par[idx + 1] != -1) {
rig = true;
long long a_par = getpar(idx);
long long b_par = getpar(idx + 1);
merge(a_par, b_par);
}
}
if (lef and rig) {
sz--;
} else if (lef == false and rig == false) {
sz++;
}
}
}
}
time_t2 = clock();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int nxt() {
int x;
scanf("%d", &x);
return x;
}
int main() {
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int n = nxt(), m = nxt(), l = nxt();
vector<long long> a(n);
for (int i = 0; i < n; ++i) {
a[i] = nxt();
}
set<int> S;
S.insert(-1);
S.insert(n);
for (int i = 0; i < n; ++i) {
if (a[i] <= l) {
S.insert(i);
}
}
int ans = 0;
int lst = -2;
for (int x : S) {
if (x > lst + 1) {
++ans;
}
lst = x;
}
while (m--) {
int t = nxt();
if (t == 0) {
printf("%d\n", ans);
} else {
int p = nxt() - 1, d = nxt();
bool ok = (a[p] <= l);
a[p] += d;
ok &= (a[p] > l);
if (ok) {
auto it = S.find(p);
if (p > *prev(it) + 1) {
--ans;
}
if (*next(it) > p + 1) {
--ans;
}
++ans;
S.erase(p);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100000;
int n;
long long v[N];
int p[N];
int find(int u) {
if (p[u] == u) return u;
return p[u] = find(p[u]);
}
int main() {
int q, l;
scanf("%d%d%d", &n, &q, &l);
for (int i = 0; i < n; ++i) p[i] = i;
for (int i = 0; i < n; ++i) scanf("%lld", &v[i]);
int comp = 0;
for (int i = 0; i < n; ++i) {
if (v[i] > l) {
++comp;
if (i && v[i - 1] > l) {
int u = find(i - 1);
int v = find(i);
if (u != v) {
--comp;
p[u] = v;
}
}
if (i + 1 < n && v[i + 1] > l) {
int u = find(i + 1);
int v = find(i);
if (u != v) {
--comp;
p[u] = v;
}
}
}
}
while (q--) {
int t;
scanf("%d", &t);
if (t == 0) {
printf("%d\n", comp);
} else {
int a, b;
scanf("%d%d", &a, &b);
--a;
if (v[a] <= l && v[a] + b > l) ++comp;
v[a] += b;
if (v[a] > l) {
int i = a;
if (i && v[i - 1] > l) {
int u = find(i - 1);
int v = find(i);
if (u != v) {
--comp;
p[u] = v;
}
}
if (i + 1 < n && v[i + 1] > l) {
int u = find(i + 1);
int v = find(i);
if (u != v) {
--comp;
p[u] = v;
}
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[100100];
int main() {
long long now = 0;
long long n, m, l;
cin >> n >> m >> l;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] > l) {
if (i == 0) {
now++;
} else {
if (a[i - 1] <= l) now++;
}
}
}
while (m--) {
int cmp;
cin >> cmp;
if (cmp == 0) {
cout << now << endl;
} else {
int p, d;
cin >> p >> d;
p -= 1;
if (a[p] > l) continue;
a[p] += d;
if (a[p] <= l) continue;
if (p != 0) {
if (p == n - 1) {
if (a[p - 1] <= l) now++;
} else {
if (a[p - 1] > l && a[p + 1] > l)
now--;
else if (a[p - 1] <= l && a[p + 1] <= l)
now++;
}
} else {
if (a[p + 1] <= l) now++;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long A[100005];
int main() {
long long N, M, L;
scanf("%lld%lld%lld", &N, &M, &L);
for (int i = 0; i < N; i++) scanf("%lld", &A[i]);
long long cnt = 0, ans = 0;
for (int i = 0; i < N; i++) {
if (A[i] > L) {
if (i == 0 || A[i - 1] <= L) ans++;
}
}
for (int i = 0; i < M; i++) {
int num;
scanf("%d", &num);
if (num == 0) {
printf("%d\n", ans);
} else {
long long p, q;
scanf("%lld%lld", &p, &q);
p--;
if (A[p] > L) continue;
A[p] += q;
if (A[p] <= L) continue;
if (p == 0) {
if (A[p + 1] <= L) ans++;
} else if (p == N - 1) {
if (A[p - 1] <= L) ans++;
} else {
if (A[p - 1] <= L && A[p + 1] <= L)
ans++;
else if (A[p - 1] > L && A[p + 1] > L)
ans--;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = (long long)1e9 + 7;
long long n, m, k, a[100005], ans, x, y, z;
int main() {
cin >> n >> m >> k;
for (long long i = (long long)1; i < (long long)n + 1; i++) {
cin >> a[i];
if (i == 1 && a[i] > k)
ans++;
else if (a[i] > k && a[i - 1] <= k)
ans++;
}
for (long long i = 0; i < (long long)m; i++) {
cin >> x;
if (x == 0)
cout << ans << endl;
else {
cin >> y >> z;
if (a[y] > k)
a[y] += z;
else if (y == 1 && a[y + 1] > k)
a[y] += z;
else if (y == n && a[y - 1] > k)
a[y] += z;
else if (a[y - 1] > k && a[y + 1] > k && a[y] + z > k) {
ans--;
a[y] += z;
} else if (a[y - 1] > k || a[y + 1] > k) {
a[y] += z;
} else if (a[y] + z > k) {
a[y] += z;
ans++;
} else
a[y] += z;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, M;
long long int L;
vector<long long int> A;
vector<int> parent;
vector<int> rnk;
int disjointSetsCount;
void initDisjointSets(int n) {
for (int i = 0; i < n; ++i) {
parent.push_back(i);
rnk.push_back(1);
}
}
int findRoot(int n) {
return parent[n] == n ? n : (parent[n] = findRoot(parent[n]));
}
bool isSameSet(int p, int q) { return findRoot(p) == findRoot(q); }
void join(int p, int q) {
int rootP = findRoot(p), rootQ = findRoot(q);
if (rootP == rootQ) {
return;
}
--disjointSetsCount;
if (rnk[rootP] < rnk[rootQ]) {
parent[rootP] = rootQ;
rnk[rootQ] += rnk[rootP];
return;
}
parent[rootQ] = rootP;
rnk[rootP] += rnk[rootQ];
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int i, x, p;
long long int d;
cin >> N >> M >> L;
initDisjointSets(N);
for (i = 0; i < N; ++i) {
cin >> x;
A.push_back(x);
}
for (i = 0; i < N; ++i) {
if (A[i] > L) {
++disjointSetsCount;
if ((i - 1) >= 0 and A[i - 1] > L) {
join(i, i - 1);
}
}
}
for (i = 0; i < M; ++i) {
cin >> x;
if (x > 0) {
cin >> p >> d;
A[p - 1] += d;
if (A[p - 1] > L) {
if ((A[p - 1] - d) <= L) {
++disjointSetsCount;
}
if (p < N and A[p] > L) {
join(p - 1, p);
}
if ((p - 2) >= 0 and A[p - 2] > L) {
join(p - 1, p - 2);
}
}
} else {
cout << disjointSetsCount << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long count_set(vector<long long> hair, long long l) {
long long ans = 0;
for (long long i = 1; i < hair.size(); i++)
if (hair[i] > l && hair[i - 1] <= l) ans++;
return ans;
}
int main() {
long long n, m, l, ans = 0;
cin >> n >> m >> l;
vector<long long> hair(n + 1, 0);
for (long long i = 1; i <= n; i++) cin >> hair[i];
ans = count_set(hair, l);
for (long long i = 1; i <= m; i++) {
int t;
scanf("%d", &t);
if (t == 0)
cout << ans << endl;
else {
long long p, d;
cin >> p >> d;
if (hair[p] + d > l && hair[p] <= l && p == n) {
if (hair[p - 1] <= l) {
ans++;
}
} else if (hair[p] + d > l && hair[p] <= l && p == 1) {
if (hair[p + 1] <= l) {
ans++;
}
} else if (hair[p] + d > l && hair[p] <= l) {
if (hair[p + 1] > l && hair[p - 1] > l) {
ans--;
} else if (hair[p + 1] <= l && hair[p - 1] <= l) {
ans++;
}
}
hair[p] += d;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int N = 2e5 + 7;
const long long int inf = 1e16 + 9;
const long long int mod = 1e9 + 7;
int main() {
long long int n, m, l, i, j, k, p, d, ans = 0;
cin >> n >> m >> l;
long long int a[n + 1], b[n + 1];
for (i = 0; i < n; i++) {
cin >> a[i];
if (a[i] > l) {
b[i] = 1;
} else
b[i] = 0;
}
b[i] = 0;
for (i = 1; i <= n; i++) {
if (b[i] == 0 && b[i - 1] == 1) ans++;
}
for (i = 0; i < m; i++) {
cin >> k;
if (k == 0) {
printf("%lld\n", ans);
} else {
cin >> p >> d;
p--;
if (a[p] <= l && a[p] + d > l) {
if (p == 0) {
if (b[1] == 0) ans++;
} else if (p == n - 1) {
if (b[n - 2] == 0) ans++;
} else {
if (b[p - 1] == 0 && b[p + 1] == 0) ans++;
if (b[p + 1] == 1 && b[p - 1] == 1) ans--;
}
b[p] = 1;
}
a[p] += d;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int INF = 10000000;
const int N = 100005;
const long long int mod = 1000000007;
vector<int> lst[N];
int parent[N];
bool used[N] = {0};
int cnt = 0;
void make_set(int v) {
lst[v] = vector<int>(1, v);
parent[v] = v;
cnt++;
}
int find_set(int v) { return parent[v]; }
void union_sets(int a, int b) {
a = find_set(a);
b = find_set(b);
if (a != b) {
cnt--;
if (lst[a].size() < lst[b].size()) swap(a, b);
while (!lst[b].empty()) {
int v = lst[b].back();
lst[b].pop_back();
parent[v] = a;
lst[a].push_back(v);
}
}
}
void solve() {
long long int n, m, l;
cin >> n >> m >> l;
;
vector<long long int> d(n + 2);
for (int i = 1; i <= n; i++) {
cin >> d[i];
if (d[i] > l) {
used[i] = 1;
make_set(i);
if (d[i - 1] > l) {
union_sets(i - 1, i);
}
}
}
long long int t, x, y;
for (int i = 0; i < (m); i++) {
cin >> t;
if (t == 0) {
cout << cnt << endl;
} else {
cin >> x >> y;
d[x] += y;
if (used[x]) continue;
if (d[x] > l) {
used[x] = 1;
make_set(x);
if (d[x - 1] > l) {
union_sets(x - 1, x);
}
if (d[x + 1] > l) {
union_sets(x + 1, x);
}
}
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie();
cout.tie();
int t = 1;
while (t--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, l;
long long a[101010];
int c;
int main() {
cin >> n >> m >> l;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) {
if (a[i - 1] <= l && a[i] > l) c++;
}
for (int i = 1; i <= m; i++) {
int t;
cin >> t;
if (t == 0) {
cout << c << "\n";
} else {
int p, d;
cin >> p >> d;
if (a[p] <= l && a[p] + d > l) {
if (a[p - 1] <= l && a[p + 1] <= l) c++;
if (a[p - 1] > l && a[p + 1] > l) c--;
}
a[p] += d;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long M = 1e9 + 7;
long long inf = 2e18;
string to_string(long long x) {
stringstream second;
second << x;
return second.str();
}
long long to_integer(string s) {
stringstream second(s);
long long x;
second >> x;
return x;
}
int main() {
long long n, m, l;
cin >> n >> m >> l;
long long a[n + 1];
for (long long i = 1; i <= n; i++) cin >> a[i];
if (n == 1) {
while (m--) {
long long tp;
cin >> tp;
if (tp == 0) {
if (a[1] <= l)
cout << "0\n";
else
cout << "1\n";
} else {
long long p, d;
cin >> p >> d;
a[p] += d;
}
}
return 0;
}
long long cnt = 0;
for (long long i = 1; i <= n; i++) {
long long loc = 0;
while (a[i] > l) {
i++;
loc++;
}
if (loc) cnt++;
}
while (m--) {
long long tp;
cin >> tp;
if (tp == 0) {
cout << cnt << "\n";
} else {
long long p, d;
cin >> p >> d;
if (a[p] + d <= l || a[p] > l) {
a[p] += d;
continue;
}
if (p == 1) {
if (p + 1 <= n && a[p + 1] <= l) cnt++;
} else if (p == n) {
if (p - 1 > 0 && a[p - 1] <= l) cnt++;
} else {
if (p - 1 > 0 && a[p - 1] <= l && p + 1 <= n && a[p + 1] <= l)
cnt++;
else if (p - 1 > 0 && a[p - 1] > l && p + 1 <= n && a[p + 1] > l)
cnt--;
}
a[p] += d;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, l, a[100005];
int main() {
cin >> n >> m >> l;
long long ans = 0;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n + 1; i++)
if (a[i - 1] > l && a[i] <= l) ans++;
long long t, p, d;
while (m--) {
cin >> t;
if (t == 0)
cout << ans << endl;
else {
cin >> p >> d;
if (a[p] <= l && a[p] + d > l) {
if (a[p - 1] <= l && a[p + 1] <= l)
ans++;
else if (a[p - 1] > l && a[p + 1] > l)
ans--;
}
a[p] += d;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long s[100010], ct, M, N, L;
int t, p, d;
int main() {
scanf("%d%d%d", &N, &M, &L);
for (int i = 0; i < N; i++) {
scanf("%d", &s[i]);
if (s[i] > L) {
if (i == 0)
ct++;
else {
if (s[i - 1] <= L) ct++;
}
}
}
while (M--) {
scanf("%d", &t);
if (t == 0)
printf("%d\n", ct);
else {
scanf("%d%d", &p, &d);
p -= 1;
if (s[p] > L) continue;
s[p] += d;
if (s[p] <= L) continue;
if (p != 0) {
if (p == N - 1) {
if (s[p - 1] <= L) ct++;
} else {
if (s[p - 1] >= L && s[p + 1] > L)
ct--;
else if (s[p - 1] <= L && s[p + 1] <= L)
ct++;
}
} else {
if (s[p + 1] <= L) ct++;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
long long n, m, l;
cin >> n >> m >> l;
vector<long long> a(n);
vector<pair<long long, long long>> lr(n);
long long ans = 0, old = -1000;
long long flag = 0;
for (long long i = 0; i < n; i++) {
cin >> a[i];
if (a[i] > l) {
if (flag == 0) ans++;
flag = 1;
}
if (a[i] <= l && flag == 1) {
flag = 0;
}
}
while (m--) {
long long tp;
cin >> tp;
if (tp == 0) {
cout << ans << endl;
} else {
long long p, d;
cin >> p >> d;
if (n > 1) {
if (a[p - 1] <= l && a[p - 1] + d > l) {
if (p - 1 > 0 && p - 1 < n - 1) {
if (a[p - 2] > l && a[p] > l)
ans--;
else if (a[p - 2] <= l && a[p] > l)
ans += 0;
else if (a[p - 2] > l && a[p] <= l)
ans += 0;
else
ans++;
} else if (p - 1 == 0) {
if (a[p] > l)
ans += 0;
else if (a[p] <= l)
ans++;
} else {
if (a[p - 2] > l)
ans += 0;
else if (a[p - 2] <= l)
ans++;
}
}
} else {
if (a[p - 1] <= l && a[p - 1] + d > l) ans++;
}
a[p - 1] += d;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, m, l;
cin >> n >> m >> l;
vector<long long> A(n, 0);
vector<bool> isgre(n, false);
int count = 0;
for (int i = 0; i < n; ++i) {
cin >> A[i];
if (A[i] > l) isgre[i] = true;
}
long long ans = 0;
int flag = 1;
for (int i = 0; i < n; ++i) {
if (isgre[i]) {
if (flag) {
++ans;
flag ^= 1;
}
} else {
flag = 1;
}
}
for (int i = 0; i < m; ++i) {
int cmd;
cin >> cmd;
if (cmd == 0) {
cout << ans << endl;
} else {
int p, d;
cin >> p >> d;
A[p - 1] += d;
if (A[p - 1] < l || isgre[p - 1]) {
continue;
}
if (A[p - 1] > l) {
int index = p - 1;
if (index + 1 < n && index - 1 >= 0) {
if (isgre[index + 1] && isgre[index - 1]) {
--ans;
isgre[p - 1] = A[p - 1] > l;
continue;
}
}
if (index + 1 < n) {
isgre[p - 1] = A[p - 1] > l;
if (isgre[index + 1]) continue;
}
if (index - 1 >= 0) {
isgre[p - 1] = A[p - 1] > l;
if (isgre[index - 1]) continue;
}
isgre[p - 1] = A[p - 1] > l;
++ans;
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100000 + 7;
int n, m, length;
long long int line[N];
int main() {
ios::sync_with_stdio(false);
cout.tie(nullptr);
cin.tie(nullptr);
cin >> n >> m >> length;
for (int i = 1; i <= n; ++i) cin >> line[i];
int swing = 0;
for (int i = 1; i <= n; ++i)
if (line[i] > length && line[i - 1] <= length) ++swing;
for (int query = 1; query <= m; ++query) {
int type;
cin >> type;
if (type == 0)
cout << swing << "\n";
else {
int p, value;
cin >> p >> value;
if (line[p] <= length && line[p] + value > length) {
if (line[p + 1] > length) --swing;
if (line[p - 1] <= length) ++swing;
}
line[p] += value;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, m, l;
cin >> n >> m >> l;
vector<long long> a(n + 2);
for (long long i = 1; i <= n; i++) cin >> a[i];
a[n + 1] = a[0] = 0;
long long seg = 0;
for (long long i = 1; i <= n; i++) {
if (a[i - 1] <= l && a[i] > l) seg++;
}
while (m--) {
long long query;
cin >> query;
if (query == 0) {
cout << seg << "\n";
} else {
long long p, d;
cin >> p >> d;
a[p] += d;
if (a[p] > l && a[p] - d <= l && a[p - 1] > l && a[p + 1] > l) {
seg--;
} else if (a[p] > l && a[p] - d <= l &&
(a[p - 1] <= l && a[p + 1] <= l)) {
seg++;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
long long mod = 1e9 + 7;
const int MAX = 1e5 + 5;
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
long long l;
cin >> n >> m >> l;
long long a[n + 1];
for (int i = 1; i <= n; i++) cin >> a[i];
long long ans = 0;
long long cnt = 0;
for (int i = 1; i <= n; i++) {
int f = 0;
while (a[i] > l && i <= n) {
f = 1;
i++;
continue;
}
if (f == 1) {
ans++;
i--;
}
}
if (n == 1) {
for (int i = 0; i < m; i++) {
int x;
cin >> x;
if (x == 0)
cout << ans << endl;
else {
long long pos, d;
cin >> pos >> d;
long long ini = a[pos];
a[pos] += d;
if (ini <= l) {
if (a[pos] > l) ans++;
}
}
}
return 0;
}
for (int i = 0; i < m; i++) {
int x;
cin >> x;
if (x == 0) {
cout << ans;
cout << '\n';
} else {
long long pos;
long long val;
cin >> pos >> val;
long long ini = a[pos];
a[pos] += val;
if (pos == 1) {
if (ini <= l && a[2] <= l) {
if (a[pos] > l) ans++;
}
} else if (pos == n) {
if (ini <= l && a[n - 1] <= l) {
if (a[pos] > l) ans++;
}
} else {
if (ini <= l && a[pos + 1] > l && a[pos - 1] > l) {
if (a[pos] > l) ans--;
} else if (ini <= l && a[pos + 1] <= l && a[pos - 1] <= l) {
if (a[pos] > l) ans++;
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, a[200200], r, y, o, k, p, v, i, d;
int main() {
cin >> n >> m >> k;
cin >> a[1];
if (a[1] > k) o++;
for (i = 2; i <= n; i++) {
cin >> a[i];
if (a[i] > k && a[i - 1] <= k) o++;
}
for (i = 1; i <= m; i++) {
cin >> d;
if (d == 0) {
cout << o << endl;
} else {
cin >> p >> v;
if (a[p - 1] > k && a[p + 1] > k && (a[p] + v) > k && a[p] <= k)
o--;
else if (a[p] <= k && (a[p] + v) > k && (!(a[p - 1] > k || a[p + 1] > k)))
o++;
a[p] = a[p] + v;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <class TH>
void _dbg(const char *sdbg, TH h) {
cerr << sdbg << "=" << h << "\n";
}
template <class TH, class... TA>
void _dbg(const char *sdbg, TH h, TA... a) {
while (*sdbg != ',') cerr << *sdbg++;
cerr << "=" << h << ",";
_dbg(sdbg + 1, a...);
}
const long long inf = 1000 * 1000 * 1000 + 7;
const long long INF = inf * inf;
const long long MOD = inf;
const long long N = 1e5 + 10, base = 1 << 18;
long long tab[N];
long long n, m, l;
void solve() {
cin >> n >> m >> l;
set<pair<long long, long long> > prze;
for (long long i = (1); i <= (n); i++) cin >> tab[i];
long long res = 0;
long long bylo = false;
for (long long i = (1); i <= (n); i++) {
if (tab[i] <= l) bylo = false;
if (tab[i] > l && !bylo) {
res++;
bylo = true;
}
}
while (m--) {
long long in;
cin >> in;
if (in == 0) {
cout << res << "\n";
continue;
}
long long gdzie, ile;
cin >> gdzie >> ile;
tab[gdzie] += ile;
if (tab[gdzie] - ile > l || tab[gdzie] <= l) continue;
if (tab[gdzie - 1] > l && tab[gdzie + 1] > l) res--;
if (tab[gdzie - 1] <= l && tab[gdzie + 1] <= l) res++;
}
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cerr.tie(0);
cout << setprecision(9) << fixed;
cerr << setprecision(6) << fixed;
long long test = 1;
while (test--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, l;
long long int vet[100010], cont;
long long int st[40 * 100010];
inline long long int buildtree(int p, int i, int j) {
if (i == j) {
if (vet[i] > l)
st[p] = 1;
else
st[p] = 0;
return st[p];
}
int meio = (i + j) / 2;
long long int p1 = buildtree(p * 2, i, meio);
long long int p2 = buildtree(p * 2 + 1, meio + 1, j);
long long int r = p1 + p2;
if (vet[meio] > l and vet[meio + 1] > l) r--;
return st[p] = r;
}
inline long long int update(int p, int i, int j, int pos, int val) {
if (i > pos or j < pos) {
return st[p];
}
if (i == j) {
vet[i] += val;
if (vet[i] > l)
st[p] = 1;
else
st[p] = 0;
return st[p];
}
int meio = (i + j) / 2;
long long int p1 = update(p * 2, i, meio, pos, val);
long long int p2 = update(p * 2 + 1, meio + 1, j, pos, val);
long long int r = p1 + p2;
if (vet[meio] > l and vet[meio + 1] > l) r--;
return st[p] = r;
}
int main() {
cin >> n >> m >> l;
cont = 1;
for (int i = 1; i <= n; i++) {
cin >> vet[i];
}
buildtree(1, 1, n);
while (m--) {
int t;
cin >> t;
if (t == 0)
cout << st[1] << endl;
else {
int p, d;
cin >> p >> d;
update(1, 1, n, p, d);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long TESTS = 1;
while (TESTS--) {
long long n, q, l;
cin >> n >> q >> l;
vector<long long> a(n + 1);
for (long long i = 1; i < n + 1; i++) cin >> a[i];
long long ans = 0, cnt = 0;
for (long long i = 1; i < n + 1; i++)
if (a[i] > l)
cnt++;
else if (cnt)
ans++, cnt = 0;
if (cnt) ans++;
while (q--) {
long long ch;
cin >> ch;
if (!ch)
cout << ans << '\n';
else {
long long p, d;
cin >> p >> d;
if (n == 1) {
a[1] += d;
if (a[1] > l) ans = 1;
continue;
}
if (p == 1) {
if (a[1] + d > l && a[1] <= l)
if (a[2] <= l) ans++;
a[1] += d;
continue;
}
if (p == n) {
if (a[n] + d > l && a[n] <= l)
if (a[n - 1] <= l) ans++;
a[n] += d;
continue;
}
if (a[p - 1] > l && a[p + 1] > l && a[p] <= l && a[p] + d > l)
ans--;
else if (a[p - 1] <= l && a[p + 1] <= l && a[p] <= l && a[p] + d > l)
ans++;
a[p] += d;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, l, q, res, a, b, components;
int snm[100001], siz[100001], len[100001];
int find(int ind) {
if (snm[ind] == ind) return ind;
return snm[ind] = find(snm[ind]);
}
bool unionn(int a, int b) {
a = find(a);
b = find(b);
if (a == b) return false;
if (a < b) swap(a, b);
snm[b] = a;
siz[a] += siz[b];
--components;
}
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(nullptr);
cin >> n >> q >> l >> len[0];
if (len[0] > l) ++components;
snm[0] = 0, siz[0] = 1;
for (int i = 1; i < n; ++i) {
snm[i] = i;
siz[i] = 1;
cin >> len[i];
if (len[i] > l) {
++components;
if (len[i - 1] > l) unionn(i, i - 1);
}
}
for (int i = 0; i < q; ++i) {
cin >> a;
if (a == 0)
printf("%d\n", components);
else {
cin >> a >> b;
if (len[a - 1] > l) continue;
len[a - 1] += b;
if (len[a - 1] > l) {
++components;
if (a - 2 >= 0 && len[a - 2] > l) unionn(a - 1, a - 2);
if (a < n && len[a] > l) unionn(a - 1, a);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
const double PI =
3.141592653589793238462643383279502884197169399375105820974944;
using namespace std;
vector<pair<long long, long long> > vec;
int bin_search(long long n) {
int start = 0, end = vec.size();
while (start < end) {
int mid = (start + end) >> 1;
if (vec[mid].first < n)
start = mid + 1;
else
end = mid;
}
if (start < 0 || start >= vec.size()) return -1;
if (vec[start].first >= n && vec[start].second <= n)
return start;
else
return -1;
}
void solve() {
long long n, m, l;
cin >> n >> m >> l;
long long arr[n];
for (long long i = 0; i < n; ++i) {
cin >> arr[i];
}
int start = -1, ans = 0;
if (arr[0] > l) {
++ans;
}
for (long long i = 0; i < n; ++i) {
if (arr[i] <= l && start == -1) {
start = i;
} else if (arr[i] > l && start != -1) {
++ans;
start = -1;
}
}
for (long long i = 0; i < m; ++i) {
long long t;
cin >> t;
if (t == 0) {
cout << ans << "\n";
} else {
long long p, d;
cin >> p >> d;
p--;
long long prev = arr[p];
arr[p] += d;
if (prev <= l && arr[p] > l) {
if (p - 1 >= 0 && arr[p - 1] <= l && p + 1 < n && arr[p + 1] <= l) {
ans++;
} else if (p - 1 >= 0 && arr[p - 1] <= l && p + 1 >= n)
++ans;
else if (p + 1 < n && arr[p + 1] <= l && p - 1 < 0)
++ans;
else if (p - 1 < 0 && p + 1 >= n)
++ans;
if (p - 1 >= 0 && p + 1 < n && arr[p - 1] > l && arr[p + 1] > l) --ans;
}
}
}
}
int main() {
bool testing = false;
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
if (testing) {
freopen("test.txt", "rt", stdin);
int start = clock();
solve();
int end = clock();
cout << "time: " << (end - start) / (double)(CLOCKS_PER_SEC)*1000
<< " milliseconds\n";
} else {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, m, l;
cin >> n >> m >> l;
vector<long long> vec(n);
set<long long> s;
for (long long i = 0; i < n; ++i) {
cin >> vec[i];
if (vec[i] > l) s.insert(i);
}
long long cnt = 0;
long long prev = -2;
for (auto x : s) {
if (x > prev + 1) ++cnt;
prev = x;
}
while (m > 0) {
--m;
int q;
cin >> q;
if (q == 0) {
cout << cnt << endl;
} else {
long long p, d;
cin >> p >> d;
--p;
vec[p] += d;
if (vec[p] > l) s.insert(p);
if (vec[p] > l && vec[p] - d <= l) {
if (p > 0 && p == n - 1) {
if (vec[p - 1] <= l) ++cnt;
} else if (p < n - 1 && p == 0) {
if (vec[p + 1] <= l) ++cnt;
} else if (p < n - 1 && p > 0) {
if (vec[p + 1] <= l && vec[p - 1] <= l)
++cnt;
else if (vec[p + 1] > l && vec[p - 1] > l)
--cnt;
} else if (p == 0 && p == n - 1) {
if (vec[p] > l && vec[p] - d <= l) ++cnt;
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
const int maxn = 1e5 + 10;
long long a[maxn];
int n, m, l;
int main() {
scanf("%d%d%d", &n, &m, &l);
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
int ans = 0;
for (int i = 1; i <= n;) {
if (a[i] > l) {
int j = 1;
while (i + j <= n && a[i + j] > l) j++;
ans++;
i += j;
} else
i++;
}
for (int i = 0; i < m; i++) {
int t;
scanf("%d", &t);
if (t == 0)
printf("%d\n", ans);
else {
int pos, x;
scanf("%d", &pos);
scanf("%d", &x);
if (a[pos] > l)
a[pos] += x;
else {
a[pos] += x;
if (a[pos] > l) {
ans++;
if (a[pos - 1] > l) ans--;
if (a[pos + 1] > l) ans--;
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void __print(long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
long long f = 0;
cerr << '{';
for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
const long long inf = 3e18;
const long long N = 1e5 + 10;
long long n, m, l, a[N];
long long ans;
void add(long long ind) {
if (ind == 0 || a[ind - 1] <= l) ans++;
if (ind < n - 1 and a[ind + 1] > l) ans--;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> m >> l;
for (long long i = 0; i < n; i++) {
cin >> a[i];
if (a[i] > l) add(i);
}
while (m--) {
long long op;
cin >> op;
if (op == 0)
cout << ans << '\n';
else {
long long ind, val;
cin >> ind >> val;
--ind;
if (a[ind] <= l and a[ind] + val > l) add(ind);
a[ind] += val;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int m, n, l, s = 0;
cin >> n >> m >> l;
vector<int> a(n);
vector<int> otvet;
for (int i = 0; i < n; ++i) cin >> a[i];
if (n == 1) {
for (int i = 0; i < m; ++i) {
int x;
cin >> x;
if (x == 0) {
if (a[0] <= l)
otvet.push_back(0);
else
otvet.push_back(1);
continue;
}
int y, z;
cin >> y >> z;
if (a[0] <= l) a[0] += z;
}
for (int i = 0; i < otvet.size(); ++i) cout << otvet[i] << endl;
return 0;
}
int i = 0;
while (i < n) {
if (a[i] <= l) {
++i;
continue;
}
int j = i;
while (a[j] > l && j < n) {
j++;
}
s++;
i = j;
}
for (int i = 0; i < m; ++i) {
int x;
cin >> x;
if (x == 0) {
otvet.push_back(s);
continue;
}
int y, z;
cin >> y >> z;
y--;
if (a[y] > l) continue;
a[y] += z;
if (a[y] > l) {
if (y > 0 && y < n - 1) {
if (a[y - 1] <= l && a[y + 1] <= l)
s++;
else if (a[y - 1] > l && a[y + 1] > l) {
s--;
}
} else if (y == 0) {
if (a[y + 1] <= l) s++;
} else if (y == n - 1) {
if (a[y - 1] <= l) s++;
}
}
}
for (int i = 0; i < otvet.size(); ++i) cout << otvet[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long cul, que, len, x, y, z, trig = 0, old = -1;
map<long long, long long> m, an;
map<long long, long long>::iterator it;
bool vis[1000000];
void primaryjob() {
memset((vis), (false), sizeof((vis)));
;
for (long long int i = (long long int)1; i <= cul; i++) {
if (m[i] > len) {
vis[i] = true;
}
}
old = 0;
for (long long int i = (long long int)1; i <= cul; i++) {
if (vis[i]) {
old++;
while (vis[i + 1] == vis[i]) {
i++;
}
}
}
}
int main() {
scanf("%lld %lld %lld", &cul, &que, &len);
for (long long int i = (long long int)0; i < cul; i++) {
scanf("%lld", &x);
m[i + 1] = x;
}
primaryjob();
for (long long int i = (long long int)0; i < que; i++) {
scanf("%lld", &x);
if (x) {
scanf("%lld %lld", &y, &z);
trig = 0;
if (m[y] > len) {
trig = 1;
}
m[y] = m[y] + z;
if (trig and m[y] > len)
trig = 0;
else if (!trig and m[y] > len)
trig = 1;
if (trig) {
vis[y] = true;
if (vis[y - 1] and vis[y + 1]) old--;
if (!vis[y - 1] and !vis[y + 1]) old++;
}
} else {
printf("%lld\n", old);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int n, m, q, p;
long long int arr[100005], d, l;
cin >> n >> m >> l;
for (int i = 0; i < n; i++) cin >> arr[i];
int cur_cut = 0;
for (int i = 0; i < n; i++) {
if (arr[i] > l) {
cur_cut++;
while (arr[i] > l && i < n) i++;
i--;
}
}
for (int i = 0; i < m; i++) {
cin >> q;
if (q == 0)
cout << cur_cut << "\n";
else {
cin >> p >> d;
if (arr[p - 1] > l || arr[p - 1] + d <= l)
arr[p - 1] += d;
else {
arr[p - 1] += d;
if (p == 1) {
if (arr[p] <= l) cur_cut++;
} else if (p == n) {
if (arr[p - 2] <= l) cur_cut++;
} else if (arr[p] > l && arr[p - 2] > l)
cur_cut--;
else if (arr[p] <= l && arr[p - 2] <= l) {
cur_cut++;
}
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 100005;
int n, q, b[N], r;
ll a[N], l;
int f(int x) { return b[x] && !b[x - 1]; }
void u(int x, ll y) {
r -= f(x) + f(x + 1);
a[x] += y;
b[x] = (a[x] > l);
r += f(x) + f(x + 1);
}
int main() {
scanf("%d%d%lld", &n, &q, &l);
for (int i = 1; i <= n; i++) {
ll x;
scanf("%lld", &x);
u(i, x);
}
for (int t; q--;) {
scanf("%d", &t);
if (t == 0)
printf("%d\n", r);
else {
int i;
ll x;
scanf("%d%lld", &i, &x);
u(i, x);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, q, l, x, y, z, ans, a[2000000];
void f(int x, int y) {
if (a[x] > l) return;
a[x] += y;
if (a[x] <= l) return;
if (a[x - 1] <= l && a[x + 1] <= l) ans++;
if (a[x - 1] > l && a[x + 1] > l) ans--;
}
int main() {
scanf("%d%d%d", &n, &q, &l);
for (int i = (1); i <= (n); i++) {
scanf("%d", &x);
f(i, x);
}
for (int i = (1); i <= (q); i++) {
scanf("%d", &x);
if (x) {
scanf("%d%d", &y, &z);
f(y, z);
} else
printf("%d\n", ans);
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long INF = 1e9;
const int MAX = 1e5 + 7, N = 1e5 + 3;
double pi = acos(-1);
long long r, l, k, m, n, ans;
long long hair[100100];
bool seg[100100];
int main() {
cin >> n >> m >> l;
for (int i = 1; i <= n; i++) {
cin >> hair[i];
if (hair[i] > l) {
seg[i] = true;
}
}
for (int i = 1; i <= n; i++) {
if (seg[i] == 1 and seg[i - 1] == 0) {
ans++;
}
}
bool task;
long long p, d;
for (int i = 0; i < m; i++) {
cin >> task;
if (task == 0) {
cout << ans << endl;
} else {
cin >> p >> d;
if (seg[p]) {
continue;
} else {
hair[p] += d;
if (hair[p] > l) {
seg[p] = true;
if (seg[p - 1] == 0 and seg[p + 1] == 0) {
ans++;
} else if ((seg[p - 1] == 1 and seg[p + 1] == 1)) {
ans--;
}
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
int chkmax(T& a, T b) {
if (b > a) {
a = b;
return 1;
}
return 0;
}
template <class T>
int chkmin(T& a, T b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
template <class iterator>
void output(iterator begin, iterator end, ostream& out = cerr) {
while (begin != end) {
out << (*begin) << " ";
begin++;
}
out << '\n';
}
template <class T>
void output(T x, ostream& out = cerr) {
output(x.begin(), x.end(), out);
}
void fast_io() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
const int mx = 1e5 + 228;
long long n, m, l, a[mx], b[mx], ans = 0;
void make1(int i) {
int cnt1 = 0;
if (i > 0 && b[i - 1] == 1) cnt1++;
if (i < n - 1 && b[i + 1] == 1) cnt1++;
b[i] = 1;
if (cnt1 == 0) ans++;
if (cnt1 == 2) ans--;
}
signed main() {
cin >> n >> m >> l;
for (int i = 0; i < n; ++i) {
cin >> a[i];
if (a[i] > l) {
make1(i);
}
}
for (int i = 0; i < m; ++i) {
int type;
cin >> type;
if (type == 0) {
cout << ans << '\n';
} else {
int pos, val;
cin >> pos >> val;
pos--;
if (a[pos] <= l && a[pos] + val > l) {
make1(pos);
}
a[pos] += val;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(0);
long long n, m, l, s = 0;
cin >> n >> m >> l;
long long a[n + 2];
for (long long i = 1; i <= n; i++) cin >> a[i];
a[0] = 0;
for (long long i = 1; i <= n; i++) {
if (a[i - 1] <= l && a[i] > l) s++;
}
a[n + 1] = 0;
while (m--) {
long long x;
cin >> x;
if (x == 0)
cout << s << "\n";
else {
long long p, d;
cin >> p >> d;
if (a[p] <= l && a[p] + d > l) {
if (a[p - 1] <= l && a[p + 1] <= l) s++;
if (a[p - 1] > l && a[p + 1] > l) s--;
}
a[p] += d;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct fastIO {
fastIO() {}
};
void no() {
cout << "NO";
exit(0);
}
void yes() {
cout << "YES";
exit(0);
}
const int MAXN = 1e6 * 2;
long long n, x, a[MAXN], b[MAXN], m, l, ans, y, z;
int main() {
if (0) cerr << fixed << setprecision(20);
fastIO();
cin >> n >> m >> l;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) {
if (a[i] > l) {
if (!x) {
x++;
b[i]++;
ans++;
}
} else if (x) {
b[i - 1]++;
x = 0;
}
}
for (int i = 0; i < m; i++) {
cin >> x;
if (x) {
cin >> y >> z;
y--;
if (a[y] > l) continue;
a[y] += z;
if (0) cerr << endl;
if (y && a[y] > l && b[y - 1] && b[y + 1]) {
ans--;
} else if (a[y] > l) {
if ((y && b[y - 1]) || b[y + 1]) {
b[y]++;
} else {
ans++;
b[y]++;
}
}
} else {
cout << ans << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
int main() {
std::ios::sync_with_stdio(0);
std::cin.tie(0);
std::cout.tie(0);
std::cout.precision(15);
std::cout.setf(std::ios::fixed);
int n, m, l;
std::cin >> n >> m >> l;
std::vector<int64_t> a(n);
for (int i = 0; i < n; ++i) {
std::cin >> a[i];
}
int ans = (a[0] > l) ? 1 : 0;
for (int i = 1; i < n; ++i) {
if (a[i] > l && a[i - 1] <= l) {
++ans;
}
}
for (int i = 0; i < m; ++i) {
int t;
std::cin >> t;
if (t == 1) {
int64_t p, d;
std::cin >> p >> d;
--p;
if (a[p] + d <= l || a[p] > l) {
a[p] += d;
} else if (n == 1) {
a[p] += d;
ans = 1;
} else if (p > 0 && p + 1 < n && a[p - 1] <= l && a[p + 1] <= l ||
p == 0 && a[1] <= l || p + 1 == n && a[p - 1] <= l) {
++ans;
a[p] += d;
} else if (p > 0 && p + 1 < n && a[p - 1] > l && a[p + 1] > l) {
--ans;
a[p] += d;
} else {
a[p] += d;
}
} else {
std::cout << ans << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
void _R(T &x) {
cin >> x;
}
void _R(int &x) { scanf("%d", &x); }
void _R(long long &x) { scanf("%lld", &x); }
void _R(double &x) { scanf("%lf", &x); }
void _R(char &x) { scanf(" %c", &x); }
void _R(char *x) { scanf("%s", x); }
void R() {}
template <class T, class... U>
void R(T &head, U &...tail) {
_R(head);
R(tail...);
}
template <class T>
void _W(const T &x) {
cout << x;
}
void _W(const int &x) { printf("%d", x); }
void _W(const long long &x) { printf("%lld", x); }
void _W(const double &x) { printf("%.16f", x); }
void _W(const char &x) { putchar(x); }
void _W(const char *x) { printf("%s", x); }
template <class T, class U>
void _W(const pair<T, U> &x) {
_W(x.first);
putchar(' ');
_W(x.second);
}
template <class T>
void _W(const vector<T> &x) {
for (auto i = x.begin(); i != x.end(); _W(*i++))
if (i != x.cbegin()) putchar(' ');
}
void W() {}
template <class T, class... U>
void W(const T &head, const U &...tail) {
_W(head);
putchar(sizeof...(tail) ? ' ' : '\n');
W(tail...);
}
int MOD = 1e9 + 7;
void ADD(long long &x, long long v) {
x = (x + v) % MOD;
if (x < 0) x += MOD;
}
const int SIZE = 1e6 + 10;
struct Union_Find {
int d[SIZE], num[SIZE];
void init(int n) {
for (int i = 0; i < (n); ++i) d[i] = i, num[i] = 1;
}
int find(int x) { return (x != d[x]) ? (d[x] = find(d[x])) : x; }
bool is_root(int x) { return d[x] == x; }
bool uu(int x, int y) {
x = find(x);
y = find(y);
if (x == y) return 0;
if (num[x] > num[y]) swap(x, y);
num[y] += num[x];
d[x] = y;
return 1;
}
} U;
long long a[SIZE];
int main() {
int n, m, l;
R(n, m, l);
U.init(n + 1);
int an = 0;
for (int i = (1); i <= (n); ++i) {
R(a[i]);
if (a[i] > l) {
an++;
if (a[i - 1] > l) {
if (U.uu(i - 1, i)) an--;
}
}
}
while (m--) {
int ty;
R(ty);
if (!ty)
W(an);
else {
int p, d;
R(p, d);
if (a[p] <= l) {
a[p] += d;
if (a[p] > l) {
an++;
if (a[p - 1] > l) {
if (U.uu(p - 1, p)) an--;
}
if (a[p + 1] > l) {
if (U.uu(p + 1, p)) an--;
}
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 100002;
long long a[MAX_N];
int vis[MAX_N];
int main() {
int n, q, l;
scanf("%d%d%d", &n, &q, &l);
for (int i = 0; i < n; i++) scanf("%lld", &a[i]);
int i = 0, flag = 0, left = -1, right = -1;
int ans = 0;
while (i < n) {
if (flag == 0) {
while (a[i] <= l) {
++i;
if (i >= n) break;
}
if (i >= n) break;
left = i;
flag = 1;
}
if (flag == 1) {
while (a[i] > l) {
vis[i] = 1;
++i;
if (i >= n) break;
}
right = i - 1;
ans++;
if (i >= n) break;
left = right = -1;
flag = 0;
}
}
while (q--) {
int t;
scanf("%d", &t);
if (t == 0) {
printf("%d\n", ans);
} else {
int p, d;
scanf("%d%d", &p, &d);
--p;
a[p] += d;
if (vis[p] == 0 && a[p] > l) {
vis[p] = 1;
int vlef = 0, vrig = 0;
if (p - 1 >= 0 && vis[p - 1] == 1) vlef = 1;
if (p + 1 < n && vis[p + 1] == 1) vrig = 1;
if (vlef == 1 && vrig == 1) --ans;
if (vlef == 0 && vrig == 0) ++ans;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << std::endl;
}
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...);
}
void pre() {}
void solve() {}
long long a[100009];
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cin.exceptions(cin.failbit);
pre();
int n;
cin >> n;
int m, l;
cin >> m >> l;
int ans = 0;
for (int i = 0; i < (n); ++i) {
cin >> a[i + 1];
if (a[i + 1] > l && a[i] <= l) ans++;
}
for (int i = 0; i < (m); ++i) {
int t;
cin >> t;
if (t == 0)
cout << ans << '\n';
else {
long long p, d;
cin >> p >> d;
if (a[p] > l) continue;
a[p] += d;
if (a[p] > l) {
ans++;
if (a[p - 1] > l) ans--;
if (a[p + 1] > l) ans--;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, l, q, num, ll;
cin >> n >> m >> l;
vector<long long> len(n);
vector<bool> is_long(n, false);
long long prev_long = 0;
long long count = 0;
bool was_long = false;
for (long long i = 0; i < n; ++i) {
cin >> len[i];
if (len[i] > l) {
if (!was_long) {
++count;
}
was_long = true;
is_long[i] = true;
} else {
was_long = false;
}
}
int c_merged;
for (long long i = 0; i < m; ++i) {
cin >> q;
if (q == 1) {
cin >> num >> ll;
len[num - 1] += ll;
if (len[num - 1] > l) {
c_merged = 0;
if (is_long[num - 1] == false) {
if (num - 2 >= 0 && is_long[num - 2] == true) {
c_merged++;
}
if (num < n && is_long[num] == true) {
c_merged++;
}
if (c_merged == 2) {
--count;
}
if (c_merged == 0) {
++count;
}
}
is_long[num - 1] = true;
}
} else {
cout << count << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, l, a[100002], ans, p, d;
signed main() {
cin >> n >> m >> l;
for (long long i = 1; i <= n; i++) cin >> a[i];
for (long long i = 1; i <= n; i++)
if (a[i] > l && a[i - 1] <= l) ans++;
for (long long i = 1; i <= m; i++) {
long long type;
cin >> type;
if (!type)
cout << ans << "\n";
else {
cin >> p >> d;
if (a[p] <= l && a[p] + d > l) {
if (a[p - 1] <= l && a[p + 1] <= l) ans++;
if (a[p - 1] > l && a[p + 1] > l) ans--;
}
a[p] += d;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long ara[100009];
long long fnd[100009] = {0};
struct node {
long b, e;
node() {}
node(long _b, long _e) {
b = _b;
e = _e;
}
bool operator<(const node &bb) const { return b > bb.b; }
};
struct nd {
long long bb, ee;
nd() {}
nd(long long _bb, long long _ee) {
bb = _bb;
ee = _ee;
}
};
nd a[100009];
int main() {
long long i, j, k, l, m, n, p, q, b, e, cnt;
while (cin >> n >> m >> l) {
for (i = 1; i <= n; i++) {
cin >> ara[i];
}
b = e = 0;
for (i = 0; i <= n + 1; i++) {
a[i] = nd(0, 0);
}
memset(fnd, 0, sizeof(fnd));
cnt = 0;
for (i = 1; i <= n;) {
if (ara[i] > l) {
b = i;
fnd[b] = b;
j = i + 1;
while (j <= n && ara[j] > l) {
fnd[j] = b;
j++;
}
i = j;
a[j - 1] = nd(b, j - 1);
cnt++;
} else
i++;
}
for (i = 1; i <= m; i++) {
cin >> k;
if (k == 0)
cout << cnt << endl;
else {
cin >> p >> q;
if (fnd[p] != 0) continue;
ara[p] += q;
if (ara[p] > l) {
long long strt1 = fnd[p - 1];
long long strt2 = fnd[p + 1];
if (strt1 != 0 && strt2 != 0) {
fnd[p] = strt1;
a[strt1] = nd(a[strt1].bb, a[strt2].ee);
cnt--;
} else if (strt1 == 0 && strt2 == 0) {
fnd[p] = p;
cnt++;
a[p] = nd(p, p);
} else if (strt1 != 0) {
a[strt1] = nd(strt1, p);
fnd[p] = strt1;
} else if (strt2 != 0) {
fnd[p] = p;
a[p] = nd(p, a[strt2].ee);
}
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MN = 100005, inf = 1000000005, mod = 1000000007;
const long long INF = 1000000000000000005LL;
long long A[MN], licze[MN];
int main() {
int n, m, l, res = 0;
scanf("%d%d%d", &n, &m, &l);
for (int i = 1; i <= n; ++i) {
scanf("%lld", &A[i]);
if (A[i] > l) {
licze[i] = 1;
if (A[i - 1] <= l) ++res;
}
}
while (m--) {
int t;
scanf("%d", &t);
if (t == 0) {
printf("%d\n", res);
} else {
int p, d;
scanf("%d%d", &p, &d);
A[p] += d;
if (!licze[p] && A[p] > l) {
licze[p] = 1;
int soms = licze[p - 1] + licze[p + 1];
if (soms == 0)
++res;
else if (soms == 2)
--res;
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
long long a[200000];
long long l;
int p;
long long d;
int r = 0;
int t;
int main() {
scanf("%d %d %lld", &n, &m, &l);
for (int i = 0; i < n; i++) scanf("%lld", &a[i]);
if (a[0] > l) r++;
for (int i = 1; i < n; i++) {
if (a[i] > l && a[i - 1] <= l) r++;
}
while (m--) {
scanf("%d", &t);
if (t == 0)
printf("%d\n", r);
else {
scanf("%d %lld", &p, &d);
p--;
if (a[p] <= l && a[p] + d > l) {
r++;
if ((p > 0 && a[p - 1] > l) || (p < n - 1 && a[p + 1] > l)) r--;
if ((p > 0 && a[p - 1] > l) && (p < n - 1 && a[p + 1] > l)) r--;
}
a[p] += d;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[100002];
bool c[100002];
int main() {
int n, m, l;
cin >> n >> m >> l;
int cnt = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 1; i <= n; i++) {
if (a[i] > l) {
c[i] = true;
if (a[i - 1] <= l) {
cnt++;
}
}
}
for (int i = 0; i < m; i++) {
int x;
cin >> x;
if (x == 0) {
cout << cnt << '\n';
} else {
int y, z;
cin >> y >> z;
a[y] += z;
if (a[y] > l && !c[y]) {
c[y] = true;
if (c[y - 1] && c[y + 1]) {
cnt--;
} else if (!c[y - 1] && !c[y + 1]) {
cnt++;
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
int n, m, l, ans, a[maxn];
int main() {
scanf("%d %d %d", &n, &m, &l);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (a[i] > l) ans++;
if (a[i] > l && a[i - 1] > l) ans--;
}
while (m--) {
int op, p, d;
scanf("%d", &op);
if (!op) {
printf("%d\n", ans);
} else {
scanf("%d %d", &p, &d);
if (a[p] > l) ans--;
if (a[p] > l && a[p - 1] > l) ans++;
if (a[p] > l && a[p + 1] > l) ans++;
a[p] = min(l + 1, a[p] + d);
if (a[p] > l) ans++;
if (a[p] > l && a[p - 1] > l) ans--;
if (a[p] > l && a[p + 1] > l) ans--;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long h[100001];
int main() {
int n, m, i, ans = 0;
long long l;
scanf("%d%d%lld", &n, &m, &l);
for (i = 1; i <= n; i++) scanf("%lld", h + i);
bool cur = 0;
for (i = 1; i <= n; i++) {
if (h[i] <= l)
ans += cur, cur = 0;
else
cur = 1;
}
ans += cur;
while (m--) {
int a, b;
scanf("%d", &a);
if (a == 0)
printf("%d\n", ans);
else {
scanf("%d%d", &a, &b);
h[a] += b;
if (h[a] <= l || h[a] - b > l) continue;
int num = 0;
if (h[a - 1] > l) num++;
if (h[a + 1] > l) num++;
ans += 1 - num;
}
}
getchar();
getchar();
}
|
#include <bits/stdc++.h>
using namespace std;
long long num[100010];
int main() {
int n, q, req;
while (~scanf("%d%d%d", &n, &q, &req)) {
bool res[100010];
res[0] = true;
res[n + 1] = true;
for (int i = 1; i <= n; i++) {
scanf("%d", &num[i]);
if (num[i] <= req)
res[i] = true;
else
res[i] = false;
}
int qiu = 0;
bool flag = true;
for (int i = 1; i <= n; i++) {
if (flag == true && res[i] == false) {
qiu++;
flag = false;
}
if (res[i] == true) flag = true;
}
for (int i = 0; i < q; i++) {
int cur;
scanf("%d", &cur);
if (cur == 0) {
cout << qiu << endl;
} else {
int a;
long long b;
scanf("%d%lld", &a, &b);
num[a] += b;
if (res[a] == true && num[a] > req) {
res[a] = false;
if (res[a - 1] == false && res[a + 1] == false) qiu--;
if (res[a - 1] == true && res[a + 1] == true) qiu++;
}
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T gcd(T a, T b) {
return (b == 0) ? a : gcd(b, a % b);
}
const long long N = 1e5 + 10;
long long a[N];
long long dsu[N];
pair<long long, long long> val[N];
long long find(long long x) {
if (x == dsu[x]) return x;
return dsu[x] = find(dsu[x]);
}
long long ncomps;
long long merge(long long a, long long b) {
a = find(a), b = find(b);
if (a == b) return 0;
dsu[a] = b;
--ncomps;
return 1;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, m, l;
cin >> n >> m >> l;
for (long long i = 1; i < n + 1; ++i) cin >> a[i], ncomps += (a[i] > l);
for (long long i = 1; i < n + 1; ++i) dsu[i] = i;
for (long long i = 1; i < n; ++i) {
if (a[i] > l && a[i + 1] > l) {
merge(i, i + 1);
}
}
while (m--) {
long long opt;
cin >> opt;
if (opt) {
long long x, y;
cin >> x >> y;
a[x] += y;
if (a[x] - y > l) {
continue;
} else if (a[x] > l) {
++ncomps;
if (x > 1) {
if (a[x - 1] > l) merge(x - 1, x);
}
if (x < n) {
if (a[x + 1] > l) merge(x, x + 1);
}
}
} else {
cout << ncomps << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1 << 30;
const long long INF = 1e18;
const int mod = 1e9 + 7;
const int maxn = (int)1e5 + 2;
const int mov[4][2] = {-1, 0, 1, 0, 0, 1, 0, -1};
const int Mov[8][2] = {-1, -1, -1, 0, -1, 1, 0, -1, 0, 1, 1, -1, 1, 0, 1, 1};
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
void read(int &x) {
x = 0;
int f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
x *= f;
return;
}
long long a[maxn];
int tot;
int n, m, l;
inline void check(int i) {
if (i == 1) {
if (a[i + 1] <= l) tot++;
} else if (i == n) {
if (a[i - 1] <= l) tot++;
} else {
if (a[i - 1] > l && a[i + 1] > l)
tot--;
else if (a[i - 1] <= l && a[i + 1] <= l)
tot++;
}
}
int main(void) {
std::ios::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
cin >> n >> m >> l;
tot = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (a[i] > l && a[i - 1] <= l) tot++;
}
while (m--) {
bool op;
cin >> op;
if (op) {
int i, add;
cin >> i >> add;
a[i] += add;
if (a[i] - add <= l && a[i] > l) check(i);
} else
cout << max(0, tot) << endl;
}
}
|
#include <bits/stdc++.h>
int main() {
long long n, m, l;
std::cin >> n >> m >> l;
std::vector<long long> a(n);
std::vector<bool> otr(n + 2);
for (int i = 0; i < n; i++) std::cin >> a[i];
long long kol_otr = 0;
for (int i = 0; i < n; i++) {
if (a[i] > l) {
otr[i + 1] = true, kol_otr++;
if (otr[i]) {
kol_otr--;
}
}
}
for (int _ = 0; _ < m; _++) {
long long q;
std::cin >> q;
if (!q) {
std::cout << kol_otr << '\n';
continue;
} else {
long long i, x;
std::cin >> i >> x;
a[i - 1] += x;
if (a[i - 1] - x <= l && a[i - 1] > l) {
kol_otr++;
otr[i] = true;
if (otr[i + 1] && otr[i - 1]) {
otr[i] = true;
kol_otr -= 2;
} else if (otr[i + 1] || otr[i - 1]) {
otr[i] = true;
kol_otr--;
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, i, x[100006], l, m, ans, t, p, q;
int main() {
cin >> n >> m >> l;
for (i = 0; i < n; ++i) cin >> x[i];
for (i = 0; i < n; ++i) {
if (x[i] > l && x[i + 1] <= l) ++ans;
}
while (m--) {
cin >> t;
if (t == 1) {
cin >> p >> q;
if (x[p - 1] > l) {
x[p - 1] += q;
} else if (p == 1) {
if (x[0] + q > l && x[1] <= l) ++ans;
x[0] += q;
} else if (p == n) {
if (x[n - 1] + q > l && x[n - 2] <= l) ++ans;
x[n - 1] += q;
} else {
p--;
if (x[p] + q > l && x[p - 1] <= l && x[p + 1] <= l)
++ans;
else if (x[p] + q > l && x[p - 1] > l && x[p + 1] > l)
--ans;
x[p] += q;
}
} else if (t == 0)
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long hair[100005];
long long groub[100005];
int n, m, l, groubs = 0;
void pre() {
for (int i = 1; i <= n; ++i) {
if (hair[i] > l) {
if (groub[i - 1] > 0 && groub[i + 1] > 0) {
groub[i] = groub[i - 1];
--groubs;
} else if (groub[i - 1] > 0)
groub[i] = groub[i - 1];
else if (groub[i + 1] > 0)
groub[i] = groub[i + 1];
else
groub[i] = ++groubs;
}
}
}
void print() {
cout << "L:: ";
for (int i = 1; i <= n; ++i) cout << groub[i] << ' ';
cout << endl;
}
void update(int p, int d) {
if (hair[p] > l) {
hair[p] += d;
return;
}
hair[p] += d;
if (hair[p] > l) {
if (groub[p - 1] > 0 && groub[p + 1] > 0) {
groub[p] = groub[p - 1];
--groubs;
} else if (groub[p - 1] > 0)
groub[p] = groub[p - 1];
else if (groub[p + 1] > 0)
groub[p] = groub[p + 1];
else
groub[p] = ++groubs;
}
}
int main() {
cin >> n >> m >> l;
for (int i = 1; i <= n; ++i) cin >> hair[i];
pre();
int type, p, d;
while (m--) {
cin >> type;
if (type == 0)
cout << groubs << '\n';
else {
cin >> p >> d;
update(p, d);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int N, M, L;
signed long long A[101010];
int cur = 0;
void solve() {
int i, j, k, l, r, x, y;
string s;
cin >> N >> M >> L;
for (i = 0; i < (N); i++) {
cin >> A[i + 1];
if (A[i + 1] > L) {
if (A[i] <= L) cur++;
}
}
while (M--) {
cin >> i;
if (i == 0) {
cout << cur << endl;
} else {
cin >> x >> y;
if (A[x] <= L && A[x] + y > L) {
if (A[x - 1] <= L && A[x + 1] <= L) cur++;
if (A[x - 1] > L && A[x + 1] > L) cur--;
}
A[x] += y;
}
}
}
int main(int argc, char** argv) {
string s;
int i;
if (argc == 1) ios::sync_with_stdio(false), cin.tie(0);
for (i = 0; i < (argc - 1); i++) s += argv[i + 1], s += '\n';
for (i = 0; i < (s.size()); i++) ungetc(s[s.size() - 1 - i], stdin);
cout.tie(0);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, m, l;
cin >> n >> m >> l;
vector<long long> h(n);
set<long long> st;
set<long long> en;
for (int i = 0; i < n; i++) cin >> h[i];
int s = 0;
for (int i = 0; i < n; i++) {
if (i == n - 1 && h[i] > l) {
st.insert(s);
en.insert(i);
}
if (h[i] <= l) {
if (s != i) {
st.insert(s);
en.insert(i - 1);
}
s = i + 1;
}
}
for (int k = 0; k < m; k++) {
int t, p, d;
cin >> t;
if (t == 0) {
cout << st.size() << endl;
continue;
}
cin >> p >> d;
p--;
if (h[p] > l) continue;
h[p] += d;
if (h[p] <= l) continue;
if (p != 0 && p != n - 1) {
if (h[p - 1] > l && h[p + 1] > l) {
en.erase(p - 1);
st.erase(p + 1);
continue;
}
}
if (p != 0 && h[p - 1] > l) {
en.erase(p - 1);
en.insert(p);
continue;
}
if (p != n - 1 && h[p + 1] > l) {
st.erase(p + 1);
st.insert(p);
continue;
}
st.insert(p);
en.insert(p);
continue;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, q_num;
int max_len;
vector<int64_t> len;
int cur_ans;
bool is_end(int ind) {
if (ind < 0) {
return false;
}
return len[ind] > max_len && len[ind + 1] <= max_len;
}
void input() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cin >> n >> q_num >> max_len;
len.resize(n + 1);
for (int i = 0; i < n; ++i) {
cin >> len[i];
}
len[n] = 0;
cur_ans = 0;
for (int i = 0; i < n; ++i) {
if (is_end(i)) {
++cur_ans;
}
}
}
void update(int ind, int64_t delta) {
if (is_end(ind - 1)) {
--cur_ans;
}
if (is_end(ind)) {
--cur_ans;
}
len[ind] += delta;
if (is_end(ind - 1)) {
++cur_ans;
}
if (is_end(ind)) {
++cur_ans;
}
}
int main() {
input();
for (int i = 0; i < q_num; ++i) {
int q_type;
cin >> q_type;
if (q_type == 0) {
cout << cur_ans << endl;
} else {
int ind, delta_len;
cin >> ind >> delta_len;
update(ind - 1, delta_len);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int n, m, l;
cin >> n >> m >> l;
long long cnt = 0, a[100007], vis[100007] = {0};
for (long long i = 1; i <= (long long)n; ++i) cin >> a[i];
for (long long i = 1; i <= (long long)n; ++i) {
if (a[i] > l) {
if (i == 1 || a[i - 1] <= l) {
cnt++;
}
vis[i] = 1;
}
}
for (long long i = 1; i <= (long long)m; ++i) {
int x;
cin >> x;
if (x == 0)
cout << cnt << endl;
else {
long long p, q;
cin >> p >> q;
a[p] += q;
if (a[p] > l) {
int pre = vis[p - 1];
int nxt = vis[p + 1];
int cur = vis[p];
if (pre && nxt && !cur)
cnt--;
else if ((pre || nxt || cur))
;
else if (!cur)
cnt++;
vis[p] = 1;
}
}
}
}
|
#include <bits/stdc++.h>
enum quiery_type { REQUEST = 0, CHANGE = 1 };
size_t get_size_t(void) {
long long unsigned result;
scanf("%I64u", &result);
return result;
}
size_t count_segments_more_than_target(long long unsigned length[],
size_t hairlines,
unsigned target_length) {
size_t count = 0;
for (size_t i = 0; i < hairlines; i++)
if (length[i] > target_length && (!i || length[i - 1] <= target_length))
count++;
return count;
}
int main(void) {
size_t hairlines = get_size_t(), quieries = get_size_t();
unsigned target_length;
scanf("%u", &target_length);
static unsigned long long length[(size_t)1e5];
for (size_t i = 0; i < hairlines; i++) scanf("%I64u", length + i);
size_t count =
count_segments_more_than_target(length, hairlines, target_length);
for (size_t i = 0; i < quieries; i++) {
unsigned quiery_type;
scanf("%u", &quiery_type);
if (quiery_type == REQUEST)
printf("%u\n", (unsigned)count);
else if (quiery_type == CHANGE) {
size_t idx = get_size_t() - 1;
unsigned growth;
scanf("%u", &growth);
if (length[idx] > target_length) continue;
if ((length[idx] += growth) <= target_length) continue;
if (idx && idx != hairlines - 1 && length[idx - 1] > target_length &&
length[idx + 1] > target_length)
count--;
else if ((!idx || length[idx - 1] <= target_length) &&
(idx == hairlines - 1 || length[idx + 1] <= target_length))
count++;
} else
return 43;
}
return EXIT_SUCCESS;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[100010];
long long res;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, m, l;
cin >> n >> m >> l;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
}
long long x, p, d;
for (long long i = 1; i <= n; i++) {
if (a[i] > l && a[i - 1] <= l) res++;
}
while (m--) {
cin >> x;
if (x == 0)
cout << res << '\n';
else if (x == 1) {
cin >> p >> d;
if (a[p] + d > l && a[p] <= l) {
if (a[p - 1] > l && a[p + 1] > l) {
res--;
} else if (a[p - 1] <= l && a[p + 1] <= l) {
res++;
}
}
a[p] += d;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, m, l, i, c = 0;
cin >> n >> m >> l;
long long int ar[n];
for (i = 0; i < n; i++) {
cin >> ar[i];
}
for (i = 0; i < n; i++) {
if (ar[i] > l) {
if (i == 0)
c++;
else {
if (ar[i - 1] <= l) c++;
}
}
}
while (m--) {
long long int a, b, d;
cin >> a;
if (a == 0)
cout << c << "\n";
else {
cin >> b >> d;
b = b - 1;
if (ar[b] > l) continue;
ar[b] += d;
if (ar[b] <= l) continue;
if (n == 1) {
if (ar[b] > l) c++;
} else {
if (b != 0) {
if (b != n - 1) {
if (ar[b - 1] > l && ar[b + 1] > l) c--;
if (ar[b - 1] <= l && ar[b + 1] <= l) c++;
} else {
if (ar[b - 1] <= l) c++;
}
} else {
{
if (ar[b + 1] <= l) c++;
}
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, l;
void speedup() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
int main() {
speedup();
cin >> n >> m >> l;
vector<long long> a(n);
long long k = 0;
for (int i = 0; i < n; ++i) {
cin >> a[i];
if (i == 0 && a[i] > l) {
++k;
} else if (i > 0 && a[i] > l) {
if (!(a[i - 1] > l)) {
++k;
}
}
}
for (int i = 0; i < m; ++i) {
int x;
cin >> x;
if (x == 1) {
long long p, d;
cin >> p >> d;
--p;
if (a[p] > l) {
a[p] += d;
continue;
} else {
a[p] += d;
if (a[p] > l) {
if (n > 1) {
if (p > 0 && p < n - 1) {
if (a[p - 1] > l && a[p + 1] > l)
--k;
else if (a[p + 1] > l || a[p - 1] > l)
continue;
else
++k;
}
if (p == 0) {
if (a[p + 1] > l)
continue;
else
++k;
}
if (p == n - 1) {
if (a[p - 1] > l)
continue;
else
++k;
}
} else
++k;
}
}
}
if (x == 0) {
cout << k << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
bool vis[100005];
int n, m, t;
long long l, a[100005], ans = 0, x, y;
memset(vis, 0, sizeof vis);
cin >> n >> m >> l;
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (a[i] > l) {
vis[i] = 1;
ans++;
if (vis[i - 1] == 1) ans--;
if (vis[i + 1] == 1) ans--;
}
}
for (int i = 1; i <= m; i++) {
cin >> t;
if (t == 0)
cout << ans << "\n";
else {
cin >> x >> y;
if (!vis[x]) {
a[x] += y;
if (a[x] > l) {
ans++;
vis[x] = 1;
if (vis[x - 1] == 1) ans--;
if (vis[x + 1] == 1) ans--;
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[100001];
int main() {
long long n, m, l;
cin >> n >> m >> l;
long long i;
for (i = 1; i <= n; i++) cin >> a[i];
long long seg = 0;
long long val = 0;
for (i = 1; i <= n; i++) {
if (a[i] > l)
val = 1;
else {
seg += val;
val = 0;
}
if (i == n) seg += val;
}
long long x, p, q;
for (i = 1; i <= m; i++) {
cin >> x;
if (x == 0)
cout << seg << endl;
else {
cin >> p >> q;
if (a[p] <= l && a[p] + q > l) {
if (n == 1)
seg++;
else if (p == 1) {
if (a[p + 1] <= l) seg++;
} else if (p == n) {
if (a[p - 1] <= l) seg++;
} else if (p > 1 && p < n) {
if (a[p + 1] > l && a[p - 1] > l)
seg--;
else if (a[p + 1] <= l && a[p - 1] <= l)
seg++;
}
}
a[p] += q;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long n, m, l;
long long a[200000] = {0};
long res, p, d, dem = 0;
cin >> n >> m >> l;
for (int i = 1; i <= n; i = i + 1) {
cin >> a[i];
if (a[i] > l && a[i - 1] <= l) dem = dem + 1;
}
for (int k = 1; k <= m; k = k + 1) {
cin >> res;
if (res == 1) {
cin >> p >> d;
a[p] = a[p] + d;
if (a[p] - d <= l && a[p] > l) {
if (a[p - 1] > l && a[p + 1] > l) dem = dem - 1;
if (a[p - 1] <= l && a[p + 1] <= l) dem = dem + 1;
}
} else {
cout << dem << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100000;
int fa[N + 100];
int a[N + 100];
inline void init(int n) { memset(fa, -1, sizeof(int) * (n + 2)); }
int Find(int x) {
if (fa[x] < 0) return x;
return fa[x] = Find(fa[x]);
}
void Union(int x, int y) {
int rx = Find(x);
int ry = Find(y);
if (rx == ry) return;
if (fa[rx] > fa[ry]) {
fa[ry] += fa[rx];
fa[rx] = ry;
} else {
fa[rx] += fa[ry];
fa[ry] = rx;
}
}
int main() {
int n, m, l, x, y, order, a1 = 0, cnt = 0, a2 = 0, ans = 0;
scanf("%d%d%d", &n, &m, &l);
init(n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
}
if (a[1] > l) Union(1, n + 1), ++ans;
for (int i = 2; i <= n; ++i) {
if (a[i] > l) {
if (a[i - 1] > l) Union(i, i - 1), --ans;
++ans;
}
}
while (m--) {
scanf("%d", &order);
if (order == 1) {
scanf("%d%d", &x, &y);
if (a[x] <= l) {
a[x] += y;
if (a[x] > l) {
++ans;
if (a[x + 1] > l) --ans;
if (a[x - 1] > l) --ans;
}
}
} else {
printf("%d\n", ans);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, l, t;
long long p, d;
vector<long long> as;
int main() {
cin >> n >> m >> l;
as = vector<long long>(n, 0);
for (long long i = 0; i < n; i++) {
cin >> as[i];
}
long long res = 0;
long long i = 0, j = 0;
while (i < n && j < n) {
while (i < n && as[i] <= l) i++;
if (i < n) res++;
while (i < n && as[i] > l) i++;
}
for (long long i = 0; i < m; i++) {
cin >> t;
if (t == 0) {
cout << res << endl;
} else {
cin >> p >> d;
p--;
if (as[p] > l || as[p] + d <= l) {
as[p] += d;
} else if (as[p] <= l && as[p] + d > l) {
long long lf = 0, rf = 0;
if (p - 1 >= 0 && as[p - 1] > l) lf = 1;
if (p + 1 < n && as[p + 1] > l) rf = 1;
if (lf == 1 && rf == 1) res--;
if (lf == 0 && rf == 0) res++;
as[p] += d;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, l;
cin >> n >> m >> l;
vector<int> a(n + 2, 0);
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
a[0] = 0;
a[n + 1] = 0;
int count = 0;
int start = 0;
for (int i = 1; i <= n; i++) {
if (a[i] > l && start == 0) {
start = 1;
count++;
}
if (a[i] <= l && start == 1) {
start = 0;
}
}
for (int i = 0; i < m; i++) {
int t;
cin >> t;
if (t == 0) {
cout << count << endl;
} else {
int p, d;
cin >> p >> d;
if (a[p] <= l) {
a[p] += d;
if (a[p] > l) {
if (a[p - 1] > l && a[p + 1] > l) count--;
if (a[p - 1] <= l && a[p + 1] <= l) count++;
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000 + 5;
int n, m, l, a[maxn];
int main() {
scanf("%d%d%d", &n, &m, &l);
for (int i = 1; i <= n; i++) scanf("%d", a + i);
int ans = 0, cnt = 0;
for (int i = 1; i <= n; i++) {
if (a[i] > l)
cnt++;
else {
if (cnt) ans++;
cnt = 0;
}
}
if (cnt) ans++;
int op, p, d;
while (m--) {
scanf("%d", &op);
if (op == 0) {
printf("%d\n", ans);
} else if (op == 1) {
scanf("%d%d", &p, &d);
if (a[p] <= l) {
a[p] += d;
if (a[p] <= l) continue;
if (p - 1 >= 1 && p + 1 <= n && a[p + 1] > l && a[p - 1] > l) {
ans--;
} else if (p - 1 >= 1 && p + 1 <= n && a[p + 1] <= l && a[p - 1] <= l) {
ans++;
}
if (p == 1 && p + 1 <= n && a[p + 1] <= l) {
ans++;
}
if (p == n && p - 1 >= 1 && a[p - 1] <= l) {
ans++;
}
if (n == 1) ans++;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
const long long inf = std::numeric_limits<long long>::max();
const long long mod = 1e9 + 7;
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
long long a[100100], l;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m >> l;
for (int i = 0; i < n; i++) cin >> a[i];
int ted = 0;
for (int i = 0; i < n; i++) {
if (a[i] > l) ted++;
while (a[i] > l) i++;
}
for (int i = 0; i < m; i++) {
int c;
cin >> c;
if (c == 0) {
cout << ted << '\n';
} else {
int p, x;
cin >> p >> x;
p--;
if (a[p] > l) continue;
a[p] += x;
if (a[p] > l) {
if (p > 0 && p < n - 1 && a[p - 1] > l && a[p + 1] > l)
ted--;
else if (p > 0 && a[p - 1] > l)
continue;
else if (p < n - 1 && a[p + 1] > l)
continue;
else
ted++;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int n, m, l, hair[N];
int type, pos, d;
int ans;
int main() {
scanf("%d %d %d", &n, &m, &l);
for (int i = 1; i <= n; i++) {
scanf("%d", &hair[i]);
if (hair[i] > l) {
ans++;
if (hair[i - 1] > l) {
ans--;
}
}
}
for (int i = 1; i <= m; i++) {
scanf("%d", &type);
if (type == 0) {
printf("%d\n", ans);
} else {
scanf("%d %d", &pos, &d);
if (hair[pos] > l) continue;
hair[pos] += d;
if (hair[pos] > l) {
ans++;
if (hair[pos - 1] > l) {
ans--;
}
if (hair[pos + 1] > l) {
ans--;
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
double PI = 3.141592653589793;
const double EPS = 1e-9;
const int N = 1e6 + 5;
const long long mod = 1e9 + 7;
const int oo = 1e9;
int dx[] = {0, 0, 1, -1, 1, -1, 1, -1};
int dy[] = {1, -1, 0, 0, -1, 1, 1, -1};
int n, m;
long long l;
long long t[N];
int main() {
scanf("%d%d%lld", &n, &m, &l);
for (int i = 1; i <= n; i++) {
scanf("%lld", &t[i]);
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (t[i] <= l) continue;
ans++;
while (i <= n && t[i] > l) i++;
}
while (m--) {
int type;
scanf("%d", &type);
if (type == 0) {
printf("%d\n", ans);
} else {
int a;
long long b;
scanf("%d%lld", &a, &b);
if (t[a] > l || t[a] + b <= l) {
t[a] += b;
continue;
}
t[a] += b;
if (t[a - 1] > l && t[a + 1] > l) {
ans--;
} else if (t[a - 1] <= l && t[a + 1] <= l)
ans++;
}
}
}
|
#include <bits/stdc++.h>
const int MAXN = 1e5 + 10;
long long a[MAXN];
int main() {
long long n, m, l;
while (scanf("%lld%lld%lld", &n, &m, &l) != EOF) {
int ans = 0;
memset(a, 0, sizeof(a));
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
for (int i = 1; i <= n; i++) {
if (a[i] > l) {
while (i <= n && a[i] > l) i++;
ans++;
}
}
while (m--) {
int x, b, c;
scanf("%d", &x);
if (x == 0)
printf("%d\n", ans);
else {
scanf("%d%d", &b, &c);
if (a[b] <= l && a[b] + c > l) {
ans++;
if (a[b - 1] > l) ans--;
if (a[b + 1] > l) ans--;
}
a[b] += c;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 998244353;
const int dy[4] = {-1, 0, 1, 0};
const int dx[4] = {0, 1, 0, -1};
int N, M, L;
long long arr[100000];
int cnt;
int main() {
scanf("%d%d%d", &N, &M, &L);
for (int i = 0; i < N; ++i) {
long long t;
scanf("%lld", &t);
arr[i] += t;
if (arr[i] - t <= L && arr[i] > L) {
++cnt;
if (i != 0 && arr[i - 1] > L) --cnt;
if (i != N - 1 && arr[i + 1] > L) --cnt;
}
}
for (int i = 0; i < M; ++i) {
int a, b;
long long t;
scanf("%d", &a);
if (a == 0) {
printf("%d\n", cnt);
} else {
scanf("%d%lld", &b, &t);
--b;
arr[b] += t;
if (arr[b] - t <= L && arr[b] > L) {
++cnt;
if (b != 0 && arr[b - 1] > L) --cnt;
if (b != N - 1 && arr[b + 1] > L) --cnt;
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, l;
cin >> n >> m >> l;
long long int a[n], ans = 0;
for (int i = 0; i < n; i++) cin >> a[i];
int flag = 0;
for (int i = 0; i < n; i++) {
if (a[i] > l) {
if (flag == 0) {
ans++;
flag = 1;
}
} else
flag = 0;
}
while (m--) {
long long int x;
cin >> x;
if (x == 0) {
cout << ans << endl;
} else {
int j, d;
cin >> j >> d;
j--;
if (a[j] > l) {
a[j] += d;
continue;
}
a[j] += d;
if (a[j] > l) {
if (j == 0) {
if (a[j + 1] <= l) ans++;
if (n == 1) ans++;
continue;
}
if (j == n - 1) {
if (a[j - 1] <= l) ans++;
continue;
}
if (a[j - 1] <= l && a[j + 1] <= l)
ans++;
else if (a[j - 1] > l && a[j + 1] > l)
ans--;
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
long long l;
cin >> n >> m >> l;
vector<long long> len(n);
for (int i = 0; i < n; i++) cin >> len[i];
int seg = 0;
if (len[0] > l) seg++;
for (int i = 1; i < n; i++) {
if (len[i] > l && len[i - 1] <= l) seg++;
}
int t, p;
long long d;
for (int i = 0; i < m; i++) {
cin >> t;
if (t) {
cin >> p >> d;
p--;
if (len[p] <= l) {
if (len[p] + d > l) {
if (p == 0) {
if (len[p + 1] <= l) seg++;
} else if (p == n - 1) {
if (len[p - 1] <= l) seg++;
} else {
if (len[p - 1] > l && len[p + 1] > l)
seg--;
else if (len[p - 1] <= l && len[p + 1] <= l)
seg++;
}
}
}
len[p] += d;
} else {
cout << seg << "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
long long l;
cin >> n >> m >> l;
long hair[n];
bool lc = false;
long cnt = 0;
for (long i = 0; i < n; i++) {
cin >> hair[i];
if (hair[i] > l && !lc) {
cnt += 1;
lc = true;
} else if (hair[i] <= l && lc) {
lc = false;
}
}
for (long i = 0; i < m; i++) {
int k;
cin >> k;
if (k == 0) {
cout << cnt << endl;
} else {
long long p, d;
cin >> p >> d;
p--;
if (hair[p] <= l) {
if (hair[p] + d > l) {
hair[p] = l + 1;
} else {
hair[p] += d;
}
if (p - 1 == -1 && p + 1 == n) {
if (hair[p] > l) {
cnt++;
}
} else if (p - 1 == -1) {
if (hair[p + 1] <= l && hair[p] > l) {
cnt++;
}
} else if (p + 1 == n) {
if (hair[p - 1] <= l && hair[p] > l) {
cnt++;
}
} else {
if (hair[p + 1] > l && hair[p] > l && hair[p - 1] > l) {
cnt--;
} else if (hair[p] > l && hair[p - 1] <= l && hair[p + 1] <= l) {
cnt++;
}
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[1000005];
int main() {
long long l;
int n, m, lab, ans = 0;
scanf("%d%d%lld", &n, &m, &l);
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
a[0] = 0;
for (int i = 1; i <= n; i++) {
if (a[i] > l && a[i - 1] <= l) ans++;
}
for (int i1 = 1; i1 <= m; i1++) {
scanf("%d", &lab);
if (lab == 0)
printf("%d\n", ans);
else {
int v1;
long long v2;
scanf("%d%lld", &v1, &v2);
if (a[v1] <= l && a[v1] + v2 > l) {
ans++;
if (v1 > 1) {
if (a[v1 - 1] > l) ans--;
}
if (v1 != n) {
if (a[v1 + 1] > l) ans--;
}
}
a[v1] += v2;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m;
long long l;
cin >> n >> m >> l;
int ans = 0;
vector<long long> a(n + 7);
for (int i = 1; i <= n; ++i) {
cin >> a[i];
if (a[i] > l) {
if (a[i - 1] <= l) {
ans++;
}
}
}
for (int i = 1; i <= m; ++i) {
int op, p, d;
cin >> op;
if (op == 1) {
cin >> p >> d;
if (a[p] <= l && a[p] + d > l) {
ans++;
if (a[p - 1] > l) {
ans--;
}
if (a[p + 1] > l) {
ans--;
}
}
a[p] += d;
} else {
cout << ans << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[100005] = {0};
int b[100005] = {0};
int c[100005] = {0};
int main() {
int n, m, l;
cin >> n >> m >> l;
for (int i = 1; i <= n; ++i) cin >> a[i];
a[0] = l + 1;
a[n + 1] = l + 1;
int j = 1;
bool b;
int sum = 0;
while (j <= n) {
while (j <= n && a[j] <= l) j++;
if (j <= n) sum++;
while (j <= n && a[j] > l) j++;
}
for (int i = 0; i < m; ++i) {
int temp;
cin >> temp;
if (temp == 1) {
int p, v;
cin >> p >> v;
a[p] += v;
if (a[p] > l && a[p] - v <= l) {
if ((p - 1 > 0 && a[p - 1] > l) && (p + 1 <= n && a[p + 1] > l))
sum--;
else if ((p - 1 <= 0 || a[p - 1] <= l) && (p + 1 > n || a[p + 1] <= l))
sum++;
}
} else {
cout << sum << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void fast() {
std::ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
using namespace std;
int main() {
long long n, m, l, i, j;
cin >> n >> m >> l;
long long a[n];
for (i = 0; i < n; i++) {
cin >> a[i];
}
long long t, siz;
long long p, d, ind;
vector<pair<long long, long long>> vc;
map<long long, long long> mk;
for (j = 0; j < n; j++) {
if (a[j] > l) {
ind = j;
while (j <= n - 1 && a[j] > l) {
j++;
}
j--;
for (i = ind; i <= j; i++) {
mk[i] = 1;
}
vc.push_back(make_pair(ind, j));
} else
continue;
}
siz = vc.size();
for (i = 0; i < m; i++) {
cin >> t;
if (t == 0) {
cout << siz << endl;
} else {
cin >> p >> d;
a[p - 1] += d;
if (a[p - 1] > l) {
if (mk[p - 1] == 1) {
mk[p - 1] = 1;
} else if ((p - 1) >= 1 && mk[p - 2] == 1 && (p - 1) <= n - 2 &&
mk[p] == 1) {
mk[p - 1] = 1;
siz--;
} else if ((p - 1) >= 1 && (p - 1) <= n - 2 && (mk[p] == 1) ||
(mk[p - 2] == 1)) {
mk[p - 1] = 1;
} else if ((p - 1) == 0 && p <= n - 1 && mk[p] == 1) {
mk[p - 1] = 1;
} else if ((p - 1) == n - 1 && p - 2 >= 0 && mk[p - 2] == 1) {
mk[p - 1] = 1;
} else {
vc.push_back(make_pair(p - 1, p - 1));
siz++;
mk[p - 1] = 1;
}
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long arr[100002];
int main() {
int n, m, l;
cin >> n >> m >> l;
for (int i = 1; i <= n; i++) cin >> arr[i];
int cnt = 0;
for (int i = 1; i <= n; i++) {
if (arr[i] > l) {
while (i <= n && arr[i] > l) i++;
cnt++;
}
}
while (m--) {
int cmd;
cin >> cmd;
if (cmd == 0) {
cout << cnt << '\n';
} else {
int p, d;
cin >> p >> d;
if (arr[p] <= l && arr[p] + d > l) {
if (arr[p - 1] > l && arr[p + 1] > l)
cnt--;
else if (arr[p - 1] <= l && arr[p + 1] <= l)
cnt++;
}
arr[p] += d;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, l;
cin >> n >> m >> l;
int a[n + 2];
for (long long int i = 1; i < n + 1; i++) cin >> a[i];
a[0] = a[n + 1] = -1;
int cmd, x, y;
int ans = 0;
for (long long int i = 1; i < n + 1; i++) {
if (a[i] > l && a[i - 1] <= l) ans++;
}
for (long long int i = 0; i < m; i++) {
cin >> cmd;
if (cmd) {
cin >> x >> y;
if (a[x] > l)
continue;
else if (a[x] + y <= l)
a[x] += y;
else {
if (a[x - 1] > l && a[x + 1] > l)
ans--;
else if (a[x - 1] <= l && a[x + 1] <= l)
ans++;
a[x] += y;
}
} else {
cout << ans << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
const int inf = 1e9 + 7;
vector<int> ans;
int a[(int)1e5 + 5];
bool used[(int)1e5 + 5];
int n, t, l, cnt;
int main() {
cin >> n >> t >> l;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) {
if (a[i] > l) {
while (a[i] > l) used[i] = 1, i++;
i--;
cnt++;
}
}
while (t--) {
int tp, id, x;
cin >> tp;
if (tp == 0) {
ans.push_back(cnt);
} else {
cin >> id >> x;
a[id] += x;
if (a[id] <= l || used[id]) continue;
used[id] = true;
if (!used[id + 1] && !used[id - 1]) cnt++;
if (used[id + 1] && used[id - 1]) cnt--;
}
}
for (auto c : ans) cout << c << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, l, q, p, d, nr, ok, r, a[100005], tt[100005];
bool v[100005];
void init(long long n, long long a[], long long x) {
for (int i = 1; i <= n; i++) {
if (a[i] > x) {
tt[i] = i;
v[i] = 1;
nr++;
} else
tt[i] = 0;
}
}
long long gasit(long long x) {
long long r = x, aux;
while (tt[r] != r) r = tt[r];
while (tt[x] != r) {
aux = tt[x];
tt[x] = r;
x = aux;
}
return r;
}
void uneste(long long x, long long y) {
long long rx = gasit(x), ry = gasit(y);
if (rx != ry) tt[rx] = ry;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> l;
for (int i = 1; i <= n; i++) cin >> a[i];
init(n, a, l);
for (int i = 1; i < n; i++) {
if (a[i] > l) {
if (a[i + 1] > l) {
uneste(i + 1, i);
r = gasit(i + 1);
v[r] = 0;
nr--;
}
}
}
for (int i = 1; i <= m; i++) {
cin >> q;
if (q == 1) {
cin >> p >> d;
a[p] += d;
r = gasit(p);
if (r == 0 && a[p] > l) {
tt[p] = p;
if ((p < n && a[p + 1] > l) && (p > 1 && a[p - 1] > l)) {
r = gasit(p);
v[r] = 0;
nr--;
uneste(p, p + 1);
uneste(p, p - 1);
} else {
if (p < n && a[p + 1] > l)
uneste(p, p + 1);
else if (p > 1 && a[p - 1] > l)
uneste(p, p - 1);
else {
tt[p] = p;
v[p] = 1;
nr++;
}
}
}
} else
cout << nr << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[100999];
int b[100999];
int main() {
long long i, n, m, l;
cin >> n >> m >> l;
int tot = 0;
for (i = 1; i <= n; i++) {
cin >> a[i];
if (a[i] > l) b[i] = 1;
if (b[i] == 1 && b[i - 1] == 0) tot++;
}
long long p, x, tip;
while (m--) {
cin >> tip;
if (tip == 0)
cout << tot << '\n';
else {
cin >> p >> x;
if (a[p] <= l && a[p] + x > l) {
b[p] = 1;
if (b[p - 1] == 1 && b[p + 1] == 1)
tot--;
else if (b[p - 1] == 0 && b[p + 1] == 0)
tot++;
}
a[p] += x;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 100000;
long long a[MX + 2];
int main() {
int n, m, l;
ignore = scanf("%d %d %d", &n, &m, &l);
for (int i = 1; i <= n; i++) ignore = scanf("%lld", a + i);
int f = 0;
for (int i = 1; i <= n + 1; i++)
if ((a[i - 1] > l) != (a[i] > l)) f++;
while (m--) {
int x;
ignore = scanf("%d", &x);
if (x == 0)
printf("%d\n", f / 2);
else {
int p, d;
ignore = scanf("%d %d", &p, &d);
if ((a[p - 1] > l) != (a[p] > l)) f--;
if ((a[p + 1] > l) != (a[p] > l)) f--;
a[p] += d;
if ((a[p - 1] > l) != (a[p] > l)) f++;
if ((a[p + 1] > l) != (a[p] > l)) f++;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007, N = 1e5 + 5;
int a[N], p[N], r[N], vis[N];
void pre() {
for (int i = 0; i < N; i++) p[i] = i, r[i] = 0;
}
int f(int v) { return (v == p[v] ? v : p[v] = f(p[v])); }
void unite(int u, int v) {
u = f(u), v = f(v);
if (u == v) return;
if (r[u] > r[v])
p[v] = u;
else
r[v]++, p[u] = v;
}
int main() {
pre();
int n, m, l, ans = 0;
cin >> n >> m >> l;
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (a[i] > l) r[i]++;
if (a[i] > l && a[i - 1] > l) unite(i, i - 1);
}
for (int i = 1; i <= n; i++) {
if (!vis[f(i)] && r[f(i)] > 0) vis[f(i)] = 1, ans++;
}
while (m--) {
int x, d, p;
cin >> x;
if (!x) {
cout << ans << "\n";
continue;
}
cin >> p >> d;
a[p] += d;
if (a[p] <= l || vis[f(p)]) continue;
if (r[f(p - 1)] > 0 && r[f(p + 1)] > 0) {
unite(p, p + 1);
unite(p, p - 1);
vis[f(p)] = 1;
ans--;
} else if (r[f(p - 1)] > 0)
unite(p, p - 1);
else if (r[f(p + 1)] > 0)
unite(p, p + 1);
else if (!vis[p])
vis[p] = 1, ans++, r[p]++;
else
r[p]++;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
const int MAXN = 1e6 + 5, inf = 1e9;
const ll INF = 1e18;
const ld PI = 3.1415926535897932384626433832795;
int cnt[MAXN];
ll dp[MAXN], tab[MAXN];
bool vis[MAXN], used[MAXN];
vector<int> G[MAXN];
vector<ll> V;
set<ll> S;
map<ll, int> M;
stack<ll> St;
queue<ll> Q;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout << setprecision(13) << fixed;
int n, m, l;
cin >> n >> m >> l;
bool ok = 0;
int res = 0;
for (int i = 1; i <= n; i++) {
cin >> tab[i];
if (tab[i] > l) {
if (ok) continue;
ok = 1;
res++;
} else
ok = 0;
}
for (int i = 0; i < m; i++) {
int co;
cin >> co;
if (co == 0) {
cout << res << "\n";
} else {
int p, d;
cin >> p >> d;
if (tab[p] > l) continue;
tab[p] += d;
if (tab[p] <= l) continue;
if (tab[p - 1] > l and tab[p + 1] > l)
res--;
else if (tab[p - 1] <= l and tab[p + 1] <= l)
res++;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[200005];
map<int, int> mp;
vector<int> ver;
long long sum;
int main() {
scanf("%d", &n);
for (register int i = 1; i <= n; ++i)
scanf("%d", &a[i]), sum += a[i], mp[a[i]]++;
long long t;
for (register int i = 1; i <= n; ++i) {
t = sum - a[i];
if (t & 1) continue;
t >>= 1;
if (t > 0 && t <= 1000000) {
if (t != a[i] && mp[t] >= 1 || t == a[i] && mp[t] >= 2) {
ver.push_back(i);
}
}
}
printf("%d\n", ver.size());
for (int i : ver) printf("%d ", i);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; }
const int INF = 1 << 29;
inline int two(int n) { return 1 << n; }
inline int test(int n, int b) { return (n >> b) & 1; }
inline void set_bit(int& n, int b) { n |= two(b); }
inline void unset_bit(int& n, int b) { n &= ~two(b); }
inline int last_bit(int n) { return n & (-n); }
inline int ones(int n) {
int res = 0;
while (n && ++res) n -= n & (-n);
return res;
}
template <class T>
void chmax(T& a, const T& b) {
a = max(a, b);
}
template <class T>
void chmin(T& a, const T& b) {
a = min(a, b);
}
int main() {
int n;
cin >> n;
vector<int> a(n);
vector<int> b;
set<long long> s;
long long lsum = 0;
map<int, int> c;
for (int i = 0; i < (n); i++) {
cin >> a[i];
s.insert(a[i]);
c[a[i]]++;
lsum += a[i];
}
for (int i = 0; i < (n); i++) {
long long llsum = lsum;
llsum = llsum - a[i];
if (llsum % 2 == 0) {
long long k = llsum / 2;
if (s.find(k) != s.end() && (k != a[i] || c[a[i]] > 1))
b.push_back(i + 1);
}
}
cout << b.size() << endl;
for (int i = 0; i < (b.size()); i++) cout << b[i] << " ";
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.