text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <typename T>
class fenwick_tree {
const int n;
vector<T> data;
public:
fenwick_tree(int n_) : n(n_), data(n + 1) {}
T find(int p) const {
T res = 0;
while (p > 0) {
res += data[p];
p -= p & -p;
}
return res;
}
T find(int l, int r) const { return find(r) - find(l); }
void add(int p, T val) {
++p;
while (p <= n) {
data[p] += val;
p += p & -p;
}
}
void update(int p, T val) { add(p, val - find(p, p + 1)); }
};
template <int MOD>
class mod_int {
unsigned x;
public:
mod_int() : x(0) {}
mod_int(int sig) {
int sigt = sig % MOD;
if (sigt < 0) sigt += MOD;
x = sigt;
}
mod_int(long long sig) {
int sigt = sig % MOD;
if (sigt < 0) sigt += MOD;
x = sigt;
}
int get() const { return (int)x; }
mod_int &operator+=(mod_int that) {
if ((x += that.x) >= MOD) x -= MOD;
return *this;
}
mod_int &operator-=(mod_int that) {
if ((x += MOD - that.x) >= MOD) x -= MOD;
return *this;
}
mod_int &operator*=(mod_int that) {
x = (unsigned long long)x * that.x % MOD;
return *this;
}
mod_int &operator/=(mod_int that) { return *this *= that.inverse(); }
mod_int operator+(mod_int that) const { return mod_int(*this) += that; }
mod_int operator-(mod_int that) const { return mod_int(*this) -= that; }
mod_int operator*(mod_int that) const { return mod_int(*this) *= that; }
mod_int operator/(mod_int that) const { return mod_int(*this) /= that; }
bool operator==(const mod_int &that) const { return x == that.x; }
mod_int inverse() const {
long long a = x, b = MOD, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
return mod_int(u);
}
};
const int mod = 1e9 + 7;
using mint = mod_int<mod>;
int main() {
ios::sync_with_stdio(false), cin.tie(0);
int n, q;
cin >> n >> q;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
a[i] -= i;
}
fenwick_tree<ll> co(n);
fenwick_tree<mint> all(n);
for (int i = 0; i < n; i++) {
int w;
cin >> w;
co.add(i, w);
all.add(i, mint(1) * w * a[i]);
}
while (q--) {
int x, y;
cin >> x >> y;
if (x < 0) {
int id = -x - 1;
co.update(id, y);
all.update(id, mint(1) * y * a[id]);
} else {
--x;
ll sum = co.find(x, y);
int lb = x, ub = y;
while (ub - lb > 1) {
int m = (lb + ub) / 2;
(co.find(x, m) * 2 <= sum ? lb : ub) = m;
}
mint pos = a[lb];
ll lc = co.find(x, lb), rc = sum - lc;
mint res = (pos * lc - all.find(x, lb)) + (all.find(lb, y) - pos * rc);
printf("%d\n", res.get());
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long acum[301009], wacum[301009], aw[301009];
long long read(int i, long long *tree, int mod = -1) {
long long ret = 0;
while (i > 0) {
ret += tree[i];
if (mod != -1) ret %= 1000000007;
i -= (i & -i);
}
return ret;
}
void add(int i, int v, long long *tree, int maxi, int mod = -1) {
while (i <= maxi) {
tree[i] += v;
if (mod != -1) tree[i] %= 1000000007;
i += (i & -i);
}
}
long long query(int l, int r, long long *tree, int mod = -1) {
if (l > r) return 0;
long long ans = read(r, tree, mod) - read(l - 1, tree, mod);
if (mod != -1) ans = (ans + 1000000007) % 1000000007;
return ans;
}
int a[301009], w[301009];
int main() {
int n, q, val, l, r, id;
const int maxi = 200009;
scanf("%d %d", &n, &q);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) {
scanf("%d", &w[i]);
add(i, w[i], acum, maxi);
add(i, (i * 1LL * w[i]) % 1000000007, wacum, maxi, 1000000007);
add(i, (a[i] * 1LL * w[i]) % 1000000007, aw, maxi, 1000000007);
}
while (q--) {
scanf("%d %d", &l, &r);
if (l < 0) {
id = -l;
add(id, -w[id], acum, maxi);
add(id, (1000000007 - (id * 1LL * w[id]) % 1000000007) % 1000000007,
wacum, maxi, 1000000007);
add(id, (1000000007 - (a[id] * 1LL * w[id]) % 1000000007) % 1000000007,
aw, maxi, 1000000007);
w[id] = r;
add(id, w[id], acum, maxi);
add(id, (id * 1LL * w[id]) % 1000000007, wacum, maxi, 1000000007);
add(id, (a[id] * 1LL * w[id]) % 1000000007, aw, maxi, 1000000007);
} else {
int lo = l, hi = r;
while (lo < hi) {
int mid = (lo + hi + 1) / 2;
long long p1 = query(l, mid - 1, acum);
long long p2 = query(mid + 1, r, acum);
if (p1 > p2 + w[mid]) {
hi = mid - 1;
} else
lo = mid;
}
id = lo;
int pos = a[id] - (id - l);
long long ans = 0;
ans -= query(l, id - 1, aw, 1000000007);
ans = (ans + 1000000007) % 1000000007;
ans += (query(l, id - 1, wacum, 1000000007) -
l * 1LL * query(l, id - 1, acum, 1000000007)) %
1000000007;
ans = (ans + 1000000007) % 1000000007;
ans += (pos * 1LL * query(l, id - 1, acum, 1000000007)) % 1000000007;
ans = (ans + 1000000007) % 1000000007;
ans += query(id + 1, r, aw, 1000000007);
ans = (ans + 1000000007) % 1000000007;
ans -= (query(id + 1, r, wacum, 1000000007) -
(id)*1LL * query(id + 1, r, acum, 1000000007)) %
1000000007;
ans = (ans + 1000000007) % 1000000007;
ans -= (a[id] * 1LL * query(id + 1, r, acum, 1000000007)) % 1000000007;
ans = (ans + 1000000007) % 1000000007;
printf("%lld\n", ans);
}
}
}
|
#include <bits/stdc++.h>
const int Z = 1 << 18;
const long long mod = 1000000007;
struct node {
node() { a = w = s = 0; }
node(long long a_, long long w_) {
a = a_;
w = w_;
s = a * w % mod;
}
node(long long a_, long long w_, long long s_) {
a = a_;
w = w_;
s = s_;
}
long long a, w, s;
node operator+(const node &t) const {
return {a + t.a, w + t.w, (s + t.s) % mod};
}
} IT[Z * 2];
int N, Q, A[200200], W[200200];
void push(int x) {
IT[x + Z] = node(A[x], W[x]);
x = (x + Z) / 2;
while (x) {
IT[x] = IT[x * 2] + IT[x * 2 + 1];
x /= 2;
}
}
node get(int x, int y) {
node r;
x += Z;
y += Z;
while (x < y) {
if (x & 1) r = r + IT[x++];
if (y & 1) r = r + IT[--y];
x /= 2;
y /= 2;
}
return r;
}
int getPos(long long w) {
int x = 1;
while (x < Z) {
x *= 2;
if (w > IT[x].w) {
w -= IT[x].w;
x++;
}
}
return x - Z;
}
int main() {
scanf("%d %d", &N, &Q);
for (int i = 1; i <= N; i++) scanf("%d", &A[i]), A[i] -= i;
for (int i = 1; i <= N; i++) scanf("%d", &W[i]);
for (int i = 1; i <= N; i++) IT[i + Z] = node(A[i], W[i]);
for (int i = Z - 1; i >= 1; i--) IT[i] = IT[i * 2] + IT[i * 2 + 1];
while (Q--) {
int x, y;
scanf("%d %d", &x, &y);
if (x < 0) {
W[-x] = y;
push(-x);
} else {
y++;
node s = get(x, y);
node l = get(0, x);
long long want = l.w + (s.w + 1) / 2;
int p = getPos(want);
long long c = A[p];
node a = get(x, p);
node b = get(p + 1, y);
long long as = (a.w % mod * c) + mod - a.s;
long long bs = b.s + mod - (b.w % mod * c) % mod;
printf("%lld\n", (as + bs) % mod);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
const int MOD = 1e9 + 7;
long long dist[N], cnt[N], a[N], w[N], L[N], R[N];
void update(long long* f, int p, long long x, int flg = 0) {
while (p < N) {
if (flg)
f[p] += x;
else {
if ((f[p] += x) >= MOD) f[p] -= MOD;
};
p += p & -p;
}
}
long long query(long long* f, int p, int flg = 0) {
long long res = 0;
while (p) {
if (flg)
res += f[p];
else {
if ((res += f[p]) >= MOD) res -= MOD;
};
p -= p & -p;
}
return res;
}
long long sum(long long* f, int l, int r, int flg = 0) {
if (l > r) return 0;
if (flg) return query(f, r, 1) - query(f, l - 1, 1);
long long res = query(f, r);
{
if ((res += MOD - query(f, l - 1)) >= MOD) res -= MOD;
};
return res;
}
long long qsm(long long* f, int l, int r, long long x, int flg = 0) {
if (l > r) return 0;
long long res = sum(f, l, r, flg);
{
if ((res += MOD - x * (sum(cnt, l, r, 1) % MOD) % MOD) >= MOD) res -= MOD;
};
return res;
}
int search(int ql, int qr) {
int l = ql, r = qr, res = ql;
long long tot = sum(cnt, ql, qr, 1) / 2;
while (l <= r) {
int mid = l + r >> 1;
if (sum(cnt, ql, mid, 1) <= tot) {
res = mid + 1;
l = mid + 1;
} else {
r = mid - 1;
}
}
return min(qr, res);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, q;
cin >> n >> q;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 1; i <= n; i++) {
cin >> w[i];
update(dist, i, (long long)a[i] * w[i] % MOD);
update(cnt, i, w[i], 1);
update(L, i, (n - i + 1LL) * w[i] % MOD);
update(R, i, (long long)i * w[i] % MOD);
}
while (q--) {
int x, y;
cin >> x >> y;
if (x < 0) {
x = -x;
update(cnt, x, y - w[x], 1);
long long ch = (y - w[x] + MOD) % MOD;
w[x] = y;
update(dist, x, a[x] * ch % MOD);
update(L, x, (n - x + 1LL) * ch % MOD);
update(R, x, x * ch % MOD);
} else {
int pos = search(x, y);
long long cl = sum(cnt, x, pos - 1, 1) % MOD,
cr = sum(cnt, pos + 1, y, 1) % MOD;
long long res = 0;
{
if ((res += a[pos] * cl % MOD) >= MOD) res -= MOD;
};
{
if ((res += MOD - sum(dist, x, pos - 1)) >= MOD) res -= MOD;
};
{
if ((res += sum(dist, pos + 1, y)) >= MOD) res -= MOD;
};
{
if ((res += MOD - a[pos] * cr % MOD) >= MOD) res -= MOD;
};
{
if ((res += MOD - qsm(L, x, pos - 1, n - pos + 1)) >= MOD) res -= MOD;
};
{
if ((res += MOD - qsm(R, pos + 1, y, pos)) >= MOD) res -= MOD;
};
cout << res << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
long long N, Q;
long long pos[200005], W[200005];
struct segtree {
long long sum[800005], sumL[800005], sumR[800005];
long long upd_pos, ql, qr, type;
long long val, res;
void build(long long n, long long l, long long r) {
if (l == r) {
sum[n] = W[l];
sumL[n] = W[l] * (pos[l] + (N - l + 1)) % MOD;
sumR[n] = W[l] * (pos[l] - l) % MOD;
return;
}
long long mid = (l + r) >> 1;
build((n << 1), l, mid);
build((n << 1 | 1), mid + 1, r);
sum[n] = sum[(n << 1)] + sum[(n << 1 | 1)];
sumL[n] = sumL[(n << 1)] + sumL[(n << 1 | 1)] % MOD;
sumR[n] = sumR[(n << 1)] + sumR[(n << 1 | 1)] % MOD;
}
void build() { build(1, 1, N); }
void update(long long n, long long l, long long r) {
if (l == r) {
sum[n] = val;
sumL[n] = val * (pos[l] + (N - l + 1)) % MOD;
sumR[n] = val * (pos[l] - l) % MOD;
return;
}
long long mid = (l + r) >> 1;
if (upd_pos <= mid)
update((n << 1), l, mid);
else
update((n << 1 | 1), mid + 1, r);
sum[n] = sum[(n << 1)] + sum[(n << 1 | 1)];
sumL[n] = sumL[(n << 1)] + sumL[(n << 1 | 1)] % MOD;
sumR[n] = sumR[(n << 1)] + sumR[(n << 1 | 1)] % MOD;
}
void update(long long pos, long long new_val) {
upd_pos = pos;
val = new_val;
update(1, 1, N);
}
void get_sum(long long n, long long l, long long r) {
if (ql <= l && r <= qr) {
res += (type == 1 ? sum[n] : type == 2 ? sumL[n] : sumR[n]);
return;
}
long long mid = (l + r) >> 1;
if (ql <= mid) get_sum((n << 1), l, mid);
if (qr > mid) get_sum((n << 1 | 1), mid + 1, r);
}
long long query(long long l, long long r, long long query_type) {
if (l > r) return 0;
ql = l, qr = r;
type = query_type;
res = 0;
get_sum(1, 1, N);
if (type == 1)
return res;
else
return res % MOD;
}
long long K;
void binser(long long n, long long l, long long r) {
if (K < 0) return;
if (l == r) {
if (K < sum[n]) {
res = l;
K = -1;
} else {
K -= sum[n];
}
return;
}
long long mid = (l + r) >> 1;
if (ql <= l && r <= qr) {
if (sum[n] <= K) {
K -= sum[n];
return;
}
if (K < sum[(n << 1)]) {
binser((n << 1), l, mid);
} else {
K -= sum[(n << 1)];
binser((n << 1 | 1), mid + 1, r);
}
return;
}
if (ql <= mid) binser((n << 1), l, mid);
if (qr > mid) binser((n << 1 | 1), mid + 1, r);
}
long long cari(long long l, long long r, long long sum) {
K = sum >> 1;
ql = l, qr = r;
binser(1, 1, N);
return res;
}
};
segtree tree;
int32_t main() {
ios_base::sync_with_stdio(0);
cin >> N >> Q;
for (long long i = 1; i <= N; i++) {
cin >> pos[i];
}
for (long long i = 1; i <= N; i++) {
cin >> W[i];
}
tree.build();
long long x, y, mid;
long long total_sum, sum_left, sum_right;
while (Q--) {
cin >> x >> y;
if (x < 0) {
tree.update(-x, y);
} else {
total_sum = tree.query(x, y, 1);
mid = tree.cari(x, y, total_sum);
sum_left =
tree.query(x, mid - 1, 1) % MOD * (pos[mid] + (N - mid + 1)) % MOD -
tree.query(x, mid - 1, 2);
sum_right = tree.query(mid + 1, y, 3) -
tree.query(mid + 1, y, 1) % MOD * (pos[mid] - mid) % MOD;
while (sum_left < 0) sum_left = sum_left + MOD;
while (sum_right < 0) sum_right = sum_right + MOD;
cout << (sum_left + sum_right) % MOD << "\n";
}
}
cin >> N;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long ans = 0, w = 1;
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-') w = -1, c = getchar();
while (isdigit(c)) ans = (ans << 1) + (ans << 3) + c - '0', c = getchar();
return ans * w;
}
long long sum1[300010 << 2], sum2[300010 << 2];
void pu(int o) {
sum1[o] = sum1[(o << 1)] + sum1[((o << 1) | 1)];
sum2[o] = (sum2[(o << 1)] + sum2[((o << 1) | 1)]) % 1000000007;
}
int a[300010], w[300010];
int n, q;
long long mod(long long a) {
a %= 1000000007;
if (a < 0) a += 1000000007;
return a;
}
long long add(long long a, long long b) { return mod(a + b); }
long long mul(long long a, long long b) { return mod(a * b); }
void pushup1(int t) { sum1[t] = sum1[(t << 1)] + sum1[(t << 1 | 1)]; }
void pushup2(int t) { sum2[t] = add(sum2[(t << 1)], sum2[(t << 1 | 1)]); }
void modify1(int t, int l, int r, int pos, long long vl) {
if (l == r) {
sum1[t] = vl;
return;
}
if (pos <= ((l + r) >> 1))
modify1((t << 1), l, ((l + r) >> 1), pos, vl);
else
modify1((t << 1 | 1), ((l + r) >> 1) + 1, r, pos, vl);
pushup1(t);
}
void modify2(int t, int l, int r, int pos, long long vl) {
if (l == r) {
sum2[t] = vl;
return;
}
if (pos <= ((l + r) >> 1))
modify2((t << 1), l, ((l + r) >> 1), pos, vl);
else
modify2((t << 1 | 1), ((l + r) >> 1) + 1, r, pos, vl);
pushup2(t);
}
long long qry1(int o, int l, int r, int ql, int qr) {
if (ql <= l && r <= qr) return sum1[o];
long long ans = 0;
if (((l + r) >> 1) >= ql) ans += qry1((o << 1), l, ((l + r) >> 1), ql, qr);
if (((l + r) >> 1) < qr)
ans += qry1(((o << 1) | 1), ((l + r) >> 1) + 1, r, ql, qr);
return ans;
}
long long qry2(int o, int l, int r, int ql, int qr) {
if (ql <= l && r <= qr) return sum2[o];
long long ans = 0;
if (((l + r) >> 1) >= ql) ans = qry2((o << 1), l, ((l + r) >> 1), ql, qr);
if (((l + r) >> 1) < qr)
(ans += qry2(((o << 1) | 1), ((l + r) >> 1) + 1, r, ql, qr)) %= 1000000007;
return ans;
}
int query1_pos(int t, int l, int r, int L, int R, long long vl) {
if (l == r) return l;
if (R <= ((l + r) >> 1))
return query1_pos((t << 1), l, ((l + r) >> 1), L, R, vl);
if (L > ((l + r) >> 1))
return query1_pos((t << 1 | 1), ((l + r) >> 1) + 1, r, L, R, vl);
long long suml = qry1((t << 1), l, ((l + r) >> 1), L, ((l + r) >> 1));
if (suml >= vl)
return query1_pos((t << 1), l, ((l + r) >> 1), L, ((l + r) >> 1), vl);
else
return query1_pos((t << 1 | 1), ((l + r) >> 1) + 1, r, ((l + r) >> 1) + 1,
R, vl - suml);
}
void build(int o, int l, int r) {
if (l == r) {
sum1[o] = w[l], sum2[o] = (long long)a[l] * w[l] % 1000000007;
return;
}
build((o << 1), l, ((l + r) >> 1)),
build(((o << 1) | 1), ((l + r) >> 1) + 1, r);
pu(o);
}
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; ++i) scanf("%d", a + i), a[i] -= i;
for (int i = 1; i <= n; ++i) scanf("%d", w + i);
build(1, 1, n);
while (q--) {
int first = read(), second = read();
if (first < 0) {
first = -first;
w[first] = second;
modify1(1, 1, n, first, w[first]);
modify2(1, 1, n, first, mul(a[first], w[first]));
} else {
long long sum = qry1(1, 1, n, first, second);
int l = first, r = second, pos = -1;
while (l <= r) {
if (2 * qry1(1, 1, n, first, ((l + r) >> 1)) >= sum)
pos = ((l + r) >> 1), r = ((l + r) >> 1) - 1;
else
l = ((l + r) >> 1) + 1;
}
long long ans = 0;
ans = add(ans, mul(a[pos], add(qry1(1, 1, n, first, pos),
-qry1(1, 1, n, pos, second))));
ans =
add(ans, add(-qry2(1, 1, n, first, pos), qry2(1, 1, n, pos, second)));
printf("%lld\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 7, N = 2e5 + 7, M = 1e9 + 7;
int a[N], w[N];
struct {
long long bit[N];
void add(int i, long long val = 1) {
for (; i < N; i += i & -i) bit[i] += val;
}
long long qry(int i) {
long long res = 0;
for (; i; i -= i & -i) res += bit[i];
return res;
}
} b1;
struct {
int bit[N];
void add(int i, int val = 1) {
for (; i < N; i += i & -i) bit[i] = (bit[i] + val) % M;
}
int qry(int i) {
int res = 0;
for (; i; i -= i & -i) res = (res + bit[i]) % M;
return res;
}
} b2;
signed main() {
std::ios::sync_with_stdio(0);
std::cin.tie(0);
;
int n, q;
cin >> n >> q;
for (int i = 1; i <= n; i++) {
cin >> a[i];
a[i] -= i;
}
for (int i = 1; i <= n; i++) {
cin >> w[i];
b1.add(i, w[i]);
b2.add(i, (long long)a[i] * w[i] % M);
}
while (q--) {
int x, y;
cin >> x >> y;
if (x < 0) {
int i = -x, nw = y;
b1.add(i, -w[i]);
b2.add(i, (M - (long long)a[i] * w[i] % M) % M);
w[i] = nw;
b1.add(i, w[i]);
b2.add(i, (long long)a[i] * w[i] % M);
} else {
int l = x, r = y;
if (l == r) {
cout << 0 << endl;
continue;
}
int cur = 0;
long long tot = b1.qry(r) - b1.qry(l - 1), sum = 0, tt = b1.qry(l - 1);
for (int j = 19; j >= 0; j--) {
if (cur + (1 << j) <= r) {
int tmp = cur + (1 << j);
long long summ = b1.bit[tmp] + sum;
if ((summ - tt) * 2 < tot) {
sum = summ;
cur = tmp;
}
}
}
int to = cur + 1;
assert(to <= r);
long long ans = (b1.qry(to - 1) - b1.qry(l - 1)) % M * a[to] % M;
ans = (ans + -(b1.qry(r) - b1.qry(to)) % M * a[to] % M % M + M) % M;
ans = (ans - b2.qry(to - 1) + b2.qry(l - 1) + M) % M;
ans = (ans + b2.qry(r) - b2.qry(to) + M) % M;
cout << ans << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[(long long)1e6], w[(long long)1e6];
const long long maxn = 100100;
const long long mod = 1e9 + 7;
long long tree[maxn << 2], tree2[maxn << 2], tree3[maxn << 2];
long long n;
inline void add(long long r, long long v) {
while (r <= n) tree[r] += v, r += r & -r;
}
inline long long query(long long r) {
long long ans = 0;
while (r) ans += tree[r], r &= r - 1;
return ans;
}
inline long long query(long long l, long long r) {
return query(r) - query(l - 1);
}
inline void add1(long long r, long long v) {
while (r <= n) (tree2[r] += v) %= mod, r += r & -r;
}
inline long long query1(long long r) {
long long ans = 0;
while (r) (ans += tree2[r]) %= mod, r &= r - 1;
return ans;
}
inline long long query1(long long l, long long r) {
return query1(r) - query1(l - 1);
}
inline void add2(long long r, long long v) {
while (r <= n) (tree3[r] += v) %= mod, r += r & -r;
}
inline long long query2(long long r) {
long long ans = 0;
while (r) (ans += tree3[r]) %= mod, r &= r - 1;
return ans;
}
inline long long query2(long long l, long long r) {
return query2(r) - query2(l - 1);
}
inline long long move_1(long long l, long long r, long long pos) {
long long len = r - l + 1;
return pos * (query(l, r) % mod) % mod + query2(l, r) -
query(l, r) * l % mod - query1(l, r);
}
inline long long move_2(long long l, long long r, long long pos) {
long long len = r - l + 1;
return -pos * (query(l, r) % mod) % mod - query2(l, r) +
query(l, r) % mod * l % mod + query1(l, r);
}
signed main() {
ios::sync_with_stdio(false);
long long q;
cin >> n >> q;
for (long long i = 1; i <= n; ++i) {
cin >> a[i];
}
for (long long i = 1; i <= n; ++i) {
cin >> w[i];
add(i, w[i]);
add1(i, a[i] * w[i] % mod);
add2(i, (i)*w[i] % mod);
}
while (q--) {
long long x, y;
cin >> x >> y;
if (x < 0) {
x = -x;
add(x, -w[x]);
add1(x, mod - a[x] * w[x] % mod);
add2(x, mod - (x)*w[x] % mod);
w[x] = y;
add(x, w[x]);
add1(x, a[x] * w[x] % mod);
add2(x, (x)*w[x] % mod);
} else {
long long l = x, r = y;
while (l != r) {
long long mid = l + r >> 1;
if (query(x, mid) < query(mid + 1, y))
l = mid + 1;
else
r = mid;
}
cout << ((move_1(x, r, a[r] - (r - x + 1) + 1) +
move_2(r + 1, y, a[r] + 1)) %
mod +
mod) %
mod
<< endl;
}
}
}
|
#include <bits/stdc++.h>
const int MAXN = 200010;
const int mod = 1000000007;
void reduce(int& x) { x += x >> 31 & mod; }
int mul(int a, int b) { return (long long)a * b % mod; }
int remod(long long x) {
x %= mod;
return x + (x >> 63 & mod);
}
int n;
int A[MAXN], W[MAXN];
long long rt[MAXN];
void mdfc(int x, int v) {
for (; x <= n; x += x & -x) rt[x] += v;
}
long long qry(int x) {
long long res = 0;
for (; x; x &= x - 1) res += rt[x];
return res;
}
long long qry(int l, int r) { return qry(r) - qry(l - 1); }
int tr[MAXN];
void mdfv(int x, int v) {
for (v -= mod; x <= n; x += x & -x) reduce(tr[x] += v);
}
int qryv(int x) {
int res = 0;
for (; x; x &= x - 1) reduce(res += tr[x] - mod);
return res;
}
int qryv(int l, int r) {
int x = qryv(r) - qryv(l - 1);
return x + (x >> 31 & mod);
}
void add(int x, int v) { mdfc(x, v), mdfv(x, remod(mul(A[x], v))); }
int main() {
std::ios_base::sync_with_stdio(false), std::cin.tie(0);
int T;
std::cin >> n >> T;
for (int i = 1; i <= n; ++i) std::cin >> A[i], A[i] -= i;
for (int i = 1; i <= n; ++i) std::cin >> W[i], add(i, W[i]);
while (T-- > 0) {
int x, y;
std::cin >> x >> y;
if (x < 0)
x = -x, add(x, y - W[x]), W[x] = y;
else {
int l = x, r = y, at = -1;
long long sm = qry(l, r);
while (l <= r) {
int mid = l + r >> 1;
if (qry(x, mid) * 2 >= sm)
at = mid, r = mid - 1;
else
l = mid + 1;
}
l = x, r = y;
int X = A[at];
long long ans = qry(l, at) % mod * X - qryv(l, at);
ans += qryv(at + 1, r) - qry(at + 1, r) % mod * X;
std::cout << remod(ans) << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int md = 1e9 + 7;
int mul(int a, int b) { return ((long long)a * b) % md; }
void sub(int &a, int b) {
a -= b;
if (a < 0) a += md;
}
void add(int &a, int b) {
a += b;
if (a >= md) a -= md;
}
struct fenwick {
vector<long long> f;
int n;
fenwick(int nn) {
f.resize(nn);
n = nn;
}
void modify(int x, long long y) {
for (int i = x; i < n; i |= i + 1) f[i] += y;
}
long long get(int x) {
long long sum = 0;
for (int i = x; i >= 0; i &= i + 1, --i) {
sum += f[i];
}
return sum;
}
long long sum(int l, int r) { return get(r) - get(l - 1); }
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.setf(ios::fixed);
cout.precision(20);
int n, q;
cin >> n >> q;
fenwick fs(n), fw(n);
vector<int> a(n), w(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
a[i] -= i;
}
for (int i = 0; i < n; ++i) {
cin >> w[i];
fw.modify(i, w[i]);
}
for (int i = 0; i < n; ++i) {
fs.modify(i, mul(w[i], a[i]));
}
while (q--) {
int x, y;
cin >> x >> y;
if (x < 0) {
x = -x;
--x;
fw.modify(x, -w[x]);
fw.modify(x, y);
fs.modify(x, -mul(w[x], a[x]));
fs.modify(x, mul(y, a[x]));
w[x] = y;
} else {
--x, --y;
int l = x - 1, r = y;
long long sum = fw.sum(x, y);
while (r - l > 1) {
int m = (l + r) >> 1;
if (2 * fw.sum(x, m) <= sum)
l = m;
else
r = m;
}
++l;
int ans = mul(fw.sum(x, l) % md, a[l]);
sub(ans, ((fs.sum(x, l) % md) + md) % md);
add(ans, ((fs.sum(l, y) % md) + md) % md);
sub(ans, mul(fw.sum(l, y) % md, a[l]));
cout << ans << '\n';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long p, i, j, k, l, s, n, m, sum, x, y, a[400005], b[400005];
struct node {
long long sum, val;
} f[400005 * 4];
inline node up(node x, node y) {
return node{(x.sum + y.sum), (x.val + y.val) % 1000000007};
}
inline void change(long long o, long long l, long long r, long long ll,
long long p) {
if (l == ll && r == ll) {
f[o].val = a[l] * p % 1000000007;
f[o].sum = p;
return;
}
long long mid = (l + r) >> 1;
if (ll <= mid)
change(o * 2, l, mid, ll, p);
else
change(o * 2 + 1, mid + 1, r, ll, p);
f[o] = up(f[o * 2], f[o * 2 + 1]);
}
inline node ask(long long o, long long l, long long r, long long ll,
long long rr) {
if (l == ll && r == rr) return f[o];
long long mid = (l + r) >> 1;
if (rr <= mid)
return ask(o * 2, l, mid, ll, rr);
else if (ll > mid)
return ask(o * 2 + 1, mid + 1, r, ll, rr);
else
return up(ask(o * 2, l, mid, ll, mid),
ask(o * 2 + 1, mid + 1, r, mid + 1, rr));
}
inline long long get(long long o, long long l, long long r, long long ll,
long long rr) {
if (p * 2 >= sum) return 0;
if (l >= ll && r <= rr) {
if (p * 2 >= sum) return 0;
if ((p + f[o].sum) * 2 < sum) {
p += f[o].sum;
return 0;
}
if (l == r) {
p += f[o].sum;
return l;
}
long long mid = (l + r) >> 1;
if (2 * (f[o * 2].sum + p) >= sum)
return get(o * 2, l, mid, ll, rr);
else {
p += f[o * 2].sum;
return get(o * 2 + 1, mid + 1, r, ll, rr);
}
}
long long mid = (l + r) >> 1;
if (rr <= mid)
return get(o * 2, l, mid, ll, rr);
else if (ll > mid)
return get(o * 2 + 1, mid + 1, r, ll, rr);
else {
long long xx = get(o * 2, l, mid, ll, mid);
long long yy = get(o * 2 + 1, mid + 1, r, mid + 1, rr);
return max(xx, yy);
}
}
inline long long ask(long long x, long long l, long long r) {
node gt = ask(1, 1, n, l, x);
node gtw = ask(1, 1, n, x, r);
return (gt.sum % 1000000007 * a[x] % 1000000007 - gt.val + gtw.val -
gtw.sum % 1000000007 * a[x] % 1000000007) %
1000000007;
}
int main() {
scanf("%I64d%I64d", &n, &m);
for (long long i = 1; i <= n; i++) scanf("%I64d", &a[i]), a[i] -= i;
for (long long i = 1; i <= n; i++) {
scanf("%I64d", &b[i]);
change(1, 1, n, i, b[i]);
}
for (long long i = 1; i <= m; i++) {
scanf("%I64d%I64d", &x, &y);
if (x > 0) {
sum = ask(1, 1, n, x, y).sum;
p = 0;
long long gt = get(1, 1, n, x, y);
printf("%I64d\n",
(((ask(gt, x, y)) % 1000000007) + 1000000007) % 1000000007);
} else {
x = -x;
b[x] = y;
change(1, 1, n, x, b[x]);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 2e5 + 200, mod = 1e9 + 7;
int n, q, ai[MAX_N], bi[MAX_N], wi[MAX_N];
long long sum[MAX_N << 2], diff[MAX_N << 2];
void pushup(int p) {
sum[p] = sum[(p << 1)] + sum[((p << 1) | 1)],
diff[p] = (diff[(p << 1)] + diff[((p << 1) | 1)]) % mod;
}
void build(int l, int r, int p) {
if (l == r) {
sum[p] = wi[l], diff[p] = 1LL * wi[l] * bi[l];
return;
}
build(l, ((l + r) >> 1), (p << 1)),
build(((l + r) >> 1) + 1, r, ((p << 1) | 1));
pushup(p);
}
void update(int qx, int l, int r, int p) {
if (l == r) {
sum[p] = wi[l], diff[p] = 1LL * wi[l] * bi[l];
return;
}
if (qx <= ((l + r) >> 1))
update(qx, l, ((l + r) >> 1), (p << 1));
else
update(qx, ((l + r) >> 1) + 1, r, ((p << 1) | 1));
pushup(p);
}
long long query(int ql, int qr, int l, int r, int p, long long *nodes,
bool opt = false) {
if (ql > qr) return 0;
if (ql <= l && r <= qr) return nodes[p];
long long ret = 0;
if (ql <= ((l + r) >> 1))
ret += query(ql, qr, l, ((l + r) >> 1), (p << 1), nodes);
if (((l + r) >> 1) < qr)
ret += query(ql, qr, ((l + r) >> 1) + 1, r, ((p << 1) | 1), nodes);
if (opt) ret %= mod;
return ret;
}
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; i++) scanf("%d", &ai[i]), bi[i] = ai[i] - i;
for (int i = 1; i <= n; i++) scanf("%d", &wi[i]);
build(1, n, 1);
while (q--) {
int l, r;
scanf("%d%d", &l, &r);
if (l < 0)
l = -l, wi[l] = r, update(l, 1, n, 1);
else {
int lb = l, rb = r, res = l;
while (lb <= rb) {
int mid = (lb + rb) >> 1;
if (query(l, mid, 1, n, 1, sum) >= query(mid + 1, r, 1, n, 1, sum))
res = mid, rb = mid - 1;
else
lb = mid + 1;
}
long long part1 =
(1LL * query(l, res - 1, 1, n, 1, sum, true) * (ai[res] - res) % mod +
mod - query(l, res - 1, 1, n, 1, diff, true)) %
mod;
long long part2 = (1LL * query(res + 1, r, 1, n, 1, sum, true) *
(res + mod - ai[res]) % mod +
query(res + 1, r, 1, n, 1, diff, true)) %
mod;
printf("%lld\n", (0LL + part1 + part2) % mod);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e9;
const int mod = inf + 7;
const double eps = 1e-9;
const double pi = acos(-1.0);
long long read_long() {
long long ans = 0;
char c;
bool started = false;
bool is_negative = false;
while (true) {
c = getchar();
if ((c < '0' || c > '9') && c != '-' && !started) continue;
if ((c < '0' || c > '9') && c != '-' && started) break;
if (started) {
ans = ans * 10;
}
started = true;
if (c == '-')
is_negative = true;
else
ans += c - '0';
}
if (is_negative) ans *= -1;
return ans;
}
int n, q;
int a[200200];
int b[200200];
int w[200200];
long long tw[200200 * 4];
int t[200200 * 4];
void build_tw(int v, int tl, int tr) {
if (tl == tr) {
tw[v] = w[tl];
t[v] = w[tl] * 1ll * b[tl] % mod;
} else {
int mid = (tl + tr) >> 1;
build_tw(2 * v, tl, mid);
build_tw(2 * v + 1, mid + 1, tr);
tw[v] = tw[v * 2] + tw[v * 2 + 1];
t[v] = t[2 * v] + t[2 * v + 1];
t[v] %= mod;
}
}
long long get_tw(int v, int tl, int tr, int l, int r) {
if (l > tr || r < tl) return 0;
if (l <= tl && tr <= r) return tw[v];
int mid = (tl + tr) >> 1;
long long ans1 = get_tw(2 * v, tl, mid, l, r);
long long ans2 = get_tw(2 * v + 1, mid + 1, tr, l, r);
return ans1 + ans2;
}
int get(int v, int tl, int tr, int l, int r) {
if (l > tr || r < tl) return 0;
if (l <= tl && tr <= r) return t[v];
int mid = (tl + tr) >> 1;
int ans1 = get(2 * v, tl, mid, l, r);
int ans2 = get(2 * v + 1, mid + 1, tr, l, r);
return (ans1 + ans2) % mod;
}
void update_tw(int v, int tl, int tr, int pos, int val) {
if (tl == tr) {
tw[v] = val;
t[v] = val * 1ll * b[tl] % mod;
} else {
int mid = (tl + tr) >> 1;
if (pos <= mid)
update_tw(2 * v, tl, mid, pos, val);
else
update_tw(2 * v + 1, mid + 1, tr, pos, val);
tw[v] = tw[v * 2] + tw[v * 2 + 1];
t[v] = t[2 * v] + t[2 * v + 1];
t[v] %= mod;
}
}
void precalc() { build_tw(1, 0, n - 1); }
void update(int pos, int val) { update_tw(1, 0, n - 1, pos, val); }
int get_mid(int l, int r) {
long long S = get_tw(1, 0, n - 1, l, r);
int L = l, R = r, ans = r;
while (L <= R) {
int mid = (L + R) >> 1;
long long cur = get_tw(1, 0, n - 1, l, mid);
if (cur * 2 >= S) {
ans = mid;
R = mid - 1;
} else
L = mid + 1;
}
return ans;
}
int get(int l, int r) {
if (l >= r) return 0;
int mid = get_mid(l, r);
int L = get_tw(1, 0, n - 1, l, mid - 1) % mod;
int R = get_tw(1, 0, n - 1, mid + 1, r) % mod;
int Lw = get(1, 0, n - 1, l, mid - 1);
int Rw = get(1, 0, n - 1, mid + 1, r);
int ans = b[mid] * 1ll * L % mod;
ans -= Lw;
ans %= mod;
ans += Rw;
ans %= mod;
ans -= b[mid] * 1ll * R % mod;
ans %= mod;
if (ans < 0) ans += mod;
return ans;
}
int main() {
scanf("%d%d", &n, &q);
for (int i = 0; i < n; i++) {
scanf("%d", a + i);
b[i] = a[i] - i;
}
for (int i = 0; i < n; i++) {
scanf("%d", w + i);
}
precalc();
while (q--) {
int x, y;
scanf("%d%d", &x, &y);
if (x < 0) {
update(-x - 1, y);
} else {
printf("%d\n", get(x - 1, y - 1));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
const int mod = 1e9 + 7;
int n, l, r;
long long S[maxn << 1], wp[maxn << 1], owp[maxn], os[maxn], ps[maxn];
long long add(long long a, long long b) {
if (a + b > mod)
return a + b - mod;
else
return a + b;
}
int lowbit(int x) { return x & (-x); }
void change1(int p, int x) {
while (p <= n) {
S[p] += x;
p += lowbit(p);
}
}
void change2(int p, int x) {
while (p <= n) {
wp[p] = add(x, wp[p]);
p += lowbit(p);
}
}
long long ssum(int k) {
long long ans = 0;
while (k > 0) {
ans += S[k];
k -= lowbit(k);
}
return ans;
}
int wpsum(int k) {
long long ans = 0;
while (k > 0) {
ans = add(ans, wp[k]);
k -= lowbit(k);
}
if (ans > mod || ans < -mod)
return ans % mod;
else
return ans;
}
long long ask(int l, int r, int op) {
if (op == 1)
return ssum(r) - ssum(l - 1);
else
return wpsum(r) - wpsum(l - 1);
}
int findk(int l, int r) {
int L = l, R = r, mid;
double al = 1.0 * (ask(l, r, 1)) / 2;
while (L < R) {
mid = (L + R) >> 1;
if (ask(l, mid, 1) >= al)
R = mid;
else
L = mid + 1;
}
return L;
}
int main() {
int q, a, b, pos;
long long nw, n1, n2;
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; i++) scanf("%lld", &ps[i]);
for (int i = 1; i <= n; i++) {
scanf("%lld", &os[i]);
owp[i] = (ps[i] - i) * os[i];
if (owp[i] > mod) owp[i] %= mod;
change1(i, os[i]);
change2(i, owp[i]);
}
while (q--) {
scanf("%d%d", &a, &b);
if (a < 0) {
pos = -a, nw = b;
n1 = nw - os[pos], n2 = (nw * (ps[pos] - pos) - owp[pos]) % mod;
os[pos] = b;
owp[pos] = nw * (ps[pos] - pos);
change1(pos, n1);
change2(pos, n2);
} else {
int k = findk(a, b);
l = a, r = b;
long long ans = ((ask(l, k, 1) - ask(k, r, 1)) * (ps[k] - k) -
(ask(l, k, 2) - ask(k, r, 2))) %
mod;
printf("%lld\n", (ans % mod + mod) % mod);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 1;
const int mod = 1e9 + 7;
long long f[2][maxn];
void upd(int r, long long x, int ix = 0) {
for (; r < maxn; r += r & -r) {
f[ix][r] += x;
}
}
long long getf(int r, int ix) {
long long ans = 0;
for (; r > 0; r -= r & -r) {
ans += f[ix][r];
}
return ans;
}
long long get(int l, int r, int ix = 0) {
if (l > r) return 0;
long long ans = getf(r, ix) - getf(l - 1, ix);
return ans;
}
long long getm(int l, int r, int ix = 0) { return get(l, r, ix) % mod; }
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, q;
cin >> n >> q;
long long a[n + 1], w[n + 1];
for (int i = 1; i <= n; i++) {
cin >> a[i];
a[i] -= i;
}
for (int i = 1; i <= n; i++) {
cin >> w[i];
upd(i, w[i], 0);
upd(i, a[i] * w[i] % mod, 1);
}
while (q--) {
long long l, r;
cin >> l >> r;
if (l < 0) {
upd(-l, -w[-l] + r);
upd(-l, (-a[-l] * w[-l]) % mod, 1);
upd(-l, (a[-l] * r) % mod, 1);
w[-l] = r;
} else {
long long lo = l - 1, hi = r, mid = l;
long long s = get(l, r);
while (lo < hi) {
int mid = (lo + hi) / 2;
long long s1 = get(l, mid);
if (s1 * 2 <= s)
lo = mid + 1;
else
hi = mid;
}
long long ansl =
(((a[lo] * getm(l, lo - 1) - getm(l, lo - 1, 1)) % mod) + mod) % mod;
long long ansr =
(((getm(lo + 1, r, 1) - a[lo] * getm(lo + 1, r)) % mod) + mod) % mod;
cout << (ansl + ansr) % mod << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = int(1e9) + 7;
int norm(int a) {
if (a >= MOD) a -= MOD;
if (a < 0) a += MOD;
return a;
}
int norm(const long long &a) { return norm(int(a % MOD)); }
int mul(int a, int b) { return int((a * 1ll * b) % MOD); }
const int N = 200 * 1000 + 555;
int n, q;
int a[N], w[N];
inline bool read() {
if (!(cin >> n >> q)) return false;
for (int i = int(0); i < int(n); i++) scanf("%d", &a[i]) == 1;
for (int i = int(0); i < int(n); i++) scanf("%d", &w[i]);
return true;
}
long long fW[N], fAW[N];
void inc(long long f[N], int pos, long long val) {
for (; pos < N; pos |= pos + 1) f[pos] += val;
}
long long sum(long long f[N], int pos) {
long long ans = 0;
for (; pos >= 0; pos = (pos & (pos + 1)) - 1) ans += f[pos];
return ans;
}
long long getSum(long long f[N], int l, int r) {
return sum(f, r - 1) - sum(f, l - 1);
}
int getNSum(long long f[N], int l, int r) {
return norm(sum(f, r - 1) - sum(f, l - 1));
}
inline void solve() {
for (int i = int(0); i < int(n); i++) {
a[i] -= i;
inc(fW, i, w[i]);
inc(fAW, i, mul(a[i], w[i]));
}
for (int _ = int(0); _ < int(q); _++) {
int x, y;
scanf("%d%d", &x, &y);
if (x < 0) {
x = -x - 1;
inc(fW, x, -w[x]);
inc(fAW, x, -mul(a[x], w[x]));
w[x] = y;
inc(fW, x, w[x]);
inc(fAW, x, mul(a[x], w[x]));
} else {
x--;
long long sum = getSum(fW, x, y);
int lf = x, rg = y;
while (rg - lf > 1) {
int mid = (lf + rg) >> 1;
if (2 * getSum(fW, x, mid) > sum)
rg = mid;
else
lf = mid;
}
int ans = norm(mul(a[lf], getNSum(fW, x, lf)) - getNSum(fAW, x, lf));
ans = norm(ans +
norm(getNSum(fAW, lf, y) - mul(a[lf], getNSum(fW, lf, y))));
printf("%d\n", ans);
}
}
}
int main() {
read();
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void chmin(T &x, const T &y) {
if (x > y) x = y;
}
template <typename T>
void chmax(T &x, const T &y) {
if (x < y) x = y;
}
int read() {
char c;
while ((c = getchar()) < '-')
;
if (c == '-') {
int x = (c = getchar()) - '0';
while ((c = getchar()) >= '0') x = x * 10 + c - '0';
return -x;
}
int x = c - '0';
while ((c = getchar()) >= '0') x = x * 10 + c - '0';
return x;
}
const int N = 2e5 + 5, T = N * 3, D = 1e9 + 7;
int b[N];
long long s[T], s2[T];
int n, d;
void modify(int i, int w) {
i += d;
s[i] = w;
s2[i] = (long long)w * b[i - d] % D;
while (i >>= 1) {
s[i] = s[(i * 2)] + s[((i * 2) + 1)];
s2[i] = s2[(i * 2)] + s2[((i * 2) + 1)];
}
}
long long qiu(int i, int t) {
if (i == 0) return 0;
i += d;
long long a1 = s[i], a2 = s2[i];
while (i) {
if (i % 2) {
a1 += s[i - 1];
a2 += s2[i - 1];
}
i >>= 1;
}
return t == 1 ? a1 : a2;
}
int erfen(long long sum) {
int i = 1;
while (i <= d)
if (s[(i * 2)] >= sum)
i = (i * 2);
else {
sum -= s[(i * 2)];
i = ((i * 2) + 1);
}
return i - d;
}
int query(int l, int r) {
long long sum = qiu(r, 1) - qiu(l - 1, 1);
int m = erfen((sum + 1) / 2 + qiu(l - 1, 1));
return ((b[m] * ((qiu(m, 1) - qiu(l - 1, 1) - (qiu(r, 1) - qiu(m, 1))) % D) +
(qiu(r, 2) - qiu(m, 2) - (qiu(m, 2) - qiu(l - 1, 2)))) %
D +
D) %
D;
}
int main() {
n = read();
int m = read();
for (d = 1; d < n; d *= 2)
;
--d;
for (int i = 1; i <= n; ++i) b[i] = read() - i;
for (int i = 1; i <= n; ++i) modify(i, read());
while (m--) {
int x = read(), y = read();
if (x < 0)
modify(-x, y);
else
printf("%d\n", query(x, y));
}
}
|
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
const int MAXN = 200000;
const int MAXQ = 200000;
const int MOD = 1000000007;
const int MAXS = 4 * MAXN;
void inc(int &a, int b) {
if ((a += b) >= MOD) a -= MOD;
}
int n, nq;
int a[MAXN];
int w[MAXN];
int qa[MAXQ], qb[MAXQ], qans[MAXQ];
long long ssum[MAXS];
int ssum2[MAXS];
void spull(int x) {
ssum[x] = ssum[2 * x + 1] + ssum[2 * x + 2];
ssum2[x] = (ssum2[2 * x + 1] + ssum2[2 * x + 2]) % MOD;
}
void sinit(int x, int l, int r) {
if (l == r) {
int idx = l;
ssum[x] = w[idx];
ssum2[x] = (long long)(a[idx] - idx) * w[idx] % MOD;
} else {
int m = l + (r - l) / 2;
sinit(2 * x + 1, l, m);
sinit(2 * x + 2, m + 1, r);
spull(x);
}
}
void sset(int x, int l, int r, int IDX, int VAL) {
if (l == r) {
ssum[x] = VAL;
ssum2[x] = (long long)(a[IDX] - IDX) * VAL % MOD;
} else {
int m = l + (r - l) / 2;
if (IDX <= m) sset(2 * x + 1, l, m, IDX, VAL);
if (m + 1 <= IDX) sset(2 * x + 2, m + 1, r, IDX, VAL);
spull(x);
}
}
pair<long long, int> sget(int x, int l, int r, int L, int R) {
if (L <= l && r <= R) {
return make_pair(ssum[x], ssum2[x]);
} else {
int m = l + (r - l) / 2;
pair<long long, int> ret = make_pair(0LL, 0);
if (L <= m) {
pair<long long, int> cur = sget(2 * x + 1, l, m, L, R);
ret.first += cur.first;
inc(ret.second, cur.second);
}
if (m + 1 <= R) {
pair<long long, int> cur = sget(2 * x + 2, m + 1, r, L, R);
ret.first += cur.first;
inc(ret.second, cur.second);
}
return ret;
}
}
int sfind(int x, int l, int r, int L, int R, long long &want) {
if (l == r && want <= ssum[x]) {
return l;
} else if (L <= l && r <= R && ssum[x] < want) {
want -= ssum[x];
return -1;
} else {
int m = l + (r - l) / 2;
if (L <= m) {
int cur = sfind(2 * x + 1, l, m, L, R, want);
if (cur != -1) return cur;
}
if (m + 1 <= R) {
int cur = sfind(2 * x + 2, m + 1, r, L, R, want);
if (cur != -1) return cur;
}
return -1;
}
}
void solve() {
sinit(0, 0, n - 1);
for (int i = (0); i < (nq); ++i) {
if (qa[i] < 0) {
int idx = -qa[i] - 1, nw = qb[i];
sset(0, 0, n - 1, idx, nw);
} else {
int l = qa[i] - 1, r = qb[i] - 1;
long long wsum = sget(0, 0, n - 1, l, r).first;
long long want = (wsum + 1) / 2;
int mid = sfind(0, 0, n - 1, l, r, want);
assert(mid != -1);
pair<long long, int> lres = sget(0, 0, n - 1, l, mid);
pair<long long, int> rres = sget(0, 0, n - 1, mid, r);
qans[i] = (((long long)(a[mid] - mid) * (lres.first % MOD) - lres.second +
(mid - a[mid]) * (rres.first % MOD) + rres.second) %
MOD +
MOD) %
MOD;
}
}
}
void run() {
scanf("%d%d", &n, &nq);
for (int i = (0); i < (n); ++i) scanf("%d", &a[i]);
for (int i = (0); i < (n); ++i) scanf("%d", &w[i]);
for (int i = (0); i < (nq); ++i) scanf("%d%d", &qa[i], &qb[i]);
solve();
for (int i = (0); i < (nq); ++i)
if (qa[i] > 0) printf("%d\n", qans[i]);
}
int main() {
run();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 5;
const long long INF = 1e9 + 7;
const long long mod = 1e9 + 7;
struct data {
long long a, b, c;
} tree[N << 2 | 1];
long long n, Q, t, a[N], w[N];
data operator+(const data &a, const data &b) {
data c;
c.a = a.a + b.a;
c.b = (a.b + b.b) % mod;
c.c = (a.c + b.c) % mod;
return c;
}
inline void init(long long k, long long l, long long r) {
if (l == r)
tree[k] = {w[l], w[l] * (l - a[l]) % mod, w[l] * (a[l] - l) % mod};
else {
long long mid = (l + r) >> 1;
init(k << 1, l, mid);
init(k << 1 | 1, mid + 1, r);
tree[k] = tree[k << 1] + tree[k << 1 | 1];
}
}
inline void update(long long k, long long l, long long r, long long pos) {
if (l > pos || r < pos) return;
if (l == r && l == pos)
tree[k] = {w[l], w[l] * (l - a[l]) % mod, w[l] * (a[l] - l) % mod};
else {
long long mid = (l + r) >> 1;
update(k << 1, l, mid, pos);
update(k << 1 | 1, mid + 1, r, pos);
tree[k] = tree[k << 1] + tree[k << 1 | 1];
}
}
inline data query(long long k, long long l, long long r, long long L,
long long R) {
if (l > R || r < L) return {0, 0, 0};
if (L <= l && r <= R)
return tree[k];
else {
long long mid = (l + r) >> 1;
return query(k << 1, l, mid, L, R) + query(k << 1 | 1, mid + 1, r, L, R);
}
}
inline long long sum(const long long &l, const long long &r,
const long long &num) {
if (num == 1) return query(1, 1, n, l, r).a;
if (num == 2) return query(1, 1, n, l, r).b;
if (num == 3) return query(1, 1, n, l, r).c;
}
inline long long Find(long long k, long long l, long long r, long long val) {
if (l == r) return l;
long long mid = (l + r) >> 1;
if (t % 2 == 0) {
if (tree[k << 1].a > val) return Find(k << 1, l, mid, val);
return Find(k << 1 | 1, mid + 1, r, val - tree[k << 1].a);
} else {
if (tree[k << 1].a >= val) return Find(k << 1, l, mid, val);
return Find(k << 1 | 1, mid + 1, r, val - tree[k << 1].a);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
scanf("%lld%lld", &n, &Q);
for (long long i = 1; i <= n; i++) scanf("%lld", a + i);
for (long long i = 1; i <= n; i++) scanf("%lld", w + i);
init(1, 1, n);
while (Q--) {
long long x, y;
scanf("%lld%lld", &x, &y);
if (x < 0) {
x = -x;
w[x] = y;
update(1, 1, n, x);
} else {
long long k = 0;
t = sum(x, y, 1);
long long ss = (sum(x, y, 1) + 1) / 2;
k = Find(1, 1, n, ss + sum(1, x - 1, 1));
long long s = 0;
s = (s + (a[k] * (sum(x, k - 1, 1) % mod) % mod) -
(k * (sum(x, k - 1, 1) % mod) % mod) + mod) %
mod;
s = (s + (sum(x, k - 1, 2) % mod) + mod) % mod;
s = (s - (a[k] * (sum(k, y, 1) % mod) % mod) +
(k * (sum(k, y, 1) % mod) % mod) + mod) %
mod;
s = (s + (sum(k, y, 3) % mod) + mod) % mod;
printf("%lld\n", s);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200100;
const int P = (1 << 18);
const int MAXP = 2 * P + 10;
const int MOD = 1e9 + 7;
int N, Q;
long long a[MAXN];
long long w[MAXN];
long long wseg[MAXP], wiseg[MAXP], waseg[MAXP];
void upd(long long* seg, int cloc, long long cdiff, bool mmod) {
cloc += P;
while (cloc) {
seg[cloc] += cdiff;
if (mmod) seg[cloc] %= MOD;
cloc /= 2;
}
}
long long add(long long* seg, int cloc, bool mmod) {
long long res = 0;
cloc += P;
while (cloc > 1) {
if (cloc & 1) {
res += seg[cloc - 1];
if (mmod) res %= MOD;
}
cloc /= 2;
}
return res;
}
int wsearch(long long sgoal) {
int cloc = 1;
while (cloc < P) {
if (wseg[2 * cloc] >= sgoal)
cloc *= 2;
else {
sgoal -= wseg[2 * cloc];
cloc *= 2;
cloc++;
}
}
return cloc - P;
}
int findm(int lo, int hi) {
long long sleft = add(wseg, lo, 0), sright = add(wseg, hi + 1, 0);
long long sgoal = (sleft + sright + 1) / 2;
return wsearch(sgoal);
}
int main() {
scanf("%d %d", &N, &Q);
for (int i = 0; i < N; i++) {
int x;
scanf("%d", &x);
a[i] = x;
}
for (int i = 0; i < N; i++) {
int x;
scanf("%d", &x);
w[i] = x;
}
for (int i = 0; i < N; i++) {
upd(wseg, i, w[i], 0);
upd(wiseg, i, i * w[i], 1);
upd(waseg, i, a[i] * w[i], 1);
}
for (int i = 0; i < Q; i++) {
int l, r;
scanf("%d %d", &l, &r);
if (l < 0) {
int cloc = -l - 1;
long long cdiff = r - w[cloc];
upd(wseg, cloc, cdiff, 0);
upd(wiseg, cloc, cloc * cdiff, 1);
upd(waseg, cloc, a[cloc] * cdiff, 1);
w[cloc] = r;
} else {
l--, r--;
int mm = findm(l, r);
long long ws = ((add(wseg, mm, 1) - add(wseg, l, 1)) % MOD + MOD) % MOD;
long long wis =
((add(wiseg, mm, 1) - add(wiseg, l, 1)) % MOD + MOD) % MOD;
long long was =
((add(waseg, mm, 1) - add(waseg, l, 1)) % MOD + MOD) % MOD;
long long res = ws * (a[mm] - mm) + wis - was;
r++;
ws = ((add(wseg, r, 1) - add(wseg, mm, 1)) % MOD + MOD) % MOD;
wis = ((add(wiseg, r, 1) - add(wiseg, mm, 1)) % MOD + MOD) % MOD;
was = ((add(waseg, r, 1) - add(waseg, mm, 1)) % MOD + MOD) % MOD;
long long bres = ws * (mm - a[mm]) - wis + was;
res = ((res + bres) % MOD + MOD) % MOD;
printf("%d\n", (int)res);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int q = 1000000007;
int n, m, a[200010], w[200010], g[200010];
long long f[200010], s[200010], p;
inline void add(int i, int k) {
for (; i <= n; i += i & -i) f[i] += k;
}
inline long long sum(int i) {
long long k = 0;
for (; i; i ^= i & -i) k += f[i];
return k;
}
inline void add2(int i, int k) {
for (; i <= n; i += i & -i) g[i] = (g[i] + k) % q;
}
inline int sum2(int i) {
long long k = 0;
for (; i; i ^= i & -i) k += g[i];
return k % q;
}
int main() {
int i, j, l, r;
long long k, u;
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
a[i] = a[i] + n - i;
s[i] = s[i - 1] + a[i];
}
for (i = 1; i <= n; i++) {
scanf("%d", &w[i]);
add(i, w[i]);
add2(i, (long long)w[i] * a[i] % q);
}
while (m--) {
scanf("%d", &i);
if (i < 0) {
i = -i;
scanf("%d", &j);
add(i, j - w[i]);
add2(i, (long long)(j - w[i]) * a[i] % q);
w[i] = j;
} else {
scanf("%d", &j);
u = sum(i - 1);
k = sum(j) - u;
for (l = i, r = j; l < r;)
if ((sum(l + r >> 1) - u) * 2 >= k)
r = (l + r >> 1);
else
l = (l + r >> 1) + 1;
p = (sum(l) - sum(i - 1)) % q * a[l] - (sum2(l) - sum2(i - 1));
p += (sum2(j) - sum2(l - 1)) - (sum(j) - sum(l - 1)) % q * a[l];
p = (p % q + q) % q;
printf("%lld\n", p);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
const int MOD = 1000000007;
long long A[N];
int B[N];
int n, q, a[N], w[N];
void add(int a, int b) {
for (int i = a; i <= n; i += (i & -i)) {
A[i] += b;
}
}
long long ask(int a) {
long long ret = 0;
for (; a > 0; a -= (a & -a)) {
ret += A[a];
}
return ret;
}
void add2(int a, int b) {
for (int i = a; i <= n; i += (i & -i)) {
(B[i] += b) %= MOD;
}
}
long long ask2(int a) {
long long ret = 0;
for (; a > 0; a -= (a & -a)) {
(ret += B[a]) %= MOD;
}
return ret;
}
int find(long long k) {
int ans = 0, i;
long long cnt = 0;
for (i = 20; i >= 0; i--) {
if (ans + (1 << i) <= n && cnt + A[ans + (1 << i)] < k) {
ans += (1 << i);
cnt += A[ans];
}
}
return ans + 1;
}
int main() {
scanf("%d %d", &n, &q);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (int i = 1; i <= n; i++) {
scanf("%d", &w[i]);
add(i, w[i]);
add2(i, (long long)w[i] * (((a[i] - i) + MOD) % MOD) % MOD);
}
while (q--) {
int x, y;
scanf("%d %d", &x, &y);
if (x < 0) {
x = -x;
add(x, y - w[x]);
add2(x, ((long long)y * (((a[x] - x) + MOD) % MOD) % MOD -
(long long)w[x] * (((a[x] - x) + MOD) % MOD) % MOD + MOD) %
MOD);
w[x] = y;
} else {
long long sr = ask(y);
long long sl = ask(x - 1);
long long sum = sr - sl;
int mid = find(sl + (sum + 1) / 2);
long long smid = ask(mid);
long long xx = (a[mid] - mid + MOD) % MOD;
long long ans = ask2(y) - ask2(mid) - (sr - smid) % MOD * xx % MOD;
ans +=
(smid - w[mid] - sl) % MOD * xx % MOD - (ask2(mid - 1) - ask2(x - 1));
ans %= MOD;
while (ans < 0) {
ans += MOD;
}
printf("%I64d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
inline int add(int a, int b) {
if ((a += b) >= mod) a -= mod;
return a;
}
inline int mult(int a, int b) {
long long t = 1ll * a * b;
if (t >= mod) t %= mod;
return t;
}
inline int dec(int a, int b) {
if ((a -= b) < 0) a += mod;
return a;
}
int n, q, a[200010], w[200010];
inline int lowbit(int x) { return x & (-x); }
class tree1 {
public:
long long dat[200010];
void modify(int p, int v) {
for (; p <= n; p += lowbit(p)) dat[p] += v;
}
long long query(int p) {
long long ret = 0;
for (; p; p -= lowbit(p)) ret += dat[p];
return ret;
}
long long query(int l, int r) { return query(r) - query(l - 1); }
} T1;
class tree2 {
public:
int dat[200010];
void modify(int p, int v) {
for (; p <= n; p += lowbit(p)) dat[p] = add(dat[p], v);
}
int query(int p) {
int ret = 0;
for (; p; p -= lowbit(p)) ret = add(ret, dat[p]);
return ret;
}
int query(int l, int r) { return dec(query(r), query(l - 1)); }
} T2;
int x, y;
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) {
scanf("%d", &w[i]);
T1.modify(i, w[i]);
T2.modify(i, mult(w[i], a[i] - i));
}
while (q--) {
scanf("%d%d", &x, &y);
if (x < 0) {
x = -x;
T1.modify(x, y - w[x]);
T2.modify(x, mult(dec(y, w[x]), a[x] - x));
w[x] = y;
} else {
if (x == y) {
puts("0");
continue;
}
int L = x, R = y, pos = L;
while (L <= R) {
int mid = (L + R) >> 1;
if (T1.query(x, mid) >= T1.query(mid + 1, y))
pos = mid, R = mid - 1;
else
L = mid + 1;
}
printf("%d\n", add(dec(mult(a[pos] - pos, T1.query(x, pos) % mod),
T2.query(x, pos)),
dec(T2.query(pos, y),
mult(a[pos] - pos, T1.query(pos, y) % mod))));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Fenwick {
vector<long long int> bit;
long long int size;
void modify(long long int j, long long int v) {
j++;
for (; j < size; j += j & -j) bit[j] += v;
}
long long int query(long long int j) {
j++;
long long int v = 0;
for (; j > 0; j -= j & -j) v += bit[j];
return v;
}
long long int rangequery(long long int a, long long int b) {
if (b < a) return 0;
return query(b) - query(a - 1);
}
void rangeupdate(long long int a, long long int b, long long int v) {
modify(a, v);
modify(b + 1, -v);
}
Fenwick(long long int s) {
s += 3;
size = s;
bit = vector<long long int>(s, 0);
}
};
struct FenwickM {
vector<long long int> bit;
long long int size;
void modify(long long int j, long long int v) {
v %= 1000000007;
v = (v + 1000000007) % 1000000007;
j++;
for (; j < size; j += j & -j) bit[j] = (bit[j] + v) % 1000000007;
}
long long int query(long long int j) {
j++;
long long int v = 0;
for (; j > 0; j -= j & -j) v = (bit[j] + v) % 1000000007;
return v;
}
long long int rangequery(long long int a, long long int b) {
return (query(b) - query(a - 1) + 1000000007) % 1000000007;
}
void rangeupdate(long long int a, long long int b, long long int v) {
modify(a, v);
modify(b + 1, -v);
}
FenwickM(long long int s) {
s += 3;
size = s;
bit = vector<long long int>(s, 0);
}
};
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n, q;
cin >> n >> q;
vector<long long int> X(n + 1);
vector<long long int> W(n + 1);
vector<pair<long long int, long long int> > Q(q);
vector<long long int> beg;
Fenwick pref(200005);
FenwickM data(200005);
for (long long int i = 1; i <= n; i++) cin >> X[i];
for (long long int i = 1; i <= n; i++) cin >> W[i];
beg = W;
for (long long int i = 0; i < q; i++) {
cin >> Q[i].first >> Q[i].second;
}
for (long long int i = 1; i <= n; i++) {
pref.modify(i, W[i]);
data.modify(i, (i - X[i]) * W[i]);
}
for (long long int k = 0; k < q; k++) {
if (Q[k].first < 0) {
long long int i = -Q[k].first;
pref.modify(i, Q[k].second - W[i]);
data.modify(i, -(i - X[i]) * W[i]);
data.modify(i, (i - X[i]) * Q[k].second);
W[i] = Q[k].second;
} else {
long long int L = Q[k].first, R = Q[k].second;
long long int l = L, r = R;
long long int med = L - 1;
if (L == R) {
cout << "0\n";
continue;
}
while (l <= r) {
long long int mid = (l + r) / 2;
if (pref.rangequery(L, mid) <= pref.rangequery(mid + 1, R)) {
med = mid;
l = mid + 1;
} else
r = mid - 1;
}
long long int ans = 0;
if (med >= L)
ans = (pref.rangequery(L, med) % 1000000007 * (X[med + 1] - med - 1) %
1000000007 +
data.rangequery(L, med)) %
1000000007;
med += 2;
if (med <= R)
ans = (ans -
pref.rangequery(med, R) % 1000000007 * (X[med - 1] - med + 1) %
1000000007 -
data.rangequery(med, R)) %
1000000007;
cout << (ans % 1000000007 + 1000000007) % 1000000007 << "\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
string to_string(const string& str) { return str; }
template <typename T>
string to_string(const set<T>& mys) {
if (mys.empty()) return "{}";
string ret = "{";
for (auto el : mys) ret += to_string(el) + ", ";
ret.pop_back(), ret.pop_back();
ret += "}";
return ret;
}
template <typename T>
string to_string(const pair<T, T>& pr) {
return "(" + to_string(pr.first) + "," + to_string(pr.second) + ")";
}
template <typename T>
string to_string(const vector<T>& vc, int w) {
if (vc.empty()) return "";
if (w + 1 == vc.size()) return to_string(vc[w]);
return to_string(vc[w]) + "," + to_string(vc, w + 1);
}
template <typename T>
string to_string(const vector<T>& vc) {
return "{" + to_string(vc, 0) + "}";
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
class DebugStream {
} LOG;
template <typename T>
DebugStream& operator<<(DebugStream& s, const T&) {
return s;
}
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
const int maxN = 2e5 + 9, maxV = 1e6 + 9, MOD = 1e9 + 7, SQ = 335, lg = 20,
bs = 29;
int n;
long long query(long long* T, int l, int r, bool md = true) {
long long ret = 0;
for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
if (l & 1) ret += T[l++];
if (r & 1) ret += T[--r];
if (md) ret %= MOD;
}
return ret;
}
void pullUp(long long* T, int w, bool md = true) {
while (w > 1) {
w >>= 1;
T[w] = T[w << 1] + T[w << 1 | 1];
if (md) T[w] %= MOD;
}
}
long long pln[maxN << 1];
struct Estr {
long long arr[maxN], wgt[maxN << 1], cst[maxN << 1];
void build() {
for (int i = 0; i < n; i++) cst[i + n] = wgt[i + n] * (arr[i] - i) % MOD;
for (int i = n - 1; i > 0; i--) {
cst[i] = (cst[i << 1] + cst[i << 1 | 1]) % MOD;
wgt[i] = (wgt[i << 1] + wgt[i << 1 | 1]) % MOD;
}
}
void upd(int w, long long x) {
wgt[w + n] = x;
cst[w + n] = x * (arr[w] - w) % MOD;
pullUp(wgt, w + n), pullUp(cst, w + n);
}
long long calc(int le, int ri) {
long long dists = query(cst, le, ri);
long long sob = query(wgt, le, ri) * (arr[le] - le) % MOD;
return (dists - sob + MOD) % MOD;
}
} one, two;
int getKey(int a, int b) {
int le = a, ri = b;
while (le + 1 < ri) {
int mi = (le + ri) / 2;
if (query(pln, a, mi, false) <= query(pln, mi, b, false))
le = mi;
else
ri = mi;
}
return le;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int q;
cin >> n >> q;
for (int i = 0, inp; i < n; i++) {
cin >> inp;
one.arr[i] = inp;
two.arr[n - i - 1] = MOD - inp;
}
for (int i = 0, inp; i < n; i++) {
cin >> inp;
pln[i + n] = inp;
one.wgt[i + n] = inp;
two.wgt[n * 2 - i - 1] = inp;
}
for (int i = n - 1; i > 0; i--) pln[i] = pln[i << 1] + pln[i << 1 | 1];
one.build();
two.build();
while (q--) {
int x, y;
cin >> x >> y;
if (x < 0) {
int w = -x - 1, nw = y;
one.upd(w, nw);
two.upd(n - w - 1, nw);
pln[w + n] = nw;
pullUp(pln, w + n, false);
} else {
int le = x, ri = y;
le--;
int w = getKey(le, ri);
long long ans = (one.calc(w, ri) + two.calc(n - w - 1, n - le)) % MOD;
cout << ans << '\n';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
struct SegtreeMOD {
vector<long long> t;
int n, h;
SegtreeMOD() {}
SegtreeMOD(int sz) {
h = 32 - __builtin_clz(sz);
n = 1 << h;
t = vector<long long>(n << 1);
}
void assign(int x, long long v) {
x += n;
t[x] = v % MOD;
for (x /= 2; x; x /= 2) {
t[x] = (t[x << 1] + t[x << 1 | 1]);
if (t[x] >= MOD) {
t[x] -= MOD;
}
}
}
long long query(int l, int r) {
long long ans = 0;
for (l += n, r += n; l < r; l /= 2, r /= 2) {
if (l % 2) {
ans += t[l++];
}
if (r % 2) {
ans += t[--r];
}
}
return ans % MOD;
}
};
struct Segtree {
vector<long long> t;
int n, h;
Segtree() {}
Segtree(int sz) {
h = 32 - __builtin_clz(sz);
n = 1 << h;
t = vector<long long>(n << 1);
}
void assign(int x, long long v) {
x += n;
t[x] = v;
for (x /= 2; x; x /= 2) {
t[x] = t[x << 1] + t[x << 1 | 1];
}
}
long long query(int l, int r) {
long long ans = 0;
for (l += n, r += n; l < r; l /= 2, r /= 2) {
if (l % 2) {
ans += t[l++];
}
if (r % 2) {
ans += t[--r];
}
}
return ans;
}
pair<long long, int> bs(int l, int r, long long goal, int x, int lv, int rv) {
if (rv <= l || r <= lv) {
return {0, -1};
}
if (l <= lv && rv <= r) {
if (t[x] < goal) {
return {t[x], -1};
}
if (rv - lv == 1) {
return {t[x], lv};
}
}
int mv = (lv + rv) / 2;
auto res1 = bs(l, r, goal, x * 2, lv, mv);
if (res1.second != -1) {
return res1;
}
auto res2 = bs(l, r, goal - res1.first, x * 2 + 1, mv, rv);
return {res2.first + res1.first, res2.second};
}
int bs(int l, int r, long long goal) {
return bs(l, r, goal, 1, 0, n).second;
}
};
Segtree weights;
SegtreeMOD wx;
int n, q;
long long a[200200];
long long query(int l, int r) {
long long wtot = weights.query(l, r + 1);
int med = weights.bs(l, r + 1, (wtot + 1) / 2);
long long ans = ((weights.query(l, med) * 2 - wtot) % MOD) * a[med] -
wx.query(l, med) + wx.query(med, r + 1);
ans = (ans % MOD + MOD) % MOD;
return ans % MOD;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
cin >> n >> q;
weights = Segtree(n + 1);
wx = SegtreeMOD(n + 1);
for (int i = 1; i <= n; ++i) {
cin >> a[i];
a[i] -= i;
}
for (int i = 1; i <= n; ++i) {
long long w;
cin >> w;
weights.assign(i, w);
wx.assign(i, w * a[i]);
}
while (q--) {
int _a, b;
cin >> _a >> b;
if (_a > 0) {
cout << query(_a, b) << "\n";
} else {
int id = -_a, nw = b;
weights.assign(id, nw);
wx.assign(id, nw * a[id]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename _T>
inline void _DBG(const char *s, _T x) {
cerr << s << " = " << x << "\n";
}
template <typename _T, typename... args>
void _DBG(const char *s, _T x, args... a) {
while (*s != ',') cerr << *s++;
cerr << " = " << x << ',';
_DBG(s + 1, a...);
}
const int N = 2e5 + 7;
const int M = 1e9 + 7;
const int MAX = 1 << 18;
struct node {
long long l, r;
long long sum, val, pos;
};
void merge(node &nn, node A, node &B) {
node my;
my.l = A.l, my.r = B.r;
my.sum = A.sum + B.sum;
my.pos = B.pos;
my.val = (B.val + A.val + A.sum % M * (B.pos - A.pos + A.r - B.r)) % M;
nn = my;
}
int n, q;
long long A[N], W[N], RA[N], RW[N];
node tree[2 * MAX + 7], rtree[2 * MAX + 7];
long long query1(int l, int r) {
l += MAX, r += MAX;
if (l == r) {
return 0;
}
vector<int> vec = {r};
node res = tree[l];
while (l / 2 != r / 2) {
if (l % 2 == 0) merge(res, res, tree[l + 1]);
if (r % 2 == 1) vec.push_back(r - 1);
l /= 2, r /= 2;
}
while (!vec.empty()) {
merge(res, res, tree[vec.back()]);
vec.pop_back();
}
return res.val;
}
long long query2(int l, int r) {
l = n - l + 1, r = n - r + 1;
swap(l, r);
l += MAX, r += MAX;
if (l == r) {
return 0;
}
vector<int> vec = {r};
node res = rtree[l];
while (l / 2 != r / 2) {
if (l % 2 == 0) merge(res, res, rtree[l + 1]);
if (r % 2 == 1) vec.push_back(r - 1);
l /= 2, r /= 2;
}
while (!vec.empty()) {
merge(res, res, rtree[vec.back()]);
vec.pop_back();
}
return res.val;
}
long long sum(int l, int r) {
l += MAX, r += MAX;
if (l == r) return tree[l].sum;
long long ans = tree[l].sum + tree[r].sum;
while (l / 2 != r / 2) {
if (l % 2 == 0) ans += tree[l + 1].sum;
if (r % 2 == 1) ans += tree[r - 1].sum;
l /= 2, r /= 2;
}
return ans;
}
long long alls;
long long cost(int i, int l, int r) {
long long s1 = sum(l, i), s2 = alls - s1;
return s1 - s2;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> q;
for (int i = 1; i <= n; i++) {
cin >> A[i];
RA[n - i + 1] = -A[i];
}
for (int i = 1; i <= n; i++) {
cin >> W[i];
RW[n - i + 1] = W[i];
}
for (int i = 1; i <= n; i++) {
tree[MAX + i].l = tree[MAX + i].r = i;
tree[MAX + i].sum = W[i], tree[MAX + i].val = 0;
tree[MAX + i].pos = A[i];
rtree[MAX + i].l = rtree[MAX + i].r = i;
rtree[MAX + i].sum = RW[i], rtree[MAX + i].val = 0;
rtree[MAX + i].pos = RA[i];
}
for (int i = MAX; i; i--) {
merge(tree[i], tree[2 * i], tree[2 * i + 1]);
merge(rtree[i], rtree[2 * i], rtree[2 * i + 1]);
}
while (q--) {
int x, y;
cin >> x >> y;
if (x < 0) {
x *= -1;
W[x] = y;
tree[MAX + x].sum = y;
for (int e = (x + MAX) / 2; e; e /= 2) {
merge(tree[e], tree[2 * e], tree[2 * e + 1]);
}
RW[n - x + 1] = y;
rtree[n - x + 1 + MAX].sum = y;
for (int e = (n - x + 1 + MAX) / 2; e; e /= 2) {
merge(rtree[e], rtree[2 * e], rtree[2 * e + 1]);
}
} else {
if (x == y) {
cout << 0 << "\n";
} else {
int l = x - 1, r = y;
alls = sum(x, y);
while (l + 1 < r) {
int m = (l + r) / 2;
if (cost(m, x, y) <= 0) {
l = m;
} else {
r = m;
}
}
l++;
cout << (query1(x, l) + query2(l, y)) % M << "\n";
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200005, mod = 1e9 + 7;
inline long long read() {
long long X = 0, w = 1;
char ch = 0;
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
X = (X << 3) + (X << 1) + ch - '0', ch = getchar();
return X * w;
}
int n, Q, a[N], w[N], c2[N];
long long c1[N];
void add(int &x, int y) {
if ((x += y) >= mod) x -= mod;
}
void add1(int x, long long d) {
for (; x <= n; x += x & -x) c1[x] += d;
}
void add2(int x, int d) {
for (; x <= n; x += x & -x) add(c2[x], d);
}
long long ask1(int x) {
long long ans = 0;
for (; x; x -= x & -x) ans += c1[x];
return ans;
}
int ask2(int x) {
int ans = 0;
for (; x; x -= x & -x) add(ans, c2[x]);
return ans;
}
void opt1(int i, int nw) {
add1(i, -w[i]);
add2(i, (-1ll * w[i] * a[i] % mod + mod) % mod);
w[i] = nw;
add1(i, w[i]);
add2(i, 1ll * w[i] * a[i] % mod);
}
void opt2(int L, int R) {
long long t = ask1(L - 1);
long long sum = ask1(R) - t;
int le = L, ri = R, mid, ans = R;
while (le <= ri) {
mid = (le + ri) >> 1;
long long v = ask1(mid) - t;
if (v * 2 >= sum)
ri = mid - 1, ans = mid;
else
le = mid + 1;
}
long long v11 = ask2(ans) - ask2(L - 1),
v12 = -1ll * a[ans] * ((ask1(ans) - t) % mod) % mod;
long long v21 = ask2(R) - ask2(ans),
v22 = -1ll * a[ans] * ((ask1(R) - ask1(ans)) % mod) % mod;
long long Ans = (v21 + v22 - v11 - v12) % mod;
Ans = (Ans + mod) % mod;
printf("%I64d\n", Ans);
}
int main() {
n = read(), Q = read();
for (int i = 1; i <= n; i++) a[i] = read() - i + n;
for (int i = 1; i <= n; i++) {
w[i] = read();
add1(i, w[i]);
add2(i, 1ll * w[i] * a[i] % mod);
}
while (Q--) {
int x = read(), y = read();
if (x < 0)
opt1(-x, y);
else
opt2(x, y);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char buf[1 << 21], *p1 = buf, *p2 = buf;
inline int read() {
char ch;
bool flag = 0;
int res;
while (!isdigit(
ch = (p1 == p2 &&
(p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin), p1 == p2)
? EOF
: *p1++)))
(ch == '-') && (flag = true);
for (res = ch - '0'; isdigit(
ch = (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin),
p1 == p2)
? EOF
: *p1++));
res = res * 10 + ch - '0')
;
(flag) && (res = -res);
return res;
}
char sr[1 << 21], z[20];
int C = -1, Z;
inline void Ot() { fwrite(sr, 1, C + 1, stdout), C = -1; }
inline void print(int x) {
if (C > 1 << 20) Ot();
if (x < 0) sr[++C] = 45, x = -x;
while (z[++Z] = x % 10 + 48, x /= 10)
;
while (sr[++C] = z[Z], --Z)
;
sr[++C] = '\n';
}
const int N = 2e5 + 5;
const long long P = 1e9 + 7;
int n, q;
long long a[N], w[N];
namespace SUM {
long long c[N];
inline void add(int x, long long y) {
for (; x <= n; x += x & -x) c[x] += y;
}
inline long long que(int x) {
long long res = 0;
for (; x; x -= x & -x) res += c[x];
return res;
}
inline long long query(int l, int r) {
if (r < l) return 0;
return que(r) - que(l - 1);
}
} // namespace SUM
namespace MUL {
long long c[N];
inline void add(int x, long long y) {
y %= P;
for (; x <= n; x += x & -x) (c[x] += y + P) %= P;
}
inline long long que(int x) {
long long res = 0;
for (; x; x -= x & -x) (res += c[x]) %= P;
return res;
}
inline long long query(int l, int r) {
if (r < l) return 0;
return (que(r) - que(l - 1) + P) % P;
}
} // namespace MUL
inline int getpos(int ql, int qr) {
int l = ql, r = qr, mid, res;
while (l <= r) {
mid = (l + r) >> 1;
if (SUM::query(ql, mid) >= SUM::query(mid + 1, qr))
res = mid, r = mid - 1;
else
l = mid + 1;
}
return res;
}
void solve(int l, int r) {
if (l == r) return (void)(print(0));
int pos = getpos(l, r);
long long res = 0;
res = (-MUL::query(l, pos) + (SUM::query(l, pos) % P) * (a[pos] - pos) % P +
P) %
P;
res = (res + MUL::query(pos, r) -
SUM::query(pos, r) % P * (a[pos] - pos) % P + P) %
P;
print(res);
}
int main() {
n = read(), q = read();
for (int i = 1; i <= n; ++i) a[i] = read();
for (int i = 1; i <= n; ++i) {
w[i] = read(), SUM::add(i, w[i]), MUL::add(i, w[i] * (a[i] - i));
}
while (q--) {
int x = read(), y = read();
if (x < 0) {
x = -x, SUM::add(x, -w[x]), MUL::add(x, -w[x] * (a[x] - x));
w[x] = y, SUM::add(x, y), MUL::add(x, y * (a[x] - x));
} else
solve(x, y);
}
Ot();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXSIZE = 30000020;
int bufpos;
char buf[MAXSIZE];
void init() {
buf[fread(buf, 1, MAXSIZE, stdin)] = '\0';
bufpos = 0;
}
int readint() {
bool isneg;
int val = 0;
for (; !isdigit(buf[bufpos]) && buf[bufpos] != '-'; bufpos++)
;
bufpos += (isneg = buf[bufpos] == '-');
for (; isdigit(buf[bufpos]); bufpos++) val = val * 10 + buf[bufpos] - '0';
return isneg ? -val : val;
}
char readchar() {
for (; isspace(buf[bufpos]); bufpos++)
;
return buf[bufpos++];
}
int readstr(char* s) {
int cur = 0;
for (; isspace(buf[bufpos]); bufpos++)
;
for (; !isspace(buf[bufpos]); bufpos++) s[cur++] = buf[bufpos];
s[cur] = '\0';
return cur;
}
const int maxn = 200002;
const int mod = 1000000007;
struct bit {
int n;
long long a[maxn];
void add(int p, long long v) {
for (; p <= n; p += p & -p) a[p] += v;
}
long long query(int p) {
long long ans = 0;
for (; p; p -= p & -p) ans += a[p];
return ans;
}
} b1, b2;
long long a[maxn], w[maxn];
int main() {
init();
int n = readint(), q = readint();
for (int i = 1; i <= n; i++) a[i] = readint() - i;
b1.n = b2.n = n;
for (int i = 1; i <= n; i++) {
w[i] = readint();
b1.add(i, w[i]);
b2.add(i, w[i] * a[i] % mod);
}
while (q--) {
int x = readint(), y = readint();
if (x < 0) {
x = -x;
b1.add(x, y - w[x]);
b2.add(x, y * a[x] % mod - w[x] * a[x] % mod);
w[x] = y;
continue;
}
long long o = b1.query(x - 1), t = b1.query(y);
int l = x, r = y;
while (l < r) {
int mid = (l + r) / 2;
if (2 * b1.query(mid) - o - t > 0)
r = mid;
else
l = mid + 1;
}
long long ans = (b1.query(l) - o) % mod * a[l] - b2.query(l) +
b2.query(x - 1) + b2.query(y) - b2.query(l) -
(t - b1.query(l)) % mod * a[l];
printf("%lld\n", (ans % mod + mod) % mod);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int mo = 1000000007;
const int N = 200005;
int n, q;
int a[N], w[N];
long long cntw[N * 4];
int val[N * 4];
void build(int k, int l, int r) {
if (l == r) {
cntw[k] = w[l];
val[k] = 1ll * w[l] * a[l] % mo;
return;
}
int mid = (l + r) / 2;
build(k * 2, l, mid);
build(k * 2 + 1, mid + 1, r);
cntw[k] = cntw[k * 2] + cntw[k * 2 + 1];
val[k] = (val[k * 2] + val[k * 2 + 1]) % mo;
}
void change(int k, int l, int r, int p, int v) {
if (l == r) {
cntw[k] = v;
val[k] = 1ll * v * a[l] % mo;
return;
}
int mid = (l + r) / 2;
if (p <= mid)
change(k * 2, l, mid, p, v);
else
change(k * 2 + 1, mid + 1, r, p, v);
cntw[k] = cntw[k * 2] + cntw[k * 2 + 1];
val[k] = (val[k * 2] + val[k * 2 + 1]) % mo;
}
long long askw(int k, int l, int r, int x, int y) {
if (l == x && r == y) return cntw[k];
int mid = (l + r) / 2;
if (y <= mid) return askw(k * 2, l, mid, x, y);
if (x > mid) return askw(k * 2 + 1, mid + 1, r, x, y);
return askw(k * 2, l, mid, x, mid) + askw(k * 2 + 1, mid + 1, r, mid + 1, y);
}
int findpos(int k, int l, int r, long long v) {
if (l == r) return l;
int mid = (l + r) / 2;
if (cntw[k * 2] <= v) return findpos(k * 2 + 1, mid + 1, r, v - cntw[k * 2]);
return findpos(k * 2, l, mid, v);
}
int askcnt(int k, int l, int r, int x, int y) {
if (l == x && r == y) return val[k];
int mid = (l + r) / 2;
if (y <= mid) return askcnt(k * 2, l, mid, x, y);
if (x > mid) return askcnt(k * 2 + 1, mid + 1, r, x, y);
return (askcnt(k * 2, l, mid, x, mid) +
askcnt(k * 2 + 1, mid + 1, r, mid + 1, y)) %
mo;
}
int calc(int l, int mid, int r) {
int ans = 0;
if (mid >= l) {
ans = mo - askcnt(1, 1, n, l, mid);
ans = (ans + 1ll * askw(1, 1, n, l, mid) % mo * a[mid] % mo) % mo;
}
if (mid < r) {
ans = (ans + askcnt(1, 1, n, mid + 1, r)) % mo;
ans = (ans + mo - 1ll * askw(1, 1, n, mid + 1, r) % mo * a[mid] % mo) % mo;
}
return ans;
}
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), a[i] += n - i;
for (int i = 1; i <= n; i++) scanf("%d", &w[i]);
build(1, 1, n);
while (q--) {
int x, y;
scanf("%d%d", &x, &y);
if (x < 0)
change(1, 1, n, -x, y);
else {
long long sum = askw(1, 1, n, x, y);
long long leftv = (sum + 1) / 2;
if (x != 1) leftv += askw(1, 1, n, 1, x - 1);
int mid = findpos(1, 1, n, leftv - 1);
printf("%d\n", calc(x, mid, y));
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200010, LGN = 18, X = 1 << LGN, P = 1000000007;
int n, q;
int a[N], w[N];
int fw[N];
long long wfw[X];
int lowBit(int k) { return k & -k; }
long long lq(int k);
void lch(int k, int x);
int bound(long long v);
int qr(int k);
void ch(int k, int x);
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
a[i] -= i;
}
for (int i = 1; i <= n; ++i) {
scanf("%d", &w[i]);
ch(i, w[i] * (long long)a[i] % P);
lch(i, w[i]);
}
while (q--) {
int x, y;
scanf("%d%d", &x, &y);
if (x < 0) {
x = -x;
int delt = y - w[x];
w[x] = y;
lch(x, delt);
if ((delt %= P) < 0) delt += P;
ch(x, delt * (long long)a[x] % P);
} else {
int pos = bound(lq(x - 1) + (lq(y) - lq(x - 1) + 1) / 2);
int ans =
((qr(y) - qr(pos)) % P - (lq(y) - lq(pos)) % P * a[pos] % P) % P;
if (ans < 0) ans += P;
ans = (ans + (lq(pos - 1) - lq(x - 1)) % P * a[pos] % P -
(qr(pos - 1) - qr(x - 1)) % P) %
P;
if (ans < 0) ans += P;
printf("%d\n", ans);
}
}
return 0;
}
int qr(int k) {
int ret = 0;
for (; k; k -= lowBit(k))
if ((ret += fw[k]) >= P) ret -= P;
return ret;
}
void ch(int k, int x) {
for (; k <= n; k += lowBit(k))
if ((fw[k] += x) >= P) fw[k] -= P;
}
long long lq(int k) {
long long ret = 0;
for (; k; k -= lowBit(k)) ret += wfw[k];
return ret;
}
void lch(int k, int x) {
for (; k < X; k += lowBit(k)) wfw[k] += x;
}
int bound(long long x) {
int ret = 0;
for (int k = LGN - 1; k >= 0; --k)
if (x > wfw[ret | (1 << k)]) x -= wfw[ret |= 1 << k];
return ret + 1;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200005, mod = 1e9 + 7;
long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch) && ch != '-') ch = getchar();
if (ch == '-') f = -1, ch = getchar();
while (isdigit(ch)) x = (x << 1) + (x << 3) + ch - 48, ch = getchar();
return x * f;
}
int n, Q;
int a[N], w[N];
long long c1[N];
int c2[N];
void add(int &x, int y) {
if ((x += y) >= mod) x -= mod;
}
void add1(int x, long long d) {
for (; x <= n; x += x & -x) c1[x] += d;
}
void add2(int x, int d) {
for (; x <= n; x += x & -x) add(c2[x], d);
}
long long ask1(int x) {
long long ans = 0;
for (; x; x -= x & -x) ans += c1[x];
return ans;
}
int ask2(int x) {
int ans = 0;
for (; x; x -= x & -x) add(ans, c2[x]);
return ans;
}
void opt1(int i, int nw) {
add1(i, -w[i]);
add2(i, (-1LL * w[i] * a[i] % mod + mod) % mod);
w[i] = nw;
add1(i, w[i]);
add2(i, 1LL * w[i] * a[i] % mod);
}
void opt2(int L, int R) {
long long t = ask1(L - 1);
long long sum = ask1(R) - t;
int le = L, ri = R, mid, ans = R;
while (le <= ri) {
mid = (le + ri) >> 1;
long long v = ask1(mid) - t;
if (v * 2 >= sum)
ri = mid - 1, ans = mid;
else
le = mid + 1;
}
long long v11 = ask2(ans) - ask2(L - 1),
v12 = -1LL * a[ans] * ((ask1(ans) - t) % mod) % mod;
long long v21 = ask2(R) - ask2(ans),
v22 = -1LL * a[ans] * ((ask1(R) - ask1(ans)) % mod) % mod;
long long Ans = (v21 + v22 - v11 - v12) % mod;
Ans = (Ans + mod) % mod;
printf("%I64d\n", Ans);
}
int main() {
n = read(), Q = read();
for (int i = 1; i <= n; i++) a[i] = read() - i + n;
memset(c1, 0, sizeof c1);
memset(c2, 0, sizeof c2);
for (int i = 1; i <= n; i++) {
w[i] = read();
add1(i, w[i]);
add2(i, 1LL * w[i] * a[i] % mod);
}
while (Q--) {
int x = read(), y = read();
if (x < 0)
opt1(-x, y);
else
opt2(x, y);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const int N = 1 << 18;
long long places[N];
long long weights[N];
long long negs[2 * N];
long long mults[2 * N];
void update(int i) {
negs[i] = (negs[2 * i] + negs[2 * i + 1]) % MOD;
mults[i] = mults[2 * i] + mults[2 * i + 1];
}
void setWeight(int i, int w) {
int j = i + N;
mults[j] = w;
negs[j] = ((places[i] - i) * w) % MOD;
j >>= 1;
while (j > 0) {
update(j);
j >>= 1;
}
}
long long ans(int a, int b, int j, int i = 1, int ia = 0, int ib = N - 1) {
if (b < ia || ib < a) return 0;
if (a <= ia && ib <= b) {
long long mt = (mults[i] % MOD) * (places[j] - j);
long long nt = negs[i];
if (ib <= j) {
return (mt - nt) % MOD;
} else if (ia >= j) {
return (nt - mt) % MOD;
}
}
int mid = (ia + ib) >> 1;
return (ans(a, b, j, 2 * i, ia, mid) + ans(a, b, j, 2 * i + 1, mid + 1, ib)) %
MOD;
}
long long delta(int a, int b, int j, int i = 1, int ia = 0, int ib = N - 1) {
if (b < ia || ib < a) return 0;
if (a <= ia && ib <= b) {
if (ib <= j) {
return mults[i];
} else if (ia > j) {
return -mults[i];
}
}
int mid = (ia + ib) >> 1;
return delta(a, b, j, 2 * i, ia, mid) +
delta(a, b, j, 2 * i + 1, mid + 1, ib);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, q;
cin >> n >> q;
for (int i = 0; i < n; ++i) cin >> places[i];
for (int i = 0; i < n; ++i) cin >> weights[i];
for (int i = 0; i < n; ++i) setWeight(i, weights[i]);
for (int t = 0; t < q; ++t) {
int x, y;
cin >> x >> y;
if (x > 0) {
--x;
--y;
int split_low = x;
int split_high = y;
while (split_low != split_high) {
int split_mid = (split_low + split_high) >> 1;
if (delta(x, y, split_mid) < 0) {
split_low = split_mid + 1;
} else {
split_high = split_mid;
}
}
long long res = ans(x, y, split_low);
if (res < 0) res += MOD;
cout << res << '\n';
} else {
x = -x;
--x;
setWeight(x, y);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
void read(T &x) {
x = 0;
char c = getchar();
long long f = 0;
while (c < '0' || c > '9') f |= (c == '-'), c = getchar();
while (c >= '0' && c <= '9')
x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();
if (f) x = -x;
}
const long long N = 2e5 + 5, mod = 1e9 + 7;
void addn(long long &x, long long y) { x = (x + y) % mod; }
long long n, q, a[N], w[N];
struct BIT {
long long tr[N];
void init() { memset(tr, 0, sizeof(tr)); }
void mdf(long long x, long long v, long long op) {
for (; x <= n; x += x & -x) {
if (op)
addn(tr[x], v);
else
tr[x] += v;
}
}
long long que(long long x, long long op) {
long long res = 0;
for (; x; x -= x & -x) {
if (op)
addn(res, tr[x]);
else
res += tr[x];
}
return res;
}
long long ask(long long l, long long r, long long op) {
if (op)
return (que(r, 1) - que(l - 1, 1) + mod) % mod;
else
return que(r, 0) - que(l - 1, 0);
}
} sum, mul1, mul2;
signed main() {
cin >> n >> q;
for (long long i = 1; i <= n; ++i) scanf("%lld", &a[i]);
for (long long i = 1; i <= n; ++i) scanf("%lld", &w[i]);
sum.init();
mul1.init();
mul2.init();
for (long long i = 1; i <= n; ++i) {
sum.mdf(i, w[i], 0);
mul1.mdf(i, a[i] * w[i] % mod, 1);
mul2.mdf(i, w[i] * i % mod, 1);
}
long long x, y;
while (q-- > 0) {
read(x);
read(y);
if (x < 0) {
x *= -1;
sum.mdf(x, y - w[x], 0);
mul1.mdf(x, (a[x] * y % mod - a[x] * w[x] % mod + mod) % mod, 1);
mul2.mdf(x, (x * y % mod - x * w[x] % mod + mod) % mod, 1);
w[x] = y;
} else {
long long tot = sum.ask(x, y, 0);
long long l = x, r = y, p, mid;
while (l <= r) {
mid = l + r >> 1;
long long L = sum.ask(x, mid, 0);
if (L >= tot - L)
p = mid, r = mid - 1;
else
l = mid + 1;
}
long long L = 0, R = 0;
L = (a[p] - p) * sum.ask(x, p - 1, 1) % mod - mul1.ask(x, p - 1, 1) +
mul2.ask(x, p - 1, 1);
L = (L % mod + mod) % mod;
R = mul1.ask(p + 1, y, 1) - (a[p] - p) * sum.ask(p + 1, y, 1) % mod -
mul2.ask(p + 1, y, 1);
R = (R % mod + mod) % mod;
cout << (L + R) % mod << "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200010, P = 1000000007;
int n, q, a[maxn], b[maxn], w[maxn];
__int128 c1[maxn], c2[maxn];
void add(__int128 *c, int p, __int128 v) {
for (; p <= n; p += p & -p) c[p] += v;
}
__int128 sum(__int128 *c, int p) {
__int128 s = 0;
for (; p; p -= p & -p) s += c[p];
return s;
}
int main() {
scanf("%d %d", &n, &q);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]), b[i] = i - a[i];
}
for (int i = 1; i <= n; i++) {
scanf("%d", &w[i]);
add(c1, i, w[i]), add(c2, i, 1LL * b[i] * w[i]);
}
while (q--) {
int x, y;
scanf("%d %d", &x, &y);
if (x < 0) {
x *= -1, add(c1, x, -w[x]), add(c2, x, -1LL * b[x] * w[x]);
w[x] = y;
add(c1, x, w[x]), add(c2, x, 1LL * b[x] * w[x]);
} else {
auto chk = [&](int st) {
int l = x, r = y, p = x - 1;
while (l <= r) {
int mid = (l + r) >> 1;
if (a[mid] <= st + mid - x)
l = (p = mid) + 1;
else
r = mid - 1;
}
__int128 s = (st - x) * (sum(c1, p) - sum(c1, x - 1)) + sum(c2, p) -
sum(c2, x - 1);
s -= (st - x) * (sum(c1, y) - sum(c1, p)) + sum(c2, y) - sum(c2, p);
return s;
};
int l0 = 1, r0 = 1000000000, ans;
while (l0 <= r0) {
int mid = (l0 + r0) >> 1;
auto t1 = chk(mid), t2 = chk(mid + 1);
if (t1 <= t2)
ans = t1 % P, r0 = mid - 1;
else
l0 = mid + 1;
}
printf("%d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, q;
const int N = 2e5 + 10;
const int Mod = 1e9 + 7;
void inc(int &x, int y) {
x += y;
x = x >= Mod ? x - Mod : x;
}
struct Binary_Indexed_Tree {
long long c[N];
int lowbit(int x) { return x & (-x); }
void add(int x, int w) {
while (x <= n) {
c[x] += w;
x += lowbit(x);
}
}
long long sum(int x) {
long long ret = 0;
while (x) {
ret += c[x];
x -= lowbit(x);
}
return ret;
}
} T, S;
int w[N], a[N];
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) scanf("%d", &w[i]);
for (int i = 1; i <= n; i++)
T.add(i, w[i]), S.add(i, 1ll * (a[i] - i) * w[i] % Mod);
while (q--) {
int x, y;
scanf("%d%d", &x, &y);
if (x < 0) {
x = -x;
T.add(x, y - w[x]);
S.add(x, 1ll * (a[x] - x) * (y - w[x] + Mod) % Mod);
w[x] = y;
} else {
long long lw = T.sum(x - 1), sumw = T.sum(y) - lw;
int l = x, r = y;
while (l < r) {
int mid = (l + r) / 2;
if ((T.sum(mid) - lw) * 2 >= sumw)
r = mid;
else
l = mid + 1;
}
long long ans = S.sum(x - 1) + S.sum(y) - 2ll * S.sum(l);
ans = ans + (2ll * T.sum(l) - T.sum(x - 1) - T.sum(y)) % Mod * (a[l] - l);
ans = (ans % Mod + Mod) % Mod;
printf("%I64d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T& x) {
char c = getchar();
bool f = false;
for (x = 0; !isdigit(c); c = getchar()) {
if (c == '-') {
f = true;
}
}
for (; isdigit(c); c = getchar()) {
x = x * 10 + c - '0';
}
if (f) {
x = -x;
}
}
template <typename T, typename... U>
inline void read(T& x, U&... y) {
read(x), read(y...);
}
const int N = 2e5 + 10, P = 1e9 + 7;
int n, Q;
int A[N], W[N];
long long X[N], S[N], G[N];
void Modify(int pos, int val) {
while (pos <= n) {
X[pos] += val;
pos += (pos & -pos);
}
}
long long Sum(int pos) {
long long res = 0;
while (pos) {
res += X[pos];
pos -= (pos & -pos);
}
return res;
}
void ADD(int pos, int val) {
while (pos <= n) {
S[pos] += val;
if (S[pos] >= P) S[pos] -= P;
pos += (pos & -pos);
}
}
long long Get(int pos) {
long long res = 0;
while (pos) {
res += S[pos];
if (res >= P) res -= P;
pos -= (pos & -pos);
}
return res;
}
void Update(int pos, int val) {
while (pos <= n) {
G[pos] += val;
if (S[pos] >= P) G[pos] -= P;
pos += (pos & -pos);
}
}
long long Calc(int pos) {
long long res = 0;
while (pos) {
res += G[pos];
if (res >= P) res -= P;
pos -= (pos & -pos);
}
return res;
}
int Find(int l, int r, long long x, long long Sl) {
if (l == r) return l;
int mid = l + r >> 1;
long long t = Sum(mid) - Sl;
if (t >= x - t) return Find(l, mid, x, Sl);
return Find(mid + 1, r, x, Sl);
}
int Query(int l, int r) {
if (l == r) return 0;
int p = Find(l, r, Sum(r) - Sum(l - 1), Sum(l - 1));
long long SUM = (Sum(p) - Sum(l - 1)) % P, S1 = 1ll * A[p] * SUM % P,
S2 = 1ll * p * SUM % P, S3 = (Calc(p) - Calc(l - 1)) % P,
S4 = (Get(p) - Get(l - 1)) % P;
long long t1 = ((S1 - S2 + S3 - S4) % P + P) % P;
SUM = (Sum(r) - Sum(p)) % P, S1 = (Get(r) - Get(p)) % P,
S2 = 1ll * A[p] * SUM % P, S3 = (Calc(r) - Calc(p)) % P,
S4 = 1ll * p * SUM % P;
long long t2 = ((S1 - S2 - S3 + S4) % P + P) % P;
return (t1 + t2) % P;
}
int main() {
read(n, Q);
for (int i = 1; i <= n; ++i) read(A[i]);
for (int i = 1; i <= n; ++i)
read(W[i]), Modify(i, W[i]), ADD(i, 1ll * W[i] * A[i] % P),
Update(i, 1ll * i * W[i] % P);
while (Q--) {
int l, r;
read(l, r);
if (l < 0)
Modify(-l, r - W[-l]), ADD(-l, (1ll * (r - W[-l]) * A[-l] % P + P) % P),
Update(-l, (1ll * (r - W[-l]) * (-l) % P + P) % P), W[-l] = r;
else
printf("%d\n", Query(l, r));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 2e5 + 10;
const long long MOD = 1e9 + 7;
int n, Q;
long long A[M], W[M];
struct bit_tree {
long long bit[M], Mod;
void init(long long mod) { Mod = mod; }
void Add(long long &a, long long b) {
a += b;
if (Mod != -1) {
a %= Mod;
if (a < 0) a += Mod;
}
}
void add(int a, long long v) {
if (!a) a = 1;
for (; a <= n; a += ((a) & (-(a)))) Add(bit[a], v);
}
long long query(int a) {
long long res = 0;
for (; a > 0; a -= ((a) & (-(a)))) Add(res, bit[a]);
return res;
}
} b1, b2;
void change_pos(long long p, long long v) {
long long res = v - W[p];
b1.add(p, res);
b2.add(p, A[p] * res % MOD);
W[p] += res;
}
void solve_area(long long le, long long ri) {
long long sum = b1.query(le - 1);
sum += ((b1.query(ri) - sum + 1) >> 1);
int l = le, r = ri, mid;
while (l < r) {
mid = l + r >> 1;
if (b1.query(mid) >= sum)
r = mid;
else
l = mid + 1;
}
long long all = b2.query(ri) + b2.query(le - 1) - (2ll * b2.query(l) % MOD);
all %= MOD;
if (all < 0) all += MOD;
sum = b1.query(l);
long long bef = (sum - b1.query(le - 1)) % MOD + sum - b1.query(ri);
bef %= MOD;
if (bef < 0) bef += MOD;
printf("%I64d\n", (all + bef * A[l] % MOD) % MOD);
}
long long a, b;
int main() {
b1.init(-1);
b2.init(MOD);
scanf("%d%d", &n, &Q);
for (int i = 1; i <= n; i++) {
scanf("%I64d", &A[i]);
A[i] -= i;
}
for (int i = 1; i <= n; i++) scanf("%I64d", &W[i]);
for (int i = 1; i <= n; i++) b1.add(i, W[i]), b2.add(i, A[i] * W[i] % MOD);
while (Q--) {
scanf("%I64d%I64d", &a, &b);
if (a < 0)
change_pos(-a, b);
else
solve_area(a, b);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int inf = 1e9;
int a[200005], w[200005];
struct ft1 {
long long ft[200005];
void update(int i, long long v) {
for (; i <= 200000; i += (i & -i)) ft[i] = (ft[i] + v + mod) % mod;
}
long long query(int i) {
long long res = 0;
for (; i > 0; i -= (i & -i)) res = (res + ft[i]) % mod;
return res;
}
} ft[2];
struct ft2 {
long long ft[200005];
void update(int i, long long v) {
for (; i <= 200000; i += (i & -i)) ft[i] += v;
}
long long query(int i) {
long long res = 0;
for (; i > 0; i -= (i & -i)) res += ft[i];
return res;
}
} ft2;
int main() {
int n, q;
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), a[i] -= i;
for (int i = 1; i <= n; i++) scanf("%d", &w[i]);
for (int i = 1; i <= n; i++) {
ft[0].update(i, a[i] * 1ll * w[i] % mod);
ft[1].update(i, (inf - a[i]) * 1ll * w[i] % mod);
ft2.update(i, w[i]);
}
for (int i = 1; i <= q; i++) {
int l, r;
scanf("%d%d", &l, &r);
if (l < 0) {
l = -l;
ft[0].update(l, -a[l] * 1ll * w[l] % mod);
ft[1].update(l, -(inf - a[l]) * 1ll * w[l] % mod);
ft2.update(l, -w[l]);
w[l] = r;
ft[0].update(l, a[l] * 1ll * w[l] % mod);
ft[1].update(l, (inf - a[l]) * 1ll * w[l] % mod);
ft2.update(l, w[l]);
} else {
long long sum = ft2.query(r) - ft2.query(l - 1);
int lo = l, hi = r, res;
while (lo <= hi) {
int mid = (lo + hi) / 2;
if ((ft2.query(mid) - ft2.query(l - 1)) * 2 >= sum)
res = mid, hi = mid - 1;
else
lo = mid + 1;
}
long long ans = 0;
ans = (ans + (ft[1].query(res) - ft[1].query(l - 1) + mod)) % mod;
ans = (ans + (ft[0].query(r) - ft[0].query(res) + mod)) % mod;
ans = (ans -
(ft2.query(res) - ft2.query(l - 1)) % mod * 1ll * (inf - a[res]) %
mod +
mod) %
mod;
ans = (ans - (ft2.query(r) - ft2.query(res)) % mod * 1ll * a[res] % mod +
mod) %
mod;
printf("%lld\n", ans);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long M = 1000000007;
long long b[262155], c[262155], d[262155], a[262155], s[262155], n, q, l, r, lf,
rt;
long long sl, sr, sm, ans;
void add_(long long &x, long long y) {
x += y;
if (x >= M) x -= M;
if (x < 0) x += M;
}
void add1(long long x, long long y) {
while (x < 262155) c[x] += y, x += x & (-x);
}
void add2(long long x, long long y) {
while (x < 262155) add_(d[x], y), x += x & (-x);
}
long long qry1(long long x) {
long long res = 0;
while (x) res += c[x], x -= x & (-x);
return res;
}
long long qry2(long long x) {
long long res = 0;
while (x) res += d[x], x -= x & (-x);
return res % M;
}
int main() {
cin >> n >> q;
for (int i = 1; i <= n; i++) {
scanf("%I64d", &a[i]);
a[i] += n - i;
}
for (int i = 1; i <= n; i++) {
scanf("%I64d", &b[i]);
add1(i, b[i]);
add2(i, a[i] * b[i] % M);
}
while (q--) {
scanf("%I64d%I64d", &l, &r);
if (l < 0) {
l = -l;
add1(l, -b[l] + r);
add2(l, a[l] * (r - b[l]) % M);
b[l] = r;
} else {
l--;
lf = l;
rt = r;
sl = qry1(l);
sr = qry1(r);
while (rt - lf > 1) {
int mid = (lf + rt) / 2;
sm = qry1(mid);
if (sm - sl >= sr - sm)
rt = mid;
else
lf = mid;
}
ans = qry2(r) - qry2(lf) - (qry1(r) - qry1(lf)) % M * a[rt] % M;
ans += (qry1(lf) - qry1(l)) % M * a[rt] % M - qry2(lf) + qry2(l);
printf("%I64d\n", (ans % M + M) % M);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Node {
int size, xL, xR;
long long sum, costTL, costTR;
Node() { size = xL = xR = sum = costTL = costTR = 0; }
Node(long long x, long long w) {
xL = xR = x;
size = 1;
sum = w;
costTL = costTR = 0;
}
void updateN(long long w) { sum = w; }
};
const int MOD = 1e9 + 7;
Node join(Node p1, Node p2) {
Node r;
r.xL = p1.xL, r.xR = p2.xR;
r.sum = p1.sum + p2.sum;
r.size = p1.size + p2.size;
r.costTL = p1.costTL + p2.costTL +
((p2.xL - p1.xL - p1.size) % MOD) * (p2.sum % MOD);
r.costTL %= MOD;
r.costTR = p1.costTR + p2.costTR +
((p2.xR - p1.xR - p2.size) % MOD) * (p1.sum % MOD);
r.costTR %= MOD;
return r;
}
int N;
int A[200010], W[200010];
Node st[800010];
void create(int n = 1, int l = 0, int r = N) {
if (l == r)
st[n] = Node(A[l], W[l]);
else {
int m = (l + r) / 2;
create(2 * n, l, m);
create(2 * n + 1, m + 1, r);
st[n] = join(st[2 * n], st[2 * n + 1]);
}
}
Node query(int x, int y, int n = 1, int l = 0, int r = N) {
if (x <= l && r <= y)
return st[n];
else {
int m = (l + r) / 2;
if (y <= m) return query(x, y, 2 * n, l, m);
if (x > m) return query(x, y, 2 * n + 1, m + 1, r);
return join(query(x, y, 2 * n, l, m), query(x, y, 2 * n + 1, m + 1, r));
}
}
void update(int x, int v, int n = 1, int l = 0, int r = N) {
if (l == r)
st[n].updateN(v);
else {
int m = (l + r) / 2;
if (x <= m)
update(x, v, 2 * n, l, m);
else
update(x, v, 2 * n + 1, m + 1, r);
st[n] = join(st[2 * n], st[2 * n + 1]);
}
}
int getMid(long long v, int n = 1, int l = 0, int r = N) {
if (l == r) return l;
int m = (l + r) / 2;
if (st[2 * n].sum < v) {
v -= st[2 * n].sum;
return getMid(v, 2 * n + 1, m + 1, r);
}
return getMid(v, 2 * n, l, m);
}
int main() {
int n, q;
scanf("%d%d", &n, &q);
for (int i = 0; i < n; i++) scanf("%d", &A[i]);
for (int i = 0; i < n; i++) scanf("%d", &W[i]);
N = n - 1;
create();
while (q--) {
int x, y;
scanf("%d%d", &x, &y);
if (x < 0)
update(-x - 1, y);
else {
x--, y--;
if (x == y) {
puts("0");
continue;
}
long long ms = query(x, y).sum / 2;
if (x) ms += query(0, x - 1).sum;
int m = getMid(ms);
if (m >= y) m--;
Node t1 = query(x, m), t2 = query(m + 1, y);
long long ans = t1.costTR + t2.costTL;
ans += ((t2.xL - t1.xR - 1) % MOD) * (min(t1.sum, t2.sum) % MOD);
printf("%I64d\n", ans % MOD);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
struct SegtreeMOD {
vector<long long> t;
int n, h;
SegtreeMOD() {}
SegtreeMOD(int sz) {
h = 32 - __builtin_clz(sz);
n = 1 << h;
t = vector<long long>(n << 1);
}
void assign(int x, long long v) {
x += n;
t[x] = v % MOD;
for (x /= 2; x; x /= 2) {
t[x] = (t[x << 1] + t[x << 1 | 1]) % MOD;
}
}
long long query(int l, int r) {
long long ans = 0;
for (l += n, r += n; l < r; l /= 2, r /= 2) {
if (l % 2) {
ans += t[l++];
}
if (r % 2) {
ans += t[--r];
}
}
return ans % MOD;
}
};
struct Segtree {
vector<long long> t;
int n, h;
Segtree() {}
Segtree(int sz) {
h = 32 - __builtin_clz(sz);
n = 1 << h;
t = vector<long long>(n << 1);
}
void assign(int x, long long v) {
x += n;
t[x] = v;
for (x /= 2; x; x /= 2) {
t[x] = t[x << 1] + t[x << 1 | 1];
}
}
long long query(int l, int r) {
long long ans = 0;
for (l += n, r += n; l < r; l /= 2, r /= 2) {
if (l % 2) {
ans += t[l++];
}
if (r % 2) {
ans += t[--r];
}
}
return ans;
}
pair<long long, int> bs(int l, int r, long long goal, int x, int lv, int rv) {
if (rv <= l || r <= lv) {
return {0, -1};
}
if (l <= lv && rv <= r) {
if (t[x] < goal) {
return {t[x], -1};
}
if (rv - lv == 1) {
return {t[x], lv};
}
}
int mv = (lv + rv) / 2;
auto res1 = bs(l, r, goal, x * 2, lv, mv);
if (res1.second != -1) {
return res1;
}
auto res2 = bs(l, r, goal - res1.first, x * 2 + 1, mv, rv);
return {res2.first + res1.first, res2.second};
}
int bs(int l, int r, long long goal) {
return bs(l, r, goal, 1, 0, n).second;
}
};
Segtree weights;
SegtreeMOD wx;
int n, q;
long long a[200200];
long long query(int l, int r) {
long long wtot = weights.query(l, r + 1);
int med = weights.bs(l, r + 1, (wtot + 1) / 2);
long long ans = ((weights.query(l, med) * 2 - wtot) % MOD) * a[med] -
wx.query(l, med) + wx.query(med, r + 1);
ans = (ans % MOD + MOD) % MOD;
return ans % MOD;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
cin >> n >> q;
weights = Segtree(n + 1);
wx = SegtreeMOD(n + 1);
for (int i = 1; i <= n; ++i) {
cin >> a[i];
a[i] -= i;
}
for (int i = 1; i <= n; ++i) {
long long w;
cin >> w;
weights.assign(i, w);
wx.assign(i, w * a[i]);
}
while (q--) {
int _a, b;
cin >> _a >> b;
if (_a > 0) {
cout << query(_a, b) << "\n";
} else {
int id = -_a, nw = b;
weights.assign(id, nw);
wx.assign(id, nw * a[id]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, q, x[200005], at;
long long y[19][200005], sum, z[19][200005];
int ta, tb;
long long f1(int a, int b, int c, int d) {
if (((1 << (c)) * (d)) == a && ((1 << (c)) * (d + 1)) == b) return y[c][d];
c--;
d = d * 2 + 1;
if (b <= ((1 << (c)) * (d))) return f1(a, b, c, d - 1);
if (a >= ((1 << (c)) * (d))) return f1(a, b, c, d);
return f1(a, ((1 << (c)) * (d)), c, d - 1) + f1(((1 << (c)) * (d)), b, c, d);
}
void f2(int c, int d) {
if (c == 0) {
at = d;
return;
}
c--;
d = d * 2 + 1;
if (sum < y[c][d - 1])
f2(c, d - 1);
else {
sum -= y[c][d - 1];
f2(c, d);
}
}
long long f3(int a, int b, int c, int d) {
if (((1 << (c)) * (d)) == a && ((1 << (c)) * (d + 1)) == b) return z[c][d];
c--;
d = d * 2 + 1;
if (b <= ((1 << (c)) * (d))) return f3(a, b, c, d - 1);
if (a >= ((1 << (c)) * (d))) return f3(a, b, c, d);
return f3(a, ((1 << (c)) * (d)), c, d - 1) + f3(((1 << (c)) * (d)), b, c, d);
}
int main() {
scanf("%d%d", &n, &q);
for (int i = 0; i < n; i++) {
scanf("%d", x + i);
x[i] -= i;
}
for (int i = 0; i < n; i++) {
scanf("%lld", y[0] + i);
z[0][i] = y[0][i] * x[i] % 1000000007;
}
for (int i = 1; i < 19; i++)
for (int j = 0; ((1 << (i)) * (j)) < n; j++) {
y[i][j] = y[i - 1][j * 2] + y[i - 1][j * 2 + 1];
z[i][j] = z[i - 1][j * 2] + z[i - 1][j * 2 + 1];
}
while (q--) {
scanf("%d%d", &ta, &tb);
if (ta < 0) {
ta = -ta - 1;
y[0][ta] = tb;
z[0][ta] = y[0][ta] * x[ta] % 1000000007;
for (int i = 1; i < 19; i++) {
ta >>= 1;
y[i][ta] = y[i - 1][ta * 2] + y[i - 1][ta * 2 + 1];
z[i][ta] = z[i - 1][ta * 2] + z[i - 1][ta * 2 + 1];
}
} else {
ta--;
sum = f1(ta, tb, 18, 0) / 2;
if (ta) sum += f1(0, ta, 18, 0);
f2(18, 0);
sum = 0;
if (ta < at)
sum = (sum + f1(ta, at, 18, 0) % 1000000007 * x[at] % 1000000007 +
1000000007 - f3(ta, at, 18, 0) % 1000000007) %
1000000007;
if (at < tb)
sum = (sum + f3(at, tb, 18, 0) % 1000000007 + 1000000007 -
f1(at, tb, 18, 0) % 1000000007 * x[at] % 1000000007) %
1000000007;
printf("%lld\n", sum);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mo = 1e9 + 7;
const long long maxn = 2e5 + 100;
long long n, Q, x, y, a[maxn], w[maxn], F[maxn], G[maxn], H[maxn], l, r, mid,
pos, lim, ans;
long long read() {
long long tot = 0, fh = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') fh = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
tot = tot * 10 + c - '0';
c = getchar();
}
return tot * fh;
}
int lowbit(int x) { return x & -x; }
void modifyF(long long x, long long y) {
for (int i = x; i <= n; i += lowbit(i)) F[i] += y;
}
long long queryF(long long x) {
long long res = 0;
for (int i = x; i > 0; i -= lowbit(i)) res += F[i];
return res;
}
void modifyG(long long x, long long y) {
for (int i = x; i <= n; i += lowbit(i)) G[i] = (G[i] + y) % mo;
}
long long queryG(long long x) {
long long res = 0;
for (int i = x; i > 0; i -= lowbit(i)) res = (res + G[i]) % mo;
return res;
}
void modifyH(long long x, long long y) {
for (int i = x; i <= n; i += lowbit(i)) H[i] = (H[i] + y) % mo;
}
long long queryH(long long x) {
long long res = 0;
for (int i = x; i > 0; i -= lowbit(i)) res = (res + H[i]) % mo;
return res;
}
int main() {
n = read();
Q = read();
for (int i = 1; i <= n; i++) a[i] = read();
for (int i = 1; i <= n; i++) {
w[i] = read();
modifyF(i, w[i]);
modifyG(i, (a[i] * w[i]) % mo);
modifyH(i, (i * w[i]) % mo);
}
while (Q) {
x = read();
y = read();
if (x < 0) {
x = -x;
modifyF(x, y - w[x]);
modifyG(x, a[x] * (y - w[x]) % mo);
modifyH(x, x * (y - w[x]) % mo);
w[x] = y;
} else {
l = x;
r = y;
lim = (queryF(y) - queryF(x - 1)) / 2;
while (l + 1 < r) {
mid = (l + r) / 2;
if (queryF(mid - 1) - queryF(x - 1) <= lim)
l = mid;
else
r = mid - 1;
}
if (l + 1 <= y && queryF(l + 1 - 1) - queryF(x - 1) <= lim) l++;
pos = l;
ans = 0;
ans += ((queryF(pos) - queryF(x - 1)) % mo * (a[pos] - pos) % mo -
(queryG(pos) - queryG(x - 1)) % mo +
(queryH(pos) - queryH(x - 1)) % mo + mo * 4ll) %
mo;
ans += ((queryF(y) - queryF(pos - 1)) % mo * (pos - a[pos]) % mo +
(queryG(y) - queryG(pos - 1)) % mo -
(queryH(y) - queryH(pos - 1)) % mo + mo * 4ll) %
mo;
ans %= mo;
cout << ans << "\n";
}
Q--;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 5;
const long long mod = 1e9 + 7;
long long n, q;
long long a[N], w[N];
template <typename T>
inline void chkmax(T &x, T y) {
x = max(x, y);
}
template <typename T>
inline void chkmin(T &x, T y) {
x = min(x, y);
}
template <typename T>
inline void read(T &x) {
T f = 1;
x = 0;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -f;
for (; isdigit(c); c = getchar()) x = (x << 3) + (x << 1) + c - '0';
x *= f;
}
inline void inc(long long &x, long long y) {
x = x + y < mod ? x + y : x + y - mod;
}
inline void dec(long long &x, long long y) {
x = x - y >= 0 ? x - y : x - y + mod;
}
struct B1 {
long long c[N];
inline long long lowbit(long long x) { return x & (-x); }
inline void mdf(long long x, long long val) {
for (long long i = x; i <= n; i += lowbit(i)) c[i] += val;
}
inline long long qry(long long x) {
long long ret = 0;
for (long long i = x; i >= 1; i -= lowbit(i)) ret += c[i];
return ret;
}
inline long long qry(long long l, long long r) {
if (l > r) return 0;
return qry(r) - qry(l - 1);
}
} BitSum;
struct B2 {
long long c[N];
inline long long lowbit(long long x) { return x & (-x); }
inline void mdf(long long x, long long val) {
val = (val % mod + mod) % mod;
for (long long i = x; i <= n; i += lowbit(i)) inc(c[i], val);
}
inline long long qry(long long x) {
long long ret = 0;
for (long long i = x; i >= 1; i -= lowbit(i)) inc(ret, c[i]);
return ret;
}
inline long long qry(long long l, long long r) {
if (l > r) return 0;
long long ret = qry(r);
dec(ret, qry(l - 1));
return ret;
}
} BitMul;
inline long long getPos(long long x, long long y) {
long long ln = x, rn = y, mid, res = 0;
for (; ln <= rn;) {
mid = (ln + rn) / 2;
if (BitSum.qry(x, mid) >= BitSum.qry(mid + 1, y))
res = mid, rn = mid - 1;
else
ln = mid + 1;
}
return res;
}
inline void solve(long long x, long long y) {
if (x == y) {
puts("0");
return;
}
long long pos = getPos(x, y);
long long res = 0LL;
res = (-BitMul.qry(x, pos) +
(BitSum.qry(x, pos) % mod) * abs(a[pos] - pos) % mod + mod) %
mod;
res = (res - (BitSum.qry(pos, y)) % mod * abs(a[pos] - pos) % mod +
BitMul.qry(pos, y) + mod) %
mod;
printf("%lld\n", (res % mod + mod) % mod);
}
signed main() {
read(n), read(q);
for (long long i = 1; i <= n; ++i) read(a[i]);
for (long long i = 1; i <= n; ++i) {
read(w[i]);
BitMul.mdf(i, 1LL * w[i] * (a[i] - i));
BitSum.mdf(i, w[i]);
}
while (q--) {
long long x, y;
read(x), read(y);
if (x < 0) {
x = -x;
BitSum.mdf(x, -w[x]);
BitMul.mdf(x, -1LL * w[x] * (a[x] - x));
w[x] = 1LL * y;
BitSum.mdf(x, w[x]);
BitMul.mdf(x, 1LL * w[x] * (a[x] - x));
} else
solve(x, y);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using lli = long long;
using lld = long double;
using ulli = unsigned long long int;
using pll = pair<lli, lli>;
using ttt = pair<lli, pll>;
using vttt = vector<ttt>;
using vll = vector<pll>;
using vl = vector<lli>;
using vi = vector<int>;
using vvi = vector<vector<int>>;
using cd = complex<lld>;
const double PI = acos(-1);
lli pref[200010], lcol[200010], rcol[200010];
lli arr[200010], wrr[200010];
void add(lli tre[], int x, lli val, bool fl) {
for (x += 2; x < 200010; x += (x & -x)) {
tre[x] += val;
if (fl) tre[x] %= 1000000007;
}
}
lli get(lli tre[], int x, bool fl) {
lli res = 0;
for (x += 2; x > 0; x -= (x & -x)) res += tre[x];
if (fl) res %= 1000000007;
return res;
}
lli get(lli tre[], int l, int r, bool fl) {
if (!fl)
return get(tre, r, fl) - get(tre, l - 1, fl);
else
return (get(tre, r, fl) - get(tre, l - 1, fl) + 1000000007) % 1000000007;
}
lli fin(int pos, int l, int r) {
lli move = (get(rcol, pos + 1, r, 1) - get(rcol, l, pos, 1)) % 1000000007;
lli del1 =
((arr[pos] - pos) * (get(pref, pos + 1, r, 0) % 1000000007)) % 1000000007;
lli add1 =
((arr[pos] - pos) * (get(pref, l, pos, 0) % 1000000007)) % 1000000007;
return ((move - del1 + add1) % 1000000007 + 1000000007) % 1000000007;
}
int tejas_919(int kkkk) {
lli n, m, k, q, u, v, temp = 0, ans = 0;
cin >> n >> q;
for (int i = 0; i < n; i++) cin >> arr[i];
for (int i = 0; i < n; i++) {
cin >> wrr[i];
add(pref, i, wrr[i], 0);
}
for (int i = 0; i < n; i++) add(rcol, i, wrr[i] * (arr[i] - i), 1);
for (int i = 1; i < q + 1; i++) {
cin >> u >> v;
if (u < 0) {
u = -u - 1;
temp = v - wrr[u];
add(pref, u, temp, 0);
add(rcol, u, temp * (arr[u] - u), 1);
wrr[u] = v;
} else {
if (u == v) {
cout << 0 << '\n';
continue;
} else {
u--;
v--;
lli f = get(pref, u, u, 0);
lli s = get(pref, u + 1, v, 0);
if (f >= s) {
cout << fin(u, u, v) << '\n';
continue;
}
int l = u, r = v;
f += s;
f /= 2;
while (r - l > 1) {
int mid = (l + r) / 2;
if (get(pref, u, mid, 0) <= f)
l = mid;
else
r = mid;
}
cout << fin(l + 1, u, v) << '\n';
}
}
}
return 0;
}
signed main() {
if (!0) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
cout << fixed << setprecision(10);
int t = 1;
for (int i = 0; i < t; i++) {
tejas_919(i + 1);
}
{};
if (0) system("pause");
}
|
#include <bits/stdc++.h>
using namespace std;
int n, q;
const int maxn = 2e5 + 5;
const long long mod = 1e9 + 7;
long long a[maxn], w[maxn];
long long lowbit(long long x) { return x & -x; }
void add(long long t[], long long x, long long d, int typ) {
for (; x < maxn; x += lowbit(x)) {
t[x] += d;
if (typ) t[x] = (t[x] + mod) % mod;
}
}
long long ask(long long t[], long long x, int typ) {
long long ret = 0;
for (; x; x -= lowbit(x)) {
ret += t[x];
if (typ) ret %= mod;
}
return ret;
}
long long sum[maxn];
long long t[maxn];
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; i++) {
scanf("%lld", a + i);
a[i] -= i;
}
for (int i = 1; i <= n; i++) {
scanf("%lld", w + i);
add(t, i, w[i], 0);
add(sum, i, w[i] * a[i], 1);
}
while (q--) {
long long l, r;
scanf("%lld%lld", &l, &r);
if (l < 0) {
add(t, -l, r - w[-l], 0);
add(sum, -l, a[-l] * (r - w[-l] + mod), 1);
w[-l] = r;
} else {
long long L = l, R = r;
long long all = ask(t, r, 0) - ask(t, l - 1, 0);
while (L < R) {
long long mid = (L + R) / 2;
if (ask(t, mid, 0) - ask(t, l - 1, 0) > all / 2)
R = mid;
else
L = mid + 1;
}
long long k = R;
long long ans = a[k] * (ask(t, k - 1, 1) - ask(t, l - 1, 1) + mod) % mod;
ans -= (ask(sum, k - 1, 1) - ask(sum, l - 1, 1) + mod) % mod;
ans = (ans + mod) % mod;
(ans += (ask(sum, r, 1) - ask(sum, k, 1) + mod)) %= mod;
ans -= a[k] * (ask(t, r, 1) - ask(t, k, 1) + mod) % mod;
ans = (ans + mod) % mod;
printf("%lld\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int _inf = 0xc0c0c0c0;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const long long _INF = 0xc0c0c0c0c0c0c0c0;
const long long mod = (int)1e9 + 7;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long ksm(long long a, long long b, long long mod) {
int ans = 1;
while (b) {
if (b & 1) ans = (ans * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return ans;
}
long long inv2(long long a, long long mod) { return ksm(a, mod - 2, mod); }
void exgcd(long long a, long long b, long long &x, long long &y, long long &d) {
if (!b) {
d = a;
x = 1;
y = 0;
} else {
exgcd(b, a % b, y, x, d);
y -= x * (a / b);
}
}
const int MAX_N = 200025;
long long s[MAX_N << 2], sum[MAX_N << 2], arr[MAX_N], b[MAX_N], w[MAX_N];
int n;
void up(int rt) {
sum[rt] = sum[rt << 1] + sum[rt << 1 | 1];
s[rt] = s[rt << 1] + s[rt << 1 | 1];
}
void build(int rt, int l, int r) {
sum[rt] = s[rt] = 0;
if (l == r) {
sum[rt] = w[l];
s[rt] = b[l] * w[l] % 1000000007;
return;
}
build(rt << 1, l, ((l + r) >> 1));
build(rt << 1 | 1, ((l + r) >> 1) + 1, r);
up(rt);
}
void update(int rt, int l, int r, int x, int v) {
if (l == r) {
sum[rt] = v;
s[rt] = 1ll * b[x] * v % 1000000007;
return;
}
if (x <= ((l + r) >> 1))
update(rt << 1, l, ((l + r) >> 1), x, v);
else
update(rt << 1 | 1, ((l + r) >> 1) + 1, r, x, v);
up(rt);
}
long long query(int rt, int l, int r, int x, int y) {
if (x > r || y < l) return 0;
if (x <= l && r <= y) {
return sum[rt];
}
if (x > ((l + r) >> 1))
return query(rt << 1 | 1, ((l + r) >> 1) + 1, r, x, y);
else if (y <= ((l + r) >> 1))
return query(rt << 1, l, ((l + r) >> 1), x, y);
else
return query(rt << 1, l, ((l + r) >> 1), x, y) +
query(rt << 1 | 1, ((l + r) >> 1) + 1, r, x, y);
}
long long ask(int rt, int l, int r, int x, int y) {
if (x > r || y < l) return 0;
if (x <= l && r <= y) {
return s[rt];
}
if (x > ((l + r) >> 1))
return ask(rt << 1 | 1, ((l + r) >> 1) + 1, r, x, y);
else if (y <= ((l + r) >> 1))
return ask(rt << 1, l, ((l + r) >> 1), x, y);
else
return (ask(rt << 1, l, ((l + r) >> 1), x, y) % 1000000007 +
ask(rt << 1 | 1, ((l + r) >> 1) + 1, r, x, y) % 1000000007) %
1000000007;
}
long long solve(int x, int y) {
int l = x, r = y, pos = l;
while (l <= r) {
long long tmp = query(1, 1, n, x, ((l + r) >> 1)),
tmp_ = query(1, 1, n, ((l + r) >> 1) + 1, y);
if (tmp >= tmp_)
pos = ((l + r) >> 1), r = ((l + r) >> 1) - 1;
else
l = ((l + r) >> 1) + 1;
}
long long tmp = (query(1, 1, n, x, pos - 1) % 1000000007 *
((arr[pos] - pos + 1000000007) % 1000000007) -
ask(1, 1, n, x, pos - 1) + 1000000007) %
1000000007;
long long tmp_ = (query(1, 1, n, pos + 1, y) % 1000000007 *
((pos - arr[pos] + 1000000007) % 1000000007) +
ask(1, 1, n, pos + 1, y) % 1000000007) %
1000000007;
return ((tmp + tmp_) % 1000000007);
}
int main() {
int Q, x;
long long y;
scanf("%d%d", &n, &Q);
for (int i = 1; i <= n; ++i) scanf("%lld", &arr[i]), b[i] = arr[i] - i;
for (int i = 1; i <= n; ++i) scanf("%lld", &w[i]);
build(1, 1, n);
while (Q--) {
scanf("%d%lld", &x, &y);
if (x < 0) {
update(1, 1, n, -x, y);
} else {
printf("%lld\n", solve(x, y));
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
void pre() {}
void solve() {}
const long long mod = 1e9 + 7;
struct FT {
vector<long long> s;
FT(int n) : s(n, 0) {}
void update(int pos, long long dif) {
for (; pos < (int)(s).size(); pos |= pos + 1) s[pos] += dif;
}
long long query(int pos) {
long long res = 0;
for (; pos > 0; pos &= pos - 1) res += s[pos - 1];
return res;
}
};
struct Node {
Node *l = 0, *r = 0;
int lo, hi;
long long madd = 0, val = 0, d;
Node(vector<int>& v, int lo, int hi) : lo(lo), hi(hi) {
if (lo + 1 < hi) {
int mid = lo + (hi - lo) / 2;
l = new Node(v, lo, mid);
r = new Node(v, mid, hi);
d = (l->d + r->d) % mod;
} else if (lo + 1 == hi)
d = v[lo];
}
long long query(int L, int R) {
if (R <= lo || hi <= L) return 0;
if (L <= lo && hi <= R) return val;
push();
return (l->query(L, R) + r->query(L, R)) % mod;
}
void add(int L, int R, long long x) {
if (R <= lo || hi <= L) return;
if (L <= lo && hi <= R) {
madd += x;
val += x % mod * d % mod;
madd %= mod;
val %= mod;
} else {
push(), l->add(L, R, x), r->add(L, R, x);
val = (l->val + r->val) % mod;
}
}
void push() {
if (madd)
l->add(lo, hi, madd), r->add(lo, hi, madd), madd = 0,
val = (l->val + r->val) % mod;
}
};
long long a[200009], w[200009];
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cin.exceptions(cin.failbit);
pre();
int n, q;
cin >> n >> q;
for (int i = 0; i < (n); ++i) cin >> a[i];
for (int i = 0; i < (n); ++i) cin >> w[i];
FT T1(n + 3), T2(n + 3), T3(n + 3), T4(n + 3);
long long sum = 0;
vector<int> d(n - 1);
for (int i = 0; i < (n - 1); ++i)
d[i] = a[i + 1] - a[i] - 1, T4.update(i, d[i]);
Node N1(d, 0, n - 1), N2(d, 0, n - 1);
for (int i = 0; i < (n - 1); ++i) {
sum += w[i];
sum %= mod;
T1.update(i, 1ll * (a[i + 1] - a[i] - 1) * sum % mod);
}
sum = 0;
for (int i = n - 2; i >= (0); --i) {
sum += w[i + 1];
sum %= mod;
T2.update(i, 1ll * (a[i + 1] - a[i] - 1) * sum % mod);
}
for (int i = 0; i < (n); ++i) {
T3.update(i, w[i]);
}
for (int i = 0; i < (q); ++i) {
int l, r;
cin >> l >> r;
if (l < 0) {
int ix = -l;
ix--;
long long dif = r - w[ix];
dif %= mod;
T3.update(ix, r - w[ix]);
w[ix] = r;
if (ix > 0) {
N2.add(0, ix, dif);
}
if (ix < n - 1) {
N1.add(ix, n, dif);
}
} else {
l--, r--;
int lo = l, hi = r;
while (lo < hi) {
int m = (lo + hi) / 2;
if (T3.query(r + 1) - T3.query(m + 1) >=
T3.query(m + 1) - T3.query(l)) {
lo = m + 1;
} else
hi = m;
}
long long ans =
T2.query(r) - T2.query(lo) + T1.query(lo) - T1.query(l) -
(T4.query(lo) - T4.query(l)) % mod * (T3.query(l) % mod) % mod -
(T4.query(r) - T4.query(lo)) % mod *
((T3.query(n) - T3.query(r + 1)) % mod) % mod;
ans += N1.query(l, lo) + N2.query(lo, r);
ans = (ans % mod + mod) % mod;
cout << ans << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using lint = long long;
const int MAXN = 200005;
const lint mod = 1e9 + 7;
int n, q;
int a[MAXN], w[MAXN];
struct bit {
lint tree[MAXN];
void add(int x, int v) {
while (x <= n) {
tree[x] += v;
x += x & -x;
}
}
lint query(int x) {
lint ret = 0;
while (x) {
ret += tree[x];
x -= x & -x;
}
return ret;
}
int kth(lint x) {
int pos = 0;
for (int i = 17; i >= 0; i--) {
if (pos + (1 << i) <= n && tree[pos + (1 << i)] < x) {
pos += (1 << i);
x -= tree[pos];
}
}
return pos + 1;
}
} bit, bit2;
void upd(int x, int y) {
bit.add(x, y - w[x]);
bit2.add(x, 1ll * a[x] * (y - w[x]) % mod);
w[x] = y;
}
lint query(int l, int r) {
lint lo = bit.query(l - 1);
lint hi = bit.query(r);
lint pos = (lo + hi + 1) / 2;
int v = bit.kth(pos);
lint mi = bit.query(v);
lint ret = 1ll * a[v] * ((mi - lo) % mod) - 1ll * a[v] * ((hi - mi) % mod);
ret -= bit2.query(v) - bit2.query(l - 1);
ret += bit2.query(r) - bit2.query(v);
ret %= mod;
ret += mod;
ret %= mod;
return ret;
}
int main() {
scanf("%d %d", &n, &q);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
a[i] += n - i;
}
for (int i = 1; i <= n; i++) {
scanf("%d", &w[i]);
bit.add(i, w[i]);
bit2.add(i, 1ll * w[i] * a[i] % mod);
}
while (q--) {
int x, y;
scanf("%d %d", &x, &y);
if (x < 0) {
upd(-x, y);
} else {
printf("%lld\n", query(x, y) % 1000000007);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000 * 1000 * 1000 + 7;
const long long nax = 200005;
struct fenwick_tree_1D {
long long n, log_n;
vector<long long> tree;
fenwick_tree_1D(long long _n)
: n(_n), log_n((long long)(log2(_n) + 1.0L)), tree(_n + 5) {}
void update(long long x, long long v) {
while (x <= n) {
tree[x] += v;
x += x & (-x);
}
}
long long prefix_sum(long long x) {
long long r = 0;
while (x) {
r += tree[x];
x -= x & (-x);
}
return r;
}
long long range_sum(long long l, long long r) {
if (l > r) return 0;
return prefix_sum(r) - prefix_sum(l - 1);
}
long long lower_bound(long long v) {
long long b = 0, s = 0;
for (long long i = log_n; i >= 0; i--)
if ((b | (1LL << i)) <= n && s + tree[b | (1LL << i)] < v)
s += tree[b | (1LL << i)], b |= (1LL << i);
return (b != n) ? (b + 1) : (1LL << 62);
}
};
fenwick_tree_1D weights(nax), prefix(nax), suffix(nax);
long long n, q;
long long a[nax] = {0}, w[nax] = {0}, p[nax] = {0}, s[nax] = {0};
void update(long long x, long long y) {
weights.update(x, y - w[x]);
w[x] = y;
prefix.update(x, ((a[x] + n - x + 1) * y - p[x] + mod) % mod);
p[x] = ((a[x] + n - x + 1) * y) % mod;
suffix.update(x, ((a[x] + x) * y - s[x] + mod) % mod);
s[x] = ((a[x] + x) * y) % mod;
}
long long query(long long l, long long r) {
long long totalWeight = weights.range_sum(l, r);
long long median = weights.prefix_sum(l - 1) + (totalWeight + 1) / 2;
long long medianPosition = weights.lower_bound(median);
long long leftWeight = weights.range_sum(l, medianPosition) % mod;
long long rightWeight = weights.range_sum(medianPosition + 1, r) % mod;
long long leftSum =
(((a[medianPosition] + n - medianPosition + 1) * leftWeight) % mod) -
(prefix.range_sum(l, medianPosition) % mod);
leftSum += mod;
leftSum %= mod;
long long rightSum =
(prefix.range_sum(medianPosition + 1, r) % mod) -
(((a[medianPosition] + n - medianPosition + 1) * rightWeight) % mod);
rightSum += mod;
rightSum %= mod;
return (leftSum + rightSum) % mod;
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> q;
for (long long i = 1; i <= n; i++) cin >> a[i];
for (long long i = 1; i <= n; i++) {
long long x;
cin >> x;
update(i, x);
}
while (q--) {
long long x, y;
cin >> x >> y;
if (x < 0)
update(-1 * x, y);
else
cout << query(x, y) << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const double eps = 1e-11;
template <class T>
inline void ckmin(T& a, T b) {
if (b < a) a = b;
}
template <class T>
inline void ckmax(T& a, T b) {
if (b > a) a = b;
}
template <class T>
inline T sqr(T x) {
return x * x;
}
const int maxn = (1 << 20);
const int MOD = 1000000007;
template <typename base_type, base_type _MOD>
class IntMod {
public:
static const int INVERSE_CACHE_SIZE = (1 << 20);
static base_type MOD;
static void set_mod(base_type new_mod) { MOD = new_mod; }
base_type n;
IntMod(long long d = 0) { n = (d >= 0 ? d % MOD : (d % MOD + MOD) % MOD); }
virtual ~IntMod() = default;
IntMod operator-() const { return Build(n == 0 ? 0 : MOD - n); }
IntMod& operator+=(IntMod a) {
n = (n >= MOD - a.n ? n - MOD + a.n : n + a.n);
return *this;
}
IntMod& operator-=(IntMod a) {
n = (n >= a.n) ? n - a.n : n - a.n + MOD;
return *this;
}
IntMod& operator*=(IntMod a) {
*this = *this * a;
return *this;
}
IntMod& operator/=(IntMod a) {
*this = *this / a;
return *this;
}
static IntMod build(base_type n) {
IntMod r;
r.n = n;
return r;
}
static base_type inverse_cache[INVERSE_CACHE_SIZE];
static bool inverse_cache_ready;
friend IntMod inverse(IntMod n) { return build(inverse_internal(n.n)); }
static base_type inverse_internal(base_type n) {
if (!inverse_cache_ready) {
inverse_cache_ready = true;
inverse_cache[0] = 0;
inverse_cache[1] = 1;
for (int n = 2; n < INVERSE_CACHE_SIZE; ++n)
inverse_cache[n] =
(MOD -
(base_type)((long long)inverse_cache[MOD % n] * (MOD / n) % MOD));
}
return n < INVERSE_CACHE_SIZE
? inverse_cache[n]
: MOD - (base_type)((long long)inverse_internal(MOD % n) *
(MOD / n) % MOD);
}
friend bool operator==(IntMod a, IntMod b) { return a.n == b.n; }
friend bool operator!=(IntMod a, IntMod b) { return a.n != b.n; }
friend IntMod operator+(IntMod a, IntMod b) {
return build(a.n >= MOD - b.n ? a.n - MOD + b.n : a.n + b.n);
}
friend IntMod operator-(IntMod a, IntMod b) {
return build(a.n >= b.n ? a.n - b.n : a.n - b.n + MOD);
}
friend IntMod operator*(IntMod a, IntMod b) {
return build(
static_cast<base_type>(static_cast<long long>(a.n) * b.n % MOD));
}
friend IntMod operator/(IntMod a, IntMod b) { return a * inverse(b); }
friend IntMod pow(IntMod p, long long e) {
if (e <= 0) return IntMod(1);
IntMod r = IntMod(1);
while (1) {
if (e & 1) r *= p;
e /= 2;
if (e)
p = p * p;
else
break;
}
return r;
}
friend istream& operator>>(istream& stream, IntMod& a) {
stream >> a.n;
return stream;
}
friend ostream& operator<<(ostream& stream, const IntMod& a) {
stream << a.n;
return stream;
}
};
template <typename base_type, base_type _MOD>
base_type IntMod<base_type, _MOD>::inverse_cache[INVERSE_CACHE_SIZE];
template <typename base_type, base_type _MOD>
bool IntMod<base_type, _MOD>::inverse_cache_ready;
template <typename base_type, base_type _MOD>
base_type IntMod<base_type, _MOD>::MOD = _MOD;
using Int = IntMod<int, MOD>;
int n;
int a[maxn], w[maxn];
Int sw[maxn], swa[maxn];
long long sw2[maxn];
void update_sa(Int s[], int p, Int delta) {
for (++p; p <= n; p = (p | (p - 1)) + 1) s[p] += delta;
}
Int get_sa(Int s[], int p) {
Int r = 0;
for (; p > 0; p &= (p - 1)) r += s[p];
return r;
}
Int calc(Int s[], int a, int b) {
if (a > b) return 0;
return get_sa(s, b + 1) - get_sa(s, a);
}
void update_sa2(long long s[], int p, long long delta) {
for (++p; p <= n; p = (p | (p - 1)) + 1) s[p] += delta;
}
long long get_sa2(long long s[], int p) {
long long r = 0;
for (; p > 0; p &= (p - 1)) r += s[p];
return r;
}
long long calc2(long long s[], int a, int b) {
if (a > b) return 0;
return get_sa2(s, b + 1) - get_sa2(s, a);
}
void update_weight(int id, int new_w) {
Int delta = new_w - w[id];
update_sa(sw, id, delta);
update_sa(swa, id, delta * a[id]);
update_sa2(sw2, id, new_w - w[id]);
w[id] = new_w;
}
int query(int s, int t) {
int low = s, high = t, m;
while (1) {
m = (low + high) / 2;
long long s1 = calc2(sw2, s, m - 1);
long long s2 = calc2(sw2, m + 1, t);
if (s1 + w[m] < s2) {
low = m + 1;
continue;
}
if (s2 + w[m] < s1) {
high = m - 1;
continue;
}
break;
}
Int ret = 0;
ret += calc(sw, s, m) * a[m];
ret -= calc(swa, s, m);
ret += calc(swa, m + 1, t);
ret -= calc(sw, m + 1, t) * a[m];
return ret.n;
}
int main() {
std::ios::sync_with_stdio(false);
int nq;
while (cin >> n >> nq) {
for (int i = 0; i < (n); ++i) cin >> a[i];
for (int i = 0; i < (n); ++i) cin >> w[i];
for (int i = 0; i < (n); ++i) a[i] -= i;
for (int i = 0; i < (n + 1); ++i) sw[i] = swa[i] = 0;
for (int i = 0; i < (n + 1); ++i) sw2[i] = 0;
for (int i = 0; i < (n); ++i) update_sa(sw, i, w[i]);
for (int i = 0; i < (n); ++i)
update_sa(swa, i, (long long)w[i] * a[i] % MOD);
for (int i = 0; i < (n); ++i) update_sa2(sw2, i, w[i]);
for (int cl = 0; cl < (nq); ++cl) {
int x, y;
cin >> x >> y;
if (x < 0)
update_weight(-x - 1, y);
else {
int r = query(x - 1, y - 1);
printf("%d\n", r);
}
}
break;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, q, a[210000], w[210000];
long long W[210000], AW[210000];
void modify(long long *b, int x, long long y) {
for (; x <= n; x += x & -x) b[x] += y;
}
long long query(long long *b, int x) {
long long ans = 0;
for (; x; x -= x & -x) ans += b[x];
return ans;
}
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
a[i] -= i;
}
for (int i = 1; i <= n; i++) {
scanf("%d", &w[i]);
}
for (int i = 1; i <= n; i++) {
modify(W, i, w[i]);
modify(AW, i, 1LL * a[i] * w[i] % 1000000007);
}
while (q--) {
int x, y;
scanf("%d%d", &x, &y);
if (x < 0) {
x = -x;
modify(W, x, -w[x]);
modify(AW, x, -(1LL * a[x] * w[x] % 1000000007));
w[x] = y;
modify(W, x, w[x]);
modify(AW, x, (1LL * a[x] * w[x] % 1000000007));
} else {
long long base = query(W, x - 1);
long long SW = query(W, y) - base;
int l = x - 1, r = y, mid;
while (l < r - 1) {
mid = (l + r) / 2;
if (query(W, mid) - base >= (SW + 1) / 2)
r = mid;
else
l = mid;
}
long long ans = 0;
if (x < r) {
ans += 1LL * a[r] * ((query(W, r - 1) - query(W, x - 1)) % 1000000007) %
1000000007;
ans -= (query(AW, r - 1) - query(AW, x - 1)) % 1000000007;
}
if (r < y) {
ans -= 1LL * a[r] * ((query(W, y) - query(W, r)) % 1000000007) %
1000000007;
ans += (query(AW, y) - query(AW, r)) % 1000000007;
}
ans = ((ans % 1000000007) + 1000000007) % 1000000007;
printf("%I64d\n", ans);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
using namespace std;
void enumerateSubmasks(long long m) {
for (long long s = m;; s = (s - 1) & m) {
if (s == 0) {
break;
}
}
}
long long mpow(long long a, long long b, long long m) {
if (b == 0) return 1;
long long x = mpow(a, b / 2, m);
x = (x * x) % m;
if (b % 2) {
x = (x * a) % m;
}
return x;
}
void update(long long s, long long e, long long qs, long long qe,
vector<long long> &seg, vector<long long> &lazy, long long index,
long long value) {
if (lazy[index] != -1) {
seg[index] = max(seg[index], lazy[index]);
if (s != e) {
if (lazy[2 * index] == -1)
lazy[2 * index] = lazy[index];
else
lazy[2 * index] = max(lazy[2 * index], lazy[index]);
if (lazy[2 * index + 1] == -1)
lazy[2 * index + 1] = lazy[index];
else
lazy[2 * index + 1] = max(lazy[2 * index + 1], lazy[index]);
}
lazy[index] = -1;
}
if (qs > e || qe < s) return;
if (s >= qs && e <= qe) {
seg[index] = max(seg[index], value);
if (s != e) {
if (lazy[2 * index] == -1)
lazy[2 * index] = value;
else
lazy[2 * index] = max(lazy[2 * index], value);
if (lazy[2 * index + 1] == -1)
lazy[2 * index + 1] = value;
else
lazy[2 * index + 1] = max(lazy[2 * index + 1], value);
}
return;
}
long long mid = (s + e) / 2;
update(s, mid, qs, qe, seg, lazy, 2 * index, value);
update(mid + 1, e, qs, qe, seg, lazy, 2 * index + 1, value);
}
long long query(long long s, long long e, long long qs, long long qe,
vector<long long> &seg, vector<long long> &lazy,
long long index) {
if (lazy[index] != -1) {
seg[index] = max(seg[index], lazy[index]);
if (s != e) {
if (lazy[2 * index] == -1)
lazy[2 * index] = lazy[index];
else
lazy[2 * index] = max(lazy[2 * index], lazy[index]);
if (lazy[2 * index + 1] == -1)
lazy[2 * index + 1] = lazy[index];
else
lazy[2 * index + 1] = max(lazy[2 * index + 1], lazy[index]);
}
lazy[index] = -1;
}
if (qs > e || qe < s) return LLONG_MIN;
if (s >= qs && e <= qe) {
return seg[index];
}
long long mid = (s + e) / 2;
long long a = query(s, mid, qs, qe, seg, lazy, 2 * index);
long long b = query(mid + 1, e, qs, qe, seg, lazy, 2 * index + 1);
return max(a, b);
}
void printBinaryString(long long n) {
vector<long long> temp;
while (n) {
if (n & 1)
temp.push_back(1);
else
temp.push_back(0);
n = n >> 1;
}
reverse(temp.begin(), temp.end());
for (auto node : temp) cout << node << " ";
cout << endl;
}
void readVector(vector<long long> &a) {
long long n = a.size();
for (long long i = 0; i < n; ++i) cin >> a[i];
}
struct node {
long long id;
long long val;
char dir;
};
map<long long, list<long long>> adj;
map<long long, long long> par;
map<long long, bool> x;
map<long long, bool> y;
long long k1, k2;
long long answer;
long long interactA(long long x) {
cout << "A " << x << endl;
long long ret;
cin >> ret;
fflush(stdout);
return ret;
}
long long interactB(long long x) {
cout << "B " << x << endl;
long long ret;
cin >> ret;
fflush(stdout);
return ret;
}
pair<long long, bool> solve(long long node, long long par, long long k) {
long long totalInSubtree = 1;
for (auto child : adj[node]) {
if (child == par) continue;
auto ret = solve(child, node, k);
bool mila = ret.second;
if (mila) return {0, true};
totalInSubtree += ret.first;
}
if (totalInSubtree < k) return {totalInSubtree, false};
if (x[node] == false) return {0, false};
long long bLabel = interactA(node);
if (y[bLabel]) {
answer = node;
return {0, true};
} else
return {0, false};
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long tc;
cin >> tc;
while (tc--) {
answer = -1;
x.clear();
y.clear();
adj.clear();
par.clear();
long long n;
cin >> n;
for (long long i = 0; i < n - 1; ++i) {
long long u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
cin >> k1;
for (long long i = 0; i < k1; ++i) {
long long temp;
cin >> temp;
x[temp] = true;
}
long long st;
cin >> k2;
for (long long i = 0; i < k2; ++i) {
long long temp;
cin >> temp;
st = temp;
y[temp] = true;
}
long long start = interactB(st);
queue<long long> bfs;
long long toCompare;
bfs.push(start);
map<long long, bool> visited;
while (!bfs.empty()) {
auto node = bfs.front();
bfs.pop();
visited[node] = true;
if (x[node]) {
toCompare = node;
break;
}
for (auto child : adj[node]) {
if (visited[child]) continue;
bfs.push(child);
}
}
long long temp = interactA(toCompare);
if (y[temp])
cout << "C " << toCompare << endl;
else
cout << "C -1" << endl;
fflush(stdout);
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
void pv(vector<T> &vec) {
for (int i = 0; i < (int)(vec).size(); i++)
cout << vec[i] << (i == (int)(vec).size() - 1 ? '\n' : ' ');
}
int V, a, b, t;
vector<vector<int> > G;
vector<int> mine, his;
vector<bool> label, his_label;
void init() {
cin >> V;
(G).clear();
G.resize(V);
for (int i = 0; i < V - 1; i++) {
cin >> a >> b;
a--;
b--;
G[a].push_back(b);
G[b].push_back(a);
}
cin >> a;
mine.resize(a);
label.assign(V, false);
for (int i = 0; i < a; i++) {
cin >> mine[i];
mine[i]--;
label[mine[i]] = true;
}
cin >> a;
his.resize(a);
his_label.assign(V, false);
for (int i = 0; i < a; i++) {
cin >> his[i];
his[i]--;
his_label[his[i]] = true;
}
}
int dfs(int u, int p) {
if (label[u]) return u;
for (int i = 0; i < (int)(G[u]).size(); i++) {
int v = G[u][i];
if (v != p) {
int tans = dfs(v, u);
if (tans != -1) return tans;
}
}
return -1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int TC;
cin >> TC;
while (TC--) {
init();
cout << "B " << his[0] + 1 << endl;
int strt;
cin >> strt;
strt--;
int my_closest = dfs(strt, -1);
assert(my_closest != -1);
cout << "A " << my_closest + 1 << endl;
cin >> t;
t--;
cout << "C " << (his_label[t] ? my_closest + 1 : -1) << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1001;
int dis[N], n;
vector<int> g[N], my, his;
void read(vector<int>& a) {
int temp;
a.clear();
scanf("%d", &temp);
for (int i = 0, b; i < temp; i++) {
scanf("%d", &b);
a.push_back(b);
}
}
int ask(char c, int a) {
cout << c << " " << a << endl;
int ret;
cin >> ret;
return ret;
}
void dfs(int u, int p) {
for (auto i : g[u])
if (i != p) {
dis[i] = dis[u] + 1;
dfs(i, u);
}
}
int main() {
int T;
scanf("%d", &T);
while (T--) {
scanf("%d", &n);
for (int i = 1, a, b; i < n; i++) {
scanf("%d%d", &a, &b);
g[a].push_back(b);
g[b].push_back(a);
}
read(my);
read(his);
int y = ask('B', his[0]);
dfs(y, -1);
int at = my.front();
for (auto i : my)
if (dis[i] < dis[at]) at = i;
y = ask('A', at);
if (find(his.begin(), his.end(), y) != his.end())
cout << "C " << at << endl;
else
cout << "C -1" << endl;
for (int i = 0; i <= n; i++) g[i].clear();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int limN = 1005;
int query(int tp, int pos) {
printf("%c %d\n", tp + 'A', pos);
fflush(stdout);
if (tp != 2) {
int N;
scanf("%d", &N);
if (N == -1) {
exit(0);
}
return N;
}
return 0;
}
vector<int> adj[limN];
bool inA[limN], inB[limN];
int closestA(int pos, int pv = -1) {
if (inA[pos]) return pos;
int ans;
for (const int sig : adj[pos])
if (sig != pv) {
ans = closestA(sig, pos);
if (ans != -1) return ans;
}
return -1;
}
void testCase() {
memset(inA, 0, sizeof(inA));
memset(inB, 0, sizeof(inB));
int N;
int X, Y;
scanf("%d", &N);
for (int i = 1, a, b; i < N; i++) {
scanf("%d%d", &a, &b);
adj[a].push_back(b);
adj[b].push_back(a);
}
scanf("%d", &X);
for (int i = 0, a; i < X; i++) {
scanf("%d", &a);
inA[a] = true;
}
scanf("%d", &Y);
for (int i = 0, a; i < Y; i++) {
scanf("%d", &a);
inB[a] = true;
}
int p = -1;
for (int i = 1; i <= N; i++) {
if (!inB[i]) continue;
p = closestA(query(1, i));
break;
}
int w = query(0, p);
query(2, inB[w] ? p : -1);
for (int i = 1; i <= N; i++) adj[i].clear();
}
int main() {
int tc;
scanf("%d", &tc);
for (int i = 0; i < tc; i++) testCase();
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> g[2005], dis(2005), a(2005);
void dfs(int a, int p) {
for (int i = 0; i < g[a].size(); i++) {
int y = g[a][i];
if (y == p) continue;
dis[y] = dis[a] + 1;
dfs(y, a);
}
}
int ask(int a, int b) {
int ans;
if (a == 0) {
cout << "B " << b << "\n";
} else
cout << "A " << b << "\n";
fflush(stdout);
cin >> ans;
if (ans == -1) exit(0);
return ans;
}
void clean(int n) {
for (int i = 0; i <= n; i++) {
g[i].clear();
dis[i] = 0;
a[i] = 0;
}
}
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
clean(n);
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
int k1, k2;
cin >> k1;
for (int i = 1; i <= k1; i++) {
int x;
cin >> x;
a[x] = 1;
}
cin >> k2;
int x;
map<int, int> mp;
for (int i = 1; i <= k2; i++) {
int b;
cin >> b;
mp[b];
x = b;
}
x = ask(0, x);
int mn = 9999999;
dis[x] = 0;
dfs(x, 0);
int y;
for (int i = 1; i <= n; i++)
if (dis[i] < mn && a[i]) {
mn = dis[i];
y = i;
}
int z = ask(1, y);
if (mp.find(z) == mp.end()) {
cout << "C " << -1 << "\n";
} else
cout << "C " << y << "\n";
fflush(stdout);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> v[1007], v1, v2;
bool vis1[1007], vis2[1007];
int t, n, n1, n2;
int dfs(int x) {
queue<int> q;
bool vis[1007];
memset(vis, false, sizeof(vis));
q.push(x);
while (!q.empty()) {
x = q.front();
q.pop();
if (vis1[x]) {
return x;
}
vis[x] = true;
for (int i = 0; i < v[x].size(); i++) {
if (!vis[v[x][i]]) {
vis[v[x][i]] = true;
q.push(v[x][i]);
}
}
}
}
int main() {
scanf("%d", &t);
while (t--) {
memset(vis1, false, sizeof(vis1));
memset(vis2, false, sizeof(vis2));
v1.clear();
v2.clear();
for (int i = 1; i <= 1007; i++) v[i].clear();
scanf("%d", &n);
int x, y;
while (--n) {
scanf("%d%d", &x, &y);
v[x].push_back(y);
v[y].push_back(x);
}
scanf("%d", &n1);
int a;
for (int i = 0; i < n1; i++) {
scanf("%d", &a);
vis1[a] = true;
v1.push_back(a);
}
scanf("%d", &n2);
for (int i = 0; i < n2; i++) {
scanf("%d", &a);
vis2[a] = true;
v2.push_back(a);
}
printf("B %d\n", v2[0]);
fflush(stdout);
scanf("%d", &a);
if (vis1[a]) {
printf("C %d\n", a);
fflush(stdout);
} else {
a = dfs(a);
int a11 = a;
printf("A %d\n", a);
fflush(stdout);
scanf("%d", &a);
if (vis2[a]) {
printf("C %d\n", a11);
fflush(stdout);
} else {
printf("C %d\n", -1);
fflush(stdout);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int const MAXN = 1e3;
const char MIO_A_OTRO = 'A';
const char OTRO_A_MIO = 'B';
vector<int> rel[MAXN + 2];
bool es_especial[MAXN + 2];
bool visitado[MAXN + 2];
int raiz;
void limpia() {
for (int i = 0; i < MAXN + 1; ++i) {
rel[i].clear();
es_especial[i] = false;
visitado[i] = false;
}
}
int query(char tipo, int nodo) {
cout << tipo << " " << nodo << '\n';
cout.flush();
int resp;
cin >> resp;
return resp;
}
void responde(int nodo) {
cout << "C " << nodo << '\n';
cout.flush();
}
void dfs(int nodo) {
if (visitado[nodo]) return;
visitado[nodo] = true;
if (es_especial[nodo]) {
raiz = nodo;
return;
}
for (const auto& sig : rel[nodo]) {
dfs(sig);
}
}
void resuelve(int n, vector<int> lista, int m) {
int act = query(OTRO_A_MIO, lista[0]);
if (es_especial[act]) {
responde(act);
return;
}
dfs(act);
int buscar = query(MIO_A_OTRO, raiz);
for (int i = 0; i < m; ++i) {
if (lista[i] == buscar) {
responde(raiz);
return;
}
}
responde(-1);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
for (int caso = 0; caso < t; ++caso) {
limpia();
int n;
cin >> n;
for (int i = 0; i < n - 1; ++i) {
int a, b;
cin >> a >> b;
rel[a].push_back(b);
rel[b].push_back(a);
}
int k1;
cin >> k1;
for (int i = 0; i < k1; ++i) {
int nodo;
cin >> nodo;
es_especial[nodo] = true;
}
int k2;
cin >> k2;
vector<int> lista(k2);
for (int i = 0; i < k2; ++i) cin >> lista[i];
resuelve(n, lista, k2);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> g[1010];
int a[1010], b[1010], vis[1010];
set<int> aa, bb;
int bfs(int x) {
memset(vis, 0, sizeof vis);
queue<int> q;
q.push(x);
vis[x] = 1;
while (!q.empty()) {
int v = q.front();
q.pop();
if (aa.count(v) > 0) return v;
for (auto it : g[v]) {
if (!vis[it]) {
vis[it] = 1;
q.push(it);
}
}
}
return -1;
}
int main() {
int t, n, x, y, k, kk;
cin >> t;
while (t--) {
cin >> n;
for (int i = 0; i <= n; i++) g[i].clear();
aa.clear();
bb.clear();
for (int i = 1; i < n; i++) {
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
cin >> k;
for (int i = 0; i < k; i++) {
cin >> a[i];
aa.insert(a[i]);
}
cin >> kk;
for (int i = 0; i < kk; i++) {
cin >> b[i];
bb.insert(b[i]);
}
cout << "B " << b[0] << endl;
fflush(stdout);
cin >> x;
int v = bfs(x);
cout << "A " << v << endl;
fflush(stdout);
cin >> x;
if (bb.count(x) > 0) {
cout << "C " << v << endl;
fflush(stdout);
} else {
cout << "C -1" << endl;
fflush(stdout);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1005;
int test, n, k1, k2;
vector<int> e[N];
set<int> ms1, ms2;
queue<int> qu;
bool check[N];
int bfs(int s) {
while (qu.size()) qu.pop();
for (int i = 1; i <= n; ++i) {
check[i] = false;
}
qu.push(s);
check[s] = true;
while (qu.size()) {
int u = qu.front();
qu.pop();
if (ms1.find(u) != ms1.end()) return u;
for (int v : e[u]) {
if (!check[v]) {
qu.push(v);
check[v] = true;
}
}
}
return -1;
}
void solve() {
cin >> n;
ms1.clear();
ms2.clear();
for (int i = 1; i <= n; ++i) {
e[i].clear();
}
for (int i = 1; i < n; ++i) {
int x, y;
cin >> x >> y;
e[x].push_back(y);
e[y].push_back(x);
}
cin >> k1;
for (int i = 1; i <= k1; ++i) {
int x;
cin >> x;
ms1.insert(x);
}
cin >> k2;
for (int i = 1; i <= k2; ++i) {
int x;
cin >> x;
ms2.insert(x);
}
int u, ans;
u = *ms2.begin();
cout << "B " << u << "\n";
fflush(stdout);
cin >> ans;
u = bfs(ans);
cout << "A " << u << "\n";
fflush(stdout);
cin >> ans;
if (ms2.find(ans) != ms2.end()) {
cout << "C " << u << "\n";
fflush(stdout);
return;
}
cout << "C -1\n";
fflush(stdout);
return;
}
int main() {
cin >> test;
while (test--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(3)
using namespace std;
const long long llINF = 9223372036854775807;
const int INF = 2147483647;
const int maxn = 1e3 + 7;
const int maxm = 1e5 + 7;
const int mod = 998244353;
int t, n;
int x, y;
int k1, k2;
int subtreex[maxn], subtreey[maxn];
vector<int> tree[maxn];
void init() {
memset(subtreey, 0, sizeof(subtreey));
memset(subtreex, 0, sizeof(subtreex));
for (int i = 0; i < maxn; i++) tree[i].clear();
}
int dfs(int cur, int lst) {
if (subtreex[cur]) return cur;
for (int i = 0; i < tree[cur].size(); i++) {
int v = tree[cur][i];
if (v == lst) continue;
int idx = dfs(v, cur);
if (idx != -1) return idx;
}
return -1;
}
int main(int argc, char const *argv[]) {
scanf("%d", &t);
while (t--) {
init();
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
tree[u].push_back(v);
tree[v].push_back(u);
}
scanf("%d", &k1);
for (int i = 1; i <= k1; i++) {
scanf("%d", &x);
subtreex[x] = 1;
}
scanf("%d", &k2);
for (int i = 1; i <= k2; i++) {
scanf("%d", &y);
subtreey[y] = 1;
}
printf("B %d\n", y);
fflush(stdout);
int yinx;
scanf("%d", &yinx);
if (subtreex[yinx]) {
printf("C %d\n", yinx);
fflush(stdout);
continue;
}
int idx = dfs(yinx, 0);
if (idx == -1) {
printf("C -1\n");
fflush(stdout);
continue;
}
int p;
printf("A %d\n", idx);
fflush(stdout);
scanf("%d", &p);
printf("C %d\n", subtreey[p] ? idx : -1);
fflush(stdout);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int askB(int v) {
cout << "B " << v << endl;
int y;
cin >> y;
return y;
}
int askA(int v) {
cout << "A " << v << endl;
int y;
cin >> y;
return y;
}
int dfsnearest(std::vector<std::vector<int> >& adj, int u, int p,
std::vector<bool>& vis) {
if (vis[u]) return u;
int y = -1;
for (int v : adj[u])
if (v != p) y = max(y, dfsnearest(adj, v, u, vis));
return y;
}
int32_t main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
std::vector<std::vector<int> > adj(n + 1);
std::vector<bool> v1(n + 1);
std::vector<bool> v2(n + 1);
for (int i = 0; i < n - 1; ++i) {
int u, v;
cin >> u >> v;
adj[u].emplace_back(v);
adj[v].emplace_back(u);
}
int k1;
cin >> k1;
for (int i = 0; i < k1; ++i) {
int u;
cin >> u;
v1[u] = true;
}
int k2;
cin >> k2;
int vv = -1;
for (int i = 0; i < k2; ++i) {
int u;
cin >> u;
v2[u] = true;
vv = u;
}
int u = askB(vv);
if (v1[u]) {
cout << "C " << u << endl;
continue;
}
vv = dfsnearest(adj, u, 0, v1);
u = askA(vv);
if (!v2[u]) vv = -1;
cout << "C " << vv << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int N;
int K1;
set<int> S1, S2;
int K2;
vector<int> edges[1000010];
set<pair<int, int> > S;
void dfs(int curr, int par, int cnt) {
if ((S1.find(curr) != S1.end())) {
S.insert(make_pair(cnt, curr));
}
for (int i = 0; i < edges[curr].size(); i++) {
if (edges[curr][i] != par) {
dfs(edges[curr][i], curr, cnt + 1);
}
}
}
int main() {
ios_base::sync_with_stdio(0);
int T;
cin >> T;
while (T--) {
S1.clear();
S2.clear();
S.clear();
cin >> N;
for (int i = 1; i <= N; i++) {
edges[i].clear();
}
for (int i = 1; i < N; i++) {
int x, y;
cin >> x >> y;
edges[x].push_back(y);
edges[y].push_back(x);
}
cin >> K1;
for (int i = 1; i <= K1; i++) {
int x;
cin >> x;
S1.insert(x);
}
cin >> K2;
for (int i = 1; i <= K2; i++) {
int x;
cin >> x;
S2.insert(x);
}
cout << "B " << *(S2.begin()) << endl;
fflush(stdout);
int which;
cin >> which;
if ((S1.find(which) != S1.end())) {
cout << "C " << which << endl;
fflush(stdout);
} else {
dfs(which, which, 0);
int okay = (*(S.begin())).second;
cout << "A " << okay << endl;
fflush(stdout);
cin >> which;
if ((S2.find(which) != S2.end())) {
cout << "C " << okay << endl;
fflush(stdout);
} else {
cout << "C -1" << endl;
fflush(stdout);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1024;
vector<int> g[N];
int n, t, k1, k2, x, y;
bool vst[N];
set<int> a, b;
int bfs(int x) {
queue<int> q;
q.push(x);
while (q.size()) {
int t = q.front();
q.pop();
if (a.count(t)) return t;
for (int i : g[t])
if (!vst[i]) {
vst[i] = 1;
q.push(i);
}
}
assert(0);
exit(0);
}
void clean() {
for (int i = 0; i < n + 1; i++) g[i].clear();
memset(vst, 0, sizeof(vst));
a.clear();
b.clear();
}
int ask(char c, int k) {
cout << c << " " << k << endl;
cin >> x;
if (x == -1) {
assert(0);
return (0);
}
return x;
}
int main() {
ios::sync_with_stdio(false);
cin >> t;
while (t--) {
clean();
cin >> n;
for (int i = 0; i < n - 1; i++) {
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
cin >> k1;
for (int i = 0; i < k1; i++) cin >> x, a.insert(x);
cin >> k2;
for (int i = 0; i < k2; i++) cin >> x, b.insert(x);
x = ask('B', *b.begin());
int k = bfs(x);
x = ask('A', k);
if (b.count(x))
cout << "C " << k << endl;
else
cout << "C -1" << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INFll = 1ll * 1000000100 * 1000000100;
const long double PI =
3.141592653589793238462643383279502884197169399375105820974944;
vector<vector<int>> g;
int n;
vector<int> dist;
void bfs(int start) {
dist.assign(n, 1000000100);
queue<int> q;
q.push(start);
dist[start] = 0;
while (!q.empty()) {
int u = q.front();
q.pop();
for (int v : g[u]) {
if (dist[v] == 1000000100) {
dist[v] = dist[u] + 1;
q.push(v);
}
}
}
}
void solve() {
cin >> n;
g.clear();
g.resize(n);
for (int i = 0; i < n - 1; i++) {
int x, y;
cin >> x >> y;
x--;
y--;
g[x].push_back(y);
g[y].push_back(x);
}
int k1, k2;
set<int> me, you;
cin >> k1;
for (int i = 0; i < k1; i++) {
int x;
cin >> x;
x--;
me.insert(x);
}
cin >> k2;
for (int i = 0; i < k2; i++) {
int x;
cin >> x;
x--;
you.insert(x);
}
int start;
cout << "B " << (*you.begin()) + 1 << endl;
fflush(stdout);
cin >> start;
start--;
bfs(start);
int mn = 1000000100, ver = -1;
for (auto it = me.begin(); it != me.end(); it++) {
if (dist[*it] < mn) {
ver = *it;
mn = dist[ver];
}
}
cout << "A " << ver + 1 << endl;
fflush(stdout);
int ans;
cin >> ans;
ans--;
if (you.count(ans)) {
cout << "C " << ver + 1 << endl;
fflush(stdout);
} else {
cout << "C " << -1 << endl;
fflush(stdout);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1010;
int cases, n, k, k2, u, v, p[N], x[N], y[N];
bool fnd[N], fnd2[N];
vector<int> adj[N];
void dfs(int u, int p2) {
p[u] = p2;
for (int i = 0, v; i < adj[u].size(); i++) {
v = adj[u][i];
if (v == p2) continue;
dfs(v, u);
}
}
void solve() {
cin >> cases;
while (cases--) {
cin >> n;
for (int i = 1; i <= n; i++) {
fnd[i] = 0;
fnd2[i] = 0;
p[i] = -1;
adj[i].clear();
}
for (int i = 1; i < n; i++) {
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
cin >> k;
for (int i = 1; i <= k; i++) {
cin >> x[i];
fnd[x[i]] = 1;
}
cin >> k2;
for (int i = 1; i <= k2; i++) {
cin >> y[i];
fnd2[y[i]] = 1;
}
if (k >= 1)
dfs(x[1], -1);
else
dfs(1, -1);
if (k2 >= 1) {
cout << "B " << y[1] << "\n";
cout.flush();
} else {
cout << "C -1\n";
cout.flush();
continue;
}
cin >> u;
if (u == -1) return;
while (1) {
if (u == -1) {
cout << "C -1\n";
cout.flush();
break;
}
if (fnd[u]) {
cout << "A " << u << "\n";
cout.flush();
cin >> v;
if (v == -1) return;
if (fnd2[v])
cout << "C " << u << "\n";
else
cout << "C -1\n";
cout.flush();
break;
}
u = p[u];
}
}
}
int main() {
std::ios::sync_with_stdio(0);
cin.tie(0);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<string> parser(string line) {
string tmp;
vector<string> ret;
line += ' ';
int n = line.size();
for (int i = 0; i < n; i++) {
if (line[i] == ' ') {
ret.push_back(tmp);
tmp = "";
} else {
tmp += line[i];
}
}
return ret;
}
int str_to_int(string str) {
stringstream sstr;
int ret;
sstr << str;
sstr >> ret;
return ret;
}
chrono::steady_clock::time_point get_now() {
return chrono::steady_clock::now();
}
double GetTimeDiff(const chrono::steady_clock::time_point& begin_t,
const chrono::steady_clock::time_point& end_t) {
return ((double)chrono::duration_cast<chrono::microseconds>(end_t - begin_t)
.count()) /
1000.0 / 1000.0;
}
void sub_func() {
string line;
int n;
getline(cin, line);
sscanf(line.c_str(), "%d", &n);
unordered_map<int, vector<int>> graph_dict;
for (int i = 0; i < n - 1; ++i) {
int x, y;
getline(cin, line);
sscanf(line.c_str(), "%d %d", &x, &y);
graph_dict[x].push_back(y);
graph_dict[y].push_back(x);
}
int k1, k2;
vector<int> subtree1, subtree2;
unordered_set<int> vset1, vset2;
getline(cin, line);
sscanf(line.c_str(), "%d", &k1);
getline(cin, line);
vector<string> vec = parser(line);
for (auto str : vec) {
subtree1.push_back(str_to_int(str));
}
getline(cin, line);
sscanf(line.c_str(), "%d", &k2);
getline(cin, line);
vec = parser(line);
for (auto str : vec) {
subtree2.push_back(str_to_int(str));
}
for (auto v : subtree1) {
vset1.insert(v);
}
for (auto v : subtree2) {
vset2.insert(v);
}
cout << "B " << subtree2[0] << endl;
getline(cin, line);
int src;
sscanf(line.c_str(), "%d", &src);
if (vset1.find(src) != vset1.end()) {
cout << "C " << src << endl;
return;
}
vector<int> queue = {src};
vector<bool> touched(n, false);
int idx = 0, dest = -1;
bool end = false;
while (true) {
int q = queue[idx];
touched[q] = true;
idx++;
for (auto y : graph_dict[q]) {
if (touched[y]) {
continue;
}
if (vset1.find(y) != vset1.end()) {
dest = y;
end = true;
break;
}
queue.push_back(y);
}
if (end) {
break;
}
}
cout << "A " << dest << endl;
getline(cin, line);
sscanf(line.c_str(), "%d", &src);
if (vset2.find(src) != vset2.end()) {
cout << "C " << dest << endl;
} else {
cout << "C "
<< "-1" << endl;
}
}
void main_func() {
string line;
getline(cin, line);
int t;
sscanf(line.c_str(), "%d", &t);
for (int i = 0; i < t; ++i) {
sub_func();
}
}
int main() {
main_func();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int ask(char type, int id) {
printf("%c %d\n", type, id);
fflush(stdout);
int q = -1;
if (type != 'C') scanf("%d", &q);
return q;
}
vector<int> g[1010];
int x[1010], y[1010], par[1010];
bool apr_x[1010], apr_y[1010];
void solve() {
int n, a, b;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
apr_x[i] = apr_y[i] = false;
g[i].clear();
}
for (int i = 1; i < n; i++) {
scanf("%d%d", &a, &b);
g[a].push_back(b);
g[b].push_back(a);
}
int k1, k2;
scanf("%d", &k1);
for (int i = 1; i <= k1; i++) {
scanf("%d", x + i);
apr_x[x[i]] = true;
}
scanf("%d", &k2);
for (int i = 1; i <= k2; i++) {
scanf("%d", y + i);
apr_y[y[i]] = true;
}
int x_id = ask('B', y[1]);
queue<int> q;
q.push(x_id);
par[x_id] = -1;
int found = -1;
while (!q.empty()) {
int u = q.front();
if (apr_x[u]) {
found = u;
break;
}
q.pop();
for (int i = 0; i < (int)g[u].size(); i++) {
int v = g[u][i];
if (v != par[u]) {
par[v] = u;
q.push(v);
}
}
}
int y_id = ask('A', found);
if (apr_y[y_id])
ask('C', found);
else
ask('C', -1);
}
int main() {
int t;
scanf("%d", &t);
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 10;
vector<int> G[N];
int Select[2][N];
int K[2];
bool vis[N];
int Tag[N];
set<int> myset;
int dfs(int u) {
if (Tag[u] == 1) return u;
vis[u] = true;
for (int i = 0; i < ((int)G[u].size()); i++) {
int v = G[u][i];
if (!vis[v]) {
int ret = dfs(v);
if (ret) return ret;
}
}
return 0;
}
int main() {
ios::sync_with_stdio(false);
int T;
cin >> T;
while (T--) {
memset(vis, false, sizeof(vis));
memset(Tag, 0, sizeof(Tag));
myset.clear();
int n, u, v;
cin >> n;
for (int i = 1; i < n + 1; i++) G[i].clear();
for (int i = 0; i < n - 1; i++)
cin >> u >> v, G[u].push_back(v), G[v].push_back(u);
int k1, k2;
cin >> K[0];
for (int i = 0; i < K[0]; i++) {
cin >> Select[0][i];
Tag[Select[0][i]] = 1;
}
cin >> K[1];
for (int i = 0; i < K[1]; i++) {
cin >> Select[1][i];
myset.insert(Select[1][i]);
}
cout << "B " << Select[1][0] << endl;
;
int res = 0;
cin >> res;
bool ok = (Tag[res] == 1);
if (!ok) {
int qnode = dfs(res);
cout << "A " << qnode << endl;
cin >> res;
if (myset.find(res) != myset.end())
ok = true;
else
ok = false;
cout << "C ";
if (ok)
cout << qnode << endl;
else
cout << -1 << endl;
} else {
cout << "C " << res << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target( \
"sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,tune=native")
#pragma GCC optimize("unroll-loops")
using namespace std;
using ll = long long int;
using vi = vector<int>;
using namespace std;
ll if_found = -1;
void DFS(set<ll> &our, int v, vector<vector<int>> &gr, int pr) {
if (our.find(v) != our.end()) {
if_found = v;
return;
}
for (int u : gr[v]) {
if (u != pr) DFS(our, u, gr, v);
}
}
int main() {
ll n = 0, t = 0;
cin >> t;
for (int i = 0; i < t; i++) {
ll n;
if_found = -1;
cin >> n;
vector<vector<int>> gr(n);
for (int i = 0; i < n - 1; i++) {
ll u, v;
cin >> u >> v;
gr[u - 1].push_back(v - 1);
gr[v - 1].push_back(u - 1);
}
ll k1;
cin >> k1;
set<ll> our;
for (int i = 0; i < k1; i++) {
ll v;
cin >> v;
our.insert(v - 1);
}
ll k2;
cin >> k2;
set<ll> lc;
for (int i = 0; i < k2; i++) {
ll v;
cin >> v;
lc.insert(v - 1);
}
cout << "B " << *lc.begin() + 1 << "\n";
ll vert;
cin >> vert;
if (our.find(vert - 1) != our.end()) {
cout << "C " << vert << "\n";
cout.flush();
continue;
}
DFS(our, vert - 1, gr, -1);
cout << "A " << if_found + 1 << "\n";
ll leec;
cin >> leec;
if (lc.find(leec - 1) != lc.end()) {
cout << "C " << if_found + 1 << "\n";
cout.flush();
continue;
} else {
cout << "C " << -1 << "\n";
cout.flush();
continue;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
ifstream fin("AAtest.in.txt");
long long t, n, k1, k2, x[1005], y[1005], a, b, boo = -2;
vector<long long> tee[1005];
bool kul[1005];
void rek(long long l) {
kul[l] = 1;
if (x[l]) {
cout << "A " << l << endl;
cin >> boo;
if (y[boo])
boo = l;
else
boo = -1;
return;
}
for (int i = 0; i < tee[l].size(); i++)
if (!kul[tee[l][i]]) {
rek(tee[l][i]);
if (boo != -2) return;
}
}
int main() {
ios::sync_with_stdio(0);
cin >> t;
for (int o = 0; o < t; o++) {
cin >> n;
for (int i = 1; i <= n; i++) tee[i].resize(0);
for (int i = 0; i < n - 1; i++) {
cin >> a >> b;
tee[a].push_back(b);
tee[b].push_back(a);
}
cin >> k1;
memset(x, 0, sizeof(x));
memset(y, 0, sizeof(y));
for (int i = 0; i < k1; i++) cin >> a, x[a] = 1;
cin >> k2;
for (int i = 0; i < k2; i++) cin >> a, y[a] = 1;
cout << "B " << a << endl;
cin >> a;
boo = -2;
memset(kul, 0, sizeof(kul));
rek(a);
cout << "C " << boo << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200500;
vector<int> g[N];
vector<int> k[2];
int ask(char c, int x) {
cout << c << " " << x + 1 << endl;
int y;
cin >> y;
y--;
return y;
}
int dist[N];
int main() {
int tn;
cin >> tn;
for (int tc = 0, qwerty = tn; tc < qwerty; tc++) {
int n;
cin >> n;
for (int i = 0, qwerty = n; i < qwerty; i++) g[i].clear();
for (int i = 1, qwerty = n; i < qwerty; i++) {
int x, y;
cin >> x >> y;
x--;
y--;
g[x].push_back(y);
g[y].push_back(x);
}
for (int i = 0, qwerty = 2; i < qwerty; i++) {
k[i].clear();
int m;
cin >> m;
for (int j = 0, qwerty = m; j < qwerty; j++) {
int x;
cin >> x;
x--;
k[i].push_back(x);
}
}
int root = ask('B', k[1][0]);
for (int i = 0, qwerty = n; i < qwerty; i++) dist[i] = 1e9;
queue<int> q;
q.push(root);
dist[root] = 0;
while (!q.empty()) {
int x = q.front();
q.pop();
for (int y : g[x]) {
if (dist[y] > dist[x] + 1) {
dist[y] = dist[x] + 1;
q.push(y);
}
}
}
int less = -1, d = n;
for (int x : k[0]) {
if (dist[x] < d) {
d = dist[x];
less = x;
}
}
if (d == 0) {
cout << "C " << less + 1 << endl;
} else {
int v = ask('A', less);
bool can = 0;
for (int x : k[1]) {
if (x == v) {
can = 1;
}
}
if (can) {
cout << "C " << less + 1 << endl;
} else {
cout << "C -1" << endl;
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
void dfs(int x, vector<vector<int> > &graph, vector<bool> &is_in_subgraph,
vector<bool> &used, int &ans) {
if (used[x]) return;
used[x] = true;
if (is_in_subgraph[x]) {
ans = x;
return;
}
for (int i = 0; i < graph[x].size(); ++i)
dfs(graph[x][i], graph, is_in_subgraph, used, ans);
}
int main() {
int t;
cin >> t;
for (int i = 0; i < t; ++i) {
int n, a, b, k, x, k2;
cin >> n;
vector<vector<int> > graph(n);
for (int i = 0; i < n - 1; ++i) {
cin >> a >> b;
--a;
--b;
graph[a].push_back(b);
graph[b].push_back(a);
}
cin >> k;
vector<bool> is_in_subgraph(n);
for (int i = 0; i < k; ++i) {
cin >> x;
--x;
is_in_subgraph[x] = true;
}
cin >> k2;
set<int> his_subgraph;
for (int i = 0; i < k2; ++i) {
cin >> x;
his_subgraph.insert(x);
}
cout << "B " << x << endl;
cout.flush();
cin >> x;
--x;
vector<bool> used(n);
int ans = -1;
dfs(x, graph, is_in_subgraph, used, ans);
cout << "A " << ans + 1 << endl;
cout.flush();
cin >> x;
if (his_subgraph.find(x) != his_subgraph.end()) {
cout << "C " << ans + 1 << endl;
cout.flush();
} else {
cout << "C " << -1 << endl;
cout.flush();
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(time(NULL));
void get_ans() {
vector<int> g[1000];
set<int> a, b;
int n, k, s, q[1000], head = 0, tail = 0, p[1000];
cin >> n;
for (int i = 0; i < n - 1; i++) {
int first, second;
cin >> first >> second;
g[first - 1].push_back(second - 1);
g[second - 1].push_back(first - 1);
}
cin >> k;
for (int i = 0; i < k; i++) {
int first;
cin >> first;
a.insert(first - 1);
}
cin >> k;
for (int i = 0; i < k; i++) {
int first;
cin >> first;
b.insert(first - 1);
}
cout << "B " << *b.begin() + 1 << endl;
cin >> s;
s--;
p[s] = -1;
q[head++] = s;
while (head != tail) {
int v = q[tail++];
if (a.count(v)) {
cout << "A " << v + 1 << endl;
int first;
cin >> first;
if (b.count(first - 1)) {
cout << "C " << v + 1 << endl;
return;
} else {
cout << "C -1" << endl;
return;
}
}
for (int i = 0; i < g[v].size(); i++) {
int to = g[v][i];
if (to == p[v]) continue;
p[to] = v;
q[head++] = to;
}
}
cout << "C -1" << endl;
}
int main() {
int t;
cin >> t;
for (int i = 0; i < t; i++) get_ans();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char _;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long fpow(long long b, long long exp, long long mod) {
if (exp == 0) return 1;
long long t = fpow(b, exp / 2, mod);
if (exp & 1) return t * t % mod * b % mod;
return t * t % mod;
}
int num_cases, num_nodes, num_A, num_B;
bool marked[1005], vis[1005];
vector<int> connections[1005];
unordered_set<int> A, B;
int main() {
cin >> num_cases;
for (int t = 0; t < num_cases; t++) {
cin >> num_nodes;
for (int i = 1; i <= num_nodes; i++) connections[i].clear();
for (int i = 0; i < num_nodes - 1; i++) {
int a, b;
cin >> a >> b;
connections[a].push_back(b);
connections[b].push_back(a);
}
cin >> num_A;
A.clear(), B.clear();
memset(marked, false, sizeof marked);
for (int i = 1; i <= num_A; i++) {
int n;
cin >> n;
A.insert(n);
marked[n] = true;
}
cin >> num_B;
for (int i = 1; i <= num_B; i++) {
int n;
cin >> n;
B.insert(n);
}
int first = *B.begin();
cout << "B " << first << "\n";
int ans;
cin >> ans;
if (A.count(ans)) {
cout << "C " << ans << "\n";
continue;
}
memset(vis, false, sizeof vis);
queue<int> q;
q.push(ans);
vis[ans] = true;
bool done = false;
while (!q.empty()) {
int node = q.front();
q.pop();
if (marked[node]) {
cout << "A " << node << "\n";
cin >> ans;
if (B.count(ans)) {
cout << "C " << node << "\n";
done = true;
break;
}
break;
}
for (int check : connections[node]) {
if (!vis[check]) {
vis[check] = true;
q.push(check);
}
}
}
if (!done)
cout << "C -1"
<< "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1024;
vector<int> g[N];
int n, t, k1, k2, x, y;
int d[N];
set<int> a, b;
int bfs(int x) {
memset(d, -1, sizeof(d));
d[x] = 0;
queue<int> q;
q.push(x);
while (q.size()) {
int t = q.front();
q.pop();
for (int i : g[t]) {
if (d[i] < 0) {
d[i] = d[t] + 1;
q.push(i);
}
}
}
pair<int, int> res = {N, N};
for (int i : a) res = min(res, {d[i], i});
return res.second;
}
void clean() {
for (int i = 0; i < n + 1; i++) g[i].clear();
a.clear();
b.clear();
}
int ask(char c, int k) {
cout << c << " " << k << endl;
cin >> x;
if (x == -1) {
assert(0);
return (0);
}
return x;
}
int main() {
ios::sync_with_stdio(false);
cin >> t;
while (t--) {
clean();
cin >> n;
for (int i = 0; i < n - 1; i++) {
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
cin >> k1;
for (int i = 0; i < k1; i++) cin >> x, a.insert(x);
cin >> k2;
for (int i = 0; i < k2; i++) cin >> x, b.insert(x);
x = ask('B', *b.begin());
int k = bfs(x);
x = ask('A', k);
if (b.count(x))
cout << "C " << k << endl;
else
cout << "C -1" << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
const long double EPS = 1e-7;
vector<vector<long long> > g;
vector<long long> tin, tout;
long long cl = 0;
void dfs(long long v, long long p) {
tin[v] = ++cl;
for (long long to : g[v]) {
if (to != p) {
dfs(to, v);
}
}
tout[v] = ++cl;
}
void solve() {
long long n;
cin >> n;
g.clear();
g.resize(n);
tin.clear();
tin.resize(n);
tout.clear();
tout.resize(n);
for (long long i = 0; i < n - 1; ++i) {
long long a, b;
cin >> a >> b;
--a;
--b;
g[a].push_back(b);
g[b].push_back(a);
}
long long k1;
cin >> k1;
vector<long long> x(k1);
set<long long> set_x;
for (long long& it : x) {
cin >> it;
set_x.insert(it);
}
long long k2;
cin >> k2;
vector<long long> y(k2);
set<long long> set_y;
for (long long& it : y) {
cin >> it;
set_y.insert(it);
}
cout << "B " << y[0] << endl;
long long x_num;
cin >> x_num;
if (set_x.count(x_num)) {
cout << "C " << x_num << endl;
return;
}
cl = 0;
dfs(0, -1);
long long root = x[0];
for (long long v : x) {
if (tin[v - 1] < tin[root - 1]) {
root = v;
}
}
cout << "A " << root << endl;
long long res;
cin >> res;
if (set_y.count(res)) {
cout << "C " << root << endl;
return;
}
long long closest = -1;
for (long long v : x) {
if (tin[v - 1] < tin[x_num - 1] && tout[v - 1] > tout[x_num - 1]) {
if (closest == -1 || abs(tin[v - 1] - tin[x_num - 1]) <
abs(tin[closest - 1] - tin[x_num - 1])) {
closest = v;
}
}
}
if (closest != -1) {
cout << "A " << closest << endl;
cin >> res;
if (set_y.count(res)) {
cout << "C " << closest << endl;
return;
}
}
cout << "C " << -1 << endl;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
for (long long i = 0; i < t; ++i) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int>> g;
vector<int> used;
set<int> x, y;
int bfs(int v) {
fill(used.begin(), used.end(), 0);
queue<int> q;
q.push(v);
used[v] = 1;
while (q.size() > 0) {
v = q.front();
if (x.find(v) != x.end()) return v;
q.pop();
for (int to : g[v]) {
if (!used[to]) {
used[to] = 1;
q.push(to);
}
}
}
}
int main() {
int t;
cin >> t;
while (t--) {
int n, a, b, k;
cin >> n;
x.clear();
y.clear();
g.assign(n, vector<int>());
used.assign(n, 0);
for (int i = 0; i < n - 1; i++) {
cin >> a >> b;
a--;
b--;
g[a].push_back(b);
g[b].push_back(a);
}
cin >> k;
for (int i = 0; i < k; i++) {
cin >> a;
a--;
x.insert(a);
}
cin >> k;
for (int i = 0; i < k; i++) {
cin >> a;
a--;
y.insert(a);
}
b = *y.begin();
cout << "B " << b + 1 << "\n";
cin >> a;
a--;
if (x.find(a) != x.end()) {
cout << "C " << a + 1 << "\n";
continue;
}
a = bfs(a);
cout << "A " << a + 1 << "\n";
cin >> b;
b--;
if (y.find(b) != y.end()) {
cout << "C " << a + 1 << "\n";
continue;
}
cout << "C -1"
<< "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T, class R>
istream& operator>>(istream& in, pair<T, R>& p) {
in >> p.first >> p.second;
return in;
}
template <class T>
istream& operator>>(istream& in, vector<T>& v) {
for (auto& x : v) {
in >> x;
}
return in;
}
const long long int mx = 210005;
vector<long long int> a, b, v;
vector<vector<long long int> > g;
long long int n, k1, k2;
long long int findClosest(const long long int& x) {
v[x] = 1;
if (a[x]) {
return x;
}
for (const auto& nx : g[x]) {
if (!v[nx]) {
int vl;
if ((vl = findClosest(nx)) != -1) {
return vl;
}
}
}
return -1;
}
void read(long long int& x) {
cin >> x;
x--;
}
void print(const char& c, const long long int& x) {
cout << c << " " << x + 1 << endl;
cout.flush();
}
void testcase() {
cin >> n;
g.assign(n, vector<long long int>());
a.assign(n, 0);
b.assign(n, 0);
v.assign(n, 0);
for (long long int i = 0; i < (n - 1); i++) {
long long int x, y;
read(x);
read(y);
g[x].push_back(y);
g[y].push_back(x);
}
cin >> k1;
for (long long int i = 0; i < (k1); i++) {
long long int x;
read(x);
a[x] = 1;
}
cin >> k2;
long long int nd2, nd1;
for (long long int i = 0; i < (k2); i++) {
long long int x;
read(x);
b[x] = 1;
nd2 = x;
}
print('B', nd2);
read(nd1);
nd1 = findClosest(nd1);
print('A', nd1);
read(nd2);
if (b[nd2]) {
print('C', nd1);
} else {
cout << "C -1\n";
cout.flush();
}
return;
}
int main() {
ios_base::sync_with_stdio(0);
long long int t;
cin >> t;
while (t--) {
testcase();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
void yes() {
cout << "Yes"
<< "\n";
}
void no() {
cout << "No"
<< "\n";
}
struct Sync_stdio {
Sync_stdio() {
cin.tie(NULL);
ios_base::sync_with_stdio(false);
}
} _sync_stdio;
struct FAIL {
FAIL() {
cout << "CHANGE!!!"
<< "\n";
}
};
vector<vector<int>> g;
vector<int> cl;
vector<int> used;
vector<int> a;
vector<int> b;
void dfs(int x, int best = -1) {
used[x] = 1;
if (binary_search(a.begin(), a.end(), x)) {
best = x;
}
cl[x] = best;
for (auto y : g[x]) {
if (used[y]) {
continue;
}
dfs(y, best);
}
}
void solve() {
g.clear();
cl.clear();
used.clear();
int n;
cin >> n;
g.resize(n);
cl.resize(n);
used.resize(n);
for (int i = (0); i < (n - 1); ++i) {
int x, y;
cin >> x >> y;
--x, --y;
g[x].push_back(y);
g[y].push_back(x);
}
int m1;
cin >> m1;
a.resize(m1);
for (int __i = 0; __i < (m1); ++__i) cin >> a[__i];
;
sort(a.begin(), a.end());
for (auto& elem : a) {
--elem;
}
int m2;
cin >> m2;
b.resize(m2);
for (int __i = 0; __i < (m2); ++__i) cin >> b[__i];
;
sort(b.begin(), b.end());
for (auto& elem : b) {
--elem;
}
dfs(a[0]);
cout << "B " << b[0] + 1 << "\n";
cout.flush();
int value;
cin >> value;
--value;
if (binary_search(a.begin(), a.end(), value)) {
cout << "C " << value + 1 << "\n";
cout.flush();
return;
}
cout << "A " << cl[value] + 1 << "\n";
cout.flush();
int value2;
cin >> value2;
--value2;
if (binary_search(b.begin(), b.end(), value2)) {
cout << "C " << cl[value] + 1 << "\n";
cout.flush();
return;
}
cout << "C " << -1 << "\n";
cout.flush();
}
int main() {
int n;
cin >> n;
for (int i = (0); i < (n); ++i) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1100;
vector<int> g[maxn];
bool mine[maxn];
bool his[maxn];
bool used[maxn];
int dfs(int v, int pv = -1) {
if (used[v]) return -1;
used[v] = 1;
if (mine[v]) return v;
for (int u : g[v])
if (u != pv) {
int d = dfs(u, v);
if (d != -1) return d;
}
return -1;
}
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
for (int i = 0; i < maxn; ++i) {
g[i].clear();
mine[i] = 0;
his[i] = 0;
used[i] = 0;
}
for (int i = 1; i < n; ++i) {
int a, b;
cin >> a >> b;
g[a].push_back(b);
g[b].push_back(a);
}
int k, x;
cin >> k;
for (int i = 0; i < k; ++i) {
cin >> x;
mine[x] = 1;
}
cin >> k;
for (int i = 0; i < k; ++i) {
cin >> x;
his[x] = 1;
}
cout << "B " << x << endl;
cin >> x;
if (mine[x]) {
cout << "C " << x << endl;
continue;
}
int ft = dfs(x);
cout << "A " << ft << endl;
cin >> x;
cout << "C ";
if (his[x]) {
cout << ft << endl;
} else
cout << -1 << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
int t, n, a, b, k, c, G;
cin >> t;
vector<int> D[1000], T;
int A[1000], B[1000], g[1000], K[1000];
for (int i = 0; i < t; i++) {
cin >> n;
for (int y = 0; y < n; y++) {
A[y] = 0;
B[y] = 0;
g[y] = 1;
}
for (int y = 0; y < n - 1; y++) {
cin >> a >> b;
a--;
b--;
D[a].push_back(b);
D[b].push_back(a);
}
cin >> k;
for (int y = 0; y < k; y++) {
cin >> a;
a--;
A[a] = 1;
}
cin >> k;
for (int y = 0; y < k; y++) {
cin >> K[y];
K[y]--;
}
cout << "B " << K[0] + 1 << endl;
cin >> c;
c--;
T.push_back(c);
for (int y = 0; y < T.size(); y++) {
if (A[T[y]] == 1) {
cout << "A " << T[y] + 1 << endl;
cin >> c;
c--;
G = 0;
for (int u = 0; u < k; u++) {
if (K[u] == c) {
G = 1;
cout << "C " << T[y] + 1 << endl;
}
}
if (G == 0) {
cout << "C " << -1 << endl;
}
y = T.size() + 1;
} else {
for (int u = 0; u < D[T[y]].size(); u++) {
if (g[D[T[y]][u]] == 1) {
g[D[T[y]][u]] = 0;
T.push_back(D[T[y]][u]);
}
}
}
}
for (int y = 0; y < 1000; y++) {
D[y].clear();
}
T.clear();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class TH>
void _dbg(const char *sdbg, TH h) {
cerr << sdbg << "=" << h << "\n";
}
template <class TH, class... TA>
void _dbg(const char *sdbg, TH h, TA... a) {
while (*sdbg != ',') cerr << *sdbg++;
cerr << "=" << h << ",";
_dbg(sdbg + 1, a...);
}
const long long inf = 1000 * 1000 * 1000 + 7;
const long long INF = inf * inf;
const long long MOD = inf;
const long long N = 1e3 + 10, base = 1 << 18;
vector<long long> G[N];
bool moje[N];
bool vis[N];
void solve() {
long long n;
cin >> n;
for (long long i = (1); i <= (n); i++) {
G[i].clear();
moje[i] = false;
vis[i] = false;
}
for (long long i = ((0)); i <= ((n - 1) - 1); i++) {
long long a, b;
cin >> a >> b;
G[a].push_back(b);
G[b].push_back(a);
}
long long k1, k2;
cin >> k1;
for (long long i = ((0)); i <= ((k1)-1); i++) {
long long a;
cin >> a;
moje[a] = 1;
}
cin >> k2;
set<long long> jego;
for (long long i = ((0)); i <= ((k2)-1); i++) {
long long a;
cin >> a;
jego.insert(a);
}
cout << "B " << *jego.begin() << "\n";
cout.flush();
long long feed;
cin >> feed;
if (moje[feed]) {
cout << "C " << feed << "\n";
cout.flush();
return;
}
queue<long long> q;
q.push(feed);
long long najblizsze;
while (true) {
long long x = q.front();
q.pop();
vis[x] = true;
if (moje[x]) {
najblizsze = x;
break;
}
for (long long i : G[x])
if (!vis[i]) q.push(i);
}
cout << "A " << najblizsze << "\n";
cout.flush();
cin >> feed;
if (jego.find(feed) != jego.end())
cout << "C " << najblizsze << "\n";
else
cout << "C -1\n";
cout.flush();
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cerr.tie(0);
cout << setprecision(9) << fixed;
cerr << setprecision(6) << fixed;
long long test = 1;
cin >> test;
while (test--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> used;
vector<vector<int>> g;
vector<int> check;
long long close;
void dfs(int v) {
if (check[v] == 1 && close == -1) {
close = v;
}
used[v] = 1;
for (int i = 0; i < g[v].size(); i++) {
if (used[g[v][i]] == 0) {
dfs(g[v][i]);
}
}
}
int main() {
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
for (int u = 0; u < t; u++) {
used.clear();
g.clear();
check.clear();
close = -1;
long long int n, ans = -1;
;
vector<int> h;
cin >> n;
for (int i = 0; i <= n; i++) {
g.push_back(h);
check.push_back(0);
used.push_back(0);
}
for (int i = 0; i < n - 1; i++) {
int x, y;
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
int k1;
cin >> k1;
for (int i = 0; i < k1; i++) {
int z;
cin >> z;
check[z] = 1;
}
int k2;
cin >> k2;
vector<int> his;
for (int i = 0; i < k2; i++) {
int z;
cin >> z;
his.push_back(z);
}
cout << "B " << his[0] << endl;
int num;
cin >> num;
if (check[num] == 1) {
ans = num;
}
if (ans == -1) {
dfs(num);
cout << "A " << close << endl;
int y;
cin >> y;
for (int i = 0; i < his.size(); i++) {
if (his[i] == y) ans = close;
}
}
cout << "C " << ans << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long power(long long x, long long p, long long MOD) {
if (p == 0) return 1 % MOD;
if (p == 1) return x % MOD;
long long res = power(x, p / 2, MOD);
res = (long long)res * res % MOD;
if (p & 1) res = (long long)res * x % MOD;
return res;
}
const long long N = 1005;
vector<long long> adj[N];
set<long long> s[2];
long long color[N];
void dfs(long long u, long long p) {
if (s[0].count(u))
color[u] = u;
else
color[u] = color[p];
for (long long v : adj[u])
if (v != p) dfs(v, u);
}
long long ask_mine(long long x) {
cout << "A " << x << endl;
long long res;
cin >> res;
return res;
}
long long ask_his(long long x) {
cout << "B " << x << endl;
long long res;
cin >> res;
return res;
}
void solve() {
long long n;
cin >> n;
for (long long i = 0; i < 2; i++) s[i].clear();
for (long long i = 1; i <= n; i++) adj[i].clear();
for (long long i = 1; i < n; i++) {
long long a, b;
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
}
for (long long i = 0; i < 2; i++) {
long long k;
cin >> k;
for (long long j = 0; j < k; j++) {
long long x;
cin >> x;
s[i].insert(x);
}
}
dfs(*s[0].begin(), -1);
long long u = ask_his(*s[1].begin());
long long v = ask_mine(color[u]);
if (s[1].count(v))
cout << "C " << color[u] << endl;
else
cout << "C -1" << endl;
}
int32_t main() {
long long t;
cin >> t;
while (t--) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> tree[1010];
bool vis[1010];
bool kk1[1010];
bool kk2[1010];
vector<int> vk1;
vector<int> vk2;
int k1, k2;
int main() {
int t;
cin >> t;
while (t--) {
for (int i = 0; i < 1010; i++) tree[i].clear();
memset(kk1, 0, sizeof kk1);
memset(kk2, 0, sizeof kk2);
memset(vis, 0, sizeof vis);
vk1.clear();
vk2.clear();
int n;
cin >> n;
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
tree[a].push_back(b);
tree[b].push_back(a);
}
cin >> k1;
for (int i = 0; i < k1; i++) {
int x;
cin >> x;
kk1[x] = true;
vk1.push_back(x);
}
cin >> k2;
for (int i = 0; i < k2; i++) {
int x;
cin >> x;
kk2[x] = true;
vk2.push_back(x);
}
cout << "B " << vk2[0] << endl;
cout.flush();
int start;
cin >> start;
int end = -1;
queue<int> bfs;
vis[start] = true;
bfs.push(start);
while (!bfs.empty() && end == -1) {
int nxt = bfs.front();
bfs.pop();
if (kk1[nxt]) {
end = nxt;
break;
}
for (int i = 0; i < tree[nxt].size(); i++) {
int vtx = tree[nxt][i];
if (vis[vtx]) continue;
if (kk1[vtx]) {
end = vtx;
break;
}
vis[vtx] = true;
bfs.push(vtx);
}
}
cout << "A " << end << endl;
cout.flush();
int show;
cin >> show;
if (kk2[show]) {
cout << "C " << end << endl;
} else {
cout << "C " << -1 << endl;
}
cout.flush();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> v[1005];
int col1[1005];
int col2[1005];
int vis[1005];
int main() {
int t;
scanf("%d", &t);
while (t--) {
int i, j, k, l, n;
scanf("%d", &n);
for (i = 0; i <= n; i++) {
v[i].clear();
col1[i] = 0;
col2[i] = 0;
vis[i] = 0;
}
int m = n - 1;
while (m--) {
scanf("%d%d", &i, &j);
v[i].push_back(j);
v[j].push_back(i);
}
int k1, k2;
scanf("%d", &k1);
for (i = 0; i < k1; i++) {
scanf("%d", &j);
col1[j] = 1;
}
scanf("%d", &k2);
int x;
for (i = 0; i < k2; i++) {
scanf("%d", &j);
col2[j] = 2;
x = j;
}
printf("B %d\n", x);
fflush(stdout);
scanf("%d", &x);
if (col1[x] == 1) {
printf("C %d\n", x);
fflush(stdout);
} else {
queue<int> q;
q.push(x);
while (!q.empty()) {
i = q.front();
q.pop();
if (vis[i] == 1) continue;
vis[i] = 1;
if (col1[i] == 1) {
x = i;
break;
}
for (auto pk : v[i]) {
if (vis[pk] == 1) continue;
q.push(pk);
}
}
printf("A %d\n", x);
fflush(stdout);
scanf("%d", &i);
if (col2[i] == 2)
printf("C %d\n", x);
else
printf("C -1\n");
fflush(stdout);
}
}
}
|
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
template <typename T>
void showArray(const T *arr, int sz) {
for (int i = 0; i < sz; ++i) {
cout << arr[i] << ' ';
}
cout << endl;
}
int readInt() {
int ret = 0, k = 1;
char c = getchar();
if (c == '-') {
k = -1;
} else {
ret = c - '0';
}
c = getchar();
while (c != ' ' && c != '\n') {
ret = ret * 10 + c - '0';
c = getchar();
}
return k * ret;
}
const bool debug = false;
const int MAXN = 1e3 + 5, INF = 1e9;
const double pi = acos(-1);
int t, n, k1, k2, x[MAXN], y[MAXN];
vector<int> g[MAXN];
bool used[MAXN];
bool findx(int v) {
int p = lower_bound(x, x + k1, v) - x;
return p < k1 && x[p] == v;
}
bool findy(int v) {
int p = lower_bound(y, y + k2, v) - y;
return p < k2 && y[p] == v;
}
int dfs(int v) {
used[v] = true;
if (findx(v)) {
return v;
}
for (auto &to : g[v]) {
if (!used[to]) {
int ret = dfs(to);
if (ret != -1) return ret;
}
}
return -1;
}
void solve() {
int z, ansx, ansy;
printf("B %d\n", y[0] + 1);
fflush(stdout);
scanf("%d", &z);
--z;
ansx = dfs(z);
printf("A %d\n", ansx + 1);
fflush(stdout);
scanf("%d", &ansy);
--ansy;
if (findy(ansy)) {
printf("C %d\n", ansx + 1);
fflush(stdout);
return;
}
printf("C -1\n");
fflush(stdout);
}
int main() {
scanf("%d", &t);
while (t--) {
scanf("%d", &n);
for (int i = 0, v, u; i < n - 1; ++i) {
scanf("%d %d", &v, &u);
--v, --u;
g[v].emplace_back(u);
g[u].emplace_back(v);
}
scanf("%d", &k1);
memset(x, 255, sizeof(int) * MAXN);
for (int i = 0; i < k1; ++i) {
scanf("%d", &x[i]);
--x[i];
}
sort(x, x + k1);
scanf("%d", &k2);
memset(y, 255, sizeof(int) * MAXN);
for (int i = 0; i < k2; ++i) {
scanf("%d", &y[i]);
--y[i];
}
sort(y, y + k2);
memset(used, 0, sizeof(bool) * MAXN);
solve();
for (int i = 0; i < n; ++i) {
g[i].clear();
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> g[1000 + 1];
bool seen[1000 + 1];
set<int> a, b;
int dfs(int u) {
int ans, v, i;
if (a.count(u)) {
return u;
}
seen[u] = true;
ans = 0;
for (i = 0; i < (int)g[u].size(); i++) {
v = g[u][i];
if (!seen[v]) {
ans = dfs(v);
if (ans != 0) {
return ans;
}
}
}
return ans;
}
int main() {
int t, n, k, u, v, i;
scanf("%d", &t);
while (t--) {
scanf("%d", &n);
for (i = 1; i <= n - 1; i++) {
scanf("%d%d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
}
scanf("%d", &k);
for (i = 1; i <= k; i++) {
scanf("%d", &u);
a.insert(u);
}
scanf("%d", &k);
for (i = 1; i <= k; i++) {
scanf("%d", &u);
b.insert(u);
}
printf("B %d\n", *b.begin());
fflush(stdout);
scanf("%d", &u);
if (a.count(u)) {
printf("C %d\n", u);
fflush(stdout);
} else {
u = dfs(u);
printf("A %d\n", u);
fflush(stdout);
scanf("%d", &v);
if (b.count(v)) {
printf("C %d\n", u);
fflush(stdout);
} else {
printf("C -1\n");
fflush(stdout);
}
}
for (u = 1; u <= n; u++) {
g[u].clear();
}
memset(seen, false, sizeof(seen));
a.clear();
b.clear();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> graf[1005];
bool visited[1005];
bool moje[1005], njegovo[1005];
long long s1[1005], s2[1005], n;
long long aska(long long x) {
cout << "A " << x << endl;
long long ret;
cin >> ret;
return ret;
}
long long askb(long long y) {
cout << "B " << y << endl;
long long ret;
cin >> ret;
return ret;
}
void resi(long long ans) { cout << "C " << ans << endl; }
long long bfs(long long x) {
queue<long long> q;
for (long i = 1; i <= n; i++) {
visited[i] = 0;
}
q.push(x);
while (!q.empty()) {
long long u = q.front();
q.pop();
if (visited[u]) {
continue;
}
visited[u] = 1;
if (moje[u]) {
return u;
}
for (auto f : graf[u]) {
if (!visited[f]) {
q.push(f);
}
}
}
return -1;
}
int main() {
ios_base::sync_with_stdio(false);
long long t, a, b, k1, k2;
cin >> t;
while (t--) {
cin >> n;
for (long i = 1; i <= n; i++) {
graf[i].clear();
moje[i] = njegovo[i] = 0;
}
for (long i = 1; i < n; i++) {
cin >> a >> b;
graf[a].push_back(b);
graf[b].push_back(a);
}
cin >> k1;
for (long i = 1; i <= k1; i++) {
cin >> s1[i];
moje[s1[i]] = 1;
}
cin >> k2;
for (long i = 1; i <= k2; i++) {
cin >> s2[i];
njegovo[s2[i]] = 1;
}
long long prvi = askb(s2[1]);
long long drugi = bfs(prvi);
long long treci = aska(drugi);
if (njegovo[treci]) {
resi(drugi);
} else {
resi(-1);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct STUFF {
int64_t a, b, c, d;
STUFF(int64_t q = -1, int64_t w = -1, int64_t e = -1, int64_t r = -1)
: a(q), b(w), c(e), d(r) {}
};
int64_t mod = 1e8, inf = 4e18;
int64_t sum = 0;
int64_t tmp3 = 0, tmp = 0, tmp2 = 0, comb = 1;
vector<int64_t> check, st, st2;
int64_t maxi = 0, mini = inf;
vector<vector<int64_t> > g;
bool high = 0;
int64_t n, m, t;
int64_t logn = 1;
set<int64_t> t1;
void dfs(int64_t cur, vector<int64_t>& last, int64_t fill) {
check[cur] = 1;
if (t1.find(cur) != t1.end()) fill = cur;
last[cur] = fill;
for (auto v : g[cur]) {
if (!check[v]) dfs(v, last, fill);
}
}
int32_t main() {
ios::sync_with_stdio(false), cin.tie(nullptr);
cout << fixed << setprecision(0);
cin >> t;
for (int64_t k1, k2; t--;) {
cin >> n;
g.clear();
g.resize(n);
for (int64_t i = 0; i < n - 1; i++) {
cin >> tmp >> tmp2;
tmp -= 1, tmp2 -= 1;
g[tmp].push_back(tmp2);
g[tmp2].push_back(tmp);
}
cin >> k1;
t1.clear();
for (int64_t i = 0; i < k1; i++) {
cin >> tmp;
t1.insert(tmp - 1);
}
cin >> k2;
set<int64_t> t2;
for (int64_t i = 0; i < k2; i++) cin >> tmp, t2.insert(tmp - 1);
vector<int64_t> last(n);
check.clear(), check.resize(n, 0);
dfs(*t1.begin(), last, *t1.begin());
cout << "B " << *t2.begin() + 1 << endl;
fflush(stdout);
int64_t val;
cin >> val;
val -= 1;
cout << "A " << last[val] + 1 << endl;
fflush(stdout);
int64_t res = last[val] + 1;
cin >> val;
val -= 1;
if (t2.find(val) != t2.end())
cout << "C " << res << endl;
else
cout << "C " << -1 << endl;
fflush(stdout);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> adjlist[1005];
long long vis[1005], nearest;
map<long long, long long> m1, m2;
void dfs(long long node) {
vis[node] = 1;
for (auto i : adjlist[node]) {
if (vis[i] == 2) {
nearest = i;
return;
} else if (!vis[i]) {
dfs(i);
}
}
}
void clall() {
for (long long i = 0; i < 1005; ++i) adjlist[i].clear();
memset(vis, 0, sizeof vis);
m1.clear();
m2.clear();
}
void aska(long long node) {
cout << "A " << node << '\n';
fflush(stdout);
}
void askb(long long node) {
cout << "B " << node << '\n';
fflush(stdout);
}
void answer(long long node) {
cout << "C " << node << '\n';
fflush(stdout);
}
void solve() {
clall();
nearest = -1;
long long n;
cin >> n;
for (long long i = 0; i < n - 1; ++i) {
long long x, y;
cin >> x >> y;
adjlist[x].push_back(y);
adjlist[y].push_back(x);
}
long long k1, k2;
cin >> k1;
for (long long i = 0; i < k1; ++i) {
long long node;
cin >> node;
vis[node] = 2;
m1[node]++;
}
cin >> k2;
for (long long i = 0; i < k2; ++i) {
long long node;
cin >> node;
m2[node]++;
}
askb(m2.begin()->first);
long long resp;
cin >> resp;
if (m1[resp]) {
answer(resp);
return;
}
dfs(resp);
aska(nearest);
cin >> resp;
if (m2[resp])
answer(nearest);
else
answer(-1);
}
signed main() {
long long t = 1;
cin >> t;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1010;
vector<int> v[N];
bool vis1[N], vis2[N];
int dfs2(int x, int p) {
if (vis1[x]) return x;
int ans = 0;
for (int y : v[x]) {
if (y != p) ans = dfs2(y, x);
if (ans) return ans;
}
return 0;
}
int main() {
int t;
cin >> t;
while (t--) {
int n, x, y, z;
cin >> n;
for (int i = 1; i <= n; i++) v[i].clear();
for (int i = 1; i < n; i++) {
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
for (int i = 0; i <= n; i++) vis1[i] = vis2[i] = 0;
int k1, k2;
cin >> k1;
for (int i = 1; i <= k1; i++) {
cin >> x;
vis1[x] = 1;
}
cin >> k2;
for (int i = 1; i <= k2; i++) {
cin >> x;
vis2[x] = 1;
}
cout << "B " << x << "\n";
flush(cout);
cin >> y;
z = dfs2(y, 0);
if (z) {
cout << "A " << z << "\n";
flush(cout);
cin >> y;
if (!vis2[y]) z = 0;
}
if (z)
cout << "C " << z << "\n";
else
cout << "C -1"
<< "\n";
flush(cout);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using dbl = double;
const int N = 1010;
int n;
vector<int> go[N];
vector<int> vs1, vs2;
vector<int> readV() {
int sz;
cin >> sz;
vector<int> res(sz);
for (auto& x : res) {
cin >> x;
--x;
}
return res;
}
int ask1(int v) {
cout << "A " << v + 1 << endl;
int u;
cin >> u;
--u;
return u;
}
int ask2(int v) {
cout << "B " << v + 1 << endl;
int u;
cin >> u;
--u;
return u;
}
int hs[N];
void dfs(int v, int p) {
for (auto u : go[v]) {
if (u == p) continue;
hs[u] = hs[v] + 1;
dfs(u, v);
}
}
void solve1() {
cin >> n;
for (int i = 0; i < n; ++i) {
go[i].clear();
}
for (int i = 0; i < n - 1; ++i) {
int a, b;
cin >> a >> b;
--a, --b;
go[a].push_back(b);
go[b].push_back(a);
}
vs1 = readV();
vs2 = readV();
auto r = ask2(vs2[0]);
hs[r] = 0;
dfs(r, -1);
int best = vs1[0];
for (auto x : vs1)
if (hs[x] < hs[best]) best = x;
auto y = ask1(best);
if (find(vs2.begin(), vs2.end(), y) == vs2.end()) {
cout << "C " << -1 << endl;
} else {
cout << "C " << best + 1 << endl;
}
}
void solve() {
int T;
cin >> T;
while (T--) solve1();
}
int main() {
solve();
(void)0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1231231234;
const int MOD = 1000000007;
const double EPS = 1e-8;
struct edge {
int to;
};
int firstHit(vector<vector<edge>> &g, vector<int> &mine, int curr, int lim,
int dist = 0, int prev = -1) {
if (binary_search(mine.begin(), mine.end(), curr)) {
return curr;
} else if (dist == lim)
return -1;
for (edge e : g[curr])
if (e.to != prev) {
auto possible = firstHit(g, mine, e.to, lim, dist + 1, curr);
if (possible != -1) return possible;
}
return -1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int T;
cin >> T;
while (T--) {
int n;
cin >> n;
vector<vector<edge>> g(n);
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
--a, --b;
g[a].push_back({b});
g[b].push_back({a});
}
int k1;
cin >> k1;
vector<int> mine(k1);
for (int i = 0; i < k1; i++) {
cin >> mine[i];
--mine[i];
}
sort(mine.begin(), mine.end());
int k2;
cin >> k2;
vector<int> others(k2);
for (int i = 0; i < k2; i++) {
cin >> others[i];
--others[i];
}
sort(others.begin(), others.end());
cout << "B " << others[0] + 1 << endl;
int myLabel;
cin >> myLabel;
if (myLabel == -1) exit(0);
--myLabel;
if (binary_search(mine.begin(), mine.end(), myLabel)) {
cout << "C " << myLabel + 1 << endl;
} else {
int check = firstHit(g, mine, myLabel, k2);
if (check == -1) {
cout << "C -1" << endl;
} else {
cout << "A " << check + 1 << endl;
int hisLabel;
cin >> hisLabel;
if (hisLabel == -1) exit(0);
--hisLabel;
if (binary_search(others.begin(), others.end(), hisLabel)) {
cout << "C " << check + 1 << endl;
} else {
cout << "C -1" << endl;
}
}
}
}
}
|
#include <bits/stdc++.h>
class TaskD {
public:
void solve(std::istream& in, std::ostream& out) {
int t;
in >> t;
for (int caseNo = 0; caseNo < t; ++caseNo) {
int n;
in >> n;
std::vector<std::vector<int> > tree(n);
for (int i = 0; i < n - 1; ++i) {
int a, b;
in >> a >> b;
a--;
b--;
tree[a].push_back(b);
tree[b].push_back(a);
}
int k1;
in >> k1;
std::set<int> my;
for (int i = 0; i < k1; ++i) {
int a;
in >> a;
a--;
my.insert(a);
}
int k2;
in >> k2;
std::set<int> his;
for (int i = 0; i < k2; ++i) {
int a;
in >> a;
a--;
his.insert(a);
}
int witness = *(his.begin());
out << "B " << witness + 1 << "\n";
out.flush();
int my_witness;
in >> my_witness;
my_witness--;
if (my.find(my_witness) != my.end()) {
out << "C " << my_witness + 1 << "\n";
out.flush();
continue;
}
std::queue<int> q;
std::vector<int> visited(n, 0);
q.push(my_witness);
visited[my_witness] = 1;
int v;
while (!q.empty()) {
v = q.front();
q.pop();
if (my.find(v) != my.end()) {
break;
}
for (int j = 0; j < (int)tree[v].size(); ++j) {
int u = tree[v][j];
if (visited[u] == 0) {
visited[u] = 1;
q.push(u);
}
}
}
out << "A " << v + 1 << "\n";
out.flush();
int hisV;
in >> hisV;
hisV--;
if (his.find(hisV) != his.end()) {
out << "C " << v + 1 << "\n";
out.flush();
} else {
out << "C " << -1 << "\n";
out.flush();
}
}
}
};
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(NULL);
std::cout << std::fixed;
std::cout << std::setprecision(15);
TaskD solver;
std::istream& in(std::cin);
std::ostream& out(std::cout);
solver.solve(in, out);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const long long inf = 4e18 + 5;
long long gcd(long long x, long long y) {
while (y) x %= y, swap(x, y);
return x;
}
pair<long long, long long> operator+(pair<long long, long long> a,
pair<long long, long long> b) {
return pair<long long, long long>(a.first + b.first, a.second + b.second);
}
pair<long long, long long> operator-(pair<long long, long long> a,
pair<long long, long long> b) {
return pair<long long, long long>(a.first - b.first, a.second - b.second);
}
long long operator*(pair<long long, long long> a,
pair<long long, long long> b) {
return a.first * b.second - a.second * b.first;
}
template <class T>
int sign(T x) {
return x < 0 ? -1 : x > 0 ? 1 : 0;
}
int ccw(pair<long long, long long> a, pair<long long, long long> b,
pair<long long, long long> c) {
return sign((b - a) * (c - b));
}
template <class T>
void setmin(T &x, T y) {
if (x > y) x = y;
}
template <class T>
void setmax(T &x, T y) {
if (x < y) x = y;
}
template <class T>
void addval(T &x, T y) {
x += y;
x %= mod;
}
vector<int> edge[1005];
int chx[1005], chy[1005];
int dfs(int x, int p) {
if (chx[x]) return x;
for (int i : edge[x]) {
if (i == p) continue;
int ret = dfs(i, x);
if (ret != -1) return ret;
}
return -1;
}
void solve() {
int n, k1, k2;
cin >> n;
for (int i = 1; i <= n; i++) {
edge[i].clear();
chx[i] = chy[i] = 0;
}
for (int i = 0; i < n - 1; i++) {
int x, y;
cin >> x >> y;
edge[x].push_back(y);
edge[y].push_back(x);
}
cin >> k1;
int xn, yn;
for (int i = 0; i < k1; i++) {
int x;
cin >> x;
xn = x;
chx[x] = 1;
}
cin >> k2;
for (int i = 0; i < k2; i++) {
int x;
cin >> x;
yn = x;
chy[x] = 1;
}
cout << "B " << yn << endl;
int ynx;
cin >> ynx;
if (chx[ynx])
cout << "C " << ynx << endl;
else {
int ret = dfs(ynx, 0);
cout << "A " << ret << endl;
int lst;
cin >> lst;
if (chy[lst])
cout << "C " << ret << endl;
else
cout << "C -1" << endl;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int T;
cin >> T;
while (T--) solve();
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.