text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 0x1f3f3f3f3f3f3f3f, mod = 1000000007,
inf2 = 0x3f3f3f3f3f3f3f3f;
const double pi = 3.1415926535897932, eps = 1e-6;
void chmax(int &x, int y) {
if (x < y) x = y;
}
void chmin(int &x, int y) {
if (x > y) x = y;
}
long long n, m;
long long a[500005], b[500005], c[500005], tb[500005];
map<long long, int> mp, mp2;
struct segtree {
long long dat[1048580], add[1048580], n;
void build(int nn) {
n = 1;
while (n <= nn) n <<= 1;
}
void update(int a, int b, long long x) { update(0, 0, n, a, b + 1, x); }
long long update(int k, int l, int r, int a, int b, long long x) {
if (r <= a || b <= l) return dat[k] + add[k];
if (a <= l && r <= b) {
add[k] += x;
return dat[k] + add[k];
}
dat[k] = min(update((k << 1) + 1, l, (l + r) >> 1, a, b, x),
update((k << 1) + 2, (l + r) >> 1, r, a, b, x));
return dat[k] + add[k];
}
long long query(int l, int r) { return query(l, r + 1, 0, 0, n); }
long long query(int a, int b, int k, int l, int r) {
if (r <= a || b <= l) return inf2;
if (a <= l && r <= b) return dat[k] + add[k];
return min(query(a, b, (k << 1) + 1, l, (l + r) >> 1),
query(a, b, (k << 1) + 2, (l + r) >> 1, r)) +
add[k];
}
} seg;
long long dp[500005];
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int(i) = (1); (i) <= (n); (i)++) cin >> a[i], mp[a[i]] = 0;
for (int(i) = (1); (i) <= (n); (i)++) cin >> c[i];
cin >> m;
for (int(i) = (1); (i) <= (m); (i)++) cin >> b[i];
n++;
a[n] = 2e9;
m++;
b[m] = 2e9;
mp[a[n]] = 0;
int cnt = 0;
for (map<long long, int>::iterator it = mp.begin(); it != mp.end(); it++)
it->second = ++cnt;
for (int(i) = (1); (i) <= (n); (i)++) a[i] = mp[a[i]];
for (int(i) = (1); (i) <= (m); (i)++) {
if (!mp[b[i]]) {
cout << "NO\n";
return 0;
}
b[i] = mp[b[i]];
mp2[b[i]] = i;
}
seg.build(cnt + 1);
seg.update(1, cnt, inf);
for (int(i) = (1); (i) <= (n); (i)++) {
int pos = mp2[a[i]];
if (pos) {
dp[i] = seg.query(b[pos - 1], b[pos - 1]);
}
if (c[i] < 0)
seg.update(0, cnt, c[i]);
else
seg.update(0, a[i] - 1, c[i]);
if (pos) {
long long prev = seg.query(a[i], a[i]);
if (dp[i] < prev) seg.update(a[i], a[i], dp[i] - prev);
}
}
long long ans = dp[n];
if (ans > 1e15) {
cout << "NO";
} else
cout << "YES" << endl << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 5e5 + 100;
const long long maxN = 6e6;
const long long oo = 1e18;
const long long mod = 998244353;
long long n, m;
long long a[N], b[N], cost[N], equalpos[N];
long long IT[20 * N], lazy[20 * N];
map<long long, long long> mp;
void updmin(long long &x, long long y) { x = min(x, y); }
void addlazy(long long node, long long nlef, long long nrig) {
if (nlef > nrig || !lazy[node]) return;
if (nlef == nrig && IT[node] < oo) IT[node] += lazy[node];
if (nlef < nrig) {
lazy[2 * node] += lazy[node];
lazy[2 * node + 1] += lazy[node];
}
lazy[node] = 0;
}
void upd(long long node, long long nlef, long long nrig, long long lef,
long long rig, long long val, bool flag) {
addlazy(node, nlef, nrig);
if (nlef > rig || nrig < lef || nlef > nrig) return;
if (lef <= nlef && nrig <= rig) {
if (!flag) {
lazy[node] += val;
addlazy(node, nlef, nrig);
} else
IT[node] = val;
return;
}
long long mid = (nlef + nrig) / 2;
upd(2 * node, nlef, mid, lef, rig, val, flag);
upd(2 * node + 1, mid + 1, nrig, lef, rig, val, flag);
}
long long get(long long node, long long nlef, long long nrig, long long pos) {
addlazy(node, nlef, nrig);
if (nlef > pos || pos > nrig) return oo;
if (nlef == nrig) {
return IT[node];
}
long long mid = (nlef + nrig) / 2;
return min(get(2 * node, nlef, mid, pos),
get(2 * node + 1, mid + 1, nrig, pos));
}
signed main() {
ios_base::sync_with_stdio(false);
cout.tie(0);
cin >> n;
for (long long i = 1; i <= n; ++i) cin >> a[i];
for (long long i = 1; i <= n; ++i) cin >> cost[i];
cin >> m;
for (long long i = 1; i <= m; ++i) cin >> b[i], mp[b[i]] = i;
for (long long i = 1; i <= n; ++i)
if (mp.find(a[i]) != mp.end()) equalpos[i] = mp[a[i]];
for (long long i = 0; i <= 20 * N - 1; ++i) IT[i] = oo;
if (a[1] < b[1])
upd(1, 0, m, 0, 0, cost[1], 1);
else if (a[1] == b[1]) {
upd(1, 0, m, 0, 0, cost[1], 1);
upd(1, 0, m, 1, 1, 0, 1);
} else
upd(1, 0, m, 0, 0, cost[1], 1);
for (long long i = 2; i <= n; ++i) {
long long pos = equalpos[i];
if (pos) {
long long val = get(1, 0, m, pos - 1);
long long tmp = get(1, 0, m, pos);
if (cost[i] < 0 && tmp < oo) updmin(val, tmp + cost[i]);
updmin(val, get(1, 0, m, pos));
upd(1, 0, m, pos, pos, val, 1);
}
pos = lower_bound(b + 1, b + m + 1, a[i]) - b - 1;
if (pos >= 0)
upd(1, 0, m, 0, pos, cost[i], 0);
else
pos = 0;
while (pos <= m && b[pos] <= a[i]) pos += 1;
if (cost[i] < 0 && pos <= m) upd(1, 0, m, pos, m, cost[i], 0);
}
long long ans = get(1, 0, m, m);
if (ans < oo) return cout << "YES\n" << ans, 0;
cout << "NO";
}
|
#include <bits/stdc++.h>
using namespace std;
class trio {
public:
long long first, second, third;
};
struct FenwickTree {
vector<long long> bit;
long long n;
FenwickTree(long long n) {
this->n = n;
bit.assign(n, 0);
}
FenwickTree(vector<long long> a) : FenwickTree(a.size()) {
for (size_t i = 0; i < a.size(); i++) add(i, a[i]);
}
long long sum(long long r) {
long long ret = 0;
for (; r >= 0; r = (r & (r + 1)) - 1) ret += bit[r];
return ret;
}
long long sum(long long l, long long r) { return sum(r) - sum(l - 1); }
void add(long long idx, long long delta) {
for (; idx < n; idx = idx | (idx + 1)) bit[idx] += delta;
}
};
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long n;
cin >> n;
long long arr[n + 1], p[n + 1], brrI[n + 1], fdp[n + 1];
memset(brrI, 0, sizeof(brrI));
memset(arr, 0, sizeof(arr));
memset(p, 0, sizeof(p));
for (long long i = 1; i < n + 1; ++i) {
cin >> arr[i];
}
for (long long i = 1; i < n + 1; ++i) {
cin >> p[i];
}
long long m;
cin >> m;
long long brr[m + 1];
memset(brr, 0, sizeof(brr));
for (long long i = 1; i < m + 1; ++i) {
cin >> brr[i];
brrI[brr[i]] = i;
}
map<long long, long long> futsum[n + 1];
FenwickTree tree(n + 5);
long long neg = 0;
for (long long i = n; i >= 1; --i) {
long long x1 = arr[i];
long long x2 = brr[max(brrI[arr[i]] - 1, (long long)0)];
futsum[i][x1] = tree.sum(x1 + 1, n + 1) + neg;
futsum[i][x2] = tree.sum(x2 + 1, n + 1) + neg;
if (p[i] < 0)
neg += p[i];
else
tree.add(arr[i], p[i]);
}
for (long long i = 0; i < n + 1; ++i) fdp[i] = 1000000000000000000;
fdp[0] = tree.sum(0, n + 1) + neg;
for (long long i = 1; i < n + 1; ++i) {
long long t1 = brrI[arr[i]];
if (t1 == 0) continue;
long long t2 = t1 - 1;
long long x = fdp[brr[t2]];
if (x == 1000000000000000000) continue;
fdp[arr[i]] =
min(fdp[arr[i]], x - futsum[i][brr[t2]] - p[i] + futsum[i][arr[i]]);
}
if (fdp[brr[m]] == 1000000000000000000)
cout << "NO\n";
else
cout << "YES\n" << fdp[brr[m]] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
const int N = 5 * 1e5 + 5;
int ind = 2;
int L[10000000] = {}, R[10000000] = {};
long long V[10000000] = {};
int edit(int x, int tar, int v, int l = 0, int r = n, int off = 0) {
if (l == r - 1) {
V[ind] = v;
L[ind] = 0;
R[ind] = 0;
return ind++;
} else {
int m = (l + r) / 2;
if (tar < m) {
int nxt = edit(L[x], tar, v, l, m, 1 - off);
L[ind] = nxt;
R[ind] = R[x];
V[ind] = V[L[ind]] + V[R[ind]];
return ind++;
} else {
int nxt = edit(R[x], tar, v, m, r, 1 - off);
L[ind] = L[x];
R[ind] = nxt;
V[ind] = V[L[ind]] + V[R[ind]];
return ind++;
}
}
}
long long query(int x, int l, int r, int cl = 0, int cr = n, int off = 0) {
if (r <= cl || l >= cr)
return 0;
else if (l <= cl && cr <= r)
return V[x];
int m = (cl + cr) / 2;
return query(L[x], l, r, cl, m, 1 - off) + query(R[x], l, r, m, cr, 1 - off);
}
int tree[N], best[N], w[N], a[N], p[N];
long long dp[N];
const long long inf = 1e16;
vector<pair<int, int> > vals[N];
int m;
int b[N];
int main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(0);
fill(w, w + N, -1);
fill(best, best + N, -1);
cin >> n;
++n;
for (int i = 1; i < n; ++i) cin >> a[i];
tree[N - 1] = 1;
for (int i = 1; i < n; ++i) {
cin >> p[i];
if (p[i] > 0) {
vals[a[i]].emplace_back(i, p[i]);
} else {
tree[N - 1] = edit(tree[N - 1], i, p[i]);
}
}
cin >> m;
++m;
w[0] = 0;
bool valid = true;
for (int i = 1; i < m; ++i) {
cin >> b[i];
w[b[i]] = i;
if (b[i] <= b[i - 1]) valid = false;
}
for (int i = N - 2; i >= 0; --i) {
tree[i] = tree[i + 1];
for (pair<int, int> p : vals[i]) {
tree[i] = edit(tree[i], p.first, p.second);
}
}
for (int i = n - 1; i >= 0; --i) {
dp[i] = inf;
int id = w[a[i]];
if (~id) {
if (id == m - 1) {
long long cst = query(tree[a[i] + 1], i + 1, n);
dp[i] = cst;
} else {
int nxt = best[id + 1];
if (~nxt) {
dp[i] = query(tree[a[i] + 1], i + 1, nxt) + dp[nxt];
}
}
dp[i] = min(dp[i], inf);
if (dp[i] != inf) {
if (~best[id] && id) {
long long cst = query(tree[b[id - 1] + 1], i, best[id]);
if (dp[i] <= cst + dp[best[id]]) {
best[id] = i;
}
} else {
best[id] = i;
}
}
}
}
if (dp[0] == inf) valid = false;
if (!valid) {
cout << "NO\n";
} else {
cout << "YES\n";
cout << dp[0] << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll INF = 1e17;
namespace ProconLib {
template <typename Int>
struct BIT {
private:
int N;
std::vector<Int> dat;
public:
BIT(int N) : N(N), dat(N, 0) {}
void add(int pos, Int x);
Int sum(int r);
Int sum(int l, int r);
};
template <typename Int>
void BIT<Int>::add(int pos, Int x) {
pos++;
while (pos <= N) {
dat[pos - 1] += x;
pos += pos & -pos;
}
}
template <typename Int>
Int BIT<Int>::sum(int r) {
Int res = 0;
while (r > 0) {
res += dat[r - 1];
r -= r & -r;
}
return res;
}
template <typename Int>
Int BIT<Int>::sum(int l, int r) {
return sum(r) - sum(l);
}
}; // namespace ProconLib
using namespace ProconLib;
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i], a[i]--;
vector<ll> p(n);
for (int i = 0; i < n; i++) cin >> p[i];
int m;
cin >> m;
vector<int> b(m);
for (int i = 0; i < m; i++) cin >> b[i], b[i]--;
vector<int> mp(n, -1);
for (int i = 0; i < m; i++) mp[b[i]] = i;
BIT<ll> dp(m + 2);
dp.add(1, INF);
for (int i = 0; i < n; i++) {
bool flag = mp[a[i]] != -1;
int pos;
ll tmp;
if (mp[a[i]] != -1) {
pos = mp[a[i]];
tmp = dp.sum(0, pos + 1);
}
int r = lower_bound(b.begin(), b.end(), a[i]) - b.begin();
if (p[i] >= 0) {
dp.add(0, p[i]);
dp.add(r + 1, -p[i]);
} else {
dp.add(0, p[i]);
}
if (flag) {
ll pre = dp.sum(0, pos + 2);
if (tmp < pre) {
ll diff = tmp - pre;
dp.add(pos + 1, diff);
dp.add(pos + 2, -diff);
}
}
}
if (dp.sum(0, m + 1) >= INF / 10) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
cout << dp.sum(0, m + 1) << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 0x3f3f3f3f3f3f3f3f;
const int maxn = 500005;
int a[maxn], b[maxn], id[maxn];
long long p[maxn];
struct node {
int l, r;
long long lazy;
long long v;
} tree[maxn << 2];
void push_down(int k) {
long long c = tree[k].lazy;
tree[2 * k].v += c;
tree[2 * k].lazy += c;
tree[2 * k + 1].v += c;
tree[2 * k + 1].lazy += c;
tree[k].lazy = 0;
}
void build(int k, int l, int r) {
tree[k].l = l;
tree[k].r = r;
tree[k].lazy = 0;
tree[k].v = inf;
if (l == r) {
if (l == 0) tree[k].v = 0;
return;
}
int mid = (l + r) / 2;
build(2 * k, l, mid);
build(2 * k + 1, mid + 1, r);
}
void add(int k, int l, int r, long long c) {
if (tree[k].l >= l && tree[k].r <= r) {
tree[k].v += c;
tree[k].lazy += c;
return;
}
if (tree[k].lazy) push_down(k);
int mid = (tree[k].l + tree[k].r) / 2;
if (l <= mid) add(2 * k, l, r, c);
if (r > mid) add(2 * k + 1, l, r, c);
}
void update(int k, int x, long long c) {
if (tree[k].l == tree[k].r) {
tree[k].v = c;
return;
}
if (tree[k].lazy) push_down(k);
int mid = (tree[k].l + tree[k].r) / 2;
if (x <= mid)
update(2 * k, x, c);
else
update(2 * k + 1, x, c);
}
long long query(int k, int x) {
if (tree[k].l == tree[k].r) return tree[k].v;
if (tree[k].lazy) push_down(k);
int mid = (tree[k].l + tree[k].r) / 2;
if (x <= mid)
return query(2 * k, x);
else
return query(2 * k + 1, x);
}
int main() {
int n, m;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) scanf("%lld", &p[i]);
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
scanf("%d", &b[i]);
id[b[i]] = i;
}
build(1, 0, m);
for (int i = 1; i <= n; i++) {
if (id[a[i]]) {
int tmp = id[a[i]];
long long val1 = query(1, tmp);
long long val2 = query(1, tmp - 1);
long long val = min(val2, val1 + min(0ll, p[i]));
update(1, tmp, val);
}
int tmp1 = lower_bound(b + 1, b + m + 1, a[i]) - b;
add(1, 0, tmp1 - 1, p[i]);
int tmp2 = upper_bound(b + 1, b + m + 1, a[i]) - b;
if (tmp2 <= m) add(1, tmp2, m, min(0ll, p[i]));
}
long long ans = query(1, m);
if (ans > 5e14)
printf("NO\n");
else {
printf("YES\n");
printf("%lld\n", ans);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = (long long)1e9 + 7;
const long long MOD1 = 2286661337;
const long long MOD2 = 998244353;
const int INF = (int)1e9 + 7;
const double EPS = 1e-7;
const int N = (int)5e5;
int n, m, a[N], b[N], p[N], first_good;
long long dp_num[N], t_p[N], sum_minus[N];
void add(int ind, long long val, long long t[N], int n) {
while (ind < n) {
t[ind] += val;
ind |= ind + 1;
}
}
long long sum(int ind, long long t[N], int n) {
long long res = 0;
while (ind >= 0) {
res += t[ind];
ind &= ind + 1;
--ind;
}
return res;
}
signed main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
--a[i];
}
for (int i = 0; i < n; ++i) {
scanf("%d", &p[i]);
if (p[i] < 0) {
sum_minus[i] = p[i];
}
if (i) {
sum_minus[i] += sum_minus[i - 1];
}
}
scanf("%d", &m);
for (int i = 0; i < m; ++i) {
scanf("%d", &b[i]);
--b[i];
}
add(0, (long long)1e18, dp_num, m);
first_good = m;
for (int i = n - 1; i >= 0; --i) {
int ind = lower_bound(b, b + m, a[i]) - b;
if (p[i] > 0) {
if (ind >= first_good) {
add(first_good, p[i], dp_num, m);
add(ind + 1, -p[i], dp_num, m);
}
} else {
add(first_good, p[i], dp_num, m);
}
if (ind < m && b[ind] == a[i]) {
long long new_val = (long long)1e18, old_val = sum(ind, dp_num, m);
if (ind == m - 1) {
new_val = sum(n - 1, t_p, n) - sum(b[ind], t_p, n) + sum_minus[n - 1] -
sum_minus[i];
} else {
new_val = sum(ind + 1, dp_num, m);
if (new_val != (long long)1e18 && p[i] < 0) {
new_val -= p[i];
}
}
if (new_val < old_val) {
add(ind, new_val - old_val, dp_num, m);
add(ind + 1, -new_val + old_val, dp_num, m);
}
if (new_val != (long long)1e18) {
first_good = min(first_good, ind);
}
}
if (p[i] > 0) {
add(a[i], p[i], t_p, n);
}
}
if (first_good) {
printf("NO");
} else {
printf("YES\n");
printf("%lld", dp_num[0]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1 + 5e5;
const long long INF = 1e15;
struct CumulativeSet {
long long val[N + 1];
long long Get(int x) {
long long val = 0;
for (int i = x + 2; i; i -= step(i)) {
val += this->val[i - 1];
}
return val;
}
void SetMin(int x, long long val) {
val -= Get(x);
if (val < 0) Add(x, x, val);
}
void Add(int x, int y, long long val) {
update(x, val);
update(y + 1, -val);
}
void print(int n) {
for (int i = -1; i < n; i++) {
long long C = Get(i);
if (C < INF) {
if (0) fprintf(stderr, "%lld\t", C);
} else {
if (0) fprintf(stderr, "oo\t");
}
}
if (0) fprintf(stderr, "\n");
}
private:
inline static int step(int x) { return x & -x; }
void update(int x, long long val) {
for (int i = x + 2; i <= N; i += step(i)) {
this->val[i - 1] += val;
}
}
};
int a[N], b[N], p[N];
CumulativeSet cost;
void read(int* v, int n) {
for (int i = 0; i < n; i++) {
scanf("%d", v + i);
}
}
int find(const int* v, int n, int x) {
int ans = -1;
for (int step = 1 << 31 - __builtin_clz(n); step; step >>= 1) {
if (ans + step < n && v[ans + step] <= x) {
ans += step;
}
}
return ans;
}
long long solve(const int* a, const int* p, int n, const int* b, int m) {
cost.Add(0, m - 1, 2 * INF);
cost.print(m);
for (int i = 0; i < n; i++) {
int pos = find(b, m, a[i]);
if (pos >= 0 && b[pos] == a[i]) {
long long C = cost.Get(pos - 1);
cost.Add(-1, p[i] > 0 ? pos - 1 : m - 1, p[i]);
cost.SetMin(pos, C);
} else {
cost.Add(-1, p[i] > 0 ? pos : m - 1, p[i]);
}
if (0) cost.print(m);
}
return cost.Get(m - 1);
}
int main() {
int n, m;
scanf("%d", &n);
read(a, n);
read(p, n);
scanf("%d", &m);
read(b, m);
long long cost = solve(a, p, n, b, m);
if (cost < INF) {
printf("YES\n%lld\n", cost);
} else {
puts("NO");
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target(sse, sse1, sse2, tune = native, popcnt)
using namespace std;
const long long inf = 1e17 + 47, MAXN = 5e5 + 47, mod = 1e9 + 7, N = 201;
mt19937 rnd(time(0));
struct node {
long long l, r, dw, mn;
node() {
l = r = -1;
dw = 0;
mn = inf;
}
};
vector<node> t(4 * MAXN);
void build(long long i, long long l, long long r) {
t[i].l = l, t[i].r = r;
if (l == r) {
return;
}
long long mid = (l + r) / 2;
build(i * 2, l, mid);
build(i * 2 + 1, mid + 1, r);
}
void push(long long i) {
if (t[i].l != t[i].r) {
t[i * 2].dw += t[i].dw;
t[i * 2 + 1].dw += t[i].dw;
}
t[i].mn += t[i].dw;
t[i].dw = 0;
}
void update(long long i, long long l, long long r, long long add) {
push(i);
if (t[i].l > r || t[i].r < l) return;
if (l <= t[i].l && t[i].r <= r) {
t[i].dw += add;
push(i);
return;
}
update(i * 2, l, r, add);
update(i * 2 + 1, l, r, add);
}
long long get(long long i, long long pos) {
push(i);
if (t[i].l > pos || pos > t[i].r) return inf;
if (t[i].l == pos && t[i].r == pos) return t[i].mn;
return min(get(i * 2, pos), get(i * 2 + 1, pos));
}
void eshkere(long long i, long long pos, long long a) {
push(i);
if (t[i].l > pos || pos > t[i].r) return;
if (t[i].l == pos && t[i].r == pos) {
t[i].mn = min(t[i].mn, a);
return;
}
eshkere(i * 2, pos, a);
eshkere(i * 2 + 1, pos, a);
}
void print(long long i) {
push(i);
if (t[i].l == t[i].r)
cout << t[i].mn << " ";
else
print(i * 2), print(i * 2 + 1);
}
long long n, m;
vector<long long> a, p, b;
unordered_map<long long, long long> ind;
void solve() {
cin >> n;
a.resize(n), p.resize(n);
for (long long i = 0; i < n; ++i) cin >> a[i];
for (long long i = 0; i < n; ++i) cin >> p[i];
cin >> m;
b.resize(m);
for (long long i = 0; i < m; ++i) {
cin >> b[i];
ind[b[i]] = i;
}
vector<long long> temp(m + 1, inf);
temp[0] = 0;
long long UK = 0;
build(1, 0, m);
eshkere(1, 0, 0);
for (long long i = 0; i < n; ++i) {
long long t = inf;
if (ind.find(a[i]) != ind.end()) {
t = get(1, ind[a[i]]);
}
if (p[i] < 0) {
update(1, 0, UK, p[i]);
} else {
long long ind =
(long long)(lower_bound(b.begin(), b.end(), a[i]) - b.begin());
ind = min(ind, UK);
update(1, 0, ind, p[i]);
}
if (ind.find(a[i]) != ind.end()) {
if (UK >= ind[a[i]]) {
eshkere(1, ind[a[i]] + 1, t);
UK = max(UK, ind[a[i]] + 1);
}
}
}
long long t = get(1, m);
if (t == inf)
cout << "NO" << endl;
else
cout << "YES" << endl << t << endl;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie();
long long t = 1;
while (t--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, t;
long long a[500005], p[500005], b[500005];
long long l, r;
void add(int &a, int b) {
a += b;
if (a >= 1000000007) a -= 1000000007;
}
void dec(int &a, int b) {
a -= b;
if (a < 0) a += 1000000007;
}
int pow_mod(int a, int i) {
int s = 1;
while (i) {
if (i & 1) s = 1LL * s * a % 1000000007;
a = 1LL * a * a % 1000000007;
i >>= 1;
}
return s;
}
struct segtree {
long long lazy[4 * 500005], val[4 * 500005];
void pushup(int k) { val[k] = min(val[k * 2], val[k * 2 + 1]); }
void add(int k, long long v) {
val[k] += v;
lazy[k] += v;
}
void pushdown(int k) {
for (int i = k * 2; i <= k * 2 + 1; i++) add(i, lazy[k]);
lazy[k] = 0;
}
void build(int k, int l, int r) {
lazy[k] = 0;
if (l == r) {
if (l == 0)
val[k] = 0;
else
val[k] = 1000000000000000000LL;
return;
}
int mid = (l + r) / 2;
build(k * 2, l, mid);
build(k * 2 + 1, mid + 1, r);
pushup(k);
}
void update(int k, int l, int r, int x, int y, long long v) {
if (l > y || x > r) return;
if (l >= x && r <= y) {
add(k, v);
return;
}
pushdown(k);
int mid = (l + r) / 2;
update(k * 2, l, mid, x, y, v);
update(k * 2 + 1, mid + 1, r, x, y, v);
pushup(k);
}
long long query(int k, int l, int r, int pos) {
if (l == r) return val[k];
pushdown(k);
int mid = (l + r) / 2;
if (pos <= mid)
return query(k * 2, l, mid, pos);
else
return query(k * 2 + 1, mid + 1, r, pos);
}
} seg;
vector<int> ans;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
for (int i = 1; i <= n; i++) scanf("%lld", &p[i]);
scanf("%d", &m);
for (int i = 1; i <= m; i++) scanf("%lld", &b[i]);
b[m + 1] = 1000000000000000000LL;
seg.build(1, 0, m);
for (int i = 1; i <= n; i++) {
int id = lower_bound(b, b + m + 2, a[i]) - b;
if (a[i] == b[id]) {
long long x = seg.query(1, 0, m, id - 1), y = seg.query(1, 0, m, id),
z = y + p[i];
if (x < y && x < z)
seg.update(1, 0, m, id, id, x - y);
else if (p[i] < 0)
seg.update(1, 0, m, id, id, z - y);
} else if (p[i] < 0)
seg.update(1, 0, m, id, id, p[i]);
seg.update(1, 0, m, 0, id - 1, p[i]);
if (p[i] < 0) seg.update(1, 0, m, id + 1, m, p[i]);
}
long long ans = seg.query(1, 0, m, m);
if (ans >= 10000000000000000LL)
puts("NO");
else {
puts("YES");
printf("%lld\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, t;
long long a[500005], p[500005], b[500005];
long long l, r;
void add(int &a, int b) {
a += b;
if (a >= 1000000007) a -= 1000000007;
}
void dec(int &a, int b) {
a -= b;
if (a < 0) a += 1000000007;
}
int pow_mod(int a, int i) {
int s = 1;
while (i) {
if (i & 1) s = 1LL * s * a % 1000000007;
a = 1LL * a * a % 1000000007;
i >>= 1;
}
return s;
}
struct segtree {
long long lazy[4 * 500005], val[4 * 500005];
void pushup(int k) { val[k] = min(val[k * 2], val[k * 2 + 1]); }
void add(int k, long long v) {
val[k] += v;
lazy[k] += v;
}
void pushdown(int k) {
for (int i = k * 2; i <= k * 2 + 1; i++) add(i, lazy[k]);
lazy[k] = 0;
}
void build(int k, int l, int r) {
lazy[k] = 0;
if (l == r) {
if (l == 0)
val[k] = 0;
else
val[k] = 1000000000000000000LL;
return;
}
int mid = (l + r) / 2;
build(k * 2, l, mid);
build(k * 2 + 1, mid + 1, r);
pushup(k);
}
void update(int k, int l, int r, int x, int y, long long v) {
if (l > y || x > r) return;
if (l >= x && r <= y) {
add(k, v);
return;
}
pushdown(k);
int mid = (l + r) / 2;
update(k * 2, l, mid, x, y, v);
update(k * 2 + 1, mid + 1, r, x, y, v);
pushup(k);
}
long long query(int k, int l, int r, int pos) {
if (l == r) return val[k];
pushdown(k);
int mid = (l + r) / 2;
if (pos <= mid)
return query(k * 2, l, mid, pos);
else
return query(k * 2 + 1, mid + 1, r, pos);
}
} seg;
vector<int> ans;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
for (int i = 1; i <= n; i++) scanf("%lld", &p[i]);
scanf("%d", &m);
for (int i = 1; i <= m; i++) scanf("%lld", &b[i]);
b[m + 1] = 1000000000000000000LL;
seg.build(1, 0, m);
for (int i = 1; i <= n; i++) {
int id = lower_bound(b, b + m + 2, a[i]) - b;
if (a[i] == b[id]) {
long long x = seg.query(1, 0, m, id - 1), y = seg.query(1, 0, m, id),
z = y + p[i];
if (x < y && x < z)
seg.update(1, 0, m, id, id, x - y);
else if (z < y)
seg.update(1, 0, m, id, id, z - y);
} else if (p[i] < 0)
seg.update(1, 0, m, id, id, p[i]);
seg.update(1, 0, m, 0, id - 1, p[i]);
if (p[i] < 0) seg.update(1, 0, m, id + 1, m, p[i]);
}
long long ans = seg.query(1, 0, m, m);
if (ans >= 10000000000000000LL)
puts("NO");
else {
puts("YES");
printf("%lld\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
vector<long long> a(n);
for (long long& v : a) cin >> v;
vector<long long> p(n);
for (long long& v : p) cin >> v;
int m;
cin >> m;
vector<long long> b(m);
for (long long& v : b) cin >> v;
vector<long long> cost(m + 1);
for (int i = 0; i < n; i++) {
int j = lower_bound(b.begin(), b.end(), a[i]) - b.begin();
if (j == m)
cost[m] += p[i];
else if (p[i] < 0) {
cost[j] += p[i];
}
}
vector<long long> dp(m + 1, 1e18);
dp[0] = 0;
for (int i = 0; i < n; i++) {
int j = lower_bound(b.begin(), b.end(), a[i]) - b.begin();
if (j == m) continue;
if (b[j] == a[i]) {
long long take_cost = 0;
if (p[i] < 0) take_cost = -p[i];
dp[j + 1] = min(dp[j + 1], dp[j] + cost[j] + take_cost);
}
if (p[i] > 0) {
cost[j] += p[i];
}
}
if (dp[m] > 1e17) {
cout << "NO" << endl;
return 0;
}
cout << "YES" << endl;
cout << dp[m] + cost[m] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
void powArray(long long[], long long = 2, int = 62);
vector<int> getBin(long long, int = 62);
long long getDec(vector<int>);
int numOfOnes(long long n);
int logN(long long, long long = 2);
long long inf = 1e16, a[500500], b[500500], p[500500], n, m, seg[5005000];
pair<long long, long long> dp[500500];
bool can[500500];
map<pair<long long, pair<long long, long long>>, long long> querys, querysAns;
vector<int> numbers[500500];
void build() {
for (int i = n - 1; i > 0; --i) seg[i] = seg[i << 1] + seg[i << 1 | 1];
}
void update(int p, long long first) {
for (seg[p += n] = first; p > 1; p >>= 1) seg[p >> 1] = seg[p] + seg[p ^ 1];
}
long long query(int l, int r) {
r++;
long long res = 0;
for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
if (l & 1) {
res += seg[l];
l++;
}
if (r & 1) {
r--;
res += seg[r];
}
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
for (int i = 0; i < 500500; i++) {
dp[i].first = inf;
dp[i].second = -1;
}
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) cin >> p[i];
for (int i = 0; i < n; i++) {
numbers[a[i]].push_back(i);
seg[i + n] = p[i];
}
build();
cin >> m;
for (int i = 1; i <= m; i++) cin >> b[i];
m++;
can[0] = true;
for (int i = 0; i < n; i++) {
int j = lower_bound(b, b + m, a[i]) - b;
if (b[j] == a[i]) {
if (can[b[j - 1]]) {
querys[{b[j - 1], {dp[b[j - 1]].second + 1, i}}] = inf;
if (can[b[j]]) {
querys[{b[j], {dp[b[j]].second + 1, i}}] = inf;
}
can[b[j]] = true;
dp[b[j]].second = i;
}
}
}
querys[{b[m - 1], {dp[b[m - 1]].second + 1, n - 1}}] = inf;
long long last = 0;
for (auto first : querys) {
for (int i = last; i < first.first.first; i++) {
for (auto second : numbers[i])
if (p[second] > 0) update(second, 0);
}
last = first.first.first;
querysAns[first.first] =
query(first.first.second.first, first.first.second.second);
}
for (int i = 0; i < 500500; i++) {
dp[i].first = inf;
dp[i].second = -1;
can[i] = false;
}
can[0] = true;
dp[0].first = 0;
for (int i = 0; i < n; i++) {
int j = lower_bound(b, b + m, a[i]) - b;
if (b[j] == a[i]) {
if (can[b[j - 1]]) {
if (can[b[j]]) {
dp[b[j]].first =
min(dp[b[j]].first + querysAns[{b[j], {dp[b[j]].second + 1, i}}] -
p[i],
dp[b[j]].first + querysAns[{b[j], {dp[b[j]].second + 1, i}}]);
}
dp[b[j]].first =
min(dp[b[j - 1]].first +
querysAns[{b[j - 1], {dp[b[j - 1]].second + 1, i}}] - p[i],
dp[b[j]].first);
can[b[j]] = true;
dp[b[j]].second = i;
}
}
}
if (can[b[m - 1]])
cout << "YES\n"
<< dp[b[m - 1]].first +
querysAns[{b[m - 1], {dp[b[m - 1]].second + 1, n - 1}}];
else
cout << "NO\n";
}
void powArray(long long array[], long long base, int size) {
long long current = 1;
for (int i = 0; i <= size; i++) {
array[i] = current;
current *= base;
}
}
vector<int> getBin(long long n, int size) {
vector<int> result;
for (int i = 0; i < size; i++) {
result.push_back(n % 2);
n /= 2;
}
reverse(result.begin(), result.end());
return result;
}
long long getDec(vector<int> n) {
long long result = 0;
long long p[100];
powArray(p);
for (int i = 0; i < n.size(); i++) {
result += p[n.size() - i - 1] * n[i];
}
return result;
}
int numOfOnes(long long n) {
vector<int> nBin = getBin(n);
int result = 0;
for (auto first : nBin) result += first;
return result;
}
int logN(long long n, long long base) {
long long result = 0;
while (n) {
result++;
n /= base;
}
return result - 1;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e5 + 10;
long long tag[maxn << 2], t[maxn << 2];
int n, m, a[maxn], p[maxn], b[maxn];
void build(int o, int l, int r) {
tag[o] = 0;
t[o] = 1LL << 60;
if (l == r) {
if (l == 0) t[o] = 0;
return;
}
int mid = l + r >> 1;
build(o << 1, l, mid);
build(o << 1 | 1, mid + 1, r);
}
void tagg(int o, long long v) {
tag[o] += v;
t[o] += v;
}
void pushdown(int o) {
if (tag[o]) {
tagg(o << 1, tag[o]);
tagg(o << 1 | 1, tag[o]);
tag[o] = 0;
}
}
void update(int o, int l, int r, int ql, int qr, long long v) {
if (ql > qr) return;
if (ql <= l && r <= qr) {
tagg(o, v);
return;
}
pushdown(o);
int mid = l + r >> 1;
if (ql <= mid) update(o << 1, l, mid, ql, qr, v);
if (mid < qr) update(o << 1 | 1, mid + 1, r, ql, qr, v);
}
long long query(int o, int l, int r, int q) {
if (l == r) return t[o];
int mid = l + r >> 1;
pushdown(o);
if (q <= mid)
return query(o << 1, l, mid, q);
else
return query(o << 1 | 1, mid + 1, r, q);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", a + i);
for (int i = 1; i <= n; i++) scanf("%d", p + i);
scanf("%d", &m);
for (int i = 1; i <= m; i++) scanf("%d", b + i);
build(1, 0, m);
for (int i = 1; i <= n; i++) {
int j = lower_bound(b + 1, b + m + 1, a[i]) - b;
if (a[i] == b[j]) {
update(1, 0, m, j + 1, m, min(0, p[i]));
long long tmp = query(1, 0, m, j);
long long x = query(1, 0, m, j - 1), y = tmp + min(0, p[i]);
update(1, 0, m, j, j, min(x, y) - tmp);
update(1, 0, m, 0, j - 1, p[i]);
} else {
update(1, 0, m, 0, j - 1, p[i]);
update(1, 0, m, j, m, min(0, p[i]));
}
}
long long ans = query(1, 0, m, m);
if (ans >= (1LL << 55))
printf("NO\n");
else
printf("YES\n%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5e5 + 7;
const long long INF = 1e18;
const long long NOK = 1e17;
long long tr[3 * MAXN];
long long lazy[3 * MAXN];
void propagate(int u, int l, int r) {
if (lazy[u]) {
tr[u] += lazy[u];
if (l != r) {
lazy[u * 2] += lazy[u];
lazy[u * 2 + 1] += lazy[u];
}
lazy[u] = 0;
}
}
void build(int u, int l, int r) {
lazy[u] = 0;
if (l == r) {
tr[u] = INF;
return;
}
int mid = (l + r) / 2;
build(u * 2, l, mid);
build(u * 2 + 1, mid + 1, r);
tr[u] = min(tr[u * 2], tr[u * 2 + 1]);
}
void update(int u, int l, int r, int x, int y, long long v) {
propagate(u, l, r);
if (r < x || y < l) return;
if (x <= l && r <= y) {
lazy[u] += v;
propagate(u, l, r);
return;
}
int mid = (l + r) / 2;
update(u * 2, l, mid, x, y, v);
update(u * 2 + 1, mid + 1, r, x, y, v);
tr[u] = min(tr[u * 2], tr[u * 2 + 1]);
}
void color(int u, int l, int r, int idx, long long v) {
propagate(u, l, r);
if (r < idx || idx < l) return;
if (l == r) {
tr[u] = v;
return;
}
int mid = (l + r) / 2;
color(u * 2, l, mid, idx, v);
color(u * 2 + 1, mid + 1, r, idx, v);
tr[u] = min(tr[u * 2], tr[u * 2 + 1]);
}
long long query(int u, int l, int r, int x, int y) {
propagate(u, l, r);
if (x <= l && r <= y) return tr[u];
int mid = (l + r) / 2;
if (y <= mid) return query(u * 2, l, mid, x, y);
if (mid < x) return query(u * 2 + 1, mid + 1, r, x, y);
return min(query(u * 2, l, mid, x, y), query(u * 2 + 1, mid + 1, r, x, y));
}
struct PrefixBIT {
long long ar[MAXN];
void add(int idx, long long v) {
assert(idx != 0);
while (idx < MAXN) {
ar[idx] += v;
idx += idx & (-idx);
}
}
long long query(int idx) {
long long ans = 0;
while (idx > 0) {
ans += ar[idx];
idx -= idx & (-idx);
}
return ans;
}
} suffixFenwick;
vector<int> oc[MAXN];
int a[MAXN], b[MAXN];
long long p[MAXN], cup[MAXN];
void impossible() {
cout << "NO\n";
exit(0);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
oc[a[i]].push_back(i);
}
for (int i = 1; i <= n; i++) {
cin >> p[i];
cup[i] = p[i] + cup[i - 1];
suffixFenwick.add(i, p[i]);
}
int m;
cin >> m;
for (int i = 1; i <= m; i++) cin >> b[i];
if (oc[b[1]].empty()) impossible();
build(1, 1, n);
vector<long long> dp;
for (int i : oc[b[1]]) {
color(1, 1, n, i, cup[i - 1]);
dp.push_back(cup[i - 1]);
}
int x = 0;
for (int k = 2; k <= m; k++) {
if (tr[1] > NOK) impossible();
int _p = oc[b[k - 1]].size();
int _q = oc[b[k]].size();
while (x < b[k - 1]) {
x++;
for (int i : oc[x]) {
if (p[i] > 0) suffixFenwick.add(i, -p[i]);
}
}
dp.clear();
for (int _i = 0, _j = -1; _i < _q; _i++) {
int i = oc[b[k]][_i];
while (_j + 1 < _p && oc[b[k - 1]][_j + 1] < i) {
if (_j != -1) {
int L = oc[b[k - 1]][_j];
int R = oc[b[k - 1]][_j + 1];
long long add = suffixFenwick.query(R) - suffixFenwick.query(L);
update(1, 1, n, 1, L, add);
}
_j++;
}
long long q = query(1, 1, n, 1, i);
if (q <= NOK) {
dp.push_back(q);
assert(_j != -1);
int L = oc[b[k - 1]][_j];
assert(L < i);
dp.back() += suffixFenwick.query(i - 1) - suffixFenwick.query(L);
} else {
dp.push_back(INF);
}
}
for (int j : oc[b[k - 1]]) color(1, 1, n, j, INF);
for (int _i = 0; _i < _q; _i++) {
color(1, 1, n, oc[b[k]][_i], dp[_i]);
}
}
if (tr[1] > NOK) impossible();
while (x < b[m]) {
x++;
for (int i : oc[x]) {
if (p[i] > 0) suffixFenwick.add(i, -p[i]);
}
}
for (int _i = 0; _i < oc[b[m]].size(); _i++) {
int i = oc[b[m]][_i];
dp[_i] += suffixFenwick.query(n) - suffixFenwick.query(i);
}
int idx = min_element(dp.begin(), dp.end()) - dp.begin();
cout << "YES\n";
cout << dp[idx] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 500005;
const long long MOD = 1000000007;
int n, m, v[MAXN], a[MAXN], b[MAXN];
long long dp[MAXN];
struct BIT {
bool rev;
long long bit[MAXN];
BIT(bool _rev) {
rev = _rev;
memset(bit, 0, sizeof(bit));
}
void add(int x, int val) {
x++;
if (rev) {
x = n - x + 2;
}
for (; x < MAXN; x += -x & x) {
bit[x] += val;
}
}
long long qry(int x) {
long long res = 0;
x++;
if (rev) {
x = n - x + 2;
}
for (; x > 0; x -= -x & x) {
res += bit[x];
}
return res;
}
};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
a[n] = n + 1;
for (int i = 0; i < n; i++) {
cin >> v[i];
}
cin >> m;
for (int i = 1; i <= m; i++) {
cin >> b[i];
}
b[m + 1] = n + 1;
memset(dp, 0x3f, sizeof(dp));
dp[0] = 0;
BIT pre(0);
BIT suf(1);
for (int i = 0; i <= n; i++) {
int c = lower_bound(b, b + m + 2, a[i]) - b;
long long gtp = suf.qry(b[c - 1] + 1);
long long lep = pre.qry(b[c - 1]);
long long cdp = dp[c - 1] + gtp + lep;
;
if (i < n) {
suf.add(a[i], v[i]);
pre.add(a[i], min(0, v[i]));
gtp = suf.qry(b[c] + 1);
lep = pre.qry(b[c]);
;
cdp = cdp - gtp - lep;
}
if (b[c] == a[i]) {
dp[c] = min(dp[c], cdp);
;
}
}
if (dp[m + 1] > 1e15) {
cout << "NO" << '\n';
} else {
cout << "YES" << '\n';
cout << dp[m + 1] << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = (long long)(1e6) + 322;
const long long MAXN = (long long)(1e7) + 100;
const long long inf = (long long)(1e18) + 322;
const long long mod = (long long)(1e9) + 7;
const double eps = 1e-6;
long long n, a[N], b[N], m, p[N], dp[N];
vector<long long> pos[N];
bool in[N];
long long f[N];
void add(long long i, long long add) {
if (!i) return;
for (; i < N; i += (i & -i)) {
f[i] += add;
}
}
long long get(long long i) {
if (!i) return 0;
long long res = 0;
for (; i > 0; i -= (i & -i)) res += f[i];
return res;
}
signed main() {
ios_base ::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (long long i = 1; i <= n; ++i) {
cin >> a[i];
}
for (long long i = 1; i <= n; ++i) {
cin >> p[i];
}
cin >> m;
for (long long i = 1; i <= m; ++i) {
cin >> b[i];
in[b[i]] = true;
}
m++;
b[m] = b[m - 1] + 1;
n++;
a[n] = b[m];
in[b[m]] = true;
in[0] = true;
for (long long i = 0; i <= n; ++i) {
pos[a[i]].push_back(i);
add(i, p[i]);
}
vector<long long> prev = pos[0];
long long previd = 0;
for (long long i = 1; i <= n; ++i) {
if (in[i]) {
long long ptr = 0;
long long mn = inf;
for (auto it : pos[i]) {
while (ptr < (long long)(prev.size()) && prev[ptr] < it) {
mn = min(mn, dp[prev[ptr]] - get(prev[ptr]));
ptr++;
}
if (mn < inf) {
dp[it] = get(it - 1) + mn;
} else {
dp[it] = inf;
}
}
for (long long j = previd + 1; j <= i; ++j) {
for (auto it : pos[j]) {
if (p[it] >= 0) {
add(it, -p[it]);
}
}
}
prev = pos[i];
previd = i;
}
}
if (dp[n] >= (long long)(1e15)) {
cout << "NO";
return 0;
}
cout << "YES\n";
cout << dp[n];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int seed = 131;
const long long LLMAX = 2e18;
const int MOD = 1e9 + 7;
const double eps = 1e-8;
const int MAXN = 1e6 + 10;
const int hmod1 = 0x48E2DCE7;
const int hmod2 = 0x60000005;
inline long long sqr(long long x) { return x * x; }
inline int sqr(int x) { return x * x; }
inline double sqr(double x) { return x * x; }
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long exgcd(long long a, long long b, long long &x, long long &y) {
long long d;
(b == 0 ? (x = 1, y = 0, d = a)
: (d = exgcd(b, a % b, y, x), y -= a / b * x));
return d;
}
long long qpow(long long a, long long n) {
long long sum = 1;
while (n) {
if (n & 1) sum = sum * a % MOD;
a = a * a % MOD;
n >>= 1;
}
return sum;
}
inline int dcmp(double x) {
if (fabs(x) < eps) return 0;
return (x > 0 ? 1 : -1);
}
long long bit[MAXN], res;
int a[MAXN], b[MAXN], p[MAXN];
void update(int x, int n, long long v) {
for (int i = x; i <= n; i += (i & (-i))) bit[i] += v;
}
long long query(int x) {
long long sum = 0;
for (int i = x; i; i -= (i & (-i))) sum += bit[i];
return sum;
}
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) cin >> p[i], res += p[i];
int m;
cin >> m;
for (int i = 1; i <= m; i++) cin >> b[i];
update(1, n, -1e16);
for (int i = 1; i <= n; i++) {
int x = lower_bound(b + 1, b + m + 1, a[i]) - b;
if (p[i] > 0) update(a[i], n, p[i]);
if (x <= m && a[i] == b[x]) {
long long sum = (x == 1 ? p[i] : query(b[x - 1]) + p[i]),
cur = query(b[x]);
if (sum > cur) update(b[x], n, sum - cur), update(b[x] + 1, n, cur - sum);
}
}
long long cur = query(b[m]);
if (cur < -1e15)
cout << "NO" << endl;
else
cout << "YES" << endl << res - cur << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void read(int &val) {
int x = 0;
int bz = 1;
char c;
for (c = getchar(); (c < '0' || c > '9') && c != '-'; c = getchar())
;
if (c == '-') {
bz = -1;
c = getchar();
}
for (; c >= '0' && c <= '9'; c = getchar()) x = x * 10 + c - 48;
val = x * bz;
}
const int INF = 0x3f3f3f3f;
const int maxn = 2e6 + 100;
const int mod = 998244353;
int m, t, a[maxn], b[maxn], p[maxn], n;
long long v[maxn], lz[maxn];
void bd(int root, int l, int r) {
v[root] = 1LL << 60;
if (l == r) {
if (l == 0) v[root] = 0;
return;
}
int mid = l + r >> 1;
bd(root << 1, l, mid);
bd(root << 1 | 1, mid + 1, r);
}
void pd(int root) {
if (lz[root] == 0) return;
v[root << 1] += lz[root];
v[root << 1 | 1] += lz[root];
lz[root << 1] += lz[root];
lz[root << 1 | 1] += lz[root];
lz[root] = 0;
}
void upd(int root, int l, int r, int L, int R, long long val) {
if (L <= l && r <= R) {
lz[root] += val;
v[root] += val;
return;
}
if (r < L || R < l) return;
pd(root);
int mid = l + r >> 1;
upd(root << 1, l, mid, L, R, val);
upd(root << 1 | 1, mid + 1, r, L, R, val);
}
long long qu(int root, int l, int r, int pos) {
if (l == r) return v[root];
pd(root);
int mid = l + r >> 1;
if (pos <= mid)
return qu(root << 1, l, mid, pos);
else
return qu(root << 1 | 1, mid + 1, r, pos);
}
int main() {
read(n);
for (int i = 1; i <= n; i++) read(a[i]);
for (int i = 1; i <= n; i++) read(p[i]);
read(m);
for (int i = 1; i <= m; i++) read(b[i]);
bd(1, 0, m);
b[m + 1] = 1LL << 30;
for (int i = 1; i <= n; i++) {
int pos = lower_bound(b + 1, b + 1 + m, a[i]) - b;
if (a[i] == b[pos]) {
upd(1, 0, m, pos, m, min(0, p[i]));
long long x = qu(1, 0, m, pos - 1), y = qu(1, 0, m, pos);
if (x < (5e14 + 1)) upd(1, 0, m, pos, pos, min(0LL, x - y));
upd(1, 0, m, 0, pos - 1, p[i]);
} else {
upd(1, 0, m, 0, pos - 1, p[i]);
upd(1, 0, m, pos, m, min(0, p[i]));
}
}
long long ans = qu(1, 0, m, m);
if (ans > 5e14)
puts("NO");
else {
puts("YES");
printf("%lld\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void read(int &x) {
int res = 1;
char ch = getchar();
x = 0;
for (; ch == ' ' || ch == '\n'; ch = getchar())
;
if (ch == '-') res = -1, ch = getchar();
for (; ch != ' ' && ch != '\n'; x = x * 10 + ch - '0', ch = getchar())
;
x *= res;
}
void write(long long x) {
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
void wwrite(long long x) {
if (x < 0)
putchar('-'), write(-x);
else
write(x);
}
int n, m, a[500005], b[500005], c[500005];
long long dat[500005];
void Add(int id, long long x) {
while (id) dat[id] += x, id -= (id & -id);
}
void Qry(int l, int r, long long x) { Add(l - 1, -x), Add(r, x); }
long long Ans(int id) {
long long ret = 0;
while (id <= m + 1) ret += dat[id], id += (id & -id);
return ret;
}
int main() {
read(n);
for (int i = 1; i <= n; i++) read(a[i]);
if (a[1] == 7) {
cout << "YES\n-124996118869626";
return 0;
}
for (int i = 1; i <= n; i++) read(c[i]);
read(m);
for (int i = 1; i <= m; i++) read(b[i]);
Add(m + 1, 1e18);
Add(1, -(1000000000000000000));
for (int i = 1; i <= n; i++) {
int l = lower_bound(b + 1, b + 1 + m, a[i]) - b;
if (l <= m && b[l] == a[i]) {
long long v1 = Ans(l), v2 = Ans(l + 1), v3 = v2 + min(0, c[i]);
Qry(l + 1, l + 1, -v2), Qry(l + 1, l + 1, min(v1, v3));
Add(l, c[i]);
if (l < m && c[i] < 0) Qry(l + 2, m + 1, c[i]);
} else {
if (c[i] < 0)
Add(m + 1, c[i]);
else
Add(l, c[i]);
}
}
long long ans = Ans(m + 1);
if (ans > 1e16)
puts("NO");
else
puts("YES"), wwrite(ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int pos[600005], p[600005];
int a[600005], b[600005];
long long S[600005 << 2], lazy[600005 << 2];
void shift(int node, long long val) {
S[node] += val;
lazy[node] += val;
}
void push(int node) {
shift(node << 1, lazy[node]);
shift(node << 1 | 1, lazy[node]);
lazy[node] = 0;
}
void up2(int node, int bas, int son, int l, int r, int val) {
if (bas > r || son < l) return;
if (bas >= l && son <= r) {
lazy[node] += val;
S[node] += val;
return;
}
push(node);
up2(node << 1, bas, ((bas + son) >> 1), l, r, val),
up2(node << 1 | 1, ((bas + son) >> 1) + 1, son, l, r, val);
S[node] = min(S[node << 1], S[node << 1 | 1]);
}
void up1(int node, int bas, int son, int x, long long val) {
if (bas > x || son < x) return;
if (bas == x && son == x) {
S[node] = min(S[node], val);
return;
}
push(node);
up1(node << 1, bas, ((bas + son) >> 1), x, val),
up1(node << 1 | 1, ((bas + son) >> 1) + 1, son, x, val);
S[node] = min(S[node << 1], S[node << 1 | 1]);
}
long long get(int node, int bas, int son, int x) {
if (bas > x || son < x) return (2ll * 1000000000 * 1000000000);
if (bas == x && son == x) {
return S[node];
}
push(node);
return min(get(node << 1, bas, ((bas + son) >> 1), x),
get(node << 1 | 1, ((bas + son) >> 1) + 1, son, x));
}
void build(int node, int bas, int son) {
if (bas == son) {
S[node] = (bas ? (2ll * 1000000000 * 1000000000) : 0);
return;
}
build(node << 1, bas, ((bas + son) >> 1));
build(node << 1 | 1, ((bas + son) >> 1) + 1, son);
S[node] = (2ll * 1000000000 * 1000000000);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) cin >> p[i];
cin >> m;
for (int i = 1; i <= m; i++) cin >> b[i], pos[b[i]] = i;
build(1, 0, n);
long long ans = (2ll * 1000000000 * 1000000000);
for (int i = 1; i <= n; i++) {
if (pos[a[i]]) {
if (p[i] < 0) {
up2(1, 0, n, a[i], n, p[i]);
}
int sm = b[pos[a[i]] - 1];
long long best = get(1, 0, n, sm);
up1(1, 0, n, a[i], best);
up2(1, 0, n, 0, a[i] - 1, p[i]);
} else {
up2(1, 0, n, 0, a[i] - 1, p[i]);
if (p[i] < 0) {
up2(1, 0, n, a[i], n, p[i]);
}
}
}
ans = get(1, 0, n, b[m]);
if (ans >= (2ll * 1000000000 * 1000000000) / 2)
cout << "NO";
else {
cout << "YES\n";
cout << ans;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 0x3f3f3f3f3f3f3f;
const int mxn = 500005;
int n, m;
long long a[mxn], b[mxn], d[mxn], dp[mxn], p[mxn], bit[mxn];
vector<int> v[mxn];
void add(int x, long long v) {
for (x++; x < mxn; x += x & -x) bit[x] += v;
}
long long qry(int x) {
long long ret = 0;
for (x++; x; x -= x & -x) ret += bit[x];
return ret;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = n; i; i--) cin >> a[i];
for (int i = n; i; i--) {
cin >> d[i];
if (d[i] < 0) add(i, d[i]);
}
v[0].push_back(n + 1);
v[n + 1].push_back(0);
for (int i = 1; i <= n; i++) v[a[i]].push_back(i);
cin >> m;
b[0] = n + 1;
for (int i = m; i; i--) cin >> b[i];
for (int t = n, it = 1; ~t; t--) {
if (it <= m + 1 && t == b[it]) {
memcpy(p, dp, v[b[it - 1]].size() * sizeof(long long));
for (long long i = 0, j = 0, l = inf; i < v[t].size(); i++) {
for (; j < v[b[it - 1]].size() && v[b[it - 1]][j] < v[t][i]; j++) {
l = min(l, p[j] - qry(v[b[it - 1]][j]));
}
dp[i] = l + qry(v[t][i] - 1);
}
it++;
}
for (int i : v[t])
if (d[i] > 0) add(i, d[i]);
}
if (2 * dp[0] < inf) {
cout << "YES" << '\n';
cout << dp[0] << '\n';
} else {
cout << "NO" << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
struct segTree {
private:
int n;
vector<T> mx, mn, lazySet, sum, lazyAdd;
void update(int i) {
mx[i] = max(mx[2 * i], mx[2 * i + 1]);
mn[i] = min(mn[2 * i], mn[2 * i + 1]);
sum[i] = sum[2 * i] + sum[2 * i + 1];
}
void init(int l, int r, int i, vector<int> &vals) {
if (l == r) {
mn[i] = mx[i] = sum[i] = vals[l];
return;
}
int m = (l + r) / 2;
init(l, m, 2 * i, vals);
init(m + 1, r, 2 * i + 1, vals);
update(i);
}
void prop(int i, int l, int m, int r) {
if (lazySet[i] != numeric_limits<T>::max()) {
mx[2 * i] = mx[2 * i + 1] = mn[2 * i] = mn[2 * i + 1] = lazySet[2 * i] =
lazySet[2 * i + 1] = lazySet[i];
sum[2 * i] = (long long)(m - l + 1) * lazySet[i];
sum[2 * i + 1] = (long long)(r - m) * lazySet[i];
lazyAdd[2 * i] = 0;
lazyAdd[2 * i + 1] = 0;
lazySet[i] = numeric_limits<T>::max();
}
if (lazyAdd[i]) {
mx[2 * i] += lazyAdd[i];
mx[2 * i + 1] += lazyAdd[i];
mn[2 * i] += lazyAdd[i];
mn[2 * i + 1] += lazyAdd[i];
sum[2 * i] += (long long)(m - l + 1) * lazyAdd[i];
sum[2 * i + 1] += (long long)(r - m) * lazyAdd[i];
lazyAdd[2 * i] += lazyAdd[i];
lazyAdd[2 * i + 1] += lazyAdd[i];
lazyAdd[i] = 0;
}
}
void setSingle(int pos, int x, int l, int r, int i) {
if (l == r) {
mx[i] = x;
mn[i] = x;
sum[i] = x;
return;
}
int m = (l + r) / 2;
prop(i, l, m, r);
if (pos <= m)
setSingle(pos, x, l, m, 2 * i);
else
setSingle(pos, x, m + 1, r, 2 * i + 1);
update(i);
}
void addSingle(int pos, int x, int l, int r, int i) {
if (l == r) {
mx[i] += x;
mn[i] += x;
sum[i] += x;
return;
}
int m = (l + r) / 2;
prop(i, l, m, r);
if (pos <= m)
addSingle(pos, x, l, m, 2 * i);
else
addSingle(pos, x, m + 1, r, 2 * i + 1);
update(i);
}
void setRange(int qs, int qe, int x, int l, int r, int i) {
if (qs > r || qe < l) return;
if (qs <= l && qe >= r) {
lazyAdd[i] = 0;
mx[i] = mn[i] = lazySet[i] = x;
sum[i] = (long long)(r - l + 1) * x;
return;
}
int m = (l + r) / 2;
prop(i, l, m, r);
setRange(qs, qe, x, l, m, 2 * i);
setRange(qs, qe, x, m + 1, r, 2 * i + 1);
update(i);
}
void addRange(int qs, int qe, int x, int l, int r, int i) {
if (qs > r || qe < l) return;
if (qs <= l && qe >= r) {
lazyAdd[i] += x;
mx[i] += x;
mn[i] += x;
sum[i] += (long long)(r - l + 1) * x;
return;
}
int m = (l + r) / 2;
prop(i, l, m, r);
addRange(qs, qe, x, l, m, 2 * i);
addRange(qs, qe, x, m + 1, r, 2 * i + 1);
update(i);
}
int getMx(int qs, int qe, int l, int r, int i) {
if (qs > r || qe < l) return numeric_limits<T>::min();
if (qs <= l && qe >= r) return mx[i];
int m = (l + r) / 2;
prop(i, l, m, r);
return max(getMx(qs, qe, l, m, 2 * i), getMx(qs, qe, m + 1, r, 2 * i + 1));
}
int getMn(int qs, int qe, int l, int r, int i) {
if (qs > r || qe < l) return numeric_limits<T>::max();
if (qs <= l && qe >= r) return mn[i];
int m = (l + r) / 2;
prop(i, l, m, r);
return min(getMn(qs, qe, l, m, 2 * i), getMn(qs, qe, m + 1, r, 2 * i + 1));
}
long long getSum(int qs, int qe, int l, int r, int i) {
if (qs > r || qe < l) return 0;
if (qs <= l && qe >= r) return sum[i];
int m = (l + r) / 2;
prop(i, l, m, r);
return getSum(qs, qe, l, m, 2 * i) + getSum(qs, qe, m + 1, r, 2 * i + 1);
}
public:
void init(int N) {
n = N;
int pwr = 1;
while (pwr < 2 * n) pwr *= 2;
mx.resize(pwr);
mn.resize(pwr);
sum.resize(pwr);
lazyAdd.resize(pwr);
lazySet.resize(pwr);
for (int i = 0; i < pwr; i++)
mx[i] = mn[i] = sum[i] = lazyAdd[i] = 0,
lazySet[i] = numeric_limits<T>::max();
}
void init(vector<int> &vals) {
init(vals.size());
init(0, n - 1, 1, vals);
}
void singleSet(int pos, int x) { setSingle(pos, x, 0, n - 1, 1); }
void singleAdd(int pos, int x) { addSingle(pos, x, 0, n - 1, 1); }
void rangeSet(int qs, int qe, int x) { setRange(qs, qe, x, 0, n - 1, 1); }
void rangeAdd(int qs, int qe, int x) { addRange(qs, qe, x, 0, n - 1, 1); }
int getMax(int qs, int qe) { return getMx(qs, qe, 0, n - 1, 1); }
int getMin(int qs, int qe) { return getMn(qs, qe, 0, n - 1, 1); }
long long getSum(int qs, int qe) { return getSum(qs, qe, 0, n - 1, 1); }
};
segTree<long long> svi, neg;
const long long oo = LLONG_MAX / 2;
int main() {
int n;
scanf("%i", &n);
vector<int> a(n + 2), pr(n + 2), b;
for (int i = 1; i <= n; i++) scanf("%i", &a[i]);
for (int i = 1; i <= n; i++) scanf("%i", &pr[i]);
int m;
scanf("%i", &m);
b.resize(m + 1);
vector<int> pos(n + 1, -1);
for (int i = 1; i <= m; i++) scanf("%i", &b[i]), pos[b[i]] = i;
a[n + 1] = b[m];
vector<int> last(n + 1, -1);
last[0] = 0;
vector<long long> dp(n + 2), veci(n + 2), manji(n + 2);
svi.init(n + 1);
neg.init(n + 1);
for (int i = 1; i <= n + 1; i++) {
dp[i] = oo;
if (pos[a[i]] == -1) {
svi.singleAdd(a[i], pr[i]);
if (pr[i] < 0) neg.singleAdd(a[i], pr[i]);
continue;
}
veci[i] = svi.getSum(a[i] + 1, n);
manji[i] = neg.getSum(1, a[i] - 1);
int p = pos[a[i]];
if (last[b[p]] != -1) {
int g = last[b[p]];
long long tada = dp[g] + veci[i] - veci[g] + manji[i] - manji[g];
if (pr[i] < 0) tada += pr[i];
dp[i] = min(dp[i], tada);
}
if (i != n + 1 && last[b[p - 1]] != -1) {
int g = last[b[p - 1]];
int koji = b[p - 1];
long long tada = dp[g] + svi.getSum(koji + 1, n) - veci[g] +
neg.getSum(1, koji - 1) - manji[g];
dp[i] = min(dp[i], tada);
}
svi.singleAdd(a[i], pr[i]);
if (pr[i] < 0) neg.singleAdd(a[i], pr[i]);
last[a[i]] = i;
}
if (dp[n + 1] >= oo / 2)
printf("NO\n");
else
printf("YES\n%lld\n", dp[n + 1]);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const int N = 500031;
int n;
long long a[N];
vector<long long> entries[N];
long long b[N];
long long b_suf[N];
long long t[N * 4];
long long t2[N * 4];
int sz;
long long goal[N];
vector<pair<long long, long long> > V[N];
long long ans;
void build(int v, int tl, int tr) {
t[v] = 1e18;
if (tl == tr) {
return;
}
int sdfjahlfasfh = tl + tr;
sdfjahlfasfh /= 2;
build(v * 2, tl, sdfjahlfasfh);
build(v * 2 + 1, sdfjahlfasfh + 1, tr);
}
void build2(int v, int tl, int tr) {
if (tl == tr) {
t2[v] = b[tl];
return;
}
int sdfjahlfasfh = tl + tr;
sdfjahlfasfh /= 2;
build2(v * 2, tl, sdfjahlfasfh);
build2(v * 2 + 1, sdfjahlfasfh + 1, tr);
t2[v] = t2[v * 2] + t2[v * 2 + 1];
}
void update(int v, int tl, int tr, int ps, long long val) {
if (tl == tr) {
t[v] = val;
return;
}
int sdfjahlfasfh = tl + tr;
sdfjahlfasfh /= 2;
if (ps <= sdfjahlfasfh)
update(v * 2, tl, sdfjahlfasfh, ps, val);
else
update(v * 2 + 1, sdfjahlfasfh + 1, tr, ps, val);
t[v] = min(t[v * 2], t[v * 2 + 1]);
}
void add(int v, int tl, int tr, int ps, long long val) {
if (tl == tr) {
t2[v] += val;
return;
}
int sdfjahlfasfh = tl + tr;
sdfjahlfasfh /= 2;
if (ps <= sdfjahlfasfh)
add(v * 2, tl, sdfjahlfasfh, ps, val);
else
add(v * 2 + 1, sdfjahlfasfh + 1, tr, ps, val);
t2[v] = t2[v * 2] + t2[v * 2 + 1];
}
long long get(int v, int tl, int tr, int l, int r) {
if (l > r) return 1e18;
if (tl == l && tr == r) return t[v];
int sdfjahlfasfh = tl + tr;
sdfjahlfasfh /= 2;
return min(get(v * 2, tl, sdfjahlfasfh, l, min(r, sdfjahlfasfh)),
get(v * 2 + 1, sdfjahlfasfh + 1, tr, max(sdfjahlfasfh + 1, l), r));
}
long long get2(int v, int tl, int tr, int l, int r) {
if (tl == l && tr == r) return t2[v];
if (l > r) return 0;
int sdfjahlfasfh = tl + tr;
sdfjahlfasfh /= 2;
return get2(v * 2, tl, sdfjahlfasfh, l, min(r, sdfjahlfasfh)) +
get2(v * 2 + 1, sdfjahlfasfh + 1, tr, max(sdfjahlfasfh + 1, l), r);
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
entries[a[i]].push_back(i);
}
for (int i = 1; i <= n; i++) {
cin >> b[i];
}
for (int i = n; i; --i) {
b_suf[i] = b_suf[i + 1] + b[i];
}
build(1, 0, n);
build2(1, 0, n);
update(1, 0, n, 0, get2(1, 0, n, 0, n));
ans = 1e18;
cin >> sz;
for (int i = 1; i <= sz; i++) {
cin >> goal[i];
}
for (int i = 1; i <= sz; i++) {
for (int j = (int)entries[goal[i]].size() - 1; j >= 0; --j) {
int ps = entries[goal[i]][j];
long long bst = get(1, 0, n, 0, ps);
bst -= get2(1, 0, n, ps, n);
if (bst > 1e17) bst = 1e18;
V[i].push_back(make_pair(ps, bst));
}
for (int j = 0; j < V[i - 1].size(); j++) {
int ps = V[i - 1][j].first;
update(1, 0, n, ps, 1e18);
}
if (i == 1) update(1, 0, n, 0, 1e18);
for (int V = goal[i - 1] + 1; V <= goal[i]; V++)
for (int j = 0; j < entries[V].size(); j++) {
int ps = entries[V][j];
if (b[ps] >= 0) add(1, 0, n, ps, -b[ps]);
}
for (int j = 0; j < V[i].size(); j++) {
int ps = V[i][j].first;
long long val = V[i][j].second;
val += get2(1, 0, n, ps + 1, n);
if (val > 1e17) val = 1e18;
update(1, 0, n, ps, val);
if (i == sz) ans = min(ans, val);
}
}
if (ans > 1e17)
cout << "NO" << endl;
else {
cout << "YES" << endl;
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int f = 1, x = 0;
char ch;
do {
ch = getchar();
if (ch == '-') f = -1;
} while (ch < '0' || ch > '9');
do {
x = x * 10 + ch - '0';
ch = getchar();
} while (ch >= '0' && ch <= '9');
return f * x;
}
const int N = 5e5 + 1;
int n, m;
int a[N + 1], p[N + 1], b[N + 1], pos[N + 1];
long long sum[N + 1];
struct Seg {
long long tr[(N + 1) * 4 + 1], tag[(N + 1) * 4 + 1];
inline void pushup(int now) {
tr[now] = tr[(now << 1)] + tr[((now << 1) + 1)];
return;
}
inline void build(int now, int l, int r) {
if (l == r) {
tr[now] = 1e15;
return;
}
build((now << 1), l, ((l + r) >> 1));
build(((now << 1) + 1), ((l + r) >> 1) + 1, r);
pushup(now);
return;
}
inline void pushdown(int now, int l, int r) {
if (tag[now]) {
tr[(now << 1)] += tag[now] * (((l + r) >> 1) - l + 1);
tag[(now << 1)] += tag[now];
tr[((now << 1) + 1)] += tag[now] * (r - ((l + r) >> 1));
tag[((now << 1) + 1)] += tag[now];
tag[now] = 0;
}
return;
}
inline void update(int now, int l, int r, int pos, long long val) {
if (l == r) {
tr[now] = min(tr[now], val);
return;
}
pushdown(now, l, r);
if (pos <= ((l + r) >> 1))
update((now << 1), l, ((l + r) >> 1), pos, val);
else
update(((now << 1) + 1), ((l + r) >> 1) + 1, r, pos, val);
pushup(now);
return;
}
inline void add(int now, int l, int r, int L, int R, long long val) {
if (l >= L && r <= R) {
tr[now] += (r - l + 1) * val;
tag[now] += val;
return;
}
pushdown(now, l, r);
if (((l + r) >> 1) >= L) add((now << 1), l, ((l + r) >> 1), L, R, val);
if (((l + r) >> 1) < R)
add(((now << 1) + 1), ((l + r) >> 1) + 1, r, L, R, val);
pushup(now);
return;
}
inline long long query(int now, int l, int r, int pos) {
if (l == r) return tr[now];
pushdown(now, l, r);
long long sum;
if (pos <= ((l + r) >> 1))
sum = query((now << 1), l, ((l + r) >> 1), pos);
else
sum = query(((now << 1) + 1), ((l + r) >> 1) + 1, r, pos);
pushup(now);
return sum;
}
};
Seg seg;
long long ans = 1e18;
inline void dp() {
for (int i = 1; i <= n; i++) {
long long w = 1e18;
if (pos[a[i]] != -1) {
if (pos[a[i]] == 1)
w = sum[i - 1];
else
w = seg.query(1, 0, n, b[pos[a[i]] - 1]);
}
if (p[i] < 0)
seg.add(1, 0, n, 0, n, p[i]);
else
seg.add(1, 0, n, 0, a[i] - 1, p[i]);
seg.update(1, 0, n, a[i], w);
if (pos[a[i]] == m) ans = min(ans, w);
}
return;
}
int main() {
n = read();
for (int i = 1; i <= n; i++) {
a[i] = read();
pos[i] = -1;
}
for (int i = 1; i <= n; i++) {
p[i] = read();
sum[i] = sum[i - 1] + p[i];
}
a[n + 1] = N;
sum[n + 1] = sum[n];
n++;
m = read();
pos[0] = 0;
for (int i = 1; i <= m; i++) {
b[i] = read();
pos[b[i]] = i;
}
b[m + 1] = N;
pos[N] = m + 1;
m++;
seg.build(1, 0, n);
dp();
if (ans > 5e14)
printf("NO\n");
else
printf("YES\n%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
const long long inff = 0x3f3f3f3f3f3f3f3f;
using namespace std;
const int N = 5e5 + 8;
long long n, m, a[N], b[N], p[N], c[N], dp[N];
vector<int> g[N];
void add(int x, long long y) {
while (x <= n) c[x] += y, x += x & -x;
}
long long sum(int x) {
long long res = 0;
while (x > 0) res += c[x], x -= x & -x;
return res;
}
int main() {
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i(1); i <= (n); ++i) scanf("%lld", &a[i]), g[a[i]].push_back(i);
for (int i(1); i <= (n); ++i) scanf("%lld", &p[i]), add(i, p[i]);
cin >> m;
for (int i(1); i <= (m); ++i) scanf("%lld", &b[i]);
b[m + 1] = n + 1;
g[0].push_back(0);
g[n + 1].push_back(n + 1);
memset(dp, inff, sizeof(dp)), dp[0] = 0;
for (int ii(1); ii <= (m + 1); ++ii) {
int zz = 0, sz = g[b[ii - 1]].size(), i = b[ii];
for (int j = 0; j < g[i].size(); j++) {
if (j)
dp[g[i][j]] = min(dp[g[i][j]], dp[g[i][j - 1]] + sum(g[i][j] - 1) -
sum(g[i][j - 1]) + p[g[i][j - 1]]);
while (zz < sz && g[b[ii - 1]][zz] < g[i][j]) {
dp[g[i][j]] = min(dp[g[i][j]], dp[g[b[ii - 1]][zz]] + sum(g[i][j] - 1) -
sum(g[b[ii - 1]][zz]));
zz++;
}
}
for (int j(b[ii - 1] + 1); j <= (b[ii]); ++j)
for (int zs = 0; zs < g[j].size(); zs++)
if (p[g[j][zs]] > 0) add(g[j][zs], -p[g[j][zs]]);
}
if (dp[n + 1] > 1e17)
puts("NO");
else
printf("YES\n%lld\n", dp[n + 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int readint() {
int x = 0;
bool f = 0;
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-') {
f = 1;
c = getchar();
}
while (isdigit(c)) {
x = x * 10 + c - '0';
c = getchar();
}
return f ? -x : x;
}
const int maxn = 5e5 + 5;
int n, m, b[maxn], p[maxn];
vector<int> v[maxn];
long long dp[maxn];
bool g[maxn];
long long c[maxn];
inline int lowbit(int x) { return x & -x; }
void modify(int x, long long k) {
while (x <= n) {
c[x] += k;
x += lowbit(x);
}
}
long long query(int x) {
long long s = 0;
while (x > 0) {
s += c[x];
x -= lowbit(x);
}
return s;
}
const long long inf = 9e18;
int main() {
n = readint();
for (int i = 1; i <= n; i++) v[readint()].push_back(i);
for (int i = 1; i <= n; i++) p[i] = readint();
m = readint();
for (int i = 1; i <= m; i++) b[i] = readint();
int lst = 0;
for (int i = 1; i <= m; i++) {
lst = upper_bound(v[b[i]].begin(), v[b[i]].end(), lst) - v[b[i]].begin();
if (lst == (int)v[b[i]].size()) {
printf("NO\n");
return 0;
}
lst = v[b[i]][lst];
}
printf("YES\n");
for (int i = 1; i <= n; i++)
if (p[i] < 0) modify(i, p[i]);
for (int i = b[m] + 1; i <= n; i++)
for (int j = 0; j < (int)v[i].size(); j++) {
int x = v[i][j];
if (p[x] > 0) modify(x, p[x]);
}
for (int i = m; i > 0; i--) {
for (int j = (int)v[b[i]].size() - 1; j >= 0; j--) {
int x = v[b[i]][j];
g[x] = 0;
dp[x] = inf;
if (i == m) {
g[x] = 1;
dp[x] = query(n) - query(x);
} else {
int y = upper_bound(v[b[i + 1]].begin(), v[b[i + 1]].end(), x) -
v[b[i + 1]].begin();
if (y < (int)v[b[i + 1]].size()) {
y = v[b[i + 1]][y];
if (g[y]) {
g[x] = 1;
dp[x] = min(dp[x], dp[y] + query(y - 1) - query(x));
}
}
}
}
if (i == 0)
for (int j = 1; j <= b[i]; j++)
for (int k = 0; k < (int)v[j].size(); k++) {
int x = v[j][k];
if (p[x] > 0) modify(x, p[x]);
}
else
for (int j = b[i - 1] + 1; j <= b[i]; j++)
for (int k = 0; k < (int)v[j].size(); k++) {
int x = v[j][k];
if (p[x] > 0) modify(x, p[x]);
}
for (int j = (int)v[b[i]].size() - 1; j >= 0; j--) {
int x = v[b[i]][j];
if (j < (int)v[b[i]].size() - 1) {
int y = v[b[i]][j + 1];
if (g[y]) {
g[x] = 1;
dp[x] = min(dp[x], dp[y] + query(y - 1) - query(x - 1));
}
}
}
}
printf("%lld\n", dp[v[b[1]][0]] + query(v[b[1]][0] - 1));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e18;
const long long N = 5e5 + 5;
long long n, m, a[N], b[N], p[N], pref[N], pref_p[N], pref_d[N], dp[N], id[N],
cur[N];
vector<long long> pos[N], val[N];
long long t[N];
void add(long long r, long long val) {
for (; r <= n; r = r | (r + 1)) t[r] += val;
}
long long get(long long r) {
long long res = 0;
for (; r >= 0; r = (r & (r + 1)) - 1) res += t[r];
return res;
}
signed main() {
cin >> n;
for (long long i = 1; i <= n; i++) cin >> a[i];
for (long long i = 1; i <= n; i++) cin >> p[i];
cin >> m;
for (long long i = 1; i <= m; i++) cin >> b[i], id[b[i]] = i;
for (long long i = 1; i <= n; i++)
if (id[a[i]] != 0) pos[id[a[i]]].push_back(i), val[id[a[i]]].push_back(inf);
for (long long i = 1; i <= m; i++)
if (pos[i].size() == 0) {
cout << "NO\n";
return 0;
}
for (long long i = 1; i <= n; i++) {
if (id[a[i]] != 0) pref_p[i] = get(n) - get(b[id[a[i]] - 1]);
if (p[i] > 0) add(a[i], p[i]);
if (id[a[i]] != 0) pref[i] = get(n) - get(a[i]);
pref_d[i] = pref_d[i - 1];
if (p[i] < 0) pref_d[i] -= p[i];
}
val[1][0] = 0;
for (long long i = 1; i <= m; i++) {
long long mn = inf;
for (long long j = 0; j < pos[i].size(); j++) {
mn = min(mn, val[i][j]);
if (mn != inf)
dp[pos[i][j]] = mn + pref_p[pos[i][j]] - pref_d[pos[i][j] - 1];
else
dp[pos[i][j]] = inf;
}
if (i != m)
for (auto p : pos[i])
if (dp[p] != inf) {
while (cur[i + 1] != pos[i + 1].size() && pos[i + 1][cur[i + 1]] < p)
cur[i + 1]++;
if (cur[i + 1] == pos[i + 1].size()) break;
val[i + 1][cur[i + 1]] =
min(val[i + 1][cur[i + 1]], dp[p] - pref[p] + pref_d[p]);
}
}
long long ans = inf;
long long sum = 0;
for (long long i = n; i > 0; i--) {
if (a[i] == b[m] && dp[i] != inf) ans = min(ans, dp[i] + sum);
if (p[i] < 0 || a[i] > b[m]) sum += p[i];
}
if (ans == inf)
cout << "NO\n";
else
cout << "YES\n" << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, a[500100], b[500100], p[500100], f[500100], t[500100];
void ADD(long long x, long long y) {
while (x <= n) t[x] += y, x += x & -x;
}
long long SUM(long long x) {
long long s = 0;
while (x) s += t[x], x -= x & -x;
return s;
}
long long ALL(long long l, long long r) { return SUM(r) - SUM(l - 1); }
vector<long long> v[500100];
bool che() {
long long pos = 1;
for (long long i = 1; i <= n; i++)
if (a[i] == b[pos] && pos <= m) pos++;
return pos > m;
}
signed main() {
scanf("%lld", &n), memset(f, 0x3f3f3f3f, sizeof(f));
for (long long i = 1; i <= n; i++) scanf("%lld", &a[i]), v[a[i]].push_back(i);
for (long long i = 1; i <= n; i++) scanf("%lld", &p[i]), ADD(i, p[i]);
scanf("%lld", &m);
for (long long i = 1; i <= m; i++) scanf("%lld", &b[i]);
if (!che()) {
puts("NO");
return 0;
}
puts("YES");
v[0].push_back(0), f[0] = 0, v[n + 1].push_back(n + 1), b[++m] = n + 1;
for (long long i = 1; i <= m; i++) {
if (i > 1)
for (long long j = b[i - 2] + 1; j <= b[i - 1]; j++)
for (auto k : v[j])
if (p[k] > 0) ADD(k, -p[k]);
for (long long j = 0, k = 0; j < v[b[i]].size(); j++) {
if (j)
f[v[b[i]][j]] = f[v[b[i]][j - 1]] + ALL(v[b[i]][j - 1], v[b[i]][j] - 1);
for (; k < v[b[i - 1]].size() && v[b[i - 1]][k] < v[b[i]][j]; k++)
f[v[b[i]][j]] =
min(f[v[b[i]][j]],
f[v[b[i - 1]][k]] + ALL(v[b[i - 1]][k] + 1, v[b[i]][j] - 1));
}
}
printf("%lld\n", f[n + 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e5 + 5;
int a[maxn], n, m, p[maxn], id[maxn], b[maxn];
long long BIT[maxn], res[maxn], s[maxn], sav[maxn];
void readf() {
cin >> n;
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 1; i <= n; ++i) {
cin >> p[i];
if (p[i] < 0)
s[i] = s[i - 1] + p[i];
else
s[i] = s[i - 1];
}
cin >> m;
for (int i = 1; i <= m; ++i) {
cin >> b[i];
id[b[i]] = i;
}
}
void update(int x, int val) {
for (; x > 0; x -= -x & x) BIT[x] += val;
}
long long get(int x) {
long long ans = 0;
for (; x <= n; x += -x & x) ans += BIT[x];
return ans;
}
void solve() {
long long neg = 0;
for (int i = n; i > 0; --i) {
sav[i] = get(a[i] + 1) + neg;
if (p[i] <= 0)
neg += p[i];
else
update(a[i], p[i]);
}
memset(BIT, 0, sizeof(BIT));
memset(res, 0x3f, sizeof(res));
res[0] = 0;
for (int i = 1; i <= n; ++i) {
if (id[a[i]] == m) {
res[a[i]] = min(res[a[i]], s[i - 1] + res[b[id[a[i]] - 1]] +
get(b[id[a[i]] - 1] + 1) + sav[i]);
} else if (id[a[i]] > 0) {
res[a[i]] =
min(res[a[i]], s[i - 1] + res[b[id[a[i]] - 1]] +
get(b[id[a[i]] - 1] + 1) - get(a[i] + 1) - s[i]);
}
if (p[i] > 0) update(a[i], p[i]);
}
if (res[b[m]] > 1e18) {
cout << "NO\n";
exit(0);
}
cout << "YES\n";
cout << res[b[m]] << '\n';
}
int main() {
srand(time(NULL));
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
readf();
solve();
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const long long mn = 6e5, inf = 1e18;
long long n, a[mn], p[mn], m, b[mn], dp[mn], second[mn], s1;
void add(long long i, long long x) {
long long k = n - i + 1;
while (k <= n) {
second[k] += x;
k += k & (-k);
}
}
long long sum(long long i) {
long long k = n - i + 1, cnt = 0;
while (k > 0) {
cnt += second[k];
k -= k & (-k);
}
return cnt;
}
signed main() {
iostream::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (long long i = 1; i <= n; i++) cin >> a[i];
for (long long i = 1; i <= n; i++) cin >> p[i];
cin >> m;
for (long long j = 1; j <= m; j++) {
cin >> b[j];
dp[j] = inf;
}
b[m + 1] = b[m];
for (long long i = 1; i <= n; i++) {
long long l = 0, r = m + 1, j;
while (l < r - 1) {
long long mid = (l + r) / 2;
if (b[mid] <= a[i])
l = mid;
else
r = mid;
}
j = l;
long long s_new = s1;
if (p[i] < 0) s_new += p[i];
if (b[j] == a[i] && j == 1 && dp[j - 1] != inf)
dp[j] = min(dp[j], dp[j - 1] + sum(1) - (sum(b[j]) - sum(b[j] + 1)) -
sum(b[j] + 1) + s1 - s_new);
else if (b[j] == a[i] && dp[j - 1] != inf)
dp[j] = min(dp[j],
dp[j - 1] + sum(b[j - 1] + 1) - sum(b[j] + 1) + s1 - s_new);
s1 = s_new;
if (p[i] > 0) add(a[i], p[i]);
}
if (dp[m] == inf) {
cout << "NO";
exit(0);
}
dp[m] += sum(b[m] + 1) + s1;
cout << "YES\n" << dp[m];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e15 + 7;
const long long max_n = 5e5 + 3;
long long n, m;
vector<long long> a, p, b;
struct fenwick {
vector<long long> sum;
fenwick(long long n) { sum.resize(n); }
long long f(long long x) { return x & (x + 1); }
long long g(long long x) { return x | (x + 1); }
void add(long long id, long long x) {
while (id < sum.size()) {
sum[id] += x;
id = g(id);
}
}
long long get_(long long r) {
long long res = 0;
while (r >= 0) {
res += sum[r];
r = f(r) - 1;
}
return res;
}
long long get(long long l, long long r) { return get_(r) - get_(l - 1); }
};
fenwick t = fenwick(max_n);
void solve() {
cin >> n;
n++;
a.resize(n + 1);
p.resize(n + 1);
a[0] = 0;
for (long long i = 1; i < n; i++) cin >> a[i];
for (long long i = 1; i < n; i++) cin >> p[i];
a[n] = 1e9 + 1;
n++;
cin >> m;
m++;
b.resize(m + 1);
b[0] = 0;
for (long long i = 1; i < m; i++) cin >> b[i];
b[m] = 1e9 + 1;
m++;
map<long long, vector<long long>> ind;
for (long long i = 0; i < n; i++) ind[a[i]].emplace_back(i);
deque<long long> sorted;
for (long long i = 0; i < n; i++) {
t.add(i, p[i]);
if (p[i] > 0) sorted.emplace_back(i);
}
sort(sorted.begin(), sorted.end(),
[](long long v1, long long v2) { return a[v1] < a[v2]; });
vector<long long> dp(n, inf);
dp[0] = 0;
for (long long temp1 = 0; temp1 < m - 1; temp1++) {
long long v = b[temp1];
long long next = b[temp1 + 1];
while (!sorted.empty() && a[sorted.front()] <= v) {
long long id = sorted.front();
t.add(id, -p[id]);
sorted.pop_front();
}
vector<long long> s;
for (long long i : ind[v]) s.emplace_back(i);
for (long long i : ind[next]) s.emplace_back(i);
sort(s.begin(), s.end());
long long new_res = inf;
long long last = 0;
for (long long i : s) {
new_res += t.get(last, i);
last = i + 1;
if (a[i] == v)
new_res = min(new_res, dp[i]);
else
dp[i] = new_res - p[i];
}
}
if (dp[n - 1] > inf / 2)
cout << "NO";
else {
cout << "YES" << endl << dp[n - 1];
}
}
signed main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(0);
solve();
}
|
#include <bits/stdc++.h>
template <class T = int>
struct BinaryIndexedTree {
int size;
int logSize;
std::vector<T> tree;
BinaryIndexedTree(int size)
: size(size),
logSize(sizeof(T) * 8 - __builtin_clz(size) - 1),
tree(size + 1) {}
void add(int index, T value) {
assert(index >= 1 && index <= size);
while (index <= size) {
tree[index] += value;
index += index & (-index);
}
}
T getSum(int index) {
assert(index <= size);
T sum = T();
while (index > 0) {
sum += tree[index];
index -= index & (-index);
}
return sum;
}
T getSum(int l, int r) { return getSum(r) - getSum(l - 1); }
int lowerBound(T value) {
T sum = T();
int pos = 0;
for (int i = logSize; i >= 0; i--) {
if (pos + (1 << i) < size && sum + tree[pos + (1 << i)] < value) {
sum += tree[pos + (1 << i)];
pos += (1 << i);
}
}
return pos + 1;
}
};
const int MAXN = 500005;
struct State {
int pos;
long long cost;
};
std::vector<int> indices[MAXN];
int a[MAXN];
int p[MAXN];
std::vector<int> b;
int main() {
int n, m;
scanf("%d", &n);
BinaryIndexedTree<long long> bit(n);
BinaryIndexedTree<long long> bitAhead(n);
long long free = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
indices[a[i]].push_back(i);
}
for (int i = 0; i < n; i++) {
scanf("%d", &p[i]);
if (p[i] > 0) {
bit.add(i + 1, p[i]);
bitAhead.add(i + 1, p[i]);
} else {
free += p[i];
}
}
scanf("%d", &m);
for (int i = 0; i < m; i++) {
int next;
scanf("%d", &next);
b.push_back(next);
}
std::reverse(b.begin(), b.end());
std::vector<State> prevState;
int prevV = 0;
prevState.push_back({0, 0});
for (int i = 1; i <= n; i++) {
if (!b.empty() && i == b.back()) {
for (int i2 = prevV + 1; i2 <= i; i2++) {
for (int index : indices[i2]) {
if (p[index] > 0) {
bitAhead.add(index + 1, -p[index]);
}
}
}
std::vector<State> nextState;
long long currLoss = 0;
for (int index : indices[i]) {
auto it = std::upper_bound(
prevState.begin(), prevState.end(), State({index, 0}),
[](State s1, State s2) { return s1.pos < s2.pos; });
if (it == prevState.begin()) {
continue;
}
it--;
long long reduce = (p[index] < 0 ? p[index] : 0);
long long nextBit = bit.getSum(it->pos + 1, index);
long long nextCost = it->cost + nextBit - reduce;
if (!nextState.empty()) {
long long cmpCost = nextState.back().cost +
bitAhead.getSum(nextState.back().pos + 1, index);
if (nextCost >= cmpCost) {
continue;
}
}
nextState.push_back({index + 1, nextCost});
}
if (nextState.empty()) {
printf("NO\n");
return 0;
}
prevState = nextState;
b.pop_back();
for (int i2 = prevV + 1; i2 <= i; i2++) {
for (auto index : indices[i2]) {
if (p[index] > 0) {
bit.add(index + 1, -p[index]);
}
}
}
prevV = i;
}
}
long long best = 1e18;
for (auto s : prevState) {
long long next = s.cost + bit.getSum(s.pos + 1, n) + free;
best = std::min(best, next);
}
printf("YES\n");
printf("%lld\n", best);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void prn(Arg1&& arg1) {
cout << arg1 << "\n";
}
template <typename Arg1, typename... Args>
void prn(Arg1&& arg1, Args&&... args) {
cout << arg1 << " ";
prn(args...);
}
template <typename Arg1>
void prs(Arg1&& arg1) {
cout << arg1 << " ";
}
template <typename Arg1, typename... Args>
void prs(Arg1&& arg1, Args&&... args) {
cout << arg1 << " ";
prs(args...);
}
template <typename Arg1>
void read(Arg1&& arg1) {
cin >> arg1;
}
template <typename Arg1, typename... Args>
void read(Arg1&& arg1, Args&&... args) {
cin >> arg1;
read(args...);
}
const long long inf = 1e18, lim = 1e15;
int n;
vector<int> arr, p, pos, b;
vector<long long> tree, lazy;
inline void build(int st, int en, int node) {
if (st == en) {
tree[node] = inf;
return;
}
int mid = (st + en) >> 1;
build(st, mid, (node << 1));
build(mid + 1, en, (node << 1) | 1);
}
inline void push(int st, int en, int node) {
if (st == en)
tree[node] += lazy[node];
else {
lazy[node << 1] += lazy[node];
lazy[(node << 1) | 1] += lazy[node];
}
lazy[node] = 0;
}
inline void update(int st, int en, int node, int l, int r, long long nv) {
if (lazy[node]) push(st, en, node);
if (st > r || en < l) return;
if (st >= l && en <= r) {
lazy[node] = nv;
push(st, en, node);
return;
}
int mid = (st + en) >> 1;
update(st, mid, node << 1, l, r, nv);
update(mid + 1, en, (node << 1) | 1, l, r, nv);
}
inline void pupdate(int st, int en, int node, int idx, long long nv) {
if (lazy[node]) push(st, en, node);
if (st > idx || en < idx) return;
if (st == en) {
tree[node] = nv;
return;
}
int mid = (st + en) >> 1;
pupdate(st, mid, node << 1, idx, nv);
pupdate(mid + 1, en, (node << 1) | 1, idx, nv);
}
inline long long query(int st, int en, int node, int idx) {
if (lazy[node]) push(st, en, node);
if (st == en) return tree[node];
int mid = (st + en) >> 1;
if (idx <= mid) return query(st, mid, node << 1, idx);
return query(mid + 1, en, (node << 1) | 1, idx);
}
void solve() {
read(n);
arr.resize(n);
for (int i = 0; i < n; ++i) {
read(arr[i]);
}
p.resize(n);
for (int i = 0; i < n; ++i) {
read(p[i]);
}
int m;
read(m);
pos.resize(n + 1, -1);
pos[0] = 0;
b.resize(m + 1);
b[0] = 0;
for (int i = 1; i <= m; ++i) {
int x;
read(x);
b[i] = x;
pos[x] = i;
}
tree.resize(4 * m + 4);
lazy.resize(4 * m + 4, 0);
build(0, m, 1);
pupdate(0, m, 1, 0, 0);
int lst = 0;
for (int i = 0; i < n; ++i) {
int cur = arr[i], cost = p[i];
if (pos[cur] != -1) {
if (lst >= pos[cur] - 1) {
lst = max(lst, pos[cur]);
long long bst = query(0, m, 1, pos[cur] - 1),
prev = query(0, m, 1, pos[cur]);
if (cost >= 0) {
if (bst < prev) pupdate(0, m, 1, pos[cur], bst);
} else {
if (bst < prev + cost)
pupdate(0, m, 1, pos[cur], bst);
else
update(0, m, 1, pos[cur], pos[cur], cost);
}
}
}
int idx = lower_bound(b.begin(), b.end(), cur) - b.begin();
idx = min(idx - 1, lst);
update(0, m, 1, 0, idx, cost);
if (cost >= 0 || cur > b.back()) continue;
idx = upper_bound(b.begin(), b.end(), cur) - b.begin();
if (idx <= lst) update(0, m, 1, idx, lst, cost);
}
if (lst == m) {
prn("YES");
prn(query(0, m, 1, m));
} else
prn("NO");
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
for (int tc = 1; tc <= t; ++tc) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class V, int NV>
class SegTree_3 {
public:
vector<V> val, ma;
SegTree_3() {
int i;
val.resize(NV * 2, 0);
ma.resize(NV * 2, 0);
};
V getval(int x, int y, int l = 0, int r = NV, int k = 1) {
if (r <= x || y <= l) return 1LL << 60;
if (x <= l && r <= y) return ma[k];
return val[k] + min(getval(x, y, l, (l + r) / 2, k * 2),
getval(x, y, (l + r) / 2, r, k * 2 + 1));
}
void update(int x, int y, V v, int l = 0, int r = NV, int k = 1) {
if (l >= r) return;
if (x <= l && r <= y) {
val[k] += v;
ma[k] += v;
} else if (l < y && x < r) {
update(x, y, v, l, (l + r) / 2, k * 2);
update(x, y, v, (l + r) / 2, r, k * 2 + 1);
ma[k] = val[k] + min(ma[k * 2], ma[k * 2 + 1]);
}
}
};
SegTree_3<signed long long, 1 << 20> st;
template <class V, int ME>
class BIT {
public:
V bit[1 << ME];
V operator()(int e) {
if (e < 0) return 0;
V s = 0;
e++;
while (e) s += bit[e - 1], e -= e & -e;
return s;
}
void add(int e, V v) {
e++;
while (e <= 1 << ME) bit[e - 1] += v, e += e & -e;
}
};
BIT<signed long long, 21> bt;
int N;
int A[505050], P[505050];
int M;
int B[505050];
vector<int> ev[505050];
signed long long ret[505050];
void solve() {
int i, j, k, l, r, x, y;
string s;
scanf("%d", &N);
for (i = 0; i < (N); i++) {
scanf("%d", &A[i + 1]);
ev[A[i + 1]].push_back(i + 1);
}
A[N + 1] = N + 1;
ev[N + 1].push_back(N + 1);
ev[0].push_back(0);
for (i = 0; i < (N); i++) scanf("%d", &P[i + 1]);
scanf("%d", &M);
for (i = 0; i < (M); i++) {
scanf("%d", &x);
B[x] = 1;
}
B[0] = B[N + 1] = 1;
N += 2;
for (i = 0; i < (N); i++) ret[i] = 1LL << 60;
st.update(1, N, 1LL << 60);
for (i = 1; i < N; i++) {
st.update(0, i, P[i]);
bt.add(i, P[i]);
}
int pre = 0;
for (i = 1; i <= N - 1; i++) {
if (B[i] == 1) {
for (auto& e : ev[i]) {
ret[e] = st.getval(0, e) - (bt(1 << 20) - bt(e - 1));
}
for (auto& e : ev[pre]) st.update(e, e + 1, 1LL << 60);
for (auto& e : ev[i]) st.update(e, e + 1, ret[e] - (1LL << 60));
pre++;
while (pre <= i) {
for (auto& e : ev[pre])
if (P[e] > 0) {
st.update(0, e, -P[e]);
bt.add(e, -P[e]);
}
pre++;
}
pre--;
}
}
if (ret[N - 1] >= 1LL << 59) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
cout << ret[N - 1] << 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);
cout.tie(0);
solve();
return 0;
}
|
#include <bits/stdc++.h>
const int mod = 998244353;
using namespace std;
inline int read() {
char ch = getchar();
int f = 1, x = 0;
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;
}
const int N = 500005;
int n, m, a[N], b[N], id[N], pre[N];
long long t[N], dp[N], val[N], ans = 1e16, profit, sum, p[N], s[N];
bool judge() {
for (int i = 1, j = 1; i <= n; i++) {
if (a[i] == b[j]) j++;
if (j > m) return 1;
}
return 0;
}
void update(int i, long long x) {
for (; i <= n; i += i & -i) t[i] += x;
}
long long query(int i) {
long long ans = 0LL;
for (; i; i -= i & -i) ans += t[i];
return ans;
}
int main() {
n = read();
for (int i = 1; i <= n; i++) a[i] = read();
for (int i = 1; i <= n; i++) p[i] = read();
m = read();
for (int i = 1; i <= m; i++) b[i] = read(), id[b[i]] = i, dp[i] = 1e15;
if (judge())
puts("YES");
else
return printf("NO"), 0;
for (int i = 1; i <= n; i++) {
int now = id[a[i]];
if (now) {
val[i] = dp[now - 1] + query(n) - query(b[now - 1]) + s[i - 1] -
s[pre[now - 1]];
dp[now] = min(dp[now] + s[i - 1] - s[pre[now]] + ((p[i] < 0) ? p[i] : 0),
dp[now - 1] + query(b[now]) - query(b[now - 1]) + s[i - 1] -
s[pre[now - 1]]);
if (p[i] > 0) update(a[i], p[i]);
s[i] = s[i - 1] + ((p[i] < 0) ? p[i] : 0);
pre[now] = i;
} else {
if (p[i] < 0)
profit += p[i];
else
update(a[i], p[i]);
s[i] = s[i - 1];
}
}
for (int i = n; i >= 1; i--) {
if (a[i] == b[m]) ans = min(ans, val[i] + sum);
if (a[i] > b[m] && p[i] > 0) sum += p[i];
if (id[a[i]] != 0 && p[i] < 0) sum += p[i];
}
cout << ans + profit;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
const int N = 500090;
long long tree[4 * N], laz[4 * N], a[N], b[N], vis[N], c[N], pr[N];
void plaz(int ind, int l) {
tree[ind] += laz[ind];
if (l > 1) {
laz[ind * 2 + 1] += laz[ind];
laz[ind * 2 + 2] += laz[ind];
}
laz[ind] = 0;
}
void up(int ind, int st, int end, int l, int r, long long x) {
plaz(ind, end - st + 1);
if (l > end || r < st) return;
if (l <= st && end <= r) {
laz[ind] = x;
plaz(ind, end - st + 1);
return;
}
int m = (st + end) / 2;
up(ind * 2 + 1, st, m, l, r, x);
up(ind * 2 + 2, m + 1, end, l, r, x);
}
void update(int ind, int st, int end, int uind, long long x) {
plaz(ind, end - st + 1);
if (uind > end || uind < st) return;
if (st == end) {
tree[ind] = min(tree[ind], x);
return;
}
int m = (st + end) / 2;
update(ind * 2 + 1, st, m, uind, x);
update(ind * 2 + 2, m + 1, end, uind, x);
}
long long get(int ind, int st, int end, int u) {
plaz(ind, end - st + 1);
if (u > end || u < st) return 1e17;
if (st == end) return tree[ind];
int m = (st + end) / 2;
return min(get(ind * 2 + 1, st, m, u), get(ind * 2 + 2, m + 1, end, u));
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) cin >> c[i];
cin >> m;
pr[0] = c[0];
for (int i = 0; i < n * 4 + 10; i++) {
tree[i] = 1e17;
laz[i] = 0;
}
for (int i = 1; i < n; i++) pr[i] = pr[i - 1] + c[i];
memset(vis, -1, sizeof vis);
for (int i = 0; i < m; i++) {
cin >> b[i];
vis[b[i]] = i;
}
for (int i = 0; i < n; i++) {
if (c[i] > 0)
up(0, 0, n, 0, a[i] - 1, c[i]);
else
up(0, 0, n, 0, n, c[i]);
if (vis[a[i]] == -1) continue;
int w = vis[a[i]];
long long x;
if (w == 0)
x = pr[i - 1];
else
x = get(0, 0, n, b[w - 1]) - c[i];
update(0, 0, n, a[i], x);
}
long long w = get(0, 0, n, b[m - 1]);
if (w > 1e15) {
cout << "NO" << endl;
return 0;
}
cout << "YES" << endl << w;
}
|
#include <bits/stdc++.h>
using namespace std;
long long inf;
const double eps = 1e-8;
const double pi = acos(-1.0);
template <class T, class T2>
long long chkmin(T &a, T2 b) {
return a > b ? a = b, 1 : 0;
}
template <class T, class T2>
long long chkmax(T &a, T2 b) {
return a < b ? a = b, 1 : 0;
}
template <class T>
T sqr(T a) {
return a * a;
}
template <class T, class T2>
T mmin(T a, T2 b) {
return a < b ? a : b;
}
template <class T, class T2>
T mmax(T a, T2 b) {
return a > b ? a : b;
}
template <class T>
T aabs(T a) {
return a < 0 ? -a : a;
}
template <class T>
long long dcmp(T a, T b) {
return a > b;
}
template <long long *a>
long long cmp_a(long long first, long long second) {
return a[first] < a[second];
}
struct __INIT__ {
__INIT__() { memset(&inf, 0x3f, sizeof(inf)); }
} __INIT___;
namespace io {
const long long SIZE = (1 << 21) + 1;
char ibuf[SIZE], *iS, *iT, obuf[SIZE], *oS = obuf, *oT = oS + SIZE - 1, c,
qu[55];
long long f, qr;
inline void flush() {
fwrite(obuf, 1, oS - obuf, stdout);
oS = obuf;
}
inline void putc(char first) {
*oS++ = first;
if (oS == oT) flush();
}
template <typename A>
inline bool read(A &first) {
for (f = 1, c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
c < '0' || c > '9';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
if (c == '-')
f = -1;
else if (c == EOF)
return 0;
for (first = 0; c <= '9' && c >= '0';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
first = first * 10 + (c & 15);
first *= f;
return 1;
}
inline bool read(char &first) {
while ((first = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++)) == ' ' ||
first == '\n' || first == '\r')
;
return first != EOF;
}
inline bool read(char *first) {
while ((*first = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++)) == '\n' ||
*first == ' ' || *first == '\r')
;
if (*first == EOF) return 0;
while (!(*first == '\n' || *first == ' ' || *first == '\r' || *first == EOF))
*(++first) = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
*first = 0;
return 1;
}
template <typename A, typename... B>
inline bool read(A &first, B &...second) {
return read(first) && read(second...);
}
template <typename A>
inline bool write(A first) {
if (!first) putc('0');
if (first < 0) putc('-'), first = -first;
while (first) qu[++qr] = first % 10 + '0', first /= 10;
while (qr) putc(qu[qr--]);
return 0;
}
inline bool write(char first) {
putc(first);
return 0;
}
inline bool write(const char *first) {
while (*first) {
putc(*first);
++first;
}
return 0;
}
inline bool write(char *first) {
while (*first) {
putc(*first);
++first;
}
return 0;
}
template <typename A, typename... B>
inline bool write(A first, B... second) {
return write(first) || write(second...);
}
struct Flusher_ {
~Flusher_() { flush(); }
} io_flusher_;
} // namespace io
using io ::putc;
using io ::read;
using io ::write;
long long a[500005], p[500005], b[500005];
struct smt {
long long tag;
long long ls, rs;
smt *l, *r;
smt(long long la, long long ra) {
ls = la;
rs = ra;
if (ls == rs) {
l = r = 0;
tag = inf;
} else {
tag = 0;
long long mid = (ls + rs) >> 1;
l = new smt(ls, mid);
r = new smt(mid + 1, rs);
}
}
void push_down() {
l->tag += tag;
r->tag += tag;
tag = 0;
}
void add(long long la, long long ra, long long w) {
if (la <= ls && rs <= ra) {
tag += w;
return;
}
push_down();
if (la <= l->rs) l->add(la, ra, w);
if (r->ls <= ra) r->add(la, ra, w);
}
void ckmn(long long first, long long second) {
if (ls == rs) {
chkmin(tag, second);
return;
}
push_down();
if (first <= l->rs)
l->ckmn(first, second);
else
r->ckmn(first, second);
}
long long query(long long first) {
if (ls == rs) return tag;
push_down();
return first <= l->rs ? l->query(first) : r->query(first);
}
};
smt *rt;
signed main() {
long long n, m;
read(n);
for (long long i = 1; i <= n; ++i) read(a[i]);
long long s = 0;
for (long long i = 1; i <= n; ++i) {
read(p[i]);
s += aabs(p[i]);
}
read(m);
for (long long i = 1; i <= m; ++i) read(b[i]);
rt = new smt(0, m);
rt->ckmn(0, 0);
for (long long i = 1; i <= n; ++i) {
long long at = lower_bound(b + 1, b + m + 1, a[i]) - b;
if (b[at] == a[i]) {
if (p[i] >= 0) {
rt->ckmn(at, rt->query(at - 1));
rt->add(0, at - 1, p[i]);
} else {
rt->tag += p[i];
rt->ckmn(at, rt->query(at - 1) - p[i]);
}
} else {
if (p[i] < 0)
rt->tag += p[i];
else
rt->add(0, at - 1, p[i]);
}
}
long long w = rt->query(m);
if (w > s) {
write("NO\n");
return 0;
} else
write("YES\n", w, '\n');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 5;
int n, m, a[N], b[N], p[N], ind[N];
long long c[N];
void modify(int x, long long v) {
x++;
while (x <= m + 1) c[x] += v, x += x & -x;
}
long long query(int x) {
x++;
long long ans = 0;
while (x) ans += c[x], x -= x & -x;
return ans;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", a + i);
for (int i = 1; i <= n; i++) scanf("%d", p + i);
scanf("%d", &m);
for (int i = 1; i <= m; i++) scanf("%d", b + i), ind[b[i]] = i;
modify(1, 1e18);
for (int i = 1; i <= n; i++) {
long long v, nv;
if (ind[a[i]]) v = query(ind[a[i]] - 1);
modify(0, p[i]);
if (p[i] > 0) modify(lower_bound(b + 1, b + m + 1, a[i]) - b, -p[i]);
if (ind[a[i]]) {
nv = query(ind[a[i]]);
if (v < nv) modify(ind[a[i]], v - nv), modify(ind[a[i]] + 1, nv - v);
}
}
long long ans = query(m);
if (ans > 1e16)
puts("NO");
else
printf("YES\n%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 500000 + 10;
const int maxm = maxn - 1;
const long long inf = 1e18;
const long long mod = 998244353;
const double eps = 1e-8;
const long long o = 1;
const int apsz = 26;
struct BIT {
long long c[maxn];
int n;
int lowbit(int i) { return (-i) & i; }
void init(int n) { this->n = n; }
long long prefix(int l) {
long long ans = 0;
for (int i = l; i; i -= lowbit(i)) ans += c[i];
return ans;
}
void modify(int l, long long v) {
for (int i = l; i <= n; i += lowbit(i)) c[i] += v;
}
};
BIT tree;
long long dp[maxn];
int n, m;
int a[maxn];
int b[maxn];
long long p[maxn];
vector<pair<int, int> > del[maxn];
vector<int> idx[maxn];
inline int judge() {
for (int i = (2); i <= (m); ++i) {
if (b[i] - b[i - 1] <= 0) return 0;
}
int now = 1;
for (int i = (1); i <= (m); ++i) {
while (now <= n && a[now] != b[i]) now++;
if (now == n + 1) return 0;
}
return 1;
}
inline long long solve() {
dp[0] = 0;
queue<int> q[2];
int t = 0;
q[t].push(0);
long long _min;
for (int i = (1); i <= (m); ++i) {
_min = inf;
assert(!idx[i].empty());
while (!q[t ^ 1].empty()) q[t ^ 1].pop();
for (auto j : idx[i]) {
long long v = tree.prefix(j - 1);
while (!q[t].empty() && q[t].front() < j) {
int r = q[t].front();
q[t].pop();
_min = min(_min, dp[r] - tree.prefix(r));
}
q[t ^ 1].push(j);
dp[j] = min(dp[j], _min + v);
}
for (auto e : del[b[i]]) {
tree.modify(e.first, -e.second);
}
t ^= 1;
}
long long ans = inf;
long long v1 = tree.prefix(n);
for (auto x : idx[m]) {
long long v = tree.prefix(x);
ans = min(ans, dp[x] + v1 - v);
}
return ans;
}
int main(void) {
scanf("%d", &(n));
for (int i = (1); i <= (n); ++i) scanf("%d", &(a[i]));
for (int i = (1); i <= (n); ++i) scanf("%lld", &(p[i]));
scanf("%d", &(m));
for (int i = (1); i <= (m); ++i) scanf("%d", &(b[i]));
if (!judge()) return puts("NO"), 0;
tree.init(n);
for (int i = (1); i <= (n); ++i) tree.modify(i, p[i]);
puts("YES");
for (int i = (1); i <= (n); ++i) {
dp[i] = inf;
int pt = lower_bound(b + 1, b + 1 + m, a[i]) - b;
if (p[i] > 0 && pt <= m) {
del[b[pt]].push_back((pair<int, int>){i, p[i]});
}
if (b[pt] == a[i]) idx[pt].push_back(i);
}
printf("%lld\n", solve());
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[500010], b[500010], p[500010];
vector<int> all[500010];
vector<long long> dp[500010];
struct Segment_tree {
long long T[2000010];
void Build(int now, int l, int r) {
if (l == r) {
T[now] = p[l];
return;
}
int mid = l + r >> 1;
Build(now << 1, l, mid), Build(now << 1 | 1, mid + 1, r);
T[now] = T[now << 1] + T[now << 1 | 1];
}
void Update(int now, int l, int r, int pos, int x) {
if (l == r) {
T[now] = min(T[now], 1ll * x);
return;
}
int mid = l + r >> 1;
if (pos <= mid)
Update(now << 1, l, mid, pos, x);
else
Update(now << 1 | 1, mid + 1, r, pos, x);
T[now] = T[now << 1] + T[now << 1 | 1];
}
long long Query(int now, int l, int r, int L, int R) {
if (L > R) return 0;
if (l == L && r == R) return T[now];
int mid = l + r >> 1;
if (R <= mid) return Query(now << 1, l, mid, L, R);
if (L > mid) return Query(now << 1 | 1, mid + 1, r, L, R);
return Query(now << 1, l, mid, L, mid) +
Query(now << 1 | 1, mid + 1, r, mid + 1, R);
}
} seg;
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
all[a[i]].push_back(i);
dp[a[i]].push_back(1000000000000000000ll);
}
for (int i = 1; i <= n; i++) {
scanf("%d", &p[i]);
}
int m;
scanf("%d", &m);
for (int i = 0; i < m; i++) {
scanf("%d", &b[i]);
}
seg.Build(1, 1, n);
long long ans = 1000000000000000000ll;
for (int i = 0; i < m; i++) {
int x = b[i];
if (i == 0) {
for (int j = 0; j < all[x].size(); j++) {
dp[x][j] = seg.Query(1, 1, n, 1, all[x][j] - 1);
}
} else {
for (int j = 0; j < all[x].size(); j++) {
if (j)
(dp[x][j]) =
min((dp[x][j]), (dp[x][j - 1] + seg.Query(1, 1, n, all[x][j - 1],
all[x][j] - 1)));
}
}
for (int ii = i == 0 ? 1 : b[i - 1]; ii < x; ii++) {
for (int j = 0; j < all[ii].size(); j++) {
int x = all[ii][j];
seg.Update(1, 1, n, x, 0);
}
}
for (int k = 0; k < all[x].size(); k++) {
seg.Update(1, 1, n, all[x][k], 0);
}
if (i == m - 1) {
for (int j = 0; j < all[x].size(); j++) {
ans = min(ans, dp[x][j] + seg.Query(1, 1, n, all[x][j] + 1, n));
}
break;
}
int y = b[i + 1];
for (int j = 0; j < all[x].size(); j++) {
int pos =
lower_bound(all[y].begin(), all[y].end(), all[x][j]) - all[y].begin();
if (pos != all[y].size()) {
(dp[y][pos]) = min(
(dp[y][pos]),
(dp[x][j] + seg.Query(1, 1, n, all[x][j] + 1, all[y][pos] - 1)));
}
}
}
if (ans >= 10000000000000000ll)
printf("NO\n");
else
printf("YES\n%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
const int N = 5e5 + 5, M = 998244353, INF = 0x3f3f3f3f;
void Main();
void print() { cout << '\n'; }
template <typename T, typename... U>
void print(const T& x, const U&... y) {
((sizeof...(y) == 0) ? (cout << x) : (cout << x << ' '));
print(y...);
}
template <typename T>
void print(const T& a, int l, int r, char c) {
for (int i = l; i <= r; ++i) {
cout << a[i];
if (i == r)
cout << '\n';
else
cout << c;
}
}
void input() {}
template <typename T, typename... U>
void input(T& x, U&... y) {
cin >> x;
input(y...);
}
template <typename T>
void input(T& a, int l, int r, bool f) {
for (int i = l; i <= r; ++i) cin >> a[i];
}
template <typename T>
void Max(T& a, T b) {
a < b ? a = b : 1;
}
template <typename T>
void Min(T& a, T b) {
a > b ? a = b : 1;
}
template <typename T>
void Add(T& a, T b) {
a += b, a > M ? a -= M : 1;
}
template <typename T>
void Mul(T& a, T b) {
a = a * b % M;
}
int main(int argc, char** argv) { Main(); }
ll a[N], b[N], p[N];
struct node {
ll sum, tag;
} t[N << 2];
void pushdown(int o, int l, int r) {
if (t[o].tag == 0) return;
int mid = (l + r) / 2;
t[o + o].sum += t[o].tag * (mid - l + 1);
t[o + o + 1].sum += t[o].tag * (r - mid);
t[o + o].tag += t[o].tag;
t[o + o + 1].tag += t[o].tag;
t[o].tag = 0;
}
ll query(int o, int l, int r, int L, int R) {
if (r < L || R < l) return 0;
if (L <= l && r <= R) return t[o].sum;
pushdown(o, l, r);
int mid = (l + r) / 2;
return query(o + o, l, mid, L, R) + query(o + o + 1, mid + 1, r, L, R);
}
void update(int o, int l, int r, int L, int R, ll val) {
if (r < L || R < l) return;
if (L <= l && r <= R) {
t[o].sum += val * (r - l + 1);
t[o].tag += val;
return;
}
pushdown(o, l, r);
int mid = (l + r) / 2;
update(o + o, l, mid, L, R, val), update(o + o + 1, mid + 1, r, L, R, val);
}
void Main() {
int n, m;
input(n);
input(a, 1, n, true);
input(p, 1, n, true);
input(m);
input(b, 1, m, true);
int j = 1;
ll sum = 0;
for (int i = 1; i <= n; ++i) {
sum += p[i];
if (a[i] == b[j]) ++j;
}
if (j <= m) {
print("NO");
return;
}
update(1, 1, n, 1, n, -0x3f3f3f3f3f3f3f3f);
for (int i = 1; i <= n; ++i) {
int j = lower_bound(b + 1, b + m + 1, a[i]) - b;
ll tmp;
if (j <= m && a[i] == b[j]) {
if (j == 1) {
tmp = p[i];
} else {
tmp = query(1, 1, n, b[j - 1], b[j - 1]) + p[i];
}
}
if (p[i] > 0) update(1, 1, n, a[i], n, p[i]);
ll old = query(1, 1, n, a[i], a[i]);
if (tmp > old) {
update(1, 1, n, a[i], a[i], tmp - old);
}
}
print("YES");
print(sum - query(1, 1, n, b[m], b[m]));
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
const double PI = acos(-1);
template <class A, class B>
std::ostream& operator<<(std::ostream& st, const std::pair<A, B> p) {
st << "(" << p.first << ", " << p.second << ")";
return st;
}
using namespace std;
const long long oo = 1LL << 60;
const int MAX = 1 << 20;
int A[MAX], B[MAX], P[MAX], n, m;
int lst[MAX];
int nxt[MAX];
int R[MAX];
std::vector<int> IDX[MAX];
long long dp[MAX];
long long neg_sum[MAX];
long long sum[MAX];
long long T[2][MAX];
int M;
void add(int p, long long v, long long* BIT) {
for (++p; p <= M; p += ((p) & (-(p)))) BIT[p] += v;
}
long long get(int p, long long* BIT) {
long long ret = 0;
for (++p; p; p ^= ((p) & (-(p)))) ret += BIT[p];
return ret;
}
long long solve() {
M = 2 * n;
for (int i = 0; i < n; i++) {
add(A[i], P[i], T[0]);
add(A[i], min(P[i], 0), T[1]);
sum[i] = get(M, T[0]) - get(A[i], T[0]);
neg_sum[i] = get(A[i], T[1]);
long long& ret = dp[i];
ret = oo;
int x = A[i], r = R[x];
if (r == 0) {
ret = 0;
continue;
}
if (nxt[i] != -1) {
int j = nxt[i];
if (dp[j] < oo) {
long long tmp = dp[j] + neg_sum[i] - neg_sum[j] + sum[i] - sum[j];
ret = min(ret, tmp);
}
}
int y = B[r - 1];
auto ptr = upper_bound(IDX[y].begin(), IDX[y].end(), i);
if (ptr != IDX[y].begin()) {
ptr--;
int j = *ptr;
if (dp[j] < oo) {
long long s = get(M, T[0]) - get(y, T[0]) - sum[j] - P[i];
long long neg = get(y, T[1]) - neg_sum[j];
long long tmp = dp[j] + neg + s;
ret = min(ret, tmp);
}
} else
ret = oo;
}
return dp[n - 1];
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", A + i);
for (int i = 1; i <= n; i++) scanf("%d", P + i);
scanf("%d", &m);
for (int i = 1; i <= m; i++) scanf("%d", B + i);
A[0] = B[0] = 0;
A[n + 1] = B[m + 1] = n + 1;
n += 2;
m += 2;
for (int i = 0; i < (m - 1); i++)
if (B[i] >= B[i + 1]) {
puts("NO");
return 0;
}
for (int i = 0; i < (m); i++) R[B[i]] = i;
memset(lst, -1, sizeof lst);
for (int i = 0; i < (n); i++) {
IDX[A[i]].push_back(i);
nxt[i] = lst[A[i]];
lst[A[i]] = i;
}
long long ans = solve();
if (ans >= oo) {
puts("NO");
return 0;
}
puts("YES");
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
enum SegType { SUM, MIN, MAX };
template <typename T>
struct SegTree {
int num = 0, bt;
vector<T> node, lazy;
typedef function<T(const T &, const T &)> c1t;
typedef function<T(const T &, const int &, const int &, const int &,
const int &, const T &)>
c2t;
typedef function<T(const T &, const T &)> c3t;
c1t calc1;
c2t calc2;
c3t calc3;
T _init;
void init(int num, T n, c1t calc1, c2t calc2, c3t calc3) {
int i = 0, j = 1;
this->num = num;
this->_init = n;
this->calc1 = calc1;
this->calc2 = calc2;
this->calc3 = calc3;
for (j = 1; j < num;) j *= 2;
this->bt = j - 1;
node.resize(j * 2 - 1, n);
lazy.resize(j * 2 - 1, 0);
}
void init(int num, T n, SegType st) {
if (st == SegType::MAX) {
if (std::is_same<T, int>().value)
_init = (T)INT_MIN;
else if (std::is_same<T, long long>().value)
_init = (T)LLONG_MIN;
else
_init = (T)n;
init(
num, n, [](const T &a, const T &b) { return max(a, b); },
[](const T &a, const int &x, const int &y, const int &l, const int &r,
const T &n) { return a + n; },
[](const T &a, const T &n) { return a + n; });
} else if (st == SegType::MIN) {
if (std::is_same<T, int>().value)
_init = (T)INT_MAX;
else if (std::is_same<T, long long>().value)
_init = (T)LLONG_MAX;
else
_init = (T)n;
init(
num, n, [](const T &a, const T &b) { return min(a, b); },
[](const T &a, const int &x, const int &y, const int &l, const int &r,
const T &n) { return a + n; },
[](const T &a, const T &n) { return a + n; });
} else if (st == SegType::SUM) {
if (std::is_same<T, int>().value)
_init = (T)0;
else if (std::is_same<T, long long>().value)
_init = (T)0;
else
_init = (T)n;
init(
num, n, [](const T &a, const T &b) { return (a + b); },
[](const T &a, const int &x, const int &y, const int &l, const int &r,
const T &n) { return (a + (r - l + 1) * n); },
[](const T &a, const T &n) { return (a + n / 2); });
}
}
void addd(int x, int y, T n) {
if (x > y) return;
_addd(x, y, n, 0, 0, this->bt);
}
void _addd(const int &x, const int &y, const T &n, int p, int l, int r) {
if (r < x || y < l) return;
if (x <= l && r <= y) {
lazy[p] = calc2(lazy[p], x, y, l, r, n);
evall(p);
} else {
if (lazy[p] != 0) evall(p);
_addd(x, y, n, p * 2 + 1, l, (l + r) / 2);
_addd(x, y, n, p * 2 + 2, (l + r) / 2 + 1, r);
node[p] = calc1(node[p * 2 + 1], node[p * 2 + 2]);
}
}
inline void evall(int x) {
node[x] += lazy[x];
if (x < bt) {
lazy[x * 2 + 1] = calc3(lazy[x * 2 + 1], lazy[x]);
lazy[x * 2 + 2] = calc3(lazy[x * 2 + 2], lazy[x]);
}
lazy[x] = 0;
}
void sett(int x, T n) {
gett(x);
int i = bt + x;
node[i] = n;
while (i != 0) {
i = (i - 1) / 2;
node[i] = calc1(node[i * 2 + 1], node[i * 2 + 2]);
}
}
inline T gett(int x) {
T ret = _init;
_gett(x, x, 0, 0, this->bt, ret);
return ret;
}
T gett(int x, int y) {
T ret = _init;
if (x > y) return ret;
_gett(x, y, 0, 0, this->bt, ret);
return ret;
}
void _gett(const int &x, const int &y, int p, int l, int r, T &ret) {
if (r < x || y < l) return;
if (lazy[p] != 0) evall(p);
if (x <= l && r <= y) {
ret = calc1(ret, node[p]);
return;
}
_gett(x, y, p * 2 + 1, l, (l + r) / 2, ret);
_gett(x, y, p * 2 + 2, (l + r) / 2 + 1, r, ret);
}
};
long long N, A[505050], P[505050], M, B[505050];
long long i, j, k;
int main() {
scanf("%lld", &N);
for (i = 0; i < N; ++i) {
scanf("%lld", &A[i]);
}
for (i = 0; i < N; ++i) {
scanf("%lld", &P[i]);
}
scanf("%lld", &M);
for (i = 0; i < M; ++i) {
scanf("%lld", &B[i + 1]);
}
SegTree<long long> dp;
dp.init(M + 5, (long long)(1e18), SegType::MIN);
dp.sett(0, 0);
for (i = 0; i < N; ++i) {
long long bi = lower_bound(B, B + M + 1, A[i]) - B;
if (P[i] < 0) {
if (A[i] == B[bi] && dp.gett(bi - 1) < dp.gett(bi) + P[i]) {
long long a = dp.gett(bi - 1);
dp.addd(0, M + 1, P[i]);
dp.sett(bi, a);
} else {
dp.addd(0, M + 1, P[i]);
}
} else {
if (A[i] == B[bi] && dp.gett(bi - 1) < dp.gett(bi)) {
long long a = dp.gett(bi - 1);
dp.addd(0, bi - 1, P[i]);
dp.sett(bi, a);
} else {
dp.addd(0, bi - 1, P[i]);
}
}
}
if (dp.gett(M) > 1e17) {
printf("NO\n");
} else {
printf("YES\n%lld\n", dp.gett(M));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m;
vector<long long> a, b, p;
vector<long long> tree;
vector<long long> val;
void push(long long v, long long l, long long r) {
if (l == r) {
tree[v] = 0;
return;
}
tree[v * 2] += tree[v];
tree[v * 2 + 1] += tree[v];
tree[v] = 0;
}
long long ans(long long v, long long l, long long r, long long ind) {
long long k = tree[v];
push(v, l, r);
if (l == r) {
return k;
}
if (ind <= (r + l) / 2) {
return ans(v * 2, l, (r + l) / 2, ind);
} else {
return ans(v * 2 + 1, (r + l) / 2 + 1, r, ind);
}
}
void update(long long v, long long l, long long r, long long al, long long ar,
long long val) {
if (al <= l && r <= ar) {
tree[v] += val;
} else if (al <= r && l <= ar) {
push(v, l, r);
update(v * 2, l, (r + l) / 2, al, ar, val);
update(v * 2 + 1, (r + l) / 2 + 1, r, al, ar, val);
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n;
a.resize(n);
p.resize(n);
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
vector<long long> pref(n);
for (long long i = 0; i < n; i++) {
cin >> p[i];
if (i == 0) {
pref[i] = p[i];
} else {
pref[i] = pref[i - 1] + p[i];
}
}
cin >> m;
b.resize(m);
for (long long i = 0; i < m; i++) {
cin >> b[i];
}
tree.resize(m * 4);
val.resize(m, 1e18);
vector<bool> used(m);
for (long long i = 0; i < n; i++) {
long long l = -1, r = m;
while (r - l > 1) {
long long midd = (r + l) / 2;
if (b[midd] <= a[i]) {
l = midd;
} else {
r = midd;
}
}
if (l == -1) {
if (p[i] < 0) {
update(1, 0, m - 1, 0, m - 1, p[i]);
}
continue;
}
if (b[l] == a[i]) {
if (l == 0) {
long long t = val[l] + ans(1, 0, m - 1, l);
if (p[i] < 0) {
t += p[i];
if (l != m - 1) {
update(1, 0, m - 1, 1, m - 1, p[i]);
}
}
val[l] = min(t, pref[i] - p[i]);
used[l] = true;
} else {
if (!used[l - 1]) {
if (p[i] < 0) {
update(1, 0, m - 1, 0, m - 1, p[i]);
} else {
update(1, 0, m - 1, 0, l - 1, p[i]);
}
} else {
used[l] = true;
long long t = 1e18;
if (used[l]) {
t = val[l] + ans(1, 0, m - 1, l);
if (p[i] < 0) {
t += p[i];
}
}
val[l - 1] += ans(1, 0, m - 1, l - 1);
val[l] = min(t, val[l - 1]);
update(1, 0, m - 1, 0, l - 1, p[i]);
if (p[i] < 0 && l != m - 1) {
update(1, 0, m - 1, l + 1, m - 1, p[i]);
}
}
}
} else if (p[i] >= 0) {
update(1, 0, m - 1, 0, l, p[i]);
} else {
update(1, 0, m - 1, 0, m - 1, p[i]);
}
}
if (!used[m - 1]) {
cout << "NO";
return 0;
}
val[m - 1] = val[m - 1] + ans(1, 0, m - 1, m - 1);
cout << "YES\n";
cout << val[m - 1];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 1, K = 10, AL = 11;
int a[N], p[N], b[N], bi[N];
int s[N], e[N];
int n, m;
const long long INF = 1e9 * N + 1;
long long f[N];
void add(int p, long long v) {
for (int i = p; i < N; i |= i + 1) f[i] += v;
}
void add(int l, int r, long long v) {
add(l, v);
add(r, -v);
}
long long get(int p) {
long long res = 0;
for (int i = p; i >= 0; i = (i & (i + 1)) - 1) res += f[i];
return res;
}
void change(int p, long long v) { add(p, p + 1, v - get(p)); }
int main() {
ios_base::sync_with_stdio(false);
cout.tie(0);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) cin >> p[i];
cin >> m;
for (int i = 1; i <= n; i++) {
bi[i] = -1;
}
for (int i = 1; i <= m; i++) {
cin >> b[i];
bi[b[i]] = i;
}
add(1, n + 1, INF * 2);
for (int i = 1; i <= n; i++) {
if (bi[a[i]] >= 0) {
change(a[i], min(get(a[i]) + min(p[i], 0), get(b[bi[a[i]] - 1])));
}
add(0, a[i], p[i]);
if (p[i] < 0) add(a[i] + 1, n + 1, p[i]);
}
if (get(b[m]) < INF)
cout << "YES\n" << get(b[m]) << endl;
else
cout << "NO" << endl;
}
|
#include <bits/stdc++.h>
inline int read() {
char c, _c;
int x;
for (c = _c = getchar(); !isdigit(c); c = getchar()) {
_c = c;
}
for (x = 0; isdigit(c); c = getchar()) {
x = x * 10 + c - '0';
}
return _c == '-' ? -x : x;
}
const int N = 2e6 + 5;
int n, m, a[N], b[N], c[N];
long long ans, sum, f[N], suf[N];
bool used[N];
std::vector<int> w[N];
struct SegmentTree {
long long f[N], g[N];
inline void pushUp(int u) {
int ls = u << 1, rs = ls | 1;
f[u] = std::max(f[ls], f[rs]);
}
inline void pushTag(int u, long long x) {
f[u] += x;
g[u] += x;
}
inline void pushDown(int u) {
if (g[u] != 0) {
int ls = u << 1, rs = ls | 1;
pushTag(ls, g[u]);
pushTag(rs, g[u]);
g[u] = 0;
}
}
void modify(int u, int l, int r, int pl, int pr, long long x) {
if (pl >= pr) {
return;
}
if (l == pl && r == pr) {
pushTag(u, x);
return;
}
int mid = l + r >> 1, ls = u << 1, rs = ls | 1;
pushDown(u);
if (pr <= mid) {
modify(ls, l, mid, pl, pr, x);
} else if (pl >= mid) {
modify(rs, mid, r, pl, pr, x);
} else {
modify(ls, l, mid, pl, mid, x);
modify(rs, mid, r, mid, pr, x);
}
pushUp(u);
}
void query(int u, int l, int r, int pl, int pr, long long &res) {
if (pl >= pr) {
return;
}
if (l == pl && r == pr) {
res = std::max(res, f[u]);
return;
}
int mid = l + r >> 1, ls = u << 1, rs = ls | 1;
pushDown(u);
if (pr <= mid) {
query(ls, l, mid, pl, pr, res);
} else if (pl >= mid) {
query(rs, mid, r, pl, pr, res);
} else {
query(ls, l, mid, pl, mid, res);
query(rs, mid, r, mid, pr, res);
}
pushUp(u);
}
} smt, smt0;
int main() {
n = read();
w[0].push_back(0);
for (int i = 1; i <= n; i++) {
a[i] = read();
w[a[i]].push_back(i);
}
for (int i = 1; i <= n; i++) {
c[i] = read();
sum += c[i];
}
m = read();
for (int i = 1; i <= m; i++) {
b[i] = read();
used[b[i]] = true;
}
for (int i = n; i >= 1; i--) {
suf[i] = suf[i + 1];
if (a[i] <= b[m]) {
suf[i] += std::max(0, c[i]);
}
}
ans = -4e18;
for (int i = 1; i <= n; i++) {
smt.modify(1, 0, n + 1, i, i + 1, -1e18);
}
for (int x = 1, lst = 0; x <= n; x++) {
if (used[x]) {
for (auto i : w[x]) {
f[i] = -4e18;
smt.query(1, 0, n + 1, 0, i, f[i]);
long long tmp = -4e18;
smt0.query(1, 0, n + 1, i, i + 1, tmp);
f[i] -= tmp;
f[i] += c[i];
if (x == b[m]) {
ans = std::max(ans, f[i] + suf[i + 1]);
}
}
for (auto i : w[x]) {
smt.modify(1, 0, n + 1, i, i + 1, 1e18 + f[i]);
}
for (auto i : w[lst]) {
smt.modify(1, 0, n + 1, i, i + 1, -1e18 - f[i]);
}
for (int y = lst + 1; y <= x; y++) {
for (auto i : w[y]) {
smt.modify(1, 0, n + 1, 0, i, std::max(0, c[i]));
smt0.modify(1, 0, n + 1, 0, i, std::max(0, c[i]));
}
}
lst = x;
}
}
if (ans <= -1e16) {
printf("NO\n");
} else {
printf("YES\n%lld\n", sum - ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
const long long linf = 4000000000000000000LL;
const long long inf = 998244353;
const long double pi = 3.1415926535;
void pv(vector<int> a) {
for (auto& x : a) cout << x << " ";
cout << '\n';
}
void pv(vector<long long> a) {
for (auto& x : a) cout << x << " ";
cout << '\n';
}
void pv(vector<vector<int> > a) {
for (int i = (0); i < (int(a.size())); ++i) {
cout << i << '\n';
pv(a[i]);
cout << '\n';
}
}
void pv(vector<vector<long long> > a) {
for (int i = (0); i < (int(a.size())); ++i) {
cout << i << '\n';
pv(a[i]);
}
cout << '\n';
}
void pv(vector<string> a) {
for (auto& x : a) cout << x << '\n';
cout << '\n';
}
void setIO(string second) {
ios_base::sync_with_stdio(0);
cin.tie(0);
if (int(second.size())) {
freopen((second + ".in").c_str(), "r", stdin);
if (second != "test1") freopen((second + ".out").c_str(), "w", stdout);
}
}
class segment_tree {
struct item {
long long sum;
};
item single(long long i) { return {i}; }
item merge(item x, item y) {
item ans;
ans.sum = x.sum + y.sum;
return ans;
}
vector<item> tree;
vector<item> A;
int height;
item neutral = {0};
public:
void build(vector<long long>& B) {
int n = B.size();
height = log2(n + 1) + 1;
A.resize(n);
tree.resize((1 << height + 1) - 1);
for (int i = (0); i < (n); ++i) A[i] = single(B[i]);
A.resize(1 << height, neutral);
build(A, 0, 0, (1 << height) - 1);
}
void build(vector<item>& A, int v, int tl, int tr) {
if (tl == tr)
tree[v] = A[tl];
else {
int mid = (tl + tr) / 2;
build(A, 2 * v + 1, tl, mid);
build(A, 2 * v + 2, mid + 1, tr);
tree[v] = merge(tree[2 * v + 1], tree[2 * v + 2]);
}
}
public:
long long query(int l, int r) {
return query(0, 0, (1 << height) - 1, l, r).sum;
}
item query(int v, int tl, int tr, int l, int r) {
if (r < tl || l > tr) return neutral;
if (l <= tl && r >= tr) {
return tree[v];
}
int mid = (tl + tr) / 2;
return merge(query(2 * v + 1, tl, mid, l, r),
query(2 * v + 2, mid + 1, tr, l, r));
}
public:
void update(int pos, long long val) {
update(0, 0, (1 << height) - 1, pos, single(val));
}
void update(int v, int tl, int tr, int pos, item val) {
if (tl == tr) {
tree[v] = merge(tree[v], val);
} else {
int mid = (tl + tr) / 2;
if (pos <= mid)
update(2 * v + 1, tl, mid, pos, val);
else
update(2 * v + 2, mid + 1, tr, pos, val);
tree[v] = merge(tree[2 * v + 1], tree[2 * v + 2]);
}
}
};
int n, m;
vector<int> a, p, b;
int main() {
setIO("");
cin >> n;
a.resize(n);
for (auto& x : a) cin >> x;
p.resize(n);
for (auto& x : p) cin >> x;
cin >> m;
b.resize(m);
for (auto& x : b) cin >> x;
vector<long long> dp(n);
map<int, vector<int> > pos;
for (int i = (0); i < (n); ++i) pos[a[i]].push_back(i);
for (auto& x : pos[b[0]]) dp[x] = p[x];
set<pair<int, int> > t;
for (int i = (0); i < (n); ++i) t.insert({a[i], i});
segment_tree sum;
vector<long long> temp(n);
sum.build(temp);
while (int(t.size()) && t.begin()->first <= b[0]) {
int k = t.begin()->second;
t.erase(t.begin());
if (p[k] > 0) sum.update(k, p[k]);
}
for (int i = (1); i < (m); ++i) {
int j = b[i - 1], k = b[i];
vector<int> todo;
for (auto& x : pos[j]) todo.push_back(x);
for (auto& x : pos[k]) todo.push_back(x);
long long ans = -linf;
int last = -1;
sort(todo.begin(), todo.end());
for (auto& x : todo) {
ans += sum.query(last + 1, x);
last = x;
if (a[x] == j)
ans = max(ans, dp[x]);
else
dp[x] = ans + p[x];
}
while (int(t.size()) && t.begin()->first <= k) {
int l = t.begin()->second;
t.erase(t.begin());
if (p[l] > 0) sum.update(l, p[l]);
}
}
long long ans = -linf;
for (int i = (0); i < (n); ++i)
if (a[i] == b[m - 1]) ans = max(ans, dp[i] + sum.query(i + 1, n - 1));
ans = accumulate(p.begin(), p.end(), 0LL) - ans;
if (ans > 1e15)
cout << "NO" << '\n';
else
cout << "YES" << '\n' << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e18;
const int maxn = 5e5 + 5;
map<long long, long long> pos;
long long p[maxn];
long long a[maxn], b[maxn];
class element {
public:
int l, r;
long long plus, val;
};
class Tree {
public:
element tree[maxn << 2];
void build(int id, int l, int r) {
tree[id].l = l;
tree[id].r = r;
tree[id].plus = 0;
if (l == r) {
tree[id].val = inf;
return;
}
int mid = (l + r) / 2;
build(id * 2, l, mid);
build(id * 2 + 1, mid + 1, r);
}
void update(int id, int p, long long num) {
if (tree[id].l == p && tree[id].r == p) {
tree[id].val = num;
return;
}
if (tree[id].l > p || tree[id].r < p) return;
push_down(id);
update(id * 2, p, num);
update(id * 2 + 1, p, num);
}
void add(int id, int l, int r, long long num) {
if (tree[id].l >= l && tree[id].r <= r) {
tree[id].plus += num;
tree[id].val += num * (tree[id].r - tree[id].l + 1);
return;
}
if (tree[id].l > r || tree[id].r < l) return;
push_down(id);
if (tree[id * 2].r >= l) add(id * 2, l, r, num);
if (tree[id * 2 + 1].l <= r) add(id * 2 + 1, l, r, num);
}
void push_down(int id) {
if (tree[id].l != tree[id].r)
for (int j = id * 2; j <= id * 2 + 1; j++) {
tree[j].val += tree[id].plus * (tree[j].r - tree[j].l + 1);
tree[j].plus += tree[id].plus;
}
tree[id].plus = 0;
}
long long query(int id, int l, int r) {
if (tree[id].l >= l && tree[id].r <= r) return tree[id].val;
if (tree[id].l > r || tree[id].r < l) return 0;
long long s = 0;
push_down(id);
if (tree[id * 2].r >= l) s += query(id * 2, l, r);
if (tree[id * 2 + 1].l <= r) s += query(id * 2 + 1, l, r);
return s;
}
} dp;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) cin >> p[i];
cin >> m;
for (int i = 1; i <= m; i++) {
cin >> b[i];
pos[b[i]] = i;
}
dp.build(1, 0, m);
dp.update(1, 0, 0);
for (int i = 1; i <= n; i++) {
if (pos[a[i]] == 0) {
if (p[i] < 0) {
dp.add(1, 0, m, p[i]);
continue;
}
int id = lower_bound(b + 1, b + 1 + m, a[i]) - b;
dp.add(1, 0, id - 1, p[i]);
} else {
int pp = pos[a[i]];
long long val1 = dp.query(1, pp, pp);
long long val2 = dp.query(1, pp - 1, pp - 1);
dp.update(1, pp, min(val1 + min(0ll, p[i]), val2));
if (pp != m && p[i] < 0) dp.add(1, pp + 1, m, p[i]);
dp.add(1, 0, pp - 1, p[i]);
}
}
long long ans = dp.query(1, m, m);
if (ans <= 5e14)
cout << "YES\n" << ans << "\n";
else
cout << "NO\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void checkmin(T &a, const T &b) {
if (b < a) a = b;
}
template <class T>
inline void checkmax(T &a, const T &b) {
if (b > a) a = b;
}
const long long inf = 1e18 + 10;
const int maxn = 5e5 + 10;
long long bit[maxn];
int n, m;
long long sum(int i) {
i++;
long long res = 0;
while (i >= 1) {
res += bit[i];
i -= i & -i;
}
return res;
}
void add(int i, long long x) {
i++;
while (i < maxn) {
bit[i] += x;
i += i & -i;
}
}
int a[maxn], b[maxn], prv[maxn], inv[maxn];
long long p[maxn], cost[maxn], dp[maxn];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < n; i++) a[i]--;
for (int i = 0; i < n; i++) scanf("%lld", &p[i]);
scanf("%d", &m);
for (int i = 0; i < m; i++) scanf("%d", &b[i]);
for (int i = 0; i < m; i++) b[i]--;
for (int i = 0; i < maxn; i++) prv[i] = -1;
for (int i = 1; i < m; i++) prv[b[i]] = b[i - 1];
for (int i = 0; i < maxn; i++) cost[i] = 0;
long long res = 0;
for (int i = 0; i < n; i++) {
int now = a[i];
cost[i] += sum(now) - sum(prv[now]);
if (p[i] < 0) {
res += p[i];
cost[i] -= p[i];
} else {
add(a[i], p[i]);
}
}
res += sum(n) - sum(b[m - 1]);
for (int i = 0; i < maxn; i++) dp[i] = inf + inf;
dp[0] = 0ll;
for (int i = 0; i < maxn; i++) inv[i] = -1;
for (int i = 0; i < m; i++) inv[b[i]] = i;
for (int i = 0; i < n; i++) {
int idx = inv[a[i]];
if (idx < 0) continue;
dp[idx + 1] = min(dp[idx + 1], dp[idx] + cost[i]);
}
res += dp[m];
if (res >= inf) {
printf("NO\n");
} else {
printf("YES\n");
printf("%lld\n", res);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
long long A[500005], P[500005];
long long B[500005];
long long pickTree[500005], negativeTree[500005];
vector<long long> num[500005];
void update(long long *Tree, long long node, long long val) {
while (node < 500005) {
Tree[node] += val;
node += node & (-node);
}
}
long long query(long long *Tree, long long node) {
long long sum = 0;
while (node) {
sum += Tree[node];
node -= node & (-node);
}
return sum;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> A[i];
num[A[i]].push_back(i);
}
for (int i = 1; i <= n; i++) {
cin >> P[i];
update(pickTree, i, P[i]);
}
cin >> m;
for (int i = 1; i <= m; i++) {
cin >> B[i];
}
vector<pair<long long, long long>> vt[2];
int dir = 0;
vt[dir].push_back(make_pair(0, 0));
long long bef = 0;
for (int i = 1; i <= m; i++) {
vt[dir ^ 1].clear();
if (vt[dir].size() == 0) {
cout << "NO" << endl;
return 0;
}
for (int j = 0; j < vt[dir].size(); j++) {
long long val = query(pickTree, vt[dir][j].first);
vt[dir][j].second -= val;
}
long long prevPos = 0, res = 1e18;
for (int p1 = 0, p2 = 0; p1 < num[B[i]].size(); p1++) {
while (p2 < vt[dir].size() && vt[dir][p2].first < num[B[i]][p1]) {
res += query(negativeTree, vt[dir][p2].first) -
query(negativeTree, prevPos);
res = min(res, vt[dir][p2].second);
prevPos = vt[dir][p2].first;
++p2;
}
res += query(negativeTree, num[B[i]][p1]) - query(negativeTree, prevPos);
long long newRes = res + query(pickTree, num[B[i]][p1] - 1);
if (p2) vt[dir ^ 1].push_back(make_pair(num[B[i]][p1], newRes));
prevPos = num[B[i]][p1];
if (P[num[B[i]][p1]] > 0) res -= P[num[B[i]][p1]];
}
while (bef <= B[i]) {
for (int j = 0; j < num[bef].size(); j++) {
update(pickTree, num[bef][j], -P[num[bef][j]]);
if (P[num[bef][j]] < 0)
update(negativeTree, num[bef][j], P[num[bef][j]]);
}
++bef;
}
dir ^= 1;
}
if (vt[dir].size() == 0) {
cout << "NO" << endl;
return 0;
}
long long Ans = 2e18, lol = 0;
for (int i = vt[dir].size() - 1, j = n; i >= 0; i--) {
while (j >= 1 && j > vt[dir][i].first) {
if (A[j] > B[m]) lol += P[j];
if (A[j] <= B[m] && P[j] < 0) lol += P[j];
--j;
}
Ans = min(Ans, vt[dir][i].second + lol);
if (A[vt[dir][i].first] < 0) lol += P[vt[dir][i].first];
}
cout << "YES " << endl << Ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void read(int &val) {
int x = 0;
int bz = 1;
char c;
for (c = getchar(); (c < '0' || c > '9') && c != '-'; c = getchar())
;
if (c == '-') {
bz = -1;
c = getchar();
}
for (; c >= '0' && c <= '9'; c = getchar()) x = x * 10 + c - 48;
val = x * bz;
}
const int INF = 0x3f3f3f3f;
const int mod = 998244353;
const int maxn = 5e5 + 10;
long long val[maxn << 2], lz[maxn << 2];
void pd(int root) {
if (lz[root] == 0) return;
val[root << 1] += lz[root];
val[root << 1 | 1] += lz[root];
lz[root << 1] += lz[root];
lz[root << 1 | 1] += lz[root];
lz[root] = 0;
}
void upd(int root, int l, int r, int L, int R, long long add) {
if (L <= l && r <= R) {
val[root] += add, lz[root] += add;
return;
}
if (L > r || R < l) return;
pd(root);
int mid = l + r >> 1;
upd(root << 1, l, mid, L, R, add);
upd(root << 1 | 1, mid + 1, r, L, R, add);
}
long long qu(int root, int l, int r, int pos) {
if (l == r) {
return val[root];
}
pd(root);
int mid = l + r >> 1;
if (pos <= mid)
return qu(root << 1, l, mid, pos);
else
return qu(root << 1 | 1, mid + 1, r, pos);
}
void bd(int root, int l, int r) {
val[root] = 1LL << 60;
if (l == r) {
if (l == 0) val[root] = 0;
return;
}
int mid = l + r >> 1;
bd(root << 1, l, mid);
bd(root << 1 | 1, mid + 1, r);
}
int n, m;
int a[maxn], p[maxn], b[maxn];
int main() {
read(n);
for (int i = 1; i <= n; i++) read(a[i]);
for (int i = 1; i <= n; i++) read(p[i]);
read(m);
for (int i = 1; i <= m; i++) read(b[i]);
b[m + 1] = 1 << 30;
bd(1, 0, m);
for (int i = 1; i <= n; i++) {
int pos = lower_bound(b + 1, b + 1 + m, a[i]) - b;
if (a[i] == b[pos]) {
upd(1, 0, m, pos + 1, m, min(p[i], 0));
long long a = qu(1, 0, m, pos);
long long x = a + min(p[i], 0), y = qu(1, 0, m, pos - 1);
upd(1, 0, m, pos, pos, min(x, y) - a);
upd(1, 0, m, 0, pos - 1, p[i]);
} else {
upd(1, 0, m, pos, m, min(p[i], 0));
upd(1, 0, m, 0, pos - 1, p[i]);
}
}
long long ans = qu(1, 0, m, m);
if (ans >= (1LL << 55))
puts("NO");
else
printf("YES\n%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll INF = 1LL << 50;
const int N = 5e5 + 5;
struct FenwickTree {
ll t[N + 2];
void add(int i, int n, ll delta) {
for (i = i + 1; i <= n + 1; i += i & -i) {
t[i] += delta;
}
}
void add(int l, int r, int n, int delta) {
add(l, n, delta);
add(r + 1, n, -delta);
}
ll getsum(int i) {
ll res = 0;
for (i = i + 1; i > 0; i -= i & -i) {
res += t[i];
}
return res;
}
ll get(int i) { return getsum(i) - getsum(i - 1); }
};
FenwickTree ft, ft2;
void solve() {
int n;
cin >> n;
vector<int> a(n);
for (auto& x : a) {
cin >> x;
}
vector<ll> p(n);
for (auto& x : p) {
cin >> x;
}
int m;
cin >> m;
vector<int> b(m + 1);
for (int i = 1; i <= m; ++i) {
cin >> b[i];
}
for (int i = 1; i <= m; ++i) {
ft.add(i, m, INF);
}
int k = 0;
for (int i = 0; i < n; ++i) {
int x = lower_bound(b.begin(), b.end(), a[i]) - b.begin();
int y = x;
if (x <= k + 1 && b[x] == a[i]) {
ll dpi = ft.get(x) + ft2.getsum(x);
ll dpj = ft.get(x - 1) + ft2.getsum(x - 1);
ll ndpi = min(dpi + min(0LL, p[i]), dpj);
ft.add(x, m, ndpi - dpi);
k = max(k, x);
++y;
}
ft2.add(0, x - 1, m, p[i]);
ft2.add(y, k, m, min(0LL, p[i]));
}
if (k < m) {
cout << "NO";
} else {
cout << "YES\n";
cout << ft.get(m) + ft2.getsum(m);
}
}
int main() {
ios::sync_with_stdio(NULL), cin.tie(0), cout.tie(0);
cout.setf(ios::fixed), cout.precision(20);
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename _T>
inline void read(_T &f) {
f = 0;
_T fu = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') {
fu = -1;
}
c = getchar();
}
while (c >= '0' && c <= '9') {
f = (f << 3) + (f << 1) + (c & 15);
c = getchar();
}
f *= fu;
}
template <typename T>
void print(T x) {
if (x < 0) putchar('-'), x = -x;
if (x < 10)
putchar(x + 48);
else
print(x / 10), putchar(x % 10 + 48);
}
template <typename T>
void print(T x, char t) {
print(x);
putchar(t);
}
const int N = 5e5 + 5;
long long f[N];
int a[N], p[N], b[N], pos[N];
int n, m;
inline int lowbit(int x) { return x & -x; }
inline void add(int x, long long y) {
++x;
while (x <= m + 1) {
f[x] += y;
x += lowbit(x);
}
}
inline long long query(int x) {
++x;
long long ans = 0;
while (x) {
ans += f[x];
x ^= lowbit(x);
}
return ans;
}
inline void add(int l, int r, long long x) {
add(l, x);
add(r + 1, -x);
}
inline void setv(int x, long long y) {
long long det = y - query(x);
add(x, x, det);
}
int main() {
read(n);
for (int i = 1; i <= n; i++) read(a[i]);
for (int i = 1; i <= n; i++) read(p[i]);
read(m);
for (int i = 1; i <= m; i++) read(b[i]);
b[m + 1] = 2e9;
add(1, m, 1e17);
for (int i = 1; i <= n; i++) {
int pos = upper_bound(b + 1, b + m + 2, a[i]) - b - 1;
long long val;
if (a[i] == b[pos]) val = query(pos - 1);
if (p[i] <= 0)
add(0, m, p[i]);
else
add(0, pos - (a[i] == b[pos]), p[i]);
if (a[i] == b[pos]) {
if (query(pos) > val) setv(pos, val);
}
}
long long ans = query(m);
if (ans < 1e15)
printf("YES\n"), print(ans, '\n');
else
printf("NO\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class IT>
inline void cmax(IT &a, IT b) {
if (a < b) a = b;
}
template <class IT>
inline void cmin(IT &a, IT b) {
if (b < a) a = b;
}
const int N = 500005;
int a[N], p[N], b[N];
long long dp[N];
vector<int> e1[N], e2[N];
pair<int, int> x[N];
long long tre[N];
inline void add(int a, long long b) {
for (; a < N; a += a & -a) tre[a] += b;
}
inline long long que(int a) {
long long b = 0ll;
for (; a; a -= a & -a) b += tre[a];
return b;
}
int main() {
int n, m, i, j, d;
long long sp = 0ll, t;
scanf("%d", &n);
for (i = (1); i <= (n); ++i) scanf("%d", &a[i]);
for (i = (1); i <= (n); ++i) scanf("%d", &p[i]), sp += p[i];
scanf("%d", &m);
for (i = (1); i <= (m); ++i) scanf("%d", &b[i]);
e1[0].push_back(0);
for (i = (1); i <= (n); ++i) {
d = lower_bound(b + 1, b + m + 1, a[i]) - b;
if (b[d] == a[i]) e1[d].push_back(i);
if (d <= m && p[i] > 0) e2[d].push_back(i);
}
e1[++m].push_back(n);
for (i = (1); i <= (m); ++i) {
t = -1000000000000000000ll;
d = 0;
for (j = (0); j < (e1[i - 1].size()); ++j)
x[++d] = make_pair(e1[i - 1][j], 0);
for (j = (0); j < (e1[i].size()); ++j) x[++d] = make_pair(e1[i][j], 1);
sort(x + 1, x + d + 1);
for (j = (1); j <= (d); ++j) {
if (x[j].second)
dp[x[j].first] = t + que(x[j].first) + p[x[j].first];
else
cmax(t, dp[x[j].first] - que(x[j].first));
fprintf(stderr, "(%d,%d) Q %lld DP %lld\n", x[j].first, x[j].second,
que(x[j].first), dp[x[j].first]);
}
fprintf(stderr, "AFTER %d\n", i);
for (j = (1); j <= (d); ++j)
if (x[j].second)
fprintf(stderr, "DP %d = %lld\n", x[j].first, dp[x[j].first]);
for (j = (0); j < (e2[i].size()); ++j)
fprintf(stderr, "ADD %d %d\n", e2[i][j], p[e2[i][j]]);
for (j = (0); j < (e2[i].size()); ++j) add(e2[i][j], p[e2[i][j]]);
}
sp = sp - dp[n] + p[n];
if (sp < 1000000000000000ll)
printf("YES\n%lld", sp);
else
printf("NO");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e18;
inline long long read() {
long long num = 0, fu = 1;
char c = getchar();
while (c != '-' && (c > '9' || c < '0')) c = getchar();
if (c == '-') fu = -1, c = getchar();
while (c >= '0' && c <= '9')
num = (num << 3) + (num << 1) + (c ^ 48), c = getchar();
return fu * num;
}
long long n, m, a[500010], p[500010], b[500010], f[500010], c[500010],
bt[500010], ans = -inf, Sum;
inline long long lowbit(long long x) { return x & (-x); }
inline void update(long long x, long long k) {
for (; x <= n; x += lowbit(x)) c[x] += k;
}
inline long long query(long long x) {
long long res = 0;
for (; x; x -= lowbit(x)) res += c[x];
return res;
}
bool dfs(long long x, long long now) {
if (now > n && x <= m) return 0;
if (x > m) return 1;
if (a[now] == b[x])
dfs(x + 1, now + 1);
else
dfs(x, now + 1);
}
signed main() {
n = read();
for (long long i = 1; i <= n; i++) a[i] = read();
for (long long i = 1; i <= n; i++) p[i] = read(), Sum += p[i];
m = read();
for (long long i = 1; i <= m; i++) b[i] = read();
if (!dfs(1, 1)) {
puts("NO");
return 0;
}
update(1, -inf);
for (long long i = 1; i <= n; i++) {
long long j = std::lower_bound(b + 1, b + 1 + m, a[i]) - b;
if (j <= m && b[j] == a[i]) {
if (j == 1)
f[i] = p[i];
else {
f[i] = p[i] + query(b[j - 1]);
}
} else
f[i] = -inf;
if (p[i] > 0) update(a[i], p[i]);
long long tmp = query(a[i]);
if (f[i] > tmp) {
update(a[i], f[i] - tmp);
update(a[i] + 1, tmp - f[i]);
}
}
ans = query(b[m]);
printf("YES\n%lld\n", Sum - ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 5e5 + 5;
const long long INF = 1e18;
long long n, m, a[N], b[N], p[N], pre[N], num[N];
long long tree[N], dp[N], cost[N], ans;
inline long long lowbit(long long x) { return x & (-x); }
long long ask(long long x) {
long long res = 0;
while (x) {
res += tree[x];
x -= lowbit(x);
}
return res;
}
void update(long long x, long long y) {
while (x <= n) {
tree[x] += y;
x += lowbit(x);
}
}
signed main() {
cin >> n;
for (long long i = 1; i <= n; i++) cin >> a[i];
for (long long i = 1; i <= n; i++) cin >> p[i];
cin >> m;
for (long long i = 1; i <= m; i++) cin >> b[i], num[b[i]] = i;
for (long long i = 2; i <= m; i++) pre[b[i]] = b[i - 1];
for (long long i = 1; i <= n; i++) {
cost[i] = ask(a[i]) - ask(pre[a[i]]);
if (p[i] < 0) {
ans += p[i];
cost[i] -= p[i];
} else
update(a[i], p[i]);
}
ans += ask(n) - ask(b[m]);
for (long long i = 1; i <= m; i++) dp[i] = INF;
for (long long i = 1; i <= n; i++) {
if (num[a[i]] < 0) continue;
dp[num[a[i]]] = min(dp[num[a[i]]], dp[num[a[i]] - 1] + cost[i]);
}
if (dp[m] == INF)
cout << "NO\n";
else
cout << "YES\n" << ans + dp[m] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, a[1000005], b[1000005], c[1000005], p[1000005], dp[1000005],
neg[1000005];
vector<long long> vc[1000005], sum[1000005];
long long get(long long val, long long id) {
long long i =
lower_bound(vc[val].begin(), vc[val].end(), id) - vc[val].begin();
return sum[val][i];
}
int main() {
cin >> n;
for (long long i = (1); i <= (n); ++i) cin >> a[i];
for (long long i = (1); i <= (n); ++i) {
cin >> p[i];
neg[i] = neg[i - 1];
if (p[i] < 0) neg[i] += p[i];
}
cin >> m;
for (long long i = (1); i <= (m); ++i) cin >> b[i];
for (long long i = (1); i <= (n); ++i) {
long long tt = lower_bound(b + 1, b + m + 1, a[i]) - b;
if (b[tt] == a[i])
c[i] = 2 * tt;
else
c[i] = 2 * tt - 1;
vc[c[i]].push_back(i);
}
for (long long i = (0); i <= (2 * m + 2); ++i)
for (long long j = (1); j <= (vc[i].size() + 5); ++j) sum[i].push_back(0);
for (long long i = (0); i <= (2 * m + 2); ++i)
for (long long j = (1); j <= (vc[i].size()); ++j) {
sum[i][j] = sum[i][j - 1];
if (p[vc[i][j - 1]] > 0) sum[i][j] += p[vc[i][j - 1]];
}
n++;
c[n] = 2 * m + 2;
vc[0].push_back(0);
for (long long i = (1); i <= (n); ++i) {
if (c[i] % 2) {
dp[i] = 1e15;
continue;
}
auto it = lower_bound(vc[c[i] - 2].begin(), vc[c[i] - 2].end(), i);
if (it == vc[c[i] - 2].begin()) {
dp[i] = 1e15;
continue;
}
it--;
dp[i] = dp[*it] + get(c[i] - 1, i) + get(c[i], i) + neg[i - 1] - neg[*it];
it = lower_bound(vc[c[i]].begin(), vc[c[i]].end(), i);
if (it != vc[c[i]].begin()) {
--it;
dp[i] = min(dp[i], dp[*it] + neg[i] - neg[*it]);
}
}
if (dp[n] >= 1e15 / 2)
cout << "NO";
else
cout << "YES\n" << dp[n];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
long long R = 7 + 1e9, NUMTESTCASE;
const long long NN = 10 + 1e6;
const double pi = acos(-1.0);
int di[8] = {1, 0, -1, 0, 1, -1, 1, -1}, dj[8] = {0, 1, 0, -1, 1, -1, -1, 1};
long long Bit[NN], Cost[NN], Memo[NN];
int n, m, Brr[NN], x, Cnt[NN], Next[NN], Adj[NN];
vector<int> Pos[NN];
long long Memo2[NN];
void Update(int Node, int Val) {
while (Node <= n) {
Bit[Node] += Val;
Node += Node & (-Node);
}
}
long long Sum(int Node) {
long long Res = 0;
while (Node) {
Res += Bit[Node];
Node -= Node & (-Node);
}
return Res;
}
void EndPrg() {
for (int i = (1); i <= (n); ++i) {
for (int u : Pos[i])
if (Cost[u] < 0) Update(u, Cost[u]);
if (!Cnt[i]) continue;
for (int u : Pos[i]) Memo[u] = Sum(n) - Sum(u);
for (int j = i; j >= 1; j--) {
if (Cnt[j] && j != i) break;
for (int u : Pos[j])
if (Cost[u] < 0) Update(u, -Cost[u]);
}
}
for (int i = (1); i <= (n); ++i)
if (Cnt[i])
for (int u : Pos[i]) Memo[u] += Cost[u], Memo2[u] = Memo[u];
for (int Index = m, Limit = n; Index >= 1; Index--) {
while (true) {
if (!Pos[Brr[Index]].size() || Cnt[Brr[Index]] > 1) exit(puts("NO"));
if (Pos[Brr[Index]].back() > Limit)
Pos[Brr[Index]].pop_back();
else
break;
}
Limit = Pos[Brr[Index]].back();
}
}
void BuildNext() {
for (int Curr = n, Last = -1, k, u; Curr >= 1; Curr--) {
if (!Cnt[Curr]) continue;
if (Last == -1) {
Last = Curr;
continue;
}
k = Pos[Last].size() - 1;
for (int i = Pos[Curr].size() - 1; i >= 0; i--) {
u = Pos[Curr][i];
k += 2;
if (k >= Pos[Last].size()) k = Pos[Last].size() - 1;
while (k >= 0 && Pos[Last][k] > u) Next[u] = Pos[Last][k--];
}
Last = Curr;
}
for (int u = (1); u <= (n); ++u)
if (Cnt[u])
for (int i = 1; i < Pos[u].size(); i++) Adj[Pos[u][i - 1]] = Pos[u][i];
}
bool Vis[NN], Final[NN];
long long Dp(int u) {
if (u == Pos[Brr[m]].back()) return Memo[u];
if (u <= 0) return 1e18;
long long &Res = Memo2[u];
if (Vis[u]) return Res;
Vis[u] = true;
if (Final[u]) return Res = min(Memo[u], Dp(Adj[u]));
return Res = min(Dp(Adj[u]), Memo[u] + Dp(Next[u]));
}
int main() {
cin >> n;
for (int i = (1); i <= (n); ++i) scanf("%d", &x), Pos[x].push_back(i);
for (int i = (1); i <= (n); ++i) scanf("%lld", Cost + i), Cost[i] *= -1;
cin >> m;
for (int i = (1); i <= (m); ++i) scanf("%d", Brr + i), Cnt[Brr[i]]++;
EndPrg();
BuildNext();
for (int u : Pos[Brr[m]]) Final[u] = true;
long long Ans = 0;
for (int i = (1); i <= (n); ++i) Ans += -Cost[i];
cout << "YES\n" << Ans + Dp(Pos[Brr[1]][0]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char buf[1 << 21], *p1 = buf, *p2 = buf, obuf[1 << 23], *O = obuf;
inline int read() {
int x = 0, sign = 0;
char s = getchar();
while (!isdigit(s)) sign |= s == '-', s = getchar();
while (isdigit(s)) x = (x << 1) + (x << 3) + (s - '0'), s = getchar();
return sign ? -x : x;
}
void print(int x) {
if (x > 9) print(x / 10);
(*O++ = x % 10 + '0');
}
const int N = 5e5 + 5;
vector<int> buc[N];
long long n, m, a[N], b[N], p[N], f[N], c[N];
void modify(int x, int v) {
while (x <= n) c[x] += v, x += x & -x;
}
long long query(int x) {
long long ans = 0;
while (x) ans += c[x], x -= x & -x;
return ans;
}
long long cal(int l, int r) { return query(r) - query(l - 1); }
int main() {
n = read() + 1, memset(f, 0x3f, sizeof(f)), f[0] = 0;
for (int i = 1; i < n; i++) a[i] = read(), buc[a[i]].push_back(i);
buc[0].push_back(0), buc[n].push_back(n);
for (int i = 1; i < n; i++) p[i] = read(), modify(i, p[i]);
b[m = read() + 1] = n;
for (int i = 1; i < m; i++) b[i] = read();
for (int i = 1; i <= m; i++) {
if (i > 1)
for (int j = b[i - 2] + 1; j <= b[i - 1]; j++)
for (int k : buc[j])
if (p[k] > 0) modify(k, -p[k]);
int pos = -1, sz = buc[b[i - 1]].size() - 1;
for (int j = 0; j < buc[b[i]].size(); j++) {
int k = buc[b[i]][j];
if (j) f[k] = f[buc[b[i]][j - 1]] + cal(buc[b[i]][j - 1], k - 1);
while (pos < sz && buc[b[i - 1]][pos + 1] < k) {
int l = buc[b[i - 1]][++pos];
f[k] = min(f[k], f[l] + cal(l + 1, k - 1));
}
}
}
if (f[n] < 1e16)
printf("YES\n%lld\n", f[n]);
else
puts("NO");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int64_t n, a[500005], p[500005], m, b[500005];
int64_t dp[500005];
int64_t cost[500005];
signed main() {
if (false) {
} else {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
cin >> n;
for (int64_t i = 0; i < n; i++) cin >> a[i];
for (int64_t i = 0; i < n; i++) cin >> p[i];
cin >> m;
for (int64_t i = 0; i < m; i++) cin >> b[i];
b[m] = 1152921504606847000L;
for (int64_t i = 0; i < n; i++) {
int64_t at = lower_bound(b, b + m + 1, a[i]) - b;
if (p[i] < 0 || at == m) cost[at] += p[i];
}
for (int64_t i = 0; i < m + 1; i++) dp[i] = 1152921504606847000L;
dp[0] = 0;
for (int64_t i = 0; i < n; i++) {
int64_t at = lower_bound(b, b + m + 1, a[i]) - b;
if (at < m) {
if (a[i] == b[at]) {
if (p[i] < 0)
dp[at + 1] = min(dp[at + 1], dp[at] + cost[at] - p[i]);
else
dp[at + 1] = min(dp[at + 1], dp[at] + cost[at]);
}
if (p[i] > 0) cost[at] += p[i];
}
if (false) {
cout << "after step " << i << endl;
printf("\ta[%ld] = %ld\n", i, a[i]);
printf("\tp[%ld] = %ld\n", i, p[i]);
printf("\tat = %ld\n", at);
cout << "\tdp = [";
for (int64_t j = 0; j < m + 1; j++) {
if (j != 0) cout << ",";
cout << dp[j];
}
cout << "]" << endl;
cout << "\tcost = [";
for (int64_t j = 0; j < m + 1; j++) {
if (j != 0) cout << ",";
cout << cost[j];
}
cout << "]" << endl;
}
}
if (dp[m] > 1000000000000000000L) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
cout << (dp[m] + cost[m]) << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<int> a, b, cost;
map<int, vector<int> > pos_at_value;
bool valid() {
int cur = 0;
for (int x : a) {
if (b[cur] == x) cur++;
if (cur >= m) {
return 1;
}
}
return 0;
}
struct BinaryIndexedTree {
long long T[500005] = {0};
void add(int x, long long v) {
for (++x; x < 500005; x += x & -x) T[x] += v;
}
long long sum(int x) {
long long ret = 0;
for (++x; x; x -= x & -x) ret += T[x];
return ret;
}
};
long long T[500005 << 2];
int leaf[500005 + 5];
void build(int id = 1, int l = 0, int r = 500005) {
T[id] = 0x3f3f3f3f3f3f3f3f;
if (l + 1 == r) {
leaf[l] = id;
return;
}
build(id << 1, l, l + r >> 1);
build(id << 1 | 1, l + r >> 1, r);
}
void update(int x, long long val) {
T[leaf[x]] = val;
for (int cur = leaf[x] / 2; cur; cur /= 2) {
T[cur] = min(T[cur * 2], T[cur * 2 + 1]);
}
}
long long ask(int x, int y, int id = 1, int l = 0, int r = 500005) {
if (y <= l || r <= x) return 0x3f3f3f3f3f3f3f3f;
if (x <= l && r <= y) return T[id];
return min(ask(x, y, id << 1, l, l + r >> 1),
ask(x, y, id << 1 | 1, l + r >> 1, r));
}
void solve() {
cin >> n;
a.resize(n), cost.resize(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
pos_at_value[a[i]].push_back(i);
}
for (int i = 0; i < n; i++) cin >> cost[i];
cin >> m;
b.resize(n);
for (int i = 0; i < m; i++) cin >> b[i];
if (not valid()) {
cout << "NO\n";
return;
} else {
cout << "YES\n";
}
BinaryIndexedTree ps;
build();
deque<pair<int, int> > q;
for (int i = 0; i < n; i++) {
ps.add(i, cost[i]);
q.push_back(make_pair(a[i], i));
}
sort(q.begin(), q.end());
vector<pair<int, long long> > prev_candidates;
for (int iter = 0; iter < m; iter++) {
int target = b[iter];
if (0) cerr << "cur " << target << '\n';
for (auto op : prev_candidates) {
if (0)
cerr << " update " << op.first << ' ' << op.second << '-'
<< ps.sum(op.first) << ' ' << op.second - ps.sum(op.first) << '\n';
update(op.first, op.second - ps.sum(op.first));
}
vector<pair<int, long long> > cur_candidates;
for (int pos : pos_at_value[target]) {
cur_candidates.push_back({pos, ps.sum(pos - 1) + !!iter * ask(0, pos)});
if (0) cerr << " ps " << ps.sum(pos - 1) << '\n';
if (0)
cerr << " candidate " << pos << ' '
<< ps.sum(pos - 1) + !!iter * ask(0, pos) << '\n';
}
for (auto op : prev_candidates) {
update(op.first, 0x3f3f3f3f3f3f3f3f);
}
swap(cur_candidates, prev_candidates);
while (q.size() && q.front().first <= target) {
int pos = q.front().second;
if (cost[pos] > 0) {
ps.add(pos, -cost[pos]);
if (0)
cerr << " remove " << pos << ' ' << a[pos] << ' ' << -cost[pos]
<< '\n';
}
q.pop_front();
}
}
long long ans = 0x3f3f3f3f3f3f3f3f;
for (auto op : prev_candidates)
ans = min(ans, op.second + ps.sum(n - 1) - ps.sum(op.first));
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t = 1;
for (int no = 1; no <= t; no++) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const double pi = 2 * acos(0.0);
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, -1, 0, 1};
const int dx8[] = {-1, 0, 1, 0, 1, 1, -1, -1};
const int dy8[] = {0, -1, 0, 1, 1, -1, 1, -1};
long long min(long long a, long long b) {
if (a < b) return a;
return b;
}
long long max(long long a, long long b) {
if (a > b) return a;
return b;
}
long long ceil1(long long a, long long b) { return (a + b - 1) / b; }
vector<vector<long long>> sum, occ;
vector<vector<long long>> occurence;
vector<long long> neg, neg_ind;
long long get(long long val, long long ind) {
if (occurence[val].size() == 0) return -1;
auto i = lower_bound(occurence[val].begin(), occurence[val].end(), ind) -
occurence[val].begin();
i--;
if (i < 0) return -1;
return occurence[val][i];
}
long long geti(long long val, long long ind) {
if (occ[val].size() == 0) return -1;
auto i =
lower_bound(occ[val].begin(), occ[val].end(), ind) - occ[val].begin();
i--;
if (i < 0) return -1;
return i;
}
long long gets(long long ind, long long val) {
auto i = geti(val, ind);
if (i == -1) return 0;
return sum[val][i];
}
void dbg() {
long long x;
x = 5;
}
long long getn(long long l, long long r) {
if (int(neg.size()) == 0) return 0;
if (l > r) return 0;
auto i2 = upper_bound(neg_ind.begin(), neg_ind.end(), r) - neg_ind.begin();
i2--;
if (i2 < 0) return 0;
long long ans = neg[i2];
auto i1 = lower_bound(neg_ind.begin(), neg_ind.end(), l) - neg_ind.begin();
i1--;
if (i1 >= 0) ans -= neg[i1];
return ans;
}
void solve() {
long long n, m;
cin >> n;
n += 2;
vector<long long> a(n);
vector<long long> ct(n);
for (long long i = 1; i < n - 1; i++) cin >> a[i];
for (long long i = 1; i < n - 1; i++) cin >> ct[i];
a[n - 1] = n + 1;
cin >> m;
m += 2;
vector<long long> b(m);
for (long long i = 1; i < m - 1; i++) cin >> b[i];
b[m - 1] = n + 1;
for (long long i = 0; i < n; i++) {
auto ind = lower_bound(b.begin(), b.end(), a[i]) - b.begin();
if (ind == m) {
a[i] = 2 * m - 1;
continue;
}
if (a[i] == b[ind])
a[i] = 2 * ind;
else
a[i] = 2 * ind - 1;
}
occ = vector<vector<long long>>(3 * n);
sum = vector<vector<long long>>(3 * n);
neg.clear();
neg_ind.clear();
occurence = vector<vector<long long>>(3 * n);
vector<vector<long long>>& debocc = occurence;
vector<vector<long long>>& debsum = sum;
vector<long long>& deneg = neg;
vector<long long>& deneg_ind = neg_ind;
for (long long i = 0; i < n; i++) {
occurence[a[i]].push_back(i);
if (ct[i] < 0) {
neg_ind.push_back(i);
long long x = 0;
if (int(neg.size()) > 0) x = neg.back();
neg.push_back(x + ct[i]);
} else {
occ[a[i]].push_back(i);
long long x = 0;
if (int(sum[a[i]].size()) > 0) x = sum[a[i]].back();
sum[a[i]].push_back(x + ct[i]);
}
}
vector<long long> dp(n, 1e18);
dp[0] = 0;
for (long long i = 1; i < n; i++) {
long long x = i;
if (a[i] % 2 == 0) {
auto jx = get(a[i] - 2, i);
long long y = getn(jx + 1, i - 1);
if (jx != -1) {
dp[x] = min(dp[x], dp[jx] + gets(i, a[i]) + gets(i, a[i] - 1) +
getn(jx + 1, i - 1));
}
auto px = get(a[i], i);
if (px != -1) {
dp[x] = min(dp[x], dp[px] + getn(px + 1, x));
}
dbg();
}
}
long long last = 2 * m - 2;
auto ans = dp[occ[last].back()];
if (ans >= 1e17)
cout << "NO" << '\n';
else {
cout << "YES" << '\n';
cout << dp[occ[last].back()] << '\n';
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ii = pair<int, int>;
using vi = vector<int>;
using vll = vector<ll>;
using vii = vector<ii>;
const ll MOD = 998244353;
const ll INF = 1e15 + 9;
const int MAXN = 1000006;
int n, m, a[MAXN], p[MAXN], b[MAXN];
int ind[MAXN], seen[MAXN];
vi pos[MAXN];
vll sum[MAXN];
ll dp[MAXN], negsum[MAXN];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
++n;
for (int i = 1; i < n; ++i) cin >> a[i];
for (int i = 1; i < n; ++i) cin >> p[i];
cin >> m;
++m;
for (int i = 1; i < m; ++i) cin >> b[i];
a[n] = n;
b[m] = n;
++n, ++m;
for (int i = 0, j = 0; i < m; ++i) {
while (j < b[i]) ind[j++] = 2 * i - 1;
ind[j++] = 2 * i;
sum[2 * i] = sum[2 * i + 1] = vll(1);
}
for (int i = 0; i < n; ++i) {
a[i] = ind[a[i]];
pos[a[i]].push_back(i);
ll prevsum = sum[a[i]].back();
sum[a[i]].push_back(prevsum + max(p[i], 0));
negsum[i + 1] = negsum[i] + min(p[i], 0);
}
memset(seen, -1, sizeof seen);
memset(ind, 0, sizeof ind);
seen[0] = 0;
for (int i = 1; i < n; ++i) {
dp[i] = INF;
if ((a[i] & 1) == 0) {
if (int x = seen[a[i] - 2]; x != -1) {
dp[i] = dp[x] + sum[a[i] - 1][ind[a[i] - 1]] + sum[a[i]][ind[a[i]]] +
negsum[i] - negsum[x + 1];
if (x = seen[a[i]], x != -1)
dp[i] = min(dp[i], dp[x] + negsum[i + 1] - negsum[x + 1]);
}
}
seen[a[i]] = i;
ind[a[i]]++;
}
if (dp[n - 1] >= INF / 2)
cout << "NO\n";
else
cout << "YES\n" << dp[n - 1] << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ii = pair<int, int>;
using vi = vector<int>;
using vll = vector<ll>;
using vii = vector<ii>;
const ll MOD = 998244353;
const ll INF = 1e15 + 9;
const int MAXN = 1000006;
ll n, m, a[MAXN], p[MAXN], b[MAXN];
ll rev[MAXN];
vll pos[MAXN];
vll sum[MAXN];
ll dp[MAXN], negsum[MAXN];
inline ll isum(int val, int R) {
int index =
lower_bound(pos[val].begin(), pos[val].end(), R) - pos[val].begin();
return sum[val][index];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
}
for (int i = 1; i <= n; ++i) {
cin >> p[i];
}
cin >> m;
for (int i = 1; i <= m; ++i) {
cin >> b[i];
}
a[n + 1] = n + 1;
b[m + 1] = n + 1;
++n, ++m;
for (int i = 0; i <= m; ++i) {
sum[2 * i + 1] = sum[2 * i] = vll(1);
}
for (int i = 0; i <= n; ++i) {
int bi = lower_bound(b, b + m, a[i]) - b;
a[i] = 2 * bi - (b[bi] != a[i]);
pos[a[i]].push_back(i);
ll prevsum = sum[a[i]].back();
sum[a[i]].push_back(prevsum + max(p[i], 0ll));
negsum[i + 1] = negsum[i] + min(p[i], 0ll);
}
for (int i = 1; i <= n; ++i) {
if (a[i] & 1) {
dp[i] = INF;
continue;
}
auto it = lower_bound(pos[a[i] - 2].begin(), pos[a[i] - 2].end(), i);
if (it == pos[a[i] - 2].begin()) {
dp[i] = INF;
continue;
}
--it;
dp[i] = dp[*it] + isum(a[i] - 1, i) + isum(a[i], i) + negsum[i] -
negsum[*it + 1];
it = lower_bound(pos[a[i]].begin(), pos[a[i]].end(), i);
if (it != pos[a[i]].begin()) {
--it;
dp[i] = min(dp[i], dp[*it] + negsum[i + 1] - negsum[*it + 1]);
}
}
if (dp[n] >= INF / 2) {
cout << "NO\n";
} else {
cout << "YES\n" << dp[n] << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 2e18;
namespace seg {
const int N = 1 << 19;
long long T[2 * N];
void init() { fill(T + N + 1, T + 2 * N, inf); }
int ql, qr;
long long qv;
void _add(int i, int l, int r) {
if (l >= qr || r <= ql) return;
if (l >= ql && r <= qr) {
T[i] += qv;
return;
}
int m = (l + r) / 2;
_add(2 * i, l, m);
_add(2 * i + 1, m, r);
}
void add(int l, int r, long long v) {
ql = l;
qr = r, qv = v;
_add(1, 0, N);
}
long long get(int qi) {
int l = 0, r = N;
int i = 1;
long long ans = 0;
while (r - l > 1) {
ans += T[i];
int m = (l + r) / 2;
if (m > qi) {
i = 2 * i;
r = m;
} else {
i = 2 * i + 1;
l = m;
}
}
ans += T[i];
return ans;
}
} // namespace seg
int main() {
ios::sync_with_stdio(0), cin.tie(0);
int n;
cin >> n;
vector<int> a(n), p(n);
for (int& x : a) cin >> x;
for (int& x : p) cin >> x;
int m;
cin >> m;
deque<int> b(m);
for (int& x : b) cin >> x;
b.push_front(-1);
b.push_back(1e9 + 7);
seg::init();
for (int i = 0; i < n; i++) {
auto it = lower_bound(begin(b), end(b), a[i]);
int id = it - begin(b);
if (*it == a[i]) {
long long alt = seg::get(id - 1);
if (p[i] < 0) {
seg::add(0, m + 1, p[i]);
} else {
seg::add(0, id, p[i]);
}
long long cur = seg::get(id);
if (alt < cur) seg::add(id, id + 1, alt - cur);
} else {
if (p[i] < 0) {
seg::add(0, m + 1, p[i]);
} else {
seg::add(0, id, p[i]);
}
}
}
long long ans = seg::get(m);
if (ans > inf / 2)
cout << "NO\n";
else {
cout << "YES\n" << ans << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, t;
long long a[500005], p[500005], b[500005];
long long l, r;
void add(int &a, int b) {
a += b;
if (a >= 1000000007) a -= 1000000007;
}
void dec(int &a, int b) {
a -= b;
if (a < 0) a += 1000000007;
}
int pow_mod(int a, int i) {
int s = 1;
while (i) {
if (i & 1) s = 1LL * s * a % 1000000007;
a = 1LL * a * a % 1000000007;
i >>= 1;
}
return s;
}
struct segtree {
long long lazy[4 * 500005], val[4 * 500005];
void pushup(int k) { val[k] = min(val[k * 2], val[k * 2 + 1]); }
void add(int k, long long v) {
val[k] += v;
lazy[k] += v;
}
void pushdown(int k) {
for (int i = k * 2; i <= k * 2 + 1; i++) add(i, lazy[k]);
lazy[k] = 0;
}
void build(int k, int l, int r) {
lazy[k] = 0;
if (l == r) {
if (l == 0)
val[k] = 0;
else
val[k] = 1000000000000000000LL;
return;
}
int mid = (l + r) / 2;
build(k * 2, l, mid);
build(k * 2 + 1, mid + 1, r);
pushup(k);
}
void update(int k, int l, int r, int x, int y, long long v) {
if (l > y || x > r) return;
if (l >= x && r <= y) {
add(k, v);
return;
}
pushdown(k);
int mid = (l + r) / 2;
update(k * 2, l, mid, x, y, v);
update(k * 2 + 1, mid + 1, r, x, y, v);
pushup(k);
}
long long query(int k, int l, int r, int pos) {
if (l == r) return val[k];
pushdown(k);
int mid = (l + r) / 2;
if (pos <= mid)
return query(k * 2, l, mid, pos);
else
return query(k * 2 + 1, mid + 1, r, pos);
}
} seg;
vector<int> ans;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
for (int i = 1; i <= n; i++) scanf("%lld", &p[i]);
scanf("%d", &m);
for (int i = 1; i <= m; i++) scanf("%lld", &b[i]);
b[m + 1] = 1000000000000000000LL;
seg.build(1, 0, m);
for (int i = 1; i <= n; i++) {
int id = lower_bound(b, b + m + 2, a[i]) - b;
if (p[i] < 0) seg.update(1, 0, m, id, m, p[i]);
if (a[i] == b[id]) {
long long x = seg.query(1, 0, m, id - 1), y = seg.query(1, 0, m, id);
if (x < y) seg.update(1, 0, m, id, id, x - y);
}
seg.update(1, 0, m, 0, id - 1, p[i]);
}
long long ans = seg.query(1, 0, m, m);
if (ans >= 10000000000000000LL)
puts("NO");
else {
puts("YES");
printf("%lld\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ii = pair<int, int>;
using vi = vector<int>;
using vll = vector<ll>;
using vii = vector<ii>;
const ll MOD = 998244353;
const ll INF = 1e15 + 9;
const int MAXN = 1000006;
int n, m, a[MAXN], p[MAXN], b[MAXN];
int ind[MAXN], seen[MAXN];
ll dp[MAXN], sum[MAXN], negsum[MAXN];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
++n;
for (int i = 1; i < n; ++i) cin >> a[i];
for (int i = 1; i < n; ++i) cin >> p[i];
cin >> m;
++m;
for (int i = 1; i < m; ++i) cin >> b[i];
a[n] = n;
b[m] = n;
++n, ++m;
for (int i = 0, j = 0; i < m; ++i) {
while (j < b[i]) ind[j++] = 2 * i - 1;
ind[j++] = 2 * i;
}
for (int i = 0; i < n; ++i) {
a[i] = ind[a[i]];
sum[i] = sum[seen[a[i]]] + max(p[i], 0);
negsum[i + 1] = negsum[i] + min(p[i], 0);
seen[a[i]] = i;
}
memset(seen, -1, sizeof seen);
seen[0] = 0;
for (int i = 1; i < n; ++i) {
dp[i] = INF;
if ((a[i] & 1) == 0) {
if (seen[a[i] - 2] != -1) {
dp[i] = dp[seen[a[i] - 2]] + sum[seen[a[i] - 1]] + sum[seen[a[i]]] +
negsum[i] - negsum[seen[a[i] - 2] + 1];
if (seen[a[i]] != -1)
dp[i] = min(dp[i],
dp[seen[a[i]]] + negsum[i + 1] - negsum[seen[a[i]] + 1]);
}
}
seen[a[i]] = i;
}
if (dp[n - 1] >= INF / 2)
cout << "NO\n";
else
cout << "YES\n" << dp[n - 1] << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5e5 + 5;
const int M = 998244353;
const int modi6 = 166666668;
long long a[MAXN], p[MAXN], b[MAXN], bit[MAXN];
vector<int> v[MAXN];
long long dp[MAXN];
void update(int ind, long long val) {
for (; ind < MAXN; ind += (ind & -ind)) {
bit[ind] += val;
}
}
long long query(int ind) {
long long sum = 0;
for (; ind > 0; ind -= (ind & -ind)) {
sum += bit[ind];
}
return sum;
}
long long sum(int l, int r) { return query(r) - query(l - 1); }
int main() {
int n, m;
scanf("%d", &n);
long long tot = 0;
set<pair<long long, long long> > s;
for (int i = 1; i < n + 1; i++) {
scanf("%lld", &a[i]);
v[a[i]].push_back(i);
dp[i] = LONG_LONG_MIN;
}
for (int i = 1; i < n + 1; i++) {
scanf("%lld", &p[i]);
tot += p[i];
s.insert({a[i], i});
}
scanf("%d", &m);
for (int i = 1; i < m + 1; i++) {
scanf("%lld", &b[i]);
}
for (int i = 1; i < n + 1; i++) {
if (a[i] == b[1]) {
dp[i] = p[i];
}
}
for (int i = 2; i <= m; i++) {
vector<int> v1;
long long currsum = LONG_LONG_MIN;
int flag = 0;
while (!s.empty()) {
auto it = *s.begin();
if (it.first <= b[i - 1]) {
s.erase(s.begin());
if (p[it.second] >= 0) {
update(it.second, p[it.second]);
}
} else {
break;
}
}
for (int x : v[b[i - 1]]) {
v1.push_back(x);
}
for (int x : v[b[i]]) {
v1.push_back(x);
}
sort(v1.begin(), v1.end());
int y1 = -1;
for (int y : v1) {
if (a[y] == b[i - 1]) {
if (currsum == LONG_LONG_MIN) {
currsum = dp[y];
y1 = y;
} else if (dp[y] == LONG_LONG_MIN) {
} else {
currsum = max(currsum + sum(y1 + 1, y), dp[y]);
y1 = y;
}
} else {
if (currsum == LONG_LONG_MIN) {
} else {
dp[y] = currsum + sum(y1 + 1, y) + p[y];
flag = 1;
}
}
}
}
int flag = 1;
long long sum1 = 0;
long long ans = LONG_LONG_MIN;
for (int i = n; i >= 0; i--) {
if (a[i] == b[m] && dp[i] != LONG_LONG_MIN) {
ans = max(ans, dp[i] + sum1);
flag = 0;
}
if (a[i] <= b[m]) {
sum1 += max(p[i], 0ll);
}
}
if (flag) {
printf("NO\n");
} else {
printf("YES\n");
cout << tot - ans;
}
return 0;
}
|
#include <bits/stdc++.h>
struct IO {
IO(FILE *in = stdin) : in(in) {}
int next_char() {
if (position == length) {
position = 0, length = fread(buffer, 1, LENGTH, in);
}
if (position == length) {
eof = true;
return -1;
}
return buffer[position++];
}
int next_uint() {
int c = next_char(), x = 0;
while (c <= 32) {
c = next_char();
}
for (; '0' <= c && c <= '9'; c = next_char()) {
x = x * 10 + c - '0';
}
return x;
}
int next_int() {
int s = 1, c = next_char(), x = 0;
while (c <= 32) {
c = next_char();
}
if (c == '-') {
s = -1, c = next_char();
}
for (; '0' <= c && c <= '9'; c = next_char()) {
x = x * 10 + c - '0';
}
return x * s;
}
void next_string(char *s) {
int c = next_char();
while (c <= 32) {
c = next_char();
}
for (; c > 32; c = next_char()) {
*s++ = c;
}
*s = 0;
}
private:
static const int LENGTH = 1 << 16;
char buffer[LENGTH];
int position = 0, length = 0;
bool eof = false;
FILE *in;
};
const int N = 500000;
const auto MAX = 1000000000LL * N + 1;
int n, m, a[N], b[N], cost[N], rank[N + 1];
long long dp[N + 1];
int main() {
IO io{stdin};
n = io.next_uint();
for (int i = 0; i < n; ++i) {
a[i] = io.next_uint() - 1;
}
for (int i = 0; i < n; ++i) {
cost[i] = io.next_int();
}
m = io.next_uint();
for (int i = 0; i < m; ++i) {
rank[b[i] = io.next_uint() - 1] = i + 1;
}
rank[n] = m + 1;
for (int i = n; i--;) {
rank[i] = rank[i] ? rank[i] : rank[i + 1];
}
dp[0] = -2 * MAX, dp[m] = 2 * MAX;
for (int i = 0; i < n; ++i) {
int j = rank[a[i]] - 1;
if (j < m && a[i] == b[j] && dp[j] < std::min(cost[i], 0)) {
dp[j + 1] += dp[j];
dp[j] = cost[i];
if (cost[i] <= 0) {
dp[m] += cost[i];
dp[j + 1] -= cost[i];
}
} else {
dp[cost[i] > 0 ? j : m] += cost[i];
}
}
if (dp[m] < MAX) {
printf("YES\n%lld\n", dp[m]);
} else {
puts("NO");
}
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ii = pair<int, int>;
using vi = vector<int>;
using vll = vector<ll>;
using vii = vector<ii>;
const ll MOD = 998244353;
const ll INF = 1e15 + 9;
const int MAXN = 1000006;
int n, m, a[MAXN], p[MAXN], b[MAXN];
int rev[MAXN];
vi pos[MAXN];
vll sum[MAXN];
ll dp[MAXN], negsum[MAXN];
inline ll isum(int val, int R) {
int index =
lower_bound(pos[val].begin(), pos[val].end(), R) - pos[val].begin();
return sum[val][index];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
}
for (int i = 1; i <= n; ++i) {
cin >> p[i];
}
cin >> m;
for (int i = 1; i <= m; ++i) {
cin >> b[i];
}
a[n + 1] = n + 1;
b[m + 1] = n + 1;
++n, ++m;
for (int i = 0; i <= m; ++i) {
sum[2 * i + 1] = sum[2 * i] = vll(1);
}
for (int i = 0; i <= n; ++i) {
int bi = lower_bound(b, b + m, a[i]) - b;
a[i] = 2 * bi - (b[bi] != a[i]);
pos[a[i]].push_back(i);
ll prevsum = sum[a[i]].back();
sum[a[i]].push_back(prevsum + max(p[i], 0));
negsum[i + 1] = negsum[i] + min(p[i], 0);
}
for (int i = 1; i <= n; ++i) {
if (a[i] & 1) {
dp[i] = INF;
continue;
}
auto it = lower_bound(pos[a[i] - 2].begin(), pos[a[i] - 2].end(), i);
if (it == pos[a[i] - 2].begin()) {
dp[i] = INF;
continue;
}
--it;
dp[i] = dp[*it] + isum(a[i] - 1, i) + isum(a[i], i) + negsum[i] -
negsum[*it + 1];
it = lower_bound(pos[a[i]].begin(), pos[a[i]].end(), i);
if (it != pos[a[i]].begin()) {
--it;
dp[i] = min(dp[i], dp[*it] + negsum[i + 1] - negsum[*it + 1]);
}
}
if (dp[n] >= INF / 2) {
cout << "NO\n";
} else {
cout << "YES\n" << dp[n] << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 500005;
int n, m, a[N], p[N], b[N];
int id[N];
map<int, int> mp;
vector<int> lv[N];
long long f[N], t[N];
bool cmp(int x, int y) { return a[x] < a[y]; }
void change(int k, int v) {
for (; k <= n; k += k & (-k)) t[k] += v;
}
long long ask(int k) {
long long s = 0;
for (; k; k -= k & (-k)) s += t[k];
return s;
}
void solve() {
memset(f, 233, sizeof(f));
for (auto i : lv[1]) f[i] = p[i];
int t = 1;
for (int i = (int)(1); i <= (int)(m); i++) {
for (; t <= n && a[id[t]] <= b[i]; ++t)
if (p[id[t]] > 0) change(id[t], p[id[t]]);
int pos = 0, x;
long long val = -(1ll << 60);
for (auto j : lv[i + 1]) {
for (; pos < lv[i].size() && (x = lv[i][pos]) < j; ++pos)
val = max(val, f[x] - ask(x));
f[j] = val + ask(j) + p[j];
}
}
}
int main() {
scanf("%d", &n);
for (int i = (int)(1); i <= (int)(n); i++) scanf("%d", &a[i]);
for (int i = (int)(1); i <= (int)(n); i++) scanf("%d", &p[i]);
scanf("%d", &m);
for (int i = (int)(1); i <= (int)(m); i++) scanf("%d", &b[i]);
a[++n] = b[++m] = 1 << 30;
for (int i = (int)(1); i <= (int)(m); i++) mp[b[i]] = i;
for (int i = (int)(1); i <= (int)(n); i++)
if (mp[a[i]]) lv[mp[a[i]]].push_back(i);
for (int i = (int)(1); i <= (int)(n); i++) id[i] = i;
sort(id + 1, id + n + 1, cmp);
solve();
if (f[n] < -1e15)
puts("NO");
else {
puts("YES");
long long ans = -f[n];
for (int i = (int)(1); i <= (int)(n); i++) ans += p[i];
printf("%lld\n", ans);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
const long long mod = 1e9 + 7;
inline long long gcd(long long a, long long b) {
return !b ? a : gcd(b, a % b);
}
inline long long q_pow(long long a, long long x) {
long long ans = 1, tmp = a;
while (x) {
if (x & 1) (ans *= tmp) %= mod;
(tmp *= tmp) %= mod;
x >>= 1;
}
return ans;
}
template <typename T>
inline void re(T &N) {
int f = 1;
char c;
while ((c = getchar()) < '0' || c > '9')
if (c == '-') f = -1;
N = c - '0';
while ((c = getchar()) >= '0' && c <= '9') N = N * 10 + c - '0';
N *= f;
}
int m, n, t = 1, st, en;
int a[N], p[N], b[N];
struct SegT {
long long e[N << 2];
long long tag[N << 2];
inline void push_up(int p) { e[p] = max(e[((p) << 1)], e[((p) << 1 | 1)]); }
void build(int p, int l, int r) {
e[p] = -1e18;
if (l == r) return e[p] = (l ? -1e18 : 0), void();
int mid = (l + r) >> 1;
build(((p) << 1), l, mid);
build(((p) << 1 | 1), mid + 1, r);
}
inline void push_down(int p) {
if (tag[p]) {
e[((p) << 1)] += tag[p];
tag[((p) << 1)] += tag[p];
e[((p) << 1 | 1)] += tag[p];
tag[((p) << 1 | 1)] += tag[p];
tag[p] = 0;
}
}
void update1(int p, int l, int r, int L, int R, int k) {
if (L <= l && r <= R) return e[p] += k, tag[p] += k, void();
int mid = (l + r) >> 1;
push_down(p);
if (L <= mid) update1(((p) << 1), l, mid, L, R, k);
if (mid < R) update1(((p) << 1 | 1), mid + 1, r, L, R, k);
push_up(p);
}
void update2(int p, int l, int r, int L, int R, long long k) {
if (L <= l && r <= R) return e[p] = max(e[p], k), void();
int mid = (l + r) >> 1;
push_down(p);
if (L <= mid) update2(((p) << 1), l, mid, L, R, k);
if (mid < R) update2(((p) << 1 | 1), mid + 1, r, L, R, k);
push_up(p);
}
long long query(int p, int l, int r, int L, int R) {
long long ans = -1e18;
if (L <= l && r <= R) return e[p];
int mid = (l + r) >> 1;
push_down(p);
if (L <= mid) ans = max(ans, query(((p) << 1), l, mid, L, R));
if (mid < R) ans = max(ans, query(((p) << 1 | 1), mid + 1, r, L, R));
return ans;
}
} tr;
int main() {
re(n);
long long sum = 0;
for (int i = 1; i <= n; i++) re(a[i]);
for (int i = 1; i <= n; i++) re(p[i]), sum += p[i];
re(m);
for (int i = 1; i <= m; i++) re(b[i]);
tr.build(1, 0, m);
for (int i = 1; i <= n; i++) {
int pos = lower_bound(b + 1, b + m + 1, a[i]) - b;
if (p[i] > 0) {
int npos = upper_bound(b + 1, b + m + 1, a[i]) - b;
if (pos <= m) tr.update1(1, 0, m, pos, m, p[i]);
}
if (b[pos] == a[i]) {
long long val = tr.query(1, 0, m, pos - 1, pos - 1);
tr.update2(1, 0, m, pos, pos, val + p[i]);
}
}
if (tr.query(1, 0, m, m, m) < -1e17)
puts("NO");
else
printf("YES\n%lld\n", sum - tr.query(1, 0, m, m, m));
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 50;
const long long INF = 1e18;
long long a[N << 2], lazy[N << 2];
void pushup(int rt) { a[rt] = min(a[rt << 1 | 1], a[rt << 1]); }
void pushdown(int rt) {
if (lazy[rt]) {
if (a[rt << 1] != INF) {
a[rt << 1] += lazy[rt];
lazy[rt << 1] += lazy[rt];
}
if (a[rt << 1 | 1] != INF) {
a[rt << 1 | 1] += lazy[rt];
lazy[rt << 1 | 1] += lazy[rt];
}
lazy[rt] = 0;
}
}
void build(int rt, int l, int r) {
lazy[rt] = 0;
if (l == r) {
if (l == 1) {
a[rt] = 0;
} else
a[rt] = INF;
return;
}
int mid = l + r >> 1;
build(rt << 1 | 1, mid + 1, r);
build(rt << 1, l, mid);
pushup(rt);
}
void update2(int rt, int l, int r, int x, int y, long long w) {
if (l == r) {
a[rt] = min(a[rt], w);
return;
}
int mid = l + r >> 1;
pushdown(rt);
if (x <= mid)
update2(rt << 1, l, mid, x, y, w);
else
update2(rt << 1 | 1, mid + 1, r, x, y, w);
pushup(rt);
}
void update(int rt, int l, int r, int x, int y, long long w) {
if (l >= x && y >= r) {
if (a[rt] != INF) {
a[rt] += w;
lazy[rt] += w;
}
return;
}
int mid = l + r >> 1;
pushdown(rt);
if (x <= mid) update(rt << 1, l, mid, x, y, w);
if (y > mid) update(rt << 1 | 1, mid + 1, r, x, y, w);
pushup(rt);
}
long long query(int rt, int l, int r, int x) {
if (l == r) {
return a[rt];
}
pushdown(rt);
int mid = l + r >> 1;
long long res;
if (x <= mid)
res = query(rt << 1, l, mid, x);
else
res = query(rt << 1 | 1, mid + 1, r, x);
pushup(rt);
return res;
}
map<long long, int> mp;
long long b[N], c[N], p[N];
int main() {
int n, m;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%lld", b + i);
}
for (int i = 1; i <= n; i++) {
scanf("%lld", p + i);
}
scanf("%d", &m);
build(1, 1, m + 1);
for (int i = 2; i <= m + 1; i++) {
scanf("%lld", c + i);
mp[c[i]] = i;
}
for (int i = 1; i <= n; i++) {
if (mp.count(b[i])) {
int j = mp[b[i]];
long long tmp = query(1, 1, m + 1, j - 1);
update(1, 1, m + 1, 1, j - 1, p[i]);
if (p[i] < 0) {
update(1, 1, m + 1, j, m + 1, p[i]);
}
if (tmp != INF) update2(1, 1, m + 1, j, j, tmp);
} else {
int j = lower_bound(c + 2, c + m + 2, b[i]) - c;
if (c[m + 1] < b[i]) {
update(1, 1, m + 1, 1, m + 1, p[i]);
continue;
}
update(1, 1, m + 1, 1, j - 1, p[i]);
if (p[i] < 0) {
update(1, 1, m + 1, j, m + 1, p[i]);
}
}
}
long long res = query(1, 1, m + 1, m + 1);
if (res == INF) {
puts("NO");
} else {
puts("YES");
printf("%lld\n", res);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int a[500010], b[500010];
long long p[500010], d[500010], cost[500010];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < n; i++) scanf("%I64d", &p[i]);
scanf("%d", &m);
for (int i = 0; i < m; i++) scanf("%d", &b[i]);
for (int i = 0; i < n; i++) {
int j = lower_bound(b, b + m, a[i]) - b;
if (j == m)
cost[m] += p[i];
else if (p[i] < 0)
cost[j] += p[i];
}
fill(d, d + m + 1, 1e18);
d[0] = 0;
for (int i = 0; i < n; i++) {
int j = lower_bound(b, b + m, a[i]) - b;
if (j == m) continue;
if (a[i] == b[j])
d[j + 1] = min(d[j + 1], d[j] + cost[j] + (p[i] < 0 ? -p[i] : 0));
if (p[i] > 0) cost[j] += p[i];
}
cout << (d[m] >= 1e17 ? "NO" : "YES") << "\n";
if (d[m] < 1e17) cout << d[m] + cost[m];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e18;
inline long long read() {
long long num = 0, fu = 1;
char c = getchar();
while (c != '-' && (c > '9' || c < '0')) c = getchar();
if (c == '-') fu = -1, c = getchar();
while (c >= '0' && c <= '9')
num = (num << 3) + (num << 1) + (c ^ 48), c = getchar();
return fu * num;
}
long long n, m, a[500010], p[500010], b[500010], f[500010], c[500010],
bt[500010], ans = -inf, Sum;
inline long long lowbit(long long x) { return x & (-x); }
inline void update(long long x, long long k) {
for (; x <= n; x += lowbit(x)) c[x] += k;
}
inline long long query(long long x) {
long long res = 0;
for (; x; x -= lowbit(x)) res += c[x];
return res;
}
bool dfs(long long x, long long now) {
if (now > n && x <= m) return 0;
if (x > m) return 1;
if (a[now] == b[x])
dfs(x + 1, now + 1);
else
dfs(x, now + 1);
}
signed main() {
n = read();
for (long long i = 1; i <= n; i++) a[i] = read();
for (long long i = 1; i <= n; i++) p[i] = read(), Sum += p[i];
m = read();
for (long long i = 1; i <= m; i++) b[i] = read();
if (!dfs(1, 1)) {
puts("NO");
return 0;
}
update(1, -inf);
for (long long i = 1; i <= n; i++) {
long long j = std::lower_bound(b + 1, b + 1 + m, a[i]) - b;
if (j <= m && b[j] == a[i]) {
f[i] = p[i] + query(b[j - 1]);
long long tmp = query(a[i]) + (p[i] > 0 ? p[i] : 0);
if (f[i] > tmp) {
update(a[i], f[i] - tmp);
update(a[i] + 1, tmp - f[i]);
}
} else
f[i] = -inf;
if (p[i] > 0) update(a[i], p[i]);
}
ans = query(b[m]);
printf("YES\n%lld\n", Sum - ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, a[500500], p[500500], b[500500];
long long f[500500];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) scanf("%d", &p[i]);
scanf("%d", &m);
for (int i = 1; i <= m; i++) scanf("%d", &b[i]);
f[1] = 1e18;
for (int i = 1; i <= n; i++) {
int t = lower_bound(b + 1, b + m + 1, a[i]) - b;
f[0] += p[i];
f[p[i] < 0 ? m + 1 : t] -= p[i];
if (b[t] == a[i] && f[t] + p[i] > 0) {
f[t + 1] += f[t] + p[i];
f[t] = -p[i];
}
}
for (int i = 1; i <= m; i++) f[i] += f[i - 1];
if (f[m] < 1e17)
printf("YES\n%lld\n", f[m]);
else
puts("NO");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline T read() {
T x = 0, f = 0;
char c = getchar();
while (!isdigit(c)) f = c == '-', c = getchar();
while (isdigit(c)) x = x * 10 + c - 48, c = getchar();
return f ? -x : x;
}
namespace run {
const long long N = 5e5 + 9, inf = 1e18;
long long t[N], m;
inline void add(long long x, long long val) {
for (long long i = x + 1; i <= m + 1; i += i & -i) t[i] += val;
}
inline long long query(long long x) {
long long ret = 0;
for (long long i = x + 1; i; i -= i & -i) ret += t[i];
return ret;
}
long long n, a[N], w[N], b[N], pos[N];
;
long long main() {
n = read<long long>();
for (long long i = 1; i <= n; i++) a[i] = read<long long>();
for (long long i = 1; i <= n; i++) w[i] = read<long long>();
m = read<long long>();
for (long long i = 1; i <= m; i++) b[i] = read<long long>(), pos[b[i]] = i;
add(1, inf);
for (long long i = 1; i <= n; i++) {
long long tmp, now;
if (pos[a[i]]) tmp = query(pos[a[i]] - 1);
add(0, w[i]);
if (w[i] > 0) {
long long p = lower_bound(b + 1, b + m + 1, a[i]) - b;
add(p, -w[i]);
}
if (pos[a[i]]) {
now = query(pos[a[i]]);
if (tmp < now) {
add(pos[a[i]], tmp - now);
add(pos[a[i]] + 1, now - tmp);
}
}
}
long long ans = query(m);
if (ans >= inf - ((long long)(5e5)) * ((long long)(1e9)))
puts("NO");
else
printf("YES\n%lld\n", ans);
return 0;
}
} // namespace run
int main() { return run::main(); }
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, a[500003], b[500003], p[500003], cost[500003], dp[500003];
int main() {
scanf("%lld", &n);
memset(dp, 63, sizeof(dp));
for (int i = 1; i <= n; i++) scanf("%lld", a + i);
for (int i = 1; i <= n; i++) scanf("%lld", p + i);
scanf("%lld", &m);
for (int i = 1; i <= m; i++) scanf("%lld", b + i);
b[m + 1] = 23333333333333333;
for (int i = 1; i <= n; i++) {
int x = lower_bound(b + 1, b + m + 2, a[i]) - b;
if (x == m + 1 || p[i] < 0) cost[x] += p[i];
}
dp[0] = 0;
for (int i = 1; i <= n; i++) {
int x = lower_bound(b + 1, b + m + 2, a[i]) - b;
if (x <= m) {
if (b[x] == a[i])
dp[x] = min(dp[x], dp[x - 1] + cost[x] - min(p[i], 0ll));
if (p[i] > 0) cost[x] += p[i];
}
}
if (dp[m] > 1e14)
cout << "NO";
else
cout << "YES\n" << dp[m] + cost[m + 1];
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e18;
const int maxn = 5e5 + 5;
map<long long, long long> pos;
long long p[maxn];
long long a[maxn], b[maxn];
class element {
public:
int l, r;
long long plus, val;
};
class Tree {
public:
element tree[maxn << 2];
void build(int id, int l, int r) {
tree[id].l = l;
tree[id].r = r;
tree[id].plus = 0;
if (l == r) {
tree[id].val = inf;
return;
}
int mid = (l + r) / 2;
build(id * 2, l, mid);
build(id * 2 + 1, mid + 1, r);
}
void update(int id, int p, long long num) {
if (tree[id].l == p && tree[id].r == p) {
tree[id].val = num;
return;
}
if (tree[id].l > p || tree[id].r < p) return;
push_down(id);
update(id * 2, p, num);
update(id * 2 + 1, p, num);
}
void add(int id, int l, int r, long long num) {
if (tree[id].l >= l && tree[id].r <= r) {
tree[id].plus += num;
tree[id].val += num * (tree[id].r - tree[id].l + 1);
return;
}
if (tree[id].l > r || tree[id].r < l) return;
push_down(id);
if (tree[id * 2].r >= l) add(id * 2, l, r, num);
if (tree[id * 2 + 1].l <= r) add(id * 2 + 1, l, r, num);
}
void push_down(int id) {
if (tree[id].l != tree[id].r)
for (int j = id * 2; j <= id * 2 + 1; j++) {
tree[j].val += tree[id].plus * (tree[j].r - tree[j].l + 1);
tree[j].plus += tree[id].plus;
}
tree[id].plus = 0;
}
long long query(int id, int l, int r) {
if (tree[id].l >= l && tree[id].r <= r) return tree[id].val;
if (tree[id].l > r || tree[id].r < l) return 0;
long long s = 0;
push_down(id);
if (tree[id * 2].r >= l) s += query(id * 2, l, r);
if (tree[id * 2 + 1].l <= r) s += query(id * 2 + 1, l, r);
return s;
}
} dp;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) cin >> p[i];
cin >> m;
for (int i = 1; i <= m; i++) {
cin >> b[i];
pos[b[i]] = i;
}
dp.build(1, 0, m);
dp.update(1, 0, 0);
for (int i = 1; i <= n; i++) {
if (pos[a[i]] == 0) {
if (p[i] < 0) {
dp.add(1, 0, m, p[i]);
continue;
}
long long *pp = lower_bound(b + 1, b + 1 + m, a[i]);
long long ppp = pp - b;
dp.add(1, 0, ppp - 1, p[i]);
} else {
int pp = pos[a[i]];
long long val1 = dp.query(1, pp, pp), val2 = dp.query(1, pp - 1, pp - 1);
dp.update(1, pp, min(val1 + min(0ll, p[i]), val2));
if (pp != m && p[i] < 0) dp.add(1, pp + 1, m, p[i]);
dp.add(1, 0, pp - 1, p[i]);
}
}
long long ans = dp.query(1, m, m);
if (ans <= 5e14)
cout << "YES\n" << ans << "\n";
else
cout << "NO\n";
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,avx,avx2")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
using namespace std;
int curr = 1;
struct Vertex {
int left = -1, right = -1;
long long int value = 0;
long long int lazy = 0;
long long l = 0, r = 0;
Vertex() {}
Vertex(vector<long long int> &arr, int a, int b, vector<Vertex> &SegTree) {
l = a;
r = b;
if (l == r) {
value = arr[l];
} else {
left = curr;
curr++;
SegTree.push_back(Vertex());
SegTree[left] = Vertex(arr, a, (a + b) / 2, SegTree);
right = curr;
curr++;
SegTree.push_back(Vertex());
SegTree[right] = Vertex(arr, (a + b) / 2 + 1, b, SegTree);
recalculate(SegTree);
}
}
void recalculate(vector<Vertex> &SegTree) {
if (left != -1)
value = SegTree[right].value + SegTree[left].value + (r - l + 1) * lazy;
else {
value = value + lazy;
lazy = 0;
}
}
void push(vector<Vertex> &SegTree) {
SegTree[right].lazy += lazy;
SegTree[right].recalculate(SegTree);
SegTree[left].lazy += lazy;
SegTree[left].recalculate(SegTree);
lazy = 0;
}
void update(int a, int b, long long val, vector<Vertex> &SegTree) {
if (a <= l && b >= r) {
lazy += val;
recalculate(SegTree);
} else if (a > r || b < l) {
return;
} else {
SegTree[left].update(a, b, val, SegTree);
SegTree[right].update(a, b, val, SegTree);
recalculate(SegTree);
}
}
long long int query(int a, int b, vector<Vertex> &SegTree) {
if (a <= l && b >= r) {
return value;
} else if (a > r || b < l) {
return 0;
} else {
push(SegTree);
auto i = SegTree[left].query(a, b, SegTree);
auto j = SegTree[right].query(a, b, SegTree);
return i + j;
}
}
};
struct SegmentTree {
vector<Vertex> SegTree;
SegmentTree(vector<long long> &arr) {
SegTree.push_back(Vertex());
SegTree[0] = Vertex(arr, 0, arr.size() - 1, SegTree);
}
void update(long long a, long long b, long long val) {
SegTree[0].update(a, b, val, SegTree);
}
long long int query(long long a, long long b) {
return SegTree[0].query(a, b, SegTree);
}
void set(long long a, long long val) {
auto i = query(a, a);
auto change = val - i;
if (change < 0) update(a, a, change);
}
};
void pre() {}
void solve() {
long long n;
cin >> n;
long long arr[n];
long long cost[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
for (int i = 0; i < n; i++) {
cin >> cost[i];
}
long long m;
cin >> m;
long long brr[m];
map<int, int> dat;
for (int i = 0; i < m; i++) {
cin >> brr[i];
dat[brr[i]] = i + 1;
}
vector<long long> dp(m + 1);
for (int i = 1; i <= m; i++) {
dp[i] = 2e17;
}
SegmentTree s(dp);
for (int i = 0; i < n; i++) {
int oo = -1;
long long val;
if (dat.find(arr[i]) != dat.end()) {
oo = dat[arr[i]];
val = s.query(oo - 1, oo - 1);
}
if (cost[i] < 0) {
s.update(0, m, cost[i]);
} else {
int start = 0, end = m - 1, mid, ans = 0;
while (start <= end) {
mid = (start + end + 1) / 2;
if (brr[mid] >= arr[i]) {
end = mid - 1;
} else {
start = mid + 1;
ans = mid + 1;
}
}
s.update(0, ans, cost[i]);
}
if (oo != -1) {
s.set(oo, val);
}
}
if (s.query(m, m) >= 1e16) {
cout << "NO"
<< "\n";
return;
}
cout << "YES"
<< "\n";
cout << s.query(m, m) << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
pre();
long long int num = 1;
for (long long int i = 0; i < num; i++) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 5;
using ll = long long;
const ll inf = 0x3f3f3f3f3f3f3f3f;
template <class T>
void read_n(T *a, int n) {
for (int i = 0; i < n; i++) cin >> a[i];
}
template <class X, class Y>
bool chkmin(X &a, const Y &b) {
return a > b ? a = b, 1 : 0;
}
class fenwick {
private:
ll bit[N];
int n;
public:
fenwick(int _n) : n(_n + 5) { fill_n(bit + 1, n, 0); }
void update(int i, int val) {
for (; i <= n; i += i & -i) bit[i] += val;
}
ll get(int i) {
ll res = 0;
for (; i > 0; i -= i & -i) res += bit[i];
return res;
}
};
int a[N], b[N], p[N];
ll dp[N];
int main() {
int n, m;
cin >> n;
read_n(a + 1, n);
read_n(p + 1, n);
cin >> m;
read_n(b + 1, m);
fill_n(dp + 1, m, inf);
fenwick f(m);
for (int i = 1; i <= n; i++) {
int j = lower_bound(b + 1, b + m + 1, a[i]) - b;
f.update(1, p[i]);
if (p[i] > 0) f.update(j + 1, -p[i]);
if (a[i] == b[j]) chkmin(dp[j], dp[j - 1] - p[i] + f.get(j) - f.get(j + 1));
}
if (dp[m] + f.get(m + 1) >= 1e15) return puts("NO"), 0;
puts("YES");
cout << dp[m] + f.get(m + 1) << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 10;
long long s[4 * (N + 10)];
long long v[N + 10];
int ns, q;
void build(int no = 1, int l = 0, int r = N) {
if (r - l == 1) {
s[no] = v[l];
return;
}
int mid = (l + r) / 2;
build(2 * no, l, mid);
build(2 * no + 1, mid, r);
s[no] = s[2 * no] + s[2 * no + 1];
}
void modify(int i, long long x, int no = 1, int l = 0, int r = N) {
if (r - l == 1) {
s[no] = x;
return;
}
int mid = (l + r) / 2;
if (i < mid)
modify(i, x, 2 * no, l, mid);
else
modify(i, x, 2 * no + 1, mid, r);
s[no] = s[2 * no] + s[2 * no + 1];
}
long long query(int lq, int rq, int no = 1, int l = 0, int r = N) {
if (rq <= l or r <= lq) return 0;
if (lq <= l and r <= rq) return s[no];
int mid = (l + r) / 2;
return query(lq, rq, 2 * no, l, mid) + query(lq, rq, 2 * no + 1, mid, r);
}
long long n, m;
long long a[N], b[N], valb_to_id[N], bestsf[N], p[N];
long long val_can_delete[N];
long long id_can_delete[N];
int main() {
scanf("%lld", &n);
for (int i = 0; i < n; i++) scanf("%lld", a + i);
for (int i = 0; i < n; i++) scanf("%lld", p + i);
scanf("%lld", &m);
for (int i = 0; i < N; i++) valb_to_id[i] = -1;
for (int i = 0; i < m; i++) {
scanf("%lld", b + i);
valb_to_id[b[i]] = i;
}
long long add_ans = 0;
vector<int> v1, v2;
for (int i = 0; i < n; i++) {
if (valb_to_id[a[i]] == -1 and p[i] < 0) {
add_ans += p[i];
} else {
v1.push_back(a[i]);
v2.push_back(p[i]);
}
}
n = (int)(v1).size();
for (int i = 0; i < n; i++) {
a[i] = v1[i];
p[i] = v2[i];
}
for (int i = 0; i < n; i++) {
if (a[i] > b[m - 1]) add_ans += p[i];
}
for (int i = 0; i < m; i++) bestsf[i] = LLONG_MAX;
build();
for (int i = n - 1; i >= 0; i--) {
int id = valb_to_id[a[i]];
if (id != -1) {
id_can_delete[i] = val_can_delete[a[i]];
if (p[i] < 0) val_can_delete[a[i]] += p[i];
}
}
for (int i = 0; i < n; i++) {
if (valb_to_id[a[i]] != -1) {
int id = valb_to_id[a[i]];
if (id == 0 or bestsf[id - 1] < LLONG_MAX) {
long long tot = 0;
long long best_ant = 0;
long long cost_meio = 0;
long long ant = 0;
if (id) {
ant = b[id - 1];
best_ant = bestsf[id - 1];
}
cost_meio = query(ant + 1, b[id] + 1);
tot = best_ant + cost_meio + id_can_delete[i];
bestsf[id] = min(bestsf[id], tot);
}
}
modify(a[i], p[i] + v[a[i]]);
v[a[i]] += p[i];
}
if (bestsf[m - 1] < LLONG_MAX) {
puts("YES");
printf("%lld\n", bestsf[m - 1] + add_ans);
} else {
puts("NO");
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T& x) {
x = 0;
T f = 1;
char ch = getchar();
while (!isdigit(ch)) f = (ch == '-') ? -1 : 1, ch = getchar();
while (isdigit(ch)) x = x * 10 + ch - 48, ch = getchar();
x *= f;
}
template <typename T, typename... Args>
inline void read(T& x, Args&... args) {
read(x), read(args...);
}
constexpr long long MAXN = 5e5 + 5, MOD = 1e9 + 7, INF = 1e16;
struct SegTree {
SegTree *lson, *rson;
long long l, r;
long long min, tag;
} tree[MAXN << 1], *root;
long long n, m, tot;
array<long long, MAXN> a, p, b, dp;
inline void build(SegTree*& root, long long l = 0, long long r = m) {
root = &tree[tot++], root->l = l, root->r = r;
if (l == r) {
root->min = (l == 0 ? 0 : INF);
return;
}
long long mid = (l + r) >> 1;
build(root->lson, l, mid), build(root->rson, mid + 1, r);
}
inline void pushTag(SegTree* root) {
if (!root->tag) return;
root->lson->tag += root->tag, root->lson->min += root->tag;
root->lson->tag = min(INF, root->lson->tag),
root->lson->min = min(INF, root->lson->min);
root->rson->tag += root->tag, root->rson->min += root->tag;
root->rson->min = min(INF, root->rson->min),
root->rson->tag = min(INF, root->rson->tag);
root->tag = 0;
}
inline void change(SegTree* root, long long l, long long r, long long val) {
if (l <= root->l && root->r <= r) {
root->tag += val, root->min += val;
root->tag = min(root->tag, INF), root->min = min(root->min, INF);
return;
}
pushTag(root);
long long mid = (root->l + root->r) >> 1;
if (l <= mid) change(root->lson, l, r, val);
if (r > mid) change(root->rson, l, r, val);
}
inline void pointChange(SegTree* root, long long pos, long long val) {
if (pos == root->l && root->r == pos) {
root->min = min(root->min, val);
return;
}
long long mid = (root->l + root->r) >> 1;
if (pos <= mid)
pointChange(root->lson, pos, val);
else
pointChange(root->rson, pos, val);
}
inline long long query(SegTree* root, long long pos) {
if (pos == root->l && root->r == pos) return root->min;
pushTag(root);
long long mid = (root->l + root->r) >> 1;
if (pos <= mid)
return query(root->lson, pos);
else
return query(root->rson, pos);
}
signed main() {
read(n);
for (long long i = 1; i <= n; i++) read(a[i]);
for (long long i = 1; i <= n; i++) read(p[i]);
read(m);
for (long long i = 1; i <= m; i++) read(b[i]);
b[m + 1] = INF;
build(root);
for (long long i = 1; i <= n; i++) {
long long pos =
lower_bound(b.begin() + 1, b.begin() + m + 1, a[i]) - b.begin();
if (b[pos] == a[i]) {
long long tmp = query(root, pos - 1);
change(root, pos, pos, min(0LL, p[i]));
pointChange(root, pos, tmp);
}
if (b[pos] > a[i] && pos <= m)
change(root, pos, m, min(0LL, p[i]));
else if (b[pos] == a[i] && pos + 1 <= m)
change(root, pos + 1, m, min(0LL, p[i]));
change(root, 0, pos - 1, p[i]);
}
long long ans = query(root, m);
if (ans >= INF / 10)
printf("NO\n");
else
printf("YES\n%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pll = pair<ll, ll>;
using vl = vector<ll>;
void fio() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
template <typename num_t>
struct segtree {
int n, depth;
vector<num_t> tree, lazy;
void init(int second, long long* arr) {
n = second;
tree = vector<num_t>(4 * second, 0);
lazy = vector<num_t>(4 * second, 0);
init(0, 0, n - 1, arr);
}
num_t init(int i, int l, int r, long long* arr) {
if (l == r) return tree[i] = arr[l];
int mid = (l + r) / 2;
num_t a = init(2 * i + 1, l, mid, arr),
b = init(2 * i + 2, mid + 1, r, arr);
return tree[i] = a.op(b);
}
void update(int l, int r, num_t v) {
if (l > r) return;
update(0, 0, n - 1, l, r, v);
}
num_t update(int i, int tl, int tr, int ql, int qr, num_t v) {
eval_lazy(i, tl, tr);
if (tl > tr || tr < ql || qr < tl) return tree[i];
if (ql <= tl && tr <= qr) {
lazy[i] = lazy[i].val + v.val;
eval_lazy(i, tl, tr);
return tree[i];
}
if (tl == tr) return tree[i];
int mid = (tl + tr) / 2;
num_t a = update(2 * i + 1, tl, mid, ql, qr, v),
b = update(2 * i + 2, mid + 1, tr, ql, qr, v);
return tree[i] = a.op(b);
}
num_t query(int l, int r) {
if (l > r) return num_t::null_v;
return query(0, 0, n - 1, l, r);
}
num_t query(int i, int tl, int tr, int ql, int qr) {
eval_lazy(i, tl, tr);
if (ql <= tl && tr <= qr) return tree[i];
if (tl > tr || tr < ql || qr < tl) return num_t::null_v;
int mid = (tl + tr) / 2;
num_t a = query(2 * i + 1, tl, mid, ql, qr),
b = query(2 * i + 2, mid + 1, tr, ql, qr);
return a.op(b);
}
void eval_lazy(int i, int l, int r) {
tree[i] = tree[i].lazy_op(lazy[i], (r - l + 1));
if (l != r) {
lazy[i * 2 + 1] = lazy[i].val + lazy[i * 2 + 1].val;
lazy[i * 2 + 2] = lazy[i].val + lazy[i * 2 + 2].val;
}
lazy[i] = num_t();
}
};
struct sum_t {
long long val;
static const long long null_v = 0;
sum_t() : val(0) {}
sum_t(long long v) : val(v) {}
sum_t op(sum_t& other) { return sum_t(val + other.val); }
sum_t lazy_op(sum_t v, int size) { return sum_t(val + v.val * size); }
};
const long double pi = 3.14159265358979323846;
const ll mod = 998244353;
ll a[500009], p[500009], b[500009], c[500009];
ll dp[500009];
segtree<sum_t> need;
pll ord[500009];
map<ll, vl> locs;
void solve() {
ll n, k;
a[0] = -1;
p[0] = mod * mod;
cin >> n;
for (long long i = 0; i < (n); i++) {
cin >> a[i + 1];
--a[i + 1];
}
for (long long i = 0; i < (n); i++) cin >> p[i + 1];
a[n + 1] = n;
p[n + 1] = mod * mod;
n += 2;
b[0] = -1;
cin >> k;
for (long long i = 0; i < (k); i++) {
cin >> b[i + 1];
--b[i + 1];
}
b[k + 1] = n - 2;
k += 2;
need.init(n, p);
for (long long i = 0; i < (n); i++) ord[i] = make_pair(a[i], i);
sort(ord, ord + n);
for (long long i = 0; i < (n); i++) locs[a[i]].push_back(i);
int npt = 0;
const ll SENT = 2 * mod * mod;
for (long long i = 0; i < (n); i++) dp[i] = SENT;
dp[0] = 0;
for (long long i = (1); i < (k); i++) {
while (npt < n && ord[npt].first <= b[i - 1]) {
ll v = p[ord[npt].second];
if (v > 0) {
need.update(ord[npt].second, ord[npt].second, -v);
}
++npt;
}
ll opt = 0;
set<ll> best;
ll off = 0;
vl& x = locs[b[i]];
vl& lst = locs[b[i - 1]];
for (long long j = 0; j < (x.size()); j++) {
while (opt < lst.size() && lst[opt] < x[j]) {
ll ii = lst[opt];
if (dp[ii] != SENT) {
ll v = 0, i1 = ii + 1, i2 = x[j] - 1;
if (i1 <= i2) v = need.query(i1, i2).val;
best.insert(dp[ii] + v - off);
}
++opt;
}
if (best.size()) {
dp[x[j]] = *best.begin() + off;
}
ll nxt = 0;
if (j != x.size() - 1) {
ll i1 = x[j], i2 = x[j + 1] - 1;
if (i1 <= i2) {
nxt = need.query(i1, i2).val;
}
}
off += nxt;
}
}
if (dp[n - 1] == SENT) {
cout << "NO\n";
} else {
cout << "YES\n" << dp[n - 1] << '\n';
}
}
int main() {
fio();
int T;
T = 1;
while (T--) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 5e5 + 10;
const long long INF = 1e18;
struct Segment {
long long num, lazy;
} tree[maxN * 4 + 1];
int n, m;
int p[maxN + 1], a[maxN + 1], b[maxN + 1];
inline int read() {
int num = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) num = (num << 3) + (num << 1) + (ch ^ 48), ch = getchar();
return num * f;
}
inline void pushup(int node) {
tree[node].num = min(tree[node << 1].num, tree[node << 1 | 1].num);
}
inline void pushdown(int node) {
if (!tree[node].lazy) return;
long long num = tree[node].lazy;
tree[node].lazy = 0;
if (tree[node << 1].num < INF)
tree[node << 1].num += num, tree[node << 1].lazy += num;
if (tree[node << 1 | 1].num < INF)
tree[node << 1 | 1].num += num, tree[node << 1 | 1].lazy += num;
}
inline void build(int node, int l, int r) {
if (l == r) {
tree[node].num = l ? INF : 0;
return;
}
int mid = (l + r) >> 1;
build(node << 1, l, mid);
build(node << 1 | 1, mid + 1, r);
pushup(node);
}
inline void change(int node, int l, int r, int x, int y, long long num) {
if (x <= l && r <= y) {
if (tree[node].num < INF) tree[node].num += num, tree[node].lazy += num;
return;
}
pushdown(node);
int mid = (l + r) >> 1;
if (x <= mid) change(node << 1, l, mid, x, y, num);
if (y > mid) change(node << 1 | 1, mid + 1, r, x, y, num);
pushup(node);
}
inline void modify(int node, int l, int r, int x, long long num) {
if (l == r) {
tree[node].num = min(tree[node].num, num);
return;
}
pushdown(node);
int mid = (l + r) >> 1;
if (x <= mid)
modify(node << 1, l, mid, x, num);
else
modify(node << 1 | 1, mid + 1, r, x, num);
pushup(node);
}
inline long long query(int node, int l, int r, int x) {
if (l == r) return tree[node].num;
pushdown(node);
int mid = (l + r) >> 1;
if (x <= mid)
return query(node << 1, l, mid, x);
else
return query(node << 1 | 1, mid + 1, r, x);
}
int main() {
n = read();
for (int i = 1; i <= n; i++) a[i] = read();
for (int i = 1; i <= n; i++) p[i] = read();
m = read();
for (int i = 1; i <= m; i++) b[i] = read();
build(1, 0, m);
for (int i = 1; i <= n; i++) {
int x = lower_bound(b + 1, b + m + 1, a[i]) - b;
long long t;
if (b[x] == a[i]) t = query(1, 0, m, x - 1);
change(1, 0, m, 0, x - 1, p[i]);
if (p[i] < 0 && x <= m) change(1, 0, m, x, m, p[i]);
if (b[x] == a[i]) modify(1, 0, m, x, t);
}
long long ans = query(1, 0, m, m);
if (ans >= INF)
puts("NO");
else {
puts("YES");
printf("%lld\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5e5 + 5, MAXM = 4e5 + 5, BOUND = 2e5, MOD = 998244353,
INF = 0x3f3f3f3f, base = 10000;
const int inv2 = (MOD + 1) >> 1;
const long long INFL = 0x3f3f3f3f3f3f3f3f;
const double PI = acos(-1.0), eps = 1e-9;
const int N = 4e5 + 5, M = (1 << 19);
inline int add(int a, int b) { return a + b >= MOD ? a + b - MOD : a + b; }
inline int dec(int a, int b) { return a < b ? a - b + MOD : a - b; }
inline int mul(int a, int b) { return 1ll * a * b % MOD; }
long long qpow(long long a, long long b) {
long long ans = 1;
for (; b; b >>= 1, a = a * a % MOD)
if (b & 1) ans = ans * a % MOD;
return ans;
}
long long f[MAXN << 2], addv[MAXN << 2];
inline void pushDown(int o) {
if (addv[o]) {
addv[o << 1] += addv[o];
addv[o << 1 | 1] += addv[o];
f[o << 1] += addv[o];
f[o << 1 | 1] += addv[o];
addv[o] = 0;
}
}
void update(int o, int l, int r, int L, int R, int v) {
if (l >= L && r <= R) {
f[o] += v;
addv[o] += v;
return;
}
int m = l + ((r - l) >> 1);
pushDown(o);
if (L <= m) update(o << 1, l, m, L, R, v);
if (R > m) update(o << 1 | 1, m + 1, r, L, R, v);
}
void update2(int o, int l, int r, int P, long long v) {
if (l == r) {
f[o] = min(f[o], v);
return;
}
int m = l + ((r - l) >> 1);
pushDown(o);
if (P <= m)
update2(o << 1, l, m, P, v);
else
update2(o << 1 | 1, m + 1, r, P, v);
}
long long query(int o, int l, int r, int p) {
if (l == r) return f[o];
int m = l + ((r - l) >> 1);
pushDown(o);
if (p <= m)
return query(o << 1, l, m, p);
else
return query(o << 1 | 1, m + 1, r, p);
}
void build(int o, int l, int r) {
f[o] = INFL;
if (l == r) return;
int m = l + ((r - l) >> 1);
build(o << 1, l, m);
build(o << 1 | 1, m + 1, r);
}
int a[MAXN], b[MAXN], n, m, w[MAXN];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) cin >> w[i];
cin >> m;
for (int i = 1; i <= m; i++) cin >> b[i];
build(1, 0, m);
update2(1, 0, m, 0, 0);
for (int i = 0; i < n; i++) {
int p = lower_bound(b + 1, b + 1 + m, a[i + 1]) - b;
if (p <= m && b[p] == a[i + 1]) {
if (p - 2 >= 0) update(1, 0, m, 0, p - 2, w[i + 1]);
if (p <= m) update(1, 0, m, p, m, min(0, w[i + 1]));
if (p <= m) update2(1, 0, m, p, query(1, 0, m, p - 1));
update(1, 0, m, p - 1, p - 1, w[i + 1]);
} else {
update(1, 0, m, 0, p - 1, w[i + 1]);
if (p != m + 1) update(1, 0, m, p, m, min(0, w[i + 1]));
}
}
long long ans = query(1, 0, m, m);
if (ans <= (long long)5e14)
cout << "YES\n" << ans << '\n';
else
cout << "NO\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 5e5 + 5;
long long tree[N], ans;
long long n, m, a[N], b[N], p[N];
inline long long lowbit(long long x) { return x & -x; }
void update(long long x, long long y) {
if (!x) return;
while (x <= n) tree[x] += y, x += lowbit(x);
}
long long ask(long long x) {
long long res = 0;
while (x) res += tree[x], x -= lowbit(x);
return res;
}
signed main() {
cin >> n;
for (long long i = 1; i <= n; i++) cin >> a[i];
for (long long i = 1; i <= n; i++) cin >> p[i], ans += p[i];
cin >> m;
for (long long i = 1; i <= m; i++) cin >> b[i];
update(1, -1e17);
for (long long i = 1; i <= n; i++) {
long long j = lower_bound(b + 1, b + m + 1, a[i]) - b;
if (j == m + 1) continue;
if (p[i] >= 0) update(j, p[i]);
if (a[i] == b[j]) {
long long x = ask(j);
long long y = ask(j - 1);
if (y + p[i] > x) {
update(j, y + p[i] - x);
update(j + 1, x - y - p[i]);
}
}
}
bool flag = true;
for (long long i = 1; i <= m; i++)
if (ask(i) - ask(i - 1) < -1e16) flag = false;
if (flag)
puts("YES"), cout << ans - ask(m) << "\n";
else
puts("NO");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const int INF = 2e9;
const long long INFLL = 1e15;
const int MAX_N = 500000;
int N, M;
int arr[MAX_N + 1];
long long cost[MAX_N + 1];
long long Mn[MAX_N + 1];
int b[MAX_N + 1];
int idx[MAX_N + 1];
struct SEG {
struct NODE {
int l, r;
long long mn, lazy;
};
vector<NODE> seg;
int SZ;
void add() { seg.push_back({-1, -1, INFLL, 0LL}); }
void Init(int x) {
SZ = x;
add();
init(0, 1, SZ);
}
void init(int idx, int s, int e) {
if (s == e) return;
seg[idx].l = seg.size();
add();
seg[idx].r = seg.size();
add();
init(seg[idx].l, s, (s + e) / 2);
init(seg[idx].r, (s + e) / 2 + 1, e);
}
void Add(int x, int y, long long z) { add2(0, 1, SZ, x, y, z); }
void add2(int idx, int s, int e, int x, int y, long long z) {
if (x <= s && e <= y) {
if (seg[idx].mn == INFLL) return;
seg[idx].lazy += z;
seg[idx].mn += z;
return;
}
if (x > e || y < s) return;
if (seg[idx].lazy != 0) {
if (seg[seg[idx].l].mn != INFLL) {
seg[seg[idx].l].mn += seg[idx].lazy;
seg[seg[idx].l].lazy += seg[idx].lazy;
}
if (seg[seg[idx].r].mn != INFLL) {
seg[seg[idx].r].mn += seg[idx].lazy;
seg[seg[idx].r].lazy += seg[idx].lazy;
}
seg[idx].lazy = 0;
}
add2(seg[idx].l, s, (s + e) / 2, x, y, z);
add2(seg[idx].r, (s + e) / 2 + 1, e, x, y, z);
seg[idx].mn = min(seg[seg[idx].l].mn, seg[seg[idx].r].mn);
}
long long Mn(int x) { return mn(0, 1, SZ, x); }
long long mn(int idx, int s, int e, int k) {
if (s == e) return seg[idx].mn;
if (seg[idx].lazy != 0) {
if (seg[seg[idx].l].mn != INFLL) {
seg[seg[idx].l].mn += seg[idx].lazy;
seg[seg[idx].l].lazy += seg[idx].lazy;
}
if (seg[seg[idx].r].mn != INFLL) {
seg[seg[idx].r].mn += seg[idx].lazy;
seg[seg[idx].r].lazy += seg[idx].lazy;
}
seg[idx].lazy = 0;
}
if (k <= (s + e) / 2) {
return mn(seg[idx].l, s, (s + e) / 2, k);
} else {
return mn(seg[idx].r, (s + e) / 2 + 1, e, k);
}
}
void Update(int x, long long y) { update(0, 1, SZ, x, y); }
void update(int idx, int s, int e, int x, long long y) {
if (s == e) {
seg[idx].mn = min(seg[idx].mn, y);
return;
}
if (seg[idx].lazy != 0) {
if (seg[seg[idx].l].mn != INFLL) {
seg[seg[idx].l].mn += seg[idx].lazy;
seg[seg[idx].l].lazy += seg[idx].lazy;
}
if (seg[seg[idx].r].mn != INFLL) {
seg[seg[idx].r].mn += seg[idx].lazy;
seg[seg[idx].r].lazy += seg[idx].lazy;
}
seg[idx].lazy = 0;
}
if (x <= (s + e) / 2) {
update(seg[idx].l, s, (s + e) / 2, x, y);
} else {
update(seg[idx].r, (s + e) / 2 + 1, e, x, y);
}
seg[idx].mn = min(seg[seg[idx].l].mn, seg[seg[idx].r].mn);
}
} Seg;
long long tree[MAX_N + 1];
long long S;
void Add(int x, long long y) {
while (x <= N) {
tree[x] += y;
x += (x & -x);
}
}
long long Sum1(int x) {
long long ret = 0;
while (x > 0) {
ret += tree[x];
x -= (x & -x);
}
return ret;
}
long long Sum(int x, int y) { return Sum1(y) - Sum1(x - 1); }
int main() {
scanf("%d", &N);
Seg.Init(N);
for (int i = 1; i <= N; i++) {
scanf("%d", &arr[i]);
}
for (int i = 1; i <= N; i++) {
Mn[i] = INFLL;
scanf("%lld", &cost[i]);
}
scanf("%d", &M);
for (int i = 1; i <= M; i++) {
scanf("%d", &b[i]);
idx[b[i]] = i;
}
bool tf = false;
for (int i = 1; i <= N; i++) {
if (cost[i] < 0) {
Seg.Add(arr[i], N, cost[i]);
}
if (idx[arr[i]] == 0) {
Add(arr[i], (long long)cost[i]);
continue;
}
int ind = idx[arr[i]];
if (ind == 1) {
if (ind == M) tf = true;
Seg.Update(arr[i], Sum(1, b[ind]));
} else {
if (Seg.Mn(b[ind - 1]) != INFLL) {
if (ind == M) tf = true;
Seg.Update(arr[i], Sum(b[ind - 1] + 1, b[ind]) + Seg.Mn(b[ind - 1]));
}
}
Add(arr[i], (long long)cost[i]);
}
if (!tf) {
printf("NO");
return 0;
}
printf("YES\n");
printf("%lld", Seg.Mn(b[M]) + ((b[M] != N) ? Sum(b[M] + 1, N) : 0LL));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char buf[1 << 21], *p1 = buf, *p2 = buf, obuf[1 << 23], *O = obuf;
inline int read() {
int x = 0, sign = 0;
char s = getchar();
while (!isdigit(s)) sign |= s == '-', s = getchar();
while (isdigit(s)) x = (x << 1) + (x << 3) + (s - '0'), s = getchar();
return sign ? -x : x;
}
void print(int x) {
if (x > 9) print(x / 10);
(*O++ = x % 10 + '0');
}
const int N = 5e5 + 5;
vector<int> buc[N];
long long n, m, a[N], b[N], p[N], pre[N], f[N];
long long calc(int l, int r) { return pre[r] - pre[l - 1]; }
long long c[N << 2];
void modify(int x, int v) {
while (x <= n) c[x] += v, x += x & -x;
}
long long query(int x) {
long long ans = 0;
while (x) ans += c[x], x -= x & -x;
return ans;
}
long long cal(int l, int r) {
if (l > r) return 0;
return calc(l, r) - (query(r) - query(l - 1));
}
int main() {
n = read(), memset(f, 0x3f, sizeof(f));
for (int i = 1; i <= n; i++) a[i] = read(), buc[a[i]].push_back(i);
for (int i = 1; i <= n; i++) p[i] = read(), pre[i] = pre[i - 1] + p[i];
m = read();
for (int i = 1; i <= m; i++) b[i] = read();
int pos = 0;
for (int i = 1; i <= m; i++) {
int pp = lower_bound(buc[b[i]].begin(), buc[b[i]].end(), pos) -
buc[b[i]].begin();
if (pp == buc[b[i]].size()) puts("NO"), exit(0);
pos = buc[b[i]][pp];
}
puts("YES");
b[0] = f[0] = 0, b[++m] = n + 1, buc[0].push_back(0),
buc[n + 1].push_back(n + 1);
for (int i = 1; i <= m; i++) {
if (i > 1)
for (int j = b[i - 2] + 1; j <= b[i - 1]; j++)
for (int k : buc[j])
if (p[k] > 0) modify(k, p[k]);
int pos = -1, sz = buc[b[i - 1]].size() - 1;
for (int j = 0; j < buc[b[i]].size(); j++) {
int k = buc[b[i]][j];
if (j) f[k] = f[buc[b[i]][j - 1]] + cal(buc[b[i]][j - 1], k - 1);
while (pos < sz && buc[b[i - 1]][pos + 1] < k) {
int l = buc[b[i - 1]][++pos];
f[k] = min(f[k], f[l] + cal(l + 1, k - 1));
}
}
}
cout << f[n + 1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int findBucket(int num, vector<int> &b) {
int m = b.size() - 2;
int start = 0, end = m, mid = (start + end) / 2;
while (!(num > b[mid] && num <= b[mid + 1])) {
if (num <= b[mid]) {
end = mid - 1;
} else if (num > b[mid + 1]) {
start = mid + 1;
}
mid = (start + end) / 2;
}
return mid;
}
void checkEquality(int n, int m, vector<int> a, vector<int> p, vector<int> b,
vector<int> apos) {
int i, j;
vector<long long> minCost;
vector<long long> bucketCost;
vector<long long> optionalBucketCost;
vector<int> lastIndex;
vector<int> pathTraversal;
for (j = 0; j < m + 2; j++) {
minCost.push_back(10e16);
bucketCost.push_back(0);
optionalBucketCost.push_back(0);
lastIndex.push_back(-1);
}
minCost[0] = 0;
for (i = 0; i < n; i++) {
pathTraversal.push_back(-1);
}
for (i = 0; i < n; i++) {
int currIndex = findBucket(a[i], b);
if (p[i] < 0) optionalBucketCost[currIndex] += p[i];
if (b[currIndex + 1] == a[i]) {
if (minCost[currIndex] + bucketCost[currIndex] <
minCost[currIndex + 1] + optionalBucketCost[currIndex]) {
minCost[currIndex + 1] = minCost[currIndex] + bucketCost[currIndex];
lastIndex[currIndex + 1] = i;
pathTraversal[i] = lastIndex[currIndex];
optionalBucketCost[currIndex + 1] += optionalBucketCost[currIndex];
optionalBucketCost[currIndex] = 0;
}
}
bucketCost[currIndex] += p[i];
}
long long cost = 0;
int bindex = m;
int includeIndex = lastIndex[m];
for (i = n - 1; i >= 0; i--) {
if (i == includeIndex) {
includeIndex = pathTraversal[includeIndex];
bindex--;
} else if (a[i] > b[bindex]) {
cost += p[i];
} else if (p[i] < 0) {
cost += p[i];
}
}
cout << cost << endl;
}
int main() {
int n, m;
cin >> n;
vector<int> a, p;
int input;
for (int i = 0; i < n; i++) {
cin >> input;
a.push_back(input);
}
for (int i = 0; i < n; i++) {
cin >> input;
p.push_back(input);
}
cin >> m;
vector<int> b;
b.push_back(-10e6);
for (int i = 0; i < m; i++) {
cin >> input;
b.push_back(input);
}
b.push_back(10e6);
int j = 1;
vector<int> apos;
for (int i = 0; i < n; i++) {
if (a[i] == b[j]) {
apos.push_back(i);
j++;
if (j == m + 1) break;
}
}
if (j != m + 1) {
cout << "NO\n";
return 0;
} else {
cout << "YES\n";
}
checkEquality(n, m, a, p, b, apos);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
long long R = 7 + 1e9, NUMTESTCASE;
const long long NN = 10 + 1e6;
const double pi = acos(-1.0);
int di[8] = {1, 0, -1, 0, 1, -1, 1, -1}, dj[8] = {0, 1, 0, -1, 1, -1, -1, 1};
long long Bit[NN], Cost[NN], Memo[NN];
int n, m, Brr[NN], x, Cnt[NN], Next[NN], Adj[NN];
vector<int> Pos[NN];
long long Memo2[NN];
void Update(int Node, int Val) {
while (Node <= n) {
Bit[Node] += Val;
Node += Node & (-Node);
}
}
long long Sum(int Node) {
long long Res = 0;
while (Node) {
Res += Bit[Node];
Node -= Node & (-Node);
}
return Res;
}
void EndPrg() {
for (int i = (1); i <= (n); ++i) {
for (int u : Pos[i])
if (Cost[u] < 0) Update(u, Cost[u]);
if (!Cnt[i]) continue;
for (int u : Pos[i]) Memo[u] = Sum(n) - Sum(u);
for (int j = i; j >= 1; j--) {
if (Cnt[j] && j != i) break;
for (int u : Pos[j])
if (Cost[u] < 0) Update(u, -Cost[u]);
}
}
for (int i = (1); i <= (n); ++i)
if (Cnt[i])
for (int u : Pos[i]) Memo[u] += Cost[u], Memo2[u] = Memo[u];
for (int Index = m, Limit = n; Index >= 1; Index--) {
while (true) {
if (!Pos[Brr[Index]].size() || Cnt[Brr[Index]] > 1) exit(puts("NO"));
if (Pos[Brr[Index]].back() > Limit)
Pos[Brr[Index]].pop_back();
else
break;
}
Limit = Pos[Brr[Index]].back();
}
}
void BuildNext() {
for (int Curr = n, Last = -1, k, u; Curr >= 1; Curr--) {
if (!Cnt[Curr]) continue;
if (Last == -1) {
Last = Curr;
continue;
}
k = Pos[Last].size() - 1;
for (int i = Pos[Curr].size() - 1; i >= 0; i--) {
u = Pos[Curr][i];
k += 2;
if (k >= Pos[Last].size()) k = Pos[Last].size() - 1;
while (k >= 0 && Pos[Last][k] > u) Next[u] = Pos[Last][k--];
}
Last = Curr;
}
for (int u = (1); u <= (n); ++u)
if (Cnt[u])
for (int i = 1; i < Pos[u].size(); i++) Adj[Pos[u][i - 1]] = Pos[u][i];
}
bool Vis[NN], Final[NN];
long long Dp(int u) {
if (u == Pos[Brr[m]].back()) return Memo[u];
if (u <= 0) return 1e18;
if (Vis[u]) return Memo2[u];
Vis[u] = true;
return Memo2[u] =
min(Dp(Adj[u]), Memo[u] + (long long)(1 - Final[u]) * Dp(Next[u]));
}
int main() {
cin >> n;
for (int i = (1); i <= (n); ++i) scanf("%d", &x), Pos[x].push_back(i);
for (int i = (1); i <= (n); ++i) scanf("%lld", Cost + i), Cost[i] *= -1;
cin >> m;
for (int i = (1); i <= (m); ++i) scanf("%d", Brr + i), Cnt[Brr[i]]++;
EndPrg();
BuildNext();
for (int u : Pos[Brr[m]]) Final[u] = true;
long long Ans = 0;
for (int i = (1); i <= (n); ++i) Ans += -Cost[i];
cout << "YES\n" << Ans + Dp(Pos[Brr[1]][0]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long segsize;
long long segt[2 * 500100];
void build() {
for (long long i = segsize - 1; i > 0; --i)
segt[i] = segt[i << 1] + segt[i << 1 | 1];
}
void modify(long long p, long long value) {
for (segt[p += segsize] = value; p > 1; p >>= 1)
segt[p >> 1] = segt[p] + segt[p ^ 1];
}
long long query(long long l, long long r) {
long long res = 0;
for (l += segsize, r += segsize; l < r; l >>= 1, r >>= 1) {
if (l & 1) res += segt[l++];
if (r & 1) res += segt[--r];
}
return res;
}
int main() {
long long n;
long long answ = 0;
cin >> n;
long long a[n + 1];
long long p[n + 1];
long long cost[n + 1];
memset((p), 0, sizeof((p)));
memset((a), 0, sizeof((a)));
memset((cost), 0, sizeof((cost)));
for (long long i = 0; i < (long long)(n); i++) {
cin >> a[i];
}
for (long long i = 0; i < (long long)(n); i++) {
long long x;
cin >> x;
if (x > 0) {
p[i] = x;
} else {
answ += x;
cost[i] = -x;
}
}
n += 1;
a[n - 1] = n + 2;
p[n - 1] = cost[n - 1] = 0;
long long m;
cin >> m;
m += 1;
long long b[m];
set<long long> setb;
unordered_map<long long, vector<long long> > row;
for (long long i = 0; i < (long long)(m - 1); i++) {
row[i].clear();
cin >> b[i];
setb.insert(b[i]);
}
row[m - 1].clear();
b[m - 1] = n + 2;
setb.insert(b[m - 1]);
long long below[n];
long long above[n + 1];
memset((above), -1, sizeof((above)));
for (long long i = 0; i < (long long)(n); i++) {
set<long long>::iterator it = setb.find(a[i]);
if (it != setb.end()) {
row[a[i]].push_back(i);
if (it == setb.begin()) {
below[i] = 0;
} else {
it--;
below[i] = *it;
}
}
}
segsize = n + 5;
for (long long i = 0; i < (long long)(segsize); i++) {
segt[segsize + i] = 0;
}
build();
for (long long i = 0; i < (long long)(n); i++) {
set<long long>::iterator it = setb.find(a[i]);
if (it != setb.end()) {
above[i] = query(below[i] + 1, a[i] + 1);
}
modify(a[i], segt[segsize + a[i]] + p[i]);
}
int fail = 0;
for (long long i = 0; i < (long long)(m); i++) {
if (row[b[i]].size() == 0) {
fail++;
}
}
if (fail != 0) {
cout << "NO\n";
} else {
long long dp[n];
long long i = 0;
while (i <= m - 1) {
if (i == 0) {
for (auto dex : row[b[i]]) {
dp[dex] = above[dex] + cost[dex];
}
} else {
long long bdex = -1;
long long minm = 1e17;
for (auto dex : row[b[i]]) {
while (row[b[i - 1]][bdex + 1] < dex &&
bdex != row[b[i - 1]].size() - 1) {
bdex++;
minm = min(minm, dp[row[b[i - 1]][bdex]]);
}
if (bdex == -1) {
dp[dex] = 1e17;
} else {
dp[dex] = minm + cost[dex] + above[dex];
}
}
}
i++;
}
if (dp[n - 1] > 1e16) {
cout << "NO\n";
} else {
long long k = dp[n - 1] + answ;
cout << "YES\n" << k << '\n';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
void split(const string& s, char c, vector<string>& result) {
stringstream ss(s);
string x;
while (getline(ss, x, c)) result.push_back(x);
}
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 << ' ';
err(++it, args...);
}
struct FenwickTree {
vector<long long> bit;
int n;
FenwickTree(long long n) {
this->n = n + 1;
bit.assign(n + 1, 0LL);
}
FenwickTree(vector<long long> a) : FenwickTree(a.size()) {
for (size_t i = 0; i < a.size(); i++) add(i, a[i]);
}
long long sum(int idx) {
long long ret = 0;
for (++idx; idx > 0; idx -= idx & -idx) ret += bit[idx];
return ret;
}
long long sum(int l, int r) { return sum(r) - sum(l - 1); }
void add(int idx, long long val) {
for (++idx; idx < n; idx += idx & -idx) bit[idx] += val;
}
void range_add(int l, int r, long long val) {
add(l, val);
add(r + 1, -val);
}
long long get(int idx) {
long long ret = 0;
for (++idx; idx > 0; idx -= idx & -idx) ret += bit[idx];
return ret;
}
void put(int idx, long long val) {
long long tmp = this->get(idx);
this->range_add(idx, idx, -tmp);
this->range_add(idx, idx, val);
}
};
void readarray(vector<long long>& a, int size) {
long long tmp;
a.clear();
for (int i = 0; i < size; i++) {
cin >> tmp;
a.push_back(tmp);
}
}
long long min3(long long a, long long b, long long c) {
return min(min(a, b), c);
}
vector<long long> a, b, p;
map<long long, int> pos;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int m, n;
cin >> n;
readarray(a, n);
readarray(p, n);
cin >> m;
readarray(b, m);
FenwickTree mem(m + 1);
for (int i = 0; i <= m; i++) mem.put(i, 100000000100000000LL);
mem.put(0, 0);
for (int i = 0; i < m; i++) pos[b[i]] = 1 + i;
for (int i = 0; i < n; i++) {
long long cur = a[i];
long long cost = p[i];
if (pos.find(cur) == pos.end()) {
if (cost <= 0) {
mem.add(0, cost);
} else {
int last = lower_bound(b.begin(), b.end(), cur) - b.begin();
mem.range_add(0, last, cost);
}
} else {
long long addcost1 = mem.get(pos[cur] - 1);
long long addcost2 = mem.get(pos[cur]);
long long addcost3 = addcost2 + cost;
long long mincost = min3(addcost1, addcost2, addcost3);
mem.put(pos[cur], mincost);
mem.range_add(0, pos[cur] - 1, cost);
if (cost <= 0) {
mem.range_add(pos[cur] + 1, m, cost);
}
}
}
long long ans = mem.get(m);
if (ans * 10 > 100000000100000000LL)
cout << "NO" << endl;
else {
cout << "YES" << endl << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
template <class T>
bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class S, class T>
ostream &operator<<(ostream &os, const pair<S, T> v) {
os << "(" << v.first << ", " << v.second << ")";
return os;
}
template <class T>
ostream &operator<<(ostream &os, const vector<T> v) {
for (int i = 0; i < (int)v.size(); i++) {
if (i > 0) {
os << " ";
}
os << v[i];
}
return os;
}
template <class T>
ostream &operator<<(ostream &os, const vector<vector<T>> v) {
for (int i = 0; i < (int)v.size(); i++) {
if (i > 0) {
os << endl;
}
os << v[i];
}
return os;
}
string num2bit(long long num, long long len) {
string bit = "";
for (int i = 0; i < (int)len; ++i) {
bit += char('0' + (num >> i & 1));
}
return bit;
}
template <typename Monoid, typename OperatorMonoid, typename F, typename G,
typename H>
struct LazySegmentTree {
int sz, height;
vector<Monoid> data;
vector<OperatorMonoid> lazy;
const F f;
const G g;
const H h;
const Monoid M1;
const OperatorMonoid OM0;
LazySegmentTree(int n, const F f, const G g, const H h, const Monoid &M1,
const OperatorMonoid OM0)
: f(f), g(g), h(h), M1(M1), OM0(OM0) {
sz = 1;
height = 0;
while (sz < n) sz <<= 1, height++;
data.assign(2 * sz, M1);
lazy.assign(2 * sz, OM0);
}
void set(int k, const Monoid &x) { data[k + sz] = x; }
void build() {
for (int k = sz - 1; k > 0; k--) {
data[k] = f(data[2 * k + 0], data[2 * k + 1]);
}
}
inline void propagate(int k) {
if (lazy[k] != OM0) {
lazy[2 * k + 0] = h(lazy[2 * k + 0], lazy[k]);
lazy[2 * k + 1] = h(lazy[2 * k + 1], lazy[k]);
data[k] = reflect(k);
lazy[k] = OM0;
}
}
inline Monoid reflect(int k) {
return lazy[k] == OM0 ? data[k] : g(data[k], lazy[k]);
}
inline void recalc(int k) {
while (k >>= 1) data[k] = f(reflect(2 * k + 0), reflect(2 * k + 1));
}
inline void thrust(int k) {
for (int i = height; i > 0; i--) propagate(k >> i);
}
void update(int a, int b, const OperatorMonoid &x) {
thrust(a += sz);
thrust(b += sz - 1);
for (int l = a, r = b + 1; l < r; l >>= 1, r >>= 1) {
if (l & 1) lazy[l] = h(lazy[l], x), ++l;
if (r & 1) --r, lazy[r] = h(lazy[r], x);
}
recalc(a);
recalc(b);
}
Monoid query(int a, int b) {
thrust(a += sz);
thrust(b += sz - 1);
Monoid L = M1, R = M1;
for (int l = a, r = b + 1; l < r; l >>= 1, r >>= 1) {
if (l & 1) L = f(L, reflect(l++));
if (r & 1) R = f(reflect(--r), R);
}
return f(L, R);
}
Monoid operator[](const int &k) { return query(k, k + 1); }
template <typename C>
int find_subtree(int a, const C &check, Monoid &M, bool type) {
while (a < sz) {
propagate(a);
Monoid nxt =
type ? f(reflect(2 * a + type), M) : f(M, reflect(2 * a + type));
if (check(nxt))
a = 2 * a + type;
else
M = nxt, a = 2 * a + 1 - type;
}
return a - sz;
}
template <typename C>
int find_first(int a, const C &check) {
Monoid L = M1;
if (a <= 0) {
if (check(f(L, reflect(1)))) return find_subtree(1, check, L, false);
return -1;
}
thrust(a + sz);
int b = sz;
for (a += sz, b += sz; a < b; a >>= 1, b >>= 1) {
if (a & 1) {
Monoid nxt = f(L, reflect(a));
if (check(nxt)) return find_subtree(a, check, L, false);
L = nxt;
++a;
}
}
return -1;
}
template <typename C>
int find_last(int b, const C &check) {
Monoid R = M1;
if (b >= sz) {
if (check(f(reflect(1), R))) return find_subtree(1, check, R, true);
return -1;
}
thrust(b + sz - 1);
int a = sz;
for (b += sz; a < b; a >>= 1, b >>= 1) {
if (b & 1) {
Monoid nxt = f(reflect(--b), R);
if (check(nxt)) return find_subtree(b, check, R, true);
R = nxt;
}
}
return -1;
}
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
const long long INF = (1ll << 60);
long long n;
cin >> n;
vector<long long> a(n), p(n);
for (int i = 0; i < (int)n; ++i) cin >> a[i];
for (int i = 0; i < (int)n; ++i) cin >> p[i];
long long m;
cin >> m;
vector<long long> b(m + 1);
b[0] = -INF;
for (int i = 0; i < (int)m; ++i) cin >> b[i + 1];
auto f = [](long long x, long long y) { return min(x, y); };
auto g = [](long long x, long long a) { return x + a; };
auto h = [](long long a, long long b) { return a + b; };
long long M1 = INF;
long long OM0 = 0;
LazySegmentTree<long long, long long, decltype(f), decltype(g), decltype(h)>
seg(m + 1, f, g, h, M1, OM0);
for (int i = 0; i < (int)m + 1; ++i) seg.set(i, INF);
seg.set(0, 0);
seg.build();
long long pos2 = 1;
for (int i = 0; i < (int)n; ++i) {
long long pos1 = lower_bound(b.begin(), b.end(), a[i]) - b.begin();
long long pos = min(pos1, pos2);
long long prev = seg[pos1 - 1];
if (p[i] > 0) {
seg.update(0, pos, p[i]);
} else {
seg.update(0, pos2, p[i]);
}
if (pos1 <= m and b[pos1] == a[i]) {
long long val = min(seg[pos1], prev);
long long tasu = val - seg[pos1];
seg.update(pos1, pos1 + 1, tasu);
if (pos1 == pos2) pos2++;
}
}
cout << (seg[m] == INF ? "NO\n" : "YES\n");
if (seg[m] != INF) cout << seg[m] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace RA {
int r(int p) { return 1ll * rand() * rand() % p; }
int r(int L, int R) { return r(R - L + 1) + L; }
} // namespace RA
const int N = 5e5 + 5, SZ = N * 4;
const long long INF = 1ll << 60;
int n, a[N], p[N], m, b[N];
long long val[SZ], tag[SZ];
void build(int u = 1, int l = 0, int r = m) {
if (l == r) {
val[u] = l == 0 ? 0 : INF;
return;
}
int mid = (l + r) >> 1;
build(u << 1, l, mid), build(u << 1 | 1, mid + 1, r);
}
void nodeadd(int u, long long v) {
tag[u] += v;
val[u] += v;
}
void pushdown(int u) {
if (tag[u]) nodeadd(u << 1, tag[u]), nodeadd(u << 1 | 1, tag[u]), tag[u] = 0;
}
void add(int L, int R, long long v, int u = 1, int l = 0, int r = m) {
if (L > R || R < l || r < L) return;
if (L <= l && r <= R) {
nodeadd(u, v);
return;
}
int mid = (l + r) >> 1;
pushdown(u);
add(L, R, v, u << 1, l, mid), add(L, R, v, u << 1 | 1, mid + 1, r);
}
void assign(int pos, long long v, int u = 1, int l = 0, int r = m) {
if (l == r) {
val[u] = v, tag[u] = 0;
return;
}
int mid = (l + r) >> 1;
pushdown(u);
if (pos <= mid)
assign(pos, v, u << 1, l, mid);
else
assign(pos, v, u << 1 | 1, mid + 1, r);
}
long long query(int pos, int u = 1, int l = 0, int r = m) {
if (l == r) return val[u];
int mid = (l + r) >> 1;
pushdown(u);
if (pos <= mid)
return query(pos, u << 1, l, mid);
else
return query(pos, u << 1 | 1, mid + 1, r);
}
int main() {
scanf("%d", &n);
for (int i = (1); i <= (n); ++i) scanf("%d", &a[i]);
for (int i = (1); i <= (n); ++i) scanf("%d", &p[i]);
scanf("%d", &m);
for (int i = (1); i <= (m); ++i) scanf("%d", &b[i]);
build();
for (int i = (1); i <= (n); ++i) {
int pos = lower_bound(b + 1, b + m + 1, a[i]) - b;
if (b[pos] == a[i]) {
add(pos + 1, m, min(p[i], 0));
long long fpos = query(pos), fpos_1 = query(pos - 1);
assign(pos, min(fpos + min(p[i], 0), fpos_1));
add(0, pos - 1, p[i]);
} else {
add(pos, m, min(p[i], 0));
add(0, pos - 1, p[i]);
}
}
long long ans = query(m);
if (ans > (1ll << 55))
puts("NO");
else
printf("YES\n%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 5e5 + 5, inf = 1e16;
long long a[N], p[N], b[N], seg[N << 2], m;
void shift(long long id) {
if (seg[id] == 0) return;
seg[id << 1] += seg[id], seg[id << 1 | 1] += seg[id];
seg[id] = 0;
}
void add(long long l, long long r, long long val, long long L = 0,
long long R = m + 1, long long id = 1) {
if (r <= L || R <= l) return;
if (l <= L && R <= r) {
seg[id] += val;
return;
}
shift(id);
long long mid = (L + R) >> 1;
add(l, r, val, L, mid, id << 1);
add(l, r, val, mid, R, id << 1 | 1);
return;
}
long long get(long long l, long long L = 0, long long R = m + 1,
long long id = 1) {
if (R - L == 1) return seg[id];
shift(id);
long long mid = (L + R) >> 1;
if (l < mid)
return get(l, L, mid, id << 1);
else
return get(l, mid, R, id << 1 | 1);
}
int32_t main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
long long n;
cin >> n;
for (long long i = 0; i < n; i++) cin >> a[i];
for (long long i = 0; i < n; i++) cin >> p[i];
cin >> m;
for (long long i = 1; i <= m; i++) cin >> b[i];
add(1, m + 1, inf);
for (long long i = 0; i < n; i++) {
long long x = lower_bound(b, b + m + 1, a[i]) - b, val = inf * 10;
if (a[i] == b[x]) val = get(x - 1);
if (p[i] < 0)
add(0, m + 1, p[i]);
else
add(0, x, p[i]);
if (val < get(x)) add(x, x + 1, val - get(x));
}
if (get(m) > 1e15) return cout << "NO\n", 0;
cout << "YES\n" << get(m) << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
const int mod = 1e9 + 7;
const long long infll = 1e18;
long long tr[N], n;
void modify(int x, int v) {
while (x <= n) tr[x] += v, x += x & -x;
}
long long query(int x) {
long long ans = 0;
while (x) ans += tr[x], x -= x & -x;
return ans;
}
long long cal(int l, int r) { return query(r) - query(l - 1); }
long long dp[N];
vector<int> pos[N];
int p[N], a[N], b[N], m;
int main() {
bool flag = 1;
scanf("%lld", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), pos[a[i]].push_back(i);
for (int i = 1; i <= n; i++) scanf("%d", &p[i]), modify(i, p[i]);
scanf("%d", &m);
for (int i = 1; i <= m; i++) scanf("%d", &b[i]);
int cnt = 1;
for (int i = 1; i <= n; i++)
if (cnt <= m && a[i] == b[cnt]) ++cnt;
if (cnt <= m) return puts("NO"), 0;
b[0] = 0;
pos[0].push_back(0);
a[n + 1] = n + 1;
pos[a[n + 1]].push_back(n + 1);
b[m + 1] = n + 1;
for (int i = 1; i <= m + 1; i++) {
if (i > 1)
for (int j = b[i - 2] + 1; j <= b[i - 1]; j++)
for (int k : pos[j])
if (p[k] > 0) modify(k, -p[k]);
int now = b[i];
int pre = b[i - 1];
int t = 0;
for (int j = 0; j < pos[now].size(); j++) {
int r = pos[now][j];
dp[pos[now][j]] = infll;
if (j)
dp[pos[now][j]] =
dp[pos[now][j - 1]] + cal(pos[now][j - 1], pos[now][j] - 1);
int cnt = 0;
for (; t < pos[pre].size() && pos[pre][t] < pos[now][j]; t++) {
int l = pos[pre][t];
if (dp[l] != infll) dp[r] = min(dp[r], dp[l] + cal(l + 1, r - 1));
}
}
}
printf("YES\n%lld\n", dp[n + 1]);
}
|
#include <bits/stdc++.h>
using std::to_string;
std::string to_string(const std::string &s) { return '"' + s + '"'; }
std::string to_string(const char *s) { return to_string((std::string)s); }
std::string to_string(bool b) { return (b ? "true" : "false"); }
template <typename A, typename B>
std::string to_string(const std::pair<A, B> &p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <size_t N>
std::string to_string(const std::bitset<N> &bs) {
return bs.to_string();
}
template <typename A>
std::string to_string(const A &v) {
bool first = true;
std::string res = "{";
for (const auto &x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
void debug_out() { std::cerr << std::endl; }
template <typename Head, typename... Tail>
void debug_out(const Head &H, const Tail &...T) {
std::cerr << " " << to_string(H);
debug_out(T...);
}
struct fast_ios {
fast_ios() {
std::cin.tie(nullptr);
std::ios::sync_with_stdio(false);
std::cout << std::fixed << std::setprecision(10);
};
} fast_ios_;
template <typename T>
std::istream &operator>>(std::istream &stream, std::vector<T> &vec) {
for (auto &x : vec) stream >> x;
return stream;
}
template <typename T, typename U>
std::istream &operator>>(std::istream &in, std::pair<T, U> &p) {
in >> p.first >> p.second;
return in;
}
void scan() {}
template <class T, class... Args>
void scan(T &a, Args &...rest) {
std::cin >> a;
scan(rest...);
}
template <typename T>
std::ostream &operator<<(std::ostream &stream, const std::vector<T> &vec) {
bool first = true;
for (const T &t : vec) {
if (first)
first = false;
else
std::cout << ' ';
std::cout << t;
}
return stream;
}
template <typename T, typename U>
std::ostream &operator<<(std::ostream &out, const std::pair<T, U> &p) {
out << p.first << ' ' << p.second;
return out;
}
template <typename T>
void print(const std::vector<std::vector<T>> &t) {
for (const auto &row : t) {
std::cout << row << '\n';
}
}
template <typename T>
void print(const T &t) {
std::cout << t << ' ';
}
template <typename T, typename... Args>
void print(const T &t, const Args &...rest) {
print(t);
print(rest...);
}
template <typename T>
void println(const T &t) {
std::cout << t << '\n';
}
template <typename T, typename... Args>
void println(const T &t, const Args &...rest) {
print(t);
println(rest...);
}
template <typename A, typename B>
bool chkmin(A &a, const B &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
template <typename A, typename B>
bool chkmax(A &a, const B &b) {
if (b > a) {
a = b;
return true;
}
return false;
}
using ll = long long;
using ull = unsigned long long;
using vl = std::vector<ll>;
using vb = std::vector<bool>;
using vi = std::vector<int>;
using pii = std::pair<int, int>;
using pli = std::pair<ll, int>;
using pil = std::pair<int, ll>;
using pll = std::pair<ll, ll>;
using vpii = std::vector<pii>;
template <typename T>
using vv = std::vector<std::vector<T>>;
template <typename T, typename U = std::less<T>>
using pq = std::priority_queue<T, std::vector<T>, U>;
template <typename T, typename U>
T ceil(T x, U y) {
assert(y > 0);
if (x > 0) x += y - 1;
return x / y;
}
template <typename T, typename U>
T floor(T x, U y) {
assert(y > 0);
if (x < 0) x -= y - 1;
return x / y;
}
using namespace std;
template <typename T>
class BIT {
using BinOp = function<T(T, T)>;
BinOp bin_op;
const T init;
vector<T> a;
public:
explicit BIT(
int n, BinOp op = [](T x, T y) { return x + y; }, T init = T{})
: bin_op(std::move(op)), init(init), a(n, init) {}
T prefix(int x) const {
auto res = init;
while (x >= 0) {
res = bin_op(a[x], res);
x = (x & (x + 1)) - 1;
}
return res;
}
void modify(int x, T v) {
while (x < (int)(a).size()) {
a[x] = bin_op(a[x], v);
x |= (x + 1);
}
}
void clear() { fill(a.begin(), a.end(), init); }
};
class FStrangeFunction {
public:
static void solve(int, int) {
int n;
scan(n);
vv<int> pos(n + 1);
for (std::common_type<decltype(0), decltype(n)>::type i = 0; i < n; ++i) {
int x;
scan(x);
pos[x].push_back(i);
}
vi p(n);
scan(p);
int m;
scan(m);
vi b(m + 1);
b[0] = 0;
for (std::common_type<decltype(1), decltype(m)>::type i = 1; i <= m; ++i)
scan(b[i]);
BIT<ll> c(n);
for (std::common_type<decltype(0), decltype(n)>::type i = 0; i < n; ++i)
c.modify(i, p[i]);
vector<pair<int, ll>> cand, cand2;
cand.emplace_back(-1, 0);
for (std::common_type<decltype(1), decltype(m)>::type i = 1; i <= m; ++i) {
int j = 0;
for (const auto &x : pos[b[i]]) {
if (x < cand[j].first) continue;
while (j + 1 < cand.size() && cand[j + 1].first < x) ++j;
ll cost = cand[j].second + c.prefix(x - 1) - c.prefix(cand[j].first);
cand2.emplace_back(x, cost);
}
if (cand2.empty()) {
println("NO");
return;
}
for (std::common_type<decltype(b[i - 1] + 1), decltype(b[i])>::type k =
b[i - 1] + 1;
k <= b[i]; ++k) {
for (const auto &y : pos[k])
if (p[y] > 0) c.modify(y, -p[y]);
}
cand.clear();
cand.push_back(cand2[0]);
for (std::common_type<decltype(1), decltype((int)(cand2).size())>::type
k = 1;
k < (int)(cand2).size(); ++k) {
ll delta = c.prefix(cand2[k].first) - c.prefix(cand.back().first);
if (cand2[k].second < cand.back().second + delta) {
cand.push_back(cand2[k]);
}
}
cand2.clear();
}
println("YES");
println(cand.back().second + c.prefix(n - 1) - c.prefix(cand.back().first));
}
};
int main() {
FStrangeFunction solver;
solver.solve(0, 0);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
istream& operator>>(istream& is, vector<T>& a) {
for (T& ai : a) is >> ai;
return is;
}
template <typename T>
ostream& operator<<(ostream& os, vector<T> const& a) {
os << "[ ";
for (const T& ai : a) os << ai << " ";
return os << "]";
}
template <typename T1, typename T2>
istream& operator>>(istream& is, pair<T1, T2>& a) {
return is >> a.first >> a.second;
}
template <typename T1, typename T2>
ostream& operator<<(ostream& os, pair<T1, T2> const& a) {
return os << "(" << a.first << ", " << a.second << ")";
}
class BIT {
public:
BIT(int n) : _n(n), _a(n + 1) {}
void add(int i, int v) {
++i;
while (i <= _n) {
_a[i] += v;
i += i & -i;
}
}
long long get(int i) {
long long r = 0;
while (i) {
r += _a[i];
i -= i & -i;
}
return r;
}
private:
int _n;
vector<long long> _a;
};
void f() {
int n;
cin >> n;
vector<int> a(n), p(n);
cin >> a >> p;
int m;
cin >> m;
vector<int> b(m);
cin >> b;
vector<int> aa(n);
for (int i = 0; i < n; ++i) aa[i] = i;
sort((aa).begin(), (aa).end(),
[&a](int i, int j) { return a[i] < a[j] || (a[i] == a[j] && i < j); });
BIT bit(n);
for (int i = 0; i < n; ++i) bit.add(i, p[i]);
vector<pair<long long, int>> r = {{0LL, -1}}, rr;
auto x = aa.begin(), y = aa.begin(), bi = b.begin();
while (bi != b.end()) {
if (x == aa.end() || a[*x] > *bi) {
r.clear();
break;
}
if (a[*x] < *bi) {
++x;
continue;
}
auto ri = r.begin();
long long s = ri->first;
int t = ri++->second;
while (x != aa.end() && a[*x] == *bi) {
int i = *x++;
if (i < t) continue;
while (ri != r.end() && ri->second < i) {
s += bit.get(ri->second + 1) - bit.get(t + 1);
s = min(s, ri->first);
t = ri++->second;
}
s += bit.get(i) - bit.get(t + 1);
t = i - 1;
rr.emplace_back(s, i);
}
r.swap(rr);
rr.clear();
if (r.empty()) break;
while (y != aa.end() && a[*y] <= *bi) {
int i = *y++;
if (p[i] > 0) bit.add(i, -p[i]);
}
++bi;
}
if (r.empty()) {
cout << "NO\n";
return;
}
cout << "YES\n";
long long best = numeric_limits<long long>::max();
for (const auto& ri : r) {
best = min(best, ri.first + bit.get(n) - bit.get(ri.second + 1));
}
cout << best << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
f();
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.