叱咤月海猫猫鱼 Blog https://your-docusaurus-site.example.com/blog-posts 叱咤月海猫猫鱼 Blog Mon, 26 Oct 2026 13:56:05 GMT https://validator.w3.org/feed/docs/rss2.html https://github.com/jpmonette/feed zh-Hans <![CDATA[题解/洛谷-or-Nsoj/单源最短路径4]]> https://your-docusaurus-site.example.com/blog-posts/题解/洛谷-or-Nsoj/单源最短路径4 https://your-docusaurus-site.example.com/blog-posts/题解/洛谷-or-Nsoj/单源最短路径4 Mon, 26 Oct 2026 13:56:05 GMT

title: 单源最短路径4 date: 2025-08-19 slug: 题解/洛谷-or-Nsoj/单源最短路径4 tags: [题解, 拓扑排序]​

谁说这题水了，这题可太好了

第一眼：dijistradijistra水题，但是存在负权边，GGGG，改SPFASPFA？就算加了LLLLLL和SLFSLF也还要TT，还是GGGG

我嘞个豆o((⊙﹏⊙))o.，是不是突然感觉好无助，不知道怎么写了

注意一下这道题的性质：DAG(有向无环图)，我们可以从这个上面来做文章(yc音)

有向无环是个什么意思，说明我们可以对这个图进行拓扑排序啊！

那再想想拓扑排序，易得只有拓扑排序靠前的点被更新了后面的才可能被影响

那么我们根据这个拓扑序来进行松弛操作，不就可以保证无后效性了吗

queue< int > q;//保存节点
for( int i=1;i<=n;i++ )
	if( deg[i] == 0 )//入度为0
		q.push( i );
vector< int > topsort;//保存拓扑序
while( !q.empty() )//求拓扑序
{
	int t=q.front();
	q.pop();
	topsort.push_back( t );
	for( auto &[x,w]:rode[t] )
	{
		deg[x]--;
		if( deg[x] == 0 )
			q.push( x );
	}
}

for( auto u:topsort )//依据拓扑序进行松弛操作
	for( auto &[v,w]:rode[u] )
		if( min_dis[u]+w < min_dis[v] )
			min_dis[v]=min_dis[u]+w;

计算一下时间复杂度，我们只进行了一次拓扑排序和一次全图松弛操作，只遍历了每个点及其对应边，又因为边有向，所以时间复杂度为O(n+m)O(n+m)

利用拓扑序快速松弛是我们在DAGDAG中寻求最短路的常用操作，它利用拓扑序的性质从而快速且正确的求解答案

]]> <![CDATA[琪亚娜与豆腐脑]]> https://your-docusaurus-site.example.com/blog-posts/题解/洛谷-or-Nsoj/琪亚娜与OI比赛/E-琪亚娜与豆腐脑 https://your-docusaurus-site.example.com/blog-posts/题解/洛谷-or-Nsoj/琪亚娜与OI比赛/E-琪亚娜与豆腐脑 Mon, 26 Oct 2026 00:00:00 GMT

首先我们发现有一些点的颜色是固定的，并且它们不能放在一起，这就不难想到“二分图”这类东西。

那我们先考虑每个点向左右两个超级源点连边，连在那一条上就表示放在哪个组内。

但是我们发现这样还是不好做，所以不如变成先连边再删边，这样我们只需要删除一些边使不存在一个点同时连通两边就可以了。

那我们再思考一下，其实就是把这张图删除一些边使其裂成两张图，就是求这张图的最小割了。

将连左边记为甜、右边记为咸，我们再加入“争执”这个限制，那么就是一些左部点向右部点的连边，我们需要把这些边同样割掉就可以了。

那么对于“一定某个颜色”，我们只需要向对应颜色再连一个流量为 infinf 的边来强制就行了，这样是不可能割这个边的。

时间复杂度：O(NM)O(N\sqrt{M})。

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define pii pair< int,int >
#define QWQ return 0;
#define QAQ return

const int N=3e3+10, M=3e4+10;
const ll inf=1e18;

int head[N], ver[N+M<<1], nxt[N+M<<1], now[N], CNT=1;
ll edge[N+M<<1];
inline void add( int u,int v,ll w )
{
	ver[++CNT]=v, edge[CNT]=w, nxt[CNT]=head[u], head[u]=CNT;
	ver[++CNT]=u, edge[CNT]=0, nxt[CNT]=head[v], head[v]=CNT;
}

int n, m, s, t;
int d[N];

inline void intt()
{ for( int i=s;i<=t;i++ ) d[i]=0; }

inline bool bfs()
{
	intt();
	queue< int > q;
	q.push( s ), d[s]=1;
	now[s]=head[s];
	while( !q.empty() )
	{
		auto x=q.front();
		q.pop();
		for( int i=head[x];i;i=nxt[i] ) if( edge[i] && !d[ver[i]] )
		{
			d[ver[i]]=d[x]+1;
			now[ver[i]]=head[ver[i]];
			if( ver[i] == t ) QAQ true;
			q.push( ver[i] );
		}
	}
	QAQ false;
}

inline ll dinic( int x,ll flow )
{
	if( x == t ) QAQ flow;
	ll rest=flow;
	for( int i=now[x];i && rest;i=nxt[i] )
	{
		now[x]=i;
		if( edge[i] && d[ver[i]] == d[x]+1 )
		{
			ll sonflow=dinic( ver[i],min( rest,edge[i] ) );
			if( !sonflow ) d[ver[i]]=0;
			edge[i]-=sonflow; edge[i^1]+=sonflow;
			rest-=sonflow;
		}
	}
	QAQ flow-=rest;
}

int col[N];

int main()
{
    // freopen( "tofu20.in","r",stdin );
    // freopen( "tofu20.out","w",stdout );
    ios::sync_with_stdio( false );
    cin.tie( nullptr ); cout.tie( nullptr );
    int n, m;
    cin>>n>>m;
    s=0, t=n+1;
    for( int i=1;i<=n;i++ ) cin>>col[i];
    for( int i=1, a, b;i<=n;i++ )
        cin>>a>>b,
        add( s,i,b ), add( i,t,a );
    for( int i=1, u, v, w;i<=m;i++ )
        cin>>u>>v>>w, add( u,v,w );
    for( int i=1;i<=n;i++ )
             if( col[i] == 0 ) add( s,i,inf );
        else if( col[i] == 1 ) add( i,t,inf );
    ll maxflow=0, flow;
	while( bfs() ) while( flow=dinic( s,inf ) ) maxflow+=flow;
    cout<<maxflow;
    QWQ
}
]]> 题解 图论建模，网络流 <![CDATA[琪亚娜与OSU]]> https://your-docusaurus-site.example.com/blog-posts/题解/洛谷-or-Nsoj/琪亚娜与OI比赛/F-琪亚娜与OSU https://your-docusaurus-site.example.com/blog-posts/题解/洛谷-or-Nsoj/琪亚娜与OI比赛/F-琪亚娜与OSU Mon, 26 Oct 2026 00:00:00 GMT

每次的不断进行 x−>(x+d)mod  Nx -> (x+d)\mod N 本质上就是一个置换环，那么形成的环数就是 gcd(N,d)gcd( N,d )。

因此，引子印合法当且仅当 gcd⁡(N,d)=dgcd⁡( N,d )=d，也就是 d∣Nd\mid N。

那么对于一个 dd，它得到的方案数就是 (Nd)\binom{N}{d}，因此合法琪谱数量就是 ∑d∣N(Nd)\sum_{d\mid N}\binom{N}{d}。

每张琪谱独立选择 QQ 中主题，那么我们要求的答案就是 q∑d∣N(Nd)mod  Mq^{\sum_{d\mid N}\binom{N}{d}}\mod M。

那么我们先使用一次欧拉定理，得到 q∑d∣N(Nd)≡q∑d∣N(Nd)mod  M−1(mod  M)q^{\sum_{d\mid N}\binom{N}{d}}\equiv q^{\sum_{d\mid N}\binom{N}{d}\mod M-1} (\mod M)

将上面这一坨拉下来 ∑d∣N(Nd)mod  M−1\sum_{d\mid N}\binom{N}{d}\mod M-1，因为我们规定了 ∣μM∣=1|\mu M|=1，我们就可以快乐的分解 M−1M-1 的质因数做 CRTCRT 了。

那么我们如何在不爆炸的时间内求解 (Nd)mod  prime\binom{N}{d}\mod prime 呢？

因为 N,dN,d 的量级很大，显然我们是无法处理逆元来快速计算这个式子的......吗？

因为我们分解出来已经保证这个模数是质数了，我们就能想到利用 LucasLucas 定理来减小计算的量级，我们就可以解决了。

时间复杂度：O(maxprime×log⁡n+n+τ(n)log⁡2n)O(maxprime\times \log n+\sqrt{n}+\tau(n)\log^2 n)。

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define pii pair< int,int >
#define QWQ return 0;
#define QAQ return

const int N=40, M=2e6+10, upper=2e6;

int siz, p[N];
ll sum[N];
ll jc[N][M], inv[N][M], jc_inv[N][M];

inline ll quick_power( ll a,ll b,ll mod )
{
	ll ans=1, base=a%mod;
	while( b )
	{
		if( b&1 ) ( ans*=base )%=mod;
		( base*=base )%=mod; b>>=1;
	}
	QAQ ans;
}

inline void init()
{
	for( int i=1;i<=siz;i++ )
	{
		jc[i][0]=1, jc[i][1]=1;
		inv[i][0]=0, inv[i][1]=1;
		jc_inv[i][0]=1, jc_inv[i][1]=1;
		for( int j=2;j<=upper;j++ )
			jc[i][j]=jc[i][j-1]*j%p[i],
			inv[i][j]=-1ll*p[i]/j*inv[i][p[i]%j]%p[i],
			jc_inv[i][j]=jc_inv[i][j-1]*inv[i][j]%p[i];
	}
}

inline ll C( ll n,ll m,int idx )
{
	if( n < m ) QAQ 0ll;
	QAQ jc[idx][n]*jc_inv[idx][m]%p[idx]*jc_inv[idx][n-m]%p[idx];
}

inline ll Lucas( ll n,ll m,int idx )
{
	if( n < p[idx] && m < p[idx] ) QAQ C( n,m,idx );
    QAQ C( n%p[idx],m%p[idx],idx )*Lucas( n/p[idx],m/p[idx],idx )%p[idx];
}

inline ll CRT()
{
	ll T=1, ans=0;
    for( int i=1;i<=siz;i++ ) T=T*p[i];
    for( int i=1;i<=siz;i++ ) ( ans+=T/p[i]*sum[i]%T*quick_power( T/p[i],p[i]-2ll,p[i] )%T )%=T;
    QAQ ( ans%T+T )%T;
}

int main()
{
    // freopen( "big_sample2.in","r",stdin );
    // freopen( "big_sample2.out","w",stdout );
    ios::sync_with_stdio( false );
    cin.tie( nullptr ); cout.tie( nullptr );
	ll n, q;
	int m;
	cin>>n>>q>>m;
	if( q%m == 0 )
	{ cout<<0; QWQ }
	int tmp=m-1;
	for( int i=2;i*i<=tmp;i++ ) if( tmp%i == 0 )
		p[++siz]=i, tmp/=i;
	if( tmp > 1 ) p[++siz]=tmp;
	init();
	for( ll i=1;i*i<=n;i++ )if( n%i == 0 )
	{
		               for( int j=1;j<=siz;j++ ) ( sum[j]+=Lucas( n,  i,j ) )%=p[j];
		if( i*i != n ) for( int j=1;j<=siz;j++ ) ( sum[j]+=Lucas( n,n/i,j ) )%=p[j];
	}
	cout<<quick_power( q,CRT(),m );
    QWQ
}
]]> 题解 数学 组合数学 欧拉定理 Lucas定理 中国剩余定理CRT <![CDATA[Holding]]> https://your-docusaurus-site.example.com/blog-posts/题解/COCI/2019-2020-4/B-Holding https://your-docusaurus-site.example.com/blog-posts/题解/COCI/2019-2020-4/B-Holding Mon, 28 Sep 2026 00:00:00 GMT [COCI 2019/2020 #4] Holding​
Details

题目背景

Ivica 有一个由 NN 家克罗地亚公司组成的集团，但他的集团正面临着困难。他的企业承受着巨额的负债，所以政 府派遣律师没收了他的一切财产。

但我们发现，尽管他有巨额债务在身，他依然与政 府达成协议，留住了部分企业。他留住的是哪些？我们也知道了。

题目描述

律师们把 Ivica 的公司的 NN 份债务文件摆在桌上。第一家公司的债务为 A1A_1 ，第二家公司的债务为 A2A_2 ，依次类推。

Ivica 与政 府达成协议，使它留下桌上 [L,R][L,R] 区间的所有文件所对应的公司，但他需要承担 AL,AL+1…ARA_L,A_{L+1}\ldots A_R 的所有债务，其中 LL 和 RR 代表桌子上一系列文件中的位置。

幸运的是，律师们也是腐败。他们可以让他以 ∣i−j∣|i-j| 的价格交换当前放在位置 ii 和位置 jj 的文件。

Ivica 有点绝望。他口袋里只有 KK 元钱，他现在想把这些钱花在这里，使得他的需要承担的债务尽可能少。

请帮他达成目标。

输入格式

第一行四个整数 N,L,R,KN,L,R,K。

第二行 NN 个整数，第 ii 个表示 AiA_i。

输出格式

一行一个整数，表示花不超过 KK 元后负债的最小值。

输入输出样例 #1

输入 #1

3 2 2 1
1 2 3

输出 #1

1

输入输出样例 #2

输入 #2

5 2 3 3
21 54 12 2 0

输出 #2

12

输入输出样例 #3

输入 #3

6 4 6 100
1 2 3 4 5 6

输出 #3

6

说明/提示

【数据规模与约定】

子任务编号特殊限制分值
11N≤13N\le 13，R=NR=N2020
22N≤50N\le 50，R=NR=N3030
33N≤50N\le 503030
44无特殊限制2020

对于 100%100\% 的数据，保证 1≤N≤1001\le N\le 100，1≤L≤R≤N1\le L\le R\le N，1≤K≤1041\le K\le 10^4，1≤Ai≤1061\le A_i\le 10^6。

【提示与帮助】

题目译自 COCI 2019/2020 CONTEST #4 T3 Holding

在 COCI 中，本题分值为 110110 分。

分析​

容易发现交换 i,ji,j 两个元素并花费∣i−j∣∣i−j∣元，相当于进行了∣i−j∣∣i−j∣次邻项交换

所以将问题转化为进行不超过 k 次邻项交换使得 [l,r] 区间内的元素之和最小

将这些元素在原数列中的下标按照从小到大排列记为p1​,p2​,⋯,pmp_1​,p_2​,⋯,p_m​，那么在最优决策下，p1p1移动到了ll，p2​p2​移动到了l+1，……，pil+1，……，pi移动到了l+i−1l+i−1

因为如果移动两个元素i,ji,j时，路径发生了交叉，那么必然发生了交换i,ji,j两个元素的情形，这一定会更劣

那么状态设计就非常简单

fi,j,kf_{i,j,k}表示前ii个数，选择了jj个，花费了恰好kk元的情况下，选出的元素的最小值，容易得到状态转移方程：

fi,j,k​=minfi−1,j,k​,fi−1,j−1,k−∣l+j−i−1∣​+ai​f_{i,j,k}​=min{f_{i−1,j,k}​,f_{i−1,j−1,k−∣l+j−i−1∣​}+a_i​ }

时间复杂度为O(n2k)O(n^2k)，使用滚动数组滚掉第一维空间复杂度为O(nk)O(nk)

AC代码​

Code
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define pii pair< int,int >
#define QWQ return 0;
#define QAQ return

const int N=1e2+10, K=1e4+10;
const int inf=1e9;

int a[N];
int f[2][N][K];

int main()
{
    // freopen( "txt.in","r",stdin );
    // freopen( "txt.out","w",stdout );
    ios::sync_with_stdio( false );
    cin.tie( nullptr ); cout.tie( nullptr );
    int n, l, r, K;
	cin>>n>>l>>r>>K;
	for( int i=1;i<=n;i++ ) cin>>a[i];
	int m=r-l+1;
    memset( f,0x3f,sizeof f );
    f[0][0][0]=0;
    for( int i=1;i<=n;i++ ) for( int j=0;j<=m;j++ ) for( int k=0;k<=K;k++ )
    {
        int w=abs( l+j-i-1 );
        f[i&1][j][k]=f[i&1^1][j][k];
        if( k >= w && j >= 1 ) f[i&1][j][k]=min( f[i&1][j][k],f[i&1^1][j-1][k-w]+a[i] );
    }
    int ans=inf;
    for( int i=0;i<=K;i++ ) ans=min( ans,f[n&1][m][i] );
    cout<<ans;
    QWQ
}
]]> 题解 COCI 动态规划 贪心 <![CDATA[Klasika]]> https://your-docusaurus-site.example.com/blog-posts/题解/COCI/2019-2020-4/C-Klasika https://your-docusaurus-site.example.com/blog-posts/题解/COCI/2019-2020-4/C-Klasika Mon, 28 Sep 2026 00:00:00 GMT [COCI 2019/2020 #4] Klasika​
Details

题目描述

开始时，你有一个编号为 11 的节点，它代表着一棵树的根。你的任务是对树进行 QQ 次操作。

操作分为两类：

  • Add x y\texttt{Add x y}，给树上编号为 xx 的节点加入一个儿子，该儿子的编号为加入该节点后树的大小，它与 xx 的边的边权为 yy。
  • Query a b\texttt{Query a b}，查找从 aa 出发，到 bb 节点子树内某个节点（包括 BB ）的路径中边权异或和最大的一条，并输出其异或和。

输入格式

第一行一个整数 QQ。

加下来 QQ 行，每行一个字符串和两个数字，描述一次操作。

输出格式

对于每个 Query\texttt{Query} 操作，一行一个整数表示答案。

输入输出样例 #1

输入 #1

4
Add 1 5
Query 1 1
Add 1 7
Query 1 1

输出 #1

5
7

输入输出样例 #2

输入 #2

6
Add 1 5
Add 2 7
Add 1 4
Add 4 3
Query 1 1
Query 2 4

输出 #2

7
2

输入输出样例 #3

输入 #3

10
Add 1 4
Add 1 9
Add 1 10
Add 2 2
Add 3 3
Add 4 4
Query 4 2
Query 1 3
Add 6 7
Query 1 3

输出 #3

14
10
13

说明/提示

【数据规模与约定】

子任务编号特殊限制分值
11Q≤200Q\le 2001010
22Q≤2×103Q\le 2\times 10^32020
33对于所有 Query\texttt{Query} 操作，保证 b=1b=13030
44无特殊限制4040

对于 100%100\% 的数据，1≤Q≤2×1051\le Q\le 2\times 10^5，0≤y≤2300\le y\le 2^{30}，保证 x,a,bx,a,b 小于等于当前树的大小。

【提示与帮助】

题目译自 COCI 2019/2020 CONTEST #4 T4 Klasika

在 COCI 中，本题分值为 110110 分。

分析​

首先考虑没有AddAdd操作时怎么做，我们可以树剖+可持久化字典树解决

那么加入加点操作后如果在线实现我们每次加点操作后会因为重做dfndfn序和字典树导致O(qnlogn)O(qnlogn)爆炸

那么我们考虑一下离线能不能做，首先就是可以直接树剖一次作出dfndfn序了并且构建可持久化字典树了

然后我们又可以想到对于每个AddAdd操作，我们可以动态的插入这个边的权值，初始为00就不会对答案产生影响了

所以我们只需要再在外层加一个树状数组/线段树转树套树就可以O(log2n)O(log^2n)的实现单点改区间查了

时间复杂度O(qlog2n)O(qlog^2n)，建议不要外层线段树空间会出问题

AC代码​

Code
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define pii pair< int,int >
#define QWQ return 0;
#define QAQ return

const int N=2e5+10, LOGN=31;

struct ASK
{
    bool op;
    int x, y;
}ask[N];

int id;
int siz[N], fa[N], dep[N], dis[N];
int mson[N], top[N], dfn[N], idx[N];
vector< pii > rode[N];

inline void dfs1( int p,int Fa )
{
    fa[p]=Fa;
    siz[p]=1; dep[p]=dep[Fa]+1;
    for( auto &[x,w]:rode[p] ) if( x != Fa )
    {
        dis[x]=dis[p]^w;
        dfs1( x,p );
        siz[p]+=siz[x];
        if( siz[x] > siz[mson[p]] ) mson[p]=x;
    }
}

inline void dfs2( int p,int t )
{
    top[p]=t;
    dfn[p]=++id; idx[id]=p;
    if( !mson[p] ) QAQ;
    dfs2( mson[p],t );
    for( auto &[x,w]:rode[p] ) if( x != fa[p] && x != mson[p] )
        dfs2( x,x );
}

struct Trie
{
    int cnt;
    int siz[N*LOGN<<3];
    int trie[N*LOGN<<3][2];
    
    inline Trie(){ cnt=0; }

    inline int newnode()
    {
        cnt++;
        trie[cnt][0]=trie[cnt][1]=siz[cnt]=0;
        QAQ cnt;
    }

    inline void insert( int &root,int Num )
    {
        if( !root ) root=newnode();
        int p=root; siz[p]++;
        for( int bit=LOGN;bit>=0;bit-- )
        {
            int now=( Num>>bit )&1;
            if( !trie[p][now] ) trie[p][now]=newnode();
            p=trie[p][now]; siz[p]++;
        }
    }

    inline int query( int rroot[],int sizr,int lroot[],int sizl,int num )
    {
        int ans=0;
        for( int bit=LOGN;bit>=0;bit-- )
        {
            int now=( num>>bit )&1, exp=now^1, sum=0;
            for( int i=0;i<sizr;i++ ) if( rroot[i] && trie[rroot[i]][exp] ) sum+=siz[trie[rroot[i]][exp]];
            for( int i=0;i<sizl;i++ ) if( lroot[i] && trie[lroot[i]][exp] ) sum-=siz[trie[lroot[i]][exp]];

            int nxt=now;
            if( sum > 0 ) nxt=exp, ans|=1<<bit;
            for( int i=0;i<sizr;i++ ) if( rroot[i] ) rroot[i]=trie[rroot[i]][nxt];
            for( int i=0;i<sizl;i++ ) if( lroot[i] ) lroot[i]=trie[lroot[i]][nxt];
        }
        QAQ ans;
    }

};

struct Binary
{
    int n;
    int root[N];
    int rroot[LOGN], lroot[LOGN];
    Trie trie;

    inline static int lowbit( int x ){ QAQ x&-x; }

    inline void add( int x,int y )
    { for( ;x<=n;x+=lowbit( x ) ) trie.insert( root[x],y ); }

    inline int query( int l,int r,int num )
    {
        int sizr=0, sizl=0;
        for(    ;r;r-=lowbit( r ) ) rroot[sizr++]=root[r];
        for( l--;l;l-=lowbit( l ) ) lroot[sizl++]=root[l];
        QAQ trie.query( rroot,sizr,lroot,sizl,num );
    }

}Bit;

int main()
{
    // freopen( "1.in","r",stdin );
    // freopen( "1.out","w",stdout );
    ios::sync_with_stdio( false );
    cin.tie( nullptr ); cout.tie( nullptr );
    int n=1, q;
    cin>>q;
    string op;
    for( int i=1, x, y;i<=q;i++ )
    {
        cin>>op>>x>>y;
        if( op == "Add" ) rode[x].push_back( { ++n,y } );
        ask[i]={ ( op == "Add" ),x,y };
    }
    dfs1( 1,0 ); dfs2( 1,1 );
    Bit.n=n;
    Bit.add( dfn[1],dis[1] );
    n=1;
    for( int i=1;i<=q;i++ )
    {
        auto [op,x,y]=ask[i];
        if( op ) n++, Bit.add( dfn[n],dis[n] );
        else     cout<<Bit.query( dfn[y],dfn[y]+siz[y]-1,dis[x] )<<"\n";
    }
    QWQ  
}
]]> 题解 COCI 字典树 树状数组 树链剖分 树套树 <![CDATA[树形背包]]> https://your-docusaurus-site.example.com/blog-posts/题解/洛谷-or-Nsoj/树形背包 https://your-docusaurus-site.example.com/blog-posts/题解/洛谷-or-Nsoj/树形背包 Tue, 22 Sep 2026 00:00:00 GMT

虽然是个模板题，但是不是sizsiz优化的模板

据搜索整合所言，sizsiz优化复杂度是O(n2)O(n^2)，但是我们这个题一眼知道要写O(nm)O(nm)的代码

于是我们就要学习这个dfndfn序优化树形背包了

首先，根据dfndfn序的性质"一棵子树在dfndfn序中一定是一段连续区间"可以发现，如果我们不选一个父亲就可以直接跳过所有子树

那么我们在扫描dfndfn的时候，对于每个点只有两种决策：

<1> 选择这个点，可以继续在子树中选择，转移到点posdfni+1pos_{dfn_{i+1}}上

<1> 不选择这个点，那么我们直接访问posdfni+sizipos_{dfn_{i+siz_i}}跳过这颗子树

这样我们就可以得到一份复杂度严格O(nm)O(nm)的树形背包代码了

#include<bits/stdc++.h>    
using namespace std;    
#define QAQ return     
#define QWQ return 0;    
#define ll long long    
#define pii pair< int,int >    
    
const int N=5e4+10, M=6e7+6e5;    

int head[N], ver[N], nxt[N], CNT;    
void add( int u,int v )    
{ ver[++CNT]=v, nxt[CNT]=head[u], head[u]=CNT; }     
      
int n, W, id;  
int w[N], v[N];    
int dfn[N], siz[N], pos[N];    
int f[M];   
  
inline int idx( int x,int y )  
{ QAQ x*( W+1 )+y; }  
  
inline void dfs( int p )    
{    
    siz[p]=1;
    dfn[p]=++id; pos[id]=p;  
    for( int i=head[p];i;i=nxt[i] )    
    {    
        int x=ver[i];    
        dfs( x );    
        siz[p]+=siz[x];  
    }    
}    
    
int main()    
{    
    // freopen( "txt.in","r",stdin );    
    // freopen( "txt.out","w",stdout );    
    ios::sync_with_stdio( false );    
    cin.tie( nullptr ), cout.tie( nullptr );    
    cin>>n>>W;   
    for( int i=1, d;i<=n;i++ ) cin>>d, add( d,i );    
    for( int i=1;i<=n;i++ )    cin>>w[i];  
    for( int i=1;i<=n;i++ )    cin>>v[i];    
    dfs( 0 );  
    memset( f,0xc0,sizeof f );  
    f[idx( 2,0 )]=0;  
    for( int i=2, p;i<=n+1;i++ )    
    {  
        p=pos[i];  
        for( int j=0;j<=W;j++ )  
        {  
            f[idx( i+siz[p],j )]=max( f[idx( i+siz[p],j )],f[idx( i,j )] );  
            if( j+w[p] <= W ) f[idx( i+1,j+w[p] )]=max( f[idx( i+1,j+w[p] )],f[idx( i,j )]+v[p] );  
        }  
    }  
    int ans=0;  
    for( int j=0;j<=W;j++ ) ans=max( ans,f[idx( n+2,j )] );  
    cout<<ans;  
    QWQ    
}
]]> 题解 动态规划 背包DP 树形DP <![CDATA[Cow Poetry]]> https://your-docusaurus-site.example.com/blog-posts/题解/USACO/2019-Jan-Gold/A-Cow-Poetry https://your-docusaurus-site.example.com/blog-posts/题解/USACO/2019-Jan-Gold/A-Cow-Poetry Thu, 17 Sep 2026 00:00:00 GMT

现在我们只需要知道每个长度对应情况的方案数，看作完全背包计数就好理解了

所以按照韵脚分类在对每个需要押韵的点枚举即可

时间复杂度：O(26×n)O(26\times n)

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define pii pair< int,int >
#define QWQ return 0;
#define QAQ return 

const int N=5e3+10, M=1e5+10, mod=1e9+7;

int n, m, k;
int s[N];
int vis[26];
ll f[N], g[N];
ll ans[26];
vector< int > c[N];

inline ll quick_power( ll a,ll b )
{
    ll ans=1, base=a;
    while( b )
    {
        if( b&1 ) ( ans*=base )%=mod;
        ( base*=base )%=mod; b>>=1;
    }
    QAQ ans;
}

inline void init()
{
    f[0]=1;
    for( int j=0;j<=k;j++ ) for( int i=1;i<=n;i++ )
        if( j >= s[i] ) ( f[j]+=f[j-s[i]] )%=mod;
    for( int i=1;i<=n;i++ ) ( g[i]=f[k-s[i]] )%=mod;
}

int main()
{
    // freopen( "1.in","r",stdin );
    // freopen( "1.out","w",stdout );
    ios::sync_with_stdio( false );
    cin.tie( nullptr ); cout.tie( nullptr );
    cin>>n>>m>>k;
    for( int i=1, x;i<=n;i++ )
        cin>>s[i]>>x, c[x].push_back( i );
    init();
    char op;
    for( int i=1;i<=m;i++ ) cin>>op, vis[op-'A']++;
    for( int i=1;i<=n;i++ )
    {
        ll sum=0;
        for( auto &x:c[i] ) ( sum+=g[x] )%=mod;
        for( int j=0;j<26;j++ ) if( vis[j] ) ( ans[j]+=quick_power( sum,vis[j] ) )%=mod;
    }
    ll mul=1;
    for( int i=0;i<26;i++ ) ( mul*=max( 1ll,ans[i] ) )%=mod;
    cout<<mul;
    QWQ
}
]]> 题解 USACO 数学 背包DP <![CDATA[Sleepy Cow Sorting]]> https://your-docusaurus-site.example.com/blog-posts/题解/USACO/2019-Jan-Gold/B-Sleepy-Cow-Sorting https://your-docusaurus-site.example.com/blog-posts/题解/USACO/2019-Jan-Gold/B-Sleepy-Cow-Sorting Thu, 17 Sep 2026 00:00:00 GMT

给出一个序列，每次可以将第一个值插入，求使其有序的步骤数量

相当于找一个极长的后缀不降子序列，将前面的数插入进去并查询排名

那么这个树状数组，线段树或者平衡树都可以解决了

时间复杂度：O(nlogn)O(nlogn)

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define pii pair< int,int >
#define QWQ return 0;
#define QAQ return

const int N=1e5+10;

int n;
int p[N];
int tree[N];

inline int lowbit( int x ){ QAQ x&-x; }

inline void add( int x,int y )
{ for( ;x<=n;x+=lowbit( x ) ) tree[x]+=y; }

inline int query( int x )
{
    int ans=0;
    for( ;x;x-=lowbit( x ) ) ans+=tree[x];
    QAQ ans;
}

int main()
{
    // freopen( "1.in","r",stdin );
    // freopen( "1.out","w",stdout );
    ios::sync_with_stdio( false );
    cin.tie( nullptr ); cout.tie( nullptr );
    cin>>n;
    for( int i=1;i<=n;i++ ) cin>>p[i]; 
    set< int > ans;
    p[n+1]=n+1;
    for( int i=n;i>=1;i-- )
        if( p[i] < p[i+1] ) ans.insert( p[i] ), add( p[i],1 );
        else                break;
    int m=n-ans.size();
    ans.insert( 0 ); ans.insert( n+1 );
    cout<<m<<"\n";
    for( int i=1;i<=m;i++ )
    {
        auto it=prev( ans.upper_bound( p[i] ) );
        int rnk=query( *it );
        //未排序位还有m-i个
        cout<<m-i+rnk<<" ";
        ans.insert( p[i] ); add( p[i],1 );
    }
    QWQ
}
]]> 题解 USACO 贪心 平衡树 树状数组 <![CDATA[Shortcut]]> https://your-docusaurus-site.example.com/blog-posts/题解/USACO/2019-Jan-Gold/C-Shortcut https://your-docusaurus-site.example.com/blog-posts/题解/USACO/2019-Jan-Gold/C-Shortcut Thu, 17 Sep 2026 00:00:00 GMT

新路一定是要在原来路径上才会选择走，那么我们把最短路全部找下来定方向发现这是一张DAGDAG

之后我们再跑拓扑将每个点有多少奶牛记录，再根据它到11距离计算新解

时间复杂度：O(mlogm+n+m)O(mlogm+n+m)

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define pii pair< int,int >
#define QWQ return 0;
#define QAQ return
#define pli pair< ll,int >
#define int long long

const int N=1e4+10;

int c[N], pre[N], deg[N];
ll dis[N], tot[N];
vector< int > sp_rode[N];
vector< pii > rode[N];

inline void Dijikstra()
{
    memset( dis,0x3f,sizeof dis );
    priority_queue< pli,vector< pli >,greater< pli > > pq;
    pq.push( { 0,1 } ); dis[1]=0;
    while( !pq.empty() )
    {
        auto [d,p]=pq.top();
        pq.pop();
        if( d > dis[p] ) continue;
        for( auto &[x,w]:rode[p] )
            if( dis[x] > dis[p]+w )
                dis[x]=dis[p]+w, pre[x]=p,
                pq.push( { dis[x],x } );
            else if( dis[x] == dis[p]+w && p < pre[x] )
                pre[x]=p;
    }
}

signed main()
{
    // freopen( "1.in","r",stdin );
    // freopen( "1.out","w",stdout );
    ios::sync_with_stdio( false );
    cin.tie( nullptr ); cout.tie( nullptr );
    int n, m, t;
    cin>>n>>m>>t;
    for( int i=1;i<=n;i++ ) cin>>c[i];
    for( int i=1, u, v, w;i<=m;i++ )
        cin>>u>>v>>w,
        rode[u].push_back( { v,w } ), rode[v].push_back( { u,w } );
    for( int i=1;i<=n;i++ ) sort( rode[i].begin(),rode[i].end() );
    Dijikstra();
    for( int i=2;i<=n;i++ ) sp_rode[i].push_back( pre[i] ), deg[pre[i]]++;
    queue< int > topsort;
    for( int i=1;i<=n;i++ )
    {
        tot[i]=c[i];
        if( !deg[i] ) topsort.push( i );
    }
    while( !topsort.empty() )
    {
        auto p=topsort.front();
        topsort.pop();
        for( auto &x:sp_rode[p] )
        {
            tot[x]+=tot[p];
            if( !( --deg[x] ) ) topsort.push( x );
        }
    }
    ll ans=0;
    for( int i=1;i<=n;i++ ) ans=max( ans,1ll*( dis[i]-t )*tot[i] );
    cout<<ans;
    QWQ  
}
]]> 题解 USACO 最短路 拓扑排序 <![CDATA[Fine Dining]]> https://your-docusaurus-site.example.com/blog-posts/题解/USACO/2018-Dec-Gold/A-Fine-Dining https://your-docusaurus-site.example.com/blog-posts/题解/USACO/2018-Dec-Gold/A-Fine-Dining Wed, 16 Sep 2026 00:00:00 GMT

首先就是最容易想到的多源转单源，并且跑第一次最短路记录没有草干扰的disdis

然后我最先想到的是将草点拆了变成一条负权边，但是后面就发现这个就是一个边权+点权的最短路了

那么又因为只能选择一个草点，那么就是点权变成图间路径的一个分层图，最后检测选了草点的能不能保证时间不变大就行了

那么跑这个首先就是因为负权边所以可以 SPFASPFA，随便卡卡还是能过的

其次就是复杂度稳定一点的处理后 DijistraDijistra，对两个分层图独立跑最短路，跑完无草点图的后转点权放在第二张图就行了

时间复杂度：O(nlogm)O(nlogm)

#include<bits/stdc++.h>  
using namespace std;  
#define ll long long  
#define pii pair< int,int >  
#define QWQ return 0;  
#define QAQ return   
  
const int N=5e4+10;  
  
int n;  
ll grass[N];  
bool vis[N][2];  
ll   dis[N][2];  
vector< pii > rode[N];  
  
inline void SPFA()  
{     
    memset( dis,0x3f,sizeof dis );
    deque< pii > q;  
    q.push_back( { n,0 } ); dis[n][0]=0;  
    ll sum=0;  
    while( !q.empty() )  
    {  
        while( !q.empty() && dis[q.front().first][q.front().second] > sum/(ll)q.size() ) q.push_back( q.front() ), q.pop_front();  
        auto [p,op]=q.front();  
        q.pop_front();  
        vis[p][op]=false;  
        sum-=dis[p][op];  
        for( auto &[x,w]:rode[p] )  
        {  
            ll nd=dis[p][op]+w;  
            if( dis[x][op] > nd )  
            {  
                if( vis[x][op] ) sum-=dis[x][op];  
                dis[x][op]=nd;  
                sum+=dis[x][op];  
                if( !vis[x][op] )   
                {  
                    if( q.empty() || dis[q.front().first][q.front().second] > dis[x][op] ) q.push_front( { x,op } );  
                    else                                                                     q.push_back( { x,op } );  
                    vis[x][op]=true;  
                }  
            }  
        }  
        if( !op )  
            for( auto &[x,w]:rode[p] ) if( grass[x] )  
            {  
                ll nd=dis[p][op]+w-grass[x]-1;  
                if( dis[x][op^1] > nd )  
                {  
                    if( vis[x][op^1] ) sum-=dis[x][op^1];  
                    dis[x][op^1]=nd;  
                    sum+=dis[x][op^1];  
                    if( !vis[x][op^1] )   
                    {  
                        if( q.empty() || dis[q.front().first][q.front().second] > dis[x][op^1] ) q.push_front( { x,op^1 } );  
                        else                                                                     q.push_back( { x,op^1 } );  
                        vis[x][op^1]=true;  
                    }  
                }  
            }  
    }  
}  
  
int main()  
{  
    // freopen( "1.in","r",stdin );  
    // freopen( "1.out","w",stdout );  
    ios::sync_with_stdio( false );  
    cin.tie( nullptr ); cout.tie( nullptr );  
    int m, k;  
    cin>>n>>m>>k;  
    for( int i=1, u, v, w;i<=m;i++ )  
        cin>>u>>v>>w,  
        rode[u].push_back( { v,w } ), rode[v].push_back( { u,w } );  
    for( int i=1, x;i<=k;i++ )  
    {  
        ll y;  
        cin>>x>>y;  
        grass[x]=max( grass[x],y );  
    }  
    SPFA();  
    for( int i=1;i<n;i++ ) cout<<( dis[i][0] > dis[i][1] )<<"\n";  
    QWQ  
}
]]> 题解 USACO 最短路 分层图 <![CDATA[Cowpatibility]]> https://your-docusaurus-site.example.com/blog-posts/题解/USACO/2018-Dec-Gold/B-Cowpatibility https://your-docusaurus-site.example.com/blog-posts/题解/USACO/2018-Dec-Gold/B-Cowpatibility Wed, 16 Sep 2026 00:00:00 GMT

首先入手点肯定是在于每个牛冰淇淋数量只有55上面，所以我们可以很容易想到容斥

然后现在问题在与怎么寻找对应的状态

然后......

我是SBSB

我写一堆的bitsetbitset套mapmap来存，直接MLEMLE

这里的处理是将组合处理成字符串形式，也能保证一一对应，那么就好做了

时间复杂度：O(25×n)O(2^5\times n)

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define pii pair< int,int >
#define QWQ return 0;
#define QAQ return

const int N=5e4+10;

string a[5];
unordered_map< string,int > mp;

int main()
{
    // freopen( "1.in","r",stdin );
    // freopen( "1.out","w",stdout );
    ios::sync_with_stdio( false );
    cin.tie( nullptr ); cout.tie( nullptr );
    int n;
    cin>>n;
    ll ans=1ll*( n-1 )*n>>1;
    for( int i=1;i<=n;i++ )
    {
        for( int j=0;j<5;j++ ) cin>>a[j];
        sort( a,a+5 );
        for( int state=1, popc=0;state<( 1<<5 );state++ )
        {
            string s=""; popc=0;
            for( int bit=0;bit<5;bit++ ) if( ( state>>bit )&1 )
                s+=a[bit]+' ', popc++;//记得加空格
            if( popc&1 ) ans-=mp[s];
            else         ans+=mp[s];
            mp[s]++;
        }
    }
    cout<<ans;
    QWQ
}
]]> 题解 USACO 容斥定理 哈希 <![CDATA[Teamwork]]> https://your-docusaurus-site.example.com/blog-posts/题解/USACO/2018-Dec-Gold/C-Teamwork https://your-docusaurus-site.example.com/blog-posts/题解/USACO/2018-Dec-Gold/C-Teamwork Wed, 16 Sep 2026 00:00:00 GMT

首先我们自然思路下来设计状态fif_i表示将前ii个做完的最大答案

那么转移方程就是fi=max(fj−1+max a[j,i]×(i−j+1)),j∈[max(1,i−k+1),i]f_i=max(f_{j-1}+max\ a_{[j,i]}\times (i-j+1)),j\in [max(1,i-k+1),i]

然后我们发现复杂度就是O(nk)O(nk)结束了???

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define pii pair< int,int >
#define QWQ return 0;
#define QAQ return

const int N=1e4+10, K=1e3+10;

int w[N];
ll f[N];

int main()
{
    // freopen( "1.in","r",stdin );
    // freopen( "1.out","w",stdout );
    ios::sync_with_stdio( false );
    cin.tie( nullptr ); cout.tie( nullptr );
    int n, k;
    cin>>n>>k;
    for( int i=1;i<=n;i++ ) cin>>w[i];
    for( int i=1;i<=n;i++ )
    {
        int maxv=0;
        for( int j=i;j>=max( 1,i-k+1 );j-- )
            maxv=max( maxv,w[j] ),
            f[i]=max( f[i],f[j-1]+1ll*maxv*( i-j+1 ) );
    }
    cout<<f[n];
    QWQ 
}
]]> 题解 USACO 动态规划 <![CDATA[MooTube]]> https://your-docusaurus-site.example.com/blog-posts/题解/洛谷-or-Nsoj/2026-09-15测试/A-MooTube https://your-docusaurus-site.example.com/blog-posts/题解/洛谷-or-Nsoj/2026-09-15测试/A-MooTube Tue, 15 Sep 2026 00:00:00 GMT

因为我们其实就是找一个连通块，使连通块里面没有不符合的边(权值过小的边)

那么就是离线处理模拟一下生成树求连通块大小即可

并查集即可，时间复杂度：O(n+q)O(n+q)

/*
模拟一遍生成树，并查集模板了这不是
*/
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define pii pair< int,int >
#define QWQ return 0;
#define QAQ return 

const int N=1e5+10;

struct EDGE
{
    bool op;
    int x, y, z;

    bool operator< ( const EDGE &a )const
    {
        if( z == a.z ) QAQ op < a.op;
        QAQ z > a.z;
    }

}ask[N<<1];

int fa[N], siz[N];
int ans[N];

inline int get( int x )
{ QAQ ( fa[x] == x ? x : fa[x] = get( fa[x] ) ); }

inline void merge( int x,int y )
{
    x=get( x ); y=get( y );
    if( siz[x] > siz[y] ) fa[y]=x, siz[x]+=siz[y];
    else                  fa[x]=y, siz[y]+=siz[x];
}

int main()
{
    // freopen( "1.in","r",stdin );
    // freopen( "1.out","w",stdout );
    ios::sync_with_stdio( false );
    cin.tie( nullptr ); cout.tie( nullptr );
    int n, q;
    cin>>n>>q;
    for( int i=1, u, v, x;i<n;i++ ) 
        cin>>u>>v>>x, ask[i]={ 0,u,v,x };
    for( int i=1, x, y;i<=q;i++ )
        cin>>x>>y, ask[n+i-1]={ 1,i,y,x };
    for( int i=1;i<=n;i++ ) fa[i]=i, siz[i]=1;
    sort( ask+1,ask+n+q );
    for( int i=1;i<n+q;i++ )
    {
        auto &[op,u,v,w]=ask[i];
        if( op ) ans[u]=siz[get( v )];
        else     merge( u,v );
    }
    for( int i=1;i<=q;i++ ) cout<<ans[i]-1<<"\n";
	QWQ
}
]]> 题解 并查集 离线处理 <![CDATA[Dishwashing]]> https://your-docusaurus-site.example.com/blog-posts/题解/洛谷-or-Nsoj/2026-09-15测试/B.Dishwashing https://your-docusaurus-site.example.com/blog-posts/题解/洛谷-or-Nsoj/2026-09-15测试/B.Dishwashing Tue, 15 Sep 2026 00:00:00 GMT

贪心一下每次放一个盘子，如果下一个是xx需要满足以下情况：

<1> 找到一堆极左的盘子，满足该堆盘子里至少有一个盘子编号大于xx。

<2> 如果该堆盘子中有小于xx的，就把所有小于xx的盘子拿走洗掉以保证单调性

AIAI 说时间复杂度均摊的O(n+n)O(n+n)，但是也可以二分O(nlogn)O(nlogn)解决

/*
先将较小的尽量放在左边，如果序列中有更小的就弹出

woc怎么样例全过了
*/
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define pii pair< int,int >
#define QWQ return 0;
#define QAQ return

const int N=1e5+10;

int idx1[N];
stack< int > idx2[N];

int main()
{
    // freopen( "1.in","r",stdin );
    // freopen( "1.out","w",stdout );
    ios::sync_with_stdio( false );
    cin.tie( nullptr ); cout.tie( nullptr );
    int n;
    cin>>n;
    int pre=0;
    for( int i=1, x;i<=n;i++ )
    {
        cin>>x;
        if( x < pre )
        { cout<<i-1; QWQ }
        for( int j=x;j>=1 && !idx1[j];j-- ) idx1[j]=x;
        while( !idx2[idx1[x]].empty() && idx2[idx1[x]].top() < x )
            pre=idx2[idx1[x]].top(), idx2[idx1[x]].pop();
        idx2[idx1[x]].push( x );
    }
    cout<<n;
    QWQ
}
]]> 题解 贪心 <![CDATA[Grass Cownoisseur]]> https://your-docusaurus-site.example.com/blog-posts/题解/洛谷-or-Nsoj/2026-09-15测试/C-Grass-Cownoisseur https://your-docusaurus-site.example.com/blog-posts/题解/洛谷-or-Nsoj/2026-09-15测试/C-Grass-Cownoisseur Tue, 15 Sep 2026 00:00:00 GMT 首先第一步就是缩点，这个可以很容易的想到，因为我们一个环内是可以一只走全部取贡献的

然后我们看一下图，只有这样的情况才会使橙色边反转后满足回到初始点形成环

所以建正反图之后枚举边即可

时间复杂度：O(n+m)O(n+m)

#include<bits/stdc++.h>  
using namespace std;   
#define ll long long  
#define pii pair< int,int >  
#define QWQ return 0;   
#define QAQ return  
  
const int N=1e5+10;   
  
int idx, cnt, num;   
int dfn[N], low[N];   
int group[N], val[N], deg1[N], deg2[N];   
int dis1[N], dis2[N];   
bool in[N];   
stack< int > stk;   
vector< int > rode[N], frt_rode[N], bck_rode[N];   
  
inline void dfs( int p,int fa )   
{   
    dfn[p]=low[p]=++idx;   
    stk.push( p ); in[p]=true;   
    for( auto &x:rode[p] )   
        if( !dfn[x] )   
        {   
            dfs( x,p );   
            low[p]=min( low[p],low[x] );   
        }   
        else if( in[x] ) low[p]=min( low[p],dfn[x] );   
    if( dfn[p] == low[p] )   
    {   
        ++cnt;   
        while( stk.top() != p )   
        {   
            val[cnt]++;   
            group[stk.top()]=cnt;   
            in[stk.top()]=false;   
            stk.pop();   
        }   
        val[cnt]++;   
        group[stk.top()]=cnt;   
        in[stk.top()]=false;   
        stk.pop();   
    }   
}   
  
int main()   
{   
	// freopen( "1.in","r",stdin );
    // freopen( "1.out","w",stdout );
    ios::sync_with_stdio( false );   
    cin.tie( nullptr ); cout.tie( nullptr );   
    int n, m;   
    cin>>n>>m;   
    for( int i=1, x, y;i<=m;i++ )   
        cin>>x>>y, rode[x].push_back( y );   
    for( int i=1;i<=n;i++ ) if( !dfn[i] ) dfs( i,0 );   
  
    for( int u=1;u<=n;u++ ) for( auto &v:rode[u] )   
        if( group[u] != group[v] )   
            frt_rode[group[u]].push_back( group[v] ), deg1[group[v]]++,   
            bck_rode[group[v]].push_back( group[u] ), deg2[group[u]]++;
  
    queue< int > q1;   
    for( int i=1;i<=cnt;i++ ) if( !deg1[i] ) q1.push( i );   
    memset( dis1,0xcf,sizeof dis1 );   
    dis1[group[1]]=val[group[1]];   
    while( !q1.empty() )   
    {   
        auto p=q1.front();   
        q1.pop();   
        for( auto &x:frt_rode[p] )   
        {   
            if( dis1[p] > 0 ) dis1[x]=max( dis1[x],dis1[p]+val[x] );   
            if( !( --deg1[x] ) ) q1.push( x );   
        }   
    }   
  
    queue< int > q2;   
    for( int i=1;i<=cnt;i++ ) if( !deg2[i] ) q2.push( i );   
    memset( dis2,0xcf,sizeof dis2 );   
    dis2[group[1]]=val[group[1]];   
    while( !q2.empty() )   
    {   
        auto p=q2.front();   
        q2.pop();   
        for( auto &x:bck_rode[p] )   
        {   
            if( dis2[p] > 0 ) dis2[x]=max( dis2[x],dis2[p]+val[x] );   
            if( !( --deg2[x] ) ) q2.push( x );   
        }   
    }   
    int ans=val[group[1]];   
    for( int u=1;u<=cnt;u++ ) for( auto &v:frt_rode[u] )   
        ans=max( ans,dis1[v]+dis2[u]-val[group[1]] );   
    cout<<ans;   
    QWQ   
}
]]> 题解 Tarjan 强连通分量 拓扑排序 <![CDATA[快餐店]]> https://your-docusaurus-site.example.com/blog-posts/题解/洛谷-or-Nsoj/2026-09-15测试/D-fast-food-restaurant https://your-docusaurus-site.example.com/blog-posts/题解/洛谷-or-Nsoj/2026-09-15测试/D-fast-food-restaurant Tue, 15 Sep 2026 00:00:00 GMT

首先我们很容易想到我们的答案就是二分之一的直径

首先考虑树上怎么找，然后分割成环和子树，然后就可以了

时间复杂度：O(n)O(n)

#include<bits/stdc++.h>    
using namespace std;    
#define ll long long    
#define pii pair< int,int >    
#define QWQ return 0;  
#define QAQ return    
  
const int N=1e5+10;   
  
int idx, m;  
int dfn[N], fa[N];  
int circle[N], tmp[N];  
ll val[N];  
bool on_circle[N];  
vector< pii > rode[N];  
  
inline void dfs( int p )  
{  
    dfn[p]=++idx;  
    for( auto &[x,w]:rode[p] ) if( x != fa[p] )  
        if(!dfn[x])  
        {  
            fa[x]=p; tmp[x]=w;  
            dfs( x );  
        }  
        else if( dfn[x] > dfn[p] )  
        {  
            for( int i=x;i!=p;i=fa[i] )  
            {  
                on_circle[i]=true;  
                circle[++m]=i;  
                val[m]=tmp[i];  
            }  
            on_circle[p]=true;  
            circle[++m]=p;  
            val[m]=w;  
        }  
}  
  
ll Diameter;  
ll dis[N];  
  
inline void tree_dp( int p )  
{  
    for( auto &[x,w]:rode[p] ) if( !on_circle[x] && x != fa[p] )  
    {  
        tree_dp( x );  
        Diameter=max( Diameter,dis[p]+dis[x]+w );  
        dis[p]=max( dis[p],dis[x]+w );  
    }  
}  
  
ll a1[N], b1[N];  
ll a2[N], b2[N];  
  
int main()    
{    
    // freopen( "1.in","r",stdin );    
    // freopen( "1.out","w",stdout );    
    ios::sync_with_stdio( false );    
    cin.tie( nullptr ); cout.tie( nullptr );  
    int n;  
    cin>>n;  
    for( int i=1, u, v, w;i<=n;i++ )  
        cin>>u>>v>>w,  
        rode[u].push_back( { v,w } ), rode[v].push_back( { u,w } );  
    dfs( 1 );  
    for( int i=1;i<=m;i++ ) tree_dp( circle[i] );  
    ll sum, maxv;  
    sum=0, maxv=0;  
    for( int i=1;i<=m;i++ )  
    {  
        sum+=val[i-1];  
        a1[i]=max( a1[i-1],dis[circle[i]]+sum );  
        b1[i]=max( b1[i-1],sum+maxv+dis[circle[i]] );  
        maxv =max( maxv,dis[circle[i]]-sum );  
    }  
    ll tmp=val[m]; val[m]=0;  
    sum=0, maxv=0;  
    for( int i=m;i>=1;i-- )  
    {  
        sum+=val[i];  
        a2[i]=max( a2[i+1],dis[circle[i]]+sum );  
        b2[i]=max( b2[i+1],sum+maxv+dis[circle[i]] );  
        maxv =max( maxv,dis[circle[i]]-sum );  
    }  
    ll tmpp;  
    ll ans=b1[m];  
    for( int i=1;i<m;i++)  
    {  
        tmpp=max( b1[i],b2[i+1] );  
        tmpp=max( tmpp,a1[i]+a2[i+1]+tmp );  
        ans=min( tmpp,ans );  
    }  
    ans=max( Diameter,ans );  
    cout<<( ans>>1 )<<"."<<( ( ans&1 ) ? 5 : 0 );  
    QWQ      
}
]]> 题解 基环树 动态规划 <![CDATA[琪亚娜与送货]]> https://your-docusaurus-site.example.com/blog-posts/题解/洛谷-or-Nsoj/琪亚娜与OI比赛/D-琪亚娜与送货 https://your-docusaurus-site.example.com/blog-posts/题解/洛谷-or-Nsoj/琪亚娜与OI比赛/D-琪亚娜与送货 Tue, 15 Sep 2026 00:00:00 GMT

思路很 naivenaive 的毒瘤大 DSDS

首先我们看一下我们有那些操作：

<1> 树上区间查询大于等于某个数的数量。

<2> 树上单点修改。

<3> 树上区间加。

那么<2>这个就是很明显的一个树上数据结构的单点修改。

其次呢，<1>首先查询大于等于某个数的数量很明显的一个权值线段树或者树状数组。

因为要树上区间操作所以可以套一个树剖+树套树。

最后的<1>统计答案就是很简单的一个树上差分了。

时间复杂度：O(qlog3n)O(qlog^3n)。

但是 AIAI 写了一个 O(nnlogn+nlogn)O(\frac{n}{\sqrt n}logn+\sqrt nlogn)的更优分块做法。

树套树
/*
毒瘤大DS
首先树剖一下cao一颗权值线段树
其次发现区间查询大于等于某个数的个数，好的树套树
最后计算贡献就是写一个树上点差分就行
*/
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define pii pair< int,int >
#define QWQ return 0;
#define QAQ return

const int N=1e5+10;

int n, id;
int sumw[N], nw[N];
int siz[N], dep[N], fa[N];
int mson[N], top[N], dfn[N], idx[N];
ll del[N];
vector< int > w[N], tmp[N];
vector< int > rode[N];

struct OPERATOR
{
    int op;
    int x, y, z;
}ask[N];

struct Binary1
{
    vector< int > uni, bit;

    inline static int lowbit( int x ){ QAQ x&-x; }

    inline void init( vector< int > v )
    {
        uni=move( v );
        sort( uni.begin(),uni.end() );
        uni.erase( unique( uni.begin(),uni.end() ),uni.end() );
        bit.assign( uni.size()+1,0 );
    }

    inline void add1( int x,int y )
    { for( ;x<bit.size();x+=lowbit( x ) ) bit[x]+=y; }

    inline int query1( int x )
    {
        int ans=0;
        for( ;x;x-=lowbit( x ) ) ans+=bit[x];
        QAQ ans;
    }

    inline void add2( int x,int v )
    {
        int p=lower_bound( uni.begin(),uni.end(),x )-uni.begin()+1;
        add1( p,v );
    }

    inline int query2( int x )
    {
        if( uni.empty() ) QAQ 0;
        int p=lower_bound( uni.begin(),uni.end(),x )-uni.begin();
        QAQ query1( uni.size() )-query1( p );
    }
};

struct Binary2
{
    Binary1 bit1[N];

    inline static int lowbit( int x ){ QAQ x&-x; }

    inline void init()
    {
        for( int x=1;x<=n;x++ ) for( int i=dfn[x];i<=n;i+=lowbit( i ) )
        for( auto &y:w[x] )     tmp[i].push_back( y );
        for( int i=1;i<=n;i++ ) bit1[i].init( move( tmp[i] ) );
    }

    inline void add( int x,int y,int z )
    { for( ;x<=n;x+=lowbit( x ) ) bit1[x].add2( y,z ); }

    inline int query1( int x,int y )
    {
        int ans=0;
        for( ;x;x-=lowbit( x ) ) ans+=bit1[x].query2( y );
        QAQ ans;
    }

    inline int query2( int l,int r,int y )
    { QAQ query1( r,y )-query1( l-1,y ); }

}bit2;

inline void dfs1( int p,int Fa )
{
    siz[p]=1;
    dep[p]=dep[Fa]+1, fa[p]=Fa;
    for( auto &x:rode[p] ) if( x != Fa )
    {
        dfs1( x,p );
        siz[p]+=siz[x];
        if( siz[x] > siz[mson[p]] ) mson[p]=x;
    }
}

inline void dfs2( int p,int t )
{
    top[p]=t;
    dfn[p]=++id; idx[id]=p;
    if( !mson[p] ) QAQ;
    dfs2( mson[p],t );
    for( auto &x:rode[p] )
        if( x != fa[p] && x != mson[p] )dfs2( x,x );
}

inline int lca( int x,int y )
{
    while( top[x] != top[y] )
        if( dep[top[x]] > dep[top[y]] ) x=fa[top[x]];
        else                            y=fa[top[y]];
    QAQ ( dep[x] < dep[y] ? x : y );
}

inline int lcaquery( int x,int y,int z )
{
    int ans=0;
    while( top[x] != top[y] )
    {
        if( dep[top[x]] < dep[top[y]] ) swap( x,y );
        ans+=bit2.query2( dfn[top[x]],dfn[x],z );
        x=fa[top[x]];
    }
    if( dep[x] > dep[y] ) swap( x,y );
    ans+=bit2.query2( dfn[x],dfn[y],z );
    QAQ ans;
}

inline void Delta( int x,int y,ll v )
{
    int LCA=lca( x,y );
    del[x]+=v; del[y]+=v;
    del[LCA]-=v; del[fa[LCA]]-=v;
}

inline void dfs3( int p,int Fa )
{
    for( auto &x:rode[p] ) if( x != Fa )
        dfs3( x,p ), del[p]+=del[x];
}

int main()
{
    // freopen( "big_sample2.in","r",stdin );
    // freopen( "big_sample2.out","w",stdout );
    ios::sync_with_stdio( false );
    cin.tie( nullptr ); cout.tie( nullptr );
    cin>>n;
    for( int i=1;i<=n;i++ )
        cin>>nw[i], w[i].push_back( nw[i] ),
        sumw[i]+=nw[i];
    for( int i=1, u, v;i<n;i++ )
        cin>>u>>v,
        rode[u].push_back( v ), rode[v].push_back( u );
    dfs1( 1,0 ); dfs2( 1,1 );
    int q;
    cin>>q;
    for( int i=1;i<=q;i++ )
    {
        cin>>ask[i].op;
        if( ask[i].op == 1 )
        {
            cin>>ask[i].x>>ask[i].y;
            sumw[ask[i].x]+=ask[i].y;
            w[ask[i].x].push_back( sumw[ask[i].x] );
        }
        else cin>>ask[i].x>>ask[i].y>>ask[i].z;
    }
    bit2.init();
    for( int i=1;i<=n;i++ ) bit2.add( dfn[i],nw[i],1 );
    int lst=0;
    for( int i=1;i<=q;i++ )
    {
        auto &[op,x,y,z]=ask[i];
        if( op==1 )
        {
            bit2.add( dfn[x],nw[x],-1 );
            nw[x]+=y;
            bit2.add( dfn[x],nw[x], 1 );
        }
        else
        {
            z^=lst;
            lst=lcaquery( x,y,z );
            Delta( x,y,lst );
        }
    }
    dfs3( 1,0 );
    for( int i=1;i<=n;i++ ) cout<<del[i]<<" ";
	QWQ
}
分块
#include<bits/stdc++.h>
using namespace std;

const int MAXN=100005;
const int S=320;

int n,q;
int w[MAXN];
int fa[MAXN],dep[MAXN],sz[MAXN],son[MAXN];
int top[MAXN],dfn[MAXN],id[MAXN];
int timer;
long long add[MAXN];
vector<int> g[MAXN];
vector<int> block[MAXN];

void update_block(int x,int old_value,int new_value)
{
	int b=(dfn[x]-1)/S;
	vector<int>::iterator it=lower_bound(block[b].begin(),block[b].end(),old_value);
	block[b].erase(it);
	block[b].insert(lower_bound(block[b].begin(),block[b].end(),new_value),new_value);
}

int query_range(int l,int r,int upper)
{
	if(l>r)
		swap(l,r);
	int res=0;
	while(l<=r&&(l-1)%S!=0)
	{
		if(w[id[l]]>=upper)
			res++;
		l++;
	}
	while(l+S-1<=r)
	{
		int b=(l-1)/S;
		res+=(int)(block[b].end()-lower_bound(block[b].begin(),block[b].end(),upper));
		l+=S;
	}
	while(l<=r)
	{
		if(w[id[l]]>=upper)
			res++;
		l++;
	}
	return res;
}

int query_path(int u,int v,int upper,int &lca)
{
	int res=0;
	while(top[u]!=top[v])
	{
		if(dep[top[u]]<dep[top[v]])
			swap(u,v);
		res+=query_range(dfn[top[u]],dfn[u],upper);
		u=fa[top[u]];
	}
	if(dep[u]>dep[v])
		swap(u,v);
	res+=query_range(dfn[u],dfn[v],upper);
	lca=u;
	return res;
}

int main()
{
	ios::sync_with_stdio(false);
	cin.tie(nullptr);

	cin>>n;
	for(int i=1;i<=n;i++)
		cin>>w[i];

	for(int i=1;i<n;i++)
	{
		int u,v;
		cin>>u>>v;
		g[u].push_back(v);
		g[v].push_back(u);
	}

	vector<int> order;
	order.reserve(n);
	vector<int> st;
	st.push_back(1);
	fa[1]=0;
	dep[1]=1;
	while(!st.empty())
	{
		int u=st.back();
		st.pop_back();
		order.push_back(u);
		for(int v:g[u])
		{
			if(v==fa[u])
				continue;
			fa[v]=u;
			dep[v]=dep[u]+1;
			st.push_back(v);
		}
	}

	for(int i=n-1;i>=0;i--)
	{
		int u=order[i];
		sz[u]++;
		if(fa[u])
		{
			sz[fa[u]]+=sz[u];
			if(son[fa[u]]==0||sz[u]>sz[son[fa[u]]])
				son[fa[u]]=u;
		}
	}

	st.clear();
	st.push_back(1);
	top[1]=1;
	while(!st.empty())
	{
		int u=st.back();
		st.pop_back();
		int tp=top[u];
		for(int x=u;x;x=son[x])
		{
			top[x]=tp;
			dfn[x]=++timer;
			id[timer]=x;
			for(int v:g[x])
			{
				if(v!=fa[x]&&v!=son[x])
				{
					top[v]=v;
					st.push_back(v);
				}
			}
		}
	}

	int block_count=(n+S-1)/S;
	for(int i=1;i<=n;i++)
		block[(dfn[i]-1)/S].push_back(w[i]);
	for(int i=0;i<block_count;i++)
		sort(block[i].begin(),block[i].end());

	cin>>q;
	int cnt=0;
	while(q--)
	{
		int op;
		cin>>op;
		if(op==1)
		{
			int x,y;
			cin>>x>>y;
			int old_value=w[x];
			w[x]+=y;
			update_block(x,old_value,w[x]);
		}
		else
		{
			int u,v,upper;
			cin>>u>>v>>upper;
			upper^=cnt;

			int lca;
			cnt=query_path(u,v,upper,lca);

			add[u]+=cnt;
			add[v]+=cnt;
			add[lca]-=cnt;
			if(fa[lca])
				add[fa[lca]]-=cnt;
		}
	}

	for(int i=n-1;i>0;i--)
		add[fa[order[i]]]+=add[order[i]];

	for(int i=1;i<=n;i++)
	{
		if(i>1)
			cout<<" ";
		cout<<add[i];
	}
	cout<<"\n";

	return 0;
}
]]> 题解 线段树 树状数组 树套树 树链剖分 LCA 离线处理 分块 <![CDATA[琪亚娜与小蛋糕]]> https://your-docusaurus-site.example.com/blog-posts/题解/洛谷-or-Nsoj/琪亚娜与OI比赛/C-琪亚娜与小蛋糕 https://your-docusaurus-site.example.com/blog-posts/题解/洛谷-or-Nsoj/琪亚娜与OI比赛/C-琪亚娜与小蛋糕 Sun, 13 Sep 2026 00:00:00 GMT

感觉这题思维难度不算高，主要看阅读能力和斜优掌握。

首先先处理第一个吃蛋糕的问题，由题义：

gi=maxj=1i−1(bj×ai+gj)g_i=max_{j=1}^{i-1}( b_j\times a_i+g_j )

再处理第二个爬山的问题，由题义：

fi=minj=1i−1(fj+(gi−gj)2)f_i=min_{j=1}^{i-1}( f_j+(g_i-g_j)^2 )

所以容易得到一个O(n2)O(n^2)代码得到20pts20pts。

然后我们发现这两个都是可以斜优的，写下来：

gi=maxj=1i−1(bj×ai+gj)g_i=max_{j=1}^{i-1}( b_j\times a_i+g_j )

y=gi, k=bj, x=ai, b=gjy=g_i,\ k=b_j,\ x=a_i,\ b=g_j

fi=minj=1i−1(fj+(gi−gj)2)f_i=min_{j=1}^{i-1}( f_j+(g_i-g_j)^2 )

fi=minj=1i−1(f[j]+g[i]2−2×g[i]×g[j]+g[j]2)f_i=min_{j=1}^{i-1}( f[j]+g[i]^2-2\times g[i]\times g[j]+g[j]^2 )

y=fi, k=−2×g[j], x=g[i], b=f[j]+g[j]2y=f_i,\ k=-2\times g[j],\ x=g[i],\ b=f[j]+g[j]^2

对于第一个式子，双单增可以直接单调队列维护。

而对于第二个式子，容易发现gig_i也具有单调性，直接维护结束。

时间复杂度：O(n)O(n)

/*
g[i]=b[j]*a[i]+g[j]
k=b[j], x=a[i], b=g[j]
初线段：k=1, b=0

f[i]=f[j]+( g[i]​−g[j] ​)^2
f[i]=f[j]+g[i]^2-2\times g[i]\times g[j]+g[j]^2
k=-2\times g[j], x=g[i], b=f[j]+g[j]^2
初线段：k=-2\times g[1], b=0+g[1]^2
*/
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define pii pair< int,int >
#define QWQ return 0;
#define QAQ return
#define intt __int128
#define ull unsigned long long
#define uintt unsigned __int128

const int N=2e5+10;

struct Fuction
{
    intt k, b;

    inline intt f( const intt &x )const
    { QAQ k*x+b; }

};

inline void mul128( uintt a,uintt b,uintt &hi,uintt &lo )
{
    ull al=( ull )a, ah=( ull )( a>>64 );
    ull bl=( ull )b, bh=( ull )( b>>64 );
    uintt p00=( uintt )al*bl;
    uintt p01=( uintt )al*bh;
    uintt p10=( uintt )ah*bl;
    uintt p11=( uintt )ah*bh;
    uintt mid=( p00>>64 )+( ull )p01+( ull )p10;
    lo=( p00&( ( ( uintt )1<<64 )-1 ) )|( mid<<64 );
    hi=p11+( p01>>64 )+( p10>>64 )+( mid>>64 );
}

inline bool mul_leq( intt a,intt b,intt c,intt d )
{
    int s1=( a<0 )^( b<0 );
    int s2=( c<0 )^( d<0 );
    if( s1 != s2 ) QAQ s1 > s2;
    uintt ua=( a < 0 ? ( uintt )-( a+1 )+1 : ( uintt )a );
    uintt ub=( b < 0 ? ( uintt )-( b+1 )+1 : ( uintt )b );
    uintt uc=( c < 0 ? ( uintt )-( c+1 )+1 : ( uintt )c );
    uintt ud=( d < 0 ? ( uintt )-( d+1 )+1 : ( uintt )d );
    uintt hi1,lo1,hi2,lo2;
    mul128( ua,ub,hi1,lo1 );
    mul128( uc,ud,hi2,lo2 );
    bool abs_leq=( hi1 != hi2 ? hi1 < hi2 : lo1 <= lo2 );
    QAQ ( s1 ? !abs_leq : abs_leq );
}

inline bool check( Fuction f1,Fuction f2,Fuction f3 )
{
    QAQ mul_leq( f3.b-f2.b,f1.k-f2.k,
                 f2.b-f1.b,f2.k-f3.k );
}

intt a[N], b[N], g[N], f[N];

inline intt read()
{
    intt w=0;
    char ch=getchar();
    while( isdigit( ch ) )
    {
        w=w*10+ch-'0';
        ch=getchar();
    }
    QAQ w;
}

inline void print( intt num )
{
    if( num > 9 ) print( num/10 );
    putchar( num%10+'0' );
}

int main()
{
    // freopen( "big_sample2.in","r",stdin );
    // freopen( "big_sample2.out","w",stdout );
    // ios::sync_with_stdio( false );
    // cin.tie( nullptr ); cout.tie( nullptr );
    int n=read();
    for( int i=1;i<=n;i++ ) a[i]=read();
    for( int i=1;i<=n;i++ ) b[i]=read();
    deque< Fuction > dq1;
    dq1.push_back( { 1,0 } );
    for( int i=1;i<=n;i++ )
    {
        intt x=a[i];
        while( dq1.size() >= 2 && dq1[0].f( x ) <= dq1[1].f( x ) ) dq1.pop_front();
        g[i]=dq1.front().f( x );
        Fuction nf={ b[i],g[i] };
        while( dq1.size() >= 2 && check( dq1[dq1.size()-2],dq1[dq1.size()-1],nf ) ) dq1.pop_back();
        dq1.push_back( nf );
        assert( g[i] >= g[i-1] );
    }
    deque< Fuction > dq2;
    dq2.push_back( { ( intt )-2*g[1],g[1]*g[1] } );
    for( int i=1;i<=n;i++ )
    {
        intt x=g[i];
        while( dq2.size() >= 2 && dq2[0].f( x ) >= dq2[1].f( x ) ) dq2.pop_front();
        f[i]=dq2.front().f( x )+x*x;
        Fuction nf={ ( intt )-2*g[i],f[i]+g[i]*g[i] };
        while( dq2.size() >= 2 && check( dq2[dq2.size()-2],dq2[dq2.size()-1],nf ) ) dq2.pop_back();
        dq2.push_back( nf );
    }
    print( g[n] );
    cout<<"\n";
    print( f[n] );
	QWQ
}
]]> 题解 动态规划 斜率优化 <![CDATA[琪亚娜与赤鸢]]> https://your-docusaurus-site.example.com/blog-posts/题解/洛谷-or-Nsoj/琪亚娜与OI比赛/A-琪亚娜与赤鸢 https://your-docusaurus-site.example.com/blog-posts/题解/洛谷-or-Nsoj/琪亚娜与OI比赛/A-琪亚娜与赤鸢 Fri, 11 Sep 2026 00:00:00 GMT

首先我们考虑如何才能同时选中一些赤鸢，那么需要满足这个条件。

记录值ci=ai−bic_i=a_i-b_i，在放置中一直满足∑bi+ci≤V\sum b_i +c_i \le V。

因为bi+ci=aib_i+c_i=a_i，我们放置首要是看它能不能放进去，然后就等价于一个bib_i的物品了。

那么我们就相当于选择一些bib_i再选择一个aia_i，那么一贪心我们把这个cic_i最大的最后放就更优了，这样可以在前面的情况下尽可能留空间。

那我们不妨对cic_i逆序排一遍，然后贪心放入就可以了。

具体证明如下：

我们如果下个数放bi,ci{b_i,c_i}满足ci≤ci−1c_i \le c_{i-1}，记录放这个数和前一个数会产生的集合最大体积为SS。

考虑临项交换，则交换前后产生的最大集合体积为。

换前：S+bi−1+ai=S+bi−1+bi+ciS+b_{i-1}+a_i=S+b_{i-1}+b_i+c_i

换后：S+bi+ai−1=S+bi+bi−1+ci−1S+b_i+a_{i-1}=S+b_i+b_{i-1}+c_{i-1}

所以可以得到我们将cic_i从大到小选肯定不会更劣，那么考虑换贡献的时候我们只需要将最大bib_i删去就行。

因为我们还要输出一组答案，所以可以重复一遍上述操作模拟到最优答案点。

时间复杂度：O(nlogn)O(nlogn)。

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define pii pair< int,int >
#define QWQ return 0;
#define QAQ return
#define pli pair< ll,int >

const int N=5e5+10;

struct RedKite
{
	ll a, b, c;
	int idx;

	bool operator< ( const RedKite &x )const
	{ QAQ c > x.c; }

}kite[N];

bool chs[N];

int main()
{
    // freopen( "1.in","r",stdin );
    // freopen( "1.out","w",stdout );
    ios::sync_with_stdio( false );
    cin.tie( nullptr ); cout.tie( nullptr );
	int n;
	ll V;
	cin>>n>>V;
	for( int i=1;i<=n;i++ ) cin>>kite[i].a;
	for( int i=1;i<=n;i++ ) cin>>kite[i].b;
	for( int i=1;i<=n;i++ ) kite[i].c=kite[i].a-kite[i].b, kite[i].idx=i;
	sort( kite+1,kite+n+1 );
	priority_queue< pli > pq;
	int pos=0, siz=0;
	ll sum=0;
	for( int i=1;i<=n;i++ )
	{
		auto &[a,b,c,idx]=kite[i];
		pq.push( { b,idx } );
		sum+=b;
		while( !pq.empty() && sum+c > V )
			sum-=pq.top().first, pq.pop();
		if( pq.size() > siz ) siz=pq.size(), pos=i;
	}
	priority_queue< pli > ans;
	sum=0;
	for( int i=1;i<=pos;i++ )
	{
		auto &[a,b,c,idx]=kite[i];
		ans.push( { b,idx } );
		sum+=b;
		while( !ans.empty() && sum+c > V )
			sum-=ans.top().first, ans.pop();
	}
	cout<<ans.size()<<"\n";
	while( !ans.empty() ) chs[ans.top().second]=true, ans.pop();
	for( int i=1;i<=n;i++ ) cout<<chs[i]<<" ";
	QWQ
}
]]> 题解 贪心 <![CDATA[琪亚娜与虚数之海]]> https://your-docusaurus-site.example.com/blog-posts/题解/洛谷-or-Nsoj/琪亚娜与OI比赛/B-琪亚娜与虚数之海 https://your-docusaurus-site.example.com/blog-posts/题解/洛谷-or-Nsoj/琪亚娜与OI比赛/B-琪亚娜与虚数之海 Fri, 11 Sep 2026 00:00:00 GMT

我认为是比上一个题更简单的题目，我们容易想到每进入一个SCCSCC我们可以选择完所有的点。

所以TarjanTarjan缩点后保证DAGDAG再拓扑跑一遍就行。

时间复杂度：O(n+m)O(n+m)。

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define pii pair< int,int >
#define QWQ return 0;
#define QAQ return

const int N=1e5+10;

int idx, num;
int dfn[N], low[N];
int group[N], dge[N];
bool in[N];
ll sum[N], val[N], f[N];
stack< int > stk;
vector< int > rode[N], sp_rode[N];

inline void dfs( int p )
{
	dfn[p]=low[p]=++idx;
	in[p]=true;
	stk.push( p );
	for( auto &x:rode[p] )
	{
		if( !dfn[x] )
		{
			dfs( x );
			low[p]=min( low[p],low[x] );
		}
		else if( in[x] ) low[p]=min( low[p],dfn[x] );
	}
	if( dfn[p] == low[p] )
	{
        num++;
		while( stk.top() != p )
		{
			sum[num]+=val[stk.top()];
			group[stk.top()]=num;
			in[stk.top()]=false;
			stk.pop();
		}
		sum[num]+=val[stk.top()];
		group[stk.top()]=num;
		in[stk.top()]=false;
		stk.pop();
	}
}

int main()
{
    // freopen( "txt.in","r",stdin );
    // freopen( "txt.out","w",stdout );
    ios::sync_with_stdio( false );
    cin.tie( nullptr ); cout.tie( nullptr );
	int n, m;
    cin>>n>>m;
    for( int i=1;i<=n;i++ ) cin>>val[i];
    for( int i=1, u, v;i<=m;i++ )
        cin>>u>>v,
        rode[u].push_back( v );
    dfs( 1 );
    for( int u=1;u<=n;u++ ) for( auto &v:rode[u] ) if( group[u] != group[v] )
        sp_rode[group[u]].push_back( group[v] ), dge[group[v]]++;
    queue< int > topsort;
    memset( f,0xcf,sizeof f );
    topsort.push( group[1] );
    f[group[1]]=sum[group[1]];
    ll ans=0;
    while( !topsort.empty() )
    {
        auto p=topsort.front();
        topsort.pop();
        ans=max( ans,f[p] );
        for( auto &x:sp_rode[p] )
        {
            f[x]=max( f[x],f[p]+sum[x] );
            if( !( --dge[x] ) ) topsort.push( x );
        }
    }
    cout<<ans;
	QWQ
}
]]> 题解 Tarjan 强连通分量 拓扑排序