text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
long long f[7][11][100005];
int p[100005][10], q[100005][10], n;
int low(int i) { return i & (-i); }
void up(int i, int j, int k, long long w) {
while (k <= n) {
f[i][j][k] += w;
k += low(k);
}
}
long long ask(int i, int j, int k) {
long long t = 0;
while (k > 0) {
t += f[i][j][k];
k -= low(k);
}
return t;
}
long long cal(int i, int z) {
if (i % (z + z - 2) == 0) return 2;
if (i % (z + z - 2) <= z) return i % (z + z - 2);
return z + z - (i % (z + z - 2));
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
int tmp;
cin >> tmp;
for (int j = 2; j <= 6; j++) {
int tot = (j - 1) * 2;
p[i][j] = (i - 1) % tot;
q[i][j] = (i - 1) / tot + 1;
up(j, p[i][j], q[i][j], tmp);
}
}
int m;
cin >> m;
while (m--) {
int t1, t2, t3, t4;
cin >> t1 >> t2 >> t3;
if (t1 == 1) {
for (int i = 2; i <= 6; i++) {
int pp = p[t2][i];
int qq = q[t2][i];
long long ff = ask(i, pp, qq) - ask(i, pp, qq - 1);
up(i, pp, qq, t3 - ff);
}
} else {
cin >> t4;
int tot = (t4 - 1) * 2;
int fuck = p[t2][t4], count = 1;
long long ans = 0;
for (int i = fuck;;) {
int l = t2;
int r = t3;
while (l <= t3 && (l - 1) % tot != i) l++;
while (r >= t2 && (r - 1) % tot != i) r--;
if (l <= r) {
ans += cal(count, t4) *
(ask(t4, i, q[r][t4]) - ask(t4, i, q[l][t4] - 1));
}
i = (i + 1) % tot;
count++;
if (i == fuck) break;
}
cout << ans << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[100005], nrq, typeq, lq, rq, zq, valq, posq;
int fact[100005][7][2 * 7];
long long aib[100005][7][2 * 7];
int mod(int a, int b) {
int ret = a % b;
if (ret < 0) ret += b;
return ret;
}
void buildFact() {
for (int i = 1; i <= n; ++i)
for (int z = 2; z <= 6; ++z)
for (int start = 0; start < 2 * z - 2; ++start) {
fact[i][z][start] = mod(i - start + 1, 2 * z - 2);
if (fact[i][z][start] == 0) fact[i][z][start] = 2;
if (fact[i][z][start] > z)
fact[i][z][start] = 2 * z - fact[i][z][start];
}
}
void update_aib(int pos, int val) {
for (int z = 2; z <= 6; ++z)
for (int start = 0; start < 2 * z - 2; ++start) {
int ps = pos;
long long x = 1LL * val * fact[pos][z][start];
while (ps <= n) {
aib[ps][z][start] += x;
ps += (ps & (-ps));
}
}
}
long long query_aib(int pos, int z, int start) {
long long ans = 0;
while (pos) {
ans += aib[pos][z][start];
pos -= (pos & (-pos));
}
return ans;
}
int main() {
scanf("%d", &n);
buildFact();
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
update_aib(i, a[i]);
}
scanf("%d", &nrq);
while (nrq--) {
scanf("%d", &typeq);
if (typeq == 1) {
scanf("%d %d", &posq, &valq);
valq -= a[posq];
a[posq] += valq;
update_aib(posq, valq);
} else {
scanf("%d %d %d", &lq, &rq, &zq);
int startq = lq % (2 * zq - 2);
printf("%I64d\n",
query_aib(rq, zq, startq) - query_aib(lq - 1, zq, startq));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
int n;
long long s[30][100010], a[100005];
long long idx[30][100010];
int c[10][20];
int i, j, z, m, k;
int lowbit(int x) { return x & (-x); }
void insert(int l, long long w, int x) {
for (int i = l; i <= n; i += lowbit(i)) idx[x][i] += w;
}
long long query(int l, int x) {
long long ans = 0;
for (int i = l; i > 0; i -= lowbit(i)) ans += idx[x][i];
return ans;
}
int main() {
int tmp = 0;
for (z = 2; z <= 6; z++) {
for (k = 1; k <= 2 * (z - 1); k++) {
c[z][k] = tmp;
if (k == 1) {
for (i = 1; i <= 100000; i++) {
int t = i % (2 * (z - 1));
if (t == 0)
s[tmp][i] = 2;
else if (t <= z)
s[tmp][i] = t;
else
s[tmp][i] = 2 * z - t;
}
} else {
s[tmp][1] = s[tmp - 1][100000];
for (i = 2; i <= 100000; i++) s[tmp][i] = s[tmp - 1][i - 1];
}
tmp++;
}
}
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%I64d", &a[i]);
for (z = 0; z < tmp; z++) insert(i, a[i] * s[z][i], z);
}
scanf("%d", &m);
while (m--) {
int how;
scanf("%d", &how);
if (how == 1) {
int l;
long long w;
scanf("%d%I64d", &l, &w);
for (z = 0; z < tmp; z++) insert(l, -a[l] * s[z][l], z);
a[l] = w;
for (z = 0; z < tmp; z++) insert(l, a[l] * s[z][l], z);
} else {
int l, r, x;
scanf("%d%d%d", &l, &r, &z);
x = l % (2 * (z - 1));
if (x == 0) x = 2 * (z - 1);
z = c[z][x];
printf("%I64d\n", query(r, z) - query(l - 1, z));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1 << 17;
int a[100005];
long long bit[12][12][maxn];
int n, q;
void add(int x, int y, int i, long long val) {
while (i < maxn) {
bit[x][y][i] += val;
i = ((i) | (i + 1));
}
}
long long sum(int x, int y, int i) {
long long ans = 0;
while (i > 0) {
ans += bit[x][y][i - 1];
i = ((i) & (i - 1));
}
return ans;
}
void upd(int pos, int x) {
int delta = x - a[pos];
a[pos] = x;
for (int i = 2; i <= 10; i++) add(i, pos % i, pos, delta);
}
long long qry(int l, int r, int md) {
long long ans = 0;
for (int i = 0; i < md; i++)
ans += (1 + min(i, md - i)) *
(sum(md, (l + i) % md, r) - sum(md, (l + i) % md, l));
return ans;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 2; i <= 10; i += 2)
for (int j = 0; j < n; j++) add(i, j % i, j, a[j]);
scanf("%d", &q);
while (q--) {
int t, p, x, l, r, z;
scanf("%d", &t);
if (t == 1) {
scanf("%d%d", &p, &x);
upd(p - 1, x);
} else {
scanf("%d%d%d", &l, &r, &z);
long long ans = qry(l - 1, r, 2 * (z - 1));
cout << ans << endl;
}
}
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>
using namespace std;
int gcd(int a, int b) { return a % b == 0 ? b : gcd(b, a % b); }
const int MAXN = 100010;
long long A[MAXN], val[32][MAXN];
long long C[32][MAXN];
int N, M;
long long res[6][15] = {{1, 2},
{1, 2, 3, 2},
{1, 2, 3, 4, 3, 2},
{1, 2, 3, 4, 5, 4, 3, 2},
{1, 2, 3, 4, 5, 6, 5, 4, 3, 2}};
const int tot[] = {2, 4, 6, 8, 10};
const int sum[] = {0, 0, 2, 6, 12, 20, 30};
inline int lowbit(int x) { return x & (-x); }
inline long long readint() {
char c = getchar();
while (!isdigit(c)) c = getchar();
int x = 0;
while (isdigit(c)) {
x = x * 10 + c - '0';
c = getchar();
}
return x;
}
inline void writeint(long long i) {
int buf[20];
int p = 0;
if (i == 0)
p++;
else
while (i) {
buf[p++] = i % 10;
i /= 10;
}
for (int j = p - 1; j >= 0; j--) putchar('0' + buf[j]);
}
int getidx(int x, int z) {
int add = x % tot[z - 2];
if (x % tot[z - 2] == 0) add = tot[z - 2];
return sum[z - 1] + add;
}
void update(int id, int pos, long long val) {
while (pos < MAXN) {
C[id][pos] += val;
pos += lowbit(pos);
}
}
long long getsum(int id, int pos) {
long long ret = 0;
while (pos > 0) {
ret += C[id][pos];
pos -= lowbit(pos);
}
return ret;
}
void settree() {
int idx = 1;
for (int i = 0; i < 5; i++) {
for (int j = 0; j < tot[i]; j++) {
for (int k = 1, st = j; k <= N; k++, st = (st - 1 + tot[i]) % tot[i])
val[idx][k] = res[i][st];
for (int k = 1; k <= N; k++) update(idx, k, A[k] * val[idx][k]);
idx++;
}
}
}
int main() {
while (scanf("%d", &N) != EOF) {
for (int i = 1; i <= N; i++) A[i] = readint();
settree();
scanf("%d", &M);
while (M--) {
int opt;
scanf("%d", &opt);
if (opt == 1) {
int pos;
long long value;
pos = (int)readint();
value = readint();
for (int i = 1; i <= 30; i++) {
long long add = A[pos] * val[i][pos] - value * val[i][pos];
update(i, pos, -add);
}
A[pos] = value;
} else {
int l, r, z;
l = readint();
r = readint();
z = readint();
int idx = getidx(l, z);
writeint(getsum(idx, r) - getsum(idx, l - 1));
putchar('\n');
}
}
}
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;
const int N = 100003;
long long a[N];
long long tag[7][10];
long long s[7][10][N * 4];
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
inline long long read1() {
long long x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
void push_up(int l, int r, int x) {
int mid = (l + r) >> 1, lson = x << 1, rson = lson | 1;
for (int z = 2; z <= 6; z++) {
int mod = (z - 1) << 1;
for (int i = 0; i < mod; i++)
s[z][i][x] = s[z][i][lson] + s[z][(i + mid - l) % mod][rson];
}
}
void build(int l, int r, int x) {
if (l + 1 == r) {
for (int z = 2; z <= 6; z++)
for (int i = 0; i < 2 * (z - 1); i++) s[z][i][x] = tag[z][i] * a[l];
return;
}
int mid = (l + r) >> 1, lson = x << 1, rson = lson | 1;
build(l, mid, lson);
build(mid, r, rson);
push_up(l, r, x);
}
void update(int pos, long long v, int l, int r, int x) {
if (l + 1 == r) {
for (int z = 2; z <= 6; z++)
for (int i = 0; i < 2 * (z - 1); i++) s[z][i][x] = tag[z][i] * v;
return;
}
int mid = (l + r) >> 1, lson = x << 1, rson = lson | 1;
if (pos < mid)
update(pos, v, l, mid, lson);
else
update(pos, v, mid, r, rson);
push_up(l, r, x);
}
long long query(int L, int R, int z, int i, int l, int r, int x) {
if (L <= l && r <= R) return s[z][i][x];
int mid = (l + r) >> 1, lson = x << 1, rson = lson | 1;
if (R <= mid) return query(L, R, z, i, l, mid, lson);
if (L >= mid) return query(L, R, z, i, mid, r, rson);
return query(L, mid, z, i, l, mid, lson) +
query(mid, R, z, (i + mid - L) % (2 * (z - 1)), mid, r, rson);
}
int main() {
int n, m, i, j;
int t, p, v, l, r, z;
for (int i = 2; i <= 6; i++) {
tag[i][0] = 2;
for (j = 1; j < 2 * (i - 1); j++) tag[i][j] = j <= i ? j : 2 * i - j;
}
n = read();
for (int i = 1; i <= n; i++) a[i] = read1();
build(1, n + 1, 1);
m = read();
while (m--) {
t = read();
if (t == 1) {
p = read();
v = read();
update(p, v, 1, n + 1, 1);
} else {
l = read();
r = read();
z = read();
printf("%I64d\n", query(l, r + 1, z, 1, 1, n + 1, 1));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
struct seg_tree {
int left, right;
long long sum[7][10];
} L[maxn << 2];
int s[7][10];
int n, m, a[maxn];
void init() {
for (int i = 2; i <= 6; i++) {
for (int j = 0; j < 2 * (i - 1); j++) {
if (j == 0)
s[i][j] = 2;
else if (j <= i)
s[i][j] = j;
else
s[i][j] = 2 * i - j;
}
}
}
void push_up(int step) {
for (int i = 2; i <= 6; i++) {
for (int j = 0; j < 2 * (i - 1); j++) {
int d = L[step << 1].right - L[step << 1].left + 1;
L[step].sum[i][j] = (L[step << 1].sum[i][j] +
L[step << 1 | 1].sum[i][(j + d) % (2 * (i - 1))]);
}
}
}
void build(int step, int l, int r) {
L[step].left = l, L[step].right = r;
if (l == r) {
for (int i = 2; i <= 6; i++) {
for (int j = 0; j < 2 * (i - 1); j++) {
L[step].sum[i][j] = (long long)s[i][j] * a[l];
}
}
return;
}
int m = (l + r) >> 1;
build(step << 1, l, m);
build(step << 1 | 1, m + 1, r);
push_up(step);
}
long long query(int step, int l, int r, int z, int x) {
if (L[step].left == l && L[step].right == r) return L[step].sum[z][x];
int m = (L[step].left + L[step].right) >> 1;
if (r <= m)
return query(step << 1, l, r, z, x);
else if (l > m)
return query(step << 1 | 1, l, r, z, x);
else
return query(step << 1, l, m, z, x) +
query(step << 1 | 1, m + 1, r, z, (x + (m - l + 1)) % (2 * (z - 1)));
}
void update(int step, int pos, int val) {
if (L[step].left == pos && L[step].right == pos) {
for (int i = 2; i <= 6; i++) {
for (int j = 0; j < 2 * (i - 1); j++)
L[step].sum[i][j] = (long long)val * s[i][j];
}
return;
}
int m = (L[step].left + L[step].right) >> 1;
if (pos <= m)
update(step << 1, pos, val);
else
update(step << 1 | 1, pos, val);
push_up(step);
}
int main() {
init();
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
build(1, 1, n);
scanf("%d", &m);
while (m--) {
int k, l, r, z;
scanf("%d", &k);
if (k == 1) {
scanf("%d%d", &l, &z);
update(1, l, z);
} else {
scanf("%d%d%d", &l, &r, &z);
printf("%lld\n", query(1, l, r, z, 1));
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int K;
long long s[2100000], z[10][100], ps[5][1000010];
void change(int x, long long v) {
x = x + (1 << K);
s[x] = v;
while (x > 1) {
x /= 2;
s[x] = s[x + x] + s[x + x + 1];
}
}
long long ask(int l, int r) {
l = l - 1 + (1 << K);
r = r + 1 + (1 << K);
long long ans = 0;
while (l + 1 < r) {
if (r & 1) ans += s[r - 1];
if (~l & 1) ans += s[l + 1];
l /= 2;
r /= 2;
}
return ans;
}
int main() {
int n, m;
scanf("%d", &n);
for (int i = 2; i <= 6; ++i) {
int now = (i - 2) * n + 1;
for (int j = 1; j <= i + i - 2; ++j)
for (int k = j; k <= n; k += (i + i - 2)) ps[i - 2][k] = now++;
}
for (int i = 2; i <= 6; ++i) {
int dir = 1;
z[i - 2][1] = 1;
for (int j = 2; j <= i + i - 2; ++j) {
z[i - 2][j] = z[i - 2][j - 1] + dir;
if (z[i - 2][j] == 1 || z[i - 2][j] == i) dir = -dir;
}
}
for (K = 1; K <= 22; ++K)
if (n * 5 <= (1 << K) - 2) break;
for (int i = 1; i <= n; ++i) {
int tmp;
scanf("%lld", &tmp);
for (int j = 0; j < 5; ++j) s[ps[j][i] + (1 << K)] = tmp;
}
for (int i = (1 << K) - 1; i >= 1; --i) s[i] = s[i + i] + s[i + i + 1];
scanf("%d", &m);
for (int i = 1; i <= m; ++i) {
int style, x, v, l, r;
scanf("%d", &style);
if (style == 1) {
scanf("%d %d", &x, &v);
for (int j = 0; j < 5; ++j) change(ps[j][x], v);
} else {
scanf("%d%d%d", &l, &r, &v);
long long ans = 0;
int ll = l, rr = r;
while (rr % (v + v - 2) != ll % (v + v - 2)) --rr;
for (int i = 0; i < v + v - 2; ++i, ++ll, ++rr) {
if (rr > r) rr = rr - (v + v - 2);
if (rr <= 0) continue;
if (ll > r) break;
ans += ask(ps[v - 2][ll], ps[v - 2][rr]) * z[v - 2][(ll - l) + 1];
}
printf("%I64d\n", ans);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long sum[12][12][100500];
int upb;
int lowbit(int x) { return x & (-x); }
long long getsum(int jl, int ks, int site) {
long long ret = 0;
while (site > 0) {
ret += sum[jl][ks][site];
site -= lowbit(site);
}
return ret;
}
void upda(int jl, int ks, int site, long long val) {
while (site <= upb) {
sum[jl][ks][site] += val;
site += lowbit(site);
}
}
int getjl(int x) {
if (x == 2) return 2;
return 2 * (x - 1);
}
int num[100005];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d", &num[i]);
upb = n;
for (int jl = 2; jl <= 10; ++jl) {
for (int i = 0; i < n; ++i) {
upda(jl, i % jl, i / jl + 1, num[i]);
}
}
int m;
int cho, l, r, z, p, v;
scanf("%d", &m);
for (int i = 0; i < m; ++i) {
scanf("%d", &cho);
if (cho == 1) {
scanf("%d%d", &p, &v);
--p;
for (int jl = 2; jl <= 10; ++jl) {
upda(jl, p % jl, p / jl + 1, -num[p] + v);
}
num[p] = v;
} else {
scanf("%d%d%d", &l, &r, &z);
--l, --r;
int jl = getjl(z);
int tot;
long long ans = 0;
int s, e, ks;
for (int j = 0; j < jl && l + j <= r; ++j) {
if (j + 1 <= z)
tot = j + 1;
else
tot = z - (j + 1 - z);
ks = (l + j) % jl;
s = (l + j) / jl;
e = s + (r - (l + j) + 1 + jl - 1) / jl;
ans += tot * (getsum(jl, ks, e) - getsum(jl, ks, s));
}
printf("%I64d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
const int N = 100005;
int mp[7][10];
int mp_r[30][2];
int n, m;
int ori[N];
int zig[7][10];
struct SegmentTree {
static const int N = ::N * 4;
struct Node {
long long sum[30];
} dat[N];
void update(int t, int l, int r) {
int mid = l + r >> 1;
int lc = (t << 1) + 1;
int rc = (t << 1) + 2;
for (int i = 0; i < 30; ++i) {
int x = mp_r[i][0];
int y = mp_r[i][1];
int y2 = (y + (mid - l + 1)) % (x + x - 2);
dat[t].sum[i] = dat[lc].sum[i] + dat[rc].sum[mp[x][y2]];
}
}
void build(int t, int l, int r, int *from) {
if (l == r) {
for (int i = 0; i < 30; ++i) {
int x = mp_r[i][0];
int y = mp_r[i][1];
dat[t].sum[i] = (long long)zig[x][y] * from[l];
}
return;
}
int mid = l + r >> 1;
int lc = (t << 1) + 1;
int rc = (t << 1) + 2;
build(lc, l, mid, from);
build(rc, mid + 1, r, from);
update(t, l, r);
}
long long query(int t, int l, int r, int p1, int p2, int x, int y) {
if (p1 <= l && r <= p2) {
int i = mp[x][(y + l - p1) % (x + x - 2)];
return dat[t].sum[i];
}
int mid = l + r >> 1;
int lc = (t << 1) + 1;
int rc = (t << 1) + 2;
if (p2 <= mid) return query(lc, l, mid, p1, p2, x, y);
if (mid < p1) return query(rc, mid + 1, r, p1, p2, x, y);
return query(lc, l, mid, p1, p2, x, y) +
query(rc, mid + 1, r, p1, p2, x, y);
}
void modify(int t, int l, int r, int p, int v) {
if (l == r) {
for (int i = 0; i < 30; ++i) {
int x = mp_r[i][0];
int y = mp_r[i][1];
dat[t].sum[i] = (long long)zig[x][y] * v;
}
return;
}
int mid = l + r >> 1;
if (p <= mid) {
int lc = (t << 1) + 1;
modify(lc, l, mid, p, v);
} else {
int rc = (t << 1) + 2;
modify(rc, mid + 1, r, p, v);
}
update(t, l, r);
}
} tree;
int main() {
int tot = 0;
for (int x = 2; x <= 6; ++x) {
int cur = 1;
bool dir = false;
for (int y = 0; y < x * 2 - 2; ++y) {
mp_r[tot][0] = x;
mp_r[tot][1] = y;
mp[x][y] = tot++;
zig[x][y] = cur;
if (cur == x || cur == 1) dir ^= 1;
if (dir)
++cur;
else
--cur;
}
}
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &ori[i]);
tree.build(0, 1, n, ori);
scanf("%d", &m);
for (int i = 1; i <= m; ++i) {
int o;
scanf("%d", &o);
if (o == 1) {
int p, v;
scanf("%d%d", &p, &v);
tree.modify(0, 1, n, p, v);
} else {
int l, r, z;
scanf("%d%d%d", &l, &r, &z);
long long res = tree.query(0, 1, n, l, r, z, 0);
printf("%I64d\n", res);
}
}
}
|
#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>
using namespace std;
long long ta[7][11][110000];
long long aa[110000];
int N;
inline int lowbit(int x) { return x & (-x); }
void Add(long long *ta, int x, long long v) {
for (; x <= N; x += lowbit(x)) ta[x] += v;
}
long long Sum(long long *ta, int x) {
long long res = 0;
for (; x; x -= lowbit(x)) res += ta[x];
return res;
}
inline int GetCoef(int p, int z) {
int m = p % (2 * (z - 1));
if (m == 0) return 2;
if (m <= z) return m;
return 2 * z - m;
}
int main() {
while (~scanf("%d", &N)) {
for (int i = 1; i <= N; ++i) {
long long v;
scanf("%I64d", &v);
aa[i] = v;
for (int j = 2; j <= 6; ++j)
for (int k = 0; k < 2 * (j - 1); ++k)
Add(ta[j][k], i, v * GetCoef(i + k, j));
}
int M;
scanf("%d", &M);
while (M--) {
int op;
scanf("%d", &op);
if (op == 1) {
int p;
long long v;
scanf("%d %I64d", &p, &v);
for (int j = 2; j <= 6; ++j)
for (int k = 0; k < 2 * (j - 1); ++k)
Add(ta[j][k], p, (v - aa[p]) * GetCoef(p + k, j));
aa[p] = v;
} else {
int l, r, z;
scanf("%d %d %d", &l, &r, &z);
int p = ((1 - l) % (2 * (z - 1)) + (2 * (z - 1))) % (2 * (z - 1));
printf("%I64d\n", Sum(ta[z][p], r) - Sum(ta[z][p], l - 1));
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
const double eps = 1e-6;
const double pi = acos(-1.0);
template <class Z>
inline Z SQ(Z &a) {
return a * a;
}
template <class Z>
inline bool checkmax(Z &a, Z b) {
if (a == -1 || a < b) {
a = b;
return true;
}
return false;
}
template <class Z>
inline bool checkmin(Z &a, Z b) {
if (a == -1 || a > b) {
a = b;
return true;
}
return false;
}
template <class Z>
inline bool mymax(Z &a, Z b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class Z>
inline bool mymin(Z &a, Z b) {
if (a > b) {
a = b;
return true;
}
return false;
}
int a[100005];
int n, m;
struct SegTree {
long long tree[100005 << 2];
inline void PushUp(int rt) {
tree[rt] = tree[(rt << 1)] + tree[(rt << 1 | 1)];
}
void build(int s, int z, int l, int r, int rt) {
if (l == r) {
long long v = a[l];
int tt = (l + s) % (2 * z - 2);
if (tt == 0)
tree[rt] = v * 2;
else if (tt <= z)
tree[rt] = v * tt;
else
tree[rt] = v * (2 * z - tt);
return;
}
int m = (l + r) >> 1;
build(s, z, l, m, rt << 1);
build(s, z, m + 1, r, rt << 1 | 1);
PushUp(rt);
}
void update(int s, int z, long long val, int x, int l, int r, int rt) {
if (l == r) {
int tt = (x + s) % (2 * z - 2);
if (tt == 0)
tree[rt] = val * 2;
else if (tt <= z)
tree[rt] = val * tt;
else
tree[rt] = val * (2 * z - tt);
return;
}
int m = (l + r) >> 1;
if (x <= m)
update(s, z, val, x, l, m, rt << 1);
else
update(s, z, val, x, m + 1, r, rt << 1 | 1);
PushUp(rt);
}
long long query(int ll, int rr, int l, int r, int rt) {
if (ll <= l && r <= rr) {
return tree[rt];
}
long long sum = 0;
int m = (l + r) >> 1;
if (ll <= m) sum += query(ll, rr, l, m, rt << 1);
if (rr > m) sum += query(ll, rr, m + 1, r, rt << 1 | 1);
return sum;
}
} tree[4][8], t6[10];
void input() {
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
}
void build() {
for (int z = 2; z <= 5; z++) {
for (int i = 0; i < 2 * z - 2; i++) {
tree[z - 2][i].build(i, z, 1, n, 1);
}
}
for (int i = 0; i < 10; i++) {
t6[i].build(i, 6, 1, n, 1);
}
}
void gao() {
scanf("%d", &m);
while (m--) {
int op;
scanf("%d", &op);
if (op == 1) {
int p, v;
scanf("%d%d", &p, &v);
for (int z = 2; z <= 5; z++) {
for (int i = 0; i < 2 * z - 2; i++) {
tree[z - 2][i].update(i, z, v, p, 1, n, 1);
}
}
for (int i = 0; i < 10; i++) {
t6[i].update(i, 6, v, p, 1, n, 1);
}
} else {
int l, r, z;
scanf("%d%d%d", &l, &r, &z);
int tp = l % (2 * z - 2);
if (tp == 0) tp = 2 * z - 2;
int s = (2 * z - 2) - tp + 1;
s %= (2 * z - 2);
if (z == 6)
printf("%I64d\n", t6[s].query(l, r, 1, n, 1));
else
printf("%I64d\n", tree[z - 2][s].query(l, r, 1, n, 1));
}
}
}
int main() {
while (~scanf("%d", &n)) {
input();
build();
gao();
}
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long labs(long long a) { return a < 0 ? (-a) : a; }
template <typename T>
inline T sqr(T x) {
return x * x;
}
const int MAXZ = 7;
const int MAXSHIFT = MAXZ * 2;
struct Fenwick {
vector<long long> t;
long long n;
void init(long long nn) {
n = nn;
t.assign(n, 0);
}
long long sum(long long r) {
long long result = 0;
for (; r >= 0; r = (r & (r + 1)) - 1) result += t[r];
return result;
}
void inc(long long i, long long delta) {
for (; i < n; i = (i | (i + 1))) t[i] += delta;
}
long long sum(long long l, long long r) { return sum(r) - sum(l - 1); }
void init(const vector<long long> &a) {
init(a.size());
for (long long i = 0; i < a.size(); i++) inc(i, a[i]);
}
};
Fenwick f[MAXZ][MAXSHIFT];
vector<long long> v;
long long getS(long long i, long long z) {
i++;
if (i % (2 * (z - 1)) == 0) return 2;
if (i % (2 * (z - 1)) <= z) return i % (2 * (z - 1));
return 2 * z - i % (2 * (z - 1));
}
int main() {
int n;
cin >> n;
v.resize(n);
for (int(i) = 0; (i) < (n); (i)++) {
cin >> v[i];
}
vector<long long> tmp;
for (long long z = 2; z < MAXZ; z++) {
long long msh = (z - 1) * 2;
for (long long sh = 0; sh < msh; sh++) {
tmp.clear();
for (int(i) = 0; (i) < (n); (i)++) {
tmp.push_back(getS(i - sh + msh, z) * v[i]);
}
f[z][sh].init(tmp);
}
}
int m;
cin >> m;
for (int(qqq) = 0; (qqq) < (m); (qqq)++) {
int t;
cin >> t;
if (t == 1) {
long long i, a;
cin >> i >> a;
i--;
for (long long z = 2; z < MAXZ; z++) {
long long msh = (z - 1) * 2;
for (long long sh = 0; sh < msh; sh++) {
f[z][sh].inc(i, (a - v[i]) * getS(i - sh + msh, z));
}
}
v[i] = a;
} else {
long long l, r, z;
cin >> l >> r >> z;
l--;
r--;
long long msh = (z - 1) * 2;
cout << f[z][l % msh].sum(l, r) << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
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() {
n = read();
for (int i = 1; i <= n; i++) a[i] = read();
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--;) {
t = read();
l = read();
r = read();
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;
struct seg {
int l, r, m, val;
long long sum[5][10];
bool fresh;
seg *par, *lc, *rc;
seg(long long _l, long long _r, seg *_par) : l(_l), r(_r), par(_par) {
m = (l + r) / 2;
lc = rc = NULL;
fresh = false;
if (l != r) {
lc = new seg(l, m, this);
rc = new seg(m + 1, r, this);
}
for (long long i = 2; i <= 6; ++i)
for (long long j = 0; j < (2 * (i - 1)); ++j) sum[i - 2][j] = 0;
}
void upd() {
if (fresh) return;
fresh = true;
if (l == r) {
for (long long i = 2; i <= 6; ++i) {
for (long long j = 0; j < (2 * (i - 1)); ++j) {
if (j == 0)
sum[i - 2][j] = val * 2;
else if (j <= i)
sum[i - 2][j] = val * j;
else
sum[i - 2][j] = val * (2 * i - j);
}
}
} else {
lc->upd();
rc->upd();
for (long long i = 2; i <= 6; ++i) {
int d = lc->r - lc->l + 1;
for (long long j = 0; j < (2 * (i - 1)); ++j) {
sum[i - 2][j] =
lc->sum[i - 2][j] + rc->sum[i - 2][(j + d) % (2 * (i - 1))];
}
}
}
}
void assign(long long pos, long long t) {
fresh = false;
if (l == r) {
val = t;
return;
}
if (pos <= m)
lc->assign(pos, t);
else
rc->assign(pos, t);
}
long long get(int L, int R, int z, int t) {
if (l == L && r == R) {
upd();
return sum[z - 2][t];
}
long long ans = 0;
if (L <= m) {
ans += lc->get(L, min(m, R), z, t);
t = (t + min(m, R) - L + 1) % (2 * (z - 1));
}
if (R > m) {
ans += rc->get(max(L, m + 1), R, z, t);
}
return ans;
}
};
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
seg stree(1, n, NULL);
for (long long i = 1; i <= n; ++i) {
long long a;
cin >> a;
stree.assign(i, a);
}
int m;
cin >> m;
for (long long i = 0; i < m; ++i) {
int type;
cin >> type;
if (type == 1) {
int pos, val;
cin >> pos >> val;
stree.assign(pos, val);
}
if (type == 2) {
int l, r, z;
cin >> l >> r >> z;
cout << stree.get(l, r, z, 1) << '\n';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool up_max(T& a, const T& b) {
return b > a ? a = b, 1 : 0;
}
template <class T>
bool up_min(T& a, const T& b) {
return b < a ? a = b, 1 : 0;
}
int n;
int a[100020];
int Z[7][20] = {
{},
{},
{2, 1, 2},
{4, 1, 2, 3, 2},
{6, 1, 2, 3, 4, 3, 2},
{8, 1, 2, 3, 4, 5, 4, 3, 2},
{10, 1, 2, 3, 4, 5, 6, 5, 4, 3, 2},
};
int cnt;
int pos[8][20];
long long c[32][100020];
void modify(long long* T, int x, long long delta) {
while (x <= n) T[x] += delta, x += (x & (-x));
}
long long getsum(long long* T, long long x) {
long long sum = 0;
while (x) sum += T[x], x -= (x & (-x));
return sum;
}
int trans(int i, int g) {
int t = i % g;
return t == 0 ? g : t;
}
void Init() {
memset(c, 0, sizeof(c));
;
cnt = 0;
for (int z = 2; z <= 6; ++z) {
for (int i = 1; i <= Z[z][0]; ++i) {
pos[z][i] = ++cnt;
for (int j = 1; j <= n; ++j) {
int t = (trans(j, Z[z][0]) + i - 1) % Z[z][0];
if (t == 0) t = Z[z][0];
modify(c[cnt], j, (long long)a[j] * Z[z][t]);
}
}
}
}
int main() {
while (cin >> n) {
for (int i = 1; i <= n; ++i) scanf("%d", a + i);
Init();
int m;
cin >> m;
while (m--) {
int op, x, y, z;
scanf("%d", &op);
if (1 == op) {
scanf("%d%d", &x, &y);
if (a[x] == y) continue;
int delta = a[x];
for (int z = 2; z <= 6; ++z) {
for (int i = 1; i <= Z[z][0]; ++i) {
int g = pos[z][i];
int t = (trans(x, Z[z][0]) + i - 1) % Z[z][0];
if (t == 0) t = Z[z][0];
modify(c[g], x, -(long long)delta * Z[z][t]);
modify(c[g], x, (long long)y * Z[z][t]);
}
}
a[x] = y;
} else {
scanf("%d%d%d", &x, &y, &z);
int t;
for (int i = 1; i <= Z[z][0]; ++i) {
int f = (trans(x, Z[z][0]) + i - 1) % Z[z][0];
if (f == 0) f = Z[z][0];
if (1 == f) {
t = i;
break;
}
}
t = pos[z][t];
long long ans = getsum(c[t], y);
ans -= getsum(c[t], x - 1);
cout << ans << endl;
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 100000;
const int MAX_E2 = 1 << 18;
const int MIN_Z = 2;
const int MAX_Z = 6;
const int Y = MAX_Z - MIN_Z + 1;
const int MIN_Z2 = 2 * (MIN_Z - 1);
const int MAX_Z2 = 2 * (MAX_Z - 1);
struct Elm {
long long ss[Y][MAX_Z2];
Elm() {}
void add(int i, long long v) {
for (int y = 0, z2 = MIN_Z2; z2 <= MAX_Z2; y++, z2 += 2) ss[y][i % z2] += v;
}
Elm operator+(const Elm &e) const {
Elm r;
for (int y = 0, z2 = MIN_Z2; z2 <= MAX_Z2; y++, z2 += 2)
for (int j = 0; j < z2; j++) r.ss[y][j] = ss[y][j] + e.ss[y][j];
return r;
}
void print() {
for (int y = 0, z2 = MIN_Z2; z2 <= MAX_Z2; y++, z2 += 2) {
printf("%d", z2 / 2 + 1);
for (int j = 0; j < z2; j++) printf(" %lld", ss[y][j]);
putchar('\n');
}
}
};
template <typename T, const int MAX_E2>
struct SegTree {
int n, e2;
T nodes[MAX_E2], zero;
SegTree() {}
void init(int _n) {
n = _n;
memset(&zero, 0, sizeof(zero));
for (e2 = 1; e2 < n; e2 <<= 1)
;
}
T &get(int i) { return nodes[e2 - 1 + i]; }
void set(int i, T v) {
int j = e2 - 1 + i;
nodes[j] = v;
while (j > 0) {
j = (j - 1) / 2;
nodes[j] = nodes[j * 2 + 1] + nodes[j * 2 + 2];
}
}
void setall() {
for (int j = e2 - 2; j >= 0; j--)
nodes[j] = nodes[j * 2 + 1] + nodes[j * 2 + 2];
}
T sum_range(int r0, int r1, int k, int i0, int i1) {
if (r1 <= i0 || i1 <= r0) return zero;
if (r0 <= i0 && i1 <= r1) return nodes[k];
int im = (i0 + i1) / 2;
T v0 = sum_range(r0, r1, k * 2 + 1, i0, im);
T v1 = sum_range(r0, r1, k * 2 + 2, im, i1);
return v0 + v1;
}
T sum_range(int r0, int r1) { return sum_range(r0, r1, 0, 0, e2); }
};
int as[MAX_N];
SegTree<Elm, MAX_E2> st;
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", as + i);
st.init(n);
for (int i = 0; i < n; i++) st.get(i).add(i, as[i]);
st.setall();
int m;
scanf("%d", &m);
while (m--) {
int t;
scanf("%d", &t);
if (t == 1) {
int p, v;
scanf("%d%d", &p, &v);
p--;
Elm e = st.get(p);
e.add(p, v - as[p]);
st.set(p, e);
as[p] = v;
} else {
int l, r, z;
scanf("%d%d%d", &l, &r, &z);
l--;
Elm e = st.sum_range(l, r);
int z2 = 2 * (z - 1);
long long sum = 0;
for (int i = 0; i < z2; i++) {
int szi = ((i < z - 1) ? i : z2 - i) + 1;
sum += e.ss[z - 2][(i + l) % z2] * szi;
}
printf("%lld\n", sum);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct BITree {
static const int size = 1 << 17;
long long data[size];
void add(int i, long long x) {
while (i <= size) {
data[i - 1] += x;
i += i & (-i);
}
}
long long query(int i) {
long long res = 0;
while (i > 0) {
res += data[i - 1];
i -= i & (-i);
}
return res;
}
long long query(int l, int r) { return query(r + 1) - query(l); }
void set(int i, long long x) { add(i + 1, x - query(i, i)); }
};
inline int mod(int z) { return 2 * (z - 1); }
inline long long zigzag(int i, int z) {
i %= mod(z);
if (i == 0)
return 2;
else if (i > z)
return 2 * z - i;
return i;
}
int n, m;
BITree tree[15][15];
void update(int x, int val) {
for (int z = 2; z <= 6; z++) {
for (int shift = 0; shift < 2 * (z - 1); shift++) {
tree[z][shift].set(x, zigzag((x + shift) % mod(z), z) * val);
}
}
}
long long query(int l, int r, int z) {
int shift = (mod(z) - l % mod(z) + 1) % mod(z);
return tree[z][shift].query(l, r);
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int ai;
scanf("%d", &ai);
update(i, ai);
}
scanf("%d", &m);
while (m--) {
int t;
scanf("%d", &t);
if (t == 1) {
int p, v;
scanf("%d %d", &p, &v);
p--;
update(p, v);
} else {
int l, r, z;
scanf("%d %d %d", &l, &r, &z);
l--, r--;
printf("%I64d\n", query(l, r, z));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
class BinaryIndexedTree {
int N;
vector<long long> tree;
public:
BinaryIndexedTree(int _N = 0) : N(_N), tree(vector<long long>(_N + 1)) {}
long long get_cumfreq(int idx) {
long long sum = 0;
for (; idx > 0; idx -= (idx & -idx)) sum += tree[idx];
return sum;
}
void update(int idx, long long val = 1) {
for (; idx <= N; idx += (idx & -idx)) tree[idx] += val;
}
long long get_freq(int idx) {
if (idx <= 0) return 0;
long long sum = tree[idx];
int z = idx - (idx & -idx);
for (--idx; idx != z; idx -= (idx & -idx)) sum -= tree[idx];
return sum;
}
};
int N;
long long A[100004];
int S[7][11];
BinaryIndexedTree bit[7][11];
int main(int argc, char* argv[]) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> N;
for (int i = 1; i <= N; ++i) cin >> A[i];
for (int z = 2; z <= 6; ++z) {
int M = 2 * (z - 1);
for (int i = 1; i <= M; ++i) {
int iModM = i % M;
S[z][i] = iModM == 0 ? 2 : (iModM <= z ? iModM : (2 * z - iModM));
}
S[z][0] = S[z][M];
for (int ini = 1; ini <= M; ++ini) {
bit[z][ini] = BinaryIndexedTree(N);
for (int i = ini; i <= N; ++i) {
int iModM = (i - ini + 1) % M;
bit[z][ini].update(i, A[i] * S[z][iModM]);
}
}
}
int Q;
cin >> Q;
while (Q-- > 0) {
int t;
cin >> t;
if (t == 1) {
int p, v;
cin >> p >> v;
for (int z = 2; z <= 6; ++z) {
int M = 2 * (z - 1);
for (int ini = 1; ini <= M; ++ini) {
if (p < ini) continue;
int iModM = (p - ini + 1) % M;
bit[z][ini].update(p, (v - A[p]) * S[z][iModM]);
}
}
A[p] = v;
} else {
int L, R, z;
cin >> L >> R >> z;
int M = 2 * (z - 1);
int LModM = L % M;
if (LModM == 0) LModM = M;
long long res =
bit[z][LModM].get_cumfreq(R) - bit[z][LModM].get_cumfreq(L - 1);
cout << res << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(0) * 2;
template <class T>
inline T abs1(T a) {
return a < 0 ? -a : a;
}
template <class T>
inline T max1(T a, T b) {
return a > b ? a : b;
}
template <class T>
inline T min1(T a, T b) {
return a < b ? a : b;
}
template <class T>
inline T gcd1(T a, T b) {
if (a < b) swap(a, b);
if (a % b == 0) return b;
return gcd1(b, a % b);
}
template <class T>
inline T lb(T num) {
return num & (-num);
}
template <class T>
inline int bitnum(T num) {
int ans = 0;
while (num) {
num -= lb(num);
ans++;
}
return ans;
}
long long pow(long long n, long long m, long long mod = 0) {
long long ans = 1;
long long k = n;
while (m) {
if (m & 1) {
ans *= k;
if (mod) ans %= mod;
}
k *= k;
if (mod) k %= mod;
m >>= 1;
}
return ans;
}
const int maxn = 101000;
template <class t>
struct tree_array {
t num[maxn], n;
void upd(int no, t add) {
while (no <= n) {
num[no] += add;
no += lb(no);
}
}
t que(int no) {
t ans = 0;
while (no) {
ans += num[no];
no -= lb(no);
}
return ans;
}
};
tree_array<long long> tra[35];
const int be_tra[5] = {0, 2, 6, 12, 20};
long long orig[maxn];
int n, m;
int main() {
scanf("%d", &n);
for (int i = 0; i < 30; i++) tra[i].n = n;
for (int i = 1; i <= n; i++) {
scanf("%I64d", &orig[i]);
for (int j = 0; j < 5; j++)
tra[i % (2 * (j + 1)) + be_tra[j]].upd(i, orig[i]);
}
scanf("%d", &m);
for (int i = 0; i < m; i++) {
int f;
scanf("%d", &f);
if (f == 2) {
int l, r, z;
scanf("%d%d%d", &l, &r, &z);
int z1 = 2 * (z - 1);
long long ans = 0;
for (int i = 1; i <= z; i++)
ans += i * (tra[be_tra[z - 2] + (i - 1 + l) % z1].que(r) -
tra[be_tra[z - 2] + (i - 1 + l) % z1].que(l - 1));
for (int i = 1; i <= z - 2; i++)
ans += (z - i) * (tra[be_tra[z - 2] + (z + i - 1 + l) % z1].que(r) -
tra[be_tra[z - 2] + (z + i - 1 + l) % z1].que(l - 1));
printf("%I64d\n", ans);
} else {
int no, ne;
scanf("%d%d", &no, &ne);
int add = ne - orig[no];
orig[no] = ne;
for (int i = 0; i < 5; i++)
tra[be_tra[i] + no % (2 * i + 2)].upd(no, add);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
T abs(T x) {
return x > 0 ? x : -x;
}
int n;
int m;
int x[100000];
long long f[5][10][100001];
int add(int t, int s, int x, int y) {
x++;
while (x <= n) {
f[t][s][x] += y;
x |= x + 1;
}
return 0;
}
long long get(int t, int s, int x) {
x++;
long long y = 0;
while (x > 0) {
y += f[t][s][x];
x = (x & (x + 1)) - 1;
}
return y;
}
long long get(int t, int s, int a, int b) {
return get(t, s, b) - get(t, s, a - 1);
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &x[i]);
for (int j = 2; j <= 6; j++) add(j - 2, i % (2 * (j - 1)), i, x[i]);
}
scanf("%d", &m);
for (int i = 0; i < m; i++) {
int t, a, b, c;
scanf("%d", &t);
if (t == 1) {
scanf("%d%d", &a, &b);
a--;
for (int j = 2; j <= 6; j++) add(j - 2, a % (2 * (j - 1)), a, b - x[a]);
x[a] = b;
} else {
scanf("%d%d%d", &a, &b, &c);
a--;
b--;
long long ans = 0;
for (int j = 0; j < 2 * (c - 1); j++) {
int p = (a + j) % (2 * (c - 1));
int k = j + 1;
if (k > c) k = 2 * c - k;
ans += k * get(c - 2, p, a, b);
}
printf("%I64d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
long long zz[7][100035];
long long a[100005], b[7][12][100005];
inline int add(int ii, int jj, int kk, long long val) {
while (kk <= n) {
b[ii][jj][kk] += val;
kk += (kk & (-kk));
}
return 0;
}
inline long long ask(int ii, int jj, int kk) {
long long res = 0;
while (kk > 0) {
res += b[ii][jj][kk];
kk -= (kk & (-kk));
}
return res;
}
inline int print() {
for (int i = 2; i <= 6; i++) {
for (int j = 1; j <= 2 * (i - 1); j++) {
cout << "i=" << i << ",j=" << j << ":";
for (int k = 1; k <= n; k++) {
cout << ask(i, j, k) - ask(i, j, k - 1) << " ";
}
cout << endl;
}
}
return 0;
}
int main() {
for (int i = 2; i <= 6; i++) {
for (int j = 1; j <= 100020; j++) {
int tmp = j % (2 * (i - 1));
if (tmp == 0)
zz[i][j] = 2;
else if (tmp > 0 && tmp <= i)
zz[i][j] = tmp;
else
zz[i][j] = 2 * i - tmp;
}
}
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 2; i <= 6; i++) {
for (int j = 1; j <= 2 * (i - 1); j++) {
for (int k = 0; k <= n; k++) {
b[i][j][k] = 0;
}
}
}
for (int i = 2; i <= 6; i++) {
for (int j = 1; j <= 2 * (i - 1); j++) {
for (int k = 1, p = 1; k <= n; k++, p++) {
add(i, j, k, a[k] * zz[i][p + j - 1]);
}
}
}
cin >> m;
int t, p, v, l, r, z;
for (int i = 0; i < m; i++) {
cin >> t;
if (t == 1) {
cin >> p >> v;
long long tmp = a[p];
a[p] = v;
for (int i = 2; i <= 6; i++) {
for (int j = 1; j <= 2 * (i - 1); j++) {
long long ne = (a[p] - tmp) * zz[i][p + j - 1];
add(i, j, p, ne);
}
}
} else {
cin >> l >> r >> z;
int jj = (2 * (z - 1)) + 1 - ((l - 1) % (2 * (z - 1)));
if (jj > (2 * (z - 1))) jj -= (2 * (z - 1));
long long rr = ask(z, jj, r);
long long ll = ask(z, jj, l - 1);
cout << rr - ll << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 100010;
long long bit[10][15][MAX_N + 1];
int sizeN;
void initBIT(int n_) {
sizeN = n_;
for (int i = 0; i < 10; i++)
for (int j = 0; j < 15; j++)
for (int k = 0; k < MAX_N + 1; k++) bit[i][j][k] = 0;
}
long long sumBIT(int z, int mod, int i) {
i++;
long long segmentSum = 0;
while (i > 0) {
segmentSum += bit[z][mod][i];
i -= (i & (-i));
}
return segmentSum;
}
void addBIT(int z, int mod, int i, long long value) {
i++;
while (i <= sizeN) {
bit[z][mod][i] += value;
i += (i & (-i));
}
}
long long a[100010], limit[10][15];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int z = 2; z <= 6; z++) {
limit[z][0] = 1;
for (int mod = 1; mod < (z - 1) * 2; mod++) {
if (mod < z)
limit[z][mod] = limit[z][mod - 1] + 1;
else
limit[z][mod] = limit[z][mod - 1] - 1;
}
}
initBIT(n);
for (int z = 2; z <= 6; z++) {
for (int mod = 0; mod < (z - 1) * 2; mod++) {
for (int i = 0; i < n; i++)
addBIT(z, mod, i, a[i] * limit[z][(i + mod) % ((z - 1) * 2)]);
}
}
int m, ti, pi, vi, li, ri, zi;
cin >> m;
for (int i = 0; i < m; i++) {
cin >> ti;
if (ti == 1) {
cin >> pi >> vi;
pi--;
for (int z = 2; z <= 6; z++) {
for (int mod = 0; mod < (z - 1) * 2; mod++) {
long long margin =
(vi - a[pi]) * limit[z][(pi + mod) % ((z - 1) * 2)];
addBIT(z, mod, pi, margin);
}
}
a[pi] = vi;
} else {
cin >> li >> ri >> zi;
li--;
ri--;
cout << sumBIT(zi,
((zi - 1) * 2 - (li % ((zi - 1) * 2))) % ((zi - 1) * 2),
ri) -
sumBIT(
zi,
((zi - 1) * 2 - (li % ((zi - 1) * 2))) % ((zi - 1) * 2),
li - 1)
<< endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int TB[][10] = {{},
{},
{1, 2},
{1, 2, 3, 2},
{1, 2, 3, 4, 3, 2},
{1, 2, 3, 4, 5, 4, 3, 2},
{1, 2, 3, 4, 5, 6, 5, 4, 3, 2}};
long long sum[400001][7][10];
void PushUp(int l, int r, int rt) {
int m = l + r >> 1;
int x = m - l + 1;
for (int z = 2; z <= 6; z++) {
for (int i = 0; i < 2 * z - 2; i++)
sum[rt][z][i] =
sum[rt << 1][z][i] + sum[rt << 1 | 1][z][(i + x) % (2 * z - 2)];
}
}
void build(int l, int r, int rt) {
if (l == r) {
int a;
cin >> a;
for (int z = 2; z <= 6; z++) {
for (int i = 0; i < 2 * z - 2; i++)
sum[rt][z][i] = (long long)a * TB[z][i];
}
return;
}
int m = (l + r) >> 1;
build(l, m, rt << 1);
build(m + 1, r, rt << 1 | 1);
PushUp(l, r, rt);
}
void Update(int p, int v, int l, int r, int rt) {
if (r == l) {
for (int z = 2; z <= 6; z++) {
for (int i = 0; i < 2 * z - 2; i++)
sum[rt][z][i] = TB[z][i] * (long long)v;
}
return;
}
int m = (l + r) >> 1;
if (p <= m)
Update(p, v, l, m, rt << 1);
else
Update(p, v, m + 1, r, rt << 1 | 1);
PushUp(l, r, rt);
}
long long query(int L, int R, int z, int l, int r, int rt) {
if (L <= l && r <= R) {
return sum[rt][z][(l - L) % (2 * z - 2)];
}
int m = (l + r) >> 1;
long long ans = 0;
if (L <= m) ans += query(L, R, z, l, m, rt << 1);
if (R > m) ans += query(L, R, z, m + 1, r, rt << 1 | 1);
return ans;
}
int main() {
std::ios_base::sync_with_stdio(false);
int n;
cin >> n;
memset(sum, 0, sizeof(sum));
build(1, n, 1);
int m;
cin >> m;
for (int i = 0; i < m; i++) {
int t;
cin >> t;
if (t == 1) {
int p, v;
cin >> p >> v;
Update(p, v, 1, n, 1);
} else {
int l, r, z;
cin >> l >> r >> z;
printf("%I64d\n", query(l, r, z, 1, n, 1));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long spf[101];
long long fac[101];
void sieve() {
spf[1] = 1;
for (long long i = 2; i < 101; i++) spf[i] = i;
for (long long i = 4; i < 101; i += 2) spf[i] = 2;
for (long long i = 3; i * i < 101; i++) {
if (spf[i] == i) {
for (long long j = i * i; j < 101; j += i)
if (spf[j] == j) spf[j] = i;
}
}
}
map<long long, long long> getfactor(long long a) {
map<long long, long long> m;
while (a > 1) {
m[spf[a]]++;
a /= spf[a];
}
return m;
}
long long power(long long x, long long y, long long p) {
long long res = 1;
x = x % p;
if (x == 0 || y < 0) return 0;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long inverse(long long a, long long p) { return power(a, p - 2, p); }
long long ncr(long long n, long long r, long long p) {
if (r > n) return 0;
if (r == 0 || r == n) return 1;
return (fac[n] * inverse(fac[r], p) % p * inverse(fac[n - r], p) % p) % p;
}
long long bit[7][14][100001];
void update(long long ind, long long val, long long type, long long sub) {
while (ind <= 100000) {
bit[type][sub][ind] += val;
ind += ind & (-ind);
}
}
long long get(long long ind, long long type, long long sub) {
long long tot = 0;
while (ind > 0) {
tot += bit[type][sub][ind];
ind -= ind & (-ind);
}
return tot;
}
void solve() {
long long n;
cin >> n;
long long a[n + 1];
for (long long i = 1; i <= n; i++) {
cin >> a[i];
for (long long j = 2; j <= 6; j++) {
long long temp = i % (2 * j - 2);
update(i, a[i], j, temp);
}
}
long long m;
cin >> m;
while (m--) {
long long t;
cin >> t;
if (t == 1) {
long long i, val;
cin >> i >> val;
for (long long j = 2; j <= 6; j++) {
long long temp = i % (2 * j - 2);
update(i, -a[i], j, temp);
update(i, val, j, temp);
}
a[i] = val;
} else {
long long l, r, z;
cin >> l >> r >> z;
long long ans = 0, cur = l % (2 * z - 2);
for (long long j = 1; j <= z + z - 2; j++) {
ans += (j <= z ? j : z + z - j) * (get(r, z, cur) - get(l - 1, z, cur));
cur = (cur + 1) % ((2 * z - 2));
}
cout << ans << '\n';
}
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long test = 1;
while (test--) {
solve();
}
}
|
#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<vector<vector<int> > > zagzagz(7);
for (int i = 2; i <= 6; ++i) {
zagzagz[i] = vector<vector<int> >((i - 1) * 2, vector<int>(n + 1));
for (int j = 0; j < (i - 1) * 2; ++j) {
for (int k = 1; k <= n; ++k) {
zagzagz[i][j][k] = zigzag(k + j, i);
}
}
}
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] * zagzagz[i][j][k];
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 * zagzagz[i][j][x]);
} 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;
class BinaryIndexedTree {
int N;
vector<long long> tree;
public:
BinaryIndexedTree(int _N = 0) : N(_N), tree(vector<long long>(_N + 1)) {}
long long get_cumfreq(int idx) {
long long sum = 0;
for (; idx > 0; idx -= (idx & -idx)) sum += tree[idx];
return sum;
}
void update(int idx, long long val = 1) {
for (; idx <= N; idx += (idx & -idx)) tree[idx] += val;
}
long long get_freq(int idx) {
if (idx <= 0) return 0;
long long sum = tree[idx];
int z = idx - (idx & -idx);
for (--idx; idx != z; idx -= (idx & -idx)) sum -= tree[idx];
return sum;
}
};
int N;
long long A[100004];
int S[7][11];
BinaryIndexedTree bit[7][11];
int main(int argc, char* argv[]) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> N;
for (int i = 1; i <= N; ++i) cin >> A[i];
for (int z = 2; z <= 6; ++z) {
int M = 2 * (z - 1);
for (int i = 1; i <= M; ++i) {
int iModM = i % M;
S[z][i] = iModM == 0 ? 2 : (iModM <= z ? iModM : (2 * z - iModM));
}
S[z][0] = S[z][M];
for (int ini = 1; ini <= M; ++ini) {
bit[z][ini] = BinaryIndexedTree(N);
for (int i = ini; i <= N; ++i) {
int iModM = (i - ini + 1) % M;
bit[z][ini].update(i, A[i] * S[z][iModM]);
}
}
}
int Q;
cin >> Q;
while (Q-- > 0) {
int t;
cin >> t;
if (t == 1) {
int p, v;
cin >> p >> v;
for (int z = 2; z <= 6; ++z) {
int M = 2 * (z - 1);
for (int ini = 1; ini <= M; ++ini) {
if (p < ini) continue;
int iModM = (p - ini + 1) % M;
bit[z][ini].update(p, (v - A[p]) * S[z][iModM]);
}
}
A[p] = v;
} else {
int L, R, z;
cin >> L >> R >> z;
int M = 2 * (z - 1);
int LModM = L % M;
if (LModM == 0) LModM = M;
long long res =
bit[z][LModM].get_cumfreq(R) - bit[z][LModM].get_cumfreq(L - 1);
cout << res << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[100005];
int dp[6] = {0, 0, 4, 10, 18, 28};
struct data {
long long val;
long long add[45];
data() {
for (int i = 0; i < 45; i++) add[i] = 0;
}
};
struct SegTree {
int N;
vector<data> st;
void init(int n) {
N = n;
st.resize(4 * N + 5);
}
void merge(data &cur, data &l, data &r) {
for (int i = 2; i < 6 + 1; i++) {
int mod = 2 * (i - 1);
for (int j = 0; j < mod; j++) {
cur.add[dp[i - 1] + j] = l.add[dp[i - 1] + j] + r.add[dp[i - 1] + j];
}
}
}
void build(int node, int L, int R) {
if (L == R) {
st[node].val = a[L - 1];
for (int i = 2; i < 6 + 1; i++) {
int mod = (i - 1) << 1;
for (int j = 0; j < mod; j++) {
int v = L + j;
int mod_val = v % mod;
if (mod_val == 0)
st[node].add[dp[i - 1] + j] = st[node].val << 1;
else if (mod_val <= i)
st[node].add[dp[i - 1] + j] = mod_val * st[node].val;
else
st[node].add[dp[i - 1] + j] = ((i << 1) - mod_val) * st[node].val;
}
}
return;
}
int M = (L + R) >> 1;
build(node << 1, L, M);
build(node << 1 | 1, M + 1, R);
merge(st[node], st[node << 1], st[node << 1 | 1]);
}
long long Query(int node, int L, int R, int i, int j, int z, int id) {
if (j < L || i > R) return 0;
if (i <= L && R <= j) return st[node].add[dp[z - 1] + id];
int M = (L + R) >> 1;
long long left = Query(node << 1, L, M, i, j, z, id);
long long right = Query((node << 1) | 1, M + 1, R, i, j, z, id);
data cur;
return left + right;
}
void pUpdate(int node, int L, int R, int pos, int val) {
if (L == R) {
st[node].val = val;
for (int i = 2; i < 6 + 1; i++) {
int mod = (i - 1) << 1;
for (int j = 0; j < mod; j++) {
int v = L + j;
int mod_val = v % mod;
if (mod_val == 0)
st[node].add[dp[i - 1] + j] = st[node].val << 1;
else if (mod_val <= i)
st[node].add[dp[i - 1] + j] = mod_val * st[node].val;
else
st[node].add[dp[i - 1] + j] = ((i << 1) - mod_val) * st[node].val;
}
}
return;
}
int M = (L + R) >> 1;
if (pos <= M)
pUpdate(node << 1, L, M, pos, val);
else
pUpdate(node << 1 | 1, M + 1, R, pos, val);
merge(st[node], st[node << 1], st[node << 1 | 1]);
}
long long query(int l, int r, int z, int id) {
return Query(1, 1, N, l, r, z, id);
}
void update(int pos, int val) { pUpdate(1, 1, N, pos, val); }
};
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
SegTree tree;
tree.init(n);
tree.build(1, 1, n);
int q;
cin >> q;
while (q--) {
int type;
cin >> type;
if (type == 1) {
int p, v;
cin >> p >> v;
tree.update(p, v);
} else if (type == 2) {
int l, r, z;
cin >> l >> r >> z;
int mod = 2 * (z - 1);
int act = l % mod;
int id = 0;
for (int chaiye = 0; chaiye < mod; chaiye++) {
if ((act + chaiye) % mod == 1) {
id = chaiye;
}
}
long long ans = tree.query(l, r, z, id);
cout << ans << "\n";
;
;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long sgt[100010 * 4][7][11], s[7][13], tmp;
int cf[10];
int n, m, t;
void ready() {
for (int i = 0; i < 10; i++) cf[i] = (i - 1) * 2;
for (int z = 2; z < 7; z++) {
int m = (z - 1) << 1;
for (int i = 1; i < 13; i++) {
int j = i % m;
if (!j)
s[z][i] = 2;
else if (j <= z)
s[z][i] = j;
else
s[z][i] = (z << 1) - j;
}
}
}
void push_up(int llen, int rt) {
for (int z = 2; z < 7; z++)
for (int i = 1; i <= cf[z]; i++)
sgt[rt][z][i] = sgt[rt << 1][z][i] +
sgt[rt << 1 | 1][z][(i + llen + cf[z] - 1) % cf[z] + 1];
}
void build(int l, int r, int rt) {
if (l == r) {
scanf("%I64d\n", &tmp);
for (int z = 2; z < 7; z++)
for (int i = 1; i <= cf[z]; i++) sgt[rt][z][i] = tmp * s[z][i];
return;
}
int m = (l + r) >> 1;
build(l, m, rt << 1), build(m + 1, r, rt << 1 | 1);
push_up(m - l + 1, rt);
}
long long query(int L, int R, int z, int p, int l, int r, int rt) {
if (L == l && R == r) return sgt[rt][z][p];
int m = (l + r) >> 1;
if (L > m)
return query(L, R, z, p, m + 1, r, rt << 1 | 1);
else if (R <= m)
return query(L, R, z, p, l, m, rt << 1);
else
return query(L, m, z, p, l, m, rt << 1) +
query(m + 1, R, z, (p + m - L) % cf[z] + 1, m + 1, r, rt << 1 | 1);
}
void update(int p, long long c, int l, int r, int rt) {
if (l == p && r == p) {
for (int z = 2; z < 7; z++)
for (int i = 1; i <= cf[z]; i++) sgt[rt][z][i] = c * s[z][i];
return;
}
int m = (l + r) >> 1;
if (p > m)
update(p, c, m + 1, r, rt << 1 | 1);
else
update(p, c, l, m, rt << 1);
push_up(m - l + 1, rt);
}
int main() {
ready();
int l, r, t, z;
long long v;
while (scanf("%d", &n) != EOF) {
build(1, n, 1);
scanf("%d", &m);
while (m--) {
scanf("%d", &t);
switch (t) {
case (1):
scanf("%d%I64d", &t, &v);
update(t, v, 1, n, 1);
break;
case (2):
scanf("%d%d%d", &l, &r, &z);
printf("%I64d\n", query(l, r, z, 1, 1, n, 1));
break;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) { return a % b == 0 ? b : gcd(b, a % b); }
const int MAXN = 100010;
long long A[MAXN], val[32][MAXN];
long long C[32][MAXN];
int N, M;
long long res[6][15] = {{1, 2},
{1, 2, 3, 2},
{1, 2, 3, 4, 3, 2},
{1, 2, 3, 4, 5, 4, 3, 2},
{1, 2, 3, 4, 5, 6, 5, 4, 3, 2}};
const int tot[] = {2, 4, 6, 8, 10};
const int sum[] = {0, 0, 2, 6, 12, 20, 30};
inline int lowbit(int x) { return x & (-x); }
inline long long readint() {
char c = getchar();
while (!isdigit(c)) c = getchar();
int x = 0;
while (isdigit(c)) {
x = x * 10 + c - '0';
c = getchar();
}
return x;
}
inline void writeint(long long i) {
int buf[20];
int p = 0;
if (i == 0)
p++;
else
while (i) {
buf[p++] = i % 10;
i /= 10;
}
for (int j = p - 1; j >= 0; j--) putchar('0' + buf[j]);
}
int getidx(int x, int z) {
int add = x % tot[z - 2];
if (x % tot[z - 2] == 0) add = tot[z - 2];
return sum[z - 1] + add;
}
void update(int id, int pos, long long val) {
while (pos < MAXN) {
C[id][pos] += val;
pos += lowbit(pos);
}
}
long long getsum(int id, int pos) {
long long ret = 0;
while (pos > 0) {
ret += C[id][pos];
pos -= lowbit(pos);
}
return ret;
}
void settree() {
int idx = 1;
for (int i = 0; i < 5; i++) {
for (int j = 0; j < tot[i]; j++) {
for (int k = 1, st = j; k <= N; k++, st = (st - 1 + tot[i]) % tot[i])
val[idx][k] = res[i][st];
for (int k = 1; k <= N; k++) update(idx, k, A[k] * val[idx][k]);
idx++;
}
}
}
int main() {
while (scanf("%d", &N) != EOF) {
for (int i = 1; i <= N; i++) A[i] = readint();
settree();
scanf("%d", &M);
while (M--) {
int opt;
scanf("%d", &opt);
if (opt == 1) {
int pos;
long long value;
pos = (int)readint();
value = readint();
for (int i = 1; i <= 30; i++) {
long long add = A[pos] * val[i][pos] - value * val[i][pos];
update(i, pos, -add);
}
A[pos] = value;
} else {
int l, r, z;
l = readint();
r = readint();
z = readint();
int idx = getidx(l, z);
writeint(getsum(idx, r) - getsum(idx, l - 1));
putchar('\n');
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int left, right;
long long sum[5][10];
inline int dist() const { return right - left + 1; }
} tree[400005];
long long a[100005];
void build(int l, int r, int k) {
tree[k].left = l;
tree[k].right = r;
if (l == r) {
for (int i = 2; i <= 6; i++)
for (int j = 0; j < 2 * (i - 1); j++) tree[k].sum[i - 2][j] = 0;
for (int i = 0; i < 5; i++) tree[k].sum[i][1] = a[l];
return;
}
int mid = (l + r) >> 1;
build(l, mid, k << 1);
build(mid + 1, r, k << 1 | 1);
for (int i = 2; i <= 6; i++)
for (int j = 0; j < 2 * (i - 1); j++) tree[k].sum[i - 2][j] = 0;
for (int i = 2; i <= 6; i++)
for (int j = 0; j < 2 * (i - 1); j++) {
tree[k].sum[i - 2][j] += tree[k << 1].sum[i - 2][j];
tree[k].sum[i - 2][(tree[k << 1].dist() + j) % (2 * i - 2)] +=
tree[k << 1 | 1].sum[i - 2][j];
}
}
void update(int pos, long long val, int k) {
if (tree[k].left == tree[k].right) {
for (int i = 0; i < 5; i++) tree[k].sum[i][1] = val;
return;
}
int mid = (tree[k].left + tree[k].right) >> 1;
if (pos <= mid)
update(pos, val, k << 1);
else
update(pos, val, k << 1 | 1);
for (int i = 2; i <= 6; i++)
for (int j = 0; j < 2 * (i - 1); j++) tree[k].sum[i - 2][j] = 0;
for (int i = 2; i <= 6; i++)
for (int j = 0; j < 2 * (i - 1); j++) {
tree[k].sum[i - 2][j] += tree[k << 1].sum[i - 2][j];
tree[k].sum[i - 2][(tree[k << 1].dist() + j) % (2 * i - 2)] +=
tree[k << 1 | 1].sum[i - 2][j];
}
}
node query(int l, int r, int k) {
if (tree[k].left == l && tree[k].right == r) return tree[k];
int mid = (tree[k].left + tree[k].right) >> 1;
if (l > mid)
return query(l, r, k << 1 | 1);
else if (r <= mid)
return query(l, r, k << 1);
else {
node t1 = query(l, mid, k << 1);
node t2 = query(mid + 1, r, k << 1 | 1);
node t3;
t3.left = l;
t3.right = r;
for (int i = 2; i <= 6; i++)
for (int j = 0; j < 2 * (i - 1); j++) t3.sum[i - 2][j] = 0;
for (int i = 2; i <= 6; i++)
for (int j = 0; j < 2 * (i - 1); j++) {
t3.sum[i - 2][j] += t1.sum[i - 2][j];
t3.sum[i - 2][(t1.dist() + j) % (2 * i - 2)] += t2.sum[i - 2][j];
}
return t3;
}
}
int main() {
int n;
while (scanf("%d", &n) > 0) {
for (int i = 1; i <= n; i++) scanf("%I64d", &a[i]);
build(1, n, 1);
int m;
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
int op;
scanf("%d", &op);
if (op == 1) {
int x;
long long y;
scanf("%d%I64d", &x, &y);
update(x, y, 1);
} else {
int x, y;
long long z;
scanf("%d%d%I64d", &x, &y, &z);
node tmp = query(x, y, 1);
long long res = 0;
for (long long i = 1; i <= (2 * z - 2); i++) {
if (i <= z)
res += tmp.sum[z - 2][i % (2 * z - 2)] * i;
else
res += tmp.sum[z - 2][i % (2 * z - 2)] * (2 * z - i);
}
printf("%I64d\n", res);
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
long long a[100010], data[100010 << 2][7][10];
void push_up(int p, int k) {
for (int i = 0; i < 2 * (k - 1); i++)
data[p][k][i] = data[p << 1][k][i] + data[p << 1 | 1][k][i];
}
void build(int p, int k, int l, int r) {
if (l == r) {
int t = 2 * (k - 1);
data[p][k][l % t] = a[l];
return;
}
int mid = (l + r) >> 1;
build(p << 1, k, l, mid);
build(p << 1 | 1, k, mid + 1, r);
push_up(p, k);
}
void update(int p, int k, int l, int r, int pos, int val) {
if (l == r) {
int t = 2 * (k - 1);
data[p][k][l % t] = val;
return;
}
int mid = (l + r) >> 1;
if (pos <= mid)
update(p << 1, k, l, mid, pos, val);
else
update(p << 1 | 1, k, mid + 1, r, pos, val);
push_up(p, k);
}
long long co(int i, int z) {
int t = i % (2 * (z - 1));
if (t == 0) return 2;
if (t <= z) return t;
return 2 * z - t;
}
long long cal(int p, int k, int t, int l, int r, int s, int e) {
if (l == s && r == e) return data[p][k][t];
int mid = (l + r) >> 1;
if (e <= mid)
return cal(p << 1, k, t, l, mid, s, e);
else if (s > mid)
return cal(p << 1 | 1, k, t, mid + 1, r, s, e);
else
return cal(p << 1, k, t, l, mid, s, mid) +
cal(p << 1 | 1, k, t, mid + 1, r, mid + 1, e);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%I64d", &a[i]);
for (int i = 2; i <= 6; ++i) build(1, i, 1, n);
scanf("%d", &m);
int d, l, r, z, p, v;
while (m--) {
scanf("%d", &d);
if (d == 1) {
scanf("%d%d", &p, &v);
for (int i = 2; i <= 6; ++i) update(1, i, 1, n, p, v);
} else {
scanf("%d%d%d", &l, &r, &z);
long long ans = 0;
int t = 2 * (z - 1);
for (int i = 0; i < t; i++) {
ans += co(i + 1, z) * cal(1, z, (l + i) % t, 1, n, l, r);
}
printf("%I64d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int modpow(long long int a, long long int n, long long int temp) {
long long int res = 1, y = a;
while (n > 0) {
if (n & 1) res = (res * y) % temp;
y = (y * y) % temp;
n /= 2;
}
return res % temp;
}
vector<int> arr;
int track[1000006], cnt[3];
int findval(int a, int b) {
if (a == b)
return 0;
else if (a > b)
return 1;
else
return 2;
}
int main() {
int c1, c2, n, i, flag = 1, val;
scanf("%d", &n);
for (i = 0; i < n; ++i) {
scanf("%d", &val);
arr.push_back(val);
}
if (n == 1 || n == 2) {
printf("-1\n");
return 0;
}
for (i = 1; i < n; ++i) {
if (arr[i] == arr[i - 1])
track[i] = 0;
else if (arr[i] > arr[i - 1])
track[i] = 1;
else
track[i] = 2;
}
for (i = 1; i < n; ++i) cnt[track[i]]++;
for (i = 1; i < n - 1; ++i) {
cnt[track[i]]--;
cnt[track[i + 1]]--;
if (arr[i] != arr[i - 1]) {
c1 = findval(arr[i - 1], arr[i]);
c2 = findval(arr[i + 1], arr[i - 1]);
cnt[c1]++;
cnt[c2]++;
if (!(cnt[1] == 0 || cnt[2] == 0)) {
printf("%d %d\n", i + 1, i);
return 0;
}
cnt[c1]--;
cnt[c2]--;
}
if (arr[i] != arr[i + 1]) {
c1 = findval(arr[i + 1], arr[i - 1]);
c2 = findval(arr[i], arr[i + 1]);
cnt[c1]++;
cnt[c2]++;
if (!(cnt[1] == 0 || cnt[2] == 0)) {
printf("%d %d\n", i + 2, i + 1);
return 0;
}
cnt[c1]--;
cnt[c2]--;
}
cnt[track[i]]++;
cnt[track[i + 1]]++;
}
printf("-1\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 5;
long long n;
long long a[N], b[N], c[N];
bool check() {
bool check = 0;
for (long long i = 1; i <= n; i++)
if (a[i] != b[i]) check = 1;
bool check2 = 0;
for (long long i = 1; i <= n; i++)
if (a[i] != c[i]) check2 = 1;
return check & check2;
}
void work() {
for (long long i = 1; i <= n - 1; i++) {
if (a[i] != a[i + 1]) {
swap(a[i], a[i + 1]);
if (check()) {
cout << i << " " << i + 1;
exit(0);
}
swap(a[i], a[i + 1]);
}
}
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
b[i] = a[i];
c[i] = b[i];
}
sort(b + 1, b + n + 1);
sort(c + 1, c + n + 1, greater<long long>());
work();
cout << "-1";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000005;
const long long mod = 100000793;
int n, a[MAXN], b[MAXN], c[MAXN];
long long pw[MAXN], sumb, sumc, suma;
struct discretization_node {
int num;
int ki;
} disc[MAXN];
bool cmp(discretization_node x, discretization_node y) { return x.num < y.num; }
void discretization(int a[], int n, discretization_node disc[]) {
for (int i = 1; i <= n; ++i) {
disc[i].num = a[i];
disc[i].ki = i;
}
sort(disc + 1, disc + 1 + n, cmp);
int cnt = 0, pre;
for (int i = 1; i <= n; ++i) {
if (i == 1 || a[disc[i].ki] != pre) ++cnt;
pre = a[disc[i].ki];
a[disc[i].ki] = cnt;
}
return;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
}
discretization(a, n, disc);
for (int i = 1; i <= n; ++i) {
b[i] = a[i];
}
sort(b + 1, b + 1 + n);
for (int i = 1; i <= n; ++i) {
c[i] = b[n - i + 1];
}
pw[0] = 1;
for (int i = 1; i <= n; ++i) pw[i] = pw[i - 1] * 97 % mod;
for (int i = 1; i <= n; ++i) {
sumb = (sumb + pw[i] * b[i] % mod) % mod;
sumc = (sumc + pw[i] * c[i] % mod) % mod;
suma = (suma + pw[i] * a[i] % mod) % mod;
}
for (int i = 1; i < n; ++i) {
if (a[i] == a[i + 1]) continue;
long long temp = suma;
suma =
((suma - pw[i] * a[i] % mod - pw[i + 1] * a[i + 1] % mod) % mod + mod) %
mod;
suma = (suma + pw[i] * a[i + 1] % mod + pw[i + 1] * a[i] % mod) % mod;
if (suma != sumb && suma != sumc) {
printf("%d %d\n", i, i + 1);
return 0;
}
suma = temp;
}
printf("-1\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100000 + 100;
int n, a[N];
inline bool issorted() {
bool x = 1, y = 1;
for (int i = 0; i < n - 1; i++)
if (a[i] > a[i + 1]) {
x = 0;
break;
}
for (int i = n - 1; i > 0; i--)
if (a[i] > a[i - 1]) {
y = 0;
break;
}
return x | y;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", a + i);
if (n == 2) {
printf("-1\n");
return 0;
}
bool dif = 0;
for (int i = 0; i < n - 1; i++)
if (a[i] != a[i + 1]) {
dif = 1;
break;
}
if (!dif) {
printf("-1\n");
return 0;
}
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++)
if (a[i] != a[j]) {
swap(a[i], a[j]);
if (!issorted()) {
printf("%d %d\n", i + 1, j + 1);
return 0;
}
swap(a[i], a[j]);
}
printf("-1\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool ascending(vector<int> &a) {
for (int i = 0; i < a.size() - 1; ++i)
if (a[i] > a[i + 1]) return false;
return true;
}
bool descending(vector<int> &a) {
for (int i = 0; i < a.size() - 1; ++i)
if (a[i] < a[i + 1]) return false;
return true;
}
bool sorted(vector<int> &a) {
if (a.size() <= 2) return true;
if (ascending(a)) return true;
if (descending(a)) return true;
return false;
}
bool check(vector<int> &a, int l, int r) {
swap(a[l], a[r]);
bool b = sorted(a);
swap(a[r], a[l]);
return !b;
}
void solve(istream &in, ostream &out) {
int n;
in >> n;
if (n <= 2) {
out << -1;
return;
}
vector<int> a(n);
set<int> s;
for (int i = 0; i < n; ++i) {
in >> a[i];
s.insert(a[i]);
}
if (s.size() == 1) {
out << -1;
return;
}
for (int l = 0; l < n - 1; ++l) {
for (int r = l + 1; r < n; ++r) {
if (a[l] != a[r]) {
if (check(a, l, r)) {
out << l + 1 << ' ' << r + 1;
return;
}
}
}
}
out << -1;
}
int main() {
solve(cin, cout);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[1000000], d1, d2;
bool is_sorted() {
int type = 2, s = 0;
while (type == 2 && s < n - 1) {
if (a[s] == a[s + 1])
type = 2;
else if (a[s] < a[s + 1]) {
d1 = s;
d2 = s + 1;
type = 0;
break;
} else if (a[s] > a[s + 1]) {
d1 = s;
d2 = s + 1;
type = 1;
break;
}
s++;
}
if (type == 2 && s >= n + 1) return true;
if (type == 0) {
while (s < n - 1 && a[s] <= a[s + 1]) {
if (a[s] != a[s + 1]) {
d1 = s;
d2 = s + 1;
}
s++;
}
if (s < n - 1) return false;
}
if (type == 1) {
while (s < n - 1 && a[s] >= a[s + 1]) {
if (a[s] != a[s + 1]) {
d1 = s;
d2 = s + 1;
}
s++;
}
if (s < n - 1) return false;
}
return true;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
if (n == 1) {
cout << -1 << endl;
return 0;
}
for (int i = 0; i < n - 1; i++) {
if (a[i] != a[i + 1]) {
swap(a[i], a[i + 1]);
if (is_sorted() == false) {
cout << i + 1 << " " << i + 2 << endl;
return 0;
}
swap(a[i], a[i + 1]);
}
}
cout << -1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 0;
int a[100001], n;
bool is() {
int st = 0;
for (int i = 0; i < n - 1; i++) {
if (a[i] < a[i + 1]) {
if (st == 0)
st = 1;
else if (st != 1)
return false;
} else if (a[i] > a[i + 1]) {
if (st == 1) return false;
if (st == 0) st = 2;
}
}
return true;
}
int b[100001];
int main() {
cin >> n;
if (n == 1) {
cout << -1 << endl;
return 0;
}
for (int i = 0; i < n; i++) {
cin >> b[i];
}
bool is1 = true;
for (int i = 0; i < n - 1; i++) {
for (int ii = 0; ii < n && is1; ii++) {
a[ii] = b[ii];
}
if (a[i] == a[i + 1]) {
is1 = false;
continue;
}
is1 = 1;
swap(a[i], a[i + 1]);
if (!is()) {
cout << i + 1 << " " << i + 2 << endl;
return 0;
}
}
cout << -1 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long long a[100050];
long long b[100050];
int f = 1;
int f1 = 0;
if (n <= 2) f1 = 1;
for (int i = 0; i < n && !f1; i++) {
cin >> a[i];
b[i] = a[i];
}
sort(b, b + n);
for (int i = 0; i < n - 1 && !f1; i++) {
if (a[i] == a[i + 1])
continue;
else {
swap(a[i], a[i + 1]);
int f2 = 0;
for (int s = 0; s < n; s++) {
if (a[s] != b[s]) {
f = 0;
break;
} else if (s == n - 1)
f2 = 1;
}
int j = 0;
for (int t = n - 1; t >= 0 && !f2; t--) {
if (a[t] != b[j]) {
f = 0;
break;
} else if (t == 0)
f = 1;
j++;
}
if (f) swap(a[i], a[i + 1]);
}
if (!f) {
cout << i + 1 << " " << i + 2;
break;
}
}
if (f || f1) cout << -1;
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, num[100017];
while (~scanf("%d", &n)) {
memset(num, 0, sizeof(num));
for (int i = 1; i <= n; i++) scanf("%d", &num[i]);
int a, b;
if (n <= 2)
printf("-1\n");
else {
a = 2;
while (1) {
if (a > n) break;
if (num[a] != num[1]) break;
a++;
}
if (a > n)
printf("-1\n");
else {
if (a == n)
printf("%d %d\n", n - 1, n);
else {
b = a + 1;
while (1) {
if (b > n) break;
if (num[b] != num[a] && num[b] != num[1]) break;
b++;
}
if (b > n) {
if (a > 2)
printf("%d %d\n", a - 1, a);
else {
int flag = 0;
for (int i = 3; i <= n; i++)
if (num[i] != num[2]) {
flag = i;
break;
}
if (flag == 0)
printf("1 2\n");
else {
if (n == 3)
printf("-1\n");
else {
if (flag != 3)
printf("%d %d\n", flag - 1, flag);
else {
flag = 0;
for (int i = 4; i <= n; i++)
if (num[i] != num[3]) {
flag = i;
break;
}
if (flag == 0)
printf("2 3\n");
else {
printf("%d %d\n", flag - 1, flag);
}
}
}
}
}
} else {
if ((num[a - 1] > num[a] && num[a] > num[b]) ||
(num[a - 1] < num[a] && num[a] < num[b]))
printf("%d %d\n", a, b);
else if ((num[a - 1] < num[a] && num[a] > num[b]) ||
(num[a - 1] > num[a] && num[a] < num[b]))
printf("%d %d\n", a - 1, b);
}
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long max(long long a, long long b) {
if (a > b) return a;
return b;
}
long long min(long long a, long long b) {
if (a < b) return a;
return b;
}
int a[500000], b[500000];
map<int, bool> m;
int main() {
int n, now = -1, k = 0, y = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
b[i] = a[i];
if (now == a[i]) k++;
now = a[i];
}
if (n <= 2 || k == n - 1) {
cout << -1 << endl;
return 0;
}
sort(b, b + n);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (a[i] == a[j]) continue;
bool flag = 1, flag1 = 1;
swap(a[i], a[j]);
for (int i = 0; i < n && (flag || flag1); i++) {
if (a[i] != b[n - i - 1]) flag = 0;
if (a[i] != b[i]) flag1 = 0;
}
if (flag || flag1) {
swap(a[i], a[j]);
continue;
}
cout << i + 1 << " " << j + 1 << endl;
return 0;
}
if (m.find(a[i]) == m.end()) y++;
m[a[i]] = 1;
if (y > 2) break;
}
cout << -1 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n < 3) {
cout << -1;
return 0;
}
int *a = new int[n];
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
int *f = new int[n];
int *b = new int[n];
memcpy(f, a, n * sizeof(a[0]));
sort(f, f + n);
memcpy(b, f, n * sizeof(a[0]));
reverse(b, b + n);
for (int i = 1; i < n; ++i) {
if (a[i - 1] == a[i]) continue;
if (a[i] == b[i - 1] && a[i - 1] == b[i]) continue;
if (a[i] == f[i - 1] && a[i - 1] == f[i]) continue;
cout << i << " " << i + 1;
return 0;
}
cout << -1;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3f;
const int MOD = 1e9 + 7;
const int N = 1e6 + 7;
int n, a[N];
bool check() {
bool ok1 = 1, ok2 = 1;
for (int i = (1); i < (n); ++i) {
if (a[i] < a[i - 1]) ok1 = 0;
if (a[i] > a[i - 1]) ok2 = 0;
}
return !ok1 && !ok2;
}
void Init() {
for (int i = (0); i < (n); ++i) scanf("%d", a + i);
}
int Solve() {
for (int i = (1); i < (n); ++i)
if (a[i - 1] != a[i]) {
swap(a[i], a[i - 1]);
if (check()) {
return printf("%d %d\n", i, i + 1);
}
swap(a[i], a[i - 1]);
}
return puts("-1");
}
int main() {
while (~scanf("%d", &n)) {
Init();
Solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int i, i0, n, m, a[100005];
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
long long rd(long long l, long long r) {
unsigned long long ans = rng();
return (ans % (r - l + 1)) + l;
}
map<int, int> mp, mp0;
vector<int> v;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (!mp.count(a[i]))
mp[a[i]] = i;
else if (!mp0.count(a[i]))
mp0[a[i]] = i;
}
for (auto x : mp)
if (!mp0.count(x.first)) mp0[x.first] = x.second;
for (auto x : mp) v.push_back(x.first);
if (v.size() == 1) {
printf("-1\n");
return 0;
}
while (1) {
if (clock() > 1000) break;
int x, y, xx, yy;
bool f, ff;
x = rd(1, v.size());
y = rd(1, v.size());
while (x == y) y = rd(1, v.size());
xx = mp[v[x - 1]], yy = mp[v[y - 1]];
swap(a[xx], a[yy]);
f = 1, ff = 1;
for (int i = 2; i <= n; i++) {
if (a[i] < a[i - 1])
f = 0;
else if (a[i] > a[i - 1])
ff = 0;
if (f + ff == 0) break;
}
swap(a[xx], a[yy]);
if (f + ff == 0) {
printf("%d %d\n", xx, yy);
return 0;
}
xx = mp[v[x - 1]], yy = mp0[v[y - 1]];
swap(a[xx], a[yy]);
f = 1, ff = 1;
for (int i = 2; i <= n; i++) {
if (a[i] < a[i - 1])
f = 0;
else if (a[i] > a[i - 1])
ff = 0;
if (f + ff == 0) break;
}
swap(a[xx], a[yy]);
if (f + ff == 0) {
printf("%d %d\n", xx, yy);
return 0;
}
xx = mp0[v[x - 1]], yy = mp[v[y - 1]];
swap(a[xx], a[yy]);
f = 1, ff = 1;
for (int i = 2; i <= n; i++) {
if (a[i] < a[i - 1])
f = 0;
else if (a[i] > a[i - 1])
ff = 0;
if (f + ff == 0) break;
}
swap(a[xx], a[yy]);
if (f + ff == 0) {
printf("%d %d\n", xx, yy);
return 0;
}
xx = mp0[v[x - 1]], yy = mp0[v[y - 1]];
swap(a[xx], a[yy]);
f = 1, ff = 1;
for (int i = 2; i <= n; i++) {
if (a[i] < a[i - 1])
f = 0;
else if (a[i] > a[i - 1])
ff = 0;
if (f + ff == 0) break;
}
swap(a[xx], a[yy]);
if (f + ff == 0) {
printf("%d %d\n", xx, yy);
return 0;
}
}
printf("-1\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[100000];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int p1, p2 = -1, p3 = -1;
p1 = 0;
for (int i = 1; i < n; i++) {
if (a[i] != a[0]) {
p2 = i;
break;
}
}
if (p2 == -1 || n <= 2) {
cout << -1 << endl;
return 0;
}
for (int i = p2 + 1; i < n; i++) {
if (a[i] != a[p1] && a[i] != a[p2]) {
p3 = i;
break;
}
}
if (p3 != -1) {
if (a[p1] < a[p2]) {
if (a[p1] < a[p3]) {
cout << p1 + 1 << " " << p2 + 1;
} else {
cout << p2 + 1 << " " << p3 + 1;
}
} else {
if (a[p1] > a[p3]) {
cout << p1 + 1 << " " << p2 + 1;
} else {
cout << p1 + 1 << " " << p3 + 1;
}
}
} else {
if (n == 3) {
if (a[0] == a[2]) {
cout << -1 << endl;
} else {
if (a[0] != a[1]) {
cout << 1 << " " << 2 << endl;
} else {
cout << 2 << " " << 3 << endl;
}
}
} else {
if (p2 - p1 > 1) {
cout << p2 << " " << p2 + 1 << endl;
} else {
bool c = true;
for (int i = 2; i < n; i++) c &= a[i] == a[2];
if (c) {
if (a[2] == a[1]) {
cout << 1 << " " << 2 << endl;
} else {
cout << 2 << " " << 3 << endl;
}
} else {
cout << 1 << " " << 2 << endl;
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, i, j, k, rez;
long long a[100005];
void swap(int x, int y) {
int aux = a[x];
a[x] = a[y];
a[y] = aux;
}
bool corect(int x, int y) {
int ok = 0;
if (a[x] > a[y])
ok = 0;
else
ok = 1;
for (int l = 1; l <= n - 1; l++)
if ((a[l] > a[l + 1] && ok == 1) || (a[l] < a[l + 1] && ok == 0))
return true;
return false;
}
int main() {
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%I64d", &a[i]);
if (n == 1 || n == 2) {
printf("-1\n");
return 0;
} else {
for (i = 1; i <= n - 1; i++)
for (j = i + 1; j <= n; j++) {
if (a[i] != a[j]) {
swap(i, j);
if (corect(i, j)) {
printf("%d %d\n", i, j);
return 0;
} else
swap(i, j);
}
i++;
}
}
printf("-1\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T inline SQR(const T &a) {
return (a) * (a);
}
inline int SGN(double a) {
return ((a > 1e-7) ? (1) : ((a < -1e-7) ? (-1) : (0)));
}
inline int CMP(double a, double b) { return SGN(a - b); }
map<int, vector<int> > m;
set<int> _a;
vector<int> a;
int n;
int main() {
scanf("%d", &n);
for (int i = 0; i <= n - 1; ++i) {
int x;
scanf("%d", &x);
if (_a.find(x) != _a.end()) {
if ((int)m[x].size() < 4) m[x].push_back(i + 1);
} else if (_a.find(x) == _a.end())
if ((int)_a.size() < 3) {
_a.insert(x);
m[x].push_back(i + 1);
}
}
for (typeof((_a).begin()) it = (_a).begin(); it != (_a).end(); ++it)
a.push_back(*it);
if ((int)m.size() == 1)
printf("-1");
else if ((int)m.size() == 3) {
vector<pair<int, int> > p;
for (typeof((a).begin()) it_a = (a).begin(); it_a != (a).end(); ++it_a)
p.push_back(pair<int, int>(*it_a, m[*it_a].back()));
sort(p.begin(), p.end());
if (p[2].second > p[0].second && p[0].second > p[1].second)
cout << p[2].second << ' ' << p[0].second;
else if (p[2].second > p[1].second && p[1].second > p[0].second)
cout << p[2].second << ' ' << p[1].second;
else
cout << p[0].second << ' ' << p[1].second;
} else {
vector<int> k[2];
for (int i = 0; i <= (int)a.size() - 1; ++i) k[i] = m[a[i]];
int l[2] = {(int)k[0].size(), (int)k[1].size()};
bool error = true;
for (int i = 0; i <= 2 - 1; ++i) {
int t = i ^ 1;
if (l[t] >= 2 && error) {
if (k[i][0] < k[t][l[t] - 2] && k[t][l[t] - 2] < k[t][l[t] - 1]) {
printf("%d %d", k[i][0], k[t][l[t] - 2]);
error = false;
} else if (k[i][l[i] - 1] > k[t][1] && k[t][1] > k[t][0]) {
printf("%d %d", k[i][l[i] - 1], k[t][1]);
error = false;
}
}
}
if (error) printf("-1");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100100;
int N;
int ar[MAXN];
bool works(int a, int b) {
if (ar[a] == ar[b]) return false;
int prev = -1;
bool up = true;
bool down = true;
for (int i = 0; i < N; ++i) {
int j = i;
if (j == b) {
j = a;
} else if (j == a) {
j = b;
}
if (prev == -1) {
prev = ar[j];
}
if (ar[j] < prev) {
up = false;
}
if (ar[j] > prev) {
down = false;
}
prev = ar[j];
}
return !(up || down);
}
int main() {
scanf("%d", &N);
for (int i = 0; i < N; ++i) {
scanf("%d", ar + i);
}
if (N < 100) {
for (int i = 0; i < N; ++i) {
for (int j = i + 1; j < N; ++j) {
if (works(i, j)) {
printf("%d %d\n", i + 1, j + 1);
return 0;
}
}
}
printf("-1\n");
} else {
int first = ar[0];
bool allsame = true;
for (int i = 0; i < N; ++i) {
if (first != ar[i]) {
allsame = false;
}
}
if (allsame) {
printf("-1\n");
return 0;
}
for (int i = 1; i < 4; ++i) {
for (int k = 0; k < i; ++k) {
if (ar[i] == ar[k]) {
for (int j = i + 1; j < N; ++j) {
if (works(i, j)) {
printf("%d %d\n", i + 1, j + 1);
return 0;
}
}
}
}
for (int j = 0; j < i; ++j) {
if (works(i, j)) {
printf("%d %d\n", i + 1, j + 1);
return 0;
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int n;
int a[N], b[N];
int sta[10], pos[10];
int swap(int x, int y) {
int t = a[x];
a[x] = a[y];
a[y] = t;
}
int judge() {
int i;
int ok = 1;
for (i = 0; i < n; i++) {
if (a[i] != b[i]) {
ok = 0;
break;
}
}
if (ok) return 0;
ok = 1;
for (i = 0; i < n; i++) {
if (a[i] != b[n - 1 - i]) {
ok = 0;
break;
}
}
if (ok)
return 0;
else
return 1;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
b[i] = a[i];
}
sort(b, b + n);
if (n <= 2) {
printf("-1\n");
return 0;
}
if (n == 3) {
if (a[0] == a[2]) {
printf("-1\n");
return 0;
}
}
int i, j, len = 1;
sta[0] = a[0];
pos[0] = 0;
for (i = 1; i < n && len < 3; i++) {
if (a[i] != sta[0]) {
if (len == 2 && a[i] != sta[1]) {
sta[len] = a[i];
pos[len++] = i;
}
if (len == 1) {
sta[len] = a[i];
pos[len++] = i;
}
}
}
if (len == 1) {
printf("-1\n");
return 0;
}
if (len == 2) {
swap(pos[0], pos[1]);
if (judge()) {
printf("%d %d\n", pos[0] + 1, pos[1] + 1);
return 0;
}
swap(pos[0], pos[1]);
int cur = (pos[1] == 1) ? 2 : 1;
printf("%d %d\n", cur + 1, pos[1] + 1);
return 0;
}
for (i = 0; i < 3; i++) {
for (j = i + 1; j < 3; j++) {
swap(pos[i], pos[j]);
if (judge()) {
printf("%d %d\n", i + 1, j + 1);
return 0;
}
swap(pos[i], pos[j]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
int arr[maxn];
int b[maxn];
int c[maxn];
int main() {
int n;
scanf("%d", &n);
if (n <= 2) {
puts("-1");
return 0;
}
set<int> se;
for (int i = 0; i < n; i++) {
scanf("%d", &arr[i]);
se.insert(arr[i]);
}
if (se.size() == 1) {
puts("-1");
return 0;
}
if (n == 3) {
for (int i = 0; i < 3; i++)
for (int j = i + 1; j < 3; j++) {
for (int k = 0; k < 3; k++) b[k] = arr[k];
if (b[i] == b[j]) continue;
swap(b[i], b[j]);
if (b[1] > b[0] && b[1] > b[2]) {
cout << i + 1 << " " << j + 1 << endl;
return 0;
}
if (b[1] < b[0] && b[1] < b[2]) {
cout << i + 1 << " " << j + 1 << endl;
return 0;
}
}
puts("-1");
return 0;
}
for (int i = 0; i < n; i++) {
b[i] = arr[i];
}
for (int i = 0; i < n; i++) {
c[i] = arr[i];
}
sort(b, b + n);
sort(c, c + n);
reverse(c, c + n);
int maxx = 0;
int minx = 0;
for (int i = 0; i < n; i++) {
if (arr[i] > arr[maxx]) {
maxx = i;
}
}
for (int i = 0; i < n; i++) {
if (arr[i] < arr[minx]) {
minx = i;
}
}
if (maxx == 1) {
if (arr[1] != arr[2]) {
swap(arr[1], arr[2]);
int flag1 = false;
int flag2 = false;
for (int i = 0; i < n; i++) {
if (arr[i] != b[i]) flag1 = 1;
}
for (int i = 0; i < n; i++) {
if (arr[i] != c[i]) flag2 = 1;
}
if (flag1 && flag2) {
cout << 2 << " " << 3 << endl;
return 0;
}
swap(arr[1], arr[2]);
}
} else {
if (arr[1] != arr[maxx]) {
swap(arr[1], arr[maxx]);
int flag1 = false;
int flag2 = false;
for (int i = 0; i < n; i++) {
if (arr[i] != b[i]) flag1 = 1;
}
for (int i = 0; i < n; i++) {
if (arr[i] != c[i]) flag2 = 1;
}
if (flag1 && flag2) {
cout << 2 << " " << maxx + 1 << endl;
return 0;
}
swap(arr[1], arr[maxx]);
}
}
if (minx == 1) {
if (arr[1] != arr[2]) {
swap(arr[1], arr[2]);
int flag1 = false;
int flag2 = false;
for (int i = 0; i < n; i++) {
if (arr[i] != b[i]) flag1 = 1;
}
for (int i = 0; i < n; i++) {
if (arr[i] != c[i]) flag2 = 1;
}
if (flag1 && flag2) {
cout << 2 << " " << 3 << endl;
return 0;
}
swap(arr[1], arr[2]);
}
} else {
if (arr[1] != arr[minx]) {
swap(arr[1], arr[minx]);
int flag1 = false;
int flag2 = false;
for (int i = 0; i < n; i++) {
if (arr[i] != b[i]) flag1 = 1;
}
for (int i = 0; i < n; i++) {
if (arr[i] != c[i]) flag2 = 1;
}
if (flag1 && flag2) {
cout << 2 << " " << minx + 1 << endl;
return 0;
}
swap(arr[1], arr[minx]);
}
}
puts("-1");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, Max;
int num[100005];
map<int, int> m;
int main() {
int in;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> num[i];
m[num[i]]++;
if (Max < m[num[i]]) {
Max = m[num[i]];
in = num[i];
}
}
if (n <= 2) {
cout << -1 << endl;
return 0;
}
if (Max == n) {
cout << -1 << endl;
return 0;
}
if (Max == 1) {
if (num[0] > num[1]) {
for (int i = 1; i < n - 1; i++)
if (num[i] > num[i + 1]) {
printf("%d %d\n", i + 1, i + 2);
return 0;
}
cout << 1 << " " << n << endl;
}
if (num[0] < num[1]) {
for (int i = 1; i < n - 1; i++)
if (num[i] < num[i + 1]) {
printf("%d %d\n", i + 1, i + 2);
return 0;
}
cout << 1 << " " << n << endl;
}
return 0;
} else {
int tmp, pos1 = -1, pos2 = -1;
for (int i = 0; i < n; i++)
if (num[i] == in) pos2 = i;
for (int i = 0; i < n; i++)
if (num[i] == in) {
pos1 = i;
break;
}
if (pos1 != 0) {
cout << 1 << " " << pos1 + 1 << endl;
return 0;
}
if (pos2 != n - 1) {
cout << pos2 + 1 << " " << n << endl;
return 0;
}
if (n == 3 && pos1 == 0 && pos2 == n - 1) {
cout << -1 << endl;
return 0;
}
for (int i = 1; i < n - 1; i++)
if (num[i] != num[i + 1]) {
cout << i + 1 << " " << i + 2 << endl;
return 0;
}
for (int i = 1; i < n - 1; i++)
if (num[i] != num[0]) {
cout << 1 << " " << i + 1 << endl;
return 0;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[100005];
void work() {
int i, j, k, l;
scanf("%d", &n);
for (i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (i = 2; i <= n; ++i)
if (a[i] != a[i - 1]) break;
if (i > n) {
puts("-1");
return;
}
for (i = 1; i <= n; ++i) {
for (j = i + 1; j <= n; ++j) {
if (a[i] != a[j]) {
swap(a[i], a[j]);
for (k = 2; k <= n; ++k)
if (a[k] < a[k - 1]) break;
for (l = 2; l <= n; ++l)
if (a[l] > a[l - 1]) break;
if (k <= n && l <= n) {
printf("%d %d\n", i, j);
return;
}
swap(a[i], a[j]);
}
}
}
puts("-1");
}
int main() {
work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[100100], N;
bool check(int l, int r) {
int i;
swap(a[l], a[r]);
bool v = true;
for (i = 1; i < N && v; i++)
if (a[i - 1] > a[i]) v = false;
swap(a[l], a[r]);
if (v) return true;
v = true;
swap(a[l], a[r]);
for (i = 1; i < N && v; i++)
if (a[i - 1] < a[i]) v = false;
swap(a[l], a[r]);
return v;
}
int main() {
int i, l = -1, r = -1;
scanf("%d", &N);
for (i = 0; i < N; i++) scanf("%d", &a[i]);
for (i = 0; i < N - 1; i++)
if (a[i] != a[i + 1]) {
if (!check(i, i + 1)) {
printf("%d %d", i + 1, i + 2);
return 0;
}
}
printf("-1");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool sorted(vector<int> arr) {
int v = arr[0];
bool up = true;
bool down = true;
for (int i = 1; i < arr.size(); i++) {
if (arr[i] > v) down = false;
if (arr[i] < v) up = false;
v = arr[i];
}
return up | down;
}
int main() {
int n;
cin >> n;
set<int> present;
vector<int> arr(n);
for (int i = 0; i < n; i++) {
cin >> arr[i];
present.insert(arr[i]);
}
if (n <= 2 || present.size() < 2) {
cout << -1 << endl;
} else {
for (int i = 0; i < n; i++) {
int j = i + 1;
for (; j < arr.size(); j++) {
if (arr[i] == arr[j]) continue;
swap(arr[i], arr[j]);
if (!sorted(arr)) {
cout << (i + 1) << " " << (j + 1);
return 0;
}
swap(arr[j], arr[i]);
}
}
cout << -1 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int a[100000];
int sortorg[100000], sortinv[100000];
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
sortorg[i] = a[i], sortinv[i] = a[i];
}
sort(sortorg, sortorg + n);
sort(sortinv, sortinv + n, greater<int>());
for (int i = 1; i < n; i++) {
if (!((a[i] == sortinv[i - 1] && a[i - 1] == sortinv[i]) ||
(a[i] == sortorg[i - 1] && a[i - 1] == sortorg[i])) &&
a[i] != a[i - 1]) {
printf("%d %d\n", i, i + 1);
return 0;
}
}
printf("-1\n");
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
int a[maxn];
int n;
bool check() {
for (int i = (2); i <= (n - 1); i++) {
if (!(a[i - 1] <= a[i] && a[i] <= a[i + 1] ||
a[i - 1] >= a[i] && a[i] >= a[i + 1]))
return true;
}
return false;
}
int main() {
scanf("%d", &n);
bool OK = 0;
for (int i = (1); i <= (n); i++) {
scanf("%d", &a[i]);
if (a[i] != a[1]) OK = 1;
}
if (!OK || n <= 2)
puts("-1");
else {
for (int i = (1); i <= (n); i++) {
for (int j = (i + 1); j <= (n); j++) {
if (a[i] == a[j]) continue;
swap(a[i], a[j]);
if (check()) {
printf("%d %d\n", i, j);
return 0;
}
swap(a[i], a[j]);
}
}
puts("-1");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[100100];
int main() {
scanf("%d", &n);
if (n < 3) {
for (int i = 0; i < n; i++) {
scanf("%d", a + i);
}
printf("%s\n", "-1");
return 0;
} else {
for (int i = 0; i < n; i++) {
scanf("%d", a + i);
}
for (int i = 1; i < n; i++) {
if (a[i] != a[i - 1]) {
swap(a[i], a[i - 1]);
bool c1 = false, c2 = false;
for (int j = 1; j < n; j++) {
if (a[j] > a[j - 1]) c1 = true;
if (a[j] < a[j - 1]) c2 = true;
if (c1 && c2) {
printf("%d %d\n", i + 1, i);
return 0;
}
}
swap(a[i], a[i - 1]);
}
}
}
printf("%s\n", "-1");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD(1000000007);
const int INF((1 << 30) - 1);
const int MAXN(100005);
int n, a[MAXN], b[MAXN], d[MAXN];
bool unsort() {
bool c1 = 0, c2 = 0;
for (int i = 0; i < n; i++)
if (a[i] != b[i]) {
c1 = 1;
break;
}
for (int i = 0; i < n; i++)
if (a[i] != d[i]) {
c2 = 1;
break;
}
return (c1 & c2);
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
if (n == 2) {
printf("-1");
return 0;
}
bool chk = 0;
for (int i = 0; i < n; i++)
if (a[i] != a[0]) {
chk = 1;
break;
}
if (!chk) {
printf("-1");
return 0;
}
for (int i = 0; i < n; i++) b[i] = a[i];
sort(b, b + n);
for (int i = 0; i < n; i++) d[i] = b[n - i - 1];
for (int i = 0; i < n; i++)
for (int j = i + 1; j <= n - 1; j++) {
if (a[i] == a[j]) continue;
swap(a[i], a[j]);
if (unsort()) {
printf("%d %d", i + 1, j + 1);
return 0;
}
swap(a[i], a[j]);
}
printf("-1");
}
|
#include <bits/stdc++.h>
using namespace std;
int a[100005], b[100005], c[100005];
bool cmp(int a, int b) { return a > b; }
int main() {
int n;
scanf("%d", &n);
if (n <= 2) {
cout << -1 << endl;
return 0;
}
for (int i = 0; i < n; i++) {
scanf("%d", a + i);
b[i] = c[i] = a[i];
}
sort(b, b + n);
if (b[0] == b[n - 1]) {
cout << -1 << endl;
return 0;
}
sort(c, c + n, cmp);
for (int i = 0; i < n; i++) {
if (a[i] == a[i + 1]) continue;
for (int j = i + 1; j < n; j++) {
if (a[j] == a[j - 1]) continue;
if (a[i] == a[j]) continue;
if ((a[j] != b[i] || a[i] != b[j]) && (a[i] != c[j] || a[j] != c[i])) {
cout << i + 1 << " " << j + 1 << endl;
return 0;
}
}
}
cout << -1 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int a[100005];
int i, j, k;
int con;
int b[5];
int x, y, z;
bool flag;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> a[i];
}
con = 1;
b[1] = a[1];
flag = false;
x = 1;
for (i = 1; i <= n; i++) {
if (a[i] != b[1]) {
flag = true;
b[2] = a[i];
con = 2;
y = i;
break;
}
}
if (flag) {
for (i = 1; i <= n; i++) {
if (a[i] != b[1] && a[i] != b[2]) {
flag = true;
b[3] = a[i];
con = 3;
z = i;
break;
}
}
}
if (con == 1 || n == 1 || n == 2) {
cout << -1 << endl;
return 0;
}
if (con == 3) {
if (a[x] >= a[y] && a[y] >= a[z]) {
cout << x << " " << y << endl;
return 0;
} else if (a[x] <= a[y] && a[y] <= a[z]) {
cout << x << " " << y << endl;
return 0;
} else {
cout << x << " " << z << endl;
return 0;
}
}
if (con == 2) {
int now;
now = 0;
a[0] = -1;
a[n + 1] = -1;
for (i = 1; i <= n + 1; i++) {
if (a[i] == a[i - 1]) {
now++;
} else {
if (now > 1) {
if (i != n + 1) {
cout << i - 1 << " " << i << endl;
return 0;
} else {
for (j = n; j >= 1; j--) {
if (a[j] != a[n]) break;
}
cout << j << " " << j + 1 << endl;
return 0;
}
}
now = 1;
}
}
if (n > 3) {
cout << n - 1 << " " << n << endl;
return 0;
}
}
cout << -1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, m;
vector<int> v;
int dx[] = {1, 0, -1, 0, 1, -1, -1, 1};
int dy[] = {0, 1, 0, -1, 1, 1, -1, -1};
map<int, int> cnt;
int main() {
cin >> n;
v.resize(n);
int mx = 0, val = 0;
;
for (int i = 0; i < n; i++) {
cin >> v[i];
cnt[v[i]]++;
if (mx < cnt[v[i]]) {
mx = cnt[v[i]];
val = v[i];
}
}
vector<int> v2 = v, v3;
sort(v2.begin(), v2.end());
v3 = v2;
reverse(v3.begin(), v3.end());
if (n <= 2) {
cout << -1;
return 0;
}
if (v == v2) {
bool ans = 0;
for (int i = 1; i < n; i++) {
if (v[i] != v[i - 1]) {
ans = 1;
cout << i << " " << i + 1;
return 0;
}
}
cout << "-1";
return 0;
} else if (v == v3) {
bool ans = 0;
for (int i = 1; i < n; i++) {
if (v[i] != v[i - 1]) {
ans = 1;
cout << i << " " << i + 1;
return 0;
}
}
cout << "-1";
return 0;
} else {
if (n == 3) {
if (v2[0] == v2[1]) {
cout << -1 << endl;
return 0;
}
if (v[0] != v[1]) {
swap(v[0], v[1]);
if (v != v2 && v != v3) {
cout << 1 << " " << 2;
;
return 0;
}
swap(v[0], v[1]);
}
if (v[0] != v[2]) {
swap(v[0], v[2]);
if (v != v2 && v != v3) {
cout << 1 << " " << 3;
;
return 0;
}
swap(v[0], v[2]);
}
if (v[1] != v[2]) {
swap(v[1], v[2]);
if (v != v2 && v != v3) {
cout << 2 << " " << 3;
;
return 0;
}
}
cout << -1;
} else {
if (mx >= 2) {
int c = -1, cnte = 0, c2;
for (int i = 0; i < n; i++) {
if (c == -1 && v[i] != val) {
c = i;
break;
}
}
for (int i = 0; i < n; i++) {
if (v[i] == val) {
if (cnte > 0) {
cnte++;
c2 = i;
break;
} else
cnte++;
}
}
cout << c + 1 << " " << c2 + 1;
} else {
swap(v[0], v[1]);
if (v != v2 && v != v3) {
cout << 1 << " " << 2 << endl;
;
} else
cout << 2 << " " << 3 << endl;
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 100005;
int a[MAX], N;
bool sorted(bool s) {
for (int i = 1; i < N; i++)
if (s) {
if (a[i] > a[i + 1]) return false;
} else {
if (a[i] < a[i + 1]) return false;
}
return true;
}
int main() {
ios::sync_with_stdio(false);
int i, _pmin, _pmax;
cin >> N;
bool ret = false;
for (i = 1; i <= N; i++) cin >> a[i];
for (i = 2; i <= N; i++) {
if (!ret && a[i] != a[i - 1]) {
swap(a[i], a[i - 1]);
if (!(sorted(true) || sorted(false))) {
ret = true;
_pmin = i - 1, _pmax = i;
break;
}
swap(a[i], a[i - 1]);
}
}
if (ret)
cout << _pmin << " " << _pmax << endl;
else
cout << -1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int f[111111], n, i;
int main() {
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d", &f[i]);
for (i = 2; i <= n; i++)
if (f[i] != f[i - 1]) {
swap(f[i], f[i - 1]);
bool ok1 = true, ok2 = true;
for (int j = 2; j <= n; j++) {
if (f[j - 1] > f[j]) ok1 = false;
if (f[j - 1] < f[j]) ok2 = false;
if (ok1 || ok2) continue;
printf("%d %d", i - 1, i);
return 0;
}
swap(f[i], f[i - 1]);
}
puts("-1");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007;
const int m = 123123;
int n;
int a[m];
bool o1, o2;
int main() {
ios::sync_with_stdio(false);
scanf("%d", &n);
for (int i = 1; i <= int(n); ++i) scanf("%d", &a[i]);
for (int i = 2; i <= int(n); ++i)
if (a[i] != a[i - 1]) {
o1 = o2 = 1;
swap(a[i], a[i - 1]);
for (int j = 2; j <= int(n); ++j) {
if (a[j - 1] > a[j]) o1 = 0;
if (a[j - 1] < a[j]) o2 = 0;
if (o1 || o2) continue;
cout << i - 1 << ' ' << i << endl;
return 0;
}
swap(a[i], a[i - 1]);
}
cout << "-1";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int INF = 2000000000;
double EPS = 1e-8;
bool sorted(vector<int> &a) {
int n = (int)((a).size());
if (a[0] < a[n - 1]) {
int x = -1;
for (int i = 0; i < n; ++i) {
if (a[i] < x) return false;
x = max(a[i], x);
}
}
if (a[0] > a[n - 1]) {
int x = INF;
for (int i = 0; i < n; ++i) {
if (a[i] > x) return false;
x = min(a[i], x);
}
}
if (a[0] == a[n - 1]) {
int x = a[0];
for (int i = 0; i < n; ++i)
if (a[i] != x) return false;
}
return true;
}
int main() {
for (int n; ~scanf("%d", &n);) {
vector<int> a(n);
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
vector<int> x(n, INF), y(n, 0), xi(n, 0), yi(n, 0);
for (int i = 0; i < n; ++i) {
if (x[n - i - 1] > a[n - i - 1]) {
xi[n - i - 1] = n - i - 1;
x[n - i - 1] = a[n - i - 1];
} else {
xi[n - i - 1] = xi[n - i];
x[n - i - 1] = a[n - i];
}
if (y[n - i - 1] < a[n - i - 1]) {
yi[n - i - 1] = n - i - 1;
y[n - i - 1] = a[n - i - 1];
} else {
yi[n - i - 1] = n - i;
y[n - i - 1] = a[n - i];
}
}
for (int i = 0; i < n - 1; ++i) {
if (a[i] > x[i + 1]) {
int p = i + 1;
int q = xi[i + 1] + 1;
swap(a[p - 1], a[q - 1]);
if (!sorted(a)) {
cout << p << " " << q << endl;
return 0;
}
swap(a[p - 1], a[q - 1]);
}
if (a[i] < y[i + 1]) {
int p = i + 1;
int q = yi[i + 1] + 1;
swap(a[p - 1], a[q - 1]);
if (!sorted(a)) {
cout << p << " " << q << endl;
return 0;
}
swap(a[p - 1], a[q - 1]);
}
}
puts("-1");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
vector<int> a(n), b(n), c(n);
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
b = a;
sort(b.begin(), b.end());
c = b;
reverse(c.begin(), c.end());
for (int i = 0; i < n - 1; ++i) {
if (a[i] == a[i + 1]) continue;
swap(a[i], a[i + 1]);
if (a != b && a != c) {
printf("%d %d", i + 1, i + 2);
return 0;
}
swap(a[i], a[i + 1]);
}
puts("-1");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-5;
const int inf = (1 << 31) - 1;
const int hinf = 0x3f3f3f3f;
const int mod = 1000000007;
int dat[110000];
int d2[110000];
int n;
int main() {
cin >> n;
if (n == 1) {
puts("-1");
return 0;
}
for (int i = 1; i <= n; i++) cin >> dat[i];
int f1 = 1, f2 = 1;
for (int i = 1; i < n; i++)
if (dat[i] < dat[i + 1]) f1 = 0;
for (int i = 1; i < n; i++)
if (dat[i] > dat[i + 1]) f2 = 0;
if (f1 == 1 || f2 == 1) {
if (n < 3) {
puts("-1");
return 0;
}
}
int cnt = 0;
for (int j = 1; j < n; j++)
if (dat[j] != dat[j + 1]) cnt = j;
if (cnt == 0) {
puts("-1");
return 0;
}
if (f1 == 1 || f2 == 1) {
cout << cnt << " " << cnt + 1 << endl;
return 0;
}
int a, b;
srand(time(0));
for (int i = 1; i <= 1000; i++) {
if (i == 1)
a = cnt, b = cnt + 1;
else
a = rand() % n + 1;
b = rand() % n + 1;
if (a == b || dat[a] == dat[b]) {
i--;
continue;
}
for (int j = 1; j <= n; j++) d2[j] = dat[j];
swap(d2[a], d2[b]);
int f1 = 1, f2 = 1;
for (int j = 1; j < n; j++)
if (d2[j] < d2[j + 1]) f1 = 0;
for (int j = 1; j < n; j++)
if (d2[j] > d2[j + 1]) f2 = 0;
if (f1 == 0 && f2 == 0) {
cout << a << " " << b << endl;
return 0;
}
}
puts("-1");
}
|
#include <bits/stdc++.h>
using namespace std;
int a[4], p[4], length[4], q[4], pos[4];
int main() {
int n, m, top = 0;
scanf("%d%d", &n, a);
p[0] = 1;
for (int i = 2; i <= n; i++) {
scanf("%d", &m);
if (m != a[top]) {
a[++top] = m;
p[top] = i;
} else {
length[top]++;
}
if (top > 2) i = n + 1;
}
int num = 0;
q[0] = a[0];
pos[0] = p[0];
for (int i = 1; i <= top; i++) {
bool st = 1;
for (int j = 0; j < i; j++)
if (a[j] == a[i]) st = 0;
if (st) {
q[++num] = a[i];
pos[num] = p[i];
}
}
if (num == 0) printf("-1\n");
if (num == 1) {
if (top <= 2) {
int i = 0;
while ((i <= top) && (length[i] == 0)) i++;
if (i == 0) {
printf("%d %d\n", p[1] - 1, p[1]);
} else {
if (i > top) {
printf("-1\n");
} else {
printf("%d %d\n", p[i] - 1, p[i]);
}
}
} else {
printf("%d %d\n", p[0], p[1]);
}
}
if (num >= 2) {
if (q[0] < q[1]) {
if (q[1] < q[2])
printf("%d %d\n", pos[0], pos[1]);
else
printf("%d %d\n", pos[0], pos[2]);
} else {
if (q[1] > q[2])
printf("%d %d\n", pos[0], pos[1]);
else
printf("%d %d\n", pos[0], pos[2]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool orden(int a, int b) {
if (a == b)
return true;
else
return false;
}
int main() {
int arreglo[100000], n, x;
cin >> n;
for (int i = 0; i < n; i++) cin >> arreglo[i];
if (n < 3)
cout << "-1" << endl;
else {
for (x = 0; (x < n - 1) && orden(arreglo[x], arreglo[x + 1]); x++)
;
if (x == n - 1)
cout << "-1" << endl;
else if (x == 0) {
if (n == 3) {
if (arreglo[0] > arreglo[1]) {
if (arreglo[0] == arreglo[2])
cout << "-1" << endl;
else if (arreglo[0] < arreglo[2])
cout << "1 3" << endl;
else
cout << "1 2" << endl;
} else {
if (arreglo[0] == arreglo[2])
cout << "-1" << endl;
else if (arreglo[0] > arreglo[2])
cout << "1 3" << endl;
else
cout << "1 2" << endl;
}
} else if (arreglo[1] == arreglo[2])
cout << "1 2" << endl;
else
cout << "2 3" << endl;
} else {
cout << x + 1 << " " << x + 2 << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
int n;
int a[100000];
int min = 2000000000, ind;
void init() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
if (a[i] < min) {
min = a[i];
ind = i;
}
}
}
void solve() {
if (n <= 2) {
printf("-1\n");
return;
}
if (ind == 0) {
for (int i = ind + 1; i < n; i++) {
if (a[i] > min) {
if (i == 1) {
for (int j = i + 1; j < n; j++) {
if (a[j] > min) {
printf("1 2\n");
return;
}
}
if (n == 3) {
printf("-1\n");
} else {
printf("2 3\n");
}
return;
} else {
printf("%d %d\n", i, i + 1);
return;
}
}
}
printf("-1\n");
} else if (ind == n - 1) {
for (int i = ind - 1; i >= 0; i--) {
if (a[i] > min) {
printf("%d %d\n", i + 1, i + 2);
return;
}
}
printf("-1\n");
} else {
if (a[ind - 1] < a[ind + 1]) {
printf("%d %d\n", ind + 1, ind + 2);
} else if (a[ind - 1] > a[ind + 1]) {
printf("%d %d\n", ind, ind + 1);
} else {
if (ind > 1) {
printf("%d %d\n", ind, ind + 1);
return;
}
if (n == 3) {
printf("-1\n");
return;
}
for (int i = 3; i < n; i++) {
if (a[i] > min) {
printf("2 3\n");
return;
}
}
printf("1 2\n");
return;
}
}
}
int main() {
init();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void fail() {
cout << -1 << endl;
exit(0);
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
vector<int> nums;
int first_num = -1;
bool single_num = true;
for (int i = (int)(0); i < (n); ++i) {
int tmp;
cin >> tmp;
if (i == 0) first_num = tmp;
if (tmp != first_num) single_num = false;
nums.push_back(tmp);
}
if (((int)(nums).size()) <= 2) fail();
if (single_num) fail();
for (int i = (int)(0); i < (n); ++i) {
for (int j = (int)(0); j < (n); ++j) {
if (nums[i] == nums[j]) continue;
iter_swap(nums.begin() + i, nums.begin() + j);
if (!is_sorted((nums).begin(), (nums).end()) &&
!is_sorted((nums).begin(), (nums).end(), greater<int>())) {
cout << i + 1 << " " << j + 1 << endl;
exit(0);
}
iter_swap(nums.begin() + i, nums.begin() + j);
}
}
fail();
}
|
#include <bits/stdc++.h>
using namespace std;
int a[100001], n;
bool check() {
bool f = 0, g = 0;
for (int i = 2; i <= n; i++) {
if (a[i] < a[i - 1]) {
f = 1;
} else if (a[i] > a[i - 1]) {
g = 1;
}
}
return f & g;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
if (n <= 2) {
return cout << "-1", 0;
}
bool f = 1;
for (int i = 2; i <= n; i++) {
if (a[i] != a[i - 1]) {
f = 0;
break;
}
}
if (f) {
return cout << "-1", 0;
}
int k = 0;
for (int i = 1; i <= n - 1; i++) {
for (int j = i + 1; j <= n; j++) {
if (k == 3) {
return cout << "-1", 0;
}
if (a[i] != a[j]) {
swap(a[i], a[j]);
if (check()) {
return cout << i << ' ' << j, 0;
}
swap(a[i], a[j]);
k++;
}
}
}
cout << "-1";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[4], p[4], length[4], q[4], pos[4];
int main() {
int n, m, top = 0;
scanf("%d%d", &n, a);
p[0] = 1;
for (int i = 2; i <= n; i++) {
scanf("%d", &m);
if (m != a[top]) {
a[++top] = m;
p[top] = i;
} else {
length[top]++;
}
if (top >= 3) i = n + 1;
}
int num = 0;
q[0] = a[0];
pos[0] = p[0];
for (int i = 1; i <= top; i++) {
bool st = 1;
for (int j = 0; j < i; j++)
if (a[j] == a[i]) st = 0;
if (st) {
q[++num] = a[i];
pos[num] = p[i];
}
}
if (num == 0) printf("-1\n");
if (num == 1) {
if (top <= 2) {
int i = 0;
while ((i <= top) && (length[i] == 0)) i++;
if (i == 0) {
printf("%d %d\n", p[1] - 1, p[1]);
} else {
if (i > top) {
printf("-1\n");
} else {
printf("%d %d\n", p[i] - 1, p[i]);
}
}
} else {
printf("%d %d\n", p[0], p[1]);
}
}
if (num >= 2) {
if (q[0] < q[1]) {
if (q[1] < q[2])
printf("%d %d\n", pos[0], pos[1]);
else
printf("%d %d\n", pos[0], pos[2]);
} else {
if (q[1] > q[2])
printf("%d %d\n", pos[0], pos[1]);
else
printf("%d %d\n", pos[0], pos[2]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool same(int arr[], int N) {
for (int i = 0; i < N; i++) {
if (arr[i] != arr[0]) return false;
}
return true;
}
bool sorted(int arr[], int N) {
int flag = 0;
for (int i = 0; i < N - 1; i++) {
if (arr[i + 1] < arr[i]) {
flag = 1;
break;
}
}
int flag2 = 0;
for (int i = N - 1; i > 0; i--) {
if (arr[i] > arr[i - 1]) {
flag2 = 1;
break;
}
}
if (!flag || !flag2)
return true;
else
return false;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int N;
cin >> N;
int arr[N];
for (int i = 0; i < N; i++) cin >> arr[i];
if (N <= 2)
cout << -1;
else {
if (!same(arr, N)) {
int i = 0;
for (i = 0; i < N - 1; i++) {
if (arr[i] != arr[i + 1]) {
swap(arr[i], arr[i + 1]);
break;
}
}
if (!sorted(arr, N)) {
cout << i + 1 << ' ' << i + 2;
return 0;
} else {
swap(arr[i], arr[i + 1]);
for (i = N - 1; i > 0; i--) {
if (arr[i] != arr[i - 1]) {
swap(arr[i], arr[i - 1]);
break;
}
}
if (!sorted(arr, N)) {
cout << i << ' ' << i + 1;
} else
cout << -1;
}
} else
cout << -1;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 5;
const int mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
int a[MAXN];
int main() {
int n;
scanf("%d", &n);
int l = 0, r = 0, maxn = -1, minn = mod, ans1 = -1, ans2 = -1;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (a[i] > maxn) maxn = a[i], r = i;
if (a[i] < minn) minn = a[i], l = i;
}
if (maxn == minn || l == r || n <= 2)
printf("-1\n");
else {
for (int i = 1; i <= n - 2; i++) {
if (a[i] > a[i + 1] && a[i + 1] > a[i + 2]) {
ans1 = i;
ans2 = i + 1;
break;
}
if (a[i] == a[i + 1] && a[i] > a[i + 2]) {
ans1 = i + 1;
ans2 = i + 2;
break;
}
if (a[i] > a[i + 1] && a[i + 1] == a[i + 2]) {
ans1 = i;
ans2 = i + 1;
break;
}
if (a[i] < a[i + 1] && a[i + 1] < a[i + 2]) {
ans1 = i;
ans2 = i + 1;
break;
}
if (a[i] == a[i + 1] && a[i] < a[i + 2]) {
ans1 = i + 1;
ans2 = i + 2;
break;
}
if (a[i] < a[i + 1] && a[i + 1] == a[i + 2]) {
ans1 = i;
ans2 = i + 1;
break;
}
}
if (ans1 != -1)
printf("%d %d\n", ans1, ans2);
else if (n == 3 && a[1] == a[3])
printf("-1\n");
else
printf("%d %d\n", l, r);
}
return 0;
}
|
#include <bits/stdc++.h>
const long long int M = 1e9 + 7;
using namespace std;
bool check(vector<int> a) {
bool s1 = true;
bool s2 = true;
int n = a.size();
for (int i = 0; i < n - 1; i++) {
if (a[i] < a[i + 1]) s1 = false;
if (a[i] > a[i + 1]) s2 = false;
}
return (s1 || s2);
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL);
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n - 1; i++) {
if (a[i] != a[i + 1]) {
swap(a[i], a[i + 1]);
if (!check(a)) {
cout << i + 1 << " " << i + 2 << "\n";
return 0;
}
swap(a[i], a[i + 1]);
}
}
cout << -1 << "\n";
return 0;
}
|
#include <bits/stdc++.h>
template <typename T>
T inline SQR(const T &a) {
return a * a;
}
template <typename T>
T inline ABS(const T &a) {
return a < 0 ? -a : a;
}
const double EPS = 1e-9;
inline int SGN(double a) {
return ((a > EPS) ? (1) : ((a < -EPS) ? (-1) : (0)));
}
inline int CMP(double a, double b) { return SGN(a - b); }
using namespace std;
int a[100000];
bitset<100000> _inc, _dec;
bitset<100000> _incr, _decr;
int main(int argc, char *argv[]) {
ios::sync_with_stdio(false);
int n;
cin >> n;
for (int i = 0; i < n; ++i) cin >> a[i];
_inc[0] = true;
_dec[0] = true;
for (int i = 1; i <= n - 1; ++i) {
_inc[i] = (_inc[i - 1] && (a[i - 1] <= a[i]));
_dec[i] = (_dec[i - 1] && (a[i - 1] >= a[i]));
}
_incr[n - 1] = true;
_decr[n - 1] = true;
for (int i = n - 2; i >= 0; --i) {
_incr[i] = (_incr[i + 1] && (a[i] <= a[i + 1]));
_decr[i] = (_decr[i + 1] && (a[i] >= a[i + 1]));
}
int ii = -1, jj = -1;
for (int i = 0; i < n - 2; ++i) {
for (int x = 0; x < 3; ++x)
for (int y = 0; y < 3; ++y) {
if (a[i + x] != a[i + y]) {
swap(a[i + x], a[i + y]);
bool iin = (a[i] <= a[i + 1]) && (a[i + 1] <= a[i + 2]);
bool din = (a[i] >= a[i + 1]) && (a[i + 1] >= a[i + 2]);
if (!iin && !din) {
ii = i + x + 1, jj = i + y + 1;
goto hell;
}
bool bin = i ? (_inc[i - 1] && (a[i - 1] <= a[i])) : true;
bool bdc = i ? (_dec[i - 1] && (a[i - 1] >= a[i])) : true;
bool ain =
((i + 3) < n) ? (_incr[i + 3] && a[i + 2] <= a[i + 3]) : true;
bool adc =
((i + 3) < n) ? (_decr[i + 3] && a[i + 2] >= a[i + 3]) : true;
bool _incrsin = bin && iin && ain;
bool _decrsin = bdc && din && adc;
if (!_incrsin && !_decrsin) {
ii = i + x + 1;
jj = i + y + 1;
goto hell;
}
swap(a[i + x], a[i + y]);
}
}
}
hell:
cout << ii;
if (ii != -1) cout << " " << jj;
cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t = 1;
while (t--) {
long long n, i, x, y;
cin >> n;
vector<long long> a, b, c;
for (i = 0; i < n; i++) {
cin >> x;
a.push_back(x);
}
b = a;
c = a;
sort(b.begin(), b.end());
sort(c.rbegin(), c.rend());
for (i = 1; i < n; i++) {
if (a[i] != a[i - 1]) {
swap(a[i], a[i - 1]);
if (a != b && a != c) {
cout << i << " " << i + 1 << endl;
return 0;
}
swap(a[i], a[i - 1]);
}
}
cout << "-1" << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 15;
int a[maxn];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
if (n <= 2)
puts("-1");
else {
int cur = 1;
while (a[cur + 1] == a[cur] && cur <= n) cur++;
if (cur >= n)
puts("-1");
else if (cur == 1) {
if (a[cur + 2] == a[cur]) {
if (3 == n)
puts("-1");
else if (a[cur + 3] == a[cur])
printf("%d %d\n", cur + 1, cur + 2);
else
printf("%d %d\n", cur + 2, cur + 3);
} else if (a[cur + 1] > a[cur]) {
if (a[cur + 2] >= a[cur + 1])
printf("%d %d\n", cur, cur + 1);
else
printf("%d %d\n", cur, cur + 2);
} else {
if (a[cur + 2] > a[cur + 1])
printf("%d %d\n", cur, cur + 2);
else
printf("%d %d\n", cur, cur + 1);
}
} else {
printf("%d %d\n", cur, cur + 1);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 1e5 + 7;
const long long MOD = 1e9 + 7;
int a[MAXN], b[MAXN], c[MAXN];
set<int> s;
int main() {
int n, T, m;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
s.insert(a[i]);
}
if (s.size() == 1) {
printf("-1");
return 0;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (a[i] != a[j]) {
for (int i = 1; i <= n; i++) {
b[i] = a[i];
}
swap(b[i], b[j]);
if (is_sorted(b + 1, b + 1 + n, [](int x, int y) { return x < y; })) {
continue;
} else if (is_sorted(b + 1, b + 1 + n,
[](int x, int y) { return x > y; })) {
continue;
} else {
printf("%d %d\n", i, j);
return 0;
}
}
}
}
printf("-1\n");
}
|
#include <bits/stdc++.h>
int main() {
int n, i, a[100010], dec, incr, temp, j;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
if (n == 1 || n == 2) {
printf("-1\n");
return 0;
} else {
for (i = 0; i + 1 < n; i++) {
if (a[i] != a[i + 1]) {
int flag1 = 0, flag2 = 0;
temp = a[i];
a[i] = a[i + 1];
a[i + 1] = temp;
for (j = 0; j + 1 < n; j++) {
flag1 = a[j] < a[j + 1] ? 1 : flag1;
flag2 = a[j] > a[j + 1] ? 1 : flag2;
if (flag1 && flag2) {
printf("%d %d\n", i + 1, i + 2);
return 0;
}
}
temp = a[i];
a[i] = a[i + 1];
a[i + 1] = temp;
}
}
}
printf("-1");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, same = 0;
cin >> n;
vector<int> v(n), vt, vtr;
for (int i = 0; i < n; i++) {
cin >> v[i];
if (v[i] == v[0]) same++;
}
if (n <= 2 || same == n)
cout << -1 << endl;
else {
vt = v;
sort(vt.begin(), vt.end());
vtr = vt;
reverse(vtr.begin(), vtr.end());
for (int i = 1; i < n; i++) {
if (v[i] == v[i - 1]) continue;
swap(v[i], v[i - 1]);
if (v != vt && v != vtr) {
cout << i << " " << i + 1 << endl;
return 0;
}
swap(v[i], v[i - 1]);
}
}
if (!(n <= 2 || same == n)) cout << -1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> v(n), a1, a2;
for (int i = 0; i < n; i++) cin >> v[i];
a1 = a2 = v;
sort(a1.begin(), a1.end());
sort(a2.rbegin(), a2.rend());
for (int i = 1; i < n; i++) {
if (v[i] != v[i - 1]) {
swap(v[i], v[i - 1]);
if (v == a1 || v == a2) {
swap(v[i], v[i - 1]);
continue;
}
cout << i << " " << i + 1 << endl;
return 0;
}
}
cout << -1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[4], p[4], length[4], q[4], pos[4];
int main() {
int n, top = 0;
scanf("%d%d", &n, a);
p[0] = 1;
for (int i = 2; i <= n; i++) {
int m;
scanf("%d", &m);
if (m != a[top]) {
a[++top] = m;
p[top] = i;
} else {
length[top]++;
}
if (top >= 3) i = n + 1;
}
int num = 0;
q[0] = a[0];
pos[0] = p[0];
for (int i = 1; i <= top; i++) {
bool st = 1;
for (int j = 0; j < i; j++)
if (a[j] == a[i]) st = 0;
if (st) {
q[++num] = a[i];
pos[num] = p[i];
}
}
if (num == 0) printf("-1\n");
if (num == 1) {
if (top <= 2) {
int i = 0;
while ((!length[i]) && (i <= top)) i++;
if (i == 0) {
printf("%d %d\n", p[1] - 1, p[1]);
} else {
if (i > top) {
printf("-1\n");
} else {
printf("%d %d\n", p[i] - 1, p[i]);
}
}
} else {
printf("%d %d\n", p[0], p[1]);
}
}
if (num >= 2) {
if (q[0] < q[1]) {
if (q[1] < q[2])
printf("%d %d\n", pos[0], pos[1]);
else
printf("%d %d\n", pos[0], pos[2]);
} else {
if (q[1] > q[2])
printf("%d %d\n", pos[0], pos[1]);
else
printf("%d %d\n", pos[0], pos[2]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool issorted(long long int *arr, int n) {
int flag = 0;
for (int i = 1; i < n; i++) {
if (arr[i - 1] > arr[i]) {
flag = 1;
break;
}
}
if (flag == 0) return true;
flag = 0;
for (int i = n - 2; i >= 0; i--) {
if (arr[i + 1] > arr[i]) {
flag = 1;
break;
}
}
if (flag == 0) return true;
return false;
}
int main(void) {
int n;
cin >> n;
long long int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
long long int flag = 0;
for (int i = 1; i < n; i++) {
if (arr[i] != arr[i - 1]) {
flag = 1;
break;
}
}
if (flag == 0 || n <= 2)
cout << "-1" << endl;
else if (n == 3 && arr[0] == arr[2])
cout << "-1" << endl;
else {
flag = 0;
for (int i = 1; i < n; i++) {
if (arr[i] != arr[i - 1]) {
long long int swap = arr[i];
arr[i] = arr[i - 1];
arr[i - 1] = swap;
if (!issorted(arr, n)) {
cout << i + 1 << " " << i << endl;
break;
} else {
swap = arr[i];
arr[i] = arr[i - 1];
arr[i - 1] = swap;
}
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long arr[100002];
bool isIncreasing(long long N) {
for (int i = 1; i < N; i++) {
if (arr[i] < arr[i - 1]) return false;
}
return true;
}
bool isDecreasing(long long N) {
for (int i = 1; i < N; i++) {
if (arr[i] > arr[i - 1]) return false;
}
return true;
}
int main() {
long long N, temp;
cin >> N;
if (N <= 2) {
cout << -1 << endl;
return 0;
}
for (int i = 0; i < N; i++) {
cin >> arr[i];
}
if (N == 3) {
if (arr[0] == arr[2]) {
cout << -1 << endl;
return 0;
}
}
for (int i = 1; i < N; i++) {
if (arr[i] != arr[i - 1]) {
temp = arr[i];
arr[i] = arr[i - 1];
arr[i - 1] = temp;
if (isIncreasing(N) || isDecreasing(N)) {
cout << i + 1 << " " << i + 2 << endl;
return 0;
}
cout << i << " " << i + 1 << endl;
return 0;
}
}
cout << -1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int a[100005];
void swap(int i, int j) {
int t = a[i];
a[i] = a[j];
a[j] = t;
}
bool Rastuci() {
for (int i = 1; i < n; i++)
if (a[i] < a[i - 1]) return false;
return true;
}
bool Opadajuci() {
for (int i = 1; i < n; i++)
if (a[i] > a[i - 1]) return false;
return true;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
bool sviIsti = true;
for (int i = 1; i < n; i++)
if (a[i] != a[i - 1]) {
sviIsti = false;
break;
}
if (sviIsti) {
printf("-1\n");
return 0;
}
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++) {
if (a[i] != a[j]) {
swap(i, j);
if (!(Rastuci() || Opadajuci())) {
cout << i + 1 << " " << j + 1;
return 0;
}
swap(i, j);
}
}
cout << "-1";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool comp(int x, int y) { return x > y; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, i, j, arr[100001], brr[100001], crr[100001];
set<int> s;
cin >> n;
for (i = 0; i < n; i++) {
cin >> arr[i];
s.insert(arr[i]);
}
if (n <= 2 || s.size() == 1)
cout << "-1";
else {
for (i = 0; i < n; i++) {
brr[i] = arr[i];
crr[i] = arr[i];
}
sort(brr, brr + n);
sort(crr, crr + n, comp);
int flag = 0;
for (i = 0; i < n - 1; i++) {
if (arr[i] == arr[i + 1]) continue;
if (arr[i] == brr[i + 1] && arr[i + 1] == brr[i]) continue;
if (arr[i] == crr[i + 1] && arr[i + 1] == crr[i]) continue;
cout << i + 1 << " " << i + 2;
flag = 1;
break;
}
if (flag == 0) cout << "-1";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> v(n), a1, a2;
for (int i = 0; i < n; i++) {
cin >> v[i];
}
a1 = a2 = v;
sort(a1.begin(), a1.end());
sort(a2.rbegin(), a2.rend());
for (int i = 1; i < n; i++) {
if (v[i] != v[i - 1]) {
swap(v[i], v[i - 1]);
if (v == a1 || v == a2) {
swap(v[i], v[i - 1]);
continue;
}
cout << i << " " << i + 1 << endl;
return 0;
}
}
cout << -1;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100003;
int a[N];
int n;
bool sorted() {
bool p = true, q = true;
for (int i = 1; i < n; ++i) {
if (a[i] < a[i - 1]) p = false;
if (a[i] > a[i - 1]) q = false;
}
return p || q;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d", a + i);
for (int i = 0; i < n; ++i) {
bool f = false;
for (int j = 1; j < n; ++j)
if (a[i] != a[j]) {
f = true;
swap(a[i], a[j]);
if (!sorted()) {
printf("%d %d\n", i + 1, j + 1);
return 0;
}
swap(a[i], a[j]);
}
if (!f) break;
}
puts("-1");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int modInverse(long long int a, long long int m) {
long long int m0 = m;
long long int y = 0, x = 1;
if (m == 1) return 0;
while (a > 1) {
long long int q = a / m;
long long int t = m;
m = a % m, a = t;
t = y;
y = x - q * y;
x = t;
}
if (x < 0) x += m0;
return x;
}
void pairsort(int a[], int b[], int n) {
pair<int, int> pairt[n];
for (int i = 0; i < n; i++) {
pairt[i].first = a[i];
pairt[i].second = b[i];
}
sort(pairt, pairt + n);
for (int i = 0; i < n; i++) {
a[i] = pairt[i].first;
b[i] = pairt[i].second;
}
}
void pairsortlli(long long int a[], long long int b[], long long int n) {
pair<long long int, long long int> pairt[n];
for (long long int i = 0; i < n; i++) {
pairt[i].first = a[i];
pairt[i].second = b[i];
}
sort(pairt, pairt + n);
for (long long int i = 0; i < n; i++) {
a[i] = pairt[i].first;
b[i] = pairt[i].second;
}
}
long long int binomialCoeff(long long int n, long long int k) {
long long int C[k + 1];
memset(C, 0, sizeof(C));
C[0] = 1;
for (long long int i = 1; i <= n; i++) {
for (long long int j = min(i, k); j > 0; j--)
C[j] = (C[j] + C[j - 1]) % 1000000007;
}
return C[k];
}
long long int power(long long int x, long long int y, long long int p) {
long long int res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long int lcm(long long int a, long long int b) {
return a * b / gcd(a, b);
}
long long int max(long long int a, long long int b) {
if (a > b) return a;
return b;
}
long long int min(long long int a, long long int b) {
if (a < b) return a;
return b;
}
long long int bins(long long int arr[], long long int l, long long int r,
long long int x) {
if (r >= l) {
long long int mid = l + (r - l) / 2;
if (arr[mid] == x) return mid;
if (arr[mid] > x) return bins(arr, l, mid - 1, x);
return bins(arr, mid + 1, r, x);
}
return -1;
}
void swap(long long int* a, long long int* b) {
long long int t;
t = *a;
*a = *b;
*b = t;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
long long int n;
cin >> n;
long long int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
if (n == 1 || n == 2) {
cout << -1 << "\n";
return 0;
}
long long int c = 0, d = 0;
for (long long int i = 1; i < n; i++) {
if (a[i] > a[i - 1]) c++;
if (a[i] < a[i - 1]) d++;
}
if ((c == 0 && d == 0) || (c == 1 && d == 1 && n == 3 && a[0] == a[2]))
cout << -1 << "\n";
else if (c == 0) {
for (long long int i = 1; i < n; i++) {
if (a[i] < a[i - 1]) {
cout << i << " " << i + 1 << "\n";
return 0;
}
}
} else if (d == 0) {
for (long long int i = 1; i < n; i++) {
if (a[i] > a[i - 1]) {
cout << i << " " << i + 1 << "\n";
return 0;
}
}
} else if (c == 1 && d == 1) {
if (n == 3) {
cout << 1 << " " << 3 << "\n";
return 0;
}
if (a[1] == a[2]) {
for (long long int i = 3; i < n; i++) {
if (a[i] > a[i - 1] || a[i] < a[i - 1]) {
cout << i << " " << i + 1 << "\n";
return 0;
}
}
} else {
cout << 2 << " " << 3 << "\n";
}
} else {
if (c >= d) {
for (long long int i = 1; i < n; i++) {
if (a[i] > a[i - 1]) {
cout << i << " " << i + 1 << "\n";
return 0;
}
}
} else {
for (long long int i = 1; i < n; i++) {
if (a[i] < a[i - 1]) {
cout << i << " " << i + 1 << "\n";
return 0;
}
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> a;
set<long long> znach;
const long long inf = 1e18;
long long n, mm = inf, MM = -inf, cnt = 0;
void chech(long long x, long long y) {
vector<long long> b = a;
swap(b[x], b[y]);
long long i;
bool f1 = true, f2 = true;
for (i = 2; i <= n; i++)
if (b[i] > b[i - 1]) {
f1 = false;
break;
}
for (i = 2; i <= n; i++)
if (b[i] < b[i - 1]) {
f2 = false;
break;
}
if (!f1 && !f2) {
cout << x << " " << y;
exit(0);
}
}
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cin >> n;
long long i, j;
a.push_back(0);
for (i = 1; i <= n; i++) {
long long q;
cin >> q;
a.push_back(q);
znach.insert(a[i]);
}
if (n < 3) {
cout << -1;
return 0;
}
if (znach.size() == 1) {
cout << -1;
return 0;
}
if (n < 100) {
for (i = 1; i < n; i++)
for (j = i + 1; j <= n; j++) {
if (a[i] != a[j]) chech(i, j);
}
cout << -1;
return 0;
}
if (znach.size() > 2) {
for (i = 1; i <= n; i++) {
mm = min(mm, a[i]);
MM = max(MM, a[i]);
}
long long pos;
for (i = 1; i <= n; i++)
if (a[i] != mm && a[i] != MM) pos = i;
if (a[1] != a[pos]) {
cout << 1 << " " << pos;
return 0;
}
if (a[n] != a[pos]) {
cout << pos << " " << n;
return 0;
}
long long p1, p2;
for (i = 1; i <= n; i++) {
if (a[i] == mm) p1 = i;
if (a[i] == MM) p2 = i;
}
cout << p1 << " " << p2;
return 0;
}
set<long long>::iterator ii;
ii = znach.begin();
long long one = *ii;
++ii;
long long two = *ii;
vector<long long> qwe, rty;
for (i = 1; i <= n; i++)
if (a[i] == one)
qwe.push_back(i);
else
rty.push_back(i);
srand(time(NULL));
while (true) {
long long ff = rand();
long long ss = rand();
ff = (ff * ff) % (qwe.size());
ss = (ss * ss) % (rty.size());
long long x = qwe[ff], y = rty[ss];
chech(x, y);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[5], p[5], length[5], q[5], pos[5];
int main() {
int n, top = 0;
scanf("%d%d", &n, a);
p[0] = 1;
for (int i = 2; i <= n; i++) {
int m;
scanf("%d", &m);
if (m != a[top]) {
a[++top] = m;
p[top] = i;
} else {
length[top]++;
}
if (top >= 3) i = n + 1;
}
int num = 0;
q[0] = a[0];
pos[0] = p[0];
for (int i = 1; i <= top; i++) {
bool st = 1;
for (int j = 0; j < i; j++)
if (a[j] == a[i]) st = 0;
if (st) {
q[++num] = a[i];
pos[num] = p[i];
}
}
if (num == 0) printf("-1\n");
if (num == 1) {
if (top <= 2) {
int i = 0;
while ((length[i] == 0) && (i <= top)) i++;
if (i == 0) {
printf("%d %d\n", p[1] - 1, p[1]);
} else {
if (i > top) {
printf("-1\n");
} else {
printf("%d %d\n", p[i] - 1, p[i]);
}
}
} else {
printf("%d %d\n", p[0], p[1]);
}
}
if (num >= 2) {
if (q[0] < q[1]) {
if (q[1] < q[2])
printf("%d %d\n", pos[0], pos[1]);
else
printf("%d %d\n", pos[0], pos[2]);
} else {
if (q[1] > q[2])
printf("%d %d\n", pos[0], pos[1]);
else
printf("%d %d\n", pos[0], pos[2]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100 * 1000 + 10;
int n;
int xs[MAXN];
bool all_equal() {
for (int i = 1; i < n; ++i)
if (xs[i] != xs[0]) return false;
return true;
}
bool sorted() {
bool inc = true;
for (int i = 0; inc && i < n - 1; ++i) inc = xs[i] <= xs[i + 1];
bool dec = true;
for (int i = 0; !inc && dec && i < n - 1; ++i) dec = xs[i] >= xs[i + 1];
return inc || dec;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < n; ++i) cin >> xs[i];
if (n > 2 && !all_equal()) {
int k = 0;
for (int i = 0; k < 3 && i < n - 1; ++i)
for (int j = i + 1; k < 3 && j < n; ++j)
if (xs[i] != xs[j]) {
swap(xs[i], xs[j]);
if (!sorted()) {
cout << i + 1 << ' ' << j + 1 << endl;
return 0;
}
swap(xs[i], xs[j]);
++k;
}
}
cout << -1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[100005];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 1; i < n; i++) {
if (a[i] != a[i - 1]) {
swap(a[i], a[i - 1]);
int cnt1 = n - 1, cnt2 = n - 1;
for (int j = 1; j < n; j++) {
if (a[j] <= a[j - 1]) cnt1--;
if (a[j] >= a[j - 1]) cnt2--;
}
if (cnt1 && cnt2) {
cout << i << " " << i + 1 << endl;
return 0;
}
swap(a[i], a[i - 1]);
}
}
cout << -1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<int, int> p;
int main() {
int i, j, m, n;
int s[100100];
while (cin >> n) {
int mark = 0;
int k = 0;
for (i = 1; i <= n; i++) scanf("%d", &s[i]);
for (j = 1; j < n; j++) {
if (s[j] != s[j + 1]) {
int r = 0;
swap(s[j], s[j + 1]);
for (i = 1; i < n; i++) {
if (s[i] < s[i + 1]) {
r++;
break;
}
}
for (i = 1; i < n; i++) {
if (s[i] > s[i + 1]) {
r++;
break;
}
}
swap(s[j], s[j + 1]);
if (r < 2)
continue;
else {
cout << j << ' ' << j + 1 << endl;
mark = 1;
break;
}
}
}
if (mark == 0) cout << "-1" << endl;
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.