题解：【JOISC 2021 D4】 最悪の記者 4

题目链接

按 sub 层层思考。

树的暴力怎么做？建出树后要求后代的点权都不比祖先小，我们只关心点权间的大小关系，同时修改也是改成任意的值，所以实际值域上最多只有 $n$ 个数有用。离散化后考虑这样一个 DP，$f_{u,i}$ 表示节点 $u$ 选择权值为 $i$ 的最小代价，边界即为 $f_{u,i} = c_u [i \neq h_u]$。转移暴力枚举后代选择什么权值，有方程 $f_{u,i} = c_u [i \neq h_u] + \sum_{v \in son_u} \min_{j \geq i} f_{v,j}$。这样复杂度是 $\mathcal O(n^2)$ 的。

首先可以优化掉一个 $\mathcal O(n)$ 的过程：$i \neq h_u$ 非常的多，不妨先对结果加上 $c_u$，最后给 $i = h_u$ 减去 $c_u$ 即可，这样把一个区间加干成了单点减。注意到 $u$ 的取值只会为以 $u$ 为根的子树中的点权，现在需要做的是值域上的单点修改，区间查询最小值，考虑线段树合并。对于每个节点开一棵值域线段树来维护 DP 数组的第二维，这样的话右子树对于左子树是有贡献的，所以合并要先合并右区间再合并左区间。合并的操作是对值域每个位置加上它的后缀 DP 值的 $\min$。这样就将树做法优化到了 $\mathcal O(n \log n)$。

拓展到最后的内向基环树森林，答案为每一个基环树的答案的和。对于一棵内向基环树，首先找出环，对去掉环后剩下的若干棵树做上面的线段树合并即可，然后把答案合并到环上的点。能够发现环上的点取值全部相等，而且取值只可能为环上的点的值或最小值 $1$，于是遍历环上的点枚举取值，类似的在线段树上询问最小代价即可。至此总复杂度做到 $\mathcal O(n \log n)$。

#include<bits/stdc++.h>
#define ld long double
#define ui unsigned int
#define ull unsigned long long
#define int long long
#define eb emplace_back
#define pb pop_back
#define ins insert
#define mp make_pair
#define pii pair<int,int>
#define fi first
#define se second
#define power(x) ((x)*(x))
using namespace std;

namespace FastIO
{
    template<typename T=int> inline T read()
    {
        T s=0,w=1; char c=getchar();
        while(!isdigit(c)) {if(c=='-') w=-1; c=getchar();}
        while(isdigit(c)) s=(s*10)+(c^48),c=getchar();
        return s*w;
    }
    template<typename T> inline void read(T &s)
    {
        s=0; int w=1; char c=getchar();
        while(!isdigit(c)) {if(c=='-') w=-1; c=getchar();}
        while(isdigit(c)) s=(s*10)+(c^48),c=getchar();
        s=s*w;
    }
    template<typename T,typename... Args> inline void read(T &x,Args &...args)
    {
        read(x),read(args...);
    }
    template<typename T> inline void write(T x,char ch)
    {
        if(x<0) x=-x,putchar('-');
        static char stk[25]; int top=0;
        do {stk[top++]=x%10+'0',x/=10;} while(x);
        while(top) putchar(stk[--top]);
        if(ch!='~') putchar(ch);
        return;
    }
}
using namespace FastIO;

namespace MTool
{   
    #define TA template<typename T,typename... Args>
    #define TT template<typename T>
    static const int Mod=998244353;
    TT inline void Swp(T &a,T &b) {T t=a;a=b;b=t;}
    TT inline void cmax(T &a,T b) {a=max(a,b);}
    TT inline void cmin(T &a,T b) {a=min(a,b);}
    TA inline void cmax(T &a,T b,Args... args) {a=max({a,b,args...});}
    TA inline void cmin(T &a,T b,Args... args) {a=min({a,b,args...});}
    TT inline void Madd(T &a,T b) {a=a+b>=Mod?a+b-Mod:a+b;}
    TT inline void Mdel(T &a,T b) {a=a-b<0?a-b+Mod:a-b;}
    TT inline void Mmul(T &a,T b) {a=a*b%Mod;}
    TT inline void Mmod(T &a) {a=(a%Mod+Mod)%Mod;}
    TT inline T Cadd(T a,T b) {return a+b>=Mod?a+b-Mod:a+b;}
    TT inline T Cdel(T a,T b) {return a-b<0?a-b+Mod:a-b;}
    TT inline T Cmul(T a,T b) {return a*b%Mod;}
    TT inline T Cmod(T a) {return (a%Mod+Mod)%Mod;}
    TA inline void Madd(T &a,T b,Args... args) {Madd(a,Cadd(b,args...));}
    TA inline void Mdel(T &a,T b,Args... args) {Mdel(a,Cadd(b,args...));}
    TA inline void Mmul(T &a,T b,Args... args) {Mmul(a,Cmul(b,args...));}
    TA inline T Cadd(T a,T b,Args... args) {return Cadd(Cadd(a,b),args...);}
    TA inline T Cdel(T a,T b,Args... args) {return Cdel(Cdel(a,b),args...);}
    TA inline T Cmul(T a,T b,Args... args) {return Cmul(Cmul(a,b),args...);}
    TT inline T qpow(T a,T b) {int res=1; while(b) {if(b&1) Mmul(res,a); Mmul(a,a); b>>=1;} return res;}
    TT inline T qmul(T a,T b) {int res=0; while(b) {if(b&1) Madd(res,a); Madd(a,a); b>>=1;} return res;}
    TT inline T spow(T a,T b) {int res=1; while(b) {if(b&1) res=qmul(res,a); a=qmul(a,a); b>>=1;} return res;}
    TT inline void exgcd(T A,T B,T &X,T &Y) {if(!B) return X=1,Y=0,void(); exgcd(B,A%B,Y,X),Y-=X*(A/B);}
    TT inline T Ginv(T x) {T A=0,B=0; exgcd(x,Mod,A,B); return Cmod(A);}
    #undef TT
    #undef TA
}
using namespace MTool;

inline void file()
{
    freopen("1.in","r",stdin);
    freopen("1.out","w",stdout);
    return;
}

bool Mbe;

namespace LgxTpre
{
    static const int MAX=200010;
    static const int inf=2147483647;
    static const int INF=4557430888798830399;
    
    int n,ans;
    int a[MAX],h[MAX],c[MAX],d[MAX],cnt;
    vector<int> G[MAX];
    
    namespace SegmentTreeMerge
    {
    	int lson[MAX<<6],rson[MAX<<6],mix[MAX<<6],tag[MAX<<6];
    	int root[MAX],loot[MAX],tot,dl,dr;
    	inline void pushup(int i) {mix[i]=min(mix[lson[i]],mix[rson[i]]);}
    	inline void down(int i,int x) {if(i) mix[i]+=x,tag[i]+=x;}
    	inline void pushdown(int i) {if(tag[i]) down(lson[i],tag[i]),down(rson[i],tag[i]),tag[i]=0;}
		void change(int &i,int x,int l,int r,int k)
		{
			if(!i) i=++tot,mix[i]=tag[i]=0;
			if(l==r) return mix[i]=k,void();
			pushdown(i);
			int mid=(l+r)>>1;
			if(x<=mid) change(lson[i],x,l,mid,k);
			else change(rson[i],x,mid+1,r,k);
			pushup(i);
		}
		int merge(int x,int y,int l,int r)
		{
			if(!x&&!y) return 0;
			if(!x) return cmin(dr,mix[y]),down(y,dl),y;
			if(!y) return cmin(dl,mix[x]),down(x,dr),x;
			if(l==r) return cmin(dr,mix[y]),cmin(dl,mix[x]),mix[x]+dr<=mix[y]+dl?(down(x,dr),x):(down(y,dl),y);
			pushdown(x),pushdown(y);
			int mid=(l+r)>>1;
			rson[x]=merge(rson[x],rson[y],mid+1,r);
			lson[x]=merge(lson[x],lson[y],l,mid);
			return pushup(x),x;
		}
		int query(int i,int l,int r,int L,int R)
		{
			if(!i) return 0;
			if(l<=L&&R<=r) return mix[i];
			pushdown(i);
			int mid=(L+R)>>1,res=0;
			if(l<=mid) cmin(res,query(lson[i],l,r,L,mid));
			if(r>mid)  cmin(res,query(rson[i],l,r,mid+1,R));
			return res;
		}
	}
	using namespace SegmentTreeMerge;
	
	namespace TPSort
	{
		queue<int> q;
		vector<int> lp[MAX];
		int deg[MAX],id[MAX],con;
		inline void tpsort()
		{
			for(int i=1;i<=n;++i) if(!deg[i]) q.emplace(i);
	    	while(!q.empty())
	    	{
	    		int now=q.front(); q.pop();
	    		if(!--deg[a[now]]) q.emplace(a[now]);
			}
			
			auto mark=[&](auto mark,int now)->void
			{
				id[now]=con,lp[con].eb(now);
				if(!id[a[now]]) mark(mark,a[now]);
			};
			for(int i=1;i<=n;++i) if(deg[i]&&!id[i]) ++con,mark(mark,i);
		}
	}
	using namespace TPSort;
	
    inline void lmy_forever()
    {
    	read(n);
    	for(int i=1;i<=n;++i) read(a[i],h[i],c[i]),d[i]=h[i],G[a[i]].eb(i),++deg[a[i]],ans+=c[i];
    	sort(d+1,d+n+1),cnt=unique(d+1,d+n+1)-d-1;
    	for(int i=1;i<=n;++i) h[i]=lower_bound(d+1,d+cnt+1,h[i])-d;
    	tpsort();

		auto dfs=[&](auto dfs,int now)->void
		{
			change(root[now],cnt,1,cnt,0);
			for(auto to:G[now]) dfs(dfs,to),dl=dr=0,root[now]=merge(root[now],root[to],1,cnt);
			change(root[now],h[now],1,cnt,query(root[now],h[now],cnt,1,cnt)-c[now]);
		};
		for(int i=1;i<=n;++i) if(!deg[i]&&deg[a[i]]) dfs(dfs,i),dl=dr=0,loot[id[a[i]]]=merge(loot[id[a[i]]],root[i],1,cnt);
		
		for(int i=1;i<=con;++i)
		{
			sort(lp[i].begin(),lp[i].end(),[&](int x,int y){return h[x]==h[y]?c[x]<c[y]:h[x]<h[y];});
			int Mix=mix[loot[i]],sum=-c[lp[i][0]],val=h[lp[i][0]];
			for(int j=1;j<((int)lp[i].size());++j) if(val==h[lp[i][j]]) sum-=c[lp[i][j]]; else cmin(Mix,query(loot[i],val,cnt,1,cnt)+sum),sum=-c[lp[i][j]],val=h[lp[i][j]];
			cmin(Mix,query(loot[i],val,cnt,1,cnt)+sum),ans+=Mix;
		}
		write(ans,'\n');
	}
}

bool Med;

signed main()
{
//  file();
    fprintf(stderr,"%.3lf MB\n",abs(&Med-&Mbe)/1048576.0);
    int Tbe=clock();
    LgxTpre::lmy_forever();
    int Ted=clock();
    cerr<<1e3*(Ted-Tbe)/CLOCKS_PER_SEC<<" ms\n";
    return (0-0);
}