text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
int N, M;
long long ans;
int main() {
scanf("%d%d", &N, &M);
for (int i = M + 1; i + i - 1 <= N; i++)
for (int j = M + 1, k = N - M; j + M <= N && k > M; j++) {
for (; k > M &&
2 * i * (N + 1) <= 2 * i * i + (N + 1 - i) * j + (i + j) * k;
k--)
;
ans += (k - M) * (1 + (i + i <= N));
}
printf("%I64d\n", ans * 3);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char buf[1 << 21], *p1 = buf, *p2 = buf;
template <class T>
void read(T &x) {
x = 0;
int c = getchar();
int flag = 0;
while (c < '0' || c > '9') flag |= (c == '-'), c = getchar();
while (c >= '0' && c <= '9')
x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();
if (flag) x = -x;
}
template <class T>
T _max(T a, T b) {
return b < a ? a : b;
}
template <class T>
T _min(T a, T b) {
return a < b ? a : b;
}
template <class T>
bool checkmax(T &a, T b) {
return a < b ? a = b, 1 : 0;
}
template <class T>
bool checkmin(T &a, T b) {
return b < a ? a = b, 1 : 0;
}
int n, m;
void init() {
read(n);
read(m);
++n;
}
void solve() {
long long ans = 0;
int up = n - m - 1;
for (register int k = m + 1; k <= up; ++k) {
int i = m + 1, c = 2 * k * k - 2 * n * k;
for (register int j = up; j >= m + 1; --j) {
while (i <= up && c + (i - j) * k + (n + n - j) * (n - i) >= 0) ++i;
if (i <= up)
ans += up - i + 1;
else
break;
}
}
ans *= 3;
printf("%lld\n", ans);
}
int main() {
init();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long sqr(long long x) { return x * x; }
int n, m;
long long calc(int x) {
long long re = 0;
int l = m + 1, r = n - m, tmp = r;
long long suml = sqr(l) + sqr(x) - (long long)l * x + sqr(n - x + 1) +
sqr(tmp) - (long long)(n - x + 1) * tmp;
long long sumr = sqr(n - l + 1) + sqr(n - tmp + 1) -
(long long)(n - l + 1) * (n - tmp + 1);
int nx1 = n - x + 1, nt1 = n - tmp + 1, ni1 = n - l + 1;
for (int i = l; i <= r; i++) {
while (tmp >= l && suml >= sumr) {
suml -= (tmp << 1) - 1 - nx1;
sumr += (nt1 << 1) + 1 - ni1;
tmp--;
nt1++;
}
if (tmp < l) break;
re += tmp - m;
suml += (i << 1) + 1 - x;
sumr -= (ni1 << 1) - 1 - nt1;
ni1--;
}
return re;
}
int main() {
scanf("%d %d", &n, &m);
long long ans = 0;
for (int i = m + 1, up = n / 2; i <= up; i++) ans += calc(i);
ans *= 2;
if (n & 1) ans += calc(n / 2 + 1);
cout << ans * 3 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, mi, sum;
long long ans = 0;
scanf("%lld%lld", &n, &m);
for (long long x = m + 1; x <= (n + 1 >> 1); x++) {
sum = 0;
for (long long y = m + 1; y < (x << 1); y++) {
mi = (x * (2 * x - y) + (n + 1) * (2 * y - x)) / (x + y);
mi = max(mi, m);
if (mi > n - m) continue;
mi = n - m - mi;
sum += mi;
ans += mi << 1;
}
}
if (n & 1) ans -= sum;
printf("%lld\n", ans * 3);
return 0;
}
|
#include <bits/stdc++.h>
int N, M;
long long ans;
int main() {
scanf("%d%d", &N, &M);
for (register int i = M + 1; i + i - 1 <= N; i++)
for (register int j = M + 1, k = N - M; j + M <= N && k > M; j++) {
for (; k > M &&
2 * i * (N + 1) <= 2 * i * i + (N + 1 - i) * j + (i + j) * k;
k--)
;
ans += (k - M) * (1 + (i + i <= N));
}
printf("%I64d\n", ans * 3);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 32005;
int n, m, i, j, f;
int a[N];
long long ans;
int main() {
scanf("%d%d", &n, &m);
for (i = m + 1; i <= (n + 1) / 2; i++) {
for (j = m + 1; j < 2 * i; j++) {
f = (i * (2 * i - j) + (n + 1) * (2 * j - i)) / (i + j);
f = max(f, m);
if (f > n - m) continue;
a[i] += n - m - f;
}
}
for (i = m + 1; i <= (n + 1) / 2; i++) ans += 2 * a[i];
if (n % 2) ans -= a[i - 1];
printf("%I64d\n", 3 * ans);
return 0;
}
|
#include <bits/stdc++.h>
int N, M;
long long ans;
int main() {
scanf("%d%d", &N, &M);
for (int i = M + 1; i + i - 1 <= N; i++)
for (int j = M + 1, k = N - M; j + M <= N && k > M; j++) {
for (; k > M &&
2 * i * (N + 1) <= 2 * i * i + (N + 1 - i) * j + (i + j) * k;
k--)
;
ans += (k - M) * (1 + (i + i - 1 < N));
}
printf("%I64d\n", ans * 3);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int func(int x_low, int x_high, int y_low, int y_high, int maxprod) {
int i, ans = 0;
for (i = x_low; i <= x_high; i++) {
int y = min(y_high, maxprod / i);
if (y >= y_low)
ans += y - y_low + 1;
else
break;
}
return ans;
}
int main(void) {
int N, M, p, q;
cin >> N >> M;
if (M * 2 == N) {
cout << 0 << endl;
return 0;
}
long long ans = 0;
for (p = 1 + M; p <= (N + 1) / 2; p++) {
q = N + 1 - p;
int x_low = 1 + M + p;
int x_high = N - M + p;
int y_low = 1 + M + q;
int y_high = N - M + q;
int tmp = func(x_low, x_high, y_low, y_high, 3 * p * q - 1);
ans += tmp;
if (p != q) ans += tmp;
}
cout << 3 * ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
void fmax(T &a, const T &b) {
if (a < b) a = b;
}
template <class T>
void fmin(T &a, const T &b) {
if (a > b) a = b;
}
template <class T>
T sqr(const T &a) {
return a * a;
}
int n, m;
long long rec[33333];
int main() {
cin >> n >> m;
long long ans = 0;
int l = m + 1, r = n - m;
for (int x1 = (int)l; x1 <= (int)r; x1++) {
int x2 = n + 1 - x1;
if (x2 < x1)
rec[x1] = rec[x2];
else {
long long tmp = 0;
int la = m + 1 + x1, ra = n - m + x1;
int lb = m + 1 + x2, rb = n - m + x2;
int C = 3 * x1 * x2 - 1;
for (int A = (int)la; A <= (int)ra; A++) {
int M = C / A;
if (M >= rb)
tmp += rb - lb + 1;
else if (M >= lb)
tmp += M - lb + 1;
else
break;
}
rec[x1] = tmp;
}
ans += rec[x1];
}
cout << ans * 3 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
struct pt {
int x, y, z;
pt() {}
pt(int a, int b, int c) : x(a), y(b), z(c) {}
inline pt operator+(const pt& o) const {
return pt(x + o.x, y + o.y, z + o.z);
}
inline pt operator-(const pt& o) const {
return pt(x - o.x, y - o.y, z - o.z);
}
inline pt operator*(const int& o) const { return pt(x * o, y * o, z * o); }
};
inline long long dp(const pt& a, const pt& b) {
return (long long)a.x * b.x + (long long)a.y * b.y + (long long)a.z * b.z;
}
const int NMAX = 32300;
int n, m;
pt a, b, amb;
int amt[NMAX];
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
cin >> n >> m;
pt dir(1, 1, 1);
a = pt(-1, 0, 1);
b = pt(-1, 1, 0);
amb = a - b;
for (int i = m + 1; i <= n / 2 + 1; ++i) {
pt pi = b * (n + 1) + amb * i;
int j = n - m;
int k = m + 1;
pt pj = a * j;
pt pk = b * k;
pt pji = pj - pi;
pt pki = pk - pi;
int cur = dp(pj - pi, pk - pi);
int jd = -pji.x + pji.y;
int kd = pki.x - pki.z;
int jdlim = jd - (n - m) + (m + 1);
int kdlim = kd - (n - m) + (m + 1);
int ca = 0;
for (; jd >= jdlim;) {
while (cur >= 0 && kd >= kdlim) {
cur += jd;
kd--;
}
ca += kd;
jd--;
cur += kd;
}
amt[i] = ca + (n - 2 * m) * (1 - kdlim);
}
long long ans = 0;
for (int i = 1; i <= n; ++i) {
int v = min(i, n + 1 - i);
ans += amt[v];
}
cout << ans * 3 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, i, j, k, t, lim, U, L;
long long ans = 0;
scanf("%d%d", &n, &m);
lim = n - m;
L = n + 1;
for (i = L >> 1; i > m; i--) {
t = (i + i < L);
for (j = m + 1, U = (L - i) * (2 * i - j); j <= lim; j++, U += i - L) {
if ((k = (U - 1) / (i + j)) <= m) break;
if (k > lim) k = lim;
ans += (k - m) << t;
}
}
printf("%I64d\n", 3 * ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, l;
int A, B;
int check(int b, int c) { return -(A - b) * (B - c) + 3 * c * b < 0; }
int main() {
int i, j;
scanf("%d%d", &n, &m);
++m;
long long answer = 0;
for (i = m; i + i - 1 <= n; ++i) {
A = 2 * i;
B = 2 * (n + 1 - i);
int now = n + 1 - m, ans = 0;
for (j = m; j <= n - m; ++j) {
while (now >= m && !check(j, now)) --now;
ans += (now - m + 1);
}
answer += ans * ((i * 2 != n + 1) + 1);
}
cout << answer * 3 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
scanf("%d%d", &n, &m);
++n;
long long ans = 0;
for (int a = m + 1; 2 * a <= n; ++a) {
long long cur = 0;
int c = n - m - 1;
for (int b = m + 1; b < n - m && c > m; ++b) {
while (c > m && -b * (n + c) <= 2 * a * a - a * b - 2 * n * a + c * a)
--c;
cur += c - m;
}
ans += cur;
if (a + a != n) ans += cur;
}
printf("%I64d\n", 3 * ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double gen3 = sqrt(3.0), gen3_2 = gen3 / 2;
int n, m;
long long calc() {
long long ans = 0;
for (int i = m + 1; i + m <= n && i <= (n + 1) / 2; ++i) {
double xi = i * 0.5, yi = i * gen3_2;
int sum = 0;
for (int j = m + 1, k = n - m; j + m <= n; ++j) {
double xj = (n + j + 1) * 0.5, yj = (n - j + 1) * gen3_2;
double val = (xj - xi) * (k - xi) - (yj - yi) * yi;
while (k > m && val >= -1e-7) val -= xj - xi, --k;
if (k == m) break;
sum += k - m;
}
if (i * 2 != (n + 1)) sum *= 2;
ans += sum;
}
return ans * 3;
}
int main() {
scanf("%d %d", &n, &m);
cout << calc() << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
scanf("%d%d", &n, &m);
long long ans = 0;
for (int i = m + 1; i + m <= n && i <= (n + 1 >> 1); i++) {
int lx = i, rx = i;
int now = 0;
for (int j = m + 1, k = n - m; j + m <= n; j++) {
int ly = n + j + 1, ry = n - j + 1;
int val = (ly - lx) * ((k << 1) - lx) - (ry - rx) * rx * 3;
while (k > m && val >= 0) val -= ly - lx << 1, k--;
if (k <= m) break;
now += k - m;
}
if (i * 2 != n + 1) now *= 2;
ans += now;
}
printf("%I64d\n", ans * 3);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int n, m;
ll ans = 0;
int main() {
ios::sync_with_stdio(false);
cin >> n >> m;
int l = m + 1, r = n - m;
for (int b = l; b <= r; b++) {
int bb = n + 1 - b;
if (bb < b) continue;
int cur = 0, lim = 3 * b * bb - 1;
int lc = l + bb, rc = r + bb, la = l + b, ra = r + b;
int tmp = lim / rc - 3;
if (tmp > la) cur += (tmp - la) * (rc - lc + 1), la = tmp;
for (int a = la; a <= ra; a++) {
int mx = lim / a;
if (mx >= rc)
cur += rc - lc + 1;
else if (mx >= lc)
cur += mx - lc + 1;
else
break;
}
ans += cur;
if (bb != b) ans += cur;
}
cout << ans * 3 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int NMax = 34000;
int N, M;
int X, Y;
inline bool judge(int b, int c) { return (b - X) * (Y - c) + 3 * b * c < 0; }
int main() {
scanf("%d%d", &N, &M);
N++;
M++;
int nn = N - M;
long long ret = 0;
int t = (int)clock();
for (int i = M; (i << 1) <= N; ++i) {
int p = nn;
int cnt = 0;
X = (i << 1);
Y = ((N - i) << 1);
for (int j = M; j <= nn && p >= M; ++j) {
while (p >= M && !judge(j, p)) --p;
cnt += (p - M + 1);
}
if ((i << 1) == N)
ret += cnt;
else
ret += (cnt << 1);
}
printf("%lld\n", ret * 3);
return 0;
}
|
#include <bits/stdc++.h>
int n, m;
int main() {
long long ans;
int b, c, A, B, C, l;
scanf("%d%d", &n, &m);
n++;
m++;
ans = 0;
for (c = m; c <= n >> 1; c++) {
C = (n * n - n * c + c * c) << 1;
A = (n << 1) - c;
for (b = n - m; b >= m; b--) {
B = b * (n + c);
l = (C - B) / (A - b);
if (m > l) l = m - 1;
if (l >= n - m) break;
ans += n - m - l;
if (c << 1 < n) ans += n - m - l;
}
}
printf("%I64d\n", ans * 3);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 32005;
int n, m, i, j, f;
int a[N];
long long ans;
int main() {
scanf("%d%d", &n, &m);
for (i = m + 1; i <= (n + 1) / 2; i++) {
for (j = m + 1; j < 2 * i; j++) {
f = (i * (2 * i - j) + (n + 1) * (2 * j - i)) / (i + j);
f = max(f, m);
if (f > n - m) continue;
a[i] += n - m - f;
}
}
for (i = m + 1; i <= (n + 1) / 2; i++) ans += 2 * a[i];
if (n & 1) ans -= a[i - 1];
printf("%I64d\n", 3 * ans);
return 0;
}
|
#include <bits/stdc++.h>
int N, M;
long long ans;
int main() {
scanf("%d%d", &N, &M);
register int z, y, x;
for (x = M + 1; 2 * x <= N + 1; x++) {
int st = (N - M - 2 * x) * (N + 1 - x) / (M - N - x);
if (st <= M) st = M + 1;
ans += (st - M - 1) * (N - M - M);
for (z = st, y = N - M; z <= N - M && y > M; z++) {
while (y > M && (x - N - 1) * (x + x - y) + (x + y) * z >= 0) y--;
ans += (y - M) * ((2 * x < N + 1) + 1);
}
}
printf("%I64d\n", ans * 3);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long rdtsc() {
long long tmp;
asm("rdtsc" : "=A"(tmp));
return tmp;
}
inline int myrand() { return abs((rand() << 15) ^ rand()); }
inline int rnd(int x) { return myrand() % x; }
bool solve() {
int n, m;
if (scanf("%d%d", &n, &m) < 2) return 0;
long long ans = 0;
for (int i = m + 1; i <= n - m; ++i) {
unsigned int k = ((int)1e9);
int maxj = min(i, (int)((1ll << 32) / (12 * i)));
for (int j = m + 1; j <= maxj; ++j) {
unsigned int value = 2 * (n + 1) - i - j;
k = min(k, value);
value *= value;
unsigned int del = 12u * i * j;
if (value < del) break;
value -= del;
while (k * k > value) --k;
int eq = (k * k == value);
int midZ = 2 * (n + 1) + i - j;
int l = max(m + 1, (midZ - (int)k + eq + 3) >> 2);
int r = min(n - m, (midZ + (int)k - eq) >> 2);
int tmp = r - l + 1;
if (tmp > 0) ans += tmp * ((i != j) + 1);
}
}
printf(
"%lld"
"\n",
ans * 3);
return 1;
}
int main() {
srand(rdtsc());
while (1) {
if (!solve()) break;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 2000005, Maxm = 200010, Mo = 1000000007, oo = INT_MAX >> 2;
struct Edge {
int u, v;
};
typedef int IArr[Maxn];
int main() {
ios::sync_with_stdio(0);
int n, m;
cin >> n >> m;
int L = n + 1;
long long ans = 0;
for (int a = m + 1; a <= (n + 1) / 2; a++) {
int sum = 0;
for (int b = m + 1; b <= n - m; b++) {
int x = 2 * L * a + a * b - b * L - 2 * a * a;
int y = a + b;
int cnt = x / y - m - (x % y == 0);
cnt = min(cnt, n - 2 * m);
if (cnt < 0) break;
sum += cnt;
}
if (n % 2 && a == (n + 1) / 2)
ans += sum;
else
ans += 2 * sum;
}
cout << ans * 3 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
long long ans;
int main() {
scanf("%d%d", &n, &m);
n++;
m++;
for (int i = m; i <= n - m; i++) {
int k = n - m, l = 1ll * 2 * i * i - 2 * i * n - i * m + i + m * n - n +
k * (m + i) - k;
for (int j = n - m; j >= m && k >= m; j--) {
l += n + k - i;
while (k >= m && l >= 0) k--, l += j - i - n;
ans += k - m + 1;
}
}
cout << ans * 3 << endl;
return 0;
}
|
#include <bits/stdc++.h>
int main() {
int n, q;
scanf("%d%d", &n, &q);
int m = n + 1;
long long ans = 0;
for (long long i = q + 1; i + i <= n + 1; i++) {
int add = 2 * i == n + 1 ? 1 : 2;
int cc = 2 * i * i - 2 * m * i + 1LL * q * (m - i);
int v = i + q;
int k = n - q;
int ad = m - i;
int x = n - q;
int cur = 0;
for (int j = q + 1; j <= x; j++) {
++v;
cc += ad;
while (k > q && v * k >= -cc) {
--k;
}
if (k <= q) break;
int z = k - q;
cur += z;
}
ans += cur;
if (add > 1) ans += cur;
}
printf("%I64d\n", ans * 3);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
long long ans;
int main() {
scanf("%d%d", &n, &m);
for (int i = m + 1; i + i <= n + 1; ++i) {
int k = n - m, p = n + 1 - i;
for (int j = m + 1; j <= n - m && k > m; ++j) {
for (; k > m; --k)
if ((p + k) * j < (p + p - k) * i) break;
ans += (k - m) * (1 + (i + i <= n));
}
}
printf("%I64d\n", ans * 3);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct pt {
int x, y, z;
pt() {}
pt(int a, int b, int c) : x(a), y(b), z(c) {}
inline pt operator+(const pt& o) const {
return pt(x + o.x, y + o.y, z + o.z);
}
inline pt operator-(const pt& o) const {
return pt(x - o.x, y - o.y, z - o.z);
}
inline pt operator*(const int& o) const { return pt(x * o, y * o, z * o); }
};
inline long long dp(const pt& a, const pt& b) {
return (long long)a.x * b.x + (long long)a.y * b.y + (long long)a.z * b.z;
}
const int NMAX = 32300;
int n, m;
pt a, b, amb;
int amt[NMAX];
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
cin >> n >> m;
pt dir(1, 1, 1);
a = pt(-1, 0, 1);
b = pt(-1, 1, 0);
amb = a - b;
for (int i = m + 1; i <= n / 2 + 1; ++i) {
pt pi = b * (n + 1) + amb * i;
int j = n - m;
int k = m + 1;
pt pj = a * j;
pt pk = b * k;
pt pji = pj - pi;
pt pki = pk - pi;
int cur = dp(pj - pi, pk - pi);
int jd = -pji.x + pji.y;
int kd = pki.x - pki.z;
int jdlim = jd - (n - m) + (m + 1);
int kdlim = kd - (n - m) + (m + 1);
int ca = 0;
for (; jd >= jdlim;) {
while (cur >= 0 && kd >= kdlim) {
cur += jd;
kd--;
}
ca += kd + 1 - kdlim;
jd--;
cur += kd;
}
amt[i] = ca;
}
long long ans = 0;
for (int i = 1; i <= n; ++i) {
int v = min(i, n + 1 - i);
ans += amt[v];
}
cout << ans * 3 << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
long long p[100005], p3[100005];
long long q3(long long x) { return x > 0 ? p3[x] : p3[-x]; }
long long q(long long x) { return x > 0 ? p[x] : p[-x]; }
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
for (long long i = 1; i <= 1e5; i++) {
p[i] = i * i;
p3[i] = 3 * i * i;
}
long long n, m, ans = 0;
cin >> n >> m;
for (long long i = m + 1; i <= n - m; i++) {
long long l = m + 1, r = n - m;
for (long long j = n - m; j >= i; j--) {
long long t = q3(j - i) + q(i + j);
while (r >= l && q3(n + 1 - j) + q(n + 1 - l - l - i) + q3(n + 1 - i) +
q(n + 1 - l - l + j) >=
t)
l++;
while (r >= l &&
q3(n + 1 - j) + q(n + 1 - (n + 1 - r) - (n + 1 - r) - j) +
q3(n + 1 - i) + q(n + 1 - (n + 1 - r) - (n + 1 - r) + i) >=
t)
r--;
if (l > r) break;
ans = ans + (r - l + 1) + (i == j ? 0 : (r - l + 1));
}
}
cout << ans * 3;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
long long ans;
int main() {
scanf("%d%d", &n, &m);
for (int i = 1, k = m + 1; i <= (n + 1) / 2 - m; ++i) {
int o = i * 2 - 1 - (n & 1), sum = 0;
for (int x = k, y = n - m; x <= n - m; ++x) {
while (y >= m + 1 &&
(x - o) * (-y - o) + 3 * (n + 1 - x) * (n + 1 - y) < 0)
y--;
if (n - m == y) k++;
sum += (n - m) - y;
}
if (o == 0)
ans += sum;
else
ans += 2 * sum;
}
printf("%lld\n", ans * 3);
}
|
#include <bits/stdc++.h>
using namespace std;
void Get(int &T) {
char C;
bool F = 0;
for (; C = getchar(), C < '0' || C > '9';)
if (C == '-') F = 1;
for (T = C - '0'; C = getchar(), C >= '0' && C <= '9'; T = T * 10 + C - '0')
;
F && (T = -T);
}
int N, M;
void Init() {
Get(N);
Get(M);
}
long long Ans;
void Work() {
int B, C;
for (int i = M + 1; i <= N - M; i++) {
int j = std::min(N - M, N + 1 - i);
int Ans1;
B = -(N * 3 + 3 - i) + j;
C = (N + 1 + i) * (N + 1 - j);
int L = M + 1, R = N - M;
for (; j >= M + 1; j--, B--, C += (N + 1 + i)) {
for (; L <= R && (L * L << 1) + L * B >= -C;) L++;
for (; L <= R && (R * R << 1) + R * B >= -C;) R--;
if (L > R) break;
Ans1 = R - L + 1;
Ans += Ans1;
if (i + j < N + 1) Ans += Ans1;
}
}
Ans *= 3;
}
void Output() { printf("%I64d\n", Ans); }
int main() {
Init();
Work();
Output();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int finda(long long n, long long z, long long b, int Min, int Max) {
while (Max - Min > 1) {
int Mid = (Max + Min) / 2;
long long t = b * (n - z + b) - Mid * (2 * n - 2 * Mid + z);
if (t < 0)
Max = Mid;
else
Min = Mid;
}
return Max;
}
int findz(long long n, long long z, long long b, int Min, int Max) {
while (Max - Min > 1) {
int Mid = (Max + Min) / 2;
long long t = b * (n - z + b) - Mid * (2 * n - 2 * Mid + z);
if (t < 0)
Min = Mid;
else
Max = Mid;
}
return Min;
}
int findb(long long n, long long x, long long a, int Min, int Max) {
while (Max - Min > 1) {
int Mid = (Max + Min) / 2;
long long t = -n * n + n * (a + Mid) + 2 * a * Mid + x * x + x * (Mid - a);
if (t < 0)
Min = Mid;
else
Max = Mid;
}
return Min;
}
long long f(long long n, long long x, long long a, long long b) {
return -n * n + n * (a + b) + 2 * a * b + x * x + x * (b - a);
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
int i, j;
int from = m + 1;
int to = n - m;
long long res = 0;
long long cnt = 0;
for (i = (from); i < (to + 1); ++i) {
int x = n + 1 - i - i;
if (x < 0) break;
int a = from;
int b = findb(n + 1, x, a, from - 1, to + 1);
int value = f(n + 1, x, a, b);
int aa = n + 1 + a + a + x;
int bb = n + 1 - x + 2 * (from - 1);
int r = 0;
b -= from - 1;
for (j = from; j <= to && b > 0; ++j) {
r += b;
value += bb + b + b;
aa += 2;
while (value >= 0) {
value -= aa;
--b;
}
}
long long c = x == 0 ? 1 : 2;
res += c * r;
}
printf("%lld\n", 3 * res);
return 0;
};
|
#include <bits/stdc++.h>
using namespace std;
int n, m, L, lim;
long long ans = 0;
int main() {
scanf("%d%d", &n, &m);
L = n + 1;
lim = n - m;
for (int i = m + 1; i + i <= L; ++i)
for (int j = m + 1, k, C = 2 * i * (i - L) + j * (L - i); j <= lim;
++j, C += L - i) {
if ((k = (-C - 1) / (i + j)) <= m) break;
if (k > lim) k = lim;
ans += (k - m) << ((i << 1) < L);
}
printf("%I64d\n", ans * 3);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int qmin(int a, int b) { return (a < b) ? a : b; }
int qmax(int a, int b) { return (a > b) ? a : b; }
unsigned int n, m;
int main() {
ios::sync_with_stdio(false);
cin >> n >> m;
long long ans = 0;
int jl = n + m + 2;
int jr = n + n + 1 - m;
for (unsigned int x = m + 1; x <= n - m; x++) {
for (unsigned int i = m + 1; i <= n - m; i++) {
int jlmt = (2 * x * x + 3 * (n + 1) * i - i * x) / (i + x);
if (jlmt >= jr) break;
ans += jr - qmax(jlmt + 1, jl) + 1;
}
}
cout << ans * 3LL << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
long long ans = 0;
int main() {
cin >> n >> m;
for (int a = m + 1; a <= (n + 1) / 2; ++a) {
int k = n + 1 - a, c = k + k + k, v = 3 * a * k,
x = 1 + (n % 2 == 0 || a < (n + 1) / 2);
for (int b = a + m + 1; b <= n - m + a; ++b) {
while (c > m + k && b * c >= v) --c;
if (c <= m + k) break;
ans += (min(c - k, n - m) - m) * x;
}
}
cout << ans * 3 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, A;
void read(int &x) {
char ch = getchar();
int mark = 1;
for (; ch != '-' && (ch < '0' || ch > '9'); ch = getchar())
;
if (ch == '-') mark = -1, ch = getchar();
for (x = 0; ch >= '0' && ch <= '9'; ch = getchar()) x = x * 10 + ch - 48;
x *= mark;
}
inline int min(const int x, const int y) { return (x < y) ? x : y; }
inline int max(const int x, const int y) { return (x > y) ? x : y; }
int main() {
read(n);
read(m);
A = n + 1;
int st = m + 1, en = n - m;
long long ans = 0;
for (int x = st; x <= (A >> 1); x++) {
int k = en;
long long tmp = 0;
for (int a = st; a <= en && k >= st; a++) {
for (; k >= st && (A - x) * ((x << 1) - a) <= k * (x + a); k--)
;
tmp += k - m;
}
ans += tmp;
if (x + x - 1 != n) ans += tmp;
}
printf("%I64d\n", ans * 3);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, M;
void doit() {
scanf("%d%d", &N, &M);
long long ans = 0;
for (int i = M + 1; i + i - 1 <= N; i++)
for (int j = M + 1, k = N - M; j + M <= N && k > M; j++) {
for (; k > M &&
(2 * N + 2) * i - 2 * i * i - j * (N + 1 - i) - (i + j) * k <= 0;
k--)
;
ans += (k - M) * (i + i == N + 1 ? 1 : 2);
}
cout << ans * 3 << endl;
}
int main() {
doit();
return 0;
}
|
#include <bits/stdc++.h>
int n, m;
long long ans;
int main() {
scanf("%d%d", &n, &m);
n++;
m++;
for (int i = m; i * 2 <= n; i++)
for (int j = m, k = n - m; j <= n - m; j++) {
for (; k >= m && (i * 2 - j) * ((i - n) * 2 + k) + 3 * j * k >= 0; k--)
;
if (k < m) break;
ans += (k - m + 1) * (i * 2 == n ? 1 : 2);
}
printf("%I64d\n", ans * 3);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1100;
int i, j, k, l, m, n, o, p, a, L, R, x, y, cul, mid;
long long ans, cc;
int main() {
cin >> n >> m;
n++;
L = m + 1;
R = n - m - 1;
ans = 0;
mid = L + R >> 1;
l = R - L + 1;
l &= 1;
mid -= l;
for (a = L; a <= mid; a++) {
cul = 0;
for (y = L; y <= R; y++) {
o = a * ((n << 1) - y - (a << 1));
p = n - a + y;
k = (o + p - 1) / p - 1;
if (k > R) k = R;
if (k >= L) cul += (k - L + 1);
}
ans += (long long)(cul);
}
ans <<= 1;
if (l) {
a = mid + 1;
cul = 0;
for (y = L; y <= R; y++) {
o = a * ((n << 1) - y - (a << 1));
p = n - a + y;
k = (o + p - 1) / p - 1;
if (k > R) k = R;
if (k >= L) cul += (k - L + 1);
}
ans += (long long)(cul);
}
cout << ans * 3LL << endl;
return 0;
}
|
#include <bits/stdc++.h>
int n, m;
long long ans;
int main() {
int i, j, k;
scanf("%d%d", &n, &m);
for (i = m + 1; (i << 1) <= n; ++i) {
k = n - m;
for (j = m + 1; j <= n - m; ++j) {
while (0 <= (i << 1) * ((i << 1) - j - ((n << 1) - k + 2)) + 3 * j * k +
j * ((n << 1) - k + 2) &&
k > m)
--k;
if (k == m) break;
ans += k - m;
}
}
ans <<= 1;
if (n & 1) {
i = (n >> 1) + 1;
k = n - m;
for (j = m + 1; j <= n - m; ++j) {
while (k > m && 0 <= (i << 1) * ((i << 1) - j - ((n << 1) - k + 2)) +
3 * j * k + j * ((n << 1) - k + 2))
--k;
if (k == m) break;
ans += k - m;
}
}
printf("%I64d\n", ans * 3);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, temp, idx = 0;
long long sum = 0;
cin >> n >> k;
vector<long long> s;
vector<long long> v;
for (int i = 0; i < n; i++) {
cin >> temp;
v.push_back(temp);
sum += temp;
if ((i + 1) >= k) {
s.push_back(sum);
sum -= v[idx++];
}
}
int l = s.size();
vector<long long> Max(l);
vector<int> pos(l);
Max[l - 1] = s[l - 1];
pos[l - 1] = l - 1;
for (int i = l - 2; i >= 0; i--) {
if (s[i] >= Max[i + 1]) {
Max[i] = s[i];
pos[i] = i;
} else {
Max[i] = Max[i + 1];
pos[i] = pos[i + 1];
}
}
long long MAX = -1;
for (int i = 0; i < s.size() - k; i++)
if (s[i] + Max[i + k] > MAX) MAX = s[i] + Max[i + k];
for (int i = 0; i < s.size() - k; i++)
if (s[i] + Max[i + k] == MAX) {
cout << (i + 1) << " " << (pos[i + k] + 1) << endl;
break;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
long long a[N] = {0};
int main() {
int n, k;
scanf("%d%d", &n, &k);
if (2 * k == n) return printf("%d %d ", 1, k + 1), 0;
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
a[i] = x;
}
for (int i = 1; i <= n; i++) a[i] += a[i - 1];
vector<long long> v(n - k + 2);
vector<long long> vv(n - k + 2);
for (int i = 1; i <= n - k + 1; i++) {
long long t = a[i + k - 1] - a[i - 1];
v[i] = t;
vv[i] = t;
}
long long m = vv[vv.size() - 1];
for (int i = vv.size() - 1; i > 0; i--) {
m = max(m, vv[i]);
vv[i] = m;
}
long long ans = -1, d = 0, maxb, b;
for (int i = 1; i < v.size() - k; i++) {
long long t = v[i] + vv[i + k];
if (t > ans) {
d = i;
ans = t;
maxb = vv[i + k];
}
}
for (int i = 1; i < v.size(); i++) {
if (i >= d && i <= d + k - 1) continue;
if (i + k - 1 >= d && i + k - 1 <= d + k - 1) continue;
if (v[i] == maxb) {
b = i;
break;
}
}
cout << d << " " << b << endl;
return 0;
}
|
#include <bits/stdc++.h>
const int maxn = 200010;
long long a[maxn + 1], s[maxn + 1], f[maxn + 1];
long long best;
int ra, rb;
int n, K;
void init() {
int i;
scanf("%d%d", &n, &K);
s[0] = 0;
for (i = 1; i <= n; ++i) {
scanf("%lld", &a[i]);
s[i] = s[i - 1] + a[i];
}
}
void calc_f() {
int i;
f[n - K + 1] = n - K + 1;
for (i = n - K; i >= 1; --i) {
f[i] = f[i + 1];
if (s[i + K - 1] - s[i - 1] >= s[f[i + 1] + K - 1] - s[f[i + 1] - 1])
f[i] = i;
}
}
void calc_ra_rb() {
long long best = -1000000001LL * n;
int i, j, k;
long long tmp;
for (i = 1; i <= n - K - K + 1; ++i) {
tmp = s[i + K - 1] - s[i - 1] + s[f[i + K] + K - 1] - s[f[i + K] - 1];
if (tmp > best) {
best = tmp;
ra = i;
rb = f[i + K];
}
}
}
void work() {
calc_f();
calc_ra_rb();
}
void output() { printf("%d %d\n", ra, rb); }
int main() {
init();
work();
output();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n = 0, k = 0, elem = 0;
long long i = 0, j = 0, ansA = 0, ansB = 0;
vector<long long> x, sum, a;
cin >> n >> k;
x.push_back(0);
sum.push_back(0);
for (i = 1; i <= n; i++) {
cin >> elem;
x.push_back(elem);
}
for (i = 1; i <= n; i++) {
sum.push_back(sum[i - 1] + x[i]);
}
a.push_back(0);
for (i = 1; (i + k - 1) <= n; i++) {
a.push_back(sum[i + k - 1] - sum[i - 1]);
}
long long curmax = 0;
long long ans = -1;
for (i = (k + 1); (i + k - 1) <= n; i++) {
if (a[i - k] > a[curmax]) curmax = i - k;
if (ans < a[i] + a[curmax]) {
ansA = curmax;
ansB = i;
ans = a[i] + a[curmax];
}
}
cout << ansA << " " << ansB << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = (int)1e6 + 10;
long long s[N], sum[N], tot[N], maxn[N];
int main() {
int n, k;
while (cin >> n >> k) {
sum[n + 1] = 0;
for (int i = 1; i <= n; i++) cin >> s[i];
for (int i = n; i >= 1; i--) sum[i] = sum[i + 1] + s[i];
tot[n + 1] = 0;
int index = n + 1;
for (int i = n - k + 1; i >= 1; i--) {
tot[i] = sum[i] - sum[i + k];
if (tot[i] >= tot[index]) {
index = i;
}
maxn[i] = index;
}
pair<int, int> ans;
long long cur = 0;
for (int i = 1; i < n - k + 1; i++) {
if (tot[i] + tot[maxn[i + k]] > cur) {
ans = make_pair(i, maxn[i + k]);
cur = tot[i] + tot[maxn[i + k]];
}
}
cout << ans.first << " " << ans.second << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<long long> X(n + 1);
for (int i = 1; i <= n; i++) {
cin >> X[i];
}
for (int i = 1; i <= n; i++) {
X[i] += X[i - 1];
}
vector<pair<long long, int>> dp(n + 1);
dp[n - k + 1] = {X[n] - X[n - k], n - k + 1};
for (int i = n - k; i > k; i--) {
if (X[i + k - 1] - X[i - 1] >= dp[i + 1].first) {
dp[i] = {X[i + k - 1] - X[i - 1], i};
} else {
dp[i] = dp[i + 1];
}
}
int ind1 = 0, ind2 = 0;
long long ans = 0;
for (int i = 1; i <= n - 2 * k + 1; i++) {
if (X[i + k - 1] - X[i - 1] + dp[i + k].first > ans) {
ind1 = i;
ind2 = dp[i + k].second;
ans = X[i + k - 1] - X[i - 1] + dp[i + k].first;
}
}
cout << ind1 << " " << ind2 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int s = 2e5 + 9;
long long max(long long a, long long b) {
if (a > b) return a;
return b;
}
int main() {
int n, k;
scanf("%d%d", &n, &k);
vector<long long> v;
long long x[n], ans[n], a = 0, b = 0, sum = 0, maxi = 0;
vector<pair<long long, int> > dp(n);
for (int i = 0; i < n; i++) {
scanf("%lld", &x[i]);
if (i >= k) {
maxi = max(maxi, sum);
dp[i - k].first = maxi;
if (i > k) {
if (dp[i - k].first > dp[i - k - 1].first)
dp[i - k].second = i - k + 1;
else
dp[i - k].second = dp[i - k - 1].second;
}
if (i == k) dp[i - k].second = 1;
ans[i - k] = sum;
sum -= x[i - k];
}
sum += x[i];
}
maxi = 0;
long long maxa = 0, maxb = 0;
ans[n - k] = sum;
for (int i = k; i <= n - k; i++) {
if (dp[i - k].first + ans[i] > maxi) {
maxi = dp[i - k].first + ans[i];
a = dp[i - k].second;
b = i + 1;
}
}
cout << a << " " << b;
}
|
#include <bits/stdc++.h>
using namespace std;
long long v[200005];
int pmelhor[200005];
long long vmelhor[200005];
int main() {
int n, k;
scanf("%d %d", &n, &k);
int a = 1, b = k + 1;
long long vans = 0LL;
int p = 1;
long long val = 0LL;
for (int i = 1; i <= n; i++) {
scanf("%I64d", &v[i]);
v[i] += v[i - 1];
if (i >= k && v[i] - v[i - k] > val) {
val = v[i] - v[i - k];
p = i - k + 1;
}
pmelhor[i] = p;
vmelhor[i] = val;
if (i >= 2 * k && vmelhor[i - k] + v[i] - v[i - k] > vans) {
vans = vmelhor[i - k] + v[i] - v[i - k];
a = pmelhor[i - k];
b = i - k + 1;
}
}
printf("%d %d\n", a, b);
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k;
long long a[300000];
long long dp[300000] = {0};
long long p[300000] = {0};
long long an[300000] = {0};
int main() {
cin >> n >> k;
for (long long i = 1; i <= n; i++) cin >> a[i];
for (long long i = 1; i <= k; i++) dp[1] += a[i];
for (long long i = 2; i <= n - k + 1; i++)
dp[i] = dp[i - 1] - a[i - 1] + a[i + k - 1];
p[1] = dp[1];
an[1] = 1;
for (long long i = 2; i <= n - k + 1; i++)
if (dp[i] > p[i - 1]) {
p[i] = dp[i];
an[i] = i;
} else {
p[i] = p[i - 1];
an[i] = an[i - 1];
}
long long max = 0, ac = 0, bc = 0;
for (long long i = k + 1; i <= n - k + 1; i++)
if (max < dp[i] + p[i - k]) {
max = dp[i] + p[i - k];
ac = an[i - k];
bc = i;
}
cout << ac << ' ' << bc << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long x[1000005], a[1000005], b[1000005], c[1000005];
int main() {
long long n = 0, amax = 0, bmax = 0, line = 1, k;
cin >> n >> k;
int i, j;
for (i = 1; i <= n; i++) cin >> x[i];
long long sum = 0;
for (i = n - k; i > n - 2 * k; i--) {
sum += x[i];
}
a[n - 2 * k + 1] = sum;
for (i = n - 2 * k; i >= 1; i--) {
a[i] = x[i] + a[i + 1] - x[i + k];
}
sum = 0;
for (i = n; i > n - k; i--) {
sum += x[i];
}
b[n - k + 1] = sum;
for (i = n - k; i >= k + 1; i--) {
b[i] = x[i] + b[i + 1] - x[i + k];
}
long long bmx = 0;
for (i = n; i > n - k; i--) bmx += x[i];
b[n - k + 1] = bmx;
c[n - k + 1] = n - k + 1;
bmax = n - k + 1;
for (i = n - k; i >= k + 1; i--) {
if (bmx > b[i]) {
b[i] = bmx;
c[i] = bmax;
} else {
bmx = b[i];
bmax = i;
c[i] = bmax;
}
}
long long absmx = a[1] + b[k + 1];
amax = 1;
bmax = c[k + 1];
for (i = 2; i <= n - 2 * k + 1; i++) {
if (a[i] + b[i + k] > absmx) {
absmx = a[i] + b[i + k];
amax = i;
bmax = c[i + k];
}
}
cout << amax << " " << bmax;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 23;
const int MAXN = 2e5 + 100;
int arr[MAXN];
pair<long long, int> mxsuf[MAXN];
int main() {
ios_base::sync_with_stdio(0);
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; ++i) {
cin >> arr[i];
}
long long cur = 0;
for (int i = n, j = 0; j < k; --i, ++j) {
cur += arr[i];
}
mxsuf[n - k + 1] = {cur, n - k + 1};
for (int i = n - k; i >= 0; --i) {
cur -= arr[i + k];
cur += arr[i];
if (cur >= mxsuf[i + 1].first) {
mxsuf[i] = {cur, i};
} else {
mxsuf[i] = mxsuf[i + 1];
}
}
cur = 0;
for (int i = 1; i < k; ++i) {
cur += arr[i];
}
long long ans = 0;
pair<int, int> ansind = {0, 0};
for (int i = k; i <= n; ++i) {
cur += arr[i];
cur -= arr[i - k];
if (cur + mxsuf[i + 1].first > ans) {
ans = cur + mxsuf[i + 1].first;
ansind = {i - k + 1, mxsuf[i + 1].second};
}
}
cout << ansind.first << " " << ansind.second << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
long long int l[n + 1], r[n + 1], a[n + 1], k = 0, s = 0;
vector<long long int> v;
for (int i = 0; i < n; i++) {
cin >> a[i];
s += a[i];
k++;
if (k == m) {
v.push_back(s);
s -= a[i - m + 1];
k = m - 1;
}
}
for (int i = 0; i < v.size(); i++) {
if (i == 0)
l[i] = v[i];
else
l[i] = max(l[i - 1], v[i]);
}
for (int i = v.size() - 1; i >= 0; i--) {
if (i == v.size() - 1)
r[i] = v[i];
else
r[i] = max(r[i + 1], v[i]);
}
long long int ans = 0, st, e;
for (int i = 0; i < v.size() - m; i++) {
if (ans < (l[i] + r[i + m])) {
ans = l[i] + r[i + m];
st = l[i];
e = r[i + m];
}
}
int i = 0, x, y;
while (i < v.size() - m) {
if (v[i] == st) {
cout << i + 1 << " ";
x = i;
break;
}
i++;
}
i = v.size();
while (i >= m) {
if (v[i] == e && i >= x + m) y = i;
i--;
}
cout << y + 1;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool comparion(pair<long long int, long long int> a,
pair<long long int, long long int> b) {
if (a.first == b.first) return (a.second < b.second);
return (a.first > b.first);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n, k;
cin >> n >> k;
long long int a[n];
for (long long int i = 0; i < n; i++) {
cin >> a[i];
}
long long int b[n - k + 1];
long long int val = 0;
for (long long int i = n - 1; i >= 0; i--) {
val += a[i];
if (i <= (n - k)) {
b[i] = val;
val -= a[i + k - 1];
}
}
pair<long long int, long long int> m[n - (2 * k) + 1];
long long int max = b[0];
for (long long int i = k; i <= (n - k); i++) {
m[i - k] = (make_pair(b[i], i + 1));
}
sort(m, m + (n - (2 * k) + 1), comparion);
long long int q = 0;
max += m[0].first;
long long int x = 1, y = m[0].second;
for (long long int i = 1; i <= (n - (2 * k)); i++) {
while (m[q].second <= (i + k)) q++;
if (max < (b[i] + m[q].first)) {
max = (b[i] + m[q].first);
x = i + 1;
y = m[q].second;
}
}
cout << x << ' ' << y;
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b);
long long cross_prod(long long ax, long long ay, long long bx, long long by,
long long cx, long long cy);
long long sum_digit(long long A);
long long get_mask(long long x);
class SegmentTree {
public:
vector<int> V;
void init(int dim);
int query(int start, int end, int pos, int node);
void build(int start, int end, int node);
};
long long N, K;
vector<long long> V(200001);
vector<long long> M_left(200001);
int main() {
long long i, j, posM1, posM2, sum = 0, lg = 0, sum_aux = 0, sum_max = 0;
scanf("%I64d %I64d", &N, &K);
for (i = 1; i <= K; ++i) {
scanf("%I64d", &V[i]);
sum += V[i];
}
M_left[K] = sum;
for (i = K + 1; i <= N; ++i) {
scanf("%I64d", &V[i]);
sum = sum - V[i - K] + V[i];
M_left[i] = (M_left[i - 1] > sum ? M_left[i - 1] : sum);
}
sum = 0;
for (i = N; i > N - K; --i) {
sum += V[i];
}
sum_aux = sum + M_left[N - K];
if (sum_aux > sum_max) {
posM2 = N - K + 1;
sum_max = sum_aux;
}
for (i = N - K; i > K; --i) {
sum = sum + V[i] - V[i + K];
sum_aux = sum + M_left[i - 1];
if (sum_aux >= sum_max) {
sum_max = sum_aux;
posM2 = i;
}
}
for (i = posM2 - 2; i && M_left[i] == M_left[i + 1]; --i)
;
cout << (i + 1) - K + 1 << ' ' << posM2;
return 0;
}
long long gcd(long long a, long long b) { return (b ? gcd(b, a % b) : a); }
long long cross_prod(long long ax, long long ay, long long bx, long long by,
long long cx, long long cy) {
return (bx - ax) * (cy - ay) - (by - ay) * (cx - ax);
}
long long sum_digit(long long A) {
long long sum = 0;
do {
sum += A % 10;
A /= 10;
} while (A);
return sum;
}
long long get_mask(long long x) {
long long mask = 0, c;
while (x) {
c = x % 10;
x /= 10;
if (c == 4 || c == 7) {
mask = mask * 10 + c;
}
}
return mask;
}
void SegmentTree::init(int dim) { V.resize((dim + 1) << 2); }
void SegmentTree::build(int start, int end, int node) {
V[node] = end - start + 1;
if (start == end) {
return;
}
int mid;
mid = (start + end) >> 1;
build(start, mid, (node << 1));
build(mid + 1, end, ((node << 1) | 1));
}
int SegmentTree::query(int start, int end, int pos, int node) {
--V[node];
if (start == end) return end;
int L, R;
L = node << 1;
R = L | 1;
int mid;
mid = (start + end) >> 1;
if (pos <= V[L]) {
return query(start, mid, pos, L);
} else {
return query(mid + 1, end, pos - V[L], R);
}
}
|
#include <bits/stdc++.h>
using namespace std;
bool cmp(pair<int, int> a, pair<int, int> b) {
if (a.first == b.first) {
return a.second > b.second;
}
return a.first < b.first;
}
long long n, k, x[2 * 100005], sum[2 * 100005] = {0};
long long a, b, mx = 0, d, m1, m2;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> x[i];
sum[i] = sum[i - 1] + x[i];
}
vector<long long> rakh;
for (int i = k; i <= n; i++) {
rakh.push_back(sum[i] - sum[i - k]);
}
long long mx = 0, t, ans = 0;
for (int i = 0; i < rakh.size() - k; i++) {
if (rakh[i] > mx) {
mx = rakh[i];
t = i + 1;
}
if (mx + rakh[i + k] > ans) {
ans = mx + rakh[i + k];
a = t;
b = i + k + 1;
}
}
cout << a << ' ' << b << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
cin >> n >> k;
long long arr[n + 1], arr2[n + 1], arr3[n + 1], arr4[n + 2], arr5[n + 2];
for (long long i = 1; i <= n; ++i) {
cin >> arr[i];
arr2[i] = arr2[i - 1] + arr[i];
}
for (long long i = 1; i <= n; ++i) {
if (i + k - 1 > n) {
arr3[i] = 0;
continue;
}
arr3[i] = arr2[i + k - 1] - arr2[i - 1];
}
arr4[n + 1] = 0, arr5[n + 1] = n;
for (int i = n; i >= 1; --i) {
arr4[i] = arr4[i + 1];
arr5[i] = arr5[i + 1];
if (arr3[i] >= arr4[i]) arr4[i] = arr3[i], arr5[i] = i;
}
long long MAX = 0, x = 0, y = 0;
for (int i = 1; i <= n; ++i) {
if (arr3[i] == 0 || arr4[i + k] == 0) continue;
if (arr3[i] + arr4[i + k] > MAX)
MAX = arr3[i] + arr4[i + k], x = i, y = arr5[i + k];
}
cout << x << " " << y;
return 0;
}
|
#include <bits/stdc++.h>
int main(void) {
long long answer_a, answer_b, answer, n, k, i;
std::vector<long long> best_i, i_tseb, best, tseb, sum, x;
std::cin.tie(0);
std::ios_base::sync_with_stdio(0);
std::cin >> n >> k;
best_i.resize(n);
i_tseb.resize(n);
best.resize(n);
tseb.resize(n);
sum.resize(n);
x.resize(n);
for (i = 0; i < n; ++i) {
std::cin >> x[i];
}
sum[0] = 0;
for (i = 0; i < k; ++i) {
sum[0] += x[i];
}
best[k - 1] = sum[0];
best_i[k - 1] = 1;
for (i = 1; i <= n - k; ++i) {
sum[i] = sum[i - 1] - x[i - 1] + x[k + i - 1];
if (sum[i] > best[k + i - 2]) {
best[k + i - 1] = sum[i];
best_i[k + i - 1] = i + 1;
} else {
best[k + i - 1] = best[k + i - 2];
best_i[k + i - 1] = best_i[k + i - 2];
}
}
tseb[n - k] = sum[n - k];
i_tseb[n - k] = n - k + 1;
for (i = n - k - 1; i >= 0; --i) {
if (sum[i] >= tseb[i + 1]) {
tseb[i] = sum[i];
i_tseb[i] = i + 1;
} else {
tseb[i] = tseb[i + 1];
i_tseb[i] = i_tseb[i + 1];
}
}
answer = 0;
for (i = k - 1; i < n - k; ++i) {
if (best[i] + tseb[i + 1] > answer) {
answer_a = best_i[i];
answer_b = i_tseb[i + 1];
answer = best[i] + tseb[i + 1];
}
}
std::cout << answer_a << " " << answer_b << std::endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int const maxN = 2e5 + 20;
long long n, k, a[maxN], mx = -1, ans1 = -1, ans2 = -1, x;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k;
for (int i = (0); i < (n); i++) {
cin >> x;
a[max(0LL, i - k + 1)] += x;
a[i + 1] -= x;
}
for (int i = (1); i < (n - k + 1); i++) {
a[i] += a[i - 1];
}
for (int a1 = n - 2 * k, b1 = n - k; a1 >= 0; a1--) {
if (a[a1 + k] >= a[b1]) b1 = a1 + k;
if (a[a1] + a[b1] >= mx) {
mx = a[a1] + a[b1];
ans1 = a1 + 1;
ans2 = b1 + 1;
}
}
cerr << mx << endl;
return cout << ans1 << ' ' << ans2, 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int di[9] = {-1, 1, 0, 0, -1, -1, 1, 1, 0};
int dj[9] = {0, 0, -1, 1, 1, -1, -1, 1, 0};
pair<int, int> dij[9] = {make_pair(-1, 0), make_pair(1, 0), make_pair(0, -1),
make_pair(0, 1), make_pair(-1, -1), make_pair(-1, 1),
make_pair(1, -1), make_pair(1, 1), make_pair(0, 0)};
pair<int, int> operator+(const pair<int, int>& a, const pair<int, int>& b) {
return make_pair(a.first + b.first, a.second + b.second);
}
ostream& operator<<(ostream& stream, pair<long long, int> x) {
stream << x.first << " " << x.second;
return stream;
}
const int MAXN = 200010;
long long A[MAXN], S[MAXN];
priority_queue<pair<long long, int> > H;
int main() {
int n;
cin >> n;
int k;
cin >> k;
for (int i = 0; i < (n); ++i) {
cin >> S[i + 1];
S[i + 1] += S[i];
}
for (int i = 0; i < (n - k + 1); ++i) {
A[i] = S[i + k] - S[i];
H.push(make_pair(A[i], -i));
}
long long ans = 0;
pair<int, int> out;
for (int i = 0; i < (n - k - k + 1); ++i) {
while (-H.top().second - i < k) {
H.pop();
}
if (A[i] + H.top().first > ans) {
ans = A[i] + H.top().first;
out = make_pair(i + 1, 1 - H.top().second);
}
}
cout << (out) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int dx[] = {1, 0, -1, 0};
const int dy[] = {0, -1, 0, 1};
const double EPS = 1e-9;
struct State {
long long from;
long long sum;
State(long long from, long long sum) : from(from), sum(sum) {}
};
bool operator<(const State &left, const State &right) {
if (left.sum == right.sum) {
return left.from > right.from;
}
return left.sum < right.sum;
}
bool operator>(const State &left, const State &right) {
if (left.sum == right.sum) {
return left.from < right.from;
}
return left.sum > right.sum;
}
int main() {
long long n, k;
cin >> n >> k;
vector<long long> X(n);
for (int i = 0; i < n; i++) {
cin >> X[i];
}
vector<long long> sums(n - k + 1);
for (int i = 0; i < k; i++) {
sums[0] += X[i];
}
for (int i = 1; i < sums.size(); i++) {
sums[i] = sums[i - 1] - X[i - 1] + X[i + k - 1];
}
priority_queue<State> que;
for (int i = 0; i < sums.size(); i++) {
que.push(State(i, sums[i]));
}
long long ret = -1;
long long reta = -1;
long long retb = -1;
for (int na = 0; na < sums.size(); na++) {
while (not que.empty()) {
int nb = que.top().from;
if (nb <= na + k - 1) {
que.pop();
continue;
} else if (que.top().sum + sums[na] > ret) {
reta = na;
retb = nb;
ret = que.top().sum + sums[na];
break;
} else {
break;
}
}
}
cout << reta + 1 << " " << retb + 1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
long long arr[n + 2];
arr[0] = 0;
for (int i = 1; i <= n; ++i) {
cin >> arr[i];
arr[i] += arr[i - 1];
}
long long a, b, ma = -1, mb = -1, ina, inb;
for (int i = 2 * k; i <= n; ++i) {
long long c = arr[i - k] - arr[i - 2 * k];
long long d = arr[i] - arr[i - k];
if (c > ma) {
ma = c;
a = i - 2 * k + 1;
}
if (ma + d > mb) {
mb = ma + d;
ina = a;
inb = i - k + 1;
}
}
cout << ina << " " << inb << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 222222;
long long dp[MAXN][2];
int a[MAXN], p[MAXN];
long long sum[MAXN], mm[MAXN];
int main() {
int n, k;
while (scanf("%d %d", &n, &k) != EOF) {
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
sum[0] = 0;
mm[0] = 0;
for (int i = 1; i <= n; i++) {
sum[i] = sum[i - 1] + a[i];
if (sum[i] - sum[i - k] > mm[i - 1]) {
mm[i] = sum[i] - sum[i - k];
p[i] = i;
} else {
mm[i] = mm[i - 1];
p[i] = p[i - 1];
}
}
int m1 = -0x3F3F3F3F, p1 = -1, m2 = -0x3F3F3F3F, p2 = -1;
long long ans = -1000;
int pp1 = 0, pp2 = 0;
for (int i = k; i <= n; i++) {
long long v = sum[i] - sum[i - k] + mm[i - k];
if (v > ans) {
ans = v;
pp1 = p[i - k];
pp2 = i;
}
}
printf("%d %d\n", pp1 - k + 1, pp2 - k + 1);
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k, a[200050], mx, ans, l, r, z;
vector<long long> v;
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i], a[i] += a[i - 1];
for (int i = k; i <= n; i++) v.push_back(a[i] - a[i - k]);
for (int i = k, j = 0; i < v.size(); i++, j++) {
if (v[j] > mx) mx = v[j], z = j;
if (ans < mx + v[i]) ans = mx + v[i], l = z, r = i;
}
cout << l + 1 << " " << r + 1;
}
|
#include <bits/stdc++.h>
const long long N = 1e6 + 7;
const long double eps = 1e-8;
const long long md = 1e9 + 9;
const long long inf = 2e18 + 34;
using namespace std;
long long n, m, k, p, t, h, mn, num, sum, sm, n2, n1;
long long a[N], b[N], c[N];
string s, s1, s2;
bool u[N];
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
b[0] = a[0];
for (int i = 1; i < n; i++) b[i] = b[i - 1] + a[i];
c[0] = b[k - 1];
for (int i = 1; i < n - k + 1; i++) c[i] = c[i - 1] - a[i - 1] + a[i + k - 1];
sm = c[0] + c[k];
num = 0;
n2 = k;
mn = c[0];
for (int i = 1; i < n - 2 * k + 1; i++) {
if (c[i] > c[num]) {
mn = c[i];
num = i;
}
if (c[i + k] + c[num] > sm) {
n1 = num;
n2 = i + k;
sm = c[i + k] + c[num];
}
}
cout << n1 + 1 << " " << n2 + 1 << "\n";
return 0;
}
|
#include <bits/stdc++.h>
long long k_sum[200010];
long long seg_tree[200010 * 4 + 1];
long long identity = (long long)-1e9;
long long max(long long a, long long b) { return a > b ? a : b; }
void build_tree(long long idx, long long l, long long r) {
if (l == r) {
seg_tree[idx] = k_sum[l];
return;
}
long long mid = (l + r) / 2;
build_tree(idx * 2, l, mid);
build_tree(idx * 2 + 1, mid + 1, r);
seg_tree[idx] = max(seg_tree[idx * 2], seg_tree[idx * 2 + 1]);
}
long long query_tree(long long idx, long long l, long long r, long long i,
long long j) {
if (l >= i && r <= j) return seg_tree[idx];
long long res = identity;
long long mid = (l + r) / 2;
if (mid >= i && j >= l) res = max(res, query_tree(idx * 2, l, mid, i, j));
if (r >= i && j >= mid + 1)
res = max(res, query_tree(idx * 2 + 1, mid + 1, r, i, j));
return res;
}
int main(void) {
long long n, k;
scanf("%lld %lld", &n, &k);
long long A[n + 1];
for (long long i = 0; i < n; i++) scanf("%lld", &A[i]);
k_sum[0] = 0;
for (long long i = 0; i < k; i++) k_sum[0] += A[i];
for (long long i = 1; i <= n - k; i++)
k_sum[i] = k_sum[i - 1] + A[i + k - 1] - A[i - 1];
build_tree(1, 0, n - k);
long long a, sum = 0, maxB;
for (long long i = 0; i <= n - 2 * k; i++) {
long long t = query_tree(1, 0, n - k, i + k, n - k);
if (sum < t + k_sum[i]) {
sum = t + k_sum[i];
maxB = t;
a = i;
}
}
long long b = -1;
for (long long i = a + k; i <= n - k; i++)
if (k_sum[i] == maxB) {
b = i;
break;
}
printf("%lld %lld\n", a + 1, b + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
long long a[2 * 200010], sum[2 * 200010], ans = 0;
int dp1[2 * 200010], dp2[2 * 200010], x, y;
char s[2200];
void init() {
memset(sum, 0, sizeof(sum));
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%I64D", &a[i]);
a[i] = a[i] + a[i - 1];
}
for (int i = 1; i <= n - m + 1; i++) sum[i] = a[i + m - 1] - a[i - 1];
dp1[m] = 1;
for (int i = m + 1; i <= n - m + 1; i++) {
if (sum[i - m + 1] > sum[dp1[i - 1]])
dp1[i] = i - m + 1;
else
dp1[i] = dp1[i - 1];
}
dp2[n - m] = n - m + 1;
for (int i = n - m - 1; i >= m; i--) {
if (sum[i + 1] >= sum[dp2[i + 1]])
dp2[i] = i + 1;
else
dp2[i] = dp2[i + 1];
}
for (int i = m; i <= n - m + 1; i++) {
long long yy = sum[dp1[i]] + sum[dp2[i]];
if (yy > ans) {
ans = yy;
x = dp1[i];
y = dp2[i];
}
}
printf("%d %d\n", x, y);
}
int main() {
init();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
long long num[200100], sum[200100];
long long dp[200100][2];
int main() {
ios::sync_with_stdio(false);
cin >> n >> k;
sum[0] = 0;
for (int i = 1; i <= n; i++) {
cin >> num[i];
sum[i] = sum[i - 1] + num[i];
}
memset(dp, 0, sizeof(dp));
for (int i = n - k + 1; i >= 0; i--) {
long long tmp = sum[i + k - 1] - sum[i - 1];
if (tmp >= dp[i + 1][1]) {
dp[i][1] = tmp;
dp[i][0] = i;
} else {
dp[i][1] = dp[i + 1][1];
dp[i][0] = dp[i + 1][0];
}
}
long long ans = 0, a = -1, b = -1;
for (int i = 1; i + k + k - 1 <= n; i++) {
long long now = sum[i + k - 1] - sum[i - 1];
if (now + dp[i + k][1] > ans) {
ans = now + dp[i + k][1];
a = i, b = dp[i + k][0];
}
}
cout << a << " " << b << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
long long a[N], n, k, maxn[N][32], ai[N][32], sum[N];
long long xb[N];
void st() {
for (int i = 1; i <= n - k + 1; i++) {
maxn[i][0] = xb[i];
ai[i][0] = i;
}
for (int i = 1; (1 << i) <= n - k + 1; i++) {
for (int j = 1; j + (1 << i) - 1 <= n - k + 1; j++) {
if (maxn[j][i - 1] >= maxn[j + (1 << (i - 1))][i - 1]) {
maxn[j][i] = maxn[j][i - 1];
ai[j][i] = ai[j][i - 1];
} else {
maxn[j][i] = maxn[j + (1 << (i - 1))][i - 1];
ai[j][i] = ai[j + (1 << (i - 1))][i - 1];
}
}
}
}
inline pair<long long, long long> work(int l, int r) {
int k = log2(r - l + 1);
long long f, s;
if (maxn[l][k] >= maxn[r - (1 << k) + 1][k]) {
f = maxn[l][k];
s = ai[l][k];
} else {
f = maxn[r - (1 << k) + 1][k];
s = ai[r - (1 << k) + 1][k];
}
return {f, s};
}
int main() {
ios::sync_with_stdio(0), cin.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
sum[i] = sum[i - 1] + a[i];
}
for (int i = 1; i <= n - k + 1; i++) xb[i] = sum[i + k - 1] - sum[i - 1];
long long ansa, ansb, tot = -1;
st();
for (int i = 1; i <= n - 2 * k + 1; i++) {
pair<long long, long long> pp = work(i + k, n - k + 1);
if (pp.first + xb[i] > tot) {
tot = pp.first + xb[i];
ansa = i;
ansb = pp.second;
}
}
cout << ansa << " " << ansb << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
int x[300005];
long long a[300005];
long long sum;
long long ans;
int bsum1;
int p1, p2;
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) scanf("%d", &x[i]);
for (int i = 0; i < k; i++) sum += x[i];
a[0] = sum;
for (int i = 1; i <= n - k; i++) {
sum -= x[i - 1];
sum += x[i + k - 1];
a[i] = max(a[i - 1], sum);
}
sum = 0;
for (int i = k; i < 2 * k; i++) sum += x[i];
for (int i = k; i <= n - k; i++) {
if (sum + a[i - k] > ans) {
p2 = i;
ans = sum + a[i - k];
}
sum -= x[i];
sum += x[i + k];
}
sum = 0;
for (int i = 0; i < k; i++) sum += x[i];
for (int i = 0; i <= n; i++) {
if (sum == a[p2 - k]) {
cout << i + 1 << " " << p2 + 1;
return 0;
}
sum -= x[i];
sum += x[i + k];
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int a[200005];
long long int b[200005];
int main() {
long long int n, k;
cin >> n >> k;
for (long long int i = 1; i <= n; i++) {
cin >> a[i];
}
for (long long int i = 1; i <= n; i++) {
b[i] = b[i - 1] + a[i];
}
long long int cur_mx = 0;
long long int ind1 = 0;
long long int ind2 = 0;
long long int ind3 = 0;
long long int ans = 0;
long long int current = 0;
for (long long int i = n - 2 * k + 1; i >= 1; --i) {
if (b[i + 2 * k - 1] - b[i + k - 1] >= cur_mx) {
cur_mx = b[i + 2 * k - 1] - b[i + k - 1];
ind2 = i + k;
}
current = b[i + k - 1] - b[i - 1];
if (ans <= current + cur_mx) {
ans = current + cur_mx;
ind1 = i;
ind3 = ind2;
}
}
cout << ind1 << " " << ind3 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, af, bf;
int arr[200000 + 10];
long long acu[200000 + 10];
long long num[200000 + 10], res;
struct par {
long long v;
int pos;
bool operator<(par other) const {
if (v == other.v) return pos > other.pos;
return v < other.v;
}
} st[800000 + 10], a, b;
par pregunta(int a, int b, int x, int y, int v) {
if (a == x && b == y)
return st[v];
else {
int m = (a + b) / 2;
if (y <= m) return pregunta(a, m, x, y, 2 * v);
if (x > m) return pregunta(m + 1, b, x, y, 2 * v + 1);
return max(pregunta(a, m, x, m, 2 * v),
pregunta(m + 1, b, m + 1, y, 2 * v + 1));
}
}
void crea(int a, int b, int v) {
if (a == b) {
st[v].v = num[a];
st[v].pos = a;
} else {
int m = (a + b) / 2;
crea(a, m, 2 * v);
crea(m + 1, b, 2 * v + 1);
st[v] = max(st[2 * v], st[2 * v + 1]);
}
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%d", &arr[i]);
acu[i] = acu[i - 1] + arr[i];
}
for (int i = k; i <= n; i++) num[i] = acu[i] - acu[i - k];
crea(1, n, 1);
for (int i = 1; i <= n; i++) {
if (i <= n - k) a = pregunta(1, n, i + k, n, 1);
if (i > k) b = pregunta(1, n, 1, i - k, 1);
if (num[i] + max(a.v, b.v) > res) {
res = num[i] + max(a.v, b.v);
af = i;
if (a.v == b.v)
bf = min(a.pos, b.pos);
else if (a.v > b.v)
bf = a.pos;
else
bf = b.pos;
}
a.pos = a.v = b.v = b.pos = 0;
}
for (int i = 1; i <= n; i++) {
if (i == af || i == bf) {
printf("%d ", i - k + 1);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const long long INF = 1e18;
const double PI = acos(-1.0);
const int maxn = (int)5e5 + 13;
long long pref[maxn];
long long get(int l, int r) { return pref[r] - (l == 0 ? 0 : pref[l - 1]); }
void solve() {
int n, k;
cin >> n >> k;
for (int i = 0; i < (int)n; ++i) {
long long x;
cin >> x;
pref[i] = (i == 0 ? 0 : pref[i - 1]) + x;
}
pair<int, int> ans{-1, -1};
long long mx = 0, rightmx = 0, rightind = -1;
for (int i = n - 2 * k; i >= 0; --i) {
if (get(i + k, i + 2 * k - 1) >= rightmx) {
rightmx = get(i + k, i + 2 * k - 1);
rightind = i + k;
}
if (get(i, i + k - 1) + rightmx >= mx) {
mx = get(i, i + k - 1) + rightmx;
ans.first = i;
ans.second = rightind;
}
}
cout << ans.first + 1 << " " << ans.second + 1;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, mm, k, ans, t;
long long a[300005], sum[300005];
long long f[300005][64];
long long maxx(long long x1, long long x2) { return x1 < x2 ? x2 : x1; }
void init() {
int i, j;
mm = n - k + 1;
for (i = 1; i <= mm; i++) {
f[i][0] = sum[i];
}
for (j = 1; (1 << j) <= mm; j++) {
for (i = 1; i + j - 1 <= mm; i++) {
f[i][j] = maxx(f[i][j - 1], f[i + (1 << (j - 1))][j - 1]);
}
}
}
long long query(int l, int r) {
int k = 0;
while (1 << (k + 1) <= r - l + 1) k++;
return maxx(f[l][k], f[r - (1 << k) + 1][k]);
}
int main() {
int i, j, s, e;
long long ma, tmp;
scanf("%d%d", &n, &k);
sum[1] = 0;
for (i = 1; i <= n; i++) {
scanf("%I64d", &a[i]);
if (i <= k) sum[1] += a[i];
}
for (i = 2; i <= n - k + 1; i++) {
sum[i] = sum[i - 1] - a[i - 1] + a[i + k - 1];
}
init();
m = n - 2 * k + 1;
ma = -1;
for (i = 1; i <= m; i++) {
tmp = sum[i] + query(i + k, n - k + 1);
if (tmp > ma) {
s = i;
ma = tmp;
}
}
tmp = ma - sum[s];
for (i = s + k; i <= n - k + 1; i++) {
if (sum[i] == tmp) {
e = i;
break;
}
}
printf("%d %d\n", s, e);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200010;
const int MOD = 1000000007;
const int INF = 0x3fffffff;
typedef struct Node {
long long v;
int p;
Node(long long v_, int p_) {
v = v_;
p = p_;
}
bool operator<(const Node& other) const {
return v < other.v || (v == other.v && p > other.p);
}
} Node;
long long a[N];
int main() {
ios::sync_with_stdio(false);
int n, k;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i) {
scanf("%I64d", &a[i]);
a[i] += a[i - 1];
}
priority_queue<Node> Q;
Q.push(Node(a[n] - a[n - k], n + 1 - k));
long long ans = 0;
int ansa, ansb;
int q = n + 1 - k;
for (int i = n + 1 - k - k; i > 0; --i) {
if (ans <= Q.top().v + a[i + k - 1] - a[i - 1]) {
ans = Q.top().v + a[i + k - 1] - a[i - 1];
ansa = i;
ansb = Q.top().p;
}
--q;
Q.push(Node(a[q + k - 1] - a[q - 1], q));
}
printf("%d %d\n", ansa, ansb);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = (int)1e9 + 7;
const int N = (int)2e5 + 5;
struct trio {
long long a;
long long b;
long long c;
};
trio dp[2][N];
long long ps[N];
int main() {
cout.precision(15);
cout.setf(ios::fixed);
int n, k;
int i;
cin >> n >> k;
vector<int> v(n);
for (i = 0; i < n; i++) {
cin >> v[i];
if (i == 0)
ps[i] = v[i];
else
ps[i] = ps[i - 1] + v[i];
}
long long ma = 0, p1, p2;
for (i = k - 1; i < n; i++) {
dp[0][i].a = ps[i] - (i >= k ? ps[i - k] : 0);
dp[0][i].b = i;
if (i >= k)
if (dp[0][i - 1].a >= dp[0][i].a) {
dp[0][i].a = dp[0][i - 1].a;
dp[0][i].b = dp[0][i - 1].b;
}
if (i >= (2 * k - 1)) {
dp[1][i].a = dp[0][i - k].a + ps[i] - (i >= k ? ps[i - k] : 0);
dp[1][i].b = dp[0][i - k].b;
}
if (dp[1][i].a > ma) {
ma = dp[1][i].a;
p1 = dp[1][i].b;
p2 = i;
}
}
cout << p1 + 2 - k << ' ' << p2 + 2 - k << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
long long mas[200004];
long long mas2[200004];
struct ver {
long long abs;
int number;
long long maxabs;
int masnumber;
ver *l;
ver *r;
};
void build(ver *v, int l, int r, long long *m) {
if (l == r) {
v->abs = m[l];
v->number = l;
v->masnumber = l;
v->maxabs = m[l];
} else {
ver *a = new ver;
ver *b = new ver;
v->l = a;
v->r = b;
build(a, l, (l + r) / 2, m);
build(b, (l + r) / 2 + 1, r, m);
if (a->maxabs < b->maxabs) {
v->maxabs = b->maxabs;
v->masnumber = b->masnumber;
} else {
v->maxabs = a->maxabs;
v->masnumber = a->masnumber;
}
}
}
pair<long long, long long> maxver(ver *v, int l, int r, int zl, int zr) {
pair<long long, long long> answer;
answer.first = -100000;
answer.second = 0;
if (l > zr || r < zl)
return answer;
else {
if (zl <= l && r <= zr) {
answer.first = v->maxabs;
answer.second = v->masnumber;
return answer;
} else {
pair<long long, long long> left;
pair<long long, long long> right;
left = maxver(v->l, l, (l + r) / 2, zl, zr);
right = maxver(v->r, (l + r) / 2 + 1, r, zl, zr);
if (left.first < right.first)
return right;
else
return left;
}
}
}
int main() {
ver *root = new ver;
int n, k;
pair<long long, long long> answer;
long long maxans = 0;
answer.first = 0;
answer.second = 0;
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> mas[i];
for (int i = 0; i < 200004; i++) mas2[i] = 0;
for (int i = n - k + 1; i <= n; i++) mas2[n - k + 1] += mas[i];
for (int i = n - k; i >= 1; i--) mas2[i] = mas2[i + 1] + mas[i] - mas[i + k];
build(root, 1, n, mas2);
for (int i = 1; i <= n - 2 * k + 1; i++) {
pair<long long, long long> an = maxver(root, 1, n, i + k, n);
if (an.first + mas2[i] > maxans) {
maxans = an.first + mas2[i];
answer.first = i;
answer.second = an.second;
}
}
cout << answer.first << " " << answer.second;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int i, n, l, f[2 * 101010];
long long sum[2 * 101010];
int main() {
scanf("%d %d", &n, &l);
for (i = 1; i <= n; i++) scanf("%d", f + i);
for (i = 1; i <= n; i++) sum[i] = f[i] + sum[i - 1];
long long mx = 0, res = 0;
int num1 = 0, num2 = 0, k = 0;
for (i = l + 1; i <= n - l + 1; i++) {
if (mx < sum[i - 1] - sum[i - l - 1])
mx = sum[i - 1] - sum[i - l - 1], k = i - l;
if (mx + sum[i + l - 1] - sum[i - 1] > res)
res = mx + sum[i + l - 1] - sum[i - 1], num1 = k, num2 = i;
}
printf("%d %d\n", num1, num2);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int size = 1004;
const long long modulo = 1000000007;
int k = 0;
void banzai(vector<int>& a, int l, int r) {
if (l == r) {
int left = 0, right = 0;
for (int i = 1; i <= r; i++)
for (int j = 0; j < i; j++)
if (a[j] > a[i]) ++left;
for (int i = r - 1; i >= 0; i--)
for (int j = i + 1; j <= r; j++)
if (a[j] > a[i]) ++right;
if (left == right) {
++k;
}
} else {
for (int i = l; i <= r; i++) {
swap(a[l], a[i]);
banzai(a, l + 1, r);
swap(a[l], a[i]);
}
}
}
int main() {
int n, k;
cin >> n >> k;
vector<long long> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
vector<long long> b(1, 0);
for (int i = 0; i < k; i++) b[0] += a[i];
for (int i = k; i < n; i++) b.push_back(b[i - k] + a[i] - a[i - k]);
vector<long long> c(b.size());
c.back() = b.back();
for (int i = c.size() - 2; i >= 0; i--) c[i] = max(c[i + 1], b[i]);
long long aa = 0, r = 0;
for (int i = 0; i < b.size() - k; i++)
if (b[i] + c[i + k] > r) {
aa = i;
r = b[i] + c[i + k];
}
long long d = 0;
for (int i = aa + k; i < b.size(); i++)
if (b[i] == r - b[aa]) {
d = i + 1;
break;
}
aa++;
cout << aa << ' ' << d << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
long long a[200005], p[200005] = {0}, x[200005] = {0}, mx[200005] = {0},
pos[200005] = {0};
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> a[i];
p[i] = p[i - 1] + a[i];
}
int m = n - k + 1;
for (int i = 0; i <= n - k + 1; i++) {
x[i] = p[i + k - 1] - p[i - 1];
}
for (int i = m; i >= 0; i--) {
if (mx[i + 1] > x[i]) {
mx[i] = mx[i + 1];
pos[i] = pos[i + 1];
} else {
mx[i] = x[i];
pos[i] = i;
}
}
long long tmp = -1;
int pa, pb;
for (int i = 0; i <= m; i++) {
if (x[i] + mx[i + k] > tmp) {
tmp = x[i] + mx[i + k];
pa = i;
pb = pos[i + k];
}
}
cout << pa + 1 << " " << pb + 1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<ll, ll>;
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ")";
}
string to_string(const string& s) { return '"' + s + '"'; }
string to_string(bool b) { return (b ? "true" : "false"); }
string to_string(char c) { return to_string(string(1, c)); }
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto& a : v) {
if (!first) res += ", ";
first = false;
res += to_string(a);
}
res += "}";
return res;
}
void debug_out() { cerr << endl; }
template <typename A, typename... B>
void debug_out(A a, B... b) {
cerr << to_string(a);
if (sizeof...(b)) cerr << ", ";
debug_out(b...);
}
int main() {
cin.tie(0);
cin.exceptions(cin.failbit);
ios_base::sync_with_stdio(0);
int n, k;
cin >> n >> k;
vector<ll> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
vector<ll> sum(n);
ll csum = 0;
for (int i = 0; i < k; i++) {
csum += a[i];
}
sum[0] = csum;
for (int i = k; i < n; i++) {
csum += a[i];
csum -= a[i - k];
sum[i - k + 1] = csum;
}
vector<pii> suff(n + 1);
suff[n - 1] = {n - 1, sum[n - 1]};
for (int i = n - 2; i >= 0; i--) {
suff[i] = suff[i + 1];
if (sum[i] >= suff[i].second) suff[i] = {i, sum[i]};
}
42;
42;
ll ans = 0, ai = -1, bi = -1;
for (int i = 0; i < n - k; i++) {
ll cans = sum[i] + suff[i + k].second;
if (cans > ans) {
ai = i, bi = suff[i + k].first;
ans = cans;
}
}
assert(ai != -1);
42;
cout << ai + 1 << " " << bi + 1 << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x7fffffff;
const int MAXN = 200000 + 10;
int num[MAXN];
long long sum[MAXN], sumK[MAXN];
int k, n;
typedef struct Node {
int start, end;
long long sumKK;
} Node;
Node tree[4 * MAXN];
long long max(long long x, long long y) { return x > y ? x : y; }
void build(int now, int s, int e) {
tree[now].start = s;
tree[now].end = e;
int mid = (e - s) >> 1;
if (e == s)
tree[now].sumKK = sumK[s];
else {
build(now * 2 + 1, s, (s + e) >> 1);
build(now * 2 + 2, ((s + e) >> 1) + 1, e);
tree[now].sumKK = max(tree[now * 2 + 1].sumKK, tree[now * 2 + 2].sumKK);
}
}
long long query(int now, int s, int e) {
int start = tree[now].start, end = tree[now].end;
int mid = (start + end) >> 1;
if (start == s && end == e) return tree[now].sumKK;
if (e <= mid)
return query(now * 2 + 1, s, e);
else if (s > mid)
return query(now * 2 + 2, s, e);
else
return max(query(now * 2 + 1, s, mid), query(now * 2 + 2, mid + 1, e));
}
int main() {
n = 0;
k = 0;
scanf("%d%d", &n, &k);
sum[0] = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &num[i]);
sum[i] += (sum[i - 1] + num[i]);
}
for (int i = 1; i <= n - k + 1; i++) sumK[i] = sum[i + k - 1] - sum[i - 1];
build(0, 1, n - k + 1);
long long ans = 0;
long long ansTmp = 0;
int index = 0;
for (int i = 1; i <= n - k + 1 - k; i++) {
long long x = sumK[i];
long long tmp = 0;
tmp = x + query(0, i + k, n - k + 1);
if (tmp > ans) {
ans = tmp;
index = i;
ansTmp = x;
}
}
int index2 = 0;
for (int i = index + k; i <= n - k + 1; i++) {
if (sum[i + k - 1] - sum[i - 1] == ans - ansTmp) {
index2 = i;
break;
}
}
printf("%d %d\n", index, index2);
return 0;
}
|
#include <bits/stdc++.h>
const long long INF = 1e18;
const long long N = 1e6 + 5;
const long long MOD = 1e9 + 7;
using namespace std;
long long POWER(long long base, long long expo) {
long long ret = 1;
while (expo) {
if (expo & 1) ret = ret * base;
expo >>= 1;
base = base * base;
}
return ret;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long test_case = 1;
while (test_case--) {
long long n, k;
cin >> n >> k;
long long a[n + 1];
for (long long i = 1; i <= n; i++) cin >> a[i];
multiset<pair<long long, long long>, greater<pair<long long, long long> > >
s;
multiset<pair<long long, long long>,
greater<pair<long long, long long> > >::iterator it;
vector<long long> pre(n + 1, 0);
long long sum = 0;
for (long long i = 1; i <= n; i++) {
sum += a[i];
if (i < k) continue;
if (i == k)
pre[i - k + 1] = sum;
else {
sum -= a[i - k];
pre[i - k + 1] = sum;
}
}
for (long long i = k + 1; i <= n - k + 1; i++) s.insert({pre[i], -i});
long long x, y, ans = -INF;
for (long long i = 1; i <= n - (2 * k) + 1; i++) {
pair<long long, long long> p = *s.begin();
if (pre[i] + p.first > ans) {
ans = pre[i] + p.first;
x = i;
y = (-1) * p.second;
}
s.erase({pre[i + k], (-1) * (i + k)});
}
cout << x << " " << y;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int H = 18;
int P[200001];
pair<long long int, int> T[1 << (H + 1)];
long long int S[200001];
vector<long long int> A;
void Ustaw(int x, long long int w) {
int y = x;
x += 1 << H;
T[x].first = w;
T[x].second = y;
x >>= 1;
while (x) {
if (T[x << 1].first >= T[(x << 1) + 1].first) {
T[x] = T[x << 1];
} else {
T[x] = T[(x << 1) + 1];
}
x >>= 1;
}
}
pair<long long int, int> Znajdz(int x, int y) {
x += 1 << H;
y += 1 << H;
pair<long long int, int> w(0, 0);
while (x < y) {
if (x & 1) {
if (T[x].first > w.first ||
(T[x].first == w.first && T[x].second < w.second)) {
w = T[x];
}
x++;
}
if (!(y & 1)) {
if (T[y].first > w.first ||
(T[y].first == w.first && T[y].second < w.second)) {
w = T[y];
}
y--;
}
x >>= 1;
y >>= 1;
}
if (x == y) {
if (T[x].first > w.first) {
w = T[x];
}
}
return w;
}
int main() {
int k, mx, my, n;
long long int mw, w;
pair<long long int, int> z;
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%d", P + i);
S[i] = S[i - 1] + P[i];
}
A.push_back(0);
for (int i = k; i <= n; i++) {
A.push_back(S[i] - S[i - k]);
Ustaw(i - k + 1, A.back());
}
mw = 0;
for (int i = 1; i < (int)A.size(); i++) {
z = Znajdz(i + k, n);
w = z.first + A[i];
if (w > mw) {
mw = w;
mx = i;
my = z.second;
}
}
printf("%d %d\n", mx, my);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int INF = 1e9;
int const N = 2e5 + 16;
int const M = 1e9 + 7;
int n, k;
int law[N];
long long p[N];
template <class t>
void sc(t &x) {
x = 0;
int c;
while (!('0' <= (c = getchar()) && c <= '9'))
;
x = c - '0';
while ('0' <= (c = getchar()) && c <= '9') x = (x << 1) + (x << 3) + c - '0';
}
int main() {
sc(n), sc(k);
for (int i = 1; i <= n; ++i) sc(law[i]);
for (int i = 1; i <= k; ++i) p[1] += law[i];
for (int i = 2; i <= n - k + 1; ++i)
p[i] = p[i - 1] - law[i - 1] + law[i - 1 + k];
int r = n - k + 1;
int l = r - k;
int a = l;
int b = r;
long long sum = p[a] + p[b];
while (--l) {
if (p[l + k] >= p[r]) r = l + k;
long long new_sum = p[l] + p[r];
if (new_sum >= sum) a = l, b = r, sum = new_sum;
}
printf("%d %d\n", a, b);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, dp1[222222];
pair<int, int> dp2[222222];
long long a[222222], sum[222222];
long long getsum(int a, int l) { return sum[a + l - 1] - sum[a - 1]; }
int main() {
cin >> n >> k;
for (int i = (1); i <= (n); ++i) scanf("%I64d", &a[i]);
for (int i = (1); i <= (n); ++i) sum[i] = sum[i - 1] + a[i];
dp1[k] = 1;
for (int i = (k + 1); i <= (n); ++i) {
dp1[i] = dp1[i - 1];
if (getsum(i - k + 1, k) > getsum(dp1[i], k)) dp1[i] = i - k + 1;
}
dp2[2 * k] = make_pair(1, k + 1);
for (int i = (2 * k + 1); i <= (n); ++i) {
dp2[i] = dp2[i - 1];
if (getsum(i - k + 1, k) + getsum(dp1[i - k], k) >
getsum(dp2[i].first, k) + getsum(dp2[i].second, k))
dp2[i] = make_pair(dp1[i - k], i - k + 1);
}
printf("%d %d\n", dp2[n].first, dp2[n].second);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pll = pair<ll, ll>;
using vll = vector<ll>;
using vpll = vector<pll>;
const ll MOD = 1e9 + 7, LIM = 1e6 + 5, INF = 1e18 + 5;
ll power(ll x, ll y, ll p) {
ll r = 1;
x %= p;
while (y > 0) {
if (y & 1) r = (r * x) % p;
y >>= 1;
x = (x * x) % p;
}
return r;
}
ll invmod(ll n, ll p) { return power(n, p - 2, p); }
bool comp(pll p1, pll p2) {
if (p1.second == p2.second) return (p1.first < p2.first);
return (p1.second < p2.second);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
ll tt = 1;
while (tt--) {
ll n, k;
cin >> n >> k;
ll x[n + 1];
for (ll i = 1; i <= n; i++) cin >> x[i];
ll suf_sum[n - k + 2];
for (ll i = 1; i <= n - k + 1; i++) {
if (i == 1) {
suf_sum[1] = 0;
for (ll j = 1; j <= k; j++) {
suf_sum[1] += x[j];
}
continue;
}
suf_sum[i] = suf_sum[i - 1] + x[i + k - 1] - x[i - 1];
}
ll max_suf_sum[n - k + 2];
for (ll i = n - k + 1; i >= k + 1; i--) {
if (i == n - k + 1) {
max_suf_sum[i] = suf_sum[i];
continue;
}
max_suf_sum[i] = max(suf_sum[i], max_suf_sum[i + 1]);
}
ll max_val = 0, a, b;
for (ll i = 1; i <= n - 2 * k + 1; i++) {
if (max_val < suf_sum[i] + max_suf_sum[i + k]) {
max_val = suf_sum[i] + max_suf_sum[i + k];
a = i;
}
}
for (ll i = a + k; i <= n - k + 1; i++) {
if (suf_sum[i] == max_val - suf_sum[a]) {
b = i;
break;
}
}
cout << a << " " << b;
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k, ans = 0, a, b;
vector<long long> v, sum, sumk;
vector<pair<long long, long long> > maxsumk, maxsum2k;
int main() {
cin >> n >> k;
v.resize(n);
for (int i = 0; i < n; i++) cin >> v[i];
sum.resize(n);
sumk.resize(n);
sum[0] = v[0];
for (int i = 1; i < n; i++) sum[i] = sum[i - 1] + v[i];
sumk[k - 1] = sum[k - 1];
for (int i = k; i < n; i++) sumk[i] = sum[i] - sum[i - k];
maxsumk.resize(n, {0, 0});
maxsumk[k - 1].first = sumk[k - 1];
maxsumk[k - 1].second = k - 1;
for (int i = k; i < n; i++) {
maxsumk[i].first = max(maxsumk[i - 1].first, sumk[i]);
if (max(maxsumk[i - 1].first, sumk[i]) == maxsumk[i - 1].first)
maxsumk[i].second = maxsumk[i - 1].second;
else
maxsumk[i].second = i;
}
maxsum2k.resize(n, {0, 0});
maxsum2k[2 * k - 1].first = sumk[2 * k - 1] + maxsumk[2 * k - 1 - k].first;
maxsum2k[2 * k - 1].second = 2 * k - 1;
for (int i = 2 * k; i < n; i++) {
maxsum2k[i].first =
max(sumk[i] + maxsumk[i - k].first, maxsum2k[i - 1].first);
if (max(sumk[i] + maxsumk[i - k].first, maxsum2k[i - 1].first) ==
maxsum2k[i - 1].first)
maxsum2k[i].second = maxsum2k[i - 1].second;
else
maxsum2k[i].second = i;
}
int v = maxsum2k[n - 1].second;
b = v - k + 2;
a = maxsumk[v - k].second - k + 2;
cout << a << " " << b;
}
|
#include <bits/stdc++.h>
using namespace std;
long long dpleft[200005], dpright[200005];
long long sum[200005], arr[200005], ans;
int n, k, i, a, b;
int indleft[200005], indright[200005];
int main() {
scanf("%d%d", &n, &k);
dpleft[0] = 0;
for (i = 1; i <= n; i++) {
scanf("%lld", &arr[i]);
sum[i] = sum[i - 1] + arr[i];
}
for (i = 0; i < k; i++) dpleft[i] = 0;
dpleft[k] = sum[k];
for (i = k + 1; i <= n; i++) dpleft[i] = sum[i] - sum[i - k];
for (i = n; i > n - k; i--) dpright[i] = 0;
dpright[n - k] = sum[n] - sum[n - k];
for (i = n - k - 1; i >= 0; i--) dpright[i] = sum[i + k] - sum[i];
ans = -1;
for (i = 0; i < k; i++) {
indleft[i] = i;
indright[n - i] = n - i;
}
for (i = k; i <= n - k; i++) {
if (dpleft[i] > dpleft[i - 1])
indleft[i] = i - k + 1;
else {
indleft[i] = indleft[i - 1];
dpleft[i] = dpleft[i - 1];
}
if (dpright[n - i] >= dpright[n - i + 1])
indright[n - i] = n - i + 1;
else {
indright[n - i] = indright[n - i + 1];
dpright[n - i] = dpright[n - i + 1];
}
}
for (i = k; i <= n - k; i++) {
if (ans < (dpleft[i] + dpright[i])) {
ans = dpleft[i] + dpright[i];
a = indleft[i];
b = indright[i];
}
}
printf("%d %d\n", a, b);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef priority_queue<pair<int, int>, vector<pair<int, int>>,
greater<pair<int, int>>>
rpqpi;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, k, a;
cin >> n >> k;
vector<long long> p(n + 1, 0);
for (int i = 0; i < n; ++i) {
cin >> a;
p[i + 1] = p[i] + a;
}
vector<long long> f(n + 1, -1);
vector<long long> s(n + 1, -1);
for (int i = k; i <= n; ++i) {
f[i] = max(p[i] - p[i - k], f[i - 1]);
}
for (int i = 2 * k; i <= n; ++i) {
s[i] = max(s[i - 1], p[i] - p[i - k] + f[i - k]);
}
int b = n;
for (int i = n - 1; i >= 0; --i) {
if (s[i] == s[n]) b = i;
}
a = b - k;
for (int i = a - 1; i >= 0; --i) {
if (f[i] == f[a]) a = i;
}
cout << a - k + 1 << " " << b - k + 1 << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
queue<long long> q;
struct classcomp {
bool operator()(const pair<long long, long long> &a,
const pair<long long, long long> &b) {
if (a.first == b.first) return a.second > b.second;
return a.first < b.first;
}
};
set<pair<long long, long long>, classcomp> st;
long long arr[200005], sum[200005];
int main() {
int n, k, i, j;
cin >> n >> k;
for (i = 1; i < n + 1; i++) {
cin >> arr[i];
sum[i] = arr[i] + sum[i - 1];
}
long long sm = 0;
i = n;
for (j = 0; j < k; j++) {
q.push(arr[i]);
sm += arr[i];
i--;
}
st.insert(make_pair(sm, i + 1));
long long mx = -1, ansb, ansa;
while (i >= k) {
pair<long long, long long> top = *st.rbegin();
long long temp = sum[i] - sum[i - k] + top.first;
if (temp > mx) {
ansb = top.second;
ansa = i - k;
mx = temp;
} else if (temp == mx) {
if (ansa > i - k) {
ansa = i - k;
ansb = top.second;
} else if (ansa == i - k) {
ansb = min(ansb, top.second);
}
}
sm -= q.front();
sm += arr[i];
q.pop();
q.push(arr[i]);
st.insert(make_pair(sm, i));
i--;
}
cout << ansa + 1 << " " << ansb;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, -1, 1};
const int N = 2 * 100010;
int n, k;
long long v[N];
long long pd[N][2];
short memo[N][2];
long long func(int x, int qtd) {
if (qtd == 2) return 0;
if (x + k > n + 1) return -0x3F3F3F3F3F3F3F3FLL;
if (memo[x][qtd]) return pd[x][qtd];
long long ret =
max(func(x + 1, qtd), v[x + k - 1] - v[x - 1] + func(x + k, qtd + 1));
memo[x][qtd] = 1;
return pd[x][qtd] = ret;
}
void solve(int x, int qtd) {
if (qtd == 2) return;
if (x + k > n + 1) return;
if (pd[x][qtd] == v[x + k - 1] - v[x - 1] + func(x + k, qtd + 1)) {
cout << x << " ";
solve(x + k, qtd + 1);
} else
solve(x + 1, qtd);
}
int main() {
ios::sync_with_stdio(0);
cin >> n >> k;
for (int i = 1; i <= n; ++i) {
cin >> v[i];
v[i] += v[i - 1];
}
memset(memo, 0, sizeof memo);
func(1, 0);
solve(1, 0);
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const double EPS = (1e-10);
const long long mod = (1e9) + 7;
int n, k;
long long int sum[200005];
vector<long long int> num(200005);
long long int dp[200005][3];
long long int rem[200005][3];
long long int solve(int index, int left) {
if (index > n || left <= 0) return 0;
if (dp[index][left] != -1) return dp[index][left];
long long int c1 = solve(index + k, left - 1) + sum[index] - sum[index - k];
long long int c2 = solve(index + 1, left);
if (c1 >= c2) {
rem[index][left] = 1;
return dp[index][left] = c1;
}
return dp[index][left] = c2;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> num[i + 1];
sum[i + 1] = num[i + 1] + sum[i];
}
memset(dp, -1, sizeof(dp));
long long int maxi = solve(k, 2);
int init = k, left = 2;
int ans[2];
while (left) {
if (rem[init][left]) {
init += k;
left--;
ans[left] = init - 2 * k;
} else {
init += 1;
}
}
cout << ans[1] + 1 << " " << ans[0] + 1;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int a[N];
long long sum[N];
long long dp[N][18];
int n, k;
void SparseTable() {
for (int i = 1; i <= n - k + 1; ++i) {
dp[i][0] = sum[i];
}
for (int j = 1; (1 << j) <= n - k + 1; ++j) {
for (int i = 1; i + (1 << j) - 1 <= n - k + 1; ++i) {
int tmp = i + (1 << (j - 1));
dp[i][j] = ((dp[i][j - 1]) > (dp[tmp][j - 1]) ? (dp[i][j - 1])
: (dp[tmp][j - 1]));
}
}
}
long long query(int s, int e) {
int k = (int)((log(e - s + 1)) / log(2.0));
long long ret =
((dp[s][k]) > (dp[e - (1 << k) + 1][k]) ? (dp[s][k])
: (dp[e - (1 << k) + 1][k]));
return ret;
}
int main() {
scanf("%d%d", &n, &k);
sum[1] = 0;
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (int i = 1; i <= k; ++i) sum[1] += a[i];
for (int i = 2; i <= n - k + 1; ++i) {
sum[i] = sum[i - 1] + a[i + k - 1] - a[i - 1];
}
SparseTable();
long long ans = 0, res;
int s, e, resi;
for (int i = 1; i <= n - (k << 1) + 1; ++i) {
long long tmp = query(i + k, n - k + 1);
if (sum[i] + tmp > ans) {
ans = sum[i] + tmp;
s = i;
res = tmp, resi = i;
}
}
for (int j = resi + k; j <= n - k + 1; ++j) {
if (sum[j] == res) {
e = j;
break;
}
}
printf("%d %d\n", s, e);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = (long long)(1e18);
const int maxn = 200010;
struct node {
long long sum;
int id;
node(long long s = 0, int i = -1) {
sum = s;
id = i;
}
bool operator>(const node& b) const {
if (sum == b.sum) return id < b.id;
return sum > b.sum;
}
bool operator<(const node& b) const {
if (sum == b.sum) return id > b.id;
return sum < b.sum;
}
} t[maxn << 2];
long long a[maxn], b[maxn];
int n, k;
void build(int v, int tl, int tr) {
if (tl == tr) {
t[v] = node(a[tl], tl);
} else {
int tm = (tl + tr) >> 1;
int next = v << 1;
build(next, tl, tm);
build(next + 1, tm + 1, tr);
t[v] = max(t[next], t[next + 1]);
}
}
node query(int v, int tl, int tr, int l, int r) {
if (l > tr || r < tl) return node(-INF, int(1e9));
if (l <= tl && tr <= r) return t[v];
int tm = (tl + tr) >> 1;
int next = v << 1;
node left_max = query(next, tl, tm, l, r);
node right_max = query(next + 1, tm + 1, tr, l, r);
return max(left_max, right_max);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> b[i];
if (i > 0) b[i] += b[i - 1];
a[i] = -INF;
}
for (int i = 0; i + k - 1 < n; i++) {
a[i] = b[i + k - 1];
if (i > 0) a[i] -= b[i - 1];
}
build(1, 0, n);
int aa, bb;
long long best = -INF;
for (int i = 0; i + k + k - 1 < n; i++) {
node m = query(1, 0, n, i + k, n);
long long curr = a[i] + m.sum;
if (curr > best) {
aa = i + 1;
bb = m.id + 1;
best = curr;
}
}
cout << aa << " " << bb << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
double PI = 3.1415926535897932384626;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, k;
cin >> n >> k;
vector<long long> arr(n + 10, 0), prefix(n + 10, 0), suf(n + 10, 0);
for (long long i = 1; i <= n; i++) {
cin >> arr[i];
prefix[i] = prefix[i - 1] + arr[i];
}
for (long long i = n - k; i >= 0; i--) {
suf[i + 1] = max(suf[i + 2], prefix[i + k] - prefix[i]);
}
long long one = -1, two = -1, cry = INT_MIN, hehe = -1;
for (long long i = 1; i <= n - 2 * k + 1; i++) {
long long j = i + k - 1;
if ((suf[j + 1] + prefix[j] - prefix[i - 1]) > cry) {
one = i;
hehe = suf[j + 1];
cry = suf[j + 1] + prefix[j] - prefix[i - 1];
}
}
for (long long u = one + k; u <= n; u++) {
if ((prefix[u + k - 1] - prefix[u - 1]) == hehe) {
two = u;
break;
}
}
cout << one << " " << two << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, a, b, c;
long long dpp[4123];
long long dp(long long k) {
if (k < 0) return -10000000000000;
if (dpp[k] != -1) return dpp[k];
if (k == 0) return dpp[k] = 0;
return dpp[k] = 1 + max(dp(k - a), max(dp(k - b), dp(k - c)));
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n;
cin >> n;
long long k;
cin >> k;
long long a[n];
for (long long i = 0; i < n; i++) cin >> a[i];
long long s[n];
s[0] = 0;
for (long long i = 0; i < k; i++) s[0] += a[i];
for (long long i = 1; i < n - k + 1; i++)
s[i] = s[i - 1] - a[i - 1] + a[k + i - 1];
long long aa = 0, bb = k;
long long pa = -1, push_back = -1;
for (long long i = k + 1; i < n - k + 1; i++) {
if (pa == -1) {
pa = aa;
push_back = bb;
} else {
if (s[aa] + s[bb] > s[pa] + s[push_back]) {
pa = aa;
push_back = bb;
}
}
if (s[i - k] > s[aa]) aa = i - k;
bb = i;
}
if (pa == -1) {
pa = aa;
push_back = bb;
} else {
if (s[aa] + s[bb] > s[pa] + s[push_back]) {
pa = aa;
push_back = bb;
}
}
cout << pa + 1 << " " << push_back + 1;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
const long long oo = 1e18;
const long long mod = 1e9 + 7;
const int INF = 1 << 30;
long long n, k;
long long a[N], cum[N];
int segments = 2;
long long dp[N][3];
long long solve(int idx, int segs) {
if (idx > n) {
return 0;
}
if (segs == 2) return 0;
if (dp[idx][segs] != -1) return dp[idx][segs];
long long seg = 0;
long long take = 0;
if (idx + k - 1 <= n) {
seg = cum[idx + k - 1] - cum[idx - 1];
take = solve(idx + k, segs + 1) + seg;
}
long long leave = solve(idx + 1, segs);
return dp[idx][segs] = max(leave, take);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
ios_base::sync_with_stdio(0);
memset(dp, -1, sizeof(dp));
cin >> n >> k;
cum[0] = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
cum[i] = a[i] + cum[i - 1];
}
map<long long, vector<int>> index;
for (int i = 1; i + k - 1 <= n; i++) {
index[cum[i + k - 1] - cum[i - 1]].push_back(i);
}
long long ans = solve(1, 0);
for (int i = 1; i + k - 1 <= n; i++) {
long long cur = cum[i + k - 1] - cum[i - 1];
if (index[ans - cur].size()) {
for (int j = 0; j < index[ans - cur].size(); j++) {
if (index[ans - cur][j] >= i + k) {
return cout << i << " " << index[ans - cur][j] << endl, 0;
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long s[222222], si[222222], ms[222222], a[222222];
int main() {
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (i > 0)
s[i] = s[i - 1] + a[i];
else
s[i] = a[i];
}
si[0] = s[k - 1];
for (int i = 1; i <= n - k; i++) si[i] = s[i + k - 1] - s[i - 1];
ms[n - k] = n - k;
for (int i = n - k - 1; i >= 0; i--) {
if (si[ms[i + 1]] > si[i])
ms[i] = ms[i + 1];
else
ms[i] = i;
}
long long ret = 0;
for (int i = 0; i <= n - 2 * k; i++) ret = max(ret, si[i] + si[ms[i + k]]);
for (int i = 0; i <= n - 2 * k; i++)
if (si[i] + si[ms[i + k]] == ret) {
cout << i + 1 << " " << ms[i + k] + 1 << endl;
break;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long sum[200010], mx[200010], ind[200010];
int main() {
ios::sync_with_stdio(false);
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
long long x;
cin >> x;
sum[i] += (sum[i - 1] + x);
}
for (int i = n; i >= k; i--) {
if (mx[i + 1] > (sum[i] - sum[i - k])) {
mx[i] = max(mx[i + 1], sum[i] - sum[i - k]);
ind[i] = ind[i + 1];
} else {
mx[i] = max(mx[i + 1], sum[i] - sum[i - k]);
ind[i] = i - k + 1;
}
}
int indx1 = 1, indx2 = 1;
long long tot = 0;
for (int i = k; i <= n - k; i++) {
if ((sum[i] - sum[i - k] + mx[i + k]) > tot) {
tot = (sum[i] - sum[i - k]) + mx[i + k];
indx1 = i - k + 1;
indx2 = ind[i + k];
}
}
cout << indx1 << " " << indx2;
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:247474112")
#pragma GCC optimize("Ofast")
using namespace std;
const long long maxn = 2e5 + 10;
long long a[maxn];
long long suf[maxn], mx[maxn];
int32_t main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
long long n, k;
cin >> n >> k;
for (long long i = 1; i <= n; ++i) cin >> a[i];
for (long long i = n, temp = 0; i; i--) {
temp += a[i];
if (i + k <= n) temp -= a[i + k];
suf[i] = suf[i + 1] + a[i];
mx[i] = max(mx[i + 1], temp);
}
long long ans = 0, first, second, half;
for (long long i = 1, temp = 0; i <= n; ++i) {
temp += a[i];
if (i - k > 0) temp -= a[i - k];
if (temp + mx[i + 1] > ans) {
ans = temp + mx[i + 1], first = i - k + 1;
half = temp;
}
}
for (long long i = first + k; i <= n; ++i) {
if ((suf[i] - suf[i + k]) + half == ans) {
second = i;
break;
}
}
cout << first << ' ' << second;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[200001];
pair<long long, long long> p[200001];
int32_t main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
srand(chrono::high_resolution_clock::now().time_since_epoch().count());
long long i, j, k, m, n, tmp, prev, r = 0, c = 0;
string s, t;
pair<long long, long long> ans;
cin >> n >> k;
m = 0;
for (i = 0; i < n; i++) {
cin >> a[i];
}
for (j = 0; j < k; j++) {
m += a[j];
}
p[0].first = m;
p[0].second = 0;
for (j = 1; 1 < n - k ? j < n - k : j > n - k; 1 < n - k ? j += 1 : j -= 1) {
m += (a[j + k - 1] - a[j - 1]);
p[j] = p[j - 1];
if (m > p[j - 1].first) {
p[j].first = m;
p[j].second = j;
}
}
m = 0;
for (j = 0; j < k; j++) {
m += a[k + j];
}
if (p[0].first + m > r) {
r = p[0].first + m;
ans = {p[0].second, k};
}
for (j = k + 1; k + 1 < n - k + 1 ? j < n - k + 1 : j > n - k + 1;
k + 1 < n - k + 1 ? j += 1 : j -= 1) {
m += a[k + j - 1];
m -= a[j - 1];
if (p[j - k].first + m > r) {
r = p[j - k].first + m;
ans = {p[j - k].second, j};
}
}
cout << ans.first + 1 << " " << ans.second + 1 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long in[int(1e6)], com[int(1e6)];
long long sz(int x, int y) { return com[y] - com[x - 1]; }
int main() {
int n, k;
cin >> n >> k;
com[0] = 0;
for (int i = 1; i <= n; i++) {
cin >> in[i];
com[i] = com[i - 1] + in[i];
}
long long f, s, mf, ms, si, mx, sm, sm1;
s = ms = n + 1 - k;
f = mf = s - k;
si = s - 1;
mx = sz(f, f + k - 1) + sz(s, s + k - 1);
while (f >= 1) {
f--;
sm = sz(f, f + k - 1) + sz(s, s + k - 1);
if (sm >= mx) {
mx = sm;
mf = f;
ms = s;
}
sm1 = sz(f, f + k - 1) + sz(si, si + k - 1);
if (sm1 >= mx) {
mx = sm1;
mf = f;
ms = si;
}
if (sm <= sm1) {
s = si;
}
si--;
}
cout << mf << " " << ms;
end:
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.