text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
cin >> n >> k;
vector<long long> a(n);
for (long long i = 0; i < n; i++) cin >> a[i];
vector<long long> q(n);
for (long long i = 0; i < k; i++) q[k - 1] += a[i];
for (long long i = k; i < n; i++) q[i] = q[i - 1] + a[i] - a[i - k];
vector<pair<long long, long long>> left(n);
left[0] = {q[0], 0};
for (long long i = 1; i < n; i++) {
if (q[i] > left[i - 1].first)
left[i] = {q[i], i};
else
left[i] = left[i - 1];
}
long long ans = 0, l = 0, r = 0;
for (long long i = 2 * k - 1; i < n; i++) {
long long first_ans = q[i];
pair<long long, long long> second_ans = left[i - k];
if (first_ans + second_ans.first > ans) {
ans = first_ans + second_ans.first;
l = second_ans.second;
r = i;
}
}
l++, l++, r++, r++;
l -= k, r -= k;
cout << l << " " << r;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 2e5 + 10;
typedef long long l_N[maxN];
int N, K, A[maxN];
l_N S, Fx, Gx;
long long ans;
long long sum(const int i) { return S[i + K - 1] - S[i - 1]; }
int main() {
ios_base::sync_with_stdio(0);
cin >> N >> K;
for (int i = 0; i < N; i++) cin >> A[i + 1];
for (int i = 1; i <= N; i++) S[i] = S[i - 1] + A[i];
Fx[N - K + 1] = N - K + 1;
for (int i = N - K; i; i--)
Fx[i] = (sum(i) >= sum(Fx[i + 1])) ? i : Fx[i + 1];
for (int i = K; i <= N - K; i++)
ans = max(ans, S[i] - S[i - K] + sum(Fx[i + 1]));
for (int i = K; i <= N - K; i++)
if (ans == S[i] - S[i - K] + sum(Fx[i + 1])) {
cout << i - K + 1 << ' ' << Fx[i + 1];
return 0;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int ms = 2e+5 + 9;
long long vet[ms], maxi = 0, x, y, segSum[ms], seg[ms];
int n, k, ind[ms];
int main() {
long long back, soma = 0;
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> vet[i];
for (int i = 1; i < n; i++) vet[i] += vet[i - 1];
for (int i = 0; i <= n - k; i++) {
back = (i == 0) ? 0 : vet[i - 1];
segSum[i] = vet[i + k - 1] - back;
}
for (int i = n - 1; i >= 0; i--) {
vet[i] = segSum[i];
if (segSum[i] >= segSum[i + 1]) {
ind[i] = i;
} else {
segSum[i] = segSum[i + 1];
ind[i] = ind[i + 1];
}
}
for (int i = 0; i <= n - k; i++) {
soma = vet[i];
if (soma + segSum[i + k] > maxi) {
x = i + 1;
y = ind[i + k] + 1;
maxi = soma + segSum[i + k];
}
}
cout << x << " " << y;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
long long int n, k;
cin >> n >> k;
vector<long long int> v(n, 0), pre(n - k + 1, 0), maxi(n - k + 1, 0);
long long int sum = 0;
for (int i = 0; i < n; i++) {
cin >> v[i];
if (i < k) sum += v[i];
}
pre[0] = sum;
for (int i = 1; i < n - k + 1; i++)
pre[i] = pre[i - 1] - v[i - 1] + v[i + k - 1];
maxi[n - k] = pre[n - k];
for (int i = n - k - 1; i >= 0; i--) maxi[i] = max(maxi[i + 1], pre[i]);
long long int ans = 0, c = -1;
for (int i = 0; i < n - k - k + 1; i++) {
if (ans < pre[i] + maxi[i + k]) c = i;
ans = max(ans, pre[i] + maxi[i + k]);
}
ans = pre[c + k];
long long int c2 = c + k;
for (int i = c + k; i < n - k + 1; i++) {
if (ans < pre[i]) {
c2 = i;
ans = pre[i];
}
}
cout << c + 1 << " " << c2 + 1;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int N = 2e5 + 10;
long long sum[N];
long long a[N], b[N];
long long f[N][20];
int n, k, top;
long long MAX(long long x, long long y) {
if (x < y) return y;
return x;
}
void advan() {
for (int i = 1; i <= top; ++i) f[i][0] = b[i];
for (int i = 1; (1 << i) <= top; ++i) {
for (int j = 1; j + (1 << i) - 1 <= top; ++j)
f[j][i] = f[j][i - 1] < f[j + (1 << (i - 1))][i - 1]
? f[j + (1 << (i - 1))][i - 1]
: f[j][i - 1];
}
}
long long query(int l, int r) {
int k = 0;
k = log2(double(r - l + 1));
return MAX(f[l][k], f[r - (1 << k) + 1][k]);
}
int main() {
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; ++i) {
scanf("%lld", &a[i]);
sum[i] = sum[i - 1] + a[i];
}
top = 0;
for (int i = k; i <= n; ++i) b[++top] = sum[i] - sum[i - k];
advan();
long long maxx = 0, L = 0, R = 0, be, res = 0, en;
for (int i = 1; i <= top - k; i++) {
L = b[i];
R = query(i + k, top);
if (L + R > maxx) {
maxx = L + R;
res = R;
be = i;
}
}
for (int i = be + k; i <= top; i++) {
if (b[i] == res) {
en = i;
break;
}
}
printf("%lld %lld\n", be, en);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
cin >> n >> k;
long long dp[n + 1];
vector<long long> v;
for (int i = 1; i <= n; i++) {
cin >> dp[i];
dp[i] += dp[i - 1];
}
for (int i = k; i <= n; i++) v.push_back(dp[i] - dp[i - k]);
long long ans = 0, mx = 0, l, r, z;
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 << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int fast(long long int n, long long int a, long long int m) {
if (n == 0)
return 1;
else if (n == 1)
return a;
else {
long long int r = fast(n / 2, a, m);
if (n % 2 == 0) {
return (((r % m) * (r % m)) % m);
} else {
return (((((r % m) * a) % m) * r) % m);
}
}
}
int main() {
long long int n, K;
cin >> n >> K;
long long int A[n];
long long int i;
for (i = 0; i < n; i++) {
cin >> A[i];
}
long long int p[n + 1];
p[0] = 0;
for (i = 1; i <= n; i++) {
p[i] = p[i - 1] + A[i - 1];
}
vector<long long int> pos, mps;
long long int S = 0, r = n - K + 1;
for (i = n - K + 1; i >= K + 1; i--) {
long long int d = p[i + K - 1] - p[i - 1];
if (d >= S) {
S = d;
r = i;
pos.push_back(r);
mps.push_back(S);
} else {
pos.push_back(r);
mps.push_back(S);
}
}
long long int j = pos.size() - 1, S2 = 0;
long long int u, v;
for (i = 1; i <= n - 2 * K + 1; i++) {
long long int dt = p[i + K - 1] - p[i - 1];
if (dt + mps[j] > S2) {
S2 = dt + mps[j];
u = i;
v = pos[j];
}
j--;
}
cout << u << " " << v;
}
|
#include <bits/stdc++.h>
using namespace std;
int const maxN = 2e5 + 20;
long long n, k, a[maxN], b[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 >> b[i];
a[n - k] = accumulate(b + n - k, b + n, 0LL);
for (int i = (n - k - 1); i >= (0); i--) a[i] = a[i + 1] - b[i + k] + b[i];
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 << '\n';
return cout << ans1 << ' ' << ans2, 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct s {
int beg, end;
long long val;
};
int main() {
int N, k, i;
s sol, m;
sol.val = m.val = 0;
scanf("%d%d", &N, &k);
long long int array[N], sums[N];
for (i = 0; i < N; ++i) {
scanf("%I64d", array + i);
if (i == 0) {
sums[i] = array[i];
} else {
sums[i] = array[i] + sums[i - 1];
}
}
for (i = 0; i <= N - k; ++i) {
if (i >= k) {
if (m.val + sums[i + k - 1] - sums[i - 1] > sol.val) {
sol.beg = m.beg;
sol.end = i;
sol.val = m.val + sums[i + k - 1] - sums[i - 1];
}
if (sums[i] - sums[i - k] > m.val) {
m.val = sums[i] - sums[i - k];
m.beg = i - k + 1;
}
}
if (i == k - 1) {
m.val = sums[i];
m.beg = 0;
}
}
printf("%d %d\n", sol.beg + 1, sol.end + 1);
return 0;
}
|
#include <bits/stdc++.h>
int N, K;
long long a[200010];
long long s[200010];
long long m[200010];
long long midx[200010];
int main() {
scanf("%d%d", &N, &K);
for (int i = 0; i < N; i++) scanf("%I64d", &a[i]);
long long t = 0;
for (int i = 0; i < K; i++) t += a[i];
for (int i = 0; i + K <= N; i++) {
s[i] = t;
t = t + a[i + K] - a[i];
}
for (int i = N - K; i >= 0; i--) {
if (m[i + 1] > s[i]) {
m[i] = m[i + 1];
midx[i] = midx[i + 1];
} else {
m[i] = s[i];
midx[i] = i;
}
}
long long best = 0ll;
int besta, bestb;
for (int i = 0; i + K + K <= N; i++) {
if (s[i] + m[i + K] > best) {
best = s[i] + m[i + K];
besta = i;
bestb = midx[i + K];
}
}
printf("%d %d\n", besta + 1, bestb + 1);
}
|
#include <bits/stdc++.h>
using namespace std;
long long dp[10001];
set<pair<long long, long long>> s;
set<long long> X, Y;
void solve(long long op, long long cl, string output, vector<string> &v) {
if (op == 0 && cl == 0) {
v.push_back(output);
}
if (op != 0) {
string op1 = output;
op1.push_back('(');
solve(op - 1, cl, op1, v);
}
if (cl > op) {
string op1 = output;
op1.push_back(')');
solve(op, cl - 1, op1, v);
}
return;
}
vector<string> fun(long long n) {
vector<string> v;
long long op = n;
long long cl = n;
string output = "";
solve(op, cl, output, v);
return v;
}
bool check(long long a[], long long n) {
for (long long i = 0; i < n - 1; i++) {
if (a[i] < a[i + 1]) return false;
}
return true;
}
long long countOddSquares(long long n, long long m) {
return (long long)pow(m, 0.5) - (long long)pow(n - 1, 0.5);
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
{
long long t;
t = 1;
while (t--) {
long long n, k;
cin >> n >> k;
long long a[n + 1];
for (long long i = 1; i < n + 1; i++) {
cin >> a[i];
if (i != 0) a[i] = a[i] + a[i - 1];
}
long long l = n - k, r = n, j = n;
for (long long i = n - k; i >= k; i--) {
if (a[i + k] - a[i] >= a[j] - a[j - k]) {
j = i + k;
}
if (a[i] - a[i - k] + a[j] - a[j - k] >=
a[l] - a[l - k] + a[r] - a[r - k]) {
l = i;
r = j;
}
}
cout << l - k + 1 << " " << r - k + 1;
}
}
}
|
#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) {
t = 0;
while ((1 << (t + 1)) <= r - l + 1) t++;
return maxx(f[l][t], f[r - (1 << t) + 1][t]);
}
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;
long long a[200005], b[200005];
int n, k;
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
a[i] += a[i - 1];
}
for (int i = 1, j = 1; i <= n - k + 1; i++, j++) {
b[j] = a[i + k - 1] - a[i - 1];
}
int l, r, t;
long long ans = 0, cnt = 0;
for (int i = 1; i <= n - 2 * k + 1; i++) {
if (cnt < b[i]) {
cnt = b[i];
t = i;
}
if (cnt + b[i + k] > ans) {
ans = cnt + b[i + k];
l = t;
r = i + k;
}
}
printf("%d %d\n", l, r);
return 0;
}
|
#include <bits/stdc++.h>
int st[200005];
long long sum[200005], max, maxab;
int main() {
int n, k, a, b;
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &st[i]);
for (int i = 1; i <= k; i++) sum[1] += st[i];
for (int i = k + 1; i <= n; i++)
sum[i - k + 1] = sum[i - k] + st[i] - st[i - k];
max = maxab = 0;
int preb;
for (int i = n - 2 * k + 1; i >= 1; i--) {
if (max <= sum[i + k]) {
max = sum[i + k];
b = i + k;
}
if (maxab <= max + sum[i]) {
maxab = max + sum[i];
a = i;
preb = b;
}
}
printf("%d %d\n", a, preb);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e16;
const long long SZ = 2e5 + 5;
const long long mod = 1e9 + 7;
long long n, k, a[SZ];
long long dp[SZ][3];
long long dir[SZ][3];
long long solve(long long in, long long c) {
if (c == 2) return 0;
if (in > n - k + 1) return -INF;
if (dp[in][c] != -1) return dp[in][c];
long long p1 = (a[in + k - 1] - a[in - 1]) + solve(in + k, c + 1);
long long p2 = solve(in + 1, c);
if (p1 >= p2)
dir[in][c] = 1;
else
dir[in][c] = 2;
return dp[in][c] = max(p1, p2);
}
void print(long long in, long long c) {
if (c == 2) return;
if (dir[in][c] == 1) {
cout << in << " ";
print(in + k, c + 1);
} else
print(in + 1, c);
}
int main() {
long long t = 0, x, y, z, i, j, g, p, q, ans = 0, sum = 0, c = 0;
string s, s1, s2;
cin >> n >> k;
for (i = 1; i <= n; i++) cin >> a[i];
for (i = 1; i <= n; i++) a[i] += a[i - 1];
memset(dp, -1, sizeof dp);
ans = solve(1, 0);
print(1, 0);
cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200010;
const int MOD = 1000000007;
const int INF = 0x3fffffff;
long long a[N];
long long f[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];
}
for (int i = 1; i <= n + 1 - k; ++i) {
f[i] = a[i + k - 1] - a[i - 1];
}
long long ans = 0;
int ansa, ansb;
int q = n + 1 - k;
int maxbp = q;
for (int i = n + 1 - k - k; i > 0; --i) {
if (ans <= f[maxbp] + f[i]) {
ans = f[maxbp] + f[i];
ansa = i;
ansb = maxbp;
}
--q;
if (f[maxbp] <= f[q]) maxbp = q;
}
printf("%d %d\n", ansa, ansb);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string imp = "Impossible\n";
const int N = 1e5 + 5;
long long MOD = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int tests = 1;
while (tests--) {
long long n, k;
cin >> n >> k;
vector<long long> v(n);
for (long long i = 0; i < n; i++) {
cin >> v[i];
}
vector<pair<long long, long long> > stmax(n - k + 1);
long long cs = 0;
for (long long i = n - 1; i >= n - 1 - (k - 1); i--) {
cs += v[i];
}
long long ms = cs;
long long mr = n - k;
stmax[n - k] = {ms, n - k};
for (long long i = n - k - 1; i >= 0; i--) {
cs += v[i] - v[i + k];
if (ms <= cs) {
ms = cs;
mr = i;
}
stmax[i] = {ms, mr};
}
cs = 0;
for (long long i = 0; i < k; i++) {
cs += v[i];
}
long long mabs = 0, ml = -1;
mr = -1;
ms = cs;
int curl;
mabs = max(mabs, ms + stmax[k].first);
curl = 0;
ml = 0;
mr = stmax[k].second;
for (long long i = k; i < n - k; i++) {
cs += v[i] - v[i - k];
if (ms < cs) {
ms = cs;
curl = i - k + 1;
}
if (ms + stmax[i + 1].first > mabs) {
mabs = ms + stmax[i + 1].first;
ml = curl;
mr = stmax[i + 1].second;
}
}
cout << ml + 1 << " " << mr + 1;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void ZZ(const char* name, Arg1&& arg1) {
std::cerr << name << " = " << arg1 << "\n";
}
template <typename Arg1, typename... Args>
void ZZ(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
std::cerr.write(names, comma - names) << " = " << arg1;
ZZ(comma, args...);
}
const long long int INF = 1e18 + 7;
const long long int MAX = 1234567;
const long long int MOD = 1000000007;
vector<pair<pair<long long int, long long int>, long long int> > seg;
long long int n, k;
vector<long long int> arr;
void solve() {
cin >> n >> k;
arr.resize(n + 1);
for (long long int i = 0; i < n; i++) cin >> arr[i];
long long int sum = 0;
for (long long int i = 0; i < k; i++) sum += arr[i];
seg.push_back({{1, k}, sum});
for (long long int i = 1; i <= n - k; i++) {
sum -= arr[i - 1];
sum += arr[i + k - 1];
seg.push_back({{i + 1, i + k}, sum});
}
sort(seg.begin(), seg.end());
long long int mx = 0;
vector<pair<long long int, long long int> > mex((long long int)seg.size(),
{0, INF});
for (long long int i = seg.size() - 1; i >= 0; i--) {
if (seg[i].second > mx) {
mx = seg[i].second;
mex[i].first = mx;
mex[i].second = seg[i].first.first;
}
if (seg[i].second == mx) {
mex[i].second = min(mex[i].second, seg[i].first.first);
mex[i].first = mx;
} else
mex[i].first = mex[i + 1].first, mex[i].second = mex[i + 1].second;
}
pair<long long int, long long int> ans = {INF, INF};
long long int maxim = 0;
for (long long int i = 0; i < (long long int)seg.size(); i++) {
long long int targ = seg[i].first.second + 1;
pair<pair<long long int, long long int>, long long int> p = {{targ, 0}, 0};
long long int idx = lower_bound(seg.begin(), seg.end(), p) - seg.begin();
if (idx == seg.size()) continue;
long long int sum = seg[i].second + mex[idx].first;
if (sum > maxim) {
ans.first = seg[i].first.first, ans.second = mex[idx].second;
maxim = sum;
}
}
cout << ans.first << " " << ans.second;
}
int32_t main() {
long long int t;
t = 1;
cin.sync_with_stdio(0), cin.tie(0);
while (t--) {
solve();
cout << "\n";
;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
long int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
long long int sum[n - k + 1];
long long int temp = 0;
for (int i = 0; i < n - k + 1; i++) sum[i] = 0;
int prev;
for (int i = 0; i < n; i++) {
if (i + 1 < k)
temp += a[i];
else if (i + 1 == k) {
temp += a[i];
sum[i + 1 - k] = temp;
prev = 0;
} else {
temp = temp + a[i] - a[prev];
prev++;
sum[i + 1 - k] = temp;
}
}
int maxx[n];
long long int max_val = 0;
prev = n - k;
for (int i = n - k; i >= 0; i--) {
if (sum[i] >= max_val) {
maxx[prev] = i;
max_val = sum[i];
prev--;
} else {
maxx[prev] = maxx[prev + 1];
prev--;
}
}
max_val = 0;
int start = -1, end = -1;
for (int i = 0; i <= n - 2 * k; i++) {
if (sum[i] + sum[maxx[i + k]] > max_val) {
start = i;
end = maxx[i + k];
max_val = sum[i] + sum[maxx[i + k]];
}
}
cout << (start + 1) << " " << (end + 1) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int a[2 * 100005], dp[2 * 100005][3];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, k;
cin >> n >> k;
for (long long int i = 1; i <= n; i++) {
cin >> a[i];
a[i] += a[i - 1];
}
for (long long int i = n - k; i >= k; i--) {
dp[i + 1][1] = a[i + k] - a[i];
dp[i + 1][2] = i + 1;
if (dp[i + 1][1] < dp[i + 2][1]) {
dp[i + 1][1] = dp[i + 2][1];
dp[i + 1][2] = dp[i + 2][2];
}
}
long long int mx = 0;
int pos1 = 1, pos2 = 1;
for (long long int i = 1; i <= n - 2 * k + 1; i++) {
if (mx < a[i + k - 1] - a[i - 1] + dp[i + k][1]) {
pos1 = i;
pos2 = dp[i + k][2];
mx = a[i + k - 1] - a[i - 1] + dp[i + k][1];
}
}
cout << pos1 << " " << pos2;
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 (int i = 1; i <= mm; ++i) {
f[i][0] = sum[i];
}
for (int j = 1; (1 << j) <= mm; ++j) {
for (int 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) {
t = 0;
while ((1 << (t + 1)) <= r - l + 1) t++;
return maxx(f[l][t], f[r - (1 << t) + 1][t]);
}
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;
long long power(long long base, long long exp) {
base %= 1000000009;
long long result = 1;
while (exp > 0) {
if (exp & 1) result = (result * base) % 1000000009;
base = (base * base) % 1000000009;
exp >>= 1;
}
return result;
}
const int N = 2e5 + 5;
pair<long long, int> maxx[N];
int arr[N];
long long s[N];
int main() {
int n, k;
scanf("%d", &n);
scanf("%d", &k);
for (int i = 0; i < N; ++i) arr[i] = -1e9;
for (int i = 1; i <= n; ++i) scanf("%d", &arr[i]), s[i] = s[i - 1] + arr[i];
long long ans = -1e9;
int idx1, idx2;
for (int i = k, j = 0; i <= n; ++i, ++j) {
if ((i - k) >= 1) {
if (((s[i] - s[j]) + maxx[i - k].first) > ans) {
ans = ((s[i] - s[j]) + maxx[i - k].first);
idx1 = maxx[i - k].second;
idx2 = j + 1;
}
}
if ((s[i] - s[j]) > maxx[i - 1].first) {
maxx[i].first = s[i] - s[j];
maxx[i].second = j + 1;
} else
maxx[i] = maxx[i - 1];
}
cout << idx1 << " " << idx2 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = (long long)1e18;
ifstream Cin("input.txt");
ofstream Cout("output.txt");
int main() {
long long n, k, i, j;
cin >> n >> k;
vector<long long> r(n + 1), s(n + 1), s1(n + 1), s2(n + 1), p1(n + 1),
p2(n + 1);
for (i = 1; i <= n; ++i) cin >> r[i], s[i] = s[i - 1] + r[i];
for (i = k; i <= n; i++) {
s1[i] = s1[i - 1];
p1[i] = p1[i - 1];
if (s[i] - s[i - k] > s1[i]) {
s1[i] = s[i] - s[i - k];
p1[i] = i - k + 1;
}
}
for (i = 2 * k; i <= n; i++) {
s2[i] = s2[i - 1];
p2[i] = p2[i - 1];
if (s[i] - s[i - k] + s1[i - k] > s2[i]) {
s2[i] = s[i] - s[i - k] + s1[i - k];
p2[i] = i - k + 1;
}
}
cout << p1[p2[n] - 1] << " " << p2[n];
}
|
#include <bits/stdc++.h>
long long int n, k, a[200100], dp1[200100], dp2[200100], dp3[200100] = {0}, i;
int main() {
scanf("%I64d %I64d", &n, &k);
for (i = 1; i <= n; i++) {
scanf("%I64d", &a[i]);
dp3[i] = dp3[i - 1] + a[i];
}
dp1[n - k + 1] = dp3[n] - dp3[n - k];
dp2[n - k + 1] = n - k + 1;
for (i = n - k; i >= 1; i--) {
if (dp3[i + k - 1] - dp3[i - 1] < dp1[i + 1]) {
dp1[i] = dp1[i + 1];
dp2[i] = dp2[i + 1];
} else {
dp1[i] = dp3[i + k - 1] - dp3[i - 1];
dp2[i] = i;
}
}
long long int max = -1, posa, posb;
for (i = k; i <= n - k; i++) {
if (dp3[i] - dp3[i - k] + dp1[i + 1] > max) {
posa = i - k + 1;
posb = dp2[i + 1];
max = dp3[i] - dp3[i - k] + dp1[i + 1];
}
}
printf("%I64d %I64d\n", posa, posb);
return (0);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 4000002;
int n, k, x[N], save[N];
long long sum[N], dp[N];
long long query(int a, int b) {
if (b > n) b = n;
return sum[b] - sum[a - 1];
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; ++i) {
cin >> x[i];
sum[i] = sum[i - 1] + x[i];
}
for (int i = n - k + 1; i > 0; --i) {
save[i] = i;
dp[i] = query(i, i + k - 1);
}
for (int i = n - k; i > 0; --i) {
if (dp[i + 1] > dp[i]) {
dp[i] = dp[i + 1];
save[i] = save[i + 1];
}
}
long long mx = 0;
int mxi = 0, next = 0;
for (int i = 1; i <= n - k * 2 + 1; ++i) {
long long Q = query(i, i + k - 1) + dp[i + k];
if (Q > mx) {
mx = Q;
mxi = i;
next = save[i + k];
}
}
cout << mxi << ' ' << next << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int INF = 1e9 + 7;
const int N = 1000010;
const double pi = 3.1415926;
int n, k;
int a[200010], idx1[200010], idx2[200010];
long long sum[200010], m1[200010], m2[200010];
int main() {
while (~scanf("%d%d", &n, &k)) {
sum[0] = 0;
memset(m1, 0, sizeof(m1));
;
memset(m2, 0, sizeof(m2));
;
int l, r;
long long ans = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
;
sum[i] = sum[i - 1] + a[i];
}
for (int i = 1; i <= n - 2 * k + 1; i++) {
if (sum[i + k - 1] - sum[i - 1] > m1[i + k - 2]) {
m1[i + k - 1] = sum[i + k - 1] - sum[i - 1];
idx1[i + k - 1] = i;
} else {
m1[i + k - 1] = m1[i + k - 2];
idx1[i + k - 1] = idx1[i + k - 2];
}
}
for (int i = n - k + 1; i >= k + 1; i--) {
if (sum[i + k - 1] - sum[i - 1] >= m2[i + 1]) {
m2[i] = sum[i + k - 1] - sum[i - 1];
idx2[i] = i;
} else {
m2[i] = m2[i + 1];
idx2[i] = idx2[i + 1];
}
}
for (int i = k; i <= n - k; i++) {
if (m1[i] + m2[i + 1] > ans) {
ans = m1[i] + m2[i + 1];
l = idx1[i];
r = idx2[i + 1];
}
}
printf("%d %d\n", l, r);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const double pi = acos(-1.0);
const double eps = 1e-9;
const int MAX_SIZE = 50;
const int dX[] = {-1, 1, 0, 0, -1, 1, -1, 1};
const int dY[] = {0, 0, -1, 1, 1, -1, -1, 1};
template <class S, class T>
ostream& operator<<(ostream& o, const pair<S, T>& a) {
o << a.first << " " << a.second << " ";
return o;
}
template <class S, class T>
ostream& operator<<(ostream& o, const map<S, T>& a) {
for (auto& it : (a)) o << (it);
return o;
}
template <class S>
ostream& operator<<(ostream& o, const vector<S>& a) {
for (auto& it : (a)) o << (it) << " ";
o << "\n";
return o;
}
template <class S>
ostream& operator<<(ostream& o, const vector<vector<S> >& a) {
for (auto& it : (a)) o << (it);
return o;
}
template <class S>
ostream& operator<<(ostream& o, const set<S>& a) {
for (auto& it : (a)) o << (it) << " ";
o << "\n";
return o;
}
const long long MAX = 2e5 + 10;
long long sum[MAX];
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int i, n, k, x, ansa, ansb, maxb, a, b;
long long max_sum = 0, max_suf_sum = 0;
cin >> n >> k;
for (i = (0); (((1) > 0) - ((1) < 0)) * i < (((1) > 0) - ((1) < 0)) * (n);
i += (1)) {
cin >> x;
sum[i + 1] = sum[i] + x;
}
for (a = n - 2 * k + 1; a > 0; a--) {
b = a + k;
if (sum[b + k - 1] - sum[b - 1] >= max_suf_sum) {
maxb = b;
max_suf_sum = sum[b + k - 1] - sum[b - 1];
}
if (sum[a + k - 1] - sum[a - 1] + max_suf_sum >= max_sum) {
max_sum = sum[a + k - 1] - sum[a - 1] + max_suf_sum;
ansa = a;
ansb = maxb;
}
}
cout << ansa << " " << ansb << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
long long int C(int n, int k) {
long long ans = 1;
k = k > n - k ? n - k : k;
int j = 1;
for (; j <= k; j++, n--) {
if (n % j == 0) {
ans *= n / j;
} else if (ans % j == 0) {
ans = ans / j * n;
} else {
ans = (ans * n) / j;
}
}
return ans;
}
long long int powmod(long long int a, long long int b) {
long long int res = 1;
a %= mod;
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
long long int gcd(long long int a, long long int b) {
if (a == 0)
return (b);
else
return (gcd(b % a, a));
}
long long int powmod(long long int a, long long int b, long long int m) {
long long int res = 1;
a %= m;
for (; b; b >>= 1) {
if (b & 1) res = res * a % m;
a = a * a % m;
}
return res;
}
int countSetBits(long long int n) {
unsigned int count = 0;
while (n) {
n &= (n - 1);
count++;
}
return count;
}
int members[100010];
long long int a[200010];
void init(int n) {
for (int i = 0; i <= n; i++) {
a[i] = i;
members[i] = 1;
}
}
int rootof(int x) {
if (a[x] != x) {
a[x] = rootof(a[x]);
}
return a[x];
}
void unite(int x, int y) {
x = rootof(x);
y = rootof(y);
if (x != y) {
if (members[x] < members[y]) {
swap(x, y);
}
a[y] = x;
members[x] += members[y];
}
}
int main() {
std::ios::sync_with_stdio(false);
long long int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
long long int first[n];
first[0] = a[0];
vector<pair<long long int, long long int> > rmax(n);
for (int i = 0; i < n; i++) {
rmax[i].first = rmax[i].second = 0;
}
for (int i = 1; i < k; i++) {
first[i] = first[i - 1] + a[i];
}
for (int i = k; i < n; i++) {
first[i] = first[i - 1] + a[i] - a[i - k];
}
rmax[n - 1].first = first[n - 1];
rmax[n - 1].second = n - 1;
for (int i = n - 2; i >= 0; i--) {
if (rmax[i + 1].first <= first[i]) {
rmax[i].first = first[i];
rmax[i].second = i;
} else {
rmax[i] = rmax[i + 1];
}
}
int start_index = -1, end_index = -1;
long long int max = 0;
for (int i = k - 1; i < n - k; i++) {
if (first[i] + rmax[i + k].first > max) {
start_index = i - k + 2;
end_index = rmax[i + k].second - k + 2;
max = first[i] + rmax[i + k].first;
}
}
cout << start_index << " " << end_index << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[1000000], sum[1000000], mx[1000000], mxb[1000000];
long long strt[1000000], strtb[1000000];
int main() {
long long n, m, i, j, k, l;
scanf("%I64d", &n);
scanf("%I64d", &k);
for (i = 1; i <= (n); i++) {
scanf("%I64d", &a[i]);
}
for (i = 1; i <= n; i++) {
sum[i] = sum[i - 1] + a[i];
}
for (i = 1; i < k; i++) mx[i] = -1000000000000000000;
mx[k] = sum[k];
strt[k] = 1;
for (i = k + 1; i <= n; i++) {
if (mx[i - 1] >= sum[i] - sum[i - k]) {
mx[i] = mx[i - 1];
strt[i] = strt[i - 1];
} else {
mx[i] = sum[i] - sum[i - k];
strt[i] = i - k + 1;
}
}
for (i = n; i > n - k + 1; i--) mxb[i] = -1000000000000000000;
mxb[n - k + 1] = sum[n] - sum[n - k];
strtb[n - k + 1] = n - k + 1;
for (i = n - k; i > 0; i--) {
if (mxb[i + 1] > sum[i + k - 1] - sum[i - 1]) {
mxb[i] = mxb[i + 1];
strtb[i] = strtb[i + 1];
} else {
mxb[i] = sum[i + k - 1] - sum[i - 1];
strtb[i] = i;
}
}
long long ans = 0, a, b;
for (i = k; i <= n - k; i++) {
if (mx[i] + mxb[i + 1] > ans) {
ans = mx[i] + mxb[i + 1];
a = strt[i];
b = strtb[i + 1];
}
}
printf("%I64d\n", a);
printf("%I64d\n", b);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long dp[300000], dp2[300000];
long long pos[300000], pos2[300000];
long long a[300000];
int main() {
long long n, k;
cin >> n >> k;
memset(dp, 0, sizeof(dp));
memset(dp2, 0, sizeof(dp2));
a[0] = 0;
long long val;
for (long long i = 1; i <= n; i++) {
cin >> val;
a[i] = a[i - 1] + val;
}
dp[0] = 0;
dp[k] = a[k];
pos[k] = 1;
for (long long i = 1; i <= n; i++) {
if (i <= k) {
continue;
}
dp[i] = dp[i - 1];
pos[i] = pos[i - 1];
if (a[i] - a[i - k] > dp[i]) {
dp[i] = a[i] - a[i - k];
pos[i] = i - k + 1;
}
}
dp2[n + 1] = 0;
dp2[n - k + 1] = a[n] - a[n - k];
pos2[n - k + 1] = n - k + 1;
for (long long j = n; j >= 1; j--) {
if (j > n - k) {
continue;
} else {
dp2[j] = dp2[j + 1];
pos2[j] = pos2[j + 1];
if (a[j + k - 1] - a[j - 1] >= dp2[j]) {
dp2[j] = a[j + k - 1] - a[j - 1];
pos2[j] = j;
}
}
}
long long maxval = 0;
long long posi, posj;
for (long long i = k; i <= n - k; i++) {
if (maxval < dp[i] + dp2[i + 1]) {
maxval = dp[i] + dp2[i + 1];
posi = pos[i];
posj = pos2[i + 1];
}
}
cout << posi << " " << posj << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[200040];
long long deepika(int l, int r) {
if (l == 0) {
return a[r];
}
return a[r] - a[l - 1];
}
int main() {
int n, k, i, j;
scanf("%d %d", &n, &k);
long long sum1, sum2, tot, temp, s1, s2;
a[0] = 0;
for (i = 1; i <= n; i++) {
scanf("%lld", a + i);
a[i] += a[i - 1];
}
tot = deepika(1, k) + deepika(k + 1, 2 * k);
pair<int, int> ans = {1, k + 1};
sum1 = deepika(1, k);
pair<int, long long> fr = {1, sum1};
for (i = 2; i <= n - 2 * k + 1; i++) {
temp = deepika(i, i + k - 1);
if (temp > sum1) {
sum1 = temp;
fr = {i, sum1};
}
s1 = deepika(i + k, i + 2 * k - 1) + sum1;
if (s1 > tot) {
tot = s1;
ans = {fr.first, i + k};
}
}
printf("%d %d\n", ans.first, ans.second);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const double eps = 1e-8;
const int dx[8] = {1, 0, -1, 0, -1, -1, 1, 1};
const int dy[8] = {0, 1, 0, -1, 1, -1, 1, -1};
const int days[13] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
const int leap[13] = {0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int a[222222];
long long sum[222222];
long long ans, pre;
int n, k, ans1, ans2;
int main() {
while (scanf("%d%d", &n, &k) == 2) {
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
sum[0] = 0;
for (int i = 1; i <= n; ++i) sum[i] = sum[i - 1] + a[i];
ans = 0;
int j = k;
pre = k;
for (int i = k * 2; i <= n; ++i) {
if (sum[i] + sum[j] - sum[i - k] - sum[j - k] > ans) {
ans = sum[i] + sum[j] - sum[i - k] - sum[j - k];
ans1 = j;
ans2 = i;
}
pre++;
if (sum[pre] - sum[pre - k] > sum[j] - sum[j - k]) j = pre;
}
printf("%d %d\n", ans1 - k + 1, ans2 - k + 1);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 400000 + 10;
int n, m, mm, k, ans, t;
long long d[MX][64];
long long a[MX], sum[MX];
long long maxx(long long x1, long long x2) { return x1 < x2 ? x2 : x1; }
void init() {
mm = n - k + 1;
for (int i = 1; i <= mm; ++i) {
d[i][0] = sum[i];
}
for (int j = 1; (1 << j) <= mm; ++j) {
for (int i = 1; i + j - 1 <= mm; ++i) {
d[i][j] = maxx(d[i][j - 1], d[i + (1 << (j - 1))][j - 1]);
}
}
}
long long RMQ(int l, int r) {
int k = 0;
while (1 << (k + 1) <= r - l + 1) k++;
return maxx(d[l][k], d[r - (1 << k) + 1][k]);
}
int main() {
ios::sync_with_stdio(0);
int i, j, s, e;
long long ma, tmp;
cin >> n >> k;
sum[1] = 0;
for (i = 1; i <= n; i++) {
cin >> 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] + RMQ(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;
}
}
cout << s << " " << e << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200000 + 100;
int n, k, ans1, ans2;
int a[maxn], d[maxn];
long long sum[maxn], summax;
int main() {
while (~scanf("%d%d", &n, &k)) {
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
memset(sum, 0, sizeof(sum));
for (int i = n; i > n - k; i--) sum[n - k + 1] += a[i];
d[n - k + 1] = n - k + 1;
for (int i = n - k; i > 0; i--) {
sum[i] = sum[i + 1] + a[i] - a[i + k];
if (sum[i] >= sum[d[i + 1]])
d[i] = i;
else
d[i] = d[i + 1];
}
summax = 0;
ans1 = 0;
ans2 = 0;
for (int i = 1; i <= n - 2 * k + 1; i++)
if (sum[i] + sum[d[i + k]] > summax) {
summax = sum[i] + sum[d[i + k]];
ans1 = i;
ans2 = d[i + k];
}
printf("%d %d\n", ans1, ans2);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n, k;
cin >> n >> k;
vector<long long> vec(n);
for (int i = 0; i < n; i++) cin >> vec[i];
vector<long long> fron(n), bac(n);
fron[0] = vec[0];
for (int i = 1; i < k; i++) fron[i] = fron[i - 1] + vec[i];
for (int i = k; i < n; i++) fron[i] = fron[i - 1] + vec[i] - vec[i - k];
bac[n - 1] = vec[n - 1];
for (int i = n - 2; i >= n - k; i--) bac[i] = bac[i + 1] + vec[i];
for (int i = n - k - 1; i >= 0; i--)
bac[i] = bac[i + 1] + vec[i] - vec[i + k];
pair<long long, int> maxi;
pair<long long, int> andss;
maxi.first = 0;
long long ans = 0, curr;
for (int i = k - 1; i < n - k; i++) {
if (maxi.first < fron[i]) {
maxi.first = fron[i];
maxi.second = i - k + 2;
}
curr = maxi.first + bac[i + 1];
if (ans < curr) {
andss.first = maxi.second;
andss.second = i + 2;
ans = curr;
}
}
cout << andss.first << " " << andss.second;
}
|
#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 < 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;
using ll = long long;
const ll MOD = 1e9 + 7;
const ll INF = 1e9 + 9;
const double PI = 4.0 * atan(1.0);
ll powmod(ll a, ll b) {
ll res = 1;
a %= MOD;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) res = res * a % MOD;
a = a * a % MOD;
}
return res;
}
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int n, k;
cin >> n >> k;
vector<ll> a(n);
vector<ll> prefix(n + 1);
vector<ll> suffix(n + 2);
prefix[0] = 0;
for (int i = 0; i < n; ++i) {
cin >> a[i];
prefix[i + 1] = prefix[i] + a[i];
}
suffix[n + 1] = 0;
for (int i = n; i >= 1; --i) {
suffix[i] = suffix[i + 1] + a[i - 1];
}
vector<ll> max_prefix(n + 1);
vector<int> at_prefix(n + 1);
vector<int> at_suffix(n + 1);
for (int i = k; i <= n; ++i) {
max_prefix[i] = max(max_prefix[i - 1], prefix[i] - prefix[i - k]);
if (prefix[i] - prefix[i - k] > max_prefix[i - 1])
at_prefix[i] = i;
else
at_prefix[i] = at_prefix[i - 1];
}
vector<ll> max_suffix(n + 2);
for (int i = n - k + 1; i >= 1; --i) {
max_suffix[i] = max(max_suffix[i + 1], suffix[i] - suffix[i + k]);
if (suffix[i] - suffix[i + k] >= max_suffix[i + 1])
at_suffix[i] = i;
else
at_suffix[i] = at_suffix[i + 1];
}
ll ans = 0;
int aa, bb;
for (int i = k; i <= n - k; ++i) {
if (max_prefix[i] + max_suffix[i + 1] > ans) {
ans = max_prefix[i] + max_suffix[i + 1];
aa = i;
bb = i + 1;
}
}
aa = at_prefix[aa] - k + 1;
bb = at_suffix[bb];
cout << aa << " " << bb;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
cin >> n >> k;
long long a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
long long s[n];
s[0] = 0;
long long dp[n];
for (int i = 0; i < k; i++) {
s[0] += a[i];
}
for (int i = 1; i <= n - k; i++) {
s[i] = s[i - 1] - a[i - 1] + a[i + k - 1];
}
dp[n - k] = n - k;
for (int i = n - k - 1; i >= 0; i--) {
if (s[i] >= s[dp[i + 1]])
dp[i] = i;
else
dp[i] = dp[i + 1];
}
long long ans = 0;
for (int i = 0; i <= n - k - k; i++) {
ans = max(ans, s[i] + s[dp[i + k]]);
}
for (int i = 0; i <= n - k - k; i++) {
if (ans == s[i] + s[dp[i + k]]) {
cout << i + 1 << " " << dp[i + k] + 1;
return 0;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 20;
long long a[MAXN], b[MAXN], c[MAXN];
struct DP {
int pos;
long long sum;
} dp[MAXN];
int main() {
int n, d, i, j, x, p1, p2;
while (scanf("%d%d", &n, &d) != EOF) {
memset(dp, 0, sizeof(dp));
a[0] = b[n + 1] = 0;
for (i = 1; i <= n; i++) {
cin >> c[i];
a[i] = a[i - 1] + c[i];
}
for (i = n; i >= 0; i--) b[i] = b[i + 1] + c[i];
dp[n + 1].sum = 0;
for (i = n - d; i <= n; i++) dp[i].sum = 0;
for (i = 1 + n - d; i >= 1; i--) {
dp[i].sum = b[i] - b[i + d];
dp[i].pos = i;
if (dp[i].sum < dp[i + 1].sum) {
dp[i].sum = dp[i + 1].sum;
dp[i].pos = dp[i + 1].pos;
}
}
long long ans = 0;
for (i = 1; i <= n - d + 1; i++) {
long long tmp = a[i + d - 1] - a[i - 1];
if (tmp + dp[i + d].sum > ans) {
ans = tmp + dp[i + d].sum;
p1 = i;
p2 = dp[i + d].pos;
}
}
printf("%d %d\n", p1, p2);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
while (t--) {
int n, k;
cin >> n >> k;
vector<long long> ar(n);
for (int i = 0; i < n; i++) cin >> ar[i];
vector<long long> dp(n, 0);
vector<pair<long long, int> > mem(n);
for (int i = 0; i < k; i++) dp[0] += ar[i];
for (int i = 1; i <= n - k; i++) {
dp[i] = dp[i - 1] + ar[i + k - 1] - ar[i - 1];
}
mem[n - k] = make_pair(dp[n - k], n - k);
for (int i = n - k - 1; i >= k; i--) {
if (dp[i] >= mem[i + 1].first)
mem[i] = make_pair(dp[i], i);
else
mem[i] = make_pair(mem[i + 1].first, mem[i + 1].second);
}
int a = 0, b = mem[k].second;
long long ans = dp[0] + mem[k].first;
for (int i = 1; i <= n - k * 2; i++) {
if (dp[i] + mem[i + k].first > ans) {
a = i;
b = mem[i + k].second;
ans = dp[i] + mem[i + k].first;
}
}
cout << a + 1 << " " << b + 1;
}
}
|
#include <bits/stdc++.h>
long long a[200003], s[200003];
int p[200003];
int main() {
int n, k, i, j, l, r;
long long mmax, ans;
while (~scanf("%d%d", &n, &k)) {
for (s[0] = 0, i = 1; i <= n; i++)
scanf("%I64d", &a[i]), s[i] = s[i - 1] + a[i];
mmax = s[n] - s[n - k], p[n - k + 1] = n - k + 1;
for (i = n - k; i >= 1; i--) {
if (s[i + k - 1] - s[i - 1] >= mmax)
mmax = s[i + k - 1] - s[i - 1], p[i] = i;
else
p[i] = p[i + 1];
}
for (ans = 0, l = 1, r = k + 1, i = 1; i + 2 * k - 1 <= n; i++) {
j = p[i + k];
if (s[i + k - 1] - s[i - 1] + s[j + k - 1] - s[j - 1] > ans)
ans = s[i + k - 1] - s[i - 1] + s[j + k - 1] - s[j - 1], l = i, r = j;
}
printf("%d %d\n", l, r);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n, k;
cin >> n >> k;
long long arr[n];
for (int i = (int)(0); i <= (int)(n - 1); i++) {
cin >> arr[i];
}
long long pref[n];
pref[0] = arr[0];
for (int i = (int)(1); i <= (int)(n - 1); i++) {
pref[i] = pref[i - 1] + arr[i];
}
long long maxi = pref[n - 1] - pref[n - k - 1];
long long ans = pref[n - 1] - pref[n - 2 * k - 1];
long long a = n - 2 * k + 1, b = n - k + 1;
long long i = n - 2 * k - 1;
long long b1 = b;
while (i >= 0) {
if (maxi <= pref[i + 2 * k - 1] - pref[i + k - 1]) {
long long val = 0;
if (i == 0) {
val = pref[i + k - 1] + pref[i + 2 * k - 1] - pref[i + k - 1];
} else {
val = pref[i + k - 1] - pref[i - 1] + pref[i + 2 * k - 1] -
pref[i + k - 1];
}
if (val >= ans) {
a = i + 1;
ans = val;
maxi = pref[i + 2 * k - 1] - pref[i + k - 1];
b = i + k + 1;
b1 = i + k + 1;
} else {
maxi = pref[i + 2 * k - 1] - pref[i + k - 1];
b1 = i + k + 1;
}
} else {
long long val = 0;
if (i == 0) {
val = pref[i + k - 1] + maxi;
} else {
val = pref[i + k - 1] - pref[i - 1] + maxi;
}
if (ans <= val) {
a = i + 1;
ans = val;
b = b1;
}
}
i--;
}
cout << a << " " << b << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
struct Data {
long long val, a, b;
};
bool comp(Data &a, Data &b) {
if (a.val > b.val) return true;
if (a.val < b.val) return false;
if (a.a < b.a) return true;
if (a.a > b.a) return false;
return a.b < b.b;
}
void solve() {
long long n, k;
cin >> n >> k;
long long a[n];
for (long long i = 0; i < n; i++) cin >> a[i];
long long sum = 0LL;
for (long long i = 0; i < k; i++) sum += a[i];
vector<pair<long long, long long> > sums;
sums.push_back({sum, 1});
for (long long i = 1; i < n - k + 1; i++) {
sum += a[i + k - 1];
sum -= a[i - 1];
sums.push_back({sum, i + 1});
}
long long sz = sums.size();
vector<pair<long long, long long> > maxi(sz, {0, 0});
for (long long i = sz - 1; i >= 0; i--) {
if (i == sz - 1) {
maxi[i] = sums[i];
} else {
maxi[i] = maxi[i + 1];
if (sums[i].first >= maxi[i].first) maxi[i] = sums[i];
}
}
vector<Data> ans;
for (long long i = 0; i + 2 * k <= n; i++) {
Data cur;
cur.val = sums[i].first + maxi[i + k].first;
cur.a = sums[i].second;
cur.b = maxi[i + k].second;
ans.push_back(cur);
}
sort((ans).begin(), (ans).end(), comp);
cout << ans[0].a << " " << ans[0].b << endl;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long t = 1;
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int max_n = 3e5;
int n, k;
long long sum[max_n + 1];
long long dp[max_n + 1];
int id[max_n + 1];
int main() {
cin >> n >> k;
sum[0] = 0;
for (int i = 1; i <= n; ++i) {
int a;
cin >> a;
sum[i] = sum[i - 1] + a;
}
dp[n - k + 1] = sum[n] - sum[n - k];
id[n - k + 1] = n - k + 1;
for (int i = n - k; i >= 1; --i) {
dp[i] = dp[i + 1];
id[i] = id[i + 1];
if (sum[i + k - 1] - sum[i - 1] >= dp[i]) {
dp[i] = sum[i + k - 1] - sum[i - 1];
id[i] = i;
}
}
long long ans = sum[2 * k];
int id1 = 1;
int id2 = 1 + k;
for (int i = 1; i + k <= n - k + 1; ++i)
if (sum[i + k - 1] - sum[i - 1] + dp[i + k] > ans) {
ans = sum[i + k - 1] - sum[i - 1] + dp[i + k];
id1 = i;
id2 = id[i + k];
}
cout << id1 << " " << id2 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int N = 2e5 + 10;
long long sum[N];
long long a[N], b[N];
long long f[N][20];
int n, k, top;
long long MAX(long long x, long long y) {
if (x < y) return y;
return x;
}
void advan() {
for (int i = 1; i <= top; ++i) f[i][0] = b[i];
for (int i = 1; (1 << i) <= top; ++i) {
for (int j = 1; j + (1 << i) - 1 <= top; ++j)
f[j][i] = f[j][i - 1] < f[j + (1 << (i - 1))][i - 1]
? f[j + (1 << (i - 1))][i - 1]
: f[j][i - 1];
}
}
long long query(int l, int r) {
int k = 0;
k = log2(double(r - l + 1));
return MAX(f[l][k], f[r - (1 << k) + 1][k]);
}
int main() {
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; ++i) {
scanf("%lld", &a[i]);
sum[i] = sum[i - 1] + a[i];
}
top = 0;
for (int i = k; i <= n; ++i) b[++top] = sum[i] - sum[i - k];
advan();
long long maxx = 0, L = 0, R = 0, be, res = 0, en;
for (int i = 1; i <= top - k; ++i) {
L = b[i];
R = query(i + k, top);
if (L + R > maxx) {
maxx = L + R;
res = R;
be = i;
}
}
for (int i = be + k; i <= top; ++i) {
if (b[i] == res) {
en = i;
break;
}
}
printf("%lld %lld\n", be, en);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct pairs {
pairs(int f, int s) : first(f), secound(s) {}
int first;
int secound;
};
long long int abs1(long long int i) {
if (i < 0)
return i * -1;
else
return i;
}
int main() {
int n, k, first = 0, last = 200001, ptr = 0, f2, l2, maxi = 200001, j, gf;
long long int currentsum = 0;
int* arr = new int[200009];
cin >> n >> k;
j = n;
gf = k;
long long int sums[200002];
sums[200001] = -1;
vector<int> f, l;
for (int i = 0; i < k; i++) {
cin >> arr[i];
currentsum += arr[i];
}
sums[ptr++] = currentsum;
for (int i = k; i < n; i++) {
cin >> arr[i];
currentsum += arr[i];
currentsum -= arr[i - k];
sums[ptr++] = currentsum;
}
long long int min = 0, max = -1, maxo, minch;
for (int i = k; i < ptr; i++) {
if (sums[i - k] > sums[min]) {
min = i - k;
}
if (sums[min] + sums[i] > max) {
maxo = i;
max = sums[min] + sums[i];
minch = min;
}
}
cout << minch + 1 << ' ' << maxo + 1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int i, n, m, ansa, ansb, t[200000];
long long a[200000], f[200000], s[200000], ans;
int main() {
scanf("%d%d", &n, &m);
for (i = 0; i < n; ++i) scanf("%d", &a[i]);
f[0] = a[0];
for (i = 1; i < n; ++i) f[i] = f[i - 1] + a[i];
s[0] = 0;
for (i = 0; i < m; ++i) s[0] += a[i];
for (i = 1; i <= n - m; ++i) s[i] = s[i - 1] - a[i - 1] + a[i + m - 1];
t[0] = 0;
for (i = 1; i <= n - m; ++i)
if (s[i - 1] >= s[i]) {
s[i] = s[i - 1];
t[i] = t[i - 1];
} else
t[i] = i;
ans = 0;
for (i = m; i + m <= n; ++i)
if (s[i - m] + f[i + m - 1] - f[i - 1] > ans) {
ans = s[i - m] + f[i + m - 1] - f[i - 1];
ansa = t[i - m];
ansb = i;
}
printf("%d %d\n", ansa + 1, ansb + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 998244353;
const int N = 200005;
const double PI = 4 * atan(1);
int dx[] = {1, -1, 0, 0, 1, -1, 1, -1};
int dy[] = {0, 0, 1, -1, 1, 1, -1, -1};
long long gcd(long long a, long long b) { return (b == 0 ? a : gcd(b, a % b)); }
long long lcm(long long a, long long b) { return a * (b / gcd(a, b)); }
bool issquare(long long w) { return trunc(sqrt(w)) * trunc(sqrt(w)) == w; }
bool isprime(long long u) {
for (long long i = 2; i <= (int)sqrt(u); i++) {
if (u % i == 0) return 0;
}
return 1;
}
long long mod(long long to_mod) {
to_mod %= MOD;
while (to_mod < 0) to_mod += MOD;
return to_mod % MOD;
}
long long moduloMultiplication(long long a, long long b, long long mod) {
long long res = 0;
a %= mod;
while (b) {
if (b & 1) res = (res + a) % mod;
a = (2 * a) % mod;
b >>= 1;
}
return res;
}
long long power(long long x, long long y) {
long long res = 1;
x = x;
while (y > 0) {
if (y & 1) res = (res * x);
y = y >> 1;
x = (x * x);
}
return res;
}
long long n, k, ans;
long long x[N], tab[N], tab1[N];
int main() {
ios_base::sync_with_stdio(false);
memset(tab, 0, sizeof(tab));
memset(tab1, 0, sizeof(tab1));
cin >> n >> k;
x[0] = 0;
for (int i = 0; i < n; i++) {
cin >> x[i + 1];
x[i + 1] += x[i];
}
for (int i = n - k + 1; i > k; i--) {
if (x[i + k - 1] - x[i - 1] >= tab[i + 1]) {
tab1[i] = i;
} else
tab1[i] = tab1[i + 1];
tab[i] = max(tab[i + 1], x[i + k - 1] - x[i - 1]);
}
ans = 0;
long long a = -1;
long long b = -1;
for (int i = 1; i < n - k + 1; i++) {
if (x[i + k - 1] - x[i - 1] + tab[i + k] > ans) {
a = i;
b = tab1[i + k];
}
ans = max(ans, x[i + k - 1] - x[i - 1] + tab[i + k]);
}
cout << a << " " << b << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
long long a[maxn];
long long sum[maxn];
int n, k;
int main() {
while (~scanf("%d%d", &n, &k)) {
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
sum[0] = 0;
for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + a[i];
for (int i = 1; i <= n - k + 1; i++) a[i] = sum[i + k - 1] - sum[i - 1];
long long ans = a[1], MAX = a[1];
int l = 1, r = 1;
int maxl = 1, maxr = 1;
for (int i = 1; i <= n - k + 1; i++) {
if (a[i] > ans) {
ans = a[i];
l = i;
}
if (ans + a[i + k] > MAX) {
MAX = ans + a[i + k];
maxl = l;
maxr = i + k;
}
}
printf("%d %d\n", maxl, maxr);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 200005;
long long seg[4 * N][2], n, k, ar[N], sm[N];
void build(long long ss, long long se, long long pos) {
if (ss == se) {
seg[pos][0] = sm[ss];
seg[pos][1] = ss;
return;
}
long long mid = (ss + se) / 2;
build(ss, mid, 2 * pos + 1);
build(mid + 1, se, 2 * pos + 2);
if (seg[2 * pos + 1][0] >= seg[2 * pos + 2][0]) {
seg[pos][0] = seg[2 * pos + 1][0];
seg[pos][1] = seg[2 * pos + 1][1];
} else {
seg[pos][0] = seg[2 * pos + 2][0];
seg[pos][1] = seg[2 * pos + 2][1];
}
}
pair<long long, long long> query(long long ss, long long se, long long pos,
long long qs, long long qe) {
if (se < qs or ss > qe) return {0, -1};
if (ss == se) return {seg[pos][0], seg[pos][1]};
if (ss >= qs and se <= qe) {
return {seg[pos][0], seg[pos][1]};
}
long long mid = (ss + se) / 2;
pair<long long, long long> a = query(ss, mid, 2 * pos + 1, qs, qe);
pair<long long, long long> b = query(mid + 1, se, 2 * pos + 2, qs, qe);
if (a.first >= b.first) {
return a;
} else {
return b;
}
}
void Heavy_Gaurav_Singh() {
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> ar[i];
for (int i = n - 1; i >= 0; i--) {
if (i == n - 1)
sm[i] = ar[i];
else
sm[i] = ar[i] + sm[i + 1];
}
for (int i = 0; i + k < n; i++) sm[i] -= sm[i + k];
build(0, n - k, 0);
long long ans = 0;
pair<long long, long long> pr;
for (int i = 0; i < n - k; i++) {
pair<long long, long long> q = query(0, n - k, 0, i + k, n - k);
long long t = sm[i] + q.first;
if (t > ans) {
pr = {i + 1, q.second + 1};
ans = t;
}
}
cout << pr.first << " " << pr.second << endl;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int test = 1;
while (test--) {
Heavy_Gaurav_Singh();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long oo = (1LL << 62);
int n, K, idma, id2, id1;
long long ans, acum[200012], ma, curr;
vector<long long> tree;
long long get(int ini) { return (acum[ini + K - 1] - acum[ini - 1]); }
void update(int u, int i, int j, int idx, long long val) {
if (idx < i || idx > j) return;
if (i == j) {
tree[u] = val;
return;
}
update((u << 1), i, ((i + j) >> 1), idx, val);
update(((u << 1) | 1), ((i + j) >> 1) + 1, j, idx, val);
tree[u] = max(tree[(u << 1)], tree[((u << 1) | 1)]);
}
long long query(int u, int i, int j, int l, int r) {
if (r < i || l > j) return -oo;
if (l <= i && j <= r) return tree[u];
long long lans = query((u << 1), i, ((i + j) >> 1), l, r);
long long rans = query(((u << 1) | 1), ((i + j) >> 1) + 1, j, l, r);
return max(lans, rans);
}
int main() {
cin.tie(NULL);
ios_base::sync_with_stdio(0);
long long x;
scanf("%d %d", &n, &K);
for (int i = 1; i <= n; ++i) {
scanf("%lld", &x);
acum[i] = acum[i - 1] + x;
}
tree = vector<long long>(4 * (n + 5), -oo);
for (int i = 1; i <= n - K + 1; ++i) {
update(1, 1, n, i, get(i));
}
ma = -1;
for (int i = 1; i <= n - K + 1; ++i) {
curr = query(1, 1, n, i + K, n) + get(i);
if (curr > ans) {
id1 = i;
ans = curr;
}
}
printf("%d ", id1);
for (int i = id1 + K; i <= n - K + 1; ++i) {
if (get(id1) + get(i) == ans) {
printf("%d\n", i);
return 0;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k, a[200001] = {0}, dp[200001] = {0}, max1 = 0, max2 = 0,
ans1 = 0, ans2 = 0, ans3 = 0;
cin >> n >> k;
cin >> a[1];
for (int i = 2; i <= n; i++) {
long long b;
cin >> b;
a[i] = a[i - 1] + b;
}
for (int i = 1; i <= n - k + 1; i++) dp[i] = a[i + k - 1] - a[i - 1];
for (int i = n - 2 * k + 1; i >= 1; i--) {
if (max1 <= dp[i + k]) {
max1 = dp[i + k];
ans3 = i + k;
}
if (max1 + dp[i] >= max2) {
max2 = max1 + dp[i];
ans1 = i;
ans2 = ans3;
}
}
cout << ans1 << " " << ans2;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<long long> v(n), sum(n - k + 1, 0);
for (int i = 0; i < n; i++) cin >> v[i];
for (int i = 0; i < k; i++) sum[0] = sum[0] + v[i];
for (int i = 1; i <= n - k; i++)
sum[i] = sum[i - 1] + v[i + k - 1] - v[i - 1];
long long maxi = sum[0];
long long maxsum = sum[0] + sum[k];
int a = 0, b = k, index = 0;
for (int i = k; i <= n - k; i++) {
if (sum[i - k] > maxi) {
maxi = sum[i - k];
index = i - k;
}
if (maxsum < sum[i] + maxi) {
maxsum = sum[i] + maxi;
b = i;
if (b - index >= k) a = index;
}
}
cout << a + 1 << ' ' << b + 1;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int a[200005], l[200005], r[200005], c[200005], maxl, maxr, imax,
jmax;
int main() {
long long int n, k, i, j;
cin >> n >> k;
for (i = 1; i <= n; i++) {
cin >> a[i];
c[i] = c[i - 1] + a[i];
if (i == k) {
maxl = c[i] - c[i - k - 1];
l[i] = i;
}
if (i > k) {
if (c[i] - c[i - k] > c[l[i - 1]] - c[l[i - 1] - k]) {
maxl = c[i] - c[i - k];
l[i] = i;
} else
l[i] = l[i - 1];
}
}
for (j = n - k + 1; j >= 1; j--) {
if (j == n - k + 1) {
maxr = c[j + k - 1] - c[j - 1];
r[j] = j;
continue;
}
if (c[j + k - 1] - c[j - 1] >= c[r[j + 1] + k - 1] - c[r[j + 1] - 1]) {
maxr = c[j + k - 1] - c[j - 1];
r[j] = j;
} else
r[j] = r[j + 1];
}
maxl = 0;
maxr = 0;
for (i = k; i <= n - k + 1; i++) {
long long int left, right;
left = c[l[i]] - c[l[i] - k];
right = c[r[i + 1] + k - 1] - c[r[i + 1] - 1];
if (left + right > maxl + maxr) {
maxl = left;
maxr = right;
imax = l[i] - k + 1;
jmax = r[i + 1];
}
}
cout << imax << " " << jmax;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000 * 1000 + 10;
const int mod = 1000 * 1000 * 1000 + 7;
const long long int inf = 1e18;
long long int p[N];
int mx[N];
long long int a[N];
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 1; i <= n; i++) {
p[i] = p[i - 1] + a[i];
}
for (int i = 1; i <= n - k + 1; i++) {
a[i] = p[i + k - 1] - p[i - 1];
mx[i] = mx[i - 1];
if (a[i] > a[mx[i - 1]]) {
mx[i] = i;
}
}
long long int ans = 0, x = 0, y = 0;
for (int i = n - k + 1; i >= k + 1; i--) {
if (ans <= a[i] + a[mx[i - k]]) {
ans = a[i] + a[mx[i - k]];
x = i;
y = mx[i - k];
}
}
cout << y << ' ' << x << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long sum[1000001];
int a[1000001];
long long dp[1000000][3];
int pos[1000000][3];
int l[10000000];
int main() {
int n;
int k;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 1; i <= n; i++) {
sum[i] = sum[i - 1] + a[i];
if (i > k) {
sum[i] -= a[i - k];
}
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= 2; j++) {
dp[i][j] = dp[i - 1][j];
if (i >= k && j > 0) {
pos[i][j] = pos[i - 1][j];
l[i] = l[i - 1];
if (dp[i][j] < dp[i - k][j - 1] + sum[i]) {
dp[i][j] = dp[i - k][j - 1] + sum[i];
pos[i][j] = i - k + 1;
if (j == 2) {
l[i] = pos[i - k][j - 1];
}
}
}
}
}
long long maxu = 0;
int le, r;
for (int i = 1; i <= n; i++) {
if (dp[i][2] > maxu) {
maxu = dp[i][2];
le = l[i];
r = pos[i][2];
}
}
cout << le << " " << r << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
long long s[211111], mx[211111];
int a[211111], bg[211111];
long long hf, ans;
int bhf, aa, bb;
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
s[i] = s[i - 1] + a[i];
}
for (int i = k; i <= n; ++i) {
if (s[i] - s[i - k] > mx[i - 1]) {
mx[i] = s[i] - s[i - k];
bg[i] = i - k + 1;
} else
mx[i] = mx[i - 1], bg[i] = bg[i - 1];
}
hf = 0;
for (int i = n - k + 1; i >= 1; --i) {
if (mx[i] + hf >= ans) {
long long tmp = ans;
ans = mx[i] + hf;
if (tmp < ans) aa = bg[i], bb = bhf;
if (bg[i] < aa || (bg[i] == aa && bhf < bb)) {
aa = bg[i], bb = bhf;
}
}
if (s[i + k - 1] - s[i - 1] >= hf) {
hf = s[i + k - 1] - s[i - 1];
bhf = i;
}
}
cout << aa << " " << bb << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int x[200010], m, p, q;
long long s[200010], a[200010], A[200010], b[200010], B[200010], C[200010];
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &x[i]);
for (int i = 1; i <= n; i++) s[i] = s[i - 1] + x[i];
for (int i = k; i <= n - k; i++) a[i] = s[i] - s[i - k];
for (int i = k + 1; i <= n - k + 1; i++) b[i] = s[i + k - 1] - s[i - 1];
A[k] = a[k];
for (int i = k + 1; i <= n - k; i++) A[i] = max(A[i - 1], a[i]);
B[n - k + 1] = b[n - k + 1];
for (int i = n - k; i >= (k + 1); i--) B[i] = max(B[i + 1], b[i]);
for (int i = k; i <= n - k; i++) C[i] = A[i] + B[i + 1];
long long ans = 0;
for (int i = k; i <= n - k; i++) ans = max(ans, C[i]);
for (int i = k; i <= n - k; i++) {
if (C[i] == ans) {
m = i;
break;
}
}
for (int i = k; i <= m; i++) {
if (a[i] == A[m]) {
p = i;
break;
}
}
for (int j = m + 1; j <= n - k + 1; j++) {
if (b[j] == B[m + 1]) {
q = j;
break;
}
}
printf("%d %d", p - k + 1, q);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<long long int> v(n, 0);
vector<long long int> p(n, 0);
cin >> v[0];
p[0] = v[0];
for (int i = 1; i < n; i++) {
cin >> v[i];
p[i] = p[i - 1] + v[i];
}
vector<long long int> I(n, 0);
I[0] = p[k - 1];
for (int i = k; i < n; i++) {
I[i - k + 1] = p[i] - p[i - k];
}
long long int maxs = -1;
int pos = -1;
vector<pair<long long int, int> > P(n, make_pair(-1, -1));
for (int i = k - 1; i < n; i++) {
if (I[i - k + 1] > maxs) {
maxs = I[i - k + 1];
pos = i - k + 1;
}
P[i] = make_pair(maxs, pos);
}
maxs = -1;
int a = -1, b = -1;
for (int i = k; i < n - k + 1; i++) {
if (P[i - 1].first + I[i] > maxs) {
b = i;
a = P[i - 1].second;
maxs = P[i - 1].first + I[i];
}
}
cout << a + 1 << " " << b + 1;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
int n, k;
long long a[N];
struct A {
long long v;
int p;
} ele, tr[N * 4];
void build(int L, int R, int o) {
if (L == R) {
ele.v = a[L];
ele.p = L;
tr[o] = ele;
} else {
int M = (L + R) / 2;
build(L, M, o << 1);
build(M + 1, R, o << 1 | 1);
ele.v = max(tr[o << 1].v, tr[o << 1 | 1].v);
ele.p = tr[o << 1].v >= tr[o << 1 | 1].v ? tr[o << 1].p : tr[o << 1 | 1].p;
tr[o] = ele;
}
}
A query(int x, int y, int L, int R, int o) {
if (x <= L && y >= R) {
return tr[o];
} else {
int M = (L + R) / 2;
A le, ri;
le.v = ri.v = -1;
if (x <= M) {
le = query(x, y, L, M, o << 1);
}
if (y > M) {
ri = query(x, y, M + 1, R, o << 1 | 1);
}
ele.v = max(le.v, ri.v);
ele.p = le.v >= ri.v ? le.p : ri.p;
return ele;
}
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; ++i) {
scanf("%lld", &a[i]);
}
for (int i = 1; i < n; ++i) {
a[i] += a[i - 1];
}
for (int i = n - 1; i >= k; --i) a[i] -= a[i - k];
for (int i = 0; i < k - 1; ++i) a[i] = 0;
build(0, n - 1, 1);
long long M = -1, x, y;
for (int i = 2 * k - 1; i < n; ++i) {
ele = query(0, i - k, 0, n - 1, 1);
if (a[i] + ele.v > M) {
M = a[i] + ele.v;
x = ele.p - k + 1;
y = i - k + 1;
}
}
cout << x + 1 << ' ' << y + 1 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void deb(T v[], long long n) {
if (false) cerr << "ARRAY : ";
long long i;
for (i = 0; i < n; i++)
if (false) cerr << v[i] << " ";
if (false) cerr << endl;
}
template <typename T>
void deb(set<T> s) {
if (false) cerr << "SET : ";
for (auto it : s)
if (false) cerr << it << " ";
if (false) cerr << endl;
}
template <typename T>
void deb(vector<T> v) {
if (false) cerr << "VECTOR : ";
long long i;
for (i = 0; i < v.size(); i++)
if (false) cerr << v[i] << " ";
if (false) cerr << endl;
}
template <typename T>
void deb(stack<T> s) {
if (false) cerr << "STACK : ";
stack<T> st = s;
while (st.size()) {
if (false) cerr << st.top() << " ";
st.pop();
};
if (false) cerr << endl;
}
template <typename T>
void deb(queue<T> q) {
if (false) cerr << "Queue : ";
queue<T> qq = q;
while (qq.size()) {
if (false) cerr << qq.front() << " ";
qq.pop();
};
if (false) cerr << endl;
}
void deb(map<long long, long long> m) {
if (false) cerr << "MAP : ";
for (auto it : m)
if (false) cerr << it.first << " : " << it.second << endl;
}
void deb(unordered_map<long long, long long> m) {
if (false) cerr << "MAP : ";
for (auto it : m)
if (false) cerr << it.first << " : " << it.second << endl;
}
template <typename T>
T abs(T a) {
return a < 0 ? a * -1 : a;
}
void swap(long long &x, long long &y);
bool isPrime(long long n);
long long power(long long x, long long y, long long p);
long long gcdExtended(long long a, long long b, long long *x, long long *y);
long long modInverse(long long b, long long m);
long long modDivide(long long a, long long b, long long m);
void simpleSieve(long long N, bool[]);
void PrimeDivisorSieve(long long N, long long prime[]);
class nCrModPClass {
public:
vector<long long> f, fi;
long long N;
long long MOD;
long long poww(long long a, long long b, long long m) {
long long ans = 1;
while (b) {
if (b & 1) ans = (ans * a) % m;
b /= 2;
a = (a * a) % m;
}
return ans;
}
long long modinvv(long long k) { return poww(k, MOD - 2, MOD); }
nCrModPClass(long long size, long long mod) {
MOD = mod;
N = size + 10;
f.resize(N);
fi.resize(N);
f[0] = f[1] = 1;
for (long long i = 2; i < N; i++) f[i] = (f[i - 1] * i) % MOD;
fi[N - 1] = modinvv(f[N - 1]);
for (long long i = N - 2; i >= 0; i--) fi[i] = (fi[i + 1] * (i + 1)) % MOD;
}
long long nCrModPfromClass(long long n, long long r) {
if (r > n) return 0;
long long ret = f[n];
ret %= MOD;
ret *= fi[r];
ret %= MOD;
ret *= fi[n - r];
ret %= MOD;
return ret;
}
};
long long testCases;
int main() {
long long n, k;
cin >> n >> k;
long long arr[n + 1], i, j;
for (i = 0; i < n; i++) cin >> arr[i];
long long pref[n - k + 1];
long long suf[n - k + 1];
long long sum = 0;
for (i = 0; i < k; i++) sum += arr[i];
pref[0] = sum;
suf[0] = sum;
for (i = 1; i < n - k + 1; i++) {
sum -= arr[i - 1];
sum += arr[i + k - 1];
pref[i] = sum;
suf[i] = sum;
}
long long indP[n - k + 1];
long long indS[n - k + 1];
indP[0] = 0;
indS[n - k] = n - k;
for (i = 1; i < n - k + 1; i++) {
if (pref[i] <= pref[i - 1]) {
pref[i] = pref[i - 1];
indP[i] = indP[i - 1];
} else if (pref[i] > pref[i - 1]) {
indP[i] = i;
}
}
for (i = n - k - 1; i >= 0; i--) {
if (suf[i] < suf[i + 1]) {
suf[i] = suf[i + 1];
indS[i] = indS[i + 1];
} else if (suf[i] >= suf[i + 1]) {
indS[i] = i;
}
}
long long ans = 0;
long long a, b;
for (i = 0; i < n - k + 1; i++) {
if (i + k < n - k + 1) {
if (ans < pref[i] + suf[i + k]) {
a = indP[i];
b = indS[i + k];
ans = pref[i] + suf[i + k];
}
}
}
cout << a + 1 << " " << b + 1 << endl;
return 0;
}
void simpleSieve(long long N, bool prime[]) {
long long i, j;
for (i = 0; i < N + 1; i++) prime[i] = true;
for (i = 2; i * i <= N; i++) {
if (prime[i]) {
for (j = i * i; j <= N; j += i) {
prime[j] = false;
}
}
}
}
void PrimeDivisorSieve(long long N, long long prime[]) {
long long i, j;
for (i = 0; i < N + 1; i++) prime[i] = i;
for (i = 2; i * i <= N; i++) {
if (prime[i] == i) {
for (j = i; j <= N; j += i) {
if (prime[j] == j) prime[j] = i;
}
}
}
}
void swap(long long &x, long long &y) {
x ^= y;
y ^= x;
x ^= y;
}
bool isPrime(long long n) {
if (n <= 1) return false;
for (long long i = 2; i < n; i++)
if (n % i == 0) return false;
return true;
}
long long power(long long x, long long y, long long p) {
long long 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 gcdExtended(long long a, long long b, long long *x, long long *y) {
if (a == 0) {
*x = 0, *y = 1;
return b;
}
long long x1, y1;
long long gcd = gcdExtended(b % a, a, &x1, &y1);
*x = y1 - (b / a) * x1;
*y = x1;
return gcd;
}
long long modInverse(long long b, long long m) {
long long x, y;
long long g = gcdExtended(b, m, &x, &y);
if (g != 1) return -1;
return (x % m + m) % m;
}
long long modDivide(long long a, long long b, long long m) {
a = a % m;
long long inv = modInverse(b, m);
if (inv == -1)
return -1;
else
return (inv * a) % m;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, x;
vector<int> v;
long long s[200010];
long long dp[200010][2];
long long path[200010][2];
long long solve(int curr, int u) {
if (curr > n - k || u >= 2) return 0;
long long& ret = dp[curr][u];
if (ret != -1) return ret;
long long nx = s[curr + k - 1];
if (curr > 0) nx -= s[curr - 1];
long long a = solve(curr + 1, u);
long long b = solve(curr + k, u + 1) + nx;
if (b >= a)
path[curr][u] = 2;
else
path[curr][u] = 1;
return ret = max(a, b);
}
void print(int curr, int u) {
if (curr > n - k || u >= 2) return;
if (path[curr][u] == -1)
return;
else if (path[curr][u] == 1)
print(curr + 1, u);
else {
printf("%d ", curr + 1);
print(curr + k, u + 1);
}
}
int main(void) {
cin >> n >> k;
memset(s, 0, sizeof s);
memset(dp, -1, sizeof dp);
memset(path, -1, sizeof path);
for (int i = 0; i < n; ++i) {
cin >> x;
v.push_back(x);
}
s[0] = (long long)v[0];
for (int i = 1; i < n; ++i) s[i] = (long long)s[i - 1] + (long long)v[i];
solve(0, 0);
print(0, 0);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long val[220000], sum[220000], best[2][220000];
int pos[2][220000];
int main() {
int n, k, i;
long long ans;
cin >> n >> k;
for (i = 1; i <= n; i++) cin >> val[i];
sum[1] = 0;
for (i = 1; i <= k; i++) sum[1] += val[i];
for (i = 2; i <= n - k + 1; i++)
sum[i] = sum[i - 1] - val[i - 1] + val[i + k - 1];
best[0][1] = sum[1];
pos[0][1] = 1;
for (i = 2; i <= n - k + 1; i++)
if (best[0][i - 1] >= sum[i]) {
best[0][i] = best[0][i - 1];
pos[0][i] = pos[0][i - 1];
} else {
best[0][i] = sum[i];
pos[0][i] = i;
}
best[1][n - k + 1] = sum[n - k + 1];
pos[1][n - k + 1] = n - k + 1;
for (i = n - k; i >= 1; i--)
if (best[1][i + 1] > sum[i]) {
best[1][i] = best[1][i + 1];
pos[1][i] = pos[1][i + 1];
} else {
best[1][i] = sum[i];
pos[1][i] = i;
}
ans = 0;
int a, b;
for (i = 1; i + k <= n - k + 1; i++)
if (ans < sum[i] + best[1][i + k]) {
ans = sum[i] + best[1][i + k];
a = i;
b = pos[1][i + k];
}
cout << a << " " << b << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 2e5 + 10;
typedef long long l_N[maxN];
int N, K;
l_N A, S, Fx, Gx;
long long ans;
long long sum(const int i) { return S[i + K - 1] - S[i - 1]; }
int main() {
cin >> N >> K;
for (int i = 0; i < N; i++) cin >> A[i + 1];
for (int i = 1; i <= N; i++) S[i] = S[i - 1] + A[i];
Fx[N - K + 1] = N - K + 1;
for (int i = N - K; i; i--)
Fx[i] = (sum(i) >= sum(Fx[i + 1])) ? i : Fx[i + 1];
for (int i = K; i <= N - K; i++)
ans = max(ans, S[i] - S[i - K] + sum(Fx[i + 1]));
for (int i = K; i <= N - K; i++)
if (ans == S[i] - S[i - K] + sum(Fx[i + 1])) {
cout << i - K + 1 << ' ' << Fx[i + 1];
return 0;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, k;
cin >> n >> k;
vector<long long> v(n);
for (auto &x : v) cin >> x;
vector<long long> pre(n), suf(n);
pre[0] = v[0];
for (long long i = 1; i < n; i++) {
pre[i] = v[i] + pre[i - 1];
}
suf[n - 1] = v[n - 1];
for (long long i = n - 2, j = 1; j < k; i--, j++) {
suf[i] = v[i] + suf[i + 1];
}
long long end = n - 1;
for (long long i = n - k - 1; i >= 0; i--) {
suf[i] = v[i] + suf[i + 1] - v[end];
end--;
}
for (long long i = n - k - 1; i >= 0; i--) {
suf[i] = max(suf[i], suf[i + 1]);
}
long long ans = 0, index_a, find_b;
for (long long i = 0; i <= n - 2 * k; i++) {
if (i == 0) {
ans = pre[i + k - 1] + suf[i + k];
find_b = suf[i + k];
index_a = i;
} else {
long long c = pre[i + k - 1] - pre[i - 1] + suf[i + k];
if (c > ans) {
ans = c;
find_b = suf[i + k];
index_a = i;
}
}
}
for (long long i = index_a + k; i <= n - k; i++) {
if (pre[i + k - 1] - pre[i - 1] == find_b) {
cout << (++index_a) << " " << i + 1 << endl;
break;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxv = 2e5 + 5;
long long num[maxv];
long long ksum[maxv];
int main() {
int n, k, t;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%d", &t);
num[i] = num[i - 1] + t;
if (i >= k) {
ksum[i] = num[i] - num[i - k];
}
}
int ml, mr, tl;
long long max1 = 0, max2 = 0;
for (int i = k; i + k <= n; i++) {
if (ksum[i] > max1) {
max1 = ksum[i];
tl = i;
}
if (ksum[i + k] + max1 > max2) {
max2 = ksum[i + k] + max1;
mr = i + k;
ml = tl;
}
}
cout << (ml - k + 1) << ' ' << (mr - k + 1) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
int n, k;
cin >> n >> k;
vector<long long int> A(n + 2, 0), dp1(n + 2, 0), dp2(n + 2, 0),
sum(n + 2, 0), idx(n + 2, 0);
for (int i = 1; i <= n; i++) {
cin >> A[i];
}
for (int i = 1; i <= n; i++) {
sum[i] = sum[i - 1] + A[i];
}
for (int i = 1; i <= n - k + 1; i++) {
dp1[i] = sum[i + k - 1] - sum[i - 1];
dp2[i] = dp1[i];
}
long long int fans = 0;
for (int i = n; i >= 1; i--) {
if (dp2[i] < dp2[i + 1]) {
dp2[i] = dp2[i + 1];
idx[i] = idx[i + 1];
} else {
idx[i] = i;
}
}
int aa, bb;
for (int i = 1; i < n - k + 1; i++) {
if (fans < dp1[i] + dp2[i + k]) {
fans = dp1[i] + dp2[i + k];
aa = i;
bb = idx[i + k];
}
}
cout << aa << " " << bb;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
const int N = 2 * 100000 + 9;
const double pi = acos(-1);
class cmp {
public:
bool operator()(long long &A, long long &B) { return A > B; }
};
bool by_sec(const pair<long long, long long> &a,
const pair<long long, long long> &b) {
return (a.second < b.second);
}
bool byth(const tuple<long long, long long, long double> &a,
const tuple<long long, long long, long double> &b) {
return (get<2>(a) < get<2>(b));
}
long double dist(complex<long double> a, complex<long double> b) {
return (long double)abs(a - b);
}
long long fact[1000009], inv[1000009];
long long fp(long long a, long long b) {
if (b == 0) return 1;
long long ans = fp(a, b / 2);
ans = (ans * ans) % mod;
if (b % 2 != 0) ans = (ans * (a % mod)) % mod;
return ans;
}
void FacInv(long long n) {
fact[0] = inv[0] = 1;
for (long long i = 1; i <= n; i++) {
fact[i] = ((i % mod) * fact[i - 1] % mod) % mod;
inv[i] = fp(fact[i], mod - 2);
}
}
long long ncr(long long n, long long r) {
return (((fact[n] * inv[r]) % mod) * inv[n - r]) % mod;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long max(long long a, long long b) {
if (a >= b)
return a;
else
return b;
}
long long min(long long a, long long b) {
if (a <= b)
return a;
else
return b;
}
vector<long long> seg(4 * N), ar(N, -1000000000000000009);
void build(long long p, long long l, long long r) {
if (l == r) {
seg[p] = ar[l];
return;
}
long long md = l + (r - l) / 2;
build(p * 2, l, md);
build(p * 2 + 1, md + 1, r);
seg[p] = max(seg[p * 2], seg[p * 2 + 1]);
}
long long n, k;
long long get_max(long long l, long long r, long long a = 0,
long long b = n - 1, long long p = 1) {
if (l <= a && b <= r) {
return seg[p];
} else if (r < a || l > b)
return -1000000000000000009;
long long md = a + (b - a) / 2;
return max(get_max(l, r, a, md, p * 2), get_max(l, r, md + 1, b, p * 2 + 1));
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
vector<long long> v(n);
vector<pair<long long, long long> > vp;
for (int i = 0; i < n; i++) {
cin >> v[i];
if (i) v[i] += v[i - 1];
}
for (int i = 0; i < n; i++) {
if (i + k - 1 >= n) break;
ar[i] = v[i + k - 1];
if (i) ar[i] -= v[i - 1];
}
build(1, 0, n - 1);
long long mx = 0, dx = 0, vx = 0;
for (int i = 0; i < n; i++) {
if (i + k >= n) break;
long long a, b;
a = ar[i];
b = get_max(i + k, n - 1);
if (a + b > mx) mx = a + b, dx = i, vx = b;
}
for (int i = dx + k; i < n; i++) {
if (ar[i] == vx) {
cout << dx + 1 << " " << i + 1 << "\n";
return 0;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int MAXN = 2 * (1e5) + 5;
const long long int MINN = 1e2;
const long long int inf = 1e9 + 7;
long long n, k, precalc[MAXN], a[MAXN], m2, i1 = -1, i2 = -1, prevsum = -1;
set<int>::iterator it;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin.exceptions(cin.failbit);
cin >> n >> k;
vector<long long> tmp;
i1 = n - 2 * k + 1;
i2 = n - k + 1;
for (int i = 1; i <= (n); ++i) {
cin >> a[i];
precalc[i] = a[i] + precalc[i - 1];
tmp.push_back(a[i]);
}
if (k == 1) {
int qw, we;
sort(tmp.begin(), tmp.end());
long long x = tmp[n - 1];
long long y = tmp[n - 2];
for (int i = 1; i <= (n); ++i) {
if (a[i] == x) {
qw = i;
a[i] = -1;
break;
}
}
for (int i = 1; i <= (n); ++i) {
if (a[i] == y) {
we = i;
break;
}
}
cout << min(qw, we) << " " << max(qw, we) << endl;
exit(0);
}
set<int> fin;
for (int i = n - 2 * k + 1; i >= (1); --i) {
long long s1 = precalc[i + k - 1] - precalc[i - 1];
long long s2 = precalc[i + 2 * k - 1] - precalc[i + k - 1];
if (s2 >= m2) {
m2 = s2;
fin.insert(i + k);
}
if (s1 + m2 >= prevsum) {
prevsum = s1 + m2;
i1 = i;
it = fin.begin();
i2 = *it;
}
}
cout << i1 << " " << i2 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 2e5 + 10;
typedef long long l_N[maxN];
int N, K, A[maxN];
l_N S, Fx, Gx;
long long ans;
long long sum(const int i) { return S[i + K - 1] - S[i - 1]; }
int main() {
cin >> N >> K;
for (int i = 0; i < N; i++) cin >> A[i + 1];
for (int i = 1; i <= N; i++) S[i] = S[i - 1] + A[i];
Fx[N - K + 1] = N - K + 1;
for (int i = N - K; i; i--)
Fx[i] = (sum(i) >= sum(Fx[i + 1])) ? i : Fx[i + 1];
for (int i = K; i <= N - K; i++)
ans = max(ans, S[i] - S[i - K] + sum(Fx[i + 1]));
for (int i = K; i <= N - K; i++)
if (ans == S[i] - S[i - K] + sum(Fx[i + 1])) {
cout << i - K + 1 << ' ' << Fx[i + 1];
return 0;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n, k;
vector<long long> arr, f, b;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k;
arr.assign(n + 1, 0);
f.assign(n + 1, 0);
b.assign(n + 2, 0);
for (int i = 1; i < n + 1; i++) cin >> arr[i], arr[i] += arr[i - 1];
int i;
for (i = k; i < n - k + 1; i++) f[i] = max(f[i - 1], arr[i] - arr[i - k]);
for (int i = n - k + 1; i > k; i--)
b[i] = max(b[i + 1], arr[i + k - 1] - arr[i - 1]);
long long ans = -1, idx = -1;
for (int i = k; i < n - k + 1; i++) {
long long tmp = f[i] + b[i + 1];
if (ans < tmp) ans = tmp, idx = i;
}
int x = -1;
for (int i = 1; i < idx - k + 2; i++) {
if (arr[i + k - 1] - arr[i - 1] == f[idx]) {
x = i;
break;
}
}
int y = -1;
for (int i = idx + 1; i < n - k + 2; i++) {
if (arr[i + k - 1] - arr[i - 1] == b[idx + 1]) {
y = i;
break;
}
}
cout << x << " " << y << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n, k;
long long f[N];
int g[N];
long long cost(int l) { return f[l + k - 1] - f[l - 1]; }
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
f[0] = 0;
for (int i = 1; i <= n; ++i) {
int x;
cin >> x;
f[i] = f[i - 1] + x;
}
g[k] = 1;
for (int i = k + 1; i <= n; ++i) {
g[i] = g[i - 1];
if (cost(g[i - 1]) < cost(i - k + 1)) {
g[i] = i - k + 1;
}
}
long long res = 0;
int u, v;
for (int i = k + 1; i <= n - k + 1; ++i) {
long long tmp = cost(g[i - 1]) + cost(i);
if (res < tmp) {
res = tmp;
u = g[i - 1];
v = i;
}
}
cout << u << ' ' << v << '\n';
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast", "unroll-loops", "omit-frame-pointer", "inline")
#pragma GCC option("arch=native", "tune=native", "no-zero-upper")
#pragma GCC target("avx2")
long long read() {
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;
}
using namespace std;
const int mod = 1000000007;
const int mxn = 4e5 + 7;
const int inf = 1000000007;
long long _, n, m, t, k, u, w, v, ans, cnt, ok, lim, len, tmp, last;
struct node {
int x, y, t;
};
string str;
long long a[mxn], b[mxn], c[mxn];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
while (cin >> n >> k) {
ans = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
a[i] += a[i - 1];
}
for (int i = n - k + 1; i > 0; i--) {
b[i] = max(b[i + 1], a[i + k - 1] - a[i - 1]);
c[i] = c[i + 1];
if (b[i] == a[i + k - 1] - a[i - 1]) c[i] = i;
}
int p1, p2;
for (int i = k; i <= n - k; i++) {
tmp = a[i] - a[i - k] + b[i + 1];
if (tmp > ans) ans = tmp, p1 = i - k + 1, p2 = c[i + 1];
}
cout << p1 << " " << p2 << endl;
}
}
bool isPrime(int num) {
if (num == 1) return 0;
if (num == 2 || num == 3) return 1;
if (num % 6 != 1 && num % 6 != 5) return 0;
int tmp = sqrt(num);
for (int i = 5; i <= tmp; i += 6)
if (num % i == 0 || num % (i + 2) == 0) return 0;
return 1;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mxN = 5e5 + 5;
const int mod = 1e9 + 7;
const int INF = 1e9;
long long dp[mxN][3];
long long pref[mxN];
void solve() {
int n, k = 2, m;
cin >> n >> m;
int x;
int arr[n + 1];
arr[0] = 0;
for (int i = 1; i <= n; i++) {
cin >> x;
arr[i] = x;
pref[i] = pref[i - 1] + x;
}
int a = 0, b = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= k; j++) {
dp[i][j] = dp[i - 1][j];
if (i >= j * m) {
if (dp[i][j] < dp[i - m][j - 1] + pref[i] - pref[i - m]) {
b = i - m;
dp[i][j] = dp[i - m][j - 1] + pref[i] - pref[i - m];
}
}
}
}
int sum = 0;
int need = dp[n][k] - (pref[b + m] - pref[b]);
for (int i = 0; i < b; i++) {
if (i < m - 1) {
sum += arr[i + 1];
} else {
sum -= arr[i + 1 - m];
sum += arr[i + 1];
if (sum == need) {
a = i - m + 1;
break;
}
}
}
cout << a + 1 << " " << b + 1 << endl;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout << setprecision(12) << fixed;
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200100;
const long long inf = 100000000000000001;
struct node {
long long val;
int index;
bool operator<(const node& a) const {
if (val == a.val) return index > a.index;
return val < a.val;
}
};
priority_queue<node> q;
int n, k, a[maxn];
long long sum[maxn];
int main() {
while (scanf("%d%d", &n, &k) != EOF) {
while (!q.empty()) q.pop();
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
sum[i] = sum[i - 1] + a[i];
}
long long ans = 0;
int ansa, ansb;
for (int i = k + 1; i <= n - k + 1; i++) {
q.push((node){sum[i - 1] - sum[i - 1 - k], i - k});
long long a = q.top().val;
long long b = sum[i + k - 1] - sum[i - 1];
if (ans < a + b) {
ansa = q.top().index;
ansb = i;
ans = a + b;
}
}
printf("%d %d\n", ansa, ansb);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5, MOD = 1e9 + 7;
long long n, k, x, cs[N], a, b;
vector<pair<long long, long long> > v;
int main() {
scanf("%lld%lld", &n, &k);
for (int i = 1; i <= n; ++i) {
scanf("%lld", &x);
cs[i] = cs[i - 1] + x;
}
long long mx1, mx2;
mx1 = mx2 = 0;
for (int i = 1; i <= n - k + 1; ++i) {
mx2 = cs[i + k - 1] - cs[i - 1];
v.push_back({mx2, -i});
}
sort(v.begin(), v.end());
vector<int> z;
for (int i = v.size() - 1; i > -1; i--) {
int idx = -v[i].second;
if (!a && (idx > k || n - (idx + k - 1) >= k)) {
a = idx;
continue;
} else if (a && (idx <= a - k || idx >= a + k)) {
b = idx;
break;
}
z.push_back(idx);
}
sort(z.begin(), z.end());
mx1 = (cs[a + k - 1] - cs[a - 1]) + (cs[b + k - 1] - cs[b - 1]);
for (int i = 0; i < z.size(); ++i) {
int d = lower_bound(z.begin() + i, z.end(), z[i] + k) - z.begin();
mx2 = 0;
int idx;
if (d && d < z.size()) {
for (int j = d; j < z.size(); ++j) {
if (mx2 < (cs[z[i] + k - 1] - cs[z[i] - 1]) +
(cs[z[j] + k - 1] - cs[z[j] - 1])) {
mx2 = (cs[z[i] + k - 1] - cs[z[i] - 1]) +
(cs[z[j] + k - 1] - cs[z[j] - 1]);
idx = j;
}
}
}
if (mx1 < mx2) {
a = z[i];
b = z[idx];
mx1 = mx2;
}
}
printf("%lld %lld", min(a, b), max(a, b));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 100100;
int a[2 * MAX_N], n, k;
long long sum[2 * MAX_N];
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
sum[i] = (i == 0 ? a[i] : sum[i - 1] + (long long)a[i]);
}
long long i2 = n - k, v2 = (sum[n - 1] - (n - k == 0 ? 0 : sum[n - k - 1]));
long long i1 = n - k - k,
v1 = (sum[n - k - 1] - (n - k - k == 0 ? 0 : sum[n - k - k - 1]));
long long ans1 = i1, ans2 = i2, ans = v1 + v2;
while ((--i1) >= 0) {
v1 = (sum[i1 + k - 1] - (i1 == 0 ? 0 : sum[i1 - 1]));
if (v2 <= (sum[i1 + k + k - 1] - (i1 + k == 0 ? 0 : sum[i1 + k - 1])))
i2 = i1 + k,
v2 = (sum[i1 + k + k - 1] - (i1 + k == 0 ? 0 : sum[i1 + k - 1]));
if (ans <= v1 + v2) ans1 = i1, ans2 = i2, ans = v1 + v2;
}
cout << ans1 + 1 << " " << ans2 + 1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long int i, j, k, n;
cin >> n >> k;
vector<long long int> v(n + 1);
for (i = 1; i < n + 1; i++) cin >> v[i];
vector<long long int> pre(n + 100, 0);
for (i = 1; i < n + 1; i++) pre[i] = pre[i - 1] + v[i];
vector<long long int> lau(n + 100);
for (i = 1; i < n - k + 2; i++) {
lau[i] = pre[i + k - 1] - pre[i - 1];
}
vector<long long int> lau_mx(n + 100), lau_mx_ind(n + 100);
for (i = n - k + 1; i > 0; i--) {
if (lau[i] >= lau_mx[i + 1]) {
lau_mx[i] = lau[i];
lau_mx_ind[i] = i;
} else
lau_mx[i] = lau_mx[i + 1], lau_mx_ind[i] = lau_mx_ind[i + 1];
}
long long int ans = 0, a, b;
for (i = 1; i < n - (2 * k) + 2; i++) {
if (ans < lau[i] + lau_mx[i + k]) {
ans = lau[i] + lau_mx[i + k];
a = i, b = lau_mx_ind[i + k];
}
}
cout << a << " " << b << '\n';
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long int t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void solve2() {
int n, k;
cin >> n >> k;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
vector<long long> pr(n + 1);
for (int i = 0; i < n; i++) {
pr[i + 1] = pr[i] + a[i];
}
auto sum = [&](int l, int r) { return pr[r + 1] - pr[l]; };
set<pair<long long, int>> st;
for (int i = k; i + k <= n; i++) {
st.insert({-sum(i, i + k - 1), i});
}
long long ans = 0;
pair<int, int> pos;
for (int i = 0; i + 2 * k <= n; i++) {
long long sa = sum(i, i + k - 1);
auto tp = *st.begin();
if (sa - tp.first > ans) {
ans = sa - tp.first;
pos = {i, tp.second};
};
int next = i + k;
st.erase({-sum(next, next + k - 1), next});
}
cout << pos.first + 1 << ' ' << pos.second + 1 << '\n';
}
void solve() {
int n, k;
cin >> n >> k;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
vector<long long> pr(n + 1);
for (int i = 0; i < n; i++) {
pr[i + 1] = pr[i] + a[i];
}
auto sum = [&](int l, int r) { return pr[r + 1] - pr[l]; };
long long ans = 0;
pair<int, int> pos;
long long bestb_val = sum(n - k, n - 1);
int bestb_pos = n - k;
for (int i = n - 2 * k; i >= 0; i--) {
long long sa = sum(i, i + k - 1);
if (sa + bestb_val >= ans) {
ans = sa + bestb_val;
pos = {i, bestb_pos};
}
int last = i + k - 1;
long long sm = sum(last, last + k - 1);
if (sm > bestb_val) {
bestb_val = sm;
bestb_pos = last;
} else if (sm == bestb_val && last < bestb_pos) {
bestb_pos = last;
}
}
cout << pos.first + 1 << ' ' << pos.second + 1 << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
long long absurdity[200010];
long long sum[200010];
int main(void) {
ios::sync_with_stdio(false);
cin >> n >> k;
int i, j;
for (i = 1; i <= n; ++i) {
cin >> absurdity[i];
}
for (i = 1; i <= k; ++i) {
sum[1] += absurdity[i];
}
for (i = 2; i + k - 1 <= n; ++i) {
sum[i] = sum[i - 1] + absurdity[i + k - 1] - absurdity[i - 1];
}
int a, b, bestj = n - k + 1;
long long best = -1, bestjsum = sum[n - k + 1];
for (i = n - 2 * k + 1; i >= 1; --i) {
if (bestjsum <= sum[i + k]) {
bestjsum = sum[i + k];
bestj = i + k;
}
if (sum[i] + bestjsum >= best) {
a = i;
b = bestj;
best = sum[i] + bestjsum;
}
}
cout << a << " " << b << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
long long ar[n];
for (int i = 0; i < n; i++) {
cin >> ar[i];
}
long long p[n + 1];
p[0] = 0;
for (int i = 1; i <= n; i++) {
p[i] = p[i - 1] + ar[i - 1];
}
int x = n - 2 * k + 1, y = n - k + 1;
long long bmax = p[n] - p[n - k], bi = n - k + 1;
long long cur;
long long ans = p[n - k] - p[n - 2 * k] + p[n] - p[n - k];
for (long long a = n - 2 * k; a >= 1; a--) {
cur = p[a + 2 * k - 1] - p[a + k - 1];
if (cur >= bmax) {
bmax = cur;
bi = a + k;
}
cur = p[a + k - 1] - p[a - 1] + bmax;
if (cur >= ans) {
ans = cur;
x = a;
y = bi;
}
}
cout << x << " " << y << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k, a[200005], b[200005], i, q, f, r, c[200005], d[200005],
e[200005], z[200005], s, p, g, ans1, ans2;
int main() {
cin >> n >> k;
for (i = 1; i <= n; i++) {
cin >> a[i];
b[i] = b[i - 1] + a[i];
}
for (i = 1; i <= ((n - k) + 1); i++) {
r = b[i + (k - 1)] - b[i - 1];
if (r > q) {
q = r;
f = i;
}
c[i] = q;
d[i] = f;
s = b[(n - i) + 1] - b[n - (k + i) + 1];
if (s >= p) {
p = s;
g = n - (k + i) + 2;
}
e[n - (k + i) + 2] = p;
z[n - (k + i) + 2] = g;
}
q = 0;
for (i = 1; i <= (n - k) + 1; i++) {
r = c[i] + e[i + k];
if (r > q) {
q = r;
ans1 = d[i];
ans2 = z[i + k];
}
}
cout << ans1 << " " << ans2;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[1000011];
long long dp[1000011];
long long dps[1000011];
long long dpp[1000011];
int main() {
long long n, k;
long long i;
scanf("%lld%lld", &n, &k);
for (i = 1; i <= n; i++) scanf("%lld", &a[i]);
long long s = 0;
for (i = 1; i <= k; i++) s += a[i];
dp[1] = s;
for (i = 2; i <= n - k + 1; i++) {
dp[i] = dp[i - 1] + a[i + k - 1] - a[i - 1];
}
long long maxx;
long long st;
maxx = dp[n - k + 1];
dpp[n - k + 1] = dp[n - k + 1];
dps[n - k + 1] = n - k + 1;
st = n - k + 1;
for (i = n - k; i >= 1; i--) {
if (dp[i] >= maxx) {
dpp[i] = dp[i];
dps[i] = i;
maxx = dpp[i];
st = i;
} else {
dpp[i] = maxx;
dps[i] = st;
}
}
maxx = -1;
long long sta, stb;
for (i = 1; i <= n - 2 * k + 1; i++) {
if (dp[i] + dpp[i + k] > maxx) {
sta = i;
stb = dps[i + k];
maxx = dp[i] + dpp[i + k];
}
}
cout << sta << " " << stb << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long ar[200010], n;
long long m1[200010], m2[200010];
int l1[200010], l2[200010];
long long temp = 0;
int k;
int a, b;
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%I64d", &ar[i]);
temp = 0;
int i;
for (i = 1; i <= k; i++) temp += ar[i];
m1[i - 1] = temp;
l1[i - 1] = 1;
for (i = k + 1; i <= n; i++) {
if (m1[i - 1] < temp - ar[i - k] + ar[i]) {
m1[i] = temp - ar[i - k] + ar[i];
l1[i] = i - k + 1;
} else {
m1[i] = m1[i - 1];
l1[i] = l1[i - 1];
}
temp = temp - ar[i - k] + ar[i];
}
temp = 0;
for (i = n; i >= n - k + 1; i--) temp += ar[i];
m2[i + 1] = temp;
l2[i + 1] = n - k + 1;
for (i = n - k; i >= 1; i--) {
if (m2[i + 1] <= temp - ar[i + k] + ar[i]) {
m2[i] = temp - ar[i + k] + ar[i];
l2[i] = i;
} else {
m2[i] = m2[i + 1];
l2[i] = l2[i + 1];
}
temp = temp - ar[i + k] + ar[i];
}
long long S = 0;
a = b = 0;
for (i = k; i <= n - k; i++) {
if (S == 0) {
S = m1[i] + m2[i + 1];
a = 1;
b = l2[i + 1];
} else {
if (m1[i] + m2[i + 1] > S) {
S = m1[i] + m2[i + 1];
a = l1[i];
b = l2[i + 1];
}
}
}
printf("%d %d\n", a, b);
return 0;
}
|
#include <bits/stdc++.h>
int data[200005], aidx[200005];
int64_t asum[200005];
int main() {
int n, k;
scanf("%d %d", &n, &k);
for (int _k = (0), _n = (n - 1), i = _k; i <= _n; ++i) {
scanf("%d", &data[i]);
}
int first = 0, last = k - 1, ma = 0;
int64_t sum = 0, msum = 0;
for (int _k = (first), _n = (last), i = _k; i <= _n; ++i) sum += data[i];
ma = first;
msum = sum;
aidx[last] = ma;
asum[last] = msum;
++last;
while (last < n) {
sum = sum + data[last] - data[first];
if (sum > msum) {
ma = first + 1;
msum = sum;
}
aidx[last] = ma;
asum[last] = msum;
++first;
++last;
}
first = k;
last = 2 * k - 1;
sum = 0;
for (int _k = (first), _n = (last), i = _k; i <= _n; ++i) sum += data[i];
int mb = first;
ma = aidx[first - 1];
int64_t mcsum = sum + asum[first - 1];
++last;
while (last < n) {
sum = sum + data[last] - data[first];
if (sum + asum[first] > mcsum) {
ma = aidx[first];
mcsum = sum + asum[first];
mb = first + 1;
}
++first;
++last;
}
printf("%d %d", ma + 1, mb + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string to_string(string s) { return "\"" + s + "\""; }
template <typename T>
string to_string(vector<T>);
template <typename U, typename V>
string to_string(pair<U, V> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename T>
string to_string(vector<T> v) {
string res = "[";
for (int i = 0; i < (int)v.size() - 1; i++) res += to_string(v[i]) + ", ";
if (!v.empty()) res += to_string(v.back());
res += "]";
return res;
}
long long int n, k;
long long int a[200100];
long long int sum[200100];
vector<pair<long long int, long long int> > f, g;
int main() {
scanf("%lld %lld", &n, &k);
f.assign((n + 2), pair<long long int, long long int>(0, 0));
g.assign((n + 2), pair<long long int, long long int>(0, 0));
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + a[i];
for (int i = k; i <= n; i++) {
f[i].first = max(f[i - 1].first, sum[i] - sum[i - k]);
if ((sum[i] - sum[i - k]) > f[i - 1].first) {
f[i].second = i - k + 1;
} else
f[i].second = f[i - 1].second;
}
for (int i = n - k + 1; i >= 1; i--) {
g[i].first = max(g[i + 1].first, sum[i + k - 1] - sum[i - 1]);
if ((sum[i + k - 1] - sum[i - 1]) >= g[i + 1].first) {
g[i].second = i;
} else
g[i].second = g[i + 1].second;
}
pair<int, int> ans;
long long int mx = 0;
for (int i = 1; i <= n; i++) {
if ((f[i].first + g[i + 1].first) > mx) {
mx = f[i].first + g[i + 1].first;
ans.first = f[i].second;
ans.second = g[i + 1].second;
}
}
printf("%d %d\n", ans.first, ans.second);
}
|
#include <bits/stdc++.h>
using namespace std;
int dx[8] = {0, 0, 1, -1, 1, 1, -1, -1};
int dy[8] = {1, -1, 0, 0, 1, -1, 1, -1};
template <typename T>
inline T BigMod(T A, T B) {
T ret = 1;
while (B) {
if (B & 1) ret = (ret * A) % 1000000007;
A = (A * A) % 1000000007;
B = B >> 1;
}
return ret;
}
template <typename T>
inline T InvMod(T A, T M = 1000000007) {
return BigMod(A, M - 2);
}
string tostring(long long int res) {
string curstr = "";
while (res != 0) {
long long int temp = (res % 10);
curstr += ((char)temp + '0');
res /= 10;
}
reverse(curstr.begin(), curstr.end());
return curstr;
}
long long int toint(string ss) {
long long int inss = 0;
for (int i = 0; i < ss.size(); i++) {
inss = (inss * 10) + ((int)(ss[i] - '0'));
}
return inss;
}
long long int ar[200005], cum[200005];
struct ST {
long long int val;
int ind;
};
ST rightt[2000005];
int main() {
int n, k;
scanf("%d", &n);
scanf("%d", &k);
for (int i = 1; i <= n; i++) {
scanf("%lld", &ar[i]);
cum[i] = cum[i - 1] + ar[i];
}
int in = 0;
for (int i = 1; i <= n; i++) rightt[i].val = -2e18;
for (int i = 1; i <= n; i++) {
int st = i - 1;
int en = i + k - 1;
if (en > n) {
break;
}
long long int now = cum[en] - cum[st];
if (now > rightt[en - 1].val) {
rightt[en].val = now;
rightt[en].ind = i;
} else
rightt[en] = rightt[en - 1];
}
int ans1, ans2;
long long int res = -2e15;
for (int i = n;; i--) {
int st = i - k;
int en = i;
if (st < 0) break;
if (st - k + 1 <= 0) break;
long long int now = cum[en] - cum[st];
long long int rt = rightt[st].val;
now += rt;
if (res <= now) {
res = now;
ans1 = rightt[st].ind;
ans2 = st + 1;
}
}
cout << ans1 << " " << ans2 << endl;
return 0;
}
|
#include <bits/stdc++.h>
const int MOD = 1000000007;
using namespace std;
const int MAX_N = 200005;
long long psum[MAX_N];
long long dp[MAX_N][2];
long long dp2[MAX_N][2];
int main() {
int n, k;
scanf("%d %d", &n, &k);
int a[n + 1];
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
psum[i] = psum[i - 1] + a[i];
}
for (int i = k; i <= n; i++) {
if (psum[i] - psum[i - k] > dp[i - 1][0]) {
dp[i][0] = psum[i] - psum[i - k];
dp[i][1] = i - k + 1;
} else {
dp[i][0] = dp[i - 1][0];
dp[i][1] = dp[i - 1][1];
}
}
pair<int, int> ans;
for (int sE = 2 * k; sE <= n; sE++) {
if (psum[sE] - psum[sE - k] + dp[sE - k][0] > dp2[sE - 1][0]) {
dp2[sE][0] = psum[sE] - psum[sE - k] + dp[sE - k][0];
dp2[sE][1] = sE - k + 1;
ans = {dp[sE - k][1], sE - k + 1};
} else {
dp2[sE][0] = dp2[sE - 1][0];
dp2[sE][1] = dp2[sE - 1][1];
}
}
cout << ans.first << " " << ans.second << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
long long int arr[400] = {0};
int main() {
ios::sync_with_stdio(0);
int n, k;
cin >> n >> k;
long long int arr[n + 1];
long long int answer[n + 1];
long long int dp[n + 1];
for (int i = 0; i < n; i++) cin >> arr[i];
long long int sum = 0;
for (int i = 0; i < k; i++) sum += arr[i];
dp[0] = sum;
answer[0] = 0;
for (int i = 1; i < n - k + 1; i++) {
sum -= arr[i - 1];
sum += arr[i + k - 1];
if (sum > dp[i - 1]) {
answer[i] = i;
dp[i] = sum;
} else {
answer[i] = answer[i - 1];
dp[i] = dp[i - 1];
}
}
for (int i = 0; i < n - k + 1; i++) {
}
sum = 0;
long long int best = 0;
int a, b;
for (int i = n - 1; i >= n - k; i--) {
sum += arr[i];
}
best = sum + dp[n - k - k];
a = answer[n - k - k], b = n - k;
for (int i = n - k - 1; i >= k; i--) {
sum -= arr[i + k];
sum += arr[i];
if (sum + dp[i - k] >= best) {
best = sum + dp[i - k];
b = i;
a = answer[i - k];
}
}
cout << a + 1 << " " << b + 1;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int SET(int n, int pos) { return n = n | (1 << pos); }
int RESET(int n, int pos) { return n = n & ~(1 << pos); }
int CHECK(int n, int pos) { return (bool)(n & (1 << pos)); }
int str2int(string s) {
stringstream ss(s);
int x;
ss >> x;
return x;
}
string int2str(int a) {
stringstream ss;
ss << a;
string str = ss.str();
return str;
}
string char2str(char a) {
stringstream ss;
ss << a;
string str = ss.str();
return str;
}
long long int bigMod(long long int n, long long int power, long long int MOD) {
if (power == 0) return 1;
if (power % 2 == 0) {
long long int ret = bigMod(n, power / 2, MOD);
return ((ret % MOD) * (ret % MOD)) % MOD;
} else
return ((n % MOD) * (bigMod(n, power - 1, MOD) % MOD)) % MOD;
}
long long int modInverse(long long int n, long long int MOD) {
return bigMod(n, MOD - 2, MOD);
}
int POW(int x, int y) {
int res = 1;
for (; y;) {
if ((y & 1)) {
res *= x;
}
x *= x;
y >>= 1;
}
return res;
}
int inverse(int x) {
double p = ((double)1.0) / x;
return (p) + 1e-9;
}
int gcd(int a, int b) {
while (b) b ^= a ^= b ^= a %= b;
return a;
}
int nC2(int n) { return n * (n - 1) / 2; }
long long int MOD(long long int n, long long int mod) {
if (n >= 0)
return n % mod;
else if (-n == mod)
return 0;
else
return mod + (n % mod);
}
int n, k;
long long int data[200005], dp[200005][3][3], cum[200005];
vector<int> ans;
long long int call(int i, int cnt, int ff) {
if (i > n) {
if (cnt >= 2) return 0;
return -1000000000;
}
long long int &ret = dp[i][cnt][ff];
if (ret != -1) return ret;
ret = 0;
if (cnt >= 2) {
ret = call(i + 1, cnt, 0);
} else {
if (i + k - 1 <= n) {
long long int val = cum[i + k - 1] - cum[i - 1];
ret = max(ret, call(i + k, cnt + 1, 1) + val);
}
ret = max(ret, call(i + 1, cnt, 0));
}
return ret;
}
void find_sol(int i, int cnt) {
if (i > n) {
return;
}
if (cnt >= 2)
find_sol(i + 1, cnt);
else {
if (i + k - 1 <= n) {
long long int val = cum[i + k - 1] - cum[i - 1];
if (dp[i + k][cnt + 1][1] + val >= dp[i + 1][cnt][0]) {
ans.push_back(i);
find_sol(i + k, cnt + 1);
} else {
find_sol(i + 1, cnt);
}
} else {
find_sol(i + 1, cnt);
}
}
return;
}
int main() {
int t, cas = 0;
scanf("%d %d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%lld", &data[i + 1]);
}
cum[0] = 0;
for (int i = 1; i <= n; i++) cum[i] = cum[i - 1] + data[i];
memset(dp, -1, sizeof(dp));
call(1, 0, 0);
find_sol(1, 0);
printf("%d %d\n", ans[0], ans[1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
cin >> n >> k;
long long arr[n];
for (long long i = 0; i < n; i++) cin >> arr[i];
long long arrPre[n];
arrPre[0] = arr[0];
for (long long i = 1; i < n; i++) arrPre[i] = arr[i] + arrPre[i - 1];
vector<long long> tillNextK(n, 0);
for (long long i = 0; i + k - 1 < n; i++) {
long long id1 = 0;
long long id2 = arrPre[i + k - 1];
if (i > 0) id1 = arrPre[i - 1];
tillNextK[i] = id2 - id1;
}
vector<long long> fromRight(n, 0);
long long maxVal = -1;
long long idx = n - 1;
for (long long i = n - 1; i >= 0; i--) {
if (maxVal <= tillNextK[i]) {
maxVal = tillNextK[i];
idx = i;
}
fromRight[i] = idx;
}
maxVal = -1;
long long a = 0;
long long b = 0;
for (long long i = 0; i + k < n; i++) {
if (maxVal < (tillNextK[i] + tillNextK[fromRight[i + k]])) {
a = i;
b = fromRight[i + k];
maxVal = (tillNextK[i] + tillNextK[fromRight[i + k]]);
}
}
cout << a + 1 << " " << b + 1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000;
const double eps = 1e-9;
long long INF = 1e9 + 7;
bool comp(pair<int, double> a, pair<int, double> b) {
if (a.second > b.second)
return true;
else if (a.second < b.second)
return false;
else
return a.first < b.first;
}
struct compare {
bool operator()(const int& l, const int& r) { return l > r; }
};
void read(string str, int node) {
stringstream ss;
int number;
ss << str;
while (ss >> number) cout << number << endl;
}
int dx[] = {1, -1, 0, 0, 1, -1, 1, -1};
int dy[] = {0, 0, 1, -1, 1, -1, -1, 1};
long long fp(long long b, long long p) {
if (p == 0) return 1;
if (p % 2 == 0) return fp((b * b) % INF, p / 2);
return (fp(b, p - 1) * b) % INF;
}
long long read_binary(string s) {
unsigned long long x = 0, tmp = 1;
for (int i = s.size() - 1; i >= 0; i--) {
x = (x + tmp * (s[i] - '0')) % INF;
tmp = (tmp * 2) % INF;
}
return x;
}
long long com(long long x, long long y) {
long long sum = 1;
for (int i = 1; i <= y; i++) {
sum *= x;
x--;
sum /= i;
}
return sum;
}
int main() {
long long n, k;
cin >> n >> k;
vector<long long> a(n + 1);
for (int i = 1; i <= n; i++) cin >> a[i];
partial_sum(a.begin(), a.end(), a.begin());
vector<unsigned long long> seg;
for (int i = k; i <= n; i++) seg.push_back(a[i] - a[i - k]);
unsigned long long sum = 0, csu = 0;
int l = -1, r = -1, c = -1;
for (int i = k, j = 0; i < seg.size(); i++, j++) {
if (seg[j] > sum) c = j, sum = seg[j];
if (csu < (sum + seg[i])) {
csu = sum + seg[i];
l = c;
r = i;
}
}
cout << ++l << ' ' << ++r << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cout << name << " : " << arg1 << "\n";
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cout.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
int mpow(int base, int exp);
void ipgraph(int n, int m);
void dfs(int u, int par);
const int N = 5000, M = 100005;
vector<long long> g[N];
int a[N];
void solve() {
long long i, j, n, m, k, a, b, c;
cin >> n >> k;
vector<long long> arr(n);
for (i = 0; i < n; ++i) cin >> arr[i];
vector<long long> window(n);
i = 0, m = 0;
for (i = 0; i < k; ++i) m += arr[i];
j = k;
i = 1;
window[0] = m;
while (j < n) {
m -= arr[i - 1];
m += arr[j];
window[i] = m;
i++, j++;
}
long long m1 = -1, m2 = -1, temp, ans1, ans2;
for (i = n - 2 * k; i >= 0; i--) {
long long s1 = window[i + k];
if (s1 >= m1) {
temp = i + k;
m1 = s1;
}
long long s2 = window[i] + m1;
if (s2 >= m2) {
ans1 = i, ans2 = temp;
m2 = s2;
}
}
cout << ans1 + 1 << " " << ans2 + 1;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
{ solve(); }
}
int mpow(int base, int exp) {
base %= ((int)1e9 + 7);
int result = 1;
while (exp > 0) {
if (exp & 1) result = ((long long)result * base) % ((int)1e9 + 7);
base = ((long long)base * base) % ((int)1e9 + 7);
exp >>= 1;
}
return result;
}
void ipgraph(int n, int m) {
int i, u, v;
while (m--) {
cin >> u >> v;
u--, v--;
g[u].push_back(v);
g[v].push_back(u);
}
}
void dfs(int u, int par) {
for (int v : g[u]) {
if (v == par) continue;
dfs(v, u);
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long int n, k, w[200001], a, b, bb, s1, s2, v[200001];
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> w[i];
long long int t = 1;
for (; t <= k; t++) v[1] += w[t];
t = k + 1;
while (t <= n) {
v[t - k + 1] = v[t - k] - w[t - k] + w[t];
t++;
}
for (int i = n - 2 * k + 1; i >= 1; i--) {
if (v[i + k] >= s1) s1 = v[i + k], b = i + k;
if (s2 <= s1 + v[i]) s2 = s1 + v[i], a = i, bb = b;
}
cout << a << " " << bb;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
long long ret[10][200005];
long long dp(long long x, long long m) {
long long &u = ret[x][m];
if (m == 0) return 1;
if (u != -1) {
return u;
}
if (x == 9) {
u = dp(0, m - 1) + dp(1, m - 1);
u %= MOD;
} else
u = dp(x + 1, m - 1);
u %= MOD;
return u;
}
int bb[400005];
int best[400005];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long a, b;
cin >> a >> b;
vector<long long> v;
vector<pair<long long, long long>> p;
vector<long long> pref;
for (long long i = 1; i <= a; i++) {
cin >> bb[i];
}
pref.push_back(0);
for (long long i = 1; i <= a; i++) {
pref.push_back(bb[i] + pref[i - 1]);
}
vector<pair<long long, long long>> best(a + 5);
for (int i = a - b + 1; i >= 1; i--) {
long long segment = pref[i + b - 1] - pref[i - 1];
if (best[i + 1].first <= segment) {
best[i] = {segment, i};
} else {
best[i] = best[i + 1];
}
}
pair<int, int> answer;
long long total = 0;
for (int i = a - b * 2 + 1; i >= 1; i--) {
long long segment = pref[i + b - 1] - pref[i - 1];
long long u = best[i + b].first + segment;
if (u >= total) {
long long aa = i;
long long bd = best[i + b].second;
answer = {aa, bd};
total = u;
}
}
cout << answer.first << " " << answer.second << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int k;
cin >> n >> k;
long long array[n];
long long w[n - k + 1];
long long m[n - k + 1];
for (int i = 0; i < n; i++) cin >> array[i];
w[0] = 0;
for (int i = 0; i < k; i++) w[0] += array[i];
int end = k;
int beg = 0;
int i = 1;
while (end < n) {
w[i] = w[i - 1] + array[end++] - array[beg++];
i++;
}
m[n - k] = n - k;
for (i = n - k - 1; i >= 0; i--) {
if (w[i] >= w[m[i + 1]])
m[i] = i;
else
m[i] = m[i + 1];
}
long long maxC = 0;
int a = 0;
int b = 0;
for (i = 0; i < n - k; i++) {
if (i + k < (n - k + 1)) {
if (maxC < w[i] + w[m[i + k]]) {
maxC = w[i] + w[m[i + k]];
a = i;
b = m[i + k];
}
}
}
cout << a + 1 << " " << b + 1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
priority_queue<int, vector<int>, greater<int> > Q;
const int INF = 1e9 + 9;
long int pow(long int a, long int b, int m) {
a %= m;
long long res = 1;
while (b > 0) {
if (b & 1) res = res * a % m;
a = a * a % m;
b >>= 1;
}
return res;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long n, k;
cin >> n >> k;
long long ar[n];
for (long long i = 0; i < n; i++) {
cin >> ar[i];
}
vector<long long> v;
long long sum = 0;
for (long long i = 0; i < k; i++) {
sum += ar[i];
}
v.push_back(sum);
for (long long i = k; i < n; i++) {
sum -= ar[i - k];
sum += ar[i];
v.push_back(sum);
}
long long x = 0;
long long y = 0;
long long ans = 0;
long long ax = 0;
long long by = 0;
for (int i = 0; i + k < v.size(); i++) {
if (v[i] > x) {
x = v[i];
y = i;
}
long long temp = x + v[i + k];
if (temp > ans) {
ans = temp;
ax = y;
by = i + k;
}
}
cout << ax + 1 << " " << by + 1;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[200005];
long long sum[200005];
long long fl[200005];
long long fr[200005];
int pathl[200005];
int pathr[200005];
int main() {
int n, k;
cin >> n >> k;
sum[0] = 0;
for (int i = 1; i <= n; i++) {
scanf("%I64d", &a[i]);
sum[i] = sum[i - 1] + a[i];
}
fl[k] = sum[k];
pathl[k] = 1;
for (int i = k + 1; i <= n; i++) {
fl[i] = fl[i - 1];
pathl[i] = pathl[i - 1];
if (sum[i] - sum[i - k] > fl[i]) {
fl[i] = sum[i] - sum[i - k];
pathl[i] = i - k + 1;
}
}
fr[n - k + 1] = sum[n] - sum[n - k];
pathr[n - k + 1] = n - k + 1;
for (int i = n - k; i >= 1; i--) {
fr[i] = fr[i + 1];
pathr[i] = pathr[i + 1];
if (sum[i + k - 1] - sum[i - 1] >= fr[i]) {
fr[i] = sum[i + k - 1] - sum[i - 1];
pathr[i] = i;
}
}
long long ans = 0;
int ansa = 0, ansb = 0;
for (int i = k; i <= n - k; i++)
if (fl[i] + fr[i + 1] > ans) {
ans = fl[i] + fr[i + 1];
ansa = pathl[i];
ansb = pathr[i + 1];
}
cout << ansa << " " << ansb << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 222222;
int n, k;
int a[N];
long long s[2][N];
pair<long long, int> dp[N];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
s[0][i] = s[0][i - 1] + a[i];
}
for (int i = n; i >= 1; --i) {
s[1][i] = s[1][i + 1] + a[i];
}
for (int i = n - k + 1; i >= 1; --i) {
long long t = s[1][i] - s[1][i + k];
if (t >= dp[i + 1].first) {
dp[i] = {t, i};
} else {
dp[i] = dp[i + 1];
}
}
pair<int, int> ans;
long long mx = 0;
for (int i = k; i <= n - k; ++i) {
if (s[0][i] - s[0][i - k] + dp[i + 1].first > mx) {
mx = s[0][i] - s[0][i - k] + dp[i + 1].first;
ans = {i - k + 1, dp[i + 1].second};
}
}
cout << ans.first << ' ' << ans.second << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void FASTIO() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
long long n, k;
string s;
void solve() {
cin >> n >> k;
long long sum1 = 0;
long long sum2 = 0;
vector<long long> v(n);
for (long long i = 0; i < n; i++) {
cin >> v[i];
if (i < k) {
sum1 += v[i];
} else if (i >= k && i < 2 * k) {
sum2 += v[i];
}
}
long long first = sum1;
long long sec = sum2;
long long maxi = sum1 + sum2;
long long i = k;
long long j = 2 * k;
long long fi = 0;
long long fj = k;
long long a = 1;
long long temp = 1;
long long b = k + 1;
while (j < n) {
first -= v[fi];
first += v[i];
sec -= v[fj];
sec += v[j];
fi++;
fj++;
if (first > sum1) {
sum1 = first;
temp = fi + 1;
}
if (sum1 + sec > maxi) {
maxi = sum1 + sec;
a = temp;
b = fj + 1;
}
i++;
j++;
}
cout << a << " " << b << "\n";
}
int32_t main() {
FASTIO();
{ solve(); }
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.