text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
int n, d, S;
vector<pair<int, int> > La, Lb, Lc;
vector<int> tmp;
long long sum[100000 + 5];
pair<int, int> solve(long long cnt, int ans1, int ans2) {
if (cnt >= Lb.size())
ans1 += Lb.size();
else {
ans1 += cnt;
int ll = 0, rr = Lb.size() - cnt;
while (ll < rr) {
int mid = (ll + rr + 1) / 2;
if (sum[mid] + ans2 <= S)
ll = mid;
else
rr = mid - 1;
}
ans1 += ll;
ans2 += sum[ll];
}
return pair<int, int>(ans1, ans2);
}
int main() {
scanf("%d %d %d", &n, &d, &S);
for (int i = 0, a, b, c; i < n; i++) {
scanf("%d %d %d", &a, &b, &c);
if (c >= d) {
if (a > 0)
La.push_back(pair<int, int>(b, a));
else
Lb.push_back(pair<int, int>(b, a));
tmp.push_back(b);
} else
Lc.push_back(pair<int, int>(a, b));
}
sort(tmp.begin(), tmp.end());
int tmp1 = 0, tmp2 = 0;
for (int i = 0; i < tmp.size() && tmp2 + tmp[i] <= S; i++) {
tmp1++;
tmp2 += tmp[i];
}
sort(La.begin(), La.end());
sort(Lb.begin(), Lb.end());
for (int k = 0; k < int(Lb.size()); k++) sum[k + 1] = sum[k] + Lb[k].first;
int ans1 = tmp1, ans2 = tmp2;
long long SUM = 0;
for (int k = 0; k < int(La.size()); k++) SUM += La[k].second - 1;
long long cv1 = 0, cv2 = 0, cv3 = 0;
for (int k = 0; k < int(Lc.size()); k++) {
if (Lc[k].first > 0) {
cv1++;
cv2 += Lc[k].first - 1;
} else {
cv3++;
}
}
long long tv2 = 0;
for (int k = 0; k < int(La.size()) && tv2 + La[k].first <= S; k++) {
tv2 += La[k].first;
SUM++;
long long cnt = SUM + cv2, cc = La.size() + cv1;
if (cnt >= cv3) {
cc += cv3;
cnt -= cv3;
} else {
cc += cnt;
cnt = 0;
}
pair<int, int> ans = solve(cnt, cc, tv2);
if (ans.first > ans1 || (ans.first == ans1 && ans.second < ans2)) {
ans1 = ans.first;
ans2 = ans.second;
}
}
printf("%d %d\n", ans1, ans2);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int kNMax = 100010;
int cnt1, cnt2, cnt3, cnt4;
int arr3[kNMax], arr4[kNMax];
int c[kNMax], f[kNMax], l[kNMax];
int n, d, S;
bool cmpF(int i, int j) { return f[i] < f[j]; }
pair<int, int> work(int S, int lim) {
pair<int, int> ret = make_pair(0, 0);
for (int i = 0; ret.first < lim && i < cnt3; i++) {
if (S < f[arr3[i]]) break;
S -= f[arr3[i]];
ret.second += f[arr3[i]];
ret.first++;
}
return ret;
}
int main() {
scanf("%d%d%d", &n, &d, &S);
for (int i = 0; i < n; i++) {
scanf("%d%d%d", &c[i], &f[i], &l[i]);
if (c[i] == 0 && l[i] < d) cnt1++;
if (c[i] > 0 && l[i] < d) cnt2++;
if (c[i] == 0 && l[i] >= d) arr3[cnt3++] = i;
if (c[i] > 0 && l[i] >= d) arr4[cnt4++] = i;
}
sort(arr3, arr3 + cnt3, cmpF);
sort(arr4, arr4 + cnt4, cmpF);
pair<int, int> tmpp = work(S, cnt3);
if (!(cnt4 == 0 || f[arr4[0]] > S)) {
int best = arr4[0];
S -= f[best];
long long sumC = 0;
int goodCnt = 0;
for (int i = 0; i < n; i++)
if (c[i] > 0) {
goodCnt++;
sumC += c[i];
}
if (cnt4 - 1 <= cnt1) {
for (int i = 1; i < cnt4; i++) arr3[cnt3++] = arr4[i];
cnt1 -= cnt4 - 1;
} else {
for (int i = 1; i <= cnt1; i++) arr3[cnt3++] = arr4[i];
sort(arr3, arr3 + cnt3, cmpF);
for (int i = cnt1 + 1, j = cnt3 - 1; j >= 0 && i < cnt4; i++, j--) {
f[arr3[j]] = min(f[arr3[j]], f[arr4[i]]);
}
sort(arr3, arr3 + cnt3, cmpF);
cnt1 = 0;
}
int more = (int)min((long long)cnt1 + cnt3, sumC - goodCnt + 1);
pair<int, int> tmp;
if (more <= cnt1)
tmp = work(S, cnt3);
else
tmp = work(S, cnt3 - (more - cnt1));
tmp.first += more + goodCnt;
tmp.second += f[best];
if (tmp.first > tmpp.first ||
(tmp.first == tmpp.first && tmp.second < tmpp.second))
tmpp = tmp;
}
printf("%d %d\n", tmpp.first, tmpp.second);
}
|
#include <bits/stdc++.h>
using namespace std;
struct Node {
long long c, f, l;
bool operator<(const Node& nd) const { return f < nd.f; }
};
Node Empty[100010];
Node NonE[100010];
int ect, nct;
int n;
long long D, S;
void runEmpty(long long& res, long long& ans) {
sort(Empty, Empty + ect);
res = 0;
ans = 0;
for (int i = 0; i < ect; ++i) {
if (Empty[i].l >= D) {
if (res + Empty[i].f <= S) {
res += Empty[i].f;
ans++;
} else {
break;
}
}
}
}
int main() {
scanf("%d%I64d%I64d", &n, &D, &S);
ect = nct = 0;
long long sum = 0;
bool hasone = false;
for (int i = 0; i < n; ++i) {
long long c, f, l;
scanf("%I64d%I64d%I64d", &c, &f, &l);
if (c) {
NonE[nct].c = c;
NonE[nct].f = f;
NonE[nct].l = l;
nct++;
sum += c;
if (l >= D && f <= S) hasone = true;
} else {
Empty[ect].c = c;
Empty[ect].f = f;
Empty[ect].l = l;
ect++;
}
}
if (hasone) {
sum -= nct - 1;
long long left = ect - sum > 0 ? ect - sum : 0;
sort(NonE, NonE + nct);
sort(Empty, Empty + ect);
long long res = 0;
int pn, pe;
pn = pe = 0;
while (pn < nct) {
if (NonE[pn].l < D)
pn++;
else
break;
}
res = NonE[pn++].f;
NonE[nct].f = 1LL << 61;
Empty[ect].f = 1LL << 61;
while (left) {
while (pn < nct) {
if (NonE[pn].l < D)
pn++;
else
break;
}
while (pe < ect) {
if (Empty[pe].l < D)
pe++;
else
break;
}
if (NonE[pn].f < Empty[pe].f) {
if (res + NonE[pn].f <= S) {
left--;
res += NonE[pn].f;
pn++;
} else {
break;
}
} else {
if (res + Empty[pe].f <= S) {
left--;
res += Empty[pe].f;
pe++;
} else {
break;
}
}
}
long long a = n - left;
long long b = res;
long long c, d;
runEmpty(d, c);
if (a < c || (a == c && b > d)) {
a = c;
b = d;
}
printf("%I64d %I64d\n", a, b);
} else {
long long res, ans;
runEmpty(res, ans);
printf("%I64d %I64d\n", ans, res);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int carry_minati = 1e5 + 100;
int n, d, f, c[carry_minati], ff[carry_minati], dd[carry_minati], res = 0,
val = 0;
vector<int> g, a, b;
void tensor_flow() {
g.clear();
for (int i = 0; i < n; i++)
if (c[i] == 0 and dd[i] >= d) g.push_back(ff[i]);
sort(g.begin(), g.end());
int ans = 0;
for (int i = 0; i < g.size(); i++) {
ans += g[i];
if (ans > f) break;
if (i + 1 > res or (i + 1 == res and ans < val)) {
res = i + 1;
val = ans;
}
}
return;
}
void amit_bhadana() {
bool can = 0;
for (int i = 0; i < n; i++)
if (c[i] and ff[i] <= f and dd[i] >= d) can = 1;
if (!can) return;
int hi = 0;
for (int i = 0; i < n; i++) {
hi += c[i];
hi = min(hi, n);
}
for (int i = 0; i < n; i++)
if (dd[i] >= d)
if (c[i])
a.push_back(ff[i]);
else
b.push_back(ff[i]);
sort(a.begin(), a.end());
sort(b.begin(), b.end());
int answer = a[0], i = 1, j = 0;
while (1) {
int cnt = min(i + j + hi, n);
if (cnt > res or (cnt == res and answer < val)) {
res = cnt;
val = answer;
}
if (i == a.size() and j == b.size()) break;
if (i < a.size() and (j == b.size() or a[i] < b[j])) {
answer += a[i];
i++;
} else {
answer += b[j];
j++;
}
if (answer > f) break;
}
}
int main() {
cin >> n >> d >> f;
for (int i = 0; i < n; i++) cin >> c[i] >> ff[i] >> dd[i];
tensor_flow();
amit_bhadana();
cout << res << " " << val;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
int deg = 0, total = 0;
vector<pair<int, int> > data;
int n, d, s;
pair<int, int> go(int s) {
int x, y;
int ret = 0;
int now = 0;
for (typeof(data.begin()) it = data.begin(); it != data.end(); it++) {
if (it->first + now <= s) {
now += it->first;
++ret;
} else
break;
}
x = ret;
y = -now;
int buy = 0;
while (buy < data.size() && data[buy].second == 0) ++buy;
if (buy == data.size() || data[buy].first > s) return make_pair(x, y);
pair<int, int> ans = make_pair(x, y);
now = data[buy].first;
ans = max(ans, make_pair(min(n, deg + 1), -now));
int afford = 0;
for (int i = 0; i < data.size(); i++)
if (i != buy) {
if (now + data[i].first <= s)
++afford;
else
break;
now += data[i].first;
ans = max(ans, make_pair(min(n, deg + 1 + afford), -now));
}
return ans;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> d >> s;
for (int i = 0; i < n; i++) {
int c, f, l;
cin >> c >> f >> l;
deg += c;
deg = min(deg, n);
if (l < d) {
++total;
} else
data.push_back(make_pair(f, c));
}
sort(data.begin(), data.end());
pair<int, int> out = go(s);
cout << out.first << " " << -out.second << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void swap(int &x, int &y) {
int t = x;
x = y;
y = t;
}
int max(int x, int y) { return x > y ? x : y; }
int min(int x, int y) { return x < y ? x : y; }
const int inf = 0x3F3F3F3F;
const int M = 100000 + 5;
int T, cas;
int n, m;
long long a, sum[M << 2][5][11], s[5][M];
long long cf[5] = {2, 4, 6, 8, 10};
void preSof() {
for (long long z = 2; z <= 6; z++) {
long long md = (z - 1) << 1;
for (long long i = 1; i < 13; i++) {
long long j = i % md;
if (!j)
s[z - 2][i - 1] = 2;
else if (j <= z)
s[z - 2][i - 1] = j;
else
s[z - 2][i - 1] = (z << 1) - j;
}
}
return;
}
void pushUp(int llen, int rt) {
for (long long z = 2; z <= 6; z++)
for (long long i = 0; i < cf[z - 2]; i++)
sum[rt][z - 2][i] = sum[rt << 1][z - 2][i] +
sum[rt << 1 | 1][z - 2][(i + llen) % cf[z - 2]];
}
void build(int l, int r, int rt) {
if (l == r) {
scanf("%I64d", &a);
for (long long z = 2; z <= 6; z++)
for (long long i = 0; i < cf[z - 2]; i++)
sum[rt][z - 2][i] = a * s[z - 2][i];
return;
}
int mid = l + r >> 1;
build(l, mid, rt << 1), build(mid + 1, r, rt << 1 | 1);
pushUp(mid - l + 1, rt);
}
void update(int l, int r, int rt, int p, long long c) {
if (l == r) {
for (long long z = 2; z <= 6; z++)
for (long long i = 0; i < cf[z - 2]; i++)
sum[rt][z - 2][i] = c * s[z - 2][i];
return;
}
int mid = l + r >> 1;
if (p <= mid)
update(l, mid, rt << 1, p, c);
else
update(mid + 1, r, rt << 1 | 1, p, c);
pushUp(mid - l + 1, rt);
}
long long query(int l, int r, int rt, int L, int R, int z, int i) {
if (L == l && r == R) {
return sum[rt][z][i];
}
int mid = l + r >> 1;
if (R <= mid) return query(l, mid, rt << 1, L, R, z, i);
if (mid < L) return query(mid + 1, r, rt << 1 | 1, L, R, z, i);
return query(l, mid, rt << 1, L, mid, z, i) +
query(mid + 1, r, rt << 1 | 1, mid + 1, R, z,
(i + mid - L + 1) % cf[z]);
}
void run() {
int i, j, t, p, v, l, r, z;
build(1, n, 1);
scanf("%d", &m);
while (m--) {
scanf("%d", &t);
if (t == 1) {
scanf("%d%d", &p, &v);
update(1, n, 1, p, (long long)v);
} else {
scanf("%d%d%d", &l, &r, &z);
printf("%I64d\n", query(1, n, 1, l, r, z - 2, 0));
}
}
}
int main() {
preSof();
while (~scanf("%d", &n)) run();
return 0;
}
|
#include <bits/stdc++.h>
const long double eps = 1e-9;
const double pi = acos(-1.0);
const long long inf = 1e18;
using namespace std;
struct summator {
long long a[100002];
summator() {
for (int i = 0; i < 100002; i++) a[i] = 0;
}
void modify(int pos, long long val) {
while (pos < 100002) {
a[pos] += val;
pos = 2 * pos - (pos & (pos - 1));
}
}
long long fsum(int pos) {
long long res = 0;
while (pos > 0) {
res += a[pos];
pos = pos & (pos - 1);
}
return res;
}
};
int n, m, num[7][11][100002], cc[7], bg[7][100002];
long long val[100002];
summator ss[7][11];
void modify(int pos, long long n) {
for (int z = 2; z <= 6; z++)
for (int s = 1; s <= cc[z]; s++) {
long long coef = num[z][s][pos];
ss[z][s].modify(pos, coef * (n - val[pos]));
}
val[pos] = n;
}
long long query(int l, int r, int z) {
int s = bg[z][l];
return ss[z][s].fsum(r) - ss[z][s].fsum(l - 1);
}
int main(int argc, const char* argv[]) {
cc[2] = 2;
cc[3] = 4;
cc[4] = 6;
cc[5] = 8;
cc[6] = 10;
scanf("%d", &n);
for (int z = 2; z <= 6; z++) {
for (int i = 1; i <= n; i++) {
int val = i % (z + z - 2);
if (val == 0) num[z][1][i] = 2;
if (0 < val && val <= z) num[z][1][i] = val;
if (z < val) num[z][1][i] = z + z - val;
}
for (int s = 2; s <= cc[z]; s++)
for (int i = 1; i <= n; i++) {
int ii = i - 1;
if (ii == 0) ii = n;
num[z][s][i] = num[z][s - 1][ii];
}
for (int i = 1; i <= cc[z]; i++) bg[z][i] = i;
for (int i = cc[z] + 1; i <= n; i++) bg[z][i] = bg[z][i - cc[z]];
}
for (int i = 1; i <= n; i++) {
long long a;
scanf("%I64d", &a);
modify(i, a);
}
int t;
scanf("%d", &t);
for (int q = 0; q < t; q++) {
int tp;
scanf("%d", &tp);
if (tp == 1) {
int pos;
long long cur;
scanf("%d%I64d", &pos, &cur);
modify(pos, cur);
}
if (tp == 2) {
int l, r, z;
scanf("%d%d%d", &l, &r, &z);
printf("%I64d\n", query(l, r, z));
}
}
return 0;
}
|
#include <bits/stdc++.h>
const int maxn = 100000;
long long tree[5][10][maxn + 1];
int num[maxn + 1];
int lowbit(int x) { return x & -x; }
long long s(int z, int i) {
int t = i % (2 * (z - 1));
if (!t)
return 2;
else if (t <= z)
return t;
else
return 2 * z - t;
}
long long query(long long* tree, int a) {
long long ret = 0;
while (a) {
ret += tree[a];
a -= lowbit(a);
}
return ret;
}
void update(long long* tree, int n, int a, long long x) {
while (a <= n) {
tree[a] += x;
a += lowbit(a);
}
}
int main() {
int n;
int i;
int z, st;
scanf("%d", &n);
for (i = 1; i <= n; ++i) {
scanf("%d", num + i);
for (z = 0; z < 5; ++z) {
for (st = 0; st < z * 2 + 2; ++st)
update(tree[z][st], n, i, num[i] * s(z + 2, st + i));
}
}
int m;
scanf("%d", &m);
int l, r, p, v;
int cmd;
while (m--) {
scanf("%d", &cmd);
if (cmd == 1) {
scanf("%d%d", &p, &v);
for (z = 0; z < 5; ++z) {
for (st = 0; st < z * 2 + 2; ++st) {
update(tree[z][st], n, p, ((long long)v - num[p]) * s(z + 2, st + p));
}
}
num[p] = v;
} else {
scanf("%d%d%d", &l, &r, &z);
z -= 2;
st = ((1 - l) % (z * 2 + 2) + (z * 2 + 2)) % (z * 2 + 2);
printf("%I64d\n", query(tree[z][st], r) - query(tree[z][st], l - 1));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
long long seg[5][10][N << 2];
int tp[5][10], n;
void update(int val, int v, int p = 1, int l = 1, int r = n) {
if (l == r) {
for (int j = 0; j < 5; j++)
for (int i = 0; i < 2 + j * 2; i++) seg[j][i][p] = 1LL * val * tp[j][i];
return;
}
int m = l + r >> 1;
if (v <= m)
update(val, v, p << 1, l, m);
else
update(val, v, p << 1 | 1, m + 1, r);
for (int i = 0; i < 5; i++) {
int md = 2 + i * 2;
for (int j = 0; j < md; j++) {
int len = m - l + 1;
int nxt = (j + len) % md;
seg[i][j][p] = seg[i][j][p << 1] + seg[i][nxt][p << 1 | 1];
}
}
}
int mod, len, z;
long long query(int L, int R, int p = 1, int l = 1, int r = n) {
if (L <= l && R >= r) {
long long ans = seg[z][len % mod][p];
len += r - l + 1;
return ans;
}
int m = l + r >> 1;
long long ans = 0;
if (L <= m) ans += query(L, R, p << 1, l, m);
if (R > m) ans += query(L, R, p << 1 | 1, m + 1, r);
return ans;
}
inline int cal(int z, int i) {
int v = i % (2 * (z - 1));
if (v == 0) return 2;
if (v <= z) return v;
if (v > z) return 2 * z - v;
}
int main() {
static int num[N];
for (int i = 2; i <= 6; i++) {
for (int j = 0; j < i * 2 - 2; j++) {
tp[i - 2][j] = cal(i, j + 1);
}
}
cin >> n;
for (int i = 1; i <= n; i++) {
scanf("%d", &num[i]);
update(num[i], i);
}
int m;
cin >> m;
while (m--) {
int c, l, r;
scanf("%d%d%d", &c, &l, &r);
if (c == 1)
update(r, l);
else {
scanf("%d", &c);
z = c - 2;
len = 0;
mod = 2 * c - 2;
cout << query(l, r) << endl;
;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
void swap(int &x, int &y) {
int t = x;
x = y;
y = t;
}
int max(int x, int y) { return x > y ? x : y; }
int min(int x, int y) { return x < y ? x : y; }
const int inf = 0x3F3F3F3F;
const int M = 100000 + 5;
int T, cas;
int n, m;
long long a, sum[M << 2][5][11], s[5][M];
long long cf[5] = {2, 4, 6, 8, 10};
void preSof() {
for (long long z = 2; z <= 6; z++) {
long long md = (z - 1) << 1;
for (long long i = 1; i < M; i++) {
long long j = i % md;
if (!j)
s[z - 2][i - 1] = 2;
else if (j <= z)
s[z - 2][i - 1] = j;
else
s[z - 2][i - 1] = (z << 1) - j;
}
}
return;
}
void pushUp(int llen, int rt) {
for (long long z = 2; z <= 6; z++)
for (long long i = 0; i < cf[z - 2]; i++)
sum[rt][z - 2][i] = sum[rt << 1][z - 2][i] +
sum[rt << 1 | 1][z - 2][(i + llen) % cf[z - 2]];
}
void build(int l, int r, int rt) {
if (l == r) {
scanf("%I64d", &a);
for (long long z = 2; z <= 6; z++)
for (long long i = 0; i < cf[z - 2]; i++)
sum[rt][z - 2][i] = a * s[z - 2][i];
return;
}
int mid = l + r >> 1;
build(l, mid, rt << 1), build(mid + 1, r, rt << 1 | 1);
pushUp(mid - l + 1, rt);
}
void update(int l, int r, int rt, int p, long long c) {
if (l == r) {
for (long long z = 2; z <= 6; z++)
for (long long i = 0; i < cf[z - 2]; i++)
sum[rt][z - 2][i] = c * s[z - 2][i];
return;
}
int mid = l + r >> 1;
if (p <= mid)
update(l, mid, rt << 1, p, c);
else
update(mid + 1, r, rt << 1 | 1, p, c);
pushUp(mid - l + 1, rt);
}
long long query(int l, int r, int rt, int L, int R, int z, int i) {
if (L == l && r == R) {
return sum[rt][z][i];
}
int mid = l + r >> 1;
if (R <= mid) return query(l, mid, rt << 1, L, R, z, i);
if (mid < L) return query(mid + 1, r, rt << 1 | 1, L, R, z, i);
return query(l, mid, rt << 1, L, mid, z, i) +
query(mid + 1, r, rt << 1 | 1, mid + 1, R, z,
(i + mid - L + 1) % cf[z]);
}
void run() {
int i, j, t, p, v, l, r, z;
build(1, n, 1);
scanf("%d", &m);
while (m--) {
scanf("%d", &t);
if (t == 1) {
scanf("%d%d", &p, &v);
update(1, n, 1, p, (long long)v);
} else {
scanf("%d%d%d", &l, &r, &z);
printf("%I64d\n", query(1, n, 1, l, r, z - 2, 0));
}
}
}
int main() {
preSof();
while (~scanf("%d", &n)) run();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 1 << 17;
long long dat[7][15][2 * MAX_N - 1];
void init() {
for (int i = 2; i <= 6; i++) {
for (int j = 0; j < 2 * (i - 1); j++) {
for (int k = 0; k < 2 * MAX_N - 1; k++) dat[i][j][k] = 0;
}
}
}
long long zigzag(int i, int z) {
i++;
int n = i % (2 * (z - 1));
if (n == 0) return 2;
if (0 < n && n <= z) return n;
return 2 * z - n;
}
void update(int k, long long a) {
int nk = k + MAX_N - 1;
for (int i = 2; i <= 6; i++) {
for (int j = 0; j < 2 * (i - 1); j++) {
int tmpk = nk;
dat[i][j][tmpk] = a * zigzag(2 * (i - 1) - j + k, i);
while (tmpk > 0) {
tmpk = (tmpk - 1) / 2;
dat[i][j][tmpk] = dat[i][j][tmpk * 2 + 1] + dat[i][j][tmpk * 2 + 2];
}
}
}
}
long long query(int a, int b, int k, int l, int r, int z, int offset) {
if (r <= a || b <= l) return 0;
if (a <= l && r <= b)
return dat[z][offset][k];
else {
return query(a, b, k * 2 + 1, l, (l + r) / 2, z, offset) +
query(a, b, k * 2 + 2, (l + r) / 2, r, z, offset);
}
}
int main() {
int n, m;
cin >> n;
init();
for (int i = 0; i < n; i++) {
int a;
cin >> a;
update(i, a);
}
cin >> m;
for (int i = 0; i < m; i++) {
int kind;
cin >> kind;
if (kind == 1) {
int p, v;
cin >> p >> v;
p--;
update(p, v);
} else {
int l, r, z;
cin >> l >> r >> z;
l--;
cout << query(l, r, 0, 0, MAX_N, z, l % (2 * (z - 1))) << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int bit[7][12][100024];
long long int v[7][12][100024];
int N, M;
inline void updateBit(int y, int x, int o, long long int v) {
int i;
for (i = y; i <= N; i += i & -i) {
bit[x][o][i] += v;
}
}
long long int Z[7][32];
int SZ[7];
inline long long int queryBit(int y, int x, int o) {
long long int r = 0;
int i;
for (i = y; i; i -= i & -i) {
r += bit[x][o][i];
}
return r;
}
int main() {
int i, n, t;
long long a, b;
memset(bit, 0, sizeof(bit));
for (a = 2; a <= 6; a++) {
n = 0;
for (i = 1; i <= a; i++) {
Z[a][n++] = i;
}
for (i = a - 1; i > 1; i--) {
Z[a][n++] = i;
}
SZ[a] = n;
}
scanf("%d", &N);
for (i = 1; i <= N; i++) {
scanf("%I64d", &a);
for (n = 2; n <= 6; n++) {
for (t = 0; t < SZ[n]; t++) {
b = a * Z[n][(i + -t - 1 + SZ[n]) % SZ[n]];
v[n][t][i] = b;
updateBit(i, n, t, b);
}
}
}
scanf("%d", &M);
while (M--) {
scanf("%d", &t);
switch (t) {
case 1:
scanf("%d %I64d", &i, &a);
for (n = 2; n <= 6; n++) {
for (t = 0; t < SZ[n]; t++) {
b = a * Z[n][(i - 1 - t + SZ[n]) % SZ[n]];
updateBit(i, n, t, b - v[n][t][i]);
v[n][t][i] = b;
}
}
break;
case 2:
scanf("%d %d %d", &i, &n, &t);
a = queryBit(n, t, (i - 1) % SZ[t]) -
queryBit(i - 1, t, (i - 1) % SZ[t]);
printf("%I64d\n", a);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
inline int max(int a, int b) { return a > b ? a : b; }
inline int min(int a, int b) { return a < b ? a : b; }
inline int gcd(int a, int b) {
if (a % b)
return gcd(b, a % b);
else
return b;
}
inline int lcm(int a, int b) { return (a * (b / gcd(a, b))); }
inline int And(int mask, int bit) { return mask & (1 << bit); }
inline int Or(int mask, int bit) { return mask | (1 << bit); }
inline int Xor(int mask, int bit) { return mask ^ (1 << bit); }
int n, m;
long long tree[7][11][100010], a[100010];
void updateBIT(long long tree[], int x, long long v) {
while (x <= n) {
tree[x] += v;
x += (x & -x);
}
}
long long getBIT(long long tree[], int x) {
long long res = 0;
while (x) {
res += tree[x];
x -= (x & -x);
}
return res;
}
long long cal(int i, int z, int k) {
i -= k;
long long d = 2 * z - 2;
i %= d;
if (i < 0) i += d;
if (i == 0) return 2;
if (i <= z) return i;
return 2 * z - i;
}
int main() {
int u, v, c, l, r, z;
long long res;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%I64d", &a[i]);
for (int z = 2; z <= 6; z++)
for (int k = 0; k < 2 * z - 2; k++)
updateBIT(tree[z][k], i, a[i] * cal(i, z, k));
}
scanf("%d", &m);
for (int i = 0; i < m; i++) {
scanf("%d", &c);
if (c == 1) {
scanf("%d %d", &u, &v);
for (int z = 2; z <= 6; z++)
for (int k = 0; k < 2 * z - 2; k++)
updateBIT(tree[z][k], u, (long long)(v - a[u]) * cal(u, z, k));
a[u] = v;
} else if (c == 2) {
scanf("%d %d %d", &l, &r, &z);
res = getBIT(tree[z][(l - 1) % (2 * z - 2)], r) -
getBIT(tree[z][(l - 1) % (2 * z - 2)], l - 1);
printf("%I64d\n", res);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long tree[12][12][1 << 17];
long long a[100008];
void add(long long id1, long long id2, long long pos, long long val) {
for (long long i = pos; i < (1 << 17); i = ((i) | (i + 1)))
tree[id1][id2][i] += val;
}
long long sum(long long id1, long long id2, long long pos) {
long long res = 0;
for (long long i = pos; i > 0; i = ((i) & (i - 1)))
res += tree[id1][id2][i - 1];
return res;
}
void update(long long pos, long long x) {
long long d = x - a[pos];
a[pos] = x;
for (long long i = 2; i <= 10; i += 2) add(i, pos % i, pos, d);
}
long long query(long long l, long long r, long long mod) {
long long res = 0;
for (long long i = 0; i < mod; i++) {
long long op = 1 + min(i, mod - i);
res += op * sum(mod, (l + i) % mod, r) - op * sum(mod, (l + i) % mod, l);
}
return res;
}
int main() {
long long n;
long long m;
cin >> n;
for (long long i = 0; i < n; i++) cin >> a[i];
for (long long i = 2; i <= 10; i += 2)
for (long long j = 0; j < n; j++) add(i, j % i, j, a[j]);
cin >> m;
for (long long i = 0; i < m; i++) {
long long q;
cin >> q;
if (q == 1) {
long long a0, b0;
cin >> a0 >> b0;
update(a0 - 1, b0);
}
if (q == 2) {
long long a0, b0, c0;
cin >> a0 >> b0 >> c0;
cout << query(a0 - 1, b0, 2 * (c0 - 1)) << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
int n;
struct BIT {
long long c[N];
void insert(int x, long long val) {
for (; x <= n; x += x & -x) c[x] += val;
}
long long get(int x) {
long long ret = 0;
for (; x; x ^= x & -x) ret += c[x];
return ret;
}
};
BIT bit[7][10];
int m, v[N];
inline long long cal(int ps, int z, int delta) {
int tem = (z - 1) << 1;
int pss = (ps - delta + tem) % tem;
if (pss < z) return pss + 1;
return tem - pss + 1;
}
int main() {
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> v[i];
for (int j = 2; j <= 6; ++j) {
for (int k = 0; k < (j - 1) * 2; ++k) {
bit[j][k].insert(i + 1, cal(i, j, k) * v[i]);
}
}
}
cin >> m;
for (int q = 0, cmd, l, r, x; q < m; ++q) {
cin >> cmd;
if (cmd == 1) {
cin >> l >> x;
for (int i = 2; i <= 6; ++i)
for (int j = 0; j < (i - 1) * 2; ++j) {
bit[i][j].insert(l, -1 * cal(l - 1, i, j) * v[l - 1]);
bit[i][j].insert(l, cal(l - 1, i, j) * x);
}
v[l - 1] = x;
} else {
cin >> l >> r >> x;
int tem = (x - 1) << 1;
cout << bit[x][(l - 1) % tem].get(r) - bit[x][(l - 1) % tem].get(l - 1)
<< endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[11][100010] = {0};
long long sum(int k, int dir) {
long long ans = 0;
int r = k % dir;
k = k / dir + 1;
while (k > 0) {
ans += a[dir][(k - 1) * dir + r];
k -= k & (-k);
}
return ans;
}
void update(int k, int dir, long long num) {
int r = k % dir;
k = k / dir + 1;
while ((k - 1) * dir + r < 100010) {
a[dir][(k - 1) * dir + r] += num;
k += k & (-k);
}
}
long long calc(int dir, int start, int end) {
int r = start % dir;
if (end / dir * dir + r > end)
end = end / dir * dir + r - dir;
else
end = end / dir * dir + r;
long long ans = sum(end, dir);
if (start - dir > 0) ans -= sum(start - dir, dir);
return ans;
}
int fz(int i, int z) {
int r = i % (2 * (z - 1));
if (r == 0)
return 2;
else if (r <= z)
return r;
else
return 2 * z - r;
}
long long b[100010];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%I64d", &b[i]);
for (int j = 1; j <= 10; j++) {
update(i, j, b[i]);
}
}
int q;
int t, p;
long long v;
scanf("%d", &q);
int l, r, z;
long long ans = 0;
while (q--) {
scanf("%d", &t);
if (t == 1) {
scanf("%d%I64d", &p, &v);
long long diff = v - b[p];
b[p] = v;
for (int j = 1; j <= 10; j++) update(p, j, diff);
} else {
scanf("%d%d%d", &l, &r, &z);
ans = 0;
for (int i = 1; i <= 2 * (z - 1) && l + i - 1 <= r; i++) {
ans += calc(2 * (z - 1), i + l - 1, r) * fz(i, z);
}
printf("%I64d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 7, Z = 7;
long long read() {
long long s = 0, w = 1;
char c;
while (c = getchar(), c > '9' || c < '0')
if (c == '-') w = -1;
while (c >= '0' && c <= '9') s = s * 10 + c - '0', c = getchar();
return s * w;
}
void write(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) write(x / 10);
putchar(x % 10 | '0');
}
void wsp(long long x) {
write(x);
putchar(' ');
}
void wln(long long x) {
write(x);
putchar('\n');
}
long long n, m;
long long a[N];
struct seg {
long long z, ps;
long long s[N << 2];
void pushup(long long ts) { s[ts] = s[(ts << 1)] + s[(ts << 1 | 1)]; }
long long Val(long long x) {
x += ps;
long long p = 2 * (z - 1);
if (x % p == 0) return 2;
if (x % p <= z) return x % p;
return 2 * z - x % p;
}
void build(long long ts, long long l, long long r) {
if (l == r) {
s[ts] = a[l] * Val(l);
return;
}
long long mid = (l + r) >> 1;
build((ts << 1), l, mid);
build((ts << 1 | 1), mid + 1, r);
pushup(ts);
}
void change(long long ts, long long l, long long r, long long x,
long long v) {
if (l == r) {
s[ts] = v * Val(l);
return;
}
long long mid = (l + r) >> 1;
if (x <= mid)
change((ts << 1), l, mid, x, v);
else
change((ts << 1 | 1), mid + 1, r, x, v);
pushup(ts);
}
long long query(long long ts, long long l, long long r, long long L,
long long R) {
if (l == L && r == R) return s[ts];
long long mid = (l + r) >> 1;
if (R <= mid)
return query((ts << 1), l, mid, L, R);
else if (L > mid)
return query((ts << 1 | 1), mid + 1, r, L, R);
else
return query((ts << 1), l, mid, L, mid) +
query((ts << 1 | 1), mid + 1, r, mid + 1, R);
}
} T[7][11];
void change(long long l, long long x) {
for (long long i = 2; i <= 6; i++)
for (long long j = 0; j < 2 * (i - 1); j++) T[i][j].change(1, 1, n, l, x);
}
signed main() {
n = read();
for (long long i = 1; i <= n; i++) a[i] = read();
for (long long i = 2; i <= 6; i++)
for (long long j = 0; j < 2 * (i - 1); j++) {
T[i][j].z = i;
T[i][j].ps = j;
T[i][j].build(1, 1, n);
}
m = read();
for (long long i = 1, opt, l, r, x; i <= m; i++) {
opt = read();
if (opt == 1) {
l = read();
x = read();
change(l, x);
} else {
l = read();
r = read();
x = read();
long long p = 2 * (x - 1);
wln(T[x][(p - l % p + 1) % p].query(1, 1, n, l, r));
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 20000000;
const long long mod = 1e9 + 7;
int arr[100001];
long long n, t[7][10][400000];
long long ZZ(int num, int z) {
while (num <= 0) num += 2 * (z - 1);
if ((num % (2 * (z - 1))) == 0)
return 2;
else if ((num % (2 * (z - 1))) <= z)
return (num % (2 * (z - 1)));
else
return 2 * z - (num % (2 * (z - 1)));
}
void build(int z, int shift, int v, int tl, int tr) {
if (tl == tr)
t[z][shift][v] = arr[tl] * ZZ(tl + 1 - shift, z);
else {
int tm = (tl + tr) / 2;
build(z, shift, v * 2, tl, tm);
build(z, shift, v * 2 + 1, tm + 1, tr);
t[z][shift][v] = t[z][shift][v * 2] + t[z][shift][v * 2 + 1];
}
}
long long sum(int z, int shift, int v, int tl, int tr, int l, int r) {
if (l > r) return 0;
if (l == tl && r == tr) return t[z][shift][v];
int tm = (tl + tr) / 2;
return sum(z, shift, v * 2, tl, tm, l, min(r, tm)) +
sum(z, shift, v * 2 + 1, tm + 1, tr, max(l, tm + 1), r);
}
void update(int z, int shift, int v, int tl, int tr, int pos, long long val) {
if (tl == tr)
t[z][shift][v] = val * ZZ(tl + 1 - shift, z);
else {
int tm = (tl + tr) / 2;
if (pos <= tm)
update(z, shift, v * 2, tl, tm, pos, val);
else
update(z, shift, v * 2 + 1, tm + 1, tr, pos, val);
t[z][shift][v] = t[z][shift][v * 2] + t[z][shift][v * 2 + 1];
}
}
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> arr[i];
}
for (int i = 2; i <= 6; ++i) {
for (int sh = 0; sh < 2 * (i - 1); ++sh) {
build(i, sh, 1, 0, n - 1);
}
}
int q;
cin >> q;
while (q) {
int t;
cin >> t;
if (t == 1) {
int p, v;
cin >> p >> v;
for (int i = 2; i <= 6; ++i) {
for (int sh = 0; sh < 2 * (i - 1); ++sh) {
update(i, sh, 1, 0, n - 1, p - 1, v);
}
}
} else {
int l, r, z;
cin >> l >> r >> z;
cout << sum(z, (l - 1) % (2 * (z - 1)), 1, 0, n - 1, l - 1, r - 1)
<< endl;
}
--q;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline void pisz(int n) { printf("%d\n", n); }
template <typename T, typename TT>
ostream &operator<<(ostream &s, pair<T, TT> t) {
return s << "(" << t.first << "," << t.second << ")";
}
template <typename T>
ostream &operator<<(ostream &s, vector<T> t) {
for (int(i) = 0; (i) < (((int)(t.size()))); ++(i)) s << t[i] << " ";
return s;
}
void add(long long *t, int n, long long x) {
for (; n < 100007; n |= n + 1) t[n] += x;
}
long long sum(long long *t, int n) {
long long s = 0;
while (n >= 0) {
s += t[n];
n = (n & (n + 1)) - 1;
}
return s;
}
int a[100007];
long long tab[6][14][100007];
void dodaj(int ppi, long long diff) {
for (int(z) = (2); (z) <= (6); ++z)
for (int(k) = (0); (k) <= (2 * z - 3); ++k) {
int pos = (ppi + 1 - k) % (2 * z - 2);
if (pos < 0) pos += 2 * z - 2;
int res;
if (pos == 0)
res = 2;
else if (pos <= z)
res = pos;
else
res = 2 * z - pos;
add(tab[z - 2][k], ppi, diff * res);
}
}
int main() {
for (int(z) = (2); (z) <= (6); ++z)
for (int(k) = (0); (k) <= (2 * z - 3); ++k)
for (int(i) = 0; (i) < (100007); ++(i)) tab[z - 2][k][i] = 0;
int(n);
scanf("%d", &(n));
for (int(i) = 1; (i) <= (n); ++(i)) {
scanf("%d", a + i);
dodaj(i, a[i]);
}
int(testow);
scanf("%d", &(testow));
while (testow--) {
int(tp);
scanf("%d", &(tp));
if (tp == 1) {
int(ppi), (vvi);
scanf("%d %d", &(ppi), &(vvi));
;
long long diff = vvi - a[ppi];
a[ppi] = vvi;
dodaj(ppi, diff);
} else {
int(l), (r), (z);
scanf("%d %d %d", &(l), &(r), &(z));
long long sum1 = sum(tab[z - 2][l % (2 * z - 2)], l - 1);
long long sum2 = sum(tab[z - 2][l % (2 * z - 2)], r);
printf("%I64d\n", sum2 - sum1);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
typedef char* cstr;
const int oo = (~0u) >> 1;
const long long int ooll = (~0ull) >> 1;
const double inf = 1e+8;
const double eps = 1e-8;
const double pi = acos(-1.0);
const int MOD = 1000000007;
template <typename type>
inline bool cmax(type& a, const type& b) {
return a < b ? a = b, true : false;
}
template <typename type>
inline bool cmin(type& a, const type& b) {
return a > b ? a = b, true : false;
}
template <typename type>
inline type sqr(const type& first) {
return first * first;
}
int dbcmp(const double& a, const double& b) {
return (a > b + eps) - (a < b - eps);
}
int sgn(const double& first) { return dbcmp(first, 0); }
template <typename type>
inline type gcd(type a, type b) {
if (b)
while ((a %= b) && (b %= a))
;
return a + b;
}
template <typename type>
inline type lcm(type a, type b) {
return a * b / gcd(a, b);
}
template <typename type>
inline void bit_inc(vector<type>& st, int first, type inc) {
while (first < ((int)(st).size())) st[first] += inc, first |= first + 1;
}
template <typename type>
inline type bit_sum(const vector<type>& st, int first) {
type s = 0;
while (first >= 0) s += st[first], first = (first & (first + 1)) - 1;
return s;
}
inline void make_set(vector<int>& set, int size) {
set.resize(size);
for (int i = 0; i < (size); ++i) set[i] = i;
}
inline int find_set(vector<int>& set, int first) {
if (set[first] != first) set[first] = find_set(set, set[first]);
return set[first];
}
inline bool union_set(vector<int>& set, int a, int b) {
a = find_set(set, a), b = find_set(set, b);
return a == b ? false : set[a] = b, true;
}
vector<long long int> a;
vector<long long int> st[6 + 2][10 + 2];
void ins(long long int p, long long int first) {
long long int delta = first - a[p];
a[p] = first;
for (int i = (2); i <= (6); ++i) {
bit_inc(st[i][p % ((i - 1) * 2)], p, delta);
}
}
long long int qry(long long int l, long long int r, long long int z) {
long long int ans = 0;
for (int i = 0; i < ((z - 1) * 2); ++i) {
ans += (bit_sum(st[z][(l + i) % ((z - 1) * 2)], r) -
bit_sum(st[z][(l + i) % ((z - 1) * 2)], l - 1)) *
min<long long int>(i + 1, z * 2 - (i + 1));
}
return ans;
}
int main() {
int n;
cin >> n;
a.resize(n);
for (int i = (2); i <= (6); ++i)
for (int j = 0; j < ((i - 1) * 2); ++j) st[i][j].resize(n);
for (int i = 0; i < (n); ++i) {
long long int ai;
cin >> ai;
ins(i, ai);
}
int m;
cin >> m;
for (int i = 0; i < (m); ++i) {
int t;
cin >> t;
switch (t) {
case 1: {
long long int p, first;
cin >> p >> first;
ins(--p, first);
} break;
case 2: {
long long int l, r, z;
cin >> l >> r >> z;
cout << qry(--l, --r, z) << endl;
} break;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int OO = 2e9;
const int MOD = 1e9 + 7;
const double Pi = 3.141592653589793;
const int N = 1e5 + 5;
struct data {
int l, r;
long long s[7][12];
} IT[3 * N];
int a[N];
int n, q;
data combine(data a, data b) {
data res;
res.l = a.l;
res.r = b.r;
for (int z = (int)2; z <= (int)6; z++)
for (int p = (int)1; p <= (int)2 * z - 2; p++)
res.s[z][p] = 1LL * a.s[z][p] + b.s[z][(a.r - a.l + p) % (2 * z - 2) + 1];
return res;
}
int S(int z, int i) {
int l = 2 * (z - 1);
if (i % l == 0) return 2;
if (i % l <= z) return i % l;
return 2 * z - (i % l);
}
void gen(int x, int l, int r) {
if (l == r) {
IT[x].l = l;
IT[x].r = r;
for (int z = (int)2; z <= (int)6; z++)
for (int p = (int)1; p <= (int)2 * z - 2; p++)
IT[x].s[z][p] = 1LL * a[l] * S(z, p);
return;
}
int m = (l + r) >> 1;
gen(x * 2, l, m);
gen(x * 2 + 1, m + 1, r);
IT[x] = combine(IT[x * 2], IT[x * 2 + 1]);
}
void update(int x, int l, int r, int P, int v) {
if (l == r) {
a[l] = v;
for (int z = (int)2; z <= (int)6; z++)
for (int p = (int)1; p <= (int)2 * z - 2; p++)
IT[x].s[z][p] = 1LL * a[l] * S(z, p);
} else {
int m = (l + r) >> 1;
if (P <= m)
update(x * 2, l, m, P, v);
else
update(x * 2 + 1, m + 1, r, P, v);
IT[x] = combine(IT[x * 2], IT[x * 2 + 1]);
}
}
data query(int x, int l, int r, int L, int R) {
if (L <= l && r <= R) return IT[x];
int m = (l + r) >> 1;
if (R <= m) return query(x * 2, l, m, L, R);
if (m < L) return query(x * 2 + 1, m + 1, r, L, R);
return combine(query(x * 2, l, m, L, R), query(x * 2 + 1, m + 1, r, L, R));
}
int main() {
cin >> n;
for (int i = (int)1; i <= (int)n; i++) scanf("%i", &a[i]);
gen(1, 1, n);
cin >> q;
int t, x, y, z;
while (q--) {
scanf("%i%i%i", &t, &x, &y);
if (t == 1)
update(1, 1, n, x, y);
else {
scanf("%i", &z);
data db = (query(1, 1, n, x, y));
printf("%I64d\n", db.s[z][1]);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
inline int mmod(int n, int z, int l) {
int mod = 2 * z - 2;
return ((n - l) % mod + mod) % mod;
}
vector<vector<long long> > z;
struct ST {
int n;
vector<long long> t;
int x, y;
ST() {}
ST(const vector<long long> &a, int _x, int _y) {
x = _x;
y = _y;
n = 1;
int _n = (int)a.size();
while (n < _n) n <<= 1;
t.clear();
t.resize(2 * n);
for (int i = n; i < n + _n; i++) t[i] = a[i - n] * z[x][mmod(i - n, x, y)];
for (int i = n - 1; i > 0; i--) t[i] = t[i << 1] + t[(i << 1) + 1];
}
inline void update(int v, int val) {
v += n;
t[v] = (long long)val * z[x][mmod(v - n, x, y)];
v >>= 1;
while (v) t[v] = t[v << 1] + t[(v << 1) + 1], v >>= 1;
}
inline long long get(int v, int a, int b, int l, int r) {
if (r < a || b < l) return 0;
if (l <= a && b <= r) return t[v];
int m = (a + b) >> 1;
return get(v << 1, a, m, l, r) + get((v << 1) + 1, m + 1, b, l, r);
}
inline long long get(int l, int r) {
return get(1, n, (n << 1) - 1, l + n, r + n);
}
};
int n;
vector<long long> a;
int main() {
while (scanf("%d", &n) >= 1) {
z.resize(7);
for (int i = 2; i <= 6; i++) {
z[i].resize(2 * i - 2);
for (int j = 0; j < i; j++) z[i][j] = j + 1;
for (int j = i; j < 2 * i - 2; j++) z[i][j] = (i << 1) - j - 1;
}
a.resize(n);
for (int i = 0; i < n; i++) scanf("%I64d", &a[i]);
vector<ST> trees[7];
for (int i = 2; i <= 6; i++) {
trees[i].resize(2 * i - 2);
for (int j = 0; j < 2 * i - 2; j++) trees[i][j] = ST(a, i, j);
}
int q;
scanf("%d", &q);
for (int i = 0; i < q; i++) {
int type;
scanf("%d", &type);
if (type == 1) {
int p, v;
scanf("%d%d", &p, &v);
--p;
for (int z = 2; z <= 6; z++)
for (int j = 0; j < 2 * z - 2; j++) trees[z][j].update(p, v);
} else {
int l, r, z;
scanf("%d%d%d", &l, &r, &z);
--l, --r;
printf("%I64d\n", trees[z][l % (2 * z - 2)].get(l, r));
}
}
break;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, A[100005];
struct BIT {
long long arr[100005];
int sz;
void add(int pos, int val) {
while (pos <= sz) {
arr[pos] += (long long)val;
pos += pos & -pos;
}
}
long long sum(int pos) {
long long S = 0;
while (pos > 0) {
S += arr[pos];
pos -= pos & -pos;
}
return S;
}
} ars[5][10];
inline int cals(int i, int z) {
return ((!(i % ((z << 1) - 2))) ? (2)
: ((i % ((z << 1) - 2) <= z)
? (i % ((z << 1) - 2))
: ((z << 1) - (i % ((z << 1) - 2)))));
}
inline int app(int i, int z) { return (i + (z << 1) - 3) / ((z << 1) - 2); }
inline int inc(int i, int z, int m) {
z = (z << 1) - 2;
if (m) {
return ((i - m + z) / z);
} else {
return (i / z);
}
}
int main() {
int p, v, xb, x2, t, l, r, z;
scanf("%d", &n);
for (xb = 0; xb < 5; xb++)
for (x2 = 0; x2 < 10; x2++) ars[xb][x2].sz = n;
for (xb = 1; xb <= n; xb++) {
scanf("%d", &A[xb]);
for (x2 = 2; x2 <= 6; x2++) {
ars[x2 - 2][xb % ((x2 << 1) - 2)].add(app(xb, x2), A[xb]);
}
}
scanf("%d", &m);
for (xb = 0; xb < m; xb++) {
scanf("%d", &t);
if (t == 1) {
scanf("%d%d", &p, &v);
for (x2 = 2; x2 <= 6; x2++) {
ars[x2 - 2][p % ((x2 << 1) - 2)].add(app(p, x2), v - A[p]);
}
A[p] = v;
} else {
scanf("%d%d%d", &l, &r, &z);
long long res = 0;
for (x2 = 0; x2 < (z << 1) - 2; x2++) {
res += (long long)cals(x2 + 100000 * ((z << 1) - 2) - l + 1, z) *
(ars[z - 2][x2].sum(inc(r, z, x2)) -
ars[z - 2][x2].sum(inc(l - 1, z, x2)));
}
printf("%I64d\n", res);
}
}
return 0;
}
|
#include <bits/stdc++.h>
const int LMT = 100003;
long long sum[5][12][LMT << 2];
int Z;
long long query(int L, int R, int l, int r, int x) {
if (L <= l && r <= R) return sum[Z - 2][(l - L + 1) % ((Z << 1) - 2)][x];
int m = (l + r) >> 1;
long long res = 0;
if (L <= m) res += query(L, R, l, m, x << 1);
if (R > m) res += query(L, R, m + 1, r, x << 1 | 1);
return res;
}
void update(long long op, int pos, int l, int r, int x) {
if (l == r) {
int i, j;
for (i = 2; i <= 6; ++i)
for (j = 0; j < (i << 1) - 2; ++j)
if (j > i)
sum[i - 2][j][x] = op * ((i << 1) - j);
else if (j > 0 && j <= i)
sum[i - 2][j][x] = op * j;
else
sum[i - 2][j][x] = op << 1;
return;
}
int m = (l + r) >> 1, i, j, le = m - l + 1;
if (pos <= m)
update(op, pos, l, m, x << 1);
else
update(op, pos, m + 1, r, x << 1 | 1);
for (i = 2; i <= 6; ++i)
for (j = 0; j < (i << 1) - 2; ++j)
sum[i - 2][j][x] = sum[i - 2][j][x << 1] +
sum[i - 2][(j + le) % ((i << 1) - 2)][x << 1 | 1];
}
int main(void) {
int l, r, i, n, t, v;
long long x;
scanf("%d", &n);
for (i = 1; i <= n; ++i) {
scanf("%I64d", &x);
update(x, i, 1, n, 1);
}
scanf("%d", &t);
while (t--) {
scanf("%I64d", &x);
if (1 == x) {
scanf("%d%d", &l, &v);
update(v, l, 1, n, 1);
} else {
scanf("%d%d%d", &l, &r, &Z);
printf("%I64d\n", query(l, r, 1, n, 1));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct forZ {
vector<long long int> BIT[20];
int prev[200000];
int N, Z;
int maxsZ;
void init(int _n, int _Z) {
N = _n;
Z = (_Z - 1) * 2;
maxsZ = (N + Z) / Z + 10;
for (int i = 0; i <= 12; i++) BIT[i].resize(10 + (N + Z) / Z);
}
void U(int loc, int val) {
int i;
int rem = loc % Z;
loc /= Z;
loc += 3;
for (i = loc; i < maxsZ; i += (i & -i)) BIT[rem][i] += val;
}
long long int Q(int loc) {
if (loc < 0) return 0;
int i;
long long int ret = 0;
int rem = loc % Z;
loc /= Z;
loc += 3;
for (i = loc; i > 0; i -= (i & -i)) ret += BIT[rem][i];
return ret;
}
void upd(int loc, int ele) {
U(loc, ele - prev[loc]);
prev[loc] = ele;
}
long long int lastmul(long long int a, long long int b) {
long long int mul = a / Z;
mul *= Z;
mul += b;
mul += Z;
while (mul >= a) mul -= Z;
return mul;
}
long long int query(int lft, int rgt) {
long long int ans = 0;
int i;
long long int cur = 1;
for (i = 0; i < Z / 2; i++)
ans += cur++ * (Q(lastmul(rgt + 1, (i + lft) % Z)) -
Q(lastmul(lft, (i + lft) % Z)));
for (i = Z / 2; i < Z; i++) {
ans += cur-- * (Q(lastmul(rgt + 1, (i + lft) % Z)) -
Q(lastmul(lft, (i + lft) % Z)));
}
return ans;
}
};
int n, i;
forZ dss[7];
int main() {
int x, j;
cin >> n;
for (i = 2; i <= 6; i++) {
dss[i].init(n, i);
}
for (i = 0; i < n; i++) {
cin >> x;
for (j = 2; j <= 6; j++) dss[j].upd(i, x);
}
int m, l, r, z, tp;
cin >> m;
while (m--) {
cin >> tp;
if (tp == 2) {
cin >> l >> r >> z;
l--;
r--;
cout << dss[z].query(l, r) << endl;
} else {
cin >> l >> z;
l--;
for (i = 2; i <= 6; i++) dss[i].upd(l, z);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
class FenwickTree {
public:
long long sum(int r) {
long long result = 0;
for (; r >= 0; r = (r & (r + 1)) - 1) result += t[r];
return result;
}
long long sum(int l, int r) { return sum(r) - sum(l - 1); }
void inc(int i, long long delta) {
for (; i < (int)t.size(); i = (i | (i + 1))) t[i] += delta;
}
void inc(int l, int r, long long delta) {
inc(l, delta);
inc(r + 1, -delta);
}
void assign(int i, long long value) {
long long delta = value - sum(i, i);
inc(i, delta);
}
FenwickTree(std::vector<long long> &a) : t(vector<long long>(a.size(), 0)) {
for (int i = 0; i < (int)a.size(); ++i) inc(i, a[i]);
}
FenwickTree() {}
private:
std::vector<long long> t;
};
int zigzag(int i, int z) {
int zz = 2 * (z - 1);
if (i % zz == 0) return 2;
if (i % zz <= z) return i % zz;
return z * 2 - i % zz;
}
int main() {
ios_base::sync_with_stdio(0);
int n, m;
cin >> n;
vector<long long> a(n + 1);
for (int i = 1; i <= n; ++i) cin >> a[i];
vector<vector<FenwickTree> > trees(7);
for (int i = 2; i <= 6; ++i) {
trees[i] = vector<FenwickTree>((i - 1) * 2);
for (int j = 0; j < (i - 1) * 2; ++j) {
vector<long long> aij(a);
for (int k = 1; k <= n; ++k) aij[k] = a[k] * zigzag(k + j, i);
trees[i][j] = FenwickTree(aij);
}
}
cin >> m;
int t, x, y, z;
while (m--) {
cin >> t;
if (t == 1) {
cin >> x >> y;
for (int i = 2; i <= 6; ++i)
for (int j = 0; j < (i - 1) * 2; ++j)
trees[i][j].assign(x, (long long)y * zigzag(x + j, i));
} else {
cin >> x >> y >> z;
int mod = x % ((z - 1) * 2);
if (mod == 0) mod += (z - 1) * 2;
int pos = (z - 1) * 2 + 1 - mod;
pos %= (z - 1) * 2;
cout << trees[z][pos].sum(x, y) << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1 << 29;
const double PI = acos(-1);
const double EPS = 1e-8;
long long bit[7][10][100010];
int n;
long long sum(int z, int k, int i) {
long long s = 0;
while (i > 0) {
s += bit[z][k][i];
i -= i & -i;
}
return s;
}
long long sum2(int z, int k, int a, int b) {
return sum(z, k, b) - sum(z, k, a - 1);
}
void add(int z, int k, int i, long long x) {
while (i <= n) {
bit[z][k][i] += x;
i += i & -i;
}
}
int f(int i, int z) {
int p = i % (2 * (z - 1));
if (p == 0) return 2;
if (p <= z) return p;
return 2 * z - p;
}
int g(int i, int z) {
int zz = 2 * (z - 1);
return (i % zz + zz) % zz;
}
long long a[100001];
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
for (int z = 2; z <= 6; ++z) {
for (int t = 0; t < 2 * (z - 1); ++t) {
add(z, t, i, a[i] * f(g(i - t, z), z));
}
}
}
int m;
cin >> m;
for (int i = 0; i < (int)m; ++i) {
int t;
cin >> t;
if (t == 1) {
long long p, v;
cin >> p >> v;
for (int z = 2; z <= 6; ++z) {
for (int t = 0; t < 2 * (z - 1); ++t) {
add(z, t, p, -a[p] * f(g(p - t, z), z));
add(z, t, p, v * f(g(p - t, z), z));
}
}
a[p] = v;
} else {
int l, r, z;
cin >> l >> r >> z;
int t = (l - 1) % (2 * (z - 1));
cout << sum2(z, t, l, r) << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int Get() {
char c;
while (c = getchar(), c < '0' || c > '9')
;
int X = c - 48;
while (c = getchar(), c >= '0' && c <= '9') X = X * 10 + c - 48;
return X;
}
void Output(long long X) {
int Data[20], Len = 0;
while (X) {
Data[Len++] = X % 10;
X /= 10;
}
if (!Len) Data[Len++] = 0;
while (Len--) putchar(Data[Len] + 48);
putchar('\n');
}
const int Code[11][10] = {
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 4, 5,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 7, 8, 9, 10, 11,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 12, 13, 14, 15, 16, 17, 18, 19,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
};
int N;
long long S[30][100001];
void Add(int X, int P, long long Delta) {
while (P <= N) {
S[X][P] += Delta;
P += P & -P;
}
}
long long Sum(int X, int P) {
long long Ans = 0;
while (P) {
Ans += S[X][P];
P -= P & -P;
}
return Ans;
}
int main() {
static long long Data[100000];
N = Get();
for (int i = 0; i < N; i++) Data[i] = Get();
memset(S, 0, sizeof(S));
for (int i = 0; i < N; i++)
for (int j = 2; j <= 10; j += 2) Add(Code[j][i % j], i + 1, Data[i]);
int Query = Get();
while (Query--) {
int Type = Get();
if (Type == 1) {
int X = Get() - 1, Y = Get();
for (int i = 2; i <= 10; i += 2) Add(Code[i][X % i], X + 1, Y - Data[X]);
Data[X] = Y;
} else {
int L = Get() - 1, R = Get(), M = (Get() - 1) * 2;
long long Ans = 0;
for (int i = 0, j = 1; i < M; i++, j++) {
int X = Code[M][(L + i) % M];
Ans += (Sum(X, R) - Sum(X, L)) * min(j, M + 2 - j);
}
Output(Ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
long long T[7][11][N] = {0}, ans;
int n, m, a[N], c, l, r, z;
void update(int zz, int mod, int x, int v) {
while (x <= n) T[zz][mod][x] += v, x += x & -x;
}
long long getres(int zz, int mod, int x) {
long long res = 0;
while (x) res += T[zz][mod][x], x -= x & -x;
return res;
}
long long S(int i, int z) {
if (i % (2 * (z - 1)) == 0) return 2;
if (i % (2 * (z - 1)) > z)
return 2 * z - i % (2 * (z - 1));
else
return i % (2 * (z - 1));
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", a + i);
for (int i = 1; i <= n; ++i) {
for (int zz = 2; zz <= 6; ++zz) update(zz, i % (2 * (zz - 1)), i, a[i]);
}
scanf("%d", &m);
for (int i = 1; i <= m; ++i) {
scanf("%d", &c);
if (c == 1) {
scanf("%d%d", &l, &r);
for (int zz = 2; zz <= 6; ++zz) update(zz, l % (2 * (zz - 1)), l, -a[l]);
a[l] = r;
for (int zz = 2; zz <= 6; ++zz) update(zz, l % (2 * (zz - 1)), l, a[l]);
} else {
ans = 0;
scanf("%d%d%d", &l, &r, &z);
for (int j = l; j <= min(r, l + 2 * z - 3); ++j)
ans += 1LL *
(getres(z, j % (2 * (z - 1)), r) -
getres(z, j % (2 * (z - 1)), l - 1)) *
S(j - l + 1, z);
printf("%I64d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
double EPS = 1e-10;
const int MAX_N = 100010;
double EQ(double a, double b) { return abs(a - b) < EPS; }
void fast_stream() { std::ios_base::sync_with_stdio(0); }
class BIT {
private:
long long bit[MAX_N];
int n;
public:
BIT() {}
BIT(int sz) { init(sz); }
void init(int sz) {
n = sz;
memset(bit, 0, sizeof(bit));
}
long long sum(int i) {
long long s = 0;
while (i > 0) {
s += bit[i];
i -= i & -i;
}
return s;
}
void add(int i, long long x) {
while (i <= n) {
bit[i] += x;
i += i & -i;
}
}
};
BIT bit[7][11];
int N, M;
long long as[100010];
int main() {
fast_stream();
cin >> N;
for (int i = 0; i < N; i++) cin >> as[i];
for (int i = 0; i < 7; i++)
for (int j = 0; j < 11; j++) bit[i][j].init(N + 20);
for (int z = 2; z <= 6; z++) {
for (int i = 0; i < (z - 1) * 2; i++) {
for (int j = i; j < N; j++) {
int pos = j - i;
int pos2 = pos % (2 * (z - 1));
if (pos2 >= (z - 1)) pos2 = 2 * (z - 1) - pos2;
bit[z][i].add(pos + 1, as[j] * (pos2 + 1));
}
}
}
cin >> M;
for (int i = 0; i < M; i++) {
int t;
cin >> t;
if (t == 1) {
long long p, v;
cin >> p >> v;
p--;
for (int z = 2; z <= 6; z++) {
for (int i = 0; i < (z - 1) * 2; i++) {
if (p - i < 0) break;
int rp = (p - i);
int pos2 = rp % (2 * (z - 1));
if (pos2 >= (z - 1)) pos2 = 2 * (z - 1) - pos2;
long long sum = bit[z][i].sum(rp + 1) - bit[z][i].sum(rp);
bit[z][i].add(rp + 1, -sum + v * (pos2 + 1));
}
}
} else {
int l, r, z;
cin >> l >> r >> z;
l--;
r--;
int index = l % ((z - 1) * 2);
int rl = l - index;
int rr = r - index;
long long sum = bit[z][index].sum(rr + 1) - bit[z][index].sum(rl);
cout << sum << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 140005;
long long it[maxn * 2 + 10][6][12], bau[100005][6][12];
int to[maxn * 2 + 10], from[maxn * 2 + 10];
long long a[maxn];
int n, m;
void read() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%lld", &a[i]);
scanf("%d", &m);
}
void update(int pos, long long k, int zz, int co) {
int idx = from[pos];
while (idx) {
it[idx][zz][co] += k;
idx = to[idx];
}
}
long long ask(int l, int r, int l1, int r1, int idx, int zz, int co) {
int mid = l1 + r1;
mid /= 2;
long long ret = 0LL;
if (idx > maxn * 2) return 0LL;
if (l1 > r1 || l1 < 0 || r1 > 2 * n + 1) return 0LL;
if (l1 >= l && r1 <= r) {
ret = it[idx][zz][co];
} else if (l1 > r || r1 < l)
return 0LL;
else if (mid >= r) {
ret = ask(l, r, l1, mid, idx * 2, zz, co);
} else if (l > mid)
ret = ask(l, r, mid + 1, r1, idx * 2 + 1, zz, co);
else {
ret += ask(l, r, l1, mid, idx * 2, zz, co);
ret += ask(l, r, mid + 1, r1, idx * 2 + 1, zz, co);
}
return ret;
}
void make(int l, int r, int idx) {
if (l == r) {
from[l] = idx;
return;
}
to[idx * 2] = idx;
to[idx * 2 + 1] = idx;
int mid = (l + r) / 2;
make(l, mid, idx * 2);
make(mid + 1, r, idx * 2 + 1);
}
void init() {
long long tmp, add;
to[1] = 0;
make(1, n, 1);
for (int i = 2; i <= 6; ++i)
for (int k = 1; k <= 2 * i - 2; ++k) {
tmp = 1;
add = 1;
for (int j = k; j <= n; ++j) {
bau[j][i][k] = tmp;
if (tmp == i) {
add = -1;
} else if (tmp == 1) {
add = 1;
}
tmp += add;
}
}
for (int i = 2; i <= 6; ++i)
for (int k = 1; k <= i * 2 - 2; ++k) {
for (int j = 1; j <= n; ++j)
if (j >= k) {
tmp = bau[j][i][k];
update(j, a[j] * tmp, i, k);
}
}
}
void update_all(int l, long long x) {
long long tmp;
for (int i = 2; i <= 6; ++i)
for (int k = 1; k <= i * 2 - 2; ++k)
if (l >= k) {
tmp = bau[l][i][k];
update(l, x * tmp - a[l] * tmp, i, k);
}
a[l] = x;
}
long long query(int l, int r, int Z) {
long long ret = 0LL;
long long tmp = 1, pos = l, add = 1;
for (long long i = 1; i <= Z * 2 - 2; ++i)
if (bau[l][Z][i] == 1 && i <= l) {
ret += ask(l, r, 1, n, 1, Z, i);
return ret;
}
cout << "FUCK" << endl;
return 0;
}
void solve() {
int left, right, t, z;
long long x;
for (int i = 0; i < m; ++i) {
scanf("%d", &t);
if (t == 1) {
scanf("%d%lld", &left, &x);
update_all(left, x);
} else {
scanf("%d%d%d", &left, &right, &z);
printf("%lld\n", query(left, right, z));
}
}
}
int main() {
read();
init();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long t[100100][10];
const int N = 100005;
int a[100100];
int Z[30][10];
int ty[100100];
int x[100100];
int y[100100];
int z[100100];
int olda[100100];
long long ans[100100];
inline void modif(int p, int v, int val) {
for (int i = p; i <= N; i += (i & (-i))) t[i][v] += val;
}
inline long long fsum(int p, int v) {
long long res = 0;
for (int i = p; i > 0; i -= (i & (-i))) res += t[i][v];
return res;
}
int main() {
for (int z1 = (2); z1 < (7); ++z1) {
for (int i = (1); i < (30); ++i) {
int k = 2 * (z1 - 1);
if (i % k == 0)
Z[i - 1][z1] = 2;
else if (i % k <= z1)
Z[i - 1][z1] = i % k;
else
Z[i - 1][z1] = 2 * z1 - (i % k);
}
}
int n;
scanf("%d", &n);
for (int i = (0); i < (n); ++i) {
scanf("%d", &a[i]);
olda[i] = a[i];
}
int q;
scanf("%d", &q);
for (int i = (0); i < (q); ++i) {
int t1;
scanf("%d", &t1);
ty[i] = t1;
if (t1 == 1) scanf("%d%d", &x[i], &y[i]);
if (t1 == 2) scanf("%d%d%d", &x[i], &y[i], &z[i]);
}
for (int Z1 = (2); Z1 < (7); ++Z1) {
memset(t, 0, sizeof(t));
for (int i = (0); i < (n); ++i) a[i] = olda[i];
for (int i = (0); i < (n); ++i) {
int v = i % (2 * Z1 - 2);
modif(i + 1, v, a[i]);
}
for (int i = (0); i < (q); ++i) {
if (ty[i] == 1) {
int dif = y[i] - a[x[i] - 1];
modif(x[i], (x[i] - 1) % (2 * Z1 - 2), dif);
a[x[i] - 1] = y[i];
} else {
if (z[i] != Z1) continue;
int l = x[i];
int r = y[i];
int st = (l - 1) % (2 * Z1 - 2);
long long res = 0;
for (int j = (0); j < (2 * Z1 - 2); ++j) {
long long k = fsum(r, st) - fsum(l - 1, st);
k *= Z[j][Z1];
res += k;
st++;
if (st == 2 * Z1 - 2) st = 0;
}
ans[i] = res;
}
}
}
for (int i = (0); i < (q); ++i)
if (ty[i] == 2) printf("%I64d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 5;
int n, m;
long long aa[MAX];
long long t[7][10][MAX << 2];
int sz = 1;
inline void Modify(int x, int y, int k, long long val) {
k = k + sz - 1;
t[x][y][k] = val;
k >>= 1;
while (k) {
t[x][y][k] = t[x][y][k << 1] + t[x][y][(k << 1) + 1];
k >>= 1;
}
}
inline long long Query(int x, int y, int k, int l, int r, int a, int b) {
if (a > r || b < l) return 0ll;
if (a >= l && b <= r) return t[x][y][k];
return Query(x, y, k << 1, l, r, a, (a + b) >> 1) +
Query(x, y, (k << 1) + 1, l, r, ((a + b) >> 1) + 1, b);
}
inline int S(int i, int z) {
int mod = 2 * z - 2;
if (i % mod == 0) return 2;
if (i % mod <= z) return i % mod;
return 2 * z - i % mod;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%I64d", &aa[i]);
while (sz < n) sz <<= 1;
for (int i = 2; i <= 6; i++)
for (int j = 0; j < 2 * i - 2; j++)
for (int k = 1; k <= n; k++) Modify(i, j, k, aa[k] * S(j + k, i));
scanf("%d", &m);
while (m--) {
int op;
scanf("%d", &op);
if (op == 1) {
int k;
long long x;
scanf("%d%I64d", &k, &x);
aa[k] = x;
for (int i = 2; i <= 6; i++)
for (int j = 0; j < 2 * i - 2; j++)
Modify(i, j, k, aa[k] * S(j + k, i));
} else {
int l, r, z;
scanf("%d%d%d", &l, &r, &z);
int mod = 2 * z - 2;
printf("%I64d\n", Query(z, (1 - l + mod * n) % mod, 1, l, r, 1, sz));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long tree[12][5][100001];
int n, a[100001], m, s[12][5][100001];
inline int lowbit(int x) { return x & (-x); }
inline void add(long long *c, int p, long long v) {
for (int i = p; i <= n; i += lowbit(i)) c[i] += v;
}
inline long long sum(long long *c, int p) {
long long re = 0;
for (int i = p; i; i -= lowbit(i)) re += c[i];
return re;
}
inline int gets(int l, int i, int z) {
i += 2 * z - 2;
int q = (i - l + 1) % (2 * z - 2);
if (q == 0) return 2;
if (q < z) return q;
return 2 * z - q;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", a + i);
scanf("%d", &m);
for (int j = 2; j <= 6; ++j)
for (int k = 0; k < j * 2 - 2; ++k)
for (int i = 1; i <= n; ++i) {
s[k][j - 2][i] = gets(k, i, j);
add(tree[k][j - 2], i, (long long)(s[k][j - 2][i]) * a[i]);
}
for (; m--;) {
int t;
scanf("%d", &t);
if (t == 1) {
int p, v;
scanf("%d %d", &p, &v);
for (int i = 2; i <= 6; ++i)
for (int j = 0; j < i * 2 - 2; ++j)
add(tree[j][i - 2], p, (long long)(v - a[p]) * s[j][i - 2][p]);
a[p] = v;
} else {
int l, r, z;
scanf("%d %d %d", &l, &r, &z);
printf("%I64d\n", sum(tree[l % (2 * z - 2)][z - 2], r) -
sum(tree[l % (2 * z - 2)][z - 2], l - 1));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
long long a[100010];
long long tree[265000][30];
int v[100010][30];
int where(int l, int z) {
if (z == 2) {
if (l % 2 == 1)
return 0;
else
return 1;
} else if (z == 3) {
for (int i = 0; i < (2 * 3 - 2); i++) {
if (l % 4 == i) return 2 + i;
}
} else if (z == 4) {
for (int i = 0; i < (2 * 4 - 2); i++) {
if (l % 6 == i) return 6 + i;
}
} else if (z == 5) {
for (int i = 0; i < (2 * 5 - 2); i++) {
if (l % 8 == i) return 12 + i;
}
} else if (z == 6) {
for (int i = 0; i < (2 * 6 - 2); i++) {
if (l % 10 == i) return 20 + i;
}
}
}
void build(int id, int l, int r, int t) {
if (l == r) {
tree[id][t] = v[l][t] * a[l - 1];
return;
}
int h = (l + r) >> 1;
build(2 * id, l, h, t);
build(2 * id + 1, h + 1, r, t);
tree[id][t] = tree[2 * id][t] + tree[2 * id + 1][t];
}
void update(int id, int l, int r, int lt, int rt, int val, int t) {
if (l > rt || r < lt) return;
if (l >= lt && r <= rt) {
tree[id][t] = (long long)v[l][t] * val;
return;
}
int h = (l + r) >> 1;
update(2 * id, l, h, lt, rt, val, t);
update(2 * id + 1, h + 1, r, lt, rt, val, t);
tree[id][t] = tree[2 * id][t] + tree[2 * id + 1][t];
}
long long get(int id, int l, int r, int lt, int rt, int t) {
if (l > rt || r < lt) return 0;
if (l >= lt && r <= rt) {
return tree[id][t];
}
int h = (l + r) >> 1;
long long sum = 0;
sum += get(2 * id, l, h, lt, rt, t);
sum += get(2 * id + 1, h + 1, r, lt, rt, t);
return sum;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
scanf("%I64d", a + i);
}
for (int i = 2; i <= 6; i++) {
for (int j = 1; j <= (2 * i - 2); j++) {
int h = where(j, i);
for (int k = j; k <= n; k++) {
if ((k - j + 1) % (2 * (i - 1)) == 0)
v[k][h] = 2;
else if ((k - j + 1) % (2 * (i - 1)) > 0 &&
(k - j + 1) % (2 * (i - 1)) <= i)
v[k][h] = (k - j + 1) % (2 * (i - 1));
else
v[k][h] = 2 * i - (k - j + 1) % (2 * (i - 1));
}
build(1, 1, n, h);
}
}
int q;
cin >> q;
for (int i = 0; i < q; i++) {
int type;
scanf("%d", &type);
if (type == 1) {
int p, val;
scanf("%d%d", &p, &val);
for (int ii = 2; ii <= 6; ii++) {
for (int j = 1; j <= (2 * ii - 2); j++) {
int h = where(j, ii);
if (p >= j) update(1, 1, n, p, p, val, h);
}
}
} else {
int l, r, z;
scanf("%d%d%d", &l, &r, &z);
int h = where(l, z);
printf("%I64d\n", get(1, 1, n, l, r, h));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = int(1e5) + 10;
const long long oo = (1LL << 60);
int N;
struct bit {
long long T[MAX];
void put(int p, long long v) {
for (; p <= N; p += p & -p) T[p] += v;
}
long long get(int p) {
long long sum = 0;
for (; p; p -= p & -p) sum += T[p];
return sum;
}
};
bit A[7][11];
long long a[MAX];
int mod(int x, int m) {
x %= m;
return x < 0 ? x + m : x;
}
int func(int r, int z) {
if (r == 0) return 2;
if (r <= z) return r;
return 2 * z - r;
}
int main() {
scanf("%d", &N);
for (int i = 1; i <= N; i++) scanf("%I64d", a + i);
for (int z = 2; z <= 6; z++)
for (int r = 0; r < 2 * (z - 1); r++)
for (int i = 1; i <= N; i++) {
int rr = mod(i - 1 + r, 2 * (z - 1));
long long v = a[i] * func(rr, z);
A[z][r].put(i, v);
}
int Q;
scanf("%d", &Q);
int typ, p, v, lo, hi, r, rr, z;
while (Q--) {
scanf("%d", &typ);
if (typ == 1) {
scanf("%d%d", &p, &v);
for (z = 2; z <= 6; z++)
for (r = 0; r < 2 * (z - 1); r++) {
rr = mod(p - 1 + r, 2 * (z - 1));
long long tmp = (v - a[p]) * func(rr, z);
A[z][r].put(p, tmp);
}
a[p] = v;
} else {
scanf("%d%d%d", &lo, &hi, &z);
r = mod(2 - lo, 2 * (z - 1));
long long ans = A[z][r].get(hi) - A[z][r].get(lo - 1);
printf("%I64d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, size_t size>
class FenwickTree {
size_t pow2;
T* tree;
T SUM(int i) {
T res = T();
for (; i; i -= i & (-i)) res += tree[i];
return res;
}
public:
FenwickTree() {
for (pow2 = 1; pow2 < size; pow2 <<= 1) continue;
tree = new T[pow2];
}
void add(int p, const T& x) {
for (int i = p; i <= pow2; i += i & (-i)) tree[i] += x;
}
T query(int l, int r) { return SUM(--r) - SUM(--l); }
};
const size_t MAX_N = 1e5 + 5;
FenwickTree<long long, MAX_N> segtree[7][11];
long long arr[MAX_N];
inline long long z(int i, int z) {
if (i == 2 * z - 2) return 2;
if (i % (2 * z - 2) <= z) return i % (2 * z - 2);
return 2 * z - i % (2 * z - 2);
}
inline void modify(int i, long long a) {
for (int j = 2, t = 2; j <= 6; j++, t += 2)
for (int k = 0; k < t; k++) {
segtree[j][(k + t * 60000 - i) % t].add(i, (a - arr[i]) * z(k + 1, j));
}
arr[i] = a;
}
int main() {
int n, m, t, p, v, l, r, z, a;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a);
modify(i, a);
}
scanf("%d", &m);
while (m-- && scanf("%d", &t) == 1)
if (t == 1) {
scanf("%d%d", &p, &v);
modify(p, v);
} else {
scanf("%d%d%d", &l, &r, &z);
t = 2 * z - 2;
printf("%I64d\n", segtree[z][(t * 60000 - l) % t].query(l, r + 1));
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct FenwickTree {
long long n;
vector<long long> ft;
FenwickTree() : n(), ft() {}
FenwickTree(long long n) : n(n) { ft.assign(n + 5, 0); }
void update(long long p, long long val) {
for (p++; p < n; p += p & (-p)) ft[p] += val;
}
long long query(long long p) {
long long res = 0;
for (p++; p; p -= p & (-p)) res += ft[p];
return res;
}
long long query(long long l, long long r) { return query(r) - query(l - 1); }
};
long long n, A[100022];
long long S[7][100022];
FenwickTree ft[7][11];
signed main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
for (long long k = 2; k < 7; k++) {
for (long long i = 0; i < 100022; i++) {
long long x = (i + 1) % (2 * (k - 1));
if (x == 0)
S[k][i] = 2;
else if (x <= k)
S[k][i] = x;
else
S[k][i] = 2 * k - x;
}
for (long long i = 0; i < 2 * (k - 1); i++) {
ft[k][i] = FenwickTree(100022);
}
}
cin >> n;
for (long long i = 0; i < n; i++) {
cin >> A[i];
for (long long z = 2; z < 7; z++) {
for (long long k = 0; k < 2 * (z - 1); k++) {
ft[z][k].update(i, A[i] * S[z][i + k]);
}
}
}
long long m;
cin >> m;
while (m--) {
long long typ;
cin >> typ;
if (typ == 1) {
long long p, v;
cin >> p >> v;
p--;
for (long long z = 2; z < 7; z++) {
for (long long k = 0; k < 2 * (z - 1); k++) {
ft[z][k].update(p, -A[p] * S[z][p + k]);
ft[z][k].update(p, v * S[z][p + k]);
}
}
A[p] = v;
} else {
long long l, r, z;
cin >> l >> r >> z;
l--;
r--;
long long k = 2 * (z - 1);
cout << ft[z][(k - l % k) % k].query(l, r) << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
int d[4][2] = {1, 0, -1, 0, 0, 1, 0, -1};
long long sum[maxn << 2][7][11];
int a[maxn], val[maxn << 2], xs[7][12], sz[7] = {0, 0, 2, 4, 6, 8, 10};
void pushup(int rt, int L, int R) {
int mid = (L + R) >> 1;
for (int i = 2; i <= 6; i++)
for (int j = 1; j <= sz[i]; j++)
sum[rt][i][j] = sum[rt << 1][i][j] +
sum[(rt << 1) + 1][i][((j + mid - L + 1) % sz[i] == 0)
? sz[i]
: ((j + mid - L + 1) % sz[i])];
}
void build(int rt, int L, int R) {
if (L == R) {
val[L] = a[L];
for (int i = 2; i <= 6; i++)
for (int j = 1; j <= sz[i]; j++) sum[rt][i][j] = 1LL * val[L] * xs[i][j];
return;
}
int mid = (L + R) >> 1;
build(rt << 1, L, mid);
build((rt << 1) + 1, mid + 1, R);
pushup(rt, L, R);
}
void update(int rt, int L, int R, int pos, int v) {
if (L == R) {
val[L] = v;
for (int i = 2; i <= 6; i++)
for (int j = 1; j <= sz[i]; j++) sum[rt][i][j] = 1LL * val[L] * xs[i][j];
return;
}
int mid = (L + R) >> 1;
if (pos <= mid)
update(rt << 1, L, mid, pos, v);
else
update((rt << 1) + 1, mid + 1, R, pos, v);
pushup(rt, L, R);
}
long long query(int rt, int L, int R, int l, int r, int z) {
if (l <= L && r >= R) {
return sum[rt][z]
[((L - l + 1) % sz[z] == 0) ? sz[z] : ((L - l + 1) % sz[z])];
}
int mid = (L + R) >> 1;
if (r <= mid)
return query(rt << 1, L, mid, l, r, z);
else if (l >= mid + 1)
return query((rt << 1) + 1, mid + 1, R, l, r, z);
else
return query(rt << 1, L, mid, l, r, z) +
query((rt << 1) + 1, mid + 1, R, l, r, z);
}
int main() {
xs[2][1] = 1, xs[2][2] = 2;
xs[3][1] = 1, xs[3][2] = 2;
xs[3][3] = 3, xs[3][4] = 2;
xs[4][1] = 1, xs[4][2] = 2;
xs[4][3] = 3, xs[4][4] = 4;
xs[4][5] = 3, xs[4][6] = 2;
xs[5][1] = 1, xs[5][2] = 2;
xs[5][3] = 3, xs[5][4] = 4;
xs[5][5] = 5, xs[5][6] = 4;
xs[5][7] = 3, xs[5][8] = 2;
xs[6][1] = 1, xs[6][2] = 2;
xs[6][3] = 3, xs[6][4] = 4;
xs[6][5] = 5, xs[6][6] = 6;
xs[6][7] = 5, xs[6][8] = 4, xs[6][9] = 3;
xs[6][10] = 2;
int n, m;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &(a[i]));
build(1, 1, n);
scanf("%d", &m);
while (m--) {
int op, l, r, z, p, v;
scanf("%d", &op);
if (op == 1) {
scanf("%d%d", &p, &v);
update(1, 1, n, p, v);
} else {
scanf("%d%d%d", &l, &r, &z);
printf("%I64d\n", query(1, 1, n, l, r, z));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, aa, b, c, d;
long long a[100001];
long long z(int s, int x) {
long long k = (s % (2 * (x - 1)));
if (!k) return 2ll;
if (k <= x) return k;
return 2ll * x - k;
}
struct fenvick_tree {
long long f[100001];
void update(int r, long long s) {
for (int i = r; i <= n; i = (i | (i + 1))) f[i] += s;
}
long long sum(int r) {
long long res = 0ll;
for (int i = r; i > 0; i = (i & (i + 1)) - 1) res += f[i];
return res;
}
long long getsum(int l, int r) { return sum(r) - sum(l - 1); }
} fen[12][12];
void add(int ind, long long s) {
a[ind] += s;
for (int i = 2; i <= 6; ++i)
for (int j = 1; j <= 2 * (i - 1); ++j)
fen[i][j].update(ind, s * z(j + ind - 1, i));
}
long long query(int l, int r, int z) {
int ans = 0;
for (int i = 1; i <= 2 * (z - 1); ++i)
if ((i + l - 1) % (2 * (z - 1)) == 1) {
ans = i;
break;
}
return fen[z][ans].getsum(l, r);
}
int main() {
scanf("%d", &n);
long long w;
for (int i = 1; i <= n; ++i) {
cin >> w;
add(i, w);
}
scanf("%d", &m);
while (m--) {
cin >> aa >> b >> c;
if (aa == 1)
add(b, c - a[b]);
else {
cin >> d;
cout << query(b, c, d) << '\n';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 101000;
int n, m, x[N], px, val, nrel[3 * N], py, poo;
long long sum[7][11][3 * N];
void update(int nod, int pozx, int pozy) {
int i, j;
if (pozx == pozy) {
nrel[nod] = 1;
for (i = 2; i <= 6; ++i)
for (j = 0; j < 2 * i - 2; ++j) {
if (!j)
sum[i][j][nod] = 1LL * 2 * val;
else if (j < i)
sum[i][j][nod] = 1LL * j * val;
else
sum[i][j][nod] = 1LL * (2 * i - j) * val;
}
return;
}
int mid = (pozx + pozy) / 2;
if (mid < px)
update(2 * nod + 1, mid + 1, pozy);
else
update(2 * nod, pozx, mid);
nrel[nod] = nrel[2 * nod + 1] + nrel[2 * nod];
for (i = 2; i <= 6; ++i)
for (j = 0; j < 2 * i - 2; ++j)
sum[i][j][nod] = sum[i][j][2 * nod] +
sum[i][(j + nrel[2 * nod]) % (2 * i - 2)][2 * nod + 1];
}
long long query(int nod, int pozx, int pozy, int zig, int po) {
if (px <= pozx && pozy <= py) return sum[zig][po][nod];
int mid = (pozx + pozy) / 2;
if (mid < px) return query(2 * nod + 1, mid + 1, pozy, zig, po);
if (mid >= py) return query(2 * nod, pozx, mid, zig, po);
return query(2 * nod, pozx, mid, zig, po) +
query(2 * nod + 1, mid + 1, pozy, zig, (mid - px + 2) % (2 * zig - 2));
}
int main() {
int i, op, zig;
cin >> n;
for (i = 1; i <= n; ++i) {
cin >> x[i];
px = i;
val = x[i];
update(1, 1, n);
}
cin >> m;
for (i = 1; i <= m; ++i) {
cin >> op;
if (op == 1) {
cin >> px >> val;
update(1, 1, n);
} else {
cin >> px >> py >> zig;
cout << query(1, 1, n, zig, 1) << "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long fpm(long long b, long long e, long long m) {
long long t = 1;
for (; e; e >>= 1, b = b * b % m) e & 1 ? t = t * b % m : 0;
return t;
}
template <class T>
inline bool chkmin(T &a, T b) {
return a < b ? a = b, true : false;
}
template <class T>
inline bool chkmax(T &a, T b) {
return a > b ? a = b, true : false;
}
template <class T>
inline T sqr(T x) {
return x * x;
}
template <class edge>
struct Graph {
vector<vector<edge> > adj;
Graph(int n) {
adj.clear();
adj.resize(n + 5);
}
void adde(int s, edge e) { adj[s].push_back(e); }
typename vector<edge>::iterator operator[](int t) { return adj[t].begin(); }
};
const int maxn = 110000;
int n;
long long bit[33][maxn];
int a[maxn];
void modify(long long *bit, int x, int v) {
for (; x <= n; x += x & -x) bit[x] += v;
}
long long query(long long *bit, int x) {
long long t = 0;
for (; x; x &= x - 1) t += bit[x];
return t;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
for (int j = 2; j <= 6; ++j)
modify(bit[(((j)-2) * ((j)-1) + ((((i)-1) % (2 * (j)-2))))], i, a[i]);
}
int m, cmd, l, r, z;
cin >> m;
for (; m--;) {
cin >> cmd;
if (cmd == 1) {
int p, v;
cin >> p >> v;
for (int j = 2; j <= 6; ++j)
modify(bit[(((j)-2) * ((j)-1) + ((((p)-1) % (2 * (j)-2))))], p,
v - a[p]);
a[p] = v;
} else {
cin >> l >> r >> z;
long long ans = 0;
for (int k = 0; k < 2 * z - 2; ++k) {
int nk = (l - 1 + k) % (2 * z - 2);
ans += (query(bit[(((z)-2) * ((z)-1) + (nk))], r) -
query(bit[(((z)-2) * ((z)-1) + (nk))], l - 1)) *
(k >= z ? (2 * z - 1 - k) : (k + 1));
}
cout << ans << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int x, y;
long long s[7][10];
};
int n, m, x, y, z, op;
int len[10];
node T[270000];
int Z(int x, int y) {
if (y < x) return y + 1;
return len[x] - y + 1;
}
void build(int d, int x, int y) {
T[d].x = x;
T[d].y = y;
int l, r, w;
l = d << 1;
r = l + 1;
w = y - x + 1;
if (x != y) {
build(l, x, (x + y) / 2);
build(r, (x + y) / 2 + 1, y);
for (int i = (2); i <= (6); i++)
for (int j = (0); j < (len[i]); j++)
T[d].s[i][j] = T[l].s[i][j] + T[r].s[i][(j + (w + 1) / 2) % len[i]];
} else {
scanf("%d", &w);
for (int i = (2); i <= (6); i++)
for (int j = (0); j < (len[i]); j++) T[d].s[i][j] = w * 1LL * Z(i, j);
}
}
void update(int d, int x, int v) {
if (T[d].x == T[d].y) {
for (int i = (2); i <= (6); i++)
for (int j = (0); j < (len[i]); j++) T[d].s[i][j] = v * 1LL * Z(i, j);
} else {
int l = d * 2, r = l + 1, w = T[d].y - T[d].x + 1;
if (x <= T[l].y)
update(l, x, v);
else
update(r, x, v);
for (int i = (2); i <= (6); i++)
for (int j = (0); j < (len[i]); j++)
T[d].s[i][j] = T[l].s[i][j] + T[r].s[i][(j + (w + 1) / 2) % len[i]];
}
}
long long query(int d, int x, int y, int z, int t) {
if (x <= T[d].x && y >= T[d].y) {
return T[d].s[z][t];
} else {
long long res = 0;
int l = d * 2, r = l + 1, w = T[d].y - T[d].x + 1;
if (x < T[d].x) x = T[d].x;
if (y > T[d].y) y = T[d].y;
if (x <= T[l].y) res += query(l, x, y, z, t);
if (y > T[l].y) {
if (x >= T[r].x)
res += query(r, x, y, z, t);
else
res += query(r, x, y, z, (t + T[r].x - x) % len[z]);
}
return res;
}
}
int main() {
for (int i = (2); i <= (6); i++) len[i] = (i - 1) * 2;
scanf("%d", &n);
build(1, 1, n);
scanf("%d", &m);
while (m--) {
scanf("%d%d%d", &op, &x, &y);
if (op == 1) update(1, x, y);
if (op == 2) {
scanf("%d", &z);
printf("%I64d\n", query(1, x, y, z, 0));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int a[100011], zig[7][100011];
long long fen[7][14][100011];
void upd(long long *f, int pos, long long x) {
for (int i = pos; i <= n; i += i & (-i)) f[i] += x;
}
long long sum(long long *f, int pos) {
long long res = 0;
for (int i = pos; i > 0; i -= i & (-i)) res += f[i];
return res;
}
long long get(long long *f, int l, int r) { return sum(f, r) - sum(f, l - 1); }
long long getf(int k, int z) {
if (k == 0) return 2;
if (k > 0 && k <= z) return k;
if (k > z) return 2 * z - k;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int z = 2; z <= 6; z++) {
for (int i = 1; i <= n + 10; i++) {
int k = i % (2 * (z - 1));
int j = getf(k, z);
k = (i - 1) % (2 * z - 2);
zig[z][i] = j;
upd(fen[z][k], i, a[i]);
}
}
cin >> m;
for (int i = 0; i < m; i++) {
int t;
cin >> t;
if (t == 1) {
int p, v;
cin >> p >> v;
for (int j = 2; j <= 6; j++) {
int k = (p - 1) % (2 * j - 2);
long long cur = get(fen[j][k], p, p);
upd(fen[j][k], p, v - cur);
}
a[p] = v;
} else {
int l, r, z;
cin >> l >> r >> z;
long long res = 0;
int kf = (l - 1) % (2 * (z - 1));
kf = kf + 1;
kf += 2 * z - 2 * kf;
for (int j = 0; j < 2 * (z - 1); j++) {
int koef = zig[z][kf + j];
res += get(fen[z][j], l, r) * koef;
}
cout << res << "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int getSi(int i, int z) {
int t = i % ((z - 1) << 1);
if (t == 0)
return 2;
else if (t <= z)
return t;
else
return (z << 1) - t;
}
int seq[100005];
struct node {
int l, r;
long long sum[7][7 << 1];
};
struct node segTree[100005 * 3];
inline int leftChild(int i) { return i << 1; }
inline int rightChild(int i) { return (i << 1) | 1; }
void build(int index, int lb, int rb) {
if (lb > rb) {
return;
}
segTree[index].l = lb;
segTree[index].r = rb;
if (lb == rb) {
int num;
scanf("%d", &num);
seq[lb] = num;
for (int i = 2; i < 7; i++) {
int m = ((i - 1) << 1);
for (int j = 1; j <= m; j++) {
if (lb < j)
segTree[index].sum[i][j] = 0;
else
segTree[index].sum[i][j] = (long long)num * getSi((lb - j + 1), i);
}
}
return;
}
int mid = ((lb + rb) >> 1);
build(leftChild(index), lb, mid);
build(rightChild(index), mid + 1, rb);
for (int i = 2; i < 7; i++) {
int m = ((i - 1) << 1);
for (int j = 1; j <= m; j++) {
segTree[index].sum[i][j] = segTree[leftChild(index)].sum[i][j] +
segTree[rightChild(index)].sum[i][j];
}
}
}
void update(int index, int pos, int oldvalue, int newvalue) {
for (int i = 2; i < 7; i++) {
int m = ((i - 1) << 1);
for (int j = 1; j <= m; j++) {
if (pos >= j) {
segTree[index].sum[i][j] +=
(long long)(newvalue - oldvalue) * getSi((pos - j + 1), i);
}
}
}
if (segTree[index].l == segTree[index].r) {
return;
}
int mid = ((segTree[index].l + segTree[index].r) >> 1);
if (pos <= mid) {
update(leftChild(index), pos, oldvalue, newvalue);
} else {
update(rightChild(index), pos, oldvalue, newvalue);
}
}
long long query(int index, int lb, int rb, int z, int startPos) {
if (segTree[index].l >= lb && segTree[index].r <= rb)
return segTree[index].sum[z][startPos];
int mid = ((segTree[index].l + segTree[index].r) >> 1);
if (rb <= mid) return query(leftChild(index), lb, rb, z, startPos);
if (lb > mid) return query(rightChild(index), lb, rb, z, startPos);
return query(leftChild(index), lb, mid, z, startPos) +
query(rightChild(index), mid + 1, rb, z, startPos);
}
long long solve(int lb, int rb, int z) {
int startPos = lb % ((z - 1) << 1);
if (startPos == 0) startPos = ((z - 1) << 1);
return query(1, lb, rb, z, startPos);
}
int main() {
int n, m;
scanf("%d", &n);
build(1, 1, n);
scanf("%d", &m);
int t, l, r, z;
for (int i = 0; i < m; i++) {
scanf("%d%d%d", &t, &l, &r);
if (t == 1) {
update(1, l, seq[l], r);
seq[l] = r;
} else {
scanf("%d", &z);
cout << solve(l, r, z) << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a, b, c, d[100007], n, m, T[5][100007 << 2][12], R[100007 << 2], type,
ans, sm;
void combine(long long z, long long v) {
long long tr = R[v << 1] % (((z + 2) << 1) - 2);
for (long long i = 0; i < ((z + 2) << 1) - 2; i++)
T[z][v][i] =
T[z][v << 1][i] +
T[z][v << 1 | 1][(i - tr + (4 * z + 8 - 4)) % (((z + 2) << 1) - 2)];
}
void form_tree(long long l, long long r, long long v, long long z) {
if (l == r) {
R[v] = 1;
T[z][v][0] = d[l];
return;
}
form_tree(l, ((l + r) >> 1), v << 1, z);
form_tree(((l + r) >> 1) + 1, r, v << 1 | 1, z);
R[v] = R[v << 1] + R[v << 1 | 1];
combine(z, v);
}
void upd(long long x, long long y, long long l, long long r, long long v,
long long z) {
if (l == r) {
T[z][v][0] = y;
return;
}
if (x <= ((l + r) >> 1))
upd(x, y, l, ((l + r) >> 1), v << 1, z);
else
upd(x, y, ((l + r) >> 1) + 1, r, v << 1 | 1, z);
combine(z, v);
}
long long bul(long long x, long long y, long long l, long long r, long long v,
long long z, long long w) {
if (y < l || r < x) return 0;
if (x <= l && r <= y) {
sm += r - l + 1;
return T[z][v][(w - ((sm - (r - l + 1)) % (((z + 2) << 1) - 2)) +
(4 * z + 8 - 4)) %
(((z + 2) << 1) - 2)];
}
return (bul(x, y, l, ((l + r) >> 1), v << 1, z, w) +
bul(x, y, ((l + r) >> 1) + 1, r, v << 1 | 1, z, w));
}
int main() {
scanf("%lld", &n);
for (long long i = 1; i <= n; i++) scanf("%lld", &d[i]);
for (long long i = 0; i < 5; i++) form_tree(1, n, 1, i);
scanf("%lld", &m);
while (m--) {
scanf("%lld%lld%lld", &type, &a, &b);
if (type == 2) {
scanf("%lld", &c);
ans = 0;
for (long long i = 1; i <= c; i++) {
sm = 0;
ans += (bul(a, b, 1, n, 1, c - 2, i - 1) * i);
}
long long cn = 1;
for (int i = (c << 1) - 2; i > c; i--) {
cn++;
sm = 0;
ans += (bul(a, b, 1, n, 1, c - 2, i - 1) * cn);
}
printf("%lld\n", ans);
} else {
for (long long i = 0; i < 5; i++) upd(a, b, 1, n, 1, i);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, q;
int a[100048];
long long c[12][12][100048];
void update(int x, int y, int pos, int delta) {
while (pos <= n) {
c[x][y][pos] += delta;
pos += pos & (-pos);
}
}
long long query(int x, int y, int pos) {
long long res = 0;
while (pos > 0) {
res += c[x][y][pos];
pos -= pos & (-pos);
}
return res;
}
int main() {
int i, j, m, t, x, y, z, x1, y1, d, p;
long long ans, coef;
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
for (m = 2; m <= 10; m += 2)
for (i = 1; i <= n; i++) update(m, i % m, i, a[i]);
scanf("%d", &q);
for (i = 1; i <= q; i++) {
scanf("%d%d%d", &t, &x, &y);
if (t == 1) {
d = y - a[x];
a[x] = y;
for (m = 2; m <= 10; m += 2) update(m, x % m, x, d);
} else {
scanf("%d", &z);
ans = 0;
for (j = 0; j <= 2 * (z - 1) - 1; j++) {
coef = (j == 0) ? 2 : min(j, 2 * z - j);
ans += coef * (query(2 * (z - 1), (x + j - 1) % (2 * (z - 1)), y) -
query(2 * (z - 1), (x + j - 1) % (2 * (z - 1)), x - 1));
}
printf("%I64d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int n, q, tipo;
long long int Z[7][13][100003];
long long int BIT[7][13][100003];
long long int v[100003];
void update(long long int b, long long int s, long long int u,
long long int x) {
for (long long int i = u; i <= n; i += i & -i) BIT[b][s][i] += x;
}
long long int query(long long int b, long long int s, long long int u) {
long long int res = 0;
for (long long int i = u; i; i -= i & -i) res += BIT[b][s][i];
return res;
}
int main() {
for (long long int z = 2; z <= 6; z++) {
for (long long int i = 1; i < 100003; i++) {
long long int &S = Z[z][0][i];
if ((i % (2 * z - 2)) == 0)
S = 2;
else if (0 < (i % (2 * z - 2)) and (i % (2 * z - 2)) <= z)
S = (i % (2 * z - 2));
else
S = 2 * z - (i % (2 * z - 2));
}
for (long long int s = 1; s < 13; s++) {
for (long long int i = 1; i < 100002; i++)
Z[z][s][i] = Z[z][s - 1][i + 1];
Z[z][s][100002] = Z[z][s][100001 % (2 * z - 2) + 1];
}
}
memset(BIT, 0, sizeof(BIT));
cin >> n;
for (long long int i = 1; i <= n; i++) {
long long int t;
cin >> t;
v[i] = t;
for (long long int z = 2; z <= 6; z++)
for (long long int s = 0; s < 13; s++)
update(z, s, i, (long long int)t * (long long int)Z[z][s][i]);
}
cin >> q;
long long int aimprimir = 1;
while (q--) {
cin >> tipo;
if (tipo == 1) {
long long int p, val;
cin >> p >> val;
v[p] = val;
for (long long int z = 2; z <= 6; z++)
for (long long int s = 0; s < 13; s++) {
long long int atu = query(z, s, p) - query(z, s, p - 1);
long long int qro = (long long int)val * (long long int)Z[z][s][p];
update(z, s, p, qro - atu);
}
} else {
long long int l, r, z;
cin >> l >> r >> z;
long long int s;
for (s = 0; s < 13; s++)
if (Z[z][s][l] == 1 and Z[z][s][l + 1] == 2) break;
if (s == 13) assert(1 == 2);
long long int resp = query(z, s, r) - query(z, s, l - 1);
cout << resp << endl;
aimprimir++;
}
}
return 0;
}
|
#include <bits/stdc++.h>
const int maxn = 100005;
long long sgt[maxn * 4][5][10];
int n, m;
void update(int flag, int lower, int upper, int mid) {
for (int i = 2; i <= 6; ++i) {
for (int j = 0; j < 2 * i - 2; ++j) {
sgt[flag][i - 2][j] =
sgt[flag * 2][i - 2][j] +
sgt[flag * 2 + 1][i - 2][(j + mid - lower + 1) % (2 * i - 2)];
}
}
}
void insert(int flag, int lower, int upper, int pos, int key) {
if (lower == upper) {
for (int i = 0; i < 5; ++i) sgt[flag][i][1] = key;
return;
}
int mid = (lower + upper) >> 1;
if (pos <= mid)
insert(flag * 2, lower, mid, pos, key);
else
insert(flag * 2 + 1, mid + 1, upper, pos, key);
update(flag, lower, upper, mid);
}
long long query(int flag, int lower, int upper, int st, int ed, int z,
int dep) {
if (lower == st && upper == ed) return sgt[flag][z - 2][dep];
int mid = (lower + upper) >> 1;
if (ed <= mid)
return query(flag * 2, lower, mid, st, ed, z, dep);
else if (st > mid)
return query(flag * 2 + 1, mid + 1, upper, st, ed, z, dep);
else
return query(flag * 2, lower, mid, st, mid, z, dep) +
query(flag * 2 + 1, mid + 1, upper, mid + 1, ed, z,
(dep + mid - st + 1) % (2 * z - 2));
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
int x;
scanf("%d", &x);
insert(1, 1, n, i, x);
}
scanf("%d", &m);
while (m--) {
int x, y, z, d;
scanf("%d", &d);
if (d == 1) {
scanf("%d%d", &x, &y);
insert(1, 1, n, x, y);
} else {
scanf("%d%d%d", &x, &y, &z);
long long ans = query(1, 1, n, x, y, z, 0) * 2;
for (int i = 1; i < 2 * z - 2; ++i) {
if (i <= z)
ans += query(1, 1, n, x, y, z, i) * i;
else
ans += query(1, 1, n, x, y, z, i) * (2 * z - i);
}
printf("%I64d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 100500;
const int maxn = 100500;
char zig[maxn][7][10];
int n;
void genZigs() {
int n = maxn;
for (int z = (int)(2); z <= (int)(6); z++) {
for (int i = 0; i < (int)(n); i++) {
int t = (i + 1) % (2 * z - 2);
if (t == 0)
zig[i][z][0] = 2;
else if (t <= z)
zig[i][z][0] = t;
else
zig[i][z][0] = 2 * z - t;
}
for (int p = 1; p < 2 * z - 2; p++)
for (int i = (int)(p); i <= (int)(n - 1); i++)
zig[i][z][p] = zig[i - p][z][0];
}
}
long long fen[maxn][7][20];
void add(int i, long long x, int b, int c) {
for (; i < maxn; i |= (i + 1)) fen[i][b][c] += x;
}
long long get(int i, int b, int c) {
long long s = 0;
for (; i >= 0; i = (i & (i + 1)) - 1) s += fen[i][b][c];
return s;
}
long long get(int l, int r, int b, int c) {
return get(r, b, c) - (l ? get(l - 1, b, c) : 0);
}
int a[maxn];
void mset(int i, int x) {
for (int z = (int)(2); z <= (int)(6); z++)
for (int p = (int)(0); p <= (int)(z * 2 - 3); p++)
add(i, (long long)(x - a[i]) * (long long)zig[i][z][p], z, p);
a[i] = x;
}
long long mget(int l, int r, int z) { return get(l, r, z, l % (z * 2 - 2)); }
void solve() {
cin >> n;
genZigs();
for (int i = 0; i < (int)(n); i++) {
int x;
cin >> x;
mset(i, x);
}
int m;
cin >> m;
for (int i = 0; i < (int)(m); i++) {
int t;
cin >> t;
if (t == 1) {
int p, v;
cin >> p >> v;
mset(p - 1, v);
} else {
int l, r, z;
cin >> l >> r >> z;
cout << mget(l - 1, r - 1, z) << "\n";
}
}
}
void gen() {
freopen("input.txt", "w", stdout);
int n = 100000;
cout << n << endl;
for (int i = 0; i < (int)(n); i++) cout << rand() << " ";
cout << endl;
cout << n << endl;
for (int i = 0; i < (int)(n); i++) {
if (rand() % 2) {
cout << 1 << " " << rand() % n + 1 << " " << rand() << endl;
} else {
int l = rand() % n, r = rand() % n;
if (l > r) swap(l, r);
cout << 2 << " " << l + 1 << " " << r + 1 << " " << rand() % 5 + 2
<< endl;
}
}
exit(0);
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, ar[1 << 20];
long long t[7][14][200000];
int tests;
int Z[20], coef[20][20];
int ps, val;
long long sum(int a, int b, int r) {
long long res = 0;
for (; r >= 0; r = (r & (r + 1)) - 1) res += t[a][b][r];
return res;
}
void inc(int a, int b, int i, long long val) {
for (; i < 200000; i = (i | (i + 1))) t[a][b][i] += val;
}
long long sum(int a, int b, int l, int r) {
return sum(a, b, r) - sum(a, b, l - 1);
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> ar[i];
}
for (int i = 1; i <= 6; i++) Z[i] = i * 2 - 2;
for (int z = 2; z <= 6; z++) {
for (int j = 1; j <= z * 2 - 2; j++) {
coef[z][j - 1] = j % (2 * z - 2);
if (coef[z][j - 1] > z) coef[z][j - 1] = 2 * z - coef[z][j - 1];
if (coef[z][j - 1] == 0) coef[z][j - 1] = 2;
}
}
for (int i = 0; i < n; i++) {
for (int z = 2; z <= 6; z++)
for (int rem = 0; rem < 2 * z - 2; rem++) {
int trem = i + 2 * z - 2 - rem;
trem %= (2 * z - 2);
inc(z, rem, i, ar[i] * 1ll * coef[z][trem]);
}
}
cin >> tests;
for (; tests; --tests) {
int tp;
cin >> tp;
if (tp == 2) {
int l, r, z;
cin >> l >> r >> z;
--l;
--r;
long long ans = 0;
ans = sum(z, l % (z * 2 - 2), l, r);
cout << ans << endl;
} else {
cin >> ps >> val;
--ps;
int dif = val - ar[ps];
ar[ps] = val;
for (int z = 2; z <= 6; z++) {
for (int rem = 0; rem < (z * 2 + 2); rem++) {
int trem = ps + z * 2 - 2 - rem;
trem %= (z * 2 - 2);
inc(z, rem, ps, dif * 1ll * coef[z][trem]);
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 100;
long long sum[35][N << 2];
long long val[N], mul[35][N];
int n;
inline void pushup(int rt, long long *sum) {
sum[rt] = sum[rt << 1] + sum[rt << 1 | 1];
}
void build(int l, int r, int rt, long long sum[], long long mul[]) {
if (l == r) {
sum[rt] = val[l] * mul[l];
return;
}
int m = (l + r) >> 1;
build(l, m, rt << 1, sum, mul);
build(m + 1, r, rt << 1 | 1, sum, mul);
pushup(rt, sum);
}
void update(int pos, long long x, int l, int r, int rt, long long sum[],
long long mul[]) {
if (l == r) {
sum[rt] = x * mul[l];
return;
}
int m = (l + r) >> 1;
if (pos <= m)
update(pos, x, l, m, rt << 1, sum, mul);
else
update(pos, x, m + 1, r, rt << 1 | 1, sum, mul);
pushup(rt, sum);
}
long long query(int L, int R, int l, int r, int rt, long long sum[]) {
if (L <= l && r <= R) {
return sum[rt];
}
long long ans = 0;
int m = (l + r) >> 1;
if (L <= m) ans += query(L, R, l, m, rt << 1, sum);
if (R > m) ans += query(L, R, m + 1, r, rt << 1 | 1, sum);
return ans;
}
inline int getid(int l, int z) {
int buf = 0;
for (int i = 1; i <= int(z - 2); i++) buf += 2 * i;
int k = 2 * (z - 1);
l = (l - 1) % k + 1;
if (l == 1) return l + buf;
return k - l + 2 + buf;
}
int main() {
long long a[15];
a[1] = 1, a[2] = 2;
for (int i = 1; i <= int(2); i++)
for (int j = 1; j <= int(N - 10); j++)
mul[i][j] = a[(j - 1 + i - 1) % 2 + 1];
a[3] = 3, a[4] = 2;
for (int i = 1; i <= int(4); i++)
for (int j = 1; j <= int(N - 10); j++)
mul[2 + i][j] = a[(j - 1 + i - 1) % 4 + 1];
a[4] = 4, a[5] = 3, a[6] = 2;
for (int i = 1; i <= int(6); i++)
for (int j = 1; j <= int(N - 10); j++)
mul[6 + i][j] = a[(j - 1 + i - 1) % 6 + 1];
a[5] = 5, a[6] = 4, a[7] = 3, a[8] = 2;
for (int i = 1; i <= int(8); i++)
for (int j = 1; j <= int(N - 10); j++)
mul[12 + i][j] = a[(j - 1 + i - 1) % 8 + 1];
a[6] = 6, a[7] = 5, a[8] = 4, a[9] = 3, a[10] = 2;
for (int i = 1; i <= int(10); i++)
for (int j = 1; j <= int(N - 10); j++)
mul[20 + i][j] = a[(j - 1 + i - 1) % 10 + 1];
cin >> n;
for (int i = 1; i <= int(n); i++) scanf("%I64d", &val[i]);
for (int i = 1; i <= int(30); i++) build(1, n, 1, sum[i], mul[i]);
int Q;
cin >> Q;
for (int i = 1; i <= int(Q); i++) {
int op;
scanf("%d", &op);
if (op == 1) {
int pos;
long long x;
scanf("%d%I64d", &pos, &x);
for (int i = 1; i <= int(30); i++)
update(pos, x, 1, n, 1, sum[i], mul[i]);
} else {
int l, r, z;
scanf("%d%d%d", &l, &r, &z);
int id = getid(l, z);
printf("%I64d\n", query(l, r, 1, n, 1, sum[id]));
}
}
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:100000000,100000000")
using namespace std;
const long long inf = 1e9 + 7;
const long long mod = 1e9 + 7;
const double eps = 1e-9;
const double PI = 2 * acos(0.0);
const double E = 2.71828;
struct SegTree {
long long* t;
void build(long long pos, long long L, long long R, long long a[]) {
if (L > R) return;
if (L == R)
t[pos] = a[L];
else {
long long Mid = (L + R) / 2;
build(pos * 2, L, Mid, a);
build(pos * 2 + 1, Mid + 1, R, a);
t[pos] = t[pos * 2] + t[pos * 2 + 1];
}
}
long long get(long long pos, long long tl, long long tr, long long L,
long long R) {
if (L > R) return 0;
if (L == tl && R == tr) return t[pos];
long long Mid = (tl + tr) / 2;
long long i = get(pos * 2, tl, Mid, L, min(Mid, R));
long long j = get(pos * 2 + 1, Mid + 1, tr, max(L, Mid + 1), R);
return i + j;
}
void update(long long pos, long long tl, long long tr, long long P,
long long val) {
if (tl == tr)
t[pos] = val;
else {
long long Mid = (tl + tr) / 2;
if (P <= Mid)
update(pos * 2, tl, Mid, P, val);
else
update(pos * 2 + 1, Mid + 1, tr, P, val);
t[pos] = t[pos * 2] + t[pos * 2 + 1];
}
}
} t[7][14];
long long aa[100001], bb[100001], A[7][14][100001], C[7][100001];
int main(void) {
long long n;
cin >> n;
for (int i = 0; i < n; i++) {
scanf("%I64d", &aa[i]);
}
for (int i = 2; i <= 6; i++) {
for (int y = 1; y <= i; y++) {
long long u = 1, h = y - 1;
for (int j = 0; j <= n; j++) {
h += u;
if (h == i) u = -1;
if (h == 1) u = 1;
bb[j] = h * aa[j];
A[i][y][j] = h;
if (h == 1) C[i][j] = y;
}
t[i][y].t = new long long[4 * n + 1];
t[i][y].build(1, 0, n - 1, bb);
}
for (int y = 1; y < i; y++) {
long long u = -1, h = i - y + 1;
for (int j = 0; j <= n; j++) {
h += u;
if (h == i) u = -1;
if (h == 1) u = 1;
bb[j] = h * aa[j];
A[i][y + i][j] = h;
if (h == 1) C[i][j] = y + i;
}
t[i][i + y].t = new long long[4 * n + 1];
t[i][i + y].build(1, 0, n - 1, bb);
}
}
long long m;
cin >> m;
for (int i = 0; i < m; i++) {
long long T;
scanf("%I64d", &T);
if (T == 1) {
long long a, b;
scanf("%I64d%I64d", &a, &b);
a--;
;
;
;
for (int j = 2; j <= 6; j++) {
for (int y = 1; y <= j; y++) {
t[j][y].update(1, 0, n - 1, a, b * A[j][y][a]);
}
for (int y = 1; y < j; y++) {
t[j][j + y].update(1, 0, n - 1, a, b * A[j][j + y][a]);
}
}
} else {
long long a, b, c;
scanf("%I64d%I64d%I64d", &a, &b, &c);
a--, b--;
long long w1 = C[c][a];
printf("%I64d\n", t[c][w1].get(1, 0, n - 1, a, b));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int a[N], n;
long long bit[30][N];
void add(int x, long long v, long long *b) {
while (x <= n) {
b[x] += v;
x += x & -x;
}
}
long long ask(int x, long long *b) {
long long ret = 0;
while (x) {
ret += b[x];
x -= x & -x;
}
return ret;
}
long long ask(int x, int y, long long *b) { return ask(y, b) - ask(x - 1, b); }
inline int getseq(int z, int v) {
if (z == 2) return v % 2;
if (z == 3) return v % 4 + 2;
if (z == 4) return v % 6 + 6;
if (z == 5) return v % 8 + 12;
return v % 10 + 20;
}
int main(void) {
int m;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++)
for (int z = 2; z <= 6; z++) add(i, a[i], bit[getseq(z, i)]);
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
int t, x, v, l, r, z;
scanf("%d", &t);
if (t == 1) {
scanf("%d%d", &x, &v);
v = v - a[x];
a[x] += v;
for (z = 2; z <= 6; z++) add(x, v, bit[getseq(z, x)]);
} else {
scanf("%d%d%d", &l, &r, &z);
long long ans = 0;
for (int j = 1; j < z; j++)
ans += j * ask(l, r, bit[getseq(z, l + j - 1)]);
for (int j = z; j > 1; j--)
ans += j * ask(l, r, bit[getseq(z, l + 2 * z - j - 1)]);
printf("%I64d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
const int nmax = 100000, zmax = 6;
long long t[zmax][2 * zmax - 2][nmax + 1];
inline int fz(int x, int z) {
if (x % (2 * z - 2) == 0) {
return 2;
} else if (x % (2 * z - 2) <= z) {
return x % (2 * z - 2);
} else {
return 2 * z - x % (2 * z - 2);
}
}
long long t_query(int i, int j, int x) {
long long aux;
aux = 0;
for (int k = x; k; k &= k - 1) {
aux += t[i][j][k];
}
return aux;
}
int main() {
int n, m;
assert(scanf(" %d ", &n));
for (int i = 1; i <= n; ++i) {
long long x;
assert(scanf(" %I64d ", &x));
t[0][0][i] = x;
for (int j = 1; j < zmax; ++j) {
for (int k = 0; k < 2 * j; ++k) {
t[j][k][i] = t_query(j, k, i - 1) - t_query(j, k, i & (i - 1)) +
x * fz(i + k, j + 1);
}
}
}
assert(scanf(" %d ", &m));
for (; m; --m) {
int op;
assert(scanf(" %d ", &op));
if (op == 1) {
int p;
long long x;
assert(scanf(" %d %I64d ", &p, &x));
for (int j = 1; j < zmax; ++j) {
for (int k = 0; k < 2 * j; ++k) {
long long aux;
aux = (x - t[0][0][p]) * fz(p + k, j + 1);
for (int i = p; i <= n; i = 2 * i - (i & (i - 1))) {
t[j][k][i] += aux;
}
}
}
t[0][0][p] = x;
} else {
int l, r, z, x;
assert(scanf(" %d %d %d ", &l, &r, &z));
x = (l - 1) % (2 * z - 2) + 1;
x = (2 * z - x - 1) % (2 * z - 2);
printf("%I64d\n", t_query(z - 1, x, r) - t_query(z - 1, x, l - 1));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = (int)1e9;
const int inf = (int)1e9;
const int base = 1000 * 1000 * 1000;
const int maxn = 1005;
const long double pi = acosl(-1.0);
const long double eps = 1e-9;
void error() { exit(1); }
long long f(int i, int z, int d) {
int res = (i + d + 1) % (2 * (z - 1));
if (res == 0)
return 2;
else if (res <= z)
return res;
return 2 * z - res;
}
struct Tree {
vector<long long> t;
int size;
void init(vector<int> &a, int n, int z, int del) {
size = 1;
while (n >= size) size <<= 1;
t.resize(size << 1, 0);
for (int i = 0; i < n; i++) {
t[i + size] = a[i] * f(i, z, del);
}
for (int i = size - 1; i >= 1; i--) t[i] = t[2 * i] + t[2 * i + 1];
}
void change(int v, int val, int z, int del) {
v = size + v;
t[v] = val * f(v - size, z, del);
while ((v >> 1) >= 1) {
v >>= 1;
t[v] = t[2 * v] + t[2 * v + 1];
}
}
long long get(int v, int curl, int curr, int l, int r) {
if (l > r) return 0;
if (curl == l && curr == r) return t[v];
int mid = (curl + curr) >> 1;
long long a = get(2 * v, curl, mid, l, min(r, mid));
long long b = get(2 * v + 1, mid + 1, curr, max(l, mid + 1), r);
return a + b;
}
};
void solve() {
Tree tree[10][20];
int n;
scanf("%d", &n);
vector<int> a(n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 2; i < 7; i++)
for (int j = 0; j < 2 * (i - 1); j++) {
tree[i][j].init(a, n, i, j);
}
int m, t;
scanf("%d", &m);
while (m--) {
scanf("%d", &t);
if (t == 1) {
int p, v;
scanf("%d %d", &p, &v);
for (int i = 2; i < 7; i++)
for (int j = 0; j < 2 * (i - 1); j++) {
tree[i][j].change(p - 1, v, i, j);
}
} else {
int l, r, z;
scanf("%d %d %d", &l, &r, &z);
int ost = (l - 1) % (2 * (z - 1));
int del = (2 * (z - 1) - ost) % (2 * (z - 1));
long long ans =
tree[z][del].get(1, 0, tree[z][del].size - 1, l - 1, r - 1);
printf("%I64d\n", ans);
}
}
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[111111];
long long s[7][13][111111];
void add(int x, long long y) {
for (int i = (2); i <= (6); ++i)
for (int j = 0; j < (2 * (i - 1)); ++j) {
int zd = (x + 2 * (i - 1) - j) % (2 * (i - 1));
if (zd == 0)
zd = 2;
else if (zd > i)
zd = 2 * i - zd;
for (int t = x; t < 111111; t += t - (t & (t - 1))) s[i][j][t] += y * zd;
}
}
long long ask(int x, int z, int d) {
long long ret = 0;
for (; x; x &= x - 1) ret += s[z][d][x];
return ret;
}
int main() {
scanf("%d", &n);
for (int i = (1); i <= (n); ++i) {
scanf("%d", a + i);
add(i, a[i]);
}
int q;
scanf("%d", &q);
for (int qq = 0; qq < (q); ++qq) {
int t, x, y, z;
scanf("%d", &t);
if (t == 1) {
scanf("%d%d", &x, &y);
add(x, -a[x]);
a[x] = y;
add(x, a[x]);
} else {
scanf("%d%d%d", &x, &y, &z);
int m = 2 * (z - 1);
int j;
for (int jj = 0; jj < (m); ++jj) {
int zd = (x + m - jj) % m;
if (zd == 0)
zd = 2;
else if (zd > z)
zd = 2 * z - zd;
if (zd == 1) {
j = jj;
break;
}
}
printf("%I64d\n", ask(y, z, j) - ask(x - 1, z, j));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100000;
struct fenvik {
long long t[MAXN];
int n;
fenvik(int n = 0) : n(n) { memset(t, 0, sizeof(t)); }
long long sum(int l, int r) {
long long res = 0;
l--;
for (; r >= 0; r = (r & (r + 1)) - 1) res += t[r];
for (; l >= 0; l = (l & (l + 1)) - 1) res -= t[l];
return res;
}
void update(int i, int det) {
for (; i < n; i |= (i + 1)) t[i] += det;
}
};
const int Z = 10;
fenvik f[Z][2 * Z];
int a[MAXN];
int n, m;
int main() {
cin >> n;
for (int z = 2; z <= 6; z++)
for (int i = 0; i < 2 * (z - 1); i++) f[z][i].n = n;
for (int i = 0; i < n; i++) {
cin >> a[i];
for (int z = 2; z <= 6; z++) f[z][i % (2 * (z - 1))].update(i, a[i]);
}
cin >> m;
int type;
for (int i = 0; i < m; i++) {
cin >> type;
switch (type) {
case 1:
int p, v;
cin >> p >> v;
p--;
for (int z = 2; z <= 6; z++)
f[z][p % (2 * (z - 1))].update(p, v - a[p]);
a[p] = v;
break;
case 2:
int l, r, z;
cin >> l >> r >> z;
l--;
r--;
long long ans = 0;
int coef = 1, det = 1;
for (int k = l % (2 * (z - 1));;) {
ans += coef * f[z][k].sum(l, r);
coef += det;
if (coef == z) det = -det;
k++;
k %= 2 * (z - 1);
if (k == l % (2 * (z - 1))) break;
}
cout << ans << endl;
break;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long ar[100010];
long long st[30][400010];
long long t1[] = {0, 2, 6, 12, 20};
void buildTree(long long id, long long mod, long long v, long long l,
long long r) {
if (l == r) {
st[id + l % mod][v] = ar[l];
return;
}
buildTree(id, mod, 2 * v, l, (l + r) / 2);
buildTree(id, mod, 2 * v + 1, (l + r) / 2 + 1, r);
for (long long i = 0; i < mod; ++i)
st[id + i][v] = st[id + i][2 * v] + st[id + i][2 * v + 1];
}
void update(long long id, long long v, long long l, long long r,
long long pos) {
if (l == r) {
st[id][v] = ar[pos];
return;
}
long long m = (l + r) / 2;
if (pos <= m)
update(id, 2 * v, l, m, pos);
else
update(id, 2 * v + 1, m + 1, r, pos);
st[id][v] = st[id][2 * v] + st[id][2 * v + 1];
}
long long get(long long id, long long v, long long tl, long long tr,
long long l, long long r) {
if (l > r) return 0;
if (tl == l && tr == r) return st[id][v];
long long tm = (tl + tr) / 2;
return get(id, 2 * v, tl, tm, l, min(r, tm)) +
get(id, 2 * v + 1, tm + 1, tr, max(l, tm + 1), r);
}
long long n;
long long br[100][100];
int main(int argc, char** argv) {
cin >> n;
for (long long i = 0; i < n; ++i) cin >> ar[i];
for (long long i = 2; i <= 6; ++i) {
for (long long j = 1; j <= 2 * (i - 1); ++j) {
long long t = j % (2 * (i - 1));
if (t == 0)
br[i][j] = 2;
else if (t <= i)
br[i][j] = t;
else if (t > i)
br[i][j] = 2 * i - t;
}
}
for (long long i = 2; i <= 6; ++i)
buildTree(t1[i - 2], 2 * (i - 1), 1, 0, n - 1);
long long m;
cin >> m;
for (long long count = 0; count < m; ++count) {
long long t;
cin >> t;
if (t == 1) {
long long p, v;
cin >> p >> v;
--p;
ar[p] = v;
for (long long i = 2; i <= 6; ++i)
update(t1[i - 2] + p % (2 * i - 2), 1, 0, n - 1, p);
} else {
long long l, r, z;
cin >> l >> r >> z;
--l;
--r;
long long ans = 0;
for (long long i = l; i < min(l + 2 * z - 2, r + 1); ++i) {
ans += ((long long)br[z][i - l + 1]) *
get(t1[z - 2] + i % (2 * (z - 1)), 1, 0, n - 1, l, r);
}
cout << ans << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100044;
long long a[N], s[34][N];
int f[N][8], n, q;
void add(int idx, int p, long long w) {
for (int i = p; i <= n; i += (i & -i)) s[idx][i] += w;
}
long long que(int idx, int p) {
long long ans = 0;
for (int i = p; i; i -= (i & -i)) ans += s[idx][i];
return ans;
}
int g[] = {0, 0, 2, 4, 6, 8, 10}, sg[] = {0, 0, 2, 6, 12, 20, 30};
int main() {
int x, y, z, op;
long long v;
scanf("%d", &n);
for (int z = 2; z <= 6; z++) {
for (int i = 1; i <= n + 40; i++) {
int t = i % g[z];
if (t == 0)
f[i][z] = 2;
else if (t <= z)
f[i][z] = t;
else
f[i][z] = 2 * z - t;
}
}
for (int i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
for (int j = 2, s = 0; j <= 6; j++) {
for (int k = 0; k < g[j]; k++) {
add(s + k, i, a[i] * f[i - k + g[j]][j]);
}
s = sg[j];
}
}
scanf("%d", &q);
while (q--) {
scanf("%d", &op);
if (op == 1) {
scanf("%d %lld", &x, &v);
long long d = v - a[x];
for (int j = 2, s = 0; j <= 6; j++) {
for (int k = 0; k < g[j]; k++) {
add(s + k, x, d * f[x - k + g[j]][j]);
}
s = sg[j];
}
a[x] = v;
} else {
scanf("%d %d %d", &x, &y, &z);
int ofs = (x - 1) % g[z];
printf("%lld\n", que(sg[z - 1] + ofs, y) - que(sg[z - 1] + ofs, x - 1));
}
}
}
|
#include <bits/stdc++.h>
const int N = 100005;
using namespace std;
long long s[15][15][N];
int n, a[N];
void add(int M, int m, int x, long long d) {
for (; x <= n; x += x & (-x)) s[M][m][x] += d;
}
long long sum(int M, int m, int x) {
long long res = 0;
for (; x; x -= x & (-x)) res += s[M][m][x];
return res;
}
void update(int t, int x) {
x = x - a[t];
int i;
for (i = 2; i <= 10; i += 2) {
add(i, t % i, t, (long long)x);
}
a[t] += x;
}
long long calc(int l, int r, int z) {
int i, k, p = (z - 1) << 1;
long long res = 0;
for (i = 0; i < p; i++) {
if (i + 1 == p)
k = 2;
else if (i < z)
k = i + 1;
else
k = z * 2 - i - 1;
res += 1LL * k * (sum(p, (l + i) % p, r) - sum(p, (l + i) % p, l - 1));
}
return res;
}
int main() {
int q;
scanf("%d", &n);
int i, x;
for (i = 0; i < n; i++) {
scanf("%d", &x);
update(i + 1, x);
}
scanf("%d", &q);
int t, l, r, z, p, v;
while (q--) {
scanf("%d", &t);
if (t == 1) {
scanf("%d%d", &p, &v);
update(p, v);
} else {
scanf("%d%d%d", &l, &r, &z);
printf("%I64d\n", calc(l, r, z));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int a[7][11] = {{0},
{0},
{0, 1, 2},
{0, 1, 2, 3, 2},
{0, 1, 2, 3, 4, 3, 2},
{0, 1, 2, 3, 4, 5, 4, 3, 2},
{0, 1, 2, 3, 4, 5, 6, 5, 4, 3, 2}};
long long int MOD[300000][20];
class segment_tree {
public:
long long int z;
private:
class segment {
public:
long long int size, sum[11];
segment() {
size = 0;
memset(sum, 0, sizeof sum);
}
};
inline segment merge(segment a, segment b) {
segment t;
t.size = a.size + b.size;
for (long long int i = 1; i <= 2 * (z - 1); i++)
t.sum[i] = a.sum[i] + b.sum[MOD[i - 1 + a.size][2 * (z - 1)] + 1];
return t;
}
public:
segment kd[262145];
inline void update(long long int root, long long int bas, long long int son,
long long int x, long long int val) {
if (x < bas or son < x) return;
if (bas == son) {
kd[root].size = 1;
for (long long int i = 1; i <= 2 * (z - 1); i++)
kd[root].sum[i] = val * a[z][i];
return;
}
update(root * 2, bas, (bas + son) / 2, x, val);
update(root * 2 + 1, (bas + son) / 2 + 1, son, x, val);
kd[root] = merge(kd[root * 2], kd[root * 2 + 1]);
}
inline segment query(long long int root, long long int bas, long long int son,
long long int x, long long int y) {
if (y < bas or son < x) return segment();
if (x <= bas and son <= y) return kd[root];
return merge(query(root * 2, bas, (bas + son) / 2, x, y),
query(root * 2 + 1, (bas + son) / 2 + 1, son, x, y));
}
} ST[7];
long long int n, m;
int main() {
for (long long int i = 0; i <= 290000; i++)
for (long long int j = 1; j <= 18; j++) MOD[i][j] = i % j;
for (long long int c = 2; c <= 6; c++) ST[c].z = c;
cin >> n;
long long int t, x, y, c;
for (long long int i = 1; i <= n; i++) {
scanf("%lld", &x);
for (long long int c = 2; c <= 6; c++) ST[c].update(1, 1, n, i, x);
}
cin >> m;
while (m--) {
scanf("%lld", &t);
if (t == 1) {
scanf("%lld %lld", &x, &c);
for (long long int cc = 2; cc <= 6; cc++) ST[cc].update(1, 1, n, x, c);
} else {
scanf("%lld %lld %lld", &x, &y, &c);
printf("%lld\n", ST[c].query(1, 1, n, x, y).sum[1]);
}
}
}
|
#include <bits/stdc++.h>
inline int getInt() {
int s;
scanf("%d", &s);
return s;
}
using namespace std;
class BIT {
vector<long long> bit;
public:
BIT(int n) : bit(n + 1) {}
void add(int idx, long long val) {
idx++;
while (idx < (int)bit.size()) {
bit[idx] += val;
idx += idx & -idx;
}
}
long long sum(int i) {
long long s = 0;
i++;
while (i > 0) {
s += bit[i];
i -= i & -i;
}
return s;
}
};
int zz(int z, int i) {
i++;
int m = i % (2 * (z - 1));
if (m == 0) return 2;
if (m <= z) return m;
return 2 * z - m;
}
int main() {
const int n = getInt();
vector<vector<BIT> > bits(7, vector<BIT>(14, BIT(n)));
vector<long long> a(n);
for (int i = 0; i < (int)(n); i++) {
a[i] = getInt();
}
for (int i = 0; i < (int)(7); i++)
for (int j = 0; j < (int)((i - 1) * 2); j++)
if (i > 1) {
for (int k = 0; k < (int)(n); k++) {
bits[i][j].add(k, zz(i, j + k) * a[k]);
}
}
const int m = getInt();
for (int cc = 0; cc < (int)(m); cc++) {
const int t = getInt();
if (t == 1) {
const int p = getInt() - 1;
const long long v = getInt();
for (int i = 0; i < (int)(7); i++)
for (int j = 0; j < (int)((i - 1) * 2); j++)
if (i > 1) {
bits[i][j].add(p, -zz(i, j + p) * a[p]);
bits[i][j].add(p, zz(i, j + p) * v);
}
a[p] = v;
} else {
const int l = getInt() - 1;
const int r = getInt() - 1;
const int z = getInt();
for (int i = 0; i < (int)(2 * (z - 1)); i++)
if (zz(z, i + l) == 1) {
long long ans = bits[z][i].sum(r);
if (l != 0) ans -= bits[z][i].sum(l - 1);
cout << ans << endl;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 100000 + 10;
const int NUM = 12;
long long n, a[MAX], sum[NUM][NUM][MAX];
void ins(long long* sum, int x, long long delta) {
for (; x <= n; x += (x & (-x))) sum[x] += delta;
}
long long ask(long long* sum, int l) {
long long ans = 0;
for (; l; l -= (l & (-l))) ans += sum[l];
return ans;
}
long long S(int i, int z) {
int d = 2 * (z - 1), k = i % d;
if (!k) return 2;
if (k <= z)
return k;
else
return 2 * z - k;
}
void add(int c, long long d) {
a[c] += d;
int i, j;
for (i = 2; i <= 6; ++i)
for (j = 1; j <= 2 * (i - 1); ++j) ins(sum[i][j], c, d * S(j - 1 + c, i));
}
long long ask(int l, int r, int z) {
int j;
for (j = 1; j <= 2 * (z - 1); ++j)
if ((j - 1 + l) % (2 * (z - 1)) == 1) break;
return ask(sum[z][j], r) - ask(sum[z][j], l - 1);
}
int main() {
int i, b, Q, x, y, z;
cin >> n;
for (i = 1; i <= n; ++i) {
cin >> b;
add(i, b);
}
scanf("%d", &Q);
for (i = 1; i <= Q; ++i) {
scanf("%d", &b);
if (b == 1) {
scanf("%d %d", &x, &y);
add(x, y - a[x]);
} else if (b == 2) {
scanf("%d %d %d", &x, &y, &z);
cout << ask(x, y, z) << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const char al[100] = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I',
'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R',
'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'};
vector<vector<long long int> > go(7);
vector<vector<vector<long long int> > > tree(5);
vector<vector<vector<long long int> > > values(5);
vector<long long int> my;
void inc(long long int i, long long int delta, long long int id,
long long int mod) {
for (; i < tree[id][mod].size(); i = (i | (i + 1))) tree[id][mod][i] += delta;
}
void init(long long int id, long long int mod) {
long long int n = go[id].size();
for (long long int i = 0; i < my.size(); i++) {
values[id][mod][i] = my[i] * go[id][(i + mod) % n];
inc(i, my[i] * go[id][(i + mod) % n], id, mod);
}
}
long long int sum(long long int r, long long int id, long long int mod) {
long long int result = 0;
for (; r >= 0; r = (r & (r + 1)) - 1) result += tree[id][mod][r];
return result;
}
long long int sum(long long int l, long long int r, long long int id,
long long int mod) {
return sum(r, id, mod) - sum(l - 1, id, mod);
}
int main() {
long long int pp;
for (long long int i = 2; i <= 6; i++) {
for (long long int j = 0; j < 2 * (i - 1); j++) {
if ((j + 1) % (2 * (i - 1)) == 0)
go[i - 2].push_back(2);
else if ((j + 1) % (2 * (i - 1)) <= i)
go[i - 2].push_back((j + 1) % (2 * (i - 1)));
else
go[i - 2].push_back(2 * i - (j + 1) % (2 * (i - 1)));
}
}
cin >> pp;
for (long long int i = 0; i < pp; i++) {
long long int x;
cin >> x;
my.push_back(x);
}
for (long long int i = 0; i < 5; i++)
tree[i].resize(go[i].size(), vector<long long int>(my.size(), 0));
for (long long int i = 0; i < 5; i++)
values[i].resize(go[i].size(), vector<long long int>(my.size(), 0));
for (long long int i = 0; i < 5; i++) {
for (long long int j = 0; j < go[i].size(); j++) init(i, j);
}
long long int m;
cin >> m;
long long int x, y, z, p;
for (long long int i = 0; i < m; i++) {
z = 0;
cin >> p;
if (p == 2)
cin >> x >> y >> z;
else
cin >> x >> y;
x--;
y--;
if (p == 2) {
long long int to = x % go[z - 2].size();
long long int temp;
if (to != 0)
temp = go[z - 2].size() - to;
else
temp = 0;
cout << sum(x, y, z - 2, temp) << endl;
} else {
y++;
long long int delta;
for (long long int j = 0; j < 5; j++)
for (long long int k = 0; k < go[j].size(); k++) {
delta = y * go[j][(x + k) % go[j].size()] - values[j][k][x];
values[j][k][x] += delta;
inc(x, delta, j, k);
}
}
}
};
|
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 1 << 17;
int F[7][MaxN];
int mod[7];
int n;
long long v[7][11][MaxN << 1];
void add(int k, int L, int R, int x, long long p) {
if (L == R) {
for (int i = 2; i <= 6; ++i)
for (int j = 1; j <= mod[i]; ++j) v[i][j][k] = p * F[i][j];
return;
}
int mid = (L + R) >> 1;
if (x <= mid)
add(k << 1, L, mid, x, p);
else
add(k << 1 | 1, mid + 1, R, x, p);
for (int i = 2; i <= 6; ++i)
for (int j = 1; j <= mod[i]; ++j) {
int t = (j + (R - L + 1) / 2) % mod[i];
if (!t) t = mod[i];
v[i][j][k] = v[i][j][k << 1] + v[i][t][k << 1 | 1];
}
}
long long get(int k, int L, int R, int x, int y, int z, int t) {
if (L == x && R == y) return v[z][t][k];
int mid = (L + R) >> 1;
if (y <= mid) return get(k << 1, L, mid, x, y, z, t);
if (x > mid) return get(k << 1 | 1, mid + 1, R, x, y, z, t);
int u = (t + mid - x + 1) % mod[z];
if (!u) u = mod[z];
return get(k << 1, L, mid, x, mid, z, t) +
get(k << 1 | 1, mid + 1, R, mid + 1, y, z, u);
}
void init() {
for (int i = 2; i <= 6; ++i) {
mod[i] = 2 * (i - 1);
for (int j = 1; j <= 100000; ++j) {
int t = j % (2 * (i - 1));
if (!t)
F[i][j] = 2;
else if (t <= i)
F[i][j] = t;
else
F[i][j] = 2 * i - t;
}
}
cin >> n;
for (int i = 1; i <= n; ++i) {
int x;
scanf("%d", &x);
add(1, 1, MaxN, i, x);
}
}
void work() {
int T;
cin >> T;
while (T--) {
int flag;
scanf("%d", &flag);
if (flag == 1) {
int x, p;
scanf("%d%d", &x, &p);
add(1, 1, MaxN, x, p);
} else {
int x, y, z;
scanf("%d%d%d", &x, &y, &z);
printf("%I64d\n", get(1, 1, MaxN, x, y, z, 1));
}
}
}
int main() {
init();
work();
return 0;
}
|
#include <bits/stdc++.h>
int n;
struct pp {
long long a[100001];
void add(int p, long long d) {
for (; p <= n; p += p & -p) a[p] += d;
}
long long suma(int p) {
long long ret = 0;
for (; p; p -= p & -p) ret += a[p];
return ret;
}
long long sum(int l, int r) { return suma(r) - suma(l - 1); }
} mem[30];
int go[5] = {0, 2, 6, 12, 20};
int gao(int x, int m) {
if (x * 2 <= m)
return x;
else
return m + 2 - x;
}
int a[102400];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", a + i);
for (int i = 0, t; i <= 4; ++i) {
t = i * 2 + 2;
for (int j = 1; j <= n; ++j) mem[go[i] + j % t].add(j, a[j]);
}
int m, l, r, t, x;
for (scanf("%d", &m); m--;) {
scanf("%d%d%d", &t, &l, &r);
if (t == 1) {
r -= a[l];
a[l] += r;
for (int i = 0, t; i <= 4; ++i) {
t = i * 2 + 2;
mem[go[i] + l % t].add(l, r);
}
} else {
scanf("%d", &x);
x -= 2;
t = x * 2 + 2;
long long ans = 0;
for (int i = 1; i <= t && i + l <= r + 1; ++i)
ans += mem[go[x] + (l + i - 1) % t].sum(l, r) * gao(i, t);
printf("%I64d\n", ans);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 3, MAXK = 7;
int AK[MAXK][2 * MAXK], m;
void buildK() {
for (int i = 2; i < MAXK; i++) {
for (int ii = 0; ii < 2 * (i - 1); ii++) {
int md = ii;
if (md == 0) md = 2;
if (md > i) md = 2 * i - md;
AK[i][ii] = md;
}
}
}
int cal(int x, int kk) {
x %= (2 * (kk - 1));
return x;
}
struct node {
vector<long long> v[MAXK];
node() {
for (int i = 2; i < MAXK; i++) v[i].resize(2 * (i - 1));
}
void build(int val) {
for (int i = 2; i < MAXK; i++) {
for (int ii = 0; ii < 2 * (i - 1); ii++) {
v[i][ii] = val * 1LL * AK[i][ii];
}
}
}
void merge(node &L, node &R, int sz) {
for (int i = 2; i < MAXK; i++) {
for (int ii = 0; ii < 2 * (i - 1); ii++) {
v[i][ii] = L.v[i][ii];
int nxt = cal(sz + ii, i);
v[i][ii] += R.v[i][nxt];
}
}
}
};
node Te[4 * MAXN], dum;
int n;
void up(int idx, int l1, int r1, int l, int r, int v) {
if (l > r1 || r < l1) return;
if (l >= l1 && r <= r1) {
Te[idx].build(v);
return;
}
int md = (l + r) >> 1;
up(idx * 2, l1, r1, l, md, v);
up(idx * 2 + 1, l1, r1, md + 1, r, v);
int sz = md - l + 1;
Te[idx].merge(Te[idx * 2], Te[idx * 2 + 1], sz);
}
int varK;
long long get(int idx, int l1, int r1, int l, int r, int kk) {
if (l > r1 || r < l1) return 0;
if (l >= l1 && r <= r1) {
int x = cal(varK, kk);
long long val = Te[idx].v[kk][x];
varK += (r - l + 1);
return val;
}
int md = (l + r) >> 1;
return get(idx * 2, l1, r1, l, md, kk) +
get(idx * 2 + 1, l1, r1, md + 1, r, kk);
}
int main() {
buildK();
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
up(1, i, i, 0, n - 1, x);
}
scanf("%d", &m);
for (int i = 0; i < m; i++) {
int type, pos, l, r, val, zz;
scanf("%d", &type), varK = 1;
if (type == 1) {
scanf("%d%d", &pos, &val), pos--;
up(1, pos, pos, 0, n - 1, val);
} else {
scanf("%d%d%d", &l, &r, &zz), l--, r--;
long long ret = get(1, l, r, 0, n - 1, zz);
printf("%lld\n", ret);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int mxN = 100000;
int n, q, a[mxN];
struct ft {
long long a[mxN + 1];
void upd(int i, long long val) {
for (++i; i <= n; i += i & -i) a[i] += val;
}
long long sum(int i) {
long long res = 0;
for (++i; i > 0; i -= i & -i) res += a[i];
return res;
}
long long sum(int l, int r) { return sum(r) - sum(l - 1); }
} f[5][10];
inline long long get(int i, int j, int ind) {
int res = (ind - j + 2 * (i - 1)) % (2 * (i - 1));
if (res >= i) res = 2 * (i - 1) - res;
return res + 1;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; ++i) cin >> a[i];
for (int i = 2; i <= 6; ++i)
for (int j = 0; j < 2 * (i - 1); ++j)
for (int k = 0; k < n; ++k) f[i - 2][j].upd(k, get(i, j, k) * a[k]);
cin >> q;
while (q--) {
int t;
cin >> t;
if (t == 1) {
int ind, val;
cin >> ind >> val, --ind;
int inc = val - a[ind];
a[ind] = val;
for (int i = 2; i <= 6; ++i)
for (int j = 0; j < 2 * (i - 1); ++j)
f[i - 2][j].upd(ind, get(i, j, ind) * inc);
} else {
int l, r, z;
cin >> l >> r >> z, --l, --r;
cout << f[z - 2][l % (2 * (z - 1))].sum(l, r) << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int a, long long int b) {
if (a == 0)
return (b);
else
return (gcd(b % a, a));
}
long long int fastpow(long long int a, long long int n, long long int temp) {
if (n == 0) return (1);
if (n == 1) return ((a * temp) % 1000000007);
if (n & 1) temp = (temp * a) % 1000000007;
return (fastpow((a * a) % 1000000007, n / 2, temp));
}
char dum;
long long int a[100005];
long long int t[400005][5][12];
long long int z[7][15];
void push(int nd, int nnd, int mid, int l) {
for (int i = 2; i < 7; i++) {
for (int j = 0; j < 2 * (i - 1); j++)
t[nd][i - 2][j] = t[nnd][i - 2][j] +
t[nnd + 1][i - 2][(j + (mid - l + 1)) % (2 * (i - 1))];
}
}
void init(int l, int r, int nd) {
if (l > r) return;
if (l == r) {
for (int i = 2; i < 7; i++) {
for (int j = 0; j < 2 * (i - 1); j++) t[nd][i - 2][j] = a[l] * z[i][j];
}
return;
}
int mid = (l + r) / 2, nnd = nd * 2;
init(l, mid, nd * 2);
init(mid + 1, r, nd * 2 + 1);
push(nd, nnd, mid, l);
}
void update(int l, int r, int ind, int nd) {
if (l > r) return;
if (l == ind and r == ind) {
for (int i = 2; i < 7; i++) {
for (int j = 0; j < 2 * (i - 1); j++) t[nd][i - 2][j] = a[l] * z[i][j];
}
return;
}
int mid = (l + r) / 2, nnd = nd * 2;
if (l <= ind and ind <= mid)
update(l, mid, ind, nnd);
else
update(mid + 1, r, ind, nnd + 1);
push(nd, nnd, mid, l);
}
long long int query(int l, int r, int i, int j, int z, int nd, int ofst) {
if (l > r or l > j or r < i) return 0;
if (i <= l and r <= j) return t[nd][z - 2][ofst % (2 * (z - 1))];
int mid = (l + r) / 2, nnd = nd * 2;
long long int res1 = 0, res2 = 0;
if (j <= mid)
res1 = query(l, mid, i, j, z, nnd, ofst);
else if (i > mid)
res2 = query(mid + 1, r, i, j, z, nnd + 1, ofst);
else {
res1 = query(l, mid, i, j, z, nnd, ofst);
res2 = query(mid + 1, r, i, j, z, nnd + 1, ofst + (mid - max(i, l) + 1));
}
return res1 + res2;
}
int main() {
int v;
for (int i = 2; i < 7; i++)
for (int j = 0; j < 2 * (i - 1); j++) {
if ((j + 1) % (2 * (i - 1)) == 0)
v = 2;
else if ((j + 1) % (2 * (i - 1)) <= i)
v = (j + 1) % (2 * (i - 1));
else
v = 2 * i - (j + 1) % (2 * (i - 1));
z[i][j] = v;
}
int n, m, type, p, l, r, z;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%lld", &a[i]);
init(0, n - 1, 1);
scanf("%d", &m);
while (m--) {
scanf("%d", &type);
if (type == 1) {
scanf("%d", &p), scanf("%d", &v);
a[p - 1] = v;
update(0, n - 1, p - 1, 1);
} else {
scanf("%d", &l), scanf("%d", &r), scanf("%d", &z);
cout << query(0, n - 1, l - 1, r - 1, z, 1, 0) << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int l = 1 << 17, size = (2 * (1 << 17) - 1) + 1;
long long T[7][11][size];
long long Z(long long z, long long i) {
long long r = i % (2 * (z - 1));
if (r == 0) return 2;
if (r > 0 && r <= z) return r;
return 2 * z - r;
}
void Zmien(int i, int j, int k, int x) {
k += l;
T[i][j][k] = x;
k /= 2;
while (k != 0) {
T[i][j][k] = T[i][j][2 * k] + T[i][j][2 * k + 1];
k /= 2;
}
}
long long Suma(int i, int j, int a, int b) {
a += l;
b += l;
long long s = T[i][j][a];
if (a != b) s += T[i][j][b];
while (a / 2 != b / 2) {
if (a % 2 == 0) s += T[i][j][a + 1];
if (b % 2 == 1) s += T[i][j][b - 1];
a /= 2;
b /= 2;
}
return s;
}
int main() {
ios_base::sync_with_stdio(0);
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; ++i) cin >> a[i];
for (int i = 0; i < 7; ++i)
for (int j = 0; j < 11; ++j)
for (int k = 0; k <= size; ++k) T[i][j][k] = 0;
for (int i = 2; i <= 6; ++i) {
int T = 2 * (i - 1);
for (int j = 0; j < T; ++j)
for (int k = j; k < n; k += T) Zmien(i, j, k, a[k]);
}
int m;
cin >> m;
for (int i = 0; i < m; ++i) {
int t;
cin >> t;
if (t == 1) {
int p, v;
cin >> p >> v;
--p;
for (int j = 2; j <= 6; ++j) {
int T = 2 * (j - 1);
Zmien(j, p % T, p, v);
}
} else {
int l, r, z;
cin >> l >> r >> z;
--l;
--r;
long long odp = 0;
int T = 2 * (z - 1);
for (int j = 0; j < T; ++j)
odp += Suma(z, (l + j) % T, l, r) * Z(z, j + 1);
cout << odp << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long d[5][10][100001];
int a[100001];
void insert(long long dd[], int x, long long v) {
while (x < 100001) {
dd[x] += v;
x += x & -x;
}
}
long long qq(long long dd[], int x) {
long long res = 0;
while (x) {
res += dd[x];
x -= x & -x;
}
return res;
}
int f(int x, int d, int offset) {
x -= offset;
x %= (d * 2 - 2);
if (x < 0) x += d * 2 - 2;
if (!x) return 2;
if (x <= d) return x;
return 2 * d - x;
}
int main() {
int i, j, k, n, Q;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
for (j = 2; j <= 6; j++)
for (k = 0; k < j * 2 - 2; k++)
insert(d[j - 2][k], i, (long long)a[i] * f(i, j, k));
}
scanf("%d", &Q);
while (Q--) {
int ty;
scanf("%d", &ty);
if (ty == 2) {
int ll, rr, z;
scanf("%d%d%d", &ll, &rr, &z);
printf("%I64d\n", qq(d[z - 2][(ll - 1) % (2 * z - 2)], rr) -
qq(d[z - 2][(ll - 1) % (2 * z - 2)], ll - 1));
} else {
int p, v;
scanf("%d%d", &p, &v);
for (j = 2; j <= 6; j++)
for (k = 0; k < j * 2 - 2; k++)
insert(d[j - 2][k], p, (long long)(v - a[p]) * f(p, j, k));
a[p] = v;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = (int)1e5 + 7;
int n;
int q;
long long a[N];
long long coef(int z, int i) {
i %= (2 * (z - 1));
if (i < 0) {
i += 2 * (z - 1);
}
if (i == 0) {
return 2;
}
if (i <= z) {
return i;
}
return 2 * z - i;
}
long long t[7][13][N];
void add(int x, int y, int i, long long val) {
while (i <= n) {
t[x][y][i] += val;
i += i & (-i);
}
}
long long get(int x, int y, int i) {
long long sol = 0;
while (i >= 1) {
sol += t[x][y][i];
i -= i & (-i);
}
return sol;
}
int rep(int x, int val) {
x = 2 * (x - 1);
val %= x;
if (val < 0) {
val += x;
}
return val;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
cin >> q;
for (int z = 2; z <= 6; z++) {
for (int m = 0; m < 2 * (z - 1); m++) {
for (int i = 1; i <= n; i++) {
add(z, m, i, a[i] * coef(z, m + i));
}
}
}
while (q--) {
int type;
cin >> type;
if (type == 1) {
int i, x;
cin >> i >> x;
for (int z = 2; z <= 6; z++) {
for (int m = 0; m < 2 * (z - 1); m++) {
add(z, m, i, -a[i] * coef(z, m + i));
}
}
a[i] = x;
for (int z = 2; z <= 6; z++) {
for (int m = 0; m < 2 * (z - 1); m++) {
add(z, m, i, a[i] * coef(z, m + i));
}
}
continue;
}
int l, r, z;
cin >> l >> r >> z;
int mod = 2 * (z - 1);
int x = (r - l) / mod;
long long sol = 0;
for (int j = l + x * mod; j <= r; j++) {
sol += a[j] * coef(z, j - l + 1);
}
int m = rep(z, -(l - 1));
sol += get(z, m, l + x * mod - 1);
sol -= get(z, m, l - 1);
cout << sol << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 100005;
const int Maxt = 300005;
long long t[7][12][Maxt];
int a[Maxn];
void modify(int t1, int t2, int l, int r, int p, int k, long long val) {
if (l == r) {
t[t1][t2][p] = val;
return;
}
int m = (l + r) / 2;
if (k <= m) {
modify(t1, t2, l, m, p * 2, k, val);
} else {
modify(t1, t2, m + 1, r, p * 2 + 1, k, val);
}
t[t1][t2][p] = t[t1][t2][p * 2] + t[t1][t2][p * 2 + 1];
}
long long query(int t1, int t2, int l, int r, int p, int lo, int hi) {
if (l >= lo && r <= hi) return t[t1][t2][p];
int m = (l + r) / 2;
long long ans = 0;
if (lo <= m) {
ans += query(t1, t2, l, m, p * 2, lo, min(m, hi));
}
if (hi > m) {
ans += query(t1, t2, m + 1, r, p * 2 + 1, max(lo, m + 1), hi);
}
return ans;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
for (int j = 2; j <= 6; j++) {
modify(j, i % (2 * j - 2), 1, n, 1, i, (long long)a[i]);
}
}
int m;
scanf("%d", &m);
while (m--) {
int tp;
scanf("%d", &tp);
if (tp == 1) {
int p, val;
scanf("%d %d", &p, &val);
for (int j = 2; j <= 6; j++) {
modify(j, p % (2 * j - 2), 1, n, 1, p, (long long)val);
}
} else {
int lf, rg, z;
scanf("%d %d %d", &lf, &rg, &z);
long long ans = 0;
z = 2 * z - 2;
int now = lf % z;
for (int i = 1; i <= z; i++) {
int si;
if (i == 0)
si = 2;
else if (i <= (z + 2) / 2) {
si = i;
} else {
si = z + 2 - i;
}
ans += (long long)si *
query((z + 2) / 2, (now + i - 1) % z, 1, n, 1, lf, rg);
}
printf("%I64d\n", ans);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
class BIT {
public:
int N;
long long Arr[100010];
BIT() {}
int set_size(int _N) {
N = _N;
return 0;
}
int Modify(int x, long long delta) {
for (int i = x; i <= N; i += (i & (-i))) Arr[i] += delta;
return 0;
}
long long Query(int x) {
long long sum = 0;
for (int i = x; i > 0; i -= (i & (-i))) sum += Arr[i];
return sum;
}
};
BIT WTF[6][10];
int a[111111];
int zzSeq(int z, int i) {
if (i <= 0) return 0;
if (i % (2 * (z - 1)) == 0)
return 2;
else if (i % (2 * (z - 1)) <= z)
return i % (2 * (z - 1));
else
return 2 * z - i % (2 * (z - 1));
}
int Modify(int x, long long delta) {
for (int z = 2; z <= 6; z++) {
for (int off = 0; off < 2 * z - 2; off++) {
int zi = z - 2;
WTF[zi][off].Modify(x, delta * zzSeq(z, x - off));
}
}
return 0;
}
int main(void) {
int n = 0;
scanf("%d", &n);
for (int i = 0; i < 6; i++) {
for (int j = 0; j < 10; j++) WTF[i][j].set_size(n);
}
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) Modify(i, a[i]);
int q = 0;
scanf("%d", &q);
while (q--) {
int op = 0;
scanf("%d", &op);
if (op == 1) {
int p = 0;
int v = 0;
scanf("%d %d", &p, &v);
Modify(p, -a[p]);
a[p] = v;
Modify(p, a[p]);
} else {
int l = 0;
int r = 0;
int z = 0;
scanf("%d %d %d", &l, &r, &z);
int off = (l - 1) % (2 * z - 2);
printf("%I64d\n",
WTF[z - 2][off].Query(r) - WTF[z - 2][off].Query(l - 1));
}
}
while (getchar() != EOF)
;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100000;
int n, a[N], indices[11][N];
vector<long long> sum[11][11];
void insert(vector<long long> &vs, int k, int v) {
for (int i = k; i < (int)vs.size(); i += ~i & i + 1) {
vs[i] += v;
}
}
long long query(vector<long long> &vs, int k) {
long long result = 0;
for (int i = k; i >= 0; i -= ~i & i + 1) {
result += vs[i];
}
return result;
}
int fix(int n, int m, int r) {
while ((n % m + m) % m != r) {
n--;
}
if (n < 0) {
return -1;
}
return indices[m][n];
}
vector<int> zeta[7];
int main() {
for (int z = 2; z <= 6; ++z) {
for (int i = 1; i <= 2 * (z - 1); ++i) {
if (i % (2 * (z - 1)) == 0) {
zeta[z].push_back(2);
} else if (i % (2 * (z - 1)) <= z) {
zeta[z].push_back(i % (2 * (z - 1)));
} else {
zeta[z].push_back(2 * z - i % (2 * (z - 1)));
}
}
}
scanf("%d", &n);
for (int z = 2; z <= 10; z += 2) {
for (int i = 0; i < n; ++i) {
indices[z][i] = sum[z][i % z].size();
sum[z][i % z].push_back(0);
}
}
for (int i = 0; i < n; ++i) {
scanf("%d", a + i);
for (int z = 2; z <= 10; z += 2) {
insert(sum[z][i % z], indices[z][i], a[i]);
}
}
int m;
scanf("%d", &m);
while (m--) {
int type;
scanf("%d", &type);
if (type == 1) {
int p, v;
scanf("%d%d", &p, &v);
p--;
for (int z = 2; z <= 10; z += 2) {
insert(sum[z][p % z], indices[z][p], v - a[p]);
}
a[p] = v;
} else {
int l, r, z;
scanf("%d%d%d", &l, &r, &z);
l -= 2;
r--;
long long result = 0;
int mod = 2 * (z - 1);
for (int i = 0; i < mod; ++i) {
int rem = ((l + 1 + i) % mod + mod) % mod;
result += zeta[z][i] * (query(sum[mod][rem], fix(r, mod, rem)) -
query(sum[mod][rem], fix(l, mod, rem)));
}
cout << result << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 10;
struct node {
long long l, r, a[7][11];
} tr[4 * N];
long long s[7][11], a[N];
void init() {
for (long long i = 2; i <= 6; i++) {
for (long long j = 0; j < 2 * (i - 1); j++) {
if (j % (2 * (i - 1)) == 0)
s[i][j] = 2;
else if (j % (2 * (i - 1)) <= i)
s[i][j] = j % (2 * (i - 1));
else
s[i][j] = 2 * i - j % (2 * (i - 1));
}
}
}
void push(long long x) {
for (long long i = 2; i <= 6; i++)
for (long long j = 0; j < 2 * (i - 1); j++)
tr[x].a[i][j] =
tr[2 * x].a[i][j] +
tr[2 * x + 1]
.a[i][(tr[x * 2].r - tr[x * 2].l + 1 + j) % (2 * (i - 1))];
}
void build(long long x, long long l, long long r) {
tr[x].l = l, tr[x].r = r;
if (l == r) {
for (long long i = 2; i <= 6; i++)
for (long long j = 0; j < 2 * (i - 1); j++)
tr[x].a[i][j] = a[l] * s[i][j];
return;
}
long long mid = (l + r) / 2;
build(x * 2, l, mid), build(x * 2 + 1, mid + 1, r);
push(x);
}
void modif(long long x, long long k, long long d) {
if (tr[x].l == tr[x].r) {
for (long long i = 2; i <= 6; i++)
for (long long j = 0; j < 2 * (i - 1); j++) tr[x].a[i][j] = d * s[i][j];
return;
}
if (tr[x * 2].r >= k)
modif(x * 2, k, d);
else
modif(x * 2 + 1, k, d);
push(x);
}
long long query(long long x, long long l, long long r, long long z,
long long d) {
if (tr[x].l == l && tr[x].r == r) return tr[x].a[z][d];
if (tr[x * 2].r >= r) return query(x * 2, l, r, z, d);
if (tr[x * 2 + 1].l <= l) return query(x * 2 + 1, l, r, z, d);
return query(x * 2, l, tr[x * 2].r, z, d) +
query(x * 2 + 1, tr[x * 2 + 1].l, r, z,
(d + tr[x * 2].r - l + 1) % (2 * (z - 1)));
}
signed main() {
init();
long long n, m;
scanf("%lld", &n);
for (long long i = 1; i <= n; i++) scanf("%lld", &a[i]);
build(1, 1, n);
scanf("%lld", &m);
long long op, x, y, z;
while (m--) {
scanf("%lld", &op);
if (op == 1) {
scanf("%lld%lld", &x, &y);
modif(1, x, y);
} else {
scanf("%lld%lld%lld", &x, &y, &z);
printf("%lld\n", query(1, x, y, z, 1));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int limite = 1000000;
const int limitebis = 200000;
long long int suma[30][limite];
int seq[30][limitebis];
int numseq;
int primero, tope;
int n, m;
long long int a[limitebis];
int comienza[7];
void inserta(int pos, long long int val) {
int posa = pos;
a[posa] = val;
pos += primero;
for (int i = 0; i < numseq; i++) suma[i][pos] = seq[i][posa] * a[posa];
while (pos > 1) {
pos /= 2;
for (int i = 0; i < numseq; i++)
suma[i][pos] = suma[i][2 * pos] + suma[i][2 * pos + 1];
}
}
long long int sumaantes(int pos, int iseq) {
pos += primero;
long long int s = suma[iseq][pos];
while (pos > 1) {
if (pos % 2 == 1) s += suma[iseq][pos - 1];
pos /= 2;
}
return s;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
{
numseq = 0;
for (int i = 2; i <= 6; i++) {
comienza[i] = numseq;
int sig = 1;
seq[numseq][0] = 1;
for (int j = 1; j < limitebis; j++) {
seq[numseq][j] = seq[numseq][j - 1] + sig;
if (seq[numseq][j] == i)
sig = -1;
else if (seq[numseq][j] == 1)
sig = 1;
}
for (int k = 1; k < 2 * i - 2; k++)
for (int j = 0; j < limitebis; j++)
seq[numseq + k][j] =
seq[numseq + k - 1][(j - 1 + 2 * i - 2) % limitebis];
numseq += 2 * i - 2;
}
}
{
int nn = n;
primero = 1;
while (nn > 0) {
nn /= 2;
primero *= 2;
}
tope = 2 * primero;
for (int i = 0; i < n; i++) inserta(i, a[i]);
}
cin >> m;
for (int i = 0; i < m; i++) {
int t;
cin >> t;
if (t == 1) {
int p, val;
cin >> p >> val;
p--;
inserta(p, val);
} else {
int l, r, z;
cin >> l >> r >> z;
l--;
r--;
int iseq = comienza[z] + l % (2 * z - 2);
long long int s = sumaantes(r, iseq);
if (l > 0) s -= sumaantes(l - 1, iseq);
cout << s << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
long long tree[7][4 * N];
int tp[7][N];
int st[7][20];
int a[N];
int n, m;
long long ans;
void Read(int &x) {
char c;
while (c = getchar(), c < '0' || c > '9')
;
x = c - '0';
while (c = getchar(), c >= '0' && c <= '9') x = x * 10 + c - '0';
}
void Make(long long *t, int *a, int x, int l, int r) {
if (l == r) {
t[x] = a[l];
return;
}
int mid = (l + r) >> 1;
Make(t, a, x + x, l, mid);
Make(t, a, x + x + 1, mid + 1, r);
t[x] = t[x + x] + t[x + x + 1];
}
void Init() {
Read(n);
int temp;
for (int i = 1; i <= n; i++) Read(a[i]);
for (int i = 2; i <= 6; i++) {
int temp = (i + i - 2);
int tot = 0;
for (int j = 1; j <= temp; j++) {
st[i][j] = tot;
for (int k = j; k <= n; k += temp) tp[i][++tot] = a[k];
}
Make(tree[i], tp[i], 1, 1, n);
}
}
void Change(long long *t, int x, int l, int r, int pos, int value) {
if (l > pos || r < pos) return;
if (l == r) {
t[x] = value;
return;
}
int mid = (l + r) >> 1;
Change(t, x + x, l, mid, pos, value);
Change(t, x + x + 1, mid + 1, r, pos, value);
t[x] = t[x + x] + t[x + x + 1];
}
void Find(long long *t, int x, int l, int r, int st, int en) {
if (l > en || st > r) return;
if (st <= l && r <= en) {
ans += t[x];
return;
}
int mid = (l + r) >> 1;
Find(t, x + x, l, mid, st, en);
Find(t, x + x + 1, mid + 1, r, st, en);
}
void Work() {
Read(m);
int t, x, y, z;
for (int i = 1; i <= m; i++) {
Read(t);
if (t == 1) {
Read(x);
Read(y);
a[x] = y;
for (int j = 2; j <= 6; j++) {
int temp = j + j - 2, tt = (x - 1) % temp + 1;
Change(tree[j], 1, 1, n, st[j][tt] + (x - 1) / temp + 1, y);
}
} else {
Read(x);
Read(y);
Read(z);
int temp = z + z - 2, tt, J;
long long sum = 0;
for (int j = 1; j <= temp; j++) {
J = (j + x - 2) % temp + 1;
if (j > z) tt = z + z - j;
if (j <= z) tt = j;
if (j == temp) tt = 2;
int S = (x - 1) / temp + 1, E = (y - 1) / temp + 1;
if ((S - 1) * temp + J < x) S++;
if ((E - 1) * temp + J > y) E--;
ans = 0;
Find(tree[z], 1, 1, n, st[z][J] + S, st[z][J] + E);
sum += tt * ans;
}
printf("%I64d\n", sum);
}
}
}
int main() {
Init();
Work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 7, Z = 7;
long long read() {
long long s = 0, w = 1;
char c;
while (c = getchar(), c > '9' || c < '0')
if (c == '-') w = -1;
while (c >= '0' && c <= '9') s = s * 10 + c - '0', c = getchar();
return s * w;
}
void write(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) write(x / 10);
putchar(x % 10 | '0');
}
void wsp(long long x) {
write(x);
putchar(' ');
}
void wln(long long x) {
write(x);
putchar('\n');
}
long long n, m;
long long a[N];
struct seg {
long long z, ps;
long long s[N << 2];
void pushup(long long ts) { s[ts] = s[(ts << 1)] + s[(ts << 1 | 1)]; }
long long Val(long long x) {
x += ps;
long long p = 2 * (z - 1);
if (x % p == 0) return 2;
if (x % p <= z) return x % p;
return 2 * z - x % p;
}
void build(long long ts, long long l, long long r) {
if (l == r) {
s[ts] = a[l] * Val(l);
return;
}
long long mid = (l + r) >> 1;
build((ts << 1), l, mid);
build((ts << 1 | 1), mid + 1, r);
pushup(ts);
}
void change(long long ts, long long l, long long r, long long x,
long long v) {
if (l == r) {
s[ts] = v * Val(l);
return;
}
long long mid = (l + r) >> 1;
if (x <= mid)
change((ts << 1), l, mid, x, v);
else
change((ts << 1 | 1), mid + 1, r, x, v);
pushup(ts);
}
long long query(long long ts, long long l, long long r, long long L,
long long R) {
if (l == L && r == R) return s[ts];
long long mid = (l + r) >> 1;
if (R <= mid)
return query((ts << 1), l, mid, L, R);
else if (L > mid)
return query((ts << 1 | 1), mid + 1, r, L, R);
else
return query((ts << 1), l, mid, L, mid) +
query((ts << 1 | 1), mid + 1, r, mid + 1, R);
}
} T[7][11];
void change(long long l, long long x) {
for (long long i = 2; i <= 6; i++)
for (long long j = 0; j < 2 * (i - 1); j++) T[i][j].change(1, 1, n, l, x);
}
signed main() {
n = read();
for (long long i = 1; i <= n; i++) a[i] = read();
for (long long i = 2; i <= 6; i++)
for (long long j = 0; j < 2 * (i - 1); j++) {
T[i][j].z = i;
T[i][j].ps = j;
T[i][j].build(1, 1, n);
}
m = read();
for (long long i = 1, opt, l, r, x; i <= m; i++) {
opt = read();
if (opt == 1) {
l = read();
x = read();
change(l, x);
} else {
l = read();
r = read();
x = read();
long long p = 2 * (x - 1);
wln(T[x][(p - l % p + 1) % p].query(1, 1, n, l, r));
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 111111;
const long long OO = (long long)1 * 1e18;
long long arr[N];
long long tree[7][13][N];
int n, q;
void update(int x, long long y) {
for (int z = 2; z <= 6; z++)
for (int j = 0; j < 2 * (z - 1); j++) {
int zd = (x + 2 * (z - 1) - j) % (2 * (z - 1));
if (zd == 0)
zd = 2;
else if (zd > z)
zd = 2 * z - zd;
for (int t = x; t < N; t += t - (t & (t - 1))) tree[z][j][t] += y * zd;
}
}
long long ask(int x, int z, int d) {
long long ret = 0;
for (; x; x &= x - 1) ret += tree[z][d][x];
return ret;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> arr[i];
update(i, arr[i]);
}
cin >> q;
while (q--) {
int t, x, y, z;
cin >> t;
if (t == 1) {
cin >> x >> y;
update(x, -arr[x]);
arr[x] = y;
update(x, arr[x]);
} else {
cin >> x >> y >> z;
int m = 2 * (z - 1), j;
for (int k = 0; k < m; k++) {
int zd = (x + m - k) % m;
if (zd == 0)
zd = 2;
else if (zd > z)
zd = 2 * z - zd;
if (zd == 1) {
j = k;
break;
}
}
cout << ask(y, z, j) - ask(x - 1, z, j) << "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
inline int lb(int a) { return a & (-a); }
long long a[100100], bit[7][15][100100];
int n, m, t;
inline void adj(int z, int zm, int pos, long long val) {
for (int i = pos; i <= n; i += lb(i)) bit[z][zm][i] += val;
}
inline long long qry(int z, int zm, int pos) {
if (pos <= 0) return 0;
long long rt = 0;
for (int i = pos; i > 0; i -= lb(i)) rt += bit[z][zm][i];
return rt;
}
inline long long sum(int z, int zm, int l, int r) {
int z2 = z * 2 - 2;
int lb = l + zm - 1, rb = r;
if (lb > r) return 0;
while (rb % z2 != lb % z2) rb--;
lb -= z2;
if (rb < l) return 0;
return qry(z, rb % z2, rb) - qry(z, lb % z2, lb);
}
inline int s(int z, int i) {
int mod = i % (2 * z - 2);
if (mod == 0)
return 2;
else if (mod <= z)
return mod;
else
return 2 * z - mod;
}
inline void update(int p, int v) {
for (int z = 2; z <= 6; z++) {
int z2 = z * 2 - 2;
adj(z, p % z2, p, v - a[p]);
}
a[p] = v;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int in;
scanf("%d", &in);
update(i, in);
}
scanf("%d", &m);
while (m-- > 0) {
scanf("%d", &t);
if (t == 1) {
int p, v;
scanf("%d%d", &p, &v);
update(p, v);
} else {
int l, r, z;
scanf("%d%d%d", &l, &r, &z);
long long ans = 0;
int z2 = z * 2 - 2;
for (int i = 1; i <= z2; i++) {
ans += s(z, i) * sum(z, i, l, r);
}
printf("%I64d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 50;
int a[N], n, m;
long long b[N], tree[5][11][4 * N];
vector<long long> zig[7][11];
vector<long long> getzig(int z) {
vector<long long> res(2 * N);
int dir = 0, u = 1;
for (int i = 0; i < 2 * N; i++) {
res[i] = u;
if (u == z || u == 1) dir = !dir;
if (dir)
u++;
else
u--;
}
return res;
}
vector<long long> rot(vector<long long> zig, int z) {
vector<long long> res = zig;
for (int i = 0; i < zig.size() - 2 * z; i++)
res[i] = res[i + 2 * (z - 1) - 1];
return res;
}
void build(int l, int r, int id, long long tree[4 * N]) {
if (l == r) {
tree[id] = b[l];
return;
}
int mid = (l + r) / 2;
build(l, mid, id * 2, tree);
build(mid + 1, r, id * 2 + 1, tree);
tree[id] = tree[id * 2] + tree[id * 2 + 1];
}
void modify(int l, int r, int pos, int id, long long val,
long long tree[4 * N]) {
if (l == r) {
tree[id] = val;
return;
}
int mid = (l + r) / 2;
if (pos <= mid)
modify(l, mid, pos, id * 2, val, tree);
else
modify(mid + 1, r, pos, id * 2 + 1, val, tree);
tree[id] = tree[id * 2] + tree[id * 2 + 1];
}
long long query(int x, int y, int l, int r, int id, long long tree[4 * N]) {
if (l >= x && r <= y) return tree[id];
if (y < l || x > r) return 0;
int mid = (l + r) / 2;
return query(x, y, l, mid, id * 2, tree) +
query(x, y, mid + 1, r, id * 2 + 1, tree);
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int z = 2; z <= 6; z++) {
zig[z][0] = getzig(z);
for (int shift = 0; shift < 2 * (z - 1); shift++) {
for (int i = 0; i < n; i++) b[i] = zig[z][shift][i] * 1ll * a[i];
build(0, n - 1, 1, tree[z - 2][shift]);
zig[z][shift + 1] = rot(zig[z][shift], z);
}
printf("\n");
}
scanf("%d", &m);
for (int i = 0; i < m; i++) {
int tp;
scanf("%d", &tp);
if (tp == 1) {
long long pi, val;
scanf("%lld%lld", &pi, &val);
for (int z = 2; z <= 6; z++) {
for (int shift = 0; shift < 2 * (z - 1); shift++) {
modify(0, n - 1, pi - 1, 1, val * 1ll * zig[z][shift][pi - 1],
tree[z - 2][shift]);
}
}
} else {
int l, r, z;
scanf("%d%d%d", &l, &r, &z);
printf("%lld\n", query(l - 1, r - 1, 0, n - 1, 1,
tree[z - 2][(l - 1) % (2 * (z - 1))]));
}
}
return 0;
}
|
#include <bits/stdc++.h>
long long bit[10][10][100001];
long long sum(long long *b, int i) {
long long s = 0;
while (i > 0) {
s += b[i];
i -= i & -i;
}
return s;
}
void add(long long *b, int i, long long x) {
while (i <= 100000) {
b[i] += x;
i += i & -i;
}
}
int main() {
int n, m, i, j;
int a[100000];
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
for (j = 0; j < 10; j++) {
add(bit[j][i % (j + 1)], i + 1, a[i]);
}
}
scanf("%d", &m);
for (i = 0; i < m; i++) {
int t;
scanf("%d", &t);
if (t == 1) {
int p, v;
scanf("%d %d", &p, &v);
for (j = 0; j < 10; j++) {
add(bit[j][(p - 1) % (j + 1)], p, v - a[p - 1]);
}
a[p - 1] = v;
} else {
int l, r, z;
long long ans = 0;
scanf("%d %d %d", &l, &r, &z);
for (j = 1; j <= 2 * (z - 1); j++) {
int c;
if (j % (2 * (z - 1)) == 0) {
c = 2;
} else if (j % (2 * (z - 1)) <= z) {
c = j % (2 * (z - 1));
} else {
c = 2 * z - j % (2 * (z - 1));
}
ans += (sum(bit[2 * (z - 1) - 1][(l + j - 2) % (2 * (z - 1))], r) -
sum(bit[2 * (z - 1) - 1][(l + j - 2) % (2 * (z - 1))], l - 1)) *
c;
}
printf("%I64d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:100000000,100000000")
using namespace std;
const long long inf = 1e9 + 7;
const long long mod = 1e9 + 7;
const double eps = 1e-9;
const double PI = 2 * acos(0.0);
const double E = 2.71828;
struct SegTree {
long long* t;
void build(long long pos, long long L, long long R, long long a[]) {
if (L > R) return;
if (L == R)
t[pos] = a[L];
else {
long long Mid = (L + R) / 2;
build(pos * 2, L, Mid, a);
build(pos * 2 + 1, Mid + 1, R, a);
t[pos] = t[pos * 2] + t[pos * 2 + 1];
}
}
long long get(long long pos, long long tl, long long tr, long long L,
long long R) {
if (L > R) return 0;
if (L == tl && R == tr) return t[pos];
long long Mid = (tl + tr) / 2;
long long i = get(pos * 2, tl, Mid, L, min(Mid, R));
long long j = get(pos * 2 + 1, Mid + 1, tr, max(L, Mid + 1), R);
return i + j;
}
void update(long long pos, long long tl, long long tr, long long P,
long long val) {
if (tl == tr)
t[pos] = val;
else {
long long Mid = (tl + tr) / 2;
if (P <= Mid)
update(pos * 2, tl, Mid, P, val);
else
update(pos * 2 + 1, Mid + 1, tr, P, val);
t[pos] = t[pos * 2] + t[pos * 2 + 1];
}
}
} t[7][14];
long long aa[100001], bb[100001], A[7][14][100001], C[7][100001];
int main(void) {
long long n;
cin >> n;
for (int i = 0; i < n; i++) {
scanf("%I64d", &aa[i]);
}
for (int i = 2; i <= 6; i++) {
for (int y = 1; y <= i; y++) {
long long u = 1, h = y - 1;
for (int j = 0; j <= n; j++) {
h += u;
if (h == i) u = -1;
if (h == 1) u = 1;
bb[j] = h * aa[j];
A[i][y][j] = h;
if (h == 1) C[i][j] = y;
}
t[i][y].t = new long long[4 * n + 1];
t[i][y].build(1, 0, n - 1, bb);
}
for (int y = 1; y < i; y++) {
long long u = -1, h = i - y + 1;
for (int j = 0; j <= n; j++) {
h += u;
if (h == i) u = -1;
if (h == 1) u = 1;
bb[j] = h * aa[j];
A[i][y + i][j] = h;
if (h == 1) C[i][j] = y + i;
}
t[i][i + y].t = new long long[4 * n + 1];
t[i][i + y].build(1, 0, n - 1, bb);
}
}
long long m;
cin >> m;
for (int i = 0; i < m; i++) {
long long T;
scanf("%I64d", &T);
if (T == 1) {
long long a, b;
scanf("%I64d%I64d", &a, &b);
a--;
for (int j = 2; j <= 6; j++) {
for (int y = 1; y <= j; y++) {
t[j][y].update(1, 0, n - 1, a, b * A[j][y][a]);
}
for (int y = 1; y < j; y++) {
t[j][j + y].update(1, 0, n - 1, a, b * A[j][j + y][a]);
}
}
} else {
long long a, b, c;
scanf("%I64d%I64d%I64d", &a, &b, &c);
a--, b--;
long long w1 = C[c][a];
printf("%I64d\n", t[c][w1].get(1, 0, n - 1, a, b));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 1e5 + 10;
long long tree[MAXN * 4][7][11], s[6][MAXN], a[MAXN];
void Pushup(long long u, long long len) {
long long z, i, j;
for (z = 2; z <= 6; z++)
for (i = 0; i < 2 * (z - 1); i++)
tree[u][z][i] =
tree[u * 2][z][i] + tree[u * 2 + 1][z][(i + len) % (2 * (z - 1))];
return;
}
void Build(long long u, long long l, long long r) {
long long z, i;
if (l == r) {
for (z = 2; z <= 6; z++)
for (i = 0; i < (z - 1) * 2; i++) tree[u][z][i] = a[l] * s[z][i];
return;
}
long long mid = (l + r) >> 1;
Build(u * 2, l, mid);
Build(u * 2 + 1, mid + 1, r);
Pushup(u, mid - l + 1);
}
void Update(long long u, long long l, long long r, long long pos,
long long val) {
long long z, i;
if (l == r) {
for (z = 2; z <= 6; z++)
for (i = 0; i < 2 * (z - 1); i++) tree[u][z][i] = val * s[z][i];
return;
}
long long mid = (l + r) >> 1;
if (pos <= mid)
Update(u * 2, l, mid, pos, val);
else
Update(u * 2 + 1, mid + 1, r, pos, val);
Pushup(u, mid - l + 1);
}
long long Query(long long u, long long L, long long R, long long l, long long r,
long long z, long long i) {
if (L == l && R == r) return tree[u][z][i];
long long mid = (L + R) >> 1;
if (r <= mid) return Query(u * 2, L, mid, l, r, z, i);
if (l > mid) return Query(u * 2 + 1, mid + 1, R, l, r, z, i);
return Query(u * 2, L, mid, l, mid, z, i) +
Query(u * 2 + 1, mid + 1, R, mid + 1, r, z,
(i + mid - l + 1) % (2 * (z - 1)));
}
int main() {
long long n, m, z, i, j;
scanf("%lld", &n);
for (i = 1; i <= n; i++) scanf("%lld", &a[i]);
for (z = 2; z <= 6; z++) {
long long mod = 2 * (z - 1);
for (i = 1; i <= 100000; i++) {
if (i % mod == 0)
s[z][i - 1] = 2;
else if (i % mod <= z)
s[z][i - 1] = i % mod;
else
s[z][i - 1] = (z * 2) - (i % mod);
}
}
Build(1, 1, n);
scanf("%lld", &m);
for (i = 1; i <= m; i++) {
long long op;
scanf("%lld", &op);
if (op == 1) {
long long pos, val;
scanf("%lld %lld", &pos, &val);
Update(1, 1, n, pos, val);
} else {
long long l, r, z;
scanf("%lld %lld %lld", &l, &r, &z);
printf("%lld\n", Query(1, 1, n, l, r, z, 0));
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
const int nmax = 100009;
long long a[nmax];
int n;
long long F[8][13][nmax];
void update(int a, int b, int i, long long val) {
for (; i < nmax; i = (2 * i) - (i & (i - 1))) {
F[a][b][i] += val;
}
}
long long get(int a, int b, int i) {
long long ans = 0;
for (; i > 0; i = i & (i - 1)) ans += F[a][b][i];
return ans;
}
int Z(int z, int p) {
int tmp = 2 * (z - 1);
p %= tmp;
p += tmp;
p += tmp;
p %= tmp;
if (p == 0) return 2;
if (p <= z) return p;
return 2 * z - p;
}
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
}
for (int z = 2; z <= 6; ++z) {
for (int l = 0; l < 2 * (z - 1); ++l) {
for (int i = 1; i <= n; ++i) {
long long fz = Z(z, i - l + 1);
update(z, l, i, fz * a[i]);
}
}
}
int T;
cin >> T;
for (; T > 0; --T) {
int op;
cin >> op;
if (op == 1) {
int p;
long long val;
cin >> p >> val;
for (int z = 2; z <= 6; ++z) {
for (int l = 0; l < 2 * (z - 1); ++l) {
long long fz = Z(z, p - l + 1);
update(z, l, p, fz * (val - a[p]));
}
}
a[p] = val;
} else {
int l, r, z;
cin >> l >> r >> z;
long long ans =
get(z, l % (2 * (z - 1)), r) - get(z, l % (2 * (z - 1)), l - 1);
cout << ans << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long tree[12][12][(1 << 17)];
void add(int id1, int id2, int pos, long long val) {
for (int i = pos; i < (1 << 17); i = ((i) | (i + 1)))
tree[id1][id2][i] += val;
}
long long sum(int id1, int id2, int pos) {
long long ans = 0;
for (int i = pos; i > 0; i = ((i) & (i - 1))) ans += tree[id1][id2][i - 1];
return ans;
}
int a[100010];
void update(int pos, int x) {
int mod, i;
int d = x - a[pos];
a[pos] = x;
for (mod = 2; mod <= 10; mod++) add(mod, pos % mod, pos, d);
}
long long query(int L, int R, int mod) {
int i;
long long ans = 0;
for ((i) = 0; (i) < (int)(mod); (i)++) {
int coef = 1 + min(i, mod - i);
ans += coef * (sum(mod, (L + i) % mod, R) - sum(mod, (L + i) % mod, L));
}
return ans;
}
int main(void) {
int N, Q, mod, i;
scanf("%d", &N);
for ((i) = 0; (i) < (int)(N); (i)++) scanf("%d", &a[i]);
for (mod = 2; mod <= 10; mod += 2)
for ((i) = 0; (i) < (int)(N); (i)++) add(mod, i % mod, i, a[i]);
scanf("%d", &Q);
for ((i) = 0; (i) < (int)(Q); (i)++) {
int t, p, v, l, r, z;
scanf("%d", &t);
if (t == 1) {
scanf("%d%d", &p, &v);
update(p - 1, v);
} else {
scanf("%d%d%d", &l, &r, &z);
long long ans = query(l - 1, r, 2 * (z - 1));
cout << ans << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const int INF = 1000 * 1000 * 1000 + 7;
const int MOD = 1000 * 1000 * 1000 + 7;
const int MAX = 1000 * 100 + 47;
struct node {
long long ss[6 + 1][12];
};
long long a[MAX];
node t[MAX];
vector<long long> ss[6 + 4];
int n;
void calcs() {
for (int z = (2); z < (7); z++) {
for (int i = (1); i < (2 * (z - 1) + 1); i++) {
long long p = i % (2 * (z - 1));
if (p == 0) {
ss[z].push_back(2);
continue;
}
if (p <= z) {
ss[z].push_back(p);
continue;
}
ss[z].push_back(2 * z - p);
}
}
}
int get_ind(int ind1, int z1, int z, int ind2) {
int p = 2 * (z - 1), vid = abs(ind2 - ind1);
int ind;
if (ind1 <= ind2) {
ind = (z1 + vid) % p;
} else {
ind = (z1 - vid + vid * p) % p;
}
return ind;
}
int get_mult(int ind1, int z1, int z, int ind2) {
return ss[z][get_ind(ind1, z1, z, ind2)];
}
void add(int ind, long long val) {
int tochange = ind;
for (; ind < n; ind = (ind | (ind + 1))) {
int ind1 = (ind & (ind + 1));
for (int z = (2); z < (7); z++) {
for (int z1 = (0); z1 < (ss[z].size()); z1++) {
int mult = get_mult(ind1, z1, z, tochange);
t[ind].ss[z][z1] += mult * val;
}
}
}
}
long long getPref(int ind, int z, int z1) {
int begInd = ind;
long long res = 0;
for (; ind >= 0; ind = ((ind & (ind + 1)) - 1)) {
int ind1 = (ind & (ind + 1));
int toSumInd = get_ind(begInd, z1, z, ind1);
res += t[ind].ss[z][toSumInd];
}
return res;
}
long long getSum(int l, int r, int z) {
int indr = get_ind(l, 0, z, r);
long long res = getPref(r, z, indr);
if (l) {
int indl = get_ind(l, 0, z, l - 1);
res -= getPref(l - 1, z, indl);
}
return res;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
calcs();
cin >> n;
int x;
for (int i = (0); i < (n); i++) {
cin >> a[i];
add(i, a[i]);
}
int m, type, p, v, l, r, z;
cin >> m;
for (int i = (0); i < (m); i++) {
cin >> type;
if (type == 1) {
cin >> p >> v;
p--;
add(p, v - a[p]);
a[p] = v;
} else {
cin >> l >> r >> z;
l--;
r--;
long long res = getSum(l, r, z);
cout << res << "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int P = 1e9 + 7, mo1 = 1234567891, mo2 = 1e9 + 123;
const int N = 1e3 + 12, Base = 131, M = 2e3 + 13;
template <class Tv>
Tv umin(Tv a, Tv b) {
return a < b ? a : b;
}
template <class Tv>
Tv umax(Tv a, Tv b) {
return a > b ? a : b;
}
int n, m, s[7][90];
int a[100005];
struct BIT {
long long C[100005];
long long& operator[](int alp) { return C[alp]; }
int lowbit(int x) { return x & (-x); }
void modify(int x, long long k) {
for (int i = x; i <= n; i += lowbit(i)) C[i] += k;
}
void pri() {
for (int i = 1; i <= n; i++) {
cout << i << ':' << C[i] << endl;
}
}
long long query(int x) {
long long res = 0;
for (int i = x; i; i -= lowbit(i)) {
res += C[i];
}
return res;
}
} bit[7][13];
int omi(int v, int z) {
int alp = v % (2 * z - 2);
if (!alp)
return s[z][v] = 2, 2;
else if (alp > z)
return s[z][v] = 2 * z - alp, s[z][v];
else
return s[z][v] = alp, alp;
}
int pos(int i, int a, int b) {
if (i == 1) return a;
int tmp = i % b;
tmp = !tmp ? b : tmp;
if (a >= tmp)
return a - tmp + 1;
else
return b + 1 - (tmp - a);
}
void change(int ip, int val) {
for (int j = 2; j <= 6; j++)
for (int k = 1; k <= 2 * (j - 1); k++)
bit[j][pos(ip, k, 2 * j - 2)].modify(ip, 1ll * (val - a[ip]) * s[j][k]);
a[ip] = val;
}
int main() {
scanf("%d", &n);
for (int j = 2; j <= 6; j++) {
for (int k = 1; k <= 2 * (j - 1); k++) omi(k, j);
}
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
for (int j = 2; j <= 6; j++) {
for (int k = 1; k <= 2 * (j - 1); k++) {
bit[j][pos(i, k, 2 * j - 2)].modify(i, 1ll * a[i] * s[j][k]);
}
}
}
scanf("%d", &m);
while (m--) {
int opt;
scanf("%d", &opt);
if (opt == 1) {
int ip, v;
scanf("%d%d", &ip, &v);
change(ip, v);
} else {
int ql, qr, z;
scanf("%d%d%d", &ql, &qr, &z);
int ip = pos(ql, 1, (z - 1) * 2);
long long res = bit[z][ip].query(qr) - bit[z][ip].query(ql - 1);
printf("%lld\n", res);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
void PA(T x[], int n) {
for (int i = 0; i < n; ++i) cout << x[i] << " ";
cout << endl;
}
const int N = 100000;
int z[5][20];
int a[N];
int len[5];
struct Seg {
int l, r, lc, rc;
long long s[5][10];
} seg[N * 2];
int segn;
void update(Seg &ns, Seg &ls, Seg &rs) {
for (int n_ = (5), z = 0; z < n_; ++z)
for (int n_ = (len[z]), o = 0; o < n_; ++o) {
ns.s[z][o] = ls.s[z][o] + rs.s[z][o];
}
}
int seg_init(int l, int r) {
int p = segn++;
Seg &ns = seg[p];
ns.l = l, ns.r = r;
if (l == r) {
for (int n_ = (5), zz = 0; zz < n_; ++zz)
for (int n_ = (len[zz]), o = 0; o < n_; ++o)
ns.s[zz][o] = (long long)z[zz][(l + o) % len[zz]] * a[l];
return p;
}
int mid = (l + r) / 2;
ns.lc = seg_init(l, mid);
ns.rc = seg_init(mid + 1, r);
update(ns, seg[ns.lc], seg[ns.rc]);
return p;
}
void seg_ins(int p, int x, int v) {
Seg &ns = seg[p];
if (ns.l == ns.r) {
for (int n_ = (5), zz = 0; zz < n_; ++zz)
for (int n_ = (len[zz]), o = 0; o < n_; ++o)
ns.s[zz][o] = (long long)z[zz][(ns.l + o) % len[zz]] * v;
return;
}
int mid = (ns.l + ns.r) / 2;
if (x <= mid)
seg_ins(ns.lc, x, v);
else
seg_ins(ns.rc, x, v);
update(ns, seg[ns.lc], seg[ns.rc]);
}
long long seg_find(int p, int l, int r, int zz, int o) {
Seg &ns = seg[p];
if (l <= ns.l && ns.r <= r) {
return ns.s[zz][o];
}
int mid = (ns.l + ns.r) / 2;
long long ret = 0;
if (l <= mid) ret += seg_find(ns.lc, l, r, zz, o);
if (r > mid) ret += seg_find(ns.rc, l, r, zz, o);
return ret;
}
int main(int argc, char *argv[]) {
for (int n_ = (5), dz = 0; dz < n_; ++dz)
for (int n_ = (20), di = 0; di < n_; ++di) {
int zz = dz + 2;
int i = di + 1;
int &ret = z[dz][di];
if (i % (2 * (zz - 1)) == 0)
ret = 2;
else if (i % (int)(2 * (zz - 1)) <= zz)
ret = i % (2 * (zz - 1));
else
ret = 2 * zz - i % (2 * (zz - 1));
}
for (int n_ = (5), zz = 0; zz < n_; ++zz) len[zz] = (zz + 1) * 2;
int n;
cin >> n;
for (int n_ = (n), i = 0; i < n_; ++i) cin >> a[i];
seg_init(0, n - 1);
int m;
cin >> m;
while (m--) {
int t;
cin >> t;
if (t == 1) {
int p, v;
cin >> p >> v;
p--;
seg_ins(0, p, v);
} else {
int l, r, z;
cin >> l >> r >> z;
l--, r--, z -= 2;
long long ret = seg_find(0, l, r, z, (len[z] - l % len[z]) % len[z]);
cout << ret << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
long long size, n;
long long tre[7][17][262150];
void up(long long Z, long long N, long long x, long long v) {
x += size - 1;
long long d = v - tre[Z][N][x];
while (x) tre[Z][N][x] += d, x /= 2;
}
long long read(long long Z, long long N, long long s, long long e) {
s += size - 1;
e += size - 1;
long long r = 0;
while (s <= e) {
if (s % 2 == 1) r += tre[Z][N][s], s++;
if (e % 2 == 0) r += tre[Z][N][e], e--;
s /= 2, e /= 2;
}
return r;
}
void UP(long long P, long long K) {
long long i, j, d;
for (i = 2; i <= 6; i++) {
int T = 2 * i - 2;
for (j = 1; j <= T; j++) {
d = (P + T - j + 1) % T;
if (d == 0) d = 2;
if (d > i) d = 2 * i - d;
up(i, j, P, d * K);
}
}
}
int main() {
scanf("%I64d", &n);
long long i, k, j, p;
for (size = 1; size < n; size *= 2)
;
for (p = 1; p <= n; p++) {
scanf("%I64d", &k);
UP(p, k);
}
scanf("%I64d", &n);
while (n--) {
scanf("%I64d", &p);
if (p == 1) {
scanf("%I64d%I64d", &p, &k);
UP(p, k);
} else {
long long s, e, z;
long long D;
scanf("%I64d%I64d%I64d", &s, &e, &z);
D = 0;
long long rst = 0;
k = s % (z * 2 - 2);
if (k == 0) k = z * 2 - 2;
rst += read(z, k, s, e);
printf("%I64d\n", rst);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, size_t size>
class SegmentTree {
size_t pow2;
T* tree;
public:
SegmentTree() {
for (pow2 = 1; pow2 < size; pow2 <<= 1) continue;
tree = new T[pow2 << 1];
}
template <class UnaryFunction>
void push(int p, const T& x, UnaryFunction func) {
for (tree[p += pow2] = x; p > 1; p >>= 1)
tree[p >> 1] = func(tree[p], tree[p ^ 1]);
}
template <class UnaryFunction>
T query(int l, int r, UnaryFunction func, const T& initial = T()) {
T res = initial;
for (l += pow2, r += pow2; l < r; l >>= 1, r >>= 1) {
if (l & 1) res = func(res, tree[l++]);
if (r & 1) res = func(res, tree[--r]);
}
return res;
}
};
long long SUM(const long long& x, const long long& y) { return x + y; }
const size_t MAX_N = 1e5 + 5;
SegmentTree<long long, MAX_N> segtree[7][11];
inline long long z(int i, int z) {
if (i == 2 * z - 2) return 2;
if (i % (2 * z - 2) <= z) return i % (2 * z - 2);
return 2 * z - i % (2 * z - 2);
}
inline void modify(int i, long long a) {
for (int j = 2, t = 2; j <= 6; j++, t += 2)
for (int k = 0; k < t; k++)
segtree[j][(k + t * 60000 - i) % t].push(i, a * z(k + 1, j), SUM);
}
int main() {
ios::sync_with_stdio(false);
int n, m, t, p, v, l, r, z, a;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a;
modify(i, a);
}
cin >> m;
while (m-- && cin >> t)
if (t == 1) {
cin >> p >> v;
modify(p - 1, v);
} else {
cin >> l >> r >> z;
t = 2 * z - 2;
--l;
cout << segtree[z][(t * 60000 - l) % t].query(l, r, SUM) << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[111111];
long long s[7][13][111111];
void add(int x, long long y) {
for (int i = (2); i <= (6); ++i)
for (int j = 0; j < (2 * (i - 1)); ++j) {
int zd = (x + 2 * (i - 1) - j) % (2 * (i - 1));
if (zd == 0)
zd = 2;
else if (zd > i)
zd = 2 * i - zd;
for (int t = x; t < 111111; t += t - (t & (t - 1))) s[i][j][t] += y * zd;
}
}
long long ask(int x, int z, int d) {
long long ret = 0;
for (; x; x &= x - 1) ret += s[z][d][x];
return ret;
}
int main() {
scanf("%d", &n);
for (int i = (1); i <= (n); ++i) {
scanf("%d", a + i);
add(i, a[i]);
}
int q;
scanf("%d", &q);
for (int qq = 0; qq < (q); ++qq) {
int t, x, y, z;
scanf("%d", &t);
if (t == 1) {
scanf("%d%d", &x, &y);
add(x, -a[x]);
a[x] = y;
add(x, a[x]);
} else {
scanf("%d%d%d", &x, &y, &z);
int m = 2 * (z - 1);
int j;
for (int jj = 0; jj < (m); ++jj) {
int zd = (x + m - jj) % m;
if (zd == 0)
zd = 2;
else if (zd > z)
zd = 2 * z - zd;
if (zd == 1) {
j = jj;
break;
}
}
printf("%I64d\n", ask(y, z, j) - ask(x - 1, z, j));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXZ = 7;
struct SegmentTree {
int n;
long long *s;
static int L(int i) { return i << 1; }
static int R(int i) { return L(i) ^ 1; }
void init(int m) {
n = 1;
while (n < m) {
n <<= 1;
}
s = new long long[n + n];
fill(s, s + n + n, 0);
}
void set(int p, int v) {
p += n;
v -= s[p];
while (p > 0) {
s[p] += v;
p >>= 1;
}
}
long long get(int p, int pl, int pr, int l, int r) {
l = max(l, pl);
r = min(r, pr);
if (l >= r) {
return 0;
} else if (pl == l && pr == r) {
return s[p];
} else {
int pm = (pl + pr) / 2;
return get(L(p), pl, pm, l, r) + get(R(p), pm, pr, l, r);
}
}
long long get(int l, int r) { return get(1, 0, n, l, r); }
} st[MAXZ][MAXZ * 2];
inline int mz(int z) { return 2 * (z - 1); }
inline int siz(int i, int z) {
int r = i % mz(z);
if (r == 0) {
return 2;
} else if (r <= z) {
return r;
} else {
return 2 * z - r;
}
}
inline int idx(int i, int j, int z) { return (i - j + mz(z) - 1) / mz(z); }
int main() {
int n, m, t, l, r, z;
long long ans;
scanf("%d", &n);
for (int i = 2; i < MAXZ; ++i) {
for (int j = 0; j < mz(i); ++j) {
st[i][j].init(n / mz(i) + 2);
}
}
for (int i = 1; i <= n; ++i) {
scanf("%d", &z);
for (int j = 2; j < MAXZ; ++j) {
st[j][i % mz(j)].set(i / mz(j), z);
}
}
scanf("%d", &m);
for (int i = 0; i < m; ++i) {
scanf("%d%d%d", &t, &l, &r);
if (t == 1) {
for (int j = 2; j < MAXZ; ++j) {
st[j][l % mz(j)].set(l / mz(j), r);
}
} else {
scanf("%d", &z);
ans = 0;
++r;
for (int j = 0; j < mz(z); ++j) {
ans += siz((j - l % mz(z) + 1 + mz(z)) % mz(z), z) *
st[z][j].get(idx(l, j, z), idx(r, j, z));
}
printf("%I64d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:100000000,100000000")
using namespace std;
const long long inf = 1e9 + 7;
const long long mod = 1e9 + 7;
const double eps = 1e-9;
const double PI = 2 * acos(0.0);
const double E = 2.71828;
struct SegTree {
long long* t;
void build(long long pos, long long L, long long R, long long a[]) {
if (L > R) return;
if (L == R)
t[pos] = a[L];
else {
long long Mid = (L + R) / 2;
build(pos * 2, L, Mid, a);
build(pos * 2 + 1, Mid + 1, R, a);
t[pos] = t[pos * 2] + t[pos * 2 + 1];
}
}
long long get(long long pos, long long tl, long long tr, long long L,
long long R) {
if (L > R) return 0;
if (L == tl && R == tr) return t[pos];
long long Mid = (tl + tr) / 2;
long long i = get(pos * 2, tl, Mid, L, min(Mid, R));
long long j = get(pos * 2 + 1, Mid + 1, tr, max(L, Mid + 1), R);
return i + j;
}
void update(long long pos, long long tl, long long tr, long long P,
long long val) {
if (tl == tr)
t[pos] = val;
else {
long long Mid = (tl + tr) / 2;
if (P <= Mid)
update(pos * 2, tl, Mid, P, val);
else
update(pos * 2 + 1, Mid + 1, tr, P, val);
t[pos] = t[pos * 2] + t[pos * 2 + 1];
}
}
} t[7][14];
long long aa[100001], bb[100001], A[7][14][100001], C[7][100001];
int main(void) {
long long n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> aa[i];
}
for (int i = 2; i <= 6; i++) {
for (int y = 1; y <= i; y++) {
long long u = 1, h = y - 1;
for (int j = 0; j <= n; j++) {
h += u;
if (h == i) u = -1;
if (h == 1) u = 1;
bb[j] = h * aa[j];
A[i][y][j] = h;
if (h == 1) C[i][j] = y;
}
t[i][y].t = new long long[4 * n + 1];
t[i][y].build(1, 0, n - 1, bb);
}
for (int y = 1; y < i; y++) {
long long u = -1, h = i - y + 1;
for (int j = 0; j <= n; j++) {
h += u;
if (h == i) u = -1;
if (h == 1) u = 1;
bb[j] = h * aa[j];
A[i][y + i][j] = h;
if (h == 1) C[i][j] = y + i;
}
t[i][i + y].t = new long long[4 * n + 1];
t[i][i + y].build(1, 0, n - 1, bb);
}
}
long long m;
cin >> m;
for (int i = 0; i < m; i++) {
long long T;
cin >> T;
if (T == 1) {
long long a, b;
cin >> a >> b;
a--;
for (int j = 2; j <= 6; j++) {
for (int y = 1; y <= j; y++) {
t[j][y].update(1, 0, n - 1, a, b * A[j][y][a]);
}
for (int y = 1; y < j; y++) {
t[j][j + y].update(1, 0, n - 1, a, b * A[j][j + y][a]);
;
;
}
}
} else {
long long a, b, c;
cin >> a >> b >> c;
a--, b--;
long long w1 = C[c][a];
cout << t[c][w1].get(1, 0, n - 1, a, b) << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using namespace std;
long long seg[400001][5][15];
long long val[7][15];
void insert(int idx, int s, int e, int p, long long v) {
int x, y;
if (s == e) {
for (x = 2; x <= 6; x++)
for (y = 1; y < 2 * x - 1; y++) seg[idx][x - 2][y] = val[x][y] * v;
return;
}
int mid = (s + e) / 2;
if (p <= mid)
insert(idx * 2 + 1, s, mid, p, v);
else
insert(idx * 2 + 2, mid + 1, e, p, v);
for (x = 2; x <= 6; x++) {
for (y = 1; y < 2 * x - 1; y++) {
seg[idx][x - 2][y] = seg[idx * 2 + 1][x - 2][y];
int a = (mid - s + y) % (2 * (x - 1));
seg[idx][x - 2][y] += seg[idx * 2 + 2][x - 2][a + 1];
}
}
}
long long query(int idx, int s, int e, int st, int ed, int z, int ss) {
if (s == st && e == ed) return seg[idx][z - 2][ss];
int mid = (s + e) / 2;
if (ed <= mid)
return query(idx * 2 + 1, s, mid, st, ed, z, ss);
else if (st > mid)
return query(idx * 2 + 2, mid + 1, e, st, ed, z, ss);
int a = (mid - st + ss) % (2 * (z - 1));
return query(idx * 2 + 1, s, mid, st, mid, z, ss) +
query(idx * 2 + 2, mid + 1, e, mid + 1, ed, z, a + 1);
}
int main() {
int a, b, c, d, e, f, g, h, x, y, z;
for (x = 2; x <= 6; x++) {
a = 2 * (x - 1);
for (y = 1; y < 2 * x - 1; y++) {
if (y % a == 0)
val[x][y] = 2;
else if (y % a <= x)
val[x][y] = y % a;
else
val[x][y] = 2 * x - (y % a);
}
}
cin >> a;
for (x = 1; x <= a; x++) {
cin >> b;
insert(0, 1, a, x, b);
}
cin >> b;
for (x = 0; x < b; x++) {
cin >> c;
if (c == 1) {
cin >> d >> e;
insert(0, 1, a, d, (long long)e);
} else {
cin >> d >> e >> f;
cout << query(0, 1, a, d, e, f, 1) << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100110;
const int maxm = 100010;
char s[maxn][5];
long long sum[maxm * 4][5][11];
int n;
void init() {
for (int i = 1; i < maxn; i++)
for (int z = 2; z <= 6; z++) {
int tp = i % (2 * (z - 1));
if (tp == 0)
s[i][z - 2] = 2;
else if (tp <= z)
s[i][z - 2] = tp;
else
s[i][z - 2] = 2 * z - tp;
}
}
void build(int pos, int l, int r) {
for (int i = 2; i <= 6; i++)
for (int j = 0; j <= 10; j++) sum[pos][i - 2][j] = 0;
if (l == r) return;
int mid = (l + r) >> 1;
build((pos << 1), l, mid);
build(((pos << 1) | 1), mid + 1, r);
}
void insert(int pos, int l, int r, int i, int a) {
if (i < l || i > r) return;
if (l == r) {
for (int z = 2; z <= 6; z++)
for (int j = 0; j <= 10; j++)
sum[pos][z - 2][j] = (long long)s[i + j][z - 2] * a;
return;
}
int mid = (l + r) >> 1;
insert((pos << 1), l, mid, i, a);
insert(((pos << 1) | 1), mid + 1, r, i, a);
for (int z = 2; z <= 6; z++)
for (int j = 0; j <= 10; j++)
sum[pos][z - 2][j] =
sum[(pos << 1)][z - 2][j] + sum[((pos << 1) | 1)][z - 2][j];
}
long long search(int pos, int l, int r, int x, int y, int z, int offset) {
if (y < l || r < x) return 0;
if (x <= l && r <= y) return sum[pos][z - 2][offset];
int mid = (l + r) >> 1;
return search((pos << 1), l, mid, x, y, z, offset) +
search(((pos << 1) | 1), mid + 1, r, x, y, z, offset);
}
int main() {
init();
while (~scanf("%d", &n)) {
build(1, 1, n);
for (int i = 1; i <= n; i++) {
int a;
scanf("%d", &a);
insert(1, 1, n, i, a);
}
int m;
scanf("%d", &m);
while (m-- > 0) {
int t, p, v, l, r, z;
scanf("%d", &t);
if (t == 1) {
scanf("%d%d", &p, &v);
insert(1, 1, n, p, v);
} else {
scanf("%d%d%d", &l, &r, &z);
int offset = 0;
if (s[l][z - 2] <= s[l + 1][z - 2]) {
if (s[l][z - 2] == 1)
offset = 0;
else
offset = z - s[l][z - 2] + z - 1;
} else {
offset = s[l][z - 2] - 1;
}
cout << search(1, 1, n, l, r, z, offset) << endl;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[100100], n;
long long A[13][100100];
long long b[7][100100];
long long d[13][7][100100];
long long Q;
inline long long lowbit(long long x) { return x & (x ^ (x - 1)); }
long long getSum(long long delta, long long z, long long p) {
long long r = 0;
while (p) {
r += d[delta][z][p];
p -= lowbit(p);
}
return r;
}
void update(long long _p, long long _x) {
long long dx = _x - a[_p];
a[_p] = _x;
for (int k = 0; k <= 12; k++)
for (int z = 2; z <= 6; z++) {
long long p = _p + k;
long long x = dx * b[z][p];
while (p <= n + k) {
d[k][z][p] += x;
p += lowbit(p);
}
}
}
void init() {
for (int _p = 1; _p <= n; _p++) {
long long dx = a[_p];
for (int k = 0; k <= 12; k++)
for (int z = 2; z <= 6; z++) {
long long p = _p + k;
long long x = dx * b[z][p];
p += lowbit(p);
while (p <= n + k) {
d[k][z][p] += x;
p += lowbit(p);
}
}
}
}
int main() {
std::ios::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int j = 0; j < 13; j++)
for (int i = 1; i <= n; i++) A[j][i + j] = a[i];
cin >> Q;
for (int k = 0; k <= 12; k++) {
for (int z = 2; z <= 6; z++) {
for (int j = 1; j <= n + k; j++) {
int t, m = 2 * (z - 1);
if (j % m == 0)
t = 2;
else if (j % m <= z)
t = j % m;
else
t = 2 * z - j % m;
b[z][j] = t;
d[k][z][j] = t * A[k][j];
}
}
}
init();
while (Q--) {
long long op;
cin >> op;
if (op == 1) {
long long p, v;
cin >> p >> v;
update(p, v);
} else {
long long l, r, z;
cin >> l >> r >> z;
long long m = 2 * z - 2;
long long delta = m - (l - 1) % m;
long long R = getSum(delta, z, r + delta);
long long L = getSum(delta, z, l - 1 + delta);
cout << R - L << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int p[11][10], m[100100];
long long d[2 * (1 << 21)];
void add(int i, long long v) {
for (i += (1 << 21), v -= d[i]; i; d[i] += v, i >>= 1)
;
}
long long get(int i, int j) {
long long r;
for (r = 0, i += (1 << 21), j += (1 << 21); i <= j; i >>= 1, j >>= 1) {
if (i & 1) r += d[i++];
if (~j & 1) r += d[j--];
}
return r;
}
int main() {
int i, j, n, k, t, v, ii, jj, b;
long long r;
for (scanf("%d", &n), i = 0; i < n; scanf("%d", &m[i]), i++)
;
for (t = 0, k = 2; k <= 10; k++)
for (j = 0; j < k; j++)
for (p[k][j] = t, i = j; i < n; add(t, m[i]), t++, i += k)
;
for (scanf("%d", &n); n--;) {
scanf("%d", &t);
if (t == 1) {
scanf("%d%d", &i, &j);
i--;
for (k = 2; k <= 10; add(p[k][i % k] + i / k, j), k++)
;
} else {
scanf("%d%d%d", &i, &j, &k);
i--;
j--;
k = (k - 1) * 2;
for (r = 0, t = 0; t < k; t++) {
if (t > j) break;
v = p[k][t];
ii = (i + ((t - i) % k + k) % k) / k;
jj = (j - ((j - t) % k + k) % k) / k;
b = ((t - i) % k + k) % k;
r += get(v + ii, v + jj) * (b <= k / 2 ? b + 1 : k - b + 1);
}
printf("%I64d\n", r);
}
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.