text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
int n, m, a[500100], b[500100];
long long p[500100], chafen[500100];
int main() {
ios::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) cin >> p[i];
cin >> m;
for (int i = 1; i <= m; i++) cin >> b[i];
for (int i = 1; i <= m; i++) chafen[i] = 1e15;
for (int i = 0; i < n; i++) {
int id = lower_bound(b + 1, b + m + 1, a[i]) - b;
if (id <= m) chafen[id] += min(p[i], 0LL);
if (id <= m && b[id] == a[i] && chafen[id] > 0) {
if (id + 1 <= m) chafen[id + 1] += chafen[id];
chafen[id] = 0;
}
chafen[0] += p[i];
if (id <= m) chafen[id] -= p[i];
if (id <= m && chafen[id] > 1e15 / 2LL) chafen[id] = 1e15;
if (id + 1 <= m && chafen[id + 1] > 1e15 / 2LL) chafen[id + 1] = 1e15;
}
long long res = 0LL;
for (int i = 0; i <= m; i++) {
if (chafen[i] == 1e15) {
cout << "NO" << endl;
return 0;
}
res += chafen[i];
}
cout << "YES" << endl << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T getint() {
T x = 0, p = 1;
char ch;
do {
ch = getchar();
} while (ch <= ' ');
if (ch == '-') p = -1, ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return x * p;
}
template <typename T1, typename T2>
bool umin(T1 &x, const T2 &y) {
if (x > y) return x = y, true;
return false;
}
template <typename T1, typename T2>
bool umax(T1 &x, const T2 &y) {
if (x < y) return x = y, true;
return false;
}
const int maxn = (int)5e5 + 10;
const int inf = (int)1e9 + 5;
const int mod = 998244353;
const long long llinf = (long long)1e18 + 5;
const double pi = acos(-1.0);
int a[maxn];
int n, m;
int b[maxn];
int p[maxn];
long long dp[maxn];
vector<int> idx[maxn];
long long get(int l, int r, int val) {
long long ret = 0;
for (int i = l; i <= r; ++i) {
if (a[i] >= val) {
ret += p[i];
}
}
return ret;
}
long long get2(int l, int r, int val) {
long long ret = 0;
for (int i = l; i <= r; ++i) {
if (a[i] <= val && p[i] < 0) {
ret += p[i];
}
}
return ret;
}
long long fw[maxn];
long long fw2[maxn];
void addfw(long long fw[maxn], int x, long long val) {
for (; x < maxn; x |= x + 1) {
fw[x] += val;
}
}
long long get(long long fw[maxn], int r) {
long long ret = 0;
for (; r >= 0; r = (r & (r + 1)) - 1) {
ret += fw[r];
}
return ret;
}
long long get(long long fw[maxn], int l, int r) {
if (l > r) return 0;
return get(fw, r) - get(fw, l - 1);
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
}
for (int i = 1; i <= n; ++i) {
cin >> p[i];
}
a[n + 1] = n + 1;
cin >> m;
for (int i = 1; i <= m; ++i) {
cin >> b[i];
}
b[++m] = n + 1;
for (int i = 0; i <= n + 1; ++i) {
idx[a[i]].push_back(i);
}
vector<int> order(n + 2);
for (int i = 0; i <= n + 1; ++i) {
order[i] = i;
}
sort(order.begin(), order.end(), [&](int x, int y) { return a[x] < a[y]; });
for (int i = 0; i <= n + 2; ++i) {
addfw(fw, i, p[i]);
}
int rev_ptr = 0;
int ptr = 0;
for (int i = 1; i <= m; ++i) {
while (rev_ptr < order.size() && a[order[rev_ptr]] < b[i - 1] + 1) {
int j = order[rev_ptr++];
addfw(fw, j, -p[j]);
}
while (ptr < order.size() && a[order[ptr]] <= b[i - 1]) {
int j = order[ptr++];
if (p[j] < 0) {
addfw(fw2, j, p[j]);
}
}
int prev_ptr = 0;
int prev_sz = (int)idx[b[i - 1]].size();
long long best = llinf;
for (int cur : idx[b[i]]) {
dp[cur] = llinf;
while (prev_ptr < prev_sz && idx[b[i - 1]][prev_ptr] < cur) {
int prv = idx[b[i - 1]][prev_ptr++];
long long val = dp[prv] - get(fw, prv) - get(fw2, prv);
if (dp[prv] != llinf) {
best = min(best, val);
}
}
if (best != llinf) {
dp[cur] = best + get(fw, cur - 1) + get(fw2, cur - 1);
}
}
}
long long ans = llinf;
for (int cur : idx[b[m]]) {
ans = min(ans, dp[cur]);
}
if (ans == llinf)
cout << "NO" << endl;
else
cout << "YES" << endl << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 5e5 + 7, INF = 1e18;
long long n, m, a[N], b[N], p[N], dp[N];
struct Fen {
long long first[N];
void clear() {
for (long long i = 0; i < N; ++i) first[i] = 0;
}
void add(long long i, long long x) {
for (; i < N; i |= i + 1) first[i] += x;
}
long long get(long long i) {
long long ans = 0;
for (; i >= 0; i &= i + 1, --i) ans += first[i];
return ans;
}
long long get(long long l, long long r) { return get(r) - get(l - 1); }
} first, fmn;
long long tot = 0;
vector<long long> c;
void addi(long long i) {
tot += p[i];
long long pos = lower_bound(c.begin(), c.end(), a[i]) - c.begin();
first.add(pos, p[i]);
fmn.add(pos, min(0ll, p[i]));
}
long long get(long long x) {
long long r = upper_bound(c.begin(), c.end(), x) - c.begin() - 1;
return fmn.get(r) + (tot - first.get(r));
}
long long cur[N];
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (long long i = 0; i < n; ++i) cin >> a[i];
for (long long i = 0; i < n; ++i) cin >> p[i];
a[n] = INF;
++n;
cin >> m;
for (long long i = 0; i < m; ++i) cin >> b[i];
b[m] = INF;
++m;
for (long long i = 0; i < n; ++i) c.push_back(a[i]);
sort(c.begin(), c.end());
c.resize(unique(c.begin(), c.end()) - c.begin());
for (long long i = 0; i < N; ++i) cur[i] = INF;
for (long long i = 0; i < n; ++i) {
long long pb = lower_bound(b, b + m, a[i]) - b;
if (b[pb] != a[i]) {
addi(i);
dp[i] = INF;
continue;
}
if (pb == 0) {
dp[i] = get(0);
addi(i);
cur[pb] = min(cur[pb], dp[i] - get(a[i]));
} else {
long long x = b[pb - 1];
long long add = get(x);
addi(i);
dp[i] = INF;
if (cur[pb - 1] != INF) {
dp[i] = cur[pb - 1] + add;
cur[pb] = min(cur[pb], dp[i] - get(a[i]));
}
}
}
if (dp[n - 1] == INF)
cout << "NO" << '\n';
else
cout << "YES" << '\n' << dp[n - 1] << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 5;
long long dif[N], ans;
int n, m, a[N], b[N], p[N];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i], dif[i] = 1e18;
for (int i = 1; i <= n; i++) cin >> p[i];
cin >> m;
for (int i = 1; i <= m; i++) cin >> b[i];
for (int i = 1; i <= n; i++) {
int j = lower_bound(b + 1, b + 1 + m, a[i]) - b;
if (j <= m) dif[j] += min(0, p[i]);
if (a[i] == b[j]) {
if (dif[j] > 0) {
if (j < m) dif[j + 1] += dif[j];
dif[j] = 0;
}
}
dif[0] += p[i];
if (j <= m) dif[j] -= p[i];
if (j <= m && dif[j] > 1e17) dif[j] = 1e18;
if (j < m && dif[j + 1] > 1e17) dif[j + 1] = 1e18;
}
for (int i = 0; i <= m; i++) {
if (dif[i] == 1e18) {
puts("NO");
exit(0);
}
ans += dif[i];
}
puts("YES");
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void add(long long bit[], int n, int x, long long a) {
for (; x <= n; x += x & -x) {
bit[x] += a;
}
}
long long qry(long long bit[], int x) {
long long r = 0;
for (; x; x -= x & -x) {
r += bit[x];
}
return r;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
int a[n + 2];
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
a[0] = 0, a[n + 1] = n + 1;
int p[n + 2];
for (int i = 1; i <= n; i++) {
cin >> p[i];
}
p[0] = p[n + 1] = 0;
int m;
cin >> m;
int pr[n + 2];
fill(pr, pr + n + 2, -1);
int lb = 0;
for (int i = 0; i < m; i++) {
int b;
cin >> b;
pr[b] = lb;
lb = b;
}
pr[n + 1] = lb;
long long ss1[n + 2], ss2[n + 2];
long long bit[n + 2];
fill(bit, bit + n + 2, 0);
for (int i = n + 1; i >= 0; i--) {
if (pr[a[i]] != -1) {
ss1[i] = qry(bit, a[i]);
ss2[i] = pr[a[i]] <= 0 ? 0 : qry(bit, pr[a[i]]);
}
if (p[i] > 0) {
add(bit, n + 1, a[i], p[i]);
}
}
long long dp[n + 2], dpm[n + 2];
fill(dpm, dpm + n + 2, -2e15);
dp[0] = dpm[0] = 0;
for (int i = 1; i <= n + 1; i++) {
if (pr[a[i]] != -1) {
dp[i] = dpm[pr[a[i]]] - ss2[i] + p[i];
dpm[a[i]] = max(dpm[a[i]], dp[i] + ss1[i]);
}
}
if (dp[n + 1] < -1e15) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
long long psum = 0;
for (int i = 0; i <= n + 1; i++) {
psum += p[i];
}
cout << psum - dp[n + 1] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const long long INF = (long long)1000000007 * 1000000007;
const long double eps = 1e-8;
const long double pi = acos(-1.0);
int dx[4] = {1, -1, 0, 0};
int dy[4] = {0, 0, 1, -1};
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 (b < a) {
a = b;
return 1;
}
return 0;
}
const long long border = 10000000000000000ll;
template <class S, S (*op)(S, S), S (*e)(), class F, S (*mapping)(F, S),
F (*composition)(F, F), F (*id)()>
struct SegmentTree {
public:
SegmentTree() : SegmentTree(0) {}
SegmentTree(int n) : SegmentTree(std::vector<S>(n, e())) {}
SegmentTree(const std::vector<S> &v) : _n(int(v.size())) {
log = ceil_pow2(_n);
size = 1 << log;
d = std::vector<S>(2 * size, e());
lz = std::vector<F>(size, id());
for (int i = 0; i < _n; i++) d[size + i] = v[i];
for (int i = size - 1; i >= 1; i--) {
update_(i);
}
}
void set(int p, S x) {
assert(0 <= p && p < _n);
p += size;
for (int i = log; i >= 1; i--) push(p >> i);
d[p] = x;
for (int i = 1; i <= log; i++) update_(p >> i);
}
S get(int p) {
assert(0 <= p && p < _n);
p += size;
for (int i = log; i >= 1; i--) push(p >> i);
return d[p];
}
S query(int l, int r) {
assert(0 <= l && l <= r && r <= _n);
if (l == r) return e();
l += size;
r += size;
for (int i = log; i >= 1; i--) {
if (((l >> i) << i) != l) push(l >> i);
if (((r >> i) << i) != r) push(r >> i);
}
S sml = e(), smr = e();
while (l < r) {
if (l & 1) sml = op(sml, d[l++]);
if (r & 1) smr = op(d[--r], smr);
l >>= 1;
r >>= 1;
}
return op(sml, smr);
}
S all_query() { return d[1]; }
void update(int p, F f) {
assert(0 <= p && p < _n);
p += size;
for (int i = log; i >= 1; i--) push(p >> i);
d[p] = mapping(f, d[p]);
for (int i = 1; i <= log; i++) update_(p >> i);
}
void update(int l, int r, F f) {
assert(0 <= l && l <= r && r <= _n);
if (l == r) return;
l += size;
r += size;
for (int i = log; i >= 1; i--) {
if (((l >> i) << i) != l) push(l >> i);
if (((r >> i) << i) != r) push((r - 1) >> i);
}
{
int l2 = l, r2 = r;
while (l < r) {
if (l & 1) all_apply(l++, f);
if (r & 1) all_apply(--r, f);
l >>= 1;
r >>= 1;
}
l = l2;
r = r2;
}
for (int i = 1; i <= log; i++) {
if (((l >> i) << i) != l) update_(l >> i);
if (((r >> i) << i) != r) update_((r - 1) >> i);
}
}
template <bool (*g)(S)>
int max_right(int l) {
return max_right(l, [](S x) { return g(x); });
}
template <class G>
int max_right(int l, G g) {
assert(0 <= l && l <= _n);
assert(g(e()));
if (l == _n) return _n;
l += size;
for (int i = log; i >= 1; i--) push(l >> i);
S sm = e();
do {
while (l % 2 == 0) l >>= 1;
if (!g(op(sm, d[l]))) {
while (l < size) {
push(l);
l = (2 * l);
if (g(op(sm, d[l]))) {
sm = op(sm, d[l]);
l++;
}
}
return l - size;
}
sm = op(sm, d[l]);
l++;
} while ((l & -l) != l);
return _n;
}
template <bool (*g)(S)>
int min_left(int r) {
return min_left(r, [](S x) { return g(x); });
}
template <class G>
int min_left(int r, G g) {
assert(0 <= r && r <= _n);
assert(g(e()));
if (r == 0) return 0;
r += size;
for (int i = log; i >= 1; i--) push((r - 1) >> i);
S sm = e();
do {
r--;
while (r > 1 && (r % 2)) r >>= 1;
if (!g(op(d[r], sm))) {
while (r < size) {
push(r);
r = (2 * r + 1);
if (g(op(d[r], sm))) {
sm = op(d[r], sm);
r--;
}
}
return r + 1 - size;
}
sm = op(d[r], sm);
} while ((r & -r) != r);
return 0;
}
private:
int _n, size, log;
std::vector<S> d;
std::vector<F> lz;
void update_(int k) { d[k] = op(d[2 * k], d[2 * k + 1]); }
void all_apply(int k, F f) {
d[k] = mapping(f, d[k]);
if (k < size) lz[k] = composition(f, lz[k]);
}
void push(int k) {
all_apply(2 * k, lz[k]);
all_apply(2 * k + 1, lz[k]);
lz[k] = id();
}
int ceil_pow2(int n) {
int x = 0;
while ((1U << x) < (unsigned int)(n)) x++;
return x;
}
};
template <typename T>
struct Compress {
vector<T> V;
Compress() { V.clear(); }
Compress(vector<T> &V) : V(V) {}
void add(T x) { V.push_back(x); }
int build() {
sort(V.begin(), V.end());
V.erase(unique(V.begin(), V.end()), V.end());
return V.size();
}
int get(T x) { return lower_bound(V.begin(), V.end(), x) - V.begin(); }
pair<int, int> section(T l, T r) {
int l_ = get(l), r_ = get(r);
return pair<int, int>(l_, r_);
}
T &operator[](int i) { return V[i]; };
};
long long F(long long a, long long b) { return min(a, b); }
long long e() { return INF; }
long long G(long long a, long long b) { return a + b; }
long long id() { return 0; }
int n, m;
int a[500010];
long long p[500010];
void solve() {
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) cin >> p[i];
Compress<int> B;
cin >> m;
B.add(-1);
for (int i = 0; i < m; i++) {
int b_;
cin >> b_;
B.add(b_);
}
B.build();
SegmentTree<long long, F, e, long long, G, G, id> seg(m + 1);
seg.set(0, 0);
for (int i = 0; i < n; i++) {
int k = B.get(a[i]);
bool flg = false;
long long D;
if (a[i] == B[k]) {
flg = true;
D = seg.get(k - 1);
}
if (p[i] >= 0)
seg.update(0, k, p[i]);
else
seg.update(0, m + 1, p[i]);
if (flg) {
if (seg.get(k) > D) {
seg.set(k, D);
}
}
}
if (seg.get(m) > border)
cout << "NO" << endl;
else {
cout << "YES" << endl;
cout << seg.get(m) << endl;
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(50);
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
char ch = getchar();
long long nega = 1;
while (!isdigit(ch)) {
if (ch == '-') nega = -1;
ch = getchar();
}
long long ans = 0;
while (isdigit(ch)) {
ans = ans * 10 + ch - 48;
ch = getchar();
}
if (nega == -1) return -ans;
return ans;
}
inline long long min(long long x, long long y, long long z) {
return min(x, min(y, z));
}
inline long long max(long long x, long long y, long long z) {
return max(x, max(y, z));
}
inline long long add(long long x, long long y) {
return x + y >= 998244353 ? x + y - 998244353 : x + y;
}
inline long long add(long long x, long long y, long long z) {
return add(add(x, y), z);
}
inline long long sub(long long x, long long y) {
return x - y < 0 ? x - y + 998244353 : x - y;
}
inline long long mul(long long x, long long y) {
return 1LL * x * y % 998244353;
}
inline long long mul(long long x, long long y, long long z) {
return mul(mul(x, y), z);
}
long long a[500005], b[500005], c[500005], p[500005], sum[500005];
long long f[500005], v[500005], n, m;
long long t[500005];
long long lowbit(long long u) { return u & (-u); }
void update(long long u, long long d) {
while (u <= n) {
t[u] += d;
u += lowbit(u);
}
}
long long query(long long u) {
long long ans = 0;
while (u) {
ans += t[u];
u -= lowbit(u);
}
return ans;
}
signed main() {
cin >> n;
for (long long i = 1; i <= n; i++) a[i] = read();
for (long long i = 1; i <= n; i++) p[i] = read();
for (long long i = 1; i <= n; i++) sum[i] = sum[i - 1] + p[i];
cin >> m;
for (long long i = 1; i <= m; i++) b[i] = read();
for (long long i = 1; i <= m; i++) c[b[i]] = i;
long long cur = 1;
for (long long i = 1; i <= n; i++) {
if (cur <= m && a[i] == b[cur]) cur++;
}
if (cur <= m) {
cout << "NO\n";
return 0;
}
cout << "YES\n";
for (long long i = 1; i <= m; i++) f[i] = 0x3f3f3f3f3f3f3f3f;
for (long long i = 1; i <= n; i++) {
if (c[a[i]]) {
long long qaq = c[a[i]];
v[i] = f[qaq - 1] + sum[i - 1] - query(b[qaq - 1]);
if (p[i] > 0) update(a[i], p[i]);
long long R = v[i] - sum[i] + query(b[qaq]);
if (R < f[qaq]) f[qaq] = R;
} else if (p[i] > 0)
update(a[i], p[i]);
}
long long res = 0, ans = 0x3f3f3f3f3f3f3f3f;
for (long long i = n; i >= 1; i--) {
if (a[i] == b[m]) {
if (v[i] + res < ans) ans = v[i] + res;
if (p[i] < 0) res += p[i];
} else if (a[i] > b[m] || p[i] < 0)
res += p[i];
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 500005;
int n, a[N], m, b[N];
long long p[N], dp[N], val[N][2], ans;
long long t[4 * N];
void add(int v, int l, int r, int pos, long long val) {
if (l == r) {
t[v] += val;
return;
}
int m = (l + r) / 2;
if (pos <= m)
add(v * 2, l, m, pos, val);
else
add(v * 2 + 1, m + 1, r, pos, val);
t[v] = t[v * 2] + t[v * 2 + 1];
}
long long get(int v, int l, int r, int i, int j) {
if (i > j) return 0;
if (l == i && r == j) return t[v];
int m = (l + r) / 2;
return get(v * 2, l, m, i, min(j, m)) +
get(v * 2 + 1, m + 1, r, max(m + 1, i), j);
}
int last[N];
vector<pair<int, int>> lav[N];
vector<int> upd[N];
long long best[N];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) scanf("%d", a + i);
for (int i = 1; i <= n; i++) scanf("%lld", p + i);
cin >> m;
for (int i = 1; i <= m; i++) scanf("%d", b + i);
for (int i = 1; i <= n; i++) last[i] = -1;
for (int i = 1; i <= m; i++) last[b[i]] = b[i - 1];
lav[0].push_back(make_pair(0, 1));
for (int i = 1; i <= n; i++) {
if (last[a[i]] != -1) {
lav[a[i]].push_back(make_pair(i, 1));
lav[last[a[i]]].push_back(make_pair(i, 0));
}
if (p[i] < 0)
add(1, 0, n, i, p[i]);
else
upd[a[i]].push_back(i);
}
for (int i = n; i >= 0; i--) {
best[i] = 1000000007ll * 1000000007ll;
for (int j = 0; j < lav[i].size(); j++)
val[lav[i][j].first][lav[i][j].second] =
get(1, 0, n, lav[i][j].first + 1, n);
for (int j = 0; j < upd[i].size(); j++)
add(1, 0, n, upd[i][j], p[upd[i][j]]);
}
best[0] = val[0][1];
for (int i = 1; i <= n; i++) {
if (last[a[i]] == -1) continue;
dp[i] = 1000000007ll * 1000000007ll;
if (best[last[a[i]]] != 1000000007ll * 1000000007ll)
dp[i] = best[last[a[i]]] - val[i][0] - p[i];
if (dp[i] != 1000000007ll * 1000000007ll)
best[a[i]] = min(best[a[i]], dp[i] + val[i][1]);
}
ans = best[b[m]];
if (ans == 1000000007ll * 1000000007ll) {
cout << "NO" << endl;
return 0;
}
cout << "YES" << endl;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
struct node {
T val;
T lazy;
int l, r;
node* left;
node* right;
node(int l, int r) {
this->l = l;
this->r = r;
this->left = nullptr;
this->right = nullptr;
}
};
template <class T, int SZ>
struct segtree {
T combIdentity = 1e17;
T comb(T l, T r) { return min(l, r); }
T pushIdentity = 0;
void push(node<T>* n) {
n->val += n->lazy;
if (n->l != n->r) {
n->left->lazy += n->lazy;
n->right->lazy += n->lazy;
}
n->lazy = pushIdentity;
}
node<T>* root;
segtree() {
int ub = 1;
while (ub < SZ) ub *= 2;
root = new node<T>(0, ub - 1);
root->val = pushIdentity;
root->lazy = pushIdentity;
}
void propagate(node<T>* n) {
if (n->l != n->r) {
int mid = ((n->l) + (n->r)) / 2;
if (n->left == nullptr) {
n->left = new node<T>(n->l, mid);
n->left->val = pushIdentity;
n->left->lazy = pushIdentity;
}
if (n->right == nullptr) {
n->right = new node<T>(mid + 1, n->r);
n->right->val = pushIdentity;
n->right->lazy = pushIdentity;
}
}
push(n);
}
void updN(node<T>* n, int i1, int i2, T val) {
propagate(n);
if (i2 < n->l || i1 > n->r) return;
if (i1 <= n->l && i2 >= n->r) {
n->lazy = val;
return;
}
updN(n->left, i1, i2, val);
updN(n->right, i1, i2, val);
n->val = comb(n->left->val, n->right->val);
}
void upd(int i1, int i2, T val) { updN(root, i1, i2, val); }
T queryN(node<T>* n, int i1, int i2) {
propagate(n);
if (i2 < n->l || i1 > n->r) return combIdentity;
if (n->l >= i1 && n->r <= i2) return n->val;
T a = combIdentity;
if (n->left != nullptr) a = comb(a, queryN(n->left, i1, i2));
if (n->right != nullptr) a = comb(a, queryN(n->right, i1, i2));
return a;
}
T query(int i1, int i2) { return queryN(root, i1, i2); }
};
const int MAX_N = 500500;
int n;
int arr[MAX_N];
long long cost[MAX_N];
int k;
int des[MAX_N];
map<int, int> desIdx;
segtree<long long, MAX_N> dp;
void setVal(int idx, long long val) {
dp.upd(idx, idx, -dp.query(idx, idx) + val);
assert(dp.query(idx, idx) == val);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; i++) cin >> arr[i];
for (int i = 0; i < n; i++) cin >> cost[i];
cin >> k;
for (int i = 0; i < k; i++) cin >> des[i];
for (int i = 0; i < k; i++) desIdx[des[i]] = i + 1;
dp.upd(0, k, 1e16);
setVal(0, cost[0]);
if (arr[0] == des[0]) setVal(desIdx[arr[0]], 0);
for (int i = 1; i < n; i++) {
if (arr[i] < des[0]) {
dp.upd(1, k, min(cost[i], 0LL));
} else if (desIdx.count(arr[i])) {
int idx = desIdx[arr[i]];
long long val = min(dp.query(idx - 1, idx - 1),
dp.query(idx, idx) + min(cost[i], 0LL));
if (val <= 1e15) setVal(idx, val);
if (1 <= idx - 1) dp.upd(1, idx - 1, cost[i]);
if (idx + 1 <= k && cost[i] < 0) dp.upd(idx + 1, k, cost[i]);
} else {
auto it = desIdx.upper_bound(arr[i]);
if (it == desIdx.end()) {
dp.upd(1, k, cost[i]);
} else {
int idx = (*it).second;
if (1 <= idx - 1) dp.upd(1, idx - 1, cost[i]);
if (cost[i] < 0) dp.upd(idx, k, cost[i]);
}
}
dp.upd(0, 0, cost[i]);
}
long long res = dp.query(k, k);
if (abs(res) > (long long)MAX_N * 1e9) {
return cout << "NO" << '\n', 0;
;
}
cout << "YES"
<< "\n";
return cout << res << '\n', 0;
;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e5 + 10;
const long long inf = 1e17 + 10;
int n;
int a[maxn];
int p[maxn];
int m;
long long b[maxn];
long long dp[maxn];
long long cost[maxn];
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];
b[m + 1] = inf;
for (int i = 1; i <= n; i++) {
int j = lower_bound(b + 1, b + m + 2, a[i]) - b;
if (p[i] < 0 || j > m) cost[j] += p[i];
}
dp[0] = 0;
for (int i = 1; i <= m; i++) dp[i] = inf;
for (int i = 1; i <= n; i++) {
int j = lower_bound(b + 1, b + m + 2, a[i]) - b;
if (j <= m) {
if (a[i] == b[j]) {
if (p[i] < 0)
dp[j] = min(dp[j], dp[j - 1] + cost[j] - p[i]);
else
dp[j] = min(dp[j], dp[j - 1] + cost[j]);
}
if (p[i] > 0) cost[j] += p[i];
}
}
if (dp[m] > 1e14) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
cout << (dp[m] + cost[m + 1]) << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5;
const long long oo = 1e16 + 5;
int du[] = {-1, 0, 0, 1};
int dv[] = {0, -1, 1, 0};
const long long mod = 1e9 + 7;
long long sqr(long long x) { return x * x; }
int getbit(int state, int i) { return ((state >> i) & 1); }
int n, m, a[N + 5], b[N + 5];
long long f[N + 5], dp[N + 5], c[N + 5], neg[N + 5], t[N + 5];
vector<int> List[N + 5];
void update(int u, long long val) {
for (int i = u; i <= N; i += i & -i) f[i] += val;
}
long long get(int u) {
long long tmp = 0;
for (int i = u; i > 0; i -= i & -i) tmp += f[i];
return tmp;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) cin >> c[i];
n++;
a[n] = n;
c[n] = 0;
for (int i = 1; i <= n; i++) {
List[a[i]].push_back(i);
neg[i] = neg[i - 1];
if (c[i] < 0)
neg[i] += c[i];
else
update(i, c[i]);
t[i] = t[i - 1] + c[i];
}
cin >> m;
for (int i = 1; i <= m; i++) cin >> b[i];
for (int i = 0; i < List[b[1]].size(); i++)
dp[List[b[1]][i]] = t[List[b[1]][i] - 1];
m++;
b[m] = n;
for (int k = 2; k <= m; k++) {
int v = b[k - 1], u = b[k], vt = 0;
for (int i = b[k - 2] + 1; i <= v; i++)
for (int j = 0; j < List[i].size(); j++)
if (c[List[i][j]] > 0) update(List[i][j], -c[List[i][j]]);
if (List[u].empty()) {
cout << "NO";
return 0;
}
if (List[v].empty()) {
cout << "NO";
return 0;
}
long long Min = oo;
for (int i = 0, j = 0; i < List[u].size(); i++) {
while (j < List[v].size() && List[v][j] < List[u][i]) {
if (j > 0 && Min < oo)
Min += (neg[List[v][j]] - neg[List[v][j - 1]]) + get(List[v][j]) -
get(List[v][j - 1]);
Min = min(Min, dp[List[v][j]]);
vt = List[v][j];
j++;
}
if (Min < oo)
dp[List[u][i]] =
Min + neg[List[u][i] - 1] - neg[vt] + get(List[u][i] - 1) - get(vt);
else
dp[List[u][i]] = oo;
}
}
if (dp[n] >= oo)
cout << "NO" << endl;
else
cout << "YES" << endl << dp[n];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 10, mod = 1e9 + 7;
long long seg[4 * N], flag[4 * N];
int a[N], p[N], b[N];
inline void relax(int ind) {
long long x = flag[ind];
flag[ind] = 0;
seg[2 * ind] += x;
seg[2 * ind + 1] += x;
flag[2 * ind] += x;
flag[2 * ind + 1] += x;
}
void add(int s, int e, int ind, int l, int r, long long val, int tp) {
if (s >= r || e <= l) return;
if (s >= l && e <= r) {
if (tp == 0)
seg[ind] = min(seg[ind], val);
else
seg[ind] += val, flag[ind] += val;
return;
}
relax(ind);
int mid = (s + e) / 2;
add(s, mid, 2 * ind, l, r, val, tp);
add(mid, e, 2 * ind + 1, l, r, val, tp);
}
long long get(int s, int e, int ind, int l, int r) {
if (s >= r || e <= l) return 1ll * mod * mod;
if (s >= l && e <= r) return seg[ind];
relax(ind);
int mid = (s + e) / 2;
return min(get(s, mid, 2 * ind, l, r), get(mid, e, 2 * ind + 1, l, r));
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) cin >> p[i];
int m;
cin >> m;
for (int i = 1; i <= m; i++) cin >> b[i];
for (int i = 0; i < 4 * N; i++) seg[i] = 1ll * mod * mod;
add(0, m + 1, 1, 0, 1, 0, 0);
for (int i = 0; i < n; i++) {
int id = lower_bound(b + 1, b + m + 1, a[i]) - b;
long long ret = get(0, m + 1, 1, id - 1, id);
if (p[i] > 0)
add(0, m + 1, 1, 0, id, p[i], 1);
else
add(0, m + 1, 1, 0, m + 1, p[i], 1);
if (id <= m && b[id] == a[i]) add(0, m + 1, 1, id, id + 1, ret, 0);
}
long long ans = get(0, m + 1, 1, m, m + 1);
if (ans >= 1ll * mod * mod / 10)
cout << "NO";
else
cout << "YES\n" << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 500500;
const long long Inf = 1e18;
template <typename type>
struct SegmentTreeWithLazyPropagation {
private:
const type E = Inf;
private:
const type EL = 0;
private:
static const int Nax = 4 * N;
private:
int n;
private:
type Tree[Nax];
private:
type Lazy[Nax];
public:
SegmentTreeWithLazyPropagation(int n = 0) : n(n) {
for (int Node = 0; Node < Nax; Node++) Tree[Node] = E, Lazy[Node] = EL;
}
private:
type Unite(type x, type y) { return min(x, y); }
private:
void Merge(int Node) {
Tree[Node] = Unite(Tree[(Node << 1)], Tree[(Node << 1 | 1)]);
}
private:
void PushLazy(int Node, int Len) {
if (Lazy[Node] != EL) {
Tree[Node] += Lazy[Node];
if (Len > 1) {
Lazy[(Node << 1)] += Lazy[Node];
Lazy[(Node << 1 | 1)] += Lazy[Node];
}
Lazy[Node] = EL;
}
}
public:
void Build(const vector<type>& a) {
Clear();
n = a.size();
Build(a, 1, 0, n - 1);
}
private:
void Build(const vector<type>& a, int Node, int L, int R) {
Tree[Node] = E, Lazy[Node] = EL;
if (L == R) return void(Tree[Node] = a[L]);
Build(a, (Node << 1), L, ((L + R) >> 1));
Build(a, (Node << 1 | 1), ((L + R) >> 1) + 1, R);
Merge(Node);
}
public:
void Update(int i, type x) { Update(i, i, x - Query(i, i)); }
public:
void Update(int i, int j, type x) {
if (n <= 0 || i > j) return;
Update(i, j, x, 1, 0, n - 1);
}
private:
void Update(int i, int j, type x, int Node, int L, int R) {
PushLazy(Node, R - L + 1);
if (j < L || R < i) return;
if (i <= L && R <= j) return Lazy[Node] = x, PushLazy(Node, R - L + 1);
Update(i, j, x, (Node << 1), L, ((L + R) >> 1));
Update(i, j, x, (Node << 1 | 1), ((L + R) >> 1) + 1, R);
Merge(Node);
}
public:
type Query(int i, int j) {
if (n <= 0 || i > j) return E;
return Query(i, j, 1, 0, n - 1);
}
private:
type Query(int i, int j, int Node, int L, int R) {
PushLazy(Node, R - L + 1);
if (j < L || R < i) return E;
if (i <= L && R <= j) return Tree[Node];
return Unite(Query(i, j, (Node << 1), L, ((L + R) >> 1)),
Query(i, j, (Node << 1 | 1), ((L + R) >> 1) + 1, R));
}
public:
void Clear() {
for (int Node = 0; Node <= 4 * n; Node++) Tree[Node] = E, Lazy[Node] = EL;
n = 0;
}
};
SegmentTreeWithLazyPropagation<long long> myTree;
SegmentTreeWithLazyPropagation<long long> myTree2;
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int& x : a) scanf("%d", &x), x--;
vector<int> p(n);
for (int& x : p) scanf("%d", &x);
int m;
cin >> m;
vector<int> b(m);
for (int& x : b) scanf("%d", &x), x--;
b.push_back(n);
vector<vector<int>> Have(n + 1);
for (int i = 0; i < n; i++) Have[a[i]].push_back(i);
Have[n].push_back(n);
vector<int> Idx(n + 1, -1);
for (int i = 0; i <= m; i++) Idx[b[i]] = i;
vector<long long> Suff(n + 1);
for (int i = n - 1; i >= 0; --i) {
Suff[i] = Suff[i + 1];
if (p[i] < 0) Suff[i] += (long long)p[i];
}
vector<long long> Dp(n + 1, Inf);
myTree.Build(vector<long long>(n + 1, Inf));
myTree2.Build(vector<long long>(n + 1, 0));
Dp[n] = 0;
myTree.Update(n, Dp[n] - Suff[n]);
for (int x = n - 1; x >= 0; x--) {
if (Idx[x] != -1) {
for (int i : Have[x])
Dp[i] = Suff[i + 1] + myTree.Query(i + 1, n) - myTree2.Query(i, i);
for (int i : Have[b[Idx[x] + 1]]) myTree.Update(i, Inf);
for (int i : Have[x]) myTree.Update(i, Dp[i] - Suff[i]);
}
for (int i : Have[x]) {
if (p[i] > 0) {
myTree.Update(i + 1, n, p[i]);
myTree2.Update(i + 1, n, p[i]);
}
}
}
long long Ans = Inf;
long long Cost = 0;
for (int i = 0; i < n; i++) {
if (a[i] == b[0]) Ans = min(Ans, Cost + Dp[i]);
Cost += (long long)p[i];
}
long long Max = 0;
for (int x : p)
if (x > 0) Max += (long long)x;
if (Ans > Max) return 0 * puts("NO");
puts("YES");
cout << Ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
int chkmax(T& a, T b) {
if (b > a) {
a = b;
return 1;
}
return 0;
}
template <class T>
int chkmin(T& a, T b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
template <class iterator>
void output(iterator begin, iterator end, ostream& out = cerr) {
while (begin != end) {
out << (*begin) << " ";
begin++;
}
out << endl;
}
template <class T>
void output(T x, ostream& out = cerr) {
output(x.begin(), x.end(), out);
}
void fast_io() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
const long long INF = 1e18;
struct st {
int n;
vector<long long> t;
st(int _n) {
n = 1;
while (n < _n) {
n <<= 1;
}
t.resize(2 * n);
t[1] = INF;
}
void update(int l, int r, long long val) {
l += n;
r += n;
while (l <= r) {
if (l & 1) {
t[l] += val;
l++;
}
if ((r & 1) == 0) {
t[r] += val;
r--;
}
l >>= 1;
r >>= 1;
}
}
long long get(int pos) {
pos += n;
long long res = 0;
while (pos) {
res += t[pos];
pos >>= 1;
}
return res;
}
void chkmin_pos(int pos, long long val) {
long long cur_val = get(pos);
if (val < cur_val) {
update(pos, pos, val - cur_val);
}
}
};
const int mx = 5e5 + 228;
int n, m, a[mx], b[mx], id[mx];
long long p[mx];
void read() {
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a[i + 1];
}
for (int i = 0; i < n; ++i) {
cin >> p[i + 1];
}
cin >> m;
for (int i = 0; i < m; ++i) {
cin >> b[i + 1];
}
a[n + 1] = n + 1;
b[m + 1] = n + 1;
n += 2;
m += 2;
}
void solve() {
st T(m);
fill(id, id + n, -1);
for (int i = 0; i < m; ++i) {
id[b[i]] = i;
}
T.chkmin_pos(0, 0);
for (int i = 1; i < n; ++i) {
long long dp_val;
if (id[a[i]] != -1) {
dp_val = T.get(id[a[i]] - 1);
}
if (p[i] >= 0) {
int pos = lower_bound(b, b + m, a[i]) - b - 1;
if (pos >= 0) {
T.update(0, pos, p[i]);
}
} else {
T.update(0, m - 1, p[i]);
}
if (id[a[i]] != -1) {
T.chkmin_pos(id[a[i]], dp_val);
}
}
long long ans = T.get(m - 1);
if (ans >= INF / 2) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
cout << ans << endl;
}
}
signed main() {
fast_io();
read();
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 998244353;
const long long inf = 4e18;
const int maxn = 1e6 + 3;
int a[maxn], b[maxn], n, m, c[maxn];
long long p[maxn], s[maxn], dp[maxn], sum;
long long qry(int x) {
long long ret = 0;
while (x) ret += s[x], x -= x & (-x);
return ret;
}
void add(int x, long long y) {
while (x < maxn) s[x] += y, x += x & (-x);
}
int main() {
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]);
b[m + 1] = 1e9 + 3;
for (int i = 1; i <= n; i++) {
int x = lower_bound(b + 1, b + m + 1, a[i]) - b;
if (b[x] == a[i])
c[i] = x * 2;
else
c[i] = x * 2 - 1;
sum += p[i];
}
for (int i = 1; i <= m; i++) dp[i] = -inf;
for (int i = n; i; i--) {
if (p[i] > 0) add(c[i], p[i]);
if (c[i] % 2 == 0) {
int x = c[i] / 2;
if (dp[x + 1] > -inf)
dp[x] = max(dp[x],
dp[x + 1] + qry(x * 2) - qry(x * 2 - 2) + min(0ll, p[i]));
}
}
if (dp[1] > -inf)
printf("YES\n%lld\n", sum - dp[1]);
else
puts("NO");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5e5 + 5;
const long long INF = (1LL << 60LL);
int N, M, a[MAXN], p[MAXN], b[MAXN], nxt[MAXN], idx[MAXN];
long long BIT[MAXN], DP[MAXN], minim[MAXN], pre[MAXN];
void upd(int pos, long long x) {
for (; pos <= N + 1; pos += (pos & -pos)) BIT[pos] += x;
}
long long qry(int pos) {
long long ans = 0;
for (; pos; pos -= (pos & -pos)) ans += BIT[pos];
return ans;
}
int main() {
ios_base::sync_with_stdio(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];
pre[i] = pre[i - 1] + p[i];
}
cin >> M;
for (int i = 1; i <= M; i++) {
cin >> b[i];
idx[b[i]] = i;
nxt[i] = N + 1;
}
nxt[M + 1] = N + 1;
for (int i = N; i >= 1; i--) {
if (p[i] >= 0)
upd(a[i], p[i]);
else
upd(N + 1, p[i]);
if (idx[a[i]] > 0) {
long long ans1 = INF;
if (DP[nxt[idx[a[i]]]] < INF && nxt[idx[a[i]]] <= N)
ans1 = qry(N + 1) - qry(b[idx[a[i]] - 1]) - minim[nxt[idx[a[i]]]] +
DP[nxt[idx[a[i]]]];
long long ans2 = INF;
if (DP[nxt[idx[a[i]] + 1]] < INF && nxt[idx[a[i]] + 1] <= N) {
ans2 = qry(N + 1) - qry(b[idx[a[i]]]) - minim[nxt[idx[a[i]] + 1]] +
DP[nxt[idx[a[i]] + 1]];
if (p[i] < 0) ans2 -= p[i];
} else if (idx[a[i]] == M) {
ans2 = qry(N + 1) - qry(b[idx[a[i]]]);
if (p[i] < 0) ans2 -= p[i];
}
DP[i] = min(ans1, ans2);
nxt[idx[a[i]]] = i;
minim[i] = qry(N + 1) - qry(b[idx[a[i]] - 1]);
}
}
long long ans = INF;
for (int i = 1; i <= N; i++) {
if (a[i] == b[1]) {
if (DP[i] < INF) ans = DP[i] + pre[i - 1];
break;
}
}
if (ans < INF)
cout << "YES\n" << ans << "\n";
else
cout << "NO\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353, N = 510000;
const long long inf = 1e16;
int n, m, a[N], p[N], b[N];
long long f[N], sum[N], tree[N];
vector<int> pos[N];
inline void modify(int x, int w) {
while (x <= n) tree[x] += w, x += x & -x;
return;
}
inline long long query(int x) {
long long ret = 0;
while (x) ret += tree[x], x -= x & -x;
return ret;
}
inline int addMod(int a, int b) { return (a += b) >= mod ? a - mod : a; }
inline long long quickpow(long long base, long long pw) {
long long ret = 1;
while (pw) {
if (pw & 1) ret = ret * base % mod;
base = base * base % mod, pw >>= 1;
}
return ret;
}
template <class T>
inline void read(T &x) {
x = 0;
char ch = getchar(), w = 0;
while (!isdigit(ch)) w = (ch == '-'), ch = getchar();
while (isdigit(ch)) x = (x << 1) + (x << 3) + (ch ^ 48), ch = getchar();
x = w ? -x : x;
return;
}
int main() {
read(n);
for (register int i = 1; i <= n; ++i) {
read(a[i]);
pos[a[i]].push_back(i);
}
pos[0].push_back(0);
for (register int i = 1; i <= n; ++i) read(p[i]);
read(m);
for (register int i = 1; i <= m; ++i) read(b[i]);
for (register int i = 1; i <= n; ++i) {
sum[i] = sum[i - 1] + min(p[i], 0);
modify(i, max(p[i], 0));
}
for (register int i = 1; i <= m; ++i) {
long long minP = inf;
auto it = pos[b[i - 1]].begin();
for (auto &v : pos[b[i]]) {
while (it != pos[b[i - 1]].end() && *it <= v)
minP = min(minP, f[*it] - sum[*it] - query(*it)), ++it;
f[v] = minP + sum[v - 1] + query(v - 1);
}
for (register int j = b[i - 1] + 1; j <= b[i]; ++j)
for (auto &v : pos[j]) modify(v, -max(p[v], 0));
}
long long ans = inf;
for (auto &v : pos[b[m]])
ans = min(ans, f[v] + sum[n] - sum[v] + query(n) - query(v));
if (ans >= inf / 2)
printf("NO\n");
else
printf("YES\n%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-O2")
using namespace std;
const long long N = 500000 + 10;
const long long MOD = 1000000000 + 7;
const long long INF = 100000000000000010;
const long long LOG = 25;
long long dp[N], n, a[N], lazy[N << 2], m, b[N], seg[N << 2], p[N], koj[N];
void modify(long long id, long long x) {
seg[id] += x;
lazy[id] += x;
}
void shift(long long id) {
modify(id << 1, lazy[id]);
modify(id << 1 | 1, lazy[id]);
lazy[id] = 0;
}
void add(long long id, long long lq, long long rq, long long x, long long l,
long long r) {
if (rq <= l || r <= lq) return;
if (lq <= l && r <= rq) {
modify(id, x);
return;
}
long long md = (l + r) >> 1;
shift(id);
add(id << 1, lq, rq, x, l, md);
add(id << 1 | 1, lq, rq, x, md, r);
seg[id] = seg[id << 1] + seg[id << 1 | 1];
}
long long get(long long id, long long lq, long long rq, long long l,
long long r) {
if (rq <= l || r <= lq) return 0;
if (lq <= l && r <= rq) return seg[id];
shift(id);
long long md = (l + r) >> 1;
return get(id << 1, lq, rq, l, md) + get(id << 1 | 1, lq, rq, md, r);
}
void Set(long long id, long long lq, long long rq, long long x, long long l,
long long r) {
if (rq <= l || r <= lq) return;
if (lq <= l && r <= rq) {
seg[id] = x;
return;
}
long long md = (l + r) >> 1;
shift(id);
Set(id << 1, lq, rq, x, l, md);
Set(id << 1 | 1, lq, rq, x, md, r);
seg[id] = seg[id << 1] + seg[id << 1 | 1];
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
}
for (long long i = 1; i <= n; i++) cin >> p[i];
cin >> m;
for (long long i = 1; i <= m; i++) {
cin >> b[i];
koj[b[i]] = i;
}
add(1, 1, m + 1, INF, 0, m + 1);
for (long long i = 1; i <= n; i++) {
if (koj[a[i]] == 0) {
long long x = lower_bound(b + 1, b + m + 1, a[i]) - b;
add(1, 0, x, p[i], 0, m + 1);
long long zed = min(0ll, p[i]);
add(1, x, m + 1, zed, 0, m + 1);
} else {
long long j = koj[a[i]];
long long zed = min(0ll, p[i]);
long long mn =
min(get(1, j - 1, j, 0, m + 1), get(1, j, j + 1, 0, m + 1) + zed);
Set(1, j, j + 1, mn, 0, m + 1);
add(1, 0, j, p[i], 0, m + 1);
add(1, j + 1, m + 1, zed, 0, m + 1);
}
}
long long ans = get(1, m, m + 1, 0, m + 1);
if (ans > 1000000000000000) return cout << "NO", 0;
cout << "YES\n";
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long c = 524288;
long long n, m, bal[2 * c], jobb[2 * c], t[c], p[c], k[c], o = 0, lp[2 * c],
sok = 1e16;
bool f;
void add(long long a, long long st, long long fi, long long ert) {
if (st > jobb[a] || fi < bal[a]) return;
if (st <= bal[a] && jobb[a] <= fi)
lp[a] += ert;
else
add(2 * a, st, fi, ert), add(2 * a + 1, st, fi, ert);
}
void cl(long long a, long long x) {
if (x > jobb[a] || x < bal[a]) return;
if (a >= c) return;
lp[2 * a] += lp[a], lp[2 * a + 1] += lp[a], lp[a] = 0;
cl(2 * a, x), cl(2 * a + 1, x);
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (long long i = 1; i <= n; i++) cin >> t[i];
for (long long i = 1; i <= n; i++) cin >> p[i];
cin >> m, k[m + 1] = sok;
for (long long i = 1; i <= m; i++) {
cin >> k[i];
if (k[i] < k[i - 1]) f = true;
}
for (long long i = c; i < 2 * c; i++) bal[i] = i - c, jobb[i] = i - c;
for (long long i = c - 1; i >= 1; i--)
bal[i] = bal[2 * i], jobb[i] = jobb[2 * i + 1];
add(1, 1, m, sok);
for (long long i = 1; i <= n; i++) {
long long a = t[i], b = p[i], x = 0, y = m + 1;
while (y - x > 1) {
long long z = (x + y) / 2;
if (k[z] >= a)
y = z;
else
x = z;
}
if (k[y] == a) {
cl(1, x), cl(1, y);
lp[c + y] = min(lp[c + y] + min(o, b), lp[c + x]);
} else if (b < 0)
add(1, y, y, b);
add(1, 0, x, b);
if (b < 0) add(1, y + 1, m, b);
}
cl(1, m);
if (lp[c + m] > sok / 10) f = true;
if (f)
cout << "NO"
<< "\n";
else
cout << "YES\n" << lp[c + m] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
struct Fenwick {
vector<T> bit;
int N;
Fenwick(int n) : N(n) { bit.assign(n + 1, 0); }
void add(int a, T w) {
for (int x = ++a; x <= N; x += x & -x) bit[x] += w;
}
T sum(int a) {
T ret = 0;
for (int x = a; x > 0; x -= x & -x) ret += bit[x];
return ret;
}
T sum(int a, int b) { return sum(b) - sum(a); }
};
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<int> a(n);
vector<long long> c(n);
for (auto &x : a) cin >> x;
for (auto &x : c) cin >> x;
int m;
cin >> m;
vector<int> b(m);
for (auto &x : b) cin >> x;
Fenwick<long long> f(m + 2);
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();
int k = upper_bound(b.begin(), b.end(), a[i]) - b.begin();
long long e = min(0LL, c[i]);
long long y = 1e18;
if (j != m && b[j] == a[i]) y = dp[j] + f.sum(j + 1);
f.add(0, c[i]);
f.add(j + 1, e - c[i]);
if (j != m && b[j] == a[i]) {
dp[j + 1] = min(dp[j + 1], y - f.sum(j + 2));
}
}
if (dp[m] >= 1e16) {
cout << "NO\n";
return 0;
}
cout << "YES\n";
cout << f.sum(m + 1) + dp[m] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
constexpr int inf = 1e9 + 7;
constexpr ll longinf = 1LL << 60;
constexpr ll mod = 1e9 + 7;
template <typename T, typename S>
struct LazySegmentTree {
private:
int n;
vector<T> node;
vector<S> lazy;
T E0;
S E1;
inline void updatef(S& lazy, S& value) { lazy += value; }
inline void calculatef(T& node, S& lazy, int len) { node += lazy; }
inline T queryf(T& x, T& y) { return min(x, y); }
public:
LazySegmentTree(int sz, T nodeE, S lazyE) : E0(nodeE), E1(lazyE) {
n = 1;
while (n < sz) n <<= 1;
node.resize(2 * n - 1, E0);
lazy.resize(2 * n - 1, E1);
}
LazySegmentTree(vector<T>& v, T E0, S E1) : E0(E0), E1(E1) {
n = 1;
int sz = v.size();
while (n < sz) n <<= 1;
node.resize(2 * n - 1, E0);
lazy.resize(2 * n - 1, E1);
for (int i = (int)(0); i < (int)(sz); ++i) node[i + n - 1] = v[i];
for (int i = n - 2; i >= 0; --i) {
node[i] = queryf(node[2 * i + 1], node[2 * i + 2]);
}
}
void eval(int k, int l, int r) {
if (lazy[k] == E1) return;
calculatef(node[k], lazy[k], r - l);
if (r - l > 1) {
updatef(lazy[2 * k + 1], lazy[k]);
updatef(lazy[2 * k + 2], lazy[k]);
}
lazy[k] = E1;
}
void update(int a, int b, S x, int k = 0, int l = 0, int r = -1) {
if (r < 0) r = n;
eval(k, l, r);
if (r <= a || b <= l) return;
if (a <= l && r <= b) {
updatef(lazy[k], x);
eval(k, l, r);
} else {
update(a, b, x, 2 * k + 1, l, (l + r) / 2);
update(a, b, x, 2 * k + 2, (l + r) / 2, r);
node[k] = queryf(node[2 * k + 1], node[2 * k + 2]);
}
}
T query(int a, int b, int k = 0, int l = 0, int r = -1) {
if (r < 0) r = n;
eval(k, l, r);
if (r <= a || b <= l) return E0;
if (a <= l && r <= b) return node[k];
T xl = query(a, b, 2 * k + 1, l, (l + r) / 2);
T xr = query(a, b, 2 * k + 2, (l + r) / 2, r);
return queryf(xl, xr);
}
};
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<int> a(n), p(n);
for (int i = (int)(0); i < (int)(n); ++i) cin >> a[i];
ll ans = 0;
for (int i = (int)(0); i < (int)(n); ++i) {
cin >> p[i];
if (p[i] < 0) ans += p[i];
}
int m;
cin >> m;
vector<int> b(m);
map<int, int> mp;
for (int i = (int)(0); i < (int)(m); ++i) {
cin >> b[i];
mp[b[i]] = i;
}
vector<ll> c(m + 1, longinf);
c[0] = 0;
LazySegmentTree<ll, ll> sg(c, 2 * longinf, 0);
for (int i = (int)(0); i < (int)(n); ++i) {
int idx = lower_bound(b.begin(), b.end(), a[i]) - b.begin();
if (idx < m && b[idx] == a[i]) {
if (p[i] >= 0) {
ll cur = sg.query(idx + 1, idx + 2);
ll pre = sg.query(idx, idx + 1);
if (pre < cur) {
sg.update(idx + 1, idx + 2, pre - cur);
}
sg.update(0, idx, p[i]);
} else {
ll pre = sg.query(idx, idx + 1);
ll cur = sg.query(idx + 1, idx + 2);
if (pre - p[i] < cur) {
sg.update(idx + 1, idx + 2, pre - p[i] - cur);
}
}
} else {
if (p[i] >= 0) sg.update(0, idx + 1, p[i]);
}
}
ans += sg.query(m, m + 1);
if (ans >= longinf / 2) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
cout << ans << endl;
}
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 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];
}
a[n + 1] = n + 1;
for (int i = 1; i <= n; ++i) {
cin >> p[i];
}
cin >> m;
for (int i = 1; i <= m; ++i) {
cin >> b[i];
}
b[m + 1] = n + 1;
pos[0].push_back(0);
++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;
if (b[bi] == a[i]) {
a[i] = 2 * bi;
} else {
a[i] = 2 * bi - 1;
}
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] = 1e15;
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] = 1e15;
continue;
}
--it;
int index =
lower_bound(pos[a[i]].begin(), pos[a[i]].end(), i) - pos[a[i]].begin();
dp[i] = dp[*it] + isum(a[i] - 1, i) + isum(a[i], i) + negsum[i] -
negsum[*it + 1];
if (index > 0) {
dp[i] = min(dp[i], dp[pos[a[i]][index - 1]] + negsum[i + 1] -
negsum[pos[a[i]][index - 1] + 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 = 1e18;
const int MX = 500005;
int n, a[MX], p[MX], m, b[MX], f[MX];
long long ft[MX], x[MX], sum, mn[MX];
void update(int i, long long k) {
while (i < MX) {
ft[i] += k;
i += i & -i;
}
}
long long query(int i) {
long long s = 0;
while (i) {
s += ft[i];
i -= i & -i;
}
return s;
}
long long query(int a, int b) { return query(b) - query(a - 1); }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i + 1];
for (int i = 0; i < n; i++) {
cin >> p[i + 1];
if (p[i + 1] < 0) sum += p[i + 1];
}
cin >> m;
for (int i = 0; i < m; i++) {
cin >> b[i + 1];
f[b[i + 1]] = i + 1;
}
int j = 1;
for (int i = 0; i < n; i++)
if (j <= m && a[i + 1] == b[j]) j++;
if (j <= m) {
cout << "NO" << '\n';
return 0;
}
for (int i = n; i; i--) {
if (p[i] < 0)
x[i] -= p[i];
else
update(a[i], p[i]);
if (f[a[i]]) x[i] -= query(b[f[a[i]] - 1] + 1, a[i]);
}
fill(mn, mn + MX, inf);
mn[m + 1] = 0;
for (int i = n; i; i--)
if (f[a[i]]) mn[f[a[i]]] = min(mn[f[a[i]]], x[i] + mn[f[a[i]] + 1]);
cout << "YES" << '\n' << mn[1] + sum + query(n) << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void add(long long bit[], int n, int x, long long a) {
for (; x <= n; x += x & -x) {
bit[x] += a;
}
}
long long qry(long long bit[], int x) {
long long r = 0;
for (; x; x -= x & -x) {
r += bit[x];
}
return r;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
int a[n + 2];
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
a[0] = 0, a[n + 1] = n + 1;
int p[n + 2];
for (int i = 1; i <= n; i++) {
cin >> p[i];
}
p[0] = p[n + 1] = 0;
int m;
cin >> m;
int pr[n + 2];
fill(pr, pr + n + 2, -1);
int lb = 0;
for (int i = 0; i < m; i++) {
int b;
cin >> b;
pr[b] = lb;
lb = b;
}
pr[n + 1] = lb;
long long ss1[n + 2], ss2[n + 2];
long long bit[n + 2];
fill(bit, bit + n + 2, 0);
for (int i = n + 1; i >= 0; i--) {
if (pr[a[i]] != -1) {
ss1[i] = qry(bit, a[i]);
ss2[i] = pr[a[i]] <= 0 ? 0 : qry(bit, pr[a[i]]);
}
if (p[i] > 0) {
add(bit, n + 1, a[i], p[i]);
}
}
long long dp[n + 2], dpm[n + 2];
fill(dp, dp + n + 2, -6e14);
fill(dpm, dpm + n + 2, -6e14);
dp[0] = dpm[0] = 0;
for (int i = 1; i <= n + 1; i++) {
if (pr[a[i]] != -1 && dpm[pr[a[i]]] != -6e14) {
dp[i] = dpm[pr[a[i]]] - ss2[i] + p[i];
dpm[a[i]] = max(dpm[a[i]], dp[i] + ss1[i]);
}
}
if (dp[n + 1] == -6e14) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
long long psum = 0;
for (int i = 0; i <= n + 1; i++) {
psum += p[i];
}
cout << psum - dp[n + 1] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 5e5 + 100, inF = 1e16;
long long n, m, ans, a[N], b[N], p[N], val[N], dp[N], fen[N];
void add(int y, int x) {
for (y++; y < N; y += y & -y) fen[y] += x;
}
long long get(int r) {
long long res = 0;
for (; r; r ^= r & -r) res += fen[r];
return res;
}
void input() {
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) {
cin >> p[i];
ans += p[i];
p[i] *= -1;
}
cin >> m;
for (int i = 0; i < m; i++) cin >> b[i];
}
void solve() {
fill(dp, dp + m, inF);
for (int i = n - 1; ~i; i--) {
if (binary_search(b, b + m, a[i])) {
int x = lower_bound(b, b + m, a[i]) - b;
dp[x] = min(dp[x], p[i] + dp[x + 1] + get(b[x] + 1) -
(x ? get(b[x - 1] + 1) : 0));
}
add(a[i], min(0LL, p[i]));
}
ans += dp[0];
if (ans > 1e15)
cout << "NO\n";
else
cout << "YES\n" << ans << '\n';
}
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
input();
solve();
}
|
#include <bits/stdc++.h>
long long n, m, a[500010], b[500010], p[500010], t[500010], c[500010];
void update(int x, long long const &v) {
for (; x <= m + 1; x += x & -x) c[x] += v;
}
long long query(int x) {
long long ans(0);
for (; x; x -= x & -x) ans += c[x];
return ans;
}
int main() {
scanf("%lld", &n);
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), t[b[i]] = i;
update(2, (long long)1e18);
for (int i = 1; i <= n; i++) {
long long v, rv;
if (t[a[i]]) v = query(t[a[i]]);
update(1, p[i]);
if (p[i] > 0)
update(std::lower_bound(b + 1, b + m + 1, a[i]) - b + 1, -p[i]);
if (t[a[i]]) {
rv = query(t[a[i]] + 1);
if (v < rv) update(t[a[i]] + 1, v - rv), update(t[a[i]] + 2, rv - v);
}
}
long long ans = query(m + 1);
if (ans > 5e14)
printf("NO");
else
printf("YES\n%lld", ans);
return 0;
}
|
#include <bits/stdc++.h>
const int MAXN = 5e5 + 5;
struct BIT {
long long tree[MAXN];
inline void add(int pos, long long x) {
pos++;
while (pos < MAXN) {
tree[pos] += x;
pos += ((pos) & (-(pos)));
}
}
inline long long query(int pos) {
long long res = 0;
pos++;
while (pos) {
res += tree[pos];
pos -= ((pos) & (-(pos)));
}
return res;
}
} bit;
int n, m;
int a[MAXN], w[MAXN], b[MAXN];
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", w + i);
scanf("%d", &m);
for (int i = 1; i <= m; ++i) scanf("%d", b + i);
bit.add(1, 1e18);
for (int i = 1; i <= n; ++i) {
int p = std::lower_bound(b + 1, b + m + 1, a[i]) - b;
long long v = -1;
if (b[p] == a[i]) {
v = bit.query(p - 1);
}
bit.add(0, w[i]);
if (w[i] > 0) bit.add(p, -w[i]);
if (b[p] == a[i]) {
long long now = bit.query(p);
if (now > v) {
bit.add(p, -now + v);
bit.add(p + 1, now - v);
}
}
}
long long res = bit.query(m);
if (res > 1e17) {
puts("NO");
} else {
printf("YES\n%lld\n", res);
}
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) {
ios::sync_with_stdio(0), cin.tie(0);
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>
using namespace std;
const int N = 1e6 + 10;
const long long inf = 1e18;
const int mo = 998244353;
int n;
long long a0;
long long a[N], p[N];
int s[N], ls[N];
void f(int x, long long y) {
for (; x <= n; x += x & -x) a[x] += y;
}
long long q(int x) {
long long r = a0;
for (; x; x -= x & -x) r += a[x];
return r;
}
int main() {
int m;
scanf("%d", &n);
for (auto i = (1); i <= (n); ++i) scanf("%d", &s[i]);
for (auto i = (1); i <= (n); ++i) scanf("%lld", &p[i]);
scanf("%d", &m);
int LS = 0;
for (auto i = (0); i <= (n); ++i) ls[i] = -1;
for (auto i = (1); i <= (m); ++i) {
int x;
scanf("%d", &x);
ls[x] = LS;
LS = x;
}
f(1, inf);
for (auto i = (1); i <= (n); ++i) {
long long res;
if (~ls[s[i]]) res = q(ls[s[i]]);
a0 += p[i];
if (p[i] > 0) f(s[i], -p[i]);
if (~ls[s[i]]) {
long long nw = q(s[i]);
if (res < nw) {
f(s[i], res - nw);
if (s[i] < n) f(s[i] + 1, nw - res);
}
}
}
long long ans = q(LS);
if (ans >= inf / 2)
printf("NO\n");
else
printf("YES\n%lld\n", ans);
}
|
#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(), 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(), modify(i, 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>
const int NN = 1e6 + 10;
using namespace std;
long long n, m, a[NN], b[NN], p[NN], cost[NN], dp[NN];
int main() {
cin >> n;
memset(dp, '0', sizeof(dp));
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];
b[m + 1] = 1e18;
for (int i = 1; i <= n; i++) {
int pos = lower_bound(b + 1, b + m + 2, a[i]) - b;
if (pos == m + 1 || p[i] < 0) cost[pos] += p[i];
}
dp[0] = 0;
for (int i = 1; i <= n; i++) {
int pos = lower_bound(b + 1, b + m + 2, a[i]) - b;
if (pos <= m) {
if (b[pos] == a[i])
dp[pos] = min(dp[pos], dp[pos - 1] + cost[pos] - min(p[i], 0ll));
if (p[i] > 0) cost[pos] += p[i];
}
}
if (dp[m] > 1e9)
cout << "NO";
else
cout << "YES" << endl << dp[m] + cost[m + 1];
}
|
#include <bits/stdc++.h>
using namespace std;
char pool[1 << 27 | 1 << 26], *pool_pos = pool;
void clear_pool() { pool_pos = pool; }
void *operator new(size_t siz) { return pool_pos += siz, pool_pos - siz; }
void operator delete(void *p) {}
struct SEGT {
static const int maxn = 1 << 19;
static const long long linf = 0x3f3f3f3f3f3f3f3f;
long long mn[maxn << 1], add[maxn << 1];
int siz;
void init(int n) {
siz = 1;
while (siz < n) siz <<= 1;
for (int i = 0; i < (int)(siz << 1); ++i) mn[i] = linf, add[i] = 0;
}
void push(int i, long long v) {
add[i] += v;
mn[i] += v;
}
void pushdown(int i) {
if (add[i]) {
if (i < siz) {
push(i << 1, add[i]);
push(i << 1 | 1, add[i]);
}
add[i] = 0;
}
}
void upd(int i, int a, int b, int l, int r, long long v) {
if (l <= a && b <= r) return push(i, v);
pushdown(i);
int m = (a + b) >> 1;
if (l < m) upd(i << 1, a, m, l, r, v);
if (r > m) upd(i << 1 | 1, m, b, l, r, v);
mn[i] = min(mn[i << 1], mn[i << 1 | 1]);
}
long long qry(int i, int a, int b, int l, int r) {
if (l <= a && b <= r) return mn[i];
pushdown(i);
int m = (a + b) >> 1;
long long ans = linf << 1;
if (l < m) ans = min(ans, qry(i << 1, a, m, l, r));
if (r > m) ans = min(ans, qry(i << 1 | 1, m, b, l, r));
return ans;
}
void upd(int l, int r, long long v) {
if (l < r) upd(1, 0, siz, l, r, v);
}
void upd(int x, long long v) { upd(x, x + 1, v - qry(x)); }
long long qry(int l, int r) { return qry(1, 0, siz, l, r); }
long long qry(int x) { return qry(x, x + 1); }
} segt;
const int maxn = 5e5 + 5;
int n, m;
int a[maxn], p[maxn], b[maxn];
int main() {
scanf("%d", &n);
for (int i = 0; i < (int)(n); ++i) scanf("%d", &a[i]);
for (int i = 0; i < (int)(n); ++i) scanf("%d", &p[i]);
scanf("%d", &m);
for (int i = 0; i < (int)(m); ++i) scanf("%d", &b[i]);
segt.init(m + 1);
segt.upd(0, 0);
for (int i = 0; i < (int)(n); ++i) {
int ps = lower_bound(b, b + m, a[i]) - b;
if (b[ps] == a[i]) {
if (p[i] < 0) segt.upd(ps + 1, m + 1, p[i]);
if (segt.qry(ps) < segt.qry(ps + 1)) segt.upd(ps + 1, segt.qry(ps));
segt.upd(0, ps + 1, p[i]);
} else {
if (p[i] < 0) segt.upd(ps + 1, m + 1, p[i]);
segt.upd(0, ps + 1, p[i]);
}
}
long long ans = segt.qry(m);
if (ans >= 1e16)
puts("NO");
else {
puts("YES");
printf("%lld\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[500010], p[500010], m, b[500010], pos[500010];
long long dp[500010], s, BIT[500010];
void upl(int x, int val) {
for (; x <= 500000; x += (-x & x)) BIT[x] += val;
}
long long dwl(int x) {
long long tmp = 0;
for (; x > 0; x -= (-x & x)) tmp += BIT[x];
return tmp;
}
void readf() {
s = 0;
cin >> n;
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 1; i <= n; ++i) cin >> p[i], s += p[i];
cin >> m;
for (int i = 1; i <= m; ++i) cin >> b[i];
}
void solve() {
memset(dp, 0x3f, sizeof(dp));
dp[0] = 0;
for (int i = 1; i <= n; ++i) {
int j = lower_bound(b + 1, b + m + 1, a[i]) - b;
if (p[i] > 0) {
upl(1, p[i]);
upl(j + 1, -p[i]);
} else {
upl(1, p[i]);
upl(m + 2, -p[i]);
}
if (b[j] == a[i])
dp[j] = min(dp[j] + dwl(j + 1), dp[j - 1] + dwl(j) - p[i]) - dwl(j + 1);
}
long long ans = dp[m] + dwl(m + 1);
if (ans < 1000000000000000000)
cout << "YES\n" << ans;
else
cout << "NO";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
readf();
solve();
}
|
#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]);
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;
const long long inf = 0x3f3f3f3f3f3f3f3f;
long long lowbit(long long x) { return x & -x; }
const long long N = 500001, M = N;
long long n, m;
long long a[N + 1], p[N + 1], b[M + 1];
long long id[N + 1];
struct bitree {
long long sum[N + 1];
void init() { memset(sum, 0, sizeof(sum)); }
void add(long long x, long long v) {
while (x <= n) sum[x] += v, x += lowbit(x);
}
long long Sum(long long x) {
long long res = 0;
while (x) res += sum[x], x -= lowbit(x);
return res;
}
long long _sum(long long l, long long r) { return Sum(r) - Sum(l - 1); }
} bit;
long long now[M + 1];
long long dp[N + 1];
signed main() {
cin >> n;
for (long long i = 1; i <= n; i++) scanf("%lld", a + i);
n++;
a[n] = n;
for (long long i = 1; i < n; i++) scanf("%lld", p + i);
cin >> m;
for (long long i = 1; i <= m; i++) scanf("%lld", b + i), id[b[i]] = i;
b[++m] = n;
id[n] = m;
bit.init();
memset(now, 0x3f, sizeof(now));
now[0] = 0;
long long ne = 0;
for (long long i = 1; i <= n; i++) {
if (id[a[i]]) {
if (now[id[a[i]] - 1] < inf)
dp[i] = now[id[a[i]] - 1] + bit._sum(b[id[a[i]] - 1] + 1, n) + ne;
else
dp[i] = inf;
if (p[i] >= 0)
bit.add(a[i], p[i]);
else
ne += p[i];
if (dp[i] < inf)
now[id[a[i]]] = min(now[id[a[i]]], dp[i] - bit._sum(a[i] + 1, n) - ne);
} else {
if (p[i] >= 0)
bit.add(a[i], p[i]);
else
ne += p[i];
}
}
if (dp[n] < inf)
cout << "YES\n" << dp[n];
else
puts("NO");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long BIG = 1LL << 55;
const long long INFTY = 1LL << 58;
const int MAXN = 500005;
int N, M;
int A[MAXN];
long long P[MAXN];
int B[MAXN];
int idx[MAXN];
long long BIT[MAXN];
long long sum = 0;
void add(int idx, long long val) {
for (; idx < MAXN; idx += idx & -idx) BIT[idx] = min(INFTY, BIT[idx] + val);
}
long long get(int idx) {
if (idx == 0) return sum;
long long ret = 0;
for (; idx > 0; idx -= idx & -idx) ret += BIT[idx];
return ret;
}
int main() {
ios::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];
for (int i = 1, j = 1; i <= N; i++) {
while (j <= M && B[j] < i) j++;
idx[i] = j;
}
add(1, INFTY);
for (int i = 1; i <= N; i++) {
long long same_val = INFTY;
if (idx[A[i]] <= M && B[idx[A[i]]] == A[i]) same_val = get(idx[A[i]] - 1);
add(1, P[i]);
if (P[i] > 0) add(idx[A[i]], -P[i]);
if (same_val != INFTY) {
long long cur = get(idx[A[i]]);
if (cur > same_val) {
add(idx[A[i]], same_val - cur);
add(idx[A[i]] + 1, cur - same_val);
}
}
sum += P[i];
}
long long ans = get(M);
if (ans >= BIG)
cout << "NO\n";
else
cout << "YES\n" << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const int maxn = 5e5 + 5;
int n, m;
int a[maxn], b[maxn], prv[maxn], inv[maxn];
long long ans;
long long p[maxn], dp[maxn], cost[maxn];
class FenwickTree {
private:
long long dat[maxn];
public:
inline void update(int x, long long k) {
if (!~x) return;
for (++x; x <= n + 1; x += x & (-x)) dat[x] += k;
return;
}
inline long long query(int x) {
if (!~x) return 0;
long long ret = 0;
for (++x; x; x -= x & (-x)) ret += dat[x];
return ret;
}
} fen;
int 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("%lld", p + i);
scanf("%d", &m);
for (int i = (0); i < (m); ++i) scanf("%d", b + i), --b[i];
memset(prv, -1, sizeof(prv));
memset(inv, -1, sizeof(inv));
for (int i = (1); i < (m); ++i) {
prv[b[i]] = b[i - 1];
inv[b[i]] = i;
}
inv[b[0]] = 0;
for (int i = (0); i < (n); ++i) {
cost[i] += fen.query(a[i]) - fen.query(prv[a[i]]);
if (p[i] < 0) {
ans += p[i];
cost[i] -= p[i];
} else {
fen.update(a[i], p[i]);
}
}
ans += fen.query(n) - fen.query(b[m - 1]);
memset(dp, 0x3f, sizeof(dp));
dp[0] = 0;
for (int i = (0); i < (n); ++i)
if (~inv[a[i]]) {
dp[inv[a[i]] + 1] = min(dp[inv[a[i]] + 1], dp[inv[a[i]]] + cost[i]);
}
ans += dp[m];
if (ans > INF / 2)
puts("NO");
else
printf("YES\n%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 10;
const int K = 23;
const long long INF = 1e18;
int id[N], a[N], b[N], w[N];
int n, m;
vector<int> pos[N];
long long dp[N];
int ls[N * K], rs[N * K], rootcnt = 0;
long long vs[N * K];
void copy(int root, int newroot) {
ls[newroot] = ls[root];
rs[newroot] = rs[root];
vs[newroot] = vs[root];
}
void updates(int root, int& newroot, int l, int r, int pos, int v) {
newroot = ++rootcnt;
copy(root, newroot);
vs[newroot] += v;
if (l == r || v == 0) return;
int m = (l + r) >> 1;
if (pos <= m)
updates(ls[root], ls[newroot], l, m, pos, v);
else
updates(rs[root], rs[newroot], m + 1, r, pos, v);
}
long long querys(int lt, int rt, int l, int r, int a, int b) {
if (l == a && r == b) {
return vs[rt] - vs[lt];
}
int m = (l + r) >> 1;
if (b <= m)
return querys(ls[lt], ls[rt], l, m, a, b);
else if (a > m)
return querys(rs[lt], rs[rt], m + 1, r, a, b);
else {
return querys(ls[lt], ls[rt], l, m, a, m) +
querys(rs[lt], rs[rt], m + 1, r, m + 1, b);
}
}
long long val[N << 2];
long long tag[N << 2];
void build(int root, int l, int r) {
val[root] = -INF;
tag[root] = 0;
if (l == r) return;
int m = (l + r) >> 1;
build((root << 1), l, m);
build((root << 1 | 1), m + 1, r);
}
void pushdown(int root) {
long long c = tag[root];
tag[root] = 0;
val[(root << 1)] += c;
tag[(root << 1)] += c;
val[(root << 1 | 1)] += c;
tag[(root << 1 | 1)] += c;
}
void setv(int root, int l, int r, int pos, long long v) {
if (l == r) {
val[root] = v;
return;
}
pushdown(root);
int m = (l + r) >> 1;
if (pos <= m)
setv((root << 1), l, m, pos, v);
else
setv((root << 1 | 1), m + 1, r, pos, v);
val[root] = max(val[(root << 1)], val[(root << 1 | 1)]);
}
void update(int root, int l, int r, int a, int b, long long v) {
if (v == 0) return;
if (a > b) return;
if (l == a && r == b) {
val[root] += v;
tag[root] += v;
return;
}
pushdown(root);
int m = (l + r) >> 1;
if (b <= m)
update((root << 1), l, m, a, b, v);
else if (a > m)
update((root << 1 | 1), m + 1, r, a, b, v);
else {
update((root << 1), l, m, a, m, v);
update((root << 1 | 1), m + 1, r, m + 1, b, v);
}
val[root] = max(val[(root << 1)], val[(root << 1 | 1)]);
}
long long query(int root, int l, int r, int a, int b) {
if (a > b) return -INF;
if (l == a && r == b) return val[root];
pushdown(root);
int m = (l + r) >> 1;
if (b <= m)
return query((root << 1), l, m, a, b);
else if (a > m)
return query((root << 1 | 1), m + 1, r, a, b);
else
return max(query((root << 1), l, m, a, m),
query((root << 1 | 1), m + 1, r, m + 1, b));
}
bool hasAns() {
int len = 0;
for (int i = 1; i <= n && len < m; i++) {
if (a[i] == b[len + 1]) len++;
}
return len == m;
}
int root[N];
long long lessSum(int l, int r, int v) {
if (l > r || v <= 0) return 0;
return querys(root[l - 1], root[r], 1, n, 1, v);
}
void solve() {
scanf("%d", &n);
root[0] = 0;
for (int i = 1; i <= n; i++) scanf("%d", a + i);
for (int i = 1; i <= n; i++) {
scanf("%d", w + i);
updates(root[i - 1], root[i], 1, n, a[i], max(0, w[i]));
}
scanf("%d", &m);
for (int i = 1; i <= m; i++) scanf("%d", b + i), id[b[i]] = i;
for (int i = 1; i <= n; i++) {
if (id[a[i]]) pos[id[a[i]]].push_back(i);
}
if (!hasAns()) {
printf("NO\n");
return;
}
printf("YES\n");
for (int i = 1; i <= n; i++) dp[i] = -INF;
build(1, 1, n);
for (auto p : pos[m]) {
dp[p] = lessSum(p + 1, n, b[m]) + w[p];
setv(1, 1, n, p, dp[p]);
}
for (int i = m - 1; i >= 1; i--) {
vector<int> vec;
for (auto j : pos[i + 1]) vec.push_back(j);
for (auto j : pos[i]) vec.push_back(j);
sort(vec.begin(), vec.end());
for (int j = (int)vec.size() - 2; j >= 0; j--) {
update(1, 1, n, vec[j + 1], n, lessSum(vec[j] + 1, vec[j + 1] - 1, b[i]));
if (a[vec[j]] == b[i]) {
dp[vec[j]] = query(1, 1, n, vec[j + 1], n) + w[vec[j]];
if (w[vec[j]] > 0) {
update(1, 1, n, vec[j + 1], n, w[vec[j]]);
}
}
}
for (int j = (int)vec.size() - 2; j >= 0; j--) {
update(1, 1, n, vec[j + 1], n,
-lessSum(vec[j] + 1, vec[j + 1] - 1, b[i]));
if (a[vec[j]] == b[i]) {
if (w[vec[j]] > 0) {
update(1, 1, n, vec[j + 1], n, -w[vec[j]]);
}
}
}
for (auto j : pos[i + 1]) {
setv(1, 1, n, j, -INF);
}
assert(val[1] == -INF);
for (auto j : pos[i]) {
setv(1, 1, n, j, dp[j]);
}
}
long long ans = 0;
for (int i = 1; i <= n; i++) ans += w[i];
ans -= val[1];
printf("%lld\n", ans);
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
const int N = 5e5 + 5;
int n, m, a[N], b[N], id[N], q[N];
long long f[N], g[N], h[N], p[N];
int main() {
scanf("%d", &n);
int i, j;
long long F, x = 0;
for (i = 1; i <= n; i++) scanf("%d", a + i);
for (i = 1; i <= n; i++) scanf("%lld", p + i);
scanf("%d", &m), n++, a[n] = n;
for (i = 1; i <= m; i++) scanf("%d", b + i), id[b[i]] = i;
m++, b[m] = n, id[n] = m, memset(g, 63, 8 * m + 8), F = g[0], g[0] = 0;
for (i = j = 1; i <= n; q[i++] = j)
if (b[j] < i) j++;
for (i = 1; i <= n; i++) {
j = id[a[i]];
if (j) f[i] = g[j - 1] < F ? g[j - 1] + h[j] + x : F;
if (p[i] > -1)
h[q[a[i]]] += p[i];
else
x += p[i];
if (j) (f[i] < F) && (g[j] = std::min(g[j], f[i] - x));
}
if (f[n] < F)
printf("YES\n%lld", f[n]);
else
puts("NO");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MXN = 5e5 + 10;
const long long MXS = MXN * 4;
const long long INF = 1e18;
long long n, m, ex;
long long A[MXN], B[MXN], C[MXN], lazy[MXS];
long long mn[MXN], Fen[MXN], ps[MXN];
bool check(long long p = 1) {
for (int i = 1; i <= n; i++) {
if (p <= m) p += (A[i] == B[p]);
}
return (p > m);
}
void Upd(long long p, long long x) {
for (; p < MXN; p += p & -p) Fen[p] += x;
}
long long Get(long long p) {
long long s = 0;
for (; p; p -= p & -p) s += Fen[p];
return s;
}
long long Get(long long l, long long r) {
if (r < l) return 0;
return Get(r) - Get(l - 1);
}
void Shift(long long id, long long s, long long e) {
if (!lazy[id]) return;
if ((e - s + 1) > 1) {
lazy[(id * 2)] += lazy[id];
lazy[(id * 2 + 1)] += lazy[id];
} else
mn[s] += lazy[id];
lazy[id] = 0;
}
void Push(long long p, long long id = 1, long long s = 1,
long long e = MXN - 1) {
Shift(id, s, e);
if ((e - s + 1) == 1) return;
if (p <= ((s + e) / 2))
Push(p, (id * 2), s, ((s + e) / 2));
else
Push(p, (id * 2 + 1), ((s + e) / 2 + 1), e);
}
void Add(long long l, long long r, long long x, long long id = 1,
long long s = 1, long long e = MXN - 1) {
if (e < l || s > r || r < l) return;
if (l <= s && e <= r) {
lazy[id] += x;
Shift(id, s, e);
return;
}
Add(l, r, x, (id * 2), s, ((s + e) / 2)),
Add(l, r, x, (id * 2 + 1), ((s + e) / 2 + 1), e);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n, fill(mn, mn + MXN, INF);
for (int i = 1; i <= n; i++) cin >> A[i];
for (int i = 1; i <= n; i++) cin >> C[i];
cin >> m;
for (int i = 1; i <= m; i++) cin >> B[i];
if (!check()) return cout << "NO\n", 0;
cout << "YES\n";
for (int i = n; i; i--) ps[i] = ps[i + 1] + (A[i] > B[m] ? C[i] : 0);
mn[0] = 0;
B[m + 1] = MXN - 1;
for (int i = 1; i <= n; i++) {
if (A[i] > B[m]) {
ex += C[i];
continue;
}
long long ind = lower_bound(B + 1, B + m + 1, A[i]) - B;
if (B[ind] != A[i]) {
if (C[i] > 0)
Upd(A[i], C[i]);
else
ex += C[i];
continue;
}
long long cost = Get(B[ind - 1] + 1, B[ind]);
Push(B[ind]);
if (C[i] < 0) mn[B[ind]] += C[i];
mn[B[ind]] = min(mn[B[ind]], cost + mn[B[ind - 1]]);
if (C[i] < 0)
ex += C[i], Add(A[i], A[i], -C[i]);
else
Upd(A[i], C[i]);
}
cout << mn[B[m]] + ex << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = 3.1415926535897932384626433832795;
const long long INF = 1LL << 62;
const long long MINF = -1LL << 62;
template <typename T>
T getint() {
T val = 0;
char c;
bool neg = false;
while ((c = getchar()) && !(c >= '0' && c <= '9')) {
neg |= c == '-';
}
do {
val = (val * 10) + c - '0';
} while ((c = getchar()) && (c >= '0' && c <= '9'));
return val * (neg ? -1 : 1);
}
long long n, m;
long long lz[4 * 500002];
long long tr[4 * 500002];
void push(int ind, int L, int R) {
if (lz[ind] == 0) return;
tr[ind] += lz[ind];
if (L != R) lz[2 * ind] += lz[ind], lz[2 * ind + 1] += lz[ind];
lz[ind] = 0;
}
void pull(int ind, int L, int R) {
if (L != R) {
tr[ind] = min(tr[2 * ind], tr[2 * ind] + 1);
}
}
void build(int ind, int L, int R) {
if (L == R) {
tr[ind] = 1LL << 60;
} else {
build(2 * ind, L, (L + R) / 2);
build(2 * ind + 1, (L + R) / 2 + 1, R);
pull(ind, L, R);
}
}
long long get(int ind, int L, int R, int i) {
push(ind, L, R);
if (R < i || i < L) return 1LL << 60;
if (L == R) return tr[ind];
long long res = min(get(2 * ind, L, (L + R) / 2, i),
get(2 * ind + 1, (L + R) / 2 + 1, R, i));
pull(ind, L, R);
return res;
}
void sett(int ind, int L, int R, int i, long long to) {
push(ind, L, R);
if (R < i || i < L) return;
if (L == R) {
tr[ind] = to;
return;
}
sett(2 * ind, L, (L + R) / 2, i, to);
sett(2 * ind + 1, (L + R) / 2 + 1, R, i, to);
pull(ind, L, R);
return;
}
void incr(int ind, int L, int R, int i, int j, long long by) {
push(ind, L, R);
if (R < i || j < L) return;
if (i <= L && R <= j) {
lz[ind] += by;
push(ind, L, R);
return;
}
incr(2 * ind, L, (L + R) / 2, i, j, by);
incr(2 * ind + 1, (L + R) / 2 + 1, R, i, j, by);
pull(ind, L, R);
}
long long a[500001], p[500001], b[500001];
int main() {
ios_base::sync_with_stdio(false);
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];
build(1, 0, m);
sett(1, 0, m, 0, 0);
for (int i = 1; i <= n; ++i) {
int pos = lower_bound(b, b + m + 1, a[i]) - b - 1;
if (p[i] > 0) {
incr(1, 0, m, 0, pos, p[i]);
} else {
incr(1, 0, m, 0, m, p[i]);
}
if (pos + 1 <= m && b[pos + 1] == a[i]) {
long long val = get(1, 0, m, pos) - p[i];
if (val < get(1, 0, m, pos + 1)) {
sett(1, 0, m, pos + 1, val);
}
}
}
long long res = get(1, 0, m, m);
if (res <= 1LL << 55) {
cout << "YES\n" << res << "\n";
} else {
cout << "NO\n";
}
return 0;
}
|
#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 last = 0;
for (int i = 1; i <= m; i++) {
int pp = lower_bound(pos[b[i]].begin(), pos[b[i]].end(), last) -
pos[b[i]].begin();
if (pp == pos[b[i]].size()) puts("NO"), exit(0);
last = pos[b[i]][pp];
}
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 namespace std;
const int N = 5e5 + 5;
long long n, m, a[N], b[N], p[N];
long long cost[N], dp[N], Minus;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i], dp[i] = 1e18;
for (int i = 1; i <= n; i++) cin >> p[i];
cin >> m;
for (int i = 1; i <= m; i++) cin >> b[i];
b[m + 1] = 1e18;
for (int i = 1; i <= n; i++) {
int j = lower_bound(b + 1, b + m + 2, a[i]) - b;
if (j == m + 1)
cost[j] += p[i];
else if (p[i] < 0)
cost[j] += p[i];
}
for (int i = 1; i <= n; i++) {
int j = lower_bound(b + 1, b + m + 2, a[i]) - b;
if (j == m + 1) continue;
if (b[j] == a[i] && dp[j - 1] != 1e18)
dp[j] = min(dp[j], dp[j - 1] + cost[j] - (p[i] < 0 ? p[i] : 0));
if (p[i] > 0) cost[j] += p[i];
}
if (dp[m] == 1e18) {
cout << "NO\n";
} else {
cout << "YES\n";
cout << dp[m] + cost[m + 1] << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 9;
const long long inf = -1e18, e = -1e17;
int n, m, c, l, r, x, a[N], p[N], b[N], mark[N], ans[N];
long long sum, dp[N];
vector<pair<int, long long> > tree[N * 2];
void merge(int x, int u, int v) {
int p1 = 0, p2 = 0;
long long sum1 = 0, sum2 = 0;
while (p1 < tree[u].size() || p2 < tree[v].size()) {
if (p1 == tree[u].size() ||
(p2 < tree[v].size() && tree[v][p2].first < tree[u][p1].first))
tree[x].push_back(
make_pair(tree[v][p2].first, sum1 + tree[v][p2].second)),
sum2 = tree[v][p2++].second;
else
tree[x].push_back(
make_pair(tree[u][p1].first, sum2 + tree[u][p1].second)),
sum1 = tree[u][p1++].second;
}
}
void build(int id = 1, int l = 0, int r = n) {
for (int i = n; i < 2 * n; i++)
tree[i].push_back(make_pair(a[i - n + 1], max(p[i - n + 1], 0)));
for (int i = n - 1; i >= 1; i--) merge(i, i * 2, i * 2 + 1);
}
long long binary_search(int an, int x) {
int l = -1, r = tree[an].size(), mid;
while (l + 1 < r) {
mid = (l + r) / 2;
if (tree[an][mid].first <= x)
l = mid;
else
r = mid;
}
return (l == -1 ? 0 : tree[an][l].second);
}
long long query(int l, int r, int x) {
long long res = 0;
--l;
for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
if (l & 1) res += binary_search(l++, x);
if (r & 1) res += binary_search(--r, x);
}
return res;
}
int main() {
cin >> n;
for (int i = 1; i < n + 1; i++) scanf("%d", &a[i]);
;
for (int i = 1; i < n + 1; i++) {
scanf("%d", &p[i]);
;
sum += p[i];
}
cin >> m;
for (int i = 1; i < m + 1; i++) dp[i] = inf;
for (int i = 1; i < m + 1; i++) {
scanf("%d", &b[i]);
;
mark[b[i]] = i;
}
build();
for (int i = 1; i < n + 1; i++)
if (mark[a[i]]) {
long long res = 0;
res = dp[mark[a[i]] - 1] + query(i + 1, n, a[i]) -
query(i, n, b[mark[a[i]] - 1]) + p[i];
dp[mark[a[i]]] = max(dp[mark[a[i]]], res);
;
}
cout << (dp[m] <= e ? "NO" : "YES") << endl;
if (dp[m] > e) cout << sum - dp[m];
}
|
#include <bits/stdc++.h>
const int maxn = 5E+5 + 5;
const long long INF = 0x3f3f3f3f3f3f3f;
int n, m;
int a[maxn], b[maxn];
long long p[maxn];
bool vis[maxn];
class SegmentTree {
private:
struct Node {
int lef, rig;
long long val, tag;
} t[maxn * 4];
void PushDown(int num) {
if (t[num].tag) {
t[num << 1].val += t[num].tag;
t[num << 1].tag += t[num].tag;
t[num << 1 | 1].val += t[num].tag;
t[num << 1 | 1].tag += t[num].tag;
t[num].tag = 0;
}
}
public:
void BuildTree(int num, int nlef, int nrig) {
t[num].lef = nlef, t[num].rig = nrig;
t[num].val = 0, t[num].tag = 0;
if (nlef == nrig) return;
int mid = (nlef + nrig) >> 1;
BuildTree(num << 1, nlef, mid);
BuildTree(num << 1 | 1, mid + 1, nrig);
}
void Update(int num, int nlef, int nrig, long long nval) {
if (t[num].lef >= nlef && t[num].rig <= nrig) {
t[num].val += nval;
t[num].tag += nval;
return;
}
PushDown(num);
if (nlef <= t[num << 1].rig) Update(num << 1, nlef, nrig, nval);
if (nrig >= t[num << 1 | 1].lef) Update(num << 1 | 1, nlef, nrig, nval);
t[num].val = std::min(t[num << 1].val, t[num << 1 | 1].val);
}
long long Query(int num, int nlef, int nrig) {
if (t[num].lef >= nlef && t[num].rig <= nrig) return t[num].val;
PushDown(num);
long long res = INF;
if (nlef <= t[num << 1].rig)
res = std::min(res, Query(num << 1, nlef, nrig));
if (nrig >= t[num << 1 | 1].lef)
res = std::min(res, Query(num << 1 | 1, nlef, nrig));
return res;
}
} str;
int main() {
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), ++m;
for (int i = 2; i <= m; ++i) scanf("%d", &b[i]);
str.BuildTree(1, 1, m), vis[1] = 1;
for (int i = 1; i <= n; ++i) {
int pos = std::upper_bound(b + 1, b + m + 1, a[i]) - b - 1;
if (p[i] < 0 && pos < m) str.Update(1, pos + 1, m, p[i]);
if (b[pos] == a[i] && vis[pos - 1]) {
long long v0 = str.Query(1, pos - 1, pos - 1);
long long v1 = str.Query(1, pos, pos);
if (vis[pos]) {
long long v2 = std::min(v1 + std::min(p[i], 0ll), v0);
str.Update(1, pos, pos, v2 - v1);
} else
str.Update(1, pos, pos, v0 - v1);
vis[pos] = 1;
} else
str.Update(1, pos, pos, p[i]);
if (pos > 1) str.Update(1, 1, pos - 1, p[i]);
}
if (vis[m])
printf("YES\n%lld\n", str.Query(1, m, m));
else
puts("NO");
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1000777;
long long n, m;
long long a[N];
long long p[N];
long long b[N];
long long t[4 * N];
long long t2[4 * N];
map<long long, long long> mp;
long long nl = 0;
void build(long long v, long long tl, long long tr) {
if (tl == tr) {
t[v] = p[tl];
} else {
long long tm = (tl + tr) / 2;
build(v * 2, tl, tm);
build(v * 2 + 1, tm + 1, tr);
t[v] = t[v * 2] + t[v * 2 + 1];
}
}
void update(long long v, long long tl, long long tr, long long pos,
long long x) {
if (tl > tr) {
return;
}
if (tl == tr) {
t[v] = x;
} else {
long long tm = (tl + tr) / 2;
if (pos <= tm) {
update(v * 2, tl, tm, pos, x);
} else {
update(v * 2 + 1, tm + 1, tr, pos, x);
}
t[v] = t[v * 2] + t[v * 2 + 1];
}
}
long long get(long long v, long long tl, long long tr, long long l,
long long r) {
if (tl > tr) {
return 0;
}
if (l > r) {
return 0;
}
if (l == tl && r == tr) {
return t[v];
} else {
long long tm = (tl + tr) / 2;
return get(v * 2, tl, tm, l, min(r, tm)) +
get(v * 2 + 1, tm + 1, tr, max(l, tm + 1), r);
}
}
bool check() {
long long j = 1;
for (long long i = 1; i <= n; i++) {
if (a[i] == b[j]) {
j++;
if (j == m + 1) {
return 1;
}
}
}
return 0;
}
vector<long long> g[N];
long long ans = 1e18;
long long inf = 1e18;
long long otv[N];
set<long long> st;
map<long long, long long> to;
long long from[N];
long long sz = 0;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
st.insert(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];
}
for (long long i = 1; i <= n; i++) {
otv[i] = inf;
}
if (!check()) {
cout << "NO"
<< "\n";
return 0;
}
cout << "YES"
<< "\n";
for (auto it = st.begin(); it != st.end(); it++) {
long long x = *it;
sz++;
to[x] = sz;
from[sz] = x;
}
for (long long i = 1; i <= n; i++) {
a[i] = to[a[i]];
}
for (long long i = 1; i <= m; i++) {
b[i] = to[b[i]];
}
for (long long i = 1; i <= n; i++) {
g[a[i]].push_back(i);
}
long long j = 1;
build(1, 1, n);
for (long long i = 1; i <= b[m]; i++) {
long long k = 0;
long long sum = 1e18;
if (i == b[j]) {
if (j == 1) {
for (long long ii = 0; ii < g[i].size(); ii++) {
long long id = g[i][ii];
otv[id] = get(1, 1, n, 1, id - 1);
}
for (long long ii = 0; ii < g[i].size(); ii++) {
long long id = g[i][ii];
if (p[id] > 0) {
update(1, 1, n, id, 0);
}
}
long long x = i - 1;
while (x >= 1) {
for (long long ii = 0; ii < g[x].size(); ii++) {
long long id = g[x][ii];
if (p[id] > 0) {
update(1, 1, n, id, 0);
}
}
x--;
}
j++;
if (j == m + 1) {
break;
}
} else {
vector<pair<long long, long long> > vec;
long long x = b[j - 1];
long long y = i;
for (long long ii = 0; ii < g[x].size(); ii++) {
vec.push_back({g[x][ii], 1});
}
for (long long ii = 0; ii < g[y].size(); ii++) {
vec.push_back({g[y][ii], 2});
}
sort(vec.begin(), vec.end());
for (long long ii = 0; ii < vec.size(); ii++) {
long long id = vec[ii].first;
if (vec[ii].second == 1) {
if (otv[id] == inf) {
continue;
}
sum = min(sum + get(1, 1, n, k + 1, id), otv[id]);
k = id;
} else {
if (k == 0) {
continue;
}
otv[id] = sum + get(1, 1, n, k + 1, id - 1);
}
}
while (x < y) {
for (long long ii = 0; ii < g[y].size(); ii++) {
long long id = g[y][ii];
if (p[id] > 0) {
update(1, 1, n, id, 0);
}
}
y--;
}
j++;
if (j == m + 1) {
break;
}
}
} else {
continue;
}
}
for (long long i = 0; i < g[b[m]].size(); i++) {
long long id = g[b[m]][i];
ans = min(ans, otv[id] + get(1, 1, n, id + 1, n));
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int pct(int x) { return __builtin_popcount(x); }
int pct(long long x) { return __builtin_popcountll(x); }
int bit(int x) { return 31 - __builtin_clz(x); }
int bit(long long x) { return 63 - __builtin_clzll(x); }
int cdiv(int a, int b) { return a / b + !(a < 0 || a % b == 0); }
long long cdiv(long long a, long long b) {
return a / b + !(a < 0 || a % b == 0);
}
template <typename T>
void leftShift(vector<T> &v, long long k) {
k %= (int)v.size();
if (k < 0) k += (int)v.size();
rotate(v.begin(), v.begin() + k, v.end());
}
template <typename T>
void rightSift(vector<T> &v, long long k) {
leftShift(v, (int)v.size() - k);
}
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
long long rand(long long l, long long r) {
uniform_int_distribution<long long> uid(l, r);
return uid(rng);
}
inline int nxt() {
int x;
cin >> x;
return x;
}
inline int nxtll() {
long long x;
cin >> x;
return x;
}
void pr() {}
void sc() {}
template <typename Head, typename... Tail>
void pr(Head H, Tail... T) {
cout << H << " ";
pr(T...);
}
template <typename Head, typename... Tail>
void sc(Head &H, Tail &...T) {
cin >> H;
sc(T...);
}
string to_string(__int128 x) {
string s = "";
bool neg = 0;
if (x < 0) {
s += "-";
neg = 1;
}
if (!x) s += '0';
while (x) {
int rem = x % 10;
s += to_string(rem);
x /= 10;
}
reverse(s.begin() + neg, s.end());
return s;
}
const int mod = 1e9 + 7;
int pwr(int a, int b) {
int ans = 1;
while (b) {
if (b & 1) ans = (ans * 1LL * a) % mod;
a = (a * 1LL * a) % mod;
b >>= 1;
}
return ans;
}
template <typename T>
class Segtree_Without_Lazy {
struct node {
T val;
};
int n;
vector<node> tr;
T Id;
inline T op(T a, T b) { return a + b; }
inline node merge(node a, node b) {
node ans;
ans.val = op(a.val, b.val);
return ans;
}
void build(int nd, int s, int e, const vector<T> &v) {
if (s == e) {
tr[nd].val = v[s];
return;
}
int m = (s + e) >> 1;
build(nd << 1, s, m, v);
build(nd << 1 | 1, m + 1, e, v);
tr[nd] = merge(tr[nd << 1], tr[nd << 1 | 1]);
}
void upd(int idx, T x, int nd, int s, int e) {
if (s == e) {
tr[nd].val = op(tr[nd].val, x);
return;
}
int m = (s + e) >> 1;
if (idx <= m)
upd(idx, x, nd << 1, s, m);
else
upd(idx, x, nd << 1 | 1, m + 1, e);
tr[nd] = merge(tr[nd << 1], tr[nd << 1 | 1]);
}
T query(int l, int r, int nd, int s, int e) {
if (s > r || e < l) return Id;
if (l <= s && e <= r) return tr[nd].val;
int m = (s + e) >> 1;
return op(query(l, r, nd << 1, s, m), query(l, r, nd << 1 | 1, m + 1, e));
}
void print(int l, int r, int nd, int s, int e, vector<T> &v) {
if (s > r || e < l) return;
if (s == e) {
v.push_back(tr[nd].val);
return;
}
int m = (s + e) >> 1;
print(l, r, nd << 1, s, m, v);
print(l, r, nd << 1 | 1, m + 1, e, v);
}
public:
Segtree_Without_Lazy(int nn) : n(nn), Id(0), tr(4 * nn, {0}) {}
Segtree_Without_Lazy(const vector<T> &v)
: n((int)v.size() - 1), tr(4 * n), Id(0) {
build(1, 1, n, v);
}
void upd(int idx, T val) {
assert(1 <= idx && idx <= n);
upd(idx, val, 1, 1, n);
}
T query(int l, int r) {
if (l > r) return Id;
assert(1 <= l && r <= n);
return query(l, r, 1, 1, n);
}
void print(int l, int r) {
vector<T> v;
print(l, r, 1, 1, n, v);
42;
}
};
const int N = 5e5 + 5;
int a[N], p[N], b[N];
int in[N];
long long dp[N];
void solve() {
int n;
sc(n);
for (int i = 1; i <= n; i++) {
sc(a[i + 1]);
a[i + 1]++;
}
for (int i = 1; i <= n; i++) {
sc(p[i + 1]);
}
a[1] = 1;
n++;
int m;
sc(m);
for (int i = 1; i <= m; i++) {
sc(b[i + 1]);
b[i + 1]++;
}
b[1] = 1;
m++;
for (int i = 1; i <= n; i++) {
if (binary_search(b + 1, b + m + 1, a[i])) {
in[i] = lower_bound(b + 1, b + m + 1, a[i]) - b;
}
}
dp[1] = 0;
for (int i = 2; i <= n; i++) {
dp[i] = 1e18;
}
long long ans = 0;
Segtree_Without_Lazy<long long> s(n);
long long tot = 0;
for (int i = 2; i <= n; i++) {
if (in[i]) {
long long val = dp[b[in[i] - 1]] + s.query(b[in[i] - 1] + 1, n) + tot;
if (p[i] < 0) tot += p[i];
42;
dp[a[i]] = min(dp[a[i]], val - s.query(a[i] + 1, n) - tot);
if (p[i] >= 0) s.upd(a[i], p[i]);
} else {
if (p[i] < 0) {
ans += p[i];
continue;
} else {
s.upd(a[i], p[i]);
}
}
}
ans += dp[b[m]] + s.query(b[m] + 1, n) + tot;
if (ans > 1e16) {
cout << "NO" << '\n';
} else {
cout << "YES" << '\n';
pr(ans);
}
}
signed main() {
ios ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
t = 1;
for (int tt = 1; tt <= t; tt++) {
solve();
}
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 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);
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 && lst >= pos[cur] - 1) {
long long bst = query(0, m, 1, pos[cur] - 1),
prev = (lst >= pos[cur] ? query(0, m, 1, pos[cur]) : inf);
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);
}
lst = max(lst, pos[cur]);
}
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;
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 = 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]);
}
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;
const long long inf = 0x3f3f3f3f;
const long long maxn = 201110;
const long long M = 1e9 + 7;
long long n, m, k, ok;
long long mii(long long x) {
long long res = 9;
while (x) {
res = min(res, x % 10);
x /= 10;
}
return res;
}
long long mxx(long long x) {
long long res = 0;
while (x) {
res = max(res, x % 10);
x /= 10;
}
return res;
}
signed main() {
long long T;
cin >> T;
while (T--) {
cin >> n >> k;
long long mi = mii(n), mx = mxx(n);
for (long long i = 1; i < k && mi; i++) {
n += mi * mx;
mi = mii(n), mx = mxx(n);
}
cout << n << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
void cp() {
long long int n, k;
cin >> n >> k;
bool zero = false;
while (k != 1 && !zero) {
long long int temp = n;
int mxdig = INT_MIN;
int midig = INT_MAX;
while (temp > 0) {
int n = temp % 10;
mxdig = max(mxdig, n);
midig = min(midig, n);
temp /= 10;
if (!midig || !mxdig) {
zero = true;
break;
}
}
n += midig * mxdig;
k--;
}
cout << n << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int t;
t = 1;
cin >> t;
while (t--) {
cp();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
unsigned long long int min_digit(unsigned long long int a) {
unsigned long long int ans = 9;
while (a) {
ans = min(ans, a % 10);
a /= 10;
}
return ans;
}
unsigned long long int max_digit(unsigned long long int a) {
unsigned long long int ans = 0;
while (a) {
ans = max(ans, a % 10);
a /= 10;
}
return ans;
}
int main() {
unsigned long long int t, a, k, prev, x, y;
cin >> t;
while (t--) {
cin >> a >> k;
prev = a;
for (unsigned long long i = 1; i < k; ++i) {
x = min_digit(a);
y = max_digit(a);
a += x * y;
if (prev == a) break;
prev = a;
}
cout << a << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long x, k;
cin >> x >> k;
while (--k) {
int mn = 9, mx = 0;
for (long long i = x; i; i /= 10)
mn = min(1LL * mn, i % 10), mx = max(1LL * mx, i % 10);
if (!mn) break;
x += mn * mx;
}
cout << x << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long a, k, c, d;
long long mindigit(long long val) {
long long mn = 10;
while (val > 0) {
mn = min(val % 10, mn);
val /= 10;
}
return mn;
}
long long maxdigit(long long val) {
long long mx = -1;
while (val > 0) {
mx = max(val % 10, mx);
val /= 10;
}
return mx;
}
int main() {
int t;
scanf("%d", &t);
while (t--) {
scanf("%lld %lld", &a, &k);
k--;
while (k--) {
c = mindigit(a), d = maxdigit(a);
if (c == 0) {
break;
}
a += c * d;
}
printf("%lld\n", a);
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, t, k;
long long a[1000001];
int main() {
cin >> t;
while (t--) {
cin >> n >> k;
m = n;
for (int i = 1; i < k; i++) {
n = m;
long long min1 = 10, max1 = -1;
while (n) {
min1 = min(min1, n % 10);
max1 = max(max1, n % 10);
n /= 10;
}
m = m + min1 * max1;
if (min1 == 0) break;
}
cout << m << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
for (int i = 0; i < t; i++) {
long long int A;
cin >> A;
long long int k;
cin >> k;
int mi = A % 10;
int ma = A % 10;
long long int B = A;
while (k > 1) {
mi = A % 10;
ma = A % 10;
if (mi == 0) break;
while (A > 0) {
if (A % 10 > ma) ma = A % 10;
if (A % 10 < mi) mi = A % 10;
A = A / 10;
if (mi == 0) break;
}
if (mi == 0) break;
B = B + (mi * ma);
A = B;
k--;
}
cout << B << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long a1, k;
cin >> a1 >> k;
long long ans = a1;
k--;
while (k--) {
long long max = 0, min = 9;
long long temp = ans;
while (temp) {
long long n = temp % 10;
if (n < min) min = n;
if (n > max) max = n;
temp /= 10;
}
if (min == 0) break;
ans = ans + min * max;
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll getAdd(ll x) {
ll m1 = 10, m2 = 0;
while (x > 0) {
ll y = x % 10;
x /= 10;
m1 = min(m1, y);
m2 = max(m2, y);
}
return m1 * m2;
}
int main() {
int t;
scanf("%d", &t);
while (t--) {
ll x, k;
scanf("%lld%lld", &x, &k);
k--;
while (k--) {
ll y = getAdd(x);
if (y == 0) break;
x += y;
}
printf("%lld\n", x);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
while (a && b) {
if (a > b)
a = a % b;
else
b = b % a;
}
return a + b;
}
long long fact(int n) {
if (n == 0) return 1;
return fact(n - 1) * n;
}
long long lcm(long long a, long long b) {
long long temp = gcd(a, b);
return temp ? (a / temp * b) : 0;
}
bool isPolindrom(string s) {
for (int i = 0; i < s.length() / 2; ++i) {
if (s[i] != s[s.length() - 1 - i]) return false;
}
return true;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t;
cin >> t;
while (t--) {
long long n, k;
cin >> n >> k;
while (--k) {
long long tp = n;
int mx = -1, mn = 10;
while (tp) {
if (mx < tp % 10) mx = tp % 10;
if (mn > tp % 10) mn = tp % 10;
tp /= 10;
}
if (!mn) break;
n += (mx * mn);
}
cout << n << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimization("unroll-loops")
using namespace std;
const long long INF = 998244353;
long long mx(long long n) {
long long m = INT_MIN;
while (n) {
m = max(m, n % 10);
n /= 10;
}
return m;
}
long long mn(long long n) {
long long m = INT_MAX;
while (n) {
m = min(m, n % 10);
n /= 10;
}
return m;
}
int main() {
long long t = 1;
cin >> t;
while (t--) {
long long n, k;
cin >> n >> k;
for (int i = 1; i < k; i++) {
long long m = mn(n);
long long mn = mx(n);
if (mn == 0 || m == 0) {
break;
}
n += mn * m;
}
cout << n << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> sum(long long int n) {
long long int mx = INT_MIN, mn = INT_MAX;
while (n > 0) {
mx = max(mx, n % 10);
mn = min(mn, n % 10);
n /= 10;
}
std::vector<int> v;
v.push_back(mx);
v.push_back(mn);
return v;
}
int main() {
long long int t, n, i, j, k;
cin >> t;
while (t--) {
cin >> n >> k;
k--;
std::vector<int> v;
while (k--) {
v = sum(n);
n += (v[0] * v[1]);
if (v[0] == 0 or v[1] == 0) break;
}
cout << n << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
long long a, k;
cin >> a >> k;
long long res = a;
long long prev = a;
for (int i = 0; i < k - 1; i++) {
long long mini = 9, maxi = 0;
res = prev;
while (prev > 0) {
mini = min(mini, prev % 10);
maxi = max(maxi, prev % 10);
prev /= 10;
}
res += mini * maxi;
if (mini == 0) break;
prev = res;
}
cout << res << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
pair<long long int, long long int> minmax(long long int n) {
long long int d;
vector<long long int> v;
while (n > 0) {
d = n % 10;
v.push_back(d);
n = n / 10;
}
long long int a = *min_element(v.begin(), v.end());
long long int b = *max_element(v.begin(), v.end());
pair<long long int, long long int> p;
p = make_pair(a, b);
return p;
}
int main() {
long long int i, t, j, inp, k, n;
cin >> t;
for (i = 0; i < t; i++) {
cin >> n >> k;
pair<long long int, long long int> p;
p = minmax(n);
j = 1;
while (p.first != 0 && j < k) {
n += p.first * p.second;
p = minmax(n);
j++;
}
cout << n << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T read() {
T x = 0;
int f = 1;
char k = getchar();
for (; k > '9' || k < '0'; k = getchar())
if (k == '-') f = -1;
for (; k >= '0' && k <= '9'; k = getchar()) x = x * 10 + k - '0';
return x * f;
}
template <class T>
inline T read(T &x) {
return x = read<T>();
}
int _num, _buf[20];
inline void print(long long x) {
if (x == 0) return putchar('0'), void();
if (x < 0) putchar('-'), x = -x;
while (x) _buf[++_num] = x % 10, x /= 10;
while (_num) putchar(_buf[_num--] + '0');
}
long long mul(long long a, long long b, long long mod) {
long double c = 1.;
return (a * b - (long long)(c * a * b / mod) * mod) % mod;
}
inline int qpow(int x, int m, int mod) {
int res = 1, bas = x;
while (m) {
if (m & 1) res = (1ll * res * bas) % mod;
bas = (1ll * bas * bas) % mod, m >>= 1;
}
return res;
}
int T;
long long a, k;
inline void Solve() {
a = read<long long>(), k = read<long long>() - 1;
while (k--) {
long long tmp = a;
int mx = 0, mn = 9;
while (tmp) {
int c = tmp % 10;
mx = std::max(mx, c);
mn = std::min(mn, c);
tmp /= 10;
}
if (mn == 0) return print(a), puts(""), void();
a += mx * mn;
}
print(a), puts("");
}
int main() {
T = read<int>();
while (T--) Solve();
cerr << 1. * clock() / CLOCKS_PER_SEC << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int digits(long long a) {
int largest = 0;
int smallest = 9;
while (a) {
int r = a % 10;
largest = max(r, largest);
smallest = min(r, smallest);
a /= 10;
}
return smallest * largest;
}
int main() {
int t;
long long a, K;
cin >> t;
while (t--) {
cin >> a >> K;
while (K > 1) {
int dig = digits(a);
if (dig == 0) break;
a += digits(a);
K--;
}
cout << a << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int T;
long long n, k;
pair<int, int> ask(long long x) {
int Maxv = 0, Minv = 10;
while (x) {
Maxv = max(1ll * Maxv, x % 10), Minv = min(1ll * Minv, x % 10);
x /= 10;
}
return make_pair(Maxv, Minv);
}
void work() {
scanf("%lld%lld", &n, &k);
long long ans = n, t = 1;
while (t < k) {
t++;
pair<int, int> az = ask(ans);
if (az.second == 0) break;
ans += az.first * az.second;
}
printf("%lld\n", ans);
}
int main() {
scanf("%d", &T);
while (T--) work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int mind(long long int num) {
long long int ma = 0;
long long int mi = 10;
int m;
while (num != 0) {
m = num % 10;
if (m > ma) ma = m;
if (m < mi) mi = m;
num /= 10;
}
return (ma * mi);
}
void solve() {
long long int x, k;
cin >> x >> k;
long long int q = x, w;
if (k == 1) {
cout << x << "\n";
return;
}
for (long long int i = 2; i <= k; i++) {
w = mind(q);
if (w == 0) break;
q += w;
}
cout << q << "\n";
return;
}
int main() {
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
int max_digit(long long n) {
int rem;
int high = -1;
while (n != 0) {
rem = n % 10;
if (rem > high) high = rem;
n /= 10;
}
return high;
}
int min_digit(long long n) {
int rem;
int low = 11;
while (n != 0) {
rem = n % 10;
if (rem < low) low = rem;
n /= 10;
}
return low;
}
using namespace std;
int main() {
int t;
long long a, k;
cin >> t;
while (t--) {
cin >> a >> k;
for (long long i = 2; i <= k; i++) {
if (min_digit(a) == 0)
break;
else
a = a + max_digit(a) * min_digit(a);
}
cout << a << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int q;
cin >> q;
while (q--) {
long long aaa, kkk;
cin >> aaa >> kkk;
long long as = aaa, tp = aaa, maax = -1, miin = aaa;
if (kkk == 1) {
cout << aaa << endl;
continue;
}
while (tp > 0) {
long long nn = tp % 10;
tp /= 10;
if (nn > maax) maax = nn;
if (nn < miin) miin = nn;
}
as += (maax * miin);
kkk--;
kkk--;
while (as != aaa and kkk > 0) {
aaa = as;
maax = -1;
miin = aaa;
tp = aaa;
while (tp > 0) {
long long nn = tp % 10;
tp /= 10;
if (nn > maax) maax = nn;
if (nn < miin) miin = nn;
}
as += (maax * miin);
kkk--;
}
cout << as << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long numToAdd(long long x) {
if (x == 0) return 0;
long long mino = INT64_MAX, maxo = 0;
while (x != 0) {
long long dig = x % 10;
mino = min(dig, mino);
maxo = max(dig, maxo);
x = x / 10;
}
return mino * maxo;
}
int main() {
int t;
cin >> t;
while (t--) {
long long x, k;
cin >> x >> k;
for (int i = 1; i < k; i++) {
long long num = numToAdd(x);
if (num == 0) {
break;
}
x = x + num;
}
cout << x << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long int a, k;
cin >> a >> k;
long long int co = 1;
while (co < k) {
co += 1;
long long int b = a, ma = INT_MIN, mi = INT_MAX;
while (b) {
long long int r = b % 10;
mi = min(r, mi);
ma = max(r, ma);
b /= 10;
}
a = a + ma * mi;
if (ma * mi == 0) {
break;
}
}
cout << a << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dx[] = {1, 2, 1, -1, -2, 2, -1, -2};
int dy[] = {2, 1, -2, 2, 1, -1, -2, -1};
const int MOD = 1e9 + 7;
long long power(long long x, long long y) {
if (y == 0) return 1;
long long s = power(x, y / 2);
s *= s;
if (y & 1) s *= x;
return s;
}
long long Ceil(long long x, long long y) { return (x + y - 1) / y; }
bool has_zero(long long x) {
while (x != 0) {
int dig = x % 10;
x /= 10;
if (dig == 0) return 1;
}
return 0;
}
int get_min(long long x) {
int mn = 10;
while (x != 0) {
int dig = x % 10;
x /= 10;
mn = min(mn, dig);
}
return mn;
}
int get_max(long long x) {
int mx = 0;
while (x != 0) {
int dig = x % 10;
x /= 10;
mx = max(mx, dig);
}
return mx;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int T;
cin >> T;
while (T--) {
long long n, k;
cin >> n >> k;
int i = 1;
while (!has_zero(n) && i < k) {
i++;
n += get_min(n) * get_max(n);
}
cout << n << "\n";
}
cin.get();
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[500008];
long long maxidig(long long n) {
long long maxi = -1;
while (n) {
maxi = max(maxi, n % 10);
n /= 10;
}
return maxi;
}
long long minidig(long long n) {
long long maxi = 11;
while (n) {
maxi = min(maxi, n % 10);
n /= 10;
}
return maxi;
}
signed main() {
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
long long k;
cin >> k;
long long mini = minidig(n);
long long maxi = maxidig(n);
long long ans = n;
for (long long i = 1; i < k; i++) {
if (minidig(ans) == 0 || maxidig(ans) == 0) break;
ans += (minidig(ans) * maxidig(ans));
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
const int MOD = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int T;
cin >> T;
while (T--) {
long long n, k;
cin >> n >> k;
long long ans = n, tmp;
for (int i = 1; i <= k - 1; i++) {
long long minDigit = 10, maxDigit = 0;
tmp = ans;
while (tmp) {
minDigit = min(minDigit, tmp % (long long)10);
maxDigit = max(maxDigit, tmp % (long long)10);
tmp /= (long long)10;
}
ans += (minDigit * maxDigit);
if (minDigit == 0 || maxDigit == 0) break;
}
cout << ans << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void test() {
long long n, k;
cin >> n >> k;
long long prev = n;
for (long long i = 0; i < k - 1; i++) {
string s = to_string(prev);
sort(s.begin(), s.end());
long long x = (s[0] - '0') * (s[s.length() - 1] - '0');
prev = prev + x;
if (x == 0) break;
}
cout << prev << "\n";
}
int main() {
int t = 1;
cin >> t;
while (t--) {
test();
}
}
|
#include <bits/stdc++.h>
using namespace std;
int mi_f(vector<int> v) {
int mi = 9, i;
for (i = 0; i < v.size(); i++) mi = min(mi, v[i]);
return mi;
}
int ma_f(vector<int> v) {
int ma = 0, i;
for (i = 0; i < v.size(); i++) ma = max(ma, v[i]);
return ma;
}
vector<int> add_f(vector<int> v, int p) {
int i, j;
v[0] += p;
int l = 0;
for (i = 0; i < v.size(); i++) {
v[i] += l;
if (v[i] > 9) {
l = v[i] / 10;
v[i] = v[i] % 10;
} else
l = 0;
}
if (l > 0) v.push_back(l);
return v;
}
int main() {
int t;
cin >> t;
while (t--) {
int i, j;
long long int m, a, k, l;
cin >> a >> k;
vector<int> v;
while (a > 0) {
int p = a % 10;
a = a / 10;
v.push_back(p);
}
for (i = 1; i < k; i++) {
int mi = mi_f(v);
int ma = ma_f(v);
if (mi == 0) break;
v = add_f(v, mi * ma);
}
for (i = v.size() - 1; i > -1; i--) cout << v[i];
cout << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t) {
t--;
unsigned long long a, k;
cin >> a >> k;
for (unsigned long long i = 2; i <= k; i++) {
int x = 10;
int y = -1;
unsigned long long z = a;
while (z) {
int k = z % 10;
x = min(x, k);
y = max(y, k);
z = z / 10;
}
if (x * y == 0) break;
a = a + x * y;
}
cout << a << endl;
}
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(3)
using namespace std;
const double PI = acos(-1.0);
const double eps = 1e-6;
int main() {
long long t;
cin >> t;
while (t--) {
long long a1, k;
cin >> a1 >> k;
if (k == 1)
cout << a1 << endl;
else {
bool ok = 1;
for (long long i = 2; i <= k; i++) {
long long mn = 10, mx = -1;
long long tmp = a1;
while (tmp > 0) {
mn = min(tmp % 10, mn);
mx = max(tmp % 10, mx);
tmp /= 10;
}
if (mn == 0) {
cout << a1 << endl;
ok = 0;
break;
} else
a1 += (mn * mx);
}
if (ok == 1) cout << a1 << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
pair<long long int, long long int> digits(long long int a) {
map<long long int, long long int> mp;
vector<long long int> v;
long long int mini = LONG_LONG_MAX;
long long int maxi = LONG_LONG_MIN;
while (a) {
long long int rem = a % 10;
mini = min(mini, rem);
maxi = max(maxi, rem);
a = a / 10;
}
return make_pair(mini, maxi);
}
void solve() {
long long int a, k;
cin >> a >> k;
long long int s = a;
for (long long int i = 0; i < k - 1; i++) {
pair<long long int, long long int> p = digits(a);
s = s + (p.first * p.second);
a = s;
if (p.first == 0) {
break;
}
}
cout << a << "\n";
}
int main() {
long long int t;
cin >> t;
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(3)
#pragma GCC optimize(2)
const long long P = 998244353;
using namespace std;
inline void ckmax(long long &a, long long b) { a = max(a, b); }
inline void ckmin(long long &a, long long b) { a = min(a, b); }
inline void mulmod(long long &a, long long b) { a = 1ll * a * b % P; }
inline void addmod(long long &a, long long b) {
long long t = a + b;
a = (t >= P ? t - P : t);
}
inline long long ksm(long long a, long long b) {
long long ans = 1;
for (; b; b >>= 1) {
if (b & 1) ans = 1ll * ans * a % P;
a = 1ll * a * a % P;
}
return ans;
}
inline long long inv(long long a) { return ksm(a, P - 2); }
inline long long read() {
long long num = 0, flag = 1;
char c = ' ';
for (; !isdigit(c); c = getchar())
if (c == '-') flag = -1;
for (; isdigit(c); num = num * 10 + c - 48, c = getchar())
;
return num * flag;
}
const long long MAXN = 2e5 + 5;
inline long long check(long long &a) {
long long t = a, mi = 9, mx = 0;
while (t) {
ckmin(mi, t % 10);
ckmax(mx, t % 10);
t /= 10;
}
a += mx * mi;
if (mx * mi == 0) return 0;
return 1;
}
signed main() {
long long T = read();
while (T--) {
long long a = read(), b = read();
b--;
while (1) {
if (!b) break;
b--;
if (!check(a)) break;
}
printf("%lld\n", a);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> visited(200000, 0);
vector<long long> adj[200000];
long long prime[2000000];
long long M = 1000000007;
void boost() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
void sieve(long long ending) {
for (long long i = 2; i < ending; i++) prime[i] = 1;
for (long long i = 2; i * i <= ending; i++) {
if (prime[i] == 1) {
for (long long j = 2 * i; j <= ending; j = j + i) {
prime[j] = 0;
}
}
}
prime[1] = 0;
}
long long ncrmodp(long long num, long long r) {
long long C[r + 1];
long long i, j;
memset(C, 0, sizeof(C));
C[0] = 1;
for (i = 1; i <= num; i++) {
for (j = min(i, r); j > 0; j--) {
C[j] = ((C[j]) % M + (C[j - 1]) % M) % M;
}
}
return C[r];
}
long long power(long long x, long long y) {
long long res = 1;
x = x % M;
while (y > 0) {
if (y & 1) res = (res * x) % M;
y = y >> 1;
x = (x * x) % M;
}
return res;
}
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;
}
void solve() {
long long a1, k;
cin >> a1 >> k;
k--;
string s;
while (k--) {
s = to_string(a1);
long long mini = 9;
long long maxi = 0;
for (long long i = 0; i < s.length(); i++) {
mini = min(mini, s[i] - '0');
maxi = max(maxi, s[i] - '0');
}
a1 = a1 + mini * maxi;
if (mini == 0 || maxi == 0) break;
}
cout << a1 << endl;
}
int main() {
boost();
long long t;
cin >> t;
while (t--) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int q;
cin >> q;
while (q--) {
string x;
long long y;
cin >> x >> y;
--y;
int maxi = 0, mini = 9;
for (char c : x) maxi = max(maxi, c - '0'), mini = min(mini, c - '0');
long long current = stoll(x);
while (mini != 0 && y) {
--y;
current += (mini * maxi);
x = to_string(current);
mini = 9, maxi = 0;
for (char c : x) maxi = max(maxi, c - '0'), mini = min(mini, c - '0');
}
cout << current << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int N = 2e5 + 5;
void solve() {
long long int n, k;
cin >> n >> k;
for (long long int i = 0; i < k - 1; i++) {
long long int mi = 10, ma = 0, m = n;
while (m > 0) {
mi = min(mi, m % 10);
ma = max(ma, m % 10);
m /= 10;
}
if (mi == 0) {
break;
}
n += mi * ma;
}
cout << n << '\n';
}
signed main() {
ios_base::sync_with_stdio(0), cin.tie(NULL), cout.tie(NULL);
long long int t = 1;
cin >> t;
while (t--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
int a[20];
int main() {
long long a, k;
int num;
cin >> num;
while (num--) {
cin >> a >> k;
int ans = 0;
k -= 1;
while (k--) {
long long mm = -100;
long long mi = 1000;
long long temp = a;
while (temp) {
mm = max(mm, temp % 10);
mi = min(mi, temp % 10);
temp = temp / 10;
}
if (mm == 0 || mi == 0) break;
a += mm * mi;
}
cout << a << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t = 1;
cin >> t;
while (t--) {
long long n, k, k2 = 0;
cin >> n >> k;
map<long long, long long> a;
a[1] = n;
for (long long i = 2; i <= k; ++i) {
long long k1 = a[i - 1], mn = 10, mx = 0;
while (k1 > 0) {
mn = min(mn, k1 % 10);
mx = max(mx, k1 % 10);
k1 /= 10;
}
a[i] = mn * mx + a[i - 1];
if (mn == 0) {
cout << a[i] << "\n";
k2++;
break;
}
}
if (k2 == 0) cout << a[k] << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(void) {
long long int t, a1, k;
cin >> t;
for (long long int i = 0; i < t; i++) {
cin >> a1 >> k;
long long int min = 10, max = -1, x, y;
for (long long int j = 1; j < k; j++) {
x = a1;
min = 10;
max = -1;
while (x != 0) {
y = x % 10;
x /= 10;
if (y > max) {
max = y;
}
if (y < min) {
min = y;
}
}
if (min == 0) {
break;
}
a1 += min * max;
}
cout << a1 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool trans(long long int &m) {
long long int n = m;
long long int minD = n % 10, maxD = n % 10;
for (; n; n /= 10) {
if (n % 10 == 0) {
return true;
}
minD = min(minD, n % 10);
maxD = max(maxD, n % 10);
}
m += minD * maxD;
return false;
}
void solve() {
long long int a, k;
cin >> a >> k;
for (long long int i = 1; i < k; ++i) {
if (trans(a)) {
break;
}
}
cout << a << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int T;
cin >> T;
for (int t = 0; t < T; ++t) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 105;
const long long INF = LLONG_MAX / 2;
void solve() {
long long n, k;
cin >> n >> k;
for (long long i = 1; i < k; i++) {
string second = to_string(n);
long long minv = 10, maxv = 0;
for (long long j = 0; j < (long long)second.length(); j++) {
minv = min(minv, (long long)second[j] - '0');
maxv = max(maxv, (long long)second[j] - '0');
}
if (minv == 0 or maxv == 0) break;
n += minv * maxv;
}
cout << n << "\n";
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long tc;
cin >> tc;
while (tc--) solve();
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("-Ofast", "-funroll-all-loops")
using namespace std;
long long a, k, res;
inline long long check(long long x) {
while (x) {
if (x % 10 == 0) return 1;
x /= 10;
}
return 0;
}
inline long long f(long long x) {
long long res = 0;
while (x) res = max(res, x % 10), x /= 10;
return res;
}
inline long long g(long long x) {
long long res = 10;
while (x) res = min(res, x % 10), x /= 10;
return res;
}
inline void solve() {
cin >> a >> k;
res = k;
if (k == 1) return printf("%lld\n", a), void();
for (long long i = 2; i <= k; i++) {
if (check(a)) break;
a = a + f(a) * g(a);
}
printf("%lld\n", a);
}
signed main() {
long long T;
cin >> T;
while (T--) solve();
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
template <class T>
void out(T arg) {
cout << arg;
}
template <class Type, class... args>
void out(Type arg, args... params) {
cout << arg << " ";
out(params...);
}
int power_mod(int _a, int _b, int _mod = 1000000007) {
int ans = 1, temp = _a;
while (_b) {
if (_b & 1) ans = 1ll * ans * temp % _mod;
_b >>= 1;
temp = 1ll * temp * temp % _mod;
}
return ans;
}
const int maxn = 1e5 + 5;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int T;
cin >> T;
while (T--) {
long long n, m;
cin >> n >> m;
while (--m) {
long long temp = n;
long long mx = 0, mi = 100;
while (temp) {
mx = max(temp % 10, mx);
mi = min(temp % 10, mi);
temp /= 10;
}
if (mi == 0) break;
n += mi * mx;
}
cout << n << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int mind(long long x) {
long long int m, r;
m = 9;
while (x != 0) {
r = x % 10;
x = x / 10;
if (r == 0) {
return r;
}
m = min(m, r);
}
return m;
}
int maxd(long long y) {
long long int k, s;
k = 0;
while (y != 0) {
s = y % 10;
y = y / 10;
if (s == 9) {
return s;
}
k = max(k, s);
}
return k;
}
int main() {
long long n, l, c, k, t, i, p;
cin >> t;
while (t--) {
p = 1;
cin >> n;
cin >> k;
l = mind(n);
c = maxd(n);
for (i = 1; i < k; i++) {
if (l == 0) {
cout << n << endl;
p = 0;
break;
}
n = n + l * c;
l = mind(n);
c = maxd(n);
}
if (p) {
cout << n << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int add(long long int a);
int add(long long int a) {
int min = 10;
int max = 0;
while (a > 0) {
int d = a % 10;
if (min > d) min = d;
if (max < d) max = d;
if (min == 0) return 0;
a = a / 10;
}
return min * max;
}
int main() {
int t;
cin >> t;
long long int a[t];
long long int k[t];
for (int i = 0; i < t; i++) {
cin >> a[i] >> k[i];
k[i] = k[i] - 1;
long long int num = a[i];
while (k[i]) {
int p = add(num);
if (p == 0) break;
num = num + p;
k[i]--;
}
cout << num << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long q, a, k, kop, i, najm, najv;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
cin >> q;
while (q--) {
cin >> a >> k;
i = 2;
while (i <= k) {
kop = a;
najm = LLONG_MAX;
najv = -1;
while (kop > 0) {
najm = min(najm, kop % 10);
najv = max(najv, kop % 10);
kop /= 10;
}
if (najm == 0) {
break;
}
a += (najm * najv);
i++;
}
cout << a << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long go(long long n, long long type) {
long long m = 9999999999999999;
long long M = -9999999999999999;
while (n > 0) {
long long last = n % 10;
m = min(m, last);
M = max(M, last);
n /= 10;
}
if (type == 1)
return m;
else
return M;
}
int32_t main() {
long long t;
cin >> t;
while (t--) {
long long n, k;
cin >> n >> k;
long long prev = n;
k--;
while (k--) {
long long m = go(n, 1);
long long M = go(n, 2);
n = n + (m * M);
if (prev == n) {
break;
} else {
prev = n;
}
}
cout << n << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long power(long long x, unsigned long long y) {
if (y == 0)
return 1;
else if (y % 2 == 0)
return power(x, y / 2) * power(x, y / 2);
else
return x * power(x, y / 2) * power(x, y / 2);
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
vector<long long> seg[200001];
void build(long long ci, long long st, long long end,
pair<long long, long long>* B) {
if (st == end) {
seg[ci].push_back(B[st].second);
return;
}
long long mid = (st + end) / 2;
build(2 * ci + 1, st, mid, B);
build(2 * ci + 2, mid + 1, end, B);
merge(seg[2 * ci + 1].begin(), seg[2 * ci + 1].end(), seg[2 * ci + 2].begin(),
seg[2 * ci + 2].end(), back_inserter(seg[ci]));
}
long long query(long long ci, long long st, long long end, long long l,
long long r, long long k) {
if (st == end) return seg[ci][0];
long long p = upper_bound(seg[2 * ci + 1].begin(), seg[2 * ci + 1].end(), r) -
lower_bound(seg[2 * ci + 1].begin(), seg[2 * ci + 1].end(), l);
long long mid = (st + end) / 2;
if (p >= k)
return query(2 * ci + 1, st, mid, l, r, k);
else
return query(2 * ci + 2, mid + 1, end, l, r, k - p);
}
bool cmp(pair<long long, long long> x, pair<long long, long long> y) {
return x.second < y.second;
}
int32_t main() {
long long q;
cin >> q;
long long Q = 1;
long long MAXN = 100000;
long long spf[MAXN + 1];
while (q--) {
long long a1, k;
cin >> a1 >> k;
k--;
while (k--) {
long long mn = 9, mx = 0;
long long y = a1;
while (y > 0) {
long long r = y % 10;
mn = min(mn, r);
mx = max(mx, r);
y = y / 10;
}
a1 += mn * mx;
if (mn == 0) break;
}
cout << a1 << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int min_index(long long n) {
long long x = 10;
for (long long i = 0; i != n; n /= 10) {
x = min(x, n % 10);
}
return x;
}
int max_index(long long n) {
long long x = 0;
for (long long i = 0; i < n; n /= 10) {
x = max(x, n % 10);
}
return x;
}
int main() {
int t;
cin >> t;
for (int i = 0; i < t; i++) {
long long a, k;
cin >> a >> k;
for (int j = 1; j < k; j++) {
int x, y;
x = min_index(a);
y = max_index(a);
if (x == 0 || y == 0) break;
a += x * y;
}
cout << a << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxi = 2000000000;
const int maxq = 1000000000;
const long long mod = 1000000007LL;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
long long a, k, r;
cin >> a >> k;
for (long long i = (1); i < (k); ++i) {
long long x = a, b = 9, c = 1;
while (x) {
r = x % 10;
b = min(r, b);
c = max(r, c);
x /= 10;
}
a = a + b * c;
if (!b) break;
}
cout << a << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int maxn = 110000;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << setiosflags(ios::fixed) << setprecision(12);
int t;
cin >> t;
while (t--) {
long long a, k;
cin >> a >> k;
long long ans = a;
for (int i = 0; i < k - 1; i++) {
long long mn = 1LL << 63 - 1;
long long mx = -1;
long long temp = a;
while (a) {
long long num = a % 10;
a = a / 10;
mn = min(mn, num);
mx = max(mx, num);
}
a = temp;
a = a + mn * mx;
if (mn == 0) break;
ans += mn * mx;
}
cout << ans << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long max(long long a, long long b) {
if (a > b) return a;
return b;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t, n, s, k, ans = 0, cnt;
long long temp, temp2;
cin >> t;
while (t--) {
cin >> n >> k;
string s;
int min = 9;
int max = 0;
ans = n;
cnt = 1;
while (min != 0 && cnt < k) {
s = to_string(ans);
min = 9;
max = 0;
for (int i = 0; i < s.length(); i++) {
if (s[i] - '0' < min) min = s[i] - '0';
if (s[i] - '0' > max) max = s[i] - '0';
}
ans = ans + (min * max);
cnt++;
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int solve(long long int a) {
long long int n = a, maxv = 0, minv = 9, digit;
while (n != 0) {
digit = n % 10;
if (digit > maxv) maxv = digit;
if (digit < minv) minv = digit;
n /= 10;
}
return a += minv * maxv;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int t = 1;
cin >> t;
while (t--) {
long long int a, k, ans;
cin >> a >> k;
k--;
while (k--) {
ans = solve(a);
if (ans == a) break;
a = ans;
}
cout << a << endl;
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.