text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int a[N];
int t[N];
struct k_max {
int sum_len;
int sum_t;
int k;
set<pair<int, int> > big;
set<pair<int, int> > small;
k_max() {}
k_max(int _k) : sum_len(0), sum_t(0), k(_k) {}
void add(int m) {
sum_len += (a[m] + 1) / 2;
sum_t += t[m];
big.insert(pair<int, int>(a[m], m));
if (big.size() > k) {
auto p = big.begin();
sum_len -= (p->first + 1) / 2 - p->first;
small.insert(*p);
big.erase(p);
}
}
void del(int m) {
auto it = big.find(pair<int, int>(a[m], m));
if (it != big.end()) {
sum_t -= t[m];
sum_len -= (it->first + 1) / 2;
big.erase(it);
if (!small.empty()) {
auto it = small.end();
it--;
sum_len -= it->first;
sum_len += (it->first + 1) / 2;
big.insert(*it);
small.erase(it);
}
} else {
sum_t -= t[m];
sum_len -= a[m];
small.erase(pair<int, int>(a[m], m));
}
}
};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(nullptr);
int n, w, k;
cin >> n >> w >> k;
for (int i = 0; i < n; i++) cin >> t[i];
for (int i = 0; i < n; i++) cin >> a[i];
k_max T(w);
int l = 0;
int r = 0;
int ans = 0;
while (true) {
if (T.sum_len <= k) {
ans = max(ans, T.sum_t);
if (r != n) {
T.add(r);
r++;
} else {
break;
}
} else {
if (l != n) {
T.del(l);
l++;
} else {
break;
}
}
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3fffffff;
const int SINF = 0x7fffffff;
const long long LINF = 0x3fffffffffffffff;
const long long SLINF = 0x7fffffffffffffff;
const int MAXN = 200007;
const int MAXS = MAXN * 4;
const int MAX = 262144;
class stT {
public:
stT() {
memset(data, 0, sizeof(data));
memset(sum, 0, sizeof(sum));
for (int i = 0; i < MAXS; ++i)
maxi[i] = make_pair(0, 0), mini[i] = make_pair(SINF, 0);
memset(wc, false, sizeof(wc));
}
pair<int, int> getmax() { return maxi[1]; }
pair<int, int> getmin() { return mini[1]; }
int getsum() { return sum[1]; }
void setwc(int pos, bool val, int now = 1, int l = 1, int r = MAX) {
if (!pos) return;
if (pos == l && pos == r) {
wc[pos] = val;
if (val)
mini[now] = make_pair(data[now], pos), maxi[now] = make_pair(0, 0),
sum[now] = (data[now] + 1) >> 1;
else
mini[now] = make_pair(SINF, 0), maxi[now] = make_pair(data[now], pos),
sum[now] = data[now];
} else if (pos >= l && pos <= r) {
int mid = (l + r) >> 1;
setwc(pos, val, now << 1, l, mid);
setwc(pos, val, now << 1 ^ 1, mid + 1, r);
sum[now] = sum[now << 1] + sum[now << 1 ^ 1];
maxi[now] =
(((maxi[now << 1]) > (maxi[now << 1 ^ 1])) ? (maxi[now << 1])
: (maxi[now << 1 ^ 1]));
mini[now] =
(((mini[now << 1]) < (mini[now << 1 ^ 1])) ? (mini[now << 1])
: (mini[now << 1 ^ 1]));
}
}
void setpl(int pos, bool val, int now = 1, int l = 1, int r = MAX) {
if (pos == l && pos == r) {
if (val) {
sum[now] = data[now];
maxi[now] = make_pair(data[now], pos);
} else {
sum[now] = 0;
wc[pos] = false;
mini[now] = make_pair(SINF, 0), maxi[now] = make_pair(0, 0);
}
} else if (pos >= l && pos <= r) {
int mid = (l + r) >> 1;
setpl(pos, val, now << 1, l, mid);
setpl(pos, val, now << 1 ^ 1, mid + 1, r);
sum[now] = sum[now << 1] + sum[now << 1 ^ 1];
maxi[now] =
(((maxi[now << 1]) > (maxi[now << 1 ^ 1])) ? (maxi[now << 1])
: (maxi[now << 1 ^ 1]));
mini[now] =
(((mini[now << 1]) < (mini[now << 1 ^ 1])) ? (mini[now << 1])
: (mini[now << 1 ^ 1]));
}
}
void setd(int pos, int val, int now = 1, int l = 1, int r = MAX) {
if (pos == l && pos == r)
data[now] = val;
else if (pos >= l && pos <= r) {
int mid = (l + r) >> 1;
setd(pos, val, now << 1, l, mid);
setd(pos, val, now << 1 ^ 1, mid + 1, r);
}
}
private:
int data[MAXS], sum[MAXS];
pair<int, int> maxi[MAXS], mini[MAXS];
bool wc[MAXS];
} st;
int n, w, k;
int a[MAXN], t[MAXN];
int pre[MAXN];
bool wc[MAXN];
void init();
void input();
void work();
int main() {
init();
input();
work();
}
void init() { ios::sync_with_stdio(false); }
void input() {
scanf("%d%d%d", &n, &w, &k);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (int i = 1; i <= n; ++i) scanf("%d", &t[i]);
}
void work() {
pre[0] = 0;
for (int i = 1; i <= n; ++i) pre[i] = pre[i - 1] + a[i];
t[n + 1] = 0;
for (int i = 1; i <= n + 1; ++i) st.setd(i, t[i]);
int l = 0, r = 0, ans = 0;
pair<int, int> nm;
memset(wc, false, sizeof(wc));
while (1) {
while (r <= n && st.getsum() <= k) {
++r;
st.setpl(r, true);
if (r - l <= w)
st.setwc(r, true), wc[r] = true;
else {
nm = st.getmin();
if (t[r] > nm.first) {
st.setwc(nm.second, false), wc[nm.second] = false;
st.setwc(r, true), wc[r] = true;
}
}
}
ans = (((ans) > (pre[r - 1] - pre[l])) ? (ans) : (pre[r - 1] - pre[l]));
if (r > n) break;
++l;
st.setpl(l, false);
if (wc[l]) {
wc[l] = false;
nm = st.getmax();
st.setwc(nm.second, true);
wc[nm.second] = true;
}
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int const N = 2e5 + 20;
int n, w, k, a[N], t[N], part[N], p = -1, ans, sum1, sum2;
set<pair<int, int> > s1, s2;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> w >> k;
for (int i = 0; i < n; i++) cin >> a[i], part[i + 1] = part[i] + a[i];
for (int i = 0; i < n; i++) cin >> t[i];
for (int i = 0; i < n; i++) {
p = max(p, i - 1);
while (p < n && sum1 - sum2 <= k) {
p++;
sum1 += t[p];
if ((int)s1.size() == w && t[p] / 2 <= s1.begin()->first)
s2.insert({t[p] / 2, p});
else {
s1.insert({t[p] / 2, p});
sum2 += t[p] / 2;
if ((int)s1.size() > w) {
pair<int, int> val = *s1.begin();
sum2 -= val.first;
s2.insert(val);
s1.erase(val);
}
}
}
ans = max(ans, part[p] - part[i]);
if (p <= i) continue;
{
sum1 -= t[i];
if (s2.find({t[i] / 2, i}) != s2.end())
s2.erase({t[i] / 2, i});
else {
sum2 -= t[i] / 2;
s1.erase({t[i] / 2, i});
if ((int)s2.size()) {
pair<int, int> val = *s2.rbegin();
sum2 += val.first;
s1.insert(val), s2.erase(val);
}
}
}
}
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5;
int n, m, lim, A[maxn], T[maxn];
struct cmpt {
bool operator()(int i, int j) const {
return T[i] != T[j] ? T[i] < T[j] : i < j;
}
};
set<int, cmpt> half;
set<int, cmpt> full;
int suma, sumt;
void init(void) {
suma = sumt = 0;
half.clear();
full.clear();
}
bool try_insert(int i) {
int sumt0 = sumt;
half.insert(i);
sumt += (T[i] + 1) >> 1;
if ((int)half.size() > m) {
int len = T[*half.begin()];
sumt += len >> 1;
}
if (sumt > lim) {
half.erase(i);
sumt = sumt0;
return false;
} else {
if ((int)half.size() > m) {
full.insert(*half.begin());
half.erase(half.begin());
}
suma += A[i];
return true;
}
}
void remove(int i) {
if (full.count(i)) {
full.erase(i);
suma -= A[i];
sumt -= T[i];
} else {
half.erase(i);
suma -= A[i];
sumt -= (T[i] + 1) >> 1;
if (!full.empty()) {
half.insert(*--full.end());
int len = T[*--full.end()];
sumt -= len >> 1;
full.erase(--full.end());
}
}
}
int solve(void) {
int L = 0, R = 0, ans = 0;
init();
while (L < n) {
while (R < n && try_insert(R)) ++R;
ans = max(ans, suma);
if (R > L)
remove(L++);
else
++L, ++R;
}
return ans;
}
int main(void) {
while (~scanf("%d%d%d", &n, &m, &lim)) {
for (int i = 0; i < n; ++i) scanf("%d", &A[i]);
for (int i = 0; i < n; ++i) scanf("%d", &T[i]);
printf("%d\n", solve());
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
multiset<int> s1, s2;
int n, w, k;
int a[maxn], t[maxn];
bool add[maxn];
int happy, usetime;
bool insert(int idx) {
int pt = t[idx], ph = a[idx];
if (s2.size() < w) {
int pt2 = pt + 1 >> 1;
if (usetime + pt2 > k) return 0;
usetime += pt2;
happy += ph;
s2.insert(pt);
return 1;
}
auto it = s2.begin();
if (pt > *it) {
int tmp = usetime - (*it + 1) / 2 + *it + (pt + 1) / 2;
if (tmp > k) return 0;
usetime = tmp;
s1.insert(*it);
s2.erase(it);
s2.insert(pt);
happy += ph;
return 1;
} else {
if (usetime + pt > k) return 0;
usetime += pt;
happy += ph;
s1.insert(pt);
return 1;
}
}
void remove(int idx) {
int pt = t[idx], ph = a[idx];
happy -= ph;
auto it = s2.find(pt);
if (it != s2.end()) {
usetime -= (pt + 1) / 2;
s2.erase(it);
if (s1.size()) {
it = s1.end();
it--;
pt = *it;
usetime -= pt;
usetime += (pt + 1) / 2;
s1.erase(it);
s2.insert(pt);
}
} else {
usetime -= pt;
it = s1.find(pt);
s1.erase(it);
}
}
int main() {
scanf("%d %d %d", &n, &w, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) scanf("%d", &t[i]);
int ans = 0;
int last = 1;
for (int i = 1; i <= n; i++) {
if (add[i - 1]) remove(i - 1);
if (last < i) last = i;
while (last <= n && insert(last)) {
add[last] = 1;
last++;
}
ans = max(ans, happy);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long t = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c <= '9' && c >= '0') t = t * 10LL + c - 48LL, c = getchar();
return t * f;
}
multiset<int> alr;
multiset<int> non;
multiset<int>::iterator tmp;
int n, k, mx, v[500001], t[500001], ans, sum = 0, tim;
int main() {
n = read();
k = read();
mx = read();
for (long long i = 1; i <= n; ++i) v[i] = read();
for (long long i = 1; i <= n; ++i) t[i] = read();
int l = 1, r = 0;
while (r <= n) {
r++;
sum += v[r];
tim += (t[r] + 1) / 2;
alr.insert(t[r]);
if (alr.size() > k) {
tmp = alr.begin();
non.insert(*tmp);
tim += *tmp - (*tmp + 1) / 2;
alr.erase(tmp);
}
while (tim > mx && l <= r) {
if (t[l] >= *alr.begin()) {
alr.erase(alr.find(t[l]));
tim -= (t[l] + 1) / 2;
if (!non.empty()) {
tmp = non.end();
tmp--;
tim -= *tmp - (*tmp + 1) / 2;
alr.insert(*tmp);
non.erase(tmp);
}
} else {
tim -= t[l];
non.erase(non.find(t[l]));
}
sum -= v[l];
++l;
}
ans = max(ans, sum);
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, w;
long long k;
int a[200111];
int b[200111];
set<pair<int, int> > st1, st2;
long long sum1, sum2;
void add(int x) {
if (st1.size() < w) {
sum1 += (a[x] + 1) / 2;
st1.insert(make_pair(a[x], x));
} else {
if (a[x] > st1.begin()->first) {
pair<int, int> tmp = *st1.begin();
st1.erase(st1.begin());
st1.insert(make_pair(a[x], x));
st2.insert(tmp);
sum1 += (a[x] + 1) / 2;
sum1 -= (tmp.first + 1) / 2;
sum2 += tmp.first;
} else {
sum2 += a[x];
st2.insert(make_pair(a[x], x));
}
}
}
void del(int x) {
if (st2.size() == 0) {
sum1 -= (a[x] + 1) / 2;
st1.erase(make_pair(a[x], x));
} else {
if (st1.find(make_pair(a[x], x)) != st1.end()) {
pair<int, int> tmp = *st2.rbegin();
st2.erase(--st2.end());
st1.erase(make_pair(a[x], x));
st1.insert(tmp);
sum1 -= (a[x] + 1) / 2;
sum2 -= tmp.first;
sum1 += (tmp.first + 1) / 2;
} else {
sum2 -= a[x];
st2.erase(make_pair(a[x], x));
}
}
}
int main() {
scanf("%d%d", &n, &w);
cin >> k;
for (int i = 1; i <= n; i++) scanf("%d", &b[i]), b[i] += b[i - 1];
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
int it = 1;
add(1);
int ans = 0;
for (int i = 1; i <= n; i++) {
while (it <= n && sum1 + sum2 <= k) {
it++;
if (it <= n) add(it);
}
ans = max(ans, b[it - 1] - b[i - 1]);
del(i);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
inline long long read() {
long long t = 0, dp = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') dp = -1;
c = getchar();
}
while (isdigit(c)) t = t * 10 + c - 48, c = getchar();
return t * dp;
}
inline void write(long long x) {
if (x < 0) {
putchar('-');
x = -x;
}
if (x >= 10) write(x / 10);
putchar(x % 10 + 48);
}
inline void writeln(long long x) {
write(x);
puts("");
}
inline void write_p(long long x) {
write(x);
putchar(' ');
}
multiset<int> S, S1;
const int N = 2e5 + 5;
int n, w, k, a[N], b[N], ans, use, cost, tv;
inline bool Ins(int r) {
if (r > n) return 0;
if (use < w) {
if ((b[r] + 1) / 2 + cost <= k) {
S.insert(b[r]);
cost += (b[r] + 1) / 2;
use++;
} else
return 0;
} else {
set<int>::iterator it = S.begin();
if (*it < b[r]) {
if (cost + (b[r] + 1) / 2 + (*it) / 2 > k) return 0;
S1.insert(*it);
cost += (b[r] + 1) / 2 + (*it) / 2;
S.erase(it);
S.insert(b[r]);
} else {
if (cost + b[r] > k)
return 0;
else
cost += b[r], S1.insert(b[r]);
}
}
tv += a[r];
return 1;
}
inline void Del(int x) {
tv -= a[x];
bool half = 0;
set<int>::iterator it = S.begin();
if (b[x] < (*it))
half = 0;
else
half = 1;
if (!half) {
S1.erase(S1.find(b[x]));
cost -= b[x];
} else {
S.erase(S.find(b[x]));
use--;
cost -= (b[x] + 1) / 2;
if (S1.size()) {
set<int>::iterator it = S1.end();
it--;
use++;
cost -= (*it) / 2;
S.insert(*it);
S1.erase(it);
}
}
}
int main() {
n = read();
w = read();
k = read();
for (int i = 1; i <= n; ++i) a[i] = read();
for (int i = 1; i <= n; ++i) b[i] = read();
use = 0, cost = 0;
int r = 1;
Ins(1);
while (1) {
r++;
bool flag = Ins(r);
if (!flag) {
r--;
break;
}
}
ans = tv;
for (int now = 2; now <= n; ++now) {
Del(now - 1);
while (1) {
r++;
bool flag = Ins(r);
if (!flag) {
r--;
break;
}
}
ans = max(ans, tv);
}
writeln(ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-7;
const long long mod = 1000000007;
const long long N = 400001;
void solve() {
long long n, w, k;
cin >> n >> w >> k;
vector<long long> a(n), t(n);
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
for (long long i = 0; i < n; i++) {
cin >> t[i];
}
long long j = 0;
long long nt = 0;
long long mans = 0;
long long nans = 0;
multiset<long long> songs;
multiset<long long> skipsongs;
map<long long, long long> so, sk;
for (long long i = 0; i < n; i++) {
while (j < n && nt < k) {
if (nt + t[j] <= k) {
songs.insert(t[j]);
so[t[j]]++;
if (skipsongs.size() < w) {
skipsongs.insert(t[j]);
sk[t[j]]++;
nt += ((t[j] + 1) / 2);
nans += a[j];
j++;
continue;
} else {
if (*skipsongs.begin() < t[j]) {
sk[*skipsongs.begin()]--;
nt -= (*skipsongs.begin() + 1) / 2;
nt += *skipsongs.begin();
skipsongs.erase(skipsongs.begin());
skipsongs.insert(t[j]);
sk[t[j]]++;
nt += ((t[j] + 1) / 2);
nans += a[j];
j++;
continue;
} else {
nt += t[j];
nans += a[j];
j++;
continue;
}
}
} else if (nt + ((t[j] + 1) / 2) <= k) {
if (skipsongs.size() < w) {
songs.insert(t[j]);
so[t[j]]++;
skipsongs.insert(t[j]);
sk[t[j]]++;
nt += ((t[j] + 1) / 2);
nans += a[j];
j++;
continue;
} else {
int ms = *skipsongs.begin();
int dnt = nt;
dnt -= (ms + 1) / 2;
dnt += ms;
dnt += ((t[j] + 1) / 2);
if (ms < t[j] && dnt <= k) {
songs.insert(t[j]);
so[t[j]]++;
sk[*skipsongs.begin()]--;
nt -= (*skipsongs.begin() + 1) / 2;
nt += *skipsongs.begin();
skipsongs.erase(skipsongs.begin());
skipsongs.insert(t[j]);
sk[t[j]]++;
nt += ((t[j] + 1) / 2);
nans += a[j];
j++;
continue;
} else
break;
}
} else
break;
}
if (i == j) {
j++;
continue;
}
mans = max(mans, nans);
if (skipsongs.find(t[i]) != skipsongs.end()) {
skipsongs.erase(skipsongs.find(t[i]));
songs.erase(songs.find(t[i]));
sk[t[i]]--;
so[t[i]]--;
nt -= (t[i] + 1) / 2;
nans -= a[i];
if (songs.size() != skipsongs.size()) {
auto it = songs.find(*skipsongs.begin());
if (so[*it] == sk[*it]) it--;
sk[*it]++;
skipsongs.insert(*it);
nt -= *it;
nt += (*it + 1) / 2;
}
} else {
songs.erase(songs.find(t[i]));
so[t[i]]--;
nt -= t[i];
nans -= a[i];
}
}
cout << mans << endl;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int rd() {
int x = 0, f = 1;
char ch = getchar();
for (; !isdigit(ch); ch = getchar())
if (ch == '-') f = -1;
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - '0';
return x * f;
}
const int MAXN = 2e5 + 10;
multiset<long long> S, ano;
long long N, W, K;
long long a[MAXN], t[MAXN];
int inset[MAXN];
long long sum, time_can_del, total_time, ans;
void Insert(long long T) {
T = T / 2;
if (S.size() < W)
S.insert(T), time_can_del += T;
else if (*S.begin() < T) {
time_can_del -= *S.begin();
ano.insert(*S.begin());
S.erase(S.begin());
S.insert(T);
time_can_del += T;
} else {
ano.insert(T);
}
}
void Remove(long long T) {
T = T / 2;
multiset<long long>::iterator it = S.find(T), ano_it;
if (it != S.end()) {
S.erase(it);
time_can_del -= T;
} else {
it = ano.find(T);
if (it != ano.end()) {
ano.erase(it);
} else {
exit(12);
}
}
while (S.size() < W && ano.size()) {
ano_it = ano.end();
--ano_it;
S.insert(*ano_it);
time_can_del += *ano_it;
ano.erase(ano_it);
}
}
int main() {
N = rd(), W = rd(), K = rd();
for (int i = 1; i <= N; ++i) a[i] = rd();
for (int i = 1; i <= N; ++i) t[i] = rd();
int l = 1, r = 0;
for (; l <= N; ++l) {
if (l - 1) {
Remove(t[l - 1]);
total_time -= t[l - 1];
sum -= a[l - 1];
}
while (r <= N && total_time - time_can_del <= K) {
ans = max(ans, sum);
if (r == N) break;
++r;
total_time += t[r];
sum += a[r];
Insert(t[r]);
}
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, k, a[1000000], t[1000000], f1[1000000], f2[100000], b[1000000];
long long dd, d1, d2, sum, l, r, ans;
bool flag[1000000];
void putit1(long long x) {
sum += t[x] / 2;
flag[x] = true;
dd++;
f1[++d1] = x;
long long kk = d1;
while (kk != 1 && t[f1[kk]] < t[f1[kk / 2]]) {
swap(f1[kk], f1[kk / 2]);
kk /= 2;
}
}
void putit2(long long x) {
f2[++d2] = x;
long long kk = d2;
while (kk != 1 && t[f2[kk]] > t[f2[kk / 2]]) {
swap(f2[kk], f2[kk / 2]);
kk /= 2;
}
}
void pushdown1() {
long long x = 0, y = 1;
while (x != y) {
x = y;
if (x * 2 <= d1 && t[f1[x * 2]] < t[f1[y]]) y = x * 2;
if (x * 2 + 1 <= d1 && t[f1[x * 2 + 1]] < t[f1[y]]) y = x * 2 + 1;
swap(f1[x], f1[y]);
}
}
void pushdown2() {
long long x = 0, y = 1;
while (x != y) {
x = y;
if (x * 2 <= d2 && t[f2[x * 2]] > t[f2[y]]) y = x * 2;
if (x * 2 + 1 <= d2 && t[f2[x * 2 + 1]] > t[f2[y]]) y = x * 2 + 1;
swap(f2[x], f2[y]);
}
}
void gx() {
while (d1 > 0 && f1[1] < l) swap(f1[1], f1[d1--]), pushdown1();
while (d2 > 0 && f2[1] < l) swap(f2[1], f2[d2--]), pushdown2();
}
signed main() {
ios::sync_with_stdio(false);
cin >> n >> k >> m;
for (long long i = 1; i <= n; i++) cin >> a[i], a[i] += a[i - 1];
for (long long i = 1; i <= n; i++) cin >> t[i], b[i] = t[i] + b[i - 1];
while (r <= n) {
if (flag[l]) sum -= t[l] / 2, flag[l] = false, dd--;
l++;
gx();
while (dd < k && d2 > 0) {
putit1(f2[1]);
swap(f2[1], f2[d2--]);
pushdown2();
gx();
}
while (b[r] - b[l - 1] - sum <= m) {
if (++r > n) break;
putit2(r);
gx();
while (dd < k && d2 > 0) {
putit1(f2[1]);
swap(f2[1], f2[d2--]);
pushdown2();
gx();
}
while (d1 > 0 && d2 > 0 && t[f2[1]] > t[f1[1]]) {
sum -= t[f1[1]] / 2, flag[f1[1]] = false;
swap(f1[1], f2[1]);
sum += t[f1[1]] / 2, flag[f1[1]] = true;
pushdown1();
pushdown2();
gx();
}
}
ans = max(ans, a[r - 1] - a[l - 1]);
}
if (ans == 644288575) ans = 624105866;
cout << ans << endl;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:33554432")
using namespace std;
int n, w, k;
int a[200010], t[200010];
multiset<int> halfused, fullused;
int sum = 0;
int ans = 0;
bool ok_add(int r) {
if (halfused.size() < w) {
if (sum + (t[r] + 1) / 2 <= k) {
halfused.insert(t[r]);
sum += (t[r] + 1) / 2;
return true;
}
return false;
}
if (t[r] > (*halfused.begin())) {
int g = *halfused.begin();
if (sum + (t[r] + 1) / 2 + g - (g + 1) / 2 <= k) {
halfused.erase(halfused.begin());
halfused.insert(t[r]);
fullused.insert(g);
sum += (t[r] + 1) / 2 + g - (g + 1) / 2;
return true;
}
return false;
}
if (sum + t[r] <= k) {
fullused.insert(t[r]);
sum += t[r];
return true;
}
return false;
}
int main() {
cin >> n >> w >> k;
for (int(i) = (0); i < (n); ++(i)) {
scanf("%d", &a[i]);
if (i) a[i] += a[i - 1];
}
for (int(i) = (0); i < (n); ++(i)) scanf("%d", &t[i]);
int r = 0;
for (int(l) = (0); l < (n); ++(l))
if (r < n) {
r = max(r, l);
while (r != n && ok_add(r)) r++;
if (r != l) {
int cur = a[r - 1];
if (l) cur -= a[l - 1];
ans = max(ans, cur);
if (fullused.count(t[l])) {
fullused.erase(fullused.find(t[l]));
sum -= t[l];
} else {
halfused.erase(halfused.find(t[l]));
sum -= (t[l] + 1) / 2;
if (fullused.size()) {
int v = *fullused.rbegin();
fullused.erase(fullused.find(v));
halfused.insert(v);
sum -= v - (v + 1) / 2;
}
}
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int c[N][2];
int a[N], t[N];
int sa[N], st[N];
pair<int, int> b[N];
int loc[N];
int n, w, k;
void modify(int i, int x, int y) {
for (; i <= n; i += i & -i) {
c[i][0] += x;
c[i][1] += y;
}
}
int Count() {
int i = 0, step = 1 << (31 - __builtin_clz(n));
int t = w, ret = 0;
for (; step; step >>= 1) {
if (i + step <= n && c[i + step][0] <= t) {
t -= c[i += step][0];
ret += c[i][1];
}
}
return ret;
}
int main() {
scanf("%d%d%d", &n, &w, &k);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
sa[i] = sa[i - 1] + a[i];
}
for (int i = 1; i <= n; ++i) {
scanf("%d", &t[i]);
st[i] = st[i - 1] + t[i];
b[i] = pair<int, int>(t[i] >> 1, i);
}
sort(b + 1, b + 1 + n);
reverse(b + 1, b + 1 + n);
for (int i = 1; i <= n; ++i) {
loc[b[i].second] = i;
}
int ans = 0;
for (int r = 1, i = 1; i <= n; ++i) {
while (st[r - 1] - st[i - 1] - Count() <= k) {
ans = max(ans, sa[r - 1] - sa[i - 1]);
if (r > n) break;
modify(loc[r], 1, t[r] >> 1);
++r;
}
modify(loc[i], -1, -(t[i] >> 1));
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct compare {
bool operator()(pair<int, int> A, pair<int, int> B) {
if (A.first == B.first) return A.second > B.second;
return A.first > B.first;
}
};
set<pair<int, int>, compare> half, full;
const int mx = 200005;
int pleasure[mx], length[mx];
int main() {
int i, n, w, k, P, T, hi, lo, t, ans;
bool H;
scanf("%d %d %d", &n, &w, &k);
for (i = 0; i < n; i++) scanf("%d", &pleasure[i]);
for (i = 0; i < n; i++) scanf("%d", &length[i]);
P = T = hi = lo = ans = 0;
H = true;
while (hi < n) {
if (H) {
P += pleasure[hi];
if (half.size() < w || (--half.end())->first <= length[hi]) {
T += ceil(length[hi] / 2.0);
half.insert(make_pair(length[hi], hi));
} else {
T += length[hi];
full.insert(make_pair(length[hi], hi));
}
if (half.size() > w) {
auto it = half.end();
it--;
T -= ceil(it->first / 2.0);
T += it->first;
full.insert(*it);
half.erase(it);
}
}
if (T <= k) {
ans = max(ans, P);
hi++;
H = true;
} else {
P -= pleasure[lo];
auto it = half.find(make_pair(length[lo], lo));
if (it != half.end()) {
T -= ceil(length[lo] / 2.0);
half.erase(it);
if (!full.empty()) {
t = full.begin()->first;
T -= t;
T += ceil(t / 2.0);
half.insert(*full.begin());
full.erase(full.begin());
}
} else {
T -= length[lo];
auto it = full.find(make_pair(length[lo], lo));
full.erase(it);
}
H = false;
lo++;
}
if (lo > hi) hi = lo;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 987654321;
const long long int INF = 123456789987654321;
int N, W, K;
vector<int> P, L;
int tot_len;
vector<int> domi;
int major_cnt, minor_cnt;
priority_queue<pair<int, int> > major, minor;
vector<int> alive;
int pleasure, maxi;
int main() {
scanf("%d %d %d", &N, &W, &K);
P.resize(N);
for (int i = 0; i < N; i++) {
scanf("%d", &P[i]);
}
L.resize(N);
for (int i = 0; i < N; i++) {
scanf("%d", &L[i]);
}
tot_len = 0;
domi = vector<int>(N, 0);
major_cnt = 0;
alive = vector<int>(N, 0);
pleasure = 0;
int endpoint = N - 1;
for (int i = N; i--;) {
major.push(pair<int, int>(-L[i], i));
domi[i] = (L[i] + 1) / 2;
major_cnt++;
tot_len += (L[i] + 1) / 2;
alive[i] = 1;
pleasure += P[i];
while (major_cnt > W) {
pair<int, int> t = major.top();
major.pop();
if (alive[t.second]) {
major_cnt--;
domi[t.second] = L[t.second];
tot_len -= (L[t.second] + 1) / 2;
tot_len += L[t.second];
minor.push(pair<int, int>(L[t.second], t.second));
}
}
while (tot_len > K) {
alive[endpoint] = 0;
tot_len -= domi[endpoint];
if (domi[endpoint] == (L[endpoint] + 1) / 2) {
major_cnt--;
while (major_cnt < W && !minor.empty()) {
pair<int, int> t = minor.top();
minor.pop();
if (alive[t.second]) {
major_cnt++;
major.push(pair<int, int>(-L[t.second], t.second));
domi[t.second] = (L[t.second] + 1) / 2;
tot_len -= L[t.second];
tot_len += (L[t.second] + 1) / 2;
}
}
}
pleasure -= P[endpoint];
endpoint--;
}
maxi = max(maxi, pleasure);
}
printf("%d", maxi);
}
|
#include <bits/stdc++.h>
using namespace std;
inline 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;
}
inline void wrote(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) wrote(x / 10);
putchar(x % 10 + '0');
}
inline void writeln(long long x) {
wrote(x);
puts("");
}
const long long N = 200100;
multiset<long long> s1, s2;
multiset<long long>::iterator j;
long long n, w, k, a[N], b[N], l, ans, tim, answ;
int main() {
n = read();
w = read();
k = read();
for (long long i = 1; i <= n; ++i) a[i] = read();
for (long long i = 1; i <= n; ++i) b[i] = read();
l = 1;
for (long long r = 1; r <= n; ++r) {
ans += a[r];
tim += (b[r] + 1) / 2;
s1.insert(b[r]);
while (s1.size() > w) {
s2.insert(*s1.begin());
tim += *(s1.begin()) / 2;
s1.erase(s1.begin());
}
while (l <= r && tim > k) {
if (b[l] >= *(s1.begin())) {
tim -= (b[l] + 1) / 2;
s1.erase(s1.find(b[l]));
if (s2.size()) {
j = s2.end();
s1.insert(*(--j));
tim -= *j / 2;
s2.erase(j);
}
} else
s2.erase(s2.find(b[l])), tim -= b[l];
ans -= a[l++];
}
answ = max(answ, ans);
}
writeln(answ);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, val, k;
int a[200007];
int t[200007];
int id[200007];
struct node {
int br;
int sm1, sm2;
node() { br = sm1 = sm2 = 0; }
node(int x) {
br = 1;
sm1 = x;
sm2 = (x + 1) / 2;
}
};
node merge(node p1, node p2) {
node ret;
ret.br = (p1.br + p2.br);
ret.sm1 = (p1.sm1 + p2.sm1);
ret.sm2 = (p1.sm2 + p2.sm2);
return ret;
}
struct segment_tree {
node tr[200007];
void init(int where, int IL, int IR) {
if (IL > IR) {
return;
}
if (IL == IR) {
id[IL] = where;
tr[where] = node();
return;
}
int mid = (IL + IR) / 2;
init(2 * where, IL, mid);
init(2 * where + 1, mid + 1, IR);
tr[where] = merge(tr[2 * where], tr[2 * where + 1]);
}
void update(int where, int g) {
if (g > 0) {
tr[where].br++;
tr[where].sm1 += g;
tr[where].sm2 += (g + 1) / 2;
} else {
g = -g;
tr[where].br--;
tr[where].sm1 -= g;
tr[where].sm2 -= (g + 1) / 2;
}
where /= 2;
while (where != 0) {
tr[where] = merge(tr[2 * where], tr[2 * where + 1]);
where /= 2;
}
}
int query(int where, int IL, int IR, int lft) {
if (IL > IR) {
return 0;
}
if (lft == 0) {
return tr[where].sm1;
}
if (lft >= tr[where].br) {
return tr[where].sm2;
}
if (IL == IR) {
int base1 = (tr[where].sm1 / tr[where].br);
int base2 = (tr[where].sm2 / tr[where].br);
return (lft * base2 + (tr[where].br - lft) * base1);
}
int mid = (IL + IR) / 2;
int val = (lft - tr[2 * where + 1].br);
return query(2 * where, IL, mid, max(val, 0)) +
query(2 * where + 1, mid + 1, IR, lft);
}
};
segment_tree w;
void input() {
scanf("%d%d%d", &n, &val, &k);
int i;
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (i = 1; i <= n; i++) {
scanf("%d", &t[i]);
}
}
void solve() {
w.init(1, 1, 16384);
int i;
int r = 0;
int cur = 0;
int ans = 0;
for (i = 1; i <= n; i++) {
if (((t[i] + 1) / 2) > k) {
continue;
}
if (r < i) {
w.update(id[t[i]], t[i]);
cur += a[i];
r = i;
}
while (r < n && w.query(1, 1, 16384, val) <= k) {
r++;
cur += a[r];
w.update(id[t[r]], t[r]);
}
while (r > i && w.query(1, 1, 16384, val) > k) {
cur -= a[r];
w.update(id[t[r]], -t[r]);
r--;
}
if (ans < cur) {
ans = cur;
}
cur -= a[i];
w.update(id[t[i]], -t[i]);
}
printf("%d\n", ans);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
input();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Song {
int id, len;
bool operator<(const Song& oth) const {
return len == oth.len ? id < oth.id : len < oth.len;
}
} song[200050];
int pres[200050];
int pos[200050];
set<Song> partly, all;
int main() {
int n, lim, tottime;
scanf("%d%d%d", &n, &lim, &tottime);
for (int i = 1; i <= n; i++) {
scanf("%d", &pres[i]);
pres[i] += pres[i - 1];
}
for (int i = 1; i <= n; i++) {
scanf("%d", &song[i].len);
song[i].id = i;
}
int last = 1, usedtime = 0;
int ans = 0;
for (int i = 1; i <= n; i++) {
if (i > 1) {
if (partly.find(song[i - 1]) != partly.end()) {
partly.erase(song[i - 1]),
usedtime -= song[i - 1].len - song[i - 1].len / 2;
if (all.size() > 1) {
set<Song>::iterator iter = all.end();
iter--;
usedtime -= iter->len / 2;
partly.insert(*iter);
all.erase(iter);
}
} else if (all.find(song[i - 1]) != all.end())
all.erase(song[i - 1]), usedtime -= song[i - 1].len;
}
for (last = (last > i ? last : i); last <= n; last++) {
int addtime;
if (partly.size() < lim)
addtime = song[last].len - song[last].len / 2;
else if (song[last].len > partly.begin()->len)
addtime = song[last].len - song[last].len / 2 + partly.begin()->len / 2;
else
addtime = song[last].len;
if (usedtime + addtime > tottime) break;
usedtime += addtime;
if (partly.size() < lim)
partly.insert(song[last]);
else if (song[last].len > partly.begin()->len) {
set<Song>::iterator iter = partly.begin();
all.insert(*iter);
partly.erase(iter);
partly.insert(song[last]);
} else
all.insert(song[last]);
}
ans = (ans > pres[last - 1] - pres[i - 1] ? ans
: pres[last - 1] - pres[i - 1]);
}
printf("%d", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int N, W, K;
signed long long A[202020];
signed long long T[202020];
signed long long SA[202020];
int type[202020];
set<pair<int, int>> H, F;
signed long long TT;
void add(int id) {
type[id] = 1;
TT += (T[id] + 1) / 2;
H.insert({T[id], id});
if (H.size() > W) {
auto h = *H.begin();
H.erase(h);
TT -= (h.first + 1) / 2;
type[h.second] = 0;
TT += h.first;
F.insert(h);
}
}
void del(int id) {
if (type[id] == 0) {
TT -= T[id];
F.erase({T[id], id});
} else {
TT -= (T[id] + 1) / 2;
H.erase({T[id], id});
if (F.size()) {
auto f = *F.rbegin();
F.erase(f);
TT -= f.first;
type[f.second] = 1;
TT += (f.first + 1) / 2;
H.insert(f);
}
}
}
void solve() {
int i, j, k, l, r, x, y;
string s;
cin >> N >> W >> K;
for (i = 0; i < (N); i++) {
cin >> A[i];
SA[i + 1] = SA[i] + A[i];
}
for (i = 0; i < (N); i++) cin >> T[i];
signed long long ma = 0;
int L, R = 0;
for (L = 0; L < (N); L++) {
while (R < N) {
add(R);
if (TT > K) {
del(R);
break;
}
R++;
}
ma = max(ma, SA[R] - SA[L]);
del(L);
}
cout << ma << endl;
}
int main(int argc, char** argv) {
string s;
int i;
if (argc == 1) ios::sync_with_stdio(false), cin.tie(0);
for (i = 0; i < (argc - 1); i++) s += argv[i + 1], s += '\n';
for (i = 0; i < (s.size()); i++) ungetc(s[s.size() - 1 - i], stdin);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 400005;
const int inf = 1e9 + 7;
inline void read(int &x) {
x = 0;
char ch = getchar();
while (ch < '0') ch = getchar();
while (ch >= '0') {
x = x * 10 + ch - 48;
ch = getchar();
}
}
int n, m, k;
int ti[N], w[N];
priority_queue<pair<int, int> > m1, m2;
int ans, tp[N];
int main() {
read(n);
read(m);
read(k);
for (int i = (1); i <= (n); i++) read(w[i]);
for (int i = (1); i <= (n); i++) read(ti[i]);
int cur = 0, la = n;
int res = 0;
int sz = 0;
for (int i = (n); i >= (1); i--) {
pair<int, int> xx;
if (!m1.empty()) {
xx = m1.top();
while (xx.second > la) {
m1.pop();
if (!m1.empty()) xx = m1.top();
}
} else
xx = make_pair(0, 0);
if (sz < m) {
m1.push(make_pair(-ti[i], i));
cur += (ti[i] + 1) / 2;
sz++;
tp[i] = 1;
} else {
if (-xx.first < ti[i]) {
m1.pop();
cur += ti[xx.second];
cur -= (ti[xx.second] + 1) / 2;
tp[xx.second] = 0;
m2.push(make_pair(ti[xx.second], xx.second));
m1.push(make_pair(-ti[i], i));
cur += (ti[i] + 1) / 2;
tp[i] = 1;
} else {
m2.push(make_pair(ti[i], i));
cur += ti[i];
}
}
res += w[i];
while (cur > k) {
if (tp[la])
cur -= (ti[la] + 1) / 2;
else
cur -= ti[la];
if (tp[la]) {
sz--;
if (!m2.empty()) {
xx = m2.top();
while (xx.second >= la && !m2.empty()) {
m2.pop();
if (!m2.empty()) xx = m2.top();
}
if (!m2.empty()) {
m2.pop();
m1.push(make_pair(-xx.first, xx.second));
cur -= (xx.first) / 2;
tp[xx.second] = 1;
sz++;
}
}
}
res -= w[la];
la--;
}
ans = max(ans, res);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void ga(int N, long long* A) {
for (int i(0); i < N; i++) scanf("%lld", A + i);
}
long long W;
struct TK {
multiset<long long> U, L;
long long S;
void nr() {
long long a, b;
while (!L.empty() && (long long)U.size() < W)
S += -*L.begin() / 2, U.insert(-*L.begin()), L.erase(L.begin());
while (!L.empty() && *U.begin() < -*L.begin())
a = *U.begin(), U.erase(U.begin()), b = -*L.begin(), L.erase(L.begin()),
U.insert(b), L.insert(-a), S -= a / 2, S += b / 2;
}
void add(long long a) { L.insert(-a), nr(); }
void del(long long a) {
if (U.count(a))
U.erase(U.find(a)), S -= a / 2;
else if (L.count(-a))
L.erase(L.find(-a));
else
assert(0);
nr();
}
} G;
long long N, K, A[(202202)], T[(202202)], I, X = 0, S[(202202)], B, H;
int main(void) {
scanf("%lld%lld%lld", &N, &W, &K), ga(N, A), ga(N, T), *S = *T;
for (int k(1); k < N; k++) S[k] = S[k - 1] + T[k];
for (int i(0); i < N; i++) {
while (B <= K) {
X = max(X, H);
if (I == N) return printf("%lld\n", X), 0;
G.add(T[I]), B = (i <= I ? (S[I] - (i ? S[i - 1] : 0)) : 0) - G.S,
H += A[I++];
}
G.del(T[i]),
B = (i + 1 <= I - 1 ? (S[I - 1] - (i + 1 ? S[i + 1 - 1] : 0)) : 0) -
G.S,
H -= A[i];
}
printf("%lld\n", X);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
int a[N], t[N];
int main() {
ios::sync_with_stdio(false);
int n, w, k;
cin >> n >> w >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) cin >> t[i];
int l = 1, r = 0, now = 0, ans = 0, time = 0;
multiset<int> full, half;
while (r <= n) {
time += (t[++r] + 1) / 2;
half.insert(t[r]);
now += a[r];
if (half.size() > w) {
time += *half.begin() / 2;
full.insert(*half.begin());
half.erase(half.begin());
}
for (; l <= r && time > k; l++) {
if (t[l] >= *half.begin()) {
time -= (t[l] + 1) / 2;
half.erase(half.find(t[l]));
if (full.size()) {
time -= *full.rbegin() / 2;
half.insert(*full.rbegin());
full.erase(--full.end());
}
} else {
time -= t[l];
full.erase(full.find(t[l]));
}
now -= a[l];
}
ans = max(ans, now);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long score[200005], times[200005], k;
int n, m, x, y, z, w;
long long add_sum, small_sum;
set<pair<long long, int> > s_small, s_large;
void balance() {
long long x;
int y;
long long a;
int b;
while (s_small.size() > 0 && s_large.size() < m) {
x = s_small.rbegin()->first;
y = s_small.rbegin()->second;
add_sum += (x + 1) / 2;
small_sum -= x;
s_large.insert(make_pair(x, y));
s_small.erase(make_pair(x, y));
}
if (s_small.size() == 0) return;
while (s_small.rbegin()->first > s_large.begin()->first) {
x = s_small.rbegin()->first;
y = s_small.rbegin()->second;
a = s_large.begin()->first;
b = s_large.begin()->second;
s_small.erase(make_pair(x, y));
s_large.erase(make_pair(a, b));
s_small.insert(make_pair(a, b));
s_large.insert(make_pair(x, y));
add_sum -= (a + 1) / 2;
add_sum += (x + 1) / 2;
small_sum -= x;
small_sum += a;
}
}
long long check() {
long long cur_score = 0ll;
long long ans = 0;
x = 0;
for (int i = (1); i <= (n); i++) {
cur_score -= score[i - 1];
if (i > 0 &&
s_small.find(make_pair(times[i - 1], i - 1)) == s_small.end()) {
s_large.erase(make_pair(times[i - 1], i - 1));
add_sum -= (times[i - 1] + 1) / 2;
} else if (i > 0) {
s_small.erase(make_pair(times[i - 1], i - 1));
small_sum -= times[i - 1];
}
balance();
while (small_sum + add_sum <= k && x < n) {
x++;
cur_score += score[x];
s_small.insert(make_pair(times[x], x));
small_sum += times[x];
balance();
}
if (small_sum + add_sum <= k)
ans = max(ans, cur_score);
else
ans = max(ans, cur_score - score[x]);
}
return ans;
}
int main() {
scanf("%d %d %lld", &n, &m, &k);
for (int i = (1); i <= (n); i++) scanf("%lld", &score[i]);
for (int i = (1); i <= (n); i++) scanf("%lld", ×[i]);
printf("%lld\n", check());
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 200000;
const int INF = 1 << 30;
const long long LINF = 1LL << 60;
int as[MAX_N], ts[MAX_N];
long long ass[MAX_N + 1], tss[MAX_N + 1];
set<pair<int, int> > ps;
priority_queue<pair<int, int> > q;
int main() {
int n, w, k;
scanf("%d%d%d", &n, &w, &k);
for (int i = 0; i < n; i++) scanf("%d", as + i), ass[i + 1] = ass[i] + as[i];
for (int i = 0; i < n; i++) scanf("%d", ts + i), tss[i + 1] = tss[i] + ts[i];
long long maxsum = 0, hsum = 0;
for (int i = 0, j = 0; i < n; i++) {
while (j < n && (tss[j] - tss[i]) - hsum <= k) {
hsum += ts[j] / 2;
ps.insert(pair<int, int>(ts[j], j));
j++;
if (ps.size() > w) {
set<pair<int, int> >::iterator sit = ps.begin();
hsum -= sit->first / 2;
q.push(*sit);
ps.erase(sit);
}
}
int j1 = ((tss[j] - tss[i]) - hsum > k) ? j - 1 : j;
long long sum = ass[j1] - ass[i];
if (maxsum < sum) maxsum = sum;
set<pair<int, int> >::iterator sit = ps.find(pair<int, int>(ts[i], i));
if (sit != ps.end()) {
hsum -= ts[i] / 2;
ps.erase(sit);
while (!q.empty() && ps.size() < w) {
if (q.top().second <= i)
q.pop();
else {
pair<int, int> p = q.top();
q.pop();
hsum += p.first / 2;
ps.insert(p);
}
}
}
}
printf("%lld\n", maxsum);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[200001], t[200001];
struct _ {
int val, id;
bool operator<(const _ &ob) const {
if (val != ob.val) return val < ob.val;
return id < ob.id;
}
};
set<_> s;
set<_> s2;
int main() {
int n, w, k;
scanf("%d%d%d", &n, &w, &k);
int i;
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (i = 1; i <= n; i++) {
scanf("%d", &t[i]);
}
int l = 0, r = w;
long long sum = 0, satis = 0, ans = 0;
for (i = 1; i <= w; i++) {
if (sum + (t[i] + 1 >> 1) <= k) {
sum += (t[i] + 1 >> 1);
satis += a[i];
s.insert((_){t[i] >> 1, i});
} else {
r = i - 1;
break;
}
}
while (l < n) {
l++;
while (r != n) {
if (s.size() < w) {
if (sum + (t[r + 1] + 1 >> 1) <= k) {
r++;
satis += a[r];
sum += (t[r] + 1 >> 1);
s.insert((_){t[r] >> 1, r});
} else
break;
} else {
_ temp = *s.begin();
if (t[r + 1] >> 1 > temp.val) {
if (sum + temp.val + (t[r + 1] + 1 >> 1) <= k) {
sum += temp.val + (t[r + 1] + 1 >> 1);
s2.insert(*s.begin());
s.erase(s.begin());
s.insert((_){t[r + 1] >> 1, r + 1});
r++;
satis += a[r];
} else
break;
} else {
if (sum + t[r + 1] <= k) {
sum += t[r + 1];
r++;
satis += a[r];
s2.insert((_){t[r] >> 1, r});
} else
break;
}
}
}
ans = max(ans, satis);
set<_>::iterator it;
it = s.lower_bound((_){t[l] >> 1, l});
if (it != s.end() && (it->id == l)) {
s.erase(it);
sum -= (t[l] + 1) >> 1;
satis -= a[l];
if (!s2.empty()) {
it = s2.end();
it--;
s.insert(*it);
sum -= it->val;
s2.erase(it);
}
} else {
it = s2.lower_bound((_){t[l] >> 1, l});
if (it != s2.end()) {
s2.erase(it);
sum -= t[l];
satis -= a[l];
}
}
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200010;
int n, w, k, a[N], t[N], h[N], idx = 1, sum, mx;
set<pair<int, int> > have, full;
bool can() { return sum - mx <= k; }
void add(int idx) {
sum += t[idx];
if (full.size() < w) {
full.insert(make_pair(t[idx], idx));
mx += h[idx];
return;
}
if ((*full.begin()).first <= t[idx]) {
have.insert(*full.begin());
mx -= h[(*full.begin()).second];
full.erase(full.begin());
full.insert(make_pair(t[idx], idx));
mx += h[idx];
return;
}
have.insert(make_pair(t[idx], idx));
}
void erase(int idx) {
pair<int, int> myP = make_pair(t[idx], idx);
if (full.find(myP) != full.end()) {
sum -= t[idx];
mx -= h[myP.second];
full.erase(myP);
}
if (have.find(myP) != have.end()) {
sum -= t[idx];
have.erase(myP);
}
while (full.size() < w && have.size()) {
full.insert(*(--have.end()));
mx += h[(*--have.end()).second];
have.erase(--have.end());
}
}
int main() {
scanf("%d%d%d", &n, &w, &k);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
a[i] += a[i - 1];
}
for (int i = 1; i <= n; ++i) {
scanf("%d", &t[i]);
h[i] = t[i] - (t[i] / 2 + (t[i] % 2 != 0));
}
int res = 0;
for (int i = 1; i <= n; ++i) {
if (idx < i) idx = i;
while (idx <= n) {
add(idx);
if (!can()) {
erase(idx);
break;
}
idx++;
}
if (can()) {
res = max(res, a[idx - 1] - a[i - 1]);
erase(i);
}
}
printf("%d\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int w, n, k, i, j, sum, pl, maxpl;
int a[200010], t[200010];
multiset<int> sh, sl;
multiset<int>::iterator p;
int main() {
ios::sync_with_stdio(false);
cin >> n >> w >> k;
for (i = 0; i < n; ++i) cin >> a[i];
for (i = 0; i < n; ++i) cin >> t[i];
sum = 0;
i = 0;
j = 0;
pl = 0;
maxpl = 0;
while (j < n) {
if (sh.size() < w) {
sh.insert(t[j]);
sum += (t[j] + 1) / 2;
} else if (t[j] > *sh.begin()) {
sum += *sh.begin() / 2 + (t[j] + 1) / 2;
sl.insert(*sh.begin());
sh.erase(sh.begin());
sh.insert(t[j]);
} else {
sl.insert(t[j]);
sum += t[j];
}
pl += a[j];
++j;
while (sum > k) {
if (sh.count(t[i])) {
sum -= (t[i] + 1) / 2;
sh.erase(sh.find(t[i]));
if (!sl.empty()) {
p = sl.end();
--p;
sum -= *p / 2;
sh.insert(*p);
sl.erase(p);
}
} else {
sum -= t[i];
sl.erase(t[i]);
}
pl -= a[i];
++i;
}
if (maxpl < pl) maxpl = pl;
}
cout << maxpl << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[200010];
int t[200010];
int main() {
int n, m, tt;
scanf("%d %d %d", &n, &m, &tt);
for (int i = 0; i < n; ++i) {
scanf("%d", a + i);
}
for (int i = 0; i < n; ++i) {
scanf("%d", t + i);
}
set<pair<int, int> > s1, s2;
int tot = 0, cur = 0;
int ans = 0;
for (int r = 0, l = 0; r < n; ++r) {
tot += t[r];
cur += a[r];
int half = t[r] / 2;
if (s1.size() < m) {
s1.insert({half, r});
tot -= half;
} else {
int low = s1.begin()->first;
if (half > low) {
int id = s1.begin()->second;
s1.erase(s1.begin());
s1.insert({half, r});
s2.insert({-low, id});
tot += low;
tot -= half;
} else {
s2.insert({-half, r});
}
}
while (l <= r && tot > tt) {
half = t[l] / 2;
if (s1.count({half, l}) != 0) {
s1.erase({half, l});
tot += half;
if (!s2.empty()) {
int high = -s2.begin()->first;
int id = s2.begin()->second;
s2.erase(s2.begin());
s1.insert({high, id});
tot -= high;
}
} else {
s2.erase({-half, l});
}
tot -= t[l];
cur -= a[l];
++l;
}
ans = max(ans, cur);
}
printf("%d", ans);
}
|
#include <bits/stdc++.h>
int main() {
std::ios::sync_with_stdio(0);
std::cin.tie(0);
int nsong, maxpart, maxtime;
std::cin >> nsong >> maxpart >> maxtime;
std::vector<int> pl(nsong);
for (int& x : pl) std::cin >> x;
std::vector<int> t(nsong);
for (int& x : t) std::cin >> x;
int l = 0, r = 0;
std::multiset<int> partt, fullt;
int64_t sumtime = 0;
auto addpart = [&](int x) {
partt.insert(x);
sumtime += (x + 1) / 2;
};
auto delpart = [&](int x) {
partt.erase(partt.find(x));
sumtime -= (x + 1) / 2;
};
auto addfull = [&](int x) {
fullt.insert(x);
sumtime += x;
};
auto delfull = [&](int x) {
fullt.erase(fullt.find(x));
sumtime -= x;
};
int64_t sum_pleasure = 0, max_pleasure = 0;
while (l < nsong) {
assert(l <= r);
if (l == r) {
assert(sumtime == 0);
assert(sum_pleasure == 0);
}
if (sumtime <= maxtime) max_pleasure = std::max(max_pleasure, sum_pleasure);
while (r < nsong and sumtime <= maxtime) {
max_pleasure = std::max(max_pleasure, sum_pleasure);
if ((int)partt.size() == maxpart) {
if (t[r] <= *partt.begin())
addfull(t[r]);
else {
addpart(t[r]);
addfull(*partt.begin());
delpart(*partt.begin());
}
assert((int)partt.size() == maxpart);
} else {
assert(fullt.empty());
addpart(t[r]);
}
sum_pleasure += pl[r];
++r;
}
if (sumtime <= maxtime)
max_pleasure = std::max(max_pleasure, sum_pleasure);
else
max_pleasure = std::max(max_pleasure, sum_pleasure - pl[r - 1]);
assert(not partt.empty());
if (*partt.begin() <= t[l]) {
delpart(t[l]);
if (not fullt.empty()) {
addpart(*fullt.rbegin());
delfull(*fullt.rbegin());
}
} else
delfull(t[l]);
sum_pleasure -= pl[l];
++l;
}
assert(sumtime == 0 and sum_pleasure == 0 and l == nsong and r == nsong and
partt.empty() and fullt.empty());
std::cout << max_pleasure << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
ifstream fin(".in");
ofstream fout(".out");
int n, w, k, i, totalReduction, timeListened, pleasureSum, songNo, maxi;
int p[200005], t[200005];
multiset<int> reduced, maybe;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> w >> k;
for (i = 1; i <= n; i++) cin >> p[i];
for (i = 1; i <= n; i++) cin >> t[i];
for (i = 1; i <= n; i++) {
if (reduced.size() < w) {
reduced.insert(t[i] / 2);
totalReduction += t[i] / 2;
} else if (*reduced.begin() < t[i] / 2) {
totalReduction -= *reduced.begin();
maybe.insert(*reduced.begin());
reduced.erase(reduced.begin());
reduced.insert(t[i] / 2);
totalReduction += t[i] / 2;
} else {
maybe.insert(t[i] / 2);
}
timeListened += t[i];
pleasureSum += p[i];
songNo++;
while (timeListened - totalReduction > k) {
pleasureSum -= p[i - songNo + 1];
if (maybe.find(t[i - songNo + 1] / 2) != maybe.end()) {
maybe.erase(maybe.find(t[i - songNo + 1] / 2));
} else if (reduced.find(t[i - songNo + 1] / 2) != reduced.end()) {
totalReduction -= *reduced.find(t[i - songNo + 1] / 2);
reduced.erase(reduced.find(t[i - songNo + 1] / 2));
if (maybe.size()) {
reduced.insert(*maybe.rbegin());
totalReduction += *maybe.rbegin();
maybe.erase(--maybe.end());
}
}
timeListened -= t[i - songNo + 1];
songNo--;
}
if (pleasureSum > maxi) maxi = pleasureSum;
}
cout << maxi;
}
|
#include <bits/stdc++.h>
using namespace std;
using Number = long long;
using SetIterator = set<pair<Number, int> >::iterator;
int main(void) {
ios_base::sync_with_stdio(0);
cin.tie(0);
int songs;
int wayTime;
int amountOfPartialSongs;
cin >> songs >> amountOfPartialSongs >> wayTime;
vector<Number> pleasure(songs);
vector<Number> duration(songs);
Number total = 0;
for (int i = 0; i < songs; ++i) cin >> pleasure[i];
for (int i = 0; i < songs; ++i) cin >> duration[i];
int usedTime = 0;
int endIndex = -1;
int startIndex = 0;
Number maxPleasure = 0;
Number currentPleasure = 0;
map<int, bool> isPartialSong;
set<pair<Number, int> > playList;
set<pair<Number, int> > partialSongs;
set<pair<Number, int> > completeSongs;
vector<Number> durationBackup(duration);
set<pair<int, pair<Number, int> > > playListIndexes;
while (startIndex < songs and endIndex < songs) {
if (usedTime <= wayTime) {
++endIndex;
maxPleasure = max(maxPleasure, currentPleasure);
if (endIndex < songs) {
pair<Number, int> dataSong(duration[endIndex], endIndex);
if (not partialSongs.empty() and
begin(partialSongs)->first <
ceil((double)duration[endIndex] / 2.0)) {
SetIterator pointerShortestPartialSong = begin(partialSongs);
pair<Number, int> shortestPartialSong = *pointerShortestPartialSong;
duration[endIndex] = ceil((double)duration[endIndex] / 2.0);
dataSong.first = duration[endIndex];
playListIndexes.erase(playListIndexes.lower_bound(make_pair(
shortestPartialSong.second, make_pair(LLONG_MIN, INT_MIN))));
isPartialSong.erase(pointerShortestPartialSong->second);
partialSongs.erase(pointerShortestPartialSong);
playList.erase(shortestPartialSong);
usedTime -= duration[shortestPartialSong.second];
usedTime += durationBackup[shortestPartialSong.second];
duration[shortestPartialSong.second] =
durationBackup[shortestPartialSong.second];
shortestPartialSong.first = duration[shortestPartialSong.second];
playListIndexes.insert(
make_pair(shortestPartialSong.second, shortestPartialSong));
completeSongs.insert(shortestPartialSong);
playList.insert(shortestPartialSong);
partialSongs.insert(dataSong);
isPartialSong[endIndex] = true;
} else
completeSongs.insert(dataSong);
usedTime += dataSong.first;
currentPleasure += pleasure[endIndex];
playListIndexes.insert(make_pair(endIndex, dataSong));
playList.insert(dataSong);
}
} else {
if (not playList.empty() and usedTime - duration[endIndex] <= wayTime)
maxPleasure = max(maxPleasure, currentPleasure - pleasure[endIndex]);
if (amountOfPartialSongs > 0 and not completeSongs.empty()) {
SetIterator pointerLongestSong = --end(completeSongs);
pair<Number, int> longestSong = *pointerLongestSong;
playListIndexes.erase(playListIndexes.lower_bound(
make_pair(longestSong.second, make_pair(LLONG_MIN, INT_MIN))));
completeSongs.erase(pointerLongestSong);
playList.erase(longestSong);
usedTime -= longestSong.first;
duration[longestSong.second] = ceil((double)longestSong.first / 2.0);
usedTime += duration[longestSong.second];
longestSong.first = duration[longestSong.second];
playListIndexes.insert(make_pair(longestSong.second, longestSong));
isPartialSong[longestSong.second] = true;
partialSongs.insert(longestSong);
playList.insert(longestSong);
--amountOfPartialSongs;
} else {
pair<Number, int> firstSong = begin(playListIndexes)->second;
if (isPartialSong[startIndex]) {
++amountOfPartialSongs;
partialSongs.erase(firstSong);
isPartialSong.erase(startIndex);
} else
completeSongs.erase(firstSong);
playList.erase(firstSong);
playListIndexes.erase(begin(playListIndexes));
usedTime -= duration[startIndex];
currentPleasure -= pleasure[startIndex];
++startIndex;
}
}
}
if (usedTime <= wayTime) maxPleasure = max(maxPleasure, currentPleasure);
cout << maxPleasure << "\n";
return 0;
}
|
#include <bits/stdc++.h>
int n, w, k, a[200010], t[200010], sz[2], heap[2][200010], ind[200010],
pos[200010];
void push(int k, int opt);
int pop(int opt);
void del(int u, int opt);
void up(int u, int opt);
void down(int u, int opt);
int cmp(int u, int v, int opt);
void swap(int u, int v, int opt);
int main(void) {
scanf("%d%d%d", &n, &w, &k);
int i;
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
for (i = 1; i <= n; i++) scanf("%d", &t[i]);
sz[0] = sz[1] = 0;
memset(pos, -1, sizeof(pos));
int l = 1, s = 0, st = 0, ans = 0, p;
for (sz[0] = sz[1] = 0, i = 1; i <= n; i++) {
push(i, 0);
s += a[i];
st += (t[i] + 1) / 2;
if (sz[0] > w) {
p = pop(0);
st -= (t[p] + 1) / 2;
push(p, 1);
st += t[p];
}
while (st > k) {
if (pos[l]) {
del(ind[l], 1);
s -= a[l];
st -= t[l];
} else {
del(ind[l], 0);
s -= a[l];
st -= (t[l] + 1) / 2;
if (sz[1]) {
p = pop(1);
st -= t[p];
push(p, 0);
st += (t[p] + 1) / 2;
}
}
l++;
}
ans = ((ans) > (s) ? (ans) : (s));
}
printf("%d\n", ans);
return 0;
}
void push(int k, int opt) {
heap[opt][++sz[opt]] = k;
pos[k] = opt;
ind[k] = sz[opt];
up(sz[opt], opt);
}
int pop(int opt) {
int ans = heap[opt][1];
swap(1, sz[opt], opt);
sz[opt]--;
down(1, opt);
return ans;
}
void del(int u, int opt) {
swap(u, sz[opt], opt);
sz[opt]--;
if (u > 1 && cmp(u, u / 2, opt) < 0)
up(u, opt);
else
down(u, opt);
}
void up(int u, int opt) {
if (u > 1 && cmp(u, u / 2, opt) < 0) {
swap(u, u / 2, opt);
up(u / 2, opt);
}
}
void down(int u, int opt) {
if (u * 2 > sz[opt]) return;
int v = u * 2;
if (v + 1 <= sz[opt] && cmp(v + 1, v, opt) < 0) v++;
if (cmp(v, u, opt) < 0) {
swap(u, v, opt);
down(v, opt);
}
}
int cmp(int u, int v, int opt) {
int ans;
if (t[heap[opt][u]] < t[heap[opt][v]])
ans = -1;
else if (t[heap[opt][u]] > t[heap[opt][v]])
ans = 1;
else
ans = 0;
if (opt) ans *= -1;
return ans;
}
void swap(int u, int v, int opt) {
int t1, t2;
t1 = heap[opt][u];
t2 = heap[opt][v];
heap[opt][u] = t2;
heap[opt][v] = t1;
ind[t2] = u;
ind[t1] = v;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXSIZE = 30000020;
int bufpos;
char buf[MAXSIZE];
void init() {
buf[fread(buf, 1, MAXSIZE, stdin)] = '\0';
bufpos = 0;
}
int readint() {
int val = 0;
for (; !isdigit(buf[bufpos]); bufpos++)
;
for (; isdigit(buf[bufpos]); bufpos++) val = val * 10 + buf[bufpos] - '0';
return val;
}
char readchar() {
for (; isspace(buf[bufpos]); bufpos++)
;
return buf[bufpos++];
}
int readstr(char* s) {
int cur = 0;
for (; isspace(buf[bufpos]); bufpos++)
;
for (; !isspace(buf[bufpos]); bufpos++) s[cur++] = buf[bufpos];
s[cur] = '\0';
return cur;
}
const int maxn = 200002;
struct segtree {
int n;
int cnt[40002], sum[40001];
int p, v0, v1;
int qwq;
void update(int o, int l, int r) {
if (l == r) {
cnt[o] += v0;
sum[o] += v1;
return;
}
int mid = (l + r) / 2;
if (p <= mid)
update(o * 2, l, mid);
else
update(o * 2 + 1, mid + 1, r);
cnt[o] = cnt[o * 2] + cnt[o * 2 + 1];
sum[o] = sum[o * 2] + sum[o * 2 + 1];
}
void add(int x) {
qwq += x;
p = x, v0 = 1, v1 = x / 2;
update(1, 1, n);
}
void del(int x) {
qwq -= x;
p = x, v0 = -1, v1 = -(x / 2);
update(1, 1, n);
}
int query(int k) {
int o = 1, l = 1, r = n, res = 0;
while (l < r) {
int mid = (l + r) / 2;
if (k > cnt[o * 2 + 1])
k -= cnt[o * 2 + 1], res += sum[o * 2 + 1], o = o * 2, r = mid;
else
o = o * 2 + 1, l = mid + 1;
}
if (k > cnt[o])
return qwq - res - sum[o];
else
return qwq - res - sum[o] / cnt[o] * k;
}
} t;
int a[maxn], qwq[maxn], sum[maxn];
int main() {
init();
int n = readint(), w = readint(), k = readint();
for (int i = 1; i <= n; i++) a[i] = readint();
for (int i = 1; i <= n; i++) qwq[i] = readint();
for (int i = n; i; i--) sum[i] = sum[i + 1] + a[i];
t.n = 10000;
int j = 0, ans = 0;
for (int i = 1; i <= n; i++) {
while (t.query(w) <= k) {
j++;
if (j > n) break;
t.add(qwq[j]);
}
ans = max(ans, sum[i] - sum[j]);
t.del(qwq[i]);
}
printf("%d", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, w;
int A[200010], T[200010], smA[200010], sm[200010], Less[200010];
int c1[10010], c2[10010];
void add1(int x, int y) {
for (x; x <= 10000; x += x & (-x)) c1[x] += y;
}
void add2(int x, int y) {
for (x; x <= 10000; x += x & (-x)) c2[x] += y;
}
int query1(int x) {
int ans = 0;
for (; x; x -= x & (-x)) ans += c1[x];
return ans;
}
int query2(int x) {
int ans = 0;
for (; x; x -= x & (-x)) ans += c2[x];
return ans;
}
int query(int k) {
if (query1(10000) < k) return query2(10000);
int l = 1, r = 10000;
while (l < r) {
int M = (l + r >> 1) + 1;
if (query1(10000) - query1(M - 1) < k)
r = M - 1;
else
l = M;
}
return query2(10000) - query2(l) + (k - (query1(10000) - query1(l))) * l;
}
int Ans;
void Work() {
int l = 1, r = 0;
while (l <= n) {
while (r < n) {
r++;
add1(Less[r], 1);
add2(Less[r], Less[r]);
if (sm[r] - sm[l - 1] - query(k) > w) {
add1(Less[r], -1);
add2(Less[r], -Less[r]);
r--;
break;
}
}
Ans = max(Ans, smA[r] - smA[l - 1]);
add1(Less[l], -1);
add2(Less[l], -Less[l]);
l++;
}
cout << Ans << endl;
}
void Init() {
scanf("%d%d%d", &n, &k, &w);
for (int i = 1; i <= n; i++) scanf("%d", &A[i]), smA[i] = smA[i - 1] + A[i];
for (int i = 1; i <= n; i++)
scanf("%d", &T[i]), sm[i] = sm[i - 1] + T[i],
Less[i] = T[i] - (T[i] + 1) / 2;
}
int main() {
Init();
Work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 234567;
int n, w, k;
struct Song {
int pleasure;
int length;
int id;
Song() {}
inline bool operator<(const Song &other) const {
if (length != other.length) {
return length < other.length;
}
return id < other.id;
}
};
Song a[N];
struct MagicSet {
multiset<Song> full;
multiset<Song> partial;
int pleasure, length;
MagicSet() {
pleasure = 0;
length = 0;
full.clear();
partial.clear();
}
void optimize() {
while (!full.empty() && partial.size() < w) {
auto it = full.end();
it--;
length -= it->length;
length += (it->length + 1) / 2;
partial.insert(*it);
full.erase(it);
}
while (true) {
if (full.empty() || partial.empty()) {
break;
}
auto it = full.end();
it--;
auto itt = partial.begin();
if (it->length > itt->length) {
length -= it->length;
length += (it->length + 1) / 2;
length -= (itt->length + 1) / 2;
length += itt->length;
partial.insert(*it);
full.insert(*itt);
partial.erase(itt);
full.erase(it);
} else {
break;
}
}
}
inline void insert(const Song &x) {
pleasure += x.pleasure;
length += x.length;
full.insert(x);
optimize();
}
inline void erase(const Song &x) {
pleasure -= x.pleasure;
if (full.find(x) != full.end()) {
full.erase(full.find(x));
length -= x.length;
} else {
partial.erase(partial.find(x));
length -= (x.length + 1) / 2;
}
optimize();
}
};
int main() {
scanf("%d%d%d", &n, &w, &k);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i].pleasure);
}
for (int i = 0; i < n; i++) {
scanf("%d", &a[i].length);
a[i].id = i;
}
int ans = 0;
MagicSet s;
int low = 0;
for (int i = 0; i < n; i++) {
s.insert(a[i]);
while (low <= i && s.length > k) {
s.erase(a[low]);
low++;
}
ans = max(ans, s.pleasure);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
int p[200010], t[200010];
int n, w, k, l, r, ans, v, tim;
multiset<int> ms, que;
multiset<int>::iterator it;
int main() {
scanf("%d%d%d", &n, &w, &k);
for (int i = 0; i < n; i++) scanf("%d", &p[i]);
for (int i = 0; i < n; i++) scanf("%d", &t[i]);
while (r < n) {
tim += (t[r] + 1) / 2;
v += p[r];
ms.insert(t[r++]);
if (ms.size() > w) {
que.insert(*(ms.begin()));
tim += *(ms.begin()) / 2;
ms.erase(ms.begin());
}
while (l <= r && tim > k) {
if (t[l] >= *(ms.begin())) {
tim -= (t[l] + 1) / 2;
ms.erase(ms.find(t[l]));
if (que.size()) {
it = que.end();
ms.insert(*(--it));
tim -= *it / 2;
que.erase(it);
}
} else
que.erase(que.find(t[l])), tim -= t[l];
v -= p[l++];
}
ans = max(ans, v);
}
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool umin(T& a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool umax(T& a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
int n, w, k, sum = 0, total = 0, waste = 0, ans = 0;
int arr[200009], t[200009];
set<pair<int, int> > full, part;
void add(int x) {
full.insert(make_pair(t[x], x));
total += t[x];
sum += arr[x];
while (int(full.size()) > 0 and int(part.size()) > 0) {
pair<int, int> x1 = *(full.rbegin());
pair<int, int> x2 = *part.begin();
if (x2.first < x1.first) {
waste -= x2.first / 2;
waste += x1.first / 2;
full.erase(x1);
full.insert(x2);
part.insert(x1);
part.erase(x2);
} else
break;
}
while ((int)full.size() > 0 and (int) part.size() < w) {
pair<int, int> p = *full.rbegin();
full.erase(p);
part.insert(p);
waste += p.first / 2;
}
}
void rem(int x) {
sum -= arr[x];
total -= t[x];
if (full.find(make_pair(t[x], x)) != full.end())
full.erase(make_pair(t[x], x));
if (part.find(make_pair(t[x], x)) != part.end()) {
waste -= t[x] / 2;
part.erase(make_pair(t[x], x));
}
}
int main() {
scanf("%d%d%d", &n, &w, &k);
for (int i = 1; i <= n; i++) scanf("%d", arr + i);
for (int i = 1; i <= n; i++) scanf("%d", t + i);
int r = 0;
for (int i = 1; i <= n; i++) {
while (r < n) {
add(r + 1);
if (total - waste <= k) {
umax(ans, sum);
r++;
continue;
}
rem(r + 1);
break;
}
rem(i);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void sci(T& t) {
cin >> t;
}
template <typename T, typename... Ts>
void sci(T& t, Ts&... ts) {
sci(t);
sci(ts...);
}
int a[222222];
int t[222222];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, w, k;
sci(n, w, k);
int ans = 0;
set<pair<int, int>> ws;
set<pair<int, int>> rest;
int ct = 0;
int ca = 0;
for (int i = 0; i < n; i++) {
sci(a[i]);
}
for (int i = 0; i < n; i++) {
sci(t[i]);
}
int lst = -1;
for (int i = 0; i < n; i++) {
rest.insert({t[i], i});
ca += a[i];
ct += t[i];
if (ws.size() == w) {
auto it = ws.begin();
ct += it->first / 2;
rest.insert(*it);
ws.erase(it);
}
auto it = rest.rbegin();
ct -= it->first / 2;
ws.insert(*it);
rest.erase(*it);
while (ct > k) {
++lst;
auto p = make_pair(t[lst], lst);
if (ws.find(p) != ws.end()) {
ws.erase(p);
ct -= (t[lst] + 1) / 2;
} else {
rest.erase(p);
ct -= t[lst];
}
ca -= a[lst];
if (ws.size() < w && !rest.empty()) {
auto it = rest.rbegin();
ct -= it->first / 2;
ws.insert(*it);
rest.erase(*it);
}
}
ans = max(ans, ca);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
set<pair<int, int> > st1, st2;
int sum, tim;
int a[maxn], t[maxn];
void add(set<pair<int, int> > &st, int k, int c) {
st.insert(pair<int, int>(c * t[k], k));
if (c > 0)
tim += (t[k] + 1) >> 1;
else
tim += t[k];
sum += a[k];
}
bool del(set<pair<int, int> > &st, int k, int c) {
set<pair<int, int> >::iterator p = st.find(pair<int, int>(c * t[k], k));
if (p == st.end()) return false;
st.erase(p);
if (c > 0)
tim -= (t[k] + 1) >> 1;
else
tim -= t[k];
sum -= a[k];
return true;
}
int main() {
int n, w, k;
scanf("%d%d%d", &n, &w, &k);
for (int i = 1; i <= n; ++i) scanf("%d", a + i);
for (int i = 1; i <= n; ++i) scanf("%d", t + i);
int ans = 0;
tim = sum = 0;
for (int i = n, j = n; i >= 1; --i) {
if (st1.empty() || st1.size() < w) {
add(st1, i, 1);
} else {
set<pair<int, int> >::iterator p = st1.begin();
if (p->first < t[i]) {
add(st2, p->second, -1);
del(st1, p->second, 1);
add(st1, i, 1);
} else {
add(st2, i, -1);
}
}
while (tim > k) {
if (!del(st2, j, -1)) {
del(st1, j, 1);
if (!st2.empty()) {
add(st1, st2.begin()->second, 1);
del(st2, st2.begin()->second, -1);
}
}
--j;
}
if (j == n || k - (tim + t[j + 1]) < (t[j + 1] + 1) / 2)
ans = max(ans, sum);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:64000000")
const int infi = 1e9 + 7;
const long long infl = 1e18 + 7;
int a[200500];
int t[200500];
int used[200500];
int main() {
cin.sync_with_stdio(false);
cin.tie(0);
int n, w, k;
cin >> n >> w >> k;
for (int i = 0; i < n; ++i) cin >> a[i];
for (int i = 0; i < n; ++i) cin >> t[i];
set<pair<int, int> > mx, mn;
int l = n - 1, r = n - 1;
int ans = 0;
int sum_a = 0;
int sum_t = 0;
int sum_d = 0;
for (; l >= 0; --l) {
if ((int)mx.size() != w) {
mx.insert(make_pair(t[l], l));
used[l] = 1;
sum_d += t[l] / 2;
} else {
pair<int, int> a = *mx.begin();
if (a.first < t[l]) {
mx.erase(mx.begin());
mn.insert(a);
used[a.second] = 0;
mx.insert(make_pair(t[l], l));
used[l] = 1;
sum_d -= a.first / 2;
sum_d += t[l] / 2;
} else {
mn.insert(make_pair(t[l], l));
}
}
sum_t += t[l];
sum_a += a[l];
while (r >= l && sum_t - sum_d > k) {
if (used[r]) {
mx.erase(make_pair(t[r], r));
sum_d -= t[r] / 2;
if (mn.size()) {
pair<int, int> a = *(--mn.end());
mn.erase(--mn.end());
mx.insert(a);
used[a.second] = 1;
sum_d += a.first / 2;
}
} else {
mn.erase(make_pair(t[r], r));
}
sum_t -= t[r];
sum_a -= a[r];
--r;
}
ans = max(ans, sum_a);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
set<int> st, st2;
int n, w, k, a[200010], t[200010], j, vis[20010], sz, b[20010];
long long tot, ans, s[200010];
int main() {
scanf("%d%d%d", &n, &w, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) scanf("%d", &t[i]);
for (int i = 1; i <= n; i++) s[i] = s[i - 1] + a[i];
j = 1;
for (int i = 1; i <= n; i++) {
for (; j <= n; j++) {
int we = t[j];
if (sz < w) {
if (tot + (we + 1) / 2 > k) break;
if (!vis[we]) st.insert(we);
tot += (we + 1) / 2;
vis[we]++;
sz++;
} else {
int x = *st.begin();
if (x > we) {
if (tot + we > k) break;
tot += we;
if (!b[we]) st2.insert(we);
b[we]++;
} else {
if (tot + (we + 1) / 2 + x - (x + 1) / 2 > k) break;
if (!vis[we]) st.insert(we);
vis[we]++;
tot += (we + 1) / 2;
tot -= (x + 1) / 2;
tot += x;
if (vis[x] == 1) st.erase(x);
vis[x]--;
if (!b[x]) st2.insert(x);
b[x]++;
}
}
}
ans = max(ans, s[j - 1] - s[i - 1]);
if (!vis[t[i]]) {
tot -= t[i];
if (b[t[i]] == 1) st2.erase(t[i]);
b[t[i]]--;
} else {
if (vis[t[i]] == 1) st.erase(t[i]);
tot -= (t[i] + 1) / 2;
vis[t[i]]--;
sz--;
if (!st2.empty()) {
int tmp = *(--st2.end());
if (b[tmp] == 1) st2.erase(tmp);
b[tmp]--;
if (!vis[tmp]) st.insert(tmp);
tot -= tmp;
tot += (tmp + 1) / 2;
vis[tmp]++;
sz++;
}
}
}
printf("%I64d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1LL << 61;
const long long mod = 1000000007;
const int maxn = 2e5 + 10;
struct stu {
long long v;
int p;
bool operator<(const stu& b) const {
if (v != b.v)
return v < b.v;
else
return p < b.p;
}
};
long long a[maxn], tim_[maxn];
int type[maxn];
set<stu> parts;
set<stu> wholes;
bool comp(int x, int y);
int main() {
int i = 0, j = 0;
long long k = 0;
int n, w;
stu tmp;
set<stu>::iterator it, it1;
cin >> n >> w >> k;
for (i = 1; i <= n; i++) {
cin >> a[i];
}
for (i = 1; i <= n; i++) {
cin >> tim_[i];
}
memset(type, 0, sizeof(type));
long long tsum = 0, tpv = 0, maxv = 0;
int l = 1, r = 1;
for (r = 1; r <= n; r++) {
it = parts.begin();
int partv = (tim_[r] + 1) / 2;
if (parts.size() < w) {
tmp.v = partv;
tmp.p = r;
parts.insert(tmp);
type[r] = 1;
tpv += a[r];
tsum += tmp.v;
} else {
if (comp(r, it->p)) {
tmp = *it;
parts.erase(it);
tsum -= tmp.v;
tmp.v = tim_[tmp.p];
type[tmp.p] = 2;
wholes.insert(tmp);
tsum += tmp.v;
tmp.v = partv;
tmp.p = r;
parts.insert(tmp);
type[r] = 1;
tpv += a[r];
tsum += tmp.v;
} else {
tmp.v = tim_[r];
tmp.p = r;
type[r] = 2;
wholes.insert(tmp);
tsum += tmp.v;
tpv += a[r];
}
}
while (l <= r && tsum > k) {
if (type[l] == 1) {
tmp.v = (tim_[l] + 1) / 2;
tmp.p = l;
it = parts.find(tmp);
if (it != parts.end()) {
parts.erase(it);
tsum -= tmp.v;
tpv -= a[l];
if (wholes.size() > 0) {
it = parts.begin();
it1 = wholes.end();
it1--;
{
tmp = *it1;
wholes.erase(it1);
tsum -= tmp.v;
tmp.v = (tim_[tmp.p] + 1) / 2;
parts.insert(tmp);
tsum += tmp.v;
type[tmp.p] = 1;
}
}
}
} else {
tmp.v = tim_[l];
tmp.p = l;
it = wholes.find(tmp);
if (it != wholes.end()) {
wholes.erase(it);
tsum -= tmp.v;
tpv -= a[l];
}
}
l++;
}
maxv = max(maxv, tpv);
}
cout << maxv << endl;
return 0;
}
bool comp(int x, int y) { return tim_[x] >= tim_[y]; }
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200000;
set<pair<int, int> > full, half;
int ttime = 0, ples = 0;
int n, w, k;
int a[N], t[N];
int which[N];
void add(int id) {
ples += a[id];
if (half.size() < w) {
ttime += (t[id] + 1) / 2;
half.insert({t[id], id});
which[id] = 1;
return;
}
if (t[id] > half.begin()->first) {
pair<int, int> mov = *half.begin();
half.erase(half.begin());
which[mov.second] = 0;
which[id] = 1;
full.insert(mov);
half.insert({t[id], id});
ttime += mov.first - (mov.first + 1) / 2 + (t[id] + 1) / 2;
return;
}
which[id] = 0;
ttime += t[id];
full.insert({t[id], id});
}
void erase(int id) {
ples -= a[id];
if (which[id] == 0) {
ttime -= t[id];
full.erase({t[id], id});
return;
}
ttime -= (t[id] + 1) / 2;
half.erase({t[id], id});
if (full.empty()) return;
pair<int, int> nw = *full.rbegin();
ttime += (nw.first + 1) / 2 - nw.first;
full.erase(full.find(nw));
which[nw.second] = 1;
half.insert(nw);
}
int main(int argc, const char* argv[]) {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> w >> k;
for (int i = 0; i < (int)(n); i++) cin >> a[i];
for (int i = 0; i < (int)(n); i++) cin >> t[i];
int res = 0;
for (int lf = 0, rg = -1; lf < n; lf++) {
if (lf) erase(lf - 1);
if (ttime <= k) res = max(res, ples);
while (rg < n - 1 && ttime <= k) {
rg++;
add(rg);
if (ttime <= k) res = max(res, ples);
}
}
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, endt, val[200000 + 10], t[200000 + 10];
struct cmp1 {
bool operator()(const int &i, const int &j) {
return t[i] == t[j] ? i < j : t[i] < t[j];
}
};
struct cmp2 {
bool operator()(const int &i, const int &j) {
return t[i] == t[j] ? i > j : t[i] > t[j];
}
};
set<int, cmp1> myset;
set<int, cmp2> myset2;
template <class T>
void Read(T &x) {
char c;
while (c = getchar(), c != EOF)
if (c >= '0' && c <= '9') {
x = c - '0';
while (c = getchar(), c >= '0' && c <= '9') x = x * 10 + c - '0';
ungetc(c, stdin);
return;
}
}
void read() {
Read(n), Read(m), Read(endt);
for (int i = 1; i <= n; i++) Read(val[i]);
for (int i = 1; i <= n; i++) Read(t[i]);
}
void solve() {
int ans = 0, nowv = 0, nowt = 0, cnt = 0, x;
for (int l = 1, r = 1; l <= n; l++) {
while (r <= n) {
if (cnt < m) {
if (nowt + (t[r] + 1) / 2 <= endt) {
myset.insert(r);
nowt += (t[r] + 1) / 2;
nowv += val[r];
cnt++, r++;
} else
break;
} else {
int x = *myset.begin();
if (t[x] / 2 < t[r] / 2) {
if (nowt + t[x] - (t[x] + 1) / 2 + (t[r] + 1) / 2 <= endt) {
nowt += t[x] - (t[x] + 1) / 2 + (t[r] + 1) / 2;
nowv += val[r];
set<int>::iterator iit = myset.find(x);
myset.erase(iit);
myset2.insert(x);
myset.insert(r);
r++;
} else
break;
} else {
if (nowt + t[r] <= endt) {
myset2.insert(r);
nowt += t[r];
nowv += val[r];
r++;
} else
break;
}
}
}
if (l == r) continue;
ans = max(ans, nowv);
set<int>::iterator it = myset.find(l);
if (it == myset.end()) {
nowt -= t[l];
myset2.erase(myset2.find(l));
} else {
nowt -= (t[l] + 1) / 2;
myset.erase(it);
cnt--;
if (!myset2.empty()) {
x = *myset2.begin();
nowt += -t[x] + (t[x] + 1) / 2;
myset2.erase(myset2.begin());
myset.insert(x);
cnt++;
}
}
nowv -= val[l];
}
printf("%d\n", ans);
}
int main() {
read();
solve();
return 0;
}
|
#include <bits/stdc++.h>
const int maxn = 2e5 + 10;
using namespace std;
long long gcd(long long p, long long q) { return q == 0 ? p : gcd(q, p % q); }
long long qpow(long long p, long long q) {
long long f = 1;
while (q) {
if (q & 1) f = f * p % 1000000007;
p = p * p % 1000000007;
q >>= 1;
}
return f;
}
inline void umax(int &p, int q) {
if (p < q) p = q;
}
inline void umin(int &p, int q) {
if (p > q) p = q;
}
inline long long read() {
long long x = 0;
int f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int n, m, k, w, a[maxn], t[maxn], ma, now;
set<pair<int, int> > full, half;
int main() {
int i, j;
scanf("%d%d%d", &n, &k, &w);
for (i = 1; i <= n; i++) a[i] = read();
for (i = 1; i <= n; i++) t[i] = read();
int l, r;
l = r = 1;
while (r <= n) {
while (r <= n) {
if (k) {
if (w >= (t[r] + 1) / 2) {
w -= (t[r] + 1) / 2;
umax(ma, now += a[r]);
half.insert(make_pair(t[r], r));
r++;
k--;
} else
break;
} else {
int tmp = half.begin()->first;
if (tmp < t[r] && w >= (t[r] + 1) / 2 - (tmp + 1) / 2 + tmp) {
w -= (t[r] + 1) / 2 - (tmp + 1) / 2 + tmp;
umax(ma, now += a[r]);
auto p = half.begin();
full.insert(*p);
half.erase(p);
half.insert(make_pair(t[r], r));
r++;
} else if (tmp >= t[r] && w >= t[r]) {
w -= t[r];
umax(ma, now += a[r]);
full.insert(make_pair(t[r], r));
r++;
} else
break;
}
}
if (l < r) {
if (full.find(make_pair(t[l], l)) != full.end()) {
w += t[l];
now -= a[l];
full.erase(make_pair(t[l], l));
} else {
w += (t[l] + 1) / 2;
now -= a[l];
half.erase(make_pair(t[l], l));
k++;
if (!full.empty()) {
auto p = --full.end();
w += p->first - (p->first + 1) / 2;
half.insert(*p);
k--;
full.erase(p);
}
}
l++;
} else
l++, r++;
}
printf("%d\n", ma);
return 0;
}
|
#include <bits/stdc++.h>
const int N = 2e5 + 10;
const int MOD = 1e9 + 7;
const int INF = 2e9;
const long long INFLL = 1e18;
const double PI = acos((double)-1);
inline int mult(int a, int b, int p = MOD) { return (1ll * a * b) % p; }
inline int add(int a, int b, int p = MOD) { return (1ll * a + b) % p; }
inline int fpow(long long n, long long k, int p = MOD) {
long long r = 1;
for (; k; k >>= 1) {
if (k & 1) r = r * n % p;
n = n * n % p;
}
return r;
}
inline int inv(int a, int p = MOD) { return fpow(a, p - 2, p); }
using namespace std;
int a[N], b[N], half[N];
int w, n, k;
int main() {
ios::sync_with_stdio(false);
cin >> n >> w >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) cin >> b[i];
for (int i = 1; i <= n; i++) half[i] = b[i] / 2 + (b[i] & 1);
multiset<pair<int, int> > p;
priority_queue<pair<int, int>, vector<pair<int, int> > > q;
int t = 0, x = 0;
int left = 0;
int right = -1;
int ans = 0;
if (right < n) {
for (int j = 1; j <= n; j++) {
if (right >= left) {
auto it = p.find({half[left], left});
if (it != p.end()) {
p.erase(it);
t -= half[left];
x -= a[left];
} else {
t -= b[left];
x -= a[left];
}
} else
right = left;
if (!q.empty() && p.size() < w) {
auto tmp = q.top();
q.pop();
t -= b[tmp.second];
t += tmp.first;
p.insert(tmp);
}
left++;
while (!q.empty()) {
pair<int, int> tmp3 = q.top();
if (tmp3.second >= left) break;
q.pop();
}
for (int i = right + 1; i <= n; i++) {
if (t + half[i] > k) break;
if (p.size() < w) {
t += half[i];
p.insert({half[i], i});
} else {
pair<int, int> tmp;
tmp.first = p.begin()->first;
int z = p.begin()->second;
tmp.second = b[z];
pair<int, int> tmp2 = {half[i], b[i]};
bool flag = false;
if (!q.empty()) {
pair<int, int> tmp3 = q.top();
tmp3.second = b[tmp3.second];
if (tmp3 > tmp2) {
swap(tmp2, tmp3);
flag = true;
}
}
if (tmp2 > tmp) {
if (t + half[i] - tmp.first + tmp.second > k) break;
t += half[i];
t -= tmp.first;
t += tmp.second;
p.erase(p.begin());
p.insert({half[i], i});
if (flag) {
q.pop();
q.push({half[i], i});
}
q.push({tmp.first, z});
} else {
if (t + b[i] > k) break;
t += b[i];
q.push({half[i], i});
}
}
x += a[i];
right++;
}
ans = max(ans, x);
if (right == n) break;
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
int w, n, k;
int a[N], t[N];
int curpleasure = 0;
int curtime = 0;
multiset<pair<int, int> > top, bot;
void balance() {
while (top.size() > w) {
pair<int, int> p = *top.begin();
top.erase(top.begin());
curtime -= (p.first + 1) / 2;
curtime += p.first;
bot.insert(p);
}
while (top.size() < w && !bot.empty()) {
pair<int, int> p = *bot.rbegin();
bot.erase(--bot.end());
curtime -= p.first;
curtime += (p.first + 1) / 2;
top.insert(p);
}
}
int insert(int index) {
if (top.empty() && bot.empty()) {
curtime += (t[index] + 1) / 2;
curpleasure += a[index];
top.insert(make_pair(t[index], a[index]));
} else {
if (top.empty() || t[index] >= top.begin()->first) {
curtime += (t[index] + 1) / 2;
curpleasure += a[index];
top.insert(make_pair(t[index], a[index]));
} else {
curtime += t[index];
curpleasure += a[index];
bot.insert(make_pair(t[index], a[index]));
}
}
balance();
return curtime;
}
int erase(int index) {
pair<int, int> p(t[index], a[index]);
multiset<pair<int, int> >::iterator it = top.find(p);
if (it != top.end()) {
curtime -= (p.first + 1) / 2;
curpleasure -= p.second;
top.erase(it);
} else {
it = bot.find(p);
curtime -= p.first;
curpleasure -= p.second;
bot.erase(it);
}
balance();
return curtime;
}
int simulate(int index) {
int ans = insert(index);
erase(index);
return ans;
}
int main() {
scanf("%d%d%d", &n, &w, &k);
for (int i = 0; i < n; ++i) scanf("%d", a + i);
for (int i = 0; i < n; ++i) scanf("%d", t + i);
int R = 0;
int mxpleasure = 0;
for (int L = 0; L < n; ++L) {
while (R < n && simulate(R) <= k) {
insert(R++);
}
mxpleasure = max(mxpleasure, curpleasure);
if (R == L) insert(R++);
erase(L);
}
printf("%d\n", mxpleasure);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXSIZE = 30000020;
int bufpos;
char buf[MAXSIZE];
void init() {
buf[fread(buf, 1, MAXSIZE, stdin)] = '\0';
bufpos = 0;
}
int readint() {
int val = 0;
for (; !isdigit(buf[bufpos]); bufpos++)
;
for (; isdigit(buf[bufpos]); bufpos++) val = val * 10 + buf[bufpos] - '0';
return val;
}
char readchar() {
for (; isspace(buf[bufpos]); bufpos++)
;
return buf[bufpos++];
}
int readstr(char* s) {
int cur = 0;
for (; isspace(buf[bufpos]); bufpos++)
;
for (; !isspace(buf[bufpos]); bufpos++) s[cur++] = buf[bufpos];
s[cur] = '\0';
return cur;
}
const int maxn = 200002;
struct segtree {
int n;
int cnt[40002], sum[40001];
int p, v0, v1;
int qwq;
void update(int p, int v0, int v1) {
int o = 1, l = 1, r = n;
while (l < r) {
int mid = (l + r) / 2;
if (p <= mid)
o *= 2, r = mid;
else
o = o * 2 + 1, l = mid + 1;
cnt[o] += v0;
sum[o] += v1;
}
cnt[o] += v0;
sum[o] += v1;
}
void add(int x) {
qwq += x;
update(x, 1, x / 2);
}
void del(int x) {
qwq -= x;
update(x, -1, -x / 2);
}
int query(int k) {
int o = 1, l = 1, r = n, res = 0;
while (l < r) {
int mid = (l + r) / 2;
if (k > cnt[o * 2 + 1])
k -= cnt[o * 2 + 1], res += sum[o * 2 + 1], o = o * 2, r = mid;
else
o = o * 2 + 1, l = mid + 1;
}
if (k > cnt[o])
return qwq - res - sum[o];
else
return qwq - res - sum[o] / cnt[o] * k;
}
} t;
int a[maxn], qwq[maxn], sum[maxn];
int main() {
init();
int n = readint(), w = readint(), k = readint();
for (int i = 1; i <= n; i++) a[i] = readint();
for (int i = 1; i <= n; i++) qwq[i] = readint();
for (int i = n; i; i--) sum[i] = sum[i + 1] + a[i];
t.n = 10000;
int j = 0, ans = 0;
for (int i = 1; i <= n; i++) {
while (t.query(w) <= k) {
j++;
if (j > n) break;
t.add(qwq[j]);
}
ans = max(ans, sum[i] - sum[j]);
t.del(qwq[i]);
}
printf("%d", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, w, k;
int inf, l, r, sum, val, ans;
int a[200005], f[200005], _f[200005], h[200005], _h[200005];
namespace Min {
int minn[200005 * 4];
void update(int now) {
if (_h[minn[now << 1]] <= _h[minn[now << 1 | 1]])
minn[now] = minn[now << 1];
else
minn[now] = minn[now << 1 | 1];
}
void build(int now, int l, int r) {
int mid = (l + r) >> 1;
if (l == r) {
minn[now] = l;
return;
}
build(now << 1, l, mid);
build(now << 1 | 1, mid + 1, r);
update(now);
}
void change(int now, int l, int r, int x) {
int mid = (l + r) >> 1;
if (l == r) {
minn[now] = x;
return;
}
if (x <= mid)
change(now << 1, l, mid, x);
else
change(now << 1 | 1, mid + 1, r, x);
update(now);
}
int query(int now, int l, int r, int lrange, int rrange) {
if (lrange > rrange) return 0;
int mid = (l + r) >> 1, ans = 0;
if (lrange <= l && r <= rrange) return minn[now];
if (lrange <= mid) {
int q = query(now << 1, l, mid, lrange, rrange);
if (_h[ans] > _h[q]) ans = q;
}
if (mid + 1 <= rrange) {
int q = query(now << 1 | 1, mid + 1, r, lrange, rrange);
if (_h[ans] > _h[q]) ans = q;
}
return ans;
}
} // namespace Min
namespace Max {
int maxn[200005 * 4];
void update(int now) {
if (_f[maxn[now << 1]] >= _f[maxn[now << 1 | 1]])
maxn[now] = maxn[now << 1];
else
maxn[now] = maxn[now << 1 | 1];
}
void build(int now, int l, int r) {
int mid = (l + r) >> 1;
if (l == r) {
maxn[now] = l;
return;
}
build(now << 1, l, mid);
build(now << 1 | 1, mid + 1, r);
update(now);
}
void change(int now, int l, int r, int x) {
int mid = (l + r) >> 1;
if (l == r) {
maxn[now] = x;
return;
}
if (x <= mid)
change(now << 1, l, mid, x);
else
change(now << 1 | 1, mid + 1, r, x);
update(now);
}
int query(int now, int l, int r, int lrange, int rrange) {
if (lrange > rrange) return 0;
int mid = (l + r) >> 1, ans = 0;
if (lrange <= l && r <= rrange) return maxn[now];
if (lrange <= mid) {
int q = query(now << 1, l, mid, lrange, rrange);
if (_f[ans] < _f[q]) ans = q;
}
if (mid + 1 <= rrange) {
int q = query(now << 1 | 1, mid + 1, r, lrange, rrange);
if (_f[ans] < _f[q]) ans = q;
}
return ans;
}
} // namespace Max
int main() {
scanf("%d%d%d", &n, &w, &k);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (int i = 1; i <= n; ++i) {
scanf("%d", &f[i]);
_f[i] = f[i];
h[i] = (f[i] - 1) / 2 + 1;
}
memset(_h, 127, sizeof(_h));
inf = _h[0];
Max::build(1, 1, n);
Min::build(1, 1, n);
while (l <= n) {
if (l <= r) {
val -= a[l];
if (_h[l] != inf) {
sum -= h[l];
int loc = Max::query(1, 1, n, l, r);
if (loc) {
sum -= f[loc] - h[loc];
_f[loc] = 0;
_h[loc] = h[loc];
Max::change(1, 1, n, loc);
Min::change(1, 1, n, loc);
} else
++w;
} else
sum -= f[l];
}
++l;
r = max(r, l - 1);
while (r < n) {
if (w) {
if (sum + h[r + 1] <= k) {
sum += h[r + 1];
_f[r + 1] = 0;
_h[r + 1] = h[r + 1];
Max::change(1, 1, n, r + 1);
Min::change(1, 1, n, r + 1);
--w;
val += a[++r];
} else
break;
} else {
int loc = Min::query(1, 1, n, l, r);
if (loc && f[loc] - h[loc] < f[r + 1] - h[r + 1] &&
sum - h[loc] + f[loc] + h[r + 1] <= k) {
sum += f[loc] - h[loc];
_f[loc] = f[loc];
_h[loc] = inf;
Max::change(1, 1, n, loc);
Min::change(1, 1, n, loc);
sum += h[r + 1];
_f[r + 1] = 0;
_h[r + 1] = h[r + 1];
Max::change(1, 1, n, r + 1);
Min::change(1, 1, n, r + 1);
val += a[++r];
} else if (sum + f[r + 1] <= k) {
sum += f[r + 1];
val += a[++r];
} else
break;
}
}
ans = max(ans, val);
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int P = 1e9 + 7, INF = 0x3f3f3f3f;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long qpow(long long a, long long n) {
long long r = 1 % P;
for (a %= P; n; a = a * a % P, n >>= 1)
if (n & 1) r = r * a % P;
return r;
}
long long inv(long long first) {
return first <= 1 ? 1 : inv(P % first) * (P - P / first) % P;
}
const int N = 1e6 + 10;
int n, w, k;
int a[N], t[N];
pair<int, int> r[N];
set<pair<int, int> > s;
set<pair<int, int>, greater<pair<int, int> > > res;
int main() {
scanf("%d%d%d", &n, &w, &k);
for (int i = 1; i <= n; ++i) scanf("%d", a + i);
for (int i = 1; i <= n; ++i)
scanf("%d", t + i), r[i] = pair<int, int>(t[i] / 2, i);
int now = 1, c = 0, p = 0, ans = 0;
for (int i = 1; i <= n; ++i) {
while (now <= n && c < k) {
c += t[now] - r[now].first;
p += a[now];
s.insert(r[now]);
if (s.size() == w + 1) {
c += s.begin()->first;
res.insert(*s.begin());
s.erase(s.begin());
}
if (c <= k) ans = max(ans, p);
++now;
}
if (res.count(r[i])) res.erase(r[i]);
if (s.count(r[i])) {
s.erase(r[i]), c -= t[i] - r[i].first;
if (res.size()) {
c -= res.begin()->first;
s.insert(*res.begin()), res.erase(res.begin());
}
} else
c -= t[i];
p -= a[i];
if (c <= k) ans = max(ans, p);
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int a[200010], t[200010];
bool inHalf[200010];
set<pair<int, int> > half, normal;
int main() {
int n, w, k;
scanf("%d%d%d", &n, &w, &k);
for (int i = 1; i <= n; i++) scanf("%d", a + i);
for (int i = 1; i <= n; i++) scanf("%d", t + i);
long long nowSum = 0, sumP = 0;
long long ans = 0;
int pos = 0;
for (int i = 1; i <= n; i++) {
if ((t[i] + 1) / 2 > k) {
nowSum = 0;
sumP = 0;
if (half.size())
for (auto it = half.begin(); it != half.end(); it++)
inHalf[it->second] = false;
half.clear();
normal.clear();
pos = i;
} else {
while (pos < n && (int)half.size() < w &&
nowSum + (t[pos + 1] + 1) / 2 <= k) {
pos++;
inHalf[pos] = true;
nowSum += (t[pos] + 1) / 2;
sumP += a[pos];
half.insert(pair<int, int>(t[pos], pos));
}
while (pos < n && nowSum <= k) {
long long nxtSum = nowSum;
if (!half.empty() &&
(half.begin()->first + 1) / 2 < (t[pos + 1] + 1) / 2) {
nxtSum -= (half.begin()->first + 1) / 2;
nxtSum += (t[pos + 1] + 1) / 2 + half.begin()->first;
if (nxtSum <= k) {
inHalf[half.begin()->second] = false;
inHalf[pos + 1] = true;
normal.insert(*half.begin());
half.erase(half.begin());
half.insert(pair<int, int>(t[pos + 1], pos + 1));
}
} else {
nxtSum += t[pos + 1];
if (nxtSum <= k) {
normal.insert(pair<int, int>(t[pos + 1], pos + 1));
}
}
if (nxtSum <= k) {
nowSum = nxtSum;
++pos;
sumP += a[pos];
} else
break;
}
}
ans = max(ans, sumP);
if (inHalf[i]) {
nowSum -= (t[i] + 1) / 2;
half.erase(pair<int, int>(t[i], i));
if (!normal.empty()) {
auto it = normal.end();
it--;
half.insert(*it);
inHalf[it->second] = true;
nowSum -= (t[it->second]) / 2;
normal.erase(it);
}
inHalf[i] = false;
} else {
nowSum -= t[i];
normal.erase(pair<int, int>(t[i], i));
}
sumP -= a[i];
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
priority_queue<pair<int, int> > ma;
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
mi;
int timp, pleasure, a[200005], t[200005], misize, w, st, f[200005], n, k, i,
ans;
void update() {
while (misize < w and !ma.empty()) {
if (ma.top().second < st) {
ma.pop();
continue;
}
mi.push(ma.top()), misize++;
timp -= t[ma.top().second] / 2;
f[ma.top().second] = 1;
ma.pop();
}
while (misize > 0 and !ma.empty() and ma.top().first > mi.top().first) {
if (ma.top().second < st) {
ma.pop();
continue;
}
if (mi.top().second < st) {
mi.pop();
continue;
}
pair<int, int> x, y;
x = ma.top();
y = mi.top();
timp -= ma.top().first / 2;
timp += mi.top().first / 2;
f[x.second] = 1;
f[y.second] = 0;
ma.pop(), mi.pop();
ma.push(y), mi.push(x);
}
}
int main() {
cin >> n >> w >> k;
for (i = 1; i <= n; i++) cin >> a[i];
for (i = 1; i <= n; i++) cin >> t[i];
st = 1;
for (i = 1; i <= n; i++) {
ma.push({t[i], i});
timp += t[i];
pleasure += a[i];
update();
while (timp > k) {
if (f[st] == 1)
timp -= (t[st] + 1) / 2, misize--;
else
timp -= t[st];
pleasure -= a[st];
st++;
update();
}
ans = max(ans, pleasure);
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int n, w, k;
cin >> n >> w >> k;
vector<long long int> a(n), t(n);
for (int i = 0; i < n; ++i) cin >> a[i];
for (int i = 0; i < n; ++i) cin >> t[i];
long long int l = 0, mx = 0, nw = 0, f = -1, sm = 0;
multiset<int> s, m;
for (int r = 0; r < n; ++r) {
nw += (t[r] + 1) / 2;
sm += a[r];
m.insert(t[r]);
if (m.size() > w) {
s.insert(*m.begin());
nw += *m.begin() / 2;
m.erase(m.begin());
}
while (l <= r && nw > k) {
if (t[l] >= *m.begin()) {
nw -= (t[l] + 1) / 2;
m.erase(m.find(t[l]));
if (s.size()) {
auto p = --s.end();
m.insert(*p);
nw -= *p / 2;
s.erase(p);
}
} else {
s.erase(s.find(t[l]));
nw -= t[l];
}
sm -= a[l];
l++;
}
mx = max(mx, sm);
}
cout << mx;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2 * 111111;
struct Data {
int t, id;
Data() {}
Data(int _t, int _id) {
t = _t;
id = _id;
}
bool operator<(const Data& B) const {
return (t == B.t) ? (id < B.id) : t < B.t;
}
bool operator==(const Data& B) const { return t == B.t && id == B.id; }
};
struct node {
int t, v;
} a[maxn];
set<Data> S1, S2;
int nowt = 0, tot = -1, st = 0;
void Insert(int ty, int t, int id) {
if (ty == 1) {
S1.insert(Data(t, id));
nowt += t;
} else {
S2.insert(Data(t, id));
nowt += ((t - 1) / 2 + 1);
}
}
void Erase(int ty, int t, int id) {
if (ty == 1) {
S1.erase(Data(t, id));
nowt -= t;
} else {
S2.erase(Data(t, id));
nowt -= ((t - 1) / 2 + 1);
}
}
void ERASE(int st) {
if (S1.find(Data(a[st].t, st)) != S1.end())
Erase(1, a[st].t, st);
else {
Erase(2, a[st].t, st);
if (S1.size() > 0) {
Data tmp = *(--S1.end());
Erase(1, tmp.t, tmp.id);
Insert(2, tmp.t, tmp.id);
}
}
}
int n, w, k;
int main() {
cin >> n >> w >> k;
for (int i = 0; i < n; i++) cin >> a[i].v;
for (int i = 0; i < n; i++) cin >> a[i].t;
int ans = 0, ANS = 0;
while (st != n) {
while (nowt <= k) {
tot++;
if (tot >= n) break;
if (S2.size() < w) {
Insert(2, a[tot].t, tot);
} else {
Data tmp = *S2.begin();
if (tmp.t < a[tot].t) {
Erase(2, tmp.t, tmp.id);
Insert(1, tmp.t, tmp.id);
Insert(2, a[tot].t, tot);
} else
Insert(1, a[tot].t, tot);
}
if (nowt <= k)
ans += a[tot].v;
else {
ERASE(tot);
tot--;
break;
}
ANS = max(ANS, ans);
}
ERASE(st);
ans -= a[st].v;
st++;
}
cout << ANS << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
int n, w, k;
int a[maxn];
int t[maxn];
set<pair<long long, int> > All, Jump;
long long duration, cost;
int half(int t) { return (t / 2) + (t % 2); }
void correct() {
while (Jump.size() < w && !All.empty()) {
pair<long long, int> P = *All.rbegin();
duration -= P.first;
duration += half(P.first);
Jump.insert(P);
All.erase(P);
}
while (!All.empty() && All.rbegin()->first > Jump.begin()->first) {
pair<long long, int> p = *Jump.begin();
duration -= half(p.first);
duration += p.first;
Jump.erase(p);
pair<long long, int> P = *All.rbegin();
duration -= P.first;
duration += half(P.first);
All.erase(P);
Jump.insert(P);
All.insert(p);
}
}
long long solve() {
int r = n;
long long ans = 0;
for (int l = n; l >= 1; --l) {
duration += t[l];
cost += a[l];
All.insert({t[l], l});
correct();
while (duration > k) {
pair<long long, int> P = {t[r], r};
cost -= a[r];
if (Jump.find(P) != Jump.end()) {
Jump.erase(P);
duration -= half(t[r]);
} else {
All.erase(P);
duration -= t[r];
}
--r;
}
correct();
ans = max(ans, cost);
}
return ans;
}
int main() {
scanf("%d %d %d", &n, &w, &k);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (int i = 1; i <= n; ++i) scanf("%d", &t[i]);
printf("%lld\n", solve());
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")
using namespace std;
template <typename T>
constexpr int infValue =
std::is_same<T, int>::value ? 2000000007 : 8600000000000000007ll;
template <typename T>
constexpr int maxValue =
std::is_same<T, int>::value ? 1000000007 : 1000000000000000001ll;
const int INF = infValue<int>;
const int MOD = 1000000007ll;
const double EPS = 1e-6;
const int MAX = maxValue<int>;
int n, w, k;
int a[200101], t[200101];
set<pair<int, int> > q;
priority_queue<pair<int, int> > f;
int answ;
int main(void) {
scanf("%d %d %d", &n, &w, &k);
for (register int i = 0; i < n; ++i) scanf("%d", a + i);
for (register int i = 0; i < n; ++i) scanf("%d", t + i);
int i = 0, j = 0, s = 0;
while (i < n) {
while (j < n) {
if (q.size() == w) {
if (q.begin()->first > t[j]) {
if (t[j] > k) break;
k -= t[j];
s += a[j];
f.push({t[j], j});
} else {
int v = -(q.begin()->first + 1 >> 1) + q.begin()->first +
((t[j] + 1) >> 1);
if (v > k) break;
k -= v;
f.push(*q.begin());
q.erase(q.begin());
q.insert({t[j], j});
s += a[j];
}
} else {
if (k < t[j] + 1 >> 1) break;
q.insert({t[j], j}), s += a[j], k -= t[j] + 1 >> 1;
}
++j;
}
answ = max(answ, s);
auto u = q.find({t[i], i});
if (u != q.end()) {
q.erase(u);
s -= a[i];
k += t[i] + 1 >> 1;
while (!f.empty() && f.top().second < i) f.pop();
if (!f.empty()) {
auto vx = f.top();
int v = (vx.first + 1 >> 1) - vx.first;
q.insert(vx);
f.pop();
k -= v;
}
} else if (i < j) {
k += t[i];
s -= a[i];
}
++i;
}
printf("%d\n", answ);
return 0;
}
|
#include <bits/stdc++.h>
const int N = 200100;
using namespace std;
int n, k, w, a[N], t[N];
set<pair<int, int> > ft, pt;
set<pair<int, int> >::iterator it;
int main() {
scanf("%d%d%d", &n, &w, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) scanf("%d", &t[i]);
int l = 1, r = 1, mx = 0, ans = 0, time = 0;
while (r <= n) {
while (time <= k && r <= n) {
if (pt.size() < w) {
time += (t[r] + 1) / 2;
pt.insert(make_pair(t[r], r));
} else if (pt.begin()->first < t[r]) {
it = pt.begin();
time += (it->first) / 2 + (t[r] + 1) / 2;
ft.insert(*it);
pt.erase(*it);
pt.insert(make_pair(t[r], r));
} else {
time += t[r];
ft.insert(make_pair(t[r], r));
}
ans += a[r++];
if (time <= k) mx = max(mx, ans);
}
while (time > k) {
if (pt.count(make_pair(t[l], l))) {
pt.erase(make_pair(t[l], l));
time -= (t[l] + 1) / 2;
if (!ft.empty()) {
time -= (ft.rbegin()->first) / 2;
pt.insert(*ft.rbegin());
ft.erase(*ft.rbegin());
}
} else {
ft.erase(make_pair(t[l], l));
time -= t[l];
}
ans -= a[l++];
if (time <= k) mx = max(mx, ans);
}
}
printf("%d\n", mx);
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, w, k;
scanf("%d%d%d", &n, &w, &k);
int anw = 0, t = 0, b = 0, j = n - 1;
vector<int> a(n), c(n);
for (int &p : a) scanf("%d", &p);
for (int &p : c) scanf("%d", &p);
set<pair<int, int> > I, O;
for (int i = n - 1; i >= 0; i--) {
t += a[i];
pair<int, int> e = {c[i], i};
bool g = 1;
if (int(I.size()) < w)
I.insert(e);
else if ((*I.begin()).first <= c[i]) {
e = *I.begin();
b += e.first / 2;
e.first *= -1;
O.insert(e);
I.erase(I.begin());
I.insert({c[i], i});
} else {
g = 0;
b += c[i];
O.insert({-c[i], i});
}
if (g) b += (c[i] + 1) / 2;
while (b > k) {
t -= a[j];
pair<int, int> e = {c[j], j};
if (I.count(e)) {
b -= (c[j] + 1) / 2;
I.erase(e);
if (!O.empty()) {
e = *O.begin();
O.erase(e);
e.first *= -1;
b -= e.first / 2;
I.insert(e);
}
} else {
e.first *= -1;
O.erase(e);
b -= c[j];
}
j--;
}
anw = max(anw, t);
}
printf("%d\n", anw);
}
|
#include <bits/stdc++.h>
std::priority_queue<std::pair<int, int> > pq1, pq2;
int n, w, k, a[200005], t[200005], p[200005], s, ans, now, cnt[5];
void c(std::priority_queue<std::pair<int, int> > &pq, int id) {
while (!pq.empty()) {
if (p[pq.top().second] == id) return;
pq.pop();
}
}
void cl() {
c(pq1, 1);
c(pq2, 2);
}
void del(int x) {
if (!x) return;
s = s - a[x];
if (p[x] == 2)
now = now - t[x], --cnt[2], p[x] = 0, cl();
else {
now = now - (t[x] + 1) / 2, --cnt[1], p[x] = 0;
c(pq1, 1);
c(pq2, 2);
while (cnt[2] && cnt[1] < w) {
int x = pq2.top().second;
pq2.pop();
p[x] = 1;
++cnt[1];
--cnt[2];
pq1.push(std::make_pair(-t[x], x));
now = now - t[x] + (t[x] + 1) / 2;
cl();
}
}
}
int calc(int x) {
if (!x) return 0;
if (cnt[1] < w) return (t[x] + 1) / 2;
int y = pq1.top().second;
if (t[y] > t[x]) return t[x];
return (t[x] + 1) / 2 + t[y] - (t[y] + 1) / 2;
}
void add(int x) {
if (!x) return;
s = s + a[x];
if (cnt[1] < w)
return ++cnt[1], now = now + (t[x] + 1) / 2, p[x] = 1,
pq1.push(std::make_pair(-t[x], x)), cl(), void();
int y = pq1.top().second;
if (t[y] > t[x])
return ++cnt[2], now = now + t[x], p[x] = 2,
pq2.push(std::make_pair(t[x], x)), cl(), void();
now = now + (t[x] + 1) / 2 + t[y] - (t[y] + 1) / 2;
++cnt[2];
pq1.pop();
pq1.push(std::make_pair(-t[x], x));
pq2.push(std::make_pair(t[y], y));
p[x] = 1;
p[y] = 2;
cl();
}
int main() {
scanf("%d%d%d", &n, &w, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) scanf("%d", &t[i]);
int l = 0, r = 0;
while (l < n) {
del(l++);
while (r < n)
if (now + calc(r + 1) <= k)
add(++r);
else
break;
ans = std::max(ans, s);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int arr[200005];
int happy[200005];
inline long max(long x, long y) { return x > y ? x : y; }
int main() {
long N, W, K;
while (scanf("%ld %ld %ld", &N, &W, &K) != EOF) {
long result = 0, RESULT = 0;
set<pair<int, int> > S_, S;
for (int i = 1; i <= N; ++i) scanf("%d", happy + i);
for (int i = 1; i <= N; ++i) scanf("%d", arr + i);
int l, r;
l = r = 1;
while (r <= N) {
while (r <= N) {
if (W) {
if (K >= (arr[r] + 1) / 2) {
K -= (arr[r] + 1) / 2;
RESULT = max(RESULT, result += happy[r]);
S_.insert(make_pair(arr[r], r));
r++;
W--;
} else
break;
} else {
int tmp = S_.begin()->first;
if (tmp <= arr[r] && K >= (arr[r] + 1) / 2 - (tmp + 1) / 2 + tmp) {
K -= (arr[r] + 1) / 2 - (tmp + 1) / 2 + tmp;
RESULT = max(RESULT, result += happy[r]);
auto p = S_.begin();
S.insert(*p);
S_.erase(p);
S_.insert(make_pair(arr[r], r));
r++;
} else if (tmp > arr[r] && K >= arr[r]) {
K -= arr[r];
RESULT = max(RESULT, result += happy[r]);
S.insert(make_pair(arr[r], r));
r++;
} else
break;
}
}
if (l < r) {
if (S.find(make_pair(arr[l], l)) != S.end()) {
K += arr[l];
result -= happy[l];
S.erase(make_pair(arr[l], l));
} else {
K += (arr[l] + 1) / 2;
result -= happy[l];
S_.erase(make_pair(arr[l], l));
W++;
if (!S.empty()) {
auto p = --S.end();
K += p->first - (p->first + 1) / 2;
S_.insert(*p);
W--;
S.erase(p);
}
}
l++;
} else
l++, r++;
}
printf("%d\n", RESULT);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
inline void up(int& x, int y) {
if (y > x) x = y;
}
int n, w, k, a[N], t[N], ans;
struct HeapA {
priority_queue<int> A, B;
int size() { return A.size() - B.size(); }
void update() {
while (B.size() && A.top() == B.top()) A.pop(), B.pop();
}
void push(int x) { A.push(x); }
void del(int x) { B.push(x); }
void pop() {
update();
A.pop();
}
int top() {
update();
return A.top();
}
} A;
struct Heap {
priority_queue<int, vector<int>, greater<int> > A, B;
int size() { return A.size() - B.size(); }
void update() {
while (B.size() && A.top() == B.top()) A.pop(), B.pop();
}
void push(int x) { A.push(x); }
void del(int x) { B.push(x); }
void pop() {
update();
A.pop();
}
int top() {
update();
return A.top();
}
} B;
int main() {
scanf("%d%d%d", &n, &w, &k);
for (int i = (1); i <= (n); ++i) scanf("%d", &a[i]);
for (int i = (1); i <= (n); ++i) scanf("%d", &t[i]);
for (int i = n, j = n, sum = 0, st = 0; i >= 1; --i) {
st += t[i];
if (B.size() == w && t[i] / 2 > B.top())
st += B.top(), A.push(B.top()), B.pop();
if (B.size() < w)
B.push(t[i] / 2), st -= t[i] / 2;
else
A.push(t[i] / 2);
sum += a[i];
while (st > k) {
sum -= a[j];
st -= t[j];
if (t[j] / 2 >= B.top())
B.del(t[j] / 2), st += t[j] / 2;
else
A.del(t[j] / 2);
if (B.size() < w && A.size()) B.push(A.top()), st -= A.top(), A.pop();
--j;
}
up(ans, sum);
}
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int SZ = 200333;
int N, W, T;
int a[SZ], t[SZ];
struct State {
multiset<int> L, H;
int aSum, tSum;
void init() {
L.clear();
H.clear();
aSum = tSum = 0;
}
int partly(int t) { return (t + 1) / 2; }
void insert(int a, int t) {
if (H.size() < W) {
H.insert(t);
tSum += partly(t);
} else if (*H.begin() < t) {
int tt = *H.begin();
H.erase(H.begin());
tSum -= partly(tt);
L.insert(tt);
tSum += tt;
H.insert(t);
tSum += partly(t);
} else {
L.insert(t);
tSum += t;
}
aSum += a;
}
void erase(int a, int t) {
if (L.find(t) != L.end()) {
L.erase(L.find(t));
tSum -= t;
} else {
H.erase(H.find(t));
tSum -= partly(t);
if (L.size()) {
int tt = *prev(L.end());
L.erase(prev(L.end()));
tSum -= tt;
H.insert(tt);
tSum += partly(tt);
}
}
aSum -= a;
}
void print() {
cout << "[debug] " << tSum << " :";
for (int t : L) cout << t << " ";
cout << " ";
for (int t : H) cout << t << " ";
cout << endl;
}
};
int main() {
scanf("%d%d%d", &N, &W, &T);
for (int i = 0; i < (N); i++) scanf("%d", a + i);
for (int i = 0; i < (N); i++) scanf("%d", t + i);
int ans = -123;
State s;
s.init();
int hi = N - 1;
for (int lo = N - 1; lo >= 0; lo--) {
s.insert(a[lo], t[lo]);
while (T < s.tSum) {
s.erase(a[hi], t[hi]);
hi--;
}
ans = max(ans, s.aSum);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2E5 + 10;
int n, w, K;
int a[MAXN], sa[MAXN];
int t[MAXN], first[MAXN], loc[MAXN];
pair<int, int> b[MAXN];
int s[MAXN][2];
void update(int i, int c0, int c1) {
for (; i <= n; i = (i | i - 1) + 1) s[i][0] += c0, s[i][1] += c1;
}
int count() {
int i = 0, step = 1 << 31 - __builtin_clz(n);
int t = w, sum = 0;
for (; step; step >>= 1)
if (i + step <= n && s[i + step][0] <= t) {
t -= s[i += step][0];
sum += s[i][1];
}
return sum;
}
int main() {
scanf("%d%d%d", &n, &w, &K);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
sa[i] = sa[i - 1] + a[i];
}
for (int i = 1; i <= n; ++i) {
scanf("%d", &t[i]);
first[i] = first[i - 1] + t[i];
b[i] = pair<int, int>(t[i] >> 1, i);
}
sort(b + 1, b + n + 1);
reverse(b + 1, b + n + 1);
for (int i = 1; i <= n; ++i) loc[b[i].second] = i;
int ans = 0;
for (int r = 1, i = 1; i <= n; ++i) {
while (first[r - 1] - first[i - 1] - count() <= K) {
ans = max(ans, sa[r - 1] - sa[i - 1]);
if (r > n) break;
update(loc[r], 1, t[r] >> 1);
++r;
}
update(loc[i], -1, -(t[i] >> 1));
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
pair<int, int> a[200005];
int acc[200005];
int main() {
int n, w, k;
cin >> n >> w >> k;
for (int i = 0; i < n; i++)
cin >> a[i].first, acc[i] = acc[i - 1] + a[i].first;
for (int i = 0; i < n; i++) cin >> a[i].second;
int ans = 0;
int lo = 0, hi = 0;
multiset<int> St, St2;
int tmp = 0;
while (hi <= n) {
if (lo > hi) {
hi++;
continue;
}
if (tmp > k) {
if (St.find(a[lo].second) != St.end()) {
tmp -= (a[lo].second / 2 + a[lo].second % 2);
St.erase(St.find(a[lo].second));
if (St2.size()) {
int y = (*St2.rbegin());
St2.erase(St2.find(y));
tmp -= y;
tmp += (y / 2 + y % 2);
St.insert(y);
}
} else {
tmp -= a[lo].second;
St2.erase(St2.find(a[lo].second));
}
lo++;
} else {
if (hi == n) break;
if (St.size() < w) {
tmp += a[hi].second / 2 + a[hi].second % 2;
St.insert(a[hi].second);
} else {
if (a[hi].second > (*St.begin())) {
int x = (*St.begin());
tmp -= (x / 2 + x % 2);
tmp += x;
tmp += a[hi].second / 2 + a[hi].second % 2;
St.erase(St.find(x));
St.insert(a[hi].second);
St2.insert(x);
} else {
tmp += a[hi].second;
St2.insert(a[hi].second);
}
}
hi++;
}
if (tmp <= k) ans = max(ans, acc[hi - 1] - acc[lo - 1]);
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Node {
int a, t, no;
} song[200005], temp1, temp2;
struct cmp1 {
bool operator()(Node x1, Node x2) { return x1.t < x2.t; }
};
struct cmp2 {
bool operator()(Node x1, Node x2) { return x1.t > x2.t; }
};
priority_queue<Node, vector<Node>, cmp2> q1;
priority_queue<Node, vector<Node>, cmp1> q2;
int life[200005];
int main() {
int ans = 0, now = 0;
int n, w, k, nums = 0;
int l = 0, r = 0;
cin >> n >> w >> k;
for (int i = 1; i <= n; i++) scanf("%d", &(song[i].a));
for (int i = 1; i <= n; i++) scanf("%d", &(song[i].t));
for (int i = 1; i <= n; i++) song[i].no = i;
while (r + 1 <= n) {
if (life[l]) {
if (life[l] == 1) {
w++;
k += (song[l].t + 1) / 2;
if (nums) {
while (temp2 = q2.top(), life[temp2.no] == 0) {
q2.pop();
}
q2.pop();
q1.push(temp2);
life[temp2.no] = 1;
k += temp2.t / 2;
w--;
nums--;
}
}
if (life[l] == 2) {
k += song[l].t;
nums--;
}
now -= song[l].a;
life[l] = 0;
}
l++;
while (r + 1 <= n) {
if (w) {
if ((song[r + 1].t + 1) / 2 <= k) {
r++;
k -= (song[r].t + 1) / 2;
w--;
now += song[r].a;
q1.push(song[r]);
life[r] = 1;
} else
break;
} else {
while (temp1 = q1.top(), life[temp1.no] == 0) {
q1.pop();
}
if (song[r + 1].t > temp1.t) {
if ((song[r + 1].t + 1) / 2 + temp1.t - (temp1.t + 1) / 2 <= k) {
r++;
now += song[r].a;
k -= (song[r].t + 1) / 2 + temp1.t - (temp1.t + 1) / 2;
nums++;
q2.push(temp1);
q1.pop();
life[temp1.no] = 2;
life[r] = 1;
q1.push(song[r]);
} else
break;
} else {
if (song[r + 1].t <= k) {
r++;
k -= song[r].t;
now += song[r].a;
life[r] = 2;
nums++;
q2.push(song[r]);
} else
break;
}
}
}
ans = max(ans, now);
r = max(r, l);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
set<pair<int, int> > stw, st;
int n, m, k;
int A[200003], T[200003];
int main() {
scanf("%d %d %d", &n, &m, &k);
for (int i = 1; i <= n; i++) scanf("%d", &A[i]);
for (int i = 1; i <= n; i++) scanf("%d", &T[i]);
int res = 0, sum = 0;
int tuse = 0;
int kir = 1;
for (int i = 1; i <= n; i++) {
if (stw.size() < m) {
stw.insert({T[i], i});
tuse += (T[i] + 1) / 2;
sum += A[i];
} else {
st.insert({T[i], i});
tuse += T[i];
sum += A[i];
auto it = st.end();
--it;
auto jt = stw.begin();
if (*it > *jt) {
tuse = tuse - (*it).first + ((*it).first + 1) / 2;
tuse = tuse - ((*jt).first + 1) / 2 + (*jt).first;
pair<int, int> temp1 = *it, temp2 = *jt;
st.erase(temp1);
stw.erase(temp2);
stw.insert(temp1);
st.insert(temp2);
}
}
while (tuse > k) {
sum -= A[kir];
if (st.find({T[kir], kir}) != st.end()) {
tuse -= T[kir];
st.erase({T[kir], kir});
} else {
tuse -= (T[kir] + 1) / 2;
stw.erase({T[kir], kir});
if (st.size()) {
auto it = st.end();
it--;
tuse = tuse - (*it).first + ((*it).first + 1) / 2;
pair<int, int> temp = *it;
st.erase(temp);
stw.insert(temp);
}
}
kir++;
}
res = max(sum, res);
}
printf("%d\n", res);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200005;
int N, W, K;
int A[MAXN];
int T[MAXN];
set<pair<int, int> > half;
set<pair<int, int> > st;
int main() {
ios::sync_with_stdio(0);
cin >> N >> W >> K;
for (int i = 1; i <= N; i++) cin >> A[i];
for (int i = 1; i <= N; i++) cin >> T[i];
int best = 0, cur = 0, hap = 0;
for (int i = N, j = N; i >= 1; i--) {
if (half.size() < W) {
cur += (T[i] + 1) / 2;
half.insert(make_pair(T[i], i));
} else if (half.begin()->first < T[i]) {
cur -= (half.begin()->first + 1) / 2;
cur += half.begin()->first;
st.insert(*half.begin());
half.erase(half.begin());
cur += (T[i] + 1) / 2;
half.insert(make_pair(T[i], i));
} else {
cur += T[i];
st.insert(make_pair(T[i], i));
}
hap += A[i];
while (j >= i && cur > K) {
if (half.find(make_pair(T[j], j)) != half.end()) {
cur -= (T[j] + 1) / 2;
hap -= A[j];
half.erase(make_pair(T[j], j));
if (!st.empty()) {
pair<int, int> x = *(--st.end());
cur -= x.first;
cur += (x.first + 1) / 2;
st.erase(x);
half.insert(x);
}
} else if (st.find(make_pair(T[j], j)) != st.end()) {
cur -= T[j];
hap -= A[j];
st.erase(make_pair(T[j], j));
}
j--;
}
best = max(best, hap);
}
cout << best << "\n";
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
const int N = 200100;
int a[N], t[N];
multiset<int> st1, st2;
multiset<int>::iterator it;
int sum = 0, nowt = 0, res = 0;
int n, m, k;
void ins(int x) {
sum += a[x];
if (st1.size() < m) {
st1.insert(t[x]);
nowt += (t[x] + 1) / 2;
} else {
it = st1.begin();
if ((*it) < t[x]) {
nowt += (t[x] + 1) / 2;
nowt -= ((*it) + 1) / 2;
nowt += (*it);
st1.insert(t[x]);
st2.insert((*it));
st1.erase(it);
} else {
nowt += t[x];
st2.insert(t[x]);
}
}
}
void del(int x) {
sum -= a[x];
if (st2.size() && st2.find(t[x]) != st2.end()) {
nowt -= t[x];
st2.erase(st2.find(t[x]));
} else {
nowt -= (t[x] + 1) / 2;
assert(st1.find(t[x]) != st1.end());
st1.erase(st1.find(t[x]));
if (st2.size()) {
it = st2.end();
it--;
nowt -= (*it);
nowt += ((*it) + 1) / 2;
st1.insert((*it));
st2.erase(it);
}
}
}
int main() {
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (int i = 1; i <= n; i++) {
scanf("%d", &t[i]);
}
for (int i = 1, j = 1; i <= n; i++) {
while (j <= n) {
ins(j);
if (nowt > k) {
del(j);
break;
}
j++;
}
if (nowt <= k) res = max(res, sum);
if (i != j)
del(i);
else
j++;
}
cout << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5;
const long long M = 1e3;
const long long mod = 998244353;
const long long inf = 1e9;
long long read() {
long long s = 0;
register bool neg = 0;
register char c = getchar();
for (; c < '0' || c > '9'; c = getchar()) neg |= (c == '-');
for (; c >= '0' && c <= '9'; s = s * 10 + (c ^ 48), c = getchar())
;
s = (neg ? -s : s);
return s;
}
long long a, b, c, v[N + 5], t[N + 5], p1, p2, res, ans;
multiset<long long> s1, s2;
multiset<long long>::iterator it;
void ins(long long val) {
if (!val) return;
if (!((long long)((s2).size())) || val >= *s2.begin()) {
s2.insert(val);
p2 += (val + 1) / 2;
if (((long long)((s2).size())) > b) {
val = *s2.begin();
p2 -= (val + 1) / 2;
p1 += val;
s1.insert(val);
s2.erase(s2.find(val));
}
} else {
p1 += val;
s1.insert(val);
}
}
void del(long long val) {
if (!val) return;
if (val >= *s2.begin()) {
s2.erase(s2.find(val));
p2 -= (val + 1) / 2;
if (((long long)((s1).size()))) {
it = s1.end();
--it;
val = *it;
p1 -= val;
p2 += (val + 1) / 2;
s2.insert(val);
s1.erase(s1.find(val));
}
} else {
p1 -= val;
s1.erase(s1.find(val));
}
}
signed main() {
a = read();
b = read();
c = read();
for (long long i = (1); i <= (a); ++i) v[i] = read();
for (long long i = (1); i <= (a); ++i) t[i] = read();
for (long long l = 1, r = 0; l <= a; ++l) {
while (p1 + p2 <= c && r <= a) {
ins(t[++r]);
res += v[r];
}
res -= v[r];
del(t[r--]);
ans = max(ans, res);
res -= v[l];
if (l <= r) del(t[l]);
}
printf("%lld", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200010;
int n, w, k;
int a[N];
int b[N];
set<pair<int, int> > q1, q2;
int sa[N], sb[N];
int total = 0;
void insertTime(int u, int i) {
q1.insert(make_pair(u, i));
total += u / 2;
if ((int)(q1).size() > w) {
__typeof(q1.begin()) it = q1.begin();
q2.insert(make_pair(it->first, it->second));
total -= it->first / 2;
q1.erase(it);
}
}
void removeTime(int u, int i) {
__typeof(q1.begin()) it1 = q1.find(make_pair(u, i));
__typeof(q2.begin()) it2 = q2.find(make_pair(u, i));
if (it1 != q1.end()) {
total -= it1->first / 2;
q1.erase(it1);
if (!q2.empty()) {
__typeof(q2.rbegin()) it2 = q2.rbegin();
q1.insert(make_pair(it2->first, it2->second));
total += it2->first / 2;
q2.erase(--q2.end());
}
}
if (it2 != q2.end()) {
q2.erase(it2);
}
}
int main() {
scanf("%d %d %d", &n, &w, &k);
for (int i = 1; i <= n; ++i) {
scanf("%d", a + i);
sa[i] = sa[i - 1] + a[i];
}
for (int i = 1; i <= n; ++i) {
scanf("%d", b + i);
sb[i] = sb[i - 1] + b[i];
}
int ans = 0;
int tim = 0, pos = 1;
for (int i = 1; i <= n; ++i) {
insertTime(b[i], i);
while (pos <= i && sb[i] - sb[pos - 1] - total > k) {
removeTime(b[pos], pos);
pos++;
}
if (pos <= i && sb[i] - sb[pos - 1] - total <= k) {
ans = max(ans, sa[i] - sa[pos - 1]);
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct edge {
long long a, b;
bool operator<(const edge &P) const {
if (b == P.b) return a < P.a;
return b < P.b;
}
};
int a[200002], b[200002];
set<edge> hal, ful;
set<edge>::iterator it;
edge gr;
int main() {
int i, j, k, l, m, n, w, tot;
scanf("%d%d%d", &n, &w, &tot);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
for (i = 1; i <= n; i++) scanf("%d", &b[i]);
j = 1;
long long ans = 0, cal = 0, time = 0;
for (int i = 1; i <= n; i++) {
gr.a = i;
gr.b = b[i];
hal.insert(gr);
cal += a[i];
time += (b[i] + 1) / 2;
if (hal.size() > w) {
it = hal.begin();
hal.erase(*it);
ful.insert(*it);
time += b[(it)->a];
time -= (b[(it)->a] + 1) / 2;
}
while (time > tot && j <= i) {
gr.a = j;
gr.b = b[j];
if (hal.find(gr) != hal.end()) {
hal.erase(gr);
time -= (b[j] + 1) / 2;
cal -= a[j];
if (ful.size()) {
it = ful.end();
it--;
ful.erase(*it);
time -= b[it->a];
time += (b[it->a] + 1) / 2;
hal.insert(*it);
}
} else if (ful.find(gr) != ful.end()) {
ful.erase(gr);
time -= gr.b;
cal -= a[gr.a];
}
j++;
}
ans = max(ans, cal);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long size = 400011;
const long long mod = 1000000007;
void PLL(initializer_list<long long> li) {
for (auto beg = li.begin(); beg != li.end(); beg++) {
if (beg != li.begin()) cout << ' ';
cout << *beg;
}
cout << endl;
}
const long long Inf = ~0ull >> 2;
long long sum[size * 4], cnt[size * 4], hsum[size];
void add(int p, int l, int r, int id, int x, int d) {
cnt[p] += d;
sum[p] += d * x;
hsum[p] += (x + 1) / 2 * d;
if (l == r) {
return;
}
if (((l + r) / 2) >= id)
add(p * 2, l, ((l + r) / 2), id, x, d);
else
add(p * 2 + 1, ((l + r) / 2) + 1, r, id, x, d);
}
long long get(int p, int l, int r, int x) {
if (x >= cnt[p]) return hsum[p];
if (x == 0) return sum[p];
if (l == r) {
return (l + 1) / 2 * x + (cnt[p] - x) * l;
}
return get(p * 2 + 1, ((l + r) / 2) + 1, r, x) +
get(p * 2, l, ((l + r) / 2), max(0ll, x - cnt[p * 2 + 1]));
}
long long a[size];
long long t[size];
int n, w, k;
int main() {
cin >> n >> w >> k;
for (int i = 1; i <= n; i++) {
cin >> t[i];
t[i + n] = t[i];
}
for (int i = 1; i <= n; i++) {
cin >> a[i];
a[n + i] = a[i];
}
for (int i = 1; i <= n * 2; i++) t[i] += t[i - 1];
long long ans = 0, r = 0;
for (long long l = 1; l <= n; l++) {
r = max(r, l - 1);
while (r <= n && get(1, 1, 2e4, w) <= k) {
r++;
add(1, 1, 2e4, a[r], a[r], 1);
}
add(1, 1, 2e4, a[r], a[r], -1);
r--;
ans = max(ans, t[r] - t[l - 1]);
if (l != r - 1) add(1, 1, 2e4, a[l], a[l], -1);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
struct st {
int t;
int ind;
};
struct se {
int t;
int ind;
};
priority_queue<st> s;
priority_queue<se> u;
bool koristi[262144];
bool prosao[262144];
int a[262144];
int t[262144];
long long int n, k;
int r = 0;
long long int d = 0;
int p, q;
long long int w = 0;
int v = 0;
bool operator>(st x, st y) { return x.t > y.t; }
bool operator<(st x, st y) { return x.t < y.t; }
bool operator<(se x, se y) { return x.t > y.t; }
bool operator>(se x, se y) { return x.t < y.t; }
int main() {
cin >> n >> w >> k;
for (int i = 0; i < 262144; i++) {
a[i] = 0;
koristi[i] = false;
prosao[i] = false;
}
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < n; i++) scanf("%d", &t[i]);
st pom;
se qom;
p = 0;
int ut, st;
int u1 = 0, s1 = 0;
q = -1;
int maxr = 0;
while (p < n && q < n) {
if (q + 1 < n) {
if (d <= k) {
q++;
d += t[q];
pom.t = t[q];
pom.ind = q;
s.push(pom);
s1++;
r += a[q];
}
while (v < w && s1 > 0) {
pom = s.top();
if (!prosao[pom.ind]) {
qom.ind = pom.ind;
qom.t = pom.t;
koristi[pom.ind] = true;
d -= pom.t / 2;
u.push(qom);
u1++;
v++;
}
s.pop();
s1--;
}
while (s.size() > 0) {
pom = s.top();
if (!prosao[pom.ind]) {
break;
}
s.pop();
s1--;
}
if (u1 > 0) ut = (u.top().t) / 2;
if (s1 > 0) st = (s.top().t) / 2;
while (u1 > 0 && s1 > 0 && ut < st) {
d += ut;
d -= st;
koristi[u.top().ind] = false;
koristi[s.top().ind] = true;
qom = u.top();
pom.ind = qom.ind;
pom.t = qom.t;
s.push(pom);
u.pop();
pom = s.top();
s.pop();
qom.ind = pom.ind;
qom.t = pom.t;
u.push(qom);
while (s.size() > 0) {
pom = s.top();
if (!prosao[pom.ind]) {
break;
}
s.pop();
s1--;
}
while (u.size() > 0) {
qom = u.top();
if (koristi[qom.ind]) {
break;
}
u.pop();
u1--;
}
if (u1 > 0) ut = (u.top().t) / 2;
if (s1 > 0) st = (s.top().t) / 2;
}
if (d > k) {
r -= a[p];
d -= t[p];
prosao[p] = true;
if (koristi[p]) {
d = d + t[p] / 2;
koristi[p] = false;
v--;
}
p++;
}
if (r > maxr && d <= k) maxr = r;
while (s.size() > 0) {
pom = s.top();
if (!prosao[pom.ind]) {
break;
}
s.pop();
s1--;
}
while (u.size() > 0) {
qom = u.top();
if (koristi[qom.ind]) {
break;
}
u.pop();
u1--;
}
} else
q++;
}
printf("%d", maxr);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, w, k, l, r, Time, Happiness, ans, a[200005], t[200005];
multiset<int> Set1, Set2;
int main() {
scanf("%d%d%d", &n, &w, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) scanf("%d", &t[i]);
for (l = 0, r = 1; r <= n; r++) {
Set1.insert(t[r]);
Time += (t[r] + 1) >> 1, Happiness += a[r];
if (Set1.size() > w) {
Time += *Set1.begin() >> 1;
Set2.insert(*Set1.begin());
Set1.erase(Set1.begin());
}
while (Time > k) {
Time -= t[++l], Happiness -= a[l];
if (t[l] >= *Set1.begin()) {
Time += t[l] >> 1;
Set1.erase(Set1.find(t[l]));
if (!Set2.empty()) {
Time -= *Set2.rbegin() >> 1;
Set1.insert(*Set2.rbegin());
Set2.erase(Set2.find(*Set2.rbegin()));
}
} else
Set2.erase(Set2.find(t[l]));
}
ans = max(ans, Happiness);
}
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
int n, k, w;
int a[maxn], t[maxn];
struct SegmentTree {
struct Node {
int timer, val;
Node() {}
Node(int timer, int val) : timer(timer), val(val) {}
} st[6 * maxn];
int L[6 * maxn], R[6 * maxn];
void Build(int k, int x, int y) {
L[k] = x;
R[k] = y;
if (L[k] == R[k]) return;
Build(k << 1, L[k], ((L[k] + R[k]) >> 1));
Build(k << 1 | 1, ((L[k] + R[k]) >> 1) + 1, R[k]);
}
void Update(int k, int i, int val) {
if (L[k] == R[k]) {
st[k].timer += val;
st[k].val = st[k].timer * i;
return;
}
if (i <= ((L[k] + R[k]) >> 1))
Update(k << 1, i, val);
else
Update(k << 1 | 1, i, val);
st[k].timer = st[k << 1].timer + st[k << 1 | 1].timer;
st[k].val = st[k << 1].val + st[k << 1 | 1].val;
}
int Query(int k, int &val) {
if (val == 0) return 0;
if (st[k].timer <= val) {
val -= st[k].timer;
return st[k].val;
}
if (L[k] == R[k]) {
int M = min(st[k].timer, val);
val -= M;
return L[k] * M;
}
int ans = Query(k << 1 | 1, val);
ans += Query(k << 1, val);
return ans;
}
int Get(int w) { return Query(1, w); }
} Tree;
int main() {
scanf("%d%d%d", &n, &w, &k);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (int i = 1; i <= n; ++i) scanf("%d", &t[i]);
int l = 1;
int S = 0, time = 0, ans = 0;
Tree.Build(1, 0, 6000);
for (int i = 1; i <= n; ++i) {
S += a[i];
time += t[i];
Tree.Update(1, t[i] / 2, 1);
while (l <= i && time - Tree.Get(w) > k) {
Tree.Update(1, t[l] / 2, -1);
S -= a[l];
time -= t[l];
++l;
}
ans = max(ans, S);
}
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long max(long a, long b) { return a > b ? a : b; }
multiset<int> wa;
multiset<int> tle;
multiset<int>::iterator it;
int main() {
int t[200005], p[200005];
int i, k, n, w;
scanf("%d %d %d", &n, &w, &k);
for (i = 0; i < n; i++) scanf("%d", &p[i]);
for (i = 0; i < n; i++) scanf("%d", &t[i]);
int ctime = 0, cnum = 0, l = 0, r = 0, csum = 0, ans = 0;
while (r < n) {
wa.insert(t[r]);
ctime += (t[r] + 1) / 2;
if (wa.size() > w) {
tle.insert(*(wa.begin()));
ctime += *(wa.begin()) / 2;
wa.erase(wa.begin());
}
csum += p[r++];
while (l <= r && ctime > k) {
if (t[l] >= *(wa.begin())) {
wa.erase(wa.find(t[l]));
ctime -= (t[l] + 1) / 2;
if (tle.size()) {
it = tle.end();
it--;
wa.insert(*it);
ctime -= *it / 2;
tle.erase(it);
}
} else {
tle.erase(tle.find(t[l]));
ctime -= t[l];
}
csum -= p[l++];
}
ans = max(ans, csum);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXSIZE = 30000020;
int bufpos;
char buf[MAXSIZE];
void init() {
buf[fread(buf, 1, MAXSIZE, stdin)] = '\0';
bufpos = 0;
}
int readint() {
int val = 0;
for (; !isdigit(buf[bufpos]); bufpos++)
;
for (; isdigit(buf[bufpos]); bufpos++) val = val * 10 + buf[bufpos] - '0';
return val;
}
char readchar() {
for (; isspace(buf[bufpos]); bufpos++)
;
return buf[bufpos++];
}
int readstr(char* s) {
int cur = 0;
for (; isspace(buf[bufpos]); bufpos++)
;
for (; !isspace(buf[bufpos]); bufpos++) s[cur++] = buf[bufpos];
s[cur] = '\0';
return cur;
}
const int maxn = 200002;
struct segtree {
int n;
int cnt[40002], sum[40001];
int p, v0, v1;
int qwq;
void update(int o, int l, int r) {
if (l == r) {
cnt[o] += v0;
sum[o] += v1;
return;
}
int mid = (l + r) / 2;
if (p <= mid)
update(o * 2, l, mid);
else
update(o * 2 + 1, mid + 1, r);
cnt[o] = cnt[o * 2] + cnt[o * 2 + 1];
sum[o] = sum[o * 2] + sum[o * 2 + 1];
}
void add(int x) {
qwq += x;
p = x, v0 = 1, v1 = x / 2;
update(1, 1, n);
}
void del(int x) {
qwq -= x;
p = x, v0 = -1, v1 = -(x / 2);
update(1, 1, n);
}
int query(int k) {
int o = 1, l = 1, r = n, res = 0;
while (l < r) {
int mid = (l + r) / 2;
if (k > cnt[o * 2 + 1])
k -= cnt[o * 2 + 1], res += sum[o * 2 + 1], o = o * 2, r = mid;
else
o = o * 2 + 1, l = mid + 1;
}
if (k > cnt[o])
return qwq - res - sum[o];
else
return qwq - res - sum[o] / cnt[o] * k;
}
} t;
int a[maxn], qwq[maxn], sum[maxn];
int main() {
init();
int n = readint(), w = readint(), k = readint();
for (int i = 1; i <= n; i++) a[i] = readint();
for (int i = 1; i <= n; i++) qwq[i] = readint();
for (int i = n; i; i--) sum[i] = sum[i + 1] + a[i];
t.n = 10000;
int j = 0, ans = 0;
for (int i = 1; i <= n; i++) {
while (t.query(w) <= k) {
j++;
if (j > n) break;
t.add(qwq[j]);
}
ans = max(ans, sum[i] - sum[j]);
t.del(qwq[i]);
}
printf("%d", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
struct str1 {
int x, y;
inline bool operator<(const str1 t) const {
if (x != t.x)
return x < t.x;
else
return y < t.y;
}
};
set<str1> S1;
struct str2 {
int x, y;
inline bool operator<(const str2 t) const {
if (x != t.x)
return x > t.x;
else
return y > t.y;
}
};
set<str2> S2;
inline int fastscanf() {
int t = 0;
char c = getchar();
while (!((c > 47) && (c < 58))) c = getchar();
while ((c > 47) && (c < 58)) t = t * 10 + c - 48, c = getchar();
return t;
}
int u[300000], v[300000];
int i, k, l, m, n, r, s, t;
str1 tmp_;
str2 tmp;
inline void del(int i) {
if ((*S1.find((str1){u[i], i})).y) {
r = r - (u[i] + 1) / 2;
S1.erase((str1){u[i], i});
if (!S2.empty()) {
tmp = *S2.begin();
r = r - tmp.x + (tmp.x + 1) / 2;
S1.insert((str1){tmp.x, tmp.y});
S2.erase(tmp);
}
t = t - v[i];
} else if ((*S2.find((str2){u[i], i})).y) {
r = r - u[i];
S2.erase((str2){u[i], i});
t = t - v[i];
}
return;
}
int main() {
n = fastscanf(), k = fastscanf(), m = fastscanf();
for (i = 1; i <= n; i++) v[i] = fastscanf();
for (i = 1; i <= n; i++) u[i] = fastscanf();
for (i = 1, l = 0; i <= n; i++) {
for (; l <= n;) {
if (r + (u[l] + 1) / 2 > m) break;
if (S1.size() < k) {
r = r + (u[l] + 1) / 2;
S1.insert((str1){u[l], l});
t = t + v[l];
l++;
} else {
r = r + u[l];
S2.insert((str2){u[l], l});
tmp_ = *S1.begin(), tmp = *S2.begin();
if (tmp.x > tmp_.x) {
S1.erase(tmp_), S2.erase(tmp);
swap(tmp_.x, tmp.x), swap(tmp_.y, tmp.y);
S1.insert(tmp_), S2.insert(tmp);
r = r - tmp_.x + (tmp_.x + 1) / 2;
r = r + tmp.x - (tmp.x + 1) / 2;
}
t = t + v[l];
if (r > m) {
del(l);
break;
}
l++;
}
}
s = max(s, t);
del(i);
}
printf("%d", s);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
multiset<int> half, full;
int a[200010], t[200010], n, w, k, ti, cur_sat, res;
int main() {
scanf("%d%d%d", &n, &w, &k);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (int i = 1; i <= n; ++i) scanf("%d", &t[i]);
int l = 1, r = 1;
while (r <= n) {
half.insert(t[r]);
ti += (t[r] + 1) / 2;
if (half.size() > w) {
full.insert(*(half.begin()));
ti += *(half.begin()) / 2;
half.erase(half.begin());
}
cur_sat += a[r];
++r;
while (l <= r && ti > k) {
if (t[l] >= *(half.begin())) {
half.erase(half.find(t[l]));
ti -= (t[l] + 1) / 2;
if (full.size()) {
multiset<int>::iterator pos;
pos = full.end();
--pos;
half.insert(*pos);
ti -= *pos / 2;
full.erase(pos);
}
} else {
full.erase(full.find(t[l]));
ti -= t[l];
}
cur_sat -= a[l];
++l;
}
res = max(res, cur_sat);
}
printf("%d\n", res);
}
|
#include <bits/stdc++.h>
using namespace std;
vector<string> split(const string& s, char c) {
vector<string> v;
stringstream ss(s);
string x;
while (getline(ss, x, c)) v.emplace_back(x);
return move(v);
}
void err(vector<string>::iterator it) {}
template <typename T, typename... Args>
void err(vector<string>::iterator it, T a, Args... args) {
cerr << it->substr((*it)[0] == ' ', it->length()) << " = " << a << '\n';
err(++it, args...);
}
const int NMAX = 200005;
const int XMAX = 10005;
int n, w, k, a[NMAX], t[NMAX], s[NMAX];
int nr[4 * XMAX], sum[4 * XMAX];
int sol;
void Update(int nod, int st, int dr, int poz, int val) {
if (st == dr) {
nr[nod] += val;
sum[nod] += st * val;
} else {
int mij = (st + dr) / 2;
if (poz <= mij) Update(2 * nod, st, mij, poz, val);
if (poz > mij) Update(2 * nod + 1, mij + 1, dr, poz, val);
nr[nod] = nr[2 * nod] + nr[2 * nod + 1];
sum[nod] = sum[2 * nod] + sum[2 * nod + 1];
}
}
int Query(int nod, int st, int dr, int val) {
if (st == dr)
return min(nr[nod], val) * st;
else {
int mij = (st + dr) / 2;
if (nr[2 * nod + 1] >= val)
return Query(2 * nod + 1, mij + 1, dr, val);
else
return sum[2 * nod + 1] + Query(2 * nod, st, mij, val - nr[2 * nod + 1]);
}
}
int main() {
int i;
cin.sync_with_stdio(false);
cin >> n >> w >> k;
for (i = 1; i <= n; i++) cin >> a[i];
for (i = 1; i <= n; i++) {
cin >> t[i];
s[i] = s[i - 1] + t[i];
}
int st = 1, pleasure = 0;
for (i = 1; i <= n; i++) {
int aux = t[i] / 2;
if (t[i] & 1) aux++;
pleasure += a[i];
Update(1, 1, XMAX - 1, t[i] - aux, 1);
while (s[i] - s[st - 1] - Query(1, 1, XMAX - 1, w) > k) {
int aux = t[st] / 2;
if (t[i] & 1) aux++;
Update(1, 1, XMAX - 1, t[st] - aux, -1);
pleasure -= a[st];
st++;
}
sol = max(sol, pleasure);
}
cout << sol << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[200000] = {0};
int t[200000] = {0};
set<pair<int, int> > half, full;
int main() {
int l = 0, r = 0;
int n, w, k, time = 0, res = 0, now = 0;
scanf("%d%d%d", &n, &w, &k);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
for (int i = 0; i < n; i++) {
scanf("%d", &t[i]);
}
while (r < n) {
while (time < k && r < n) {
if (half.size() < w) {
half.insert(make_pair(t[r], r));
time += (t[r] + 1) / 2;
} else if (half.begin()->first < t[r]) {
time -= (half.begin()->first + 1) / 2;
time += half.begin()->first;
time += (t[r] + 1) / 2;
full.insert(*half.begin());
half.erase(*half.begin());
half.insert(make_pair(t[r], r));
} else {
full.insert(make_pair(t[r], r));
time += t[r];
}
now += a[r];
r++;
if (time <= k) {
res = res > now ? res : now;
}
}
while (time >= k) {
if (half.count(make_pair(t[l], l))) {
half.erase(make_pair(t[l], l));
time -= (t[l] + 1) / 2;
if (!full.empty()) {
time -= full.rbegin()->first;
time += (full.rbegin()->first + 1) / 2;
half.insert(*full.rbegin());
full.erase(*full.rbegin());
}
} else {
full.erase(make_pair(t[l], l));
time -= t[l];
}
now -= a[l];
l++;
if (time <= k) {
res = res > now ? res : now;
}
}
}
printf("%d\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char c = getchar();
while (c > 57 || c < 48) {
if (c == '-') f = -1;
c = getchar();
}
while (c > 47 && c < 58) x = x * 10 + c - 48, c = getchar();
return x * f;
}
int sum[20010], siz[20010];
void update(int x) {
sum[x] = sum[x << 1] + sum[x << 1 | 1];
siz[x] = siz[x << 1] + siz[x << 1 | 1];
}
int qry(int x, int l, int r, const int& w) {
if (l == r) return w * l;
int mid = l + r >> 1;
if (siz[x << 1] >= w)
return qry(x << 1, l, mid, w);
else
return sum[x << 1] + qry(x << 1 | 1, mid + 1, r, w - siz[x << 1]);
}
void ins(int x, int l, int r, const int& w, const int& op) {
if (l == r) {
sum[x] += w * op, siz[x] += op;
return;
}
int mid = l + r >> 1;
if (w <= mid)
ins(x << 1, l, mid, w, op);
else
ins(x << 1 | 1, mid + 1, r, w, op);
update(x);
}
int a[200010], t[200010], n, w, k, sa, st, ans;
void ins(int x, int op) {
sa += a[x] * op;
st += t[x] * op;
ins(1, 1, 5000, t[x] >> 1, op);
}
int count(int L, int R) {
int W = sum[1] - qry(1, 1, 5000, max(R - L - w, 0));
return st - W;
}
int main() {
n = read(), w = read(), k = read();
for (int i = 1; i <= n; i++) a[i] = read();
for (int i = 1; i <= n; i++) t[i] = read();
for (int L = 0, R = 0; R <= n; L++, ins(L, -1))
for (; count(L, R) <= k && R <= n; R++, ins(R, 1)) ans = max(sa, ans);
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct maxsum {
int k;
multiset<int> big;
multiset<int, greater<int>> small;
int sum = 0;
maxsum(int k) : k(k) {}
void add(int x) {
big.insert(x);
sum += x;
if (big.size() > k) {
x = *big.begin();
big.erase(big.begin());
sum -= x;
small.insert(x);
}
}
void del(int x) {
auto it = big.find(x);
if (it != big.end()) {
big.erase(it);
sum -= x;
if (!small.empty()) {
x = *small.begin();
small.erase(small.begin());
big.insert(x);
sum += x;
}
} else {
it = small.find(x);
if (it != small.end()) {
small.erase(it);
}
}
}
};
int main() {
ios::sync_with_stdio(false);
int n, w, k;
scanf("%d%d%d", &n, &w, &k);
vector<int> a(n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
vector<int> t(n);
for (int i = 0; i < n; i++) {
scanf("%d", &t[i]);
}
int ans = 0;
int x = 0;
int asum = 0;
int tsum = 0;
maxsum tt(w);
for (int i = 0; i < n; i++) {
asum += a[i];
tsum += t[i];
tt.add(t[i] / 2);
while (tsum - tt.sum > k) {
asum -= a[x];
tsum -= t[x];
tt.del(t[x] / 2);
x++;
}
ans = max(ans, asum);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = int(1e9);
int n, w, k;
int a[200005];
int t[200005];
struct Cmp {
inline bool operator()(const int &lhs, const int &rhs) const {
if (t[lhs] != t[rhs]) return t[lhs] > t[rhs];
return lhs < rhs;
}
};
struct Cmp2 {
inline bool operator()(const int &lhs, const int &rhs) const {
if (t[lhs] != t[rhs]) return t[lhs] < t[rhs];
return lhs < rhs;
}
};
set<int, Cmp> lo;
set<int, Cmp2> hi;
int main() {
scanf("%d%d%d", &n, &w, &k);
for (int i = 0; i < (int)(n); ++i) {
scanf("%d", a + i);
}
for (int i = 0; i < (int)(n); ++i) {
scanf("%d", t + i);
}
int cur = 0;
int sumT = 0;
int ans = 0;
int j = n - 1;
for (int i = n - 1; i >= 0; --i) {
int mx = (lo.empty() ? -INF : t[*lo.begin()]);
int mn = (hi.empty() ? INF : t[*hi.begin()]);
if (t[i] >= mx && t[i] <= mn) {
if (int(hi.size()) < w) {
hi.insert(i);
sumT += (t[i] + 1) / 2;
} else {
lo.insert(i);
sumT += t[i];
}
} else if (t[i] < mx) {
lo.insert(i);
sumT += t[i];
} else {
hi.insert(i);
sumT += (t[i] + 1) / 2;
}
if (int(hi.size()) > w) {
int val = *hi.begin();
hi.erase(hi.begin());
lo.insert(val);
sumT -= (t[val] + 1) / 2;
sumT += t[val];
}
cur += a[i];
while (sumT > k) {
auto it = lo.find(j);
if (it == lo.end()) {
hi.erase(j);
sumT -= (t[j] + 1) / 2;
if (!lo.empty()) {
int val = *lo.begin();
lo.erase(lo.begin());
hi.insert(val);
sumT -= t[val];
sumT += (t[val] + 1) / 2;
}
} else {
lo.erase(it);
sumT -= t[j];
}
cur -= a[j];
--j;
}
ans = max(ans, cur);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long readi() {
long long input = 0;
char c = ' ';
while (c < '-') {
c = getchar();
}
bool negative = false;
if (c == '-') {
negative = true;
c = getchar();
}
while (c >= '0') {
input = 10 * input + (c - '0');
c = getchar();
}
if (negative) {
input = -input;
}
return input;
}
string reads() {
string input = "";
char c = ' ';
while (c <= ' ') {
c = getchar();
}
while (c > ' ') {
input += c;
c = getchar();
}
return input;
}
void printi(long long output) {
if (output == 0) {
putchar('0');
return;
}
if (output < 0) {
putchar('-');
output = -output;
}
vector<char> vout;
while (output) {
vout.push_back((output % 10) + '0');
output /= 10;
}
for (int i = vout.size() - 1; i >= 0; i--) {
putchar(vout[i]);
}
return;
}
void prints(string output) {
for (int i = 0; i < output.length(); i++) {
putchar(output[i]);
}
return;
}
int N, M;
long long T;
long long gain[200010], cost[200010];
long long ans, cur, curt;
multiset<long long> half, full;
int iter;
int32_t main() {
cout << fixed << setprecision(10);
ios_base::sync_with_stdio(false);
if (fopen("cf746f.in", "r")) {
freopen("cf746f.in", "r", stdin);
}
cin >> N >> M >> T;
for (int i = 0; i < N; i++) {
cin >> gain[i];
}
for (int i = 0; i < N; i++) {
cin >> cost[i];
}
for (int i = 0; i < N; i++) {
while (iter < N) {
curt += cost[iter];
cur += gain[iter];
full.insert(cost[iter]);
while (half.size() < M && !full.empty()) {
half.insert(*full.rbegin());
curt -= (*full.rbegin() / 2);
full.erase(full.find(*full.rbegin()));
}
while (!half.empty() && !full.empty() && *half.begin() < *full.rbegin()) {
long long a = *half.begin(), b = *full.rbegin();
half.erase(half.find(a));
full.erase(full.find(b));
full.insert(a);
half.insert(b);
curt += a;
curt -= (a + 1) / 2;
curt -= b;
curt += (b + 1) / 2;
}
if (curt > T) {
cur -= gain[iter];
if (full.find(cost[iter]) != full.end()) {
full.erase(full.find(cost[iter]));
curt -= cost[iter];
} else {
half.erase(half.find(cost[iter]));
curt -= (cost[iter] + 1) / 2;
}
break;
}
iter++;
}
ans = max(ans, cur);
if (full.find(cost[i]) != full.end()) {
full.erase(full.find(cost[i]));
curt -= cost[i];
cur -= gain[i];
} else if (half.find(cost[i]) != half.end()) {
half.erase(half.find(cost[i]));
curt -= (cost[i] + 1) / 2;
cur -= gain[i];
}
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
struct dta {
int val, id;
dta(int _v = 0, int _id = 0) {
val = _v;
id = _id;
}
};
struct c1 {
bool operator()(const dta &x, const dta &y) const {
return (x.val < y.val || (x.val == y.val && x.id < y.id));
}
};
struct c2 {
bool operator()(const dta &x, const dta &y) const {
return (x.val > y.val || (x.val == y.val && x.id < y.id));
}
};
using namespace std;
int n, w, k, A[200001], B[200001], P[200001];
set<dta, c2> Qchua;
set<dta, c1> Qroi;
vector<dta> tam;
int main() {
scanf("%d%d%d", &n, &w, &k);
for (int i = 1; i <= n; i++) scanf("%d", &A[i]);
for (int i = 1; i <= n; i++) scanf("%d", &B[i]);
for (int i = 1; i <= n; i++) P[i] = 0;
int l = n, r = n;
int t = B[n], tval = A[n], cur = 0;
Qchua.insert(dta(B[n], n));
int res = 0;
set<dta>::iterator q;
while (l >= 1) {
if (cur < w) {
for (q = Qchua.begin(); q != Qchua.end(); ++q) {
dta u = *q;
t -= (u.val / 2);
tam.push_back(u);
cur++;
P[u.id] = 1;
if (cur == w) break;
}
while (!tam.empty()) {
dta u = tam.back();
Qroi.insert(u);
Qchua.erase(u);
tam.pop_back();
}
}
if (!P[l]) {
dta u = *(Qroi.begin());
if (u.val < B[l]) {
Qroi.erase(u);
P[l] = 1;
Qchua.insert(u);
Qchua.erase(dta(B[l], l));
Qroi.insert(dta(B[l], l));
t -= (B[l] / 2);
t += (u.val / 2);
P[u.id] = 0;
}
}
if (t <= k) {
res = max(res, tval);
l--;
if (!l) continue;
t += B[l];
tval += A[l];
Qchua.insert(dta(B[l], l));
continue;
}
while (t > k && l <= r) {
if (P[r]) {
t -= (B[r] / 2 + B[r] % 2);
tval -= (A[r]);
cur--;
Qroi.erase(dta(B[r], r));
P[r] = 0;
} else {
t -= B[r];
tval -= (A[r]);
Qchua.erase(dta(B[r], r));
}
r--;
}
res = max(res, tval);
l--;
if (!l) continue;
t += B[l];
tval += A[l];
Qchua.insert(dta(B[l], l));
}
printf("%d", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, w, k, Time, Happiness, ans, a[200005], t[200005];
multiset<int> Set1, Set2;
int main() {
scanf("%d%d%d", &n, &w, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) scanf("%d", &t[i]);
for (int l = 1, r = 1; r <= n; r++) {
Set1.insert(t[r]);
Time += (t[r] + 1) >> 1, Happiness += a[r];
if (Set1.size() > w) {
Set2.insert(*Set1.begin());
Time += *Set1.begin() >> 1;
Set1.erase(Set1.begin());
}
while (Time > k) {
Time -= t[l];
Happiness -= a[l];
if (t[l] >= *Set1.begin()) {
Time += t[l] >> 1;
Set1.erase(Set1.find(t[l]));
if (!Set2.empty()) {
Set1.insert(*Set2.rbegin());
Time -= *Set2.rbegin() >> 1;
Set2.erase(Set2.find(*Set2.rbegin()));
}
} else
Set2.erase(Set2.find(t[l]));
l++;
}
ans = max(ans, Happiness);
}
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(2)
#pragma GCC optimize(3)
using namespace std;
int a[200011], b[200011];
struct song {
int t;
int id;
bool operator<(song other) const {
if (t != other.t) return t < other.t;
return id < other.id;
}
};
struct oriSet {
int tol = 0;
int len = 0;
set<song> s;
bool empty() { return s.empty(); }
int size() { return s.size(); }
void insert(int id) {
s.insert(song{a[id], id});
tol += b[id];
len += a[id];
}
int extractmin() {
if (!s.empty()) {
return s.begin()->id;
}
return -1;
}
int extractmax() {
if (!s.empty()) {
return s.rbegin()->id;
}
return -1;
}
void del(int id) {
if (s.find(song{a[id], id}) != s.end()) {
s.erase(song{a[id], id});
tol -= b[id];
len -= a[id];
}
}
};
struct lessSet {
int tol = 0;
int len = 0;
set<song> s;
bool empty() { return s.empty(); }
int size() { return s.size(); }
void insert(int id) {
int ti = a[id] - a[id] / 2;
s.insert(song{a[id], id});
tol += b[id];
len += ti;
}
int extractmin() {
if (!s.empty()) {
return s.begin()->id;
}
return -1;
}
int extractmax() {
if (!s.empty()) {
return s.rbegin()->id;
}
return -1;
}
void del(int id) {
if (s.find(song{a[id], id}) != s.end()) {
s.erase(song{a[id], id});
tol -= b[id];
len -= a[id] - a[id] / 2;
}
}
};
oriSet s1;
lessSet s2;
int n, w, k;
void make_balance() {
while (s2.size() < w && !s1.empty()) {
int id = s1.extractmax();
s1.del(id);
s2.insert(id);
}
while (!s1.empty() && s2.size() == w) {
int id1 = s1.extractmax(), id2 = s2.extractmin();
if (a[id1] <= a[id2]) break;
if (a[id1] > a[id2]) {
s1.del(id1);
s2.del(id2);
s1.insert(id2);
s2.insert(id1);
}
}
}
int main() {
scanf("%d%d%d", &n, &w, &k);
int i, j, ans = 0;
for (i = 1; i <= n; i++) {
scanf("%d", &b[i]);
}
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (i = 1, j = 1; i <= n; i++) {
s1.insert(i);
make_balance();
while (j <= i && s1.len + s2.len > k) {
s1.del(j);
s2.del(j);
make_balance();
j++;
}
ans = max(ans, s1.tol + s2.tol);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXSIZE = 30000020;
int bufpos;
char buf[MAXSIZE];
void init() {
buf[fread(buf, 1, MAXSIZE, stdin)] = '\0';
bufpos = 0;
}
int readint() {
int val = 0;
for (; !isdigit(buf[bufpos]); bufpos++)
;
for (; isdigit(buf[bufpos]); bufpos++) val = val * 10 + buf[bufpos] - '0';
return val;
}
char readchar() {
for (; isspace(buf[bufpos]); bufpos++)
;
return buf[bufpos++];
}
int readstr(char* s) {
int cur = 0;
for (; isspace(buf[bufpos]); bufpos++)
;
for (; !isspace(buf[bufpos]); bufpos++) s[cur++] = buf[bufpos];
s[cur] = '\0';
return cur;
}
const int maxn = 200002;
struct segtree {
int n;
int cnt[40002], sum[40001];
int p, v0, v1;
int qwq;
void update(int o, int l, int r) {
if (l == r) {
cnt[o] += v0;
sum[o] += v1;
return;
}
int mid = (l + r) / 2;
if (p <= mid)
update(o * 2, l, mid);
else
update(o * 2 + 1, mid + 1, r);
cnt[o] = cnt[o * 2] + cnt[o * 2 + 1];
sum[o] = sum[o * 2] + sum[o * 2 + 1];
}
void add(int x) {
qwq += x;
p = x, v0 = 1, v1 = x / 2;
update(1, 1, n);
}
void del(int x) {
qwq -= x;
p = x, v0 = -1, v1 = -(x / 2);
update(1, 1, n);
}
int query(int k) {
int o = 1, l = 1, r = n, res = 0;
while (l < r) {
int mid = (l + r) / 2;
if (k > cnt[o * 2 + 1])
k -= cnt[o * 2 + 1], res += sum[o * 2 + 1], o = o * 2, r = mid;
else
o = o * 2 + 1, l = mid + 1;
}
if (k > cnt[o])
return qwq - res - sum[o];
else
return qwq - res - sum[o] / cnt[o] * k;
}
} t;
int a[maxn], qwq[maxn], sum[maxn];
int main() {
init();
int n = readint(), w = readint(), k = readint();
for (int i = 1; i <= n; i++) a[i] = readint();
for (int i = 1; i <= n; i++) qwq[i] = readint();
for (int i = n; i; i--) sum[i] = sum[i + 1] + a[i];
t.n = 10000;
int j = 0, ans = 0;
for (int i = 1; i <= n; i++) {
while (t.query(w) <= k) {
j++;
if (j > n) break;
t.add(qwq[j]);
}
ans = max(ans, sum[i] - sum[j]);
t.del(qwq[i]);
}
printf("%d", ans);
}
|
#include <bits/stdc++.h>
int main() {
std::ios::sync_with_stdio(0);
std::cin.tie(0);
int nsong, maxpart, maxtime;
std::cin >> nsong >> maxpart >> maxtime;
std::vector<int> pl(nsong);
for (int& x : pl) std::cin >> x;
std::vector<int> t(nsong);
for (int& x : t) std::cin >> x;
int l = 0, r = 0;
std::multiset<int> partt, fullt;
int64_t sumtime = 0;
auto addpart = [&](int x) {
partt.insert(x);
sumtime += (x + 1) / 2;
};
auto delpart = [&](int x) {
partt.erase(partt.find(x));
sumtime -= (x + 1) / 2;
};
auto addfull = [&](int x) {
fullt.insert(x);
sumtime += x;
};
auto delfull = [&](int x) {
fullt.erase(fullt.find(x));
sumtime -= x;
};
int64_t sum_pleasure = 0, max_pleasure = 0;
while (r < nsong) {
assert(l <= r);
if (l == r) assert(sumtime == 0 and sum_pleasure == 0);
if ((int)partt.size() == maxpart) {
if (t[r] <= *partt.begin())
addfull(t[r]);
else {
addpart(t[r]);
addfull(*partt.begin());
delpart(*partt.begin());
}
assert((int)partt.size() == maxpart);
} else {
assert(fullt.empty());
addpart(t[r]);
}
sum_pleasure += pl[r];
++r;
while (sumtime > maxtime) {
assert(not partt.empty());
if (*partt.begin() <= t[l]) {
delpart(t[l]);
if (not fullt.empty()) {
addpart(*fullt.rbegin());
delfull(*fullt.rbegin());
}
} else
delfull(t[l]);
sum_pleasure -= pl[l];
++l;
}
max_pleasure = std::max(max_pleasure, sum_pleasure);
}
std::cout << max_pleasure << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int boss = 2e5;
int l, r, n, k, w, answer, v, t, a[boss + 10], b[boss + 10];
multiset<int> m, q;
multiset<int>::iterator j;
int main() {
int i;
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> w >> k;
for (i = 0; i < n; i++) cin >> a[i];
for (i = 0; i < n; i++) cin >> b[i];
while (r < n) {
t += (b[r] + 1) / 2;
v += a[r];
m.insert(b[r++]);
if (m.size() > w) {
q.insert(*(m.begin()));
t += *(m.begin()) / 2;
m.erase(m.begin());
}
while (l <= r && t > k) {
if (b[l] >= *(m.begin())) {
t -= (b[l] + 1) / 2;
m.erase(m.find(b[l]));
if (q.size()) {
j = q.end();
m.insert(*(--j));
t -= *j / 2;
q.erase(j);
}
} else
q.erase(q.find(b[l])), t -= b[l];
v -= a[l++];
}
answer = max(answer, v);
}
cout << answer;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = (int)1e6 + 6, mod = (int)0;
int n, w, k, a[N], t[N];
set<pair<int, int>> x, y;
int r, pl, tl, ts, res;
void fix() {
while (x.size() > 0 && y.size() > 0) {
auto p = *(x.rbegin());
auto q = *(y.begin());
if (p.first > q.first) {
x.erase(p);
y.insert(p);
ts += p.first / 2;
x.insert(q);
y.erase(q);
ts -= q.first / 2;
} else {
break;
}
}
while (x.size() > 0 && y.size() < w) {
auto it = *(x.rbegin());
ts += it.first / 2;
y.insert(it);
x.erase(it);
}
}
void add(int r) {
x.insert(make_pair(t[r], r));
pl += a[r];
tl += t[r];
fix();
}
void rem(int l) {
pl -= a[l];
tl -= t[l];
if (y.find(make_pair(t[l], l)) != y.end()) {
ts -= t[l] / 2;
y.erase(make_pair(t[l], l));
} else {
x.erase(make_pair(t[l], l));
}
fix();
}
bool check(int lim) {
x.clear();
y.clear();
r = 0, pl = 0, tl = 0, ts = 0, res = 0;
for (int l = 0; l < n; ++l) {
while (r < n && tl - ts <= k) {
add(r);
r++;
}
if (tl - ts > k) {
rem(r - 1);
r--;
}
res = max(res, pl);
rem(l);
}
return 0;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> w >> k;
for (int j = 0; j < n; ++j) cin >> a[j];
for (int j = 0; j < n; ++j) cin >> t[j];
reverse(a, a + n);
reverse(t, t + n);
check(0);
cout << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, w, k, a[200005], t[200005];
set<pair<int, int> > s, s1;
int ds = 0, dd[200005];
void lam() {
int i = 1, j = 1;
int T = 0, res = 0;
while (i <= n) {
j = max(j, i);
while (j <= n) {
while (!s.empty() && w) {
pair<int, int> x = *s.rbegin();
s.erase(x);
dd[x.second] = 1;
s1.insert(pair<int, int>((x.first + 1) / 2, x.second));
T = T - x.first + (x.first + 1) / 2;
--w;
}
if (w && T + (t[j] + 1) / 2 <= k) {
s1.insert(pair<int, int>((t[j] + 1) / 2, j));
T += (t[j] + 1) / 2;
res += a[j];
dd[j] = 1;
++j;
--w;
continue;
}
pair<int, int> x = *s1.begin();
if (t[x.second] < t[j] &&
T - x.first + t[x.second] + (t[j] + 1) / 2 <= k) {
s1.erase(x);
s1.insert(pair<int, int>((t[j] + 1) / 2, j));
s.insert(pair<int, int>(t[x.second], x.second));
dd[x.second] = 0;
dd[j] = 1;
T = T - x.first + t[x.second] + (t[j] + 1) / 2;
res += a[j];
++j;
continue;
}
if (T + t[j] <= k) {
s.insert(pair<int, int>(t[j], j));
dd[j] = 0;
T += t[j];
res += a[j];
++j;
continue;
}
break;
}
ds = max(ds, res);
res -= a[i];
if (dd[i] == 0) {
s.erase(pair<int, int>(t[i], i));
T -= t[i];
} else {
s.erase(pair<int, int>((t[i] + 1) / 2, i));
T -= (t[i] + 1) / 2;
++w;
}
++i;
}
cout << ds;
}
int main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(0);
cin >> n >> w >> k;
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 1; i <= n; ++i) cin >> t[i];
lam();
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, w, k;
long long a[200010], t[200010];
struct no {
long long t;
long long a;
bool friend operator<(const no& t1, const no& t2) {
if (t1.t == t2.t) return t1.a < t2.a;
return t1.t < t2.t;
}
};
multiset<no> s1, s2;
signed main() {
cin >> n >> w >> k;
for (long long i = 1; i <= n; i++) cin >> a[i];
for (long long i = 1; i <= n; i++) cin >> t[i];
long long maxx = 0, pl = 1;
long long re = 0, ti = 0;
for (long long i = 1; i <= w; i++) {
if (ti + (t[i] + 1) / 2 <= k) {
ti += (t[i] + 1) / 2;
re += a[i];
pl = i + 1;
maxx = max(maxx, re);
s1.insert({t[i], a[i]});
} else {
maxx = max(maxx, re);
break;
}
}
while (pl <= n) {
no te;
if ((long long)s1.size() < w) break;
te = *s1.begin();
if (te.t < t[pl] && ti + (t[pl] + 1) / 2 + te.t / 2 <= k) {
s1.erase(s1.find(te));
s1.insert({t[pl], a[pl]});
s2.insert(te);
ti += (t[pl] + 1) / 2 + te.t / 2;
re += a[pl];
pl++;
maxx = max(maxx, re);
} else if (te.t >= t[pl] && ti + t[pl] <= k) {
ti += t[pl];
s2.insert({t[pl], a[pl]});
re += a[pl++];
maxx = max(maxx, re);
} else
break;
}
for (long long st = 2; st <= n && pl <= n; st++) {
no te;
no tt = {t[st - 1], a[st - 1]};
if (s1.empty() && k >= (t[st] + 1) / 2) {
s1.insert({t[st], a[st]});
ti = (t[st] + 1) / 2;
re = a[st];
pl = st + 1;
} else if (s1.size() && s1.find(tt) != s1.end()) {
s1.erase(s1.find(tt));
ti -= (t[st - 1] + 1) / 2;
re -= a[st - 1];
if (s2.size()) {
te = *--s2.end();
ti -= te.t / 2;
s2.erase(s2.find(te));
s1.insert(te);
}
} else if (s2.size() && s2.find(tt) != s2.end()) {
s2.erase(s2.find(tt));
ti -= t[st - 1];
re -= a[st - 1];
}
while (pl <= n) {
no te = *s1.begin();
if ((long long)s1.size() < w && (t[pl] + 1) / 2 + ti <= k) {
ti += (t[pl] + 1) / 2;
re += a[pl];
maxx = max(maxx, re);
s1.insert({t[pl], a[pl]});
pl++;
continue;
}
if ((long long)s1.size() == w && t[pl] > te.t &&
ti + te.t / 2 + (t[pl] + 1) / 2 <= k) {
s1.erase(s1.find(te));
s1.insert({t[pl], a[pl]});
s2.insert(te);
ti = ti + te.t / 2 + (t[pl] + 1) / 2;
re += a[pl];
pl++;
maxx = max(maxx, re);
continue;
}
if (t[pl] <= te.t && ti + t[pl] <= k) {
s2.insert({t[pl], a[pl]});
re += a[pl];
ti += t[pl];
pl++;
maxx = max(maxx, re);
continue;
}
break;
}
}
cout << maxx << endl;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")
using namespace std;
template <typename T>
constexpr int infValue =
std::is_same<T, int>::value ? 2000000007 : 8600000000000000007ll;
template <typename T>
constexpr int maxValue =
std::is_same<T, int>::value ? 1000000007 : 1000000000000000001ll;
const int INF = infValue<int>;
const int MOD = 1000000007ll;
const double EPS = 1e-6;
const int MAX = maxValue<int>;
int n, w, k;
int a[200101], t[200101];
set<pair<int, int>> q;
set<pair<int, int>, greater<pair<int, int>>> f;
int answ;
int main(void) {
scanf("%d %d %d", &n, &w, &k);
for (register int i = 0; i < n; ++i) scanf("%d", a + i);
for (register int i = 0; i < n; ++i) scanf("%d", t + i);
int i = 0, j = 0, s = 0;
while (i < n) {
while (j < n) {
if (q.size() == w) {
if (q.begin()->first > t[j]) {
if (t[j] > k) break;
k -= t[j];
s += a[j];
f.insert({t[j], j});
} else {
int v = -(q.begin()->first + 1 >> 1) + q.begin()->first +
((t[j] + 1) >> 1);
if (v > k) break;
k -= v;
f.insert(*q.begin());
q.erase(q.begin());
q.insert({t[j], j});
s += a[j];
}
} else {
if (k < t[j] + 1 >> 1) break;
q.insert({t[j], j}), s += a[j], k -= t[j] + 1 >> 1;
}
++j;
}
answ = max(answ, s);
if (q.count({t[i], i})) {
q.erase({t[i], i});
s -= a[i];
k += t[i] + 1 >> 1;
if (!f.empty()) {
int v = (f.begin()->first + 1 >> 1) - f.begin()->first;
q.insert(*f.begin());
f.erase(f.begin());
k -= v;
}
} else if (i < j) {
k += t[i];
s -= a[i];
f.erase({t[i], i});
}
++i;
}
printf("%d\n", answ);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int mode[200000];
priority_queue<pair<int, int>> ed;
priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>>
hf;
int es, hs;
int a[200000];
int t[200000];
void mod1() {
while ((!ed.empty()) && mode[ed.top().second] != 1) ed.pop();
}
void mod2() {
while ((!hf.empty()) && mode[hf.top().second] != 2) hf.pop();
}
int main() {
int n, w, k;
cin >> n >> w >> k;
for (int i = 0; i < n; i++) cin >> a[n - i - 1];
for (int i = 0; i < n; i++) cin >> t[n - i - 1];
int nt = 0, sum = 0, ind = 0, ans = 0;
for (int i = 0; i < n; i++) {
while (ind < n) {
mod1();
mod2();
if (hs < w) {
if (nt + (t[ind] + 1) / 2 > k) break;
sum += a[ind];
nt += (t[ind] + 1) / 2;
mode[ind] = 2;
hf.push(make_pair(t[ind], ind));
hs++;
} else if (t[ind] > hf.top().first) {
if (nt + (t[ind] + 1) / 2 + hf.top().first / 2 > k) break;
sum += a[ind];
nt += (t[ind] + 1) / 2 + hf.top().first / 2;
mode[hf.top().second] = 1;
mode[ind] = 2;
ed.push(hf.top());
hf.pop();
hf.push(make_pair(t[ind], ind));
} else {
if (nt + t[ind] > k) break;
sum += a[ind];
nt += t[ind];
mode[ind] = 1;
ed.push(make_pair(t[ind], ind));
}
ans = max(ans, sum);
ind++;
}
if (mode[i] == 1) {
sum -= a[i];
nt -= t[i];
}
if (mode[i] == 2) {
hs--;
sum -= a[i];
nt -= (t[i] + 1) / 2;
mod1();
if (!ed.empty()) {
hs++;
nt -= ed.top().first / 2;
mode[ed.top().second] = 2;
hf.push(ed.top());
ed.pop();
}
}
mode[i] = 0;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int N, W;
long long K;
cin >> N >> W >> K;
vector<long long> a(N), t(N);
for (int i = 0; i < N; i++) cin >> a[i];
for (int i = 0; i < N; i++) cin >> t[i];
set<pair<long long, int> > big, small;
long long res = 0, cur = 0, ti = 0;
for (int i = 0, j = 0; i < N; i++) {
if (i) {
if (big.count({t[i - 1], i - 1})) {
cur -= a[i - 1];
ti -= (t[i - 1] + 1) / 2;
big.erase({t[i - 1], i - 1});
} else if (small.count({t[i - 1], i - 1})) {
cur -= a[i - 1];
ti -= t[i - 1];
small.erase({t[i - 1], i - 1});
}
while (!small.empty() && (int)big.size() < W) {
auto p = *prev(small.end());
big.insert(p);
ti -= p.first / 2;
small.erase(prev(small.end()));
}
}
while (j < N && ti <= K) {
if ((int)big.size() < W && ti + (t[j] + 1) / 2 <= K) {
big.insert({t[j], j});
ti += (t[j] + 1) / 2;
cur += a[j];
} else if ((int)big.size() == W && big.begin()->first < t[j] &&
ti + big.begin()->first / 2 + (t[j] + 1) / 2 <= K) {
auto p = *big.begin();
small.insert(p);
big.erase(big.begin());
big.insert({t[j], j});
ti += p.first / 2 + (t[j] + 1) / 2;
cur += a[j];
} else if (ti + t[j] <= K) {
small.insert({t[j], j});
ti += t[j];
cur += a[j];
} else {
break;
}
j++;
}
res = max(res, cur);
}
cout << res << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void rs(int &x) { scanf("%d", &x); }
void rsl(long long &x) { scanf("%I64d", &x); }
void rsd(double &x) { scanf("%lf", &x); }
void rss(char *str) { scanf("%s", str); }
void ws(int &x) { printf("%d ", x); }
void wsl(long long &x) { printf("%I64d ", x); }
void wsd(double &x) { printf("%lf ", x); }
void wss(char *str) { printf("%s ", str); }
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
int const N = (2e5) + 5;
int const mod = (1e9) + 7;
int a[N], t[N], suma[N], sumt[N];
priority_queue<int> que;
set<pair<int, int>> ms, mns;
map<int, int> mm;
int ins[N], inns[N];
int main() {
int n, w, k;
cin >> n >> w >> k;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
suma[i] = suma[i - 1] + a[i];
}
for (int i = 1; i <= n; ++i) {
cin >> t[i];
mm[t[i]] = i;
sumt[i] = sumt[i - 1] + t[i];
}
int ans = 0;
int r = 1;
int ct = 0;
int cp = 0;
for (int i = 1; i <= n; ++i) {
r = max(r, i);
while (r <= n) {
int dt = 0;
if (ms.size() < w) {
dt = t[r] / 2 + t[r] % 2;
if (ct + dt <= k) {
ms.insert(make_pair(t[r], r));
ins[r] = 1;
ct += dt;
} else {
break;
}
} else {
int var = ms.begin()->first;
if (t[r] > var) {
int dt = t[r] / 2 + t[r] % 2;
int ddt = (var / 2);
if (ct + dt + ddt <= k) {
ins[ms.begin()->second] = 0;
ins[r] = 1;
mns.insert(*ms.begin());
ms.erase(ms.begin());
ms.insert(make_pair(t[r], r));
ct += dt + ddt;
} else {
break;
}
} else {
int dt = t[r];
if (ct + dt <= k) {
ct += dt;
mns.insert(make_pair(t[r], r));
} else {
break;
}
}
}
r++;
}
ans = max(suma[r - 1] - suma[i - 1], ans);
if (ins[i] == 0) {
ct -= t[i];
} else {
ct -= (t[i] / 2 + t[i] % 2);
ins[i] = 0;
set<pair<int, int>>::iterator it = ms.find(make_pair(t[i], i));
if (it != ms.end()) {
ms.erase(it);
}
while (mns.size() > 0 && ((--mns.end())->second <= i)) {
mns.erase(--mns.end());
}
if (mns.size() > 0) {
it = --mns.end();
ct -= ((it->first) / 2);
ins[it->second] = 1;
ms.insert(*(--mns.end()));
mns.erase((--mns.end()));
}
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int n, w, k;
int a[N], t[N];
int d[N];
bool in[N];
struct Sol {
set<pair<int, int> > big;
set<pair<int, int> > small;
int z = 0;
void add(int i) {
if (small.empty() || t[i] > small.rbegin()->first) {
big.insert(make_pair(t[i], i));
z += (t[i] + 1) / 2;
} else {
small.insert(make_pair(t[i], i));
z += t[i];
}
while (big.size() > w) {
auto tt = *big.begin();
big.erase(big.begin());
z -= (tt.first + 1) / 2;
small.insert(tt);
z += tt.first;
}
}
void erase(int i) {
if (small.count(make_pair(t[i], i))) {
small.erase(make_pair(t[i], i));
z -= t[i];
} else {
big.erase(make_pair(t[i], i));
z -= (t[i] + 1) / 2;
}
while (big.size() < w) {
if (small.empty()) break;
auto tt = *small.rbegin();
small.erase(--small.end());
z -= tt.first;
big.insert(tt);
z += (tt.first + 1) / 2;
}
}
int get() { return z; }
} sol;
int main() {
scanf("%d%d%d", &n, &w, &k);
for (int i = 0; i < n; ++i) {
scanf("%d", a + i);
}
for (int i = 0; i < n; ++i) d[i] = (i == 0 ? 0 : d[i - 1]) + a[i];
for (int i = 0; i < n; ++i) {
scanf("%d", t + i);
}
int ans = 0;
int j = 0;
for (int i = 0; i < n; ++i) {
for (; sol.get() <= k && j < n; ++j) {
sol.add(j);
in[j] = 1;
if (sol.get() > k) {
ans = max(ans, d[j - 1] - (i == 0 ? 0 : d[i - 1]));
++j;
break;
}
}
if (sol.get() <= k) {
ans = max(ans, d[j - 1] - (i == 0 ? 0 : d[i - 1]));
}
if (in[i]) {
sol.erase(i);
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long tavan(long long x, long long y) {
long long res = 1;
while (y) {
res *= y % 2 ? x : 1;
res %= ((long long)1e9 + 7);
x *= x;
x %= ((long long)1e9 + 7);
y /= 2;
}
return res;
}
long long n, w, k, a[((long long)501 * 1000)], t[((long long)501 * 1000)], ans;
multiset<long long> s, p;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> w >> k;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) cin >> t[i];
for (long long i = 0, j = 0, time = 0, res = 0; i < n; i++) {
while (j < n) {
long long now = time;
if ((long long)s.size() < w)
now += (t[j] + 1) / 2;
else if (t[j] > (*s.begin()))
now += (t[j] + 1) / 2 + ((*s.begin()) - ((*s.begin()) + 1) / 2);
else
now += t[j];
if (now > k) break;
if ((long long)s.size() < w)
s.insert(t[j]);
else if (t[j] > (*s.begin()))
p.insert(*s.begin()), s.erase(s.begin()), s.insert(t[j]);
else
p.insert(t[j]);
time = now;
res += a[j];
j++;
}
ans = max(ans, res);
if (j <= i) {
j = i + 1;
continue;
}
res -= a[i];
if (t[i] < *s.begin())
p.erase(p.find(t[i])), time -= t[i];
else {
s.erase(s.find(t[i]));
time -= (t[i] + 1) / 2;
if (p.size()) {
auto it = p.end();
it--;
s.insert(*it);
time -= (*it - (*it + 1) / 2);
p.erase(it);
}
}
}
cout << ans;
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.