【总结】BalticOI 2021 Day1
T1
有一个未知的长度为 \(N\) 的单调上升序列 \(X\)，每次可以询问一个位置上的数，给定常数 \(A\)，需要找到 \(K\) 个数使得 这些数之和在区间 \([A,2A]\) 中。最多询问 \(40\) 次，\(N\le 10^5, 3\le K\le 10\)
比较好的思维题。
首先我们需要找到第一个 \(\ge A\) 的位置。显然不会选这个位置后面的数。因为如果选了后面的某个数，将其替换为当前数一定更优。如果选了后面两个及以上的数，和已经 \(>2A\) 了。
所以先判断第一个大于 \(A\) 的数和最小的 \(K - 1\) 个数之和是否 \(\le 2A\)。
接下我们考虑所有 \(<A\) 的数，我们先找出最小的 \(K\) 个数和，每次将一个数替换成未选的 \(<A\) 中最大的数并判断是否满足条件即可。
因为每替换一次和的改变量 \(<A\)，所以一定是正确的。
typedef long long LL;
LL u[15];
void check(int n, int K, LL A){
LL s = 0;
rep(i, 1, K)s += u[i];
if(s > 2 * A){impossible();return ;}
if(s >= A){
vector<int>ans;
rep(i, 1, K)ans.pb(i);
answer(ans); return ;
}
pre(i, K, 1){
s -= u[i];
s += skim(n - i + 1);
if(s >= A){
vector<int>ans;
rep(j, 1, i - 1)ans.pb(j);
rep(j, 1, K - i + 1)ans.pb(n - j + 1);
answer(ans); return ;
}
}
impossible();
}
void solve(int N, int K, LL A, int S) {
int l = 1, r = N, ed = 0;
while(l <= r){
int mid = (l + r) >> 1;
if(skim(mid) >= A)ed = mid, r = mid - 1;
else l = mid + 1;
}
rep(i, 1, K)u[i] = skim(i);
if(!ed)check(N, K, A);
else if(ed < K)impossible();
else {
LL ss = 0;
rep(i, 1, K - 1)ss += u[i];
if(ss + skim(ed) <= 2 * A){
vector<int>ans;
rep(i, 1, K - 1)ans.pb(i);
ans.pb(ed);
answer(ans); return ;
}
if(ed > K)check(ed - 1, K, A);
else impossible();
}
}
T2
很神的 DS 题。
首先考虑 \(Q\) 询问。经过转化，等价于查询 \(d\to a\) 的路径上的数是否单调递增，且所有数都小于给定值。
直接树上倍增可以做到 \(\mathcal{O}(N\log N)\)。
考虑 \(C\) 询问，等价于询问从 \(a\) 出发能到达的点数。
如果 \(C\) 询问在所有 \(S\) 之后，那么整个问题是个静态问题，可以直接动态规划，状态为 \(f_{i,j}\) 表示从与 \(i\) 相连的点中第 \(j\) 大的边进入 \(i\)，可达的点数。时间复杂度 \(\mathcal{O}(N)\)。
#define N 240005
int n, k;
vector<Pr>e[N];
struct node{
int op, x, y;
}a[N];
int d[N], f[N][17], t, p[2][N][17], u[N], dfn[N], idx, sz[N];
void dfs(int x,int fa){
d[x] = d[f[x][0] = fa] + 1, dfn[x] = ++idx, sz[x] = 1;
rp(i, t)f[x][i] = f[f[x][i - 1]][i - 1];
go(y, e[x])if(y.se != fa)u[y.se] = y.fi, dfs(y.se, x), sz[x] += sz[y.se];
}
void init(int x,int fa){
p[0][x][0] = (u[x] < u[fa]), p[1][x][0] = (u[x] > u[fa]);
rp(i, t){
p[0][x][i] = p[0][x][i - 1] & p[0][f[x][i - 1]][i - 1];
p[1][x][i] = p[1][x][i - 1] & p[1][f[x][i - 1]][i - 1];
}
go(y, e[x])if(y.se != fa)init(y.se, x);
}
inline bool ck(int x,int y){return dfn[x] <= dfn[y] && dfn[x] + sz[x] > dfn[y];}
bool check(int x,int y,int lim){
if(x == y)return true;
int op = 0;
if(d[x] < d[y])op ^= 1, swap(x, y);
if(ck(y, x)){
if(op && u[x] > lim)return false;
pre(i, t, 0)if(d[f[x][i]] > d[y]){
if(!p[op][x][i])return false;
x = f[x][i];
}
if(!op && u[x] > lim)return false;
return true;
}
else{
if(op && u[x] > lim)return false;
if(!op && u[y] > lim)return false;
pre(i, t, 0)if(d[f[x][i]] >= d[y]){
if(!p[op][x][i])return false;
x = f[x][i];
}
pre(i, t, 0)if(f[x][i] != f[y][i]){
if(!p[op][x][i] || !p[op ^ 1][y][i])return false;
x = f[x][i], y = f[y][i];
}
return (u[x] < u[y]) ^ op;
}
}
vector<int>g[N];
int solve(int x, int y){
if(~g[x][y])return g[x][y];
g[x][y] = 1;
if(y < si(e[x])){
int w = e[x][y].se;
int cur = lower_bound(e[w].begin(), e[w].end(), mp(e[x][y].fi, x)) - e[w].begin();
g[x][y] += solve(w, cur + 1) + solve(x, y + 1) - 1;
}
return g[x][y];
}
int main() {
//int T = read();while(T--)solve();
n = read(), k = read(), t = log2(n);
rp(i, n + k - 1){
char op[2];
scanf("%s", op);
if('S' == *op){
int x = read(), y = read();
e[x].pb(mp(i, y)), e[y].pb(mp(i, x));
}
else if('Q' == *op) a[i].op = 1, a[i].x = read(), a[i].y = read();
else a[i].op = 2, a[i].x = read();
}
rp(i, n){
sort(e[i].begin(), e[i].end());
rep(j, 0, si(e[i]))g[i].pb( ~0 );
}
dfs(1, 0), init(1, 0);
rp(i, n + k - 1)
if(1 == a[i].op){
if(check(a[i].y, a[i].x, i))puts("yes");
else puts("no");
}
else if(2 == a[i].op)printf("%d\n", solve(a[i].x, 0));
return 0;
}
但是 \(C\) 的询问是实时的，所以需要考虑更好的方法。
如果我们直接按题意模拟，就是 \(\mathcal{O}(N^2)\) 的。由于我们只用记录当前节点 \(x\) 是否有数据 \(y\)，可以 bitset 优化到 \(\mathcal{O}(\dfrac{N^2}{64})\)。
进一步观察不难发现这就是线段树合并的过程，所以我们直接可持久化线段树合并即可。对于 \(C\) 询问，我们离线后倒着做，线段树上第 \(i\) 个位置表示最大标号为 \(i\) 的路径是否可达。时间和空间复杂度都是 \(\mathcal{O}(N\log N)\)。
有一个无脑但难写的做法，直接点分治加树状数组维护，时间复杂度是 \(\mathcal{O}(N\log^2N)\)。
#define N 120005
int n, k, ans[N], tot, rt[N]; Pr e[N], u[N];
struct node{int l, r, sum;}a[N << 6];
#define ls a[x].l
#define rs a[x].r
int ins(int y,int l,int r,int pos){
int x = ++tot; a[x] = a[y];
if(l == r){a[x].sum++; return x;}
else{
int mid = (l + r) >> 1;
if(mid >= pos)a[x].l = ins(a[y].l, l, mid, pos);
else a[x].r = ins(a[y].r, mid + 1, r, pos);
a[x].sum = a[ls].sum + a[rs].sum;
return x;
}
}
int merge(int x,int y,int l,int r){
if(!x || !y)return x | y;
int p = ++tot, mid = (l + r) >> 1;
a[p].sum = a[x].sum + a[y].sum;
if(l == r)return p;
a[p].l = merge(a[x].l, a[y].l, l, mid);
a[p].r = merge(a[x].r, a[y].r, mid + 1, r);
return p;
}
int ask(int x,int l,int r,int pos){
if(l == r)return a[x].sum;
int mid = (l + r) >> 1;
if(mid >= pos)return ask(ls, l, mid, pos);
return ask(rs, mid + 1, r, pos);
}
int calc(int x,int L,int R,int l,int r){
if(l > r)return 0;
if(L >= l && R <= r)return a[x].sum;
int mid = (L + R) >> 1, sum = 0;
if(mid >= l)sum += calc(ls, L, mid, l, r);
if(mid < r)sum += calc(rs, mid + 1, R, l, r);
return sum;
}
int main() {
//int T = read();while(T--)solve();
n = read(), k = read();
int p = 0, q = 0;
rp(i, n)rt[i] = ins(0, 1, n, i);
rp(i, n + k - 1){
char op[2];
scanf("%s", op);
if('S' == *op){
int x = read(), y = read();
e[++p] = mp(x, y);
rt[y] = rt[x] = merge(rt[x], rt[y], 1, n);
}
else if('Q' == *op){
int x = read(), y = read();
ans[++q] = ask(rt[x], 1, n, y);
}
else{
ans[++q] = ~0;
u[q] = mp(read(), p);
}
}
rp(i, n)rt[i] = 0;
pr(i, p){
int x = e[i].fi, y = e[i].se;
rt[x] = merge(rt[x], rt[y], 1, n);
rt[y] = rt[x] = ins(rt[x], 1, n, i);
}
rp(i, k){
if(~ans[i])puts(ans[i] ? "yes" : "no");
else printf("%d\n", 1 + calc(rt[u[i].fi], 1, n, 1, u[i].se));
}
return 0;
}
