省集

好像这篇有点咕咕咕了。

二轮省集

感受到了和别人的差距。

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\) 次是否合法,发现我们实际上是要求

\[\sum\limits_{i=1}^n \lceil\frac{\max(0,a_i + xt)}{k}\rceil \]

考虑找到最大的 \(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)\)。

posted @ 2026-11-14 00:48  点亮花火  阅读(5)  评论(0)    收藏  举报