省集
好像这篇有点咕咕咕了。
二轮省集
感受到了和别人的差距。
Day 0
还没写。
Day 1
T1 最优化题
显然是一个基环树森林,如果不加修改操作,显然让 \(t\) 充分大使得所有点都走到了环上,此时取环上出现次数最多的点即可,我们可以按照每个点走到环上对应的点编号分组,类似按照 \(\bmod\) 环长分组,最大的一组就是答案。
修改 \(k\) 条出边后,一种想法是肯定能取到前 \(k\) 大连通块大小之和,考虑先钦定其中一个连通块 \(x\),将 \(x\) 环上的一个点变成自环,于是所有 \(x\) 连通块的点都能停在这个点;再用 \(k-1\) 次把剩下的 \(k-1\) 个连通块合并上来即可。
剩下的情况,显然是合并 \(k+1\) 个连通块所取到的答案。
我们钦定把其余连通块合并到连通块 \(C_{k+1}\) 上,设 \(C_{k+1}\) 的环长为 \(l\),现在把 \(C_1,C_2\dots C_k\) 合并上来,需要算每个连通块的贡献,设 \(x\) 连通块贡献为 \(f(x)\)。
首先考虑一定断掉环上的点,考虑断掉 \((u,a_u)\),则能产生贡献的是能到达 \(a_u\) 的点,显然所有点最终会到达环上,因此取环上某个点不劣。
我们发现把 \(x\) 连通块按照 \(\bmod {l}\) 分组染色后,贡献一定能取到最大的那个。考虑我们可以任意选择把这个连通块接到 \(C_{k+1}\) 的环上哪个点上,也就是我们可以给 \(C_{x}\) 的每个点颜色 \(+v (v\in [0,l - 1])\),于是我们能够取到这个最大值。
于是问题变成以下几步:
- 找到一个连通块 \(C_x\) 不动,把其它连通块合并上来,计算 \(x\) 连通块染色后最多的点数 \(g(x)\)。
- 计算每个连通块 \(C_y\) 断开一条边按照 \(\bmod l_x\) 染色,最大的颜色贡献 \(f(y)\)。
- 对于 \(k \in [0,n)\) 更新答案,即取前 \(k\) 大的 \(f(x)\)。
直接做这个东西复杂度是 \(O(n^3)\) 的,因为我们计算 \(f(x)\) 需要枚举断掉哪条边并 \(O(|C|)\) 计算贡献。
考虑如何加速计算的过程,假设一个环为 \(h_1,h_2\dots h_l\),假如断掉 \((h_l,h_1)\),则换上一点 \(u\) 挂着的子树内距离 \(u\) 为 \(d\) 的点颜色为 \(l - u + d \bmod l\)。当变化为断掉 \((h_1,h_2)\) 时,对于 \(h_2,h_3\dots h_l\),其颜色增加了 \(+1\) 的偏移量,只有 \(h_1\) 处由 \(l - 1 + d\) 变为了 \(d\),重新计算其贡献即可,每个子树只会被重算一次,算一个连通块贡献复杂度为 \(O(|C|)\),优化到了 \(O(n^2)\)。
发现不同环长只有 \(\sqrt n\) 中,我们不枚举 \(C_x\),改成枚举环长 \(l\),对每个 \(l\) 算贡献,并找到环长为 \(l\) 的贡献最大的连通块作为之前枚举的 \(C_x\),把其余的合并上来,复杂度 \(O(n \sqrt n)\)。
::::success[代码]
// 考虑要维护哪些操作
// 对于每个连通块,我们记录下所有环长
// 接下来我们枚举环长,不同环长只有 \sqrt 种,考虑对每个环长算贡献
// 我们需要确定一个连通块作为根的 P,我们需要对其他连通块算 F(C)
// F(C) 表示 C 这个连通块在环长为 l 时能产生最大贡献
// 考虑按照距离染色,实际上是需要实时维护一个桶
// 考虑枚举断掉哪条边,在断边的过程中,我们实际上是每次把所有之前的距离都 +1,也就是对之前的下标进行 +1,同时对于
// 当前点 u 的子树内点需要进行重构,由于每棵子树只会重构一次,总复杂度是 O(abs(C)) 级别的。
// 考虑维护之后就可以求答案了,对于 k 的答案实际上就是取前 k 大,要注意与 \sum siz 取 max
#include<bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
int a[maxn],n;
int fa[maxn],siz[maxn];
int getf(int x)
{
if(fa[x] == x) return x;
return fa[x] = getf(fa[x]);
}
void merge(int u,int v)
{
u = getf(u),v = getf(v);
if(siz[u] > siz[v]) swap(u,v);
if(u != v) fa[u] = v,siz[v] += siz[u];
}
int ind[maxn];
void topu()
{
queue<int> q;
for(int i = 1;i <= n;i++) if(!ind[i]) q.push(i);
while(q.size())
{
int u = q.front(); q.pop();
if(!--ind[a[u]]) q.push(a[u]);
}
}
vector<int> G[maxn];
vector<int> h[maxn]; // 对于每个连通块的环
int hid[maxn],lh[maxn],tot,cid;
void dfs(int u,int fa)
{
h[cid].push_back(u);
if(!--ind[a[u]] && a[u] != fa) dfs(a[u],fa);
}
void solve(int u)
{
// 考虑我们的 solve 要干哪些事
// 记录下每个连通块对应的环的点
// 对每个连通块编号
int rt = getf(u);
hid[rt] = ++cid;
dfs(u,u);
lh[++tot] = h[cid].size();
}
int ans[maxn],pre[maxn];
vector<int> sz;
int tong[maxn],cz[maxn];
void ds(int u,int dx,int op,int dd,int k,int len)
{
int col = dd + dx; col %= len;
for(int v : G[u]) ds(v,dx,op,dd+1,k,len);
if(op == 0) ++tong[col];
else
{
tong[col]--;
col = ((col - k) % len + len) % len;
++tong[col];
}
}
void add(int u,int dx,int op,int dd,int k,int len)
{
int col = dd + dx; col %= len;
for(int v : G[u]) add(v,dx,op,dd+1,k,len);
if(op == 0) cz[tong[col]] = 1;
else
{
col = ((col - k) % len + len) % len;
cz[tong[col]] = 1;
}
}
int getans(int uid,int len)
{
for(int i = 0;i <= len;i++) tong[i] = 0;
for(int i = 0;i <= siz[getf(h[uid][0])];i++) cz[i] = 0;
int k = h[uid].size();
// 考虑实现一个 ds 函数,ds(u,dx,op) 表示 u 这个点,颜色是 dx,op 表示 +/-
for(int i = 1;i <= k;i++) ds(h[uid][i-1],k-i,0,0,k,len),add(h[uid][i-1],k-i,0,0,k,len);
// 首先我们钦定删掉的是 k->1
// 考虑往后转
for(int i = 1;i < k;i++)
{
ds(h[uid][i-1],k-i,1,0,k,len);
add(h[uid][i-1],k-i,1,0,k,len);
}
// 枚举删 i -> i+1
int da = 0;
for(int i = 0;i <= siz[getf(h[uid][0])];i++) if(cz[i]) da = i;
return da;
}
signed main()
{
ios::sync_with_stdio(false);
cin.tie(0);cout.tie(0);
cin >> n;
for(int i = 1;i <= n;i++) fa[i] = i,siz[i] = 1;
for(int i = 1;i <= n;i++)
{
cin >> a[i],ind[a[i]]++;
merge(i,a[i]);
}
topu();
for(int i = 1;i <= n;i++) if(!ind[i]) G[a[i]].push_back(i);
for(int i = 1;i <= n;i++) if(ind[i]) solve(i);
sort(lh + 1,lh + tot + 1);
tot = unique(lh + 1,lh + tot + 1) - lh - 1;
for(int i = 1;i <= tot;i++)
{
// 考虑在 lh[i] 的环长时,每个连通块的贡献
// 用 multiset 存一下
// 统计答案时取前 k 大的
multiset<int> st;
int mx = 0;
for(int id = 1;id <= cid;id++)
{
int res = getans(id,lh[i]);
st.insert(res);
if(h[id].size() == lh[i]) mx = max(mx,res);
// if(lh[i] == 1 && lh[i] == h[id].size()) cout << "fuck! " << mx << "\n";
}
int nowres = mx;
ans[0] = max(ans[0],nowres);
st.erase(st.find(mx));
for(int k = 1;k <= n;k++)
{
if(st.size())
{
int x = *prev(st.end());
st.erase(st.find(x));
nowres += x;
}
ans[k] = max(ans[k],nowres);
}
}
for(int i = 1;i <= n;i++) if(fa[i] == i) sz.push_back(siz[i]);
sort(sz.begin(),sz.end(),greater<int>());
for(int i = 1;i <= sz.size();i++) pre[i] = pre[i - 1] + sz[i - 1];
for(int i = sz.size() + 1;i <= n;i++) pre[i] = pre[i - 1];
for(int i = 0;i <= n;i++)
{
ans[i] = max(ans[i],pre[i]);
cout << ans[i] << ' ';
}
cout << '\n';
return 0;
}
::::
T2 数数题
操作可以转化为对于任意 \(i < n\),令 \(a_i = a_{i+1} = \max(a_i,a_{i+1})\),求最终序列方案数。
先考虑排列怎么做,发现每个数 \(a_i\) 要么不出现,要么覆盖了一段区间 \([l_i,r_i]\),而一个合法方案一定对应一个区间序列,满足以下条件:
- 区间序列单增,即对于任意 \(i\) 满足 \(l_i > r_{i - 1}\)。
- 区间序列是一个划分,即 \(\forall_{i,j},[l_i,r_i] \cap [l_j,r_j] = \varnothing\),且 \(\bigcup\limits_{i=1}^n [l_i,r_i] = [1,n]\)。
利用单调栈找到每个点能覆盖的区间 \([L_i,R_i]\),则还需满足 \(L_i \le l_i \le r_i \le R_i\)。
必要性是显然的,每个数不可能跨过比它大的数覆盖其他数,尝试证明其充分性,也就是任意区间序列均存在一个合法的原序列。考虑先找到 \(n\) 的位置 \(p\),则最终序列 \([l_p,r_p]\) 全都是 \(n\),我们希望存在合法方案填完 \([1,p-1]\) 和 \([p+1,n]\),最后用 \(p\) 去覆盖。
考虑能不能填完 \([1,p-1]\),发现我们找到 \(l_p - 1\) 位置的数,把它一直向右扩展到它的 \(R\),则 \(R + 1\) 一定是一个 \(>\) 它的数,我们再用这个数向右填,最终一定能填到 \(p-1\)。
先考虑排列。可以对着区间序列 dp,设 \(f_{i,j}\) 表示用 \([1,i]\) 的数填了 \([1,j]\) 的位置合法方案数,转移限制 \(i\) 只能填在 \([L_i,R_i]\) 即可,复杂度 \(O(n^2)\)。
考虑不是排列的情况,发现可能算重的是,两个 \(i,j\) 满足 \(a_i = a_j\) 且中间的数均 \(\le a_i\),于是他们的 \(L_i = L_j,R_i = R_j\),于是会算重。
考虑去重也很简单,我们钦定这样的区间其方案只能在字典序更下小的位置被算到,也就是若 \(i \le k \le j\) 的所有 \(a_k\) 在最终序列均未出现,则我们强制 \(j\) 不出现,只允许 \(i\) 出现。
也就是转移 \(f_i\) 时我们需要减去覆盖上个区间的数为 \(a_i\),中间均为空的方案数,也即找到上一个 \(a_i\) 同色数位置 \(pre\),若 \([L_{pre},R_{pre}] = [L_i,R_i]\),减去 \(f_{pre}\) 的方案,复杂度还是 \(O(n^2)\) 的。
::::success[代码]
#include<bits/stdc++.h>
using namespace std;
#define int long long
const int mod = 998244353;
int dp[5010][5010];
int L[5010],R[5010],pre[5010];
signed main()
{
ios::sync_with_stdio(false);
cin.tie(0);cout.tie(0);
dp[0][0] = 1;
int n;cin >> n;
int p[n + 1];
p[0] = 0;
for(int i = 1;i <= n;i++) cin >> p[i];
for(int i = 1;i <= n;i++)
{
int l = i,r = i,sum = 0,sm = 0;
while(l >= 0 && p[i] >= p[l]) l--; l++;
while(r <= n && p[i] >= p[r]) r++; r--;
L[i] = l,R[i] = r;
int m = pre[p[i]],fl = 0;
if(L[m] == l && R[m] == r) fl = 1;
pre[p[i]] = i;
for(int j = 0;j <= n;j++) dp[i][j] = dp[i - 1][j];
if(l)
{
sum = dp[i - 1][l - 1];
sm = dp[m][l - 1];
}
for(int j = l;j <= r;j++)
{
dp[i][j] = (dp[i][j] + sum) % mod;
if(fl) dp[i][j] = (dp[i][j] + mod - sm) % mod;
sum = (sum + dp[i - 1][j]) % mod;
sm = (sm + dp[m][j]) % mod;
}
}
cout << dp[n][n];
return 0;
}
::::
T3 计算几何题
还没补,咕咕咕。
Day 2
T1 最优化问题
考虑把第 \(c_i\) 种男孩看成 \(a_i\) 向 \(b_i\) 连一条边权为 \(c_i\) 的边,要求选出一个边权和最大的菊花或三元环。
统计菊花是简单的,难点在于找到最大三元环,使用三元环计数的方式可以做到 \(O(n \sqrt n)\),考虑如何优化。
考虑一个点 \(u\),我们要统计以 \(u\) 作为一个端点的三元环的最大权值,感觉菊花权值是非常容易大于三元环的,思考什么情况下三元环贡献会优于菊花。
考虑三元环最短的一条边对着的点 \(u\),我们要求三元环权值 \(>\) 菊花权值,也就是这条最短边边权 \(>\) 点 \(u\) 不在三元环上的边权和,那么显然这条边 \(>\) 不在三元环上的每条边。
由此我们得到,三元环 \(u,v,w\) 上每条边都大于 \(u,v,w\) 不在三元环上的边,于是我们只需要考虑每个点最大和次大的出边,计算该三元环的贡献即可,用 Umap 可以简单维护。
::::success[代码]
#include<bits/stdc++.h>
using namespace std;
#define ll long long
char buf[(1<<21)+5],*p1,*p2;
#define getchar() (p1==p2&&(p2=(p1=buf)+fread(buf,1,1<<21,stdin),p1==p2)?EOF:*p1++)
inline int read(){
int f=0,x=0;
char ch=getchar();
while(!isdigit(ch)){f|=(ch=='-');ch=getchar();}
while(isdigit(ch)){x=x*10+ch-'0';ch=getchar();}
return f?-x:x;
}
const int maxn = 2e7 + 10;
int n;
unordered_map<ll,int> mp;
inline ll get(int u,int v) {return 1ll*(u-1)*(n*2)+v;}
#define pii pair<int,int>
#define fi first
#define se second
#define ri register int
pii mx[maxn],mmx[maxn];
ll cnt[maxn];
void solve()
{
n = read();
ll res = 0; mp.clear();
for(ri i = 0;i <= 2 * n;i++) mx[i] = mmx[i] = {-1,-1},cnt[i] = 0;
for(int u,v,w,i = 1;i <= n;++i)
{
u = read(),v = read(),w = read();
if(u > v) swap(u,v);
cnt[u] += w,cnt[v] += w;
res = max({res,cnt[u],cnt[v]});
if(w > mx[u].fi) mmx[u] = mx[u],mx[u] = {w,v};
else if(w > mmx[u].fi) mmx[u] = {w,v};
if(w > mx[v].fi) mmx[v] = mx[v],mx[v] = {w,u};
else if(w > mmx[v].fi) mmx[v] = {w,u};
ll id = get(u,v);
mp[id] = w;
}
for(ri i = 1;i <= n * 2;++i)
{
if(mmx[i].fi < 0) continue;
int u = mx[i].se,v = mmx[i].se;
if(u > v) swap(u,v);
if(!mp.count(get(u,v))) continue;
int w = mp[get(u,v)];
res = max(res,(ll)w + mx[i].fi + mmx[i].fi);
}
cout << res << '\n';
return;
}
signed main()
{
// ios::sync_with_stdio(false);
// cin.tie(0);cout.tie(0);
int T = read();
while(T--) solve();
return 0;
}
::::
T2 构造题
先特判掉初始合法、\(k =0\) 以及 \(t=0\) 的情况。
令 \(k \leftarrow k + t\),操作变为每次全局 \(+t\),并选择一个点 \(-k\)。把原序列从大到小排序,则操作序列是单调不增的。
考虑有这样一个性质:我们找到最大的 \(p\) 满足 \(k > p t\),则我们只会操作 \([1,p]\) 这段前缀。若要操作一个 \(i > p\) 的位置进行操作,则它的值会不降反增,因此必然不会操作。
于是我们只需要求出 \([1,p]\) 的操作方案,并对后面的判断是否合法即可。发现每轮操作后每个位置的值至少会减少 \(1\),设 \(m = \max(0,a_i)\),则最多进行 \(n\times m\) 次操作。
于是有一个 \(O(n^2m)\) 的暴力,直接枚举操作次数,然后为每个位置分配,判断是否合法即可。
继续考虑这样一个性质,若进行 \(X\) 操作合法,则对于需要操作的位置每个都多操作一遍显然合法,即 \(X + p\) 也一定合法,即对于 \(X \bmod p\) 同余的 \(X\) 是具有单调性的,我们可以对每个同余系二分轮数并 check,时间复杂度 \(O(n^2 \log m)\)。
考虑对所有余数按随机顺序枚举,期望二分次数为 \(O(\log n)\) 次,可以考虑随机排列前缀最大值期望个数,于是复杂度为 \(O(n^2 + n\log n\log m)\)。
考虑如何快速判定 \(x\) 次是否合法,发现我们实际上是要求
考虑找到最大的 \(q\) 满足 \(a_i + xt > 0\),把式子拆开,最后需要快速询问一个前缀 \(a\bmod k\) 位于一段区间内的数量。
然后就做完了,三只 \(\log\)。
尽力了,确实卡常卡不过去,只能过你谷神机。
upd:之前写法假了,需要精细实现,必须要正确的判断是否能更新答案,也就是二分之前 continue 那一句的条件,否则复杂度会多乘一个 \(\log\)。
::::success[代码]
#include<bits/stdc++.h>
using namespace std;
#define int __int128
#define sint signed
int n,k,t,nn;
const sint maxn = 1e6 + 10;
int a[maxn],b[maxn];
inline int max(int x,int y){return x > y ? x : y;}
inline int min(int x,int y){return x < y ? x : y;}
inline int read()
{
int x = 0,f = 1;
char ch = getchar();
while(ch < '0' || ch > '9')
{
if(ch == '-') f = -1;
ch = getchar();
}
while(ch >= '0' && ch <= '9')
{
x = (x << 1) + (x << 3) + (ch ^ 48);
ch = getchar();
}
return x * f;
}
inline void write(int x)
{
if(x < 0) putchar('-'),x = -x;
if(x > 9) write(x / 10);
putchar(x % 10 + 48);
}
bool chk_wj()
{
bool fl = 1;
for(register sint i = 1;i <= n;i++) fl &= (a[i] <= 0);
if(fl)
{
write(0),putchar('\n');
for(register sint i = 1;i <= n;i++) write(0),putchar(' ');
return 1;
}
if(k == 0)
{
write(-1),putchar('\n');
return 1;
}
if(t == 0)
{
int sum = 0;
for(register sint i = 1;i <= n;i++) sum += max(__int128(0),(a[i] + k - 1) / k);
write(sum),putchar('\n');
for(register sint i = 1;i <= n;i++) write(max(__int128(0),(a[i] + k - 1) / k)),putchar(' ');
return 1;
}
return 0;
}
int pre[maxn];
vector<int> lsh;
sint tr[maxn * 21];
sint ls[maxn * 21],rs[maxn * 21],root[maxn],id = 1;
#define mid ((l + r) >> 1)
#define lson (ls[rt])
#define rson (rs[rt])
void pushup(sint rt) {tr[rt] = tr[lson] + tr[rson];}
sint update(sint rt,sint l,sint r,sint x)
{
sint p = ++id;
tr[p] = tr[rt],ls[p] = ls[rt],rs[p] = rs[rt];
if(l == r)
{
tr[p]++;
return p;
}
if(x <= mid) ls[p] = update(lson,l,mid,x);
else rs[p] = update(rson,mid + 1,r,x);
pushup(p);
return p;
}
sint query(sint rt,sint l,sint r,sint x,sint y)
{
if(x > y || !rt) return 0;
if(x <= l && r <= y) return tr[rt];
sint res = 0;
if(x <= mid) res += query(lson,l,mid,x,y);
if(y > mid) res += query(rson,mid + 1,r,x,y);
return res;
}
bool cmp(sint x,sint y){return a[x] > a[y];}
sint mod[maxn];
mt19937 rng(time(0));
inline bool check(int x)
{
sint p = 0;
if(a[b[n]] + x * t >= 0) p = n;
else
{
sint l = 1,r = n;
while(l <= r)
{
if(a[b[mid]] + x * t >= 0) p = mid,l = mid + 1;
else r = mid - 1;
}
}
if(p == 0) return 1;
int sum = pre[p] + p * (x * t / k);
sint pa = lower_bound(lsh.begin(),lsh.end(),k-x*t%k+1) - lsh.begin();
sint pb = lower_bound(lsh.begin(),lsh.end(),-x*t%k+1) - lsh.begin();
if(pa < lsh.size()) sum += query(root[p],1,lsh.size(),pa+1,lsh.size());
if(pb < lsh.size()) sum += query(root[p],1,lsh.size(),pb+1,lsh.size());
return sum <= x;
}
inline int get(int x,int i)
{
int res = (a[i] + x * t + k - 1) / k;
res = max(__int128(0),res);
return res;
}
signed main()
{
n = read(),k = read(),t = read();
for(sint i = 1;i <= n;i++) a[i] = read(),b[i] = i;
if(chk_wj()) return 0;
k += t,nn = n;
sort(b + 1,b + n + 1,cmp);
for(register sint i = 1;i <= n;i++) lsh.push_back(a[i] % k);
int lim = 1e20;
while(k <= n * t && a[b[n]] < 0) lim = min(lim,-a[b[n]] / t),n--;
if(k <= n * t) return write(-1),0;
for(sint i = 0;i < n;i++) mod[i] = i;
shuffle(mod,mod + n,rng);
root[0] = 1;
sort(lsh.begin(),lsh.end());
lsh.erase(unique(lsh.begin(),lsh.end()),lsh.end());
for(register sint i = 1;i <= n;i++)
{
pre[i] = pre[i - 1] + a[b[i]] / k;
sint pos = lower_bound(lsh.begin(),lsh.end(),a[b[i]] % k) - lsh.begin() + 1;
root[i] = update(root[i - 1],1,lsh.size(),pos);
}
int rs = -1;
for(register sint o = 0;o < n;o++)
{
int i = mod[o];
int l = 0,r = 1e9 + 10,res = 1e18;
if(rs != -1) r = rs / n;
if(rs != -1 && !check(rs / n * n + i - (rs / n * n + i > rs) * n)) continue;
while(l <= r)
{
// cout << "i:mid:chk " << signed(i) << " " << signed(mid) << " " << check(mid) << '\n';
if(check(mid * n + i)) res = mid * n + i,r = mid - 1;
else l = mid + 1;
}
if(rs == -1 || res < rs) rs = res;
}
if(rs > lim)
{
write(-1),putchar('\n');
return 0;
}
write(rs),putchar('\n');
for(sint i = 1;i <= nn;i++)
{
write(get(rs,i));
putchar(' ');
}
return 0;
}
::::
### T3 判定问题
还没补。
## Day 3
### T1 排列题
[原题](https://www.luogu.com.cn/problem/P16357)
打表找规律题,真是糖丸了。
若 $n$ 是偶数,推推式子知道某个颜色数量为奇数就不行,否则直接首尾染色即可。
考虑我们可以用形如 $(1,n),(2,n-1)$ 这样的对来配对,先把偶数全配对好,奇数只留下最终 $3$ 个,于是最终只剩下偶数个需要填 $3$ 个的点。
如果存在 $>1$ 个只有 $1$ 个的颜色就寄了,否则把它填在中心点,若没有随便找一个奇数点放上去就行,最后构造方案不知道怎么瞎构造一下,大体是左边放一个右边对称的隔一个放一个,然后剩下的顺着放进去,忘了。
### T2 数数题
还不会。
### T3 最短路问题
还不会。
## Day 4
### T1 莫队之理
这题可以。
首先部分分分别对应着各种莫队的做法,然后我们考虑正解。考虑随机排列的 LIS 长度期望 $O(\sqrt n)$,于是我们找到所有包含的区间,从内往外删即可。
具体的,把区间按 $l$ 排序,此时从小到大扫,对每个区间找到前缀中最大满足 $r > r_i$ 的,然后把它替换掉,期望操作次数 $O(n\sqrt q)$,可以通过。
::::success[代码]
```cpp
#include "ds.h"
#include <bits/stdc++.h>
using namespace std;
#define pii pair<int,int>
#define fi first
#define se second
set<pii> s;
const int maxn = 1e5 + 10;
int a[maxn],pre[maxn],nx[maxn];
void solve(int n, int q, vector<int> L, vector<int> R) {
for(int i = 0;i < q;i++) a[i] = i,pre[i] = nx[i] = -1;
sort(a,a + q,[&](int x, int y){
if(L[x] == L[y]) return R[x] > R[y];
return L[x] < L[y];
});
for(int i = 0;i < q;i++)
{
int id = a[i];
if(!s.size() || s.lower_bound({R[id],0}) == s.end()) s.insert({R[id],id});
else
{
auto it = s.lower_bound({R[id],0});
int u = (*it).se;
pre[u] = id,nx[id] = u;
s.erase(it);
s.insert({R[id],id});
}
}
for(int i = 0;i < q;i++) if(pre[i] == -1)
{
clear();
int u = i,l = L[i],r = R[i];
for(int j = l;j <= r;j++) add(j);
report(i + 1);
while(nx[u] != -1)
{
u = nx[u];
for(int j = L[u];j < l;j++) add(j);
for(int j = r + 1;j <= R[u];j++) add(j);
l = L[u],r = R[u];
report(u + 1);
}
}
}
::::
T2 又见星图
三轮省集
怎么说,学 whk 找状态太难了,其实还是菜,但是也有收获吧。
暂时不知道写啥,先咕咕咕一下。
感觉就先不按顺序写了,直接乱序会了哪个题写哪个题吧,要不然可能进度太难了。
D1T2 you are given a tree
无敌了,省集一直没学会,学考考完地理没事干研究了研究怎么会了。
要求做到两个 log,首先有一个 \(n^2\) 暴力是,我们考虑记录 \(f_{i,x}\) 表示考虑了 \(i\) 子树,\(k=x\) 时 \(x\) 向上延伸的最长链长度,转移直接维护子树内最长链次长链,如果满足 \(mx + mmx + 1 \ge k\) 则答案 \(+1\) 并且该位置 \(f\) 变为 \(0\),否则取最长链延伸上去。
考虑怎么快速维护贡献,类似 dsu on tree 的方法,我们首先从重儿子继承 \(f\),并把每个位置 \(+1\),然后我们只要保证计算贡献复杂度与轻儿子 \(siz\) 相关就可以保证复杂度。
我们记 \(mx\) 表示最大的轻子树大小。
- 对于 \(k\in [1,mx]\),我们直接暴力维护轻儿子中最长次长,暴力修改即可,这部分复杂度是 $n\log n \times $修改复杂度。
- 对于 \(k\in [mx + siz_u + 1,n]\),由于子树内最长链不超过子树大小,这部分贡献显然就是子树内最长链,对每个点维护一下最长链即可。
- 对于 \(k\in [mx + 1,xm + siz_u]\),此时所有轻儿子只能贡献子树内最长链,于是我们对于每个 \(k\) 找到轻子树中最长链 \(mxl\),尝试更新答案,发现更新答案形式相当于 \(mxl + f_{u,x} \ge x\),移项可得 \(mxl + f_{u,x} - x \ge 0\),于是维护区间最大值,判断加上之后是否 \(>0\),合法就直接递归进入子区间,直到叶子处修改答案。
- 要注意判断最长链和次长链直接更新答案的情况。
至于为什么第三个复杂度是对的,考虑答案的总数是 \(\sum\limits_i \lfloor \frac{n}{i}\rfloor\),因此暴力修改就是对的。
用线段树维护贡献即可做到 \(O(n\log^2 n)\)。
D2T1 垃圾分类
咕咕咕。
D3T1
首先考虑到对于一个集合算贡献一定是取 \(x = mid\) 的,其中 \(mid\) 表示集合中位数,于是有一个做法是枚举一条边 \(x\) 作为中位数,\(w_i < x\) 的部分设为白边,边权为 \(x - w_i\),其余设为黑边,边权为 \(w_i - x\),此时问题变成选出恰好 \(\lfloor \frac{n - 2}{2}\rfloor\) 条黑和白求最大生成树,相当于 Tree I,可以 wqs 二分做。
考虑每次枚举一条边作为中位数复杂度太大了,但是我们确实需要中位数来给每条边确定贡献。尝试把所有边作为两种颜色贡献都加入进去,然后做最大生成树,看是否合法,发现是合法的,合法的原因就在于我们每种颜色都恰好取了 \(\frac{n-1}{2}\) 条,而在第二个集合被取到,说明其绝对值极大,因此反转到第一个集合对应绝对值极小,不会被取到,于是我们只需要把所有边加进去,wqs 做一遍最大生成树即可,复杂度 \(O(n\log V \log n)\)。

浙公网安备 33010602011771号